import { LitElement, html, css, nothing } from 'lit';
import { customElement, property, state, query } from 'lit/decorators.js';
import { classMap } from 'lit/directives/class-map.js';
import { designTokens } from '../../styles/tokens.css';
import { srOnly } from '../../styles/sr-only.css';
import {
    LookupReleaseGroup,
    BrowseReleases,
    GetThumbnail,
} from '@go/explore/service.js';
import {
    GetAlbumTracks,
    GetAlbumCompleteness,
    GetFilePathsByRecordingMBIDs,
} from '@go/library/library.js';
import * as library from '@go/library/models.js';
import type * as download from '@go/download/models.js';
import type * as explore from '@go/explore/models.js';
type MBReleaseGroup = explore.MBReleaseGroup;
type MBRelease = explore.MBRelease;
type MBTrack = explore.MBTrack;
import { exploreCache } from '../../store/explore-cache';
import { libraryStore } from '../../store/library-store';
import { creditLink, exploreLinkStyles } from '../../utils/explore-link';
import { creditStore } from '@store/credit-store';
import { describeError } from '../../utils/describe-error';
import { EventsOn } from '@runtime/runtime';
import { Events } from '../../events';
import '@awesome.me/webawesome/dist/components/icon/icon.js';
import '../library-status-indicator/library-status-indicator.js';
import { libraryStatusFor } from '@utils/library-status';
import type { LibraryStatus } from '../library-status-indicator/library-status-indicator.js';
import '../catalog-scope-notice/catalog-scope-notice.js';
import type { CatalogScope } from '../catalog-scope-notice/catalog-scope-notice.js';
import '@awesome.me/webawesome/dist/components/button/button.js';
import '../download-picker/download-picker';
import { downloadStore } from '../../store/download-store';
import { queueStore } from '../../store/queue-store';
import type { QueueSource } from '../../store/queue-store';
import { notificationStore } from '../../store/notification-store';
import '../notifications/inline-notice';
import {
    ContextMenuController,
    contextMenuStyles,
    isContextMenuKey,
} from '@utils/context-menu-controller.js';
import type { ContextMenuHost } from '@utils/context-menu-controller.js';
import '@awesome.me/webawesome/dist/components/popup/popup.js';
import type WaPopup from '@awesome.me/webawesome/dist/components/popup/popup.js';
import '@awesome.me/webawesome/dist/components/dropdown-item/dropdown-item.js';
import { dictByName } from '@utils/binding';
import type { TrackDetails } from '@components/track-details/track-details.js';
import { showTrackDetailsForPath } from '@utils/track-details-opener.js';
import '@components/playlist-picker/playlist-picker.js';

/**
 * The region the album header's own failures are rendered in.
 *
 * "Inline" says *not global*, not *where* — so the region is named
 * once, here, rather than spelled at each call site.
 */
export const ExploreAlbumRegion = 'explore-album';

/**
 * How long to wait on a background release browse that has reported
 * neither success nor failure before treating it as gone.  See
 * `armReleasesFallback` for why this is generous.
 */
const RELEASES_FALLBACK_MS = 60000;

/* ── Utility functions (duplicated per Knowledge Pattern #9 — no cross-component imports) ── */

/** The earliest release date in a group, for tie-breaking. */
function earliestDate(releases: MBRelease[]): string {
    let earliest = '\uffff';

    for (const r of releases) {
        const d = r.date || '\uffff';
        if (d < earliest) earliest = d;
    }

    return earliest;
}

function extractYear(dateStr: string): string {
    if (!dateStr) return '';
    return dateStr.substring(0, 4);
}

/**
 * Convert a duration in milliseconds to a human-readable "m:ss" string.
 * Returns "0:00" for zero/negative/NaN values.
 */
function formatDuration(ms: number): string {
    if (!ms || ms <= 0) return '0:00';
    const totalSeconds = Math.round(ms / 1000);
    const minutes = Math.floor(totalSeconds / 60);
    const seconds = totalSeconds % 60;
    return `${minutes}:${String(seconds).padStart(2, '0')}`;
}

/* ── Types ── */

interface ReleaseCluster {
    representative: MBRelease;
    allReleases: MBRelease[];
    fingerprint: string;
    /** Standard-version score, computed by buildClusters. */
    score: number;
}

/** Synthetic kinds — virtual entries pinned at the top of the dropdown. */
type SyntheticKind = 'standard' | 'library';

/** Unified version-entry shape covering both synthetic and real clusters. */
interface VersionEntry {
    /** Stable identifier for the dropdown <option value="...">. */
    key: string;
    /** Display label for the dropdown option. */
    label: string;
    /** Tooltip / sub-label. */
    sublabel: string;
    /** Visible group: "Aggregate" (synthetics) vs "Versions" (real clusters). */
    group: 'aggregate' | 'cluster';
    /** Synthetic identifier when group is aggregate. */
    syntheticKind?: SyntheticKind;
    /** Track set to render when this entry is selected. */
    tracks: MBTrack[];
    /** Underlying cluster for real entries; undefined for synthetics. */
    cluster?: ReleaseCluster;
    /**
     * This real version is the one on disk.  It carries a marker rather
     * than being replaced by a synthetic "Your Library" entry, so the
     * user can still see *which* release they own.
     */
    inLibrary?: boolean;
    /**
     * For synthetics: the cluster (or synthetic source) that this entry
     * was *built from*, used for the metadata header.  For real clusters,
     * always equal to `cluster`.
     */
    backingCluster?: ReleaseCluster;
}

/* ── Component ── */

@customElement('explore-album-details')
export class ExploreAlbumDetails extends LitElement implements ContextMenuHost {
    /* ── Public attributes ── */

    @property({ type: String, attribute: 'release-group-mbid' })
    releaseGroupMBID = '';

    @property({ type: String, attribute: 'album-name' })
    albumName = '';

    @property({ type: String, attribute: 'artist-name' })
    artistName = '';

    @property({ type: String, attribute: 'highlight-track-mbid' })
    highlightTrackMBID = '';

    /** Highlight target for a track with no recording MBID — the only
     * handle an untagged track has is its title. */
    @property({ type: String, attribute: 'highlight-track-title' })
    highlightTrackTitle = '';

    @property({ type: Number, attribute: 'local-album-id' })
    localAlbumId = 0;

    /* ── Internal state ── */

    @state() private releaseGroup: MBReleaseGroup | null = null;
    @state() private releases: MBRelease[] = [];
    @state() private loadingInfo = true;
    @state() private loadingReleases = true;
    @state() private errorInfo = '';
    @state() private errorReleases = '';
    /** True once the versions/tracklist on screen came from the catalog
     * rather than standing in from the local library. */
    @state() private catalogReleasesLoaded = false;
    /** True once the catalog has been *shown* not to answer for this
     * release group — the browse errored, or it came back empty after
     * the background fetch reported itself done.  Only this puts the
     * page in `unavailable`; a fetch that is merely slow does not. */
    @state() private catalogFailed = false;
    /** How much of this album the local files say is here, or null when
     * the album is not in the library at all. */
    @state() private completeness: library.AlbumCompleteness | null = null;
    /** Unified entries shown in the dropdown — synthetics first, then real clusters. */
    @state() private versionEntries: VersionEntry[] = [];
    /** Currently-selected dropdown entry (by VersionEntry.key). */
    @state() private selectedVersionKey: string = '';
    @state() private coverArtURL = '';

    /**
     * The local album's own tracks — the authoritative answer to "what
     * is actually on disk," independent of `this.releases`, which
     * `fetchReleases()` fully replaces with catalog data as soon as it
     * lands. "Your Library" is built from this, so a slow or wrong
     * catalog match can never make it show a different release's
     * tracklist than what the files are actually tagged to.
     */
    @state() private localTracks: MBTrack[] = [];

    /**
     * The file behind each displayed track, resolved once when the
     * tracklist settles rather than per click.
     *
     * This is the page's one answer to "do I own this". It used to be
     * asked three different ways — a local album id, the backend's
     * cross-reference, a cached MBID match, or *any* track flagged
     * inLibrary — none of which is "there is a file", and then answered
     * a fourth way at the moment the user clicked something. So a row
     * could render owned, offer Play, and fail; on a real library 129
     * catalog rows were in exactly that state.
     *
     * A path here means the track plays. Nothing else on this page is
     * allowed to mean it.
     */
    @state() private filePaths = new Map<string, string>();

    /**
     * Which MBIDs have been *asked* about, which is not the same as
     * which resolved.
     *
     * A track the library does not have never lands in `filePaths`, so
     * a guard keyed on the answer asks about it again on every render —
     * an unbounded query loop for exactly the tracks the user does not
     * own. This is not `@state`: it records work done, and changing it
     * must not schedule a render.
     */
    private askedFor = new Set<string>();

    /** Open state of the "find this album" dialog. */
    @state() private pickerOpen = false;

    /** True once a download client is configured and enabled. */
    @state() private canDownload = false;

    /** True when this album already has a request. */
    @state() private isRequested = false;

    /**
     * Library to attach downloads/requests to.  The library-filter UI that
     * would normally set libraryStore's selection isn't mounted anywhere
     * currently, so that selection is always null here — falling back to
     * `?? 0` would send a library id that doesn't exist and fail the
     * download_requests/download_wants foreign key.  Resolved to the
     * selected library, or the first one if none is selected.
     */
    @state() private targetLibraryId: number | null = null;

    /** Unsubscribe handle for the download store. */
    private downloadUnsub: (() => void) | null = null;

    /* ── Track context menu ── */

    private ctxMenu = new ContextMenuController(this);

    /** The track the open context menu applies to. */
    @state() private ctxMenuTrack: MBTrack | null = null;

    @query('#track-context-menu')
    private contextMenuPopup!: WaPopup;

    @query('#playlist-submenu')
    private playlistSubmenuPopup?: WaPopup;

    @query('track-details')
    private trackDetailsDialog?: TrackDetails;

    // -- ContextMenuHost interface --

    getContextMenuPopup(): WaPopup | undefined {
        return this.contextMenuPopup;
    }

    getPlaylistSubmenuPopup(): WaPopup | undefined {
        return this.playlistSubmenuPopup;
    }

    onContextMenuClose(): void {
        this.ctxMenuTrack = null;
    }

    /* ── Styles ── */

