// Artist detail page — QML port of artist/ArtistPageView.slint.
//
// Header (200px circular portrait — right-click for the image menu
// (Add/Change/Remove custom image, View image, Open in browser, Save as…),
// left-click for the lightbox — name, bio + Read more, CircleAction
// row: Follow / Radio / Network / ⋯, From-catalog/In-library toggle),
// JUMP TO bar (jump-scroll), Popular Tracks (artwork + album column rows,
// Load more 5→all, play/shuffle-all), Latest release, release sections
// (Albums / EPs & Singles / Live / … in the official order, sort menu,
// per-section Load more paged through the core), Appears On, Playlists,
// Other (collapsed), and the 300px Network sidebar (Network/Magazine
// tabs, ORIGIN, LABELS, SIMILAR ARTISTS, RELATIONSHIPS, YOU MAY ALSO LIKE,
// and the Magazine story teasers).
//
// The document arrives in passes: the Qobuz page first, then the Magazine
// stories, then MusicBrainz Origin -> Relationships -> Discovery (see
// artist_qt.rs). Each MB section renders its own "Loading…" line and, when
// MusicBrainz is off in Settings or the artist has no confident MB match, is
// simply ABSENT — never an error frame, and nothing is requested.
//
// Blacklist banner, Artist Scene, Create Collection, both radio engines,
// multi-select and the sticky JUMP TO bar are live. The remaining artist-page
// deltas are documented beside their data producers in artist_qt.rs.
//
// "Share" left this list when the seam landed: the ⋯ entry now calls
// QbzArtist.share (artist_bridge.rs -> src/share_qt.rs), which copies
// play.qobuz.com/artist/{id} and raises the same "Link copied" toast as
// ArtistPageView.slint:530-538 / main.rs:12749.
//
// Header atmosphere (ArtistPageView.slint:120-147, 211-247): wired through
// the shared controls/HeaderGradient.qml — the SAME component AlbumView
// mounts, because the .slint paints both headers from identical blocks. It
// carries the .slint's header-colour rules with it (light text + overlay
// CircleActions while the band is on).

import "../assets/release-sort.js" as ReleaseSort
import QtQuick
import QtQuick.Controls
import QtQuick.Window
import com.blitzfc.qbz
import "../cards"
import "../controls"
import "../rows"
import "../shell"
import "../theme"

