fix: use content_type for image format detection on mobile uploads (#489)

on iOS, selecting a HEIC photo from the Photos library often results
in a file with a .heic filename but jpeg content (iOS converts on the
fly). the backend was using only the filename extension to validate
image format, causing these files to be silently rejected.

changes:
- backend: add from_content_type() method to ImageFormat
- backend: validate_and_extract() now prefers content_type over extension
- backend: pass image content_type through upload pipeline
- frontend: use accept="image/*" for broader iOS compatibility
- tests: add coverage for iOS HEIC case

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-authored-by: Claude <[e-mail]>

backend/src/backend/_internal/image.py

···
         return None
 
     @classmethod
+    def from_content_type(cls, content_type: str | None) -> "ImageFormat | None":
+        """extract image format from MIME content type.
+
+        this is more reliable than filename extension, especially on iOS
+        where HEIC photos may be converted to JPEG but keep the .heic filename.
+        """
+        if not content_type:
+            return None
+
+        content_type = content_type.lower().split(";")[0].strip()
+        mapping = {
+            "image/jpeg": cls.JPEG,
+            "image/jpg": cls.JPEG,
+            "image/png": cls.PNG,
+            "image/webp": cls.WEBP,
+            "image/gif": cls.GIF,
+        }
+        return mapping.get(content_type)
+
+    @classmethod
     def validate_and_extract(
-        cls, filename: str | None
+        cls, filename: str | None, content_type: str | None = None
     ) -> tuple["ImageFormat | None", bool]:
-        """validate image format from filename.
+        """validate image format from filename or content type.
+
+        prefers content_type over filename extension when available, since
+        iOS may convert HEIC to JPEG but keep the original filename.
 
         returns:
             tuple of (image_format, is_valid) where:
···
         unconditionally used.
 
         usage:
-            image_format, is_valid = ImageFormat.validate_and_extract(filename)
+            image_format, is_valid = ImageFormat.validate_and_extract(filename, content_type)
             if not is_valid:
                 logger.warning(f"unsupported image format: {filename}")
         """
         if not filename:
             return None, True
 
+        # prefer content_type over filename - more reliable on iOS
+        if content_type:
+            image_format = cls.from_content_type(content_type)
+            if image_format:
+                return image_format, True
+
+        # fall back to filename extension
         image_format = cls.from_filename(filename)
         return image_format, image_format is not None

backend/src/backend/api/tracks/uploads.py

···
     auth_session: AuthSession,
     image_path: str | None = None,
     image_filename: str | None = None,
+    image_content_type: str | None = None,
 ) -> None:
     """Background task to process upload."""
     with logfire.span(
···
                     "saving image...",
                     phase="image",
                 )
+                # use content_type for format detection (more reliable on iOS)
                 image_format, is_valid = ImageFormat.validate_and_extract(
-                    image_filename
+                    image_filename, image_content_type
                 )
                 if is_valid and image_format:
                     try:
···
 
         # stream image to temp file if provided
         image_filename = None
+        image_content_type = None
         if image and image.filename:
             image_filename = image.filename
+            image_content_type = image.content_type
             # images have much smaller limit (20MB is generous for cover art)
             max_image_size = 20 * 1024 * 1024
             image_bytes_read = 0
···
             auth_session,
             image_path,
             image_filename,
+            image_content_type,
         )
     except Exception:
         if file_path:

backend/tests/test_image_formats.py

···
         assert (
             ImageFormat.from_filename("C:\\Users\\test\\pic.webp") == ImageFormat.WEBP
         )
+
+    @pytest.mark.parametrize(
+        ("content_type", "expected_format"),
+        [
+            ("image/jpeg", ImageFormat.JPEG),
+            ("image/jpg", ImageFormat.JPEG),
+            ("image/png", ImageFormat.PNG),
+            ("image/webp", ImageFormat.WEBP),
+            ("image/gif", ImageFormat.GIF),
+            # with charset
+            ("image/jpeg; charset=utf-8", ImageFormat.JPEG),
+            # case insensitive
+            ("IMAGE/JPEG", ImageFormat.JPEG),
+            ("Image/Png", ImageFormat.PNG),
+        ],
+    )
+    def test_from_content_type_supported(
+        self, content_type: str, expected_format: ImageFormat
+    ):
+        """test supported content type recognition."""
+        assert ImageFormat.from_content_type(content_type) == expected_format
+
+    @pytest.mark.parametrize(
+        "content_type",
+        [
+            "image/heic",
+            "image/bmp",
+            "image/tiff",
+            "application/octet-stream",
+            "",
+            None,
+        ],
+    )
+    def test_from_content_type_unsupported(self, content_type: str | None):
+        """test unsupported content types return None."""
+        assert ImageFormat.from_content_type(content_type) is None
+
+    def test_validate_and_extract_prefers_content_type(self):
+        """test that content_type is preferred over filename extension.
+
+        this is the iOS HEIC case: filename is .heic but content is jpeg.
+        """
+        # HEIC filename but JPEG content type -> should return JPEG
+        image_format, is_valid = ImageFormat.validate_and_extract(
+            "IMG_1234.HEIC", "image/jpeg"
+        )
+        assert is_valid is True
+        assert image_format == ImageFormat.JPEG
+
+    def test_validate_and_extract_falls_back_to_filename(self):
+        """test fallback to filename when no content_type provided."""
+        image_format, is_valid = ImageFormat.validate_and_extract("photo.png", None)
+        assert is_valid is True
+        assert image_format == ImageFormat.PNG
+
+    def test_validate_and_extract_unsupported_both(self):
+        """test unsupported format when both filename and content_type are invalid."""
+        image_format, is_valid = ImageFormat.validate_and_extract(
+            "image.heic", "image/heic"
+        )
+        assert is_valid is False
+        assert image_format is None

frontend/src/routes/upload/+page.svelte

···
 				<input
 					id="image-input"
 					type="file"
-					accept=".jpg,.jpeg,.png,.webp,.gif,image/jpeg,image/png,image/webp,image/gif"
+					accept="image/*"
 					onchange={handleImageChange}
 				/>
 				<p class="format-hint">supported: jpg, png, webp, gif</p>