    static override styles = [
        designTokens,
        exploreLinkStyles,
        contextMenuStyles,
        srOnly,
        css`
            :host {
                display: flex;
                flex-direction: column;
                overflow: hidden;
                height: 100%;
                box-sizing: border-box;
            }

            /* ── Header ── */
            .album-header {
                display: flex;
                align-items: center;
                gap: 20px;
                padding: 16px 20px;
                flex-shrink: 0;
                border-bottom: 1px solid
                    var(--yj-border-subtle, rgba(255, 255, 255, 0.06));
            }

            .back-button {
                display: flex;
                align-items: center;
                justify-content: center;
                width: 32px;
                height: 32px;
                border: none;
                border-radius: 50%;
                background: var(--yj-bg-overlay, rgba(255, 255, 255, 0.06));
                color: var(--yj-text-primary, #fff);
                cursor: pointer;
                flex-shrink: 0;
                transition: background-color 0.15s ease;
            }

            .back-button:hover {
                background: var(--yj-bg-hover, rgba(255, 255, 255, 0.12));
            }

            .back-button wa-icon {
                font-size: 16px;
            }

            .cover-art-container {
                width: 200px;
                height: 200px;
                border-radius: 6px;
                overflow: hidden;
                background: linear-gradient(
                    135deg,
                    var(--yj-bg-overlay, #404040) 0%,
                    var(--yj-bg-surface, #282828) 100%
                );
                display: flex;
                align-items: center;
                justify-content: center;
                flex-shrink: 0;
                position: relative;
            }

            .cover-art-container img {
                width: 100%;
                height: 100%;
                object-fit: cover;
                display: block;
            }

            .cover-art-fallback {
                display: flex;
                align-items: center;
                justify-content: center;
                width: 100%;
                height: 100%;
                position: absolute;
                inset: 0;
            }

            .cover-art-fallback wa-icon {
                color: var(--yj-text-tertiary, #888);
                font-size: 48px;
                opacity: 0.5;
            }

            .album-info {
                display: flex;
                flex-direction: column;
                gap: 4px;
                min-width: 0;
            }

            .album-title {
                font-size: 24px;
                font-weight: 700;
                color: var(--yj-text-primary, #fff);
                margin: 0;
                line-height: 1.2;
                display: flex;
                align-items: center;
                gap: 12px;
                min-width: 0;
            }

            .album-title-text {
                white-space: nowrap;
                overflow: hidden;
                text-overflow: ellipsis;
                min-width: 0;
            }

            .album-title library-status-indicator {
                flex-shrink: 0;
            }

            .album-actions {
                display: flex;
                flex-wrap: wrap;
                align-items: center;
                gap: 8px;
                margin-top: 8px;
            }

            /*
             * The sentence under a partial Play button. It repeats the
             * count on the button on purpose: the button has to be
             * short and the claim has to be unambiguous, and "Play 7 of
             * 12" alone does not say whether the other five are missing
             * or merely unselected.
             */
            .album-owned-note {
                font-size: var(--yj-text-sm);
                color: var(--yj-text-secondary, #aaa);
            }

            .album-artist {
                font-size: var(--yj-text-lg);
                color: var(--yj-text-secondary, #b3b3b3);
                white-space: nowrap;
                overflow: hidden;
                text-overflow: ellipsis;
            }

            .album-meta {
                font-size: var(--yj-text-md);
                color: var(--yj-text-tertiary, #888);
                display: flex;
                align-items: center;
                gap: 6px;
                flex-wrap: wrap;
            }

            .meta-separator {
                opacity: 0.4;
            }

            /* ── Scrollable content ── */
            .content {
                flex: 1;
                overflow-y: auto;
                padding: 20px 24px 32px;
                display: flex;
                flex-direction: column;
                gap: 24px;
            }

            /* ── Section headers ── */
            .section-header {
                font-size: 11px;
                font-weight: 600;
                color: var(--yj-text-secondary, #b3b3b3);
                text-transform: uppercase;
                letter-spacing: 0.05em;
                margin: 0 0 12px;
            }

            /* ── Loading / error states ── */
            .section-loading {
                color: var(--yj-text-secondary, #b3b3b3);
                font-size: var(--yj-text-md);
                animation: pulse 1.5s ease-in-out infinite;
            }

            @keyframes pulse {
                0%,
                100% {
                    opacity: 1;
                }
                50% {
                    opacity: 0.5;
                }
            }

            .section-error {
                display: flex;
                align-items: center;
                gap: 6px;
                color: var(--yj-text-secondary, #b3b3b3);
                font-size: var(--yj-text-sm);
            }

            .section-error wa-icon {
                color: #e5534b;
                font-size: var(--yj-icon-sm);
                flex-shrink: 0;
            }

            /* ── Version selector ── */
            .version-selector {
                display: flex;
                flex-direction: column;
                gap: 8px;
                padding: 10px 16px;
                background: var(--yj-surface-1, rgba(255, 255, 255, 0.04));
                border-radius: 8px;
            }

            .version-selector-row {
                display: flex;
                align-items: center;
                gap: 10px;
            }

            .version-selector label {
                font-size: var(--yj-text-sm);
                color: var(--yj-text-secondary, #b3b3b3);
                font-weight: 600;
                text-transform: uppercase;
                letter-spacing: 0.04em;
                white-space: nowrap;
                flex-shrink: 0;
            }

            .version-selector select {
                flex: 1;
                min-width: 0;
                padding: 6px 10px;
                background: var(--yj-bg-overlay, rgba(255, 255, 255, 0.06));
                color: var(--yj-text-primary, #fff);
                border: 1px solid var(--yj-border-subtle, rgba(255, 255, 255, 0.08));
                border-radius: 6px;
                font-size: var(--yj-text-md);
                font-family: inherit;
                cursor: pointer;
                appearance: none;
                -webkit-appearance: none;
                background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='12' height='12' viewBox='0 0 12 12'%3E%3Cpath fill='%23888' d='M3 5l3 3 3-3'/%3E%3C/svg%3E");
                background-repeat: no-repeat;
                background-position: right 8px center;
                padding-right: 28px;
            }

            .version-selector select:focus {
                outline: none;
                border-color: var(--yj-border-focus, rgba(255, 255, 255, 0.2));
            }

            .version-selector select option {
                background: var(--yj-bg-surface, #1e1e1e);
                color: var(--yj-text-primary, #fff);
            }

            .version-meta {
                font-size: var(--yj-text-xs);
                color: var(--yj-text-tertiary, #888);
                line-height: 1.4;
                padding-left: 2px;
            }

            /* ── Tracklist ── */
            .tracklist {
                display: flex;
                flex-direction: column;
            }

            .disc-separator {
                display: flex;
                align-items: center;
                gap: 12px;
                padding: 12px 0 8px;
            }

            .disc-separator::before,
            .disc-separator::after {
                content: '';
                flex: 1;
                height: 1px;
                background: var(--yj-border-subtle, rgba(255, 255, 255, 0.06));
            }

            .disc-label {
                font-size: var(--yj-text-xs);
                font-weight: 600;
                color: var(--yj-text-tertiary, #888);
                text-transform: uppercase;
                letter-spacing: 0.05em;
                white-space: nowrap;
            }

            .track-row {
                display: flex;
                align-items: center;
                gap: 12px;
                padding: 7px 12px;
                border-radius: 6px;
                cursor: default;
                transition: background 0.1s ease;
            }

            .track-row.owned {
                cursor: pointer;
            }

            .track-row:hover {
                background: var(
                    --yj-bg-overlay,
                    rgba(255, 255, 255, 0.04)
                );
            }

            .track-row.highlighted {
                background: var(
                    --yj-bg-overlay,
                    rgba(255, 255, 255, 0.04)
                );
            }

            .track-row:focus-visible {
                outline: 2px solid var(--yj-accent-text, #ffd43b);
                outline-offset: -2px;
            }

            .track-position {
                width: 28px;
                text-align: right;
                color: var(--yj-text-tertiary, #888);
                font-size: var(--yj-text-md);
                font-variant-numeric: tabular-nums;
                flex-shrink: 0;
            }

            .track-title {
                flex: 1;
                min-width: 0;
                font-weight: 500;
                color: var(--yj-text-primary, #fff);
                font-size: var(--yj-text-md);
                white-space: nowrap;
                overflow: hidden;
                text-overflow: ellipsis;
            }

            .track-duration {
                color: var(--yj-text-tertiary, #888);
                font-size: var(--yj-text-sm);
                font-variant-numeric: tabular-nums;
                flex-shrink: 0;
                white-space: nowrap;
            }

            /* A track the library does not have, on the pattern a
             * streaming service uses for something it cannot play: the
             * row stays, dimmed, so the album reads as the album rather
             * than as the subset that happens to be here.
             *
             * The dimming is a colour, so it cannot be the only signal
             * — the row also carries aria-disabled, which is what
             * reaches anyone not seeing it.  Secondary rather than
             * tertiary because the row's hover background is
             * bgOverlay, which tertiary does not clear. */
            .track-row.unowned .track-title {
                color: var(--yj-text-secondary, #b3b3b3);
                font-weight: 400;
            }

            /* The request control is offered on every row that has
             * something to request, and is not revealed on hover.
             *
             * It used to be transparent until the row was hovered or
             * focused, on the reasoning that a column of plus signs
             * down a mostly-owned album is clutter. That reasoning was
             * inherited from the green ticks it replaced and does not
             * survive the rule those were removed for: a tick marked
             * the *common* case, while this marks the rows that are
             * **not** here. A mark on the exception is the information
             * on this page — and one that appears only under the
             * pointer cannot be seen, counted, or reached by anyone
             * driving this with a finger. */
            .track-row .track-request {
                flex-shrink: 0;
            }
        `,
    ];

    /* ── Lifecycle ── */

    private unsubReleasesReady?: () => void;
    private unsubReleasesFailed?: () => void;
    /** Release-group MBIDs whose AlbumReleasesReady event we've handled,
     * so a background BrowseReleases fetch re-hydrates versions once. */
    private releasesReloaded = new Set<string>();
    /** Fallback timer that stops the versions spinner if the background
     * BrowseReleases fetch never signals readiness. */
    private releasesFallbackTimer?: number;

    /** Unsubscribes the credit-arrival repaint. */
    private creditsUnsub?: () => void;

    override connectedCallback() {
        super.connectedCallback();

        this.creditsUnsub = creditStore.subscribe(() => {
            this.requestUpdate();
        });
        if (this.releaseGroupMBID || this.localAlbumId) {
            void this.loadAllData();
        }

        // The download button only appears once a client is connected,
        // so this tracks the provider list rather than assuming.
        //
        // The `requestUpdate` is what makes the *tracklist's* badges
        // move.  Both assignments below are reactive fields, so Lit
        // repaints when either changes — but a track request changes
        // neither: `canDownload` is about providers and `isRequested`
        // is about this album's own release group.  Each row's badge
        // reads `libraryStatusFor(false, track.mbid)` at render time,
        // which is a dependency on the store that Lit cannot see, so
        // clicking one filed the request and left the plus exactly
        // where it was.  The other three hosts rendering these badges
        // (`explore-artist-details`, `explore-view`, `top-results-row`)
        // have always asked for the repaint here; this one did not.
        this.downloadUnsub = downloadStore.subscribe(() => {
            this.canDownload = downloadStore.available;
            this.syncRequested();
            this.requestUpdate();
        });

        void downloadStore.init().then(() => {
            this.canDownload = downloadStore.available;
            this.syncRequested();
            this.requestUpdate();
        });

        void this.resolveTargetLibraryId();

        // A background BrowseReleases fetch (cold album, versions +
        // tracklist not cached yet) finished — re-fetch the versions once
        // per release group so they fill in without the initial request
        // having blocked on a live MusicBrainz browse.
        this.unsubReleasesReady = EventsOn(
            Events.AlbumReleasesReady,
            (mbid: string) => {
                if (mbid !== this.releaseGroupMBID) return;
                if (this.releasesReloaded.has(mbid)) return;

                if (this.releasesFallbackTimer) clearTimeout(this.releasesFallbackTimer);
                this.releasesReloaded.add(mbid);
                void this.fetchReleases(mbid);
            },
        );

        // The same browse reporting that it failed.  This is the only
        // prompt reason to say the catalog is unavailable — before it,
        // the page had to infer a failure from a deadline, which a
        // browse queued behind PrefetchReleases on a 1 req/s limiter
        // misses routinely while succeeding.
        this.unsubReleasesFailed = EventsOn(
            Events.AlbumReleasesFailed,
            (mbid: string) => {
                if (mbid !== this.releaseGroupMBID) return;

                if (this.releasesFallbackTimer) clearTimeout(this.releasesFallbackTimer);
                this.releasesReloaded.add(mbid);
                this.catalogFailed = true;
                this.loadingReleases = false;
            },
        );
    }

    override disconnectedCallback() {
        super.disconnectedCallback();
        this.creditsUnsub?.();
        this.creditsUnsub = undefined;
        this.downloadUnsub?.();
        this.downloadUnsub = null;
        this.unsubReleasesReady?.();
        this.unsubReleasesFailed?.();
        if (this.releasesFallbackTimer) clearTimeout(this.releasesFallbackTimer);
    }

    /**
     * Arm a one-shot fallback for the case neither event covers: the
     * background browse neither finished nor reported an error, because
     * it hung.  Both outcomes now emit, so this is a backstop rather
     * than the primary verdict — and it is long, because the thing it
     * used to cut short was a browse that was going to succeed.
     *
     * A cold browse waits on a 1 req/s limiter shared with
     * PrefetchReleases, which fires up to eight of them when an artist
     * page renders — and an album is almost always opened from one.  So
     * eight seconds of queueing before the request starts is the normal
     * path, not the tail, and the old 12 s deadline was reporting a
     * healthy fetch as a catalog failure.
     */
    private armReleasesFallback(mbid: string) {
        if (this.releasesFallbackTimer) clearTimeout(this.releasesFallbackTimer);

        this.releasesFallbackTimer = window.setTimeout(() => {
            if (this.releasesReloaded.has(mbid)) return;

            this.releasesReloaded.add(mbid);
            this.catalogFailed = true;
            if (this.releases.length === 0) this.loadingReleases = false;
        }, RELEASES_FALLBACK_MS);
    }

    /** Whether we've already scrolled to the highlight target. */
    private hasScrolledToHighlight = false;

