app.js

/**
 * GITHUB REPO LINKTREE & MINI WEBSITE ENGINE
 * Ultra-minimalist, mobile-first GitHub showcase engine.
 * Features a tactile Tinder-style card deck and Swiss Linktree list view.
 * Zero dependencies, zero build step, real-time sync with GitHub API.
 * 
 * Open Source & Universally Configurable (c) Emanuele BDC (emaf205).
 * Licensed under the MIT License.
 */

(function () {
  'use strict';

  // Open-Source Default Configuration Template
  const DEFAULT_CONFIG = {
    username: 'your-github-username',
    name: 'Your Name',
    title: 'Projects & Repositories',
    tagline: 'Curated collection of public repositories, web apps and client-side tools.',
    theme: 'acid', // 'acid' | 'dark' | 'warm'
    layout: 'cards', // 'cards' (Masonry Schede) | 'deck' (Tinder Swipe) | 'list' (Compact)
    homeUrl: '',
    blogUrl: '',
    hideConfigButton: false,
    hideForks: true,
    excludedRepos: [],
    pinnedRepos: [],
    customDemos: {},
    customCovers: {}
  };

  // Curated metadata and verified bespoke covers for Emanuele BDC (emaf205)
  const VERIFIED_PROJECTS = {
    'github': {
      title: 'GitHub Repo Linktree Engine',
      desc: 'Open-source mobile-first portfolio engine with responsive Masonry & 3D Swipe Deck.',
      demo: 'https://emaf205.com/github/',
      cover: 'assets/covers/github.jpg',
      cat: 'pwa',
      badge: 'Engine'
    },
    'silvo-tv': {
      title: 'SILVO TV',
      desc: 'Player vintage CRT con 200 video storici in autoplay continuo.',
      demo: 'https://emaf205.com/ideas/silvo-tv/',
      cover: 'assets/covers/silvo-tv.jpg',
      cat: 'pwa',
      badge: 'PWA'
    },
    'BRERA-STYLEBOOK': {
      title: 'BRERA StyleBook',
      desc: 'Design system editoriale svizzero e libreria visuale per workflow con l\'AI.',
      demo: 'https://brera-stylebook.netlify.app/',
      cover: 'assets/covers/BRERA-STYLEBOOK.jpg',
      cat: 'visual',
      badge: 'Design'
    },
    'FIXYOUREYES': {
      title: 'FIXYOUREYES',
      desc: 'Utility sensoriale di sollievo oculare ed esercizi per affaticamento visivo da schermo.',
      demo: 'https://fixyoureyes.netlify.app',
      cover: 'assets/covers/FIXYOUREYES.jpg',
      cat: 'visual',
      badge: 'Design'
    },
    'ai-policy-builder': {
      title: 'AI Policy Builder',
      desc: 'Generatore in 3 step di bozze di governance ed etica AI interna per aziende e studi.',
      demo: 'https://emaf205.com/ideas/ai-policy-builder/',
      cover: 'assets/covers/ai-policy-builder.jpg',
      cat: 'pwa',
      badge: 'Web App'
    },
    'SIMPLE-PDF-SIGN': {
      title: 'Simple PDF Sign',
      desc: 'Firma e timbro crittografico su PDF nel browser. 100% offline, zero caricamento server.',
      demo: 'https://emaf205.com/ideas/simple-pdf-sign/',
      cover: 'assets/covers/SIMPLE-PDF-SIGN.jpg',
      cat: 'pwa',
      badge: 'PWA'
    },
    'DEAD-TEXT-SOCIETY': {
      title: 'Dead Text Society',
      desc: 'Cripta tipografica interattiva e zine per distillare testi dimenticati e frammenti.',
      demo: 'https://emaf205.com/ideas/dead-text-society/',
      cover: 'assets/covers/DEAD-TEXT-SOCIETY.jpg',
      cat: 'editorial',
      badge: 'Editoriale'
    },
    'ai-diary': {
      title: 'AI Diary',
      desc: 'Diario intimo e cronaca di riflessione crittografata local-first con storage IndexedDB.',
      demo: 'https://emaf205.com/ideas/ai-diary/',
      cover: 'assets/covers/ai-diary.jpg',
      cat: 'pwa',
      badge: 'PWA'
    },
    'emaf205-tapetone': {
      title: 'TapeTone Player',
      desc: 'Saturatore analogico per nastro a cassetta e synth acustico via Web Audio API.',
      demo: 'https://emaf205.com/ideas/tapetone/',
      cover: 'assets/covers/emaf205-tapetone.jpg',
      cat: 'visual',
      badge: 'Audio'
    },
    'office-os': {
      title: 'Office OS',
      desc: 'Desktop environment retrò anni \'90, sistema operativo vintage e soundboard d\'ufficio.',
      demo: 'https://emaf205.com/ideas/office-os/',
      cover: 'assets/covers/office-os.jpg',
      cat: 'tools',
      badge: 'Tool'
    },
    'gif-tv': {
      title: 'GIF TV',
      desc: 'Emittente algoritmica vintage per broadcast continuo di GIF animate retrò.',
      demo: 'https://emaf205.com/ideas/gif-tv/',
      cover: 'assets/covers/gif-tv.jpg',
      cat: 'visual',
      badge: 'Design'
    },
    'torno-subito': {
      title: 'Torno Subito',
      desc: 'Net art: cartello vintage italiano con oscillazione fisica e orari di apertura.',
      demo: 'https://emaf205.com/ideas/torno-subito/',
      cover: 'assets/covers/torno-subito.jpg',
      cat: 'visual',
      badge: 'Concept'
    },
    'prompt-search': {
      title: 'Prompt Search',
      desc: 'Ricerca istantanea e catalogo visuale client-side per prompt generativi ed istruzioni AI.',
      demo: 'https://emaf205.com/ideas/prompt-search/',
      cover: 'assets/covers/prompt-search.jpg',
      cat: 'tools',
      badge: 'Tool'
    },
    'EASY-PERSONAL-LINKTREE': {
      title: 'Easy Personal Linktree',
      desc: 'Biolink minimale ad altissima velocità (<50ms), zero tracker e zero dipendenze.',
      demo: 'https://linktr.ee/emaf205',
      cover: 'assets/covers/EASY-PERSONAL-LINKTREE.jpg',
      cat: 'pwa',
      badge: 'Biolink'
    },
    'FTP-Minimal-Archive': {
      title: 'FTP Minimal Archive',
      desc: 'Browser statico di directory e deployer leggero per hosting condivisi e pacchetti release.',
      demo: 'https://emaf205.com/ideas/',
      cover: 'assets/covers/FTP-Minimal-Archive.jpg',
      cat: 'tools',
      badge: 'Tool'
    },
    'Rex-for-ChatGPT': {
      title: 'REX for ChatGPT',
      desc: 'Direttiva di sistema ad alta densità per reasoning esecutivo e revisione forense del codice.',
      demo: 'https://emaf205.com/github',
      cover: 'assets/covers/Rex-for-ChatGPT.jpg',
      cat: 'tools',
      badge: 'Persona'
    },
    'static-folder-publisher': {
      title: 'Static Folder Publisher',
      desc: 'CLI Python per compilare, sanitizzare metadati OS e sincronizzare cartelle su server web.',
      demo: 'https://emaf205.com/github',
      cover: 'assets/covers/static-folder-publisher.jpg',
      cat: 'tools',
      badge: 'CLI Tool'
    },
    'emaf205-landing': {
      title: 'EMAF205 Landing',
      desc: 'Landing page editoriale e portfolio architettonico con tipografia svizzera e codice snello.',
      demo: 'https://emaf205.com',
      cover: 'assets/covers/emaf205-landing.jpg',
      cat: 'pwa',
      badge: 'Web App'
    },
    'EmaF205-LinksX': {
      title: 'Links-X',
      desc: 'Indice personale ad alto contrasto, design brutalista e touch ergonomics su mobile.',
      demo: 'https://emaf205.com/ideas/easy-links/',
      cover: 'assets/covers/EmaF205-LinksX.jpg',
      cat: 'pwa',
      badge: 'Web App'
    },
    'emaf205-snap': {
      title: 'SNAP Framing Utility',
      desc: 'Cattura e inquadratura viewport con proporzioni perfette per mockup di web app.',
      demo: 'https://emaf205.com/github',
      cover: 'assets/covers/emaf205-snap.jpg',
      cat: 'tools',
      badge: 'Utility'
    },
    'EMAF205-Easy-ChatGPT-Importer': {
      title: 'ChatGPT Importer',
      desc: 'PWA offline-first per esplorare archivi OpenAI JSON ed esportare in Markdown pulito.',
      demo: 'https://emaf205.com/ideas/chatgpt-importer/',
      cover: 'assets/covers/EMAF205-Easy-ChatGPT-Importer.jpg',
      cat: 'tools',
      badge: 'Tool'
    },
    'transcript-to-magazine-ai': {
      title: 'Transcript to Magazine',
      desc: 'Motore editoriale per trasformare trascrizioni AI in magazine monografici stampabili.',
      demo: 'https://emaf205.com/github',
      cover: 'assets/covers/transcript-to-magazine-ai.jpg',
      cat: 'editorial',
      badge: 'Editoriale'
    },
    'kurt-cobain-street-critic': {
      title: 'Kurt Cobain Street Critic',
      desc: 'Simulatore di fanzine grunge lo-fi anni \'90 e critico stradale satirico in PWA.',
      demo: 'https://emaf205.com/ideas/kurt-critic/',
      cover: 'assets/covers/kurt-cobain-street-critic.jpg',
      cat: 'visual',
      badge: 'Game / PWA'
    },
    'emaf205': {
      title: 'Emanuele BDC (Profile)',
      desc: 'Manifesto architettonico, principi di design, profilo e repository selezionati.',
      demo: 'https://emaf205.com/github',
      cover: 'assets/covers/emaf205.jpg',
      cat: 'editorial',
      badge: 'Manifesto'
    }
  };

  const CACHE_TTL_MS = 10 * 60 * 1000; // 10 minutes cache

  // DOM Elements
  const cardsSection = document.getElementById('cardsSection');
  const cardsGrid = document.getElementById('cardsGrid');
  const cardsEmpty = document.getElementById('cardsEmpty');
  const controlsBox = document.getElementById('controlsBox');

  const deckSection = document.getElementById('deckSection');
  const deckStage = document.getElementById('deckStage');
  const deckCounter = document.getElementById('deckCounter');
  const prevCardBtn = document.getElementById('prevCardBtn');
  const nextCardBtn = document.getElementById('nextCardBtn');

  const listSection = document.getElementById('listSection');
  const listEl = document.getElementById('list');
  const searchEl = document.getElementById('search');
  const clearBtn = document.getElementById('clearBtn');
  const chips = document.querySelectorAll('.chip');
  const countEl = document.getElementById('count');
  const emptyEl = document.getElementById('empty');

  const viewCardsBtn = document.getElementById('viewCardsBtn');
  const viewDeckBtn = document.getElementById('viewDeckBtn');
  const viewListBtn = document.getElementById('viewListBtn');

  const brandNameEl = document.getElementById('brandName');
  const brandLinkEl = document.getElementById('brandLink');
  const pageTitleEl = document.getElementById('pageTitle');
  const footGhEl = document.getElementById('footGh');

  // Modal & Config Elements
  const openConfigBtn = document.getElementById('openConfigBtn');
  const closeConfigBtn = document.getElementById('closeConfigBtn');
  const modalBackdrop = document.getElementById('modalBackdrop');
  const usernameInput = document.getElementById('usernameInput');
  const fetchUserBtn = document.getElementById('fetchUserBtn');
  const layoutPicker = document.getElementById('layoutPicker');
  const themePicker = document.getElementById('themePicker');
  const repoManager = document.getElementById('repoManager');
  const copyShareLinkBtn = document.getElementById('copyShareLinkBtn');
  const downloadConfigBtn = document.getElementById('downloadConfigBtn');

  // State
  let config = Object.assign({}, DEFAULT_CONFIG);
  let activeUsername = DEFAULT_CONFIG.username;
  let activeTheme = DEFAULT_CONFIG.theme;
  let currentView = DEFAULT_CONFIG.layout;
  let hiddenRepos = new Set(DEFAULT_CONFIG.excludedRepos);
  let allRepos = [];
  let activeDeckProjects = [];
  let deckIndex = 0;
  let activeCat = 'all';
  let query = '';

  // Touch / Drag Gesture State
  let startX = 0;
  let startY = 0;
  let currentX = 0;
  let currentY = 0;
  let isDragging = false;
  let startTime = 0;

  // Parse URL query parameters
  function parseQueryParams() {
    const params = new URLSearchParams(window.location.search);
    if (params.has('u')) activeUsername = params.get('u').trim();
    if (params.has('theme')) {
      const th = params.get('theme').toLowerCase();
      if (['acid', 'dark', 'warm'].includes(th)) activeTheme = th;
    }
    if (params.has('view') || params.has('layout')) {
      const v = (params.get('view') || params.get('layout')).toLowerCase();
      if (['cards', 'masonry', 'deck', 'list'].includes(v)) {
        currentView = (v === 'masonry' ? 'cards' : v);
      }
    }
    if (params.has('hide')) {
      const hides = params.get('hide').split(',').map(s => s.trim()).filter(Boolean);
      hides.forEach(h => hiddenRepos.add(h));
    }
    if (params.has('config') && modalBackdrop) {
      modalBackdrop.classList.add('open');
    }
  }

  // Set Theme
  function setTheme(theme) {
    activeTheme = theme;
    document.documentElement.setAttribute('data-theme', theme);
    if (themePicker) {
      themePicker.querySelectorAll('.pill-btn').forEach(btn => {
        btn.classList.toggle('selected', btn.getAttribute('data-val') === theme);
      });
    }
  }

  // Set View (Cards/Masonry vs Deck vs List)
  function setView(view) {
    if (view === 'masonry') view = 'cards';
    currentView = view;
    document.body.setAttribute('data-view', view);

    if (viewCardsBtn) {
      viewCardsBtn.classList.toggle('active', view === 'cards');
      viewCardsBtn.setAttribute('aria-selected', view === 'cards');
    }
    if (viewDeckBtn) {
      viewDeckBtn.classList.toggle('active', view === 'deck');
      viewDeckBtn.setAttribute('aria-selected', view === 'deck');
    }
    if (viewListBtn) {
      viewListBtn.classList.toggle('active', view === 'list');
      viewListBtn.setAttribute('aria-selected', view === 'list');
    }

    if (layoutPicker) {
      layoutPicker.querySelectorAll('.pill-btn').forEach(btn => {
        btn.classList.toggle('selected', btn.getAttribute('data-val') === view);
      });
    }

    if (view === 'cards') {
      if (cardsSection) cardsSection.hidden = false;
      if (deckSection) deckSection.hidden = true;
      if (listSection) listSection.hidden = true;
      if (controlsBox) controlsBox.hidden = false;
      filterCards();
    } else if (view === 'deck') {
      if (cardsSection) cardsSection.hidden = true;
      if (deckSection) deckSection.hidden = false;
      if (listSection) listSection.hidden = true;
      if (controlsBox) controlsBox.hidden = true;
      updateDeckStack(false);
    } else {
      if (cardsSection) cardsSection.hidden = true;
      if (deckSection) deckSection.hidden = true;
      if (listSection) listSection.hidden = false;
      if (controlsBox) controlsBox.hidden = false;
      filterList();
    }
  }

  // Categorize a generic repository
  function categorizeRepo(repo) {
    const name = (repo.name || '').toLowerCase();
    const desc = (repo.description || '').toLowerCase();
    const lang = (repo.language || '').toLowerCase();

    if (name.includes('pwa') || desc.includes('pwa') || name.includes('link') || name.includes('landing') || repo.has_pages) {
      return { cat: 'pwa', badge: 'Web App' };
    }
    if (name.includes('tool') || name.includes('importer') || name.includes('publisher') || desc.includes('utility') || desc.includes('tool')) {
      return { cat: 'tools', badge: 'Tool' };
    }
    if (name.includes('visual') || name.includes('tv') || name.includes('audio') || name.includes('critic') || desc.includes('design') || desc.includes('style')) {
      return { cat: 'visual', badge: 'Design' };
    }
    if (desc.includes('magazine') || desc.includes('testo') || desc.includes('doc') || desc.includes('bio') || name.includes('doc')) {
      return { cat: 'editorial', badge: 'Editoriale' };
    }
    return { cat: 'tools', badge: lang ? lang.toUpperCase() : 'Code' };
  }

  // Render Welcome Onboarding Card in Deck when unconfigured
  function renderWelcomeCard() {
    if (!deckStage) return;
    deckStage.innerHTML = '';

    const card = document.createElement('article');
    card.className = 'deck-card';
    card.style.display = 'flex';
    card.style.zIndex = '30';
    card.style.opacity = '1';
    card.style.transform = 'translate3d(0, 0, 0) scale(1) rotate(0deg)';

    const cover = document.createElement('div');
    cover.className = 'card-cover';
    cover.innerHTML = `
      <div class="cover-fallback" style="display:flex; background: linear-gradient(135deg, #111, #222); color: #fff;">
        <span class="fallback-tag" style="background:var(--acid); color:#111;">OPEN SOURCE</span>
        <span class="fallback-title" style="font-size:22px; color:#fff;">GitHub Repo Engine</span>
      </div>
      <span class="cover-badge" style="background:var(--acid); color:#111;">Quickstart</span>
    `;

    const content = document.createElement('div');
    content.className = 'card-content';
    content.innerHTML = `
      <div class="card-meta">
        <span class="card-num">#01</span>
        <span class="card-category">Configurazione Rapida</span>
      </div>
      <h2 class="deck-card-title">I Tuoi Repository GitHub</h2>
      <p class="deck-card-desc">Trasforma i tuoi repository pubblici in uno stack a card swipabili o linktree minimal. Inserisci il tuo username per provarlo subito:</p>
      <div class="welcome-card-box">
        <div class="welcome-input-row">
          <input type="text" id="welcomeInput" class="welcome-input" placeholder="es. torvalds, emaf205..." autocomplete="off" spellcheck="false">
          <button type="button" id="welcomeBtn" class="welcome-btn-submit">Carica ↗</button>
        </div>
        <div class="welcome-presets">
          <span class="welcome-preset-label">Prova:</span>
          <button type="button" class="welcome-preset-btn" data-u="emaf205">@emaf205</button>
          <button type="button" class="welcome-preset-btn" data-u="torvalds">@torvalds</button>
          <button type="button" class="welcome-preset-btn" data-u="antfu">@antfu</button>
        </div>
      </div>
    `;

    const actions = document.createElement('div');
    actions.className = 'deck-card-actions';
    actions.innerHTML = `
      <button type="button" id="openConfigFromCardBtn" class="deck-btn-primary" style="cursor:pointer;">⚙️ Apri Configuratore</button>
      <a href="https://github.com/emaf205/github" target="_blank" rel="noopener" class="deck-btn-secondary">GitHub Repo ↗</a>
    `;

    card.appendChild(cover);
    card.appendChild(content);
    card.appendChild(actions);
    deckStage.appendChild(card);

    if (deckCounter) deckCounter.textContent = '01 / 01';

    // Welcome card events
    const input = card.querySelector('#welcomeInput');
    const btn = card.querySelector('#welcomeBtn');
    const applyUser = (u) => {
      const trimmed = (u || '').trim();
      if (trimmed) {
        activeUsername = trimmed;
        updateHeaderInfo(activeUsername, activeUsername);
        fetchUserRepos(activeUsername);
      }
    };

    if (btn) btn.addEventListener('click', () => applyUser(input.value));
    if (input) {
      input.addEventListener('keydown', (e) => {
        if (e.key === 'Enter') {
          e.preventDefault();
          applyUser(input.value);
        }
      });
    }
    card.querySelectorAll('.welcome-preset-btn').forEach(pb => {
      pb.addEventListener('click', () => {
        const u = pb.getAttribute('data-u');
        if (u) applyUser(u);
      });
    });
    const cfgBtn = card.querySelector('#openConfigFromCardBtn');
    if (cfgBtn && modalBackdrop) {
      cfgBtn.addEventListener('click', () => modalBackdrop.classList.add('open'));
    }
  }

  // Render Deck Cards
  function renderDeck(projects) {
    if (!deckStage) return;

    if (!activeUsername || activeUsername === 'your-github-username') {
      renderWelcomeCard();
      return;
    }

    activeDeckProjects = projects.filter(p => !hiddenRepos.has(p.name));
    deckStage.innerHTML = '';

    if (!activeDeckProjects.length) {
      deckStage.innerHTML = '<div class="empty"><p>Nessun repository trovato o visibile.</p></div>';
      if (deckCounter) deckCounter.textContent = '00 / 00';
      return;
    }

    if (deckIndex >= activeDeckProjects.length) {
      deckIndex = 0;
    }

    const frag = document.createDocumentFragment();

    activeDeckProjects.forEach((p, idx) => {
      const card = document.createElement('article');
      card.className = 'deck-card';
      card.setAttribute('data-index', String(idx));
      card.setAttribute('data-repo', p.name);

      // Cover container
      const cover = document.createElement('div');
      cover.className = 'card-cover';

      if (p.cover) {
        const img = document.createElement('img');
        img.className = 'cover-img';
        img.src = p.cover;
        img.alt = p.title || p.name;
        img.loading = (idx < 3) ? 'eager' : 'lazy';

        const fallback = document.createElement('div');
        fallback.className = 'cover-fallback';
        fallback.style.display = 'none';
        fallback.innerHTML = `<span class="fallback-tag">${p.badge || 'PROJECT'}</span><span class="fallback-title">${p.title || p.name}</span>`;

        img.onerror = function () {
          this.style.display = 'none';
          fallback.style.display = 'flex';
        };

        cover.appendChild(img);
        cover.appendChild(fallback);
      } else {
        const fallback = document.createElement('div');
        fallback.className = 'cover-fallback';
        fallback.innerHTML = `<span class="fallback-tag">${p.badge || 'PROJECT'}</span><span class="fallback-title">${p.title || p.name}</span>`;
        cover.appendChild(fallback);
      }

      const badge = document.createElement('span');
      badge.className = 'cover-badge';
      badge.textContent = p.badge || 'Repo';
      cover.appendChild(badge);

      // Content container
      const content = document.createElement('div');
      content.className = 'card-content';

      const meta = document.createElement('div');
      meta.className = 'card-meta';
      meta.innerHTML = `<span class="card-num">#${String(idx + 1).padStart(2, '0')}</span><span class="card-category">${p.catLabel || p.badge || 'Progetto'}</span>`;

      const title = document.createElement('h2');
      title.className = 'deck-card-title';
      title.textContent = p.title || p.name;

      const desc = document.createElement('p');
      desc.className = 'deck-card-desc';
      desc.textContent = p.desc || p.description || 'Nessuna descrizione disponibile.';

      content.appendChild(meta);
      content.appendChild(title);
      content.appendChild(desc);

      // Actions container
      const actions = document.createElement('div');
      actions.className = 'deck-card-actions';

      const primaryBtn = document.createElement('a');
      primaryBtn.className = 'deck-btn-primary';
      primaryBtn.href = p.demo || p.html_url || `https://github.com/${activeUsername}/${p.name}`;
      primaryBtn.target = '_blank';
      primaryBtn.rel = 'noopener';
      primaryBtn.textContent = p.demo ? 'Apri Progetto ↗' : 'GitHub Code ↗';
      actions.appendChild(primaryBtn);

      const codeBtn = document.createElement('a');
      codeBtn.className = 'deck-btn-secondary';
      codeBtn.href = p.html_url || `https://github.com/${activeUsername}/${p.name}`;
      codeBtn.target = '_blank';
      codeBtn.rel = 'noopener';
      codeBtn.textContent = 'Code ↗';
      actions.appendChild(codeBtn);

      card.appendChild(cover);
      card.appendChild(content);
      card.appendChild(actions);

      // Touch / pointer drag bindings
      attachDragEvents(card);

      frag.appendChild(card);
    });

    deckStage.appendChild(frag);
    updateDeckStack(false);
  }

  // Update 3D Visual Deck Stack
  function updateDeckStack(animate) {
    if (!deckStage || !activeDeckProjects.length) return;
    const cards = deckStage.querySelectorAll('.deck-card');
    const total = activeDeckProjects.length;

    cards.forEach(card => {
      const idx = parseInt(card.getAttribute('data-index'), 10);
      const diff = (idx - deckIndex + total) % total;

      card.classList.remove('is-dragging');

      if (diff === 0) {
        // Active top card
        card.style.display = 'flex';
        card.style.zIndex = '30';
        card.style.pointerEvents = 'auto';
        card.style.opacity = '1';
        card.style.transition = animate ? 'transform 0.3s cubic-bezier(0.16, 1, 0.3, 1), opacity 0.3s ease' : 'none';
        card.style.transform = 'translate3d(0, 0, 0) scale(1) rotate(0deg)';
      } else if (diff === 1) {
        // Second card underneath
        card.style.display = 'flex';
        card.style.zIndex = '20';
        card.style.pointerEvents = 'none';
        card.style.opacity = '0.9';
        card.style.transition = animate ? 'transform 0.3s cubic-bezier(0.16, 1, 0.3, 1), opacity 0.3s ease' : 'none';
        card.style.transform = 'translate3d(0, 13px, -15px) scale(0.95) rotate(0deg)';
      } else if (diff === 2) {
        // Third card underneath
        card.style.display = 'flex';
        card.style.zIndex = '10';
        card.style.pointerEvents = 'none';
        card.style.opacity = '0.6';
        card.style.transition = animate ? 'transform 0.3s cubic-bezier(0.16, 1, 0.3, 1), opacity 0.3s ease' : 'none';
        card.style.transform = 'translate3d(0, 26px, -30px) scale(0.90) rotate(0deg)';
      } else {
        // Hidden cards in deck
        card.style.display = 'none';
        card.style.zIndex = '1';
        card.style.pointerEvents = 'none';
        card.style.opacity = '0';
        card.style.transform = 'translate3d(0, 36px, -45px) scale(0.85) rotate(0deg)';
      }
    });

    if (deckCounter) {
      deckCounter.textContent = `${String(deckIndex + 1).padStart(2, '0')} / ${String(total).padStart(2, '0')}`;
    }
  }

  // Advance Deck Index
  function advanceDeck(direction) {
    if (!activeDeckProjects.length) return;
    const total = activeDeckProjects.length;
    const currentCard = deckStage.querySelector(`.deck-card[data-index="${deckIndex}"]`);

    if (currentCard) {
      currentCard.style.transition = 'transform 0.28s cubic-bezier(0.16, 1, 0.3, 1), opacity 0.28s ease';
      const flyX = direction > 0 ? -450 : 450;
      currentCard.style.transform = `translate3d(${flyX}px, 0, 0) rotate(${direction > 0 ? -20 : 20}deg)`;
      currentCard.style.opacity = '0';
    }

    setTimeout(() => {
      deckIndex = (deckIndex + direction + total) % total;
      updateDeckStack(true);
    }, 200);
  }

  // Attach Touch / Pointer Drag Gesture to Card
  function attachDragEvents(card) {
    function startDrag(e) {
      const idx = parseInt(card.getAttribute('data-index'), 10);
      if (idx !== deckIndex) return;

      if (e.target.closest('a') || e.target.closest('button') || e.target.closest('input')) {
        return;
      }

      isDragging = true;
      startTime = Date.now();
      card.classList.add('is-dragging');

      if (e.type === 'touchstart') {
        startX = e.touches[0].clientX;
        startY = e.touches[0].clientY;
      } else {
        startX = e.clientX;
        startY = e.clientY;
      }
      currentX = startX;
      currentY = startY;
    }

    function moveDrag(e) {
      if (!isDragging) return;
      if (e.type === 'touchmove') {
        currentX = e.touches[0].clientX;
        currentY = e.touches[0].clientY;
      } else {
        currentX = e.clientX;
        currentY = e.clientY;
      }

      const deltaX = currentX - startX;
      const deltaY = currentY - startY;
      const rotation = deltaX * 0.08;

      card.style.transition = 'none';
      card.style.transform = `translate3d(${deltaX}px, ${deltaY * 0.25}px, 0) rotate(${rotation}deg)`;

      const total = activeDeckProjects.length;
      const nextCard = deckStage.querySelector(`.deck-card[data-index="${(deckIndex + 1) % total}"]`);
      if (nextCard) {
        const progress = Math.min(Math.abs(deltaX) / 180, 1);
        nextCard.style.transform = `translate3d(0, ${13 - progress * 13}px, ${-15 + progress * 15}px) scale(${0.95 + progress * 0.05})`;
        nextCard.style.opacity = `${0.9 + progress * 0.1}`;
      }
    }

    function endDrag() {
      if (!isDragging) return;
      isDragging = false;
      card.classList.remove('is-dragging');

      const deltaX = currentX - startX;
      const timeDiff = Date.now() - startTime;
      const velocity = Math.abs(deltaX) / Math.max(timeDiff, 1);
      const threshold = 75;

      if (Math.abs(deltaX) > threshold || velocity > 0.55) {
        const dir = deltaX > 0 ? 1 : -1;
        card.style.transition = 'transform 0.32s cubic-bezier(0.16, 1, 0.3, 1), opacity 0.32s ease';
        card.style.transform = `translate3d(${dir * 500}px, 0, 0) rotate(${dir * 28}deg)`;
        card.style.opacity = '0';

        setTimeout(() => {
          const total = activeDeckProjects.length;
          deckIndex = (deckIndex + 1) % total;
          updateDeckStack(true);
        }, 260);
      } else {
        // Snap back spring
        card.style.transition = 'transform 0.28s cubic-bezier(0.175, 0.885, 0.32, 1.275)';
        card.style.transform = 'translate3d(0, 0, 0) scale(1) rotate(0deg)';
        const total = activeDeckProjects.length;
        const nextCard = deckStage.querySelector(`.deck-card[data-index="${(deckIndex + 1) % total}"]`);
        if (nextCard) {
          nextCard.style.transform = 'translate3d(0, 13px, -15px) scale(0.95)';
          nextCard.style.opacity = '0.9';
        }
      }
    }

    card.addEventListener('pointerdown', startDrag);
    window.addEventListener('pointermove', moveDrag);
    window.addEventListener('pointerup', endDrag);
    window.addEventListener('pointercancel', endDrag);

    card.addEventListener('touchstart', startDrag, { passive: true });
    window.addEventListener('touchmove', moveDrag, { passive: true });
    window.addEventListener('touchend', endDrag);
    window.addEventListener('touchcancel', endDrag);
  }

  // Render Masonry Schede (Default View: Vertical Stack on Mobile, Grid Side-by-Side on Desktop)
  function renderCards(projects) {
    if (!cardsGrid) return;
    cardsGrid.innerHTML = '';

    if (!activeUsername || activeUsername === 'your-github-username') {
      if (cardsEmpty) {
        cardsEmpty.hidden = false;
        cardsEmpty.innerHTML = '<p>Inserisci un GitHub username per iniziare.</p>';
      }
      return;
    }

    const frag = document.createDocumentFragment();

    projects.forEach((p, idx) => {
      const isHidden = hiddenRepos.has(p.name);
      const card = document.createElement('article');
      card.className = 'masonry-card';
      card.setAttribute('data-cat', p.cat || 'tools');
      card.setAttribute('data-search', `${p.name} ${p.title} ${p.desc || ''}`.toLowerCase());
      card.setAttribute('data-repo', p.name);

      if (isHidden) card.style.display = 'none';

      // Cover container
      const cover = document.createElement('div');
      cover.className = 'card-cover';

      if (p.cover) {
        const img = document.createElement('img');
        img.className = 'cover-img';
        img.src = p.cover;
        img.alt = p.title || p.name;
        img.loading = 'lazy';
        img.onerror = function () {
          this.style.display = 'none';
          if (cover.querySelector('.cover-fallback')) return;
          const fb = document.createElement('div');
          fb.className = 'cover-fallback';
          fb.innerHTML = `<span class="fallback-tag">${p.badge || 'PROGETTO'}</span><div class="fallback-title">${p.title || p.name}</div>`;
          cover.appendChild(fb);
        };
        cover.appendChild(img);
      } else {
        const fb = document.createElement('div');
        fb.className = 'cover-fallback';
        fb.innerHTML = `<span class="fallback-tag">${p.badge || 'PROGETTO'}</span><div class="fallback-title">${p.title || p.name}</div>`;
        cover.appendChild(fb);
      }

      const badge = document.createElement('span');
      badge.className = 'cover-badge';
      badge.textContent = p.badge || 'Repo';
      cover.appendChild(badge);

      // Content container
      const content = document.createElement('div');
      content.className = 'card-content';

      const meta = document.createElement('div');
      meta.className = 'card-meta';
      meta.innerHTML = `<span class="card-num">#${String(idx + 1).padStart(2, '0')}</span><span class="card-category">${p.catLabel || p.badge || 'Progetto'}</span>`;

      const title = document.createElement('h2');
      title.className = 'masonry-card-title';
      title.textContent = p.title || p.name;

      const desc = document.createElement('p');
      desc.className = 'masonry-card-desc';
      desc.textContent = p.desc || p.description || 'Nessuna descrizione disponibile.';

      content.appendChild(meta);
      content.appendChild(title);
      content.appendChild(desc);

      // Actions container
      const actions = document.createElement('div');
      actions.className = 'masonry-card-actions';

      if (p.demo) {
        const demoBtn = document.createElement('a');
        demoBtn.className = 'card-btn-primary';
        demoBtn.href = p.demo;
        demoBtn.target = '_blank';
        demoBtn.rel = 'noopener';
        demoBtn.textContent = 'Live Demo ↗';
        actions.appendChild(demoBtn);
      }

      const codeBtn = document.createElement('a');
      codeBtn.className = p.demo ? 'card-btn-secondary' : 'card-btn-primary';
      codeBtn.href = p.html_url || `https://github.com/${activeUsername}/${p.name}`;
      codeBtn.target = '_blank';
      codeBtn.rel = 'noopener';
      codeBtn.textContent = 'GitHub Code ↗';
      actions.appendChild(codeBtn);

      card.appendChild(cover);
      card.appendChild(content);
      card.appendChild(actions);

      frag.appendChild(card);
    });

    cardsGrid.appendChild(frag);
    filterCards();
  }

  // Filter Masonry Schede
  function filterCards() {
    if (!cardsGrid) return;
    const cards = cardsGrid.querySelectorAll('.masonry-card');
    let visible = 0;
    const q = query.toLowerCase().trim();

    cards.forEach(card => {
      const repoName = card.getAttribute('data-repo');
      const isHidden = hiddenRepos.has(repoName);
      const matchCat = (activeCat === 'all' || card.getAttribute('data-cat') === activeCat);
      const matchSearch = !q || (card.getAttribute('data-search') || '').includes(q);

      if (!isHidden && matchCat && matchSearch) {
        card.style.display = 'flex';
        visible++;
      } else {
        card.style.display = 'none';
      }
    });

    if (countEl) countEl.textContent = String(visible);
    if (cardsEmpty) cardsEmpty.hidden = (visible > 0);
  }

  // Render Scrollable List Cards (Alternative Swiss Linktree View)
  function renderList(projects) {
    if (!listEl) return;
    listEl.innerHTML = '';

    if (!activeUsername || activeUsername === 'your-github-username') {
      if (emptyEl) {
        emptyEl.hidden = false;
        emptyEl.innerHTML = '<p>Inserisci un username GitHub per visualizzare l\'elenco.</p>';
      }
      if (countEl) countEl.textContent = '0';
      return;
    }

    const frag = document.createDocumentFragment();

    projects.forEach(p => {
      const isHidden = hiddenRepos.has(p.name);

      const card = document.createElement('article');
      card.className = 'card';
      card.setAttribute('data-cat', p.cat || 'tools');
      card.setAttribute('data-search', `${p.name} ${p.title} ${p.desc || ''}`.toLowerCase());
      card.setAttribute('data-repo', p.name);

      if (isHidden) card.style.display = 'none';

      const info = document.createElement('div');
      info.className = 'card-info';

      const titleRow = document.createElement('div');
      titleRow.className = 'card-title-row';

      const title = document.createElement('h2');
      title.className = 'card-title';
      title.textContent = p.title || p.name;

      const badge = document.createElement('span');
      badge.className = 'card-badge';
      badge.textContent = p.badge || 'Repo';

      titleRow.appendChild(title);
      titleRow.appendChild(badge);

      const desc = document.createElement('p');
      desc.className = 'card-desc';
      desc.textContent = p.desc || p.description || '';

      info.appendChild(titleRow);
      info.appendChild(desc);

      const actions = document.createElement('div');
      actions.className = 'card-actions';

      if (p.demo) {
        const demoLink = document.createElement('a');
        demoLink.className = 'btn-demo';
        demoLink.href = p.demo;
        demoLink.target = '_blank';
        demoLink.rel = 'noopener';
        demoLink.textContent = 'Demo ↗';
        actions.appendChild(demoLink);
      }

      const codeLink = document.createElement('a');
      codeLink.className = 'btn-code';
      codeLink.href = p.html_url || `https://github.com/${activeUsername}/${p.name}`;
      codeLink.target = '_blank';
      codeLink.rel = 'noopener';
      codeLink.textContent = 'Code ↗';
      actions.appendChild(codeLink);

      card.appendChild(info);
      card.appendChild(actions);
      frag.appendChild(card);
    });

    listEl.appendChild(frag);
    updateRepoManager();
    filterList();
  }

  // Update repository checkboxes in modal drawer
  function updateRepoManager() {
    if (!repoManager) return;
    repoManager.innerHTML = '';

    allRepos.forEach(repo => {
      const label = document.createElement('label');
      label.className = 'repo-check-item';

      const checkbox = document.createElement('input');
      checkbox.type = 'checkbox';
      checkbox.value = repo.name;
      checkbox.checked = !hiddenRepos.has(repo.name);

      checkbox.addEventListener('change', () => {
        if (checkbox.checked) {
          hiddenRepos.delete(repo.name);
        } else {
          hiddenRepos.add(repo.name);
        }
        renderCards(allRepos);
        renderDeck(allRepos);
        filterList();
      });

      const span = document.createElement('span');
      span.textContent = repo.title || repo.name;

      label.appendChild(checkbox);
      label.appendChild(span);
      repoManager.appendChild(label);
    });
  }

  // Filter List view based on search and category
  function filterList() {
    if (!listEl) return;
    const cards = listEl.querySelectorAll('.card');
    let visible = 0;
    const q = query.toLowerCase().trim();

    cards.forEach(card => {
      const repoName = card.getAttribute('data-repo');
      const isHidden = hiddenRepos.has(repoName);
      const matchCat = (activeCat === 'all' || card.getAttribute('data-cat') === activeCat);
      const matchSearch = !q || (card.getAttribute('data-search') || '').includes(q);

      if (!isHidden && matchCat && matchSearch) {
        card.style.display = 'flex';
        visible++;
      } else {
        card.style.display = 'none';
      }
    });

    if (countEl) countEl.textContent = String(visible);
    if (emptyEl) emptyEl.hidden = (visible > 0);
  }

  // Update Brand and Header Information
  function updateHeaderInfo(username, displayName) {
    const isEma = (username.toLowerCase() === 'emaf205');
    const resolvedName = isEma ? ((config.name && config.name !== 'Your Name') ? config.name : 'Emanuele BDC') : (displayName || username);

    if (brandNameEl) {
      brandNameEl.textContent = resolvedName;
    }
    if (brandLinkEl) {
      brandLinkEl.href = config.homeUrl || (isEma ? 'https://emaf205.com' : `https://github.com/${username}`);
    }
    if (pageTitleEl) {
      if (isEma) {
        pageTitleEl.textContent = `${config.title || 'Progetti & Strumenti'} — Emanuele BDC`;
      } else {
        pageTitleEl.textContent = `${resolvedName} — GitHub Projects`;
      }
    }
    if (usernameInput) usernameInput.value = username;
    if (footGhEl) footGhEl.href = `https://github.com/${username}`;

    // Hide config button on Emanuele's site unless ?config=1 is passed
    const params = new URLSearchParams(window.location.search);
    if (openConfigBtn) {
      if (config.hideConfigButton || (isEma && !params.has('config'))) {
        openConfigBtn.style.display = 'none';
      } else {
        openConfigBtn.style.display = 'inline-flex';
      }
    }
  }

  // Fetch repositories from GitHub API
  async function fetchUserRepos(username) {
    if (!username || username === 'your-github-username') {
      renderWelcomeCard();
      renderCards([]);
      renderList([]);
      return;
    }

    const cacheKey = `gh_cache_${username}`;
    try {
      const cached = localStorage.getItem(cacheKey);
      if (cached) {
        const parsed = JSON.parse(cached);
        if (Date.now() - parsed.timestamp < CACHE_TTL_MS && parsed.data) {
          allRepos = parsed.data;
          renderCards(allRepos);
          renderDeck(allRepos);
          renderList(allRepos);
          return;
        }
      }
    } catch (e) {}

    try {
      const res = await fetch(`https://api.github.com/users/${username}/repos?sort=pushed&per_page=100`);
      if (!res.ok) {
        // Fallback to local repos.json if user is emaf205
        if (username.toLowerCase() === 'emaf205') {
          try {
            const localRes = await fetch('repos.json');
            if (localRes.ok) {
              const localRepos = await localRes.json();
              allRepos = localRepos;
              renderCards(allRepos);
              renderDeck(allRepos);
              renderList(allRepos);
              return;
            }
          } catch (le) {}
        }
        renderWelcomeCard();
        renderCards([]);
        renderList([]);
        return;
      }

      const repos = await res.json();
      const publicRepos = repos.filter(r => (!config.hideForks || !r.fork) && !r.private);
      const isDefaultUser = (username.toLowerCase() === 'emaf205');

      const list = publicRepos.map(r => {
        const meta = isDefaultUser ? (VERIFIED_PROJECTS[r.name] || VERIFIED_PROJECTS[r.name.toLowerCase()] || {}) : {};
        const customDemo = config.customDemos ? config.customDemos[r.name] : null;
        const customCover = config.customCovers ? config.customCovers[r.name] : null;
        const auto = meta.cat ? { cat: meta.cat, badge: meta.badge } : categorizeRepo(r);

        const resolvedCover = customCover || meta.cover || (isDefaultUser ? `assets/covers/${r.name}.jpg` : null);

        return {
          name: r.name,
          title: meta.title || r.name,
          desc: meta.desc || r.description || '',
          demo: customDemo || meta.demo || (r.homepage && r.homepage.startsWith('http') ? r.homepage : null),
          cover: resolvedCover,
          html_url: r.html_url,
          cat: auto.cat,
          badge: auto.badge,
          catLabel: meta.badge || auto.badge
        };
      });

      // Pinned repos sorting if configured
      if (Array.isArray(config.pinnedRepos) && config.pinnedRepos.length > 0) {
        const pinSet = new Set(config.pinnedRepos);
        list.sort((a, b) => {
          const aPin = pinSet.has(a.name);
          const bPin = pinSet.has(b.name);
          if (aPin && !bPin) return -1;
          if (!aPin && bPin) return 1;
          return 0;
        });
      }

      allRepos = list;
      try {
        localStorage.setItem(cacheKey, JSON.stringify({ timestamp: Date.now(), data: list }));
      } catch (e) {}

      renderCards(allRepos);
      renderDeck(allRepos);
      renderList(allRepos);
    } catch (err) {
      console.warn('Network error fetching GitHub repos:', err);
      if (username.toLowerCase() === 'emaf205') {
        try {
          const localRes = await fetch('repos.json');
          if (localRes.ok) {
            allRepos = await localRes.json();
            renderCards(allRepos);
            renderDeck(allRepos);
            renderList(allRepos);
          }
        } catch (le) {}
      } else {
        renderWelcomeCard();
        renderCards([]);
        renderList([]);
      }
    }
  }

  // Load Initial Data
  async function init() {
    parseQueryParams();

    try {
      const res = await fetch('config.json');
      if (res.ok) {
        const json = await res.json();
        config = Object.assign({}, DEFAULT_CONFIG, json);
        if (!new URLSearchParams(window.location.search).has('u')) {
          activeUsername = config.username || activeUsername;
        }
        if (!new URLSearchParams(window.location.search).has('theme')) {
          activeTheme = config.theme || activeTheme;
        }
        if (!new URLSearchParams(window.location.search).has('view') && !new URLSearchParams(window.location.search).has('layout')) {
          currentView = config.layout || currentView;
        }
        if (Array.isArray(config.excludedRepos) && !new URLSearchParams(window.location.search).has('hide')) {
          config.excludedRepos.forEach(r => hiddenRepos.add(r));
        }
      }
    } catch (e) {}

    setTheme(activeTheme);
    setView(currentView);
    updateHeaderInfo(activeUsername, (activeUsername.toLowerCase() === 'emaf205') ? (config.name || 'Emanuele BDC') : activeUsername);

    await fetchUserRepos(activeUsername);
  }

  // Setup Event Listeners
  function setupEvents() {
    // View Switcher Buttons
    if (viewCardsBtn) {
      viewCardsBtn.addEventListener('click', () => setView('cards'));
    }
    if (viewDeckBtn) {
      viewDeckBtn.addEventListener('click', () => setView('deck'));
    }
    if (viewListBtn) {
      viewListBtn.addEventListener('click', () => setView('list'));
    }

    // Deck Prev & Next Buttons
    if (prevCardBtn) {
      prevCardBtn.addEventListener('click', (e) => {
        e.stopPropagation();
        advanceDeck(-1);
      });
    }
    if (nextCardBtn) {
      nextCardBtn.addEventListener('click', (e) => {
        e.stopPropagation();
        advanceDeck(1);
      });
    }

    // Keyboard Arrow Keys
    window.addEventListener('keydown', (e) => {
      if (currentView === 'deck') {
        if (e.key === 'ArrowRight' || e.key === 'Space') {
          e.preventDefault();
          advanceDeck(1);
        } else if (e.key === 'ArrowLeft') {
          e.preventDefault();
          advanceDeck(-1);
        }
      }
    });

    // Search & Clear
    if (searchEl) {
      searchEl.addEventListener('input', function () {
        query = this.value;
        if (clearBtn) clearBtn.hidden = !this.value;
        filterCards();
        filterList();
      });
    }

    if (clearBtn) {
      clearBtn.addEventListener('click', function () {
        if (searchEl) {
          searchEl.value = '';
          searchEl.focus();
        }
        query = '';
        this.hidden = true;
        filterCards();
        filterList();
      });
    }

    // Chips
    chips.forEach(chip => {
      chip.addEventListener('click', function () {
        chips.forEach(c => c.classList.remove('active'));
        this.classList.add('active');
        activeCat = this.getAttribute('data-filter') || 'all';
        filterCards();
        filterList();
      });
    });

    // Modal Drawer controls
    if (openConfigBtn && modalBackdrop) {
      openConfigBtn.addEventListener('click', () => {
        modalBackdrop.classList.add('open');
      });
    }

    if (closeConfigBtn && modalBackdrop) {
      closeConfigBtn.addEventListener('click', () => {
        modalBackdrop.classList.remove('open');
      });
    }

    if (modalBackdrop) {
      modalBackdrop.addEventListener('click', (e) => {
        if (e.target === modalBackdrop) {
          modalBackdrop.classList.remove('open');
        }
      });
    }

    document.addEventListener('keydown', (e) => {
      if (e.key === 'Escape' && modalBackdrop && modalBackdrop.classList.contains('open')) {
        modalBackdrop.classList.remove('open');
      }
    });

    // Username apply in modal
    if (fetchUserBtn && usernameInput) {
      fetchUserBtn.addEventListener('click', async () => {
        const newUser = usernameInput.value.trim();
        if (newUser && newUser !== activeUsername) {
          activeUsername = newUser;
          hiddenRepos.clear();
          deckIndex = 0;
          updateHeaderInfo(activeUsername, activeUsername);
          await fetchUserRepos(activeUsername);
        }
      });

      usernameInput.addEventListener('keydown', (e) => {
        if (e.key === 'Enter') {
          e.preventDefault();
          fetchUserBtn.click();
        }
      });
    }

    // Layout buttons in modal
    if (layoutPicker) {
      layoutPicker.querySelectorAll('.pill-btn').forEach(btn => {
        btn.addEventListener('click', () => {
          const val = btn.getAttribute('data-val');
          if (val) {
            setView(val);
            layoutPicker.querySelectorAll('.pill-btn').forEach(b => b.classList.remove('selected'));
            btn.classList.add('selected');
          }
        });
      });
    }

    // Theme buttons in modal
    if (themePicker) {
      themePicker.querySelectorAll('.pill-btn').forEach(btn => {
        btn.addEventListener('click', () => {
          const val = btn.getAttribute('data-val');
          if (val) setTheme(val);
        });
      });
    }

    // Copy Shareable Link
    if (copyShareLinkBtn) {
      copyShareLinkBtn.addEventListener('click', async () => {
        const url = new URL(window.location.origin + window.location.pathname);
        url.searchParams.set('u', activeUsername);
        url.searchParams.set('theme', activeTheme);
        url.searchParams.set('view', currentView);

        if (hiddenRepos.size > 0) {
          url.searchParams.set('hide', Array.from(hiddenRepos).join(','));
        }

        try {
          await navigator.clipboard.writeText(url.toString());
          const origText = copyShareLinkBtn.textContent;
          copyShareLinkBtn.textContent = '✓ Copiato!';
          setTimeout(() => {
            copyShareLinkBtn.textContent = origText;
          }, 2000);
        } catch (e) {
          prompt('Copia il link:', url.toString());
        }
      });
    }

    // Download config.json
    if (downloadConfigBtn) {
      downloadConfigBtn.addEventListener('click', () => {
        const outConfig = {
          username: activeUsername,
          name: brandNameEl ? brandNameEl.textContent : activeUsername,
          title: config.title || "Projects & Repositories",
          tagline: config.tagline || "Curated collection of public repositories.",
          theme: activeTheme,
          layout: currentView,
          homeUrl: config.homeUrl || `https://github.com/${activeUsername}`,
          blogUrl: config.blogUrl || '',
          hideForks: true,
          excludedRepos: Array.from(hiddenRepos),
          customDemos: config.customDemos || {},
          customCovers: config.customCovers || {}
        };

        const blob = new Blob([JSON.stringify(outConfig, null, 2)], { type: 'application/json' });
        const a = document.createElement('a');
        a.href = URL.createObjectURL(blob);
        a.download = 'config.json';
        document.body.appendChild(a);
        a.click();
        document.body.removeChild(a);
        URL.revokeObjectURL(a.href);
      });
    }
  }

  setupEvents();
  init();
})();