feat: Papierkorb, Abrufzaehler, WebP ohne Adressaenderung, ZIP hochladen

Vier Dinge, alle am laufenden Dienst gemessen.

PAPIERKORB. Loeschen war endgueltig -- bei einem Knopf "alle 3861 waehlen"
direkt neben "loeschen" ist das die falsche Haerte, und die Sicherung half nur
bis zum letzten naechtlichen Lauf. Die Datei wandert jetzt nach
/data/papierkorb, der Datensatz in eine eigene Tabelle, nach 30 Tagen raeumt
der Dienst stuendlich selbst auf. Der Ablagename traegt eine laufende Nummer:
unter demselben Pfad koennen nacheinander verschiedene Dateien gelegen haben,
und beide sollen zurueckholbar sein. Geprueft: loeschen -> oeffentlich 404,
Eintrag im Papierkorb, zurueckholen -> 200 samt neu gerechneter Vorschau.

ABRUFZAEHLER. media.abrufe und zuletzt_abgerufen. Gezaehlt wird im Speicher und
alle 30 Sekunden weggeschrieben -- ein UPDATE je Kachel waeren bei einer
Galerieseite 120 Schreibvorgaenge. Der 304 zaehlt mit (der Aufrufer WOLLTE die
Datei, er hatte sie nur schon), HEAD nicht. Was vor dem Einbau lag, steht als
"nie geholt" da, auch wenn es taeglich benutzt wurde -- die Karte im
Speicherbericht sagt das auch dazu, statt eine Zahl zu zeigen, die luegt.

WEBP OHNE ADRESSAENDERUNG. Der Pfad ist die Adresse: aus items/foo.png darf
nicht items/foo.webp werden. Die sparsame Fassung liegt deshalb DANEBEN und
wird unter DERSELBEN Adresse ausgeliefert, wenn der Aufrufer per Accept sagt,
dass er WebP versteht. Nachgemessen an einer Datei: 6448 Bytes fuer curl, 2758
fuer einen Browser. Ueber den ganzen Bestand: 3606 Fassungen, 199,3 MB ->
33,1 MB, gespart 166,2 MB. Bei 29 lohnt WebP nicht -- dort bleibt es beim
Original.

Zwei Dinge haengen daran, beide gegengeprueft: "Vary: Accept" (ohne die Zeile
legt ein Zwischenspeicher die WebP-Fassung fuer alle ab, auch fuer die, die sie
nicht lesen koennen) und getrennte ETags mit "-w" (sonst bekaeme jemand auf
seinen If-None-Match hin ein 304 fuer das falsche Bild). Gemessen: derselbe
ETag mit Accept -> 304, ohne Accept -> 200 mit dem PNG.

ZIP HOCHLADEN. Ein Archiv wird ausgepackt statt abgelegt, die Ordner darin
bleiben erhalten und haengen sich hinter den gewaehlten Zielordner. fflate und
nicht adm-zip: reines JavaScript, keine native Bibliothek -- dieses Projekt hat
schon einen halben Abend an einer ABI-Nummer verloren. Grenzen: 5000 Eintraege,
256 MB entpackt, geprueft VOR dem Entpacken (eine Zip-Bombe waere sonst schon
im Speicher). Zip-Slip gemessen: "../../../../etc/passwd" und
"..\..\windows\hosts" abgelehnt, die harmlose Datei im selben Archiv abgelegt.

UND EIN KNOPF, DER GELOGEN HAT. Der erste Nachruestlauf ueber alle Dateien
brauchte mehr als 90 Sekunden -- genau da gibt Nginx Proxy Manager auf. Der
Aufrufer sah einen 504, waehrend die Arbeit im Hintergrund weiterlief und
fertig wurde. Ein Knopf, der Erfolg als Fehler meldet, ist schlimmer als einer
ohne Rueckmeldung.

Beide Wartungsknoepfe laufen deshalb in Runden zu 300 Stueck: der Server meldet
"offen" und "fertig", die Oberflaeche ruft erneut auf und zeigt dabei "280
erzeugt, noch 129 offen ...". Gemessen: 7,8 s je Runde statt 90+ am Stueck. Der
Vorschau-Knopf hatte dieselbe Wand und wurde mitgezogen, obwohl er noch nicht
dagegengelaufen war.

Nebenbei: der Verwaisten-Sucher kennt jetzt auch /data/webp (gleiche Schleife,
Ordner im Ergebnis vorangestellt), Verschieben und Loeschen nehmen die sparsame
Fassung mit, und das Loeschen eines Ordners raeumt thumbs/ und webp/ hinterher.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

server/src/storage.ts