    override updated() {
        // Whatever is displayed needs its files known, and the
        // tracklist can change from four directions - the local
        // hydrate, the catalog browse, the cluster build, the version
        // dropdown. Asking here covers all of them; resolveFilePaths
        // returns immediately once every displayed MBID is in the map,
        // so this settles after one pass.
        void this.resolveFilePaths();

        if (
            (this.highlightTrackMBID || this.highlightTrackTitle) &&
            !this.hasScrolledToHighlight &&
            !this.loadingReleases
        ) {
            const el = this.highlightTrackMBID
                ? this.shadowRoot?.querySelector<HTMLElement>(
                      `[data-track-mbid="${this.highlightTrackMBID}"]`,
                  )
                : this.findRowByTitle(this.highlightTrackTitle);

            if (el) {
                this.hasScrolledToHighlight = true;

                // Apply highlight imperatively — avoids CSS
                // transition/animation conflicts with the hover
                // transition on .track-row.
                const hoverBg = 'rgba(255, 255, 255, 0.04)';

                requestAnimationFrame(() => {
                    el.scrollIntoView({
                        behavior: 'smooth',
                        block: 'center',
                    });

                    // Two quick pulses after scroll settles.
                    setTimeout(() => {
                        el.style.transition = 'background 0.22s ease-in';
                        el.style.background = hoverBg;

                        setTimeout(() => {
                            el.style.transition = 'background 0.22s ease-out';
                            el.style.background = '';

                            setTimeout(() => {
                                el.style.transition = 'background 0.22s ease-in';
                                el.style.background = hoverBg;

                                setTimeout(() => {
                                    el.style.transition = 'background 0.22s ease-out';
                                    el.style.background = '';

                                    setTimeout(() => {
                                        el.style.transition = 'background 0.22s ease-in';
                                        el.style.background = hoverBg;

                                        setTimeout(() => {
                                            el.style.transition = 'background 0.22s ease-out';
                                            el.style.background = '';
                                        }, 840);
                                    }, 112);
                                }, 560);
                            }, 112);
                        }, 560);
                    }, 300);
                });
            }
        }
    }

    /**
     * Locate a track row by title, for tracks with no recording MBID.
     * Matched in JS rather than by attribute selector because titles
     * contain quotes and other things a selector cannot carry.
     */
    private findRowByTitle(title: string): HTMLElement | null {
        const wanted = title.trim().toLowerCase();
        const rows = this.shadowRoot?.querySelectorAll<HTMLElement>(
            '.track-row[data-track-title]',
        );

        for (const row of rows ?? []) {
            if ((row.dataset.trackTitle ?? '').toLowerCase() === wanted) {
                return row;
            }
        }

        return null;
    }

    /* ── Data Loading ── */

    private async loadAllData() {
        const mbid = this.releaseGroupMBID;

        // Reset state for a clean reload (handles toggle switches).
        this.errorInfo = '';
        this.errorReleases = '';
        this.loadingInfo = true;
        this.loadingReleases = true;
        this.catalogReleasesLoaded = false;
        this.catalogFailed = false;
        this.completeness = null;
        this.releases = [];
        this.versionEntries = [];
        this.selectedVersionKey = '';
        this.localTracks = [];
        this.filePaths = new Map();
        this.askedFor = new Set();

        // Local-only album (no MBID) — populate entirely from library.
        if (!mbid && this.localAlbumId) {
            await this.hydrateLocalOnly();
            await this.loadCompleteness();

            return;
        }


        // Phase 0: hydrate from explore cache (instant).
        const cached = exploreCache.getAlbum(mbid);
        if (cached) {
            this.releaseGroup = {
                mbid: cached.mbid,
                title: cached.title,
                artistCredit: cached.artistName,
                firstReleaseDate: cached.year || '',
                primaryType: 'Album',
            } as MBReleaseGroup;
            this.loadingInfo = false;
        }

        // Phase 1: hydrate tracklist from local library if available.
        // Awaited for the side effect of populating the local
        // tracklist; the return value isn't currently consumed.
        await this.hydrateFromLibrary(mbid);

        // `hydrateFromLibrary` finds the library album by MBID or by a
        // name+artist match — if the caller already knows the local
        // album id (the ordinary case, navigated here from the
        // library) and that lookup still missed it, fetch by id
        // directly rather than leaving "Your Library" with nothing to
        // go on.
        if (this.localTracks.length === 0 && this.localAlbumId > 0) {
            await this.loadLocalTracks(this.localAlbumId);
        }

        // Phase 1b: ask the files how much of this album is here.
        const completeness = await this.loadCompleteness();

        // A complete album needs nothing from the catalog, and this is
        // the whole point of asking: the release group is MBID-matched
        // (so the identity is right) and the files' own tags account
        // for every track (so the tracklist is right), which between
        // them are the two things a browse was being spent on.  Opening
        // an owned album is now offline.
        //
        // The catalog still has *versions* — other pressings, editions —
        // and those are not derivable from tags. They stay a click away
        // rather than a page load away.
        if (completeness?.complete) {
            this.loadingReleases = false;
            void this.fetchReleaseGroup(mbid);
            this.resolveCoverArt();

            return;
        }

        // Phase 2: fire API calls independently so each section
        // renders as its data arrives.  Allow the versions section one
        // background-fetch re-fetch and arm a fallback so it can't spin
        // forever if AlbumReleasesReady never arrives.
        this.releasesReloaded.delete(mbid);
        this.armReleasesFallback(mbid);
        void this.fetchReleaseGroup(mbid);
        void this.fetchReleases(mbid);

        // Fire cover art resolution immediately — doesn't wait for release group.
        this.resolveCoverArt();

    }

    /**
     * Hydrate album info and tracklist from the local library store.
     * Uses GetAlbumTracks(album.ID, libraryStore.libraryFilter()) — same local DB call as cover-grid.
     * Returns true if a tracklist was populated from local data.
     */
    /**
     * Populate the view entirely from local library data when the
     * album has no MusicBrainz release group ID.  Uses the local
     * album ID to fetch tracks and resolve metadata.
     */
    private async hydrateLocalOnly() {
        const cachedAlbums = libraryStore.cachedAlbums;
        let libraryAlbum: library.Album | null = null;

        if (cachedAlbums) {
            for (const a of cachedAlbums) {
                if (a.ID === this.localAlbumId) {
                    libraryAlbum = a;
                    break;
                }
            }
        }

        if (libraryAlbum) {
            this.releaseGroup = {
                mbid: '',
                title: libraryAlbum.Name,
                artistCredit: libraryAlbum.ArtistName,
                firstReleaseDate: libraryAlbum.Year ? String(libraryAlbum.Year) : '',
                primaryType: 'Album',
            } as MBReleaseGroup;
        }

        this.loadingInfo = false;

        // Fetch tracks via the same local DB call the cover-grid uses.
        let tracks: Awaited<ReturnType<typeof GetAlbumTracks>>;
        try {
            tracks = await GetAlbumTracks(this.localAlbumId, libraryStore.libraryFilter());
        } catch {
            this.loadingReleases = false;
            return;
        }

        if (!tracks || tracks.length === 0) {
            this.loadingReleases = false;
            return;
        }

        const localTracks = this.mapLocalTracks(tracks);

        this.localTracks = localTracks;

        const localRelease: MBRelease = {
            mbid: '',
            title: libraryAlbum?.Name || this.albumName,
            date: libraryAlbum?.Year ? String(libraryAlbum.Year) : '',
            country: '',
            tracks: localTracks,
        } as MBRelease;

        this.releases = [localRelease];
        this.buildClusters();
        this.loadingReleases = false;
    }

    /**
     * Map local track rows to `MBTrack`s and sort them into disc/track
     * order — the shape every "built from local data" release/entry on
     * this page is made of.
     */
    private mapLocalTracks(
        tracks: Awaited<ReturnType<typeof GetAlbumTracks>>,
    ): MBTrack[] {
        // The rows carry the file paths; this is where they stop being
        // thrown away.
        this.rememberLocalPaths(tracks);

        const mapped: MBTrack[] = (tracks ?? []).map((t) => ({
            mbid: t.RecordingMBID || '',
            title: t.TrackName,
            position: t.TrackNumber || 0,
            length: this.parseDurationMs(t.TrackLength),
            discNumber: t.DiscNumber || 1,
            inLibrary: true,
        } as MBTrack));

        mapped.sort((a, b) => {
            const d = (a.discNumber || 1) - (b.discNumber || 1);
            return d !== 0 ? d : a.position - b.position;
        });

        return mapped;
    }

    /**
     * Read how much of this album is present, from the tags the scan
     * already stored.  No network, one query.
     *
     * Silent on failure: this decides whether to *skip* work and how to
     * draw a badge, so an unanswered question falls back to the old
     * behaviour rather than surfacing an error the user cannot act on.
     */
    private async loadCompleteness(): Promise<library.AlbumCompleteness | null> {
        if (this.localAlbumId <= 0) {
            this.completeness = null;

            return null;
        }

        try {
            this.completeness = await GetAlbumCompleteness(this.localAlbumId);
        } catch {
            this.completeness = null;
        }

        return this.completeness;
    }

    /**
     * Fetch and set `localTracks` directly by local album id — the
     * definite source of truth, used when nothing else has already
     * populated it (see the call site in `loadAllData`).
     */
    private async loadLocalTracks(albumId: number): Promise<void> {
        try {
            const tracks = await GetAlbumTracks(albumId, libraryStore.libraryFilter());

            this.localTracks = this.mapLocalTracks(tracks);
        } catch {
            this.localTracks = [];
        }

        // A catalog fetch may have already built the version list
        // without a "Your Library" entry to point at — rebuild now
        // that there's local data to match against it.
        //
        // Unconditionally, including when the catalog returned nothing:
        // `buildVersionEntries` synthesises the library entry *from*
        // these tracks, so the no-releases case is exactly the one that
        // needs this. Guarded on `releases.length` before, an album the
        // catalog could not answer for showed "No release data
        // available" over a tracklist it was holding in memory.
        this.buildClusters();
    }

    private async hydrateFromLibrary(mbid: string): Promise<boolean> {
        const cachedAlbums = libraryStore.cachedAlbums;
        if (!cachedAlbums) return false;

        // Find the library album: prefer MBID match, fall back to
        // name+artist match for albums without MBID tags.
        let libraryAlbum: typeof cachedAlbums[0] | null = null;

        if (mbid) {
            for (const a of cachedAlbums) {
                if (a.MBID === mbid) {
                    libraryAlbum = a;
                    break;
                }
            }
        }

        if (!libraryAlbum && this.albumName) {
            const targetName = this.albumName.toLowerCase();
            const targetArtist = this.artistName.toLowerCase();

            for (const a of cachedAlbums) {
                if (a.Name.toLowerCase() !== targetName) continue;
                if (targetArtist && a.ArtistName.toLowerCase() !== targetArtist) continue;
                libraryAlbum = a;
                break;
            }
        }

        if (!libraryAlbum) return false;

        // Populate release group info from library if not already set.
        if (!this.releaseGroup) {
            this.releaseGroup = {
                mbid,
                title: libraryAlbum.Name,
                artistCredit: libraryAlbum.ArtistName,
                firstReleaseDate: libraryAlbum.Year ? String(libraryAlbum.Year) : '',
                primaryType: 'Album',
            } as MBReleaseGroup;
            this.loadingInfo = false;
        }

        // Fetch tracks via the same local DB call the cover-grid uses.
        let tracks: Awaited<ReturnType<typeof GetAlbumTracks>>;
        try {
            tracks = await GetAlbumTracks(libraryAlbum.ID, libraryStore.libraryFilter());
        } catch {
            return false;
        }

        if (!tracks || tracks.length === 0) return false;

        const localTracks = this.mapLocalTracks(tracks);

        this.localTracks = localTracks;

        // Wrap into a single MBRelease.
        const localRelease: MBRelease = {
            mbid: '',
            title: libraryAlbum.Name,
            date: libraryAlbum.Year ? String(libraryAlbum.Year) : '',
            country: '',
            tracks: localTracks,
        } as MBRelease;

        this.releases = [localRelease];
        this.buildClusters();
        this.loadingReleases = false;

        return true;
    }

    /**
     * Parse a TrackLength value into milliseconds.
     * Library stores TrackLength as a string of milliseconds (e.g. "180000").
     * Also handles "m:ss" format as a fallback.
     */
    private parseDurationMs(duration: string): number {
        if (!duration) return 0;
        // Check for "m:ss" format
        if (duration.includes(':')) {
            const parts = duration.split(':');
            if (parts.length === 2) {
                const mins = parseInt(parts[0]!, 10);
                const secs = parseInt(parts[1]!, 10);
                if (!isNaN(mins) && !isNaN(secs)) {
                    return (mins * 60 + secs) * 1000;
                }
            }
        }
        // Raw milliseconds string (the library format)
        const n = Number(duration);
        return isNaN(n) ? 0 : n;
    }

    private async fetchReleaseGroup(mbid: string) {
        try {
            this.releaseGroup = await LookupReleaseGroup(mbid);
            this.resolveCoverArt();
        } catch (err) {
            console.error('[explore-album] LookupReleaseGroup error', err);
            this.errorInfo = describeError(
                err,
                'The catalog did not answer for this album.',
            );
        } finally {
            this.loadingInfo = false;
        }
    }

