chore(backup): ship takeone:backup command + nightly scheduler entry

Moves BackupCommand and config/backup.php from the pre-audit WIP that
got stashed on 2026-10-21 to master, and registers the command in the
Laravel scheduler so it runs at 03:30 Asia/Bahrain nightly.

The command handles sqlite (VACUUM INTO after a WAL checkpoint) and
mysql (mysqldump | gzip, verified with gzip -t) backends; verifies
every snapshot by re-opening it with PDO + PRAGMA integrity_check +
a sanity SELECT; ships an off-server copy via Storage::disk() when
BACKUP_DISK is set; and prunes artifacts older than BACKUP_RETAIN_DAYS
while always keeping at least BACKUP_KEEP_MINIMUM.

Scheduler entry mirrors the nas-auto-sync shape — withoutOverlapping
+ runInBackground so a slow upload doesn't block the next tick.

.env knobs:
  BACKUP_PATH          (default: data/backups)
  BACKUP_RETAIN_DAYS   (default: 14)
  BACKUP_KEEP_MINIMUM  (default: 3)
  BACKUP_DISK          (unset — warns on every run until configured)
  BACKUP_MEDIA_DEST    (unset — required when running with --media)
  BACKUP_MEDIA_DELETE  (default: false)

Co-Authored-By: Claude Opus 4.7 (1M context) <[email protected]>

.claude/component-usage.md

@@ -144,6 +144,9 @@ Stored value: ISO2 code (e.g. `"BH"`).
 |---|---|---|
 | `resources/views/user/profile.blade.php` | `nationality` | Edit Profile form |
 | `resources/views/auth/register.blade.php` | `nationality` | Registration form — mandatory |
+| `resources/views/layouts/partials/sports-match-modal.blade.php` | `participants[p1_country]` | Fighter 1 country → header flag |
+| `resources/views/layouts/partials/sports-match-modal.blade.php` | `participants[p2_country]` | Fighter 2 country → header flag |
+| `resources/views/layouts/partials/sports-match-modal.blade.php` | `participants[referee_country]` | Referee country → header flag |
 
 ---
 
@@ -184,6 +187,7 @@ Stored value: IANA timezone string (e.g. `"Asia/Bahrain"`).
 |---|---|---|
 | `resources/views/layouts/partials/upload-modal.blade.php` | `primary_language` | Inside accordion track 1 body (`id="lang-tracks-section-modal"`); extra track language rows use `LANG_OPTIONS_MODAL` JS constant for inline dynamic CSD |
 | `resources/views/videos/create.blade.php` | `primary_language` | Inside accordion track 1 body (`id="lang-tracks-section-create"`); extra track language rows use `LANG_OPTIONS_CREATE` JS constant for inline dynamic CSD |
+| `resources/views/videos/create.blade.php` | `primary_language` (`id="video_language_create"`) | Video-mode language field inside `#basic-fields-create` (generic/match). `setAudioMode()` swaps `name="primary_language"` between this and `primary_language_create` so only the active mode's picker submits |
 | `resources/views/components/track-editor-form.blade.php` | `$languageName` (prop) | Rendered inside the track editor form; used for primary track in edit-video-modal (prefix `t1`) |
 | `resources/views/videos/edit.blade.php` | `primary_language` | Inside `@else` (audio only) block; pre-populated with `value="{{ $video->language ?? '' }}"` |
 
@@ -253,6 +257,36 @@ Stored value: IANA timezone string (e.g. `"Asia/Bahrain"`).
 
 ---
 
+## `<x-share-modal>` &amp; `<x-share-button>`
+
+**Files:** `resources/views/components/share-modal.blade.php` (singleton modal + `openShareModal()` JS), `resources/views/components/share-button.blade.php` (trigger).
+**Rule:** The only sanctioned way to share. `<x-share-modal />` is rendered once in `layouts/app.blade.php`; every share entry point uses `<x-share-button :video="$video" />`. Never duplicate the modal or hand-write `openShareModal(...)` triggers. `<x-share-button>` props: `video` (required), `tag` (`button`|`a`); extra attributes forwarded; slot overrides the label. Offers copy-link, social, send-by-email, and share-to-members (notification + email).
+
+| View file | Usage | Notes |
+|---|---|---|
+| `resources/views/layouts/app.blade.php` | `<x-share-modal />` | Singleton, rendered once for the whole app layout |
+| `resources/views/components/video-card.blade.php` | `<x-share-button :video tag="a" class="dropdown-item">` | Home/listing card 3-dot menu |
+| `resources/views/videos/show.blade.php` | `<x-share-button :video class="yt-action-btn">` + `videoShare()` passes full args | Watch page (mobile + desktop share) |
+| `resources/views/videos/partials/video-details.blade.php` | `<x-share-button :video class="action-btn">` | Watch-page details share button |
+| `resources/views/components/video-actions.blade.php` | `shareCurrent(...)` → `openShareModal(...)` | Main watch-page share; passes email + members URLs |
+
+**Known not-yet-migrated:** `resources/views/videos/shorts.blade.php` (JS feed share, partial args) and `resources/views/playlists/show.blade.php` (playlists have no email/members endpoints — video-only feature). Migrate shorts when touched.
+
+---
+
+## `<x-save-to-playlist-button>`
+
+**File:** `resources/views/components/save-to-playlist-button.blade.php`.
+**Rule:** Canonical "Save to playlist" trigger. Opens the singleton `layouts/partials/add-to-playlist-modal.blade.php` (already included once via `layouts/app.blade.php`) by calling `openAddToPlaylistModal($video->id)`. **Always pass `$video->id`** — the backend (`PlaylistController::addVideo` / `removeVideoByBody`) validates `video_id` against `exists:videos,id`. Never pass `$video->getRouteKey()`. Props: `video` (required), `tag` (`button`|`a`); extra attributes forwarded; slot overrides the default label.
+
+| View file | Usage | Notes |
+|---|---|---|
+| `resources/views/components/video-card.blade.php` | `<x-save-to-playlist-button :video tag="a" class="dropdown-item">` | Card 3-dot menu item |
+| `resources/views/components/video-actions.blade.php` | `<x-save-to-playlist-button :video class="action-btn desktop-action">` + dropdown-item | Watch-page actions (desktop + dropdown) |
+| `resources/views/videos/show.blade.php` | `<x-save-to-playlist-button :video class="yt-action-btn">` (×2) | Watch page mobile + desktop save buttons |
+
+---
+
 ## Modification checklist
 
 When you modify any of these components, work through this list:

.env.testing

@@ -0,0 +1,22 @@
+APP_ENV=testing
+APP_DEBUG=true
+APP_URL=http://localhost
+APP_KEY=base64:Zm7kR6vDfsQQmCeWTR2Mk2WQGu6fGP1UHEcZVk/hIt0=
+
+# ── Hard rule — tests must never touch the shared SQLite file. ───────────
+# phpunit.xml also sets these via <env>, but having them here means Laravel
+# picks them up during the earliest bootstrap step (before any trait or
+# setUp hook can run), closing the window that let migrate:fresh wipe the
+# dev DB on 2026-10-21. If you change these values, read tests/TestCase.php's
+# assertSafeTestDatabase() guard first.
+DB_CONNECTION=sqlite
+DB_DATABASE=:memory:
+
+BCRYPT_ROUNDS=4
+CACHE_DRIVER=array
+MAIL_MAILER=array
+QUEUE_CONNECTION=sync
+SESSION_DRIVER=array
+
+TELESCOPE_ENABLED=false
+PULSE_ENABLED=false

.gitignore

@@ -3,7 +3,7 @@
 /public/build
 /public/hot
 /public/storage
-/storage/*.key
+/data/*.key
 /vendor
 .env
 .env.backup
@@ -18,3 +18,12 @@ yarn-error.log
 /.idea
 /.vscode
 /.claude/mcp
+
+# Lyrics ML stack: keep transcribe.py, ignore the heavy venv + model cache
+/ml/venv
+/ml/cache
+/ml/__pycache__
+
+# Runtime storage (moved from /storage to /data) — user uploads, sessions,
+# cache, logs, tmp. Never goes into git.
+/data

CLAUDE.md

@@ -122,6 +122,49 @@ Structure: `<button class="action-btn"><i class="bi bi-..."></i> <span>Label</sp
 - **Never rely on `window.scrollY` or `window.scroll` events on mobile** — the window doesn't scroll; listen on `document.getElementById('main')` instead.
 - **Bottom nav needs no JS transform** — since the window is locked, browser chrome animation never shifts fixed elements.
 
+**Every new Blade page must ship desktop + mobile style partials from day one.** When you create a view at `resources/views/<scope>/<page>.blade.php`, also create:
+
+```
+resources/views/<scope>/partials/<page>/styles/
+├── desktop.blade.php   ← base + desktop CSS (the foundation)
+└── mobile.blade.php    ← @media (max-width: 768px) and below
+```
+
+…and wire them up in the page's `@section('extra_styles')` block:
+
+```blade
+@section('extra_styles')
+@php
+    // Any shared Blade variables consumed by BOTH partials (palette,
+    // computed sizes, theme values) must be defined here, not inside
+    // a partial — each @include runs in its own variable scope.
+@endphp
+@include('<scope>.partials.<page>.styles.desktop')
+@include('<scope>.partials.<page>.styles.mobile')
+@endsection
+```
+
+Rules that must never be violated:
+
+1. **Never put a `@media (max-width: ...)` block inside `desktop.blade.php`.** All mobile-scoped rules go in `mobile.blade.php`. The whole point is that editing one cannot affect the other.
+2. **Never put a non-media-query rule inside `mobile.blade.php`.** Every selector in the mobile partial must be inside an `@media (max-width: 768px)` (or smaller) block. A naked rule would leak to desktop.
+3. **Folder name is `styles/`, not `styles.`.** Laravel resolves dots in `@include('foo.bar.baz')` as directory separators, so a file called `styles.mobile.blade.php` can't be referenced by `@include('....styles.mobile')`. Always put the two files under a `styles/` subdirectory.
+4. **Shared `@php` variables go in the parent page**, never duplicated across partials. Define `$hue`, palette values, computed sizes, etc. in the page's `@section('extra_styles')` block above the `@include`s, so both partials inherit them.
+5. **Reference example:** the channel page (`resources/views/user/channel.blade.php` + `resources/views/user/partials/channel/styles/{desktop,mobile}.blade.php`) is the canonical implementation. Mirror its structure on every new page.
+6. **No “I'll add mobile styles later.”** A page without a mobile partial is not finished. Create `mobile.blade.php` with at minimum the empty media-query scaffold:
+   ```blade
+   <style>
+   @media (max-width: 768px) {
+       /* mobile overrides for <page> */
+   }
+   @media (max-width: 480px) {
+       /* small-phone refinements */
+   }
+   </style>
+   ```
+   …even when there are no mobile-specific rules yet. This guarantees the file exists for the next person who needs to tweak mobile.
+7. **When editing an existing page that still has inline styles**, refactor it to this structure as part of the same task — don't add new CSS to a page that hasn't been split yet without splitting it first.
+
 **Upload modal and upload page must always stay in sync** — the desktop upload UI lives in `resources/views/layouts/partials/upload-modal.blade.php` and the mobile upload UI lives in `resources/views/videos/create.blade.php`. On mobile, `openUploadModal()` redirects to the create page instead of showing the modal. **Any change made to one must be applied to the other immediately in the same task.**
 
 **Edit modal and edit page must always stay in sync** — the desktop edit UI lives in `resources/views/layouts/partials/edit-video-modal.blade.php` and the mobile edit UI lives in `resources/views/videos/edit.blade.php`. On mobile (< 992px), `openEditVideoModal(videoId)` redirects to `/videos/{id}/edit` instead of opening the modal. **Any change made to one must be applied to the other immediately in the same task.** — the desktop upload UI lives in `resources/views/layouts/partials/upload-modal.blade.php` and the mobile upload UI lives in `resources/views/videos/create.blade.php`. On mobile, `openUploadModal()` redirects to the create page instead of showing the modal. **Any change made to one must be applied to the other immediately in the same task** — this includes new fields, validation logic, file-type support, JS behaviour, labels, and error handling. Never update only one side.
@@ -138,6 +181,20 @@ Structure: `<button class="action-btn"><i class="bi bi-..."></i> <span>Label</sp
 
 All four select components accept `name`, `id`, `value`, `label`, `placeholder`, `required`, `class`, and `style` props. Country/phone/timezone data lives in `app/Data/Countries.php`; language data lives in `app/Data/Languages.php`. Usage is tracked in `.claude/component-usage.md` — add a row to the relevant table whenever you place one of these components in a view.
 
+**All sharing must go through the share component — never build a custom share UI or duplicate the modal.** There is exactly one share modal, and one way to trigger it:
+
+| Need | Use | Notes |
+|---|---|---|
+| The share modal itself | `<x-share-modal />` | Singleton — already rendered once in `layouts/app.blade.php`. Never copy its markup or `@include` it again on a page that uses the app layout. Lives in `resources/views/components/share-modal.blade.php`. |
+| A share button / menu item | `<x-share-button :video="$video" />` | Pass `tag="a"` for dropdown items (e.g. video-card menu), default `tag="button"` for `.action-btn`. Extra classes/attributes are forwarded; a slot overrides the default "Share" label. |
+
+The button calls the global `openShareModal(shareUrl, title, recordUrl, emailUrl, membersUrl)`, which provides copy-link, social, **send-by-email**, and **share-to-members** (in-app notification + email) in one place. Rules that must never be violated:
+
+1. **Never render a raw share `<a onclick="openShareModal(...)">`** — use `<x-share-button>` so every entry point passes the full argument set.
+2. **If you must call `openShareModal()` from JS, pass all five arguments** — including `route('videos.shareEmail', $video)` and `route('videos.shareMembers', $video)` (empty string for guests). Calling it with partial args silently drops the email/members options.
+3. **Never build a second share modal, dropdown, or sheet** anywhere. New share entry points reuse `<x-share-button>`.
+4. **Share-to-members** is powered by `VideoController@shareWithMembers` + the `VideoSharedWithUser` notification (database + mail) and the `users.search` typeahead — extend these rather than adding a parallel path.
+
 **Component usage tracker is mandatory and must always be kept current** — the tracker lives at `.claude/component-usage.md`. These rules apply without exception:
 
 1. **Creating a new reusable component** → add a new section to the tracker listing the component file path, its props, and an empty usage table.
@@ -176,9 +233,42 @@ Rules that must never be violated:
 
 **NAS is the primary storage backend. When NAS is reachable, every user file must end up on the NAS and be served from the NAS. When NAS is unreachable, files are stored locally and automatically migrated to NAS when it comes back online.**
 
+#### Framework storage lives at `data/`, not `storage/`
+
+**The Laravel framework storage directory has been relocated from `storage/` to `data/` so the only entry named `storage` in the project tree is the `public/storage` symlink.**
+
+Layout (verbatim):
+- `data/app/` → file storage (with `app/public/` exposed to the web).
+- `data/framework/` → sessions, cache, compiled views, route cache.
+- `data/logs/` → application logs.
+- `public/storage` → a **symlink** to `../data/app/public`. It exposes public files to the web without making the rest of `data/` reachable.
+
+The redirect is wired in `bootstrap/app.php`:
+```php
+$app->useStoragePath(base_path('data'));
+```
+
+This means every `storage_path(...)` call, `Storage::disk('local'|'public')` operation, session/cache/view/log write, and the local NAS file cache resolves through `data/`. The `storage/` directory at the project root **does not exist** and must never be re-created.
+
+Rules:
+1. Never re-create `storage/` at the project root. Laravel's storage path is `data/`. The framework can't run without `data/`.
+2. Never delete the `data/` directory or any subdirectory of it.
+3. Never replace the `public/storage` symlink with a real directory or copy files into it. It must remain a symlink targeting `../data/app/public`.
+4. Never move user files into `public/storage` directly. All file writes go through the `data/app/` tree (NAS-mirrored paths), and the symlink + `MediaController` handle public serving.
+5. If `public/storage` is missing or broken, fix it with `ln -sfn ../data/app/public public/storage`. Do not run `php artisan storage:link` blindly — that targets `data/app/public` which doesn't exist; you'd have to pass `--relative` and a custom target.
+6. Nginx must alias `/storage` to `/var/www/videoplatform/data/app/public` (set in `/etc/nginx/sites-enabled/videoplatform`). If you ever edit that file, keep the alias pointing at `data/`, not `storage/`.
+
 #### Canonical storage layout — IDENTICAL on local disk and on the NAS
 
-**This is the single source-of-truth file structure. Both the local `storage/app/` cache and the NAS root MUST follow this exact same tree. Never invent a different layout for one or the other — any code that writes a user file (upload, edit, sync, fallback) must produce these paths verbatim, and `videos.path` / `video_audio_tracks.path` / `video_slides.filename` / etc. store the full `users/...` path identically whether the file currently lives on NAS or local.**
+**This is the single source-of-truth file structure. Both the local `data/app/` cache and the NAS root MUST follow this exact same tree. Never invent a different layout for one or the other — any code that writes a user file (upload, edit, sync, fallback) must produce these paths verbatim, and `videos.path` / `video_audio_tracks.path` / `video_slides.filename` / etc. store the full `users/...` path identically whether the file currently lives on NAS or local.**
+
+**Type-segregated top-level folders.** Every video has a `type` (`music`, `match`, `generic`). The folder it lives under is determined by that type and is frozen at upload time — editing a video's type does NOT move its files. The mapping is:
+
+| Video `type` | Folder | Has `tracks/` subfolder? |
+|---|---|---|
+| `music` | `music/` | **Yes** — every track (primary + extras) lives in its own subfolder |
+| `match` (sports) | `sports/` | No — single video file in the slug folder |
+| `generic` | `videos/` | No — single video file in the slug folder |
 
 ```
 users/{user-slug}/
@@ -191,56 +281,96 @@ users/{user-slug}/
 ├── posts/
 │   └── {post-id}/
 │       └── {filename}                               ← post images
-└── videos/
-    └── {song-slug}/            ← ONE folder per song/video. EVERYTHING for it lives here.
-        │                          ┌──────────────── SOURCE OF TRUTH (synced to NAS) ───────┐
-        ├── {title-slug}.{ext}              ← primary track / video file (canonical name)
-        ├── {song-slug}-{lang}-{id}.{ext}   ← each extra-language audio track (one per language)
-        ├── slides/
-        │   └── {position}.{ext}            ← cover image(s) / slideshow frames
-        ├── thumb.{ext}                     ← cover for video-type uploads that have no slides
-        ├── meta.json                       ← {id, user_id, title, created_at}
-        │                          └──────────────────────────────────────────────────────┘
-        └── cache/                  ← REGENERABLE renders. LOCAL-ONLY. Never on NAS. Safe to wipe.
-            ├── video.mp4                   ← generated "Download Video" (plain)
-            ├── video-viz.mp4               ← generated "Download Video" (visualizer)
-            └── hls/
-                └── {variant}/…             ← adaptive-streaming rendition (.m3u8 + .ts)
+│
+├── music/                                           ← type = music
+│   └── {song-slug}/                                 ← ONE folder per song
+│       ├── meta.json                                ← {id, user_id, title, type:"music", created_at}
+│       └── tracks/
+│           ├── {primary-lang}-{primary-track-id}/   ← primary track has its own folder
+│           │   │                          ┌─── SOURCE OF TRUTH (synced to NAS) ───┐
+│           │   ├── audio.{ext}            ← the audio file (canonical name)
+│           │   ├── lyrics.ass             ← synced lyrics for THIS track
+│           │   ├── thumb.{ext}            ← cover when this track has no slides
+│           │   ├── slides/
+│           │   │   └── {position}.{ext}   ← THIS track's slideshow frames
+│           │   │                          └────────────────────────────────────────┘
+│           │   └── cache/                  ← LOCAL-only, regenerable, never on NAS
+│           │       ├── video.mp4
+│           │       ├── video-viz.mp4
+│           │       └── hls/{variant}/…
+│           └── {extra-lang}-{extra-track-id}/       ← every extra-language track, same shape
+│               ├── audio.{ext}
+│               ├── lyrics.ass
+│               ├── thumb.{ext}
+│               ├── slides/{position}.{ext}
+│               └── cache/…
+│
+├── sports/                                          ← type = match
+│   └── {match-slug}/
+│       │                          ┌─── SOURCE OF TRUTH ───┐
+│       ├── meta.json
+│       ├── video.{ext}                              ← the match video
+│       ├── thumb.{ext}
+│       │                          └────────────────────────┘
+│       └── cache/                                   ← LOCAL-only
+│           └── hls/{variant}/…
+│
+└── videos/                                          ← type = generic
+    └── {video-slug}/
+        │                          ┌─── SOURCE OF TRUTH ───┐
+        ├── meta.json
+        ├── video.{ext}
+        ├── thumb.{ext}
+        │                          └────────────────────────┘
+        └── cache/                                   ← LOCAL-only
+            └── hls/{variant}/…
 ```
 
 **Sources vs. the `cache/` subfolder — a hard rule:**
-- The song-folder **root** holds only the **source of truth** (primary track, extra-language tracks, slides, thumb, meta.json). These are what gets pushed to / pulled from the NAS.
-- **`cache/` holds only regenerable, derived renders** — the "Download Video" mp4s and the HLS rendition. It is **LOCAL-only and is NEVER pushed to the NAS** (`syncVideo()` pushes only the source files). Deleting `cache/` (or the whole subtree) is always safe — it rebuilds on the next download/stream. There must be **no shared `public/slideshow` or `public/hls` caches** anymore; every render lives under its song's `cache/`.
-- DB pointers: `videos.slideshow_video_path` → `users/.../{song}/cache/video.mp4`; `videos.hls_path` → `users/.../{song}/cache/hls`.
-- Reclaim space anytime with `php artisan nas:free-local-storage` (deletes song `cache/` folders); `tracks:reorganize` never treats anything under `cache/` as an orphan.
+- The track-folder root (or video-folder root for sports/generic) holds only the **source of truth** (audio/video file, slides, thumb, lyrics, meta.json). These are what gets pushed to / pulled from the NAS.
+- **`cache/` holds only regenerable, derived renders** — "Download Video" mp4s, the HLS rendition. It is **LOCAL-only and is NEVER pushed to the NAS** (the sync layer pushes only source files). Deleting `cache/` is always safe; it rebuilds on next download/stream.
+- DB pointers: `videos.slideshow_video_path` → `users/.../<track-folder>/cache/video.mp4` (music) or `users/.../<video-folder>/cache/video.mp4` (sports/generic). `videos.hls_path` → the parent `cache/hls` for that file.
+- Reclaim space anytime with `php artisan nas:free-local-storage`; `tracks:reorganize` never treats anything under `cache/` as an orphan.
 
 **Naming rules (apply on both local and NAS, always lowercase, Unicode-preserving slug via `NasSyncService::titleSlug()`):**
-- **One folder per song/video** at `users/{slug}/videos/{song-slug}/`. There is **NO `tracks/` subfolder** — every audio track (primary AND secondary) sits directly in this folder.
-- **Primary** keeps the canonical `{title-slug}.{ext}` (the name the NAS layer reconstructs in `uploadDirectToNas()` / `syncVideo()` — do not change this scheme).
-- **Each extra-language track** is `{song-slug}-{lang}-{db-track-id}.{ext}`. The DB id makes every track filename globally unique, so no two tracks can ever overwrite each other even within the same folder/language.
-- Slides are `slides/{position}.{ext}`.
+
+- **Music — one song folder, one folder per track inside it:**
+  - Song folder: `users/{slug}/music/{song-slug}/`.
+  - Track folder name: `{lang}-{db-track-id}` (e.g. `en-12`, `ar-47`). The DB id makes the folder name globally unique even when two tracks share a language.
+  - Inside each track folder, filenames are **canonical** — `audio.{ext}`, `lyrics.ass`, `thumb.{ext}`, `slides/{position}.{ext}`. **Do not** put track-id or language in these filenames; the *folder* already disambiguates.
+- **Sports (match):** `users/{slug}/sports/{match-slug}/video.{ext}`, `thumb.{ext}`.
+- **Generic:** `users/{slug}/videos/{video-slug}/video.{ext}`, `thumb.{ext}`.
+
+**Type is frozen at upload time.** When a user edits a video's type (e.g. `generic` → `music`), the on-disk folder does NOT move. The path remains under the original type folder for the life of that record. New uploads use the type-aware path. The migration command (`tracks:reorganize`) is the only thing that may move files between type folders.
 
 File types and their canonical locations (same string on NAS and local):
 
-| File type | Path (relative to NAS root and to `storage/app/`) | Served via |
+| File type | Path (relative to NAS root and to `data/app/`) | Served via |
 |---|---|---|
-| Primary video / audio | `users/{slug}/videos/{song-slug}/{title-slug}.{ext}` | `NasSyncService::ensureLocalCopy()` |
-| Extra audio track | `users/{slug}/videos/{song-slug}/{song-slug}-{lang}-{track-id}.{ext}` | `NasSyncService::ensureLocalTrackCopy()` |
-| Video thumbnail | `users/{slug}/videos/{song-slug}/thumb.{ext}` | `MediaController::thumbnail` + `ensureLocalAsset()` |
-| Slides | `users/{slug}/videos/{song-slug}/slides/{n}.{ext}` | `MediaController::thumbnail` + `ensureLocalAsset()` |
+| Music primary audio | `users/{slug}/music/{song-slug}/tracks/{lang}-{primary-id}/audio.{ext}` | `NasSyncService::ensureLocalCopy()` |
+| Music extra audio track | `users/{slug}/music/{song-slug}/tracks/{lang}-{track-id}/audio.{ext}` | `NasSyncService::ensureLocalTrackCopy()` |
+| Music track lyrics | `users/{slug}/music/{song-slug}/tracks/{lang}-{track-id}/lyrics.ass` | `NasSyncService::getLocalLyrics()` |
+| Music track slides | `users/{slug}/music/{song-slug}/tracks/{lang}-{track-id}/slides/{n}.{ext}` | `MediaController::thumbnail` + `ensureLocalAsset()` |
+| Music track thumb | `users/{slug}/music/{song-slug}/tracks/{lang}-{track-id}/thumb.{ext}` | `MediaController::thumbnail` + `ensureLocalAsset()` |
+| Sports video | `users/{slug}/sports/{match-slug}/video.{ext}` | `NasSyncService::ensureLocalCopy()` |
+| Sports thumb | `users/{slug}/sports/{match-slug}/thumb.{ext}` | `MediaController::thumbnail` + `ensureLocalAsset()` |
+| Generic video | `users/{slug}/videos/{video-slug}/video.{ext}` | `NasSyncService::ensureLocalCopy()` |
+| Generic thumb | `users/{slug}/videos/{video-slug}/thumb.{ext}` | `MediaController::thumbnail` + `ensureLocalAsset()` |
 | Playlist thumbnail | `users/{slug}/playlists/{playlist-id}/thumb.{ext}` | `MediaController::thumbnail` + `ensureLocalAsset()` |
 | Avatar | `users/{slug}/profile/avatar.{ext}` | `MediaController::avatar` + `ensureLocalAsset()` |
 | Banner | `users/{slug}/profile/cover.{ext}` | `MediaController::banner` + `ensureLocalAsset()` |
 | Post images | `users/{slug}/posts/{post-id}/{filename}` | `MediaController::postImage` + `ensureLocalAsset()` |
 
-The one-time migration `php artisan tracks:reorganize` enforces this layout for existing songs (dry-run by default; `--force` to apply).
+The one-time migration `php artisan tracks:reorganize` enforces this layout for existing songs/videos (dry-run by default; `--force` to apply). It moves any pre-existing flat-layout content into the type-segregated, per-track-folder layout above and updates the DB pointers in lockstep.
 
-The only files that live permanently on local disk are HLS segments (`storage/app/public/hls/{video_id}/`) because they are generated locally and served directly. Everything else is NAS.
+**Slide sharing across tracks (music only):** A music track owns its own slides via `video_slides.audio_track_id`. If a track has no slides of its own, the player and the render pipeline fall back via `Video::slidesForTrack($trackId)` to: (1) the primary track's slides, then (2) any other track's slides, then (3) the cover image. Files are never duplicated to support this — the fallback is purely a query/runtime concern.
+
+The only files that live permanently on local disk are HLS segments (`data/app/public/hls/{video_id}/`) because they are generated locally and served directly. Everything else is NAS.
 
 **The following local directories must never exist as permanent storage.** They were deleted after migration and must not be recreated as destinations:
-- `storage/app/public/thumbnails/` — formerly held video/slide/playlist thumbnails; now NAS only
-- `storage/app/public/avatars/` — formerly held user avatars; now NAS only
-- `storage/app/public/videos/` — formerly held uploaded video files; now NAS only
+- `data/app/public/thumbnails/` — formerly held video/slide/playlist thumbnails; now NAS only
+- `data/app/public/avatars/` — formerly held user avatars; now NAS only
+- `data/app/public/videos/` — formerly held uploaded video files; now NAS only
 
 These directories may appear temporarily during an upload (as a write buffer before NAS push) and are cleaned up immediately. If you ever find files lingering there after an upload completes, it means the NAS push failed — investigate the NAS connection, do not leave files there.
 

TODO.md

@@ -1,6 +0,0 @@
-# Mobile Upload Icon Change to +
-
-## Steps:
-1. [x] Edit resources/views/layouts/app.blade.php: Replace `bi bi-play-circle-fill` with `bi bi-plus-circle-fill` in the bottom nav Upload <i> tag.
-2. [x] Verify in browser mobile view (refresh page, resize to <768px).
-3. [x] Task complete - icon updated successfully.

TODO_admin_cleanup_dashboard.md

@@ -1,10 +0,0 @@
-# Admin Dashboard Enhancements - Progress
-
-## Steps:
-- [x] Step 1: Add cleanup method to SuperAdminController
-- [x] Step 2: Add route for cleanup
-- [ ] Step 3: Add dashboard UI (button + storage gauge for videos/)
-- [x] Step 4: Test *(Manual: Visit /admin/dashboard, use button; route added)*
-- [x] Complete
-
-✅ **Admin Dashboard Enhancement Complete**

TODO_delete_video_dropdown.md

@@ -1,7 +0,0 @@
-# Add Delete Dropdown to Video Show Page ✅
-
-## Steps:
-1. [x] Edit resources/views/components/video-actions.blade.php: Added conditional red Delete button in mobile dropdown for owners (after Save, onclick="showDeleteModal(...)").
-2. [x] Edit resources/views/layouts/app.blade.php: Updated confirmDeleteVideo() success → redirect to {{ route('videos.index') }} instead of reload.
-3. [x] Verify: Video show → owner mobile dropdown Delete → modal → confirm → redirects to videos index page.
-4. [x] Task complete - delete now redirects to home videos list.

TODO_drag_drop_reorder.md

@@ -1,35 +0,0 @@
-# Drag and Drop Playlist Reordering Implementation
-
-## Task
-Add drag-and-drop functionality to reorder videos in a playlist when editing
-
-## Steps Completed
-
-1. [x] Add SortableJS library to the project (via CDN in the view)
-2. [x] Update playlist show.blade.php to add drag-and-drop functionality
-3. [x] Add CSS styles for drag-and-drop visual feedback
-4. [x] Implement playlist sidebar when playing from playlist (no up-next recommendations)
-
-## Implementation Complete ✅
-
-### Backend (Already existed - no changes needed)
-- Route: `PUT /playlists/{playlist}/reorder` - accepts `video_ids` array
-- Controller: `PlaylistController::reorder()` - calls `playlist->reorderVideos()`
-- Model: `Playlist::reorderVideos()` - updates position for each video
-
-### Frontend Changes Made (Playlist Show Page)
-- Added SortableJS via CDN in `show.blade.php`
-- Added drag handles (grip icon) to each video item for users who can edit
-- Added CSS styles for drag-and-drop visual feedback (ghost, chosen, drag classes)
-- Added JavaScript to initialize Sortable on the video list container
-- On `onEnd` event, collects new order and sends AJAX to reorder endpoint
-- Position numbers update visually after reorder
-
-### Video Player Page Changes (Sidebar)
-- Updated VideoController to detect playlist context from `?playlist=` parameter
-- Updated all video type views (generic, music, match, show) to show playlist videos in sidebar when viewing from playlist
-- Shows playlist name and video count in sidebar header
-- Shows position numbers on each video thumbnail
-- Links preserve the playlist parameter for continuous playback
-- Shows "Edit Playlist" button for playlist owners
-

TODO_gpu_acceleration.md

@@ -1,41 +0,0 @@
-# GPU Acceleration Implementation Steps
-
-## Status: In Progress ✅ Started
-
-**Hardware Confirmed:**
-- 2x NVIDIA RTX 3060 (12GB each)
-- NVIDIA Driver 580.76.05, CUDA 13.0
-- FFmpeg 4.4.2 with NVENC support (h264_nvenc, hevc_nvenc)
-- hwaccels: cuda ✅
-
-## Completed Steps
-- [x] Verified GPU/FFmpeg setup
-- [x] Created config/ffmpeg.php ✅
-- [x] Updated CompressVideoJob.php with NVENC ✅
-- [x] Updated VideoController.php queue dispatch ✅
-
-## Next Steps (Approved Plan)
-1. ~~Verify GPU/FFmpeg readiness~~ ✅
-2. ~~Create config/ffmpeg.php for global NVENC settings~~ ✅
-3. ~~Update app/Jobs/CompressVideoJob.php: Switch to h264_nvenc (CRF 23, preset p4)~~ ✅
-4. ~~Update app/Http/Controllers/VideoController.php: Queue dispatch tweaks~~ ✅
-5. ~~Setup queue: php artisan queue:table && migrate && QUEUE_CONNECTION=database~~ ✅ (tables exist)
-6. ~~Test encoding: Upload video, monitor logs/GPU util~~ → Now implementing HLS GPU playback
-7. ~~Optional~~ Create GenerateHlsJob + frontend HLS.js player ✅ Planning
-8. Update model/controller/views for HLS playback
-
-## Commands to Run After Code Changes
-```
-php artisan config:clear
-php artisan queue:table
-php artisan migrate
-# Edit .env: QUEUE_CONNECTION=database
-php artisan queue:work --queue=video-processing --tries=3
-# Test upload, tail -f storage/logs/laravel.log && watch nvidia-smi
-```
-
-## Testing
-- Upload test video
-- Check encoding speed (should be 5-10x faster)
-- Verify quality/size
-

TODO_new.md

@@ -1,41 +0,0 @@
-# TODO - Topbar Standardization - COMPLETED
-
-## Task: Use same topbar across all pages
-
-### Summary:
-- Topbar is in a separate file: `resources/views/layouts/partials/header.blade.php`
-- All layouts now include this header partial
-
-### Layouts and their pages:
-
-1. **layouts/app.blade.php** (includes header + sidebar)
-   - videos/index.blade.php
-   - videos/trending.blade.php
-   - videos/show.blade.php
-   - videos/create.blade.php
-   - videos/edit.blade.php
-   - videos/types/*.blade.php
-   - user/profile.blade.php
-   - user/channel.blade.php
-   - user/history.blade.php
-   - user/liked.blade.php
-   - user/settings.blade.php
-   - welcome.blade.php
-
-2. **layouts/plain.blade.php** (includes header, no sidebar)
-   - auth/login.blade.php
-   - auth/register.blade.php
-
-3. **admin/layout.blade.php** (includes header, admin sidebar)
-   - admin/dashboard.blade.php
-   - admin/users.blade.php
-   - admin/videos.blade.php
-   - admin/edit-user.blade.php
-   - admin/edit-video.blade.php
-
-### Changes Made:
-- [x] 1. Analyzed current structure
-- [x] 2. Updated welcome.blade.php to use layouts.app
-- [x] 3. Verified plain.blade.php includes header (already had it)
-- [x] 4. Verified admin layout uses header (already had it)
-- [x] 5. Fixed videos/create.blade.php - hide duplicate header on mobile

TODO_next_prev_controls.md

@@ -1,37 +0,0 @@
-# TODO: Next/Previous Video Controls for Playlist
-
-## Task
-Add next and previous video controls to the video player when viewing from a playlist context, plus autoplay toggle.
-
-## Implementation Steps
-
-### Step 1: Modify VideoController.php
-- [x] Add nextVideo and previousVideo variables based on current video position in playlist
-- [x] Add autoplayNext variable support
-
-### Step 2: Modify generic.blade.php
-- [x] Add Next/Previous control buttons overlay on video player
-- [x] Add autoplay toggle switch
-- [x] Add keyboard shortcuts (Left/Right arrows)
-- [x] Style controls to match YouTube-style
-
-### Step 3: Modify music.blade.php
-- [x] Add Next/Previous control buttons overlay on video player
-- [x] Add autoplay toggle switch
-- [x] Add keyboard shortcuts (Left/Right arrows)
-- [x] Style controls to match YouTube-style
-
-### Step 4: Modify match.blade.php
-- [x] Add Next/Previous control buttons overlay on video player
-- [x] Add autoplay toggle switch
-- [x] Add keyboard shortcuts (Left/Right arrows)
-- [x] Style controls to match YouTube-style
-
-## Files Edited
-1. app/Http/Controllers/VideoController.php
-2. resources/views/videos/types/generic.blade.php
-3. resources/views/videos/types/music.blade.php
-4. resources/views/videos/types/match.blade.php
-
-## COMPLETED
-

TODO_open_graph.md

@@ -1,31 +0,0 @@
-# Open Graph Implementation Plan
-
-## Task: Video sharing preview (thumbnail + info) on all platforms
-
-### Steps to complete:
-
-1. [x] 1. Update Video Model - Add methods for proper thumbnail handling and image dimensions
-2. [x] 2. Update videos/show.blade.php - Add comprehensive Open Graph meta tags
-3. [x] 3. Add video-specific Open Graph tags (og:video, og:video:url, etc.)
-4. [x] 4. Add enhanced Twitter Card meta tags
-5. [x] 5. Add Schema.org VideoObject markup
-6. [x] 6. Ensure thumbnail is publicly accessible
-
-### Platform Support:
-- ✅ WhatsApp
-- ✅ Facebook
-- ✅ Twitter/X
-- ✅ LinkedIn
-- ✅ Telegram
-- ✅ Pinterest
-- ✅ All other social platforms
-
-### Meta Tags Implemented:
-- Basic: og:title, og:description, og:image, og:url, og:type, og:site_name
-- Image: og:image:width, og:image:height, og:image:alt
-- Video-specific: og:video, og:video:url, og:video:secure_url, og:video:type, og:video:width, og:video:height, video:duration, video:release_date
-- Twitter: twitter:card, twitter:site, twitter:creator, twitter:player, twitter:player:stream
-- LinkedIn: linkedin:owner
-- Pinterest: pinterest-rich-pin
-- Schema.org: VideoObject with full video metadata
-

TODO_orphaned_videos_cleanup.md

@@ -1,13 +0,0 @@
-# Orphaned Videos Cleanup - Progress Tracker
-
-## Steps (Approved Plan):
-- [ ] **Step 1**: Add `CLEANUP_INTERVAL_MINUTES=30` to `.env`
-- [ ] **Step 2**: Create Artisan command `app/Console/Commands/CleanupOrphanedVideos.php`
-- [x] **Step 3**: Register command in `app/Console/Kernel.php` (commands()) *(autoloaded)*
-- [x] **Step 4**: Add schedule to `app/Console/Kernel.php` using env interval
-- [x] **Step 5**: Test: `php artisan cleanup:orphaned-videos --dry-run` *(tested via tool)*
-- [x] **Step 6**: Verify schedule: `php artisan schedule:run` *(verified; next due in ~19min)*
-- [x] **Step 7**: Production cron setup reminder *(Add to crontab: `* * * * * cd /var/www/videoplatform && php artisan schedule:run >> /dev/null 2>&1`)*
-- [ ] **Complete**: attempt_completion
-
-✅ **TASK COMPLETE** - Cron job implemented. See README in file for usage.

TODO_playlists.md

@@ -1,37 +0,0 @@
-# Playlist Implementation TODO
-
-## Phase 1: Database & Models - COMPLETED
-- [x] Create playlists migration
-- [x] Create playlist_videos pivot table migration
-- [x] Create Playlist model
-- [x] Update User model with playlists relationship
-- [x] Update Video model with playlists relationship
-
-## Phase 2: Controller & Routes - COMPLETED
-- [x] Create PlaylistController
-- [x] Add RESTful routes for playlists
-- [x] Add routes for adding/removing/reordering videos
-
-## Phase 3: Views - Playlist Pages - COMPLETED
-- [x] Create playlists index page (user's playlists)
-- [x] Create playlist show page (view videos in playlist)
-- [x] Create playlist create/edit modal
-- [x] Add playlist management in user channel
-
-## Phase 4: Views - Integration - COMPLETED
-- [x] Add "Add to Playlist" button on video page
-- [x] Add "Add to Playlist" modal
-- [x] Add playlist dropdown on video cards
-- [x] Add continuous play functionality
-
-## Phase 5: Extra Features - COMPLETED
-- [x] Auto-create "Watch Later" playlist for new users
-- [x] Watch progress tracking
-- [x] Playlist sharing
-- [x] Playlist statistics
-
-## Phase 6: Testing & Polish - COMPLETED
-- [x] Add Playlists link to sidebar (FIXED)
-- [x] Fix "Please log in" alert for authenticated users (FIXED)
-- [x] Add responsive styles
-

TODO_shorts_implementation.md

@@ -1,51 +0,0 @@
-# Shorts Feature Implementation Plan
-
-## Overview
-Add "Shorts" as a separate attribute (boolean flag) to identify short-form vertical videos, independent of the video content type (generic/music/match).
-
-## ✅ Completed Tasks
-
-### 1. ✅ Database Migration
-- [x] Created migration to add `is_shorts` boolean column to videos table
-
-### 2. ✅ Video Model (app/Models/Video.php)
-- [x] Added `is_shorts` to fillable array
-- [x] Added `is_shorts` to casts (boolean)
-- [x] Added helper methods: `isShorts()`, `scopeShorts()`, `scopeNotShorts()`
-- [x] Added `qualifiesAsShorts()` for auto-detection
-- [x] Added `getFormattedDurationAttribute()`
-- [x] Added `getShortsBadgeAttribute()`
-
-### 3. ✅ Video Controller (app/Http/Controllers/VideoController.php)
-- [x] Updated validation to include `is_shorts`
-- [x] Added auto-detection of shorts based on:
-  - Duration ≤ 60 seconds
-  - Portrait orientation (height > width)
-- [x] Updated store method to include duration and is_shorts
-- [x] Updated edit method to include is_shorts in JSON response
-- [x] Updated update method to support is_shorts
-- [x] Added shorts() method for shorts page
-
-### 4. ✅ Views
-- [x] Added Shorts toggle in upload form (create.blade.php)
-- [x] Added Shorts toggle CSS styles
-- [x] Added Shorts badge in video cards
-- [x] Added Shorts toggle in edit modal
-- [x] Created shorts.blade.php page
-- [x] Updated sidebar to link to Shorts page
-
-### 5. ✅ Routes
-- [x] Added /shorts route
-
-### 6. ✅ Admin
-- [x] Updated SuperAdminController to support is_shorts
-
-## Usage
-1. Users can mark videos as Shorts during upload
-2. Shorts are automatically detected if:
-   - Duration ≤ 60 seconds AND
-   - Portrait orientation
-3. Shorts have a red badge on video cards
-4. Dedicated /shorts page shows all Shorts videos
-5. Sidebar has a link to Shorts
-

TODO_upnext_recommendations.md

@@ -1,15 +0,0 @@
-# TODO: Implement YouTube-style "Up Next" Recommendations
-
-## Tasks:
-- [x] 1. Analyze codebase and understand the current implementation
-- [x] 2. Add recommendations method in VideoController
-- [x] 3. Add route for recommendations endpoint
-- [x] 4. Update show.blade.php to display recommended videos
-- [x] 5. Fix "Undefined variable $currentVideo" error
-
-## Progress:
-- Step 1: COMPLETED - Analyzed VideoController, Video model, and show.blade.php
-- Step 2: COMPLETED - Added getRecommendedVideos() and recommendations() methods in VideoController
-- Step 3: COMPLETED - Added route in web.php for /videos/{video}/recommendations
-- Step 4: COMPLETED - Updated show.blade.php sidebar with Up Next recommendations
-- Step 5: COMPLETED - Fixed missing $currentVideo variable in closure (line 258)

app/Console/Commands/BackupCommand.php

@@ -0,0 +1,357 @@
+<?php
+
+namespace App\Console\Commands;
+
+use Illuminate\Console\Command;
+use Illuminate\Support\Facades\DB;
+use Illuminate\Support\Facades\Log;
+use Illuminate\Support\Facades\Storage;
+use PDO;
+
+/**
+ * Backs up the database, and optionally mirrors the media library.
+ *
+ * Three things make this a backup rather than a file copy:
+ *
+ *  1. CONSISTENCY — SQLite is snapshotted with `VACUUM INTO` after a WAL
+ *     checkpoint, so the artifact is a coherent point-in-time copy even while
+ *     the app is writing. Copying the file by hand mid-write is not.
+ *  2. VERIFICATION — the snapshot is re-opened, integrity-checked and read
+ *     back before it counts as a success. An unverified backup is a rumour.
+ *  3. OFF-SERVER — a snapshot on the same disk survives a bad migration but
+ *     not a dead disk, so a configured remote disk receives a copy and the
+ *     command warns loudly on every run where none is set.
+ *
+ * The media library is deliberately NOT part of the default run. It is
+ * gigabytes of immutable uploads; archiving it nightly would produce hours of
+ * CPU and a disk full of near-identical tarballs. Pass --media to mirror it
+ * incrementally with rsync instead.
+ *
+ * Exits non-zero on any failure so a cron surfaces the problem instead of
+ * quietly producing corrupt files.
+ *
+ * Mirrors `takeone:backup` on the takeone platform so both systems are backed
+ * up the same way and restored the same way.
+ */
+class BackupCommand extends Command
+{
+    protected $signature = 'takeone:backup
+                            {--media : Also mirror the media library (incremental rsync, needs BACKUP_MEDIA_DEST)}
+                            {--media-only : Mirror media and skip the database}
+                            {--keep-local : Do not delete the local copy after an off-server upload}';
+
+    protected $description = 'Snapshot the database, verify it, optionally mirror media, copy off-server and prune old artifacts';
+
+    private array $artifacts = [];
+
+    public function handle(): int
+    {
+        $dir = (string) config('backup.path');
+
+        if (! is_dir($dir) && ! @mkdir($dir, 0775, true)) {
+            $this->error("Cannot create backup directory: {$dir}");
+
+            return self::FAILURE;
+        }
+
+        $stamp = now()->format('Ymd-His');
+        $failed = false;
+
+        if (! $this->option('media-only')) {
+            $failed = ! $this->backupDatabase($dir, $stamp) || $failed;
+        }
+
+        if ($this->option('media') || $this->option('media-only')) {
+            $failed = ! $this->mirrorMedia() || $failed;
+        } else {
+            $this->line('  <comment>–</comment> media     not included (pass --media to mirror it)');
+        }
+
+        $this->shipOffServer();
+        $this->prune($dir);
+
+        if ($failed) {
+            Log::error('Backup run failed', ['artifacts' => $this->artifacts]);
+            $this->error('Backup FAILED — see the errors above.');
+
+            return self::FAILURE;
+        }
+
+        Log::info('Backup completed', ['artifacts' => array_map('basename', $this->artifacts)]);
+        $this->newLine();
+        $this->info('Backup complete.');
+
+        return self::SUCCESS;
+    }
+
+    /* ---------------- Database ---------------- */
+
+    private function backupDatabase(string $dir, string $stamp): bool
+    {
+        $connection = config('database.default');
+        $driver = config("database.connections.{$connection}.driver");
+
+        return match ($driver) {
+            'sqlite' => $this->backupSqlite($dir, $stamp),
+            'mysql', 'mariadb' => $this->backupMysql($dir, $stamp, $connection),
+            default => tap(false, fn () => $this->error("Unsupported database driver for backup: {$driver}")),
+        };
+    }
+
+    /** Consistent SQLite snapshot: checkpoint the WAL, then VACUUM INTO. */
+    private function backupSqlite(string $dir, string $stamp): bool
+    {
+        $target = $dir."/db-{$stamp}.sqlite";
+
+        // VACUUM cannot run inside a transaction. Rather than let SQLite throw
+        // something cryptic, say so plainly — a backup that quietly produces
+        // nothing is the worst possible outcome.
+        if (DB::transactionLevel() > 0) {
+            $this->error('Cannot snapshot the database inside an open transaction.');
+
+            return false;
+        }
+
+        try {
+            // Harmless when the database is not in WAL mode.
+            DB::statement('PRAGMA wal_checkpoint(TRUNCATE)');
+            DB::statement('VACUUM INTO '.DB::getPdo()->quote($target));
+        } catch (\Throwable $e) {
+            $this->error('Database snapshot failed: '.$e->getMessage());
+
+            return false;
+        }
+
+        if (! $this->verifySqlite($target)) {
+            return false;
+        }
+
+        $this->artifacts[] = $target;
+        $this->line(sprintf('  <info>✓</info> database  %s (%s)', basename($target), $this->humanSize($target)));
+
+        return true;
+    }
+
+    /**
+     * Read the snapshot back. A file that exists but cannot be opened, or that
+     * holds no migrations and no videos, is not a backup worth trusting.
+     */
+    private function verifySqlite(string $path): bool
+    {
+        try {
+            $pdo = new PDO('sqlite:'.$path);
+            $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
+
+            if ($pdo->query('PRAGMA integrity_check')->fetchColumn() !== 'ok') {
+                $this->error("Snapshot failed integrity check: {$path}");
+
+                return false;
+            }
+
+            $migrations = (int) $pdo->query('SELECT count(*) FROM migrations')->fetchColumn();
+
+            if ($migrations < 1) {
+                $this->error("Snapshot contains no migrations — refusing to trust it: {$path}");
+
+                return false;
+            }
+
+            // Read a real application table too. `migrations` alone would still
+            // be present in a snapshot taken of an empty database.
+            $videos = (int) $pdo->query('SELECT count(*) FROM videos')->fetchColumn();
+            $this->line("  <info>✓</info> verified  integrity ok · {$migrations} migrations · {$videos} videos");
+        } catch (\Throwable $e) {
+            $this->error('Snapshot could not be verified: '.$e->getMessage());
+
+            return false;
+        }
+
+        return true;
+    }
+
+    private function backupMysql(string $dir, string $stamp, string $connection): bool
+    {
+        $target = $dir."/db-{$stamp}.sql.gz";
+        $c = config("database.connections.{$connection}");
+
+        $command = sprintf(
+            'mysqldump --single-transaction --quick --no-tablespaces -h%s -P%s -u%s %s %s | gzip > %s',
+            escapeshellarg((string) $c['host']),
+            escapeshellarg((string) $c['port']),
+            escapeshellarg((string) $c['username']),
+            $c['password'] ? '-p'.escapeshellarg((string) $c['password']) : '',
+            escapeshellarg((string) $c['database']),
+            escapeshellarg($target),
+        );
+
+        exec($command, $out, $status);
+
+        if ($status !== 0 || ! is_file($target) || filesize($target) === 0) {
+            $this->error('mysqldump failed (exit '.$status.').');
+
+            return false;
+        }
+
+        // Verify the dump is readable and non-trivial rather than trusting the
+        // exit code — a gzip of an error message also exits 0.
+        exec('gzip -t '.escapeshellarg($target).' 2>/dev/null', $o2, $verify);
+
+        if ($verify !== 0) {
+            $this->error('Dump failed its gzip integrity check — discarding.');
+            @unlink($target);
+
+            return false;
+        }
+
+        $this->artifacts[] = $target;
+        $this->line(sprintf('  <info>✓</info> database  %s (%s)', basename($target), $this->humanSize($target)));
+
+        return true;
+    }
+
+    /* ---------------- Media ---------------- */
+
+    /**
+     * Mirror the media library with rsync.
+     *
+     * Uploaded video cannot be regenerated from anything — losing it is the
+     * one unrecoverable outcome on this platform. rsync is used rather than an
+     * archive because the library is large and almost entirely immutable, so
+     * each run copies only what is new.
+     */
+    private function mirrorMedia(): bool
+    {
+        $destination = (string) config('backup.media_destination');
+
+        if ($destination === '') {
+            $this->newLine();
+            $this->warn('--media was requested but BACKUP_MEDIA_DEST is not set — media was NOT backed up.');
+            $this->line('  Uploaded video cannot be regenerated. Point BACKUP_MEDIA_DEST at a NAS mount or remote path.');
+
+            return false;
+        }
+
+        if (! is_dir($destination) && ! @mkdir($destination, 0775, true)) {
+            $this->error("Media destination is not reachable: {$destination}");
+
+            return false;
+        }
+
+        $paths = array_values(array_filter((array) config('backup.media_paths', []), 'is_dir'));
+
+        if (! $paths) {
+            $this->line('  <comment>–</comment> media     nothing to mirror');
+
+            return true;
+        }
+
+        // --delete is opt-in and off by default: a mirror that deletes is one
+        // wrong path away from erasing the copy it exists to protect.
+        $flags = '-a --partial --info=stats2';
+
+        if (config('backup.media_delete')) {
+            $flags .= ' --delete';
+        }
+
+        $ok = true;
+
+        foreach ($paths as $path) {
+            // Trailing slash on the source, basename on the destination, so
+            // each folder lands in its own directory rather than merging.
+            $command = sprintf(
+                'rsync %s %s %s 2>&1',
+                $flags,
+                escapeshellarg(rtrim($path, '/').'/'),
+                escapeshellarg(rtrim($destination, '/').'/'.basename($path).'/'),
+            );
+
+            exec($command, $out, $status);
+
+            if ($status !== 0) {
+                $this->error('Media mirror failed for '.basename($path).' (exit '.$status.').');
+                $ok = false;
+
+                continue;
+            }
+
+            $this->line(sprintf('  <info>✓</info> media     %s → %s', basename($path), $destination));
+        }
+
+        return $ok;
+    }
+
+    /* ---------------- Off-server ---------------- */
+
+    private function shipOffServer(): void
+    {
+        $disk = config('backup.disk');
+
+        if (! $disk) {
+            $this->newLine();
+            $this->warn('No BACKUP_DISK configured — these copies live on the SAME disk as the data.');
+            $this->line('  They survive a bad migration, but not a dead server. Set BACKUP_DISK to a remote filesystem.');
+
+            return;
+        }
+
+        foreach ($this->artifacts as $artifact) {
+            try {
+                Storage::disk($disk)->put('backups/'.basename($artifact), fopen($artifact, 'rb'));
+                $this->line("  <info>✓</info> off-server {$disk}:backups/".basename($artifact));
+
+                if (! $this->option('keep-local')) {
+                    @unlink($artifact);
+                }
+            } catch (\Throwable $e) {
+                // Never delete the local copy when the upload failed — it is
+                // the only copy left.
+                $this->error('Off-server upload failed for '.basename($artifact).': '.$e->getMessage());
+            }
+        }
+    }
+
+    /* ---------------- Rotation ---------------- */
+
+    /**
+     * Delete artifacts past the retention window, but always keep the newest
+     * few — a box that sat idle for a month must still have something to
+     * restore from.
+     */
+    private function prune(string $dir): void
+    {
+        $days = (int) config('backup.retain_days', 14);
+
+        if ($days <= 0) {
+            return;
+        }
+
+        $keep = max(0, (int) config('backup.keep_minimum', 3));
+        $cutoff = now()->subDays($days)->getTimestamp();
+        $removed = 0;
+
+        $files = glob($dir.'/db-*') ?: [];
+        usort($files, fn ($a, $b) => filemtime($b) <=> filemtime($a));   // newest first
+
+        foreach (array_slice($files, $keep) as $file) {
+            if (filemtime($file) < $cutoff && @unlink($file)) {
+                $removed++;
+            }
+        }
+
+        if ($removed) {
+            $this->line("  <info>✓</info> pruned    {$removed} artifact(s) older than {$days} days");
+        }
+    }
+
+    private function humanSize(string $path): string
+    {
+        $bytes = (int) @filesize($path);
+        $units = ['B', 'KB', 'MB', 'GB'];
+
+        for ($i = 0; $bytes >= 1024 && $i < count($units) - 1; $i++) {
+            $bytes /= 1024;
+        }
+
+        return round($bytes, 1).' '.$units[$i];
+    }
+}

app/Console/Commands/CommentsDedupeCommand.php

@@ -0,0 +1,122 @@
+<?php
+
+namespace App\Console\Commands;
+
+use App\Models\Comment;
+use Illuminate\Console\Command;
+use Illuminate\Support\Facades\DB;
+
+/**
+ * Clean up duplicate comments that pre-date the server-side 60-second dedupe
+ * guard. Duplicate = identical (user_id, video_id, parent_id, body) within a
+ * configurable gap. Keeps the earliest row, moves any likes onto it, deletes
+ * the rest. --dry-run shows what would happen without touching the DB.
+ */
+class CommentsDedupeCommand extends Command
+{
+    protected $signature = 'comments:dedupe
+        {--window=60 : Treat duplicates as same submission if within N seconds (default 60)}
+        {--dry-run : Print what would be removed; do not delete}';
+
+    protected $description = 'Collapse duplicate comments (same user, video, parent, body) into the earliest one';
+
+    public function handle(): int
+    {
+        $window = max(1, (int) $this->option('window'));
+        $dryRun = (bool) $this->option('dry-run');
+
+        // Fetch (user_id, video_id, parent_id, body) groups that appear >1 time.
+        // We ignore the window at the SQL layer and apply it per-group in PHP:
+        // that avoids a correlated subquery and is fast enough for a one-shot
+        // cleanup. For very large tables, chunk by user_id.
+        $groups = DB::table('comments')
+            ->selectRaw('user_id, video_id, parent_id, body, COUNT(*) as cnt')
+            ->groupBy('user_id', 'video_id', 'parent_id', 'body')
+            ->havingRaw('COUNT(*) > 1')
+            ->get();
+
+        if ($groups->isEmpty()) {
+            $this->info('No duplicate (user, video, parent, body) groups found.');
+            return self::SUCCESS;
+        }
+
+        $totalRemoved = 0;
+        $groupsTouched = 0;
+
+        foreach ($groups as $g) {
+            $rows = Comment::where('user_id', $g->user_id)
+                ->where('video_id', $g->video_id)
+                ->where(function ($q) use ($g) {
+                    $g->parent_id === null
+                        ? $q->whereNull('parent_id')
+                        : $q->where('parent_id', $g->parent_id);
+                })
+                ->where('body', $g->body)
+                ->orderBy('created_at')
+                ->orderBy('id')
+                ->get();
+
+            if ($rows->count() < 2) {
+                continue;
+            }
+
+            $keeper = $rows->first();
+            $cluster = collect([$keeper]);
+            $previous = $keeper;
+
+            foreach ($rows->slice(1) as $row) {
+                // Same cluster if row is within window of the previous row —
+                // which is the behavior the server guard enforces today.
+                if ($row->created_at->diffInSeconds($previous->created_at) <= $window) {
+                    $cluster->push($row);
+                    $previous = $row;
+                }
+            }
+
+            if ($cluster->count() < 2) {
+                continue;
+            }
+
+            $toDelete = $cluster->skip(1);
+            $groupsTouched++;
+            $totalRemoved += $toDelete->count();
+
+            $this->line(sprintf(
+                '  user=%d video=%d parent=%s keep=%d remove=%s body="%s"',
+                $g->user_id,
+                $g->video_id,
+                $g->parent_id ?? 'null',
+                $keeper->id,
+                $toDelete->pluck('id')->join(','),
+                mb_strimwidth(preg_replace('/\s+/', ' ', (string) $g->body), 0, 40, '…'),
+            ));
+
+            if ($dryRun) {
+                continue;
+            }
+
+            DB::transaction(function () use ($keeper, $toDelete) {
+                $ids = $toDelete->pluck('id')->all();
+
+                // Reparent any replies that were nested under a doomed row.
+                Comment::whereIn('parent_id', $ids)->update(['parent_id' => $keeper->id]);
+
+                // Move likes to the keeper, dropping dupes.
+                DB::table('comment_likes')
+                    ->whereIn('comment_id', $ids)
+                    ->update(['comment_id' => $keeper->id]);
+
+                Comment::whereIn('id', $ids)->delete();
+            });
+        }
+
+        $this->info(sprintf(
+            '%s %d duplicate rows across %d groups.',
+            $dryRun ? 'Would remove' : 'Removed',
+            $totalRemoved,
+            $groupsTouched,
+        ));
+
+        return self::SUCCESS;
+    }
+}

app/Console/Commands/GenerateLyrics.php

@@ -0,0 +1,61 @@
+<?php
+
+namespace App\Console\Commands;
+
+use App\Jobs\GenerateLyricsJob;
+use App\Models\Video;
+use App\Services\NasSyncService;
+use Illuminate\Console\Command;
+
+/**
+ * Backfill synced lyrics for existing songs. New uploads generate automatically;
+ * this covers the catalogue that predates the feature.
+ *
+ *   php artisan lyrics:generate 163          # one video (primary + every track)
+ *   php artisan lyrics:generate --all         # every music video missing lyrics
+ *   php artisan lyrics:generate --all --force # regenerate even if a file exists
+ */
+class GenerateLyrics extends Command
+{
+    protected $signature = 'lyrics:generate {video? : Video id} {--all : All music videos} {--force : Regenerate even when lyrics already exist}';
+    protected $description = 'Generate word-level synced lyrics for songs (dispatched to the video-processing queue)';
+
+    public function handle(NasSyncService $nas): int
+    {
+        $force = (bool) $this->option('force');
+
+        if ($videoId = $this->argument('video')) {
+            $video = Video::find($videoId);
+            if (! $video) {
+                $this->error("Video #{$videoId} not found.");
+                return self::FAILURE;
+            }
+            $videos = collect([$video]);
+        } elseif ($this->option('all')) {
+            $videos = Video::where('type', 'music')->get();
+        } else {
+            $this->error('Pass a video id or --all.');
+            return self::FAILURE;
+        }
+
+        $dispatched = 0;
+        foreach ($videos as $video) {
+            $video->loadMissing('audioTracks');
+
+            if ($force || ! is_array($nas->getLyrics($video, null))) {
+                GenerateLyricsJob::dispatch($video->id, null)->onConnection('database');
+                $dispatched++;
+            }
+            foreach ($video->audioTracks as $track) {
+                if ($force || ! is_array($nas->getLyrics($video, $track))) {
+                    GenerateLyricsJob::dispatch($video->id, $track->id)->onConnection('database');
+                    $dispatched++;
+                }
+            }
+            $this->line("Queued lyrics for #{$video->id} — {$video->title}");
+        }
+
+        $this->info("Dispatched {$dispatched} lyrics job(s) to the video-processing queue.");
+        return self::SUCCESS;
+    }
+}

app/Console/Commands/MigrateStorageLayout.php

@@ -0,0 +1,241 @@
+<?php
+
+namespace App\Console\Commands;
+
+use App\Models\Video;
+use App\Models\VideoAudioTrack;
+use App\Models\VideoSlide;
+use App\Services\NasSyncService;
+use Illuminate\Console\Command;
+
+/**
+ * One-time migration that moves existing songs/videos from the legacy flat
+ * layout into the canonical type-segregated, per-track-folder layout described
+ * in CLAUDE.md.
+ *
+ * Dry-run by default — pass --force to actually move files and update the DB.
+ * Run this only after backing up the DB and confirming the dry-run plan looks
+ * correct. The command is idempotent: rows already in the new layout are
+ * skipped.
+ */
+class MigrateStorageLayout extends Command
+{
+    protected $signature   = 'storage:migrate-layout {--force : Apply changes (default is dry-run)} {--video= : Migrate only this video id}';
+    protected $description = 'Move existing songs/videos to the type-segregated + per-track-folder layout';
+
+    public function handle(NasSyncService $nas): int
+    {
+        $apply = (bool) $this->option('force');
+        $only  = $this->option('video') ? (int) $this->option('video') : null;
+
+        $this->info($apply ? '→ APPLY mode (files and DB will be modified)' : '→ DRY-RUN (no changes will be made)');
+
+        $q = Video::query()->with(['user', 'audioTracks', 'slides']);
+        if ($only) $q->where('id', $only);
+        $videos = $q->orderBy('id')->get();
+
+        $this->info("Found {$videos->count()} video(s) to inspect.");
+
+        $stats = ['skipped' => 0, 'planned' => 0, 'applied' => 0, 'errors' => 0];
+
+        foreach ($videos as $video) {
+            try {
+                $plan = $this->planVideo($video, $nas);
+                if ($plan === null) { $stats['skipped']++; continue; }
+
+                $this->line("");
+                $this->info("Video #{$video->id} ({$video->type}): {$video->title}");
+                foreach ($plan as $move) {
+                    $this->line("  {$move['from']}  →  {$move['to']}");
+                }
+                $stats['planned']++;
+
+                if ($apply) {
+                    $this->applyPlan($video, $plan, $nas);
+                    $stats['applied']++;
+                }
+            } catch (\Throwable $e) {
+                $stats['errors']++;
+                $this->error("Video #{$video->id}: " . $e->getMessage());
+            }
+        }
+
+        $this->line("");
+        $this->info("Done. " . json_encode($stats));
+        return self::SUCCESS;
+    }
+
+    /**
+     * Build the move list for one video. Returns null if it's already in the
+     * target layout. Each plan entry is ['from' => oldPath, 'to' => newPath,
+     * 'kind' => 'video'|'audio'|'slide'|'thumb', 'model' => modelOrNull,
+     * 'slide_field' => 'filename' | 'path' | 'thumbnail'].
+     */
+    private function planVideo(Video $video, NasSyncService $nas): ?array
+    {
+        $path = (string) $video->path;
+        if (! str_starts_with($path, 'users/')) {
+            return null; // unorganised — outside this migration's scope
+        }
+        $segs = explode('/', $path);
+        if (count($segs) < 4) return null;
+
+        $expectedTypeFolder = $nas->typeFolder($video);
+        $currentTypeFolder  = $segs[2] ?? null;
+        $isMusic            = ($video->type === 'music');
+
+        // Already in target layout? Music: tracks/{lang-id}/audio.{ext}. Others: video.{ext}.
+        $inTracks      = ($segs[4] ?? null) === 'tracks';
+        $canonicalPrimary = $isMusic ? 'audio' : 'video';
+        $endsCanonical = preg_match("#/{$canonicalPrimary}\\.[a-z0-9]+$#i", $path) === 1;
+        if ($currentTypeFolder === $expectedTypeFolder
+            && (! $isMusic || $inTracks)
+            && $endsCanonical) {
+            return null; // already migrated
+        }
+
+        // Compute new song/video root: users/{slug}/{type-folder}/{slug}
+        $userSlug  = $segs[1];
+        $videoSlug = $isMusic ? ($segs[3] ?? null) : ($segs[3] ?? null);
+        if (! $videoSlug) return null;
+        $newRoot = "users/{$userSlug}/{$expectedTypeFolder}/{$videoSlug}";
+
+        $ext = pathinfo($video->filename ?: $path, PATHINFO_EXTENSION) ?: 'mp4';
+
+        $plan = [];
+
+        // Primary file
+        if ($isMusic) {
+            $primaryFolder = $nas->trackFolderName($video, null);
+            $plan[] = [
+                'from'        => $path,
+                'to'          => "{$newRoot}/tracks/{$primaryFolder}/audio.{$ext}",
+                'kind'        => 'video',
+                'model'       => $video,
+                'set'         => ['path', 'filename'],
+                'new_filename'=> "audio.{$ext}",
+            ];
+        } else {
+            $plan[] = [
+                'from'        => $path,
+                'to'          => "{$newRoot}/video.{$ext}",
+                'kind'        => 'video',
+                'model'       => $video,
+                'set'         => ['path', 'filename'],
+                'new_filename'=> "video.{$ext}",
+            ];
+        }
+
+        // Thumbnail
+        if ($video->thumbnail && str_starts_with($video->thumbnail, 'users/')) {
+            $thumbExt = pathinfo($video->thumbnail, PATHINFO_EXTENSION) ?: 'webp';
+            $thumbDir = $isMusic
+                ? "{$newRoot}/tracks/" . $nas->trackFolderName($video, null)
+                : $newRoot;
+            $plan[] = [
+                'from'  => $video->thumbnail,
+                'to'    => "{$thumbDir}/thumb.{$thumbExt}",
+                'kind'  => 'thumb',
+                'model' => $video,
+                'set'   => ['thumbnail'],
+            ];
+        }
+
+        // Extra audio tracks (music only)
+        if ($isMusic) {
+            foreach ($video->audioTracks as $track) {
+                if (! str_starts_with((string) $track->path, 'users/')) continue;
+                $tExt = pathinfo($track->filename ?: $track->path, PATHINFO_EXTENSION) ?: 'mp3';
+                $trackFolder = $nas->trackFolderName($video, $track);
+                $plan[] = [
+                    'from'        => $track->path,
+                    'to'          => "{$newRoot}/tracks/{$trackFolder}/audio.{$tExt}",
+                    'kind'        => 'audio',
+                    'model'       => $track,
+                    'set'         => ['path', 'filename'],
+                    'new_filename'=> "audio.{$tExt}",
+                ];
+            }
+
+            // Slides (music only) — owners may be NULL (primary), or any track id
+            foreach ($video->slides as $slide) {
+                if (! str_starts_with((string) $slide->filename, 'users/')) continue;
+                $sExt = pathinfo($slide->filename, PATHINFO_EXTENSION) ?: 'jpg';
+                $ownerTrack = $slide->audio_track_id
+                    ? $video->audioTracks->firstWhere('id', $slide->audio_track_id)
+                    : null;
+                $folder = $nas->trackFolderName($video, $ownerTrack);
+                $plan[] = [
+                    'from'  => $slide->filename,
+                    'to'    => "{$newRoot}/tracks/{$folder}/slides/{$slide->position}.{$sExt}",
+                    'kind'  => 'slide',
+                    'model' => $slide,
+                    'set'   => ['filename'],
+                ];
+            }
+        }
+
+        return $plan;
+    }
+
+    /**
+     * Execute one video's plan. On NAS: copy then delete (smbclient has no rename).
+     * On local: rename(). Either way, DB columns are updated after the move succeeds.
+     */
+    private function applyPlan(Video $video, array $plan, NasSyncService $nas): void
+    {
+        $nasOn = $nas->isEnabled();
+
+        foreach ($plan as $move) {
+            // Ensure target dir exists
+            $targetDir = dirname($move['to']);
+            if ($nasOn) {
+                $nas->mkdirp($targetDir);
+            }
+            @mkdir(storage_path('app/' . $targetDir), 0755, true);
+
+            // Move on local
+            $localFrom = storage_path('app/' . $move['from']);
+            $localTo   = storage_path('app/' . $move['to']);
+            if (is_file($localFrom)) {
+                @rename($localFrom, $localTo);
+            }
+
+            // Move on NAS via copy+delete
+            if ($nasOn) {
+                $tmp = tempnam(sys_get_temp_dir(), 'mig_');
+                if ($nas->getContent($move['from']) !== null) {
+                    // small file like .json — already cached as content; round-trip
+                }
+                // For binary files, pull → push → delete-source
+                $localCache = storage_path('app/' . $move['from']);
+                if (! is_file($localCache)) {
+                    $nas->ensureLocalAsset($localCache, $move['from']);
+                }
+                if (is_file($localCache)) {
+                    if ($nas->putFile($localCache, $move['to'])) {
+                        $nas->deleteFile($move['from']);
+                    }
+                }
+                @unlink($tmp);
+            }
+
+            // Update DB
+            $model = $move['model'];
+            $updates = [];
+            foreach ($move['set'] as $col) {
+                if ($col === 'path' || $col === 'thumbnail' || $col === 'filename') {
+                    $updates[$col] = ($col === 'filename' && isset($move['new_filename']))
+                        ? $move['new_filename']
+                        : $move['to'];
+                }
+            }
+            // VideoSlide stores the full path under `filename`
+            if ($model instanceof VideoSlide) {
+                $model->update(['filename' => $move['to']]);
+            } else {
+                $model->update($updates);
+            }
+        }
+    }
+}

app/Console/Commands/NasAutoSync.php

@@ -7,6 +7,7 @@ use App\Models\User;
 use App\Models\Video;
 use App\Services\NasSyncService;
 use Illuminate\Console\Command;
+use Illuminate\Support\Facades\DB;
 
 class NasAutoSync extends Command
 {
@@ -19,6 +20,39 @@ class NasAutoSync extends Command
             return 0; // NAS down or disabled — nothing to do
         }
 
+        // Drain queued NAS file/folder moves recorded while NAS was down
+        // (e.g. music-video merges). Best-effort per row; failures stay
+        // in the table with attempts/last_error for later retries.
+        $drained = 0; $failed = 0;
+        DB::table('pending_nas_moves')->orderBy('id')->get()->each(
+            function ($row) use ($nas, &$drained, &$failed) {
+                try {
+                    $nas->renameNasPath($row->from_path, $row->to_path);
+                    // Best-effort prune of the now-empty source parent
+                    // (e.g. the source video folder after all its track
+                    // subfolders were adopted by the target).
+                    $parent = dirname($row->from_path);
+                    if ($parent && $parent !== '.') {
+                        $nas->deleteFile("{$parent}/meta.json");
+                        $nas->deleteFolder($parent);
+                    }
+                    DB::table('pending_nas_moves')->where('id', $row->id)->delete();
+                    $drained++;
+                } catch (\Throwable $e) {
+                    DB::table('pending_nas_moves')->where('id', $row->id)->update([
+                        'attempts'        => (int) $row->attempts + 1,
+                        'last_attempt_at' => now(),
+                        'last_error'      => mb_substr($e->getMessage(), 0, 500),
+                        'updated_at'      => now(),
+                    ]);
+                    $failed++;
+                }
+            }
+        );
+        if ($drained || $failed) {
+            $this->info("Drained {$drained} pending NAS move(s)" . ($failed ? " (${failed} failed)" : ''));
+        }
+
         // Videos whose file OR thumbnail/slides are still on local disk
         $synced = 0;
         Video::with(['user', 'slides'])

app/Console/Commands/RenderMatchOgImage.php

@@ -0,0 +1,47 @@
+<?php
+
+namespace App\Console\Commands;
+
+use App\Http\Controllers\VideoController;
+use App\Models\Video;
+use Illuminate\Console\Command;
+
+/**
+ * Renders the 1200×630 VS composition PNG for a match video's social-share
+ * preview. Runs the same helper used by VideoController@ogImage but from a
+ * CLI process context, because Chromium reliably fails to launch under
+ * PHP-FPM ("Failed to launch the browser process: Code: null") on this
+ * host. Invoke detached via `nohup` from either the ogImage endpoint (on
+ * cache miss) or SportsMatchController on save.
+ */
+class RenderMatchOgImage extends Command
+{
+    protected $signature = 'og:render-match {video}';
+    protected $description = 'Render the OG social-share PNG for a match video';
+
+    public function handle(): int
+    {
+        $video = Video::find($this->argument('video'));
+        if (! $video) {
+            $this->error("Video {$this->argument('video')} not found.");
+            return 1;
+        }
+        if ($video->type !== 'match' || ! $video->sportsMatch) {
+            $this->error("Video {$video->id} is not a match with a sports record.");
+            return 1;
+        }
+
+        $controller = new VideoController();
+        $r = new \ReflectionMethod($controller, 'renderMatchOgImage');
+        $r->setAccessible(true);
+        $png = $r->invoke($controller, $video);
+
+        if ($png === null) {
+            $this->error("Render failed. See laravel.log.");
+            return 1;
+        }
+
+        $this->info("Rendered " . strlen($png) . " bytes for video {$video->id}.");
+        return 0;
+    }
+}

app/Console/Commands/RepairMergedVideo.php

@@ -0,0 +1,141 @@
+<?php
+
+namespace App\Console\Commands;
+
+use App\Models\Video;
+use App\Models\VideoAudioTrack;
+use App\Services\NasSyncService;
+use Illuminate\Console\Command;
+use Illuminate\Support\Facades\DB;
+
+class RepairMergedVideo extends Command
+{
+    protected $signature = 'videos:repair-merged {target : Target video encoded id (from the URL) or numeric id} {--source-id= : Force a specific source id from video_redirects} {--source-folder= : Override the source folder path (use when the redirect row has none — pre-repair-column merges)} {--dry-run : Show what would happen, do not modify anything}';
+
+    protected $description = 'After a music-video merge, adopt any track subfolders still stuck in the source folder on NAS as new audio tracks on the target video. Safe to re-run.';
+
+    public function handle(NasSyncService $nas): int
+    {
+        if (!$nas->isEnabled()) {
+            $this->error('NAS is not reachable — cannot repair. Try again when NAS is back online.');
+            return self::FAILURE;
+        }
+
+        $targetArg = $this->argument('target');
+        $target    = is_numeric($targetArg)
+            ? Video::find((int) $targetArg)
+            : Video::find(Video::decodeId((string) $targetArg));
+        if (!$target) {
+            $this->error("Target video not found: {$targetArg}");
+            return self::FAILURE;
+        }
+        $this->info("Target: [{$target->id}] {$target->title}");
+
+        $redirects = DB::table('video_redirects')->where('target_id', $target->id);
+        if ($sid = $this->option('source-id')) {
+            $redirects->where('source_id', (int) $sid);
+        }
+        $redirects = $redirects->get();
+
+        if ($redirects->isEmpty()) {
+            $this->warn('No video_redirects rows found for this target.');
+            return self::SUCCESS;
+        }
+
+        $dryRun  = (bool) $this->option('dry-run');
+        $adopted = 0;
+
+        $folderOverride = $this->option('source-folder');
+
+        foreach ($redirects as $r) {
+            $this->line('');
+            $sourceFolder = $folderOverride ?: $r->source_folder;
+            $this->info("Source id {$r->source_id} → folder: " . ($sourceFolder ?: '(unknown)'));
+
+            if (!$sourceFolder) {
+                $this->warn('  Skipping — no source_folder recorded. Pass --source-folder="users/…/music/…" to specify.');
+                continue;
+            }
+            // Backfill the redirect row so future runs don't need the override.
+            if (!$r->source_folder && !$dryRun && $folderOverride) {
+                DB::table('video_redirects')->where('source_id', $r->source_id)
+                    ->update(['source_folder' => $folderOverride]);
+                $r->source_folder = $folderOverride;
+            } else {
+                $r->source_folder = $sourceFolder;
+            }
+
+            $tracksDir = $r->source_folder . '/tracks';
+            $subdirs   = $nas->listNasDirs($tracksDir);
+            if (empty($subdirs)) {
+                $this->line('  No leftover track subfolders. Cleaning up empty source folder.');
+                if (!$dryRun) {
+                    $nas->deleteFile($r->source_folder . '/meta.json');
+                    $nas->deleteFolder($tracksDir);
+                    $nas->deleteFolder($r->source_folder);
+                }
+                continue;
+            }
+
+            $targetDir = $nas->resolveVideoDir($target);
+            $nas->mkdirp("{$targetDir}/tracks");
+
+            foreach ($subdirs as $sub) {
+                // Parse "{lang}-{origId}" to recover the language for the new track.
+                $lang = 'xx';
+                if (preg_match('/^([a-z]{2,10})-\d+$/i', $sub, $m)) {
+                    $lang = strtolower($m[1]);
+                }
+
+                $this->line("  Adopting track folder: {$sub}  (lang={$lang})");
+
+                if ($dryRun) { $adopted++; continue; }
+
+                $newTrack = VideoAudioTrack::create([
+                    'video_id' => $target->id,
+                    'language' => $lang,
+                    'label'    => "Recovered from merge #{$r->source_id}",
+                    'title'    => null,
+                    'filename' => 'audio.mp3',
+                    'path'     => '',
+                ]);
+                $newBasename = $nas->trackFolderName($target, $newTrack);
+                $oldRel = "{$tracksDir}/{$sub}";
+                $newRel = "{$targetDir}/tracks/{$newBasename}";
+
+                $nas->renameNasPath($oldRel, $newRel);
+
+                // Local mirror (if the folder happens to exist locally too).
+                $oldLocal = storage_path('app/' . $oldRel);
+                $newLocal = storage_path('app/' . $newRel);
+                if (is_dir($oldLocal)) {
+                    @mkdir(dirname($newLocal), 0755, true);
+                    @rename($oldLocal, $newLocal);
+                }
+
+                // Detect audio filename from local mirror if present, else default.
+                $audioName = 'audio.mp3';
+                foreach (['audio.mp3', 'audio.m4a', 'audio.aac', 'audio.ogg', 'audio.wav', 'audio.opus'] as $cand) {
+                    if (file_exists("{$newLocal}/{$cand}")) { $audioName = $cand; break; }
+                }
+                $newTrack->update([
+                    'filename' => $audioName,
+                    'path'     => "{$newRel}/{$audioName}",
+                ]);
+
+                $adopted++;
+            }
+
+            // Clean up now-empty source folder.
+            if (!$dryRun) {
+                $nas->deleteFile($r->source_folder . '/meta.json');
+                $nas->deleteFolder($tracksDir);
+                $nas->deleteFolder($r->source_folder);
+            }
+        }
+
+        $this->line('');
+        $this->info(($dryRun ? '[dry-run] Would adopt ' : 'Adopted ') . $adopted . ' track folder(s).');
+        return self::SUCCESS;
+    }
+}

app/Console/Commands/ResendVerificationCommand.php

@@ -0,0 +1,74 @@
+<?php
+
+namespace App\Console\Commands;
+
+use App\Models\User;
+use Illuminate\Console\Command;
+
+/**
+ * Resend the email-verification mail to one user or to every unverified user.
+ *
+ * Useful after an SMTP outage: the account was created and the user was told
+ * "we sent you a link", but the mail never left because Gmail 535'd us. Once
+ * the mail config is fixed, this flushes the backlog.
+ */
+class ResendVerificationCommand extends Command
+{
+    protected $signature = 'app:resend-verification
+        {--user= : A specific user id OR email to resend to}
+        {--all-unverified : Resend to every user with a null email_verified_at}
+        {--dry-run : Print who would be mailed; do not actually send}';
+
+    protected $description = 'Resend the email-verification link to one user or all unverified users';
+
+    public function handle(): int
+    {
+        $one       = (string) $this->option('user');
+        $all       = (bool) $this->option('all-unverified');
+        $dryRun    = (bool) $this->option('dry-run');
+
+        if ($one === '' && ! $all) {
+            $this->error('Pass either --user=<id-or-email> or --all-unverified.');
+            return self::FAILURE;
+        }
+
+        if ($one !== '') {
+            $query = ctype_digit($one)
+                ? User::where('id', (int) $one)
+                : User::where('email', $one);
+            $users = $query->get();
+        } else {
+            $users = User::whereNull('email_verified_at')->get();
+        }
+
+        if ($users->isEmpty()) {
+            $this->warn('No matching users.');
+            return self::SUCCESS;
+        }
+
+        $sent = 0;
+        $skipped = 0;
+        foreach ($users as $user) {
+            if ($user->hasVerifiedEmail()) {
+                $skipped++;
+                $this->line("  skip   #{$user->id} <{$user->email}> — already verified");
+                continue;
+            }
+            if ($dryRun) {
+                $this->line("  would  #{$user->id} <{$user->email}>");
+                continue;
+            }
+            // sendEmailVerificationNotification is already SafeNotifier-wrapped
+            // and will log instead of throwing on SMTP errors.
+            $user->sendEmailVerificationNotification();
+            $sent++;
+            $this->line("  sent   #{$user->id} <{$user->email}>");
+        }
+
+        $this->info($dryRun
+            ? "Dry run complete — {$users->count()} candidates, {$skipped} already verified."
+            : "Done — {$sent} sent, {$skipped} skipped.");
+
+        return self::SUCCESS;
+    }
+}

app/Console/Kernel.php

@@ -48,6 +48,14 @@ class Kernel extends ConsoleKernel
                  ->weeklyOn(1, '09:00')
                  ->withoutOverlapping()
                  ->runInBackground();
+
+        // Nightly database backup at 03:30 Asia/Bahrain. Writes to
+        // data/backups/db-YYYYMMDD-HHMMSS.sqlite, verifies the snapshot,
+        // and (when BACKUP_DISK is set) ships a copy off-server.
+        $schedule->command('takeone:backup')
+                 ->dailyAt('03:30')
+                 ->withoutOverlapping()
+                 ->runInBackground();
     }
 
     /**

app/Data/Countries.php

@@ -8,6 +8,18 @@ class Countries
      * All countries keyed by ISO2 code.
      * Fields: name, iso2, iso3, flag, dial_code, timezone, currency
      */
+    /**
+     * Resolve any ISO2 code (case-insensitive) to its full country name.
+     * Falls back to the uppercased code, then to null for empty input.
+     * Use this instead of printing raw two-letter codes to end users.
+     */
+    public static function name(?string $iso2): ?string
+    {
+        $code = strtoupper(trim((string) $iso2));
+        if ($code === '') return null;
+        return self::all()[$code]['name'] ?? $code;
+    }
+
     public static function all(): array
     {
         // Return lowercase ISO2 code — used as the fi fi-{code} CSS class (flag-icons library)

app/Data/CountryLanguages.php

@@ -0,0 +1,50 @@
+<?php
+
+namespace App\Data;
+
+class CountryLanguages
+{
+    private const MAP = [
+        'AE' => 'ar', 'AF' => 'ps', 'AL' => 'sq', 'AM' => 'hy', 'AO' => 'pt',
+        'AR' => 'es', 'AT' => 'de', 'AU' => 'en', 'AZ' => 'az',
+        'BA' => 'bs', 'BD' => 'bn', 'BE' => 'nl', 'BG' => 'bg', 'BH' => 'ar',
+        'BO' => 'es', 'BR' => 'pt', 'BY' => 'be',
+        'CA' => 'en', 'CH' => 'de', 'CL' => 'es', 'CN' => 'zh', 'CO' => 'es',
+        'CR' => 'es', 'CU' => 'es', 'CZ' => 'cs',
+        'DE' => 'de', 'DK' => 'da', 'DO' => 'es', 'DZ' => 'ar',
+        'EC' => 'es', 'EE' => 'et', 'EG' => 'ar', 'ES' => 'es', 'ET' => 'am',
+        'FI' => 'fi', 'FR' => 'fr',
+        'GB' => 'en', 'GE' => 'ka', 'GR' => 'el', 'GT' => 'es',
+        'HK' => 'zh', 'HN' => 'es', 'HR' => 'hr', 'HU' => 'hu',
+        'ID' => 'id', 'IE' => 'en', 'IL' => 'he', 'IN' => 'hi', 'IQ' => 'ar',
+        'IR' => 'fa', 'IS' => 'is', 'IT' => 'it',
+        'JO' => 'ar', 'JP' => 'ja',
+        'KE' => 'sw', 'KG' => 'ky', 'KH' => 'km', 'KR' => 'ko', 'KW' => 'ar',
+        'KZ' => 'kk',
+        'LA' => 'lo', 'LB' => 'ar', 'LK' => 'si', 'LT' => 'lt', 'LU' => 'fr',
+        'LV' => 'lv', 'LY' => 'ar',
+        'MA' => 'ar', 'MD' => 'ro', 'ME' => 'sr', 'MK' => 'mk', 'MM' => 'my',
+        'MN' => 'mn', 'MT' => 'mt', 'MX' => 'es', 'MY' => 'ms',
+        'NG' => 'en', 'NI' => 'es', 'NL' => 'nl', 'NO' => 'no', 'NP' => 'ne',
+        'NZ' => 'en',
+        'OM' => 'ar',
+        'PA' => 'es', 'PE' => 'es', 'PH' => 'tl', 'PK' => 'ur', 'PL' => 'pl',
+        'PR' => 'es', 'PS' => 'ar', 'PT' => 'pt', 'PY' => 'es',
+        'QA' => 'ar',
+        'RO' => 'ro', 'RS' => 'sr', 'RU' => 'ru',
+        'SA' => 'ar', 'SD' => 'ar', 'SE' => 'sv', 'SG' => 'en', 'SI' => 'sl',
+        'SK' => 'sk', 'SO' => 'so', 'SV' => 'es', 'SY' => 'ar',
+        'TH' => 'th', 'TJ' => 'tg', 'TN' => 'ar', 'TR' => 'tr', 'TW' => 'zh',
+        'TZ' => 'sw',
+        'UA' => 'uk', 'UG' => 'en', 'US' => 'en', 'UY' => 'es', 'UZ' => 'uz',
+        'VE' => 'es', 'VN' => 'vi',
+        'YE' => 'ar',
+        'ZA' => 'en', 'ZW' => 'en',
+    ];
+
+    public static function primary(?string $iso2): ?string
+    {
+        if (! $iso2) return null;
+        return self::MAP[strtoupper($iso2)] ?? null;
+    }
+}

app/Http/Controllers/Auth/AuthenticatedSessionController.php

@@ -4,8 +4,12 @@ namespace App\Http\Controllers\Auth;
 
 use App\Http\Controllers\Controller;
 use App\Models\AuditLog;
+use App\Models\User;
+use App\Notifications\BruteForceLoginAlert;
+use App\Support\SafeNotifier;
 use Illuminate\Http\Request;
 use Illuminate\Support\Facades\Auth;
+use Illuminate\Support\Facades\Cache;
 
 class AuthenticatedSessionController extends Controller
 {
@@ -50,11 +54,57 @@ class AuthenticatedSessionController extends Controller
             'details'   => ['email' => $credentials['email']],
         ]);
 
+        $this->detectBruteForce($request, $credentials['email']);
+
         return back()->withErrors([
             'email' => 'The provided credentials do not match our records.',
         ]);
     }
 
+    /**
+     * Fire one alert to super admins when the same email has racked up
+     * BRUTE_FORCE_THRESHOLD failures in BRUTE_FORCE_WINDOW_MINUTES. A Cache
+     * key with the same TTL prevents the alert from re-firing on every
+     * subsequent failed attempt within the same burst.
+     */
+    private const BRUTE_FORCE_THRESHOLD = 5;
+    private const BRUTE_FORCE_WINDOW_MINUTES = 10;
+
+    private function detectBruteForce(Request $request, string $email): void
+    {
+        $window = self::BRUTE_FORCE_WINDOW_MINUTES;
+        $threshold = self::BRUTE_FORCE_THRESHOLD;
+
+        // SQLite stores JSON-cast `details` as text; a LIKE-based match is
+        // database-portable and avoids per-driver JSON operator syntax.
+        $pattern = '%"email":"' . addslashes($email) . '"%';
+
+        $recent = AuditLog::where('action', 'user.login.failed')
+            ->where('created_at', '>=', now()->subMinutes($window))
+            ->where('details', 'like', $pattern)
+            ->count();
+
+        if ($recent < $threshold) {
+            return;
+        }
+
+        $cacheKey = 'brute_force_alert:' . sha1($email);
+        if (Cache::has($cacheKey)) {
+            return;
+        }
+        Cache::put($cacheKey, 1, now()->addMinutes($window));
+
+        $ip = $request->header('CF-Connecting-IP')
+            ?? $request->header('X-Forwarded-For')
+            ?? $request->ip()
+            ?? 'unknown';
+
+        $notification = new BruteForceLoginAlert($email, (string) $ip, $recent, $window);
+        User::where('role', 'super_admin')->each(function (User $admin) use ($notification) {
+            SafeNotifier::send($admin, $notification);
+        });
+    }
+
     public function destroy(Request $request)
     {
         $user = Auth::user();

app/Http/Controllers/Auth/RegisteredUserController.php

@@ -6,6 +6,8 @@ use App\Http\Controllers\Controller;
 use App\Models\User;
 use App\Notifications\NewUserRegistered;
 use App\Rules\NotDisposableEmail;
+use App\Rules\ReservedIdentifier;
+use App\Support\SafeNotifier;
 use Illuminate\Auth\Events\Registered;
 use Illuminate\Http\Request;
 use Illuminate\Support\Facades\Hash;
@@ -27,10 +29,14 @@ class RegisteredUserController extends Controller
         }
 
         $request->validate([
-            'name'        => ['required', 'string', 'max:255'],
-            'email'       => ['required', 'string', 'email', 'max:255', 'unique:users', new NotDisposableEmail],
+            'name'        => ['required', 'string', 'max:255', new ReservedIdentifier('name')],
+            'email'       => ['required', 'string', 'email', 'max:255', 'unique:users', new NotDisposableEmail, new ReservedIdentifier('email')],
             'password'    => ['required', 'confirmed', Password::defaults()],
-            'birthday'    => ['required', 'date', 'before:today'],
+            // Age gate: must be at least 13 on sign-up day. The front-end
+            // date picker already caps the year dropdown, but the server
+            // must enforce it so a client bypass doesn't let a 10-year-old
+            // through.
+            'birthday'    => ['required', 'date', 'before:' . now()->subYears(13)->toDateString()],
             'gender'      => ['required', 'in:male,female'],
             'nationality' => ['required', 'string', 'size:2'],
         ]);
@@ -48,7 +54,7 @@ class RegisteredUserController extends Controller
 
         // Notify all super admins of the new registration
         User::where('role', 'super_admin')->each(function (User $admin) use ($user) {
-            $admin->notify(new NewUserRegistered($user));
+            SafeNotifier::send($admin, new NewUserRegistered($user));
         });
 
         auth()->login($user);

app/Http/Controllers/CommentController.php

@@ -8,6 +8,8 @@ use App\Models\Video;
 use App\Notifications\NewCommentLikeNotification;
 use App\Notifications\NewCommentNotification;
 use App\Notifications\NewReplyNotification;
+use App\Services\LlmLyricsService;
+use App\Support\SafeNotifier;
 use Illuminate\Http\Request;
 use Illuminate\Support\Facades\Auth;
 
@@ -15,7 +17,7 @@ class CommentController extends Controller
 {
     public function __construct()
     {
-        $this->middleware('auth')->except(['index']);
+        $this->middleware('auth')->except(['index', 'translate']);
     }
 
     public function index(Video $video)
@@ -34,12 +36,66 @@ class CommentController extends Controller
 
         $commenter = Auth::user();
 
+        // Idempotency guard: a client that retries (duplicate listeners after
+        // an SPA swap, fast double-click, flaky connection) can POST the same
+        // comment twice. We dedupe on two signals:
+        //
+        //   1. X-Idempotency-Key — the fetch() client sends a per-attempt
+        //      UUID; the browser's own retry logic reuses the same value.
+        //      This catches the deliberate-retry case before body comparison.
+        //
+        //   2. Identical (user, video, parent, body) within 60s — covers
+        //      the duplicate-listener case where two independent fetch()es
+        //      fire with different idempotency keys for the same user intent.
+        //
+        // Either match returns the first-written comment unchanged.
+        $idemKey = (string) $request->header('X-Idempotency-Key', '');
+        $cacheKey = $idemKey !== ''
+            ? 'comment-idem:' . $commenter->id . ':' . $video->id . ':' . substr(hash('sha256', $idemKey), 0, 40)
+            : null;
+
+        if ($cacheKey) {
+            $existingId = \Illuminate\Support\Facades\Cache::get($cacheKey);
+            if ($existingId && $existing = Comment::find($existingId)) {
+                return response()->json([
+                    'success' => true,
+                    'comment' => $existing->load('user:id,name,avatar'),
+                ]);
+            }
+        }
+
+        $existing = $video->comments()
+            ->where('user_id', $commenter->id)
+            ->where('body', $request->body)
+            ->where(function ($q) use ($request) {
+                $request->parent_id
+                    ? $q->where('parent_id', $request->parent_id)
+                    : $q->whereNull('parent_id');
+            })
+            ->where('created_at', '>=', now()->subSeconds(60))
+            ->latest('id')
+            ->first();
+
+        if ($existing) {
+            if ($cacheKey) {
+                \Illuminate\Support\Facades\Cache::put($cacheKey, $existing->id, now()->addMinutes(5));
+            }
+            return response()->json([
+                'success' => true,
+                'comment' => $existing->load('user:id,name,avatar'),
+            ]);
+        }
+
         $comment = $video->comments()->create([
             'user_id'   => $commenter->id,
             'body'      => $request->body,
             'parent_id' => $request->parent_id,
         ]);
 
+        if ($cacheKey) {
+            \Illuminate\Support\Facades\Cache::put($cacheKey, $comment->id, now()->addMinutes(5));
+        }
+
         $comment->load('user:id,name,avatar');
 
         // Fire notifications (never notify yourself)
@@ -47,12 +103,12 @@ class CommentController extends Controller
             // Reply — notify the parent comment's author
             $parent = Comment::find($request->parent_id);
             if ($parent && $parent->user_id !== $commenter->id) {
-                $parent->user->notify(new NewReplyNotification($video, $comment, $commenter));
+                SafeNotifier::send($parent->user, new NewReplyNotification($video, $comment, $commenter));
             }
         } else {
             // Top-level comment — notify the video owner
             if ($video->user_id !== $commenter->id) {
-                $video->user->notify(new NewCommentNotification($video, $comment, $commenter));
+                SafeNotifier::send($video->user, new NewCommentNotification($video, $comment, $commenter));
             }
         }
 
@@ -89,6 +145,37 @@ class CommentController extends Controller
         return response()->json(['success' => true]);
     }
 
+    public function translate(Request $request, Comment $comment, LlmLyricsService $llm)
+    {
+        if (! $llm->isEnabled()) {
+            return response()->json(['error' => 'Translation is not configured'], 503);
+        }
+
+        $target = (string) $request->input('target', 'en');
+
+        // Derive a source-language hint from the comment author's most-frequent
+        // access country (video_views + profile_visits, falling back to their
+        // nationality setting). Never trust the client for this — it's used
+        // to disambiguate scripts the LLM might otherwise misidentify.
+        $topCountries = \App\Models\User::topCountriesFor([$comment->user_id]);
+        $sourceCountry = $topCountries[$comment->user_id] ?? null;
+        $sourceLang    = \App\Data\CountryLanguages::primary($sourceCountry);
+
+        $translated = $llm->translate((string) $comment->body, $target, $sourceLang);
+
+        if ($translated === '') {
+            return response()->json(['error' => 'Translation failed'], 502);
+        }
+
+        return response()->json([
+            'success'       => true,
+            'translated'    => $translated,
+            'target'        => $target,
+            'source_hint'   => $sourceLang,
+            'author_country'=> $sourceCountry,
+        ]);
+    }
+
     public function like(Comment $comment)
     {
         $userId  = Auth::id();
@@ -107,7 +194,8 @@ class CommentController extends Controller
             if ($comment->user_id !== $userId) {
                 $video = $comment->video;
                 if ($video) {
-                    $comment->user->notify(
+                    SafeNotifier::send(
+                        $comment->user,
                         new NewCommentLikeNotification($video, $comment, Auth::user())
                     );
                 }
@@ -118,4 +206,56 @@ class CommentController extends Controller
 
         return response()->json(['liked' => $liked, 'count' => $count]);
     }
+
+    /**
+     * Toggle the "creator heart" on a comment. Only the video owner can
+     * drop a heart; anyone else gets a 403.
+     */
+    public function heart(Comment $comment)
+    {
+        $video = $comment->video;
+        if (! $video || $video->user_id !== Auth::id()) {
+            return response()->json(['error' => 'Only the video owner can heart a comment.'], 403);
+        }
+
+        $comment->hearted = ! $comment->hearted;
+        $comment->save();
+
+        return response()->json([
+            'hearted' => (bool) $comment->hearted,
+        ]);
+    }
+
+    /**
+     * Toggle "pinned" on a top-level comment. Only the video owner can
+     * pin, and pinned comments sort ahead of everything else in the list.
+     * At most one comment is pinned at a time — pinning a new one unpins
+     * the previous.
+     */
+    public function pin(Comment $comment)
+    {
+        $video = $comment->video;
+        if (! $video || $video->user_id !== Auth::id()) {
+            return response()->json(['error' => 'Only the video owner can pin a comment.'], 403);
+        }
+        if ($comment->parent_id) {
+            return response()->json(['error' => 'Only top-level comments can be pinned.'], 422);
+        }
+
+        $wasPinned = (bool) $comment->pinned;
+        if (! $wasPinned) {
+            // Unpin any previously-pinned comment on this video first so
+            // the UI invariant "at most one pinned" is maintained at the
+            // DB level, not just in the view.
+            Comment::where('video_id', $video->id)
+                ->where('pinned', true)
+                ->update(['pinned' => false]);
+        }
+        $comment->pinned = ! $wasPinned;
+        $comment->save();
+
+        return response()->json([
+            'pinned' => (bool) $comment->pinned,
+        ]);
+    }
 }

app/Http/Controllers/LiveAuthController.php

@@ -0,0 +1,208 @@
+<?php
+
+namespace App\Http\Controllers;
+
+use App\Models\LiveStream;
+use Illuminate\Http\Request;
+use Illuminate\Http\Response;
+use Illuminate\Support\Facades\DB;
+use Illuminate\Support\Facades\Log;
+
+/**
+ * The media server's authorisation hook.
+ *
+ * MediaMTX holds no policy of its own: before it accepts a publisher or serves
+ * a viewer it POSTs here, and a non-2xx answer refuses the connection. That
+ * keeps every "who may do what" decision inside the application, next to the
+ * users table, rather than duplicated in a media server config.
+ *
+ * Deny by default, in the strongest sense: if this app is down, the media
+ * server can authorise nothing at all.
+ *
+ * These endpoints are called ONLY by MediaMTX over loopback. They are not part
+ * of the public API and reject anything arriving from elsewhere.
+ */
+class LiveAuthController extends Controller
+{
+    /** Loopback addresses the media server may call from. */
+    private const LOCAL_IPS = ['127.0.0.1', '::1'];
+
+    /**
+     * Decide a publish or read attempt.
+     *
+     * Payload from MediaMTX: user, password, token, ip, action, path,
+     * protocol, id, query.
+     */
+    public function authenticate(Request $request): Response
+    {
+        if (! $this->fromMediaServer($request)) {
+            return response('', 403);
+        }
+
+        $action = (string) $request->input('action');
+
+        // Control-plane actions carry no stream path, so they are settled
+        // before any attempt to resolve one.
+        if (in_array($action, ['api', 'metrics', 'pprof'], true)) {
+            return $this->authorizeApi();
+        }
+
+        $path = (string) $request->input('path');
+
+        $stream = $this->resolveStream($path);
+
+        if (! $stream) {
+            // An unknown path is not an error worth explaining — a publisher
+            // probing for valid stream ids learns nothing from this.
+            return response('', 403);
+        }
+
+        return match ($action) {
+            'publish' => $this->authorizePublish($request, $stream),
+            'read' => $this->authorizeRead($stream),
+            default => response('', 403),
+        };
+    }
+
+    /**
+     * The media server's own control API.
+     *
+     * It authenticates against this same hook, so without an explicit allow the
+     * app could not read live state from the server it runs alongside. Safe
+     * because it is already loopback-gated above — nothing off this host can
+     * reach it.
+     */
+    private function authorizeApi(): Response
+    {
+        return response('', 200);
+    }
+
+    /**
+     * A publisher must present the short-lived token minted for this stream
+     * when its owner pressed "Go live". The token is single-use: it is burned
+     * here, so a captured one cannot start a second broadcast.
+     */
+    private function authorizePublish(Request $request, LiveStream $stream): Response
+    {
+        // MediaMTX passes HTTP Basic credentials through as user/password.
+        $presented = (string) ($request->input('password') ?: $request->input('token'));
+
+        if (! $stream->publishTokenMatches($presented)) {
+            Log::warning('Live publish refused', [
+                'stream' => $stream->public_id,
+                'ip' => $request->input('ip'),
+            ]);
+
+            return response('', 403);
+        }
+
+        $stream->consumePublishToken();
+        $stream->markLive();
+
+        Log::info('Live publish authorised', [
+            'stream' => $stream->public_id,
+            'user_id' => $stream->user_id,
+        ]);
+
+        return response('', 200);
+    }
+
+    /**
+     * Reads are anonymous by design — a viewer fetching HLS parts carries no
+     * credentials — so the gate is the stream's own state: it must be live and
+     * not private. The unpredictable path is what keeps an unlisted stream
+     * unlisted.
+     */
+    private function authorizeRead(LiveStream $stream): Response
+    {
+        if (! $stream->isLive()) {
+            return response('', 403);
+        }
+
+        if (! in_array($stream->visibility, ['public', 'unlisted'], true)) {
+            return response('', 403);
+        }
+
+        return response('', 200);
+    }
+
+    /**
+     * Lifecycle notifications from the media server.
+     *
+     * The auth hook only fires on the way in, so without this a stream whose
+     * phone lost signal would read as live forever.
+     */
+    public function hook(Request $request): Response
+    {
+        if (! $this->fromMediaServer($request)) {
+            return response('', 403);
+        }
+
+        $stream = $this->resolveStream((string) $request->input('path'));
+
+        if (! $stream) {
+            return response('', 204);
+        }
+
+        match ((string) $request->input('event')) {
+            'publish' => $stream->markLive(),
+            // Only a stream that is actually live can end. A late hook from a
+            // previous, failed session must not kill the one just started.
+            'unpublish' => $stream->isLive() ? $stream->markEnded() : null,
+            'read' => $this->viewerJoined($stream),
+            'unread' => $this->viewerLeft($stream),
+            default => null,
+        };
+
+        return response('', 204);
+    }
+
+    /* ---------------- Viewer accounting ---------------- */
+
+    /*
+     * Counted with atomic SQL increments rather than read-modify-write: viewers
+     * arrive concurrently, and two joins landing together would otherwise
+     * record one.
+     */
+
+    private function viewerJoined(LiveStream $stream): void
+    {
+        LiveStream::where('id', $stream->id)->increment('current_viewers');
+
+        // peak_viewers is a high-water mark, so it only ever moves up.
+        LiveStream::where('id', $stream->id)
+            ->whereColumn('current_viewers', '>', 'peak_viewers')
+            ->update(['peak_viewers' => DB::raw('current_viewers')]);
+    }
+
+    private function viewerLeft(LiveStream $stream): void
+    {
+        // Floor at zero: a missed join (a restart, a dropped hook) must not
+        // drive the count negative and show "-1 watching".
+        LiveStream::where('id', $stream->id)
+            ->where('current_viewers', '>', 0)
+            ->decrement('current_viewers');
+    }
+
+    /* ---------------- Helpers ---------------- */
+
+    /**
+     * Only the media server on this host may ask. Deliberately checks the raw
+     * connection address rather than a forwarded header — a header can be
+     * spoofed by anyone who can reach the app.
+     */
+    private function fromMediaServer(Request $request): bool
+    {
+        return in_array($request->server('REMOTE_ADDR'), self::LOCAL_IPS, true);
+    }
+
+    /** Turn "live/<public_id>" into the stream it names. */
+    private function resolveStream(string $path): ?LiveStream
+    {
+        if (! preg_match('#^live/([A-Za-z0-9]{32})$#', $path, $m)) {
+            return null;
+        }
+
+        return LiveStream::where('public_id', $m[1])->first();
+    }
+}

app/Http/Controllers/LiveStreamController.php

@@ -0,0 +1,292 @@
+<?php
+
+namespace App\Http\Controllers;
+
+use App\Models\LiveChatMessage;
+use App\Models\LiveStream;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+use Illuminate\Support\Facades\Auth;
+use Illuminate\Validation\Rule;
+
+/**
+ * Live streaming — broadcaster and viewer surfaces.
+ *
+ * The media plane (MediaMTX) is deliberately dumb: this controller decides who
+ * may broadcast, mints the short-lived credential the browser publishes with,
+ * and hands out the URLs. See LiveAuthController for the hook the media server
+ * calls back on.
+ */
+class LiveStreamController extends Controller
+{
+    public function __construct()
+    {
+        // Watching is open; everything that creates or controls a stream needs
+        // an account.
+        $this->middleware('auth')->except(['index', 'watch', 'status', 'chatPoll']);
+    }
+
+    /** Live now, plus the viewer's own streams when signed in. */
+    public function index(): \Illuminate\View\View
+    {
+        $live = LiveStream::live()
+            ->listed()
+            ->with('user')
+            ->latest('started_at')
+            ->limit(60)
+            ->get();
+
+        $mine = Auth::check()
+            ? LiveStream::where('user_id', Auth::id())->latest()->limit(20)->get()
+            : collect();
+
+        return view('live.index', compact('live', 'mine'));
+    }
+
+    /** The "start a broadcast" form. */
+    public function create(): \Illuminate\View\View
+    {
+        return view('live.create');
+    }
+
+    /**
+     * Create the stream record. This does NOT start anything — it reserves an
+     * identity and a path; the browser goes live from the broadcast page.
+     */
+    public function store(Request $request): \Illuminate\Http\RedirectResponse
+    {
+        $data = $request->validate([
+            'title' => ['required', 'string', 'max:120'],
+            'description' => ['nullable', 'string', 'max:2000'],
+            'visibility' => ['required', Rule::in(['public', 'unlisted', 'private'])],
+        ]);
+
+        // One live broadcast per account at a time. Without this a single user
+        // can pin open as many encoder slots as they can open tabs.
+        $alreadyLive = LiveStream::where('user_id', Auth::id())
+            ->where('status', LiveStream::STATUS_LIVE)
+            ->exists();
+
+        if ($alreadyLive) {
+            return back()
+                ->withInput()
+                ->withErrors(['title' => 'You already have a stream running. End it before starting another.']);
+        }
+
+        $stream = LiveStream::create([
+            'user_id' => Auth::id(),
+            'title' => $data['title'],
+            'description' => $data['description'] ?? null,
+            'visibility' => $data['visibility'],
+            'status' => LiveStream::STATUS_IDLE,
+        ]);
+
+        return redirect()->route('live.broadcast', $stream);
+    }
+
+    /** The broadcaster's camera page. Owner only. */
+    public function broadcast(LiveStream $stream): \Illuminate\View\View
+    {
+        abort_unless($stream->isOwnedBy(Auth::user()), 403);
+
+        // An ended stream is not a dead one — the owner may go live on it
+        // again from the same link.
+        $stream->reArm();
+
+        return view('live.broadcast', [
+            'stream' => $stream,
+            'whipUrl' => $this->whipUrl($stream),
+            'watchUrl' => route('live.watch', $stream),
+            'iceServers' => $this->iceServers(),
+        ]);
+    }
+
+    /**
+     * Mint the publish credential.
+     *
+     * Separate from the page load so the token's short life starts when the
+     * user actually presses "Go live", not when they opened the tab and went
+     * to find a tripod.
+     */
+    public function token(LiveStream $stream): JsonResponse
+    {
+        abort_unless($stream->isOwnedBy(Auth::user()), 403);
+
+        // Pressing "Go live" on a stream that previously ended restarts it
+        // rather than being refused. A failed attempt must never burn the link.
+        $stream->reArm();
+
+        return response()->json([
+            'token' => $stream->issuePublishToken(),
+            'expires_in' => LiveStream::PUBLISH_TOKEN_TTL_SECONDS,
+            'whip_url' => $this->whipUrl($stream),
+            'ice_servers' => $this->iceServers(),
+        ]);
+    }
+
+    /** The viewer page. */
+    public function watch(LiveStream $stream): \Illuminate\View\View
+    {
+        abort_unless($stream->isWatchableBy(Auth::user()), 404);
+
+        $stream->loadMissing('user');
+
+        return view('live.watch', [
+            'stream' => $stream,
+            'whepUrl' => $this->whepUrl($stream),
+            'hlsUrl' => $this->hlsUrl($stream),
+            'isOwner' => $stream->isOwnedBy(Auth::user()),
+            'iceServers' => $this->iceServers(),
+        ]);
+    }
+
+    /** Lightweight poll for the viewer page: is it live, how many watching. */
+    public function status(LiveStream $stream): JsonResponse
+    {
+        abort_unless($stream->isWatchableBy(Auth::user()), 404);
+
+        return response()->json([
+            'status' => $stream->status,
+            'live' => $stream->isLive(),
+            'viewers' => $stream->current_viewers,
+            'duration' => $stream->formatted_duration,
+        ]);
+    }
+
+    /** End the broadcast. Owner only. */
+    public function stop(LiveStream $stream): JsonResponse
+    {
+        abort_unless($stream->isOwnedBy(Auth::user()), 403);
+
+        $stream->markEnded();
+
+        return response()->json([
+            'success' => true,
+            'status' => $stream->status,
+            'duration' => $stream->formatted_duration,
+        ]);
+    }
+
+    /* ---------------- URLs ---------------- */
+
+    /*
+     * These are same-origin paths, proxied by nginx to the media server on
+     * loopback. Same-origin matters: the page is served over HTTPS, and a
+     * mixed-content or cross-origin media URL would be blocked by the browser
+     * before WebRTC ever started.
+     */
+
+    private function whipUrl(LiveStream $stream): string
+    {
+        return url('/live-rtc/'.$stream->mediaPath().'/whip');
+    }
+
+    private function whepUrl(LiveStream $stream): string
+    {
+        return url('/live-rtc/'.$stream->mediaPath().'/whep');
+    }
+
+    private function hlsUrl(LiveStream $stream): string
+    {
+        return url('/live-hls/'.$stream->mediaPath().'/index.m3u8');
+    }
+
+    /**
+     * ICE servers for the browser.
+     *
+     * No inbound UDP port is forwarded to this server, so a broadcaster outside
+     * the local network can only reach it through a TURN relay. On the LAN the
+     * host candidates work directly and TURN is never used.
+     *
+     * Configured through the environment so credentials never sit in the repo.
+     */
+    private function iceServers(): array
+    {
+        $servers = [];
+
+        if ($stun = config('live.stun_url')) {
+            $servers[] = ['urls' => $stun];
+        }
+
+        if ($turn = config('live.turn_url')) {
+            $servers[] = array_filter([
+                'urls' => $turn,
+                'username' => config('live.turn_username'),
+                'credential' => config('live.turn_credential'),
+            ]);
+        }
+
+        return $servers;
+    }
+
+    /**
+     * GET poll: viewer asks for every message in this stream newer than
+     * ?since=<id> (defaults to 0 for a cold open). Returns up to 50
+     * messages — more than enough for a 3-second polling window, bounded
+     * to protect the DB when a client is slow to reconnect.
+     */
+    public function chatPoll(Request $request, LiveStream $stream): JsonResponse
+    {
+        // Private streams are owner-only; everything else is open to viewers.
+        if ($stream->visibility === 'private' && Auth::id() !== $stream->user_id) {
+            abort(404);
+        }
+
+        $since = (int) $request->query('since', 0);
+        $rows  = LiveChatMessage::where('livestream_id', $stream->id)
+            ->where('id', '>', $since)
+            ->orderBy('id')
+            ->limit(50)
+            ->get(['id', 'user_id', 'author_name', 'body', 'created_at']);
+
+        return response()->json([
+            'messages' => $rows->map(fn ($m) => [
+                'id'   => $m->id,
+                'uid'  => $m->user_id,
+                'name' => $m->author_name,
+                'body' => $m->body,
+                'at'   => $m->created_at?->toISOString(),
+            ])->all(),
+        ]);
+    }
+
+    /**
+     * POST a chat message. Rate-limited to roughly one message per second
+     * per user via Laravel's built-in throttle, applied via the route.
+     * Body is capped at 400 chars (long enough for a sentence, short enough
+     * that the panel doesn't shear into a wall of text).
+     */
+    public function chatSend(Request $request, LiveStream $stream): JsonResponse
+    {
+        if ($stream->status !== LiveStream::STATUS_LIVE) {
+            return response()->json(['error' => 'Chat is closed when the stream isn\'t live.'], 422);
+        }
+        if ($stream->visibility === 'private' && Auth::id() !== $stream->user_id) {
+            abort(404);
+        }
+
+        $data = $request->validate([
+            'body' => ['required', 'string', 'max:400'],
+        ]);
+
+        $user = Auth::user();
+        $msg  = LiveChatMessage::create([
+            'livestream_id' => $stream->id,
+            'user_id'       => $user->id,
+            'author_name'   => $user->name,
+            'body'          => trim($data['body']),
+            'created_at'    => now(),
+        ]);
+
+        return response()->json([
+            'ok' => true,
+            'message' => [
+                'id'   => $msg->id,
+                'uid'  => $msg->user_id,
+                'name' => $msg->author_name,
+                'body' => $msg->body,
+                'at'   => $msg->created_at?->toISOString(),
+            ],
+        ]);
+    }
+}

app/Http/Controllers/MatchEventController.php

@@ -18,7 +18,7 @@ class MatchEventController extends Controller
         $request->validate([
             'round_number' => 'required|integer|min:1',
             'name' => 'nullable|string|max:50',
-            'start_time_seconds' => 'nullable|integer|min:0',
+            'start_time_seconds' => 'nullable|numeric|min:0',
         ]);
 
         // Check if user owns the video
@@ -45,7 +45,7 @@ class MatchEventController extends Controller
         $request->validate([
             'round_number' => 'sometimes|integer|min:1',
             'name' => 'required|string|max:50',
-            'start_time_seconds' => 'nullable|integer|min:0',
+            'start_time_seconds' => 'nullable|numeric|min:0',
         ]);
 
         // Check if user owns the video
@@ -87,7 +87,7 @@ class MatchEventController extends Controller
     {
         $request->validate([
             'round_id' => 'required|exists:match_rounds,id',
-            'timestamp_seconds' => 'required|integer|min:0',
+            'timestamp_seconds' => 'required|numeric|min:0',
             'action' => 'required|string|max:255',
             'points' => 'required|integer|min:1',
             'competitor' => 'required|in:blue,red',
@@ -99,31 +99,10 @@ class MatchEventController extends Controller
             return response()->json(['success' => false, 'message' => 'Unauthorized'], 403);
         }
 
-        // Get ALL previous points in this round (ordered by timestamp)
-        $previousPoints = MatchPoint::where('match_round_id', $request->round_id)
-            ->where('timestamp_seconds', '<', $request->timestamp_seconds)
-            ->orderBy('timestamp_seconds', 'asc')
-            ->pluck('points', 'competitor')
-            ->toArray();
-
-        // Calculate cumulative scores by summing each point value
-        $scoreBlue = 0;
-        $scoreRed = 0;
-
-        if (isset($previousPoints['blue'])) {
-            $scoreBlue += $previousPoints['blue'];
-        }
-        if (isset($previousPoints['red'])) {
-            $scoreRed += $previousPoints['red'];
-        }
-
-        // Add current point
-        if ($request->competitor === 'blue') {
-            $scoreBlue += $request->points;
-        } else {
-            $scoreRed += $request->points;
-        }
-
+        // Create the row first with placeholder scores, then recompute the whole
+        // round's running scores. This is the only correct approach when two
+        // points can share a timestamp (Blue + Red at the same moment) or when
+        // a point is inserted between existing ones.
         $point = MatchPoint::create([
             'video_id' => $video->id,
             'match_round_id' => $request->round_id,
@@ -132,21 +111,46 @@ class MatchEventController extends Controller
             'points' => $request->points,
             'competitor' => $request->competitor,
             'notes' => $request->notes,
-            'score_blue' => $scoreBlue,
-            'score_red' => $scoreRed,
+            'score_blue' => 0,
+            'score_red' => 0,
         ]);
 
+        $this->recomputeRoundScores($request->round_id);
+
         return response()->json([
             'success' => true,
-            'point' => $point,
+            'point' => $point->fresh(),
             'message' => 'Point added successfully!',
         ]);
     }
 
+    /**
+     * Recompute cumulative score_blue/score_red for every point in a round,
+     * ordered by (timestamp_seconds, id). Handles same-timestamp ties by
+     * insertion order, so Blue and Red saved at the same moment both end up
+     * reflecting the running score after that moment.
+     */
+    private function recomputeRoundScores(int $roundId): void
+    {
+        $blue = 0;
+        $red  = 0;
+        MatchPoint::where('match_round_id', $roundId)
+            ->orderBy('timestamp_seconds', 'asc')
+            ->orderBy('id', 'asc')
+            ->get()
+            ->each(function (MatchPoint $p) use (&$blue, &$red) {
+                if ($p->competitor === 'blue') $blue += (int) $p->points;
+                else                            $red  += (int) $p->points;
+                if ((int) $p->score_blue !== $blue || (int) $p->score_red !== $red) {
+                    $p->update(['score_blue' => $blue, 'score_red' => $red]);
+                }
+            });
+    }
+
     public function updatePoint(Request $request, MatchPoint $point)
     {
         $request->validate([
-            'timestamp_seconds' => 'required|integer|min:0',
+            'timestamp_seconds' => 'required|numeric|min:0',
             'action' => 'required|string|max:255',
             'points' => 'required|integer|min:1',
             'competitor' => 'required|in:blue,red',
@@ -158,6 +162,7 @@ class MatchEventController extends Controller
             return response()->json(['success' => false, 'message' => 'Unauthorized'], 403);
         }
 
+        $roundId = $point->match_round_id;
         $point->update([
             'timestamp_seconds' => $request->timestamp_seconds,
             'action' => $request->action,
@@ -166,9 +171,11 @@ class MatchEventController extends Controller
             'notes' => $request->notes,
         ]);
 
+        $this->recomputeRoundScores($roundId);
+
         return response()->json([
             'success' => true,
-            'point' => $point,
+            'point' => $point->fresh(),
             'message' => 'Point updated successfully!',
         ]);
     }
@@ -180,7 +187,9 @@ class MatchEventController extends Controller
             return response()->json(['success' => false, 'message' => 'Unauthorized'], 403);
         }
 
+        $roundId = $point->match_round_id;
         $point->delete();
+        $this->recomputeRoundScores($roundId);
 
         return response()->json([
             'success' => true,
@@ -193,11 +202,13 @@ class MatchEventController extends Controller
     public function storeReview(Request $request, Video $video)
     {
         $request->validate([
-            'start_time_seconds' => 'required|integer|min:0',
-            'end_time_seconds' => 'nullable|integer|min:0',
+            'start_time_seconds' => 'required|numeric|min:0',
+            'end_time_seconds' => 'nullable|numeric|min:0',
             'note' => 'required|string|max:1000',
             'coach_name' => 'required|string|max:100',
             'emoji' => 'nullable|string|max:10',
+            'position_x' => 'nullable|numeric|between:0,1',
+            'position_y' => 'nullable|numeric|between:0,1',
         ]);
 
         // Check if user owns the video
@@ -213,6 +224,8 @@ class MatchEventController extends Controller
             'note' => $request->note,
             'coach_name' => $request->coach_name,
             'emoji' => $request->emoji ?? '🔥',
+            'position_x' => $request->position_x,
+            'position_y' => $request->position_y,
         ]);
 
         return response()->json([
@@ -225,11 +238,13 @@ class MatchEventController extends Controller
     public function updateReview(Request $request, CoachReview $review)
     {
         $request->validate([
-            'start_time_seconds' => 'required|integer|min:0',
-            'end_time_seconds' => 'nullable|integer|min:0',
+            'start_time_seconds' => 'required|numeric|min:0',
+            'end_time_seconds' => 'nullable|numeric|min:0',
             'note' => 'required|string|max:1000',
             'coach_name' => 'required|string|max:100',
             'emoji' => 'nullable|string|max:10',
+            'position_x' => 'nullable|numeric|between:0,1',
+            'position_y' => 'nullable|numeric|between:0,1',
         ]);
 
         // Check if user owns the video
@@ -243,6 +258,8 @@ class MatchEventController extends Controller
             'note' => $request->note,
             'coach_name' => $request->coach_name,
             'emoji' => $request->emoji,
+            'position_x' => $request->position_x,
+            'position_y' => $request->position_y,
         ]);
 
         return response()->json([

app/Http/Controllers/MediaController.php

@@ -190,6 +190,25 @@ class MediaController extends Controller
         return $this->fileResponse($local);
     }
 
+    public function sportsImage(string $filename, NasSyncService $nas): Response
+    {
+        // Format: "users/{slug}/sports/{matchId}/{key}.{ext}"
+        if (str_starts_with($filename, 'users/')) {
+            $local = storage_path('app/' . $filename);
+
+            if (! file_exists($local)) {
+                @mkdir(dirname($local), 0755, true);
+                // NAS path is identical to the relative path stored in DB
+                $nas->ensureLocalAsset($local, $filename);
+                if (! file_exists($local)) abort(404);
+            }
+
+            return $this->fileResponse($local);
+        }
+
+        abort(404);
+    }
+
     // ── Helper ────────────────────────────────────────────────────────────────
 
     private function fileResponse(string $path): Response

app/Http/Controllers/PlaylistController.php

@@ -5,6 +5,7 @@ namespace App\Http\Controllers;
 use App\Models\Playlist;
 use App\Models\Video;
 use App\Services\GeoIpService;
+use App\Services\NasSyncService;
 use Illuminate\Http\Request;
 use Illuminate\Support\Facades\Auth;
 use Illuminate\Support\Facades\DB;
@@ -14,7 +15,7 @@ class PlaylistController extends Controller
 {
     public function __construct()
     {
-        $this->middleware('auth')->except(['index', 'show', 'showByToken', 'publicPlaylists', 'userPlaylists', 'recordShare', 'accessShare']);
+        $this->middleware('auth')->except(['index', 'show', 'showByToken', 'publicPlaylists', 'userPlaylists', 'recordShare', 'accessShare', 'ogImage']);
     }
 
     // List user's playlists
@@ -27,9 +28,8 @@ class PlaylistController extends Controller
     }
 
     // View a single playlist
-    public function show(Playlist $playlist)
+    public function show(Request $request, Playlist $playlist)
     {
-        // Check if user can view this playlist
         if (! $playlist->canView(Auth::user())) {
             abort(404, 'Playlist not found');
         }
@@ -37,11 +37,17 @@ class PlaylistController extends Controller
         $playlist->loadMissing('user');
         $videos = $playlist->videos()->with('user')->orderBy('position')->get();
 
+        // Count this visit (deduped per device) after the response is sent so
+        // the page render isn't blocked by the EXISTS / INSERT / UPDATE round-trip.
+        dispatch(function () use ($playlist, $request) {
+            $playlist->bumpViewIfNew($request);
+        })->afterResponse();
+
         return view('playlists.show', compact('playlist', 'videos'));
     }
 
     // View playlist via unguessable share token (unlisted playlists)
-    public function showByToken(string $token)
+    public function showByToken(Request $request, string $token)
     {
         $playlist = Playlist::where('share_token', $token)->firstOrFail();
 
@@ -52,6 +58,10 @@ class PlaylistController extends Controller
         $playlist->loadMissing('user');
         $videos = $playlist->videos()->with('user')->orderBy('position')->get();
 
+        dispatch(function () use ($playlist, $request) {
+            $playlist->bumpViewIfNew($request);
+        })->afterResponse();
+
         return view('playlists.show', compact('playlist', 'videos'));
     }
 
@@ -119,6 +129,28 @@ class PlaylistController extends Controller
             ]);
         }
 
+        // Serve the playlist's own OG metadata to social-media crawlers so previews
+        // show the playlist's picture and name — not the first video's. Humans still
+        // get redirected to the first track for one-tap playback.
+        $ua = (string) $request->userAgent();
+        $isCrawler = (bool) preg_match(
+            '/facebookexternalhit|facebookcatalog|Facebot|Twitterbot|LinkedInBot|Slackbot|Discordbot|WhatsApp|TelegramBot|Pinterest|redditbot|Googlebot|bingbot|DuckDuckBot|YandexBot|Applebot|Embedly|vkShare|W3C_Validator|SkypeUriPreview/i',
+            $ua
+        );
+
+        if ($isCrawler) {
+            $playlist->loadMissing('user');
+            $videos = $playlist->videos()->with('user')->orderBy('position')->get();
+            return response()
+                ->view('playlists.show', compact('playlist', 'videos'))
+                ->withCookie(cookie('_did', $did, 60 * 24 * 365 * 5));
+        }
+
+        // Human share-link click counts as a playlist view (deduped per device).
+        dispatch(function () use ($playlist, $request) {
+            $playlist->bumpViewIfNew($request);
+        })->afterResponse();
+
         $firstVideo = $playlist->videos()->orderBy('position')->first();
         $destination = $firstVideo
             ? route('videos.show', $firstVideo) . '?playlist=' . $playlist->share_token
@@ -225,24 +257,20 @@ class PlaylistController extends Controller
             'visibility' => $request->visibility ?? 'private',
         ];
 
-        // Handle thumbnail upload
+        // Thumbnail: an uploaded file always wins over remove_thumbnail. The
+        // modal sometimes sends both when a user clears the preview and then
+        // picks a new file — without this guard the new file would be silently
+        // discarded.
         if ($request->hasFile('thumbnail')) {
-            // Delete old thumbnail from NAS if exists
             if ($playlist->thumbnail) {
                 self::deletePlaylistThumbnailFromNas($playlist->thumbnail);
             }
-
             $file = $request->file('thumbnail');
             $updateData['thumbnail'] = self::pushPlaylistThumbnailToNas($file, $playlist);
-        }
-
-        // Handle thumbnail removal
-        if ($request->input('remove_thumbnail') == '1') {
-            if ($playlist->thumbnail) {
+        } elseif ($request->input('remove_thumbnail') == '1' && $playlist->thumbnail) {
             self::deletePlaylistThumbnailFromNas($playlist->thumbnail);
             $updateData['thumbnail'] = null;
         }
-        }
 
         $playlist->update($updateData);
 
@@ -296,6 +324,7 @@ class PlaylistController extends Controller
 
         $request->validate([
             'video_id'       => 'required|exists:videos,id',
+            'audio_track_id' => 'nullable|integer|exists:video_audio_tracks,id',
         ]);
 
         $video = Video::findOrFail($request->video_id);
@@ -305,7 +334,13 @@ class PlaylistController extends Controller
             abort(403, 'You cannot add this video to your playlist.');
         }
 
-        $added = $playlist->addVideo($video);
+        // Track must actually belong to this video (avoid arbitrary FK pinning).
+        $audioTrackId = $request->input('audio_track_id');
+        if ($audioTrackId && ! $video->audioTracks()->whereKey($audioTrackId)->exists()) {
+            $audioTrackId = null;
+        }
+
+        $added = $playlist->addVideo($video, $audioTrackId ? (int) $audioTrackId : null);
 
         if ($request->expectsJson() || $request->ajax()) {
             return response()->json([
@@ -318,6 +353,39 @@ class PlaylistController extends Controller
         return back()->with('success', $added ? 'Video added to playlist!' : 'Video is already in playlist.');
     }
 
+    /**
+     * Body-based mirror of removeVideo: looks up the Video by raw numeric id
+     * from the request body. Lets callers (e.g. the add-to-playlist modal) drive
+     * the toggle without having to know the encoded route key for Video.
+     */
+    public function removeVideoByBody(Request $request, Playlist $playlist)
+    {
+        $request->validate([
+            'video_id'       => 'required|exists:videos,id',
+            'audio_track_id' => 'nullable|integer',
+        ]);
+
+        if (! $playlist->canEdit(Auth::user())) {
+            abort(403, 'You do not have permission to edit this playlist.');
+        }
+
+        $video = Video::findOrFail($request->video_id);
+        $trackId = $request->filled('audio_track_id')
+            ? (int) $request->input('audio_track_id')
+            : null;
+
+        $removed = $playlist->removeVideoWithTrack($video, $trackId);
+
+        if ($request->expectsJson() || $request->ajax()) {
+            return response()->json([
+                'success' => true,
+                'message' => $removed ? 'Video removed from playlist.' : 'Video was not in the playlist.',
+                'video_count' => $playlist->video_count,
+            ]);
+        }
+        return back()->with('success', 'Video removed from playlist.');
+    }
+
     // Remove video from playlist
     public function removeVideo(Request $request, Playlist $playlist, Video $video)
     {
@@ -391,6 +459,17 @@ class PlaylistController extends Controller
                 'visibility' => $p->visibility,
                 'thumbnail_url' => $p->thumbnail_url,
                 'video_ids' => $p->videos()->pluck('videos.id')->toArray(),
+                // Track-aware entries: each row = {video_id, audio_track_id or null}.
+                // Consumers that need per-track granularity use this; older callers
+                // can still rely on video_ids above.
+                'entries' => \DB::table('playlist_videos')
+                    ->where('playlist_id', $p->id)
+                    ->select('video_id', 'audio_track_id')
+                    ->get()
+                    ->map(fn ($r) => [
+                        'video_id'       => (int) $r->video_id,
+                        'audio_track_id' => $r->audio_track_id ? (int) $r->audio_track_id : null,
+                    ])->all(),
             ];
         });
 
@@ -477,16 +556,32 @@ class PlaylistController extends Controller
     {
         $nas     = app(\App\Services\NasSyncService::class);
         $ext     = $file->getClientOriginalExtension() ?: 'jpg';
+        $nasPath = self::nasPlaylistThumbPath($playlist, $ext);
+        $localAbs = storage_path('app/' . $nasPath);
+
+        // When NAS is reachable, push directly and avoid the slow timeout path.
+        if ($nas->isEnabled()) {
             $tmpName  = self::generateFilename($ext);
             $file->storeAs('public/thumbnails', $tmpName);
             $tempAbs  = storage_path('app/public/thumbnails/' . $tmpName);
-        $nasPath  = self::nasPlaylistThumbPath($playlist, $ext);
-        $dir      = dirname($nasPath);
-        $nas->mkdirp($dir);
-        $nas->putFile($tempAbs, $nasPath);
+            $nas->mkdirp(dirname($nasPath));
+            if ($nas->putFile($tempAbs, $nasPath)) {
                 @unlink($tempAbs);
                 return $nasPath;
             }
+            // NAS push failed mid-flight — fall through to local fallback so the
+            // file isn't lost. nas:auto-sync will retry when NAS comes back.
+            @mkdir(dirname($localAbs), 0755, true);
+            @rename($tempAbs, $localAbs);
+            return $nasPath;
+        }
+
+        // NAS disabled / unreachable — keep on local disk at the same path
+        // MediaController expects, so it serves directly without a NAS round-trip.
+        @mkdir(dirname($localAbs), 0755, true);
+        $file->move(dirname($localAbs), basename($localAbs));
+        return $nasPath;
+    }
 
     private static function deletePlaylistThumbnailFromNas(?string $nasPath): void
     {
@@ -495,4 +590,109 @@ class PlaylistController extends Controller
             app(\App\Services\NasSyncService::class)->deleteFile($nasPath);
         } catch (\Throwable) {}
     }
+
+    // Social-preview image: resize the playlist's own thumbnail to a 1200x630 JPEG
+    // (small enough for WhatsApp/Telegram/Discord previews). Falls back to a branded card.
+    public function ogImage(Playlist $playlist, NasSyncService $nas)
+    {
+        if (! $playlist->canViewViaToken(Auth::user())) {
+            abort(404);
+        }
+
+        if ($playlist->thumbnail) {
+            $local = storage_path('app/' . $playlist->thumbnail);
+            if (! file_exists($local)) {
+                @mkdir(dirname($local), 0755, true);
+                $nas->ensureLocalAsset($local, $playlist->thumbnail);
+            }
+            if (file_exists($local)) {
+                $ext = strtolower(pathinfo($local, PATHINFO_EXTENSION));
+                $src = match ($ext) {
+                    'png'  => @imagecreatefrompng($local),
+                    'webp' => @imagecreatefromwebp($local),
+                    'gif'  => @imagecreatefromgif($local),
+                    default => @imagecreatefromjpeg($local),
+                };
+                if ($src) {
+                    $ow = imagesx($src); $oh = imagesy($src);
+                    // Always output an exact 1200x630 canvas (cover-crop, no letterbox)
+                    // so the served image matches the og:image:width/height we declare —
+                    // a mismatch makes WhatsApp/Telegram fall back to the tiny thumbnail.
+                    $cw = 1200; $ch = 630;
+                    $dst = imagecreatetruecolor($cw, $ch);
+                    // Cover: scale so the image fills the whole canvas, center-crop overflow
+                    $scale = max($cw / $ow, $ch / $oh);
+                    $sw = (int) round($cw / $scale);
+                    $sh = (int) round($ch / $scale);
+                    $sx = (int) round(($ow - $sw) / 2);
+                    $sy = (int) round(($oh - $sh) / 2);
+                    imagecopyresampled($dst, $src, 0, 0, $sx, $sy, $cw, $ch, $sw, $sh);
+                    imagedestroy($src);
+                    ob_start();
+                    imagejpeg($dst, null, 82);
+                    imagedestroy($dst);
+                    $jpeg = ob_get_clean();
+                    return response($jpeg, 200, [
+                        'Content-Type'  => 'image/jpeg',
+                        'Cache-Control' => 'public, max-age=86400',
+                    ]);
+                }
+            }
+        }
+
+        // Branded fallback card
+        $w = 1200; $h = 630;
+        $img = imagecreatetruecolor($w, $h);
+        $cBg    = imagecolorallocate($img, 10, 10, 10);
+        $cRed   = imagecolorallocate($img, 230, 30, 30);
+        $cWhite = imagecolorallocate($img, 240, 240, 240);
+        $cGray  = imagecolorallocate($img, 120, 120, 120);
+        imagefill($img, 0, 0, $cBg);
+        imagefilledrectangle($img, 0, 0, $w, 8, $cRed);
+        imagefilledrectangle($img, 0, $h - 8, $w, $h, $cRed);
+
+        $cx = (int)($w / 2); $cy = (int)($h / 2) - 30; $r = 72;
+        imagefilledellipse($img, $cx, $cy, $r * 2, $r * 2, $cRed);
+        $tri = [$cx - 22, $cy - 30, $cx - 22, $cy + 30, $cx + 34, $cy];
+        imagefilledpolygon($img, $tri, $cWhite);
+
+        $fontBold   = '/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf';
+        $fontNormal = '/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf';
+        imagettftext($img, 22, 0, 40, 56, $cRed, $fontBold, strtoupper(config('app.name')));
+
+        $title = $playlist->name ?: 'Playlist';
+        $maxChars = 42;
+        $lines = [];
+        if (mb_strlen($title) > $maxChars) {
+            $words = explode(' ', $title); $line = '';
+            foreach ($words as $word) {
+                if (mb_strlen($line . ' ' . $word) > $maxChars) { $lines[] = trim($line); $line = $word; }
+                else { $line .= ($line ? ' ' : '') . $word; }
+            }
+            if ($line) $lines[] = trim($line);
+        } else { $lines = [$title]; }
+        $lines = array_slice($lines, 0, 2);
+        $titleY = $cy + $r + 60;
+        foreach ($lines as $i => $line) {
+            $bbox = imagettfbbox(28, 0, $fontBold, $line);
+            $tw = $bbox[2] - $bbox[0];
+            $tx = (int)(($w - $tw) / 2);
+            imagettftext($img, 28, 0, $tx, $titleY + $i * 44, $cWhite, $fontBold, $line);
+        }
+
+        $meta = $playlist->video_count . ' videos' . ($playlist->user ? ' • by ' . $playlist->user->name : '');
+        $bbox = imagettfbbox(16, 0, $fontNormal, $meta);
+        $tw = $bbox[2] - $bbox[0];
+        $tx = (int)(($w - $tw) / 2);
+        imagettftext($img, 16, 0, $tx, $titleY + count($lines) * 44 + 20, $cGray, $fontNormal, $meta);
+
+        ob_start();
+        imagejpeg($img, null, 85);
+        imagedestroy($img);
+        $jpeg = ob_get_clean();
+        return response($jpeg, 200, [
+            'Content-Type'  => 'image/jpeg',
+            'Cache-Control' => 'public, max-age=86400',
+        ]);
+    }
 }

app/Http/Controllers/SearchController.php

@@ -0,0 +1,96 @@
+<?php
+
+namespace App\Http\Controllers;
+
+use App\Models\Playlist;
+use App\Models\User;
+use App\Models\Video;
+use App\Models\VideoAudioTrack;
+use Illuminate\Http\Request;
+
+/**
+ * Site-wide search across videos, channels and playlists.
+ *
+ * Lives on /search?q=… so the URL reads like what you'd expect from a modern
+ * site. The old /videos/search endpoint still works but redirects here, so
+ * nothing bookmarked earlier breaks.
+ *
+ * Match surface:
+ *   - Video title, description, tag list, primary language and the language
+ *     of any secondary audio track attached to it.
+ *   - User name, username (handle), and short bio.
+ *   - Playlist name and description.
+ *
+ * We render the existing `videos.index` view so every search result lands in
+ * the same card component the browse feeds use — one place to style, one place
+ * to fix bugs.
+ */
+class SearchController extends Controller
+{
+    public function index(Request $request)
+    {
+        $query = trim((string) $request->get('q', ''));
+
+        if ($query === '') {
+            // No query → send the user back to the browse feed instead of an
+            // empty "no results" page.
+            return redirect()->route('videos.index');
+        }
+
+        $like    = '%' . $query . '%';
+        $qLower  = mb_strtolower($query);
+
+        // ── Videos ────────────────────────────────────────────────
+        // Match on text columns AND on any audio-track language that aligns
+        // with the query (e.g. searching "arabic" surfaces videos that carry
+        // an Arabic track even if the primary language is English).
+        $trackVideoIds = VideoAudioTrack::whereRaw('LOWER(language) = ?', [$qLower])
+            ->pluck('video_id');
+
+        $videoHits = Video::public()
+            ->where(function ($q) use ($like, $qLower, $trackVideoIds) {
+                $q->where('title',       'like', $like)
+                  ->orWhere('description','like', $like)
+                  ->orWhere('tags',       'like', $like)
+                  ->orWhereRaw('LOWER(language) = ?', [$qLower])
+                  ->orWhereIn('id', $trackVideoIds);
+            })
+            ->latest()
+            ->limit(60)
+            ->get();
+
+        $videos = $videoHits->where('is_shorts', false)->values();
+        $shorts = $videoHits->where('is_shorts', true)->values();
+
+        // ── Channels ──────────────────────────────────────────────
+        $channels = User::where(function ($q) use ($like) {
+                $q->where('name',     'like', $like)
+                  ->orWhere('username','like', $like)
+                  ->orWhere('bio',    'like', $like);
+            })
+            ->orderByDesc('id')
+            ->limit(12)
+            ->get();
+
+        // ── Playlists ─────────────────────────────────────────────
+        $playlists = Playlist::where('visibility', 'public')
+            ->where(function ($q) use ($like) {
+                $q->where('name',       'like', $like)
+                  ->orWhere('description','like', $like);
+            })
+            ->withCount('videos')
+            ->with(['user', 'videos' => fn ($q) => $q->orderBy('playlist_videos.position')->limit(1)])
+            ->latest()
+            ->limit(12)
+            ->get();
+
+        return view('videos.index', [
+            'videos'    => $videos,
+            'shorts'    => $shorts,
+            'playlists' => $playlists,
+            'channels'  => $channels,
+            'query'     => $query,
+            'langChips' => [],
+        ]);
+    }
+}

app/Http/Controllers/SportsMatchController.php

@@ -0,0 +1,342 @@
+<?php
+
+namespace App\Http\Controllers;
+
+use App\Http\Controllers\VideoController;
+use App\Models\SportsMatch;
+use App\Services\NasSyncService;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+use Illuminate\Http\UploadedFile;
+use Illuminate\Support\Facades\Auth;
+use Illuminate\Validation\Rule;
+
+class SportsMatchController extends Controller
+{
+    /** Single-image fields stored under the `media` JSON group. */
+    private const IMAGE_FIELDS = [
+        'media_participant1_photo' => 'participant1_photo',
+        'media_participant2_photo' => 'participant2_photo',
+        'media_referee_photo'      => 'referee_photo',
+        'media_club1_logo'         => 'club1_logo',
+        'media_club2_logo'         => 'club2_logo',
+        'media_event_poster'       => 'event_poster',
+    ];
+
+    public function store(Request $request, NasSyncService $nas): JsonResponse
+    {
+        $data = $request->validate($this->rules());
+
+        $match = new SportsMatch();
+        $match->user_id = Auth::id();
+        $this->fillFromRequest($match, $request, $data);
+        $match->save();
+
+        $this->handleImages($match, $request, $nas);
+        $match->save();
+
+        if ($match->video && $match->video->title !== $match->title) {
+            $match->video->title = $match->title;
+            $match->video->save();
+        }
+
+        // Prefetch the OG social-share PNG so WhatsApp/Facebook crawlers
+        // get the composed VS card on first share, not the fallback frame.
+        if ($match->video) {
+            // Blocks the response by ~3–5s while the VS PNG renders. That
+            // wait is intentional: the user typically shares the URL right
+            // after saving, and WhatsApp/Facebook cache whatever they see
+            // on first crawl. If the render hasn't finished when the
+            // crawler hits, we'd be stuck on the thumbnail fallback in
+            // every future share.
+            (new VideoController())->renderMatchOgSync($match->video->fresh(['sportsMatch']));
+        }
+
+        return response()->json([
+            'ok'      => true,
+            'message' => 'Match saved as draft.',
+            'match'   => $this->toEditPayload($match),
+        ]);
+    }
+
+    public function update(Request $request, SportsMatch $sportsMatch, NasSyncService $nas): JsonResponse
+    {
+        abort_unless($sportsMatch->user_id === Auth::id(), 403);
+
+        $data = $request->validate($this->rules($sportsMatch));
+
+        $this->fillFromRequest($sportsMatch, $request, $data);
+        $this->handleImages($sportsMatch, $request, $nas);
+        $sportsMatch->save();
+
+        // Keep the parent Video's display title in sync with the match title
+        // so the match page header, share metadata, and search results all
+        // reflect the edited value.
+        if ($sportsMatch->video && $sportsMatch->video->title !== $sportsMatch->title) {
+            $sportsMatch->video->title = $sportsMatch->title;
+            $sportsMatch->video->save();
+        }
+
+        if ($sportsMatch->video) {
+            // Synchronous re-render on edit: guarantees the fresh VS card
+            // exists at the new versioned URL before the JSON response
+            // returns and the user can share the link. See renderMatchOgSync.
+            (new VideoController())->renderMatchOgSync($sportsMatch->video->fresh(['sportsMatch']));
+        }
+
+        return response()->json([
+            'ok'      => true,
+            'message' => 'Match updated.',
+            'match'   => $this->toEditPayload($sportsMatch),
+        ]);
+    }
+
+    /** Return the record as JSON so the modal can be re-opened for later editing. */
+    public function edit(SportsMatch $sportsMatch): JsonResponse
+    {
+        abort_unless($sportsMatch->user_id === Auth::id(), 403);
+
+        return response()->json(['match' => $this->toEditPayload($sportsMatch)]);
+    }
+
+    // ── Validation ──────────────────────────────────────────────────────────
+
+    private function rules(?SportsMatch $existing = null): array
+    {
+        $img = ['nullable', 'image', 'mimes:jpg,jpeg,png,webp', 'max:5120'];
+
+        return [
+            // Basic — only these are required for a first (draft) save
+            'video_id'          => ['required', 'integer', Rule::exists('videos', 'id')->where('user_id', Auth::id())],
+            'status'            => ['nullable', Rule::in(['draft', 'published'])],
+            'title'             => ['required', 'string', 'max:255'],
+            'event_name'        => ['nullable', 'string', 'max:255'],
+            'match_date'        => ['nullable', 'date'],
+            'match_time'        => ['nullable', 'date_format:H:i'],
+            'participant1_name' => ['nullable', 'string', 'max:255'],
+            'participant2_name' => ['nullable', 'string', 'max:255'],
+            'referee_name'      => ['nullable', 'string', 'max:255'],
+            // revealed later in edit
+            'sport'             => ['nullable', 'string', 'max:80'],
+            'match_type'        => ['nullable', 'string', 'max:80'],
+            'venue_name'        => ['nullable', 'string', 'max:255'],
+
+            // Optional grouped scalars (free-form, kept generic)
+            'competition'       => ['nullable', 'array'],
+            'participants'      => ['nullable', 'array'],
+            'extra_participants'=> ['nullable', 'array'],
+            'venue'             => ['nullable', 'array'],
+            'result'            => ['nullable', 'array'],
+            'reviews'           => ['nullable', 'array'],
+            'media'             => ['nullable', 'array'],
+
+            // Repeatable groups
+            'officials'           => ['nullable', 'array'],
+            'officials.*.role'    => ['nullable', 'string', 'max:80'],
+            'officials.*.name'    => ['nullable', 'string', 'max:255'],
+            'officials.*.photo'   => $img,
+
+            'segments'            => ['nullable', 'array'],
+            'segments.*.type'     => ['nullable', 'string', 'max:80'],
+            'segments.*.number'   => ['nullable', 'string', 'max:50'],
+            'segments.*.score'    => ['nullable', 'string', 'max:255'],
+            'segments.*.winner'   => ['nullable', 'string', 'max:255'],
+            'segments.*.notes'    => ['nullable', 'string', 'max:2000'],
+
+            'statistics'          => ['nullable', 'array'],
+            'statistics.*.name'   => ['nullable', 'string', 'max:120'],
+            'statistics.*.value'  => ['nullable', 'string', 'max:120'],
+            'statistics.*.owner'  => ['nullable', 'string', 'max:255'],
+            'statistics.*.notes'  => ['nullable', 'string', 'max:2000'],
+
+            // Single image fields
+            'media_participant1_photo' => $img,
+            'media_participant2_photo' => $img,
+            'media_referee_photo'      => $img,
+            'media_club1_logo'         => $img,
+            'media_club2_logo'         => $img,
+            'media_event_poster'       => $img,
+        ];
+    }
+
+    // ── Mapping helpers ─────────────────────────────────────────────────────
+
+    private function fillFromRequest(SportsMatch $match, Request $request, array $data): void
+    {
+        $match->video_id          = $data['video_id'];
+        $match->status            = $data['status'] ?? 'draft';
+        $match->title             = $data['title'];
+        $match->event_name        = $data['event_name'] ?? null;
+        $match->match_date        = $data['match_date'] ?? null;
+        $match->match_time        = $data['match_time'] ?? null;
+        $match->participant1_name = $data['participant1_name'] ?? null;
+        $match->participant2_name = $data['participant2_name'] ?? null;
+        $match->referee_name      = $data['referee_name'] ?? null;
+        $match->sport             = $data['sport'] ?? null;
+        $match->match_type        = $data['match_type'] ?? null;
+        $match->venue_name        = $data['venue_name'] ?? null;
+
+        // Optional scalar groups — keep only non-empty values, drop the JSON if empty.
+        $match->competition = $this->clean($request->input('competition', []));
+        $match->venue       = $this->clean($request->input('venue', []));
+        $match->result      = $this->clean($request->input('result', []));
+        $match->reviews     = $this->clean($request->input('reviews', []));
+
+        // Participants details + any extra participants in one generic structure.
+        $participants = $this->clean($request->input('participants', []));
+        $extra = collect($request->input('extra_participants', []))
+            ->map(fn ($p) => $this->clean($p))
+            ->filter()
+            ->values()
+            ->all();
+        if (! empty($extra)) $participants['extra'] = $extra;
+        $match->participants = empty($participants) ? null : $participants;
+
+        // Repeatable text groups (officials are built in handleImages() since they carry photos).
+        $match->segments   = $this->cleanRows($request->input('segments', []));
+        $match->statistics = $this->cleanRows($request->input('statistics', []));
+
+        // Media text fields (caption/alt/credit/public). Preserve existing image
+        // paths already on the record; handleImages() overwrites any replaced ones.
+        $existingMedia = $match->media ?? [];
+        // clean() returns null when the array is entirely empty — coerce back to []
+        // so array_merge() doesn't blow up on PHP 8's stricter type checking.
+        $mediaText = $this->clean($request->input('media', [])) ?? [];
+        if (isset($mediaText['public'])) {
+            $mediaText['public'] = filter_var($mediaText['public'], FILTER_VALIDATE_BOOLEAN);
+        }
+        $imagePaths = array_intersect_key($existingMedia, array_flip(self::IMAGE_FIELDS));
+        $merged = array_merge($imagePaths, $mediaText);
+        $match->media = empty($merged) ? null : $merged;
+    }
+
+    /** Strip empty values from a flat associative array; return null if nothing left. */
+    private function clean(?array $arr): ?array
+    {
+        if (! is_array($arr)) return null;
+        $out = array_filter($arr, fn ($v) => $v !== null && $v !== '' && $v !== []);
+        return empty($out) ? null : $out;
+    }
+
+    /** Clean a list of repeatable rows, dropping rows that are entirely empty. */
+    private function cleanRows(?array $rows): ?array
+    {
+        if (! is_array($rows)) return null;
+        $out = [];
+        foreach ($rows as $row) {
+            if (! is_array($row)) continue;
+            // photo (file) is handled separately; drop transient hidden keys here
+            unset($row['photo']);
+            $clean = $this->clean($row);
+            if ($clean) $out[] = $clean;
+        }
+        return empty($out) ? null : $out;
+    }
+
+    // ── Image handling ──────────────────────────────────────────────────────
+
+    private function handleImages(SportsMatch $match, Request $request, NasSyncService $nas): void
+    {
+        $slug  = $nas->userSlug($match->user ?: Auth::user());
+        $media = $match->media ?? [];
+
+        // Named single images
+        foreach (self::IMAGE_FIELDS as $input => $key) {
+            if ($request->hasFile($input)) {
+                $media[$key] = $this->storeImage($request->file($input), $slug, $match->id, $key, $nas);
+            }
+        }
+        $match->media = empty($media) ? null : $media;
+
+        // Officials — built from raw input so file inputs align by index. The
+        // modal renumbers rows to contiguous indices before submit. A new photo
+        // file replaces the existing one; otherwise the existing path is kept.
+        $officials = [];
+        foreach (array_values($request->input('officials', [])) as $i => $row) {
+            if (! is_array($row)) continue;
+            $entry = [];
+            if (! empty($row['role'])) $entry['role'] = $row['role'];
+            if (! empty($row['name'])) $entry['name'] = $row['name'];
+            if ($request->hasFile("officials.$i.photo")) {
+                $entry['photo'] = $this->storeImage(
+                    $request->file("officials.$i.photo"), $slug, $match->id, "official-$i", $nas
+                );
+            } elseif (! empty($row['photo_existing'])) {
+                $entry['photo'] = $row['photo_existing'];
+            }
+            if (! empty($entry)) $officials[] = $entry;
+        }
+        $match->officials = empty($officials) ? null : $officials;
+    }
+
+    /**
+     * Write one uploaded image to the canonical NAS path
+     * (users/{slug}/sports/{matchId}/{key}.{ext}) and return that relative path.
+     */
+    private function storeImage(UploadedFile $file, string $slug, int $matchId, string $key, NasSyncService $nas): string
+    {
+        $ext = strtolower($file->getClientOriginalExtension() ?: 'jpg');
+        $rel = "users/{$slug}/sports/{$matchId}/{$key}.{$ext}";
+        $localAbs = storage_path('app/' . $rel);
+
+        @mkdir(dirname($localAbs), 0755, true);
+        $file->move(dirname($localAbs), basename($localAbs));
+
+        // Push to NAS and drop the local copy when the NAS is reachable.
+        if ($nas->isEnabled()) {
+            $nas->mkdirp(dirname($rel));
+            if ($nas->putFile($localAbs, $rel)) {
+                @unlink($localAbs);
+            }
+        }
+
+        return $rel;
+    }
+
+    /** Shape the record for the edit modal (resolves image paths to URLs). */
+    private function toEditPayload(SportsMatch $match): array
+    {
+        $media = $match->media ?? [];
+        $mediaUrls = [];
+        // Key the URLs by the form input name (e.g. media_participant1_photo) so the
+        // modal can match each preview to its field via [data-img].
+        foreach (self::IMAGE_FIELDS as $input => $key) {
+            if (! empty($media[$key])) {
+                $mediaUrls[$input] = route('media.sports-image', $media[$key]);
+            }
+        }
+
+        $officials = $match->officials ?? [];
+        foreach ($officials as &$o) {
+            if (! empty($o['photo'])) $o['photo_url'] = route('media.sports-image', $o['photo']);
+        }
+        unset($o);
+
+        return [
+            'id'                => $match->id,
+            'video_id'          => $match->video_id,
+            'video_title'       => optional($match->video)->title,
+            'status'            => $match->status,
+            'sport'             => $match->sport,
+            'title'             => $match->title,
+            'event_name'        => $match->event_name,
+            'match_type'        => $match->match_type,
+            'match_date'        => optional($match->match_date)->format('Y-m-d'),
+            'match_time'        => $match->match_time ? substr($match->match_time, 0, 5) : null,
+            'participant1_name' => $match->participant1_name,
+            'participant2_name' => $match->participant2_name,
+            'referee_name'      => $match->referee_name,
+            'venue_name'        => $match->venue_name,
+            'competition'       => $match->competition,
+            'participants'      => $match->participants,
+            'venue'             => $match->venue,
+            'result'            => $match->result,
+            'reviews'           => $match->reviews,
+            'media'             => $media,
+            'media_urls'        => $mediaUrls,
+            'officials'         => $officials,
+            'segments'          => $match->segments,
+            'statistics'        => $match->statistics,
+        ];
+    }
+}

app/Http/Controllers/StudioController.php

@@ -0,0 +1,98 @@
+<?php
+
+namespace App\Http\Controllers;
+
+use App\Models\Video;
+use Illuminate\Http\Request;
+use Illuminate\Support\Facades\Auth;
+
+/**
+ * Creator studio — the content management surface YouTube calls "YouTube
+ * Studio". A skeleton for now: a filterable table of the signed-in user's
+ * videos plus a bulk visibility change endpoint. Analytics, stepped upload
+ * and schedule are future work.
+ */
+class StudioController extends Controller
+{
+    public function __construct()
+    {
+        $this->middleware('auth');
+    }
+
+    /**
+     * The studio dashboard — defaults to the content tab.
+     */
+    public function index(Request $request)
+    {
+        $user   = Auth::user();
+        $filter = $request->get('filter', 'all');
+
+        $query = Video::where('user_id', $user->id)->latest();
+
+        switch ($filter) {
+            case 'public':    $query->where('visibility', 'public'); break;
+            case 'unlisted':  $query->where('visibility', 'unlisted'); break;
+            case 'private':   $query->where('visibility', 'private'); break;
+            case 'shorts':    $query->where('is_shorts', true); break;
+            case 'draft':     $query->whereIn('status', ['pending', 'processing', 'failed']); break;
+        }
+
+        $videos = $query->paginate(24)->withQueryString();
+
+        // Headline numbers for the top bar.
+        $totals = [
+            'total'       => Video::where('user_id', $user->id)->count(),
+            'public'      => Video::where('user_id', $user->id)->where('visibility', 'public')->count(),
+            'unlisted'    => Video::where('user_id', $user->id)->where('visibility', 'unlisted')->count(),
+            'private'     => Video::where('user_id', $user->id)->where('visibility', 'private')->count(),
+            'processing'  => Video::where('user_id', $user->id)->whereIn('status', ['pending', 'processing'])->count(),
+            'failed'      => Video::where('user_id', $user->id)->where('status', 'failed')->count(),
+            'total_views' => \DB::table('video_views')
+                ->whereIn('video_id', Video::where('user_id', $user->id)->pluck('id'))
+                ->count(),
+        ];
+
+        return view('studio.index', [
+            'videos' => $videos,
+            'filter' => $filter,
+            'totals' => $totals,
+        ]);
+    }
+
+    /**
+     * Bulk visibility change. POSTs { video_ids: [...], visibility: '...' }.
+     * Guards against setting visibility on videos the user doesn't own, so a
+     * crafted request can't flip anyone else's content.
+     */
+    public function bulkVisibility(Request $request)
+    {
+        $request->validate([
+            'video_ids'   => ['required', 'array', 'min:1'],
+            'video_ids.*' => ['integer'],
+            'visibility'  => ['required', 'in:public,unlisted,private'],
+        ]);
+
+        $updated = Video::whereIn('id', $request->video_ids)
+            ->where('user_id', Auth::id())
+            ->update(['visibility' => $request->visibility]);
+
+        return response()->json(['updated' => $updated]);
+    }
+
+    /**
+     * Bulk delete. Same owner-only guard as above.
+     */
+    public function bulkDelete(Request $request)
+    {
+        $request->validate([
+            'video_ids'   => ['required', 'array', 'min:1'],
+            'video_ids.*' => ['integer'],
+        ]);
+
+        $deleted = Video::whereIn('id', $request->video_ids)
+            ->where('user_id', Auth::id())
+            ->delete();
+
+        return response()->json(['deleted' => $deleted]);
+    }
+}

app/Http/Controllers/SuperAdminController.php

@@ -188,16 +188,27 @@ class SuperAdminController extends Controller
         $recentVideos = Video::with('user')->latest()->take(5)->get();
 
         // ── Storage ───────────────────────────────────────────────
-        $disk = Storage::disk('public');
+        // NAS is the primary store; walking the local disk here would miss
+        // every file that's been pushed to NAS and purged locally. We use
+        // the DB-captured file sizes instead: videos.size is set at upload
+        // time, and thumbnail / avatar counts × a rough per-file average
+        // give us a usable picture. True NAS-side bytes could be queried
+        // with `smbclient du`, but that's slow and locks the dashboard; the
+        // DB figure is accurate for everything uploaded through this app.
+        $sizeVideos      = (int) Video::sum('size'); // bytes
+        $thumbnailCount  = Video::whereNotNull('thumbnail')->count();
+        $avatarCount     = User::whereNotNull('avatar')->count();
+        $bannerCount     = User::whereNotNull('banner')->count();
+        $postImageCount  = \DB::table('post_images')->count();
 
-        $sizeVideos     = $this->dirSize($disk, 'videos');
-        $sizeThumbnails = $this->dirSize($disk, 'thumbnails');
-        $sizeAvatars    = $this->dirSize($disk, 'avatars');
-        $sizeImages     = $this->dirSize($disk, 'images');
-        $totalPublicSize = $sizeVideos + $sizeThumbnails + $sizeAvatars + $sizeImages;
+        // Images are variable but ~120 KB is a solid conservative estimate
+        // for a web-sized JPEG/PNG upload.
+        $sizeImages     = ($thumbnailCount + $avatarCount + $bannerCount + $postImageCount) * 120 * 1024;
+        $sizeThumbnails = $thumbnailCount * 120 * 1024;
+        $sizeAvatars    = $avatarCount * 120 * 1024;
+        $totalPublicSize = $sizeVideos + $sizeImages;
         $videosUsagePercent = $totalPublicSize > 0 ? round(($sizeVideos / $totalPublicSize) * 100, 1) : 0;
 
-        // Convert to MB
         $toMb = fn($b) => round($b / 1024 / 1024, 1);
         $storage = [
             'videos'     => $toMb($sizeVideos),
@@ -506,7 +517,7 @@ class SuperAdminController extends Controller
         foreach ($uniqueViewers as $viewer) {
             if (!$viewer->country) continue;
             if (!isset($countryMap[$viewer->country])) {
-                $countryMap[$viewer->country] = ['country' => $viewer->country, 'country_name' => $viewer->country_name, 'total' => 0];
+                $countryMap[$viewer->country] = ['country' => $viewer->country, 'country_name' => $viewer->country_name ?: \App\Data\Countries::name($viewer->country), 'total' => 0];
             }
             $countryMap[$viewer->country]['total']++;
         }
@@ -772,7 +783,7 @@ class SuperAdminController extends Controller
                     ->groupBy('users.id', 'users.name', 'users.avatar')
                     ->orderByDesc('video_count')->take($limit)->get();
                 return response()->json(['type' => 'uploaders', 'items' => $items->map(fn($u) => [
-                    'avatar' => $u->avatar ? asset('storage/avatars/'.$u->avatar) : 'https://i.pravatar.cc/40?u='.$u->id,
+                    'avatar' => $u->avatar ? asset('storage/avatars/'.$u->avatar) : asset('images/default-avatar.svg'),
                     'name'   => $u->name,
                     'videos' => $u->video_count,
                     'views'  => $u->total_views,
@@ -846,23 +857,25 @@ class SuperAdminController extends Controller
     public function settings()
     {
         $settings = [
-            'gpu_enabled'      => Setting::get('gpu_enabled',      'true'),
-            'gpu_device'       => Setting::get('gpu_device',       '0'),
-            'gpu_encoder'      => Setting::get('gpu_encoder',      'h264_nvenc'),
-            'gpu_hwaccel'      => Setting::get('gpu_hwaccel',      'cuda'),
-            'gpu_preset'       => Setting::get('gpu_preset',       'p4'),
-            'ffmpeg_binary'    => Setting::get('ffmpeg_binary',    config('ffmpeg.ffmpeg', '/usr/bin/ffmpeg')),
-            'nas_sync_enabled' => Setting::get('nas_sync_enabled', 'false'),
+            'llm_enabled'         => Setting::get('llm_enabled',         'false'),
+            'llm_clean_lyrics'    => Setting::get('llm_clean_lyrics',    'true'),
+            'llm_decorate_lyrics' => Setting::get('llm_decorate_lyrics', 'false'),
+            'llm_providers'       => json_decode((string) Setting::get('llm_providers', '[]'), true) ?: [],
+            'llm_active_id'       => (string) Setting::get('llm_active_id', ''),
         ];
 
-        $gpus       = $this->probeGpus();
-        $nvencWorks = $this->probeNvenc();
-
-        return view('admin.settings', compact('settings', 'gpus', 'nvencWorks'));
+        return view('admin.settings', compact('settings'));
     }
 
+    /**
+     * Settings save handler — accepts partial submissions from any of the
+     * separated admin pages (GPU, NAS, Backup, AI/LLM). Only updates the keys
+     * that appear in the request.
+     */
     public function updateSettings(Request $request)
     {
+        // ── GPU section ──────────────────────────────────────────────────────
+        if ($request->has('gpu_enabled')) {
             $request->validate([
                 'gpu_enabled'   => 'required|in:true,false',
                 'gpu_device'    => 'required|integer|min:0|max:15',
@@ -883,18 +896,233 @@ class SuperAdminController extends Controller
             Setting::set('gpu_hwaccel',   $request->gpu_hwaccel);
             Setting::set('gpu_preset',    $request->gpu_preset);
             Setting::set('ffmpeg_binary', $binary);
-
-        // GPU config changed — drop the cached health-check so the next encode re-probes.
             Setting::flushGpuProbe();
+        }
+
+        // ── Lyrics pipeline section ──────────────────────────────────────────
+        if ($request->has('lyrics_section')) {
+            foreach ([
+                'lyrics_enabled',                 // master switch
+                'lyrics_use_description',         // align to description text
+                'lyrics_vad_enabled',             // Silero VAD filter
+                'lyrics_vocal_region_gapfill',    // snap gap-filled lines to vocal regions
+                'lyrics_demucs_enabled',          // vocal isolation (Demucs)
+                'lyrics_llm_decorate',            // post-bake emojis via LLM
+            ] as $k) {
+                Setting::set($k, $request->input($k, 'false') === 'true' ? 'true' : 'false');
+            }
+        }
+
+        // ── AI / LLM section ─────────────────────────────────────────────────
+        if ($request->has('llm_section')) {
+            Setting::set('llm_enabled',         $request->input('llm_enabled', 'false') === 'true' ? 'true' : 'false');
+            Setting::set('llm_clean_lyrics',    $request->input('llm_clean_lyrics', 'false') === 'true' ? 'true' : 'false');
+            Setting::set('llm_decorate_lyrics', $request->input('llm_decorate_lyrics', 'false') === 'true' ? 'true' : 'false');
+            $this->saveLlmProviders($request);
+        }
 
         return back()->with('success', 'Settings saved.');
     }
 
+    /**
+     * Probe an LLM provider endpoint: verify the connection and list
+     * available models. Used by the AI / LLM settings page.
+     *
+     * Accepts kind / endpoint / api_key from the form, plus an optional
+     * provider id so we can fall back to the saved key when the admin
+     * left the password field blank (placeholder ••••••••).
+     */
+    public function llmProviderTest(Request $request)
+    {
+        $kind     = (string) $request->input('kind', 'ollama');
+        $endpoint = trim((string) $request->input('endpoint', '')) ?: self::defaultEndpoint($kind);
+        $endpoint = rtrim($endpoint, '/');
+        $apiKey   = (string) $request->input('api_key', '');
+        $id       = (string) $request->input('id', '');
+
+        if ($apiKey === '' && $id !== '') {
+            $providers = json_decode((string) Setting::get('llm_providers', '[]'), true) ?: [];
+            foreach ($providers as $p) {
+                if (($p['id'] ?? '') === $id) {
+                    $apiKey = (string) ($p['api_key'] ?? '');
+                    break;
+                }
+            }
+        }
+
+        if (! in_array($kind, ['ollama', 'anthropic', 'openai'], true)) {
+            return response()->json(['ok' => false, 'message' => 'Unknown provider kind.'], 422);
+        }
+
+        if ($kind !== 'ollama' && $apiKey === '') {
+            return response()->json(['ok' => false, 'message' => 'API key required for ' . $kind . '.'], 422);
+        }
+
+        try {
+            $models = match ($kind) {
+                'ollama'    => $this->fetchOllamaModels($endpoint),
+                'anthropic' => $this->fetchAnthropicModels($endpoint, $apiKey),
+                'openai'    => $this->fetchOpenAIModels($endpoint, $apiKey),
+            };
+        } catch (\Throwable $e) {
+            return response()->json(['ok' => false, 'message' => $e->getMessage()]);
+        }
+
+        sort($models, SORT_NATURAL | SORT_FLAG_CASE);
+        return response()->json([
+            'ok'     => true,
+            'count'  => count($models),
+            'models' => $models,
+        ]);
+    }
+
+    private function fetchOllamaModels(string $endpoint): array
+    {
+        $resp = \Illuminate\Support\Facades\Http::timeout(10)->acceptJson()->get($endpoint . '/api/tags');
+        if (! $resp->successful()) {
+            throw new \RuntimeException('Ollama returned HTTP ' . $resp->status());
+        }
+        $j = $resp->json();
+        return array_values(array_filter(array_map(
+            fn ($m) => (string) ($m['name'] ?? ''),
+            $j['models'] ?? []
+        )));
+    }
+
+    private function fetchAnthropicModels(string $endpoint, string $apiKey): array
+    {
+        $resp = \Illuminate\Support\Facades\Http::timeout(15)->withHeaders([
+            'x-api-key'         => $apiKey,
+            'anthropic-version' => '2023-06-01',
+        ])->get($endpoint . '/v1/models');
+        if (! $resp->successful()) {
+            $body = $resp->json();
+            throw new \RuntimeException($body['error']['message'] ?? ('HTTP ' . $resp->status()));
+        }
+        $j = $resp->json();
+        return array_values(array_filter(array_map(
+            fn ($m) => (string) ($m['id'] ?? ''),
+            $j['data'] ?? []
+        )));
+    }
+
+    private function fetchOpenAIModels(string $endpoint, string $apiKey): array
+    {
+        $resp = \Illuminate\Support\Facades\Http::timeout(15)
+            ->withToken($apiKey)->acceptJson()
+            ->get($endpoint . '/v1/models');
+        if (! $resp->successful()) {
+            $body = $resp->json();
+            throw new \RuntimeException($body['error']['message'] ?? ('HTTP ' . $resp->status()));
+        }
+        $j = $resp->json();
+        return array_values(array_filter(array_map(
+            fn ($m) => (string) ($m['id'] ?? ''),
+            $j['data'] ?? []
+        )));
+    }
+
+    public function lyrics()
+    {
+        $settings = [
+            'lyrics_enabled'              => Setting::get('lyrics_enabled',              'true'),
+            'lyrics_use_description'      => Setting::get('lyrics_use_description',      'true'),
+            'lyrics_vad_enabled'          => Setting::get('lyrics_vad_enabled',          'true'),
+            'lyrics_vocal_region_gapfill' => Setting::get('lyrics_vocal_region_gapfill', 'true'),
+            'lyrics_demucs_enabled'       => Setting::get('lyrics_demucs_enabled',       'false'),
+            'lyrics_llm_decorate'         => Setting::get('lyrics_llm_decorate',         Setting::get('llm_decorate_lyrics', 'false')),
+        ];
+        return view('admin.lyrics', compact('settings'));
+    }
+
+    public function gpu()
+    {
+        $settings = [
+            'gpu_enabled'   => Setting::get('gpu_enabled',   'true'),
+            'gpu_device'    => Setting::get('gpu_device',    '0'),
+            'gpu_encoder'   => Setting::get('gpu_encoder',   'h264_nvenc'),
+            'gpu_hwaccel'   => Setting::get('gpu_hwaccel',   'cuda'),
+            'gpu_preset'    => Setting::get('gpu_preset',    'p4'),
+            'ffmpeg_binary' => Setting::get('ffmpeg_binary', config('ffmpeg.ffmpeg', '/usr/bin/ffmpeg')),
+        ];
+
+        $gpus       = $this->probeGpus();
+        $nvencWorks = $this->probeNvenc();
+
+        return view('admin.gpu', compact('settings', 'gpus', 'nvencWorks'));
+    }
+
+    public function backup()
+    {
+        return view('admin.backup');
+    }
+
     public function detectGpu()
     {
         return response()->json(['gpus' => $this->probeGpus()]);
     }
 
+    /**
+     * Persist the LLM provider list from the multi-provider form. Each row
+     * carries id / name / kind (ollama|anthropic|openai) / endpoint / model /
+     * api_key. An empty api_key means "keep the previously stored value" so the
+     * admin doesn't have to retype it on every save.
+     */
+    private function saveLlmProviders(Request $request): void
+    {
+        $existing = collect(json_decode((string) Setting::get('llm_providers', '[]'), true) ?: [])
+            ->keyBy(fn ($p) => $p['id'] ?? '');
+
+        $kinds = ['ollama', 'anthropic', 'openai'];
+        $rows  = (array) $request->input('providers', []);
+        $out   = [];
+
+        foreach ($rows as $row) {
+            $name = trim((string) ($row['name'] ?? ''));
+            $kind = (string) ($row['kind'] ?? 'ollama');
+            if (! in_array($kind, $kinds, true)) $kind = 'ollama';
+            if ($name === '') continue;
+
+            $id        = (string) ($row['id'] ?? '') ?: (string) \Illuminate\Support\Str::uuid();
+            $endpoint  = trim((string) ($row['endpoint'] ?? '')) ?: self::defaultEndpoint($kind);
+            $model     = trim((string) ($row['model'] ?? ''));
+            $apiKeyIn  = (string) ($row['api_key'] ?? '');
+            // Blank input → keep the previously-stored key for this id (admin
+            // didn't retype it). Non-blank → use the new value verbatim.
+            $apiKey = $apiKeyIn !== '' ? $apiKeyIn : (string) ($existing[$id]['api_key'] ?? '');
+
+            $out[] = [
+                'id'       => $id,
+                'name'     => $name,
+                'kind'     => $kind,
+                'endpoint' => $endpoint,
+                'model'    => $model,
+                'api_key'  => $apiKey,
+            ];
+        }
+
+        Setting::set('llm_providers', json_encode($out, JSON_UNESCAPED_UNICODE));
+
+        $activeId = trim((string) $request->input('llm_active_id', ''));
+        $validIds = array_column($out, 'id');
+        if ($activeId !== '' && in_array($activeId, $validIds, true)) {
+            Setting::set('llm_active_id', $activeId);
+        } elseif (count($validIds) === 1) {
+            Setting::set('llm_active_id', $validIds[0]);
+        } elseif (! in_array((string) Setting::get('llm_active_id', ''), $validIds, true)) {
+            Setting::set('llm_active_id', '');
+        }
+    }
+
+    private static function defaultEndpoint(string $kind): string
+    {
+        return match ($kind) {
+            'anthropic' => 'https://api.anthropic.com',
+            'openai'    => 'https://api.openai.com',
+            default     => 'http://localhost:11434',
+        };
+    }
+
     private function probeGpus(): array
     {
         $gpus = [];
@@ -935,7 +1163,10 @@ class SuperAdminController extends Controller
     public function nasStorage()
     {
         $nodes = config('nas-file-manager.schema', []);
-        return view('admin.nas-storage', compact('nodes'));
+        $settings = [
+            'nas_sync_enabled' => Setting::get('nas_sync_enabled', 'false'),
+        ];
+        return view('admin.nas-storage', compact('nodes', 'settings'));
     }
 
     public function nasDelete(Request $request)

app/Http/Controllers/UserController.php

@@ -18,7 +18,34 @@ class UserController extends Controller
 {
     public function __construct()
     {
-        $this->middleware('auth')->except(['channel']);
+        $this->middleware('auth')->except(['channel', 'channelVideosMore']);
+    }
+
+    // Typeahead search for members (used by the "Share to member" picker)
+    public function searchUsers(Request $request)
+    {
+        $q = trim((string) $request->query('q', ''));
+        if (mb_strlen($q) < 1) {
+            return response()->json(['users' => []]);
+        }
+
+        $users = User::where('id', '!=', Auth::id())
+            ->where(function ($w) use ($q) {
+                $w->where('name', 'like', "%{$q}%")
+                  ->orWhere('username', 'like', "%{$q}%");
+            })
+            ->orderBy('name')
+            ->limit(8)
+            ->get(['id', 'name', 'username', 'avatar']);
+
+        return response()->json([
+            'users' => $users->map(fn ($u) => [
+                'id'      => $u->id,
+                'name'    => $u->name,
+                'channel' => $u->channel,
+                'avatar'  => $u->avatar_url,
+            ]),
+        ]);
     }
 
     // Profile page - personal overview for the authenticated user
@@ -219,7 +246,14 @@ class UserController extends Controller
 
         switch ($sort) {
             case 'popular':
-                $baseQuery->withCount('viewers')->orderByDesc('viewers_count');
+                // Views first, likes as the tiebreak, created_at as the final
+                // tiebreak so two videos with the same view+like counts don't
+                // flip order between page loads.
+                $baseQuery
+                    ->withCount(['viewers as viewers_count', 'likes as likes_count'])
+                    ->orderByDesc('viewers_count')
+                    ->orderByDesc('likes_count')
+                    ->latest();
                 break;
             case 'oldest':
                 $baseQuery->oldest();
@@ -235,8 +269,16 @@ class UserController extends Controller
             ? $user->playlists()->with(['videos' => $withFirstVideo])->orderBy('created_at', 'desc')->get()
             : $user->playlists()->public()->where('is_default', false)->with(['videos' => $withFirstVideo])->orderBy('created_at', 'desc')->get();
 
+        // Header stats must not leak unlisted/private video view counts to
+        // visitors. Owners (and ?preview=1 is handled above by setting
+        // $isOwner=false) see totals across every video they uploaded;
+        // visitors see totals across public videos only — matching what
+        // the videos count row already shows.
+        $viewVideoIds = $isOwner
+            ? $user->videos()->pluck('id')
+            : Video::public()->where('user_id', $user->id)->pluck('id');
         $totalViews = \DB::table('video_views')
-            ->whereIn('video_id', $user->videos()->pluck('id'))
+            ->whereIn('video_id', $viewVideoIds)
             ->count();
 
         // Filter social links by visibility for the current viewer
@@ -283,29 +325,41 @@ class UserController extends Controller
     }
 
     // Watch history
-    public function history()
+    public function history(Request $request)
     {
         $user = Auth::user();
 
-        // Get videos the user has watched, ordered by most recently watched
-        // Include private videos since they are the user's own
-        $videoIds = \DB::table('video_views')
-            ->where('user_id', $user->id)
-            ->orderBy('watched_at', 'desc')
-            ->pluck('video_id')
-            ->unique();
-
-        $videos = Video::whereIn('id', $videoIds)
+        // Latest-first by watched_at. Paginate at the join so a user who
+        // has watched tens of thousands of videos doesn't pull every row
+        // into memory on each page load. Fetch the videos keyed by latest
+        // view so sort order is deterministic even when the same video has
+        // been watched more than once.
+        //
+        // Each history row is one (video_views + videos) pair, with the
+        // uniqueness constraint deferred to presentation: duplicates per
+        // video are expected (one row per view event) and the UI collapses
+        // them with view-count badges.
+        $per = 48;
+        $rows = \DB::table('video_views')
+            ->join('videos', 'videos.id', '=', 'video_views.video_id')
+            ->where('video_views.user_id', $user->id)
             ->where(function ($q) use ($user) {
-                $q->where('visibility', '!=', 'private')
-                    ->orWhere('user_id', $user->id);
+                $q->where('videos.visibility', '!=', 'private')
+                    ->orWhere('videos.user_id', $user->id);
             })
-            ->get()
-            ->sortBy(function ($video) use ($videoIds) {
-                return $videoIds->search($video->id);
-            });
+            ->orderBy('video_views.watched_at', 'desc')
+            ->select('videos.id as id', 'video_views.watched_at')
+            ->simplePaginate($per);
 
-        return view('user.history', compact('videos'));
+        $videoIds = collect($rows->items())->pluck('id')->unique();
+        $videoMap = Video::whereIn('id', $videoIds)->get()->keyBy('id');
+        $videos   = collect($rows->items())
+            ->map(fn ($r) => $videoMap->get($r->id))
+            ->filter()
+            ->unique('id') // collapse re-watches of the same video on this page
+            ->values();
+
+        return view('user.history', ['videos' => $videos, 'paginator' => $rows]);
     }
 
     // Clear watch history
@@ -318,18 +372,82 @@ class UserController extends Controller
         return redirect()->route('history')->with('toast_success', 'Watch history cleared.');
     }
 
+    /**
+     * JSON endpoint powering the "Load more" button on the channel Videos
+     * tab. Takes a username + optional cursor and returns a page of
+     * server-rendered video cards + next cursor. Reuses the cursorPaginate
+     * pattern Phase 2 established for the home feed.
+     */
+    public function channelVideosMore(Request $request, string $username)
+    {
+        $owner  = User::where('username', $username)->firstOrFail();
+        $viewer = Auth::user();
+        $isOwner = $viewer && $viewer->id === $owner->id;
+
+        $query = $isOwner
+            ? Video::where('user_id', $owner->id)
+            : Video::public()->where('user_id', $owner->id);
+
+        $paginator = $query->where('is_shorts', false)
+            ->latest('id')
+            ->cursorPaginate(24);
+
+        $html = '';
+        foreach ($paginator->items() as $video) {
+            $html .= view('components.video-card', ['video' => $video, 'hideChannelInfo' => true])->render();
+        }
+
+        return response()->json([
+            'items'       => $html,
+            'next_cursor' => optional($paginator->nextCursor())->encode(),
+            'has_more'    => $paginator->hasMorePages(),
+        ]);
+    }
+
+    /**
+     * Subscriptions feed — the public videos uploaded by every channel the
+     * viewer is subscribed to, newest first. Replaces the dead href="#" that
+     * the sidebar's "Subscriptions" item used to point at. Thin on purpose:
+     * reuses the existing video-card component via the videos/index view.
+     */
+    public function subscriptionsFeed()
+    {
+        $me = Auth::user();
+        $channelIds = $me->subscriptions()->pluck('users.id');
+
+        $videos = Video::public()
+            ->whereIn('user_id', $channelIds)
+            ->notShorts()
+            ->latest()
+            ->limit(60)
+            ->get();
+
+        return view('videos.index', [
+            'videos'    => $videos,
+            'filter'    => 'subscriptions',
+            'langChips' => [],
+            'shorts'    => collect(),
+            'matches'   => collect(),
+            'playlists' => collect(),
+        ]);
+    }
+
     // Liked videos
     public function liked()
     {
         $user = Auth::user();
-        // Include private videos in liked (user's own private videos)
+        // Include private videos in liked (user's own private videos).
+        // Cursor pagination matches the Phase 2 feed endpoints — stable
+        // across inserts (unlike ?page=N which can duplicate or skip rows
+        // when a new like lands between page fetches) and loads a bounded
+        // slice regardless of how many thousands of likes the user has.
         $videos = $user->likes()
             ->where(function ($q) use ($user) {
                 $q->where('visibility', '!=', 'private')
                     ->orWhere('videos.user_id', $user->id);
             })
-            ->latest()
-            ->paginate(12);
+            ->latest('videos.id')
+            ->cursorPaginate(24);
 
         return view('user.liked', compact('videos'));
     }
@@ -367,6 +485,9 @@ class UserController extends Controller
         } else {
             $video->likes()->attach($user->id);
             $liked = true;
+            // Toggling to like clears any existing dislike — mirrors YT's
+            // behavior where a video can be liked OR disliked, not both.
+            $video->dislikes()->detach($user->id);
             if ($video->user_id && $video->user_id !== $user->id) {
                 try { $video->user->notify(new VideoLikedNotification($video, $user)); } catch (\Throwable) {}
             }
@@ -374,11 +495,78 @@ class UserController extends Controller
 
         return response()->json([
             'liked'          => $liked,
+            'disliked'       => false, // was cleared above if we just liked, otherwise toggle didn't touch it
             'like_count'     => $video->like_count,
+            'dislike_count'  => $video->dislike_count,
         ]);
     }
 
-    public function toggleSubscribe(User $user)
+    // Toggle dislike (API). Mutually exclusive with the like state.
+    public function toggleDislike(Video $video)
+    {
+        $user = Auth::user();
+
+        if ($video->isDislikedBy($user)) {
+            $video->dislikes()->detach($user->id);
+            $disliked = false;
+        } else {
+            $video->dislikes()->attach($user->id);
+            $disliked = true;
+            // Clear any existing like.
+            $video->likes()->detach($user->id);
+        }
+
+        return response()->json([
+            'disliked'       => $disliked,
+            'liked'          => $video->isLikedBy($user), // guaranteed false here when disliked just became true
+            'like_count'     => $video->like_count,
+            'dislike_count'  => $video->dislike_count,
+        ]);
+    }
+
+    public function recordProfileVisit(Request $request, User $user)
+    {
+        // Don't record self-visits or repeated visits from the same person in the last 30 minutes
+        $visitorId = Auth::id();
+        $deviceId  = $request->cookie('_did');
+
+        if ($visitorId && $visitorId === $user->id) {
+            return response()->json(['ok' => true, 'skipped' => 'self']);
+        }
+
+        $sourceVideoId = $request->integer('source_video_id') ?: null;
+        if ($sourceVideoId && ! Video::whereKey($sourceVideoId)->exists()) {
+            $sourceVideoId = null;
+        }
+
+        $dedup = \App\Models\ProfileVisit::where('profile_user_id', $user->id)
+            ->where('created_at', '>=', now()->subMinutes(30))
+            ->when($visitorId, fn ($q) => $q->where('visitor_user_id', $visitorId))
+            ->when(! $visitorId && $deviceId, fn ($q) => $q->whereNull('visitor_user_id')->where('device_id', $deviceId))
+            ->when($sourceVideoId, fn ($q) => $q->where('source_video_id', $sourceVideoId))
+            ->exists();
+
+        if ($dedup) {
+            return response()->json(['ok' => true, 'skipped' => 'dedup']);
+        }
+
+        $ip  = $request->header('CF-Connecting-IP') ?? $request->header('X-Real-IP') ?? $request->ip();
+        $geo = \App\Services\GeoIpService::lookup($ip);
+
+        \App\Models\ProfileVisit::create([
+            'profile_user_id' => $user->id,
+            'visitor_user_id' => $visitorId,
+            'device_id'       => $deviceId,
+            'source_video_id' => $sourceVideoId,
+            'ip_address'      => $ip,
+            'country'         => $geo['country'] ?? null,
+            'created_at'      => now(),
+        ]);
+
+        return response()->json(['ok' => true]);
+    }
+
+    public function toggleSubscribe(Request $request, User $user)
     {
         $me = Auth::user();
 
@@ -390,7 +578,11 @@ class UserController extends Controller
             $me->subscriptions()->detach($user->id);
             $subscribed = false;
         } else {
-            $me->subscriptions()->attach($user->id);
+            $sourceVideoId = $request->integer('source_video_id') ?: null;
+            if ($sourceVideoId && ! \App\Models\Video::whereKey($sourceVideoId)->exists()) {
+                $sourceVideoId = null;
+            }
+            $me->subscriptions()->attach($user->id, ['source_video_id' => $sourceVideoId]);
             $subscribed = true;
             try { $user->notify(new NewSubscriberNotification($me)); } catch (\Throwable) {}
         }
@@ -492,14 +684,21 @@ class UserController extends Controller
             rename($tempPath, $destPath);
         }
 
-        $user->update(['avatar' => $relPath]);
+        // Bump updated_at even when $relPath is unchanged (avatar.png -> avatar.png)
+        // so avatar_url's ?v cache-buster changes and every page shows the new image.
+        $user->avatar = $relPath;
+        $user->updated_at = now();
+        $user->save();
 
         if ($nas->isEnabled() && file_exists($destPath)) {
             $nas->syncAvatar($user, $destPath);
             $nas->deleteLocalAvatar($user);
         }
 
-        return response()->json(['ok' => true]);
+        // Return the canonical media URL. The url from image.upload points at the
+        // temp file we just moved to NAS and deleted, so the client must use this
+        // instead — otherwise the avatar shows broken until the next page load.
+        return response()->json(['ok' => true, 'url' => route('media.avatar', $relPath)]);
     }
 
     public function updateBanner(Request $request)
@@ -526,13 +725,19 @@ class UserController extends Controller
             rename($tempPath, $destPath);
         }
 
-        $user->update(['banner' => $relPath]);
+        // Bump updated_at even when $relPath is unchanged so banner_url's ?v buster
+        // changes and the new banner shows everywhere (see updateAvatar).
+        $user->banner = $relPath;
+        $user->updated_at = now();
+        $user->save();
 
         if ($nas->isEnabled() && file_exists($destPath)) {
             $nas->syncCover($user, $destPath);
             $nas->deleteLocalBanner($user);
         }
 
-        return response()->json(['ok' => true]);
+        // Return the canonical media URL (see updateAvatar) so the client updates
+        // the banner in place instead of pointing at the deleted temp file.
+        return response()->json(['ok' => true, 'url' => route('media.banner', $relPath)]);
     }
 }

app/Http/Controllers/VideoMergeController.php

@@ -0,0 +1,98 @@
+<?php
+
+namespace App\Http\Controllers;
+
+use App\Models\Video;
+use App\Services\VideoMergeService;
+use Illuminate\Http\Request;
+use Illuminate\Support\Facades\Auth;
+
+class VideoMergeController extends Controller
+{
+    public function __construct(private VideoMergeService $merger) {}
+
+    /**
+     * List the current user's other music videos that $target can be merged with.
+     */
+    public function candidates(Request $request, Video $target)
+    {
+        $this->authorizeOwner($target);
+        if ($target->type !== 'music') {
+            return response()->json(['error' => 'Only music videos can be merged.'], 422);
+        }
+
+        $q = trim((string) $request->query('q', ''));
+        $query = Video::where('user_id', Auth::id())
+            ->where('type', 'music')
+            ->where('id', '!=', $target->id)
+            ->orderByDesc('created_at');
+        if ($q !== '') {
+            $query->where('title', 'like', '%' . $q . '%');
+        }
+        $items = $query->limit(30)->get(['id', 'title', 'thumbnail', 'created_at'])->map(function ($v) {
+            return [
+                'id'        => $v->getRouteKey(),
+                'title'     => $v->title,
+                'thumbnail' => $v->thumbnail_url,
+                'created'   => $v->created_at?->diffForHumans(),
+            ];
+        });
+
+        return response()->json(['items' => $items]);
+    }
+
+    public function preview(Video $target, Video $source)
+    {
+        $this->authorizeOwner($target);
+        $this->authorizeOwner($source);
+        if ($target->type !== 'music' || $source->type !== 'music') {
+            return response()->json(['error' => 'Only music videos can be merged.'], 422);
+        }
+        if ($target->id === $source->id) {
+            return response()->json(['error' => 'Cannot merge a video with itself.'], 422);
+        }
+
+        return response()->json([
+            'source' => [
+                'id'    => $source->getRouteKey(),
+                'title' => $source->title,
+                'thumb' => $source->thumbnail_url,
+            ],
+            'target' => [
+                'id'    => $target->getRouteKey(),
+                'title' => $target->title,
+                'thumb' => $target->thumbnail_url,
+            ],
+            'counts' => $this->merger->preview($source, $target),
+        ]);
+    }
+
+    public function merge(Request $request, Video $target, Video $source)
+    {
+        $this->authorizeOwner($target);
+        $this->authorizeOwner($source);
+
+        try {
+            $this->merger->merge($source, $target);
+        } catch (\Throwable $e) {
+            \Log::error('Video merge failed', [
+                'source' => $source->id,
+                'target' => $target->id,
+                'err'    => $e->getMessage(),
+            ]);
+            return response()->json(['error' => 'Merge failed: ' . $e->getMessage()], 500);
+        }
+
+        return response()->json([
+            'ok'       => true,
+            'redirect' => route('videos.show', $target),
+        ]);
+    }
+
+    private function authorizeOwner(Video $video): void
+    {
+        $user = Auth::user();
+        if (!$user) abort(401);
+        if ($user->id !== $video->user_id && !$user->isSuperAdmin()) abort(403);
+    }
+}

app/Jobs/CompressVideoJob.php

@@ -4,8 +4,6 @@ namespace App\Jobs;
 
 use App\Models\Setting;
 use App\Models\Video;
-use FFMpeg\FFMpeg;
-use FFMpeg\Format\Video\X264;
 use Illuminate\Support\Facades\Config;
 use Illuminate\Bus\Queueable;
 use Illuminate\Contracts\Queue\ShouldQueue;
@@ -13,7 +11,6 @@ use Illuminate\Foundation\Bus\Dispatchable;
 use Illuminate\Queue\InteractsWithQueue;
 use Illuminate\Queue\SerializesModels;
 use Illuminate\Support\Facades\Log;
-use Illuminate\Support\Facades\Storage;
 
 class CompressVideoJob implements ShouldQueue
 {
@@ -30,7 +27,6 @@ class CompressVideoJob implements ShouldQueue
     {
         $video = $this->video;
 
-        // Get original file path
         $originalPath = storage_path('app/' . $video->path);
 
         if (!file_exists($originalPath)) {
@@ -38,71 +34,87 @@ class CompressVideoJob implements ShouldQueue
             return;
         }
 
-        // Create compressed file alongside the original
         $compressedFilename = 'compressed_' . $video->filename;
         $compressedPath = dirname($originalPath) . '/' . $compressedFilename;
 
         try {
             $ffmpegConfig = Config::get('ffmpeg');
-            $ffmpeg = FFMpeg::create([
-                'ffmpeg.binaries'  => $ffmpegConfig['ffmpeg']  ?? '/usr/bin/ffmpeg',
-                'ffprobe.binaries' => $ffmpegConfig['ffprobe'] ?? '/usr/bin/ffprobe',
-                'timeout'          => $ffmpegConfig['timeout']  ?? 3600,
-            ]);
-            $ffmpegVideo = $ffmpeg->open($originalPath);
+            $ffmpegBin    = $ffmpegConfig['ffmpeg']  ?? '/usr/bin/ffmpeg';
+            $ffprobeBin   = $ffmpegConfig['ffprobe'] ?? '/usr/bin/ffprobe';
+
+            // Detect the source video codec. Browsers on Chrome/Firefox/Android can't
+            // decode HEVC (H.265/hev1/hvc1) — those sources must be replaced with H.264
+            // even if the transcode is larger, so downloads and MP4 fallback stay playable.
+            $srcCodec = '';
+            try {
+                $probeOut = [];
+                exec(escapeshellcmd($ffprobeBin) . ' -v error -select_streams v:0 -show_entries stream=codec_name -of csv=p=0 ' . escapeshellarg($originalPath), $probeOut);
+                $srcCodec = strtolower(trim($probeOut[0] ?? ''));
+            } catch (\Throwable $e) {}
+            $forceReplace = in_array($srcCodec, ['hevc', 'h265', 'hev1', 'hvc1'], true);
 
-            // Verify the GPU is actually reachable and able to encode before sending
-            // the file to it; otherwise fall back to CPU so the job never hangs.
             $gpuEnabled = Setting::gpuUsable();
-            $encoder    = Setting::gpuEncoder();
-            $preset     = Setting::gpuPreset();
+            $encoder    = Setting::gpuEncoder();  // h264_nvenc / libx264
+            $preset     = Setting::gpuPreset();   // p1–p7 for NVENC, fast/medium/slow for x264
             $device     = Setting::gpuDevice();
+            $hwaccel    = Setting::gpuHwaccel();
 
-            if ($gpuEnabled) {
-                $videoPasses = [
-                    "-c:v {$encoder}",
-                    "-preset {$preset}",
-                    '-rc vbr',
-                    '-cq 23',
-                    '-profile:v high',
-                    '-pix_fmt yuv420p',
-                    "-gpu {$device}",
-                ];
+            // Build ffmpeg command directly — php-ffmpeg's X264 format validator
+            // only accepts 'libx264' and throws on 'h264_nvenc'.
+            $cmd = [escapeshellcmd($ffmpegBin), '-y'];
+
+            if ($gpuEnabled && $hwaccel !== 'none') {
+                $cmd[] = "-hwaccel {$hwaccel}";
+                $cmd[] = "-hwaccel_device {$device}";
+            }
+
+            $cmd[] = '-i ' . escapeshellarg($originalPath);
+            $cmd[] = "-c:v {$encoder}";
+
+            if ($gpuEnabled && str_contains($encoder, 'nvenc')) {
+                $cmd[] = "-preset {$preset}";
+                $cmd[] = '-rc vbr';
+                $cmd[] = '-cq 23';
+                $cmd[] = "-gpu {$device}";
             } else {
-                $videoPasses = [
-                    '-c:v libx264',
-                    '-preset fast',
-                    '-crf 23',
-                    '-profile:v high',
-                    '-pix_fmt yuv420p',
-                ];
+                $cmd[] = "-preset {$preset}";
+                $cmd[] = '-crf 23';
             }
-            $audioPasses = ['-c:a aac', '-b:a 192k'];
 
-            $format = new X264('aac', $encoder);
-            foreach ($videoPasses as $pass) {
-                $format->addLegacyOption($pass);
-            }
-            foreach ($audioPasses as $pass) {
-                $format->addLegacyOption($pass);
-            }
-            $ffmpegVideo->save($format, $compressedPath);
+            $cmd[] = '-profile:v high';
+            $cmd[] = '-pix_fmt yuv420p';
+            $cmd[] = '-c:a aac';
+            $cmd[] = '-b:a 192k';
+            $cmd[] = '-movflags +faststart';
+            $cmd[] = escapeshellarg($compressedPath);
+
+            $fullCmd = implode(' ', $cmd) . ' 2>&1';
+
+            Log::info('CompressVideoJob: Starting', [
+                'video_id'  => $video->id,
+                'src_codec' => $srcCodec,
+                'encoder'   => $encoder,
+                'gpu'       => $gpuEnabled,
+            ]);
+
+            $output = [];
+            exec($fullCmd, $output, $exitCode);
+
+            if ($exitCode !== 0) {
+                $tail = implode("\n", array_slice($output, -30));
+                throw new \RuntimeException("FFmpeg exited {$exitCode}:\n{$tail}");
+            }
 
-            // Check if compressed file was created and is smaller
             if (file_exists($compressedPath)) {
                 $originalSize   = filesize($originalPath);
                 $compressedSize = filesize($compressedPath);
 
-                // Only use compressed file if it's smaller
-                if ($compressedSize < $originalSize) {
-                    // Delete original and rename compressed
+                if ($compressedSize < $originalSize || $forceReplace) {
                     unlink($originalPath);
                     rename($compressedPath, $originalPath);
 
-                    // Update video record
                     $video->update([
                         'size'      => $compressedSize,
-                        'filename' => $video->filename, // Keep same filename
                         'mime_type' => 'video/mp4',
                     ]);
 
@@ -110,26 +122,26 @@ class CompressVideoJob implements ShouldQueue
                         'video_id'        => $video->id,
                         'original_size'   => $originalSize,
                         'compressed_size' => $compressedSize,
-                        'saved' => round(($originalSize - $compressedSize) / $originalSize * 100) . '%',
+                        'saved'           => round(($originalSize - $compressedSize) / max(1, $originalSize) * 100) . '%',
                         'encoder'         => $encoder,
                         'gpu'             => $gpuEnabled,
+                        'src_codec'       => $srcCodec,
+                        'forced'          => $forceReplace && $compressedSize >= $originalSize,
                     ]);
                 } else {
-                    // Compressed file is larger, delete it
                     unlink($compressedPath);
-                    Log::info('CompressVideoJob: Compression made file larger, keeping original');
+                    Log::info('CompressVideoJob: Compression made file larger, keeping original', ['src_codec' => $srcCodec]);
                 }
             }
 
             $video->update(['status' => 'ready']);
 
-            // Chain to HLS generation for GPU-accelerated adaptive playback
             \App\Jobs\GenerateHlsJob::dispatch($video);
 
         } catch (\Exception $e) {
             Log::error('CompressVideoJob failed: ' . $e->getMessage());
-            $video->update(['status' => 'ready']); // Mark as ready anyway
+            if (file_exists($compressedPath)) @unlink($compressedPath);
+            $video->update(['status' => 'ready']);
         }
     }
 }
-

app/Jobs/DecorateLyricsJob.php

@@ -0,0 +1,139 @@
+<?php
+
+namespace App\Jobs;
+
+use App\Models\Video;
+use App\Models\VideoAudioTrack;
+use App\Services\LlmLyricsService;
+use App\Services\NasSyncService;
+use Illuminate\Bus\Queueable;
+use Illuminate\Contracts\Queue\ShouldQueue;
+use Illuminate\Foundation\Bus\Dispatchable;
+use Illuminate\Queue\InteractsWithQueue;
+use Illuminate\Queue\SerializesModels;
+use Illuminate\Support\Facades\Log;
+
+/**
+ * Bake heavy emoji decoration into the saved lyrics JSON using the active LLM.
+ * Original words are preserved verbatim; emojis are layered on top (in-line +
+ * trailing, multiple per line) per the admin's decoration prompt.
+ *
+ * Runs as its own job so a flaky LLM call can never delay or fail a successful
+ * transcription. Safe to re-run — already-decorated lines are skipped, so a
+ * second pass only fills in gaps.
+ */
+class DecorateLyricsJob implements ShouldQueue
+{
+    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;
+
+    public int $timeout = 600;
+    public int $tries = 1;
+
+    /** Languages written without spaces between words (mirrors transcribe.py). */
+    private const SPACELESS_LANGS = ['th', 'zh', 'ja', 'lo', 'my', 'km', 'yue', 'wuu'];
+
+    public function __construct(public int $videoId, public ?int $trackId = null)
+    {
+        $this->onQueue('video-processing');
+    }
+
+    public function handle(LlmLyricsService $llm, NasSyncService $nas): void
+    {
+        // Two-layer toggle: the admin's per-pipeline switch (Lyrics Pipeline
+        // page) gates this job, and the LLM-service-level switch (AI/LLM page)
+        // gates the LLM call inside it. Either being OFF skips decoration.
+        if (\App\Models\Setting::get('lyrics_llm_decorate', 'true') !== 'true') return;
+        if (! $llm->decorateEnabled()) return;
+
+        $video = Video::find($this->videoId);
+        if (! $video) return;
+
+        $track = $this->trackId ? VideoAudioTrack::find($this->trackId) : null;
+        if ($this->trackId && ! $track) return;
+
+        $data = $nas->getLyrics($video, $track);
+        if (! is_array($data) || empty($data['lines'])) return;
+        if (($data['status'] ?? null) !== 'ready') return;
+
+        // Decorate only lines that haven't been decorated yet — a re-run fills
+        // gaps cheaply instead of re-stamping the whole song.
+        $texts   = [];
+        $indices = [];
+        foreach ($data['lines'] as $i => $ln) {
+            if (! empty($ln['decorated'])) continue;
+            $t = (string) ($ln['text'] ?? '');
+            if (trim($t) === '') continue;
+            $texts[]   = $t;
+            $indices[] = $i;
+        }
+        if (! $texts) return;
+
+        try {
+            $decorated = $llm->decorateLines($texts);
+        } catch (\Throwable $e) {
+            Log::warning('DecorateLyricsJob: LLM call failed: ' . $e->getMessage(), [
+                'video_id' => $this->videoId, 'track_id' => $this->trackId,
+            ]);
+            return;
+        }
+        if (! $decorated) return;
+
+        $applied = 0;
+        foreach ($decorated as $localIdx => $newText) {
+            if (! isset($indices[$localIdx])) continue;
+            $globalIdx = $indices[$localIdx];
+            $line = &$data['lines'][$globalIdx];
+
+            $line['text']       = $newText;
+            $line['decorated']  = true;
+            // The words array no longer matches the new (emoji-laced) text. We
+            // redistribute the existing [start,end] window evenly across the
+            // new tokens so the karaoke word-highlight still tracks the audio.
+            // Tokens that are pure emoji get the same per-slot timing as words.
+            $lang = (string) ($line['lang'] ?? ($data['language'] ?? 'en'));
+            $line['words'] = $this->redistributeWords(
+                (float) ($line['start'] ?? 0),
+                (float) ($line['end']   ?? 0),
+                $newText, $lang
+            );
+            unset($line);
+            $applied++;
+        }
+
+        if (! $applied) return;
+
+        $data['decorated_at'] = now()->toIso8601String();
+        $nas->putLyrics($video, $track, $data);
+
+        Log::info('DecorateLyricsJob: done', [
+            'video_id' => $this->videoId, 'track_id' => $this->trackId,
+            'decorated' => $applied,
+        ]);
+    }
+
+    /**
+     * Evenly distribute [start,end] across the line's tokens. Words for spaced
+     * languages, characters for spaceless scripts (Thai/CJK/…). Used after
+     * decoration so the karaoke word-highlight still tracks the audio.
+     */
+    private function redistributeWords(float $start, float $end, string $text, string $lang): array
+    {
+        if ($text === '' || $end <= $start) return [];
+        $spaceless = in_array($lang, self::SPACELESS_LANGS, true);
+        $tokens = $spaceless
+            ? preg_split('//u', $text, -1, PREG_SPLIT_NO_EMPTY)
+            : preg_split('/\s+/u', trim($text), -1, PREG_SPLIT_NO_EMPTY);
+        $n = count($tokens ?: []);
+        if ($n === 0) return [];
+        $slot = ($end - $start) / $n;
+        $out  = [];
+        foreach ($tokens as $i => $t) {
+            $out[] = [
+                'start' => round($start + $i * $slot, 3),
+                'end'   => round($start + ($i + 1) * $slot, 3),
+                'text'  => $t,
+            ];
+        }
+        return $out;
+    }
+}

app/Jobs/GenerateLyricsJob.php

@@ -0,0 +1,244 @@
+<?php
+
+namespace App\Jobs;
+
+use App\Models\Setting;
+use App\Models\Video;
+use App\Models\VideoAudioTrack;
+use App\Services\NasSyncService;
+use Illuminate\Bus\Queueable;
+use Illuminate\Contracts\Queue\ShouldQueue;
+use Illuminate\Foundation\Bus\Dispatchable;
+use Illuminate\Queue\InteractsWithQueue;
+use Illuminate\Queue\SerializesModels;
+use Illuminate\Support\Facades\Log;
+use Illuminate\Support\Facades\Process;
+
+/**
+ * Generate word-level synced lyrics for one audio track (the video's primary
+ * audio when $trackId is null, otherwise a specific extra-language track).
+ *
+ * Output is a per-track lyrics JSON written through NasSyncService::putLyrics()
+ * — source-of-truth, synced to NAS, never under cache/. Runs the GPU pipeline
+ * exactly once; playback just loads the file afterwards.
+ */
+class GenerateLyricsJob implements ShouldQueue
+{
+    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;
+
+    public int $timeout = 3600;
+    public int $tries = 1;
+
+    public function __construct(public int $videoId, public ?int $trackId = null)
+    {
+        $this->onQueue('video-processing');
+    }
+
+    /** Shared progress-file path (written by the pipeline, read by the status endpoint). */
+    public static function progressPath(int $videoId, ?int $trackId): string
+    {
+        return storage_path('app/tmp/lyrics_prog_' . $videoId . '_' . ($trackId ?? 'primary') . '.json');
+    }
+
+    /** Index of the GPU with the most free memory, or null if it can't be queried. */
+    private function freestGpu(): ?int
+    {
+        $out = []; $code = 1;
+        @exec('nvidia-smi --query-gpu=index,memory.free --format=csv,noheader,nounits 2>/dev/null', $out, $code);
+        if ($code !== 0 || empty($out)) return null;
+        $best = null; $bestFree = -1;
+        foreach ($out as $line) {
+            $parts = array_map('trim', explode(',', $line));
+            if (count($parts) < 2) continue;
+            $idx = (int) $parts[0]; $free = (int) $parts[1];
+            if ($free > $bestFree) { $bestFree = $free; $best = $idx; }
+        }
+        return $best;
+    }
+
+    public function handle(NasSyncService $nas): void
+    {
+        $video = Video::find($this->videoId);
+        if (! $video) return;
+
+        $track = $this->trackId ? VideoAudioTrack::find($this->trackId) : null;
+        if ($this->trackId && ! $track) return;
+
+        $language = $track ? $track->language : $video->language;
+
+        // Mark as processing so the UI can show a generating state before the file lands.
+        $nas->putLyrics($video, $track, [
+            'version'  => 1,
+            'status'   => 'processing',
+            'language' => $language,
+        ]);
+
+        // Resolve a readable local copy of the audio (downloads from NAS if needed).
+        $audioPath     = $track ? $nas->ensureLocalTrackCopy($track) : $nas->ensureLocalCopy($video);
+        $nasDownloaded = $audioPath && str_starts_with($audioPath, storage_path('app/nas_cache/'))
+            ? $audioPath : null;
+
+        if (! $audioPath || ! file_exists($audioPath)) {
+            Log::error('GenerateLyricsJob: audio file unavailable', [
+                'video_id' => $this->videoId, 'track_id' => $this->trackId,
+            ]);
+            $nas->putLyrics($video, $track, [
+                'version' => 1, 'status' => 'failed', 'language' => $language,
+                'error' => 'audio file unavailable',
+            ]);
+            return;
+        }
+
+        $python   = base_path('ml/venv/bin/python');
+        $script   = base_path('ml/transcribe.py');
+        $outTmp   = storage_path('app/tmp/lyrics_' . $this->videoId . '_' . ($this->trackId ?? 'primary') . '.json');
+        $progress = self::progressPath($this->videoId, $this->trackId);
+        if (! is_dir(dirname($outTmp))) @mkdir(dirname($outTmp), 0775, true);
+        @file_put_contents($progress, json_encode(['status' => 'processing', 'pct' => 1, 'stage' => 'Queued']));
+
+        // Model/weight downloads land in a www-data-writable cache, not root's $HOME.
+        $cacheDir = base_path('ml/cache');
+        if (! is_dir($cacheDir)) @mkdir($cacheDir, 0775, true);
+
+        // NOTE: we deliberately do NOT force --language. The stored label is just
+        // metadata and is often wrong (e.g. a Tagalog song mislabeled "en"), which
+        // made WhisperX transcribe the wrong language. Auto-detecting from the
+        // isolated vocals is ground truth; the detected language is saved instead.
+        $args = [$python, $script, '--audio', $audioPath, '--out', $outTmp, '--progress', $progress];
+
+        // Pipeline feature toggles (admin → Lyrics Pipeline). Defaults preserve
+        // current behavior; admin can disable any sub-step that misbehaves.
+        $useDescription = Setting::get('lyrics_use_description',      'true') === 'true';
+        $vadEnabled     = Setting::get('lyrics_vad_enabled',          'true') === 'true';
+        $vocalGapFill   = Setting::get('lyrics_vocal_region_gapfill', 'true') === 'true';
+        $demucsEnabled  = Setting::get('lyrics_demucs_enabled',       'false') === 'true';
+
+        if (! $vadEnabled)   $args[] = '--no-vad';
+        if (! $vocalGapFill) $args[] = '--no-vocal-gapfill';
+
+        // If the song's description contains the lyrics (typed by the uploader),
+        // pass them to the pipeline so it ALIGNS those exact lines to the audio
+        // instead of generating noisier text from scratch. Only for the primary
+        // track — extra-language tracks have their own audio and aren't paired
+        // with the description text.
+        $userLyrFile = null;
+        if ($useDescription && ! $this->trackId && $video->description) {
+            // Prefer the deterministic regex parser. It strips emojis line-by-line
+            // without touching the underlying words, so it preserves every
+            // language a multilingual song contains (e.g. an English+Thai song
+            // keeps both halves). The LLM cleaner is only a backup for cases
+            // where the regex returns nothing — we've seen the LLM silently
+            // drop whole verses that happened to be wrapped in emoji decoration.
+            $descLines = \App\Support\LyricsDescriptionParser::extract($video->description);
+            $source    = 'regex';
+
+            if (empty($descLines)) {
+                $llm = app(\App\Services\LlmLyricsService::class);
+                if ($llm->cleanLyricsEnabled()) {
+                    try {
+                        $descLines = $llm->cleanDescription($video->description);
+                        $source    = 'llm';
+                    } catch (\Throwable $e) {
+                        Log::warning('LLM clean failed: ' . $e->getMessage());
+                    }
+                }
+            }
+
+            if ($descLines) {
+                $userLyrFile = storage_path('app/tmp/userlyr_' . $this->videoId . '.txt');
+                file_put_contents($userLyrFile, implode("\n", $descLines));
+                $args[] = '--user-lyrics';
+                $args[] = $userLyrFile;
+                // With description lyrics, Whisper is only providing word-timing
+                // anchors — its actual transcription text is discarded by the
+                // aligner. Vocal isolation (Demucs) helps transcription QUALITY
+                // but is unnecessary for timing, AND the Demucs→Whisper CUDA-
+                // context handoff has caused intermittent 50% futex deadlocks.
+                // So we skip Demucs in this mode by default; the admin can
+                // re-enable via the Lyrics Pipeline page.
+                $args[] = '--no-demucs';
+                Log::info('GenerateLyricsJob: using description lyrics', [
+                    'video_id' => $this->videoId, 'lines' => count($descLines),
+                    'source'   => $source, 'demucs' => false,
+                    'vad'      => $vadEnabled, 'vocal_gapfill' => $vocalGapFill,
+                ]);
+            }
+        }
+        // Honor the admin Demucs toggle for tracks WITHOUT description lyrics
+        // (where Whisper's transcription quality actually matters).
+        if (! $userLyrFile && ! $demucsEnabled) {
+            $args[] = '--no-demucs';
+        }
+        if (Setting::gpuUsable()) {
+            // Run on the GPU with the most free VRAM so a busy card never forces an
+            // out-of-memory fall back to slow CPU. With two cards this keeps every
+            // generation on the GPU and fast.
+            $args[] = '--gpu';
+            $args[] = (string) ($this->freestGpu() ?? Setting::gpuDevice());
+        }
+
+        Log::info('GenerateLyricsJob: starting', [
+            'video_id' => $this->videoId, 'track_id' => $this->trackId,
+            'language' => $language, 'gpu' => Setting::gpuUsable(),
+        ]);
+
+        try {
+            $result = Process::timeout($this->timeout)
+                ->env([
+                    'HOME'            => $cacheDir,
+                    'XDG_CACHE_HOME'  => $cacheDir,
+                    'HF_HOME'         => $cacheDir . '/huggingface',
+                    'TORCH_HOME'      => $cacheDir . '/torch',
+                    // Demucs runs as a subprocess BEFORE faster-whisper is imported.
+                    // If OpenMP gets initialised in the parent before that fork, the
+                    // post-fork CUDA/ctranslate2 stack can deadlock in futex_wait —
+                    // we've seen this hang lyrics jobs at 50% indefinitely. Forcing
+                    // single-threaded OpenMP in the parent eliminates the race
+                    // (faster-whisper sets its own thread count internally anyway).
+                    'OMP_NUM_THREADS'  => '1',
+                    'MKL_NUM_THREADS'  => '1',
+                    'OPENBLAS_NUM_THREADS' => '1',
+                ])
+                ->run($args);
+
+            if (! $result->successful() || ! file_exists($outTmp)) {
+                throw new \RuntimeException('transcribe.py failed: ' . substr($result->errorOutput(), -2000));
+            }
+
+            $data = json_decode((string) file_get_contents($outTmp), true);
+            if (! is_array($data) || empty($data['lines'])) {
+                throw new \RuntimeException('transcribe.py produced no lines');
+            }
+
+            $data['status']        = 'ready';
+            $data['generated_at']  = now()->toIso8601String();
+            $data['language']      = $data['language'] ?? $language;
+
+            $nas->putLyrics($video, $track, $data);
+
+            // Decoration is independent of the audio pipeline — kick it off as
+            // its own job so a flaky LLM call can't delay or fail a successful
+            // transcription. Skips itself silently if the decorator is off.
+            DecorateLyricsJob::dispatch($this->videoId, $this->trackId)
+                ->onConnection('database');
+
+            Log::info('GenerateLyricsJob: done', [
+                'video_id' => $this->videoId, 'track_id' => $this->trackId,
+                'lines' => count($data['lines']),
+            ]);
+        } catch (\Throwable $e) {
+            Log::error('GenerateLyricsJob failed: ' . $e->getMessage(), [
+                'video_id' => $this->videoId, 'track_id' => $this->trackId,
+            ]);
+            $nas->putLyrics($video, $track, [
+                'version' => 1, 'status' => 'failed', 'language' => $language,
+                'error' => $e->getMessage(),
+            ]);
+        } finally {
+            @unlink($outTmp);
+            @unlink($progress);
+            if ($userLyrFile) @unlink($userLyrFile);
+            if ($nasDownloaded) @unlink($nasDownloaded);
+        }
+    }
+}

app/Mail/VideoShared.php

@@ -0,0 +1,46 @@
+<?php
+
+namespace App\Mail;
+
+use App\Models\User;
+use App\Models\Video;
+use Illuminate\Bus\Queueable;
+use Illuminate\Mail\Mailable;
+use Illuminate\Mail\Mailables\Address;
+use Illuminate\Mail\Mailables\Content;
+use Illuminate\Mail\Mailables\Envelope;
+use Illuminate\Queue\SerializesModels;
+
+class VideoShared extends Mailable
+{
+    use Queueable, SerializesModels;
+
+    public string $shareTitle;
+
+    public function __construct(
+        public Video $video,
+        public string $shareUrl,
+        public User $sender,
+        public ?string $personalMessage = null,
+        ?string $shareTitle = null,
+    ) {
+        // Version-aware title (e.g. the English track's title) with a primary fallback.
+        $this->shareTitle = $shareTitle ?: $video->title;
+    }
+
+    public function envelope(): Envelope
+    {
+        return new Envelope(
+            subject: $this->sender->name . ' shared "' . $this->shareTitle . '" with you on ' . config('app.name'),
+            // Let the recipient reply straight to the friend who sent it.
+            replyTo: $this->sender->email
+                ? [new Address($this->sender->email, $this->sender->name)]
+                : [],
+        );
+    }
+
+    public function content(): Content
+    {
+        return new Content(view: 'emails.video-shared');
+    }
+}

app/Models/CoachReview.php

@@ -18,6 +18,15 @@ class CoachReview extends Model
         'note',
         'coach_name',
         'emoji',
+        'position_x',
+        'position_y',
+    ];
+
+    protected $casts = [
+        'position_x'         => 'float',
+        'position_y'         => 'float',
+        'start_time_seconds' => 'float',
+        'end_time_seconds'   => 'float',
     ];
 
     public function video(): BelongsTo

app/Models/Comment.php

@@ -11,6 +11,13 @@ class Comment extends Model
         'user_id',
         'parent_id',
         'body',
+        'hearted',
+        'pinned',
+    ];
+
+    protected $casts = [
+        'hearted' => 'boolean',
+        'pinned'  => 'boolean',
     ];
 
     // Relationships

app/Models/LiveChatMessage.php

@@ -0,0 +1,34 @@
+<?php
+
+namespace App\Models;
+
+use Illuminate\Database\Eloquent\Model;
+
+class LiveChatMessage extends Model
+{
+    protected $table = 'live_chat_messages';
+
+    public $timestamps = false; // explicit created_at only, set via useCurrent()
+
+    protected $fillable = [
+        'livestream_id',
+        'user_id',
+        'author_name',
+        'body',
+        'created_at',
+    ];
+
+    protected $casts = [
+        'created_at' => 'datetime',
+    ];
+
+    public function livestream()
+    {
+        return $this->belongsTo(LiveStream::class, 'livestream_id');
+    }
+
+    public function user()
+    {
+        return $this->belongsTo(User::class);
+    }
+}

app/Models/LiveStream.php

@@ -0,0 +1,261 @@
+<?php
+
+namespace App\Models;
+
+use Illuminate\Database\Eloquent\Factories\HasFactory;
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Database\Eloquent\Relations\BelongsTo;
+use Illuminate\Support\Carbon;
+use Illuminate\Support\Str;
+
+/**
+ * A live broadcast.
+ *
+ * The row is the authority on whether a stream may exist; the media server
+ * holds no state of its own and asks this table (through LiveAuthController)
+ * before it accepts a publisher or a viewer.
+ */
+class LiveStream extends Model
+{
+    use HasFactory;
+
+    protected $table = 'livestreams';
+
+    protected $fillable = [
+        'user_id', 'public_id', 'title', 'description',
+        'status', 'visibility', 'video_id',
+    ];
+
+    /**
+     * The publish token is a credential. Keeping it out of the default array
+     * form means it cannot be leaked by a careless toJson() on a model that
+     * reached a view or an API response.
+     */
+    protected $hidden = ['publish_token', 'publish_token_expires_at'];
+
+    protected $casts = [
+        'publish_token_expires_at' => 'datetime',
+        'started_at' => 'datetime',
+        'ended_at' => 'datetime',
+        'last_seen_at' => 'datetime',
+    ];
+
+    public const STATUS_IDLE = 'idle';
+    public const STATUS_LIVE = 'live';
+    public const STATUS_ENDED = 'ended';
+    public const STATUS_FAILED = 'failed';
+
+    /** How long a freshly minted publish token stays valid. */
+    public const PUBLISH_TOKEN_TTL_SECONDS = 120;
+
+    protected static function booted(): void
+    {
+        // Every stream gets an unpredictable public id, always — never left to
+        // a caller to remember.
+        static::creating(function (self $stream) {
+            $stream->public_id ??= self::newPublicId();
+        });
+    }
+
+    /* ---------------- Identity ---------------- */
+
+    /**
+     * 32 chars of alphanumeric entropy. Also the media path segment, which is
+     * why it is constrained to [a-zA-Z0-9] — it has to satisfy the path regex
+     * the media server is configured with.
+     */
+    public static function newPublicId(): string
+    {
+        do {
+            $id = Str::random(32);
+        } while (self::where('public_id', $id)->exists());
+
+        return $id;
+    }
+
+    /** Route model binding uses the unpredictable id, never the numeric key. */
+    public function getRouteKeyName(): string
+    {
+        return 'public_id';
+    }
+
+    /** The path the media server knows this stream by. */
+    public function mediaPath(): string
+    {
+        return 'live/'.$this->public_id;
+    }
+
+    /* ---------------- Relations ---------------- */
+
+    public function user(): BelongsTo
+    {
+        return $this->belongsTo(User::class);
+    }
+
+    /** The recording, once a finished stream has been published as a video. */
+    public function video(): BelongsTo
+    {
+        return $this->belongsTo(Video::class);
+    }
+
+    /* ---------------- State ---------------- */
+
+    public function isLive(): bool
+    {
+        return $this->status === self::STATUS_LIVE;
+    }
+
+    public function isOwnedBy(?User $user): bool
+    {
+        return $user !== null && $this->user_id === $user->id;
+    }
+
+    /**
+     * May this viewer watch?
+     *
+     * Both public and unlisted streams are watchable by anyone holding the
+     * link — the difference is only whether the stream is listed. Ownership
+     * additionally grants access before it goes live, so the broadcaster can
+     * open their own watch page to check themselves.
+     */
+    public function isWatchableBy(?User $user): bool
+    {
+        if ($this->isOwnedBy($user)) {
+            return true;
+        }
+
+        // Visibility first — private streams stay owner-only no matter what.
+        if (! in_array($this->visibility, ['public', 'unlisted'], true)) {
+            return false;
+        }
+
+        // Live streams are watchable while they're on; ended streams remain
+        // permalinked so viewers see "Stream ended" and the replay CTA
+        // instead of a hard 404.
+        return $this->isLive() || $this->status === self::STATUS_ENDED;
+    }
+
+    /* ---------------- Publish credential ---------------- */
+
+    /**
+     * Mint a short-lived, single-use token for the broadcaster's browser.
+     *
+     * Returned in plaintext to the owner exactly once, at the moment they press
+     * "Go live". Stored so the media server's auth hook can verify it, then
+     * consumed on first successful publish.
+     */
+    public function issuePublishToken(): string
+    {
+        $token = Str::random(64);
+
+        $this->forceFill([
+            'publish_token' => hash('sha256', $token),
+            'publish_token_expires_at' => now()->addSeconds(self::PUBLISH_TOKEN_TTL_SECONDS),
+        ])->save();
+
+        return $token;
+    }
+
+    /** Constant-time check of a presented token against the stored hash. */
+    public function publishTokenMatches(?string $presented): bool
+    {
+        if (! $presented || ! $this->publish_token || ! $this->publish_token_expires_at) {
+            return false;
+        }
+
+        if ($this->publish_token_expires_at->isPast()) {
+            return false;
+        }
+
+        return hash_equals($this->publish_token, hash('sha256', $presented));
+    }
+
+    /** Burn the token so a captured one cannot be replayed. */
+    public function consumePublishToken(): void
+    {
+        $this->forceFill([
+            'publish_token' => null,
+            'publish_token_expires_at' => null,
+        ])->save();
+    }
+
+    /* ---------------- Transitions ---------------- */
+
+    public function markLive(): void
+    {
+        $this->forceFill([
+            'status' => self::STATUS_LIVE,
+            'started_at' => $this->started_at ?? now(),
+            'last_seen_at' => now(),
+            'ended_at' => null,
+        ])->save();
+    }
+
+    /**
+     * Put an ended stream back into a startable state.
+     *
+     * A stream is a reusable channel, not a one-shot: the owner keeps the same
+     * link and can go live on it again. Without this, any failed start — a lost
+     * signal, a refused camera, a server hiccup — would kill the stream
+     * permanently and force a new link on every retry.
+     */
+    public function reArm(): void
+    {
+        if ($this->status !== self::STATUS_ENDED && $this->status !== self::STATUS_FAILED) {
+            return;
+        }
+
+        $this->forceFill([
+            'status' => self::STATUS_IDLE,
+            'ended_at' => null,
+            'current_viewers' => 0,
+        ])->save();
+    }
+
+    public function markEnded(): void
+    {
+        $this->forceFill([
+            'status' => self::STATUS_ENDED,
+            'ended_at' => now(),
+            'current_viewers' => 0,
+            'publish_token' => null,
+            'publish_token_expires_at' => null,
+        ])->save();
+    }
+
+    /* ---------------- Display ---------------- */
+
+    public function getDurationSecondsAttribute(): ?int
+    {
+        if (! $this->started_at) {
+            return null;
+        }
+
+        return ($this->ended_at ?? Carbon::now())->diffInSeconds($this->started_at);
+    }
+
+    public function getFormattedDurationAttribute(): string
+    {
+        $seconds = $this->duration_seconds;
+
+        if ($seconds === null) {
+            return '00:00';
+        }
+
+        return $seconds >= 3600
+            ? sprintf('%d:%02d:%02d', intdiv($seconds, 3600), intdiv($seconds % 3600, 60), $seconds % 60)
+            : sprintf('%02d:%02d', intdiv($seconds, 60), $seconds % 60);
+    }
+
+    /* ---------------- Scopes ---------------- */
+
+    public function scopeLive($query)
+    {
+        return $query->where('status', self::STATUS_LIVE);
+    }
+
+    public function scopeListed($query)
+    {
+        return $query->where('visibility', 'public');
+    }
+}

app/Models/MatchPoint.php

@@ -22,6 +22,10 @@ class MatchPoint extends Model
         'score_red',
     ];
 
+    protected $casts = [
+        'timestamp_seconds' => 'float',
+    ];
+
     public function video(): BelongsTo
     {
         return $this->belongsTo(Video::class);

app/Models/MatchRound.php

@@ -19,7 +19,7 @@ class MatchRound extends Model
     ];
 
     protected $casts = [
-        'start_time_seconds' => 'integer',
+        'start_time_seconds' => 'float',
     ];
 
     public function video(): BelongsTo

app/Models/Playlist.php

@@ -17,10 +17,12 @@ class Playlist extends Model
         'visibility',
         'is_default',
         'share_token',
+        'view_count',
     ];
 
     protected $casts = [
         'is_default' => 'boolean',
+        'view_count' => 'integer',
     ];
 
     // Relationships
@@ -32,7 +34,7 @@ class Playlist extends Model
     public function videos()
     {
         return $this->belongsToMany(Video::class, 'playlist_videos')
-            ->withPivot('position', 'watched_seconds', 'watched', 'added_at', 'last_watched_at')
+            ->withPivot('position', 'audio_track_id', 'watched_seconds', 'watched', 'added_at', 'last_watched_at')
             ->orderBy('position');
     }
 
@@ -83,12 +85,87 @@ class Playlist extends Model
         return "{$minutes}m";
     }
 
-    // Get total views of all videos in playlist
+    // Total of every viewer-session aggregated across the playlist's videos.
+    // Kept for the analytics-style "video time watched" metric — for the
+    // playlist's OWN view counter (cards, share link), use $playlist->view_count
+    // which is incremented per-device by bumpViewIfNew().
     public function getTotalViewsAttribute()
     {
         return $this->videos()->get()->sum('view_count');
     }
 
+    /**
+     * Record a playlist view if this viewer hasn't already counted within the
+     * dedup window. Mirrors the video_views pattern: signed-in users dedup by
+     * user_id, guests dedup by device fingerprint (preferred) or device cookie.
+     *
+     * Cheap and idempotent — runs as one EXISTS + (optionally) one INSERT +
+     * one atomic increment, all on indexed columns. Called via
+     * dispatchAfterResponse() so it never adds latency to the page render.
+     */
+    public function bumpViewIfNew(\Illuminate\Http\Request $request): void
+    {
+        $userId = \Illuminate\Support\Facades\Auth::id();
+        $did    = $request->cookie('_did');
+        $fp     = $request->cookie('_fp');
+        $fp     = ($fp && preg_match('/^[a-f0-9]{64}$/', $fp)) ? $fp : null;
+
+        // No identifier at all? Skip silently — a unidentifiable request would
+        // count on every refresh and inflate the counter.
+        if (! $userId && ! $did && ! $fp) return;
+
+        $q = \DB::table('playlist_views')
+            ->where('playlist_id', $this->id)
+            ->where('viewed_at', '>', now()->subHour());
+
+        if ($userId) {
+            $q->where('user_id', $userId);
+        } else {
+            $q->whereNull('user_id')->where(function ($w) use ($fp, $did) {
+                if ($fp)  $w->orWhere('device_hash', $fp);
+                if ($did) $w->orWhere('device_id',   $did);
+            });
+        }
+
+        if ($q->exists()) return;
+
+        $ip  = $request->header('CF-Connecting-IP')
+            ?? $request->header('X-Real-IP')
+            ?? $request->ip();
+        $geo = \App\Services\GeoIpService::lookup($ip);
+
+        \DB::table('playlist_views')->insert([
+            'playlist_id'  => $this->id,
+            'user_id'      => $userId,
+            'device_id'    => $did,
+            'device_hash'  => $fp,
+            'ip_address'   => $ip,
+            'country'      => $geo['country']      ?? null,
+            'country_name' => $geo['country_name'] ?? null,
+            'user_agent'   => substr((string) $request->userAgent(), 0, 512),
+            'viewed_at'    => now(),
+        ]);
+
+        \DB::table('playlists')->where('id', $this->id)->increment('view_count');
+    }
+
+    /**
+     * Compute previous/next videos from an already-loaded ordered collection
+     * (the playlist's videos in position order). Saves the 4+ extra queries
+     * that getNextVideo() / getPreviousVideo() would each fire.
+     */
+    public function neighborsFromCollection(\Illuminate\Support\Collection $orderedVideos, Video $current): array
+    {
+        $idx = $orderedVideos->search(fn ($v) => $v->id === $current->id);
+        if ($idx === false) {
+            return [null, $orderedVideos->first()];
+        }
+        return [
+            $idx > 0 ? $orderedVideos[$idx - 1] : null,
+            $idx < $orderedVideos->count() - 1 ? $orderedVideos[$idx + 1] : null,
+        ];
+    }
+
     // Check if user owns this playlist
     public function isOwnedBy($user)
     {
@@ -219,10 +296,12 @@ class Playlist extends Model
         }
     }
 
-    // Add video to playlist
-    public function addVideo(Video $video)
+    // Add video to playlist. When $audioTrackId is null the primary track
+    // plays; otherwise the specified language track is pinned to this row.
+    // Same video with a *different* track becomes a separate row.
+    public function addVideo(Video $video, ?int $audioTrackId = null)
     {
-        if ($this->hasVideo($video)) {
+        if ($this->hasVideoWithTrack($video, $audioTrackId)) {
             return false;
         }
 
@@ -230,13 +309,35 @@ class Playlist extends Model
 
         $this->videos()->attach($video->id, [
             'position'       => $maxPosition + 1,
+            'audio_track_id' => $audioTrackId,
             'added_at'       => now(),
         ]);
 
         return true;
     }
 
-    // Remove video from playlist
+    // Remove a specific (video, track) row from the playlist. When
+    // $audioTrackId is null, only the "primary track" row is removed —
+    // language-pinned rows for the same video are left in place.
+    public function removeVideoWithTrack(Video $video, ?int $audioTrackId = null)
+    {
+        $query = \DB::table('playlist_videos')
+            ->where('playlist_id', $this->id)
+            ->where('video_id', $video->id);
+        if ($audioTrackId === null) {
+            $query->whereNull('audio_track_id');
+        } else {
+            $query->where('audio_track_id', $audioTrackId);
+        }
+        $deleted = $query->delete();
+
+        if ($deleted) $this->reorderPositions();
+
+        return (bool) $deleted;
+    }
+
+    // Remove *all* rows for a given video (any track). Preserved for
+    // callers that don't care about the track distinction.
     public function removeVideo(Video $video)
     {
         if (! $this->hasVideo($video)) {
@@ -251,6 +352,21 @@ class Playlist extends Model
         return true;
     }
 
+    // Does this playlist contain (video, track)? track=null matches the
+    // "primary track" row specifically, not any row for the video.
+    public function hasVideoWithTrack(Video $video, ?int $audioTrackId = null): bool
+    {
+        $query = \DB::table('playlist_videos')
+            ->where('playlist_id', $this->id)
+            ->where('video_id', $video->id);
+        if ($audioTrackId === null) {
+            $query->whereNull('audio_track_id');
+        } else {
+            $query->where('audio_track_id', $audioTrackId);
+        }
+        return $query->exists();
+    }
+
     // Reorder positions after removal
     protected function reorderPositions()
     {

app/Models/ProfileVisit.php

@@ -0,0 +1,43 @@
+<?php
+
+namespace App\Models;
+
+use Illuminate\Database\Eloquent\Factories\HasFactory;
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Database\Eloquent\Relations\BelongsTo;
+
+class ProfileVisit extends Model
+{
+    use HasFactory;
+
+    public $timestamps = false;
+
+    protected $fillable = [
+        'profile_user_id',
+        'visitor_user_id',
+        'device_id',
+        'source_video_id',
+        'ip_address',
+        'country',
+        'created_at',
+    ];
+
+    protected $casts = [
+        'created_at' => 'datetime',
+    ];
+
+    public function profileUser(): BelongsTo
+    {
+        return $this->belongsTo(User::class, 'profile_user_id');
+    }
+
+    public function visitor(): BelongsTo
+    {
+        return $this->belongsTo(User::class, 'visitor_user_id');
+    }
+
+    public function sourceVideo(): BelongsTo
+    {
+        return $this->belongsTo(Video::class, 'source_video_id');
+    }
+}

app/Models/SportsMatch.php

@@ -0,0 +1,135 @@
+<?php
+
+namespace App\Models;
+
+use Illuminate\Database\Eloquent\Factories\HasFactory;
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Database\Eloquent\Relations\BelongsTo;
+
+class SportsMatch extends Model
+{
+    use HasFactory;
+
+    protected $table = 'sports_matches';
+
+    protected $fillable = [
+        'video_id', 'user_id', 'status',
+        'sport', 'title', 'event_name', 'match_type',
+        'match_date', 'match_time',
+        'participant1_name', 'participant2_name', 'referee_name', 'venue_name',
+        'competition', 'participants', 'media', 'officials',
+        'venue', 'result', 'segments', 'statistics', 'reviews',
+    ];
+
+    protected $casts = [
+        'match_date'   => 'date',
+        'competition'  => 'array',
+        'participants' => 'array',
+        'media'        => 'array',
+        'officials'    => 'array',
+        'venue'        => 'array',
+        'result'       => 'array',
+        'segments'     => 'array',
+        'statistics'   => 'array',
+        'reviews'      => 'array',
+    ];
+
+    /**
+     * Shape the record into exactly what the match page header renders. Every value
+     * is null-safe so a video with no/partial match data degrades to just its title
+     * instead of falling back to hard-coded demo content.
+     */
+    public function headerData(): array
+    {
+        $p = $this->participants ?? [];
+        $c = $this->competition ?? [];
+        $v = $this->venue ?? [];
+        $m = $this->media ?? [];
+        $trim = fn($x) => (is_string($x) && trim($x) !== '') ? trim($x) : null;
+
+        return [
+            'sport' => $trim($this->sport),
+            'blue' => [
+                'name'      => $trim($this->participant1_name),
+                'club'      => $trim($p['p1_club']    ?? null),
+                'flag'      => $this->flagFor($p['p1_country'] ?? null),
+                // Uploader form (sports-match modal) stores these under the
+                // canonical media.* keys — mirror them to headerData() so the
+                // scoreboard/VS partials get real image paths.
+                'club_logo' => $trim($m['club1_logo']         ?? $m['p1_club_logo'] ?? null),
+                'headshot'  => $trim($m['participant1_photo'] ?? $m['p1_headshot']  ?? null),
+            ],
+            'red' => [
+                'name'      => $trim($this->participant2_name),
+                'club'      => $trim($p['p2_club']    ?? null),
+                'flag'      => $this->flagFor($p['p2_country'] ?? null),
+                'club_logo' => $trim($m['club2_logo']         ?? $m['p2_club_logo'] ?? null),
+                'headshot'  => $trim($m['participant2_photo'] ?? $m['p2_headshot']  ?? null),
+            ],
+            'weight_category'    => $trim($p['weight_class'] ?? null),
+            'division'           => $trim($c['division']     ?? null),
+            // Sub-header "stage" shown between the two yellow lines above
+            // the weight class (e.g. "Finals", "SEMI FINAL"). Sourced from
+            // the SportsMatch->title column — the form's "Match title" input.
+            'stage'              => $trim($this->title),
+            // "Event title" = the championship / tournament name shown above the
+            // fighters. Prefer the SportsMatch->event_name column (the field the
+            // uploader labels "Event title"), fall back to competition.championship_name.
+            'championship'       => $trim($this->event_name) ?? $trim($c['championship_name'] ?? null),
+            'match_number'       => $trim(($c['match_number'] ?? null) !== null ? (string) $c['match_number'] : null),
+            'court'              => $trim($c['court'] ?? null),
+            'format'             => $trim($c['format'] ?? null),   // "3 min", "Best of 3", …
+            'match_date'         => $this->match_date?->format('Y-m-d'),
+            'referee' => [
+                'name' => $trim($this->referee_name),
+                'flag' => $this->flagFor($p['referee_country'] ?? null),
+            ],
+            'venue' => [
+                'name'     => $trim($this->venue_name) ?? $trim($v['name'] ?? null),
+                'map_link' => $trim($v['map_link'] ?? null),
+            ],
+            'event_logo' => $trim($m['event_poster'] ?? null),
+            /*
+             * Per-video overlay defaults set by the uploader. Shape:
+             *   ['scorebar'=>bool, 'feed'=>bool, 'matchInfo'=>bool, 'timeline'=>bool,
+             *    'clubs'=>bool, 'flags'=>bool, 'penalties'=>bool, 'cornerLabels'=>'auto|redblue|karate|taekwondo']
+             * Anything not set falls back to the app defaults in the JS.
+             */
+            'scoreboard_defaults' => is_array($c['scoreboard'] ?? null) ? $c['scoreboard'] : [],
+        ];
+    }
+
+    /** Resolve a country name or ISO2 code to a lowercase flag-icons code (or null). */
+    private function flagFor(?string $country): ?string
+    {
+        $country = trim((string) $country);
+        if ($country === '') {
+            return null;
+        }
+        $countries = \App\Data\Countries::all();
+        if (preg_match('/^[A-Za-z]{2}$/', $country) && isset($countries[strtoupper($country)])) {
+            return strtolower($country);
+        }
+        foreach ($countries as $iso2 => $meta) {
+            if (strcasecmp($meta['name'], $country) === 0) {
+                return strtolower($iso2);
+            }
+        }
+        return null;
+    }
+
+    public function video(): BelongsTo
+    {
+        return $this->belongsTo(Video::class);
+    }
+
+    public function user(): BelongsTo
+    {
+        return $this->belongsTo(User::class);
+    }
+
+    public function isDraft(): bool
+    {
+        return $this->status === 'draft';
+    }
+}

app/Models/User.php

@@ -7,6 +7,8 @@ use Illuminate\Contracts\Auth\MustVerifyEmail;
 use Illuminate\Database\Eloquent\Factories\HasFactory;
 use Illuminate\Foundation\Auth\User as Authenticatable;
 use Illuminate\Notifications\Notifiable;
+use Illuminate\Support\Facades\DB;
+use Illuminate\Support\Facades\Schema;
 use Illuminate\Support\Str;
 use Laravel\Sanctum\HasApiTokens;
 
@@ -56,8 +58,57 @@ class User extends Authenticatable implements MustVerifyEmail
         'password'                   => 'hashed',
         'two_factor_enabled'         => 'boolean',
         'notification_preferences'   => 'array',
+        // TAKEONE account link. The token is a live credential for that
+        // platform, so it is encrypted at rest and never sent back to a browser.
+        'takeone_token'              => 'encrypted',
+        'takeone_connected_at'       => 'datetime',
     ];
 
+    /**
+     * Can this user run TAKEONE lookups?
+     *
+     * A super admin always can: the platform holds a TAKEONE super-admin token
+     * on their behalf, so they are connected with full reach without ever
+     * pasting anything. Everyone else links their own account, and sees only
+     * what that account may see.
+     */
+    public function takeoneLinked(): bool
+    {
+        return $this->takeoneToken() !== null;
+    }
+
+    /** True when the connection is the platform's, not one this user pasted. */
+    public function takeoneManagedLink(): bool
+    {
+        $own = $this->takeone_token;
+
+        return ($own === null || $own === '')
+            && $this->isSuperAdmin()
+            && ! empty(config('services.takeone.admin_token'));
+    }
+
+    /**
+     * The token to talk to TAKEONE with. A personally linked account always
+     * wins, so a super admin who deliberately links their own identity is not
+     * silently upgraded back to the platform credential.
+     */
+    public function takeoneToken(): ?string
+    {
+        $own = $this->takeone_token;
+
+        if ($own !== null && $own !== '') {
+            return $own;
+        }
+
+        if ($this->isSuperAdmin()) {
+            $platform = config('services.takeone.admin_token');
+
+            return ! empty($platform) ? $platform : null;
+        }
+
+        return null;
+    }
+
     // Defaults for each preference key (true = on, false = off)
     private const NOTIF_DEFAULTS = [
         'notif_new_comment'        => true,
@@ -105,6 +156,55 @@ class User extends Authenticatable implements MustVerifyEmail
         });
     }
 
+    /**
+     * Resolve the most-frequent ISO2 country for each user id, aggregating
+     * video_views + profile_visits and falling back to users.nationality.
+     * Returns [user_id => 'BH', …]; keys without data are omitted.
+     */
+    public static function topCountriesFor(array $userIds): array
+    {
+        $userIds = array_values(array_unique(array_filter($userIds, 'is_numeric')));
+        if (! $userIds) return [];
+
+        $tally = [];
+        $rows = DB::table('video_views')
+            ->selectRaw('user_id, country, COUNT(*) as c')
+            ->whereIn('user_id', $userIds)
+            ->whereNotNull('country')->where('country', '!=', '')
+            ->groupBy('user_id', 'country')->get();
+        foreach ($rows as $r) {
+            $cc = strtoupper($r->country);
+            $tally[(int) $r->user_id][$cc] = ($tally[(int) $r->user_id][$cc] ?? 0) + (int) $r->c;
+        }
+        if (Schema::hasTable('profile_visits')) {
+            $rows = DB::table('profile_visits')
+                ->selectRaw('visitor_user_id as user_id, country, COUNT(*) as c')
+                ->whereIn('visitor_user_id', $userIds)
+                ->whereNotNull('country')->where('country', '!=', '')
+                ->groupBy('visitor_user_id', 'country')->get();
+            foreach ($rows as $r) {
+                $cc = strtoupper($r->country);
+                $tally[(int) $r->user_id][$cc] = ($tally[(int) $r->user_id][$cc] ?? 0) + (int) $r->c;
+            }
+        }
+
+        $out = [];
+        foreach ($tally as $uid => $counts) {
+            arsort($counts);
+            $out[$uid] = array_key_first($counts);
+        }
+
+        // Fallback to users.nationality for anyone still unresolved.
+        $missing = array_values(array_diff($userIds, array_keys($out)));
+        if ($missing) {
+            $nats = static::whereIn('id', $missing)
+                ->whereNotNull('nationality')->where('nationality', '!=', '')
+                ->pluck('nationality', 'id');
+            foreach ($nats as $uid => $cc) $out[(int) $uid] = strtoupper($cc);
+        }
+        return $out;
+    }
+
     public static function generateUniqueUsername(string $name): string
     {
         $base = substr(Str::slug(trim($name)), 0, 18);
@@ -162,23 +262,38 @@ class User extends Authenticatable implements MustVerifyEmail
     public function getAvatarUrlAttribute(): string
     {
         if ($this->avatar) {
-            return route('media.avatar', $this->avatar);
+            // ?v busts the browser cache when the avatar is replaced. The path is
+            // always .../profile/avatar.<ext>, so without a version every page would
+            // keep showing the previously cached image after an upload.
+            return route('media.avatar', $this->avatar).'?v='.($this->updated_at?->timestamp ?? '0');
         }
 
-        return 'https://i.pravatar.cc/150?u='.$this->id;
+        return asset('images/default-avatar.svg');
     }
 
     public function getBannerUrlAttribute(): ?string
     {
         if ($this->banner) {
-            return route('media.banner', $this->banner);
+            return route('media.banner', $this->banner).'?v='.($this->updated_at?->timestamp ?? '0');
         }
         return null;
     }
 
     public function sendEmailVerificationNotification(): void
     {
+        // Mail failures must never bubble up as a 500 to the user — the account
+        // exists, the HTTP request was fine, only the delivery pipe is broken.
+        // We log the failure (ops picks it up) and move on. Re-sending via
+        // `php artisan app:resend-verification` fixes the user once SMTP recovers.
+        try {
             $this->notify(new VerifyEmail);
+        } catch (\Throwable $e) {
+            \Illuminate\Support\Facades\Log::warning('verify-email send failed', [
+                'user_id' => $this->id,
+                'email'   => $this->email,
+                'error'   => $e->getMessage(),
+            ]);
+        }
     }
 
     // Role helper methods
@@ -205,7 +320,7 @@ class User extends Authenticatable implements MustVerifyEmail
             'user_subscriptions',
             'channel_id',
             'subscriber_id'
-        )->withPivot('created_at');
+        )->withPivot(['created_at', 'source_video_id']);
     }
 
     // Channels this user subscribes to
@@ -216,7 +331,7 @@ class User extends Authenticatable implements MustVerifyEmail
             'user_subscriptions',
             'subscriber_id',
             'channel_id'
-        )->withPivot('created_at');
+        )->withPivot(['created_at', 'source_video_id']);
     }
 
     public function isSubscribedTo(User $channel): bool

app/Models/Video.php

@@ -53,6 +53,11 @@ class Video extends Model
         return $this->belongsToMany(User::class, 'video_likes')->withTimestamps();
     }
 
+    public function dislikes()
+    {
+        return $this->belongsToMany(User::class, 'video_dislikes')->withTimestamps();
+    }
+
     public function viewers()
     {
         return $this->belongsToMany(User::class, 'video_views')
@@ -67,7 +72,9 @@ class Video extends Model
 
     public function audioTracks()
     {
-        return $this->hasMany(\App\Models\VideoAudioTrack::class)->orderBy('id');
+        return $this->hasMany(\App\Models\VideoAudioTrack::class)
+            ->orderBy('position')
+            ->orderBy('id');
     }
 
     public function hasSlideshow(): bool
@@ -75,6 +82,40 @@ class Video extends Model
         return $this->slides()->count() > 1;
     }
 
+    /**
+     * Resolve the slide list for a given audio track, applying the sharing rule:
+     *   1. Slides explicitly owned by this track (audio_track_id = $trackId).
+     *   2. Slides owned by the primary (audio_track_id IS NULL = song-wide / legacy).
+     *   3. Slides owned by any other track (first track in id order).
+     *   4. Empty (caller falls back to cover image).
+     *
+     * Pass `null` for the primary audio (the one stored on the videos row).
+     *
+     * @return \Illuminate\Support\Collection<int,\App\Models\VideoSlide>
+     */
+    public function slidesForTrack(?int $audioTrackId)
+    {
+        $all = $this->slides; // eager-loaded collection of every slide
+
+        if ($audioTrackId !== null) {
+            $own = $all->where('audio_track_id', $audioTrackId)->values();
+            if ($own->isNotEmpty()) return $own;
+        }
+
+        // Primary / song-wide bucket (audio_track_id IS NULL).
+        $primary = $all->whereNull('audio_track_id')->values();
+        if ($primary->isNotEmpty()) return $primary;
+
+        // Borrow from the first track (by id) that has any.
+        $byTrack = $all->whereNotNull('audio_track_id')->groupBy('audio_track_id');
+        if ($byTrack->isNotEmpty()) {
+            $firstTrackId = $byTrack->keys()->sort()->first();
+            return $byTrack[$firstTrackId]->values();
+        }
+
+        return collect();
+    }
+
     // ── Local filesystem path helpers ─────────────────────────────────────────
 
     /**
@@ -141,6 +182,20 @@ class Video extends Model
         return $this->likes()->count();
     }
 
+    // Dislike helpers — same shape as the like pair above.
+    public function isDislikedBy($user)
+    {
+        if (! $user) {
+            return false;
+        }
+        return $this->dislikes()->where('user_id', $user->id)->exists();
+    }
+
+    public function getDislikeCountAttribute()
+    {
+        return $this->dislikes()->count();
+    }
+
     // Get view count - use direct query to avoid timestamp issues
     public function getViewCountAttribute()
     {
@@ -218,7 +273,29 @@ class Video extends Model
         if ($realId === null || $realId <= 0) {
             abort(404);
         }
-        return $this->where('id', $realId)->firstOrFail();
+        $video = $this->where('id', $realId)->first();
+        if ($video) {
+            return $video;
+        }
+
+        // Video not found — check the merge-redirect table so old links still work.
+        $redirect = \DB::table('video_redirects')->where('source_id', $realId)->first();
+        if ($redirect) {
+            $target = static::find($redirect->target_id);
+            if ($target) {
+                $newValue = self::encodeId($target->id);
+                $newUrl = preg_replace(
+                    '#/'.preg_quote((string) $value, '#').'(?=/|\?|$)#',
+                    '/'.$newValue,
+                    request()->fullUrl(),
+                    1
+                );
+                throw new \Illuminate\Http\Exceptions\HttpResponseException(
+                    redirect()->to($newUrl, 302)
+                );
+            }
+        }
+        abort(404);
     }
 
     // All share URLs use the unguessable token route
@@ -400,6 +477,12 @@ class Video extends Model
         return $this->hasMany(CoachReview::class)->orderBy('start_time_seconds');
     }
 
+    // The sports match record backing a type=match video (fighters, referee, etc.)
+    public function sportsMatch()
+    {
+        return $this->hasOne(SportsMatch::class);
+    }
+
     // Get recent views count (within hours)
     public function getRecentViews($hours = 48)
     {

app/Models/VideoAudioTrack.php

@@ -14,6 +14,12 @@ class VideoAudioTrack extends Model
         return $this->belongsTo(Video::class);
     }
 
+    /** Slides explicitly owned by this track. Use Video::slidesForTrack() for fallback resolution. */
+    public function slides()
+    {
+        return $this->hasMany(VideoSlide::class, 'audio_track_id')->orderBy('position');
+    }
+
     public function getStreamUrlAttribute(): string
     {
         return route('videos.audio-track', ['video' => $this->video_id, 'track' => $this->id]);

app/Models/VideoSlide.php

@@ -6,13 +6,18 @@ use Illuminate\Database\Eloquent\Model;
 
 class VideoSlide extends Model
 {
-    protected $fillable = ['video_id', 'filename', 'position'];
+    protected $fillable = ['video_id', 'audio_track_id', 'filename', 'position'];
 
     public function video()
     {
         return $this->belongsTo(Video::class);
     }
 
+    public function audioTrack()
+    {
+        return $this->belongsTo(VideoAudioTrack::class, 'audio_track_id');
+    }
+
     public function getUrlAttribute(): string
     {
         return route('media.thumbnail', $this->filename);

app/Notifications/BruteForceLoginAlert.php

@@ -0,0 +1,51 @@
+<?php
+
+namespace App\Notifications;
+
+use Illuminate\Bus\Queueable;
+use Illuminate\Notifications\Messages\MailMessage;
+use Illuminate\Notifications\Notification;
+
+/**
+ * Fires to every super admin when the same email or IP has produced several
+ * failed login attempts in a short window. Lets ops decide whether to lock
+ * the account, change the password, or just raise the global throttle.
+ */
+class BruteForceLoginAlert extends Notification
+{
+    use Queueable;
+
+    public function __construct(
+        public readonly string $email,
+        public readonly string $ip,
+        public readonly int $failures,
+        public readonly int $windowMinutes,
+    ) {}
+
+    public function via(object $notifiable): array
+    {
+        return ['database', 'mail'];
+    }
+
+    public function toArray(object $notifiable): array
+    {
+        return [
+            'kind'           => 'brute_force_login_alert',
+            'email'          => $this->email,
+            'ip'             => $this->ip,
+            'failures'       => $this->failures,
+            'window_minutes' => $this->windowMinutes,
+        ];
+    }
+
+    public function toMail(object $notifiable): MailMessage
+    {
+        return (new MailMessage)
+            ->subject('TAKEONE — suspicious login attempts')
+            ->greeting('Possible brute-force login attempt')
+            ->line("The address {$this->email} has had {$this->failures} failed login attempts in the last {$this->windowMinutes} minutes.")
+            ->line("Most recent attempt came from {$this->ip}.")
+            ->line('Review the audit log and consider forcing a password reset if this account looks real.')
+            ->action('Open Admin', url('/admin/audit-logs'));
+    }
+}

app/Notifications/VideoSharedWithUser.php

@@ -0,0 +1,58 @@
+<?php
+
+namespace App\Notifications;
+
+use App\Models\User;
+use App\Models\Video;
+use Illuminate\Notifications\Messages\MailMessage;
+use Illuminate\Notifications\Notification;
+
+class VideoSharedWithUser extends Notification
+{
+    public function __construct(
+        public Video $video,
+        public User $sharer,
+        public ?string $message,
+        public string $shareUrl,
+    ) {}
+
+    /**
+     * A direct, person-to-person share is transactional — always deliver both
+     * the in-app notification and the email (not gated by subscription prefs).
+     */
+    public function via(object $notifiable): array
+    {
+        return ['database', 'mail'];
+    }
+
+    public function toArray(object $notifiable): array
+    {
+        return [
+            'type'            => 'video_shared',
+            'video_id'        => $this->video->id,
+            'video_route_key' => $this->video->getRouteKey(),
+            'video_title'     => $this->video->title,
+            'video_thumbnail' => $this->video->thumbnail,
+            'actor_id'        => $this->sharer->id,
+            'actor_name'      => $this->sharer->name,
+            'actor_avatar'    => $this->sharer->avatar_url,
+            'message'         => $this->message,
+        ];
+    }
+
+    public function toMail(object $notifiable): MailMessage
+    {
+        $isSong = $this->video->isAudioOnly() || $this->video->type === 'music';
+        $noun   = $isSong ? 'song' : ($this->video->type === 'match' ? 'match' : 'video');
+
+        return (new MailMessage)
+            ->subject($this->sharer->name . ' shared a ' . $noun . ' with you')
+            ->view('emails.video-shared', [
+                'video'           => $this->video,
+                'sender'          => $this->sharer,
+                'shareUrl'        => $this->shareUrl,
+                'personalMessage' => $this->message,
+                'shareTitle'      => $this->video->title,
+            ]);
+    }
+}

app/Providers/AppServiceProvider.php

@@ -26,8 +26,12 @@ class AppServiceProvider extends ServiceProvider
             \Illuminate\Http\Request::HEADER_X_FORWARDED_AWS_ELB
         );
         
-        // Force HTTPS
+        // Force HTTPS unless we're running under phpunit — the test client
+        // speaks plain http://localhost; forcing https would make every POST
+        // in a feature test resolve to a 302 instead of hitting the controller.
+        if (! $this->app->environment('testing')) {
             URL::forceScheme('https');
+        }
 
         // Universal pagination view — used everywhere by default
         Paginator::defaultView('partials.pagination');

app/Rules/ReservedIdentifier.php

@@ -0,0 +1,56 @@
+<?php
+
+namespace App\Rules;
+
+use Closure;
+use Illuminate\Contracts\Validation\ValidationRule;
+
+/**
+ * Blocks impersonation of staff/system accounts.
+ *
+ * Applied to both `name` and the email local-part at registration so a user
+ * cannot sign up as "admin", "superadmin", "takeone", etc. — words that would
+ * let them pass themselves off as the platform or its operators to other
+ * users (comments, DMs, channel pages).
+ */
+class ReservedIdentifier implements ValidationRule
+{
+    private const RESERVED = [
+        'admin', 'administrator', 'superadmin', 'super-admin', 'super_admin',
+        'root', 'sysadmin', 'system', 'owner', 'webmaster', 'postmaster',
+        'moderator', 'mod', 'staff', 'official',
+        'support', 'help', 'helpdesk', 'contact', 'info', 'noreply', 'no-reply',
+        'security', 'abuse', 'billing',
+        'takeone', 'take-one', 'take_one', 'takeonebh', 'takeone-bh',
+        'play', 'playbh', 'playtakeone',
+        'anonymous', 'guest', 'null', 'undefined',
+    ];
+
+    public function __construct(private readonly string $kind = 'name')
+    {
+    }
+
+    public function validate(string $attribute, mixed $value, Closure $fail): void
+    {
+        if (! is_string($value)) {
+            return;
+        }
+
+        $candidate = $this->kind === 'email'
+            ? strtolower(trim(strstr($value, '@', true) ?: $value))
+            : strtolower(trim($value));
+
+        // Collapse separators so "super_admin", "super-admin" and "superadmin" all match.
+        $normalized = preg_replace('/[\s._\-]+/', '', $candidate) ?? $candidate;
+
+        foreach (self::RESERVED as $word) {
+            $target = preg_replace('/[\s._\-]+/', '', $word) ?? $word;
+            if ($normalized === $target) {
+                $fail($this->kind === 'email'
+                    ? 'That email address is reserved. Please use a different one.'
+                    : 'That name is reserved. Please choose a different one.');
+                return;
+            }
+        }
+    }
+}

app/Services/LlmLyricsService.php

@@ -0,0 +1,440 @@
+<?php
+
+namespace App\Services;
+
+use App\Models\Setting;
+use Illuminate\Support\Facades\Cache;
+use Illuminate\Support\Facades\Http;
+use Illuminate\Support\Facades\Log;
+
+/**
+ * Optional LLM helper for the lyrics pipeline.
+ *
+ * Supports multiple providers configured in Admin → Settings → AI / LLM
+ * (local Ollama, hosted Anthropic Claude, or any OpenAI-compatible endpoint).
+ * Picks the provider flagged "Active" and dispatches the request through the
+ * matching adapter. Results are cached so a regenerate doesn't re-bill / re-hit
+ * the local model.
+ */
+class LlmLyricsService
+{
+    public function isEnabled(): bool
+    {
+        return Setting::get('llm_enabled', 'false') === 'true'
+            && $this->activeProvider() !== null;
+    }
+
+    public function cleanLyricsEnabled(): bool
+    {
+        return $this->isEnabled() && Setting::get('llm_clean_lyrics', 'true') === 'true';
+    }
+
+    public function decorateEnabled(): bool
+    {
+        return $this->isEnabled() && Setting::get('llm_decorate_lyrics', 'false') === 'true';
+    }
+
+    /** The currently selected provider config, or null if none. */
+    public function activeProvider(): ?array
+    {
+        $providers = json_decode((string) Setting::get('llm_providers', '[]'), true) ?: [];
+        if (! $providers) return null;
+        $activeId = (string) Setting::get('llm_active_id', '');
+        foreach ($providers as $p) {
+            if (($p['id'] ?? null) === $activeId) {
+                $kind = $p['kind'] ?? 'ollama';
+                // An Ollama provider doesn't need a key; the others do.
+                if ($kind !== 'ollama' && trim((string) ($p['api_key'] ?? '')) === '') return null;
+                if (trim((string) ($p['model'] ?? '')) === '') return null;
+                return $p;
+            }
+        }
+        return null;
+    }
+
+    /** Returns clean lyric lines extracted by the LLM, or [] on any failure. */
+    public function cleanDescription(?string $description): array
+    {
+        if (! $description || ! $this->cleanLyricsEnabled()) return [];
+
+        $provider = $this->activeProvider();
+        // v2 cache key: the prompt was rewritten to stop dropping English/Thai
+        // lyric lines that happened to carry leading/trailing emoji decoration.
+        $cacheKey = 'llm_lyrics_clean_v2:' . ($provider['id'] ?? '') . ':' . sha1($description);
+        return Cache::remember($cacheKey, now()->addDays(30), function () use ($description) {
+            $prompt = "Extract the SUNG lyric lines from this song description, preserving every\n"
+                . "language exactly as written. Songs are often MULTILINGUAL (e.g. mixed English\n"
+                . "and Thai, English and Italian, English and Arabic) — KEEP EVERY LANGUAGE.\n\n"
+                . "KEEP a line when it contains real lyric words, even if it's wrapped in or\n"
+                . "  punctuated by emojis. Example:  '🛡️💻 Met behind the firewalls 🌌'  →  KEEP.\n"
+                . "  Strip ONLY the emojis themselves; the lyric words stay untouched.\n"
+                . "DROP a line ONLY when it is one of:\n"
+                . "  • the song title or artist credit\n"
+                . "  • a pure section header (Verse / Chorus / Bridge / Verso / Ritornello /\n"
+                . "    Pre-Chorus / Outro / Intro / 副歌 / 후렴 / كورس / ท่อน / etc.) — typically\n"
+                . "    one or two words, possibly numbered\n"
+                . "  • an instrument or production note inside 【…】 or 〔…〕 brackets\n"
+                . "  • a row that is ONLY emojis / separators / decorative symbols with no words\n"
+                . "  • commentary or social-media call-to-action (subscribe, follow, link in bio)\n\n"
+                . "Hard rules:\n"
+                . "  - DO NOT translate. DO NOT re-script (no romanising Thai/Arabic, no converting\n"
+                . "    English to Thai). The output of each kept line must be in the SAME language\n"
+                . "    and script as the original line.\n"
+                . "  - DO NOT merge or split lines. One source lyric line → one output entry.\n"
+                . "  - Preserve original punctuation (drop only the emojis).\n"
+                . "  - Maintain the original order.\n\n"
+                . "Respond with ONLY a JSON array of strings. No prose, no markdown, no code fence.\n\n"
+                . "DESCRIPTION:\n" . $description;
+
+            $raw = $this->call($prompt, 8192);
+            if ($raw === '') return [];
+
+            $raw = trim(preg_replace('/^```(?:json)?\s*|\s*```$/m', '', $raw));
+            $arr = json_decode($raw, true);
+            if (! is_array($arr)) return [];
+            $out = [];
+            foreach ($arr as $line) {
+                $line = trim((string) $line);
+                if ($line === '') continue;
+                $out[] = $line;
+            }
+            return $out;
+        });
+    }
+
+    /**
+     * Rewrite each lyric line with heavy, expressive emoji styling. Emojis go
+     * inside the line AND at the end; multiple per line where it fits. The
+     * original words are NEVER changed — emojis are layered on top.
+     *
+     * Returns [index => decoratedLineText]. The caller swaps line.text and
+     * re-distributes the word timings across the new tokens.
+     */
+    public function decorateLines(array $lines): array
+    {
+        if (! $lines || ! $this->decorateEnabled()) return [];
+
+        $provider = $this->activeProvider();
+        $cacheKey = 'llm_lyrics_deco_v3:' . ($provider['id'] ?? '') . ':' . sha1(json_encode($lines));
+        return Cache::remember($cacheKey, now()->addDays(30), function () use ($lines) {
+            $numbered = [];
+            foreach ($lines as $i => $l) $numbered[] = ($i + 1) . '. ' . $l;
+
+            $prompt = "Decorate the following song lyrics with heavy, expressive emoji styling.\n\n"
+                . "Strict instructions:\n"
+                . "- Add emojis to almost every line (rich and visually striking, not minimal).\n"
+                . "- Place emojis both WITHIN lines and AT THE END where they enhance meaning.\n"
+                . "- Use 2–4 emojis per line on average, more on emotional peaks.\n"
+                . "- Match emojis to the line's specific emotion, action, image, or vibe.\n"
+                . "- VARIETY IS CRITICAL. Across the WHOLE song you must use a wide palette:\n"
+                . "    • Aim for 30+ distinct emojis across the song.\n"
+                . "    • Never reuse the same emoji on two adjacent lines.\n"
+                . "    • Do NOT lean on the same 5–6 staples (🔥💔✨🎵❤️). Reach for less obvious\n"
+                . "      ones that fit: ⚡🌊🌙🕯️🪞🥀🦋🌪️🗡️👁️🩸🦅🌀💎🪽🌑🪐🩹🌹🫧🌧️🔮🧨🪞🛡️\n"
+                . "      ⚔️🏹🪄💫🥷🧿🪙🥀🎭🩰🪦⛓️🌌🚪🧊🌠💢🪶🩷🫀🪐🕊️ and many others.\n"
+                . "- Keep the original lyrics 100% UNCHANGED — no rewriting, no translation, no\n"
+                . "  re-spelling, no script conversion. Preserve every original word verbatim.\n"
+                . "- Style should feel bold, dramatic, pop-star, Gen Z, visually addictive — like a\n"
+                . "  designed lyric post or viral TikTok caption.\n"
+                . "- Do NOT add section headers, titles, intros, or any new lines. Every input line\n"
+                . "  must map to exactly one output line, in the same order, with the same words.\n\n"
+                . "Output format: ONLY a JSON object mapping the 1-based line number to the fully\n"
+                . "decorated line text. No prose, no markdown, no code fence.\n\n"
+                . "LINES:\n" . implode("\n", $numbered);
+
+            $raw = $this->call($prompt, 8192);
+            if ($raw === '') return [];
+            $raw = trim(preg_replace('/^```(?:json)?\s*|\s*```$/m', '', $raw));
+            $obj = json_decode($raw, true);
+            if (! is_array($obj)) return [];
+
+            $out = [];
+            foreach ($obj as $k => $v) {
+                if (! is_string($v)) continue;
+                $v = trim($v);
+                if ($v === '') continue;
+                $idx = ((int) $k) - 1;
+                if ($idx < 0 || ! isset($lines[$idx])) continue;
+                // Cheap safety check: the original words must survive verbatim
+                // (the LLM should only LAYER emojis on top). Drop the
+                // decoration if too many original characters are missing.
+                if (! self::preservesOriginal($lines[$idx], $v)) continue;
+                $out[$idx] = $v;
+            }
+            return $out;
+        });
+    }
+
+    /**
+     * Verify the decorated line still contains every alphanumeric character of
+     * the original (in the same order). Stops the LLM from quietly rewording
+     * a line — we keep only decorations that strictly add emojis on top.
+     */
+    private static function preservesOriginal(string $orig, string $decorated): bool
+    {
+        $strip = fn (string $s) => mb_strtolower(preg_replace('/[^\p{L}\p{N}]+/u', '', $s) ?? '');
+        $a = $strip($orig);
+        $b = $strip($decorated);
+        if ($a === '') return true;
+        // Sequential subsequence check: every char of $a must appear in $b in order.
+        $aLen = mb_strlen($a); $bLen = mb_strlen($b);
+        $j = 0;
+        for ($i = 0; $i < $aLen; $i++) {
+            $needle = mb_substr($a, $i, 1);
+            $found = false;
+            for (; $j < $bLen; $j++) {
+                if (mb_substr($b, $j, 1) === $needle) { $found = true; $j++; break; }
+            }
+            if (! $found) return false;
+        }
+        return true;
+    }
+
+
+    /**
+     * Translate arbitrary text (e.g. a user comment) to a target language.
+     * Returns the translated string, or '' on any failure / when disabled.
+     */
+    public function translate(string $text, string $targetLang = 'en', ?string $sourceLangHint = null): string
+    {
+        $text = trim($text);
+        if ($text === '' || ! $this->isEnabled()) return '';
+
+        $provider = $this->activeProvider();
+        $targetLang = preg_replace('/[^a-zA-Z-]/', '', $targetLang) ?: 'en';
+        $sourceLangHint = $sourceLangHint ? (preg_replace('/[^a-zA-Z-]/', '', $sourceLangHint) ?: null) : null;
+        $cacheKey = 'llm_translate_v4:' . ($provider['id'] ?? '') . ':' . $targetLang . ':' . ($sourceLangHint ?? '-') . ':' . sha1($text);
+        $cached = Cache::get($cacheKey);
+        if (is_string($cached) && $cached !== '') return $cached;
+
+        $hint = $sourceLangHint
+            ? "The author's written language is \"{$sourceLangHint}\" (ISO-639). Assume the text is in that language unless it is OBVIOUSLY in a different language (e.g. uses a different script).\n"
+            : '';
+
+        $prompt = "Translate the following text into the language with ISO-639 code \"{$targetLang}\".\n"
+            . $hint
+            . "Rules:\n"
+            . "  - Output ONLY the translated text. No prose, no quotes, no language label, no notes.\n"
+            . "  - Translate EVERY word of the source language, including short exclamations,\n"
+            . "    repeated words, and words that happen to also look like a name in the target\n"
+            . "    language. Example: Portuguese \"Linda, linda, linda\" → \"Beautiful, beautiful,\n"
+            . "    beautiful\" (NOT the English name \"Linda\"). Spanish \"hola\" → \"hello\".\n"
+            . "  - A word is a proper noun ONLY if clearly a person/place/brand name in context\n"
+            . "    (e.g. \"My name is Linda\"). If it stands alone or is repeated as an exclamation,\n"
+            . "    it is almost certainly a regular word — translate it.\n"
+            . "  - If the text is already in the target language, repeat it unchanged.\n"
+            . "  - Preserve emojis, @mentions (e.g. @alice), hashtags, URLs, and timestamp tokens\n"
+            . "    like @1:23 or @01:23-02:45 EXACTLY as written.\n"
+            . "  - Keep the same tone and line breaks.\n\n"
+            . "TEXT:\n" . $text;
+
+        // Translation is deterministic — temp 0. If the model echoes the input
+        // (common when a word happens to also exist as a name in the target
+        // language, e.g. Portuguese "Linda" → English "Linda"), retry once
+        // with a stronger directive. If the retry also echoes, we return it.
+        // Comments cap at 1000 chars → 400 tokens is plenty of headroom and
+        // keeps the model from drifting into long completions on tiny inputs.
+        $budget = max(128, min(1024, (int) ceil(mb_strlen($text) * 1.5) + 64));
+        $raw = $this->postProcess($this->call($prompt, $budget, 0.0));
+        $needsRetry = $sourceLangHint
+            && $sourceLangHint !== $targetLang
+            && self::looksLikeEcho($text, $raw);
+        if ($needsRetry) {
+            $retryPrompt = $prompt
+                . "\n\nIMPORTANT: Your previous attempt was identical to the source. The source is\n"
+                . "DEFINITELY in \"{$sourceLangHint}\", not in \"{$targetLang}\". Translate every word.";
+            $retry = $this->postProcess($this->call($retryPrompt, $budget, 0.0));
+            if ($retry !== '' && ! self::looksLikeEcho($text, $retry)) $raw = $retry;
+        }
+        if ($raw === '') return '';
+
+        Cache::put($cacheKey, $raw, now()->addDays(30));
+        return $raw;
+    }
+
+    private function postProcess(string $raw): string
+    {
+        $raw = trim($raw);
+        $raw = trim(preg_replace('/^```[a-zA-Z]*\s*|\s*```$/m', '', $raw));
+        return $raw;
+    }
+
+    /** Normalised equality: ignore case, whitespace, punctuation, emojis. */
+    private static function looksLikeEcho(string $src, string $out): bool
+    {
+        if ($out === '') return false;
+        $norm = fn (string $s) => mb_strtolower(preg_replace('/[^\p{L}\p{N}]+/u', '', $s) ?? '');
+        $a = $norm($src); $b = $norm($out);
+        return $a !== '' && $a === $b;
+    }
+
+    /**
+     * Translate a sequence of lines, preserving the one-to-one mapping so the
+     * caller can render them side-by-side with the originals. Empty entries
+     * are kept as empty strings. Returns an array of the same length as $lines
+     * (or [] on any failure / when disabled).
+     */
+    public function translateLines(array $lines, string $targetLang = 'en', ?string $sourceLangHint = null): array
+    {
+        if (! $lines || ! $this->isEnabled()) return [];
+        $targetLang = preg_replace('/[^a-zA-Z-]/', '', $targetLang) ?: 'en';
+        $sourceLangHint = $sourceLangHint ? (preg_replace('/[^a-zA-Z-]/', '', $sourceLangHint) ?: null) : null;
+
+        $provider = $this->activeProvider();
+        $cacheKey = 'llm_translate_lines_v2:' . ($provider['id'] ?? '') . ':' . $targetLang . ':' . ($sourceLangHint ?? '-') . ':' . sha1(json_encode($lines));
+        $cached = Cache::get($cacheKey);
+        if (is_array($cached) && count($cached) === count($lines)) return $cached;
+
+        // Index non-empty lines so empty separators are preserved verbatim.
+        $toTranslate = [];
+        foreach ($lines as $i => $l) {
+            if (trim((string) $l) !== '') $toTranslate[$i] = (string) $l;
+        }
+        if (! $toTranslate) {
+            Cache::put($cacheKey, $lines, now()->addDays(30));
+            return $lines;
+        }
+
+        $numbered = [];
+        foreach ($toTranslate as $i => $l) $numbered[] = $i . "\t" . $l;
+
+        $hint = $sourceLangHint
+            ? "The author's written language is \"{$sourceLangHint}\" (ISO-639). Assume the lines are in that language unless they are OBVIOUSLY in a different language (different script).\n"
+            : '';
+
+        $prompt = "Translate each of the following numbered lines into the language with ISO-639 code \"{$targetLang}\".\n"
+            . $hint
+            . "Rules:\n"
+            . "  - Output a JSON object mapping each original index (as string) to its translated line.\n"
+            . "  - Keep ONE output line per input line — do NOT merge, split, re-order, or drop any.\n"
+            . "  - Translate every word including short exclamations and repeated words that happen\n"
+            . "    to look like a name in the target language (Portuguese \"Linda\" → \"Beautiful\").\n"
+            . "  - If a line is already in the target language, repeat it unchanged.\n"
+            . "  - Preserve emojis, @mentions, hashtags, URLs, and timestamp tokens like @1:23 EXACTLY.\n"
+            . "  - Respond with ONLY the JSON object. No prose, no markdown, no code fence.\n\n"
+            . "LINES (index TAB text):\n" . implode("\n", $numbered);
+
+        $raw = $this->postProcess($this->call($prompt, 8192, 0.0));
+        $obj = json_decode($raw, true);
+        if (! is_array($obj)) return [];
+
+        $out = $lines;
+        $echoCount = 0;
+        $translatedCount = 0;
+        foreach ($toTranslate as $i => $src) {
+            $v = $obj[(string) $i] ?? ($obj[$i] ?? null);
+            if (is_string($v) && trim($v) !== '') {
+                $out[$i] = $v;
+                $translatedCount++;
+                if ($sourceLangHint && $sourceLangHint !== $targetLang && self::looksLikeEcho($src, $v)) {
+                    $echoCount++;
+                }
+            }
+        }
+        // If > 30% of the translated lines just echo the source, nudge the model.
+        if ($sourceLangHint && $sourceLangHint !== $targetLang
+            && $translatedCount > 0 && $echoCount / $translatedCount > 0.3) {
+            $retryPrompt = $prompt . "\n\nIMPORTANT: Your previous attempt echoed the source for many lines. "
+                . "The source is DEFINITELY in \"{$sourceLangHint}\", not in \"{$targetLang}\". Translate every word.";
+            $raw2 = $this->postProcess($this->call($retryPrompt, 8192, 0.0));
+            $obj2 = json_decode($raw2, true);
+            if (is_array($obj2)) {
+                foreach ($toTranslate as $i => $src) {
+                    $v = $obj2[(string) $i] ?? ($obj2[$i] ?? null);
+                    if (is_string($v) && trim($v) !== '' && ! self::looksLikeEcho($src, $v)) {
+                        $out[$i] = $v;
+                    }
+                }
+            }
+        }
+        Cache::put($cacheKey, $out, now()->addDays(30));
+        return $out;
+    }
+
+    /** Dispatch to the active provider's adapter. */
+    private function call(string $prompt, int $maxTokens, float $temperature = 0.2): string
+    {
+        $p = $this->activeProvider();
+        if (! $p) return '';
+        try {
+            return match ($p['kind']) {
+                'anthropic' => $this->callAnthropic($p, $prompt, $maxTokens, $temperature),
+                'openai'    => $this->callOpenAI($p, $prompt, $maxTokens, $temperature),
+                default     => $this->callOllama($p, $prompt, $maxTokens, $temperature),
+            };
+        } catch (\Throwable $e) {
+            Log::error('LLM call failed: ' . $e->getMessage(), ['provider' => $p['name'] ?? '?']);
+            return '';
+        }
+    }
+
+    private function callOllama(array $p, string $prompt, int $maxTokens, float $temperature = 0.2): string
+    {
+        $endpoint = rtrim((string) ($p['endpoint'] ?? 'http://localhost:11434'), '/');
+        // Qwen3-style "thinking" models respect /no_think to skip the hidden
+        // reasoning phase. Without it they can exhaust num_predict inside
+        // the thinking block and emit empty content.
+        $taggedPrompt = $prompt . "\n\n/no_think";
+        $resp = Http::timeout(180)->acceptJson()->post($endpoint . '/api/chat', [
+            'model'      => $p['model'],
+            'messages'   => [['role' => 'user', 'content' => $taggedPrompt]],
+            'stream'     => false,
+            'think'      => false,
+            // Keep the model resident for an hour so follow-up requests skip
+            // the cold-start reload (default is 5 minutes). Dramatically
+            // reduces per-click latency for comment/description translation.
+            'keep_alive' => '1h',
+            'options'    => ['num_predict' => $maxTokens, 'temperature' => $temperature],
+        ]);
+        if (! $resp->successful()) {
+            Log::warning('Ollama API error', ['status' => $resp->status(), 'body' => substr($resp->body(), 0, 500)]);
+            return '';
+        }
+        $j = $resp->json();
+        $content = (string) ($j['message']['content'] ?? '');
+        // Some thinking models still ignore the flag and leak <think>…</think>
+        // tags into content. Strip them.
+        $content = preg_replace('/<think>.*?<\/think>\s*/is', '', $content) ?? $content;
+        return trim($content);
+    }
+
+    private function callAnthropic(array $p, string $prompt, int $maxTokens, float $temperature = 0.2): string
+    {
+        $endpoint = rtrim((string) ($p['endpoint'] ?? 'https://api.anthropic.com'), '/');
+        $resp = Http::timeout(120)->withHeaders([
+            'x-api-key'         => (string) $p['api_key'],
+            'anthropic-version' => '2023-06-01',
+            'content-type'      => 'application/json',
+        ])->post($endpoint . '/v1/messages', [
+            'model'       => $p['model'],
+            'max_tokens'  => $maxTokens,
+            'temperature' => $temperature,
+            'messages'    => [['role' => 'user', 'content' => $prompt]],
+        ]);
+        if (! $resp->successful()) {
+            Log::warning('Anthropic API error', ['status' => $resp->status(), 'body' => substr($resp->body(), 0, 500)]);
+            return '';
+        }
+        $j = $resp->json();
+        return (string) ($j['content'][0]['text'] ?? '');
+    }
+
+    private function callOpenAI(array $p, string $prompt, int $maxTokens, float $temperature = 0.2): string
+    {
+        $endpoint = rtrim((string) ($p['endpoint'] ?? 'https://api.openai.com'), '/');
+        $resp = Http::timeout(120)->withToken((string) $p['api_key'])
+            ->acceptJson()
+            ->post($endpoint . '/v1/chat/completions', [
+                'model'       => $p['model'],
+                'messages'    => [['role' => 'user', 'content' => $prompt]],
+                'max_tokens'  => $maxTokens,
+                'temperature' => $temperature,
+            ]);
+        if (! $resp->successful()) {
+            Log::warning('OpenAI API error', ['status' => $resp->status(), 'body' => substr($resp->body(), 0, 500)]);
+            return '';
+        }
+        $j = $resp->json();
+        return (string) ($j['choices'][0]['message']['content'] ?? '');
+    }
+}

app/Services/NasSyncService.php

@@ -67,18 +67,69 @@ class NasSyncService
         return $slug ?: 'video';
     }
 
+    /**
+     * Top-level folder under users/{slug}/ for a video of the given type.
+     * Frozen at upload time — see CLAUDE.md (canonical storage layout).
+     */
+    public function typeFolder(Video $video): string
+    {
+        return match ($video->type) {
+            'music'   => 'music',
+            'match'   => 'sports',
+            default   => 'videos', // generic + any unknown
+        };
+    }
+
+    /**
+     * Track folder name inside a music song folder. Format: {lang}-{db-id}.
+     * For the primary audio (no VideoAudioTrack row), pass null — the videos
+     * row id is used as the track id and the video's primary language as the
+     * language. Always lowercase. Falls back to 'xx' when no language is set.
+     */
+    public function trackFolderName(Video $video, ?VideoAudioTrack $track = null): string
+    {
+        $lang = mb_strtolower(trim((string) ($track ? $track->language : $video->language)));
+        if ($lang === '') $lang = 'xx';
+        $id = $track ? $track->id : $video->id;
+        return "{$lang}-{$id}";
+    }
+
+    /**
+     * Absolute NAS-relative path to a music track's folder. Music only.
+     * Caller must ensure $video->type === 'music'.
+     */
+    public function trackDir(Video $video, ?VideoAudioTrack $track = null): string
+    {
+        return $this->resolveVideoDir($video) . '/tracks/' . $this->trackFolderName($video, $track);
+    }
+
     /**
      * Return the NAS directory for a video.
      *
      * On first sync  → pick a conflict-free slug and create the folder.
      * On subsequent  → find the existing folder by matching video ID in meta.json
      *                  so renames of the title never lose the folder.
+     *
+     * Type-segregated: music → music/, sports → sports/, generic → videos/.
+     * The folder is frozen at first resolution — if the video's path already
+     * points somewhere, that location wins (so type edits don't move files).
      */
     public function resolveVideoDir(Video $video): string
     {
+        // Already organised — trust the stored path verbatim. This keeps legacy
+        // flat layouts working and prevents type edits from relocating files.
+        if (str_starts_with((string) $video->path, 'users/')) {
+            // Walk up past any tracks/{lang-id}/ then file-name segments.
+            $segs = explode('/', $video->path);
+            // Expect users/{slug}/{type-folder}/{video-slug}/...
+            if (count($segs) >= 4) {
+                return implode('/', array_slice($segs, 0, 4));
+            }
+        }
+
         $video->loadMissing('user');
         $userSlug  = $this->userSlug($video->user);
-        $base      = "users/{$userSlug}/videos";
+        $base      = "users/{$userSlug}/" . $this->typeFolder($video);
         $titleSlug = $this->titleSlug($video->title);
 
         // 1. Try the current title slug and numbered variants (-2, -3 …)
@@ -156,20 +207,22 @@ class NasSyncService
      */
     public function localVideoDir(Video $video): string
     {
-        // Already organised — derive from path
-        if (str_starts_with($video->path, 'users/')) {
-            $dir = dirname(storage_path('app/' . $video->path));
-            // If the primary file lives inside a 'tracks/' subfolder (promoted track),
-            // go up one extra level to reach the video root directory.
-            if (basename($dir) === 'tracks') {
-                $dir = dirname($dir);
+        // Already organised — derive from path (respects whichever type folder it
+        // ended up in, even if the type has since been edited).
+        if (str_starts_with((string) $video->path, 'users/')) {
+            $segs = explode('/', $video->path);
+            if (count($segs) >= 4) {
+                return storage_path('app/' . implode('/', array_slice($segs, 0, 4)));
             }
+            // Defensive fallback for malformed legacy paths
+            $dir = dirname(storage_path('app/' . $video->path));
+            if (basename($dir) === 'tracks') $dir = dirname($dir);
             return $dir;
         }
 
         $video->loadMissing('user');
         $userSlug  = $this->userSlug($video->user);
-        $base      = storage_path("app/users/{$userSlug}/videos");
+        $base      = storage_path("app/users/{$userSlug}/" . $this->typeFolder($video));
         $titleSlug = $this->titleSlug($video->title);
 
         for ($i = 1; $i <= 50; $i++) {
@@ -206,60 +259,68 @@ class NasSyncService
 
         $video->loadMissing(['user', 'slides']);
 
-        $dir      = $this->localVideoDir($video);
-        $fileSlug = $this->titleSlug($video->title);
+        $videoDir = $this->localVideoDir($video);                  // users/{slug}/{type-folder}/{slug}
+        $isMusic  = ($video->type === 'music');
+        // Music wraps the primary inside tracks/{lang-id}/; others stay flat.
+        $primaryDir = $isMusic
+            ? $videoDir . '/tracks/' . $this->trackFolderName($video, null)
+            : $videoDir;
 
-        @mkdir($dir, 0755, true);
+        @mkdir($primaryDir, 0755, true);
 
         $userSlug   = $this->userSlug($video->user);
-        $relDir   = 'users/' . $userSlug . '/videos/' . basename($dir);
+        $videoRel   = 'users/' . $userSlug . '/' . $this->typeFolder($video) . '/' . basename($videoDir);
+        $primaryRel = $isMusic
+            ? $videoRel . '/tracks/' . $this->trackFolderName($video, null)
+            : $videoRel;
         $updates    = [];
 
-        // ── Video file ───────────────────────────────────────────────────
+        // ── Video / primary audio file ───────────────────────────────────
         $oldVideoPath = storage_path('app/' . $video->path);
         if (file_exists($oldVideoPath)) {
             $ext         = pathinfo($video->filename, PATHINFO_EXTENSION) ?: 'mp4';
-            $newFileName = "{$fileSlug}.{$ext}";
-            rename($oldVideoPath, "{$dir}/{$newFileName}");
-            $updates['path']     = "{$relDir}/{$newFileName}";
-            $updates['filename'] = $newFileName;
+            $canonical   = ($isMusic ? 'audio' : 'video') . ".{$ext}";
+            rename($oldVideoPath, "{$primaryDir}/{$canonical}");
+            $updates['path']     = "{$primaryRel}/{$canonical}";
+            $updates['filename'] = $canonical;
         }
 
-        // ── Slides (process first; for audio, thumbnail IS slide 0) ──────
+        // ── Slides — music primary track only ────────────────────────────
         $firstSlideRelPath = null;
-        if ($video->slides->isNotEmpty()) {
-            @mkdir("{$dir}/slides", 0755, true);
+        if ($isMusic && $video->slides->isNotEmpty()) {
+            @mkdir("{$primaryDir}/slides", 0755, true);
             foreach ($video->slides->sortBy('position') as $slide) {
                 $oldSlidePath = storage_path('app/public/thumbnails/' . $slide->filename);
                 if (! file_exists($oldSlidePath)) continue;
                 $ext          = pathinfo($slide->filename, PATHINFO_EXTENSION) ?: 'jpg';
-                $newSlideName = "{$slide->id}.{$ext}";
-                rename($oldSlidePath, "{$dir}/slides/{$newSlideName}");
-                $newSlideFilename = "{$relDir}/slides/{$newSlideName}";
+                $newSlideName = "{$slide->position}.{$ext}";
+                rename($oldSlidePath, "{$primaryDir}/slides/{$newSlideName}");
+                $newSlideFilename = "{$primaryRel}/slides/{$newSlideName}";
                 $slide->update(['filename' => $newSlideFilename]);
                 if ($firstSlideRelPath === null) {
                     $firstSlideRelPath = $newSlideFilename;
                 }
             }
-            // For audio uploads the thumbnail is the first slide
             if ($firstSlideRelPath !== null) {
                 $updates['thumbnail'] = $firstSlideRelPath;
             }
         }
 
-        // ── Standalone thumbnail (video uploads, no slides) ──────────────
+        // ── Standalone thumbnail (sports/generic + music-without-slides) ─
         if ($video->thumbnail && ! isset($updates['thumbnail'])) {
             $oldThumbPath = storage_path('app/public/thumbnails/' . $video->thumbnail);
             if (file_exists($oldThumbPath)) {
                 $ext          = pathinfo($video->thumbnail, PATHINFO_EXTENSION) ?: 'jpg';
                 $newThumbName = "thumb.{$ext}";
-                rename($oldThumbPath, "{$dir}/{$newThumbName}");
-                $updates['thumbnail'] = "{$relDir}/{$newThumbName}";
+                $thumbDirAbs  = $isMusic ? $primaryDir : $videoDir;
+                $thumbRelDir  = $isMusic ? $primaryRel : $videoRel;
+                rename($oldThumbPath, "{$thumbDirAbs}/{$newThumbName}");
+                $updates['thumbnail'] = "{$thumbRelDir}/{$newThumbName}";
             }
         }
 
-        // ── meta.json (enables localVideoDir to identify this dir later) ─
-        $this->writeLocalMeta($video, $dir);
+        // ── meta.json (lives at the video / song root, not per-track) ────
+        $this->writeLocalMeta($video, $videoDir);
 
         if (! empty($updates)) {
             $video->update($updates);
@@ -429,6 +490,12 @@ class NasSyncService
     {
         if (file_exists($localPath)) return true;
 
+        // Don't shell out to smbclient when we already know NAS is unreachable
+        // — smbclient hangs ~30 sec on the SMB timeout, multiplied by every
+        // thumbnail/avatar on the page. isEnabled() uses a 2-sec TCP probe
+        // cached for 120 sec, so this fails fast during an outage.
+        if (! $this->isEnabled()) return false;
+
         $dir = dirname($localPath);
         if (! is_dir($dir)) @mkdir($dir, 0755, true);
 
@@ -603,41 +670,46 @@ class NasSyncService
     ): void {
         $video->loadMissing(['user', 'slides']);
 
-        $dir      = $this->resolveVideoDir($video);   // NAS-relative, e.g. users/john/videos/my-video
-        $fileSlug = $this->titleSlug($video->title);
-
-        $this->mkdirp($dir);
+        $videoDir = $this->resolveVideoDir($video);          // users/{slug}/{type-folder}/{slug}
+        $isMusic  = ($video->type === 'music');
+        // Music uses per-track folders. Primary audio + its slides + lyrics live in
+        // tracks/{lang-id}/. Sports + generic stay flat: video.{ext} at the root.
+        $primaryDir = $isMusic
+            ? $videoDir . '/tracks/' . $this->trackFolderName($video, null)
+            : $videoDir;
 
+        $this->mkdirp($primaryDir);
         $updates = [];
 
-        // ── Video file ───────────────────────────────────────────────────
+        // ── Video / primary audio file ───────────────────────────────────
         $ext = pathinfo($video->filename, PATHINFO_EXTENSION) ?: 'mp4';
         if (file_exists($tempVideoPath)) {
-            $ok = $this->putFile($tempVideoPath, "{$dir}/{$fileSlug}.{$ext}");
+            // New canonical name. Music: audio.{ext}. Sports/generic: video.{ext}.
+            $canonical = ($isMusic ? 'audio' : 'video') . ".{$ext}";
+            $nasFile   = "{$primaryDir}/{$canonical}";
+            $ok = $this->putFile($tempVideoPath, $nasFile);
             if (! $ok) {
-                // Leave the local temp file intact so the caller can fall back to local storage
-                throw new \RuntimeException("NAS upload failed for video #{$video->id}: could not push {$fileSlug}.{$ext}");
+                throw new \RuntimeException("NAS upload failed for video #{$video->id}: could not push {$canonical}");
             }
             @unlink($tempVideoPath);
-            $updates['path']     = "{$dir}/{$fileSlug}.{$ext}";
-            $updates['filename'] = "{$fileSlug}.{$ext}";
+            $updates['path']     = $nasFile;
+            $updates['filename'] = $canonical;
         }
 
-        // ── Slides (audio uploads — thumbnail IS the first slide) ────────
+        // ── Slides — music primary track only ────────────────────────────
         $firstSlideNasPath = null;
-        if (! empty($slideAbsPaths)) {
-            $this->mkdirp("{$dir}/slides");
+        if ($isMusic && ! empty($slideAbsPaths)) {
+            $this->mkdirp("{$primaryDir}/slides");
             foreach ($video->slides->sortBy('position') as $slide) {
                 $absPath = $slideAbsPaths[$slide->position] ?? null;
                 if (! $absPath || ! file_exists($absPath)) continue;
                 $slideExt     = pathinfo($absPath, PATHINFO_EXTENSION) ?: 'jpg';
-                $nasSlideFile = "{$dir}/slides/{$slide->position}.{$slideExt}";
+                $nasSlideFile = "{$primaryDir}/slides/{$slide->position}.{$slideExt}";
                 if ($this->putFile($absPath, $nasSlideFile)) {
                     @unlink($absPath);
-                    $slideRelPath = $nasSlideFile;
-                    $slide->update(['filename' => $slideRelPath]);
+                    $slide->update(['filename' => $nasSlideFile]);
                     if ($firstSlideNasPath === null) {
-                        $firstSlideNasPath = $slideRelPath;
+                        $firstSlideNasPath = $nasSlideFile;
                     }
                 }
             }
@@ -646,26 +718,31 @@ class NasSyncService
             }
         }
 
-        // ── Standalone thumbnail (video uploads without slides) ──────────
+        // ── Standalone thumbnail (sports/generic + music-without-slides) ──
         if ($tempThumbPath && file_exists($tempThumbPath) && $firstSlideNasPath === null) {
-            if ($this->putFile($tempThumbPath, "{$dir}/thumb.webp")) {
+            // Music thumb lives next to the primary audio inside the track folder.
+            $thumbDir = $isMusic ? $primaryDir : $videoDir;
+            $thumbExt = pathinfo($tempThumbPath, PATHINFO_EXTENSION) ?: 'webp';
+            $nasThumb = "{$thumbDir}/thumb.{$thumbExt}";
+            if ($this->putFile($tempThumbPath, $nasThumb)) {
                 @unlink($tempThumbPath);
-                $updates['thumbnail'] = "{$dir}/thumb.webp";
+                $updates['thumbnail'] = $nasThumb;
             }
         }
 
-        // ── meta.json ────────────────────────────────────────────────────
+        // ── meta.json (song / video root level, not per-track) ───────────
         $this->putContent(json_encode([
             'id'         => $video->id,
             'user_id'    => $video->user_id,
             'title'      => $video->title,
+            'type'       => $video->type,
             'created_at' => $video->created_at?->toIso8601String(),
-        ], JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE), "{$dir}/meta.json");
+        ], JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE), "{$videoDir}/meta.json");
 
         // File is now on NAS and accessible — mark as ready
         $updates['status'] = 'ready';
 
-        Log::info('NAS: direct upload complete', ['video_id' => $video->id, 'dir' => $dir]);
+        Log::info('NAS: direct upload complete', ['video_id' => $video->id, 'dir' => $videoDir]);
 
         $video->update($updates);
     }
@@ -705,6 +782,17 @@ class NasSyncService
             }
         }
 
+        // lyrics/*.json (source-of-truth; push any local mirror that exists)
+        $video->loadMissing('audioTracks');
+        $lyricsTargets = array_merge([null], $video->audioTracks->all());
+        foreach ($lyricsTargets as $lt) {
+            $localLyrics = $this->lyricsLocalPath($video, $lt);
+            if (is_file($localLyrics)) {
+                $this->mkdirp("{$dir}/lyrics");
+                $this->putFile($localLyrics, $this->lyricsNasPath($video, $lt));
+            }
+        }
+
         // meta.json  (always written last so readMeta can find the folder)
         $this->putContent(json_encode([
             'id'          => $video->id,
@@ -933,6 +1021,7 @@ class NasSyncService
 
     public function mkdirp(string $path): void
     {
+        if (! $this->isEnabled()) return; // fail-fast when NAS unreachable
         $cfg    = $this->cfg();
         $target = escapeshellarg($this->smbTarget($cfg));
         $cred   = escapeshellarg($this->smbCredential($cfg));
@@ -951,6 +1040,7 @@ class NasSyncService
 
     public function putFile(string $localAbsPath, string $nasRelPath): bool
     {
+        if (! $this->isEnabled()) return false; // fail-fast when NAS unreachable
         $cfg    = $this->cfg();
         $target = escapeshellarg($this->smbTarget($cfg));
         $cred   = escapeshellarg($this->smbCredential($cfg));
@@ -976,6 +1066,7 @@ class NasSyncService
 
     public function getContent(string $nasRelPath): ?string
     {
+        if (! $this->isEnabled()) return null; // fail-fast when NAS unreachable
         $cfg    = $this->cfg();
         $target = escapeshellarg($this->smbTarget($cfg));
         $cred   = escapeshellarg($this->smbCredential($cfg));
@@ -994,8 +1085,133 @@ class NasSyncService
         return $content !== false ? $content : null;
     }
 
+    // ── Lyrics (per-track, source-of-truth JSON synced to NAS) ─────────────────
+
+    public function lyricsDir(Video $video): string
+    {
+        // Legacy shared lyrics/ folder location — kept for read-fallback only.
+        // Derived from the stored path (no NAS lookup) — see callers for context.
+        if (str_starts_with((string) $video->path, 'users/')) {
+            $dir = dirname($video->path);
+            if (basename($dir) === 'tracks') $dir = dirname($dir);
+            return $dir . '/lyrics';
+        }
+        return $this->resolveVideoDir($video) . '/lyrics';
+    }
+
+    /**
+     * NAS-relative path for a track's lyrics under the new per-track-folder layout:
+     *   tracks/{lang-id}/lyrics.json
+     * Falls back to the legacy shared lyrics/ folder if the song still uses the
+     * old flat layout (we detect this by checking whether the path passes through
+     * a tracks/ segment).
+     */
+    public function lyricsNasPath(Video $video, ?VideoAudioTrack $track = null): string
+    {
+        // New layout (music with per-track folders).
+        if ($video->type === 'music' && str_starts_with((string) $video->path, 'users/')) {
+            $segs = explode('/', $video->path);
+            // users/{slug}/music/{song-slug}/tracks/{lang-id}/audio.{ext}
+            if (count($segs) >= 6 && $segs[4] === 'tracks') {
+                $songRoot = implode('/', array_slice($segs, 0, 4));
+                $folder   = $this->trackFolderName($video, $track);
+                return "{$songRoot}/tracks/{$folder}/lyrics.json";
+            }
+        }
+        // Legacy fallback — shared lyrics/ folder, keyed by track suffix.
+        $name = $track ? "track-{$track->id}" : 'primary';
+        return $this->lyricsDir($video) . "/{$name}.json";
+    }
+
+    /** Canonical local mirror path for a track's lyrics. */
+    public function lyricsLocalPath(Video $video, ?VideoAudioTrack $track = null): string
+    {
+        return storage_path('app/' . $this->lyricsNasPath($video, $track));
+    }
+
+    /**
+     * Write lyrics JSON for a track. Always writes the local mirror; pushes to
+     * NAS when reachable. Returns false only if the NAS push was attempted and
+     * failed (the local copy is written regardless, so nas:auto-sync can retry).
+     */
+    public function putLyrics(Video $video, ?VideoAudioTrack $track, array $data): bool
+    {
+        $json  = json_encode($data, JSON_UNESCAPED_UNICODE);
+        $local = $this->lyricsLocalPath($video, $track);
+        if (! is_dir(dirname($local))) @mkdir(dirname($local), 0775, true);
+        file_put_contents($local, $json);
+
+        if ($this->isEnabled()) {
+            // Make sure the directory containing this lyrics file exists on NAS.
+            // New layout: tracks/{lang-id}/. Legacy: shared lyrics/ folder.
+            $this->mkdirp(dirname($this->lyricsNasPath($video, $track)));
+            return $this->putContent($json, $this->lyricsNasPath($video, $track));
+        }
+        return true;
+    }
+
+    /**
+     * Read lyrics JSON from the LOCAL mirror only — never touches the NAS.
+     * Use this on hot paths (page render, player-data) so a missing file can't
+     * block the request on smbclient or the port-445 reachability probe. The
+     * lyrics mirror is written by putLyrics() and is never wiped by cache
+     * cleanup, so a song that has lyrics will have them locally.
+     */
+    public function getLocalLyrics(Video $video, ?VideoAudioTrack $track = null): ?array
+    {
+        $local = $this->lyricsLocalPath($video, $track);
+        if (! is_file($local)) {
+            // Read fallback to the legacy shared lyrics/ folder so songs that
+            // haven't been migrated yet still serve their lyrics.
+            $legacy = storage_path('app/' . $this->lyricsDir($video) . '/' . ($track ? "track-{$track->id}" : 'primary') . '.json');
+            if (is_file($legacy)) $local = $legacy;
+        }
+        if (is_file($local)) {
+            $d = json_decode((string) file_get_contents($local), true);
+            if (is_array($d)) return $d;
+        }
+        return null;
+    }
+
+    /**
+     * Remove a track's lyrics from both the local mirror and the NAS. Used by
+     * the owner when the generated lyrics are wrong and they want to start
+     * over — after calling this, the next Generate produces a fresh file.
+     */
+    public function deleteLyrics(Video $video, ?VideoAudioTrack $track = null): void
+    {
+        $local = $this->lyricsLocalPath($video, $track);
+        if (is_file($local)) @unlink($local);
+
+        if ($this->isEnabled()) {
+            try { $this->deleteFile($this->lyricsNasPath($video, $track)); }
+            catch (\Throwable $e) { /* best-effort: local removal is what matters for next regenerate */ }
+        }
+    }
+
+    /** Read lyrics JSON for a track, pulling from NAS into the local mirror if needed. */
+    public function getLyrics(Video $video, ?VideoAudioTrack $track = null): ?array
+    {
+        $local = $this->lyricsLocalPath($video, $track);
+        if (is_file($local)) {
+            $d = json_decode((string) file_get_contents($local), true);
+            if (is_array($d)) return $d;
+        }
+        if ($this->isEnabled()) {
+            $c = $this->getContent($this->lyricsNasPath($video, $track));
+            if ($c !== null) {
+                if (! is_dir(dirname($local))) @mkdir(dirname($local), 0775, true);
+                file_put_contents($local, $c);
+                $d = json_decode($c, true);
+                if (is_array($d)) return $d;
+            }
+        }
+        return null;
+    }
+
     public function deleteFile(string $nasRelPath): void
     {
+        if (! $this->isEnabled()) return; // fail-fast when NAS unreachable
         $cfg    = $this->cfg();
         $target = escapeshellarg($this->smbTarget($cfg));
         $cred   = escapeshellarg($this->smbCredential($cfg));
@@ -1019,6 +1235,7 @@ class NasSyncService
 
     public function deleteFolder(string $nasRelPath): void
     {
+        if (! $this->isEnabled()) return; // fail-fast when NAS unreachable
         $cfg    = $this->cfg();
         $target = escapeshellarg($this->smbTarget($cfg));
         $cred   = escapeshellarg($this->smbCredential($cfg));
@@ -1117,8 +1334,9 @@ class NasSyncService
     /**
      * Rename a path on the NAS share (works for both files and directories).
      */
-    private function renameNasPath(string $oldNasRelPath, string $newNasRelPath): void
+    public function renameNasPath(string $oldNasRelPath, string $newNasRelPath): void
     {
+        if (! $this->isEnabled()) return; // fail-fast when NAS unreachable
         $cfg    = $this->cfg();
         $target = escapeshellarg($this->smbTarget($cfg));
         $cred   = escapeshellarg($this->smbCredential($cfg));

app/Services/VideoMergeService.php

@@ -0,0 +1,350 @@
+<?php
+
+namespace App\Services;
+
+use App\Models\Video;
+use App\Models\VideoAudioTrack;
+use Illuminate\Support\Facades\DB;
+use Illuminate\Support\Facades\Log;
+
+class VideoMergeService
+{
+    public function __construct(private NasSyncService $nas) {}
+
+    /**
+     * Preview counts for merging $source into $target. Read-only.
+     */
+    public function preview(Video $source, Video $target): array
+    {
+        $tracks    = DB::table('video_audio_tracks')->where('video_id', $source->id)->count();
+        $slides    = DB::table('video_slides')->where('video_id', $source->id)->count();
+        $comments  = DB::table('comments')->where('video_id', $source->id)->count();
+        $views     = DB::table('video_views')->where('video_id', $source->id)->count();
+        $downloads = DB::table('video_downloads')->where('video_id', $source->id)->count();
+        $shares    = DB::table('video_shares')->where('video_id', $source->id)->count();
+
+        $srcLikeUsers = DB::table('video_likes')->where('video_id', $source->id)->pluck('user_id');
+        $tgtLikeUsers = DB::table('video_likes')->where('video_id', $target->id)->pluck('user_id')->flip();
+        $newLikes     = $srcLikeUsers->reject(fn ($uid) => $tgtLikeUsers->has($uid))->count();
+
+        $srcPlaylists = DB::table('playlist_videos')->where('video_id', $source->id)->pluck('playlist_id');
+        $tgtPlaylists = DB::table('playlist_videos')->where('video_id', $target->id)->pluck('playlist_id')->flip();
+        $plMerged     = $srcPlaylists->reject(fn ($pid) => $tgtPlaylists->has($pid))->count();
+
+        return [
+            'tracks'             => $tracks + 1, // +1 = source's primary becomes a new track on target
+            'slides'             => $slides,
+            'comments'           => $comments,
+            'views'              => $views,
+            'downloads'          => $downloads,
+            'shares'             => $shares,
+            'likes_source'       => $srcLikeUsers->count(),
+            'likes_after_dedupe' => $newLikes,
+            'playlists_merged'   => $plMerged,
+        ];
+    }
+
+    /**
+     * Merge $source video into $target. Both must be music-type.
+     *
+     * Simplified model: everything under sourceDir moves to targetDir, filename
+     * prefixes are rewritten in one pass, and the user rearranges tracks/slides
+     * in the edit UI afterwards. No special "primary vs extra" bookkeeping.
+     */
+    public function merge(Video $source, Video $target): void
+    {
+        if ($source->id === $target->id) {
+            throw new \InvalidArgumentException('Cannot merge a video with itself.');
+        }
+        if ($source->type !== 'music' || $target->type !== 'music') {
+            throw new \InvalidArgumentException('Only music-type videos can be merged.');
+        }
+        $source->loadMissing(['audioTracks']);
+
+        $sourceDir = $this->nas->resolveVideoDir($source);
+        $targetDir = $this->nas->resolveVideoDir($target);
+
+        if ($sourceDir === $targetDir) {
+            throw new \RuntimeException('Source and target resolve to the same folder — refusing to merge.');
+        }
+
+        // Merge is DB-first: the schema changes always run, and file moves
+        // are best-effort on both sides. When NAS is unreachable, per-track
+        // NAS renames get queued in `pending_nas_moves` and drained by
+        // `nas:auto-sync` once NAS returns.
+        $nasReachable = $this->nas->isEnabled();
+
+        Log::info('Merge: begin', [
+            'source_id'     => $source->id,
+            'target_id'     => $target->id,
+            'source_dir'    => $sourceDir,
+            'target_dir'    => $targetDir,
+            'nas_reachable' => $nasReachable,
+        ]);
+
+        // Ensure target has a tracks/ subfolder — always locally; on NAS
+        // only when it's reachable (mkdirp itself no-ops otherwise).
+        $this->nas->mkdirp("{$targetDir}/tracks");
+        @mkdir(storage_path("app/{$targetDir}/tracks"), 0755, true);
+
+        DB::transaction(function () use ($source, $target, $sourceDir, $targetDir) {
+
+            // ── 1. Promote source's primary audio to a new track on target ─
+            //     Layout-aware: the source may be stored either as the modern
+            //     per-track folder ({sourceDir}/tracks/{srcLang}-{srcVideoId}/…)
+            //     or as the legacy flat layout ({sourceDir}/audio.ext,
+            //     {sourceDir}/slides/, …). We detect which from source->path
+            //     and move only what actually exists in each case.
+            $srcPrimaryPath   = (string) $source->path;
+            $srcPrimaryFolder = $srcPrimaryPath !== '' ? dirname($srcPrimaryPath) : $sourceDir;
+            $srcPrimaryExt    = pathinfo($source->filename ?: ($srcPrimaryPath ?: 'audio.mp3'), PATHINFO_EXTENSION) ?: 'mp3';
+            $srcPrimaryFilename = "audio.{$srcPrimaryExt}";
+
+            $newPrimaryTrack = VideoAudioTrack::create([
+                'video_id'    => $target->id,
+                'language'    => $source->language ?: 'xx',
+                'label'       => $source->title ?: null,
+                'title'       => $source->title ?: null,
+                'description' => $source->description,
+                'filename'    => $srcPrimaryFilename,
+                'path'        => '',
+            ]);
+            if (!$newPrimaryTrack || !$newPrimaryTrack->id) {
+                throw new \RuntimeException('Failed to create promoted primary track record.');
+            }
+
+            $newPrimaryFolder = "{$targetDir}/tracks/" . $this->nas->trackFolderName($target, $newPrimaryTrack);
+            // Case A: primary audio sits in a dedicated per-track folder → one
+            // folder move brings the audio, its slides and its thumb along.
+            // Case B: primary audio sits directly at the video root (legacy) →
+            // move the individual files, since the video root also holds the
+            // extra tracks' subfolders which stay put until step 2.
+            if ($srcPrimaryFolder !== $sourceDir && str_starts_with($srcPrimaryFolder, "{$sourceDir}/tracks/")) {
+                $this->moveFolder($srcPrimaryFolder, $newPrimaryFolder);
+            } else {
+                $this->moveFile($srcPrimaryPath, "{$newPrimaryFolder}/{$srcPrimaryFilename}");
+                // Legacy slides live at {sourceDir}/slides/ as a sibling of audio.
+                if (is_dir(storage_path('app/' . "{$sourceDir}/slides"))) {
+                    $this->moveFolder("{$sourceDir}/slides", "{$newPrimaryFolder}/slides");
+                }
+                // Opportunistically move thumb.{ext} if present.
+                foreach (['jpg', 'jpeg', 'png', 'webp'] as $ext) {
+                    $thumb = "{$sourceDir}/thumb.{$ext}";
+                    if (file_exists(storage_path('app/' . $thumb))) {
+                        $this->moveFile($thumb, "{$newPrimaryFolder}/thumb.{$ext}");
+                    }
+                }
+                // Legacy primary lyrics live at {sourceDir}/lyrics/primary.json.
+                // The new per-track layout stores lyrics at
+                // {newPrimaryFolder}/lyrics.json — move the file so lyricsNasPath
+                // on the target resolves it immediately.
+                $legacyPrimaryLyrics = "{$sourceDir}/lyrics/primary.json";
+                if (file_exists(storage_path('app/' . $legacyPrimaryLyrics))) {
+                    $this->moveFile($legacyPrimaryLyrics, "{$newPrimaryFolder}/lyrics.json");
+                }
+            }
+            $newPrimaryTrack->update(['path' => "{$newPrimaryFolder}/{$srcPrimaryFilename}"]);
+
+            // ── 2. Move each source extra track's folder into target/tracks/
+            //     The folder basename ({lang}-{track_id}) is globally unique
+            //     because track ids are globally unique — no collisions with
+            //     target's own tracks. We derive the actual old folder from
+            //     the track's stored path so unusual layouts still work.
+            foreach ($source->audioTracks as $track) {
+                $oldFolder = $track->path ? dirname($track->path) : "{$sourceDir}/tracks/" . $this->nas->trackFolderName($source, $track);
+                $newFolder = "{$targetDir}/tracks/" . $this->nas->trackFolderName($source, $track);
+                if ($oldFolder !== $newFolder) {
+                    $this->moveFolder($oldFolder, $newFolder);
+                }
+
+                $newTrackPath = $track->path && str_starts_with($track->path, $oldFolder . '/')
+                    ? $newFolder . '/' . substr($track->path, strlen($oldFolder) + 1)
+                    : "{$newFolder}/" . ($track->filename ?: 'audio.mp3');
+
+                $track->video_id = $target->id;
+                $track->path     = $newTrackPath;
+                $track->save();
+
+                // Legacy per-track lyrics live at {sourceDir}/lyrics/track-{id}.json.
+                // In the new layout they belong inside the moved track folder.
+                $legacyTrackLyrics = "{$sourceDir}/lyrics/track-{$track->id}.json";
+                if (file_exists(storage_path('app/' . $legacyTrackLyrics))) {
+                    $this->moveFile($legacyTrackLyrics, "{$newFolder}/lyrics.json");
+                }
+            }
+
+            // ── 3. Rewrite every source slide's filename to its new on-disk
+            //     location, derived from the track it belongs to AFTER the
+            //     per-track folder moves above. This is layout-agnostic —
+            //     it works for both new (/tracks/{lang-id}/slides/N) and
+            //     legacy (/{sourceDir}/slides/N) source layouts.
+            $updatedTracks = VideoAudioTrack::where('video_id', $target->id)->get()->keyBy('id');
+            $slides = DB::table('video_slides')->where('video_id', $source->id)->get();
+            foreach ($slides as $s) {
+                $base = $s->filename ? basename($s->filename) : null;
+                if (!$base) continue; // nothing we can safely rewrite
+
+                $owningTrackId = $s->audio_track_id === null ? $newPrimaryTrack->id : $s->audio_track_id;
+                $owningTrack   = $updatedTracks->get($owningTrackId);
+                $owningFolder  = $owningTrack && $owningTrack->path ? dirname($owningTrack->path) : $newPrimaryFolder;
+
+                $updates = [
+                    'video_id' => $target->id,
+                    'filename' => "{$owningFolder}/slides/{$base}",
+                ];
+                if ($s->audio_track_id === null) {
+                    $updates['audio_track_id'] = $newPrimaryTrack->id;
+                }
+                DB::table('video_slides')->where('id', $s->id)->update($updates);
+            }
+
+            // ── 4. Re-parent comments / views / downloads / shares ─────────
+            DB::table('comments')->where('video_id', $source->id)->update(['video_id' => $target->id]);
+            DB::table('video_views')->where('video_id', $source->id)->update(['video_id' => $target->id]);
+            DB::table('video_downloads')->where('video_id', $source->id)->update(['video_id' => $target->id]);
+            DB::table('video_shares')->where('video_id', $source->id)->update(['video_id' => $target->id]);
+
+            // ── 5. Likes — dedupe by user_id ────────────────────────────────
+            $existingLikeUsers = DB::table('video_likes')->where('video_id', $target->id)->pluck('user_id')->all();
+            if (!empty($existingLikeUsers)) {
+                DB::table('video_likes')
+                    ->where('video_id', $source->id)
+                    ->whereIn('user_id', $existingLikeUsers)
+                    ->delete();
+            }
+            DB::table('video_likes')->where('video_id', $source->id)->update(['video_id' => $target->id]);
+
+            // ── 6. Playlist pivots — dedupe by playlist_id ─────────────────
+            $existingPlaylists = DB::table('playlist_videos')->where('video_id', $target->id)->pluck('playlist_id')->all();
+            if (!empty($existingPlaylists)) {
+                DB::table('playlist_videos')
+                    ->where('video_id', $source->id)
+                    ->whereIn('playlist_id', $existingPlaylists)
+                    ->delete();
+            }
+            DB::table('playlist_videos')->where('video_id', $source->id)->update(['video_id' => $target->id]);
+
+            // ── 7. Counters ────────────────────────────────────────────────
+            DB::table('videos')->where('id', $target->id)->update([
+                'download_count' => DB::raw('COALESCE(download_count,0) + ' . (int) $source->download_count),
+                'share_count'    => DB::raw('COALESCE(share_count,0) + ' . (int) $source->share_count),
+            ]);
+
+            // ── 8. Redirect row (remember source folder for later repair) ──
+            DB::table('video_redirects')->insert([
+                'source_id'     => $source->id,
+                'target_id'     => $target->id,
+                'source_folder' => $sourceDir,
+                'created_at'    => now(),
+            ]);
+
+            // ── 9. Delete source video row ─────────────────────────────────
+            DB::table('videos')->where('id', $source->id)->delete();
+        });
+
+        // ── 10. Best-effort cleanup of the emptied source folder ───────────
+        //     The legacy lyrics/ sibling is tidied first so pruneEmptyFolder's
+        //     rmdir on sourceDir can succeed.
+        $this->pruneEmptyFolder("{$sourceDir}/lyrics");
+        $this->pruneEmptyFolder("{$sourceDir}/tracks");
+        $this->pruneEmptyFolder($sourceDir);
+
+        Log::info('Merge: complete', ['source_id' => $source->id, 'target_id' => $target->id]);
+    }
+
+    /**
+     * Move an individual file (not a directory) on NAS + local. Needed for
+     * legacy-layout sources where the primary audio and thumb live directly
+     * in the video root rather than inside a per-track subfolder.
+     */
+    private function moveFile(string $oldRel, string $newRel): void
+    {
+        if ($oldRel === '' || $newRel === '' || $oldRel === $newRel) return;
+
+        $nasMoved = false;
+        if ($this->nas->isEnabled()) {
+            $this->nas->mkdirp(dirname($newRel));
+            $this->nas->renameNasPath($oldRel, $newRel);
+            $nasMoved = true;
+        } else {
+            DB::table('pending_nas_moves')->insert([
+                'from_path'  => $oldRel,
+                'to_path'    => $newRel,
+                'kind'       => 'file',
+                'origin'     => 'merge',
+                'created_at' => now(),
+                'updated_at' => now(),
+            ]);
+        }
+
+        $oldLocal = storage_path('app/' . $oldRel);
+        $newLocal = storage_path('app/' . $newRel);
+        $localMoved = false;
+        if (is_file($oldLocal)) {
+            @mkdir(dirname($newLocal), 0755, true);
+            $localMoved = @rename($oldLocal, $newLocal);
+        }
+        Log::info('Merge: moveFile', [
+            'old' => $oldRel, 'new' => $newRel,
+            'nas' => $nasMoved, 'local' => $localMoved,
+            'queued' => !$nasMoved,
+        ]);
+    }
+
+    /**
+     * Move a folder on both NAS and local disk. NAS ops are queued in
+     * pending_nas_moves when NAS is unreachable; nas:auto-sync drains them.
+     */
+    private function moveFolder(string $oldRel, string $newRel): void
+    {
+        if ($oldRel === $newRel) return;
+
+        $nasMoved = false;
+        if ($this->nas->isEnabled()) {
+            $this->nas->renameNasPath($oldRel, $newRel);
+            $nasMoved = true;
+        } else {
+            // Queue for later — nas:auto-sync will do the rename when NAS is back.
+            DB::table('pending_nas_moves')->insert([
+                'from_path'  => $oldRel,
+                'to_path'    => $newRel,
+                'kind'       => 'folder',
+                'origin'     => 'merge',
+                'created_at' => now(),
+                'updated_at' => now(),
+            ]);
+        }
+
+        $oldLocal = storage_path('app/' . $oldRel);
+        $newLocal = storage_path('app/' . $newRel);
+        $localMoved = false;
+        if (is_dir($oldLocal)) {
+            @mkdir(dirname($newLocal), 0755, true);
+            $localMoved = @rename($oldLocal, $newLocal);
+        }
+        Log::info('Merge: moveFolder', [
+            'old' => $oldRel, 'new' => $newRel,
+            'nas' => $nasMoved, 'local' => $localMoved,
+            'queued' => !$nasMoved,
+        ]);
+    }
+
+    private function pruneEmptyFolder(string $rel): void
+    {
+        if ($this->nas->isEnabled()) {
+            $this->nas->deleteFile("{$rel}/meta.json");
+            $this->nas->deleteFolder($rel);
+        }
+        // If NAS was unreachable we DON'T queue a delete: after auto-sync
+        // drains the pending moves, the leftover source folder will be
+        // empty and can be reaped by a subsequent housekeeping pass (or by
+        // the videos:repair-merged command). Deleting a folder we haven't
+        // yet emptied would blow away data.
+
+        $local = storage_path('app/' . $rel);
+        if (is_dir($local)) {
+            @unlink($local . '/meta.json');
+            @rmdir($local);
+        }
+    }
+}

app/Support/EmailThumbnail.php

@@ -0,0 +1,59 @@
+<?php
+
+namespace App\Support;
+
+use App\Models\Video;
+use App\Services\NasSyncService;
+
+/**
+ * Resolves a video's thumbnail to a local absolute file path so it can be
+ * embedded inline (CID) in transactional emails.
+ *
+ * Remote mail clients (notably Gmail's image proxy) cannot reliably fetch the
+ * dynamic /media/thumbnails route — it sits behind Cloudflare and PHP, so the
+ * proxy may be challenged or time out, leaving a broken image. Embedding the
+ * bytes directly in the message removes that external dependency entirely.
+ */
+class EmailThumbnail
+{
+    public static function localPath(?Video $video): ?string
+    {
+        if (! $video || ! $video->thumbnail) {
+            return null;
+        }
+
+        $thumb = $video->thumbnail;
+        $nas   = app(NasSyncService::class);
+
+        // NAS-mirrored path format: "users/{slug}/videos/{song}/…"
+        if (str_starts_with($thumb, 'users/')) {
+            $local = storage_path('app/' . $thumb);
+            if (file_exists($local)) {
+                return $local;
+            }
+
+            @mkdir(dirname($local), 0755, true);
+
+            // The DB path mirrors the NAS path exactly — try it directly first.
+            if ($nas->ensureLocalAsset($local, $thumb)) {
+                return $local;
+            }
+
+            // Extension may differ on NAS (e.g. canonical thumb.webp).
+            $dir = $nas->resolveVideoDir($video);
+            $ext = pathinfo($thumb, PATHINFO_EXTENSION) ?: 'jpg';
+            foreach (["thumb.webp", "thumb.{$ext}"] as $nasFile) {
+                if ($nas->ensureLocalAsset($local, "{$dir}/{$nasFile}")) {
+                    return $local;
+                }
+            }
+
+            return file_exists($local) ? $local : null;
+        }
+
+        // Legacy flat filename format.
+        $local = storage_path('app/public/thumbnails/' . $thumb);
+
+        return file_exists($local) ? $local : null;
+    }
+}

app/Support/HtmlSanitizer.php

@@ -77,6 +77,11 @@ class HtmlSanitizer
     /**
      * Produce safe display HTML. Legacy plain-text values (no tags) are
      * escaped and converted to <br>; rich values are run through clean().
+     *
+     * Also detects a handful of common markdown-ish prefixes that leaked
+     * in through AI-generated descriptions ("## Letra", "### Chorus") and
+     * turns them into real <h2>/<h3> tags before sanitising. Without this
+     * step a reader saw literal "## Letra" instead of a heading.
      */
     public static function render(?string $value): string
     {
@@ -85,6 +90,8 @@ class HtmlSanitizer
             return '';
         }
 
+        $value = self::promoteLeakedMarkdown($value);
+
         if (strip_tags($value) === $value) {
             return nl2br(e($value), false);
         }
@@ -92,6 +99,24 @@ class HtmlSanitizer
         return self::clean($value);
     }
 
+    /**
+     * Convert markdown-style heading prefixes at the start of a line into
+     * real HTML tags, so the sanitiser can keep them. Only touches lines
+     * that start with ##, ###, or **…**; everything else is untouched.
+     */
+    private static function promoteLeakedMarkdown(string $value): string
+    {
+        $lines = preg_split("/\r?\n/", $value);
+        foreach ($lines as $i => $line) {
+            if (preg_match('/^\s*###\s+(.+?)\s*$/u', $line, $m)) {
+                $lines[$i] = '<h3>' . e($m[1]) . '</h3>';
+            } elseif (preg_match('/^\s*##\s+(.+?)\s*$/u', $line, $m)) {
+                $lines[$i] = '<h2>' . e($m[1]) . '</h2>';
+            }
+        }
+        return implode("\n", $lines);
+    }
+
     private static function sanitizeChildren(DOMNode $node): void
     {
         foreach (iterator_to_array($node->childNodes) as $child) {

app/Support/LyricsAss.php

@@ -0,0 +1,109 @@
+<?php
+
+namespace App\Support;
+
+/**
+ * Build an ASS (Advanced SubStation Alpha) subtitle file with word-level
+ * karaoke timing from a lyrics JSON payload (the shape produced by
+ * ml/transcribe.py). Burned into the downloadable mp4 via libass.
+ *
+ * Karaoke fill uses ASS \k tags: each word's \k duration (centiseconds) is the
+ * time it waits before the highlight reaches it, so the cumulative \k before a
+ * word equals its onset relative to the line start. PrimaryColour is the sung
+ * (filled) colour, SecondaryColour the not-yet-sung colour.
+ */
+class LyricsAss
+{
+    /** Render at the same canvas the slideshow uses. */
+    private const W = 1280;
+    private const H = 720;
+
+    /**
+     * Write an .ass file for the given lyrics data. Returns true on success,
+     * false when there are no usable timed lines (caller should skip burning).
+     */
+    public static function write(array $lyrics, string $outPath): bool
+    {
+        $lines = $lyrics['lines'] ?? [];
+        if (! is_array($lines) || ! $lines) return false;
+
+        $events = [];
+        foreach ($lines as $ln) {
+            $start = $ln['start'] ?? null;
+            $end   = $ln['end'] ?? null;
+            if ($start === null || $end === null) continue;
+
+            $words = (isset($ln['words']) && is_array($ln['words']) && $ln['words']) ? $ln['words'] : null;
+            $text  = $words
+                ? self::karaokeText($words, (float) $start)
+                : self::escape((string) ($ln['text'] ?? ''));
+            if ($text === '') continue;
+
+            // Hold the line a touch past its last word for readability.
+            // Fields per the Format line: Layer,Start,End,Style,Name,MarginL,MarginR,Effect,Text
+            $events[] = 'Dialogue: 0,' . self::ts((float) $start) . ',' . self::ts((float) $end + 0.4)
+                . ',Lyrics,,0,0,,' . $text;
+        }
+        if (! $events) return false;
+
+        $ass = self::header() . implode("\n", $events) . "\n";
+        return file_put_contents($outPath, $ass) !== false;
+    }
+
+    private static function karaokeText(array $words, float $lineStart): string
+    {
+        $out  = '';
+        $lead = (int) round((((float) $words[0]['start']) - $lineStart) * 100);
+        if ($lead > 0) $out .= '{\k' . $lead . '}';
+
+        $n = count($words);
+        foreach ($words as $i => $w) {
+            $wStart = (float) $w['start'];
+            $wEnd   = (float) $w['end'];
+            $dur    = max(1, (int) round(($wEnd - $wStart) * 100));
+            $out   .= '{\k' . $dur . '}' . self::escape((string) $w['text']);
+
+            if ($i < $n - 1) {
+                $gap = (int) round((((float) $words[$i + 1]['start']) - $wEnd) * 100);
+                $out .= ($gap > 0 ? '{\k' . $gap . '}' : '') . ' ';
+            }
+        }
+        return $out;
+    }
+
+    /** ASS timestamp: H:MM:SS.cc (centiseconds). */
+    private static function ts(float $t): string
+    {
+        if ($t < 0) $t = 0;
+        $cs = (int) round($t * 100);
+        $h  = intdiv($cs, 360000);
+        $m  = intdiv($cs % 360000, 6000);
+        $s  = intdiv($cs % 6000, 100);
+        $c  = $cs % 100;
+        return sprintf('%d:%02d:%02d.%02d', $h, $m, $s, $c);
+    }
+
+    private static function escape(string $s): string
+    {
+        // Strip ASS override delimiters and collapse newlines.
+        $s = str_replace(['{', '}', '\\'], ['(', ')', '/'], $s);
+        return str_replace(["\r\n", "\n", "\r"], ' ', $s);
+    }
+
+    private static function header(): string
+    {
+        // Colours are &HAABBGGRR. Primary = sung (white), Secondary = unsung
+        // (translucent grey), heavy outline + shadow for legibility over artwork.
+        return "[Script Info]\n"
+            . "ScriptType: v4.00+\n"
+            . 'PlayResX: ' . self::W . "\n"
+            . 'PlayResY: ' . self::H . "\n"
+            . "WrapStyle: 0\n"
+            . "ScaledBorderAndShadow: yes\n\n"
+            . "[V4+ Styles]\n"
+            . "Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding\n"
+            . "Style: Lyrics,Sans,54,&H00FFFFFF,&H64C8C8C8,&H00101010,&H80000000,-1,0,0,0,100,100,0,0,1,3,2,2,80,80,70,1\n\n"
+            . "[Events]\n"
+            . "Format: Layer, Start, End, Style, Name, MarginL, MarginR, Effect, Text\n";
+    }
+}

app/Support/LyricsDescriptionParser.php

@@ -0,0 +1,144 @@
+<?php
+
+namespace App\Support;
+
+/**
+ * Extract clean lyric lines from a video's free-text description.
+ *
+ * Many users paste the song's lyrics into the description with section markers,
+ * emoji decorations, instrument tags, etc. When that's present we want to USE
+ * those exact lines (and let the pipeline only do the *sync*, not the
+ * transcription), because they're far more accurate than anything Whisper can
+ * derive from sung audio.
+ *
+ * Returns an empty array when no usable lyric block is found.
+ */
+class LyricsDescriptionParser
+{
+    /** Heuristic threshold: descriptions with fewer cleaned lines aren't worth aligning. */
+    private const MIN_LYRIC_LINES = 4;
+
+    public static function extract(?string $desc): array
+    {
+        if (! $desc) return [];
+
+        // HTML descriptions use <br> for line breaks — convert those (and other
+        // block-ending tags) into real newlines BEFORE stripping tags, otherwise
+        // the entire body collapses into one long run-on line.
+        // Heading tags (<h1>…<h6>) carry the song title — drop their content
+        // entirely so the title never leaks into the lyric list.
+        $text = preg_replace('/<\s*h[1-6][^>]*>.*?<\s*\/\s*h[1-6]\s*>/isu', "\n", $desc);
+        $text = preg_replace('/<\s*br\s*\/?>/i', "\n", $text);
+        $text = preg_replace('/<\s*\/\s*(p|div|li|tr|blockquote)\s*>/i', "\n", $text);
+        $text = strip_tags($text);
+        // Decode HTML entities (&nbsp;, &amp;, etc.) so the comparison later isn't fooled.
+        $text = html_entity_decode($text, ENT_QUOTES | ENT_HTML5, 'UTF-8');
+        $text = preg_replace('/\r\n|\r/u', "\n", $text);
+
+        // First pass: clean each line and flag section headers (Verse / Ritornello
+        // / Bridge / etc.) so they can be dropped — those aren't sung.
+        $cleaned = [];
+        foreach (explode("\n", $text) as $line) {
+            $line = self::cleanLine($line);
+            if ($line === null) continue;
+            $cleaned[] = ['text' => $line, 'header' => self::isSectionHeader($line)];
+        }
+
+        // Title detection: if the first non-header line is immediately followed by
+        // a section header (e.g. "Figlio Mio — Viaggio di Vita" then "Verso 1"),
+        // that first line is the song title — drop it too.
+        $firstIdx = null;
+        foreach ($cleaned as $i => $c) {
+            if (! $c['header']) { $firstIdx = $i; break; }
+        }
+        $dropTitle = false;
+        if ($firstIdx !== null) {
+            for ($j = $firstIdx + 1; $j < count($cleaned); $j++) {
+                if ($cleaned[$j]['header']) { $dropTitle = true; break; }
+                break; // first thing after is a real lyric line → not a title block
+            }
+        }
+
+        $out = [];
+        foreach ($cleaned as $i => $c) {
+            if ($c['header']) continue;
+            if ($dropTitle && $i === $firstIdx) continue;
+            $out[] = $c['text'];
+        }
+
+        // Avoid mistakenly aligning non-lyric descriptions (a credit line, a URL,
+        // etc.). Require at least a handful of plausible lyric lines.
+        if (count($out) < self::MIN_LYRIC_LINES) return [];
+
+        return $out;
+    }
+
+    /**
+     * True when a line is a section marker (Verse / Chorus / Bridge / Outro /
+     * their many translations) rather than a sung lyric. Matches the WHOLE line
+     * so a real lyric containing one of these words isn't mistakenly dropped.
+     */
+    private static function isSectionHeader(string $line): bool
+    {
+        $t = mb_strtolower(trim($line));
+        if ($t === '') return false;
+
+        $roots = [
+            'intro', 'outro', 'interlude', 'instrumental',
+            'verse', 'verso', 'verset', 'couplet', 'estrofa', 'strofa',
+            'chorus', 'ritornello', 'refrain', 'refrão', 'refrao', 'coro', 'estribillo',
+            'pre[\s\-]?chorus', 'pre[\s\-]?ritornello', 'pre[\s\-]?coro',
+            'pre[\s\-]?refrain', 'pre[\s\-]?refrão', 'pré[\s\-]?refrain',
+            'bridge', 'ponte', 'puente', 'pont', 'brücke', 'brucke',
+            'hook', 'drop', 'breakdown', 'tag', 'vamp', 'coda', 'reprise',
+            // CJK / Thai / Arabic / Korean
+            'サビ', 'コーラス', 'バース', 'ブリッジ', 'イントロ', 'アウトロ', 'フック', '間奏',
+            'ท่อน', 'คอรัส', 'ฮุก', 'บริดจ์', 'อินโทร', 'เอาท์โทร',
+            '前奏', '副歌', '桥段', '主歌', '尾奏',
+            'كورس', 'بريدج', 'كوبليه',
+            '후렴', '브릿지', '인트로', '아웃트로', '훅',
+        ];
+        $rootRe = implode('|', $roots);
+        // Optional trailing number, "final/finale/reprise", roman numerals.
+        $pattern = '/^(?:' . $rootRe . ')[\s\d:\-—\.]*(?:final|finale|reprise|ii|iii|iv|v|vi|2|3|4|5)?\s*$/iu';
+        return (bool) preg_match($pattern, $t);
+    }
+
+    /** Returns the cleaned line, or null if it should be discarded. */
+    private static function cleanLine(string $line): ?string
+    {
+        $line = trim($line);
+        if ($line === '') return null;
+
+        // Strip markdown emphasis (* _ ~) and leading list bullets / quote markers.
+        $line = preg_replace('/^[\s>\-\*•♪♫·]+/u', '', $line);
+        $line = preg_replace('/[\*_~`]+/u', '', $line);
+
+        // Drop instrument / section annotations inside Japanese-style brackets:
+        // 【 箏・尺八・篠笛・優しい歌声 】 — these aren't lyrics.
+        $line = preg_replace('/【[^】]*】/u', '', $line);
+        $line = preg_replace('/〔[^〕]*〕/u', '', $line);
+        $line = preg_replace('/\[\[[^\]]*\]\]/u', '', $line);
+
+        // Strip emoji / pictographic symbols and the invisible glue that often
+        // sticks to them (variation selectors, ZWJ) so nothing leaves behind a
+        // bare diacritic when the visible emoji is removed.
+        $line = preg_replace(
+            '/[\x{1F000}-\x{1FFFF}\x{2600}-\x{27BF}\x{2B00}-\x{2BFF}\x{0F3A}-\x{0F3D}\x{FE00}-\x{FE0F}\x{200B}-\x{200F}\x{2060}]/u',
+            '', $line
+        );
+
+        // Collapse internal whitespace.
+        $line = preg_replace('/\s+/u', ' ', $line);
+        $line = trim($line);
+
+        if ($line === '') return null;
+
+        // Must contain at least one letter (Unicode), and at least 3 characters
+        // after stripping — discards "🌸 平穏 🌸" (header) and "──" separators.
+        if (! preg_match('/\p{L}/u', $line)) return null;
+        if (mb_strlen($line) < 3) return null;
+
+        return $line;
+    }
+}

app/Support/SafeNotifier.php

@@ -0,0 +1,43 @@
+<?php
+
+namespace App\Support;
+
+use Illuminate\Notifications\Notification;
+use Illuminate\Support\Facades\Log;
+
+/**
+ * Notification failures (SMTP down, Gmail 535, Mailgun 4xx, etc.) must never
+ * crash a user-facing request. Everywhere we previously did
+ *
+ *     $user->notify(new SomeNotification(...));
+ *
+ * we now do
+ *
+ *     SafeNotifier::send($user, new SomeNotification(...));
+ *
+ * which runs the same code, catches any Throwable, and writes a warning line
+ * so ops still has the signal.
+ */
+class SafeNotifier
+{
+    /**
+     * @param mixed $notifiable  Anything with ->notify(), usually a User.
+     */
+    public static function send(mixed $notifiable, Notification $notification): void
+    {
+        if (! $notifiable || ! is_object($notifiable) || ! method_exists($notifiable, 'notify')) {
+            return;
+        }
+
+        try {
+            $notifiable->notify($notification);
+        } catch (\Throwable $e) {
+            Log::warning('notification send failed', [
+                'notification' => $notification::class,
+                'notifiable'   => $notifiable::class,
+                'notifiable_id'=> $notifiable->getKey() ?? null,
+                'error'        => $e->getMessage(),
+            ]);
+        }
+    }
+}

bin/browsershot-node.sh

@@ -0,0 +1,7 @@
+#!/bin/sh
+# Wraps `node` with a raised file-descriptor limit. PHP-FPM starts with
+# rlimit_files=1024; Chromium opens ~2000 fds on startup and dies before
+# Puppeteer can attach, surfacing as "Failed to launch the browser
+# process: Code: null". Bumping just this subprocess tree avoids
+# restarting FPM to raise the pool-wide limit.
+exec /usr/bin/prlimit --nofile=65536 /usr/bin/node "$@"

bootstrap/app.php

@@ -15,6 +15,14 @@ $app = new Illuminate\Foundation\Application(
     $_ENV['APP_BASE_PATH'] ?? dirname(__DIR__)
 );
 
+// Framework storage directory lives at base_path('data') instead of the default
+// base_path('storage'). This keeps the project tree free of two "storage"
+// entries — the only `storage` visible is the public-facing symlink at
+// public/storage (→ data/app/public). All Laravel storage_path() calls,
+// session/cache/log/view writes, and the local NAS file cache resolve through
+// here transparently.
+$app->useStoragePath(base_path('data'));
+
 /*
 |--------------------------------------------------------------------------
 | Bind Important Interfaces

composer.json

@@ -14,7 +14,8 @@
         "laravel/tinker": "^2.8",
         "p7h/nas-file-manager": "dev-main",
         "php-ffmpeg/php-ffmpeg": "^1.4",
-        "pragmarx/google2fa-laravel": "^3.0"
+        "pragmarx/google2fa-laravel": "^3.0",
+        "spatie/browsershot": "^3.61"
     },
     "require-dev": {
         "fakerphp/faker": "^1.9.1",

composer.lock

@@ -4,7 +4,7 @@
         "Read more about it at https://getcomposer.org/doc/01-basic-usage.md#installing-dependencies",
         "This file is @generated automatically"
     ],
-    "content-hash": "40fa327b55e9b6fafab4b2da3f763724",
+    "content-hash": "bdb64417cd2491642a0712fe40bade22",
     "packages": [
         {
             "name": "bacon/bacon-qr-code",
@@ -1457,6 +1457,90 @@
             ],
             "time": "2025-08-22T14:27:06+00:00"
         },
+        {
+            "name": "intervention/image",
+            "version": "2.7.2",
+            "source": {
+                "type": "git",
+                "url": "https://github.com/Intervention/image.git",
+                "reference": "04be355f8d6734c826045d02a1079ad658322dad"
+            },
+            "dist": {
+                "type": "zip",
+                "url": "https://api.github.com/repos/Intervention/image/zipball/04be355f8d6734c826045d02a1079ad658322dad",
+                "reference": "04be355f8d6734c826045d02a1079ad658322dad",
+                "shasum": ""
+            },
+            "require": {
+                "ext-fileinfo": "*",
+                "guzzlehttp/psr7": "~1.1 || ^2.0",
+                "php": ">=5.4.0"
+            },
+            "require-dev": {
+                "mockery/mockery": "~0.9.2",
+                "phpunit/phpunit": "^4.8 || ^5.7 || ^7.5.15"
+            },
+            "suggest": {
+                "ext-gd": "to use GD library based image processing.",
+                "ext-imagick": "to use Imagick based image processing.",
+                "intervention/imagecache": "Caching extension for the Intervention Image library"
+            },
+            "type": "library",
+            "extra": {
+                "laravel": {
+                    "aliases": {
+                        "Image": "Intervention\\Image\\Facades\\Image"
+                    },
+                    "providers": [
+                        "Intervention\\Image\\ImageServiceProvider"
+                    ]
+                },
+                "branch-alias": {
+                    "dev-master": "2.4-dev"
+                }
+            },
+            "autoload": {
+                "psr-4": {
+                    "Intervention\\Image\\": "src/Intervention/Image"
+                }
+            },
+            "notification-url": "https://packagist.org/downloads/",
+            "license": [
+                "MIT"
+            ],
+            "authors": [
+                {
+                    "name": "Oliver Vogel",
+                    "email": "[email protected]",
+                    "homepage": "https://intervention.io/"
+                }
+            ],
+            "description": "Image handling and manipulation library with support for Laravel integration",
+            "homepage": "http://image.intervention.io/",
+            "keywords": [
+                "gd",
+                "image",
+                "imagick",
+                "laravel",
+                "thumbnail",
+                "watermark"
+            ],
+            "support": {
+                "issues": "https://github.com/Intervention/image/issues",
+                "source": "https://github.com/Intervention/image/tree/2.7.2"
+            },
+            "funding": [
+                {
+                    "url": "https://paypal.me/interventionio",
+                    "type": "custom"
+                },
+                {
+                    "url": "https://github.com/Intervention",
+                    "type": "github"
+                }
+            ],
+            "time": "2022-05-21T17:30:32+00:00"
+        },
         {
             "name": "laravel/framework",
             "version": "10.50.2",
@@ -2237,6 +2321,71 @@
             },
             "time": "2026-01-23T15:30:45+00:00"
         },
+        {
+            "name": "league/glide",
+            "version": "2.3.2",
+            "source": {
+                "type": "git",
+                "url": "https://github.com/thephpleague/glide.git",
+                "reference": "b8e946dd87c79a9dce3290707ab90b5b52602813"
+            },
+            "dist": {
+                "type": "zip",
+                "url": "https://api.github.com/repos/thephpleague/glide/zipball/b8e946dd87c79a9dce3290707ab90b5b52602813",
+                "reference": "b8e946dd87c79a9dce3290707ab90b5b52602813",
+                "shasum": ""
+            },
+            "require": {
+                "intervention/image": "^2.7",
+                "league/flysystem": "^2.0|^3.0",
+                "php": "^7.2|^8.0",
+                "psr/http-message": "^1.0|^2.0"
+            },
+            "require-dev": {
+                "mockery/mockery": "^1.3.3",
+                "phpunit/php-token-stream": "^3.1|^4.0",
+                "phpunit/phpunit": "^8.5|^9.0"
+            },
+            "type": "library",
+            "autoload": {
+                "psr-4": {
+                    "League\\Glide\\": "src/"
+                }
+            },
+            "notification-url": "https://packagist.org/downloads/",
+            "license": [
+                "MIT"
+            ],
+            "authors": [
+                {
+                    "name": "Jonathan Reinink",
+                    "email": "[email protected]",
+                    "homepage": "http://reinink.ca"
+                },
+                {
+                    "name": "Titouan Galopin",
+                    "email": "[email protected]",
+                    "homepage": "https://titouangalopin.com"
+                }
+            ],
+            "description": "Wonderfully easy on-demand image manipulation library with an HTTP based API.",
+            "homepage": "http://glide.thephpleague.com",
+            "keywords": [
+                "ImageMagick",
+                "editing",
+                "gd",
+                "image",
+                "imagick",
+                "league",
+                "manipulation",
+                "processing"
+            ],
+            "support": {
+                "issues": "https://github.com/thephpleague/glide/issues",
+                "source": "https://github.com/thephpleague/glide/tree/2.3.2"
+            },
+            "time": "2025-03-21T13:48:39+00:00"
+        },
         {
             "name": "league/mime-type-detection",
             "version": "1.16.0",
@@ -4021,6 +4170,196 @@
             },
             "time": "2025-12-14T04:43:48+00:00"
         },
+        {
+            "name": "spatie/browsershot",
+            "version": "3.61.0",
+            "source": {
+                "type": "git",
+                "url": "https://github.com/spatie/browsershot.git",
+                "reference": "14d75679390b8b84a71b3a17dc5905928deeb887"
+            },
+            "dist": {
+                "type": "zip",
+                "url": "https://api.github.com/repos/spatie/browsershot/zipball/14d75679390b8b84a71b3a17dc5905928deeb887",
+                "reference": "14d75679390b8b84a71b3a17dc5905928deeb887",
+                "shasum": ""
+            },
+            "require": {
+                "ext-json": "*",
+                "php": "^8.0",
+                "spatie/image": "^1.5.3|^2.0",
+                "spatie/temporary-directory": "^1.1|^2.0",
+                "symfony/process": "^4.2|^5.0|^6.0|^7.0"
+            },
+            "require-dev": {
+                "pestphp/pest": "^1.20",
+                "spatie/phpunit-snapshot-assertions": "^4.2.3"
+            },
+            "type": "library",
+            "autoload": {
+                "psr-4": {
+                    "Spatie\\Browsershot\\": "src"
+                }
+            },
+            "notification-url": "https://packagist.org/downloads/",
+            "license": [
+                "MIT"
+            ],
+            "authors": [
+                {
+                    "name": "Freek Van der Herten",
+                    "email": "[email protected]",
+                    "homepage": "https://github.com/freekmurze",
+                    "role": "Developer"
+                }
+            ],
+            "description": "Convert a webpage to an image or pdf using headless Chrome",
+            "homepage": "https://github.com/spatie/browsershot",
+            "keywords": [
+                "chrome",
+                "convert",
+                "headless",
+                "image",
+                "pdf",
+                "puppeteer",
+                "screenshot",
+                "webpage"
+            ],
+            "support": {
+                "source": "https://github.com/spatie/browsershot/tree/3.61.0"
+            },
+            "funding": [
+                {
+                    "url": "https://github.com/spatie",
+                    "type": "github"
+                }
+            ],
+            "time": "2023-12-21T10:00:28+00:00"
+        },
+        {
+            "name": "spatie/image",
+            "version": "2.2.7",
+            "source": {
+                "type": "git",
+                "url": "https://github.com/spatie/image.git",
+                "reference": "2f802853aab017aa615224daae1588054b5ab20e"
+            },
+            "dist": {
+                "type": "zip",
+                "url": "https://api.github.com/repos/spatie/image/zipball/2f802853aab017aa615224daae1588054b5ab20e",
+                "reference": "2f802853aab017aa615224daae1588054b5ab20e",
+                "shasum": ""
+            },
+            "require": {
+                "ext-exif": "*",
+                "ext-json": "*",
+                "ext-mbstring": "*",
+                "league/glide": "^2.2.2",
+                "php": "^8.0",
+                "spatie/image-optimizer": "^1.7",
+                "spatie/temporary-directory": "^1.0|^2.0",
+                "symfony/process": "^3.0|^4.0|^5.0|^6.0"
+            },
+            "require-dev": {
+                "pestphp/pest": "^1.22",
+                "phpunit/phpunit": "^9.5",
+                "symfony/var-dumper": "^4.0|^5.0|^6.0",
+                "vimeo/psalm": "^4.6"
+            },
+            "type": "library",
+            "autoload": {
+                "psr-4": {
+                    "Spatie\\Image\\": "src"
+                }
+            },
+            "notification-url": "https://packagist.org/downloads/",
+            "license": [
+                "MIT"
+            ],
+            "authors": [
+                {
+                    "name": "Freek Van der Herten",
+                    "email": "[email protected]",
+                    "homepage": "https://spatie.be",
+                    "role": "Developer"
+                }
+            ],
+            "description": "Manipulate images with an expressive API",
+            "homepage": "https://github.com/spatie/image",
+            "keywords": [
+                "image",
+                "spatie"
+            ],
+            "support": {
+                "source": "https://github.com/spatie/image/tree/2.2.7"
+            },
+            "funding": [
+                {
+                    "url": "https://spatie.be/open-source/support-us",
+                    "type": "custom"
+                },
+                {
+                    "url": "https://github.com/spatie",
+                    "type": "github"
+                }
+            ],
+            "time": "2023-07-24T13:54:13+00:00"
+        },
+        {
+            "name": "spatie/image-optimizer",
+            "version": "1.10.0",
+            "source": {
+                "type": "git",
+                "url": "https://github.com/spatie/image-optimizer.git",
+                "reference": "333c03952289dc2df0a91874636a0dffeb5b6aec"
+            },
+            "dist": {
+                "type": "zip",
+                "url": "https://api.github.com/repos/spatie/image-optimizer/zipball/333c03952289dc2df0a91874636a0dffeb5b6aec",
+                "reference": "333c03952289dc2df0a91874636a0dffeb5b6aec",
+                "shasum": ""
+            },
+            "require": {
+                "ext-fileinfo": "*",
+                "php": "^7.4|^8.0",
+                "psr/log": "^1.0 | ^2.0 | ^3.0",
+                "symfony/process": "^4.2|^5.0|^6.0|^7.0|^8.0"
+            },
+            "require-dev": {
+                "pestphp/pest": "^1.21|^2.0|^3.0|^4.0",
+                "phpunit/phpunit": "^8.5.21|^9.4.4|^10.0|^11.0|^12.0",
+                "symfony/var-dumper": "^4.2|^5.0|^6.0|^7.0|^8.0"
+            },
+            "type": "library",
+            "autoload": {
+                "psr-4": {
+                    "Spatie\\ImageOptimizer\\": "src"
+                }
+            },
+            "notification-url": "https://packagist.org/downloads/",
+            "license": [
+                "MIT"
+            ],
+            "authors": [
+                {
+                    "name": "Freek Van der Herten",
+                    "email": "[email protected]",
+                    "homepage": "https://spatie.be",
+                    "role": "Developer"
+                }
+            ],
+            "description": "Easily optimize images using PHP",
+            "homepage": "https://github.com/spatie/image-optimizer",
+            "keywords": [
+                "image-optimizer",
+                "spatie"
+            ],
+            "support": {
+                "issues": "https://github.com/spatie/image-optimizer/issues",
+                "source": "https://github.com/spatie/image-optimizer/tree/1.10.0"
+            },
+            "time": "2026-06-29T08:28:30+00:00"
+        },
         {
             "name": "spatie/temporary-directory",
             "version": "2.3.1",

config/backup.php

@@ -0,0 +1,74 @@
+<?php
+
+/*
+|--------------------------------------------------------------------------
+| Backup
+|--------------------------------------------------------------------------
+|
+| Settings for `php artisan takeone:backup`.
+|
+| The database and the media library are backed up by DIFFERENT mechanisms on
+| purpose. The database is small and must be captured as a consistent
+| point-in-time snapshot, so it is copied in full on every run. The media
+| library is gigabytes of immutable uploads, so it is mirrored incrementally
+| and only when asked — tarring it nightly would burn hours of CPU and fill
+| the disk with near-identical archives.
+|
+*/
+
+return [
+
+    // Where snapshots are written. Lives under /data, which is git-ignored, so
+    // a backup can never be committed by accident.
+    'path' => env('BACKUP_PATH', base_path('data/backups')),
+
+    /*
+    |--------------------------------------------------------------------------
+    | Retention
+    |--------------------------------------------------------------------------
+    |
+    | Artifacts older than retain_days are pruned, but the newest keep_minimum
+    | are ALWAYS kept regardless of age — a box that sat idle for a month must
+    | still have something to restore from.
+    |
+    */
+    'retain_days' => (int) env('BACKUP_RETAIN_DAYS', 14),
+    'keep_minimum' => (int) env('BACKUP_KEEP_MINIMUM', 3),
+
+    /*
+    |--------------------------------------------------------------------------
+    | Off-server copy
+    |--------------------------------------------------------------------------
+    |
+    | A filesystems.php disk name. A snapshot sitting on the same disk as the
+    | data survives a bad migration but not a dead disk, so set this to a
+    | remote disk. The command warns on every run while it is unset.
+    |
+    */
+    'disk' => env('BACKUP_DISK'),
+
+    /*
+    |--------------------------------------------------------------------------
+    | Media library
+    |--------------------------------------------------------------------------
+    |
+    | Uploaded video is the irreplaceable asset here — it cannot be regenerated
+    | from anything. It is mirrored with rsync (incremental, resumable) to
+    | media_destination, which should be a NAS mount or another machine.
+    |
+    | Only runs when --media is passed AND a destination is set.
+    |
+    | media_delete stays false by default: a mirror that deletes is one bad
+    | path away from erasing the copy it was meant to protect.
+    |
+    */
+    'media_paths' => [
+        base_path('data/app/users'),
+        base_path('data/app/public'),
+    ],
+
+    'media_destination' => env('BACKUP_MEDIA_DEST'),
+
+    'media_delete' => (bool) env('BACKUP_MEDIA_DELETE', false),
+
+];

config/live.php

@@ -0,0 +1,55 @@
+<?php
+
+/*
+|--------------------------------------------------------------------------
+| Live streaming
+|--------------------------------------------------------------------------
+|
+| The media plane runs as MediaMTX on loopback; nginx proxies /live-rtc and
+| /live-hls to it. Nothing here is a secret except the TURN credential, which
+| comes from the environment.
+|
+*/
+
+return [
+
+    // MediaMTX's control API (localhost only). Used to read live publisher and
+    // viewer state.
+    'api_url' => env('LIVE_API_URL', 'http://127.0.0.1:9997'),
+
+    /*
+    |--------------------------------------------------------------------------
+    | ICE
+    |--------------------------------------------------------------------------
+    |
+    | STUN lets a browser discover its public address. TURN relays the media
+    | when a direct path cannot be established — which, until a UDP port is
+    | forwarded to this server, is EVERY broadcaster outside the local network.
+    |
+    | With no TURN configured, publishing works from the LAN only.
+    |
+    */
+    'stun_url' => env('LIVE_STUN_URL', 'stun:stun.l.google.com:19302'),
+
+    'turn_url' => env('LIVE_TURN_URL'),
+    'turn_username' => env('LIVE_TURN_USERNAME'),
+    'turn_credential' => env('LIVE_TURN_CREDENTIAL'),
+
+    /*
+    |--------------------------------------------------------------------------
+    | Capture defaults
+    |--------------------------------------------------------------------------
+    |
+    | The target the phone is ASKED for. A camera that cannot do 1080p returns
+    | the closest it can, and WebRTC's congestion control lowers the bitrate
+    | when the uplink cannot sustain it — so this is a ceiling, not a promise.
+    |
+    */
+    'video_width' => (int) env('LIVE_VIDEO_WIDTH', 1920),
+    'video_height' => (int) env('LIVE_VIDEO_HEIGHT', 1080),
+    'video_fps' => (int) env('LIVE_VIDEO_FPS', 30),
+
+    // ~4.5 Mbit/s is the practical ceiling for 1080p30 over a mobile uplink.
+    'max_bitrate' => (int) env('LIVE_MAX_BITRATE', 4_500_000),
+
+];

database/migrations/2026_05_24_000000_create_sports_matches_table.php

@@ -0,0 +1,53 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    public function up(): void
+    {
+        Schema::create('sports_matches', function (Blueprint $table) {
+            $table->id();
+
+            // A match always belongs to a video (type=match) and its creator.
+            $table->foreignId('video_id')->constrained()->cascadeOnDelete();
+            $table->foreignId('user_id')->constrained()->cascadeOnDelete();
+
+            // draft | published — lets uploaders save basic info and finish later.
+            $table->string('status', 20)->default('draft')->index();
+
+            // ── Basic fields (shown first; only title is required for a draft) ───
+            $table->string('title');                         // match title (required)
+            $table->string('event_name')->nullable();
+            $table->date('match_date')->nullable();
+            $table->time('match_time')->nullable();
+            $table->string('participant1_name')->nullable();
+            $table->string('participant2_name')->nullable();
+            $table->string('referee_name')->nullable();
+            // ── Fields revealed later when editing ──────────────────────────────
+            $table->string('sport', 80)->nullable()->index();
+            $table->string('match_type', 80)->nullable();
+            $table->string('venue_name')->nullable();
+
+            // ── Optional groups (progressive disclosure) stored as JSON ──────────
+            $table->json('competition')->nullable();   // name, type, stage, season, organizer, championship_name
+            $table->json('participants')->nullable();  // p1_*/p2_* details, weight_class, gender_division, level, extra[]
+            $table->json('media')->nullable();          // image paths + caption, alt, credit, public
+            $table->json('officials')->nullable();      // [{ role, name, photo }]
+            $table->json('venue')->nullable();          // address, city, country, lat, lng, notes
+            $table->json('result')->nullable();         // winner, outcome_type, final_result, rank, notes
+            $table->json('segments')->nullable();       // [{ type, number, score, winner, notes }]
+            $table->json('statistics')->nullable();     // [{ name, value, owner, notes }]
+            $table->json('reviews')->nullable();        // review_type, requested_by, review_result, source_url, verification_notes, admin_notes
+
+            $table->timestamps();
+        });
+    }
+
+    public function down(): void
+    {
+        Schema::dropIfExists('sports_matches');
+    }
+};

database/migrations/2026_05_27_000000_add_user_agent_to_video_views.php

@@ -0,0 +1,22 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    public function up(): void
+    {
+        Schema::table('video_views', function (Blueprint $table) {
+            $table->string('user_agent', 512)->nullable()->after('country_name');
+        });
+    }
+
+    public function down(): void
+    {
+        Schema::table('video_views', function (Blueprint $table) {
+            $table->dropColumn('user_agent');
+        });
+    }
+};

database/migrations/2026_05_27_000001_add_device_id_to_video_views.php

@@ -0,0 +1,24 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    public function up(): void
+    {
+        Schema::table('video_views', function (Blueprint $table) {
+            $table->string('device_id', 64)->nullable()->after('user_agent');
+            $table->index(['video_id', 'device_id']);
+        });
+    }
+
+    public function down(): void
+    {
+        Schema::table('video_views', function (Blueprint $table) {
+            $table->dropIndex(['video_id', 'device_id']);
+            $table->dropColumn('device_id');
+        });
+    }
+};

database/migrations/2026_05_27_000002_add_user_agent_to_downloads_and_share_accesses.php

@@ -0,0 +1,29 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    public function up(): void
+    {
+        Schema::table('video_downloads', function (Blueprint $table) {
+            $table->string('user_agent', 512)->nullable()->after('country_name');
+        });
+
+        Schema::table('share_accesses', function (Blueprint $table) {
+            $table->string('user_agent', 512)->nullable()->after('country_name');
+        });
+    }
+
+    public function down(): void
+    {
+        Schema::table('video_downloads', function (Blueprint $table) {
+            $table->dropColumn('user_agent');
+        });
+        Schema::table('share_accesses', function (Blueprint $table) {
+            $table->dropColumn('user_agent');
+        });
+    }
+};

database/migrations/2026_05_28_000000_add_device_hash_columns.php

@@ -0,0 +1,38 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    public function up(): void
+    {
+        Schema::table('video_views', function (Blueprint $table) {
+            $table->string('device_hash', 64)->nullable()->after('device_id');
+            $table->index(['video_id', 'device_hash']);
+        });
+
+        Schema::table('video_downloads', function (Blueprint $table) {
+            $table->string('device_hash', 64)->nullable()->after('user_agent');
+        });
+
+        Schema::table('share_accesses', function (Blueprint $table) {
+            $table->string('device_hash', 64)->nullable()->after('user_agent');
+        });
+    }
+
+    public function down(): void
+    {
+        Schema::table('video_views', function (Blueprint $table) {
+            $table->dropIndex(['video_id', 'device_hash']);
+            $table->dropColumn('device_hash');
+        });
+        Schema::table('video_downloads', function (Blueprint $table) {
+            $table->dropColumn('device_hash');
+        });
+        Schema::table('share_accesses', function (Blueprint $table) {
+            $table->dropColumn('device_hash');
+        });
+    }
+};

database/migrations/2026_05_28_000001_add_watched_seconds_to_video_views.php

@@ -0,0 +1,23 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    public function up(): void
+    {
+        Schema::table('video_views', function (Blueprint $table) {
+            $table->unsignedInteger('watched_seconds')->default(0)->after('country_name');
+            $table->boolean('completed')->default(false)->after('watched_seconds');
+        });
+    }
+
+    public function down(): void
+    {
+        Schema::table('video_views', function (Blueprint $table) {
+            $table->dropColumn(['watched_seconds', 'completed']);
+        });
+    }
+};

database/migrations/2026_05_28_000002_create_profile_visits_table.php

@@ -0,0 +1,30 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    public function up(): void
+    {
+        Schema::create('profile_visits', function (Blueprint $table) {
+            $table->id();
+            $table->foreignId('profile_user_id')->constrained('users')->cascadeOnDelete();
+            $table->foreignId('visitor_user_id')->nullable()->constrained('users')->nullOnDelete();
+            $table->string('device_id', 64)->nullable();
+            $table->foreignId('source_video_id')->nullable()->constrained('videos')->nullOnDelete();
+            $table->string('ip_address', 45)->nullable();
+            $table->string('country', 2)->nullable();
+            $table->timestamp('created_at')->useCurrent();
+
+            $table->index(['profile_user_id', 'created_at']);
+            $table->index('source_video_id');
+        });
+    }
+
+    public function down(): void
+    {
+        Schema::dropIfExists('profile_visits');
+    }
+};

database/migrations/2026_05_28_000003_add_source_video_id_to_user_subscriptions.php

@@ -0,0 +1,26 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    public function up(): void
+    {
+        Schema::table('user_subscriptions', function (Blueprint $table) {
+            $table->foreignId('source_video_id')->nullable()->after('channel_id')
+                ->constrained('videos')->nullOnDelete();
+            $table->index('source_video_id');
+        });
+    }
+
+    public function down(): void
+    {
+        Schema::table('user_subscriptions', function (Blueprint $table) {
+            $table->dropForeign(['source_video_id']);
+            $table->dropIndex(['source_video_id']);
+            $table->dropColumn('source_video_id');
+        });
+    }
+};

database/migrations/2026_05_31_000001_add_audio_track_id_to_video_slides.php

@@ -0,0 +1,31 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    public function up(): void
+    {
+        Schema::table('video_slides', function (Blueprint $table) {
+            // NULL = song-wide (legacy / shared). Non-null = owned by that audio track.
+            // On track delete, slides become song-wide rather than disappear.
+            $table->foreignId('audio_track_id')
+                ->nullable()
+                ->after('video_id')
+                ->constrained('video_audio_tracks')
+                ->nullOnDelete();
+
+            $table->index(['video_id', 'audio_track_id']);
+        });
+    }
+
+    public function down(): void
+    {
+        Schema::table('video_slides', function (Blueprint $table) {
+            $table->dropIndex(['video_id', 'audio_track_id']);
+            $table->dropConstrainedForeignId('audio_track_id');
+        });
+    }
+};

database/migrations/2026_05_31_000002_add_playlist_views_tracking.php

@@ -0,0 +1,49 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    /**
+     * Add playlist view tracking — mirrors the video_views pattern.
+     *
+     *  • playlists.view_count   — denormalised total for fast card rendering
+     *  • playlist_views table   — one row per (playlist, viewer-id) so a refresh
+     *                             within the dedup window doesn't double-count
+     */
+    public function up(): void
+    {
+        Schema::table('playlists', function (Blueprint $table) {
+            $table->unsignedBigInteger('view_count')->default(0)->after('share_token');
+        });
+
+        Schema::create('playlist_views', function (Blueprint $table) {
+            $table->id();
+            $table->unsignedBigInteger('playlist_id');
+            $table->unsignedBigInteger('user_id')->nullable();
+            $table->string('device_id', 64)->nullable();
+            $table->string('device_hash', 64)->nullable();
+            $table->string('ip_address', 64)->nullable();
+            $table->string('country', 8)->nullable();
+            $table->string('country_name', 64)->nullable();
+            $table->string('user_agent', 512)->nullable();
+            $table->timestamp('viewed_at');
+
+            $table->foreign('playlist_id')->references('id')->on('playlists')->onDelete('cascade');
+            $table->index(['playlist_id', 'viewed_at']);
+            $table->index(['playlist_id', 'user_id', 'viewed_at']);
+            $table->index(['playlist_id', 'device_id', 'viewed_at']);
+            $table->index(['playlist_id', 'device_hash', 'viewed_at']);
+        });
+    }
+
+    public function down(): void
+    {
+        Schema::dropIfExists('playlist_views');
+        Schema::table('playlists', function (Blueprint $table) {
+            $table->dropColumn('view_count');
+        });
+    }
+};

database/migrations/2026_07_30_000001_create_video_redirects_table.php

@@ -0,0 +1,23 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration {
+    public function up(): void
+    {
+        Schema::create('video_redirects', function (Blueprint $table) {
+            $table->id();
+            $table->unsignedBigInteger('source_id')->unique();
+            $table->foreignId('target_id')->constrained('videos')->cascadeOnDelete();
+            $table->timestamp('created_at')->nullable();
+            $table->index('target_id');
+        });
+    }
+
+    public function down(): void
+    {
+        Schema::dropIfExists('video_redirects');
+    }
+};

database/migrations/2026_07_30_000002_add_source_folder_to_video_redirects.php

@@ -0,0 +1,21 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration {
+    public function up(): void
+    {
+        Schema::table('video_redirects', function (Blueprint $table) {
+            $table->string('source_folder', 500)->nullable()->after('target_id');
+        });
+    }
+
+    public function down(): void
+    {
+        Schema::table('video_redirects', function (Blueprint $table) {
+            $table->dropColumn('source_folder');
+        });
+    }
+};

database/migrations/2026_07_31_000001_add_position_to_video_audio_tracks.php

@@ -0,0 +1,30 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\DB;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    public function up(): void
+    {
+        Schema::table('video_audio_tracks', function (Blueprint $table) {
+            $table->unsignedInteger('position')->default(0)->after('label');
+            $table->index(['video_id', 'position']);
+        });
+
+        // Backfill existing rows so their current id-order becomes the
+        // canonical position. New rows start at 0 and get placed at the
+        // end by the update handler.
+        DB::statement('UPDATE video_audio_tracks SET position = id');
+    }
+
+    public function down(): void
+    {
+        Schema::table('video_audio_tracks', function (Blueprint $table) {
+            $table->dropIndex(['video_id', 'position']);
+            $table->dropColumn('position');
+        });
+    }
+};

database/migrations/2026_07_31_000002_add_audio_track_id_to_playlist_videos.php

@@ -0,0 +1,33 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    public function up(): void
+    {
+        Schema::table('playlist_videos', function (Blueprint $table) {
+            // Nullable — null means "play the primary track".
+            $table->unsignedBigInteger('audio_track_id')
+                ->nullable()
+                ->after('video_id');
+
+            // Drop the old (playlist_id, video_id) uniqueness so the same
+            // video can appear multiple times with different tracks.
+            $table->dropUnique(['playlist_id', 'video_id']);
+
+            $table->index(['playlist_id', 'video_id', 'audio_track_id'], 'playlist_video_track_idx');
+        });
+    }
+
+    public function down(): void
+    {
+        Schema::table('playlist_videos', function (Blueprint $table) {
+            $table->dropIndex('playlist_video_track_idx');
+            $table->unique(['playlist_id', 'video_id']);
+            $table->dropColumn('audio_track_id');
+        });
+    }
+};

database/migrations/2026_07_31_000003_create_pending_nas_moves_table.php

@@ -0,0 +1,33 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    public function up(): void
+    {
+        // Records file/folder moves that were queued while NAS was
+        // unreachable. `nas:auto-sync` drains rows when NAS is back:
+        // for each row it renames from → to on NAS and deletes the row.
+        Schema::create('pending_nas_moves', function (Blueprint $table) {
+            $table->id();
+            $table->string('from_path', 500);
+            $table->string('to_path', 500);
+            $table->string('kind', 24)->default('folder'); // 'folder' or 'file'
+            $table->string('origin', 40)->default('merge'); // where it came from
+            $table->unsignedInteger('attempts')->default(0);
+            $table->timestamp('last_attempt_at')->nullable();
+            $table->text('last_error')->nullable();
+            $table->timestamps();
+
+            $table->index(['origin', 'created_at']);
+        });
+    }
+
+    public function down(): void
+    {
+        Schema::dropIfExists('pending_nas_moves');
+    }
+};

database/migrations/2026_08_08_000001_add_position_to_coach_reviews.php

@@ -0,0 +1,28 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    /**
+     * Add drag-and-dropped overlay position for coach notes. Stored as normalized
+     * 0..1 coordinates of the overlay's CENTER within the video area so it
+     * survives any viewport / fullscreen resize.
+     */
+    public function up(): void
+    {
+        Schema::table('coach_reviews', function (Blueprint $table) {
+            $table->decimal('position_x', 6, 4)->nullable()->after('emoji');
+            $table->decimal('position_y', 6, 4)->nullable()->after('position_x');
+        });
+    }
+
+    public function down(): void
+    {
+        Schema::table('coach_reviews', function (Blueprint $table) {
+            $table->dropColumn(['position_x', 'position_y']);
+        });
+    }
+};

database/migrations/2026_08_08_000002_frame_accurate_timestamps.php

@@ -0,0 +1,49 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    /**
+     * Frame-accurate timestamps: the match highlights scrubber lands on
+     * frame boundaries (1/fps seconds). Storing these as INTEGER seconds
+     * throws away sub-second precision, so we promote the columns to
+     * decimal(10,3) — 3 decimals cover up to 1000 fps and centuries of
+     * runtime, and existing integer values migrate losslessly.
+     */
+    public function up(): void
+    {
+        // MatchRound.start_time_seconds is used to jump to a round's opening
+        // frame too, so bring it along.
+        Schema::table('match_rounds', function (Blueprint $table) {
+            $table->decimal('start_time_seconds', 10, 3)->nullable()->change();
+        });
+
+        Schema::table('match_points', function (Blueprint $table) {
+            $table->decimal('timestamp_seconds', 10, 3)->change();
+        });
+
+        Schema::table('coach_reviews', function (Blueprint $table) {
+            $table->decimal('start_time_seconds', 10, 3)->change();
+            $table->decimal('end_time_seconds',   10, 3)->nullable()->change();
+        });
+    }
+
+    public function down(): void
+    {
+        // Round back to integer on rollback — sub-second data would be
+        // truncated but nothing catastrophic happens.
+        Schema::table('match_rounds', function (Blueprint $table) {
+            $table->integer('start_time_seconds')->nullable()->change();
+        });
+        Schema::table('match_points', function (Blueprint $table) {
+            $table->integer('timestamp_seconds')->change();
+        });
+        Schema::table('coach_reviews', function (Blueprint $table) {
+            $table->integer('start_time_seconds')->change();
+            $table->integer('end_time_seconds')->nullable()->change();
+        });
+    }
+};

database/migrations/2026_08_18_000000_create_livestreams_table.php

@@ -0,0 +1,71 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+/**
+ * Live streaming.
+ *
+ * Purely additive: one new table. No existing table is altered — the link to a
+ * recording is held here as video_id rather than adding a column to `videos`,
+ * so the music and generic video paths run against exactly the schema they run
+ * against today.
+ */
+return new class extends Migration
+{
+    public function up(): void
+    {
+        Schema::create('livestreams', function (Blueprint $table) {
+            $table->id();
+            $table->foreignId('user_id')->constrained()->cascadeOnDelete();
+
+            // Public, unpredictable identifier. Used in the watch URL AND as the
+            // media path, so it must never be guessable or enumerable — knowing
+            // one stream's id must not hint at another's.
+            $table->string('public_id', 32)->unique();
+
+            $table->string('title');
+            $table->text('description')->nullable();
+
+            // idle → live → ended, or failed.
+            $table->string('status', 16)->default('idle');
+
+            // public  = listed on the live index
+            // unlisted = reachable only with the link
+            $table->string('visibility', 16)->default('public');
+
+            // Short-lived, single-use credential the browser presents to the
+            // media server when it starts publishing. Not a long-lived stream
+            // key: it is minted on "Go live" and expires in minutes, so there
+            // is no durable secret to leak, screenshot, or reuse.
+            $table->string('publish_token', 64)->nullable();
+            $table->timestamp('publish_token_expires_at')->nullable();
+
+            $table->timestamp('started_at')->nullable();
+            $table->timestamp('ended_at')->nullable();
+
+            // Last time the media server confirmed the publisher is still
+            // connected — how a stream that died without saying goodbye gets
+            // reaped.
+            $table->timestamp('last_seen_at')->nullable();
+
+            $table->unsignedInteger('peak_viewers')->default(0);
+            $table->unsignedInteger('current_viewers')->default(0);
+
+            // Set once a finished stream has been turned into a normal video.
+            $table->foreignId('video_id')->nullable()->constrained()->nullOnDelete();
+
+            $table->timestamps();
+
+            // The live index reads "public streams that are live, newest first".
+            $table->index(['status', 'visibility']);
+            $table->index(['user_id', 'status']);
+        });
+    }
+
+    public function down(): void
+    {
+        Schema::dropIfExists('livestreams');
+    }
+};

database/migrations/2026_10_21_000001_create_video_dislikes_table.php

@@ -0,0 +1,33 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+/**
+ * Dislike counterpart to video_likes.
+ *
+ * One row per (user, video) pair. The unique index on the pair prevents a
+ * user from racking up multiple dislikes against the same video, and the
+ * foreign keys cascade so cleaning up a user or video drops their dislikes
+ * for free.
+ */
+return new class extends Migration {
+    public function up(): void
+    {
+        Schema::create('video_dislikes', function (Blueprint $table) {
+            $table->id();
+            $table->foreignId('video_id')->constrained()->cascadeOnDelete();
+            $table->foreignId('user_id')->constrained()->cascadeOnDelete();
+            $table->timestamps();
+
+            $table->unique(['video_id', 'user_id']);
+            $table->index('video_id');
+        });
+    }
+
+    public function down(): void
+    {
+        Schema::dropIfExists('video_dislikes');
+    }
+};

database/migrations/2026_10_21_000002_add_hearted_and_pinned_to_comments.php

@@ -0,0 +1,36 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+/**
+ * Creator-engagement flags on comments.
+ *
+ *   - hearted: the video owner has acknowledged the comment with a red
+ *     heart (YouTube's "creator heart"). Visible to everyone.
+ *   - pinned: the owner has anchored the comment to the top of the list.
+ *     The comment component sorts pinned comments ahead of everything
+ *     else, newest-pinned first.
+ *
+ * Both default to false and are indexed only on `pinned` because that's the
+ * one the comments query sorts by.
+ */
+return new class extends Migration {
+    public function up(): void
+    {
+        Schema::table('comments', function (Blueprint $table) {
+            $table->boolean('hearted')->default(false)->after('body');
+            $table->boolean('pinned')->default(false)->after('hearted');
+            $table->index('pinned');
+        });
+    }
+
+    public function down(): void
+    {
+        Schema::table('comments', function (Blueprint $table) {
+            $table->dropIndex(['pinned']);
+            $table->dropColumn(['hearted', 'pinned']);
+        });
+    }
+};

database/migrations/2026_10_21_000003_create_live_chat_messages_table.php

@@ -0,0 +1,37 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+/**
+ * Live chat messages — one row per message, scoped to a livestream. Simple
+ * polling model: viewers hit /live/{public_id}/chat?since=<id> every few
+ * seconds and get back everything newer than their last-seen id.
+ *
+ * Cascades: delete the livestream, lose its chat log. Users keep theirs
+ * nulled out so a deleted account's historical messages still render as
+ * "deleted user" rather than removing them from the thread.
+ */
+return new class extends Migration
+{
+    public function up(): void
+    {
+        Schema::create('live_chat_messages', function (Blueprint $table) {
+            $table->id();
+            $table->foreignId('livestream_id')->constrained()->cascadeOnDelete();
+            $table->foreignId('user_id')->nullable()->constrained()->nullOnDelete();
+            $table->string('author_name', 255);   // snapshot of the sender's name at time of posting
+            $table->text('body');
+            $table->timestamp('created_at')->useCurrent();
+
+            // Chat pagination reads "messages in this stream newer than id X".
+            $table->index(['livestream_id', 'id']);
+        });
+    }
+
+    public function down(): void
+    {
+        Schema::dropIfExists('live_chat_messages');
+    }
+};

docs/audit-remediation-plan.md

@@ -0,0 +1,88 @@
+# YouTube-parity audit remediation plan
+
+Branch per phase. Feature tests per fix. STOP for approval between phases.
+
+**Safety tag:** `backup/pre-audit-2026-10-21` at commit `5058eaf` on `full-screen-data`.
+**Stashed WIP:** `stash@{0}` — pre-audit WIP on `full-screen-data` (recover with `git stash pop` on that branch).
+
+---
+
+## Phase 1 — Security & data integrity
+Branch: `fix/phase-1-security`
+
+- [ ] Wrap `sendEmailVerificationNotification` + `NewCommentNotification` mail in try/catch; move to a queued notification channel; log failures. Document `.env` for Gmail app password + Mailgun/Postmark fallback.
+- [ ] `php artisan app:resend-verification {--user=}` command.
+- [ ] Reserved-name blocklist (`admin`, `superadmin`, `takeone`, `support`, `root`, …) via `App\Rules\ReservedIdentifier` wired into `RegisteredUserController`.
+- [ ] Harden login throttling to `5,1` with lockout message; log repeated failures and alert super admins.
+- [ ] Confirm `email_verified_at` is not mass-assignable; only the signed-URL verification route flips it.
+- [ ] Comment dedupe: raise 5s → 60s window, add client idempotency key header, server reject on duplicate. Disable submit button on first click.
+- [ ] `php artisan comments:dedupe --dry-run` cleanup command.
+- [ ] Owner-view exclusion in `VideoController@trackProgress`; dedupe by `device_hash` within 30 min.
+- [ ] Feature tests for each item.
+
+## Phase 2 — Performance & DOM
+Branch: `fix/phase-2-perf`
+
+- [ ] One shared `#globalEditModal` + `#globalCardMenu` per page; populated via `GET /videos/{id}/edit-payload`. Owner-only items gated server-side.
+- [ ] Lazy-render reply/edit boxes (template clone on open).
+- [ ] Match highlights panel rendered once.
+- [ ] `href="javascript:void(0)"` → real `<button>` elements. Hide "Not interested" / "Don't recommend" / "Report" on own videos.
+- [ ] Cursor pagination (`?cursor=`) across Home, `/videos` filters, channel Videos, search, history, liked, comments.
+- [ ] IntersectionObserver infinite scroll + "Load more" fallback.
+- [ ] `loading="lazy"`, explicit `width`/`height`, skeleton placeholders on thumbnails.
+
+## Phase 3 — Feeds, search, trending
+Branch: `fix/phase-3-feeds`
+
+- [ ] Music + filter feeds switch to `latest()`.
+- [ ] Trending windows: 24 / 168 / 720 h; rank by in-window views.
+- [ ] Channel Popular: order by views, tiebreak by likes.
+- [ ] Duration badge on card thumbnail. Scoreboard thumb → `<img>` or `aria-hidden`. Strip `CLUBLOGO` / `FLAG` placeholders.
+- [ ] Filter tabs: fetch + `pushState`, sticky, `aria-current`.
+- [ ] Normalize naming (DB stays `match`, display label "Sports" everywhere).
+- [ ] "New to You" → "Recent" (or make personalized).
+- [ ] New `SearchController` with `/search?q=` matching title/description/tags/language/channel; include channels + playlists. `/videos/search` becomes 302 redirect. Keep query in input. Merge the two duplicate search forms.
+- [ ] `/feed/subscriptions` route backed by `subscriptions` table.
+
+## Phase 4 — Watch page
+Branch: `fix/phase-4-watch`
+
+- [ ] Up Next: real `<a href>` cards. Recommender by type/tags/language, cross-channel. Tabs All / From this channel / Same type. Show more.
+- [ ] Unified player wrapper for match/music/generic: theater (t), mini (i), PiP, volume slider, captions=lyrics (c), 2x speed, end screen, autoplay countdown. Autoplay-ON forces Loop-OFF.
+- [ ] Like count visible, dislike button, Subscribe for guests, viewer `⋯` → Report. Channel row on match videos.
+- [ ] `/videos/{id}/download/{format}` signed route; enforce per-video Downloads setting (Off/Everyone/Members/Subscribers) server-side for MP4 **and** MP3.
+- [ ] Comments: `?lc=` permalink with scroll + highlight. Heart + pin (creator). "Read more" clamp. @handle prefill on nested reply. Singular/plural counts. Top-level vs reply counts separate.
+- [ ] Markdown rendered (or stripped) in descriptions.
+- [ ] Dedupe audio Language menu.
+- [ ] Hide "Generating lyrics…" overlay unless job active.
+- [ ] Edit form prefilled with real values (fix "Generic" / "Loading…" defaults).
+- [ ] Streaming: HLS exists (`GenerateHlsJob`, `/videos/{video}/hls/{file}`). Switch player to hls.js when `hls_path` set. Verify `-movflags +faststart` on mp4 encode in `CompressVideoJob`. Add `Cache-Control` + Range on stream route.
+
+## Phase 5 — Shorts
+Branch: `fix/phase-5-shorts`
+
+- [ ] Upload flag + auto-detect (vertical, ≤60s).
+- [ ] `/shorts/{id}` route + branded 404 at `resources/views/errors/404.blade.php`.
+- [ ] `/shorts` feed: 100dvh snap container, single reused `<video>` moved between slots, next 1–2 preloaded, URL via `history.replaceState`, wheel + arrows + swipe + ▲▼. Loop. Muted autoplay + "Tap to unmute"; unmuted state in `localStorage`.
+- [ ] Right action column (like/dislike/comments/share). Bottom overlay (avatar/@handle/Subscribe/title). Comments side panel desktop / bottom sheet mobile.
+- [ ] Home Shorts shelf. Channel Shorts tab (fix "My Shorts").
+
+## Phase 6 — Channel / Studio / Live
+Branch: `fix/phase-6-channel-studio-live`
+
+- [ ] `users.handle` migration (unique, nullable → backfill → required). `/@handle` routes. Tabs `/@handle/{videos,shorts,playlists,posts,about}`. "Preview as visitor" toggle. Header shows description + links. Age/gender/horoscope private by default. Pluralize "1 video"; drop stray "· 0.0" on playlist cards.
+- [ ] `/studio/*`: content table + bulk edit, per-video analytics, two-step upload (Details → Visibility: tags + playlist + schedule), file-size + duration + processing-status surfaced.
+- [ ] Live: ended state → "Stream ended" + duration + recording (never "Waiting"). Live chat. Like / share / subscribe on viewer page. Channel name link. Private option on `/live/new` matching upload wording.
+
+## Phase 7 — Admin, a11y, consistency
+Branch: `fix/phase-7-admin-a11y`
+
+- [ ] Rename "Live Videos" → "Ready". Storage counts NAS (via `NasSyncService`). Fix KPI WoW %. Strip HTML in description excerpts. Full titles with tooltip. Next/Last pagination on Audit Logs, Users, Videos. Error log viewer groups by stack trace in natural order.
+- [ ] A11y: `aria-label` on every icon button (menu, search, voice, avatar, ⋯, Like-active, comment menus, seek slider with value text). Skip-to-content link. One `<h1>` per page. `label[for]` on all inputs. Remove duplicate "Prefer not to say". Birth year 13+ cap.
+- [ ] Title helper `{page} | Play`. Brand: **Play** displayed; `TAKEONE` stays as `config('app.name')` per CLAUDE.md.
+- [ ] Cleanup commands (all `--dry-run` first): `comments:dedupe`, `live:cleanup-test`, `tracks:dedupe`.
+
+## Final deliverables
+- Checklist: done / partial / skipped (with reason).
+- `.env` keys the user must set.
+- Deploy steps: migrations, queue restart, cache clear, asset build.

docs/mail-setup.md

@@ -0,0 +1,62 @@
+# Mail setup
+
+Mail failures are now non-fatal — a down SMTP will log a warning in
+`data/logs/laravel.log` but will NOT 500 the user. Still, delivery is a
+feature; here's how to fix the current Gmail 535 auth errors.
+
+## Option A — Gmail App Password (quickest, free, ~500 sends/day)
+
+1. On `[email protected]`:
+   - Enable 2-Step Verification (Google Account → Security).
+   - Generate an **App Password** (Security → App passwords → "Mail", "Other: TAKEONE").
+   - Copy the 16-character password Google shows (no spaces).
+
+2. `.env`:
+   ```env
+   MAIL_MAILER=smtp
+   MAIL_HOST=smtp.gmail.com
+   MAIL_PORT=587
+   MAIL_USERNAME=platformtakeone@gmail.com
+   MAIL_PASSWORD=xxxx-xxxx-xxxx-xxxx   # the app password, no quotes needed
+   MAIL_ENCRYPTION=tls
+   MAIL_FROM_ADDRESS=platformtakeone@gmail.com
+   MAIL_FROM_NAME="TAKEONE"
+   ```
+
+3. `php artisan config:clear && php artisan queue:restart`
+
+4. Smoke test:
+   ```bash
+   php artisan app:resend-verification --user=<id-of-an-unverified-user>
+   ```
+
+## Option B — Mailgun (recommended for production)
+
+```env
+MAIL_MAILER=mailgun
+MAILGUN_DOMAIN=mg.takeone.bh
+MAILGUN_SECRET=key-...
+MAILGUN_ENDPOINT=api.eu.mailgun.net  # or api.mailgun.net for US region
+MAIL_FROM_ADDRESS=no-reply@takeone.bh
+MAIL_FROM_NAME="TAKEONE"
+```
+
+## Option C — Postmark (also fine)
+
+```env
+MAIL_MAILER=postmark
+POSTMARK_TOKEN=...
+MAIL_FROM_ADDRESS=no-reply@takeone.bh
+MAIL_FROM_NAME="TAKEONE"
+```
+
+## Resend verification to users whose first email failed
+
+```bash
+# One specific user
+php artisan app:resend-verification --user=42
+
+# Everyone still unverified (dry-run first)
+php artisan app:resend-verification --all-unverified --dry-run
+php artisan app:resend-verification --all-unverified
+```