Studio: make grid checkbox rectangular and commit table changes

app/Http/Controllers/Api/SimilarArtworksController.php

@@ -7,29 +7,33 @@ namespace App\Http\Controllers\Api;
 use App\Http\Controllers\Controller;
 use App\Models\Artwork;
 use App\Services\ArtworkSearchService;
+use App\Services\Recommendations\HybridSimilarArtworksService;
 use Illuminate\Http\JsonResponse;
-use Illuminate\Support\Facades\Cache;
+use Illuminate\Http\Request;
 
 /**
  * GET /api/art/{id}/similar
  *
- * Returns up to 12 similar artworks based on:
- *   1. Tag overlap (primary signal)
- *   2. Same category
- *   3. Similar orientation
+ * Returns up to 12 similar artworks using the hybrid recommender (precomputed lists)
+ * with a Meilisearch-based fallback if no precomputed data exists.
  *
- * Uses Meilisearch via ArtworkSearchService for fast retrieval.
- * Current artwork and its creator are excluded from results.
+ * Query params:
+ *   ?type=similar (default) | visual | tags | behavior
+ *
+ * Priority (default):
+ *   1. Hybrid precomputed (tag + behavior + optional vector)
+ *   2. Meilisearch tag-overlap fallback (legacy)
  */
 final class SimilarArtworksController extends Controller
 {
-    private const LIMIT     = 12;
-    /** Spec §5: cache similar artworks 30–60 min; using config with 30 min default. */
-    private const CACHE_TTL = 1800; // 30 minutes
+    private const LIMIT = 12;
 
-    public function __construct(private readonly ArtworkSearchService $search) {}
+    public function __construct(
+        private readonly ArtworkSearchService $search,
+        private readonly HybridSimilarArtworksService $hybridService,
+    ) {}
 
-    public function __invoke(int $id): JsonResponse
+    public function __invoke(Request $request, int $id): JsonResponse
     {
         $artwork = Artwork::public()
             ->published()
@@ -40,22 +44,64 @@ final class SimilarArtworksController extends Controller
             return response()->json(['error' => 'Artwork not found'], 404);
         }
 
-        $cacheKey = "api.similar.{$artwork->id}";
+        $type = $request->query('type');
+        $validTypes = ['similar', 'visual', 'tags', 'behavior'];
+        if ($type !== null && ! in_array($type, $validTypes, true)) {
+            $type = null; // ignore invalid, fall through to default
+        }
 
-        $items = Cache::remember($cacheKey, self::CACHE_TTL, function () use ($artwork) {
-            return $this->findSimilar($artwork);
-        });
+        // Service handles its own caching (6h TTL), no extra controller-level cache
+        $hybridResults = $this->hybridService->forArtwork($artwork->id, self::LIMIT, $type);
+
+        if ($hybridResults->isNotEmpty()) {
+            // Eager-load relations needed for formatting
+            $ids = $hybridResults->pluck('id')->all();
+            $loaded = Artwork::query()
+                ->whereIn('id', $ids)
+                ->with(['tags:id,slug', 'stats', 'user:id,name', 'user.profile:user_id,avatar_hash'])
+                ->get()
+                ->keyBy('id');
+
+            $items = $hybridResults->values()->map(function (Artwork $a) use ($loaded) {
+                $full = $loaded->get($a->id) ?? $a;
+                return $this->formatArtwork($full);
+            })->all();
+
+            return response()->json(['data' => $items]);
+        }
+
+        // Fall back to Meilisearch tag-overlap search
+        $items = $this->findSimilarViaSearch($artwork);
 
         return response()->json(['data' => $items]);
     }
 