    /**
     * Resolve the album cover art through the backend proxy
     * (local library → disk cache → CAA).
     */
    private resolveCoverArt() {
        if (this.coverArtURL || !this.releaseGroupMBID) return;

        const albumName = this.releaseGroup?.title || this.albumName || '';
        const artistName = this.releaseGroup?.artistCredit || this.artistName || '';

        GetThumbnail(this.releaseGroupMBID, albumName, artistName)
            .then((url) => {
                if (url) {
                    this.coverArtURL = url;
                }
            })
            .catch(() => {});
    }

    private async fetchReleases(mbid: string) {
        try {
            const releases = await BrowseReleases(mbid);

            if (releases && releases.length > 0) {
                // Warm cache hit (or the background re-fetch landed):
                // authoritative MB versions replace any local placeholder.
                this.catalogReleasesLoaded = true;
                this.catalogFailed = false;
                this.releases = releases;
                this.buildClusters();
                this.loadingReleases = false;
                return;
            }

            // Cold miss: BrowseReleases is cache-first + async and the
            // versions/tracklist are still being fetched in the background.
            // Don't clobber a tracklist already hydrated from the library —
            // keep showing it.  Hold the spinner only when there's nothing
            // on screen yet; AlbumReleasesReady (or the fallback) resolves it.
            if (this.releases.length > 0 || this.releasesReloaded.has(mbid)) {
                this.loadingReleases = false;
            }

            // A cold miss after the background fetch already signalled
            // ready is as far as the catalog is going to get: it
            // answered, and the answer was nothing.
            if (this.releasesReloaded.has(mbid)) {
                this.catalogFailed = true;
            }
        } catch (err) {
            console.error('[explore-album] BrowseReleases error', err);
            this.errorReleases = describeError(
                err,
                'The catalog did not answer for this album\u2019s versions.',
            );
            this.loadingReleases = false;
            this.catalogFailed = true;
        }
    }

    /* ── Release Clustering (R026) + Synthetic Versions ── */

    /**
     * Groups releases by identical tracklist fingerprints (ordered
     * recording MBIDs), scores each cluster, then builds the unified
     * version-entry list (synthetics + clusters) for the dropdown.
     */
    /**
     * Fingerprint a tracklist: tracks sorted by (discNumber, position),
     * recording MBIDs joined. Two tracklists with the same fingerprint
     * are the same edition for display purposes — this is also how a
     * local album's own tracks are matched against a catalog cluster
     * for "Your Library" (`buildLibraryEntry`), so a match here is a
     * real one, not a guess.
     */
    private static fingerprint(tracks: MBTrack[]): string {
        const sorted = [...tracks].sort((a, b) => {
            const discDiff = (a.discNumber || 1) - (b.discNumber || 1);
            if (discDiff !== 0) return discDiff;
            return a.position - b.position;
        });

        return sorted.map((t) => t.mbid).join('|');
    }

    /**
     * How many genuinely different tracklists the version entries hold.
     *
     * Deliberately *not* `fingerprint()`, which keys on recording MBIDs
     * alone: a library entry built from untagged files has none, so
     * every such tracklist fingerprints to the same run of empty
     * strings and would compare equal to any other. Falling back to the
     * title lets a local copy be recognised as the same tracklist as
     * the catalog's when that is what it is — which is exactly the case
     * that decides whether the dropdown is a choice or a decoration.
     */
    private distinctTracklistCount(): number {
        // The basis is chosen for the whole comparison, not per track.
        // A per-track `mbid || title` fallback is asymmetric: it only
        // helps when *both* sides lack ids, so an untagged library copy
        // and the catalog's identical tracklist keyed one by title and
        // one by MBID and never compared equal — which put a dropdown
        // on every owned album the moment its catalog data landed, with
        // two options showing the same songs.
        const allTagged = this.versionEntries.every((e) =>
            e.tracks.every((t) => !!t.mbid),
        );

        const seen = new Set<string>();

        for (const entry of this.versionEntries) {
            const key = [...entry.tracks]
                .sort((a, b) => {
                    const discDiff = (a.discNumber || 1) - (b.discNumber || 1);

                    return discDiff !== 0 ? discDiff : a.position - b.position;
                })
                .map(
                    (t) =>
                        `${t.discNumber || 1}:${t.position}:${
                            allTagged ? t.mbid : t.title.trim().toLowerCase()
                        }`,
                )
                .join('|');

            seen.add(key);
        }

        return seen.size;
    }

    /** The set of recording MBIDs on a tracklist, order ignored. */
    private static trackMBIDSet(tracks: MBTrack[]): Set<string> {
        const set = new Set<string>();

        for (const t of tracks) if (t.mbid) set.add(t.mbid);

        return set;
    }

    /** How many recordings differ between two MBID sets. */
    private static symmetricDifferenceSize(a: Set<string>, b: Set<string>): number {
        let diff = 0;

        for (const x of a) if (!b.has(x)) diff++;
        for (const x of b) if (!a.has(x)) diff++;

        return diff;
    }

    /**
     * How many tracks two clusters may differ by and still count as
     * the same edition for display purposes. A bonus track present on
     * one regional pressing and missing from another — or a tagging
     * gap that drops one recording's MBID — produces a different exact
     * fingerprint but isn't a meaningfully different "version" to a
     * listener choosing between them.
     */
    private static readonly NEAR_DUPLICATE_TOLERANCE = 2;

    /**
     * Fold clusters that differ from a larger one by only a couple of
     * tracks into it, so the "Versions" list reflects meaningfully
     * different editions rather than every minor pressing variation.
     * This is the fix for the dropdown getting so long it stopped
     * being useful — trying to give every pressing its own row was the
     * over-categorization problem, not a missing feature.
     *
     * Largest-tracklist-first, so a cluster only ever merges into
     * something at least as big as itself: the result keeps the
     * fuller tracklist and folds the combined release counts into it,
     * rather than the reverse (which would silently drop tracks from
     * what's shown). A cluster with no recording MBIDs at all
     * (unidentifiable) is left alone — there's nothing to compare.
     */
    private mergeNearDuplicateClusters(
        clusters: ReleaseCluster[],
    ): ReleaseCluster[] {
        const sets = new Map<ReleaseCluster, Set<string>>(
            clusters.map((c) => [
                c,
                ExploreAlbumDetails.trackMBIDSet(c.representative.tracks ?? []),
            ]),
        );
        const sorted = [...clusters].sort(
            (a, b) =>
                (b.representative.tracks?.length ?? 0)
                - (a.representative.tracks?.length ?? 0),
        );

        const kept: ReleaseCluster[] = [];
        const keptSets: Set<string>[] = [];

        candidateLoop: for (const candidate of sorted) {
            const candSet = sets.get(candidate)!;

            if (candSet.size > 0) {
                for (let i = 0; i < kept.length; i++) {
                    const diff = ExploreAlbumDetails.symmetricDifferenceSize(
                        candSet,
                        keptSets[i]!,
                    );

                    if (diff <= ExploreAlbumDetails.NEAR_DUPLICATE_TOLERANCE) {
                        kept[i]!.allReleases.push(...candidate.allReleases);
                        continue candidateLoop;
                    }
                }
            }

            kept.push(candidate);
            keptSets.push(candSet);
        }

        return kept.map((c) => ExploreAlbumDetails.withConsensusRepresentative(c));
    }

    /**
     * Re-pick a merged cluster's representative by consensus.
     *
     * Merging compares track *sets*, so a resequenced pressing — same
     * songs, different running order — folds in correctly. But the
     * survivor was whichever release happened to be encountered first,
     * which is browse order and means nothing: one 2021 pressing
     * arriving ahead of eleven 2013 ones made the cluster wear the 2021
     * running order. The user's own files then matched no cluster
     * fingerprint, so the page said their copy "isn't linked to a
     * MusicBrainz release yet" while showing a tracklist in an order
     * almost nothing was pressed in.
     *
     * The representative is the ordering the most releases agree on,
     * earliest release breaking the tie — and the cluster's fingerprint
     * has to move with it, since that is what the library match is
     * tested against.
     */
    private static withConsensusRepresentative(
        cluster: ReleaseCluster,
    ): ReleaseCluster {
        if (cluster.allReleases.length < 2) return cluster;

        const byOrder = new Map<string, MBRelease[]>();

        for (const release of cluster.allReleases) {
            const fp = ExploreAlbumDetails.fingerprint(release.tracks ?? []);
            const group = byOrder.get(fp);

            if (group) {
                group.push(release);
            } else {
                byOrder.set(fp, [release]);
            }
        }

        let bestFingerprint = cluster.fingerprint;
        let best: MBRelease[] | null = null;

        for (const [fp, group] of byOrder) {
            if (
                best === null
                || group.length > best.length
                || (group.length === best.length
                    && earliestDate(group) < earliestDate(best))
            ) {
                best = group;
                bestFingerprint = fp;
            }
        }

        if (!best) return cluster;

        const representative = [...best].sort(
            (a, b) => (a.date || '￿').localeCompare(b.date || '￿'),
        )[0]!;

        return { ...cluster, representative, fingerprint: bestFingerprint };
    }

    private buildClusters() {
        const clusterMap = new Map<string, MBRelease[]>();

        for (const release of this.releases) {
            const tracks = release.tracks ?? [];

            // Releases whose tracks have no MBIDs all collapse together
            // under an "empty" fingerprint, which is intentional —
            // unidentifiable releases shouldn't multiply dropdown noise.
            const fingerprint = ExploreAlbumDetails.fingerprint(tracks);

            const existing = clusterMap.get(fingerprint);
            if (existing) {
                existing.push(release);
            } else {
                clusterMap.set(fingerprint, [release]);
            }
        }

        // Build clusters with earliest-dated representative per group.
        let clusters: ReleaseCluster[] = [];
        for (const [fingerprint, releases] of clusterMap) {
            // Sort releases inside the cluster by date ascending so the
            // earliest serves as the cluster's representative — this
            // also gives us a stable "earliest official date" for
            // scoring later.
            const sorted = [...releases].sort((a, b) => {
                const da = a.date || '\uffff';
                const db = b.date || '\uffff';
                return da.localeCompare(db);
            });

            clusters.push({
                representative: sorted[0]!,
                allReleases: sorted,
                fingerprint,
                score: 0, // filled in below, after merging
            });
        }

        // Fold near-duplicate clusters (one bonus track, a tagging
        // gap) into the closest larger cluster before scoring —
        // otherwise every minor pressing difference gets counted as
        // its own "version" and the size bonus below undercounts how
        // many releases actually agree with each other.
        clusters = this.mergeNearDuplicateClusters(clusters);

        for (const cluster of clusters) {
            cluster.score = this.scoreCluster(cluster);
        }

        // Sort clusters by score descending so the highest-scoring
        // (best "standard" candidate) sits first.  Tiebreak by
        // earliest representative date.
        clusters.sort((a, b) => {
            if (b.score !== a.score) return b.score - a.score;
            const da = a.representative.date || '\uffff';
            const db = b.representative.date || '\uffff';
            return da.localeCompare(db);
        });

        // Build the unified version-entry list (synthetics + clusters).
        this.versionEntries = this.buildVersionEntries(clusters);

        // Default selection: prefer the user's own version — whether
        // that is a marked real release or the synthetic fallback —
        // otherwise the standard version, otherwise the first entry.
        const ownedEntry = this.versionEntries.find((e) => e.inLibrary);
        const libraryEntry = this.versionEntries.find(
            (e) => e.syntheticKind === 'library',
        );
        const standardEntry = this.versionEntries.find(
            (e) => e.syntheticKind === 'standard',
        );
        this.selectedVersionKey =
            ownedEntry?.key
            || libraryEntry?.key
            || standardEntry?.key
            || this.versionEntries[0]?.key
            || '';
    }

