..

.gitlab-ci.yml

@@ -1,114 +1,76 @@
 stages:
   - deploy
 
-# -----------------------------------------
-# Globale Variablen
-# -----------------------------------------
-variables:
-  BASE_DIRS: "src public api partials tools"
-  CONFIG_BASE_DIR: "config"
-
-# Standard-Image für alle Jobs
-default:
-  image: usbcheck/ci-usbcheck-deploy:latest
-
 # -----------------------------------------
 # Deployment auf STAGING
 # -----------------------------------------
 deploy:staging:
   stage: deploy
-
-  variables:
-    TARGET_PATH: "${FTP_PATH_STAGING}"
-    CONFIG_ENV_DIR: "config/staging"
+  image: alpine:3.20
 
   before_script:
+    - echo "📡 Installing lftp..."
+    - apk add --no-cache lftp
+
     - echo "📂 CI Workspace:"
     - pwd
     - ls -la
-    - echo "📁 Prüfe & zeige Projektverzeichnisse:"
-    - |
-      for d in $BASE_DIRS $CONFIG_BASE_DIR $CONFIG_ENV_DIR; do
-        echo "----------------------------------------"
-        if [ -d "$d" ]; then
-          echo "📂 Inhalt von $d/:"
-          ls -la "$d/"
-        else
-          echo "⚠️ Verzeichnis '$d' existiert nicht!"
-        fi
-      done
+
+    - echo "📂 Inhalt von src/:"
+    - ls -la src/ || echo "⚠️ src/ existiert nicht!"
+    - echo "📂 Inhalt von public/:"
+    - ls -la public/ || echo "⚠️ public/ existiert nicht!"
+    - echo "📂 Inhalt von config/:"
+    - ls -la config/ || echo "⚠️ config/ existiert nicht!"
+    - echo "📂 Inhalt von config/staging/:"
+    - ls -la config/staging/ || echo "⚠️ config/staging/ existiert nicht!"
 
   script:
     - |
-      echo "📁 Prüfe lokale Basisverzeichnisse..."
-      MISSING=0
+      set -e
 
-      for d in $BASE_DIRS; do
+      # Sicherstellen, dass Basisverzeichnisse existieren
+      for d in src public config config/staging; do
         if [ ! -d "$d" ]; then
-          echo "❌ Verzeichnis '$d/' fehlt im Repo!"
-          MISSING=1
-        fi
-      done
-
-      if [ ! -d "$CONFIG_BASE_DIR" ]; then
-        echo "❌ Basis-Konfig-Verzeichnis '$CONFIG_BASE_DIR/' fehlt!"
-        MISSING=1
-      fi
-
-      if [ ! -d "$CONFIG_ENV_DIR" ]; then
-        echo "❌ Env-Konfiguration '$CONFIG_ENV_DIR/' fehlt!"
-        MISSING=1
-      fi
-
-      if [ "$MISSING" -ne 0 ]; then
-        echo "⛔ Abbruch wegen fehlender Verzeichnisse."
+          echo "❌ Verzeichnis '$d/' fehlt im Repo! Abbruch."
           exit 1
         fi
+      done
 
-      echo "🚀 Deploy ${CI_ENVIRONMENT_NAME} → ${FTP_HOST}:${TARGET_PATH}"
+      echo "🚀 Deploy STAGING → ${FTP_HOST}:${FTP_PATH_STAGING}"
 
-      for d in $BASE_DIRS; do
-        echo "🔁 Sync ${d}/ → ${TARGET_PATH}${d}/"
+      echo "🔁 Sync src/ → ${FTP_PATH_STAGING}src/"
       lftp -u "${FTP_USER}","${FTP_PASSWORD}" "${FTP_HOST}" -e "
         set ftp:ssl-force true;
         set ftp:passive-mode true;
         set ftp:ssl-protect-data true;
         set ssl:verify-certificate no;
-          mirror -R --delete --exclude .gitkeep ${d}/ ${TARGET_PATH}${d}/;
+        mirror -R --delete --exclude .gitkeep src/ ${FTP_PATH_STAGING}src/;
         bye
-        " || { echo "❌ Upload für Verzeichnis '${d}' fehlgeschlagen."; exit 1; }
-      done
+      "
 
-      echo "🧩 Baue gemischtes Config-Verzeichnis (config/*.php + ${CONFIG_ENV_DIR})..."
-      rm -rf .ci_config_deploy
-      mkdir -p .ci_config_deploy
-
-      if [ -d "${CONFIG_BASE_DIR}" ]; then
-        for f in ${CONFIG_BASE_DIR}/*.php; do
-          if [ -f "$f" ]; then
-            echo "➕ Basis-Config-Datei: $f"
-            cp "$f" .ci_config_deploy/
-          fi
-        done
-      fi
-
-      if [ -d "${CONFIG_ENV_DIR}" ]; then
-        echo "➕ Env-Config aus ${CONFIG_ENV_DIR}/"
-        cp -R ${CONFIG_ENV_DIR}/. .ci_config_deploy/
-      fi
-
-      echo "🔁 Sync .ci_config_deploy/ → ${TARGET_PATH}${CONFIG_BASE_DIR}/"
+      echo "🔁 Sync public/ → ${FTP_PATH_STAGING}public/"
       lftp -u "${FTP_USER}","${FTP_PASSWORD}" "${FTP_HOST}" -e "
         set ftp:ssl-force true;
         set ftp:passive-mode true;
         set ftp:ssl-protect-data true;
         set ssl:verify-certificate no;
-        lcd .ci_config_deploy;
-        mirror -R --delete --exclude .gitkeep ./ ${TARGET_PATH}${CONFIG_BASE_DIR}/;
+        mirror -R --delete --exclude .gitkeep public/ ${FTP_PATH_STAGING}public/;
         bye
-      " || { echo "❌ Upload für gemischtes Config-Verzeichnis fehlgeschlagen."; exit 1; }
+      "
 
-      echo "✅ Deploy ${CI_ENVIRONMENT_NAME} abgeschlossen."
+      echo "🔁 Sync config/staging/ (nur Inhalt) → ${FTP_PATH_STAGING}config/"
+      lftp -u "${FTP_USER}","${FTP_PASSWORD}" "${FTP_HOST}" -e "
+        set ftp:ssl-force true;
+        set ftp:passive-mode true;
+        set ftp:ssl-protect-data true;
+        set ssl:verify-certificate no;
+        lcd config/staging;
+        mirror -R --delete --exclude .gitkeep ./ ${FTP_PATH_STAGING}config/;
+        bye
+      "
+
+      echo "✅ Deploy STAGING abgeschlossen."
 
   environment:
     name: staging
@@ -124,98 +86,71 @@ deploy:staging:
 # -----------------------------------------
 deploy:production:
   stage: deploy
-
-  variables:
-    TARGET_PATH: "${FTP_PATH_PROD}"
-    CONFIG_ENV_DIR: "config/prod"
+  image: alpine:3.20
 
   before_script:
+    - echo "📡 Installing lftp..."
+    - apk add --no-cache lftp
+
     - echo "📂 CI Workspace:"
     - pwd
     - ls -la
-    - echo "📁 Prüfe & zeige Projektverzeichnisse:"
-    - |
-      for d in $BASE_DIRS $CONFIG_BASE_DIR $CONFIG_ENV_DIR; do
-        echo "----------------------------------------"
-        if [ -d "$d" ]; then
-          echo "📂 Inhalt von $d/:"
-          ls -la "$d/"
-        else
-          echo "⚠️ Verzeichnis '$d' existiert nicht!"
-        fi
-      done
+
+    - echo "📂 Inhalt von src/:"
+    - ls -la src/ || echo "⚠️ src/ existiert nicht!"
+    - echo "📂 Inhalt von public/:"
+    - ls -la public/ || echo "⚠️ public/ existiert nicht!"
+    - echo "📂 Inhalt von config/:"
+    - ls -la config/ || echo "⚠️ config/ existiert nicht!"
+    - echo "📂 Inhalt von config/prod/:"
+    - ls -la config/prod/ || echo "⚠️ config/prod/ existiert nicht!"
 
   script:
     - |
-      echo "📁 Prüfe lokale Basisverzeichnisse..."
-      MISSING=0
+      set -e
 
-      for d in $BASE_DIRS; do
+      # Sicherstellen, dass Basisverzeichnisse existieren
+      for d in src public config config/prod; do
         if [ ! -d "$d" ]; then
-          echo "❌ Verzeichnis '$d/' fehlt im Repo!"
-          MISSING=1
-        fi
-      done
-
-      if [ ! -d "$CONFIG_BASE_DIR" ]; then
-        echo "❌ Basis-Konfig-Verzeichnis '$CONFIG_BASE_DIR/' fehlt!"
-        MISSING=1
-      fi
-
-      if [ ! -d "$CONFIG_ENV_DIR" ]; then
-        echo "❌ Env-Konfiguration '$CONFIG_ENV_DIR/' fehlt!"
-        MISSING=1
-      fi
-
-      if [ "$MISSING" -ne 0 ]; then
-        echo "⛔ Abbruch wegen fehlender Verzeichnisse."
+          echo "❌ Verzeichnis '$d/' fehlt im Repo! Abbruch."
           exit 1
         fi
+      done
 
-      echo "🚀 Deploy ${CI_ENVIRONMENT_NAME} → ${FTP_HOST}:${TARGET_PATH}"
+      echo "🚀 Deploy PRODUCTION → ${FTP_HOST}:${FTP_PATH_PROD}"
 
-      for d in $BASE_DIRS; do
-        echo "🔁 Sync ${d}/ → ${TARGET_PATH}${d}/"
+      echo "🔁 Sync src/ → ${FTP_PATH_PROD}src/"
       lftp -u "${FTP_USER}","${FTP_PASSWORD}" "${FTP_HOST}" -e "
         set ftp:ssl-force true;
         set ftp:passive-mode true;
         set ftp:ssl-protect-data true;
         set ssl:verify-certificate no;
-          mirror -R --delete --exclude .gitkeep ${d}/ ${TARGET_PATH}${d}/;
+        mirror -R --delete --exclude .gitkeep src/ ${FTP_PATH_PROD}src/;
         bye
-        " || { echo "❌ Upload für Verzeichnis '${d}' fehlgeschlagen."; exit 1; }
-      done
+      "
 
-      echo "🧩 Baue gemischtes Config-Verzeichnis (config/*.php + ${CONFIG_ENV_DIR})..."
-      rm -rf .ci_config_deploy
-      mkdir -p .ci_config_deploy
-
-      if [ -d "${CONFIG_BASE_DIR}" ]; then
-        for f in ${CONFIG_BASE_DIR}/*.php; do
-          if [ -f "$f" ]; then
-            echo "➕ Basis-Config-Datei: $f"
-            cp "$f" .ci_config_deploy/
-          fi
-        done
-      fi
-
-      if [ -d "${CONFIG_ENV_DIR}" ]; then
-        echo "➕ Env-Config aus ${CONFIG_ENV_DIR}/"
-        cp -R ${CONFIG_ENV_DIR}/. .ci_config_deploy/
-      fi
-
-      echo "🔁 Sync .ci_config_deploy/ → ${TARGET_PATH}${CONFIG_BASE_DIR}/"
+      echo "🔁 Sync public/ → ${FTP_PATH_PROD}public/"
       lftp -u "${FTP_USER}","${FTP_PASSWORD}" "${FTP_HOST}" -e "
         set ftp:ssl-force true;
         set ftp:passive-mode true;
         set ftp:ssl-protect-data true;
         set ssl:verify-certificate no;
-        lcd .ci_config_deploy;
-        mirror -R --delete --exclude .gitkeep ./ ${TARGET_PATH}${CONFIG_BASE_DIR}/;
+        mirror -R --delete --exclude .gitkeep public/ ${FTP_PATH_PROD}public/;
         bye
-      " || { echo "❌ Upload für gemischtes Config-Verzeichnis fehlgeschlagen."; exit 1; }
+      "
 
-      echo "✅ Deploy ${CI_ENVIRONMENT_NAME} abgeschlossen."
+      echo "🔁 Sync config/prod/ (nur Inhalt) → ${FTP_PATH_PROD}config/"
+      lftp -u "${FTP_USER}","${FTP_PASSWORD}" "${FTP_HOST}" -e "
+        set ftp:ssl-force true;
+        set ftp:passive-mode true;
+        set ftp:ssl-protect-data true;
+        set ssl:verify-certificate no;
+        lcd config/prod;
+        mirror -R --delete --exclude .gitkeep ./ ${FTP_PATH_PROD}config/;
+        bye
+      "
+
+      echo "✅ Deploy PRODUCTION abgeschlossen."
 
   environment:
     name: production
@@ -223,4 +158,4 @@ deploy:production:
 
   only:
     - main
-  # when: manual
+#  when: manual

api/.htaccess

@@ -1,28 +0,0 @@
-RewriteEngine On
-
-# --------------------------------------------------------------
-# 1) Direkter Aufruf von PHP-Dateien verhindern und auf index.php routen
-#    Beispiel:
-#    /v1/browser.quick.test.php  ->   /index.php (mit REQUEST_URI erhalten)
-# --------------------------------------------------------------
-RewriteCond %{REQUEST_URI} !/index\.php$
-RewriteRule ^(.+)\.php$ /index.php [QSA,L]
-
-# --------------------------------------------------------------
-# 2) Echte Dateien (JSON, JS, CSS, Bilder etc.) normal ausliefern
-# --------------------------------------------------------------
-RewriteCond %{REQUEST_FILENAME} -f
-RewriteRule ^ - [L]
-
-# --------------------------------------------------------------
-# 3) Echte Verzeichnisse normal ausliefern
-# --------------------------------------------------------------
-RewriteCond %{REQUEST_FILENAME} -d
-RewriteRule ^ - [L]
-
-# --------------------------------------------------------------
-# 4) Alles andere durch index.php routen
-#    Beispiel:
-#    /v1/quickcheck  ->  index.php
-# --------------------------------------------------------------
-RewriteRule ^ /index.php [QSA,L]

api/index.php

@@ -1,117 +0,0 @@
-<?php
-// /api/index.php
-
-declare(strict_types=1);
-
-$apibasedir = $_SERVER['DOCUMENT_ROOT']; 
-require $apibasedir . '/../config/fileload.php';
-
-/*
-|--------------------------------------------------------------------------
-| CORS – Dynamische Freigabe
-|--------------------------------------------------------------------------
-| WICHTIG: credentials:true verbietet Access-Control-Allow-Origin: *
-| Darum erlauben wir nur explizite Frontend-Domains.
-*/
-$allowedOrigins = [
-    'https://staging.usbcheck.it',
-    'https://usbcheck.it',
-    'http://localhost',     // optional für lokale Entwicklung
-];
-
-$origin = $_SERVER['HTTP_ORIGIN'] ?? '';
-
-if (in_array($origin, $allowedOrigins, true)) {
-    // Dynamische Freigabe der erlaubten Domain
-    header("Access-Control-Allow-Origin: {$origin}");
-    header("Vary: Origin");    // wichtig gegen Proxy-Caching-Probleme
-} else {
-    // Fallback: Staging-Domain
-    header("Access-Control-Allow-Origin: https://staging.usbcheck.it");
-    header("Vary: Origin");
-}
-
-// Weitere CORS-Header
-header('Access-Control-Allow-Credentials: true');
-header('Access-Control-Allow-Methods: GET, POST, OPTIONS');
-header('Access-Control-Allow-Headers: Content-Type, Authorization, X-Requested-With');
-
-// JSON Response Header
-header('Content-Type: application/json; charset=utf-8');
-
-// OPTIONS – Preflight-Anfrage vorzeitig beenden
-if ($_SERVER['REQUEST_METHOD'] === 'OPTIONS') {
-    http_response_code(204);
-    exit;
-}
-
-/*
-|--------------------------------------------------------------------------
-| Routing vorbereiten
-|--------------------------------------------------------------------------
-*/
-
-$uri  = parse_url($_SERVER['REQUEST_URI'] ?? '/', PHP_URL_PATH);
-$path = rtrim($uri, '/');
-
-if ($path === '') {
-    $path = '/';
-}
-
-/*
-|--------------------------------------------------------------------------
-| Root-Info (optional)
-|--------------------------------------------------------------------------
-*/
-if ($path === '/') {
-    echo json_encode([
-        'ok'        => true,
-        'service'   => 'usbcheck-api',
-        'version'   => 1,
-        'endpoints' => [
-            '/v1/quickcheck',
-            '/v1/browser.quick.test',
-            '/internal/* (geschützt)',
-        ],
-    ], JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE);
-    exit;
-}
-
-/*
-|--------------------------------------------------------------------------
-| Versioniertes Routing /v1/*
-|--------------------------------------------------------------------------
-*/
-if (str_starts_with($path, '/v1/')) {
-
-    // alles hinter /v1/ in Segmente zerlegen
-    $rel = substr($path, strlen('/v1/'));  // z.B. "browser.quick.test"
-    $rel = ltrim($rel, '/');
-    $segments = $rel === '' ? [] : explode('/', $rel);
-
-    require_once $apibasedir . '/router/router.v1.php';
-    router_v1_dispatch($segments);
-    exit;
-}
-
-/*
-|--------------------------------------------------------------------------
-| Internal API /internal/*
-|--------------------------------------------------------------------------
-*/
-if (str_starts_with($path, '/internal/')) {
-    require_once $apibasedir . '/router/router.internal.php';
-    exit;
-}
-
-/*
-|--------------------------------------------------------------------------
-| Fallback: Unbekannter Bereich
-|--------------------------------------------------------------------------
-*/
-http_response_code(404);
-echo json_encode([
-    'ok'    => false,
-    'error' => 'Unknown API area',
-    'path'  => $path,
-], JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE);

api/router/router.internal.php

@@ -1,97 +0,0 @@
-<?php
-// /api/router.internal.php
-
-declare(strict_types=1);
-
-// *** SICHERHEIT ***
-// → Unbedingt User/Pass ändern oder später auf Token/IP-Restriktion umstellen
-$validUser = 'usbcheck-internal';
-$validPass = 'SwejaFynja050223!';
-
-// Basic-Auth prüfen
-if (
-    !isset($_SERVER['PHP_AUTH_USER'], $_SERVER['PHP_AUTH_PW']) ||
-    $_SERVER['PHP_AUTH_USER'] !== $validUser ||
-    $_SERVER['PHP_AUTH_PW']   !== $validPass
-) {
-    header('WWW-Authenticate: Basic realm="USBCheck Internal API"');
-    http_response_code(401);
-    echo json_encode([
-        'ok'    => false,
-        'error' => 'Authentication required',
-    ]);
-    exit;
-}
-
-// Pfad erneut bestimmen
-$uri  = parse_url($_SERVER['REQUEST_URI'] ?? '/', PHP_URL_PATH);
-$path = rtrim($uri, '/');
-
-// interne Routen
-switch ($path) {
-    // Beispiel: Aggregierte Stats
-    case '/internal/stats.overview':
-        internal_stats_overview($pdo);
-        break;
-
-    // Beispiel: Wartung / Cleanup
-    case '/internal/maintenance.cleanup-tests':
-        internal_cleanup_tests($pdo);
-        break;
-
-    default:
-        http_response_code(404);
-        echo json_encode([
-            'ok'    => false,
-            'error' => 'Unknown internal endpoint',
-            'path'  => $path,
-        ], JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE);
-        break;
-}
-
-/**
- * Beispiel: einfache Übersicht für Admin-Dashboard
- */
-function internal_stats_overview(PDO $pdo): void
-{
-    // alles nur Beispiel – du kannst die Queries anpassen
-    $totalQuicktests = (int)$pdo->query("SELECT COUNT(*) FROM web_quicktests")->fetchColumn();
-
-    $lastTestsStmt = $pdo->query("
-        SELECT id, created_at, ip_address, measured_capacity_bytes
-        FROM web_quicktests
-        ORDER BY created_at DESC
-        LIMIT 10
-    ");
-
-    $lastTests = $lastTestsStmt ? $lastTestsStmt->fetchAll(PDO::FETCH_ASSOC) : [];
-
-    echo json_encode([
-        'ok'    => true,
-        'stats' => [
-            'total_quicktests' => $totalQuicktests,
-            'last_quicktests'  => $lastTests,
-        ],
-    ], JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE);
-}
-
-/**
- * Beispiel: alte Tests aufräumen (z.B. älter als 90 Tage)
- */
-function internal_cleanup_tests(PDO $pdo): void
-{
-    // je nach Schema musst du Feldnamen anpassen – hier: created_at
-    $stmt = $pdo->prepare("
-        DELETE FROM web_quicktests
-        WHERE created_at < (NOW() - INTERVAL 90 DAY)
-    ");
-
-    $stmt->execute();
-    $deleted = $stmt->rowCount();
-
-    echo json_encode([
-        'ok'      => true,
-        'deleted' => $deleted,
-        'note'    => 'Tests älter als 90 Tage wurden entfernt (Beispiel-Implementierung).',
-    ], JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE);
-}

api/router/router.v1.php

@@ -1,109 +0,0 @@
-<?php
-// /api/router/router.v1.php
-
-declare(strict_types=1);
-
-/**
- * Router für /v1/...
- *
- * Wird von /api/index.php so aufgerufen:
- *   router_v1_dispatch($segments)
- *
- * $segments[0] ist dann z.B. "browser.quick.test" oder "quickcheck"
- */
-
-// Basisverzeichnis der API ermitteln (…/api)
-$apibasedir = dirname(__DIR__);
-
-function router_v1_dispatch(array $segments): void
-{
-    global $apibasedir;
-
-    if (empty($segments[0])) {
-        http_response_code(404);
-        echo json_encode([
-            'ok'    => false,
-            'error' => 'No endpoint specified for v1',
-        ], JSON_UNESCAPED_UNICODE);
-        return;
-    }
-
-    $endpoint = $segments[0]; // z.B. "browser.quick.test" oder "quickcheck"
-
-    switch ($endpoint) {
-        case 'quickcheck':
-            $file    = $apibasedir . '/v1/target/quickcheck.php';
-            $handler = 'quickcheck_handle_request';
-            break;
-
-        case 'browser.quick.test':
-            $file    = $apibasedir . '/v1/result/browser.quick.test.php';
-            $handler = 'browser_quick_test_handle_request';
-            break;
-
-        default:
-            http_response_code(404);
-            echo json_encode([
-                'ok'       => false,
-                'error'    => 'Unknown v1 endpoint',
-                'endpoint' => $endpoint,
-            ], JSON_UNESCAPED_UNICODE);
-            return;
-    }
-
-    if (!file_exists($file)) {
-        http_response_code(500);
-        echo json_encode([
-            'ok'    => false,
-            'error' => 'Endpoint file not found',
-            'file'  => $file,
-        ], JSON_UNESCAPED_UNICODE);
-        return;
-    }
-
-    require_once $file;
-
-    if (!function_exists($handler)) {
-        http_response_code(500);
-        echo json_encode([
-            'ok'      => false,
-            'error'   => 'Handler not found',
-            'handler' => $handler,
-        ], JSON_UNESCAPED_UNICODE);
-        return;
-    }
-
-    try {
-        $result = $handler();
-
-        if (!is_array($result)) {
-            $result = [
-                'ok'      => false,
-                'error'   => 'Handler did not return array',
-                'raw'     => $result,
-                'handler' => $handler,
-            ];
-        }
-
-        if (isset($result['ok']) && $result['ok'] === false) {
-            if (!http_response_code()) {
-                http_response_code(400);
-            }
-        } else {
-            if (!http_response_code()) {
-                http_response_code(200);
-            }
-        }
-
-        echo json_encode($result, JSON_UNESCAPED_UNICODE);
-    } catch (Throwable $e) {
-        http_response_code(500);
-        error_log('[usbcheck] router_v1_dispatch error: ' . $e->getMessage());
-
-        echo json_encode([
-            'ok'    => false,
-            'error' => 'Unhandled exception in endpoint',
-            'debug' => $e->getMessage(), // später ggf. entfernen
-        ], JSON_UNESCAPED_UNICODE);
-    }
-}

api/v1/result/browser.quick.test.php

@@ -1,213 +0,0 @@
-<?php
-// /api/v1/result/browser.quick.test.php
-
-declare(strict_types=1);
-
-/**
- * Handler für:  /v1/browser.quick.test
- *
- * WICHTIG:
- * - Keine direkten header()/echo-Ausgaben hier.
- * - Der Router (router.v1.php) ruft diese Funktion auf und encodiert das Ergebnis als JSON.
- *
- * Erwartung des Routers:
- *   function browser_quick_test_handle_request(): array
- */
-function browser_quick_test_handle_request(): array
-{
-    // Session & DB
-    if (session_status() !== PHP_SESSION_ACTIVE) {
-        session_start();
-    }
-
-    // ---------------------------------------------------------------------
-    // 1. JSON einlesen
-    // ---------------------------------------------------------------------
-    $raw  = file_get_contents('php://input');
-    $data = json_decode($raw, true);
-
-    if (!is_array($data)) {
-        // Kein gültiges JSON → wir geben nur das Ergebnis zurück,
-        // HTTP-Status-Code kann der Router setzen, wenn er mag.
-        return [
-            'ok'    => false,
-            'error' => 'Invalid JSON payload',
-        ];
-    }
-
-    // ---------------------------------------------------------------------
-    // 2. User / Session ermitteln – angepasst an dein Login
-    // ---------------------------------------------------------------------
-    $userId     = null;
-    $isLoggedIn = 0;
-
-    // **Primär**: so wird der User in src/auth/login.php gesetzt:
-    // $_SESSION['user'] = ['id' => ..., ...]
-    if (
-        isset($_SESSION['user']) &&
-        is_array($_SESSION['user']) &&
-        !empty($_SESSION['user']['id'])
-    ) {
-        $userId = (int)$_SESSION['user']['id'];
-    }
-    // Fallback A: klassisch
-    elseif (!empty($_SESSION['user_id'])) {
-        $userId = (int)$_SESSION['user_id'];
-    }
-    // Fallback B: auth-Block (z.B. $_SESSION['auth']['user_id'])
-    elseif (
-        isset($_SESSION['auth']) &&
-        is_array($_SESSION['auth']) &&
-        !empty($_SESSION['auth']['user_id'])
-    ) {
-        $userId = (int)$_SESSION['auth']['user_id'];
-    }
-
-    if ($userId) {
-        $isLoggedIn = 1;
-    }
-
-    $sessionId = session_id() ?: null;
-
-    $ipAddress  = $_SERVER['REMOTE_ADDR']     ?? null;
-    $userAgent  = $_SERVER['HTTP_USER_AGENT'] ?? null;
-
-    // ---------------------------------------------------------------------
-    // 3. Grobe Auswertung aus dem Report (optional)
-    // ---------------------------------------------------------------------
-    $modeRequested = $data['mode_requested'] ?? 'unknown';
-    $meta          = $data['meta'] ?? [];
-
-    // Hier könntest du später Browser/OS parsen
-    $browserName    = null;
-    $browserVersion = null;
-    $osName         = null;
-    $osVersion      = null;
-
-    // Beispiel: Gesamtmenge geschriebener/verifizierter Bytes aggregieren
-    $measuredBytes = 0;
-
-    if (!empty($data['quick']) && is_array($data['quick'])) {
-        $measuredBytes += (int)($data['quick']['size_bytes'] ?? 0);
-    }
-    if (!empty($data['benchmark']) && is_array($data['benchmark'])) {
-        $measuredBytes += (int)($data['benchmark']['size_bytes'] ?? 0);
-    }
-    if (!empty($data['writeverify']) && is_array($data['writeverify'])) {
-        $measuredBytes += (int)($data['writeverify']['total_bytes'] ?? 0);
-    }
-
-    // Kapazitätsstatus vorerst neutral
-    $capacityStatus = 'unknown';
-
-    // Volume-/Stick-Daten hast du aktuell im Browser noch nicht separat,
-    // darum bleiben diese Felder (erstmal) NULL:
-    $volumeLabel   = null;
-    $manufacturer  = null;
-    $modelName     = null;
-    $usbType       = null;
-    $filesystem    = null;
-
-    // advertised_capacity_bytes kennen wir im Browser noch nicht:
-    $advCapacityBytes = null;
-
-    // test_report_json = kompletter Report (roher JSON-String)
-    $testReportJson = $raw ?: json_encode($data, JSON_UNESCAPED_UNICODE);
-
-    // ---------------------------------------------------------------------
-    // 4. Insert in web_quicktests
-    // ---------------------------------------------------------------------
-    /** @var PDO $pdo */
-    global $pdo;
-
-    try {
-        $sql = "
-            INSERT INTO web_quicktests (
-                user_id,
-                is_logged_in,
-                usb_device_id,
-                browser_name,
-                browser_version,
-                os_name,
-                os_version,
-                volume_label,
-                manufacturer,
-                model_name,
-                usb_type,
-                advertised_capacity_bytes,
-                measured_capacity_bytes,
-                capacity_status,
-                filesystem,
-                test_report_json,
-                ip_address,
-                session_id
-            )
-            VALUES (
-                :user_id,
-                :is_logged_in,
-                :usb_device_id,
-                :browser_name,
-                :browser_version,
-                :os_name,
-                :os_version,
-                :volume_label,
-                :manufacturer,
-                :model_name,
-                :usb_type,
-                :advertised_capacity_bytes,
-                :measured_capacity_bytes,
-                :capacity_status,
-                :filesystem,
-                :test_report_json,
-                :ip_address,
-                :session_id
-            )
-        ";
-
-        $stmt = $pdo->prepare($sql);
-
-        $stmt->execute([
-            'user_id'                   => $userId,
-            'is_logged_in'              => $isLoggedIn,
-            'usb_device_id'             => null,
-            'browser_name'              => $browserName,
-            'browser_version'           => $browserVersion,
-            'os_name'                   => $osName,
-            'os_version'                => $osVersion,
-            'volume_label'              => $volumeLabel,
-            'manufacturer'              => $manufacturer,
-            'model_name'                => $modelName,
-            'usb_type'                  => $usbType,
-            'advertised_capacity_bytes' => $advCapacityBytes,
-            'measured_capacity_bytes'   => $measuredBytes ?: null,
-            'capacity_status'           => $capacityStatus,
-            'filesystem'                => $filesystem,
-            'test_report_json'          => $testReportJson,
-            'ip_address'                => $ipAddress,
-            'session_id'                => $sessionId,
-        ]);
-
-        $id = (int)$pdo->lastInsertId();
-
-        // Optionales Debug-Logging, falls trotz Login kein user_id ankam
-        if ($isLoggedIn === 0 && !empty($_SESSION['user'])) {
-            error_log('[usbcheck] browser.quick.test: SESSION[user] vorhanden, aber user_id blieb leer: ' . json_encode($_SESSION['user']));
-        }
-
-        return [
-            'ok'             => true,
-            'id'             => $id,
-            'mode'           => $modeRequested,
-            'measured_bytes' => $measuredBytes ?: null,
-        ];
-    } catch (Throwable $e) {
-        // Fehler ins Error-Log schreiben (nur Server-seitig sichtbar)
-        error_log('[usbcheck] web_quicktests insert failed: ' . $e->getMessage());
-
-        return [
-            'ok'    => false,
-            'error' => 'DB error',
-            'debug' => $e->getMessage(), // zum Debuggen – ggf. später entfernen
-        ];
-    }
-}

api/v1/target/quickcheck.php

@@ -1,316 +0,0 @@
-<?php
-// api/v1/quickcheck.php
-
-/**
- * Diese Funktion wird von api/index.php aufgerufen.
- * Sie liest die Eingaben, prüft Seriennummer + VID, und gibt ein Array zurück,
- * das dann als JSON ausgegeben wird.
- */
-function quickcheck_handle_request(): array
-{
-    // JSON Body hat Priorität
-    $source = quickcheck_get_input();
-
-    $vid          = isset($source['vid']) ? trim((string)$source['vid']) : '';
-    $pid          = isset($source['pid']) ? trim((string)$source['pid']) : '';
-    $manufacturer = isset($source['manufacturer']) ? trim((string)$source['manufacturer']) : '';
-    $serial       = isset($source['serial']) ? trim((string)$source['serial']) : '';
-
-    if ($serial === '') {
-        http_response_code(400);
-        return [
-            'success' => false,
-            'error'   => 'Missing required parameter: serial',
-        ];
-    }
-
-    // Mini-VID-Datenbank (kannst du später aus Datei/DB laden)
-    $VID_DB = [
-        '0781' => 'SanDisk Corp.',
-        '0951' => 'Kingston Technology',
-        '054C' => 'Sony Corp.',
-        '1B1C' => 'Corsair',
-        '13FE' => 'Phison Electronics',
-        '8564' => 'Transcend Information, Inc.',
-        '090C' => 'Silicon Motion, Inc.',
-        '174C' => 'ASMedia Technology',
-        '0BC2' => 'Seagate',
-        // ... nach Bedarf ergänzen
-    ];
-
-    $vendorInfo      = quickcheck_lookup_vendor($vid, $VID_DB);
-    $serialAnalysis  = quickcheck_analyze_serial($serial);
-    $consistencyInfo = quickcheck_evaluate_consistency($vendorInfo['vendor'] ?? null, $manufacturer, $serialAnalysis);
-
-    // Gesamtrating
-    $rating = 'ok';
-    if ($serialAnalysis['category'] === 'invalid') {
-        $rating = 'invalid';
-    } elseif ($serialAnalysis['category'] === 'very_suspicious' || $consistencyInfo['manufacturer_match'] === 'mismatch') {
-        $rating = 'suspicious';
-    } elseif ($serialAnalysis['category'] === 'suspicious') {
-        $rating = 'needs_review';
-    }
-
-    return [
-        'success' => true,
-        'rating'  => $rating,
-        'input'   => [
-            'vid'          => $vid,
-            'pid'          => $pid,
-            'manufacturer' => $manufacturer,
-            'serial'       => $serial,
-        ],
-        'vendor_detected' => $vendorInfo,
-        'serial_analysis' => $serialAnalysis,
-        'consistency'     => $consistencyInfo,
-        'messages'        => [
-            'de' => [
-                'Hinweis: Diese Prüfung kann keine Echtheit garantieren, sondern bewertet nur Plausibilität und Auffälligkeiten.',
-            ],
-        ],
-    ];
-}
-
-/**
- * Eingaben lesen: JSON-Body > POST > GET
- */
-function quickcheck_get_input(): array
-{
-    $contentType = $_SERVER['CONTENT_TYPE'] ?? $_SERVER['HTTP_CONTENT_TYPE'] ?? '';
-    $contentType = strtolower(trim(explode(';', $contentType)[0]));
-
-    if ($contentType === 'application/json') {
-        $raw = file_get_contents('php://input');
-        if ($raw !== false && $raw !== '') {
-            $data = json_decode($raw, true);
-            if (json_last_error() === JSON_ERROR_NONE && is_array($data)) {
-                return $data;
-            }
-        }
-    }
-
-    if (!empty($_POST)) {
-        return $_POST;
-    }
-    if (!empty($_GET)) {
-        return $_GET;
-    }
-
-    return [];
-}
-
-/**
- * VID normalisieren + Lookup
- */
-function quickcheck_normalize_vid(string $vid): ?string
-{
-    $vid = strtoupper(trim($vid));
-    $vid = preg_replace('/^0X/i', '', $vid);
-    if ($vid === '' || !preg_match('/^[0-9A-F]{1,4}$/', $vid)) {
-        return null;
-    }
-    return str_pad($vid, 4, '0', STR_PAD_LEFT);
-}
-
-function quickcheck_lookup_vendor(?string $vid, array $VID_DB): array
-{
-    if (!$vid) {
-        return [
-            'vid'        => null,
-            'found'      => false,
-            'vendor'     => null,
-            'confidence' => 0,
-        ];
-    }
-
-    $norm = quickcheck_normalize_vid($vid);
-    if (!$norm) {
-        return [
-            'vid'        => $vid,
-            'found'      => false,
-            'vendor'     => null,
-            'confidence' => 0,
-            'issue'      => 'Invalid VID format',
-        ];
-    }
-
-    if (isset($VID_DB[$norm])) {
-        return [
-            'vid'        => $norm,
-            'found'      => true,
-            'vendor'     => $VID_DB[$norm],
-            'confidence' => 1.0,
-        ];
-    }
-
-    return [
-        'vid'        => $norm,
-        'found'      => false,
-        'vendor'     => null,
-        'confidence' => 0.2,
-    ];
-}
-
-/**
- * Seriennummer grob analysieren (Plausibilität)
- */
-function quickcheck_analyze_serial(string $serial): array
-{
-    $serial = trim($serial);
-    $length = strlen($serial);
-    $issues = [];
-    $score  = 100;
-
-    if ($length === 0) {
-        return [
-            'serial'   => $serial,
-            'length'   => 0,
-            'issues'   => ['empty'],
-            'score'    => 0,
-            'category' => 'invalid',
-        ];
-    }
-
-    if ($length < 4) {
-        $issues[] = 'too_short_critical';
-        $score -= 60;
-    } elseif ($length < 8) {
-        $issues[] = 'short_suspicious';
-        $score -= 30;
-    }
-
-    if ($length > 32) {
-        $issues[] = 'very_long';
-        $score -= 10;
-    }
-
-    if (quickcheck_is_all_same_char($serial)) {
-        $issues[] = 'all_same_char';
-        $score -= 50;
-    }
-
-    $simplePatterns = [
-        '000000', '00000000', '000000000000',
-        '111111', '123456', '12345678', 'ABCDEF', 'AABBCC'
-    ];
-    if (in_array(strtoupper($serial), $simplePatterns, true)) {
-        $issues[] = 'simple_pattern';
-        $score -= 40;
-    }
-
-    if (quickcheck_is_simple_sequence($serial)) {
-        $issues[] = 'sequence_pattern';
-        $score -= 25;
-    }
-
-    $isNumeric = preg_match('/^[0-9]+$/', $serial) === 1;
-    $isAlpha   = preg_match('/^[A-Za-z]+$/', $serial) === 1;
-    $isHex     = preg_match('/^[0-9A-Fa-f]+$/', $serial) === 1;
-    $isAlnum   = preg_match('/^[A-Za-z0-9]+$/', $serial) === 1;
-
-    if ($isNumeric) {
-        $issues[] = 'numeric_only';
-        $score -= 10;
-    } elseif ($isAlpha) {
-        $issues[] = 'letters_only';
-        $score -= 10;
-    }
-
-    if ($isHex && !$isNumeric && $length >= 8 && $length <= 24) {
-        $issues[] = 'hex_pattern_plausible';
-        $score += 5;
-    }
-
-    if ($isAlnum && !$isNumeric && !$isAlpha && $length >= 8) {
-        $issues[] = 'alnum_mixed_plausible';
-        $score += 5;
-    }
-
-    if ($score > 100) $score = 100;
-    if ($score < 0)   $score = 0;
-
-    if ($length === 0) {
-        $category = 'invalid';
-    } elseif ($score >= 80) {
-        $category = 'plausible';
-    } elseif ($score >= 50) {
-        $category = 'suspicious';
-    } else {
-        $category = 'very_suspicious';
-    }
-
-    return [
-        'serial'   => $serial,
-        'length'   => $length,
-        'issues'   => array_values(array_unique($issues)),
-        'score'    => $score,
-        'category' => $category,
-    ];
-}
-
-function quickcheck_is_all_same_char(string $s): bool
-{
-    return strlen($s) > 1 && preg_match('/^(.)\1+$/', $s) === 1;
-}
-
-function quickcheck_is_simple_sequence(string $s): bool
-{
-    $seqs = [
-        '123456', '1234567', '12345678', '234567', '345678',
-        'ABCDEFG', 'ABCDEF', 'ABCDE'
-    ];
-    $ls = strtoupper($s);
-    foreach ($seqs as $pattern) {
-        if (strpos($ls, $ls) !== false && strpos($ls, $pattern) !== false) {
-            return true;
-        }
-    }
-    return false;
-}
-
-/**
- * Herstellerangabe vs. Vendor-Name bewerten
- */
-function quickcheck_evaluate_consistency(?string $vendorName, string $userManufacturer, array $serialAnalysis): array
-{
-    $vendorName       = $vendorName ? trim($vendorName) : '';
-    $userManufacturer = trim($userManufacturer);
-
-    $matchStatus = 'unknown';
-    $notes       = [];
-
-    if ($vendorName !== '' && $userManufacturer !== '') {
-        $v = mb_strtolower($vendorName);
-        $u = mb_strtolower($userManufacturer);
-
-        if (strpos($v, $u) !== false || strpos($u, $v) !== false) {
-            $matchStatus = 'match';
-            $notes[]     = 'Herstellerangabe passt zur ermittelten Vendor-ID.';
-        } else {
-            $matchStatus = 'mismatch';
-            $notes[]     = 'Herstellerangabe weicht von der Vendor-ID ab.';
-        }
-    } elseif ($vendorName !== '') {
-        $notes[] = 'Hersteller über Vendor-ID bekannt, aber keine Herstellerangabe des Nutzers.';
-    } elseif ($userManufacturer !== '') {
-        $notes[] = 'Hersteller vom Nutzer angegeben, aber keine oder unbekannte Vendor-ID.';
-    } else {
-        $notes[] = 'Keine Herstellerinformationen vorhanden.';
-    }
-
-    $ratingHint = 'neutral';
-    if ($serialAnalysis['category'] === 'very_suspicious' || $matchStatus === 'mismatch') {
-        $ratingHint = 'suspicious';
-    } elseif ($serialAnalysis['category'] === 'plausible' && $matchStatus === 'match') {
-        $ratingHint = 'good';
-    }
-
-    return [
-        'manufacturer_match' => $matchStatus,
-        'notes'              => $notes,
-        'consistency_hint'   => $ratingHint,
-    ];
-}
-
-

config/fileload.php

@@ -1,58 +0,0 @@
-<?php
-
-// 0) Umgebung / Domains / Error-Level
-require_once __DIR__ . "/config.php";
-
-// ----------------------------------------------------------
-// Session starten (gemeinsam für Frontend + API Subdomains)
-// -----------------------------------------------------------
-if (php_sapi_name() !== 'cli') {
-    if (session_status() === PHP_SESSION_NONE) {
-
-        // Einheitlicher Name für alle Teilbereiche
-        session_name('usbcheck_session');
-
-        $isHttps = (!empty($_SERVER['HTTPS']) && $_SERVER['HTTPS'] !== 'off');
-
-        // Cookie-Domain so wählen, dass ALLE Subdomains von usbcheck.it
-        // dieselbe Session sehen (staging., api.staging., www., …)
-        $cookieDomain = '';
-        if (!empty($_SERVER['HTTP_HOST'])) {
-            $host = $_SERVER['HTTP_HOST'];
-
-            // alles was auf "usbcheck.it" endet, bekommt die gemeinsame Domain
-            if (substr($host, -strlen('usbcheck.it')) === 'usbcheck.it') {
-                // wirkt für usbcheck.it, staging.usbcheck.it, api.staging.usbcheck.it, ...
-                $cookieDomain = '.usbcheck.it';
-            }
-        }
-
-        session_set_cookie_params([
-            'lifetime' => 0,
-            'path'     => '/',
-            // WICHTIG: hier die Domain, damit API + Frontend teilen
-            'domain'   => $cookieDomain ?: '',
-            'secure'   => $isHttps,
-            'httponly' => true,
-            // eTLD+1 ist gleich (usbcheck.it), daher reicht Lax für Same-Site
-            'samesite' => 'Lax',
-        ]);
-
-        session_start();
-    }
-}
-
-require_once __DIR__ . '/i18n.php';  // <— zentrale Sprachlogik
-
-// ab hier kannst du überall $GLOBALS['lang'] und $GLOBALS['availableLangs'] nutzen
-// und für JS:
-$usbConfig = [
-    // ... dein sonstiges Zeug ...
-    'i18n' => app_i18n_get_frontend_config(),
-];
-
-// -----------------------------------------------------------
-// 7) Rest des Systems laden
-// -----------------------------------------------------------
-require_once __DIR__ . "/db.php";
-require_once __DIR__ . '/../src/functions.php';

config/i18n.php

@@ -1,397 +0,0 @@
-<?php
-// config/i18n.php
-// Zentrale Sprachlogik für das gesamte Projekt
-
-if (session_status() !== PHP_SESSION_ACTIVE) {
-    @session_start();
-}
-
-/**
- * Liest die meta-Infos einer Sprachdatei.
- * Erwartet Struktur:
- * {
- *   "meta": { "code": "de", "label": "Deutsch", "flag": "🇩🇪", "enabled": true },
- *   ...
- * }
- *
- * Gibt NULL zurück, wenn:
- *  - Datei nicht lesbar
- *  - JSON ungültig
- *  - kein meta vorhanden
- *  - meta.enabled existiert und NICHT true ist
- */
-function app_i18n_load_language_meta_from_file(string $file): ?array
-{
-    $json = @file_get_contents($file);
-    if ($json === false) {
-        return null;
-    }
-
-    $data = json_decode($json, true);
-    if (!is_array($data)) {
-        return null;
-    }
-
-    $meta = $data['meta'] ?? null;
-    if (!is_array($meta)) {
-        return null;
-    }
-
-    // Nur aktive Sprachen (enabled === true)
-    if (array_key_exists('enabled', $meta) && !$meta['enabled']) {
-        return null;
-    }
-
-    // Code aus meta, Fallback: Dateiname
-    $code = '';
-    if (!empty($meta['code'])) {
-        $code = strtolower(substr((string)$meta['code'], 0, 5));
-    } else {
-        $base = basename($file, '.json');
-        $code = strtolower($base);
-    }
-
-    // Auf 2-Buchstaben-Codes normalisieren (de-DE → de)
-    if (strlen($code) > 2) {
-        $code = substr($code, 0, 2);
-    }
-
-    if ($code === '') {
-        return null;
-    }
-
-    $label = isset($meta['label']) && $meta['label'] !== ''
-        ? (string)$meta['label']
-        : strtoupper($code);
-
-    $flag = isset($meta['flag']) ? (string)$meta['flag'] : '';
-
-    return [
-        'code'  => $code,
-        'label' => $label,
-        'flag'  => $flag,
-    ];
-}
-
-/**
- * Alle verfügbaren Sprachen aus /public/assets/i18n/*.json ermitteln.
- * Verfügbar = JSON mit meta.enabled === true.
- * EN wird garantiert hinzugefügt (Fallback), falls nicht gefunden.
- */
-function app_i18n_detect_available_languages(): array
-{
-    $baseDir = realpath(__DIR__ . '/../public/assets/i18n');
-    if ($baseDir === false) {
-        // Wenn gar kein Verzeichnis da ist: minimaler EN-Fallback
-        return [
-            'en' => [
-                'code'  => 'en',
-                'label' => 'English',
-                'flag'  => '',
-            ],
-        ];
-    }
-
-    $files = glob($baseDir . '/*.json') ?: [];
-    $langs = [];
-
-    foreach ($files as $file) {
-        $meta = app_i18n_load_language_meta_from_file($file);
-        if ($meta === null) {
-            continue;
-        }
-
-        $code = $meta['code'];
-
-        // Erste gültige Definition pro Code gewinnt
-        if (!isset($langs[$code])) {
-            $langs[$code] = $meta;
-        }
-    }
-
-    // EN muss immer vorhanden sein (laut deiner Vorgabe)
-    if (!isset($langs['en'])) {
-        // Versuch: gibt es eine en.json, auch wenn enabled=false?
-        foreach ($files as $file) {
-            $base = strtolower(basename($file, '.json'));
-            if ($base === 'en') {
-                $json = @file_get_contents($file);
-                $data = json_decode($json, true);
-                $meta = is_array($data['meta'] ?? null) ? $data['meta'] : [];
-
-                $label = isset($meta['label']) && $meta['label'] !== ''
-                    ? (string)$meta['label']
-                    : 'English';
-                $flag  = isset($meta['flag']) ? (string)$meta['flag'] : '';
-
-                $langs['en'] = [
-                    'code'  => 'en',
-                    'label' => $label,
-                    'flag'  => $flag,
-                ];
-                break;
-            }
-        }
-    }
-
-    // Wenn immer noch kein EN → minimaler Stub
-    if (!isset($langs['en'])) {
-        $langs['en'] = [
-            'code'  => 'en',
-            'label' => 'English',
-            'flag'  => '',
-        ];
-    }
-
-    ksort($langs);
-
-    return $langs;
-}
-
-/**
- * Browsersprache aus HTTP_ACCEPT_LANGUAGE extrahieren (2-Buchstaben),
- * aber nur, wenn sie in $available existiert.
- */
-function app_i18n_detect_browser_lang(array $available): ?string
-{
-    $header = $_SERVER['HTTP_ACCEPT_LANGUAGE'] ?? '';
-    if ($header === '') {
-        return null;
-    }
-
-    $parts = explode(',', $header);
-    foreach ($parts as $part) {
-        $part = trim($part);
-        if ($part === '') {
-            continue;
-        }
-
-        $code = strtolower(substr($part, 0, 2)); // "de-DE" → "de"
-        if (isset($available[$code])) {
-            return $code;
-        }
-    }
-
-    return null;
-}
-
-/**
- * Aktuelle Sprache bestimmen:
- *  1) ?lang=xx (wenn in $available)
- *  2) Browsersprache (wenn in $available)
- *  3) Fallback "en"
- */
-function app_i18n_resolve_current_lang(array $available): string
-{
-    // 1) URL-Parameter ?lang=xx
-    if (!empty($_GET['lang'])) {
-        $param = strtolower(substr($_GET['lang'], 0, 2));
-        if (isset($available[$param])) {
-            return $param;
-        }
-    }
-
-    // 2) Browsersprache
-    $browser = app_i18n_detect_browser_lang($available);
-    if ($browser !== null) {
-        return $browser;
-    }
-
-    // 3) Standard EN
-    if (isset($available['en'])) {
-        return 'en';
-    }
-
-    // Sicherheitsfallback: erste verfügbare Sprache
-    $keys = array_keys($available);
-    return $keys[0] ?? 'en';
-}
-
-// -----------------------------------------------------
-// Bootstrap ausführen
-// -----------------------------------------------------
-
-$availableLangs = app_i18n_detect_available_languages();
-$currentLang    = app_i18n_resolve_current_lang($availableLangs);
-
-// Global bereitstellen
-$GLOBALS['availableLangs'] = $availableLangs;
-$GLOBALS['lang']           = $currentLang;
-
-// Optional in Session merken (muss nicht, schadet aber auch nicht)
-$_SESSION['lang'] = $currentLang;
-
-/**
- * Frontend-Config für JS (usbConfig.i18n)
- * → benutzt direkt die Meta-Daten aus den JSONs (code, label, flag)
- */
-function app_i18n_get_frontend_config(): array
-{
-    return [
-        'current'   => $GLOBALS['lang']           ?? 'en',
-        'available' => $GLOBALS['availableLangs'] ?? [],
-    ];
-}
-
-/**
- * Komplette JSON-Struktur für eine Sprache laden.
- * Nutzt einfachen Request-Cache, damit pro Sprache nur einmal von Platte gelesen wird.
- */
-function app_i18n_load_lang_json(string $lang): array
-{
-    static $cache = [];
-
-    $lang = strtolower(substr($lang, 0, 5));
-
-    if (isset($cache[$lang])) {
-        return $cache[$lang];
-    }
-
-    $baseDir = realpath(__DIR__ . '/../public/assets/i18n');
-    if ($baseDir === false) {
-        $cache[$lang] = [];
-        return $cache[$lang];
-    }
-
-    $path = $baseDir . '/' . $lang . '.json';
-    if (!is_file($path)) {
-        // Fallback: en.json, falls vorhanden
-        $fallback = $baseDir . '/en.json';
-        if (is_file($fallback)) {
-            $json = @file_get_contents($fallback);
-            $data = json_decode($json, true);
-            $cache[$lang] = is_array($data) ? $data : [];
-            return $cache[$lang];
-        }
-
-        $cache[$lang] = [];
-        return $cache[$lang];
-    }
-
-    $json = @file_get_contents($path);
-    $data = json_decode($json, true);
-    $cache[$lang] = is_array($data) ? $data : [];
-
-    return $cache[$lang];
-}
-
-/**
- * Aus einem Label einen stabilen i18n-Key für Nav-Anker bauen.
- * Beispiel: "So funktioniert USBCheck!" -> "nav_so_funktioniert_usbcheck"
- */
-function app_i18n_make_anchor_key(string $label): string
-{
-    // HTML-Entities entfernen (z. B. &amp;)
-    $decoded = html_entity_decode($label, ENT_QUOTES | ENT_HTML5, 'UTF-8');
-
-    // Kleinbuchstaben
-    $decoded = mb_strtolower($decoded, 'UTF-8');
-
-    // Alles, was kein a-z oder 0-9 ist, durch Unterstrich ersetzen
-    $key = preg_replace('/[^a-z0-9]+/u', '_', $decoded);
-
-    // Mehrfache Unterstriche trimmen
-    $key = trim($key, '_');
-
-    if ($key === '') {
-        $key = 'item';
-    }
-
-    // Prefix, damit klar ist, dass es Navigationskeys sind
-    return 'nav_' . $key;
-}
-
-/**
- * Nav-Anker für eine Seite aus der Sprachdatei holen.
- *
- * Haupt-Variante im JSON:
- *
- * "pages": {
- *   "landing": {
- *     "anchors": {
- *       "how":      "So funktioniert USBCheck",
- *       "problem":  "Warum gefälschte USB-Sticks gefährlich sind",
- *       "features": "Funktionen",
- *       "security": "Sicherheit",
- *       "faq":      "FAQ"
- *     }
- *   }
- * }
- *
- * Optional explizit:
- * "anchors": {
- *   "how": { "label": "So funktioniert USBCheck", "i18n": "nav_how" },
- *   "faq": { "i18n": "nav_faq" }
- * }
- *
- * Rückgabe-Format:
- * [
- *   [ 'href' => '#how', 'label' => 'So funktioniert USBCheck', 'i18n' => 'nav_so_funktioniert_usbcheck' ],
- *   [ 'href' => '#faq', 'label' => '', 'i18n' => 'nav_faq' ],
- * ]
- */
-function app_get_nav_anchors(string $pageKey): array
-{
-    $lang = $GLOBALS['lang'] ?? 'en';
-    $data = app_i18n_load_lang_json($lang);
-
-    $cfg = $data['pages'][$pageKey]['anchors'] ?? null;
-    if (!is_array($cfg)) {
-        return [];
-    }
-
-    $anchors = [];
-
-    foreach ($cfg as $id => $value) {
-        $id = trim((string)$id);
-        if ($id === '') {
-            continue;
-        }
-
-        $href  = '#' . $id;
-        $label = '';
-        $i18n  = '';
-
-        if (is_string($value)) {
-            // String IMMER als Label übernehmen
-            $labelTrim = trim($value);
-            if ($labelTrim === '') {
-                continue;
-            }
-
-            $label = $labelTrim;
-            // i18n-Key automatisch aus dem Label ableiten
-            $i18n  = app_i18n_make_anchor_key($labelTrim);
-
-        } elseif (is_array($value)) {
-            // Explizite Variante:
-            // "how": { "label": "...", "i18n": "nav_how" }
-            if (!empty($value['label'])) {
-                $label = trim((string)$value['label']);
-            }
-            if (!empty($value['i18n'])) {
-                $i18n = trim((string)$value['i18n']);
-            }
-
-            if ($label === '' && $i18n === '') {
-                continue;
-            }
-
-            // Wenn Label gesetzt, aber kein i18n: automatisch generieren
-            if ($label !== '' && $i18n === '') {
-                $i18n = app_i18n_make_anchor_key($label);
-            }
-        } else {
-            // Weder String noch Array → ignorieren
-            continue;
-        }
-
-        $anchors[] = [
-            'href'  => $href,
-            'label' => $label,
-            'i18n'  => $i18n,
-        ];
-    }
-
-    return $anchors;
-}

config/prod/config.php

@@ -1,35 +0,0 @@
-<?php
-ini_set('display_errors', 1);
-ini_set('display_startup_errors', 1);
-error_reporting(E_ALL);
-
-if (!defined('ASSET_VERSION')) {
-    define('ASSET_VERSION', '2024-11-22'); // oder deine aktuelle Version
-}
-
-// Domain-Konfiguration (kann pro Umgebung angepasst werden)
-if (!defined('APP_DOMAIN_PRIMARY')) {
-    define('APP_DOMAIN_PRIMARY', 'usbcheck.it');
-}
-if (!defined('APP_URL_PRIMARY')) {
-    define('APP_URL_PRIMARY', 'https://' . APP_DOMAIN_PRIMARY);
-}
-if (!defined('APP_DOMAIN_FAKECHECK')) {
-    define('APP_DOMAIN_FAKECHECK', 'ismyusbfake.com');
-}
-if (!defined('APP_URL_FAKECHECK')) {
-    define('APP_URL_FAKECHECK', 'https://' . APP_DOMAIN_FAKECHECK);
-}
-
-// Matomo Einstellungen
-define('MATOMO_URL', 'https://matomo.my-statistics.info/');
-define('MATOMO_ENABLED', true);
-define('MATOMO_SITE_ID', 7);
-$env  = 'prod';
-$baseUrl   = 'https://usbcheck.it';
-$apiBaseUrl = 'https://api.usbcheck.it';
-
-// Diese Werte später ins Template schieben:
-$GLOBALS['usb_env']       = $env;
-$GLOBALS['usb_base_url']  = $baseUrl;
-$GLOBALS['usb_api_base']  = $apiBaseUrl;

config/prod/db.php

@@ -1,28 +0,0 @@
-<?php
-// config/db.php
-declare(strict_types=1);
-
-$DB_HOST = 'localhost';
-$DB_NAME = 'd0455ede';
-$DB_USER = 'd0455ede';
-$DB_PASS = 'fF8PhxfCibdLBrSxowIo'; // anpassen
-
-$options = [
-    PDO::ATTR_ERRMODE            => PDO::ERRMODE_EXCEPTION,
-    PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
-    PDO::ATTR_EMULATE_PREPARES   => false,
-];
-
-try {
-    $pdo = new PDO(
-        "mysql:host={$DB_HOST};dbname={$DB_NAME};charset=utf8mb4",
-        $DB_USER,
-        $DB_PASS,
-        $options
-    );
-} catch (PDOException $e) {
-    // In Produktion Logging, keine Details ausgeben
-    http_response_code(500);
-    echo 'Database connection error.';
-    exit;
-}

config/staging/config.php

@@ -1,34 +0,0 @@
-<?php
-ini_set('display_errors', 1);
-ini_set('display_startup_errors', 1);
-error_reporting(E_ALL);
-
-if (!defined('ASSET_VERSION')) {
-    define('ASSET_VERSION', time()); // oder deine aktuelle Version
-}
-
-// Domain-Konfiguration (kann pro Umgebung angepasst werden)
-if (!defined('APP_DOMAIN_PRIMARY')) {
-    define('APP_DOMAIN_PRIMARY', 'staging.usbcheck.it');
-}
-if (!defined('APP_URL_PRIMARY')) {
-    define('APP_URL_PRIMARY', 'https://' . APP_DOMAIN_PRIMARY);
-}
-if (!defined('APP_DOMAIN_FAKECHECK')) {
-    define('APP_DOMAIN_FAKECHECK', 'staging.ismyusbfake.com');
-}
-if (!defined('APP_URL_FAKECHECK')) {
-    define('APP_URL_FAKECHECK', 'https://' . APP_DOMAIN_FAKECHECK);
-}
-
-// Matomo Einstellungen
-define('MATOMO_URL', 'https://matomo.my-statistics.info/');
-define('MATOMO_ENABLED', false);
-define('MATOMO_SITE_ID', 8);
-$env  = 'staging';
-$apiBaseUrl = 'https://api.'.APP_DOMAIN_PRIMARY;
-
-// Diese Werte später ins Template schieben:
-$GLOBALS['usb_env']       = $env;
-$GLOBALS['usb_base_url']  = APP_URL_PRIMARY;
-$GLOBALS['usb_api_base']  = $apiBaseUrl;

config/staging/db.php

@@ -1,28 +0,0 @@
-<?php
-// config/db.php
-declare(strict_types=1);
-
-$DB_HOST = 'localhost';
-$DB_NAME = 'd0455edf';
-$DB_USER = 'd0455edf';
-$DB_PASS = 'fF8PhxfCibdLBrSxowIo'; // anpassen
-
-$options = [
-    PDO::ATTR_ERRMODE            => PDO::ERRMODE_EXCEPTION,
-    PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
-    PDO::ATTR_EMULATE_PREPARES   => false,
-];
-
-try {
-    $pdo = new PDO(
-        "mysql:host={$DB_HOST};dbname={$DB_NAME};charset=utf8mb4",
-        $DB_USER,
-        $DB_PASS,
-        $options
-    );
-} catch (PDOException $e) {
-    // In Produktion Logging, keine Details ausgeben
-    http_response_code(500);
-    echo 'Database connection error.';
-    exit;
-}

lastchatgptmessage.txt

@@ -1,6 +0,0 @@
-ich würde es noch flexibler bauen:
-in der tpl-Funktion bauen wir die Pfade fix, aber aufgrund nachfolgender Struktur.
-
-tpl([dateiname],[type = structure, landing],[(optional)site=main, fakecheck)
-
-Weil dann kann ich im Hintergrund die Pfade ändern und muss das nur in der tpl-Funktion anpassen. Die Seiten bleiben wie sie sind.

partials/landing/dashboard/dashboard.php

@@ -1,110 +0,0 @@
-<?php
-// partials/landing/dashboard/dashboard.php
-
-// Annahme: $currentUser kommt über tpl() aus $GLOBALS (siehe functions.php)
-$currentUser = $currentUser ?? ($_SESSION['user'] ?? null);
-
-$firstName = '';
-$plan      = 'free';
-
-if (is_array($currentUser)) {
-    $firstName = trim((string)($currentUser['first_name'] ?? ''));
-    $plan      = (string)($currentUser['plan'] ?? 'free');
-}
-
-$planLabel = [
-    'free'       => 'Free',
-    'pro'        => 'Pro',
-    'enterprise' => 'Enterprise',
-][$plan] ?? ucfirst($plan ?: 'Free');
-?>
-<section id="dashboard" class="section-band section-band--soft border-t border-brand-border/60 py-16 sm:py-20">
-    <div class="px-4 sm:px-6 lg:px-8">
-        <div class="section-shell space-y-10">
-
-        <!-- Begrüßung & Plan -->
-        <div class="flex flex-col md:flex-row md:items-center md:justify-between gap-6">
-            <div class="space-y-2">
-                <p class="text-xs font-heading font-semibold tracking-[0.3em] uppercase text-brand-primary" data-i18n="dashboard_kicker">
-                    Dashboard
-                </p>
-                <h1 class="font-heading text-2xl sm:text-3xl font-bold text-brand-text" data-i18n="dashboard_title">
-                    Willkommen<?= $firstName ? ', ' . htmlspecialchars($firstName) : '' ?>!
-                </h1>
-                <p class="text-sm sm:text-base text-brand-muted max-w-2xl" data-i18n="dashboard_intro">
-                    Hier kannst du deine USB-Tests verwalten, Geräte übersichtlich organisieren und später den Pro-Modus aktivieren. Dieser Bereich ist aktuell noch im Aufbau – du bekommst aber schon einen ersten Überblick.
-                </p>
-            </div>
-
-            <div class="self-start md:self-auto">
-                <div class="inline-flex items-center gap-3 rounded-full border border-brand-border bg-brand-surface/80 px-4 py-2 shadow-soft">
-                    <span class="text-xs font-semibold uppercase tracking-[0.18em] text-brand-muted" data-i18n="dashboard_plan_label">
-                        Aktueller Plan
-                    </span>
-                    <span class="inline-flex items-center rounded-full bg-brand-primary/10 px-3 py-1 text-xs font-semibold text-brand-primary">
-                        <?= htmlspecialchars($planLabel) ?>
-                    </span>
-                </div>
-            </div>
-        </div>
-
-        <!-- Grid: Karten -->
-        <div class="grid gap-6 md:grid-cols-3">
-
-            <!-- Letzte Tests -->
-            <div class="card-frame card-frame--soft flex flex-col">
-                <h2 class="font-heading text-lg font-semibold text-brand-text mb-2" data-i18n="dashboard_card_tests_title">
-                    Letzte Tests
-                </h2>
-                <p class="text-sm text-brand-muted mb-4" data-i18n="dashboard_card_tests_text">
-                    Hier werden später deine letzten Schnelltests und Pro-Scans angezeigt – inklusive Status, Geschwindigkeit und Integritätsprüfung.
-                </p>
-
-                <div class="flex-1 flex items-center justify-center text-xs text-brand-muted/70 border border-dashed border-brand-border/60 rounded-lg py-6">
-                    <span data-i18n="dashboard_card_tests_empty">
-                        Noch keine Testdaten vorhanden. Starte einen ersten Test über den Browser oder den Pro-Modus.
-                    </span>
-                </div>
-            </div>
-
-            <!-- Geräte / USB-Sticks -->
-            <div class="card-frame card-frame--soft flex flex-col">
-                <h2 class="font-heading text-lg font-semibold text-brand-text mb-2" data-i18n="dashboard_card_devices_title">
-                    Deine USB-Geräte
-                </h2>
-                <p class="text-sm text-brand-muted mb-4" data-i18n="dashboard_card_devices_text">
-                    Später kannst du hier deine getesteten Sticks verwalten: Hersteller, Modell, Seriennummer und erkannte Kapazität.
-                </p>
-
-                <div class="flex-1 flex items-center justify-center text-xs text-brand-muted/70 border border-dashed border-brand-border/60 rounded-lg py-6">
-                    <span data-i18n="dashboard_card_devices_empty">
-                        Noch keine Geräte gespeichert. Nach deinen ersten Tests kannst du USB-Sticks hier als Geräte anlegen.
-                    </span>
-                </div>
-            </div>
-
-            <!-- Pro-Modus / Nächste Schritte -->
-            <div class="card-frame flex flex-col">
-                <h2 class="font-heading text-lg font-semibold text-brand-text mb-2" data-i18n="dashboard_card_next_title">
-                    Nächste Schritte
-                </h2>
-                <p class="text-sm text-brand-muted mb-4" data-i18n="dashboard_card_next_text">
-                    USBCheck ist noch im Aufbau. Du gehörst zu den ersten Nutzern – später findest du hier Pro-Optionen, API-Zugänge und Detail-Reports.
-                </p>
-
-                <ul class="text-sm text-brand-muted space-y-1 mb-4">
-                    <li data-i18n="dashboard_card_next_item1">• Browser-FakeCheck testen und Feedback geben</li>
-                    <li data-i18n="dashboard_card_next_item2">• Pro-Modus-Features definieren (z. B. Vollscan, Reports, API)</li>
-                    <li data-i18n="dashboard_card_next_item3">• Accounts &amp; SSO (my-log.in) finalisieren</li>
-                </ul>
-
-                <a href="/fakecheck/?lang=<?= urlencode($lang ?? 'de') ?>"
-                   class="mt-auto inline-flex items-center justify-center rounded-full bg-brand-primary px-4 py-2.5 text-xs font-semibold text-brand-bg hover:bg-blue-400 transition-colors"
-                   data-i18n="dashboard_card_next_cta">
-                    Zum Browser-FakeCheck
-                </a>
-            </div>
-        </div>
-        </div>
-    </div>
-</section>

partials/landing/fakecheck/hero.php

@@ -1,78 +0,0 @@
-<section id="hero" class="hero-section relative overflow-hidden border-b border-brand-border/70">
-    <div class="absolute inset-0 bg-[radial-gradient(circle_at_top,_rgba(8,47,73,0.35),_transparent_60%)] pointer-events-none"></div>
-
-    <div class="relative px-4 sm:px-6 lg:px-8 py-14 sm:py-20">
-        <div class="section-shell hero-shell items-center">
-        <!-- Left: Text -->
-        <div class="hero-copy space-y-6">
-            <p class="text-xs font-heading font-semibold tracking-[0.3em] uppercase text-brand-primary" data-i18n="fake_hero_kicker">
-                FakeCheck – Browser-Modus
-            </p>
-            <h1 class="font-heading text-3xl sm:text-4xl md:text-5xl font-extrabold tracking-tight text-brand-text" data-i18n="fake_hero_title">
-                Ist mein USB-Stick fake?
-            </h1>
-            <p class="text-base sm:text-lg text-brand-muted max-w-xl" data-i18n="fake_hero_lead">
-                Der FakeCheck hilft dir, typische Fake-Sticks aufzuspüren: Browser-basierte Schreib-/Lesetests und Plausibilitätsprüfungen der nutzbaren Kapazität – ohne Installation.
-            </p>
-
-            <div class="flex flex-col sm:flex-row gap-3 sm:gap-4">
-                <button
-                    id="startButton"
-                    class="inline-flex items-center justify-center rounded-full px-5 py-2.5 text-sm font-semibold bg-brand-primary text-brand-bg shadow-soft hover:bg-cyan-400 transition-colors"
-                    data-i18n="fake_cta_start">
-                    Browser-Test starten (Demo)
-                </button>
-
-                <a href="/?lang=<?= htmlspecialchars($lang) ?>"
-                   class="inline-flex items-center justify-center rounded-full px-5 py-2.5 text-sm font-medium border border-brand-border text-brand-muted hover:border-brand-primary hover:text-brand-primary transition-colors"
-                   data-i18n="fake_cta_back_home">
-                    Zur Übersicht zurück
-                </a>
-            </div>
-
-            <p class="text-xs text-brand-muted/80 max-w-md" data-i18n="fake_hero_hint">
-                Der FakeCheck im Browser arbeitet mit Testdateien und Lese-/Schreibmustern, die du in einem ausgewählten Ordner anlegst. Deine echten Dateien bleiben unangetastet.
-            </p>
-        </div>
-
-        <!-- Right: Explainer -->
-        <div class="hero-preview w-full">
-            <div class="card-frame card-frame--soft space-y-4">
-                <h2 class="font-heading text-lg sm:text-xl font-semibold text-brand-text" data-i18n="fake_box_title">
-                    Was der Browser-Test leisten kann
-                </h2>
-                <ul class="space-y-3 text-sm text-brand-muted">
-                    <li class="flex gap-2">
-                        <span class="mt-0.5 h-5 w-5 flex items-center justify-center rounded-full bg-brand-primary/15 text-[11px] font-semibold text-brand-primary">1</span>
-                        <div>
-                            <p class="font-medium text-brand-text" data-i18n="fake_box_point1_title">Schreib-/Lesetest mit Testdateien</p>
-                            <p data-i18n="fake_box_point1_text">
-                                Der Browser legt Testdateien im gewählten Ordner an, misst Schreib- und Leseraten und prüft, ob gelesene Daten mit den geschriebenen Mustern übereinstimmen.
-                            </p>
-                        </div>
-                    </li>
-                    <li class="flex gap-2">
-                        <span class="mt-0.5 h-5 w-5 flex items-center justify-center rounded-full bg-brand-primary/15 text-[11px] font-semibold text-brand-primary">2</span>
-                        <div>
-                            <p class="font-medium text-brand-text" data-i18n="fake_box_point2_title">Plausibilitätscheck der Kapazität</p>
-                            <p data-i18n="fake_box_point2_text">
-                                Aus der Menge der erfolgreich geschriebenen und verifizierten Daten ergibt sich ein realistischer Eindruck, wie viel Nutzkapazität tatsächlich stabil ankommt.
-                            </p>
-                        </div>
-                    </li>
-                    <li class="flex gap-2">
-                        <span class="mt-0.5 h-5 w-5 flex items-center justify-center rounded-full bg-brand-primary/15 text-[11px] font-semibold text-brand-primary">3</span>
-                        <div>
-                            <p class="font-medium text-brand-text" data-i18n="fake_box_point3_title">JSON-Report für deine Dokumentation</p>
-                            <p data-i18n="fake_box_point3_text">
-                                Alle Ergebnisse werden in einem strukturierten JSON-Report gesammelt, den du speichern, hochladen oder für spätere Vergleiche nutzen kannst.
-                            </p>
-                        </div>
-                    </li>
-                </ul>
-            </div>
-        </div>
-        </div>
-    </div>
-    </div>
-</section>

partials/landing/fakecheck/serialcheck.php

@@ -1,92 +0,0 @@
-<section id="serialcheck-root" class="mx-auto max-w-3xl py-8 px-4">
-    <div class="mb-4 text-center">
-        <h2 class="text-2xl font-heading font-bold text-brand-primary mb-2">
-            Seriennummer prüfen (Quickcheck)
-        </h2>
-        <p class="text-sm text-brand-muted">
-            Gib die Seriennummer deines USB-Sticks ein und wir prüfen die Plausibilität
-            sowie die Konsistenz deiner Herstellerangabe zu Vendor-ID (falls vorhanden).
-        </p>
-    </div>
-
-    <div class="bg-white/80 dark:bg-slate-900/70 border border-slate-200/70 dark:border-slate-700 rounded-2xl shadow-sm p-4 mb-4">
-        <form id="serialcheck-form" class="space-y-4">
-            <div>
-                <label for="sc-manufacturer" class="block text-xs font-medium text-slate-700 dark:text-slate-200 mb-1">
-                    Hersteller (laut Aufdruck, optional)
-                </label>
-                <input
-                    type="text"
-                    id="sc-manufacturer"
-                    name="manufacturer"
-                    placeholder="z. B. SanDisk, Kingston..."
-                    class="w-full rounded-lg border border-slate-300 dark:border-slate-700 bg-white dark:bg-slate-800 px-3 py-2 text-xs focus:outline-none focus:ring-2 focus:ring-brand-primary"
-                />
-            </div>
-
-            <div class="grid grid-cols-2 gap-3">
-                <div>
-                    <label for="sc-vid" class="block text-xs font-medium text-slate-700 dark:text-slate-200 mb-1">
-                        Vendor-ID (VID, optional)
-                    </label>
-                    <input
-                        type="text"
-                        id="sc-vid"
-                        name="vid"
-                        placeholder="z. B. 0781"
-                        class="w-full rounded-lg border border-slate-300 dark:border-slate-700 bg-white dark:bg-slate-800 px-3 py-2 text-xs focus:outline-none focus:ring-2 focus:ring-brand-primary"
-                    />
-                    <p class="mt-1 text-[10px] text-slate-500">
-                        Hexadezimal, z. B. 0781 (falls bekannt).
-                    </p>
-                </div>
-                <div>
-                    <label for="sc-pid" class="block text-xs font-medium text-slate-700 dark:text-slate-200 mb-1">
-                        Product-ID (PID, optional)
-                    </label>
-                    <input
-                        type="text"
-                        id="sc-pid"
-                        name="pid"
-                        placeholder="z. B. 5581"
-                        class="w-full rounded-lg border border-slate-300 dark:border-slate-700 bg-white dark:bg-slate-800 px-3 py-2 text-xs focus:outline-none focus:ring-2 focus:ring-brand-primary"
-                    />
-                </div>
-            </div>
-
-            <div>
-                <label for="sc-serial" class="block text-xs font-medium text-slate-700 dark:text-slate-200 mb-1">
-                    Seriennummer (Pflicht)
-                </label>
-                <input
-                    type="text"
-                    id="sc-serial"
-                    name="serial"
-                    required
-                    placeholder="Seriennummer genau so eingeben wie angezeigt"
-                    class="w-full rounded-lg border border-slate-300 dark:border-slate-700 bg-white dark:bg-slate-800 px-3 py-2 text-xs focus:outline-none focus:ring-2 focus:ring-brand-primary"
-                />
-            </div>
-
-            <button
-                type="submit"
-                class="inline-flex items-center justify-center rounded-lg bg-brand-primary text-white text-xs font-semibold px-4 py-2 mt-1 hover:bg-brand-primary/90 focus:outline-none focus:ring-2 focus:ring-brand-primary"
-            >
-                Seriennummer prüfen
-            </button>
-
-            <p class="mt-2 text-[10px] text-slate-500">
-                Hinweis: Dieser Quickcheck bewertet nur Plausibilität und Konsistenz und ersetzt keinen
-                vollständigen Kapazitäts- oder Geschwindigkeitstest.
-            </p>
-        </form>
-    </div>
-
-    <div id="serialcheck-error" class="hidden border border-red-300 bg-red-50 text-red-800 rounded-xl px-3 py-2 text-xs mb-3">
-        <!-- Fehlermeldung -->
-    </div>
-
-    <div id="serialcheck-result" class="hidden bg-white/80 dark:bg-slate-900/70 border border-slate-200/70 dark:border-slate-700 rounded-2xl shadow-sm p-4 text-xs">
-        <!-- Ergebnis wird per JS eingefügt -->
-    </div>
-</section>

partials/landing/fakecheck/webcheck.php

@@ -1,178 +0,0 @@
-<?php
-// fakecheck.php – Template für das Browser-Test-Tool im Bereich /fakecheck
-?>
-<section class="section-band section-band--soft border-t border-brand-border/60 py-12 sm:py-16" id="fakecheck-tool">
-    <div class="px-4 sm:px-6 lg:px-8">
-        <div class="section-shell fc-container">
-    <div class="fc-header">
-        <div class="fc-header-text">
-            <h2>Browser-basierter USB-Test</h2>
-            <p>
-                Führe einen Schnelltest direkt im Browser durch – ohne Installation.
-                Für tiefere Analysen gibt es später den Pro-Modus mit lokalem Helper.
-            </p>
-        </div>
-        <div class="fc-header-badge">
-            <span class="dot"></span>
-            <span id="fc-env-label">
-                Browser-Modus aktiv – keine Installation nötig
-            </span>
-        </div>
-    </div>
-
-    <div class="fc-layout" id="fc-root">
-        <!-- Linke Seite: Steuerung & Fortschritt -->
-        <section class="fc-card fc-main">
-            <h3 class="fc-card-title">Schritt 1: USB-Stick wählen</h3>
-            <p class="fc-card-subtitle">
-                Wähle das Wurzelverzeichnis deines USB-Sticks. Der Browser erhält nur Zugriff auf diesen Bereich.
-            </p>
-
-            <div class="fc-actions">
-                <button type="button" class="fc-btn" id="fc-btn-pick-directory">
-                    USB-Stick auswählen
-                </button>
-                <button type="button" class="fc-btn fc-btn-secondary" id="fc-btn-clear-selection" disabled>
-                    Auswahl zurücksetzen
-                </button>
-            </div>
-
-            <p class="fc-help" id="fc-selected-path-label">
-                Noch kein Verzeichnis gewählt.
-            </p>
-
-            <div class="fc-alert fc-alert-warn" id="fc-fsapi-warning" style="display:none;">
-                Dein Browser unterstützt die File System Access API nicht oder nur eingeschränkt.
-                Du kannst dieses Browser-Test-Tool nur mit aktuellen Chrome-/Edge-Versionen voll nutzen.
-            </div>
-
-            <hr class="fc-divider">
-
-            <h3 class="fc-card-title">Schritt 2: Testmodus</h3>
-            <p class="fc-card-subtitle">
-                Wähle, welche Tests du durchführen möchtest. Alle Tests arbeiten nur mit Testdateien
-                im gewählten Ordner.
-            </p>
-
-            <div class="fc-mode-grid" id="fc-mode-grid">
-                <article class="fc-mode-tile" data-mode="quick">
-                    <div class="pill">Quick-Check</div>
-                    <h4>Basis-Check</h4>
-                    <p>Schreibt und liest eine kleine Testdatei, um grundlegende Schreib-/Lesefehler zu erkennen.</p>
-                    <small>Empfohlen für einen ersten Eindruck in wenigen Sekunden.</small>
-                </article>
-
-                <article class="fc-mode-tile" data-mode="benchmark">
-                    <div class="pill">Benchmark</div>
-                    <h4>Speed-Test</h4>
-                    <p>Misst sequentielle Schreib- und Leseraten auf deinem Stick im Browser.</p>
-                    <small>Ideal für „Ist der Stick so langsam, wie er sich anfühlt?“</small>
-                </article>
-
-                <article class="fc-mode-tile" data-mode="writeverify">
-                    <div class="pill">Write &amp; Verify</div>
-                    <h4>Intensiver Dateitest</h4>
-                    <p>Schreibt mehrere Testblöcke und prüft sie direkt wieder – nur in Test-Dateien.</p>
-                    <small>Dauert länger, liefert aber eine bessere Aussage zur Stabilität.</small>
-                </article>
-
-                <article class="fc-mode-tile" data-mode="all">
-                    <div class="pill">All-Inclusive</div>
-                    <h4>Alle Browser-Tests</h4>
-                    <p>Führt Quick-Check, Benchmark und Write/Verify nacheinander aus.</p>
-                    <small>Maximale Aussagekraft im Browsermodus (ohne Pro-Helper).</small>
-                </article>
-            </div>
-
-            <p class="fc-help">
-                Hinweis: Diese Tests erzeugen nur eigene Testdateien in deinem gewählten Ordner
-                und überschreiben keine bestehenden Dateien. Für vollflächige, destruktive Tests
-                ist später der Pro-Helper zuständig.
-            </p>
-
-            <hr class="fc-divider">
-
-            <div class="fc-status-line">
-                <span id="fc-status-text">Bereit. Wähle zuerst deinen USB-Stick aus.</span>
-                <span id="fc-status-mode" class="fc-tag">Kein Modus selektiert</span>
-            </div>
-
-            <div class="fc-progress" aria-hidden="true">
-                <div class="fc-progress-inner" id="fc-progress-inner"></div>
-            </div>
-
-            <div class="fc-actions fc-actions-bottom">
-                <button type="button" class="fc-btn" id="fc-btn-start-tests" disabled>
-                    Tests starten
-                </button>
-                <button type="button" class="fc-btn fc-btn-secondary" id="fc-btn-cancel-tests" disabled>
-                    Abbrechen
-                </button>
-            </div>
-
-            <div class="fc-log" id="fc-log"></div>
-        </section>
-
-        <!-- Rechte Seite: Ergebnis-Dashboard -->
-        <aside class="fc-card fc-sidebar">
-            <h3 class="fc-card-title">Ergebnis-Dashboard</h3>
-            <p class="fc-card-subtitle">
-                Zusammenfassung der Browser-Tests. Für tiefergehende Analysen kannst du später den Pro-Modus nutzen.
-            </p>
-
-            <div class="fc-overall-status-wrap">
-                <span id="fc-overall-status-pill" class="fc-pill-status fc-pill-ok">
-                    <span class="fc-pill-dot"></span>
-                    <span id="fc-overall-status-text">Noch kein Test durchgeführt</span>
-                </span>
-            </div>
-
-            <dl class="fc-kv-list">
-                <div class="fc-kv-item">
-                    <dt>Modus</dt>
-                    <dd id="fc-res-mode">–</dd>
-                </div>
-                <div class="fc-kv-item">
-                    <dt>Gesamtlaufzeit</dt>
-                    <dd id="fc-res-duration">–</dd>
-                </div>
-                <div class="fc-kv-item">
-                    <dt>Write-Speed (Ø)</dt>
-                    <dd id="fc-res-write-speed">–</dd>
-                </div>
-                <div class="fc-kv-item">
-                    <dt>Read-Speed (Ø)</dt>
-                    <dd id="fc-res-read-speed">–</dd>
-                </div>
-                <div class="fc-kv-item">
-                    <dt>Geschriebene Testdaten</dt>
-                    <dd id="fc-res-written-bytes">–</dd>
-                </div>
-                <div class="fc-kv-item">
-                    <dt>Verifizierte Testdaten</dt>
-                    <dd id="fc-res-verified-bytes">–</dd>
-                </div>
-            </dl>
-
-            <div class="fc-alert fc-alert-info" id="fc-save-hint" style="display:none;">
-                Testergebnisse werden – sofern du eingeloggt bist – automatisch als Resultat gespeichert.
-            </div>
-
-            <div class="fc-alert fc-alert-error" id="fc-save-error" style="display:none;">
-                Ergebnis konnte nicht automatisch gespeichert werden. Du kannst es später erneut versuchen.
-            </div>
-
-            <p class="fc-help">
-                Technischer Hinweis: Diese Seite arbeitet ausschließlich mit Testdateien im gewählten Ordner
-                und übermittelt keine Inhalte deiner privaten Dateien.
-            </p>
-
-            <p class="fc-help">
-                Der vollständige JSON-Report ist nach dem Test in der Browser-Konsole einsehbar
-                (F12 → Console).
-            </p>
-        </aside>
-    </div>
-    </div>
-    </div>
-</section>

partials/landing/login/login.php

@@ -1,212 +0,0 @@
-<?php
-// Fallback falls $authView nicht gesetzt ist
-$authView = $authView ?? 'login';
-
-// Optional: View über GET-Parameter überschreiben (?view=login|register)
-if (isset($_GET['view']) && in_array($_GET['view'], ['login', 'register'], true)) {
-    $authView = $_GET['view'];
-}
-
-// Flash-Meldung holen (falls flash_get() existiert)
-$flash = function_exists('flash_get') ? flash_get() : null;
-
-// Wenn eine Flash-Message mit Kontext kommt, Tabs entsprechend umschalten
-if ($flash && !empty($flash['context']) && in_array($flash['context'], ['login', 'register'], true)) {
-    $authView = $flash['context'];
-}
-?>
-<section id="auth" class="section-band section-band--reverse border-t border-brand-border/60 py-16 sm:py-20">
-    <div class="px-4 sm:px-6 lg:px-8">
-        <div class="section-shell w-full max-w-2xl mx-auto">
-        <div class="mb-8 text-center space-y-3">
-            <p class="text-xs font-heading font-semibold tracking-[0.3em] uppercase text-brand-primary" data-i18n="auth_kicker">
-                Account &amp; Login
-            </p>
-            <h1 class="font-heading text-2xl sm:text-3xl font-bold text-brand-text" data-i18n="auth_title">
-                Melde dich bei USBCheck an
-            </h1>
-            <p class="text-sm sm:text-base text-brand-muted max-w-2xl mx-auto" data-i18n="auth_intro">
-                Mit einem Account kannst du Tests speichern, Reports exportieren und den Pro-Modus auf mehreren Geräten nutzen. Die Registrierung ist kostenlos – du kannst später jederzeit auf Pro upgraden.
-            </p>
-        </div>
-
-        <?php if ($flash): ?>
-            <div class="mb-6 rounded-xl px-4 py-3 text-sm border
-                <?php if ($flash['type'] === 'error'): ?>
-                    border-red-500/60 bg-red-500/10 text-red-300
-                <?php elseif ($flash['type'] === 'success'): ?>
-                    border-emerald-500/60 bg-emerald-500/10 text-emerald-300
-                <?php else: ?>
-                    border-brand-border bg-brand-bg/60 text-brand-muted
-                <?php endif; ?>
-            ">
-                <?= htmlspecialchars($flash['message']) ?>
-            </div>
-        <?php endif; ?>
-
-        <!-- Tabs -->
-        <div class="mb-6 rounded-full border border-brand-border bg-brand-surface/80 p-1 flex text-xs font-semibold uppercase tracking-[0.18em] text-brand-muted">
-            <button
-                type="button"
-                class="flex-1 px-3 py-2 rounded-full text-center transition-colors auth-tab <?= $authView === 'login' ? 'bg-brand-primary text-brand-bg' : 'hover:text-brand-primary'; ?>"
-                data-tab="login"
-                data-i18n="auth_tab_login">
-                Login
-            </button>
-            <button
-                type="button"
-                class="flex-1 px-3 py-2 rounded-full text-center transition-colors auth-tab <?= $authView === 'register' ? 'bg-brand-primary text-brand-bg' : 'hover:text-brand-primary'; ?>"
-                data-tab="register"
-                data-i18n="auth_tab_register">
-                Registrieren
-            </button>
-        </div>
-
-        <!-- Panels -->
-        <div class="space-y-6">
-            <!-- Login Panel -->
-            <div
-                id="authPanelLogin"
-                class="card-frame card-frame--soft space-y-5 <?= $authView !== 'login' ? 'hidden' : ''; ?>">
-                <h2 class="font-heading text-lg font-semibold text-brand-text" data-i18n="auth_login_title">
-                    Login
-                </h2>
-                <p class="text-sm text-brand-muted" data-i18n="auth_login_text">
-                    Melde dich mit deiner E-Mail-Adresse und deinem Passwort an.
-                </p>
-
-                <form method="post" action="/auth/login" class="space-y-4" autocomplete="on">
-                    <input type="hidden" name="lang" value="<?= htmlspecialchars($lang ?? 'de') ?>">
-                    <input type="hidden" name="redirect" value="<?= htmlspecialchars($_GET['redirect'] ?? '/') ?>">
-                    <input type="hidden" name="authView" value="login">
-
-                    <div class="space-y-1">
-                        <label for="login_email" class="block text-xs font-semibold tracking-wide uppercase text-brand-muted" data-i18n="auth_login_email_label">
-                            E-Mail-Adresse
-                        </label>
-                        <input
-                            type="email"
-                            id="login_email"
-                            name="email"
-                            required
-                            class="w-full rounded-lg border border-brand-border bg-brand-bg/60 px-3 py-2 text-sm text-brand-text placeholder:text-brand-muted/60 focus:outline-none focus:ring-2 focus:ring-brand-primary/60"
-                            placeholder="you@example.com"
-                            autocomplete="username"
-                        >
-                    </div>
-
-                    <div class="space-y-1">
-                        <label for="login_password" class="block text-xs font-semibold tracking-wide uppercase text-brand-muted" data-i18n="auth_login_password_label">
-                            Passwort
-                        </label>
-                        <input
-                            type="password"
-                            id="login_password"
-                            name="password"
-                            required
-                            class="w-full rounded-lg border border-brand-border bg-brand-bg/60 px-3 py-2 text-sm text-brand-text placeholder:text-brand-muted/60 focus:outline-none focus:ring-2 focus:ring-brand-primary/60"
-                            placeholder="••••••••"
-                            autocomplete="current-password"
-                        >
-                    </div>
-
-                    <p class="text-xs text-red-400 hidden" id="login_error">
-                        <!-- später dynamisch -->
-                    </p>
-
-                    <button
-                        type="submit"
-                        class="w-full inline-flex items-center justify-center rounded-full bg-brand-primary px-4 py-2.5 text-sm font-semibold text-brand-bg hover:bg-blue-400 transition-colors"
-                        data-i18n="auth_login_submit">
-                        Einloggen
-                    </button>
-
-                    <div class="flex justify-between items-center text-xs text-brand-muted mt-1">
-                        <a href="#" class="hover:text-brand-primary transition-colors" data-i18n="auth_login_forgot">
-                            Passwort vergessen?
-                        </a>
-                    </div>
-                </form>
-            </div>
-
-            <!-- Register Panel -->
-            <div
-                id="authPanelRegister"
-                class="card-frame space-y-5 <?= $authView !== 'register' ? 'hidden' : ''; ?>">
-                <h2 class="font-heading text-lg font-semibold text-brand-text" data-i18n="auth_register_title">
-                    Kostenlos registrieren
-                </h2>
-                <p class="text-sm text-brand-muted" data-i18n="auth_register_text">
-                    Erstelle einen kostenlosen Account, um Tests zu speichern, Berichte zu exportieren und den Pro-Modus später freizuschalten.
-                </p>
-
-                <form method="post" action="/auth/register" class="space-y-4" autocomplete="on">
-                    <input type="hidden" name="lang" value="<?= htmlspecialchars($lang ?? 'de') ?>">
-                    <input type="hidden" name="redirect" value="<?= htmlspecialchars($_GET['redirect'] ?? '/') ?>">
-                    <input type="hidden" name="authView" value="register">
-
-                    <div class="space-y-1">
-                        <label for="reg_name" class="block text-xs font-semibold tracking-wide uppercase text-brand-muted" data-i18n="auth_register_name_label">
-                            Name
-                        </label>
-                        <input
-                            type="text"
-                            id="reg_name"
-                            name="name"
-                            required
-                            class="w-full rounded-lg border border-brand-border bg-brand-bg/60 px-3 py-2 text-sm text-brand-text placeholder:text-brand-muted/60 focus:outline-none focus:ring-2 focus:ring-brand-primary/60"
-                            placeholder="Dein Name"
-                            autocomplete="name"
-                        >
-                    </div>
-
-                    <div class="space-y-1">
-                        <label for="reg_email" class="block text-xs font-semibold tracking-wide uppercase text-brand-muted" data-i18n="auth_register_email_label">
-                            E-Mail-Adresse
-                        </label>
-                        <input
-                            type="email"
-                            id="reg_email"
-                            name="email"
-                            required
-                            class="w-full rounded-lg border border-brand-border bg-brand-bg/60 px-3 py-2 text-sm text-brand-text placeholder:text-brand-muted/60 focus:outline-none focus:ring-2 focus:ring-brand-primary/60"
-                            placeholder="you@example.com"
-                            autocomplete="email"
-                        >
-                    </div>
-
-                    <div class="space-y-1">
-                        <label for="reg_password" class="block text-xs font-semibold tracking-wide uppercase text-brand-muted" data-i18n="auth_register_password_label">
-                            Passwort
-                        </label>
-                        <input
-                            type="password"
-                            id="reg_password"
-                            name="password"
-                            required
-                            class="w-full rounded-lg border border-brand-border bg-brand-bg/60 px-3 py-2 text-sm text-brand-text placeholder:text-brand-muted/60 focus:outline-none focus:ring-2 focus:ring-brand-primary/60"
-                            placeholder="Mindestens 8 Zeichen"
-                            autocomplete="new-password"
-                        >
-                    </div>
-
-                    <p class="text-xs text-red-400 hidden" id="register_error">
-                        <!-- später dynamisch -->
-                    </p>
-
-                    <button
-                        type="submit"
-                        class="w-full inline-flex items-center justify-center rounded-full border border-brand-primary bg-brand-bg/80 px-4 py-2.5 text-sm font-semibold text-brand-primary hover:bg-brand-primary hover:text-brand-bg transition-colors"
-                        data-i18n="auth_register_submit">
-                        Account erstellen
-                    </button>
-
-                    <p class="text-[11px] text-brand-muted/80 mt-1" data-i18n="auth_register_hint">
-                        Durch die Registrierung akzeptierst du die Datenschutzerklärung und das Impressum von USBCheck.
-                    </p>
-                </form>
-            </div>
-        </div>
-        </div>
-    </div>
-</section>

partials/landing/main/faq.php

@@ -1,63 +0,0 @@
-<section id="faq" class="section-band section-band--soft border-t border-brand-border/60 py-16 sm:py-20">
-    <div class="px-4 sm:px-6 lg:px-8">
-        <div class="section-shell space-y-10">
-        <div class="max-w-3xl space-y-4">
-            <p class="text-xs font-heading font-semibold tracking-[0.3em] uppercase text-brand-primary" data-i18n="faq_kicker">
-                FAQ
-            </p>
-            <h2 class="font-heading text-2xl sm:text-3xl font-bold text-brand-text" data-i18n="faq_title">
-                Häufige Fragen zu USBCheck
-            </h2>
-            <p class="text-sm sm:text-base text-brand-muted" data-i18n="faq_intro">
-                Hier findest du Antworten auf häufig gestellte Fragen. Der FAQ-Bereich kann jederzeit erweitert werden, wenn neue Anwendungsfälle hinzukommen oder du Feedback von Nutzern erhältst.
-            </p>
-        </div>
-
-        <div class="space-y-4 text-sm text-brand-muted">
-            <details class="group card-frame">
-                <summary class="flex cursor-pointer list-none items-center justify-between gap-4">
-                    <span class="font-semibold text-brand-text" data-i18n="faq_q1">Ist der Schnelltest wirklich komplett im Browser?</span>
-                    <span class="ml-auto text-brand-muted group-open:hidden">+</span>
-                    <span class="ml-auto text-brand-muted hidden group-open:inline">−</span>
-                </summary>
-                <div class="mt-2 text-sm text-brand-muted" data-i18n="faq_a1">
-                    Ja. Der Schnelltest läuft vollständig im Browser und nutzt moderne Browser-APIs, um Testdateien auf deinem Stick zu schreiben und wieder auszulesen. Es wird nichts ohne deine Zustimmung hochgeladen.
-                </div>
-            </details>
-
-            <details class="group card-frame">
-                <summary class="flex cursor-pointer list-none items-center justify-between gap-4">
-                    <span class="font-semibold text-brand-text" data-i18n="faq_q2">Brauche ich ein Konto, um den Schnelltest zu benutzen?</span>
-                    <span class="ml-auto text-brand-muted group-open:hidden">+</span>
-                    <span class="ml-auto text-brand-muted hidden group-open:inline">−</span>
-                </summary>
-                <div class="mt-2 text-sm text-brand-muted" data-i18n="faq_a2">
-                    Nein. Der kostenlose Schnelltest ist ohne Registrierung nutzbar. Ein Login ist nur notwendig, wenn du Testberichte speichern, mehrere Sticks verwalten oder den Pro-Modus nutzen möchtest.
-                </div>
-            </details>
-
-            <details class="group card-frame">
-                <summary class="flex cursor-pointer list-none items-center justify-between gap-4">
-                    <span class="font-semibold text-brand-text" data-i18n="faq_q3">Kann USBCheck jeden Fake-Stick sicher erkennen?</span>
-                    <span class="ml-auto text-brand-muted group-open:hidden">+</span>
-                    <span class="ml-auto text-brand-muted hidden group-open:inline">−</span>
-                </summary>
-                <div class="mt-2 text-sm text-brand-muted" data-i18n="faq_a3">
-                    Kein Tool kann eine 100&nbsp;%-Garantie geben. Der Pro-Modus mit Vollscan ist jedoch darauf ausgelegt, typische Fälschungsmuster (Manipulation der gemeldeten Kapazität, instabile Bereiche, Fehler ab einer bestimmten Füllmenge) sehr zuverlässig zu erkennen.
-                </div>
-            </details>
-
-            <details class="group card-frame">
-                <summary class="flex cursor-pointer list-none items-center justify-between gap-4">
-                    <span class="font-semibold text-brand-text" data-i18n="faq_q4">Wie fügt sich das Tool in mein bestehendes System ein?</span>
-                    <span class="ml-auto text-brand-muted group-open:hidden">+</span>
-                    <span class="ml-auto text-brand-muted hidden group-open:inline">−</span>
-                </summary>
-                <div class="mt-2 text-sm text-brand-muted" data-i18n="faq_a4">
-                    USBCheck ist von Anfang an für Automatisierung gedacht. Über den Pro-Modus und die geplante API kannst du Tests in bestehende Workflows integrieren – beispielsweise in Wareneingangsprüfungen oder Qualitätskontrollen.
-                </div>
-            </details>
-        </div>
-        </div>
-    </div>
-</section>

partials/landing/main/features.php

@@ -1,70 +0,0 @@
-<section id="features" class="section-band section-band--soft border-t border-brand-border/60 py-16 sm:py-20">
-    <div class="px-4 sm:px-6 lg:px-8">
-        <div class="section-shell space-y-10">
-        <div class="max-w-3xl space-y-4">
-            <p class="text-xs font-heading font-semibold tracking-[0.3em] uppercase text-brand-primary" data-i18n="features_kicker">
-                Free &amp; Pro features
-            </p>
-            <h2 class="font-heading text-2xl sm:text-3xl font-bold text-brand-text" data-i18n="features_title">
-                Starte mit dem kostenlosen Schnelltest – wechsle in den Pro-Modus, wenn du mehr brauchst.
-            </h2>
-            <p class="text-sm sm:text-base text-brand-muted" data-i18n="features_intro">
-                USBCheck wächst mit deinen Anforderungen: Private Nutzer brauchen oft nur eine schnelle Einschätzung. Profis möchten tiefer einsteigen, Kapazitäten verifizieren und Reports archivieren. Genau dafür ist der Pro-Modus gedacht.
-            </p>
-        </div>
-
-        <div class="grid gap-6 md:grid-cols-2">
-            <!-- Free -->
-            <div class="card-frame card-frame--soft space-y-4">
-                <div class="flex items-center justify-between">
-                    <h3 class="font-heading text-xl font-semibold text-brand-text" data-i18n="features_free_title">Free Quick Check</h3>
-                    <span class="inline-flex items-center rounded-full bg-emerald-500/10 px-3 py-1 text-xs font-semibold text-emerald-400" data-i18n="features_free_badge">
-                        Recommended for most users
-                    </span>
-                </div>
-                <p class="text-sm text-brand-muted" data-i18n="features_free_text">
-                    Ideal für alle, die schnell prüfen möchten, ob ein USB-Stick zumindest grundlegend performant und stabil arbeitet – ganz ohne Installation.
-                </p>
-                <ul class="mt-2 space-y-2 text-sm text-brand-muted">
-                    <li data-i18n="features_free_li1">• Browser-basierter Schnelltest direkt auf deinem Stick</li>
-                    <li data-i18n="features_free_li2">• Schreib- und Lesegeschwindigkeit mit realen Testdaten</li>
-                    <li data-i18n="features_free_li3">• Hash-basierte Integritätsprüfung einer Testmenge</li>
-                    <li data-i18n="features_free_li4">• Auswahl verschiedener Teststufen (z. B. 200&nbsp;MB, 2&nbsp;GB)</li>
-                    <li data-i18n="features_free_li5">• Keine Registrierung erforderlich</li>
-                </ul>
-                <a href="<?= htmlspecialchars(app_primary_url() . '/fakecheck/') ?>"
-                   class="inline-flex mt-3 items-center text-sm font-semibold text-brand-primary hover:text-blue-300"
-                   data-i18n="features_free_cta">
-                    Start free quick check
-                    <svg class="ml-1 h-4 w-4" viewBox="0 0 20 20" fill="currentColor">
-                        <path d="M10.293 3.293a1 1 0 011.414 0L17 8.586a2 2 0 010 2.828l-5.293 5.293a1 1 0 01-1.414-1.414L13.586 11H4a1 1 0 110-2h9.586L10.293 4.707a1 1 0 010-1.414z"/>
-                    </svg>
-                </a>
-            </div>
-
-            <!-- Pro -->
-            <div class="card-frame card-frame--accent space-y-4">
-                <div class="flex items-center justify-between">
-                    <h3 class="font-heading text-xl font-semibold text-brand-text" data-i18n="features_pro_title">Pro Mode</h3>
-                    <span class="inline-flex items-center rounded-full bg-brand-primary/10 px-3 py-1 text-xs font-semibold text-brand-primary" data-i18n="features_pro_badge">
-                        For power users &amp; teams
-                    </span>
-                </div>
-                <p class="text-sm text-brand-muted" data-i18n="features_pro_text">
-                    Für alle, die volle Kontrolle brauchen: IT-Abteilungen, Techniker, Refurbisher, Labore oder Unternehmen, die regelmäßig größere Stick-Mengen testen.
-                </p>
-                <ul class="mt-2 space-y-2 text-sm text-brand-muted">
-                    <li data-i18n="features_pro_li1">• Tiefenscan der gesamten Kapazität (ähnlich F3 / badblocks)</li>
-                    <li data-i18n="features_pro_li2">• Erkennung von Kapazitäts-Fakes und defekten Bereichen</li>
-                    <li data-i18n="features_pro_li3">• Detaillierte, speicherbare Testberichte (JSON, PDF)</li>
-                    <li data-i18n="features_pro_li4">• Optional: API-Zugriff für automatisierte Testprozesse</li>
-                    <li data-i18n="features_pro_li5">• Multi-Device- und Multi-User-Support (über Login-Bereich)</li>
-                </ul>
-                <p class="mt-3 text-xs text-brand-muted/80" data-i18n="features_pro_note">
-                    Der Pro-Modus erfordert ein kleines Helfer-Tool auf deinem System. Dieses arbeitet lokal und kann bei Bedarf mit deinem Account auf USBCheck verbunden werden.
-                </p>
-            </div>
-        </div>
-        </div>
-    </div>
-</section>

partials/landing/main/hero.php

@@ -1,122 +0,0 @@
-<?php $primaryFakecheckUrl = app_primary_url() . '/fakecheck/'; ?>
-<section id="hero" class="hero-section relative overflow-hidden">
-    <div class="relative px-4 sm:px-6 lg:px-8">
-        <div class="section-shell hero-shell items-center">
-        <!-- Left: Text -->
-        <div class="hero-copy space-y-7">
-            <p class="text-xs font-heading font-semibold tracking-[0.3em] uppercase text-brand-primary" data-i18n="hero_kicker">
-                Detect fake USB sticks before you lose data
-            </p>
-            <h1 class="font-heading text-3xl sm:text-4xl lg:text-5xl font-extrabold tracking-tight text-brand-text" data-i18n="hero_title">
-                Is my USB fake?<br><span class="text-brand-primary">Find out in minutes.</span>
-            </h1>
-            <p class="text-base sm:text-lg text-brand-muted max-w-xl" data-i18n="hero_lead">
-                USBCheck kombiniert einen schnellen Browser-Test mit einem professionellen Pro-Modus. So erkennst du gefälschte USB-Sticks, zu kleine echte Kapazität und langsame Billig-Controller – bevor deine Dateien verschwinden.
-            </p>
-
-            <!-- CTAs -->
-            <div class="flex flex-col sm:flex-row gap-3 sm:gap-4">
-                <a href="<?= htmlspecialchars($primaryFakecheckUrl) ?>"
-                   class="inline-flex items-center justify-center rounded-full bg-brand-primary px-6 py-3 text-sm font-semibold text-brand-bg shadow-soft hover:bg-blue-400 transition-colors"
-                   data-i18n="cta_quick">
-                    Start free quick check
-                    <svg class="ml-2 h-4 w-4" viewBox="0 0 20 20" fill="currentColor" aria-hidden="true">
-                        <path fill-rule="evenodd" d="M10.293 3.293a1 1 0 011.414 0L17 8.586a2 2 0 010 2.828l-5.293 5.293a1 1 0 01-1.414-1.414L13.586 11H4a1 1 0 110-2h9.586L10.293 4.707a1 1 0 010-1.414z" clip-rule="evenodd" />
-                    </svg>
-                </a>
-
-                <a href="#features"
-                   class="inline-flex items-center justify-center rounded-full border border-brand-border/70 bg-brand-bg/60 px-6 py-3 text-sm font-semibold text-brand-text hover:border-brand-primary hover:text-brand-primary transition-colors"
-                   data-i18n="cta_learn">
-                    Learn more about Free &amp; Pro
-                </a>
-            </div>
-
-            <!-- Trust / Highlights -->
-            <div class="grid grid-cols-1 sm:grid-cols-3 gap-4 pt-6 border-t border-brand-border/60">
-                <div class="space-y-1">
-                    <p class="text-xs font-semibold text-brand-muted uppercase tracking-[0.18em]" data-i18n="trust1_title">No install for quick check</p>
-                    <p class="text-sm text-brand-text/90" data-i18n="trust1_text">Browser-basierter Test direkt auf deinem Stick.</p>
-                </div>
-                <div class="space-y-1">
-                    <p class="text-xs font-semibold text-brand-muted uppercase tracking-[0.18em]" data-i18n="trust2_title">Real write &amp; read tests</p>
-                    <p class="text-sm text-brand-text/90" data-i18n="trust2_text">Schreib-/Lesetests mit echten Daten – keine synthetische Theorie.</p>
-                </div>
-                <div class="space-y-1">
-                    <p class="text-xs font-semibold text-brand-muted uppercase tracking-[0.18em]" data-i18n="trust3_title">Privacy first</p>
-                    <p class="text-sm text-brand-text/90" data-i18n="trust3_text">Deine Testdaten bleiben lokal – Reports nur auf Wunsch.</p>
-                </div>
-            </div>
-        </div>
-
-        <!-- Right: Card (Teaser Quickcheck) -->
-        <div class="hero-preview w-full">
-            <div class="quick-preview-card space-y-6">
-                <div class="quick-preview-header">
-                    <div>
-                        <p class="quick-preview-eyebrow" data-i18n="quick_label">
-                            QUICK CHECK PREVIEW
-                        </p>
-                        <h2 class="mt-2 font-heading font-semibold text-xl text-brand-text" data-i18n="quick_title">
-                            Test a USB drive in under 2 minutes
-                        </h2>
-                    </div>
-                    <span class="quick-badge" data-i18n="badge_free">
-                        Free
-                    </span>
-                </div>
-
-                <div class="grid grid-cols-1 sm:grid-cols-2 gap-3">
-                    <div class="quick-metric-card">
-                        <span data-i18n="quick_metric1_label">Write performance</span>
-                        <span data-i18n="quick_metric1_value">~ 75–120 MB/s*</span>
-                    </div>
-                    <div class="quick-metric-card">
-                        <span data-i18n="quick_metric2_label">Integrity checks</span>
-                        <span data-i18n="quick_metric2_value">512 MB sample</span>
-                    </div>
-                </div>
-
-                <p class="text-sm text-brand-muted" data-i18n="quick_intro">
-                    Der Schnelltest prüft eine definierte Datenmenge auf deinem Stick und misst:
-                </p>
-                <ul class="list-disc list-inside space-y-1 text-sm text-brand-muted">
-                    <li data-i18n="quick_li1">Schreib- und Leserate</li>
-                    <li data-i18n="quick_li2">Datenintegrität (Hash-Vergleich)</li>
-                    <li data-i18n="quick_li3">Verdächtige Abbrüche oder Fehler</li>
-                </ul>
-
-                <div class="quick-kit">
-                    <div class="quick-kit-left">
-                        <h4 data-i18n="quick_visual_title">Quick test indicator</h4>
-                        <p data-i18n="quick_visual_text">
-                            So sieht die Schnelltest-Vorschau aus: Grün markiert einen stabilen Stick, Orange warnt bei Auffälligkeiten.
-                        </p>
-                        <div class="quick-kit-lines">
-                            <div class="quick-kit-line"></div>
-                            <div class="quick-kit-line is-alert"></div>
-                        </div>
-                    </div>
-                    <div class="quick-kit-window">
-                        <span class="window-label" data-i18n="quick_visual_window">Result window</span>
-                        <div class="window-strip">
-                            <span class="window-dot is-active"></span>
-                            <span class="window-dot is-pass"></span>
-                            <span class="window-dot"></span>
-                        </div>
-                        <p class="quick-kit-footnote" data-i18n="quick_footnote">
-                            *Beispielwerte – deine Ergebnisse hängen von Stick, Port &amp; System ab.
-                        </p>
-                    </div>
-                </div>
-
-                <a href="<?= htmlspecialchars($primaryFakecheckUrl) ?>"
-                   class="block text-center rounded-full bg-brand-primary px-4 py-2.5 text-sm font-semibold text-brand-bg hover:bg-blue-400 transition-colors"
-                   data-i18n="quick_cta">
-                    Go to free quick check
-                </a>
-            </div>
-        </div>
-        </div>
-    </div>
-</section>

partials/landing/main/how.php

@@ -1,74 +0,0 @@
-<section id="how" class="section-band section-band--soft border-t border-brand-border/60 py-16 sm:py-20">
-    <div class="px-4 sm:px-6 lg:px-8">
-        <div class="section-shell grid gap-10 lg:grid-cols-[1.2fr,1fr]">
-            <div class="space-y-6">
-            <p class="text-xs font-heading font-semibold tracking-[0.3em] uppercase text-brand-primary" data-i18n="how_kicker">
-                How USBCheck works
-            </p>
-            <h2 class="font-heading text-2xl sm:text-3xl font-bold text-brand-text" data-i18n="how_title">
-                Schnelltest im Browser, Pro-Modus mit Tiefenanalyse.
-            </h2>
-            <p class="text-brand-muted text-sm sm:text-base" data-i18n="how_intro">
-                USBCheck wurde entwickelt, um zwei Welten zu verbinden: einen einfachen Schnelltest für alle und einen tiefgehenden Pro-Modus für Power-User, Techniker und Admins. Der Schnelltest läuft direkt im Browser, ohne Installation. Für den Pro-Modus wird ein kleines Helfer-Tool verwendet, das auf Wunsch F3- / badblocks-ähnliche Tests ausführt und damit Kapazitäts-Fakes sicher enttarnt.
-            </p>
-
-            <ol class="space-y-4 text-sm text-brand-muted">
-                <li class="flex gap-3">
-                    <span class="flex h-7 w-7 items-center justify-center rounded-full bg-brand-primary/20 text-xs font-semibold text-brand-primary">01</span>
-                    <div>
-                        <h3 class="font-semibold text-brand-text" data-i18n="how_step1_title">Browser-Test starten</h3>
-                        <p data-i18n="how_step1_text">
-                            Du öffnest den Schnelltest unter <strong><?= htmlspecialchars(app_primary_url()) ?>/fakecheck/</strong>, wählst deinen USB-Stick bzw. einen Ordner darauf aus und definierst, wie viel Daten getestet werden sollen.
-                        </p>
-                    </div>
-                </li>
-                <li class="flex gap-3">
-                    <span class="flex h-7 w-7 items-center justify-center rounded-full bg-brand-primary/20 text-xs font-semibold text-brand-primary">02</span>
-                    <div>
-                        <h3 class="font-semibold text-brand-text" data-i18n="how_step2_title">Schreib-, Lese- und Integritätsprüfung</h3>
-                        <p data-i18n="how_step2_text">
-                            Der Browser erstellt Testdateien, misst Schreib- und Leserate und vergleicht Hash-Werte, um Datenfehler zu erkennen – alles lokal und ohne Übertragung deiner Inhalte.
-                        </p>
-                    </div>
-                </li>
-                <li class="flex gap-3">
-                    <span class="flex h-7 w-7 items-center justify-center rounded-full bg-brand-primary/20 text-xs font-semibold text-brand-primary">03</span>
-                    <div>
-                        <h3 class="font-semibold text-brand-text" data-i18n="how_step3_title">Optional: Pro-Modus für Vollscan</h3>
-                        <p data-i18n="how_step3_text">
-                            Wer mehr wissen will, installiert das optionale Helfer-Tool. Dieses kann die gesamte Kapazität des Sticks prüfen, Fakes identifizieren und detaillierte Reports erzeugen – ideal für Refurbisher, IT-Abteilungen oder Labore.
-                        </p>
-                    </div>
-                </li>
-            </ol>
-        </div>
-
-            <!-- Small feature card -->
-            <div class="card-frame card-frame--soft space-y-5">
-                <h3 class="font-heading text-lg font-semibold text-brand-text" data-i18n="how_side_title">
-                    Free vs Pro at a glance
-                </h3>
-                <ul class="space-y-3 text-sm text-brand-muted">
-                    <li class="flex gap-2">
-                        <span class="mt-1 h-5 w-5 rounded-full bg-emerald-500/10 text-emerald-400 flex items-center justify-center text-[10px]">F</span>
-                        <p data-i18n="how_side_free">
-                            <strong>Free Quick Check:</strong> Geschwindigkeit &amp; Integritätstest im Browser – ideal für schnelle Einschätzungen.
-                        </p>
-                    </li>
-                    <li class="flex gap-2">
-                        <span class="mt-1 h-5 w-5 rounded-full bg-sky-500/10 text-sky-400 flex items-center justify-center text-[10px]">P</span>
-                        <p data-i18n="how_side_pro">
-                            <strong>Pro-Modus:</strong> Tiefenscan, Kapazitätsvalidierung, erweiterte Berichte und API-Integration für Unternehmen.
-                        </p>
-                    </li>
-                    <li class="flex gap-2">
-                        <span class="mt-1 h-5 w-5 rounded-full bg-violet-500/10 text-violet-400 flex items-center justify-center text-[10px]">A</span>
-                        <p data-i18n="how_side_account">
-                            <strong>Account &amp; Login:</strong> Nach dem Login kannst du Tests speichern, Berichte exportieren und mehrere Geräte verwalten.
-                        </p>
-                    </li>
-                </ul>
-            </div>
-        </div>
-    </div>
-</section>

partials/landing/main/problem.php

@@ -1,40 +0,0 @@
-<section id="problem" class="section-band section-band--reverse border-t border-brand-border/60 py-16 sm:py-20">
-    <div class="px-4 sm:px-6 lg:px-8">
-        <div class="section-shell space-y-8">
-        <div class="max-w-3xl space-y-4">
-            <p class="text-xs font-heading font-semibold tracking-[0.3em] uppercase text-brand-primary" data-i18n="problem_kicker">
-                Why fake USB sticks are dangerous
-            </p>
-            <h2 class="font-heading text-2xl sm:text-3xl font-bold text-brand-text" data-i18n="problem_title">
-                Gefälschte USB-Sticks kosten Geld – und im schlimmsten Fall deine Daten.
-            </h2>
-            <p class="text-sm sm:text-base text-brand-muted" data-i18n="problem_p1">
-                Viele Billig-USB-Sticks werben mit unrealistisch hohen Kapazitäten. In Wahrheit wurde der Controller manipuliert: Der Stick meldet z. B. 256&nbsp;GB, obwohl physisch nur 32&nbsp;GB verbaut sind. Die Folge: Daten werden scheinbar korrekt kopiert, später aber stillschweigend überschrieben oder beschädigt.
-            </p>
-            <p class="text-sm sm:text-base text-brand-muted" data-i18n="problem_p2">
-                USBCheck hilft dir, solche Fakes zu erkennen, bevor du sie produktiv einsetzt – egal ob du einzelne Sticks privat nutzt oder größere Chargen für dein Unternehmen prüfst.
-            </p>
-        </div>
-
-        <div class="grid gap-6 md:grid-cols-3 text-sm text-brand-muted">
-            <div class="card-frame space-y-2">
-                <h3 class="font-semibold text-brand-text" data-i18n="problem_card1_title">Verlust wichtiger Dateien</h3>
-                <p data-i18n="problem_card1_text">
-                    Fotos, Projektdateien, Backups – alles kann betroffen sein, wenn der Stick weniger speichert als behauptet. Defekte Sektoren bleiben oft unbemerkt, bis es zu spät ist.
-                </p>
-            </div>
-            <div class="card-frame space-y-2">
-                <h3 class="font-semibold text-brand-text" data-i18n="problem_card2_title">Kosten durch defekte Chargen</h3>
-                <p data-i18n="problem_card2_text">
-                    Unternehmen, Reseller und Agenturen verteilen USB-Sticks oft in großer Stückzahl. Fakes bedeuten Reklamationen, Imageschaden und erneute Produktionskosten.
-                </p>
-            </div>
-            <div class="card-frame space-y-2">
-                <h3 class="font-semibold text-brand-text" data-i18n="problem_card3_title">Unsichere Performance</h3>
-                <p data-i18n="problem_card3_text">
-                    Langsame Controller, instabile Firmware und schwankende Schreibraten sind typisch für Fake-Sticks. Das erhöht das Risiko von Fehlern – besonders bei großen Dateien.
-                </p>
-            </div>
-        </div>
-    </div>
-</section>

partials/landing/main/security.php

@@ -1,38 +0,0 @@
-<section id="security" class="section-band section-band--reverse border-t border-brand-border/60 py-16 sm:py-20">
-    <div class="px-4 sm:px-6 lg:px-8">
-        <div class="section-shell space-y-8">
-        <div class="max-w-3xl space-y-4">
-            <p class="text-xs font-heading font-semibold tracking-[0.3em] uppercase text-brand-primary" data-i18n="security_kicker">
-                Security &amp; privacy
-            </p>
-            <h2 class="font-heading text-2xl sm:text-3xl font-bold text-brand-text" data-i18n="security_title">
-                Privacy-first-Design: Deine Testdaten gehören dir.
-            </h2>
-            <p class="text-sm sm:text-base text-brand-muted" data-i18n="security_intro">
-                USBCheck wurde von Anfang an so konzipiert, dass deine Daten geschützt bleiben. Der Browser-Schnelltest arbeitet ausschließlich mit Testdateien. Deine eigenen Dokumente, Bilder oder Backups werden weder gelesen noch übertragen. Im Pro-Modus hast du volle Kontrolle, ob und welche Reports mit deinem Account synchronisiert werden.
-            </p>
-        </div>
-
-        <div class="grid gap-6 md:grid-cols-3 text-sm text-brand-muted">
-            <div class="card-frame space-y-2">
-                <h3 class="font-semibold text-brand-text" data-i18n="security_card1_title">Local-only Tests</h3>
-                <p data-i18n="security_card1_text">
-                    Alle Schreib- und Lesetests erfolgen lokal auf deinem USB-Stick. Der Browser greift nur auf die Testdateien zu – nicht auf deine privaten Inhalte.
-                </p>
-            </div>
-            <div class="card-frame space-y-2">
-                <h3 class="font-semibold text-brand-text" data-i18n="security_card2_title">Transparente Reports</h3>
-                <p data-i18n="security_card2_text">
-                    Wenn du dich einloggst, kannst du Testberichte in deinem Account speichern, exportieren oder wieder löschen. Du entscheidest, welche Daten im System bleiben.
-                </p>
-            </div>
-            <div class="card-frame space-y-2">
-                <h3 class="font-semibold text-brand-text" data-i18n="security_card3_title">Schonend für deine Hardware</h3>
-                <p data-i18n="security_card3_text">
-                    Der Schnelltest arbeitet mit moderaten Datenmengen, um unnötigen Verschleiß zu vermeiden. Der Pro-Modus warnt deutlich, wenn ein Vollscan mit hoher Schreiblast ausgeführt wird.
-                </p>
-            </div>
-        </div>
-        </div>
-    </div>
-</section>

partials/structure/app_config.php

@@ -1,58 +0,0 @@
-<?php
-// partials/structure/app_config.php
-
-// Host-Infos ermitteln (für URLs / Redirects etc.)
-$scheme     = (!empty($_SERVER['HTTPS']) && $_SERVER['HTTPS'] !== 'off') ? 'https' : 'http';
-$host       = $_SERVER['HTTP_HOST'] ?? app_primary_domain();
-$requestUri = $_SERVER['REQUEST_URI'] ?? '/';
-
-// Aktuelle Sprache & Sprachen aus den GLOBALS (fileload.php)
-$currentLang     = $GLOBALS['lang']           ?? ($lang ?? 'en');
-$allAvailable    = $GLOBALS['availableLangs'] ?? [];
-
-// Optional: Environment aus config.php (du hattest $env → $GLOBALS['usb_env'])
-$env = $GLOBALS['usb_env'] ?? 'prod';
-
-// -----------------------------------------------
-// USBCheck JavaScript-Konfiguration
-// -----------------------------------------------
-$usbConfig = [
-    'lang'        => $currentLang,
-
-    // Basis-Pfade
-    'assetsBase'  => '/assets',
-
-    // Versionierung für JS/CSS
-    'assetVersion'=> defined('ASSET_VERSION') ? ASSET_VERSION : null,
-
-    // Environment (prod, staging, dev)
-    'env'         => $env,
-
-    // Domains
-    'domains'     => [
-        'primaryDomain'   => app_primary_domain(),
-        'primaryUrl'      => app_primary_url(),
-        'fakecheckDomain' => app_fakecheck_domain(),
-        'fakecheckUrl'    => app_fakecheck_url(),
-    ],
-
-    // Fakecheck-Tool-Config
-    'fakecheck' => [
-        'baseUrl'    => $GLOBALS['usb_base_url']  ?? '',
-        'apiBaseUrl' => $GLOBALS['usb_api_base']  ?? 'https://api.usbcheck.it',
-        'locale'     => $currentLang,
-    ],
-
-    // i18n-Konfiguration
-    'i18n' => [
-        'available' => $allAvailable,
-        'current'   => $currentLang,
-    ],
-];
-?>
-<script>
-    window.usbConfig = <?= json_encode(
-        $usbConfig,
-        JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE | JSON_INVALID_UTF8_SUBSTITUTE
-    ) ?>;
-</script>

partials/structure/footer.php

@@ -1,13 +0,0 @@
-<?php
-// public/partials/footer.php
-?>
-<footer class="border-t border-brand-border/70">
-    <div class="mx-auto max-w-6xl px-4 sm:px-6 lg:px-8 py-6 flex flex-col sm:flex-row items-center justify-between gap-4 text-xs text-brand-muted">
-        <p>© <?= date('Y') ?> <?= htmlspecialchars(app_primary_domain()) ?></p>
-
-        <div class="flex items-center gap-4">
-            <a href="/impressum.php" class="hover:text-brand-primary transition-colors" data-i18n="footer_imprint"></a>
-            <a href="/datenschutz.php" class="hover:text-brand-primary transition-colors" data-i18n="footer_privacy"></a>
-        </div>
-    </div>
-</footer>

partials/structure/header.php

@@ -1,239 +0,0 @@
-<?php
-// partials/structure/header.php
-
-// Aktuelle Basis-URL der laufenden Instanz (staging, prod, etc.)
-$baseUrl = app_current_base_url();
-
-// Aktueller Page-Key (z.B. 'landing', 'fakecheck', 'dashboard')
-$pageKey = $GLOBALS['pageKey'] ?? null;
-
-// Nav-Anker: wenn nicht explizit gesetzt, aus der i18n-JSON holen
-if (!isset($navAnchors) || !is_array($navAnchors)) {
-    if ($pageKey && function_exists('app_get_nav_anchors')) {
-        $navAnchors = app_get_nav_anchors($pageKey); // ['href' => '#how', 'label' => '...']
-    } else {
-        $navAnchors = [];
-    }
-}
-
-// Session sollte in config/fileload.php bereits gestartet sein.
-// Falls nicht, hier Fallback:
-if (session_status() !== PHP_SESSION_ACTIVE) {
-    @session_start();
-}
-
-// aktuellen User aus der Session holen (wenn vorhanden)
-$currentUser = $_SESSION['user'] ?? null;
-$isLoggedIn  = is_array($currentUser) && !empty($currentUser['id']);
-
-// Initialen für Avatar bestimmen
-$userInitials = null;
-if ($isLoggedIn) {
-    if (!empty($currentUser['initials'])) {
-        $userInitials = $currentUser['initials'];
-    } else {
-        $firstName = $currentUser['first_name'] ?? '';
-        $lastName  = $currentUser['last_name'] ?? '';
-        $username  = $currentUser['username'] ?? ($currentUser['email'] ?? 'U');
-
-        $initials = '';
-        if ($firstName !== '') {
-            $initials .= mb_substr($firstName, 0, 1);
-        }
-        if ($lastName !== '') {
-            $initials .= mb_substr($lastName, 0, 1);
-        }
-        if ($initials === '') {
-            $initials = mb_substr($username, 0, 2);
-        }
-        $userInitials = mb_strtoupper($initials);
-    }
-}
-
-// -----------------------------------------
-// Sprachkontext direkt aus fileload.php
-// -----------------------------------------
-$currentLang    = $GLOBALS['lang']           ?? 'en';
-$availableLangs = $GLOBALS['availableLangs'] ?? [];
-
-// Sicherheits-Fallback: falls aus irgendeinem Grund leer
-if (!is_array($availableLangs) || empty($availableLangs)) {
-    $availableLangs = [
-        $currentLang => [
-            'code'  => $currentLang,
-            'label' => strtoupper($currentLang),
-            'flag'  => '🏳️',
-        ],
-    ];
-}
-
-// Sicherstellen, dass currentLang eine gültige Sprache ist
-if (!isset($availableLangs[$currentLang])) {
-    $keys        = array_keys($availableLangs);
-    $currentLang = $keys[0] ?? 'en';
-}
-
-// aktuelle Sprache-Info
-$currentLangInfo  = $availableLangs[$currentLang] ?? ['code' => $currentLang];
-$currentLangFlag  = $currentLangInfo['flag']  ?? '🏳️';
-$currentLangCode  = strtoupper($currentLangInfo['code'] ?? $currentLang);
-$currentLangLabel = $currentLangInfo['label'] ?? $currentLangCode;
-
-// -----------------------------------------
-// Helper: URL mit anderem ?lang=.. bauen
-// -----------------------------------------
-$currentPath  = app_current_path();
-$currentQuery = $_GET ?? [];
-
-function build_lang_url(string $code, string $path, array $query): string
-{
-    $query['lang'] = $code;
-    $qs = http_build_query($query);
-    return $path . ($qs ? ('?' . $qs) : '');
-}
-?>
-<header class="sticky top-0 z-40 border-b border-brand-border/70 backdrop-blur bg-brand-bg/85">
-    <div class="mx-auto max-w-6xl px-4 sm:px-6 lg:px-8 flex items-center justify-between min-h-16 py-2">
-
-        <!-- Logo -->
-        <div class="flex items-center gap-3">
-            <a href="<?= htmlspecialchars(build_lang_url($currentLang, '/', [])) ?>" class="flex items-center gap-3">
-                <img src="<?= $baseUrl ?>/assets/img/logo_slogan.png"
-                     alt="<?= htmlspecialchars(app_primary_domain()) ?> Logo"
-                     class="h-9 w-auto">
-
-                <div class="hidden sm:flex flex-col leading-tight">
-                    <span class="font-heading font-bold text-sm uppercase tracking-[0.18em] text-brand-muted">
-                        <?= htmlspecialchars(app_primary_domain()) ?>
-                    </span>
-                    <span class="text-xs text-brand-muted" data-i18n="header_slogan">
-                        Test USB drives
-                    </span>
-                </div>
-            </a>
-        </div>
-
-        <!-- Navigation + Controls -->
-        <div class="flex items-center gap-6">
-
-            <!-- Hauptnavigation -->
-            <?php if (!empty($navAnchors)): ?>
-                <nav class="flex flex-wrap items-center gap-x-4 gap-y-1 sm:gap-x-6 text-xs font-medium text-brand-muted uppercase tracking-[0.18em]">
-                    <?php foreach ($navAnchors as $item): ?>
-                        <?php
-                            $href    = $item['href']  ?? '#';
-                            $label   = $item['label'] ?? '';
-                            $i18nKey = $item['i18n']  ?? '';
-                        ?>
-                        <a href="<?= htmlspecialchars($href) ?>"
-                           class="hover:text-brand-primary transition-colors"
-                           <?php if ($i18nKey !== ''): ?>
-                               data-i18n="<?= htmlspecialchars($i18nKey) ?>"
-                           <?php endif; ?>
-                        ><?= htmlspecialchars($label) ?></a>
-                    <?php endforeach; ?>
-                </nav>
-            <?php endif; ?>
-
-            <!-- Language Switcher -->
-            <div class="relative">
-                <button id="langCurrent"
-                        type="button"
-                        class="flex items-center gap-1 text-xs uppercase tracking-[0.18em] text-brand-muted hover:text-brand-primary transition">
-                    <span id="langCurrentLabel"><?= htmlspecialchars($currentLangCode) ?></span>
-                    <svg class="w-3 h-3 opacity-70" viewBox="0 0 20 20" aria-hidden="true">
-                        <path d="M5 7l5 6 5-6" fill="currentColor" />
-                    </svg>
-                </button>
-
-                <div id="langMenu"
-                     class="hidden absolute right-0 mt-2 w-32 rounded-xl bg-brand-surface border border-brand-border shadow-lg py-1 text-xs z-40">
-                    <?php foreach ($availableLangs as $code => $info): ?>
-                        <?php
-                            // 👉 aktuelle Sprache NICHT noch einmal im Menü anzeigen
-                            if ($code === $currentLang) {
-                                continue;
-                            }
-
-                            $flag  = $info['flag']  ?? '🏳️';
-                            $label = strtoupper($info['code'] ?? $code);
-                            $url   = build_lang_url($code, $currentPath, $currentQuery);
-                        ?>
-                        <a href="<?= htmlspecialchars($url) ?>"
-                           class="lang-pill flex items-center gap-2 w-full text-left px-3 py-1.5 uppercase tracking-[0.18em] text-brand-muted hover:text-brand-primary hover:bg-brand-bg/60">
-                            <span class="text-base"><?= htmlspecialchars($flag) ?></span>
-                            <span><?= htmlspecialchars($label) ?></span>
-                        </a>
-                    <?php endforeach; ?>
-                </div>
-            </div>
-
-            <!-- Login / Avatar -->
-            <div class="relative">
-                <?php if (!$isLoggedIn): ?>
-                    <!-- Nicht eingeloggt: Login-Button -->
-                    <button id="loginButton"
-                            type="button"
-                            class="relative inline-flex items-center justify-center rounded-full bg-brand-primary px-4 py-1.5 text-xs font-semibold uppercase tracking-[0.18em] text-brand-bg shadow-soft hover:bg-cyan-400 transition-colors"
-                            data-i18n="header_btn_login"
-                            data-login-url="/login/?lang=<?= htmlspecialchars($currentLang) ?>">
-                        Login
-                    </button>
-                <?php else: ?>
-                    <!-- Eingeloggt: Avatar + Dropdown -->
-                    <button id="userAvatar"
-                            type="button"
-                            class="h-9 w-9 rounded-full border border-brand-border bg-brand-surface flex items-center justify-center text-xs font-semibold text-brand-text shadow-soft hover:border-brand-primary transition"
-                            aria-label="Mein Konto"
-                            aria-expanded="false"
-                            aria-haspopup="true">
-                        <span><?= htmlspecialchars($userInitials) ?></span>
-                    </button>
-
-                    <div id="userMenu"
-                         class="hidden absolute right-0 mt-2 w-44 rounded-xl bg-brand-surface border border-brand-border shadow-lg py-1 text-xs z-40">
-                        <a href="/dashboard/?lang=<?= htmlspecialchars($currentLang) ?>"
-                           class="flex items-center gap-2 px-3 py-2 text-brand-muted hover:text-brand-primary hover:bg-brand-bg/60 transition-colors"
-                           data-i18n="header_menu_dashboard">
-                            Dashboard
-                        </a>
-                        <button type="button"
-                                class="flex items-center gap-2 w-full text-left px-3 py-2 text-brand-muted hover:text-red-400 hover:bg-red-500/10 transition-colors"
-                                data-logout-link="true"
-                                data-logout-href="/auth/logout?lang=<?= htmlspecialchars($currentLang) ?>"
-                                data-i18n="header_menu_logout">
-                            Logout
-                        </button>
-                    </div>
-                <?php endif; ?>
-            </div>
-        </div>
-    </div>
-</header>
-
-<!-- Logout-Modal -->
-<div id="logoutModalBackdrop"
-     class="hidden fixed inset-0 z-50 flex items-center justify-center bg-black/60">
-    <div class="w-full max-w-sm rounded-2xl border border-brand-border bg-brand-surface shadow-soft p-6 space-y-4">
-        <h2 class="font-heading text-lg font-semibold text-brand-text" data-i18n="logout_title">
-            Wirklich abmelden?
-        </h2>
-        <p class="text-sm text-brand-muted" data-i18n="logout_text">
-            Du wirst von deinem USBCheck-Konto abgemeldet. Aktive Tests im Browser-Modus sind davon nicht betroffen.
-        </p>
-        <div class="flex justify-end gap-3 pt-2">
-            <button id="logoutCancel"
-                    type="button"
-                    class="px-4 py-2 rounded-full border border-brand-border text-xs font-semibold uppercase tracking-[0.18em] text-brand-muted hover:text-brand-primary hover:border-brand-primary transition-colors"
-                    data-i18n="logout_cancel">
-                Abbrechen
-            </button>
-            <button id="logoutConfirm"
-                    type="button"
-                    class="px-4 py-2 rounded-full bg-red-500 text-xs font-semibold uppercase tracking-[0.18em] text-white hover:bg-red-400 transition-colors"
-                    data-i18n="logout_confirm">
-                Ja, abmelden
-            </button>
-        </div>
-    </div>
-</div>

partials/structure/layout_end.php

@@ -1,79 +0,0 @@
-<?php
-// public/partials/layout_end.php
-?>
-    </main>
-
-    <!-- FOOTER -->
-    <?php 
-        tpl('footer'); 
-    ?>
-
-</div>
-<?php
-// CSS im Footer (falls benötigt)
-foreach ($GLOBALS['page_styles'] as $style) {
-    if ($style['pos'] !== 'footer') {
-        continue;
-    }
-
-    $href = $style['href'];
-    if (!empty($style['version'])) {
-        $href .= (str_contains($href, '?') ? '&' : '?') . 'v=' . urlencode($style['version']);
-    }
-
-    echo '<link rel="stylesheet" href="' . htmlspecialchars($href) . '">' . PHP_EOL;
-}
-
-// Scripts im Footer
-foreach ($GLOBALS['page_footer_scripts'] as $script) {
-    $src = $script['src'];
-    if (!empty($script['version'])) {
-        $src .= (str_contains($src, '?') ? '&' : '?') . 'v=' . urlencode($script['version']);
-    }
-
-    $attr = '';
-    if ($script['async']) {
-        $attr .= ' async';
-    } elseif ($script['defer']) {
-        $attr .= ' defer';
-    }
-    if ($script['type']) {
-        $attr .= ' type="' . htmlspecialchars($script['type']) . '"';
-    }
-
-    echo '<script src="' . htmlspecialchars($src) . '"' . $attr . '></script>' . PHP_EOL;
-}
-?>
-
-<!-- Logout-Modal -->
-<div id="logoutModalBackdrop"
-     class="hidden fixed inset-0 z-50 bg-black/60 backdrop-blur-sm">
-    <div class="min-h-full flex items-center justify-center p-4">
-        <div class="w-full max-w-sm rounded-2xl border border-brand-border bg-brand-surface shadow-soft p-6 space-y-4">
-            <h2 class="font-heading text-lg font-semibold text-brand-text" data-i18n="logout_modal_title">
-                Wirklich ausloggen?
-            </h2>
-            <p class="text-sm text-brand-muted" data-i18n="logout_modal_text">
-                Wenn du dich abmeldest, werden deine Sitzung und alle nicht gespeicherten Aktionen beendet. Du kannst dich jederzeit wieder einloggen.
-            </p>
-
-            <div class="flex justify-end gap-3 pt-2">
-                <button type="button"
-                        id="logoutCancel"
-                        class="inline-flex items-center justify-center rounded-full border border-brand-border px-4 py-1.5 text-xs font-semibold uppercase tracking-[0.18em] text-brand-muted hover:border-brand-primary hover:text-brand-primary transition-colors"
-                        data-i18n="logout_modal_cancel">
-                    Abbrechen
-                </button>
-                <button type="button"
-                        id="logoutConfirm"
-                        class="inline-flex items-center justify-center rounded-full bg-red-500/90 px-4 py-1.5 text-xs font-semibold uppercase tracking-[0.18em] text-white shadow-soft hover:bg-red-400 transition-colors"
-                        data-i18n="logout_modal_confirm">
-                    Ja, ausloggen
-                </button>
-            </div>
-        </div>
-    </div>
-</div>
-</body>
-</html>
-<?php tpl('matomo', 'structure'); ?>

partials/structure/layout_start.php

@@ -1,192 +0,0 @@
-<?php
-// public/partials/layout_start.php
-
-// Erwartet (vor require):
-// - $pageKey (string) – Seiten-Key für i18n, z. B. 'landing', 'fakecheck', 'login', 'dashboard'
-// - optional: $pageTitle (string)
-// - optional: $pageDescription (string)
-// - optional: $canonical (string)
-
-// -----------------------------------------------------------
-// Fallbacks & i18n Title/Description
-// -----------------------------------------------------------
-
-// Sprachen **immer** aus den GLOBALS holen (aus fileload.php)
-$availableLangs = $GLOBALS['availableLangs'] ?? [];
-
-// Page-Key Fallback
-if (!isset($pageKey) || !is_string($pageKey) || $pageKey === '') {
-    $pageKey = 'landing';
-}
-
-// Sprache: aus Globals (fileload.php) bzw. Fallback
-$lang = $GLOBALS['lang'] ?? (array_key_first($availableLangs) ?: 'en');
-
-// Title aus i18n, falls nichts explizit gesetzt wurde
-if (!isset($pageTitle) || !is_string($pageTitle) || $pageTitle === '') {
-    $pageTitle = i18n_get("pages.$pageKey.meta.title", app_primary_domain());
-}
-
-// Description aus i18n, falls nichts explizit gesetzt wurde
-if (!isset($pageDescription) || !is_string($pageDescription) || $pageDescription === '') {
-    $pageDescription = i18n_get("pages.$pageKey.meta.description", '');
-}
-
-// -----------------------------------------------------------
-// Standard-Scripts für Header-Interaktionen (Footer-Scripts)
-// -----------------------------------------------------------
-if (function_exists('tpl_add_script')) {
-    tpl_add_script('/assets/js/header.js', 'footer', true, false, '', null);
-    tpl_add_script('/assets/js/lang.js',   'footer', true, false, '', null);
-}
-
-// -----------------------------------------------------------
-// Globales CSS registrieren (z.B. main.css)
-// → Priority 'late', damit es Tailwind überschreiben kann
-// -----------------------------------------------------------
-if (function_exists('tpl_add_style')) {
-    tpl_add_style('/assets/css/base.css', 'early');
-    tpl_add_style('/assets/css/layout-main.css', 'normal');
-    tpl_add_style('/assets/css/header-extras.css', 'late');
-
-}
-
-// -----------------------------------------------------------
-// Canonical-URL bestimmen (zentral über Helper)
-// -----------------------------------------------------------
-$effectiveCanonical = app_canonical_url($canonical ?? null);
-
-?>
-<!DOCTYPE html>
-<html lang="<?= htmlspecialchars($lang) ?>">
-<head>
-    <meta charset="UTF-8">
-    <title><?= htmlspecialchars($pageTitle) ?></title>
-    <meta name="viewport" content="width=device-width, initial-scale=1">
-
-    <?php if ($pageDescription !== ''): ?>
-        <meta name="description" content="<?= htmlspecialchars($pageDescription) ?>">
-    <?php endif; ?>
-
-    <!-- Canonical URL -->
-    <link rel="canonical" href="<?= htmlspecialchars($effectiveCanonical) ?>">
-
-    <!-- Fonts -->
-    <link rel="preconnect" href="https://fonts.googleapis.com">
-    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
-    <link
-        href="https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600&family=Montserrat:wght@600;700;800&display=swap"
-        rel="stylesheet"
-    >
-
-    <!-- Tailwind Config -->
-    <script>
-        window.tailwind = window.tailwind || {};
-        window.tailwind.config = {
-            theme: {
-                extend: {
-                    colors: {
-                        'brand-primary': '#3a6ff8',
-                        'brand-primarySoft': '#e8f1ff',
-                        'brand-border': '#dfe6f4',
-                        'brand-bg': '#f9fbff',
-                        'brand-surface': '#ffffff',
-                        'brand-text': '#0f1f3d',
-                        'brand-muted': '#5f6b85'
-                    },
-                    fontFamily: {
-                        heading: ['"Montserrat"', '"Plus Jakarta Sans"', '"Inter"', 'system-ui', 'sans-serif']
-                    },
-                    borderRadius: {
-                        xl2: '1.75rem',
-                        xl3: '2.25rem'
-                    },
-                    boxShadow: {
-                        soft: '0 18px 45px rgba(58, 111, 248, 0.18)'
-                    }
-                }
-            }
-        };
-    </script>
-
-    <!-- Tailwind (Dev) -->
-    <script src="https://cdn.tailwindcss.com"></script>
-
-    <?php
-    // App-Config (usbConfig + i18n.available/current) ins Fenster schreiben
-    tpl('app_config', 'structure');
-
-    // -------------------------------------------------------
-    // CSS im Header aus der zentralen Registry
-    // -------------------------------------------------------
-    $styles = $GLOBALS['page_styles'] ?? [];
-
-    if (!empty($styles)) {
-        usort($styles, function ($a, $b) {
-            $order = ['early' => 0, 'normal' => 1, 'late' => 2];
-
-            $pa = $order[$a['priority'] ?? 'normal'] ?? 1;
-            $pb = $order[$b['priority'] ?? 'normal'] ?? 1;
-
-            return $pa <=> $pb;
-        });
-
-        foreach ($styles as $s) {
-            $href    = $s['href'] ?? '';
-            $version = $s['version'] ?? null;
-
-            if ($href === '') {
-                continue;
-            }
-
-            // Cache-Buster nur, wenn Version explizit gesetzt und nicht leer
-            if ($version !== null && $version !== '') {
-                $separator = (strpos($href, '?') === false) ? '?' : '&';
-                $href .= $separator . 'v=' . rawurlencode($version);
-            }
-
-            echo '<link rel="stylesheet" href="' . htmlspecialchars($href) . '">' . "\n";
-        }
-    }
-
-    // -------------------------------------------------------
-    // Scripts im Header aus der zentralen Registry
-    // -------------------------------------------------------
-    $headerScripts = $GLOBALS['page_header_scripts'] ?? [];
-
-    foreach ($headerScripts as $script) {
-        $src     = $script['src']     ?? '';
-        $version = $script['version'] ?? null;
-
-        if ($src === '') {
-            continue;
-        }
-
-        if ($version !== null && $version !== '') {
-            $src .= (str_contains($src, '?') ? '&' : '?') . 'v=' . urlencode($version);
-        }
-
-        $attr = '';
-        if (!empty($script['async'])) {
-            $attr .= ' async';
-        } elseif (!empty($script['defer'])) {
-            $attr .= ' defer';
-        }
-        if (!empty($script['type'])) {
-            $attr .= ' type="' . htmlspecialchars($script['type']) . '"';
-        }
-
-        echo '<script src="' . htmlspecialchars($src) . '"' . $attr . '></script>' . PHP_EOL;
-    }
-    ?>
-
-</head>
-
-<body class="bg-brand-bg text-brand-text font-sans antialiased scroll-smooth">
-<div class="min-h-screen flex flex-col">
-
-    <!-- HEADER -->
-    <?php tpl('header'); ?>
-
-    <!-- MAIN CONTENT -->
-    <main class="flex-1">

partials/structure/matomo.php

@@ -1,39 +0,0 @@
-<?php if (!defined('MATOMO_SITE_ID')) return; ?>
-<?php if (!defined('MATOMO_ENABLED') || !MATOMO_ENABLED) return; ?>
-<?php
-$matomoDomains = [];
-$primaryDomain   = app_primary_domain();
-$fakecheckDomain = app_fakecheck_domain();
-
-$matomoDomains[] = '*.' . $primaryDomain;
-$matomoDomains[] = '*.' . $fakecheckDomain;
-$matomoDomains[] = '*.' . $primaryDomain . '/fakecheck';
-?>
-
-<!-- Matomo -->
-<script>
-    var _paq = window._paq = window._paq || [];
-    _paq.push(["setDomains", <?= json_encode($matomoDomains, JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE) ?>]);
-    _paq.push(['trackPageView']);
-    _paq.push(['enableLinkTracking']);
-
-    (function() {
-        var u = "<?= rtrim(MATOMO_URL, '/') ?>/";
-        _paq.push(['setTrackerUrl', u + 'matomo.php']);
-        _paq.push(['setSiteId', '<?= MATOMO_SITE_ID ?>']);
-
-        var d=document, g=d.createElement('script'), s=d.getElementsByTagName('script')[0];
-        g.async=true;
-        g.src=u + 'matomo.js';
-        s.parentNode.insertBefore(g,s);
-    })();
-</script>
-
-<noscript>
-    <p>
-        <img referrerpolicy="no-referrer-when-downgrade"
-             src="<?= rtrim(MATOMO_URL,'/') ?>/matomo.php?idsite=<?= MATOMO_SITE_ID ?>&amp;rec=1"
-             style="border:0;" alt="" />
-    </p>
-</noscript>
-<!-- End Matomo -->

projektdetails.txt

@@ -1,91 +0,0 @@
-Projekt Details:
-Online Angebot einen USB Speicherstick zu überprüfen. Sprich, stimmt die vom Hersteller angegebene Größe mit der tatsächlichen überein.
-Hierzu soll es zwei Varianten geben:
-- rein online basiert, die nur Basis checks durchführt
-- der Nutzer lädt eine Binary herunter, die es der Website ermöglicht eine detailliertere bzw. tiefergehende Prüfung vorzunehmen.
-
-Ggf. können die Funktionen später erweitert werden.
-
-Domains:
-- usbcheck.it
-- usb-check.it
-- ismyusbfake.it
-- ismyusbfake.com
-- usb-check.com
-- fakeusbcheck.com
-
-Domainaufbau:
-Hauptdomain: usbcheck.it (Staging: staging.usbcheck.it)
-Domains welche  auf diese umgeleitet werden: usb-check.it, usb-check.com
-
-SocialMedia/LandingPage Domain: ismyusbfake.com (Staging: staging.ismyusbfake.com)
-Domains welche  auf diese umgeleitet werden: ismyusbfake.it, fakeusbcheck.com
-
-
-Ordnerstruktur usbcheck.it auf Gitlab:
-config/
-- prod/     => Nutzung für Configdateien
-- staging/  => Nutzung für Configdateien staging.
-public/     => hier liegen die generellen Seiten
-src/        => Nutzung für generelle Tools (z.B. API)
-
-Ordnerstruktur usbcheck.it auf Server:
-web/config/ => Nutzung für Configdateien
-web/public/ => hier zeigt die usbcheck.it hin
-web/src/    => Nutzung für generelle Tools (z.B. API)
-
-Ordnerstruktur staging.usbcheck.it auf Server:
-staging/config/ => Nutzung für Configdateien
-staging/public/ => hier zeigt die usbcheck.it hin
-staging/src/    => Nutzung für generelle Tools (z.B. API)
-
-
-Die Domain ismyusbfake.com zeigt auf einen SubOrdner in web/public/fakecheck und dient als Landingpage, Layout etc. muss von der Hauptdomain übernommen werden
-Die Domain staging.ismyusbfake.com zeigt auf einen SubOrdner in staging/public/fakecheck und dient als Landingpage, Layout etc. muss von der Hauptdomain übernommen werden
-
-
-Farbcodes:
-{
-  "primary": {
-    "brand_blue": "#0051FF",
-    "deep_gray": "#1A1A1A",
-    "silver": "#C8CBD0"
-  },
-  "secondary": {
-    "green_check": "#03C160",
-    "error_red": "#E63946",
-    "amber_yellow": "#FFDA3D"
-  },
-  "neutral": {
-    "light_gray": "#F4F4F4",
-    "very_light_gray": "#FAFAFA",
-    "off_white": "#FFFFFF"
-  }
-}
-
-
-Typografie:
-{
-  "typography": {
-    "heading": {
-      "font_family": "Montserrat",
-      "font_weight": 700,
-      "style_name": "Montserrat Bold"
-    },
-    "body": {
-      "font_family": "Inter",
-      "font_weight": 400,
-      "style_name": "Inter Regular"
-    },
-    "subheading": {
-      "font_family": "Montserrat",
-      "font_weight": 600,
-      "style_name": "Montserrat SemiBold"
-    }
-  }
-}
-
-Logos:
-public/img/logo.png => Logo nur mit Domain
-public/img/logo_slogan.png => Logo mit Domain und Slogan
-public/img/stick_blank.png => USB Stick ohne Text

public/.htaccess

@@ -1,63 +0,0 @@
-RewriteEngine On
-
-# ---------------------------------------------------------
-# 1) Nur Root von *.ismyusbfake.com nach /fakecheck/ umleiten
-# ---------------------------------------------------------
-RewriteCond %{HTTP_HOST} (^|\.)ismyusbfake\.com$ [NC]
-RewriteRule ^$ /fakecheck/ [L,R=301]
-
-# 1b) Subpath weiterreichen: /xyz → /fakecheck/?referrer=xyz
-RewriteCond %{HTTP_HOST} (^|\.)ismyusbfake\.com$ [NC]
-RewriteCond %{REQUEST_URI} !^/fakecheck(/|$) [NC]
-RewriteCond %{REQUEST_URI} ^/([^/]+)/?$ [NC]
-RewriteRule ^ /fakecheck/?referrer=%1 [L,R=302]
-
-# ---------------------------------------------------------
-# 2) Uploads schützen
-# ---------------------------------------------------------
-RewriteRule ^uploads/avatar/ - [F]
-
-# ---------------------------------------------------------
-# 3) Auth-Routen
-# ---------------------------------------------------------
-RewriteRule ^auth/login/?$    auth/login.php    [L]
-RewriteRule ^auth/register/?$ auth/register.php [L]
-RewriteRule ^auth/logout/?$   auth/logout.php   [L]
-
-# ---------------------------------------------------------
-# 4) Tools-Regel
-#    /tools/foo.php  → landingpage/tools/foo.php
-# ---------------------------------------------------------
-RewriteCond %{REQUEST_URI} ^/tools/ [NC]
-RewriteCond %{REQUEST_FILENAME} !-f
-RewriteCond %{REQUEST_FILENAME} !-d
-RewriteRule ^tools/(.*)$ landingpage/tools/$1 [L]
-
-# ---------------------------------------------------------
-# 5) Generische Landingpage-Regel
-# ---------------------------------------------------------
-RewriteCond %{REQUEST_FILENAME} !-f
-RewriteCond %{REQUEST_FILENAME} !-d
-RewriteCond %{REQUEST_URI} !^/(auth|assets|uploads|landingpage|tools|_errors)/ [NC]
-RewriteCond %{REQUEST_URI} ^/([^/]+)/?$ [NC]
-RewriteCond %{DOCUMENT_ROOT}/landingpage/%1/index.php -f
-RewriteRule ^ landingpage/%1/index.php [L]
-
-# ---------------------------------------------------------
-# 6) Fallback-Regeln (.php und /index.php)
-# ---------------------------------------------------------
-RewriteCond %{REQUEST_FILENAME} !-d
-RewriteCond %{REQUEST_FILENAME}.php -f
-RewriteRule ^(.+?)/?$ $1.php [L]
-
-RewriteCond %{REQUEST_FILENAME} !-d
-RewriteCond %{REQUEST_FILENAME}/index.php -f
-RewriteRule ^(.+?)/?$ $1/index.php [L]
-
-# ---------------------------------------------------------
-# 7) Globaler 404-Fallback **IMMER deine eigene Fehlerseite**
-# ---------------------------------------------------------
-RewriteCond %{REQUEST_FILENAME} !-f
-RewriteCond %{REQUEST_FILENAME} !-d
-RewriteCond %{REQUEST_URI} !^/(assets|uploads|auth|landingpage|tools|_errors)/ [NC]
-RewriteRule ^ _errors/404.php [L]

public/_errors/.htaccess

@@ -1,6 +0,0 @@
-RewriteEngine On
-
-# nur PHP in _errors vor direktem Aufruf schützen
-RewriteCond %{THE_REQUEST} \s/+_errors/ [NC]
-RewriteCond %{REQUEST_URI} \.php$ [NC]
-RewriteRule ^ - [R=404,L]

public/_errors/404.php

@@ -1,44 +0,0 @@
-<?php
-// public/_errors/404.php
-
-require __DIR__ . '/../../config/fileload.php';
-
-// Sprache aus Query oder Default
-$lang = $_GET['lang'] ?? 'de';
-$lang = in_array($lang, ['de','en','it','fr']) ? $lang : 'de';
-
-// Titel & Description
-$pageTitle       = 'Seite nicht gefunden – ' . app_primary_domain();
-$pageDescription = 'Die angeforderte Seite wurde nicht gefunden.';
-$navAnchors      = []; // Navigation auf der 404 deaktiviert
-
-tpl('layout_start', 'structure');
-?>
-
-<!-- Vollflächiges Hintergrundbild -->
-<div class="relative w-full min-h-[70vh] flex items-center justify-center text-center">
-
-    <!-- Hintergrund -->
-    <div class="absolute inset-0 bg-cover bg-center"
-         style="background-image: url('/_errors/img/404.png'); filter: brightness(0.45);">
-    </div>
-
-    <!-- Inhalt -->
-    <div class="relative z-10 px-6 py-20 max-w-2xl mx-auto">
-        <h1 class="text-5xl sm:text-6xl font-heading font-bold text-white drop-shadow-lg mb-4">
-            404
-        </h1>
-
-        <p class="text-brand-muted text-lg sm:text-xl mb-8 text-white/90 drop-shadow">
-            Die angeforderte Seite wurde nicht gefunden.
-        </p>
-
-        <a href="/?lang=<?= htmlspecialchars($lang) ?>"
-           class="inline-block rounded-full bg-brand-primary text-brand-bg px-8 py-3 text-sm sm:text-base font-semibold hover:bg-blue-400 transition-colors shadow-lg">
-            Zurück zur Startseite
-        </a>
-    </div>
-</div>
-
-<?php
-tpl('layout_end', 'structure');

public/assets/css/auth.css

@@ -1,191 +0,0 @@
-/* =====================================================================
-   Auth / Forms / Account
-   ===================================================================== */
-
-.auth-page {
-  padding: 4rem 0;
-}
-
-.auth-layout {
-  max-width: 480px;
-  margin: 0 auto;
-}
-
-.auth-card {
-  background: #fff;
-  border-radius: 18px;
-  padding: 1.6rem 1.8rem;
-  box-shadow: var(--shadow-soft);
-  border: 1px solid rgba(200, 203, 208, 0.5);
-}
-
-.auth-title {
-  font-family: var(--font-heading);
-  font-weight: 700;
-  font-size: 1.5rem;
-  margin: 0 0 0.35rem;
-  color: var(--deep-gray);
-}
-
-.auth-subtitle {
-  font-size: 0.95rem;
-  color: #555;
-  margin: 0 0 1.5rem;
-}
-
-.auth-flash-success,
-.auth-flash-error {
-  border-radius: 12px;
-  padding: 0.75rem 0.9rem;
-  font-size: 0.9rem;
-  margin-bottom: 1rem;
-}
-
-.auth-flash-success {
-  background: #e6f9ef;
-  border: 1px solid rgba(3, 193, 96, 0.4);
-  color: #145c32;
-}
-
-.auth-flash-error {
-  background: #fde7ea;
-  border: 1px solid rgba(230, 57, 70, 0.4);
-  color: #7f1d1d;
-}
-
-/* Forms */
-
-.form-row {
-  margin-bottom: 1rem;
-}
-
-.form-label {
-  display: block;
-  font-size: 0.85rem;
-  color: #555;
-  margin-bottom: 0.3rem;
-}
-
-.form-input,
-.form-select,
-.form-textarea {
-  width: 100%;
-  border-radius: 10px;
-  border: 1px solid var(--silver);
-  padding: 0.55rem 0.7rem;
-  font-size: 0.95rem;
-  font-family: inherit;
-  transition:
-    border-color 0.12s ease,
-    box-shadow 0.12s ease,
-    background-color 0.12s ease;
-  background: #fff;
-}
-
-.form-input:focus,
-.form-select:focus,
-.form-textarea:focus {
-  outline: none;
-  border-color: var(--brand-blue);
-  box-shadow: 0 0 0 1px rgba(0, 81, 255, 0.15);
-  background: #fff;
-}
-
-.form-input[readonly],
-.form-select[readonly] {
-  background: #f3f4f6;
-  color: #666;
-}
-
-.form-error {
-  margin-top: 0.3rem;
-  font-size: 0.8rem;
-  color: var(--error-red);
-}
-
-.form-help {
-  margin-top: 0.3rem;
-  font-size: 0.8rem;
-  color: #777;
-}
-
-.form-actions {
-  margin-top: 1.5rem;
-  display: flex;
-  align-items: center;
-  justify-content: space-between;
-  gap: 0.75rem;
-}
-
-.auth-link {
-  font-size: 0.9rem;
-  color: var(--brand-blue);
-  text-decoration: none;
-}
-
-.auth-link:hover {
-  text-decoration: underline;
-}
-
-/* Account page */
-
-.account-page {
-  padding: 4rem 0;
-}
-
-.account-grid {
-  display: grid;
-  grid-template-columns: minmax(0, 2fr) minmax(0, 1.2fr);
-  gap: 2rem;
-}
-
-.account-card {
-  background: #fff;
-  border-radius: 18px;
-  padding: 1.6rem 1.8rem;
-  box-shadow: var(--shadow-soft);
-  border: 1px solid rgba(200, 203, 208, 0.5);
-}
-
-.account-title {
-  font-family: var(--font-heading);
-  font-weight: 700;
-  font-size: 1.4rem;
-  margin: 0 0 0.4rem;
-  color: var(--deep-gray);
-}
-
-.account-subtitle {
-  margin: 0 0 1.4rem;
-  font-size: 0.95rem;
-  color: #555;
-}
-
-.account-meta {
-  font-size: 0.85rem;
-  color: #777;
-}
-
-.account-avatar-preview {
-  display: flex;
-  align-items: center;
-  gap: 1rem;
-  margin-top: 0.75rem;
-}
-
-.account-avatar-preview .user-avatar {
-  width: 44px;
-  height: 44px;
-  font-size: 1.05rem;
-}
-
-.account-avatar-note {
-  font-size: 0.85rem;
-  color: #666;
-}
-
-@media (max-width: 900px) {
-  .account-grid {
-    grid-template-columns: 1fr;
-  }
-}

public/assets/css/base.css

@@ -1,136 +0,0 @@
-:root {
-  /* Brand Colors */
-  --brand-blue: #3a6ff8;
-  --deep-gray: #0f1f3d;
-  --silver: #d9e1f2;
-  --green-check: #1fce88;
-  --error-red: #f46666;
-  --amber-yellow: #ffb347;
-  --light-gray: #edf2fb;
-  --very-light-gray: #f9fbff;
-  --off-white: #ffffff;
-
-  /* Radii & Shadows */
-  --radius-lg: 16px;
-  --radius-pill: 999px;
-  --shadow-soft: 0 18px 45px rgba(55, 101, 202, 0.15);
-
-  /* Fonts */
-  --font-body: 'Inter', system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
-  --font-heading: 'Montserrat', system-ui, sans-serif;
-}
-
-/* =====================================================================
-   Global Reset & Base
-   ===================================================================== */
-
-*,
-*::before,
-*::after {
-  box-sizing: border-box;
-}
-
-html,
-body {
-  margin: 0;
-  padding: 0;
-}
-
-body {
-  font-family: var(--font-body);
-  font-weight: 400;
-  color: #1f2a44;
-  background: linear-gradient(180deg, #ffffff 0%, #f6f8ff 50%, #f1f6ff 100%);
-}
-
-/* Layout helpers */
-
-.container {
-  width: 100%;
-  max-width: 1120px;
-  margin: 0 auto;
-  padding: 0 1.5rem;
-}
-
-.hidden {
-  display: none !important;
-}
-
-/* =====================================================================
-   Buttons & Avatar (global nutzbar)
-   ===================================================================== */
-
-.btn {
-  display: inline-flex;
-  align-items: center;
-  justify-content: center;
-  border-radius: var(--radius-pill);
-  border: none;
-  font-family: var(--font-heading);
-  font-weight: 600;
-  font-size: 0.95rem;
-  padding: 0.6rem 1.4rem;
-  cursor: pointer;
-  text-decoration: none;
-  transition:
-    transform 0.08s ease,
-    box-shadow 0.08s ease,
-    background 0.1s ease;
-}
-
-.btn-primary {
-  background: linear-gradient(135deg, var(--brand-blue), #2a73ff);
-  color: #fff;
-  box-shadow: 0 12px 24px rgba(0, 81, 255, 0.35);
-}
-
-.btn-primary:hover {
-  transform: translateY(-1px);
-  box-shadow: 0 16px 32px rgba(0, 81, 255, 0.4);
-}
-
-.btn-outline {
-  border: 1px solid var(--silver);
-  background: #fff;
-  color: #333;
-}
-
-.btn-outline:hover {
-  background: var(--very-light-gray);
-}
-
-.btn-ghost {
-  border-radius: var(--radius-pill);
-  padding-inline: 1.2rem;
-  background: transparent;
-  border: 1px solid transparent;
-  color: #333;
-}
-
-.btn-ghost:hover {
-  border-color: var(--silver);
-  background: rgba(0, 0, 0, 0.02);
-}
-
-.btn-disabled {
-  background: var(--light-gray);
-  color: #888;
-  cursor: not-allowed;
-  box-shadow: none;
-}
-
-/* Avatar */
-
-.user-avatar {
-  width: 36px;
-  height: 36px;
-  border-radius: 50%;
-  background: var(--deep-gray);
-  color: #fff;
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  font-family: var(--font-heading);
-  font-weight: 700;
-  font-size: 0.9rem;
-}

public/assets/css/fakecheck.css

@@ -1,452 +0,0 @@
-/* /public/assets/css/fakecheck.css */
-
-:root {
-    --fc-brand-primary: var(--brand-blue, #3a6ff8);
-    --fc-brand-primary-soft: rgba(58, 111, 248, 0.12);
-    --fc-surface: #ffffff;
-    --fc-surface-muted: #f5f8ff;
-    --fc-border: rgba(58, 111, 248, 0.15);
-    --fc-text: #1f2a44;
-    --fc-text-muted: #5f6b85;
-    --fc-success: #1fce88;
-    --fc-warning: #ffb347;
-    --fc-danger: #f46666;
-}
-
-.fc-container {
-    max-width: 1120px;
-    margin: 0 auto;
-    padding: 2rem 1.25rem 3rem;
-    color: var(--fc-text);
-}
-
-.fc-header {
-    display: flex;
-    flex-wrap: wrap;
-    justify-content: space-between;
-    gap: 1rem;
-    margin-bottom: 1.75rem;
-    align-items: center;
-}
-
-.fc-header-text h2 {
-    margin: 0 0 0.3rem;
-    font-family: var(--font-heading, "Montserrat", system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif);
-    font-weight: 700;
-    font-size: clamp(1.6rem, 2.3vw, 2rem);
-    color: var(--fc-text);
-}
-
-.fc-header-text p {
-    margin: 0;
-    color: var(--fc-text-muted);
-    font-size: 0.95rem;
-}
-
-.fc-header-badge {
-    display: inline-flex;
-    align-items: center;
-    gap: 0.4rem;
-    padding: 0.35rem 0.85rem;
-    border-radius: 999px;
-    background: var(--fc-brand-primary-soft);
-    color: var(--fc-text);
-    font-size: 0.75rem;
-    border: 1px solid var(--fc-border);
-}
-
-.fc-header-badge .dot {
-    width: 8px;
-    height: 8px;
-    border-radius: 999px;
-    background: var(--fc-success);
-}
-
-.fc-layout {
-    display: grid;
-    grid-template-columns: minmax(0, 2fr) minmax(0, 1.4fr);
-    gap: 1.5rem;
-}
-
-@media (max-width: 900px) {
-    .fc-layout {
-        grid-template-columns: minmax(0, 1fr);
-    }
-}
-
-/* Karten */
-
-.fc-card {
-    background: var(--fc-surface);
-    border-radius: 24px;
-    border: 1px solid var(--fc-border);
-    padding: 1.75rem 1.8rem 2rem;
-    box-shadow: 0 18px 40px rgba(15, 33, 66, 0.08);
-}
-
-.fc-card-title {
-    margin: 0 0 0.45rem;
-    font-size: 1.05rem;
-    font-family: var(--font-heading, "Montserrat", system-ui, sans-serif);
-    font-weight: 600;
-    color: var(--fc-text);
-}
-
-.fc-card-subtitle {
-    margin: 0 0 0.8rem;
-    font-size: 0.9rem;
-    color: var(--fc-text-muted);
-}
-
-/* Buttons */
-
-.fc-actions {
-    display: flex;
-    flex-wrap: wrap;
-    gap: 0.75rem;
-    margin-bottom: 0.4rem;
-}
-
-.fc-actions-bottom {
-    margin-top: 0.9rem;
-}
-
-.fc-btn {
-    display: inline-flex;
-    align-items: center;
-    justify-content: center;
-    gap: 0.4rem;
-    padding: 0.6rem 1.25rem;
-    border-radius: 999px;
-    border: 1px solid transparent;
-    background: linear-gradient(135deg, var(--fc-brand-primary), #2a73ff);
-    color: #fff;
-    font-size: 0.92rem;
-    cursor: pointer;
-    text-decoration: none;
-    transition:
-        transform 0.1s ease,
-        box-shadow 0.1s ease,
-        background 0.15s ease;
-    white-space: nowrap;
-    box-shadow: 0 12px 28px rgba(58, 111, 248, 0.35);
-}
-
-.fc-btn[disabled] {
-    opacity: 0.4;
-    cursor: not-allowed;
-    transform: none;
-    box-shadow: none;
-}
-
-.fc-btn:hover:not([disabled]) {
-    transform: translateY(-1px);
-    box-shadow: 0 16px 32px rgba(58, 111, 248, 0.45);
-}
-
-.fc-btn-secondary {
-    background: var(--fc-surface-muted);
-    border-color: var(--fc-border);
-    color: var(--fc-text-muted);
-    box-shadow: none;
-}
-
-.fc-btn-secondary:hover:not([disabled]) {
-    background: #fff;
-    color: var(--fc-brand-primary);
-}
-
-/* Modus-Kacheln */
-
-.fc-mode-grid {
-    display: grid;
-    grid-template-columns: repeat(2, minmax(0, 1fr));
-    gap: 0.75rem;
-    margin-top: 0.75rem;
-}
-
-@media (max-width: 600px) {
-    .fc-mode-grid {
-        grid-template-columns: minmax(0, 1fr);
-    }
-}
-
-.fc-mode-tile {
-    border-radius: 18px;
-    padding: 1rem 1.1rem;
-    border: 1px solid var(--fc-border);
-    background: linear-gradient(140deg, #ffffff 0%, #f3f7ff 100%);
-    cursor: pointer;
-    transition:
-        border 0.15s ease,
-        box-shadow 0.15s ease,
-        transform 0.1s ease;
-}
-
-.fc-mode-tile.selected {
-    border-color: rgba(58, 111, 248, 0.45);
-    box-shadow: 0 15px 35px rgba(58, 111, 248, 0.18);
-}
-
-.fc-mode-tile h4 {
-    margin: 0 0 0.35rem;
-    font-size: 1rem;
-    font-weight: 600;
-    color: var(--fc-text);
-}
-
-.fc-mode-tile p {
-    margin: 0;
-    font-size: 0.84rem;
-    color: var(--fc-text-muted);
-}
-
-.fc-mode-tile small {
-    display: block;
-    margin-top: 0.3rem;
-    font-size: 0.72rem;
-    color: var(--fc-text-muted);
-}
-
-.fc-mode-tile .pill {
-    display: inline-flex;
-    align-items: center;
-    padding: 0.12rem 0.55rem;
-    border-radius: 999px;
-    border: 1px solid var(--fc-border);
-    font-size: 0.7rem;
-    color: var(--fc-text-muted);
-    background: var(--fc-surface);
-}
-
-/* Status & Log */
-
-.fc-status-line {
-    display: flex;
-    flex-wrap: wrap;
-    align-items: center;
-    justify-content: space-between;
-    gap: 0.75rem;
-    margin: 1.1rem 0;
-    font-size: 0.85rem;
-    color: var(--fc-text-muted);
-}
-
-.fc-tag {
-    display: inline-flex;
-    align-items: center;
-    border-radius: 999px;
-    padding: 0.15rem 0.75rem;
-    border: 1px dashed var(--fc-border);
-    font-size: 0.75rem;
-    color: var(--fc-text);
-    background: var(--fc-surface-muted);
-}
-
-.fc-progress {
-    width: 100%;
-    height: 8px;
-    border-radius: 999px;
-    background: var(--fc-surface-muted);
-    overflow: hidden;
-}
-
-.fc-progress-inner {
-    height: 100%;
-    width: 0%;
-    border-radius: 999px;
-    background: linear-gradient(90deg, var(--fc-brand-primary), #7facff);
-    transition: width 0.2s ease-out;
-}
-
-.fc-log {
-    margin-top: 1rem;
-    background: var(--fc-surface-muted);
-    border-radius: 16px;
-    padding: 1rem;
-    max-height: 240px;
-    overflow-y: auto;
-    border: 1px solid rgba(58, 111, 248, 0.08);
-    font-size: 0.8rem;
-    color: var(--fc-text);
-}
-
-.fc-log-line {
-    display: flex;
-    gap: 0.4rem;
-    margin-bottom: 0.35rem;
-}
-
-.fc-log-line strong {
-    color: var(--fc-text-muted);
-    font-size: 0.72rem;
-    text-transform: uppercase;
-    letter-spacing: 0.08em;
-}
-
-/* Result cards */
-
-.fc-overall-status-wrap {
-    margin-bottom: 1rem;
-}
-
-.fc-pill-status {
-    display: inline-flex;
-    align-items: center;
-    gap: 0.4rem;
-    padding: 0.4rem 0.9rem;
-    border-radius: 999px;
-    font-size: 0.8rem;
-    font-weight: 600;
-    border: 1px solid transparent;
-}
-
-.fc-pill-status .fc-pill-dot {
-    width: 8px;
-    height: 8px;
-    border-radius: 999px;
-    background: currentColor;
-}
-
-.fc-pill-ok {
-    background: rgba(31, 206, 136, 0.15);
-    color: var(--fc-success);
-    border-color: rgba(31, 206, 136, 0.25);
-}
-
-.fc-pill-warn {
-    background: rgba(255, 179, 71, 0.15);
-    color: var(--fc-warning);
-    border-color: rgba(255, 179, 71, 0.3);
-}
-
-.fc-pill-bad {
-    background: rgba(244, 102, 102, 0.15);
-    color: var(--fc-danger);
-    border-color: rgba(244, 102, 102, 0.3);
-}
-
-.fc-kv-list {
-    display: grid;
-    grid-template-columns: repeat(2, minmax(0, 1fr));
-    gap: 0.5rem 0.75rem;
-    margin: 1rem 0;
-    font-size: 0.85rem;
-    color: var(--fc-text);
-}
-
-@media (max-width: 500px) {
-    .fc-kv-list {
-        grid-template-columns: minmax(0, 1fr);
-    }
-}
-
-.fc-kv-item dt {
-    font-size: 0.72rem;
-    text-transform: uppercase;
-    letter-spacing: 0.08em;
-    color: var(--fc-text-muted);
-    margin-bottom: 0.1rem;
-}
-
-.fc-alert {
-    border-radius: 16px;
-    padding: 0.8rem 1rem;
-    font-size: 0.82rem;
-    margin: 0.4rem 0;
-}
-
-.fc-alert-warn {
-    background: rgba(255, 179, 71, 0.12);
-    border: 1px solid rgba(255, 179, 71, 0.4);
-    color: #ab680d;
-}
-
-.fc-alert-info {
-    background: rgba(58, 111, 248, 0.08);
-    border: 1px solid rgba(58, 111, 248, 0.3);
-    color: var(--fc-text);
-}
-
-.fc-alert-error {
-    background: rgba(244, 102, 102, 0.12);
-    border: 1px solid rgba(244, 102, 102, 0.35);
-    color: #b73232;
-}
-
-.fc-help {
-    font-size: 0.8rem;
-    color: var(--fc-text-muted);
-    margin: 0.55rem 0;
-}
-
-.fc-log code,
-.fc-log kbd {
-    font-family: "JetBrains Mono", "SFMono-Regular", Menlo, Consolas, monospace;
-}
-
-/* Serial check widget */
-
-#serialcheck-root {
-    margin-top: 2.5rem;
-}
-
-#serialcheck-form {
-    display: grid;
-    grid-template-columns: repeat(2, minmax(0, 1fr));
-    gap: 0.9rem;
-}
-
-@media (max-width: 640px) {
-    #serialcheck-form {
-        grid-template-columns: minmax(0, 1fr);
-    }
-}
-
-#serialcheck-form label {
-    display: block;
-    font-size: 0.72rem;
-    text-transform: uppercase;
-    letter-spacing: 0.08em;
-    color: var(--fc-text-muted);
-    margin-bottom: 0.2rem;
-}
-
-#serialcheck-form input {
-    width: 100%;
-    border-radius: 12px;
-    border: 1px solid var(--fc-border);
-    padding: 0.5rem 0.75rem;
-    font-size: 0.9rem;
-    color: var(--fc-text);
-    background: var(--fc-surface);
-}
-
-#serialcheck-result {
-    margin-top: 1.2rem;
-    border-radius: 20px;
-    border: 1px solid var(--fc-border);
-    background: var(--fc-surface);
-    padding: 1.2rem;
-}
-
-#serialcheck-error {
-    margin-top: 1rem;
-    border-radius: 14px;
-    border: 1px solid rgba(244, 102, 102, 0.4);
-    background: rgba(244, 102, 102, 0.12);
-    color: #b73232;
-    padding: 0.8rem 1rem;
-    font-size: 0.85rem;
-}
-
-/* Log Scrollbar */
-
-.fc-log::-webkit-scrollbar {
-    width: 6px;
-}
-
-.fc-log::-webkit-scrollbar-thumb {
-    background: rgba(58, 111, 248, 0.3);
-    border-radius: 999px;
-}

public/assets/css/header-extras.css

@@ -1,104 +0,0 @@
-/* =====================================================================
-   USBCheck Header Dropdowns (neuer Header) + Logout-Modal
-   ===================================================================== */
-
-/* Dropdown Panels für Sprach- & User-Menü */
-
-#langMenu,
-#userMenu {
-  background: rgba(255, 255, 255, 0.96);
-  border-radius: 12px;
-  border: 1px solid rgba(200, 203, 208, 0.85);
-  box-shadow: var(--shadow-soft);
-  backdrop-filter: blur(10px);
-}
-
-#langMenu .lang-pill,
-#userMenu a,
-#userMenu button {
-  background: transparent;
-}
-
-#langMenu .lang-pill:hover,
-#userMenu a:hover,
-#userMenu button:hover {
-  background: rgba(237, 242, 251, 0.95);
-}
-
-/* Logout-Modal Overlay & Panel */
-
-#logoutModalBackdrop {
-  background: rgba(15, 31, 61, 0.32);
-  backdrop-filter: blur(4px);
-}
-
-#logoutModalBackdrop > div {
-  background: #ffffff;
-  border-radius: 24px;
-  border: 1px solid rgba(200, 203, 208, 0.85);
-  box-shadow: var(--shadow-soft);
-  padding: 1.8rem 2rem;
-}
-
-#logoutModalBackdrop h2 {
-  font-family: var(--font-heading);
-  font-weight: 700;
-  font-size: 1.25rem;
-  color: var(--deep-gray);
-  margin-bottom: 0.4rem;
-}
-
-#logoutModalBackdrop p {
-  font-size: 0.95rem;
-  color: #555;
-}
-
-/* Cancel Button */
-
-#logoutCancel {
-  border-radius: var(--radius-pill);
-  border: 1px solid var(--silver);
-  background: #fff;
-  color: #555;
-  font-family: var(--font-heading);
-  font-weight: 600;
-  font-size: 0.8rem;
-  letter-spacing: 0.18em;
-  text-transform: uppercase;
-  padding: 0.45rem 1.4rem;
-  transition:
-    background 0.12s ease,
-    box-shadow 0.12s ease,
-    transform 0.08s ease;
-}
-
-#logoutCancel:hover {
-  background: var(--very-light-gray);
-  transform: translateY(-1px);
-}
-
-/* Confirm Button (Danger) */
-
-#logoutConfirm {
-  border-radius: var(--radius-pill);
-  border: none;
-  background: linear-gradient(135deg, var(--error-red), #ff7a7a);
-  color: #fff;
-  font-family: var(--font-heading);
-  font-weight: 600;
-  font-size: 0.8rem;
-  letter-spacing: 0.18em;
-  text-transform: uppercase;
-  padding: 0.45rem 1.6rem;
-  box-shadow: 0 12px 24px rgba(244, 102, 102, 0.35);
-  transition:
-    background 0.12s ease,
-    box-shadow 0.12s ease,
-    transform 0.08s ease;
-}
-
-#logoutConfirm:hover {
-  background: linear-gradient(135deg, #ff7a7a, var(--error-red));
-  box-shadow: 0 16px 30px rgba(244, 102, 102, 0.45);
-  transform: translateY(-1px);
-}

public/assets/css/layout-main.css

@@ -1,655 +0,0 @@
-/* =====================================================================
-   Header (legacy Layout – kann parallel zur neuen Tailwind-Header-Partial existieren)
-   ===================================================================== */
-
-.site-header {
-  position: sticky;
-  top: 0;
-  z-index: 20;
-  backdrop-filter: blur(10px);
-  background: rgba(250, 250, 250, 0.92);
-  border-bottom: 1px solid rgba(200, 203, 208, 0.4);
-}
-
-.header-inner {
-  display: flex;
-  align-items: center;
-  justify-content: space-between;
-  height: 72px;
-}
-
-.logo-img {
-  height: 36px;
-  display: block;
-}
-
-.main-nav {
-  display: none;
-  gap: 1.5rem;
-  margin-left: 2rem;
-}
-
-.nav-link {
-  font-family: var(--font-heading);
-  font-weight: 600;
-  font-size: 0.95rem;
-  text-decoration: none;
-  color: #444;
-}
-
-.nav-link:hover {
-  color: var(--brand-blue);
-}
-
-.header-actions {
-  display: flex;
-  align-items: center;
-  gap: 1rem;
-}
-
-/* Language switcher (alte Variante) */
-
-.lang-switch {
-  position: relative;
-}
-
-.lang-current {
-  border-radius: var(--radius-pill);
-  border: 1px solid var(--silver);
-  background: #fff;
-  padding: 0.35rem 0.8rem;
-  font-size: 0.85rem;
-  cursor: pointer;
-}
-
-.lang-menu {
-  position: absolute;
-  right: 0;
-  top: 120%;
-  background: #fff;
-  border-radius: 12px;
-  box-shadow: var(--shadow-soft);
-  padding: 0.4rem;
-  min-width: 140px;
-}
-
-.lang-menu button {
-  width: 100%;
-  border: none;
-  background: transparent;
-  padding: 0.35rem 0.6rem;
-  text-align: left;
-  font-size: 0.85rem;
-  cursor: pointer;
-  border-radius: 8px;
-}
-
-.lang-menu button:hover {
-  background: var(--very-light-gray);
-}
-
-/* =====================================================================
-   Sections & Hero
-   ===================================================================== */
-
-.section {
-  padding: 4rem 0;
-}
-
-.section-alt {
-  background: var(--very-light-gray);
-}
-
-.section-title {
-  font-family: var(--font-heading);
-  font-weight: 700;
-  font-size: 2rem;
-  margin: 0 0 0.5rem;
-  color: var(--deep-gray);
-}
-
-.section-lead {
-  max-width: 680px;
-  font-size: 1rem;
-  color: #555;
-  margin: 0.25rem 0 2.5rem;
-}
-
-/* Hero */
-
-.hero-section {
-  position: relative;
-  padding-top: 5rem;
-  padding-bottom: 4rem;
-  background: linear-gradient(180deg, #ffffff 0%, #f3f7ff 55%, #e7f0ff 100%);
-}
-
-.hero-section::before {
-  content: "";
-  position: absolute;
-  inset: 0;
-  background:
-    radial-gradient(circle at top left, rgba(58, 111, 248, 0.14), transparent 55%),
-    radial-gradient(circle at bottom right, rgba(255, 215, 166, 0.25), transparent 60%);
-  pointer-events: none;
-}
-
-.hero-shell {
-  display: flex;
-  flex-direction: column;
-  gap: 2rem;
-}
-
-@media (min-width: 1024px) {
-  .hero-shell {
-    flex-direction: row;
-    gap: 2.5rem;
-  }
-}
-
-.hero-copy {
-  flex: 1;
-}
-
-.hero-preview {
-  flex: 1;
-  max-width: 480px;
-}
-
-.hero-kicker {
-  font-family: var(--font-heading);
-  font-weight: 600;
-  font-size: 0.9rem;
-  text-transform: uppercase;
-  letter-spacing: 0.12em;
-  color: var(--brand-blue);
-  margin: 0 0 0.75rem;
-}
-
-.hero-title {
-  font-family: var(--font-heading);
-  font-weight: 700;
-  font-size: clamp(2rem, 3vw, 2.6rem);
-  margin: 0 0 0.75rem;
-  color: var(--deep-gray);
-}
-
-.hero-subtitle {
-  margin: 0 0 1.5rem;
-  color: #555;
-  font-size: 1rem;
-}
-
-.hero-actions {
-  display: flex;
-  flex-wrap: wrap;
-  gap: 0.75rem;
-  margin-bottom: 1.2rem;
-}
-
-.hero-bullets {
-  list-style: none;
-  padding: 0;
-  margin: 0;
-  color: #555;
-  font-size: 0.95rem;
-}
-
-.hero-bullets li::before {
-  content: "•";
-  color: var(--green-check);
-  font-weight: 700;
-  display: inline-block;
-  margin-right: 0.45rem;
-}
-
-.hero-visual {
-  display: flex;
-  flex-direction: column;
-  gap: 1.5rem;
-}
-
-/* =====================================================================
-   Quick test visual
-   ===================================================================== */
-
-.quick-preview-card {
-  position: relative;
-  border-radius: 32px;
-  padding: 1.8rem;
-  background: linear-gradient(165deg, #ffffff 0%, #eef4ff 100%);
-  border: 1px solid rgba(56, 102, 214, 0.2);
-  box-shadow: var(--shadow-soft);
-  overflow: hidden;
-}
-
-.quick-preview-card::after {
-  content: "";
-  position: absolute;
-  inset: 12% auto auto 60%;
-  width: 220px;
-  height: 220px;
-  background: radial-gradient(circle, rgba(58, 111, 248, 0.12), transparent 65%);
-  pointer-events: none;
-}
-
-.quick-preview-header {
-  display: flex;
-  justify-content: space-between;
-  gap: 1rem;
-  align-items: flex-start;
-}
-
-.quick-preview-eyebrow {
-  font-size: 0.75rem;
-  letter-spacing: 0.3em;
-  text-transform: uppercase;
-  font-weight: 600;
-  color: var(--brand-blue);
-}
-
-.quick-badge {
-  display: inline-flex;
-  align-items: center;
-  gap: 0.35rem;
-  padding: 0.35rem 0.75rem;
-  border-radius: 999px;
-  font-size: 0.75rem;
-  font-weight: 600;
-  color: #1b4045;
-  background: rgba(31, 206, 136, 0.15);
-}
-
-.quick-metric-card {
-  background: rgba(255, 255, 255, 0.9);
-  border-radius: 20px;
-  border: 1px solid rgba(90, 132, 224, 0.2);
-  padding: 0.8rem 1rem;
-  display: flex;
-  flex-direction: column;
-  gap: 0.2rem;
-}
-
-.quick-metric-card span:first-child {
-  font-size: 0.75rem;
-  letter-spacing: 0.08em;
-  text-transform: uppercase;
-  color: #6c7695;
-}
-
-.quick-metric-card span:last-child {
-  font-size: 1.05rem;
-  font-weight: 600;
-  color: var(--deep-gray);
-}
-
-.quick-kit {
-  position: relative;
-  margin-top: 1.5rem;
-  border-radius: 30px;
-  padding: 1.5rem;
-  background: linear-gradient(120deg, #ffffff 0%, #f2f7ff 100%);
-  border: 1px solid rgba(68, 121, 249, 0.18);
-  display: grid;
-  grid-template-columns: 1.1fr 0.9fr;
-  gap: 1rem;
-}
-
-.quick-kit-left h4 {
-  margin: 0;
-  font-size: 1.1rem;
-  font-family: var(--font-heading);
-  color: var(--deep-gray);
-}
-
-.quick-kit-left p {
-  margin: 0.35rem 0 0;
-  font-size: 0.9rem;
-  color: #5f6b85;
-}
-
-.quick-kit-lines {
-  display: flex;
-  flex-direction: column;
-  gap: 0.5rem;
-  margin-top: 0.8rem;
-}
-
-.quick-kit-line {
-  position: relative;
-  height: 14px;
-  border-radius: 999px;
-  background: rgba(92, 120, 192, 0.12);
-  overflow: hidden;
-}
-
-.quick-kit-line::after {
-  content: "";
-  position: absolute;
-  inset: 2px;
-  border-radius: 999px;
-  background: linear-gradient(90deg, rgba(58, 111, 248, 0.1), rgba(31, 206, 136, 0.5));
-}
-
-.quick-kit-line.is-alert::after {
-  background: linear-gradient(90deg, rgba(255, 180, 90, 0.2), rgba(255, 118, 118, 0.5));
-}
-
-.quick-kit-window {
-  position: relative;
-  border-radius: 26px;
-  padding: 1rem;
-  background: linear-gradient(145deg, #edf2ff, #ffffff);
-  box-shadow: inset 0 2px 6px rgba(15, 33, 66, 0.08);
-}
-
-.quick-kit-window .window-label {
-  font-size: 0.7rem;
-  letter-spacing: 0.3em;
-  text-transform: uppercase;
-  color: #8390b3;
-  margin-bottom: 0.5rem;
-  display: block;
-}
-
-.quick-kit-window .window-strip {
-  height: 60px;
-  border-radius: 18px;
-  background: #ffffff;
-  border: 1px dashed rgba(89, 124, 178, 0.4);
-  display: flex;
-  align-items: center;
-  justify-content: space-around;
-  padding: 0 1.2rem;
-}
-
-.window-dot {
-  width: 14px;
-  height: 14px;
-  border-radius: 50%;
-  background: #e6ecff;
-  position: relative;
-}
-
-.window-dot.is-active {
-  background: #3a6ff8;
-  box-shadow: 0 0 0 6px rgba(58, 111, 248, 0.18);
-}
-
-.window-dot.is-pass {
-  background: #1fce88;
-  box-shadow: 0 0 0 6px rgba(31, 206, 136, 0.18);
-}
-
-.quick-kit-footnote {
-  margin-top: 0.7rem;
-  font-size: 0.75rem;
-  color: #7a86a8;
-}
-
-/* =====================================================================
-   Generic Section Shell & Cards
-   ===================================================================== */
-
-.section-shell {
-  position: relative;
-  max-width: 1120px;
-  margin: 0 auto;
-  padding: clamp(1.75rem, 3.5vw, 3.25rem);
-  border-radius: 36px;
-  background: linear-gradient(155deg, #ffffff 0%, #f4f7ff 100%);
-  border: 1px solid rgba(58, 111, 248, 0.14);
-  box-shadow: 0 30px 60px rgba(15, 33, 66, 0.08);
-  backdrop-filter: blur(6px);
-  overflow: hidden;
-}
-
-.section-shell::after {
-  content: "";
-  position: absolute;
-  inset: 12% 8% auto auto;
-  width: 160px;
-  height: 160px;
-  background: radial-gradient(circle, rgba(255, 215, 166, 0.18), transparent 65%);
-  pointer-events: none;
-}
-
-.card-frame {
-  border-radius: 26px;
-  padding: 1.5rem;
-  background: linear-gradient(140deg, #ffffff 0%, #f5f7ff 100%);
-  border: 1px solid rgba(58, 111, 248, 0.14);
-  box-shadow: 0 18px 40px rgba(15, 33, 66, 0.08);
-}
-
-.card-frame--accent {
-  border-color: rgba(58, 111, 248, 0.3);
-  box-shadow: 0 22px 45px rgba(58, 111, 248, 0.15);
-}
-
-.card-frame--soft {
-  background: linear-gradient(140deg, #fbfcff 0%, #f2f6ff 100%);
-}
-
-.section-band {
-  position: relative;
-}
-
-.section-band--soft {
-  background: linear-gradient(180deg, #edf3ff 0%, #f9fbff 100%);
-}
-
-.section-band--reverse {
-  background: linear-gradient(180deg, #f9fbff 0%, #edf3ff 100%);
-}
-
-/* =====================================================================
-   Steps / Features / Pricing / FAQ
-   ===================================================================== */
-
-.steps-grid,
-.features-grid,
-.pricing-grid,
-.faq-grid {
-  display: grid;
-  grid-template-columns: repeat(2, minmax(0, 1fr));
-  gap: 1.5rem;
-}
-
-.step-card,
-.feature-card,
-.pricing-card,
-.faq-item {
-  background: #fff;
-  border-radius: 18px;
-  padding: 1.3rem 1.4rem;
-  box-shadow: 0 8px 22px rgba(0, 0, 0, 0.03);
-  border: 1px solid rgba(230, 230, 230, 0.9);
-}
-
-.section-alt .step-card,
-.section-alt .feature-card,
-.section-alt .pricing-card,
-.section-alt .faq-item {
-  background: #fff;
-}
-
-.step-icon {
-  width: 32px;
-  height: 32px;
-  border-radius: 12px;
-  background: rgba(0, 81, 255, 0.07);
-  color: var(--brand-blue);
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  font-family: var(--font-heading);
-  font-weight: 700;
-  margin-bottom: 0.8rem;
-}
-
-.step-card h3,
-.feature-card h3,
-.pricing-card h3 {
-  font-family: var(--font-heading);
-  font-weight: 600;
-  margin: 0 0 0.5rem;
-  font-size: 1.1rem;
-}
-
-.step-card p,
-.feature-card p,
-.pricing-card p,
-.faq-item p {
-  margin: 0;
-  font-size: 0.95rem;
-  color: #555;
-}
-
-.feature-card ul,
-.pricing-card ul {
-  list-style: none;
-  margin: 0.75rem 0 0;
-  padding: 0;
-}
-
-.feature-card li,
-.pricing-card li {
-  font-size: 0.95rem;
-  color: #555;
-  margin-bottom: 0.35rem;
-}
-
-.feature-card li::before,
-.pricing-card li::before {
-  content: "✔";
-  color: var(--green-check);
-  margin-right: 0.45rem;
-}
-
-/* Pro card */
-
-.feature-card-pro {
-  border-color: rgba(0, 81, 255, 0.3);
-}
-
-.pill {
-  display: inline-block;
-  padding: 0.18rem 0.55rem;
-  border-radius: var(--radius-pill);
-  background: rgba(0, 81, 255, 0.08);
-  color: var(--brand-blue);
-  font-size: 0.75rem;
-  font-family: var(--font-heading);
-  font-weight: 600;
-  margin-bottom: 0.4rem;
-}
-
-/* Pricing */
-
-.pricing-card {
-  position: relative;
-}
-
-.pricing-card-muted {
-  opacity: 0.85;
-}
-
-.price-tag {
-  font-family: var(--font-heading);
-  font-weight: 700;
-  font-size: 1.4rem;
-  margin: 0.3rem 0 0.4rem;
-}
-
-/* FAQ */
-
-.faq-item summary {
-  font-family: var(--font-heading);
-  font-weight: 600;
-  cursor: pointer;
-  list-style: none;
-}
-
-.faq-item summary::-webkit-details-marker {
-  display: none;
-}
-
-.faq-item summary::after {
-  content: "+";
-  float: right;
-  font-weight: 700;
-}
-
-.faq-item[open] summary::after {
-  content: "−";
-}
-
-.faq-item p {
-  margin-top: 0.6rem;
-}
-
-/* =====================================================================
-   Footer
-   ===================================================================== */
-
-.site-footer {
-  border-top: 1px solid rgba(200, 203, 208, 0.6);
-  background: #fafafa;
-  padding: 1.5rem 0;
-  font-size: 0.85rem;
-  color: #666;
-}
-
-.footer-inner {
-  display: flex;
-  align-items: center;
-  justify-content: space-between;
-}
-
-.footer-links {
-  display: flex;
-  gap: 1.2rem;
-}
-
-.footer-links a {
-  color: #666;
-  text-decoration: none;
-}
-
-.footer-links a:hover {
-  text-decoration: underline;
-}
-
-/* =====================================================================
-   Responsive
-   ===================================================================== */
-
-@media (min-width: 900px) {
-  .main-nav {
-    display: flex;
-  }
-}
-
-@media (max-width: 899px) {
-  .hero-grid {
-    grid-template-columns: 1fr;
-  }
-
-  .hero-visual {
-    order: -1;
-  }
-
-  .header-inner {
-    gap: 0.75rem;
-  }
-}
-
-@media (max-width: 720px) {
-  .steps-grid,
-  .features-grid,
-  .pricing-grid,
-  .faq-grid {
-    grid-template-columns: 1fr;
-  }
-}

public/assets/i18n/ar.json

@@ -1,237 +0,0 @@
-{
-    "meta": {
-        "code": "ar",
-        "label": "العربية",
-        "flag": "🇸🇦",
-        "enabled": true,
-        "dir": "rtl"
-    },
-    "pages": {
-        "landing": {
-            "meta": {
-                "title": "بدون عنوان"
-            }
-        },
-        "main": {
-            "anchors": {
-                "how": "كيف يعمل",
-                "problem": "لماذا تكون وحدات USB المزوّرة خطرة",
-                "features": "المزايا",
-                "security": "الأمان",
-                "faq": "الأسئلة الشائعة"
-            },
-            "sections": {
-                "security": {
-                    "security_kicker": "الأمان والخصوصية",
-                    "security_title": "تصميم يركز على الخصوصية: بيانات الاختبار ملكٌ لك وحدك.",
-                    "security_intro": "تم تصميم USBCheck منذ البداية لحماية خصوصيتك. يعمل اختبار المتصفح السريع باستخدام ملفات اختبار فقط، ولا يقرأ أو يرسل أي صور أو مستندات أو نسخ احتياطية خاصة بك. في وضع Pro يمكنك التحكم بالكامل في ما إذا كانت التقارير ستُزامن مع حسابك أم لا.",
-                    "security_card1_title": "اختبارات محلية فقط",
-                    "security_card1_text": "تتم جميع اختبارات القراءة والكتابة على وحدة USB الخاصة بك محليًا. يصل المتصفح إلى ملفات الاختبار فقط — ولا يلمس ملفاتك الشخصية.",
-                    "security_card2_title": "تقارير شفافة",
-                    "security_card2_text": "بعد تسجيل الدخول يمكنك حفظ تقارير الاختبار أو تصديرها أو حذفها متى شئت. أنت من يقرر ما يبقى في النظام.",
-                    "security_card3_title": "حماية العتاد",
-                    "security_card3_text": "يستخدم الاختبار السريع كمية معتدلة من البيانات لتجنب تآكل الذاكرة. أما وضع Pro فيعرض تحذيرات واضحة قبل تشغيل فحص كامل عالي الكتابة."
-                },
-                "how": {
-                    "how_kicker": "كيف يعمل USBCheck",
-                    "how_title": "اختبار سريع داخل المتصفح، وتحليل معمّق مع وضع Pro.",
-                    "how_intro": "يجمع USBCheck بين اختبار سريع بسيط يناسب الجميع وبين وضع Pro المتقدم المصمم للمحترفين والفنيين والمسؤولين. يعمل الاختبار السريع مباشرة في المتصفح دون تثبيت. أما وضع Pro فيستخدم أداة صغيرة اختيارية تسمح بإجراء فحوصات مشابهة لـ F3 / badblocks لاكتشاف السعات المزوّرة.",
-                    "how_step1_title": "ابدأ اختبار المتصفح",
-                    "how_step1_text": "افتح الاختبار السريع عبر:",
-                    "how_step2_title": "فحوصات الكتابة والقراءة والسلامة",
-                    "how_step2_text": "ينشئ المتصفح ملفات اختبار ويقيس سرعة الكتابة والقراءة ويقارن قيم الهاش للكشف عن أخطاء البيانات — كل ذلك محليًا دون نقل أي ملفات خاصة بك.",
-                    "how_step3_title": "اختياري: فحص كامل مع وضع Pro",
-                    "how_step3_text": "إذا كنت ترغب في تحليل أعمق، يمكنك تثبيت أداة المساعدة الاختيارية. يمكنها فحص السعة الكاملة لوحدة USB وكشف السعات المزوّرة وإنشاء تقارير مفصّلة — مثالية للفنيين، وفرق تقنية المعلومات، والمختبرات.",
-                    "how_side_title": "مقارنة سريعة بين Free و Pro",
-                    "how_side_free": "pages.main.sections.how.how_side_free",
-                    "how_side_pro": "pages.main.sections.how.how_side_pro",
-                    "how_side_account": "pages.main.sections.how.how_side_account"
-                },
-                "hero": {
-                    "hero_kicker": "اكتشف وحدات USB المزوّرة قبل أن تفقد بياناتك",
-                    "hero_title": "هل وحدة USB لديّ مزوّرة؟",
-                    "hero_lead": "يجمع USBCheck بين اختبار سريع داخل المتصفح ووضع Pro الاحترافي. يساعدك على اكتشاف وحدات USB المزوّرة أو السعات الحقيقية الأكثر انخفاضًا أو المتحكمات الرخيصة — قبل أن تتلف ملفاتك.",
-                    "cta_quick": "ابدأ الاختبار السريع مجانًا",
-                    "cta_learn": "اعرف المزيد عن Free و Pro",
-                    "trust1_title": "لا يتطلب تثبيتًا",
-                    "trust1_text": "اختبار مباشر داخل المتصفح على وحدة USB الخاصة بك.",
-                    "trust2_title": "اختبارات كتابة وقراءة حقيقية",
-                    "trust2_text": "اختبارات تعتمد على بيانات حقيقية — بدون نتائج نظرية.",
-                    "trust3_title": "الخصوصية أولًا",
-                    "trust3_text": "تبقى بيانات الاختبار محليًا — ولا تُرسل التقارير إلا إذا رغبت بذلك.",
-                    "quick_label": "معاينة الاختبار السريع",
-                    "quick_title": "اختبر وحدة USB في أقل من دقيقتين",
-                    "badge_free": "مجاني",
-                    "quick_metric1_label": "أداء الكتابة",
-                    "quick_metric1_value": "~ 75–120 MB/s*",
-                    "quick_metric2_label": "فحوصات السلامة",
-                    "quick_metric2_value": "عينة 512 MB",
-                    "quick_intro": "يقوم الاختبار السريع بفحص كمية محددة من البيانات ويقيس:",
-                    "quick_li1": "سرعة الكتابة والقراءة",
-                    "quick_li2": "سلامة البيانات (مقارنة الهاش)",
-                    "quick_li3": "الأخطاء أو الانقطاعات المريبة",
-                    "quick_visual_title": "مؤشر الاختبار السريع",
-                    "quick_visual_text": "يشير اللون الأخضر إلى وحدة مستقرة، بينما يشير البرتقالي إلى مشاكل محتملة.",
-                    "quick_visual_window": "نافذة النتائج",
-                    "quick_footnote": "*قيم افتراضية — تعتمد النتائج على الوحدة والمنفذ والنظام.",
-                    "quick_cta": "اذهب إلى الاختبار السريع المجاني"
-                },
-                "features": {
-                    "features_kicker": "ميزات Free و Pro",
-                    "features_title": "ابدأ بالاختبار السريع المجاني — وانتقل إلى Pro عند الحاجة.",
-                    "features_intro": "يتطور USBCheck مع احتياجاتك: يحتاج المستخدمون العاديون غالبًا إلى تقييم سريع فقط، بينما يحتاج المحترفون للتحقق من السعات وأرشفة التقارير. وضع Pro مخصص لهذه الحالات.",
-                    "features_free_title": "الاختبار السريع المجاني",
-                    "features_free_badge": "موصى به لمعظم المستخدمين",
-                    "features_free_text": "مثالي لأي شخص يريد التحقق بسرعة من استقرار وحدة USB وأدائها — دون تثبيت أي شيء.",
-                    "features_free_li1": "• اختبار سريع داخل المتصفح",
-                    "features_free_li2": "• قياس سرعات الكتابة والقراءة ببيانات حقيقية",
-                    "features_free_li3": "• فحص سلامة البيانات عبر الهاش",
-                    "features_free_li4": "• مستويات اختبار مختلفة (مثل 200 MB، 2 GB)",
-                    "features_free_li5": "• لا حاجة لإنشاء حساب",
-                    "features_free_cta": "ابدأ الاختبار السريع",
-                    "features_pro_title": "وضع Pro",
-                    "features_pro_badge": "للمحترفين والفرق",
-                    "features_pro_text": "مصمم للمختصين وتقنيات الشركات: فحص كامل للسعة، تقارير متقدمة، ودعم متعدد المستخدمين والأجهزة.",
-                    "features_pro_li1": "• فحص كامل للسعة (مشابه لـ F3 / badblocks)",
-                    "features_pro_li2": "• كشف السعات المزوّرة والمناطق التالفة",
-                    "features_pro_li3": "• تقارير تفصيلية قابلة للحفظ (JSON، PDF)",
-                    "features_pro_li4": "• خيار دمج API لأتمتة الفحوصات",
-                    "features_pro_li5": "• دعم للأجهزة والمستخدمين المتعددين",
-                    "features_pro_note": "يتطلب وضع Pro أداة مساعدة صغيرة تعمل محليًا. يمكن ربط النتائج بحسابك عند الحاجة."
-                },
-                "faq": {
-                    "faq_kicker": "الأسئلة الشائعة",
-                    "faq_title": "أسئلة شائعة حول USBCheck",
-                    "faq_intro": "إجابات لأكثر الأسئلة شيوعًا. سيتم توسيع هذا القسم لاحقًا بناءً على الاستخدام وردود الفعل.",
-                    "faq_q1": "هل يعمل الاختبار السريع بالكامل داخل المتصفح؟",
-                    "faq_a1": "نعم. يعمل الاختبار السريع بالكامل عبر المتصفح، ويستخدم تقنيات حديثة لكتابة وقراءة ملفات الاختبار محليًا — دون رفع أي بيانات.",
-                    "faq_q2": "هل أحتاج إلى حساب لاستخدام الاختبار السريع؟",
-                    "faq_a2": "لا. الاختبار السريع مجاني ولا يتطلب تسجيل حساب. الحساب مطلوب فقط لحفظ التقارير أو استخدام وضع Pro.",
-                    "faq_q3": "هل يمكن لـ USBCheck اكتشاف جميع وحدات USB المزوّرة؟",
-                    "faq_a3": "لا يوجد ضمان بنسبة 100%، ولكن فحص Pro الكامل مصمم للكشف عن الأنماط الشائعة للتلاعب بالسعة والبيانات.",
-                    "faq_q4": "هل يمكن دمج USBCheck مع أنظمة أخرى؟",
-                    "faq_a4": "نعم. تم تصميم USBCheck مع أخذ الأتمتة في الاعتبار. يمكن دمجه في عمليات الفحص الداخلي والأنظمة عبر API."
-                },
-                "problem": {
-                    "problem_kicker": "لماذا تعد وحدات USB المزوّرة خطيرة؟",
-                    "problem_title": "الوحدات المزوّرة قد تكلّفك المال — وقد تتسبب في فقدان البيانات.",
-                    "problem_p1": "العديد من وحدات USB الرخيصة تدّعي سعات غير واقعية. يتم التلاعب بالمتحكم ليعلن عن سعة أكبر من السعة الفعلية. عند تجاوز السعة الحقيقية، يتم الكتابة فوق البيانات بصمت.",
-                    "problem_p2": "يساعدك USBCheck على اكتشاف هذه الوحدات قبل الاعتماد عليها — سواء كنت مستخدمًا فرديًا أو مؤسسة.",
-                    "problem_card1_title": "فقدان الملفات المهمة",
-                    "problem_card1_text": "الصور، الملفات، النسخ الاحتياطية — يمكن أن تتلف دون ملاحظة بسبب تلاعب السعة.",
-                    "problem_card2_title": "تكاليف الدُفعات التالفة",
-                    "problem_card2_text": "الشركات والموزعون غالبًا يشترون وحدات USB بالجملة — والوحدات المزوّرة تعني خسائر مالية وسمعة سيئة.",
-                    "problem_card3_title": "أداء غير مستقر",
-                    "problem_card3_text": "المتحكمات الرديئة والأداء المتذبذب شائع في الوحدات المزوّرة — ما يزيد من خطر الأخطاء."
-                }
-            }
-        },
-        "dashboard": {
-            "meta": {
-                "title": "{{primary_domain}} – لوحة التحكم",
-                "description": "لوحة التحكم لإدارة الاختبارات والأجهزة على {{primary_domain}}"
-            },
-            "sections": {
-                "dashboard": {
-                    "dashboard_kicker": "لوحة التحكم",
-                    "dashboard_title": "مرحبًا بك",
-                    "dashboard_intro": "يمكنك هنا إدارة اختبارات USB وتنظيم الأجهزة وتفعيل وضع Pro لاحقًا. هذه المنطقة قيد التطوير ولكنها توفر لك نظرة أولية.",
-                    "dashboard_plan_label": "الخطة الحالية",
-                    "dashboard_card_tests_title": "أحدث الاختبارات",
-                    "dashboard_card_tests_text": "ستظهر الاختبارات الأخيرة وعمليات الفحص مع التفاصيل الكاملة هنا.",
-                    "dashboard_card_tests_empty": "لا توجد بيانات اختبار بعد. ابدأ باختبار المتصفح أو وضع Pro.",
-                    "dashboard_card_devices_title": "أجهزتك",
-                    "dashboard_card_devices_text": "سيتمكن المستخدم لاحقًا من إدارة الأجهزة المختبرة هنا.",
-                    "dashboard_card_devices_empty": "لا توجد أجهزة محفوظة حتى الآن.",
-                    "dashboard_card_next_title": "الخطوات التالية",
-                    "dashboard_card_next_text": "USBCheck ما يزال قيد التطوير — وستصل ميزات Pro وAPI قريبًا.",
-                    "dashboard_card_next_item1": "• جرب FakeCheck داخل المتصفح وقدّم ملاحظاتك",
-                    "dashboard_card_next_item2": "• ساعد في تطوير ميزات Pro (مثل الفحص الكامل والتقارير)",
-                    "dashboard_card_next_item3": "• إكمال نظام الحساب وتكامل SSO (my-log.in)",
-                    "dashboard_card_next_cta": "الانتقال إلى FakeCheck"
-                }
-            }
-        },
-        "fakecheck": {
-            "meta": {
-                "title": "{{primary_domain}} – FakeCheck",
-                "description": "استخدم FakeCheck لفحص وحدات USB عبر المتصفح على {{primary_domain}}"
-            },
-            "sections": {
-                "hero": {
-                    "fake_hero_kicker": "FakeCheck — وضع المتصفح",
-                    "fake_hero_title": "هل وحدتي USB مزوّرة؟",
-                    "fake_hero_lead": "يساعد FakeCheck في اكتشاف وحدات USB المزوّرة عبر اختبارات كتابة/قراءة وفحوصات السعة، دون تثبيت.",
-                    "fake_cta_start": "ابدأ اختبار المتصفح (تجريبي)",
-                    "fake_cta_back_home": "الرجوع إلى النظرة العامة",
-                    "fake_hero_hint": "ينشئ FakeCheck ملفات اختبار في مجلد تختاره، دون لمس ملفاتك الحقيقية.",
-                    "fake_box_title": "ما الذي يمكن لاختبار المتصفح فعله؟",
-                    "fake_box_point1_title": "اختبار الكتابة والقراءة",
-                    "fake_box_point1_text": "يقيس السرعات ويتحقق من مطابقة البيانات.",
-                    "fake_box_point2_title": "التحقق من السعة الحقيقية",
-                    "fake_box_point2_text": "يساعدك على تقدير السعة الفعلية استنادًا إلى البيانات المكتوبة فعليًا.",
-                    "fake_box_point3_title": "تقرير JSON",
-                    "fake_box_point3_text": "يتم جمع النتائج في تقرير JSON منظم يمكن حفظه أو رفعه."
-                }
-            }
-        },
-        "login": {
-            "meta": {
-                "title": "{{primary_domain}} – تسجيل الدخول",
-                "description": "تسجيل الدخول إلى USBCheck على {{primary_domain}}"
-            },
-            "sections": {
-                "login": {
-                    "auth_kicker": "الحساب وتسجيل الدخول",
-                    "auth_title": "سجل الدخول إلى USBCheck",
-                    "auth_intro": "من خلال الحساب يمكنك حفظ الاختبارات وتصدير التقارير واستخدام وضع Pro على عدة أجهزة. التسجيل مجاني تمامًا.",
-                    "auth_tab_login": "تسجيل الدخول",
-                    "auth_tab_register": "إنشاء حساب",
-                    "auth_login_title": "تسجيل الدخول",
-                    "auth_login_text": "أدخل بريدك الإلكتروني وكلمة المرور.",
-                    "auth_login_email_label": "البريد الإلكتروني",
-                    "auth_login_password_label": "كلمة المرور",
-                    "auth_login_submit": "تسجيل الدخول",
-                    "auth_login_forgot": "نسيت كلمة المرور؟",
-                    "auth_register_title": "إنشاء حساب مجاني",
-                    "auth_register_text": "أنشئ حسابًا مجانيًا لحفظ الاختبارات وتصدير التقارير واستخدام وضع Pro لاحقًا.",
-                    "auth_register_name_label": "الاسم",
-                    "auth_register_email_label": "البريد الإلكتروني",
-                    "auth_register_password_label": "كلمة المرور",
-                    "auth_register_submit": "إنشاء الحساب",
-                    "auth_register_hint": "بتسجيلك، فأنت توافق على سياسة الخصوصية والشروط القانونية لـ USBCheck."
-                }
-            }
-        },
-        "tools": {
-            "meta": {
-                "title": "{{primary_domain}} – الأدوات",
-                "description": "عرض أدوات USBCheck على {{primary_domain}}"
-            }
-        }
-    },
-    "partials": {
-        "structure": {
-            "layout_end": {
-                "logout_modal_title": "هل تريد تسجيل الخروج؟",
-                "logout_modal_text": "سيتم إنهاء جلستك الحالية، وقد تفقد أي تغييرات غير محفوظة.",
-                "logout_modal_cancel": "إلغاء",
-                "logout_modal_confirm": "نعم، تسجيل الخروج"
-            },
-            "header": {
-                "header_slogan": "اختبر وحدات USB",
-                "header_btn_login": "تسجيل الدخول",
-                "header_menu_dashboard": "لوحة التحكم",
-                "header_menu_logout": "تسجيل الخروج",
-                "logout_title": "هل تريد تسجيل الخروج؟",
-                "logout_text": "سيتم تسجيل خروجك من حساب USBCheck. لن تتأثر الاختبارات الجارية في المتصفح.",
-                "logout_cancel": "إلغاء",
-                "logout_confirm": "نعم، تسجيل الخروج"
-            },
-            "footer": {
-                "footer_imprint": "partials.structure.footer.footer_imprint",
-                "footer_privacy": "partials.structure.footer.footer_privacy"
-            }
-        }
-    }
-}

public/assets/i18n/cs.json

@@ -1,236 +0,0 @@
-{
-    "meta": {
-        "code": "cs",
-        "label": "Čeština",
-        "flag": "🇨🇿",
-        "enabled": true
-    },
-    "pages": {
-        "landing": {
-            "meta": {
-                "title": "Bez názvu"
-            }
-        },
-        "main": {
-            "anchors": {
-                "how": "Jak to funguje",
-                "problem": "Proč jsou falešné USB disky nebezpečné",
-                "features": "Funkce",
-                "security": "Zabezpečení",
-                "faq": "FAQ"
-            },
-            "sections": {
-                "security": {
-                    "security_kicker": "Zabezpečení a soukromí",
-                    "security_title": "Design s důrazem na soukromí: testovací data patří jen vám.",
-                    "security_intro": "USBCheck je od základu navržen tak, aby chránil vaše soukromí. Rychlý test v prohlížeči pracuje pouze s testovacími soubory. Vaše dokumenty, fotky ani zálohy se nečtou ani neodesílají. V Pro režimu máte plnou kontrolu nad tím, které reporty se synchronizují s vaším účtem – a kdy je chcete smazat.",
-                    "security_card1_title": "Testy pouze lokálně",
-                    "security_card1_text": "Veškeré testy čtení a zápisu probíhají lokálně na vašem USB disku. Prohlížeč přistupuje jen k testovacím souborům – nikdy k vašim osobním datům.",
-                    "security_card2_title": "Transparentní reporty",
-                    "security_card2_text": "Po přihlášení můžete testovací reporty ukládat, exportovat nebo mazat. Vy rozhodujete, jaká data v systému zůstanou.",
-                    "security_card3_title": "Šetrné k hardwaru",
-                    "security_card3_text": "Rychlý test pracuje s rozumným množstvím dat, aby se zbytečně neopotřebovával paměťový čip. Pro režim vás před spuštěním plného skenu s vysokou zátěží jasně upozorní."
-                },
-                "how": {
-                    "how_kicker": "Jak USBCheck funguje",
-                    "how_title": "Rychlý test v prohlížeči, Pro režim s hlubokou analýzou.",
-                    "how_intro": "USBCheck spojuje dvě potřeby: jednoduchý rychlý test pro všechny a pokročilý Pro režim pro techniky, administrátory a náročné uživatele. Rychlý test běží přímo v prohlížeči bez instalace. Pro režim využívá malý pomocný nástroj, který dokáže spouštět testy podobné F3 / badblocks a spolehlivě odhalovat falešnou kapacitu.",
-                    "how_step1_title": "Spuštění testu v prohlížeči",
-                    "how_step1_text": "Rychlý test otevřete na této adrese:",
-                    "how_step2_title": "Test zápisu, čtení a integrity",
-                    "how_step2_text": "Prohlížeč vytváří na vašem USB disku testovací soubory, měří rychlosti zápisu a čtení a porovnává hash hodnoty, aby odhalil chyby v datech – vše probíhá lokálně, bez odesílání vašich souborů.",
-                    "how_step3_title": "Volitelně: Pro režim s plným skenem",
-                    "how_step3_text": "Pokud potřebujete jít víc do hloubky, můžete nainstalovat volitelný pomocný nástroj. Ten umí otestovat celou kapacitu zařízení, odhalit falešné jednotky a vytvořit detailní reporty – ideální pro refurbishery, IT oddělení nebo laboratoře.",
-                    "how_side_title": "Free vs Pro v rychlém přehledu",
-                    "how_side_free": "pages.main.sections.how.how_side_free",
-                    "how_side_pro": "pages.main.sections.how.how_side_pro",
-                    "how_side_account": "pages.main.sections.how.how_side_account"
-                },
-                "hero": {
-                    "hero_kicker": "Odhalte falešné USB disky dříve, než přijdete o data",
-                    "hero_title": "Je moje USB falešné?",
-                    "hero_lead": "USBCheck kombinuje rychlý test v prohlížeči s profesionálním Pro režimem. Díky tomu odhalíte falešné USB disky, nadsazenou kapacitu i pomalé, nespolehlivé řadiče – dřív, než zmizí vaše soubory.",
-                    "cta_quick": "Spustit bezplatný rychlý test",
-                    "cta_learn": "Zjistit více o Free & Pro",
-                    "trust1_title": "Rychlý test bez instalace",
-                    "trust1_text": "Test přímo v prohlížeči, přímo na vašem disku.",
-                    "trust2_title": "Skutečné testy zápisu a čtení",
-                    "trust2_text": "Testy pracují s reálnými daty – nejde jen o syntetické benchmarky.",
-                    "trust3_title": "Soukromí na prvním místě",
-                    "trust3_text": "Testovací data zůstávají u vás – reporty se ukládají jen pokud si to přejete.",
-                    "quick_label": "NÁHLED RYCHLÉHO TESTU",
-                    "quick_title": "Otestujte USB disk za méně než 2 minuty",
-                    "badge_free": "Zdarma",
-                    "quick_metric1_label": "Výkon zápisu",
-                    "quick_metric1_value": "~ 75–120 MB/s*",
-                    "quick_metric2_label": "Kontrola integrity",
-                    "quick_metric2_value": "Vzorek 512 MB",
-                    "quick_intro": "Rychlý test otestuje definovaný objem dat na vašem disku a změří:",
-                    "quick_li1": "rychlost zápisu a čtení",
-                    "quick_li2": "integritu dat (porovnání hashů)",
-                    "quick_li3": "podezřelé chyby nebo výpadky",
-                    "quick_visual_title": "Indikátor rychlého testu",
-                    "quick_visual_text": "Takto vypadá náhled výsledku: zelená značí stabilní disk, oranžová upozorňuje na problémy.",
-                    "quick_visual_window": "Okno s výsledky",
-                    "quick_footnote": "*Ukázkové hodnoty – vaše výsledky závisí na disku, portu a systému.",
-                    "quick_cta": "Přejít na bezplatný rychlý test"
-                },
-                "features": {
-                    "features_kicker": "Funkce Free & Pro",
-                    "features_title": "Začněte bezplatným rychlým testem – na Pro režim přejděte, až ho budete potřebovat.",
-                    "features_intro": "USBCheck roste společně s vašimi požadavky. Běžným uživatelům často stačí rychlý přehled. Profesionálové chtějí ověřit kapacitu, archivovat reporty a mít detailní přehled. Proto existuje Pro režim.",
-                    "features_free_title": "Bezplatný rychlý test",
-                    "features_free_badge": "Doporučeno pro většinu uživatelů",
-                    "features_free_text": "Ideální pro všechny, kdo chtějí rychle ověřit, zda USB disk alespoň základně funguje stabilně – bez jakékoli instalace.",
-                    "features_free_li1": "• Rychlý test v prohlížeči přímo na vašem disku",
-                    "features_free_li2": "• Měření rychlosti zápisu a čtení s reálnými daty",
-                    "features_free_li3": "• Kontrola integrity na základě hashů",
-                    "features_free_li4": "• Různé úrovně testu (např. 200 MB, 2 GB)",
-                    "features_free_li5": "• Není vyžadována registrace",
-                    "features_free_cta": "Spustit bezplatný test",
-                    "features_pro_title": "Pro režim",
-                    "features_pro_badge": "Pro náročné uživatele a týmy",
-                    "features_pro_text": "Pro všechny, kdo potřebují plnou kontrolu: IT oddělení, technici, refurbisheři, laboratoře nebo firmy, které pravidelně testují větší množství USB disků.",
-                    "features_pro_li1": "• Hluboký sken celé kapacity (podobně jako F3 / badblocks)",
-                    "features_pro_li2": "• Detekce falešné kapacity a vadných oblastí",
-                    "features_pro_li3": "• Detailní, uložitelná testovací hlášení (JSON, PDF)",
-                    "features_pro_li4": "• Volitelný API přístup pro automatizované testy",
-                    "features_pro_li5": "• Podpora více zařízení a více uživatelů (přes přihlášení)",
-                    "features_pro_note": "Pro režim vyžaduje instalaci malého pomocného nástroje na vašem systému. Ten pracuje lokálně a může být propojen s vaším USBCheck účtem."
-                },
-                "faq": {
-                    "faq_kicker": "FAQ",
-                    "faq_title": "Často kladené otázky k USBCheck",
-                    "faq_intro": "Zde najdete odpovědi na nejčastější dotazy. Tuto sekci můžeme kdykoli rozšířit, až se objeví nové scénáře nebo obdržíme další zpětnou vazbu.",
-                    "faq_q1": "Probíhá rychlý test opravdu celý v prohlížeči?",
-                    "faq_a1": "Ano. Rychlý test běží plně v prohlížeči a používá moderní API, která umožňují zapisovat a číst testovací soubory z vašeho USB disku. Žádná data se bez vašeho souhlasu nikam neodesílají.",
-                    "faq_q2": "Potřebuji účet, abych mohl rychlý test používat?",
-                    "faq_a2": "Ne. Bezplatný rychlý test lze používat bez registrace. Přihlášení je potřeba pouze tehdy, když chcete ukládat reporty, spravovat více disků nebo používat Pro režim.",
-                    "faq_q3": "Dokáže USBCheck spolehlivě odhalit každý falešný USB disk?",
-                    "faq_a3": "Žádný nástroj nemůže dát stoprocentní záruku. Pro režim s plným skenem je ale navržen tak, aby velmi spolehlivě odhaloval typické podvody – například manipulovanou kapacitu nebo chyby, které se objeví až po určitém zaplnění disku.",
-                    "faq_q4": "Jak USBCheck zapojím do svého stávajícího systému?",
-                    "faq_a4": "USBCheck je od začátku navrhován s ohledem na automatizaci. Díky Pro režimu a plánovanému API budete moci testy integrovat do existujících workflow – například do příjmové kontroly zboží nebo interního testování kvality."
-                },
-                "problem": {
-                    "problem_kicker": "Proč jsou falešné USB disky nebezpečné",
-                    "problem_title": "Falešná USB zařízení vás stojí peníze – a v horším případě i důležitá data.",
-                    "problem_p1": "Mnoho levných USB disků slibuje nereálně vysoké kapacity. Ve skutečnosti je řadič zmanipulovaný: disk hlásí například 256 GB, i když má fyzicky jen 32 GB. Výsledek: soubory se tváří, že jsou zkopírované, ale později se tiše přepisují nebo poškozují.",
-                    "problem_p2": "USBCheck vám pomůže takové disky odhalit dříve, než je začnete používat – ať už jde o jednotlivé disky pro domácí použití nebo celé série pro firmu.",
-                    "problem_card1_title": "Riziko ztráty důležitých souborů",
-                    "problem_card1_text": "Fotografie, projektové soubory, zálohy – o všechna tato data můžete přijít, pokud disk fyzicky neukládá tolik, kolik slibuje.",
-                    "problem_card2_title": "Náklady na vadné série",
-                    "problem_card2_text": "Firmy, reselleři i agentury často nakupují a rozdávají USB disky ve velkém. Falešné nebo vadné série znamenají reklamace, poškozenou pověst a dodatečné náklady.",
-                    "problem_card3_title": "Nestabilní výkon",
-                    "problem_card3_text": "Pomalé řadiče, nestabilní firmware a kolísající rychlosti jsou pro falešné disky typické. Zvyšují riziko chyb zejména při práci s velkými soubory."
-                }
-            }
-        },
-        "dashboard": {
-            "meta": {
-                "title": "{{primary_domain}} – Dashboard",
-                "description": "Přehled USB testů, zařízení a Pro funkcí na {{primary_domain}}."
-            },
-            "sections": {
-                "dashboard": {
-                    "dashboard_kicker": "Dashboard",
-                    "dashboard_title": "Vítejte",
-                    "dashboard_intro": "Zde můžete spravovat své USB testy, přehledně organizovat zařízení a později aktivovat Pro režim. Tato část se stále vyvíjí – už teď ale vidíte základní strukturu.",
-                    "dashboard_plan_label": "Aktuální plán",
-                    "dashboard_card_tests_title": "Poslední testy",
-                    "dashboard_card_tests_text": "V budoucnu zde uvidíte své poslední rychlé testy a Pro skeny – včetně stavu, rychlosti a výsledků kontroly integrity.",
-                    "dashboard_card_tests_empty": "Zatím zde nejsou žádná testovací data. Začněte prvním testem v prohlížeči nebo v Pro režimu.",
-                    "dashboard_card_devices_title": "Vaše USB zařízení",
-                    "dashboard_card_devices_text": "Později zde budete moci spravovat testované disky – výrobce, model, sériové číslo a zjištěnou kapacitu.",
-                    "dashboard_card_devices_empty": "Zatím nejsou uložena žádná zařízení. Po prvních testech si zde můžete své USB disky přidat.",
-                    "dashboard_card_next_title": "Další kroky",
-                    "dashboard_card_next_text": "USBCheck je stále ve vývoji. Patříte mezi první uživatele – později zde najdete Pro funkce, API přístup a detailní reporty.",
-                    "dashboard_card_next_item1": "• Vyzkoušejte prohlížečový FakeCheck a dejte nám zpětnou vazbu",
-                    "dashboard_card_next_item2": "• Pomozte definovat funkce Pro režimu (plný sken, reporty, API)",
-                    "dashboard_card_next_item3": "• Dokončete účty a SSO (my-log.in)",
-                    "dashboard_card_next_cta": "Přejít na FakeCheck"
-                }
-            }
-        },
-        "fakecheck": {
-            "meta": {
-                "title": "{{primary_domain}} – Fakecheck",
-                "description": "FakeCheck na {{primary_domain}}: detekce falešných USB disků přímo v prohlížeči."
-            },
-            "sections": {
-                "hero": {
-                    "fake_hero_kicker": "FakeCheck – režim v prohlížeči",
-                    "fake_hero_title": "Je můj USB disk falešný?",
-                    "fake_hero_lead": "FakeCheck vám pomůže odhalit typické falešné disky pomocí testů zápisu/čtení a kontroly využitelné kapacity – bez instalace.",
-                    "fake_cta_start": "Spustit test v prohlížeči (demo)",
-                    "fake_cta_back_home": "Zpět na přehled",
-                    "fake_hero_hint": "FakeCheck pracuje s testovacími soubory ve zvolené složce. Vaše reálné soubory zůstávají nedotčené.",
-                    "fake_box_title": "Co dokáže test v prohlížeči",
-                    "fake_box_point1_title": "Test zápisu a čtení",
-                    "fake_box_point1_text": "Prohlížeč vytváří testovací soubory, měří rychlosti a ověřuje, zda přečtená data odpovídají původním vzorům.",
-                    "fake_box_point2_title": "Kontrola kapacity",
-                    "fake_box_point2_text": "Na základě množství úspěšně zapsaných a ověřených dat získáte realistický obrázek o skutečně stabilní kapacitě zařízení.",
-                    "fake_box_point3_title": "JSON report pro vaši dokumentaci",
-                    "fake_box_point3_text": "Všechny výsledky se ukládají do strukturovaného JSON reportu, který můžete archivovat, sdílet nebo porovnávat s dalšími testy."
-                }
-            }
-        },
-        "login": {
-            "meta": {
-                "title": "{{primary_domain}} – Přihlášení",
-                "description": "Přihlášení k USBCheck účtu na {{primary_domain}} pro správu testů a Pro režimu."
-            },
-            "sections": {
-                "login": {
-                    "auth_kicker": "Účet a přihlášení",
-                    "auth_title": "Přihlaste se do USBCheck",
-                    "auth_intro": "S účtem můžete ukládat testy, exportovat reporty a využívat Pro režim na více zařízeních. Registrace je zdarma – na Pro můžete přejít kdykoli později.",
-                    "auth_tab_login": "Přihlášení",
-                    "auth_tab_register": "Registrace",
-                    "auth_login_title": "Přihlášení",
-                    "auth_login_text": "Přihlaste se pomocí e-mailu a hesla.",
-                    "auth_login_email_label": "E-mailová adresa",
-                    "auth_login_password_label": "Heslo",
-                    "auth_login_submit": "Přihlásit se",
-                    "auth_login_forgot": "Zapomenuté heslo?",
-                    "auth_register_title": "Registrace zdarma",
-                    "auth_register_text": "Vytvořte si zdarma účet, abyste mohli ukládat testy, exportovat reporty a později odemknout Pro režim.",
-                    "auth_register_name_label": "Jméno",
-                    "auth_register_email_label": "E-mailová adresa",
-                    "auth_register_password_label": "Heslo",
-                    "auth_register_submit": "Vytvořit účet",
-                    "auth_register_hint": "Registrací souhlasíte se zásadami ochrany osobních údajů a právními informacemi USBCheck."
-                }
-            }
-        },
-        "tools": {
-            "meta": {
-                "title": "{{primary_domain}} – Nástroje",
-                "description": "Přehled nástrojů a funkcí USBCheck na {{primary_domain}}."
-            }
-        }
-    },
-    "partials": {
-        "structure": {
-            "layout_end": {
-                "logout_modal_title": "Opravdu se odhlásit?",
-                "logout_modal_text": "Odhlášením ukončíte aktuální relaci a všechny neuložené akce mohou být ztraceny. Přihlásit se můžete kdykoli znovu.",
-                "logout_modal_cancel": "Zrušit",
-                "logout_modal_confirm": "Ano, odhlásit"
-            },
-            "header": {
-                "header_slogan": "Testování USB disků",
-                "header_btn_login": "Přihlásit se",
-                "header_menu_dashboard": "Dashboard",
-                "header_menu_logout": "Odhlásit se",
-                "logout_title": "Opravdu se odhlásit?",
-                "logout_text": "Budete odhlášeni ze svého USBCheck účtu. Probíhající testy v prohlížeči tím nebudou přerušeny.",
-                "logout_cancel": "Zrušit",
-                "logout_confirm": "Ano, odhlásit"
-            },
-            "footer": {
-                "footer_imprint": "partials.structure.footer.footer_imprint",
-                "footer_privacy": "partials.structure.footer.footer_privacy"
-            }
-        }
-    }
-}

public/assets/i18n/da.json

@@ -1,236 +0,0 @@
-{
-    "meta": {
-        "code": "da",
-        "label": "Dansk",
-        "flag": "🇩🇰",
-        "enabled": true
-    },
-    "pages": {
-        "landing": {
-            "meta": {
-                "title": "INGEN TITEL"
-            }
-        },
-        "main": {
-            "anchors": {
-                "how": "Sådan fungerer det",
-                "problem": "Hvorfor falske USB-drev er farlige",
-                "features": "Funktioner",
-                "security": "Sikkerhed",
-                "faq": "FAQ"
-            },
-            "sections": {
-                "security": {
-                    "security_kicker": "Sikkerhed og privatliv",
-                    "security_title": "Privacy-first design: Dine testdata tilhører dig.",
-                    "security_intro": "USBCheck er fra starten designet til at beskytte dine data. Browser-hurtigtesten arbejder kun med testfiler. Dine dokumenter, billeder og backups bliver hverken læst eller overført. I Pro-tilstand har du fuld kontrol over, hvilke rapporter der synkroniseres med din konto.",
-                    "security_card1_title": "Kun lokale tests",
-                    "security_card1_text": "Alle skrive- og læsetests udføres lokalt på dit USB-drev. Browseren får kun adgang til testfiler – ikke til dine private data.",
-                    "security_card2_title": "Gennemsigtige rapporter",
-                    "security_card2_text": "Når du logger ind, kan du gemme, eksportere og slette testresultater i din konto. Du bestemmer, hvilke data der bliver gemt.",
-                    "security_card3_title": "Skånsom mod hardware",
-                    "security_card3_text": "Hurtigtesten bruger moderate datamængder for at undgå unødigt slid. Pro-tilstanden advarer tydeligt, hvis der startes en fuld scanning med høj skrivebelastning."
-                },
-                "how": {
-                    "how_kicker": "Sådan fungerer USBCheck",
-                    "how_title": "Hurtigtest i browseren, Pro-tilstand med dybdegående analyse.",
-                    "how_intro": "USBCheck kombinerer to verdener: en enkel hurtigtest for alle og en avanceret Pro-tilstand til powerbrugere, teknikere og administratorer. Hurtigtesten kører direkte i browseren uden installation. Pro-tilstanden bruger et lille hjælpeværktøj, der kan udføre F3-/badblocks-lignende tests for at afsløre kapacitetsfalsknerier.",
-                    "how_step1_title": "Start test i browseren",
-                    "how_step1_text": "Du åbner hurtigtesten på",
-                    "how_step2_title": "Skrive-, læse- og integritetstest",
-                    "how_step2_text": "Browseren opretter testfiler, måler skrive- og læsehastighed og sammenligner hashværdier for at finde datafejl – alt sammen lokalt uden at overføre dine filer.",
-                    "how_step3_title": "Valgfrit: Pro-tilstand for fuld scanning",
-                    "how_step3_text": "Hvis du vil vide mere, kan du installere hjælpeværktøjet. Det kan scanne hele drevets kapacitet, identificere falske drev og generere detaljerede rapporter — ideelt til IT-afdelinger, refurbishere eller laboratorier.",
-                    "how_side_title": "Free vs Pro – et hurtigt overblik",
-                    "how_side_free": "pages.main.sections.how.how_side_free",
-                    "how_side_pro": "pages.main.sections.how.how_side_pro",
-                    "how_side_account": "pages.main.sections.how.how_side_account"
-                },
-                "hero": {
-                    "hero_kicker": "Opdag falske USB-drev før du mister data",
-                    "hero_title": "Er min USB falsk?",
-                    "hero_lead": "USBCheck kombinerer en hurtig browsertest med en professionel Pro-tilstand. Så kan du identificere falske USB-drev, reel kapacitet der er lavere end lovet, og langsomme billige controllere — før dine filer bliver ødelagt.",
-                    "cta_quick": "Start gratis hurtigtest",
-                    "cta_learn": "Læs mere om Free & Pro",
-                    "trust1_title": "Ingen installation nødvendig",
-                    "trust1_text": "Browserbaseret test direkte på dit drev.",
-                    "trust2_title": "Reelle skrive- og læsetests",
-                    "trust2_text": "Tests med rigtige data – ikke syntetiske teoretiske værdier.",
-                    "trust3_title": "Privacy first",
-                    "trust3_text": "Dine testdata forbliver lokale – rapporter kun hvis du ønsker det.",
-                    "quick_label": "FORHÅNDSVISNING AF HURTIGTEST",
-                    "quick_title": "Test en USB-enhed på under 2 minutter",
-                    "badge_free": "Gratis",
-                    "quick_metric1_label": "Skriveydelse",
-                    "quick_metric1_value": "~ 75–120 MB/s*",
-                    "quick_metric2_label": "Integritetstjek",
-                    "quick_metric2_value": "512 MB eksempeldata",
-                    "quick_intro": "Hurtigtesten analyserer en defineret datamængde og måler:",
-                    "quick_li1": "Skrive- og læsehastighed",
-                    "quick_li2": "Dataintegritet (hash-sammenligning)",
-                    "quick_li3": "Mistænkelige fejl eller afbrydelser",
-                    "quick_visual_title": "Hurtigtestindikator",
-                    "quick_visual_text": "Sådan ser forhåndsvisningen ud: Grønt betyder stabilt drev, orange betyder advarsel.",
-                    "quick_visual_window": "Resultatvindue",
-                    "quick_footnote": "*Eksempelværdier – dine resultater afhænger af drev, port og system.",
-                    "quick_cta": "Gå til gratis hurtigtest"
-                },
-                "features": {
-                    "features_kicker": "Free & Pro funktioner",
-                    "features_title": "Start med gratis hurtigtest — skift til Pro, når du får brug for mere.",
-                    "features_intro": "USBCheck vokser med dine behov: Privatpersoner har ofte brug for en hurtig vurdering. Professionelle har brug for dybdegående analyser og arkiverbare rapporter.",
-                    "features_free_title": "Gratis hurtigtest",
-                    "features_free_badge": "Anbefalet til de fleste",
-                    "features_free_text": "Ideelt til hurtigt at tjekke om en USB-enhed fungerer stabilt – helt uden installation.",
-                    "features_free_li1": "• Browserbaseret hurtigtest direkte på drevet",
-                    "features_free_li2": "• Rigtige skrive- og læsehastigheder",
-                    "features_free_li3": "• Hash-baseret integritetstest",
-                    "features_free_li4": "• Flere testniveauer (200 MB, 2 GB)",
-                    "features_free_li5": "• Ingen registrering nødvendig",
-                    "features_free_cta": "Start gratis test",
-                    "features_pro_title": "Pro-tilstand",
-                    "features_pro_badge": "Til avancerede brugere og teams",
-                    "features_pro_text": "Perfekt til dem, der har brug for fuld kontrol: IT-afdelinger, teknikere, refurbishere, laboratorier eller virksomheder.",
-                    "features_pro_li1": "• Dybdegående scanning af hele kapaciteten (F3/badblocks-lignende)",
-                    "features_pro_li2": "• Detektion af falsk kapacitet og defekte sektorer",
-                    "features_pro_li3": "• Detaljerede rapporter (JSON, PDF)",
-                    "features_pro_li4": "• Valgfri API-adgang",
-                    "features_pro_li5": "• Multi-device og multi-user support",
-                    "features_pro_note": "Pro-tilstanden kræver et lille hjælpeværktøj installeret lokalt. Det fungerer offline og kan kobles til din USBCheck-konto."
-                },
-                "faq": {
-                    "faq_kicker": "FAQ",
-                    "faq_title": "Ofte stillede spørgsmål om USBCheck",
-                    "faq_intro": "Her finder du svar på de mest almindelige spørgsmål. FAQ-sektionen udvides løbende baseret på feedback og nye behov.",
-                    "faq_q1": "Kører hurtigtesten helt i browseren?",
-                    "faq_a1": "Ja. Hurtigtesten kører 100 % i browseren ved hjælp af moderne API’er, der tillader skrivning og læsning af testfiler uden upload.",
-                    "faq_q2": "Skal jeg have en konto for at bruge hurtigtesten?",
-                    "faq_a2": "Nej. Gratis hurtigtest kræver ingen konto. Den er kun nødvendig, hvis du vil gemme rapporter, håndtere flere enheder eller bruge Pro-tilstand.",
-                    "faq_q3": "Kan USBCheck opdage alle falske USB-drev?",
-                    "faq_a3": "Ingen test kan garantere 100 %. Men Pro-tilstanden med fuld scanning er udviklet til at opdage typiske mønstre for falske drev meget pålideligt.",
-                    "faq_q4": "Hvordan integrerer jeg værktøjet i mit system?",
-                    "faq_a4": "USBCheck er udviklet med fokus på automatisering. Via Pro-tilstand og den kommende API kan du integrere tests i dine arbejdsprocesser — fx kvalitetskontrol."
-                },
-                "problem": {
-                    "problem_kicker": "Hvorfor falske USB-drev er farlige",
-                    "problem_title": "Falske USB-drev koster penge — og i værste fald dine data.",
-                    "problem_p1": "Mange billige USB-drev lover urealistisk kapacitet. Controlleren kan være manipuleret og rapportere f.eks. 256 GB, selvom der kun er 32 GB fysisk. Resultatet: Filer ser ud til at blive kopieret korrekt, men overskrives eller beskadiges senere.",
-                    "problem_p2": "USBCheck hjælper dig med at identificere sådanne falske drev, før du tager dem i brug — både privat og i virksomheder.",
-                    "problem_card1_title": "Tab af vigtige filer",
-                    "problem_card1_text": "Billeder, projekter, backup — alt kan gå tabt, hvis drevet ikke har den lovede kapacitet.",
-                    "problem_card2_title": "Omkostninger ved defekte partier",
-                    "problem_card2_text": "Virksomheder og forhandlere distribuerer ofte USB-drev i store mængder. Falske drev fører til reklamationer, omkostninger og imageproblemer.",
-                    "problem_card3_title": "Ustabil ydeevne",
-                    "problem_card3_text": "Langsomme controllere, ustabil firmware og varierende hastigheder er typiske for falske drev og øger risikoen for fejl."
-                }
-            }
-        },
-        "dashboard": {
-            "meta": {
-                "title": "{{primary_domain}} – Dashboard",
-                "description": "Beskrivelse for dashboard på {{primary_domain}}"
-            },
-            "sections": {
-                "dashboard": {
-                    "dashboard_kicker": "Dashboard",
-                    "dashboard_title": "Velkommen",
-                    "dashboard_intro": "Her kan du administrere USB-tests, organisere enheder og senere aktivere Pro-tilstand. Området er stadig under udvikling, men giver allerede et overblik.",
-                    "dashboard_plan_label": "Aktuel plan",
-                    "dashboard_card_tests_title": "Seneste tests",
-                    "dashboard_card_tests_text": "Her vil dine seneste hurtigtests og Pro-scanninger blive vist med status, hastighed og integritetstjek.",
-                    "dashboard_card_tests_empty": "Ingen testdata endnu. Start en test via browseren eller Pro-tilstand.",
-                    "dashboard_card_devices_title": "Dine USB-enheder",
-                    "dashboard_card_devices_text": "Senere kan du administrere testede drev her: producent, model, serienummer og registreret kapacitet.",
-                    "dashboard_card_devices_empty": "Ingen enheder gemt endnu. Efter dine første tests kan du tilføje dem her.",
-                    "dashboard_card_next_title": "Næste trin",
-                    "dashboard_card_next_text": "USBCheck er stadig under udvikling. Som en af de første brugere vil du senere finde Pro-funktioner, API-adgang og detaljerede rapporter her.",
-                    "dashboard_card_next_item1": "• Test browser-baseret FakeCheck og giv feedback",
-                    "dashboard_card_next_item2": "• Definér Pro-funktioner (fuld scanning, rapporter, API)",
-                    "dashboard_card_next_item3": "• Færdiggør konti & SSO (my-log.in)",
-                    "dashboard_card_next_cta": "Gå til FakeCheck"
-                }
-            }
-        },
-        "fakecheck": {
-            "meta": {
-                "title": "{{primary_domain}} – FakeCheck",
-                "description": "Beskrivelse for FakeCheck på {{primary_domain}}"
-            },
-            "sections": {
-                "hero": {
-                    "fake_hero_kicker": "FakeCheck – browser-tilstand",
-                    "fake_hero_title": "Er min USB falsk?",
-                    "fake_hero_lead": "FakeCheck hjælper med at afsløre falske USB-drev via skrive-/læs-tests og kapacitetskontrol — uden installation.",
-                    "fake_cta_start": "Start browser-test (demo)",
-                    "fake_cta_back_home": "Tilbage til oversigten",
-                    "fake_hero_hint": "FakeCheck arbejder med testfiler i en valgt mappe. Dine rigtige filer bliver ikke rørt.",
-                    "fake_box_title": "Hvad browser-testen kan",
-                    "fake_box_point1_title": "Skrive-/læse-tests",
-                    "fake_box_point1_text": "Browseren opretter testfiler, måler hastigheder og validerer datamønstre.",
-                    "fake_box_point2_title": "Kapacitetstjek",
-                    "fake_box_point2_text": "Den verificerede datamængde viser, hvor meget kapacitet der faktisk kan bruges stabilt.",
-                    "fake_box_point3_title": "JSON-rapport",
-                    "fake_box_point3_text": "Alle resultater gemmes i en struktureret JSON-rapport, som du kan eksportere eller arkivere."
-                }
-            }
-        },
-        "login": {
-            "meta": {
-                "title": "{{primary_domain}} – Login",
-                "description": "Beskrivelse for login på {{primary_domain}}"
-            },
-            "sections": {
-                "login": {
-                    "auth_kicker": "Konto & login",
-                    "auth_title": "Log ind på USBCheck",
-                    "auth_intro": "Med en konto kan du gemme tests, eksportere rapporter og bruge Pro-tilstand på flere enheder. Registrering er gratis, og du kan opgradere til Pro senere.",
-                    "auth_tab_login": "Login",
-                    "auth_tab_register": "Registrér",
-                    "auth_login_title": "Login",
-                    "auth_login_text": "Log ind med din e-mail og adgangskode.",
-                    "auth_login_email_label": "E-mail",
-                    "auth_login_password_label": "Adgangskode",
-                    "auth_login_submit": "Log ind",
-                    "auth_login_forgot": "Glemt adgangskode?",
-                    "auth_register_title": "Gratis registrering",
-                    "auth_register_text": "Opret en gratis konto for at gemme tests, eksportere rapporter og aktivere Pro-tilstand.",
-                    "auth_register_name_label": "Navn",
-                    "auth_register_email_label": "E-mail",
-                    "auth_register_password_label": "Adgangskode",
-                    "auth_register_submit": "Opret konto",
-                    "auth_register_hint": "Ved at registrere dig accepterer du USBChecks privatlivspolitik og juridiske oplysninger."
-                }
-            }
-        },
-        "tools": {
-            "meta": {
-                "title": "{{primary_domain}} – Værktøjer",
-                "description": "Beskrivelse for værktøjer på {{primary_domain}}"
-            }
-        }
-    },
-    "partials": {
-        "structure": {
-            "layout_end": {
-                "logout_modal_title": "Log ud?",
-                "logout_modal_text": "Hvis du logger ud, afsluttes din session og ikke-gemte handlinger går tabt. Du kan logge ind igen når som helst.",
-                "logout_modal_cancel": "Annuller",
-                "logout_modal_confirm": "Ja, log ud"
-            },
-            "header": {
-                "header_slogan": "Test USB-drev",
-                "header_btn_login": "Login",
-                "header_menu_dashboard": "Dashboard",
-                "header_menu_logout": "Log ud",
-                "logout_title": "Log ud?",
-                "logout_text": "Du bliver logget ud af din USBCheck-konto. Aktive browser-tests påvirkes ikke.",
-                "logout_cancel": "Annuller",
-                "logout_confirm": "Ja, log ud"
-            },
-            "footer": {
-                "footer_imprint": "partials.structure.footer.footer_imprint",
-                "footer_privacy": "partials.structure.footer.footer_privacy"
-            }
-        }
-    }
-}

public/assets/i18n/de.json

@@ -1,247 +0,0 @@
-{
-    "meta": {
-        "code": "de",
-        "label": "Deutsch",
-        "flag": "🇩🇪",
-        "enabled": true
-    },
-    "pages": {
-        "landing": {
-            "meta": {
-                "title": "KEIN TITEL"
-            },
-            "anchors": {
-                "how":      "So funktioniert USBCheck",
-                "problem":  "Warum gefälschte USB-Sticks gefährlich sind",
-                "features": "Funktionen",
-                "security": "Sicherheit",
-                "faq":      "FAQ"
-            }
-        },
-        "main": {
-            "meta": {
-                "title": "{{primary_domain}} – USB-Sticks testen",
-                "description": "Erkenne gefälschte USB-Sticks mit USBCheck: Kostenloser Browser-Test & professioneller Pro-Modus für sichere Schreib-/Lesetests, Kapazitätsprüfung & Datenintegrität."
-            },
-            "anchors": {
-                "how":      "So funktioniert es",
-                "problem":  "Warum gefälschte Sticks gefährlich sind",
-                "features": "Funktionen",
-                "security": "Sicherheit",
-                "faq":      "FAQ"
-            },
-            "sections": {
-                "security": {
-                    "security_kicker": "Sicherheit & Datenschutz",
-                    "security_title": "Privacy-first-Design: Deine Testdaten gehören dir.",
-                    "security_intro": "USBCheck wurde von Anfang an so konzipiert, dass deine Daten geschützt bleiben. Der Browser-Schnelltest arbeitet ausschließlich mit Testdateien. Deine eigenen Dokumente, Bilder oder Backups werden weder gelesen noch übertragen. Im Pro-Modus hast du volle Kontrolle, ob und welche Reports mit deinem Account synchronisiert werden.",
-                    "security_card1_title": "Tests nur lokal",
-                    "security_card1_text": "Alle Schreib- und Lesetests erfolgen lokal auf deinem USB-Stick. Der Browser greift nur auf die Testdateien zu – nicht auf deine privaten Inhalte.",
-                    "security_card2_title": "Transparente Reports",
-                    "security_card2_text": "Wenn du dich einloggst, kannst du Testberichte in deinem Account speichern, exportieren oder wieder löschen. Du entscheidest, welche Daten im System bleiben.",
-                    "security_card3_title": "Schonend für deine Hardware",
-                    "security_card3_text": "Der Schnelltest arbeitet mit moderaten Datenmengen, um unnötigen Verschleiß zu vermeiden. Der Pro-Modus warnt deutlich, wenn ein Vollscan mit hoher Schreiblast ausgeführt wird."
-                },
-                "how": {
-                    "how_kicker": "So funktioniert USBCheck",
-                    "how_title": "Schnelltest im Browser, Pro-Modus mit Tiefenanalyse.",
-                    "how_intro": "USBCheck wurde entwickelt, um zwei Welten zu verbinden: einen einfachen Schnelltest für alle und einen tiefgehenden Pro-Modus für Power-User, Techniker und Admins. Der Schnelltest läuft direkt im Browser, ohne Installation. Für den Pro-Modus wird ein kleines Helfer-Tool verwendet, das auf Wunsch F3- / badblocks-ähnliche Tests ausführt und damit Kapazitäts-Fakes sicher enttarnt.",
-                    "how_step1_title": "Browser-Test starten",
-                    "how_step1_text": "Du öffnest den Schnelltest unter",
-                    "how_step2_title": "Schreib-, Lese- und Integritätsprüfung",
-                    "how_step2_text": "Der Browser erstellt Testdateien, misst Schreib- und Leserate und vergleicht Hash-Werte, um Datenfehler zu erkennen – alles lokal und ohne Übertragung deiner Inhalte.",
-                    "how_step3_title": "Optional: Pro-Modus für Vollscan",
-                    "how_step3_text": "Wer mehr wissen will, installiert das optionale Helfer-Tool. Dieses kann die gesamte Kapazität des Sticks prüfen, Fakes identifizieren und detaillierte Reports erzeugen – ideal für Refurbisher, IT-Abteilungen oder Labore.",
-                    "how_side_title": "Free vs. Pro auf einen Blick",
-                    "how_side_free": "pages.main.sections.how.how_side_free",
-                    "how_side_pro": "pages.main.sections.how.how_side_pro",
-                    "how_side_account": "pages.main.sections.how.how_side_account"
-                },
-                "hero": {
-                    "hero_kicker": "Erkenne gefälschte USB-Sticks, bevor du Daten verlierst",
-                    "hero_title": "Ist mein USB-Stick fake?",
-                    "hero_lead": "USBCheck kombiniert einen schnellen Browser-Test mit einem professionellen Pro-Modus. So erkennst du gefälschte USB-Sticks, zu kleine echte Kapazität und langsame Billig-Controller – bevor deine Dateien verschwinden.",
-                    "cta_quick": "Kostenlosen Schnelltest starten",
-                    "cta_learn": "Mehr über Free & Pro erfahren",
-                    "trust1_title": "Kein Install für Schnelltest",
-                    "trust1_text": "Browser-basierter Test direkt auf deinem Stick.",
-                    "trust2_title": "Echte Schreib- & Lesetests",
-                    "trust2_text": "Schreib-/Lesetests mit echten Daten – keine synthetische Theorie.",
-                    "trust3_title": "Privacy first",
-                    "trust3_text": "Deine Testdaten bleiben lokal – Reports nur auf Wunsch.",
-                    "quick_label": "SCHNELLTEST-VORSCHAU",
-                    "quick_title": "USB-Stick in unter 2 Minuten testen",
-                    "badge_free": "Kostenlos",
-                    "quick_metric1_label": "Schreibleistung",
-                    "quick_metric1_value": "~ 75–120 MB/s*",
-                    "quick_metric2_label": "Integritätsprüfungen",
-                    "quick_metric2_value": "512 MB Testmenge",
-                    "quick_intro": "Der Schnelltest prüft eine definierte Datenmenge auf deinem Stick und misst:",
-                    "quick_li1": "Schreib- und Leserate",
-                    "quick_li2": "Datenintegrität (Hash-Vergleich)",
-                    "quick_li3": "Verdächtige Abbrüche oder Fehler",
-                    "quick_visual_title": "Schnelltest-Anzeige",
-                    "quick_visual_text": "So sieht die Schnelltest-Vorschau aus: Grün markiert einen stabilen Stick, Orange warnt bei Auffälligkeiten.",
-                    "quick_visual_window": "Ergebnisfenster",
-                    "quick_footnote": "*Beispielwerte – deine Ergebnisse hängen von Stick, Port & System ab.",
-                    "quick_cta": "Zum kostenlosen Schnelltest"
-                },
-                "features": {
-                    "features_kicker": "Free- & Pro-Funktionen",
-                    "features_title": "Starte mit dem kostenlosen Schnelltest – wechsle in den Pro-Modus, wenn du mehr brauchst.",
-                    "features_intro": "USBCheck wächst mit deinen Anforderungen: Private Nutzer brauchen oft nur eine schnelle Einschätzung. Profis möchten tiefer einsteigen, Kapazitäten verifizieren und Reports archivieren. Genau dafür ist der Pro-Modus gedacht.",
-                    "features_free_title": "Kostenloser Schnelltest",
-                    "features_free_badge": "Empfohlen für die meisten Nutzer",
-                    "features_free_text": "Ideal für alle, die schnell prüfen möchten, ob ein USB-Stick zumindest grundlegend performant und stabil arbeitet – ganz ohne Installation.",
-                    "features_free_li1": "• Browser-basierter Schnelltest direkt auf deinem Stick",
-                    "features_free_li2": "• Schreib- und Lesegeschwindigkeit mit realen Testdaten",
-                    "features_free_li3": "• Hash-basierte Integritätsprüfung einer Testmenge",
-                    "features_free_li4": "• Auswahl verschiedener Teststufen (z. B. 200 MB, 2 GB)",
-                    "features_free_li5": "• Keine Registrierung erforderlich",
-                    "features_free_cta": "Kostenlosen Schnelltest starten",
-                    "features_pro_title": "Pro-Modus",
-                    "features_pro_badge": "Für Power-User & Teams",
-                    "features_pro_text": "Für alle, die volle Kontrolle brauchen: IT-Abteilungen, Techniker, Refurbisher, Labore oder Unternehmen, die regelmäßig größere Stick-Mengen testen.",
-                    "features_pro_li1": "• Tiefenscan der gesamten Kapazität (ähnlich F3 / badblocks)",
-                    "features_pro_li2": "• Erkennung von Kapazitäts-Fakes und defekten Bereichen",
-                    "features_pro_li3": "• Detaillierte, speicherbare Testberichte (JSON, PDF)",
-                    "features_pro_li4": "• Optional: API-Zugriff für automatisierte Testprozesse",
-                    "features_pro_li5": "• Multi-Device- und Multi-User-Support (über Login-Bereich)",
-                    "features_pro_note": "Der Pro-Modus erfordert ein kleines Helfer-Tool auf deinem System. Dieses arbeitet lokal und kann bei Bedarf mit deinem Account auf USBCheck verbunden werden."
-                },
-                "faq": {
-                    "faq_kicker": "FAQ",
-                    "faq_title": "Häufige Fragen zu USBCheck",
-                    "faq_intro": "Hier findest du Antworten auf häufig gestellte Fragen. Der FAQ-Bereich kann jederzeit erweitert werden, wenn neue Anwendungsfälle hinzukommen oder du Feedback von Nutzern erhältst.",
-                    "faq_q1": "Ist der Schnelltest wirklich komplett im Browser?",
-                    "faq_a1": "Ja. Der Schnelltest läuft vollständig im Browser und nutzt moderne Browser-APIs, um Testdateien auf deinem Stick zu schreiben und wieder auszulesen. Es wird nichts ohne deine Zustimmung hochgeladen.",
-                    "faq_q2": "Brauche ich ein Konto, um den Schnelltest zu benutzen?",
-                    "faq_a2": "Nein. Der kostenlose Schnelltest ist ohne Registrierung nutzbar. Ein Login ist nur notwendig, wenn du Testberichte speichern, mehrere Sticks verwalten oder den Pro-Modus nutzen möchtest.",
-                    "faq_q3": "Kann USBCheck jeden Fake-Stick sicher erkennen?",
-                    "faq_a3": "Kein Tool kann eine 100 %-Garantie geben. Der Pro-Modus mit Vollscan ist jedoch darauf ausgelegt, typische Fälschungsmuster (Manipulation der gemeldeten Kapazität, instabile Bereiche, Fehler ab einer bestimmten Füllmenge) sehr zuverlässig zu erkennen.",
-                    "faq_q4": "Wie fügt sich das Tool in mein bestehendes System ein?",
-                    "faq_a4": "USBCheck ist von Anfang an für Automatisierung gedacht. Über den Pro-Modus und die geplante API kannst du Tests in bestehende Workflows integrieren – beispielsweise in Wareneingangsprüfungen oder Qualitätskontrollen."
-                },
-                "problem": {
-                    "problem_kicker": "Warum gefälschte USB-Sticks gefährlich sind",
-                    "problem_title": "Gefälschte USB-Sticks kosten Geld – und im schlimmsten Fall deine Daten.",
-                    "problem_p1": "Viele Billig-USB-Sticks werben mit unrealistisch hohen Kapazitäten. In Wahrheit wurde der Controller manipuliert: Der Stick meldet z. B. 256 GB, obwohl physisch nur 32 GB verbaut sind. Die Folge: Daten werden scheinbar korrekt kopiert, später aber stillschweigend überschrieben oder beschädigt.",
-                    "problem_p2": "USBCheck hilft dir, solche Fakes zu erkennen, bevor du sie produktiv einsetzt – egal ob du einzelne Sticks privat nutzt oder größere Chargen für dein Unternehmen prüfst.",
-                    "problem_card1_title": "Verlust wichtiger Dateien",
-                    "problem_card1_text": "Fotos, Projektdateien, Backups – alles kann betroffen sein, wenn der Stick weniger speichert als behauptet. Defekte Sektoren bleiben oft unbemerkt, bis es zu spät ist.",
-                    "problem_card2_title": "Kosten durch defekte Chargen",
-                    "problem_card2_text": "Unternehmen, Reseller und Agenturen verteilen USB-Sticks oft in großer Stückzahl. Fakes bedeuten Reklamationen, Imageschaden und erneute Produktionskosten.",
-                    "problem_card3_title": "Unsichere Performance",
-                    "problem_card3_text": "Langsame Controller, instabile Firmware und schwankende Schreibraten sind typisch für Fake-Sticks. Das erhöht das Risiko von Fehlern – besonders bei großen Dateien."
-                }
-            }
-        },
-        "dashboard": {
-            "meta": {
-                "title": "{{primary_domain}} – Dashboard",
-                "description": "Beschreibung für Dashboard auf {{primary_domain}}"
-            },
-            "sections": {
-                "dashboard": {
-                    "dashboard_kicker": "Dashboard",
-                    "dashboard_title": "Willkommen",
-                    "dashboard_intro": "Hier kannst du deine USB-Tests verwalten, Geräte übersichtlich organisieren und später den Pro-Modus aktivieren. Dieser Bereich ist aktuell noch im Aufbau – du bekommst aber schon einen ersten Überblick.",
-                    "dashboard_plan_label": "Aktueller Plan",
-                    "dashboard_card_tests_title": "Letzte Tests",
-                    "dashboard_card_tests_text": "Hier werden später deine letzten Schnelltests und Pro-Scans angezeigt – inklusive Status, Geschwindigkeit und Integritätsprüfung.",
-                    "dashboard_card_tests_empty": "Noch keine Testdaten vorhanden. Starte einen ersten Test über den Browser oder den Pro-Modus.",
-                    "dashboard_card_devices_title": "Deine USB-Geräte",
-                    "dashboard_card_devices_text": "Später kannst du hier deine getesteten Sticks verwalten: Hersteller, Modell, Seriennummer und erkannte Kapazität.",
-                    "dashboard_card_devices_empty": "Noch keine Geräte gespeichert. Nach deinen ersten Tests kannst du USB-Sticks hier als Geräte anlegen.",
-                    "dashboard_card_next_title": "Nächste Schritte",
-                    "dashboard_card_next_text": "USBCheck ist noch im Aufbau. Du gehörst zu den ersten Nutzern – später findest du hier Pro-Optionen, API-Zugänge und Detail-Reports.",
-                    "dashboard_card_next_item1": "• Browser-FakeCheck testen und Feedback geben",
-                    "dashboard_card_next_item2": "• Pro-Modus-Features definieren (z. B. Vollscan, Reports, API)",
-                    "dashboard_card_next_item3": "• Accounts & SSO (my-log.in) finalisieren",
-                    "dashboard_card_next_cta": "Zum Browser-FakeCheck"
-                }
-            }
-        },
-        "fakecheck": {
-            "meta": {
-                "title": "{{primary_domain}} – Fakecheck",
-                "description": "Beschreibung für Fakecheck auf {{primary_domain}}"
-            },
-            "sections": {
-                "hero": {
-                    "fake_hero_kicker": "FakeCheck – Browser-Modus",
-                    "fake_hero_title": "Ist mein USB-Stick fake?",
-                    "fake_hero_lead": "Der FakeCheck hilft dir, typische Fake-Sticks aufzuspüren: Browser-basierte Schreib-/Lesetests und Plausibilitätsprüfungen der nutzbaren Kapazität – ohne Installation.",
-                    "fake_cta_start": "Browser-Test starten (Demo)",
-                    "fake_cta_back_home": "Zur Übersicht zurück",
-                    "fake_hero_hint": "Der FakeCheck im Browser arbeitet mit Testdateien und Lese-/Schreibmustern, die du in einem ausgewählten Ordner anlegst. Deine echten Dateien bleiben unangetastet.",
-                    "fake_box_title": "Was der Browser-Test leisten kann",
-                    "fake_box_point1_title": "Schreib-/Lesetest mit Testdateien",
-                    "fake_box_point1_text": "Der Browser legt Testdateien im gewählten Ordner an, misst Schreib- und Leseraten und prüft, ob gelesene Daten mit den geschriebenen Mustern übereinstimmen.",
-                    "fake_box_point2_title": "Plausibilitätscheck der Kapazität",
-                    "fake_box_point2_text": "Aus der Menge der erfolgreich geschriebenen und verifizierten Daten ergibt sich ein realistischer Eindruck, wie viel Nutzkapazität tatsächlich stabil ankommt.",
-                    "fake_box_point3_title": "JSON-Report für deine Dokumentation",
-                    "fake_box_point3_text": "Alle Ergebnisse werden in einem strukturierten JSON-Report gesammelt, den du speichern, hochladen oder für spätere Vergleiche nutzen kannst."
-                }
-            }
-        },
-        "login": {
-            "meta": {
-                "title": "{{primary_domain}} – Login",
-                "description": "Beschreibung für Login auf {{primary_domain}}"
-            },
-            "sections": {
-                "login": {
-                    "auth_kicker": "Account & Login",
-                    "auth_title": "Melde dich bei USBCheck an",
-                    "auth_intro": "Mit einem Account kannst du Tests speichern, Reports exportieren und den Pro-Modus auf mehreren Geräten nutzen. Die Registrierung ist kostenlos – du kannst später jederzeit auf Pro upgraden.",
-                    "auth_tab_login": "Login",
-                    "auth_tab_register": "Registrieren",
-                    "auth_login_title": "Login",
-                    "auth_login_text": "Melde dich mit deiner E-Mail-Adresse und deinem Passwort an.",
-                    "auth_login_email_label": "E-Mail-Adresse",
-                    "auth_login_password_label": "Passwort",
-                    "auth_login_submit": "Einloggen",
-                    "auth_login_forgot": "Passwort vergessen?",
-                    "auth_register_title": "Kostenlos registrieren",
-                    "auth_register_text": "Erstelle einen kostenlosen Account, um Tests zu speichern, Berichte zu exportieren und den Pro-Modus später freizuschalten.",
-                    "auth_register_name_label": "Name",
-                    "auth_register_email_label": "E-Mail-Adresse",
-                    "auth_register_password_label": "Passwort",
-                    "auth_register_submit": "Account erstellen",
-                    "auth_register_hint": "Durch die Registrierung akzeptierst du die Datenschutzerklärung und das Impressum von USBCheck."
-                }
-            }
-        },
-        "tools": {
-            "meta": {
-                "title": "{{primary_domain}} – Tools",
-                "description": "Beschreibung für Tools auf {{primary_domain}}"
-            }
-        }
-    },
-    "partials": {
-        "structure": {
-            "layout_end": {
-                "logout_modal_title": "Wirklich ausloggen?",
-                "logout_modal_text": "Wenn du dich abmeldest, werden deine Sitzung und alle nicht gespeicherten Aktionen beendet. Du kannst dich jederzeit wieder einloggen.",
-                "logout_modal_cancel": "Abbrechen",
-                "logout_modal_confirm": "Ja, ausloggen"
-            },
-            "header": {
-                "header_slogan": "USB-Sticks testen",
-                "header_btn_login": "Login",
-                "header_menu_dashboard": "Dashboard",
-                "header_menu_logout": "Logout",
-                "logout_title": "Wirklich abmelden?",
-                "logout_text": "Du wirst von deinem USBCheck-Konto abgemeldet. Aktive Tests im Browser-Modus sind davon nicht betroffen.",
-                "logout_cancel": "Abbrechen",
-                "logout_confirm": "Ja, abmelden"
-            },
-            "footer": {
-                "footer_imprint": "partials.structure.footer.footer_imprint",
-                "footer_privacy": "partials.structure.footer.footer_privacy"
-            }
-        }
-    }
-}

public/assets/i18n/el.json

@@ -1,236 +0,0 @@
-{
-    "meta": {
-        "code": "el",
-        "label": "Ελληνικά",
-        "flag": "🇬🇷",
-        "enabled": true
-    },
-    "pages": {
-        "landing": {
-            "meta": {
-                "title": "Χωρίς τίτλο"
-            }
-        },
-        "main": {
-            "anchors": {
-                "how": "Πώς λειτουργεί",
-                "problem": "Γιατί τα πλαστά USB είναι επικίνδυνα",
-                "features": "Λειτουργίες",
-                "security": "Ασφάλεια",
-                "faq": "Συχνές ερωτήσεις"
-            },
-            "sections": {
-                "security": {
-                    "security_kicker": "Ασφάλεια & ιδιωτικότητα",
-                    "security_title": "Σχεδιασμός με προτεραιότητα την ιδιωτικότητα: Τα δεδομένα των δοκιμών σου ανήκουν μόνο σε εσένα.",
-                    "security_intro": "Το USBCheck σχεδιάστηκε από την αρχή ώστε να προστατεύει τα δεδομένα σου. Ο γρήγορος έλεγχος λειτουργεί αποκλειστικά με αρχεία δοκιμής. Τα προσωπικά σου αρχεία, φωτογραφίες ή αντίγραφα ασφαλείας δεν διαβάζονται ούτε μεταφέρονται. Στη λειτουργία Pro έχεις πλήρη έλεγχο για το αν και ποιες αναφορές θα συγχρονίζονται με τον λογαριασμό σου.",
-                    "security_card1_title": "Έλεγχοι μόνο τοπικά",
-                    "security_card1_text": "Όλες οι δοκιμές εγγραφής και ανάγνωσης εκτελούνται τοπικά στο USB σου. Το πρόγραμμα περιήγησης έχει πρόσβαση μόνο στα αρχεία δοκιμής – ποτέ στα προσωπικά σου δεδομένα.",
-                    "security_card2_title": "Διαφανείς αναφορές",
-                    "security_card2_text": "Αν συνδεθείς, μπορείς να αποθηκεύεις, να εξάγεις ή να διαγράφεις αναφορές δοκιμών. Εσύ αποφασίζεις τι μένει στο σύστημα.",
-                    "security_card3_title": "Φιλικό προς το υλικό",
-                    "security_card3_text": "Ο γρήγορος έλεγχος χρησιμοποιεί μετρημένες ποσότητες δεδομένων ώστε να μειώνει την περιττή καταπόνηση. Η λειτουργία Pro προειδοποιεί ξεκάθαρα πριν εκτελέσει πλήρη σάρωση με υψηλό φορτίο εγγραφής."
-                },
-                "how": {
-                    "how_kicker": "Πώς λειτουργεί το USBCheck",
-                    "how_title": "Γρήγορος έλεγχος στο πρόγραμμα περιήγησης, βαθιά ανάλυση στη λειτουργία Pro.",
-                    "how_intro": "Το USBCheck συνδυάζει δύο κόσμους: έναν απλό γρήγορο έλεγχο για όλους και μια βαθύτερη λειτουργία Pro για power-users, τεχνικούς και διαχειριστές. Ο γρήγορος έλεγχος εκτελείται απευθείας στο πρόγραμμα περιήγησης χωρίς εγκατάσταση. Η λειτουργία Pro χρησιμοποιεί ένα μικρό βοηθητικό εργαλείο που μπορεί να εκτελέσει δοκιμές τύπου F3 / badblocks για να εντοπίζει με ασφάλεια ψεύτικες χωρητικότητες.",
-                    "how_step1_title": "Ξεκίνα τον έλεγχο στο πρόγραμμα περιήγησης",
-                    "how_step1_text": "Άνοιξε τον γρήγορο έλεγχο στη διεύθυνση:",
-                    "how_step2_title": "Έλεγχος εγγραφής, ανάγνωσης & ακεραιότητας",
-                    "how_step2_text": "Το πρόγραμμα περιήγησης δημιουργεί αρχεία δοκιμής, μετρά ταχύτητες εγγραφής/ανάγνωσης και συγκρίνει hash για την ανίχνευση λαθών – όλα τοπικά, χωρίς μεταφορά των δικών σου δεδομένων.",
-                    "how_step3_title": "Προαιρετικό: Πλήρης σάρωση με λειτουργία Pro",
-                    "how_step3_text": "Αν θέλεις περισσότερες λεπτομέρειες, μπορείς να εγκαταστήσεις το βοηθητικό εργαλείο. Μπορεί να ελέγξει ολόκληρη τη χωρητικότητα, να εντοπίσει προβληματικούς τομείς και να δημιουργήσει αναλυτικές αναφορές – ιδανικό για refurbishers, τμήματα IT ή εργαστήρια.",
-                    "how_side_title": "Free vs Pro με μια ματιά",
-                    "how_side_free": "pages.main.sections.how.how_side_free",
-                    "how_side_pro": "pages.main.sections.how.how_side_pro",
-                    "how_side_account": "pages.main.sections.how.how_side_account"
-                },
-                "hero": {
-                    "hero_kicker": "Ανακάλυψε ψεύτικα USB πριν χάσεις δεδομένα",
-                    "hero_title": "Είναι το USB μου ψεύτικο;",
-                    "hero_lead": "Το USBCheck συνδυάζει έναν γρήγορο έλεγχο στο πρόγραμμα περιήγησης με μια επαγγελματική λειτουργία Pro. Έτσι εντοπίζεις ψεύτικα USB, μικρότερη πραγματική χωρητικότητα και αργούς ελεγκτές – πριν χαθούν τα αρχεία σου.",
-                    "cta_quick": "Ξεκίνα τον δωρεάν γρήγορο έλεγχο",
-                    "cta_learn": "Μάθε περισσότερα για Free & Pro",
-                    "trust1_title": "Χωρίς εγκατάσταση",
-                    "trust1_text": "Έλεγχος μέσω browser, απευθείας στο USB.",
-                    "trust2_title": "Πραγματικά τεστ εγγραφής/ανάγνωσης",
-                    "trust2_text": "Μέτρηση απόδοσης με πραγματικά δεδομένα – όχι θεωρητικές τιμές.",
-                    "trust3_title": "Ιδιωτικότητα πρώτα",
-                    "trust3_text": "Τα δεδομένα των δοκιμών παραμένουν τοπικά – οι αναφορές συγχρονίζονται μόνο αν το επιλέξεις.",
-                    "quick_label": "ΠΡΟΕΠΙΣΚΟΠΗΣΗ ΓΡΗΓΟΡΟΥ ΕΛΕΓΧΟΥ",
-                    "quick_title": "Έλεγξε ένα USB σε λιγότερο από 2 λεπτά",
-                    "badge_free": "Δωρεάν",
-                    "quick_metric1_label": "Απόδοση εγγραφής",
-                    "quick_metric1_value": "~ 75–120 MB/s*",
-                    "quick_metric2_label": "Έλεγχοι ακεραιότητας",
-                    "quick_metric2_value": "Δείγμα 512 MB",
-                    "quick_intro": "Ο γρήγορος έλεγχος μετράει:",
-                    "quick_li1": "Ταχύτητα εγγραφής & ανάγνωσης",
-                    "quick_li2": "Ακεραιότητα δεδομένων (hash σύγκριση)",
-                    "quick_li3": "Ύποπτες διακοπές ή σφάλματα",
-                    "quick_visual_title": "Δείκτης γρήγορου ελέγχου",
-                    "quick_visual_text": "Η προεπισκόπηση δείχνει: Πράσινο = σταθερό USB, Πορτοκαλί = προειδοποίηση για ανωμαλίες.",
-                    "quick_visual_window": "Παράθυρο αποτελεσμάτων",
-                    "quick_footnote": "*Ενδεικτικές τιμές – τα αποτελέσματα εξαρτώνται από USB, θύρα & σύστημα.",
-                    "quick_cta": "Μετάβαση στον δωρεάν γρήγορο έλεγχο"
-                },
-                "features": {
-                    "features_kicker": "Χαρακτηριστικά Free & Pro",
-                    "features_title": "Ξεκίνα με τον δωρεάν γρήγορο έλεγχο – πέρασε στο Pro όταν χρειαστείς περισσότερα.",
-                    "features_intro": "Το USBCheck εξελίσσεται σύμφωνα με τις ανάγκες σου: Οι απλοί χρήστες χρειάζονται γρήγορη εκτίμηση, ενώ οι επαγγελματίες θέλουν βαθύτερη ανάλυση και αρχειοθέτηση αναφορών.",
-                    "features_free_title": "Free Quick Check",
-                    "features_free_badge": "Προτείνεται για τους περισσότερους χρήστες",
-                    "features_free_text": "Ιδανικό για όσους θέλουν να ελέγξουν γρήγορα αν ένα USB λειτουργεί σταθερά – χωρίς εγκατάσταση.",
-                    "features_free_li1": "• Γρήγορος έλεγχος μέσω browser",
-                    "features_free_li2": "• Μετρήσεις πραγματικών ταχυτήτων εγγραφής/ανάγνωσης",
-                    "features_free_li3": "• Έλεγχος ακεραιότητας με hash",
-                    "features_free_li4": "• Επιλογή επιπέδων δοκιμής (200 MB, 2 GB)",
-                    "features_free_li5": "• Δεν απαιτείται λογαριασμός",
-                    "features_free_cta": "Ξεκίνα τον δωρεάν έλεγχο",
-                    "features_pro_title": "Λειτουργία Pro",
-                    "features_pro_badge": "Για power-users & ομάδες",
-                    "features_pro_text": "Για όσους χρειάζονται πλήρη έλεγχο: τμήματα IT, τεχνικούς, εργαστήρια ή επιχειρήσεις που δοκιμάζουν μεγάλες ποσότητες USB.",
-                    "features_pro_li1": "• Πλήρης σάρωση χωρητικότητας (τύπου F3 / badblocks)",
-                    "features_pro_li2": "• Εντοπισμός ψεύτικων χωρητικοτήτων και προβληματικών περιοχών",
-                    "features_pro_li3": "• Αναλυτικές αναφορές (JSON, PDF)",
-                    "features_pro_li4": "• Προαιρετικό API για αυτοματοποιημένες διαδικασίες",
-                    "features_pro_li5": "• Υποστήριξη πολλαπλών συσκευών & χρηστών",
-                    "features_pro_note": "Η λειτουργία Pro απαιτεί ένα μικρό τοπικό εργαλείο. Λειτουργεί τοπικά και μπορεί να συγχρονιστεί με τον λογαριασμό σου."
-                },
-                "faq": {
-                    "faq_kicker": "Συχνές ερωτήσεις",
-                    "faq_title": "Συχνές ερωτήσεις για το USBCheck",
-                    "faq_intro": "Εδώ θα βρεις απαντήσεις σε συχνές ερωτήσεις. Το FAQ θα επεκτείνεται με βάση τα σχόλια και τις ανάγκες των χρηστών.",
-                    "faq_q1": "Είναι όντως ο γρήγορος έλεγχος πλήρως στο πρόγραμμα περιήγησης;",
-                    "faq_a1": "Ναι. Ο έλεγχος εκτελείται εξ ολοκλήρου στο browser, δημιουργώντας και διαβάζοντας αρχεία δοκιμής τοπικά. Τίποτα δεν ανεβαίνει χωρίς άδεια.",
-                    "faq_q2": "Χρειάζεται λογαριασμός για τον γρήγορο έλεγχο;",
-                    "faq_a2": "Όχι. Ο δωρεάν έλεγχος λειτουργεί χωρίς σύνδεση. Ο λογαριασμός χρειάζεται μόνο για αποθήκευση αναφορών ή χρήση Pro.",
-                    "faq_q3": "Μπορεί το USBCheck να εντοπίσει κάθε ψεύτικο USB;",
-                    "faq_a3": "Κανένα εργαλείο δεν προσφέρει 100% εγγύηση. Ωστόσο ο Pro πλήρης έλεγχος είναι σχεδιασμένος ώστε να εντοπίζει αξιόπιστα συνηθισμένα μοτίβα απάτης.",
-                    "faq_q4": "Μπορώ να ενσωματώσω το USBCheck στο σύστημά μου;",
-                    "faq_a4": "Ναι. Το USBCheck έχει σχεδιαστεί για εύκολη αυτοματοποίηση. Η λειτουργία Pro και το μελλοντικό API θα επιτρέψουν ενσωμάτωση σε ροές εργασίας, όπως έλεγχο εισερχόμενου εξοπλισμού."
-                },
-                "problem": {
-                    "problem_kicker": "Γιατί τα ψεύτικα USB είναι επικίνδυνα",
-                    "problem_title": "Τα ψεύτικα USB κοστίζουν χρήματα – και μπορούν να καταστρέψουν τα δεδομένα σου.",
-                    "problem_p1": "Πολλά φθηνά USB υπόσχονται εξωπραγματικές χωρητικότητες. Στην πραγματικότητα, ο ελεγκτής έχει τροποποιηθεί ώστε να αναφέρει ψευδή χωρητικότητα. Όταν ξεπεραστεί η πραγματική, τα νεότερα δεδομένα αντικαθιστούν τα παλαιά χωρίς προειδοποίηση.",
-                    "problem_p2": "Το USBCheck σε βοηθά να εντοπίζεις αυτά τα προβλήματα πριν τα USB χρησιμοποιηθούν πραγματικά – είτε είσαι ιδιώτης είτε επιχείρηση.",
-                    "problem_card1_title": "Απώλεια σημαντικών αρχείων",
-                    "problem_card1_text": "Φωτογραφίες, έργα, αντίγραφα ασφαλείας – όλα μπορούν να καταστραφούν αν το USB αποθηκεύει λιγότερο απ’ όσο ισχυρίζεται.",
-                    "problem_card2_title": "Κόστη από προβληματικές παρτίδες",
-                    "problem_card2_text": "Επιχειρήσεις και οργανισμοί διανέμουν USB σε μεγάλες ποσότητες. Τα ψεύτικα USB δημιουργούν παράπονα, ζημιά στη φήμη και επιπλέον κόστη.",
-                    "problem_card3_title": "Ασταθής απόδοση",
-                    "problem_card3_text": "Αργοί ελεγκτές, ασταθές firmware και μεταβαλλόμενες ταχύτητες είναι συχνά σημάδια ψεύτικων USB."
-                }
-            }
-        },
-        "dashboard": {
-            "meta": {
-                "title": "{{primary_domain}} – Πίνακας Ελέγχου",
-                "description": "Περιγραφή για τον Πίνακα Ελέγχου στο {{primary_domain}}"
-            },
-            "sections": {
-                "dashboard": {
-                    "dashboard_kicker": "Πίνακας Ελέγχου",
-                    "dashboard_title": "Καλώς ήρθες",
-                    "dashboard_intro": "Εδώ μπορείς να διαχειριστείς τις δοκιμές USB, να οργανώσεις συσκευές και στο μέλλον να ενεργοποιήσεις τη λειτουργία Pro. Αυτή η περιοχή βρίσκεται ακόμα υπό ανάπτυξη.",
-                    "dashboard_plan_label": "Τρέχον πλάνο",
-                    "dashboard_card_tests_title": "Πρόσφατες δοκιμές",
-                    "dashboard_card_tests_text": "Εδώ θα εμφανίζονται οι πρόσφατες δοκιμές – συμπεριλαμβανομένης της κατάστασης, ταχύτητας και ελέγχου ακεραιότητας.",
-                    "dashboard_card_tests_empty": "Δεν υπάρχουν ακόμα δεδομένα. Ξεκίνα μια δοκιμή μέσω browser ή Pro.",
-                    "dashboard_card_devices_title": "Οι USB συσκευές σου",
-                    "dashboard_card_devices_text": "Στο μέλλον εδώ θα βλέπεις τις συσκευές που έχεις ελέγξει: κατασκευαστή, μοντέλο, σειριακό αριθμό και πραγματική χωρητικότητα.",
-                    "dashboard_card_devices_empty": "Δεν έχουν αποθηκευτεί συσκευές. Μετά την πρώτη δοκιμή μπορείς να καταχωρήσεις USB εδώ.",
-                    "dashboard_card_next_title": "Επόμενα βήματα",
-                    "dashboard_card_next_text": "Το USBCheck βρίσκεται υπό εξέλιξη. Ως από τους πρώτους χρήστες, θα μπορείς σύντομα να χρησιμοποιήσεις Pro επιλογές, API και λεπτομερείς αναφορές.",
-                    "dashboard_card_next_item1": "• Δοκίμασε το Browser FakeCheck και δώσε σχόλια",
-                    "dashboard_card_next_item2": "• Καθόρισε Pro δυνατότητες (πλήρης σάρωση, αναφορές, API)",
-                    "dashboard_card_next_item3": "• Ολοκλήρωσε τους λογαριασμούς & SSO (my-log.in)",
-                    "dashboard_card_next_cta": "Μετάβαση στο FakeCheck"
-                }
-            }
-        },
-        "fakecheck": {
-            "meta": {
-                "title": "{{primary_domain}} – FakeCheck",
-                "description": "Περιγραφή για FakeCheck στο {{primary_domain}}"
-            },
-            "sections": {
-                "hero": {
-                    "fake_hero_kicker": "FakeCheck — Browser Mode",
-                    "fake_hero_title": "Είναι το USB μου ψεύτικο;",
-                    "fake_hero_lead": "Το FakeCheck σε βοηθά να εντοπίσεις ψεύτικα USB: τεστ εγγραφής/ανάγνωσης από τον browser και έλεγχος πραγματικής χωρητικότητας – χωρίς εγκατάσταση.",
-                    "fake_cta_start": "Έναρξη ελέγχου (Demo)",
-                    "fake_cta_back_home": "Επιστροφή στην επισκόπηση",
-                    "fake_hero_hint": "Το FakeCheck δημιουργεί αρχεία δοκιμής στον φάκελο που επιλέγεις. Τα πραγματικά αρχεία σου παραμένουν ανέγγιχτα.",
-                    "fake_box_title": "Τι μπορεί να κάνει ο έλεγχος στον browser",
-                    "fake_box_point1_title": "Τεστ εγγραφής/ανάγνωσης με αρχεία",
-                    "fake_box_point1_text": "Γράφει και διαβάζει δεδομένα από πραγματικά αρχεία, και ελέγχει αν τα πρότυπα ταιριάζουν.",
-                    "fake_box_point2_title": "Έλεγχος πραγματικής χωρητικότητας",
-                    "fake_box_point2_text": "Η ποσότητα επιτυχώς γραμμένων και επαληθευμένων δεδομένων δείχνει τη σταθερή, πραγματικά διαθέσιμη χωρητικότητα.",
-                    "fake_box_point3_title": "JSON αναφορά για τεκμηρίωση",
-                    "fake_box_point3_text": "Όλα τα αποτελέσματα αποθηκεύονται σε JSON αναφορά για χρήση, αρχειοθέτηση ή σύγκριση."
-                }
-            }
-        },
-        "login": {
-            "meta": {
-                "title": "{{primary_domain}} – Σύνδεση",
-                "description": "Περιγραφή για Σύνδεση στο {{primary_domain}}"
-            },
-            "sections": {
-                "login": {
-                    "auth_kicker": "Λογαριασμός & σύνδεση",
-                    "auth_title": "Συνδέσου στο USBCheck",
-                    "auth_intro": "Με έναν λογαριασμό μπορείς να αποθηκεύεις δοκιμές, να εξάγεις αναφορές και να χρησιμοποιείς τη λειτουργία Pro σε πολλές συσκευές. Η εγγραφή είναι δωρεάν.",
-                    "auth_tab_login": "Σύνδεση",
-                    "auth_tab_register": "Εγγραφή",
-                    "auth_login_title": "Σύνδεση",
-                    "auth_login_text": "Χρησιμοποίησε το email και τον κωδικό πρόσβασής σου.",
-                    "auth_login_email_label": "Email",
-                    "auth_login_password_label": "Κωδικός πρόσβασης",
-                    "auth_login_submit": "Είσοδος",
-                    "auth_login_forgot": "Ξέχασες τον κωδικό;",
-                    "auth_register_title": "Δωρεάν εγγραφή",
-                    "auth_register_text": "Δημιούργησε δωρεάν λογαριασμό για να αποθηκεύεις δοκιμές και να χρησιμοποιείς τη λειτουργία Pro.",
-                    "auth_register_name_label": "Όνομα",
-                    "auth_register_email_label": "Email",
-                    "auth_register_password_label": "Κωδικός πρόσβασης",
-                    "auth_register_submit": "Δημιουργία λογαριασμού",
-                    "auth_register_hint": "Με την εγγραφή αποδέχεσαι την πολιτική απορρήτου και τους όρους χρήσης του USBCheck."
-                }
-            }
-        },
-        "tools": {
-            "meta": {
-                "title": "{{primary_domain}} – Εργαλεία",
-                "description": "Περιγραφή για Εργαλεία στο {{primary_domain}}"
-            }
-        }
-    },
-    "partials": {
-        "structure": {
-            "layout_end": {
-                "logout_modal_title": "Θέλεις σίγουρα να αποσυνδεθείς;",
-                "logout_modal_text": "Αν αποσυνδεθείς, η συνεδρία θα λήξει και ενδέχεται να χαθούν μη αποθηκευμένες ενέργειες.",
-                "logout_modal_cancel": "Ακύρωση",
-                "logout_modal_confirm": "Ναι, αποσύνδεση"
-            },
-            "header": {
-                "header_slogan": "Έλεγχος USB συσκευών",
-                "header_btn_login": "Σύνδεση",
-                "header_menu_dashboard": "Πίνακας Ελέγχου",
-                "header_menu_logout": "Αποσύνδεση",
-                "logout_title": "Αποσύνδεση;",
-                "logout_text": "Θα αποσυνδεθείς από τον λογαριασμό USBCheck. Οι δοκιμές στο browser δεν θα επηρεαστούν.",
-                "logout_cancel": "Ακύρωση",
-                "logout_confirm": "Ναι, αποσύνδεση"
-            },
-            "footer": {
-                "footer_imprint": "partials.structure.footer.footer_imprint",
-                "footer_privacy": "partials.structure.footer.footer_privacy"
-            }
-        }
-    }
-}

public/assets/i18n/en.json

@@ -1,236 +0,0 @@
-{
-    "meta": {
-        "code": "en",
-        "label": "English",
-        "flag": "🇬🇧",
-        "enabled": true
-    },
-    "pages": {
-        "landing": {
-            "meta": {
-                "title": "NO TITLE"
-            }
-        },
-        "main": {
-            "anchors": {
-                "how": "How it works",
-                "problem": "Why fake drives are dangerous",
-                "features": "Features",
-                "security": "Security",
-                "faq": "FAQ"
-            },
-            "sections": {
-                "security": {
-                    "security_kicker": "Security & privacy",
-                    "security_title": "Privacy-first design: Your test data belongs to you.",
-                    "security_intro": "USBCheck was designed from the ground up to keep your data protected. The browser quick check works exclusively with test files. Your own documents, photos or backups are neither read nor transmitted. In Pro mode, you remain in full control of whether and which reports are synchronized with your account.",
-                    "security_card1_title": "Local-only tests",
-                    "security_card1_text": "All write and read tests are performed locally on your USB drive. The browser only accesses the test files – not your private content.",
-                    "security_card2_title": "Transparent reports",
-                    "security_card2_text": "If you log in, you can store test reports in your account, export them or delete them again. You decide which data remains in the system.",
-                    "security_card3_title": "Gentle on your hardware",
-                    "security_card3_text": "The quick check uses moderate data volumes to avoid unnecessary wear. The Pro mode clearly warns you when a full scan with high write load is executed."
-                },
-                "how": {
-                    "how_kicker": "How USBCheck works",
-                    "how_title": "Quick browser test, Pro mode with in-depth analysis.",
-                    "how_intro": "USBCheck was built to combine two worlds: a simple quick check for everyone and a deep Pro mode for power users, technicians and admins. The quick check runs directly in the browser, without installation. For the Pro mode, a small helper tool is used that can perform F3 / badblocks-like tests on demand to reliably detect capacity fakes.",
-                    "how_step1_title": "Start browser test",
-                    "how_step1_text": "You open the quick check at",
-                    "how_step2_title": "Write, read and integrity checks",
-                    "how_step2_text": "The browser creates test files, measures write and read speed and compares hash values to detect data errors – all locally and without transmitting your content.",
-                    "how_step3_title": "Optional: Pro mode for full scan",
-                    "how_step3_text": "If you want deeper insights, you install the optional helper tool. It can check the full capacity of the drive, identify fakes and generate detailed reports – ideal for refurbishers, IT departments or labs.",
-                    "how_side_title": "Free vs Pro at a glance",
-                    "how_side_free": "pages.main.sections.how.how_side_free",
-                    "how_side_pro": "pages.main.sections.how.how_side_pro",
-                    "how_side_account": "pages.main.sections.how.how_side_account"
-                },
-                "hero": {
-                    "hero_kicker": "Detect fake USB sticks before you lose data",
-                    "hero_title": "Is my USB stick fake?",
-                    "hero_lead": "USBCheck combines a fast browser test with a professional Pro mode. This lets you detect fake USB sticks, too-small real capacity and cheap, slow controllers – before your files disappear.",
-                    "cta_quick": "Start free quick check",
-                    "cta_learn": "Learn more about Free & Pro",
-                    "trust1_title": "No install for quick check",
-                    "trust1_text": "Browser-based test directly on your drive.",
-                    "trust2_title": "Real write & read tests",
-                    "trust2_text": "Write/read tests with real data – no synthetic theory.",
-                    "trust3_title": "Privacy first",
-                    "trust3_text": "Your test data stays local – reports only if you want.",
-                    "quick_label": "QUICK CHECK PREVIEW",
-                    "quick_title": "Test a USB drive in under 2 minutes",
-                    "badge_free": "Free",
-                    "quick_metric1_label": "Write performance",
-                    "quick_metric1_value": "~ 75–120 MB/s*",
-                    "quick_metric2_label": "Integrity checks",
-                    "quick_metric2_value": "512 MB sample",
-                    "quick_intro": "The quick check tests a defined data volume on your drive and measures:",
-                    "quick_li1": "Write and read speed",
-                    "quick_li2": "Data integrity (hash comparison)",
-                    "quick_li3": "Suspicious aborts or errors",
-                    "quick_visual_title": "Quick test indicator",
-                    "quick_visual_text": "This is what the quick test preview looks like: green marks a stable drive, orange warns in case of anomalies.",
-                    "quick_visual_window": "Result window",
-                    "quick_footnote": "*Example values – your results depend on drive, port & system.",
-                    "quick_cta": "Go to free quick check"
-                },
-                "features": {
-                    "features_kicker": "Free & Pro features",
-                    "features_title": "Start with the free quick check – switch to Pro mode when you need more.",
-                    "features_intro": "USBCheck grows with your needs: private users often just need a quick assessment. Professionals want to dig deeper, verify capacities and archive reports. That’s exactly what the Pro mode is built for.",
-                    "features_free_title": "Free Quick Check",
-                    "features_free_badge": "Recommended for most users",
-                    "features_free_text": "Ideal for everyone who wants to quickly check whether a USB drive is at least basically performant and stable – with no installation required.",
-                    "features_free_li1": "• Browser-based quick check directly on your drive",
-                    "features_free_li2": "• Write and read speed with real test data",
-                    "features_free_li3": "• Hash-based integrity check of a test volume",
-                    "features_free_li4": "• Choice of different test levels (e.g. 200 MB, 2 GB)",
-                    "features_free_li5": "• No registration required",
-                    "features_free_cta": "Start free quick check",
-                    "features_pro_title": "Pro Mode",
-                    "features_pro_badge": "For power users & teams",
-                    "features_pro_text": "For everyone who needs full control: IT departments, technicians, refurbishers, labs or companies that regularly test larger batches of USB drives.",
-                    "features_pro_li1": "• Deep scan of the full capacity (similar to F3 / badblocks)",
-                    "features_pro_li2": "• Detection of capacity fakes and defective areas",
-                    "features_pro_li3": "• Detailed, storable test reports (JSON, PDF)",
-                    "features_pro_li4": "• Optional API access for automated test workflows",
-                    "features_pro_li5": "• Multi-device and multi-user support (via login area)",
-                    "features_pro_note": "Pro mode requires a small helper tool on your system. It works locally and can be linked to your USBCheck account if needed."
-                },
-                "faq": {
-                    "faq_kicker": "FAQ",
-                    "faq_title": "Frequently asked questions about USBCheck",
-                    "faq_intro": "Here you’ll find answers to frequently asked questions. The FAQ section can be extended at any time as new use cases appear or you receive feedback from users.",
-                    "faq_q1": "Is the quick check really completely in the browser?",
-                    "faq_a1": "Yes. The quick check runs entirely in the browser and uses modern browser APIs to write and read test files on your drive. Nothing is uploaded without your consent.",
-                    "faq_q2": "Do I need an account to use the quick check?",
-                    "faq_a2": "No. The free quick check can be used without registration. A login is only required if you want to save test reports, manage multiple drives or use the Pro mode.",
-                    "faq_q3": "Can USBCheck reliably detect every fake drive?",
-                    "faq_a3": "No tool can give a 100% guarantee. However, the Pro mode with full scan is designed to detect typical fraud patterns (manipulated reported capacity, unstable areas, errors from a certain fill level) very reliably.",
-                    "faq_q4": "How does the tool fit into my existing system?",
-                    "faq_a4": "USBCheck is designed for automation. Via the Pro mode and the planned API you can integrate tests into existing workflows – for example into incoming goods inspection or quality control."
-                },
-                "problem": {
-                    "problem_kicker": "Why fake USB drives are dangerous",
-                    "problem_title": "Fake USB drives cost money – and in the worst case your data.",
-                    "problem_p1": "Many cheap USB drives advertise unrealistically high capacities. In reality, the controller has been manipulated: the drive reports e.g. 256 GB although physically only 32 GB are installed. The result: data appears to be copied correctly but is silently overwritten or damaged later.",
-                    "problem_p2": "USBCheck helps you detect such fakes before you use them in production – whether you use individual drives privately or test larger batches for your company.",
-                    "problem_card1_title": "Loss of important files",
-                    "problem_card1_text": "Photos, project files, backups – everything can be affected if the drive stores less than promised. Defective sectors often remain unnoticed until it’s too late.",
-                    "problem_card2_title": "Costs from defective batches",
-                    "problem_card2_text": "Companies, resellers and agencies often distribute USB drives in large quantities. Fakes mean complaints, damage to reputation and repeated production costs.",
-                    "problem_card3_title": "Unstable performance",
-                    "problem_card3_text": "Slow controllers, unstable firmware and fluctuating write speeds are typical of fake drives. This increases the risk of errors – especially with large files."
-                }
-            }
-        },
-        "dashboard": {
-            "meta": {
-                "title": "{{primary_domain}} – Dashboard",
-                "description": "Description for dashboard on {{primary_domain}}"
-            },
-            "sections": {
-                "dashboard": {
-                    "dashboard_kicker": "Dashboard",
-                    "dashboard_title": "Welcome",
-                    "dashboard_intro": "Here you can manage your USB tests, organize devices clearly and later activate Pro mode. This area is still under construction – but you already get a first overview.",
-                    "dashboard_plan_label": "Current plan",
-                    "dashboard_card_tests_title": "Latest tests",
-                    "dashboard_card_tests_text": "Your latest quick checks and Pro scans will be displayed here – including status, speed and integrity checks.",
-                    "dashboard_card_tests_empty": "No test data yet. Start your first test via the browser or Pro mode.",
-                    "dashboard_card_devices_title": "Your USB devices",
-                    "dashboard_card_devices_text": "Later you can manage your tested drives here: manufacturer, model, serial number and detected capacity.",
-                    "dashboard_card_devices_empty": "No devices stored yet. After your first tests you can create USB drives as devices here.",
-                    "dashboard_card_next_title": "Next steps",
-                    "dashboard_card_next_text": "USBCheck is still under development. You’re among the first users – later you’ll find Pro options, API access and detailed reports here.",
-                    "dashboard_card_next_item1": "• Try the browser FakeCheck and give feedback",
-                    "dashboard_card_next_item2": "• Define Pro mode features (e.g. full scan, reports, API)",
-                    "dashboard_card_next_item3": "• Finalize accounts & SSO (my-log.in)",
-                    "dashboard_card_next_cta": "Go to browser FakeCheck"
-                }
-            }
-        },
-        "fakecheck": {
-            "meta": {
-                "title": "{{primary_domain}} – FakeCheck",
-                "description": "Description for FakeCheck on {{primary_domain}}"
-            },
-            "sections": {
-                "hero": {
-                    "fake_hero_kicker": "FakeCheck – browser mode",
-                    "fake_hero_title": "Is my USB drive fake?",
-                    "fake_hero_lead": "FakeCheck helps you detect typical fake drives: browser-based write/read tests and plausibility checks of the usable capacity – with no installation.",
-                    "fake_cta_start": "Start browser test (demo)",
-                    "fake_cta_back_home": "Back to overview",
-                    "fake_hero_hint": "The browser-based FakeCheck works with test files and read/write patterns that you create in a selected folder. Your real files remain untouched.",
-                    "fake_box_title": "What the browser test can do",
-                    "fake_box_point1_title": "Write/read test with test files",
-                    "fake_box_point1_text": "The browser creates test files in the selected folder, measures write and read speed and checks whether the read data matches the written patterns.",
-                    "fake_box_point2_title": "Capacity plausibility check",
-                    "fake_box_point2_text": "From the amount of successfully written and verified data you get a realistic impression of how much usable capacity actually works stably.",
-                    "fake_box_point3_title": "JSON report for your documentation",
-                    "fake_box_point3_text": "All results are collected in a structured JSON report that you can save, upload or use for later comparison."
-                }
-            }
-        },
-        "login": {
-            "meta": {
-                "title": "{{primary_domain}} – Login",
-                "description": "Description for login on {{primary_domain}}"
-            },
-            "sections": {
-                "login": {
-                    "auth_kicker": "Account & login",
-                    "auth_title": "Sign in to USBCheck",
-                    "auth_intro": "With an account you can save tests, export reports and use Pro mode on multiple devices. Registration is free – you can upgrade to Pro at any time later.",
-                    "auth_tab_login": "Login",
-                    "auth_tab_register": "Register",
-                    "auth_login_title": "Login",
-                    "auth_login_text": "Sign in with your email address and password.",
-                    "auth_login_email_label": "Email address",
-                    "auth_login_password_label": "Password",
-                    "auth_login_submit": "Sign in",
-                    "auth_login_forgot": "Forgot your password?",
-                    "auth_register_title": "Register for free",
-                    "auth_register_text": "Create a free account to save tests, export reports and unlock Pro mode later.",
-                    "auth_register_name_label": "Name",
-                    "auth_register_email_label": "Email address",
-                    "auth_register_password_label": "Password",
-                    "auth_register_submit": "Create account",
-                    "auth_register_hint": "By registering you accept the privacy policy and legal imprint of USBCheck."
-                }
-            }
-        },
-        "tools": {
-            "meta": {
-                "title": "{{primary_domain}} – Tools",
-                "description": "Description for tools on {{primary_domain}}"
-            }
-        }
-    },
-    "partials": {
-        "structure": {
-            "layout_end": {
-                "logout_modal_title": "Really log out?",
-                "logout_modal_text": "If you log out, your session and all unsaved actions will be ended. You can log in again at any time.",
-                "logout_modal_cancel": "Cancel",
-                "logout_modal_confirm": "Yes, log out"
-            },
-            "header": {
-                "header_slogan": "Test USB drives",
-                "header_btn_login": "Login",
-                "header_menu_dashboard": "Dashboard",
-                "header_menu_logout": "Logout",
-                "logout_title": "Really sign out?",
-                "logout_text": "You will be logged out of your USBCheck account. Active tests in browser mode are not affected.",
-                "logout_cancel": "Cancel",
-                "logout_confirm": "Yes, sign out"
-            },
-            "footer": {
-                "footer_imprint": "partials.structure.footer.footer_imprint",
-                "footer_privacy": "partials.structure.footer.footer_privacy"
-            }
-        }
-    }
-}

public/assets/i18n/es.json

@@ -1,236 +0,0 @@
-{
-    "meta": {
-        "code": "es",
-        "label": "Español",
-        "flag": "🇪🇸",
-        "enabled": true
-    },
-    "pages": {
-        "landing": {
-            "meta": {
-                "title": "SIN TÍTULO"
-            }
-        },
-        "main": {
-            "anchors": {
-                "how": "Cómo funciona",
-                "problem": "Por qué son peligrosas las memorias USB falsas",
-                "features": "Funciones",
-                "security": "Seguridad",
-                "faq": "Preguntas frecuentes"
-            },
-            "sections": {
-                "security": {
-                    "security_kicker": "Seguridad y privacidad",
-                    "security_title": "Diseño centrado en la privacidad: tus datos te pertenecen.",
-                    "security_intro": "USBCheck fue diseñado desde el principio para mantener tus datos protegidos. La prueba rápida del navegador trabaja exclusivamente con archivos de prueba. Tus documentos, fotos o copias de seguridad no se leen ni se transmiten. En el modo Pro, tienes control total sobre si los informes se sincronizan con tu cuenta y cuáles.",
-                    "security_card1_title": "Pruebas solo locales",
-                    "security_card1_text": "Todas las pruebas de lectura y escritura se realizan localmente en tu unidad USB. El navegador solo accede a los archivos de prueba, no a tu contenido privado.",
-                    "security_card2_title": "Informes transparentes",
-                    "security_card2_text": "Si inicias sesión, puedes guardar informes de prueba en tu cuenta, exportarlos o eliminarlos. Tú decides qué datos permanecen en el sistema.",
-                    "security_card3_title": "Amigable con tu hardware",
-                    "security_card3_text": "La prueba rápida utiliza cantidades moderadas de datos para evitar desgaste innecesario. El modo Pro te advierte claramente cuando se ejecuta un escaneo completo con alta carga de escritura."
-                },
-                "how": {
-                    "how_kicker": "Cómo funciona USBCheck",
-                    "how_title": "Prueba rápida en el navegador, modo Pro con análisis profundo.",
-                    "how_intro": "USBCheck fue creado para combinar dos mundos: una prueba rápida sencilla para todos y un modo Pro profundo para usuarios avanzados, técnicos y administradores. La prueba rápida se ejecuta directamente en el navegador sin instalación. Para el modo Pro se utiliza una pequeña herramienta auxiliar que puede realizar pruebas similares a F3 / badblocks para detectar falsificaciones de capacidad de forma fiable.",
-                    "how_step1_title": "Iniciar prueba en el navegador",
-                    "how_step1_text": "Abres la prueba rápida en",
-                    "how_step2_title": "Pruebas de escritura, lectura e integridad",
-                    "how_step2_text": "El navegador crea archivos de prueba, mide la velocidad de lectura y escritura y compara valores hash para detectar errores de datos, todo localmente y sin transmitir tu contenido.",
-                    "how_step3_title": "Opcional: modo Pro para escaneo completo",
-                    "how_step3_text": "Si quieres un análisis más profundo, instalas la herramienta auxiliar opcional. Puede verificar toda la capacidad de la memoria, identificar falsificaciones y generar informes detallados, ideal para reacondicionadores, departamentos de TI o laboratorios.",
-                    "how_side_title": "Comparación Free vs Pro",
-                    "how_side_free": "pages.main.sections.how.how_side_free",
-                    "how_side_pro": "pages.main.sections.how.how_side_pro",
-                    "how_side_account": "pages.main.sections.how.how_side_account"
-                },
-                "hero": {
-                    "hero_kicker": "Detecta USB falsificados antes de perder tus datos",
-                    "hero_title": "¿Mi USB es falso?",
-                    "hero_lead": "USBCheck combina una prueba rápida en el navegador con un modo Pro profesional. Así puedes detectar USB falsificados, capacidad real insuficiente y controladores lentos y baratos, antes de que tus archivos desaparezcan.",
-                    "cta_quick": "Iniciar prueba rápida gratis",
-                    "cta_learn": "Más información sobre Free & Pro",
-                    "trust1_title": "Sin instalación para la prueba rápida",
-                    "trust1_text": "Prueba basada en navegador directamente en tu unidad.",
-                    "trust2_title": "Pruebas reales de lectura y escritura",
-                    "trust2_text": "Pruebas con datos reales, no teoría sintética.",
-                    "trust3_title": "Privacidad ante todo",
-                    "trust3_text": "Tus datos de prueba permanecen locales. Informes solo si tú lo deseas.",
-                    "quick_label": "VISTA PREVIA DE PRUEBA RÁPIDA",
-                    "quick_title": "Prueba una unidad USB en menos de 2 minutos",
-                    "badge_free": "Gratis",
-                    "quick_metric1_label": "Rendimiento de escritura",
-                    "quick_metric1_value": "~ 75–120 MB/s*",
-                    "quick_metric2_label": "Controles de integridad",
-                    "quick_metric2_value": "Muestra de 512 MB",
-                    "quick_intro": "La prueba rápida examina una cantidad definida de datos en tu unidad y mide:",
-                    "quick_li1": "Velocidad de lectura y escritura",
-                    "quick_li2": "Integridad de datos (comparación hash)",
-                    "quick_li3": "Errores o interrupciones sospechosas",
-                    "quick_visual_title": "Indicador de prueba rápida",
-                    "quick_visual_text": "Así se ve la vista previa de la prueba rápida: verde marca una unidad estable, naranja advierte de anomalías.",
-                    "quick_visual_window": "Ventana de resultados",
-                    "quick_footnote": "*Valores de ejemplo; tus resultados dependen de la unidad, el puerto y el sistema.",
-                    "quick_cta": "Ir a la prueba rápida gratuita"
-                },
-                "features": {
-                    "features_kicker": "Funciones Free & Pro",
-                    "features_title": "Comienza con la prueba rápida gratuita y cambia al modo Pro cuando necesites más.",
-                    "features_intro": "USBCheck crece con tus necesidades: los usuarios privados suelen necesitar solo una evaluación rápida. Los profesionales quieren profundizar, verificar capacidades y archivar informes. Para eso existe el modo Pro.",
-                    "features_free_title": "Prueba Rápida Gratis",
-                    "features_free_badge": "Recomendado para la mayoría",
-                    "features_free_text": "Ideal para quienes desean verificar rápidamente si una unidad USB funciona de manera básica y estable, sin instalación.",
-                    "features_free_li1": "• Prueba rápida basada en navegador directamente en tu unidad",
-                    "features_free_li2": "• Velocidades reales de lectura y escritura",
-                    "features_free_li3": "• Prueba de integridad basada en hash",
-                    "features_free_li4": "• Selección de diferentes niveles de prueba (200 MB, 2 GB)",
-                    "features_free_li5": "• No requiere registro",
-                    "features_free_cta": "Iniciar prueba rápida gratis",
-                    "features_pro_title": "Modo Pro",
-                    "features_pro_badge": "Para usuarios avanzados y equipos",
-                    "features_pro_text": "Para quienes necesitan control total: departamentos de TI, técnicos, reacondicionadores, laboratorios o empresas que prueban grandes cantidades de unidades USB.",
-                    "features_pro_li1": "• Escaneo profundo de la capacidad completa (similar a F3 / badblocks)",
-                    "features_pro_li2": "• Detección de falsificaciones y sectores defectuosos",
-                    "features_pro_li3": "• Informes detallados y almacenables (JSON, PDF)",
-                    "features_pro_li4": "• Acceso opcional a API para procesos automatizados",
-                    "features_pro_li5": "• Soporte multi-dispositivo y multi-usuario (vía inicio de sesión)",
-                    "features_pro_note": "El modo Pro requiere una pequeña herramienta auxiliar instalada en tu sistema. Funciona localmente y puede vincularse a tu cuenta USBCheck si lo deseas."
-                },
-                "faq": {
-                    "faq_kicker": "FAQ",
-                    "faq_title": "Preguntas frecuentes sobre USBCheck",
-                    "faq_intro": "Aquí encontrarás respuestas a preguntas frecuentes. La sección FAQ puede ampliarse en cualquier momento según surjan nuevos casos de uso o comentarios de usuarios.",
-                    "faq_q1": "¿La prueba rápida se realiza completamente en el navegador?",
-                    "faq_a1": "Sí. La prueba rápida se ejecuta completamente en el navegador y utiliza APIs modernas para escribir y leer archivos de prueba en tu unidad. Nada se sube sin tu consentimiento.",
-                    "faq_q2": "¿Necesito una cuenta para usar la prueba rápida?",
-                    "faq_a2": "No. La prueba rápida gratuita se puede usar sin registro. Solo necesitas iniciar sesión si quieres guardar informes, gestionar varias unidades o usar el modo Pro.",
-                    "faq_q3": "¿USBCheck puede detectar con fiabilidad todas las unidades falsas?",
-                    "faq_a3": "Ninguna herramienta puede garantizar un 100%. Sin embargo, el modo Pro con escaneo completo está diseñado para detectar patrones típicos de fraude de manera muy fiable.",
-                    "faq_q4": "¿Cómo se integra la herramienta en mi sistema?",
-                    "faq_a4": "USBCheck está diseñado para la automatización. A través del modo Pro y la futura API, puedes integrar pruebas en tus flujos de trabajo existentes, como control de calidad o inspecciones de recepción."
-                },
-                "problem": {
-                    "problem_kicker": "Por qué las unidades USB falsas son peligrosas",
-                    "problem_title": "Los USB falsificados cuestan dinero y, en el peor caso, tus datos.",
-                    "problem_p1": "Muchos USB baratos anuncian capacidades irreales. En realidad, el controlador ha sido manipulado: la unidad informa por ejemplo 256 GB cuando solo tiene 32 GB físicos. El resultado: los datos parecen copiarse bien, pero luego se sobrescriben o dañan silenciosamente.",
-                    "problem_p2": "USBCheck te ayuda a detectar estas falsificaciones antes de usarlas, ya sea para uso privado o en lotes grandes en una empresa.",
-                    "problem_card1_title": "Pérdida de archivos importantes",
-                    "problem_card1_text": "Fotos, proyectos, copias de seguridad… todo puede perderse si la unidad almacena menos de lo prometido.",
-                    "problem_card2_title": "Costes por lotes defectuosos",
-                    "problem_card2_text": "Empresas y distribuidores entregan USB en grandes cantidades. Las falsificaciones provocan reclamaciones, daños reputacionales y costes de producción duplicados.",
-                    "problem_card3_title": "Rendimiento inestable",
-                    "problem_card3_text": "Controladores lentos, firmware inestable y tasas de escritura variables son típicos en unidades falsas, aumentando el riesgo de errores."
-                }
-            }
-        },
-        "dashboard": {
-            "meta": {
-                "title": "{{primary_domain}} – Panel",
-                "description": "Descripción del panel en {{primary_domain}}"
-            },
-            "sections": {
-                "dashboard": {
-                    "dashboard_kicker": "Panel",
-                    "dashboard_title": "Bienvenido",
-                    "dashboard_intro": "Aquí puedes gestionar tus pruebas USB, organizar dispositivos y activar el modo Pro más adelante. Esta sección aún está en construcción, pero ya ofrece una visión general.",
-                    "dashboard_plan_label": "Plan actual",
-                    "dashboard_card_tests_title": "Últimas pruebas",
-                    "dashboard_card_tests_text": "Aquí se mostrarán tus últimas pruebas rápidas y escaneos Pro, incluyendo estado, velocidad y control de integridad.",
-                    "dashboard_card_tests_empty": "Aún no hay datos de prueba. Inicia una prueba a través del navegador o del modo Pro.",
-                    "dashboard_card_devices_title": "Tus dispositivos USB",
-                    "dashboard_card_devices_text": "Más adelante podrás gestionar aquí tus unidades probadas: fabricante, modelo, número de serie y capacidad detectada.",
-                    "dashboard_card_devices_empty": "Aún no hay dispositivos guardados. Después de tus primeras pruebas podrás añadir unidades aquí.",
-                    "dashboard_card_next_title": "Próximos pasos",
-                    "dashboard_card_next_text": "USBCheck sigue en desarrollo. Eres de los primeros usuarios; más adelante encontrarás aquí funciones Pro, acceso API e informes detallados.",
-                    "dashboard_card_next_item1": "• Probar FakeCheck del navegador y dar opinión",
-                    "dashboard_card_next_item2": "• Definir funciones del modo Pro (escaneo completo, informes, API)",
-                    "dashboard_card_next_item3": "• Finalizar cuentas y SSO (my-log.in)",
-                    "dashboard_card_next_cta": "Ir a FakeCheck del navegador"
-                }
-            }
-        },
-        "fakecheck": {
-            "meta": {
-                "title": "{{primary_domain}} – FakeCheck",
-                "description": "Descripción de FakeCheck en {{primary_domain}}"
-            },
-            "sections": {
-                "hero": {
-                    "fake_hero_kicker": "FakeCheck – modo navegador",
-                    "fake_hero_title": "¿Mi USB es falso?",
-                    "fake_hero_lead": "FakeCheck te ayuda a detectar USB falsificados mediante pruebas de lectura/escritura y chequeos de capacidad sin instalación.",
-                    "fake_cta_start": "Iniciar prueba en el navegador (demo)",
-                    "fake_cta_back_home": "Volver al resumen",
-                    "fake_hero_hint": "FakeCheck crea archivos de prueba y patrones de lectura/escritura en una carpeta seleccionada. Tus archivos reales no se tocan.",
-                    "fake_box_title": "Qué puede hacer la prueba en el navegador",
-                    "fake_box_point1_title": "Pruebas de escritura y lectura",
-                    "fake_box_point1_text": "El navegador crea archivos de prueba, mide velocidades y comprueba la coincidencia de patrones.",
-                    "fake_box_point2_title": "Verificación de capacidad",
-                    "fake_box_point2_text": "La cantidad de datos escritos y verificados muestra la capacidad usable real.",
-                    "fake_box_point3_title": "Informe JSON",
-                    "fake_box_point3_text": "Todos los resultados se almacenan en un informe JSON estructurado que puedes guardar o comparar después."
-                }
-            }
-        },
-        "login": {
-            "meta": {
-                "title": "{{primary_domain}} – Iniciar sesión",
-                "description": "Descripción de inicio de sesión en {{primary_domain}}"
-            },
-            "sections": {
-                "login": {
-                    "auth_kicker": "Cuenta & acceso",
-                    "auth_title": "Inicia sesión en USBCheck",
-                    "auth_intro": "Con una cuenta puedes guardar pruebas, exportar informes y usar el modo Pro en varios dispositivos. El registro es gratuito y puedes mejorar a Pro cuando quieras.",
-                    "auth_tab_login": "Iniciar sesión",
-                    "auth_tab_register": "Registrarse",
-                    "auth_login_title": "Iniciar sesión",
-                    "auth_login_text": "Inicia sesión con tu correo electrónico y contraseña.",
-                    "auth_login_email_label": "Correo electrónico",
-                    "auth_login_password_label": "Contraseña",
-                    "auth_login_submit": "Acceder",
-                    "auth_login_forgot": "¿Olvidaste la contraseña?",
-                    "auth_register_title": "Registrarse gratis",
-                    "auth_register_text": "Crea una cuenta gratuita para guardar pruebas, exportar informes y activar el modo Pro más adelante.",
-                    "auth_register_name_label": "Nombre",
-                    "auth_register_email_label": "Correo electrónico",
-                    "auth_register_password_label": "Contraseña",
-                    "auth_register_submit": "Crear cuenta",
-                    "auth_register_hint": "Al registrarte aceptas la política de privacidad y el aviso legal de USBCheck."
-                }
-            }
-        },
-        "tools": {
-            "meta": {
-                "title": "{{primary_domain}} – Herramientas",
-                "description": "Descripción de herramientas en {{primary_domain}}"
-            }
-        }
-    },
-    "partials": {
-        "structure": {
-            "layout_end": {
-                "logout_modal_title": "¿Cerrar sesión?",
-                "logout_modal_text": "Si cierras sesión, tu sesión y las acciones no guardadas terminarán. Puedes iniciar sesión de nuevo en cualquier momento.",
-                "logout_modal_cancel": "Cancelar",
-                "logout_modal_confirm": "Sí, cerrar sesión"
-            },
-            "header": {
-                "header_slogan": "Probar USB",
-                "header_btn_login": "Iniciar sesión",
-                "header_menu_dashboard": "Panel",
-                "header_menu_logout": "Cerrar sesión",
-                "logout_title": "¿Cerrar sesión?",
-                "logout_text": "Se cerrará tu sesión en USBCheck. Las pruebas activas no se verán afectadas.",
-                "logout_cancel": "Cancelar",
-                "logout_confirm": "Sí, cerrar sesión"
-            },
-            "footer": {
-                "footer_imprint": "partials.structure.footer.footer_imprint",
-                "footer_privacy": "partials.structure.footer.footer_privacy"
-            }
-        }
-    }
-}

public/assets/i18n/fr.json

@@ -1,236 +0,0 @@
-{
-    "meta": {
-        "code": "fr",
-        "label": "Français",
-        "flag": "🇫🇷",
-        "enabled": true
-    },
-    "pages": {
-        "landing": {
-            "meta": {
-                "title": "SANS TITRE"
-            }
-        },
-        "main": {
-            "anchors": {
-                "how": "Comment ça marche",
-                "problem": "Pourquoi les clés USB contrefaites sont dangereuses",
-                "features": "Fonctionnalités",
-                "security": "Sécurité",
-                "faq": "FAQ"
-            },
-            "sections": {
-                "security": {
-                    "security_kicker": "Sécurité & confidentialité",
-                    "security_title": "Conçu pour la confidentialité : tes données t’appartiennent.",
-                    "security_intro": "USBCheck a été conçu dès le départ pour garantir la protection de tes données. Le test rapide du navigateur fonctionne uniquement avec des fichiers de test. Tes documents, images ou sauvegardes ne sont ni lus ni transférés. En mode Pro, tu contrôles entièrement si des rapports sont synchronisés avec ton compte, et lesquels.",
-                    "security_card1_title": "Tests uniquement locaux",
-                    "security_card1_text": "Tous les tests de lecture et d’écriture sont effectués localement sur ta clé USB. Le navigateur n’accède qu’aux fichiers de test – jamais à tes données personnelles.",
-                    "security_card2_title": "Rapports transparents",
-                    "security_card2_text": "Si tu es connecté, tu peux enregistrer, exporter ou supprimer tes rapports. C’est toi qui décides quelles données restent dans le système.",
-                    "security_card3_title": "Respecte ton matériel",
-                    "security_card3_text": "Le test rapide utilise une quantité de données modérée pour éviter toute usure inutile. Le mode Pro avertit clairement lorsqu’un scan complet avec forte charge d’écriture est lancé."
-                },
-                "how": {
-                    "how_kicker": "Comment fonctionne USBCheck",
-                    "how_title": "Test rapide dans le navigateur, mode Pro avec analyse approfondie.",
-                    "how_intro": "USBCheck a été conçu pour réunir deux mondes : un test simple et rapide pour tout le monde, et un mode Pro puissant pour les utilisateurs avancés, techniciens et administrateurs. Le test rapide s’exécute directement dans le navigateur, sans installation. Le mode Pro utilise un petit outil capable de réaliser des tests similaires à F3 / badblocks pour détecter de manière fiable les fausses capacités.",
-                    "how_step1_title": "Démarrer le test dans le navigateur",
-                    "how_step1_text": "Ouvre le test rapide sur",
-                    "how_step2_title": "Tests d’écriture, de lecture et d’intégrité",
-                    "how_step2_text": "Le navigateur crée des fichiers de test, mesure les vitesses de lecture/écriture et compare les valeurs de hachage pour détecter d’éventuelles erreurs – le tout localement, sans transmission de tes fichiers.",
-                    "how_step3_title": "Optionnel : mode Pro pour analyse complète",
-                    "how_step3_text": "Pour une analyse plus poussée, installe l’outil optionnel. Il peut tester toute la capacité réelle, identifier les contrefaçons et générer des rapports détaillés – idéal pour les services informatiques, les ateliers, ou les laboratoires.",
-                    "how_side_title": "Comparatif Free vs Pro",
-                    "how_side_free": "pages.main.sections.how.how_side_free",
-                    "how_side_pro": "pages.main.sections.how.how_side_pro",
-                    "how_side_account": "pages.main.sections.how.how_side_account"
-                },
-                "hero": {
-                    "hero_kicker": "Détecte les clés USB contrefaites avant de perdre des données",
-                    "hero_title": "Ma clé USB est-elle fausse ?",
-                    "hero_lead": "USBCheck combine un test rapide dans le navigateur et un mode Pro professionnel. Tu peux ainsi détecter les clés USB contrefaites, les capacités mensongères et les contrôleurs bon marché, avant de perdre tes fichiers.",
-                    "cta_quick": "Démarrer le test rapide gratuit",
-                    "cta_learn": "En savoir plus sur Free & Pro",
-                    "trust1_title": "Aucune installation nécessaire",
-                    "trust1_text": "Test dans le navigateur directement sur ta clé USB.",
-                    "trust2_title": "Tests réels de lecture/écriture",
-                    "trust2_text": "Mesures basées sur de vraies données – pas de théorie synthétique.",
-                    "trust3_title": "Priorité à la confidentialité",
-                    "trust3_text": "Tes données restent locales – rapports envoyés seulement si tu le souhaites.",
-                    "quick_label": "APERÇU TEST RAPIDE",
-                    "quick_title": "Teste une clé USB en moins de 2 minutes",
-                    "badge_free": "Gratuit",
-                    "quick_metric1_label": "Performance d’écriture",
-                    "quick_metric1_value": "~ 75–120 MB/s*",
-                    "quick_metric2_label": "Contrôles d’intégrité",
-                    "quick_metric2_value": "Échantillon de 512 MB",
-                    "quick_intro": "Le test rapide vérifie une quantité définie de données et mesure :",
-                    "quick_li1": "Vitesses d’écriture et de lecture",
-                    "quick_li2": "Intégrité des données (comparaison de hachage)",
-                    "quick_li3": "Erreurs ou anomalies détectées",
-                    "quick_visual_title": "Indicateur de test rapide",
-                    "quick_visual_text": "Voici l’aperçu du test rapide : le vert indique une clé stable, l’orange signale des irrégularités.",
-                    "quick_visual_window": "Fenêtre de résultat",
-                    "quick_footnote": "*Valeurs d’exemple – tes résultats dépendront de ta clé, du port et du système.",
-                    "quick_cta": "Accéder au test rapide gratuit"
-                },
-                "features": {
-                    "features_kicker": "Fonctionnalités Free & Pro",
-                    "features_title": "Commence avec le test rapide gratuit – passe au mode Pro si tu as besoin de plus.",
-                    "features_intro": "USBCheck s’adapte à tes besoins : les utilisateurs privés veulent souvent un aperçu rapide, les professionnels souhaitent vérifier les capacités et enregistrer des rapports. C’est exactement ce que le mode Pro permet.",
-                    "features_free_title": "Test rapide gratuit",
-                    "features_free_badge": "Recommandé pour la plupart des utilisateurs",
-                    "features_free_text": "Idéal pour vérifier rapidement si une clé USB fonctionne de manière stable – sans installation.",
-                    "features_free_li1": "• Test rapide basé dans le navigateur directement sur ta clé",
-                    "features_free_li2": "• Mesure réelle des vitesses d’écriture et de lecture",
-                    "features_free_li3": "• Vérification d’intégrité basée sur le hachage",
-                    "features_free_li4": "• Choix du niveau de test (200 MB, 2 GB)",
-                    "features_free_li5": "• Aucun compte requis",
-                    "features_free_cta": "Démarrer le test gratuit",
-                    "features_pro_title": "Mode Pro",
-                    "features_pro_badge": "Pour utilisateurs avancés & équipes",
-                    "features_pro_text": "Pour ceux qui ont besoin d’un contrôle total : services informatiques, techniciens, ateliers, laboratoires ou entreprises testant de grandes quantités de clés.",
-                    "features_pro_li1": "• Analyse complète de la capacité (similaire à F3 / badblocks)",
-                    "features_pro_li2": "• Détection de capacités falsifiées et secteurs défectueux",
-                    "features_pro_li3": "• Rapports détaillés (JSON, PDF)",
-                    "features_pro_li4": "• Accès API optionnel pour automatisation",
-                    "features_pro_li5": "• Support multi-appareils et multi-utilisateurs (via compte)",
-                    "features_pro_note": "Le mode Pro nécessite un petit outil local. Il fonctionne en local et peut être lié à ton compte USBCheck."
-                },
-                "faq": {
-                    "faq_kicker": "FAQ",
-                    "faq_title": "Questions fréquentes sur USBCheck",
-                    "faq_intro": "Retrouve ici les réponses aux questions les plus courantes. Cette section sera enrichie au fil des retours utilisateurs et nouveaux besoins.",
-                    "faq_q1": "Le test rapide est-il entièrement exécuté dans le navigateur ?",
-                    "faq_a1": "Oui. Le test rapide s’exécute entièrement dans le navigateur grâce à des API modernes permettant d’écrire puis de relire des fichiers de test sur ta clé. Rien n’est envoyé sans ton consentement.",
-                    "faq_q2": "Ai-je besoin d’un compte pour utiliser le test rapide ?",
-                    "faq_a2": "Non. Le test rapide gratuit peut être utilisé sans inscription. Un compte est nécessaire uniquement pour enregistrer des rapports, gérer plusieurs clés ou utiliser le mode Pro.",
-                    "faq_q3": "USBCheck peut-il détecter toutes les clés contrefaites ?",
-                    "faq_a3": "Aucun outil ne peut garantir 100 %. Mais le mode Pro avec analyse complète a été conçu pour détecter de manière fiable les schémas de falsification habituels.",
-                    "faq_q4": "Comment intégrer l’outil dans mon système ?",
-                    "faq_a4": "USBCheck est pensé pour l’automatisation. Grâce au mode Pro et à l’API prévue, tu pourras intégrer les tests à tes flux de travail existants (contrôle qualité, inspections, etc.)."
-                },
-                "problem": {
-                    "problem_kicker": "Pourquoi les clés USB contrefaites sont dangereuses",
-                    "problem_title": "Les clés USB falsifiées coûtent de l’argent – et parfois tes données.",
-                    "problem_p1": "Beaucoup de clés USB bon marché annoncent des capacités irréalistes. En réalité, le contrôleur est manipulé : la clé indique par exemple 256 GB alors qu’elle n’en contient physiquement que 32 GB. Résultat : les fichiers semblent copiés correctement, puis sont silencieusement écrasés ou corrompus.",
-                    "problem_p2": "USBCheck t’aide à détecter ces contrefaçons avant une utilisation réelle – que ce soit en usage privé ou en entreprise.",
-                    "problem_card1_title": "Perte de fichiers importants",
-                    "problem_card1_text": "Photos, projets, sauvegardes… tout peut être perdu si la clé stocke moins que ce qui est annoncé.",
-                    "problem_card2_title": "Coûts liés aux lots défectueux",
-                    "problem_card2_text": "Entreprises et revendeurs distribuent souvent des clés en grande quantité. Les contrefaçons entraînent réclamations, perte d’image et coûts supplémentaires.",
-                    "problem_card3_title": "Performances instables",
-                    "problem_card3_text": "Contrôleurs lents, firmware instable et vitesses variables sont typiques des clés falsifiées, augmentant le risque d’erreurs."
-                }
-            }
-        },
-        "dashboard": {
-            "meta": {
-                "title": "{{primary_domain}} – Tableau de bord",
-                "description": "Description du tableau de bord sur {{primary_domain}}"
-            },
-            "sections": {
-                "dashboard": {
-                    "dashboard_kicker": "Tableau de bord",
-                    "dashboard_title": "Bienvenue",
-                    "dashboard_intro": "Ici, tu peux gérer tes tests USB, organiser tes appareils et activer le mode Pro plus tard. Cette section est encore en construction, mais offre déjà un premier aperçu.",
-                    "dashboard_plan_label": "Plan actuel",
-                    "dashboard_card_tests_title": "Derniers tests",
-                    "dashboard_card_tests_text": "Tes derniers tests rapides et analyses Pro s’afficheront ici, avec statut, vitesse et contrôles d’intégrité.",
-                    "dashboard_card_tests_empty": "Aucune donnée pour l’instant. Lance un test via le navigateur ou le mode Pro.",
-                    "dashboard_card_devices_title": "Tes appareils USB",
-                    "dashboard_card_devices_text": "Plus tard, tu pourras gérer ici les clés testées : fabricant, modèle, numéro de série et capacité détectée.",
-                    "dashboard_card_devices_empty": "Aucun appareil enregistré. Après tes premiers tests, tu pourras ajouter des clés ici.",
-                    "dashboard_card_next_title": "Étapes suivantes",
-                    "dashboard_card_next_text": "USBCheck est encore en développement. Tu fais partie des premiers utilisateurs – bientôt, tu trouveras ici les fonctions Pro, accès API et rapports détaillés.",
-                    "dashboard_card_next_item1": "• Tester FakeCheck dans le navigateur et donner un avis",
-                    "dashboard_card_next_item2": "• Définir les fonctions du mode Pro (scan complet, rapports, API)",
-                    "dashboard_card_next_item3": "• Finaliser comptes & SSO (my-log.in)",
-                    "dashboard_card_next_cta": "Accéder à FakeCheck"
-                }
-            }
-        },
-        "fakecheck": {
-            "meta": {
-                "title": "{{primary_domain}} – FakeCheck",
-                "description": "Description de FakeCheck sur {{primary_domain}}"
-            },
-            "sections": {
-                "hero": {
-                    "fake_hero_kicker": "FakeCheck – mode navigateur",
-                    "fake_hero_title": "Ma clé USB est-elle fausse ?",
-                    "fake_hero_lead": "FakeCheck t’aide à détecter les contrefaçons grâce à des tests de lecture/écriture et à un contrôle de capacité, sans installation.",
-                    "fake_cta_start": "Démarrer le test navigateur (démo)",
-                    "fake_cta_back_home": "Retour à l’aperçu",
-                    "fake_hero_hint": "FakeCheck crée des fichiers de test et des motifs d’écriture/lecture dans un dossier choisi. Tes fichiers réels ne sont jamais modifiés.",
-                    "fake_box_title": "Ce que peut faire le test navigateur",
-                    "fake_box_point1_title": "Tests de lecture/écriture",
-                    "fake_box_point1_text": "Le navigateur crée des fichiers de test, mesure les vitesses et vérifie les motifs écrits.",
-                    "fake_box_point2_title": "Vérification de capacité",
-                    "fake_box_point2_text": "La quantité de données écrites et vérifiées donne une estimation fiable de la capacité réellement utilisable.",
-                    "fake_box_point3_title": "Rapport JSON",
-                    "fake_box_point3_text": "Tous les résultats sont collectés dans un rapport JSON structuré que tu peux sauvegarder ou comparer plus tard."
-                }
-            }
-        },
-        "login": {
-            "meta": {
-                "title": "{{primary_domain}} – Connexion",
-                "description": "Description de la connexion sur {{primary_domain}}"
-            },
-            "sections": {
-                "login": {
-                    "auth_kicker": "Compte & connexion",
-                    "auth_title": "Connecte-toi à USBCheck",
-                    "auth_intro": "Avec un compte, tu peux enregistrer des tests, exporter des rapports et utiliser le mode Pro sur plusieurs appareils. L’inscription est gratuite – tu peux passer à Pro à tout moment.",
-                    "auth_tab_login": "Connexion",
-                    "auth_tab_register": "S’inscrire",
-                    "auth_login_title": "Connexion",
-                    "auth_login_text": "Connecte-toi avec ton adresse e-mail et ton mot de passe.",
-                    "auth_login_email_label": "Adresse e-mail",
-                    "auth_login_password_label": "Mot de passe",
-                    "auth_login_submit": "Se connecter",
-                    "auth_login_forgot": "Mot de passe oublié ?",
-                    "auth_register_title": "Inscription gratuite",
-                    "auth_register_text": "Crée un compte gratuit pour enregistrer des tests, exporter des rapports et activer le mode Pro plus tard.",
-                    "auth_register_name_label": "Nom",
-                    "auth_register_email_label": "Adresse e-mail",
-                    "auth_register_password_label": "Mot de passe",
-                    "auth_register_submit": "Créer un compte",
-                    "auth_register_hint": "En créant un compte, tu acceptes la politique de confidentialité et les mentions légales d’USBCheck."
-                }
-            }
-        },
-        "tools": {
-            "meta": {
-                "title": "{{primary_domain}} – Outils",
-                "description": "Description des outils sur {{primary_domain}}"
-            }
-        }
-    },
-    "partials": {
-        "structure": {
-            "layout_end": {
-                "logout_modal_title": "Se déconnecter ?",
-                "logout_modal_text": "Si tu te déconnectes, ta session et les actions non enregistrées seront perdues. Tu peux te reconnecter à tout moment.",
-                "logout_modal_cancel": "Annuler",
-                "logout_modal_confirm": "Oui, se déconnecter"
-            },
-            "header": {
-                "header_slogan": "Tester les clés USB",
-                "header_btn_login": "Connexion",
-                "header_menu_dashboard": "Tableau de bord",
-                "header_menu_logout": "Déconnexion",
-                "logout_title": "Se déconnecter ?",
-                "logout_text": "Tu vas être déconnecté de ton compte USBCheck. Les tests actifs dans le navigateur ne seront pas interrompus.",
-                "logout_cancel": "Annuler",
-                "logout_confirm": "Oui, se déconnecter"
-            },
-            "footer": {
-                "footer_imprint": "partials.structure.footer.footer_imprint",
-                "footer_privacy": "partials.structure.footer.footer_privacy"
-            }
-        }
-    }
-}

public/assets/i18n/hi.json

@@ -1,236 +0,0 @@
-{
-    "meta": {
-        "code": "hi",
-        "label": "हिन्दी",
-        "flag": "🇮🇳",
-        "enabled": true
-    },
-    "pages": {
-        "landing": {
-            "meta": {
-                "title": "कोई शीर्षक नहीं"
-            }
-        },
-        "main": {
-            "anchors": {
-                "how": "यह कैसे काम करता है",
-                "problem": "नकली USB ड्राइव खतरनाक क्यों हैं",
-                "features": "विशेषताएँ",
-                "security": "सुरक्षा",
-                "faq": "अक्सर पूछे जाने वाले प्रश्न"
-            },
-            "sections": {
-                "security": {
-                    "security_kicker": "सुरक्षा और गोपनीयता",
-                    "security_title": "प्राइवेसी-फ़र्स्ट डिज़ाइन: आपके टेस्ट डेटा सिर्फ़ आपके हैं।",
-                    "security_intro": "USBCheck शुरू से ही आपकी गोपनीयता को ध्यान में रखकर बनाया गया है। ब्राउज़र-क्विक-टेस्ट केवल टेस्ट फ़ाइलों के साथ काम करता है। आपकी निजी फ़ाइलें, फ़ोटो या बैकअप न तो पढ़े जाते हैं और न ही अपलोड किए जाते हैं। Pro मोड में आप तय करते हैं कि कौन-सी रिपोर्ट आपके अकाउंट के साथ सिंक की जाए।",
-                    "security_card1_title": "लोकल-ओनली टेस्ट",
-                    "security_card1_text": "सभी पढ़ने और लिखने के टेस्ट आपके USB ड्राइव पर स्थानीय रूप से किए जाते हैं। ब्राउज़र केवल टेस्ट फ़ाइलों का उपयोग करता है — आपकी निजी फ़ाइलों का नहीं।",
-                    "security_card2_title": "पारदर्शी रिपोर्ट",
-                    "security_card2_text": "लॉगिन करने के बाद आप रिपोर्ट को सहेज सकते हैं, निर्यात कर सकते हैं या मिटा सकते हैं। कौन-सी जानकारी रखनी है — यह निर्णय आपके हाथ में है।",
-                    "security_card3_title": "हार्डवेयर के लिए सुरक्षित",
-                    "security_card3_text": "क्विक-टेस्ट मध्यम डेटा उपयोग करता है ताकि अनावश्यक घिसावट न हो। Pro मोड स्पष्ट चेतावनी देता है जब पूरे ड्राइव पर भारी लिखने वाला परीक्षण सक्रिय किया जाता है।"
-                },
-                "how": {
-                    "how_kicker": "USBCheck कैसे काम करता है",
-                    "how_title": "ब्राउज़र में क्विक-टेस्ट, Pro मोड में गहन विश्लेषण।",
-                    "how_intro": "USBCheck दो दुनिया को जोड़ता है: सभी उपयोगकर्ताओं के लिए एक आसान क्विक-टेस्ट और पावर-यूज़र, तकनीशियन और एडमिन के लिए गहरा Pro मोड। ब्राउज़र-टेस्ट बिना इंस्टॉलेशन के चलता है। Pro मोड एक छोटे टूल का उपयोग करता है जो F3/badblocks जैसे परीक्षण कर सकता है और नकली क्षमता वाले USB ड्राइव को पकड़ सकता है।",
-                    "how_step1_title": "ब्राउज़र-टेस्ट शुरू करें",
-                    "how_step1_text": "आप क्विक-टेस्ट को यहां खोलते हैं:",
-                    "how_step2_title": "लिखने, पढ़ने और अखंडता की जांच",
-                    "how_step2_text": "ब्राउज़र टेस्ट फ़ाइलें बनाता है, गति मापता है और हैश-मूल्यों की तुलना करता है ताकि डेटा त्रुटियाँ पकड़ी जा सकें — यह सब स्थानीय रूप से।",
-                    "how_step3_title": "वैकल्पिक: पूरे ड्राइव की Pro-स्कैन",
-                    "how_step3_text": "कम जानकारी पर्याप्त न हो तो आप हेल्पर-टूल इंस्टॉल कर सकते हैं। यह पूरी क्षमता की जांच करता है, नकली ड्राइव का पता लगाता है और विस्तृत रिपोर्ट बनाता है — IT विभागों, लैब्स और पेशेवरों के लिए आदर्श।",
-                    "how_side_title": "Free बनाम Pro – एक नज़र में",
-                    "how_side_free": "pages.main.sections.how.how_side_free",
-                    "how_side_pro": "pages.main.sections.how.how_side_pro",
-                    "how_side_account": "pages.main.sections.how.how_side_account"
-                },
-                "hero": {
-                    "hero_kicker": "डेटा खोने से पहले नकली USB ड्राइव पहचानें",
-                    "hero_title": "क्या मेरा USB नकली है?",
-                    "hero_lead": "USBCheck तेज़ ब्राउज़र-टेस्ट और पेशेवर Pro मोड का संयोजन प्रदान करता है। इससे आप नकली USB ड्राइव, गलत क्षमता और धीमे कंट्रोलर का पता समय पर लगा सकते हैं।",
-                    "cta_quick": "मुफ़्त क्विक-टेस्ट शुरू करें",
-                    "cta_learn": "Free और Pro के बारे में और जानें",
-                    "trust1_title": "इंस्टॉलेशन की आवश्यकता नहीं",
-                    "trust1_text": "ब्राउज़र-आधारित परीक्षण सीधे आपके ड्राइव पर चलता है।",
-                    "trust2_title": "वास्तविक लिखने/पढ़ने के परीक्षण",
-                    "trust2_text": "टेस्ट वास्तविक डेटा का उपयोग करते हैं — कोई सिंथेटिक अनुमान नहीं।",
-                    "trust3_title": "गोपनीयता पहले",
-                    "trust3_text": "आपके टेस्ट-डेटा स्थानीय रहते हैं — रिपोर्ट केवल आपकी इच्छा पर।",
-                    "quick_label": "क्विक-टेस्ट पूर्वावलोकन",
-                    "quick_title": "USB ड्राइव को 2 मिनट से कम में टेस्ट करें",
-                    "badge_free": "मुफ़्त",
-                    "quick_metric1_label": "लिखने की गति",
-                    "quick_metric1_value": "~ 75–120 MB/s*",
-                    "quick_metric2_label": "इंटीग्रिटी चेक",
-                    "quick_metric2_value": "512 MB नमूना",
-                    "quick_intro": "क्विक-टेस्ट एक परिभाषित डेटा-मात्रा की जांच करता है और मापता है:",
-                    "quick_li1": "लिखने और पढ़ने की गति",
-                    "quick_li2": "डेटा अखंडता (हैश तुलना)",
-                    "quick_li3": "संदिग्ध त्रुटियाँ या रुकावटें",
-                    "quick_visual_title": "क्विक-टेस्ट संकेतक",
-                    "quick_visual_text": "पूर्वावलोकन में: हरा रंग स्थिर ड्राइव दिखाता है, नारंगी चेतावनी देता है।",
-                    "quick_visual_window": "परिणाम विंडो",
-                    "quick_footnote": "*उदाहरण मूल्य — परिणाम हार्डवेयर और सिस्टम पर निर्भर करते हैं।",
-                    "quick_cta": "मुफ़्त क्विक-टेस्ट पर जाएँ"
-                },
-                "features": {
-                    "features_kicker": "Free और Pro फ़ीचर्स",
-                    "features_title": "मुफ़्त क्विक-टेस्ट से शुरू करें — अधिक आवश्यकता होने पर Pro मोड का उपयोग करें।",
-                    "features_intro": "USBCheck आपकी आवश्यकताओं के अनुसार बढ़ता है। सामान्य उपयोगकर्ता तेज़ जाँच चाहते हैं, जबकि पेशेवर विस्तृत विश्लेषण और सुरक्षित रिपोर्टिंग की अपेक्षा करते हैं।",
-                    "features_free_title": "मुफ़्त क्विक-टेस्ट",
-                    "features_free_badge": "अधिकांश उपयोगकर्ताओं के लिए अनुशंसित",
-                    "features_free_text": "तेज़ी से जांचने के लिए आदर्श कि आपका USB ड्राइव कम से कम बुनियादी रूप से स्थिर और तेज़ है — बिना किसी इंस्टॉलेशन के।",
-                    "features_free_li1": "• ब्राउज़र-आधारित क्विक-टेस्ट",
-                    "features_free_li2": "• वास्तविक लिखने और पढ़ने की गति",
-                    "features_free_li3": "• हैश-आधारित अखंडता जांच",
-                    "features_free_li4": "• विभिन्न टेस्ट-स्तर (उदा. 200 MB, 2 GB)",
-                    "features_free_li5": "• रजिस्ट्रेशन आवश्यक नहीं",
-                    "features_free_cta": "मुफ़्त टेस्ट शुरू करें",
-                    "features_pro_title": "Pro मोड",
-                    "features_pro_badge": "उन्नत उपयोगकर्ताओं और टीमों के लिए",
-                    "features_pro_text": "उनके लिए जो पूर्ण नियंत्रण चाहते हैं: IT विभाग, तकनीशियन, लैब, या कंपनियाँ जो नियमित रूप से कई ड्राइव टेस्ट करती हैं।",
-                    "features_pro_li1": "• पूरे ड्राइव की गहन स्कैनिंग (F3/badblocks जैसा)",
-                    "features_pro_li2": "• नकली क्षमता और खराब सेक्टरों का पता लगाना",
-                    "features_pro_li3": "• विस्तृत रिपोर्ट (JSON, PDF)",
-                    "features_pro_li4": "• वैकल्पिक API पहुंच",
-                    "features_pro_li5": "• मल्टी-डिवाइस और मल्टी-यूज़र सपोर्ट",
-                    "features_pro_note": "Pro मोड के लिए एक छोटा टूल इंस्टॉल करना होता है, जो स्थानीय रूप से काम करता है और आपके USBCheck अकाउंट से जुड़ सकता है।"
-                },
-                "faq": {
-                    "faq_kicker": "FAQ",
-                    "faq_title": "USBCheck के सामान्य प्रश्न",
-                    "faq_intro": "यहाँ आपको सबसे अधिक पूछे जाने वाले प्रश्नों के उत्तर मिलेंगे। यह खंड उपयोगकर्ताओं की प्रतिक्रिया के आधार पर बढ़ता रहेगा।",
-                    "faq_q1": "क्या क्विक-टेस्ट पूरी तरह से ब्राउज़र में चलता है?",
-                    "faq_a1": "हाँ, क्विक-टेस्ट 100% ब्राउज़र में चलता है और आधुनिक APIs का उपयोग करता है जो स्थानीय फ़ाइल लिखने/पढ़ने की अनुमति देते हैं — बिना किसी अपलोड के।",
-                    "faq_q2": "क्या क्विक-टेस्ट का उपयोग करने के लिए अकाउंट चाहिए?",
-                    "faq_a2": "नहीं। मुफ्त क्विक-टेस्ट के लिए अकाउंट आवश्यक नहीं है। अकाउंट केवल रिपोर्ट सेव करने या Pro मोड उपयोग करने के लिए चाहिए।",
-                    "faq_q3": "क्या USBCheck सभी नकली USB ड्राइव पकड़ सकता है?",
-                    "faq_a3": "कोई भी टूल 100% गारंटी नहीं दे सकता, लेकिन Pro मोड की पूर्ण-स्कैन क्षमता आम नकली पैटर्न को बहुत विश्वसनीय रूप से पकड़ती है।",
-                    "faq_q4": "क्या इसे मेरे सिस्टम में एकीकृत किया जा सकता है?",
-                    "faq_a4": "USBCheck ऑटोमेशन के लिए डिज़ाइन किया गया है। Pro मोड और आने वाला API इसे कार्य-प्रवाहों में आसानी से जोड़ने की अनुमति देगा।"
-                },
-                "problem": {
-                    "problem_kicker": "नकली USB ड्राइव क्यों ख़तरनाक हैं",
-                    "problem_title": "नकली USB ड्राइव पैसे — और कभी-कभी आपके डेटा — का नुकसान कराते हैं।",
-                    "problem_p1": "कई सस्ते USB ड्राइव अवास्तविक क्षमता दिखाते हैं। कंट्रोलर को हेरफेर किया जाता है ताकि 256 GB जैसी क्षमता दिखाई जाए, जबकि वास्तविक मात्रा बहुत कम होती है।",
-                    "problem_p2": "USBCheck आपको ऐसे नकली ड्राइव पहचानने में मदद करता है — निजी और व्यावसायिक उपयोग दोनों में।",
-                    "problem_card1_title": "महत्वपूर्ण डेटा का नुकसान",
-                    "problem_card1_text": "फ़ोटो, प्रोजेक्ट, बैकअप — सब कुछ खतरे में है अगर ड्राइव वास्तविक से कम क्षमता रखता है।",
-                    "problem_card2_title": "खराब बैचों की लागत",
-                    "problem_card2_text": "कंपनियाँ अक्सर बड़ी मात्रा में ड्राइव वितरित करती हैं। नकली ड्राइव शिकायतें, हानि और छवि-नुकसान पैदा करते हैं।",
-                    "problem_card3_title": "अस्थिर प्रदर्शन",
-                    "problem_card3_text": "धीमे कंट्रोलर, अस्थिर फ़र्मवेयर और बदलती गति नकली ड्राइव की आम विशेषताएँ हैं।"
-                }
-            }
-        },
-        "dashboard": {
-            "meta": {
-                "title": "{{primary_domain}} – डैशबोर्ड",
-                "description": "{{primary_domain}} पर डैशबोर्ड विवरण"
-            },
-            "sections": {
-                "dashboard": {
-                    "dashboard_kicker": "डैशबोर्ड",
-                    "dashboard_title": "स्वागत है",
-                    "dashboard_intro": "यहाँ आप USB परीक्षणों को प्रबंधित कर सकते हैं, उपकरण व्यवस्थित कर सकते हैं, और बाद में Pro मोड सक्रिय कर सकते हैं। यह क्षेत्र अभी विकास में है, लेकिन एक प्रारंभिक अवलोकन देता है।",
-                    "dashboard_plan_label": "वर्तमान प्लान",
-                    "dashboard_card_tests_title": "हाल के टेस्ट",
-                    "dashboard_card_tests_text": "यहाँ आपके हाल के क्विक-टेस्ट और Pro-स्कैन दिखाए जाएंगे — स्थिति, गति और अखंडता सहित।",
-                    "dashboard_card_tests_empty": "अभी तक कोई टेस्ट नहीं। ब्राउज़र-टेस्ट या Pro मोड शुरू करें।",
-                    "dashboard_card_devices_title": "आपके USB उपकरण",
-                    "dashboard_card_devices_text": "आगे चलकर आप यहाँ अपने टेस्ट किए हुए ड्राइव प्रबंधित कर सकेंगे।",
-                    "dashboard_card_devices_empty": "अभी तक कोई उपकरण नहीं। पहले टेस्ट के बाद आप उन्हें जोड़ सकते हैं।",
-                    "dashboard_card_next_title": "अगले कदम",
-                    "dashboard_card_next_text": "USBCheck अभी विकास में है। आगे चलकर यहाँ Pro विकल्प, API एक्सेस और विस्तृत रिपोर्ट उपलब्ध होंगी।",
-                    "dashboard_card_next_item1": "• ब्राउज़र-आधारित FakeCheck आज़माएँ",
-                    "dashboard_card_next_item2": "• Pro मोड की सुविधाएँ निर्धारित करें",
-                    "dashboard_card_next_item3": "• अकाउंट और SSO (my-log.in) सेटअप पूर्ण करें",
-                    "dashboard_card_next_cta": "FakeCheck खोलें"
-                }
-            }
-        },
-        "fakecheck": {
-            "meta": {
-                "title": "{{primary_domain}} – FakeCheck",
-                "description": "{{primary_domain}} पर FakeCheck विवरण"
-            },
-            "sections": {
-                "hero": {
-                    "fake_hero_kicker": "FakeCheck – ब्राउज़र मोड",
-                    "fake_hero_title": "क्या मेरा USB ड्राइव नकली है?",
-                    "fake_hero_lead": "FakeCheck बिना इंस्टॉलेशन के लिखने/पढ़ने और क्षमता जांच के माध्यम से नकली ड्राइव का पता लगाता है।",
-                    "fake_cta_start": "ब्राउज़र-टेस्ट शुरू करें (डेमो)",
-                    "fake_cta_back_home": "समग्र दृश्य पर वापस",
-                    "fake_hero_hint": "FakeCheck चुने हुए फ़ोल्डर में टेस्ट-फ़ाइलें बनाता है। आपकी वास्तविक फ़ाइलों को कोई नुकसान नहीं होता।",
-                    "fake_box_title": "ब्राउज़र-टेस्ट क्या कर सकता है",
-                    "fake_box_point1_title": "लिखने/पढ़ने के परीक्षण",
-                    "fake_box_point1_text": "ब्राउज़र गति मापता है और डेटा पैटर्न की जाँच करता है।",
-                    "fake_box_point2_title": "क्षमता जांच",
-                    "fake_box_point2_text": "सत्यापित डेटा मात्रा वास्तविक उपयोग योग्य क्षमता का संकेत देती है।",
-                    "fake_box_point3_title": "JSON रिपोर्ट",
-                    "fake_box_point3_text": "सभी परिणाम एक संरचित JSON रिपोर्ट में संग्रहीत किए जाते हैं।"
-                }
-            }
-        },
-        "login": {
-            "meta": {
-                "title": "{{primary_domain}} – लॉगिन",
-                "description": "{{primary_domain}} पर लॉगिन विवरण"
-            },
-            "sections": {
-                "login": {
-                    "auth_kicker": "अकाउंट और लॉगिन",
-                    "auth_title": "USBCheck में लॉगिन करें",
-                    "auth_intro": "अकाउंट बनाकर आप टेस्ट सेव कर सकते हैं, रिपोर्ट निर्यात कर सकते हैं और कई उपकरणों पर Pro मोड का उपयोग कर सकते हैं। पंजीकरण मुफ़्त है।",
-                    "auth_tab_login": "लॉगिन",
-                    "auth_tab_register": "रजिस्टर",
-                    "auth_login_title": "लॉगिन",
-                    "auth_login_text": "अपना ई-मेल और पासवर्ड दर्ज करें।",
-                    "auth_login_email_label": "ई-मेल",
-                    "auth_login_password_label": "पासवर्ड",
-                    "auth_login_submit": "लॉगिन",
-                    "auth_login_forgot": "पासवर्ड भूल गए?",
-                    "auth_register_title": "मुफ़्त पंजीकरण",
-                    "auth_register_text": "टेस्ट सेव करने, रिपोर्ट निर्यात करने और बाद में Pro मोड सक्षम करने के लिए मुफ़्त अकाउंट बनाएँ।",
-                    "auth_register_name_label": "नाम",
-                    "auth_register_email_label": "ई-मेल",
-                    "auth_register_password_label": "पासवर्ड",
-                    "auth_register_submit": "अकाउंट बनाएँ",
-                    "auth_register_hint": "पंजीकरण करके आप USBCheck की गोपनीयता नीति और कानूनी जानकारी से सहमत होते हैं।"
-                }
-            }
-        },
-        "tools": {
-            "meta": {
-                "title": "{{primary_domain}} – टूल्स",
-                "description": "{{primary_domain}} पर टूल्स विवरण"
-            }
-        }
-    },
-    "partials": {
-        "structure": {
-            "layout_end": {
-                "logout_modal_title": "लॉगआउट करें?",
-                "logout_modal_text": "लॉगआउट करने पर आपकी सक्रिय सत्र समाप्त हो जाएगा और बिना सेव किए कार्य खो जाएंगे।",
-                "logout_modal_cancel": "रद्द करें",
-                "logout_modal_confirm": "हाँ, लॉगआउट करें"
-            },
-            "header": {
-                "header_slogan": "USB ड्राइव टेस्ट करें",
-                "header_btn_login": "लॉगिन",
-                "header_menu_dashboard": "डैशबोर्ड",
-                "header_menu_logout": "लॉगआउट",
-                "logout_title": "लॉगआउट करें?",
-                "logout_text": "आप अपने USBCheck अकाउंट से लॉगआउट हो जाएँगे। ब्राउज़र-टेस्ट प्रभावित नहीं होंगे।",
-                "logout_cancel": "रद्द करें",
-                "logout_confirm": "हाँ, लॉगआउट करें"
-            },
-            "footer": {
-                "footer_imprint": "partials.structure.footer.footer_imprint",
-                "footer_privacy": "partials.structure.footer.footer_privacy"
-            }
-        }
-    }
-}

public/assets/i18n/id.json

@@ -1,236 +0,0 @@
-{
-    "meta": {
-        "code": "id",
-        "label": "Bahasa Indonesia",
-        "flag": "🇮🇩",
-        "enabled": true
-    },
-    "pages": {
-        "landing": {
-            "meta": {
-                "title": "TANPA JUDUL"
-            }
-        },
-        "main": {
-            "anchors": {
-                "how": "Cara kerjanya",
-                "problem": "Mengapa USB palsu berbahaya",
-                "features": "Fitur",
-                "security": "Keamanan",
-                "faq": "FAQ"
-            },
-            "sections": {
-                "security": {
-                    "security_kicker": "Keamanan & privasi",
-                    "security_title": "Desain berpusat pada privasi: data pengujian tetap milikmu.",
-                    "security_intro": "USBCheck sejak awal dirancang agar data kamu tetap terlindungi. Uji cepat di browser hanya bekerja dengan berkas uji khusus. Dokumen, foto, atau cadangan (backup) pribadimu tidak pernah dibaca atau dikirim. Dalam mode Pro, kamu punya kendali penuh apakah laporan akan disinkronkan ke akunmu atau hanya disimpan lokal.",
-                    "security_card1_title": "Pengujian hanya secara lokal",
-                    "security_card1_text": "Semua uji baca/tulis dilakukan langsung di flashdisk USB milikmu. Browser hanya mengakses berkas uji – bukan isi data pribadi.",
-                    "security_card2_title": "Laporan transparan",
-                    "security_card2_text": "Setelah login, kamu bisa menyimpan, mengekspor, atau menghapus laporan pengujian di akunmu. Kamu yang menentukan data apa yang tetap berada di sistem.",
-                    "security_card3_title": "Ramah terhadap hardware",
-                    "security_card3_text": "Uji cepat menggunakan jumlah data yang moderat untuk menghindari keausan yang tidak perlu. Mode Pro akan memberikan peringatan yang jelas sebelum menjalankan pemindaian penuh dengan beban tulis yang tinggi."
-                },
-                "how": {
-                    "how_kicker": "Cara kerja USBCheck",
-                    "how_title": "Uji cepat di browser, mode Pro untuk analisis mendalam.",
-                    "how_intro": "USBCheck menggabungkan dua kebutuhan: uji cepat yang simpel untuk semua pengguna, dan mode Pro yang lebih dalam untuk pengguna teknis, teknisi, serta admin. Uji cepat berjalan langsung di browser, tanpa instalasi. Mode Pro menggunakan tool kecil yang dapat menjalankan uji mirip F3 / badblocks untuk mendeteksi flashdisk palsu dengan kapasitas yang dimanipulasi.",
-                    "how_step1_title": "Mulai uji dari browser",
-                    "how_step1_text": "Buka halaman uji cepat di",
-                    "how_step2_title": "Pengujian tulis, baca, dan integritas",
-                    "how_step2_text": "Browser membuat berkas uji, mengukur kecepatan tulis dan baca, lalu membandingkan nilai hash untuk mendeteksi kesalahan data – semuanya dilakukan secara lokal, tanpa mengunggah kontenmu.",
-                    "how_step3_title": "Opsional: mode Pro untuk pemindaian penuh",
-                    "how_step3_text": "Jika ingin hasil yang lebih mendalam, kamu dapat memasang tool pendamping. Tool ini dapat memeriksa seluruh kapasitas flashdisk, mengidentifikasi kapasitas palsu, dan menghasilkan laporan terperinci – ideal untuk refurbisher, departemen IT, atau laboratorium.",
-                    "how_side_title": "Sekilas perbandingan Free vs Pro",
-                    "how_side_free": "pages.main.sections.how.how_side_free",
-                    "how_side_pro": "pages.main.sections.how.how_side_pro",
-                    "how_side_account": "pages.main.sections.how.how_side_account"
-                },
-                "hero": {
-                    "hero_kicker": "Deteksi flashdisk USB palsu sebelum datamu hilang",
-                    "hero_title": "Apakah USB saya palsu?",
-                    "hero_lead": "USBCheck menggabungkan uji cepat di browser dengan mode Pro yang profesional. Dengan begitu, kamu bisa mendeteksi USB palsu, kapasitas nyata yang lebih kecil dari klaim, dan kontroler murahan yang lambat – sebelum file-file pentingmu rusak.",
-                    "cta_quick": "Mulai uji cepat gratis",
-                    "cta_learn": "Pelajari perbedaan Free & Pro",
-                    "trust1_title": "Tanpa instalasi untuk uji cepat",
-                    "trust1_text": "Uji berbasis browser langsung di flashdisk milikmu.",
-                    "trust2_title": "Uji tulis & baca yang nyata",
-                    "trust2_text": "Kecepatan tulis/baca diuji dengan data sungguhan – bukan sekadar angka sintetis.",
-                    "trust3_title": "Privasi didahulukan",
-                    "trust3_text": "Data uji tetap lokal – laporan hanya dibuat atau disinkronkan jika kamu menginginkannya.",
-                    "quick_label": "PRATINJAU UJI CEPAT",
-                    "quick_title": "Uji satu flashdisk USB dalam waktu kurang dari 2 menit",
-                    "badge_free": "Gratis",
-                    "quick_metric1_label": "Performa tulis",
-                    "quick_metric1_value": "~ 75–120 MB/detik*",
-                    "quick_metric2_label": "Volume pemeriksaan integritas",
-                    "quick_metric2_value": "Sampel 512 MB",
-                    "quick_intro": "Uji cepat menulis dan membaca kembali sejumlah data di flashdisk dan mengukur:",
-                    "quick_li1": "Kecepatan tulis dan baca",
-                    "quick_li2": "Integritas data (perbandingan hash)",
-                    "quick_li3": "Gangguan atau kesalahan yang mencurigakan",
-                    "quick_visual_title": "Indikator hasil uji cepat",
-                    "quick_visual_text": "Tampilan pratinjau: hijau menunjukkan flashdisk stabil, oranye menandakan ada hal yang perlu diperhatikan.",
-                    "quick_visual_window": "Jendela hasil",
-                    "quick_footnote": "*Nilai contoh – hasil aktual bergantung pada flashdisk, port, dan sistem yang digunakan.",
-                    "quick_cta": "Pergi ke uji cepat gratis"
-                },
-                "features": {
-                    "features_kicker": "Fitur Free & Pro",
-                    "features_title": "Mulai dengan uji cepat gratis – beralih ke mode Pro jika kamu butuh lebih banyak kontrol.",
-                    "features_intro": "USBCheck tumbuh mengikuti kebutuhanmu: pengguna rumahan biasanya hanya perlu gambaran cepat. Profesional ingin memverifikasi kapasitas, mendokumentasikan hasil, dan menyimpan laporan untuk jangka panjang. Mode Pro dirancang khusus untuk itu.",
-                    "features_free_title": "Uji Cepat Gratis",
-                    "features_free_badge": "Direkomendasikan untuk sebagian besar pengguna",
-                    "features_free_text": "Ideal untuk siapa pun yang ingin dengan cepat memeriksa apakah sebuah flashdisk setidaknya bekerja cukup stabil dan tidak terlalu lambat – tanpa perlu instalasi.",
-                    "features_free_li1": "• Uji cepat berbasis browser langsung di flashdisk",
-                    "features_free_li2": "• Pengukuran kecepatan tulis dan baca dengan data nyata",
-                    "features_free_li3": "• Pemeriksaan integritas berbasis hash pada sejumlah data uji",
-                    "features_free_li4": "• Pilihan beberapa tingkat uji (misalnya 200 MB, 2 GB)",
-                    "features_free_li5": "• Tidak perlu registrasi untuk mulai menggunakan",
-                    "features_free_cta": "Mulai uji cepat gratis",
-                    "features_pro_title": "Mode Pro",
-                    "features_pro_badge": "Untuk power user & tim",
-                    "features_pro_text": "Ditujukan bagi mereka yang membutuhkan kontrol penuh: departemen IT, teknisi, refurbisher, laboratorium, atau perusahaan yang secara rutin menguji banyak flashdisk.",
-                    "features_pro_li1": "• Pemindaian mendalam atas seluruh kapasitas (mirip F3 / badblocks)",
-                    "features_pro_li2": "• Deteksi kapasitas palsu dan area memori yang rusak",
-                    "features_pro_li3": "• Laporan terperinci yang dapat disimpan (JSON, PDF)",
-                    "features_pro_li4": "• Akses API opsional untuk alur kerja pengujian otomatis",
-                    "features_pro_li5": "• Dukungan multi-perangkat dan multi-pengguna melalui area login",
-                    "features_pro_note": "Mode Pro membutuhkan sebuah tool pendamping kecil di sistemmu. Tool ini bekerja secara lokal dan, bila diinginkan, dapat dihubungkan dengan akun USBCheck milikmu."
-                },
-                "faq": {
-                    "faq_kicker": "FAQ",
-                    "faq_title": "Pertanyaan umum tentang USBCheck",
-                    "faq_intro": "Di sini kamu dapat menemukan jawaban atas pertanyaan yang paling sering ditanyakan. Bagian FAQ dapat diperluas sewaktu-waktu seiring munculnya kasus penggunaan baru atau adanya masukan dari pengguna.",
-                    "faq_q1": "Apakah uji cepat benar-benar berjalan sepenuhnya di browser?",
-                    "faq_a1": "Ya. Uji cepat berjalan sepenuhnya di dalam browser dan menggunakan API browser modern untuk menulis dan membaca berkas uji di flashdisk milikmu. Tidak ada data yang diunggah tanpa persetujuanmu.",
-                    "faq_q2": "Apakah saya perlu akun untuk menggunakan uji cepat?",
-                    "faq_a2": "Tidak. Uji cepat gratis dapat digunakan tanpa registrasi. Login hanya dibutuhkan jika kamu ingin menyimpan laporan uji, mengelola banyak flashdisk, atau menggunakan mode Pro.",
-                    "faq_q3": "Apakah USBCheck bisa mendeteksi semua flashdisk palsu dengan pasti?",
-                    "faq_a3": "Tidak ada alat yang dapat memberikan jaminan 100%. Namun, mode Pro dengan pemindaian penuh dirancang untuk sangat andal dalam mendeteksi pola kecurangan yang umum, seperti kapasitas palsu, area memori yang tidak stabil, atau kesalahan yang muncul setelah kapasitas tertentu terisi.",
-                    "faq_q4": "Bagaimana USBCheck bisa diintegrasikan dengan sistem saya?",
-                    "faq_a4": "USBCheck sejak awal dirancang untuk mendukung otomatisasi. Melalui mode Pro dan API yang direncanakan, kamu dapat mengintegrasikan pengujian ke dalam alur kerja yang sudah ada – misalnya pada proses inspeksi barang masuk atau kontrol kualitas."
-                },
-                "problem": {
-                    "problem_kicker": "Mengapa flashdisk USB palsu berbahaya",
-                    "problem_title": "Flashdisk USB palsu bisa menghabiskan uang – dan yang lebih parah, menghilangkan datamu.",
-                    "problem_p1": "Banyak flashdisk murah mengklaim kapasitas yang jauh lebih besar dari yang sebenarnya. Kontroler dimanipulasi sehingga melaporkan, misalnya, 256 GB, padahal secara fisik hanya 32 GB. Akibatnya, data tampak tersalin dengan normal, tetapi sebagian akan ditimpa atau rusak setelah kapasitas nyata terlampaui.",
-                    "problem_p2": "USBCheck membantumu mendeteksi masalah seperti ini sebelum flashdisk digunakan secara serius – baik untuk penggunaan pribadi maupun untuk pengujian batch dalam perusahaan.",
-                    "problem_card1_title": "Kehilangan file penting",
-                    "problem_card1_text": "Foto, dokumen proyek, dan cadangan – semuanya bisa terdampak jika flashdisk tidak memiliki kapasitas nyata seperti yang diklaim. Kerusakan sering kali baru ketahuan saat sudah terlambat.",
-                    "problem_card2_title": "Biaya dari satu batch yang bermasalah",
-                    "problem_card2_text": "Perusahaan, reseller, dan agensi sering membagikan flashdisk dalam jumlah besar. Jika batch tersebut palsu, akibatnya adalah komplain, kerusakan reputasi, dan biaya produksi ulang.",
-                    "problem_card3_title": "Performa yang tidak stabil",
-                    "problem_card3_text": "Kontroler yang jelek, firmware yang tidak stabil, dan kecepatan tulis yang naik turun adalah ciri khas flashdisk palsu. Hal ini meningkatkan risiko kesalahan, terutama pada file besar."
-                }
-            }
-        },
-        "dashboard": {
-            "meta": {
-                "title": "{{primary_domain}} – Dashboard",
-                "description": "Dashboard pada {{primary_domain}} untuk mengelola pengujian USB, perangkat, dan mode Pro."
-            },
-            "sections": {
-                "dashboard": {
-                    "dashboard_kicker": "Dashboard",
-                    "dashboard_title": "Selamat datang",
-                    "dashboard_intro": "Di sini kamu dapat mengelola pengujian USB, menata perangkat, dan nantinya mengaktifkan mode Pro. Bagian ini masih dalam pengembangan – kamu sudah mendapatkan gambaran awal tentang bagaimana semuanya akan terhubung.",
-                    "dashboard_plan_label": "Paket saat ini",
-                    "dashboard_card_tests_title": "Pengujian terbaru",
-                    "dashboard_card_tests_text": "Di sini nantinya akan tampil uji cepat dan pemindaian Pro terakhirmu – lengkap dengan status, kecepatan, dan hasil pemeriksaan integritas.",
-                    "dashboard_card_tests_empty": "Belum ada data pengujian. Mulai uji pertama melalui browser atau, nanti, melalui mode Pro.",
-                    "dashboard_card_devices_title": "Perangkat USB milikmu",
-                    "dashboard_card_devices_text": "Di masa depan kamu akan bisa mengelola flashdisk yang telah diuji di sini: produsen, model, nomor seri, dan kapasitas nyata yang terdeteksi.",
-                    "dashboard_card_devices_empty": "Belum ada perangkat yang disimpan. Setelah uji pertama, kamu bisa menambahkan flashdisk sebagai entri perangkat.",
-                    "dashboard_card_next_title": "Langkah berikutnya",
-                    "dashboard_card_next_text": "USBCheck masih dalam pengembangan aktif. Kamu adalah salah satu pengguna pertama – ke depannya, di sini akan muncul opsi Pro, akses API, dan laporan rinci.",
-                    "dashboard_card_next_item1": "• Coba FakeCheck berbasis browser dan kirimkan masukan",
-                    "dashboard_card_next_item2": "• Ikut mendefinisikan fitur mode Pro (pemindaian penuh, laporan, API)",
-                    "dashboard_card_next_item3": "• Menyelesaikan integrasi akun & SSO (my-log.in)",
-                    "dashboard_card_next_cta": "Buka FakeCheck"
-                }
-            }
-        },
-        "fakecheck": {
-            "meta": {
-                "title": "{{primary_domain}} – FakeCheck",
-                "description": "Deskripsi FakeCheck pada {{primary_domain}} untuk mendeteksi flashdisk USB palsu melalui browser."
-            },
-            "sections": {
-                "hero": {
-                    "fake_hero_kicker": "FakeCheck – mode browser",
-                    "fake_hero_title": "Apakah flashdisk saya palsu?",
-                    "fake_hero_lead": "FakeCheck membantumu menemukan flashdisk palsu yang umum ditemui dengan uji tulis/baca berbasis browser dan pemeriksaan kewajaran kapasitas – tanpa instalasi apa pun.",
-                    "fake_cta_start": "Mulai uji di browser (demo)",
-                    "fake_cta_back_home": "Kembali ke ringkasan",
-                    "fake_hero_hint": "FakeCheck bekerja dengan berkas uji dan pola baca/tulis yang dibuat di folder yang kamu pilih. File asli di dalam folder tersebut tidak akan disentuh.",
-                    "fake_box_title": "Apa yang bisa dilakukan uji browser",
-                    "fake_box_point1_title": "Uji tulis/baca dengan berkas uji",
-                    "fake_box_point1_text": "Browser membuat berkas uji di folder yang dipilih, mengukur kecepatan tulis dan baca, lalu memverifikasi apakah data yang dibaca kembali sesuai dengan pola yang ditulis.",
-                    "fake_box_point2_title": "Pemeriksaan kewajaran kapasitas",
-                    "fake_box_point2_text": "Dari jumlah data yang berhasil ditulis dan diverifikasi, kamu mendapatkan gambaran realistis tentang berapa banyak kapasitas yang benar-benar stabil dan dapat digunakan.",
-                    "fake_box_point3_title": "Laporan JSON untuk dokumentasi",
-                    "fake_box_point3_text": "Semua hasil dikumpulkan ke dalam laporan JSON terstruktur yang bisa kamu simpan, unggah, atau gunakan untuk membandingkan dengan pengujian berikutnya."
-                }
-            }
-        },
-        "login": {
-            "meta": {
-                "title": "{{primary_domain}} – Login",
-                "description": "Halaman login pada {{primary_domain}} untuk mengelola akun USBCheck, laporan, dan mode Pro."
-            },
-            "sections": {
-                "login": {
-                    "auth_kicker": "Akun & login",
-                    "auth_title": "Masuk ke USBCheck",
-                    "auth_intro": "Dengan sebuah akun, kamu dapat menyimpan pengujian, mengekspor laporan, dan menggunakan mode Pro di beberapa perangkat. Pendaftaran gratis – kamu bisa memutuskan nanti jika ingin upgrade ke Pro.",
-                    "auth_tab_login": "Login",
-                    "auth_tab_register": "Daftar",
-                    "auth_login_title": "Login",
-                    "auth_login_text": "Masuk dengan alamat email dan kata sandi.",
-                    "auth_login_email_label": "Alamat email",
-                    "auth_login_password_label": "Kata sandi",
-                    "auth_login_submit": "Masuk",
-                    "auth_login_forgot": "Lupa kata sandi?",
-                    "auth_register_title": "Daftar gratis",
-                    "auth_register_text": "Buat akun gratis untuk menyimpan pengujian, mengekspor laporan, dan mengaktifkan mode Pro di kemudian hari.",
-                    "auth_register_name_label": "Nama",
-                    "auth_register_email_label": "Alamat email",
-                    "auth_register_password_label": "Kata sandi",
-                    "auth_register_submit": "Buat akun",
-                    "auth_register_hint": "Dengan mendaftar, kamu menyetujui kebijakan privasi dan ketentuan hukum USBCheck."
-                }
-            }
-        },
-        "tools": {
-            "meta": {
-                "title": "{{primary_domain}} – Tools",
-                "description": "Deskripsi untuk bagian tools pada {{primary_domain}}."
-            }
-        }
-    },
-    "partials": {
-        "structure": {
-            "layout_end": {
-                "logout_modal_title": "Yakin ingin logout?",
-                "logout_modal_text": "Jika kamu logout, sesi saat ini akan diakhiri dan tindakan yang belum disimpan mungkin akan hilang. Kamu selalu bisa login lagi kapan saja.",
-                "logout_modal_cancel": "Batal",
-                "logout_modal_confirm": "Ya, logout"
-            },
-            "header": {
-                "header_slogan": "Tes flashdisk USB",
-                "header_btn_login": "Login",
-                "header_menu_dashboard": "Dashboard",
-                "header_menu_logout": "Logout",
-                "logout_title": "Yakin ingin logout?",
-                "logout_text": "Kamu akan keluar dari akun USBCheck. Uji yang sedang berjalan di browser tidak akan terpengaruh.",
-                "logout_cancel": "Batal",
-                "logout_confirm": "Ya, logout"
-            },
-            "footer": {
-                "footer_imprint": "partials.structure.footer.footer_imprint",
-                "footer_privacy": "partials.structure.footer.footer_privacy"
-            }
-        }
-    }
-}

public/assets/i18n/it.json

@@ -1,236 +0,0 @@
-{
-    "meta": {
-        "code": "it",
-        "label": "Italiano",
-        "flag": "🇮🇹",
-        "enabled": true
-    },
-    "pages": {
-        "landing": {
-            "meta": {
-                "title": "SENZA TITOLO"
-            }
-        },
-        "main": {
-            "anchors": {
-                "how": "Come funziona",
-                "problem": "Perché le chiavette USB false sono pericolose",
-                "features": "Funzionalità",
-                "security": "Sicurezza",
-                "faq": "FAQ"
-            },
-            "sections": {
-                "security": {
-                    "security_kicker": "Sicurezza e privacy",
-                    "security_title": "Privacy-first: i tuoi dati ti appartengono.",
-                    "security_intro": "USBCheck è stato progettato fin dall’inizio per proteggere i tuoi dati. Il test rapido del browser utilizza esclusivamente file di test. I tuoi documenti, immagini o backup non vengono mai letti o trasmessi. Con la modalità Pro hai il pieno controllo su quali report sincronizzare con il tuo account.",
-                    "security_card1_title": "Test solo locali",
-                    "security_card1_text": "Tutti i test di lettura e scrittura avvengono localmente sulla tua chiavetta USB. Il browser accede solo ai file di test – mai ai tuoi contenuti privati.",
-                    "security_card2_title": "Report trasparenti",
-                    "security_card2_text": "Se effettui il login, puoi salvare, esportare o eliminare i report nel tuo account. Sei tu a decidere quali dati rimangono nel sistema.",
-                    "security_card3_title": "Delicato sull’hardware",
-                    "security_card3_text": "Il test rapido utilizza una quantità moderata di dati per evitare usura inutile. La modalità Pro avvisa chiaramente quando viene avviata una scansione completa con elevato carico di scrittura."
-                },
-                "how": {
-                    "how_kicker": "Come funziona USBCheck",
-                    "how_title": "Test rapido nel browser, modalità Pro con analisi approfondita.",
-                    "how_intro": "USBCheck unisce due mondi: un test rapido semplice per tutti e una modalità Pro avanzata per utenti esperti, tecnici e amministratori. Il test rapido funziona direttamente nel browser senza installazione. La modalità Pro utilizza un piccolo tool in grado di eseguire test simili a F3 / badblocks per individuare falsi di capacità.",
-                    "how_step1_title": "Avvia il test nel browser",
-                    "how_step1_text": "Apri il test rapido su",
-                    "how_step2_title": "Test di scrittura, lettura e integrità",
-                    "how_step2_text": "Il browser crea file di test, misura le velocità e confronta gli hash per rilevare errori – tutto localmente e senza trasmettere i tuoi contenuti.",
-                    "how_step3_title": "Opzionale: modalità Pro per scansione completa",
-                    "how_step3_text": "Per controlli più approfonditi, installi lo strumento opzionale. Può verificare l’intera capacità reale, identificare falsi e generare report dettagliati – ideale per reparti IT, tecnici o laboratori.",
-                    "how_side_title": "Differenze tra Free e Pro",
-                    "how_side_free": "pages.main.sections.how.how_side_free",
-                    "how_side_pro": "pages.main.sections.how.how_side_pro",
-                    "how_side_account": "pages.main.sections.how.how_side_account"
-                },
-                "hero": {
-                    "hero_kicker": "Individua USB falsi prima di perdere i dati",
-                    "hero_title": "La mia USB è falsa?",
-                    "hero_lead": "USBCheck combina un test rapido nel browser con una modalità Pro professionale. Così puoi rilevare USB false, capacità reali più basse del dichiarato e controller economici e lenti – prima di perdere i tuoi file.",
-                    "cta_quick": "Avvia test rapido gratuito",
-                    "cta_learn": "Scopri di più su Free & Pro",
-                    "trust1_title": "Nessuna installazione",
-                    "trust1_text": "Test direttamente sulla chiavetta tramite browser.",
-                    "trust2_title": "Test reali di scrittura e lettura",
-                    "trust2_text": "Dati reali, non simulazioni teoriche.",
-                    "trust3_title": "Privacy prima di tutto",
-                    "trust3_text": "I dati del test rimangono in locale – i report vengono sincronizzati solo se lo desideri.",
-                    "quick_label": "ANTEPRIMA TEST RAPIDO",
-                    "quick_title": "Testa una USB in meno di 2 minuti",
-                    "badge_free": "Gratis",
-                    "quick_metric1_label": "Prestazioni di scrittura",
-                    "quick_metric1_value": "~ 75–120 MB/s*",
-                    "quick_metric2_label": "Controlli di integrità",
-                    "quick_metric2_value": "Campione da 512 MB",
-                    "quick_intro": "Il test rapido verifica una quantità definita di dati e misura:",
-                    "quick_li1": "Velocità di lettura e scrittura",
-                    "quick_li2": "Integrità dei dati (hash)",
-                    "quick_li3": "Errori o interruzioni sospette",
-                    "quick_visual_title": "Indicatore test rapido",
-                    "quick_visual_text": "Ecco l’anteprima: verde indica una chiavetta stabile, arancione segnala anomalie.",
-                    "quick_visual_window": "Finestra risultati",
-                    "quick_footnote": "*Valori indicativi – dipendono da chiavetta, porta e sistema.",
-                    "quick_cta": "Vai al test rapido gratuito"
-                },
-                "features": {
-                    "features_kicker": "Funzioni Free & Pro",
-                    "features_title": "Inizia con il test rapido gratuito – passa alla modalità Pro se hai bisogno di più strumenti.",
-                    "features_intro": "USBCheck cresce con le tue esigenze: gli utenti privati spesso vogliono solo una valutazione rapida. I professionisti invece desiderano verifiche approfondite e report archiviabili.",
-                    "features_free_title": "Test rapido gratuito",
-                    "features_free_badge": "Raccomandato per la maggior parte degli utenti",
-                    "features_free_text": "Ideale per verificare rapidamente se una USB funziona in modo stabile – senza installazione.",
-                    "features_free_li1": "• Test rapido via browser direttamente sulla chiavetta",
-                    "features_free_li2": "• Velocità reali di lettura/scrittura",
-                    "features_free_li3": "• Controllo integrità basato su hash",
-                    "features_free_li4": "• Livelli di test selezionabili (200 MB, 2 GB)",
-                    "features_free_li5": "• Nessuna registrazione richiesta",
-                    "features_free_cta": "Avvia test rapido",
-                    "features_pro_title": "Modalità Pro",
-                    "features_pro_badge": "Per power users & team",
-                    "features_pro_text": "Per chi ha bisogno di controllo totale: aziende, IT, tecnici, laboratori e produttori che testano molte USB.",
-                    "features_pro_li1": "• Scansione completa della capacità (simile a F3 / badblocks)",
-                    "features_pro_li2": "• Rilevamento falsi e settori danneggiati",
-                    "features_pro_li3": "• Report dettagliati (JSON, PDF)",
-                    "features_pro_li4": "• Accesso API opzionale",
-                    "features_pro_li5": "• Supporto multi-dispositivo e multi-utente",
-                    "features_pro_note": "La modalità Pro richiede un piccolo tool locale. Funziona offline e può collegarsi al tuo account USBCheck."
-                },
-                "faq": {
-                    "faq_kicker": "FAQ",
-                    "faq_title": "Domande frequenti su USBCheck",
-                    "faq_intro": "Qui trovi le risposte alle domande più comuni. La sezione FAQ verrà ampliata con nuovi casi d’uso e feedback degli utenti.",
-                    "faq_q1": "Il test rapido funziona completamente nel browser?",
-                    "faq_a1": "Sì. Il test rapido si svolge interamente nel browser utilizzando API moderne che permettono di scrivere e leggere file di test sulla USB, senza caricare nulla online.",
-                    "faq_q2": "Serve un account per usare il test rapido?",
-                    "faq_a2": "No. Il test gratuito non richiede registrazione. L’account serve solo per salvare report, gestire più dispositivi o usare la modalità Pro.",
-                    "faq_q3": "USBCheck può rilevare tutti i falsi USB?",
-                    "faq_a3": "Nessuno strumento può garantire il 100%. Tuttavia, la modalità Pro con scansione completa è progettata per individuare con alta affidabilità i modelli tipici di falsificazione.",
-                    "faq_q4": "Come si integra lo strumento nel mio sistema?",
-                    "faq_a4": "USBCheck è pensato per l’automazione. Con la modalità Pro e la futura API puoi integrare i test nei tuoi flussi di lavoro, come controlli qualità o verifiche in ingresso."
-                },
-                "problem": {
-                    "problem_kicker": "Perché le USB false sono pericolose",
-                    "problem_title": "Le chiavette USB false costano denaro – e rischiano i tuoi dati.",
-                    "problem_p1": "Molte USB economiche dichiarano capacità irrealistiche. In realtà il controller è manipolato: può segnalare 256 GB quando ne contiene solo 32. Il risultato: i dati sembrano copiati correttamente, ma vengono sovrascritti o corrotti in silenzio.",
-                    "problem_p2": "USBCheck ti aiuta a individuare questi falsi prima dell’uso, sia in ambito privato che aziendale.",
-                    "problem_card1_title": "Perdita di file importanti",
-                    "problem_card1_text": "Foto, progetti, backup… tutto può andare perso se la memoria reale è inferiore al dichiarato.",
-                    "problem_card2_title": "Costi dovuti a lotti difettosi",
-                    "problem_card2_text": "Aziende e rivenditori distribuiscono spesso USB in grandi quantità. Le falsificazioni causano reclami, danni d’immagine e costi aggiuntivi.",
-                    "problem_card3_title": "Prestazioni instabili",
-                    "problem_card3_text": "Controller lenti, firmware instabile e velocità variabili sono tipici nelle USB false e aumentano il rischio di errori."
-                }
-            }
-        },
-        "dashboard": {
-            "meta": {
-                "title": "{{primary_domain}} – Dashboard",
-                "description": "Descrizione per dashboard su {{primary_domain}}"
-            },
-            "sections": {
-                "dashboard": {
-                    "dashboard_kicker": "Dashboard",
-                    "dashboard_title": "Benvenuto",
-                    "dashboard_intro": "Qui puoi gestire i tuoi test USB, organizzare i dispositivi e attivare la modalità Pro. L’area è ancora in sviluppo, ma offre già una panoramica.",
-                    "dashboard_plan_label": "Piano attuale",
-                    "dashboard_card_tests_title": "Ultimi test",
-                    "dashboard_card_tests_text": "Qui verranno visualizzati i tuoi ultimi test rapidi e analisi Pro – con stato, velocità e integrità.",
-                    "dashboard_card_tests_empty": "Ancora nessun test disponibile. Avvia un test tramite browser o modalità Pro.",
-                    "dashboard_card_devices_title": "I tuoi dispositivi USB",
-                    "dashboard_card_devices_text": "In futuro potrai gestire qui le USB testate: produttore, modello, numero di serie e capacità rilevata.",
-                    "dashboard_card_devices_empty": "Nessun dispositivo salvato. Dopo i primi test potrai aggiungere le chiavette qui.",
-                    "dashboard_card_next_title": "Prossimi passi",
-                    "dashboard_card_next_text": "USBCheck è ancora in sviluppo. Sei tra i primi utenti; più avanti troverai funzioni Pro, accesso API e report avanzati.",
-                    "dashboard_card_next_item1": "• Testa FakeCheck nel browser e invia feedback",
-                    "dashboard_card_next_item2": "• Definisci le funzioni della modalità Pro (scansione completa, report, API)",
-                    "dashboard_card_next_item3": "• Finalizza account & SSO (my-log.in)",
-                    "dashboard_card_next_cta": "Vai a FakeCheck"
-                }
-            }
-        },
-        "fakecheck": {
-            "meta": {
-                "title": "{{primary_domain}} – FakeCheck",
-                "description": "Descrizione per FakeCheck su {{primary_domain}}"
-            },
-            "sections": {
-                "hero": {
-                    "fake_hero_kicker": "FakeCheck – modalità browser",
-                    "fake_hero_title": "La mia USB è falsa?",
-                    "fake_hero_lead": "FakeCheck ti aiuta a individuare USB contraffatte tramite test di lettura/scrittura e controlli di capacità – senza installazione.",
-                    "fake_cta_start": "Avvia test browser (demo)",
-                    "fake_cta_back_home": "Torna alla panoramica",
-                    "fake_hero_hint": "FakeCheck utilizza file di test creati in una cartella selezionata. I tuoi file reali non vengono toccati.",
-                    "fake_box_title": "Cosa può fare il test browser",
-                    "fake_box_point1_title": "Test di lettura/scrittura",
-                    "fake_box_point1_text": "Il browser crea file di test, misura le velocità e verifica la corrispondenza dei dati.",
-                    "fake_box_point2_title": "Controllo capacità",
-                    "fake_box_point2_text": "La quantità di dati scritti e verificati mostra la capacità realmente utilizzabile.",
-                    "fake_box_point3_title": "Report JSON",
-                    "fake_box_point3_text": "Tutti i risultati vengono raccolti in un report JSON strutturato che puoi salvare o confrontare in seguito."
-                }
-            }
-        },
-        "login": {
-            "meta": {
-                "title": "{{primary_domain}} – Accesso",
-                "description": "Descrizione per accesso su {{primary_domain}}"
-            },
-            "sections": {
-                "login": {
-                    "auth_kicker": "Account & accesso",
-                    "auth_title": "Accedi a USBCheck",
-                    "auth_intro": "Con un account puoi salvare test, esportare report e usare la modalità Pro su più dispositivi. La registrazione è gratuita – puoi passare alla versione Pro in qualsiasi momento.",
-                    "auth_tab_login": "Accedi",
-                    "auth_tab_register": "Registrati",
-                    "auth_login_title": "Accesso",
-                    "auth_login_text": "Accedi con la tua email e la tua password.",
-                    "auth_login_email_label": "Email",
-                    "auth_login_password_label": "Password",
-                    "auth_login_submit": "Accedi",
-                    "auth_login_forgot": "Password dimenticata?",
-                    "auth_register_title": "Registrazione gratuita",
-                    "auth_register_text": "Crea un account gratuito per salvare test, esportare report e attivare la modalità Pro.",
-                    "auth_register_name_label": "Nome",
-                    "auth_register_email_label": "Email",
-                    "auth_register_password_label": "Password",
-                    "auth_register_submit": "Crea account",
-                    "auth_register_hint": "Registrandoti accetti l’informativa sulla privacy e il colophon di USBCheck."
-                }
-            }
-        },
-        "tools": {
-            "meta": {
-                "title": "{{primary_domain}} – Strumenti",
-                "description": "Descrizione per strumenti su {{primary_domain}}"
-            }
-        }
-    },
-    "partials": {
-        "structure": {
-            "layout_end": {
-                "logout_modal_title": "Vuoi disconnetterti?",
-                "logout_modal_text": "Disconnettendoti, la sessione corrente e le azioni non salvate verranno chiuse. Puoi accedere di nuovo in qualsiasi momento.",
-                "logout_modal_cancel": "Annulla",
-                "logout_modal_confirm": "Sì, disconnettiti"
-            },
-            "header": {
-                "header_slogan": "Test USB",
-                "header_btn_login": "Accedi",
-                "header_menu_dashboard": "Dashboard",
-                "header_menu_logout": "Disconnetti",
-                "logout_title": "Vuoi disconnetterti?",
-                "logout_text": "Verrai disconnesso dal tuo account USBCheck. I test attivi nel browser non verranno interrotti.",
-                "logout_cancel": "Annulla",
-                "logout_confirm": "Sì, disconnettiti"
-            },
-            "footer": {
-                "footer_imprint": "partials.structure.footer.footer_imprint",
-                "footer_privacy": "partials.structure.footer.footer_privacy"
-            }
-        }
-    }
-}

public/assets/i18n/ja.json

@@ -1,236 +0,0 @@
-{
-    "meta": {
-        "code": "ja",
-        "label": "日本語",
-        "flag": "🇯🇵",
-        "enabled": true
-    },
-    "pages": {
-        "landing": {
-            "meta": {
-                "title": "タイトルなし"
-            }
-        },
-        "main": {
-            "anchors": {
-                "how": "仕組み",
-                "problem": "偽造USBメモリが危険な理由",
-                "features": "機能",
-                "security": "セキュリティ",
-                "faq": "よくある質問"
-            },
-            "sections": {
-                "security": {
-                    "security_kicker": "セキュリティとプライバシー",
-                    "security_title": "プライバシー優先設計：テストデータはあなたのものです。",
-                    "security_intro": "USBCheck は初期段階からプライバシー保護を中心に設計されています。ブラウザのクイックテストはテスト用ファイルのみを使用し、あなたの文書・写真・バックアップなどが読み取られたり送信されたりすることはありません。Pro モードでは、どのレポートをアカウントと同期するかを完全に自分でコントロールできます。",
-                    "security_card1_title": "ローカルのみで動作",
-                    "security_card1_text": "すべての書き込み・読み取りテストは USB ドライブ上でローカルに実行されます。ブラウザがアクセスするのはテストファイルのみで、あなたの個人的なデータには触れません。",
-                    "security_card2_title": "透明性のあるレポート",
-                    "security_card2_text": "ログインすると、テストレポートを保存したり、エクスポートしたり、削除したりできます。どのデータをシステムに残すかはあなたが決められます。",
-                    "security_card3_title": "ハードウェアへの負担軽減",
-                    "security_card3_text": "クイックテストは適切なデータ量のみを使用し、不要な書き込み負荷を避けます。Pro モードでは、全体スキャンを行う前に書き込み負荷が高いことを明確に警告します。"
-                },
-                "how": {
-                    "how_kicker": "USBCheck の仕組み",
-                    "how_title": "ブラウザでのクイックテストと、Pro モードでの高度な分析。",
-                    "how_intro": "USBCheck は、誰でも使えるシンプルなクイックテストと、技術ユーザー・管理者向けの高度な Pro モードを兼ね備えています。クイックテストはブラウザ上で動作し、インストールは不要です。Pro モードでは小型の補助ツールを利用し、F3 / badblocks に近い方法で容量詐称を確実に検出できます。",
-                    "how_step1_title": "ブラウザテストを開始",
-                    "how_step1_text": "以下のページからクイックテストを開きます：",
-                    "how_step2_title": "書き込み・読み取り・整合性チェック",
-                    "how_step2_text": "ブラウザは USB ドライブ上にテストファイルを作成し、書き込み速度・読み取り速度を計測し、ハッシュ値比較によりデータの整合性を検証します。すべてローカルで行われ、あなたの本当のファイルがアップロードされることはありません。",
-                    "how_step3_title": "オプション：Pro モードでフルスキャン",
-                    "how_step3_text": "さらに詳しい情報が必要な場合は、補助ツールをインストールできます。これにより、ドライブ全体の容量を検証し、偽装容量や不安定な領域を検出し、詳細レポートを生成できます。リファービッシャー、IT 部門、研究施設などにも適しています。",
-                    "how_side_title": "Free と Pro の比較",
-                    "how_side_free": "pages.main.sections.how.how_side_free",
-                    "how_side_pro": "pages.main.sections.how.how_side_pro",
-                    "how_side_account": "pages.main.sections.how.how_side_account"
-                },
-                "hero": {
-                    "hero_kicker": "大切なデータを失う前に、偽物 USB を見抜く",
-                    "hero_title": "この USB は偽物？",
-                    "hero_lead": "USBCheck は高速ブラウザテストとプロ向けモードを組み合わせ、容量偽装、不良コントローラ、速度の低い安価モデルなどを事前に見抜くことができます。",
-                    "cta_quick": "無料クイックテストを開始",
-                    "cta_learn": "Free と Pro の違いを詳しく見る",
-                    "trust1_title": "インストール不要",
-                    "trust1_text": "ブラウザだけで実行できるテスト。",
-                    "trust2_title": "実データによるテスト",
-                    "trust2_text": "実際の書き込み・読み取りデータを使用します。理論値ではありません。",
-                    "trust3_title": "プライバシー優先",
-                    "trust3_text": "テストに使うデータはすべてローカルに留まり、レポートの保存は任意です。",
-                    "quick_label": "クイックテスト プレビュー",
-                    "quick_title": "2 分以内に USB ドライブをチェック",
-                    "badge_free": "無料",
-                    "quick_metric1_label": "書き込み性能",
-                    "quick_metric1_value": "~ 75–120 MB/s*",
-                    "quick_metric2_label": "整合性チェック量",
-                    "quick_metric2_value": "512 MB サンプル",
-                    "quick_intro": "クイックテストは以下を測定します：",
-                    "quick_li1": "書き込み速度・読み取り速度",
-                    "quick_li2": "データ整合性（ハッシュ比較）",
-                    "quick_li3": "異常な中断やエラー",
-                    "quick_visual_title": "テスト結果の表示",
-                    "quick_visual_text": "プレビュー画面では、安定している場合は緑、注意が必要な場合はオレンジで表示されます。",
-                    "quick_visual_window": "結果ウィンドウ",
-                    "quick_footnote": "*参考値です。実際の速度は USB、ポート、システム環境によって変わります。",
-                    "quick_cta": "無料クイックテストへ"
-                },
-                "features": {
-                    "features_kicker": "Free と Pro の機能",
-                    "features_title": "まずは無料のクイックテスト。必要に応じて Pro モードへ。",
-                    "features_intro": "USBCheck はユーザーのニーズに合わせて成長します。一般ユーザーは簡単な評価だけで十分ですが、プロユーザーは容量の検証やレポート保存が求められます。Pro モードはそうしたニーズに特化しています。",
-                    "features_free_title": "無料クイックテスト",
-                    "features_free_badge": "多くのユーザーに最適",
-                    "features_free_text": "インストールなしで U 盤の基本性能や安定性を素早く確認できます。",
-                    "features_free_li1": "• ブラウザ上で直接実行",
-                    "features_free_li2": "• 実データを使った読写速度の検証",
-                    "features_free_li3": "• データ整合性のハッシュ検証",
-                    "features_free_li4": "• 200MB / 2GB など複数のテストレベル",
-                    "features_free_li5": "• アカウント登録不要",
-                    "features_free_cta": "無料テストを開始",
-                    "features_pro_title": "Pro モード",
-                    "features_pro_badge": "パワーユーザー・チーム向け",
-                    "features_pro_text": "IT 部門、技術者、リファービッシャー、大量検査が必要な企業などに理想的です。",
-                    "features_pro_li1": "• 全容量のディープスキャン（F3 / badblocks に類似）",
-                    "features_pro_li2": "• 容量偽装や不良領域を検出",
-                    "features_pro_li3": "• 保存可能な詳細レポート（JSON / PDF）",
-                    "features_pro_li4": "• 自動化向け API（オプション）",
-                    "features_pro_li5": "• マルチデバイス / マルチユーザー対応",
-                    "features_pro_note": "Pro モードには補助ツールのインストールが必要です。データはローカルで処理され、アカウント同期は任意です。"
-                },
-                "faq": {
-                    "faq_kicker": "よくある質問",
-                    "faq_title": "USBCheck に関する FAQ",
-                    "faq_intro": "よく寄せられる質問への回答です。ユーザーの利用状況やフィードバックに応じて随時更新されます。",
-                    "faq_q1": "クイックテストは完全にブラウザ内で動作しますか？",
-                    "faq_a1": "はい。ブラウザが USB ドライブ上にテストファイルを作成・読み取りし、あなたの許可なしにデータが送信されることはありません。",
-                    "faq_q2": "クイックテストにアカウント登録は必要ですか？",
-                    "faq_a2": "不要です。無料クイックテストは登録なしで利用できます。レポート保存や複数デバイス管理にはログインが必要です。",
-                    "faq_q3": "USBCheck はすべての偽造 USB を確実に検出できますか？",
-                    "faq_a3": "100% の保証はできませんが、Pro モードのフルスキャンは代表的な偽造パターン（容量詐称、不安定領域、特定容量超過後のエラー）を非常に高い精度で検出します。",
-                    "faq_q4": "USBCheck を既存のワークフローに統合できますか？",
-                    "faq_a4": "はい。USBCheck は自動化と統合を想定して設計されており、Pro モードと今後導入予定の API によって、入庫検査や品質管理などにも組み込むことができます。"
-                },
-                "problem": {
-                    "problem_kicker": "なぜ偽造 USB は危険なのか",
-                    "problem_title": "偽造 USB は損失を招き、最悪の場合データが失われます。",
-                    "problem_p1": "多くの安価な USB は実際より大きな容量を偽って表示します。コントローラが改ざんされており、たとえば実は 32GB しかないのに 256GB と報告することがあります。超過分に書き込まれたデータは後で上書きされたり破損したりします。",
-                    "problem_p2": "USBCheck はこうした偽造品を本格使用前に発見するのに役立ちます。個人利用でも、企業で大量に購入する場合でも有効です。",
-                    "problem_card1_title": "重要なデータの消失",
-                    "problem_card1_text": "写真、プロジェクトファイル、バックアップなど、大切なデータが偽装領域に書き込まれると、後で読み取れなくなる可能性があります。",
-                    "problem_card2_title": "大量仕入れによる損害",
-                    "problem_card2_text": "企業や代理店では大量の USB を配布することが多く、偽造品を混ぜてしまうと返品や信用低下、再製造コストが発生します。",
-                    "problem_card3_title": "不安定な性能",
-                    "problem_card3_text": "偽造 USB は低品質のコントローラを使用していることが多く、ファームウェアも不安定なため、速度が大きく揺らぎエラーの危険性が高まります。"
-                }
-            }
-        },
-        "dashboard": {
-            "meta": {
-                "title": "{{primary_domain}} – ダッシュボード",
-                "description": "{{primary_domain}} のダッシュボード概要"
-            },
-            "sections": {
-                "dashboard": {
-                    "dashboard_kicker": "ダッシュボード",
-                    "dashboard_title": "ようこそ",
-                    "dashboard_intro": "ここでは USB テストを管理したり、デバイスを整理したり、将来的に Pro 機能を有効化したりできます。現時点では開発中ですが、全体の構造が分かるようになっています。",
-                    "dashboard_plan_label": "現在のプラン",
-                    "dashboard_card_tests_title": "最近のテスト",
-                    "dashboard_card_tests_text": "最近実行したクイックテストおよび Pro スキャンがここに表示されます。状態、速度、整合性チェックなどが確認できます。",
-                    "dashboard_card_tests_empty": "テストデータがまだありません。まずはブラウザの FakeCheck または Pro モードからテストを開始してください。",
-                    "dashboard_card_devices_title": "あなたの USB デバイス",
-                    "dashboard_card_devices_text": "テスト後、デバイス情報（メーカー、モデル、シリアル番号、検出容量）をここで管理できます。",
-                    "dashboard_card_devices_empty": "保存されたデバイスはまだありません。初回テスト後にここに追加できます。",
-                    "dashboard_card_next_title": "次のステップ",
-                    "dashboard_card_next_text": "USBCheck は継続的に開発中です。今後、Pro オプション、API、詳細レポートなどが追加されます。",
-                    "dashboard_card_next_item1": "• ブラウザ版 FakeCheck を試してフィードバックを送る",
-                    "dashboard_card_next_item2": "• Pro 機能（フルスキャン、レポート、API）を検討",
-                    "dashboard_card_next_item3": "• アカウントおよび SSO（my-log.in）の統合を完了",
-                    "dashboard_card_next_cta": "FakeCheck へ移動"
-                }
-            }
-        },
-        "fakecheck": {
-            "meta": {
-                "title": "{{primary_domain}} – FakeCheck",
-                "description": "{{primary_domain}} の FakeCheck ブラウザ版テスト"
-            },
-            "sections": {
-                "hero": {
-                    "fake_hero_kicker": "FakeCheck – ブラウザモード",
-                    "fake_hero_title": "USB ドライブは本物？偽物？",
-                    "fake_hero_lead": "FakeCheck は、ブラウザ上で書き込み・読み取りテストと容量の妥当性チェックを行い、インストール不要で偽造 USB を見抜きます。",
-                    "fake_cta_start": "ブラウザテストを開始（デモ）",
-                    "fake_cta_back_home": "概要へ戻る",
-                    "fake_hero_hint": "FakeCheck は指定したフォルダ内にテストファイルを作成し、読み取りパターンと照合します。本物のファイルには一切触れません。",
-                    "fake_box_title": "ブラウザテストでできること",
-                    "fake_box_point1_title": "ファイルベースの書き込み・読み取りテスト",
-                    "fake_box_point1_text": "ブラウザがテストファイルを作成し、速度を計測し、読み戻したデータを比較して正確性を確認します。",
-                    "fake_box_point2_title": "容量の妥当性チェック",
-                    "fake_box_point2_text": "正常に書き込み・検証できたデータ量をもとに、実際の安定利用可能容量を推定できます。",
-                    "fake_box_point3_title": "JSON レポートによる記録",
-                    "fake_box_point3_text": "すべての結果が JSON レポートとしてまとめられ、保存や共有、比較に利用できます。"
-                }
-            }
-        },
-        "login": {
-            "meta": {
-                "title": "{{primary_domain}} – ログイン",
-                "description": "{{primary_domain}} のログインページ"
-            },
-            "sections": {
-                "login": {
-                    "auth_kicker": "アカウントとログイン",
-                    "auth_title": "USBCheck にログイン",
-                    "auth_intro": "ログインすると、テスト結果の保存、レポートのエクスポート、複数デバイスでの Pro モード利用が可能になります。登録は無料で、Pro へのアップグレードは後から選択できます。",
-                    "auth_tab_login": "ログイン",
-                    "auth_tab_register": "登録",
-                    "auth_login_title": "ログイン",
-                    "auth_login_text": "メールアドレスとパスワードを入力してください。",
-                    "auth_login_email_label": "メールアドレス",
-                    "auth_login_password_label": "パスワード",
-                    "auth_login_submit": "ログイン",
-                    "auth_login_forgot": "パスワードを忘れた場合",
-                    "auth_register_title": "無料アカウント登録",
-                    "auth_register_text": "無料アカウントを作成して、テストの保存・レポートのエクスポート・Pro モードの利用ができるようになります。",
-                    "auth_register_name_label": "名前",
-                    "auth_register_email_label": "メールアドレス",
-                    "auth_register_password_label": "パスワード",
-                    "auth_register_submit": "アカウントを作成",
-                    "auth_register_hint": "登録することで、USBCheck のプライバシーポリシーと法的情報に同意したものとみなされます。"
-                }
-            }
-        },
-        "tools": {
-            "meta": {
-                "title": "{{primary_domain}} – ツール",
-                "description": "{{primary_domain}} の補助ツールと機能"
-            }
-        }
-    },
-    "partials": {
-        "structure": {
-            "layout_end": {
-                "logout_modal_title": "ログアウトしますか？",
-                "logout_modal_text": "ログアウトするとセッションが終了し、保存されていない操作は失われる可能性があります。再ログインはいつでも可能です。",
-                "logout_modal_cancel": "キャンセル",
-                "logout_modal_confirm": "ログアウトする"
-            },
-            "header": {
-                "header_slogan": "USB ドライブをテスト",
-                "header_btn_login": "ログイン",
-                "header_menu_dashboard": "ダッシュボード",
-                "header_menu_logout": "ログアウト",
-                "logout_title": "ログアウトしますか？",
-                "logout_text": "USBCheck アカウントからログアウトします。ブラウザ内で動作中のテストには影響しません。",
-                "logout_cancel": "キャンセル",
-                "logout_confirm": "ログアウト"
-            },
-            "footer": {
-                "footer_imprint": "partials.structure.footer.footer_imprint",
-                "footer_privacy": "partials.structure.footer.footer_privacy"
-            }
-        }
-    }
-}

public/assets/i18n/ko.json

@@ -1,236 +0,0 @@
-{
-    "meta": {
-        "code": "ko",
-        "label": "한국어",
-        "flag": "🇰🇷",
-        "enabled": true
-    },
-    "pages": {
-        "landing": {
-            "meta": {
-                "title": "제목 없음"
-            }
-        },
-        "main": {
-            "anchors": {
-                "how": "작동 방식",
-                "problem": "가짜 USB가 위험한 이유",
-                "features": "기능",
-                "security": "보안",
-                "faq": "자주 묻는 질문"
-            },
-            "sections": {
-                "security": {
-                    "security_kicker": "보안 & 개인정보",
-                    "security_title": "프라이버시 우선 설계: 테스트 데이터는 오직 당신의 것입니다.",
-                    "security_intro": "USBCheck은 처음부터 개인정보 보호를 최우선으로 설계되었습니다. 브라우저 빠른 테스트는 테스트용 파일만 사용하며, 사용자의 문서·사진·백업 파일은 읽거나 전송하지 않습니다. Pro 모드에서는 어떤 보고서를 계정과 동기화할지 완전히 직접 선택할 수 있습니다.",
-                    "security_card1_title": "로컬에서만 실행되는 테스트",
-                    "security_card1_text": "모든 읽기/쓰기 테스트는 USB 드라이브에서만 이루어집니다. 브라우저는 테스트 파일 외에는 어떤 개인 파일에도 접근하지 않습니다.",
-                    "security_card2_title": "투명한 보고서 관리",
-                    "security_card2_text": "로그인하면 테스트 보고서를 계정에 저장하거나 내보내거나 삭제할 수 있습니다. 어떤 데이터를 남길지 100% 당신이 결정합니다.",
-                    "security_card3_title": "하드웨어에 부담을 줄인 테스트",
-                    "security_card3_text": "빠른 테스트는 적절한 데이터량을 사용하여 불필요한 마모를 최소화합니다. Pro 모드에서 전체 스캔과 같이 쓰기 부하가 높은 작업을 실행할 경우 명확한 안내를 제공합니다."
-                },
-                "how": {
-                    "how_kicker": "USBCheck 작동 방식",
-                    "how_title": "브라우저 빠른 테스트 + Pro 모드의 심층 분석",
-                    "how_intro": "USBCheck은 두 가지 세계를 결합합니다: 누구나 사용할 수 있는 쉬운 브라우저 빠른 테스트, 그리고 기술 사용자·엔지니어·관리자를 위한 깊은 Pro 모드. 빠른 테스트는 설치 없이 브라우저에서 바로 실행됩니다. Pro 모드는 F3 / badblocks와 유사한 테스트를 수행하는 작은 도구를 통해 용량 속임수를 확실하게 잡아냅니다.",
-                    "how_step1_title": "브라우저 테스트 시작",
-                    "how_step1_text": "아래 링크에서 빠른 테스트를 열어주세요:",
-                    "how_step2_title": "쓰기·읽기·무결성 검사",
-                    "how_step2_text": "브라우저는 테스트 파일을 생성하고 쓰기/읽기 속도를 측정하며, 해시 비교로 데이터 오류를 확인합니다. 모든 과정은 로컬에서 이루어지며, 어떤 파일도 업로드되지 않습니다.",
-                    "how_step3_title": "선택 사항: Pro 모드 전체 스캔",
-                    "how_step3_text": "더 깊은 정보를 원한다면 보조 도구를 설치하세요. 전체 용량을 검사하여 가짜 용량을 판별하고 상세한 보고서를 생성합니다 — IT 부서, 리퍼비셔, 연구실에 최적입니다.",
-                    "how_side_title": "Free vs Pro 한눈에 비교",
-                    "how_side_free": "pages.main.sections.how.how_side_free",
-                    "how_side_pro": "pages.main.sections.how.how_side_pro",
-                    "how_side_account": "pages.main.sections.how.how_side_account"
-                },
-                "hero": {
-                    "hero_kicker": "데이터를 잃기 전에 가짜 USB를 찾아내세요",
-                    "hero_title": "내 USB는 가짜인가요?",
-                    "hero_lead": "USBCheck은 빠른 브라우저 테스트와 전문 Pro 모드를 결합하여, 가짜 USB·허위 표기된 용량·저급 컨트롤러 문제를 파일이 손상되기 전에 발견하도록 도와줍니다.",
-                    "cta_quick": "무료 빠른 테스트 시작",
-                    "cta_learn": "Free & Pro 자세히 보기",
-                    "trust1_title": "빠른 테스트는 설치 불필요",
-                    "trust1_text": "브라우저에서 바로 USB 드라이브를 검사할 수 있습니다.",
-                    "trust2_title": "실제 데이터 기반 테스트",
-                    "trust2_text": "가상의 벤치마크가 아닌 실제 데이터를 사용하여 읽기/쓰기 성능을 측정합니다.",
-                    "trust3_title": "프라이버시 우선",
-                    "trust3_text": "테스트 데이터는 오직 로컬에서만 사용됩니다 — 보고서 동기화 여부는 100% 사용자 선택입니다.",
-                    "quick_label": "빠른 테스트 미리보기",
-                    "quick_title": "2분 안에 USB 드라이브를 테스트하세요",
-                    "badge_free": "무료",
-                    "quick_metric1_label": "쓰기 속도",
-                    "quick_metric1_value": "~ 75–120 MB/s*",
-                    "quick_metric2_label": "무결성 검사량",
-                    "quick_metric2_value": "512 MB 샘플 데이터",
-                    "quick_intro": "빠른 테스트는 USB 드라이브에 지정된 데이터량을 기록하며 다음을 측정합니다:",
-                    "quick_li1": "쓰기 및 읽기 속도",
-                    "quick_li2": "데이터 무결성 (해시 비교)",
-                    "quick_li3": "잠재적 오류 또는 중단",
-                    "quick_visual_title": "빠른 테스트 표시 예시",
-                    "quick_visual_text": "녹색은 안정적인 상태, 주황색은 주의가 필요한 이상징후를 의미합니다.",
-                    "quick_visual_window": "결과 창",
-                    "quick_footnote": "*예시 값이며, 사용 환경·USB·포트에 따라 달라질 수 있습니다.",
-                    "quick_cta": "무료 빠른 테스트로 이동"
-                },
-                "features": {
-                    "features_kicker": "Free & Pro 기능",
-                    "features_title": "무료 빠른 테스트로 시작하고, 더 많은 기능이 필요하면 Pro로 전환하세요.",
-                    "features_intro": "USBCheck은 다양한 사용자 요구를 모두 충족하도록 설계되었습니다. 개인 사용자는 대개 빠른 평가만 필요하지만, 전문가나 팀은 용량 검증·보고서 보관 같은 고급 기능을 필요로 합니다.",
-                    "features_free_title": "무료 빠른 테스트",
-                    "features_free_badge": "대부분의 사용자에게 추천",
-                    "features_free_text": "설치 없이 USB 드라이브의 기본 안정성·속도를 빠르게 확인하고 싶은 사용자에게 이상적입니다.",
-                    "features_free_li1": "• 브라우저 기반 빠른 테스트",
-                    "features_free_li2": "• 실제 데이터로 읽기/쓰기 속도 측정",
-                    "features_free_li3": "• 테스트 데이터의 해시 무결성 검사",
-                    "features_free_li4": "• 여러 테스트 단계 선택 가능 (200 MB, 2 GB 등)",
-                    "features_free_li5": "• 계정 없이 사용 가능",
-                    "features_free_cta": "무료 빠른 테스트 시작",
-                    "features_pro_title": "Pro 모드",
-                    "features_pro_badge": "고급 사용자 & 팀용",
-                    "features_pro_text": "IT팀, 기술자, 리퍼비셔, 연구실 또는 대량 테스트가 필요한 기업을 위한 고급 기능입니다.",
-                    "features_pro_li1": "• 전체 용량 심층 스캔 (F3 / badblocks 유사)",
-                    "features_pro_li2": "• 가짜 용량 및 손상된 영역 감지",
-                    "features_pro_li3": "• 저장 가능한 상세 보고서 (JSON, PDF)",
-                    "features_pro_li4": "• 자동화 테스트를 위한 API 지원 (선택 사항)",
-                    "features_pro_li5": "• 로그인 기반 다중 기기/다중 사용자 지원",
-                    "features_pro_note": "Pro 모드는 작은 보조 도구 설치가 필요합니다. 모든 작업은 로컬에서 수행되며, 계정 동기화 여부는 선택 사항입니다."
-                },
-                "faq": {
-                    "faq_kicker": "FAQ",
-                    "faq_title": "USBCheck 자주 묻는 질문",
-                    "faq_intro": "여기에는 사용자가 자주 묻는 질문들이 정리되어 있습니다. 사용 사례와 피드백에 따라 지속적으로 업데이트됩니다.",
-                    "faq_q1": "빠른 테스트는 정말 브라우저에서만 실행되나요?",
-                    "faq_a1": "네. 빠른 테스트는 100% 브라우저에서 실행되며, U 드라이브에 테스트 파일을 작성하고 읽는 데 최신 브라우저 기술을 사용합니다. 사용자의 파일은 절대 업로드되지 않습니다.",
-                    "faq_q2": "빠른 테스트를 사용하려면 계정이 필요한가요?",
-                    "faq_a2": "아니요. 무료 빠른 테스트는 로그인 없이 사용할 수 있습니다. 보고서 저장 또는 Pro 모드 사용을 원할 때만 계정이 필요합니다.",
-                    "faq_q3": "USBCheck이 모든 가짜 USB를 완벽하게 잡아낼 수 있나요?",
-                    "faq_a3": "어떤 도구도 100% 완벽할 수는 없습니다. 하지만 Pro 모드의 전체 스캔은 일반적인 용량 사기 패턴을 매우 높은 신뢰도로 감지할 수 있습니다.",
-                    "faq_q4": "USBCheck을 내 시스템에 통합할 수 있나요?",
-                    "faq_a4": "가능합니다. USBCheck은 처음부터 자동화·통합을 고려해 설계되었습니다. Pro 모드 확장 기능과 향후 API를 통해 업무 프로세스에 쉽게 연결할 수 있습니다."
-                },
-                "problem": {
-                    "problem_kicker": "가짜 USB가 위험한 이유",
-                    "problem_title": "가짜 USB는 금전적 손해뿐 아니라 중요한 데이터를 잃게 할 수 있습니다.",
-                    "problem_p1": "많은 저가 USB는 비현실적으로 큰 용량을 표시합니다. 실제로는 컨트롤러가 조작되어 시스템에 거짓 용량을 보고하는 경우가 많습니다. 이로 인해 실제 용량을 초과하는 데이터는 조용히 덮어쓰이거나 손상됩니다.",
-                    "problem_p2": "USBCheck은 이러한 위험을 사전에 발견하도록 도와줍니다 — 개인 사용자든 대량 구매자든 모두에게 유용합니다.",
-                    "problem_card1_title": "중요 파일 손실",
-                    "problem_card1_text": "사진, 프로젝트 파일, 백업 등 중요한 데이터가 진짜 용량보다 큰 영역에 기록되면 나중에 복구가 불가능할 수 있습니다.",
-                    "problem_card2_title": "대량 구매 시 비용 증가",
-                    "problem_card2_text": "기업, 판매자, 단체 이벤트 등에서 USB를 대량 배포할 경우, 가짜 제품은 반품·이미지 실추·재제작 비용을 초래합니다.",
-                    "problem_card3_title": "불안정한 성능",
-                    "problem_card3_text": "가짜 USB는 품질이 낮은 컨트롤러와 불안정한 펌웨어를 사용하는 경우가 많아 속도 변동과 데이터 오류 위험이 높습니다."
-                }
-            }
-        },
-        "dashboard": {
-            "meta": {
-                "title": "{{primary_domain}} – 대시보드",
-                "description": "{{primary_domain}}의 USB 테스트·기기·Pro 기능 관리 대시보드"
-            },
-            "sections": {
-                "dashboard": {
-                    "dashboard_kicker": "대시보드",
-                    "dashboard_title": "환영합니다",
-                    "dashboard_intro": "여기에서 USB 테스트 기록을 관리하고 기기를 정리하며, 앞으로 제공될 Pro 기능을 사용할 수 있습니다. 이 영역은 아직 개발 중이지만 전체 구조를 미리 확인할 수 있습니다.",
-                    "dashboard_plan_label": "현재 요금제",
-                    "dashboard_card_tests_title": "최근 테스트",
-                    "dashboard_card_tests_text": "가장 최근의 빠른 테스트와 Pro 스캔 결과가 여기에 표시됩니다 — 상태, 속도, 무결성 정보 포함.",
-                    "dashboard_card_tests_empty": "아직 테스트 데이터가 없습니다. 빠른 테스트 또는 Pro 테스트를 시작해 보세요.",
-                    "dashboard_card_devices_title": "내 USB 기기",
-                    "dashboard_card_devices_text": "추후 여기에 테스트한 USB 기기를 저장하고 관리할 수 있습니다 — 제조사, 모델, 시리얼 번호, 실제 용량 등.",
-                    "dashboard_card_devices_empty": "아직 저장된 기기가 없습니다. 첫 테스트 후 기기를 등록할 수 있습니다.",
-                    "dashboard_card_next_title": "다음 단계",
-                    "dashboard_card_next_text": "USBCheck은 계속 발전하고 있습니다. 초기 사용자로서 향후 Pro 옵션·API·세부 보고서 기능을 가장 먼저 경험하게 됩니다.",
-                    "dashboard_card_next_item1": "• 브라우저 FakeCheck 사용 및 피드백 제공",
-                    "dashboard_card_next_item2": "• Pro 모드 기능 정의 (전체 스캔·보고서·API 등)",
-                    "dashboard_card_next_item3": "• 계정 및 SSO(my-log.in) 통합 완료",
-                    "dashboard_card_next_cta": "FakeCheck로 이동"
-                }
-            }
-        },
-        "fakecheck": {
-            "meta": {
-                "title": "{{primary_domain}} – FakeCheck",
-                "description": "{{primary_domain}}에서 브라우저 기반 FakeCheck로 USB 용량 사기 및 오류를 빠르게 확인하세요."
-            },
-            "sections": {
-                "hero": {
-                    "fake_hero_kicker": "FakeCheck – 브라우저 모드",
-                    "fake_hero_title": "내 USB는 가짜인가요?",
-                    "fake_hero_lead": "FakeCheck은 브라우저에서 테스트 파일을 생성하여 읽기/쓰기 성능과 실제 사용 가능한 용량을 검사해, 설치 없이 빠르게 가짜 USB를 찾도록 도와줍니다.",
-                    "fake_cta_start": "브라우저 테스트 시작 (데모)",
-                    "fake_cta_back_home": "전체 보기로 돌아가기",
-                    "fake_hero_hint": "FakeCheck은 선택한 폴더에 테스트 파일을 생성합니다. 실제 파일은 절대 변경되거나 이동되지 않습니다.",
-                    "fake_box_title": "브라우저 테스트 기능",
-                    "fake_box_point1_title": "파일 기반 쓰기/읽기 테스트",
-                    "fake_box_point1_text": "테스트 파일을 생성하여 쓰기·읽기 속도를 측정하고, 원본 패턴과 일치하는지 확인합니다.",
-                    "fake_box_point2_title": "용량 합리성 확인",
-                    "fake_box_point2_text": "성공적으로 기록·검증된 데이터 양을 통해, 실제 사용 가능한 용량을 명확히 확인할 수 있습니다.",
-                    "fake_box_point3_title": "문서 보관용 JSON 보고서",
-                    "fake_box_point3_text": "모든 결과는 구조화된 JSON 보고서로 저장할 수 있어 비교·보관에 편리합니다."
-                }
-            }
-        },
-        "login": {
-            "meta": {
-                "title": "{{primary_domain}} – 로그인",
-                "description": "{{primary_domain}}에서 USBCheck 계정에 로그인하고 테스트 기록과 Pro 기능을 관리하세요."
-            },
-            "sections": {
-                "login": {
-                    "auth_kicker": "계정 & 로그인",
-                    "auth_title": "USBCheck 로그인",
-                    "auth_intro": "계정을 만들면 테스트를 저장하고 보고서를 내보내며 여러 기기에서 Pro 모드를 사용할 수 있습니다. 등록은 무료이며, Pro 업그레이드는 나중에 선택할 수 있습니다.",
-                    "auth_tab_login": "로그인",
-                    "auth_tab_register": "회원가입",
-                    "auth_login_title": "로그인",
-                    "auth_login_text": "이메일과 비밀번호로 로그인하세요.",
-                    "auth_login_email_label": "이메일",
-                    "auth_login_password_label": "비밀번호",
-                    "auth_login_submit": "로그인",
-                    "auth_login_forgot": "비밀번호를 잊으셨나요?",
-                    "auth_register_title": "무료 회원가입",
-                    "auth_register_text": "무료 계정을 만들면 테스트를 저장하고 보고서를 내보내며, 나중에 Pro 모드를 활성화할 수 있습니다.",
-                    "auth_register_name_label": "이름",
-                    "auth_register_email_label": "이메일",
-                    "auth_register_password_label": "비밀번호",
-                    "auth_register_submit": "계정 만들기",
-                    "auth_register_hint": "가입 시 USBCheck의 개인정보 처리방침 및 이용 약관에 동의하게 됩니다."
-                }
-            }
-        },
-        "tools": {
-            "meta": {
-                "title": "{{primary_domain}} – 도구",
-                "description": "{{primary_domain}}에서 USBCheck 도구를 확인하고 관리하세요."
-            }
-        }
-    },
-    "partials": {
-        "structure": {
-            "layout_end": {
-                "logout_modal_title": "로그아웃하시겠습니까?",
-                "logout_modal_text": "로그아웃하면 세션이 종료되며 저장되지 않은 작업은 사라질 수 있습니다. 언제든 다시 로그인할 수 있습니다.",
-                "logout_modal_cancel": "취소",
-                "logout_modal_confirm": "네, 로그아웃합니다"
-            },
-            "header": {
-                "header_slogan": "USB 드라이브 테스트",
-                "header_btn_login": "로그인",
-                "header_menu_dashboard": "대시보드",
-                "header_menu_logout": "로그아웃",
-                "logout_title": "로그아웃하시겠습니까?",
-                "logout_text": "USBCheck 계정에서 로그아웃합니다. 브라우저에서 실행 중인 테스트는 영향을 받지 않습니다.",
-                "logout_cancel": "취소",
-                "logout_confirm": "로그아웃"
-            },
-            "footer": {
-                "footer_imprint": "partials.structure.footer.footer_imprint",
-                "footer_privacy": "partials.structure.footer.footer_privacy"
-            }
-        }
-    }
-}

public/assets/i18n/nl.json

@@ -1,236 +0,0 @@
-{
-    "meta": {
-        "code": "nl",
-        "label": "Nederlands",
-        "flag": "🇳🇱",
-        "enabled": true
-    },
-    "pages": {
-        "landing": {
-            "meta": {
-                "title": "GEEN TITEL"
-            }
-        },
-        "main": {
-            "anchors": {
-                "how": "Zo werkt het",
-                "problem": "Waarom nepsticks gevaarlijk zijn",
-                "features": "Functies",
-                "security": "Beveiliging",
-                "faq": "FAQ"
-            },
-            "sections": {
-                "security": {
-                    "security_kicker": "Beveiliging & privacy",
-                    "security_title": "Privacy-first ontwerp: jouw testgegevens blijven van jou.",
-                    "security_intro": "USBCheck is vanaf de basis ontworpen met privacy in gedachten. De Quick Check in de browser werkt uitsluitend met testbestanden. Je persoonlijke documenten, foto’s en back-ups worden niet gelezen of verzonden. In de Pro-modus bepaal jij zelf welke rapporten met je account worden gesynchroniseerd.",
-                    "security_card1_title": "Alleen lokale tests",
-                    "security_card1_text": "Alle lees- en schrijftests worden lokaal op je USB-stick uitgevoerd. De browser heeft alleen toegang tot testbestanden – niet tot je privébestanden.",
-                    "security_card2_title": "Transparante rapporten",
-                    "security_card2_text": "Na het inloggen kun je testrapporten opslaan, exporteren of verwijderen. Jij beslist welke gegevens in het systeem blijven.",
-                    "security_card3_title": "Vriendelijk voor je hardware",
-                    "security_card3_text": "De Quick Check gebruikt een gematigde hoeveelheid data om onnodige slijtage te voorkomen. De Pro-modus waarschuwt duidelijk wanneer een volledige scan met hoge schrijflast wordt uitgevoerd."
-                },
-                "how": {
-                    "how_kicker": "Hoe USBCheck werkt",
-                    "how_title": "Snelle test in de browser, Pro-modus voor diepgaande analyse.",
-                    "how_intro": "USBCheck combineert een eenvoudige Quick Check voor iedereen met een uitgebreide Pro-modus voor power users, technici en beheerders. De Quick Check draait direct in de browser, zonder installatie. Voor de Pro-modus wordt een kleine helper-tool gebruikt die F3- / badblocks-achtige tests kan uitvoeren om capaciteitsfraude betrouwbaar te detecteren.",
-                    "how_step1_title": "Start de browsertest",
-                    "how_step1_text": "Je opent de Quick Check via:",
-                    "how_step2_title": "Schrijf-, lees- en integriteitscontrole",
-                    "how_step2_text": "De browser maakt testbestanden aan, meet de schrijfsnelheid en leessnelheid en vergelijkt hashwaarden om fouten te detecteren – volledig lokaal en zonder je eigen bestanden te verzenden.",
-                    "how_step3_title": "Optioneel: Pro-modus voor volledige scan",
-                    "how_step3_text": "Wie meer wil weten, kan de optionele helper-tool installeren. Deze kan de volledige capaciteit testen, fakes identificeren en gedetailleerde rapporten genereren – ideaal voor refurbishers, IT-afdelingen of laboratoria.",
-                    "how_side_title": "Free vs Pro in één oogopslag",
-                    "how_side_free": "pages.main.sections.how.how_side_free",
-                    "how_side_pro": "pages.main.sections.how.how_side_pro",
-                    "how_side_account": "pages.main.sections.how.how_side_account"
-                },
-                "hero": {
-                    "hero_kicker": "Herken nep-USB-sticks vóórdat je data verliest",
-                    "hero_title": "Is mijn USB-stick nep?",
-                    "hero_lead": "USBCheck combineert een snelle browsertest met een professionele Pro-modus. Zo ontdek je vervalste sticks, verminderde werkelijke capaciteit en trage goedkope controllers – nog voordat je bestanden beschadigd raken.",
-                    "cta_quick": "Start gratis Quick Check",
-                    "cta_learn": "Meer over Free & Pro",
-                    "trust1_title": "Geen installatie nodig",
-                    "trust1_text": "Snelle browsertest direct op je USB-stick.",
-                    "trust2_title": "Echte schrijf- en leessnelheden",
-                    "trust2_text": "Testen met echte data — geen theoretische benchmark.",
-                    "trust3_title": "Privacy eerst",
-                    "trust3_text": "Je testgegevens blijven lokaal — rapporten alleen op jouw verzoek.",
-                    "quick_label": "QUICK CHECK VOORBEELD",
-                    "quick_title": "Test een USB-stick in minder dan 2 minuten",
-                    "badge_free": "Gratis",
-                    "quick_metric1_label": "Schrijfsnelheid",
-                    "quick_metric1_value": "~ 75–120 MB/s*",
-                    "quick_metric2_label": "Integriteitscontrole",
-                    "quick_metric2_value": "512 MB sample",
-                    "quick_intro": "De Quick Check test een bepaalde hoeveelheid data op je stick en meet:",
-                    "quick_li1": "Schrijf- en leessnelheid",
-                    "quick_li2": "Dataintegriteit (hash-vergelijking)",
-                    "quick_li3": "Verdachte fouten of onderbrekingen",
-                    "quick_visual_title": "Quick Check indicator",
-                    "quick_visual_text": "Zo ziet de testvoorvertoning eruit: groen betekent stabiel, oranje waarschuwt voor afwijkingen.",
-                    "quick_visual_window": "Resultaatvenster",
-                    "quick_footnote": "*Voorbeeldwaarden — je resultaten hangen af van de stick, poort & systeem.",
-                    "quick_cta": "Ga naar Quick Check"
-                },
-                "features": {
-                    "features_kicker": "Free & Pro functies",
-                    "features_title": "Start met de gratis Quick Check – schakel over naar Pro als je meer nodig hebt.",
-                    "features_intro": "USBCheck groeit mee met jouw behoeften: particuliere gebruikers hebben vaak genoeg aan een snelle beoordeling. Professionals willen diepgaande analyse, capaciteitsverificatie en bewaarrapporten. Daar is de Pro-modus voor bedoeld.",
-                    "features_free_title": "Gratis Quick Check",
-                    "features_free_badge": "Aanbevolen voor de meeste gebruikers",
-                    "features_free_text": "Ideaal voor iedereen die snel wil controleren of een USB-stick redelijk presteert en stabiel werkt — zonder installatie.",
-                    "features_free_li1": "• Browsergebaseerde snelle test direct op je stick",
-                    "features_free_li2": "• Echte schrijfsnelheid en leessnelheid",
-                    "features_free_li3": "• Hash-gebaseerde integriteitscontrole",
-                    "features_free_li4": "• Verschillende testniveaus (bijv. 200 MB, 2 GB)",
-                    "features_free_li5": "• Geen registratie vereist",
-                    "features_free_cta": "Start Quick Check",
-                    "features_pro_title": "Pro-modus",
-                    "features_pro_badge": "Voor power users & teams",
-                    "features_pro_text": "Voor iedereen die volledige controle nodig heeft: IT-afdelingen, technici, refurbishers, laboratoria of bedrijven die grote hoeveelheden sticks testen.",
-                    "features_pro_li1": "• Diepgaande scan van volledige capaciteit (F3/badblocks-achtig)",
-                    "features_pro_li2": "• Detectie van capaciteitfraude en defecte gebieden",
-                    "features_pro_li3": "• Gedetailleerde, exporteerbare testrapporten (JSON, PDF)",
-                    "features_pro_li4": "• Optionele API voor geautomatiseerde testprocessen",
-                    "features_pro_li5": "• Ondersteuning voor meerdere apparaten en gebruikers (via login)",
-                    "features_pro_note": "Pro-modus vereist een kleine helper-tool op je systeem. Deze werkt lokaal en kan indien gewenst met je account synchroniseren."
-                },
-                "faq": {
-                    "faq_kicker": "FAQ",
-                    "faq_title": "Veelgestelde vragen over USBCheck",
-                    "faq_intro": "Hier vind je antwoorden op veelgestelde vragen. De FAQ-sectie wordt uitgebreid naarmate er nieuwe gebruikssituaties en feedback binnenkomen.",
-                    "faq_q1": "Werkt de Quick Check echt volledig in de browser?",
-                    "faq_a1": "Ja. De Quick Check draait volledig in de browser en gebruikt moderne browser-API’s om testbestanden op je stick te schrijven en te lezen. Niets wordt zonder jouw toestemming geüpload.",
-                    "faq_q2": "Heb ik een account nodig voor de Quick Check?",
-                    "faq_a2": "Nee. De gratis Quick Check werkt zonder registratie. Een account is alleen nodig als je rapporten wilt opslaan of de Pro-modus wilt gebruiken.",
-                    "faq_q3": "Kan USBCheck elke nepstick betrouwbaar herkennen?",
-                    "faq_a3": "Geen enkel hulpmiddel kan 100% garantie bieden. Maar de Pro-modus is ontworpen om typische fraudepatronen zoals valse capaciteit of instabiele delen zeer betrouwbaar te detecteren.",
-                    "faq_q4": "Hoe integreert USBCheck in mijn bestaande workflow?",
-                    "faq_a4": "USBCheck is vanaf de basis gebouwd met automatisering in gedachten. De Pro-modus en toekomstige API’s maken integratie in interne processen eenvoudig."
-                },
-                "problem": {
-                    "problem_kicker": "Waarom nep-USB-sticks gevaarlijk zijn",
-                    "problem_title": "Nepsticks kosten geld – en kunnen je belangrijkste gegevens beschadigen.",
-                    "problem_p1": "Veel goedkope USB-sticks adverteren met onrealistische capaciteiten. In werkelijkheid meldt de controller een hogere capaciteit dan fysiek aanwezig is. Dit leidt tot stille gegevensoverschrijving en datacorruptie.",
-                    "problem_p2": "USBCheck helpt je deze risico’s te identificeren voordat je ze echt gebruikt – zowel voor privégebruik als voor zakelijke bulkinkoop.",
-                    "problem_card1_title": "Verlies van belangrijke bestanden",
-                    "problem_card1_text": "Foto’s, projectbestanden, back-ups – alles kan worden beschadigd zodra er buiten de echte capaciteit wordt geschreven.",
-                    "problem_card2_title": "Kosten door defecte batches",
-                    "problem_card2_text": "Bedrijven en resellers verspreiden vaak USB-sticks in grote hoeveelheden. Nepsticks leiden tot klachten, reputatieschade en nieuwe productiekosten.",
-                    "problem_card3_title": "Onstabiele prestaties",
-                    "problem_card3_text": "Trage controllers, instabiele firmware en fluctuerende schrijfsnelheden zijn typisch voor nepsticks en verhogen de kans op fouten."
-                }
-            }
-        },
-        "dashboard": {
-            "meta": {
-                "title": "{{primary_domain}} – Dashboard",
-                "description": "Dashboard op {{primary_domain}}"
-            },
-            "sections": {
-                "dashboard": {
-                    "dashboard_kicker": "Dashboard",
-                    "dashboard_title": "Welkom",
-                    "dashboard_intro": "Hier kun je USB-tests beheren, apparaten organiseren en later de Pro-modus activeren. Deze omgeving wordt nog ontwikkeld, maar geeft je al een eerste overzicht.",
-                    "dashboard_plan_label": "Huidig abonnement",
-                    "dashboard_card_tests_title": "Laatste tests",
-                    "dashboard_card_tests_text": "Hier zie je straks je recente Quick Checks en Pro-scans – inclusief status, snelheid en integriteitscontrole.",
-                    "dashboard_card_tests_empty": "Nog geen testgegevens beschikbaar. Start een eerste test via de browser of de Pro-modus.",
-                    "dashboard_card_devices_title": "Jouw USB-apparaten",
-                    "dashboard_card_devices_text": "In de toekomst kun je hier alle geteste USB-sticks beheren: fabrikant, model, serienummer en gedetecteerde capaciteit.",
-                    "dashboard_card_devices_empty": "Nog geen apparaten opgeslagen. Na je eerste test kun je USB-sticks hier toevoegen.",
-                    "dashboard_card_next_title": "Volgende stappen",
-                    "dashboard_card_next_text": "USBCheck wordt nog verder ontwikkeld. Als vroege gebruiker krijg je straks toegang tot nieuwe Pro-functies, API’s en uitgebreidere rapportages.",
-                    "dashboard_card_next_item1": "• Test de Browser-FakeCheck en geef feedback",
-                    "dashboard_card_next_item2": "• Definieer Pro-functies (volledige scan, rapporten, API)",
-                    "dashboard_card_next_item3": "• Maak accounts & SSO (my-log.in) definitief",
-                    "dashboard_card_next_cta": "Naar Browser-FakeCheck"
-                }
-            }
-        },
-        "fakecheck": {
-            "meta": {
-                "title": "{{primary_domain}} – Fakecheck",
-                "description": "Fakecheck informatie op {{primary_domain}}"
-            },
-            "sections": {
-                "hero": {
-                    "fake_hero_kicker": "FakeCheck – Browsermodus",
-                    "fake_hero_title": "Is mijn USB-stick nep?",
-                    "fake_hero_lead": "FakeCheck helpt je typische nepsticks op te sporen: browsergebaseerde lees-/schrijftests en controles op bruikbare capaciteit – zonder installatie.",
-                    "fake_cta_start": "Start browsertest (Demo)",
-                    "fake_cta_back_home": "Terug naar overzicht",
-                    "fake_hero_hint": "De Browser-FakeCheck werkt met testbestanden die je in een gekozen map aanmaakt. Je echte bestanden blijven onaangeroerd.",
-                    "fake_box_title": "Wat de browsertest kan",
-                    "fake_box_point1_title": "Lees-/schrijftest met testbestanden",
-                    "fake_box_point1_text": "De browser maakt testbestanden aan, meet lees- en schrijfsnelheid en controleert of data correct wordt teruggelezen.",
-                    "fake_box_point2_title": "Controle van bruikbare capaciteit",
-                    "fake_box_point2_text": "De hoeveelheid succesvol geschreven en geverifieerde data geeft een realistisch beeld van de werkelijke bruikbare capaciteit.",
-                    "fake_box_point3_title": "JSON-rapport voor documentatie",
-                    "fake_box_point3_text": "Alle resultaten worden opgeslagen in een gestructureerd JSON-rapport, dat je kunt bewaren of uploaden voor vergelijking."
-                }
-            }
-        },
-        "login": {
-            "meta": {
-                "title": "{{primary_domain}} – Login",
-                "description": "Login informatie op {{primary_domain}}"
-            },
-            "sections": {
-                "login": {
-                    "auth_kicker": "Account & login",
-                    "auth_title": "Log in bij USBCheck",
-                    "auth_intro": "Met een account kun je tests opslaan, rapporten exporteren en de Pro-modus op meerdere apparaten gebruiken. Registratie is gratis – upgraden naar Pro kan later altijd nog.",
-                    "auth_tab_login": "Login",
-                    "auth_tab_register": "Registreren",
-                    "auth_login_title": "Login",
-                    "auth_login_text": "Log in met je e-mailadres en wachtwoord.",
-                    "auth_login_email_label": "E-mailadres",
-                    "auth_login_password_label": "Wachtwoord",
-                    "auth_login_submit": "Inloggen",
-                    "auth_login_forgot": "Wachtwoord vergeten?",
-                    "auth_register_title": "Gratis registreren",
-                    "auth_register_text": "Maak een gratis account aan om tests op te slaan, rapporten te exporteren en later de Pro-modus te activeren.",
-                    "auth_register_name_label": "Naam",
-                    "auth_register_email_label": "E-mailadres",
-                    "auth_register_password_label": "Wachtwoord",
-                    "auth_register_submit": "Account aanmaken",
-                    "auth_register_hint": "Door je te registreren accepteer je het privacybeleid en de juridische informatie van USBCheck."
-                }
-            }
-        },
-        "tools": {
-            "meta": {
-                "title": "{{primary_domain}} – Tools",
-                "description": "Tools informatie op {{primary_domain}}"
-            }
-        }
-    },
-    "partials": {
-        "structure": {
-            "layout_end": {
-                "logout_modal_title": "Weet je zeker dat je wilt uitloggen?",
-                "logout_modal_text": "Wanneer je uitlogt, wordt je sessie beëindigd en kunnen niet-opgeslagen acties verloren gaan. Je kunt altijd opnieuw inloggen.",
-                "logout_modal_cancel": "Annuleren",
-                "logout_modal_confirm": "Ja, uitloggen"
-            },
-            "header": {
-                "header_slogan": "Test USB-sticks",
-                "header_btn_login": "Inloggen",
-                "header_menu_dashboard": "Dashboard",
-                "header_menu_logout": "Uitloggen",
-                "logout_title": "Echt uitloggen?",
-                "logout_text": "Je wordt afgemeld van je USBCheck-account. Lopende browsertests worden hierdoor niet beïnvloed.",
-                "logout_cancel": "Annuleren",
-                "logout_confirm": "Ja, afmelden"
-            },
-            "footer": {
-                "footer_imprint": "partials.structure.footer.footer_imprint",
-                "footer_privacy": "partials.structure.footer.footer_privacy"
-            }
-        }
-    }
-}

public/assets/i18n/pl.json

@@ -1,236 +0,0 @@
-{
-    "meta": {
-        "code": "pl",
-        "label": "Polski",
-        "flag": "🇵🇱",
-        "enabled": true
-    },
-    "pages": {
-        "landing": {
-            "meta": {
-                "title": "BRAK TYTUŁU"
-            }
-        },
-        "main": {
-            "anchors": {
-                "how": "Jak to działa",
-                "problem": "Dlaczego fałszywe pendrive'y są niebezpieczne",
-                "features": "Funkcje",
-                "security": "Bezpieczeństwo",
-                "faq": "FAQ"
-            },
-            "sections": {
-                "security": {
-                    "security_kicker": "Bezpieczeństwo i prywatność",
-                    "security_title": "Projekt oparty na prywatności: Twoje dane testowe należą do Ciebie.",
-                    "security_intro": "USBCheck został zaprojektowany od początku tak, aby chronić Twoje dane. Szybki test w przeglądarce działa wyłącznie na plikach testowych. Twoje dokumenty, zdjęcia czy kopie zapasowe nie są odczytywane ani przesyłane. W trybie Pro masz pełną kontrolę nad tym, które raporty mają być synchronizowane z Twoim kontem.",
-                    "security_card1_title": "Testy tylko lokalnie",
-                    "security_card1_text": "Wszystkie testy zapisu i odczytu są wykonywane lokalnie na Twoim pendrivie. Przeglądarka uzyskuje dostęp jedynie do plików testowych – nigdy do Twoich prywatnych danych.",
-                    "security_card2_title": "Przejrzyste raporty",
-                    "security_card2_text": "Po zalogowaniu możesz zapisywać, eksportować lub usuwać swoje raporty testowe. Ty decydujesz, które dane mają zostać w systemie.",
-                    "security_card3_title": "Oszczędne dla sprzętu",
-                    "security_card3_text": "Szybki test używa umiarkowanych ilości danych, aby uniknąć niepotrzebnego zużycia pamięci. Tryb Pro wyraźnie ostrzega przed pełnym skanem wymagającym intensywnego zapisu."
-                },
-                "how": {
-                    "how_kicker": "Jak działa USBCheck",
-                    "how_title": "Szybki test w przeglądarce, tryb Pro z dogłębną analizą.",
-                    "how_intro": "USBCheck łączy dwie możliwości: prosty szybki test dla każdego oraz zaawansowany tryb Pro dla użytkowników technicznych, serwisantów i administratorów. Szybki test działa bez instalacji, bezpośrednio w przeglądarce. Tryb Pro wykorzystuje małe narzędzie pomocnicze, które może wykonywać testy podobne do F3/badblocks i wykrywać fałszywe pendrive'y.",
-                    "how_step1_title": "Uruchom test w przeglądarce",
-                    "how_step1_text": "Uruchamiasz szybki test na stronie",
-                    "how_step2_title": "Test zapisu, odczytu i integralności",
-                    "how_step2_text": "Przeglądarka tworzy pliki testowe, mierzy prędkość zapisu i odczytu oraz porównuje hashe, aby wykryć błędy danych – wszystko lokalnie, bez przesyłania jakichkolwiek plików.",
-                    "how_step3_title": "Opcjonalnie: tryb Pro dla pełnego skanu",
-                    "how_step3_text": "Jeśli chcesz pełnej analizy, możesz zainstalować narzędzie pomocnicze. Umożliwia ono pełne sprawdzenie pojemności pendrive'a, wykrywanie fałszerstw oraz generowanie szczegółowych raportów — idealne dla działów IT, laboratoriów lub serwisów.",
-                    "how_side_title": "Free vs Pro – szybkie porównanie",
-                    "how_side_free": "pages.main.sections.how.how_side_free",
-                    "how_side_pro": "pages.main.sections.how.how_side_pro",
-                    "how_side_account": "pages.main.sections.how.how_side_account"
-                },
-                "hero": {
-                    "hero_kicker": "Wykryj fałszywe pendrive’y zanim utracisz dane",
-                    "hero_title": "Czy mój pendrive jest fałszywy?",
-                    "hero_lead": "USBCheck łączy szybki test w przeglądarce z profesjonalnym trybem Pro. Dzięki temu wykryjesz fałszywe pendrive’y, zawyżoną pojemność oraz wolne lub wadliwe kontrolery — zanim utracisz dane.",
-                    "cta_quick": "Rozpocznij darmowy szybki test",
-                    "cta_learn": "Dowiedz się więcej o Free & Pro",
-                    "trust1_title": "Bez instalacji",
-                    "trust1_text": "Testy działają bezpośrednio w przeglądarce.",
-                    "trust2_title": "Rzeczywiste testy zapisu i odczytu",
-                    "trust2_text": "Testy z użyciem prawdziwych danych — nie symulacji.",
-                    "trust3_title": "Prywatność przede wszystkim",
-                    "trust3_text": "Twoje dane testowe pozostają lokalnie — raporty tylko na życzenie.",
-                    "quick_label": "PODGLĄD SZYBKIEGO TESTU",
-                    "quick_title": "Przetestuj pendrive’a w mniej niż 2 minuty",
-                    "badge_free": "Darmowe",
-                    "quick_metric1_label": "Wydajność zapisu",
-                    "quick_metric1_value": "~ 75–120 MB/s*",
-                    "quick_metric2_label": "Test integralności",
-                    "quick_metric2_value": "Próbka 512 MB",
-                    "quick_intro": "Szybki test analizuje określoną ilość danych i mierzy:",
-                    "quick_li1": "Prędkość zapisu i odczytu",
-                    "quick_li2": "Integralność danych (porównanie hashów)",
-                    "quick_li3": "Podejrzane błędy lub przerwania",
-                    "quick_visual_title": "Wskaźnik szybkiego testu",
-                    "quick_visual_text": "Podgląd testu: Zielony oznacza stabilny pendrive, pomarańczowy sygnalizuje ostrzeżenia.",
-                    "quick_visual_window": "Okno wyników",
-                    "quick_footnote": "*Przykładowe wartości — wyniki zależą od sprzętu i systemu.",
-                    "quick_cta": "Przejdź do darmowego testu"
-                },
-                "features": {
-                    "features_kicker": "Funkcje Free & Pro",
-                    "features_title": "Rozpocznij od darmowego szybkiego testu — przełącz na Pro, jeśli potrzebujesz więcej.",
-                    "features_intro": "USBCheck dopasowuje się do Twoich potrzeb: użytkownicy domowi często potrzebują szybkiej oceny, a profesjonaliści — głębokiej analizy i archiwizacji raportów.",
-                    "features_free_title": "Darmowy szybki test",
-                    "features_free_badge": "Polecany dla większości użytkowników",
-                    "features_free_text": "Idealny, aby szybko sprawdzić, czy pendrive działa prawidłowo — bez instalacji.",
-                    "features_free_li1": "• Szybki test w przeglądarce",
-                    "features_free_li2": "• Rzeczywiste prędkości zapisu i odczytu",
-                    "features_free_li3": "• Test integralności (hash)",
-                    "features_free_li4": "• Różne poziomy testów (200 MB, 2 GB)",
-                    "features_free_li5": "• Brak konieczności rejestracji",
-                    "features_free_cta": "Rozpocznij darmowy test",
-                    "features_pro_title": "Tryb Pro",
-                    "features_pro_badge": "Dla zaawansowanych użytkowników i zespołów",
-                    "features_pro_text": "Doskonały dla tych, którzy potrzebują pełnej kontroli: IT, serwisy, laboratoria, firmy testujące wiele urządzeń.",
-                    "features_pro_li1": "• Dogłębny skan całej pojemności (podobny do F3/badblocks)",
-                    "features_pro_li2": "• Wykrywanie fałszywej pojemności i uszkodzonych sektorów",
-                    "features_pro_li3": "• Szczegółowe raporty (JSON, PDF)",
-                    "features_pro_li4": "• Opcjonalne API",
-                    "features_pro_li5": "• Obsługa wielu urządzeń i użytkowników",
-                    "features_pro_note": "Tryb Pro wymaga instalacji niewielkiego narzędzia. Działa lokalnie i może łączyć się z Twoim kontem USBCheck."
-                },
-                "faq": {
-                    "faq_kicker": "FAQ",
-                    "faq_title": "Najczęściej zadawane pytania",
-                    "faq_intro": "Tutaj znajdziesz odpowiedzi na najczęstsze pytania. Sekcja FAQ będzie rozszerzana na podstawie opinii użytkowników.",
-                    "faq_q1": "Czy szybki test działa całkowicie w przeglądarce?",
-                    "faq_a1": "Tak. Szybki test działa w 100% w przeglądarce i wykorzystuje nowoczesne API do zapisu i odczytu plików testowych bez przesyłania danych.",
-                    "faq_q2": "Czy muszę mieć konto, aby wykonać szybki test?",
-                    "faq_a2": "Nie. Darmowy szybki test nie wymaga konta. Konto jest potrzebne tylko do zapisywania raportów lub korzystania z trybu Pro.",
-                    "faq_q3": "Czy USBCheck wykryje każdy fałszywy pendrive?",
-                    "faq_a3": "Żadne narzędzie nie daje gwarancji 100%, ale tryb Pro z pełnym skanem bardzo skutecznie wykrywa typowe schematy fałszerstw.",
-                    "faq_q4": "Jak mogę zintegrować narzędzie z moim systemem?",
-                    "faq_a4": "USBCheck jest projektowany z myślą o automatyzacji. Tryb Pro i przyszłe API umożliwią integrację z procesami firmowymi, np. kontrolą jakości."
-                },
-                "problem": {
-                    "problem_kicker": "Dlaczego fałszywe pendrive’y są niebezpieczne",
-                    "problem_title": "Fałszywe pendrive’y kosztują pieniądze — a czasem Twoje dane.",
-                    "problem_p1": "Wiele tanich pendrive’ów podaje nierealnie wysoką pojemność. Kontroler może być zmanipulowany, aby zgłaszać np. 256 GB, mimo że fizycznie dostępne jest tylko 32 GB.",
-                    "problem_p2": "USBCheck pomaga wykryć takie oszustwa, zanim zaczniesz używać pendrive’a — prywatnie lub w firmie.",
-                    "problem_card1_title": "Utrata ważnych plików",
-                    "problem_card1_text": "Zdjęcia, projekty, kopie zapasowe — wszystko może zostać utracone, jeśli rzeczywista pojemność pendrive’a jest mniejsza niż deklarowana.",
-                    "problem_card2_title": "Koszty wadliwych partii",
-                    "problem_card2_text": "Firmy i resellerzy często dystrybuują pendrive’y w dużych ilościach. Fałszywe urządzenia oznaczają reklamacje, straty i problemy wizerunkowe.",
-                    "problem_card3_title": "Niestabilna wydajność",
-                    "problem_card3_text": "Wolne kontrolery, niestabilny firmware i zmienne prędkości zapisu to typowe cechy fałszywych pendrive’ów."
-                }
-            }
-        },
-        "dashboard": {
-            "meta": {
-                "title": "{{primary_domain}} – Panel użytkownika",
-                "description": "Opis panelu użytkownika na {{primary_domain}}"
-            },
-            "sections": {
-                "dashboard": {
-                    "dashboard_kicker": "Panel",
-                    "dashboard_title": "Witaj",
-                    "dashboard_intro": "Tutaj możesz zarządzać testami USB, organizować urządzenia i w przyszłości aktywować tryb Pro. Panel nadal jest w budowie, ale daje już ogólny podgląd.",
-                    "dashboard_plan_label": "Aktualny plan",
-                    "dashboard_card_tests_title": "Ostatnie testy",
-                    "dashboard_card_tests_text": "W tym miejscu pojawią się Twoje ostatnie szybkie testy i skany Pro — wraz ze statusem, prędkością i wynikami integracji.",
-                    "dashboard_card_tests_empty": "Brak testów. Uruchom szybki test lub tryb Pro.",
-                    "dashboard_card_devices_title": "Twoje urządzenia USB",
-                    "dashboard_card_devices_text": "W przyszłości możesz tu zarządzać przetestowanymi urządzeniami: producent, model, numer seryjny, wykryta pojemność.",
-                    "dashboard_card_devices_empty": "Brak zapisanych urządzeń. Po pierwszych testach możesz je tutaj dodać.",
-                    "dashboard_card_next_title": "Następne kroki",
-                    "dashboard_card_next_text": "USBCheck jest nadal rozwijany. Jako jeden z pierwszych użytkowników będziesz mieć tu dostęp do funkcji Pro, raportów i API.",
-                    "dashboard_card_next_item1": "• Przetestuj FakeCheck w przeglądarce",
-                    "dashboard_card_next_item2": "• Zdefiniuj funkcje Pro (skanowanie, raporty, API)",
-                    "dashboard_card_next_item3": "• Ukończ konfigurację kont i SSO (my-log.in)",
-                    "dashboard_card_next_cta": "Przejdź do FakeCheck"
-                }
-            }
-        },
-        "fakecheck": {
-            "meta": {
-                "title": "{{primary_domain}} – Fakecheck",
-                "description": "Opis FakeCheck na {{primary_domain}}"
-            },
-            "sections": {
-                "hero": {
-                    "fake_hero_kicker": "FakeCheck – tryb przeglądarkowy",
-                    "fake_hero_title": "Czy mój pendrive jest fałszywy?",
-                    "fake_hero_lead": "FakeCheck pomaga wykrywać typowe fałszerstwa poprzez testy zapisu/odczytu oraz analizę realnej pojemności — bez instalacji.",
-                    "fake_cta_start": "Uruchom test w przeglądarce (demo)",
-                    "fake_cta_back_home": "Wróć do przeglądu",
-                    "fake_hero_hint": "FakeCheck działa na podstawie plików testowych zapisywanych w wybranym folderze. Twoje prawdziwe pliki pozostają nienaruszone.",
-                    "fake_box_title": "Co potrafi test w przeglądarce",
-                    "fake_box_point1_title": "Test zapisu i odczytu",
-                    "fake_box_point1_text": "Przeglądarka tworzy pliki testowe, mierzy prędkości i sprawdza zgodność danych.",
-                    "fake_box_point2_title": "Sprawdzenie pojemności",
-                    "fake_box_point2_text": "Zweryfikowana ilość zapisanych danych daje realny obraz stabilnej pojemności.",
-                    "fake_box_point3_title": "Raport JSON",
-                    "fake_box_point3_text": "Wyniki są zapisywane w ustrukturyzowanym raporcie JSON, który można eksportować lub archiwizować."
-                }
-            }
-        },
-        "login": {
-            "meta": {
-                "title": "{{primary_domain}} – Logowanie",
-                "description": "Opis logowania na {{primary_domain}}"
-            },
-            "sections": {
-                "login": {
-                    "auth_kicker": "Konto i logowanie",
-                    "auth_title": "Zaloguj się do USBCheck",
-                    "auth_intro": "Za pomocą konta możesz zapisywać testy, eksportować raporty i korzystać z trybu Pro na wielu urządzeniach. Rejestracja jest bezpłatna i możesz później przejść na Pro.",
-                    "auth_tab_login": "Logowanie",
-                    "auth_tab_register": "Rejestracja",
-                    "auth_login_title": "Logowanie",
-                    "auth_login_text": "Zaloguj się za pomocą adresu e-mail i hasła.",
-                    "auth_login_email_label": "Adres e-mail",
-                    "auth_login_password_label": "Hasło",
-                    "auth_login_submit": "Zaloguj się",
-                    "auth_login_forgot": "Zapomniałeś hasła?",
-                    "auth_register_title": "Darmowa rejestracja",
-                    "auth_register_text": "Utwórz darmowe konto, aby zapisywać testy, eksportować raporty i korzystać z trybu Pro.",
-                    "auth_register_name_label": "Imię",
-                    "auth_register_email_label": "Adres e-mail",
-                    "auth_register_password_label": "Hasło",
-                    "auth_register_submit": "Utwórz konto",
-                    "auth_register_hint": "Rejestrując się, akceptujesz politykę prywatności i regulamin USBCheck."
-                }
-            }
-        },
-        "tools": {
-            "meta": {
-                "title": "{{primary_domain}} – Narzędzia",
-                "description": "Opis narzędzi na {{primary_domain}}"
-            }
-        }
-    },
-    "partials": {
-        "structure": {
-            "layout_end": {
-                "logout_modal_title": "Wylogować się?",
-                "logout_modal_text": "Wylogowanie zakończy sesję i utraci niezapisane działania. Możesz zalogować się ponownie w każdej chwili.",
-                "logout_modal_cancel": "Anuluj",
-                "logout_modal_confirm": "Tak, wyloguj"
-            },
-            "header": {
-                "header_slogan": "Testuj pendrive’y",
-                "header_btn_login": "Zaloguj",
-                "header_menu_dashboard": "Panel",
-                "header_menu_logout": "Wyloguj",
-                "logout_title": "Wylogować się?",
-                "logout_text": "Zostaniesz wylogowany ze swojego konta USBCheck. Aktywne testy w przeglądarce nie zostaną przerwane.",
-                "logout_cancel": "Anuluj",
-                "logout_confirm": "Tak, wyloguj"
-            },
-            "footer": {
-                "footer_imprint": "partials.structure.footer.footer_imprint",
-                "footer_privacy": "partials.structure.footer.footer_privacy"
-            }
-        }
-    }
-}

public/assets/i18n/pt.json

@@ -1,236 +0,0 @@
-{
-    "meta": {
-        "code": "pt",
-        "label": "Português",
-        "flag": "🇵🇹",
-        "enabled": true
-    },
-    "pages": {
-        "landing": {
-            "meta": {
-                "title": "SEM TÍTULO"
-            }
-        },
-        "main": {
-            "anchors": {
-                "how": "Como funciona",
-                "problem": "Por que pen drives falsos são perigosos",
-                "features": "Recursos",
-                "security": "Segurança",
-                "faq": "Perguntas frequentes"
-            },
-            "sections": {
-                "security": {
-                    "security_kicker": "Segurança e privacidade",
-                    "security_title": "Design centrado na privacidade: os teus dados pertencem-te.",
-                    "security_intro": "O USBCheck foi concebido desde o início para proteger os teus dados. O teste rápido do navegador utiliza apenas ficheiros de teste. Os teus documentos, imagens ou cópias de segurança não são lidos nem transferidos. No modo Pro tens controlo total sobre se os relatórios são sincronizados com a tua conta — e quais.",
-                    "security_card1_title": "Testes apenas locais",
-                    "security_card1_text": "Todos os testes de escrita e leitura são realizados localmente na tua pen USB. O navegador acede apenas aos ficheiros de teste — nunca aos teus conteúdos privados.",
-                    "security_card2_title": "Relatórios transparentes",
-                    "security_card2_text": "Se iniciares sessão, podes guardar relatórios na tua conta, exportá-los ou apagá-los. Tu decides que dados permanecem no sistema.",
-                    "security_card3_title": "Amigo do teu hardware",
-                    "security_card3_text": "O teste rápido utiliza quantidades moderadas de dados para evitar desgaste desnecessário. O modo Pro avisa claramente quando um teste completo com carga elevada de escrita é iniciado."
-                },
-                "how": {
-                    "how_kicker": "Como funciona o USBCheck",
-                    "how_title": "Teste rápido no navegador, modo Pro com análise profunda.",
-                    "how_intro": "O USBCheck foi criado para unir dois mundos: um teste rápido simples para todos e um modo Pro para utilizadores avançados, técnicos e administradores. O teste rápido funciona diretamente no navegador, sem instalação. O modo Pro utiliza uma pequena ferramenta que pode executar testes semelhantes ao F3 / badblocks para detetar falsificações de capacidade de forma fiável.",
-                    "how_step1_title": "Iniciar teste no navegador",
-                    "how_step1_text": "Abres o teste rápido em",
-                    "how_step2_title": "Teste de escrita, leitura e integridade",
-                    "how_step2_text": "O navegador cria ficheiros de teste, mede velocidades de leitura/escrita e compara valores de hash para detetar erros — tudo localmente, sem transferir os teus ficheiros.",
-                    "how_step3_title": "Opcional: modo Pro para verificação completa",
-                    "how_step3_text": "Para análises mais detalhadas, instalas a ferramenta auxiliar opcional. Ela pode verificar toda a capacidade real, identificar falsificações e gerar relatórios detalhados — ideal para departamentos de TI, laboratórios ou técnicos.",
-                    "how_side_title": "Comparação entre Free e Pro",
-                    "how_side_free": "pages.main.sections.how.how_side_free",
-                    "how_side_pro": "pages.main.sections.how.how_side_pro",
-                    "how_side_account": "pages.main.sections.how.how_side_account"
-                },
-                "hero": {
-                    "hero_kicker": "Deteta USB falsificados antes de perderes dados",
-                    "hero_title": "A minha pen USB é falsa?",
-                    "hero_lead": "O USBCheck combina um teste rápido no navegador com um modo Pro profissional. Assim consegues detetar USB falsificados, capacidade real inferior ao anunciado e controladores lentos — antes de perderes ficheiros.",
-                    "cta_quick": "Iniciar teste rápido gratuito",
-                    "cta_learn": "Saber mais sobre Free & Pro",
-                    "trust1_title": "Sem instalação",
-                    "trust1_text": "Teste baseado no navegador diretamente na pen USB.",
-                    "trust2_title": "Testes reais de leitura e escrita",
-                    "trust2_text": "Testes com dados reais — não teorias sintéticas.",
-                    "trust3_title": "Privacidade em primeiro lugar",
-                    "trust3_text": "Os teus dados de teste permanecem locais — relatórios só se quiseres.",
-                    "quick_label": "PRÉ-VISUALIZAÇÃO DO TESTE RÁPIDO",
-                    "quick_title": "Testa uma pen USB em menos de 2 minutos",
-                    "badge_free": "Grátis",
-                    "quick_metric1_label": "Desempenho de escrita",
-                    "quick_metric1_value": "~ 75–120 MB/s*",
-                    "quick_metric2_label": "Verificações de integridade",
-                    "quick_metric2_value": "Amostra de 512 MB",
-                    "quick_intro": "O teste rápido analisa uma quantidade definida de dados e mede:",
-                    "quick_li1": "Velocidade de leitura e escrita",
-                    "quick_li2": "Integridade dos dados (hash)",
-                    "quick_li3": "Erros ou interrupções suspeitas",
-                    "quick_visual_title": "Indicador de teste rápido",
-                    "quick_visual_text": "Assim aparece a pré-visualização: verde indica estabilidade, laranja sinaliza anomalias.",
-                    "quick_visual_window": "Janela de resultados",
-                    "quick_footnote": "*Valores de exemplo — os teus resultados variam consoante a pen, porta e sistema.",
-                    "quick_cta": "Ir para o teste rápido gratuito"
-                },
-                "features": {
-                    "features_kicker": "Funções Free & Pro",
-                    "features_title": "Começa com o teste rápido gratuito — muda para o modo Pro quando precisares.",
-                    "features_intro": "O USBCheck adapta-se às tuas necessidades: utilizadores privados geralmente querem apenas uma verificação rápida. Profissionais precisam de análises profundas e relatórios arquiváveis.",
-                    "features_free_title": "Teste rápido gratuito",
-                    "features_free_badge": "Recomendado para a maioria",
-                    "features_free_text": "Ideal para verificar rapidamente se uma pen USB funciona de forma estável — sem instalação.",
-                    "features_free_li1": "• Teste rápido no navegador diretamente na pen",
-                    "features_free_li2": "• Velocidades reais de leitura e escrita",
-                    "features_free_li3": "• Teste de integridade baseado em hash",
-                    "features_free_li4": "• Vários níveis de teste (200 MB, 2 GB)",
-                    "features_free_li5": "• Sem necessidade de registo",
-                    "features_free_cta": "Iniciar teste gratuito",
-                    "features_pro_title": "Modo Pro",
-                    "features_pro_badge": "Para utilizadores avançados e equipas",
-                    "features_pro_text": "Perfeito para quem precisa de controlo total: TI, técnicos, laboratórios ou empresas que testam muitas pens USB.",
-                    "features_pro_li1": "• Verificação profunda da capacidade (semelhante a F3 / badblocks)",
-                    "features_pro_li2": "• Deteção de falsificações e sectores danificados",
-                    "features_pro_li3": "• Relatórios detalhados (JSON, PDF)",
-                    "features_pro_li4": "• Acesso API opcional",
-                    "features_pro_li5": "• Suporte multi-dispositivo e multi-utilizador",
-                    "features_pro_note": "O modo Pro requer uma pequena ferramenta instalada localmente. Funciona offline e pode ser ligada à tua conta USBCheck."
-                },
-                "faq": {
-                    "faq_kicker": "FAQ",
-                    "faq_title": "Perguntas frequentes sobre USBCheck",
-                    "faq_intro": "Aqui encontras respostas para as perguntas mais comuns. A secção FAQ será ampliada com novos casos de uso e feedback dos utilizadores.",
-                    "faq_q1": "O teste rápido funciona totalmente no navegador?",
-                    "faq_a1": "Sim. O teste rápido é executado inteiramente no navegador, utilizando APIs modernas que permitem escrever e ler ficheiros de teste sem enviar nada online.",
-                    "faq_q2": "Preciso de uma conta para usar o teste rápido?",
-                    "faq_a2": "Não. O teste gratuito não requer registo. A conta só é necessária para guardar relatórios, gerir várias pens ou usar o modo Pro.",
-                    "faq_q3": "O USBCheck consegue detetar todas as falsificações?",
-                    "faq_a3": "Nenhuma ferramenta pode garantir 100%. No entanto, o modo Pro com verificação completa foi concebido para detetar padrões típicos de falsificação com elevada fiabilidade.",
-                    "faq_q4": "Como integro a ferramenta no meu sistema?",
-                    "faq_a4": "O USBCheck foi pensado para automação. Com o modo Pro e a futura API, podes integrar os testes nos teus fluxos de trabalho, como controlo de qualidade ou inspeções de entrada."
-                },
-                "problem": {
-                    "problem_kicker": "Porque as pens USB falsas são perigosas",
-                    "problem_title": "As pens USB falsificadas custam dinheiro — e podem custar-te os teus dados.",
-                    "problem_p1": "Muitas pens baratas anunciam capacidades irreais. Na realidade, o controlador foi manipulado: pode indicar 256 GB quando só existem 32 GB reais. O resultado: os ficheiros parecem ser copiados corretamente, mas são silenciosamente substituídos ou corrompidos.",
-                    "problem_p2": "O USBCheck ajuda-te a detetar estes falsos antes que prejudiquem o teu trabalho ou empresa.",
-                    "problem_card1_title": "Perda de ficheiros importantes",
-                    "problem_card1_text": "Fotos, projetos, backups — tudo pode ser perdido se a capacidade real for menor do que o declarado.",
-                    "problem_card2_title": "Custos por lotes defeituosos",
-                    "problem_card2_text": "Empresas e distribuidores fornecem grandes quantidades de pens. Falsificações causam reclamações, danos de reputação e custos adicionais.",
-                    "problem_card3_title": "Performance instável",
-                    "problem_card3_text": "Controladores lentos, firmware instável e velocidades inconsistentes são típicos de pens falsificadas, aumentando o risco de erros."
-                }
-            }
-        },
-        "dashboard": {
-            "meta": {
-                "title": "{{primary_domain}} – Dashboard",
-                "description": "Descrição do dashboard em {{primary_domain}}"
-            },
-            "sections": {
-                "dashboard": {
-                    "dashboard_kicker": "Dashboard",
-                    "dashboard_title": "Bem-vindo",
-                    "dashboard_intro": "Aqui podes gerir testes USB, organizar dispositivos e ativar o modo Pro. Ainda está em desenvolvimento, mas já oferece uma boa visão geral.",
-                    "dashboard_plan_label": "Plano atual",
-                    "dashboard_card_tests_title": "Últimos testes",
-                    "dashboard_card_tests_text": "Aqui aparecerão os teus testes rápidos e análises Pro — incluindo estado, velocidade e integridade.",
-                    "dashboard_card_tests_empty": "Ainda sem dados. Inicia um teste no navegador ou no modo Pro.",
-                    "dashboard_card_devices_title": "Os teus dispositivos USB",
-                    "dashboard_card_devices_text": "No futuro poderás gerir aqui dispositivos testados: fabricante, modelo, número de série e capacidade identificada.",
-                    "dashboard_card_devices_empty": "Nenhum dispositivo guardado. Após os primeiros testes poderás adicioná-los aqui.",
-                    "dashboard_card_next_title": "Próximos passos",
-                    "dashboard_card_next_text": "O USBCheck ainda está a ser desenvolvido. És um dos primeiros utilizadores — no futuro encontrarás aqui funções Pro, API e relatórios detalhados.",
-                    "dashboard_card_next_item1": "• Testar FakeCheck e enviar feedback",
-                    "dashboard_card_next_item2": "• Definir funções da versão Pro (scansão completa, API, relatórios)",
-                    "dashboard_card_next_item3": "• Finalizar contas e SSO (my-log.in)",
-                    "dashboard_card_next_cta": "Ir para FakeCheck"
-                }
-            }
-        },
-        "fakecheck": {
-            "meta": {
-                "title": "{{primary_domain}} – FakeCheck",
-                "description": "Descrição do FakeCheck em {{primary_domain}}"
-            },
-            "sections": {
-                "hero": {
-                    "fake_hero_kicker": "FakeCheck – modo navegador",
-                    "fake_hero_title": "A minha pen USB é falsa?",
-                    "fake_hero_lead": "O FakeCheck ajuda-te a detetar falsificações através de testes de leitura/escrita e verificações de capacidade — sem instalação.",
-                    "fake_cta_start": "Iniciar teste do navegador (demo)",
-                    "fake_cta_back_home": "Voltar à vista geral",
-                    "fake_hero_hint": "O FakeCheck cria ficheiros de teste numa pasta escolhida. Os teus ficheiros reais não são tocados.",
-                    "fake_box_title": "O que o teste do navegador pode fazer",
-                    "fake_box_point1_title": "Testes de leitura/escrita",
-                    "fake_box_point1_text": "O navegador cria ficheiros de teste, mede velocidades e verifica os padrões escritos.",
-                    "fake_box_point2_title": "Verificação de capacidade",
-                    "fake_box_point2_text": "A quantidade de dados escritos e validados mostra a capacidade realmente utilizável.",
-                    "fake_box_point3_title": "Relatório JSON",
-                    "fake_box_point3_text": "Todos os resultados são guardados num relatório JSON estruturado que podes exportar ou comparar mais tarde."
-                }
-            }
-        },
-        "login": {
-            "meta": {
-                "title": "{{primary_domain}} – Login",
-                "description": "Descrição do login em {{primary_domain}}"
-            },
-            "sections": {
-                "login": {
-                    "auth_kicker": "Conta & login",
-                    "auth_title": "Inicia sessão no USBCheck",
-                    "auth_intro": "Com uma conta podes guardar testes, exportar relatórios e usar o modo Pro em vários dispositivos. O registo é gratuito — podes atualizar para Pro quando quiseres.",
-                    "auth_tab_login": "Iniciar sessão",
-                    "auth_tab_register": "Registar",
-                    "auth_login_title": "Login",
-                    "auth_login_text": "Inicia sessão com o teu e-mail e palavra-passe.",
-                    "auth_login_email_label": "E-mail",
-                    "auth_login_password_label": "Palavra-passe",
-                    "auth_login_submit": "Entrar",
-                    "auth_login_forgot": "Esqueceste-te da palavra-passe?",
-                    "auth_register_title": "Registo gratuito",
-                    "auth_register_text": "Cria uma conta gratuita para guardar testes, exportar relatórios e ativar o modo Pro.",
-                    "auth_register_name_label": "Nome",
-                    "auth_register_email_label": "E-mail",
-                    "auth_register_password_label": "Palavra-passe",
-                    "auth_register_submit": "Criar conta",
-                    "auth_register_hint": "Ao registares-te aceitas a política de privacidade e o aviso legal da USBCheck."
-                }
-            }
-        },
-        "tools": {
-            "meta": {
-                "title": "{{primary_domain}} – Ferramentas",
-                "description": "Descrição das ferramentas em {{primary_domain}}"
-            }
-        }
-    },
-    "partials": {
-        "structure": {
-            "layout_end": {
-                "logout_modal_title": "Terminar sessão?",
-                "logout_modal_text": "Se terminares sessão, a sessão atual e ações não guardadas serão perdidas. Podes voltar a iniciar sessão a qualquer momento.",
-                "logout_modal_cancel": "Cancelar",
-                "logout_modal_confirm": "Sim, terminar sessão"
-            },
-            "header": {
-                "header_slogan": "Testar USB",
-                "header_btn_login": "Entrar",
-                "header_menu_dashboard": "Dashboard",
-                "header_menu_logout": "Sair",
-                "logout_title": "Terminar sessão?",
-                "logout_text": "Serás desconectado da tua conta USBCheck. Os testes ativos não serão interrompidos.",
-                "logout_cancel": "Cancelar",
-                "logout_confirm": "Sim, sair"
-            },
-            "footer": {
-                "footer_imprint": "partials.structure.footer.footer_imprint",
-                "footer_privacy": "partials.structure.footer.footer_privacy"
-            }
-        }
-    }
-}

public/assets/i18n/ru.json

@@ -1,236 +0,0 @@
-{
-    "meta": {
-        "code": "ru",
-        "label": "Русский",
-        "flag": "🇷🇺",
-        "enabled": true
-    },
-    "pages": {
-        "landing": {
-            "meta": {
-                "title": "Без названия"
-            }
-        },
-        "main": {
-            "anchors": {
-                "how": "Как это работает",
-                "problem": "Почему поддельные флешки опасны",
-                "features": "Возможности",
-                "security": "Безопасность",
-                "faq": "Частые вопросы"
-            },
-            "sections": {
-                "security": {
-                    "security_kicker": "Безопасность и конфиденциальность",
-                    "security_title": "Принцип Privacy-first: данные тестов принадлежат только вам.",
-                    "security_intro": "USBCheck изначально разработан с упором на защиту данных. Быстрый тест в браузере использует только тестовые файлы — ваши документы, фото и резервные копии не читаются и не передаются. В Pro-режиме вы полностью контролируете, какие отчёты сохраняются и синхронизируются с аккаунтом.",
-                    "security_card1_title": "Тесты только локально",
-                    "security_card1_text": "Все операции чтения и записи выполняются исключительно на вашем USB-накопителе. Браузер обращается только к тестовым файлам — личные данные остаются нетронутыми.",
-                    "security_card2_title": "Прозрачные отчёты",
-                    "security_card2_text": "После входа в аккаунт вы можете сохранять отчёты, экспортировать их или удалять. Вы сами решаете, что хранится в системе.",
-                    "security_card3_title": "Бережное отношение к устройству",
-                    "security_card3_text": "Быстрый тест использует умерённый объём данных, чтобы избежать лишнего износа. Pro-режим заранее предупреждает о высокой нагрузке при полном сканировании."
-                },
-                "how": {
-                    "how_kicker": "Как работает USBCheck",
-                    "how_title": "Быстрый тест в браузере и глубокий анализ в Pro-режиме.",
-                    "how_intro": "USBCheck объединяет простой браузерный тест для всех пользователей и расширенный Pro-режим для специалистов, техников и администраторов. Быстрый тест работает без установки. Pro-режим использует небольшое вспомогательное приложение, которое может выполнять тесты, похожие на F3/badblocks, и надёжно выявлять поддельную ёмкость.",
-                    "how_step1_title": "Запуск теста в браузере",
-                    "how_step1_text": "Откройте быстрый тест по адресу:",
-                    "how_step2_title": "Запись, чтение и проверка целостности",
-                    "how_step2_text": "Браузер создаёт тестовые файлы, измеряет скорость чтения и записи и сравнивает хэши для обнаружения ошибок — всё выполняется локально, без передачи ваших данных.",
-                    "how_step3_title": "Дополнительно: полный скан в Pro-режиме",
-                    "how_step3_text": "Установив вспомогательное приложение, вы сможете выполнить полный анализ ёмкости, выявить фальсификации и получить детальные отчёты — идеально для сервисных центров, лабораторий и IT-отделов.",
-                    "how_side_title": "Free vs Pro — в сравнении",
-                    "how_side_free": "pages.main.sections.how.how_side_free",
-                    "how_side_pro": "pages.main.sections.how.how_side_pro",
-                    "how_side_account": "pages.main.sections.how.how_side_account"
-                },
-                "hero": {
-                    "hero_kicker": "Выявляйте поддельные USB до потери данных",
-                    "hero_title": "Мой USB-накопитель — подделка?",
-                    "hero_lead": "USBCheck сочетает быстрый браузерный тест с профессиональным Pro-режимом, что позволяет вовремя обнаружить фальсифицированную ёмкость, медленные контроллеры и нестабильность — прежде чем ваши файлы окажутся повреждены.",
-                    "cta_quick": "Начать бесплатный быстрый тест",
-                    "cta_learn": "Подробнее о Free и Pro",
-                    "trust1_title": "Без установки",
-                    "trust1_text": "Быстрый тест запускается прямо в браузере.",
-                    "trust2_title": "Реальные операции записи и чтения",
-                    "trust2_text": "Тест использует реальные данные — без синтетических результатов.",
-                    "trust3_title": "Конфиденциальность прежде всего",
-                    "trust3_text": "Все тестовые данные обрабатываются локально — отчёты загружаются только по вашему выбору.",
-                    "quick_label": "ПРЕДПРОСМОТР БЫСТРОГО ТЕСТА",
-                    "quick_title": "Проверка USB за 2 минуты",
-                    "badge_free": "Бесплатно",
-                    "quick_metric1_label": "Скорость записи",
-                    "quick_metric1_value": "~ 75–120 МБ/с*",
-                    "quick_metric2_label": "Объём проверки целостности",
-                    "quick_metric2_value": "512 МБ",
-                    "quick_intro": "Быстрый тест анализирует заданный объём данных и измеряет:",
-                    "quick_li1": "скорость записи и чтения",
-                    "quick_li2": "целостность данных (сравнение хэшей)",
-                    "quick_li3": "подозрительные прерывания или ошибки",
-                    "quick_visual_title": "Индикатор результата",
-                    "quick_visual_text": "Зелёный цвет означает стабильность, оранжевый указывает на возможные проблемы.",
-                    "quick_visual_window": "Окно результатов",
-                    "quick_footnote": "*Пример значения — результаты зависят от устройства, порта и системы.",
-                    "quick_cta": "Перейти к бесплатному тесту"
-                },
-                "features": {
-                    "features_kicker": "Функции Free и Pro",
-                    "features_title": "Начните с бесплатного теста — переходите в Pro, когда потребуется больше.",
-                    "features_intro": "USBCheck подстраивается под ваши задачи: большинству пользователей нужна быстрая оценка, а специалисты хотят детальные отчёты, анализ ёмкости и архивирование результатов — всё это доступно в Pro-режиме.",
-                    "features_free_title": "Бесплатный быстрый тест",
-                    "features_free_badge": "Рекомендуется большинству",
-                    "features_free_text": "Подходит для быстрого анализа работоспособности USB-накопителя без установки программ.",
-                    "features_free_li1": "• Быстрый браузерный тест",
-                    "features_free_li2": "• Скорость записи и чтения на реальных данных",
-                    "features_free_li3": "• Проверка целостности по хэшу",
-                    "features_free_li4": "• Несколько уровней тестирования (200 МБ, 2 ГБ)",
-                    "features_free_li5": "• Без регистрации",
-                    "features_free_cta": "Начать бесплатный тест",
-                    "features_pro_title": "Pro-режим",
-                    "features_pro_badge": "Для специалистов и команд",
-                    "features_pro_text": "Для тех, кому нужна максимальная точность: IT-отделы, сервисы, лаборатории и компании, тестирующие большие партии устройств.",
-                    "features_pro_li1": "• Полное сканирование накопителя (как F3/badblocks)",
-                    "features_pro_li2": "• Выявление поддельной ёмкости и повреждённых областей",
-                    "features_pro_li3": "• Детальные отчёты (JSON, PDF)",
-                    "features_pro_li4": "• Дополнительно: API для автоматизации",
-                    "features_pro_li5": "• Поддержка нескольких пользователей и устройств",
-                    "features_pro_note": "Pro-режим требует установки небольшого локального приложения. Оно работает только на устройстве и может по желанию синхронизировать отчёты с вашим аккаунтом."
-                },
-                "faq": {
-                    "faq_kicker": "FAQ",
-                    "faq_title": "Часто задаваемые вопросы",
-                    "faq_intro": "Здесь собраны ответы на наиболее частые вопросы. Раздел будет обновляться по мере появления новых случаев и отзывов.",
-                    "faq_q1": "Правда ли, что быстрый тест полностью работает в браузере?",
-                    "faq_a1": "Да. Быстрый тест полностью выполняется в браузере, создавая тестовые файлы на USB-накопителе через современные браузерные API. Ничего не загружается без вашего согласия.",
-                    "faq_q2": "Нужен ли аккаунт для использования быстрого теста?",
-                    "faq_a2": "Нет. Бесплатный быстрый тест доступен без регистрации. Аккаунт нужен только для сохранения отчётов, работы с несколькими устройствами и использования Pro-режима.",
-                    "faq_q3": "USBCheck гарантированно выявляет поддельные устройства?",
-                    "faq_a3": "Ни один инструмент не даёт 100% гарантии. Но полный скан в Pro-режиме специально разработан для обнаружения типичных схем фальсификации ёмкости и нестабильных участков.",
-                    "faq_q4": "Можно ли интегрировать инструмент в мою систему?",
-                    "faq_a4": "Да. USBCheck изначально создавался с учётом автоматизации. Через Pro-режим и будущий API можно встроить тестирование в рабочие процессы, например в проверки качества."
-                },
-                "problem": {
-                    "problem_kicker": "Почему поддельные USB опасны",
-                    "problem_title": "Поддельные USB-накопители стоят денег — и могут стоить вам данных.",
-                    "problem_p1": "Многие дешёвые USB-накопители рекламируются с завышенной ёмкостью. На самом деле контроллер подделан и сообщает системе, например, 256 ГБ, хотя физически установлено лишь 32 ГБ. При превышении реального объёма данные тихо перезаписываются или повреждаются.",
-                    "problem_p2": "USBCheck помогает выявить такие устройства до их использования — как для личных нужд, так и при проверке крупных партий для бизнеса.",
-                    "problem_card1_title": "Потеря важных данных",
-                    "problem_card1_text": "Фотографии, проекты, резервные копии — всё может быть утеряно, если накопитель не хранит заявленный объём.",
-                    "problem_card2_title": "Убытки от бракованных партий",
-                    "problem_card2_text": "Компании, реселлеры и агентства часто закупают большие партии устройств. Подделки приводят к возвратам, потерям доверия и дополнительным расходам.",
-                    "problem_card3_title": "Нестабильная производительность",
-                    "problem_card3_text": "Медленные контроллеры, нестабильная прошивка и скачки скоростей — типичные признаки поддельных USB-устройств."
-                }
-            }
-        },
-        "dashboard": {
-            "meta": {
-                "title": "{{primary_domain}} – Панель управления",
-                "description": "Описание панели управления на {{primary_domain}}"
-            },
-            "sections": {
-                "dashboard": {
-                    "dashboard_kicker": "Панель управления",
-                    "dashboard_title": "Добро пожаловать",
-                    "dashboard_intro": "Здесь вы сможете управлять тестами, организовывать устройства и позднее активировать Pro-режим. Раздел ещё находится в разработке, но уже даёт общее представление о возможностях.",
-                    "dashboard_plan_label": "Текущий план",
-                    "dashboard_card_tests_title": "Последние тесты",
-                    "dashboard_card_tests_text": "Здесь будут отображаться ваши последние быстрые тесты и Pro-сканы — с состоянием, скоростью и проверками целостности.",
-                    "dashboard_card_tests_empty": "Пока нет тестовых данных. Начните тест в браузере или в Pro-режиме.",
-                    "dashboard_card_devices_title": "Ваши USB-устройства",
-                    "dashboard_card_devices_text": "Позднее здесь можно будет управлять протестированными устройствами: производитель, модель, серийный номер, реальная ёмкость.",
-                    "dashboard_card_devices_empty": "Пока нет сохранённых устройств. После первых тестов вы сможете добавлять их сюда.",
-                    "dashboard_card_next_title": "Следующие шаги",
-                    "dashboard_card_next_text": "USBCheck активно развивается. Как один из первых пользователей, вы будете получать новые функции: Pro-опции, API-доступ и расширенные отчёты.",
-                    "dashboard_card_next_item1": "• Попробовать браузерный FakeCheck и оставить отзыв",
-                    "dashboard_card_next_item2": "• Уточнить функции Pro-режима (полный скан, отчёты, API)",
-                    "dashboard_card_next_item3": "• Завершить настройку аккаунтов и SSO (my-log.in)",
-                    "dashboard_card_next_cta": "Перейти к FakeCheck"
-                }
-            }
-        },
-        "fakecheck": {
-            "meta": {
-                "title": "{{primary_domain}} – FakeCheck",
-                "description": "Описание FakeCheck на {{primary_domain}}"
-            },
-            "sections": {
-                "hero": {
-                    "fake_hero_kicker": "FakeCheck – браузерный режим",
-                    "fake_hero_title": "Мой USB-накопитель поддельный?",
-                    "fake_hero_lead": "FakeCheck помогает выявлять типичные признаки поддельных устройств: тесты записи/чтения в браузере и проверка реальной доступной ёмкости — без установки программ.",
-                    "fake_cta_start": "Запустить браузерный тест (демо)",
-                    "fake_cta_back_home": "Вернуться к обзору",
-                    "fake_hero_hint": "FakeCheck использует тестовые файлы и шаблоны чтения/записи в выбранной папке. Ваши личные файлы не затрагиваются.",
-                    "fake_box_title": "Что умеет браузерный тест",
-                    "fake_box_point1_title": "Тест записи и чтения",
-                    "fake_box_point1_text": "Создаёт тестовые файлы, измеряет скорость, проверяет соответствие данных исходному шаблону.",
-                    "fake_box_point2_title": "Проверка ёмкости",
-                    "fake_box_point2_text": "На основе успешно записанных и проверенных данных можно понять, какая ёмкость реально доступна.",
-                    "fake_box_point3_title": "JSON-отчёт",
-                    "fake_box_point3_text": "Все результаты собираются в структурированный JSON-отчёт, который можно сохранить или загрузить."
-                }
-            }
-        },
-        "login": {
-            "meta": {
-                "title": "{{primary_domain}} – Вход",
-                "description": "Описание страницы входа на {{primary_domain}}"
-            },
-            "sections": {
-                "login": {
-                    "auth_kicker": "Аккаунт и вход",
-                    "auth_title": "Войти в USBCheck",
-                    "auth_intro": "Создав аккаунт, вы сможете сохранять тесты, экспортировать отчёты и использовать Pro-режим на нескольких устройствах. Регистрация бесплатная, обновление до Pro — по желанию.",
-                    "auth_tab_login": "Вход",
-                    "auth_tab_register": "Регистрация",
-                    "auth_login_title": "Вход",
-                    "auth_login_text": "Введите ваш e-mail и пароль.",
-                    "auth_login_email_label": "E-mail",
-                    "auth_login_password_label": "Пароль",
-                    "auth_login_submit": "Войти",
-                    "auth_login_forgot": "Забыли пароль?",
-                    "auth_register_title": "Бесплатная регистрация",
-                    "auth_register_text": "Создайте бесплатный аккаунт, чтобы сохранять тесты, экспортировать отчёты и позднее активировать Pro-режим.",
-                    "auth_register_name_label": "Имя",
-                    "auth_register_email_label": "E-mail",
-                    "auth_register_password_label": "Пароль",
-                    "auth_register_submit": "Создать аккаунт",
-                    "auth_register_hint": "Регистрируясь, вы принимаете политику конфиденциальности и юридическую информацию USBCheck."
-                }
-            }
-        },
-        "tools": {
-            "meta": {
-                "title": "{{primary_domain}} – Инструменты",
-                "description": "Описание инструментов на {{primary_domain}}"
-            }
-        }
-    },
-    "partials": {
-        "structure": {
-            "layout_end": {
-                "logout_modal_title": "Выйти из аккаунта?",
-                "logout_modal_text": "После выхода ваша сессия завершится, несохранённые изменения будут потеряны. Вы можете войти снова в любой момент.",
-                "logout_modal_cancel": "Отмена",
-                "logout_modal_confirm": "Да, выйти"
-            },
-            "header": {
-                "header_slogan": "Тестирование USB-накопителей",
-                "header_btn_login": "Войти",
-                "header_menu_dashboard": "Панель управления",
-                "header_menu_logout": "Выйти",
-                "logout_title": "Выйти из аккаунта?",
-                "logout_text": "Вы выходите из аккаунта USBCheck. Тесты, выполняемые в браузере, продолжат работать.",
-                "logout_cancel": "Отмена",
-                "logout_confirm": "Выйти"
-            },
-            "footer": {
-                "footer_imprint": "partials.structure.footer.footer_imprint",
-                "footer_privacy": "partials.structure.footer.footer_privacy"
-            }
-        }
-    }
-}

public/assets/i18n/san.json

@@ -1,236 +0,0 @@
-{
-    "meta": {
-        "code": "san",
-        "label": "संस्कृतम्",
-        "flag": "🇮🇳",
-        "enabled": true
-    },
-    "pages": {
-        "landing": {
-            "meta": {
-                "title": "शीर्षकः नास्ति"
-            }
-        },
-        "main": {
-            "anchors": {
-                "how": "कथं कार्यं करोति",
-                "problem": "कुतः मिथ्या USB-यन्त्राणि घातकानि",
-                "features": "विशेषताः",
-                "security": "सुरक्षा",
-                "faq": "प्रायः पृष्टाः प्रश्नाः"
-            },
-            "sections": {
-                "security": {
-                    "security_kicker": "सुरक्षा तथा गोपनीयता",
-                    "security_title": "गोपनीयतामुख्य-रचना — परीक्षणदत्तानि केवलं तव एव।",
-                    "security_intro": "USBCheck नामकं उपकरणं आरम्भात् एव गोपनीयताम् अवलम्ब्य निर्मितम्। ब्राउज़र-शीघ्रपरीक्षा केवलं परीक्षणसञ्चिकाभिः एव कार्यं करोति। तव निजी-दस्तावेजाः, चित्राणि, सङ्ग्रहतः इत्यादयः न पठ्यन्ते, न च प्रेष्यन्ते। Pro-मोदः उपयुज्य त्वमेव निर्णोति — काः रिपोर्टः तव खातेन सह संयोजनीयाः स्युः।",
-                    "security_card1_title": "स्थानीय-परीक्षा एव",
-                    "security_card1_text": "सर्वे लेखन-पठन-परीक्षणाः तव USB-यन्त्रे एव स्थानीयरूपेण क्रियन्ते। ब्राउज़रः केवलम् परीक्षणसञ्चिकाः पश्यति, न तु तव निजदत्तानि।",
-                    "security_card2_title": "पारदर्शिक-रिपोर्ट्स्",
-                    "security_card2_text": "प्रवेशं कृत्वा त्वं रिपोर्टः संग्रहीतुं, निर्यातयितुं, अपि वा लोपयितुं शक्नोषि। काः दत्ताः प्रणालीषु स्थापनियाः — एतत् त्वमेव निर्णोति।",
-                    "security_card3_title": "यन्त्र-मैत्री-परिक्षणम्",
-                    "security_card3_text": "शीघ्रपरीक्षा मध्यम-दत्तमात्रां प्रयुङ्क्ते, येन अनावश्यक-क्षयो न भविष्यति। Pro-मोदः चेतयति, यदि पूर्ण-स्कैन् आरभ्यते।"
-                },
-                "how": {
-                    "how_kicker": "USBCheck कथं कार्यं करोति",
-                    "how_title": "ब्राउज़र-शीघ्रपरीक्षा, Pro-मोदेन सह गम्भीरविश्लेषणम्।",
-                    "how_intro": "USBCheck इदं साधारण-शीघ्रपरीक्षां च गम्भीर Pro-मोडं च संयोजयति। शीघ्रपरीक्षा स्थापनेन विहीना — ब्राउज़रे एव प्रवर्तते। Pro-मोडः लघु-उपकरणस्य साहाय्येन F3/badblocks-सदृशं परीक्षणं करोति, येन मिथ्या-क्षमतायुक्ताः दत्तांशयुक्त-यन्त्राणि अधिगम्यन्ते।",
-                    "how_step1_title": "ब्राउज़र-परीक्षा आरभत",
-                    "how_step1_text": "त्वं शीघ्रपरीक्षां अत्र उद्घाटयसि —",
-                    "how_step2_title": "लेखन-पठन-अखण्डता-परीक्षणम्",
-                    "how_step2_text": "ब्राउज़रः परीक्षणसञ्चिकाः निर्माति, लेखन-पठन-गति-मापनं करोति, तथा च hash-मूल्य-तुलनया दोषान् अन्वेषयति — सर्वं स्थानीयरूपेण।",
-                    "how_step3_title": "वैकल्पिकम् — Pro-मोडस्य पूर्ण-स्कैन्",
-                    "how_step3_text": "यदि त्वं अधिकं ज्ञातुम् इच्छसि, हेल्पर-टूल् स्थापनीयम्। तत् सर्वां क्षमतां परीक्षणं कर्तुं शक्नोति, मिथ्यायन्त्राणि ज्ञातुं, विस्तृताः रिपोर्टः च निर्माणयितुम्।",
-                    "how_side_title": "Free विरुद्ध Pro — संक्षिप्तदर्शनम्",
-                    "how_side_free": "pages.main.sections.how.how_side_free",
-                    "how_side_pro": "pages.main.sections.how.how_side_pro",
-                    "how_side_account": "pages.main.sections.how.how_side_account"
-                },
-                "hero": {
-                    "hero_kicker": "दत्तहानिं पूर्वमेव नकली-USB ज्ञातव्याः",
-                    "hero_title": "किं मम USB नकली अस्ति?",
-                    "hero_lead": "USBCheck शीघ्र-परिक्षणं च Pro-मोडं च संयोजयति। एवं त्वं नकली-USB-दत्तयन्त्राणि, अल्प-यथार्थ-क्षमतां, मन्दगमन-कंट्रोलरान् च पूर्वमेव ज्ञातुं शक्नोषि।",
-                    "cta_quick": "मुफ्त-शीघ्रपरीक्षा आरभत",
-                    "cta_learn": "Free तथा Pro विषये अधिकं पठतु",
-                    "trust1_title": "स्थापना न आवश्यकाः",
-                    "trust1_text": "ब्राउज़राधारित-परीक्षा तव यन्त्रे एव प्रवर्तते।",
-                    "trust2_title": "यथार्थ-लेखन-पठन-परीक्षणम्",
-                    "trust2_text": "परीक्षा वास्तविक-दत्तयोः कृते — न तु काल्पनिकम्।",
-                    "trust3_title": "गोपनीयतापूर्वम्",
-                    "trust3_text": "तव परीक्षणदत्तानि स्थानीयमेव भवन्ति — रिपोर्टः केवलं इच्छया।",
-                    "quick_label": "शीघ्रपरीक्षायाः पूर्वावलोकनम्",
-                    "quick_title": "USB-दत्तयन्त्रं द्वयोः निमेषयोः अन्तः परीक्ष्यताम्",
-                    "badge_free": "मुक्तम्",
-                    "quick_metric1_label": "लेखन-क्षमता",
-                    "quick_metric1_value": "~ ७५–१२० MB/s*",
-                    "quick_metric2_label": "अखण्डता-परीक्षा",
-                    "quick_metric2_value": "५१२ MB नमूना",
-                    "quick_intro": "शीघ्रपरीक्षा निम्नलिखितानि मापयति —",
-                    "quick_li1": "लेखन-पठन-गति",
-                    "quick_li2": "दत्त-अखण्डता (hash-तुलना)",
-                    "quick_li3": "सन्दिग्धदोषाः वा विच्छेदाः",
-                    "quick_visual_title": "शीघ्रपरीक्षा-सूचकम्",
-                    "quick_visual_text": "हरितवर्णः स्थिरतां द्योतयति, नारङ्गवर्णः चेतां ददाति।",
-                    "quick_visual_window": "परिणाम-विन्दु",
-                    "quick_footnote": "*उदाहरणमात्रम् — परिणामाः यन्त्रे, पोर्टे, प्रणाली च आधीयन्ते।",
-                    "quick_cta": "मुक्त-शीघ्रपरीक्षां प्रति गच्छतु"
-                },
-                "features": {
-                    "features_kicker": "Free तथा Pro विशेषताः",
-                    "features_title": "मुक्त-शीघ्रपरीक्षया आरभत — आवश्यके Pro-मोडं स्वीकुरुत।",
-                    "features_intro": "USBCheck तव आवश्यकतानुसारं विकसितः। सामान्य-उपयोक्तारः द्रुतमूल्यांकनं इच्छन्ति, किन्तु विशेषज्ञाः गहनविश्लेषणं रिपोर्ट्स् च अपेक्षन्ते।",
-                    "features_free_title": "मुक्त-शीघ्रपरीक्षा",
-                    "features_free_badge": "बहुभ्यः उपयोक्तृभ्यः उपयुक्तम्",
-                    "features_free_text": "स्थापनेन विहीना द्रुतं परीक्षणम् — स्थिरता, गति इत्यादीनां मूल्यम् अवगन्तुं।",
-                    "features_free_li1": "• ब्राउज़र-आधारित शीघ्रपरीक्षा",
-                    "features_free_li2": "• वास्तविक लेखन-पठन-गति",
-                    "features_free_li3": "• hash-आधारित अखण्डता-परीक्षा",
-                    "features_free_li4": "• विषम-स्तराः (२०० MB, २ GB)",
-                    "features_free_li5": "• पंजीकरणम् अनावश्यकम्",
-                    "features_free_cta": "मुक्त-परीक्षां आरभत",
-                    "features_pro_title": "Pro-मोडः",
-                    "features_pro_badge": "विशेषज्ञानां टीमानां च कृते",
-                    "features_pro_text": "IT-विभागाः, तकनीक-विशेषज्ञाः, प्रयोगशालाः, पुनर्निर्माण-कर्तारः च यत्र विस्तृत-परीक्षणम् आवश्यकम्।",
-                    "features_pro_li1": "• सम्पूर्ण-ड्राइव-स्कैन् (F3/badblocks-सम)",
-                    "features_pro_li2": "• मिथ्या-क्षमतायाः, दोषयुक्त-भागानां च अन्वेषणम्",
-                    "features_pro_li3": "• विस्तृताः रिपोर्ट्स् (JSON, PDF)",
-                    "features_pro_li4": "• विकल्परूपेण API-सम्बन्धः",
-                    "features_pro_li5": "• बहु-उपकरण-बहु-उपयोक्ता समर्थनम्",
-                    "features_pro_note": "स्थानीय-उपकरणम् स्थापनीयम्, Pro-मोडस्य कृते — तत् तव USBCheck-खातेन संयोजनीयम्।"
-                },
-                "faq": {
-                    "faq_kicker": "प्रश्नाः",
-                    "faq_title": "USBCheck विषये सामान्यप्रश्नाः",
-                    "faq_intro": "सामान्यप्रश्नानां उत्तराणि अत्र उपलब्धानि। आवश्यकतानुसारं खण्डः विस्तार्यते।",
-                    "faq_q1": "किं शीघ्रपरीक्षा पूर्णतया ब्राउज़रे कार्यं करोति?",
-                    "faq_a1": "आम्, शीघ्रपरीक्षा १००% ब्राउज़रे एव प्रवर्तते, परीक्षणसञ्चिकानाम् स्थानीयलेखन-पठनस्य अनुमतिं ददाति।",
-                    "faq_q2": "किं परीक्षणाय खाते आवश्यकं?",
-                    "faq_a2": "नहि। मुक्त-शीघ्रपरीक्षा खातं विना उपलब्धा। रिपोर्ट्-सेव-करणाय एव खाता आवश्यकः।",
-                    "faq_q3": "किं USBCheck सर्वाणि नकली-यन्त्राणि ज्ञातुं शक्नोति?",
-                    "faq_a3": "शतप्रतिशत-गारण्टी न, किन्तु Pro-मोडः विशिष्ट-नकली-पद्धतीः अत्युत्तमं ज्ञातुं शक्नोति।",
-                    "faq_q4": "कथं उपकरणं मम प्रणालीयुतं भविष्यति?",
-                    "faq_a4": "USBCheck स्वयंचालनं प्रति निर्मितम्। Pro-मोडः व आगामी API तव कार्यप्रवाहेषु संयोजनम् सरलम् करिष्यतः।"
-                },
-                "problem": {
-                    "problem_kicker": "नकली USB-यन्त्राणां हानिः",
-                    "problem_title": "नकली USB यन्त्रं धनं — अपि च दत्तहानिं — जनयति।",
-                    "problem_p1": "अनेकानि सस्तानि USB-यन्त्राणि मिथ्याक्तं क्षमतां दर्शयन्ति। नियंत्रकाः कृत्रिमरूपेण २५६ GB इति दर्शयन्ति, यथा केवलं ३२ GB अस्ति।",
-                    "problem_p2": "USBCheck इदं पूर्वमेव ज्ञापयति — यत् त्वं यन्त्रं उपयोजयेत् — गृहं वा कार्यालयं वा।",
-                    "problem_card1_title": "महत्त्वपूर्णदत्तहानिः",
-                    "problem_card1_text": "चित्राणि, प्रकल्पाः, सङ्ग्रहाः — सर्वं विनष्टं भवेत् यदि यन्त्रस्य वास्तविक-क्षमता न्यूनास्ति।",
-                    "problem_card2_title": "दोषयुक्त-समूहानां मूल्यः",
-                    "problem_card2_text": "कम्पन्यः बहूनि यन्त्राणि वितरन्ति। नकली-दत्तयन्त्रं तेषां प्रतिकूलं मूल्यं, क्षतिः, छविनाशं च जनयति।",
-                    "problem_card3_title": "अस्थिर-प्रदर्शनम्",
-                    "problem_card3_text": "मन्दगति-नियन्त्रकाः, दोषयुक्त-फर्मवेयरः, अस्थिर-गति — नकली-यन्त्रस्य सामान्यलक्षणानि।"
-                }
-            }
-        },
-        "dashboard": {
-            "meta": {
-                "title": "{{primary_domain}} – डैशबोर्ड्",
-                "description": "{{primary_domain}} इत्यत्र डैशबोर्ड् विवरणम्"
-            },
-            "sections": {
-                "dashboard": {
-                    "dashboard_kicker": "डैशबोर्ड्",
-                    "dashboard_title": "स्वागतम्",
-                    "dashboard_intro": "अत्र त्वं USB-परीक्षणानि व्यवस्थापयितुं शक्नोषि, उपकरणानि विन्यस्य, तथा च Pro-मोडं परं सक्रियं कर्तुं शक्नोषि।",
-                    "dashboard_plan_label": "वर्तमान-योजना",
-                    "dashboard_card_tests_title": "अद्यतन-परीक्षणानि",
-                    "dashboard_card_tests_text": "अत्र भवतः अद्यतन-शीघ्रपरीक्षा तथा Pro-स्कैन् दर्शनं प्राप्तम्।",
-                    "dashboard_card_tests_empty": "अद्य पर्यन्तं परीक्षणं न कृतम्।",
-                    "dashboard_card_devices_title": "भवतः USB-उपकरणानि",
-                    "dashboard_card_devices_text": "परीक्षणानन्तरं उपकरणानि अत्र स्थापयितुं शक्यन्ते।",
-                    "dashboard_card_devices_empty": "अद्य पर्यन्तं उपकरणं न लब्धम्।",
-                    "dashboard_card_next_title": "परम् पथः",
-                    "dashboard_card_next_text": "USBCheck विकासे अस्ति — परं Pro विकल्पाः, API, विस्तृत-रिपोर्टः च अत्र भविष्यति।",
-                    "dashboard_card_next_item1": "• FakeCheck ब्राउज़र-परिक्षणम् परीक्ष्यताम्",
-                    "dashboard_card_next_item2": "• Pro-विशेषताः निर्दिशताम्",
-                    "dashboard_card_next_item3": "• खाताः तथा SSO (my-log.in) पूर्णं कुरुत",
-                    "dashboard_card_next_cta": "FakeCheck प्रति गच्छतु"
-                }
-            }
-        },
-        "fakecheck": {
-            "meta": {
-                "title": "{{primary_domain}} – FakeCheck",
-                "description": "{{primary_domain}} इत्यत्र FakeCheck विवरणम्"
-            },
-            "sections": {
-                "hero": {
-                    "fake_hero_kicker": "FakeCheck – ब्राउज़र मोडः",
-                    "fake_hero_title": "किं मम USB यन्त्रं मिथ्यकं अस्ति?",
-                    "fake_hero_lead": "FakeCheck लिखन-पठन-परीक्षा तथा क्षमतापरीक्षणद्वारा नकली-यन्त्रं ज्ञापयति — स्थापनेन विना।",
-                    "fake_cta_start": "ब्राउज़र-परीक्षा आरभत (डेमो)",
-                    "fake_cta_back_home": "समग्रदृश्यं प्रति गच्छतु",
-                    "fake_hero_hint": "FakeCheck परीक्षणसञ्चिकाः निर्दिष्टे फोल्डरे स्थापयति — तव वास्तविकसञ्चिकाः न स्पृशन्ति।",
-                    "fake_box_title": "ब्राउज़र-परीक्षयाः शक्तयः",
-                    "fake_box_point1_title": "लेखन-पठन-परीक्षा",
-                    "fake_box_point1_text": "गति माप्यते, दत्त-पैटर्न् परीक्ष्यते।",
-                    "fake_box_point2_title": "क्षमता-परीक्षणम्",
-                    "fake_box_point2_text": "सत्यापित-दत्तमात्रा स्थिर-यथार्थ-क्षमतां दर्शयति।",
-                    "fake_box_point3_title": "JSON रिपोर्ट्",
-                    "fake_box_point3_text": "सर्वे परिणामाः एकस्मिन् JSON-रिपोर्ट् संहत्य स्थाप्यन्ते।"
-                }
-            }
-        },
-        "login": {
-            "meta": {
-                "title": "{{primary_domain}} – Login",
-                "description": "{{primary_domain}} इत्यत्र Login विवरणम्"
-            },
-            "sections": {
-                "login": {
-                    "auth_kicker": "खातं तथा प्रवेशः",
-                    "auth_title": "USBCheck मध्ये प्रवेशं कुरु",
-                    "auth_intro": "खातं निर्माय त्वं परीक्षणानि संग्रहीतुं, रिपोर्ट् निर्यातयितुं, Pro-मोडस्य उपयोगं बहुषु उपकरणेषु कर्तुं शक्नोषि।",
-                    "auth_tab_login": "प्रवेशः",
-                    "auth_tab_register": "पंजीकरणम्",
-                    "auth_login_title": "प्रवेशः",
-                    "auth_login_text": "स्वीयं ईमेलं, गुप्तशब्दं च लिखतु।",
-                    "auth_login_email_label": "ईमेल्",
-                    "auth_login_password_label": "गुप्तशब्दः",
-                    "auth_login_submit": "प्रवेशं कुरुत",
-                    "auth_login_forgot": "गुप्तशब्दः विस्मृतः?",
-                    "auth_register_title": "मुक्त-पंजीकरणम्",
-                    "auth_register_text": "खातं निर्माय परीक्षणानि संग्रहीतुं, रिपोर्ट् निर्यातयितुं, परं Pro-मोडं सक्रियं कर्तुं शक्नोषि।",
-                    "auth_register_name_label": "नाम",
-                    "auth_register_email_label": "ईमेल्",
-                    "auth_register_password_label": "गुप्तशब्दः",
-                    "auth_register_submit": "खातं निर्मीयताम्",
-                    "auth_register_hint": "पंजीकरणेन त्वं गोपनीयतानियमं च विधिम् अपि स्वीकुरुषे।"
-                }
-            }
-        },
-        "tools": {
-            "meta": {
-                "title": "{{primary_domain}} – साधनानि",
-                "description": "{{primary_domain}} इत्यत्र साधन-विवरणम्"
-            }
-        }
-    },
-    "partials": {
-        "structure": {
-            "layout_end": {
-                "logout_modal_title": "निष्क्रमणम्?",
-                "logout_modal_text": "निष्क्रमणेन तव सत्रं समाप्तं भविष्यति, असंगृहीतक्रियाश्च नश्यन्ति।",
-                "logout_modal_cancel": "निरस्तम्",
-                "logout_modal_confirm": "आम्, निष्क्रमणम्"
-            },
-            "header": {
-                "header_slogan": "USB यन्त्राणि परीक्ष्यताम्",
-                "header_btn_login": "प्रवेशः",
-                "header_menu_dashboard": "डैशबोर्ड्",
-                "header_menu_logout": "निष्क्रमणम्",
-                "logout_title": "निष्क्रमणम्?",
-                "logout_text": "त्वं स्वस्य USBCheck-खातात् निष्क्रमसि। सक्रियम् ब्राउज़र-परीक्षणं न बाध्यते।",
-                "logout_cancel": "निरस्तम्",
-                "logout_confirm": "आम्, निष्क्रमणम्"
-            },
-            "footer": {
-                "footer_imprint": "partials.structure.footer.footer_imprint",
-                "footer_privacy": "partials.structure.footer.footer_privacy"
-            }
-        }
-    }
-}

public/assets/i18n/sv.json

@@ -1,236 +0,0 @@
-{
-    "meta": {
-        "code": "sv",
-        "label": "Svenska",
-        "flag": "🇸🇪",
-        "enabled": true
-    },
-    "pages": {
-        "landing": {
-            "meta": {
-                "title": "INGEN TITEL"
-            }
-        },
-        "main": {
-            "anchors": {
-                "how": "Så fungerar det",
-                "problem": "Varför falska USB-minnen är farliga",
-                "features": "Funktioner",
-                "security": "Säkerhet",
-                "faq": "FAQ"
-            },
-            "sections": {
-                "security": {
-                    "security_kicker": "Säkerhet och integritet",
-                    "security_title": "Privacy-first-design: Dina testdata tillhör dig.",
-                    "security_intro": "USBCheck är från början utformat för att skydda dina data. Snabbtestet i webbläsaren arbetar enbart med testfiler. Dina egna dokument, bilder eller säkerhetskopior läses eller överförs aldrig. I Pro-läge har du full kontroll över vilka rapporter som ska synkroniseras med ditt konto.",
-                    "security_card1_title": "Endast lokala tester",
-                    "security_card1_text": "Alla skriv- och lästester utförs lokalt på ditt USB-minne. Webbläsaren får endast åtkomst till testfiler – inte till ditt privata innehåll.",
-                    "security_card2_title": "Transparenta rapporter",
-                    "security_card2_text": "När du loggar in kan du spara, exportera och radera dina testrapporter. Du bestämmer vilka data som ska finnas kvar i systemet.",
-                    "security_card3_title": "Skonsamt för hårdvaran",
-                    "security_card3_text": "Snabbtestet använder måttliga datamängder för att undvika onödigt slitage. Pro-läget varnar tydligt när en fullständig skanning med hög skrivbelastning körs."
-                },
-                "how": {
-                    "how_kicker": "Så fungerar USBCheck",
-                    "how_title": "Snabbtest i webbläsaren, Pro-läge med djupanalys.",
-                    "how_intro": "USBCheck kombinerar två världar: ett enkelt snabbtest för alla och ett avancerat Pro-läge för tekniker, administratörer och avancerade användare. Snabbtestet körs direkt i webbläsaren utan installation. Pro-läget använder ett litet hjälpprogram som kan utföra tester liknande F3/badblocks och avslöja kapacitetsförfalskningar.",
-                    "how_step1_title": "Starta webbläsartestet",
-                    "how_step1_text": "Du öppnar snabbtestet på",
-                    "how_step2_title": "Skriv-, läs- och integritetskontroll",
-                    "how_step2_text": "Webbläsaren skapar testfiler, mäter skriv- och läshastighet och jämför hash-värden för att upptäcka datafel – allt lokalt utan överföring av dina filer.",
-                    "how_step3_title": "Valfritt: Pro-läge för fullständig skanning",
-                    "how_step3_text": "Om du vill veta mer kan du installera hjälpprogrammet. Det kan kontrollera hela minnet, identifiera falska USB-minnen och skapa detaljerade rapporter – perfekt för IT-avdelningar, laboratorier och refurbishers.",
-                    "how_side_title": "Free vs Pro – en snabb översikt",
-                    "how_side_free": "pages.main.sections.how.how_side_free",
-                    "how_side_pro": "pages.main.sections.how.how_side_pro",
-                    "how_side_account": "pages.main.sections.how.how_side_account"
-                },
-                "hero": {
-                    "hero_kicker": "Upptäck falska USB-minnen innan du förlorar data",
-                    "hero_title": "Är mitt USB-minne falskt?",
-                    "hero_lead": "USBCheck kombinerar ett snabbt webbläsartest med ett professionellt Pro-läge. På så sätt upptäcker du falska USB-minnen, felaktigt angiven kapacitet och långsamma kontroller – innan dina filer skadas.",
-                    "cta_quick": "Starta gratis snabbtest",
-                    "cta_learn": "Läs mer om Free & Pro",
-                    "trust1_title": "Ingen installation behövs",
-                    "trust1_text": "Webbläsarbaserat test direkt på ditt USB-minne.",
-                    "trust2_title": "Riktiga skriv- och lästester",
-                    "trust2_text": "Tester med riktiga data – ingen syntetisk teori.",
-                    "trust3_title": "Integritet först",
-                    "trust3_text": "Dina testdata stannar lokalt – rapporter bara om du vill.",
-                    "quick_label": "FÖRHANDSVISNING SNABBTEST",
-                    "quick_title": "Testa ett USB-minne på under 2 minuter",
-                    "badge_free": "Gratis",
-                    "quick_metric1_label": "Skrivprestanda",
-                    "quick_metric1_value": "~ 75–120 MB/s*",
-                    "quick_metric2_label": "Integritetskontroll",
-                    "quick_metric2_value": "512 MB testdata",
-                    "quick_intro": "Snabbtestet analyserar en definierad datamängd och mäter:",
-                    "quick_li1": "Skriv- och läshastighet",
-                    "quick_li2": "Dataintegritet (hash-jämförelse)",
-                    "quick_li3": "Misstänkta fel eller avbrott",
-                    "quick_visual_title": "Indikator för snabbtest",
-                    "quick_visual_text": "Så här ser snabbtestets vy ut: grönt betyder stabilt minne, orange indikerar varningar.",
-                    "quick_visual_window": "Resultatfönster",
-                    "quick_footnote": "*Exempelvärden – dina resultat beror på minne, port och system.",
-                    "quick_cta": "Gå till gratis snabbtest"
-                },
-                "features": {
-                    "features_kicker": "Free & Pro funktioner",
-                    "features_title": "Börja med gratis snabbtest – byt till Pro när du behöver mer.",
-                    "features_intro": "USBCheck växer med dina behov: vanliga användare behöver ofta bara en snabb översikt, medan proffs behöver djupanalys och möjligheten att arkivera rapporter.",
-                    "features_free_title": "Gratis snabbtest",
-                    "features_free_badge": "Rekommenderas för de flesta",
-                    "features_free_text": "Perfekt för att snabbt kontrollera om ett USB-minne fungerar stabilt – helt utan installation.",
-                    "features_free_li1": "• Snabbtest direkt i webbläsaren",
-                    "features_free_li2": "• Riktiga skriv- och läshastigheter",
-                    "features_free_li3": "• Hash-baserad integritetskontroll",
-                    "features_free_li4": "• Flera testnivåer (t.ex. 200 MB, 2 GB)",
-                    "features_free_li5": "• Ingen registrering krävs",
-                    "features_free_cta": "Starta gratis test",
-                    "features_pro_title": "Pro-läge",
-                    "features_pro_badge": "För avancerade användare och team",
-                    "features_pro_text": "För alla som behöver full kontroll: IT-avdelningar, tekniker, laboratorier och verksamheter som testar många enheter.",
-                    "features_pro_li1": "• Djupskanning av hela kapaciteten (F3/badblocks-liknande)",
-                    "features_pro_li2": "• Detektering av falsk kapacitet och defekta områden",
-                    "features_pro_li3": "• Detaljerade rapporter (JSON, PDF)",
-                    "features_pro_li4": "• Valfri API-åtkomst",
-                    "features_pro_li5": "• Stöd för flera enheter och användare",
-                    "features_pro_note": "Pro-läget kräver ett litet hjälpprogram installerat lokalt. Det arbetar offline och kan anslutas till ditt USBCheck-konto."
-                },
-                "faq": {
-                    "faq_kicker": "FAQ",
-                    "faq_title": "Vanliga frågor om USBCheck",
-                    "faq_intro": "Här hittar du svar på vanliga frågor. Sektionen utökas baserat på feedback och nya användningsområden.",
-                    "faq_q1": "Körs snabbtestet helt i webbläsaren?",
-                    "faq_a1": "Ja. Snabbtestet körs helt i webbläsaren med moderna API:er som gör det möjligt att skapa och läsa testfiler utan uppladdning.",
-                    "faq_q2": "Behöver jag ett konto för att använda snabbtestet?",
-                    "faq_a2": "Nej. Gratis snabbtest kräver inget konto. Ett konto behövs bara om du vill spara rapporter eller använda Pro-läget.",
-                    "faq_q3": "Kan USBCheck upptäcka alla falska USB-minnen?",
-                    "faq_a3": "Inget verktyg kan garantera 100 %, men Pro-läget med full skanning är designat för att mycket tillförlitligt upptäcka vanliga falskhetsmönster.",
-                    "faq_q4": "Hur integreras verktyget i mitt system?",
-                    "faq_a4": "USBCheck är utvecklat med automatisering i åtanke. Pro-läge och kommande API gör att tester kan integreras i dina arbetsflöden."
-                },
-                "problem": {
-                    "problem_kicker": "Varför falska USB-minnen är farliga",
-                    "problem_title": "Falska USB-minnen kostar pengar – och ibland dina data.",
-                    "problem_p1": "Många billiga USB-minnen anger orealistiskt hög kapacitet. Kontrollen kan vara manipulerad för att rapportera t.ex. 256 GB fast det bara finns 32 GB.",
-                    "problem_p2": "USBCheck hjälper dig att upptäcka sådana förfalskningar innan du använder dem – både privat och i företag.",
-                    "problem_card1_title": "Förlust av viktiga filer",
-                    "problem_card1_text": "Bilder, projektfiler, säkerhetskopior – allt kan gå förlorat om minnet har mindre verklig kapacitet än utlovat.",
-                    "problem_card2_title": "Kostnader för defekta partier",
-                    "problem_card2_text": "Företag och återförsäljare delar ofta ut USB-minnen i stora mängder. Förfalskningar leder till reklamationer och ökade kostnader.",
-                    "problem_card3_title": "Instabil prestanda",
-                    "problem_card3_text": "Långsamma kontroller, instabil firmware och varierande hastigheter är vanliga tecken på falska USB-minnen."
-                }
-            }
-        },
-        "dashboard": {
-            "meta": {
-                "title": "{{primary_domain}} – Dashboard",
-                "description": "Beskrivning för dashboard på {{primary_domain}}"
-            },
-            "sections": {
-                "dashboard": {
-                    "dashboard_kicker": "Dashboard",
-                    "dashboard_title": "Välkommen",
-                    "dashboard_intro": "Här kan du hantera USB-tester, organisera enheter och senare aktivera Pro-läget. Detta område är fortfarande under utveckling men ger redan en översikt.",
-                    "dashboard_plan_label": "Aktuell plan",
-                    "dashboard_card_tests_title": "Senaste tester",
-                    "dashboard_card_tests_text": "Här visas dina senaste snabbtester och Pro-skanningar – inklusive status, hastighet och integritetskontroll.",
-                    "dashboard_card_tests_empty": "Inga testdata ännu. Starta ett test via webbläsaren eller Pro-läget.",
-                    "dashboard_card_devices_title": "Dina USB-enheter",
-                    "dashboard_card_devices_text": "Här kommer du senare kunna hantera dina testade enheter: tillverkare, modell, serienummer och uppmätt kapacitet.",
-                    "dashboard_card_devices_empty": "Inga enheter sparade än. Efter dina första tester kan du lägga till dem här.",
-                    "dashboard_card_next_title": "Nästa steg",
-                    "dashboard_card_next_text": "USBCheck är fortfarande under utveckling. Som en av de första användarna kommer du senare hitta Pro-funktioner, API-åtkomst och detaljerade rapporter här.",
-                    "dashboard_card_next_item1": "• Testa FakeCheck i webbläsaren och ge feedback",
-                    "dashboard_card_next_item2": "• Definiera Pro-funktioner (full skanning, rapporter, API)",
-                    "dashboard_card_next_item3": "• Slutför konton & SSO (my-log.in)",
-                    "dashboard_card_next_cta": "Gå till FakeCheck"
-                }
-            }
-        },
-        "fakecheck": {
-            "meta": {
-                "title": "{{primary_domain}} – FakeCheck",
-                "description": "Beskrivning för FakeCheck på {{primary_domain}}"
-            },
-            "sections": {
-                "hero": {
-                    "fake_hero_kicker": "FakeCheck – webbläsarläge",
-                    "fake_hero_title": "Är mitt USB-minne falskt?",
-                    "fake_hero_lead": "FakeCheck hjälper dig att upptäcka typiska förfalskningar genom skriv-/lästester och kapacitetskontroller – utan installation.",
-                    "fake_cta_start": "Starta webbläsartest (demo)",
-                    "fake_cta_back_home": "Tillbaka till översikten",
-                    "fake_hero_hint": "FakeCheck arbetar med testfiler i en vald mapp. Dina riktiga filer påverkas inte.",
-                    "fake_box_title": "Vad webbläsartestet kan göra",
-                    "fake_box_point1_title": "Skriv-/lästester",
-                    "fake_box_point1_text": "Webbläsaren skapar testfiler, mäter hastigheter och verifierar datamönster.",
-                    "fake_box_point2_title": "Kapacitetstest",
-                    "fake_box_point2_text": "Mängden verifierade data ger en realistisk bild av den stabilt användbara kapaciteten.",
-                    "fake_box_point3_title": "JSON-rapport",
-                    "fake_box_point3_text": "Alla resultat sparas i en strukturerad JSON-rapport som du kan exportera eller arkivera."
-                }
-            }
-        },
-        "login": {
-            "meta": {
-                "title": "{{primary_domain}} – Inloggning",
-                "description": "Beskrivning för inloggning på {{primary_domain}}"
-            },
-            "sections": {
-                "login": {
-                    "auth_kicker": "Konto & inloggning",
-                    "auth_title": "Logga in på USBCheck",
-                    "auth_intro": "Med ett konto kan du spara tester, exportera rapporter och använda Pro-läge på flera enheter. Registrering är gratis och du kan uppgradera till Pro senare.",
-                    "auth_tab_login": "Logga in",
-                    "auth_tab_register": "Registrera",
-                    "auth_login_title": "Logga in",
-                    "auth_login_text": "Logga in med din e-postadress och ditt lösenord.",
-                    "auth_login_email_label": "E-postadress",
-                    "auth_login_password_label": "Lösenord",
-                    "auth_login_submit": "Logga in",
-                    "auth_login_forgot": "Glömt lösenord?",
-                    "auth_register_title": "Gratis registrering",
-                    "auth_register_text": "Skapa ett gratis konto för att spara tester, exportera rapporter och senare aktivera Pro-läge.",
-                    "auth_register_name_label": "Namn",
-                    "auth_register_email_label": "E-postadress",
-                    "auth_register_password_label": "Lösenord",
-                    "auth_register_submit": "Skapa konto",
-                    "auth_register_hint": "Genom att registrera dig accepterar du USBChecks sekretesspolicy och användarvillkor."
-                }
-            }
-        },
-        "tools": {
-            "meta": {
-                "title": "{{primary_domain}} – Verktyg",
-                "description": "Beskrivning för verktyg på {{primary_domain}}"
-            }
-        }
-    },
-    "partials": {
-        "structure": {
-            "layout_end": {
-                "logout_modal_title": "Logga ut?",
-                "logout_modal_text": "När du loggar ut avslutas din session och osparade åtgärder går förlorade. Du kan logga in igen när som helst.",
-                "logout_modal_cancel": "Avbryt",
-                "logout_modal_confirm": "Ja, logga ut"
-            },
-            "header": {
-                "header_slogan": "Testa USB-minnen",
-                "header_btn_login": "Logga in",
-                "header_menu_dashboard": "Dashboard",
-                "header_menu_logout": "Logga ut",
-                "logout_title": "Logga ut?",
-                "logout_text": "Du loggas ut från ditt USBCheck-konto. Aktiva webbläsartester påverkas inte.",
-                "logout_cancel": "Avbryt",
-                "logout_confirm": "Ja, logga ut"
-            },
-            "footer": {
-                "footer_imprint": "partials.structure.footer.footer_imprint",
-                "footer_privacy": "partials.structure.footer.footer_privacy"
-            }
-        }
-    }
-}

public/assets/i18n/tr.json

@@ -1,236 +0,0 @@
-{
-    "meta": {
-        "code": "tr",
-        "label": "Türkçe",
-        "flag": "🇹🇷",
-        "enabled": true
-    },
-    "pages": {
-        "landing": {
-            "meta": {
-                "title": "BAŞLIK YOK"
-            }
-        },
-        "main": {
-            "anchors": {
-                "how": "Nasıl çalışır",
-                "problem": "Sahte USB bellekler neden tehlikelidir",
-                "features": "Özellikler",
-                "security": "Güvenlik",
-                "faq": "SSS"
-            },
-            "sections": {
-                "security": {
-                    "security_kicker": "Güvenlik ve gizlilik",
-                    "security_title": "Gizlilik odaklı tasarım: Test verilerin tamamen sana ait.",
-                    "security_intro": "USBCheck en başından beri gizliliği temel alarak tasarlandı. Tarayıcıdaki hızlı test yalnızca test dosyalarıyla çalışır. Belgelerin, fotoğrafların veya yedeklerin okunmaz ve yüklenmez. Pro modunda ise hangi raporların hesabınla senkronize edileceğine tamamen sen karar verirsin.",
-                    "security_card1_title": "Tamamen yerel testler",
-                    "security_card1_text": "Tüm yazma ve okuma testleri USB belleğin üzerinde yerel olarak gerçekleştirilir. Tarayıcı yalnızca test dosyalarına erişir — kişisel verilerine değil.",
-                    "security_card2_title": "Şeffaf rapor yönetimi",
-                    "security_card2_text": "Giriş yaptıktan sonra test raporlarını hesabında kaydedebilir, dışa aktarabilir veya silebilirsin. Sistemde hangi verilerin kalacağına tamamen sen karar verirsin.",
-                    "security_card3_title": "Cihaz dostu çalışma",
-                    "security_card3_text": "Hızlı test gereksiz aşınmayı önlemek için orta miktarda veri kullanır. Pro modu ise yüksek yazma yükü içeren tam tarama başlatıldığında seni açıkça uyarır."
-                },
-                "how": {
-                    "how_kicker": "USBCheck nasıl çalışır?",
-                    "how_title": "Tarayıcıda hızlı test, Pro modda derin analiz.",
-                    "how_intro": "USBCheck iki dünyayı bir araya getirir: herkes için basit bir tarayıcı hızlı testi ve teknik kullanıcılar, uzmanlar ve yöneticiler için derinlemesine Pro modu. Hızlı test doğrudan tarayıcıda, kurulum gerektirmeden çalışır. Pro modu ise F3 / badblocks benzeri testler yapabilen küçük bir yardımcı araç kullanır ve sahte kapasiteyi güvenilir şekilde tespit eder.",
-                    "how_step1_title": "Tarayıcı testini başlat",
-                    "how_step1_text": "Hızlı testi şu adresten aç:",
-                    "how_step2_title": "Yazma, okuma ve bütünlük kontrolü",
-                    "how_step2_text": "Tarayıcı test dosyaları oluşturur, yazma/okuma hızını ölçer ve hash karşılaştırmalarıyla veri hatalarını algılar — tümü yerel olarak yapılır, içerik aktarılmaz.",
-                    "how_step3_title": "İsteğe bağlı: Pro mod ile tam tarama",
-                    "how_step3_text": "Daha fazla bilgi isteyenler için yardımcı araç kurulabilir. Tüm kapasiteyi test edebilir, sahte alanları tespit edebilir ve detaylı raporlar oluşturabilir.",
-                    "how_side_title": "Free ve Pro karşılaştırması",
-                    "how_side_free": "pages.main.sections.how.how_side_free",
-                    "how_side_pro": "pages.main.sections.how.how_side_pro",
-                    "how_side_account": "pages.main.sections.how.how_side_account"
-                },
-                "hero": {
-                    "hero_kicker": "Veri kaybetmeden önce sahte USB’leri tespit et",
-                    "hero_title": "USB belleğim sahte mi?",
-                    "hero_lead": "USBCheck hızlı tarayıcı testini profesyonel Pro modu ile birleştirir. Böylece sahte USB bellekleri, düşük gerçek kapasiteyi ve yavaş denetleyicileri dosyaların kaybolmadan önce tespit edebilirsin.",
-                    "cta_quick": "Ücretsiz hızlı testi başlat",
-                    "cta_learn": "Free ve Pro hakkında bilgi al",
-                    "trust1_title": "Hızlı test için kurulum yok",
-                    "trust1_text": "Test tarayıcıda çalışır — doğrudan USB belleğin üzerinde.",
-                    "trust2_title": "Gerçek yazma & okuma testleri",
-                    "trust2_text": "Gerçek verilerle hız testi yapılır — sentetik değil.",
-                    "trust3_title": "Gizlilik öncelikli",
-                    "trust3_text": "Test verilerin yerel kalır — raporlar sadece istersen kaydedilir.",
-                    "quick_label": "HIZLI TEST ÖNİZLEMESİ",
-                    "quick_title": "Bir USB belleği 2 dakikadan kısa sürede test et",
-                    "badge_free": "Ücretsiz",
-                    "quick_metric1_label": "Yazma performansı",
-                    "quick_metric1_value": "~ 75–120 MB/s*",
-                    "quick_metric2_label": "Bütünlük kontrolü",
-                    "quick_metric2_value": "512 MB örnek",
-                    "quick_intro": "Hızlı test USB belleğinde belirli bir veri miktarını yazar ve şunları ölçer:",
-                    "quick_li1": "Yazma ve okuma hızı",
-                    "quick_li2": "Veri bütünlüğü (hash kontrolü)",
-                    "quick_li3": "Şüpheli hatalar veya kesilmeler",
-                    "quick_visual_title": "Hızlı test göstergesi",
-                    "quick_visual_text": "Önizleme ekranında yeşil: stabil. Turuncu: dikkat gerektiren durum.",
-                    "quick_visual_window": "Sonuç penceresi",
-                    "quick_footnote": "*Örnek değerlerdir — sonuçlar USB bellek, port ve sisteme göre değişir.",
-                    "quick_cta": "Ücretsiz hızlı teste git"
-                },
-                "features": {
-                    "features_kicker": "Free ve Pro özellikleri",
-                    "features_title": "Ücretsiz hızlı test ile başla — daha fazlası için Pro moduna geç.",
-                    "features_intro": "USBCheck ihtiyaçlarına göre gelişir: bireysel kullanıcılar genellikle hızlı bir değerlendirme ister, profesyoneller ise derin analiz ve raporlama ister. Pro modu tam da bunun için var.",
-                    "features_free_title": "Ücretsiz hızlı test",
-                    "features_free_badge": "Çoğu kullanıcı için önerilir",
-                    "features_free_text": "USB belleğinin temel performans ve stabilitesini kurulum gerekmeden hızlıca kontrol etmek için idealdir.",
-                    "features_free_li1": "• Tarayıcı tabanlı hızlı test",
-                    "features_free_li2": "• Gerçek veri ile yazma/okuma testi",
-                    "features_free_li3": "• Veri bütünlüğü için hash doğrulaması",
-                    "features_free_li4": "• Farklı test seviyeleri (örn. 200 MB, 2 GB)",
-                    "features_free_li5": "• Kayıt gerekmez",
-                    "features_free_cta": "Ücretsiz hızlı testi başlat",
-                    "features_pro_title": "Pro modu",
-                    "features_pro_badge": "Güç kullanıcıları ve ekipler için",
-                    "features_pro_text": "Tam kontrol isteyenler için: IT ekipleri, teknisyenler, laboratuvarlar ve büyük miktarda USB bellek test eden işletmeler.",
-                    "features_pro_li1": "• Tüm kapasitenin derin taraması (F3 / badblocks benzeri)",
-                    "features_pro_li2": "• Sahte kapasite ve bozuk alan tespiti",
-                    "features_pro_li3": "• Kaydedilebilir detaylı test raporları (JSON, PDF)",
-                    "features_pro_li4": "• Otomasyon için isteğe bağlı API erişimi",
-                    "features_pro_li5": "• Çoklu cihaz ve çoklu kullanıcı desteği",
-                    "features_pro_note": "Pro modu için küçük bir yardımcı araç gerekir. Tüm işlemler yerel olarak yapılır ve isterse hesabınla senkronize edilir."
-                },
-                "faq": {
-                    "faq_kicker": "SSS",
-                    "faq_title": "USBCheck hakkında sık sorulan sorular",
-                    "faq_intro": "Burada sıkça sorulan soruların yanıtlarını bulabilirsin. Kullanıcı geri bildirimlerine göre bölüm düzenli olarak genişletilir.",
-                    "faq_q1": "Hızlı test tamamen tarayıcıda mı çalışıyor?",
-                    "faq_a1": "Evet. Hızlı test tamamen tarayıcıda çalışır ve USB belleğinde test dosyaları oluşturup okur. İznin olmadan hiçbir veri yüklenmez.",
-                    "faq_q2": "Hızlı testi kullanmak için hesap gerekiyor mu?",
-                    "faq_a2": "Hayır. Hızlı test ücretsizdir ve kayıt gerekmez. Test raporlarını kaydetmek veya Pro modu kullanmak için giriş yapmak gerekir.",
-                    "faq_q3": "USBCheck tüm sahte USB bellekleri tespit edebilir mi?",
-                    "faq_a3": "Hiçbir araç %100 garanti veremez. Ancak Pro modun tam taraması, yaygın sahtecilik yöntemlerini çok yüksek doğrulukla tespit eder.",
-                    "faq_q4": "USBCheck mevcut sistemime entegre edilebilir mi?",
-                    "faq_a4": "Evet. USBCheck otomasyon için tasarlanmıştır. Pro modu ve API ile iş akışlarına kolayca entegre edilebilir."
-                },
-                "problem": {
-                    "problem_kicker": "Sahte USB'ler neden tehlikelidir?",
-                    "problem_title": "Sahte USB bellekler para kaybettirir — ve en kötüsü, verilerini yok edebilir.",
-                    "problem_p1": "Birçok ucuz USB bellek gerçek kapasiteden çok daha yüksek bir değer gösterir. Denetleyici manipüle edilmiştir: örneğin 256 GB gösterir ama içinde yalnızca 32 GB fiziksel depolama vardır. Sonuç: Veriler doğru yazılmış gibi görünür ama daha sonra sessizce bozulur veya üzerine yazılır.",
-                    "problem_p2": "USBCheck bu tür sahteciliği kullanmaya başlamadan önce fark etmene yardımcı olur — ister bireysel, ister kurumsal kullanım olsun.",
-                    "problem_card1_title": "Önemli dosyaların kaybı",
-                    "problem_card1_text": "Fotoğraflar, projeler, yedekler — USB bellek sahte kapasiteye sahipse hepsi bozulma riski taşır.",
-                    "problem_card2_title": "Hatalı ürün gruplarının maliyeti",
-                    "problem_card2_text": "Şirketler ve ajanslar USB bellekleri genellikle toplu dağıtır. Sahte ürünler iade, itibar kaybı ve yeni üretim maliyeti demektir.",
-                    "problem_card3_title": "Dengesiz performans",
-                    "problem_card3_text": "Sahte USB bellekler genellikle düşük kaliteli kontrolcülere sahiptir; hız dalgalanır ve hata riski artar."
-                }
-            }
-        },
-        "dashboard": {
-            "meta": {
-                "title": "{{primary_domain}} – Kontrol Paneli",
-                "description": "{{primary_domain}} için kontrol paneli açıklaması"
-            },
-            "sections": {
-                "dashboard": {
-                    "dashboard_kicker": "Kontrol Paneli",
-                    "dashboard_title": "Hoş geldin",
-                    "dashboard_intro": "Burada USB testlerini yönetebilir, cihazlarını organize edebilir ve ileride Pro modunu etkinleştirebilirsin. Bu bölüm hâlâ geliştirme aşamasındadır.",
-                    "dashboard_plan_label": "Geçerli plan",
-                    "dashboard_card_tests_title": "Son testler",
-                    "dashboard_card_tests_text": "Burada hızlı testlerin ve Pro taramalarının sonuçları görüntülenecek.",
-                    "dashboard_card_tests_empty": "Henüz test bulunmuyor. Tarayıcı testi veya Pro testiyle başlayabilirsin.",
-                    "dashboard_card_devices_title": "USB cihazların",
-                    "dashboard_card_devices_text": "Test ettiğin USB bellekleri burada marka, model, seri numarası ve gerçek kapasite bilgileriyle yönetebileceksin.",
-                    "dashboard_card_devices_empty": "Henüz kayıtlı cihaz yok. İlk testten sonra buraya ekleyebilirsin.",
-                    "dashboard_card_next_title": "Sonraki adımlar",
-                    "dashboard_card_next_text": "USBCheck hâlâ geliştirilmekte. Yakında Pro özellikleri, API erişimi ve detaylı raporlar burada yer alacak.",
-                    "dashboard_card_next_item1": "• Tarayıcı FakeCheck'i dene ve geri bildirim ver",
-                    "dashboard_card_next_item2": "• Pro modu planla (örn. tam tarama, raporlar, API)",
-                    "dashboard_card_next_item3": "• Hesap & SSO (my-log.in) entegrasyonunu tamamla",
-                    "dashboard_card_next_cta": "FakeCheck'e git"
-                }
-            }
-        },
-        "fakecheck": {
-            "meta": {
-                "title": "{{primary_domain}} – FakeCheck",
-                "description": "{{primary_domain}} için FakeCheck açıklaması"
-            },
-            "sections": {
-                "hero": {
-                    "fake_hero_kicker": "FakeCheck – Tarayıcı Modu",
-                    "fake_hero_title": "USB belleğim sahte mi?",
-                    "fake_hero_lead": "FakeCheck; tarayıcı tabanlı yazma/okuma testleri ve kapasite tutarlılık kontrolleriyle sahte USB bellekleri hızlıca tespit etmene yardımcı olur.",
-                    "fake_cta_start": "Tarayıcı testini başlat (Demo)",
-                    "fake_cta_back_home": "Genel bakışa dön",
-                    "fake_hero_hint": "FakeCheck seçtiğin klasörde test dosyaları oluşturur, yazma/okuma düzenlerini kontrol eder. Gerçek dosyalarına dokunulmaz.",
-                    "fake_box_title": "Tarayıcı testi neler yapabilir?",
-                    "fake_box_point1_title": "Dosya tabanlı yazma/okuma testi",
-                    "fake_box_point1_text": "Tarayıcı test dosyaları oluşturur, hızları ölçer ve okunan veriyi karşılaştırarak doğrular.",
-                    "fake_box_point2_title": "Kapasite tutarlılık kontrolü",
-                    "fake_box_point2_text": "Başarılı şekilde yazılıp doğrulanan veri miktarı, gerçek kullanılabilir kapasite hakkında güvenilir bir izlenim verir.",
-                    "fake_box_point3_title": "JSON raporu oluşturma",
-                    "fake_box_point3_text": "Tüm sonuçlar tek bir JSON raporunda toplanır ve saklanabilir veya karşılaştırılabilir."
-                }
-            }
-        },
-        "login": {
-            "meta": {
-                "title": "{{primary_domain}} – Giriş",
-                "description": "{{primary_domain}} için giriş açıklaması"
-            },
-            "sections": {
-                "login": {
-                    "auth_kicker": "Hesap & Giriş",
-                    "auth_title": "USBCheck hesabına giriş yap",
-                    "auth_intro": "Bir hesapla test sonuçlarını kaydedebilir, raporları dışa aktarabilir ve Pro modunu birden fazla cihazda kullanabilirsin. Kayıt ücretsizdir — Pro'ya istediğin zaman geçebilirsin.",
-                    "auth_tab_login": "Giriş",
-                    "auth_tab_register": "Kayıt ol",
-                    "auth_login_title": "Giriş",
-                    "auth_login_text": "E-posta adresin ve şifrenle giriş yap.",
-                    "auth_login_email_label": "E-posta adresi",
-                    "auth_login_password_label": "Şifre",
-                    "auth_login_submit": "Giriş yap",
-                    "auth_login_forgot": "Şifreni mi unuttun?",
-                    "auth_register_title": "Ücretsiz kayıt ol",
-                    "auth_register_text": "Testleri kaydetmek, raporları dışa aktarmak ve Pro modunu açmak için ücretsiz bir hesap oluştur.",
-                    "auth_register_name_label": "Ad",
-                    "auth_register_email_label": "E-posta adresi",
-                    "auth_register_password_label": "Şifre",
-                    "auth_register_submit": "Hesap oluştur",
-                    "auth_register_hint": "Kayıt olarak USBCheck’in gizlilik politikasını ve yasal şartlarını kabul etmiş olursun."
-                }
-            }
-        },
-        "tools": {
-            "meta": {
-                "title": "{{primary_domain}} – Araçlar",
-                "description": "{{primary_domain}} için araçlar açıklaması"
-            }
-        }
-    },
-    "partials": {
-        "structure": {
-            "layout_end": {
-                "logout_modal_title": "Çıkış yapılsın mı?",
-                "logout_modal_text": "Çıkış yaparsan oturumun kapanır ve kaydedilmemiş işlemler kaybolabilir. İstediğin zaman tekrar giriş yapabilirsin.",
-                "logout_modal_cancel": "İptal",
-                "logout_modal_confirm": "Evet, çıkış yap"
-            },
-            "header": {
-                "header_slogan": "USB bellekleri test et",
-                "header_btn_login": "Giriş",
-                "header_menu_dashboard": "Kontrol Paneli",
-                "header_menu_logout": "Çıkış",
-                "logout_title": "Çıkış yapılsın mı?",
-                "logout_text": "USBCheck hesabından çıkış yapacaksın. Tarayıcıdaki aktif testler etkilenmez.",
-                "logout_cancel": "İptal",
-                "logout_confirm": "Evet, çıkış"
-            },
-            "footer": {
-                "footer_imprint": "partials.structure.footer.footer_imprint",
-                "footer_privacy": "partials.structure.footer.footer_privacy"
-            }
-        }
-    }
-}

public/assets/i18n/zh-CN.json

@@ -1,236 +0,0 @@
-{
-    "meta": {
-        "code": "zh-CN",
-        "label": "简体中文",
-        "flag": "🇨🇳",
-        "enabled": true
-    },
-    "pages": {
-        "landing": {
-            "meta": {
-                "title": "无标题"
-            }
-        },
-        "main": {
-            "anchors": {
-                "how": "工作原理",
-                "problem": "为什么假冒USB设备很危险",
-                "features": "功能",
-                "security": "安全",
-                "faq": "常见问题"
-            },
-            "sections": {
-                "security": {
-                    "security_kicker": "安全与隐私",
-                    "security_title": "隐私优先的设计：你的测试数据只属于你。",
-                    "security_intro": "USBCheck 从一开始就以保护隐私为核心设计。浏览器快速测试只会使用专门生成的测试文件。你的文档、照片或备份不会被读取或上传。在 Pro 模式下，你可以完全控制哪些测试报告会与账号同步，以及保存多久。",
-                    "security_card1_title": "本地执行测试",
-                    "security_card1_text": "所有读写测试都在你的 U 盘本地完成。浏览器只访问测试文件，不会触及任何私人的文件内容。",
-                    "security_card2_title": "透明可控的报告",
-                    "security_card2_text": "登录后，你可以在账号中保存、导出或删除测试报告。哪些数据留在系统里，由你说了算。",
-                    "security_card3_title": "尽量减少对硬件的磨损",
-                    "security_card3_text": "快速测试使用适中的数据量，避免不必要的写入磨损。Pro 模式在执行高写入负载的全盘扫描之前，会给出清晰的风险提示。"
-                },
-                "how": {
-                    "how_kicker": "USBCheck 如何工作",
-                    "how_title": "浏览器内快速测试，Pro 模式提供深度分析。",
-                    "how_intro": "USBCheck 结合了两种需求：面向所有人的简单浏览器快速测试，以及面向技术用户、工程师和管理员的深度 Pro 模式。快速测试直接在浏览器中运行，无需安装。Pro 模式使用一个小型辅助工具，可以执行类似 F3 / badblocks 的全面测试，从而可靠识别容量造假。",
-                    "how_step1_title": "启动浏览器测试",
-                    "how_step1_text": "在下方地址打开快速测试：",
-                    "how_step2_title": "写入、读取与完整性检查",
-                    "how_step2_text": "浏览器会在你的 U 盘上创建测试文件，测量写入和读取速度，并通过哈希值比对来检测数据错误——所有操作都在本地完成，不会上传你的真实文件。",
-                    "how_step3_title": "可选：Pro 模式全盘扫描",
-                    "how_step3_text": "如果你需要更深入的信息，可以安装可选的辅助工具。它可以扫描整个盘的有效容量，识别假容量和不稳定区域，并生成详细报告——非常适合翻新商、IT 部门或实验室。",
-                    "how_side_title": "Free 与 Pro 对比一览",
-                    "how_side_free": "pages.main.sections.how.how_side_free",
-                    "how_side_pro": "pages.main.sections.how.how_side_pro",
-                    "how_side_account": "pages.main.sections.how.how_side_account"
-                },
-                "hero": {
-                    "hero_kicker": "在丢失数据之前识别假 U 盘",
-                    "hero_title": "我的 U 盘是假的么？",
-                    "hero_lead": "USBCheck 将快速的浏览器测试与专业的 Pro 模式结合起来，帮助你在文件真正出问题之前，就发现假 U 盘、虚标容量和劣质控制器。",
-                    "cta_quick": "开始免费快速测试",
-                    "cta_learn": "了解 Free 与 Pro 的区别",
-                    "trust1_title": "快速测试无需安装",
-                    "trust1_text": "纯浏览器测试，直接在你的 U 盘上运行。",
-                    "trust2_title": "真实的读写测试",
-                    "trust2_text": "使用真实数据进行写入与读取测试，而不是理论化的合成跑分。",
-                    "trust3_title": "隐私优先",
-                    "trust3_text": "测试数据仅在本地使用——是否生成和同步报告完全由你决定。",
-                    "quick_label": "快速测试预览",
-                    "quick_title": "在 2 分钟内检测一个 U 盘",
-                    "badge_free": "免费",
-                    "quick_metric1_label": "写入性能",
-                    "quick_metric1_value": "~ 75–120 MB/s*",
-                    "quick_metric2_label": "完整性检查量",
-                    "quick_metric2_value": "512 MB 样本数据",
-                    "quick_intro": "快速测试会在你的 U 盘上写入一段定义好的数据量，并测量：",
-                    "quick_li1": "写入速度与读取速度",
-                    "quick_li2": "数据完整性（哈希比对）",
-                    "quick_li3": "可疑中断或错误",
-                    "quick_visual_title": "快速测试指示结果",
-                    "quick_visual_text": "预览界面中，绿色表示整体稳定，橙色表示发现异常情况，需要进一步关注。",
-                    "quick_visual_window": "结果窗口",
-                    "quick_footnote": "*示例值——你的实际结果会因 U 盘、接口和系统环境而有所不同。",
-                    "quick_cta": "前往免费快速测试"
-                },
-                "features": {
-                    "features_kicker": "Free 与 Pro 功能",
-                    "features_title": "从免费的快速测试开始，需要更深入分析时再升级 Pro 模式。",
-                    "features_intro": "USBCheck 会随着你的使用场景一起成长：个人用户通常只需要一个快速判断，而专业用户则希望验证容量、记录报告并长期归档。Pro 模式正是为此设计。",
-                    "features_free_title": "免费快速测试",
-                    "features_free_badge": "适合大多数用户",
-                    "features_free_text": "非常适合想快速检查 U 盘是否基本稳定、是否有明显性能问题的用户，完全无需安装软体。",
-                    "features_free_li1": "• 基于浏览器的快速测试，直接在 U 盘上运行",
-                    "features_free_li2": "• 使用真实测试数据测量读写速度",
-                    "features_free_li3": "• 对一定数据量进行哈希完整性校验",
-                    "features_free_li4": "• 多个测试级别可选（如 200 MB、2 GB）",
-                    "features_free_li5": "• 无需注册账号即可使用",
-                    "features_free_cta": "开始免费快速测试",
-                    "features_pro_title": "Pro 模式",
-                    "features_pro_badge": "面向专业用户与团队",
-                    "features_pro_text": "适合需要高度可控流程的场景：IT 部门、技术支持、翻新工厂、实验室，或需要批量测试 U 盘的企业。",
-                    "features_pro_li1": "• 对整盘容量进行深度扫描（类似 F3 / badblocks）",
-                    "features_pro_li2": "• 检测容量造假和坏块区域",
-                    "features_pro_li3": "• 生成可保存的详细测试报告（JSON、PDF）",
-                    "features_pro_li4": "• 可选 API 接口，用于自动化测试流程",
-                    "features_pro_li5": "• 通过登录实现多设备、多用户支持",
-                    "features_pro_note": "Pro 模式需要在本地安装一个小型辅助工具。所有操作在本机执行，你可以选择是否把结果与 USBCheck 账号同步。"
-                },
-                "faq": {
-                    "faq_kicker": "常见问题",
-                    "faq_title": "关于 USBCheck 的常见问题解答",
-                    "faq_intro": "这里收集了用户最关心的一些问题。随着使用场景和反馈的增加，FAQ 会不断扩展和更新。",
-                    "faq_q1": "快速测试真的完全在浏览器中运行吗？",
-                    "faq_a1": "是的。快速测试完全在浏览器中执行，依赖现代浏览器 API 在你的 U 盘上创建并读取测试文件。没有任何内容会在未经允许的情况下上传到服务器。",
-                    "faq_q2": "使用快速测试需要注册账号吗？",
-                    "faq_a2": "不需要。免费快速测试对所有人开放，无需注册。只有在你希望保存测试报告、管理多个 U 盘或使用 Pro 模式时，才需要登录账号。",
-                    "faq_q3": "USBCheck 能 100% 识别所有假 U 盘吗？",
-                    "faq_a3": "任何工具都无法给出 100% 的保证。但带有全盘扫描的 Pro 模式，是专门为识别常见造假手段而设计的，例如虚假容量、特定填充比例后的错误等，可靠性非常高。",
-                    "faq_q4": "USBCheck 可以接入到我现有的系统里吗？",
-                    "faq_a4": "可以。USBCheck 从设计之初就考虑到自动化和集成。未来通过 Pro 模式的扩展和计划中的 API，你可以把测试嵌入到入库检测、质检流程或内部工具中。"
-                },
-                "problem": {
-                    "problem_kicker": "为什么假 U 盘是个严重问题",
-                    "problem_title": "假 U 盘会带来金钱损失，更可能毁掉你最重要的数据。",
-                    "problem_p1": "许多廉价 U 盘以远超真实容量的数字进行宣传。实际上，控制器被篡改，只是向系统“谎报”了更大的容量。当写入数据超过真实物理容量后，旧数据会被悄悄覆盖或损坏。",
-                    "problem_p2": "USBCheck 帮助你在正式使用之前就识别出这些风险，不管你是个人用户，还是需要批量验收设备的企业用户。",
-                    "problem_card1_title": "关键文件面临丢失风险",
-                    "problem_card1_text": "照片、项目文件、备份——一旦写入到虚假容量区域，很可能在日后恢复或使用时才发现已经无法读取。",
-                    "problem_card2_title": "批量采购带来的损失",
-                    "problem_card2_text": "企业、代理商或活动组织方通常会大量派发 U 盘。一批有问题的 U 盘意味着退货、声誉受损以及额外的重制成本。",
-                    "problem_card3_title": "性能不稳定与错误",
-                    "problem_card3_text": "假 U 盘往往使用低质量控制器，固件不稳定，写入速度忽快忽慢。这会显著增加复制失败、文件损坏和备份不可靠的风险。"
-                }
-            }
-        },
-        "dashboard": {
-            "meta": {
-                "title": "{{primary_domain}} – 控制面板",
-                "description": "在 {{primary_domain}} 上管理你的 USB 测试、设备与 Pro 功能的控制面板。"
-            },
-            "sections": {
-                "dashboard": {
-                    "dashboard_kicker": "控制面板",
-                    "dashboard_title": "欢迎回来",
-                    "dashboard_intro": "在这里，你可以管理自己的 USB 测试记录、整理设备，并在未来启用 Pro 模式功能。该区域目前仍在开发中，但已经可以让你提前了解整体结构。",
-                    "dashboard_plan_label": "当前方案",
-                    "dashboard_card_tests_title": "最近的测试",
-                    "dashboard_card_tests_text": "这里将显示你最近的快速测试和 Pro 扫描结果，包括状态、速度和完整性检查情况。",
-                    "dashboard_card_tests_empty": "当前还没有任何测试数据。先从浏览器快速测试或 Pro 模式测试开始吧。",
-                    "dashboard_card_devices_title": "你的 USB 设备",
-                    "dashboard_card_devices_text": "未来你可以在这里管理已经测试过的 U 盘：例如品牌、型号、序列号，以及检测到的真实容量。",
-                    "dashboard_card_devices_empty": "尚未保存任何设备。在完成第一次测试后，你就可以把 U 盘保存为一个设备条目。",
-                    "dashboard_card_next_title": "接下来可以做什么",
-                    "dashboard_card_next_text": "USBCheck 仍在积极开发中。作为早期用户，你将率先体验新的 Pro 选项、API 接口和更详细的报告视图。",
-                    "dashboard_card_next_item1": "• 试用浏览器版 FakeCheck 并反馈意见",
-                    "dashboard_card_next_item2": "• 一起打磨 Pro 模式功能（如全盘扫描、报告、API）",
-                    "dashboard_card_next_item3": "• 完成账号体系与 SSO（my-log.in）集成",
-                    "dashboard_card_next_cta": "前往 FakeCheck"
-                }
-            }
-        },
-        "fakecheck": {
-            "meta": {
-                "title": "{{primary_domain}} – FakeCheck",
-                "description": "在 {{primary_domain}} 上使用 FakeCheck，通过浏览器检测 U 盘容量造假与稳定性。"
-            },
-            "sections": {
-                "hero": {
-                    "fake_hero_kicker": "FakeCheck —— 浏览器测试模式",
-                    "fake_hero_title": "我的 U 盘是不是假货？",
-                    "fake_hero_lead": "FakeCheck 通过浏览器进行写入/读取测试，并结合有效容量的合理性判断，帮助你在无需安装的前提下快速识别典型假 U 盘。",
-                    "fake_cta_start": "启动浏览器测试（演示）",
-                    "fake_cta_back_home": "返回总览页面",
-                    "fake_hero_hint": "FakeCheck 会在你选定的文件夹内创建测试文件，并对读写模式进行校验。你的真实文件不会被移动或修改。",
-                    "fake_box_title": "浏览器测试可以帮你做什么",
-                    "fake_box_point1_title": "基于文件的读写测试",
-                    "fake_box_point1_text": "浏览器创建一组测试文件，测量写入速度和读取速度，并检查读回的数据是否与原始模式一致。",
-                    "fake_box_point2_title": "容量合理性检查",
-                    "fake_box_point2_text": "根据成功写入并验证的数据量，可以直观判断，U 盘的真实可用容量是否与标称值相符。",
-                    "fake_box_point3_title": "用于留档的 JSON 报告",
-                    "fake_box_point3_text": "所有测试结果会汇总到结构化的 JSON 报告中，方便你保存、上传或与后续测试做对比。"
-                }
-            }
-        },
-        "login": {
-            "meta": {
-                "title": "{{primary_domain}} – 登录",
-                "description": "在 {{primary_domain}} 登录 USBCheck 账号，管理测试报告与 Pro 模式。"
-            },
-            "sections": {
-                "login": {
-                    "auth_kicker": "账号与登录",
-                    "auth_title": "登录 USBCheck 账号",
-                    "auth_intro": "登录账号后，你可以保存测试结果、导出报告，并在多台设备上使用 Pro 模式。注册完全免费，是否升级为 Pro 可以稍后再决定。",
-                    "auth_tab_login": "登录",
-                    "auth_tab_register": "注册",
-                    "auth_login_title": "登录",
-                    "auth_login_text": "使用你的电子邮箱和密码登录。",
-                    "auth_login_email_label": "电子邮箱",
-                    "auth_login_password_label": "密码",
-                    "auth_login_submit": "登录",
-                    "auth_login_forgot": "忘记密码？",
-                    "auth_register_title": "免费注册",
-                    "auth_register_text": "创建一个免费账号，用于保存测试记录、导出报告，并在需要时解锁 Pro 模式功能。",
-                    "auth_register_name_label": "姓名",
-                    "auth_register_email_label": "电子邮箱",
-                    "auth_register_password_label": "密码",
-                    "auth_register_submit": "创建账号",
-                    "auth_register_hint": "注册即表示你同意 USBCheck 的隐私政策和法律声明。"
-                }
-            }
-        },
-        "tools": {
-            "meta": {
-                "title": "{{primary_domain}} – 工具",
-                "description": "在 {{primary_domain}} 上查看和管理 USBCheck 提供的工具与辅助功能。"
-            }
-        }
-    },
-    "partials": {
-        "structure": {
-            "layout_end": {
-                "logout_modal_title": "确认要退出登录？",
-                "logout_modal_text": "退出登录后，你当前的会话将结束，未保存的操作可能会丢失。你可以随时再次登录。",
-                "logout_modal_cancel": "取消",
-                "logout_modal_confirm": "是的，退出登录"
-            },
-            "header": {
-                "header_slogan": "测试 USB 闪存盘",
-                "header_btn_login": "登录",
-                "header_menu_dashboard": "控制面板",
-                "header_menu_logout": "退出登录",
-                "logout_title": "确认退出登录？",
-                "logout_text": "你将退出当前 USBCheck 账号。正在浏览器中运行的测试不会受到影响。",
-                "logout_cancel": "取消",
-                "logout_confirm": "是的，退出"
-            },
-            "footer": {
-                "footer_imprint": "partials.structure.footer.footer_imprint",
-                "footer_privacy": "partials.structure.footer.footer_privacy"
-            }
-        }
-    }
-}

public/assets/js/auth.js

@@ -1,30 +0,0 @@
-document.addEventListener("DOMContentLoaded", () => {
-    const tabs = document.querySelectorAll(".auth-tab");
-    const panelLogin = document.getElementById("authPanelLogin");
-    const panelRegister = document.getElementById("authPanelRegister");
-
-    if (!tabs.length || !panelLogin || !panelRegister) return;
-
-    tabs.forEach(tab => {
-        tab.addEventListener("click", () => {
-            const target = tab.getAttribute("data-tab"); // "login" oder "register"
-
-            // Tab-Styles
-            tabs.forEach(t => {
-                t.classList.remove("bg-brand-primary", "text-brand-bg");
-                t.classList.add("hover:text-brand-primary");
-            });
-            tab.classList.add("bg-brand-primary", "text-brand-bg");
-            tab.classList.remove("hover:text-brand-primary");
-
-            // Panels
-            if (target === "login") {
-                panelLogin.classList.remove("hidden");
-                panelRegister.classList.add("hidden");
-            } else {
-                panelRegister.classList.remove("hidden");
-                panelLogin.classList.add("hidden");
-            }
-        });
-    });
-});

public/assets/js/dashboard.js

@@ -1,7 +0,0 @@
-// public/assets/js/dashboard.js
-
-document.addEventListener('DOMContentLoaded', function () {
-    // Platzhalter für zukünftige Dashboard-Logik
-    // z.B. AJAX-Liste der letzten Tests, Filtern, Sortieren etc.
-    console.log('Dashboard JS loaded');
-});

public/assets/js/fakecheck.js

@@ -1,37 +0,0 @@
-// /public/assets/js/fakecheck.js
-// Loader für alle Fakecheck-Module
-
-(function () {
-    const cfg = window.usbConfig || {};
-    const assetsBase = cfg.assetsBase || "/assets";
-
-    // Version aus PHP-Config (ASSET_VERSION) → app_config.php
-    const assetVersion = cfg.assetVersion;
-    const versionQuery = assetVersion
-        ? ("?v=" + encodeURIComponent(assetVersion))
-        : "";
-
-    // Basis-Pfad für die Teil-Skripte
-    const base = assetsBase.replace(/\/+$/, "") + "/js/fakecheck/";
-
-    const scripts = [
-        base + "fakecheck.core.js" + versionQuery,
-        base + "fakecheck.browser.js" + versionQuery,
-        base + "fakecheck.serial.js" + versionQuery
-    ];
-
-    function loadScript(src) {
-        return new Promise((resolve, reject) => {
-            const s = document.createElement("script");
-            s.src = src;
-            s.async = false; // Reihenfolge sicherstellen
-            s.onload = resolve;
-            s.onerror = () => reject(new Error("Konnte " + src + " nicht laden"));
-            document.head.appendChild(s);
-        });
-    }
-
-    scripts
-        .reduce((p, src) => p.then(() => loadScript(src)), Promise.resolve())
-        .catch(err => console.error("Fakecheck Loader Fehler:", err));
-})();

public/assets/js/fakecheck/fakecheck.browser.js

@@ -1,970 +0,0 @@
-// /public/assets/js/fakecheck/fakecheck.browser.js
-
-(function () {
-    // Core / Namespace muss geladen sein
-    if (!window.usbcheck) return;
-
-    const {
-        cfg,
-        log: logLine,
-        setStatus,
-        setModeLabel,
-        setProgress,
-        setOverallStatus,
-        formatBytes,
-        formatMbps,
-        formatDuration,
-        t,
-        tFmt
-    } = window.usbcheck;
-
-    const root = document.getElementById("fc-root");
-    if (!root) {
-        // Seite ohne Fakecheck-Tool → nichts tun
-        return;
-    }
-
-    // --- DOM-Helper ---------------------------------------------------------
-    const $  = (sel) => document.querySelector(sel);
-    const $$ = (sel) => Array.from(document.querySelectorAll(sel));
-
-    const fsapiWarning     = $("#fc-fsapi-warning");
-    const selectedPathText = $("#fc-selected-path-label");
-    const saveHint         = $("#fc-save-hint");
-    const saveError        = $("#fc-save-error");
-
-    const resMode        = $("#fc-res-mode");
-    const resDuration    = $("#fc-res-duration");
-    const resWriteSpeed  = $("#fc-res-write-speed");
-    const resReadSpeed   = $("#fc-res-read-speed");
-    const resWritten     = $("#fc-res-written-bytes");
-    const resVerified    = $("#fc-res-verified-bytes");
-
-    const btnPickDir  = $("#fc-btn-pick-directory");
-    const btnClearSel = $("#fc-btn-clear-selection");
-    const btnStart    = $("#fc-btn-start-tests");
-    const btnCancel   = $("#fc-btn-cancel-tests");
-    const modeTiles   = $$("#fc-mode-grid .fc-mode-tile");
-
-    // Login-Indikator
-    if (cfg.loggedIn && saveHint) {
-        saveHint.style.display = "block";
-    }
-
-    // --- Test-Engine (Browser) ---------------------------------------------
-
-    class UsbBrowserTester {
-        constructor() {
-            this.rootHandle        = null;
-            this.abortController   = null;
-            this.capacityBytes     = null;
-            this.capacityProbeFile = "usbcheck_capacity_probe.bin";
-        }
-
-        hasFsApiSupport() {
-            return "showDirectoryPicker" in window;
-        }
-
-        async pickDirectory() {
-            if (!this.hasFsApiSupport()) {
-                throw new Error(t("fake_ui.error_fsapi_not_supported", "File System Access API wird von diesem Browser nicht unterstützt."));
-            }
-            const handle = await window.showDirectoryPicker();
-            this.rootHandle = handle;
-            return handle;
-        }
-
-        async clearSelection() {
-            this.rootHandle = null;
-            this.capacityBytes = null;
-        }
-
-        // Freispeicher-Ermittlung
-        async ensureCapacity(abortSignal) {
-            if (this.capacityBytes != null) return this.capacityBytes;
-            if (!this.rootHandle) {
-                throw new Error(t("fake_ui.error_no_directory_selected", "Kein Verzeichnis ausgewählt."));
-            }
-
-            const dirHandle = this.rootHandle;
-            const PROBE_FILENAME = this.capacityProbeFile;
-            const CHUNK_SIZE = 1024 * 1024; // 1 MiB
-            const MAX_BYTES  = 128 * 1024 * 1024; // max. 128 MiB testen
-
-            logLine(t("fake_ui.log_capacity_probe_start", "Ermittle verfügbaren Speicherplatz im gewählten Verzeichnis..."), "info");
-
-            let bytesWritten = 0;
-            let writable = null;
-
-            try {
-                const fileHandle = await dirHandle.getFileHandle(PROBE_FILENAME, { create: true });
-                writable = await fileHandle.createWritable();
-
-                const chunk = new Uint8Array(CHUNK_SIZE);
-                chunk.fill(0x5a);
-
-                while (bytesWritten + CHUNK_SIZE <= MAX_BYTES) {
-                    if (abortSignal && abortSignal.aborted) {
-                        await writable.abort();
-                        throw new DOMException("Abgebrochen", "AbortError");
-                    }
-
-                    await writable.write(chunk);
-                    bytesWritten += CHUNK_SIZE;
-                }
-
-                await writable.close();
-            } catch (err) {
-                if (writable) {
-                    try { await writable.close(); } catch (e) {}
-                }
-                if (err && err.name === "AbortError") {
-                    throw err;
-                }
-                // sonst: „Out of space“ → okay, wir nehmen bytesWritten als Limit
-            } finally {
-                try {
-                    await dirHandle.removeEntry(PROBE_FILENAME);
-                } catch (e) {
-                    // egal
-                }
-            }
-
-            if (!bytesWritten) {
-                throw new Error(t("fake_ui.error_no_space_detected", "Es konnte kein freier Speicher im gewählten Verzeichnis reserviert werden."));
-            }
-
-            this.capacityBytes = bytesWritten;
-            logLine(
-                tFmt(
-                    "fake_ui.log_capacity_probe_result",
-                    "Ermittelter für Tests nutzbarer Speicher: {size} (Schreibprobe).",
-                    { size: formatBytes(bytesWritten) }
-                ),
-                "info"
-            );
-
-            return this.capacityBytes;
-        }
-
-        planSizeBytes({ defaultMB, minMB, maxFraction }) {
-            const MiB = 1024 * 1024;
-            const cap = this.capacityBytes || (64 * MiB);
-
-            const minBytes      = (minMB || 1) * MiB;
-            const defaultBytes  = (defaultMB || 8) * MiB;
-            const maxBytesByCap = Math.max(minBytes, cap * (maxFraction || 0.25));
-
-            let target = Math.min(defaultBytes, maxBytesByCap);
-
-            const CHUNK_SIZE = MiB;
-            target = Math.floor(target / CHUNK_SIZE) * CHUNK_SIZE;
-            if (target < CHUNK_SIZE) target = CHUNK_SIZE;
-
-            return target;
-        }
-
-        // Quick-Check
-        async runQuickCheck(report, progressCb, abortSignal) {
-            const TEST_FILENAME = "usbcheck_quick_test.bin";
-            const CHUNK_SIZE    = 1024 * 1024;
-
-            const dirHandle = this.rootHandle;
-            if (!dirHandle) throw new Error(t("fake_ui.error_no_directory_selected", "Kein Verzeichnis ausgewählt."));
-
-            const totalBytes = this.planSizeBytes({
-                defaultMB: 8,
-                minMB: 1,
-                maxFraction: 0.25
-            });
-
-            logLine(
-                tFmt(
-                    "fake_ui.log_quick_prepare",
-                    "Quick-Check: Vorbereitung... (Testgröße: {size})",
-                    { size: formatBytes(totalBytes) }
-                ),
-                "info"
-            );
-
-            const fileHandle = await dirHandle.getFileHandle(TEST_FILENAME, { create: true });
-            const writable   = await fileHandle.createWritable();
-
-            let writtenBytes = 0;
-
-            const writeStart = performance.now();
-            while (writtenBytes < totalBytes) {
-                if (abortSignal.aborted) {
-                    await writable.abort();
-                    throw new DOMException("Abgebrochen", "AbortError");
-                }
-                const remaining = totalBytes - writtenBytes;
-                const chunkLen  = Math.min(CHUNK_SIZE, remaining);
-                const chunk     = new Uint8Array(chunkLen);
-                for (let i = 0; i < chunkLen; i++) {
-                    chunk[i] = (i + writtenBytes) % 251;
-                }
-                await writable.write(chunk);
-                writtenBytes += chunkLen;
-                progressCb((writtenBytes / totalBytes) * 100 * 0.5);
-            }
-            await writable.close();
-            const writeEnd = performance.now();
-
-            logLine(t("fake_ui.log_quick_verify_start", "Quick-Check: Schreiben abgeschlossen. Verifiziere Daten..."), "info");
-
-            const file = await fileHandle.getFile();
-            const readStart = performance.now();
-
-            const reader = file.stream().getReader();
-            let offset = 0;
-            let verifiedBytes = 0;
-            while (true) {
-                if (abortSignal.aborted) {
-                    reader.cancel();
-                    throw new DOMException("Abgebrochen", "AbortError");
-                }
-                const { done, value } = await reader.read();
-                if (done) break;
-                const chunk = value;
-                for (let i = 0; i < chunk.length; i++) {
-                    const expected = (offset + i) % 251;
-                    if (chunk[i] !== expected) {
-                        logLine(
-                            tFmt(
-                                "fake_ui.log_quick_data_error",
-                                "Quick-Check: Datenfehler bei Byte {byte}",
-                                { byte: (offset + i).toString() }
-                            ),
-                            "error"
-                        );
-                        throw new Error(
-                            tFmt(
-                                "fake_ui.error_quick_data_error",
-                                "Datenfehler im Quick-Check bei Byte {byte}",
-                                { byte: (offset + i).toString() }
-                            )
-                        );
-                    }
-                }
-                offset += chunk.length;
-                verifiedBytes += chunk.length;
-                progressCb(50 + (verifiedBytes / totalBytes) * 100 * 0.5);
-            }
-
-            const readEnd = performance.now();
-
-            const writeSeconds = (writeEnd - writeStart) / 1000;
-            const readSeconds  = (readEnd - readStart) / 1000;
-
-            report.quick = {
-                mode: "quick",
-                test_file: TEST_FILENAME,
-                size_bytes: totalBytes,
-                write_bytes: writtenBytes,
-                read_bytes: verifiedBytes,
-                write_duration_s: writeSeconds,
-                read_duration_s: readSeconds,
-                write_mbit_s: writeSeconds ? (writtenBytes * 8 / (writeSeconds * 1e6)) : null,
-                read_mbit_s:  readSeconds  ? (verifiedBytes * 8 / (readSeconds * 1e6)) : null,
-                ok: true
-            };
-
-            try {
-                await dirHandle.removeEntry(TEST_FILENAME);
-            } catch (e) {
-                logLine(t("fake_ui.log_quick_delete_warn", "Quick-Check: Konnte Testdatei nicht löschen (nicht kritisch)."), "warn");
-            }
-
-            logLine(t("fake_ui.log_quick_success", "Quick-Check: Erfolgreich abgeschlossen."), "info");
-        }
-
-        // Benchmark
-        async runBenchmark(report, progressCb, abortSignal) {
-            const TEST_FILENAME = "usbcheck_benchmark.bin";
-            const CHUNK_SIZE    = 1024 * 1024;
-
-            const dirHandle = this.rootHandle;
-            if (!dirHandle) throw new Error(t("fake_ui.error_no_directory_selected", "Kein Verzeichnis ausgewählt."));
-
-            const totalBytes = this.planSizeBytes({
-                defaultMB: 32,
-                minMB: 4,
-                maxFraction: 0.5
-            });
-
-            logLine(
-                tFmt(
-                    "fake_ui.log_bench_start",
-                    "Benchmark: Start – schreibe Testdatei ({size})...",
-                    { size: formatBytes(totalBytes) }
-                ),
-                "info"
-            );
-
-            const fileHandle = await dirHandle.getFileHandle(TEST_FILENAME, { create: true });
-            const writable   = await fileHandle.createWritable();
-
-            let writtenBytes = 0;
-
-            const writeStart = performance.now();
-            while (writtenBytes < totalBytes) {
-                if (abortSignal.aborted) {
-                    await writable.abort();
-                    throw new DOMException("Abgebrochen", "AbortError");
-                }
-                const remaining = totalBytes - writtenBytes;
-                const chunkLen  = Math.min(CHUNK_SIZE, remaining);
-                const chunk     = new Uint8Array(chunkLen);
-                for (let i = 0; i < chunkLen; i++) {
-                    chunk[i] = 0xaa;
-                }
-                await writable.write(chunk);
-                writtenBytes += chunkLen;
-                progressCb((writtenBytes / totalBytes) * 100 * 0.4);
-            }
-            await writable.close();
-            const writeEnd = performance.now();
-
-            logLine(t("fake_ui.log_bench_read_start", "Benchmark: Lesen & Timing..."), "info");
-
-            const file = await fileHandle.getFile();
-            const readStart = performance.now();
-            const reader = file.stream().getReader();
-            let readBytes = 0;
-            while (true) {
-                if (abortSignal.aborted) {
-                    reader.cancel();
-                    throw new DOMException("Abgebrochen", "AbortError");
-                }
-                const { done, value } = await reader.read();
-                if (done) break;
-                readBytes += value.length;
-                progressCb(40 + (readBytes / totalBytes) * 100 * 0.6);
-            }
-            const readEnd = performance.now();
-
-            const writeSeconds = (writeEnd - writeStart) / 1000;
-            const readSeconds  = (readEnd - readStart) / 1000;
-
-            report.benchmark = {
-                mode: "benchmark",
-                test_file: TEST_FILENAME,
-                size_bytes: totalBytes,
-                write_bytes: writtenBytes,
-                read_bytes: readBytes,
-                write_duration_s: writeSeconds,
-                read_duration_s: readSeconds,
-                write_mbit_s: writeSeconds ? (writtenBytes * 8 / (writeSeconds * 1e6)) : null,
-                read_mbit_s:  readSeconds  ? (readBytes  * 8 / (readSeconds  * 1e6)) : null,
-                ok: true
-            };
-
-            try {
-                await dirHandle.removeEntry(TEST_FILENAME);
-            } catch (e) {
-                logLine(t("fake_ui.log_bench_delete_warn", "Benchmark: Konnte Testdatei nicht löschen (nicht kritisch)."), "warn");
-            }
-
-            logLine(t("fake_ui.log_bench_success", "Benchmark: Erfolgreich abgeschlossen."), "info");
-        }
-
-        // Write/Verify
-        async runWriteVerify(report, progressCb, abortSignal) {
-            const BASE_FILENAME = "usbcheck_block_";
-            const BLOCKS        = 4;
-            const CHUNK_SIZE    = 1024 * 1024;
-
-            const dirHandle = this.rootHandle;
-            if (!dirHandle) throw new Error(t("fake_ui.error_no_directory_selected", "Kein Verzeichnis ausgewählt."));
-
-            const totalBytesPlanned = this.planSizeBytes({
-                defaultMB: 128,
-                minMB: 8,
-                maxFraction: 0.75
-            });
-
-            const blockBytes = Math.max(
-                CHUNK_SIZE,
-                Math.floor(totalBytesPlanned / BLOCKS / CHUNK_SIZE) * CHUNK_SIZE
-            );
-
-            const totalBytes = blockBytes * BLOCKS;
-
-            logLine(
-                tFmt(
-                    "fake_ui.log_wv_start",
-                    "Write/Verify: Start – {blocks} Blöcke à {size} (gesamt {total})...",
-                    {
-                        blocks: BLOCKS.toString(),
-                        size:   formatBytes(blockBytes),
-                        total:  formatBytes(totalBytes)
-                    }
-                ),
-                "info"
-            );
-
-            let writtenBytes  = 0;
-            let verifiedBytes = 0;
-
-            const globalStart = performance.now();
-            const writeDetails = [];
-            const readDetails  = [];
-
-            for (let b = 0; b < BLOCKS; b++) {
-                const filename = `${BASE_FILENAME}${String(b + 1).padStart(2, "0")}.bin`;
-                logLine(
-                    tFmt(
-                        "fake_ui.log_wv_block_start",
-                        "Write/Verify: Block {num}/{blocks} – {file}",
-                        {
-                            num: (b + 1).toString(),
-                            blocks: BLOCKS.toString(),
-                            file: filename
-                        }
-                    ),
-                    "info"
-                );
-
-                const fileHandle = await dirHandle.getFileHandle(filename, { create: true });
-                const writable   = await fileHandle.createWritable();
-
-                const blockBytesTotal = blockBytes;
-                let blockWritten = 0;
-                const blockWriteStart = performance.now();
-
-                while (blockWritten < blockBytesTotal) {
-                    if (abortSignal.aborted) {
-                        await writable.abort();
-                        throw new DOMException("Abgebrochen", "AbortError");
-                    }
-                    const remaining = blockBytesTotal - blockWritten;
-                    const chunkLen  = Math.min(CHUNK_SIZE, remaining);
-                    const chunk     = new Uint8Array(chunkLen);
-                    for (let i = 0; i < chunkLen; i++) {
-                        chunk[i] = (i + blockWritten + b * 13) % 251;
-                    }
-                    await writable.write(chunk);
-                    blockWritten  += chunkLen;
-                    writtenBytes  += chunkLen;
-                    const progress = (writtenBytes + verifiedBytes) / (totalBytes * 2) * 100;
-                    progressCb(progress);
-                }
-                await writable.close();
-                const blockWriteEnd = performance.now();
-                writeDetails.push({
-                    block: b + 1,
-                    bytes: blockBytesTotal,
-                    duration_s: (blockWriteEnd - blockWriteStart) / 1000
-                });
-
-                const file = await fileHandle.getFile();
-                const reader = file.stream().getReader();
-                let blockOffset = 0;
-                const blockReadStart = performance.now();
-
-                while (true) {
-                    if (abortSignal.aborted) {
-                        reader.cancel();
-                        throw new DOMException("Abgebrochen", "AbortError");
-                    }
-                    const { done, value } = await reader.read();
-                    if (done) break;
-                    const chunk = value;
-                    for (let i = 0; i < chunk.length; i++) {
-                        const expected = (i + blockOffset + b * 13) % 251;
-                        if (chunk[i] !== expected) {
-                            logLine(
-                                tFmt(
-                                    "fake_ui.log_wv_data_error",
-                                    "Write/Verify: Datenfehler in Block {num} bei Byte {byte}",
-                                    {
-                                        num: (b + 1).toString(),
-                                        byte: (blockOffset + i).toString()
-                                    }
-                                ),
-                                "error"
-                            );
-                            throw new Error(
-                                tFmt(
-                                    "fake_ui.error_wv_data_error",
-                                    "Datenfehler in Block {num} bei Byte {byte}",
-                                    {
-                                        num: (b + 1).toString(),
-                                        byte: (blockOffset + i).toString()
-                                    }
-                                )
-                            );
-                        }
-                    }
-                    blockOffset   += chunk.length;
-                    verifiedBytes += chunk.length;
-                    const progress = (writtenBytes + verifiedBytes) / (totalBytes * 2) * 100;
-                    progressCb(progress);
-                }
-                const blockReadEnd = performance.now();
-                readDetails.push({
-                    block: b + 1,
-                    bytes: blockBytesTotal,
-                    duration_s: (blockReadEnd - blockReadStart) / 1000
-                });
-
-                try {
-                    await dirHandle.removeEntry(filename);
-                } catch (e) {
-                    logLine(
-                        tFmt(
-                            "fake_ui.log_wv_delete_warn",
-                            "Write/Verify: Konnte Blockdatei {file} nicht löschen (nicht kritisch).",
-                            { file: filename }
-                        ),
-                        "warn"
-                    );
-                }
-            }
-
-            const globalEnd = performance.now();
-            const totalDuration = (globalEnd - globalStart) / 1000;
-
-            const sumWrite = writeDetails.reduce((acc, d) => acc + d.bytes, 0);
-            const sumRead  = readDetails.reduce((acc, d) => acc + d.bytes, 0);
-            const writeSec = writeDetails.reduce((acc, d) => acc + d.duration_s, 0);
-            const readSec  = readDetails.reduce((acc, d) => acc + d.duration_s, 0);
-
-            report.writeverify = {
-                mode: "writeverify",
-                blocks: BLOCKS,
-                block_size_bytes: blockBytes,
-                total_bytes: totalBytes,
-                written_bytes: writtenBytes,
-                verified_bytes: verifiedBytes,
-                write_duration_s: writeSec,
-                read_duration_s: readSec,
-                write_mbit_s: writeSec ? (sumWrite * 8 / (writeSec * 1e6)) : null,
-                read_mbit_s:  readSec  ? (sumRead  * 8 / (readSec  * 1e6)) : null,
-                ok: true
-            };
-
-            report.writeverify_total_duration_s = totalDuration;
-
-            logLine(t("fake_ui.log_wv_success", "Write/Verify: Alle Blöcke erfolgreich verifiziert."), "info");
-        }
-
-        async run(mode, updateProgressCb, abortSignal) {
-            if (!this.rootHandle) {
-                throw new Error(t("fake_ui.error_no_directory_selected", "Kein Verzeichnis ausgewählt."));
-            }
-
-            await this.ensureCapacity(abortSignal);
-
-            const report = {
-                meta: {
-                    base_url: cfg.baseUrl || "",
-                    locale:   cfg.locale || "en",
-                    user_agent: navigator.userAgent,
-                    started_at: new Date().toISOString()
-                },
-                tool: "usbcheck_browser",
-                tool_version: "0.1.0",
-                mode_requested: mode,
-                quick: null,
-                benchmark: null,
-                writeverify: null,
-                total_duration_s: null
-            };
-
-            const t0 = performance.now();
-
-            if (mode === "quick") {
-                await this.runQuickCheck(report, updateProgressCb, abortSignal);
-            } else if (mode === "benchmark") {
-                await this.runBenchmark(report, updateProgressCb, abortSignal);
-            } else if (mode === "writeverify") {
-                await this.runWriteVerify(report, updateProgressCb, abortSignal);
-            } else if (mode === "all") {
-                const modes = ["quick", "benchmark", "writeverify"];
-                for (let i = 0; i < modes.length; i++) {
-                    const subMode = modes[i];
-                    logLine(
-                        tFmt(
-                            "fake_ui.log_all_subtest_start",
-                            "All-Inclusive: Starte Teiltest \"{mode}\" ({num}/{total})...",
-                            {
-                                mode: subMode,
-                                num: (i + 1).toString(),
-                                total: modes.length.toString()
-                            }
-                        ),
-                        "info"
-                    );
-
-                    const base  = (i / modes.length) * 100;
-                    const span  = (1 / modes.length) * 100;
-                    const mapProgress = (p) => {
-                        const mapped = base + (p / 100) * span;
-                        updateProgressCb(mapped);
-                    };
-
-                    if (subMode === "quick") {
-                        await this.runQuickCheck(report, mapProgress, abortSignal);
-                    } else if (subMode === "benchmark") {
-                        await this.runBenchmark(report, mapProgress, abortSignal);
-                    } else if (subMode === "writeverify") {
-                        await this.runWriteVerify(report, mapProgress, abortSignal);
-                    }
-                }
-            } else {
-                throw new Error(tFmt("fake_ui.error_unknown_mode", "Unbekannter Modus: {mode}", { mode }));
-            }
-
-            const t1 = performance.now();
-            report.total_duration_s = (t1 - t0) / 1000;
-            report.meta.ended_at = new Date().toISOString();
-
-            return report;
-        }
-    }
-
-    const tester = new UsbBrowserTester();
-    let currentMode = null;
-    let isRunning   = false;
-
-    if (!tester.hasFsApiSupport()) {
-        if (fsapiWarning) fsapiWarning.style.display = "block";
-        logLine(
-            t("fake_ui.log_fsapi_partial", "Dein Browser unterstützt die File System Access API nicht voll. Einige Funktionen sind deaktiviert."),
-            "warn"
-        );
-    }
-
-    function updateStartButtonState() {
-        const hasDir  = !!tester.rootHandle;
-        const hasMode = !!currentMode;
-        if (btnStart)  btnStart.disabled  = !(hasDir && hasMode && !isRunning);
-        if (btnCancel) btnCancel.disabled = !isRunning;
-    }
-
-    // --- Event-Handler ------------------------------------------------------
-
-    let isPickingDir = false;
-
-    if (btnPickDir) {
-        btnPickDir.addEventListener("click", () => {
-            if (isPickingDir) return;
-            isPickingDir = true;
-
-            if (!("showDirectoryPicker" in window)) {
-                logLine(t("fake_ui.error_fsapi_not_supported", "File System Access API wird von diesem Browser nicht unterstützt."), "error");
-                if (fsapiWarning) fsapiWarning.style.display = "block";
-                isPickingDir = false;
-                return;
-            }
-
-            window.showDirectoryPicker()
-                .then((handle) => {
-                    tester.rootHandle    = handle;
-                    tester.capacityBytes = null;
-
-                    if (selectedPathText) {
-                        selectedPathText.textContent = tFmt(
-                            "fake_ui.selected_path_label",
-                            'USB-Ordner ausgewählt (Name: "{name}").',
-                            { name: (handle.name || "Unbekannt") }
-                        );
-                    }
-                    if (btnClearSel) btnClearSel.disabled = false;
-                    setStatus(t("fake_ui.status_dir_selected", "USB-Verzeichnis ausgewählt. Wähle jetzt einen Testmodus."));
-                    logLine(
-                        tFmt(
-                            "fake_ui.log_dir_selected",
-                            "Verzeichnis ausgewählt: {name}",
-                            { name: (handle.name || "[ohne Namen]") }
-                        ),
-                        "info"
-                    );
-                    updateStartButtonState();
-                })
-                .catch((err) => {
-                    if (err && err.name === "AbortError") {
-                        logLine(t("fake_ui.log_pick_abort", "Verzeichnisauswahl abgebrochen."), "warn");
-                    } else if (err) {
-                        logLine(
-                            tFmt(
-                                "fake_ui.log_pick_error",
-                                "Fehler bei Verzeichnisauswahl: {msg}",
-                                { msg: err.message || "unbekannt" }
-                            ),
-                            "error"
-                        );
-                    } else {
-                        logLine(t("fake_ui.log_pick_error_unknown", "Unbekannter Fehler bei Verzeichnisauswahl."), "error");
-                    }
-                })
-                .finally(() => {
-                    isPickingDir = false;
-                });
-        });
-    }
-
-    if (btnClearSel) {
-        btnClearSel.addEventListener("click", async () => {
-            await tester.clearSelection();
-            if (selectedPathText) {
-                selectedPathText.textContent = t("fake_ui.selected_path_none", "Noch kein Verzeichnis gewählt.");
-            }
-            btnClearSel.disabled = true;
-            setStatus(t("fake_ui.status_ready", "Bereit. Wähle zuerst deinen USB-Stick aus."));
-            logLine(t("fake_ui.log_dir_reset", "Verzeichnisauswahl zurückgesetzt."), "info");
-            updateStartButtonState();
-        });
-    }
-
-    modeTiles.forEach((tile) => {
-        tile.addEventListener("click", () => {
-            if (tile.classList.contains("disabled")) return;
-            if (isRunning) return;
-            modeTiles.forEach((tEl) => tEl.classList.remove("selected"));
-            tile.classList.add("selected");
-            currentMode = tile.getAttribute("data-mode");
-            const titleEl = tile.querySelector("h4");
-            const label = titleEl ? titleEl.textContent : currentMode;
-            setModeLabel(label || "");
-            setStatus(
-                tFmt(
-                    "fake_ui.status_mode_selected",
-                    'Modus "{mode}" ausgewählt. Du kannst den Test jetzt starten.',
-                    { mode: label || currentMode || "" }
-                )
-            );
-            logLine(
-                tFmt(
-                    "fake_ui.log_mode_selected",
-                    "Modus gewählt: {mode}",
-                    { mode: currentMode || "" }
-                ),
-                "info"
-            );
-            updateStartButtonState();
-        });
-    });
-
-    if (btnStart) {
-        btnStart.addEventListener("click", async () => {
-            if (!currentMode || !tester.rootHandle || isRunning) return;
-            isRunning = true;
-            updateStartButtonState();
-            if (btnCancel) btnCancel.disabled = false;
-            if (saveError) saveError.style.display = "none";
-            setProgress(0);
-            logLine(
-                tFmt(
-                    "fake_ui.log_test_start",
-                    "Starte Tests im Modus: {mode}",
-                    { mode: (currentMode || "").toUpperCase() }
-                ),
-                "info"
-            );
-            setStatus(t("fake_ui.status_running", "Test läuft... bitte USB-Stick nicht entfernen."));
-            setOverallStatus("warn", t("fake_ui.overall_running", "Test läuft..."));
-
-            const abortController = new AbortController();
-            tester.abortController = abortController;
-
-            const updateProgressCb = (percent) => setProgress(percent);
-            let report = null;
-
-            try {
-                report = await tester.run(currentMode, updateProgressCb, abortController.signal);
-
-                setProgress(100);
-                setStatus(t("fake_ui.status_done", "Test abgeschlossen."));
-                setOverallStatus("ok", t("fake_ui.overall_done", "Browser-Test erfolgreich abgeschlossen."));
-                applyReportToDashboard(report);
-
-                console.log("USB Browser Test Report (fakecheck):", report);
-
-                await saveReportToBackend(report);
-            } catch (err) {
-                if (err && err.name === "AbortError") {
-                    setStatus(t("fake_ui.status_aborted", "Test wurde abgebrochen."));
-                    setOverallStatus("warn", t("fake_ui.overall_aborted", "Test abgebrochen."));
-                    logLine(t("fake_ui.log_test_aborted", "Test wurde vom Benutzer abgebrochen."), "warn");
-                } else if (err) {
-                    setStatus(
-                        tFmt(
-                            "fake_ui.status_error",
-                            "Fehler: {msg}",
-                            { msg: err.message || "unbekannt" }
-                        )
-                    );
-                    setOverallStatus("bad", t("fake_ui.overall_error", "Fehler im Browser-Test."));
-                    logLine(
-                        tFmt(
-                            "fake_ui.log_test_error",
-                            "Fehler im Test: {msg}",
-                            { msg: err.message || "unbekannt" }
-                        ),
-                        "error"
-                    );
-                } else {
-                    setStatus(t("fake_ui.status_error_unknown", "Unbekannter Fehler im Test."));
-                    setOverallStatus("bad", t("fake_ui.overall_error", "Fehler im Browser-Test."));
-                    logLine(t("fake_ui.log_test_error_unknown", "Unbekannter Fehler im Test."), "error");
-                }
-            } finally {
-                isRunning = false;
-                tester.abortController = null;
-                updateStartButtonState();
-                if (btnCancel) btnCancel.disabled = true;
-            }
-        });
-    }
-
-    if (btnCancel) {
-        btnCancel.addEventListener("click", () => {
-            if (!isRunning || !tester.abortController) return;
-            tester.abortController.abort();
-        });
-    }
-
-    // --- Dashboard-Füllung --------------------------------------------------
-
-    function applyReportToDashboard(report) {
-        const modeLabelMap = {
-            quick: t("fake_ui.mode_quick", "Quick-Check"),
-            benchmark: t("fake_ui.mode_benchmark", "Benchmark"),
-            writeverify: t("fake_ui.mode_writeverify", "Write & Verify"),
-            all: t("fake_ui.mode_all", "All-Inclusive (alle Browser-Tests)")
-        };
-
-        if (resMode) {
-            resMode.textContent = modeLabelMap[report.mode_requested] || report.mode_requested || "–";
-        }
-        if (resDuration) {
-            resDuration.textContent = formatDuration(report.total_duration_s);
-        }
-
-        let aggWriteBytes = 0;
-        let aggReadBytes  = 0;
-        let writeSec = 0;
-        let readSec  = 0;
-
-        if (report.quick) {
-            aggWriteBytes += report.quick.write_bytes || 0;
-            aggReadBytes  += report.quick.read_bytes  || 0;
-            writeSec      += report.quick.write_duration_s || 0;
-            readSec       += report.quick.read_duration_s  || 0;
-        }
-        if (report.benchmark) {
-            aggWriteBytes += report.benchmark.write_bytes || 0;
-            aggReadBytes  += report.benchmark.read_bytes  || 0;
-            writeSec      += report.benchmark.write_duration_s || 0;
-            readSec       += report.benchmark.read_duration_s  || 0;
-        }
-        if (report.writeverify) {
-            aggWriteBytes += report.writeverify.written_bytes || 0;
-            aggReadBytes  += report.writeverify.verified_bytes || 0;
-            writeSec      += report.writeverify.write_duration_s || 0;
-            readSec       += report.writeverify.read_duration_s  || 0;
-        }
-
-        if (resWritten) {
-            resWritten.textContent = aggWriteBytes ? formatBytes(aggWriteBytes) : "–";
-        }
-        if (resVerified) {
-            resVerified.textContent = aggReadBytes ? formatBytes(aggReadBytes) : "–";
-        }
-
-        const avgWriteMbps = (aggWriteBytes && writeSec) ? formatMbps(aggWriteBytes, writeSec) : "–";
-        const avgReadMbps  = (aggReadBytes  && readSec)  ? formatMbps(aggReadBytes,  readSec)  : "–";
-
-        if (resWriteSpeed) resWriteSpeed.textContent = avgWriteMbps;
-        if (resReadSpeed)  resReadSpeed.textContent  = avgReadMbps;
-    }
-
-    // --- Backend-Speicherung ------------------------------------------------
-
-    async function saveReportToBackend(report) {
-        // apiBase kommt aus fakecheck.core.js (detectApiBase)
-        const apiBase = (cfg && cfg.apiBase) ? cfg.apiBase : "";
-        const base    = apiBase.replace(/\/+$/, "");
-        // v1-Endpunkt
-        const url     = base ? (base + "/v1/browser.quick.test") : "/api/v1/browser.quick.test";
-
-        try {
-            const response = await fetch(url, {
-                method: "POST",
-                headers: {
-                    "Content-Type": "application/json"
-                },
-                body: JSON.stringify(report),
-                credentials: "include"
-            });
-
-            if (!response.ok) {
-                const msg = "HTTP " + response.status;
-                logLine(
-                    tFmt(
-                        "fake_ui.log_backend_save_error_status",
-                        "Backend: Konnte Ergebnis nicht speichern ({status}).",
-                        { status: msg }
-                    ),
-                    "warn"
-                );
-                if (response.status >= 500 && saveError) {
-                    saveError.style.display = "block";
-                }
-                return;
-            }
-
-            const data = await response.json().catch(() => null);
-
-            if (!data || data.ok !== true) {
-                logLine(
-                    tFmt(
-                        "fake_ui.log_backend_save_error_payload",
-                        "Backend: Testergebnis wurde nicht bestätigt{suffix}.",
-                        {
-                            suffix: data && data.error
-                                ? ` (${data.error})`
-                                : ""
-                        }
-                    ),
-                    "warn"
-                );
-                if (saveError) saveError.style.display = "block";
-                return;
-            }
-
-            logLine(
-                tFmt(
-                    "fake_ui.log_backend_save_ok",
-                    "Backend: Testergebnis gespeichert{suffix}",
-                    { suffix: (data && data.id ? ` (ID: ${data.id})` : "") }
-                ),
-                "info"
-            );
-        } catch (err) {
-            if (saveError) saveError.style.display = "block";
-            logLine(
-                tFmt(
-                    "fake_ui.log_backend_save_error",
-                    "Fehler beim Speichern im Backend: {msg}",
-                    { msg: err ? err.message || "unbekannt" : "unbekannt" }
-                ),
-                "error"
-            );
-        }
-    }
-
-    // --- Initialzustand -----------------------------------------------------
-
-    setStatus(t("fake_ui.status_ready", "Bereit. Wähle zuerst deinen USB-Stick aus."));
-    setModeLabel(t("fake_ui.status_mode_none", "Kein Modus selektiert"));
-    setOverallStatus("ok", t("fake_ui.overall_initial", "Noch kein Test durchgeführt."));
-    logLine(
-        t("fake_ui.log_loaded", "USB-Browser-Test (fakecheck) geladen. Warte auf Verzeichnisauswahl und Modus."),
-        "info"
-    );
-    updateStartButtonState();
-})();

public/assets/js/fakecheck/fakecheck.core.js

@@ -1,168 +0,0 @@
-// /public/assets/js/fakecheck/fakecheck.core.js
-
-(function() {
-
-    // Namespace
-    window.usbcheck = window.usbcheck || {};
-    const usbcheck = window.usbcheck;
-
-    const cfg = window.usbConfig || {};
-
-    // URL-Detection
-    function detectApiBaseUrl() {
-        const host = window.location.hostname || "";
-        if (host === "staging.usbcheck.it" || host.endsWith(".staging.usbcheck.it")) {
-            return "https://api.staging.usbcheck.it";
-        }
-        return "https://api.usbcheck.it";
-    }
-
-    // Locale aus Config:
-    // - bevorzugt fakecheck.locale (aus PHP fakecheck-Block)
-    // - sonst cfg.lang
-    const locale =
-        (cfg.fakecheck && cfg.fakecheck.locale)
-        || cfg.lang
-        || "en";
-
-    // Config bereitstellen
-    usbcheck.cfg = {
-        // wenn fakecheck.baseUrl vorhanden ist → bevorzugen
-        baseUrl:  (cfg.fakecheck && cfg.fakecheck.baseUrl) || cfg.baseUrl || "",
-        locale:   (locale || "en").toLowerCase(),
-        apiBase:  (cfg.fakecheck && cfg.fakecheck.apiBaseUrl) || cfg.apiBaseUrl || detectApiBaseUrl(),
-        loggedIn: !!cfg.isLoggedIn
-    };
-
-    // -----------------------------------
-    // i18n – JSON laden + Helfer
-    // -----------------------------------
-
-    usbcheck.locale = usbcheck.cfg.locale || "en";
-    usbcheck.i18n   = {};
-
-    function loadI18n() {
-        // Pfad wie bei deinen JSONs: /public/assets/i18n/de.json etc.
-        const assetsBase = cfg.assetsBase || "/assets";
-        const url = assetsBase.replace(/\/+$/, "") + "/i18n/" + usbcheck.locale + ".json";
-
-        fetch(url)
-            .then(res => {
-                if (!res.ok) throw new Error("HTTP " + res.status);
-                return res.json();
-            })
-            .then(data => {
-                usbcheck.i18n = data || {};
-                // console.debug("usbcheck i18n loaded:", usbcheck.locale, usbcheck.i18n);
-            })
-            .catch(err => {
-                console.warn("usbcheck i18n konnte nicht geladen werden:", err);
-                usbcheck.i18n = {};
-            });
-    }
-
-    // Key-Lookup: "fake_ui.status_ready"
-    usbcheck.t = function t(key, fallback) {
-        if (!key) return (fallback != null ? fallback : "");
-        const parts = String(key).split(".");
-        let cur = usbcheck.i18n;
-        for (let i = 0; i < parts.length; i++) {
-            const p = parts[i];
-            if (!cur || typeof cur !== "object" || !(p in cur)) {
-                return (fallback != null ? fallback : key);
-            }
-            cur = cur[p];
-        }
-        if (cur == null) return (fallback != null ? fallback : key);
-        return cur;
-    };
-
-    // Format-Variante mit Platzhaltern {name}, {mode}, {size}, ...
-    usbcheck.tFmt = function tFmt(key, fallback, vars) {
-        let str = usbcheck.t(key, fallback);
-        if (!vars) return str;
-        for (const k in vars) {
-            if (!Object.prototype.hasOwnProperty.call(vars, k)) continue;
-            const re = new RegExp("\\{" + k.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&") + "\\}", "g");
-            str = str.replace(re, vars[k]);
-        }
-        return str;
-    };
-
-    // direkt beim Laden JSON holen
-    loadI18n();
-
-
-    // ---------- Hilfsfunktionen ----------
-    usbcheck.log = function logLine(message, level = "info") {
-        const logEl = document.querySelector("#fc-log");
-        if (!logEl) return;
-        const line = document.createElement("div");
-        line.className = "fc-log-line";
-        const prefix =
-            level === "error" ? "[ERROR] " :
-            level === "warn"  ? "[WARN]  " :
-                                 "[INFO]  ";
-        line.innerHTML = `<strong>${prefix}</strong>${message}`;
-        logEl.appendChild(line);
-        logEl.scrollTop = logEl.scrollHeight;
-    };
-
-    usbcheck.setStatus = function(msg) {
-        const el = document.querySelector("#fc-status-text");
-        if (el) el.textContent = msg;
-    };
-
-    usbcheck.setModeLabel = function(msg) {
-        const el = document.querySelector("#fc-status-mode");
-        if (el) el.textContent = msg;
-    };
-
-    usbcheck.setProgress = function(percent) {
-        const el = document.querySelector("#fc-progress-inner");
-        if (!el) return;
-        const v = Math.min(100, Math.max(0, percent));
-        el.style.width = v + "%";
-    };
-
-    usbcheck.setOverallStatus = function(state, text) {
-        const pill = document.querySelector("#fc-overall-status-pill");
-        const label = document.querySelector("#fc-overall-status-text");
-        if (!pill || !label) return;
-
-        pill.classList.remove("fc-pill-ok","fc-pill-warn","fc-pill-bad");
-
-        if (state === "ok") pill.classList.add("fc-pill-ok");
-        else if (state === "warn") pill.classList.add("fc-pill-warn");
-        else pill.classList.add("fc-pill-bad");
-
-        label.textContent = text;
-    };
-
-    usbcheck.formatBytes = function(bytes) {
-        if (bytes == null) return "–";
-        const units = ["B", "KB", "MB", "GB", "TB"];
-        let u = 0, v = bytes;
-        while (v >= 1024 && u < units.length - 1) { v /= 1024; u++; }
-        return v.toFixed(1) + " " + units[u];
-    };
-
-    usbcheck.formatMbps = function(bytes, seconds) {
-        if (!seconds || seconds <= 0) return "–";
-        const mbits = (bytes * 8) / 1e6;
-        return mbits.toFixed(1) + " Mbit/s";
-    };
-
-    usbcheck.formatDuration = function(seconds) {
-        if (!seconds) return "–";
-        const s = Math.round(seconds);
-        if (s < 60) return s + " s";
-        const m = Math.floor(s / 60);
-        const r = s % 60;
-        if (m < 60) return `${m} min ${r}s`;
-        const h = Math.floor(m / 60);
-        const rm = m % 60;
-        return `${h} h ${rm} min`;
-    };
-
-})();

public/assets/js/fakecheck/fakecheck.serial.js

@@ -1,184 +0,0 @@
-// /public/assets/js/fakecheck/fakecheck.serial.js
-
-(function () {
-    if (!window.usbcheck) return;
-
-    const {
-        cfg,
-        t,
-        tFmt,
-        log: logLine
-    } = window.usbcheck;
-
-    const rootSc = document.getElementById("serialcheck-root");
-    if (!rootSc) return; // Partial nicht eingebunden → nichts tun
-
-    // Elemente
-    const form      = rootSc.querySelector("#serialcheck-form");
-    const errorBox  = rootSc.querySelector("#serialcheck-error");
-    const resultBox = rootSc.querySelector("#serialcheck-result");
-
-    const manufacturerInput = rootSc.querySelector("#sc-manufacturer");
-    const vidInput          = rootSc.querySelector("#sc-vid");
-    const pidInput          = rootSc.querySelector("#sc-pid");
-    const serialInput       = rootSc.querySelector("#sc-serial");
-
-    // API-Basis:
-    // - cfg.apiBase kommt aus fakecheck.core.js (z.B. https://api.usbcheck.it)
-    // - wir hängen /v1/quickcheck dran
-    // - Fallback: /api/v1/quickcheck auf demselben Host
-    const apiBaseRaw = (cfg && cfg.apiBase) ? cfg.apiBase : "";
-    const apiBase    = apiBaseRaw.replace(/\/+$/, "");
-    const apiUrl     = apiBase ? (apiBase + "/v1/quickcheck") : "/api/v1/quickcheck";
-
-    // -------------------------------------------------------
-    // Fehleranzeige
-    // -------------------------------------------------------
-    function showScError(msgKey, fallback, vars = {}) {
-        if (!errorBox) return;
-        const msg = tFmt(msgKey, fallback, vars);
-        errorBox.textContent = msg;
-        errorBox.classList.remove("hidden");
-        if (resultBox) resultBox.classList.add("hidden");
-    }
-
-    function clearScError() {
-        if (!errorBox) return;
-        errorBox.classList.add("hidden");
-        errorBox.textContent = "";
-    }
-
-    // -------------------------------------------------------
-    // Ergebnis rendern
-    // -------------------------------------------------------
-    function renderScResult(data) {
-        if (!resultBox) return;
-
-        clearScError();
-        resultBox.classList.remove("hidden");
-
-        const rating = data.rating || "unknown";
-        const input  = data.input || {};
-        const vendorInfo  = data.vendor_detected || {};
-        const serialInfo  = data.serial_analysis || {};
-        const consistency = data.consistency || {};
-
-        // Rating → Label + Beschreibung
-        const ratingLabel = t(`serial.rating.${rating}.label`, rating);
-        const ratingDesc  = t(`serial.rating.${rating}.desc`, "");
-
-        // Auffälligkeiten
-        const issues = serialInfo.issues || [];
-        const issuesHtml = issues.length
-            ? '<ul class="list-disc list-inside mt-1">' +
-                issues.map(i => `<li>${i}</li>`).join("") +
-              '</ul>'
-            : `<span class="text-emerald-600 text-[11px]">${t("serial.issues_none", "Keine besonderen Auffälligkeiten.")}</span>`;
-
-        // Vendor
-        const vendorLine = vendorInfo.found
-            ? tFmt("serial.vendor_detected", "{vendor} (VID {vid})", {
-                vendor: vendorInfo.vendor,
-                vid: vendorInfo.vid
-            })
-            : vendorInfo.vid
-              ? tFmt("serial.vendor_unknown", "Unbekannter Hersteller für VID {vid}", { vid: vendorInfo.vid })
-              : t("serial.vendor_none", "Keine Vendor-ID angegeben");
-
-        // Konsistenz-Notizen
-        const notes = consistency.notes || [];
-        const notesHtml = notes.length
-            ? '<ul class="list-disc list-inside mt-1 text-[11px]">' +
-                notes.map(n => `<li>${n}</li>`).join("") +
-              '</ul>'
-            : "";
-
-        // HTML einsetzen
-        resultBox.innerHTML = `
-            <div class="mb-3">
-                <span class="inline-flex items-center rounded-full px-3 py-1 text-[11px] font-semibold
-                    ${rating === "ok" ? "bg-emerald-100 text-emerald-800" : ""}
-                    ${rating === "needs_review" ? "bg-amber-100 text-amber-800" : ""}
-                    ${rating === "suspicious" ? "bg-red-100 text-red-800" : ""}
-                    ${rating === "invalid" ? "bg-slate-100 text-slate-700" : ""}
-                ">
-                    ${t("serial.rating_label", "Bewertung")}: ${ratingLabel}
-                </span>
-                <p class="mt-1 text-xs text-slate-600 dark:text-slate-300">${ratingDesc}</p>
-            </div>
-
-            <div class="border border-slate-200 dark:border-slate-700 rounded-xl p-3 mb-3">
-                <h3 class="text-xs font-semibold mb-1">${t("serial.heading_input", "Eingabedaten")}</h3>
-                <dl class="text-[11px] space-y-1 text-slate-600 dark:text-slate-300">
-                    <div><dt class="font-medium">${t("serial.input.manufacturer", "Hersteller (Angabe):")}</dt><dd>${input.manufacturer || '<span class="text-slate-400">' + t("serial.none", "keine Angabe") + '</span>'}</dd></div>
-                    <div><dt class="font-medium">${t("serial.input.vidpid", "VID/PID:")}</dt><dd>${(input.vid || "–") + " / " + (input.pid || "–")}</dd></div>
-                    <div><dt class="font-medium">${t("serial.input.vendor_detected", "Vendor aus VID:")}</dt><dd>${vendorLine}</dd></div>
-                </dl>
-            </div>
-
-            <div class="border border-slate-200 dark:border-slate-700 rounded-xl p-3 mb-3">
-                <h3 class="text-xs font-semibold mb-1">${t("serial.heading_analysis", "Seriennummer-Analyse")}</h3>
-                <dl class="text-[11px] space-y-1 text-slate-600 dark:text-slate-300">
-                    <div><dt class="font-medium">${t("serial.analysis.serial", "Seriennummer:")}</dt><dd><code class="text-[10px] bg-slate-100 dark:bg-slate-800 px-1.5 py-0.5 rounded">${serialInfo.serial || ""}</code></dd></div>
-                    <div><dt class="font-medium">${t("serial.analysis.length", "Länge:")}</dt><dd>${serialInfo.length || 0} ${t("serial.chars", "Zeichen")}</dd></div>
-                    <div><dt class="font-medium">${t("serial.analysis.category", "Kategorie:")}</dt><dd>${serialInfo.category || "-"}</dd></div>
-                    <div><dt class="font-medium">${t("serial.analysis.score", "Score:")}</dt><dd>${typeof serialInfo.score === "number" ? serialInfo.score : "-"} / 100</dd></div>
-                    <div><dt class="font-medium">${t("serial.analysis.issues", "Auffälligkeiten:")}</dt><dd>${issuesHtml}</dd></div>
-                </dl>
-            </div>
-
-            <div class="border border-slate-200 dark:border-slate-700 rounded-xl p-3">
-                <h3 class="text-xs font-semibold mb-1">${t("serial.heading_consistency", "Hersteller-Konsistenz")}</h3>
-                ${notesHtml}
-                <p class="mt-2 text-[10px] text-slate-500">
-                    ${t("serial.disclaimer", "Diese Einschätzung basiert auf Heuristiken und kann keine Echtheit garantieren.")}
-                </p>
-            </div>
-        `;
-    }
-
-    // -------------------------------------------------------
-    // Submit-Handler
-    // -------------------------------------------------------
-    if (!form) return;
-
-    form.addEventListener("submit", (e) => {
-        e.preventDefault();
-        clearScError();
-        if (resultBox) resultBox.classList.add("hidden");
-
-        const payload = {
-            manufacturer: manufacturerInput ? manufacturerInput.value.trim() : "",
-            vid:          vidInput ? vidInput.value.trim() : "",
-            pid:          pidInput ? pidInput.value.trim() : "",
-            serial:       serialInput ? serialInput.value.trim() : ""
-        };
-
-        if (!payload.serial) {
-            showScError("serial.error.no_serial", "Bitte gib eine Seriennummer ein.");
-            return;
-        }
-
-        fetch(apiUrl, {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify(payload)
-        })
-        .then(res => {
-            if (!res.ok) {
-                throw new Error("HTTP " + res.status);
-            }
-            return res.json();
-        })
-        .then(data => {
-            if (!data || !data.success) {
-                throw new Error((data && data.error) || t("serial.error.unknown", "Unerwartete Antwort vom Server."));
-            }
-            renderScResult(data);
-        })
-        .catch(err => {
-            showScError("serial.error.api", "Fehler bei der Prüfung: {msg}", { msg: err.message });
-        });
-    });
-
-})();

public/assets/js/header.js

@@ -1,188 +0,0 @@
-// public/assets/js/header.js
-document.addEventListener("DOMContentLoaded", function () {
-    const cfg        = window.usbConfig || {};
-    const i18nCfg    = cfg.i18n || {};
-    const availLangs = i18nCfg.available || {};
-    const availCodes = Object.keys(availLangs);
-
-    function normalizeLang(code) {
-        if (!code) return "";
-        return String(code).slice(0, 2).toLowerCase();
-    }
-
-    function detectBrowserLang() {
-        const nav = window.navigator || {};
-        const candidates = [];
-
-        if (Array.isArray(nav.languages)) {
-            candidates.push(...nav.languages);
-        }
-        if (typeof nav.language === "string") {
-            candidates.push(nav.language);
-        }
-        if (typeof nav.userLanguage === "string") {
-            candidates.push(nav.userLanguage);
-        }
-
-        for (const raw of candidates) {
-            const code = normalizeLang(raw);
-            if (availCodes.includes(code)) {
-                return code;
-            }
-        }
-        return null;
-    }
-
-    function resolveCurrentLang() {
-        const url     = new URL(window.location.href);
-        const urlLang = normalizeLang(url.searchParams.get("lang"));
-
-        // 1) ?lang
-        if (urlLang && availCodes.includes(urlLang)) {
-            return urlLang;
-        }
-
-        // 2) Browsersprache
-        const browserLang = detectBrowserLang();
-        if (browserLang) {
-            return browserLang;
-        }
-
-        // 3) EN
-        if (availCodes.includes("en")) {
-            return "en";
-        }
-
-        if (availCodes.length > 0) {
-            return availCodes[0];
-        }
-
-        return "en";
-    }
-
-    // LOGIN-BUTTON
-    const loginBtn = document.getElementById("loginButton");
-
-    if (loginBtn) {
-        loginBtn.addEventListener("click", function (event) {
-            event.preventDefault();
-
-            const currentPath  = window.location.pathname || "/";
-            const currentQuery = window.location.search || "";
-            const redirect     = currentPath + currentQuery;
-
-            const lang = resolveCurrentLang();
-
-            if (currentPath === "/login" || currentPath === "/login/") {
-                const authEl = document.getElementById("auth");
-                if (authEl) {
-                    authEl.scrollIntoView({ behavior: "smooth", block: "start" });
-                }
-                return;
-            }
-
-            const url = "/login/?lang=" + encodeURIComponent(lang) +
-                "&redirect=" + encodeURIComponent(redirect) +
-                "#auth";
-
-            window.location.href = url;
-        });
-    }
-
-    // AVATAR-MENÜ & LOGOUT wie gehabt (deine bestehende Logik)
-    const avatarBtn = document.getElementById("userAvatar");
-    const userMenu  = document.getElementById("userMenu");
-
-    if (avatarBtn && userMenu) {
-        avatarBtn.addEventListener("click", function (event) {
-            event.stopPropagation();
-            userMenu.classList.toggle("hidden");
-
-            const expanded = avatarBtn.getAttribute("aria-expanded") === "true";
-            avatarBtn.setAttribute("aria-expanded", expanded ? "false" : "true");
-        });
-
-        document.addEventListener("click", function (event) {
-            if (userMenu.classList.contains("hidden")) {
-                return;
-            }
-
-            const clickedInsideMenu   = userMenu.contains(event.target);
-            const clickedAvatarButton = avatarBtn.contains(event.target);
-
-            if (!clickedInsideMenu && !clickedAvatarButton) {
-                userMenu.classList.add("hidden");
-                avatarBtn.setAttribute("aria-expanded", "false");
-            }
-        });
-    }
-
-    const logoutButtons = document.querySelectorAll('[data-logout-link="true"]');
-    const backdrop      = document.getElementById("logoutModalBackdrop");
-    const btnConfirm    = document.getElementById("logoutConfirm");
-    const btnCancel     = document.getElementById("logoutCancel");
-
-    let logoutTarget = null;
-
-    function showLogoutModal(targetHref) {
-        logoutTarget = targetHref || null;
-        if (!backdrop) return;
-
-        backdrop.classList.remove("hidden");
-        document.body.classList.add("overflow-hidden");
-    }
-
-    function hideLogoutModal() {
-        if (!backdrop) return;
-        backdrop.classList.add("hidden");
-        document.body.classList.remove("overflow-hidden");
-        logoutTarget = null;
-    }
-
-    if (logoutButtons.length && backdrop && btnConfirm && btnCancel) {
-        logoutButtons.forEach(function (btn) {
-            btn.addEventListener("click", function (event) {
-                event.preventDefault();
-                event.stopPropagation();
-
-                const href = btn.getAttribute("data-logout-href")
-                    || btn.getAttribute("href")
-                    || "/auth/logout";
-
-                showLogoutModal(href);
-
-                if (userMenu && !userMenu.classList.contains("hidden")) {
-                    userMenu.classList.add("hidden");
-                    if (avatarBtn) {
-                        avatarBtn.setAttribute("aria-expanded", "false");
-                    }
-                }
-            });
-        });
-
-        btnConfirm.addEventListener("click", function () {
-            if (logoutTarget) {
-                window.location.href = logoutTarget;
-            } else {
-                window.location.href = "/auth/logout";
-            }
-        });
-
-        btnCancel.addEventListener("click", function () {
-            hideLogoutModal();
-        });
-
-        backdrop.addEventListener("click", function (event) {
-            const card = backdrop.querySelector(".max-w-sm");
-            if (card && !card.contains(event.target)) {
-                hideLogoutModal();
-            }
-        });
-
-        document.addEventListener("keydown", function (event) {
-            if (event.key === "Escape" && !backdrop.classList.contains("hidden")) {
-                hideLogoutModal();
-            }
-        });
-    }
-});

public/assets/js/lang.js

@@ -1,214 +0,0 @@
-// public/assets/js/lang.js
-(function () {
-  const usbConfig  = window.usbConfig || {};
-  const i18nConfig = usbConfig.i18n || {};
-
-  const availableLangs = i18nConfig.available || {};
-  const supportedLangs = Object.keys(availableLangs);
-
-  let currentLang = "en";
-  let translations = {};
-
-  function flattenTranslations(obj, target = {}) {
-    Object.keys(obj || {}).forEach((key) => {
-      const val = obj[key];
-      if (val && typeof val === "object" && !Array.isArray(val)) {
-        flattenTranslations(val, target);
-      } else {
-        target[key] = val;
-      }
-    });
-    return target;
-  }
-
-  function applyDomainPlaceholders(text) {
-    if (typeof text !== "string") return text;
-
-    const domains = usbConfig.domains || window.appDomains || {};
-    const replacements = {
-      "{{primary_domain}}": domains.primaryDomain || "usbcheck.it",
-      "{{primary_url}}":
-        domains.primaryUrl ||
-        "https://" + (domains.primaryDomain || "usbcheck.it"),
-      "{{fakecheck_domain}}": domains.fakecheckDomain || "ismyusbfake.com",
-      "{{fakecheck_url}}":
-        domains.fakecheckUrl ||
-        "https://" + (domains.fakecheckDomain || "ismyusbfake.com"),
-    };
-
-    return Object.keys(replacements).reduce((acc, token) => {
-      const value = replacements[token];
-      return acc.split(token).join(value);
-    }, text);
-  }
-
-  function detectBrowserLang() {
-    const nav = window.navigator || {};
-    const candidates = [];
-
-    if (Array.isArray(nav.languages)) {
-      candidates.push(...nav.languages);
-    }
-    if (typeof nav.language === "string") {
-      candidates.push(nav.language);
-    }
-    if (typeof nav.userLanguage === "string") {
-      candidates.push(nav.userLanguage);
-    }
-
-    for (const raw of candidates) {
-      const code = (raw || "").slice(0, 2).toLowerCase();
-      if (supportedLangs.includes(code)) {
-        return code;
-      }
-    }
-    return null;
-  }
-
-  // *** Deine Priorität:
-  // 1) ?lang
-  // 2) Browser
-  // 3) en
-  function getInitialLang() {
-    const urlParams = new URLSearchParams(window.location.search);
-    const paramLang = (urlParams.get("lang") || "").toLowerCase();
-
-    // 1) URL-Parameter
-    if (paramLang && supportedLangs.includes(paramLang)) {
-      return paramLang;
-    }
-
-    // 2) Browsersprache
-    const browser = detectBrowserLang();
-    if (browser) {
-      return browser;
-    }
-
-    // 3) EN (immer vorhanden laut deiner Vorgabe)
-    if (supportedLangs.includes("en")) {
-      return "en";
-    }
-
-    // Sicherheitsfallback
-    if (supportedLangs.length > 0) {
-      return supportedLangs[0];
-    }
-
-    return "en";
-  }
-
-  async function loadLangFile(lang) {
-    const code = (lang || "").toLowerCase();
-    if (!supportedLangs.includes(code)) {
-      console.warn("i18n: unsupported language in loadLangFile:", code);
-      translations = {};
-      return;
-    }
-
-    try {
-      const res = await fetch(`/assets/i18n/${code}.json`, { cache: "no-store" });
-      if (!res.ok) throw new Error(`Failed to load /assets/i18n/${code}.json`);
-      const raw = await res.json();
-      translations = flattenTranslations(raw);
-    } catch (err) {
-      console.error("i18n load error:", err);
-      translations = {};
-    }
-  }
-
-  function applyTranslations() {
-    document.documentElement.setAttribute("lang", currentLang);
-
-    document.querySelectorAll("[data-i18n]").forEach((node) => {
-      const key = node.getAttribute("data-i18n");
-      if (!key) return;
-      let value = translations[key];
-      if (typeof value !== "string") return;
-
-      if (value.includes("{year}")) {
-        const year = new Date().getFullYear();
-        value = value.replace("{year}", year);
-      }
-
-      value = applyDomainPlaceholders(value);
-      node.innerHTML = value;
-    });
-  }
-
-  function updateLangCurrentLabel(lang) {
-    const code = (lang || "").toLowerCase();
-
-    const info = availableLangs[code] || {
-      code: code || "en",
-      label: (code || "en").toUpperCase(),
-      flag: "",
-    };
-
-    const node =
-      document.getElementById("langCurrentLabel") ||
-      document.getElementById("langCurrent");
-    if (!node) return;
-
-    const flag = info.flag || "";
-    const label = info.label || info.code.toUpperCase();
-
-    if (flag) {
-      node.innerHTML = `<span class="mr-1.5">${flag}</span><span>${label}</span>`;
-    } else {
-      node.textContent = label;
-    }
-  }
-
-  // Wenn du später mal explizit via JS Sprache setzen willst
-  // (z.B. beim Klick auf ein eigenes UI-Element), kannst du:
-  function setLang(lang) {
-    const code = (lang || "").toLowerCase();
-    if (!supportedLangs.includes(code)) {
-      console.warn("Unsupported language:", code, supportedLangs);
-      return;
-    }
-
-    const url = new URL(window.location.href);
-    url.searchParams.set("lang", code);
-    window.location.href = url.toString();
-  }
-
-  document.addEventListener("DOMContentLoaded", async function () {
-    currentLang = getInitialLang();
-    updateLangCurrentLabel(currentLang);
-
-    await loadLangFile(currentLang);
-    applyTranslations();
-
-    const langCurrent = document.getElementById("langCurrent");
-    const langMenu = document.getElementById("langMenu");
-
-    if (langCurrent && langMenu) {
-      langCurrent.addEventListener("click", function (e) {
-        e.stopPropagation();
-        langMenu.classList.toggle("hidden");
-      });
-
-      document.addEventListener("click", function (e) {
-        if (!langMenu.classList.contains("hidden")) {
-          if (!langMenu.contains(e.target) && !langCurrent.contains(e.target)) {
-            langMenu.classList.add("hidden");
-          }
-        }
-      });
-    }
-
-    // Nur falls du später data-lang in .lang-pill nutzt,
-    // im aktuellen header.php kommen die Links ja direkt mit ?lang=... aus PHP.
-    document.addEventListener("click", function (e) {
-      const btn = e.target.closest(".lang-pill");
-      if (!btn) return;
-
-      const targetLang = btn.getAttribute("data-lang");
-      if (!targetLang) return;
-
-      e.preventDefault();
-      setLang(targetLang);
-    });
-  });
-})();

public/auth/login.php

@@ -1,4 +0,0 @@
-<?php
-// Gemeinsame Bootstrap-/Config-Datei laden
-//require __DIR__ . '/../../config/fileload.php';  // Pfad ggf. anpassen
-require_once $_SERVER['DOCUMENT_ROOT']. '/../src/auth/login.php';

public/auth/logout.php

@@ -1,5 +0,0 @@
-<?php
-// Gemeinsame Bootstrap-/Config-Datei laden
-//require __DIR__ . '/../../config/fileload.php';  // Pfad ggf. anpassen
-require_once $_SERVER['DOCUMENT_ROOT']. '/../config/fileload.php';
-require_once $_SERVER['DOCUMENT_ROOT']. '/../src/auth/logout.php';

public/auth/register.php

@@ -1,4 +0,0 @@
-<?php
-// Gemeinsame Bootstrap-/Config-Datei laden
-//require __DIR__ . '/../../config/fileload.php';  // Pfad ggf. anpassen
-require_once $_SERVER['DOCUMENT_ROOT']. '/../src/auth/register.php';

public/css/comingsoon.css

@@ -0,0 +1,171 @@
+/* Base layout */
+* {
+    box-sizing: border-box;
+}
+
+body {
+    margin: 0;
+    font-family: 'Inter', system-ui, -apple-system, BlinkMacSystemFont, sans-serif;
+    background:
+        radial-gradient(circle at top left, rgba(0, 81, 255, 0.35), transparent 55%),
+        radial-gradient(circle at bottom right, rgba(200, 203, 208, 0.25), transparent 55%),
+        #0b0b0d;
+    color: #FFFFFF;
+    min-height: 100vh;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+}
+
+/* Page wrapper */
+.page {
+    position: relative;
+    width: 100%;
+    max-width: 960px;
+    padding: 24px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+}
+
+/* Subtle background glow */
+.glow {
+    position: absolute;
+    inset: 0;
+    pointer-events: none;
+    background:
+        radial-gradient(circle at 10% 10%, rgba(0, 81, 255, 0.35), transparent 55%),
+        radial-gradient(circle at 90% 90%, rgba(3, 193, 96, 0.20), transparent 50%);
+    opacity: 0.75;
+    z-index: 0;
+}
+
+/* Card container */
+.card {
+    position: relative;
+    z-index: 1;
+    max-width: 720px;
+    width: 100%;
+    padding: 32px 32px 28px;
+    border-radius: 18px;
+    background: linear-gradient(
+        135deg,
+        rgba(26, 26, 26, 0.96),
+        rgba(11, 11, 13, 0.98)
+    );
+    box-shadow:
+        0 18px 45px rgba(0, 0, 0, 0.65),
+        0 0 0 1px rgba(200, 203, 208, 0.08);
+    text-align: left;
+    overflow: hidden;
+}
+
+/* Accent bar oben */
+.card::before {
+    content: "";
+    position: absolute;
+    top: 0;
+    left: 12%;
+    right: 12%;
+    height: 3px;
+    border-radius: 999px;
+    background: linear-gradient(90deg, #0051FF, #03C160);
+    opacity: 0.9;
+}
+
+/* Logo */
+.logo {
+    display: block;
+    max-width: 260px;
+    width: 60%;
+    margin-bottom: 24px;
+    filter:
+        drop-shadow(0 8px 24px rgba(0, 0, 0, 0.6))
+        drop-shadow(0 0 14px rgba(200, 203, 208, 0.45));
+}
+
+/* Heading & text */
+h1 {
+    font-family: 'Montserrat', system-ui, sans-serif;
+    font-weight: 700; /* Montserrat Bold */
+    font-size: clamp(2.1rem, 2.6vw, 2.6rem);
+    margin: 0 0 12px;
+    letter-spacing: 0.04em;
+    color: #FFFFFF;
+}
+
+.lead {
+    margin: 0 0 22px;
+    font-size: 1.05rem;
+    line-height: 1.7;
+    color: #F4F4F4;
+}
+
+/* Pills / Badges */
+.pill-row {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 10px;
+    margin-bottom: 20px;
+}
+
+.pill {
+    display: inline-flex;
+    align-items: center;
+    padding: 6px 12px;
+    border-radius: 999px;
+    font-size: 0.82rem;
+    font-family: 'Montserrat', system-ui, sans-serif;
+    font-weight: 600; /* Montserrat SemiBold */
+    letter-spacing: 0.02em;
+    border: 1px solid rgba(200, 203, 208, 0.28);
+    background: rgba(26, 26, 26, 0.85);
+    color: #FFFFFF;
+    backdrop-filter: blur(8px);
+}
+
+.pill-safe {
+    border-color: rgba(3, 193, 96, 0.55);
+    box-shadow: 0 0 12px rgba(3, 193, 96, 0.45);
+}
+
+.pill-size {
+    border-color: rgba(0, 81, 255, 0.6);
+    box-shadow: 0 0 12px rgba(0, 81, 255, 0.45);
+}
+
+.pill-fake {
+    border-color: rgba(230, 57, 70, 0.6);
+    box-shadow: 0 0 12px rgba(230, 57, 70, 0.45);
+}
+
+/* Footer note */
+.note {
+    margin: 0;
+    font-size: 0.9rem;
+    line-height: 1.6;
+    color: #C8CBD0; /* silver */
+}
+
+/* Responsive tweaks */
+@media (max-width: 640px) {
+    .card {
+        padding: 24px 20px 22px;
+        text-align: left;
+    }
+
+    .card::before {
+        left: 16px;
+        right: 16px;
+    }
+
+    .logo {
+        max-width: 220px;
+        width: 70%;
+        margin-bottom: 20px;
+    }
+
+    .pill-row {
+        flex-direction: row;
+    }
+}

public/index.php

@@ -1,22 +1,47 @@
-<?php
-$pageKey = 'main';
-$GLOBALS['pageKey'] = $pageKey;
-require_once dirname(__DIR__) . '/config/fileload.php';
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>usbcheck.it – Coming Soon</title>
 
-// User-Dummy (später über Login ersetzen)
-$userInitials = null;
+    <!-- Google Fonts -->
+    <link href="https://fonts.googleapis.com/css2?family=Montserrat:wght@600;700&family=Inter:wght@300;400&display=swap" rel="stylesheet">
 
-// Seitentitel & Description für das Layout
-$pageTitle = app_primary_domain() . ' – Test USB-Sticks';
-$pageDescription = 'Prüfe deine USB-Sticks auf Geschwindigkeit, Integrität und mögliche Fakes – direkt im Browser.';
+    <!-- Main CSS -->
+    <link rel="stylesheet" href="css/comingsoon.css">
+</head>
+<body>
 
-tpl('layout_start');                  // structure/header.php
+<div class="page">
+    <div class="glow"></div>
 
-tpl('hero',     'landing', 'main'); 
-tpl('how',      'landing', 'main'); 
-tpl('problem',  'landing', 'main');
-tpl('features', 'landing', 'main'); 
-tpl('security', 'landing', 'main'); 
-tpl('faq',      'landing', 'main'); 
+    <main class="card">
+        <img
+            src="img/logo_slogan.png"
+            alt="usbcheck.it – Test USB drives for fakes"
+            class="logo"
+        >
 
-tpl('layout_end');                  // structure/footer.php
+        <h1>Coming soon.</h1>
+
+        <p class="lead">
+            Soon you’ll be able to verify if your USB drives are genuine –  
+            with quick online checks and deeper tests using our desktop tool.
+        </p>
+
+        <div class="pill-row">
+            <span class="pill pill-safe">Secure checks</span>
+            <span class="pill pill-size">Real capacity tests</span>
+            <span class="pill pill-fake">Detect fake USB sticks</span>
+        </div>
+
+        <p class="note">
+            This service is currently under development.  
+            Stay tuned – usbcheck.it will be online shortly.
+        </p>
+    </main>
+</div>
+
+</body>
+</html>

public/landingpage/dashboard/index.php

@@ -1,46 +0,0 @@
-<?php
-// public/dashboard/index.php
-$pageKey = 'dashboard';
-$GLOBALS['pageKey'] = $pageKey;
-require_once $_SERVER['DOCUMENT_ROOT']. '/../config/fileload.php';
-
-
-
-// User aus Session holen
-$currentUser = $_SESSION['user'] ?? null;
-$isLoggedIn  = is_array($currentUser) && !empty($currentUser['id']);
-
-// Wenn nicht eingeloggt → zurück zur Login-Seite mit Redirect zurück zum Dashboard
-if (!$isLoggedIn) {
-    if (function_exists('flash_set')) {
-        flash_set('error', 'Bitte melde dich zuerst an.', 'login');
-    }
-
-    $loginUrl = '/login/?lang=' . urlencode($lang) .
-                '&view=login' .
-                '&redirect=' . urlencode('/dashboard/');
-
-    header('Location: ' . $loginUrl);
-    exit;
-}
-
-// Seitentitel & Description
-$pageTitle       = 'Dashboard – ' . app_primary_domain();
-$pageDescription = 'Verwalte deine USB-Tests, Geräte und Pro-Einstellungen in deinem USBCheck-Dashboard.';
-
-// Navigation kannst du für das Dashboard leer lassen oder anpassen
-$navAnchors = [];
-
-// Optional: spezielles Dashboard-JS laden (Platzhalter)
-if (function_exists('tpl_add_script')) {
-    tpl_add_script('/assets/js/dashboard.js', 'footer', true, false, '', null);
-}
-
-// Layout-Start
-tpl('layout_start', 'structure');
-
-// Dashboard-Content
-tpl('dashboard', 'landing', 'dashboard');
-
-// Layout-Ende
-tpl('layout_end', 'structure');

public/landingpage/fakecheck/index.php

@@ -1,39 +0,0 @@
-<?php
-$pageKey = 'fakecheck';
-$GLOBALS['pageKey'] = $pageKey;
-/*
- * USBCheck Fake USB Check - Landingpage
- * --------------------------------------*/
-require_once $_SERVER['DOCUMENT_ROOT']. '/../config/fileload.php';
-
-
-// public/fakecheck/index.php
-
-
-// User-Dummy (später über Login ersetzen)
-$userInitials = null;
-
-// Seitentitel & Description (SEO)
-$pageTitle = app_primary_domain() . ' – Fake USB Check';
-$pageDescription = 'Fake USB-Sticks erkennen: Browser-basierter Schnelltest für Kapazität, Schreib-/Lesegeschwindigkeit und Datenintegrität – ohne Installation.';
-
-// Header-Navigation: auf dieser Seite KEINE Onepager-Anchors anzeigen
-$lang = $GLOBALS['lang'] ?? 'en';
-
-// Basis-URL für Reports
-$baseUrl = app_primary_url();
-
-if (function_exists('tpl_add_script')) {
-    tpl_add_script('/assets/js/fakecheck.js', 'footer', true, false, '', null);
-}
-if (function_exists('tpl_add_style')) {
-    tpl_add_style('/assets/css/fakecheck.css', 'header');
-}
-?>
-<?php tpl('layout_start', 'structure'); ?>
-
-<?php tpl('hero',     'landing', 'fakecheck'); ?>
-<?php tpl('webcheck', 'landing', 'fakecheck'); ?>
-
-
-<?php tpl('layout_end', 'structure'); ?>

public/landingpage/login/index.php

@@ -1,32 +0,0 @@
-<?php
-// Auth-/Account-Seite: spezifische Styles registrieren
-if (function_exists('tpl_add_style')) {
-    tpl_add_style('/assets/css/auth.css', 'late');
-}
-
-$pageKey = 'login';
-$GLOBALS['pageKey'] = $pageKey;
-require_once $_SERVER['DOCUMENT_ROOT']. '/../config/fileload.php';
-
-tpl_add_script('/assets/js/auth.js', 'footer', true, false, '', 'auth-1');
-
-// später: echte Session
-$userInitials = null;
-
-$pageTitle = 'Login – ' . app_primary_domain();
-$pageDescription = 'Melde dich bei USBCheck an, um Tests zu speichern, Pro-Modus zu nutzen und mehrere Geräte zu verwalten.';
-
-// Navigation ausblenden:
-$navAnchors = [];
-
-// Welche Ansicht? login | register
-$authView = ($_GET['mode'] ?? 'login') === 'register' ? 'register' : 'login';
-
-tpl('layout_start', 'structure');
-
-// Login-/Register-Section
-// $authView wird in der Partial verfügbar sein
-tpl('login', 'landing', 'login');
-
-tpl('layout_end', 'structure');
-

public/landingpage/tools/debug/boost.php

@@ -1,10 +0,0 @@
-<?php
-require_once $_SERVER['DOCUMENT_ROOT']. '/../config/fileload.php';
-
-echo "<pre>";
-echo "Lang: " . htmlspecialchars($GLOBALS['lang']) . "\n";
-echo "Available:\n";
-print_r($GLOBALS['availableLangs']);
-
-echo "\nTitle landing: " . i18n_get('pages.landing.meta.title', 'NO TITLE');
-echo "\n</pre>";

public/landingpage/tools/debug/lang.php

@@ -1,25 +0,0 @@
-<?php
-// public/debug/lang.php
-
-// 1) Rohheader anzeigen
-header('Content-Type: text/plain; charset=utf-8');
-
-echo "=== HTTP_ACCEPT_LANGUAGE ===\n";
-echo ($_SERVER['HTTP_ACCEPT_LANGUAGE'] ?? "(nicht gesetzt)") . "\n\n";
-
-// 2) fileload.php einbinden (macht Session + i18n + functions.php)
-require_once $_SERVER['DOCUMENT_ROOT']. '/../config/fileload.php';
-
-echo "=== Ergebnis aus fileload.php ===\n";
-echo "Gewähltes \$lang: " . ($GLOBALS['lang'] ?? '(kein lang)') . "\n\n";
-
-echo "=== Verfügbare Sprachen (\$availableLangs) ===\n";
-print_r($GLOBALS['availableLangs'] ?? []);
-
-echo "\n=== Aktive Sprachdatei (i18n.current.meta) ===\n";
-$current = $GLOBALS['i18n']['current'] ?? [];
-if (isset($current['meta'])) {
-    print_r($current['meta']);
-} else {
-    echo "(kein meta in current)\n";
-}

public/landingpage/tools/i18n.php

@@ -1,16 +0,0 @@
-<?php
-declare(strict_types=1);
-
-// Header GANZ am Anfang, bevor IRGENDWAS ausgegeben wird
-header('Content-Type: text/plain; charset=utf-8');
-
-// Optional: Fehlerausgabe für dieses Tool
-ini_set('display_errors', '1');
-ini_set('display_startup_errors', '1');
-error_reporting(E_ALL);
-
-// Projektbasis ermitteln: /public/landingpages/tools -> / (Projektroot)
-$baseDir = $_SERVER['DOCUMENT_ROOT'];
-// Tool-Script einbinden und ausführen
-require_once $baseDir . '/../tools/i18n_collect_keys.php';
-// eof

sql.schema

@@ -1,166 +0,0 @@
--- ============================================================
--- USERS – Benutzerkonto + spätere Rechnungs-/Zahlungsinfos
--- ============================================================
-
-CREATE TABLE IF NOT EXISTS users (
-    id BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
-    
-    -- Login
-    username VARCHAR(50) NOT NULL UNIQUE,
-    email VARCHAR(150) NOT NULL UNIQUE,
-    password_hash VARCHAR(255) NOT NULL,
-    avatar_path VARCHAR(255) NULL,
-
-    -- Persönliche Daten
-    first_name VARCHAR(100) NULL,
-    last_name VARCHAR(100) NULL,
-
-    -- spätere Rechnungsdaten / Billing
-    company_name VARCHAR(255) NULL,
-    street VARCHAR(255) NULL,
-    postal_code VARCHAR(20) NULL,
-    city VARCHAR(255) NULL,
-    country VARCHAR(100) NULL,
-    vat_id VARCHAR(50) NULL,
-
-    -- spätere Pro-Features / Limits
-    plan ENUM('free', 'pro', 'enterprise') DEFAULT 'free',
-    plan_valid_until DATETIME NULL,
-
-    -- Sicherheit
-    created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    updated_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
-    last_login_at DATETIME NULL,
-    failed_logins INT DEFAULT 0,
-    is_locked TINYINT(1) DEFAULT 0
-) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
-
-
--- ============================================================
--- USB DEVICES – vom Nutzer gespeicherte USB-Sticks
--- Ein Benutzer kann mehrere Sticks speichern.
--- ============================================================
-
-CREATE TABLE IF NOT EXISTS usb_devices (
-    id BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
-    user_id BIGINT UNSIGNED NOT NULL,
-
-    serial_number VARCHAR(255) NULL,
-    manufacturer VARCHAR(255) NULL,
-    model_name VARCHAR(255) NULL,
-    usb_type ENUM('USB 2.0', 'USB 3.0', 'USB 3.1', 'USB 3.2', 'USB 4.0') NULL,
-
-    capacity_bytes BIGINT UNSIGNED NULL,
-    advertised_capacity_bytes BIGINT UNSIGNED NULL,
-
-    read_speed_mbps FLOAT NULL,
-    write_speed_mbps FLOAT NULL,
-
-    created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    updated_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
-        ON UPDATE CURRENT_TIMESTAMP,
-
-    FOREIGN KEY (user_id) REFERENCES users(id)
-        ON DELETE CASCADE
-);
-
-
--- ============================================================
--- USB TEST RESULTS – Schnelltest + Pro-Test
--- Jedes Testergebnis gehört zu einem Stick.
--- ============================================================
-
-CREATE TABLE IF NOT EXISTS usb_tests (
-    id BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
-    usb_device_id BIGINT UNSIGNED NOT NULL,
-    user_id BIGINT UNSIGNED NOT NULL,
-
-    -- Testtyp
-    test_type ENUM('quick', 'standard', 'deep', 'pro') NOT NULL,
-
-    -- Ergebniswerte
-    test_start DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    test_end DATETIME NULL,
-
-    read_speed_mbps FLOAT NULL,
-    write_speed_mbps FLOAT NULL,
-
-    integrity_ok TINYINT(1) NULL,
-    checksum_sha256 VARCHAR(255) NULL,
-
-    -- Pro-Modus Zusatzwerte (f3, badblocks etc.)
-    f3_status ENUM('unknown', 'pass', 'fail', 'warning') DEFAULT 'unknown',
-    f3_real_capacity_bytes BIGINT UNSIGNED NULL,
-    f3_lost_bytes BIGINT UNSIGNED NULL,
-
-    badblocks_errors INT NULL,
-
-    -- Metadaten
-    test_report_json JSON NULL,
-    ip_address VARCHAR(45) NULL, -- ipv6 kompatibel
-
-    created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    updated_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
-        ON UPDATE CURRENT_TIMESTAMP,
-
-    FOREIGN KEY (usb_device_id) REFERENCES usb_devices(id)
-        ON DELETE CASCADE,
-
-    FOREIGN KEY (user_id) REFERENCES users(id)
-        ON DELETE CASCADE
-);
-
-
--- ============================================================
--- WEB QUICKTESTS – Browser-Schnellcheck (Gast + eingeloggt)
--- Ergebnisse können anonym oder usergebunden sein.
--- ============================================================
-
-CREATE TABLE IF NOT EXISTS web_quicktests (
-    id BIGINT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
-
-    -- Zuordnung zum Nutzer (NULL = anonym)
-    user_id BIGINT UNSIGNED NULL,
-    is_logged_in TINYINT(1) NOT NULL DEFAULT 0,
-
-    -- optional: Zuordnung zu einem gespeicherten Stick (falls vorhanden)
-    usb_device_id BIGINT UNSIGNED NULL,
-
-    -- Umgebung (für Statistik / Debug)
-    browser_name VARCHAR(100) NULL,
-    browser_version VARCHAR(50) NULL,
-    os_name VARCHAR(100) NULL,
-    os_version VARCHAR(50) NULL,
-
-    -- Stick-Infos aus dem Schnelldurchlauf (soweit ermittelbar)
-    volume_label VARCHAR(255) NULL,          -- z.B. "USB DISK", "NO NAME"
-    manufacturer VARCHAR(255) NULL,
-    model_name VARCHAR(255) NULL,
-    usb_type ENUM('USB 2.0', 'USB 3.0', 'USB 3.1', 'USB 3.2', 'USB 4.0') NULL,
-
-    -- Kapazitätsdaten (Hersteller vs. gemessen im Schnellcheck)
-    advertised_capacity_bytes BIGINT UNSIGNED NULL,
-    measured_capacity_bytes   BIGINT UNSIGNED NULL,
-
-    capacity_status ENUM('unknown', 'ok', 'suspicious', 'fake')
-        NOT NULL DEFAULT 'unknown',
-
-    filesystem VARCHAR(64) NULL,
-
-    -- Detaildaten (z.B. Block-Infos, Logs, Messpunkte)
-    test_report_json JSON NULL,
-
-    -- Meta
-    ip_address VARCHAR(45) NULL,
-    session_id VARCHAR(64) NULL,
-
-    created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    updated_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
-        ON UPDATE CURRENT_TIMESTAMP,
-
-    FOREIGN KEY (user_id) REFERENCES users(id)
-        ON DELETE CASCADE,
-
-    FOREIGN KEY (usb_device_id) REFERENCES usb_devices(id)
-        ON DELETE CASCADE
-) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

src/Session.php

@@ -1,87 +0,0 @@
-<?php
-// src/Session.php
-
-declare(strict_types=1);
-
-class Session
-{
-    public static function start(): void
-    {
-        if (session_status() !== PHP_SESSION_ACTIVE) {
-            // Etwas härtere Session-Cookies
-            session_set_cookie_params([
-                'lifetime' => 0,
-                'path'     => '/',
-                'secure'   => isset($_SERVER['HTTPS']),
-                'httponly' => true,
-                'samesite' => 'Lax',
-            ]);
-            session_start();
-        }
-    }
-
-    public static function regenerate(): void
-    {
-        if (session_status() === PHP_SESSION_ACTIVE) {
-            session_regenerate_id(true);
-        }
-    }
-
-    public static function set(string $key, mixed $value): void
-    {
-        $_SESSION[$key] = $value;
-    }
-
-    public static function get(string $key, mixed $default = null): mixed
-    {
-        return $_SESSION[$key] ?? $default;
-    }
-
-    public static function remove(string $key): void
-    {
-        unset($_SESSION[$key]);
-    }
-
-    public static function destroy(): void
-    {
-        if (session_status() === PHP_SESSION_ACTIVE) {
-            $_SESSION = [];
-            if (ini_get("session.use_cookies")) {
-                $params = session_get_cookie_params();
-                setcookie(
-                    session_name(),
-                    '',
-                    time() - 42000,
-                    $params["path"],
-                    $params["domain"],
-                    $params["secure"],
-                    $params["httponly"]
-                );
-            }
-            session_destroy();
-        }
-    }
-
-    public static function csrfToken(): string
-    {
-        self::start();
-        if (!isset($_SESSION['_csrf_token'])) {
-            $_SESSION['_csrf_token'] = bin2hex(random_bytes(32));
-        }
-        return $_SESSION['_csrf_token'];
-    }
-
-    public static function validateCsrf(?string $token): bool
-    {
-        self::start();
-        if (!isset($_SESSION['_csrf_token']) || !$token) {
-            return false;
-        }
-        $valid = hash_equals($_SESSION['_csrf_token'], $token);
-        if ($valid) {
-            // Optional: Token nach Benutzung rotieren
-            unset($_SESSION['_csrf_token']);
-        }
-        return $valid;
-    }
-}

src/auth.php

@@ -1,284 +0,0 @@
-<?php
-// src/auth.php
-// Zentrale Auth-Logik: Session, CSRF, Login, Registrierung, aktueller Nutzer
-
-declare(strict_types=1);
-
-require_once __DIR__ . '/../config/db.php'; // Stellt $pdo (PDO) bereit
-
-// --- Session Setup ---
-if (session_status() !== PHP_SESSION_ACTIVE) {
-    $secure = (!empty($_SERVER['HTTPS']) && $_SERVER['HTTPS'] !== 'off');
-    session_set_cookie_params([
-        'lifetime' => 0,
-        'path'     => '/',
-        'domain'   => '',         // Standard: aktuelle Domain
-        'secure'   => $secure,
-        'httponly' => true,
-        'samesite' => 'Lax',
-    ]);
-    session_start();
-}
-
-// --- Sprache ermitteln / speichern ---
-function auth_get_lang(): string {
-    if (!empty($_GET['lang'])) {
-        $_SESSION['lang'] = $_GET['lang'];
-    }
-    if (!empty($_SESSION['lang'])) {
-        return $_SESSION['lang'];
-    }
-    return 'en';
-}
-
-// --- CSRF-Token ---
-function auth_csrf_token(): string {
-    if (empty($_SESSION['csrf_token'])) {
-        $_SESSION['csrf_token'] = bin2hex(random_bytes(32));
-    }
-    return $_SESSION['csrf_token'];
-}
-
-function auth_verify_csrf(?string $token): bool {
-    if (empty($token) || empty($_SESSION['csrf_token'])) {
-        return false;
-    }
-    return hash_equals($_SESSION['csrf_token'], $token);
-}
-
-// --- PDO Helper ---
-function auth_pdo(): PDO {
-    // $pdo kommt aus config/db.php
-    global $pdo;
-    if (!$pdo instanceof PDO) {
-        throw new RuntimeException('Database connection not available.');
-    }
-    return $pdo;
-}
-
-// --- Aktueller User ---
-function auth_current_user(): ?array {
-    if (!empty($_SESSION['user_cache']) && is_array($_SESSION['user_cache'])) {
-        return $_SESSION['user_cache'];
-    }
-    if (empty($_SESSION['user_id'])) {
-        return null;
-    }
-    $pdo = auth_pdo();
-    $stmt = $pdo->prepare('SELECT * FROM users WHERE id = :id LIMIT 1');
-    $stmt->execute([':id' => $_SESSION['user_id']]);
-    $user = $stmt->fetch(PDO::FETCH_ASSOC);
-    if (!$user) {
-        return null;
-    }
-    $_SESSION['user_cache'] = $user;
-    return $user;
-}
-
-function auth_require_login(): void {
-    if (!auth_current_user()) {
-        $lang = auth_get_lang();
-        header('Location: /login.php?lang=' . urlencode($lang));
-        exit;
-    }
-}
-
-// --- Avatar-Helfer ---
-function auth_user_initials(array $user): string {
-    $name = $user['full_name'] ?? '';
-    if (trim($name) === '') {
-        $name = $user['username'] ?? $user['email'] ?? 'U';
-    }
-    $parts = preg_split('/\s+/', trim($name));
-    $initials = strtoupper(mb_substr($parts[0], 0, 1));
-    if (count($parts) > 1) {
-        $initials .= strtoupper(mb_substr(end($parts), 0, 1));
-    }
-    return $initials;
-}
-
-function auth_user_avatar_url(array $user): ?string {
-    if (!empty($user['avatar_path'])) {
-        return '/uploads/avatars/' . ltrim($user['avatar_path'], '/');
-    }
-    return null;
-}
-
-// --- Registrierung ---
-function auth_register_user(
-    string $email,
-    string $username,
-    string $fullName,
-    string $password,
-    string $passwordConfirm,
-    string $preferredLang
-): array {
-    $pdo = auth_pdo();
-    $errors = [];
-
-    $email = trim($email);
-    $username = trim($username);
-    $fullName = trim($fullName);
-
-    if (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
-        $errors['email'] = 'Bitte eine gültige E-Mail-Adresse eingeben.';
-    }
-
-    if ($username === '' || !preg_match('/^[a-zA-Z0-9_.-]{3,32}$/', $username)) {
-        $errors['username'] = 'Username muss 3–32 Zeichen lang sein und darf nur Buchstaben, Zahlen, ., _, - enthalten.';
-    }
-
-    if (mb_strlen($fullName) < 3) {
-        $errors['full_name'] = 'Bitte einen vollständigen Namen angeben.';
-    }
-
-    if (mb_strlen($password) < 10) {
-        $errors['password'] = 'Passwort muss mindestens 10 Zeichen lang sein.';
-    }
-
-    if ($password !== $passwordConfirm) {
-        $errors['password_confirm'] = 'Passwörter stimmen nicht überein.';
-    }
-
-    $allowedLangs = ['de', 'en', 'it', 'fr'];
-    if (!in_array($preferredLang, $allowedLangs, true)) {
-        $preferredLang = 'en';
-    }
-
-    // E-Mail / Username bereits vergeben?
-    if (!$errors) {
-        $stmt = $pdo->prepare('SELECT email, username FROM users WHERE email = :email OR username = :username LIMIT 1');
-        $stmt->execute([
-            ':email'    => $email,
-            ':username' => $username,
-        ]);
-        $existing = $stmt->fetch(PDO::FETCH_ASSOC);
-        if ($existing) {
-            if (strcasecmp($existing['email'], $email) === 0) {
-                $errors['email'] = 'Diese E-Mail-Adresse wird bereits verwendet.';
-            }
-            if (strcasecmp($existing['username'], $username) === 0) {
-                $errors['username'] = 'Dieser Username ist bereits vergeben.';
-            }
-        }
-    }
-
-    if ($errors) {
-        return ['success' => false, 'errors' => $errors];
-    }
-
-    $hash = password_hash($password, PASSWORD_DEFAULT);
-    $now = (new DateTimeImmutable('now', new DateTimeZone('UTC')))->format('Y-m-d H:i:s');
-
-    $stmt = $pdo->prepare('
-        INSERT INTO users (email, username, full_name, password_hash, preferred_lang, created_at, updated_at)
-        VALUES (:email, :username, :full_name, :password_hash, :preferred_lang, :created_at, :updated_at)
-    ');
-    $stmt->execute([
-        ':email'         => $email,
-        ':username'      => $username,
-        ':full_name'     => $fullName,
-        ':password_hash' => $hash,
-        ':preferred_lang'=> $preferredLang,
-        ':created_at'    => $now,
-        ':updated_at'    => $now,
-    ]);
-
-    $userId = (int)$pdo->lastInsertId();
-    $_SESSION['user_id'] = $userId;
-    unset($_SESSION['user_cache']); // neu laden beim nächsten Zugriff
-    $_SESSION['lang'] = $preferredLang;
-
-    return ['success' => true, 'errors' => []];
-}
-
-// --- Login ---
-function auth_login(string $login, string $password): array {
-    $pdo = auth_pdo();
-    $errors = [];
-
-    $login = trim($login);
-
-    if ($login === '' || $password === '') {
-        $errors['login'] = 'Bitte Zugangsdaten vollständig ausfüllen.';
-        return ['success' => false, 'errors' => $errors];
-    }
-
-    $stmt = $pdo->prepare('
-        SELECT * FROM users 
-        WHERE email = :login OR username = :login
-        LIMIT 1
-    ');
-    $stmt->execute([':login' => $login]);
-    $user = $stmt->fetch(PDO::FETCH_ASSOC);
-
-    if (!$user || !password_verify($password, $user['password_hash'])) {
-        $errors['login'] = 'E-Mail/Username oder Passwort ist falsch.';
-        return ['success' => false, 'errors' => $errors];
-    }
-
-    $_SESSION['user_id'] = (int)$user['id'];
-    unset($_SESSION['user_cache']);
-    if (!empty($user['preferred_lang'])) {
-        $_SESSION['lang'] = $user['preferred_lang'];
-    }
-
-    // Option: Password-Rehash, wenn Algorithmus veraltet
-    if (password_needs_rehash($user['password_hash'], PASSWORD_DEFAULT)) {
-        $newHash = password_hash($password, PASSWORD_DEFAULT);
-        $upd = $pdo->prepare('UPDATE users SET password_hash = :hash WHERE id = :id');
-        $upd->execute([':hash' => $newHash, ':id' => $user['id']]);
-    }
-
-    return ['success' => true, 'errors' => []];
-}
-
-// --- Profil aktualisieren (Name, Sprache) ---
-function auth_update_profile(int $userId, string $fullName, string $preferredLang): array {
-    $pdo = auth_pdo();
-    $errors = [];
-
-    $fullName = trim($fullName);
-    if (mb_strlen($fullName) < 3) {
-        $errors['full_name'] = 'Bitte einen gültigen Namen angeben.';
-    }
-
-    $allowedLangs = ['de', 'en', 'it', 'fr'];
-    if (!in_array($preferredLang, $allowedLangs, true)) {
-        $preferredLang = 'en';
-    }
-
-    if ($errors) {
-        return ['success' => false, 'errors' => $errors];
-    }
-
-    $now = (new DateTimeImmutable('now', new DateTimeZone('UTC')))->format('Y-m-d H:i:s');
-    $stmt = $pdo->prepare('
-        UPDATE users 
-        SET full_name = :full_name,
-            preferred_lang = :preferred_lang,
-            updated_at = :updated_at
-        WHERE id = :id
-    ');
-    $stmt->execute([
-        ':full_name'     => $fullName,
-        ':preferred_lang'=> $preferredLang,
-        ':updated_at'    => $now,
-        ':id'            => $userId,
-    ]);
-
-    unset($_SESSION['user_cache']);
-    $_SESSION['lang'] = $preferredLang;
-
-    return ['success' => true, 'errors' => []];
-}
-
-// --- Logout ---
-function auth_logout(): void {
-    $_SESSION = [];
-    if (ini_get('session.use_cookies')) {
-        $params = session_get_cookie_params();
-        setcookie(session_name(), '', time() - 42000, $params['path'], $params['domain'], $params['secure'], $params['httponly']);
-    }
-    session_destroy();
-}

src/auth/login.php

@@ -1,190 +0,0 @@
-<?php
-// src/auth/login.php
-// wird durch public/auth/login.php aufgerufen
-
-// Basis-Setup: Session, $pdo, flash_*, Sprachlogik etc.
-require_once $_SERVER['DOCUMENT_ROOT']. '/../config/fileload.php';
-
-// Sprache aus der zentralen Sprachlogik holen
-// (fileload.php sollte $GLOBALS['lang'] anhand von URL, Session, Browser etc. setzen)
-$lang = $GLOBALS['lang'] ?? 'en';
-
-// Nur POST zulassen – alles andere zurück zur Login-Seite
-if ($_SERVER['REQUEST_METHOD'] !== 'POST') {
-    $target = '/login/?lang=' . urlencode($lang) . '&view=login#auth';
-    header('Location: ' . $target);
-    exit;
-}
-
-// ---------------------------------------------------------
-// Form-Daten einsammeln
-// ---------------------------------------------------------
-$email    = trim((string)($_POST['email'] ?? ''));
-$password = (string)($_POST['password'] ?? '');
-$redirect = $_POST['redirect'] ?? '/';
-
-// (Optional) Falls das Formular noch ein <input name="lang"> hat,
-// kannst du das nutzen, falls kein $GLOBALS['lang'] gesetzt ist:
-if (empty($lang) && !empty($_POST['lang'])) {
-    $lang = substr((string)$_POST['lang'], 0, 2);
-}
-
-// Minimal-Validierung
-if (
-    $email === '' ||
-    !filter_var($email, FILTER_VALIDATE_EMAIL) ||
-    $password === ''
-) {
-    flash_set('error', 'Bitte E-Mail-Adresse und Passwort eingeben.', 'login');
-    header('Location: /login/?lang=' . urlencode($lang) . '&view=login#auth');
-    exit;
-}
-
-/* ---------------------------------------------------------
-   USER LADEN
---------------------------------------------------------- */
-
-try {
-    $stmt = $pdo->prepare('SELECT * FROM users WHERE email = :email LIMIT 1');
-    $stmt->execute([':email' => $email]);
-    $user = $stmt->fetch(PDO::FETCH_ASSOC);
-} catch (Throwable $e) {
-    // DB-Fehler → generische Meldung
-    flash_set('error', 'Es ist ein Fehler beim Login aufgetreten. Bitte versuche es später erneut.', 'login');
-    header('Location: /login/?lang=' . urlencode($lang) . '&view=login#auth');
-    exit;
-}
-
-if (!$user) {
-    flash_set('error', 'E-Mail oder Passwort ist falsch.', 'login');
-    header('Location: /login/?lang=' . urlencode($lang) . '&view=login#auth');
-    exit;
-}
-
-/* ---------------------------------------------------------
-   ACCOUNT GESPERRT?
---------------------------------------------------------- */
-
-if (!empty($user['is_locked'])) {
-    flash_set('error', 'Dein Konto ist gesperrt. Bitte kontaktiere den Support.', 'login');
-    header('Location: /login/?lang=' . urlencode($lang) . '&view=login#auth');
-    exit;
-}
-
-/* ---------------------------------------------------------
-   PASSWORT PRÜFEN
---------------------------------------------------------- */
-
-if (!password_verify($password, $user['password_hash'])) {
-
-    // Fehlversuche hochzählen
-    try {
-        $failed = (int)($user['failed_logins'] ?? 0) + 1;
-        $lock   = 0;
-
-        if ($failed >= 5) {
-            $lock = 1;
-        }
-
-        $upd = $pdo->prepare('UPDATE users SET failed_logins = :failed, is_locked = :locked WHERE id = :id');
-        $upd->execute([
-            ':failed' => $failed,
-            ':locked' => $lock,
-            ':id'     => $user['id'],
-        ]);
-    } catch (Throwable $e) {
-        // Nicht kritisch, Meldung reicht
-    }
-
-    $msg = 'E-Mail oder Passwort ist falsch.';
-    if (($user['failed_logins'] ?? 0) + 1 >= 5) {
-        $msg = 'Zu viele Fehlversuche. Dein Konto wurde vorübergehend gesperrt.';
-    }
-
-    flash_set('error', $msg, 'login');
-    header('Location: /login/?lang=' . urlencode($lang) . '&view=login#auth');
-    exit;
-}
-
-/* ---------------------------------------------------------
-   PASSWORT KORREKT → FAILED_LOGINS RESET + LAST_LOGIN
---------------------------------------------------------- */
-
-try {
-    $upd = $pdo->prepare('UPDATE users SET failed_logins = 0, last_login_at = NOW() WHERE id = :id');
-    $upd->execute([':id' => $user['id']]);
-} catch (Throwable $e) {
-    // Nicht kritisch für den Nutzer
-}
-
-/* ---------------------------------------------------------
-   SESSION FÜLLEN
---------------------------------------------------------- */
-
-$firstName = $user['first_name'] ?? '';
-$lastName  = $user['last_name'] ?? '';
-$initials  = '';
-
-if ($firstName !== '') {
-    $initials .= mb_substr($firstName, 0, 1);
-}
-if ($lastName !== '') {
-    $initials .= mb_substr($lastName, 0, 1);
-}
-if ($initials === '') {
-    $initials = mb_substr($user['username'] ?? $user['email'], 0, 2);
-}
-$initials = mb_strtoupper($initials);
-
-$_SESSION['user'] = [
-    'id'         => $user['id'],
-    'email'      => $user['email'],
-    'username'   => $user['username'],
-    'first_name' => $user['first_name'],
-    'last_name'  => $user['last_name'],
-    'plan'       => $user['plan'] ?? 'free',
-    'initials'   => $initials,
-];
-
-/* ---------------------------------------------------------
-   FLASH & SMART REDIRECT
---------------------------------------------------------- */
-
-flash_set('success', 'Willkommen zurück, ' . ($user['first_name'] ?: 'User') . '!', 'login');
-
-// redirect normalisieren
-$redirect = trim((string)($redirect ?? ''));
-
-// Flag: sollen wir stattdessen aufs Dashboard?
-$goDashboard = false;
-
-// 1) redirect leer → Dashboard
-if ($redirect === '') {
-    $goDashboard = true;
-}
-
-// 2) redirect zeigt auf /login → Dashboard (Endlosschleife vermeiden)
-if (!$goDashboard && preg_match('#^/login(/|\?|$)#i', $redirect)) {
-    $goDashboard = true;
-}
-
-// 3) redirect ist keine interne URL → Dashboard (Sicherheit!)
-if (!$goDashboard && strpos($redirect, '/') !== 0) {
-    $goDashboard = true;
-}
-
-// 4) Finales Ziel bestimmen
-if ($goDashboard) {
-    // Immer Dashboard-Seite
-    $target = '/dashboard/?lang=' . urlencode($lang);
-} else {
-    // Internes Ziel, Sprache anhängen falls noch nicht vorhanden
-    if (strpos($redirect, 'lang=') === false) {
-        $sep      = (strpos($redirect, '?') === false) ? '?' : '&';
-        $redirect = $redirect . $sep . 'lang=' . urlencode($lang);
-    }
-    $target = $redirect;
-}
-
-header('Location: ' . $target);
-exit;

src/auth/logout.php

@@ -1,22 +0,0 @@
-<?php
-// src/auth/logout.php
-// wird von public/auth/logout.php eingebunden
-
-if (session_status() !== PHP_SESSION_ACTIVE) {
-    @session_start();
-}
-
-// Session leeren, aber NICHT komplett zerstören,
-// damit flash_set noch funktionieren kann.
-$_SESSION = [];
-session_regenerate_id(true);
-
-// Sprache aus GET, falls vorhanden
-$lang = $_GET['lang'] ?? 'de';
-
-// Flash-Meldung für die Login-Seite
-flash_set('success', 'Du wurdest erfolgreich ausgeloggt.', 'login');
-
-// Direkt zur Login-Seite weiterleiten
-header('Location: /login/?lang=' . urlencode($lang) . '#auth');
-exit;

src/auth/register.php

@@ -1,159 +0,0 @@
-<?php
-// src/auth/register.php
-// Wird durch public/auth/register.php aufgerufen
-
-// Basis-Setup: Session, $pdo, flash_*, Sprachlogik etc.
-require_once $_SERVER['DOCUMENT_ROOT']. '/../config/fileload.php';
-
-// Sprache aus zentraler Sprachlogik holen
-$lang = $GLOBALS['lang'] ?? 'en';
-
-// Nur POST zulassen – alles andere zurück zur Login-/Register-Ansicht
-if ($_SERVER['REQUEST_METHOD'] !== 'POST') {
-    $target = '/login/?lang=' . urlencode($lang) . '&view=register#auth';
-    header('Location: ' . $target);
-    exit;
-}
-
-// ---------------------------------------------------------
-// Form-Daten einsammeln
-// ---------------------------------------------------------
-$name     = trim((string)($_POST['name'] ?? ''));
-$email    = trim((string)($_POST['email'] ?? ''));
-$password = (string)($_POST['password'] ?? '');
-$redirect = $_POST['redirect'] ?? '/';
-
-// Optional: Falls aus irgendeinem Grund $lang noch leer ist,
-// kannst du (z.B. beim ersten Request) auf ein hidden-Feld im Formular zurückgreifen.
-if (empty($lang) && !empty($_POST['lang'])) {
-    $lang = substr((string)$_POST['lang'], 0, 2);
-}
-
-/* ---------------------------------------------------------
-   VALIDIERUNG
---------------------------------------------------------- */
-
-if ($name === '' || $email === '' || !filter_var($email, FILTER_VALIDATE_EMAIL)) {
-    flash_set('error', 'Bitte einen gültigen Namen und eine gültige E-Mail-Adresse eingeben.', 'register');
-    header('Location: /login/?lang=' . urlencode($lang) . '&view=register#auth');
-    exit;
-}
-
-if (strlen($password) < 8) {
-    flash_set('error', 'Das Passwort muss mindestens 8 Zeichen lang sein.', 'register');
-    header('Location: /login/?lang=' . urlencode($lang) . '&view=register#auth');
-    exit;
-}
-
-
-/* ---------------------------------------------------------
-   PRÜFEN, OB E-MAIL SCHON EXISTIERT
---------------------------------------------------------- */
-
-try {
-    $stmt = $pdo->prepare('SELECT id FROM users WHERE email = :email LIMIT 1');
-    $stmt->execute([':email' => $email]);
-    $existing = $stmt->fetch(PDO::FETCH_ASSOC);
-} catch (Throwable $e) {
-    flash_set('error', 'Es ist ein technischer Fehler aufgetreten. Bitte später erneut versuchen.', 'register');
-    header('Location: /login/?lang=' . urlencode($lang) . '&view=register#auth');
-    exit;
-}
-
-if ($existing) {
-    flash_set('error', 'Diese E-Mail-Adresse ist bereits registriert.', 'register');
-    header('Location: /login/?lang=' . urlencode($lang) . '&view=register#auth');
-    exit;
-}
-
-
-/* ---------------------------------------------------------
-   NAME AUFTEILEN (Vorname / Nachname)
---------------------------------------------------------- */
-
-$firstName = $name;
-$lastName  = null;
-
-$parts = preg_split('/\s+/', $name);
-if (count($parts) >= 2) {
-    $firstName = array_shift($parts);
-    $lastName  = implode(' ', $parts);
-}
-
-/* ---------------------------------------------------------
-   USER ANLEGEN
---------------------------------------------------------- */
-
-$username     = $email;
-$passwordHash = password_hash($password, PASSWORD_DEFAULT);
-
-try {
-    $stmt = $pdo->prepare('
-        INSERT INTO users
-            (username, email, password_hash, first_name, last_name, plan)
-        VALUES
-            (:username, :email, :password_hash, :first_name, :last_name, :plan)
-    ');
-    $stmt->execute([
-        ':username'      => $username,
-        ':email'         => $email,
-        ':password_hash' => $passwordHash,
-        ':first_name'    => $firstName,
-        ':last_name'     => $lastName,
-        ':plan'          => 'free',
-    ]);
-
-    $userId = (int)$pdo->lastInsertId();
-} catch (Throwable $e) {
-    flash_set('error', 'Die Registrierung ist fehlgeschlagen. Bitte versuche es später erneut.', 'register');
-    header('Location: /login/?lang=' . urlencode($lang) . '&view=register#auth');
-    exit;
-}
-
-
-/* ---------------------------------------------------------
-   DIREKT EINLOGGEN
---------------------------------------------------------- */
-
-$initials = '';
-if ($firstName !== '') {
-    $initials .= mb_substr($firstName, 0, 1);
-}
-if ($lastName !== null && $lastName !== '') {
-    $initials .= mb_substr($lastName, 0, 1);
-}
-if ($initials === '') {
-    $initials = mb_substr($username, 0, 2);
-}
-$initials = mb_strtoupper($initials);
-
-$_SESSION['user'] = [
-    'id'         => $userId,
-    'email'      => $email,
-    'username'   => $username,
-    'first_name' => $firstName,
-    'last_name'  => $lastName,
-    'plan'       => 'free',
-    'initials'   => $initials,
-];
-
-/* ---------------------------------------------------------
-   ERFOLGSMELDUNG + REDIRECT
---------------------------------------------------------- */
-
-flash_set('success', 'Konto erfolgreich erstellt. Willkommen bei USBCheck!', 'login');
-
-// Redirect absichern: nur interne Pfade erlauben
-$target = is_string($redirect) ? trim($redirect) : '/';
-if ($target === '' || !str_starts_with($target, '/')) {
-    $target = '/';
-}
-
-// Sprache anhängen, falls noch nicht vorhanden
-if (strpos($target, 'lang=') === false) {
-    $separator = (strpos($target, '?') === false) ? '?' : '&';
-    $target .= $separator . 'lang=' . urlencode($lang);
-}
-
-header('Location: ' . $target);
-exit;