Upload via GUI (195 Dateien)

CHANGELOG.md

@@ -2,7 +2,121 @@
 
 Alle nennenswerten Änderungen an AeroMC werden hier festgehalten.
 
-## [1.1.6] - 2026-10-02
+## [1.2.4] - 2026-10-11
+
+### Neu
+- Beta-Kanal: Unter Optionen → Allgemein gibt es den Schalter „An der Beta teilnehmen“. Wer ihn einschaltet, bekommt Vorabfassungen (Beta, RC) als Update; wer ihn ausschaltet, bekommt ab der nächsten fertigen Version wieder nur fertige Versionen. Wer eine Beta von Hand installiert, nimmt automatisch teil
+- Vorabfassungen sind oben in der Titelleiste gekennzeichnet (z. B. „Beta 1“)
+
+### Behoben
+- Beta-Nutzern wurde die fertige Version derselben Nummer nicht als Update angeboten (z. B. von 1.3.0-beta.2 auf 1.3.0)
+- Bei vielen Vorabfassungen hintereinander konnte die neueste fertige Version aus der Update-Suche fallen
+
+## [1.2.3] - 2026-10-07
+
+### Behoben
+- Nach der Installation hing das Setup beim Klick auf „Fertigstellen“ einige Sekunden, bevor AeroMC startete – AeroMC öffnet sich jetzt sofort
+
+## [1.2.2] - 2026-10-05
+
+### Neu
+- AeroMC-Look im Spiel (Minecraft 1.14 bis 26.x, Vanilla und mit Loadern – ohne Mod):
+  - Ladebildschirm im Vollbild mit Landschaftsbild, großem AeroMC-Logo samt Pyramide, „DEIN MINECRAFT ERLEBNIS“, hellblauem Fortschrittsbalken und „Wird geladen …“ statt des roten Mojang-Bildschirms (bei 1.14/1.15 AeroMC-Logo auf Nachtblau)
+  - Hauptmenü mit großem AeroMC-Logo, Landschaft als drehendem Hintergrund, eigenen Sprüchen („Mehr als nur Minecraft!“) und Knöpfen im AeroMC-Stil – dunkles Schiefer, beim Darüberfahren leuchtend blau, mit Symbolen vor „Einzelspieler“, „Mehrspieler“, „Minecraft Realms“, „Optionen …“ und „Spiel beenden“
+  - Fenstertitel „AeroMC - Minecraft …“ und AeroMC-Fenstersymbol
+  - Abschaltbar unter Optionen → Spiel → AeroMC-Look; eigene Ressourcenpakete des Spielers haben immer Vorrang
+- Mods im Spiel verwalten (Instanzen mit Fabric, Quilt, Forge oder NeoForge, Minecraft 1.14 bis 26.x): Im Pausemenü wird „Feedback geben“ zu „Mods verwalten“ (ab 1.21 unter „Mods & Feedback“, in 26.x als Puzzle-Symbol). Es öffnet sich ein AeroMC-Fenster über dem Spiel mit zwei Listen wie bei den Ressourcenpaketen – „Aktive Mods“ und „Deaktivierte Mods“, ein Klick verschiebt eine Mod in die andere Liste, mit Suche und Warnung, wenn andere Mods sie brauchen
+- Das Spiel läuft dabei weiter: Geladene Mods lassen sich nicht im laufenden Spiel entladen, die Änderung wird vorgemerkt und beim Beenden übernommen
+- „Übernehmen & neu starten“: Minecraft speichert, startet mit den neuen Mods neu und verbindet automatisch wieder mit demselben Server (ab 1.20 auch zurück in dieselbe Einzelspieler-Welt) – mit demselben Konto wie vorher; im Mod-Fenster steht, wohin der Neustart führt
+- Neustart-Bildschirm: Während des Neustarts liegt der AeroMC-Ladebildschirm über dem Spielfenster und zeigt, was gerade passiert („Mods werden übernommen …“, „Minecraft startet …“, „Verbinde mit … “) – bis man wieder auf dem Server bzw. in der Welt ist
+- Nach dem Neustart hat das Spielfenster wieder dieselbe Größe und Lage wie vorher – war es maximiert, ist es wieder maximiert
+- Auch im Mod-Dialog des Launchers lassen sich Mods jetzt umschalten, während das Spiel läuft („ab nächstem Start“) – vorher kam eine Fehlermeldung, weil Windows die Dateien sperrt
+- Abschaltbar unter Optionen → Spiel → Mods im Spiel verwalten
+
+### Behoben
+- Mod-Dateien, die aus dem Explorer auf eine Gruppe in der Instanzliste gezogen wurden, wurden stillschweigend ignoriert
+- Ingame-Meldungen und Fenster über dem Spiel fanden in manchen Fällen das versteckte Java-Konsolenfenster statt des Spielfensters
+
+## [1.2.1] - 2026-10-05
+
+### Neu
+- Garderobe im Skin-Fenster: Skins (samt Armform) und eigene AeroMC-Umhänge speichern und mit einem Klick wieder anziehen – vor jedem Skinwechsel im Launcher wird der bisherige Skin automatisch gesichert, denn Mojang merkt sich keine alten Skins
+- Erfolge: 17 Erfolge (z. B. Spielzeit, Starts, Instanzen, Mods, Modpack, erster Freund, eigener Umhang, Skin aus dem Editor) mit „Erfolg erzielt!“-Meldung passend zum Design (im Minecraft-Design wie im Spiel); ein Klick auf die Meldung öffnet die Übersicht
+- Freunde mit 3D-Figur: Neben der Freundesliste dreht sich groß die Figur des ausgewählten Freundes mit Skin, 2. Ebene und Umhang (online läuft sie, offline steht sie) – das Freunde-Fenster ist dafür breiter, schmal gezogen steht die Figur über der Liste; die Köpfe in der Liste zeigen ebenfalls die 2. Ebene
+- Leistungs-Paket im Mod-Dialog: installiert mit einem Klick passende Performance-Mods – Sodium (bzw. Embeddium), Lithium (bzw. Radium), FerriteCore, Entity Culling, ImmediatelyFast, ModernFix und Dynamic FPS; Vorhandenes und für die Version nicht Verfügbares wird übersprungen, mit OptiFine bleibt Sodium weg
+- Starten-Knopf mit Fortschritt: füllt sich während Download und Vorbereitung und zeigt die Phase (z. B. „Assets 57 %“), danach kurz „Läuft ✓“
+- Mehr Leben in der Oberfläche (alles über „Bewegte Oberfläche“ abschaltbar):
+  - Laufende Instanzen haben einen pulsierenden Rand – man sieht sofort, was gerade gespielt wird
+  - Instanzen löschen, verschieben oder Gruppen auf-/zuklappen: Karten schrumpfen weg bzw. blenden ein, die übrigen rutschen weich nach
+  - Skin übernommen: Die Figur dreht sich einmal um sich selbst; nach einem Umhang-Wechsel weht der Umhang kurz auf
+  - Konto gewechselt: Der Spielerkopf oben rechts dreht sich wie eine Münze zum neuen Konto
+  - Erfolg erzielt: Funken um die Meldung, im Minecraft-Design grüne XP-Kugeln
+  - Freund kommt online: Sein Kopf hüpft in der Freundesliste, der grüne Punkt pulsiert
+  - AeroMC/Nachtlila: dezent treibende Lichtpunkte im Instanzbereich
+  - Minecraft-Design: Wolken ziehen durch die Werkzeugleiste, und beim Download zeigt das Block-Symbol der Instanz Abbau-Risse als Fortschritt
+  - Das Zahnrad dreht sich beim Darüberfahren, das Block-Symbol einer Instanz kippt leicht zur Maus
+- Armform-Prüfung im Skin-Fenster: Passt die eingestellte Armform nicht zur Skin-Datei (gequetschte Arme oder dunkle Streifen), zeigt AeroMC einen Hinweis und stellt sie mit einem Klick richtig
+- Absturz-Assistent erkennt zu alte Forge-Versionen, die mit aktuellem Java 8 abstürzen („ManifestEntryVerifier“), und aktualisiert Forge auf Wunsch auf die neueste Version für dieselbe Minecraft-Version
+
+### Geändert
+- Statistik-Fenster mit zwei Reitern: „Spielzeit“ und „Erfolge (x/17)“
+- Update-Meldung zeigt die Änderungshinweise formatiert an (Überschriften, Listen, fett/kursiv, Code, Links) statt als rohen Markdown-Text; das Fenster ist dafür größer, Links öffnen im Browser
+- Einstellungen aufgeräumt: jede Option als eigene Zeile mit kurzer Erklärung und Schalter statt Häkchen, alles einspaltig statt verstreuter Kacheln; neu sortiert in Allgemein, Darstellung, Spiel (inkl. Konsole), Java & Erweitert, Freunde & Umhänge (neu), Netzwerk, Konten, Backup (Welt-Sicherung jetzt bei „Automatisch sichern“)
+
+### Behoben
+- Alte Forge-Versionen vor Minecraft 1.13 (z. B. 1.12.2) starteten nicht („Hauptklasse net.minecraft.launchwrapper.Launch konnte nicht gefunden werden“) – Klassenpfad und Startargumente fehlten
+- Bei Forge und NeoForge wurde ohne festgelegte Version teils die älteste statt der neuesten Version gewählt – die Versionsliste ist jetzt richtig sortiert
+- Der Mod-Katalog zeigte bei von Hand kopierten oder importierten Mods „Installieren“, obwohl sie schon da waren – AeroMC erkennt sie jetzt per Prüfsumme über Modrinth
+- Der ZIP-Import (AeroMC-Export oder gezippte MultiMC/Prism-Instanz) blockierte bei großen Archiven den Launcher – die Dateien werden jetzt im Hintergrund verschoben bzw. kopiert
+
+## [1.2.0] - 2026-10-04
+
+### Neu
+- Untergruppen (optional): im Feld „Gruppe“ mit „/“ trennen, z. B. „Modpacks/Survival“ – auch mehrere Ebenen tief. Untergruppen erscheinen eingerückt unter ihrer Gruppe, lassen sich einzeln einklappen und per Drag & Drop befüllen; die Anzahl an einer Gruppe zählt ihre Untergruppen mit
+- Importe aus anderen Launchern zeigen jetzt genauen Fortschritt: Instanz x von y, übertragene GB, Prozent, Tempo, Restzeit und die gerade kopierte Datei
+- Import abbrechen: fertig übernommene Instanzen bleiben erhalten, die gerade halb kopierte wird wieder entfernt
+- Vor dem Kopieren prüft AeroMC, ob genug Speicherplatz frei ist, und nennt sonst benötigte und freie GB
+- Konto-Menü oben rechts (wie in MultiMC): Ein Klick auf den Kontonamen klappt alle Konten mit Spielerkopf auf – das aktive ist markiert, ein Klick wechselt sofort. Dazu „Konto hinzufügen…“, „Skin ändern…“ und „Konten verwalten…“
+
+### Geändert
+- Plugin „AeroMC Freunde“ 1.5.1: merkt sich den von Mojang bestätigten Namen schon bei der Anmeldung und beim Senden einer Anfrage – Spieler sind damit per Name auffindbar, bevor sie zum ersten Mal über AeroMC gespielt haben (Server-Update empfohlen, der Launcher funktioniert auch mit 1.5.0)
+
+### Behoben
+- Freundschaftsanfragen zeigten statt des Namens nur eine lange ID (UUID), wenn der Absender noch nie über AeroMC gespielt hatte – fehlende Namen holt der Launcher jetzt direkt bei Mojang (auch in der Freundesliste und bei gesendeten Anfragen)
+- Große Importe (viele GB, z. B. 60 GB aus MultiMC/Prism, CurseForge, Modrinth App, Minecraft Launcher oder Technic) froren den Launcher komplett ein – kopiert wird jetzt im Hintergrund, der Launcher bleibt bedienbar
+- Einzelne gesperrte Dateien (z. B. eine gerade geöffnete Welt) brechen den Import nicht mehr ab, sie werden übersprungen und gemeldet
+- „Instanz kopieren“, „Löschen“ und das Ersetzen einer vorhandenen Instanz beim erneuten Import blockierten bei großen Instanzen den Launcher – das läuft jetzt im Hintergrund
+- Der Spielerkopf oben neben dem Kontonamen und in der Kontoliste zeigte die 2. Skin-Ebene (Mütze, Haare, Kragen, Ärmel) nicht sichtbar – er wird jetzt selbst in 3D gezeichnet, die 2. Ebene steht wie im Spiel plastisch ab
+
+## [1.1.9] - 2026-10-04
+
+### Neu
+- Startanimation: Beim Öffnen dreht sich das AeroMC-Logo mit Schriftzug, danach baut sich der Launcher von der Mitte nach außen auf – Schriftzug passend zum Design (Minecraft mit Pixel-Schrift), nicht beim Start im Infobereich
+- Lebendige Skin-Figur im Hintergrund: atmet, wiegt sich leicht, der Umhang schwingt, und der Kopf folgt dem Mauszeiger – pausiert, solange der Launcher minimiert oder im Hintergrund ist
+- Fenster wie Optionen, Mods, Skin und Freunde wachsen beim Öffnen aus dem angeklickten Knopf heraus
+- Instanzen blenden beim Öffnen des Launchers nacheinander ein; beim Darüberfahren hebt sich das Block-Symbol und dreht sich ein Stück
+- Designwechsel blenden weich über statt hart umzuschalten
+- Optionen → Darstellung → Animationen: „Startanimation“ und „Bewegte Oberfläche“ einzeln abschaltbar; ist in Windows „Animationen anzeigen“ aus, bleibt die Oberfläche ruhig
+
+## [1.1.8] - 2026-10-04
+
+### Behoben
+- Das Skin-Fenster und „Aktuellen Skin laden“ im Skin-Editor zeigten bei manchen Konten einen Standard-Skin (z. B. Efe) statt des eigenen Skins – angezeigt wird jetzt der Skin, den andere Spieler im Spiel sehen; direkt nach einer eigenen Skin-Änderung noch kurz der neue Stand aus dem Konto, bis Mojang ihn überall verteilt hat
+
+## [1.1.7] - 2026-10-03
+
+### Neu
+- Umhänge im Skin-Fenster: offiziellen Mojang-Umhang auswählen oder ablegen (Liste zeigt alle Umhänge, die das Konto besitzt) und den eigenen AeroMC-Umhang verwalten – Figur und Skin-Hintergrund zeigen den Umhang mit
+- Skin-Editor, neuer Modus „Umhang“: eigene Umhänge gestalten, auch in HD bis 1024×512 – mit allen Werkzeugen, Pinselgröße, Spiegeln (linke ↔ rechte Kante), Zoom und Verschieben, Rückgängig auch über Größenwechsel
+- Umhang auf der 3D-Figur bemalen, wahlweise als Elytra ansehen, beliebiges Bild (PNG, JPG …) mit „Bild einsetzen…“ auf die Außenseite setzen, aktuellen Umhang laden, als PNG speichern oder mit „Als Umhang übernehmen“ hochladen
+- AeroMC-Umhänge im Spiel: in jeder Minecraft-Version und mit jedem Loader (Vanilla, Fabric, Quilt, Forge, NeoForge) ohne zusätzliche Mod sichtbar – für einen selbst und für andere AeroMC-Spieler; abschaltbar unter Optionen → Spiel → Umhänge
+- Mod „AeroMC Umhänge“ für Fabric und Quilt: damit sehen auch Spieler mit anderen Launchern (offizieller Launcher, MultiMC, Prism, Modrinth App …) die AeroMC-Umhänge – ein Jar für Minecraft 1.14 bis 26.x, nur auf dem Client nötig
+
+### Geändert
+- Suche in der Werkzeugleiste: statt des dauerhaft sichtbaren Suchfelds gibt es eine Lupe – ein Klick oder Strg+F klappt das Feld auf, Esc leert und schließt es, mit Suchbegriff bleibt es offen
+- Benötigt für eigene Umhänge das Plugin „AeroMC Freunde“ 1.5.0 auf dem Server
+
+## [1.1.6] - 2026-10-03
 
 ### Neu
 - Skin-Editor: Skins direkt im Launcher pixeln – erreichbar im Skin-Fenster über „Im Editor bearbeiten…“
@@ -15,11 +129,14 @@ Alle nennenswerten Änderungen an AeroMC werden hier festgehalten.
 - Aktuellen Skin laden, PNG öffnen oder speichern und das Ergebnis mit einem Klick als Skin übernehmen – klassische und schmale Arme, alte 64×32-Skins werden automatisch umgewandelt
 - Skin-Hintergrund: Armform wählbar (Optionen → Darstellung) – „Automatisch“ übernimmt die Armform des Kontos, alternativ fest „Normal“ oder „Schmal“
 - Designs zur Auswahl (Optionen → Darstellung → Design, mit Vorschau-Kacheln): „Klassisch“ hell oder dunkel wie bisher, „AeroMC“ im Look der Webseite (Nachtblau, Cyan-Verläufe, runde Knöpfe), „Nachtlila“ (wie AeroMC, nur in dunklem Lila) und „Minecraft“ mit Block-Optik, Stein-Knöpfen, grünem Starten-Knopf und eigener Pixel-Schrift
-- Ein gewähltes Design gilt sofort in allen offenen Fenstern
+- Ein Klick auf eine Kachel zeigt das Design sofort zur Probe, nach dem Speichern gilt es in allen offenen Fenstern
 - Eigene Titelleiste im Design statt der weißen Windows-Leiste – Minimieren, Maximieren und Schließen bleiben echte Windows-Knöpfe (Andocken, Fensterlayouts) und werden passend eingefärbt
 - Import aus der Modrinth App (Importieren → „Modrinth App“, auch im Installer): übernimmt Name, Gruppe, Symbol, Minecraft-Version, Loader, Arbeitsspeicher, Java-Einstellungen, Spielzeit sowie Mods, Welten und Einstellungen – auch bei verlegtem Datenordner und während die Modrinth App läuft
 - Aus der Modrinth App übernommene Modrinth-Modpacks bleiben mit ihrem Paket verknüpft und lassen sich in AeroMC aktualisieren
 
+### Geändert
+- Die Design-Auswahl (bisher „Design: Dunkel/Hell“ unter Optionen → Allgemein) steht jetzt unter Optionen → Darstellung
+
 ### Behoben
 - Das Symbol für „Optionen“ sah aus wie eine Sonne – jetzt ein Zahnrad
 - Der Skin-Hintergrund zeigte schmale (Alex-)Skins mit breiten Armen – dadurch erschienen falsche Streifen an den Armen

Datenschutzerklaerung-Store.txt

@@ -0,0 +1,112 @@
+DATENSCHUTZERKLÄRUNG FÜR AEROMC
+Stand: 7. Oktober 2026
+
+Diese Datenschutzerklärung gilt für den Minecraft-Launcher AeroMC und die zugehörigen Online-Dienste. AeroMC ist ein inoffizielles Programm und steht in keiner Verbindung zu Mojang Studios oder Microsoft.
+
+
+1. VERANTWORTLICHER
+
+[Vor- und Nachname]
+[Straße und Hausnummer]
+[PLZ und Ort]
+[Land]
+E-Mail: [E-Mail-Adresse]
+
+
+2. GRUNDSATZ
+
+AeroMC läuft auf deinem Computer. Instanzen, Mods, Welten, Screenshots, Aufnahmen, Einstellungen und Sicherungen werden nur lokal gespeichert. Diese Daten erhalten wir nicht.
+
+Personenbezogene Daten werden nur übertragen, wenn du eine Funktion nutzt, die das erfordert, zum Beispiel die Anmeldung mit deinem Microsoft-Konto oder das Freundesystem. Es gibt keine Werbung, kein Tracking und keine Analyse-Dienste.
+
+
+3. ANMELDUNG MIT MICROSOFT / MINECRAFT
+
+Um Minecraft: Java Edition zu starten, meldest du dich mit deinem Microsoft-Konto an. Die Anmeldung läuft direkt zwischen deinem Computer und den Diensten von Microsoft, Xbox Live und Mojang.
+
+- Dein Passwort gibst du nur auf der Seite von Microsoft ein. AeroMC sieht es nicht.
+- Die erhaltenen Zugangsschlüssel, dein Minecraft-Name und deine Spieler-ID (UUID) werden verschlüsselt auf deinem Computer gespeichert.
+- Änderst du Skin oder Umhang über AeroMC, wird das an Mojang übertragen.
+
+Es gelten die Datenschutzbestimmungen von Microsoft: https://privacy.microsoft.com/de-de/privacystatement
+Rechtsgrundlage: Art. 6 Abs. 1 lit. b DSGVO.
+
+
+4. FREUNDESYSTEM UND AEROMC-DIENSTE
+
+Das Freundesystem ist optional und lässt sich unter Optionen → Freunde & Umhänge jederzeit abschalten. Es läuft auf unserem Server viper-network.de.
+
+Die Anmeldung erfolgt wie bei einem Minecraft-Server über die Sitzungsprüfung von Mojang. Ein eigenes Passwort gibt es nicht. Deine Microsoft-Zugangsdaten erhalten wir nicht.
+
+Wir speichern:
+- Minecraft-Spieler-ID und Minecraft-Name – um dich im Freundesystem zu erkennen und auffindbar zu machen; bis zur Löschung auf Anfrage.
+- Sitzungsschlüssel (nur als Prüfwert) – um angemeldet zu bleiben; 30 Tage nach letzter Nutzung gelöscht.
+- Online-Status: Zeitpunkt, Instanzname, Minecraft-Version und – sofern nicht abgeschaltet – die Server-Adresse, auf der du spielst; wird bei jeder Nutzung überschrieben.
+- Freundschaften und Freundschaftsanfragen – bis du sie entfernst.
+- Einladungen auf einen Server – 10 Minuten.
+- Kurznachrichten und mitgeschickte Screenshots – 7 Tage.
+- Eigene Umhänge (Bilddatei) – bis du sie entfernst.
+- Geteilte Instanzen (Liste von Version, Loader und Mods, keine Dateien) – 30 Tage.
+
+Diese Daten sehen nur deine Freunde bzw. die Personen, denen du etwas schickst oder einen Code gibst. Eigene Umhänge sind für alle AeroMC-Spieler sichtbar, die dir im Spiel begegnen.
+Rechtsgrundlage: Art. 6 Abs. 1 lit. b DSGVO.
+
+
+5. FEHLERBERICHTE (FREIWILLIG)
+
+Stürzt Minecraft ab, kann der Absturz-Assistent auf deinen ausdrücklichen Wunsch einen Fehlerbericht senden. Er enthält Launcher-, Minecraft- und Loader-Version, Windows-Version, Arbeitsspeicher, die Mod-Liste der Instanz, das Ende von Absturzbericht, Spielprotokoll und Konsolenausgabe sowie deinen optionalen Kommentar.
+
+Dein Minecraft-Name und deine Spieler-ID werden vor dem Senden entfernt, außer du wählst ausdrücklich, den Bericht mit Namen zu senden. Fehlerberichte nutzen wir nur zur Fehlerbehebung und löschen sie, sobald sie nicht mehr benötigt werden.
+Rechtsgrundlage: Art. 6 Abs. 1 lit. a DSGVO (Einwilligung durch das Absenden).
+
+
+6. DOWNLOADS VON SPIELDATEIEN UND INHALTEN
+
+Für Minecraft, Java und die von dir gewählten Inhalte lädt AeroMC Dateien direkt bei den jeweiligen Anbietern herunter. Diese erhalten technisch bedingt deine IP-Adresse und übliche Verbindungsdaten, aber keine weiteren personenbezogenen Daten:
+- Mojang / Microsoft – Minecraft-Dateien, Skins und Umhänge
+- Eclipse Adoptium – Java-Laufzeit
+- Modrinth – Mods, Ressourcenpakete, Shader, Modpacks
+- CurseForge – Mods und Modpacks (die Suche läuft über unseren Weiterleitungs-Server)
+- Fabric, Quilt, Forge, NeoForge – Mod-Loader
+- Technic – Technic-Modpacks
+
+Es gelten die Datenschutzbestimmungen des jeweiligen Anbieters.
+Rechtsgrundlage: Art. 6 Abs. 1 lit. b DSGVO.
+
+
+7. ANZEIGE VON SKINS
+
+Zur Darstellung von Spielerfiguren ruft AeroMC Bilder anhand der Spieler-ID bei crafthead.net, visage.surgeplay.com und nmsr.nickac.dev ab. Diese erhalten die Spieler-ID und deine IP-Adresse.
+Rechtsgrundlage: Art. 6 Abs. 1 lit. f DSGVO.
+
+
+8. UPDATES
+
+Die Fassung aus dem Microsoft Store wird ausschließlich über den Microsoft Store aktualisiert. Die Fassung von unserer Webseite prüft beim Start auf unseren Servern, ob es eine neue Version gibt. Dabei wird außer der IP-Adresse nichts übertragen.
+Rechtsgrundlage: Art. 6 Abs. 1 lit. f DSGVO.
+
+
+9. DISCORD
+
+Läuft auf deinem Computer Discord, kann AeroMC dort anzeigen, welche Instanz du spielst. Diese Information geht nur an das Discord-Programm auf deinem Computer und von dort nach den Bestimmungen von Discord an deine Discord-Kontakte.
+
+
+10. SERVER-PROTOKOLLE
+
+Beim Zugriff auf unsere Server werden technisch bedingt IP-Adresse, Zeitpunkt und angefragte Adresse kurzzeitig protokolliert, um Betrieb und Sicherheit zu gewährleisten.
+Rechtsgrundlage: Art. 6 Abs. 1 lit. f DSGVO.
+
+
+11. DEINE RECHTE
+
+Du hast das Recht auf Auskunft, Berichtigung, Löschung, Einschränkung der Verarbeitung, Datenübertragbarkeit und Widerspruch. Eine Einwilligung kannst du jederzeit für die Zukunft widerrufen. Wende dich dafür an die oben genannte E-Mail-Adresse und gib deinen Minecraft-Namen an. Du kannst dich außerdem bei einer Datenschutz-Aufsichtsbehörde beschweren.
+
+
+12. KINDER
+
+AeroMC richtet sich nicht an Kinder unter 16 Jahren. Jüngere sollten das Freundesystem nur mit Zustimmung der Eltern nutzen.
+
+
+13. ÄNDERUNGEN
+
+Wir passen diese Datenschutzerklärung an, wenn sich AeroMC oder die Rechtslage ändert. Es gilt die jeweils aktuelle Fassung.

Datenschutzerklaerung.md

@@ -0,0 +1,192 @@
+# Datenschutzerklärung für AeroMC
+
+Stand: 7. Oktober 2026
+
+Diese Datenschutzerklärung gilt für den Minecraft-Launcher **AeroMC** (Windows-Programm, auch
+aus dem Microsoft Store) und die zugehörigen Online-Dienste. AeroMC ist ein inoffizielles
+Programm und steht in keiner Verbindung zu Mojang Studios oder Microsoft.
+
+---
+
+## 1. Verantwortlicher
+
+**[Vor- und Nachname]**
+[Straße und Hausnummer]
+[PLZ und Ort]
+[Land]
+E-Mail: **[E-Mail-Adresse]**
+
+---
+
+## 2. Grundsatz
+
+AeroMC läuft auf deinem Computer. Instanzen, Mods, Welten, Screenshots, Aufnahmen,
+Einstellungen und Sicherungen werden **nur lokal** gespeichert, im Ordner
+`%APPDATA%\AeroMC` bzw. `Dokumente\AeroMC Launcher`. Diese Daten erhalten wir nicht.
+
+Personenbezogene Daten werden nur übertragen, wenn du eine Funktion nutzt, die das
+erfordert – zum Beispiel die Anmeldung mit deinem Microsoft-Konto oder das Freundesystem.
+Es gibt **keine Werbung, kein Tracking und keine Analyse-Dienste**.
+
+---
+
+## 3. Anmeldung mit Microsoft / Minecraft
+
+Um Minecraft: Java Edition zu starten, meldest du dich mit deinem Microsoft-Konto an.
+Die Anmeldung läuft direkt zwischen deinem Computer und den Diensten von Microsoft, Xbox Live
+und Mojang (`login.microsoftonline.com`, `user.auth.xboxlive.com`, `xsts.auth.xboxlive.com`,
+`api.minecraftservices.com`, `sessionserver.mojang.com`).
+
+- Dein Passwort gibst du nur auf der Seite von Microsoft ein. AeroMC sieht es nicht.
+- Die erhaltenen Zugangsschlüssel (Tokens), dein Minecraft-Name und deine Spieler-ID (UUID)
+  werden **verschlüsselt auf deinem Computer** gespeichert (Windows-Datenschutz-API).
+- Änderst du Skin oder Umhang über AeroMC, wird das an Mojang übertragen.
+
+Für diese Datenverarbeitung gelten die Datenschutzbestimmungen von Microsoft:
+https://privacy.microsoft.com/de-de/privacystatement
+
+**Rechtsgrundlage:** Art. 6 Abs. 1 lit. b DSGVO (Bereitstellung der von dir gewünschten
+Funktion).
+
+---
+
+## 4. Freundesystem und AeroMC-Dienste
+
+Das Freundesystem ist optional und lässt sich in den Einstellungen
+(Optionen → Freunde & Umhänge) jederzeit abschalten. Es läuft auf unserem Server
+`viper-network.de`.
+
+### Anmeldung am Freundesystem
+AeroMC meldet dich wie ein Minecraft-Server über die Sitzungsprüfung von Mojang an. Dabei
+wird bestätigt, dass du der Besitzer deines Minecraft-Kontos bist. Ein eigenes Passwort gibt
+es nicht. Wir erhalten **nicht** deine Microsoft-Zugangsdaten.
+
+### Welche Daten wir speichern
+
+| Daten | Zweck | Speicherdauer |
+|---|---|---|
+| Minecraft-Spieler-ID (UUID) und Minecraft-Name | dich im Freundesystem erkennen und auffindbar machen | bis zur Löschung auf Anfrage |
+| Sitzungsschlüssel (nur als Prüfwert) | angemeldet bleiben | 30 Tage nach letzter Nutzung |
+| Online-Status: Zeitpunkt, Instanzname, Minecraft-Version und – falls du es nicht abgeschaltet hast – die Server-Adresse, auf der du spielst | Freunden zeigen, dass und wo du spielst | wird bei jeder Nutzung überschrieben |
+| Freundschaften und Freundschaftsanfragen | Freundesliste | bis du sie entfernst |
+| Einladungen auf einen Server | „Komm auf meinen Server“ | 10 Minuten |
+| Kurznachrichten und mitgeschickte Screenshots | Nachrichten zwischen Freunden | 7 Tage |
+| Eigene Umhänge (Bilddatei) | deinen Umhang anderen AeroMC-Spielern anzeigen | bis du ihn entfernst |
+| Geteilte Instanzen (Liste von Version, Loader und Mods, keine Dateien) | Instanz per Code mit Freunden teilen | 30 Tage |
+
+Diese Daten sehen nur deine Freunde bzw. die Personen, denen du etwas schickst oder einen
+Code gibst. Eigene Umhänge sind für alle AeroMC-Spieler sichtbar, die dir im Spiel begegnen.
+
+**Rechtsgrundlage:** Art. 6 Abs. 1 lit. b DSGVO.
+
+---
+
+## 5. Fehlerberichte (freiwillig)
+
+Stürzt Minecraft ab, kann der Absturz-Assistent auf **deinen ausdrücklichen Wunsch** einen
+Fehlerbericht an uns senden. Er enthält:
+
+- Launcher-, Minecraft- und Loader-Version
+- Windows-Version, Größe des Arbeitsspeichers und den eingestellten Speicher der Instanz
+- die Liste der Mods der Instanz
+- das Ende von Absturzbericht, Spielprotokoll und Konsolenausgabe
+- deinen optionalen Kommentar
+
+Dein Minecraft-Name und deine Spieler-ID werden vor dem Senden aus dem Bericht entfernt,
+außer du wählst ausdrücklich, den Bericht mit deinem Namen zu senden.
+
+Fehlerberichte nutzen wir nur, um Fehler in AeroMC zu finden und zu beheben. Sie werden
+gelöscht, sobald sie nicht mehr benötigt werden.
+
+**Rechtsgrundlage:** Art. 6 Abs. 1 lit. a DSGVO (Einwilligung durch das Absenden).
+
+---
+
+## 6. Downloads von Spieldateien und Inhalten
+
+Für Minecraft, Java und die Inhalte, die du auswählst, lädt AeroMC Dateien direkt bei den
+jeweiligen Anbietern herunter. Dabei erhält der Anbieter technisch bedingt deine
+**IP-Adresse** und übliche Verbindungsdaten. Weitere personenbezogene Daten werden dabei
+nicht übertragen.
+
+| Anbieter | Wofür |
+|---|---|
+| Mojang / Microsoft (`piston-meta.mojang.com`, `libraries.minecraft.net`, `resources.download.minecraft.net`, `textures.minecraft.net`) | Minecraft-Dateien, Skins und Umhänge |
+| Eclipse Adoptium (`api.adoptium.net`) | Java-Laufzeit |
+| Modrinth (`api.modrinth.com`) | Mods, Ressourcenpakete, Shader, Modpacks |
+| CurseForge (`api.curseforge.com`, `edge.forgecdn.net`) | Mods und Modpacks – die Suche läuft über unseren Weiterleitungs-Server `curse.viper.ipv64.net` |
+| Fabric, Quilt, Forge, NeoForge (`meta.fabricmc.net`, `meta.quiltmc.org`, `maven.minecraftforge.net`, `maven.neoforged.net`) | Mod-Loader |
+| Technic (`api.technicpack.net`) | Technic-Modpacks |
+
+Es gelten die Datenschutzbestimmungen des jeweiligen Anbieters.
+
+**Rechtsgrundlage:** Art. 6 Abs. 1 lit. b DSGVO.
+
+---
+
+## 7. Anzeige von Skins
+
+Für die Darstellung von Spielerfiguren und Köpfen im Launcher ruft AeroMC Bilder anhand der
+Spieler-ID (UUID) bei folgenden Diensten ab: `crafthead.net`, `visage.surgeplay.com` und
+`nmsr.nickac.dev`. Diese erhalten dabei die Spieler-ID und deine IP-Adresse.
+
+**Rechtsgrundlage:** Art. 6 Abs. 1 lit. f DSGVO (berechtigtes Interesse an der Darstellung
+der Spielfiguren).
+
+---
+
+## 8. Updates
+
+Die Fassung von unserer Webseite prüft beim Start, ob es eine neue Version gibt
+(`git.viper.ipv64.net` und `viper-network.de`). Die Fassung aus dem Microsoft Store wird
+ausschließlich über den Microsoft Store aktualisiert. Dabei werden keine personenbezogenen
+Daten außer deiner IP-Adresse übertragen.
+
+**Rechtsgrundlage:** Art. 6 Abs. 1 lit. f DSGVO (Sicherheit und Aktualität des Programms).
+
+---
+
+## 9. Discord
+
+Läuft auf deinem Computer Discord, kann AeroMC dort anzeigen, dass und welche Instanz du
+spielst („Rich Presence“). Diese Information geht nur an das Discord-Programm auf deinem
+Computer und von dort nach den Bestimmungen von Discord an deine Discord-Kontakte.
+
+---
+
+## 10. Server-Protokolle
+
+Beim Zugriff auf unsere Server (`viper-network.de`, `git.viper.ipv64.net`,
+`curse.viper.ipv64.net`, `aeromc.viper.ipv64.net`) werden technisch bedingt IP-Adresse,
+Zeitpunkt und angefragte Adresse kurzzeitig protokolliert, um den Betrieb und die Sicherheit
+der Server zu gewährleisten.
+
+**Rechtsgrundlage:** Art. 6 Abs. 1 lit. f DSGVO.
+
+---
+
+## 11. Deine Rechte
+
+Du hast das Recht auf **Auskunft** über deine gespeicherten Daten, auf **Berichtigung**,
+**Löschung**, **Einschränkung der Verarbeitung**, **Datenübertragbarkeit** sowie auf
+**Widerspruch** gegen die Verarbeitung. Eine erteilte Einwilligung kannst du jederzeit für
+die Zukunft widerrufen.
+
+Wende dich dafür an die oben genannte E-Mail-Adresse. Gib dabei bitte deinen Minecraft-Namen
+an, damit wir deine Daten finden.
+
+Du kannst dich außerdem bei einer Datenschutz-Aufsichtsbehörde beschweren.
+
+---
+
+## 12. Kinder
+
+AeroMC richtet sich nicht an Kinder unter 16 Jahren. Wer jünger ist, sollte das Freundesystem
+nur mit Zustimmung der Eltern nutzen.
+
+---
+
+## 13. Änderungen
+
+Wir passen diese Datenschutzerklärung an, wenn sich AeroMC oder die Rechtslage ändert. Es
+gilt die jeweils auf dieser Seite veröffentlichte Fassung.

README.md

@@ -6,7 +6,7 @@
 
 Ein Minecraft-Launcher für Windows mit getrennten Instanzen, Mod-Unterstützung, Spielaufzeichnung, Freundesystem und Microsoft-Anmeldung.
 
-Aktueller Stand: Version 1.1.6
+Aktueller Stand: Version 1.2.0
 
 <img src="docs/aeromc.png" alt="AeroMC – Instanzliste mit Seitenleiste und Skin-Vorschau" width="820" />
 
@@ -62,9 +62,13 @@ Der Launcher konzentriert sich auf den Alltag: Instanz anlegen, Konto auswählen
 - Eigener Server auf Wunsch verborgen, Freundesystem komplett abschaltbar
 
 **Konten, Welten und Backups**
-- Microsoft-Login mit mehreren Konten
+- Microsoft-Login mit mehreren Konten – Wechsel mit einem Klick über das Konto-Menü oben rechts
 - Eigenen Skin im Launcher hochladen, mit Live-Vorschau anpassen (klassisch/schlank) und zurücksetzen
 - **Skin-Editor mit zwei Schichten**: Skins selbst pixeln – auf der Vorlage oder direkt auf der 3D-Figur, mit Spiegeln, Füllen, Pipette und Rückgängig
+- **Eigene Umhänge, auch HD bis 1024×512**: im Skin-Editor gestalten, im Spiel in jeder Version und mit jedem Loader sichtbar – für Spieler mit anderen Launchern gibt es den Mod „AeroMC Umhänge“
+- Offiziellen Mojang-Umhang direkt im Launcher wechseln oder ablegen
+- **Garderobe**: Skins und Umhänge speichern und mit einem Klick wieder anziehen – der bisherige Skin wird vor jedem Wechsel automatisch gesichert
+- Armform-Prüfung: Hinweis und Ein-Klick-Korrektur, wenn die Armform nicht zur Skin-Datei passt
 - Skin-Hintergrund des aktiven Kontos (mehrere Posen, passende Armform, einstellbare Deckkraft, optional wechselnd)
 - Welten, Ressourcenpakete, Datenpakete, Screenshots, Serverliste und Logdateien verwalten
 - Serverliste mit Live-Status und Desktop-Verknüpfung pro Server (startet die Instanz und verbindet direkt)
@@ -130,7 +134,7 @@ Automatische Updates bleiben getrennt: Setup erhält nur Setup-Updates, Portable
 
 Jede Instanz hat:
 
-- Namen und optionale Gruppe
+- Namen und optionale Gruppe – Untergruppen mit „/“ trennen, z. B. `Modpacks/Survival` (eingerückt, einzeln einklappbar, per Drag & Drop befüllbar)
 - Minecraft-Version und optionalen Mod-Loader
 - optionales Icon (vorgegeben, aus Minecraft extrahiert oder eigenes Bild) und Notizen
 - eigene Mods, Ressourcenpakete, Shader, Welten, Datenpakete, Screenshots, Aufzeichnungen und Serverliste
@@ -162,7 +166,7 @@ Im Launcher:
 
 | Taste | Wirkung |
 |---|---|
-| Strg+F | Suche fokussieren |
+| Strg+F | Suche öffnen (Lupe in der Werkzeugleiste), Esc leert und schließt sie |
 | Strg+N | Neue Instanz anlegen |
 | Strg+1 … Strg+5 | Schnellstart-Instanz starten |
 | Entf | Markierte Instanz(en) löschen |
@@ -195,6 +199,8 @@ Im Spiel (solange ein über AeroMC gestartetes Minecraft läuft):
 
 Existiert bereits eine Instanz mit demselben Namen, wird sie ersetzt.
 
+**Große Importe:** Auch viele Gigabyte werden im Hintergrund kopiert – der Launcher bleibt bedienbar. Vorher prüft AeroMC, ob genug Speicherplatz frei ist. Oben im Import-Fenster stehen Instanz, übertragene GB, Prozent, Tempo, Restzeit und die aktuelle Datei; **Abbrechen** behält fertig übernommene Instanzen und entfernt die halb kopierte. Einzelne gesperrte Dateien werden übersprungen und gemeldet.
+
 Beim offiziellen Minecraft Launcher werden nur benutzerdefinierte Profile angeboten (keine „Latest Release“/„Latest Snapshot“). Bei gemeinsamen Standard-Spielordnern übernimmt AeroMC spielrelevante Daten (Mods, Welten, Konfiguration), nicht den kompletten Cache.
 
 **Modrinth App:** Übernommen werden Name, Gruppe, Symbol, Minecraft-Version, Loader, Arbeitsspeicher, Java-Einstellungen, Spielzeit sowie Mods, Welten und Einstellungen. Modrinth-Modpacks bleiben mit ihrem Paket verknüpft und lassen sich weiter aktualisieren. Ein in der App verlegter Datenordner wird automatisch gefunden, und die Modrinth App darf dabei geöffnet bleiben – AeroMC liest auch ihr Schreibprotokoll mit. An den Daten der Modrinth App wird nichts verändert.
@@ -279,6 +285,33 @@ Die Änderung wird direkt bei Mojang für das angemeldete Konto hinterlegt und g
 | M | Spiegeln ein/aus |
 | L | Schicht wechseln |
 | Strg+Z / Strg+Y | Rückgängig / Wiederholen |
+| 0 | Umhang: Ansicht einpassen |
+
+### Umhänge
+
+Im Skin-Fenster (**Kontoname oben rechts → Skin ändern…**) gibt es den Bereich **Umhang**:
+
+- **Offizieller Umhang:** zeigt alle Umhänge, die dein Konto bei Mojang besitzt (z. B. Migrator, Pan …) – auswählen oder „Kein Umhang“. Das gilt wie der Skin überall, auch außerhalb von AeroMC.
+- **AeroMC-Umhang:** dein eigener Umhang, auch in HD. **Gestalten…** öffnet den Skin-Editor im Modus **Umhang**, **Entfernen** löscht ihn wieder.
+
+Im Editor-Modus **Umhang**:
+
+- Größe wählen: Normal (64×32) oder HD 128×64, 256×128, 512×256, 1024×512
+- Alle Werkzeuge wie beim Skin, dazu Pinselgröße (1–16 Pixel); Spiegeln malt linke und rechte Kante gleichzeitig
+- Mausrad zoomt, rechte oder mittlere Maustaste verschiebt die Ansicht, **0** passt sie wieder ein
+- In der 3D-Ansicht direkt auf dem Umhang an der Figur malen; **Als Elytra zeigen** zeigt dieselbe Datei als Flügel
+- **Bild einsetzen…** setzt ein beliebiges Bild (PNG, JPG …) auf die Außenseite
+- **Aktuellen Umhang laden**, PNG öffnen oder speichern, **Als Umhang übernehmen** lädt ihn hoch
+
+**Wer sieht den AeroMC-Umhang?**
+
+| Spieler | sieht den AeroMC-Umhang? |
+|---|---|
+| Spielt über AeroMC (Optionen → Spiel → Umhänge eingeschaltet) | Ja – in jeder Minecraft-Version und mit jedem Loader, ohne Mod |
+| Anderer Launcher mit Fabric oder Quilt und dem Mod **„AeroMC Umhänge“** | Ja – ein Jar für Minecraft 1.14 bis 26.x, nur auf dem Client nötig |
+| Anderer Launcher ohne den Mod (auch mit OptiFine) | Nein – sieht weiter den offiziellen Mojang-Umhang |
+
+Der AeroMC-Umhang hat Vorrang vor dem offiziellen Umhang. Benötigt das Plugin „AeroMC Freunde“ 1.5.0 auf dem Server.
 
 ## Backup und Wiederherstellung
 
@@ -308,10 +341,15 @@ Speicherort: `Dokumente\AeroMC Launcher\Backups`.
 ### Darstellung
 - Design: Klassisch Dunkel, Klassisch Hell, AeroMC, Nachtlila oder Minecraft – mit Vorschau-Kacheln, gilt nach dem Speichern in allen Fenstern
 - Block-Symbole räumlich (3D)
+- Animationen:
+  - **Startanimation**: Beim Öffnen dreht sich das AeroMC-Logo, danach baut sich das Fenster von der Mitte aus auf (nicht beim Start im Infobereich)
+  - **Bewegte Oberfläche**: Die Skin-Figur im Hintergrund atmet und schaut dem Mauszeiger nach, Fenster wachsen aus dem angeklickten Knopf, Instanzen blenden beim Öffnen ein und heben sich beim Darüberfahren, Designs blenden weich über
+  - Beides einzeln abschaltbar; ist in Windows „Animationen anzeigen“ aus, bleibt die Oberfläche ruhig
 - Skin-Hintergrund: Quelle, Pose, Armform (automatisch vom Konto, normal oder schmal), Deckkraft, optional automatischer Wechsel zwischen mehreren Konten
 
 ### Spiel
 - Standard-RAM (min./max.)
+- Umhänge: AeroMC-Umhänge im Spiel anzeigen (gilt ab dem nächsten Start)
 - Fenstergröße bzw. maximiert starten
 - Mods: vor jedem Start automatisch nach Updates suchen und installieren
 

Sicherheit.md

@@ -0,0 +1,86 @@
+# AeroMC – Sicherheit
+
+Überblick über die Sicherheitsmaßnahmen im AeroMC Launcher (Stand: Version 1.2.3).
+
+---
+
+## 1. Sichere Updates
+
+- **Digitale Signatur:** Jedes Update ist mit dem Release-Schlüssel des Entwicklers
+  unterschrieben (Ed25519). Der Launcher installiert nur Dateien mit gültiger Signatur.
+  Selbst wer den Update-Server übernimmt, kann so keine manipulierte EXE verteilen.
+- **Mehr als nur der Inhalt:** Unterschrieben werden Inhalt (SHA-256), Dateiname und Version.
+  Eine alte Version kann nicht als neue ausgegeben werden, Setup und Portable lassen sich
+  nicht vertauschen.
+- **Doppelte Prüfung:** einmal nach dem Download und noch einmal direkt vor dem Start.
+- **Getrennte Server:** Die Programmdatei und ihre Signatur liegen auf zwei verschiedenen
+  Servern. Ein Update ohne gültige Signatur wird nicht automatisch installiert.
+- **Feste Quelle:** Updates werden nur vom offiziellen AeroMC-Server geladen.
+
+## 2. Geschützte Programmdatei
+
+- **Aktuelle Technik:** AeroMC basiert auf Electron 44 mit aktuellem Chromium und Node.js
+  und erhält damit laufende Sicherheitsupdates.
+- **Keine Fernsteuerung:** Debug-Schnittstellen und der Node-Modus sind fest in der EXE
+  gesperrt. Der Launcher lässt sich weder von außen steuern noch für fremde Skripte
+  missbrauchen.
+- **Integritätsprüfung:** Beim Start prüft AeroMC, ob sein Programmpaket verändert wurde.
+  Ist das der Fall, startet es nicht.
+- **Keine fremden Webseiten:** Launcher-Fenster laden nie fremde Seiten, Links öffnen sich
+  immer im Browser.
+- **Geprüfte Abhängigkeiten:** Alle eingesetzten Programmbibliotheken sind ohne bekannte
+  Sicherheitslücken.
+
+## 3. Schutz der Instanzen
+
+- **Manipulationsschutz:** AeroMC merkt sich für jede Instanz einen Fingerabdruck aller
+  Mod-Dateien und der Starteinstellungen (Java, JVM-Argumente, Startbefehle).
+- **Automatische Sperre:** Wird eine Mod-Datei verändert (so arbeitet Schadsoftware, die
+  Mods infiziert) oder werden Starteinstellungen außerhalb des Launchers geändert, wird die
+  Instanz gesperrt und mit einem Verbotszeichen markiert.
+- **Gesperrte Instanzen** lassen sich nicht mehr starten, bearbeiten, kopieren, exportieren
+  oder teilen. Sie bleiben erhalten, bis man sie selbst löscht.
+- **Wiederherstellen:** Mit einem Klick wird die Instanz aus der neuesten sauberen
+  Sicherung als neue Instanz angelegt. Sicherungen, die bereits die veränderte Datei
+  enthalten, werden übersprungen.
+- **Normales Arbeiten bleibt möglich:** Neue, gelöschte, aktivierte oder deaktivierte Mods
+  gelten nicht als Manipulation. Änderungen über den Launcher werden automatisch übernommen.
+
+## 4. Geprüfte Downloads
+
+Jede heruntergeladene Datei wird mit der Prüfsumme der Quelle verglichen, bevor sie
+gespeichert wird. Eine veränderte oder beschädigte Datei wird verworfen.
+
+| Quelle | Prüfung |
+|---|---|
+| Minecraft, Bibliotheken und Assets (Mojang) | SHA-1 |
+| Java-Laufzeiten (Eclipse Temurin) | SHA-256 |
+| Mods, Ressourcenpakete, Shader (Modrinth) | SHA-512 / SHA-1 |
+| Mods, Ressourcenpakete, Shader (CurseForge) | SHA-1 |
+| Modpacks und ihre Dateien | Prüfsumme der Quelle, nur HTTPS |
+
+## 5. Sichere Importe
+
+- Beim Import von Instanzen aus ZIP-Archiven werden keine Java-Pfade und keine
+  JVM-Argumente aus dem Archiv übernommen – so kann ein präpariertes Archiv beim nächsten
+  Start keinen fremden Code ausführen.
+- Dateinamen aus Archiven werden geprüft, damit nichts außerhalb des Instanzordners landet.
+
+## 6. Geschützte Daten
+
+- **Konten:** Anmeldedaten von Microsoft und Minecraft werden mit der Windows-Verschlüsselung
+  (DPAPI) gespeichert – nur das eigene Windows-Konto kann sie lesen.
+- **Weitere Zugangsdaten:** Proxy-Passwort und CurseForge-Schlüssel werden ebenso
+  verschlüsselt gespeichert.
+- **Spielerweiterung:** Die Datei, die AeroMC für Umhänge und den AeroMC-Look ins Spiel
+  einbindet, wird vor jedem Spielstart mit dem Original verglichen und bei Abweichung
+  ersetzt.
+
+## 7. Freundesystem
+
+- **Anmeldung über Mojang:** Der Launcher meldet sich wie ein Minecraft-Server über Mojangs
+  Sitzungsprüfung an. Ein eigenes Passwort ist nicht nötig.
+- **Keine Identitätsfälschung:** Jede Anfrage im Namen eines Spielers muss angemeldet sein.
+  Niemand kann sich als ein anderer Spieler ausgeben.
+- **Privatsphäre:** Der eigene Server kann verborgen oder das Freundesystem ganz
+  abgeschaltet werden.

agent/src/de/aeromc/capes/Agent.java

@@ -0,0 +1,76 @@
+package de.aeromc.capes;
+
+import java.lang.instrument.Instrumentation;
+
+/**
+ * AeroMC-Agent.
+ *
+ * Wird vom Launcher per -javaagent an Minecraft angehängt (jede Version, jeder
+ * Loader) und kann zwei Dinge, einzeln zuschaltbar:
+ *
+ *   Umhänge:    klinkt sich in Mojangs authlib ein – über sie lädt Minecraft für
+ *               jeden Spieler Skin und Umhang – und setzt dort den AeroMC-Umhang
+ *               des Spielers ein, falls er einen hat. Alles Weitere (Herunterladen,
+ *               Zwischenspeichern, Anzeigen, auch HD) erledigt Minecraft selbst.
+ *   Spieldesign: AeroMC-Ladebildschirm, Fenstertitel und -symbol (siehe Design).
+ *
+ * Argument, Teile durch "|" getrennt:
+ *   <Basisadresse des Umhang-Servers>   (…/wp-json/aeromc/v1)
+ *   capes=0                              Umhänge aus
+ *   design=<Ordner>                      Spieldesign an, Grafiken aus diesem Ordner
+ * Ein Argument nur mit Adresse (ältere Launcher) heißt: nur Umhänge.
+ */
+public final class Agent {
+    /** Unter diesem Schlüssel liegt der Nachschlage-Dienst in den System-Properties. */
+    public static final String SCHLUESSEL = "aeromc.capes.hook";
+
+    private Agent() {}
+
+    public static void premain(String argument, Instrumentation inst) {
+        starte(argument, inst);
+    }
+
+    public static void agentmain(String argument, Instrumentation inst) {
+        starte(argument, inst);
+    }
+
+    private static void starte(String argument, Instrumentation inst) {
+        String basis = Nachschlagen.STANDARD_BASIS;
+        boolean umhaenge = true;
+        String design = null;
+        String mods = null;
+        if (argument != null) {
+            for (String teil : argument.split("\\|")) {
+                if (teil.startsWith("http")) basis = teil;
+                else if (teil.equals("capes=0")) umhaenge = false;
+                else if (teil.startsWith("design=") && teil.length() > 7) design = teil.substring(7);
+                else if (teil.startsWith("mods=") && teil.length() > 5) mods = teil.substring(5);
+            }
+        }
+        if (mods != null) {
+            try {
+                Design.installiereMods(mods, inst);
+            } catch (Throwable t) {
+                System.out.println("[AeroMC] Mod-Schalter konnte nicht starten: " + t);
+            }
+        }
+        if (umhaenge) {
+            try {
+                // Die eingefügten Befehle in authlib holen sich den Dienst von hier – nur
+                // über JDK-Typen, damit es mit jedem Classloader und Modulsystem klappt.
+                System.getProperties().put(SCHLUESSEL, new Nachschlagen(basis));
+                inst.addTransformer(new Umbau());
+                System.out.println("[AeroMC] Umhang-Agent aktiv");
+            } catch (Throwable t) {
+                System.out.println("[AeroMC] Umhang-Agent konnte nicht starten: " + t);
+            }
+        }
+        if (design != null) {
+            try {
+                Design.installiere(design, inst);
+            } catch (Throwable t) {
+                System.out.println("[AeroMC] Spieldesign konnte nicht starten: " + t);
+            }
+        }
+    }
+}

agent/src/de/aeromc/capes/Design.java

@@ -0,0 +1,141 @@
+package de.aeromc.capes;
+
+import java.io.ByteArrayInputStream;
+import java.io.File;
+import java.lang.instrument.Instrumentation;
+import java.lang.reflect.Method;
+import java.nio.ByteBuffer;
+import java.nio.file.Files;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Properties;
+import java.util.function.Function;
+
+/**
+ * AeroMC-Look im Spiel (Minecraft 1.14 … 26.x):
+ *
+ *   – Ladebildschirm: AeroMC-Nachtblau statt Mojang-Rot, hellblauer Balken und
+ *     AeroMC-Logo statt Mojang-Logo. Das Logo lädt Minecraft am Ressourcenpaket
+ *     vorbei direkt aus dem Spiel – deshalb tauscht der Agent den Datenstrom aus.
+ *   – Fenster: Titel "AeroMC - Minecraft …" und AeroMC-Symbol.
+ *
+ * Titel-Logo, Untertitel, Sprüche und Knöpfe kommen über ein Ressourcenpaket,
+ * das der Launcher anlegt (src/spieldesign.js).
+ *
+ * Die umgebauten Stellen im Spiel holen sich ihre Helfer – wie beim Umhang –
+ * über die System-Properties und nur über JDK-Typen (java.util.function.Function),
+ * damit es mit jedem Classloader klappt (Vanilla, Fabric, Forge, NeoForge).
+ */
+final class Design {
+    static final String LOGO = "aeromc.design.logo";
+    static final String LOGO_ALT = "aeromc.design.logoAlt";
+    static final String TITEL = "aeromc.design.titel";
+    static final String ICON = "aeromc.design.icon";
+    static final String MODS = "aeromc.mods";
+
+    /** Hintergrund des Ladebildschirms (wie das AeroMC-Design im Launcher). */
+    static final int HINTERGRUND = 0x0A0E1A;
+    /** Fortschrittsbalken. */
+    static final int BALKEN = 0x4FD2FF;
+    /** Breite des Balkens als Anteil der Bildschirmbreite (das Logo ist jetzt bildschirmbreit). */
+    static final float BALKEN_ANTEIL = 0.56f;
+
+    private static final int[] ICON_GROESSEN = {16, 32, 48, 64, 128, 256};
+    /** Pixelspeicher der Symbole festhalten, bis GLFW sie übernommen hat. */
+    private static final List<ByteBuffer> FESTHALTEN = new ArrayList<>();
+
+    private Design() {}
+
+    static void installiere(String ordner, Instrumentation inst) {
+        File dir = new File(ordner);
+        Properties p = System.getProperties();
+        p.put(LOGO, strom(new File(dir, "ladelogo.png")));
+        p.put(LOGO_ALT, strom(new File(dir, "ladelogo_alt.png")));
+        p.put(TITEL, (Function<Object, Object>) Design::titel);
+        p.put(ICON, (Function<Object, Object>) bilder -> symbol(dir, bilder));
+        inst.addTransformer(new DesignUmbau());
+        System.out.println("[AeroMC] Spieldesign aktiv");
+    }
+
+    /**
+     * Mod-Schalter: Klick auf „Mods verwalten“ im Pausemenü (Adresse aeromc://mods)
+     * meldet sich beim Launcher, der dann das Mod-Fenster über dem Spiel öffnet.
+     * Rückgabe TRUE = erledigt (Minecraft öffnet keinen Link), sonst FALSE.
+     */
+    static void installiereMods(String adresse, Instrumentation inst) {
+        System.getProperties().put(MODS, (Function<Object, Object>) link -> {
+            if (link == null || !link.toString().startsWith("aeromc:")) return Boolean.FALSE;
+            Thread t = new Thread(() -> {
+                try {
+                    java.net.HttpURLConnection c = (java.net.HttpURLConnection) new java.net.URL(adresse).openConnection();
+                    c.setConnectTimeout(2000);
+                    c.setReadTimeout(4000);
+                    c.getResponseCode();
+                    c.disconnect();
+                } catch (Throwable e) {
+                    System.out.println("[AeroMC] Launcher fuer den Mod-Schalter nicht erreichbar: " + e);
+                }
+            }, "AeroMC-Mod-Schalter");
+            t.setDaemon(true);
+            t.start();
+            return Boolean.TRUE;
+        });
+        inst.addTransformer(new ModsUmbau());
+        System.out.println("[AeroMC] Mod-Schalter aktiv");
+    }
+
+    /** Ersetzt den Datenstrom des Mojang-Logos durch das AeroMC-Logo (bei Fehlern bleibt das Original). */
+    private static Function<Object, Object> strom(File datei) {
+        return original -> {
+            try {
+                return new ByteArrayInputStream(Files.readAllBytes(datei.toPath()));
+            } catch (Throwable t) {
+                System.out.println("[AeroMC] Ladelogo nicht lesbar: " + t);
+                return original;
+            }
+        };
+    }
+
+    private static Object titel(Object original) {
+        if (original == null) return null;
+        String s = original.toString();
+        return s.startsWith("AeroMC") ? original : "AeroMC - " + s;
+    }
+
+    /**
+     * Baut aus den mitgelieferten Rohdaten (icon_N.rgba) einen neuen
+     * GLFWImage.Buffer. LWJGL wird über den Classloader des übergebenen Buffers
+     * angesprochen – der Agent selbst kennt LWJGL nicht.
+     */
+    private static Object symbol(File dir, Object original) {
+        if (original == null) return null;
+        try {
+            List<int[]> groessen = new ArrayList<>();
+            List<byte[]> daten = new ArrayList<>();
+            for (int n : ICON_GROESSEN) {
+                File f = new File(dir, "icon_" + n + ".rgba");
+                if (!f.isFile()) continue;
+                byte[] b = Files.readAllBytes(f.toPath());
+                if (b.length != n * n * 4) continue;
+                groessen.add(new int[] {n, n});
+                daten.add(b);
+            }
+            if (daten.isEmpty()) return original;
+            ClassLoader cl = original.getClass().getClassLoader();
+            Class<?> bild = Class.forName("org.lwjgl.glfw.GLFWImage", true, cl);
+            Object puffer = bild.getMethod("malloc", int.class).invoke(null, daten.size());
+            Method hole = puffer.getClass().getMethod("get", int.class);
+            Method setze = bild.getMethod("set", int.class, int.class, ByteBuffer.class);
+            for (int i = 0; i < daten.size(); i++) {
+                ByteBuffer px = ByteBuffer.allocateDirect(daten.get(i).length);
+                px.put(daten.get(i)).flip();
+                synchronized (FESTHALTEN) { FESTHALTEN.add(px); }
+                setze.invoke(hole.invoke(puffer, i), groessen.get(i)[0], groessen.get(i)[1], px);
+            }
+            return puffer;
+        } catch (Throwable t) {
+            System.out.println("[AeroMC] Fenstersymbol nicht gesetzt: " + t);
+            return original;
+        }
+    }
+}

agent/src/de/aeromc/capes/DesignUmbau.java

@@ -0,0 +1,352 @@
+package de.aeromc.capes;
+
+import java.lang.instrument.ClassFileTransformer;
+import java.nio.charset.StandardCharsets;
+import java.security.ProtectionDomain;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.objectweb.asm.ClassReader;
+import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.tree.AbstractInsnNode;
+import org.objectweb.asm.tree.ClassNode;
+import org.objectweb.asm.tree.InsnList;
+import org.objectweb.asm.tree.InsnNode;
+import org.objectweb.asm.tree.IntInsnNode;
+import org.objectweb.asm.tree.LdcInsnNode;
+import org.objectweb.asm.tree.MethodInsnNode;
+import org.objectweb.asm.tree.MethodNode;
+import org.objectweb.asm.tree.TypeInsnNode;
+import org.objectweb.asm.tree.VarInsnNode;
+
+/**
+ * Baut beim Laden um (siehe Design):
+ *
+ *  1. Ladebildschirm – erkannt am Text "textures/gui/title/mojangstudios.png"
+ *     (ab 1.16) bzw. "…/mojang.png" (1.14/1.15), denn die Klassennamen sind je
+ *     Version und Loader anders (verschleiert, Intermediary, SRG, Mojang-Namen):
+ *       ab 1.16:   color(255, 239, 50, 61)      -> AeroMC-Nachtblau
+ *                  color(alpha, 255, 255, 255)  -> Balkenfarbe
+ *       1.14/1.15: weiße Füllung (0xFFFFFF / -1) -> Nachtblau,
+ *                  Balken-Rot (226, 40, 55)     -> Balkenfarbe
+ *  2. Logo-Textur – die innere Klasse des Ladebildschirms ("…$…") liest das
+ *     Logo mit NativeImage.read(InputStream); davor wird der Strom getauscht.
+ *  3. LWJGL-GLFW – Fenstertitel (glfwCreateWindow/glfwSetWindowTitle) und
+ *     Fenstersymbol (glfwSetWindowIcon).
+ *
+ * Eingefügt bzw. ersetzt wird nur geradliniger Code ohne Sprünge mit gleicher
+ * Stapelwirkung – die vorhandenen Stack-Map-Frames bleiben gültig.
+ */
+final class DesignUmbau implements ClassFileTransformer {
+    private static final byte[] MERKMAL = "textures/gui/title/mojang".getBytes(StandardCharsets.UTF_8);
+    private static final String LOGO_NEU = "textures/gui/title/mojangstudios.png";
+    private static final String LOGO_ALT = "textures/gui/title/mojang.png";
+    private static final byte[] TITEL_MERKMAL = "textures/gui/title/minecraft.png".getBytes(StandardCharsets.UTF_8);
+    private static final int KEIN_WERT = Integer.MIN_VALUE;
+
+    /** Name der Ladebildschirm-Klasse, sobald sie gesehen wurde. */
+    private volatile String ladeKlasse;
+    private volatile boolean ladeAlt;
+
+    @Override
+    public byte[] transform(ClassLoader loader, String name, Class<?> umdefiniert, ProtectionDomain pd, byte[] klasse) {
+        if (name == null || umdefiniert != null) return null;
+        try {
+            if ("org/lwjgl/glfw/GLFW".equals(name)) return glfw(klasse);
+            if (name.startsWith("java/") || name.startsWith("jdk/") || name.startsWith("sun/")
+                || name.startsWith("de/aeromc/") || name.startsWith("org/lwjgl/")) return null;
+            String lk = ladeKlasse;
+            if (lk != null && name.startsWith(lk + "$")) return logoStrom(klasse, ladeAlt);
+            if (enthaelt(klasse, MERKMAL)) return ladeBildschirm(name, klasse);
+            if (enthaelt(klasse, TITEL_MERKMAL)) return titelLogo(name, klasse);
+        } catch (Throwable t) {
+            System.out.println("[AeroMC] Spieldesign: " + name + " nicht angepasst: " + t);
+        }
+        return null;
+    }
+
+    // ---------- 1. Ladebildschirm ----------
+
+    private byte[] ladeBildschirm(String name, byte[] klasse) {
+        ClassNode cn = lies(klasse);
+        boolean neu = hatText(cn, LOGO_NEU), alt = hatText(cn, LOGO_ALT);
+        if (!neu && !alt) return null;
+        ladeKlasse = name;
+        ladeAlt = alt && !neu;
+        int r = Design.HINTERGRUND >> 16 & 255, g = Design.HINTERGRUND >> 8 & 255, b = Design.HINTERGRUND & 255;
+        int br = Design.BALKEN >> 16 & 255, bg = Design.BALKEN >> 8 & 255, bb = Design.BALKEN & 255;
+        int hintergrund = 0, balken = 0, vollbild = 0, balkenBreite = 0;
+        for (MethodNode m : cn.methods) {
+            List<AbstractInsnNode> a = befehle(m);
+            for (int i = 0; i < a.size(); i++) {
+                if (!ladeAlt) {
+                    // color(255, 239, 50, 61) – Mojang-Rot
+                    if (i + 4 < a.size() && wert(a.get(i)) == 255 && wert(a.get(i + 1)) == 239
+                        && wert(a.get(i + 2)) == 50 && wert(a.get(i + 3)) == 61 && aufruf(a.get(i + 4), "(IIII)I")) {
+                        setze(m, a, i + 1, r); setze(m, a, i + 2, g); setze(m, a, i + 3, b);
+                        hintergrund++;
+                    }
+                    // color(alpha, 255, 255, 255) – weißer Balken
+                    if (i + 4 < a.size() && a.get(i).getOpcode() == Opcodes.ILOAD && wert(a.get(i + 1)) == 255
+                        && wert(a.get(i + 2)) == 255 && wert(a.get(i + 3)) == 255 && aufruf(a.get(i + 4), "(IIII)I")) {
+                        setze(m, a, i + 1, br); setze(m, a, i + 2, bg); setze(m, a, i + 3, bb);
+                        balken++;
+                    }
+                    // Logo-Fläche auf Vollbild: Höhe = min(Breite·0,75; Höhe)·0,25 und Breite = 4·Höhe
+                    // wird zu Höhe = min(Breite·9/16; Höhe) und Breite = 16/9·Höhe (Bild im 16:9-Format)
+                    AbstractInsnNode n = a.get(i);
+                    if (n instanceof LdcInsnNode && ((LdcInsnNode) n).cst instanceof Double) {
+                        double d = (Double) ((LdcInsnNode) n).cst;
+                        double ersatzWert = d == 0.75 ? 9.0 / 16.0 : d == 0.25 ? 1.0 : d == 4.0 ? 16.0 / 9.0 : -1;
+                        if (ersatzWert > 0) {
+                            LdcInsnNode e = new LdcInsnNode(ersatzWert);
+                            m.instructions.set(n, e);
+                            a.set(i, e);
+                            vollbild++;
+                        }
+                    }
+                    // Fortschrittsbalken: Minecraft macht ihn so breit wie das Logo – jetzt also
+                    // bildschirmbreit; beim Aufruf auf einen Teil der Breite in der Mitte kürzen
+                    if (n instanceof MethodInsnNode && ((MethodInsnNode) n).owner.equals(name)
+                        && ((MethodInsnNode) n).desc.endsWith("IIIIF)V")) {
+                        m.instructions.insertBefore(n, balkenKuerzen(m));
+                        balkenBreite++;
+                    }
+                } else {
+                    AbstractInsnNode n = a.get(i);
+                    // weiße Füllung beim Ein-/Ausblenden: 0xFFFFFF | alpha << 24
+                    if (n instanceof LdcInsnNode && Integer.valueOf(0xFFFFFF).equals(((LdcInsnNode) n).cst)) {
+                        m.instructions.set(n, ersatz(Design.HINTERGRUND, a, i));
+                        hintergrund++;
+                    }
+                    // fill(0, 0, breite, hoehe, -1) – weißer Hintergrund
+                    if (i + 5 < a.size() && n.getOpcode() == Opcodes.ICONST_0 && a.get(i + 1).getOpcode() == Opcodes.ICONST_0
+                        && a.get(i + 2).getOpcode() == Opcodes.ILOAD && a.get(i + 3).getOpcode() == Opcodes.ILOAD
+                        && a.get(i + 4).getOpcode() == Opcodes.ICONST_M1 && aufruf(a.get(i + 5), "(IIIII)V")) {
+                        m.instructions.set(a.get(i + 4), ersatz(0xFF000000 | Design.HINTERGRUND, a, i + 4));
+                        hintergrund++;
+                    }
+                    // Balken-Rot (226, 40, 55) als Gleitkommazahlen
+                    if (n instanceof LdcInsnNode && ((LdcInsnNode) n).cst instanceof Float) {
+                        float f = (Float) ((LdcInsnNode) n).cst;
+                        float neuWert = f == 226f ? br : f == 40f ? bg : f == 55f ? bb : -1f;
+                        if (neuWert >= 0) {
+                            LdcInsnNode e = new LdcInsnNode(neuWert);
+                            m.instructions.set(n, e);
+                            a.set(i, e);
+                            balken++;
+                        }
+                    }
+                }
+            }
+        }
+        System.out.println("[AeroMC] Ladebildschirm angepasst (" + (ladeAlt ? "1.14/1.15" : "ab 1.16")
+            + ", Hintergrund " + hintergrund + ", Balken " + balken + ", Vollbild " + vollbild + ", Balkenbreite " + balkenBreite + ")");
+        return schreibe(cn);
+    }
+
+    /**
+     * Vor dem Aufruf drawProgressBar(…, x1, y1, x2, y2, f): die vier Zahlen und f in
+     * neue lokale Variablen legen, x1/x2 um die Mitte auf BALKEN_ANTEIL der Breite
+     * zusammenziehen und alles wieder auf den Stapel legen.
+     */
+    private static InsnList balkenKuerzen(MethodNode m) {
+        int b = m.maxLocals;
+        m.maxLocals += 7;
+        int x1 = b, y1 = b + 1, x2 = b + 2, y2 = b + 3, f = b + 4, mitte = b + 5, halb = b + 6;
+        InsnList l = new InsnList();
+        l.add(new VarInsnNode(Opcodes.FSTORE, f));
+        l.add(new VarInsnNode(Opcodes.ISTORE, y2));
+        l.add(new VarInsnNode(Opcodes.ISTORE, x2));
+        l.add(new VarInsnNode(Opcodes.ISTORE, y1));
+        l.add(new VarInsnNode(Opcodes.ISTORE, x1));
+        // mitte = (x1 + x2) / 2
+        l.add(new VarInsnNode(Opcodes.ILOAD, x1));
+        l.add(new VarInsnNode(Opcodes.ILOAD, x2));
+        l.add(new InsnNode(Opcodes.IADD));
+        l.add(new InsnNode(Opcodes.ICONST_2));
+        l.add(new InsnNode(Opcodes.IDIV));
+        l.add(new VarInsnNode(Opcodes.ISTORE, mitte));
+        // halb = (int) ((x2 - x1) * anteil / 2)
+        l.add(new VarInsnNode(Opcodes.ILOAD, x2));
+        l.add(new VarInsnNode(Opcodes.ILOAD, x1));
+        l.add(new InsnNode(Opcodes.ISUB));
+        l.add(new InsnNode(Opcodes.I2F));
+        l.add(new LdcInsnNode(Design.BALKEN_ANTEIL / 2f));
+        l.add(new InsnNode(Opcodes.FMUL));
+        l.add(new InsnNode(Opcodes.F2I));
+        l.add(new VarInsnNode(Opcodes.ISTORE, halb));
+        // (mitte - halb, y1, mitte + halb, y2, f)
+        l.add(new VarInsnNode(Opcodes.ILOAD, mitte));
+        l.add(new VarInsnNode(Opcodes.ILOAD, halb));
+        l.add(new InsnNode(Opcodes.ISUB));
+        l.add(new VarInsnNode(Opcodes.ILOAD, y1));
+        l.add(new VarInsnNode(Opcodes.ILOAD, mitte));
+        l.add(new VarInsnNode(Opcodes.ILOAD, halb));
+        l.add(new InsnNode(Opcodes.IADD));
+        l.add(new VarInsnNode(Opcodes.ILOAD, y2));
+        l.add(new VarInsnNode(Opcodes.FLOAD, f));
+        return l;
+    }
+
+    // ---------- 1b. Titel-Logo im Hauptmenü ----------
+    // Minecraft zeichnet vom Logo nur einen 44 Punkte hohen Streifen – zu knapp für
+    // Pyramide, großen Schriftzug und Untertitel. Hier wird er auf 64 Punkte erweitert:
+    //   bis 1.19.4: blit(u 0, v 0, 155, 44) + blit(u 0, v 45, 155, 44)  ->  Höhe 64, zweites Stück ab v 65
+    //   ab 1.20:    blit(…, 256, 44, Textur 256, 64)                     ->  Höhe 64
+    private byte[] titelLogo(String name, byte[] klasse) {
+        ClassNode cn = lies(klasse);
+        int n = 0;
+        for (MethodNode m : cn.methods) {
+            List<AbstractInsnNode> a = befehle(m);
+            for (int i = 0; i + 4 < a.size(); i++) {
+                int w0 = wert(a.get(i)), w1 = wert(a.get(i + 1)), w2 = wert(a.get(i + 2)), w3 = wert(a.get(i + 3));
+                boolean aufrufDanach = a.get(i + 4) instanceof MethodInsnNode;
+                if (w0 == 0 && w1 == 0 && w2 == 155 && w3 == 44 && aufrufDanach) {
+                    setze(m, a, i + 3, 64); n++;
+                } else if (w0 == 0 && w1 == 45 && w2 == 155 && w3 == 44 && aufrufDanach) {
+                    setze(m, a, i + 1, 65); setze(m, a, i + 3, 64); n++;
+                } else if (w0 == 256 && w1 == 44 && w2 == 256 && w3 == 64) {
+                    setze(m, a, i + 1, 64); n++;
+                }
+            }
+        }
+        if (n == 0) return null;
+        System.out.println("[AeroMC] Titel-Logo vergroessert (" + n + ")");
+        return schreibe(cn);
+    }
+
+    // ---------- 2. Logo-Textur ----------
+
+    private byte[] logoStrom(byte[] klasse, boolean alt) {
+        ClassNode cn = lies(klasse);
+        int n = 0;
+        for (MethodNode m : cn.methods) {
+            for (AbstractInsnNode i : befehle(m)) {
+                if (i.getOpcode() != Opcodes.INVOKESTATIC) continue;
+                MethodInsnNode mi = (MethodInsnNode) i;
+                if (!mi.desc.startsWith("(Ljava/io/InputStream;)L") || mi.owner.startsWith("java/")) continue;
+                // Stapel: [strom] -> [strom, helfer] -> [helfer, strom] -> apply -> [neuer strom]
+                InsnList neu = new InsnList();
+                helfer(neu, alt ? Design.LOGO_ALT : Design.LOGO);
+                neu.add(new InsnNode(Opcodes.SWAP));
+                neu.add(new MethodInsnNode(Opcodes.INVOKEINTERFACE, "java/util/function/Function", "apply",
+                    "(Ljava/lang/Object;)Ljava/lang/Object;", true));
+                neu.add(new TypeInsnNode(Opcodes.CHECKCAST, "java/io/InputStream"));
+                m.instructions.insertBefore(i, neu);
+                n++;
+            }
+        }
+        if (n == 0) return null;
+        System.out.println("[AeroMC] Ladelogo ersetzt");
+        return schreibe(cn);
+    }
+
+    // ---------- 3. Fenstertitel und -symbol ----------
+
+    private byte[] glfw(byte[] klasse) {
+        ClassNode cn = lies(klasse);
+        int n = 0;
+        for (MethodNode m : cn.methods) {
+            String schluessel = null, typ = null;
+            if ("glfwCreateWindow".equals(m.name) && "(IILjava/lang/CharSequence;JJ)J".equals(m.desc)) {
+                schluessel = Design.TITEL; typ = "java/lang/CharSequence";
+            } else if ("glfwSetWindowTitle".equals(m.name) && "(JLjava/lang/CharSequence;)V".equals(m.desc)) {
+                schluessel = Design.TITEL; typ = "java/lang/CharSequence";
+            } else if ("glfwSetWindowIcon".equals(m.name) && "(JLorg/lwjgl/glfw/GLFWImage$Buffer;)V".equals(m.desc)) {
+                schluessel = Design.ICON; typ = "org/lwjgl/glfw/GLFWImage$Buffer";
+            }
+            if (schluessel == null) continue;
+            // am Anfang: argument = helfer.apply(argument)  (Argument liegt in beiden Fällen in Slot 2)
+            InsnList neu = new InsnList();
+            helfer(neu, schluessel);
+            neu.add(new VarInsnNode(Opcodes.ALOAD, 2));
+            neu.add(new MethodInsnNode(Opcodes.INVOKEINTERFACE, "java/util/function/Function", "apply",
+                "(Ljava/lang/Object;)Ljava/lang/Object;", true));
+            neu.add(new TypeInsnNode(Opcodes.CHECKCAST, typ));
+            neu.add(new VarInsnNode(Opcodes.ASTORE, 2));
+            m.instructions.insert(neu);
+            n++;
+        }
+        if (n == 0) return null;
+        System.out.println("[AeroMC] Fenstertitel und -symbol vorbereitet (" + n + ")");
+        return schreibe(cn);
+    }
+
+    // ---------- Hilfen ----------
+
+    /** legt (Function) System.getProperties().get(schluessel) auf den Stapel */
+    private static void helfer(InsnList l, String schluessel) {
+        l.add(new MethodInsnNode(Opcodes.INVOKESTATIC, "java/lang/System", "getProperties", "()Ljava/util/Properties;", false));
+        l.add(new LdcInsnNode(schluessel));
+        l.add(new MethodInsnNode(Opcodes.INVOKEVIRTUAL, "java/util/Properties", "get", "(Ljava/lang/Object;)Ljava/lang/Object;", false));
+        l.add(new TypeInsnNode(Opcodes.CHECKCAST, "java/util/function/Function"));
+    }
+
+    private static ClassNode lies(byte[] klasse) {
+        ClassNode cn = new ClassNode();
+        new ClassReader(klasse).accept(cn, 0);
+        return cn;
+    }
+
+    private static byte[] schreibe(ClassNode cn) {
+        ClassWriter w = new ClassWriter(ClassWriter.COMPUTE_MAXS);
+        cn.accept(w);
+        return w.toByteArray();
+    }
+
+    /** echte Befehle eines Methodenrumpfs (ohne Labels, Zeilennummern, Frames) */
+    private static List<AbstractInsnNode> befehle(MethodNode m) {
+        List<AbstractInsnNode> l = new ArrayList<>();
+        for (AbstractInsnNode i = m.instructions.getFirst(); i != null; i = i.getNext()) {
+            if (i.getOpcode() >= 0) l.add(i);
+        }
+        return l;
+    }
+
+    private static boolean hatText(ClassNode cn, String text) {
+        for (MethodNode m : cn.methods) {
+            for (AbstractInsnNode i : befehle(m)) {
+                if (i instanceof LdcInsnNode && text.equals(((LdcInsnNode) i).cst)) return true;
+            }
+        }
+        return false;
+    }
+
+    /** Zahlenwert eines Konstanten-Befehls, sonst KEIN_WERT */
+    private static int wert(AbstractInsnNode i) {
+        int op = i.getOpcode();
+        if (op >= Opcodes.ICONST_M1 && op <= Opcodes.ICONST_5) return op - Opcodes.ICONST_0;
+        if (op == Opcodes.BIPUSH || op == Opcodes.SIPUSH) return ((IntInsnNode) i).operand;
+        if (i instanceof LdcInsnNode && ((LdcInsnNode) i).cst instanceof Integer) return (Integer) ((LdcInsnNode) i).cst;
+        return KEIN_WERT;
+    }
+
+    private static boolean aufruf(AbstractInsnNode i, String desc) {
+        return (i.getOpcode() == Opcodes.INVOKESTATIC || i.getOpcode() == Opcodes.INVOKEVIRTUAL)
+            && desc.equals(((MethodInsnNode) i).desc);
+    }
+
+    private static void setze(MethodNode m, List<AbstractInsnNode> a, int index, int v) {
+        m.instructions.set(a.get(index), ersatz(v, a, index));
+    }
+
+    /** neuer Konstanten-Befehl; ersetzt auch den Eintrag in der Befehlsliste */
+    private static AbstractInsnNode ersatz(int v, List<AbstractInsnNode> a, int index) {
+        AbstractInsnNode n = v >= -32768 && v <= 32767 ? new IntInsnNode(Opcodes.SIPUSH, v) : new LdcInsnNode(v);
+        a.set(index, n);
+        return n;
+    }
+
+    private static boolean enthaelt(byte[] daten, byte[] muster) {
+        outer:
+        for (int i = 0, ende = daten.length - muster.length; i <= ende; i++) {
+            for (int k = 0; k < muster.length; k++) {
+                if (daten[i + k] != muster[k]) continue outer;
+            }
+            return true;
+        }
+        return false;
+    }
+}

agent/src/de/aeromc/capes/ModsUmbau.java

@@ -0,0 +1,138 @@
+package de.aeromc.capes;
+
+import java.lang.instrument.ClassFileTransformer;
+import java.nio.charset.StandardCharsets;
+import java.security.ProtectionDomain;
+
+import org.objectweb.asm.ClassReader;
+import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.Type;
+import org.objectweb.asm.tree.AbstractInsnNode;
+import org.objectweb.asm.tree.ClassNode;
+import org.objectweb.asm.tree.FieldInsnNode;
+import org.objectweb.asm.tree.FrameNode;
+import org.objectweb.asm.tree.InsnList;
+import org.objectweb.asm.tree.InsnNode;
+import org.objectweb.asm.tree.JumpInsnNode;
+import org.objectweb.asm.tree.LabelNode;
+import org.objectweb.asm.tree.LdcInsnNode;
+import org.objectweb.asm.tree.MethodInsnNode;
+import org.objectweb.asm.tree.MethodNode;
+import org.objectweb.asm.tree.TypeInsnNode;
+import org.objectweb.asm.tree.VarInsnNode;
+
+/**
+ * Mod-Schalter im Pausemenü (Minecraft 1.14 … 26.x, jeder Loader):
+ * Der Knopf „Feedback geben“ wird zum Knopf „Mods verwalten“.
+ *
+ *  1. Seine Adresse (aka.ms/javafeedback bzw. snapshotfeedback) wird zu
+ *     "aeromc://mods" – je nach Version steht sie im Pausemenü selbst
+ *     (bis 1.20) oder in CommonLinks (ab 1.21).
+ *  2. Die Lambdas, über die Minecraft einen Link öffnet (im Pausemenü bzw. in
+ *     ConfirmLinkScreen), fragen vorher den Helfer: Ist es "aeromc://mods",
+ *     öffnet der Launcher das Mod-Fenster und Minecraft zeigt keine Rückfrage.
+ *     Alle anderen Links laufen unverändert weiter.
+ *
+ * Beschriftung bzw. Symbol des Knopfs kommen aus dem Ressourcenpaket.
+ */
+final class ModsUmbau implements ClassFileTransformer {
+    static final String ZIEL = "aeromc://mods";
+    private static final String[] ADRESSEN = {"https://aka.ms/javafeedback?ref=game", "https://aka.ms/snapshotfeedback?ref=game"};
+    private static final byte[] MERKMAL_FEEDBACK = "aka.ms/".getBytes(StandardCharsets.UTF_8);
+    private static final byte[] MERKMAL_LINK = "chat.link.confirm".getBytes(StandardCharsets.UTF_8);
+
+    @Override
+    public byte[] transform(ClassLoader loader, String name, Class<?> umdefiniert, ProtectionDomain pd, byte[] klasse) {
+        if (name == null || umdefiniert != null || name.startsWith("java/") || name.startsWith("jdk/")
+            || name.startsWith("sun/") || name.startsWith("de/aeromc/") || name.startsWith("org/lwjgl/")) return null;
+        try {
+            boolean feedback = enthaelt(klasse, MERKMAL_FEEDBACK);
+            boolean link = enthaelt(klasse, MERKMAL_LINK);
+            if (!feedback && !link) return null;
+            ClassNode cn = new ClassNode();
+            new ClassReader(klasse).accept(cn, 0);
+            int adressen = 0, waechter = 0;
+            for (MethodNode m : cn.methods) {
+                for (AbstractInsnNode i = m.instructions.getFirst(); i != null; i = i.getNext()) {
+                    if (i instanceof LdcInsnNode && istFeedbackAdresse(((LdcInsnNode) i).cst)) {
+                        ((LdcInsnNode) i).cst = ZIEL;
+                        adressen++;
+                    }
+                }
+            }
+            if (adressen == 0 && !link) return null;
+            for (MethodNode m : cn.methods) {
+                if ((m.access & Opcodes.ACC_SYNTHETIC) == 0 || Type.getReturnType(m.desc) != Type.VOID_TYPE) continue;
+                int slot = adressParameter(m);
+                boolean konstante = slot < 0 && enthaeltZiel(m);
+                if (slot < 0 && !konstante) continue;
+                if (frameAmAnfang(m)) continue;    // nicht sicher erweiterbar
+                InsnList w = new InsnList();
+                w.add(new MethodInsnNode(Opcodes.INVOKESTATIC, "java/lang/System", "getProperties", "()Ljava/util/Properties;", false));
+                w.add(new LdcInsnNode(Design.MODS));
+                w.add(new MethodInsnNode(Opcodes.INVOKEVIRTUAL, "java/util/Properties", "get", "(Ljava/lang/Object;)Ljava/lang/Object;", false));
+                w.add(new TypeInsnNode(Opcodes.CHECKCAST, "java/util/function/Function"));
+                if (slot >= 0) w.add(new VarInsnNode(Opcodes.ALOAD, slot)); else w.add(new LdcInsnNode(ZIEL));
+                w.add(new MethodInsnNode(Opcodes.INVOKEINTERFACE, "java/util/function/Function", "apply", "(Ljava/lang/Object;)Ljava/lang/Object;", true));
+                w.add(new FieldInsnNode(Opcodes.GETSTATIC, "java/lang/Boolean", "TRUE", "Ljava/lang/Boolean;"));
+                LabelNode weiter = new LabelNode();
+                w.add(new JumpInsnNode(Opcodes.IF_ACMPNE, weiter));
+                w.add(new InsnNode(Opcodes.RETURN));
+                w.add(weiter);
+                w.add(new FrameNode(Opcodes.F_SAME, 0, null, 0, null));
+                m.instructions.insert(w);
+                waechter++;
+            }
+            if (adressen == 0 && waechter == 0) return null;
+            System.out.println("[AeroMC] Mod-Schalter vorbereitet (Adressen " + adressen + ", Links " + waechter + ")");
+            ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS);
+            cn.accept(cw);
+            return cw.toByteArray();
+        } catch (Throwable t) {
+            System.out.println("[AeroMC] Mod-Schalter: " + name + " nicht angepasst: " + t);
+            return null;
+        }
+    }
+
+    private static boolean istFeedbackAdresse(Object cst) {
+        for (String a : ADRESSEN) if (a.equals(cst)) return true;
+        return false;
+    }
+
+    /** Slot des ersten Parameters vom Typ String oder URI, sonst -1 */
+    private static int adressParameter(MethodNode m) {
+        int slot = (m.access & Opcodes.ACC_STATIC) != 0 ? 0 : 1;
+        for (Type t : Type.getArgumentTypes(m.desc)) {
+            String d = t.getDescriptor();
+            if ("Ljava/lang/String;".equals(d) || "Ljava/net/URI;".equals(d)) return slot;
+            slot += t.getSize();
+        }
+        return -1;
+    }
+
+    private static boolean enthaeltZiel(MethodNode m) {
+        for (AbstractInsnNode i = m.instructions.getFirst(); i != null; i = i.getNext()) {
+            if (i instanceof LdcInsnNode && ZIEL.equals(((LdcInsnNode) i).cst)) return true;
+        }
+        return false;
+    }
+
+    /** steht vor dem ersten echten Befehl schon ein Frame (Sprungziel am Anfang)? */
+    private static boolean frameAmAnfang(MethodNode m) {
+        for (AbstractInsnNode i = m.instructions.getFirst(); i != null; i = i.getNext()) {
+            if (i instanceof FrameNode) return true;
+            if (i.getOpcode() >= 0) return false;
+        }
+        return false;
+    }
+
+    private static boolean enthaelt(byte[] daten, byte[] muster) {
+        outer:
+        for (int i = 0, ende = daten.length - muster.length; i <= ende; i++) {
+            for (int k = 0; k < muster.length; k++) if (daten[i + k] != muster[k]) continue outer;
+            return true;
+        }
+        return false;
+    }
+}

agent/src/de/aeromc/capes/Nachschlagen.java

@@ -0,0 +1,183 @@
+package de.aeromc.capes;
+
+import java.io.ByteArrayOutputStream;
+import java.io.InputStream;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.net.HttpURLConnection;
+import java.net.URL;
+import java.nio.charset.StandardCharsets;
+import java.util.Base64;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.BiFunction;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * Wird aus authlib heraus mit (ergebnis, argument) aufgerufen und gibt das
+ * Ergebnis zurück – mit eingesetztem AeroMC-Umhang, falls der Spieler einen hat.
+ * Arbeitet nur über Reflexion, damit es zu jeder authlib-Fassung passt, und
+ * fängt jeden Fehler ab: im schlimmsten Fall bleibt alles wie ohne Agent.
+ */
+public final class Nachschlagen implements BiFunction<Object, Object, Object> {
+    public static final String STANDARD_BASIS = "https://viper-network.de/wp-json/aeromc/v1";
+    private static final long GEFUNDEN_MS = 5 * 60 * 1000L;
+    private static final long KEINER_MS = 2 * 60 * 1000L;
+    private static final Pattern URL_MUSTER = Pattern.compile("\"url\"\\s*:\\s*\"((?:[^\"\\\\]|\\\\.)*)\"");
+    private static final Pattern ID_MUSTER = Pattern.compile("\"profileId\"\\s*:\\s*\"([0-9a-fA-F-]{32,36})\"");
+
+    private static final class Eintrag {
+        final String url; // null = kein Umhang
+        final long zeit;
+        Eintrag(String url) { this.url = url; this.zeit = System.currentTimeMillis(); }
+        boolean frisch() { return System.currentTimeMillis() - zeit < (url != null ? GEFUNDEN_MS : KEINER_MS); }
+    }
+
+    private final String basis;
+    private final Map<String, Eintrag> speicher = new ConcurrentHashMap<>();
+    private final Map<String, Boolean> unterwegs = new ConcurrentHashMap<>();
+    private final Map<String, Boolean> gemeldet = new ConcurrentHashMap<>();
+
+    public Nachschlagen(String basis) {
+        this.basis = basis.endsWith("/") ? basis.substring(0, basis.length() - 1) : basis;
+    }
+
+    @Override
+    public Object apply(Object ergebnis, Object argument) {
+        try {
+            String id = spielerId(argument);
+            if (id == null) return ergebnis;
+            String url = umhangUrl(id);
+            if (url == null) return ergebnis;
+            Object neu = mitUmhang(ergebnis, url, argument);
+            if (neu != ergebnis && gemeldet.putIfAbsent(id, Boolean.TRUE) == null) {
+                System.out.println("[AeroMC] Umhang fuer " + id + " eingesetzt");
+            }
+            return neu;
+        } catch (Throwable t) {
+            return ergebnis;
+        }
+    }
+
+    // ---------- Spieler erkennen ----------
+    private static String spielerId(Object argument) throws Exception {
+        if (argument == null) return null;
+        String klasse = argument.getClass().getName();
+        if (klasse.endsWith("GameProfile")) {
+            Object id = rufe(argument, "getId", "id");
+            return id instanceof UUID ? hex((UUID) id) : null;
+        }
+        if (klasse.endsWith("Property")) {
+            Object wert = rufe(argument, "getValue", "value");
+            if (!(wert instanceof String)) return null;
+            String json = new String(Base64.getDecoder().decode(((String) wert).trim()), StandardCharsets.UTF_8);
+            Matcher m = ID_MUSTER.matcher(json);
+            return m.find() ? m.group(1).replace("-", "").toLowerCase() : null;
+        }
+        return null;
+    }
+
+    private static String hex(UUID u) {
+        return u.toString().replace("-", "").toLowerCase();
+    }
+
+    private static Object rufe(Object ziel, String... namen) throws Exception {
+        for (String n : namen) {
+            try {
+                Method m = ziel.getClass().getMethod(n);
+                return m.invoke(ziel);
+            } catch (NoSuchMethodException ignoriert) {
+                // nächster Name
+            }
+        }
+        return null;
+    }
+
+    // ---------- Umhang-Server ----------
+    private String umhangUrl(String id) {
+        Eintrag e = speicher.get(id);
+        if (e != null && e.frisch()) return e.url;
+        // Auf dem Haupt-/Render-Thread nie warten: dort nur im Hintergrund holen;
+        // Minecraft fragt beim nächsten Laden des Spielers erneut
+        String thread = Thread.currentThread().getName();
+        boolean hauptThread = thread.equals("Render thread") || thread.equals("Client thread") || thread.equals("main");
+        if (hauptThread) {
+            if (unterwegs.putIfAbsent(id, Boolean.TRUE) == null) {
+                Thread t = new Thread(() -> { try { hole(id); } finally { unterwegs.remove(id); } }, "AeroMC-Umhang");
+                t.setDaemon(true);
+                t.start();
+            }
+            return e != null ? e.url : null;
+        }
+        return hole(id);
+    }
+
+    private String hole(String id) {
+        try {
+            HttpURLConnection c = (HttpURLConnection) new URL(basis + "/capes?uuids=" + id).openConnection();
+            c.setConnectTimeout(2000);
+            c.setReadTimeout(3000);
+            c.setRequestProperty("User-Agent", "AeroMC-Umhang/1.0");
+            c.setRequestProperty("Accept", "application/json");
+            if (c.getResponseCode() != 200) {
+                speicher.put(id, new Eintrag(null));
+                return null;
+            }
+            String json;
+            try (InputStream in = c.getInputStream()) {
+                ByteArrayOutputStream puffer = new ByteArrayOutputStream();
+                byte[] b = new byte[4096];
+                int n;
+                while ((n = in.read(b)) > 0 && puffer.size() < 65536) puffer.write(b, 0, n);
+                json = new String(puffer.toByteArray(), StandardCharsets.UTF_8);
+            }
+            String url = null;
+            Matcher m = URL_MUSTER.matcher(json);
+            if (json.contains("\"" + id + "\"") && m.find()) {
+                url = m.group(1).replace("\\/", "/");
+                if (!url.startsWith("https://")) url = null;
+            }
+            speicher.put(id, new Eintrag(url));
+            return url;
+        } catch (Throwable t) {
+            // Server nicht erreichbar: kurz merken, damit nicht jeder Spieler hängt
+            speicher.put(id, new Eintrag(null));
+            return null;
+        }
+    }
+
+    // ---------- Umhang einsetzen ----------
+    private static Object textur(ClassLoader cl, String url) throws Exception {
+        Class<?> k = Class.forName("com.mojang.authlib.minecraft.MinecraftProfileTexture", false, cl);
+        Constructor<?> ctor = k.getConstructor(String.class, Map.class);
+        return ctor.newInstance(url, null);
+    }
+
+    @SuppressWarnings({"unchecked", "rawtypes"})
+    private static Object mitUmhang(Object ergebnis, String url, Object argument) throws Exception {
+        ClassLoader cl = argument.getClass().getClassLoader();
+        if (ergebnis instanceof Map) {
+            // authlib 1–4: Map<MinecraftProfileTexture.Type, MinecraftProfileTexture>
+            Class<?> typ = Class.forName("com.mojang.authlib.minecraft.MinecraftProfileTexture$Type", false, cl);
+            Object cape = Enum.valueOf((Class<Enum>) typ, "CAPE");
+            Map neu = new HashMap((Map) ergebnis);
+            neu.put(cape, textur(cl, url));
+            return neu;
+        }
+        if (ergebnis == null) return null;
+        // authlib 5+: record MinecraftProfileTextures(skin, cape, elytra, signatureState)
+        Class<?> k = ergebnis.getClass();
+        Object skin = k.getMethod("skin").invoke(ergebnis);
+        Object elytra = k.getMethod("elytra").invoke(ergebnis);
+        Object signatur = k.getMethod("signatureState").invoke(ergebnis);
+        for (Constructor<?> ctor : k.getConstructors()) {
+            if (ctor.getParameterCount() == 4) {
+                return ctor.newInstance(skin, textur(cl, url), elytra, signatur);
+            }
+        }
+        return ergebnis;
+    }
+}

agent/src/de/aeromc/capes/Umbau.java

@@ -0,0 +1,78 @@
+package de.aeromc.capes;
+
+import java.lang.instrument.ClassFileTransformer;
+import java.security.ProtectionDomain;
+
+import org.objectweb.asm.ClassReader;
+import org.objectweb.asm.ClassVisitor;
+import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+
+/**
+ * Baut YggdrasilMinecraftSessionService beim Laden um: vor jedem "return" der
+ * Textur-Methode wird das Ergebnis an den Nachschlage-Dienst gereicht, der den
+ * AeroMC-Umhang einsetzt.
+ *
+ *   authlib 5+ (Minecraft 1.20.2 … 26.x):
+ *     MinecraftProfileTextures unpackTextures(Property)
+ *   authlib 1–4 (Minecraft 1.8 … 1.20.1):
+ *     Map<Type, MinecraftProfileTexture> getTextures(GameProfile, boolean)
+ *
+ * Eingefügt wird nur geradliniger Code ohne Sprünge – die vorhandenen
+ * Stack-Map-Frames bleiben gültig, es muss nichts neu berechnet werden.
+ */
+final class Umbau implements ClassFileTransformer {
+    static final String ZIEL = "com/mojang/authlib/yggdrasil/YggdrasilMinecraftSessionService";
+
+    @Override
+    public byte[] transform(ClassLoader loader, String name, Class<?> umdefiniert, ProtectionDomain pd, byte[] klasse) {
+        if (!ZIEL.equals(name) || umdefiniert != null) return null;
+        try {
+            ClassReader leser = new ClassReader(klasse);
+            ClassWriter schreiber = new ClassWriter(leser, ClassWriter.COMPUTE_MAXS);
+            final int[] umgebaut = {0};
+            leser.accept(new ClassVisitor(Opcodes.ASM9, schreiber) {
+                @Override
+                public MethodVisitor visitMethod(int zugriff, String mname, String desc, String sig, String[] ausn) {
+                    MethodVisitor mv = super.visitMethod(zugriff, mname, desc, sig, ausn);
+                    if ((zugriff & Opcodes.ACC_STATIC) != 0) return mv;
+                    String rueckgabe = null;
+                    if ("unpackTextures".equals(mname) && desc.startsWith("(Lcom/mojang/authlib/properties/Property;)L")) {
+                        rueckgabe = desc.substring(desc.indexOf(")L") + 2, desc.length() - 1);
+                    } else if ("getTextures".equals(mname) && desc.equals("(Lcom/mojang/authlib/GameProfile;Z)Ljava/util/Map;")) {
+                        rueckgabe = "java/util/Map";
+                    }
+                    if (rueckgabe == null) return mv;
+                    umgebaut[0]++;
+                    final String typ = rueckgabe;
+                    return new MethodVisitor(Opcodes.ASM9, mv) {
+                        @Override
+                        public void visitInsn(int op) {
+                            if (op == Opcodes.ARETURN) {
+                                // Stapel: [ergebnis] -> [dienst, ergebnis, argument] -> apply -> [neu]
+                                super.visitVarInsn(Opcodes.ALOAD, 1);
+                                super.visitMethodInsn(Opcodes.INVOKESTATIC, "java/lang/System", "getProperties", "()Ljava/util/Properties;", false);
+                                super.visitLdcInsn(Agent.SCHLUESSEL);
+                                super.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/util/Properties", "get", "(Ljava/lang/Object;)Ljava/lang/Object;", false);
+                                super.visitTypeInsn(Opcodes.CHECKCAST, "java/util/function/BiFunction");
+                                super.visitInsn(Opcodes.DUP_X2);
+                                super.visitInsn(Opcodes.POP);
+                                super.visitMethodInsn(Opcodes.INVOKEINTERFACE, "java/util/function/BiFunction", "apply",
+                                    "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;", true);
+                                super.visitTypeInsn(Opcodes.CHECKCAST, typ);
+                            }
+                            super.visitInsn(op);
+                        }
+                    };
+                }
+            }, 0);
+            if (umgebaut[0] == 0) return null;
+            System.out.println("[AeroMC] authlib fuer Umhaenge vorbereitet (" + umgebaut[0] + " Methode)");
+            return schreiber.toByteArray();
+        } catch (Throwable t) {
+            System.out.println("[AeroMC] authlib konnte nicht angepasst werden: " + t);
+            return null;
+        }
+    }
+}

agent/tools/Shade.java

@@ -0,0 +1,80 @@
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.InputStream;
+import java.nio.file.Files;
+import java.util.Enumeration;
+import java.util.jar.Attributes;
+import java.util.jar.JarEntry;
+import java.util.jar.JarFile;
+import java.util.jar.JarOutputStream;
+import java.util.jar.Manifest;
+
+import org.objectweb.asm.ClassReader;
+import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.commons.ClassRemapper;
+import org.objectweb.asm.commons.Remapper;
+
+/**
+ * Baut die Agent-Datei: eigene Klassen + ASM, dabei org/objectweb/asm nach
+ * de/aeromc/capes/asm umbenannt. So kann das ASM von Fabric/Forge (das auf
+ * demselben Klassenpfad liegt) nie mit unserem verwechselt werden.
+ *
+ * Aufruf: java Shade <ziel.jar> <klassenordner> <asm.jar> [weitere ASM-Jars, z. B. asm-tree]
+ */
+public class Shade {
+    static final Remapper UMBENENNEN = new Remapper() {
+        @Override
+        public String map(String name) {
+            return name.startsWith("org/objectweb/asm/") ? "de/aeromc/capes/asm/" + name.substring(18) : name;
+        }
+    };
+
+    static byte[] umbenennen(byte[] klasse) {
+        ClassReader r = new ClassReader(klasse);
+        ClassWriter w = new ClassWriter(0);
+        r.accept(new ClassRemapper(w, UMBENENNEN), 0);
+        return w.toByteArray();
+    }
+
+    static byte[] lies(InputStream in) throws Exception {
+        ByteArrayOutputStream b = new ByteArrayOutputStream();
+        byte[] p = new byte[8192];
+        int n;
+        while ((n = in.read(p)) > 0) b.write(p, 0, n);
+        return b.toByteArray();
+    }
+
+    public static void main(String[] a) throws Exception {
+        Manifest mf = new Manifest();
+        Attributes at = mf.getMainAttributes();
+        at.put(Attributes.Name.MANIFEST_VERSION, "1.0");
+        at.putValue("Premain-Class", "de.aeromc.capes.Agent");
+        at.putValue("Agent-Class", "de.aeromc.capes.Agent");
+        at.putValue("Can-Retransform-Classes", "false");
+        at.putValue("Implementation-Title", "AeroMC Agent (Umhaenge, Spieldesign)");
+        try (JarOutputStream out = new JarOutputStream(new FileOutputStream(a[0]), mf)) {
+            // eigene Klassen
+            File basis = new File(a[1]);
+            for (File f : Files.walk(basis.toPath()).map(p -> p.toFile()).filter(f -> f.getName().endsWith(".class")).toArray(File[]::new)) {
+                String name = basis.toPath().relativize(f.toPath()).toString().replace('\\', '/');
+                out.putNextEntry(new JarEntry(name));
+                out.write(umbenennen(Files.readAllBytes(f.toPath())));
+                out.closeEntry();
+            }
+            // ASM (umbenannt), ohne Modul-Infos und Signaturen
+            for (int j = 2; j < a.length; j++) try (JarFile asm = new JarFile(a[j])) {
+                Enumeration<JarEntry> e = asm.entries();
+                while (e.hasMoreElements()) {
+                    JarEntry je = e.nextElement();
+                    String n = je.getName();
+                    if (!n.startsWith("org/objectweb/asm/") || !n.endsWith(".class")) continue;
+                    byte[] neu = umbenennen(lies(asm.getInputStream(je)));
+                    out.putNextEntry(new JarEntry("de/aeromc/capes/asm/" + n.substring(18)));
+                    out.write(neu);
+                    out.closeEntry();
+                }
+            }
+        }
+    }
+}

installer/Installer.cs

@@ -181,9 +181,35 @@ public static class Installer
             k.SetValue("NoRepair", 1, RegistryValueKind.DWord);
         }
 
+        progress.Report((0.98, "Installation wird abgeschlossen …"));
+        Vorwaermen(exe);
+
         progress.Report((1.0, "Fertig"));
     }
 
+    /// <summary>
+    /// Startet AeroMC einmal kurz mit "--aeromc-vorwaermen" – die App beendet sich
+    /// damit sofort wieder (siehe src/main.js). Windows Defender prüft eine neue,
+    /// noch unbekannte EXE beim ersten Start mehrere Sekunden lang (gemessen: ~8 s);
+    /// das passiert so während des Fortschrittsbalkens und nicht erst beim Klick
+    /// auf "Fertigstellen". Das Ergebnis merkt sich Windows, der echte Start ist
+    /// danach sofort da.
+    /// </summary>
+    private static void Vorwaermen(string exe)
+    {
+        try
+        {
+            using var p = Process.Start(new ProcessStartInfo(exe, "--aeromc-vorwaermen")
+            {
+                UseShellExecute = false,
+                CreateNoWindow = true,
+                WorkingDirectory = Path.GetDirectoryName(exe)!,
+            });
+            if (p != null && !p.WaitForExit(30000)) { try { p.Kill(); } catch { } }
+        }
+        catch { /* nur eine Beschleunigung – Fehler sind egal */ }
+    }
+
     private static List<string> TopLevelNames(ZipArchive zip) =>
         zip.Entries
             .Select(e => e.FullName.Replace('\\', '/').Split('/')[0])

installer/MainWindow.xaml.cs

@@ -300,7 +300,16 @@ public partial class MainWindow : Window
                 await RunInstall(DirBox.Text.Trim(), DesktopLinkBox.IsChecked == true, update: false);
                 break;
             case PageNumProgress:
-                if (LaunchBox.IsChecked == true) StartApp();
+                // Start im Hintergrund: Process.Start kann blockieren, solange Windows
+                // die EXE prüft – das Fenster darf dabei nie einfrieren
+                if (LaunchBox.IsChecked == true)
+                {
+                    _busy = true;
+                    NextButton.IsEnabled = false;
+                    NextButton.Content = "AeroMC startet …";
+                    await Task.Run(StartApp);
+                    _busy = false;
+                }
                 Close();
                 break;
         }

installer/obj/AeroMCSetup.csproj.nuget.dgspec.json

@@ -5,7 +5,7 @@
   },
   "projects": {
     "C:\\Users\\Viper\\Desktop\\AeroMC-Launcher\\installer\\AeroMCSetup.csproj": {
-      "version": "1.1.6",
+      "version": "0.0.0",
       "restore": {
         "projectUniqueName": "C:\\Users\\Viper\\Desktop\\AeroMC-Launcher\\installer\\AeroMCSetup.csproj",
         "projectName": "AeroMC-Setup",

installer/obj/Release/net48/AeroMCSetup.AssemblyInfo.cs

@@ -14,11 +14,11 @@ using System.Reflection;
 [assembly: System.Reflection.AssemblyConfigurationAttribute("Release")]
 [assembly: System.Reflection.AssemblyCopyrightAttribute("Copyright (c) M_Viper. Alle Rechte vorbehalten.")]
 [assembly: System.Reflection.AssemblyDescriptionAttribute("Installiert AeroMC")]
-[assembly: System.Reflection.AssemblyFileVersionAttribute("1.1.6.0")]
-[assembly: System.Reflection.AssemblyInformationalVersionAttribute("1.1.6")]
+[assembly: System.Reflection.AssemblyFileVersionAttribute("1.2.4.0")]
+[assembly: System.Reflection.AssemblyInformationalVersionAttribute("1.2.4")]
 [assembly: System.Reflection.AssemblyProductAttribute("AeroMC Setup")]
 [assembly: System.Reflection.AssemblyTitleAttribute("AeroMC Setup")]
-[assembly: System.Reflection.AssemblyVersionAttribute("1.1.6.0")]
+[assembly: System.Reflection.AssemblyVersionAttribute("1.2.4.0")]
 [assembly: System.Resources.NeutralResourcesLanguageAttribute("de-DE")]
 
 // Von der MSBuild WriteCodeFragment-Klasse generiert.

installer/obj/Release/net48/AeroMCSetup.AssemblyInfoInputs.cache

@@ -1 +1 @@
-5b6f28fb41c3f0e5fe29f9489cfc618a7d6593efb71d420030e4a1d4fdb4066e
+c285113a921613345252c7c4e9c903f219339ded7e116f59ea5c382b3fb91383

installer/obj/project.assets.json

@@ -418,7 +418,7 @@
     "C:\\Users\\Viper\\.nuget\\packages\\": {}
   },
   "project": {
-    "version": "1.1.6",
+    "version": "0.0.0",
     "restore": {
       "projectUniqueName": "C:\\Users\\Viper\\Desktop\\AeroMC-Launcher\\installer\\AeroMCSetup.csproj",
       "projectName": "AeroMC-Setup",

installer/obj/project.nuget.cache

@@ -1,6 +1,6 @@
 {
   "version": 2,
-  "dgSpecHash": "lJiGEWCFg6M=",
+  "dgSpecHash": "FnRoda2hVew=",
   "success": true,
   "projectFilePath": "C:\\Users\\Viper\\Desktop\\AeroMC-Launcher\\installer\\AeroMCSetup.csproj",
   "expectedPackageFiles": [

mod/MODRINTH.md

@@ -0,0 +1,42 @@
+# AeroMC Capes
+
+Shows the **custom capes (including HD up to 1024×512)** of players who designed their cape in the
+[AeroMC Launcher](https://aeromc.viper.ipv64.net) – right in the game, even if you use a different
+launcher yourself.
+
+## How it works
+- Drop the mod into your `mods` folder – done. No configuration, no Fabric API required.
+- Whenever Minecraft loads a player's skin, the mod asks the AeroMC server whether that player has
+  an AeroMC cape and shows it instead of the regular cape.
+- If a player has no AeroMC cape, nothing changes (official Mojang cape or none).
+- **Client-side only** – servers don't need anything.
+
+## Compatibility
+- **Fabric** and **Quilt**
+- **One jar for all versions**: Minecraft 1.14 to 26.x
+- Works with old Fabric Loader versions too (0.10 and newer)
+- Players using the AeroMC Launcher don't need this mod (the launcher already does this on its
+  own) – but having it installed doesn't hurt either.
+
+## Privacy
+The mod only sends the (public) UUIDs of players whose skins are currently being loaded to
+`viper-network.de` to look up their capes. Results are cached for a few minutes.
+No account or login data is ever transmitted.
+
+## Create your own cape
+In the AeroMC Launcher: click your account name (top right) → **Skin ändern…** (Change skin) →
+in the **Umhang** (Cape) section click **Gestalten…** (Design). You can paint your cape pixel by
+pixel or insert any image, in sizes from 64×32 up to HD 1024×512.
+
+---
+
+### Hinweise zum Hochladen (nicht Teil der Beschreibung)
+- Name: AeroMC Capes (URL bleibt `aeromc-umhaenge`)
+- Kurzbeschreibung: Shows custom capes (HD up to 1024×512) made in the AeroMC Launcher – even if you use another launcher. One jar for 1.14–26.x, client-side.
+- Datei: `dist/aeromc-umhaenge-fabric-1.0.0.jar`
+- Loader: Fabric, Quilt · Umgebung: Client · Server: nicht nötig
+- Spielversionen: alle Releases von 1.14 bis zur aktuellen
+- Kategorien: Sozial (hervorgehoben), Werkzeug („Cosmetic“ gibt es für Mods nicht)
+- Abhängigkeiten: keine
+- Lizenz: aktuell „All Rights Reserved“ (in `fabric.mod.json`) – Modrinth akzeptiert das, eine
+  offene Lizenz (z. B. MIT) wirkt aber vertrauenswürdiger.

mod/resources/aeromc-capes.mixins.json

@@ -0,0 +1,10 @@
+{
+  "required": false,
+  "minVersion": "0.8",
+  "package": "de.aeromc.capes.mixin",
+  "compatibilityLevel": "JAVA_8",
+  "client": ["SessionServiceMixin", "SkinLaderMixin"],
+  "injectors": {
+    "defaultRequire": 0
+  }
+}

mod/resources/fabric.mod.json

@@ -0,0 +1,18 @@
+{
+  "schemaVersion": 1,
+  "id": "aeromc-capes",
+  "version": "1.0.0",
+  "name": "AeroMC Umhänge",
+  "description": "Zeigt die eigenen Umhänge (auch HD) von AeroMC-Spielern im Spiel – gestaltet im AeroMC Launcher. Nur auf dem Client nötig. Funktioniert mit jeder Minecraft-Version, die Fabric unterstützt.",
+  "authors": ["M_Viper"],
+  "contact": {
+    "homepage": "https://aeromc.viper.ipv64.net"
+  },
+  "license": "LicenseRef-All-Rights-Reserved",
+  "icon": "assets/aeromc-capes/icon.png",
+  "environment": "client",
+  "mixins": ["aeromc-capes.mixins.json"],
+  "depends": {
+    "fabricloader": ">=0.10.0"
+  }
+}

mod/src/de/aeromc/capes/mixin/SessionServiceMixin.java

@@ -0,0 +1,48 @@
+package de.aeromc.capes.mixin;
+
+import com.mojang.authlib.GameProfile;
+import com.mojang.authlib.properties.Property;
+import com.mojang.authlib.yggdrasil.YggdrasilMinecraftSessionService;
+import de.aeromc.capes.mod.Umhaenge;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+
+/**
+ * Hängt sich an die Textur-Methoden von authlib (beide Fassungen, siehe
+ * agent/…/Umbau.java). require = 0: Es greift immer nur die Methode, die es in
+ * der jeweiligen authlib-Fassung gibt, die andere wird still übersprungen.
+ * remap = false: authlib ist nicht verschleiert, Namen bleiben wie sie sind.
+ */
+@Mixin(value = YggdrasilMinecraftSessionService.class, remap = false)
+public abstract class SessionServiceMixin {
+
+    // wird in den statischen Initialisierer von authlib übernommen: zeigt im Spielprotokoll, dass der Mod greift
+    static {
+        Umhaenge.authlibGreift = true;
+        Umhaenge.meldeAktiv("authlib");
+    }
+
+    // authlib 5+ (Minecraft 1.20.2 … 26.x)
+    @Inject(method = "unpackTextures", at = @At("RETURN"), cancellable = true, remap = false, require = 0)
+    private void aeromc$neu(Property eigenschaft, CallbackInfoReturnable<Object> cir) {
+        aeromc$ersetze(cir, eigenschaft);
+    }
+
+    // authlib 1–4 (Minecraft 1.14 … 1.20.1)
+    @Inject(method = "getTextures(Lcom/mojang/authlib/GameProfile;Z)Ljava/util/Map;", at = @At("RETURN"), cancellable = true, remap = false, require = 0)
+    private void aeromc$alt(GameProfile profil, boolean sicher, CallbackInfoReturnable<Object> cir) {
+        aeromc$ersetze(cir, profil);
+    }
+
+    private static void aeromc$ersetze(CallbackInfoReturnable<Object> cir, Object argument) {
+        try {
+            Object alt = cir.getReturnValue();
+            Object neu = Umhaenge.mitUmhang(alt, argument);
+            if (neu != alt) cir.setReturnValue(neu);
+        } catch (Throwable ignoriert) {
+            // im Zweifel bleibt alles wie ohne Mod
+        }
+    }
+}

mod/src/de/aeromc/capes/mixin/SkinLaderMixin.java

@@ -0,0 +1,38 @@
+package de.aeromc.capes.mixin;
+
+import com.mojang.authlib.GameProfile;
+import com.mojang.authlib.minecraft.MinecraftSessionService;
+import de.aeromc.capes.mod.Umhaenge;
+import net.minecraft.class_1071;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Redirect;
+
+import java.util.Map;
+
+/**
+ * Zweiter Weg für alte Fabric Loader (vor 0.12): Die lassen Mixins nur in
+ * Minecraft selbst zu, nicht in authlib – SessionServiceMixin greift dort also
+ * nie. Deshalb wird hier der Aufruf von getTextures im Skin-Lader von Minecraft
+ * (PlayerSkinProvider = class_1071, Intermediary-Name, gleich in 1.14 … 1.20.1)
+ * umgeleitet. Bei neuen Loadern erledigt das bereits SessionServiceMixin, dann
+ * reicht diese Umleitung das Ergebnis nur unverändert durch.
+ */
+@Mixin(value = class_1071.class, targets = "net.minecraft.class_1071$1", remap = false)
+public abstract class SkinLaderMixin {
+
+    @Redirect(method = "*", at = @At(value = "INVOKE", remap = false,
+            target = "Lcom/mojang/authlib/minecraft/MinecraftSessionService;getTextures(Lcom/mojang/authlib/GameProfile;Z)Ljava/util/Map;"),
+            remap = false, require = 0)
+    private Map aeromc$texturen(MinecraftSessionService dienst, GameProfile profil, boolean sicher) {
+        Map texturen = dienst.getTextures(profil, sicher);
+        if (Umhaenge.authlibGreift) return texturen;
+        Umhaenge.meldeAktiv("Skin-Lader");
+        try {
+            Object neu = Umhaenge.mitUmhang(texturen, profil);
+            return neu instanceof Map ? (Map) neu : texturen;
+        } catch (Throwable ignoriert) {
+            return texturen;
+        }
+    }
+}

mod/src/de/aeromc/capes/mod/Umhaenge.java

@@ -0,0 +1,39 @@
+package de.aeromc.capes.mod;
+
+import de.aeromc.capes.Nachschlagen;
+
+/**
+ * AeroMC Umhänge – Fabric/Quilt-Mod für Spieler, die NICHT den AeroMC Launcher
+ * nutzen. Er macht dasselbe wie der Umhang-Agent des Launchers: In Mojangs
+ * authlib wird der AeroMC-Umhang eines Spielers eingesetzt, sobald Minecraft
+ * dessen Skin lädt. Da nur authlib angepasst wird (nicht Minecraft selbst),
+ * passt ein und derselbe Mod zu jeder Minecraft-Version, die Fabric kennt.
+ * Alte Fabric Loader (vor 0.12) erlauben keine Mixins in authlib, dort greift
+ * stattdessen SkinLaderMixin im Skin-Lader von Minecraft.
+ */
+public final class Umhaenge {
+    private static final Nachschlagen DIENST = new Nachschlagen(Nachschlagen.STANDARD_BASIS);
+
+    /** true, sobald SessionServiceMixin in authlib eingebaut wurde (dann ist SkinLaderMixin überflüssig). */
+    public static volatile boolean authlibGreift;
+    private static volatile boolean gemeldet;
+
+    private Umhaenge() {}
+
+    /** Schreibt einmalig ins Spielprotokoll, dass (und über welchen Weg) der Mod greift. */
+    public static void meldeAktiv(String weg) {
+        if (gemeldet || agentAktiv()) return;
+        gemeldet = true;
+        System.out.println("[AeroMC] Umhang-Mod aktiv (" + weg + ")");
+    }
+
+    /** Läuft das Spiel über den AeroMC Launcher, setzt schon dessen Agent die Umhänge ein. */
+    public static boolean agentAktiv() {
+        return System.getProperties().containsKey("aeromc.capes.hook");
+    }
+
+    public static Object mitUmhang(Object ergebnis, Object argument) {
+        if (agentAktiv()) return ergebnis;
+        return DIENST.apply(ergebnis, argument);
+    }
+}

mod/stubs/net/minecraft/class_1071.java

@@ -0,0 +1,4 @@
+package net.minecraft;
+
+/** Nur zum Kompilieren: Platzhalter für Minecrafts PlayerSkinProvider (Intermediary-Name). Kommt nicht ins Mod-Jar. */
+public class class_1071 {}

package.json

@@ -1,7 +1,7 @@
 {
   "name": "aeromc",
   "productName": "AeroMC",
-  "version": "1.1.6",
+  "version": "1.2.4",
   "description": "AeroMC – Instanz-basierter Minecraft-Launcher (à la MultiMC/Prism)",
   "homepage": "https://m-viper.de",
   "launcherWebsite": "https://aeromc.viper.ipv64.net",
@@ -11,10 +11,10 @@
   "private": true,
   "scripts": {
     "start": "electron .",
-    "prebuild": "node scripts/write-build-config.js",
-    "prebuild:portable": "node scripts/write-build-config.js",
-    "build": "electron-builder --win dir && node scripts/build-setup.js",
-    "build:portable": "electron-builder --win portable --x64 && node -e \"const fs=require('fs');const path=require('path');['dist/builder-debug.yml','dist/builder-effective-config.yaml','dist/win-unpacked'].forEach((target)=>fs.rmSync(target,{recursive:true,force:true}));if(fs.existsSync('dist')){const source=path.join('dist','AeroMC.exe');const target=path.join('dist','AeroMC-Portable.exe');if(fs.existsSync(target))fs.rmSync(target,{force:true});if(fs.existsSync(source))fs.renameSync(source,target);for(const name of fs.readdirSync('dist')){if((name.endsWith('.exe')&&name!=='AeroMC-Setup.exe'&&name!=='AeroMC-Portable.exe')||name.endsWith('.blockmap')){fs.rmSync(path.join('dist',name),{force:true})}}}\""
+    "prebuild": "node scripts/pruefe-version.js && node scripts/write-build-config.js",
+    "prebuild:portable": "node scripts/pruefe-version.js && node scripts/write-build-config.js",
+    "build": "electron-builder --win dir && node scripts/build-setup.js && node scripts/sign-release.js setup",
+    "build:portable": "electron-builder --win portable --x64 && node -e \"const fs=require('fs');const path=require('path');['dist/builder-debug.yml','dist/builder-effective-config.yaml','dist/win-unpacked'].forEach((target)=>fs.rmSync(target,{recursive:true,force:true}));if(fs.existsSync('dist')){const source=path.join('dist','AeroMC.exe');const target=path.join('dist','AeroMC-Portable.exe');if(fs.existsSync(target))fs.rmSync(target,{force:true});if(fs.existsSync(source))fs.renameSync(source,target);for(const name of fs.readdirSync('dist')){if((name.endsWith('.exe')&&name!=='AeroMC-Setup.exe'&&name!=='AeroMC-Portable.exe')||name.endsWith('.blockmap')){fs.rmSync(path.join('dist',name),{force:true})}}}\" && node scripts/sign-release.js portable"
   },
   "build": {
     "appId": "com.aeromc.launcher",
@@ -34,11 +34,18 @@
     "win": {
       "target": "dir",
       "icon": "src/assets/icon.ico"
+    },
+    "electronFuses": {
+      "runAsNode": false,
+      "enableNodeOptionsEnvironmentVariable": false,
+      "enableNodeCliInspectArguments": false,
+      "enableEmbeddedAsarIntegrityValidation": true,
+      "onlyLoadAppFromAsar": true
     }
   },
   "devDependencies": {
-    "electron": "^28.0.0",
-    "electron-builder": "^24.0.0"
+    "electron": "^44.6.0",
+    "electron-builder": "^26.15.3"
   },
   "dependencies": {
     "@xhayper/discord-rpc": "^1.3.4",
@@ -50,5 +57,8 @@
     "sql.js": "^1.14.2",
     "undici": "^6.28.0",
     "unzipper": "^0.12.5"
+  },
+  "overrides": {
+    "brace-expansion@^2.0.0": "^2.1.7"
   }
 }

scripts/build-agent.js

@@ -0,0 +1,73 @@
+'use strict';
+
+/*
+ * build-agent.js – baut src/assets/agent/aeromc-capes.jar (AeroMC-Umhang-Agent)
+ * ------------------------------------------------------------------------------
+ * Braucht ein JDK (javac/java, ab 11) und ASM 9 – beides wird nur beim Bauen
+ * gebraucht, die fertige Datei liegt im Projekt. Gesucht wird das JDK über
+ * JAVA_HOME bzw. unter "C:\Program Files\Eclipse Adoptium", ASM im
+ * Bibliotheksordner von AeroMC (dort legen Fabric/Forge es ohnehin ab).
+ * Der Agent wird für Java 8 übersetzt, läuft also mit jeder Minecraft-Version.
+ *
+ * Aufruf: node scripts/build-agent.js
+ */
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { execFileSync } = require('child_process');
+
+const WURZEL = path.join(__dirname, '..');
+const ZIEL = path.join(WURZEL, 'src', 'assets', 'agent', 'aeromc-capes.jar');
+
+function findeJdk() {
+  const kandidaten = [];
+  if (process.env.JAVA_HOME) kandidaten.push(process.env.JAVA_HOME);
+  const adoptium = 'C:\\Program Files\\Eclipse Adoptium';
+  if (fs.existsSync(adoptium)) {
+    for (const d of fs.readdirSync(adoptium).filter((n) => /^jdk-/.test(n)).sort().reverse()) kandidaten.push(path.join(adoptium, d));
+  }
+  const jdk = kandidaten.find((d) => fs.existsSync(path.join(d, 'bin', process.platform === 'win32' ? 'javac.exe' : 'javac')));
+  if (!jdk) throw new Error('Kein JDK gefunden (JAVA_HOME setzen).');
+  return jdk;
+}
+
+function findeAsm(name) {
+  const basis = path.join(process.env.APPDATA || os.homedir(), 'aeromc', 'shared', 'libraries', 'org', 'ow2', 'asm', name);
+  if (!fs.existsSync(basis)) throw new Error(`ASM (${name}) nicht gefunden unter ${basis}`);
+  const versionen = fs.readdirSync(basis).filter((v) => /^9\./.test(v))
+    .sort((a, b) => b.split('.').map(Number).reduce((s, x, i) => s || x - (a.split('.').map(Number)[i] || 0), 0));
+  const datei = path.join(basis, versionen[0], `${name}-${versionen[0]}.jar`);
+  if (!fs.existsSync(datei)) throw new Error('ASM-Datei fehlt: ' + datei);
+  return datei;
+}
+
+function quellen(ordner) {
+  return fs.readdirSync(ordner, { withFileTypes: true }).flatMap((e) => {
+    const p = path.join(ordner, e.name);
+    return e.isDirectory() ? quellen(p) : (e.name.endsWith('.java') ? [p] : []);
+  });
+}
+
+const jdk = findeJdk();
+const javac = path.join(jdk, 'bin', 'javac');
+const java = path.join(jdk, 'bin', 'java');
+const asm = findeAsm('asm');
+const asmCommons = findeAsm('asm-commons');
+const asmTree = findeAsm('asm-tree');
+const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'aeromc-agent-'));
+const klassen = path.join(tmp, 'klassen');
+const werkzeug = path.join(tmp, 'werkzeug');
+console.log('JDK:', jdk);
+console.log('ASM:', asm);
+try {
+  execFileSync(javac, ['--release', '8', '-nowarn', '-encoding', 'UTF-8', '-cp', [asm, asmTree].join(path.delimiter), '-d', klassen,
+    ...quellen(path.join(WURZEL, 'agent', 'src'))], { stdio: 'inherit' });
+  execFileSync(javac, ['-encoding', 'UTF-8', '-cp', [asm, asmCommons].join(path.delimiter), '-d', werkzeug,
+    path.join(WURZEL, 'agent', 'tools', 'Shade.java')], { stdio: 'inherit' });
+  fs.mkdirSync(path.dirname(ZIEL), { recursive: true });
+  execFileSync(java, ['-cp', [werkzeug, asm, asmCommons].join(path.delimiter), 'Shade', ZIEL, klassen, asm, asmTree], { stdio: 'inherit' });
+  console.log(`Fertig: ${ZIEL} (${fs.statSync(ZIEL).size} Bytes)`);
+} finally {
+  fs.rmSync(tmp, { recursive: true, force: true });
+}

scripts/build-mod.js

@@ -0,0 +1,83 @@
+'use strict';
+
+/*
+ * build-mod.js – baut den Fabric/Quilt-Mod "AeroMC Umhänge" (dist/aeromc-umhaenge-fabric-<version>.jar)
+ * -------------------------------------------------------------------------------------------------
+ * Für Spieler, die NICHT den AeroMC Launcher nutzen. Der Mod greift wie der
+ * Umhang-Agent nur in Mojangs authlib ein (Mixin, ohne Namensumsetzung) – darum
+ * braucht es weder Gradle noch Fabric Loom, und eine Datei passt zu allen
+ * Minecraft-Versionen, die Fabric unterstützt. Übersetzt wird für Java 8.
+ *
+ * Gebraucht werden (nur beim Bauen) ein JDK sowie sponge-mixin und authlib aus
+ * dem Bibliotheksordner von AeroMC. Der Nachschlage-Code ist derselbe wie im
+ * Agenten (agent/src/de/aeromc/capes/Nachschlagen.java).
+ *
+ * Aufruf: node scripts/build-mod.js
+ */
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { execFileSync } = require('child_process');
+
+const WURZEL = path.join(__dirname, '..');
+const LIB = path.join(process.env.APPDATA || os.homedir(), 'aeromc', 'shared', 'libraries');
+const modInfo = JSON.parse(fs.readFileSync(path.join(WURZEL, 'mod', 'resources', 'fabric.mod.json'), 'utf8'));
+const ZIEL = path.join(WURZEL, 'dist', `aeromc-umhaenge-fabric-${modInfo.version}.jar`);
+
+function findeJdk() {
+  const kandidaten = [];
+  if (process.env.JAVA_HOME) kandidaten.push(process.env.JAVA_HOME);
+  const adoptium = 'C:\\Program Files\\Eclipse Adoptium';
+  if (fs.existsSync(adoptium)) {
+    for (const d of fs.readdirSync(adoptium).filter((n) => /^jdk-/.test(n)).sort().reverse()) kandidaten.push(path.join(adoptium, d));
+  }
+  const jdk = kandidaten.find((d) => fs.existsSync(path.join(d, 'bin', process.platform === 'win32' ? 'javac.exe' : 'javac')));
+  if (!jdk) throw new Error('Kein JDK gefunden (JAVA_HOME setzen).');
+  return jdk;
+}
+
+// neueste (oder mit aelteste=true älteste) Fassung einer Bibliothek im AeroMC-Bibliotheksordner
+function bibliothek(gruppe, name, aelteste = false) {
+  const basis = path.join(LIB, ...gruppe.split('.'), name);
+  if (!fs.existsSync(basis)) throw new Error(`${name} nicht gefunden unter ${basis}`);
+  const fassungen = fs.readdirSync(basis).sort((a, b) => a.localeCompare(b, undefined, { numeric: true }));
+  const v = aelteste ? fassungen[0] : fassungen.pop();
+  const datei = path.join(basis, v, `${name}-${v}.jar`);
+  if (!fs.existsSync(datei)) throw new Error('Datei fehlt: ' + datei);
+  return datei;
+}
+
+function quellen(ordner) {
+  return fs.readdirSync(ordner, { withFileTypes: true }).flatMap((e) => {
+    const p = path.join(ordner, e.name);
+    return e.isDirectory() ? quellen(p) : (e.name.endsWith('.java') ? [p] : []);
+  });
+}
+
+// authlib in der ältesten Fassung: SkinLaderMixin ruft getTextures(GameProfile, boolean) auf, das es nur bis authlib 4 gibt
+const jdk = findeJdk();
+const klassenpfad = [bibliothek('net.fabricmc', 'sponge-mixin'), bibliothek('com.mojang', 'authlib', true)].join(path.delimiter);
+const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'aeromc-mod-'));
+const inhalt = path.join(tmp, 'inhalt');
+const stubs = path.join(tmp, 'stubs');
+console.log('JDK:', jdk);
+try {
+  // Platzhalter für Minecraft-Klassen (nur zum Kompilieren, landen nicht im Jar)
+  execFileSync(path.join(jdk, 'bin', 'javac'), ['--release', '8', '-nowarn', '-encoding', 'UTF-8', '-d', stubs,
+    ...quellen(path.join(WURZEL, 'mod', 'stubs'))], { stdio: 'inherit' });
+  execFileSync(path.join(jdk, 'bin', 'javac'), ['--release', '8', '-nowarn', '-encoding', 'UTF-8', '-proc:none', '-cp', klassenpfad + path.delimiter + stubs, '-d', inhalt,
+    ...quellen(path.join(WURZEL, 'mod', 'src')),
+    path.join(WURZEL, 'agent', 'src', 'de', 'aeromc', 'capes', 'Nachschlagen.java')], { stdio: 'inherit' });
+  for (const datei of fs.readdirSync(path.join(WURZEL, 'mod', 'resources'))) {
+    fs.copyFileSync(path.join(WURZEL, 'mod', 'resources', datei), path.join(inhalt, datei));
+  }
+  fs.mkdirSync(path.join(inhalt, 'assets', 'aeromc-capes'), { recursive: true });
+  fs.copyFileSync(path.join(WURZEL, 'src', 'assets', 'logo.png'), path.join(inhalt, 'assets', 'aeromc-capes', 'icon.png'));
+  fs.mkdirSync(path.dirname(ZIEL), { recursive: true });
+  if (fs.existsSync(ZIEL)) fs.rmSync(ZIEL);
+  execFileSync(path.join(jdk, 'bin', 'jar'), ['--create', '--file', ZIEL, '-C', inhalt, '.'], { stdio: 'inherit' });
+  console.log(`Fertig: ${ZIEL} (${fs.statSync(ZIEL).size} Bytes)`);
+} finally {
+  fs.rmSync(tmp, { recursive: true, force: true });
+}

scripts/make-spieldesign.py

@@ -0,0 +1,712 @@
+"""
+make-spieldesign.py – erzeugt die Grafiken für den AeroMC-Look im Spiel
+=======================================================================
+Ausgabe nach src/assets/spieldesign/:
+
+  titel_alt.png / titel_neu.png     Titel-Logo (textures/gui/title/minecraft.png)
+                                    alt = bis 1.19.4 (zweigeteilt im 256×256-Atlas),
+                                    neu = ab 1.20 (ein Stück, 256×64)
+  edition_alt.png / edition_neu.png Untertitel "DEIN MINECRAFT ERLEBNIS" (edition.png)
+  ladelogo.png                      Ladebildschirm ab 1.16 als Vollbild (der Agent zieht
+                                    die Logo-Fläche auf Bildschirmgröße); im Format von
+                                    mojangstudios.png: linke Bildhälfte oben, rechte unten
+  ladelogo_alt.png                  Logo im Ladebildschirm 1.14/1.15 (ersetzt mojang.png)
+  panorama_0..5.png                 Hintergrund des Hauptmenüs (Würfelseiten)
+  pack.png, icon_<n>.rgba           Paket- und Fenstersymbol
+
+Eigene Bilder (optional) in scripts/spieldesign-quelle/:
+  hintergrund.png|jpg   Ladebildschirm-Hintergrund (am besten 16:9, z. B. 1920×1080)
+  panorama.png|jpg      Rundum-Panorama (360° × 180°, equirektangular, Seitenverhältnis 2:1)
+Fehlen sie, wird eine stilisierte Block-Landschaft in AeroMC-Blau gezeichnet.
+
+Alle Grafiken sind eigene Entwürfe – kein Mojang-Material.
+Aufruf: python scripts/make-spieldesign.py
+"""
+import math
+import os
+import random
+
+import numpy as np
+from PIL import Image, ImageChops, ImageDraw, ImageFilter, ImageFont
+
+WURZEL = os.path.join(os.path.dirname(os.path.abspath(__file__)), '..')
+ZIEL = os.path.join(WURZEL, 'src', 'assets', 'spieldesign')
+QUELLE = os.path.join(WURZEL, 'scripts', 'spieldesign-quelle')
+LOGO = os.path.join(WURZEL, 'src', 'assets', 'logo.png')
+SCHRIFT = 'C:/Windows/Fonts/seguisb.ttf'
+NACHTBLAU = (10, 14, 26)        # Hintergrund des Ladebildschirms (muss zu Design.HINTERGRUND passen)
+KONTUR = (7, 14, 36)
+
+# ---------- Block-Buchstaben (7 Zeilen hoch) ----------
+GLYPHEN = {
+    'A': ['.####.', '##..##', '##..##', '######', '##..##', '##..##', '##..##'],
+    'E': ['######', '##....', '##....', '#####.', '##....', '##....', '######'],
+    'R': ['#####.', '##..##', '##..##', '#####.', '##.##.', '##..##', '##..##'],
+    'O': ['.####.', '##..##', '##..##', '##..##', '##..##', '##..##', '.####.'],
+    'M': ['##...##', '###.###', '#######', '##.#.##', '##...##', '##...##', '##...##'],
+    'C': ['.#####', '##....', '##....', '##....', '##....', '##....', '.#####'],
+}
+# kleine Pixelschrift für den Untertitel (5 Zeilen hoch)
+KLEIN = {
+    'D': ['###.', '#..#', '#..#', '#..#', '###.'], 'E': ['###', '#..', '##.', '#..', '###'],
+    'I': ['#', '#', '#', '#', '#'], 'N': ['#..#', '##.#', '#.##', '#..#', '#..#'],
+    'M': ['#...#', '##.##', '#.#.#', '#...#', '#...#'], 'C': ['.##', '#..', '#..', '#..', '.##'],
+    'R': ['##.', '#.#', '##.', '#.#', '#.#'], 'A': ['.#.', '#.#', '###', '#.#', '#.#'],
+    'F': ['###', '#..', '##.', '#..', '#..'], 'T': ['###', '.#.', '.#.', '.#.', '.#.'],
+    'L': ['#..', '#..', '#..', '#..', '###'], 'B': ['##.', '#.#', '##.', '#.#', '##.'],
+    'S': ['.##', '#..', '.#.', '..#', '##.'],
+}
+
+
+def raster(text, glyphen, abstand=1, wortabstand=3):
+    punkte, x = [], 0
+    for i, z in enumerate(text):
+        if z == ' ':
+            x += wortabstand
+            continue
+        g = glyphen[z]
+        for y, zeile in enumerate(g):
+            for dx, c in enumerate(zeile):
+                if c == '#':
+                    punkte.append((x + dx, y, i))
+        x += len(g[0]) + abstand
+    return punkte, x - abstand, len(next(iter(glyphen.values())))
+
+
+def verlauf(h, w, oben, unten):
+    t = np.linspace(0, 1, h)[:, None, None]
+    return np.broadcast_to(np.array(oben, float) * (1 - t) + np.array(unten, float) * t, (h, w, 3)).copy()
+
+
+def rgba(arr, maske):
+    a = np.dstack([np.clip(arr, 0, 255), maske]).astype(np.uint8)
+    return Image.fromarray(a, 'RGBA')
+
+
+# ---------- Schriftzug ----------
+
+def schriftzug(b, flach=False):
+    """'AERO MC' aus Blöcken der Größe b (Pixel): Vorderseite, Tiefe nach unten, Kontur."""
+    punkte, breite, hoehe = raster('AERO MC', GLYPHEN, 1, 2)
+    tiefe = 0 if flach else max(2, int(b * 0.55))
+    k = 0 if flach else max(2, b // 5)
+    W, H = breite * b + 2 * k, hoehe * b + tiefe + 2 * k
+    front = np.zeros((H, W), bool)
+    blau = np.zeros((H, W), bool)
+    kante = np.zeros((H, W), float)
+    belegt = {(x, y) for x, y, _ in punkte}
+    rnd = np.random.RandomState(7)
+    rauschen = np.zeros((H, W))
+    zell = max(1, b // 4)
+    for bx, by, i in punkte:
+        x0, y0 = k + bx * b, k + by * b
+        front[y0:y0 + b, x0:x0 + b] = True
+        if i >= 5:
+            blau[y0:y0 + b, x0:x0 + b] = True
+        # Stein-Struktur in kleinen Zellen
+        for yy in range(0, b, zell):
+            for xx in range(0, b, zell):
+                rauschen[y0 + yy:y0 + yy + zell, x0 + xx:x0 + xx + zell] = rnd.randint(-9, 6)
+        if (bx, by - 1) not in belegt:
+            kante[y0:y0 + max(1, b // 6), x0:x0 + b] = 34          # helle Oberkante
+        if (bx + 1, by) not in belegt:
+            kante[y0:y0 + b, x0 + b - max(1, b // 7):x0 + b] -= 26  # dunklere rechte Kante
+    hell = verlauf(H, W, (255, 255, 255), (176, 190, 214))
+    mc = verlauf(H, W, (170, 236, 255), (34, 108, 232))
+    farbe = np.where(blau[..., None], mc, hell) + (rauschen + kante)[..., None]
+    if flach:
+        return rgba(farbe, front * 255)
+    seite = np.zeros((H, W), bool)
+    for t in range(1, tiefe + 1):
+        seite[t:, :] |= front[:-t, :]
+    seite &= ~front
+    blau_seite = np.zeros((H, W), bool)
+    for t in range(1, tiefe + 1):
+        blau_seite[t:, :] |= blau[:-t, :]
+    seite_farbe = np.where(blau_seite[..., None], verlauf(H, W, (30, 84, 190), (14, 44, 120)),
+                           verlauf(H, W, (112, 126, 156), (66, 78, 104)))
+    alles = Image.fromarray(((front | seite) * 255).astype(np.uint8))
+    kontur = np.array(alles.filter(ImageFilter.MaxFilter(2 * k + 1))) > 0
+    bild = np.zeros((H, W, 3))
+    bild[kontur] = KONTUR
+    bild[seite] = seite_farbe[seite]
+    bild[front] = farbe[front]
+    return rgba(bild, kontur * 255)
+
+
+def pyramide(w, h):
+    """Blaue Pyramide (linke Seite hell, rechte dunkel, leuchtender Grat)."""
+    w, h = int(w), int(h)
+    links = Image.new('L', (w, h), 0)
+    rechts = Image.new('L', (w, h), 0)
+    spitze, mitte = (w * 0.5, 0), (w * 0.56, h)
+    ImageDraw.Draw(links).polygon([spitze, (0, h), mitte], fill=255)
+    ImageDraw.Draw(rechts).polygon([spitze, mitte, (w, h)], fill=255)
+    hell = verlauf(h, w, (150, 232, 255), (40, 126, 236))
+    dunkel = verlauf(h, w, (52, 130, 236), (14, 48, 140))
+    l, r = np.array(links) > 0, np.array(rechts) > 0
+    bild = np.zeros((h, w, 3))
+    bild[l] = hell[l]
+    bild[r] = dunkel[r]
+    img = rgba(bild, np.maximum(np.array(links), np.array(rechts)))
+    d = ImageDraw.Draw(img)
+    d.line([spitze, mitte], fill=(215, 248, 255, 255), width=max(2, w // 70))
+    d.line([spitze, (0, h)], fill=(120, 215, 255, 255), width=max(1, w // 140))
+    return img
+
+
+def leuchten(bild, radius, farbe=(70, 190, 255), staerke=0.75):
+    a = bild.split()[3].filter(ImageFilter.MaxFilter(3)).filter(ImageFilter.GaussianBlur(radius))
+    a = a.point(lambda v: int(v * staerke))
+    g = Image.new('RGBA', bild.size, farbe + (0,))
+    g.putalpha(a)
+    return g
+
+
+def logo(b, mit_leuchten=True):
+    """Pyramide hinter dem Schriftzug, wie im Entwurf. Rückgabe: Bild, Unterkante des Schriftzugs."""
+    text = schriftzug(b)
+    pw, ph = text.width * 0.46, text.height * 1.55
+    pyr = pyramide(pw, ph)
+    oben = int(ph - text.height * 0.62)                    # so weit ragt die Pyramide über den Text
+    rand = int(b * 1.2) if mit_leuchten else 0
+    W, H = text.width + 2 * rand, oben + text.height + 2 * rand
+    bild = Image.new('RGBA', (W, H), (0, 0, 0, 0))
+    px = rand + (text.width - pyr.width) // 2 + int(text.width * 0.03)
+    schicht = Image.new('RGBA', (W, H), (0, 0, 0, 0))
+    schicht.alpha_composite(pyr, (px, rand))
+    schicht.alpha_composite(text, (rand, rand + oben))
+    if mit_leuchten:
+        bild.alpha_composite(leuchten(schicht, b * 0.9))
+    bild.alpha_composite(schicht)
+    return bild, rand + oben + text.height
+
+
+def einpassen(bild, w, h):
+    f = min(w / bild.width, h / bild.height, 1.0)
+    return bild.resize((max(1, int(bild.width * f)), max(1, int(bild.height * f))), Image.LANCZOS) if f < 1 else bild
+
+
+# ---------- Titel-Texturen ----------
+
+def titel_art():
+    """Pyramide, Schriftzug und Untertitel zusammen (Titel im Hauptmenü)."""
+    art, unterkante = logo(15)
+    unter, _ = untertitel_bild(5)
+    bild = Image.new('RGBA', (max(art.width, unter.width), unterkante + 8 + unter.height), (0, 0, 0, 0))
+    bild.alpha_composite(art, ((bild.width - art.width) // 2, 0))
+    bild.alpha_composite(unter, ((bild.width - unter.width) // 2, unterkante + 8))
+    return bild
+
+
+def titel(alt):
+    """
+    Der Agent erweitert den gezeichneten Streifen auf 64 Punkte Höhe (sonst 44).
+    neu (ab 1.20): 256×64-Textur, ganz genutzt.
+    alt (bis 1.19.4): Stücke (0,0,155,64) und (0,65,155,64) im 256×256-Atlas,
+    sichtbare Mitte bei x=137 des 310 breiten Streifens.
+    """
+    art = einpassen(titel_art(), (274 if alt else 256) * 4 - 8, 64 * 4)
+    if not alt:
+        t = Image.new('RGBA', (1024, 256), (0, 0, 0, 0))
+        t.alpha_composite(art, ((1024 - art.width) // 2, 256 - art.height))
+        return t
+    streifen = Image.new('RGBA', (310 * 4, 64 * 4), (0, 0, 0, 0))
+    streifen.alpha_composite(art, (137 * 4 - art.width // 2, 256 - art.height))
+    t = Image.new('RGBA', (1024, 1024), (0, 0, 0, 0))
+    t.alpha_composite(streifen.crop((0, 0, 620, 256)), (0, 0))
+    t.alpha_composite(streifen.crop((620, 0, 1240, 256)), (0, 65 * 4))
+    return t
+
+
+def untertitel_bild(skala, farbe=(236, 244, 255), schatten=(8, 16, 40)):
+    punkte, breite, hoehe = raster('DEIN MINECRAFT ERLEBNIS', KLEIN, 1, 3)
+    img = Image.new('RGBA', ((breite + 1) * skala, (hoehe + 1) * skala), (0, 0, 0, 0))
+    d = ImageDraw.Draw(img)
+    for dx, dy, f in ((1, 1, schatten), (0, 0, farbe)):
+        for x, y, _ in punkte:
+            d.rectangle(((x + dx) * skala, (y + dy) * skala, (x + dx + 1) * skala - 1, (y + dy + 1) * skala - 1), fill=f + (255,))
+    return img, breite
+
+
+def edition(breite_max):
+    img, breite = untertitel_bild(4)
+    if breite + 1 > breite_max:
+        raise SystemExit(f'Untertitel zu breit: {breite} > {breite_max}')
+    t = Image.new('RGBA', (512, 64), (0, 0, 0, 0))
+    t.alpha_composite(img, ((breite_max * 4 - img.width) // 2, (56 - img.height) // 2))
+    return t
+
+
+# ---------- stilisierte Block-Landschaft (Abendstimmung am Bergsee) ----------
+# Eine Szene, zwei Ansichten: als Rundum-Panorama (Menü) und als flacher
+# Ausschnitt nach vorne (Ladebildschirm). Gleicher Zufallswert -> gleiche Berge.
+
+def _mix(a, b, t):
+    return np.array(a, np.float32) * (1 - t) + np.array(b, np.float32) * t
+
+
+def _profil(phi, seed, schritt_rad):
+    """periodisches Höhenprofil 0..1, blockig gestuft"""
+    r = random.Random(seed)
+    stufe = np.floor(phi / schritt_rad) * schritt_rad + schritt_rad / 2
+    werte = np.zeros_like(phi)
+    for k in range(1, 16):
+        werte += r.uniform(0.25, 1.0) / k ** 1.05 * np.sin(k * stufe + r.uniform(0, 6.3))
+    return (werte + 2.2) / 4.4
+
+
+def szene(W, H, horizont, start, spanne, seed=2026):
+    rnd = random.Random(seed)
+    ppd = W / math.degrees(spanne)                     # Pixel je Grad
+    blk = max(4, int(round(ppd * 0.9)))                # Blockgröße der Silhouetten
+    schritt = math.radians(blk / ppd)                  # ein Block als Winkel
+    phi = (start + np.arange(W, dtype=np.float32) / W * spanne).astype(np.float32)
+    y = np.arange(H, dtype=np.float32)[:, None]
+    grad = (horizont - y) / ppd                        # Höhe über dem Horizont in Grad
+
+    sonne = math.pi + 0.66
+    dphi = np.angle(np.exp(1j * (phi - sonne))).astype(np.float32)[None, :]
+
+    # Himmel: Blau oben, hell am Horizont, warmer Abendschein um die Sonne
+    t = np.clip(grad / 75, 0, 1)[..., None]
+    himmel = np.where(t < 0.3, _mix((168, 202, 238), (66, 124, 210), t / 0.3), _mix((66, 124, 210), (16, 36, 96), (t - 0.3) / 0.7))
+    warm = (np.exp(-dphi ** 2 / 0.55) * np.exp(-(np.clip(grad, 0, None) / 14) ** 2))[..., None]
+    himmel = himmel * (1 - 0.8 * warm) + np.array([255, 178, 120], np.float32) * 0.8 * warm
+    bild = np.broadcast_to(himmel, (H, W, 3)).astype(np.float32).copy()
+
+    def maske_hoehe(h_grad):
+        return (grad >= 0) & (grad <= h_grad[None, :])
+
+    def stufen(h_grad):
+        return np.floor(h_grad * ppd / blk) * blk / ppd
+
+    # Sonne (eckig, wie im Spiel) mit Schein
+    s_x = (sonne - start) / spanne * W
+    s_y = horizont - 12 * ppd
+    s_r = 2.6 * ppd
+    rr = np.sqrt(((np.arange(W) - s_x) / ppd)[None, :] ** 2 + ((y - s_y) / ppd) ** 2)
+    bild += (np.exp(-(rr / 6) ** 2) * 0.55)[..., None] * np.array([255, 210, 150], np.float32)
+    quadrat = (np.abs(np.arange(W) - s_x)[None, :] < s_r) & (np.abs(y - s_y) < s_r)
+    bild[quadrat] = (255, 244, 205)
+
+    # Wolken (flach und blockig)
+    wolken = Image.new('RGBA', (W, H), (0, 0, 0, 0))
+    d = ImageDraw.Draw(wolken)
+    for _ in range(18):
+        p = rnd.uniform(0, 2 * math.pi)
+        for versatz in (-2 * math.pi, 0, 2 * math.pi):
+            cx = (p + versatz - start) / spanne * W
+            if -W * 0.2 < cx < W * 1.2:
+                break
+        else:
+            continue
+        cy = horizont - rnd.uniform(20, 42) * ppd
+        s = blk
+        nah_sonne = abs(math.atan2(math.sin(p - sonne), math.cos(p - sonne))) < 0.7
+        farbe = (255, 222, 196) if nah_sonne else (232, 240, 252)
+        for _ in range(rnd.randint(2, 4)):
+            w, h = rnd.randint(6, 16) * s, rnd.randint(1, 2) * s
+            ox, oy = rnd.randint(-4, 4) * s, rnd.randint(-1, 0) * s
+            d.rectangle((cx + ox, cy + oy, cx + ox + w, cy + oy + h), fill=farbe + (170,))
+            d.rectangle((cx + ox, cy + oy + h - max(2, s // 3), cx + ox + w, cy + oy + h), fill=tuple(int(c * 0.82) for c in farbe) + (170,))
+
+    # ferne Berge mit Schnee
+    h_fern = stufen(6 + 22 * _profil(phi, seed + 1, schritt))
+    m = maske_hoehe(h_fern)
+    tb = np.clip(grad / 28, 0, 1)[..., None]
+    fels = _mix((46, 66, 112), (96, 118, 168), tb)
+    schnee = (grad > h_fern[None, :] - 3 * blk / ppd) & (h_fern[None, :] > 15)
+    fels = np.where(schnee[..., None], np.array([236, 242, 255], np.float32), fels)
+    sonnenseite = (np.exp(-dphi ** 2 / 0.6))[..., None] * 0.35
+    fels = fels * (1 - sonnenseite) + np.array([255, 190, 150], np.float32) * sonnenseite
+    bild[m] = np.broadcast_to(fels, bild.shape)[m]
+    # bewaldete Hügel
+    h_huegel = stufen(2 + 7 * _profil(phi, seed + 2, schritt))
+    m = maske_hoehe(h_huegel)
+    huegel = _mix((26, 70, 58), (44, 98, 74), np.clip(grad / 7, 0, 1)[..., None])
+    bild[m] = np.broadcast_to(huegel, bild.shape)[m]
+
+    img = Image.fromarray(np.clip(bild, 0, 255).astype(np.uint8), 'RGB').convert('RGBA')
+    img.alpha_composite(wolken)
+    # Fichten am Ufer
+    wald = Image.new('RGBA', (W, H), (0, 0, 0, 0))
+    d = ImageDraw.Draw(wald)
+    s = max(3, blk // 2)
+    for _ in range(int(W / s * 0.55)):
+        x = rnd.randrange(W)
+        hoehe = rnd.randint(6, 13)
+        dunkel = rnd.choice(((14, 44, 34), (18, 52, 40), (12, 38, 32)))
+        d.rectangle((x - s // 2, horizont - 2 * s, x + s // 2, horizont), fill=(40, 28, 20, 255))
+        for stufe in range(hoehe):
+            breite = max(0, (hoehe - stufe) // 2 - (stufe % 2))
+            y0 = horizont - (stufe + 2) * s
+            d.rectangle((x - breite * s - s // 2, y0, x + breite * s + s // 2, y0 + s), fill=dunkel + (255,))
+            d.rectangle((x + breite * s - s // 2, y0, x + breite * s + s // 2, y0 + s), fill=tuple(c + 14 for c in dunkel) + (255,))
+    img.alpha_composite(wald)
+    bild = np.array(img.convert('RGB'), np.float32)
+
+    # See: Spiegelung, nach unten dunkler, Wellen und Sonnenglitzern
+    unten = H - horizont
+    zeilen = np.clip(horizont - 1 - np.arange(unten), 0, H - 1)
+    spiegel = bild[zeilen]
+    tiefe = np.linspace(0, 1, unten, dtype=np.float32)[:, None, None]
+    wellen = ((np.sin(np.arange(unten, dtype=np.float32)[:, None] * (0.55 / max(1, ppd / 10)) + np.sin(phi[None, :] * 37) * 1.6) > 0.86) * 14)[..., None]
+    see = spiegel * (0.62 - 0.32 * tiefe) + np.array([10, 30, 62], np.float32) * (0.45 + 0.55 * tiefe) + wellen * np.array([0.5, 0.8, 1.0], np.float32)
+    glitzer = (np.exp(-(dphi[0] / 0.07) ** 2)[None, :] * (np.sin(np.arange(unten)[:, None] * 1.7 + phi[None, :] * 900) > 0.6) * np.exp(-tiefe[..., 0] * 3))[..., None]
+    see += glitzer * np.array([255, 200, 140], np.float32) * 0.8
+    bild[horizont:] = see
+
+    # leuchtende Pixel (AeroMC)
+    img = Image.fromarray(np.clip(bild, 0, 255).astype(np.uint8), 'RGB').convert('RGBA')
+    pixel = Image.new('RGBA', (W, H), (0, 0, 0, 0))
+    d = ImageDraw.Draw(pixel)
+    for _ in range(int(W / 60)):
+        x = rnd.randrange(W)
+        yy = horizont - rnd.uniform(-8, 30) * ppd
+        g = rnd.choice((0.6, 0.8, 1.0, 1.3)) * ppd
+        d.rectangle((x, yy, x + g, yy + g), fill=(90, 210, 255, rnd.randint(150, 235)))
+    img.alpha_composite(leuchten(pixel, max(4, ppd * 0.8), (60, 170, 255), 1.0))
+    img.alpha_composite(pixel)
+    return img.convert('RGB')
+
+
+def landschaft(W=4096, H=2048):
+    """Rundum-Panorama (equirektangular): Spalte W/2 = Blick nach vorne."""
+    return szene(W, H, H // 2, 0.0, 2 * math.pi)
+
+
+def landschaft_flach(W=1920, H=1080):
+    """Ausschnitt nach vorne (ca. 110°) für den Ladebildschirm."""
+    spanne = math.radians(110)
+    return szene(W, H, int(H * 0.6), math.pi - spanne / 2, spanne)
+
+
+def wuerfelseiten(equi, groesse=1024):
+    """Equirektangulares Panorama -> 6 Würfelseiten (0 vorne, 1 rechts, 2 hinten, 3 links, 4 oben, 5 unten)."""
+    q = np.array(equi.convert('RGB'), float)
+    H, W = q.shape[:2]
+    a = (np.arange(groesse) + 0.5) / groesse * 2 - 1
+    u, v = np.meshgrid(a, a)
+    eins = np.ones_like(u)
+    richtungen = [(u, -v, eins), (eins, -v, -u), (-u, -v, -eins), (-eins, -v, u), (u, eins, v), (u, -eins, -v)]
+    seiten = []
+    for dx, dy, dz in richtungen:
+        lon = np.arctan2(dx, dz)
+        lat = np.arctan2(dy, np.sqrt(dx * dx + dz * dz))
+        x = (lon / (2 * math.pi) + 0.5) * W - 0.5
+        y = (0.5 - lat / math.pi) * H - 0.5
+        x0 = np.floor(x).astype(int); y0 = np.clip(np.floor(y).astype(int), 0, H - 2)
+        fx, fy = (x - x0)[..., None], np.clip(y - y0, 0, 1)[..., None]
+        x1 = (x0 + 1) % W; x0 %= W
+        p = (q[y0, x0] * (1 - fx) * (1 - fy) + q[y0, x1] * fx * (1 - fy) + q[y0 + 1, x0] * (1 - fx) * fy + q[y0 + 1, x1] * fx * fy)
+        seiten.append(Image.fromarray(np.clip(p, 0, 255).astype(np.uint8), 'RGB'))
+    return seiten
+
+
+def seiten_aus_bild(bild, g=1024):
+    """
+    Aus einem flachen Bild (16:9) einen nahtlosen Würfel:
+      – vorne = linke Bildhälfte, rechts = rechte Hälfte, hinten/links = dieselben
+        gespiegelt, so stoßen alle senkrechten Kanten passend aneinander;
+      – oben/unten: die vier Seiten werden in ein Rundum-Panorama umgerechnet, dort
+        nach unten (Wasser) bzw. oben (Himmel) gespiegelt fortgesetzt und weich
+        auslaufen gelassen, daraus dann die obere und untere Würfelseite gerechnet.
+        So gehen die Kanten nahtlos über – keine einfarbigen Flächen.
+    """
+    b = bild.convert('RGB').resize((2 * g, g), Image.LANCZOS)
+    vorne, rechts = b.crop((0, 0, g, g)), b.crop((g, 0, 2 * g, g))
+    hinten, links = rechts.transpose(Image.FLIP_LEFT_RIGHT), vorne.transpose(Image.FLIP_LEFT_RIGHT)
+    seiten = [np.array(s, np.float32) for s in (vorne, rechts, hinten, links)]
+
+    # 1) Seiten -> equirektangulares Panorama (oben/unten zunächst leer)
+    W, H = 4 * g, 2 * g
+    lon = ((np.arange(W) + 0.5) / W - 0.5) * 2 * math.pi
+    lat = (0.5 - (np.arange(H) + 0.5) / H) * math.pi
+    LON, LAT = np.meshgrid(lon, lat)
+    dx, dy, dz = np.cos(LAT) * np.sin(LON), np.sin(LAT), np.cos(LAT) * np.cos(LON)
+    equi = np.zeros((H, W, 3), np.float32)
+    gueltig = np.zeros((H, W), bool)
+    seitlich = np.abs(dy) < np.maximum(np.abs(dx), np.abs(dz))
+    # (Maske, s, u, v) passend zu wuerfelseiten(): vorne (u,-v,1), rechts (1,-v,-u), hinten (-u,-v,-1), links (-1,-v,u)
+    faelle = [
+        (seitlich & (dz >= np.abs(dx)), dz, dx, -dy),
+        (seitlich & (dx > np.abs(dz)), dx, -dz, -dy),
+        (seitlich & (-dz >= np.abs(dx)), -dz, -dx, -dy),
+        (seitlich & (-dx > np.abs(dz)), -dx, dz, -dy),
+    ]
+    for (maske, s, u, v), seite in zip(faelle, seiten):
+        su, sv = u[maske] / s[maske], v[maske] / s[maske]
+        px = np.clip(((su + 1) / 2 * g).astype(int), 0, g - 1)
+        py = np.clip(((sv + 1) / 2 * g).astype(int), 0, g - 1)
+        equi[maske] = seite[py, px]
+        gueltig |= maske
+
+    # 2) Lücken spiegeln: unten das Wasser (dunkler werdend), oben der Himmel
+    zeilen = np.arange(H)[:, None]
+    unterste = np.where(gueltig.any(0), H - 1 - np.argmax(gueltig[::-1], axis=0), H // 2)
+    oberste = np.where(gueltig.any(0), np.argmax(gueltig, axis=0), H // 2)
+    spalten = np.arange(W)[None, :]
+    unten = zeilen > unterste[None, :]
+    oben = zeilen < oberste[None, :]
+    quelle_unten = np.clip(2 * unterste[None, :] - zeilen, oberste[None, :], H - 1)
+    quelle_oben = np.broadcast_to(np.clip(oberste[None, :] + 2, 0, H - 1), (H, W))   # Himmel: oberste Zeile nach oben verlängern
+    gespiegelt = equi.copy()
+    gespiegelt[unten] = equi[quelle_unten, np.broadcast_to(spalten, (H, W))][unten]
+    gespiegelt[oben] = equi[quelle_oben, np.broadcast_to(spalten, (H, W))][oben]
+    # zum Pol hin weich in eine ruhige Farbe auslaufen lassen (keine Kreuznaht im Würfel)
+    abstand_unten = np.clip((zeilen - unterste[None, :]) / (H * 0.34), 0, 1)[..., None] ** 1.3
+    abstand_oben = np.clip((oberste[None, :] - zeilen) / (H * 0.34), 0, 1)[..., None] ** 1.3
+    # Wasserfarbe aus der Bildmitte (am unteren Rand stehen Pflanzen), Himmel vom oberen Rand
+    roh = np.array(b, np.float32)
+    wasser = np.median(roh[int(g * 0.62):int(g * 0.82), int(g * 0.5):int(g * 1.5)].reshape(-1, 3), axis=0)
+    himmel = equi[np.clip(oberste + 4, 0, H - 1), np.arange(W)].mean(0)
+    gespiegelt = np.where(unten[..., None], gespiegelt * (1 - abstand_unten) * 0.9 + wasser * 0.8 * abstand_unten, gespiegelt)
+    gespiegelt = np.where(oben[..., None], gespiegelt * (1 - abstand_oben) + himmel * abstand_oben, gespiegelt)
+    bild_equi = Image.fromarray(np.clip(gespiegelt, 0, 255).astype(np.uint8), 'RGB')
+    weich = bild_equi.filter(ImageFilter.GaussianBlur(16))
+    maske_luecke = Image.fromarray(((unten | oben) * 255).astype(np.uint8)).filter(ImageFilter.GaussianBlur(6))
+    bild_equi = Image.composite(weich, bild_equi, maske_luecke)
+
+    # 3) daraus oben/unten; die vier Seiten bleiben die scharfen Originale
+    neu = wuerfelseiten(bild_equi, g)
+    return [vorne, rechts, hinten, links, neu[4], neu[5]]
+
+
+def quelle(name):
+    for endung in ('png', 'jpg', 'jpeg', 'webp'):
+        p = os.path.join(QUELLE, f'{name}.{endung}')
+        if os.path.exists(p):
+            return Image.open(p).convert('RGB')
+    return None
+
+
+def fuellen(bild, w, h):
+    f = max(w / bild.width, h / bild.height)
+    b = bild.resize((int(bild.width * f + 0.5), int(bild.height * f + 0.5)), Image.LANCZOS)
+    x, y = (b.width - w) // 2, (b.height - h) // 2
+    return b.crop((x, y, x + w, y + h))
+
+
+# ---------- Ladebildschirm (Vollbild) ----------
+
+def ladebild(mit_text=True):
+    W, H = 1920, 1080
+    eigenes = quelle('hintergrund')
+    if eigenes is not None:
+        grund = fuellen(eigenes, W, H)
+    else:  # gleiche Landschaft wie im Menü, als Blick nach vorne
+        grund = landschaft_flach(W, H)
+    bild = grund.convert('RGBA')
+    # leichte Abdunklung zur Mitte und unten, damit Logo und Balken lesbar sind
+    schatten = Image.new('L', (W, H), 0)
+    ImageDraw.Draw(schatten).ellipse((W * 0.18, H * 0.12, W * 0.82, H * 0.72), fill=95)
+    schatten = schatten.filter(ImageFilter.GaussianBlur(120))
+    unten = Image.fromarray((np.clip((np.arange(H) - H * 0.62) / (H * 0.38), 0, 1) * 120).astype(np.uint8)[:, None].repeat(W, 1))
+    dunkel = Image.new('RGBA', (W, H), (4, 8, 20, 0))
+    dunkel.putalpha(ImageChops.lighter(schatten, unten))
+    bild.alpha_composite(dunkel)
+    art, _ = logo(30)
+    art = einpassen(art, int(W * 0.62), int(H * 0.56))
+    lx, ly = (W - art.width) // 2, int(H * 0.40 - art.height / 2)
+    bild.alpha_composite(art, (lx, ly))
+    unter, _ = untertitel_bild(6)
+    bild.alpha_composite(unter, ((W - unter.width) // 2, ly + art.height + 6))
+    if not mit_text:   # Neustart-Bildschirm des Launchers setzt Text und Balken selbst darüber
+        return bild.convert('RGB')
+    # "Wird geladen …" unter dem Balken (Minecraft zeichnet den Balken bei 83,25 % der Höhe)
+    schrift = ImageFont.truetype(SCHRIFT, 34)
+    text = 'Wird geladen …'
+    tb = ImageDraw.Draw(bild).textbbox((0, 0), text, font=schrift)
+    tw, th = tb[2] - tb[0], tb[3] - tb[1]
+    kasten = Image.new('RGBA', (W, H), (0, 0, 0, 0))
+    kx, ky = (W - tw) // 2, int(H * 0.885)
+    ImageDraw.Draw(kasten).rounded_rectangle((kx - 26, ky - 14, kx + tw + 26, ky + th + 22), radius=10, fill=(6, 12, 28, 175))
+    bild.alpha_composite(kasten)
+    ImageDraw.Draw(bild).text((kx - tb[0], ky - tb[1] + 2), text, font=schrift, fill=(236, 244, 255, 255))
+    return bild.convert('RGB')
+
+
+def als_logotextur(bild):
+    """
+    Minecraft zeichnet das Logo additiv auf den Hintergrund und teilt es: linke
+    Hälfte aus der oberen Texturhälfte, rechte aus der unteren. Darum: Nachtblau
+    abziehen (wird beim Zeichnen wieder addiert) und die Hälften gestreckt stapeln.
+    """
+    a = np.clip(np.array(bild, float) - np.array(NACHTBLAU, float), 0, 255).astype(np.uint8)
+    b = Image.fromarray(a, 'RGB')
+    w, h = b.size
+    t = Image.new('RGB', (2048, 2048))
+    t.paste(b.crop((0, 0, w // 2, h)).resize((2048, 1024), Image.LANCZOS), (0, 0))
+    t.paste(b.crop((w // 2, 0, w, h)).resize((2048, 1024), Image.LANCZOS), (0, 1024))
+    return t.convert('RGBA')
+
+
+# ---------- Knöpfe und Symbole (wie im Entwurf) ----------
+
+SYMBOL_ZEICHEN = ['', '', '', '', '', '']   # Spitzhacke, Personen, Globus, Zahnrad, Ein/Aus, Puzzle (Mods)
+
+
+def knopf(hell, f):
+    """Knopf 200×20 Punkte in f-facher Auflösung: dunkles Schiefer bzw. leuchtendes Blau."""
+    w, h = 200 * f, 20 * f
+    if hell:
+        oben, unten, rand, licht = (64, 166, 248), (20, 92, 200), (130, 232, 255), (170, 225, 255)
+    else:
+        oben, unten, rand, licht = (46, 56, 74), (24, 30, 42), (124, 142, 172), (78, 92, 118)
+    a = verlauf(h, w, oben, unten)
+    bild = rgba(a, np.full((h, w), 255, np.uint8))
+    d = ImageDraw.Draw(bild)
+    s = max(1, f // 2)
+    d.rectangle((0, 0, w - 1, h - 1), outline=(6, 10, 20, 255), width=s)            # dunkle Außenkante
+    d.rectangle((s, s, w - 1 - s, h - 1 - s), outline=rand + (255,), width=s)          # heller Rand
+    d.line((2 * s, 2 * s, w - 1 - 2 * s, 2 * s), fill=licht + (255,), width=s)       # Lichtkante oben
+    for x0, y0 in ((0, 0), (w - s, 0), (0, h - s), (w - s, h - s)):                   # Ecken leicht abgerundet
+        d.rectangle((x0, y0, x0 + s - 1, y0 + s - 1), fill=(0, 0, 0, 0))
+    return bild
+
+
+def puzzle(farbe=(238, 246, 255, 255), groesse=64):
+    """Puzzleteil (Symbol für Mods)."""
+    b = Image.new('RGBA', (64, 64), (0, 0, 0, 0))
+    d = ImageDraw.Draw(b)
+    d.rounded_rectangle((8, 18, 46, 56), radius=5, fill=farbe)
+    d.ellipse((19, 4, 35, 22), fill=farbe)          # Nase oben
+    d.ellipse((42, 29, 60, 45), fill=farbe)         # Nase rechts
+    d.ellipse((4, 29, 18, 43), fill=(0, 0, 0, 0))   # Kerbe links
+    return b if groesse == 64 else b.resize((groesse, groesse), Image.LANCZOS)
+
+
+def symbole():
+    """6 Symbole, je 16×16 (aus 64×64 verkleinert), weiß – als Schriftzeichen."""
+    groesse, f = 64, 4
+    leinwand = Image.new('RGBA', (16 * 6, 16), (0, 0, 0, 0))
+    farbe = (238, 246, 255, 255)
+
+    def neu():
+        return Image.new('RGBA', (groesse, groesse), (0, 0, 0, 0))
+
+    bilder = []
+    b = neu(); d = ImageDraw.Draw(b)                                   # Spitzhacke: aufrecht zeichnen, dann kippen
+    d.line((32, 16, 32, 62), fill=farbe, width=10)
+    d.arc((2, 12, 62, 56), 198, 342, fill=farbe, width=12)
+    d.polygon([(4, 30), (0, 40), (10, 34)], fill=farbe); d.polygon([(60, 30), (64, 40), (54, 34)], fill=farbe)
+    bilder.append(b.rotate(-40, resample=Image.BICUBIC))
+    b = neu(); d = ImageDraw.Draw(b)                                   # zwei Personen
+    d.ellipse((30, 8, 50, 28), fill=farbe); d.pieslice((22, 30, 58, 70), 180, 360, fill=farbe)
+    d.ellipse((10, 14, 28, 32), fill=farbe); d.pieslice((2, 34, 36, 68), 180, 360, fill=farbe)
+    bilder.append(b)
+    b = neu(); d = ImageDraw.Draw(b)                                   # Globus
+    d.ellipse((4, 4, 60, 60), outline=farbe, width=8)
+    d.ellipse((20, 4, 44, 60), outline=farbe, width=7)
+    d.line((4, 32, 60, 32), fill=farbe, width=7)
+    d.arc((10, -10, 54, 26), 30, 150, fill=farbe, width=3); d.arc((10, 38, 54, 74), 210, 330, fill=farbe, width=3)
+    bilder.append(b)
+    b = neu(); d = ImageDraw.Draw(b)                                   # Zahnrad
+    for k in range(8):
+        w = k * math.pi / 4
+        cx, cy = 32 + math.cos(w) * 23, 32 + math.sin(w) * 23
+        pts = [(cx + math.cos(w + p) * 7, cy + math.sin(w + p) * 7) for p in (0.8, 2.35, 3.9, 5.5)]
+        d.polygon(pts, fill=farbe)
+    d.ellipse((12, 12, 52, 52), fill=farbe)
+    d.ellipse((26, 26, 38, 38), fill=(0, 0, 0, 0))
+    bilder.append(b)
+    b = neu(); d = ImageDraw.Draw(b)                                   # Ein/Aus
+    d.arc((6, 8, 58, 60), -60, 240, fill=farbe, width=10)
+    d.line((32, 2, 32, 30), fill=farbe, width=10)
+    bilder.append(b)
+    bilder.append(puzzle(farbe))
+    for i, b in enumerate(bilder):
+        leinwand.alpha_composite(b.resize((16, 16), Image.LANCZOS), (16 * i, 0))
+    return leinwand
+
+
+def sprachdateien():
+    """Symbole vor die Beschriftungen der Menüknöpfe setzen (de_de und en_us)."""
+    import json
+    sp, mp, rl, op, qu, md = SYMBOL_ZEICHEN
+    texte = {
+        'de_de': {'menu.singleplayer': 'Einzelspieler', 'menu.multiplayer': 'Mehrspieler', 'menu.online': 'Minecraft Realms',
+                  'menu.options': 'Optionen …', 'menu.quit': 'Spiel beenden'},
+        'en_us': {'menu.singleplayer': 'Singleplayer', 'menu.multiplayer': 'Multiplayer', 'menu.online': 'Minecraft Realms',
+                  'menu.options': 'Options...', 'menu.quit': 'Quit Game'},
+    }
+    zeichen = {'menu.singleplayer': sp, 'menu.multiplayer': mp, 'menu.online': rl, 'menu.options': op, 'menu.quit': qu}
+    aus = {}
+    for sprache, t in texte.items():
+        aus[sprache] = json.dumps({k: zeichen[k] + '  ' + v for k, v in t.items()}, ensure_ascii=True, indent=2)
+    mods = {
+        'de_de': {'menu.sendFeedback': md + '  Mods verwalten …', 'menu.feedback': md + '  Mods & Feedback …'},
+        'en_us': {'menu.sendFeedback': md + '  Manage Mods...', 'menu.feedback': md + '  Mods & Feedback...'},
+    }
+    for sprache, t in mods.items():
+        aus['mods_' + sprache] = json.dumps(t, ensure_ascii=True, indent=2)
+    schrift = json.dumps({'providers': [{'type': 'bitmap', 'file': 'aeromc:font/symbole.png', 'ascent': 7, 'height': 8,
+                                         'chars': [''.join(SYMBOL_ZEICHEN)]}]}, ensure_ascii=True, indent=2)
+    return aus, schrift
+
+
+def knopf_dateien():
+    import json
+    knopf(False, 2).save(os.path.join(ZIEL, 'knopf.png'))
+    knopf(True, 2).save(os.path.join(ZIEL, 'knopf_hell.png'))
+    knopf(False, 4).save(os.path.join(ZIEL, 'knopf_4x.png'))
+    knopf(True, 4).save(os.path.join(ZIEL, 'knopf_hell_4x.png'))
+    meta = json.dumps({'gui': {'scaling': {'type': 'nine_slice', 'width': 200, 'height': 20, 'border': 3}}}, indent=2)
+    with open(os.path.join(ZIEL, 'knopf.png.mcmeta'), 'w', encoding='utf-8') as f:
+        f.write(meta)
+    symbole().save(os.path.join(ZIEL, 'symbole.png'))
+    puzzle(groesse=40).save(os.path.join(ZIEL, 'mods_knopf.png'))   # Symbol-Knopf im Pausemenü (26.x)
+    sprachen, schrift = sprachdateien()
+    for sprache, text in sprachen.items():
+        with open(os.path.join(ZIEL, f'lang_{sprache}.json'), 'w', encoding='utf-8') as f:
+            f.write(text)
+    with open(os.path.join(ZIEL, 'font_default.json'), 'w', encoding='utf-8') as f:
+        f.write(schrift)
+
+
+def main():
+    os.makedirs(ZIEL, exist_ok=True)
+    titel(False).save(os.path.join(ZIEL, 'titel_neu.png'))
+    titel(True).save(os.path.join(ZIEL, 'titel_alt.png'))
+    # Der Untertitel steckt jetzt im Titel-Logo – edition.png bleibt leer
+    leer = Image.new('RGBA', (512, 64), (0, 0, 0, 0))
+    leer.save(os.path.join(ZIEL, 'edition_neu.png'))
+    leer.save(os.path.join(ZIEL, 'edition_alt.png'))
+
+    equi, flach = quelle('panorama'), quelle('hintergrund')
+    if equi is not None:
+        seiten = wuerfelseiten(equi)          # echtes Rundum-Panorama
+    elif flach is not None:
+        seiten = seiten_aus_bild(flach)       # flaches Bild, nahtlos gespiegelt
+    else:
+        seiten = wuerfelseiten(landschaft())  # gezeichnete Block-Landschaft
+    for i, s in enumerate(seiten):
+        s.save(os.path.join(ZIEL, f'panorama_{i}.png'), optimize=True)
+
+    lade = ladebild()
+    lade.save(os.path.join(QUELLE if os.path.isdir(QUELLE) else ZIEL, '_vorschau_ladebildschirm.png'))
+    als_logotextur(lade).save(os.path.join(ZIEL, 'ladelogo.png'), optimize=True)
+    # derselbe Ladebildschirm ohne Text – für den Neustart über den Mod-Schalter
+    ladebild(mit_text=False).save(os.path.join(ZIEL, 'neustart.jpg'), quality=88)
+
+    # 1.14/1.15: festes 256×256-Feld in der Mitte, Logo auf durchsichtigem Grund
+    alt = Image.new('RGBA', (1024, 1024), (0, 0, 0, 0))
+    art, _ = logo(26)
+    art = einpassen(art, 980, 600)
+    alt.alpha_composite(art, ((1024 - art.width) // 2, (1024 - art.height) // 2))
+    alt.save(os.path.join(ZIEL, 'ladelogo_alt.png'))
+
+    knopf_dateien()
+
+    symbol = Image.open(LOGO).convert('RGBA')
+    symbol.resize((128, 128), Image.LANCZOS).save(os.path.join(ZIEL, 'pack.png'))
+    for n in (16, 32, 48, 64, 128, 256):
+        with open(os.path.join(ZIEL, f'icon_{n}.rgba'), 'wb') as f:
+            f.write(symbol.resize((n, n), Image.LANCZOS).tobytes())
+    print('Fertig:', ZIEL, '| Hintergrund:', 'eigenes Bild' if quelle('hintergrund') else 'Panorama-Ausschnitt',
+          '| Panorama:', 'eigenes Panorama' if quelle('panorama') else ('aus dem Hintergrundbild' if quelle('hintergrund') else 'Block-Landschaft'))
+
+
+if __name__ == '__main__':
+    main()

scripts/pruefe-version.js

@@ -0,0 +1,54 @@
+'use strict';
+
+/*
+ * pruefe-version.js – läuft vor jedem Build (prebuild)
+ * ----------------------------------------------------
+ * Bricht ab, wenn die Version aus package.json schon als Release in Gitea
+ * veröffentlicht ist. Ein neuer Build derselben Version ergäbe andere Dateien
+ * mit neuer Signatur – die bereits veröffentlichten EXEs würden dann nicht mehr
+ * dazu passen und kein Launcher nähme das Update an.
+ *
+ * Außerdem sagt es, wie das Release in Gitea heißen muss:
+ *
+ *   fertige Version  1.2.4          Tag  1.2.4
+ *   Vorabfassung     1.2.4-beta.1   Tag  0.0.0-1.2.4-beta.1  + Haken "Pre-Release"
+ *
+ * Der Vorsatz "0.0.0-" bei Vorabfassungen ist Pflicht: Launcher bis 1.2.3 kennen
+ * das Pre-Release-Feld nicht und würden "1.2.4-beta.1" als normales Update an
+ * ALLE Nutzer verteilen (siehe src/updater.js).
+ *
+ * Ausnahme (z. B. Testbuild, der nie hochgeladen wird): AEROMC_GLEICHE_VERSION=1
+ */
+
+const path = require('path');
+
+const API = 'https://git.viper.ipv64.net/api/v1/repos/M_Viper/AeroMc-Launcher/releases?limit=50';
+const version = require(path.join(__dirname, '..', 'package.json')).version;
+const vorab = /^\d+(?:\.\d+){0,2}-/.test(version);
+const tag = vorab ? `0.0.0-${version}` : version;
+
+(async () => {
+  if (process.env.AEROMC_GLEICHE_VERSION !== '1') {
+    try {
+      const res = await fetch(API, { headers: { 'User-Agent': 'AeroMC-Release', Accept: 'application/json' } });
+      if (!res.ok) throw new Error('HTTP ' + res.status);
+      const norm = (v) => String(v || '').trim().replace(/^v/i, '').replace(/^0\.0\.0-(?=\d)/, '');
+      const treffer = (await res.json() || []).find((r) => !r.draft && norm(r.tag_name) === version);
+      if (treffer) {
+        console.error(`\n✖ Version ${version} ist bereits in Gitea veröffentlicht (Tag ${treffer.tag_name}, ${treffer.published_at}).`);
+        console.error('  Bitte zuerst die Versionsnummer in package.json erhöhen – sonst passen die');
+        console.error('  veröffentlichten Dateien nicht mehr zur Signatur.');
+        process.exit(1);
+      }
+    } catch (err) {
+      console.warn(`\n! Gitea nicht erreichbar (${err.message}) – Versionsprüfung übersprungen.`);
+    }
+  }
+  console.log(`» Version ${version} ist noch nicht veröffentlicht – Build läuft.`);
+  if (vorab) {
+    console.log(`  VORABFASSUNG – in Gitea so veröffentlichen:  Tag  ${tag}   und Haken bei "Als Pre-Release kennzeichnen".`);
+    console.log('  Niemals mit dem Tag der reinen Versionsnummer: Ältere Launcher würden die Beta sonst an alle verteilen.');
+  } else {
+    console.log(`  In Gitea veröffentlichen mit dem Tag  ${tag}  (ohne Pre-Release-Haken).`);
+  }
+})();

scripts/sign-release.js

@@ -0,0 +1,248 @@
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const crypto = require('crypto');
+const readline = require('readline');
+const { execFileSync } = require('child_process');
+const { signaturText, pruefeSignatur, holeSignatur, SIGNATUR_API } = require('../src/updater');
+
+const ROOT = path.join(__dirname, '..');
+const DIST = path.join(ROOT, 'dist');
+const ORDNER = path.join(os.homedir(), '.aeromc-release');
+const OEFFENTLICH = path.join(ROOT, 'src', 'update-schluessel.pem');
+const PRIVAT = process.env.AEROMC_SIGN_KEY || path.join(ORDNER, 'release-key.pem');
+const ZUGANG = path.join(ORDNER, 'wordpress.json');
+const DATEIEN = { setup: 'AeroMC-Setup.exe', portable: 'AeroMC-Portable.exe' };
+const WP_STANDARD = new URL(SIGNATUR_API).origin;
+
+// ---------------------------------------------------------------------------
+// Schlüssel
+// ---------------------------------------------------------------------------
+
+function schluesselAnlegen() {
+  if (fs.existsSync(PRIVAT)) {
+    console.log(`Es gibt bereits einen Release-Schlüssel: ${PRIVAT}`);
+    console.log('Er wird nicht überschrieben – sonst nähmen bestehende Launcher keine Updates mehr an.');
+    return;
+  }
+  const { publicKey, privateKey } = crypto.generateKeyPairSync('ed25519');
+  fs.mkdirSync(path.dirname(PRIVAT), { recursive: true });
+  fs.writeFileSync(PRIVAT, privateKey.export({ type: 'pkcs8', format: 'pem' }), { mode: 0o600 });
+  fs.writeFileSync(OEFFENTLICH, publicKey.export({ type: 'spki', format: 'pem' }));
+  console.log(`Privater Schlüssel: ${PRIVAT}   (SICHERN, niemals weitergeben!)`);
+  console.log(`Öffentlicher Schlüssel: ${OEFFENTLICH}   (wird in den Launcher eingebaut)`);
+}
+
+
+function dpapi(skript, eingabe) {
+  return execFileSync('powershell.exe', ['-NoProfile', '-NonInteractive', '-Command', skript],
+    { input: eingabe, encoding: 'utf8', windowsHide: true }).trim();
+}
+function verschluesseln(text) {
+  return dpapi('$t = [Console]::In.ReadToEnd(); ConvertTo-SecureString $t -AsPlainText -Force | ConvertFrom-SecureString', text);
+}
+function entschluesseln(hex) {
+  return dpapi('$h = [Console]::In.ReadToEnd().Trim(); $s = ConvertTo-SecureString $h; '
+    + '[Runtime.InteropServices.Marshal]::PtrToStringBSTR([Runtime.InteropServices.Marshal]::SecureStringToBSTR($s))', hex);
+}
+
+function frage(text, verdeckt) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout, terminal: true });
+    if (verdeckt) {
+      rl._writeToOutput = (s) => { if (s.includes(text)) process.stdout.write(text); else if (s === '\r\n' || s === '\n') process.stdout.write(s); };
+    }
+    rl.question(text, (antwort) => { rl.close(); if (verdeckt) process.stdout.write('\n'); resolve(antwort.trim()); });
+  });
+}
+
+function ladeZugang() {
+  if (!fs.existsSync(ZUGANG)) return null;
+  const z = JSON.parse(fs.readFileSync(ZUGANG, 'utf8').replace(/^/, '')); 
+  return { seite: z.seite, benutzer: z.benutzer, passwort: entschluesseln(z.passwort) };
+}
+
+/*
+ * Anfrage MIT Zugangsdaten an die WordPress-Seite.
+ * Weiterleitungen werden nie verfolgt: Sonst gingen die Kopfzeilen – vor allem
+ * der eigene X-AeroMC-Auth, den fetch bei einem Wechsel der Domain nicht von
+ * selbst entfernt – samt Anwendungspasswort an das Ziel der Weiterleitung.
+ * Gesendet wird außerdem nur über HTTPS und nur an die hinterlegte Seite.
+ */
+async function wordpressAnfrage(zugang, pfad, optionen) {
+  let ziel;
+  try { ziel = new URL(zugang.seite + pfad); } catch { throw new Error('Die hinterlegte WordPress-Adresse ist ungültig.'); }
+  if (ziel.protocol !== 'https:') throw new Error('Zugangsdaten werden nur über HTTPS gesendet – WordPress-Adresse prüfen.');
+  const res = await fetch(ziel, Object.assign({}, optionen, { headers: kopfzeilen(zugang), redirect: 'manual' }));
+  if (res.status >= 300 && res.status < 400) {
+    const wohin = res.headers.get('location') || 'unbekannt';
+    throw new Error(`Die Seite leitet weiter (HTTP ${res.status} → ${wohin}). Die Zugangsdaten wurden NICHT dorthin gesendet.
+`
+      + '  Bitte die genaue Adresse eintragen:  node scripts/sign-release.js wordpress');
+  }
+  return res;
+}
+
+function kopfzeilen(zugang) {
+  const daten = Buffer.from(`${zugang.benutzer}:${zugang.passwort}`).toString('base64');
+  return {
+    Authorization: 'Basic ' + daten,
+    // Ersatz für Server, die "Authorization" nicht an PHP weitergeben (siehe signaturen.php)
+    'X-AeroMC-Auth': daten,
+    'Content-Type': 'application/json',
+    'User-Agent': 'AeroMC-Release',
+  };
+}
+
+// Übersetzt die Diagnose des Plugins (ab 1.5.4) in eine klare Meldung
+function zugangsFehler(d, benutzer) {
+  if (!d || !d.version) {
+    return 'Das Plugin auf der Seite ist zu alt – bitte "AeroMC Freunde" 1.5.4 oder neuer installieren.';
+  }
+  if (!d.anwendungspasswoerter) return 'Anwendungspasswörter sind auf der Seite abgeschaltet (z. B. durch ein Sicherheits-Plugin).';
+  if (!d.authorization_kommt_an && !d.eigener_kopf_kommt_an) {
+    return 'Der Server leitet keine Anmeldedaten an WordPress weiter (beide Header fehlen) – das muss der Hoster freigeben.';
+  }
+  switch (d.grund) {
+    case 'invalid_username': return `Den Benutzer "${benutzer}" gibt es nicht (Benutzername, nicht E-Mail-Adresse).`;
+    case 'incorrect_password':
+      return 'Falsches Anwendungspasswort. Achtung: Gemeint ist NICHT das Login-Passwort, sondern das unter '
+        + 'Benutzer → Profil → "Anwendungspasswörter" erzeugte (Form "abcd efgh ijkl …").';
+    case 'application_passwords_disabled':
+    case 'application_passwords_disabled_for_user':
+      return `Für "${benutzer}" sind Anwendungspasswörter abgeschaltet.`;
+    default: break;
+  }
+  if (d.benutzer && !d.darf_hochladen) {
+    return `Anmeldung als "${d.benutzer}" klappt, aber der Benutzer hat nicht die Rolle "AeroMC Release" (Benutzer bearbeiten → Rolle).`;
+  }
+  return 'Anmeldung abgelehnt' + (d.grund ? ` (${d.grund})` : '') + '.';
+}
+
+async function pruefeZugang(zugang) {
+  const res = await wordpressAnfrage(zugang, '/wp-json/aeromc/v1/update-signatur/zugang', {});
+  if (res.status === 404) throw new Error('Die Seite kennt die Signatur-Schnittstelle nicht – ist das Plugin "AeroMC Freunde" (ab 1.5.4) installiert und aktiviert?');
+  let d = null;
+  try { d = await res.json(); } catch { /* keine JSON-Antwort */ }
+  if (res.ok && d && d.ok) return d;
+  if (res.status === 401 || res.status === 403) throw new Error(zugangsFehler(d, zugang.benutzer));
+  throw new Error('WordPress antwortet mit HTTP ' + res.status);
+}
+
+async function wordpressEinrichten() {
+  console.log('WordPress-Zugang für das automatische Hochladen der Signaturen einrichten.');
+  console.log('Vorher in WordPress: Benutzer mit der Rolle "AeroMC Release" anlegen, dann in dessen Profil');
+  console.log('unter "Anwendungspasswörter" ein Passwort erzeugen (Name z. B. "AeroMC Build").\n');
+  const seite = (await frage(`Adresse der WordPress-Seite [${WP_STANDARD}]: `)) || WP_STANDARD;
+  if (!/^https:\/\//i.test(seite)) throw new Error('Bitte eine https://-Adresse angeben.');
+  const benutzer = await frage('WordPress-Benutzername: ');
+  const passwort = await frage('Anwendungspasswort (Eingabe bleibt unsichtbar): ', true);
+  if (!benutzer || !passwort) throw new Error('Benutzername und Passwort werden gebraucht.');
+  const zugang = { seite: seite.replace(/\/+$/, ''), benutzer, passwort };
+  const antwort = await pruefeZugang(zugang);
+  fs.mkdirSync(ORDNER, { recursive: true });
+  fs.writeFileSync(ZUGANG, JSON.stringify({ seite: zugang.seite, benutzer, passwort: verschluesseln(passwort) }, null, 2), { mode: 0o600 });
+  console.log(`\n✔ Zugang geprüft (angemeldet als ${antwort.benutzer}) und gespeichert: ${ZUGANG}`);
+  console.log('  Das Passwort ist mit Windows-DPAPI verschlüsselt.');
+}
+
+
+
+function sha256(datei) {
+  const h = crypto.createHash('sha256');
+  const fd = fs.openSync(datei, 'r');
+  const buf = Buffer.alloc(4 * 1024 * 1024);
+  let n;
+  while ((n = fs.readSync(fd, buf, 0, buf.length, null)) > 0) h.update(buf.subarray(0, n));
+  fs.closeSync(fd);
+  return h.digest('hex');
+}
+
+function signieren(art) {
+  const name = DATEIEN[art];
+  if (!name) throw new Error(`Unbekannte Art "${art}" – erwartet: setup, portable, schluessel, wordpress oder hochladen.`);
+  const datei = path.join(DIST, name);
+  if (!fs.existsSync(datei)) throw new Error(`${datei} fehlt – erst bauen.`);
+  if (!fs.existsSync(PRIVAT)) {
+    throw new Error(`Kein Release-Schlüssel unter ${PRIVAT}. Einmalig "node scripts/sign-release.js schluessel" ausführen.`);
+  }
+  const privat = crypto.createPrivateKey(fs.readFileSync(PRIVAT, 'utf8'));
+
+  const eingebaut = crypto.createPublicKey(fs.readFileSync(OEFFENTLICH, 'utf8')).export({ type: 'spki', format: 'der' });
+  const passend = crypto.createPublicKey(privat).export({ type: 'spki', format: 'der' });
+  if (!eingebaut.equals(passend)) {
+    throw new Error('Der private Schlüssel passt nicht zu src/update-schluessel.pem – Signatur wäre für den Launcher wertlos.');
+  }
+
+  const version = require(path.join(ROOT, 'package.json')).version;
+  const hash = sha256(datei);
+  const sig = {
+    format: 'AeroMC-Update/1',
+    datei: name,
+    version,
+    sha256: hash,
+    signatur: crypto.sign(null, signaturText(name, version, hash), privat).toString('base64'),
+  };
+  pruefeSignatur(sig, name, version, hash);   
+  fs.writeFileSync(datei + '.sig', JSON.stringify(sig, null, 2) + '\n');
+  console.log(`\n» ${name} ${version} signiert`);
+  return sig;
+}
+
+async function hochladen(sig) {
+  const zugang = ladeZugang();
+  if (!zugang) {
+    throw new Error('Kein WordPress-Zugang eingerichtet – Signatur NICHT hochgeladen.\n'
+      + '  Einmalig ausführen:  node scripts/sign-release.js wordpress\n'
+      + `  danach:              node scripts/sign-release.js hochladen ${sig.datei === DATEIEN.setup ? 'setup' : 'portable'}`);
+  }
+  // Nie die Signatur einer schon veröffentlichten Datei überschreiben: Dann passte
+  // die EXE im Gitea-Release nicht mehr, und kein Launcher nähme das Update an.
+  const vorhanden = await holeSignatur(sig.datei, sig.version);
+  if (vorhanden && vorhanden.sha256 !== sig.sha256 && process.env.AEROMC_SIG_ERSETZEN !== '1') {
+    throw new Error(`Für ${sig.datei} ${sig.version} liegt schon eine andere Signatur auf WordPress – `
+      + 'diese Version ist vermutlich bereits veröffentlicht. Bitte die Versionsnummer in package.json erhöhen.\n'
+      + '  (Nur wenn die Version sicher NICHT veröffentlicht ist: AEROMC_SIG_ERSETZEN=1 setzen.)');
+  }
+  if (vorhanden && vorhanden.sha256 === sig.sha256) {
+    console.log('» Signatur liegt bereits unverändert auf WordPress.');
+    return;
+  }
+  const res = await wordpressAnfrage(zugang, '/wp-json/aeromc/v1/update-signatur', {
+    method: 'POST', body: JSON.stringify(sig),
+  });
+  let antwort = {};
+  try { antwort = await res.json(); } catch { /* leer */ }
+  if (!res.ok || !antwort.ok) {
+    throw new Error(`Hochladen fehlgeschlagen (HTTP ${res.status}): ${antwort.message || 'unbekannter Fehler'}`);
+  }
+  // Gegenprobe: liefert die öffentliche Schnittstelle genau das, was der Launcher braucht?
+  const zurueck = await holeSignatur(sig.datei, sig.version);
+  if (!zurueck || zurueck.signatur !== sig.signatur || zurueck.sha256 !== sig.sha256) {
+    throw new Error('Signatur wurde hochgeladen, die Seite liefert aber etwas anderes zurück (Cache?).');
+  }
+  console.log(`» Signatur auf ${zugang.seite} hochgeladen und geprüft${antwort.geprueft ? ' (vom Server gegengeprüft)' : ''} – ins Gitea-Release kommt nur die EXE.`);
+}
+
+async function main() {
+  const [art, zusatz] = process.argv.slice(2);
+  if (art === 'schluessel') return schluesselAnlegen();
+  if (art === 'wordpress') return wordpressEinrichten();
+  if (art === 'hochladen') {
+    const name = DATEIEN[zusatz];
+    if (!name) throw new Error('Erwartet: hochladen setup|portable');
+    const sigDatei = path.join(DIST, name + '.sig');
+    if (!fs.existsSync(sigDatei)) throw new Error(`${sigDatei} fehlt – erst bauen und signieren.`);
+    const sig = JSON.parse(fs.readFileSync(sigDatei, 'utf8'));
+    pruefeSignatur(sig, name, sig.version, sha256(path.join(DIST, name)));   
+    return hochladen(sig);
+  }
+  return hochladen(signieren(art));
+}
+
+main().catch((err) => {
+  console.error('\n✖ ' + err.message);
+  process.exit(1);
+});

server/curseforge-proxy/.env.example

@@ -19,9 +19,14 @@ HOST=0.0.0.0
 # weiterlaufen, bis alle das Update haben – danach das alte streichen.
 #   CF_PROXY_TOKEN=neues-token,altes-token
 #
-# Leer lassen = keine Tokenprüfung.
+# Pflicht: Ohne Token startet der Dienst nicht – sonst könnte jeder, der die
+# Adresse kennt, deinen API-Key und dein Download-Kontingent benutzen.
+# Ein langes Zufalls-Token erzeugen, z. B.:  openssl rand -hex 32
 CF_PROXY_TOKEN=
 
+# Nur für ein abgeschottetes Netz: Dienst bewusst OHNE Token betreiben.
+# CF_PROXY_OFFEN=1
+
 # Anfragen je Minute und Absender. 0 = keine Begrenzung.
 RATE_LIMIT_PER_MIN=60
 

server/curseforge-proxy/README.md

@@ -101,7 +101,8 @@ Der Dienst steht offen im Netz. Eingebaut ist:
   die Host-Liste geprüft, höchstens vier Sprünge.
 - **Ratenbegrenzung** je Absender, einstellbar über `RATE_LIMIT_PER_MIN`.
 - **Größengrenze** für durchgereichte Dateien über `MAX_DOWNLOAD_MB`.
-- **Optionales Token** über `CF_PROXY_TOKEN`.
+- **Token** über `CF_PROXY_TOKEN` – Pflicht: ohne Token startet der Dienst nicht
+  (bewusst offen nur mit `CF_PROXY_OFFEN=1`, z. B. im abgeschotteten Netz).
 
 Zum Token eine ehrliche Einordnung: Es steckt dann auch im Launcher und ist
 dort auslesbar. Es hält Gelegenheitsnutzer ab, keine entschlossenen. Die

server/curseforge-proxy/index.js

@@ -1,58 +1,30 @@
 'use strict';
 
-/*
- * AeroMC – CurseForge-Weiterleitung
- * ---------------------------------
- * Hält den CurseForge-API-Schlüssel und stellt die Anfragen stellvertretend
- * für den Launcher. So bleibt der Schlüssel auf dem Server: in der verteilten
- * .exe wäre er für jeden auslesbar, und CurseForge untersagt die Weitergabe
- * an Dritte ausdrücklich.
- *
- * Wege:
- *   GET  /health                  – Lebenszeichen, ohne Schlüsselangaben
- *   POST /v1/mods/files           – Dateiliste auflösen (Rumpf: { fileIds: [...] })
- *   GET  /v1/download?url=...     – Mod-Datei durchreichen (CDN verlangt seit
- *                                   Juli 2026 ebenfalls einen Schlüssel)
- *
- * Einstellungen über Umgebungsvariablen, siehe .env.example.
- */
-
 const http = require('http');
+const crypto = require('crypto');
 const { Readable } = require('stream');
 
 const KEY = (process.env.CF_API_KEY || '').trim();
 const PORT = Number(process.env.PORT || 8420);
 const HOST = process.env.HOST || '0.0.0.0';
-/*
- * Ein oder mehrere gültige Token, durch Komma getrennt.
- *
- * Mehrere deshalb, weil das Token in ausgelieferten Paketen steckt: Beim
- * Wechsel trägst du eine Zeit lang altes und neues ein, damit ältere
- * Installationen weiterlaufen, bis alle das Update haben. Danach das alte
- * streichen.
- */
+
 const TOKENS = new Set(
   String(process.env.CF_PROXY_TOKEN || '')
     .split(',').map((t) => t.trim()).filter(Boolean),
 );
 const LIMIT_PRO_MIN = Number(process.env.RATE_LIMIT_PER_MIN || 60);
 const MAX_MB = Number(process.env.MAX_DOWNLOAD_MB || 512);
-// Anzahl der Reverse-Proxies davor. 0 = keiner, 1 = z. B. Nginx Proxy Manager,
-// 2 = z. B. Cloudflare vor dem Proxy Manager.
+
 const PROXY_STUFEN = Math.max(0, Number(process.env.TRUST_PROXY || 0) || 0);
 
 const CF_API = 'https://api.curseforge.com/v1';
 
-// Ohne User-Agent weisen Dienste hinter Cloudflare Anfragen gerne mit 403 ab.
 const UA = 'AeroMC-Launcher-Proxy/1.0 (+https://git.viper.ipv64.net)';
 
 function cfKopfzeilen(weitere) {
   return Object.assign({ 'x-api-key': KEY, Accept: 'application/json', 'User-Agent': UA }, weitere || {});
 }
 
-// Nur diese Hosts dürfen durchgereicht werden. Ohne diese Liste wäre der
-// Server ein offenes Tor in dein Netz – jemand könnte ihn Adressen im
-// Heimnetz abrufen lassen und die Antwort mitlesen.
 const ERLAUBTE_HOSTS = new Set([
   'edge.forgecdn.net',
   'mediafilez.forgecdn.net',
@@ -64,6 +36,17 @@ if (!KEY) {
   process.exit(1);
 }
 
+// Ohne Token wäre der Dienst für jeden offen, der die Adresse kennt – und damit
+// auch der API-Key und das Download-Kontingent dahinter. Deshalb startet er
+// ohne CF_PROXY_TOKEN gar nicht erst. Wer ihn bewusst offen betreiben will
+// (z. B. nur im eigenen Netz), muss das ausdrücklich sagen: CF_PROXY_OFFEN=1.
+const OFFEN_ERLAUBT = process.env.CF_PROXY_OFFEN === '1';
+if (!TOKENS.size && !OFFEN_ERLAUBT) {
+  console.error('CF_PROXY_TOKEN fehlt. Ohne Token könnte jeder den Dienst (und deinen API-Key) benutzen.');
+  console.error('Token setzen (siehe .env.example) – oder, nur für ein abgeschottetes Netz, CF_PROXY_OFFEN=1.');
+  process.exit(1);
+}
+
 // ---------------------------------------------------------------------------
 // Ratenbegrenzung: einfaches Zeitfenster je Absender
 // ---------------------------------------------------------------------------
@@ -117,9 +100,21 @@ function sendeJson(res, code, daten) {
   res.end(koerper);
 }
 
+// Vergleich in gleichbleibender Zeit, damit sich ein Token nicht Zeichen für
+// Zeichen über die Antwortdauer erraten lässt
+function gleich(a, b) {
+  const x = crypto.createHash('sha256').update(a).digest();
+  const y = crypto.createHash('sha256').update(b).digest();
+  return crypto.timingSafeEqual(x, y);
+}
+
 function tokenOk(req) {
-  if (!TOKENS.size) return true;
-  return TOKENS.has(String(req.headers['x-aeromc-token'] || '').trim());
+  if (!TOKENS.size) return OFFEN_ERLAUBT;   // ohne Token nur mit ausdrücklicher Freigabe
+  const erhalten = String(req.headers['x-aeromc-token'] || '').trim();
+  if (!erhalten) return false;
+  let ok = false;
+  for (const t of TOKENS) if (gleich(t, erhalten)) ok = true;
+  return ok;
 }
 
 function leseKoerper(req, maxBytes = 1_000_000) {
@@ -337,7 +332,7 @@ server.listen(PORT, HOST, () => {
   console.log(`AeroMC CurseForge-Weiterleitung läuft auf ${HOST}:${PORT}`);
   console.log(`  Ratenbegrenzung: ${LIMIT_PRO_MIN > 0 ? LIMIT_PRO_MIN + '/Minute je Absender' : 'aus'}`);
   // niemals die Token selbst ausgeben – Protokolle wandern schnell woanders hin
-  console.log(`  Token verlangt : ${TOKENS.size ? 'ja (' + TOKENS.size + ' gültige)' : 'nein'}`);
+  console.log(`  Token verlangt : ${TOKENS.size ? 'ja (' + TOKENS.size + ' gültige)' : 'NEIN – offen für jeden (CF_PROXY_OFFEN=1)'}`);
   console.log(`  Proxy-Stufen   : ${PROXY_STUFEN} (${PROXY_STUFEN ? 'Absender aus X-Forwarded-For' : 'Absender aus der Verbindung'})`);
 });
 

skills-lock.json

@@ -0,0 +1,137 @@
+{
+  "version": 1,
+  "skills": {
+    "cavecrew": {
+      "source": "JuliusBrussee/caveman",
+      "sourceType": "github",
+      "skillPath": "skills/cavecrew/SKILL.md",
+      "computedHash": "2e122d819a812bef0e4958706f306e4346e78ecb5a4893997b99cbc19866f514"
+    },
+    "caveman": {
+      "source": "JuliusBrussee/caveman",
+      "sourceType": "github",
+      "skillPath": "skills/caveman/SKILL.md",
+      "computedHash": "71b600c88c8d1d36f18c4875db23b53c5d6cb9ba3195e19451d6b1bb67db07c4"
+    },
+    "caveman-commit": {
+      "source": "JuliusBrussee/caveman",
+      "sourceType": "github",
+      "skillPath": "skills/caveman-commit/SKILL.md",
+      "computedHash": "b416cf134b0f33ddadeca7977aebdbb2d3db79a166d0fce2e1aabeec98132766"
+    },
+    "caveman-compress": {
+      "source": "JuliusBrussee/caveman",
+      "sourceType": "github",
+      "skillPath": "skills/caveman-compress/SKILL.md",
+      "computedHash": "810b9f31c05c3ef5d195eac4f76cd26674ba13f542d6ad5a0b16d5362b021614"
+    },
+    "caveman-discover": {
+      "source": "JuliusBrussee/caveman",
+      "sourceType": "github",
+      "skillPath": "skills/caveman-discover/SKILL.md",
+      "computedHash": "6850e0ca7bd7a35a1f447cbd342f91b76ece1fb2e3473ad894e51e69746df8a2"
+    },
+    "caveman-evidence-review": {
+      "source": "JuliusBrussee/caveman",
+      "sourceType": "github",
+      "skillPath": "skills/caveman-evidence-review/SKILL.md",
+      "computedHash": "6a2db0191082500739416c87ff896a7894f98aa867f15c70fe932e4d72edd327"
+    },
+    "caveman-explore": {
+      "source": "JuliusBrussee/caveman",
+      "sourceType": "github",
+      "skillPath": "skills/caveman-explore/SKILL.md",
+      "computedHash": "6e89d5fef24957b921cf021d5bb392c47185ed65233db783acef64a9228dbb1b"
+    },
+    "caveman-help": {
+      "source": "JuliusBrussee/caveman",
+      "sourceType": "github",
+      "skillPath": "skills/caveman-help/SKILL.md",
+      "computedHash": "c7a73a8c6afb6f871690666449209106aba847b4a9b0698686648960ece80012"
+    },
+    "caveman-learn": {
+      "source": "JuliusBrussee/caveman",
+      "sourceType": "github",
+      "skillPath": "skills/caveman-learn/SKILL.md",
+      "computedHash": "7af5a39ccea7b778581938662422ffce01df4271fb5403a63953794748210e93"
+    },
+    "caveman-manage": {
+      "source": "JuliusBrussee/caveman",
+      "sourceType": "github",
+      "skillPath": "skills/caveman-manage/SKILL.md",
+      "computedHash": "fdd3834941a8a576cae0ac96a38dfec6ac4bd26ef209ba9997468ca11aaf19f4"
+    },
+    "caveman-optimize": {
+      "source": "JuliusBrussee/caveman",
+      "sourceType": "github",
+      "skillPath": "skills/caveman-optimize/SKILL.md",
+      "computedHash": "5e859a3a8305b5559b2f528616f634324449a426054704d43ef0b6ec8c1d9807"
+    },
+    "caveman-review": {
+      "source": "JuliusBrussee/caveman",
+      "sourceType": "github",
+      "skillPath": "skills/caveman-review/SKILL.md",
+      "computedHash": "36a4007c5c0c6b90b5accfee1cd769a86e4963b651dece2ce5f17a223a0abb4b"
+    },
+    "caveman-setup": {
+      "source": "JuliusBrussee/caveman",
+      "sourceType": "github",
+      "skillPath": "skills/caveman-setup/SKILL.md",
+      "computedHash": "b12b9f8f3fe6b499334a4b319ae1a16aa2da5c2d11e5bc85efd3236eac5213aa"
+    },
+    "caveman-stats": {
+      "source": "JuliusBrussee/caveman",
+      "sourceType": "github",
+      "skillPath": "skills/caveman-stats/SKILL.md",
+      "computedHash": "cc9fcd21f2a30cff5596b3cbb197fe0f4b1b30b58084a864350853c217ad301a"
+    },
+    "investigate-first": {
+      "source": "JuliusBrussee/caveman",
+      "sourceType": "github",
+      "skillPath": "skills/investigate-first/SKILL.md",
+      "computedHash": "59b581b5abfc0e19b7dd5a7c3bb2b16621ab5e94e085065c7b724a9c86cc3d4d"
+    },
+    "lean-build": {
+      "source": "JuliusBrussee/caveman",
+      "sourceType": "github",
+      "skillPath": "skills/lean-build/SKILL.md",
+      "computedHash": "6074721f1653e6e9d6381595b094284807b8d5d001d7d3977ec534679b16a63c"
+    },
+    "megacave": {
+      "source": "JuliusBrussee/caveman",
+      "sourceType": "github",
+      "skillPath": "skills/megacave/SKILL.md",
+      "computedHash": "60da384ce09cedf553e2b6dfe4669ffb4e53f34c3df8ce2c8012a32e06f8e187"
+    },
+    "migration": {
+      "source": "JuliusBrussee/caveman",
+      "sourceType": "github",
+      "skillPath": "skills/migration/SKILL.md",
+      "computedHash": "7348b2d21ca05bdecc1e4ec2c8b63515ccb1700c8a261fdbd458b04b7383945b"
+    },
+    "safe-refactor": {
+      "source": "JuliusBrussee/caveman",
+      "sourceType": "github",
+      "skillPath": "skills/safe-refactor/SKILL.md",
+      "computedHash": "9df34a21a7a2c18ce13dbbe4a3f66b4e91df9e4bc33c1c9da8a80261583367ec"
+    },
+    "surgical-patch": {
+      "source": "JuliusBrussee/caveman",
+      "sourceType": "github",
+      "skillPath": "skills/surgical-patch/SKILL.md",
+      "computedHash": "028b9c3574142d19639d9f8eb11fbb01c58479f8f441e957d598a7215e79f95d"
+    },
+    "ultracave": {
+      "source": "JuliusBrussee/caveman",
+      "sourceType": "github",
+      "skillPath": "skills/ultracave/SKILL.md",
+      "computedHash": "d2e5de7e5e664e95c0c93ea0fb84c6b78a4bb2351c71964c453a8a35c63869eb"
+    },
+    "verify-and-stop": {
+      "source": "JuliusBrussee/caveman",
+      "sourceType": "github",
+      "skillPath": "skills/verify-and-stop/SKILL.md",
+      "computedHash": "3d67de16a2b3c48b643bc511ebc4cb86e6c7105215d8428b6140cbcb73aba4e6"
+    }
+  }
+}

src/assets/spieldesign/font_default.json

@@ -0,0 +1,13 @@
+{
+  "providers": [
+    {
+      "type": "bitmap",
+      "file": "aeromc:font/symbole.png",
+      "ascent": 7,
+      "height": 8,
+      "chars": [
+        "\ue900\ue901\ue902\ue903\ue904\ue905"
+      ]
+    }
+  ]
+}

src/assets/spieldesign/knopf.png.mcmeta

@@ -0,0 +1,10 @@
+{
+  "gui": {
+    "scaling": {
+      "type": "nine_slice",
+      "width": 200,
+      "height": 20,
+      "border": 3
+    }
+  }
+}

src/assets/spieldesign/lang_de_de.json

@@ -0,0 +1,7 @@
+{
+  "menu.singleplayer": "\ue900  Einzelspieler",
+  "menu.multiplayer": "\ue901  Mehrspieler",
+  "menu.online": "\ue902  Minecraft Realms",
+  "menu.options": "\ue903  Optionen \u2026",
+  "menu.quit": "\ue904  Spiel beenden"
+}

src/assets/spieldesign/lang_en_us.json

@@ -0,0 +1,7 @@
+{
+  "menu.singleplayer": "\ue900  Singleplayer",
+  "menu.multiplayer": "\ue901  Multiplayer",
+  "menu.online": "\ue902  Minecraft Realms",
+  "menu.options": "\ue903  Options...",
+  "menu.quit": "\ue904  Quit Game"
+}

src/assets/spieldesign/lang_mods_de_de.json

@@ -0,0 +1,4 @@
+{
+  "menu.sendFeedback": "\ue905  Mods verwalten \u2026",
+  "menu.feedback": "\ue905  Mods & Feedback \u2026"
+}

src/assets/spieldesign/lang_mods_en_us.json

@@ -0,0 +1,4 @@
+{
+  "menu.sendFeedback": "\ue905  Manage Mods...",
+  "menu.feedback": "\ue905  Mods & Feedback..."
+}

src/assets/spieldesign/splashes.txt

@@ -0,0 +1,33 @@
+Mehr als nur Minecraft!
+Mehr als nur Minecraft!
+Mehr als nur Minecraft!
+Mehr als nur Minecraft!
+Gemeinsam mehr bauen!
+Dein Minecraft-Erlebnis!
+Gestartet mit AeroMC!
+Jetzt mit eigenen Umhängen!
+Freunde inklusive!
+Blockig, aber schön!
+Auch in Nachtlila!
+Turbo dank Leistungs-Paket!
+17 Erfolge warten!
+Mit Garderobe!
+Ein Klick, und los!
+Mods? Ein Klick!
+Diamanten nicht inklusive!
+Achtung, Creeper!
+Handgepixelt!
+Heute schon gebaut?
+Deine Welt, dein Stil!
+Spielzeit läuft mit!
+Läuft wie geschmiert!
+Kein Lag, nur Spaß!
+Lade Freunde ein!
+Schon ein Backup gemacht?
+Hallo Nachbar!
+Nur noch ein Block!
+Bitte nicht die Lava trinken!
+Jetzt auch auf Deutsch!
+Mit 100 % mehr Blau!
+Schlaf gut, Steve!
+Endlich Wochenende!

src/assets/verbot.svg

@@ -0,0 +1,5 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100">
+  <circle cx="50" cy="50" r="49.5" fill="#fff" stroke="#222" stroke-width="0.6"/>
+  <circle cx="50" cy="50" r="43.8" fill="#fff" stroke="#c80000" stroke-width="11.2"/>
+  <line x1="23.4" y1="23.4" x2="76.6" y2="76.6" stroke="#c80000" stroke-width="11.2"/>
+</svg>

src/aufbau.html

@@ -0,0 +1,51 @@
+<!doctype html>
+<html lang="de">
+<head>
+  <meta charset="utf-8" />
+  <meta http-equiv="Content-Security-Policy"
+        content="default-src 'self'; img-src 'self' data:; style-src 'self' 'unsafe-inline'; script-src 'self' 'unsafe-inline'" />
+  <title>AeroMC</title>
+  <style>
+    html, body { margin: 0; height: 100%; overflow: hidden; background: transparent; }
+    #bild {
+      position: absolute; display: none; transform-origin: 0 0; will-change: transform, opacity;
+      border-radius: 6px; box-shadow: 0 18px 48px rgba(0, 0, 0, .45);
+    }
+  </style>
+</head>
+<body>
+  <img id="bild" alt="" />
+  <script>
+    // Hilfsfenster für "Fenster wachsen aus dem Knopf" (siehe fensteraufbau.js) – wird nach einmaligem Gebrauch geschlossen
+    const bild = document.getElementById('bild');
+    let start = 1;
+
+    // Bild an die Zielstelle legen und auf Knopfgröße zusammenschrumpfen (noch unsichtbar)
+    window.vorbereiten = (adresse, nach, von) => new Promise((fertig) => {
+      bild.onerror = () => fertig(false);
+      bild.onload = () => {
+        Object.assign(bild.style, { left: nach.x + 'px', top: nach.y + 'px', width: nach.width + 'px', height: nach.height + 'px' });
+        // wächst aus der Mitte des angeklickten Knopfs heraus (darf außerhalb liegen)
+        bild.style.transformOrigin = `${von.x + von.width / 2 - nach.x}px ${von.y + von.height / 2 - nach.y}px`;
+        start = Math.max(0.06, Math.min(0.5, Math.max(von.width / nach.width, von.height / nach.height)));
+        bild.style.transform = `scale(${start})`;
+        bild.style.opacity = '0';
+        bild.style.display = 'block';
+        // zwei Bildtakte abwarten, damit der Anfangszustand gezeichnet ist (höchstens 120 ms)
+        let erledigt = false;
+        const fertigEinmal = () => { if (!erledigt) { erledigt = true; fertig(true); } };
+        requestAnimationFrame(() => requestAnimationFrame(fertigEinmal));
+        setTimeout(fertigEinmal, 120);
+      };
+      bild.src = adresse;
+    });
+
+    window.abspielen = (ms) => bild.animate([
+      { transform: `scale(${start})`, opacity: 0 },
+      { opacity: 1, offset: 0.3 },
+      { transform: 'scale(1)', opacity: 1 },
+    ], { duration: ms, easing: 'cubic-bezier(.2, .8, .2, 1)', fill: 'forwards' }).finished.then(() => true, () => false);
+
+  </script>
+</body>
+</html>

src/cfimport.js

@@ -154,14 +154,27 @@ function scan(inputPath) {
   return { ok: true, instancesDir, count: list.length, instances: list };
 }
 
+function kopierNamen(sourceDir) {
+  return fs.readdirSync(sourceDir).filter((name) => !META_FILES.includes(name));
+}
+
 function copyInto(sourceDir, targetDir) {
   fs.mkdirSync(targetDir, { recursive: true });
-  for (const name of fs.readdirSync(sourceDir)) {
-    if (META_FILES.includes(name)) continue;
+  for (const name of kopierNamen(sourceDir)) {
     fs.cpSync(path.join(sourceDir, name), path.join(targetDir, name), { recursive: true });
   }
 }
 
+/*
+ * Was beim Übernehmen kopiert wird: [{ von, name }] – `name` ist der Zielname
+ * im Spielordner der neuen Instanz. Das Kopieren selbst erledigt kopieren.js
+ * asynchron mit Fortschritt (main.js → fuehreImportAus).
+ */
+function kopierQuellen(entry) {
+  if (!entry.gameDir || !fs.existsSync(entry.gameDir)) return [];
+  return kopierNamen(entry.gameDir).map((name) => ({ von: path.join(entry.gameDir, name), name }));
+}
+
 function importOne(store, entry, copyData = true) {
   const created = store.createOrReplaceImportedInstance({
     name: entry.name,
@@ -193,4 +206,4 @@ function importOne(store, entry, copyData = true) {
   return { id: created.id, name: created.name, copied };
 }
 
-module.exports = { scan, importOne, resolveInstancesDir };
+module.exports = { scan, importOne, kopierQuellen, resolveInstancesDir };

src/crashhelp.js

@@ -1,218 +1,227 @@
-'use strict';
-
-/*
- * crashhelp.js – Absturz-Assistent
- * ---------------------------------
- * Liest Absturzbericht, latest.log und die letzte Konsolenausgabe eines Starts
- * und erkennt die häufigsten Ursachen. Jeder Fund bekommt eine verständliche
- * Erklärung und – wo möglich – eine Aktion, die der Launcher mit einem Klick
- * ausführen kann:
- *
- *   { typ: 'mod-installieren', projekt, name }  fehlende Abhängigkeit von Modrinth holen
- *   { typ: 'mod-deaktivieren', dateiname, name } Mod abschalten (umbenennen, nichts gelöscht)
- *   { typ: 'ram', mb }                           Arbeitsspeicher der Instanz ändern
- *   { typ: 'java-auto' }                         passendes Java automatisch wählen lassen
- *   { typ: 'mods-ordner' }                       Mods-Ordner öffnen
- *
- * Bewusst nur Muster, die eindeutig sind – lieber keinen Fund als einen falschen.
- */
-
-// Mod-IDs, die keine installierbaren Mods sind
-const KEINE_MODS = new Set(['minecraft', 'java', 'fabricloader', 'fabric-loader', 'forge', 'neoforge', 'quilt_loader', 'quilt-loader', 'fml', 'mixinextras']);
-
-// Mod-ID -> Modrinth-Projekt, wo sich beides unterscheidet
-const PROJEKT_FUER_ID = {
-  fabric: 'fabric-api',
-  'fabric-api-base': 'fabric-api',
-  quilted_fabric_api: 'qsl',
-  cloth_config: 'cloth-config',
-  'cloth-config2': 'cloth-config',
-  architectury: 'architectury-api',
-  geckolib3: 'geckolib',
-};
-
-// Java-Hauptversion aus der "class file version" (52 = Java 8, 61 = 17, 65 = 21 …)
-const javaAusKlassenversion = (v) => Number(v) - 44;
-
-function projektFuer(modId) {
-  const id = String(modId || '').toLowerCase();
-  return PROJEKT_FUER_ID[id] || id.replace(/_/g, '-');
-}
-
-// installierte Mod zu einer ID/einem Namen finden (für "abschalten")
-function findeMod(mods, modId, name) {
-  const id = String(modId || '').toLowerCase();
-  const kurz = id.replace(/[-_]/g, '');
-  const n = String(name || '').toLowerCase().replace(/[^a-z0-9]/g, '');
-  return (mods || []).find((m) => {
-    if (m.enabled === false) return false;
-    const datei = String(m.filename || '').toLowerCase();
-    const titel = String(m.title || '').toLowerCase().replace(/[^a-z0-9]/g, '');
-    return (id && (datei.startsWith(id) || datei.replace(/[-_]/g, '').startsWith(kurz)))
-      || (n && titel && (titel === n || datei.replace(/[^a-z0-9]/g, '').startsWith(n)));
-  }) || null;
-}
-
-/*
- * text: zusammengeführter Text aus Bericht, Log und Konsole
- * ctx:  { loader, version, maxMemMb, gesamtMb, mods: [{ filename, title, projectId, enabled }] }
- * -> [{ schluessel, titel, text, aktion? }]
- */
-function analysiere(text, ctx = {}) {
-  const t = String(text || '');
-  const funde = [];
-  const schonDa = new Set();
-  const fund = (schluessel, titel, erklaerung, aktion) => {
-    if (schonDa.has(schluessel)) return;
-    schonDa.add(schluessel);
-    funde.push({ schluessel, titel, text: erklaerung, aktion: aktion || null });
-  };
-  const mods = ctx.mods || [];
-
-  // --- Fehlende Abhängigkeiten (Fabric/Quilt) ---
-  // "Mod 'Mod Menu' (modmenu) 7.2.2 requires any version of fabric-api, which is missing!"
-  // neuere Fassung: "... requires any version of mod 'Fabric API' (fabric-api), which is missing!"
-  for (const m of t.matchAll(/Mod '([^']+)' \(([\w.-]+)\)[^\n]*? requires (?:version ([^\n,]+?)|any version) of (?:mod '([^']+)' \(([\w.-]+)\)|([\w.-]+)), which is missing/gi)) {
-    const [, name, , version, fehltName, fehltIdNeu, fehltIdAlt] = m;
-    const fehlt = fehltIdNeu || fehltIdAlt;
-    if (KEINE_MODS.has(fehlt.toLowerCase())) continue;
-    const anzeige = fehltName || fehlt;
-    fund(`fehlt:${fehlt}`, `„${name}“ braucht ${anzeige}`,
-      `Der Mod „${name}“ funktioniert nur zusammen mit „${anzeige}“${version ? ` (Version ${version.trim()})` : ''} – und der fehlt in dieser Instanz.`,
-      { typ: 'mod-installieren', projekt: projektFuer(fehlt), name: anzeige });
-  }
-  // Lösungsvorschlag von Fabric: "- Install fabric-api, any version."
-  for (const m of t.matchAll(/^\s*-\s*Install ([\w.-]+), (?:any version|version [^\n.]+)/gim)) {
-    const fehlt = m[1];
-    if (KEINE_MODS.has(fehlt.toLowerCase())) continue;
-    fund(`fehlt:${fehlt}`, `Es fehlt „${fehlt}“`,
-      `Ein installierter Mod braucht „${fehlt}“, der in dieser Instanz nicht installiert ist.`,
-      { typ: 'mod-installieren', projekt: projektFuer(fehlt), name: fehlt });
-  }
-
-  // --- Fehlende Abhängigkeiten (Forge/NeoForge) ---
-  // "Mod ID: 'architectury', Requested by: 'rei', Expected range: '[9.1.12,)', Actual version: '[MISSING]'"
-  for (const m of t.matchAll(/Mod ID: '([\w.-]+)', Requested by: '([\w.-]+)', Expected range: '([^']*)', Actual version: '([^']*)'/gi)) {
-    const [, fehlt, von, bereich, ist] = m;
-    if (fehlt.toLowerCase() === 'minecraft') {
-      const mod = findeMod(mods, von);
-      fund(`mcversion:${von}`, `„${von}“ passt nicht zu dieser Minecraft-Version`,
-        `Der Mod „${von}“ ist für Minecraft ${bereich} gemacht, deine Instanz hat ${ctx.version || ist}.`,
-        mod ? { typ: 'mod-deaktivieren', dateiname: mod.filename, name: mod.title || von } : null);
-      continue;
-    }
-    if (KEINE_MODS.has(fehlt.toLowerCase())) continue;
-    if (/MISSING/i.test(ist)) {
-      fund(`fehlt:${fehlt}`, `„${von}“ braucht ${fehlt}`,
-        `Der Mod „${von}“ funktioniert nur zusammen mit „${fehlt}“ – und der fehlt in dieser Instanz.`,
-        { typ: 'mod-installieren', projekt: projektFuer(fehlt), name: fehlt });
-    } else {
-      fund(`alt:${fehlt}`, `„${fehlt}“ ist zu alt oder zu neu`,
-        `„${von}“ braucht „${fehlt}“ in der Version ${bereich}, installiert ist ${ist}. Aktualisiere „${fehlt}“ im Inhalts-Dialog („Nach Updates suchen“).`);
-    }
-  }
-
-  // --- Mod für eine andere Minecraft-Version (Fabric) ---
-  // "Mod 'X' (x) 1.0 requires version 1.20.4 of minecraft, but only the wrong version is present: 1.21!"
-  for (const m of t.matchAll(/Mod '([^']+)' \(([\w.-]+)\)[^\n]*? requires (?:version |any version of )?([^\n]*?) of (?:mod )?'?minecraft'?/gi)) {
-    const [, name, id, fuer] = m;
-    const mod = findeMod(mods, id, name);
-    fund(`mcversion:${id}`, `„${name}“ passt nicht zu dieser Minecraft-Version`,
-      `„${name}“ ist für Minecraft ${fuer.replace(/^version\s+/i, '').trim() || 'eine andere Version'} gemacht, deine Instanz hat ${ctx.version || 'eine andere'}. Abschalten oder eine passende Version des Mods installieren.`,
-      mod ? { typ: 'mod-deaktivieren', dateiname: mod.filename, name } : null);
-  }
-  // Lösungsvorschlag: "- Remove mod 'X' (x)."
-  for (const m of t.matchAll(/^\s*-\s*Remove mod '([^']+)' \(([\w.-]+)\)/gim)) {
-    const [, name, id] = m;
-    const mod = findeMod(mods, id, name);
-    fund(`entfernen:${id}`, `„${name}“ verursacht den Fehler`,
-      `Der Mod-Loader schlägt vor, „${name}“ zu entfernen – er verträgt sich nicht mit den anderen Mods oder dieser Version.`,
-      mod ? { typ: 'mod-deaktivieren', dateiname: mod.filename, name } : null);
-  }
-  // "Mod 'A' (a) is incompatible with any version of mod 'B' (b)"
-  for (const m of t.matchAll(/Mod '([^']+)' \(([\w.-]+)\)[^\n]*? is incompatible with [^\n]*?mod '([^']+)' \(([\w.-]+)\)/gi)) {
-    const [, a, idA, b] = m;
-    const mod = findeMod(mods, idA, a);
-    fund(`inkompatibel:${idA}`, `„${a}“ und „${b}“ vertragen sich nicht`,
-      `Diese beiden Mods können nicht zusammen installiert sein. Schalte einen der beiden ab.`,
-      mod ? { typ: 'mod-deaktivieren', dateiname: mod.filename, name: a } : null);
-  }
-
-  // --- Doppelte Mods ---
-  if (/Duplicate mods found|Found duplicate mods|is provided by multiple mods|Mod ID ['"]?[\w.-]+['"]? is (?:provided|present) multiple times/i.test(t)) {
-    fund('doppelt', 'Ein Mod ist doppelt installiert',
-      'Mindestens ein Mod liegt zweimal im Mods-Ordner (z. B. zwei Versionen desselben Mods). Lösche die ältere Datei.',
-      { typ: 'mods-ordner' });
-  }
-
-  // --- Falsche Java-Version ---
-  const klasse = t.match(/UnsupportedClassVersionError[\s\S]{0,300}?class file version (\d+)\.\d+/i);
-  const javaPflicht = t.match(/requires (?:at least )?Java (\d+)|Java (\d+) (?:or (?:newer|later|above)) is required|Unsupported Java detected \((\d+)/i);
-  if (klasse || javaPflicht) {
-    const noetig = klasse ? javaAusKlassenversion(klasse[1]) : Number(javaPflicht[1] || javaPflicht[2] || 0);
-    fund('java', noetig ? `Diese Instanz braucht Java ${noetig}` : 'Falsche Java-Version',
-      `Minecraft oder ein Mod wurde für ${noetig ? `Java ${noetig}` : 'eine andere Java-Version'} gebaut, gestartet wurde mit einer älteren. AeroMC kann das passende Java automatisch wählen und bei Bedarf herunterladen.`,
-      { typ: 'java-auto' });
-  }
-
-  // --- Zu wenig Arbeitsspeicher ---
-  if (/java\.lang\.OutOfMemoryError|There is insufficient memory for the Java Runtime/i.test(t)) {
-    const jetzt = Number(ctx.maxMemMb) || 2048;
-    const grenze = Math.max(2048, Math.floor((Number(ctx.gesamtMb) || 8192) * 0.6));
-    const neu = Math.min(grenze, jetzt + 2048);
-    fund('ram', 'Minecraft hatte zu wenig Arbeitsspeicher',
-      `Der Instanz waren ${Math.round(jetzt / 102.4) / 10} GB zugewiesen – zu wenig für diese Mods oder Welt.`
-        + (neu > jetzt ? ` Empfohlen: ${Math.round(neu / 102.4) / 10} GB.` : ' Mehr lässt dein PC kaum zu – weniger Mods oder eine kleinere Sichtweite helfen.'),
-      neu > jetzt ? { typ: 'ram', mb: neu } : null);
-  }
-  if (/Could not reserve enough space for (?:\d+KB )?object heap|Invalid maximum heap size|Initial heap size set to a larger value than the maximum/i.test(t)) {
-    const jetzt = Number(ctx.maxMemMb) || 4096;
-    const neu = Math.max(2048, Math.min(jetzt - 1024, Math.floor((Number(ctx.gesamtMb) || 8192) * 0.5)));
-    fund('ram-zuviel', 'Zu viel Arbeitsspeicher eingestellt',
-      `Java konnte die eingestellten ${Math.round(jetzt / 102.4) / 10} GB nicht reservieren – entweder ist gerade nicht genug frei oder es läuft ein 32-Bit-Java.`,
-      neu < jetzt ? { typ: 'ram', mb: neu } : { typ: 'java-auto' });
-  }
-
-  // --- Mixin-Fehler: ein bestimmter Mod passt nicht ---
-  for (const m of t.matchAll(/Mixin (?:apply|transformation)[^\n]*? (?:for|from) mod ([\w.-]+) failed|from mod ([\w.-]+) failed injection check|mixins?\.json:[^\n]*? from mod ([\w.-]+)/gi)) {
-    const id = m[1] || m[2] || m[3];
-    if (!id || KEINE_MODS.has(id.toLowerCase())) continue;
-    const mod = findeMod(mods, id);
-    fund(`mixin:${id}`, `„${mod ? (mod.title || id) : id}“ passt nicht zu dieser Version`,
-      `Der Mod „${id}“ greift tief in Minecraft ein und ist mit dieser Minecraft-Version oder einem anderen Mod nicht kompatibel. Schalte ihn ab oder installiere eine passende Version.`,
-      mod ? { typ: 'mod-deaktivieren', dateiname: mod.filename, name: mod.title || id } : null);
-  }
-
-  // --- Grafiktreiber ---
-  if (/Pixel format not accelerated|WGL: The driver does not appear to support OpenGL|GLFW error 65542|OpenGL 3\.2 (?:is )?not supported|Couldn't set pixel format|No OpenGL context found/i.test(t)) {
-    fund('treiber', 'Problem mit dem Grafiktreiber',
-      'Minecraft konnte OpenGL nicht starten. Meist hilft es, den Grafiktreiber direkt vom Hersteller (NVIDIA, AMD oder Intel) zu aktualisieren. Bei Laptops: in den Windows-Grafikeinstellungen Java auf „Hohe Leistung“ stellen.');
-  }
-
-  // --- Bekannte Unverträglichkeiten anhand der installierten Mods ---
-  const aktive = mods.filter((m) => m.enabled !== false);
-  const hat = (re) => aktive.find((m) => re.test(String(m.filename || '') + ' ' + String(m.title || '')));
-  const optifine = hat(/optifine|optifabric/i);
-  const sodium = hat(/sodium|embeddium|rubidium/i);
-  if (optifine && sodium) {
-    fund('optifine-sodium', 'OptiFine und Sodium zusammen installiert',
-      'OptiFine und Sodium (bzw. Embeddium/Rubidium) machen dasselbe und vertragen sich nicht. Schalte OptiFine ab – für Shader gibt es Iris als Ergänzung zu Sodium.',
-      { typ: 'mod-deaktivieren', dateiname: optifine.filename, name: optifine.title || 'OptiFine' });
-  }
-
-  // --- Forge nennt einen Verdächtigen, aber sonst nichts Eindeutiges ---
-  if (!funde.length) {
-    const verdacht = t.match(/^Suspected Mods?:\s*([^\n]+)$/im);
-    if (verdacht && !/^\s*NONE\s*$/i.test(verdacht[1])) {
-      const name = verdacht[1].split(/[,(]/)[0].trim();
-      const mod = findeMod(mods, '', name);
-      fund('verdacht', `Vermutlich verursacht von „${name}“`,
-        `Laut Absturzbericht steckt wahrscheinlich „${verdacht[1].trim()}“ dahinter. Schalte den Mod testweise ab und starte erneut.`,
-        mod ? { typ: 'mod-deaktivieren', dateiname: mod.filename, name: mod.title || name } : null);
-    }
-  }
-
-  return funde;
-}
-
-module.exports = { analysiere, projektFuer };
+'use strict';
+
+/*
+ * crashhelp.js – Absturz-Assistent
+ * ---------------------------------
+ * Liest Absturzbericht, latest.log und die letzte Konsolenausgabe eines Starts
+ * und erkennt die häufigsten Ursachen. Jeder Fund bekommt eine verständliche
+ * Erklärung und – wo möglich – eine Aktion, die der Launcher mit einem Klick
+ * ausführen kann:
+ *
+ *   { typ: 'mod-installieren', projekt, name }  fehlende Abhängigkeit von Modrinth holen
+ *   { typ: 'mod-deaktivieren', dateiname, name } Mod abschalten (umbenennen, nichts gelöscht)
+ *   { typ: 'ram', mb }                           Arbeitsspeicher der Instanz ändern
+ *   { typ: 'java-auto' }                         passendes Java automatisch wählen lassen
+ *   { typ: 'mods-ordner' }                       Mods-Ordner öffnen
+ *
+ * Bewusst nur Muster, die eindeutig sind – lieber keinen Fund als einen falschen.
+ */
+
+// Mod-IDs, die keine installierbaren Mods sind
+const KEINE_MODS = new Set(['minecraft', 'java', 'fabricloader', 'fabric-loader', 'forge', 'neoforge', 'quilt_loader', 'quilt-loader', 'fml', 'mixinextras']);
+
+// Mod-ID -> Modrinth-Projekt, wo sich beides unterscheidet
+const PROJEKT_FUER_ID = {
+  fabric: 'fabric-api',
+  'fabric-api-base': 'fabric-api',
+  quilted_fabric_api: 'qsl',
+  cloth_config: 'cloth-config',
+  'cloth-config2': 'cloth-config',
+  architectury: 'architectury-api',
+  geckolib3: 'geckolib',
+};
+
+// Java-Hauptversion aus der "class file version" (52 = Java 8, 61 = 17, 65 = 21 …)
+const javaAusKlassenversion = (v) => Number(v) - 44;
+
+function projektFuer(modId) {
+  const id = String(modId || '').toLowerCase();
+  return PROJEKT_FUER_ID[id] || id.replace(/_/g, '-');
+}
+
+// installierte Mod zu einer ID/einem Namen finden (für "abschalten")
+function findeMod(mods, modId, name) {
+  const id = String(modId || '').toLowerCase();
+  const kurz = id.replace(/[-_]/g, '');
+  const n = String(name || '').toLowerCase().replace(/[^a-z0-9]/g, '');
+  return (mods || []).find((m) => {
+    if (m.enabled === false) return false;
+    const datei = String(m.filename || '').toLowerCase();
+    const titel = String(m.title || '').toLowerCase().replace(/[^a-z0-9]/g, '');
+    return (id && (datei.startsWith(id) || datei.replace(/[-_]/g, '').startsWith(kurz)))
+      || (n && titel && (titel === n || datei.replace(/[^a-z0-9]/g, '').startsWith(n)));
+  }) || null;
+}
+
+/*
+ * text: zusammengeführter Text aus Bericht, Log und Konsole
+ * ctx:  { loader, version, maxMemMb, gesamtMb, mods: [{ filename, title, projectId, enabled }] }
+ * -> [{ schluessel, titel, text, aktion? }]
+ */
+function analysiere(text, ctx = {}) {
+  const t = String(text || '');
+  const funde = [];
+  const schonDa = new Set();
+  const fund = (schluessel, titel, erklaerung, aktion) => {
+    if (schonDa.has(schluessel)) return;
+    schonDa.add(schluessel);
+    funde.push({ schluessel, titel, text: erklaerung, aktion: aktion || null });
+  };
+  const mods = ctx.mods || [];
+
+  // --- Fehlende Abhängigkeiten (Fabric/Quilt) ---
+  // "Mod 'Mod Menu' (modmenu) 7.2.2 requires any version of fabric-api, which is missing!"
+  // neuere Fassung: "... requires any version of mod 'Fabric API' (fabric-api), which is missing!"
+  for (const m of t.matchAll(/Mod '([^']+)' \(([\w.-]+)\)[^\n]*? requires (?:version ([^\n,]+?)|any version) of (?:mod '([^']+)' \(([\w.-]+)\)|([\w.-]+)), which is missing/gi)) {
+    const [, name, , version, fehltName, fehltIdNeu, fehltIdAlt] = m;
+    const fehlt = fehltIdNeu || fehltIdAlt;
+    if (KEINE_MODS.has(fehlt.toLowerCase())) continue;
+    const anzeige = fehltName || fehlt;
+    fund(`fehlt:${fehlt}`, `„${name}“ braucht ${anzeige}`,
+      `Der Mod „${name}“ funktioniert nur zusammen mit „${anzeige}“${version ? ` (Version ${version.trim()})` : ''} – und der fehlt in dieser Instanz.`,
+      { typ: 'mod-installieren', projekt: projektFuer(fehlt), name: anzeige });
+  }
+  // Lösungsvorschlag von Fabric: "- Install fabric-api, any version."
+  for (const m of t.matchAll(/^\s*-\s*Install ([\w.-]+), (?:any version|version [^\n.]+)/gim)) {
+    const fehlt = m[1];
+    if (KEINE_MODS.has(fehlt.toLowerCase())) continue;
+    fund(`fehlt:${fehlt}`, `Es fehlt „${fehlt}“`,
+      `Ein installierter Mod braucht „${fehlt}“, der in dieser Instanz nicht installiert ist.`,
+      { typ: 'mod-installieren', projekt: projektFuer(fehlt), name: fehlt });
+  }
+
+  // --- Fehlende Abhängigkeiten (Forge/NeoForge) ---
+  // "Mod ID: 'architectury', Requested by: 'rei', Expected range: '[9.1.12,)', Actual version: '[MISSING]'"
+  for (const m of t.matchAll(/Mod ID: '([\w.-]+)', Requested by: '([\w.-]+)', Expected range: '([^']*)', Actual version: '([^']*)'/gi)) {
+    const [, fehlt, von, bereich, ist] = m;
+    if (fehlt.toLowerCase() === 'minecraft') {
+      const mod = findeMod(mods, von);
+      fund(`mcversion:${von}`, `„${von}“ passt nicht zu dieser Minecraft-Version`,
+        `Der Mod „${von}“ ist für Minecraft ${bereich} gemacht, deine Instanz hat ${ctx.version || ist}.`,
+        mod ? { typ: 'mod-deaktivieren', dateiname: mod.filename, name: mod.title || von } : null);
+      continue;
+    }
+    if (KEINE_MODS.has(fehlt.toLowerCase())) continue;
+    if (/MISSING/i.test(ist)) {
+      fund(`fehlt:${fehlt}`, `„${von}“ braucht ${fehlt}`,
+        `Der Mod „${von}“ funktioniert nur zusammen mit „${fehlt}“ – und der fehlt in dieser Instanz.`,
+        { typ: 'mod-installieren', projekt: projektFuer(fehlt), name: fehlt });
+    } else {
+      fund(`alt:${fehlt}`, `„${fehlt}“ ist zu alt oder zu neu`,
+        `„${von}“ braucht „${fehlt}“ in der Version ${bereich}, installiert ist ${ist}. Aktualisiere „${fehlt}“ im Inhalts-Dialog („Nach Updates suchen“).`);
+    }
+  }
+
+  // --- Mod für eine andere Minecraft-Version (Fabric) ---
+  // "Mod 'X' (x) 1.0 requires version 1.20.4 of minecraft, but only the wrong version is present: 1.21!"
+  for (const m of t.matchAll(/Mod '([^']+)' \(([\w.-]+)\)[^\n]*? requires (?:version |any version of )?([^\n]*?) of (?:mod )?'?minecraft'?/gi)) {
+    const [, name, id, fuer] = m;
+    const mod = findeMod(mods, id, name);
+    fund(`mcversion:${id}`, `„${name}“ passt nicht zu dieser Minecraft-Version`,
+      `„${name}“ ist für Minecraft ${fuer.replace(/^version\s+/i, '').trim() || 'eine andere Version'} gemacht, deine Instanz hat ${ctx.version || 'eine andere'}. Abschalten oder eine passende Version des Mods installieren.`,
+      mod ? { typ: 'mod-deaktivieren', dateiname: mod.filename, name } : null);
+  }
+  // Lösungsvorschlag: "- Remove mod 'X' (x)."
+  for (const m of t.matchAll(/^\s*-\s*Remove mod '([^']+)' \(([\w.-]+)\)/gim)) {
+    const [, name, id] = m;
+    const mod = findeMod(mods, id, name);
+    fund(`entfernen:${id}`, `„${name}“ verursacht den Fehler`,
+      `Der Mod-Loader schlägt vor, „${name}“ zu entfernen – er verträgt sich nicht mit den anderen Mods oder dieser Version.`,
+      mod ? { typ: 'mod-deaktivieren', dateiname: mod.filename, name } : null);
+  }
+  // "Mod 'A' (a) is incompatible with any version of mod 'B' (b)"
+  for (const m of t.matchAll(/Mod '([^']+)' \(([\w.-]+)\)[^\n]*? is incompatible with [^\n]*?mod '([^']+)' \(([\w.-]+)\)/gi)) {
+    const [, a, idA, b] = m;
+    const mod = findeMod(mods, idA, a);
+    fund(`inkompatibel:${idA}`, `„${a}“ und „${b}“ vertragen sich nicht`,
+      `Diese beiden Mods können nicht zusammen installiert sein. Schalte einen der beiden ab.`,
+      mod ? { typ: 'mod-deaktivieren', dateiname: mod.filename, name: a } : null);
+  }
+
+  // --- Doppelte Mods ---
+  if (/Duplicate mods found|Found duplicate mods|is provided by multiple mods|Mod ID ['"]?[\w.-]+['"]? is (?:provided|present) multiple times/i.test(t)) {
+    fund('doppelt', 'Ein Mod ist doppelt installiert',
+      'Mindestens ein Mod liegt zweimal im Mods-Ordner (z. B. zwei Versionen desselben Mods). Lösche die ältere Datei.',
+      { typ: 'mods-ordner' });
+  }
+
+  // --- Falsche Java-Version ---
+  const klasse = t.match(/UnsupportedClassVersionError[\s\S]{0,300}?class file version (\d+)\.\d+/i);
+  const javaPflicht = t.match(/requires (?:at least )?Java (\d+)|Java (\d+) (?:or (?:newer|later|above)) is required|Unsupported Java detected \((\d+)/i);
+  if (klasse || javaPflicht) {
+    const noetig = klasse ? javaAusKlassenversion(klasse[1]) : Number(javaPflicht[1] || javaPflicht[2] || 0);
+    fund('java', noetig ? `Diese Instanz braucht Java ${noetig}` : 'Falsche Java-Version',
+      `Minecraft oder ein Mod wurde für ${noetig ? `Java ${noetig}` : 'eine andere Java-Version'} gebaut, gestartet wurde mit einer älteren. AeroMC kann das passende Java automatisch wählen und bei Bedarf herunterladen.`,
+      { typ: 'java-auto' });
+  }
+
+  // --- Alte Forge-Version verträgt aktuelles Java 8 nicht ---
+  // Forge 1.16.5 vor 36.2.26 (und ähnlich alte Fassungen) nutzt eine interne
+  // Java-Klasse, die es seit Java 8u321 so nicht mehr gibt.
+  if (/sun\.security\.util\.ManifestEntryVerifier\.<init>/i.test(t) && /forge/i.test(String(ctx.loader || ''))) {
+    fund('forge-alt', 'Diese Forge-Version ist zu alt für das aktuelle Java',
+      'Ältere Forge-Versionen laufen mit aktuellem Java 8 nicht mehr (Fehler „ManifestEntryVerifier“). Eine neuere Forge-Version für dieselbe Minecraft-Version behebt das – Mods und Welten bleiben erhalten.',
+      { typ: 'forge-aktualisieren' });
+  }
+
+  // --- Zu wenig Arbeitsspeicher ---
+  if (/java\.lang\.OutOfMemoryError|There is insufficient memory for the Java Runtime/i.test(t)) {
+    const jetzt = Number(ctx.maxMemMb) || 2048;
+    const grenze = Math.max(2048, Math.floor((Number(ctx.gesamtMb) || 8192) * 0.6));
+    const neu = Math.min(grenze, jetzt + 2048);
+    fund('ram', 'Minecraft hatte zu wenig Arbeitsspeicher',
+      `Der Instanz waren ${Math.round(jetzt / 102.4) / 10} GB zugewiesen – zu wenig für diese Mods oder Welt.`
+        + (neu > jetzt ? ` Empfohlen: ${Math.round(neu / 102.4) / 10} GB.` : ' Mehr lässt dein PC kaum zu – weniger Mods oder eine kleinere Sichtweite helfen.'),
+      neu > jetzt ? { typ: 'ram', mb: neu } : null);
+  }
+  if (/Could not reserve enough space for (?:\d+KB )?object heap|Invalid maximum heap size|Initial heap size set to a larger value than the maximum/i.test(t)) {
+    const jetzt = Number(ctx.maxMemMb) || 4096;
+    const neu = Math.max(2048, Math.min(jetzt - 1024, Math.floor((Number(ctx.gesamtMb) || 8192) * 0.5)));
+    fund('ram-zuviel', 'Zu viel Arbeitsspeicher eingestellt',
+      `Java konnte die eingestellten ${Math.round(jetzt / 102.4) / 10} GB nicht reservieren – entweder ist gerade nicht genug frei oder es läuft ein 32-Bit-Java.`,
+      neu < jetzt ? { typ: 'ram', mb: neu } : { typ: 'java-auto' });
+  }
+
+  // --- Mixin-Fehler: ein bestimmter Mod passt nicht ---
+  for (const m of t.matchAll(/Mixin (?:apply|transformation)[^\n]*? (?:for|from) mod ([\w.-]+) failed|from mod ([\w.-]+) failed injection check|mixins?\.json:[^\n]*? from mod ([\w.-]+)/gi)) {
+    const id = m[1] || m[2] || m[3];
+    if (!id || KEINE_MODS.has(id.toLowerCase())) continue;
+    const mod = findeMod(mods, id);
+    fund(`mixin:${id}`, `„${mod ? (mod.title || id) : id}“ passt nicht zu dieser Version`,
+      `Der Mod „${id}“ greift tief in Minecraft ein und ist mit dieser Minecraft-Version oder einem anderen Mod nicht kompatibel. Schalte ihn ab oder installiere eine passende Version.`,
+      mod ? { typ: 'mod-deaktivieren', dateiname: mod.filename, name: mod.title || id } : null);
+  }
+
+  // --- Grafiktreiber ---
+  if (/Pixel format not accelerated|WGL: The driver does not appear to support OpenGL|GLFW error 65542|OpenGL 3\.2 (?:is )?not supported|Couldn't set pixel format|No OpenGL context found/i.test(t)) {
+    fund('treiber', 'Problem mit dem Grafiktreiber',
+      'Minecraft konnte OpenGL nicht starten. Meist hilft es, den Grafiktreiber direkt vom Hersteller (NVIDIA, AMD oder Intel) zu aktualisieren. Bei Laptops: in den Windows-Grafikeinstellungen Java auf „Hohe Leistung“ stellen.');
+  }
+
+  // --- Bekannte Unverträglichkeiten anhand der installierten Mods ---
+  const aktive = mods.filter((m) => m.enabled !== false);
+  const hat = (re) => aktive.find((m) => re.test(String(m.filename || '') + ' ' + String(m.title || '')));
+  const optifine = hat(/optifine|optifabric/i);
+  const sodium = hat(/sodium|embeddium|rubidium/i);
+  if (optifine && sodium) {
+    fund('optifine-sodium', 'OptiFine und Sodium zusammen installiert',
+      'OptiFine und Sodium (bzw. Embeddium/Rubidium) machen dasselbe und vertragen sich nicht. Schalte OptiFine ab – für Shader gibt es Iris als Ergänzung zu Sodium.',
+      { typ: 'mod-deaktivieren', dateiname: optifine.filename, name: optifine.title || 'OptiFine' });
+  }
+
+  // --- Forge nennt einen Verdächtigen, aber sonst nichts Eindeutiges ---
+  if (!funde.length) {
+    const verdacht = t.match(/^Suspected Mods?:\s*([^\n]+)$/im);
+    if (verdacht && !/^\s*NONE\s*$/i.test(verdacht[1])) {
+      const name = verdacht[1].split(/[,(]/)[0].trim();
+      const mod = findeMod(mods, '', name);
+      fund('verdacht', `Vermutlich verursacht von „${name}“`,
+        `Laut Absturzbericht steckt wahrscheinlich „${verdacht[1].trim()}“ dahinter. Schalte den Mod testweise ab und starte erneut.`,
+        mod ? { typ: 'mod-deaktivieren', dateiname: mod.filename, name: mod.title || name } : null);
+    }
+  }
+
+  return funde;
+}
+
+module.exports = { analysiere, projektFuer };

src/designs.css

@@ -9,8 +9,8 @@
 
 /* ===================== Design-Auswahl in den Optionen ===================== */
 .design-raster{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:8px}
-.settings-card-wide .design-raster{grid-template-columns:repeat(5,minmax(0,1fr))}
-@media (max-width:900px){.settings-card-wide .design-raster{grid-template-columns:repeat(2,minmax(0,1fr))}}
+.settings-card .design-raster{grid-template-columns:repeat(5,minmax(0,1fr))}
+@media (max-width:900px){.settings-card .design-raster{grid-template-columns:repeat(2,minmax(0,1fr))}}
 .design-wahl{display:flex;flex-direction:column;gap:5px;padding:6px;border:1px solid var(--border);border-radius:8px;background:none;color:var(--text);font-family:inherit;font-size:12px;cursor:pointer;text-align:left}
 .design-wahl:hover{border-color:var(--sel-br)}
 .design-wahl.on{border-color:var(--sel-br);box-shadow:0 0 0 1px var(--sel-br);background:var(--sel)}
@@ -73,7 +73,7 @@
 :root:is([data-design="aero"],[data-design="lila"]) .tbtn:active{background:var(--surface2)}
 :root:is([data-design="aero"],[data-design="lila"]) .tbtn svg,
 :root:is([data-design="aero"],[data-design="lila"]) #btn-new svg,:root:is([data-design="aero"],[data-design="lila"]) #btn-import svg,:root:is([data-design="aero"],[data-design="lila"]) #btn-open-dir svg,
-:root:is([data-design="aero"],[data-design="lila"]) #btn-console svg,:root:is([data-design="aero"],[data-design="lila"]) #btn-account svg,:root:is([data-design="aero"],[data-design="lila"]) #btn-settings svg,
+:root:is([data-design="aero"],[data-design="lila"]) #btn-search svg,:root:is([data-design="aero"],[data-design="lila"]) #btn-console svg,:root:is([data-design="aero"],[data-design="lila"]) #btn-account svg,:root:is([data-design="aero"],[data-design="lila"]) #btn-settings svg,
 :root:is([data-design="aero"],[data-design="lila"]) .acct-av svg{color:var(--cyan-soft)}
 :root:is([data-design="aero"],[data-design="lila"]) .tbsep{background:var(--border)}
 :root:is([data-design="aero"],[data-design="lila"]) .search-wrap input{border-radius:999px;padding:5px 12px;width:150px}
@@ -94,6 +94,10 @@
 :root:is([data-design="aero"],[data-design="lila"]) .card.sel{background:linear-gradient(180deg,rgba(var(--p-akzent),.24),rgba(var(--p-tief),.14));border-color:rgba(var(--p-akzent2),.55);box-shadow:0 10px 28px -14px rgba(var(--p-akzent),.95),0 0 0 1px rgba(var(--p-hell),.08) inset}
 :root:is([data-design="aero"],[data-design="lila"]) .card.sel .card-name{background:linear-gradient(120deg,rgb(var(--p-akzent2)),rgb(var(--p-akzent)) 60%,rgb(var(--p-tief)));color:#fff;border-radius:999px}
 :root:is([data-design="aero"],[data-design="lila"]) .card-icon-img{border-radius:10px}
+:root:is([data-design="aero"],[data-design="lila"]) .card.laeuft::after{border-color:rgb(var(--p-akzent2));--accent:rgb(var(--p-akzent2))}
+:root.ui-animiert:is([data-design="aero"],[data-design="lila"]) .lichtpunkte{display:block}
+:root:is([data-design="aero"],[data-design="lila"]) .lichtpunkte i{background:rgb(var(--p-hell));box-shadow:0 0 calc(var(--g) * 3) 1px rgba(var(--p-akzent2),.85)}
+:root:is([data-design="aero"],[data-design="lila"]) .erfolg .funke{box-shadow:0 0 5px 2px rgb(var(--p-hell)),0 0 14px 4px rgba(var(--p-akzent2),.8)}
 :root:is([data-design="aero"],[data-design="lila"]) .card-taste{border-radius:999px;background:linear-gradient(120deg,rgb(var(--p-akzent2)),rgb(var(--p-akzent)))}
 :root:is([data-design="aero"],[data-design="lila"]) .empty h2{background:linear-gradient(120deg,rgb(var(--p-hell)),rgb(var(--p-akzent)) 60%,rgb(var(--p-tief)));-webkit-background-clip:text;background-clip:text;color:transparent;font-size:26px}
 
@@ -132,7 +136,7 @@
 :root:is([data-design="aero"],[data-design="lila"]) .mods-filters select,
 :root:is([data-design="aero"],[data-design="lila"]) .mmc-bar select,
 :root:is([data-design="aero"],[data-design="lila"]) .clip-length select,
-:root:is([data-design="aero"],[data-design="lila"]) .path-row input,
+:root:is([data-design="aero"],[data-design="lila"]) .path-row input,:root:is([data-design="aero"],[data-design="lila"]) .path-row select,:root:is([data-design="aero"],[data-design="lila"]) select.s-wert,:root:is([data-design="aero"],[data-design="lila"]) input.s-wert,:root:is([data-design="aero"],[data-design="lila"]) .s-paar input,:root:is([data-design="aero"],[data-design="lila"]) .s-einheit input,
 :root:is([data-design="aero"],[data-design="lila"]) .se-farbzeile input[type=text],
 :root:is([data-design="aero"],[data-design="lila"]) .se-feld select{background:var(--input);color:var(--text);border-color:var(--border);border-radius:10px}
 :root:is([data-design="aero"],[data-design="lila"]) .search-wrap input{border-radius:999px}
@@ -145,6 +149,11 @@
 :root:is([data-design="aero"],[data-design="lila"]) input[type=checkbox],:root:is([data-design="aero"],[data-design="lila"]) input[type=radio],:root:is([data-design="aero"],[data-design="lila"]) input[type=range]{accent-color:rgb(var(--p-akzent))}
 :root:is([data-design="aero"],[data-design="lila"]) .login-usercode{background:var(--input);color:var(--text);border-color:var(--border);border-radius:12px}
 :root:is([data-design="aero"],[data-design="lila"]) .upd-notes{background:var(--input);border-radius:10px}
+:root:is([data-design="aero"],[data-design="lila"]) .upd-notes h5{color:rgb(var(--p-hell))}
+:root:is([data-design="aero"],[data-design="lila"]) .ms-spalte{background:var(--surface);border-radius:14px}
+:root:is([data-design="aero"],[data-design="lila"]) .ms-kopf input{background:var(--input);border-radius:10px}
+:root:is([data-design="aero"],[data-design="lila"]) .upd-notes li::marker{color:rgb(var(--p-akzent2))}
+:root:is([data-design="aero"],[data-design="lila"]) .upd-notes a{color:rgb(var(--p-hell))}
 
 /* Knöpfe – rund wie auf der Webseite */
 :root:is([data-design="aero"],[data-design="lila"]) .btn{border-radius:999px;padding:7px 15px;background:var(--surface);border-color:var(--border);color:var(--text);transition:background .15s,border-color .15s,transform .15s}
@@ -190,6 +199,7 @@
 :root:is([data-design="aero"],[data-design="lila"]) .snav:hover{background:var(--surface)}
 :root:is([data-design="aero"],[data-design="lila"]) .snav.on{background:linear-gradient(120deg,rgba(var(--p-akzent),.30),rgba(var(--p-tief),.18));border-color:rgba(var(--p-akzent2),.40);box-shadow:none}
 :root:is([data-design="aero"],[data-design="lila"]) .settings-card{background:var(--surface);border-color:var(--border);border-radius:16px}
+:root:is([data-design="aero"],[data-design="lila"]) .schalter input:checked+i{background:linear-gradient(120deg,rgb(var(--p-akzent)),rgb(var(--p-akzent2)));box-shadow:0 0 10px -2px rgba(var(--p-akzent),.8)}
 :root:is([data-design="aero"],[data-design="lila"]) .settings-kv-row,
 :root:is([data-design="aero"],[data-design="lila"]) .about-brand{border-bottom-color:var(--border2)}
 :root:is([data-design="aero"],[data-design="lila"]) .appinfo-item{background:rgba(var(--p-linie),.04);border-color:var(--border2);border-radius:12px}
@@ -197,6 +207,12 @@
 :root:is([data-design="aero"],[data-design="lila"]) .settings-hero h4{background:linear-gradient(120deg,rgb(var(--p-hell)),rgb(var(--p-akzent)) 70%);-webkit-background-clip:text;background-clip:text;color:transparent}
 
 /* Kontextmenü, Hinweis, Bildlaufleisten */
+/* Erfolg-Meldung: Glas-Karte mit Leuchtrand wie die Webseite */
+:root:is([data-design="aero"],[data-design="lila"]) .erfolg{background:linear-gradient(135deg,rgba(var(--p-akzent),.22),var(--surface) 55%);border:1px solid rgba(var(--p-akzent),.45);border-radius:14px;
+  box-shadow:0 0 0 1px rgba(255,255,255,.04) inset,0 18px 40px -12px rgba(0,0,0,.8),0 0 24px -8px rgba(var(--p-akzent),.7)}
+:root:is([data-design="aero"],[data-design="lila"]) .erfolg-symbol{border-radius:10px;background:rgba(var(--p-akzent),.18)}
+:root:is([data-design="aero"],[data-design="lila"]) .erfolg-kopf{color:rgb(var(--p-hell))}
+:root:is([data-design="aero"],[data-design="lila"]) .erfolg-karte{border-radius:12px;background:var(--surface)}
 :root:is([data-design="aero"],[data-design="lila"]) .ctx{background:var(--surface);border-color:var(--border);border-radius:12px;box-shadow:0 18px 40px -12px rgba(0,0,0,.8)}
 :root:is([data-design="aero"],[data-design="lila"]) .ctx-item{border-radius:8px}
 :root:is([data-design="aero"],[data-design="lila"]) .ctx-item:hover{background:rgba(var(--p-akzent),.22)}
@@ -267,10 +283,14 @@
 :root[data-design="minecraft"] .toolbar{
   background:url(assets/design/gras.png) 0 0/32px 8px repeat-x,url(assets/design/schiefer.png) 0 0/64px 64px;
   image-rendering:pixelated;border-bottom:2px solid #000;padding:11px 8px 6px}
+:root[data-design="minecraft"] .toolbar{position:relative;isolation:isolate}
+:root.ui-animiert[data-design="minecraft"] .toolbar::before{content:'';position:absolute;inset:0;z-index:-1;pointer-events:none;opacity:.18;
+  background:url("data:image/svg+xml;utf8,<svg xmlns='http://www.w3.org/2000/svg' width='512' height='48' shape-rendering='crispEdges' fill='white'><rect x='20' y='8' width='56' height='8'/><rect x='8' y='16' width='96' height='8'/><rect x='170' y='22' width='40' height='6'/><rect x='158' y='28' width='80' height='8'/><rect x='184' y='36' width='36' height='4'/><rect x='300' y='4' width='72' height='8'/><rect x='288' y='12' width='120' height='8'/><rect x='312' y='20' width='64' height='6'/><rect x='438' y='26' width='48' height='8'/><rect x='426' y='34' width='70' height='6'/></svg>") 0 0/512px 100% repeat-x;animation:wolken-ziehen 70s steps(512) infinite}
+@keyframes wolken-ziehen{to{background-position:512px 0}}
 :root[data-design="minecraft"] .tbtn{color:#fff;border-radius:0;text-shadow:1px 1px 0 #1a1a1a;image-rendering:auto}
 :root[data-design="minecraft"] .tbtn:hover{background:rgba(0,0,0,.35);border-color:#fff}
 :root[data-design="minecraft"] .tbtn:active{background:rgba(0,0,0,.5)}
-:root[data-design="minecraft"] .tbtn svg,:root[data-design="minecraft"] #btn-console svg,:root[data-design="minecraft"] .acct-av svg{color:#e6e6e6}
+:root[data-design="minecraft"] #btn-search svg,:root[data-design="minecraft"] .tbtn svg,:root[data-design="minecraft"] #btn-console svg,:root[data-design="minecraft"] .acct-av svg{color:#e6e6e6}
 :root[data-design="minecraft"] #btn-new svg,:root[data-design="minecraft"] #btn-account svg{color:#7fd858}
 :root[data-design="minecraft"] #btn-import svg{color:#6db8ff}
 :root[data-design="minecraft"] #btn-open-dir svg{color:#f2c94c}
@@ -288,7 +308,7 @@
 :root[data-design="minecraft"] .mods-filters select,
 :root[data-design="minecraft"] .mmc-bar select,
 :root[data-design="minecraft"] .clip-length select,
-:root[data-design="minecraft"] .path-row input,
+:root[data-design="minecraft"] .path-row input,:root[data-design="minecraft"] .path-row select,:root[data-design="minecraft"] select.s-wert,:root[data-design="minecraft"] input.s-wert,:root[data-design="minecraft"] .s-paar input,:root[data-design="minecraft"] .s-einheit input,
 :root[data-design="minecraft"] .login-usercode,
 :root[data-design="minecraft"] .upd-notes,
 :root[data-design="minecraft"] .se-farbzeile input[type=text],
@@ -308,6 +328,8 @@
 :root[data-design="minecraft"] .list{image-rendering:auto}
 :root[data-design="minecraft"] .group-header{font-family:var(--pixel);font-size:16px;font-weight:400;color:#fff;text-shadow:var(--mc-schatten);padding:8px 4px 4px}
 :root[data-design="minecraft"] .group-count{color:#b8b9bc}
+:root[data-design="minecraft"] .group-sub > .group-header{font-size:14px}
+:root[data-design="minecraft"] .group-sub{border-left:2px solid rgba(0,0,0,.45)}
 :root[data-design="minecraft"] .group-header .chev{color:#fff;font-family:"Segoe UI",sans-serif;font-size:10px}
 :root[data-design="minecraft"] .group-header::after{height:2px;background:rgba(0,0,0,.55);box-shadow:0 1px 0 rgba(255,255,255,.08)}
 :root[data-design="minecraft"] .card{border-radius:0}
@@ -317,6 +339,11 @@
 :root[data-design="minecraft"] .card.sel .card-name{background:none;color:#ffff7f;border-radius:0}
 :root[data-design="minecraft"] .card-taste{border-radius:0;background:#3c8527;box-shadow:inset -1px -1px 0 #1d4d13}
 :root[data-design="minecraft"] .card-icon-img{border-radius:0}
+:root[data-design="minecraft"] .card.laeuft::after{border-color:#7fd858;--accent:#7fd858;border-radius:0}
+/* Abbau-Risse: Download-Fortschritt auf dem Block, beim Fertigwerden springt er kurz */
+:root[data-design="minecraft"] .card.abbau .card-riss{display:block}
+:root.ui-animiert[data-design="minecraft"] .card.abgebaut .card-icon,:root.ui-animiert[data-design="minecraft"] .card.abgebaut .card-icon-img{animation:block-bricht .45s cubic-bezier(.3,.7,.4,1)}
+@keyframes block-bricht{0%{transform:scale(.8)}45%{transform:scale(1.14)}100%{transform:none}}
 :root[data-design="minecraft"] .empty h2{font-family:var(--pixel);font-weight:400;font-size:24px;color:#fff;text-shadow:3px 3px 0 #3f3f3f}
 :root[data-design="minecraft"] .empty p{color:#d0d0d0}
 
@@ -330,6 +357,8 @@
 :root[data-design="minecraft"] .hr{background:#000;height:2px;margin:6px 0}
 :root[data-design="minecraft"] .sbtn{margin-bottom:3px;padding:5px 2px}
 :root[data-design="minecraft"] .sbtn.play{font-family:var(--pixel);font-size:16px;font-weight:400;padding:6px 4px 7px;text-shadow:var(--mc-schatten)}
+:root[data-design="minecraft"] .sbtn.play::before,:root:is([data-design="aero"],[data-design="lila"]) .sbtn.play::before{background:#fff;opacity:.28}
+:root[data-design="minecraft"] .sbtn.play.laedt .play-text{font-size:13px}
 
 /* Statusleiste */
 :root[data-design="minecraft"] .statusbar{background:url(assets/design/schiefer.png) 0 0/64px 64px;image-rendering:pixelated;border-top:2px solid #000}
@@ -389,6 +418,10 @@
 :root[data-design="minecraft"] .settings-hero h4{font-family:var(--pixel);font-size:24px;font-weight:400;text-shadow:3px 3px 0 #3f3f3f}
 :root[data-design="minecraft"] .settings-hero p{color:#d0d0d0}
 :root[data-design="minecraft"] .settings-card{background:#313233;border:2px solid #000;border-radius:0;box-shadow:inset 2px 2px 0 #5a5b5d,inset -2px -2px 0 #1e1e1f}
+:root[data-design="minecraft"] .schalter i{border-radius:0;background:#1e1e1f;box-shadow:inset 2px 2px 0 #000}
+:root[data-design="minecraft"] .schalter i::after{border-radius:0;background:#c6c6c6;box-shadow:inset -2px -2px 0 #555,inset 2px 2px 0 #fff}
+:root[data-design="minecraft"] .schalter input:checked+i{background:#3c8527}
+:root[data-design="minecraft"] .s-zeile{border-top-color:rgba(0,0,0,.55)}
 :root[data-design="minecraft"] .settings-card h5{font-family:var(--pixel);font-size:16px;font-weight:400;text-shadow:var(--mc-schatten)}
 :root[data-design="minecraft"] .settings-kv-row,
 :root[data-design="minecraft"] .about-brand{border-bottom-color:#1a1a1b}
@@ -397,6 +430,12 @@
 :root[data-design="minecraft"] .spane h4{font-family:var(--pixel);font-size:16px;font-weight:400;text-shadow:var(--mc-schatten)}
 
 /* Kontextmenü, Hinweis, Bildlaufleisten */
+/* Erfolg-Meldung wie im Spiel („Erfolg erzielt!“) */
+:root[data-design="minecraft"] .erfolg{background:#212121;border:2px solid #555;border-radius:0;box-shadow:inset 2px 2px 0 #373737,inset -2px -2px 0 #141414,0 10px 24px rgba(0,0,0,.45);color:#fff;font-family:"AeroPixel","Segoe UI",sans-serif}
+:root[data-design="minecraft"] .erfolg-symbol{border-radius:0;background:#8b8b8b;box-shadow:inset 2px 2px 0 #373737,inset -2px -2px 0 #fff}
+:root[data-design="minecraft"] .erfolg-kopf{color:#ffff55;font-size:14px;font-weight:400;letter-spacing:0;text-transform:none}
+:root[data-design="minecraft"] .erfolg-name{font-size:14px;font-weight:400}
+:root[data-design="minecraft"] .erfolg-karte{border-radius:0;border:2px solid #000;background:rgba(0,0,0,.35)}
 :root[data-design="minecraft"] .ctx{background:#1e1e1f;border:2px solid #000;border-radius:0;box-shadow:inset 1px 1px 0 #48494a,0 8px 24px rgba(0,0,0,.5)}
 :root[data-design="minecraft"] .ctx-item{border-radius:0;text-shadow:1px 1px 0 #000}
 :root[data-design="minecraft"] .ctx-item:hover{background:#3c8527}

src/erfolge.js

@@ -0,0 +1,73 @@
+/*
+ * Erfolge im Minecraft-Stil („Erfolg erzielt!“).
+ *
+ * Bewertet wird aus dem, was der Launcher ohnehin weiß (Instanzen, Spielzeit,
+ * Starts, Mods), plus ein paar Merkern für einzelne Aktionen (Umhang
+ * hochgeladen, Skin im Editor übernommen, Leistungs-Paket …). Freigeschaltete
+ * Erfolge landen mit Datum in userData/erfolge.json.
+ */
+const fs = require('fs');
+const path = require('path');
+
+const STUNDE = 3600;
+const LISTE = [
+  { id: 'erster-start', symbol: 'grass', titel: 'Los geht’s!', text: 'Starte zum ersten Mal ein Spiel mit AeroMC.', pruefe: (w) => w.starts >= 1 },
+  { id: 'starts-10', symbol: 'pickaxe', titel: 'Stammgast', text: 'Starte 10-mal ein Spiel.', pruefe: (w) => w.starts >= 10 },
+  { id: 'starts-100', symbol: 'gold', titel: 'Ohne mich geht nichts', text: 'Starte 100-mal ein Spiel.', pruefe: (w) => w.starts >= 100 },
+  { id: 'zeit-1', symbol: 'map', titel: 'Erste Stunde', text: 'Spiele insgesamt eine Stunde.', pruefe: (w) => w.sekunden >= STUNDE },
+  { id: 'zeit-10', symbol: 'sword', titel: 'Zeit vergeht wie im Flug', text: 'Spiele insgesamt 10 Stunden.', pruefe: (w) => w.sekunden >= 10 * STUNDE },
+  { id: 'zeit-50', symbol: 'diamond', titel: 'Abenteurer', text: 'Spiele insgesamt 50 Stunden.', pruefe: (w) => w.sekunden >= 50 * STUNDE },
+  { id: 'zeit-100', symbol: 'star', titel: 'Lebt in Minecraft', text: 'Spiele insgesamt 100 Stunden.', pruefe: (w) => w.sekunden >= 100 * STUNDE },
+  { id: 'instanzen-5', symbol: 'chest', titel: 'Sammler', text: 'Lege 5 Instanzen an.', pruefe: (w) => w.instanzen >= 5 },
+  { id: 'instanzen-10', symbol: 'book', titel: 'Archivar', text: 'Lege 10 Instanzen an.', pruefe: (w) => w.instanzen >= 10 },
+  { id: 'versionen-3', symbol: 'end', titel: 'Zeitreisender', text: 'Spiele 3 verschiedene Minecraft-Versionen.', pruefe: (w) => w.versionen >= 3 },
+  { id: 'erste-mod', symbol: 'redstone', titel: 'Bastler', text: 'Habe die erste Mod in einer Instanz.', pruefe: (w) => w.mods >= 1 },
+  { id: 'mods-50', symbol: 'potion', titel: 'Mod-Meister', text: 'Habe 50 Mods in deinen Instanzen.', pruefe: (w) => w.mods >= 50 },
+  { id: 'modpack', symbol: 'nether', titel: 'Das volle Paket', text: 'Installiere ein Modpack.', pruefe: (w) => w.modpacks >= 1 },
+  { id: 'freund', symbol: 'creeper', titel: 'Gemeinsam statt einsam', text: 'Füge deinen ersten Freund hinzu.', pruefe: (w) => w.freunde >= 1 },
+  { id: 'umhang', symbol: 'star', titel: 'Modeschöpfer', text: 'Lade einen eigenen AeroMC-Umhang hoch.', pruefe: (w) => w.merker.umhang },
+  { id: 'skin-editor', symbol: 'map', titel: 'Pixelkünstler', text: 'Übernimm einen im Skin-Editor gemalten Skin.', pruefe: (w) => w.merker['skin-editor'] },
+  { id: 'leistung', symbol: 'tnt', titel: 'Turbo', text: 'Installiere das Leistungs-Paket.', pruefe: (w) => w.merker.leistung },
+];
+
+let datei = null;
+function init(userDataDir) { datei = path.join(userDataDir, 'erfolge.json'); }
+
+function lies() {
+  try { return JSON.parse(fs.readFileSync(datei, 'utf8')); } catch { return null; }
+}
+function schreibe(stand) {
+  try { fs.writeFileSync(datei, JSON.stringify(stand, null, 1)); } catch { /* nicht schlimm */ }
+}
+
+/**
+ * werte: { starts, sekunden, instanzen, versionen, mods, modpacks, freunde }
+ * merker: zusätzliche Einzel-Aktionen ({ umhang: true } …)
+ * -> { neu: [Erfolge], ersteAuswertung }
+ */
+function pruefe(werte, merker = {}) {
+  const vorher = lies();
+  const stand = vorher || { freigeschaltet: {}, merker: {} };
+  Object.assign(stand.merker, merker);
+  const w = Object.assign({ starts: 0, sekunden: 0, instanzen: 0, versionen: 0, mods: 0, modpacks: 0, freunde: 0 }, werte, { merker: stand.merker });
+  const neu = [];
+  const jetzt = new Date().toISOString();
+  for (const e of LISTE) {
+    if (stand.freigeschaltet[e.id]) continue;
+    let erreicht = false;
+    try { erreicht = !!e.pruefe(w); } catch { /* Wert fehlt */ }
+    if (erreicht) { stand.freigeschaltet[e.id] = jetzt; neu.push(oeffentlich(e, jetzt)); }
+  }
+  if (neu.length || !vorher || Object.keys(merker).length) schreibe(stand);
+  return { neu, ersteAuswertung: !vorher };
+}
+
+const oeffentlich = (e, am) => ({ id: e.id, symbol: e.symbol, titel: e.titel, text: e.text, am: am || null });
+
+/** Alle Erfolge mit Datum (null = noch offen). */
+function liste() {
+  const stand = lies() || { freigeschaltet: {} };
+  return LISTE.map((e) => oeffentlich(e, stand.freigeschaltet[e.id] || null));
+}
+
+module.exports = { init, pruefe, liste };

src/fensteraufbau.js

@@ -0,0 +1,85 @@
+/*
+ * "Fenster wachsen aus dem Knopf": Ein Popup-Fenster (Optionen, Mods, Skin,
+ * Freunde …) erscheint nicht schlagartig, sondern wächst aus dem angeklickten
+ * Knopf heraus. Dafür wird das noch unsichtbare Fenster abfotografiert und das
+ * Bild in einem durchsichtigen Hilfsfenster vom Knopf aus groß gezogen; am Ende
+ * übernimmt das echte Fenster an exakt derselben Stelle.
+ *
+ * Das Hilfsfenster entsteht jedes Mal neu und gleich in der richtigen Größe:
+ * Unter Windows färbt sich ein durchsichtiges Fenster schwarz, sobald es
+ * nachträglich vergrößert wird, und ein verstecktes Fenster zeichnet nicht mehr.
+ * Abschaltbar unter Optionen → Darstellung → Animationen („Bewegte Oberfläche“).
+ */
+const path = require('path');
+const { BrowserWindow } = require('electron');
+
+const DAUER_MS = 280;
+const HOECHSTENS_MS = 2000; // spätestens dann ist das Fenster in jedem Fall zu sehen
+const warte = (ms) => new Promise((r) => setTimeout(r, ms));
+
+function vereinigung(a, b) {
+  const x = Math.min(a.x, b.x);
+  const y = Math.min(a.y, b.y);
+  return {
+    x, y,
+    width: Math.max(a.x + a.width, b.x + b.width) - x,
+    height: Math.max(a.y + a.height, b.y + b.height) - y,
+  };
+}
+
+// Rechteck in Koordinaten des Hilfsfensters umrechnen
+const relativ = (r, box) => ({ x: r.x - box.x, y: r.y - box.y, width: r.width, height: r.height });
+
+async function abspielen(ziel, von, merke) {
+  // unsichtbar zeigen, damit Chromium den Inhalt zeichnet, dann abfotografieren
+  ziel.setOpacity(0);
+  ziel.setIgnoreMouseEvents(true);
+  ziel.show();
+  await warte(90);
+  if (ziel.isDestroyed()) return;
+  const bild = await ziel.webContents.capturePage();
+  if (bild.isEmpty() || ziel.isDestroyed()) return;
+  const nach = ziel.getBounds();
+  const box = vereinigung(von, nach);
+
+  const hilfe = new BrowserWindow({
+    x: box.x, y: box.y, width: box.width, height: box.height,
+    show: false, frame: false, transparent: true, resizable: false, movable: false,
+    minimizable: false, maximizable: false, fullscreenable: false, focusable: false,
+    skipTaskbar: true, hasShadow: false, alwaysOnTop: true, backgroundColor: '#00000000',
+    title: 'AeroMC',
+    webPreferences: { contextIsolation: true, nodeIntegration: false, sandbox: true },
+  });
+  merke(hilfe);
+  hilfe.setIgnoreMouseEvents(true);
+  await hilfe.loadFile(path.join(__dirname, 'aufbau.html'));
+  const ok = await hilfe.webContents.executeJavaScript(
+    `vorbereiten(${JSON.stringify(bild.toDataURL())}, ${JSON.stringify(relativ(nach, box))}, ${JSON.stringify(relativ(von, box))})`);
+  if (!ok || hilfe.isDestroyed()) return;
+  hilfe.showInactive();
+  await hilfe.webContents.executeJavaScript(`abspielen(${DAUER_MS})`);
+}
+
+/**
+ * Zeigt `ziel` (geladen, aber noch nicht sichtbar) mit Wachs-Animation an.
+ * `von` ist das Rechteck des angeklickten Knopfs in Bildschirmkoordinaten.
+ */
+async function wachsen(ziel, von) {
+  let hilfe = null;
+  try {
+    await Promise.race([abspielen(ziel, von, (h) => { hilfe = h; }), warte(HOECHSTENS_MS)]);
+  } catch {
+    // Animation ist nur Zierde – im Fehlerfall das Fenster einfach zeigen
+  } finally {
+    if (!ziel.isDestroyed()) {
+      ziel.setOpacity(1);
+      ziel.setIgnoreMouseEvents(false);
+      if (!ziel.isVisible()) ziel.show();
+      ziel.focus();
+    }
+    // Hilfsfenster erst nach dem Umschalten schließen, sonst blitzt der Hintergrund durch
+    setTimeout(() => { if (hilfe && !hilfe.isDestroyed()) hilfe.destroy(); }, 60);
+  }
+}
+
+module.exports = { wachsen };

src/friends.js

@@ -200,7 +200,32 @@ async function sendReport(daten) {
   }
 }
 
+// ---------- AeroMC-Umhänge ----------
+// Hochladen/Entfernen nur angemeldet; Abrufen ist öffentlich (auch für den Mod)
+function uploadCape(uuid, image) {
+  return anfrage('/cape', { method: 'POST', body: { uuid, image } });
+}
+
+function removeCape(uuid) {
+  return anfrage('/cape/remove', { method: 'POST', body: { uuid } });
+}
+
+async function getCapes(uuids) {
+  try {
+    const liste = [...new Set((uuids || []).map((u) => String(u).replace(/-/g, '').toLowerCase()))].filter(Boolean);
+    if (!liste.length) return { ok: true, capes: {} };
+    const { res, daten } = await roheAnfrage('/capes', { method: 'GET', body: { uuids: liste.join(',') } });
+    // ältere Plugin-Fassung ohne Umhänge
+    if (res.status === 404) return { ok: false, fehlt: true, message: 'Der Server kennt noch keine Umhänge (Plugin „AeroMC Freunde“ 1.5.0 nötig).' };
+    if (!res.ok) return { ok: false, message: (daten && daten.message) || `Fehler ${res.status}` };
+    return { ok: true, capes: (daten && daten.capes) || {} };
+  } catch (err) {
+    return { ok: false, message: 'Umhang-Server nicht erreichbar: ' + err.message };
+  }
+}
+
 module.exports = {
+  BASIS_URL, uploadCape, removeCape, getCapes,
   heartbeat, getFriends, getRequests, getSentRequests, sendRequest, respond, cancelRequest, removeFriend,
   sendInvite, getInvites, dismissInvite, createShare, getShare, setzeZugangsHelfer,
   sendMessage, getMessages, getUnreadMessages, markMessagesRead, sendReport,

src/garderobe.js

@@ -0,0 +1,106 @@
+/*
+ * Garderobe: gespeicherte Skins und Umhänge zum schnellen Wechseln.
+ *
+ * Mojang merkt sich keine früheren Skins – wer einen neuen hochlädt, verliert
+ * den alten. Die Garderobe hält Skins (samt Armform) und eigene AeroMC-Umhänge
+ * als PNG-Dateien im Launcher-Datenordner fest; vor jedem Skinwechsel im
+ * Launcher wird der bisherige Skin automatisch gesichert. Gleiche Dateien
+ * (gleiche Prüfsumme) werden nicht doppelt abgelegt.
+ */
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+const MAX_AUTOMATISCH = 20;   // ältere automatische Sicherungen fliegen raus
+let ordner = null;
+
+function init(userDataDir) {
+  ordner = path.join(userDataDir, 'garderobe');
+}
+
+const indexDatei = () => path.join(ordner, 'garderobe.json');
+function lies() {
+  try { return JSON.parse(fs.readFileSync(indexDatei(), 'utf8')); } catch { return []; }
+}
+function schreibe(liste) {
+  fs.mkdirSync(ordner, { recursive: true });
+  fs.writeFileSync(indexDatei(), JSON.stringify(liste, null, 1));
+}
+
+/** Alle Einträge, neueste zuerst, jeweils mit Bild als data:-Adresse. */
+function liste() {
+  return lies()
+    .filter((e) => fs.existsSync(path.join(ordner, e.datei)))
+    .sort((a, b) => String(b.erstellt).localeCompare(String(a.erstellt)))
+    .map((e) => Object.assign({}, e, {
+      dataUri: 'data:image/png;base64,' + fs.readFileSync(path.join(ordner, e.datei)).toString('base64'),
+    }));
+}
+
+/**
+ * Legt einen Skin/Umhang ab. art: 'skin' | 'umhang', daten: PNG-Buffer.
+ * Gibt es dieselbe Datei schon, wird nur ggf. aus "automatisch" ein fester Eintrag.
+ */
+function hinzufuegen({ art, daten, name, variante, automatisch }) {
+  const hash = crypto.createHash('sha1').update(daten).digest('hex');
+  const eintraege = lies();
+  const vorhanden = eintraege.find((e) => e.art === art && e.hash === hash);
+  if (vorhanden) {
+    if (!automatisch && vorhanden.automatisch) {
+      vorhanden.automatisch = false;
+      if (name) vorhanden.name = name;
+      schreibe(eintraege);
+    }
+    return { eintrag: vorhanden, neu: false };
+  }
+  fs.mkdirSync(ordner, { recursive: true });
+  const id = Date.now().toString(36) + crypto.randomBytes(3).toString('hex');
+  const datei = `${art}-${id}.png`;
+  fs.writeFileSync(path.join(ordner, datei), daten);
+  const eintrag = {
+    id, art, hash, datei,
+    name: String(name || '').trim().slice(0, 40) || (art === 'skin' ? 'Skin' : 'Umhang'),
+    variante: art === 'skin' ? (variante === 'slim' ? 'slim' : 'classic') : undefined,
+    automatisch: !!automatisch,
+    erstellt: new Date().toISOString(),
+  };
+  eintraege.push(eintrag);
+  // automatische Sicherungen begrenzen (feste Einträge bleiben immer)
+  const auto = eintraege.filter((e) => e.automatisch).sort((a, b) => String(b.erstellt).localeCompare(String(a.erstellt)));
+  for (const alt of auto.slice(MAX_AUTOMATISCH)) loescheIntern(eintraege, alt.id);
+  schreibe(eintraege);
+  return { eintrag, neu: true };
+}
+
+function loescheIntern(eintraege, id) {
+  const i = eintraege.findIndex((e) => e.id === id);
+  if (i < 0) return false;
+  try { fs.unlinkSync(path.join(ordner, eintraege[i].datei)); } catch { /* schon weg */ }
+  eintraege.splice(i, 1);
+  return true;
+}
+
+function loeschen(id) {
+  const eintraege = lies();
+  const ok = loescheIntern(eintraege, id);
+  if (ok) schreibe(eintraege);
+  return ok;
+}
+
+function umbenennen(id, name) {
+  const eintraege = lies();
+  const e = eintraege.find((x) => x.id === id);
+  if (!e) return false;
+  e.name = String(name || '').trim().slice(0, 40) || e.name;
+  e.automatisch = false;   // umbenannt = bewusst behalten
+  schreibe(eintraege);
+  return true;
+}
+
+/** Eintrag samt Dateipfad (zum Anziehen). */
+function holen(id) {
+  const e = lies().find((x) => x.id === id);
+  return e ? Object.assign({}, e, { pfad: path.join(ordner, e.datei) }) : null;
+}
+
+module.exports = { init, liste, hinzufuegen, loeschen, umbenennen, holen };

src/index.html

@@ -13,6 +13,7 @@
   <div class="titelleiste">
     <img src="assets/logo.png" alt="" class="titel-logo" />
     <span class="titel-text">AeroMC</span>
+    <span id="titel-beta" class="titel-beta hidden"></span>
   </div>
 
   <!-- Obere Werkzeugleiste (MultiMC-Stil: Icon + Text) -->
@@ -27,16 +28,19 @@
     <button id="btn-stats" class="tbtn" data-ic="chart" title="Spielzeit-Statistik">Statistik</button>
     <button id="btn-friends" class="tbtn" data-ic="users" title="Freunde (ingame: Strg+Alt+F zeigt, wer online ist)">Freunde<span id="friends-badge" class="tb-badge hidden"></span></button>
     <span class="tbgrow"></span>
-    <div class="search-wrap">
-      <input id="search" type="text" placeholder="Suchen… (Strg+F)" autocomplete="off" title="Strg+F fokussiert die Suche" />
+    <div id="search-wrap" class="search-wrap">
+      <button id="btn-search" class="tbtn tb-lupe" data-ic="search" title="Instanzen suchen (Strg+F)"></button>
+      <input id="search" type="text" placeholder="Suchen… (Esc schließt)" autocomplete="off" title="Instanzen nach Name, Version oder Gruppe filtern" />
     </div>
-    <button id="btn-account" class="tbtn acct-btn" title="Microsoft-Konto"><span id="account-av" class="acct-av"></span><span id="account-name">Konten</span></button>
+    <button id="btn-account" class="tbtn acct-btn" title="Konto wechseln, hinzufügen oder verwalten"><span id="account-av" class="acct-av"></span><span id="account-name">Konten</span><span class="acct-pfeil">▾</span></button>
     <button id="btn-settings" class="tbtn" data-ic="settings" title="Einstellungen">Optionen</button>
   </header>
 
   <!-- Arbeitsbereich: Instanzliste + rechte Aktionsleiste -->
   <main class="workspace">
     <div class="list-area">
+      <div id="lichtpunkte" class="lichtpunkte" aria-hidden="true"></div>
+      <canvas id="skin-live" class="skin-live hidden"></canvas>
       <div id="grid" class="list"></div>
       <section id="empty" class="empty hidden">
         <h2>Noch keine Instanzen</h2>
@@ -51,8 +55,15 @@
         <div id="p-icon" class="side-ico">🌱</div>
         <div id="p-name" class="side-title">Instanz</div>
         <div id="p-groupline" class="side-grp">Gruppe ändern</div>
+        <div id="p-gesperrt" class="side-gesperrt hidden">
+          <div class="side-gesperrt-titel"><img src="assets/verbot.svg" alt="" /> Instanz gesperrt</div>
+          <div class="side-gesperrt-text">Diese Instanz wurde außerhalb des Launchers verändert und kann nicht mehr gestartet werden.</div>
+          <ul id="p-gesperrt-gruende" class="side-gesperrt-gruende"></ul>
+          <button id="p-wiederherstellen" class="sbtn play">Aus Sicherung wiederherstellen</button>
+          <div class="side-gesperrt-text dim">Die Wiederherstellung wird als neue Instanz angelegt. Die gesperrte bleibt erhalten, bis du sie selbst löschst.</div>
+        </div>
         <div class="hr"></div>
-        <button id="p-play" class="sbtn play">Starten</button>
+        <button id="p-play" class="sbtn play"><span class="play-text">Starten</span></button>
         <button id="p-offline" class="sbtn">Offline starten</button>
         <div class="hr"></div>
         <button id="p-edit" class="sbtn">Instanz bearbeiten</button>
@@ -105,6 +116,7 @@
           <span>Gruppe <small class="opt">(optional)</small></span>
           <input id="f-group" type="text" list="group-list" placeholder="z. B. Modpacks, Server, Tests" autocomplete="off" />
           <datalist id="group-list"></datalist>
+          <small class="hint">Untergruppe: mit „/“ trennen, z. B. „Modpacks/Survival“.</small>
         </label>
 
         <div class="field-row">
@@ -243,87 +255,66 @@
           <button class="snav on" data-pane="pane-general">Allgemein</button>
           <button class="snav" data-pane="pane-appearance">Darstellung</button>
           <button class="snav" data-pane="pane-minecraft">Spiel</button>
-          <button class="snav" data-pane="pane-start">Start &amp; Java</button>
+          <button class="snav" data-pane="pane-start">Java &amp; Erweitert</button>
+          <button class="snav" data-pane="pane-online">Freunde &amp; Umhänge</button>
           <button class="snav" data-pane="pane-network">Netzwerk</button>
           <button class="snav" data-pane="pane-accounts">Konten</button>
           <button class="snav" data-pane="pane-backup">Backup</button>
           <button class="snav" data-pane="pane-info">Info</button>
         </nav>
         <div class="settings-content">
+          <!-- Aufbau: jede Karte enthält Zeilen – links Name + kurze Erklärung, rechts das Bedienelement -->
           <div id="pane-general" class="spane">
             <div class="settings-hero">
               <h4>Allgemein</h4>
-              <p>Globale Launcher-Optionen, Instanzverwaltung und sichtbare Bereiche.</p>
+              <p>Wie sich der Launcher verhält und wo deine Instanzen liegen.</p>
             </div>
             <div class="settings-grid">
               <section class="settings-card">
-                <h5>Instanzliste</h5>
-                <label class="field">
-                  <span>Instanzen sortieren</span>
-                  <select id="s-sortby">
-                    <option value="lastPlayed">Nach letztem Start</option>
-                    <option value="name">Nach Name</option>
-                  </select>
-                </label>
+                <h5>Launcher</h5>
+                <div class="s-zeile">
+                  <div class="s-text"><b>Mit Windows starten</b><small>Startet AeroMC beim Anmelden im Infobereich neben der Uhr. Solange aktiv, schließt das X den Launcher nicht, sondern legt ihn dort ab.</small></div>
+                  <label class="schalter"><input id="s-autostart" type="checkbox" /><i></i></label>
+                </div>
+                <div class="s-zeile">
+                  <div class="s-text"><b>Windows-Benachrichtigungen</b><small>Meldet, wenn ein großer Download oder ein Backup im Hintergrund fertig ist – nur, solange der Launcher nicht im Vordergrund ist.</small></div>
+                  <label class="schalter"><input id="s-notify" type="checkbox" /><i></i></label>
+                </div>
+                <div class="s-zeile">
+                  <div class="s-text"><b>Bedrock-Bereich anzeigen</b><small id="s-bedrock-hint">Wird automatisch ausgeblendet, wenn Bedrock nicht installiert ist.</small></div>
+                  <label class="schalter"><input id="s-bedrock" type="checkbox" /><i></i></label>
+                </div>
+                <div class="s-zeile">
+                  <div class="s-text"><b>An der Beta teilnehmen</b><small>Du bekommst neue Versionen früher zum Ausprobieren. Betas können noch Fehler enthalten. Wieder ausgeschaltet, bekommst du ab der nächsten fertigen Version nur noch fertige Versionen.</small></div>
+                  <label class="schalter"><input id="s-beta" type="checkbox" /><i></i></label>
+                </div>
               </section>
-
-              <section class="settings-card settings-card-wide">
+              <section class="settings-card">
                 <h5>Instanzen</h5>
-                <label class="field">
-                  <span>Instanz-Verzeichnis</span>
+                <div class="s-zeile s-voll">
+                  <div class="s-text"><b>Instanz-Verzeichnis</b><small>Jede Instanz liegt hier als Unterordner mit ihrem Namen.</small></div>
                   <div class="path-row">
                     <input id="s-instances-dir" type="text" readonly />
                     <button id="s-pick-dir" class="btn">Wählen…</button>
                   </div>
-                  <small class="hint">Hier werden alle Instanzen als Unterordner mit ihrem Namen gespeichert.</small>
-                </label>
-              </section>
-
-              <section class="settings-card">
-                <h5>Bereiche</h5>
-                <label class="checkbox-field">
-                  <input id="s-bedrock" type="checkbox" /> <span>Bedrock-Bereich anzeigen</span>
-                </label>
-                <small id="s-bedrock-hint" class="hint">Wird automatisch ausgeblendet, wenn Bedrock nicht installiert ist.</small>
-              </section>
-
-              <section class="settings-card">
-                <h5>Benachrichtigungen</h5>
-                <label class="checkbox-field">
-                  <input id="s-notify" type="checkbox" /> <span>Windows-Benachrichtigung, wenn ein großer Download oder ein Backup im Hintergrund fertig wird</span>
-                </label>
-                <small class="hint">Erscheint nur, während das Launcher-Fenster nicht im Vordergrund ist.</small>
-              </section>
-
-              <section class="settings-card">
-                <h5>Freundesystem</h5>
-                <label class="checkbox-field">
-                  <input id="s-friends" type="checkbox" /> <span>Freundesystem aktivieren</span>
-                </label>
-                <small class="hint">Ausgeschaltet: du bist für niemanden sichtbar und kannst von niemandem als Freund gefunden/hinzugefügt werden. Bestehende Freundschaften bleiben erhalten, zeigen dich aber als offline.</small>
-                <label class="checkbox-field" style="margin-top:10px">
-                  <input id="s-friends-server" type="checkbox" /> <span>Server, auf dem ich spiele, für Freunde sichtbar</span>
-                </label>
-                <small class="hint">Ausgeschaltet sehen Freunde nur, dass du spielst – nicht wo. „Beitreten“ ist dann bei dir nicht möglich, Einladungen kannst du aber weiterhin verschicken.</small>
-              </section>
-
-              <section class="settings-card">
-                <h5>Autostart</h5>
-                <label class="checkbox-field">
-                  <input id="s-autostart" type="checkbox" /> <span>Mit Windows starten (im Infobereich)</span>
-                </label>
-                <small class="hint">Startet AeroMC beim Anmelden automatisch im Hintergrund. Solange aktiv, landet der Launcher beim Schließen (X) nur im Infobereich neben der Uhr, statt sich zu beenden – über das Symbol dort lässt er sich jederzeit wieder öffnen oder wirklich beenden.</small>
+                </div>
+                <div class="s-zeile">
+                  <div class="s-text"><b>Sortierung</b><small>Reihenfolge der Instanzen in der Übersicht.</small></div>
+                  <select id="s-sortby" class="s-wert">
+                    <option value="lastPlayed">Nach letztem Start</option>
+                    <option value="name">Nach Name</option>
+                  </select>
+                </div>
               </section>
             </div>
           </div>
-
           <div id="pane-appearance" class="spane hidden">
             <div class="settings-hero">
               <h4>Darstellung</h4>
-              <p>Optik der Oberfläche und visuelle Extras für die Instanzansicht.</p>
+              <p>Design, Bewegung und der Skin im Hintergrund.</p>
             </div>
             <div class="settings-grid">
-              <section class="settings-card settings-card-wide">
+              <section class="settings-card">
                 <h5>Design</h5>
                 <div class="field">
                   <select id="s-theme" class="hidden">
@@ -353,111 +344,132 @@
                 </div>
                 <small class="hint">Ein Klick zeigt das Design sofort an – mit „Speichern“ gilt es in allen Fenstern.</small>
               </section>
-
               <section class="settings-card">
-                <h5>Icons</h5>
-                <label class="checkbox-field">
-                  <input id="s-iso3d" type="checkbox" /> <span>Block-Symbole räumlich darstellen (3D)</span>
-                </label>
+                <h5>Bewegung &amp; Effekte</h5>
+                <div class="s-zeile">
+                  <div class="s-text"><b>Startanimation</b><small>Das Logo dreht sich, danach baut sich das Fenster von der Mitte aus auf. Gilt ab dem nächsten Start.</small></div>
+                  <label class="schalter"><input id="s-start-animation" type="checkbox" /><i></i></label>
+                </div>
+                <div class="s-zeile">
+                  <div class="s-text"><b>Bewegte Oberfläche</b><small>Die Skin-Figur atmet und schaut zum Mauszeiger, Fenster wachsen aus dem Knopf, Designs blenden weich über.</small></div>
+                  <label class="schalter"><input id="s-ui-animationen" type="checkbox" /><i></i></label>
+                </div>
+                <div class="s-zeile">
+                  <div class="s-text"><b>Räumliche Block-Symbole</b><small>Zeigt die Block-Symbole der Instanzen in 3D.</small></div>
+                  <label class="schalter"><input id="s-iso3d" type="checkbox" /><i></i></label>
+                </div>
               </section>
-
-              <section class="settings-card settings-card-wide">
+              <section class="settings-card">
                 <h5>Skin-Hintergrund</h5>
-                <label class="field">
-                  <span>Quelle <small class="opt">(optional)</small></span>
-                  <select id="s-bgskin"><option value="">Aus</option></select>
-                  <small class="hint">Zeigt den Minecraft-Skin des gewählten Kontos als Hintergrund im Instanzbereich.</small>
-                </label>
-                <div class="field-row">
-                  <label class="field">
-                    <span>Pose</span>
-                    <select id="s-bgskin-pose">
-                      <option value="walking">Laufend</option>
-                      <option value="standing">Stehend</option>
-                      <option value="legends">Heldenhaft</option>
-                      <option value="bedwars">Kampfhaltung</option>
-                      <option value="hoverboard">Schwebend</option>
-                      <option value="sitting">Sitzend</option>
-                      <option value="spooky">Unheimlich</option>
-                    </select>
-                  </label>
-                  <label class="field">
-                    <span>Armform</span>
-                    <select id="s-bgskin-model" title="Bei „Automatisch“ wird die Armform übernommen, die beim Konto eingestellt ist">
-                      <option value="auto">Automatisch (vom Konto)</option>
-                      <option value="classic">Normal (breite Arme, Steve)</option>
-                      <option value="slim">Schmal (Alex)</option>
-                    </select>
-                  </label>
-                  <label class="field">
-                    <span>Deckkraft: <span id="s-bgskin-val">55</span> %</span>
-                    <input id="s-bgskin-opacity" type="range" min="10" max="100" step="5" />
-                  </label>
+                <div class="s-zeile">
+                  <div class="s-text"><b>Quelle</b><small>Zeigt den Skin eines Kontos groß im Instanzbereich.</small></div>
+                  <select id="s-bgskin" class="s-wert"><option value="">Aus</option></select>
+                </div>
+                <div class="s-zeile">
+                  <div class="s-text"><b>Pose</b></div>
+                  <select id="s-bgskin-pose" class="s-wert">
+                    <option value="walking">Laufend</option>
+                    <option value="standing">Stehend</option>
+                    <option value="legends">Heldenhaft</option>
+                    <option value="bedwars">Kampfhaltung</option>
+                    <option value="hoverboard">Schwebend</option>
+                    <option value="sitting">Sitzend</option>
+                    <option value="spooky">Unheimlich</option>
+                  </select>
+                </div>
+                <div class="s-zeile">
+                  <div class="s-text"><b>Armform</b><small>„Automatisch“ übernimmt die Einstellung des Kontos.</small></div>
+                  <select id="s-bgskin-model" class="s-wert">
+                    <option value="auto">Automatisch (vom Konto)</option>
+                    <option value="classic">Normal (breite Arme, Steve)</option>
+                    <option value="slim">Schmal (Alex)</option>
+                  </select>
+                </div>
+                <div class="s-zeile">
+                  <div class="s-text"><b>Deckkraft</b></div>
+                  <div class="s-wert s-regler"><input id="s-bgskin-opacity" type="range" min="10" max="100" step="5" /><span><span id="s-bgskin-val">55</span> %</span></div>
+                </div>
+                <div class="s-zeile">
+                  <div class="s-text"><b>Konten durchwechseln</b><small>Bei 2 oder mehr angemeldeten Konten wechselt der Skin der Reihe nach.</small></div>
+                  <label class="schalter"><input id="s-bgskin-cycle" type="checkbox" /><i></i></label>
+                </div>
+                <div class="s-zeile">
+                  <div class="s-text"><b>Wechsel alle</b></div>
+                  <div class="s-wert s-einheit"><input id="s-bgskin-cycle-seconds" type="number" min="5" step="5" /><span>Sekunden</span></div>
                 </div>
-                <label class="checkbox-field">
-                  <input id="s-bgskin-cycle" type="checkbox" /> <span>Bei mehreren angemeldeten Konten automatisch durchwechseln</span>
-                </label>
-                <label class="field">
-                  <span>Wechsel alle <small class="opt">(Sekunden)</small></span>
-                  <input id="s-bgskin-cycle-seconds" type="number" min="5" step="5" />
-                  <small class="hint">Läuft nur, wenn 2 oder mehr Konten angemeldet sind, und beginnt nach dem letzten Konto wieder von vorn.</small>
-                </label>
               </section>
             </div>
           </div>
-
           <div id="pane-minecraft" class="spane hidden">
             <div class="settings-hero">
               <h4>Spiel</h4>
-              <p>Standardwerte für neue und bestehende Instanzen ohne eigene Überschreibung.</p>
+              <p>Standardwerte für alle Instanzen ohne eigene Einstellung – und was beim Spielen passiert.</p>
             </div>
             <div class="settings-grid">
               <section class="settings-card">
-                <h5>Speicher</h5>
-                <div class="field-row">
-                  <label class="field">
-                    <span>Standard-RAM min. (MB)</span>
-                    <input id="s-min-mem" type="number" min="512" step="256" />
-                  </label>
-                  <label class="field">
-                    <span>Standard-RAM max. (MB)</span>
-                    <input id="s-max-mem" type="number" min="512" step="256" />
-                  </label>
+                <h5>Leistung &amp; Fenster</h5>
+                <div class="s-zeile">
+                  <div class="s-text"><b>Arbeitsspeicher</b><small>Mindestens / höchstens, in MB.</small></div>
+                  <div class="s-wert s-paar"><input id="s-min-mem" type="number" min="512" step="256" aria-label="RAM min. (MB)" /><span>–</span><input id="s-max-mem" type="number" min="512" step="256" aria-label="RAM max. (MB)" /></div>
+                </div>
+                <div class="s-zeile">
+                  <div class="s-text"><b>Maximiert starten</b><small>Minecraft öffnet sich bildschirmfüllend.</small></div>
+                  <label class="schalter"><input id="s-mc-max" type="checkbox" /><i></i></label>
+                </div>
+                <div class="s-zeile">
+                  <div class="s-text"><b>Fenstergröße</b><small>Breite × Höhe, wenn nicht maximiert.</small></div>
+                  <div class="s-wert s-paar"><input id="s-mc-width" type="number" min="320" step="10" aria-label="Fensterbreite" /><span>×</span><input id="s-mc-height" type="number" min="240" step="10" aria-label="Fensterhöhe" /></div>
                 </div>
-                <small class="hint">Gilt für alle Instanzen ohne eigene RAM-Einstellung.</small>
               </section>
-
               <section class="settings-card">
-                <h5>Fenster</h5>
-                <label class="checkbox-field">
-                  <input id="s-mc-max" type="checkbox" /> <span>Minecraft maximiert starten</span>
-                </label>
-                <div class="field-row">
-                  <label class="field"><span>Fensterbreite</span><input id="s-mc-width" type="number" min="320" step="10" /></label>
-                  <label class="field"><span>Fensterhöhe</span><input id="s-mc-height" type="number" min="240" step="10" /></label>
+                <h5>AeroMC-Look</h5>
+                <div class="s-zeile">
+                  <div class="s-text"><b>AeroMC-Look im Spiel</b><small>Ladebildschirm und Hauptmenü im AeroMC-Look: Landschaftsbild, großes AeroMC-Logo, Knöpfe mit Symbolen und eigene Sprüche, dazu Fenstertitel und -symbol. Ab Minecraft 1.14, gilt ab dem nächsten Start – eigene Ressourcenpakete haben Vorrang.</small></div>
+                  <label class="schalter"><input id="s-aeromc-design" type="checkbox" /><i></i></label>
                 </div>
               </section>
-
               <section class="settings-card">
                 <h5>Mods</h5>
-                <label class="checkbox-field">
-                  <input id="s-auto-mod-updates" type="checkbox" /> <span>Vor jedem Start nach Mod-Updates suchen und installieren</span>
-                </label>
-                <small class="hint">Gilt für Mods aus Modrinth. Dauert die Suche länger als 20 Sekunden, startet Minecraft ohne Update. Abgeschaltete Mods bleiben abgeschaltet.</small>
+                <div class="s-zeile">
+                  <div class="s-text"><b>Mod-Updates vor dem Start</b><small>Sucht vor jedem Start nach Updates für Modrinth-Mods und installiert sie. Nach 20 Sekunden startet Minecraft ohne Update; abgeschaltete Mods bleiben aus.</small></div>
+                  <label class="schalter"><input id="s-auto-mod-updates" type="checkbox" /><i></i></label>
+                </div>
+                <div class="s-zeile">
+                  <div class="s-text"><b>Mods im Spiel verwalten</b><small>Im Pausemenü wird „Feedback geben“ zu „Mods verwalten“: Mods per Klick zwischen „Aktiv“ und „Deaktiviert“ verschieben. Das Spiel läuft weiter, die Änderung gilt ab dem nächsten Start (oder direkt mit „Übernehmen &amp; neu starten“). Nur Instanzen mit Mod-Loader.</small></div>
+                  <label class="schalter"><input id="s-mod-schalter" type="checkbox" /><i></i></label>
+                </div>
+              </section>
+              <section class="settings-card">
+                <h5>Konsole</h5>
+                <div class="s-zeile">
+                  <div class="s-text"><b>Während des Spiels anzeigen</b></div>
+                  <label class="schalter"><input id="s-console-launch" type="checkbox" /><i></i></label>
+                </div>
+                <div class="s-zeile">
+                  <div class="s-text"><b>Nach dem Beenden schließen</b></div>
+                  <label class="schalter"><input id="s-console-autoclose" type="checkbox" /><i></i></label>
+                </div>
+                <div class="s-zeile">
+                  <div class="s-text"><b>Bei einem Absturz anzeigen</b></div>
+                  <label class="schalter"><input id="s-console-crash" type="checkbox" /><i></i></label>
+                </div>
+                <div class="s-zeile">
+                  <div class="s-text"><b>Zeilen merken</b><small>Ältere Zeilen fallen aus der Konsole heraus.</small></div>
+                  <input id="s-console-lines" class="s-wert s-zahl" type="number" min="1000" step="1000" />
+                </div>
               </section>
             </div>
           </div>
-
           <div id="pane-start" class="spane hidden">
             <div class="settings-hero">
-              <h4>Start &amp; Java</h4>
-              <p>Runtime-Auswahl, Startverhalten und globale Befehle für alle Instanzen.</p>
+              <h4>Java &amp; Erweitert</h4>
+              <p>Welches Java startet und was zusätzlich vor oder nach dem Spiel läuft.</p>
             </div>
-            <div class="settings-grid settings-grid-stack">
-              <section class="settings-card settings-card-wide">
+            <div class="settings-grid">
+              <section class="settings-card">
                 <h5>Java</h5>
-                <label class="field">
-                  <span>Java (java.exe)</span>
+                <div class="s-zeile s-voll">
+                  <div class="s-text"><b>Java-Programm</b><small id="s-java-status">–</small></div>
                   <div class="path-row">
                     <input id="s-java" type="text" placeholder="leer = java aus PATH" />
                     <button id="s-pick-java" class="btn">Wählen…</button>
@@ -466,102 +478,100 @@
                     <select id="s-java-detected"><option value="">– gefundene Java-Installationen –</option></select>
                     <button id="s-scan-java" class="btn">Erkennen</button>
                   </div>
-                  <small id="s-java-status" class="hint">–</small>
-                </label>
-                <label class="checkbox-field">
-                  <input id="s-auto-java" type="checkbox" /> <span>Fehlende Java-Version automatisch herunterladen</span>
-                </label>
-                <small class="hint">Holt beim Spielstart die passende Fassung von Eclipse Temurin, wenn keine geeignete Java-Installation gefunden wird. Ablage im Launcher-Ordner, rund 45 MB je Version.</small>
+                </div>
+                <div class="s-zeile">
+                  <div class="s-text"><b>Fehlendes Java herunterladen</b><small>Holt beim Start die passende Version von Eclipse Temurin, wenn keine geeignete gefunden wird (rund 45 MB je Version).</small></div>
+                  <label class="schalter"><input id="s-auto-java" type="checkbox" /><i></i></label>
+                </div>
               </section>
-
               <section class="settings-card">
-                <h5>Konsole</h5>
-                <label class="checkbox-field">
-                  <input id="s-console-launch" type="checkbox" /> <span>Konsole anzeigen, während das Spiel läuft</span>
-                </label>
-                <label class="checkbox-field">
-                  <input id="s-console-autoclose" type="checkbox" /> <span>Konsole automatisch schließen, nachdem das Spiel beendet wurde</span>
-                </label>
-                <label class="checkbox-field">
-                  <input id="s-console-crash" type="checkbox" /> <span>Konsole anzeigen, wenn das Spiel abstürzt</span>
-                </label>
-                <label class="field">
-                  <span>Historie-Limit (Zeilen)</span>
-                  <input id="s-console-lines" type="number" min="1000" step="1000" />
-                </label>
+                <h5>Befehle</h5>
+                <small class="hint s-vorab">Für Fortgeschrittene. Befehle aus dem Bearbeiten-Dialog einer Instanz haben Vorrang.</small>
+                <div class="s-zeile">
+                  <div class="s-text"><b>Vor dem Start</b></div>
+                  <input id="s-global-pre" class="s-wert s-breit" type="text" placeholder="läuft vor jedem Spielstart" />
+                </div>
+                <div class="s-zeile">
+                  <div class="s-text"><b>Nach dem Beenden</b></div>
+                  <input id="s-global-post" class="s-wert s-breit" type="text" placeholder="läuft nach jedem Beenden" />
+                </div>
+                <div class="s-zeile">
+                  <div class="s-text"><b>Wrapper</b><small>Startet Java über dieses Programm.</small></div>
+                  <input id="s-wrapper" class="s-wert s-breit" type="text" placeholder="z. B. prime-run" />
+                </div>
               </section>
-
+            </div>
+          </div>
+          <div id="pane-online" class="spane hidden">
+            <div class="settings-hero">
+              <h4>Freunde &amp; Umhänge</h4>
+              <p>Was andere AeroMC-Spieler von dir sehen.</p>
+            </div>
+            <div class="settings-grid">
               <section class="settings-card">
-                <h5>Globale Befehle</h5>
-                <label class="field">
-                  <span>Pre-Launch-Befehl</span>
-                  <input id="s-global-pre" type="text" placeholder="läuft vor jedem Spielstart" />
-                </label>
-                <label class="field">
-                  <span>Post-Exit-Befehl</span>
-                  <input id="s-global-post" type="text" placeholder="läuft nach jedem Beenden" />
-                </label>
-                <small class="hint">Instanzspezifische Befehle aus dem Bearbeiten-Dialog haben Vorrang.</small>
+                <h5>Freundesystem</h5>
+                <div class="s-zeile">
+                  <div class="s-text"><b>Freundesystem aktivieren</b><small>Aus: niemand kann dich finden oder hinzufügen. Bestehende Freunde bleiben, sehen dich aber als offline.</small></div>
+                  <label class="schalter"><input id="s-friends" type="checkbox" /><i></i></label>
+                </div>
+                <div class="s-zeile">
+                  <div class="s-text"><b>Server für Freunde sichtbar</b><small>Aus: Freunde sehen nur, dass du spielst, nicht wo – „Beitreten“ geht dann nicht, Einladungen schon.</small></div>
+                  <label class="schalter"><input id="s-friends-server" type="checkbox" /><i></i></label>
+                </div>
               </section>
-
-              <section class="settings-card settings-card-wide">
-                <h5>Externe Programme</h5>
-                <label class="field">
-                  <span>Wrapper-Befehl</span>
-                  <input id="s-wrapper" type="text" placeholder="z. B. prime-run (leer = kein Wrapper)" />
-                </label>
-                <small class="hint">Startet Java über dieses Programm. Java-Pfad und Argumente werden automatisch angehängt.</small>
+              <section class="settings-card">
+                <h5>Umhänge</h5>
+                <div class="s-zeile">
+                  <div class="s-text"><b>AeroMC-Umhänge im Spiel</b><small>Zeigt deinen Umhang und den anderer AeroMC-Spieler – in jeder Version, mit jedem Loader, ohne Mod. Gestalten im Skin-Fenster unter „Umhang“. Gilt ab dem nächsten Start.</small></div>
+                  <label class="schalter"><input id="s-aeromc-capes" type="checkbox" /><i></i></label>
+                </div>
               </section>
             </div>
           </div>
-
           <div id="pane-network" class="spane hidden">
             <div class="settings-hero">
               <h4>Netzwerk</h4>
-              <p>Verbindungsoptionen für Downloads und externe Dienste.</p>
+              <p>Proxy für Downloads und der Zugang zu CurseForge.</p>
             </div>
             <div class="settings-grid">
-              <section class="settings-card settings-card-wide">
+              <section class="settings-card">
                 <h5>Proxy</h5>
-                <label class="checkbox-field">
-                  <input id="s-proxy-enabled" type="checkbox" /> <span>HTTP-Proxy für Downloads verwenden</span>
-                </label>
-                <div class="field-row">
-                  <label class="field"><span>Host</span><input id="s-proxy-host" type="text" placeholder="proxy.firma.de" /></label>
-                  <label class="field field-port"><span>Port</span><input id="s-proxy-port" type="text" placeholder="8080" /></label>
+                <div class="s-zeile">
+                  <div class="s-text"><b>HTTP-Proxy verwenden</b><small>Nur nötig, wenn dein Netzwerk Downloads nur über einen Proxy erlaubt.</small></div>
+                  <label class="schalter"><input id="s-proxy-enabled" type="checkbox" /><i></i></label>
                 </div>
-                <div class="field-row">
-                  <label class="field"><span>Benutzer <small class="opt">(optional)</small></span><input id="s-proxy-user" type="text" /></label>
-                  <label class="field"><span>Passwort <small class="opt">(optional)</small></span><input id="s-proxy-pass" type="password" /></label>
+                <div class="s-felder">
+                  <div class="field-row">
+                    <label class="field"><span>Host</span><input id="s-proxy-host" type="text" placeholder="proxy.firma.de" /></label>
+                    <label class="field field-port"><span>Port</span><input id="s-proxy-port" type="text" placeholder="8080" /></label>
+                  </div>
+                  <div class="field-row">
+                    <label class="field"><span>Benutzer <small class="opt">(optional)</small></span><input id="s-proxy-user" type="text" /></label>
+                    <label class="field"><span>Passwort <small class="opt">(optional)</small></span><input id="s-proxy-pass" type="password" /></label>
+                  </div>
                 </div>
               </section>
-
-              <section class="settings-card settings-card-wide">
+              <section class="settings-card">
                 <h5>CurseForge</h5>
-                <label class="field">
-                  <span>Eigener API-Key <small class="opt">(optional)</small></span>
+                <small class="hint s-vorab">Nur für CurseForge-Modpacks und -Mods nötig. Modrinth funktioniert immer ohne.</small>
+                <div class="s-zeile s-voll">
+                  <div class="s-text"><b>Eigener API-Key</b><small>Von CurseForge for Studios (Profil → Schlüssel erstellen, beginnt mit cfc_pat_…) oder ein Organisationsschlüssel. Nach dem Eintragen speichern.</small></div>
                   <div class="path-row">
                     <input id="s-cf-key" type="password" placeholder="leer lassen, um die Weiterleitung unten zu nutzen" />
                     <button type="button" id="s-cf-test" class="btn">Prüfen</button>
                   </div>
-                  <small class="hint">Schlüssel von CurseForge for Studios (Profil → Schlüssel erstellen, beginnt mit cfc_pat_…) oder klassischer Organisationsschlüssel. Nach dem Eintragen speichern. „Prüfen“ testet den Key bei CurseForge.</small>
                   <small id="s-cf-test-status" class="hint"></small>
-                </label>
-                <div class="field-row">
-                  <label class="field">
-                    <span>Weiterleitung <small class="opt">(optional)</small></span>
-                    <input id="s-cf-proxy" type="text" placeholder="https://cf.example.de" />
-                  </label>
-                  <label class="field">
-                    <span>Token <small class="opt">(falls verlangt)</small></span>
-                    <input id="s-cf-proxy-token" type="password" />
-                  </label>
                 </div>
-                <small class="hint">Ein Server, der den Schlüssel für dich hält. Ohne beides funktionieren Modrinth-Modpacks (.mrpack) weiterhin.</small>
+                <div class="s-zeile s-voll">
+                  <div class="s-text"><b>Weiterleitung</b><small>Ein Server, der den Schlüssel für dich hält.</small></div>
+                  <div class="field-row">
+                    <label class="field"><span>Adresse</span><input id="s-cf-proxy" type="text" placeholder="https://cf.example.de" /></label>
+                    <label class="field"><span>Token <small class="opt">(falls verlangt)</small></span><input id="s-cf-proxy-token" type="password" /></label>
+                  </div>
+                </div>
               </section>
             </div>
           </div>
-
           <div id="pane-accounts" class="spane hidden">
             <div class="settings-hero">
               <h4>Konten</h4>
@@ -582,66 +592,58 @@
           <div id="pane-backup" class="spane hidden">
             <div class="settings-hero">
               <h4>Backup</h4>
-              <p>Alle Instanzen gesammelt als ZIP sichern, bevor größere Änderungen anstehen.</p>
+              <p>Sicherungen aller Instanzen und deiner Welten.</p>
             </div>
             <div class="settings-grid">
-              <section class="settings-card settings-card-wide">
-                <h5>Globales Backup</h5>
-                <small class="hint">Backups werden automatisch unter Dokumente/AeroMC Launcher/Backups gespeichert. Instanzen und Launcher-Einstellungen werden gesichert. Konten und Tokens werden nicht mitgesichert.</small>
-                <div class="path-row" style="margin-top:14px">
+              <section class="settings-card">
+                <h5>Jetzt sichern</h5>
+                <div class="s-zeile">
+                  <div class="s-text"><b>Komplett-Backup</b><small>Alle Instanzen und Launcher-Einstellungen als ZIP unter Dokumente\AeroMC Launcher\Backups. Konten und Anmeldedaten werden nicht gesichert.</small></div>
                   <button id="s-backup-global" class="btn btn-primary">Backup erstellen</button>
-                  <span id="s-backup-status" class="hint">Noch kein Backup erstellt.</span>
                 </div>
+                <small id="s-backup-status" class="hint s-status">Noch kein Backup erstellt.</small>
                 <div id="s-backup-progress" class="backup-progress hidden" aria-hidden="true">
                   <div class="backup-progress-bar"><div id="s-backup-progress-fill" class="backup-progress-fill"></div></div>
                   <div id="s-backup-progress-text" class="backup-progress-text hint">0 %</div>
                 </div>
               </section>
-
-              <section class="settings-card settings-card-wide">
-                <h5>Automatisch sichern</h5>
-                <label class="checkbox-field">
-                  <input id="s-autobackup" type="checkbox" /> <span>Sicherungen nach Zeitplan erstellen</span>
-                </label>
-                <div class="field-row">
-                  <label class="field">
-                    <span>Wie oft</span>
-                    <select id="s-autobackup-every">
-                      <option value="daily">Täglich</option>
-                      <option value="weekly">Wöchentlich</option>
-                    </select>
-                  </label>
-                  <label class="field">
-                    <span>Wie viele behalten</span>
-                    <input id="s-autobackup-keep" type="number" min="1" max="50" />
-                  </label>
-                </div>
-                <label class="checkbox-field">
-                  <input id="s-autobackup-launch" type="checkbox" /> <span>Zusätzlich vor jedem Spielstart sichern</span>
-                </label>
-                <small class="hint">Eine Sicherung umfasst <em>alle</em> Instanzen und kann je nach Umfang einige Minuten dauern. Vor dem Spielstart wird sie abgewartet – der Start verzögert sich entsprechend. Ältere automatische Sicherungen werden gelöscht, sobald die eingestellte Anzahl überschritten ist.</small>
-                <small id="s-autobackup-last" class="hint">Noch keine automatische Sicherung.</small>
-              </section>
-
               <section class="settings-card">
-                <h5>Welten</h5>
-                <label class="checkbox-field">
-                  <input id="s-auto-world" type="checkbox" /> <span>Nach jeder Spielsitzung die zuletzt gespielte Welt sichern</span>
-                </label>
-                <small class="hint">Läuft im Hintergrund, sobald Minecraft beendet ist. Pro Welt bleiben die letzten 5 Stände erhalten – unter Dokumente\AeroMC Launcher\Welten-Sicherungen\&lt;Instanz&gt;\Automatisch.</small>
-              </section>
-
-              <section class="settings-card settings-card-wide">
-                <h5>Wiederherstellen</h5>
-                <small class="hint">Wähle ein Backup aus Dokumente/AeroMC Launcher/Backups aus. Achtung: Alle vorhandenen Instanzen werden beim Wiederherstellen mit dem Inhalt des Backups überschrieben. Launcher-Einstellungen werden ebenfalls wiederhergestellt. Konten und Tokens bleiben unverändert.</small>
-                <label class="field backup-select-field">
-                  <span>Verfügbares Backup</span>
-                  <select id="s-restore-backup"></select>
-                </label>
-                <div class="path-row" style="margin-top:14px">
-                  <button id="s-restore-global" class="btn">Backup wiederherstellen</button>
-                  <span id="s-restore-status" class="hint">Noch kein Backup wiederhergestellt.</span>
+                <h5>Automatisch sichern</h5>
+                <div class="s-zeile">
+                  <div class="s-text"><b>Nach Zeitplan sichern</b><small id="s-autobackup-last">Noch keine automatische Sicherung.</small></div>
+                  <label class="schalter"><input id="s-autobackup" type="checkbox" /><i></i></label>
                 </div>
+                <div class="s-zeile">
+                  <div class="s-text"><b>Wie oft</b></div>
+                  <select id="s-autobackup-every" class="s-wert">
+                    <option value="daily">Täglich</option>
+                    <option value="weekly">Wöchentlich</option>
+                  </select>
+                </div>
+                <div class="s-zeile">
+                  <div class="s-text"><b>Wie viele behalten</b><small>Ältere automatische Sicherungen werden gelöscht.</small></div>
+                  <input id="s-autobackup-keep" class="s-wert s-zahl" type="number" min="1" max="50" />
+                </div>
+                <div class="s-zeile">
+                  <div class="s-text"><b>Zusätzlich vor jedem Start</b><small>Der Start wartet, bis die Sicherung fertig ist – bei vielen Instanzen kann das einige Minuten dauern.</small></div>
+                  <label class="schalter"><input id="s-autobackup-launch" type="checkbox" /><i></i></label>
+                </div>
+                <div class="s-zeile">
+                  <div class="s-text"><b>Welt nach dem Spielen sichern</b><small>Sichert nach jeder Sitzung die zuletzt gespielte Welt im Hintergrund. Je Welt bleiben die letzten 5 Stände (Dokumente\AeroMC Launcher\Welten-Sicherungen).</small></div>
+                  <label class="schalter"><input id="s-auto-world" type="checkbox" /><i></i></label>
+                </div>
+              </section>
+              <section class="settings-card">
+                <h5>Wiederherstellen</h5>
+                <small class="hint s-vorab s-warnung">Achtung: Alle vorhandenen Instanzen und die Launcher-Einstellungen werden mit dem Inhalt des Backups überschrieben. Konten bleiben unverändert.</small>
+                <div class="s-zeile s-voll">
+                  <div class="s-text"><b>Verfügbares Backup</b></div>
+                  <div class="path-row">
+                    <select id="s-restore-backup"></select>
+                    <button id="s-restore-global" class="btn">Wiederherstellen</button>
+                  </div>
+                </div>
+                <small id="s-restore-status" class="hint s-status">Noch kein Backup wiederhergestellt.</small>
                 <div id="s-restore-progress" class="backup-progress hidden" aria-hidden="true">
                   <div class="backup-progress-bar"><div id="s-restore-progress-fill" class="backup-progress-fill"></div></div>
                   <div id="s-restore-progress-text" class="backup-progress-text hint">0 %</div>
@@ -649,7 +651,6 @@
               </section>
             </div>
           </div>
-
           <div id="pane-info" class="spane hidden">
             <div class="settings-hero">
               <h4>Info</h4>
@@ -679,6 +680,37 @@
     </div>
   </div>
 
+  <!-- ===================== Mod-Schalter (über dem laufenden Spiel) ===================== -->
+  <div id="modal-modschalter" class="modal hidden">
+    <div class="modal-card modal-lg">
+      <div class="modal-head">
+        <h3>Mods verwalten <span id="ms-instanz" class="ms-instanz"></span></h3>
+        <button class="modal-close" id="ms-x" title="Zurück ins Spiel">✕</button>
+      </div>
+      <div class="modal-body ms-body">
+        <div class="ms-kopf">
+          <input id="ms-suche" type="search" placeholder="Mods durchsuchen …" autocomplete="off" />
+          <span id="ms-hinweis" class="hint"></span>
+        </div>
+        <div class="ms-spalten">
+          <section class="ms-spalte">
+            <div class="ms-titel">Aktive Mods <span id="ms-zahl-an" class="group-count"></span></div>
+            <div id="ms-an" class="ms-liste" role="list"></div>
+          </section>
+          <section class="ms-spalte">
+            <div class="ms-titel">Deaktivierte Mods <span id="ms-zahl-aus" class="group-count"></span></div>
+            <div id="ms-aus" class="ms-liste" role="list"></div>
+          </section>
+        </div>
+      </div>
+      <div class="modal-foot">
+        <span id="ms-status" class="hint ms-status"></span>
+        <button class="btn" id="ms-fertig">Zurück ins Spiel</button>
+        <button class="btn btn-primary hidden" id="ms-neustart" title="Minecraft speichert, beendet sich und startet mit den neuen Mods direkt wieder – in derselben Welt bzw. auf demselben Server">Übernehmen &amp; neu starten</button>
+      </div>
+    </div>
+  </div>
+
   <!-- ===================== Dialog: Bestätigung ===================== -->
   <div id="modal-confirm" class="modal hidden">
     <div class="modal-card modal-sm">
@@ -799,6 +831,7 @@
       </div>
       <div class="modal-foot">
         <button id="m-open-folder" class="btn" data-ic="folder">mods-Ordner</button>
+        <button id="m-leistung" class="btn" title="Bewährte Performance-Mods passend zu Version und Loader installieren (Sodium, Lithium, FerriteCore …)">⚡ Leistungs-Paket</button>
         <div class="spacer"></div>
         <button class="btn" data-close>Schließen</button>
       </div>
@@ -1093,10 +1126,19 @@
         <button class="modal-close" data-close>✕</button>
       </div>
       <div class="modal-body">
-        <div id="stats-tiles" class="stats-tiles"></div>
-        <div class="friends-section-title">Spielzeit pro Instanz</div>
-        <div id="stats-list" class="stats-list" role="list"></div>
-        <p id="stats-unplayed" class="hint"></p>
+        <div class="mods-tabs stats-tabs">
+          <button class="mtab on" data-stats-reiter="spielzeit">Spielzeit</button>
+          <button class="mtab" data-stats-reiter="erfolge">Erfolge <span id="erfolge-zahl"></span></button>
+        </div>
+        <div id="stats-reiter-spielzeit">
+          <div id="stats-tiles" class="stats-tiles"></div>
+          <div class="friends-section-title">Spielzeit pro Instanz</div>
+          <div id="stats-list" class="stats-list" role="list"></div>
+          <p id="stats-unplayed" class="hint"></p>
+        </div>
+        <div id="stats-reiter-erfolge" class="hidden">
+          <div id="erfolge-liste" class="erfolge-liste"></div>
+        </div>
       </div>
       <div class="modal-foot">
         <div class="spacer"></div>
@@ -1114,13 +1156,20 @@
       </div>
       <div class="modal-body">
         <p id="friends-disabled-hint" class="hint hidden">Das Freundesystem ist ausgeschaltet – aktiviere es in den Einstellungen, um Freunde zu sehen oder hinzuzufügen.</p>
-        <div id="friends-content">
-          <div class="field-row">
-            <input id="friends-add-input" type="text" placeholder="Minecraft-Name…" maxlength="16" />
-            <button id="friends-add-btn" class="btn btn-mini">Anfrage senden</button>
+        <div id="friends-content" class="freunde-raster">
+          <div class="freunde-spalte">
+            <div class="field-row">
+              <input id="friends-add-input" type="text" placeholder="Minecraft-Name…" maxlength="16" />
+              <button id="friends-add-btn" class="btn btn-mini">Anfrage senden</button>
+            </div>
+            <div id="friends-requests-box"></div>
+            <div id="friends-list-box"></div>
+          </div>
+          <!-- 3D-Figur des ausgewählten Freundes (Skin + Umhang), neben der Liste -->
+          <div id="freund-buehne" class="freund-buehne hidden">
+            <canvas id="freund-figur"></canvas>
+            <div class="freund-buehne-text"><b id="freund-buehne-name"></b><span id="freund-buehne-status"></span></div>
           </div>
-          <div id="friends-requests-box"></div>
-          <div id="friends-list-box"></div>
         </div>
         <!-- Unterhaltung mit einem Freund -->
         <div id="friends-chat" class="friends-chat hidden">
@@ -1220,6 +1269,10 @@
       </div>
       <div class="modal-body">
         <p id="skin-konto" class="hint">–</p>
+        <div id="skin-armform-hinweis" class="skin-armform-hinweis hidden">
+          <span id="skin-armform-text"></span>
+          <button id="skin-armform-fix" class="btn btn-mini btn-primary"></button>
+        </div>
         <div class="skin-vorschau">
           <div class="skin-spalte">
             <div class="skin-label">Aktuell</div>
@@ -1249,6 +1302,38 @@
           </select>
         </label>
         <p id="skin-status" class="hint"></p>
+        <div class="skin-umhang">
+          <div class="skin-label">Umhang</div>
+          <div class="field-row">
+            <label class="field">
+              <span>Offizieller Umhang <small class="opt">(im Spiel für alle sichtbar)</small></span>
+              <select id="skin-cape-offiziell" title="Nur Umhänge, die dein Konto bei Mojang besitzt">
+                <option value="">Kein Umhang</option>
+              </select>
+            </label>
+            <div class="field">
+              <span>AeroMC-Umhang <small class="opt">(eigener, auch HD)</small></span>
+              <div class="skin-umhang-aero">
+                <span id="skin-cape-aero" class="hint">–</span>
+                <button id="skin-cape-edit" class="btn btn-mini" title="Im Skin-Editor einen eigenen Umhang gestalten">Gestalten…</button>
+                <button id="skin-cape-remove" class="btn btn-mini btn-danger hidden">Entfernen</button>
+              </div>
+            </div>
+          </div>
+          <small id="skin-cape-status" class="hint">Den AeroMC-Umhang sehen im Spiel alle, die AeroMC nutzen oder den Mod „AeroMC Umhänge“ (Fabric/Quilt) installiert haben – dort hat er Vorrang vor dem offiziellen.</small>
+        </div>
+
+        <div class="skin-garderobe">
+          <div class="garderobe-kopf">
+            <div class="skin-label">Garderobe <small class="opt">(gespeicherte Skins und Umhänge – mit einem Klick wieder anziehen)</small></div>
+            <div class="garderobe-knoepfe">
+              <button id="gard-skin-speichern" class="btn btn-mini" title="Den Skin, den du gerade trägst, in der Garderobe ablegen">Aktuellen Skin speichern</button>
+              <button id="gard-umhang-speichern" class="btn btn-mini" title="Deinen eigenen AeroMC-Umhang in der Garderobe ablegen">Aktuellen Umhang speichern</button>
+            </div>
+          </div>
+          <div id="garderobe-liste" class="garderobe-liste"></div>
+          <small class="hint">Vor jedem Skinwechsel im Launcher wird der bisherige Skin automatisch hier gesichert – Mojang selbst merkt sich keine alten Skins.</small>
+        </div>
       </div>
       <div class="modal-foot">
         <button id="skin-reset" class="btn btn-danger">Auf Standard zurücksetzen</button>
@@ -1268,6 +1353,7 @@
         <div class="se-modus">
           <button class="se-modus-btn on" data-se-modus="2d" title="Auf der aufgeklappten Vorlage malen">2D-Vorlage</button>
           <button class="se-modus-btn" data-se-modus="3d" title="Direkt auf der drehbaren Figur malen">3D-Figur</button>
+          <button class="se-modus-btn" data-se-modus="umhang" title="Eigenen Umhang (auch HD) gestalten">Umhang</button>
         </div>
         <button class="modal-close" data-close>✕</button>
       </div>
@@ -1290,7 +1376,7 @@
             </div>
             <div id="se-zuletzt" class="se-zuletzt"></div>
           </div>
-          <div class="se-gruppe">
+          <div id="se-gruppe-ebene" class="se-gruppe">
             <div class="se-titel">Ebene</div>
             <div class="se-ebenen">
               <button class="se-ebene on" data-se-schicht="0" title="Die eigentliche Figur (L wechselt)">Grundschicht</button>
@@ -1300,6 +1386,30 @@
             <label class="se-check"><input id="se-durch" type="checkbox" checked /> Grundschicht durchscheinen</label>
             <button id="se-leeren" class="btn btn-mini">2. Schicht leeren</button>
           </div>
+          <div id="se-gruppe-umhang" class="se-gruppe hidden">
+            <div class="se-titel">Umhang</div>
+            <label class="se-feld"><span>Größe</span>
+              <select id="se-u-groesse" title="Größere Umhänge (HD) erlauben feinere Motive">
+                <option value="64">Normal (64×32)</option>
+                <option value="128">HD 128×64</option>
+                <option value="256">HD 256×128</option>
+                <option value="512">HD 512×256</option>
+                <option value="1024">HD 1024×512</option>
+              </select>
+            </label>
+            <label class="se-feld"><span>Pinselgröße</span>
+              <select id="se-u-pinsel">
+                <option value="1">1 Pixel</option>
+                <option value="2">2 Pixel</option>
+                <option value="4">4 Pixel</option>
+                <option value="8">8 Pixel</option>
+                <option value="16">16 Pixel</option>
+              </select>
+            </label>
+            <button id="se-u-bild" class="btn btn-mini" title="Ein beliebiges Bild (PNG, JPG …) auf die Außenseite setzen">Bild einsetzen…</button>
+            <label class="se-check" title="Dieselbe Datei trägt auch die Elytra"><input id="se-u-elytra" type="checkbox" /> Als Elytra zeigen</label>
+            <button id="se-u-einpassen" class="btn btn-mini" title="Zoom zurücksetzen (Taste 0)">Ansicht einpassen</button>
+          </div>
           <div class="se-gruppe">
             <div class="se-titel">Optionen</div>
             <label class="se-check" title="Malt gleichzeitig auf der anderen Körperseite (M)"><input id="se-spiegeln" type="checkbox" /> Spiegeln (links ↔ rechts)</label>
@@ -1319,6 +1429,10 @@
           <div id="se-buehne" class="se-buehne">
             <div id="se-2d" class="se-ansicht se-2d"><canvas id="se-2d-canvas"></canvas></div>
           </div>
+          <!-- gerade nicht gezeigte Ansichten (je nach Modus) -->
+          <div id="se-ablage" class="se-ablage">
+            <div id="se-u2d" class="se-ansicht se-u2d"><canvas id="se-u2d-canvas"></canvas></div>
+          </div>
           <div id="se-info" class="se-info hint"></div>
         </section>
         <aside class="se-seite">
@@ -1326,7 +1440,7 @@
           <div id="se-mini" class="se-mini">
             <div id="se-3d" class="se-ansicht se-3d"><canvas id="se-3d-canvas"></canvas><span id="se-3d-leer" class="hint se-3d-leer">wird geladen …</span></div>
           </div>
-          <p class="hint se-tipp">Beide Ansichten sind bemalbar. Die <b>2. Schicht</b> liegt wie eine Hülle über der Figur – lässt man Pixel darin frei, wirken Haare, Kapuzen oder Ärmel plastisch.</p>
+          <p id="se-tipp" class="hint se-tipp">Beide Ansichten sind bemalbar. Die <b>2. Schicht</b> liegt wie eine Hülle über der Figur – lässt man Pixel darin frei, wirken Haare, Kapuzen oder Ärmel plastisch.</p>
         </aside>
       </div>
       <div class="modal-foot se-fuss">
@@ -1490,6 +1604,16 @@
           <button id="import-tab-code" class="mtab" data-kind="code">Per Code</button>
         </div>
 
+        <div id="import-lauf" class="import-lauf hidden">
+          <div class="import-lauf-kopf">
+            <b id="import-lauf-titel">Wird vorbereitet …</b>
+            <button id="import-lauf-abbrechen" class="btn btn-mini btn-danger" title="Bricht den Import ab – die gerade halb kopierte Instanz wird wieder entfernt, fertig übernommene bleiben">Abbrechen</button>
+          </div>
+          <div class="import-balken"><i id="import-lauf-balken"></i></div>
+          <div id="import-lauf-zeile" class="import-lauf-zeile"></div>
+          <div id="import-lauf-datei" class="hint import-lauf-datei"></div>
+        </div>
+
         <div id="import-pane-zip" class="import-pane">
           <p class="import-copy">Importiert eine einzelne Instanz aus einem ZIP-Archiv.</p>
           <p class="hint">Erkannt werden AeroMC-Exporte (instance.json) und einzelne MultiMC- oder Prism-Instanzen (instance.cfg) – letztere auch als gezippter Instanzordner. Der Launcher legt daraus automatisch eine neue Instanz an, samt Mods, Welten und Konfiguration.</p>
@@ -1770,6 +1894,12 @@
     </div>
   </div>
 
+  <!-- Erfolg-Meldungen im Minecraft-Stil (oben rechts) -->
+  <div id="erfolg-meldungen" class="erfolg-meldungen"></div>
+
+  <!-- Konto-Menü (Klick auf den Kontoknopf oben rechts) -->
+  <div id="konto-menu" class="ctx konto-menu hidden" role="menu"></div>
+
   <div id="ctx-menu" class="ctx hidden">
     <button class="ctx-item" data-act="p-edit">Symbol ändern</button>
     <button class="ctx-item" data-act="p-edit">Umbenennen</button>

src/integritaet.js

@@ -0,0 +1,362 @@
+'use strict';
+
+/*
+ * integritaet.js – Manipulationsschutz für Instanzen
+ * --------------------------------------------------
+ * Für jede Instanz hält der Launcher ein "Siegel" fest:
+ *   - die Startdaten aus instance.json, mit denen sich Code ausführen ließe
+ *     (Java-Pfad, JVM-Argumente, Befehle vor dem Start / nach dem Beenden)
+ *   - den SHA-256 jeder Mod-Datei im mods-Ordner
+ * Das Siegel ist mit einem geheimen Schlüssel unterschrieben (HMAC), der per
+ * Windows-DPAPI verschlüsselt im Datenordner liegt.
+ *
+ * Als Manipulation gilt:
+ *   - eine bekannte Mod-Datei hat bei gleichem Namen einen anderen Inhalt
+ *     (so arbeitet Jar-infizierende Schadsoftware wie "Fractureiser")
+ *   - die Startdaten wurden außerhalb des Launchers geändert
+ *   - das Siegel selbst wurde verändert
+ * Keine Manipulation: neue, gelöschte, aktivierte oder deaktivierte Mods – das
+ * ist der normale Weg, Mods per Explorer hinzuzufügen oder zu entfernen.
+ *
+ * Eine manipulierte Instanz wird gesperrt: Sie bleibt erhalten, lässt sich aber
+ * nicht mehr starten, kopieren, exportieren oder teilen. Der Spieler kann sie
+ * aus einer sauberen Sicherung als neue Instanz wiederherstellen und muss die
+ * gesperrte selbst löschen.
+ *
+ * Ehrlich gesagt: Ein Schadprogramm, das gezielt AeroMC angreift und unter
+ * demselben Windows-Konto läuft, kann auch den DPAPI-Schlüssel benutzen. Gegen
+ * allgemeine Jar-Infektionen, fremde Tools und Hände am Dateisystem hilft es.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+const ENC = 'enc:v1:';
+const MOD_ENDUNGEN = /\.(jar|zip|litemod)(\.disabled)?$/i;
+
+let datenOrdner = null;
+let store = null;
+let schluessel = null;
+let zustand = { version: 1, instanzen: {} };
+// Pfad -> { groesse, zeit, hash }: nur für die schnelle Prüfung beim Launcher-Start
+let hashCache = new Map();
+
+function zustandsDatei() { return path.join(datenOrdner, 'integritaet.json'); }
+function schluesselDatei() { return path.join(datenOrdner, 'integritaet.key'); }
+
+function init(userData, tresor, storeModul) {
+  datenOrdner = userData;
+  store = storeModul;
+  schluessel = ladeSchluessel(tresor);
+  if (!schluessel) return;
+  let roh = null;
+  try { roh = JSON.parse(fs.readFileSync(zustandsDatei(), 'utf8')); } catch { /* erster Start oder Datei fehlt */ }
+  zustand = { version: 1, instanzen: (roh && roh.instanzen && typeof roh.instanzen === 'object') ? roh.instanzen : {} };
+  // Siegel und Sperre sind getrennt unterschrieben: Wer nur die Sperre aus der
+  // Datei löscht, bekommt sie zurück – der gute Stand (für die Prüfung der
+  // Sicherungen) bleibt dabei gültig. Wer am Siegel selbst dreht, verliert ihn.
+  const jetzt = () => new Date().toISOString();
+  for (const [id, e] of Object.entries(zustand.instanzen)) {
+    if (!e || e.mac !== siegelMac(id, e)) {
+      zustand.instanzen[id] = versiegeltEintrag(id, {
+        felder: {}, dateien: {},
+        gesperrt: { seit: jetzt(), gruende: ['Das Siegel dieser Instanz wurde verändert.'] },
+      });
+    } else if (e.sperrMac !== sperrMac(id, e.gesperrt)) {
+      zustand.instanzen[id] = versiegeltEintrag(id, {
+        felder: e.felder, dateien: e.dateien,
+        gesperrt: (e.gesperrt && e.gesperrt.seit) ? e.gesperrt
+          : { seit: jetzt(), gruende: ['Die Sperre dieser Instanz wurde von Hand aufgehoben.'] },
+      });
+    }
+  }
+  // Liste aller versiegelten Instanzen: ein gelöschter Eintrag fällt auf
+  if (roh && Array.isArray(roh.ids) && roh.idsMac === listenMac(roh.ids)) {
+    for (const id of roh.ids) {
+      if (!zustand.instanzen[id]) {
+        zustand.instanzen[id] = versiegeltEintrag(id, {
+          felder: {}, dateien: {},
+          gesperrt: { seit: jetzt(), gruende: ['Das Siegel dieser Instanz wurde entfernt.'] },
+        });
+      }
+    }
+  }
+  speichere();
+}
+
+function ladeSchluessel(tresor) {
+  const verfuegbar = (() => { try { return !!(tresor && tresor.available()); } catch { return false; } })();
+  if (fs.existsSync(schluesselDatei())) {
+    try {
+      const inhalt = fs.readFileSync(schluesselDatei(), 'utf8').trim();
+      const roh = inhalt.startsWith(ENC) ? tresor.decrypt(inhalt.slice(ENC.length)) : inhalt;
+      const s = Buffer.from(roh, 'hex');
+      if (s.length === 32) return s;
+      throw new Error('falsche Länge');
+    } catch (err) {
+      // Vorhanden, aber nicht lesbar (z. B. Datenordner von einem anderen PC
+      // kopiert). Nicht einfach neu anlegen – dann sähen ALLE Siegel verändert
+      // aus und jede Instanz wäre gesperrt. Schutz bleibt dann aus.
+      console.warn('Integritäts-Schlüssel nicht lesbar – Manipulationsschutz inaktiv:', err.message);
+      return null;
+    }
+  }
+  const neu = crypto.randomBytes(32);
+  const text = verfuegbar ? ENC + tresor.encrypt(neu.toString('hex')) : neu.toString('hex');
+  fs.mkdirSync(datenOrdner, { recursive: true });
+  fs.writeFileSync(schluesselDatei(), text);
+  return neu;
+}
+
+function speichere() {
+  const tmp = zustandsDatei() + '.tmp';
+  const ids = Object.keys(zustand.instanzen).sort();
+  fs.writeFileSync(tmp, JSON.stringify(Object.assign({}, zustand, { ids, idsMac: listenMac(ids) }), null, 1));
+  fs.renameSync(tmp, zustandsDatei());
+}
+
+function sortiert(obj) {
+  return Object.keys(obj || {}).sort().map((k) => [k, obj[k]]);
+}
+
+function hmac(daten) {
+  return crypto.createHmac('sha256', schluessel).update(JSON.stringify(daten)).digest('hex');
+}
+function siegelMac(id, e) { return hmac(['siegel', id, sortiert(e.felder), sortiert(e.dateien)]); }
+function sperrMac(id, gesperrt) { return hmac(['sperre', id, gesperrt || null]); }
+function listenMac(ids) { return hmac(['liste', ids]); }
+
+function versiegeltEintrag(id, e) {
+  const eintrag = { felder: e.felder, dateien: e.dateien, gesperrt: e.gesperrt || null, stand: new Date().toISOString() };
+  eintrag.mac = siegelMac(id, eintrag);
+  eintrag.sperrMac = sperrMac(id, eintrag.gesperrt);
+  return eintrag;
+}
+
+// Die sicherheitsrelevanten Startdaten einer Instanz
+function startDaten(inst) {
+  const j = (inst && inst.java) || {};
+  return {
+    javaPfad: String(j.path || ''),
+    jvmArgumente: String(j.extraArgs || ''),
+    vorStart: String((inst && inst.preLaunchCommand) || ''),
+    nachEnde: String((inst && inst.postExitCommand) || ''),
+  };
+}
+
+const FELD_NAMEN = {
+  javaPfad: 'Java-Pfad', jvmArgumente: 'JVM-Argumente', vorStart: 'Befehl vor dem Start', nachEnde: 'Befehl nach dem Beenden',
+};
+
+// Alle Mod-Dateien (auch Unterordner wie mods/1.12.2/). Schlüssel ohne
+// ".disabled" und in Kleinbuchstaben – Umschalten ist keine Veränderung.
+function modDateien(gameDir) {
+  const basis = path.join(gameDir, 'mods');
+  const ergebnis = {};
+  const lauf = (ordner, tiefe) => {
+    let eintraege;
+    try { eintraege = fs.readdirSync(ordner, { withFileTypes: true }); } catch { return; }
+    for (const e of eintraege) {
+      const voll = path.join(ordner, e.name);
+      if (e.isDirectory()) { if (tiefe < 2) lauf(voll, tiefe + 1); continue; }
+      if (!e.isFile() || !MOD_ENDUNGEN.test(e.name)) continue;
+      const rel = path.relative(basis, voll).replace(/\\/g, '/');
+      ergebnis[rel.replace(/\.disabled$/i, '').toLowerCase()] = voll;
+    }
+  };
+  lauf(basis, 0);
+  return ergebnis;
+}
+
+function hashDatei(datei) {
+  return new Promise((resolve, reject) => {
+    const h = crypto.createHash('sha256');
+    fs.createReadStream(datei).on('error', reject).on('data', (d) => h.update(d)).on('end', () => resolve(h.digest('hex')));
+  });
+}
+
+// schnell=true: unveränderte Größe+Zeit -> Hash aus dem Zwischenspeicher
+async function hashe(datei, schnell) {
+  const st = fs.statSync(datei);
+  const c = hashCache.get(datei);
+  if (schnell && c && c.groesse === st.size && c.zeit === st.mtimeMs) return c.hash;
+  const hash = await hashDatei(datei);
+  hashCache.set(datei, { groesse: st.size, zeit: st.mtimeMs, hash });
+  return hash;
+}
+
+async function aktuellerStand(id, schnell) {
+  const inst = store.getInstance(id);
+  if (!inst) return null;
+  const dateien = {};
+  for (const [schl, voll] of Object.entries(modDateien(store.gameDir(id)))) {
+    try { dateien[schl] = await hashe(voll, schnell); } catch { /* gesperrt/weg -> beim nächsten Mal */ }
+  }
+  return { felder: startDaten(inst), dateien };
+}
+
+function status(id) {
+  const e = zustand.instanzen[id];
+  return e && e.gesperrt ? { gesperrt: true, seit: e.gesperrt.seit, gruende: e.gesperrt.gruende } : { gesperrt: false };
+}
+
+function istGesperrt(id) { return status(id).gesperrt; }
+
+function sperre(id, gruende) {
+  if (!schluessel) return;
+  const e = zustand.instanzen[id] || { felder: {}, dateien: {} };
+  // das letzte gute Siegel bleibt stehen – daran wird eine Sicherung gemessen
+  zustand.instanzen[id] = versiegeltEintrag(id, {
+    felder: e.felder, dateien: e.dateien,
+    gesperrt: { seit: new Date().toISOString(), gruende },
+  });
+  speichere();
+}
+
+/*
+ * Prüft eine Instanz gegen ihr Siegel.
+ * -> { status: 'ok' | 'neu' | 'gesperrt', gruende?, neuGesperrt? }
+ * Ohne Befund werden neue und entfernte Mods ins Siegel übernommen.
+ */
+async function pruefe(id, { schnell = false } = {}) {
+  if (!schluessel) return { status: 'ok' };
+  const vorhanden = zustand.instanzen[id];
+  if (vorhanden && vorhanden.gesperrt) return { status: 'gesperrt', gruende: vorhanden.gesperrt.gruende };
+  const jetzt = await aktuellerStand(id, schnell);
+  if (!jetzt) return { status: 'ok' };
+  if (!vorhanden) {
+    zustand.instanzen[id] = versiegeltEintrag(id, jetzt);
+    speichere();
+    return { status: 'neu' };
+  }
+  const gruende = [];
+  for (const [k, name] of Object.entries(FELD_NAMEN)) {
+    if ((vorhanden.felder[k] || '') !== jetzt.felder[k]) gruende.push(`${name} wurde außerhalb des Launchers geändert.`);
+  }
+  for (const [datei, hash] of Object.entries(jetzt.dateien)) {
+    if (vorhanden.dateien[datei] && vorhanden.dateien[datei] !== hash) gruende.push(`Mod-Datei verändert: ${datei}`);
+  }
+  if (gruende.length) {
+    sperre(id, gruende);
+    return { status: 'gesperrt', gruende, neuGesperrt: true };
+  }
+  const geaendert = JSON.stringify(sortiert(vorhanden.dateien)) !== JSON.stringify(sortiert(jetzt.dateien));
+  if (geaendert) {
+    zustand.instanzen[id] = versiegeltEintrag(id, jetzt);
+    speichere();
+  }
+  return { status: 'ok' };
+}
+
+// Nach einer Änderung durch den Launcher selbst (Mod-Update, Bearbeiten …)
+async function versiegele(id) {
+  if (!schluessel) return;
+  if (istGesperrt(id)) return;
+  const jetzt = await aktuellerStand(id, false);
+  if (!jetzt) return;
+  zustand.instanzen[id] = versiegeltEintrag(id, jetzt);
+  speichere();
+}
+
+function entferne(id) {
+  if (!schluessel) return;
+  if (!zustand.instanzen[id]) return;
+  delete zustand.instanzen[id];
+  speichere();
+}
+
+function alleGesperrten() {
+  const r = {};
+  for (const [id, e] of Object.entries(zustand.instanzen)) if (e.gesperrt) r[id] = { seit: e.gesperrt.seit, gruende: e.gesperrt.gruende };
+  return r;
+}
+
+// Das letzte gute Siegel (für die Prüfung einer Sicherung)
+function gutesSiegel(id) {
+  const e = zustand.instanzen[id];
+  return e ? { felder: e.felder, dateien: e.dateien } : null;
+}
+
+// ---------------------------------------------------------------------------
+// Wiederherstellen aus einer Sicherung (AeroMC-Backup-*.zip, siehe backup.js)
+// ---------------------------------------------------------------------------
+
+const unterPfad = (p) => String(p || '').replace(/\\/g, '/');
+
+/*
+ * Neueste Sicherung, in der die Instanz steckt UND deren Mods zum letzten
+ * guten Siegel passen. Eine Sicherung, die erst nach der Manipulation entstand,
+ * enthält die veränderte Datei und wird übersprungen.
+ * backupPfade: neueste zuerst
+ */
+async function sucheSaubereSicherung(id, backupPfade) {
+  const unzipper = require('unzipper');
+  const gut = gutesSiegel(id);
+  const praefix = `instances/${id}/`;
+  const uebersprungen = [];
+  for (const zip of backupPfade) {
+    let verzeichnis;
+    try { verzeichnis = await unzipper.Open.file(zip); } catch { continue; }
+    const eintraege = verzeichnis.files.filter((f) => f.type === 'File' && unterPfad(f.path).startsWith(praefix));
+    if (!eintraege.some((f) => unterPfad(f.path) === praefix + 'instance.json')) continue;
+    let sauber = true;
+    for (const f of eintraege) {
+      const m = unterPfad(f.path).slice(praefix.length).match(/^minecraft\/mods\/(.+)$/i);
+      if (!m || !MOD_ENDUNGEN.test(m[1])) continue;
+      const schl = m[1].replace(/\.disabled$/i, '').toLowerCase();
+      if (!gut || !gut.dateien[schl]) continue;
+      const hash = crypto.createHash('sha256').update(await f.buffer()).digest('hex');
+      if (hash !== gut.dateien[schl]) { sauber = false; break; }
+    }
+    if (sauber) return { zip, eintraege, praefix, uebersprungen };
+    uebersprungen.push(path.basename(zip));
+  }
+  return { zip: null, uebersprungen };
+}
+
+/*
+ * Stellt die Instanz als NEUE Instanz "<Name> (wiederhergestellt)" wieder her.
+ * Die gesperrte bleibt unangetastet liegen.
+ */
+async function stelleWiederHer(id, backupPfade) {
+  const { pipeline } = require('stream/promises');
+  const fund = await sucheSaubereSicherung(id, backupPfade);
+  if (!fund.zip) {
+    throw new Error(fund.uebersprungen.length
+      ? `Keine saubere Sicherung gefunden – ${fund.uebersprungen.length} Sicherung(en) enthalten bereits die veränderten Dateien.`
+      : 'Keine Sicherung mit dieser Instanz gefunden. Sicherungen lassen sich unter Optionen → Sicherung anlegen.');
+  }
+  const alt = store.getInstance(id);
+  const name = `${(alt && alt.name) || id} (wiederhergestellt)`;
+  const neuId = store.uniqueFolderId(name);
+  const ziel = store.instancePath(neuId);
+  fs.mkdirSync(ziel, { recursive: true });
+  for (const f of fund.eintraege) {
+    const rel = unterPfad(f.path).slice(fund.praefix.length);
+    const dest = path.join(ziel, ...rel.split('/'));
+    if (!dest.startsWith(ziel + path.sep)) continue;   // nichts außerhalb des Ordners
+    fs.mkdirSync(path.dirname(dest), { recursive: true });
+    await pipeline(f.stream(), fs.createWriteStream(dest));
+  }
+  const datei = path.join(ziel, 'instance.json');
+  const inst = JSON.parse(fs.readFileSync(datei, 'utf8'));
+  inst.id = neuId;
+  inst.name = name;
+  // Startdaten auf den letzten geprüften Stand setzen
+  const gut = gutesSiegel(id);
+  if (gut && gut.felder && Object.keys(gut.felder).length) {
+    inst.java = Object.assign({}, inst.java, { path: gut.felder.javaPfad || '', extraArgs: gut.felder.jvmArgumente || '' });
+    inst.preLaunchCommand = gut.felder.vorStart || '';
+    inst.postExitCommand = gut.felder.nachEnde || '';
+  }
+  fs.writeFileSync(datei, JSON.stringify(inst, null, 2));
+  await versiegele(neuId);
+  return { id: neuId, name, sicherung: path.basename(fund.zip), uebersprungen: fund.uebersprungen };
+}
+
+module.exports = {
+  init, pruefe, versiegele, sperre, status, istGesperrt, entferne, alleGesperrten, gutesSiegel,
+  sucheSaubereSicherung, stelleWiederHer,
+  startDaten, modDateien, hashDatei, FELD_NAMEN,
+};

src/javadl.js

@@ -13,6 +13,14 @@
 const fs = require('fs');
 const path = require('path');
 const unzipper = require('unzipper');
+const crypto = require('crypto');
+
+function sha256Datei(datei) {
+  return new Promise((resolve, reject) => {
+    const h = crypto.createHash('sha256');
+    fs.createReadStream(datei).on('error', reject).on('data', (d) => h.update(d)).on('end', () => resolve(h.digest('hex')));
+  });
+}
 
 const API = 'https://api.adoptium.net/v3';
 const UA = 'AeroMC-Launcher';
@@ -193,6 +201,11 @@ async function ensureJava(major, onProgress) {
   try {
     if (onProgress) onProgress({ phase: 'java-download', geladen: 0, gesamt: release.size, percent: 0 });
     await ladeDatei(release.url, tmpZip, onProgress);
+    // Adoptium nennt zu jedem Paket die SHA-256 – ohne passende Prüfsumme wird
+    // keine Java-Laufzeit entpackt (sie würde später jedes Spiel ausführen)
+    const soll = String(release.sha256 || '').toLowerCase();
+    if (!/^[0-9a-f]{64}$/.test(soll)) throw new Error('Adoptium hat keine Prüfsumme für dieses Java-Paket geliefert – Download verworfen.');
+    if (await sha256Datei(tmpZip) !== soll) throw new Error('Prüfsumme des Java-Downloads stimmt nicht – Datei verworfen (beschädigt oder manipuliert).');
     // in einen Nebenordner entpacken und erst am Ende umbenennen -> kein
     // halbfertiges Java, falls unterwegs etwas schiefgeht
     const tmpDir = ziel + '.teil';

src/kopieren.js

@@ -0,0 +1,182 @@
+/*
+ * Große Ordner kopieren, ohne den Launcher einzufrieren.
+ *
+ * Früher liefen Importe mit fs.cpSync – synchron im Hauptprozess. Bei
+ * Spielständen mit vielen Gigabyte stand dann der komplette Launcher
+ * minutenlang still (keine Anzeige, kein Abbrechen, „Keine Rückmeldung“).
+ *
+ * Hier wird asynchron gearbeitet: erst Dateien und Größe zählen, dann mit
+ * mehreren Dateien gleichzeitig kopieren. Große Dateien gehen stückweise, damit
+ * der Fortschritt auch bei einer einzelnen 4-GB-Datei weiterläuft. Gesperrte
+ * Einzeldateien werden übersprungen und gemeldet statt alles abzubrechen.
+ */
+const fs = require('fs');
+const fsp = fs.promises;
+const path = require('path');
+const { pipeline } = require('stream/promises');
+
+const GLEICHZEITIG = 8;                    // Dateien parallel
+const STUECKWEISE_AB = 64 * 1024 * 1024;   // ab hier mit Zwischenständen kopieren
+const MAX_TIEFE = 64;                      // Schutz vor Verknüpfungs-Schleifen
+const MELDE_ALLE_MS = 200;
+
+class Abgebrochen extends Error {
+  constructor() { super('Vom Nutzer abgebrochen.'); this.abgebrochen = true; }
+}
+
+// Ordner-/Dateieintrag auflösen (Verknüpfungen werden wie ihr Ziel behandelt –
+// die Modrinth App verlinkt z. B. Dateien aus ihrem gemeinsamen Speicher)
+async function art(voll, eintrag) {
+  if (!eintrag.isSymbolicLink()) return { ordner: eintrag.isDirectory(), datei: eintrag.isFile() };
+  const st = await fsp.stat(voll).catch(() => null);
+  return st ? { ordner: st.isDirectory(), datei: st.isFile() } : { ordner: false, datei: false };
+}
+
+/** Zählt Dateien und Bytes unter allen Quellen (Dateien oder Ordner). */
+async function zaehle(quellen, job, melde) {
+  const summe = { dateien: 0, bytes: 0 };
+  let zuletzt = 0;
+  async function lauf(voll, tiefe) {
+    if (job && job.abgebrochen) throw new Abgebrochen();
+    const st = await fsp.stat(voll).catch(() => null);
+    if (!st) return;
+    if (st.isFile()) { summe.dateien++; summe.bytes += st.size; }
+    else if (st.isDirectory() && tiefe < MAX_TIEFE) {
+      const eintraege = await fsp.readdir(voll, { withFileTypes: true }).catch(() => []);
+      for (const e of eintraege) {
+        const p = path.join(voll, e.name);
+        const a = await art(p, e);
+        if (a.ordner) await lauf(p, tiefe + 1);
+        else if (a.datei) {
+          const s = await fsp.stat(p).catch(() => null);
+          if (s) { summe.dateien++; summe.bytes += s.size; }
+        }
+      }
+    }
+    if (melde && Date.now() - zuletzt > MELDE_ALLE_MS) { zuletzt = Date.now(); melde({ ...summe }); }
+  }
+  for (const q of quellen) await lauf(q, 0);
+  if (melde) melde({ ...summe });
+  return summe;
+}
+
+/** Freier Platz (Bytes) auf dem Laufwerk von `ordner`, null wenn unbekannt. */
+async function freierPlatz(ordner) {
+  try {
+    let pruefe = ordner;
+    while (!fs.existsSync(pruefe) && path.dirname(pruefe) !== pruefe) pruefe = path.dirname(pruefe);
+    const s = await fsp.statfs(pruefe);
+    return s.bavail * s.bsize;
+  } catch { return null; }
+}
+
+/**
+ * Fortschritt über mehrere Kopiervorgänge hinweg (z. B. alle Instanzen eines
+ * Imports). `melde` bekommt höchstens alle 200 ms einen Zwischenstand.
+ */
+function neuerFortschritt(gesamt, melde) {
+  const f = {
+    gesamtBytes: gesamt.bytes || 0, gesamtDateien: gesamt.dateien || 0,
+    bytes: 0, dateien: 0, datei: '', uebersprungen: [],
+    beginn: Date.now(), zuletzt: 0, verlauf: [],
+  };
+  f.melden = (sofort) => {
+    const jetzt = Date.now();
+    if (!melde || (!sofort && jetzt - f.zuletzt < MELDE_ALLE_MS)) return;
+    f.zuletzt = jetzt;
+    // Tempo über die letzten ~5 Sekunden glätten
+    f.verlauf.push([jetzt, f.bytes]);
+    while (f.verlauf.length > 2 && jetzt - f.verlauf[0][0] > 5000) f.verlauf.shift();
+    const [t0, b0] = f.verlauf[0];
+    const tempo = jetzt > t0 ? ((f.bytes - b0) * 1000) / (jetzt - t0) : 0;
+    // erst nach 1,5 s schätzen – davor gibt es noch kein brauchbares Tempo
+    const eingeschwungen = jetzt - f.beginn > 1500;
+    const rest = eingeschwungen && tempo > 0 && f.gesamtBytes > f.bytes ? Math.round((f.gesamtBytes - f.bytes) / tempo) : null;
+    melde({
+      bytes: f.bytes, gesamtBytes: f.gesamtBytes, dateien: f.dateien, gesamtDateien: f.gesamtDateien,
+      datei: f.datei, tempo: eingeschwungen ? Math.round(tempo) : 0, restSekunden: rest, uebersprungen: f.uebersprungen.length,
+    });
+  };
+  return f;
+}
+
+async function kopiereDatei(von, nach, groesse, fortschritt, job) {
+  if (groesse >= STUECKWEISE_AB) {
+    // große Datei: stückweise, damit der Balken weiterläuft
+    const lesen = fs.createReadStream(von, { highWaterMark: 4 * 1024 * 1024 });
+    lesen.on('data', (stueck) => {
+      if (job && job.abgebrochen) { lesen.destroy(new Abgebrochen()); return; }
+      if (fortschritt) { fortschritt.bytes += stueck.length; fortschritt.melden(); }
+    });
+    await pipeline(lesen, fs.createWriteStream(nach));
+  } else {
+    await fsp.copyFile(von, nach);
+    if (fortschritt) fortschritt.bytes += groesse;
+  }
+}
+
+/**
+ * Kopiert `von` (Datei oder Ordner) nach `nach`. Läuft asynchron, meldet über
+ * `fortschritt` (siehe neuerFortschritt) und bricht ab, sobald job.abgebrochen.
+ * Gesperrte Einzeldateien landen in fortschritt.uebersprungen; volle Platte
+ * (ENOSPC) und Abbruch beenden den ganzen Vorgang mit Fehler.
+ */
+async function kopiere(von, nach, fortschritt, job) {
+  const laufend = new Set();
+  let schwererFehler = null;
+
+  async function platz(aufgabe) {
+    while (laufend.size >= GLEICHZEITIG) await Promise.race(laufend);
+    if (schwererFehler) throw schwererFehler;
+    const p = aufgabe().catch((err) => {
+      if (err && (err.abgebrochen || err.code === 'ENOSPC')) schwererFehler = schwererFehler || err;
+      else if (fortschritt) fortschritt.uebersprungen.push({ datei: err && err.path ? err.path : '?', grund: err && err.code ? err.code : String(err && err.message) });
+    }).finally(() => laufend.delete(p));
+    laufend.add(p);
+  }
+
+  const basis = von;
+  async function datei(q, z) {
+    if (job && job.abgebrochen) throw new Abgebrochen();
+    const st = await fsp.stat(q);
+    if (fortschritt) fortschritt.datei = path.relative(path.dirname(basis), q);
+    await kopiereDatei(q, z, st.size, fortschritt, job);
+    if (fortschritt) { fortschritt.dateien++; fortschritt.melden(); }
+  }
+
+  async function ordner(q, z, tiefe) {
+    if (job && job.abgebrochen) throw new Abgebrochen();
+    if (schwererFehler) throw schwererFehler;
+    await fsp.mkdir(z, { recursive: true });
+    if (tiefe >= MAX_TIEFE) return;
+    const eintraege = await fsp.readdir(q, { withFileTypes: true });
+    for (const e of eintraege) {
+      const qq = path.join(q, e.name);
+      const zz = path.join(z, e.name);
+      const a = await art(qq, e);
+      if (a.ordner) await ordner(qq, zz, tiefe + 1);
+      else if (a.datei) await platz(() => datei(qq, zz));
+    }
+  }
+
+  let fehler = null;
+  try {
+    const st = await fsp.stat(von);
+    if (st.isDirectory()) await ordner(von, nach, 0);
+    else {
+      await fsp.mkdir(path.dirname(nach), { recursive: true });
+      await platz(() => datei(von, nach));
+    }
+  } catch (err) {
+    fehler = err;
+  }
+  // erst zurückkehren, wenn keine Datei mehr geschrieben wird – sonst würde
+  // das Aufräumen nach einem Abbruch mit noch laufenden Kopien kollidieren
+  while (laufend.size) await Promise.allSettled([...laufend]);
+  if (fehler) throw fehler;
+  if (schwererFehler) throw schwererFehler;
+  if (job && job.abgebrochen) throw new Abgebrochen();
+  if (fortschritt) fortschritt.melden(true);
+}
+
+module.exports = { zaehle, kopiere, freierPlatz, neuerFortschritt, Abgebrochen };

src/loaders.js

@@ -1,103 +1,117 @@
-'use strict';
-
-/*
- * loaders.js – Mod-Loader-Profile auflösen
- * ----------------------------------------
- * Fabric & Quilt liefern über ihre Meta-API ein fertiges Profil-JSON
- * (mainClass, zusätzliche Libraries als Maven-Koordinaten, Argumente,
- * inheritsFrom = Vanilla-Version). Das mergen wir beim Start mit der Vanilla-Version.
- *
- * Forge & NeoForge liefern KEIN einfaches Profil, sondern einen Installer,
- * der Prozessoren ausführt und den Client patcht -> deutlich aufwändiger,
- * daher hier noch als „in Arbeit" gekennzeichnet.
- */
-
-const UA = 'AeroMC-Launcher/0.5';
-
-const META = {
-  fabric: 'https://meta.fabricmc.net/v2',
-  quilt: 'https://meta.quiltmc.org/v3',
-};
-
-async function fetchJson(url) {
-  const res = await fetch(url, { headers: { 'User-Agent': UA, Accept: 'application/json' } });
-  if (!res.ok) throw new Error('HTTP ' + res.status + ' bei ' + url);
-  return res.json();
-}
-
-async function fetchText(url) {
-  const res = await fetch(url, { headers: { 'User-Agent': UA } });
-  if (!res.ok) throw new Error('HTTP ' + res.status + ' bei ' + url);
-  return res.text();
-}
-
-const FORGE_META = 'https://maven.minecraftforge.net/net/minecraftforge/forge/maven-metadata.xml';
-const NEOFORGE_META = 'https://maven.neoforged.net/releases/net/neoforged/neoforge/maven-metadata.xml';
-
-// NeoForge kodiert die MC-Version im Loader-Namen: 1.21.4 -> 21.4.x
-function neoforgePrefix(mcVersion) {
-  const p = mcVersion.split('.');
-  return `${p[1]}.${p[2] || '0'}.`;
-}
-
-// "group:artifact:version[:classifier]" -> { relPath, url }
-function mavenToUrl(base, name) {
-  const parts = name.split(':');
-  const group = parts[0].replace(/\./g, '/');
-  const artifact = parts[1];
-  const version = parts[2];
-  const classifier = parts[3] ? '-' + parts[3] : '';
-  const file = `${artifact}-${version}${classifier}.jar`;
-  const relPath = `${group}/${artifact}/${version}/${file}`;
-  const root = (base || 'https://libraries.minecraft.net/').replace(/\/$/, '');
-  return { relPath, url: `${root}/${relPath}` };
-}
-
-// verfügbare Loader-Versionen (für die Anzeige/Auswahl)
-async function listLoaderVersions(loader, mcVersion) {
-  if (loader === 'fabric' || loader === 'quilt') {
-    const list = await fetchJson(`${META[loader]}/versions/loader/${mcVersion}`);
-    return list.map((l) => ({ version: l.loader.version, stable: !!l.loader.stable }));
-  }
-  if (loader === 'forge') {
-    const xml = await fetchText(FORGE_META);
-    const all = [...xml.matchAll(/<version>([^<]+)<\/version>/g)].map((m) => m[1]);
-    const prefix = mcVersion + '-';
-    const versions = all.filter((v) => v.startsWith(prefix)).map((v) => v.slice(prefix.length)).reverse();
-    return versions.map((v, i) => ({ version: v, stable: i === 0 }));
-  }
-  if (loader === 'neoforge') {
-    const xml = await fetchText(NEOFORGE_META);
-    const all = [...xml.matchAll(/<version>([^<]+)<\/version>/g)].map((m) => m[1]);
-    const prefix = neoforgePrefix(mcVersion);
-    const versions = all.filter((v) => v.startsWith(prefix)).reverse();
-    return versions.map((v, i) => ({ version: v, stable: i === 0 && !/beta/i.test(v) }));
-  }
-  return [];
-}
-
-// löst das Profil (mainClass, libraries, arguments) auf
-async function resolveLoaderProfile(loader, mcVersion, loaderVersion) {
-  if (loader === 'fabric' || loader === 'quilt') {
-    let lv = loaderVersion;
-    if (!lv) {
-      const list = await fetchJson(`${META[loader]}/versions/loader/${mcVersion}`);
-      if (!list.length) throw new Error(`Kein ${loader}-Loader für Minecraft ${mcVersion} verfügbar.`);
-      const stable = list.find((l) => l.loader && l.loader.stable) || list[0];
-      lv = stable.loader.version;
-    }
-    const profile = await fetchJson(`${META[loader]}/versions/loader/${mcVersion}/${lv}/profile/json`);
-    return { profile, loaderVersion: lv };
-  }
-  if (loader === 'forge' || loader === 'neoforge') {
-    const e = new Error(
-      `${loader === 'forge' ? 'Forge' : 'NeoForge'}-Installation ist noch in Arbeit ` +
-      '(braucht Installer + Prozessoren). Fabric und Quilt funktionieren bereits vollständig.',
-    );
-    e.notImplemented = true;
-    throw e;
-  }
-  throw new Error('Unbekannter Loader: ' + loader);
-}
-
-module.exports = { resolveLoaderProfile, listLoaderVersions, mavenToUrl };
+'use strict';
+
+/*
+ * loaders.js – Mod-Loader-Profile auflösen
+ * ----------------------------------------
+ * Fabric & Quilt liefern über ihre Meta-API ein fertiges Profil-JSON
+ * (mainClass, zusätzliche Libraries als Maven-Koordinaten, Argumente,
+ * inheritsFrom = Vanilla-Version). Das mergen wir beim Start mit der Vanilla-Version.
+ *
+ * Forge & NeoForge liefern KEIN einfaches Profil, sondern einen Installer,
+ * der Prozessoren ausführt und den Client patcht -> deutlich aufwändiger,
+ * daher hier noch als „in Arbeit" gekennzeichnet.
+ */
+
+const UA = 'AeroMC-Launcher/0.5';
+
+const META = {
+  fabric: 'https://meta.fabricmc.net/v2',
+  quilt: 'https://meta.quiltmc.org/v3',
+};
+
+async function fetchJson(url) {
+  const res = await fetch(url, { headers: { 'User-Agent': UA, Accept: 'application/json' } });
+  if (!res.ok) throw new Error('HTTP ' + res.status + ' bei ' + url);
+  return res.json();
+}
+
+async function fetchText(url) {
+  const res = await fetch(url, { headers: { 'User-Agent': UA } });
+  if (!res.ok) throw new Error('HTTP ' + res.status + ' bei ' + url);
+  return res.text();
+}
+
+const FORGE_META = 'https://maven.minecraftforge.net/net/minecraftforge/forge/maven-metadata.xml';
+const NEOFORGE_META = 'https://maven.neoforged.net/releases/net/neoforged/neoforge/maven-metadata.xml';
+
+// NeoForge kodiert die MC-Version im Loader-Namen: 1.21.4 -> 21.4.x
+function neoforgePrefix(mcVersion) {
+  const p = mcVersion.split('.');
+  return `${p[1]}.${p[2] || '0'}.`;
+}
+
+// "group:artifact:version[:classifier]" -> { relPath, url }
+function mavenToUrl(base, name) {
+  const parts = name.split(':');
+  const group = parts[0].replace(/\./g, '/');
+  const artifact = parts[1];
+  const version = parts[2];
+  const classifier = parts[3] ? '-' + parts[3] : '';
+  const file = `${artifact}-${version}${classifier}.jar`;
+  const relPath = `${group}/${artifact}/${version}/${file}`;
+  const root = (base || 'https://libraries.minecraft.net/').replace(/\/$/, '');
+  return { relPath, url: `${root}/${relPath}` };
+}
+
+// verfügbare Loader-Versionen (für die Anzeige/Auswahl)
+// Versionsnummern zahlenweise vergleichen ("36.2.39" > "36.2.4"), neueste zuerst.
+// Die Maven-Listen von Forge/NeoForge sind nicht verlässlich sortiert – früher
+// landete bei Forge 1.16.5 dadurch die ÄLTESTE Version (36.0.0) vorn.
+function neuesteZuerst(a, b) {
+  const ta = String(a).split(/[.\-+]/), tb = String(b).split(/[.\-+]/);
+  for (let i = 0; i < Math.max(ta.length, tb.length); i++) {
+    const x = ta[i] || '0', y = tb[i] || '0';
+    const nx = /^\d+$/.test(x), ny = /^\d+$/.test(y);
+    if (nx && ny && Number(x) !== Number(y)) return Number(y) - Number(x);
+    if (!(nx && ny) && x !== y) return nx ? -1 : ny ? 1 : y.localeCompare(x); // reine Zahl vor "beta"
+  }
+  return 0;
+}
+
+async function listLoaderVersions(loader, mcVersion) {
+  if (loader === 'fabric' || loader === 'quilt') {
+    const list = await fetchJson(`${META[loader]}/versions/loader/${mcVersion}`);
+    return list.map((l) => ({ version: l.loader.version, stable: !!l.loader.stable }));
+  }
+  if (loader === 'forge') {
+    const xml = await fetchText(FORGE_META);
+    const all = [...xml.matchAll(/<version>([^<]+)<\/version>/g)].map((m) => m[1]);
+    const prefix = mcVersion + '-';
+    const versions = all.filter((v) => v.startsWith(prefix)).map((v) => v.slice(prefix.length)).sort(neuesteZuerst);
+    return versions.map((v, i) => ({ version: v, stable: i === 0 }));
+  }
+  if (loader === 'neoforge') {
+    const xml = await fetchText(NEOFORGE_META);
+    const all = [...xml.matchAll(/<version>([^<]+)<\/version>/g)].map((m) => m[1]);
+    const prefix = neoforgePrefix(mcVersion);
+    const versions = all.filter((v) => v.startsWith(prefix)).sort(neuesteZuerst);
+    return versions.map((v, i) => ({ version: v, stable: i === 0 && !/beta/i.test(v) }));
+  }
+  return [];
+}
+
+// löst das Profil (mainClass, libraries, arguments) auf
+async function resolveLoaderProfile(loader, mcVersion, loaderVersion) {
+  if (loader === 'fabric' || loader === 'quilt') {
+    let lv = loaderVersion;
+    if (!lv) {
+      const list = await fetchJson(`${META[loader]}/versions/loader/${mcVersion}`);
+      if (!list.length) throw new Error(`Kein ${loader}-Loader für Minecraft ${mcVersion} verfügbar.`);
+      const stable = list.find((l) => l.loader && l.loader.stable) || list[0];
+      lv = stable.loader.version;
+    }
+    const profile = await fetchJson(`${META[loader]}/versions/loader/${mcVersion}/${lv}/profile/json`);
+    return { profile, loaderVersion: lv };
+  }
+  if (loader === 'forge' || loader === 'neoforge') {
+    const e = new Error(
+      `${loader === 'forge' ? 'Forge' : 'NeoForge'}-Installation ist noch in Arbeit ` +
+      '(braucht Installer + Prozessoren). Fabric und Quilt funktionieren bereits vollständig.',
+    );
+    e.notImplemented = true;
+    throw e;
+  }
+  throw new Error('Unbekannter Loader: ' + loader);
+}
+
+module.exports = { resolveLoaderProfile, listLoaderVersions, mavenToUrl };

src/mcimport.js

@@ -173,16 +173,31 @@ function scan(inputPath) {
   return { ok: true, rootDir, count: list.length, instances: list };
 }
 
+function kopierNamen(sourceDir, usesDefaultGameDir) {
+  return fs.readdirSync(sourceDir).filter((name) => {
+    if (/^launcher_profiles.*\.json$/i.test(name)) return false;
+    if (name === 'versions' || name === 'libraries' || name === 'assets' || name === 'runtime' || name === 'webcache2') return false;
+    return !(usesDefaultGameDir && !shouldCopyRootEntry(name));
+  });
+}
+
 function copyInto(sourceDir, targetDir, usesDefaultGameDir) {
   fs.mkdirSync(targetDir, { recursive: true });
-  for (const name of fs.readdirSync(sourceDir)) {
-    if (/^launcher_profiles.*\.json$/i.test(name)) continue;
-    if (name === 'versions' || name === 'libraries' || name === 'assets' || name === 'runtime' || name === 'webcache2') continue;
-    if (usesDefaultGameDir && !shouldCopyRootEntry(name)) continue;
+  for (const name of kopierNamen(sourceDir, usesDefaultGameDir)) {
     fs.cpSync(path.join(sourceDir, name), path.join(targetDir, name), { recursive: true });
   }
 }
 
+/*
+ * Was beim Übernehmen kopiert wird: [{ von, name }] – `name` ist der Zielname
+ * im Spielordner der neuen Instanz. Das Kopieren selbst erledigt kopieren.js
+ * asynchron mit Fortschritt (main.js → fuehreImportAus).
+ */
+function kopierQuellen(entry) {
+  if (!entry.gameDir || !fs.existsSync(entry.gameDir)) return [];
+  return kopierNamen(entry.gameDir, !!entry.usesDefaultGameDir).map((name) => ({ von: path.join(entry.gameDir, name), name }));
+}
+
 function importOne(store, entry, copyData = true) {
   const created = store.createOrReplaceImportedInstance({
     name: entry.name,
@@ -214,4 +229,4 @@ function importOne(store, entry, copyData = true) {
   return { id: created.id, name: created.name, copied };
 }
 
-module.exports = { scan, importOne, parseLastVersionId, resolveLauncherRoot };
+module.exports = { scan, importOne, kopierQuellen, parseLastVersionId, resolveLauncherRoot };

src/mmcimport.js

@@ -1,188 +1,199 @@
-'use strict';
-
-/*
- * mmcimport.js – Instanzen aus MultiMC/Prism übernehmen
- * ------------------------------------------------------
- * Es genügt der Pfad zum MultiMC-Ordner (oder direkt zum instances-Ordner).
- * Ausgelesen werden:
- *   instance.cfg   – Name, Gruppe, Java-Pfad, Arbeitsspeicher, Notizen
- *   mmc-pack.json  – Minecraft-Version und Mod-Loader
- *   .minecraft/    – Spielverzeichnis (Welten, Mods, Konfigurationen)
- */
-
-const fs = require('fs');
-const path = require('path');
-
-// uid der Loader in mmc-pack.json -> unsere Bezeichnung
-const LOADER_UIDS = {
-  'net.fabricmc.fabric-loader': 'fabric',
-  'org.quiltmc.quilt-loader': 'quilt',
-  'net.minecraftforge': 'forge',
-  'net.neoforged': 'neoforge',
-};
-
-function parseCfg(file) {
-  const out = {};
-  try {
-    for (const line of fs.readFileSync(file, 'utf8').split(/\r?\n/)) {
-      const i = line.indexOf('=');
-      if (i > 0) out[line.slice(0, i).trim()] = line.slice(i + 1).trim();
-    }
-  } catch { /* Datei fehlt */ }
-  return out;
-}
-
-// Gruppen stehen zentral in instances/instgroups.json
-function readGroups(instancesDir) {
-  const map = {};
-  try {
-    const raw = JSON.parse(fs.readFileSync(path.join(instancesDir, 'instgroups.json'), 'utf8'));
-    for (const [group, data] of Object.entries(raw.groups || {})) {
-      for (const inst of data.instances || []) map[inst] = group;
-    }
-  } catch { /* keine Gruppen hinterlegt */ }
-  return map;
-}
-
-function readPack(dir) {
-  const res = { version: '', loader: 'vanilla', loaderVersion: '' };
-  try {
-    const pack = JSON.parse(fs.readFileSync(path.join(dir, 'mmc-pack.json'), 'utf8'));
-    for (const c of pack.components || []) {
-      if (c.uid === 'net.minecraft') res.version = c.version || c.cachedVersion || '';
-      const loader = LOADER_UIDS[c.uid];
-      if (loader) { res.loader = loader; res.loaderVersion = c.version || ''; }
-    }
-  } catch { /* alte Instanz ohne mmc-pack.json */ }
-  return res;
-}
-
-// findet den instances-Ordner, egal ob MultiMC-Wurzel oder instances direkt angegeben wurde
-function resolveInstancesDir(inputPath) {
-  if (!inputPath) return null;
-  const direct = path.join(inputPath, 'instances');
-  if (fs.existsSync(direct)) return direct;
-  if (path.basename(inputPath).toLowerCase() === 'instances' && fs.existsSync(inputPath)) return inputPath;
-  return fs.existsSync(inputPath) ? inputPath : null;
-}
-
-/*
- * Liest einen einzelnen Instanzordner aus. null, wenn dort keine Instanz liegt.
- * Wird sowohl beim Ordner-Import als auch beim ZIP-Import verwendet.
- */
-function readInstance(dir, folderName, group) {
-  const cfgFile = path.join(dir, 'instance.cfg');
-  if (!fs.existsSync(cfgFile)) return null;          // kein Instanzordner
-
-  const cfg = parseCfg(cfgFile);
-  const pack = readPack(dir);
-  // MultiMC nutzt .minecraft, Prism minecraft
-  const gameDir = ['.minecraft', 'minecraft']
-    .map((n) => path.join(dir, n))
-    .find((p) => fs.existsSync(p)) || null;
-
-  return {
-    folder: folderName,
-    dir,
-    name: cfg.name || folderName,
-    group: group || '',
-    notes: cfg.notes || '',
-    version: pack.version || cfg.IntendedVersion || '',
-    loader: pack.loader,
-    loaderVersion: pack.loaderVersion,
-    javaPath: cfg.OverrideJavaLocation === 'true' ? (cfg.JavaPath || '') : '',
-    minMemMb: cfg.OverrideMemory === 'true' ? Number(cfg.MinMemAlloc) || null : null,
-    maxMemMb: cfg.OverrideMemory === 'true' ? Number(cfg.MaxMemAlloc) || null : null,
-    gameDir,
-    hasGameData: !!gameDir,
-  };
-}
-
-/*
- * Listet die gefundenen Instanzen auf (ohne etwas zu kopieren).
- */
-function scan(inputPath) {
-  const instancesDir = resolveInstancesDir(inputPath);
-  if (!instancesDir) return { ok: false, reason: 'not-found' };
-
-  const groups = readGroups(instancesDir);
-  const list = [];
-  for (const entry of fs.readdirSync(instancesDir, { withFileTypes: true })) {
-    if (!entry.isDirectory()) continue;
-    const inst = readInstance(path.join(instancesDir, entry.name), entry.name, groups[entry.name]);
-    if (inst) list.push(inst);
-  }
-  list.sort((a, b) => a.name.localeCompare(b.name));
-  return { ok: true, instancesDir, count: list.length, instances: list };
-}
-
-/*
- * Sucht einen Instanzordner unterhalb von root. Deckt beide Zip-Varianten ab:
- * mit umgebendem Ordner ("26.2/instance.cfg") und ohne ("instance.cfg").
- * Die Tiefe ist begrenzt, damit nicht das ganze .minecraft durchsucht wird.
- */
-function findInstanceDir(root, tiefe = 2) {
-  if (!root || !fs.existsSync(root)) return null;
-  if (fs.existsSync(path.join(root, 'instance.cfg'))) return root;
-  if (tiefe <= 0) return null;
-  let eintraege = [];
-  try { eintraege = fs.readdirSync(root, { withFileTypes: true }); } catch { return null; }
-  for (const e of eintraege) {
-    if (!e.isDirectory()) continue;
-    // .minecraft enthält nie eine Instanz und ist der mit Abstand größte Ordner
-    if (e.name === '.minecraft' || e.name === 'minecraft') continue;
-    const treffer = findInstanceDir(path.join(root, e.name), tiefe - 1);
-    if (treffer) return treffer;
-  }
-  return null;
-}
-
-/*
- * Liest eine einzelne, ausgepackte MultiMC/Prism-Instanz.
- * -> { ok, instance } oder { ok: false, reason: 'not-found' }
- */
-function scanSingle(root) {
-  const dir = findInstanceDir(root);
-  if (!dir) return { ok: false, reason: 'not-found' };
-  const inst = readInstance(dir, path.basename(dir), '');
-  return inst ? { ok: true, instance: inst } : { ok: false, reason: 'not-found' };
-}
-
-/*
- * Übernimmt eine Instanz in den Launcher.
- * store: unser Datenspeicher; copyData: Spielverzeichnis mitkopieren
- */
-function importOne(store, entry, copyData = true) {
-  const created = store.createOrReplaceImportedInstance({
-    name: entry.name,
-    group: entry.group,
-    notes: entry.notes,
-    minecraft: {
-      version: entry.version,
-      loader: entry.loader,
-      loaderVersion: entry.loaderVersion,
-    },
-  });
-
-  const patch = {};
-  if (entry.javaPath || entry.minMemMb || entry.maxMemMb) {
-    patch.java = {
-      path: entry.javaPath || '',
-      minMemMb: entry.minMemMb || null,
-      maxMemMb: entry.maxMemMb || null,
-      extraArgs: '',
-    };
-  }
-  if (Object.keys(patch).length) store.updateInstance(created.id, patch);
-
-  let copied = false;
-  if (copyData && entry.gameDir && fs.existsSync(entry.gameDir)) {
-    try {
-      fs.cpSync(entry.gameDir, store.gameDir(created.id), { recursive: true });
-      copied = true;
-    } catch { /* Spieldaten konnten nicht kopiert werden */ }
-  }
-  return { id: created.id, name: created.name, copied };
-}
-
-module.exports = { scan, scanSingle, importOne, resolveInstancesDir, readInstance, findInstanceDir };
+'use strict';
+
+/*
+ * mmcimport.js – Instanzen aus MultiMC/Prism übernehmen
+ * ------------------------------------------------------
+ * Es genügt der Pfad zum MultiMC-Ordner (oder direkt zum instances-Ordner).
+ * Ausgelesen werden:
+ *   instance.cfg   – Name, Gruppe, Java-Pfad, Arbeitsspeicher, Notizen
+ *   mmc-pack.json  – Minecraft-Version und Mod-Loader
+ *   .minecraft/    – Spielverzeichnis (Welten, Mods, Konfigurationen)
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// uid der Loader in mmc-pack.json -> unsere Bezeichnung
+const LOADER_UIDS = {
+  'net.fabricmc.fabric-loader': 'fabric',
+  'org.quiltmc.quilt-loader': 'quilt',
+  'net.minecraftforge': 'forge',
+  'net.neoforged': 'neoforge',
+};
+
+function parseCfg(file) {
+  const out = {};
+  try {
+    for (const line of fs.readFileSync(file, 'utf8').split(/\r?\n/)) {
+      const i = line.indexOf('=');
+      if (i > 0) out[line.slice(0, i).trim()] = line.slice(i + 1).trim();
+    }
+  } catch { /* Datei fehlt */ }
+  return out;
+}
+
+// Gruppen stehen zentral in instances/instgroups.json
+function readGroups(instancesDir) {
+  const map = {};
+  try {
+    const raw = JSON.parse(fs.readFileSync(path.join(instancesDir, 'instgroups.json'), 'utf8'));
+    for (const [group, data] of Object.entries(raw.groups || {})) {
+      for (const inst of data.instances || []) map[inst] = group;
+    }
+  } catch { /* keine Gruppen hinterlegt */ }
+  return map;
+}
+
+function readPack(dir) {
+  const res = { version: '', loader: 'vanilla', loaderVersion: '' };
+  try {
+    const pack = JSON.parse(fs.readFileSync(path.join(dir, 'mmc-pack.json'), 'utf8'));
+    for (const c of pack.components || []) {
+      if (c.uid === 'net.minecraft') res.version = c.version || c.cachedVersion || '';
+      const loader = LOADER_UIDS[c.uid];
+      if (loader) { res.loader = loader; res.loaderVersion = c.version || ''; }
+    }
+  } catch { /* alte Instanz ohne mmc-pack.json */ }
+  return res;
+}
+
+// findet den instances-Ordner, egal ob MultiMC-Wurzel oder instances direkt angegeben wurde
+function resolveInstancesDir(inputPath) {
+  if (!inputPath) return null;
+  const direct = path.join(inputPath, 'instances');
+  if (fs.existsSync(direct)) return direct;
+  if (path.basename(inputPath).toLowerCase() === 'instances' && fs.existsSync(inputPath)) return inputPath;
+  return fs.existsSync(inputPath) ? inputPath : null;
+}
+
+/*
+ * Liest einen einzelnen Instanzordner aus. null, wenn dort keine Instanz liegt.
+ * Wird sowohl beim Ordner-Import als auch beim ZIP-Import verwendet.
+ */
+function readInstance(dir, folderName, group) {
+  const cfgFile = path.join(dir, 'instance.cfg');
+  if (!fs.existsSync(cfgFile)) return null;          // kein Instanzordner
+
+  const cfg = parseCfg(cfgFile);
+  const pack = readPack(dir);
+  // MultiMC nutzt .minecraft, Prism minecraft
+  const gameDir = ['.minecraft', 'minecraft']
+    .map((n) => path.join(dir, n))
+    .find((p) => fs.existsSync(p)) || null;
+
+  return {
+    folder: folderName,
+    dir,
+    name: cfg.name || folderName,
+    group: group || '',
+    notes: cfg.notes || '',
+    version: pack.version || cfg.IntendedVersion || '',
+    loader: pack.loader,
+    loaderVersion: pack.loaderVersion,
+    javaPath: cfg.OverrideJavaLocation === 'true' ? (cfg.JavaPath || '') : '',
+    minMemMb: cfg.OverrideMemory === 'true' ? Number(cfg.MinMemAlloc) || null : null,
+    maxMemMb: cfg.OverrideMemory === 'true' ? Number(cfg.MaxMemAlloc) || null : null,
+    gameDir,
+    hasGameData: !!gameDir,
+  };
+}
+
+/*
+ * Listet die gefundenen Instanzen auf (ohne etwas zu kopieren).
+ */
+function scan(inputPath) {
+  const instancesDir = resolveInstancesDir(inputPath);
+  if (!instancesDir) return { ok: false, reason: 'not-found' };
+
+  const groups = readGroups(instancesDir);
+  const list = [];
+  for (const entry of fs.readdirSync(instancesDir, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    const inst = readInstance(path.join(instancesDir, entry.name), entry.name, groups[entry.name]);
+    if (inst) list.push(inst);
+  }
+  list.sort((a, b) => a.name.localeCompare(b.name));
+  return { ok: true, instancesDir, count: list.length, instances: list };
+}
+
+/*
+ * Sucht einen Instanzordner unterhalb von root. Deckt beide Zip-Varianten ab:
+ * mit umgebendem Ordner ("26.2/instance.cfg") und ohne ("instance.cfg").
+ * Die Tiefe ist begrenzt, damit nicht das ganze .minecraft durchsucht wird.
+ */
+function findInstanceDir(root, tiefe = 2) {
+  if (!root || !fs.existsSync(root)) return null;
+  if (fs.existsSync(path.join(root, 'instance.cfg'))) return root;
+  if (tiefe <= 0) return null;
+  let eintraege = [];
+  try { eintraege = fs.readdirSync(root, { withFileTypes: true }); } catch { return null; }
+  for (const e of eintraege) {
+    if (!e.isDirectory()) continue;
+    // .minecraft enthält nie eine Instanz und ist der mit Abstand größte Ordner
+    if (e.name === '.minecraft' || e.name === 'minecraft') continue;
+    const treffer = findInstanceDir(path.join(root, e.name), tiefe - 1);
+    if (treffer) return treffer;
+  }
+  return null;
+}
+
+/*
+ * Liest eine einzelne, ausgepackte MultiMC/Prism-Instanz.
+ * -> { ok, instance } oder { ok: false, reason: 'not-found' }
+ */
+function scanSingle(root) {
+  const dir = findInstanceDir(root);
+  if (!dir) return { ok: false, reason: 'not-found' };
+  const inst = readInstance(dir, path.basename(dir), '');
+  return inst ? { ok: true, instance: inst } : { ok: false, reason: 'not-found' };
+}
+
+/*
+ * Übernimmt eine Instanz in den Launcher.
+ * store: unser Datenspeicher; copyData: Spielverzeichnis mitkopieren
+ */
+function importOne(store, entry, copyData = true) {
+  const created = store.createOrReplaceImportedInstance({
+    name: entry.name,
+    group: entry.group,
+    notes: entry.notes,
+    minecraft: {
+      version: entry.version,
+      loader: entry.loader,
+      loaderVersion: entry.loaderVersion,
+    },
+  });
+
+  const patch = {};
+  if (entry.javaPath || entry.minMemMb || entry.maxMemMb) {
+    patch.java = {
+      path: entry.javaPath || '',
+      minMemMb: entry.minMemMb || null,
+      maxMemMb: entry.maxMemMb || null,
+      extraArgs: '',
+    };
+  }
+  if (Object.keys(patch).length) store.updateInstance(created.id, patch);
+
+  let copied = false;
+  if (copyData && entry.gameDir && fs.existsSync(entry.gameDir)) {
+    try {
+      fs.cpSync(entry.gameDir, store.gameDir(created.id), { recursive: true });
+      copied = true;
+    } catch { /* Spieldaten konnten nicht kopiert werden */ }
+  }
+  return { id: created.id, name: created.name, copied };
+}
+
+
+/*
+ * Was beim Übernehmen kopiert wird: [{ von, name }] – `name` ist der Zielname
+ * im Spielordner der neuen Instanz. Das Kopieren selbst erledigt kopieren.js
+ * asynchron mit Fortschritt (main.js → fuehreImportAus).
+ */
+function kopierQuellen(entry) {
+  if (!entry.gameDir || !fs.existsSync(entry.gameDir)) return [];
+  return fs.readdirSync(entry.gameDir).map((name) => ({ von: path.join(entry.gameDir, name), name }));
+}
+
+module.exports = { scan, scanSingle, importOne, kopierQuellen, resolveInstancesDir, readInstance, findInstanceDir };

src/moderkennung.js

@@ -0,0 +1,117 @@
+/*
+ * Erkennt Mods, die nicht über AeroMC installiert wurden (von Hand kopiert,
+ * aus MultiMC/CurseForge/Modrinth App übernommen, aus einem Modpack …).
+ *
+ * Solche Dateien haben keine Projekt-Zuordnung, deshalb zeigte der Mod-Katalog
+ * z. B. bei Fabric API „Installieren“, obwohl sie längst im mods-Ordner lag.
+ * Hier wird je Datei die SHA-1-Prüfsumme gebildet und gesammelt bei Modrinth
+ * nachgeschlagen (POST /v2/version_files). Ergebnisse werden zwischengespeichert
+ * (Pfad + Größe + Änderungszeit), damit nicht bei jedem Öffnen neu gerechnet wird.
+ * Ohne Netz bleibt einfach alles wie bisher.
+ */
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+const API = 'https://api.modrinth.com/v2';
+const UA = 'AeroMC-Launcher';
+const NICHT_GEFUNDEN_NEU_PRUEFEN_MS = 7 * 24 * 60 * 60 * 1000;
+
+let cacheDatei = null;
+let cache = null;
+
+function init(userDataDir) {
+  cacheDatei = path.join(userDataDir, 'mod-erkennung.json');
+}
+
+function ladeCache() {
+  if (cache) return cache;
+  try { cache = JSON.parse(fs.readFileSync(cacheDatei, 'utf8')); } catch { cache = {}; }
+  return cache;
+}
+function speichereCache() {
+  try { fs.writeFileSync(cacheDatei, JSON.stringify(cache)); } catch { /* nur Zwischenspeicher */ }
+}
+
+function sha1(datei) {
+  return new Promise((resolve, reject) => {
+    const h = crypto.createHash('sha1');
+    fs.createReadStream(datei).on('data', (d) => h.update(d)).on('error', reject).on('end', () => resolve(h.digest('hex')));
+  });
+}
+
+async function holeJson(url, optionen) {
+  const res = await fetch(url, Object.assign({ headers: { 'User-Agent': UA, 'Content-Type': 'application/json', Accept: 'application/json' } }, optionen));
+  if (!res.ok) throw new Error('Modrinth ' + res.status);
+  return res.json();
+}
+
+/**
+ * Ergänzt Einträge ohne projectId um projectId, Titel und Versionsnummer, sofern
+ * Modrinth die Datei kennt. `dir` ist der Ordner, in dem die Dateien liegen.
+ */
+async function ergaenze(eintraege, dir) {
+  const offen = eintraege.filter((e) => e && !e.projectId && e.filename && !e.fehlt);
+  if (!offen.length || !cacheDatei) return eintraege;
+  const c = ladeCache();
+  const jetzt = Date.now();
+  const zuFragen = new Map(); // sha1 -> [schlüssel]
+  const schluesselVon = new Map();
+
+  for (const e of offen) {
+    const voll = path.join(dir, e.enabled === false ? e.filename + '.disabled' : e.filename);
+    let st;
+    try { st = fs.statSync(voll); } catch { continue; }
+    const schluessel = `${voll}|${st.size}|${Math.round(st.mtimeMs)}`;
+    schluesselVon.set(e, schluessel);
+    const bekannt = c[schluessel];
+    if (bekannt && (bekannt.projectId || jetzt - bekannt.geprueft < NICHT_GEFUNDEN_NEU_PRUEFEN_MS)) continue;
+    try {
+      const hash = (bekannt && bekannt.sha1) || await sha1(voll);
+      c[schluessel] = { sha1: hash, projectId: null, geprueft: 0 };
+      if (!zuFragen.has(hash)) zuFragen.set(hash, []);
+      zuFragen.get(hash).push(schluessel);
+    } catch { /* Datei gerade gesperrt – beim nächsten Mal */ }
+  }
+
+  if (zuFragen.size) {
+    try {
+      const versionen = await holeJson(`${API}/version_files`, {
+        method: 'POST', body: JSON.stringify({ hashes: [...zuFragen.keys()], algorithm: 'sha1' }),
+      });
+      const projektIds = [...new Set(Object.values(versionen).map((v) => v.project_id))];
+      const titel = {};
+      for (let i = 0; i < projektIds.length; i += 100) {
+        const teil = projektIds.slice(i, i + 100);
+        const projekte = await holeJson(`${API}/projects?ids=${encodeURIComponent(JSON.stringify(teil))}`);
+        for (const p of projekte) titel[p.id] = p.title;
+      }
+      for (const [hash, schluessel] of zuFragen) {
+        const v = versionen[hash];
+        for (const s of schluessel) {
+          c[s] = v
+            ? { sha1: hash, projectId: v.project_id, versionId: v.id, versionNumber: v.version_number, title: titel[v.project_id] || null, geprueft: jetzt }
+            : { sha1: hash, projectId: null, geprueft: jetzt };
+        }
+      }
+      speichereCache();
+    } catch {
+      return eintraege.map((e) => anwenden(e, c, schluesselVon));
+    }
+  }
+  return eintraege.map((e) => anwenden(e, c, schluesselVon));
+}
+
+function anwenden(e, c, schluesselVon) {
+  const s = schluesselVon.get(e);
+  const t = s && c[s];
+  if (!t || !t.projectId) return e;
+  return Object.assign({}, e, {
+    projectId: t.projectId,
+    title: t.title || e.title,
+    versionNumber: e.versionNumber === 'Importiert' && t.versionNumber ? t.versionNumber : e.versionNumber,
+    erkannt: true,   // per Prüfsumme bei Modrinth erkannt, nicht über AeroMC installiert
+  });
+}
+
+module.exports = { init, ergaenze };

src/modschalter.js

@@ -0,0 +1,65 @@
+'use strict';
+
+/*
+ * modschalter.js – Mods im laufenden Spiel an- und abschalten
+ * ------------------------------------------------------------
+ * Im Pausemenü wird „Feedback geben“ zu „Mods verwalten“ (siehe
+ * agent/ModsUmbau.java). Ein Klick ruft eine Adresse dieses kleinen, nur lokal
+ * erreichbaren Empfängers auf; der Launcher öffnet daraufhin das Mod-Fenster
+ * über dem Spiel.
+ *
+ * Solange Minecraft läuft, sind die Mod-Dateien gesperrt und geladene Mods
+ * lassen sich ohnehin nicht entladen. Änderungen werden deshalb vorgemerkt
+ * (instance.json -> modsAusstehend) und beim Beenden umgesetzt – das Spiel
+ * läuft weiter, beim nächsten Start gilt der neue Stand.
+ */
+
+const http = require('http');
+const crypto = require('crypto');
+
+let server = null;
+let port = 0;
+const sitzungen = new Map();     // token -> { instanceId, pid }
+let beimKlick = null;            // (sitzung) => void
+
+function starteServer() {
+  if (server) return Promise.resolve(port);
+  return new Promise((resolve, reject) => {
+    server = http.createServer((req, res) => {
+      const m = /^\/mods\/([a-f0-9]{32})$/.exec(req.url || '');
+      const s = m && sitzungen.get(m[1]);
+      if (!s) { res.writeHead(404); res.end(); return; }
+      res.writeHead(200, { 'Content-Type': 'text/plain' });
+      res.end('ok');
+      if (beimKlick) { try { beimKlick(s); } catch (err) { console.error('Mod-Schalter:', err); } }
+    });
+    server.on('error', (err) => { server = null; reject(err); });
+    server.listen(0, '127.0.0.1', () => { port = server.address().port; resolve(port); });
+  });
+}
+
+/** Neue Sitzung für einen Spielstart -> { token, adresse } (für das Agent-Argument) */
+async function neueSitzung(instanceId) {
+  await starteServer();
+  const token = crypto.randomBytes(16).toString('hex');
+  sitzungen.set(token, { instanceId, pid: null, token });
+  return { token, adresse: `http://127.0.0.1:${port}/mods/${token}` };
+}
+
+function setzePid(token, pid) {
+  const s = sitzungen.get(token);
+  if (s) s.pid = pid;
+}
+
+function beende(token) {
+  sitzungen.delete(token);
+}
+
+function sitzungFuer(instanceId) {
+  for (const s of sitzungen.values()) if (s.instanceId === instanceId && s.pid) return s;
+  return null;
+}
+
+function beiKlick(fn) { beimKlick = fn; }
+
+module.exports = { neueSitzung, setzePid, beende, sitzungFuer, beiKlick };

src/mrimport.js

@@ -1,437 +1,448 @@
-'use strict';
-
-/*
- * mrimport.js – Instanzen aus der Modrinth App übernehmen
- * --------------------------------------------------------
- * Die Modrinth App legt ihre Daten unter %APPDATA%\ModrinthApp ab (sehr alte
- * Fassungen: %APPDATA%\com.modrinth.theseus). Die Spielordner liegen in
- * "profiles\<Ordner>", die Angaben dazu (Name, Version, Loader, Gruppen,
- * Arbeitsspeicher …) in der SQLite-Datenbank "app.db". Wurde der Datenordner in
- * der App verlegt, steht der neue Ort in settings.custom_dir.
- *
- * Unterstützte Datenbank-Fassungen:
- *   - ab Mitte 2026: Tabelle "instances" + "instance_content_sets" (Version/Loader),
- *     Gruppen in "instance_group_memberships"/"instance_groups",
- *     Starteinstellungen als JSONB in "instance_launch_overrides"
- *   - 2024 bis Mitte 2026: eine Tabelle "profiles"
- *   - vorher (ohne app.db): je Instanz eine profile.json
- *
- * Gelesen wird mit sql.js (SQLite als WebAssembly) auf einer Kopie im Speicher –
- * die Datenbank der Modrinth App wird nie verändert.
- */
-
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-
-const LOADER = new Set(['vanilla', 'fabric', 'forge', 'neoforge', 'quilt']);
-
-let sqlPromise = null;
-function sqlJs() {
-  if (!sqlPromise) {
-    const initSqlJs = require('sql.js');
-    const wasmDir = path.dirname(require.resolve('sql.js'));
-    sqlPromise = initSqlJs({ locateFile: (datei) => path.join(wasmDir, datei) });
-  }
-  return sqlPromise;
-}
-
-function appDatenOrdner() {
-  const appdata = process.env.APPDATA || path.join(os.homedir(), 'AppData', 'Roaming');
-  return [path.join(appdata, 'ModrinthApp'), path.join(appdata, 'com.modrinth.theseus')];
-}
-
-function standardOrdner() {
-  return appDatenOrdner().find((d) => fs.existsSync(d)) || appDatenOrdner()[0];
-}
-
-function readJson(file) {
-  try { return JSON.parse(fs.readFileSync(file, 'utf8').replace(/^/, '')); } catch { return null; }
-}
-
-// Aus der Eingabe (App-Ordner, profiles-Ordner oder leer) die Orte ermitteln
-function ermittleOrte(eingabe) {
-  let basis = eingabe && eingabe.trim() ? eingabe.trim() : standardOrdner();
-  if (!fs.existsSync(basis)) return null;
-  // direkt den profiles-Ordner angegeben -> eine Ebene höher liegt die app.db
-  if (path.basename(basis).toLowerCase() === 'profiles' && !fs.existsSync(path.join(basis, 'app.db'))) {
-    const hoeher = path.dirname(basis);
-    if (fs.existsSync(path.join(hoeher, 'app.db')) || fs.existsSync(path.join(hoeher, 'profiles'))) basis = hoeher;
-  }
-  const db = path.join(basis, 'app.db');
-  return { basis, db: fs.existsSync(db) ? db : null };
-}
-
-// ---------- Datenbank ----------
-/*
- * Läuft die Modrinth App, stehen die neuesten Änderungen oft noch im
- * Schreibprotokoll (app.db-wal) statt in app.db. Dessen abgeschlossene
- * Transaktionen spielen wir hier selbst auf die Kopie im Speicher ein – nach
- * dem SQLite-Dateiformat (Kopf 32 Bytes, je Rahmen 24 Bytes Kopf + eine Seite),
- * mit Prüfung von Salz und laufender Prüfsumme wie SQLite selbst.
- * -> { daten, rahmen } oder null, wenn das Protokoll nicht passt
- */
-function spieleWalEin(daten, walPfad) {
-  let wal;
-  try { wal = fs.readFileSync(walPfad); } catch { return null; }
-  if (wal.length < 32) return null;
-  const magie = wal.readUInt32BE(0);
-  if (magie !== 0x377f0682 && magie !== 0x377f0683) return null;
-  const bigEndian = magie === 0x377f0683;
-  const seite = wal.readUInt32BE(8);
-  const dbSeite = daten.readUInt16BE(16) === 1 ? 65536 : daten.readUInt16BE(16);
-  if (!seite || seite !== dbSeite) return null;
-  const salz1 = wal.readUInt32BE(16), salz2 = wal.readUInt32BE(20);
-
-  const wort = (buf, i) => (bigEndian ? buf.readUInt32BE(i) : buf.readUInt32LE(i));
-  let s0 = 0, s1 = 0;
-  const pruefe = (buf, start, ende) => {
-    for (let i = start; i < ende; i += 8) {
-      s0 = (s0 + wort(buf, i) + s1) >>> 0;
-      s1 = (s1 + wort(buf, i + 4) + s0) >>> 0;
-    }
-  };
-  pruefe(wal, 0, 24);
-  if (s0 !== wal.readUInt32BE(24) || s1 !== wal.readUInt32BE(28)) return null;
-
-  const fertig = new Map();   // Seitennummer -> Inhalt (abgeschlossene Transaktionen)
-  let offen = new Map();
-  let seiten = Math.floor(daten.length / seite);
-  let rahmen = 0;
-  for (let pos = 32; pos + 24 + seite <= wal.length; pos += 24 + seite) {
-    if (wal.readUInt32BE(pos + 8) !== salz1 || wal.readUInt32BE(pos + 12) !== salz2) break;
-    pruefe(wal, pos, pos + 8);
-    pruefe(wal, pos + 24, pos + 24 + seite);
-    if (s0 !== wal.readUInt32BE(pos + 16) || s1 !== wal.readUInt32BE(pos + 20)) break;
-    offen.set(wal.readUInt32BE(pos), wal.subarray(pos + 24, pos + 24 + seite));
-    const nachCommit = wal.readUInt32BE(pos + 4);
-    if (nachCommit) {       // Transaktion abgeschlossen
-      for (const [nr, inhalt] of offen) fertig.set(nr, inhalt);
-      offen = new Map();
-      seiten = nachCommit;
-      rahmen++;
-    }
-  }
-  if (!rahmen) return null;
-  const neu = Buffer.alloc(seiten * seite);
-  daten.copy(neu, 0, 0, Math.min(daten.length, neu.length));
-  for (const [nr, inhalt] of fertig) if (nr >= 1 && nr <= seiten) inhalt.copy(neu, (nr - 1) * seite);
-  return { daten: neu, rahmen };
-}
-
-async function oeffneDb(dbPfad) {
-  const SQL = await sqlJs();
-  let daten = fs.readFileSync(dbPfad);
-  let walEingespielt = false;
-  if (daten.length > 100 && daten[18] === 2) {
-    const mitWal = spieleWalEin(daten, dbPfad + '-wal');
-    if (mitWal) { daten = mitWal.daten; walEingespielt = true; }
-    // WAL-Datenbanken lassen sich ohne geteilten Speicher nicht öffnen – die
-    // Kopie im Speicher als normale Datenbank kennzeichnen (Bytes 18/19)
-    daten[18] = 1; daten[19] = 1;
-  }
-  const db = new SQL.Database(daten);
-  db.walEingespielt = walEingespielt;
-  return db;
-}
-
-function zeilen(db, sql, params) {
-  const st = db.prepare(sql);
-  try {
-    if (params) st.bind(params);
-    const out = [];
-    while (st.step()) out.push(st.getAsObject());
-    return out;
-  } finally {
-    st.free();
-  }
-}
-
-function tabellen(db) {
-  return new Set(zeilen(db, "SELECT name FROM sqlite_master WHERE type = 'table'").map((r) => r.name));
-}
-
-function spalten(db, tabelle) {
-  return new Set(zeilen(db, `PRAGMA table_info(${tabelle})`).map((r) => r.name));
-}
-
-function jsonFeld(wert) {
-  if (wert === null || wert === undefined || wert === '') return null;
-  try { return JSON.parse(wert); } catch { return null; }
-}
-
-// Spalte nur abfragen, wenn es sie gibt (ältere Fassungen kennen nicht alle)
-function sp(vorhanden, ausdruck, name, ersatz = 'NULL') {
-  return vorhanden.has(name) ? `${ausdruck} AS ${name}` : `${ersatz} AS ${name}`;
-}
-
-function eigenerOrdner(db, t) {
-  if (!t.has('settings') || !spalten(db, 'settings').has('custom_dir')) return null;
-  const r = zeilen(db, 'SELECT custom_dir FROM settings LIMIT 1')[0];
-  return r && r.custom_dir ? String(r.custom_dir) : null;
-}
-
-function leseNeu(db, t) {
-  const si = spalten(db, 'instances');
-  const liste = zeilen(db, `
-    SELECT i.id AS id, i.path AS path, i.name AS name,
-      ${sp(si, 'i.icon_path', 'icon_path')}, ${sp(si, 'i.install_stage', 'install_stage')},
-      ${sp(si, 'i.last_played', 'last_played')},
-      ${sp(si, 'i.submitted_time_played', 'submitted_time_played', '0')},
-      ${sp(si, 'i.recent_time_played', 'recent_time_played', '0')},
-      cs.game_version AS game_version, cs.loader AS loader, cs.loader_version AS loader_version
-    FROM instances i
-    LEFT JOIN instance_content_sets cs ON cs.id = i.applied_content_set_id`);
-
-  const overrides = new Map();
-  if (t.has('instance_launch_overrides')) {
-    for (const r of zeilen(db, 'SELECT instance_id, json(overrides) AS o FROM instance_launch_overrides')) {
-      overrides.set(r.instance_id, jsonFeld(r.o) || {});
-    }
-  }
-  const gruppen = new Map();
-  const merke = (id, name) => { if (name && !gruppen.has(id)) gruppen.set(id, String(name)); };
-  if (t.has('instance_group_memberships') && t.has('instance_groups')) {
-    for (const r of zeilen(db, `SELECT m.instance_id AS id, g.name AS name FROM instance_group_memberships m
-      JOIN instance_groups g ON g.id = m.group_id ORDER BY g.display_order`)) merke(r.id, r.name);
-  } else if (t.has('instance_groups') && spalten(db, 'instance_groups').has('group_name')) {
-    for (const r of zeilen(db, 'SELECT instance_id AS id, group_name AS name FROM instance_groups ORDER BY group_name')) merke(r.id, r.name);
-  }
-  const links = new Map();
-  if (t.has('instance_links')) {
-    for (const r of zeilen(db, 'SELECT instance_id, link_kind, modrinth_project_id, modrinth_version_id FROM instance_links')) {
-      if (r.modrinth_project_id && r.modrinth_version_id) links.set(r.instance_id, { projectId: r.modrinth_project_id, versionId: r.modrinth_version_id });
-    }
-  }
-
-  return liste.map((r) => {
-    const o = overrides.get(r.id) || {};
-    const hooks = o.hooks || {};
-    return {
-      path: r.path,
-      name: r.name,
-      iconPath: r.icon_path,
-      installiert: !r.install_stage || r.install_stage === 'installed',
-      lastPlayed: r.last_played,
-      sekunden: (Number(r.submitted_time_played) || 0) + (Number(r.recent_time_played) || 0),
-      gameVersion: r.game_version,
-      loader: r.loader,
-      loaderVersion: r.loader_version,
-      gruppe: gruppen.get(r.id) || '',
-      javaPath: o.java_path || '',
-      maxMemMb: o.memory && Number(o.memory.maximum) ? Number(o.memory.maximum) : null,
-      extraArgs: Array.isArray(o.extra_launch_args) ? o.extra_launch_args.join(' ') : '',
-      vorStart: hooks.pre_launch || '',
-      nachEnde: hooks.post_exit || '',
-      modpack: links.get(r.id) || null,
-    };
-  });
-}
-
-function leseProfile(db) {
-  const s = spalten(db, 'profiles');
-  const liste = zeilen(db, `SELECT path, name,
-      ${sp(s, 'icon_path', 'icon_path')}, ${sp(s, 'install_stage', 'install_stage')},
-      ${sp(s, 'game_version', 'game_version')}, ${sp(s, 'mod_loader', 'mod_loader')},
-      ${sp(s, 'mod_loader_version', 'mod_loader_version')}, ${sp(s, 'json(groups)', 'groups')},
-      ${sp(s, 'last_played', 'last_played')},
-      ${sp(s, 'submitted_time_played', 'submitted_time_played', '0')},
-      ${sp(s, 'recent_time_played', 'recent_time_played', '0')},
-      ${sp(s, 'override_java_path', 'override_java_path')},
-      ${sp(s, 'json(override_extra_launch_args)', 'override_extra_launch_args')},
-      ${sp(s, 'override_mc_memory_max', 'override_mc_memory_max')},
-      ${sp(s, 'override_hook_pre_launch', 'override_hook_pre_launch')},
-      ${sp(s, 'override_hook_post_exit', 'override_hook_post_exit')},
-      ${sp(s, 'linked_project_id', 'linked_project_id')}, ${sp(s, 'linked_version_id', 'linked_version_id')}
-    FROM profiles`);
-  return liste.map((r) => {
-    const gruppen = jsonFeld(r.groups);
-    const args = jsonFeld(r.override_extra_launch_args);
-    return {
-      path: r.path,
-      name: r.name,
-      iconPath: r.icon_path,
-      installiert: !r.install_stage || r.install_stage === 'installed',
-      lastPlayed: r.last_played,
-      sekunden: (Number(r.submitted_time_played) || 0) + (Number(r.recent_time_played) || 0),
-      gameVersion: r.game_version,
-      loader: r.mod_loader,
-      loaderVersion: r.mod_loader_version,
-      gruppe: Array.isArray(gruppen) && gruppen.length ? String(gruppen[0]) : '',
-      javaPath: r.override_java_path || '',
-      maxMemMb: Number(r.override_mc_memory_max) || null,
-      extraArgs: Array.isArray(args) ? args.join(' ') : '',
-      vorStart: r.override_hook_pre_launch || '',
-      nachEnde: r.override_hook_post_exit || '',
-      modpack: r.linked_project_id && r.linked_version_id ? { projectId: r.linked_project_id, versionId: r.linked_version_id } : null,
-    };
-  });
-}
-
-// sehr alte Fassungen: profiles\<Ordner>\profile.json
-function leseProfileJson(profilesDir) {
-  const liste = [];
-  for (const e of fs.readdirSync(profilesDir, { withFileTypes: true })) {
-    if (!e.isDirectory()) continue;
-    const p = readJson(path.join(profilesDir, e.name, 'profile.json'));
-    if (!p) continue;
-    const m = p.metadata || p;
-    const lv = m.loader_version;
-    liste.push({
-      path: e.name,
-      name: m.name || e.name,
-      iconPath: m.icon || null,
-      installiert: !p.install_stage || p.install_stage === 'installed',
-      lastPlayed: m.last_played || null,
-      sekunden: 0,
-      gameVersion: m.game_version,
-      loader: m.loader,
-      loaderVersion: lv && typeof lv === 'object' ? lv.id : lv,
-      gruppe: Array.isArray(m.groups) && m.groups.length ? String(m.groups[0]) : '',
-      javaPath: (p.java && (p.java.override_version && p.java.override_version.path)) || '',
-      maxMemMb: p.memory && Number(p.memory.maximum) ? Number(p.memory.maximum) : null,
-      extraArgs: p.java && Array.isArray(p.java.extra_arguments) ? p.java.extra_arguments.join(' ') : '',
-      vorStart: (p.hooks && p.hooks.pre_launch) || '',
-      nachEnde: (p.hooks && p.hooks.post_exit) || '',
-      modpack: m.linked_data && m.linked_data.project_id && m.linked_data.version_id
-        ? { projectId: m.linked_data.project_id, versionId: m.linked_data.version_id } : null,
-    });
-  }
-  return liste;
-}
-
-// "1.20.1-47.2.0" -> "47.2.0" usw. – AeroMC erwartet die reine Loader-Version
-function loaderVersion(loader, wert, mc) {
-  let v = String(wert || '').trim();
-  if (!v || v === 'stable' || v === 'latest') return '';
-  if (loader === 'forge') {
-    v = v.replace(/^forge-/i, '');
-    if (mc && v.startsWith(mc + '-')) v = v.slice(mc.length + 1);
-  } else if (loader === 'neoforge') {
-    v = v.replace(/^neoforge-/i, '');
-  } else if (loader === 'fabric' || loader === 'quilt') {
-    v = v.replace(/^(fabric|quilt)(-loader)?-/i, '');
-    if (mc && v.endsWith('-' + mc)) v = v.slice(0, -(mc.length + 1));
-  }
-  return v;
-}
-
-function zeitstempel(wert) {
-  if (!wert) return null;
-  const n = Number(wert);
-  if (Number.isFinite(n) && n > 0) return new Date(n < 1e12 ? n * 1000 : n).toISOString();
-  const d = new Date(wert);
-  return Number.isNaN(d.getTime()) ? null : d.toISOString();
-}
-
-/*
- * Durchsucht die Modrinth App. Leere Eingabe = Standardort.
- * -> { ok, basis, count, instances, hinweis }
- */
-async function scan(eingabe) {
-  const orte = ermittleOrte(eingabe);
-  if (!orte) return { ok: false, reason: 'not-found' };
-
-  let roh = [];
-  let profilesDir = path.join(orte.basis, 'profiles');
-  let hinweis = '';
-  if (orte.db) {
-    const db = await oeffneDb(orte.db);
-    try {
-      const t = tabellen(db);
-      const eigener = eigenerOrdner(db, t);
-      if (eigener && fs.existsSync(path.join(eigener, 'profiles'))) profilesDir = path.join(eigener, 'profiles');
-      if (t.has('instances')) roh = leseNeu(db, t);
-      else if (t.has('profiles')) roh = leseProfile(db);
-    } finally {
-      db.close();
-    }
-    // Schreibprotokoll vorhanden, ließ sich aber nicht einspielen -> Kopie
-    // ist evtl. nicht ganz aktuell
-    try {
-      const wal = orte.db + '-wal';
-      if (!db.walEingespielt && fs.existsSync(wal) && fs.statSync(wal).size > 32) {
-        hinweis = 'Die Modrinth App scheint gerade zu laufen – schließe sie, damit auch die neuesten Änderungen übernommen werden.';
-      }
-    } catch { /* egal */ }
-  } else if (fs.existsSync(profilesDir)) {
-    roh = leseProfileJson(profilesDir);
-  } else {
-    return { ok: false, reason: 'not-found' };
-  }
-
-  const instances = [];
-  for (const r of roh) {
-    const dir = path.join(profilesDir, String(r.path || ''));
-    if (!r.path || !fs.existsSync(dir)) continue;
-    const loader = LOADER.has(String(r.loader || '').toLowerCase()) ? String(r.loader).toLowerCase() : 'vanilla';
-    const version = String(r.gameVersion || '').trim();
-    const icon = r.iconPath && fs.existsSync(String(r.iconPath)) ? String(r.iconPath) : '';
-    instances.push({
-      folder: r.path,
-      dir,
-      gameDir: dir,
-      name: String(r.name || r.path),
-      group: r.gruppe || '',
-      version,
-      loader,
-      loaderVersion: loader === 'vanilla' ? '' : loaderVersion(loader, r.loaderVersion, version),
-      installiert: r.installiert,
-      iconPath: icon,
-      lastPlayed: zeitstempel(r.lastPlayed),
-      playSeconds: Math.max(0, Math.round(r.sekunden || 0)),
-      javaPath: String(r.javaPath || '').trim(),
-      maxMemMb: r.maxMemMb || null,
-      extraArgs: String(r.extraArgs || '').trim(),
-      preLaunchCommand: String(r.vorStart || '').trim(),
-      postExitCommand: String(r.nachEnde || '').trim(),
-      modpack: r.modpack,
-    });
-  }
-  instances.sort((a, b) => a.name.localeCompare(b.name, 'de'));
-  return { ok: true, basis: orte.basis, profilesDir, count: instances.length, instances, hinweis };
-}
-
-// gehört zur Modrinth App bzw. wird ohnehin neu erzeugt
-const NICHT_KOPIEREN = new Set(['profile.json', 'logs', '.fabric', '.quilt']);
-
-function copyInto(quelle, ziel) {
-  fs.mkdirSync(ziel, { recursive: true });
-  for (const name of fs.readdirSync(quelle)) {
-    if (NICHT_KOPIEREN.has(name.toLowerCase())) continue;
-    // dereference: die App verlinkt Dateien teils aus ihrem gemeinsamen Speicher
-    fs.cpSync(path.join(quelle, name), path.join(ziel, name), { recursive: true, dereference: true });
-  }
-}
-
-function importOne(store, entry, copyData = true) {
-  const created = store.createOrReplaceImportedInstance({
-    name: entry.name,
-    group: entry.group,
-    minecraft: { version: entry.version, loader: entry.loader, loaderVersion: entry.loaderVersion },
-  });
-
-  const patch = {};
-  if (entry.javaPath || entry.maxMemMb || entry.extraArgs) {
-    patch.java = { path: entry.javaPath || '', minMemMb: null, maxMemMb: entry.maxMemMb || null, extraArgs: entry.extraArgs || '' };
-  }
-  if (entry.preLaunchCommand) patch.preLaunchCommand = entry.preLaunchCommand;
-  if (entry.postExitCommand) patch.postExitCommand = entry.postExitCommand;
-  // Spielzeit und letzten Start mitnehmen (falls es die Instanz schon gab: das Größere)
-  const vorher = store.getInstance(created.id) || {};
-  if (entry.playSeconds > (vorher.totalPlaySeconds || 0)) patch.totalPlaySeconds = entry.playSeconds;
-  if (entry.lastPlayed && (!vorher.lastPlayed || entry.lastPlayed > vorher.lastPlayed)) patch.lastPlayed = entry.lastPlayed;
-  if (Object.keys(patch).length) store.updateInstance(created.id, patch);
-
-  let copied = false;
-  if (copyData && entry.gameDir && fs.existsSync(entry.gameDir)) {
-    copyInto(entry.gameDir, store.gameDir(created.id));
-    copied = true;
-  }
-  if (entry.iconPath) {
-    try { store.setCustomImage(created.id, entry.iconPath); } catch { /* Bild ist kein Muss */ }
-  }
-  return { id: created.id, name: created.name, copied };
-}
-
-module.exports = { scan, importOne, standardOrdner };
+'use strict';
+
+/*
+ * mrimport.js – Instanzen aus der Modrinth App übernehmen
+ * --------------------------------------------------------
+ * Die Modrinth App legt ihre Daten unter %APPDATA%\ModrinthApp ab (sehr alte
+ * Fassungen: %APPDATA%\com.modrinth.theseus). Die Spielordner liegen in
+ * "profiles\<Ordner>", die Angaben dazu (Name, Version, Loader, Gruppen,
+ * Arbeitsspeicher …) in der SQLite-Datenbank "app.db". Wurde der Datenordner in
+ * der App verlegt, steht der neue Ort in settings.custom_dir.
+ *
+ * Unterstützte Datenbank-Fassungen:
+ *   - ab Mitte 2026: Tabelle "instances" + "instance_content_sets" (Version/Loader),
+ *     Gruppen in "instance_group_memberships"/"instance_groups",
+ *     Starteinstellungen als JSONB in "instance_launch_overrides"
+ *   - 2024 bis Mitte 2026: eine Tabelle "profiles"
+ *   - vorher (ohne app.db): je Instanz eine profile.json
+ *
+ * Gelesen wird mit sql.js (SQLite als WebAssembly) auf einer Kopie im Speicher –
+ * die Datenbank der Modrinth App wird nie verändert.
+ */
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const LOADER = new Set(['vanilla', 'fabric', 'forge', 'neoforge', 'quilt']);
+
+let sqlPromise = null;
+function sqlJs() {
+  if (!sqlPromise) {
+    const initSqlJs = require('sql.js');
+    const wasmDir = path.dirname(require.resolve('sql.js'));
+    sqlPromise = initSqlJs({ locateFile: (datei) => path.join(wasmDir, datei) });
+  }
+  return sqlPromise;
+}
+
+function appDatenOrdner() {
+  const appdata = process.env.APPDATA || path.join(os.homedir(), 'AppData', 'Roaming');
+  return [path.join(appdata, 'ModrinthApp'), path.join(appdata, 'com.modrinth.theseus')];
+}
+
+function standardOrdner() {
+  return appDatenOrdner().find((d) => fs.existsSync(d)) || appDatenOrdner()[0];
+}
+
+function readJson(file) {
+  try { return JSON.parse(fs.readFileSync(file, 'utf8').replace(/^/, '')); } catch { return null; }
+}
+
+// Aus der Eingabe (App-Ordner, profiles-Ordner oder leer) die Orte ermitteln
+function ermittleOrte(eingabe) {
+  let basis = eingabe && eingabe.trim() ? eingabe.trim() : standardOrdner();
+  if (!fs.existsSync(basis)) return null;
+  // direkt den profiles-Ordner angegeben -> eine Ebene höher liegt die app.db
+  if (path.basename(basis).toLowerCase() === 'profiles' && !fs.existsSync(path.join(basis, 'app.db'))) {
+    const hoeher = path.dirname(basis);
+    if (fs.existsSync(path.join(hoeher, 'app.db')) || fs.existsSync(path.join(hoeher, 'profiles'))) basis = hoeher;
+  }
+  const db = path.join(basis, 'app.db');
+  return { basis, db: fs.existsSync(db) ? db : null };
+}
+
+// ---------- Datenbank ----------
+/*
+ * Läuft die Modrinth App, stehen die neuesten Änderungen oft noch im
+ * Schreibprotokoll (app.db-wal) statt in app.db. Dessen abgeschlossene
+ * Transaktionen spielen wir hier selbst auf die Kopie im Speicher ein – nach
+ * dem SQLite-Dateiformat (Kopf 32 Bytes, je Rahmen 24 Bytes Kopf + eine Seite),
+ * mit Prüfung von Salz und laufender Prüfsumme wie SQLite selbst.
+ * -> { daten, rahmen } oder null, wenn das Protokoll nicht passt
+ */
+function spieleWalEin(daten, walPfad) {
+  let wal;
+  try { wal = fs.readFileSync(walPfad); } catch { return null; }
+  if (wal.length < 32) return null;
+  const magie = wal.readUInt32BE(0);
+  if (magie !== 0x377f0682 && magie !== 0x377f0683) return null;
+  const bigEndian = magie === 0x377f0683;
+  const seite = wal.readUInt32BE(8);
+  const dbSeite = daten.readUInt16BE(16) === 1 ? 65536 : daten.readUInt16BE(16);
+  if (!seite || seite !== dbSeite) return null;
+  const salz1 = wal.readUInt32BE(16), salz2 = wal.readUInt32BE(20);
+
+  const wort = (buf, i) => (bigEndian ? buf.readUInt32BE(i) : buf.readUInt32LE(i));
+  let s0 = 0, s1 = 0;
+  const pruefe = (buf, start, ende) => {
+    for (let i = start; i < ende; i += 8) {
+      s0 = (s0 + wort(buf, i) + s1) >>> 0;
+      s1 = (s1 + wort(buf, i + 4) + s0) >>> 0;
+    }
+  };
+  pruefe(wal, 0, 24);
+  if (s0 !== wal.readUInt32BE(24) || s1 !== wal.readUInt32BE(28)) return null;
+
+  const fertig = new Map();   // Seitennummer -> Inhalt (abgeschlossene Transaktionen)
+  let offen = new Map();
+  let seiten = Math.floor(daten.length / seite);
+  let rahmen = 0;
+  for (let pos = 32; pos + 24 + seite <= wal.length; pos += 24 + seite) {
+    if (wal.readUInt32BE(pos + 8) !== salz1 || wal.readUInt32BE(pos + 12) !== salz2) break;
+    pruefe(wal, pos, pos + 8);
+    pruefe(wal, pos + 24, pos + 24 + seite);
+    if (s0 !== wal.readUInt32BE(pos + 16) || s1 !== wal.readUInt32BE(pos + 20)) break;
+    offen.set(wal.readUInt32BE(pos), wal.subarray(pos + 24, pos + 24 + seite));
+    const nachCommit = wal.readUInt32BE(pos + 4);
+    if (nachCommit) {       // Transaktion abgeschlossen
+      for (const [nr, inhalt] of offen) fertig.set(nr, inhalt);
+      offen = new Map();
+      seiten = nachCommit;
+      rahmen++;
+    }
+  }
+  if (!rahmen) return null;
+  const neu = Buffer.alloc(seiten * seite);
+  daten.copy(neu, 0, 0, Math.min(daten.length, neu.length));
+  for (const [nr, inhalt] of fertig) if (nr >= 1 && nr <= seiten) inhalt.copy(neu, (nr - 1) * seite);
+  return { daten: neu, rahmen };
+}
+
+async function oeffneDb(dbPfad) {
+  const SQL = await sqlJs();
+  let daten = fs.readFileSync(dbPfad);
+  let walEingespielt = false;
+  if (daten.length > 100 && daten[18] === 2) {
+    const mitWal = spieleWalEin(daten, dbPfad + '-wal');
+    if (mitWal) { daten = mitWal.daten; walEingespielt = true; }
+    // WAL-Datenbanken lassen sich ohne geteilten Speicher nicht öffnen – die
+    // Kopie im Speicher als normale Datenbank kennzeichnen (Bytes 18/19)
+    daten[18] = 1; daten[19] = 1;
+  }
+  const db = new SQL.Database(daten);
+  db.walEingespielt = walEingespielt;
+  return db;
+}
+
+function zeilen(db, sql, params) {
+  const st = db.prepare(sql);
+  try {
+    if (params) st.bind(params);
+    const out = [];
+    while (st.step()) out.push(st.getAsObject());
+    return out;
+  } finally {
+    st.free();
+  }
+}
+
+function tabellen(db) {
+  return new Set(zeilen(db, "SELECT name FROM sqlite_master WHERE type = 'table'").map((r) => r.name));
+}
+
+function spalten(db, tabelle) {
+  return new Set(zeilen(db, `PRAGMA table_info(${tabelle})`).map((r) => r.name));
+}
+
+function jsonFeld(wert) {
+  if (wert === null || wert === undefined || wert === '') return null;
+  try { return JSON.parse(wert); } catch { return null; }
+}
+
+// Spalte nur abfragen, wenn es sie gibt (ältere Fassungen kennen nicht alle)
+function sp(vorhanden, ausdruck, name, ersatz = 'NULL') {
+  return vorhanden.has(name) ? `${ausdruck} AS ${name}` : `${ersatz} AS ${name}`;
+}
+
+function eigenerOrdner(db, t) {
+  if (!t.has('settings') || !spalten(db, 'settings').has('custom_dir')) return null;
+  const r = zeilen(db, 'SELECT custom_dir FROM settings LIMIT 1')[0];
+  return r && r.custom_dir ? String(r.custom_dir) : null;
+}
+
+function leseNeu(db, t) {
+  const si = spalten(db, 'instances');
+  const liste = zeilen(db, `
+    SELECT i.id AS id, i.path AS path, i.name AS name,
+      ${sp(si, 'i.icon_path', 'icon_path')}, ${sp(si, 'i.install_stage', 'install_stage')},
+      ${sp(si, 'i.last_played', 'last_played')},
+      ${sp(si, 'i.submitted_time_played', 'submitted_time_played', '0')},
+      ${sp(si, 'i.recent_time_played', 'recent_time_played', '0')},
+      cs.game_version AS game_version, cs.loader AS loader, cs.loader_version AS loader_version
+    FROM instances i
+    LEFT JOIN instance_content_sets cs ON cs.id = i.applied_content_set_id`);
+
+  const overrides = new Map();
+  if (t.has('instance_launch_overrides')) {
+    for (const r of zeilen(db, 'SELECT instance_id, json(overrides) AS o FROM instance_launch_overrides')) {
+      overrides.set(r.instance_id, jsonFeld(r.o) || {});
+    }
+  }
+  const gruppen = new Map();
+  const merke = (id, name) => { if (name && !gruppen.has(id)) gruppen.set(id, String(name)); };
+  if (t.has('instance_group_memberships') && t.has('instance_groups')) {
+    for (const r of zeilen(db, `SELECT m.instance_id AS id, g.name AS name FROM instance_group_memberships m
+      JOIN instance_groups g ON g.id = m.group_id ORDER BY g.display_order`)) merke(r.id, r.name);
+  } else if (t.has('instance_groups') && spalten(db, 'instance_groups').has('group_name')) {
+    for (const r of zeilen(db, 'SELECT instance_id AS id, group_name AS name FROM instance_groups ORDER BY group_name')) merke(r.id, r.name);
+  }
+  const links = new Map();
+  if (t.has('instance_links')) {
+    for (const r of zeilen(db, 'SELECT instance_id, link_kind, modrinth_project_id, modrinth_version_id FROM instance_links')) {
+      if (r.modrinth_project_id && r.modrinth_version_id) links.set(r.instance_id, { projectId: r.modrinth_project_id, versionId: r.modrinth_version_id });
+    }
+  }
+
+  return liste.map((r) => {
+    const o = overrides.get(r.id) || {};
+    const hooks = o.hooks || {};
+    return {
+      path: r.path,
+      name: r.name,
+      iconPath: r.icon_path,
+      installiert: !r.install_stage || r.install_stage === 'installed',
+      lastPlayed: r.last_played,
+      sekunden: (Number(r.submitted_time_played) || 0) + (Number(r.recent_time_played) || 0),
+      gameVersion: r.game_version,
+      loader: r.loader,
+      loaderVersion: r.loader_version,
+      gruppe: gruppen.get(r.id) || '',
+      javaPath: o.java_path || '',
+      maxMemMb: o.memory && Number(o.memory.maximum) ? Number(o.memory.maximum) : null,
+      extraArgs: Array.isArray(o.extra_launch_args) ? o.extra_launch_args.join(' ') : '',
+      vorStart: hooks.pre_launch || '',
+      nachEnde: hooks.post_exit || '',
+      modpack: links.get(r.id) || null,
+    };
+  });
+}
+
+function leseProfile(db) {
+  const s = spalten(db, 'profiles');
+  const liste = zeilen(db, `SELECT path, name,
+      ${sp(s, 'icon_path', 'icon_path')}, ${sp(s, 'install_stage', 'install_stage')},
+      ${sp(s, 'game_version', 'game_version')}, ${sp(s, 'mod_loader', 'mod_loader')},
+      ${sp(s, 'mod_loader_version', 'mod_loader_version')}, ${sp(s, 'json(groups)', 'groups')},
+      ${sp(s, 'last_played', 'last_played')},
+      ${sp(s, 'submitted_time_played', 'submitted_time_played', '0')},
+      ${sp(s, 'recent_time_played', 'recent_time_played', '0')},
+      ${sp(s, 'override_java_path', 'override_java_path')},
+      ${sp(s, 'json(override_extra_launch_args)', 'override_extra_launch_args')},
+      ${sp(s, 'override_mc_memory_max', 'override_mc_memory_max')},
+      ${sp(s, 'override_hook_pre_launch', 'override_hook_pre_launch')},
+      ${sp(s, 'override_hook_post_exit', 'override_hook_post_exit')},
+      ${sp(s, 'linked_project_id', 'linked_project_id')}, ${sp(s, 'linked_version_id', 'linked_version_id')}
+    FROM profiles`);
+  return liste.map((r) => {
+    const gruppen = jsonFeld(r.groups);
+    const args = jsonFeld(r.override_extra_launch_args);
+    return {
+      path: r.path,
+      name: r.name,
+      iconPath: r.icon_path,
+      installiert: !r.install_stage || r.install_stage === 'installed',
+      lastPlayed: r.last_played,
+      sekunden: (Number(r.submitted_time_played) || 0) + (Number(r.recent_time_played) || 0),
+      gameVersion: r.game_version,
+      loader: r.mod_loader,
+      loaderVersion: r.mod_loader_version,
+      gruppe: Array.isArray(gruppen) && gruppen.length ? String(gruppen[0]) : '',
+      javaPath: r.override_java_path || '',
+      maxMemMb: Number(r.override_mc_memory_max) || null,
+      extraArgs: Array.isArray(args) ? args.join(' ') : '',
+      vorStart: r.override_hook_pre_launch || '',
+      nachEnde: r.override_hook_post_exit || '',
+      modpack: r.linked_project_id && r.linked_version_id ? { projectId: r.linked_project_id, versionId: r.linked_version_id } : null,
+    };
+  });
+}
+
+// sehr alte Fassungen: profiles\<Ordner>\profile.json
+function leseProfileJson(profilesDir) {
+  const liste = [];
+  for (const e of fs.readdirSync(profilesDir, { withFileTypes: true })) {
+    if (!e.isDirectory()) continue;
+    const p = readJson(path.join(profilesDir, e.name, 'profile.json'));
+    if (!p) continue;
+    const m = p.metadata || p;
+    const lv = m.loader_version;
+    liste.push({
+      path: e.name,
+      name: m.name || e.name,
+      iconPath: m.icon || null,
+      installiert: !p.install_stage || p.install_stage === 'installed',
+      lastPlayed: m.last_played || null,
+      sekunden: 0,
+      gameVersion: m.game_version,
+      loader: m.loader,
+      loaderVersion: lv && typeof lv === 'object' ? lv.id : lv,
+      gruppe: Array.isArray(m.groups) && m.groups.length ? String(m.groups[0]) : '',
+      javaPath: (p.java && (p.java.override_version && p.java.override_version.path)) || '',
+      maxMemMb: p.memory && Number(p.memory.maximum) ? Number(p.memory.maximum) : null,
+      extraArgs: p.java && Array.isArray(p.java.extra_arguments) ? p.java.extra_arguments.join(' ') : '',
+      vorStart: (p.hooks && p.hooks.pre_launch) || '',
+      nachEnde: (p.hooks && p.hooks.post_exit) || '',
+      modpack: m.linked_data && m.linked_data.project_id && m.linked_data.version_id
+        ? { projectId: m.linked_data.project_id, versionId: m.linked_data.version_id } : null,
+    });
+  }
+  return liste;
+}
+
+// "1.20.1-47.2.0" -> "47.2.0" usw. – AeroMC erwartet die reine Loader-Version
+function loaderVersion(loader, wert, mc) {
+  let v = String(wert || '').trim();
+  if (!v || v === 'stable' || v === 'latest') return '';
+  if (loader === 'forge') {
+    v = v.replace(/^forge-/i, '');
+    if (mc && v.startsWith(mc + '-')) v = v.slice(mc.length + 1);
+  } else if (loader === 'neoforge') {
+    v = v.replace(/^neoforge-/i, '');
+  } else if (loader === 'fabric' || loader === 'quilt') {
+    v = v.replace(/^(fabric|quilt)(-loader)?-/i, '');
+    if (mc && v.endsWith('-' + mc)) v = v.slice(0, -(mc.length + 1));
+  }
+  return v;
+}
+
+function zeitstempel(wert) {
+  if (!wert) return null;
+  const n = Number(wert);
+  if (Number.isFinite(n) && n > 0) return new Date(n < 1e12 ? n * 1000 : n).toISOString();
+  const d = new Date(wert);
+  return Number.isNaN(d.getTime()) ? null : d.toISOString();
+}
+
+/*
+ * Durchsucht die Modrinth App. Leere Eingabe = Standardort.
+ * -> { ok, basis, count, instances, hinweis }
+ */
+async function scan(eingabe) {
+  const orte = ermittleOrte(eingabe);
+  if (!orte) return { ok: false, reason: 'not-found' };
+
+  let roh = [];
+  let profilesDir = path.join(orte.basis, 'profiles');
+  let hinweis = '';
+  if (orte.db) {
+    const db = await oeffneDb(orte.db);
+    try {
+      const t = tabellen(db);
+      const eigener = eigenerOrdner(db, t);
+      if (eigener && fs.existsSync(path.join(eigener, 'profiles'))) profilesDir = path.join(eigener, 'profiles');
+      if (t.has('instances')) roh = leseNeu(db, t);
+      else if (t.has('profiles')) roh = leseProfile(db);
+    } finally {
+      db.close();
+    }
+    // Schreibprotokoll vorhanden, ließ sich aber nicht einspielen -> Kopie
+    // ist evtl. nicht ganz aktuell
+    try {
+      const wal = orte.db + '-wal';
+      if (!db.walEingespielt && fs.existsSync(wal) && fs.statSync(wal).size > 32) {
+        hinweis = 'Die Modrinth App scheint gerade zu laufen – schließe sie, damit auch die neuesten Änderungen übernommen werden.';
+      }
+    } catch { /* egal */ }
+  } else if (fs.existsSync(profilesDir)) {
+    roh = leseProfileJson(profilesDir);
+  } else {
+    return { ok: false, reason: 'not-found' };
+  }
+
+  const instances = [];
+  for (const r of roh) {
+    const dir = path.join(profilesDir, String(r.path || ''));
+    if (!r.path || !fs.existsSync(dir)) continue;
+    const loader = LOADER.has(String(r.loader || '').toLowerCase()) ? String(r.loader).toLowerCase() : 'vanilla';
+    const version = String(r.gameVersion || '').trim();
+    const icon = r.iconPath && fs.existsSync(String(r.iconPath)) ? String(r.iconPath) : '';
+    instances.push({
+      folder: r.path,
+      dir,
+      gameDir: dir,
+      name: String(r.name || r.path),
+      group: r.gruppe || '',
+      version,
+      loader,
+      loaderVersion: loader === 'vanilla' ? '' : loaderVersion(loader, r.loaderVersion, version),
+      installiert: r.installiert,
+      iconPath: icon,
+      lastPlayed: zeitstempel(r.lastPlayed),
+      playSeconds: Math.max(0, Math.round(r.sekunden || 0)),
+      javaPath: String(r.javaPath || '').trim(),
+      maxMemMb: r.maxMemMb || null,
+      extraArgs: String(r.extraArgs || '').trim(),
+      preLaunchCommand: String(r.vorStart || '').trim(),
+      postExitCommand: String(r.nachEnde || '').trim(),
+      modpack: r.modpack,
+    });
+  }
+  instances.sort((a, b) => a.name.localeCompare(b.name, 'de'));
+  return { ok: true, basis: orte.basis, profilesDir, count: instances.length, instances, hinweis };
+}
+
+// gehört zur Modrinth App bzw. wird ohnehin neu erzeugt
+const NICHT_KOPIEREN = new Set(['profile.json', 'logs', '.fabric', '.quilt']);
+
+/*
+ * Was beim Übernehmen kopiert wird: [{ von, name }] – `name` ist der Zielname
+ * im Spielordner der neuen Instanz. Das Kopieren selbst erledigt kopieren.js
+ * asynchron mit Fortschritt (main.js → fuehreImportAus).
+ */
+function kopierQuellen(entry) {
+  if (!entry.gameDir || !fs.existsSync(entry.gameDir)) return [];
+  return fs.readdirSync(entry.gameDir).filter((name) => !NICHT_KOPIEREN.has(name.toLowerCase()))
+    .map((name) => ({ von: path.join(entry.gameDir, name), name }));
+}
+
+function copyInto(quelle, ziel) {
+  fs.mkdirSync(ziel, { recursive: true });
+  for (const name of fs.readdirSync(quelle)) {
+    if (NICHT_KOPIEREN.has(name.toLowerCase())) continue;
+    // dereference: die App verlinkt Dateien teils aus ihrem gemeinsamen Speicher
+    fs.cpSync(path.join(quelle, name), path.join(ziel, name), { recursive: true, dereference: true });
+  }
+}
+
+function importOne(store, entry, copyData = true) {
+  const created = store.createOrReplaceImportedInstance({
+    name: entry.name,
+    group: entry.group,
+    minecraft: { version: entry.version, loader: entry.loader, loaderVersion: entry.loaderVersion },
+  });
+
+  const patch = {};
+  if (entry.javaPath || entry.maxMemMb || entry.extraArgs) {
+    patch.java = { path: entry.javaPath || '', minMemMb: null, maxMemMb: entry.maxMemMb || null, extraArgs: entry.extraArgs || '' };
+  }
+  if (entry.preLaunchCommand) patch.preLaunchCommand = entry.preLaunchCommand;
+  if (entry.postExitCommand) patch.postExitCommand = entry.postExitCommand;
+  // Spielzeit und letzten Start mitnehmen (falls es die Instanz schon gab: das Größere)
+  const vorher = store.getInstance(created.id) || {};
+  if (entry.playSeconds > (vorher.totalPlaySeconds || 0)) patch.totalPlaySeconds = entry.playSeconds;
+  if (entry.lastPlayed && (!vorher.lastPlayed || entry.lastPlayed > vorher.lastPlayed)) patch.lastPlayed = entry.lastPlayed;
+  if (Object.keys(patch).length) store.updateInstance(created.id, patch);
+
+  let copied = false;
+  if (copyData && entry.gameDir && fs.existsSync(entry.gameDir)) {
+    copyInto(entry.gameDir, store.gameDir(created.id));
+    copied = true;
+  }
+  if (entry.iconPath) {
+    try { store.setCustomImage(created.id, entry.iconPath); } catch { /* Bild ist kein Muss */ }
+  }
+  return { id: created.id, name: created.name, copied };
+}
+
+module.exports = { scan, importOne, kopierQuellen, standardOrdner };

src/neustart.html

@@ -0,0 +1,51 @@
+<!DOCTYPE html>
+<html lang="de">
+<head>
+  <meta charset="UTF-8" />
+  <meta http-equiv="Content-Security-Policy" content="default-src 'self'; style-src 'self' 'unsafe-inline'; script-src 'self' 'unsafe-inline'; img-src 'self'" />
+  <title>AeroMC</title>
+  <!--
+    Neustart-Bildschirm (Mod-Schalter): liegt über dem Minecraft-Fenster, während
+    das Spiel beendet, die Mods umgestellt und Minecraft wieder gestartet wird –
+    bis man wieder auf dem Server bzw. in der Welt ist. Gleiches Bild wie der
+    Ladebildschirm im Spiel; Balken und Text an derselben Stelle (83,25 % der Höhe).
+    Der Launcher steuert die Seite über setze({ text, prozent }) und ausblenden().
+  -->
+  <style>
+    html, body { margin: 0; height: 100%; overflow: hidden; background: #0a0e1a; cursor: default; user-select: none; }
+    #bild { position: fixed; inset: 0; background: #0a0e1a url('assets/spieldesign/neustart.jpg') center / cover no-repeat; }
+    #ganz { position: fixed; inset: 0; opacity: 0; transition: opacity .35s ease; }
+    #ganz.sichtbar { opacity: 1; }
+    #balken {
+      position: absolute; left: 22%; right: 22%; top: 83.25%; height: max(8px, 1.15vh); transform: translateY(-50%);
+      border: max(1px, .18vh) solid #4fd2ff; padding: max(1px, .18vh); box-sizing: content-box; overflow: hidden;
+    }
+    #fuellung { height: 100%; width: 0; background: #4fd2ff; transition: width .4s ease; }
+    #balken.unbestimmt #fuellung { width: 30%; animation: wandern 1.3s ease-in-out infinite; }
+    @keyframes wandern { 0% { transform: translateX(-110%); } 100% { transform: translateX(370%); } }
+    #text {
+      position: absolute; left: 50%; top: 88.5%; transform: translateX(-50%);
+      padding: .55vh 1.6vh .7vh; border-radius: .9vh; background: rgba(6, 12, 28, .7);
+      color: #ecf4ff; font: 600 max(13px, 3.1vh) 'Segoe UI', sans-serif; white-space: nowrap;
+    }
+  </style>
+</head>
+<body>
+  <div id="ganz">
+    <div id="bild"></div>
+    <div id="balken" class="unbestimmt"><div id="fuellung"></div></div>
+    <div id="text">Mods werden übernommen …</div>
+  </div>
+  <script>
+    function setze(stand) {
+      if (stand.text) document.getElementById('text').textContent = stand.text;
+      const balken = document.getElementById('balken');
+      const hatProzent = typeof stand.prozent === 'number';
+      balken.classList.toggle('unbestimmt', !hatProzent);
+      document.getElementById('fuellung').style.width = hatProzent ? Math.max(2, Math.min(100, stand.prozent)) + '%' : '';
+    }
+    function ausblenden() { document.getElementById('ganz').classList.remove('sichtbar'); }
+    requestAnimationFrame(() => document.getElementById('ganz').classList.add('sichtbar'));
+  </script>
+</body>
+</html>