@@ -235,21 +235,121 @@ export async function moveFile(von: string, nach: string): Promise<void> {
     await mkdir(dirname(ziel), { recursive: true })
     await rename(absolutePath(von), ziel)
 
+    const abgeleitet: [string, string][] = [
+        [thumbPath(von), thumbPath(nach)],
+        [webpPfad(von), webpPfad(nach)],
+    ]
+    for (const [vonPfad, nachPfad] of abgeleitet) {
+        try {
+            await mkdir(dirname(nachPfad), { recursive: true })
+            await rename(vonPfad, nachPfad)
+        } catch {
+            // Nicht vorhanden — kein Fehler. Beides ist abgeleitet und laesst
+            // sich jederzeit neu rechnen.
+        }
+    }
+}
+
+// ---------------------------------------------------------- Die sparsame Fassung
+//
+// DAS PROBLEM. Die uebernommenen Item-Bilder sind PNG. Als WebP waeren sie ein
+// Bruchteil davon. Nur: DER PFAD IST DIE ADRESSE -- aus items/foo.png darf
+// nicht items/foo.webp werden, sonst zeigt jedes Skript ins Leere, das den
+// Namen schon kennt.
+//
+// DIE LOESUNG steht im Protokoll selbst. Der Browser sagt mit `Accept`, was er
+// versteht. Wir legen die sparsame Fassung DANEBEN und liefern sie unter
+// DERSELBEN Adresse aus, wenn der Aufrufer sie mag. Wer sie nicht mag -- Lua,
+// curl, ein aelteres Werkzeug -- bekommt unveraendert das Original. Niemand
+// muss etwas umstellen.
+//
+// Dazu gehoert `Vary: Accept` in der Antwort. Ohne die Zeile legt ein
+// Zwischenspeicher die WebP-Fassung fuer ALLE ab, auch fuer die, die sie nicht
+// lesen koennen. Unser Proxy speichert /f/ zwar gar nicht zwischen -- aber das
+// ist eine Einstellung, die jemand aendern kann, und darauf soll die
+// Richtigkeit nicht beruhen.
+
+export const webpPfad = (path: string) => join(config.dataDir, 'webp', `${path}.webp`)
+
+/** Fuer welche Arten sich eine sparsame Fassung lohnt.
+ *
+ *  WebP selbst NICHT: das waere ein Umkodieren ohne Gewinn. GIF auch nicht --
+ *  dort braeuchte es animiertes WebP, und der Gewinn ist klein gegen das
+ *  Risiko, dass die Bewegung dabei verlorengeht. */
+export const lohntWebp = (mime: string) =>
+    /^image\/(png|jpeg)$/.test(mime.split(';')[0]?.trim().toLowerCase() ?? '')
+
+/** Die sparsame Fassung erzeugen. Gibt ihre Groesse zurueck, oder null.
+ *
+ *  Schlaegt es fehl, ist das KEIN Fehler fuer den Aufrufer: dann wird eben
+ *  weiter das Original ausgeliefert, so wie bisher. */
+export async function writeWebp(path: string, data: Buffer): Promise<number | null> {
+    const ziel = webpPfad(path)
     try {
-        const thumbZiel = thumbPath(nach)
-        await mkdir(dirname(thumbZiel), { recursive: true })
-        await rename(thumbPath(von), thumbZiel)
-    } catch {
-        // Keine Vorschau vorhanden — kein Fehler. Sie laesst sich jederzeit
-        // neu rechnen.
+        const { default: sharp } = await import('sharp')
+        await mkdir(dirname(ziel), { recursive: true })
+
+        // OHNE Groessenaenderung -- anders als bei der Vorschau. Es geht um die
+        // Kodierung, nicht um die Aufloesung: wer ein 4K-Bild hochlaedt, will
+        // ein 4K-Bild, nur kleiner in Bytes.
+        const bild = await sharp(data, { animated: false }).webp({ quality: 82 }).toBuffer()
+
+        // NUR wenn es sich lohnt. Bei kleinen oder schon dichten PNG faellt
+        // WebP durchaus groesser aus -- dann waere die "sparsame" Fassung eine
+        // Verschwendung mit zusaetzlicher Verwaltung obendrauf. Eine alte
+        // Fassung, die nun nicht mehr lohnt, muss dabei weg: sonst liefert der
+        // Dienst weiter die groessere aus.
+        if (bild.length >= data.length) {
+            await rm(ziel, { force: true })
+            return null
+        }
+
+        const temp = `${ziel}.${process.pid}.tmp`
+        await writeFile(temp, bild)
+        await rename(temp, ziel)
+        return bild.length
+    } catch (err) {
+        console.error(`[webp] ${path}: ${err instanceof Error ? err.message : err}`)
+        return null
     }
 }
 
 export async function deleteFile(path: string): Promise<void> {
     await rm(absolutePath(path), { force: true })
-    // Die Vorschau geht mit. Sonst bleibt sie liegen, und beim naechsten Bild
-    // unter demselben Pfad sieht man das alte.
+    // Vorschau und sparsame Fassung gehen mit. Sonst bleiben sie liegen, und
+    // beim naechsten Bild unter demselben Pfad sieht man das alte.
     await rm(thumbPath(path), { force: true })
+    await rm(webpPfad(path), { force: true })
+}
+
+// ------------------------------------------------------------- Papierkorb
+//
+// Verschieben statt Loeschen. Der Ablagename traegt eine laufende Nummer, weil
+// unter demselben Pfad nacheinander verschiedene Dateien gelegen haben koennen
+// -- und beide sollen zurueckholbar sein.
+
+export const papierkorbPfad = (ablage: string) => join(config.dataDir, 'papierkorb', ablage)
+
+/** Die Datei in den Papierkorb legen. Gibt den Ablagenamen zurueck.
+ *
+ *  Die VORSCHAU wandert NICHT mit: sie laesst sich aus dem Bild neu rechnen,
+ *  und ein Papierkorb, der Abgeleitetes mitschleppt, ist doppelt so gross wie
+ *  noetig. */
+export async function inDenPapierkorb(path: string, id: number): Promise<string> {
+    const ablage = `${id}-${path.replace(/[\\/]/g, '_')}`
+    const ziel = papierkorbPfad(ablage)
+    await mkdir(dirname(ziel), { recursive: true })
+    await rename(absolutePath(path), ziel)
+    await rm(thumbPath(path), { force: true })
+    await rm(webpPfad(path), { force: true })
+    return ablage
+}
+
+/** Zurueck an ihren Platz. */
+export async function ausDemPapierkorb(ablage: string, path: string): Promise<void> {
+    const ziel = absolutePath(path)
+    await mkdir(dirname(ziel), { recursive: true })
+    await rename(papierkorbPfad(ablage), ziel)
 }
 
 export async function fileExists(path: string): Promise<boolean> {