    /**
     * Score a cluster as a "standard version" candidate.  Higher is
     * better.  Heuristic: prefer official, non-compilation, earliest
     * tracklists with broad consensus across releases.
     */
    private scoreCluster(cluster: ReleaseCluster): number {
        let score = 0;

        // Earliest-date base score: invert the ISO date so older = higher.
        // A secondary signal now — dampened to a ~26-point range across
        // a century, so it breaks ties among similarly-agreed-upon
        // clusters rather than outweighing the size bonus below. It
        // used to be the dominant term (roughly 1 point per year,
        // undamped), which meant "released a few years earlier" could
        // beat "the edition 20 physical releases actually agree on" —
        // backwards for guessing which release someone means.
        const earliestDate = cluster.representative.date || '';
        if (earliestDate.length >= 4) {
            const year = parseInt(earliestDate.slice(0, 4), 10);
            if (Number.isFinite(year)) {
                // Newer albums have larger year values, but we want
                // older = higher score, so invert against a future
                // ceiling.  Anything older than ~3000 ranks higher.
                score += (3000 - year) / 5;
            }
        }

        // Status filter: any official release in the cluster is a big
        // positive; pseudo / promo / bootleg pull the score down hard.
        let hasOfficial = false;
        let hasBadStatus = false;
        for (const r of cluster.allReleases) {
            const status = (r.status || '').toLowerCase();
            if (status === 'official') {
                hasOfficial = true;
            } else if (
                status === 'bootleg'
                || status === 'promotion'
                || status === 'pseudo-release'
                || status === 'withdrawn'
            ) {
                hasBadStatus = true;
            }
        }
        if (hasOfficial) score += 1000;
        if (hasBadStatus && !hasOfficial) score -= 1000;

        // Release group secondary type penalty: compilations, live
        // albums, remix collections, demos, and DJ mixes are not the
        // "standard" album.  Applies to every cluster equally since
        // it's a release-group property, but we still subtract so the
        // score values are comparable across release groups.
        const secondary = (this.releaseGroup?.secondaryTypes || []).map(
            (s: string) => s.toLowerCase(),
        );
        const badTypes = [
            'compilation',
            'live',
            'remix',
            'demo',
            'dj-mix',
            'soundtrack',
            'mixtape/street',
        ];
        for (const t of secondary) {
            if (badTypes.includes(t)) {
                score -= 500;
                break;
            }
        }

        // Cluster size bonus: the primary signal among same-status
        // clusters.  "How many releases agree on this tracklist" is a
        // much better guess at "the version people mean" than which
        // one happened to ship first — a reissue with dozens of
        // regional pressings sharing a tracklist is the canonical
        // edition even when an obscure early pressing is a few years
        // older.  Log-scaled so a cluster of 10 isn't 10x a cluster of
        // 1, but a cluster of 30 still beats a cluster of 5 by a
        // meaningful amount.
        score += Math.log2(1 + cluster.allReleases.length) * 150;

        return score;
    }

    /**
     * Build the unified version-entry list: a synthetic Library or
     * Standard entry pinned at the top (never both — see
     * `buildLibraryEntry`), followed by the real clusters in score
     * order.
     */
    private buildVersionEntries(clusters: ReleaseCluster[]): VersionEntry[] {
        const entries: VersionEntry[] = [];

        // No catalog clusters yet (still loading, or none exist) — the
        // only thing that can possibly be shown is the local tracklist
        // itself, if there is one.
        if (clusters.length === 0) {
            const libraryOnly = this.buildLibraryEntry(clusters);

            if (libraryOnly) entries.push(libraryOnly);

            return entries;
        }

        // ── Library ─────────────────────────────────────────────────
        // When the files on disk *are* one of these releases, that
        // release is marked rather than copied into a separate "Your
        // Library" entry. The synthetic hid the thing worth knowing:
        // the user could see that they owned a version but not which
        // one, and the real release — with its date, country and
        // release count — was sitting right underneath under a
        // different name.
        const owned = this.exactLibraryCluster(clusters);

        // Only when the local tracklist matches no release at all is a
        // synthetic still needed: there is no version name to mark.
        const libraryEntry = owned ? null : this.buildLibraryEntry(clusters);
        if (libraryEntry) entries.push(libraryEntry);

        // ── Standard ────────────────────────────────────────────────
        // Highest-scoring cluster is the standard.  We point at the
        // cluster directly so the standard entry is just a labeled
        // alias — selecting it shows the same tracks as selecting that
        // cluster from the bottom list.  Skipped once the user's own
        // version is identified, by either route: a guess next to a
        // known-correct answer is noise, not a choice.
        if (!libraryEntry && !owned) {
            const standardCluster = clusters[0]!;

            entries.push({
                key: 'synthetic:standard',
                label: 'Standard',
                sublabel: this.standardSublabel(standardCluster),
                group: 'aggregate',
                syntheticKind: 'standard',
                tracks: standardCluster.representative.tracks ?? [],
                backingCluster: standardCluster,
            });
        }

        // ── Real clusters ───────────────────────────────────────────
        // Every distinct cluster gets its own entry under "Versions".
        // Already sorted by score descending from buildClusters.
        for (const cluster of clusters) {
            entries.push({
                key: `cluster:${cluster.representative.mbid}`,
                label: this.clusterLabel(cluster),
                sublabel: this.clusterSublabel(cluster),
                group: 'cluster',
                tracks: cluster.representative.tracks ?? [],
                cluster,
                backingCluster: cluster,
                inLibrary: !!owned && cluster === owned,
            });
        }

        return entries;
    }

    /**
     * Build the "Your Library" entry: the release the local files are
     * actually tagged to, not a guess.
     *
     * `localTracks` (when there is any — the local album's own tracks,
     * fetched straight from the DB) is fingerprinted the same way a
     * catalog cluster is, and matched against the clusters on screen.
     * An exact match means a real MusicBrainz release describes what's
     * on disk, so that cluster — with its real metadata — is shown. No
     * match (untagged files, or tags that don't line up with any
     * single release) falls back to the local tracks themselves, which
     * is always correct because it came straight from the files
     * rather than from a description of them.
     *
     * Only when there's no local album at all (the user owns some of
     * this release's tracks without a local album match — e.g.
     * scattered across a compilation) does this fall back to the old
     * fractional-overlap heuristic over the catalog's own `inLibrary`
     * flags, which is a guess by construction and stays one.
     */
    private exactLibraryCluster(
        clusters: ReleaseCluster[],
    ): ReleaseCluster | undefined {
        if (this.localTracks.length === 0) return undefined;

        const localFingerprint = ExploreAlbumDetails.fingerprint(this.localTracks);
        if (!localFingerprint) return undefined;

        return clusters.find((c) => c.fingerprint === localFingerprint);
    }

    private buildLibraryEntry(clusters: ReleaseCluster[]): VersionEntry | null {
        if (this.localTracks.length > 0) {

            // Callers reach this only when no release matches what is
            // on disk (`exactLibraryCluster` is checked first), so there
            // is no exact-match branch here — the version list marks
            // that case instead of synthesising an entry for it.
            //
            // A known-incomplete album should show the *release*, not
            // the subset of it that happens to be on disk — the tracks
            // that are missing are the useful information, and a
            // tracklist trimmed to what is owned cannot show them at
            // all.  So the local files stand in only while the album is
            // complete or unjudged; once the tags say nine of twelve,
            // the catalog's twelve are what the page draws, with three
            // of them dimmed.
            //
            // Guarded on `known` rather than on "fewer tracks than the
            // cluster", which would swap in a catalog tracklist for
            // every album whose tags simply never declared a total.
            const answer = this.completenessAnswer();
            const incomplete = answer?.known && !answer.complete;

            if (incomplete) {
                const fullRelease = this.findLibraryCluster(clusters);

                if (fullRelease) {
                    return {
                        key: 'synthetic:library',
                        label: 'Your Library',
                        sublabel: `${answer?.owned ?? 0} of ${answer?.expected ?? 0} tracks · ${this.clusterLabel(fullRelease)}`,
                        group: 'aggregate',
                        syntheticKind: 'library',
                        tracks: fullRelease.representative.tracks ?? [],
                        backingCluster: fullRelease,
                    };
                }
            }

            return {
                key: 'synthetic:library',
                label: 'Your Library',
                sublabel: `${this.localTracks.length} track${this.localTracks.length === 1 ? '' : 's'} · from your files`,
                group: 'aggregate',
                syntheticKind: 'library',
                tracks: this.localTracks,
            };
        }

        const libraryCluster = this.findLibraryCluster(clusters);

        if (!libraryCluster) return null;

        return {
            key: 'synthetic:library',
            label: 'Your Library',
            sublabel: this.librarySublabel(libraryCluster),
            group: 'aggregate',
            syntheticKind: 'library',
            tracks: libraryCluster.representative.tracks ?? [],
            backingCluster: libraryCluster,
        };
    }

    /**
     * Fallback only: used when there's no local album to anchor on
     * (see `buildLibraryEntry`). Finds the cluster with the highest
     * fraction of tracks the *library-wide* `inLibrary` cross-reference
     * marked owned — a guess, since that flag isn't scoped to this
     * album and a recording can appear on more than one release.
     */
    private findLibraryCluster(
        clusters: ReleaseCluster[],
    ): ReleaseCluster | null {
        let best: ReleaseCluster | null = null;
        let bestScore = 0;

        for (const cluster of clusters) {
            const tracks = cluster.representative.tracks ?? [];
            if (tracks.length === 0) continue;

            const inLibCount = tracks.filter((t: MBTrack) => t.inLibrary).length;
            // Require at least half the cluster's tracks to be owned
            // before we'd label it "your library version" — otherwise
            // a single matching recording would falsely promote a
            // huge anniversary edition.
            const fraction = inLibCount / tracks.length;
            if (fraction < 0.5) continue;

            // Tiebreak: prefer the smaller (closer-fit) cluster when
            // multiple clusters meet the threshold.  E.g., if the
            // user owns the standard 12-track edition and we also see
            // a 14-track deluxe with the same 12 + 2 extras, the
            // standard fits better.
            const score = fraction * 1000 - tracks.length;
            if (score > bestScore) {
                best = cluster;
                bestScore = score;
            }
        }

        return best;
    }

    /* ── Synthetic version labelling ── */

    private standardSublabel(cluster: ReleaseCluster): string {
        const tracks = cluster.representative.tracks ?? [];
        const count = `${tracks.length} track${tracks.length === 1 ? '' : 's'}`;
        const year = (cluster.representative.date || '').slice(0, 4);
        const releases = cluster.allReleases.length;
        const releaseLabel = `${releases} release${releases === 1 ? '' : 's'}`;
        const parts = [count, releaseLabel];
        if (year) parts.push(year);
        return parts.join(' · ');
    }

    private librarySublabel(cluster: ReleaseCluster): string {
        const tracks = cluster.representative.tracks ?? [];
        const owned = tracks.filter((t: MBTrack) => t.inLibrary).length;
        return `${owned} of ${tracks.length} tracks owned`;
    }

    private clusterLabel(cluster: ReleaseCluster): string {
        // Prefer a distinguishing date.  Fall back to title when no
        // date is known.
        const date = cluster.representative.date;
        if (date) {
            return date;
        }
        return cluster.representative.title || 'Untitled release';
    }

    private clusterSublabel(cluster: ReleaseCluster): string {
        const tracks = cluster.representative.tracks ?? [];
        const count = `${tracks.length} track${tracks.length === 1 ? '' : 's'}`;
        const releases = cluster.allReleases.length;
        const releaseLabel
            = releases === 1
                ? '1 release'
                : `${releases} releases`;

        // Build "country list" from up to 3 distinct countries.
        const countries = new Set<string>();
        for (const r of cluster.allReleases) {
            if (r.country) countries.add(r.country);
            if (countries.size >= 3) break;
        }
        const countryStr = countries.size > 0
            ? Array.from(countries).join(', ')
            : '';

        const parts = [count, releaseLabel];
        if (countryStr) parts.push(countryStr);
        return parts.join(' · ');
    }

    /* ── Navigation ── */

    private navigateBack() {
        this.dispatchEvent(
            new CustomEvent('navigate-back', {
                bubbles: true,
                composed: true,
            }),
        );
    }

    /* ── Image Error Handling ── */

    private handleCoverError(e: Event) {
        const img = e.target as HTMLImageElement;
        img.style.display = 'none';
        const fallback = img.nextElementSibling as HTMLElement | null;
        if (fallback) {
            fallback.style.display = 'flex';
        }
    }

    /* ── Helpers ── */

    private handleVersionChange(e: Event) {
        const select = e.target as HTMLSelectElement;
        this.selectedVersionKey = select.value;
    }

    /** Resolve the currently-selected version entry, if any. */
    private currentVersion(): VersionEntry | null {
        if (!this.selectedVersionKey) return null;
        return (
            this.versionEntries.find(
                (e) => e.key === this.selectedVersionKey,
            ) ?? null
        );
    }

