feat(photos): full EXIF metadata extraction, backfill and info panel

- backend: switch EXIF parser to dsoprea/go-exif/v3 (all recognised tags, numeric normalization); store in photos.exif jsonb (migration 000003); add storage.Get and cmd/backfill-exif to backfill existing photos from S3 originals
- frontend: info panel renders all EXIF attributes with RU labels, enum translation and units (1/N, f/N, mm, EV); service tags hidden
- viewer: remove make-cover action (cover managed from panel only), icon-only download
- openspec: sync lightroom-workspace-ui artifacts (EXIF, cover-from-panel) and add plan for configurable info attributes/labels stored in user profile

backend/internal/photos/store.go

@@ -2,6 +2,7 @@ package photos
 
 import (
 	"context"
+	"encoding/json"
 	"errors"
 	"time"
 
@@ -26,33 +27,50 @@ const photoColumns = `p.id, p.album_id, p.uploader_id, p.storage_key,
 	u.id, u.name, COALESCE(u.avatar_url, ''),
 	(SELECT count(*) FROM likes l WHERE l.photo_id = p.id),
 	(SELECT count(*) FROM comments c WHERE c.photo_id = p.id),
-	EXISTS(SELECT 1 FROM likes l WHERE l.photo_id = p.id AND l.user_id = $2)`
+	EXISTS(SELECT 1 FROM likes l WHERE l.photo_id = p.id AND l.user_id = $2),
+	COALESCE(p.exif, '{}'::jsonb)::text`
 
 func scanPhoto(row pgx.Row) (*models.Photo, error) {
 	var p models.Photo
+	var exifText string
 	err := row.Scan(&p.ID, &p.AlbumID, &p.UploaderID, &p.StorageKey,
 		&p.ThumbKey, &p.PreviewKey,
 		&p.OriginalFilename, &p.Size, &p.Width, &p.Height, &p.MimeType,
 		&p.TakenAt, &p.Latitude, &p.Longitude, &p.Caption, &p.CreatedAt,
 		&p.Uploader.ID, &p.Uploader.Name, &p.Uploader.AvatarURL,
-		&p.LikesCount, &p.CommentsCount, &p.LikedByMe)
+		&p.LikesCount, &p.CommentsCount, &p.LikedByMe, &exifText)
 	if err != nil {
 		if errors.Is(err, pgx.ErrNoRows) {
 			return nil, ErrNotFound
 		}
 		return nil, err
 	}
+	setExif(&p, exifText)
 	return &p, nil
 }
 
+func setExif(p *models.Photo, raw string) {
+	if raw == "" || raw == "null" || raw == "{}" {
+		return
+	}
+	var m map[string]any
+	if err := json.Unmarshal([]byte(raw), &m); err == nil && len(m) > 0 {
+		p.EXIF = m
+	}
+}
+
 func (s *Store) Create(ctx context.Context, p *models.Photo) error {
+	exifJSON, err := json.Marshal(p.EXIF)
+	if err != nil || len(exifJSON) == 0 {
+		exifJSON = []byte("{}")
+	}
 	return s.pool.QueryRow(ctx,
 		`INSERT INTO photos (id, album_id, uploader_id, storage_key, original_filename,
-			size, width, height, mime_type, taken_at, latitude, longitude, caption)
-		 VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13)
+			size, width, height, mime_type, taken_at, latitude, longitude, caption, exif)
+		 VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14::jsonb)
 		 RETURNING created_at`,
 		p.ID, p.AlbumID, p.UploaderID, p.StorageKey, p.OriginalFilename,
-		p.Size, p.Width, p.Height, p.MimeType, p.TakenAt, p.Latitude, p.Longitude, p.Caption,
+		p.Size, p.Width, p.Height, p.MimeType, p.TakenAt, p.Latitude, p.Longitude, p.Caption, string(exifJSON),
 	).Scan(&p.CreatedAt)
 }
 
@@ -98,14 +116,16 @@ func (s *Store) List(ctx context.Context, in ListParams) ([]models.Photo, error)
 	out := []models.Photo{}
 	for rows.Next() {
 		var p models.Photo
+		var exifText string
 		if err := rows.Scan(&p.ID, &p.AlbumID, &p.UploaderID, &p.StorageKey,
 			&p.ThumbKey, &p.PreviewKey,
 			&p.OriginalFilename, &p.Size, &p.Width, &p.Height, &p.MimeType,
 			&p.TakenAt, &p.Latitude, &p.Longitude, &p.Caption, &p.CreatedAt,
 			&p.Uploader.ID, &p.Uploader.Name, &p.Uploader.AvatarURL,
-			&p.LikesCount, &p.CommentsCount, &p.LikedByMe); err != nil {
+			&p.LikesCount, &p.CommentsCount, &p.LikedByMe, &exifText); err != nil {
 			return nil, err
 		}
+		setExif(&p, exifText)
 		out = append(out, p)
 	}
 	return out, rows.Err()
@@ -138,3 +158,59 @@ func (s *Store) UpdateFilename(ctx context.Context, id, filename string) error {
 	}
 	return nil
 }
+
+type backfillRow struct {
+	ID         string
+	StorageKey string
+}
+
+func (s *Store) BackfillEXIF(ctx context.Context, fetch func(context.Context, string) ([]byte, error)) (int, error) {
+	rows, err := s.pool.Query(ctx,
+		`SELECT id, storage_key FROM photos
+		 WHERE exif IS NULL OR exif = '{}'::jsonb
+		 ORDER BY created_at`)
+	if err != nil {
+		return 0, err
+	}
+	var pending []backfillRow
+	for rows.Next() {
+		var r backfillRow
+		if err := rows.Scan(&r.ID, &r.StorageKey); err != nil {
+			rows.Close()
+			return 0, err
+		}
+		pending = append(pending, r)
+	}
+	rows.Close()
+	if err := rows.Err(); err != nil {
+		return 0, err
+	}
+
+	updated := 0
+	for _, r := range pending {
+		data, err := fetch(ctx, r.StorageKey)
+		if err != nil {
+			continue
+		}
+		meta := extractEXIF(data)
+		if len(meta.Attributes) == 0 && meta.TakenAt == nil && meta.Latitude == nil && meta.Longitude == nil {
+			continue
+		}
+		attrs, err := json.Marshal(meta.Attributes)
+		if err != nil || len(attrs) == 0 {
+			attrs = []byte("{}")
+		}
+		_, err = s.pool.Exec(ctx,
+			`UPDATE photos SET exif = $2::jsonb,
+				taken_at = COALESCE(taken_at, $3),
+				latitude = COALESCE(latitude, $4),
+				longitude = COALESCE(longitude, $5)
+			 WHERE id = $1`,
+			r.ID, string(attrs), meta.TakenAt, meta.Latitude, meta.Longitude)
+		if err != nil {
+			continue
+		}
+		updated++
+	}
+	return updated, nil
+}