The exporter named a song's web cover copy in coverPath, where the
server ranks it as a real cover file. It now writes the copy to the
webCoverPath field the server tries last and keeps coverPath for local
cover files only.
Every default download keeps an https cover address and also embeds its
cover, so round 1 copied the web cover of every download and the
catalog's coverPath then outranked the picture in the file. The owner
approved web covers only for songs with no other cover.
The exporter now reports each song without a local cover file but with a
public https cover (path, path+mtime+size stamp, address) and names a
copy only for a song whose file is known to embed no picture. The store
asks linkEmbeddedPictures about new file versions in batches of 64 on
the Rust worker pool, keeps the answers in pictures.json, keeps the
copies a song may still want, fetches only for songs known to embed
none, and announces a held copy a newly asked file can take.
Also from the review: the host stops the store only after the server
stopped, so an export finishing meanwhile fetches nothing; web cover
fetches take https only, refuse localhost and loopback, link-local and
private literals, check every redirect by hand and end after a minute;
once the store is full it fetches and retries nothing until a prune
frees space; a failed write removes its staged file. Phone covers keep
their fetch unchanged.
A desktop download saved without embedded metadata has only an https
cover. The catalog left coverPath empty for it and the server answered
getCoverArt with 404, so the phone showed a placeholder while the
desktop showed the web cover.
LinkWebCovers keeps one copy per address in <app support>/link_web_covers
(<linkCoverUrlId(url)>.<ext>), fetched with the phone covers' fetch,
image check and staged write, now shared from link_web_covers.dart.
Each export lists the copies held and names them as coverPath; songs
with a local cover file and the desktop identity index are unchanged.
Once the server has loaded a catalog, the host removes the copies no
exported song wants and fetches the missing ones in the background,
4 at a time, with a byte cap and a timeout; failures wait 1 minute,
doubling up to 6 hours. New copies schedule an export, whose
catalog.changed makes phones rescan and fetch the cover.
A catalog only names files that exist, so Rust needs no change and an
album never prefers a copy that has not arrived. The listing an export
starts with waits for a queued removal, and removals run only after
setCatalog, so no file the server names is removed.
A Loved or playlist song of a network connection now stores its
network:// cover reference, and three paths handled it poorly:
- A song that resolves to a local file (a later download, or a Library
match) played with the reference as its artwork, which blocked the
embedded cover recovery and fetched over the connection while the
local file played. The reference now applies only to a network
source; a local file shows its own cover as before.
- Go to album passed the reference into album pages and recents, which
load covers over http only, so the page showed a failed cover instead
of the provider's. It now passes http covers only; a store path never
loaded there either.
- The writer compared the shown cover against the default store, while
the player chose it with its runtime's store. The player provider and
the media controls now pass the runtime's store. It is the same
object in production.
Collection songs go out without their network:// cover, so a change
the peer authors for such a row comes back without one. A desktop
playlist reorder restamps every member, and saving a Loved song again
rewrites it; applying either replaced the phone's row and dropped the
reference for good. Before F2 the phone's store path made the same
round trip and came back unchanged.
apply now reads, inside its transaction, the rows that winning Loved,
wishlist and playlist song changes without a cover replace, and keeps
a network:// cover they hold. A cover the peer sends still wins, and
the reference still never leaves the device. Every collection receive
path (the phone's pull, the desktop's POST, the full exchange after a
replaced database) applies through this method.
A network song without a Library record (a WebDAV, SMB or Subsonic
browser song, a Link desktop song) was saved to Loved or a playlist
with the file its player item showed, a cover store file. The store
trims those files, and on iOS their container path changes with an
app update, so the entry lost its cover.
collectionTrackForMedia now keeps the item's artworkRef while the item
shows that cover or none yet: the store fetches it again after a trim,
and collection rows already show a network:// cover through the store
(pendingCover). A cover read from the song's tags (#cover, which no
server answers) or any other artwork is kept as before.
CoverStore.refetches names the references a trim cannot lose.
playableFromTrack turned a network:// cover into a file URI of that
string; it now keeps the reference as the media's coverReference, so
the player shows the stored file and the item never carries network://
as its artUri. Track.fromJson already reads the reference unchanged,
and older rows read and play exactly as before.
A network:// cover names a connection of the device that saved it, so
it means nothing on the peer. Loved, wishlist and playlist entries now
go out without one; the author's own row keeps it. Other covers are
sent unchanged, so existing rows sync exactly as before.
A Loved or playlist entry of a network song will keep its cover as a
network:// reference, which only this device's cover store reads. Such
a track can reach the download queue (a tap on an entry without a
download, Download all), where the queue tiles load the cover over http,
the request payload hands it to the backend as a cover URL to fetch and
embed, and post-processing hooks receive it.
The queue now stores such a track without that cover, so the backend
falls back to the provider's cover. Other tracks are queued unchanged
(the same instance). The quality picker loads its cover with
Image.network, so it now gets only an http cover; a local path showed
the same placeholder there before.
The browser kept the first cover provider lookup for the life of the
process. BrowserCoverProvider.load caught only platform errors, so any
other error stayed in the cached future and made every later children
and search call throw; a lookup that answered null left local covers out
until the process ended.
load now answers null on any error, and the browser keeps only a found
provider: a call without one shows no local covers and the next browse
looks again (concurrent calls still share one lookup). The root tabs no
longer wait for the lookup and the store warm-up, which they do not
need; they start it so the list opened next finds it ready.
_browserArt passed only web covers, as a car cannot open the app's own
files, so Library thumbnails, cover store files and embedded artwork
showed no cover in the car's lists.
Browse items now name a local cover inside one of the cover provider's
folders by its content:// URI, built from the path alone so the same
file always gets the same URI and the car's cache keys stay stable. A
network:// cover maps through CoverStore.indexedFile (index only, no
fetch or file IO), and a song shows the stored cover its playing item
would (CoverStore.songCover). Web covers pass as before; loopback URLs,
temporary files, covers outside the folders and every local cover on
platforms without the provider stay out. The playing item and
audio_service are unchanged.
The daily check rewrote subsonic_<hash>.image in place when no .current
pointer existed, so decoded sizes and the home-screen widget key kept
showing the old image after the server changed it. A forced refresh went
the other way and moved even an unchanged image to a new path, which
dropped every decoded size and rewrote Library rows for nothing.
The fetched bytes are now compared with the published file: the same
image only updates the modification time and keeps its path, a changed
image always gets a new path behind the .current pointer.
ListeningTrack.fromRow already normalizes and sanitizes every stored
cover, so artist artwork and Rewind album covers use the track's
artwork as it is. ListeningSummary.fromRows has no app caller and is
marked for tests. The On repeat replay check tests PlayableMedia and
the cover store, so it moves to the cover store tests.
The history sync wire format imported cover_store.dart, with
path_provider and the network storage service, for one loopback check.
The check is now isLoopbackHost in cover_art_utils.dart, which both
durableCoverReference and linkSyncRemoteArtwork use. Same results.
Both slides read the row of one day, so a day recorded by an older
build (a loopback or temporary cover, now read as none) showed the
placeholder even when the window's summary had the song's cover from a
later play. That is most of a first yearly Rewind after the update.
They now fall back to the summary's cover of the same song.
Summaries take a song's details from its latest day in the window, so
one short play without a known cover, such as a skip before an
embedded cover was read, hid the cover recorded on earlier days on the
statistics screen, Home and Rewind. The cover now comes from the
latest day that recorded one when the latest day has none; both rows
are read by primary key.
History sync sends artwork as http(s) URLs, and statistics rows from
older builds hold loopback URLs of the author's cover proxy. A first
sync with a new peer copied those into the peer's statistics, where
they name the peer's own loopback server instead. Sent and received
artwork now drops loopback URLs, so peers store none.
The resume card read only the item's artUri, which stays empty for a
network song whose cover the store does not hold, such as the first
launch after an update from a build that kept loopback URLs. It now
falls back to the item's cover reference, as the queue rows do, so
the cover is fetched once and shows.
Android Auto lists kept every cover starting with http. Collection
tracks loved from the player by older builds can hold a loopback URL
of the app's cover proxy, which a car cannot load and which named a
route of an earlier run. The browser now leaves those out like local
files.
A song loved from the player without a Library record stored the
item's artUri as its collection cover, and an album or artist opened
from the player recorded its cover in recents. Older builds put
loopback URLs there; a tag cover the store could not keep still shows
from a temporary file on that play. Both writers now store only
covers that outlast the run, through durableCoverReference.
Listening statistics rows from older builds hold loopback URLs and
temporary files that no longer load, so the statistics screen, Home
and Rewind showed broken covers. Rows are read through one
ListeningTrack.fromRow, which reads those as no artwork, so the
fallback shows until the song plays again.
A play whose cover is not known yet no longer erases the stored cover
of that day, and a write never stores a loopback or temporary cover.
Artist artwork and Rewind album covers dropped network:// references
because normalizeCoverReference rejects them; they now read through
normalizeStoredCoverReference, which keeps them without changing what
other stores accept.
A tag read without a cover dropped the song's stored tag cover. For a
Subsonic song played from the Library that cover is the server's, and a
failed cover request also reads without one (and is remembered for five
minutes), so the playing song and the lock screen lost their cover on a
passing failure. A stored tag cover now stays until the store trims it:
a picture removed from a network file's tags lingers a while, which is
better than losing a cover the server still has. The store's forget
goes with it.
A metadata event whose song left the queue during the read threw, and an
older event's read could still store its cover after a newer one's. Both
now stop before touching the store.
The cover read with a Subsonic song's tags is the server's own cover,
the one the song's network reference names. Keeping it again as a tag
cover made that copy win once the phone had played a desktop song, so a
cover changed on the desktop never reached the phone: the refresh
checks the network reference, and songs with a known tag cover skip it.
Subsonic songs with a network reference now keep only that reference,
which also stores each Link cover once and lets statistics keep a
reference the store can fetch again.
A tag read that finds no cover now drops the song's stored tag cover, so
a picture removed from the tags gives way to the folder cover as it did
before covers were stored. A metadata event updates the queue once: the
tag cover goes into the replaced entries instead of a separate update.
The Home resume item drops a loopback or temporary cover of an earlier
version, as a restored session does.
A network song with both a folder image and a cover in its tags showed
the folder image on every play once it was stored, unlike the Library.
The cover from the tags now wins once read: it is stored under the
song's cover reference, which a later play finds in the store's index,
so the item shows it from the first emission without flashing the
folder image. The folder image shows only while no tag cover is known,
and a late or changed folder cover no longer replaces a tag cover. The
session keeps neither file; statistics keep the reference of the cover
shown.
Covers a server reported changed are no longer fetched at once. A
desktop library job reported every song it touched, and each fetched
its cover, queued or not and stored or not. The store now marks the
cover stale and checks it on its next use, so only the playing song and
the next three fetch. The same mark drops the wait after a failed fetch,
so a Link reconnect retries the covers that failed while the desktop was
away instead of waiting out the store's minute.
A network:// artwork, as listening statistics keep for Home to play,
is the song's cover reference: the item shows its stored file and never
the network:// string, which the lock screen cannot load. Restored
sessions drop loopback and temporary covers of older versions, and the
temporary preview rule matches the preview folder, not a file name. A
tag cover the store could not keep shows on that play only.
The resolver and the remote's metadata subscriber each built the cover
reference of a desktop song. The cover store keys covers by that exact
string, so one helper builds it for both and the forms cannot drift.
An AutoMix transition showed a stored cover, but a cover not stored yet
was only fetched if an earlier load had fetched it ahead, so after a few
mixed songs in a row a network song could stay without one. The
transition now fetches the new song's cover and the next three, as a
gapless start does.
Cover widgets, precaching and palettes saw a network:// cover as a form
without an image. coverFilePath now answers it with the file the cover
store's index names, without file IO, so they show a stored cover as a
local file. A cover widget given a network cover the store does not
hold yet fetches it once through the store, within its fetch limit, and
builds again when it lands. Queue rows whose cover is not stored yet
show it that way.
Playing a folder resolved its cover image to a loopback URL before
playback began and passed it as the songs' artwork, a URL that named the
cover for this run only, even for Subsonic songs whose own cover
differs. The songs already carry the cover as networkArtworkSource,
which the player now shows from the cover store, so the screen passes
only that and starts playback without the extra request.
The desktop and phone remotes resolved each queued song's network cover
through the loopback proxy, a new URL per lookup, for every row of a
queue up to 500 songs long. The items now show the cover store's file,
the same on every update, and carry the reference as
extras['artworkRef'].
Only the playing song and the next three fetch their covers; other rows
fetch theirs once they show. A failed cover is tried again after a
reconnect, as before. When the desktop changes a song's file, its cover
is fetched again at once, and a cover the store replaced shows on the
items with it.
Each play resolved a song's network cover through the loopback proxy,
which hands out a new URL per call. The first item had no cover, every
play showed a different URL, the lock screen and Link Now Playing saw
the cover change, and listening statistics recorded a URL that was dead
after the run.
Items now show the file the cover store holds for the cover from their
first emission, the same file on every play, and carry the reference as
extras['artworkRef']. A cover not stored yet is fetched without holding
up the audio and shows on the song and its queue entries once it lands,
the covers of the next three songs are fetched ahead for skips and
gapless starts, and a cover the store replaced shows at once. A restored
session and the Home resume item read the store's index first.
The tag cover a network metadata read leaves in a temporary file is
copied into the store before the session keeps it. Statistics record
the cover reference, or the artwork only when it lasts. The store's
index is read at startup and trimmed once a launch.
Playback needs a stored network cover while it builds a MediaItem, so
indexedFile answers from the in-memory index without file IO. adopt
copies a cover that reached the device another way, such as the tag
cover a network metadata read leaves in a temporary file, into the store
under a reference derived from the song (songCoverReference), named by
its bytes like a fetched cover. refresh fetches a cover again at once
when its server reports a change, instead of waiting a day for the
recheck.
durableCoverReference keeps only cover strings that outlast the run:
loopback URLs and files in the system temporary directory or the known
temporary cover folders are dropped, so statistics never record them.
Clearing library covers marked rows whose cover_path started with Dart's
spelling of the folder. Scans store their own spelling: the canonical
/data/data path on Android 7 to 10, where /data/user/0 is a symlink, and
canonical backslash paths (possibly \\?\) on Windows. There no row was
marked, so local covers stayed broken until a forced rescan.
Rows are now matched by a library_covers path segment with either
separator; every file in that folder was just deleted, so each such row
is broken. The update also retries a busy writer before it begins, so a
running native scan no longer leaves the rows unmarked after the files
are gone.
A source without a modification time always published its preview to
v2_<path hash>_0.jpg. After an in-app cover edit (invalidate, then extract
again) the new cover landed on the same path, so ImageCache kept showing
the old decoded cover in the metadata screen, Library and player.
Untimed previews are now named v2_<path hash>_0_<content hash>.jpg from a
SHA-256 of the extracted bytes: an unchanged cover keeps its path across
memory misses, an edited one gets a new path, and the existing variant
cleanup removes the previous file. Publishing also no longer deletes the
target before the rename, which already replaces it atomically, so a
reader never finds the preview missing.
Clearing library covers in Settings deleted every file while Library rows
kept naming them. Network songs recover, since their scan reads a song
again when its cover file is gone, but local and document songs are
skipped by an unchanged timestamp, so their covers stayed broken until a
full rescan despite "Will re-extract on next scan".
The clear now also lowers the audio metadata scan version of local rows
whose cover was in that folder to the lyrics version. The incremental
snapshot then reports those files as changed once, so any next scan
extracts the covers again under the same names, which also brings back
the covers that playlists and sessions name. Lyrics filters are unchanged
meanwhile.
When a source had no modification time (some document providers), its
embedded cover preview went to a new systemTemp/download_cover_preview_*
folder and was deleted as soon as the 180-entry memory cache evicted it,
even while the player or the saved session still pointed at it.
Such previews now go to the existing embedded_cover_previews folder under
one durable name (v2_<path hash>_0.jpg). They are still extracted again on
each memory miss, since a disk copy cannot be validated without a
timestamp, but evicting the memory entry never deletes a file: only the
disk budget, a refresh that replaces the preview, invalidate and the
manual clear do.
The cover prune after a full scan treated a library_covers file as in use
only when library.cover_path named it. Playlists, favorites, the saved and
dismissed playback sessions, recent items, the download queue, listening
statistics and download history (including Link save offline copies) copy
those paths, so their covers broke after the next full scan.
The prune now also reads every such text column (read-only, in pages,
filtered with instr) and keeps the files they name, rebased onto today's
cover directory so file:// URIs and paths from an older iOS container
match. The names join the private native projection, so Rust still never
reads a live database and a failed read cancels the sweep.
A Subsonic cover kept by a reference also keeps its
subsonic_<hash>.image.current pointer, in Rust and in the Dart fallback;
before, the pointer was always deleted and the next scan fetched and
renamed the cover again.
A forced rescan wrote every thumbnail into a new library_covers/full_scan_*
folder, so all stored cover paths changed at once. It did that to bypass
reuse of possibly wrong cached thumbnails and stale decoded images.
With collision-free names, a forced rescan now writes the .regenerate
marker into library_covers itself: native scans extract every thumbnail
again under its existing name, and the decoded image cache is cleared once
the rescan is indexed. Playlists, sessions and statistics that copied a
cover path keep a valid file.
An unsatisfiable Range on SMB sets content-length 0 only for GET again,
so a HEAD answers as it did before the cover read moved to the shared
opener. A new test rejects 24 covers (404, audio, HTML) over one host's
six pooled connections, which times out if downloadCover stops
discarding a rejected response.
Background rechecks of stale covers and first-time fetches shared one
FIFO queue, so a scrolled grid could queue many rechecks ahead of the
playing song's cover. Waiting fetches a caller awaits now take the next
free turn before any queued recheck, and the turn is taken before the
store folder is created so queue order follows call order.
A recheck that finds changed bytes leaves the old file dated ahead of
the clock; warmUp and trim now rank a file dated more than a day ahead
as the oldest, so a restart picks the new file and a trim drops the
stuck one first. The constructor asserts a positive fetch cap, and the
cap test waits with a bounded poll instead of one event queue pump.
Playback and display will ask the store for whole queues and grids.
- At most four covers are fetched at once (maxFetches); the rest wait
their turn in order, so a burst does not queue past the HTTP pool
and time out into a retry backoff.
- A cover the server does not have (NetworkMediaUnavailable) or whose
bytes are not an image waits an hour before the next fetch instead of
a minute, so a desktop's songs without art are not asked for every
minute while they are shown. Transfer failures keep the one-minute
delay.
- A stored cover dated more than a day ahead of the clock is checked
again, as one more than a day old is.
- trim checks again that no fetch has taken up a name after reading its
details, before deleting it.
Review of the direct cover read found two regressions.
- downloadCover parsed Content-Type with ContentType.parse, which throws
on a malformed value such as an unterminated quote. The response was
then never read or discarded, so it held one of the server's six
pooled connections for good, the same pool audio playback uses.
The mime type is now read without throwing, and any response whose
body was not read is discarded, in downloadCover and in _serve. The
opener also discards when its own header checks throw (the Subsonic
contentType getter had the same hold before this unit).
- An SMB range that cannot be satisfied answered with an empty chunked
body instead of the old Content-Length: 0. The 416 answer sets the
length again.
A cover answer that will not change soon (404 or 410, a Subsonic error
document with either status, audio or video, too large, empty) now
throws NetworkMediaUnavailable, an HttpException, so callers can wait
longer before asking again. Declared audio and video types are refused
before any bytes are read. A pinned TLS server is covered by a direct
read test too.
Network covers reach the app as a loopback URL that changes on every
resolve, so the cover cache, the image cache, palettes and the media
session miss each time, and the URL breaks once the route is evicted
or the process ends. CoverStore turns a cover reference into a durable
local file instead.
- A network:// cover is fetched once with downloadCover() into
<support>/covers/<reference key>_<content key>.image. The same
reference with the same bytes keeps one path across calls and runs;
changed bytes give a new path, so caches keyed by path show the new
image.
- cachedFile() answers synchronously from an index that warmUp() reads
from disk, so the first frame can show a stored cover. Existing file
paths and file:// URIs pass through; https stays with
CoverCacheManager.
- Concurrent requests for a reference share one fetch, a failure waits
a minute before the next attempt (an unreachable desktop is not
asked once per queue row), and a cover older than a day is answered
at once and checked again in the background. New bytes are reported
on changes.
- Fetched bytes must start like a JPEG, PNG, GIF, WebP, BMP, HEIF or
AVIF image and stay within 16 MiB; they are staged and renamed, so a
failure leaves no file.
- trim() removes superseded and abandoned staging files, then the
covers checked longest ago beyond 2000 files or 200 MiB. Any cover
can be fetched again from its reference.
Nothing uses the store yet; playback and display move to it next.
A network cover (Subsonic or Link desktop getCoverArt, a WebDAV, HTTP
or SMB folder image) could only be read through resolve(), which hands
out a new loopback route per call. That URL defeats every URL-keyed
cache and dies with the Dart process, so it cannot back a durable cover
file.
downloadCover() saves the cover at a network:// source to a file over
the connection's own pinned client, with the same source validation,
local network access and out-of-reach check as resolve(). It rejects
non-200 answers, text documents (Subsonic JSON or XML errors among
them), Subsonic song paths, empty bodies and anything over 16 MiB, and
strips the credential-bearing request URI from transport errors.
Virtual sources answer with their local file; a URL from them streams
a song on its way and is refused.
The proxy and the direct read now share one opener for a connection
and path, so _serve keeps its exact statuses, headers, HEAD and range
handling without a second copy of the SMB and HTTP code.
When a phone committed a new song list, the desktop deleted every stored
cover the new list did not name right away, before the rescan of the
phone's Library source had moved the rows off them. Songs whose cover
changed (a phone rescan changes every cover id) showed placeholders until
the rescan finished, and longer when the rescan waited behind another
scan.
A commit's removal now also keeps covers the phone source's Library rows
name (LinkPhoneLibrary.coverPaths, read from the library table) and skips
deleting anything when those rows cannot be read. It is queued right
behind the last page, so it runs after the commit reply and before
anything the phone sends next. A cover kept only for rows goes at a later
commit, or at the next GET phone/catalog (the start of a sync) when it is
older than the committed list; covers sent since that commit wait for the
commit they were sent for, so a sync that stopped halfway does not upload
them again. GET phone/covers waits for the removals queued before it, so
the phone never skips a cover that is deleted right after it was listed.
The other cover readers look up covers of committed songs, which no
removal takes away, so they answer at once and never wait behind a web
cover download. Web cover fetches stay a separate queued step. The 1 GiB
store limit and the cover ids are unchanged.
The metadata cover prewarm now also runs for local paths and file URIs,
so a stale path reported an image error that the app logs as an uncaught
error and stores as the crash snapshot. Swallow local prewarm failures
as the backdrop prewarm already does; http failures still report.
Both prewarm helpers now build the provider once and return when the
form has no image, so a stateful network:// lookup cannot disagree
between two calls. Document that the network:// hook must read only an
in-memory index, since it runs during build.
Screens repeated the http-or-file check and raw Image.file calls for
cover strings. The Link transfer rows accepted only http(s) and plain
paths, so a song cover stored as a file:// URI showed the placeholder.
Track Metadata, the transfer rows and the queue artwork now use
isHttpCoverUrl, coverFilePath and coverImageSource. The album, local
album and playlist header backgrounds and the playlist grid cover use
LocalOrNetworkCoverImage with the same decode, filter, gapless and
placeholder settings they had, so they draw the same pixels. The queue
grid prewarm builds its provider with cachedCoverImageProvider.
Cover strings reach the UI as absolute paths, file:// URIs (MediaItem
artUri values saved into listening statistics), http(s) URLs and
content:// URIs, and each primitive parsed them itself.
LocalOrNetworkCoverImage sent every non-http string to File(url), so
file:// covers failed silently; precacheCoverImage skipped local files;
CoverPalette keyed a file:// URI and its path separately and never
decoded the URI.
coverFilePath, coverImageSource and coverImageProvider in
cached_cover_image.dart now map a stored string to its file, its decode
source and its image, keyed like the widgets' own decode. PlayerArtwork,
LocalOrNetworkCoverImage, both precache helpers, CoverPalette,
PlayerArtworkTheme and LocalLibraryArtworkBuilder go through them, so
the Mornye palette callers pass artUri as it is. network:// covers have
one hook in coverFilePath for the cover store. content:// and other
forms still show the placeholder.
While a paired computer plays, the iPhone publishes a NowPlaying
RemoteMediaSession through a new LinkNowPlaying ExtensionKit extension
instead of starting local audio for a Lock Screen card. The app sends
the track, position and volume over a method channel; the extension
reads the computer's state and sends its commands directly over the
pinned Link connection, so the card keeps working while the app
sleeps.
- Pairing credentials go to a Keychain item shared through the app
group. An install without the app group, and so without that
Keychain, carries them in the session attributes instead.
- A desktop catalog song's cover comes from the computer's
getCoverArt by song id. The app's own cover is a loopback proxy URL
that the extension cannot use.
- Errors returned to the system carry only their domain and code: a
URL error's details cannot cross XPC and aborted the extension.
Failures are logged to the device log without URLs or keys.
- CI and release builds move to Xcode 27 and check that the extension
is embedded.
On a test device the card appears, but its controls and cover do not
reach the computer yet; that is still being investigated.
Shrinking Material's empty "Playing on" row to one line of the label
(24dp) left it too short on Android, while the iPhone still showed a
wide empty band: the safe area stacked the 34pt home indicator inset
under the row. The row is 36dp again on every platform. On an iPhone,
Material's portrait player now lets it reach into the home indicator
inset, keeping only the bottom 12pt below it, so the label still ends
clear of the indicator and the bottom gap drops from 58pt to 48pt.