    /**
     * Resolve the album's overall library status for the header
     * indicator.  Cheap O(1)/O(n) lookups against data we already
     * have in memory — no Wails calls.
     *
     *   - localAlbumId set            → owned
     *   - releaseGroup.inLibrary set  → owned (backend cross-ref)
     *   - cachedAlbums has MBID match → owned
     *   - any selected version has    → owned (covers local-only albums
     *     a track marked inLibrary       where releaseGroup may be null)
     *   - else                        → whatever the request list says
     *
     * Four different claims of decreasing confidence, OR'd together and
     * reported as one tick — the last of which fires when a *single*
     * recording of a forty-track release matches.  `ownership()` is the
     * honest version of the same question and is what the header's
     * actions key off; this stays as it was, because the indicator's
     * job is "is any of this yours" and that is what it answers.
     *
     * When none of them hold the answer is not automatically "no":
     * the album may be on the request list, which the button directly
     * below this badge has reported as "Wanted" all along.
     */
    /**
     * How much of this album is here, from whichever side can say.
     *
     * The files answer first: `GetAlbumCompleteness` reads the "5/12"
     * totals off the tags, which is exact and costs no network. A great
     * deal of any library declares no total at all, and for those the
     * *catalog* carries one — a per-release-group track count in
     * `explore_index`, shipped in the artifact for the price of about
     * two bytes a row.
     *
     * The numerator stays the local one either way: how many distinct
     * track numbers are on disk. Only the denominator is borrowed, and
     * only when the tags have none — a catalog total is a statement
     * about the canonical release, and the files' own total, where they
     * declare one, is a statement about the release the user actually
     * has.
     *
     * Zero still means "the catalog does not say", so an album neither
     * side can total stays `known: false` and wears no ring.
     */
    private completenessAnswer(): library.AlbumCompleteness | null {
        const local = this.completeness;

        if (local?.known) return local;

        const expected = this.releaseGroup?.totalTracks ?? 0;
        if (expected <= 0 || !local) return local;

        return {
            ...local,
            expected,
            known: true,
            complete: local.owned >= expected,
        };
    }

    /**
     * What the badge beside the album title shows.
     *
     * `albumLibraryStatus()` answers "is any of this yours", which is
     * the right question for a tick and the wrong one for a ring. The
     * ring needs a denominator, and an album neither the files nor the
     * catalog can total keeps the plain tick rather than wearing an arc
     * drawn from a guess.
     */
    private albumBadgeStatus(): LibraryStatus {
        const owned = this.albumLibraryStatus();

        if (owned !== 'in-library') return owned;

        const c = this.completenessAnswer();
        if (c?.known && !c.complete) return 'partial';

        return 'in-library';
    }

    /**
     * How a displayed track is identified in `filePaths`.
     *
     * A recording MBID where there is one, and disc/track/title where
     * there is not — a library-only album's tracks are synthesised from
     * the files' own tags and may carry no MBID at all, which is the
     * case an MBID-keyed lookup silently misses.
     */
    private static trackKey(t: MBTrack): string {
        if (t.mbid) return t.mbid;

        return `${t.discNumber || 1}:${t.position}:${t.title.toLowerCase()}`;
    }

    /** The file behind a displayed track, or '' if the user has none. */
    private filePathFor(t: MBTrack): string {
        return this.filePaths.get(ExploreAlbumDetails.trackKey(t)) ?? '';
    }

    /**
     * Record the files behind the local album's own tracks.
     *
     * These cost nothing: `GetAlbumTracks` already returned the paths,
     * and this is the one place they were being thrown away.
     */
    private rememberLocalPaths(
        rows: Awaited<ReturnType<typeof GetAlbumTracks>>,
    ): void {
        const paths = new Map(this.filePaths);

        for (const row of rows ?? []) {
            if (!row.FilePath) continue;

            const key = ExploreAlbumDetails.trackKey({
                mbid: row.RecordingMBID || '',
                title: row.TrackName,
                position: row.TrackNumber || 0,
                discNumber: row.DiscNumber || 1,
            } as MBTrack);

            paths.set(key, row.FilePath);
        }

        this.filePaths = paths;
    }

    /**
     * Resolve the catalog tracklist's files in one query.
     *
     * Called when the displayed tracklist changes rather than when a
     * user clicks: the answer decides what the rows look like and which
     * menu items exist, so it has to be known before either is drawn.
     */
    private async resolveFilePaths(): Promise<void> {
        const tracks = this.currentVersion()?.tracks ?? [];
        const wanted = tracks
            .map((t) => t.mbid)
            .filter((mbid) => mbid && !this.askedFor.has(mbid));

        if (wanted.length === 0) return;

        for (const mbid of wanted) this.askedFor.add(mbid);

        try {
            const byMBID = await dictByName(
                GetFilePathsByRecordingMBIDs(wanted, libraryStore.libraryFilter()),
            );

            const paths = new Map(this.filePaths);

            for (const [mbid, forMBID] of Object.entries(byMBID)) {
                const first = forMBID?.[0];
                if (first) paths.set(mbid, first);
            }

            this.filePaths = paths;
        } catch (error) {
            // A failure here means the page cannot say what is owned, so
            // it says nothing rather than guessing: rows stay dimmed and
            // the actions that need a file stay absent.
            console.error('Could not resolve library files for this album:', error);
        }
    }

    /**
     * Whether any of this album is the user's.
     *
     * One question, asked once: does any displayed track have a file.
     * It used to be four claims of decreasing confidence OR'd into a
     * single tick — a local album id, the backend's cross-reference, a
     * cached MBID match, and finally *any* track flagged `inLibrary` —
     * none of which is "there is a file", which is why the badge could
     * say yes about an album whose every action failed.
     *
     * When it is not owned the answer is not automatically "no": the
     * album may be on the request list, which the button below the
     * badge has reported as "Wanted" all along.
     */
    private albumLibraryStatus(): LibraryStatus {
        if (this.ownership().owned > 0) return 'in-library';

        return libraryStatusFor(false, this.releaseGroupMBID);
    }

    /**
     * How much of the shown release the user actually has.
     *
     * Counted off the tracklist being displayed, by how many of its
     * tracks resolved to a file. That is the only claim on this page
     * that is not an inference: a path means the track plays.
     *
     * It is what the header's buttons key off, because "Play" that
     * plays one track of a forty-track release is worse than no Play
     * button — and it is now also what the badge above them uses, so
     * the two can no longer disagree.
     */
    private ownership(): { owned: number; total: number } {
        const tracks = this.currentVersion()?.tracks ?? [];

        return {
            owned: tracks.filter((t) => this.filePathFor(t) !== '').length,
            total: tracks.length,
        };
    }

    /**
     * Check whether the selected release's tracklist contains any track
     * with discNumber > 1, indicating a multi-disc release.
     */
    private isMultiDisc(tracks: MBTrack[]): boolean {
        return tracks.some((t) => (t.discNumber || 1) > 1);
    }

    /**
     * Group tracks by disc number, returning them in disc order.
     */
    private groupByDisc(tracks: MBTrack[]): Map<number, MBTrack[]> {
        const discMap = new Map<number, MBTrack[]>();
        for (const track of tracks) {
            const disc = track.discNumber || 1;
            const bucket = discMap.get(disc);
            if (bucket) {
                bucket.push(track);
            } else {
                discMap.set(disc, [track]);
            }
        }
        // Sort tracks within each disc by position
        for (const bucket of discMap.values()) {
            bucket.sort((a, b) => a.position - b.position);
        }
        return discMap;
    }

    /* ── Render ── */

    override render() {
        return html`
            ${this.renderHeader()}
            <div class="content">
                <catalog-scope-notice
                    scope=${this.catalogScope()}
                    entity-type="album"
                    @catalog-retry=${this.retryCatalog}
                ></catalog-scope-notice>
                ${this.renderVersionSelector()}
                ${this.renderTracklist()}
            </div>
            <track-details></track-details>
        `;
    }

    private renderHeader() {
        let artURL = this.coverArtURL;

        if (!artURL) {
            // Local fallback: try to find a library album that matches
            // by ID, MBID, or name+artist (in that priority).  Library
            // store has /covers/* paths that the dev server serves
            // directly without any backend round-trip.
            const cachedAlbums = libraryStore.cachedAlbums;
            if (cachedAlbums) {
                const targetName = (this.albumName || this.releaseGroup?.title || '').toLowerCase();
                const targetArtist = (this.artistName || this.releaseGroup?.artistCredit || '').toLowerCase();

                for (const a of cachedAlbums) {
                    let match = false;
                    if (this.localAlbumId && a.ID === this.localAlbumId) {
                        match = true;
                    } else if (this.releaseGroupMBID && a.MBID && a.MBID === this.releaseGroupMBID) {
                        match = true;
                    } else if (
                        targetName
                        && targetArtist
                        && a.Name.toLowerCase() === targetName
                        && a.ArtistName.toLowerCase() === targetArtist
                    ) {
                        match = true;
                    }

                    if (match) {
                        artURL = a.CoverArtMedium || a.CoverArtLarge || a.CoverArtPath || '';
                        if (artURL) break;
                    }
                }
            }
        }

        return html`
            <div class="album-header">
                <button
                    class="back-button"
                    @click=${this.navigateBack}
                    title="Back"
                    aria-label="Back to previous view"
                >
                    <wa-icon name="arrow-left"></wa-icon>
                </button>
                <div class="cover-art-container">
                    ${artURL
                        ? html`<img
                            src="${artURL}"
                            alt="${this.albumName}"
                            @error=${this.handleCoverError}
                        />`
                        : nothing}
                    <div class="cover-art-fallback" style="${artURL ? 'display: none' : ''}">
                        <wa-icon name="compact-disc"></wa-icon>
                    </div>
                </div>
                <div class="album-info">
                    <h1 class="album-title" title="${this.albumName}">
                        <span class="album-title-text">${this.albumName}</span>
                        <library-status-indicator
                            status=${this.albumBadgeStatus()}
                            .owned=${this.completenessAnswer()?.owned ?? 0}
                            .expected=${this.completenessAnswer()?.expected ?? 0}
                            entity-type="album"
                            label=${this.albumName}
                            size="22"
                        ></library-status-indicator>
                    </h1>
                    ${this.renderAlbumMeta()}
                    ${this.renderPlayActions()}
                    ${this.renderDownloadAction()}
                </div>
            </div>
            ${this.renderPicker()}
        `;
    }

    /**
     * The primary action, and the sentence that says what it will do.
     *
     * `H-13`: the album page had no Play, no Shuffle and no Add to
     * queue. What it could not have is a Play button that means the
     * same thing in every case — this is a *catalog* page, and the
     * album on it may be entirely yours, partly yours, or not yours at
     * all. So the button says which:
     *
     *   - all of it       → "Play", and the count is in the meta line
     *   - some of it      → "Play 7 of 12", because playing seven
     *                       tracks under a button that says "Play" is
     *                       the page lying about what you own
     *   - none of it      → no play button at all; the download and
     *                       want actions below are the whole answer
     *
     * The count is the tracklist's own `inLibrary` flags, which the
     * backend sets from each recording's MBID — the same key
     * `GetFilePathsByRecordingMBIDs` resolves the files by, so the
     * number on the button is the number of tracks that will play.
     */
    private renderPlayActions() {
        const { owned, total } = this.ownership();

        if (owned === 0 || total === 0) return nothing;

        const partial = owned < total;
        const playLabel = partial ? `Play ${owned} of ${total}` : 'Play';

        return html`
            <div class="album-actions">
                <wa-button
                    size="small"
                    appearance="filled"
                    data-testid="album-play"
                    @click=${() => this.playOwned(false)}
                >
                    <wa-icon slot="start" name="play"></wa-icon>
                    ${playLabel}
                </wa-button>
                <wa-button
                    size="small"
                    appearance="outlined"
                    data-testid="album-shuffle"
                    @click=${() => this.playOwned(true)}
                >
                    <wa-icon slot="start" name="shuffle"></wa-icon>
                    Shuffle album
                </wa-button>
                <wa-button
                    size="small"
                    appearance="outlined"
                    data-testid="album-queue"
                    @click=${() => this.queueOwned()}
                >
                    <wa-icon slot="start" name="list"></wa-icon>
                    Add to queue
                </wa-button>
                ${partial
                    ? html`<span class="album-owned-note">
                          You have ${owned} of these ${total} tracks.
                      </span>`
                    : nothing}
            </div>
            <inline-notice
                region=${ExploreAlbumRegion}
                testid="album-action-message"
            ></inline-notice>
        `;
    }

    /**
     * File paths for the tracks of this release the user actually owns,
     * in the tracklist's order.
     *
     * One call. The obvious alternative — ask for the album's tracks
     * and read `FilePath` off them — is the shape `perf.m2` was about,
     * and it is not even available here: this page's model is
     * `MBTrack`, which carries a recording MBID and a `localId` that
     * nothing in the backend ever writes.
     */
    /**
     * What "Playing from" should say for a queue built here — only when
     * there's a local album to link back to. A catalog-only album (no
     * `localAlbumId`) has nowhere in the library for the queue panel's
     * link to point, so the queue is left undescribed rather than
     * pointed at a page that doesn't exist for it.
     */
    private queueSource(): QueueSource | undefined {
        if (!(this.localAlbumId > 0)) return undefined;

        return { type: 'album', id: this.localAlbumId, label: this.albumName };
    }

