reject AIFF/AIF uploads due to browser compatibility (#152)

* fix: support .aif file extension for AIFF audio files

problem:
- users uploading .aif files would see "upload successful" but files were unusable
- files were saved to R2 with .aif extension
- get_url() only checked for .aiff extension
- resulted in 404 errors when trying to play the track

solution:
- add AIF as a separate AudioFormat enum value alongside AIFF
- both map to the same media type (audio/aiff)
- storage backends now automatically check for both extensions
- no special-casing needed since enum iteration handles both

fixes #147

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

Co-Authored-By: Claude <[e-mail]>

* reject AIFF/AIF uploads and add format hints

- remove AIFF/AIF from AudioFormat enum (browser compatibility)
- add format hints to audio and artwork upload inputs
- add logfire instrumentation to upload background tasks
- document logfire querying patterns for background tasks
- clean up debug console.log statements from Player
- update tests to reflect removed AIFF support
- add root node_modules to .gitignore

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

Co-Authored-By: Claude <[e-mail]>

---------

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

.gitignore

···
 Thumbs.db
 
 # Frontend
+node_modules/
 frontend/node_modules/
 frontend/.svelte-kit/
 frontend/build/

docs/logfire-querying.md

···
 ORDER BY duration DESC
 ```
 
+## Background Task and Storage Queries
+
+**Search by message content:**
+```sql
+SELECT
+  span_name,
+  message,
+  start_timestamp,
+  attributes
+FROM records
+WHERE message LIKE '%R2%' OR message LIKE '%upload%'
+ORDER BY start_timestamp DESC
+LIMIT 10
+```
+
+**Get full trace for a background task:**
+```sql
+-- First, find the trace_id for your background task
+SELECT trace_id, message, start_timestamp
+FROM records
+WHERE span_name = 'process upload background'
+ORDER BY start_timestamp DESC
+LIMIT 1;
+
+-- Then get all spans in that trace
+SELECT
+  span_name,
+  message,
+  start_timestamp,
+  duration * 1000 as duration_ms
+FROM records
+WHERE trace_id = '<trace-id-from-above>'
+ORDER BY start_timestamp ASC;
+```
+
+**Extract nested attributes from JSONB:**
+```sql
+-- Get bucket and key from R2 upload logs
+SELECT
+  message,
+  attributes->>'bucket' as bucket,
+  attributes->>'key' as key,
+  attributes->>'file_id' as file_id,
+  start_timestamp
+FROM records
+WHERE message = 'uploading to R2'
+ORDER BY start_timestamp DESC
+LIMIT 5;
+```
+
+**Find spans within a time range:**
+```sql
+SELECT
+  span_name,
+  message,
+  start_timestamp,
+  duration * 1000 as duration_ms
+FROM records
+WHERE start_timestamp > '2025-11-11T04:56:50Z'
+  AND start_timestamp < '2025-11-11T04:57:10Z'
+  AND (span_name LIKE '%R2%' OR message LIKE '%save%')
+ORDER BY start_timestamp ASC;
+```
+
+**Common mistake: Not all log levels create spans**
+
+When using `logfire.info()`, these create log events, not spans. To find them:
+- Search by `message` field, not `span_name`
+- Use LIKE with wildcards: `message LIKE '%preparing%'`
+- Filter by `kind = 'event'` if you only want logs (not spans)
+
+Example:
+```sql
+-- WRONG: This won't find logfire.info() calls
+SELECT * FROM records WHERE span_name = 'preparing to save audio file';
+
+-- RIGHT: Search by message instead
+SELECT * FROM records WHERE message LIKE '%preparing%';
+```
+
 ## Known Issues
 
 ### `/tracks/` 500 Error on First Load

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

···
 	import { API_URL } from '$lib/config';
 	import { uploader } from '$lib/uploader.svelte';
 
-	const ACCEPTED_AUDIO_EXTENSIONS = ['.mp3', '.wav', '.m4a', '.aif', '.aiff'];
-	const ACCEPTED_AUDIO_MIME_TYPES = ['audio/mpeg', 'audio/wav', 'audio/mp4', 'audio/aiff', 'audio/x-aiff'];
+	// browser-compatible audio formats only
+	// note: aiff/aif not supported in most browsers (safari only)
+	const ACCEPTED_AUDIO_EXTENSIONS = ['.mp3', '.wav', '.m4a'];
+	const ACCEPTED_AUDIO_MIME_TYPES = ['audio/mpeg', 'audio/wav', 'audio/mp4'];
 	const FILE_INPUT_ACCEPT = [...ACCEPTED_AUDIO_EXTENSIONS, ...ACCEPTED_AUDIO_MIME_TYPES].join(',');
 
 	function isSupportedAudioFile(name: string): boolean {
 		const dotIndex = name.lastIndexOf('.');
 		if (dotIndex === -1) return false;
 		const ext = name.slice(dotIndex).toLowerCase();
-		if (ext === '.aif') {
-			return true;
-		}
 		return ACCEPTED_AUDIO_EXTENSIONS.includes(ext);
 	}
 
···
 						onchange={handleFileChange}
 						required
 					/>
+					<p class="format-hint">supported: mp3, wav, m4a</p>
 					{#if file}
 						<p class="file-info">{file.name} ({(file.size / 1024 / 1024).toFixed(2)} MB)</p>
 					{/if}
···
 							imageFile = target.files?.[0] ?? null;
 						}}
 					/>
+					<p class="format-hint">supported: jpg, png, webp, gif</p>
 					{#if imageFile}
 						<p class="file-info">{imageFile.name} ({(imageFile.size / 1024 / 1024).toFixed(2)} MB)</p>
 					{/if}
···
 	input[type='file']:disabled {
 		opacity: 0.5;
 		cursor: not-allowed;
+	}
+
+	.format-hint {
+		margin-top: 0.25rem;
+		font-size: 0.8rem;
+		color: #888;
 	}
 
 	.file-info {

src/backend/api/tracks.py

···
 from pathlib import Path
 from typing import Annotated
 
+import logfire
 from fastapi import (
     APIRouter,
     BackgroundTasks,
···
     image_filename: str | None = None,
 ) -> None:
     """background task to process upload."""
-    try:
-        upload_tracker.update_status(
-            upload_id, UploadStatus.PROCESSING, "processing upload..."
-        )
-
-        # validate file type
-        ext = Path(filename).suffix.lower()
-        audio_format = AudioFormat.from_extension(ext)
-        if not audio_format:
-            upload_tracker.update_status(
-                upload_id,
-                UploadStatus.FAILED,
-                "upload failed",
-                error=f"unsupported file type: {ext}",
-            )
-            return
-
-        # save audio file
-        upload_tracker.update_status(
-            upload_id, UploadStatus.PROCESSING, "saving audio file..."
-        )
+    with logfire.span(
+        "process upload background", upload_id=upload_id, filename=filename
+    ):
         try:
-            file_obj = BytesIO(file_data)
-            file_id = await storage.save(file_obj, filename)
-        except ValueError as e:
             upload_tracker.update_status(
-                upload_id, UploadStatus.FAILED, "upload failed", error=str(e)
-            )
-            return
-
-        # get R2 URL
-        r2_url = None
-        if settings.storage.backend == "r2":
-            from backend.storage.r2 import R2Storage
-
-            if isinstance(storage, R2Storage):
-                r2_url = await storage.get_url(file_id)
-
-        # save image if provided
-        image_id = None
-        image_url = None
-        if image_data and image_filename:
-            upload_tracker.update_status(
-                upload_id, UploadStatus.PROCESSING, "saving image..."
+                upload_id, UploadStatus.PROCESSING, "processing upload..."
             )
-            image_format, is_valid = ImageFormat.validate_and_extract(image_filename)
-            if is_valid and image_format:
-                try:
-                    image_obj = BytesIO(image_data)
-                    # save with images/ prefix to namespace it
-                    image_id = await storage.save(image_obj, f"images/{image_filename}")
-                    # get R2 URL for image if using R2 storage
-                    if settings.storage.backend == "r2" and isinstance(
-                        storage, R2Storage
-                    ):
-                        image_url = await storage.get_url(image_id)
-                except Exception as e:
-                    logger.warning(f"failed to save image: {e}", exc_info=True)
-                    # continue without image - it's optional
-            else:
-                logger.warning(f"unsupported image format: {image_filename}")
 
-        # get artist and resolve features
-        async with db_session() as db:
-            result = await db.execute(select(Artist).where(Artist.did == artist_did))
-            artist = result.scalar_one_or_none()
-            if not artist:
+            # validate file type
+            ext = Path(filename).suffix.lower()
+            audio_format = AudioFormat.from_extension(ext)
+            if not audio_format:
                 upload_tracker.update_status(
                     upload_id,
                     UploadStatus.FAILED,
                     "upload failed",
-                    error="artist profile not found",
+                    error=f"unsupported file type: {ext}",
                 )
                 return
 
-            # resolve featured artist handles
-            featured_artists = []
-            if features:
+            # save audio file
+            upload_tracker.update_status(
+                upload_id, UploadStatus.PROCESSING, "saving audio file..."
+            )
+            try:
+                logfire.info(
+                    "preparing to save audio file",
+                    filename=filename,
+                    file_data_size=len(file_data),
+                )
+                file_obj = BytesIO(file_data)
+                logfire.info("calling storage.save")
+                file_id = await storage.save(file_obj, filename)
+                logfire.info("storage.save completed", file_id=file_id)
+            except ValueError as e:
+                logfire.error("ValueError during storage.save", error=str(e))
                 upload_tracker.update_status(
-                    upload_id, UploadStatus.PROCESSING, "resolving featured artists..."
+                    upload_id, UploadStatus.FAILED, "upload failed", error=str(e)
                 )
-                try:
-                    handles_list = json.loads(features)
-                    if isinstance(handles_list, list):
-                        for handle in handles_list:
-                            if (
-                                isinstance(handle, str)
-                                and handle.lstrip("@") != artist.handle
-                            ):
-                                resolved = await resolve_handle(handle)
-                                if resolved:
-                                    featured_artists.append(resolved)
-                except json.JSONDecodeError:
-                    pass  # ignore malformed features
-
-            # create ATProto record
-            atproto_uri = None
-            atproto_cid = None
-            if r2_url:
+                return
+            except Exception as e:
+                logfire.error(
+                    "unexpected exception during storage.save",
+                    error=str(e),
+                    exc_info=True,
+                )
                 upload_tracker.update_status(
-                    upload_id, UploadStatus.PROCESSING, "creating atproto record..."
+                    upload_id, UploadStatus.FAILED, "upload failed", error=str(e)
                 )
-                try:
-                    result = await create_track_record(
-                        auth_session=auth_session,
-                        title=title,
-                        artist=artist.display_name,
-                        audio_url=r2_url,
-                        file_type=ext[1:],
-                        album=album,
-                        duration=None,
-                        features=featured_artists if featured_artists else None,
-                        image_url=image_url,
-                    )
-                    if result:
-                        atproto_uri, atproto_cid = result
-                except Exception as e:
-                    logger.warning(
-                        f"failed to create ATProto record: {e}", exc_info=True
-                    )
+                return
 
-            # create track record
-            upload_tracker.update_status(
-                upload_id, UploadStatus.PROCESSING, "saving track metadata..."
-            )
-            extra = {}
-            if album:
-                extra["album"] = album
+            # get R2 URL
+            r2_url = None
+            if settings.storage.backend == "r2":
+                from backend.storage.r2 import R2Storage
 
-            track = Track(
-                title=title,
-                file_id=file_id,
-                file_type=ext[1:],
-                artist_did=artist_did,
-                extra=extra,
-                features=featured_artists,
-                r2_url=r2_url,
-                atproto_record_uri=atproto_uri,
-                atproto_record_cid=atproto_cid,
-                image_id=image_id,
-            )
+                if isinstance(storage, R2Storage):
+                    r2_url = await storage.get_url(file_id)
 
-            db.add(track)
-            try:
-                await db.commit()
-                await db.refresh(track)
+            # save image if provided
+            image_id = None
+            image_url = None
+            if image_data and image_filename:
+                upload_tracker.update_status(
+                    upload_id, UploadStatus.PROCESSING, "saving image..."
+                )
+                image_format, is_valid = ImageFormat.validate_and_extract(
+                    image_filename
+                )
+                if is_valid and image_format:
+                    try:
+                        image_obj = BytesIO(image_data)
+                        # save with images/ prefix to namespace it
+                        image_id = await storage.save(
+                            image_obj, f"images/{image_filename}"
+                        )
+                        # get R2 URL for image if using R2 storage
+                        if settings.storage.backend == "r2" and isinstance(
+                            storage, R2Storage
+                        ):
+                            image_url = await storage.get_url(image_id)
+                    except Exception as e:
+                        logger.warning(f"failed to save image: {e}", exc_info=True)
+                        # continue without image - it's optional
+                else:
+                    logger.warning(f"unsupported image format: {image_filename}")
 
-                # send notification about new track
-                from backend._internal.notifications import notification_service
+            # get artist and resolve features
+            async with db_session() as db:
+                result = await db.execute(
+                    select(Artist).where(Artist.did == artist_did)
+                )
+                artist = result.scalar_one_or_none()
+                if not artist:
+                    upload_tracker.update_status(
+                        upload_id,
+                        UploadStatus.FAILED,
+                        "upload failed",
+                        error="artist profile not found",
+                    )
+                    return
 
-                try:
-                    # eagerly load artist for notification
-                    await db.refresh(track, ["artist"])
-                    await notification_service.send_track_notification(track)
-                except Exception as e:
-                    logger.warning(
-                        f"failed to send notification for track {track.id}: {e}"
+                # resolve featured artist handles
+                featured_artists = []
+                if features:
+                    upload_tracker.update_status(
+                        upload_id,
+                        UploadStatus.PROCESSING,
+                        "resolving featured artists...",
                     )
+                    try:
+                        handles_list = json.loads(features)
+                        if isinstance(handles_list, list):
+                            for handle in handles_list:
+                                if (
+                                    isinstance(handle, str)
+                                    and handle.lstrip("@") != artist.handle
+                                ):
+                                    resolved = await resolve_handle(handle)
+                                    if resolved:
+                                        featured_artists.append(resolved)
+                    except json.JSONDecodeError:
+                        pass  # ignore malformed features
 
+                # create ATProto record
+                atproto_uri = None
+                atproto_cid = None
+                if r2_url:
+                    upload_tracker.update_status(
+                        upload_id, UploadStatus.PROCESSING, "creating atproto record..."
+                    )
+                    try:
+                        result = await create_track_record(
+                            auth_session=auth_session,
+                            title=title,
+                            artist=artist.display_name,
+                            audio_url=r2_url,
+                            file_type=ext[1:],
+                            album=album,
+                            duration=None,
+                            features=featured_artists if featured_artists else None,
+                            image_url=image_url,
+                        )
+                        if result:
+                            atproto_uri, atproto_cid = result
+                    except Exception as e:
+                        logger.warning(
+                            f"failed to create ATProto record: {e}", exc_info=True
+                        )
+
+                # create track record
                 upload_tracker.update_status(
-                    upload_id,
-                    UploadStatus.COMPLETED,
-                    "upload completed successfully",
-                    track_id=track.id,
+                    upload_id, UploadStatus.PROCESSING, "saving track metadata..."
                 )
+                extra = {}
+                if album:
+                    extra["album"] = album
 
-            except IntegrityError as e:
-                await db.rollback()
-                # integrity errors now only occur for foreign key violations or other constraints
-                error_msg = f"database constraint violation: {e!s}"
-                upload_tracker.update_status(
-                    upload_id, UploadStatus.FAILED, "upload failed", error=error_msg
+                track = Track(
+                    title=title,
+                    file_id=file_id,
+                    file_type=ext[1:],
+                    artist_did=artist_did,
+                    extra=extra,
+                    features=featured_artists,
+                    r2_url=r2_url,
+                    atproto_record_uri=atproto_uri,
+                    atproto_record_cid=atproto_cid,
+                    image_id=image_id,
                 )
-                # cleanup: delete uploaded file
-                with contextlib.suppress(Exception):
-                    await storage.delete(file_id)
 
-    except Exception as e:
-        logger.exception(f"upload {upload_id} failed with unexpected error")
-        upload_tracker.update_status(
-            upload_id,
-            UploadStatus.FAILED,
-            "upload failed",
-            error=f"unexpected error: {e!s}",
-        )
+                db.add(track)
+                try:
+                    await db.commit()
+                    await db.refresh(track)
+
+                    # send notification about new track
+                    from backend._internal.notifications import notification_service
+
+                    try:
+                        # eagerly load artist for notification
+                        await db.refresh(track, ["artist"])
+                        await notification_service.send_track_notification(track)
+                    except Exception as e:
+                        logger.warning(
+                            f"failed to send notification for track {track.id}: {e}"
+                        )
+
+                    upload_tracker.update_status(
+                        upload_id,
+                        UploadStatus.COMPLETED,
+                        "upload completed successfully",
+                        track_id=track.id,
+                    )
+
+                except IntegrityError as e:
+                    await db.rollback()
+                    # integrity errors now only occur for foreign key violations or other constraints
+                    error_msg = f"database constraint violation: {e!s}"
+                    upload_tracker.update_status(
+                        upload_id, UploadStatus.FAILED, "upload failed", error=error_msg
+                    )
+                    # cleanup: delete uploaded file
+                    with contextlib.suppress(Exception):
+                        await storage.delete(file_id)
+
+        except Exception as e:
+            logger.exception(f"upload {upload_id} failed with unexpected error")
+            upload_tracker.update_status(
+                upload_id,
+                UploadStatus.FAILED,
+                "upload failed",
+                error=f"unexpected error: {e!s}",
+            )
 
 
 @router.post("/")

src/backend/models/audio.py

···
     MP3 = "mp3"
     WAV = "wav"
     M4A = "m4a"
-    AIFF = "aiff"
 
     @property
     def extension(self) -> str:
···
             AudioFormat.MP3: "audio/mpeg",
             AudioFormat.WAV: "audio/wav",
             AudioFormat.M4A: "audio/mp4",
-            AudioFormat.AIFF: "audio/aiff",
         }
         return media_types[self]
 
···
     def from_extension(cls, ext: str) -> "AudioFormat | None":
         """get format from file extension (with or without dot)."""
         ext = ext.lower().lstrip(".")
-        # handle .aif as alias for .aiff
-        if ext == "aif":
-            ext = "aiff"
         for format in cls:
             if format.value == ext:
                 return format

src/backend/storage/r2.py

···
 
 import aioboto3
 import boto3
+import logfire
 from botocore.config import Config
 
 from backend.config import settings
···
 
         supports both audio and image files.
         """
-        # compute hash in chunks (constant memory)
-        file_id = hash_file_chunked(file)[:16]
+        with logfire.span("R2 save", filename=filename):
+            # compute hash in chunks (constant memory)
+            file_id = hash_file_chunked(file)[:16]
+            logfire.info("computed file hash", file_id=file_id)
 
-        # determine file extension and type
-        ext = Path(filename).suffix.lower()
+            # determine file extension and type
+            ext = Path(filename).suffix.lower()
 
-        # try audio format first
-        audio_format = AudioFormat.from_extension(ext)
-        if audio_format:
-            key = f"audio/{file_id}{ext}"
-            media_type = audio_format.media_type
-            image_format = None
-        else:
-            # try image format
-            from backend.models.image import ImageFormat
-
-            image_format, is_valid = ImageFormat.validate_and_extract(filename)
-            if is_valid and image_format:
-                key = f"{file_id}{ext}"
-                media_type = image_format.media_type
+            # try audio format first
+            audio_format = AudioFormat.from_extension(ext)
+            if audio_format:
+                key = f"audio/{file_id}{ext}"
+                media_type = audio_format.media_type
+                image_format = None
             else:
-                raise ValueError(
-                    f"unsupported file type: {ext}. "
-                    f"supported audio: {AudioFormat.supported_extensions_str()}, "
-                    f"supported image: jpg, jpeg, png, webp, gif"
-                )
+                # try image format
+                from backend.models.image import ImageFormat
 
-        # stream upload to R2 (constant memory, non-blocking)
-        # file pointer already reset by hash_file_chunked
-        bucket = self.image_bucket_name if image_format else self.audio_bucket_name
-        async with self.async_session.client(
-            "s3",
-            endpoint_url=self.endpoint_url,
-            aws_access_key_id=self.aws_access_key_id,
-            aws_secret_access_key=self.aws_secret_access_key,
-        ) as client:
-            await client.upload_fileobj(
-                Fileobj=file,
-                Bucket=bucket,
-                Key=key,
-                ExtraArgs={"ContentType": media_type},
+                image_format, is_valid = ImageFormat.validate_and_extract(filename)
+                if is_valid and image_format:
+                    key = f"{file_id}{ext}"
+                    media_type = image_format.media_type
+                else:
+                    raise ValueError(
+                        f"unsupported file type: {ext}. "
+                        f"supported audio: {AudioFormat.supported_extensions_str()}, "
+                        f"supported image: jpg, jpeg, png, webp, gif"
+                    )
+
+            # stream upload to R2 (constant memory, non-blocking)
+            # file pointer already reset by hash_file_chunked
+            bucket = self.image_bucket_name if image_format else self.audio_bucket_name
+            logfire.info(
+                "uploading to R2", bucket=bucket, key=key, media_type=media_type
             )
 
-        return file_id
+            try:
+                async with self.async_session.client(
+                    "s3",
+                    endpoint_url=self.endpoint_url,
+                    aws_access_key_id=self.aws_access_key_id,
+                    aws_secret_access_key=self.aws_secret_access_key,
+                ) as client:
+                    await client.upload_fileobj(
+                        Fileobj=file,
+                        Bucket=bucket,
+                        Key=key,
+                        ExtraArgs={"ContentType": media_type},
+                    )
+            except Exception as e:
+                logfire.error(
+                    "R2 upload failed",
+                    error=str(e),
+                    bucket=bucket,
+                    key=key,
+                    exc_info=True,
+                )
+                raise
+
+            logfire.info("R2 upload complete", file_id=file_id, key=key)
+            return file_id
 
     async def get_url(self, file_id: str) -> str | None:
         """get public URL for media file (audio or image)."""

tests/test_audio_formats.py

···
             (".m4a", AudioFormat.M4A),
             ("m4a", AudioFormat.M4A),
             (".M4A", AudioFormat.M4A),
-            # aiff
-            (".aiff", AudioFormat.AIFF),
-            ("aiff", AudioFormat.AIFF),
-            (".AIFF", AudioFormat.AIFF),
-            # aif (alias for aiff)
-            (".aif", AudioFormat.AIFF),
-            ("aif", AudioFormat.AIFF),
-            (".AIF", AudioFormat.AIFF),
         ],
     )
     def test_from_extension_supported(
···
             ".ogg",
             ".aac",
             ".wma",
+            ".aiff",
+            ".aif",
             "",
             "invalid",
         ],
···
         assert AudioFormat.MP3.media_type == "audio/mpeg"
         assert AudioFormat.WAV.media_type == "audio/wav"
         assert AudioFormat.M4A.media_type == "audio/mp4"
-        assert AudioFormat.AIFF.media_type == "audio/aiff"
 
     def test_extensions_with_dots(self):
         """test extension property includes dots."""
         assert AudioFormat.MP3.extension == ".mp3"
         assert AudioFormat.WAV.extension == ".wav"
         assert AudioFormat.M4A.extension == ".m4a"
-        assert AudioFormat.AIFF.extension == ".aiff"
 
     def test_all_extensions(self):
         """test all_extensions returns complete list."""
···
         assert ".mp3" in extensions
         assert ".wav" in extensions
         assert ".m4a" in extensions
-        assert ".aiff" in extensions
-        assert len(extensions) == 4
+        assert ".aiff" not in extensions
+        assert ".aif" not in extensions
+        assert len(extensions) == 3
 
     def test_supported_extensions_str(self):
         """test formatted string of supported extensions."""