Generalize YouTube-backed endpoints behind a source parameter

Removes the last YouTube-specific routes (/youtube/*) and merges them
into the general track/album/playlist endpoints, keyed by a `source`
string validated against TrackSource. This mirrors the earlier track
search merge for albums and playlist-track additions:

- GetAlbums now merges local albums with live YouTube Music search
  results, paginated via a youtubeContinuationToken, deduped against
  already-materialized ExternalAlbum rows.
- New GET /albums/external/{source}/{externalId} and
  GET /tracks/external/{source}/{externalId}/stream replace the
  YouTube-only equivalents.
- POST /playlists/{id}/tracks replaces the separate
  .../youtube-tracks endpoint, accepting an optional Source/ExternalId
  pair alongside TrackId.
- AlbumSearchItemResponse/AlbumsSearchResponse follow the same
  discriminated-union + trailing-HasNextPage-field pattern already
  used for track search, so HasNextPage stays a required field in the
  generated OpenAPI schema.
- Frontend routes renamed accordingly (/albums/youtube/[albumId] ->
  /albums/external/[source]/[externalId], etc.) with a single
  /api/thumbnail proxy replacing /api/youtube/thumbnail.

Musify.Api.Endpoints.YouTubeEndpoints and the standalone
SearchYouTubeAlbums query are removed as a result.

web-player/src/lib/albums.ts

@@ -16,7 +16,7 @@ export async function fetchAlbumQueueItems(
 		return toQueueItems(data.items ?? []);
 	}
 
-	const res = await fetch(`/api/albums/youtube/${albumId}/tracks`);
+	const res = await fetch(`/api/albums/external/${kind}/${albumId}/tracks`);
 	if (!res.ok) return [];
 	const detail = (await res.json()) as YouTubeAlbumTracksResponse;
 	return detail.tracks.map((track) => ({

web-player/src/lib/player/player.svelte.ts

@@ -305,7 +305,7 @@ class PlayerState {
 	}
 
 	async #resolveYouTubeSrc(videoId: string): Promise<string> {
-		const res = await fetch(`/api/youtube/tracks/${videoId}/stream`);
+		const res = await fetch(`/api/tracks/external/youtube/${videoId}/stream`);
 		if (!res.ok) throw new Error(await readErrorMessage(res));
 		const { mode, streamUrl, ticket } = (await res.json()) as {
 			mode: string;

web-player/src/lib/server/playlistActions.ts

@@ -15,8 +15,9 @@ export async function addTrackAction({ request, params, locals, fetch }: Request
 	}
 
 	const api = createApiClient({ fetch, accessToken });
-	const { error: err, response } = await api.POST('/playlists/{playlistId}/tracks/{trackId}', {
-		params: { path: { playlistId, trackId } }
+	const { error: err, response } = await api.POST('/playlists/{playlistId}/tracks', {
+		params: { path: { playlistId } },
+		body: { trackId, source: null, externalId: null }
 	});
 
 	if (err) {
@@ -36,19 +37,15 @@ export async function addYouTubeToPlaylistAction({ request, params, locals, fetc
 	const form = await request.formData();
 	const playlistId = String(form.get('playlistId') ?? '') || String(params.id ?? '');
 	const videoId = String(form.get('videoId') ?? '');
-	const title = String(form.get('title') ?? '');
-	const artist = String(form.get('artist') ?? '');
-	const durationSeconds = Number(form.get('durationSeconds') ?? 0);
-	const thumbnailUrl = String(form.get('thumbnailUrl') ?? '');
 
-	if (!playlistId || !videoId || !title) {
+	if (!playlistId || !videoId) {
 		return fail(400, { message: 'Faltan datos de la canción.' });
 	}
 
 	const api = createApiClient({ fetch, accessToken });
-	const { error: err, response } = await api.POST('/playlists/{playlistId}/youtube-tracks', {
+	const { error: err, response } = await api.POST('/playlists/{playlistId}/tracks', {
 		params: { path: { playlistId } },
-		body: { videoId, title, artist, durationSeconds, thumbnailUrl }
+		body: { trackId: null, source: 'YouTube', externalId: videoId }
 	});
 
 	if (err) {
@@ -84,8 +81,9 @@ export async function addAlbumToPlaylistAction({ request, params, locals, fetch
 
 	let added = 0;
 	for (const track of tracks.items) {
-		const { error: err } = await api.POST('/playlists/{playlistId}/tracks/{trackId}', {
-			params: { path: { playlistId, trackId: String(track.id) } }
+		const { error: err } = await api.POST('/playlists/{playlistId}/tracks', {
+			params: { path: { playlistId } },
+			body: { trackId: String(track.id), source: null, externalId: null }
 		});
 		if (!err) added++;
 	}
@@ -111,8 +109,8 @@ export async function addYoutubeAlbumToPlaylistAction({
 	}
 
 	const api = createApiClient({ fetch, accessToken });
-	const { data: detail, error: detailErr } = await api.GET('/youtube/albums/{albumId}', {
-		params: { path: { albumId } }
+	const { data: detail, error: detailErr } = await api.GET('/albums/external/{source}/{externalId}', {
+		params: { path: { source: 'YouTube', externalId: albumId } }
 	});
 
 	if (detailErr || !detail) {
@@ -121,15 +119,9 @@ export async function addYoutubeAlbumToPlaylistAction({
 
 	let added = 0;
 	for (const track of detail.tracks) {
-		const { error: err } = await api.POST('/playlists/{playlistId}/youtube-tracks', {
+		const { error: err } = await api.POST('/playlists/{playlistId}/tracks', {
 			params: { path: { playlistId } },
-			body: {
-				videoId: track.videoId,
-				title: track.title,
-				artist: detail.album.artist,
-				durationSeconds: Number(track.durationSeconds),
-				thumbnailUrl: detail.album.thumbnailUrl
-			}
+			body: { trackId: null, source: 'YouTube', externalId: track.videoId }
 		});
 		if (!err) added++;
 	}

web-player/src/lib/thumbnails.ts

@@ -6,7 +6,7 @@ export const THUMBNAIL_SIZES = {
 
 export type ThumbnailSize = keyof typeof THUMBNAIL_SIZES;
 
-const PROXY_PATH = '/api/youtube/thumbnail';
+const PROXY_PATH = '/api/thumbnail';
 
 export function thumbnailSrc(
 	url: string | undefined,

web-player/src/routes/(app)/albums/external/[source]/[externalId]/+page.server.ts

@@ -10,13 +10,15 @@ export const load: PageServerLoad = async ({ params, locals, url, fetch }) => {
 	const api = createApiClient({ fetch, accessToken: locals.accessToken ?? undefined });
 
 	const [albumRes, playlistsRes] = await Promise.all([
-		api.GET('/youtube/albums/{albumId}', { params: { path: { albumId: params.albumId } } }),
+		api.GET('/albums/external/{source}/{externalId}', {
+			params: { path: { source: params.source, externalId: params.externalId } }
+		}),
 		api.GET('/playlists/users/{userId}', {
 			params: { path: { userId: user.sub }, query: { pageNumber: 1, pageSize: 50 } }
 		})
 	]);
 
-	const album = unwrapOrError(albumRes, 'No se pudo cargar el álbum de YouTube Music.', 404);
+	const album = unwrapOrError(albumRes, 'No se pudo cargar el álbum.', 404);
 
 	return { album, playlists: playlistsRes.data?.items ?? [], section: null };
 };

web-player/src/routes/(app)/explore/+page.server.ts

@@ -10,7 +10,6 @@ import {
 import {
 	EXPLORE_ALBUMS_PAGE_SIZE,
 	EXPLORE_PAGE_SIZE as PAGE_SIZE,
-	SEARCH_MIN_LENGTH,
 	YOUTUBE_FILLER_LIMIT
 } from '$lib/config';
 import { searchUsers } from '$lib/server/userDirectory';
@@ -36,25 +35,21 @@ export const load: PageServerLoad = async ({ url, locals, fetch }) => {
 			})
 		: Promise.resolve(null);
 
-	const youtubeAlbumsPromise =
-		query.length >= SEARCH_MIN_LENGTH
-			? api.GET('/youtube/albums', { params: { query: { query } } })
-			: Promise.resolve(null);
-
-	const [tracksRes, playlistsRes, albumsRes, youtubeAlbumsRes] = await Promise.all([
+	const [tracksRes, playlistsRes, albumsRes] = await Promise.all([
 		tracksPromise,
 		playlistsPromise,
-		albumsPromise,
-		youtubeAlbumsPromise
+		albumsPromise
 	]);
 
 	const tracks = unwrapOrError(tracksRes, 'No se pudieron cargar las canciones.');
 
+	const albumItems = albumsRes?.data?.items ?? [];
+
 	return {
 		query,
 		tracks,
-		albums: albumsRes?.data?.items ?? [],
-		youtubeAlbums: youtubeAlbumsRes?.data?.items ?? [],
+		albums: albumItems.flatMap((item) => (item.album ? [item.album] : [])),
+		youtubeAlbums: albumItems.flatMap((item) => (item.youTubeAlbum ? [item.youTubeAlbum] : [])),
 		users: searchUsers(query),
 		youtubeFiller: query
 			? Promise.resolve(null)

web-player/src/routes/(app)/explore/+page.svelte

@@ -282,7 +282,7 @@
 							</a>
 						{:else}
 							<a
-								href="/albums/youtube/{entry.album.albumId}"
+								href="/albums/external/youtube/{entry.album.albumId}"
 								class="group/card animate-enter block min-w-0 rounded-art focus-visible:ring-2 focus-visible:ring-accent focus-visible:ring-offset-2 focus-visible:ring-offset-bg focus-visible:outline-none"
 								style="animation-delay:{Math.min(i, 10) * 45}ms"
 								oncontextmenu={(e) => openAlbumMenu(e, 'youtube', entry.album.albumId)}

web-player/src/routes/+page.svelte

@@ -215,7 +215,7 @@
 				{#each albums as album, i (album.id)}
 					<a
 						href={album.youTubeAlbumId
-							? `/albums/youtube/${album.youTubeAlbumId}`
+							? `/albums/external/youtube/${album.youTubeAlbumId}`
 							: `/albums/${album.id}`}
 						class="group/card animate-enter block w-42 shrink-0 rounded-art focus-visible:ring-2 focus-visible:ring-accent focus-visible:ring-offset-2 focus-visible:ring-offset-bg focus-visible:outline-none"
 						style="animation-delay:{Math.min(i, 10) * 45}ms"

web-player/src/routes/api/albums/external/[source]/[externalId]/tracks/+server.ts

@@ -4,9 +4,9 @@ import { createApiClient, unwrapOrError } from '$lib/server/api';
 
 export const GET: RequestHandler = async ({ params, locals, fetch }) => {
 	const api = createApiClient({ fetch, accessToken: locals.accessToken ?? undefined });
-	const result = await api.GET('/youtube/albums/{albumId}', {
-		params: { path: { albumId: params.albumId } }
+	const result = await api.GET('/albums/external/{source}/{externalId}', {
+		params: { path: { source: params.source, externalId: params.externalId } }
 	});
 
-	return json(unwrapOrError(result, 'No se pudo cargar el álbum de YouTube.'));
+	return json(unwrapOrError(result, 'No se pudo cargar el álbum.'));
 };

web-player/src/routes/api/tracks/external/[source]/[externalId]/stream/+server.ts

@@ -6,9 +6,9 @@ export const GET: RequestHandler = async ({ params, locals, fetch }) => {
 	const accessToken = requireAccessToken(locals, 'Inicia sesión para reproducir.');
 
 	const api = createApiClient({ fetch, accessToken });
-	const result = await api.GET('/youtube/tracks/{videoId}/stream', {
-		params: { path: { videoId: params.videoId } }
+	const result = await api.GET('/tracks/external/{source}/{externalId}/stream', {
+		params: { path: { source: params.source, externalId: params.externalId } }
 	});
 
-	return json(unwrapOrError(result, 'No se pudo obtener el stream de YouTube.'));
+	return json(unwrapOrError(result, 'No se pudo obtener el stream.'));
 };