    /**
     * The files behind the displayed tracklist, in its order.
     *
     * No query: the paths were resolved when the tracklist settled.
     * This used to be two different lookups chosen by a branch - by
     * local album id, or by recording MBID for a catalog-only album -
     * and the second silently returned nothing for an untagged library,
     * because those tracks carry no MBID at all.
     */
    private ownedFilePaths(): string[] {
        const paths: string[] = [];

        for (const track of this.currentVersion()?.tracks ?? []) {
            const path = this.filePathFor(track);

            // A recording with more than one file is a duplicate; the
            // map holds the first and the rest are the duplicate
            // feature's business.
            if (path) paths.push(path);
        }

        return paths;
    }

    /** Play what the user owns of this release, optionally shuffled. */
    private playOwned(shuffle: boolean): void {
        const paths = this.ownedFilePaths();

        // The button is only rendered when there is something to play,
        // so an empty set here is not a state the user can reach.
        if (paths.length === 0) return;

        // `shuffleStart` only picks a random first track when shuffle
        // mode is *already* on — it does not turn it on — so the mode
        // has to be set before the queue, not after.
        if (shuffle && !queueStore.getState().shuffleMode) {
            queueStore.toggleShuffle();
        }

        queueStore.setQueue(paths, 0, shuffle, this.queueSource());
    }

    /** Append what the user owns of this release to the queue. */
    private queueOwned(): void {
        const paths = this.ownedFilePaths();

        if (paths.length === 0) return;

        queueStore.addTracksToQueue(paths);
    }

    /**
     * Play an owned track *in the context of the release it is on*:
     * the whole owned tracklist is queued and playback starts at that
     * track. Activating a row is a position in an album, not a request
     * to throw the album away - "Add to Queue" and "Play Next" are what
     * a caller reaches for when it wants the one track.
     */
    private playTrack(track: MBTrack): void {
        const path = this.filePathFor(track);

        // Every path into this is gated on the row having a file: the
        // row is not activatable without one and the menu offers
        // nothing that needs one. There is no "could not be found in
        // your library" any more, because the page no longer offers an
        // action it cannot perform.
        if (!path) return;

        const paths = this.ownedFilePaths();
        const start = paths.indexOf(path);

        // `start` is only -1 if the row is not in the version currently
        // displayed, which no gesture on this page can produce; playing
        // the one track is the honest answer to it either way.
        if (start < 0) {
            queueStore.setQueue([path], 0, false, this.queueSource());

            return;
        }

        queueStore.setQueue(paths, start, false, this.queueSource());
    }

    private queueTrackNext(track: MBTrack): void {
        const path = this.filePathFor(track);

        if (path) queueStore.playNext(path);
    }

    private addTrackToQueue(track: MBTrack): void {
        const path = this.filePathFor(track);

        if (path) queueStore.addToQueue(path);
    }

    private onTrackRowDblClick(track: MBTrack): void {
        this.playTrack(track);
    }

    private onTrackRowKeydown(e: KeyboardEvent, track: MBTrack): void {
        if (isContextMenuKey(e)) {
            e.preventDefault();
            this.ctxMenuTrack = track;
            this.ctxMenu.openFrom(e.currentTarget as HTMLElement);

            return;
        }

        if ((e.key === 'Enter' || e.key === ' ') && this.filePathFor(track)) {
            e.preventDefault();
            this.playTrack(track);
        }
    }

    private onTrackContextMenu(e: MouseEvent, track: MBTrack): void {
        e.preventDefault();
        e.stopPropagation();

        this.ctxMenuTrack = track;
        this.ctxMenu.openAt(e.clientX, e.clientY);
    }

    private onContextMenuAction(
        action: 'play' | 'add-to-queue' | 'play-next' | 'track-details',
    ): void {
        const track = this.ctxMenuTrack;

        this.ctxMenu.close();

        if (!track || !this.filePathFor(track)) return;

        switch (action) {
            case 'play':
                this.playTrack(track);
                break;
            case 'add-to-queue':
                this.addTrackToQueue(track);
                break;
            case 'play-next':
                this.queueTrackNext(track);
                break;
            case 'track-details':
                void this.openTrackDetails(track);
                break;
        }
    }

    /**
     * Open the "Add to Playlist" submenu for the track the menu is on.
     *
     * No await and no guards: the file was resolved when the tracklist
     * settled, so the submenu opens or the item was never rendered.
     * This used to resolve on demand, which meant a hover could report
     * a failure for a menu the user was passing through.
     */
    private openPlaylistSubmenu(): void {
        const track = this.ctxMenuTrack;
        if (!track) return;

        const path = this.filePathFor(track);
        if (!path) return;

        this.ctxMenu.clearSubmenuCloseTimer();
        void this.ctxMenu.showPlaylistSubmenu([path]);
    }

    /**
     * The details dialog for an owned track.
     *
     * It needs the library's own `Track`, which this page never has —
     * its rows are the catalog's — so the file path is the way in, and
     * the shared opener turns it back into a track.
     */
    private async openTrackDetails(track: MBTrack): Promise<void> {
        const path = this.filePathFor(track);
        if (!path) return;

        const outcome = await showTrackDetailsForPath(
            () => this.trackDetailsDialog,
            path,
            () => void this.openTrackDetails(track),
        );

        // The file exists but the library store does not know it: a
        // rescan removed it since the page loaded, which is the one
        // case the resolved map cannot rule out.
        if (outcome === 'not-in-library') {
            notificationStore.inline(ExploreAlbumRegion, {
                text: 'This track is no longer in your library.',
            });
        }
    }

    /**
     * Explore's tracks carry a recording MBID whether or not the user
     * owns them — this is the one context-menu action that works on a
     * track the library does not have, since it needs no file at all.
     */
    private viewTrackOnMusicBrainz(): void {
        const track = this.ctxMenuTrack;

        this.ctxMenu.close();

        if (!track?.mbid) return;

        window.open(`https://musicbrainz.org/recording/${track.mbid}`, '_blank', 'noopener');
    }

    /**
     * Offers to acquire the album, but only when the user has actually
     * connected a download client and does not already own it. Showing
     * the button otherwise would advertise a feature that cannot work.
     */
    private renderDownloadAction() {
        if (this.albumLibraryStatus() === 'in-library') return nothing;

        return html`
            <div class="album-download">
                ${this.canDownload
                    ? html`
                          <wa-button
                              size="small"
                              appearance="outlined"
                              @click=${() => {
                                  void this.openPicker();
                              }}
                          >
                              <wa-icon slot="start" name="download"></wa-icon>
                              Find this album
                          </wa-button>
                      `
                    : nothing}
                ${this.renderWantAction()}
            </div>
        `;
    }

    /**
     * Adds the album to the requests list, which is the answer to "look
     * for it, but not right now".
     *
     * Unlike the download button this shows whether or not a client is
     * connected: requesting something is a durable statement about the
     * library, and it stays true — and stays queued — until a client
     * exists to act on it.
     */
    private renderWantAction() {
        if (!this.releaseGroupMBID) return nothing;

        const request = downloadStore.requestFor(this.releaseGroupMBID);

        return html`
            <wa-button
                size="small"
                appearance=${this.isRequested ? 'filled' : 'outlined'}
                @click=${() => void this.toggleRequested(request?.id)}
            >
                <!-- The requested state used to ask for bookmark-check,
                     which is a Font Awesome *Pro* name: never bundled,
                     so this button has rendered the missing-icon
                     fallback in that state ever since. Outline and solid
                     of the same Free glyph carry the toggle instead. -->
                <wa-icon
                    slot="start"
                    name=${this.isRequested ? 'solid/bookmark' : 'regular/bookmark'}
                ></wa-icon>
                ${this.isRequested ? 'Requested' : 'Request this'}
            </wa-button>
        `;
    }

    /** Resolves the library to attach downloads/requests to. */
    private async resolveTargetLibraryId(): Promise<void> {
        this.targetLibraryId = await libraryStore.getDefaultLibraryId();
    }

    /** Reflects the store's view of whether this album is requested. */
    private syncRequested(): void {
        this.isRequested = this.releaseGroupMBID
            ? downloadStore.isRequested(this.releaseGroupMBID)
            : false;
    }

    private async toggleRequested(requestId: number | undefined): Promise<void> {
        if (!this.releaseGroupMBID) return;

        try {
            if (requestId) {
                await downloadStore.removeRequest(requestId);
            } else {
                if (!this.targetLibraryId) {
                    await this.resolveTargetLibraryId();
                }
                if (!this.targetLibraryId) {
                    console.error('Could not update the requests list: no library available');
                    return;
                }

                await downloadStore.addRequest({
                    mbid: this.releaseGroupMBID,
                    entity: 'release-group',
                    libraryId: this.targetLibraryId,
                    artist: this.releaseGroup?.artistCredit ?? '',
                    title: this.albumName,
                    scope: 'future',
                    secondary: false,
                } as download.RequestInput);
            }
        } catch (err) {
            console.error('Could not update the requests list:', err);
        }

        this.syncRequested();
    }

    private async openPicker(): Promise<void> {
        if (!this.targetLibraryId) {
            await this.resolveTargetLibraryId();
        }

        if (!this.targetLibraryId) {
            console.error('Cannot search for downloads: no library available');
            return;
        }

        this.pickerOpen = true;
    }

    private renderPicker() {
        if (!this.pickerOpen || !this.targetLibraryId) return nothing;

        const tracks = this.currentTracks();

        return html`
            <download-picker
                ?open=${this.pickerOpen}
                library-id=${this.targetLibraryId}
                artist=${this.releaseGroup?.artistCredit ?? ''}
                album=${this.albumName}
                release-group-mbid=${this.releaseGroupMBID ?? ''}
                .expected=${tracks.map((t, index) => ({
                    position: t.position || index + 1,
                    discNumber: t.discNumber ?? 0,
                    title: t.title,
                    artist: '',
                    lengthMillis: t.length ?? 0,
                }))}
                @picker-close=${() => {
                    this.pickerOpen = false;
                }}
            ></download-picker>
        `;
    }

    /**
     * Where the tracklist on screen came from.  The distinction the
     * user cares about is not "did a fetch fail" but "is what I am
     * looking at everything, or only my own copy" — so an album with
     * no MBID is `library` permanently, while one whose catalog fetch
     * has not landed is `loading` and then either resolves or degrades
     * to `unavailable`.
     */
    private catalogScope(): CatalogScope {
        // A library-only album says nothing: the header names it, the
        // badge says it is yours, and the tracklist is the files'
        // own — there is nothing absent for a notice to warn about.
        // The artist page keeps its 'library' state because there a
        // missing catalog means missing *sections*.
        if (!this.releaseGroupMBID) return 'catalog';
        if (this.catalogReleasesLoaded) return 'catalog';

        // A complete, MBID-matched album is not missing anything the
        // notice could warn about, so there is nothing to say — and
        // saying it silently is the point: no browse was made, and a
        // banner about absent catalog data would be describing a
        // request the page deliberately did not send.
        if (this.completeness?.complete) return 'catalog';

        if (this.catalogFailed) return 'unavailable';

        // A fetch is still out there, and the page says nothing about
        // it.  A banner announcing that details are loading is a line
        // of text about the page's own plumbing, and it earns its space
        // only if the alternative is the user misreading what is on
        // screen — which the tracklist now prevents by itself: rows
        // that are not in the library are dimmed, so tracks arriving
        // dimmed reads as the album filling in rather than as anything
        // needing explanation.
        //
        // `unavailable` survives because it is not about plumbing: it
        // says rows may be missing from the page altogether, which
        // nothing on screen can show, and it carries a retry.
        return 'catalog';
    }

    /** Ask the catalog again after a failed or empty fetch. */
    private retryCatalog = () => {
        const mbid = this.releaseGroupMBID;
        if (!mbid) return;

        this.errorReleases = '';
        this.loadingReleases = this.releases.length === 0;
        this.catalogFailed = false;
        this.releasesReloaded.delete(mbid);
        this.armReleasesFallback(mbid);
        void this.fetchReleases(mbid);
    };

    /** Tracks of the version currently selected in the dropdown. */
    private currentTracks(): MBTrack[] {
        const entry = this.versionEntries.find(
            (e) => e.key === this.selectedVersionKey,
        );

        return entry?.tracks ?? [];
    }

