Bump version to v0.1.6.5

README.md

@@ -57,10 +57,13 @@ Eine Web-App inspiriert von Heardle, bei der Nutzer täglich einen Song anhand k
     - **Global-Kuratoren:** Optionale globale Kuratoren, die für alle Rätsel zuständig sind.
     - **Kurator-Dashboard:** Eigene Dashboard-Seite (`/curator` oder `/de/curator`, `/en/curator`) für Kuratoren.
     - **Song-Verwaltung:** Kuratoren können Songs hochladen, bearbeiten und Genres/Specials zuweisen.
+    - **Curate Specials:** Kuratoren können in einem eigenen Bereich („Curate Specials“) die Startzeiten der Songs in ihren zugewiesenen Specials über den Waveform-Editor einstellen – streng begrenzt auf ihre eigenen Specials.
     - **Batch-Edit:** Mehrere Titel gleichzeitig bearbeiten (Genre/Special Toggle, Artist ändern, Exclude Global Flag setzen).
     - **Kommentar-Verwaltung:** Kuratoren können Spieler-Kommentare zu ihren Rätseln einsehen, als gelesen markieren und archivieren.
 - **Spieler-Kommentare:**
     - **Feedback an Kuratoren:** Spieler können nach Abschluss eines Rätsels optional eine Nachricht an die Kuratoren senden.