-    private function findSimilar(Artwork $artwork): array
+    private function formatArtwork(Artwork $artwork): array
+    {
+        return [
+            'id'            => $artwork->id,
+            'title'         => $artwork->title,
+            'slug'          => $artwork->slug,
+            'thumb'         => $artwork->thumbUrl('md'),
+            'url'           => '/art/' . $artwork->id . '/' . $artwork->slug,
+            'author'        => $artwork->user?->name ?? 'Artist',
+            'author_avatar' => $artwork->user?->profile?->avatar_url,
+            'author_id'     => $artwork->user_id,
+            'orientation'   => $this->orientation($artwork),
+            'width'         => $artwork->width,
+            'height'        => $artwork->height,
+        ];
+    }
+
+    /**
+     * Legacy Meilisearch-based similar artworks (fallback).
+     */
+    private function findSimilarViaSearch(Artwork $artwork): array
     {
         $tagSlugs      = $artwork->tags->pluck('slug')->values()->all();
         $categorySlugs = $artwork->categories->pluck('slug')->values()->all();
         $srcOrientation = $this->orientation($artwork);
 
-        // Build Meilisearch filter: exclude self and same creator
         $filterParts = [
             'is_public = true',
             'is_approved = true',
@@ -63,7 +109,6 @@ final class SimilarArtworksController extends Controller
             'author_id != ' . $artwork->user_id,
         ];
 
-        // Priority 1: tag overlap (OR match across tags)
         if ($tagSlugs !== []) {
             $tagFilter = implode(' OR ', array_map(
                 fn (string $t): string => 'tags = "' . addslashes($t) . '"',
@@ -71,7 +116,6 @@ final class SimilarArtworksController extends Controller
             ));
             $filterParts[] = '(' . $tagFilter . ')';
         } elseif ($categorySlugs !== []) {
-            // Fallback to category if no tags
             $catFilter = implode(' OR ', array_map(
                 fn (string $c): string => 'category = "' . addslashes($c) . '"',
                 $categorySlugs
@@ -79,7 +123,6 @@ final class SimilarArtworksController extends Controller
             $filterParts[] = '(' . $catFilter . ')';
         }
 
-        // ── Fetch 200-candidate pool from Meilisearch ─────────────────────────
         $results = Artwork::search('')
             ->options([
                 'filter' => implode(' AND ', $filterParts),
@@ -90,9 +133,6 @@ final class SimilarArtworksController extends Controller
         $collection = $results->getCollection();
         $collection->load(['tags:id,slug', 'stats', 'user:id,name', 'user.profile:user_id,avatar_hash']);
 
-        // ── PHP reranking ──────────────────────────────────────────────────────
-        // Weights: tag_overlap ×0.60, orientation_bonus +0.10, resolution_bonus
-        // +0.05, popularity (log-views) ≤0.15, freshness (exp decay) ×0.10
         $srcTagSet = array_flip($tagSlugs);
         $srcW      = (int) ($artwork->width  ?? 0);
         $srcH      = (int) ($artwork->height ?? 0);
@@ -103,15 +143,12 @@ final class SimilarArtworksController extends Controller
             $cTagSlugs  = $candidate->tags->pluck('slug')->all();
             $cTagSet    = array_flip($cTagSlugs);
 
-            // Tag overlap (Sørensen–Dice-like)
             $common     = count(array_intersect_key($srcTagSet, $cTagSet));
             $total      = max(1, count($srcTagSet) + count($cTagSet) - $common);
             $tagOverlap = $common / $total;
 
-            // Orientation bonus
             $orientBonus = $this->orientation($candidate) === $srcOrientation ? 0.10 : 0.0;
 
-            // Resolution proximity bonus (both axes within 25 %)
             $cW = (int) ($candidate->width  ?? 0);
             $cH = (int) ($candidate->height ?? 0);
             $resBonus = ($srcW > 0 && $srcH > 0 && $cW > 0 && $cH > 0
@@ -119,11 +156,9 @@ final class SimilarArtworksController extends Controller
                 && abs($cH - $srcH) / $srcH <= 0.25
             ) ? 0.05 : 0.0;
 
-            // Popularity boost (log-normalised views, capped at 0.15)
             $views      = max(0, (int) ($candidate->stats?->views ?? 0));
             $popularity = min(0.15, log(1 + $views) / 13.0);
 
-            // Freshness boost (exp decay, 60-day half-life, weight 0.10)
             $publishedAt = $candidate->published_at ?? $candidate->created_at ?? now();
             $ageDays     = max(0.0, (float) $publishedAt->diffInSeconds(now()) / 86400);
             $freshness   = exp(-$ageDays / 60.0) * 0.10;
@@ -140,20 +175,10 @@ final class SimilarArtworksController extends Controller
         usort($scored, fn ($a, $b) => $b['score'] <=> $a['score']);
 
         return array_values(
-            array_map(fn (array $item): array => [
-                'id'          => $item['artwork']->id,
-                'title'       => $item['artwork']->title,
-                'slug'        => $item['artwork']->slug,
-                'thumb'       => $item['artwork']->thumbUrl('md'),
-                'url'         => '/art/' . $item['artwork']->id . '/' . $item['artwork']->slug,
-                'author'      => $item['artwork']->user?->name ?? 'Artist',
-                'author_avatar' => $item['artwork']->user?->profile?->avatar_url,
-                'author_id'   => $item['artwork']->user_id,
-                'orientation' => $this->orientation($item['artwork']),
-                'width'       => $item['artwork']->width,
-                'height'      => $item['artwork']->height,
-                'score'       => round((float) $item['score'], 5),
-            ], array_slice($scored, 0, self::LIMIT))
+            array_map(fn (array $item): array => array_merge(
+                $this->formatArtwork($item['artwork']),
+                ['score' => round((float) $item['score'], 5)]
+            ), array_slice($scored, 0, self::LIMIT))
         );
     }
 

app/Http/Controllers/ArtworkController.php

@@ -6,7 +6,6 @@ use App\Http\Controllers\Controller;
 use App\Http\Requests\ArtworkIndexRequest;
 use App\Models\Artwork;
 use App\Models\Category;
-use App\Services\Recommendations\SimilarArtworksService;
 use Illuminate\Http\Request;
 use Illuminate\View\View;
 
@@ -97,84 +96,12 @@ class ArtworkController extends Controller
             abort(404);
         }
 
-        $foundArtwork->loadMissing(['categories.contentType', 'user']);
-
-        $defaultAlgoVersion = (string) config('recommendations.embedding.algo_version', 'clip-cosine-v1');
-        $selectedAlgoVersion = $this->selectAlgoVersionForRequest($request, $defaultAlgoVersion);
-
-        $similarService = app(SimilarArtworksService::class);
-        $similarArtworks = $similarService->forArtwork((int) $foundArtwork->id, 12, $selectedAlgoVersion);
-
-        if ($similarArtworks->isEmpty() && $selectedAlgoVersion !== $defaultAlgoVersion) {
-            $similarArtworks = $similarService->forArtwork((int) $foundArtwork->id, 12, $defaultAlgoVersion);
-            $selectedAlgoVersion = $defaultAlgoVersion;
-        }
-
-        $similarArtworks->each(static function (Artwork $item): void {
-            $item->loadMissing(['categories.contentType', 'user']);
-        });
-
-        $similarItems = $similarArtworks
-            ->map(function (Artwork $item): ?array {
-                $category = $item->categories->first();
-                $contentType = $category?->contentType;
-
-                if (! $category || ! $contentType || empty($item->slug)) {
-                    return null;
-                }
-
-                return [
-                    'id' => (int) $item->id,
-                    'title' => html_entity_decode((string) $item->title, ENT_QUOTES | ENT_HTML5, 'UTF-8'),
-                    'author' => html_entity_decode((string) optional($item->user)->name, ENT_QUOTES | ENT_HTML5, 'UTF-8'),
-                    'thumb' => (string) ($item->thumb_url ?? $item->thumb ?? '/gfx/sb_join.jpg'),
-                    'thumb_srcset' => (string) ($item->thumb_srcset ?? ''),
-                    'url' => route('artworks.show', [
-                        'contentTypeSlug' => (string) $contentType->slug,
-                        'categoryPath' => (string) $category->slug,
-                        'artwork' => (string) $item->slug,
-                    ]),
-                ];
-            })
-            ->filter()
-            ->values();
-
-        return view('artworks.show', [
-            'artwork' => $foundArtwork,
-            'similarItems' => $similarItems,
-            'similarAlgoVersion' => $selectedAlgoVersion,
-        ]);
-    }
-
-    private function selectAlgoVersionForRequest(Request $request, string $default): string
-    {
-        $configured = (array) config('recommendations.ab.algo_versions', []);
-        $versions = array_values(array_filter(array_map(static fn ($value): string => trim((string) $value), $configured)));
-
-        if ($versions === []) {
-            return $default;
-        }
-
-        if (! in_array($default, $versions, true)) {
-            array_unshift($versions, $default);
-            $versions = array_values(array_unique($versions));
-        }
-
-        $forced = trim((string) $request->query('algo_version', ''));
-        if ($forced !== '' && in_array($forced, $versions, true)) {
-            return $forced;
-        }
-
-        if (count($versions) === 1) {
-            return $versions[0];
-        }
-
-        $visitorKey = $request->user()?->id
-            ? 'u:' . (string) $request->user()->id
-            : 's:' . (string) $request->session()->getId();
-
-        $bucket = abs(crc32($visitorKey)) % count($versions);
-
-        return $versions[$bucket] ?? $default;
+        // Delegate to the canonical ArtworkPageController which builds all
+        // required view data ($meta, thumbnails, related items, comments, etc.)
+        return app(\App\Http\Controllers\Web\ArtworkPageController::class)->show(
+            $request,
+            (int) $foundArtwork->id,
+            $foundArtwork->slug,
+        );
     }
 }

app/Http/Controllers/Legacy/LatestCommentsController.php

@@ -30,7 +30,7 @@ class LatestCommentsController extends Controller
             $user = $c->user;
 
             $present = $art ? \App\Services\ThumbnailPresenter::present($art, 'md') : null;
-            $thumb = $present ? ($present['url']) : '/gfx/sb_join.jpg';
+            $thumb = $present ? ($present['url']) : 'https://files.skinbase.org/default/missing_md.webp';
 
             return (object) [
                 'comment_id' => $c->getKey(),

app/Http/Controllers/Legacy/TodayDownloadsController.php

@@ -43,7 +43,7 @@ class TodayDownloadsController extends Controller
             $ext = pathinfo($picture ?? '', PATHINFO_EXTENSION) ?: 'jpg';
             $encoded = null; // legacy encoding unavailable; leave null
             $present = $art ? \App\Services\ThumbnailPresenter::present($art, 'md') : null;
-            $thumb = $present ? $present['url'] : '/gfx/sb_join.jpg';
+            $thumb = $present ? $present['url'] : 'https://files.skinbase.org/default/missing_md.webp';
             $categoryId = $art->categories->first()->id ?? null;
 
             return (object) [

app/Http/Controllers/LegacyController.php

@@ -58,7 +58,7 @@ class LegacyController extends Controller
                 (object) [
                     'id' => 0,
                     'name' => 'Sample Artwork',
-                    'picture' => 'gfx/sb_join.jpg',
+                    'picture' => 'https://files.skinbase.org/default/missing_md.webp',
                     'category' => null,
                     'datum' => now(),
                     'category_name' => 'Photography',
@@ -289,7 +289,7 @@ class LegacyController extends Controller
             $featured = (object) [
                 'id' => 0,
                 'name' => 'Featured Artwork',
-                'picture' => '/gfx/sb_join.jpg',
+                'picture' => 'https://files.skinbase.org/default/missing_md.webp',
                 'uname' => 'Skinbase',
             ];
         }
@@ -298,7 +298,7 @@ class LegacyController extends Controller
             $memberFeatured = (object) [
                 'id' => 0,
                 'name' => 'Members Pick',
-                'picture' => '/gfx/sb_join.jpg',
+                'picture' => 'https://files.skinbase.org/default/missing_md.webp',
                 'uname' => 'Skinbase',
                 'votes' => 0,
             ];
@@ -430,7 +430,7 @@ class LegacyController extends Controller
                 [
                     'id' => 1,
                     'name' => 'Sample Artwork',
-                    'picture' => 'gfx/sb_join.jpg',
+                    'picture' => 'https://files.skinbase.org/default/missing_md.webp',
                     'uname' => 'Skinbase',
                     'category_name' => 'Photography',
                 ],

app/Http/Controllers/Studio/StudioArtworksApiController.php

@@ -0,0 +1,349 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Http\Controllers\Studio;
+
+use App\Http\Controllers\Controller;
+use App\Services\Studio\StudioArtworkQueryService;
+use App\Services\Studio\StudioBulkActionService;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+use Illuminate\Support\Facades\Validator;
+
+/**
+ * JSON API endpoints for the Studio artwork manager.
+ */
+final class StudioArtworksApiController extends Controller
+{
+    public function __construct(
+        private readonly StudioArtworkQueryService $queryService,
+        private readonly StudioBulkActionService $bulkService,
+    ) {}
+
+    /**
+     * GET /api/studio/artworks
+     * List artworks with search, filter, sort, pagination.
+     */
+    public function index(Request $request): JsonResponse
+    {
+        $userId = $request->user()->id;
+
+        $filters = $request->only([
+            'q', 'status', 'category', 'tags', 'date_from', 'date_to',
+            'performance', 'sort',
+        ]);
+
+        $perPage = (int) $request->get('per_page', 24);
+        $perPage = min(max($perPage, 12), 100);
+
+        $paginator = $this->queryService->list($userId, $filters, $perPage);
+
+        // Transform the paginator items to a clean DTO
+        $items = collect($paginator->items())->map(fn ($artwork) => $this->transformArtwork($artwork));
+
+        return response()->json([
+            'data' => $items,
+            'meta' => [
+                'current_page' => $paginator->currentPage(),
+                'last_page'    => $paginator->lastPage(),
+                'per_page'     => $paginator->perPage(),
+                'total'        => $paginator->total(),
+            ],
+        ]);
+    }
+
+    /**
+     * POST /api/studio/artworks/bulk
+     * Execute bulk operations.
+     */
+    public function bulk(Request $request): JsonResponse
+    {
+        $validator = Validator::make($request->all(), [
+            'action'      => 'required|string|in:publish,unpublish,archive,unarchive,delete,change_category,add_tags,remove_tags',
+            'artwork_ids' => 'required|array|min:1|max:200',
+            'artwork_ids.*' => 'integer',
+            'params'      => 'sometimes|array',
+            'params.category_id' => 'sometimes|integer|exists:categories,id',
+            'params.tag_ids'     => 'sometimes|array',
+            'params.tag_ids.*'   => 'integer|exists:tags,id',
+            'confirm'     => 'required_if:action,delete|string',
+        ]);
+
+        if ($validator->fails()) {
+            return response()->json(['errors' => $validator->errors()], 422);
+        }
+
+        $data = $validator->validated();
+
+        // Require explicit DELETE confirmation
+        if ($data['action'] === 'delete' && ($data['confirm'] ?? '') !== 'DELETE') {
+            return response()->json([
+                'errors' => ['confirm' => ['You must type DELETE to confirm permanent deletion.']],
+            ], 422);
+        }
+
+        $result = $this->bulkService->execute(
+            $request->user()->id,
+            $data['action'],
+            $data['artwork_ids'],
+            $data['params'] ?? [],
+        );
+
+        $statusCode = $result['failed'] > 0 && $result['success'] === 0 ? 422 : 200;
+
+        return response()->json($result, $statusCode);
+    }
+
+    /**
+     * PUT /api/studio/artworks/{id}
+     * Update artwork details (title, description, visibility).
+     */
+    public function update(Request $request, int $id): JsonResponse
+    {
+        $artwork = $request->user()->artworks()->findOrFail($id);
+
+        $validated = $request->validate([
+            'title'       => 'sometimes|string|max:255',
+            'description' => 'sometimes|nullable|string|max:5000',
+            'is_public'   => 'sometimes|boolean',
+            'category_id' => 'sometimes|nullable|integer|exists:categories,id',
+            'tags'        => 'sometimes|array|max:15',
+            'tags.*'      => 'string|max:64',
+        ]);
+
+        if (isset($validated['is_public'])) {
+            if ($validated['is_public'] && !$artwork->is_public) {
+                $validated['published_at'] = $artwork->published_at ?? now();
+            }
+        }
+
+        // Extract tags and category before updating core fields
+        $tags = $validated['tags'] ?? null;
+        $categoryId = $validated['category_id'] ?? null;
+        unset($validated['tags'], $validated['category_id']);
+
+        $artwork->update($validated);
+
+        // Sync category
+        if ($categoryId !== null) {
+            $artwork->categories()->sync([(int) $categoryId]);
+        }
+
+        // Sync tags (by slug/name)
+        if ($tags !== null) {
+            $tagIds = [];
+            foreach ($tags as $tagSlug) {
+                $tag = \App\Models\Tag::firstOrCreate(
+                    ['slug' => \Illuminate\Support\Str::slug($tagSlug)],
+                    ['name' => $tagSlug, 'is_active' => true, 'usage_count' => 0]
+                );
+                $tagIds[$tag->id] = ['source' => 'studio_edit', 'confidence' => 1.0];
+            }
+            $artwork->tags()->sync($tagIds);
+        }
+
+        // Reindex in Meilisearch
+        try {
+            $artwork->searchable();
+        } catch (\Throwable $e) {
+            // Meilisearch may be unavailable
+        }
+
+        // Reload relationships for response
+        $artwork->load(['categories.contentType', 'tags']);
+        $primaryCategory = $artwork->categories->first();
+
+        return response()->json([
+            'success' => true,
+            'artwork' => [
+                'id'              => $artwork->id,
+                'title'           => $artwork->title,
+                'description'     => $artwork->description,
+                'is_public'       => (bool) $artwork->is_public,
+                'slug'            => $artwork->slug,
+                'content_type_id' => $primaryCategory?->contentType?->id,
+                'category_id'     => $primaryCategory?->id,
+                'tags'            => $artwork->tags->map(fn ($t) => ['id' => $t->id, 'name' => $t->name, 'slug' => $t->slug])->values()->all(),
+            ],
+        ]);
+    }
+
+    /**
+     * POST /api/studio/artworks/{id}/toggle
+     * Toggle publish/unpublish/archive for a single artwork.
+     */
+    public function toggle(Request $request, int $id): JsonResponse
+    {
+        $validator = Validator::make($request->all(), [
+            'action' => 'required|string|in:publish,unpublish,archive,unarchive',
+        ]);
+
+        if ($validator->fails()) {
+            return response()->json(['errors' => $validator->errors()], 422);
+        }
+
+        $result = $this->bulkService->execute(
+            $request->user()->id,
+            $validator->validated()['action'],
+            [$id],
+        );
+
+        if ($result['success'] === 0) {
+            return response()->json(['error' => 'Action failed', 'details' => $result['errors']], 404);
+        }
+
+        return response()->json(['success' => true]);
+    }
+
+    /**
+     * GET /api/studio/artworks/{id}/analytics
+     * Analytics data for a single artwork.
+     */
+    public function analytics(Request $request, int $id): JsonResponse
+    {
+        $artwork = $request->user()->artworks()
+            ->with(['stats', 'awardStat'])
+            ->findOrFail($id);
+
+        $stats = $artwork->stats;
+
+        return response()->json([
+            'artwork' => [
+                'id'    => $artwork->id,
+                'title' => $artwork->title,
+                'slug'  => $artwork->slug,
+            ],
+            'analytics' => [
+                'views'               => (int) ($stats?->views ?? 0),
+                'favourites'          => (int) ($stats?->favorites ?? 0),
+                'shares'              => (int) ($stats?->shares_count ?? 0),
+                'comments'            => (int) ($stats?->comments_count ?? 0),
+                'downloads'           => (int) ($stats?->downloads ?? 0),
+                'ranking_score'       => (float) ($stats?->ranking_score ?? 0),
+                'heat_score'          => (float) ($stats?->heat_score ?? 0),
+                'engagement_velocity' => (float) ($stats?->engagement_velocity ?? 0),
+            ],
+        ]);
+    }
+
+    private function transformArtwork($artwork): array
+    {
+        $stats = $artwork->stats ?? null;
+
+        return [
+            'id'              => $artwork->id,
+            'title'           => $artwork->title,
+            'slug'            => $artwork->slug,
+            'thumb_url'       => $artwork->thumbUrl('md') ?? '/images/placeholder.jpg',
+            'is_public'       => (bool) $artwork->is_public,
+            'is_approved'     => (bool) $artwork->is_approved,
+            'published_at'    => $artwork->published_at?->toIso8601String(),
+            'created_at'      => $artwork->created_at?->toIso8601String(),
+            'deleted_at'      => $artwork->deleted_at?->toIso8601String(),
+            'category'        => $artwork->categories->first()?->name,
+            'category_slug'   => $artwork->categories->first()?->slug,
+            'tags'            => $artwork->tags->pluck('slug')->values()->all(),
+            'views'           => (int) ($stats?->views ?? 0),
+            'favourites'      => (int) ($stats?->favorites ?? 0),
+            'shares'          => (int) ($stats?->shares_count ?? 0),
+            'comments'        => (int) ($stats?->comments_count ?? 0),
+            'downloads'       => (int) ($stats?->downloads ?? 0),
+            'ranking_score'   => (float) ($stats?->ranking_score ?? 0),
+            'heat_score'      => (float) ($stats?->heat_score ?? 0),
+        ];
+    }
+
+    /**
+     * GET /api/studio/tags/search?q=...
+     * Search active tags by name for the bulk tag picker.
+     */
+    public function searchTags(Request $request): JsonResponse
+    {
+        $query = trim((string) $request->input('q'));
+
+        $tags = \App\Models\Tag::query()
+            ->where('is_active', true)
+            ->when($query !== '', fn ($q) => $q->where('name', 'LIKE', "%{$query}%"))
+            ->orderByDesc('usage_count')
+            ->limit(30)
+            ->get(['id', 'name', 'slug', 'usage_count']);
+
+        return response()->json($tags);
+    }
+
+    /**
+     * POST /api/studio/artworks/{id}/replace-file
+     * Replace the artwork's primary image file and regenerate derivatives.
+     */
+    public function replaceFile(Request $request, int $id): JsonResponse
+    {
+        $artwork = $request->user()->artworks()->findOrFail($id);
+
+        $request->validate([
+            'file' => 'required|file|mimes:jpeg,jpg,png,webp|max:51200', // 50MB
+        ]);
+
+        $file = $request->file('file');
+        $tempPath = $file->getRealPath();
+
+        // Compute SHA-256 hash
+        $hash = hash_file('sha256', $tempPath);
+
+        try {
+            $derivatives = app(\App\Services\Uploads\UploadDerivativesService::class);
+            $storage = app(\App\Services\Uploads\UploadStorageService::class);
+            $artworkFiles = app(\App\Repositories\Uploads\ArtworkFileRepository::class);
+
+            // Store original
+            $originalPath = $derivatives->storeOriginal($tempPath, $hash);
+            $originalRelative = $storage->sectionRelativePath('originals', $hash, 'orig.webp');
+            $artworkFiles->upsert($artwork->id, 'orig', $originalRelative, 'image/webp', (int) filesize($originalPath));
+
+            // Generate public derivatives
+            $publicAbsolute = $derivatives->generatePublicDerivatives($tempPath, $hash);
+            foreach ($publicAbsolute as $variant => $absolutePath) {
+                $filename = $variant . '.webp';
+                $relativePath = $storage->publicRelativePath($hash, $filename);
+                $artworkFiles->upsert($artwork->id, $variant, $relativePath, 'image/webp', (int) filesize($absolutePath));
+            }
+
+            // Get dimensions
+            $dimensions = @getimagesize($tempPath);
+            $width = is_array($dimensions) && isset($dimensions[0]) ? (int) $dimensions[0] : $artwork->width;
+            $height = is_array($dimensions) && isset($dimensions[1]) ? (int) $dimensions[1] : $artwork->height;
+
+            // Update artwork record
+            $artwork->update([
+                'file_name' => 'orig.webp',
+                'file_path' => '',
+                'file_size' => (int) filesize($originalPath),
+                'mime_type' => 'image/webp',
+                'hash'      => $hash,
+                'file_ext'  => 'webp',
+                'thumb_ext' => 'webp',
+                'width'     => max(1, $width),
+                'height'    => max(1, $height),
+            ]);
+
+            // Reindex
+            try {
+                $artwork->searchable();
+            } catch (\Throwable) {}
+
+            return response()->json([
+                'success'   => true,
+                'thumb_url' => $artwork->thumbUrl('md'),
+                'thumb_url_lg' => $artwork->thumbUrl('lg'),
+                'width'     => $artwork->width,
+                'height'    => $artwork->height,
+                'file_size' => $artwork->file_size,
+            ]);
+        } catch (\Throwable $e) {
+            return response()->json([
+                'success' => false,
+                'error'   => 'File processing failed: ' . $e->getMessage(),
+            ], 500);
+        }
+    }
+}

app/Http/Controllers/Studio/StudioController.php

@@ -0,0 +1,174 @@
+<?php
+
+declare(strict_types=1);
+
+namespace App\Http\Controllers\Studio;
+
+use App\Http\Controllers\Controller;
+use App\Models\Category;
+use App\Models\ContentType;
+use App\Services\Studio\StudioMetricsService;
+use Illuminate\Http\Request;
+use Inertia\Inertia;
+use Inertia\Response;
+
+/**
+ * Serves Studio Inertia pages for authenticated creators.
+ */
+final class StudioController extends Controller
+{
+    public function __construct(
+        private readonly StudioMetricsService $metrics,
+    ) {}
+
+    /**
+     * Studio Overview Dashboard (/studio)
+     */
+    public function index(Request $request): Response
+    {
+        $userId = $request->user()->id;
+
+        return Inertia::render('Studio/StudioDashboard', [
+            'kpis'           => $this->metrics->getDashboardKpis($userId),
+            'topPerformers'  => $this->metrics->getTopPerformers($userId, 6),
+            'recentComments' => $this->metrics->getRecentComments($userId, 5),
+        ]);
+    }
+
+    /**
+     * Artwork Manager (/studio/artworks)
+     */
+    public function artworks(Request $request): Response
+    {
+        return Inertia::render('Studio/StudioArtworks', [
+            'categories' => $this->getCategories(),
+        ]);
+    }
+
+    /**
+     * Drafts (/studio/artworks/drafts)
+     */
+    public function drafts(Request $request): Response
+    {
+        return Inertia::render('Studio/StudioDrafts', [
+            'categories' => $this->getCategories(),
+        ]);
+    }
+
+    /**
+     * Archived (/studio/artworks/archived)
+     */
+    public function archived(Request $request): Response
+    {
+        return Inertia::render('Studio/StudioArchived', [
+            'categories' => $this->getCategories(),
+        ]);
+    }
+
+    /**
+     * Edit artwork (/studio/artworks/:id/edit)
+     */
+    public function edit(Request $request, int $id): Response
+    {
+        $artwork = $request->user()->artworks()
+            ->with(['stats', 'categories.contentType', 'tags'])
+            ->findOrFail($id);
+
+        $primaryCategory = $artwork->categories->first();
+
+        return Inertia::render('Studio/StudioArtworkEdit', [
+            'artwork'    => [
+                'id'              => $artwork->id,
+                'title'           => $artwork->title,
+                'slug'            => $artwork->slug,
+                'description'     => $artwork->description,
+                'is_public'       => (bool) $artwork->is_public,
+                'is_approved'     => (bool) $artwork->is_approved,
+                'thumb_url'       => $artwork->thumbUrl('md'),
+                'thumb_url_lg'    => $artwork->thumbUrl('lg'),
+                'file_name'       => $artwork->file_name,
+                'file_size'       => $artwork->file_size,
+                'width'           => $artwork->width,
+                'height'          => $artwork->height,
+                'mime_type'       => $artwork->mime_type,
+                'content_type_id' => $primaryCategory?->contentType?->id,
+                'category_id'     => $primaryCategory?->id,
+                'parent_category_id' => $primaryCategory?->parent_id ? $primaryCategory->parent_id : $primaryCategory?->id,
+                'sub_category_id'    => $primaryCategory?->parent_id ? $primaryCategory->id : null,
+                'categories'      => $artwork->categories->map(fn ($c) => ['id' => $c->id, 'name' => $c->name, 'slug' => $c->slug])->values()->all(),
+                'tags'            => $artwork->tags->map(fn ($t) => ['id' => $t->id, 'name' => $t->name, 'slug' => $t->slug])->values()->all(),
+            ],
+            'contentTypes' => $this->getCategories(),
+        ]);
+    }
+
+    /**
+     * Analytics v1 (/studio/artworks/:id/analytics)
+     */
+    public function analytics(Request $request, int $id): Response
+    {
+        $artwork = $request->user()->artworks()
+            ->with(['stats', 'awardStat'])
+            ->findOrFail($id);
+
+        $stats = $artwork->stats;
+
+        return Inertia::render('Studio/StudioArtworkAnalytics', [
+            'artwork' => [
+                'id'            => $artwork->id,
+                'title'         => $artwork->title,
+                'slug'          => $artwork->slug,
+                'thumb_url'     => $artwork->thumbUrl('md'),
+            ],
+            'analytics' => [
+                'views'           => (int) ($stats?->views ?? 0),
+                'favourites'      => (int) ($stats?->favorites ?? 0),
+                'shares'          => (int) ($stats?->shares_count ?? 0),
+                'comments'        => (int) ($stats?->comments_count ?? 0),
+                'downloads'       => (int) ($stats?->downloads ?? 0),
+                'ranking_score'   => (float) ($stats?->ranking_score ?? 0),
+                'heat_score'      => (float) ($stats?->heat_score ?? 0),
+                'engagement_velocity' => (float) ($stats?->engagement_velocity ?? 0),
+            ],
+        ]);
+    }
+
+    /**
+     * Studio-wide Analytics (/studio/analytics)
+     */
+    public function analyticsOverview(Request $request): Response
+    {
+        $userId = $request->user()->id;
+        $data = $this->metrics->getAnalyticsOverview($userId);
+
+        return Inertia::render('Studio/StudioAnalytics', [
+            'totals'           => $data['totals'],
+            'topArtworks'      => $data['top_artworks'],
+            'contentBreakdown' => $data['content_breakdown'],
+            'recentComments'   => $this->metrics->getRecentComments($userId, 8),
+        ]);
+    }
+
+    private function getCategories(): array
+    {
+        return ContentType::with(['rootCategories.children'])->get()->map(function ($ct) {
+            return [
+                'id'   => $ct->id,
+                'name' => $ct->name,
+                'slug' => $ct->slug,
+                'categories' => $ct->rootCategories->map(function ($c) {
+                    return [
+                        'id'       => $c->id,
+                        'name'     => $c->name,
+                        'slug'     => $c->slug,
+                        'children' => $c->children->map(fn ($ch) => [
+                            'id'   => $ch->id,
+                            'name' => $ch->name,
+                            'slug' => $ch->slug,
+                        ])->values()->all(),
+                    ];
+                })->values()->all(),
+            ];
+        })->values()->all();
+    }
+}

app/Http/Controllers/User/TodayDownloadsController.php

@@ -39,7 +39,7 @@ class TodayDownloadsController extends Controller
             $ext = pathinfo($picture ?? '', PATHINFO_EXTENSION) ?: 'jpg';
             $encoded = null;
             $present = $art ? \App\Services\ThumbnailPresenter::present($art, 'md') : null;
-            $thumb = $present ? $present['url'] : '/gfx/sb_join.jpg';
+            $thumb = $present ? $present['url'] : 'https://files.skinbase.org/default/missing_md.webp';
             $categoryId = $art->categories->first()->id ?? null;
 
             return (object) [

app/Http/Controllers/User/TodayInHistoryController.php

@@ -68,11 +68,11 @@ class TodayInHistoryController extends Controller
                 /** @var ?Artwork $art */
                 $art = $modelsById->get($row->id);
                 if ($art) {
-                    $row->thumb_url = $art->thumbUrl('md') ?? '/gfx/sb_join.jpg';
+                    $row->thumb_url = $art->thumbUrl('md') ?? 'https://files.skinbase.org/default/missing_md.webp';
                     $row->art_url   = '/art/' . $art->id . '/' . $art->slug;
                     $row->name      = $art->title ?: ($row->name ?? 'Untitled');
                 } else {
-                    $row->thumb_url = '/gfx/sb_join.jpg';
+                    $row->thumb_url = 'https://files.skinbase.org/default/missing_md.webp';
                     $row->art_url   = '/art/' . $row->id;
                     $row->name      = $row->name ?? 'Untitled';
                 }

app/Http/Controllers/Web/DiscoverController.php

@@ -49,6 +49,23 @@ final class DiscoverController extends Controller
         ]);
     }
 
+    // ─── /discover/rising ────────────────────────────────────────────────────
+
+    public function rising(Request $request)
+    {
+        $perPage  = 24;
+        $results  = $this->searchService->discoverRising($perPage);
+        $this->hydrateDiscoverSearchResults($results);
+
+        return view('web.discover.index', [
+            'artworks'    => $results,
+            'page_title'  => 'Rising Now',
+            'section'     => 'rising',
+            'description' => 'Fastest growing artworks right now.',
+            'icon'        => 'fa-rocket',
+        ]);
+    }
+
     // ─── /discover/fresh ─────────────────────────────────────────────────────
 
     public function fresh(Request $request)