Rectangle {
    id: root
    // Transparent while the ambient background is active (phase 14 —
    // HomeView.slint:163: the frosted content panel shows through).
    color: ambientOn ? "transparent" : theme.surfaceMain
    readonly property bool ambientOn: theme.ambientOn

    // Round to the AppShell content-frame bezel (Radius.md): QML clips
    // are rectangular, so the frame's own rounding never reaches the
    // view — the view's own fill must round instead.
    radius: 12

    QbzTheme { id: theme }

    readonly property var artist: JSON.parse(QbzArtist.artistJson)

    // ---- In-page search (JumpNavBar's magnifier) -------------------------
    // artist.rs `filter_artist` (main.rs:14991 wires ArtistActions.search to
    // it) is a PURE client-side filter over Popular Tracks, Appears On and
    // every release-section album — no backend round-trip — so it ports as a
    // filter over the parsed document rather than a bridge call.
    property string searchQuery: ""
    readonly property string needle: searchQuery.trim().toLowerCase()

    function matchTrack(t) {
        return needle === ""
            || (t.title || "").toLowerCase().indexOf(needle) >= 0
            || (t.artist || "").toLowerCase().indexOf(needle) >= 0
    }

    readonly property var topTracks: {
        var all = artist.topTracks || []
        if (root.needle === "") return all
        var out = []
        for (var i = 0; i < all.length; i++) if (matchTrack(all[i])) out.push(all[i])
        return out
    }
    readonly property var appearsOn: {
        var all = artist.appearsOn || []
        if (root.needle === "") return all
        var out = []
        for (var i = 0; i < all.length; i++) if (matchTrack(all[i])) out.push(all[i])
        return out
    }
    // A section whose albums all filter out DISAPPEARS (artist.rs:1033), and
    // Load more is suppressed while a filter is active (:1042 — appending
    // would bring back unfiltered items).
    //
    // ---- THE PAGED TAIL IS MERGED HERE, NOT PUSHED INTO `artist` ----------
    // Owner, 2026-08-02: "el error esta en que nunca cargan mas albumes."
    // The old handler parsed the page and pushed it into
    // `artist.releaseSections[i].cards` IN PLACE, then fired artistChanged().
    // Both Repeaters (`model: releaseSections` at :1997/:2114 and
    // `model: section.cards` inside ReleaseSection) were then handed the very
    // SAME array object they already held, and the unfiltered arm below used
    // to `return all` — the identical array again. Nothing was dirty, so
    // nothing rebuilt: the page was fetched, parsed and appended to a data
    // structure no view ever re-read. This tree already writes the rule down,
    // in cards/PlaylistCollage.qml: "Rebind requires a NEW object reference."
    // (PRE-EXISTING, not a regression from today's smooth-append work — that
    // pass only added the `releaseMoreLanded` call to the handler. What it
    // changed is that the button now shows an in-flight placeholder, which is
    // what made a silent no-op visible.)
    //
    // So the appended pages live in `root.releaseOverlay` (see its header)
    // and are merged HERE, which builds a NEW section object with a NEW cards
    // array whenever the overlay has anything for that bucket — the one thing
    // that actually invalidates both Repeaters. `artist` is never mutated, so
    // a republish of the document (the progressive Magazine / MusicBrainz
    // passes) cannot lose the tail either.
    //
    // De-dup by album id is MANDATORY on this path and not merely defensive:
    // artist_qt.rs `merge_release_page` (:686) folds every landed page into
    // the STASHED document too, so the moment the next enrichment pass
    // republishes, the document already carries the cards the overlay holds.
    // Without the id filter every appended album would appear twice from that
    // frame on. (Qobuz can also repeat a row across pages by itself.)
    readonly property var releaseSections: {
        var all = artist.releaseSections || []
        var out = []
        for (var i = 0; i < all.length; i++) {
            var src = all[i]
            var extra = root.releaseOverlay[src.releaseType]
            var cards = src.cards || []
            // The bucket's persisted sort, stamped on the row by
            // artist_qt.rs `map_artist` / `resort_section`. It has to be COPIED
            // into every rebuilt literal below: an object literal carries only
            // the keys it names, so a `sortBy` left out here makes the header's
            // QbzSelect snap back to "Default" the moment this arm is taken.
            var sortBy = src.sortBy || "default"
            // `hasMore` is only overridden once a page has actually LANDED
            // (`extra.hasMore` stays undefined otherwise): the document's copy
            // is the truth until then, and blanking it would hide the button —
            // and with it the in-flight placeholder QbzLoadMore draws under it.
            var hasMore = src.hasMore === true
            var k
            if (extra !== undefined) {
                var seen = {}
                var merged = []
                for (k = 0; k < cards.length; k++) {
                    merged.push(cards[k])
                    seen[cards[k].id] = true
                }
                var tail = extra.cards || []
                for (k = 0; k < tail.length; k++) {
                    if (seen[tail[k].id]) continue
                    seen[tail[k].id] = true
                    merged.push(tail[k])
                }
                // THE TAIL IS APPENDED, SO IT MUST BE RE-SORTED HERE.
                // artist.rs:1245-1258 `append_release_page` re-sorts after
                // folding a page in, "before computing the artwork jobs at
                // their post-sort positions" — under "A–Z" a page-2 album
                // belongs wherever its title puts it, not at the bottom.
                // artist_qt.rs `merge_release_page` does that to the STASHED
                // document; this does it to the copy actually on screen, which
                // is a DIFFERENT array (the overlay never reaches the stash).
                // Fixing only one of the two leaves the grid correct until the
                // next enrichment republish, or wrong until it — see the
                // overlay's own header for why the two copies exist.
                cards = root.sortReleaseCards(merged, sortBy)
                if (extra.hasMore !== undefined) hasMore = extra.hasMore === true
            }
            if (root.needle === "") {
                // No overlay for this bucket -> hand back the document's own
                // object: nothing was appended, so there is nothing to rebind
                // and a fresh wrapper would only churn delegates. (The document
                // arrives already sorted — artist_qt.rs sorts at page build and
                // on every `setSectionSort` — so there is nothing to do to it.)
                out.push(extra === undefined ? src
                         : { "releaseType": src.releaseType, "title": src.title,
                             "cards": cards, "hasMore": hasMore, "sortBy": sortBy, "sortLoading": src.sortLoading === true })
                continue
            }
            // Filtered arm: the merge happened FIRST, so an appended album
            // that matches the needle is searchable like any other — but
            // `hasMore` is still forced false (artist.rs:1042) and only the
            // KEPT cards travel, so the overlay can never leak a filtered-out
            // card into this arm.
            var kept = []
            for (var j = 0; j < cards.length; j++)
                if ((cards[j].title || "").toLowerCase().indexOf(root.needle) >= 0)
                    kept.push(cards[j])
            if (kept.length === 0) continue
            out.push({ "releaseType": src.releaseType, "title": src.title,
                       "cards": kept, "hasMore": false, "sortBy": sortBy })
        }
        return out
    }
    /// JS twin of `artist_qt::sort_release_cards`, itself the port of
    /// `album_map::sort_album_items` (crates/qbz/src/album_map.rs:244-264).
    ///
    /// Both exist because the bucket exists TWICE: Rust owns the stashed
    /// document (page 1 plus every page `merge_release_page` folded in) and
    /// sorts it there, while `releaseOverlay` holds the pages Load more brought
    /// in on THIS side and is concatenated onto the document's array by the
    /// projection above — an array Rust never sees. The two must agree, so the
    /// arms are kept identical.
    ///
    /// Returns a NEW array (`slice()` before `sort()`): the projection binds to
    /// the result, and sorting the caller's array in place would hand the
    /// Repeaters the same reference back — "Rebind requires a NEW object
    /// reference" (cards/PlaylistCollage.qml).
    ///
    /// Sort by the original numeric date; `year` is a localized label.
    /// Default preserves the server order, as in the official client.
    function sortReleaseCards(cards, sort) {
        function byTitle(a, b) {
            var x = (a.title || "").toLowerCase(), y = (b.title || "").toLowerCase()
            return x < y ? -1 : (x > y ? 1 : 0)
        }
        switch (sort) {
        case "relevant":
        case "default": return cards.slice().sort(function (a, b) { return (a.defaultOrder || 0) - (b.defaultOrder || 0) })
        case "oldest": return cards.slice().sort(function (a, b) { return ReleaseSort.compareDates(a, b, false) })
        case "newest": return cards.slice().sort(function (a, b) { return ReleaseSort.compareDates(a, b, true) })
        case "title-asc": return cards.slice().sort(byTitle)
        case "title-desc": return cards.slice().sort(function (a, b) { return byTitle(b, a) })
        default: return cards
        }
    }
    readonly property var labels: artist.labels || []
    readonly property var similarArtists: artist.similarArtists || []
    readonly property var playlists: artist.playlists || []
    // MusicBrainz-driven sidebar payload (artist_qt.rs ArtistNetwork). Absent
    // on the very first frame of a cold document — every read below is
    // defaulted so a missing member can never throw.
    readonly property var network: artist.network || ({})
    readonly property var mbOrigin: network.origin || ({})
    readonly property var mbRelationships: network.relationships || ({})
    readonly property var stories: artist.stories || []

    // ---- Artist Scene: the gate BOTH doors share (contract §2.1) ---------
    //
    // Three terms, and dropping any one of them breaks a door:
    //
    //  1. `locationClickable` — computed in Rust (artist_qt.rs `map_origin`)
    //     so QML never re-derives the reference's unparenthesised guard. A
    //     country-only location has nothing to drill into.
    //  2. `mbid !== ""` — and NOT `network.mbAvailable`, which is the trap.
    //     That flag is the user's MusicBrainz OPT-IN and nothing else
    //     (artist_qt.rs:982-983, whose doc comment used to claim otherwise);
    //     it is seeded SYNCHRONOUSLY with the first artist frame while `mbid`
    //     stays "" until the async publish_network lands. Gating on it alone
    //     lights both doors up on frame one with no id to hand them, and the
    //     click fires with an empty parameter.
    //  3. `mbAvailable` — the MusicBrainz opt-in, which is now trustworthy at
    //     THIS point in time: the settings toggle republishes the open artist
    //     document (settings_qt.rs, "musicbrainz" arm -> republish_open_artist),
    //     so a stale `locationClickable: true` can no longer survive on a page
    //     the user navigates back to after switching the integration off.
    readonly property bool sceneAvailable:
        mbOrigin.locationClickable === true
        && (network.mbid || "") !== ""
        && network.mbAvailable === true

    /// Both doors call THIS — never `QbzScene.open` directly — so they can
    /// never drift apart in what they pass.
    function openArtistScene() {
        if (!sceneAvailable)
            return
        QbzScene.open(network.mbid || "",
                      mbOrigin.artistName || artist.name || "",
                      mbOrigin.locationAreaId || "",
                      mbOrigin.locationCity || "",
                      mbOrigin.locationCountry || "",
                      mbOrigin.locationCountryCode || "",
                      mbOrigin.locationPrecision || "",
                      (mbOrigin.seedGenres || []).join(","),
                      (mbOrigin.seedTags || []).join(","))
    }

    property var coverMap: ({})
    property string activeJumpTab: "popular-tracks"
    property string artistTab: "catalog"

    // ---- "In library" tab (#737 round, contract §3/§4) ---------------------
    // The rows ride INSIDE the artist document (`artist.libraryItems`,
    // artist_qt.rs) — favourites ∪ purchases of this artist, one row per
    // entity, the purchase row representative and `isFavorite` meaning "also
    // hearted". The two switches below are the `Library > Albums / Tracks`
    // source switches with THEIR semantics (LibraryView.qml:566-590: neither
    // = union, one = that source, both = intersection) but LOCAL state: the
    // Library view's own switches must not reach into this page.
    property bool libShowPurchases: false
    property bool libShowFavorites: false
    /// Preview 10 (Popular Tracks previews 5), "Load more" opens the whole
    /// list at once — no paging, the rows are already in hand.
    readonly property int libPreview: 10
    property bool libTracksExpanded: false
    readonly property var libItems: {
        var src = artist.libraryItems || []
        var out = []
        for (var i = 0; i < src.length; i++) {
            var it = src[i]
            var purchased = it.group === "purchases"
            var hearted = it.isFavorite === true
            var included
            if (root.libShowPurchases && root.libShowFavorites) included = purchased && hearted
            else if (root.libShowPurchases) included = purchased
            else if (root.libShowFavorites) included = hearted
            else included = true
            if (included) out.push(it)
        }
        return out
    }
    readonly property var libTracks: libItems.filter(function (x) { return x.kind === "track" })
    readonly property var libAlbums: libItems.filter(function (x) { return x.kind === "album" })
    /// The queue a row click / "Play all" builds from: the WHOLE filtered
    /// list in render order, not only the revealed preview — a click on row
    /// 3 must be followed by rows 4..n exactly like Popular Tracks queues its
    /// full list. Handed to `QbzLibrary.libraryPlayVisible` / `libraryPlayAll`
    /// (library_qt::play_from_visible), the source-aware seam LibraryView
    /// uses — never `QbzPlayer.playArtistTrack`, whose queue is the POPULAR
    /// list and which starts it at row 0 for any id it does not hold (#737).
    function libTrackIds() {
        var ids = []
        for (var i = 0; i < root.libTracks.length; i++) ids.push(String(root.libTracks[i].id))
        return ids
    }
    /// The library Albums section's sort — the release buckets' five keys,
    /// seeded from the document (`artist.librarySort`, artist_prefs "library")
    /// and persisted through the same invokable the buckets use. Sorted here,
    /// not in Rust: the rows already live in QML (`sortReleaseCards` reads
    /// `title` / `year`, which a FeedItem carries).
    property string libSort: "default"
    readonly property var libAlbumsSorted: root.sortReleaseCards(root.libAlbums, root.libSort)
    function setLibSort(key) {
        root.libSort = key
        QbzArtist.setSectionSort("library", key)
    }

    // ---- Album-section play (the split button) -------------------------------
    // Every album section — each catalog bucket and the library Albums grid —
    // carries a QbzSplitButton right of its sort: the body plays the whole
    // section in its SORT order as one queue (`QbzPlayer.playAlbums`), the
    // chevron offers Play random (ONE album of the section, replacing the
    // queue) and Play selected, which arms a per-section select mode: the
    // cards grow a check bottom-right inside the art, the button reads
    // "Play selected (n)" and plays the checked albums in sort order, and the
    // menu swaps that row for Cancel selection. One section is armed at a
    // time (`albumSelectKey` is the bucket's releaseType or "library").
    // No queue options (next / later / queue) on purpose.
    property string albumSelectKey: ""
    property var albumSelected: ({})
    readonly property int albumSelectedCount: Object.keys(root.albumSelected).length
    /// The armed section's cards follow the same rule as every other
    /// select-mode surface: Shift-click ranges over the section's cards in
    /// their CURRENT sort order, Ctrl adds one (controls/SelectionModel.qml).
    SelectionModel { id: albumSectionSel }
    function albumSelectToggle(id, cards, mods) {
        root.albumSelected = albumSectionSel.next(root.albumSelected, id, cards || [],
                                                  mods === undefined ? Qt.NoModifier : mods)
    }
    function albumSelectClear() {
        root.albumSelectKey = ""
        root.albumSelected = ({})
        albumSectionSel.anchorId = ""
    }
    function albumSectionLabel(key) {
        return root.albumSelectKey === key
            ? QbzSession.tr("Play selected", QbzSession.trRev) + " (" + root.albumSelectedCount + ")"
            : QbzSession.tr("Play all", QbzSession.trRev)
    }
    function albumSectionMenu(key) {
        var m = [
            { "label": QbzSession.tr("Play all", QbzSession.trRev), "icon": "play-fill", "action": "play-all" },
            { "label": QbzSession.tr("Play random", QbzSession.trRev), "icon": "shuffle", "action": "play-random" }
        ]
        if (root.albumSelectKey === key)
            m.push({ "label": QbzSession.tr("Cancel selection", QbzSession.trRev), "icon": "x", "action": "cancel-selection" })
        else
            m.push({ "label": QbzSession.tr("Play selected", QbzSession.trRev), "icon": "square-check-big", "action": "play-selected" })
        return m
    }
    function albumSectionIds(cards) {
        var ids = []
        for (var i = 0; i < cards.length; i++) ids.push(String(cards[i].id))
        return ids
    }
    /// `cards` is the section's list in its CURRENT sort order.
    function albumSectionAction(key, cards, action) {
        var ids = root.albumSectionIds(cards)
        if (action === "play-all") {
            root.albumSelectClear()
            if (ids.length > 0) QbzPlayer.playAlbums(JSON.stringify(ids))
        } else if (action === "play-random") {
            root.albumSelectClear()
            if (ids.length > 0) QbzPlayer.playAlbum(ids[Math.floor(Math.random() * ids.length)])
        } else if (action === "play-selected") {
            root.albumSelectKey = key
            root.albumSelected = ({})
            albumSectionSel.anchorId = ""
        } else if (action === "cancel-selection") {
            root.albumSelectClear()
        }
    }
    /// The button body: Play all, or — armed — the checked albums in sort
    /// order, then disarm.
    function albumSectionPrimary(key, cards) {
        if (root.albumSelectKey !== key) {
            root.albumSectionAction(key, cards, "play-all")
            return
        }
        var ids = []
        for (var i = 0; i < cards.length; i++)
            if (root.albumSelected[cards[i].id] === true) ids.push(String(cards[i].id))
        root.albumSelectClear()
        if (ids.length > 0) QbzPlayer.playAlbums(JSON.stringify(ids))
    }

    // ---- Header atmosphere (ArtistPageView.slint:120-147) ----------------
    // Same three-line rule as AlbumView (the .slint says "same rule as
    // AlbumPageView" at :120). The pref is read LIVE off the settings
    // snapshot where one exists, else off the document (artist_qt.rs).
    readonly property bool headerGradientPref: {
        var raw = QbzBridge.settingsJson
        if (raw && raw.length > 2) {
            try {
                var d = JSON.parse(raw)
                if (d.albumHeaderGradient !== undefined)
                    return d.albumHeaderGradient === true
            } catch (e) { /* fall through to the document copy */ }
        }
        return artist.headerGradient !== false
    }
    readonly property bool headerAtmoOn: headerGradientPref && !ambientOn
    readonly property bool headerLight: headerGradientPref || ambientOn
    readonly property color hdrStrong: headerLight ? "#ffffff" : theme.textPrimary
    readonly property color hdrBody: headerLight ? "#e0ffffff" : theme.textSecondary
    readonly property bool hdrOverlay: headerLight
    /// Slint's `Theme.text-primary` as an ICON tint, for the hovers that raise
    /// a muted glyph on a THEME surface (every consumer sits on
    /// `surface-elevated`/transparent, never on the artwork header — that one
    /// uses `hdrStrong` above). Runtime-tinted via src/icon_tint_qt.rs, so it
    /// is the live token; it used to be `isDark ? "primary" : "black"`, a
    /// two-value stand-in from when only fixed bakes existed.
    readonly property string tintOnSurface: "textPrimary"
    /// TrackRow.slint:123-125 — the row hover uses the polarity-baked alpha
    /// ramp "so the hover state is visible on light themes too (the old
    /// #ffffff16 was invisible white-on-white there)". The zebra stripe is
    /// deliberately left as the literal, per the same comment.
    readonly property color rowHoverBg: theme.alphaTiers.length > 0
        ? theme.alphaTier(8) : (theme.isDark ? "#14ffffff" : "#14000000")
    property bool topTracksExpanded: false
    property bool appearsOnExpanded: false
    property bool otherExpanded: false

    // ---- Release-section "Load more": in-flight + append-fade state -------
    // controls/QbzLoadMore.qml owns the button and the placeholder row under
    // it; the APPEARANCE of what lands is the HOST's job (that file's "WHAT
    // THIS CONTROL DOES *NOT* DO" note) because only this view knows the index
    // the appended page starts at.
    //
    // Both maps live on `root`, keyed by releaseType, and NOT on the
    // ReleaseSection instances: the Repeater at :1787 re-creates every
    // delegate whenever `artist` changes (a `var` property notifies on every
    // write, and the document is republished once per enrichment pass —
    // stories, then each MusicBrainz section), and one of those republishes is
    // the very frame the new page lands in. A flag parked on the section would
    // be destroyed exactly when it was needed.
    //
    // `releasePending` is COPY-ON-WRITE because the ReleaseSection BINDS
    // `busy` to it, so it has to notify. `releaseFade` is mutated IN PLACE on
    // purpose: it is read once, imperatively, by each card's
    // Component.onCompleted, and a notify there would re-run bindings for
    // nothing.
    property var releasePending: ({})
    /// releaseType -> { from: <index the appended page starts at>,
    ///                  at: <ms the page LANDED, 0 while in flight> }.
    property var releaseFade: ({})

    /// ---- The appended pages themselves -----------------------------------
    /// releaseType -> { cards: [<pages 2..n, deduped, NEVER page 1>],
    ///                  hasMore: <the newest page's has_more; undefined until
    ///                            a page has landed>,
    ///                  pages: <index pages loaded so far, 1 = the embedded
    ///                          bucket — the LOADED_PAGES twin, see
    ///                          releaseMoreLanded's cap note> }.
    ///
    /// The document owns page 1 and stays the source of truth for it; this
    /// overlay owns everything Load more brought in, and `releaseSections`
    /// (:115) merges the two into a NEW array so the Repeaters rebuild. It is
    /// COPY-ON-WRITE for exactly that reason — the projection binds to it, so
    /// a write has to notify.
    ///
    /// Why an overlay and not a push into `artist`: `artist` is
    /// `JSON.parse(QbzArtist.artistJson)` (:52), a BINDING. Every progressive
    /// republish (Magazine stories, then each MusicBrainz section — see
    /// artist_qt.rs) re-runs that parse and yields a brand-new object, so
    /// anything written onto the parsed copy is discarded on the next pass.
    /// This is the same reasoning `localToggles` (:437) already carries for
    /// the heart/pin state.
    property var releaseOverlay: ({})
    /// releaseType -> { sent: <offset the page in flight asked for>,
    ///                  next: <offset the NEXT page must ask for> }.
    ///
    /// The paging cursor is the count of rows RECEIVED from the server, which
    /// is NOT the count on screen: both sides drop duplicate ids (here and in
    /// artist_qt.rs `merge_release_page`), so after a page that repeated three
    /// rows the on-screen count trails the server cursor by three. Handing the
    /// on-screen count back as the offset would re-request rows already held,
    /// and the dedup would then swallow them — a Load more that visibly does
    /// nothing, which is the very bug this block exists to kill.
    ///
    /// Mutated IN PLACE on purpose, same as `releaseFade`: it is written from
    /// the landing handler and read imperatively from the button's onClicked,
    /// and no binding reads it. A notifying write here would tear down and
    /// rebuild every AlbumCard in every release grid on each click, for
    /// nothing.
    property var releaseCursor: ({})
    /// How long after a landing the threshold stays live. The republish that
    /// carries the page re-creates the delegates in the same tick, so this is
    /// generous; what it buys is that a LATER, unrelated republish (a
    /// MusicBrainz pass) re-creates that tail WITHOUT re-fading it.
    readonly property int releaseFadeWindowMs: 1500

    /// Called from the section's Load more BEFORE the bridge call, so the
    /// threshold is the count that was on screen at click time. RETURNS the
    /// offset the caller must pass to the bridge (see `releaseCursor`).
    ///
    /// `sorted` = this bucket carries a non-default sort. The append fade is
    /// then SUPPRESSED, deliberately: `releaseFadeFrom` hands back an INDEX and
    /// the card delegate fades everything at or past it, which only means "the
    /// page that just landed" while new rows sit at the TAIL. Under "A–Z" the
    /// projection interleaves them (see `sortReleaseCards`), so that band would
    /// dissolve an arbitrary run of cards the user has been looking at all
    /// along. The reference has no fade at all here, so no fade is strictly
    /// closer to it than the wrong one — and tracking the new ids through a
    /// re-sort is not a thing the .slint does either.
    function releaseMoreRequested(releaseType, loadedCount, sorted) {
        if (sorted === true) delete releaseFade[releaseType]
        else releaseFade[releaseType] = { "from": loadedCount, "at": 0 }
        var c = releaseCursor[releaseType]
        // First page of this bucket: nothing has been fetched through the
        // paging endpoint yet, so the document's own row count IS the server
        // cursor. Afterwards the cursor is authoritative.
        var off = (c !== undefined && c.next !== undefined) ? c.next : loadedCount
        releaseCursor[releaseType] = { "sent": off,
                                       "next": (c !== undefined ? c.next : undefined) }
        var m = Object.assign({}, root.releasePending)
        m[releaseType] = true
        root.releasePending = m
        // artist_bridge.rs emits releaseSectionReady only on SUCCESS
        // (main.rs:872 just logs the error and returns), so a failed page would
        // otherwise leave the skeleton up forever. Bound it with the same 8s
        // QbzLoadMore's own skeleton settles at, after which the button comes
        // back armed.
        releaseSettle.restart()
        return off
    }
    /// The page landed (or came back empty): fold it into the overlay, advance
    /// the cursor, arm the fade window and disarm the placeholder.
    ///
    /// `cards` is the RAW page as the bridge sent it; `hasMore` is the
    /// server's own flag for the bucket.
    ///
    /// ORDER IS LOAD-BEARING. The overlay write is COPY-ON-WRITE, so it
    /// notifies, so `releaseSections` re-evaluates and the Repeater at :1997
    /// destroys and rebuilds every section delegate — QbzLoadMore and every
    /// AlbumCard included — SYNCHRONOUSLY, inside that assignment. Everything
    /// those rebuilt delegates read has to be true BEFORE it happens:
    ///   - `releaseFade[rt].at`, or each appended card's Component.onCompleted
    ///     asks `releaseFadeFrom()` while the landing still reads "in flight"
    ///     (at === 0 -> MAX_VALUE) and the page snaps in with no fade at all;
    ///   - `releasePending`, or the button is re-created with `busy` still
    ///     true and the skeleton flashes back for a frame UNDER the page that
    ///     just landed (the note the old handler carried, kept verbatim in
    ///     spirit).
    /// So: cursor + fade + placeholder first, overlay LAST.
    function releaseMoreLanded(releaseType, cards, hasMore) {
        // ---- 1. the cursor (in place — nothing binds to it) ---------------
        // Advance by the RAW page length, not by what survived the dedup: the
        // server counted every row it sent.
        var c = releaseCursor[releaseType]
        var base = (c !== undefined && c.sent !== undefined) ? c.sent : 0
        releaseCursor[releaseType] = { "sent": base, "next": base + cards.length }

        // ---- 2. fade window + placeholder ---------------------------------
        if (releaseFade[releaseType] !== undefined)
            releaseFade[releaseType].at = Date.now()
        if (root.releasePending[releaseType] !== undefined) {
            var m = Object.assign({}, root.releasePending)
            delete m[releaseType]
            root.releasePending = m
        }

        // ---- 3. the overlay (COPY-ON-WRITE — the projection binds to it) ---
        var prev = root.releaseOverlay[releaseType]
        var tail = (prev !== undefined && prev.cards !== undefined)
                   ? prev.cards.slice() : []
        var seen = {}
        var i
        // Page 1 lives in the document, and once artist_qt.rs
        // `merge_release_page` has folded an earlier page into the STASHED
        // document a republish puts that page there too — so both are checked
        // before anything is kept, and the overlay never grows a row the
        // document already carries.
        var doc = root.artist.releaseSections || []
        for (i = 0; i < doc.length; i++) {
            if (doc[i].releaseType !== releaseType) continue
            var dc = doc[i].cards || []
            for (var j = 0; j < dc.length; j++) seen[dc[j].id] = true
            break
        }
        for (i = 0; i < tail.length; i++) seen[tail[i].id] = true
        var before = tail.length
        for (i = 0; i < cards.length; i++) {
            if (seen[cards[i].id]) continue
            seen[cards[i].id] = true
            tail.push(cards[i])
        }
        // The reference CAPS the index at 4 pages per bucket and hands off to
        // the discography page beyond that: artist.rs:718-720 ("Page 1 is the
        // embedded bucket; 3 more loads reach the cap" — MAX_INDEX_PAGES = 4),
        // enforced at append_release_page:1268. This port has that page now
        // (QbzArtist.openReleases, the section title's own click), so the cap
        // carries over 1:1 — an uncapped index button would page a 300-album
        // Singles bucket into this grid forever, which is exactly what the
        // dedicated page exists to absorb.
        var pages = ((prev !== undefined && prev.pages !== undefined) ? prev.pages : 1) + 1
        // …and `!appended_ids.is_empty()` is the same line's other clause: a
        // page that contributed NOTHING after the dedup (all rows already on
        // screen, or empty outright) kills the button no matter what the flag
        // says — leaving it up would offer a page that can never change the
        // grid, and every further click would burn a request and land here
        // again.
        var more = (hasMore === true) && (tail.length > before) && (pages < 4)
        var o = Object.assign({}, root.releaseOverlay)
        o[releaseType] = { "cards": tail, "hasMore": more, "pages": pages }
        root.releaseOverlay = o
    }
    /// Index the appended page of `releaseType` starts at — +inf when this
    /// section never paged, when its page has not landed yet, or when the
    /// landing is already stale. Fading unconditionally would re-dissolve the
    /// whole grid on every enrichment pass, which reads as a flicker, not as
    /// polish.
    function releaseFadeFrom(releaseType) {
        var e = releaseFade[releaseType]
        if (e === undefined || e.at === 0)
            return Number.MAX_VALUE
        if (Date.now() - e.at > root.releaseFadeWindowMs)
            return Number.MAX_VALUE
        return e.from
    }
    /// The user picked a sort for one bucket (ReleaseGrid.slint:81-89). Hand it
    /// to the bridge — `QbzArtist.setSectionSort` persists it by release_type
    /// and re-sorts the STASHED document, which comes back as a republished
    /// `artistJson` — and reconcile the local paging state first.
    ///
    /// The OVERLAY's CARDS for this bucket are dropped. Nothing is lost by
    /// that: an overlay entry is only ever written when a page LANDS, and by
    /// then artist_qt.rs `load_release_page` has already folded that page into
    /// the stashed document (`merge_release_page`, called before the signal is
    /// emitted) — so every card the overlay holds is in the document the
    /// republish is about to carry, now in the new order. Keeping the cards
    /// would leave a second, stale copy of those rows whose only remaining job
    /// is to be deduped away.
    ///
    /// `hasMore` and `pages` are KEPT (the entry survives as a card-less
    /// stub). They are paging state, not row data, and neither is in the
    /// document: merge_release_page writes the SERVER's has_more flag into the
    /// stash, not the capped one, so dropping the whole entry after the cap
    /// closed a bucket would let the document's `hasMore: true` resurrect the
    /// button — and the reference's LOADED_PAGES counter survives a sort
    /// change too (nothing in artist.rs `resort_section` touches it).
    ///
    /// The CURSOR is deliberately kept. It counts rows the SERVER has sent, and
    /// the server's own order (`release_date`, hardcoded on purpose — the five
    /// picker keys are applied locally and never reach the API) has not changed
    /// just because we re-ordered them here. Resetting it would make the next
    /// Load more re-request pages we already hold, which the dedup would then
    /// swallow — the "button does nothing" bug the cursor exists to prevent.
    ///
    /// The FADE threshold is dropped for the same reason `releaseMoreRequested`
    /// suppresses it under a custom sort: it is an index into an order that no
    /// longer exists, and the republish re-creates every delegate.
    function releaseSortChanged(releaseType, sortKey) {
        delete releaseFade[releaseType]
        var sections = root.artist.releaseSections || []
        var oldSort = "default"
        for (var i = 0; i < sections.length; i++) {
            if (sections[i].releaseType === releaseType) oldSort = sections[i].sortBy || "default"
        }
        var serverChanged = (oldSort === "relevant") !== (sortKey === "relevant")
        var overlay = Object.assign({}, root.releaseOverlay)
        if (serverChanged) {
            delete overlay[releaseType]
            delete root.releaseCursor[releaseType]
            var pending = Object.assign({}, root.releasePending)
            delete pending[releaseType]
            root.releasePending = pending
        } else if (overlay[releaseType] !== undefined) {
            var e = Object.assign({}, overlay[releaseType])
            delete e.cards
            overlay[releaseType] = e
        }
        root.releaseOverlay = overlay
        QbzArtist.setSectionSort(releaseType, sortKey)
    }
    Timer {
        id: releaseSettle
        interval: 8000
        repeat: false
        onTriggered: root.releasePending = ({})
    }

    // ---- Network sidebar open/closed -------------------------------------
    // ShellState.content-constrained (state.slint:4114): window under the NPB
    // breakpoint AND a right panel (Queue / Lyrics) open. NOT a raw
    // `root.width < N` — the .slint calls that exact trigger out as the
    // regression it fixed (ArtistPageView.slint:166-172): at a normal window
    // the content area is already narrow WITHOUT any panel, so the sidebar
    // would never auto-open at all.
    readonly property bool contentConstrained:
        Window.width > 0 && Window.width < 1366
        && (QbzShell.queueOpen || QbzShell.lyricsOpen)
    // A constrain edge closes the full-width relationship sidebar so the
    // release grid keeps priority. This is deliberately ONE-WAY: after that
    // the existing Network button remains available and may reopen it even in
    // the constrained layout; gaining room must not override that user choice.
    // A newly opened artist still starts from the available-space default in
    // syncArtistState(), matching the page-entry behaviour.
    property bool networkOpen: !contentConstrained
    onContentConstrainedChanged: {
        if (contentConstrained)
            networkOpen = false
    }
    property string netTab: "network"
    readonly property int preview: 5
    // Sidebar lists are unbounded upstream (an orchestra can list 150
    // members): show a slice, expand on demand — the delegates for the rest
    // are never instantiated.
    readonly property int sidebarPreview: 12
    property bool membersExpanded: false
    property bool groupsExpanded: false
    property bool collabsExpanded: false
    // Thumbs-downed discovery rows, by mbid. Session-only: the Slint app
    // persists these in its `discovery_dismiss` store, which this POC does
    // not open, so the rejection lasts as long as the process — it is NOT
    // written anywhere and makes no claim to be.
    property var dismissedDiscovery: ({})
    // The artist the view state (tab choice, dismissals) belongs to. Compared
    // on every republish so a mid-load pass never resets the user's choices.
    property string loadedArtistId: ""

    // Optimistic heart/pin state. The document is republished several times
    // per page now (stories, then each MusicBrainz section), and every
    // republish re-parses `artist` — a toggle written straight onto the parsed
    // object would silently pop back. Overrides live here instead and win over
    // whatever the document says, until the artist changes.
    property var localToggles: ({})
    function toggleState(key, fallback) {
        return localToggles[key] !== undefined ? localToggles[key] : fallback === true
    }
    function setToggleState(key, value) {
        var m = localToggles
        m[key] = value
        localToggles = Object.assign({}, m)
    }

    // --- Artist blacklist -------------------------------------------------
    // ONE source for the two surfaces the .slint drives off the same
    // ArtistState.is-blacklisted: the overflow-menu row label
    // (ArtistPageView.slint:565-567) and the hidden-artist banner (:595, :600).
    // `artist_qt` seeds the field on entry; the local toggle map provides the
    // optimistic edge while `blacklistChanged` settles or rolls it back.
    readonly property bool artistBlacklisted: toggleState("artistBlacklist", artist.isBlacklisted)
    function toggleBlacklist() {
        var aid = artist.id || ""
        if (aid === "")
            return
        // Optimistic flip first (main.rs:12777 `st.set_is_blacklisted(!was)`),
        // then the mutation; `blacklistChanged` settles it — or rolls it back
        // on a failed write (blacklist_qt.rs `artist_toggle`).
        setToggleState("artistBlacklist", !artistBlacklisted)
        QbzBlacklist.artistToggle(aid, artist.name || "")
    }

    readonly property var discoveryRows: {
        var out = []
        var rows = network.discovery || []
        for (var i = 0; i < rows.length; i++) {
            if (!dismissedDiscovery[rows[i].mbid]) out.push(rows[i])
        }
        return out
    }

    // ---- Loading staging (artist_qt.rs publishes in passes) --------------
    // The Qobuz page lands first; the Magazine stories and each MusicBrainz
    // sidebar section arrive later on their own flags. Every one of these is
    // ALSO gated on mbAvailable upstream, so with MusicBrainz off in Settings
    // (or no confident match) they are absent — placeholder included.
    readonly property bool primaryLoading: QbzArtist.artistLoading
                                           && (artist.topTracks || []).length === 0
    readonly property bool originPending: network.mbAvailable === true
                                          && network.originLoading === true
    readonly property bool relationshipsPending: network.mbAvailable === true
                                                 && network.relationshipsLoading === true
    readonly property bool discoveryPending: network.mbAvailable === true
                                             && network.discoveryLoading === true
                                             && root.discoveryRows.length === 0
    readonly property bool similarPending: similarArtists.length === 0 && QbzArtist.artistLoading
    readonly property bool storiesPending: artist.storiesLoading === true && stories.length === 0

    // ONE 900ms phase for every placeholder on the page (QbzSkeleton's COST
    // note: N placeholders, 1 timer). Stops dead when nothing is pending.
    Timer {
        id: skeletonPhase
        property bool on: false
        interval: 900
        repeat: true
        running: root.visible && (root.primaryLoading || root.originPending
                                  || root.relationshipsPending || root.discoveryPending
                                  || root.similarPending || root.storiesPending)
        onTriggered: on = !on
    }

    // JUMP TO tabs from the present sections (ArtistState.jump-tabs).
    // Built from the RAW document, never the filtered lists: artist.rs
    // builds jump_tabs ONCE at load (`build_jump_tabs`) and `filter_artist`
    // does not touch them, so the strip must not reshuffle per keystroke.
    readonly property var jumpTabs: {
        var tabs = []
        // The strip is a SCROLL navigator over one vertical page, so it can
        // only list what that page currently draws. In library mode that is
        // the Tracks and Albums sections that have rows — the catalog set
        // stayed up before and "Popular Tracks" scrolled to a section that
        // was not there (owner capture, 2026-09-04).
        if (root.artistTab === "library") {
            // "About" is the strip's back-to-top, and in library mode it is
            // also what keeps the strip MOUNTED when the filter yields nothing
            // (purchases ∧ favourites on an artist whose purchases are not
            // hearted): the bar carries the two switches, so an empty tab set
            // would have hidden the only way to reset them.
            tabs.push({ "id": "about", "label": QbzSession.tr("About", QbzSession.trRev) })
            if (root.libTracks.length > 0) tabs.push({ "id": "tracks", "label": QbzSession.tr("Tracks", QbzSession.trRev) })
            if (root.libAlbums.length > 0) tabs.push({ "id": "albums", "label": QbzSession.tr("Albums", QbzSession.trRev) })
            return tabs
        }
        var rawTop = artist.topTracks || []
        var rawSections = artist.releaseSections || []
        var rawAppears = artist.appearsOn || []
        if ((artist.bio || "") !== "") tabs.push({ "id": "about", "label": QbzSession.tr("About", QbzSession.trRev) })
        if (rawTop.length > 0) tabs.push({ "id": "popular-tracks", "label": QbzSession.tr("Popular Tracks", QbzSession.trRev) })
        for (var i = 0; i < rawSections.length; i++) {
            if (rawSections[i].releaseType !== "other")
                tabs.push({ "id": rawSections[i].releaseType, "label": rawSections[i].title })
        }
        if (rawAppears.length > 0) tabs.push({ "id": "appears-on", "label": QbzSession.tr("Appears On", QbzSession.trRev) })
        return tabs
    }

    // Two blocks, not one: artwork is QbzLibrary's signal and the releases
    // pager is QbzArtist's. Retargeting a mixed block wholesale would
    // silently orphan the other half — QML resolves handlers lazily, so the
    // discography would just stop loading with nothing in the log.
    // Covers arrive ONE AT A TIME, and on a warm cache `sidebar_artwork_window`
    // emits the whole disk-hit set in a single synchronous loop (main.rs:391).
    // Rebinding `coverMap` per arrival is quadratic in the page: each arrival
    // copied the entire map and re-evaluated the cover binding of EVERY
    // mounted card, so an artist with 200 releases did ~40k binding
    // evaluations and 200 map copies during the frames the page is trying to
    // paint. Arrivals are coalesced into ONE rebind per frame — the same fix
    // LocalLibraryView carries, at O(n) instead of O(n²), with the covers
    // still appearing progressively (16ms granularity is invisible).
    // --- Track info for the Popular Tracks rows (2026-09-13) ---------------
    // ONE lazy modal per artist view (the full Popup tree must not exist per
    // row). Activated on demand, torn down on close (Qt.callLater so the
    // Popup is not destroyed mid-signal) — the same shape rows/TrackRow.qml
    // carries per row.
    // One clipboard carrier for every Popular Tracks row's Copy submenu.
    QbzClipboard { id: artistClipboard }

    Loader {
        id: artistTrackInfo
        active: false
        sourceComponent: TrackInfoModal { }
    }
    Connections {
        target: artistTrackInfo.item
        ignoreUnknownSignals: true
        function onClosed() { Qt.callLater(function () { artistTrackInfo.active = false }) }
    }
    function openTrackInfo(trackId) {
        if (!trackId || trackId === "")
            return
        artistTrackInfo.active = true
        artistTrackInfo.item.openFor(trackId)
    }

    property var _coverInbox: ({})
    Timer {
        id: coverFlush
        interval: 16
        repeat: false
        onTriggered: {
            var m = Object.assign({}, root.coverMap, root._coverInbox)
            root._coverInbox = ({})
            // A rebind needs a NEW object reference (same-ref assignment is
            // not a change in QML).
            root.coverMap = m
        }
    }
    Connections {
        target: QbzLibrary
        function onLibraryArtworkReady(key, path) {
            root._coverInbox[key] = path
            if (!coverFlush.running) coverFlush.start()
        }
        // The SETTLED follow/heart state from Rust: the flipped value when the
        // write landed, the UNCHANGED one when it failed. Both the header
        // follow and the Popular Tracks / Appears On hearts write their
        // optimistic flip into localToggles and nothing used to correct it, so
        // a failed write stayed visibly wrong until the user left the page.
        // Key shape is `library_qt::feed_key` (`{kind}:{id}`) — which is
        // already the exact key the track rows use for their override.
        function onLibraryFavoriteChanged(key, value) {
            var aid = (artist && artist.id) ? artist.id : ""
            if (aid !== "" && key === "artist:" + aid)
                root.setToggleState("artist", value)
            else if (key.indexOf("track:") === 0 || key.indexOf("album:") === 0)
                root.setToggleState(key, value)
        }
        // Header pin, same seam: the overflow-menu row flips `artistPin`
        // optimistically, and this settles it from the store (Slint does the
        // same for the open detail view: `st.set_pinned(pinned)` when its id
        // matches). The release CARDS need nothing here — each one listens to
        // this signal itself (cards/AlbumCard.qml).
        function onPinChanged(key, value) {
            var aid = (artist && artist.id) ? artist.id : ""
            if (aid !== "" && key === "artist:" + aid)
                root.setToggleState("artistPin", value)
        }
    }
    // Blacklist settle / rollback. `blacklistChanged` carries the state the
    // write actually produced — flipped on success, UNCHANGED on failure
    // (blacklist_qt.rs `artist_toggle`), which is exactly what main.rs:12799
    // does with its rollback branch. Also the cross-surface walk: unblocking
    // the same artist from the manager view while this page is mounted moves
    // the menu label and drops the banner. Same two-arg `{kind}:{id}` shape as
    // the two signals above; its own Connections block only because the signal
    // lives on a different singleton.
    Connections {
        target: QbzBlacklist
        function onBlacklistChanged(key, value) {
            var aid = (artist && artist.id) ? artist.id : ""
            if (aid !== "" && key === "artist:" + aid)
                root.setToggleState("artistBlacklist", value)
        }
    }

    Connections {
        target: QbzArtist
        function onReleaseSectionReady(releaseType, cardsJson, hasMore) {
            // Hand the page to the OVERLAY (root.releaseOverlay) and let the
            // `releaseSections` projection merge it. It used to be pushed
            // straight into `root.artist.releaseSections[i].cards` followed by
            // a manual `artistChanged()`, and that is why "nunca cargan mas
            // albumes": the push mutated the array IN PLACE, so both Repeaters
            // were re-handed the identical array reference and QML had nothing
            // to invalidate — the fake `artistChanged()` re-ran every OTHER
            // binding on the page and left the two that mattered untouched,
            // because `releaseSections`' unfiltered arm returned `all`, the
            // document's own array, unchanged.
            //
            // The signal is emitted only on SUCCESS (main.rs:872 logs errors
            // and returns), and an empty page comes through here too — that is
            // what clears the skeleton when a bucket runs out.
            var cards = JSON.parse(cardsJson)
            root.releaseMoreLanded(releaseType, cards, hasMore)
            // The appended covers are not in the document (artist_qt.rs folds
            // them into the STASHED copy, which only reaches us on the next
            // enrichment republish), so the document-driven dispatch would
            // leave the new row as blank tiles until an unrelated pass
            // happened to land. dispatchCovers() reads the overlay too, and
            // `dispatchedCovers` makes the re-scan free.
            root.dispatchCovers()
        }
    }
    Component.onCompleted: {
        syncArtistState()
        dispatchCovers()
    }
    onArtistChanged: {
        syncArtistState()
        invalidatePortraitOverride()
        dispatchCovers()
        // The last owned row just left (a republish after an un-heart): the
        // toggle unmounts, so the page must not stay on an empty tab with no
        // way back.
        if (artistTab === "library" && (artist.libraryCount || 0) === 0)
            artistTab = "catalog"
    }
    // Cover dispatch keys off the raw document (artist.artUrl etc.), so
    // re-fire when the parsed value actually changes (same stale race).
    // (the raw document drives the dispatch; onArtistChanged above covers it)
    onArtistTabChanged: {
        // A selection is a list of THIS mode's rows; it cannot survive the
        // switch. The strip re-anchors on the first section the new mode
        // draws (catalog keeps its Popular Tracks default).
        setMultiSelect(false)
        albumSelectClear()
        // The first SECTION, not "About" (back-to-top) when a section exists.
        var first = ""
        for (var i = 0; i < root.jumpTabs.length; i++) {
            first = root.jumpTabs[i].id
            if (first !== "about") break
        }
        root.activeJumpTab = artistTab === "catalog" ? "popular-tracks" : first
        if (artistTab === "library") {
            // Re-arm the warm, served from cache (main.rs warm_library).
            QbzArtist.warmLibrary()
            dispatchLibCovers()
        }
    }

    // The document is republished several times per page (stories, then each
    // MusicBrainz section). Reset per-artist view state ONLY when the id
    // actually changed, or an enrichment pass would yank the sidebar tab back
    // under the user mid-read.
    // --- Multi-select (Popular Tracks + Appears On) ------------------------
    // One selection model for the page's Qobuz track lists. Same shape as
    // AlbumView/PlaylistView: state in QML, select-all/clear local, the rest
    // via QbzPlayer.bulkTracksAction (bulk_tracks_qt.rs).
    property bool multiSelect: false
    property var selected: ({})
    readonly property int selectedCount: Object.keys(root.selected).length
    readonly property bool multiSelectOn: root.multiSelect
    function setMultiSelect(on) {
        root.multiSelect = on
        if (!on) { root.selected = ({}); sel.anchorId = "" }
    }
    /// Excel-style selection lives in ONE place — controls/SelectionModel.qml
    /// holds the anchor and the Shift-range rule; this view keeps owning its
    /// map. The two lists are CONCATENATED in the order they are drawn, so a
    /// range can run from the last top track into "Appears on" exactly as it
    /// looks on screen — `selectedIdsInOrder` already walks them that way.
    SelectionModel { id: sel }
    /// The track lists a selection can span, in draw order, for the ACTIVE
    /// mode: the catalog's Popular Tracks + Appears On, or the library tab's
    /// Tracks. `onArtistTabChanged` clears the selection on a switch, so a
    /// range never mixes the two.
    function selectableLists() {
        return root.artistTab === "library" ? [root.libTracks]
                                            : [root.topTracks, root.appearsOn]
    }
    function toggleSelected(id, mods) {
        var lists = selectableLists()
        var all = lists.length > 1 ? lists[0].concat(lists[1]) : lists[0]
        root.selected = sel.next(root.selected, id, all,
                                 mods === undefined ? Qt.NoModifier : mods)
    }
    function selectedIdsInOrder() {
        var out = []
        var lists = selectableLists()
        for (var l = 0; l < lists.length; l++) {
            var rows = lists[l]
            for (var i = 0; i < rows.length; i++)
                if (root.selected[rows[i].id] === true) out.push(rows[i].id)
        }
        return out
    }
    function bulkAction(action) {
        if (action === "select-all") {
            var m = {}
            var lists = selectableLists()
            for (var l = 0; l < lists.length; l++)
                for (var i = 0; i < lists[l].length; i++) m[lists[l][i].id] = true
            root.selected = m
            return
        }
        if (action === "clear") { root.selected = ({}); sel.anchorId = ""; return }
        var ids = root.selectedIdsInOrder()
        if (ids.length === 0) return
        QbzPlayer.bulkTracksAction(JSON.stringify(ids), action, "artist", String(artist.id || ""))
        if (action !== "add-to-playlist" && action !== "add-to-mixtape")
            root.selected = ({})
    }
    // Ctrl+A / Escape hotkey router seam (AppShell duck-types these).
    function selectAll() {
        if (!root.multiSelect) root.setMultiSelect(true)
        root.bulkAction("select-all")
    }
    function exitMultiSelectMode() {
        if (root.multiSelect) root.setMultiSelect(false)
    }

    function syncArtistState() {
        var id = artist.id || ""
        if (id === loadedArtistId)
            return
        loadedArtistId = id
        setMultiSelect(false)
        // A fresh artist opens on its catalog with the library tab's
        // preview and switches at rest.
        artistTab = "catalog"
        libTracksExpanded = false
        libShowPurchases = false
        libShowFavorites = false
        libSort = artist.librarySort || "default"
        albumSelectClear()
        // Slint opens a fresh artist on Network, or on Magazine when
        // MusicBrainz is off (an empty Network tab is worse than none).
        netTab = (artist.network && artist.network.mbAvailable) ? "network" : "magazine"
        // …and re-applies the room rule (ArtistPageView.slint:178, artist.rs
        // `reset_network_sidebar`): a new artist re-opens the panel unless
        // the content area is constrained.
        networkOpen = !contentConstrained
        dismissedDiscovery = ({})
        localToggles = ({})
        // A fresh artist must never inherit the previous one's paging state:
        // a stale threshold would fade a band of the new artist's first page
        // for no reason, a stale pending flag would show a skeleton under a
        // button nobody pressed, a stale OVERLAY would graft the previous
        // artist's albums onto this one's grids (release types are shared
        // keys — every artist has an "album" bucket), and a stale CURSOR would
        // page the new artist from the old one's offset.
        releasePending = ({})
        releaseFade = ({})
        releaseOverlay = ({})
        releaseCursor = ({})
        releaseSettle.stop()
        membersExpanded = false
        groupsExpanded = false
        collabsExpanded = false
        dispatchedCovers = ({})
    }

    function dispatchLibCovers() {
        var items = root.libItems || []
        var urls = []
        for (var i = 0; i < items.length; i++) if (items[i].imageUrl) urls.push(items[i].imageUrl)
        dispatchArtwork(urls)
    }

    // Already-requested artwork keys. With the progressive republish the
    // dispatch runs once per pass, so re-sending the whole (potentially
    // several-hundred-entry) URL list every time is pure waste — send only
    // what is new.
    property var dispatchedCovers: ({})
    function dispatchArtwork(urls) {
        var fresh = []
        for (var i = 0; i < urls.length; i++) {
            var u = urls[i]
            if (!u || dispatchedCovers[u]) continue
            dispatchedCovers[u] = true
            fresh.push(u)
        }
        if (fresh.length > 0) QbzShell.sidebarArtworkWindow(JSON.stringify(fresh))
    }

    // A custom portrait is consulted by `artwork_qt::cached_path` (it checks
    // `cover_artwork_qt::override_for_url` FIRST), so once one exists
    // `coverMap[artist.artUrl]` holds the OVERRIDE file, not the Qobuz one.
    // Removing the override has to invalidate that entry as well, or the
    // header and the lightbox keep showing the picture the user just deleted:
    // `dispatchedCovers` dedupes by url and is cleared only on an artist
    // change, so the republish alone never re-resolves it. Add/Change need the
    // same invalidation in reverse.
    property string _lastCustomPortrait: ""
    function invalidatePortraitOverride() {
        var cur = (artist && artist.customImagePath) ? artist.customImagePath : ""
        if (cur === root._lastCustomPortrait) return
        root._lastCustomPortrait = cur
        var url = (artist && artist.artUrl) ? artist.artUrl : ""
        if (url === "") return
        var m = Object.assign({}, root.coverMap)
        delete m[url]
        root.coverMap = m
        // Drop the dedupe key too, so the dispatchCovers() that follows in the
        // same handler actually re-requests it.
        delete root.dispatchedCovers[url]
    }

    // THE RULE FOR THIS FUNCTION: every section of the page that binds
    // `root.coverMap` has to contribute its urls here, or its covers are
    // never requested and the section renders empty tiles forever — nothing
    // downstream reports the omission, because a missing key is
    // indistinguishable from a cover that has not landed yet.
    //
    // Three sections were missing and each one rendered blank:
    //   - Latest release (`artist.lastRelease`, the reported bug) — one card,
    //     and the only cover between Popular Tracks and the release grids;
    //   - Appears On (`artist.appearsOn`) — TrackRow covers, the same
    //     PopularTrackRow component the collected topTracks use, which is why
    //     the omission was easy to miss;
    //   - Playlists (`artist.playlists`) — the 200px rectangle covers of the
    //     horizontal strip.
    // Present and collected: the header portrait, Popular Tracks, every
    // release section (including the collapsed "Other"), and the Magazine
    // stories. The Network sidebar carries NO covers (ArtistSimilar and
    // MbDiscoveryJson have no artUrl — artist_qt.rs), so it contributes none.
    // The In-library tab has its own dispatcher, dispatchLibCovers().
    function dispatchCovers() {
        var urls = []
        if (artist.artUrl) urls.push(artist.artUrl)
        var i, j
        // RAW lists: a filtered-out card still needs its cover for when the
        // query is cleared, and this must not re-run per keystroke.
        var rawTop = artist.topTracks || []
        var rawAppears = artist.appearsOn || []
        var rawSections = artist.releaseSections || []
        var rawPlaylists = artist.playlists || []
        for (i = 0; i < rawTop.length; i++) if (rawTop[i].artUrl) urls.push(rawTop[i].artUrl)
        for (i = 0; i < rawAppears.length; i++)
            if (rawAppears[i].artUrl) urls.push(rawAppears[i].artUrl)
        if (artist.lastRelease && artist.lastRelease.artUrl)
            urls.push(artist.lastRelease.artUrl)
        for (i = 0; i < rawSections.length; i++)
            for (j = 0; j < (rawSections[i].cards || []).length; j++)
                if (rawSections[i].cards[j].artUrl) urls.push(rawSections[i].cards[j].artUrl)
        // …and the pages "Load more" appended, which are NOT in the document:
        // they live in root.releaseOverlay until artist_qt.rs's stashed copy
        // reaches us through the next enrichment republish. Off the overlay
        // rather than off `releaseSections` for the same reason the lists
        // above are RAW — the projection is filtered, and a covers dispatch
        // must not depend on the search box.
        for (var rt in root.releaseOverlay) {
            var tail = root.releaseOverlay[rt].cards || []
            for (i = 0; i < tail.length; i++)
                if (tail[i].artUrl) urls.push(tail[i].artUrl)
        }
        for (i = 0; i < rawPlaylists.length; i++)
            if (rawPlaylists[i].artUrl) urls.push(rawPlaylists[i].artUrl)
        // Magazine story thumbnails ride the same pipeline (arc-cdn URLs).
        // Off `artist.stories`, NOT the derived `stories` property (:110): this
        // function is called from `onArtistChanged`, and a derived binding still
        // holds the PREVIOUS document inside its source's change handler on this
        // Qt build (measured — the same race QueuePanel.dispatchCovers and
        // AlbumView's `onHeaderChanged` exist for). The stories land in a LATER
        // publish than the page itself, so a stale read asked for the previous
        // pass's thumbnails and the story cards stayed empty frames whenever the
        // stories pass was the last publish.
        var rawStories = artist.stories || []
        for (i = 0; i < rawStories.length; i++)
            if (rawStories[i].artUrl) urls.push(rawStories[i].artUrl)
        dispatchArtwork(urls)
    }

    function scrollToSection(id) {
        root.activeJumpTab = id
        // Anchors resolve against the column of the ACTIVE mode: the catalog
        // and library columns are siblings in the page, and a library tab
        // resolved against the hidden catalog column would scroll to that
        // column's coordinates.
        var host = root.artistTab === "library" ? libraryTab : sectionAnchors
        for (var i = 0; i < host.children.length; i++) {
            var c = host.children[i]
            if (c.anchorId === id) {
                flick.contentY = host.y + c.y - 48
                return
            }
        }
        // "About" is back-to-top: the library column carries no such anchor
        // (the bio lives in the header), so it lands on the page top.
        if (id === "about") flick.contentY = 0
    }



    // Popular Tracks row (TrackRow with artwork + album column).
    //
    // COLUMN GEOMETRY: rows/TrackCols.qml, the same object rows/TrackRow.qml
    // and rows/TrackListHeader.qml read. This component is a FORK of the
    // shared row (POC-NOTE, pre-existing) and it had the full column set
    // re-typed as literals; they were numerically right, but a fork with its
    // own copy of the numbers is precisely how a table's columns drift. The
    // artist page draws no column header (neither does
    // artist/ArtistPageView.slint), so nothing is misaligned today — this
    // keeps it that way if the widths ever move.
    component PopularTrackRow: Rectangle {
        id: popRow
        property var row: ({})
        property int rowIndex: 0
        property bool showAlbum: true
        /// Where a play on this row goes — `function (id)`. Unset, the row
        /// plays through `QbzPlayer.playArtistTrack`, whose queue is the
        /// POPULAR list (artist_qt TOP_QUEUE). The "In library" tab passes
        /// its own handler because a library row is NOT in that queue and
        /// `top_queue` starts the popular list at row 0 for any id it does
        /// not hold — issue #737. The row never asks which tab it is in.
        property var playHandler: null
        function play() {
            if (popRow.playHandler) popRow.playHandler(String(popRow.row.id))
            else QbzPlayer.playArtistTrack(popRow.row.id)
        }
        // Multi-select (the view's bulk bar): in select mode the whole row
        // body is the toggle and the leading cell swaps to a round checkbox
        // (TrackRow.slint:173-177, 392-417).
        property bool selectMode: false
        property bool checked: false
        /// `modifiers` off the mouse event — see SelectionModel.
        signal toggleSelect(int modifiers)
        // Live offline status for the row (seeded in the document; updates
        // arrive on QbzShell's trackCacheStatusChanged).
        property int cacheStatus: row.cacheStatus !== undefined ? row.cacheStatus : 0
        Connections {
            target: QbzShell
            function onTrackCacheStatusChanged(trackId, status, progress) {
                if (trackId === (popRow.row.id || "")) popRow.cacheStatus = status
            }
        }

        TrackCols { id: cols }

        readonly property bool isActive: QbzPlayer.npTrackId !== "" && QbzPlayer.npTrackId === row.id
        readonly property bool hovered: trArea.containsMouse || favArea.containsMouse || moreArea.containsMouse

        // --- PULLED FROM THE QOBUZ CATALOGUE (contract §5.2) --------------
        // The artist page is one of the seven surfaces §5.2 names, and this
        // component is a documented FORK of rows/TrackRow.qml (see the header
        // above), so the treatment has to be repeated here rather than
        // inherited. It is repeated EXACTLY — same field, same predicate, same
        // `circle-alert` in the number slot, same 0.5 dim — because two
        // screens that disagree about what a dead row looks like is the
        // fork-drift this file has already paid for once.
        //
        // `row.qobuzUnavailable` is the API's `streamable: false` for THIS
        // track and nothing else: an absent field is not a claim, so a
        // producer that does not carry it yet leaves every row alive.
        // `cacheStatus === 3` (downloaded) is excluded because a pulled track
        // the user already downloaded still plays from disk (§5.3, F5) — this
        // fork has no cached-but-pulled badge of its own, so such a row simply
        // keeps behaving normally, which is the safe half of that split.
        readonly property bool pulled: row.qobuzUnavailable === true
        readonly property bool pulledDead: popRow.pulled && popRow.cacheStatus !== 3

        width: parent ? parent.width : 0
        height: 50
        radius: 8
        // Hover fill off on a dead row — a row that lights up reads clickable.
        color: (hovered && !popRow.pulledDead)
            ? root.rowHoverBg : (rowIndex % 2 === 1 ? "#07ffffff" : "transparent")

        Rectangle {
            visible: isActive
            x: 2
            y: 7
            width: 3
            height: parent.height - 14
            radius: 1.5
            color: theme.accent
        }

        Row {
            anchors.fill: parent
            anchors.leftMargin: cols.padH
            anchors.rightMargin: cols.padH
            spacing: cols.gap
            // THE DIM. On the Row, not on `popRow`: the now-playing edge mark
            // and the row menu are siblings of this item and neither fades.
            // 0.5 is views/purchases/PurchaseListRow.qml's value, the same one
            // rows/TrackRow.qml adopted.
            opacity: popRow.pulledDead ? 0.5 : 1.0

            // Position number (artwork rows carry it separate from the cover).
            // On a dead row the alert glyph takes this slot — same cell, same
            // width, so nothing reflows. `circle-alert`, NOT `triangle-alert`:
            // the download column below already draws the triangle for a
            // FAILED CACHE (`cacheStatus === 4`), and one row must not carry
            // two identical glyphs meaning two different things (§A F11).
            Item {
                visible: showAlbum
                width: cols.colNumber
                height: parent.height
                Text {
                    visible: !popRow.pulledDead
                    anchors.fill: parent
                    verticalAlignment: Text.AlignVCenter
                    text: row.number
                    color: theme.textMuted
                    font.pixelSize: 13
                    horizontalAlignment: Text.AlignHCenter
                    elide: Text.ElideRight
                }
                Loader {
                    anchors.centerIn: parent
                    width: 20
                    height: 20
                    // A Loader, so a live row instantiates neither the glyph
                    // nor the attached ToolTip (one QObject per row the moment
                    // it is referenced).
                    active: popRow.pulledDead
                    visible: active
                    sourceComponent: Item {
                        QbzIcon {
                            anchors.centerIn: parent
                            name: "circle-alert"
                            width: 15
                            height: 15
                            tintName: "favorite"
                        }
                        MouseArea {
                            anchors.fill: parent
                            hoverEnabled: true
                            ToolTip.visible: containsMouse
                            ToolTip.delay: 300
                            // Same split as rows/TrackRow.qml: a pre-release
                            // says "not yet", a pulled track keeps the REUSED
                            // msgid the reactive skip path toasts.
                            ToolTip.text: row.qobuzUpcoming === true
                                ? QbzSession.tr("This track is not yet available", QbzSession.trRev)
                                : QbzSession.tr("This track is no longer available", QbzSession.trRev)
                        }
                    }
                }
            }
            // Cover with hover play overlay — in select mode this cell is
            // the row's round checkbox instead.
            //
            // RADIUS 4, not `theme.radiusSm` (8): rows/TrackRow.qml:553 — the
            // SHARED row this component is a fork of, and the one PlaylistView
            // / the album detail / search all draw — rounds its artwork cell
            // at 4. The fork had drifted to 8 and the owner saw it ("los album
            // arts de Popular tracks esta mas redondo que otros, por ejemplo,
            // los de playlistview"). All THREE stacked elements carry the same
            // number — the cell, the image and the hover scrim — or the scrim's
            // corners stick out past the art. The ROW's own `radius: 8` above
            // is correct and matches TrackRow.qml:288; only the cover moved.
            Rectangle {
                width: showAlbum ? cols.colArt : cols.colNumber
                height: showAlbum ? cols.colArt : 28
                anchors.verticalCenter: parent.verticalCenter
                radius: 4
                color: theme.surfaceElevated
                clip: true
                // The select-mode checkbox (accent fill when checked).
                Rectangle {
                    visible: popRow.selectMode
                    anchors.centerIn: parent
                    width: 14
                    height: 14
                    radius: 7
                    color: popRow.checked ? theme.accent : "transparent"
                    border.width: popRow.checked ? 0 : 1.5
                    border.color: theme.textMuted
                    QbzIcon {
                        visible: popRow.checked
                        anchors.centerIn: parent
                        name: "check"
                        width: 10
                        height: 10
                        tintName: theme.accentGlyphTint
                    }
                }
                QbzIcon {
                    visible: !popRow.selectMode
                    anchors.centerIn: parent
                    name: "music"
                    width: showAlbum ? 16 : 14
                    height: showAlbum ? 16 : 14
                    tintName: "muted"
                }
                RoundedImage {
                    visible: !popRow.selectMode
                    anchors.fill: parent
                    source: root.coverMap[row.artUrl] || ""
                    radius: 4
                }
                // The hover scrim and its play glyph are the cover cell's play
                // AFFORDANCE, and an affordance is a claim that clicking does
                // something — so a dead row shows neither, and the area under
                // them is disabled rather than left to issue a play that can
                // only fail.
                Rectangle {
                    visible: !popRow.selectMode && !popRow.pulledDead
                    anchors.fill: parent
                    radius: 4
                    color: "#000000"
                    opacity: trArea.containsMouse || isActive ? 0.6 : 0.0
                    Behavior on opacity { NumberAnimation { duration: 150 } }
                }
                QbzIcon {
                    visible: !popRow.selectMode && !popRow.pulledDead
                        && (trArea.containsMouse || isActive)
                    anchors.centerIn: parent
                    name: isActive && QbzPlayer.npPlaying ? "pause" : "play-fill"
                    width: 16
                    height: 16
                    // On the #000000 @ 0.6 artwork scrim above — dark under
                    // every theme.
                    tintName: "white"
                }
                MouseArea {
                    anchors.fill: parent
                    enabled: !popRow.selectMode && !popRow.pulledDead
                    cursorShape: Qt.PointingHandCursor
                    onClicked: popRow.play()
                }
            }
            // Title + artist.
            //
            // This was `- 6 * 14` for the gaps in BOTH arms. With the album
            // column on there are nine visible cells, i.e. EIGHT gaps, so the
            // stretch column ran 28px long and dragged Album / Duration /
            // Quality / heart 28px right of where the shared TrackRow puts
            // them — the same class of defect as the header, inside a forked
            // row. `cols.titleWidth` counts the gaps from the arms.
            //
            // Arms: with the album column the leading cells are the 32px
            // number AND the 36px cover (artwork arm); without it the single
            // 32px cover IS the number cell.
            Column {
                width: cols.titleWidth(popRow.width, popRow.showAlbum, popRow.showAlbum,
                                       true, true, true)
                anchors.verticalCenter: parent.verticalCenter
                spacing: 2
                Row {
                    spacing: 6
                    Text {
                        text: row.title
                        // Muted, not merely dimmed: the Row's 0.5 fades the
                        // cell uniformly, and the TITLE is the part that has to
                        // stop reading as live content.
                        color: popRow.pulledDead ? theme.textMuted : theme.textPrimary
                        font.pixelSize: 14
                        font.weight: theme.weightMedium
                        elide: Text.ElideRight
                        width: Math.min(implicitWidth, parent.parent.width - (row.explicit ? 22 : 0))
                    }
                    Rectangle {
                        visible: row.explicit
                        width: 16
                        height: 16
                        radius: 3
                        anchors.verticalCenter: parent.verticalCenter
                        color: theme.surfaceElevated
                        Text {
                            anchors.centerIn: parent
                            text: "E"
                            color: theme.textMuted
                            font.pixelSize: 9
                            font.weight: theme.weightSemibold
                        }
                    }
                }
                Text {
                    width: parent.width
                    visible: row.artist !== ""
                    text: row.artist
                    color: theme.textMuted
                    font.pixelSize: 13
                    elide: Text.ElideRight
                }
            }
            // Album column.
            Text {
                id: albumCell
                visible: showAlbum
                width: showAlbum ? cols.colAlbum : 0
                anchors.verticalCenter: parent.verticalCenter
                text: row.album
                color: row.albumId !== "" && albumLinkArea.containsMouse ? theme.textPrimary : theme.textMuted
                font.pixelSize: 13
                elide: Text.ElideRight
                MouseArea {
                    id: albumLinkArea
                    anchors.fill: parent
                    enabled: row.albumId !== ""
                    hoverEnabled: true
                    cursorShape: row.albumId !== "" ? Qt.PointingHandCursor : Qt.ArrowCursor
                    onClicked: QbzAlbum.openAlbum(row.albumId)
                }
            }
            Text {
                width: cols.colDuration
                anchors.verticalCenter: parent.verticalCenter
                text: row.duration
                color: theme.textMuted
                font.pixelSize: 13
                horizontalAlignment: Text.AlignHCenter
            }
            // The SAME bare badge the shared TrackRow's quality cell mounts
            // (rows/TrackRow.qml:1048): tier label stacked over the exact
            // "24-bit / 96 kHz" line. This fork used to render a lone tier
            // word ("HI-RES") even though the document has carried
            // qualityDetail all along.
            Item {
                width: cols.colQuality
                height: parent.height
                QualityBadgeFull {
                    anchors.centerIn: parent
                    tier: row.qualityTier || ""
                    detail: row.qualityDetail || ""
                    showIcon: false
                    bare: true
                    maxTextWidth: cols.colQuality
                }
            }
            // Favorite (live). Reads through the override map so the state
            // survives a document republish (see root.localToggles).
            Rectangle {
                property bool favorite: root.toggleState("track:" + row.id, row.isFavorite)
                width: cols.colFavorite
                height: cols.colFavorite
                radius: theme.radiusSm
                anchors.verticalCenter: parent.verticalCenter
                color: favArea.containsMouse ? theme.surfaceElevated : "transparent"
                QbzIcon {
                    // The SLOT stays and only the glyph goes: this fork lays
                    // out from the same TrackCols object the shared row and its
                    // header use, so collapsing the cell would shift every
                    // column left of it.
                    visible: !popRow.pulledDead
                    anchors.centerIn: parent
                    name: parent.favorite ? "heart-filled" : "heart"
                    width: 16
                    height: 16
                    tintName: parent.favorite
                        ? "favorite"
                        : (favArea.containsMouse ? root.tintOnSurface : "muted")
                }
                MouseArea {
                    id: favArea
                    anchors.fill: parent
                    enabled: !popRow.selectMode && !popRow.pulledDead
                    hoverEnabled: true
                    cursorShape: Qt.PointingHandCursor
                    onClicked: {
                        root.setToggleState("track:" + row.id, !parent.favorite)
                        QbzLibrary.libraryToggleFavorite("track", row.id)
                    }
                }
            }
            // Offline download — live since the offline port (the fork used
            // to carry an inert stub). Same status vocabulary as the shared
            // TrackRow: 0 none · 1 queued · 2 downloading · 3 ready · 4 failed.
            Rectangle {
                width: cols.colDownload
                height: cols.colDownload
                anchors.verticalCenter: parent.verticalCenter
                color: "transparent"
                QbzIcon {
                    // A pulled track has no file url to fetch, so the download
                    // affordance could only fail — the slot keeps its width,
                    // the glyph goes.
                    visible: popRow.cacheStatus === 0 && !popRow.pulledDead
                    anchors.centerIn: parent
                    name: "cloud-download"
                    width: 16
                    height: 16
                    tintName: popDlArea.containsMouse ? root.tintOnSurface : "muted"
                }
                QbzSpinner {
                    visible: popRow.cacheStatus === 1 || popRow.cacheStatus === 2
                    anchors.centerIn: parent
                    size: 16
                }
                QbzIcon {
                    visible: popRow.cacheStatus === 3
                    anchors.centerIn: parent
                    name: "circle-check-big"
                    width: 16
                    height: 16
                    tintName: "accent"
                }
                QbzIcon {
                    // Never alongside the pulled-track alert in the number
                    // cell: one row, one alert.
                    visible: popRow.cacheStatus === 4 && !popRow.pulledDead
                    anchors.centerIn: parent
                    name: "triangle-alert"
                    width: 16
                    height: 16
                    tintName: "favorite"
                }
                MouseArea {
                    id: popDlArea
                    anchors.fill: parent
                    enabled: !popRow.selectMode && !popRow.pulledDead
                    hoverEnabled: true
                    cursorShape: Qt.PointingHandCursor
                    onClicked: {
                        if (popRow.cacheStatus === 3) QbzPlayer.uncacheTrack(row.id)
                        else QbzPlayer.cacheTrack(row.id)
                    }
                }
            }
            // ⋯ row menu. It used to be a hover-lit button with NO handler at
            // all — a control that renders and no-ops, which is the defect
            // class this round is closing.
            Rectangle {
                width: cols.colMenu
                height: cols.colMenu
                radius: theme.radiusSm
                anchors.verticalCenter: parent.verticalCenter
                color: moreArea.containsMouse ? theme.surfaceElevated : "transparent"
                QbzIcon { anchors.centerIn: parent; name: "ellipsis"; width: 16; height: 16; tintName: moreArea.containsMouse ? root.tintOnSurface : "muted" }
                MouseArea {
                    id: moreArea
                    anchors.fill: parent
                    enabled: !popRow.selectMode
                    hoverEnabled: true
                    cursorShape: Qt.PointingHandCursor
                    onClicked: function (mouse) { popMenu.openAtCursor(moreArea, mouse.x, mouse.y) }
                }
            }
        }

        // primitives/TrackContextMenu.slint, in ITS order, restricted to the
        // entries whose seam is live at this call site.
        //
        // REUSE, and why it is not `rows/TrackRow.qml`: PopularTrackRow is a
        // pre-existing, documented fork (see the component header) and the
        // fork is load-bearing here — its heart reads the VIEW-level
        // optimistic store (`root.toggleState("track:" + id, …)`, shared with
        // the header and the library tab) while TrackRow owns a private
        // `favorite` property, and its play route is the artist-context
        // `playArtistTrack`. Swapping the component is a view rewrite, not a
        // menu fix. What IS reused is the menu surface itself:
        // `controls/CardMenu.qml`, the same primitive rows/TrackRow.qml opens.
        //
        // ABSENT, not dead (the same discipline TrackRow applies): the radio
        // pair and Share Qobuz link / Song.link, which need bridge seams that
        // do not exist. Track info IS wired (2026-09-13) through ONE lazy
        // TrackInfoModal per artist view (`artistTrackInfo` below), not one
        // per row — the per-row Loader rows/TrackRow.qml carries is what this
        // comment used to refuse to duplicate.
        CardMenu {
            id: popMenu
            menuWidth: 224
            entries: {
                var t = QbzSession.tr
                var r = QbzSession.trRev
                var fav = root.toggleState("track:" + popRow.row.id, popRow.row.isFavorite)
                var m = []
                // A DEAD row gets no transport and no favourite entries: D5
                // keeps an unavailable track out of the queue at the seam, so
                // "Play next" here would render and no-op — the
                // rendered-and-inert defect this menu's own header refuses
                // ("ABSENT, not dead"). The row keeps its menu because the
                // rest of it (go-to) still works and because a right-clickable
                // dead row is what §5.2 asks for.
                if (!popRow.pulledDead) {
                    m.push({ "label": t("Play now", r), "icon": "play-fill", "action": "play" })
                    m.push({ "label": t("Play next", r), "icon": "list-start", "action": "next" })
                    m.push({ "label": t("Play later", r), "icon": "list-plus", "action": "later" })
                    m.push({ "label": t("Add to queue", r), "icon": "list-end", "action": "queue" })
                    m.push({ "label": fav ? t("Remove from Library", r) : t("Add to Library", r),
                             "icon": fav ? "heart-filled" : "heart", "action": "favorite" })
                }
                // A pulled track is refused BOTH containers, and on `pulled`
                // rather than `pulledDead`: a downloaded copy plays for this
                // user on this machine, but what a playlist or a mixtape stores
                // is the Qobuz catalog id, which resolves to nothing everywhere
                // else. Seeding a dead row into a collection is the one thing
                // worth refusing outright.
                if (!popRow.pulled) {
                    m.push({ "label": t("Add to mixtape", r), "icon": "cassette-tape", "action": "mixtape" })
                    m.push({ "label": t("Add to playlist", r), "icon": "list-music", "action": "add-to-playlist" })
                }
                // The offline block goes with the transport, and for the same
                // reason: a pulled track has no stream url left, so the
                // download arm would fail and a REFRESH would destroy the only
                // copy the user still has.
                if (!popRow.pulledDead) {
                    if (popRow.cacheStatus === 3) {
                        // `popRow.pulled` and NOT `pulledDead` here: this arm
                        // IS the cached-but-pulled row (pulled + cacheStatus 3
                        // is exactly what `pulledDead` excludes). A refresh on
                        // it would re-fetch a url that no longer exists and end
                        // with the copy gone — the one copy still playing.
                        // Remove stays: the disk space is the user's call.
                        if (!popRow.pulled)
                            m.push({ "label": t("Refresh offline copy", r), "icon": "refresh-cw", "action": "recache" })
                        m.push({ "label": t("Remove offline copy", r), "icon": "trash-2", "action": "uncache", "danger": true })
                    } else {
                        m.push({ "label": t("Make available offline", r), "icon": "cloud-download", "action": "cache" })
                    }
                }
                if ((popRow.row.albumId || "") !== "")
                    m.push({ "label": t("Go to album", r), "icon": "disc-3", "action": "go-album" })
                if ((popRow.row.artistId || "") !== "")
                    m.push({ "label": t("Go to artist", r), "icon": "user", "action": "go-artist" })
                if (!popRow.pulled)
                    m.push({ "label": t("Track info", r), "icon": "info", "action": "track-info" })
                if (!popRow.pulledDead)
                    m.push({ "label": t("Buy on Qobuz", r), "icon": "shopping-bag", "action": "buy" })
                m.push({ "label": t("Copy", r), "icon": "copy", "action": "copy", "submenu": [
                    { "label": t("Track name", r), "icon": "copy", "action": "copy-title" },
                    { "label": t("Track - Album - Artist", r), "icon": "clipboard", "action": "copy-full" }
                ] })
                return m
            }
            onPicked: function (a) {
                var id = popRow.row.id
                if (a === "play") popRow.play()
                else if (a === "next") QbzPlayer.enqueueTrack(id, "next")
                else if (a === "later") QbzPlayer.enqueueTrack(id, "later")
                else if (a === "queue") QbzPlayer.enqueueTrack(id, "queue")
                else if (a === "favorite") {
                    root.setToggleState("track:" + id,
                        !root.toggleState("track:" + id, popRow.row.isFavorite))
                    QbzLibrary.libraryToggleFavorite("track", id)
                }
                else if (a === "add-to-playlist") QbzPlaylistPicker.openForTrack(id)
                else if (a === "mixtape") {
                    // The HOST builds the AddItem payload. SOURCE: every row
                    // this component draws is a Qobuz catalog track — the
                    // `/artist/page` `top_tracks` / `appears_on` lists, and
                    // the in-library tab's rows, which artist_qt maps from
                    // Qobuz `Track` values. There is no local artist page.
                    QbzMyQbzAdd.open(JSON.stringify([{
                        "itemType": "track", "source": "qobuz",
                        "sourceItemId": id, "title": popRow.row.title || "",
                        "subtitle": popRow.row.artist || "", "artworkUrl": popRow.row.artUrl || "",
                        "year": null, "trackCount": null
                    }]))
                }
                else if (a === "cache") QbzPlayer.cacheTrack(id)
                else if (a === "uncache") QbzPlayer.uncacheTrack(id)
                else if (a === "recache") QbzPlayer.recacheTrack(id)
                else if (a === "go-album") QbzAlbum.openAlbumFrom(popRow.row.albumId, popRow.row.album || "", popRow.row.artist || "")
                else if (a === "go-artist") QbzArtist.openArtist(popRow.row.artistId)
                else if (a === "track-info") root.openTrackInfo(id)
                else if (a === "buy") QbzAlbum.buyTrack(id)
                else if (a === "copy-title" || a === "copy-full") {
                    var parts = [popRow.row.title || ""]
                    if (a === "copy-full") {
                        if ((popRow.row.album || "") !== "") parts.push(popRow.row.album)
                        if ((popRow.row.artist || "") !== "") parts.push(popRow.row.artist)
                    }
                    artistClipboard.copy(parts.join(" - "))
                }
            }
        }

        MouseArea {
            id: trArea
            anchors.fill: parent
            hoverEnabled: true
            propagateComposedEvents: true
            // The dead row is inert on double-click too (D4): no request, no
            // toast, no error. The right-press area below is untouched, so the
            // menu still opens.
            onDoubleClicked: if (!popRow.selectMode && !popRow.pulledDead)
                popRow.play()
            onClicked: {
                if (popRow.selectMode) popRow.toggleSelect(mouse.modifiers)
                else mouse.accepted = false
            }
        }
        // Right press opens the SAME menu at the pointer — the invariant
        // controls/QbzContextMenu.qml:20-22 states. Declared last so it sits
        // on top, RIGHT-only so every left click still falls through.
        MouseArea {
            id: popRcArea
            anchors.fill: parent
            acceptedButtons: Qt.RightButton
            onClicked: function (mouse) { popMenu.openAtCursor(popRcArea, mouse.x, mouse.y) }
        }
    }

    // Sidebar link row (SidebarLink). `navigable` false = informational row:
    // no pointer cursor, no hover promise it cannot keep (used by the MB
    // Relationships rows, which have no destination in this port).
    component SidebarLink: Rectangle {
        property string label: ""
        property string iconName: "user"
        property string tooltip: ""
        property bool navigable: true
        signal clicked()
        width: parent ? parent.width : 0
        height: 28
        radius: 4
        color: slArea.containsMouse ? theme.surfaceElevated : "transparent"
        Row {
            anchors.fill: parent
            anchors.leftMargin: 8
            anchors.rightMargin: 8
            spacing: 8
            QbzIcon {
                name: iconName
                width: 12
                height: 12
                anchors.verticalCenter: parent.verticalCenter
                tintName: slArea.containsMouse ? root.tintOnSurface : "muted"
            }
            Text {
                width: parent.width - 20
                anchors.verticalCenter: parent.verticalCenter
                text: label
                color: slArea.containsMouse ? theme.textPrimary : theme.textSecondary
                font.pixelSize: 13
                elide: Text.ElideRight
            }
        }
        MouseArea {
            id: slArea
            anchors.fill: parent
            hoverEnabled: true
            cursorShape: navigable ? Qt.PointingHandCursor : Qt.ArrowCursor
            onClicked: if (navigable) parent.clicked()
            ToolTip.visible: containsMouse && tooltip !== ""
            ToolTip.text: tooltip
            ToolTip.delay: 400
        }
    }

    // Sidebar section heading (11px muted caps, letter-spaced).
    component SidebarSectionHeading: Text {
        color: theme.textMuted
        font.pixelSize: 11
        font.weight: theme.weightSemibold
        font.letterSpacing: 0.5
    }

    // Small 11px muted line — sub-group labels and the empty states inside
    // the sidebar sections. (The "Loading…" lines are now SidebarSkeleton.)
    component SidebarNote: Text {
        color: theme.textMuted
        font.pixelSize: 12
    }

    // Placeholder rows for a sidebar section still in flight — the shared
    // QbzSkeleton at the 28px pitch of SidebarLink, so the section holds its
    // band and nothing jumps when the real links land.
    //
    // `phase` is a property, not a file-scope id lookup: an inline `component`
    // does not see the enclosing document's ids (QbzSkeleton.qml's gotcha), so
    // the host passes the one shared timer in.
    component SidebarSkeleton: Column {
        id: sbSk
        property bool phase: false
        property int rows: 3
        // -28 = the section Column's left+right padding (see OriginRow).
        width: parent ? parent.width - 28 : 0
        spacing: 9
        Repeater {
            model: sbSk.rows
            delegate: QbzSkeleton {
                required property int index
                variant: "block"
                width: sbSk.width * (index % 2 === 0 ? 0.86 : 0.6)
                height: 13
                cellIndex: index
                phase: sbSk.phase
            }
        }
    }

    // One "KEY   value" row of the MB Origin block.
    component OriginRow: Item {
        id: originRow
        property string key: ""
        property string value: ""
        /// When true the value renders as a link and emits `activated`.
        /// Only the location row ever sets it (door D1 to the Artist Scene);
        /// born/founded/died/disbanded stay plain text, as in the reference.
        property bool clickable: false
        signal activated()
        // The host section Column carries 14px of left+right padding, and a
        // QML Positioner does NOT shrink its children for it — a right-aligned
        // value bound to the bare parent.width would run past the sidebar
        // edge. Subtract it here (this row only ever lives in that section).
        width: parent ? parent.width - 28 : 0
        height: 20
        Text {
            id: originKey
            anchors.left: parent.left
            anchors.verticalCenter: parent.verticalCenter
            text: key
            color: theme.textMuted
            font.pixelSize: 11
            font.weight: theme.weightSemibold
            font.letterSpacing: 0.5
        }
        Text {
            id: originValue
            anchors.right: parent.right
            anchors.left: originKey.right
            anchors.leftMargin: 8
            anchors.verticalCenter: parent.verticalCenter
            text: value
            // The reference's `.origin-location-link` is
            // `background:none; border:none; padding:0; font-size:13px;
            // color:var(--accent-primary)` with `text-decoration:underline;
            // text-underline-offset:2px` on hover
            // (ArtistDetailView.svelte:3365-3379). Same 13px as the plain
            // rows, so only the colour and the underline change.
            color: originRow.clickable ? theme.accent : theme.textPrimary
            font.pixelSize: 13
            font.underline: originRow.clickable && originLink.containsMouse
            horizontalAlignment: Text.AlignRight
            elide: Text.ElideRight
        }
        MouseArea {
            id: originLink
            // Only the text, not the whole row — the key ("BORN IN") is not
            // part of the link in the reference either.
            anchors.right: parent.right
            anchors.top: parent.top
            anchors.bottom: parent.bottom
            width: Math.min(originValue.implicitWidth, originValue.width)
            enabled: originRow.clickable
            visible: originRow.clickable
            hoverEnabled: true
            cursorShape: Qt.PointingHandCursor
            onClicked: originRow.activated()
        }
    }

    // One MB relationship sub-group (Members & Former / Member Of /
    // Collaborators) with a preview cap + expander.
    component RelationshipGroup: Column {
        id: relGroup
        property string title: ""
        property var rows: []
        property string iconName: "user"
        /// The MusicBrainz role this group represents ("member", "producer",
        /// …) — passed to the resolver so a same-name match in another role is
        /// not treated as this musician.
        property string roleKey: ""
        property bool expanded: false
        signal toggled()
        visible: rows.length > 0
        // -28 = the host section Column's left+right padding (see OriginRow).
        width: parent ? parent.width - 28 : 0
        spacing: 2
        topPadding: 2
        SidebarNote {
            text: relGroup.title
            font.pixelSize: 11
        }
        Repeater {
            model: relGroup.rows.length > root.sidebarPreview && !relGroup.expanded
                   ? relGroup.rows.slice(0, root.sidebarPreview)
                   : relGroup.rows
            delegate: SidebarLink {
                required property var modelData
                label: modelData.name
                tooltip: modelData.tooltip
                iconName: relGroup.iconName
                // Relationship rows carry a NAME, not a catalog id, so the
                // click resolves through MusicBrainz first. Only a confirmed
                // match navigates (resolve_musician logs and stays put
                // otherwise) — landing the user on a same-name artist is worse
                // than the row doing nothing.
                navigable: true
                // `modelData.role`, NOT `relGroup.roleKey`. Rust already built
                // the right string per ROW: `group_relations` seeds each group
                // with the reference's own default ("Band Member" / "Band" /
                // "Collaborator") and then prefers that person's actual first
                // credited role (artist_qt.rs `map_relationships`), which is
                // exactly what the reference sends
                // (ArtistDetailView.svelte:3015,3033,3046). Sending `roleKey`
                // instead threw all of that away and shipped a per-GROUP
                // lowercase MusicBrainz key shared by every row — and for the
                // middle group it is not even a casing difference, it sent
                // "member of" where the reference sends "Band". The role is
                // echoed back on every appearance card, so it was visible.
                onClicked: QbzArtist.resolveMusician(modelData.name,
                                                     modelData.role || relGroup.roleKey || "")
            }
        }
        Text {
            visible: relGroup.rows.length > root.sidebarPreview
            leftPadding: 8
            // Same msgid pair the page's other expanders use — no new
            // catalog entries (all 8 locales already carry these).
            text: relGroup.expanded
                  ? QbzSession.tr("View less", QbzSession.trRev)
                  : QbzSession.tr("Load more", QbzSession.trRev)
            color: relMoreArea.containsMouse ? theme.textPrimary : theme.textSecondary
            font.pixelSize: 12
            MouseArea {
                id: relMoreArea
                anchors.fill: parent
                hoverEnabled: true
                cursorShape: Qt.PointingHandCursor
                onClicked: relGroup.toggled()
            }
        }
    }

    // Release section (ReleaseGrid).
    component ReleaseSection: Column {
        // Named because the card delegate below reaches for `section` from a
        // nested scope, and an inline component's own root id is the one
        // handle that is unambiguous there.
        id: relSection
        property var section: ({})
        property string anchorId: ""
        width: parent ? parent.width : 0
        spacing: 12

        Row {
            width: parent.width
            spacing: 12
            Text {
                width: parent.width - seeAll.width - sortBtn.width - playBtn.width - 36
                anchors.verticalCenter: parent.verticalCenter
                text: section.title
                color: theme.textPrimary
                font.pixelSize: theme.fontHeading
                font.weight: theme.weightSemibold
                elide: Text.ElideRight
            }
            Text {
                id: seeAll
                anchors.verticalCenter: parent.verticalCenter
                height: 28
                text: QbzSession.tr("See discography", QbzSession.trRev)
                color: seeAllArea.containsMouse ? theme.textPrimary : theme.textSecondary
                font.pixelSize: 13
                verticalAlignment: Text.AlignVCenter
                MouseArea {
                    id: seeAllArea
                    anchors.fill: parent
                    hoverEnabled: true
                    cursorShape: Qt.PointingHandCursor
                    // ReleaseGrid.slint:63-68 -> ArtistPageView.slint:928-929
                    // -> ArtistActions.open-releases -> main.rs:15055-15087,
                    // which records the nav entry and mounts
                    // ArtistReleasesView on this bucket.
                    //
                    // The artist NAME travels with the call: the second door to
                    // the same page (AlbumView's "From the same artist" View
                    // all) has no artist document open and supplies its own,
                    // exactly as main.rs:11844 does.
                    //
                    // `relSection.section`, not a bare `section` — the inline
                    // component's own root id is the one unambiguous handle
                    // from a nested scope, which is why `relSection` is named
                    // at all (:1409-1411). `root.` is the same pattern the card
                    // delegate below already uses for `coverMap` and
                    // `releaseFadeFrom`.
                    //
                    // (What stood here was an empty MouseArea under a POC-NOTE
                    // reading "dedicated discography page out of scope" — a
                    // fully lit, pointer-cursor control whose entire effect was
                    // nothing. The page now exists; the note is gone with it.)
                    onClicked: QbzArtist.openReleases(root.artist.id || "",
                        root.artist.name || "",
                        relSection.section.releaseType || "")
                }
            }
            // Per-section sort — ReleaseGrid.slint:70-90, the SAME control the
            // reference mounts (primitives/QbzSelect.slint), here through the
            // port's existing replica controls/QbzSelect.qml.
            //
            // `sm: true` + `menuWidth: 150` are the .slint's own values,
            // verbatim: QbzSelect.qml:34 is `width = menuWidth - 40` under
            // `sm`, so 150 lands at the 110 x 30 the reference computes at
            // QbzSelect.slint:88. Passing 190 "to get 150" is the exact mistake
            // that file's :42-50 note documents.
            //
            // `id: sortBtn` is load-bearing beyond this block — the section
            // title above measures `parent.width - seeAll.width - sortBtn.width
            // - 24`. The control grows 28 -> 30 tall with the swap; that IS the
            // reference (QbzSelect.slint `sm` is 30px). Row children are
            // top-aligned, hence the explicit verticalCenter.
            //
            // (What stood here was a dimmed Rectangle with no MouseArea, whose
            // note claimed `set-section-sort` "re-sorts server-side" and that
            // no seam existed. Both halves were wrong: main.rs:14997-15007 sorts
            // the ALREADY-LOADED cards in process and never touches the API —
            // see artist_qt::resort_section — and the label lied twice on top of
            // that, reading "Newest" over data in server order.)
            QbzSelect {
                id: sortBtn
                anchors.verticalCenter: parent.verticalCenter
                sm: true
                menuWidth: 150
                // The .slint's five options in its order (:74-79). "A–Z"/"Z–A"
                // carry a U+2013 EN DASH — the msgid in the catalogue is the
                // en-dash form, and a hyphen would silently go untranslated in
                // all seven non-English locales. (LibraryToolbar's "Title A-Z"
                // is a DIFFERENT, hyphenated msgid — do not copy it here.)
                options: [QbzSession.tr("Default", QbzSession.trRev),
                          QbzSession.tr("Newest", QbzSession.trRev),
                          QbzSession.tr("Oldest", QbzSession.trRev),
                          QbzSession.tr("A–Z", QbzSession.trRev),
                          QbzSession.tr("Z–A", QbzSession.trRev),
                          QbzSession.tr("Popularity", QbzSession.trRev)]
                // ReleaseGrid.slint:34-39 — the wire key back to an index. This
                // is what makes the picker come back showing the sort the user
                // actually chose: `sortBy` is stamped on the section by
                // artist_qt.rs at page build from the persisted pref, so a
                // revisited artist seats the control without a click.
                //
                // A BINDING, never an assignment: QbzSelect does not
                // self-assign `currentIndex` (it closes the popup and emits,
                // QbzSelect.qml:299-300), and every enrichment republish
                // re-creates this delegate — an assignment would be lost.
                currentIndex: {
                    var s = relSection.section.sortBy || "default"
                    return s === "newest" ? 1 : s === "oldest" ? 2
                         : s === "title-asc" ? 3 : s === "title-desc" ? 4 : s === "relevant" ? 5 : 0
                }
                // ReleaseGrid.slint:81-89 — index to wire key. These five
                // strings are BOTH what gets persisted and what the sort
                // functions switch on, on either side of the bridge.
                //
                // `relSection.section`, not a bare `section`: this header lives
                // inside an inline `component`, which does not see the enclosing
                // document's ids — `relSection` exists for exactly this.
                onSelected: function (i) {
                    root.releaseSortChanged(relSection.section.releaseType,
                        i === 1 ? "newest" : i === 2 ? "oldest"
                        : i === 3 ? "title-asc" : i === 4 ? "title-desc" : i === 5 ? "relevant" : "default")
                }
            }
            // Play all / Play random / Play selected over THIS bucket, in
            // its sort order (`section.cards` is already sorted — Rust sorts
            // the bucket and the overlay merge re-sorts).
            QbzSplitButton {
                id: playBtn
                anchors.verticalCenter: parent.verticalCenter
                label: root.albumSectionLabel(relSection.section.releaseType || "")
                menuItems: root.albumSectionMenu(relSection.section.releaseType || "")
                onClicked: root.albumSectionPrimary(relSection.section.releaseType || "",
                                                    relSection.section.cards || [])
                onPicked: function (a) {
                    root.albumSectionAction(relSection.section.releaseType || "",
                                            relSection.section.cards || [], a)
                }
            }
        }

        Grid {
            width: parent.width
            columns: Math.max(1, Math.floor((width + 24) / 224))
            columnSpacing: 24
            rowSpacing: 24
            Repeater {
                model: section.cards
                delegate: AlbumCard {
                    id: relCard
                    albumId: modelData.id
                    title: modelData.title
                    // The subtitle slot carries the YEAR on the artist page,
                    // not the artist: artist.rs `card_to_item` (:670-688)
                    // re-routes `year` through the card's `artist` field
                    // precisely so the shared card primitive stays unchanged
                    // ("the artist is redundant since we're already on their
                    // page"), and blanks artist_id so the line is inert.
                    artist: modelData.year
                    artistId: ""
                    genre: modelData.genre
                    year: modelData.year
                    qualityTier: modelData.qualityTier
                    qualityDetail: modelData.qualityDetail || ""
                    artSource: root.coverMap[modelData.artUrl] || ""
                    // artist_qt `map_release` stamps the pin state on every
                    // release row; SectionRail is the only other reader and
                    // this page never mounts it, so the flag was published
                    // and dropped on the floor — the glyph lied on all four
                    // of this page's album grids. `artUrl` is the REMOTE url
                    // (coverMap is keyed BY it), which is what the pin
                    // payload must store.
                    isPinned: modelData.isPinned === true
                    artworkUrl: modelData.artUrl || ""
                    // artist_qt::map_release stamps this the same way it
                    // stamps the pin; false inverted the first click.
                    isFavorite: modelData.isFavorite === true
                    // "Play selected" over this bucket (the split button).
                    selectMode: root.albumSelectKey === (relSection.section.releaseType || "")
                    selected: root.albumSelected[modelData.id] === true
                    selectMarkBottom: true
                    onSelectToggled: function (mods) {
                        root.albumSelectToggle(modelData.id, relSection.section.cards || [], mods)
                    }

                    // ---- smooth append (owner, 2026-08-02) ---------------
                    // "que la aparicion de lo que se cargue, sea smooth" —
                    // fade in ONLY the page Load more just brought in. The
                    // Repeater re-creates EVERY delegate on any republish (see
                    // `releasePending` at the top of this file), so an
                    // unconditional fade would re-dissolve the whole grid on
                    // an unrelated pass and read as a flicker.
                    //
                    // `opacity` carries NO binding on purpose: the assignment
                    // below would destroy one, and a Behavior would then fire
                    // for every card (Behaviors are inert only DURING
                    // creation, and Component.onCompleted runs after it). A
                    // card below the threshold is never touched at all, so it
                    // is created — and stays — fully opaque.
                    NumberAnimation {
                        id: appendFade
                        target: relCard
                        property: "opacity"
                        from: 0.0
                        to: 1.0
                        // 220ms / OutCubic is the content duration; the
                        // skeleton above it fades at 180ms.
                        duration: 220
                        easing.type: Easing.OutCubic
                    }
                    Component.onCompleted: {
                        if (index >= root.releaseFadeFrom(relSection.section.releaseType)) {
                            relCard.opacity = 0.0
                            appendFade.start()
                        }
                    }
                }
            }
        }

        // The shared affordance (controls/QbzLoadMore.qml) — this site is the
        // `a` arm its header cites: plain centred text, 28 tall, and the same
        // `section.hasMore` gate and bridge call as before. What is new is the
        // placeholder row it draws underneath while the page is in flight.
        QbzLoadMore {
            visible: section.hasMore || section.sortLoading === true
            width: parent.width
            // The grid above has a 224 x 270 PITCH: cards/AlbumCard.qml:186-189
            // is 200 x 246 and the Grid adds 24px of column/row spacing — the
            // same pitch SearchView's block was built around, so the
            // placeholder lands exactly where the first appended row will.
            skeleton: "cards"
            cellW: 224
            cellH: 270
            // There is NO per-section loading flag to bind to: the bridge
            // publishes one artist document plus the `releaseSectionReady`
            // signal (artist_bridge.rs:60-66) and nothing in between. So the
            // in-flight state is driven locally, off root's map, cleared by
            // that signal and capped by root's 8s settle timer (the error path
            // emits nothing at all — main.rs:872).
            busy: section.sortLoading === true || root.releasePending[section.releaseType] === true
            onClicked: {
                // BEFORE the call: the threshold is the count on screen now
                // (`section.cards` is the MERGED array — document page 1 plus
                // every page the overlay holds — so the fade threshold lines
                // up with the tail this request will add).
                //
                // The OFFSET is not that count: releaseMoreRequested returns
                // the server cursor (see `releaseCursor`), which is the number
                // of rows the server has actually sent. They differ as soon as
                // a page repeats a row, and passing the on-screen count then
                // re-requests rows we already have — the dedup swallows them
                // and the button appears to do nothing, forever.
                //
                // The third argument suppresses the append fade when this
                // bucket carries a non-default sort: the page will be
                // INTERLEAVED, not appended, so an index threshold would fade
                // the wrong cards (see releaseMoreRequested).
                var off = root.releaseMoreRequested(section.releaseType, section.cards.length,
                                                    (section.sortBy || "default") !== "default")
                QbzArtist.loadReleaseSection(artist.id, section.releaseType, off)
            }
        }
    }

    // ============================ the page ================================
    // FULL WIDTH even with the sidebar open. The .slint reserves the 300px
    // inside the BODY ROW only (ArtistPageView.slint:1094) — the header and
    // the JUMP TO bar span the whole window so the gradient covers edge to
    // edge (:184-191). Narrowing the whole Flickable (the port's old
    // `anchors.rightMargin`) squeezed the portrait and the bio too.
    Flickable {
        id: flick
        anchors.fill: parent
        clip: true
        contentWidth: width
        contentHeight: page.implicitHeight
        boundsBehavior: Flickable.StopAtBounds

        // Artwork-tinted header band — the SAME shared component AlbumView
        // mounts. First child = painted under the page; inside the Flickable
        // = scrolls with it (ArtistPageView.slint:213); full-bleed.
        HeaderGradient {
            x: 0
            y: 0
            width: flick.width
            // .slint:147 `atmo-height: page.y + body-row.y` — the band ends
            // exactly where the body begins, i.e. at the JUMP TO strip, so a
            // long bio pushes the fade down with no manual tuning.
            // `jumpSlot`, not `jumpBar`: the bar is a pinned overlay now and
            // its y is the CLAMPED viewport position, which would freeze this
            // band's height the moment the bar stuck.
            height: page.y + jumpSlot.y
            tint: artist.headerColor || ""
            // Route A: the blurred field. Empty until the cover resolves, and the
            // flat tint stands in meanwhile (HeaderGradient handles the swap).
            atmosphere: artist.headerAtmosphere || ""
            active: root.headerAtmoOn
        }

        Column {
            id: page
            width: parent.width
            leftPadding: 32
            rightPadding: 32
            topPadding: 11
            bottomPadding: 100
            spacing: 0

            // Width available to the BODY sections: the page width less the
            // 32+32 padding, less the sidebar reservation while it is open
            // (.slint's empty 300px slot in the body row). The header and the
            // jump strip deliberately do NOT subtract it.
            readonly property real bodyWidth: width - 64 - (root.networkOpen ? 300 : 0)

            Item { width: 1; height: 22 }

            // --- Artist header skeleton ----------------------------------
            // Mounted on the primary flag, and the real header is hidden by
            // the same flag: opening artist B never renders a half-empty
            // header frame while B's document is in flight.
            Row {
                visible: root.primaryLoading
                width: parent.width - 64
                spacing: 32

                QbzSkeleton { variant: "circle"; width: 200; height: 200; phase: skeletonPhase.on }
                Column {
                    width: parent.width - 200 - 32
                    spacing: 12
                    Item { width: 1; height: 10 }
                    QbzSkeleton { variant: "block"; width: Math.min(360, parent.width); height: 30; cellIndex: 0; phase: skeletonPhase.on }
                    QbzSkeleton { variant: "block"; width: Math.min(520, parent.width); height: 14; cellIndex: 1; phase: skeletonPhase.on }
                    QbzSkeleton { variant: "block"; width: Math.min(440, parent.width); height: 14; cellIndex: 2; phase: skeletonPhase.on }
                    Item { width: 1; height: 14 }
                    Row {
                        spacing: 12
                        Repeater {
                            model: 4
                            delegate: QbzSkeleton {
                                required property int index
                                variant: "circle"
                                width: 44
                                height: 44
                                cellIndex: index
                                phase: skeletonPhase.on
                            }
                        }
                    }
                }
            }

            // --- Artist header ------------------------------------------
            Row {
                visible: !root.primaryLoading
                width: parent.width - 64
                spacing: 32

                // Circular portrait. The circle comes from RoundedImage's
                // MASK, not from a clip: QML's `clip` is rectangular and does
                // NOT follow a Rectangle's radius — theme/RoundedImage.qml:3-6
                // says so and proved it with an isolated scene on this Qt
                // build, and :508 measures this exact radius-100-on-200px
                // case. The `clip: true` that used to sit here (with a comment
                // claiming the opposite) therefore rounded nothing, cost an
                // unconditional batch root, and would have swallowed anything
                // mounted inside the frame — which is why the menu and the
                // lightbox are view-root siblings, exactly as
                // AlbumView.qml:586-588 keeps them.
                Rectangle {
                    width: 200
                    height: 200
                    radius: 100
                    color: theme.surfaceElevated
                    RoundedImage {
                        anchors.fill: parent
                        // A custom portrait (the SHARED custom_artwork store,
                        // keyed by artist NAME) beats the url-keyed pipeline
                        // image — the album header's rule on the artist axis.
                        source: (artist.customImageUrl || "") !== ""
                            ? artist.customImageUrl
                            : (root.coverMap[artist.artUrl] || "")
                        radius: 100
                    }
                    // Left-click: the lightbox (NEW in this port — the
                    // reference lets left clicks pass through,
                    // ArtistPageView.slint:290-293). Right-click: the portrait
                    // menu the reference DOES have (ArtistPageView.slint:292-353),
                    // which this port simply never paid.
                    MouseArea {
                        anchors.fill: parent
                        acceptedButtons: Qt.LeftButton | Qt.RightButton
                        cursorShape: Qt.PointingHandCursor
                        onClicked: function (mouse) {
                            if (mouse.button === Qt.RightButton)
                                portraitMenu.openAtCursor(portraitMenuAnchor, mouse.x, mouse.y)
                            else if (root.bestArtistImage() !== "")
                                portraitLightbox.openWith(root.bestArtistImage())
                        }
                    }
                    Item { id: portraitMenuAnchor; anchors.fill: parent }
                }

                Column {
                    width: parent.width - 200 - 32
                    anchors.top: parent.top
                    anchors.topMargin: 8
                    spacing: 0

                    Text {
                        width: parent.width
                        text: artist.name || ""
                        color: root.hdrStrong
                        font.pixelSize: theme.fontSection
                        font.weight: theme.weightBold
                        elide: Text.ElideRight
                    }

                    Item { visible: (artist.bio || "") !== ""; width: 1; height: 12 }
                    Text {
                        visible: (artist.bio || "") !== ""
                        width: parent.width
                        text: artist.bioShort || ""
                        color: root.hdrBody
                        font.pixelSize: theme.fontLegal
                        wrapMode: Text.WordWrap
                    }
                    Item { visible: artist.bioTruncated === true; width: 1; height: 4 }
                    Text {
                        visible: artist.bioTruncated === true
                        text: QbzSession.tr("Read more", QbzSession.trRev)
                        color: readMoreArea.containsMouse ? theme.accentHover : theme.accent
                        font.pixelSize: theme.fontLegal
                        MouseArea {
                            id: readMoreArea
                            anchors.fill: parent
                            hoverEnabled: true
                            cursorShape: Qt.PointingHandCursor
                            onClicked: {
                                var shell = root.parent
                                while (shell && shell.openTextModal === undefined) shell = shell.parent
                                if (!shell) return
                                // The Slint modal renders the attribution
                                // ("Source: TiVo") as a small line under the
                                // body; the shared text modal has one body
                                // slot, so it rides at the end.
                                var body = artist.bio || ""
                                if ((artist.bioSource || "") !== "")
                                    body += "\n\n" + QbzSession.tr("Source", QbzSession.trRev) + ": " + artist.bioSource
                                shell.openTextModal(artist.name || "", body)
                            }
                        }
                    }

                    Item { width: 1; height: 18 }
                    // Action row — ArtistPageView.slint:413-591. Four
                    // circles (NO Play: Popular Tracks carries its own), then
                    // a stretch, then the catalog/library toggle floated
                    // right. The palette arm follows the header backdrop
                    // (`on-surface: root.hdr-on-surface`, :417).
                    Row {
                        width: parent.width
                        spacing: 12
                        QbzCircleAction {
                            readonly property bool following: root.toggleState("artist", artist.isFollowing)
                            name: following ? "heart-filled" : "heart"
                            overlay: root.hdrOverlay
                            active: following
                            anchors.verticalCenter: parent.verticalCenter
                            onClicked: {
                                root.setToggleState("artist", !following)
                                QbzLibrary.libraryToggleFavorite("artist", artist.id)
                            }
                        }
                        // Radio — ArtistPageView.slint:426-461: the disc opens
                        // a two-row dropdown, QBZ Radio (the local `qbz-radio`
                        // pool builder) vs Qobuz Radio (the curated
                        // `/radio/artist` endpoint).
                        //
                        // IT WAS `btnEnabled: false` — dimmed and inert by
                        // declaration, because at the time neither engine had a
                        // seam on a Qt bridge and the port refuses to render a
                        // control that drives nothing. Both exist now:
                        // `QbzHome.startArtistRadio` (the smart pool, already
                        // shipping behind the Discover spotlight's RADIO card)
                        // and `QbzHome.startQobuzArtistRadio`, added with this
                        // change. So the disc goes live and the dropdown is the
                        // reference's, verbatim.
                        QbzCircleAction {
                            id: radioBtn
                            name: "radio"
                            overlay: root.hdrOverlay
                            // BOTH dropdown rows arm the same key: they are
                            // two ways to fill one queue from one disc, and
                            // the disc is what the user is looking at. The
                            // control also gates its own clicks while loading,
                            // so the dropdown cannot be re-opened over a
                            // request that is already running.
                            loading: QbzHome.radioPending === "artist:" + artist.id
                            anchors.verticalCenter: parent.verticalCenter
                            onClicked: radioMenu.openBelowLeft(radioBtn)
                        }
                        QbzCircleAction {
                            name: "element-connect"
                            overlay: root.hdrOverlay
                            active: root.networkOpen
                            anchors.verticalCenter: parent.verticalCenter
                            onClicked: root.networkOpen = !root.networkOpen
                        }
                        QbzCircleAction {
                            id: overflowBtn
                            name: "ellipsis"
                            overlay: root.hdrOverlay
                            anchors.verticalCenter: parent.verticalCenter
                            onClicked: function (mouse) { overflowMenu.openAtCursor(overflowBtn, mouse.x, mouse.y) }
                        }
                        // Stretch (.slint:579 `Rectangle { horizontal-stretch: 1 }`).
                        // Clamped: at a narrow window an unclamped negative
                        // width silently reflows the whole row.
                        Item {
                            width: Math.max(0, parent.width - 4 * 32 - 4 * 12
                                               - (segTabs.visible ? segTabs.width + 12 : 0))
                            height: 1
                        }
                        // From catalog / In library — .slint:582 mounts the
                        // SHARED SegmentedTabBar; the port hand-rolled a copy
                        // of it here whose delegate walked the wrong parent
                        // chain (`parent.parent.modelData` on a Row, and the
                        // count chip read `active` off the wrong node), so the
                        // count badge never took its active colours. This is
                        // the shared control (controls/QbzTabBar.qml), which
                        // is that same SegmentedTabBar 1:1 — counts on, and
                        // the 2px accent underline the .slint's Segment draws
                        // for the active tab (:86-93).
                        QbzTabBar {
                            id: segTabs
                            visible: (artist.libraryCount || 0) > 0
                            anchors.verticalCenter: parent.verticalCenter
                            counts: true
                            underline: true
                            activeId: root.artistTab
                            tabs: [
                                { "id": "catalog", "label": QbzSession.tr("From catalog", QbzSession.trRev), "count": 0 },
                                { "id": "library", "label": QbzSession.tr("In library", QbzSession.trRev), "count": artist.libraryCount || 0 },
                            ]
                            onSelected: function (id) { root.artistTab = id }
                        }
                    }
                }
            }

            // --- Hidden-artist banner (ArtistPageView.slint:595-660) ------
            // Only when the CURRENTLY displayed artist is blacklisted. The page
            // stays fully navigable — a direct fetch-by-id is never blocked
            // (.slint:595-599) — so this is an unblock affordance, not a lock.
            // Sits between the header and the body row, exactly where the
            // .slint puts it (after the header block at :594, before the body
            // row), with the .slint's own 16px spacer (:600).
            // Built inline rather than through controls/WarningBanner.qml: that
            // control has no action slot, and this banner's whole point is the
            // right-hand "Show artist" button.
            Item { visible: root.artistBlacklisted; width: 1; height: 16 }
            Rectangle {
                id: hiddenBanner
                visible: root.artistBlacklisted
                width: parent.width - 64
                // .slint `height: banner-row.preferred-height` where the row is
                // a HorizontalLayout with padding 12 (:602) — so 24 plus the
                // tallest child: the 16px glyph, the wrapped copy, or the 28px
                // button (:604, :620, :639).
                height: visible ? 24 + Math.max(16, bannerCopy.implicitHeight, 28) : 0
                radius: 8
                // LITERALS, not theme tokens: the .slint hardcodes both
                // (:596-599). theme.warningBg / warningBorder are a different
                // amber (#fbbf24-based) and would not match the reference.
                color: "#eab3081a"
                border.width: 1
                border.color: "#eab3084d"

                // 16x16 blind-eye (:606-611). The .slint tints it with the
                // literal #eab308; QbzIcon.tintName is a CLOSED vocabulary of
                // names with no #eab308 bake, so "warning" (theme.warning
                // #fbbf24) is the nearest available and the only theme-following
                // amber — spec 03 C6's default decision.
                QbzIcon {
                    id: bannerGlyph
                    name: "blind-eye"
                    width: 16
                    height: 16
                    tintName: "warning"
                    anchors.left: parent.left
                    anchors.leftMargin: 12
                    anchors.verticalCenter: parent.verticalCenter
                }
                // "Show artist" button (:634-659): width = label + 20, height
                // 28, radius 6, hover fill surface-elevated else transparent,
                // label accent -> accentHover on hover, 13 / semibold.
                Rectangle {
                    id: bannerBtn
                    width: bannerBtnLabel.implicitWidth + 20
                    height: 28
                    radius: 6
                    color: bannerBtnArea.containsMouse ? theme.surfaceElevated : "transparent"
                    anchors.right: parent.right
                    anchors.rightMargin: 12
                    anchors.verticalCenter: parent.verticalCenter
                    Text {
                        id: bannerBtnLabel
                        anchors.centerIn: parent
                        text: QbzSession.tr("Show artist", QbzSession.trRev)
                        color: bannerBtnArea.containsMouse ? theme.accentHover : theme.accent
                        font.pixelSize: 13
                        font.weight: theme.weightSemibold
                    }
                    MouseArea {
                        id: bannerBtnArea
                        anchors.fill: parent
                        hoverEnabled: true
                        cursorShape: Qt.PointingHandCursor
                        // Same seam as the menu row (:654-657) — one toggle.
                        onClicked: root.toggleBlacklist()
                    }
                }
                // Copy (:619-627): text-secondary, Typography.legal = 13,
                // word-wrap. The 10px gaps on both sides are the .slint's
                // HorizontalLayout spacing (:603).
                Text {
                    id: bannerCopy
                    anchors.left: bannerGlyph.right
                    anchors.leftMargin: 10
                    anchors.right: bannerBtn.left
                    anchors.rightMargin: 10
                    anchors.verticalCenter: parent.verticalCenter
                    text: QbzSession.tr("This artist is hidden from discovery", QbzSession.trRev)
                    color: theme.textSecondary
                    font.pixelSize: 13
                    wrapMode: Text.WordWrap
                }
            }

            Item { width: 1; height: 20 }

            // --- JUMP TO bar ---------------------------------------------
            // The SHARED controls/QbzJumpNavBar (primitives/JumpNavBar.slint
            // 1:1). What the port drew by hand was the tab strip ONLY: no
            // "JUMP TO" caption, no bottom hairline, no search affordance,
            // 13px/medium type instead of the .slint's 15px/regular, and the
            // wrong three tab colours. padH 0 because this Column already
            // pads 32 — the .slint's own 32px padding lands the strip in the
            // same place.
            // The bar itself is an OVERLAY outside this Flickable (see
            // `jumpBar` after it) so it can pin to the top on scroll. What
            // stays in the flow is this slot, which reserves exactly its
            // height: without it the body would jump up by the bar's height
            // the moment the bar was lifted out.
            Item {
                id: jumpSlot
                width: parent.width - 64
                height: jumpBar.height
            }

            // --- Primary placeholder --------------------------------------
            // Same flag the spinner used, now in the shape of what is coming:
            // the Popular Tracks heading plus 5 rows at the PopularTrackRow
            // 50px pitch (the preview count), so nothing shifts on arrival.
            Column {
                visible: root.primaryLoading
                width: parent.width - 64
                spacing: 0

                QbzSkeleton { variant: "block"; width: 190; height: 22; phase: skeletonPhase.on }
                Item { width: 1; height: 18 }
                Repeater {
                    model: root.preview
                    delegate: Item {
                        required property int index
                        width: parent ? parent.width : 0
                        height: 50
                        QbzSkeleton {
                            anchors.verticalCenter: parent.verticalCenter
                            anchors.left: parent.left
                            anchors.right: parent.right
                            anchors.leftMargin: 12
                            anchors.rightMargin: 24
                            height: 40
                            variant: "row"
                            cellIndex: index
                            phase: skeletonPhase.on
                        }
                    }
                }
            }

            // ================= Catalog tab ================================
            Column {
                id: sectionAnchors
                visible: root.artistTab === "catalog" && !QbzArtist.artistLoading
                // Body width: yields the 300px the sidebar overlay occupies
                // (.slint's empty reservation slot, :1094) so the content is
                // never painted under the panel.
                width: page.bodyWidth
                spacing: 0

                // --- Popular Tracks -------------------------------------
                // Multi-select bulk bar — INLINE above the Popular Tracks
                // header (the Local Library album view's layout: bar in flow,
                // content below), covering this page's Qobuz track lists.
                QbzMultiSelectBar {
                    visible: root.multiSelect
                    width: parent.width
                    selectedCount: root.selectedCount
                    actions: [
                        { "id": "select-all", "label": QbzSession.tr("Select all", QbzSession.trRev), "icon": "square-check-big", "danger": false, "needsSelection": false },
                        { "id": "play-next", "label": QbzSession.tr("Play next", QbzSession.trRev), "icon": "list-start", "danger": false, "needsSelection": true },
                        { "id": "play-later", "label": QbzSession.tr("Play later", QbzSession.trRev), "icon": "list-plus", "danger": false, "needsSelection": true },
                        { "id": "queue", "label": QbzSession.tr("Add to queue", QbzSession.trRev), "icon": "list-end", "danger": false, "needsSelection": true },
                        { "id": "add-to-playlist", "label": QbzSession.tr("Add to playlist", QbzSession.trRev), "icon": "list-music", "danger": false, "needsSelection": true },
                        { "id": "add-to-mixtape", "label": QbzSession.tr("Add to Mixtape/Collection", QbzSession.trRev), "icon": "cassette-tape", "danger": false, "needsSelection": true },
                        { "id": "add-to-favorites", "label": QbzSession.tr("Add to Library", QbzSession.trRev), "icon": "heart", "danger": false, "needsSelection": true },
                        { "id": "make-offline", "label": QbzSession.tr("Make available offline", QbzSession.trRev), "icon": "cloud-download", "danger": false, "needsSelection": true },
                        { "id": "clear", "label": QbzSession.tr("Clear", QbzSession.trRev), "icon": "x", "danger": false, "needsSelection": true }
                    ]
                    onAction: function (id) { root.bulkAction(id) }
                }

                // Air between the sticky JUMP TO bar's rule and the row.
                Item { visible: topTracks.length > 0; width: 1; height: 8 }
                Row {
                    property string anchorId: "popular-tracks"
                    visible: topTracks.length > 0
                    width: parent.width
                    spacing: 12
                    Text {
                        width: parent.width - 32 - 32 - 32 - 3 * 12
                        anchors.verticalCenter: parent.verticalCenter
                        text: QbzSession.tr("Popular Tracks", QbzSession.trRev)
                        color: theme.textPrimary
                        font.pixelSize: theme.fontHeading
                        font.weight: theme.weightSemibold
                    }
                    // The SHARED CircleAction, in the same plain 32px outlined
                    // form as its two siblings (2026-09-13): the filled 44px
                    // accent disc the .slint carried here clashed with them
                    // and butted the JUMP TO bar's rule.
                    QbzCircleAction {
                        name: "play-fill"
                        anchors.verticalCenter: parent.verticalCenter
                        onClicked: QbzPlayer.playArtistTop(false)
                    }
                    // Multi-select toggle — live since the bulk-bar port.
                    QbzCircleAction {
                        name: "square-check-big"
                        active: root.multiSelect
                        btnEnabled: root.topTracks.length > 0
                        anchors.verticalCenter: parent.verticalCenter
                        onClicked: root.setMultiSelect(!root.multiSelect)
                    }
                    QbzCircleAction {
                        id: topMenuBtn
                        name: "ellipsis"
                        anchors.verticalCenter: parent.verticalCenter
                        onClicked: function (mouse) {
                            topMenu.forLibrary = false
                            topMenu.openAtCursor(topMenuBtn, mouse.x, mouse.y)
                        }
                    }
                }
                Item { visible: topTracks.length > 0; width: 1; height: 10 }

                Repeater {
                    // Do not build the unrevealed tail. Numeric growth keeps
                    // the preview delegates and adds only the requested rows.
                    model: root.topTracksExpanded ? topTracks.length
                        : Math.min(topTracks.length, root.preview)
                    delegate: PopularTrackRow {
                        // Smooth reveal (owner, 2026-08-02). This expander is
                        // CLIENT-SIDE: numeric model growth now creates only
                        // the revealed tail. The former full count built every
                        // row up front and only flipped `visible`.
                        //
                        // OPACITY ONLY, deliberately: the row is 50 tall with
                        // a 36px cover and text anchored to its verticalCenter
                        // and it does NOT clip, so animating `height` would
                        // paint those children outside the row box and over
                        // its neighbours for the whole 220ms. Height still
                        // snaps (the space opens at once); the content
                        // dissolves into it. Same 220ms / OutCubic the
                        // appended release cards use.
                        //
                        // The gate is this explicit local `revealed`, not the
                        // item's effective visibility, so showing the catalog
                        // tab again does not re-fade surviving delegates.
                        property bool revealed: false
                        height: 50
                        opacity: revealed ? 1.0 : 0.0
                        Behavior on opacity { NumberAnimation { duration: 220; easing.type: Easing.OutCubic } }
                        Component.onCompleted: revealed = true
                        row: topTracks[index]
                        rowIndex: index
                        showAlbum: true
                        selectMode: root.multiSelect
                        checked: root.selected[row.id] === true
                        onToggleSelect: function (mods) { root.toggleSelected(row.id, mods) }
                    }
                }
                Item { visible: topTracks.length > root.preview; width: 1; height: 4 }
                // The shared affordance — the `b` arm of controls/QbzLoadMore
                // .qml's header: same plain 28-tall shape, same label pair,
                // same client-side toggle. No `busy` and no skeleton: there is
                // no fetch, the reveal is instant (the rows above own the
                // smoothing).
                QbzLoadMore {
                    visible: topTracks.length > root.preview
                    width: parent.width
                    label: root.topTracksExpanded ? QbzSession.tr("View less", QbzSession.trRev) : QbzSession.tr("Load more", QbzSession.trRev)
                    onClicked: root.topTracksExpanded = !root.topTracksExpanded
                }

                // --- Latest release --------------------------------------
                Column {
                    property string anchorId: "about"
                    visible: !!root.artist.lastRelease
                    width: parent.width
                    spacing: 12
                    Item { width: 1; height: 32 }
                    Text {
                        text: QbzSession.tr("Latest release", QbzSession.trRev)
                        color: theme.textPrimary
                        font.pixelSize: theme.fontHeading
                        font.weight: theme.weightSemibold
                    }
                    AlbumCard {
                        // EVERY read here must be `root.artist.lastRelease`:
                        // inside the AlbumCard instantiation the bare name
                        // `artist` resolves to the CARD'S OWN string property
                        // (a string has no .lastRelease → undefined → every
                        // binding fell back to ""), so the card rendered as an
                        // empty tile while the grids' modelData-driven cards
                        // were fine. Verified live 2026-08-10 (VNC drive).
                        albumId: root.artist.lastRelease ? root.artist.lastRelease.id : ""
                        title: root.artist.lastRelease ? root.artist.lastRelease.title : ""
                        // year in the subtitle slot — card_to_item again
                        // (artist.rs:784 maps last_release through it too).
                        artist: root.artist.lastRelease ? root.artist.lastRelease.year : ""
                        artistId: ""
                        genre: root.artist.lastRelease ? root.artist.lastRelease.genre : ""
                        year: root.artist.lastRelease ? root.artist.lastRelease.year : ""
                        qualityTier: root.artist.lastRelease ? root.artist.lastRelease.qualityTier : ""
                        qualityDetail: root.artist.lastRelease ? (root.artist.lastRelease.qualityDetail || "") : ""
                        artSource: root.artist.lastRelease ? (root.coverMap[root.artist.lastRelease.artUrl] || "") : ""
                        // Same row shape as the release grids (map_release).
                        isPinned: root.artist.lastRelease ? root.artist.lastRelease.isPinned === true : false
                        artworkUrl: root.artist.lastRelease ? (root.artist.lastRelease.artUrl || "") : ""
                        isFavorite: root.artist.lastRelease ? root.artist.lastRelease.isFavorite === true : false
                    }
                }

                // --- Release sections ------------------------------------
                Repeater {
                    // `visible: false` does not prevent delegate construction.
                    // Feed this arm only regular buckets so the collapsed
                    // Other bucket is not built once here and again below.
                    model: releaseSections.filter(function (s) {
                        return s.releaseType !== "other"
                    })
                    delegate: Column {
                        required property var modelData
                        width: parent ? parent.width : 0
                        spacing: 0
                        Item { width: 1; height: 32 }
                        ReleaseSection { section: modelData; anchorId: modelData.releaseType }
                    }
                }

                // --- Appears On -------------------------------------------
                Column {
                    property string anchorId: "appears-on"
                    visible: appearsOn.length > 0
                    width: parent.width
                    spacing: 0
                    Item { width: 1; height: 32 }
                    Text {
                        text: QbzSession.tr("Appears On", QbzSession.trRev)
                        color: theme.textPrimary
                        font.pixelSize: theme.fontHeading
                        font.weight: theme.weightSemibold
                    }
                    Item { width: 1; height: 10 }
                    Repeater {
                        model: root.appearsOnExpanded ? appearsOn.length
                            : Math.min(appearsOn.length, root.preview)
                        delegate: PopularTrackRow {
                            // Same client-side reveal as Popular Tracks above
                            // — same component, same 50px pitch, same reason
                            // for fading opacity and letting height snap.
                            property bool revealed: false
                            height: 50
                            opacity: revealed ? 1.0 : 0.0
                            Behavior on opacity { NumberAnimation { duration: 220; easing.type: Easing.OutCubic } }
                            Component.onCompleted: revealed = true
                            row: appearsOn[index]
                            rowIndex: index
                            showAlbum: false
                            selectMode: root.multiSelect
                            checked: root.selected[row.id] === true
                            onToggleSelect: function (mods) { root.toggleSelected(row.id, mods) }
                        }
                    }
                    Item { visible: appearsOn.length > root.preview; width: 1; height: 4 }
                    // Shared affordance, `b` arm again (client-side toggle).
                    QbzLoadMore {
                        visible: appearsOn.length > root.preview
                        width: parent.width
                        label: root.appearsOnExpanded ? QbzSession.tr("View less", QbzSession.trRev) : QbzSession.tr("Load more", QbzSession.trRev)
                        onClicked: root.appearsOnExpanded = !root.appearsOnExpanded
                    }
                }

                // --- Playlists --------------------------------------------
                // The reference mounts the SHARED playlist carousel here
                // (ArtistPageView.slint:985-995 -> discover/PlaylistCarousel
                // -> discover/PlaylistCard), so this page gets the same card
                // Home, Search, Browse, Label and the Library feed already
                // mount: body click opens, overlay play/favourite/⋯, pin
                // badge, context menu — and the banner rendered CONTAIN
                // instead of cropped 2.11:1 into a square.
                //
                // What stood here was a hand-rolled Rectangle delegate whose
                // MouseArea had no onClicked at all (only a cursor, which is
                // why it LOOKED clickable) and a RoundedImage with no `fit:`,
                // i.e. the default crop. Its POC-NOTE claimed there was no
                // playlist view yet; views/PlaylistView.qml has existed and
                // been routed for a long time.
                Item { visible: playlists.length > 0; width: 1; height: 32 }
                PlaylistRail {
                    visible: playlists.length > 0
                    width: parent.width
                    title: QbzSession.tr("Playlists", QbzSession.trRev)
                    items: playlists
                    coverMap: root.coverMap
                }

                // --- Other (collapsed) ------------------------------------
                Repeater {
                    model: releaseSections.filter(function (s) {
                        return s.releaseType === "other"
                    })
                    delegate: Column {
                        required property var modelData
                        width: parent ? parent.width : 0
                        spacing: 0
                        Item { width: 1; height: 32 }
                        Row {
                            width: parent.width
                            spacing: 8
                            Text {
                                width: parent.width - otherToggle.implicitWidth - 8
                                anchors.verticalCenter: parent.verticalCenter
                                text: modelData.title
                                color: theme.textPrimary
                                font.pixelSize: theme.fontHeading
                                font.weight: theme.weightSemibold
                            }
                            Text {
                                id: otherToggle
                                anchors.verticalCenter: parent.verticalCenter
                                text: root.otherExpanded ? QbzSession.tr("Hide", QbzSession.trRev) : QbzSession.tr("Show", QbzSession.trRev)
                                color: otherToggleArea.containsMouse ? theme.textPrimary : theme.textSecondary
                                font.pixelSize: 13
                                MouseArea {
                                    id: otherToggleArea
                                    anchors.fill: parent
                                    hoverEnabled: true
                                    cursorShape: Qt.PointingHandCursor
                                    onClicked: root.otherExpanded = !root.otherExpanded
                                }
                            }
                        }
                        Item { visible: root.otherExpanded; width: 1; height: 12 }
                        Grid {
                            visible: root.otherExpanded
                            width: parent.width
                            columns: Math.max(1, Math.floor((width + 24) / 224))
                            columnSpacing: 24
                            rowSpacing: 24
                            Repeater {
                                // A hidden Grid still constructs its Repeater.
                                // The collapsed bucket must cost zero cards.
                                model: root.otherExpanded ? modelData.cards : []
                                delegate: AlbumCard {
                                    albumId: modelData.id
                                    title: modelData.title
                                    // year in the subtitle slot (card_to_item)
                                    artist: modelData.year
                                    artistId: ""
                                    genre: modelData.genre
                                    year: modelData.year
                                    qualityTier: modelData.qualityTier
                                    qualityDetail: modelData.qualityDetail || ""
                                    artSource: root.coverMap[modelData.artUrl] || ""
                                    isPinned: modelData.isPinned === true
                                    artworkUrl: modelData.artUrl || ""
                                    isFavorite: modelData.isFavorite === true
                                }
                            }
                        }
                    }
                }
            }

            // ================= In library tab =============================
            // The user's OWN rows for this artist (`root.libItems`, off the
            // artist document). Two first-class sections — Tracks modelled on
            // Popular Tracks (header action cluster, 10-row preview, Load
            // more) and the Albums grid — each carrying an `anchorId` so the
            // JUMP TO strip resolves against THIS column in library mode.
            Column {
                id: libraryTab
                visible: root.artistTab === "library" && !QbzArtist.artistLoading
                width: page.bodyWidth
                spacing: 0

                // Same bulk bar as the catalog column: `bulkAction` routes on
                // the active mode's lists (`selectableLists`).
                QbzMultiSelectBar {
                    visible: root.multiSelect
                    width: parent.width
                    selectedCount: root.selectedCount
                    actions: [
                        { "id": "select-all", "label": QbzSession.tr("Select all", QbzSession.trRev), "icon": "square-check-big", "danger": false, "needsSelection": false },
                        { "id": "play-next", "label": QbzSession.tr("Play next", QbzSession.trRev), "icon": "list-start", "danger": false, "needsSelection": true },
                        { "id": "play-later", "label": QbzSession.tr("Play later", QbzSession.trRev), "icon": "list-plus", "danger": false, "needsSelection": true },
                        { "id": "queue", "label": QbzSession.tr("Add to queue", QbzSession.trRev), "icon": "list-end", "danger": false, "needsSelection": true },
                        { "id": "add-to-playlist", "label": QbzSession.tr("Add to playlist", QbzSession.trRev), "icon": "list-music", "danger": false, "needsSelection": true },
                        { "id": "add-to-mixtape", "label": QbzSession.tr("Add to Mixtape/Collection", QbzSession.trRev), "icon": "cassette-tape", "danger": false, "needsSelection": true },
                        { "id": "make-offline", "label": QbzSession.tr("Make available offline", QbzSession.trRev), "icon": "cloud-download", "danger": false, "needsSelection": true },
                        { "id": "clear", "label": QbzSession.tr("Clear", QbzSession.trRev), "icon": "x", "danger": false, "needsSelection": true }
                    ]
                    onAction: function (id) { root.bulkAction(id) }
                }

                // --- Tracks ---------------------------------------------
                // Header + action cluster: the Popular Tracks row above,
                // with the actions re-pointed at the library list — Play all
                // / Shuffle all through `libraryPlayAll`, the ⋯ menu shared
                // with Popular Tracks (`topMenu.forLibrary`).
                Row {
                    property string anchorId: "tracks"
                    visible: root.libTracks.length > 0
                    width: parent.width
                    spacing: 12
                    Text {
                        width: parent.width - 44 - 32 - 32 - 3 * 12
                        anchors.verticalCenter: parent.verticalCenter
                        text: QbzSession.tr("Tracks", QbzSession.trRev)
                        color: theme.textPrimary
                        font.pixelSize: theme.fontHeading
                        font.weight: theme.weightSemibold
                    }
                    QbzCircleAction {
                        primary: true
                        name: "play-fill"
                        anchors.verticalCenter: parent.verticalCenter
                        onClicked: QbzLibrary.libraryPlayAll(JSON.stringify(root.libTrackIds()), false)
                    }
                    QbzCircleAction {
                        name: "square-check-big"
                        active: root.multiSelect
                        btnEnabled: root.libTracks.length > 0
                        anchors.verticalCenter: parent.verticalCenter
                        onClicked: root.setMultiSelect(!root.multiSelect)
                    }
                    QbzCircleAction {
                        id: libMenuBtn
                        name: "ellipsis"
                        anchors.verticalCenter: parent.verticalCenter
                        onClicked: function (mouse) {
                            topMenu.forLibrary = true
                            topMenu.openAtCursor(libMenuBtn, mouse.x, mouse.y)
                        }
                    }
                }
                Item { visible: root.libTracks.length > 0; width: 1; height: 10 }
                Repeater {
                    // Numeric model: only the revealed rows are BUILT
                    // (declaring is building — the Popular Tracks expander's
                    // rule, feedback_qml_hidden_is_not_unbuilt).
                    model: root.libTracksExpanded ? root.libTracks.length
                        : Math.min(root.libTracks.length, root.libPreview)
                    delegate: PopularTrackRow {
                        readonly property var item: root.libTracks[index] || ({})
                        property bool revealed: false
                        // A cleared heart takes the row out — visually now,
                        // for real when the document republishes (the heart
                        // settles, `artist_qt::apply_favorite_change`
                        // recomputes the rows). A PURCHASE that loses its
                        // heart stays: it is still library (contract §3).
                        readonly property bool leaving:
                            !root.toggleState("track:" + item.id, item.isFavorite === true)
                            && item.group !== "purchases"
                        height: 50
                        opacity: (revealed && !leaving) ? 1.0 : 0.0
                        Behavior on opacity { NumberAnimation { duration: 220; easing.type: Easing.OutCubic } }
                        Component.onCompleted: revealed = true
                        row: ({
                            "id": item.id, "number": index + 1, "title": item.title,
                            "artist": item.artist, "artistId": item.artistId,
                            "album": item.album, "albumId": item.albumId,
                            "duration": item.duration, "qualityTier": item.qualityTier,
                            "explicit": item.explicit, "artUrl": item.imageUrl,
                            "isFavorite": item.isFavorite === true,
                            "qobuzUnavailable": item.qobuzUnavailable === true,
                            "cacheStatus": item.cacheStatus || 0,
                        })
                        rowIndex: index
                        showAlbum: true
                        selectMode: root.multiSelect
                        checked: root.selected[row.id] === true
                        playHandler: function (id) {
                            QbzLibrary.libraryPlayVisible(JSON.stringify(root.libTrackIds()), id)
                        }
                        onToggleSelect: function (mods) { root.toggleSelected(row.id, mods) }
                    }
                }
                Item { visible: root.libTracks.length > root.libPreview; width: 1; height: 4 }
                QbzLoadMore {
                    visible: root.libTracks.length > root.libPreview
                    width: parent.width
                    label: root.libTracksExpanded ? QbzSession.tr("View less", QbzSession.trRev) : QbzSession.tr("Load more", QbzSession.trRev)
                    onClicked: root.libTracksExpanded = !root.libTracksExpanded
                }

                // --- Albums ---------------------------------------------
                Item { visible: root.libAlbums.length > 0 && root.libTracks.length > 0; width: 1; height: 24 }
                // Header: title, the release buckets' sort select, and the
                // split play button — the catalog section header's cluster
                // minus "See discography" (there is nothing to page here).
                Row {
                    property string anchorId: "albums"
                    visible: root.libAlbums.length > 0
                    width: parent.width
                    spacing: 12
                    Text {
                        width: parent.width - libSortBtn.width - libPlayBtn.width - 24
                        anchors.verticalCenter: parent.verticalCenter
                        text: QbzSession.tr("Albums", QbzSession.trRev)
                        color: theme.textPrimary
                        font.pixelSize: theme.fontHeading
                        font.weight: theme.weightSemibold
                        elide: Text.ElideRight
                    }
                    QbzSelect {
                        id: libSortBtn
                        anchors.verticalCenter: parent.verticalCenter
                        sm: true
                        menuWidth: 150
                        options: [QbzSession.tr("Default", QbzSession.trRev),
                                  QbzSession.tr("Newest", QbzSession.trRev),
                                  QbzSession.tr("Oldest", QbzSession.trRev),
                                  QbzSession.tr("A–Z", QbzSession.trRev),
                                  QbzSession.tr("Z–A", QbzSession.trRev)]
                        currentIndex: {
                            var s = root.libSort || "default"
                            return s === "newest" ? 1 : s === "oldest" ? 2
                                 : s === "title-asc" ? 3 : s === "title-desc" ? 4 : 0
                        }
                        onSelected: function (i) {
                            root.setLibSort(i === 1 ? "newest" : i === 2 ? "oldest"
                                : i === 3 ? "title-asc" : i === 4 ? "title-desc" : "default")
                        }
                    }
                    QbzSplitButton {
                        id: libPlayBtn
                        anchors.verticalCenter: parent.verticalCenter
                        label: root.albumSectionLabel("library")
                        menuItems: root.albumSectionMenu("library")
                        onClicked: root.albumSectionPrimary("library", root.libAlbumsSorted)
                        onPicked: function (a) { root.albumSectionAction("library", root.libAlbumsSorted, a) }
                    }
                }
                Item { visible: root.libAlbums.length > 0; width: 1; height: 10 }
                Grid {
                    visible: root.libAlbums.length > 0
                    width: parent.width
                    columns: Math.max(1, Math.floor((width + 24) / 224))
                    columnSpacing: 24
                    rowSpacing: 24
                    Repeater {
                        model: root.libAlbumsSorted
                        delegate: AlbumCard {
                            // "Play selected" over this section (the split
                            // button), check bottom-right inside the art.
                            selectMode: root.albumSelectKey === "library"
                            selected: root.albumSelected[modelData.id] === true
                            selectMarkBottom: true
                            onSelectToggled: function (mods) {
                                root.albumSelectToggle(modelData.id, root.libAlbumsSorted, mods)
                            }
                            albumId: modelData.id
                            title: modelData.title
                            artist: modelData.artist
                            artistId: modelData.artistId
                            genre: modelData.genre
                            year: modelData.year
                            qualityTier: modelData.qualityTier
                            qualityDetail: modelData.qualityDetail || ""
                            artSource: root.coverMap[modelData.imageUrl] || ""
                            // These rows are LIBRARY feed items (FeedItem),
                            // not release cards: the remote url is
                            // `imageUrl`, and the pin state rides the same
                            // row (library_qt `map_album`).
                            isPinned: modelData.isPinned === true
                            artworkUrl: modelData.imageUrl || ""
                            // The heart goes through the page's optimistic
                            // store so the card can fade out on the click,
                            // ahead of the settle that removes the row.
                            hostFavorite: true
                            isFavorite: root.toggleState("album:" + modelData.id, modelData.isFavorite === true)
                            onFavoriteRequested: {
                                var next = !root.toggleState("album:" + modelData.id, modelData.isFavorite === true)
                                root.setToggleState("album:" + modelData.id, next)
                                QbzLibrary.libraryToggleFavorite("album", modelData.id)
                            }
                            readonly property bool leaving: !isFavorite && modelData.group !== "purchases"
                            opacity: leaving ? 0.0 : 1.0
                            Behavior on opacity { NumberAnimation { duration: 220; easing.type: Easing.OutCubic } }
                        }
                    }
                }
            }
        }

    }

    // Gutter scrollbar. A SIBLING of the Flickable, not a child: anything
    // declared inside a Flickable lands in its contentItem and scrolls away
    // with the page. Hidden while the network panel is open — that panel pins
    // to the same right edge and carries its own scroll
    // (ArtistPageView.slint:1157).
    // Back/forward scroll memory (controls/ScrollMemory.qml): reports
    // this container's offset while it is the live page, and restores it
    // when a back/forward step arms this route.
    ScrollMemory { target: flick; scope: "artist" }
    QbzScrollBar {
        visible: !root.networkOpen
        anchors.right: parent.right
        anchors.rightMargin: 4
        anchors.top: parent.top
        anchors.bottom: parent.bottom
        target: flick
    }

    // --- Network sidebar (300px, surface-card + 1px left border) ---------
    // BOUNDED, not full-height. ArtistPageView.slint:1178-1195:
    //   natural-top = the live viewport y of the body row + the JUMP TO bar
    //                 height  (i.e. the panel starts under the strip, never
    //                 beside the portrait)
    //   y           = max(natural-top, sticky-top=44)  — it rides the scroll
    //                 down and then parks 44px from the top
    //   height      = root.height - y                 — always flush with the
    //                 bottom, so no gap appears once it is parked
    // The port ran it top-to-bottom of the whole view, which put the panel
    // alongside the header and made it read as app chrome instead of a page
    // panel.
    // --- STICKY JUMP TO bar (ArtistPageView.slint:1113-1126) ---------------
    //
    // An OVERLAY over the Flickable, not a row inside it, and that is the only
    // way it can pin: an item in the content column scrolls with the content by
    // definition. `jumpSlot` above holds its place in the flow so nothing jumps
    // when it lifts out.
    //
    // The clamp is the reference's, verbatim: `y = max(naturalTop, 0)` where
    // naturalTop is the slot's VIEWPORT-relative y. The reference's own comment
    // is worth keeping in mind — the formula must NOT add the viewport y, or
    // the scroll is double-counted and the bar lifts ahead of the body during
    // the transition (a visible gap plus a bar-over-header artifact mid-scroll).
    //
    // Full width with padH 32, where the in-flow version was `parent.width - 64`
    // with padH 0: the Column supplied that 32px padding, and outside it the bar
    // has to supply its own or the strip would shift left by 32 when it sticks.
    // Net position of the tabs is unchanged. Same shape as the .slint, which
    // also mounts it at x:0 across `root.width`.
    QbzJumpNavBar {
        id: jumpBar
        x: 0
        width: root.width
        padH: 32
        y: Math.max(page.y + jumpSlot.y - flick.contentY, 0)
        // PINNED at the pane's top edge -> round the top corners, or the bar's
        // square ones poke out past the shell's rounded bezel (the Discover
        // full-bleed toolbar, same defect, same fix). Driven off the live y so
        // the rounding exists ONLY while the bar is actually at the top: in
        // mid-page it is surrounded by content and a notch there would be worse
        // than the square corner it fixes.
        topRadius: y <= 0 ? theme.radiusMd : 0
        // surface-main @ 0.6 under the dynamic background, NOT
        // transparent: pinned, it overlays the page content scrolling beneath
        // it, so it needs SOME fill to stay readable — the reference gives thin
        // bars their own lighter tier for exactly that
        // (ArtistPageView.slint:1108). This mattered less when the bar scrolled
        // with the page; now it is load-bearing.
        barBg: root.ambientOn
            ? Qt.rgba(theme.surfaceMain.r, theme.surfaceMain.g,
                      theme.surfaceMain.b, 0.60)
            : theme.surfaceMain
        tabs: root.jumpTabs
        activeTabId: root.activeJumpTab
        visible: root.jumpTabs.length > 0
        // "In library" source switches — `Library > Albums / Tracks`'s
        // purchases / favourites toggles (LibraryToolbar.qml:376-377), on the
        // shared QbzToggleButton, floating in the strip ONLY while the library
        // tab is active. State is the page's own (`libShowPurchases` /
        // `libShowFavorites`), never `QbzLibrary.sessionShow*`.
        trailing: Row {
            visible: root.artistTab === "library"
            width: visible ? implicitWidth : 0
            height: 44
            spacing: 8
            QbzToggleButton {
                sm: true
                name: "shopping-bag"
                active: root.libShowPurchases
                anchors.verticalCenter: parent.verticalCenter
                onClicked: root.libShowPurchases = !root.libShowPurchases
            }
            QbzToggleButton {
                sm: true
                name: "heart"
                active: root.libShowFavorites
                anchors.verticalCenter: parent.verticalCenter
                onClicked: root.libShowFavorites = !root.libShowFavorites
            }
        }
        onTabClicked: function (id) { root.scrollToSection(id) }
        onSearchEdited: function (text) { root.searchQuery = text }
    }

    Rectangle {
        id: netPanel
        // Viewport-relative y of the strip's bottom edge. `jumpBar.y` is
        // content coords, so subtracting the scroll offset gives the live
        // viewport position — the same arithmetic the .slint does with
        // absolute-position.
        readonly property real naturalTop:
            page.y + jumpSlot.y + jumpSlot.height - flick.contentY
        readonly property real stickyTop: 44

        anchors.right: parent.right
        y: Math.max(naturalTop, stickyTop)
        height: Math.max(0, root.height - y)
        width: root.networkOpen ? 300 : 0
        clip: true
        // Chrome tier: surface-card @ 0.5 under the dynamic background
        // (ArtistPageView.slint:1196). Its 44px header row stays TRANSPARENT
        // there (:1221) — it sits ON this already-translucent body, and a
        // second translucent layer would compound to near-opaque.
        color: root.ambientOn ? theme.surfaceCardA50 : theme.surfaceCard
        Behavior on width { NumberAnimation { duration: 160; easing.type: Easing.InOutQuad } }

        Rectangle { anchors.left: parent.left; anchors.top: parent.top; anchors.bottom: parent.bottom; width: 1; color: theme.borderSubtle }

        Column {
            anchors.fill: parent
            spacing: 0

            // Header: Network / Magazine tabs + close.
            Item {
                width: parent.width
                height: 44
                Row {
                    anchors.left: parent.left
                    anchors.leftMargin: 12
                    anchors.verticalCenter: parent.verticalCenter
                    spacing: 14
                    Repeater {
                        model: [
                            { "id": "network", "label": QbzSession.tr("Network", QbzSession.trRev) },
                            { "id": "magazine", "label": QbzSession.tr("Magazine", QbzSession.trRev) },
                        ]
                        delegate: Column {
                            required property var modelData
                            spacing: 0
                            Text {
                                text: modelData.label
                                color: root.netTab === modelData.id ? theme.textPrimary : theme.textMuted
                                font.pixelSize: 12
                                font.weight: theme.weightSemibold
                                font.letterSpacing: 0.8
                                MouseArea {
                                    anchors.fill: parent
                                    cursorShape: Qt.PointingHandCursor
                                    onClicked: root.netTab = modelData.id
                                }
                            }
                            Rectangle {
                                visible: root.netTab === modelData.id
                                width: parent.width
                                height: 2
                                radius: 1
                                color: theme.accent
                            }
                        }
                    }
                }
                Rectangle {
                    anchors.right: parent.right
                    anchors.rightMargin: 8
                    anchors.verticalCenter: parent.verticalCenter
                    width: 28
                    height: 28
                    radius: 6
                    color: netCloseArea.containsMouse ? theme.surfaceElevated : "transparent"
                    QbzIcon {
                        anchors.centerIn: parent
                        name: "panel-right-close"
                        width: 18
                        height: 18
                        tintName: netCloseArea.containsMouse ? root.tintOnSurface : "muted"
                    }
                    MouseArea {
                        id: netCloseArea
                        anchors.fill: parent
                        hoverEnabled: true
                        cursorShape: Qt.PointingHandCursor
                        onClicked: root.networkOpen = false
                    }
                }
            }
            Rectangle { width: parent.width; height: 1; color: theme.borderSubtle }

            // Network tab body.
            Flickable {
                visible: root.netTab === "network"
                width: parent.width
                height: parent.height - 45
                clip: true
                contentWidth: width
                contentHeight: netBody.implicitHeight
                boundsBehavior: Flickable.StopAtBounds

                Column {
                    id: netBody
                    width: parent.width
                    topPadding: 4
                    bottomPadding: 12
                    spacing: 0

                    // ORIGIN (MusicBrainz). Gated exactly like the Slint
                    // block: MB available AND (still loading OR the artist
                    // actually carries a life span / location). With MB off
                    // the whole block is absent — nothing was requested.
                    Column {
                        visible: network.mbAvailable === true
                                 && (network.originLoading === true || mbOrigin.hasData === true)
                        width: parent.width
                        leftPadding: 14
                        rightPadding: 14
                        topPadding: 12
                        bottomPadding: 12
                        spacing: 6
                        SidebarSkeleton {
                            visible: root.originPending
                            rows: 2
                            phase: skeletonPhase.on
                        }
                        OriginRow {
                            visible: network.originLoading !== true && (mbOrigin.beginDate || "") !== ""
                            key: mbOrigin.isPerson ? QbzSession.tr("BORN", QbzSession.trRev)
                                                   : QbzSession.tr("FOUNDED", QbzSession.trRev)
                            value: mbOrigin.beginDate || ""
                        }
                        OriginRow {
                            visible: network.originLoading !== true && (mbOrigin.locationDisplay || "") !== ""
                            key: mbOrigin.isPerson ? QbzSession.tr("BORN IN", QbzSession.trRev)
                                                   : QbzSession.tr("FOUNDED IN", QbzSession.trRev)
                            // DOOR D1 to the Artist Scene, and the reference's
                            // ONLY door (ArtistDetailView.svelte:2904-2935).
                            // Was plain text under a POC-NOTE until the scene
                            // view existed to receive it.
                            value: mbOrigin.locationDisplay || ""
                            clickable: root.sceneAvailable
                            onActivated: root.openArtistScene()
                        }
                        OriginRow {
                            visible: network.originLoading !== true && (mbOrigin.endDate || "") !== ""
                            key: mbOrigin.isPerson ? QbzSession.tr("DIED", QbzSession.trRev)
                                                   : QbzSession.tr("DISBANDED", QbzSession.trRev)
                            value: mbOrigin.endDate || ""
                        }
                    }

                    // LABELS.
                    Column {
                        width: parent.width
                        leftPadding: 14
                        rightPadding: 14
                        topPadding: 12
                        bottomPadding: 6
                        spacing: 4
                        SidebarSectionHeading { text: QbzSession.tr("LABELS", QbzSession.trRev) }
                        SidebarNote {
                            visible: labels.length === 0
                            text: QbzSession.tr("No label info", QbzSession.trRev)
                        }
                        Repeater {
                            model: labels
                            delegate: SidebarLink {
                                label: modelData.name
                                tooltip: modelData.name
                                iconName: "disc"
                                onClicked: QbzHome.openLabel(modelData.id)
                            }
                        }
                    }
                    // SIMILAR ARTISTS.
                    Column {
                        visible: similarArtists.length > 0 || QbzArtist.artistLoading
                        width: parent.width
                        leftPadding: 14
                        rightPadding: 14
                        topPadding: 12
                        bottomPadding: 6
                        spacing: 4
                        SidebarSectionHeading { text: QbzSession.tr("SIMILAR ARTISTS", QbzSession.trRev) }
                        SidebarSkeleton {
                            visible: root.similarPending
                            rows: 4
                            phase: skeletonPhase.on
                        }
                        Repeater {
                            model: similarArtists
                            delegate: SidebarLink {
                                label: modelData.name
                                tooltip: modelData.name
                                iconName: "user"
                                onClicked: QbzArtist.openArtist(modelData.id)
                            }
                        }
                    }

                    // RELATIONSHIPS (MusicBrainz) — band members, the groups
                    // this artist belongs to, and studio collaborators.
                    Column {
                        visible: network.mbAvailable === true
                                 && (network.relationshipsLoading === true
                                     || mbRelationships.hasData === true)
                        width: parent.width
                        leftPadding: 14
                        rightPadding: 14
                        topPadding: 12
                        bottomPadding: 6
                        spacing: 6
                        SidebarSectionHeading { text: QbzSession.tr("RELATIONSHIPS", QbzSession.trRev) }
                        SidebarSkeleton {
                            visible: root.relationshipsPending
                            rows: 3
                            phase: skeletonPhase.on
                        }
                        RelationshipGroup {
                            visible: network.relationshipsLoading !== true
                                     && (mbRelationships.members || []).length > 0
                            title: QbzSession.tr("Members & Former", QbzSession.trRev)
                            rows: mbRelationships.members || []
                            roleKey: "member"
                            iconName: "user"
                            expanded: root.membersExpanded
                            onToggled: root.membersExpanded = !root.membersExpanded
                        }
                        RelationshipGroup {
                            visible: network.relationshipsLoading !== true
                                     && (mbRelationships.groups || []).length > 0
                            title: QbzSession.tr("Member Of", QbzSession.trRev)
                            rows: mbRelationships.groups || []
                            roleKey: "member of"
                            iconName: "music"
                            expanded: root.groupsExpanded
                            onToggled: root.groupsExpanded = !root.groupsExpanded
                        }
                        RelationshipGroup {
                            visible: network.relationshipsLoading !== true
                                     && (mbRelationships.collaborators || []).length > 0
                            title: QbzSession.tr("Collaborators", QbzSession.trRev)
                            rows: mbRelationships.collaborators || []
                            roleKey: "collaborator"
                            iconName: "user"
                            expanded: root.collabsExpanded
                            onToggled: root.collabsExpanded = !root.collabsExpanded
                        }
                    }

                    // YOU MAY ALSO LIKE (MusicBrainz tag discovery, validated
                    // against Qobuz by the core). Rows without a resolved
                    // Qobuz id stay informational instead of dead-clicking.
                    Column {
                        visible: network.mbAvailable === true
                                 && (network.discoveryLoading === true || root.discoveryRows.length > 0)
                        width: parent.width
                        leftPadding: 14
                        rightPadding: 14
                        topPadding: 12
                        bottomPadding: 12
                        spacing: 4
                        SidebarSectionHeading { text: QbzSession.tr("YOU MAY ALSO LIKE", QbzSession.trRev) }
                        SidebarSkeleton {
                            visible: root.discoveryPending
                            rows: 4
                            phase: skeletonPhase.on
                        }
                        Repeater {
                            model: root.discoveryRows
                            delegate: Item {
                                required property var modelData
                                // -28 = the section Column's left+right
                                // padding (see OriginRow).
                                width: parent ? parent.width - 28 : 0
                                height: 28
                                SidebarLink {
                                    anchors.left: parent.left
                                    anchors.verticalCenter: parent.verticalCenter
                                    // Explicit width REPLACES the component's
                                    // own `parent.width` binding (leaving it
                                    // and anchoring both edges fights it).
                                    width: parent.width - 26
                                    label: modelData.name
                                    tooltip: modelData.name
                                    iconName: "user"
                                    navigable: modelData.qobuzId !== ""
                                    onClicked: QbzArtist.openArtist(modelData.qobuzId)
                                }
                                Rectangle {
                                    id: dismissBtn
                                    anchors.right: parent.right
                                    anchors.verticalCenter: parent.verticalCenter
                                    width: 24
                                    height: 24
                                    radius: 4
                                    color: dismissArea.containsMouse ? theme.surfaceElevated : "transparent"
                                    QbzIcon {
                                        anchors.centerIn: parent
                                        name: "thumbs-down"
                                        width: 12
                                        height: 12
                                        tintName: dismissArea.containsMouse ? root.tintOnSurface : "muted"
                                    }
                                    MouseArea {
                                        id: dismissArea
                                        anchors.fill: parent
                                        hoverEnabled: true
                                        cursorShape: Qt.PointingHandCursor
                                        // Session-only: drop the row now. The
                                        // Slint app also persists it under the
                                        // discovery tag; that store is not open
                                        // in this port (see the handoff report).
                                        onClicked: {
                                            var d = root.dismissedDiscovery
                                            d[modelData.mbid] = true
                                            root.dismissedDiscovery = Object.assign({}, d)
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }

            // Magazine tab body — Qobuz editorial story teasers (limit 2,
            // like the official client). A story opens in the system browser.
            Flickable {
                visible: root.netTab === "magazine"
                width: parent.width
                height: parent.height - 45
                clip: true
                contentWidth: width
                contentHeight: magBody.implicitHeight
                boundsBehavior: Flickable.StopAtBounds

                Column {
                    id: magBody
                    width: parent.width
                    padding: 12
                    spacing: 10

                    // Story teasers are fetched after the page (Qobuz
                    // editorial): two card placeholders in the teaser shape
                    // while they resolve. Resolved-to-nothing keeps the
                    // explicit empty line below — this is a TAB body, where a
                    // blank panel would read as broken.
                    Column {
                        visible: root.storiesPending
                        width: magBody.width - 24
                        spacing: 12
                        Repeater {
                            model: 2
                            delegate: Column {
                                required property int index
                                width: parent ? parent.width : 0
                                spacing: 6
                                QbzSkeleton {
                                    variant: "block"
                                    width: parent.width
                                    height: parent.width
                                    blockRadius: 6
                                    cellIndex: index
                                    phase: skeletonPhase.on
                                }
                                QbzSkeleton { variant: "block"; width: parent.width * 0.82; height: 14; cellIndex: index; phase: skeletonPhase.on }
                                QbzSkeleton { variant: "block"; width: parent.width * 0.45; height: 11; cellIndex: index; phase: skeletonPhase.on }
                            }
                        }
                    }
                    SidebarNote {
                        visible: artist.storiesLoading !== true && stories.length === 0
                        text: QbzSession.tr("No stories for this artist", QbzSession.trRev)
                    }

                    Repeater {
                        model: stories
                        delegate: Rectangle {
                            required property var modelData
                            width: magBody.width - 24
                            height: storyCol.implicitHeight
                            radius: 8
                            color: storyArea.containsMouse ? theme.surfaceHover : "transparent"
                            Column {
                                id: storyCol
                                width: parent.width
                                padding: 6
                                spacing: 6
                                // 1:1 square thumbnail, height tracks width.
                                Rectangle {
                                    visible: (modelData.artUrl || "") !== ""
                                    width: storyCol.width - 12
                                    height: visible ? width : 0
                                    radius: 6
                                    color: theme.surfaceElevated
                                    clip: true
                                    RoundedImage {
                                        anchors.fill: parent
                                        source: root.coverMap[modelData.artUrl] || ""
                                        radius: 6
                                    }
                                }
                                Text {
                                    width: storyCol.width - 12
                                    text: modelData.title
                                    color: theme.textPrimary
                                    font.pixelSize: 13
                                    font.weight: theme.weightSemibold
                                    wrapMode: Text.WordWrap
                                }
                                Text {
                                    visible: (modelData.author || "") !== ""
                                    width: storyCol.width - 12
                                    text: modelData.author
                                    color: theme.textMuted
                                    font.pixelSize: 11
                                    elide: Text.ElideRight
                                }
                            }
                            MouseArea {
                                id: storyArea
                                anchors.fill: parent
                                hoverEnabled: true
                                cursorShape: Qt.PointingHandCursor
                                onClicked: if ((modelData.url || "") !== "") Qt.openUrlExternally(modelData.url)
                            }
                        }
                    }
                }
            }
        }
    }

    // --- Radio dropdown (the header disc) ----------------------------------
    // ArtistPageView.slint:440-460 — 180px, two rows, `close-on-click`. Left
    // aligned under the trigger (`x: 0px; y: 38px` there), which is what
    // openBelowLeft does; openBelowRight would hang a 180px panel off to the
    // LEFT of a 32px disc that sits at the start of the row.
    QbzContextMenu {
        id: radioMenu
        menuWidth: 180
        Repeater {
            model: [
                // Both labels already exist in the catalogue (they are the
                // TrackContextMenu's), so this adds no new msgid to the eight
                // locales.
                { "label": QbzSession.tr("QBZ Radio", QbzSession.trRev), "action": "qbz" },
                { "label": QbzSession.tr("Qobuz Radio", QbzSession.trRev), "action": "qobuz" },
            ]
            delegate: Rectangle {
                required property var modelData
                width: parent ? parent.width : 0
                height: 33
                radius: 5
                color: rmiArea.containsMouse ? theme.surfaceHover : "transparent"
                Row {
                    anchors.fill: parent
                    anchors.leftMargin: 8
                    spacing: 8
                    QbzIcon {
                        name: "radio"
                        width: 15
                        height: 15
                        anchors.verticalCenter: parent.verticalCenter
                        tintName: rmiArea.containsMouse ? "textPrimary" : "secondary"
                    }
                    Text {
                        height: parent.height
                        width: parent.width - 23
                        text: modelData.label
                        color: rmiArea.containsMouse ? theme.textPrimary : theme.textSecondary
                        font.pixelSize: 13
                        verticalAlignment: Text.AlignVCenter
                        elide: Text.ElideRight
                    }
                }
                MouseArea {
                    id: rmiArea
                    anchors.fill: parent
                    hoverEnabled: true
                    cursorShape: Qt.PointingHandCursor
                    onClicked: {
                        radioMenu.close()
                        if (modelData.action === "qbz")
                            QbzHome.startArtistRadio(artist.id)
                        else
                            QbzHome.startQobuzArtistRadio(artist.id)
                    }
                }
            }
        }
    }

    // --- ⋯ overflow menu ---------------------------------------------------
    QbzContextMenu {
        id: overflowMenu
        menuWidth: 224
            Repeater {
                // `live: false` = no seam on this bridge. The .slint greys
                // its own unavailable rows the same way (Artist Scene is
                // `enabled: NetworkSidebarState.mb-available`,
                // ArtistPageView.slint:523) — dimmed, no hover, no click,
                // and the menu keeps its shape.
                model: [
                    { "label": QbzSession.tr("Create Artist Collection", QbzSession.trRev), "icon": "library-big", "action": "disco", "live": true },
                    // DOOR D2. This row rendered at opacity 0.4 with
                    // `action: "stub"` — the track's named defect class, a
                    // control that renders, persists and drives nothing. It is
                    // a Slint-era invention with no counterpart in the visual
                    // reference (kept on the owner's explicit instruction,
                    // contract ruling R4), and it shares D1's gate exactly so
                    // the two doors can never disagree about availability.
                    { "label": QbzSession.tr("Artist Scene", QbzSession.trRev), "icon": "map-pin", "action": "scene", "live": root.sceneAvailable },
                    { "label": QbzSession.tr("Share", QbzSession.trRev), "icon": "link", "action": "share", "live": true },
                    { "label": root.toggleState("artistPin", artist.isPinned) ? QbzSession.tr("Unpin", QbzSession.trRev) : QbzSession.tr("Pin", QbzSession.trRev), "icon": root.toggleState("artistPin", artist.isPinned) ? "pin-filled" : "pin", "action": "pin", "live": true },
                ]
                delegate: Rectangle {
                    required property var modelData
                    width: parent ? parent.width : 0
                    height: 33
                    radius: 5
                    opacity: modelData.live ? 1.0 : 0.4
                    color: (modelData.live && omiArea.containsMouse) ? theme.surfaceHover : "transparent"
                    Row {
                        anchors.fill: parent
                        anchors.leftMargin: 8
                        spacing: 8
                        QbzIcon { name: modelData.icon; width: 15; height: 15; anchors.verticalCenter: parent.verticalCenter; tintName: "secondary" }
                        Text {
                            height: parent.height
                            width: parent.width - 23
                            text: modelData.label
                            color: theme.textSecondary
                            font.pixelSize: 13
                            verticalAlignment: Text.AlignVCenter
                            elide: Text.ElideRight
                        }
                    }
                    MouseArea {
                        id: omiArea
                        anchors.fill: parent
                        enabled: modelData.live
                        hoverEnabled: true
                        cursorShape: Qt.PointingHandCursor
                        onClicked: {
                            overflowMenu.close()
                            if (modelData.action === "pin") {
                                root.setToggleState("artistPin", !root.toggleState("artistPin", artist.isPinned))
                                QbzLibrary.togglePin("artist", artist.id, artist.name, "", artist.artUrl)
                            } else if (modelData.action === "scene") {
                                root.openArtistScene()
                            } else if (modelData.action === "disco") {
                                // Discography Builder — ArtistPageView.slint
                                // :505-511 `media-action("artist", id,
                                // "build-collection")`. This is the ONLY route
                                // to it; the nav flyout has no builder entry.
                                QbzDisco.open(artist.id)
                            } else if (modelData.action === "share") {
                                // ArtistPageView.slint:530-538 -> main.rs
                                // :12749 `media-action("artist", id,
                                // "share")`. The bridge builds the
                                // play.qobuz.com/artist/{id} URL, copies it
                                // and raises the "Link copied" toast, exactly
                                // as the .slint arm does. Nothing is copied
                                // QML-side here (unlike TrackRow.qml's
                                // Loader/TextEdit idiom): cxx-qt-lib exposes
                                // no QClipboard, and only Rust can publish
                                // QbzShell.toastJson, so the copy and its
                                // confirmation stay on one side.
                                //
                                // Link-only — artists have no Song.link path
                                // (share.rs's Song.link resolvers serve the
                                // track and album menus).
                                QbzArtist.share(artist.id)
                            }
                        }
                    }
                }
            }
            Rectangle { width: parent.width; height: 1; color: theme.borderSubtle }
            // ArtistPageView.slint:557-572 — the 1px border-subtle separator
            // above, then the LAST item, whose label flips
            // "Show artist" / "Blacklist artist" on ArtistState.is-blacklisted.
            // LIVE since QbzBlacklist landed (`artistToggle(id, name)`); it was
            // dimmed-and-inert only while the bridge had no invokable.
            Rectangle {
                width: parent.width
                height: 33
                radius: 5
                color: blkArea.containsMouse ? theme.surfaceHover : "transparent"
                Row {
                    anchors.fill: parent
                    anchors.leftMargin: 8
                    spacing: 8
                    QbzIcon { name: "blind-eye"; width: 15; height: 15; anchors.verticalCenter: parent.verticalCenter; tintName: "secondary" }
                    Text {
                        height: parent.height
                        width: parent.width - 23
                        text: root.artistBlacklisted
                            ? QbzSession.tr("Show artist", QbzSession.trRev)
                            : QbzSession.tr("Blacklist artist", QbzSession.trRev)
                        color: theme.textSecondary
                        font.pixelSize: 13
                        verticalAlignment: Text.AlignVCenter
                        elide: Text.ElideRight
                    }
                }
                MouseArea {
                    id: blkArea
                    anchors.fill: parent
                    hoverEnabled: true
                    cursorShape: Qt.PointingHandCursor
                    onClicked: {
                        overflowMenu.close()
                        root.toggleBlacklist()
                    }
                }
            }
        }

    // --- Popular Tracks ⋯ menu ---------------------------------------------
    QbzContextMenu {
        id: topMenu
        menuWidth: 224
        /// Opened from the library tab's Tracks header: the five rows act on
        /// `root.libTrackIds()` through the library seams instead of the
        /// TOP_QUEUE ones. Set by whichever ⋯ button opens the menu.
        property bool forLibrary: false
            Repeater {
                model: [
                    { "label": QbzSession.tr("Play all next", QbzSession.trRev), "icon": "list-start", "action": "next-all" },
                    { "label": QbzSession.tr("Play all later", QbzSession.trRev), "icon": "list-plus", "action": "later-all" },
                    { "label": QbzSession.tr("Add all to queue", QbzSession.trRev), "icon": "list-end", "action": "queue-all" },
                    { "label": QbzSession.tr("Shuffle all", QbzSession.trRev), "icon": "shuffle", "action": "shuffle-all" },
                    { "label": QbzSession.tr("Add all to playlist", QbzSession.trRev), "icon": "list-music", "action": "playlist-all" },
                ]
                delegate: Rectangle {
                    required property var modelData
                    width: parent ? parent.width : 0
                    height: 33
                    radius: 5
                    color: tmiArea.containsMouse ? theme.surfaceHover : "transparent"
                    Row {
                        anchors.fill: parent
                        anchors.leftMargin: 8
                        spacing: 8
                        QbzIcon { name: modelData.icon; width: 15; height: 15; anchors.verticalCenter: parent.verticalCenter; tintName: "secondary" }
                        Text {
                            height: parent.height
                            width: parent.width - 23
                            text: modelData.label
                            color: theme.textSecondary
                            font.pixelSize: 13
                            verticalAlignment: Text.AlignVCenter
                            elide: Text.ElideRight
                        }
                    }
                    MouseArea {
                        id: tmiArea
                        anchors.fill: parent
                        hoverEnabled: true
                        cursorShape: Qt.PointingHandCursor
                        onClicked: {
                            topMenu.close()
                            var a = modelData.action
                            // Library arm: the same five rows over the
                            // library tab's list — shuffle through the
                            // library play-all seam, the three enqueues
                            // through the bulk funnel with the whole list,
                            // and the picker over that list (the
                            // `playlist-all` branch below reads the mode).
                            if (topMenu.forLibrary && a !== "playlist-all") {
                                var lib = root.libTrackIds()
                                if (lib.length === 0) return
                                if (a === "shuffle-all") QbzLibrary.libraryPlayAll(JSON.stringify(lib), true)
                                else if (a === "next-all") QbzPlayer.bulkTracksAction(JSON.stringify(lib), "play-next", "artist", String(artist.id || ""))
                                else if (a === "later-all") QbzPlayer.bulkTracksAction(JSON.stringify(lib), "play-later", "artist", String(artist.id || ""))
                                else if (a === "queue-all") QbzPlayer.bulkTracksAction(JSON.stringify(lib), "queue", "artist", String(artist.id || ""))
                                return
                            }
                            if (a === "shuffle-all") QbzPlayer.playArtistTop(true)
                            // "Play all next" INSERTS at the cursor; it does
                            // not replay the artist. It used to call
                            // playArtistTop(false) — "Play all" — so the row
                            // labelled "next" wiped the queue and started
                            // over (ArtistPageView's twin in Slint enqueues,
                            // main.rs:15301).
                            else if (a === "next-all") QbzPlayer.enqueueArtistTop("next")
                            // #442 block tail — enqueue_track_list_mode's
                            // "later" arm, same funnel next-all/queue-all use.
                            else if (a === "later-all") QbzPlayer.enqueueArtistTop("later")
                            else if (a === "queue-all") QbzPlayer.enqueueArtistTop("queue")
                            else if (a === "playlist-all") {
                                // ArtistPageView.slint:797-802
                                // `top-tracks-menu-action("playlist-all")` —
                                // the picker over the section's tracks. `root
                                // .topTracks` is the FILTERED list, which is
                                // what `ArtistState.top-tracks` holds too
                                // (artist.rs filters into the state, the view
                                // never sees the raw list). Every row here is
                                // a Qobuz catalog track (`/artist/page`
                                // top_tracks), so the catalog arm is correct.
                                var ids = []
                                if (topMenu.forLibrary) ids = root.libTrackIds()
                                else for (var i = 0; i < root.topTracks.length; i++)
                                    ids.push(String(root.topTracks[i].id))
                                if (ids.length > 0)
                                    QbzPlaylistPicker.openForTracks(JSON.stringify(ids))
                            }
                        }
                    }
                }
            }
        }

    // --- Artist portrait: menu + lightbox -----------------------------------
    // View-root siblings, never descendants of the portrait frame (the frame
    // is a 200px circle; anything inside it would be masked away).

    /// Best available portrait source for the lightbox: the custom override
    /// first, then the file the artwork pipeline ALREADY downloaded for this
    /// page, then the remote URL as a last resort.
    ///
    /// Deliberate divergence from AlbumView.bestCoverSource(), which goes
    /// straight to the remote URL and re-downloads a file it already has on
    /// disk. Preferring the cache also matters more here: the artist `large`
    /// segment is the ORIGINAL upload (measured on this machine's cache:
    /// n=149, median 1439px, max 5679px), so the fetch it avoids is a big one.
    function bestArtistImage() {
        var custom = artist.customImageUrl || ""
        if (custom !== "") return custom
        var cached = root.coverMap[artist.artUrl] || ""
        if (cached !== "") return cached
        return artist.artUrl || ""
    }

    /// The portrait menu's rows, rebuilt per open so Add/Change/Remove track
    /// the live flag (ArtistPageView.slint:307-351, plus "View image" — the
    /// lightbox entry, this port's addition and the twin of the album menu's
    /// "View cover").
    ///
    /// The two url-only rows are hidden when there is nothing for them to act
    /// on. The reference passes `ArtistState.artwork-url` blindly and shows
    /// them even for an artist Qobuz has no portrait for, where they do
    /// nothing — a small, deliberate divergence rather than a copied hole.
    /// "Save as…" survives an empty url when a custom image exists, because
    /// that path saves the local file.
    function buildPortraitMenuModel() {
        var rows = []
        if (artist.hasCustomImage === true) {
            rows.push({ "label": QbzSession.tr("Change image", QbzSession.trRev), "icon": "image-plus", "action": "add" })
            rows.push({ "label": QbzSession.tr("Remove image", QbzSession.trRev), "icon": "trash-2", "action": "remove" })
        } else {
            rows.push({ "label": QbzSession.tr("Add image", QbzSession.trRev), "icon": "image-plus", "action": "add" })
        }
        if (root.bestArtistImage() !== "")
            rows.push({ "label": QbzSession.tr("View image", QbzSession.trRev), "icon": "eye", "action": "view" })
        if ((artist.artUrl || "") !== "")
            rows.push({ "label": QbzSession.tr("Open in browser", QbzSession.trRev), "icon": "external-link", "action": "browser" })
        if ((artist.artUrl || "") !== "" || artist.hasCustomImage === true)
            rows.push({ "label": QbzSession.tr("Save as…", QbzSession.trRev), "icon": "cloud-download", "action": "save" })
        return rows
    }

    QbzContextMenu {
        id: portraitMenu
        menuWidth: 196
        onAboutToShow: portraitMenuRepeater.model = root.buildPortraitMenuModel()
        Repeater {
            id: portraitMenuRepeater
            model: []
            delegate: Rectangle {
                required property var modelData
                width: parent ? parent.width : 0
                height: 33
                radius: 5
                color: pmiArea.containsMouse ? theme.surfaceHover : "transparent"
                Row {
                    anchors.fill: parent
                    anchors.leftMargin: 8
                    spacing: 8
                    QbzIcon { name: modelData.icon; width: 15; height: 15; anchors.verticalCenter: parent.verticalCenter; tintName: "secondary" }
                    Text {
                        height: parent.height
                        width: parent.width - 23
                        text: modelData.label
                        color: theme.textSecondary
                        font.pixelSize: 13
                        verticalAlignment: Text.AlignVCenter
                        elide: Text.ElideRight
                    }
                }
                MouseArea {
                    id: pmiArea
                    anchors.fill: parent
                    hoverEnabled: true
                    cursorShape: Qt.PointingHandCursor
                    onClicked: {
                        portraitMenu.close()
                        var a = modelData.action
                        // The store is keyed by NAME (ArtistPageView.slint:312),
                        // so the name — not the id — is what travels.
                        if (a === "add") QbzArtist.imageAddCustom(artist.name || "", artist.artUrl || "")
                        else if (a === "remove") QbzArtist.imageRemoveCustom(artist.name || "", artist.artUrl || "")
                        else if (a === "view") portraitLightbox.openWith(root.bestArtistImage())
                        else if (a === "browser") QbzShell.openExternalUrl(artist.artUrl)
                        else if (a === "save") QbzArtist.imageSaveAs(artist.name || "", artist.artUrl || "")
                    }
                }
            }
        }
    }

    CoverLightbox { id: portraitLightbox }
}