    private renderAlbumMeta() {
        if (this.loadingInfo) {
            return html`<span class="album-artist section-loading"
                >Loading\u2026</span
            >`;
        }
        if (this.errorInfo) {
            return html`
                <div class="section-error">
                    <wa-icon name="triangle-exclamation"></wa-icon>
                    ${this.errorInfo}
                </div>
            `;
        }
        if (!this.releaseGroup) return nothing;

        const rg = this.releaseGroup;
        const artist = rg.artistCredit || '';
        const artistMbid = rg.artistMbid ?? '';
        const year = extractYear(rg.firstReleaseDate);
        const type = rg.primaryType || '';

        const metaParts: string[] = [];
        if (type) metaParts.push(type);
        if (year) metaParts.push(year);

        return html`
            ${artist
                ? html`<div class="album-artist">
                      ${creditLink(
                          creditStore.credits(this.releaseGroupMBID),
                          artist,
                          artistMbid,
                      )}
                  </div>`
                : nothing}
            ${metaParts.length > 0
                ? html`
                      <span class="album-meta">
                          ${metaParts.map(
                              (p, i) =>
                                  html`${i > 0
                                      ? html`<span class="meta-separator"
                                            >\u00B7</span
                                        >`
                                      : nothing}${p}`,
                          )}
                      </span>
                  `
                : nothing}
        `;
    }

    /* ── Version Selector (R025, R026, R027) ── */

    private renderVersionSelector() {
        if (this.loadingReleases) {
            return html`
                <section>
                    <h3 class="section-header">Versions</h3>
                    <div class="section-loading">Loading releases\u2026</div>
                </section>
            `;
        }
        if (this.errorReleases) {
            return html`
                <section>
                    <h3 class="section-header">Versions</h3>
                    <div class="section-error">
                        <wa-icon name="triangle-exclamation"></wa-icon>
                        ${this.errorReleases}
                    </div>
                </section>
            `;
        }

        // A dropdown is only a choice if the choices differ. Counting
        // *entries* is the wrong test: a release group routinely has
        // several releases — reissues, regional pressings, a remaster —
        // whose tracklists are identical, and the synthetic "Your
        // Library" entry is often a third name for the same one. That
        // offered a control whose every option showed the same rows.
        //
        // Distinct *tracklists* is the real question, and it is already
        // computed: clusters are keyed by tracklist fingerprint.
        if (this.distinctTracklistCount() <= 1) return nothing;

        const aggregateEntries = this.versionEntries.filter(
            (e) => e.group === 'aggregate',
        );
        const clusterEntries = this.versionEntries.filter(
            (e) => e.group === 'cluster',
        );

        return html`
            <div class="version-selector">
                <div class="version-selector-row">
                    <label for="version-select">Version</label>
                    <select
                        id="version-select"
                        @change=${this.handleVersionChange}
                        aria-label="Select release version"
                    >
                        ${aggregateEntries.length > 0
                            ? html`
                                  <optgroup label="Aggregate">
                                      ${aggregateEntries.map((e) =>
                                          this.renderVersionOption(e),
                                      )}
                                  </optgroup>
                              `
                            : nothing}
                        <optgroup label="Versions">
                            ${clusterEntries.map((e) =>
                                this.renderVersionOption(e),
                            )}
                        </optgroup>
                    </select>
                </div>
                ${this.renderVersionMeta()}
            </div>
        `;
    }

    /**
     * One option in the version list.
     *
     * The marker is a star *and* the words "in your library": a `<select>`
     * cannot be styled per option, so the only way to say this is in the
     * text — and a bare glyph would be a symbol with no key, which is
     * exactly what the tracklist's green ticks were.
     */
    private renderVersionOption(entry: VersionEntry) {
        const label = entry.inLibrary ? `\u2605 ${entry.label}` : entry.label;
        const sublabel = entry.inLibrary
            ? `${entry.sublabel} \u00b7 in your library`
            : entry.sublabel;

        return html`
            <option
                value=${entry.key}
                ?selected=${entry.key === this.selectedVersionKey}
            >
                ${label} — ${sublabel}
            </option>
        `;
    }

    /**
     * Render a small status line under the version selector explaining
     * what the user is currently viewing.  Helps disambiguate the
     * synthetic entries from real clusters.
     */
    private renderVersionMeta() {
        const current = this.currentVersion();
        if (!current) return nothing;

        switch (current.syntheticKind) {
            case 'standard':
                return html`
                    <div class="version-meta">
                        Showing the standard version — the most likely
                        canonical tracklist for this album, picked by
                        weighing how many physical releases share it,
                        release status, and release date.
                    </div>
                `;
            case 'library': {
                // The exact-match case no longer lands here — it is a
                // marked real version now, handled below — so what is
                // left is the two ways of *not* being able to name the
                // release.
                const text = this.localTracks.length === 0
                    ? 'Showing the version that best matches your library, going by which tracks you own — not a specific local album.'
                    : 'Showing your library copy, built from your local files. It isn’t linked to a MusicBrainz release yet.';

                return html`<div class="version-meta">${text}</div>`;
            }
            default: {
                const releases = current.cluster?.allReleases.length ?? 0;
                const shared = releases > 1
                    ? `${releases} physical releases share this tracklist.`
                    : '';

                if (current.inLibrary) {
                    return html`
                        <div class="version-meta">
                            \u2605 This is the version in your library.
                            ${shared}
                        </div>
                    `;
                }

                return shared
                    ? html`<div class="version-meta">${shared}</div>`
                    : nothing;
            }
        }
    }

    /* ── Tracklist ── */

    /**
     * The heading is there and is not drawn.
     *
     * A list of numbered titles with durations under an album's cover
     * does not need a word above it saying what it is — it was the
     * only thing on this page labelling something already obvious. But
     * the section is a landmark and the page's heading structure runs
     * through it, so what goes is the *ink*, not the element: a reader
     * jumping by heading still finds the tracklist.
     */
    private renderTracklist() {
        if (this.loadingReleases) {
            return html`
                <section>
                    <h3 class="sr-only">Tracklist</h3>
                    <div class="section-loading">Loading tracks\u2026</div>
                </section>
            `;
        }
        if (this.errorReleases) {
            // Error already shown in version selector section
            return nothing;
        }
        const current = this.currentVersion();
        if (!current) {
            return html`
                <section>
                    <h3 class="sr-only">Tracklist</h3>
                    <div class="section-error">
                        <wa-icon name="triangle-exclamation"></wa-icon>
                        No release data available.
                    </div>
                </section>
            `;
        }

        const tracks = current.tracks;
        if (tracks.length === 0) {
            return html`
                <section>
                    <h3 class="sr-only">Tracklist</h3>
                    <div
                        style="color: var(--yj-text-tertiary, #888); font-size: var(--yj-text-md)"
                    >
                        No tracks available for this release.
                    </div>
                </section>
            `;
        }

        const multiDisc = this.isMultiDisc(tracks);
        const discMap = this.groupByDisc(tracks);
        const discNumbers = [...discMap.keys()].sort((a, b) => a - b);

        return html`
            <section>
                <h3 class="sr-only">Tracklist</h3>
                <div class="tracklist">
                    ${discNumbers.map((discNum) => {
                        const discTracks = discMap.get(discNum) ?? [];
                        return html`
                            ${multiDisc
                                ? html`
                                      <div class="disc-separator">
                                          <span class="disc-label"
                                              >Disc ${discNum}</span
                                          >
                                      </div>
                                  `
                                : nothing}
                            ${discTracks.map((track) => {
                                // A row is owned if a file is behind it.
                                // It used to be the backend's inLibrary
                                // flag, which was set from a metadata
                                // row and could be true for a track
                                // that could not be played.
                                const owned = this.filePathFor(track) !== '';

                                return html`
                                    <div
                                        class=${classMap({
                                            'track-row': true,
                                            owned,
                                            unowned: !owned,
                                        })}
                                        data-track-mbid="${track.mbid}"
                                        data-track-title="${track.title}"
                                        tabindex="0"
                                        role="button"
                                        aria-disabled=${owned ? 'false' : 'true'}
                                        aria-label=${owned
                                            ? `Play “${track.title}”`
                                            : `${track.title} — not in your library`}
                                        @dblclick=${() => this.onTrackRowDblClick(track)}
                                        @contextmenu=${(e: MouseEvent) => this.onTrackContextMenu(e, track)}
                                        @keydown=${(e: KeyboardEvent) => this.onTrackRowKeydown(e, track)}
                                    >
                                        <span class="track-position"
                                            >${track.position}</span
                                        >
                                        <span
                                            class="track-title"
                                            title="${track.title}"
                                            >${track.title}</span
                                        >
                                        <span class="track-duration"
                                            >${formatDuration(
                                                track.length,
                                            )}</span
                                        >
                                        ${owned
                                            ? nothing
                                            : html`
                                                  <library-status-indicator
                                                      class="track-request"
                                                      status=${libraryStatusFor(
                                                          false,
                                                          track.mbid,
                                                      )}
                                                      entity-type="track"
                                                      label=${track.title}
                                                      request-mbid=${track.mbid}
                                                      request-artist=${this.artistName}
                                                  ></library-status-indicator>
                                              `}
                                    </div>
                                `;
                            })}
                        `;
                    })}
                </div>
            </section>
            ${this.renderTrackContextMenu()}
        `;
    }

    private renderTrackContextMenu() {
        const track = this.ctxMenuTrack;

        return html`
            <wa-popup
                id="track-context-menu"
                placement="bottom-start"
                flip
                shift
                .active=${this.ctxMenu.contextMenuOpen}
            >
                ${this.ctxMenu.contextMenuOpen && track
                    ? html`
                          <div class="context-menu-panel" role="menu" aria-label="Track actions">
                              ${this.filePathFor(track) !== ''
                                  ? html`
                                        <wa-dropdown-item
                                            @click=${() => this.onContextMenuAction('play')}
                                            @mouseenter=${() => this.ctxMenu.closePlaylistSubmenu()}
                                        >
                                            <wa-icon slot="icon" name="play"></wa-icon>
                                            Play
                                        </wa-dropdown-item>
                                        <wa-dropdown-item
                                            @click=${() => this.onContextMenuAction('add-to-queue')}
                                            @mouseenter=${() => this.ctxMenu.closePlaylistSubmenu()}
                                        >
                                            <wa-icon slot="icon" name="plus"></wa-icon>
                                            Add to Queue
                                        </wa-dropdown-item>
                                        <wa-dropdown-item
                                            @click=${() => this.onContextMenuAction('play-next')}
                                            @mouseenter=${() => this.ctxMenu.closePlaylistSubmenu()}
                                        >
                                            <wa-icon slot="icon" name="forward-step"></wa-icon>
                                            Play Next
                                        </wa-dropdown-item>
                                        <wa-dropdown-item
                                            class="submenu-item"
                                            @mouseenter=${() => this.openPlaylistSubmenu()}
                                            @mouseleave=${this.ctxMenu.scheduleSubmenuClose}
                                            @click=${(e: Event) => {
                                                e.stopPropagation();
                                                this.openPlaylistSubmenu();
                                            }}
                                        >
                                            <wa-icon slot="icon" name="plus"></wa-icon>
                                            Add to Playlist
                                            <span class="submenu-arrow">&#9654;</span>
                                        </wa-dropdown-item>
                                        <wa-dropdown-item
                                            @click=${() => this.onContextMenuAction('track-details')}
                                            @mouseenter=${() => this.ctxMenu.closePlaylistSubmenu()}
                                        >
                                            <wa-icon slot="icon" name="circle-info"></wa-icon>
                                            Track Details
                                        </wa-dropdown-item>
                                    `
                                  : nothing}
                              <wa-dropdown-item
                                  @click=${() => this.viewTrackOnMusicBrainz()}
                                  @mouseenter=${() => this.ctxMenu.closePlaylistSubmenu()}
                              >
                                  <wa-icon slot="icon" name="globe"></wa-icon>
                                  View on MusicBrainz
                              </wa-dropdown-item>
                          </div>
                      `
                    : nothing}
            </wa-popup>

            <wa-popup
                id="playlist-submenu"
                placement="right-start"
                flip
                shift
                .active=${this.ctxMenu.playlistSubmenuOpen}
            >
                ${this.ctxMenu.playlistSubmenuOpen
                    ? html`
                          <div
                              @mouseenter=${() => this.ctxMenu.clearSubmenuCloseTimer()}
                              @mouseleave=${this.ctxMenu.scheduleSubmenuClose}
                          >
                              <playlist-picker
                                  .filePaths=${this.ctxMenu.playlistFilePaths}
                                  @playlist-action-complete=${this.ctxMenu.onPlaylistActionComplete}
                                  @click=${(e: Event) => e.stopPropagation()}
                              ></playlist-picker>
                          </div>
                      `
                    : nothing}
            </wa-popup>
        `;
    }
}

declare global {
    interface HTMLElementTagNameMap {
        'explore-album-details': ExploreAlbumDetails;
    }
}