+    - **KI-gestützte Formulierungshilfe:** Nachrichten können vor dem Absenden auf Wunsch automatisch von einer KI umformuliert/verbessert werden.
+    - **Einklappbares Kommentar-Formular:** Das Nachrichtenformular ist dezent als einklappbarer Bereich eingebunden und stört den Spielfluss nicht.
     - **Automatische Zuordnung:** Kommentare werden automatisch an relevante Kuratoren verteilt (Genre-Kuratoren, Special-Kuratoren, Global-Kuratoren).
     - **Rate-Limiting:** Pro Spieler nur ein Kommentar pro Puzzle möglich.
     - **Kontext-Informationen:** Kommentare enthalten vollständigen Rätsel-Kontext (Hördle #, Genre/Special, Titel/Artist).
@@ -193,14 +196,16 @@ Das Projekt ist für den Betrieb mit Docker optimiert.
      - **Optional:** Setze ein Startdatum (Launch Date) und Enddatum.
      - **Optional:** Trage einen Kurator ein.
    - Weise Songs dem Special zu (über die Song-Bibliothek).
-   - Klicke auf "Curate" neben dem Special.
-   - Nutze den Waveform-Editor um den perfekten Ausschnitt zu wählen:
-     - **Klicken:** Positioniert die Selektion
-     - **Hovern:** Zeigt Vorschau der neuen Position
-     - **Zoom:** 🔍+ / 🔍− Buttons für detaillierte Ansicht
-     - **Pan:** ← / → Buttons zum Verschieben der Ansicht
-     - **Segment-Playback:** Teste einzelne Puzzle-Abschnitte
-     - **Save:** Speichere Änderungen mit dem grünen Button
+   - Die eigentliche Kuratierung (Auswahl des Ausschnitts) findet im **Kuratoren-Dashboard** statt:
+     - Logge dich als Kurator ein und gehe zu `/de/curator` oder `/en/curator`.
+     - Klicke im Dashboard auf **„Curate Specials“**, um eine Liste deiner zugewiesenen Specials zu sehen.
+     - Öffne ein Special und nutze dort den Waveform-Editor, um den perfekten Ausschnitt zu wählen:
+       - **Klicken:** Positioniert die Selektion
+       - **Hovern:** Zeigt Vorschau der neuen Position
+       - **Zoom:** 🔍+ / 🔍− Buttons für detaillierte Ansicht
+       - **Pan:** ← / → Buttons zum Verschieben der Ansicht
+       - **Segment-Playback:** Teste einzelne Puzzle-Abschnitte
+       - **Save:** Speichere Änderungen mit dem grünen Button
    - Die Spieler hören dann nur den kuratierten Ausschnitt.
    - Auf der Startseite werden zukünftige Specials unter "Coming soon" angezeigt (mit Datum und Kurator).
 

app/[locale]/admin/page.tsx

@@ -1320,20 +1320,45 @@ export default function AdminPage({ params }: { params: { locale: string } }) {
                 </form>
                 <div style={{ display: 'flex', flexWrap: 'wrap', gap: '0.5rem' }}>
                     {specials.map(special => (
-                        <div key={special.id} style={{
-                            background: '#f3f4f6',
-                            padding: '0.25rem 0.75rem',
-                            borderRadius: '999px',
-                            display: 'flex',
-                            alignItems: 'center',
-                            gap: '0.5rem',
-                            fontSize: '0.875rem'
-                        }}>
-                            <span>{getLocalizedValue(special.name, activeTab)} ({special._count?.songs || 0})</span>
-                            {special.subtitle && <span style={{ fontSize: '0.75rem', color: '#666', marginLeft: '0.25rem' }}>- {getLocalizedValue(special.subtitle, activeTab)}</span>}
-                            <Link href={`/admin/specials/${special.id}`} className="btn-primary" style={{ marginRight: '0.5rem', textDecoration: 'none' }}>{t('curate')}</Link>
-                            <button onClick={() => startEditSpecial(special)} className="btn-secondary" style={{ marginRight: '0.5rem' }}>{t('edit')}</button>
-                            <button onClick={() => handleDeleteSpecial(special.id)} className="btn-danger">{t('delete')}</button>
+                        <div
+                            key={special.id}
+                            style={{
+                                background: '#f3f4f6',
+                                padding: '0.25rem 0.75rem',
+                                borderRadius: '999px',
+                                display: 'flex',
+                                alignItems: 'center',
+                                gap: '0.5rem',
+                                fontSize: '0.875rem',
+                            }}
+                        >
+                            <span>
+                                {getLocalizedValue(special.name, activeTab)} ({special._count?.songs || 0})
+                            </span>
+                            {special.subtitle && (
+                                <span
+                                    style={{
+                                        fontSize: '0.75rem',
+                                        color: '#666',
+                                        marginLeft: '0.25rem',
+                                    }}
+                                >
+                                    - {getLocalizedValue(special.subtitle, activeTab)}
+                                </span>
+                            )}
+                            <button
+                                onClick={() => startEditSpecial(special)}
+                                className="btn-secondary"
+                                style={{ marginRight: '0.5rem' }}
+                            >
+                                {t('edit')}
+                            </button>
+                            <button
+                                onClick={() => handleDeleteSpecial(special.id)}
+                                className="btn-danger"
+                            >
+                                {t('delete')}
+                            </button>
                         </div>
                     ))}
                 </div>

app/[locale]/admin/specials/[id]/page.tsx

@@ -0,0 +1,7 @@
+'use client';
+
+import SpecialEditorPage from '@/app/admin/specials/[id]/page';
+
+export default SpecialEditorPage;
+
+

app/[locale]/curator/specials/[id]/page.tsx

@@ -0,0 +1,7 @@
+'use client';
+
+import CuratorSpecialEditorPage from '@/app/curator/specials/[id]/page';
+
+export default CuratorSpecialEditorPage;
+
+

app/[locale]/curator/specials/page.tsx

@@ -0,0 +1,7 @@
+'use client';
+
+import CuratorSpecialsPage from '@/app/curator/specials/page';
+
+export default CuratorSpecialsPage;
+
+

app/admin/page.tsx

@@ -638,20 +638,45 @@ export default function AdminPage() {
                 </form>
                 <div style={{ display: 'flex', flexWrap: 'wrap', gap: '0.5rem' }}>
                     {specials.map(special => (
-                        <div key={special.id} style={{
-                            background: '#f3f4f6',
-                            padding: '0.25rem 0.75rem',
-                            borderRadius: '999px',
-                            display: 'flex',
-                            alignItems: 'center',
-                            gap: '0.5rem',
-                            fontSize: '0.875rem'
-                        }}>
-                            <span>{special.name} ({special._count?.songs || 0})</span>
-                            {special.subtitle && <span style={{ fontSize: '0.75rem', color: '#666', marginLeft: '0.25rem' }}>- {special.subtitle}</span>}
-                            <a href={`/admin/specials/${special.id}`} className="btn-primary" style={{ marginRight: '0.5rem', textDecoration: 'none' }}>Curate</a>
-                            <button onClick={() => startEditSpecial(special)} className="btn-secondary" style={{ marginRight: '0.5rem' }}>Edit</button>
-                            <button onClick={() => handleDeleteSpecial(special.id)} className="btn-danger">Delete</button>
+                        <div
+                            key={special.id}
+                            style={{
+                                background: '#f3f4f6',
+                                padding: '0.25rem 0.75rem',
+                                borderRadius: '999px',
+                                display: 'flex',
+                                alignItems: 'center',
+                                gap: '0.5rem',
+                                fontSize: '0.875rem',
+                            }}
+                        >
+                            <span>
+                                {special.name} ({special._count?.songs || 0})
+                            </span>
+                            {special.subtitle && (
+                                <span
+                                    style={{
+                                        fontSize: '0.75rem',
+                                        color: '#666',
+                                        marginLeft: '0.25rem',
+                                    }}
+                                >
+                                    - {special.subtitle}
+                                </span>
+                            )}
+                            <button
+                                onClick={() => startEditSpecial(special)}
+                                className="btn-secondary"
+                                style={{ marginRight: '0.5rem' }}
+                            >
+                                Edit
+                            </button>
+                            <button
+                                onClick={() => handleDeleteSpecial(special.id)}
+                                className="btn-danger"
+                            >
+                                Delete
+                            </button>
                         </div>
                     ))}
                 </div>

app/admin/specials/[id]/page.tsx

@@ -1,102 +1,51 @@
 'use client';
 
 import { useEffect, useState } from 'react';
-import { useParams, useRouter } from 'next/navigation';
-import WaveformEditor from '@/components/WaveformEditor';
-
-interface Song {
-    id: number;
-    title: string;
-    artist: string;
-    filename: string;
-}
-
-interface SpecialSong {
-    id: number;
-    songId: number;
-    startTime: number;
-    order: number | null;
-    song: Song;
-}
-
-interface Special {
-    id: number;
-    name: string;
-    subtitle?: string;
-    maxAttempts: number;
-    unlockSteps: string;
-    songs: SpecialSong[];
-}
+import { useParams, useRouter, usePathname } from 'next/navigation';
+import CurateSpecialEditor, { CurateSpecial } from '@/components/CurateSpecialEditor';
 
 export default function SpecialEditorPage() {
     const params = useParams();
     const router = useRouter();
+    const pathname = usePathname();
     const specialId = params.id as string;
 
-    const [special, setSpecial] = useState<Special | null>(null);
-    const [selectedSongId, setSelectedSongId] = useState<number | null>(null);
+    // Locale aus dem Pfad ableiten (/en/..., /de/...)
+    const localeFromPath = pathname?.split('/')[1] as 'de' | 'en' | undefined;
+    const locale: 'de' | 'en' = localeFromPath === 'de' || localeFromPath === 'en' ? localeFromPath : 'en';
+
+    const [special, setSpecial] = useState<CurateSpecial | null>(null);
     const [loading, setLoading] = useState(true);
-    const [saving, setSaving] = useState(false);
-    const [pendingStartTime, setPendingStartTime] = useState<number | null>(null);
-    const [hasUnsavedChanges, setHasUnsavedChanges] = useState(false);
 
     useEffect(() => {
+        const fetchSpecial = async () => {
+            try {
+                const res = await fetch(`/api/specials/${specialId}`);
+                if (res.ok) {
+                    const data = await res.json();
+                    setSpecial(data);
+                }
+            } catch (error) {
+                console.error('Error fetching special:', error);
+            } finally {
+                setLoading(false);
+            }
+        };
+
         fetchSpecial();
     }, [specialId]);
 
-    const fetchSpecial = async () => {
-        try {
-            const res = await fetch(`/api/specials/${specialId}`);
-            if (res.ok) {
-                const data = await res.json();
-                setSpecial(data);
-                if (data.songs.length > 0) {
-                    setSelectedSongId(data.songs[0].songId);
-                    // Initialize pendingStartTime with the current startTime of the first song
-                    setPendingStartTime(data.songs[0].startTime);
-                }
-            }
-        } catch (error) {
-            console.error('Error fetching special:', error);
-        } finally {
-            setLoading(false);
-        }
-    };
+    const handleSaveStartTime = async (songId: number, startTime: number) => {
+        const res = await fetch(`/api/specials/${specialId}/songs`, {
+            method: 'PUT',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ songId, startTime }),
+        });
 
-    const handleStartTimeChange = (newStartTime: number) => {
-        setPendingStartTime(newStartTime);
-        setHasUnsavedChanges(true);
-    };
-
-    const handleSave = async () => {
-        if (!special || !selectedSongId || pendingStartTime === null) return;
-
-        setSaving(true);
-        try {
-            const res = await fetch(`/api/specials/${specialId}/songs`, {
-                method: 'PUT',
-                headers: { 'Content-Type': 'application/json' },
-                body: JSON.stringify({ songId: selectedSongId, startTime: pendingStartTime })
-            });
-
-            if (res.ok) {
-                // Update local state
-                setSpecial(prev => {
-                    if (!prev) return prev;
-                    return {
-                        ...prev,
-                        songs: prev.songs.map(ss =>
-                            ss.songId === selectedSongId ? { ...ss, startTime: pendingStartTime } : ss
-                        )
-                    };
-                });
-                setHasUnsavedChanges(false);
-                setPendingStartTime(null); // Reset pending state after saving
-            }
-        } catch (error) {
-            console.error('Error updating start time:', error);
-        } finally {
-            setSaving(false);
+        if (!res.ok) {
+            const errorText = await res.text().catch(() => res.statusText || 'Unknown error');
+            console.error('Error updating special song (admin):', res.status, errorText);
+            throw new Error(`Failed to save start time: ${errorText}`);
         }
     };
 
@@ -117,116 +66,16 @@ export default function SpecialEditorPage() {
         );
     }
 
-    const selectedSpecialSong = special.songs.find(ss => ss.songId === selectedSongId);
-    const unlockSteps = JSON.parse(special.unlockSteps);
-    const totalDuration = unlockSteps[unlockSteps.length - 1];
-
     return (
-        <div style={{ padding: '2rem', maxWidth: '1200px', margin: '0 auto' }}>
-            <div style={{ marginBottom: '2rem' }}>
-                <button
-                    onClick={() => router.push('/admin')}
-                    style={{
-                        padding: '0.5rem 1rem',
-                        background: '#e5e7eb',
-                        border: 'none',
-                        borderRadius: '0.5rem',
-                        cursor: 'pointer',
-                        marginBottom: '1rem'
-                    }}
-                >
-                    ← Back to Admin
-                </button>
-                <h1 style={{ fontSize: '2rem', fontWeight: 'bold' }}>
-                    Edit Special: {special.name}
-                </h1>
-                {special.subtitle && (
-                    <p style={{ fontSize: '1.125rem', color: '#4b5563', marginTop: '0.25rem' }}>
-                        {special.subtitle}
-                    </p>
-                )}
-                <p style={{ color: '#666', marginTop: '0.5rem' }}>
-                    Max Attempts: {special.maxAttempts} | Puzzle Duration: {totalDuration}s
-                </p>
-            </div>
-
-            {special.songs.length === 0 ? (
-                <div style={{ padding: '2rem', background: '#f3f4f6', borderRadius: '0.5rem', textAlign: 'center' }}>
-                    <p>No songs assigned to this special yet.</p>
-                    <p style={{ fontSize: '0.875rem', color: '#666', marginTop: '0.5rem' }}>
-                        Go back to the admin dashboard to add songs to this special.
-                    </p>
-                </div>
-            ) : (
-                <div>
-                    <div style={{ marginBottom: '2rem' }}>
-                        <h2 style={{ fontSize: '1.25rem', fontWeight: 'bold', marginBottom: '1rem' }}>
-                            Select Song to Curate
-                        </h2>
-                        <div style={{ display: 'grid', gridTemplateColumns: 'repeat(auto-fill, minmax(250px, 1fr))', gap: '1rem' }}>
-                            {special.songs.map(ss => (
-                                <div
-                                    key={ss.songId}
-                                    onClick={() => setSelectedSongId(ss.songId)}
-                                    style={{
-                                        padding: '1rem',
-                                        background: selectedSongId === ss.songId ? '#4f46e5' : '#f3f4f6',
-                                        color: selectedSongId === ss.songId ? 'white' : 'black',
-                                        borderRadius: '0.5rem',
-                                        cursor: 'pointer',
-                                        border: selectedSongId === ss.songId ? '2px solid #4f46e5' : '2px solid transparent'
-                                    }}
-                                >
-                                    <div style={{ fontWeight: 'bold' }}>{ss.song.title}</div>
-                                    <div style={{ fontSize: '0.875rem', opacity: 0.8 }}>{ss.song.artist}</div>
-                                    <div style={{ fontSize: '0.75rem', marginTop: '0.5rem', opacity: 0.7 }}>
-                                        Start: {ss.startTime}s
-                                    </div>
-                                </div>
-                            ))}
-                        </div>
-                    </div>
-
-                    {selectedSpecialSong && (
-                        <div>
-                            <h2 style={{ fontSize: '1.25rem', fontWeight: 'bold', marginBottom: '1rem' }}>
-                                Curate: {selectedSpecialSong.song.title}
-                            </h2>
-                            <div style={{ background: '#f9fafb', padding: '1.5rem', borderRadius: '0.5rem' }}>
-                                <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', marginBottom: '1rem' }}>
-                                    <p style={{ fontSize: '0.875rem', color: '#666', margin: 0 }}>
-                                        Click on the waveform to select where the puzzle should start. The highlighted region shows what players will hear.
-                                    </p>
-                                    <button
-                                        onClick={handleSave}
-                                        disabled={!hasUnsavedChanges || saving}
-                                        style={{
-                                            padding: '0.5rem 1.5rem',
-                                            background: hasUnsavedChanges ? '#10b981' : '#e5e7eb',
-                                            color: hasUnsavedChanges ? 'white' : '#9ca3af',
-                                            border: 'none',
-                                            borderRadius: '0.5rem',
-                                            cursor: hasUnsavedChanges && !saving ? 'pointer' : 'not-allowed',
-                                            fontWeight: 'bold',
-                                            fontSize: '0.875rem',
-                                            whiteSpace: 'nowrap'
-                                        }}
-                                    >
-                                        {saving ? '💾 Saving...' : hasUnsavedChanges ? '💾 Save Changes' : '✓ Saved'}
-                                    </button>
-                                </div>
-                                <WaveformEditor
-                                    audioUrl={`/uploads/${selectedSpecialSong.song.filename}`}
-                                    startTime={pendingStartTime ?? selectedSpecialSong.startTime}
-                                    duration={totalDuration}
-                                    unlockSteps={unlockSteps}
-                                    onStartTimeChange={handleStartTimeChange}
-                                />
-                            </div>
-                        </div>
-                    )}
-                </div>
-            )}
-        </div>
+        <CurateSpecialEditor
+            special={special}
+            locale={locale}
+            onBack={() => router.push('/admin')}
+            onSaveStartTime={handleSaveStartTime}
+            backLabel="← Back to Admin"
+            headerPrefix="Edit Special:"
+            noSongsSubHint="Go back to the admin dashboard to add songs to this special."
+        />
     );
 }
+

app/api/curator/specials/[id]/route.ts

@@ -0,0 +1,58 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { PrismaClient } from '@prisma/client';
+import { requireStaffAuth } from '@/lib/auth';
+
+const prisma = new PrismaClient();
+
+export async function GET(
+    request: NextRequest,
+    { params }: { params: Promise<{ id: string }> }
+) {
+    const { error, context } = await requireStaffAuth(request);
+    if (error || !context) return error!;
+
+    if (context.role !== 'curator') {
+        return NextResponse.json(
+            { error: 'Only curators can access this endpoint' },
+            { status: 403 }
+        );
+    }
+
+    const { id } = await params;
+    const specialId = Number(id);
+    if (!specialId || Number.isNaN(specialId)) {
+        return NextResponse.json({ error: 'Invalid special id' }, { status: 400 });
+    }
+
+    // Prüfen, ob dieses Special dem Kurator zugeordnet ist
+    const assignment = await prisma.curatorSpecial.findFirst({
+        where: { curatorId: context.curator.id, specialId },
+    });
+
+    if (!assignment) {
+        return NextResponse.json(
+            { error: 'Forbidden: You are not allowed to access this special' },
+            { status: 403 }
+        );
+    }
+
+    const special = await prisma.special.findUnique({
+        where: { id: specialId },
+        include: {
+            songs: {
+                include: {
+                    song: true,
+                },
+                orderBy: { order: 'asc' },
+            },
+        },
+    });
+
+    if (!special) {
+        return NextResponse.json({ error: 'Special not found' }, { status: 404 });
+    }
+
+    return NextResponse.json(special);
+}
+
+

app/api/curator/specials/[id]/songs/route.ts

@@ -0,0 +1,69 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { PrismaClient } from '@prisma/client';
+import { requireStaffAuth } from '@/lib/auth';
+
+const prisma = new PrismaClient();
+
+export async function PUT(
+    request: NextRequest,
+    { params }: { params: Promise<{ id: string }> }
+) {
+    const { error, context } = await requireStaffAuth(request);
+    if (error || !context) return error!;
+
+    if (context.role !== 'curator') {
+        return NextResponse.json(
+            { error: 'Only curators can access this endpoint' },
+            { status: 403 }
+        );
+    }
+
+    try {
+        const { id } = await params;
+        const specialId = Number(id);
+        const { songId, startTime, order } = await request.json();
+
+        if (!specialId || Number.isNaN(specialId)) {
+            return NextResponse.json({ error: 'Invalid special id' }, { status: 400 });
+        }
+
+        if (!songId || typeof startTime !== 'number') {
+            return NextResponse.json({ error: 'Missing songId or startTime' }, { status: 400 });
+        }
+
+        // Prüfen, ob dieses Special dem Kurator zugeordnet ist
+        const assignment = await prisma.curatorSpecial.findFirst({
+            where: { curatorId: context.curator.id, specialId },
+        });
+
+        if (!assignment) {
+            return NextResponse.json(
+                { error: 'Forbidden: You are not allowed to edit this special' },
+                { status: 403 }
+            );
+        }
+
+        const specialSong = await prisma.specialSong.update({
+            where: {
+                specialId_songId: {
+                    specialId,
+                    songId,
+                },
+            },
+            data: {
+                startTime,
+                order,
+            },
+            include: {
+                song: true,
+            },
+        });
+
+        return NextResponse.json(specialSong);
+    } catch (e) {
+        console.error('Error updating curator special song:', e);
+        return NextResponse.json({ error: 'Internal Server Error' }, { status: 500 });
+    }
+}
+
+

app/api/curator/specials/route.ts

@@ -0,0 +1,47 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { PrismaClient } from '@prisma/client';
+import { requireStaffAuth } from '@/lib/auth';
+
+const prisma = new PrismaClient();
+
+export async function GET(request: NextRequest) {
+    const { error, context } = await requireStaffAuth(request);
+    if (error || !context) return error!;
+
+    if (context.role !== 'curator') {
+        return NextResponse.json(
+            { error: 'Only curators can access this endpoint' },
+            { status: 403 }
+        );
+    }
+
+    // Specials, die diesem Kurator zugewiesen sind
+    const assignments = await prisma.curatorSpecial.findMany({
+        where: { curatorId: context.curator.id },
+        select: { specialId: true },
+    });
+
+    if (assignments.length === 0) {
+        return NextResponse.json([]);
+    }
+
+    const specialIds = assignments.map(a => a.specialId);
+
+    const specials = await prisma.special.findMany({
+        where: { id: { in: specialIds } },
+        include: {
+            songs: true,
+        },
+        orderBy: { id: 'asc' },
+    });
+
+    const result = specials.map(special => ({
+        id: special.id,
+        name: special.name,
+        songCount: special.songs.length,
+    }));
+
+    return NextResponse.json(result);
+}
+
+

app/api/songs/route.ts

@@ -214,6 +214,7 @@ export async function POST(request: Request) {
 
         // Validate and extract metadata from file
         let metadata;
+        let releaseYear: number | null = null;
         let validationInfo = {
             isValid: true,
             hasCover: false,
@@ -244,6 +245,11 @@ export async function POST(request: Request) {
                 artist = metadata.common.albumartist;
             }
 
+            // Try to extract release year from tags (preferred over external APIs)
+            if (typeof metadata.common.year === 'number') {
+                releaseYear = metadata.common.year;
+            }
+
             // Validation info
             validationInfo.hasCover = !!metadata.common.picture?.[0];
             validationInfo.format = metadata.format.container || 'unknown';
@@ -338,17 +344,19 @@ export async function POST(request: Request) {
             console.error('Failed to extract cover image:', e);
         }
 
-        // Fetch release year from iTunes
-        let releaseYear = null;
-        try {
-            const { getReleaseYearFromItunes } = await import('@/lib/itunes');
-            releaseYear = await getReleaseYearFromItunes(artist, title);
+        // Fetch release year from iTunes only if not already present from tags
+        if (releaseYear == null) {
+            try {
+                const { getReleaseYearFromItunes } = await import('@/lib/itunes');
+                const fetchedYear = await getReleaseYearFromItunes(artist, title);
 
-            if (releaseYear) {
-                console.log(`Fetched release year ${releaseYear} from iTunes for "${title}" by "${artist}"`);
+                if (fetchedYear) {
+                    releaseYear = fetchedYear;
+                    console.log(`Fetched release year ${releaseYear} from iTunes for "${title}" by "${artist}"`);
+                }
+            } catch (e) {
+                console.error('Failed to fetch release year:', e);
             }
-        } catch (e) {
-            console.error('Failed to fetch release year:', e);
         }
 
         const song = await prisma.song.create({

app/curator/CuratorPageClient.tsx

@@ -807,6 +807,25 @@ export default function CuratorPageClient() {
                     )}
                 </div>
                 <div style={{ display: 'flex', gap: '0.5rem', alignItems: 'center' }}>
+                    <Link
+                        href="/curator/specials"
+                        style={{
+                            padding: '0.5rem 1rem',
+                            background: '#10b981',
+                            color: 'white',
+                            textDecoration: 'none',
+                            borderRadius: '0.375rem',
+                            fontSize: '0.9rem',
+                            display: 'inline-flex',
+                            alignItems: 'center',
+                            gap: '0.25rem',
+                            lineHeight: '1.5',
+                            boxSizing: 'border-box',
+                            fontFamily: 'inherit',
+                        }}
+                    >
+                        ✨ {t('curateSpecialsButton')}
+                    </Link>
                     <Link
                         href="/curator/help"
                         style={{

app/curator/help/CuratorHelpClient.tsx

@@ -95,6 +95,28 @@ export default function CuratorHelpClient() {
                     </div>
                 </section>
 
+                {/* Specials kuratieren */}
+                <section>
+                    <h2 style={{ fontSize: '1.5rem', marginBottom: '1rem', borderBottom: '2px solid #e5e7eb', paddingBottom: '0.5rem' }}>
+                        {t('curateSpecialsHelpTitle')}
+                    </h2>
+                    <div style={{ fontSize: '0.95rem', lineHeight: '1.7' }}>
+                        <p style={{ marginBottom: '1rem' }}>{t('curateSpecialsHelpIntro')}</p>
+                        <h3 style={{ fontSize: '1.1rem', marginTop: '1rem', marginBottom: '0.75rem' }}>
+                            {t('curateSpecialsHelpStepsTitle')}
+                        </h3>
+                        <ol style={{ marginLeft: '1.5rem', marginBottom: '1rem' }}>
+                            <li style={{ marginBottom: '0.5rem' }}>{t('curateSpecialsHelpStep1')}</li>
+                            <li style={{ marginBottom: '0.5rem' }}>{t('curateSpecialsHelpStep2')}</li>
+                            <li style={{ marginBottom: '0.5rem' }}>{t('curateSpecialsHelpStep3')}</li>
+                            <li style={{ marginBottom: '0.5rem' }}>{t('curateSpecialsHelpStep4')}</li>
+                        </ol>
+                        <p style={{ marginTop: '1rem', padding: '0.75rem', background: '#fef3c7', borderRadius: '0.375rem', border: '1px solid #fbbf24' }}>
+                            <strong>{t('note')}:</strong> {t('curateSpecialsPermissionsNote')}
+                        </p>
+                    </div>
+                </section>
+
                 {/* Kommentar-Verwaltung */}
                 <section>
                     <h2 style={{ fontSize: '1.5rem', marginBottom: '1rem', borderBottom: '2px solid #e5e7eb', paddingBottom: '0.5rem' }}>

app/curator/specials/[id]/page.tsx

@@ -0,0 +1,170 @@
+'use client';
+
+export const dynamic = 'force-dynamic';
+
+import { useEffect, useState } from 'react';
+import { useParams, useRouter, usePathname } from 'next/navigation';
+import { useLocale, useTranslations } from 'next-intl';
+import CurateSpecialEditor, { CurateSpecial } from '@/components/CurateSpecialEditor';
+import { getCuratorAuthHeaders } from '@/lib/curatorAuth';
+import HelpTooltip from '@/components/HelpTooltip';
+
+export default function CuratorSpecialEditorPage() {
+    const params = useParams();
+    const router = useRouter();
+    const pathname = usePathname();
+    const urlLocale = pathname?.split('/')[1] as 'de' | 'en' | undefined;
+    const intlLocale = useLocale() as 'de' | 'en';
+    const locale: 'de' | 'en' = urlLocale === 'de' || urlLocale === 'en' ? urlLocale : intlLocale;
+    const t = useTranslations('Curator');
+    const tHelp = useTranslations('CuratorHelp');
+
+    const specialId = params?.id as string;
+
+    const [special, setSpecial] = useState<CurateSpecial | null>(null);
+    const [loading, setLoading] = useState(true);
+    const [error, setError] = useState<string | null>(null);
+
+    useEffect(() => {
+        const fetchSpecial = async () => {
+            try {
+                setLoading(true);
+                const res = await fetch(`/api/curator/specials/${specialId}`, {
+                    headers: getCuratorAuthHeaders(),
+                });
+                if (res.status === 403) {
+                    setError(t('specialForbidden'));
+                    return;
+                }
+                if (!res.ok) {
+                    setError('Failed to load special');
+                    return;
+                }
+                const data = await res.json();
+                setSpecial(data);
+            } catch (e) {
+                setError('Failed to load special');
+            } finally {
+                setLoading(false);
+            }
+        };
+
+        if (specialId) {
+            fetchSpecial();
+        }
+    }, [specialId, t]);
+
+    const handleSaveStartTime = async (songId: number, startTime: number) => {
+        const res = await fetch(`/api/curator/specials/${specialId}/songs`, {
+            method: 'PUT',
+            headers: {
+                ...getCuratorAuthHeaders(),
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({ songId, startTime }),
+        });
+        if (res.status === 403) {
+            setError(t('specialForbidden'));
+        } else if (!res.ok) {
+            setError('Failed to save changes');
+        }
+    };
+
+    if (loading) {
+        return (
+            <div style={{ padding: '2rem', textAlign: 'center' }}>
+                <p>{t('loadingData')}</p>
+            </div>
+        );
+    }
+
+    if (error) {
+        return (
+            <div style={{ padding: '2rem', textAlign: 'center' }}>
+                <p>{error}</p>
+                <button
+                    onClick={() => router.push(`/${locale}/curator`)}
+                    style={{
+                        marginTop: '1rem',
+                        padding: '0.5rem 1rem',
+                        borderRadius: '0.5rem',
+                        border: 'none',
+                        background: '#e5e7eb',
+                        cursor: 'pointer',
+                    }}
+                >
+                    {t('backToDashboard')}
+                </button>
+            </div>
+        );
+    }
+
+    if (!special) {
+        return (
+            <div style={{ padding: '2rem', textAlign: 'center' }}>
+                <p>{t('specialNotFound')}</p>
+                <button
+                    onClick={() => router.push(`/${locale}/curator`)}
+                    style={{
+                        marginTop: '1rem',
+                        padding: '0.5rem 1rem',
+                        borderRadius: '0.5rem',
+                        border: 'none',
+                        background: '#e5e7eb',
+                        cursor: 'pointer',
+                    }}
+                >
+                    {t('backToDashboard')}
+                </button>
+            </div>
+        );
+    }
+
+    return (
+        <div style={{ padding: '2rem', maxWidth: '1200px', margin: '0 auto' }}>
+            <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', marginBottom: '1rem' }}>
+                <div style={{ display: 'flex', alignItems: 'center', gap: '0.5rem' }}>
+                    <h1 style={{ fontSize: '1.75rem', fontWeight: 'bold' }}>
+                        {t('curateSpecialHeaderPrefix')}
+                    </h1>
+                    <HelpTooltip
+                        shortText={tHelp('tooltipCurateSpecialEditorShort')}
+                        longText={tHelp('tooltipCurateSpecialEditorLong')}
+                        position="bottom"
+                    />
+                </div>
+                <button
+                    type="button"
+                    onClick={() => router.push(`/${locale}/curator/specials`)}
+                    style={{
+                        padding: '0.5rem 1rem',
+                        background: '#e5e7eb',
+                        borderRadius: '0.5rem',
+                        border: 'none',
+                        cursor: 'pointer',
+                        fontSize: '0.9rem',
+                    }}
+                >
+                    {t('backToCuratorSpecials')}
+                </button>
+            </div>
+
+            <CurateSpecialEditor
+                special={special}
+                locale={locale}
+                onBack={() => router.push(`/${locale}/curator/specials`)}
+                onSaveStartTime={handleSaveStartTime}
+                backLabel={t('backToCuratorSpecials')}
+                headerPrefix={t('curateSpecialHeaderPrefix')}
+                noSongsHint={t('curateSpecialNoSongs')}
+                noSongsSubHint={t('curateSpecialNoSongsSub')}
+                instructionsText={t('curateSpecialInstructions')}
+                savingLabel={t('saving')}
+                saveChangesLabel={t('saveChanges')}
+                savedLabel={t('saved')}
+            />
+        </div>
+    );
+}
+
+

app/curator/specials/page.tsx

@@ -0,0 +1,13 @@
+'use client';
+
+// Root /curator/specials route without locale:
+// redirect users to the default English locale version.
+
+import { redirect } from 'next/navigation';
+
+export default function CuratorSpecialsPage() {
+    redirect('/en/curator/specials');
+}
+
+
+

components/CurateSpecialEditor.tsx

@@ -0,0 +1,212 @@
+'use client';
+
+import { useState } from 'react';
+import WaveformEditor from '@/components/WaveformEditor';
+
+export type LocalizedString = string | { de: string; en: string };
+
+export interface CurateSpecialSong {
+    id: number;
+    songId: number;
+    startTime: number;
+    order: number | null;
+    song: {
+        id: number;
+        title: string;
+        artist: string;
+        filename: string;
+    };
+}
+
+export interface CurateSpecial {
+    id: number;
+    name: LocalizedString;
+    subtitle?: LocalizedString | null;
+    maxAttempts: number;
+    unlockSteps: string;
+    songs: CurateSpecialSong[];
+}
+
+export interface CurateSpecialEditorProps {
+    special: CurateSpecial;
+    locale: 'de' | 'en';
+    onBack: () => void;
+    onSaveStartTime: (songId: number, startTime: number) => Promise<void>;
+    backLabel?: string;
+    headerPrefix?: string;
+    noSongsHint?: string;
+    noSongsSubHint?: string;
+    instructionsText?: string;
+    savingLabel?: string;
+    saveChangesLabel?: string;
+    savedLabel?: string;
+}
+
+const resolveLocalized = (value: LocalizedString | null | undefined, locale: 'de' | 'en'): string | undefined => {
+    if (!value) return undefined;
+    if (typeof value === 'string') return value;
+    return value[locale] ?? value.en ?? value.de;
+};
+
+export default function CurateSpecialEditor({
+    special,
+    locale,
+    onBack,
+    onSaveStartTime,
+    backLabel = '← Back',
+    headerPrefix = 'Edit Special:',
+    noSongsHint = 'No songs assigned to this special yet.',
+    noSongsSubHint = 'Go back to the dashboard to add songs to this special.',
+    instructionsText = 'Click on the waveform to select where the puzzle should start. The highlighted region shows what players will hear.',
+    savingLabel = '💾 Saving...',
+    saveChangesLabel = '💾 Save Changes',
+    savedLabel = '✓ Saved',
+}: CurateSpecialEditorProps) {
+    const [selectedSongId, setSelectedSongId] = useState<number | null>(
+        special.songs.length > 0 ? special.songs[0].songId : null
+    );
+    const [pendingStartTime, setPendingStartTime] = useState<number | null>(
+        special.songs.length > 0 ? special.songs[0].startTime : null
+    );
+    const [hasUnsavedChanges, setHasUnsavedChanges] = useState(false);
+    const [saving, setSaving] = useState(false);
+
+    const specialName = resolveLocalized(special.name, locale) ?? `Special #${special.id}`;
+    const specialSubtitle = resolveLocalized(special.subtitle ?? null, locale);
+
+    const unlockSteps = JSON.parse(special.unlockSteps);
+    const totalDuration = unlockSteps[unlockSteps.length - 1];
+
+    const selectedSpecialSong = special.songs.find(ss => ss.songId === selectedSongId) ?? null;
+
+    const handleStartTimeChange = (newStartTime: number) => {
+        setPendingStartTime(newStartTime);
+        setHasUnsavedChanges(true);
+    };
+
+    const handleSave = async () => {
+        if (!selectedSongId || pendingStartTime === null) return;
+        setSaving(true);
+        try {
+            await onSaveStartTime(selectedSongId, pendingStartTime);
+            setHasUnsavedChanges(false);
+        } finally {
+            setSaving(false);
+        }
+    };
+
+    return (
+        <div style={{ padding: '2rem', maxWidth: '1200px', margin: '0 auto' }}>
+            <div style={{ marginBottom: '2rem' }}>
+                <button
+                    onClick={onBack}
+                    style={{
+                        padding: '0.5rem 1rem',
+                        background: '#e5e7eb',
+                        border: 'none',
+                        borderRadius: '0.5rem',
+                        cursor: 'pointer',
+                        marginBottom: '1rem'
+                    }}
+                >
+                    {backLabel}
+                </button>
+                <h1 style={{ fontSize: '2rem', fontWeight: 'bold' }}>
+                    {headerPrefix} {specialName}
+                </h1>
+                {specialSubtitle && (
+                    <p style={{ fontSize: '1.125rem', color: '#4b5563', marginTop: '0.25rem' }}>
+                        {specialSubtitle}
+                    </p>
+                )}
+                <p style={{ color: '#666', marginTop: '0.5rem' }}>
+                    Max Attempts: {special.maxAttempts} | Puzzle Duration: {totalDuration}s
+                </p>
+            </div>
+
+            {special.songs.length === 0 ? (
+                <div style={{ padding: '2rem', background: '#f3f4f6', borderRadius: '0.5rem', textAlign: 'center' }}>
+                    <p>{noSongsHint}</p>
+                    <p style={{ fontSize: '0.875rem', color: '#666', marginTop: '0.5rem' }}>
+                        {noSongsSubHint}
+                    </p>
+                </div>
+            ) : (
+                <div>
+                    <div style={{ marginBottom: '2rem' }}>
+                        <h2 style={{ fontSize: '1.25rem', fontWeight: 'bold', marginBottom: '1rem' }}>
+                            Select Song to Curate
+                        </h2>
+                        <div style={{ display: 'grid', gridTemplateColumns: 'repeat(auto-fill, minmax(250px, 1fr))', gap: '1rem' }}>
+                            {special.songs.map(ss => (
+                                <div
+                                    key={ss.songId}
+                                    onClick={() => {
+                                        setSelectedSongId(ss.songId);
+                                        setPendingStartTime(ss.startTime);
+                                        setHasUnsavedChanges(false);
+                                    }}
+                                    style={{
+                                        padding: '1rem',
+                                        background: selectedSongId === ss.songId ? '#4f46e5' : '#f3f4f6',
+                                        color: selectedSongId === ss.songId ? 'white' : 'black',
+                                        borderRadius: '0.5rem',
+                                        cursor: 'pointer',
+                                        border: selectedSongId === ss.songId ? '2px solid #4f46e5' : '2px solid transparent'
+                                    }}
+                                >
+                                    <div style={{ fontWeight: 'bold' }}>{ss.song.title}</div>
+                                    <div style={{ fontSize: '0.875rem', opacity: 0.8 }}>{ss.song.artist}</div>
+                                    <div style={{ fontSize: '0.75rem', marginTop: '0.5rem', opacity: 0.7 }}>
+                                        Start: {ss.startTime}s
+                                    </div>
+                                </div>
+                            ))}
+                        </div>
+                    </div>
+
+                    {selectedSpecialSong && (
+                        <div>
+                            <h2 style={{ fontSize: '1.25rem', fontWeight: 'bold', marginBottom: '1rem' }}>
+                                Curate: {selectedSpecialSong.song.title}
+                            </h2>
+                            <div style={{ background: '#f9fafb', padding: '1.5rem', borderRadius: '0.5rem' }}>
+                                <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', marginBottom: '1rem' }}>
+                                    <p style={{ fontSize: '0.875rem', color: '#666', margin: 0 }}>
+                                        {instructionsText}
+                                    </p>
+                                    <button
+                                        onClick={handleSave}
+                                        disabled={!hasUnsavedChanges || saving}
+                                        style={{
+                                            padding: '0.5rem 1.5rem',
+                                            background: hasUnsavedChanges ? '#10b981' : '#e5e7eb',
+                                            color: hasUnsavedChanges ? 'white' : '#9ca3af',
+                                            border: 'none',
+                                            borderRadius: '0.5rem',
+                                            cursor: hasUnsavedChanges && !saving ? 'pointer' : 'not-allowed',
+                                            fontWeight: 'bold',
+                                            fontSize: '0.875rem',
+                                            whiteSpace: 'nowrap'
+                                        }}
+                                    >
+                                        {saving ? savingLabel : hasUnsavedChanges ? saveChangesLabel : savedLabel}
+                                    </button>
+                                </div>
+                                <WaveformEditor
+                                    audioUrl={`/uploads/${selectedSpecialSong.song.filename}`}
+                                    startTime={pendingStartTime ?? selectedSpecialSong.startTime}
+                                    duration={totalDuration}
+                                    unlockSteps={unlockSteps}
+                                    onStartTimeChange={handleStartTimeChange}
+                                />
+                            </div>
+                        </div>
+                    )}
+                </div>
+            )}
+        </div>
+    );
+}
+
+

lib/curatorAuth.ts

@@ -0,0 +1,17 @@
+export function getCuratorAuthHeaders() {
+    if (typeof window === 'undefined') {
+        return {
+            'x-curator-auth': '',
+            'x-curator-username': '',
+        };
+    }
+
+    const authToken = localStorage.getItem('hoerdle_curator_auth');
+    const username = localStorage.getItem('hoerdle_curator_username') || '';
+    return {
+        'x-curator-auth': authToken || '',
+        'x-curator-username': username,
+    };
+}
+
+

messages/de.json

@@ -274,7 +274,25 @@
     "noBatchOperations": "Keine Batch-Operationen angegeben",
     "batchUpdateSuccess": "Erfolgreich {success} von {processed} Titeln aktualisiert",
     "batchUpdateError": "Fehler: {error}",
-    "batchUpdateNetworkError": "Netzwerkfehler bei der Batch-Aktualisierung"
+    "batchUpdateNetworkError": "Netzwerkfehler bei der Batch-Aktualisierung",
+    "backToDashboard": "Zurück zum Dashboard",
+    "curateSpecialsButton": "Specials kuratieren",
+    "curateSpecialsTitle": "Deine Specials kuratieren",
+    "curateSpecialsDescription": "Hier kannst du die Startzeiten der Songs in deinen zugewiesenen Specials für das Rätsel feinjustieren.",
+    "noSpecialPermissions": "Dir sind keine Specials zugeordnet.",
+    "noSpecialsInScope": "Keine Specials zum Kuratieren vorhanden.",
+    "curateSpecialSongCount": "{count, plural, one {# Song} other {# Songs}} in diesem Special",
+    "curateSpecialOpen": "Öffnen",
+    "specialForbidden": "Du darfst dieses Special nicht bearbeiten.",
+    "specialNotFound": "Special nicht gefunden.",
+    "backToCuratorSpecials": "Zurück zur Special-Übersicht",
+    "curateSpecialHeaderPrefix": "Special kuratieren:",
+    "curateSpecialNoSongs": "Diesem Special sind noch keine Songs zugeordnet.",
+    "curateSpecialNoSongsSub": "Gehe zurück zu deinem Dashboard, um diesem Special Songs zuzuordnen.",
+    "curateSpecialInstructions": "Klicke auf die Waveform, um zu wählen, wo das Rätsel starten soll. Der hervorgehobene Bereich zeigt, was die Spieler hören.",
+    "saving": "💾 Speichere...",
+    "saveChanges": "💾 Änderungen speichern",
+    "saved": "✓ Gespeichert"
   },
   "CuratorHelp": {
     "title": "Kurator-Hilfe & Handbuch",
@@ -335,6 +353,14 @@
     "troubleshootingA3": "Du kannst Songs nur Genres und Specials zuordnen, für die du verantwortlich bist. Wende dich an den Admin, wenn du Zugriff auf zusätzliche Genres oder Specials benötigst.",
     "troubleshootingQ4": "Warum ist die Exclude-Global-Checkbox deaktiviert?",
     "troubleshootingA4": "Nur Global-Kuratoren können das Exclude-Global-Flag ändern. Wenn du diese Berechtigung benötigst, wende dich an den Admin.",
+    "curateSpecialsHelpTitle": "Specials kuratieren",
+    "curateSpecialsHelpIntro": "Im Bereich „Curate Specials\" kannst du den exakten Audio-Ausschnitt festlegen, den Spieler in deinen Specials hören. Es werden nur Specials angezeigt, die dir zugewiesen sind.",
+    "curateSpecialsHelpStepsTitle": "So kuratierst du Specials",
+    "curateSpecialsHelpStep1": "Öffne das Kuratoren-Dashboard und klicke auf „Curate Specials\", um alle dir zugewiesenen Specials zu sehen.",
+    "curateSpecialsHelpStep2": "Wähle ein Special aus der Liste, um den Waveform-Editor für dieses Special zu öffnen.",
+    "curateSpecialsHelpStep3": "Klicke auf die Waveform, um die Startzeit zu wählen. Der hervorgehobene Bereich zeigt genau das, was Spieler hören werden.",
+    "curateSpecialsHelpStep4": "Nutze Zoom, Pan und Segment-Playback, um den Ausschnitt fein abzustimmen. Klicke auf „Änderungen speichern\", um die neue Startzeit zu übernehmen.",
+    "curateSpecialsPermissionsNote": "Du kannst nur Specials kuratieren, die dir zugewiesen sind. Wenn du versuchst, ein fremdes Special zu öffnen oder zu speichern, blockiert das System die Aktion.",
     "tooltipDashboardShort": "Übersicht über dein Kuratoren-Dashboard",
     "tooltipDashboardLong": "Dies ist dein Haupt-Dashboard, wo du Songs hochladen, deine Track-Liste verwalten und Kommentare von Spielern einsehen kannst. Nutze den Hilfe-Button (❓), um auf das vollständige Handbuch zuzugreifen.",
     "tooltipUploadShort": "MP3-Dateien zu deinen Genres hochladen",
@@ -356,7 +382,11 @@
     "tooltipBatchArtistShort": "Artist für alle ausgewählten Songs ändern",
     "tooltipBatchArtistLong": "Gib einen neuen Artist-Namen ein, um ihn für alle ausgewählten Songs zu setzen. Dies ist nützlich, um Artist-Namen zu korrigieren oder Namenskonventionen über mehrere Songs hinweg zu standardisieren.",
     "tooltipCommentsShort": "Spieler-Feedback und Kommentare",
-    "tooltipCommentsLong": "Spieler können dir Nachrichten zu Rätseln in deinen Genres oder Specials senden. Ungelesene Kommentare sind mit einem blauen Rahmen und Badge hervorgehoben. Klicke auf einen Kommentar, um ihn als gelesen zu markieren, oder archiviere ihn, wenn du ihn nicht mehr benötigst."
+    "tooltipCommentsLong": "Spieler können dir Nachrichten zu Rätseln in deinen Genres oder Specials senden. Ungelesene Kommentare sind mit einem blauen Rahmen und Badge hervorgehoben. Klicke auf einen Kommentar, um ihn als gelesen zu markieren, oder archiviere ihn, wenn du ihn nicht mehr benötigst.",
+    "tooltipCurateSpecialsShort": "Startzeiten für deine Specials kuratieren",
+    "tooltipCurateSpecialsLong": "In dieser Ansicht siehst du alle Specials, die dir zugewiesen sind. Öffne ein Special, um den Audio-Ausschnitt zu wählen, den die Spieler hören. Du kannst nur Specials sehen und bearbeiten, für die du zuständig bist.",
+    "tooltipCurateSpecialEditorShort": "Mit dem Waveform-Editor den Puzzle-Ausschnitt wählen",
+    "tooltipCurateSpecialEditorLong": "Klicke auf die Waveform, um zu bestimmen, wo das Rätsel startet. Nutze Zoom und Pan für Feineinstellungen und spiele einzelne Segmente ab, um sie zu testen. Beim Speichern wird nur dieser kuratierte Ausschnitt für Spieler in diesem Special verwendet."
   },
   "About": {
     "title": "Über Hördle & Impressum",

messages/en.json

@@ -274,7 +274,25 @@
     "noBatchOperations": "No batch operations specified",
     "batchUpdateSuccess": "Successfully updated {success} of {processed} songs",
     "batchUpdateError": "Error: {error}",
-    "batchUpdateNetworkError": "Network error during batch update"
+    "batchUpdateNetworkError": "Network error during batch update",
+    "backToDashboard": "Back to dashboard",
+    "curateSpecialsButton": "Curate Specials",
+    "curateSpecialsTitle": "Curate your Specials",
+    "curateSpecialsDescription": "Here you can fine-tune the start times of the songs in your assigned specials for the puzzle.",
+    "noSpecialPermissions": "You do not have any specials assigned to you.",
+    "noSpecialsInScope": "No specials available for you to curate.",
+    "curateSpecialSongCount": "{count, plural, one {# song} other {# songs}} in this special",
+    "curateSpecialOpen": "Open",
+    "specialForbidden": "You are not allowed to edit this special.",
+    "specialNotFound": "Special not found.",
+    "backToCuratorSpecials": "Back to specials overview",
+    "curateSpecialHeaderPrefix": "Curate Special:",
+    "curateSpecialNoSongs": "No songs assigned to this special yet.",
+    "curateSpecialNoSongsSub": "Go back to your dashboard to add songs to this special.",
+    "curateSpecialInstructions": "Click on the waveform to select where the puzzle should start. The highlighted region shows what players will hear.",
+    "saving": "💾 Saving...",
+    "saveChanges": "💾 Save Changes",
+    "saved": "✓ Saved"
   },
   "CuratorHelp": {
     "title": "Curator Help & Manual",
@@ -335,6 +353,14 @@
     "troubleshootingA3": "You can only assign songs to genres and specials that you are responsible for. Contact the admin if you need access to additional genres or specials.",
     "troubleshootingQ4": "Why is the exclude-from-global checkbox disabled?",
     "troubleshootingA4": "Only Global Curators can change the exclude-from-global flag. If you need this permission, contact the admin.",
+    "curateSpecialsHelpTitle": "Curating specials",
+    "curateSpecialsHelpIntro": "In the \"Curate Specials\" area you can choose the exact audio snippet that players will hear in your specials. You only ever see specials that are assigned to you.",
+    "curateSpecialsHelpStepsTitle": "How to curate specials",
+    "curateSpecialsHelpStep1": "Open the curator dashboard and click on \"Curate Specials\" to see all specials assigned to you.",
+    "curateSpecialsHelpStep2": "Select a special from the list to open the waveform editor for that special.",
+    "curateSpecialsHelpStep3": "Click on the waveform to choose the start time. The highlighted region shows exactly what players will hear.",
+    "curateSpecialsHelpStep4": "Use zoom, pan and segment playback to fine-tune the snippet. Click \"Save changes\" to apply the new start time.",
+    "curateSpecialsPermissionsNote": "You can only curate specials that are assigned to you. If you try to open or save a special that is not yours, the system will block the action.",
     "tooltipDashboardShort": "Overview of your curator dashboard",
     "tooltipDashboardLong": "This is your main dashboard where you can upload songs, manage your track list, and view comments from players. Use the help button (❓) to access the full manual.",
     "tooltipUploadShort": "Upload MP3 files to your genres",
@@ -356,7 +382,11 @@
     "tooltipBatchArtistShort": "Change artist for all selected songs",
     "tooltipBatchArtistLong": "Enter a new artist name to set it for all selected songs. This is useful for correcting artist names or standardizing naming conventions across multiple songs.",
     "tooltipCommentsShort": "Player feedback and comments",
-    "tooltipCommentsLong": "Players can send you messages about puzzles in your genres or specials. Unread comments are highlighted with a blue border and badge. Click on a comment to mark it as read, or archive it if you no longer need it."
+    "tooltipCommentsLong": "Players can send you messages about puzzles in your genres or specials. Unread comments are highlighted with a blue border and badge. Click on a comment to mark it as read, or archive it if you no longer need it.",
+    "tooltipCurateSpecialsShort": "Curate the start times for your specials",
+    "tooltipCurateSpecialsLong": "This view shows all specials that are assigned to you. Open a special to choose the audio snippet that players will hear. You can only see and edit specials for which you are responsible.",
+    "tooltipCurateSpecialEditorShort": "Use the waveform editor to pick the puzzle snippet",
+    "tooltipCurateSpecialEditorLong": "Click on the waveform to choose where the puzzle starts. Use zoom and pan for fine control, and play back individual segments to test them. When you save, only this curated snippet will be used for players in this special."
   },
   "About": {
     "title": "About Hördle & Imprint",

package.json

@@ -1,6 +1,6 @@
 {
   "name": "hoerdle",
-  "version": "0.1.6.3",
+  "version": "0.1.6.5",
   "private": true,
   "scripts": {
     "dev": "next dev",

scripts/restore-restic.sh

@@ -0,0 +1,98 @@
+#!/bin/bash
+# Restic restore script for Hördle deployment
+# Restores files from the Restic repository created by backup-restic.sh
+#
+# Usage:
+#   scripts/restore-restic.sh [SNAPSHOT] [TARGET_DIR]
+#
+#   SNAPSHOT   : Optional. Restic snapshot reference (ID, tag, or "latest").
+#                Defaults to "latest".
+#   TARGET_DIR : Optional. Directory to restore into.
+#                Defaults to "./restic-restore-<DATE>-<TIME>".
+#
+# Examples:
+#   scripts/restore-restic.sh
+#     → Restore latest snapshot into a new timestamped directory
+#
+#   scripts/restore-restic.sh latest ./restore-latest
+#     → Restore latest snapshot into ./restore-latest
+#
+#   scripts/restore-restic.sh d3adb33f ./restore-commit
+#     → Restore specific snapshot ID into ./restore-commit
+
+set -e
+
+echo "💾 Restoring from Restic backup..."
+
+if ! command -v restic >/dev/null 2>&1; then
+    echo "❌ restic nicht im PATH gefunden. Bitte installiere restic oder füge es zum PATH hinzu."
+    exit 1
+fi
+
+# Erforderliche Umgebungsvariablen prüfen
+if [ -z "$RESTIC_PASSWORD" ]; then
+    echo "❌ RESTIC_PASSWORD ist nicht gesetzt. Abbruch."
+    exit 1
+fi
+
+if [ -z "$RESTIC_AUTH_USER" ] || [ -z "$RESTIC_AUTH_PASSWORD" ]; then
+    echo "❌ RESTIC_AUTH_USER oder RESTIC_AUTH_PASSWORD ist nicht gesetzt. Abbruch."
+    exit 1
+fi
+
+# Repository-URL auf Basis des Backup-Skripts
+RESTIC_REPO="rest:https://${RESTIC_AUTH_USER}:${RESTIC_AUTH_PASSWORD}@restic.elpatron.me/"
+
+# Passwort für restic exportieren
+export RESTIC_PASSWORD
+
+# Snapshot-Referenz und Zielverzeichnis bestimmen
+SNAPSHOT_REF="${1:-latest}"
+TIMESTAMP="$(date +%Y-%m-%d_%H-%M-%S)"
+DEFAULT_TARGET_DIR="./restic-restore-${TIMESTAMP}"
+TARGET_DIR="${2:-$DEFAULT_TARGET_DIR}"
+
+echo "   Repository : $RESTIC_REPO"
+echo "   Snapshot   : $SNAPSHOT_REF"
+echo "   Zielordner : $TARGET_DIR"
+
+# Prüfen, ob Repository existiert
+if ! restic -r "$RESTIC_REPO" snapshots >/dev/null 2>&1; then
+    echo "❌ Kein gültiges Restic-Repository gefunden (oder keine Snapshots vorhanden)."
+    exit 1
+fi
+
+# Zielverzeichnis vorbereiten
+if [ -e "$TARGET_DIR" ] && [ ! -d "$TARGET_DIR" ]; then
+    echo "❌ $TARGET_DIR existiert und ist kein Verzeichnis. Abbruch."
+    exit 1
+fi
+
+if [ ! -d "$TARGET_DIR" ]; then
+    echo "   Erstelle Zielverzeichnis $TARGET_DIR ..."
+    mkdir -p "$TARGET_DIR"
+fi
+
+echo "   Verfügbare Snapshots (gekürzt):"
+restic -r "$RESTIC_REPO" snapshots --compact || true
+echo
+
+echo "   Starte Restic-Restore..."
+
+RESTIC_EXIT_CODE=0
+
+# Standard-Restore: gesamtes Repo in Zielverzeichnis
+# (Das spiegelt die beim Backup gesicherten Pfade unterhalb von TARGET_DIR.)
+restic -r "$RESTIC_REPO" restore "$SNAPSHOT_REF" \
+    --target "$TARGET_DIR" || RESTIC_EXIT_CODE=$?
+
+if [ $RESTIC_EXIT_CODE -eq 0 ]; then
+    echo "✅ Restic-Restore erfolgreich abgeschlossen."
+    echo "   Wiederhergestellte Daten befinden sich in: $TARGET_DIR"
+    exit 0
+else
+    echo "⚠️  Restic-Restore fehlgeschlagen (Exit-Code: $RESTIC_EXIT_CODE)."
+    exit $RESTIC_EXIT_CODE
+fi
+
+