feat: implement 1B domain entities/repos + 1H library API routes

1B — domain layer:
- New entities: Album, Playlist, Like, PlayHistoryEntry
- Track entity extended with album_id, genre, year fields
- New protocols: AlbumRepository, PlaylistRepository, LikeRepository, HistoryRepository
- ArtistRepository / TrackRepository protocols extended (list, count, update, get_many, etc.)
- New repos: SqlAlchemyAlbum/Playlist/Like/HistoryRepository
- Artist and track repos updated to match extended protocols

1H — library API:
- Pagination: PagedResponse[T] generic, offset-based, limit default 50 max 200
- Schemas: TrackOut, AlbumOut, ArtistOut, PlaylistOut/Create/Update,
  LikeEvent/State, HistoryIn/Out, LibrarySearchResponse
- GET/PATCH/DELETE /tracks with filters, sort, pagination
- GET /albums, /albums/{id}, /albums/{id}/tracks
- GET /artists, /artists/{id}, /artists/{id}/albums, /artists/{id}/tracks
- GET /search/library (ILIKE across tracks/albums/artists)
- Full /playlists CRUD + track add/remove (append-only version bump)
- POST /likes (append-only event log), GET /likes, GET /likes/state
- POST /history (scrobble), GET /history
- deps.py: TrackRepoDep, ArtistRepoDep, AlbumRepoDep, PlaylistRepoDep,
  LikeRepoDep, HistoryRepoDep

ruff ✅  mypy ✅  pytest 45/45 ✅

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

app/infrastructure/db/repositories/album_repository.py

@@ -0,0 +1,87 @@
+"""Album repository — adapter over ``AsyncSession``."""
+
+import uuid
+
+from sqlalchemy import func, select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.domain.entities.album import Album
+from app.infrastructure.db.models.album import AlbumModel
+from app.infrastructure.db.models.track import TrackModel
+
+
+def _to_entity(row: AlbumModel) -> Album:
+    return Album(
+        id=row.id,
+        title=row.title,
+        artist_id=row.artist_id,
+        year=row.year,
+        cover_path=row.cover_path,
+        musicbrainz_id=row.musicbrainz_id,
+        created_at=row.created_at,
+        updated_at=row.updated_at,
+    )
+
+
+class SqlAlchemyAlbumRepository:
+    def __init__(self, session: AsyncSession) -> None:
+        self._session = session
+
+    async def get_by_id(self, album_id: uuid.UUID) -> Album | None:
+        row = await self._session.get(AlbumModel, album_id)
+        return _to_entity(row) if row is not None else None
+
+    async def get_many(self, ids: list[uuid.UUID]) -> list[Album]:
+        if not ids:
+            return []
+        rows = (
+            (await self._session.execute(select(AlbumModel).where(AlbumModel.id.in_(ids))))
+            .scalars()
+            .all()
+        )
+        return [_to_entity(r) for r in rows]
+
+    async def count(self, *, artist_id: uuid.UUID | None, q: str | None) -> int:
+        stmt = select(func.count()).select_from(AlbumModel)
+        if artist_id is not None:
+            stmt = stmt.where(AlbumModel.artist_id == artist_id)
+        if q:
+            stmt = stmt.where(AlbumModel.title.ilike(f"%{q}%"))
+        return (await self._session.execute(stmt)).scalar_one()
+
+    async def track_count(self, album_id: uuid.UUID) -> int:
+        return (
+            await self._session.execute(
+                select(func.count()).select_from(TrackModel).where(TrackModel.album_id == album_id)
+            )
+        ).scalar_one()
+
+    async def track_count_many(self, album_ids: list[uuid.UUID]) -> dict[uuid.UUID, int]:
+        if not album_ids:
+            return {}
+        rows = (
+            await self._session.execute(
+                select(TrackModel.album_id, func.count(TrackModel.id).label("cnt"))
+                .where(TrackModel.album_id.in_(album_ids))
+                .group_by(TrackModel.album_id)
+            )
+        ).all()
+        return {row.album_id: row.cnt for row in rows}
+
+    # list must come after methods using list[...] in signatures (builtin name shadowing)
+    async def list(
+        self,
+        *,
+        artist_id: uuid.UUID | None,
+        q: str | None,
+        limit: int,
+        offset: int,
+    ) -> list[Album]:
+        stmt = select(AlbumModel)
+        if artist_id is not None:
+            stmt = stmt.where(AlbumModel.artist_id == artist_id)
+        if q:
+            stmt = stmt.where(AlbumModel.title.ilike(f"%{q}%"))
+        stmt = stmt.order_by(AlbumModel.title).limit(limit).offset(offset)
+        rows = (await self._session.execute(stmt)).scalars().all()
+        return [_to_entity(r) for r in rows]