@audiofool/moondog 0.2.0-beta.2 → 0.2.0-beta.3

package/src/core/track-title.mjs

@@ -0,0 +1,107 @@
+// A remaster, a live take or a guest credit names a recording of the same song, so knownness,
+// deduplication and Moondog's suggestion ledger compare titles without these suffixes:
+// " - 2011 Remaster", "(Remastered 2009)", " - Live", "(feat. X)", "[Deluxe]". A remix stays
+// its own song.
+const DASH_SUFFIX = /\s+[-\u2013\u2014]\s+[^-\u2013\u2014]*\b(?:remaster(?:ed)?|live|mono|stereo|single|radio edit|edit|version|demo|acoustic|bonus track|\d{4} mix)\b[^-\u2013\u2014]*$/iu;
+const BRACKET_SUFFIX = /\s*[([][^()[\]]*\b(?:remaster(?:ed)?|live|feat\.?|ft\.?|featuring|with|deluxe|mono|stereo|version|edit|demo|acoustic|bonus track)(?:\b|(?<=\.))[^()[\]]*[)\]]$/iu;
+
+export function normalizedTrackTitle(value) {
+  let title = String(value ?? "").normalize("NFKC").toLocaleLowerCase("und").replace(/\s+/gu, " ").trim();
+  for (let previous = null; previous !== title;) {
+    previous = title;
+    const stripped = title.replace(DASH_SUFFIX, "").replace(BRACKET_SUFFIX, "").trim();
+    // A title made only of a version word stays as it is.
+    if (stripped) title = stripped;
+  }
+  return title;
+}
+
+export function normalizedArtistName(value) {
+  return String(value ?? "").normalize("NFKC").toLocaleLowerCase("und").replace(/\s+/gu, " ").trim();
+}
+
+/**
+ * One song by one primary artist, whatever the recording's version suffix. A unit separator
+ * joins the two, not a NUL: node:sqlite on Node 22 cuts a stored string at a NUL.
+ */
+export function trackMatchKey(title, artist) {
+  const name = normalizedTrackTitle(title);
+  const credit = normalizedArtistName(artist);
+  return name && credit ? `${name}\u001f${credit}` : null;
+}
+
+// Chinese, Japanese and Korean text, which has no spaces between words (or words
+// that take particles), so a name in it is found as a substring.
+const CJK_TEXT = /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}]/u;
+
+// Folds case, width, Latin accents and punctuation, so "Beyoncé," and "beyonce" read alike.
+// Kana voicing marks stay, because they change the word.
+export function foldedWords(value) {
+  return String(value ?? "").normalize("NFKD").replace(/[̀-ͯ]/gu, "").normalize("NFC")
+    .toLocaleLowerCase("und").replace(/[^\p{L}\p{N}\p{M}]+/gu, " ").trim();
+}
+
+export const isCjkText = (value) => CJK_TEXT.test(String(value ?? ""));
+
+// A letter or digit of a script that writes its words apart. A name must not start or end
+// next to one of these when its own edge is one too; next to a CJK character, a space or
+// punctuation, it may, so "Coldplay" is named in "我不想再听Coldplay了".
+const SPACED_LETTER = /[[\p{L}\p{N}\p{M}]--[\p{scx=Han}\p{scx=Hiragana}\p{scx=Katakana}\p{scx=Hangul}]]/v;
+const joined = (left, right) => left !== undefined && right !== undefined && SPACED_LETTER.test(left) && SPACED_LETTER.test(right);
+
+/**
+ * Whether text names a name. A script change (Latin next to CJK), a space or punctuation ends
+ * a word, and between two Latin letters a name matches only as whole words.
+ * A name shorter than 2 characters after folding names nothing.
+ */
+export function textNames(text, name) {
+  const wanted = foldedWords(name);
+  if (Array.from(wanted.replace(/ /gu, "")).length < 2) return false;
+  const haystack = foldedWords(text);
+  const first = Array.from(wanted)[0];
+  const last = Array.from(wanted).at(-1);
+  for (let at = haystack.indexOf(wanted); at >= 0; at = haystack.indexOf(wanted, at + 1)) {
+    const before = Array.from(haystack.slice(0, at)).at(-1);
+    const after = Array.from(haystack.slice(at + wanted.length))[0];
+    if (!joined(before, first) && !joined(last, after)) return true;
+  }
+  return false;
+}
+
+/** Whether the listener's text names this song, by its title without version suffixes. */
+export function textNamesTitle(text, title) {
+  return textNames(text, normalizedTrackTitle(title));
+}
+
+// Articles that start band names in the supported languages: "Beatles" names "The Beatles".
+const LEADING_ARTICLE = /^(?:the|an|a|los|las|el|la|les|le|l|die|der|das|il|lo|i|gli|os|as|o) (?=\S)/u;
+
+/** Whether text names an artist, with or without a leading article. */
+export function textNamesArtist(text, artist) {
+  const name = foldedWords(artist);
+  const bare = name.replace(LEADING_ARTICLE, "");
+  // "The The" keeps its article: a bare article names nothing.
+  return textNames(text, name) || (bare !== name && !LEADING_ARTICLE.test(`${bare} x`) && textNames(text, bare));
+}
+
+// A quoted name: straight or curly double or single quotes, corner brackets, title marks or
+// guillemets. A straight or curly single quote inside a word is an apostrophe.
+const QUOTED = [/"([^"]+)"/gu, /“([^“”]+)”/gu, /„([^„“”]+)[“”]/gu, /«([^«»]+)»/gu, /「([^「」]+)」/gu, /『([^『』]+)』/gu,
+  /《([^《》]+)》/gu, /(?<![\p{L}\p{N}])'(?=(.+?)'(?![\p{L}\p{N}]))/gu, /‘(.+?)’(?![\p{L}\p{N}])/gu];
+
+/** Whether text quotes this song's title, version suffixes aside. */
+export function textQuotesTitle(text, title) {
+  const wanted = foldedWords(normalizedTrackTitle(title));
+  return Boolean(wanted) && QUOTED.some((pattern) => Array.from(String(text ?? "").matchAll(pattern))
+    .some(([, quoted]) => foldedWords(normalizedTrackTitle(quoted)) === wanted));
+}
+
+/**
+ * Whether the listener's text names this song as their own pick: its title with one of its
+ * credited artists, or its title in quotes. A title alone ("play Pink Moon") is not enough,
+ * because an open request shares words with titles ("a rainy day", "安静").
+ */
+export function textNamesSong(text, title, artists = []) {
+  return textQuotesTitle(text, title) ||
+    (textNamesTitle(text, title) && artists.some((artist) => textNamesArtist(text, artist)));
+}

package/src/i18n/messages/de.mjs

@@ -34,6 +34,7 @@ export default {
   "failure.preparationStopped": ({ evidence }) => `Die Prüfung des Wiedergabegeräts wurde nicht abgeschlossen (${evidence}); es wurde keine Wiedergabe-Anfrage gesendet. Prüfe den Gerätestatus in Spotify, bevor du es erneut versuchst.`,
   "failure.queueRequestRequired": "Es wurden keine Songs zur Warteschlange hinzugefügt: Ich konnte diese Antwort keiner Anfrage für die Warteschlange zuordnen. Um fortzufahren, braucht es eine ausdrückliche Bitte, Musik zur Warteschlange hinzuzufügen.",
   "failure.notSent": ({ code }) => `An Spotify wurde nichts gesendet: Ich konnte das keinem der gefundenen Songs zuordnen (${code}). Frag noch einmal mit Songtitel oder Künstler, dann suche ich erneut.`,
+  "failure.avoided": "An Spotify wurde nichts gesendet: Du wolltest diesen Künstler oder diesen Song nicht mehr hören. Sag mir jederzeit, wenn du das ändern willst.",
   "failure.outcome.lookup": "Die Spotify-Suche wurde nicht abgeschlossen",
   "failure.outcome.unknown": "Das Ergebnis der Spotify-Aktion ist unklar",
   "failure.outcome.unconfirmed": "Die Spotify-Wiedergabeaktion wurde nicht bestätigt",
@@ -61,7 +62,10 @@ export default {
   "queue.skippedDuplicates": ({ count }) => `${count} doppelte Titel übersprungen.`,
   "queue.skippedUncertain": ({ count }) => `${count} Titel mit unklarem früherem Ergebnis übersprungen, um Doppelungen zu vermeiden; prüfe die Spotify-Warteschlange.`,
   "queue.skippedAvoided": ({ count }) => `${count} Titel übersprungen, die du vermeiden wolltest.`,
+  "plan.avoidedLeftOut": ({ titles }) => `Weggelassen, weil du sie nicht mehr hören wolltest: ${titles}.`,
   "queue.skippedKnown": ({ count }) => `${count} Titel aus deinem Hörverlauf übersprungen, wie gewünscht.`,
+  "queue.mix": ({ familiar = 0, returning = 0, heard = 0, known_artist: knownArtist = 0, new: fresh = 0 }) =>
+    `Laut deinem Hörverlauf: ${[familiar && `${familiar} gut bekannt`, returning && `${returning} nach längerer Zeit wieder`, heard && `${heard} ein- oder zweimal gehört`, knownArtist && `${knownArtist} neu von ${knownArtist === 1 ? "einem bekannten Künstler" : "bekannten Künstlern"}`, fresh && `${fresh} neu für dich`].filter(Boolean).join(", ")}.`,
   "queue.observationTruncated": "Doppelungen wurden nur im begrenzten Ausschnitt der Warteschlange geprüft, den Spotify liefert; nicht sichtbare Einträge können noch doppelt sein.",
   "queue.notAddedHeading": "Nicht hinzugefügt:",
   "queue.earlierReceipt": "Das ist das Ergebnis der früheren Warteschlangen-Aktion; diese Klarstellung hat die Songs nicht erneut hinzugefügt.",
@@ -123,6 +127,9 @@ export default {
   "selection.note": ({ playlist, track }) => `\n\nFür weitere Änderungen ausgewählt: Playlist ${playlist}; Song ${track}.`,
   "memory.spotifyExcluded": "\n\nSpotify-Ergebnisse kommen nicht ins allgemeine Gedächtnis; nur deine eigenen, überprüften Worte konnten gespeichert werden, alles andere wurde nicht gespeichert.",
   "memory.notSaved": "\n\nDie Antwort ist fertig, aber die Erinnerung wurde nicht gespeichert.",
+  "choice.like": ({ title, artist }) => { const name = title ? `„${title}“ von ${artist}` : artist; return `\n\nGespeichert: Du magst ${name}. Sag mir jederzeit, wenn du das ändern willst.`; },
+  "choice.avoid": ({ title, artist }) => { const name = title ? `„${title}“ von ${artist}` : artist; return `\n\nGespeichert: Ich lasse ${name} aus allem heraus, was ich spiele und vorschlage. Sag mir jederzeit, wenn du das ändern willst.`; },
+  "choice.retract": ({ title, artist }) => { const name = title ? `„${title}“ von ${artist}` : artist; return `\n\nZurückgenommen: deine frühere Wahl zu ${name}.`; },
   "turn.cancelled": "Weitere Schritte abgebrochen.",
   "turn.interrupted": "Die Antwort wurde unterbrochen. Die erfassten Spotify-Ergebnisse stehen unten; keine Aktion wurde wiederholt.",
 };

package/src/i18n/messages/en.mjs

@@ -35,6 +35,7 @@ export default {
   "failure.preparationStopped": ({ evidence }) => `Playback device checks did not complete (${evidence}); no song play request was sent. Check Spotify device state before trying again.`,
   "failure.queueRequestRequired": "No songs were queued: I could not connect this reply to a queue request. An explicit request to add music to the playback queue is needed to continue.",
   "failure.notSent": ({ code }) => `Nothing was sent to Spotify: I couldn't match that to the songs I found (${code}). Ask again with the song or artist name, and I'll search again.`,
+  "failure.avoided": "Nothing was sent to Spotify: you asked me to keep that artist or song out of what I play. Tell me any time to change it.",
   "failure.outcome.lookup": "The Spotify lookup did not complete",
   "failure.outcome.unknown": "The Spotify action outcome is uncertain",
   "failure.outcome.unconfirmed": "The Spotify playback action was not confirmed",
@@ -62,7 +63,10 @@ export default {
   "queue.skippedDuplicates": ({ count }) => `Skipped ${count} duplicate tracks.`,
   "queue.skippedUncertain": ({ count }) => `Skipped ${count} tracks with earlier uncertain queue outcomes to avoid replay; check the Spotify queue.`,
   "queue.skippedAvoided": ({ count }) => `Skipped ${count} avoided tracks.`,
+  "plan.avoidedLeftOut": ({ titles }) => `Left out because you asked me to keep them out: ${titles}.`,
   "queue.skippedKnown": ({ count }) => `Skipped ${count} tracks matched in retained history, as requested.`,
+  "queue.mix": ({ familiar = 0, returning = 0, heard = 0, known_artist: knownArtist = 0, new: fresh = 0 }) =>
+    `The mix: ${[familiar && `${familiar} you know well`, returning && `${returning} back after a while`, heard && `${heard} you've heard once or twice`, knownArtist && `${knownArtist} new from ${knownArtist === 1 ? "an artist" : "artists"} you know`, fresh && `${fresh} new to you`].filter(Boolean).join(", ")}.`,
   "queue.observationTruncated": "Deduplication covers Spotify's bounded queue snapshot; unseen entries may still duplicate a selection.",
   "queue.notAddedHeading": "Not added:",
   "queue.earlierReceipt": "This is the earlier queue receipt; this clarification did not add the songs again.",
@@ -124,6 +128,9 @@ export default {
   "selection.note": ({ playlist, track }) => `\n\nSelected for follow-up edits: playlist ${playlist}; song ${track}.`,
   "memory.spotifyExcluded": "\n\nSpotify results are excluded from generic memory; only verified user quotes were eligible, and other claims were not saved.",
   "memory.notSaved": "\n\nThe response completed, but the memory was not saved.",
+  "choice.like": ({ title, artist }) => { const name = title ? `"${title}" by ${artist}` : artist; return `\n\nSaved: you like ${name}. Tell me any time to change it.`; },
+  "choice.avoid": ({ title, artist }) => { const name = title ? `"${title}" by ${artist}` : artist; return `\n\nSaved: I'll keep ${name} out of what I play and suggest. Tell me any time to change it.`; },
+  "choice.retract": ({ title, artist }) => { const name = title ? `"${title}" by ${artist}` : artist; return `\n\nUndone: your earlier choice about ${name}.`; },
   "turn.cancelled": "Cancelled further work.",
   "turn.interrupted": "The response was interrupted. The recorded Spotify outcomes are below; no action was replayed.",
 };

package/src/i18n/messages/es.mjs

@@ -34,6 +34,7 @@ export default {
   "failure.preparationStopped": ({ evidence }) => `Las comprobaciones del dispositivo no terminaron (${evidence}); no se envió ninguna petición de reproducción. Revisa el estado del dispositivo en Spotify antes de volver a intentarlo.`,
   "failure.queueRequestRequired": "No se añadió ninguna canción: no pude relacionar esta respuesta con una petición para la cola. Para seguir, pide de forma explícita añadir música a la cola.",
   "failure.notSent": ({ code }) => `No envié nada a Spotify: no pude relacionarlo con las canciones que encontré (${code}). Vuelve a pedirlo con el nombre de la canción o del artista y la busco de nuevo.`,
+  "failure.avoided": "No envié nada a Spotify: me pediste dejar fuera a ese artista o esa canción. Dime cuando quieras cambiarlo.",
   "failure.outcome.lookup": "La búsqueda en Spotify no terminó",
   "failure.outcome.unknown": "No se sabe con certeza el resultado de la acción en Spotify",
   "failure.outcome.unconfirmed": "Spotify no confirmó la acción de reproducción",
@@ -61,7 +62,10 @@ export default {
   "queue.skippedDuplicates": ({ count }) => `Omití ${count} canciones repetidas.`,
   "queue.skippedUncertain": ({ count }) => `Omití ${count} canciones cuyo resultado anterior en la cola no estaba claro, para no repetirlas; revisa la cola de Spotify.`,
   "queue.skippedAvoided": ({ count }) => `Omití ${count} canciones que marcaste para evitar.`,
+  "plan.avoidedLeftOut": ({ titles }) => `Dejé fuera lo que me pediste evitar: ${titles}.`,
   "queue.skippedKnown": ({ count }) => `Omití ${count} canciones que ya aparecen en tu historial, como pediste.`,
+  "queue.mix": ({ familiar = 0, returning = 0, heard = 0, known_artist: knownArtist = 0, new: fresh = 0 }) =>
+    `Según tu historial: ${[familiar && `${familiar} que conoces bien`, returning && `${returning} ${returning === 1 ? "que vuelve" : "que vuelven"} después de un tiempo`, heard && `${heard} que has oído una o dos veces`, knownArtist && `${knownArtist} ${knownArtist === 1 ? "nueva de un artista" : "nuevas de artistas"} que conoces`, fresh && `${fresh} ${fresh === 1 ? "nueva" : "nuevas"} para ti`].filter(Boolean).join(", ")}.`,
   "queue.observationTruncated": "La comprobación de repetidas solo cubre la parte de la cola que muestra Spotify; lo que no se ve podría repetir alguna.",
   "queue.notAddedHeading": "Sin añadir:",
   "queue.earlierReceipt": "Este es el resultado de la cola anterior; esta aclaración no volvió a añadir las canciones.",
@@ -123,6 +127,9 @@ export default {
   "selection.note": ({ playlist, track }) => `\n\nSeleccionado para próximos cambios: playlist ${playlist}; canción ${track}.`,
   "memory.spotifyExcluded": "\n\nLos resultados de Spotify no se guardan en la memoria general; solo se podían guardar citas tuyas verificables, y lo demás no se guardó.",
   "memory.notSaved": "\n\nLa respuesta terminó, pero no se pudo guardar la memoria.",
+  "choice.like": ({ title, artist }) => { const name = title ? `"${title}" de ${artist}` : artist; return `\n\nGuardado: te gusta ${name}. Dímelo cuando quieras cambiarlo.`; },
+  "choice.avoid": ({ title, artist }) => { const name = title ? `"${title}" de ${artist}` : artist; return `\n\nGuardado: dejaré ${name} fuera de lo que pongo y te sugiero. Dímelo cuando quieras cambiarlo.`; },
+  "choice.retract": ({ title, artist }) => { const name = title ? `"${title}" de ${artist}` : artist; return `\n\nDeshecho: tu elección anterior sobre ${name}.`; },
   "turn.cancelled": "Cancelé el resto.",
   "turn.interrupted": "La respuesta se interrumpió. Abajo están los resultados registrados en Spotify; no se repitió ninguna acción.",
 };

package/src/i18n/messages/fr.mjs

@@ -34,6 +34,7 @@ export default {
   "failure.preparationStopped": ({ evidence }) => `Les vérifications de l'appareil de lecture n'ont pas abouti (${evidence}) ; aucune demande de lecture n'a été envoyée. Vérifiez l'état de l'appareil Spotify avant de réessayer.`,
   "failure.queueRequestRequired": "Aucun morceau n'a été ajouté à la file d'attente : je n'ai pas pu relier cette réponse à une demande d'ajout. Il faut une demande explicite d'ajouter de la musique à la file d'attente pour continuer.",
   "failure.notSent": ({ code }) => `Rien n'a été envoyé à Spotify : je n'ai pas pu relier cela aux morceaux trouvés (${code}). Redemandez avec le titre ou l'artiste, et je chercherai à nouveau.`,
+  "failure.avoided": "Rien n'a été envoyé à Spotify : vous m'avez demandé d'écarter cet artiste ou ce morceau. Dites-le-moi quand vous voulez pour changer cela.",
   "failure.outcome.lookup": "La recherche Spotify n'a pas abouti",
   "failure.outcome.unknown": "Le résultat de l'action Spotify est incertain",
   "failure.outcome.unconfirmed": "L'action de lecture Spotify n'a pas été confirmée",
@@ -61,7 +62,10 @@ export default {
   "queue.skippedDuplicates": ({ count }) => `${count} doublons ignorés.`,
   "queue.skippedUncertain": ({ count }) => `${count} morceaux ignorés pour éviter un doublon, car leur ajout précédent est incertain ; vérifiez la file d'attente Spotify.`,
   "queue.skippedAvoided": ({ count }) => `${count} morceaux à éviter ignorés.`,
+  "plan.avoidedLeftOut": ({ titles }) => `Laissés de côté, comme vous me l'avez demandé : ${titles}.`,
   "queue.skippedKnown": ({ count }) => `${count} morceaux déjà présents dans votre historique ignorés, comme demandé.`,
+  "queue.mix": ({ familiar = 0, returning = 0, heard = 0, known_artist: knownArtist = 0, new: fresh = 0 }) =>
+    `D'après votre historique : ${[familiar && `${familiar} que vous connaissez bien`, returning && `${returning} ${returning === 1 ? "qui revient" : "qui reviennent"} après un moment`, heard && `${heard} ${heard === 1 ? "entendu" : "entendus"} une ou deux fois`, knownArtist && `${knownArtist} ${knownArtist === 1 ? "nouveau d'un artiste" : "nouveaux d'artistes"} que vous connaissez`, fresh && `${fresh} ${fresh === 1 ? "nouveau" : "nouveaux"} pour vous`].filter(Boolean).join(", ")}.`,
   "queue.observationTruncated": "Le dédoublonnage ne couvre que l'extrait limité de la file que Spotify renvoie ; des entrées non visibles peuvent encore faire doublon.",
   "queue.notAddedHeading": "Non ajoutés :",
   "queue.earlierReceipt": "Voici le reçu de l'ajout précédent ; cette précision n'a pas ajouté les morceaux une seconde fois.",
@@ -123,6 +127,9 @@ export default {
   "selection.note": ({ playlist, track }) => `\n\nSélection pour les prochaines modifications : playlist ${playlist} ; morceau ${track}.`,
   "memory.spotifyExcluded": "\n\nLes résultats Spotify sont exclus de la mémoire générale ; seules vos propres paroles vérifiées pouvaient être retenues, et le reste n'a pas été enregistré.",
   "memory.notSaved": "\n\nLa réponse est terminée, mais la mémoire n'a pas été enregistrée.",
+  "choice.like": ({ title, artist }) => { const name = title ? `« ${title} » de ${artist}` : artist; return `\n\nEnregistré : vous aimez ${name}. Dites-le-moi quand vous voulez pour le changer.`; },
+  "choice.avoid": ({ title, artist }) => { const name = title ? `« ${title} » de ${artist}` : artist; return `\n\nEnregistré : je laisserai ${name} de côté dans ce que je joue et propose. Dites-le-moi quand vous voulez pour le changer.`; },
+  "choice.retract": ({ title, artist }) => { const name = title ? `« ${title} » de ${artist}` : artist; return `\n\nAnnulé : votre choix précédent sur ${name}.`; },
   "turn.cancelled": "Suite annulée.",
   "turn.interrupted": "La réponse a été interrompue. Les résultats Spotify enregistrés figurent ci-dessous ; aucune action n'a été relancée.",
 };

package/src/i18n/messages/it.mjs

@@ -34,6 +34,7 @@ export default {
   "failure.preparationStopped": ({ evidence }) => `I controlli del dispositivo di riproduzione non sono stati completati (${evidence}); non è stata inviata alcuna richiesta di riproduzione. Controlla lo stato del dispositivo Spotify prima di riprovare.`,
   "failure.queueRequestRequired": "Nessun brano è stato messo in coda: non sono riuscito a collegare questa risposta a una richiesta di coda. Per continuare serve una richiesta esplicita di aggiungere musica alla coda di riproduzione.",
   "failure.notSent": ({ code }) => `Non ho inviato nulla a Spotify: non sono riuscito a collegarlo ai brani trovati (${code}). Chiedimelo di nuovo con il titolo o l'artista e cercherò ancora.`,
+  "failure.avoided": "Non ho inviato nulla a Spotify: mi hai chiesto di lasciare fuori questo artista o questo brano. Dimmelo quando vuoi per cambiarlo.",
   "failure.outcome.lookup": "La ricerca su Spotify non è stata completata",
   "failure.outcome.unknown": "L'esito dell'azione su Spotify è incerto",
   "failure.outcome.unconfirmed": "L'azione di riproduzione su Spotify non è stata confermata",
@@ -61,7 +62,10 @@ export default {
   "queue.skippedDuplicates": ({ count }) => `Saltati ${count} brani duplicati.`,
   "queue.skippedUncertain": ({ count }) => `Saltati ${count} brani con un esito precedente incerto, per evitare doppioni; controlla la coda di Spotify.`,
   "queue.skippedAvoided": ({ count }) => `Saltati ${count} brani che volevi evitare.`,
+  "plan.avoidedLeftOut": ({ titles }) => `Lasciati fuori, come mi hai chiesto: ${titles}.`,
   "queue.skippedKnown": ({ count }) => `Saltati ${count} brani già presenti nella tua cronologia, come richiesto.`,
+  "queue.mix": ({ familiar = 0, returning = 0, heard = 0, known_artist: knownArtist = 0, new: fresh = 0 }) =>
+    `Secondo la tua cronologia: ${[familiar && `${familiar} che conosci bene`, returning && `${returning} ${returning === 1 ? "che torna" : "che tornano"} dopo un po'`, heard && `${heard} ${heard === 1 ? "sentito" : "sentiti"} una o due volte`, knownArtist && `${knownArtist} ${knownArtist === 1 ? "nuovo da un artista" : "nuovi da artisti"} che conosci`, fresh && `${fresh} ${fresh === 1 ? "nuovo" : "nuovi"} per te`].filter(Boolean).join(", ")}.`,
   "queue.observationTruncated": "Il controllo dei doppioni copre solo la parte limitata della coda restituita da Spotify; le voci non visibili potrebbero ancora essere doppioni.",
   "queue.notAddedHeading": "Non aggiunti:",
   "queue.earlierReceipt": "Questo è l'esito della richiesta di coda precedente; questo chiarimento non ha aggiunto di nuovo i brani.",
@@ -123,6 +127,9 @@ export default {
   "selection.note": ({ playlist, track }) => `\n\nSelezionati per le prossime modifiche: playlist ${playlist}; brano ${track}.`,
   "memory.spotifyExcluded": "\n\nI risultati di Spotify sono esclusi dalla memoria generale; si potevano ricordare solo le tue parole verificate, e il resto non è stato salvato.",
   "memory.notSaved": "\n\nLa risposta è completa, ma la memoria non è stata salvata.",
+  "choice.like": ({ title, artist }) => { const name = title ? `"${title}" di ${artist}` : artist; return `\n\nSalvato: ti piace ${name}. Dimmelo quando vuoi cambiarlo.`; },
+  "choice.avoid": ({ title, artist }) => { const name = title ? `"${title}" di ${artist}` : artist; return `\n\nSalvato: terrò ${name} fuori da ciò che suono e ti propongo. Dimmelo quando vuoi cambiarlo.`; },
+  "choice.retract": ({ title, artist }) => { const name = title ? `"${title}" di ${artist}` : artist; return `\n\nAnnullato: la tua scelta precedente su ${name}.`; },
   "turn.cancelled": "Ho annullato il resto.",
   "turn.interrupted": "La risposta si è interrotta. Gli esiti di Spotify registrati sono qui sotto; nessuna azione è stata ripetuta.",
 };

package/src/i18n/messages/ja.mjs

@@ -34,6 +34,7 @@ export default {
   "failure.preparationStopped": ({ evidence }) => `再生前のデバイス確認が完了しませんでした（${evidence}）。再生リクエストは送っていません。Spotify のデバイスの状態を確認してから、もう一度試してください。`,
   "failure.queueRequestRequired": "曲は追加していません。この返事をキューへの追加リクエストと結びつけられませんでした。続けるには、キューに追加したいとはっきり伝えてください。",
   "failure.notSent": ({ code }) => `Spotify には何も送っていません。さっき見つけた曲と結び付けられませんでした（${code}）。曲名かアーティスト名を添えてもう一度頼んでください。改めて探します。`,
+  "failure.avoided": "Spotify には何も送っていません。このアーティストか曲は流さないように、と言われています。変えたいときはいつでも言ってください。",
   "failure.outcome.lookup": "Spotify での検索が完了しませんでした",
   "failure.outcome.unknown": "Spotify での操作結果がわかりません",
   "failure.outcome.unconfirmed": "Spotify が再生操作を確認しませんでした",
@@ -61,7 +62,10 @@ export default {
   "queue.skippedDuplicates": ({ count }) => `重複していた ${count} 曲を飛ばしました。`,
   "queue.skippedUncertain": ({ count }) => `前回キューへの追加結果がはっきりしなかった ${count} 曲を、重複を避けるため飛ばしました。Spotify のキューを確認してください。`,
   "queue.skippedAvoided": ({ count }) => `避けるよう指定された ${count} 曲を飛ばしました。`,
+  "plan.avoidedLeftOut": ({ titles }) => `流さないように言われていた曲は外しました：${titles}。`,
   "queue.skippedKnown": ({ count }) => `ご希望どおり、再生履歴にある ${count} 曲を飛ばしました。`,
+  "queue.mix": ({ familiar = 0, returning = 0, heard = 0, known_artist: knownArtist = 0, new: fresh = 0 }) =>
+    `再生履歴では: ${[familiar && `よく知っている曲 ${familiar} 曲`, returning && `久しぶりの曲 ${returning} 曲`, heard && `1、2 回聴いた曲 ${heard} 曲`, knownArtist && `知っているアーティストの新しい曲 ${knownArtist} 曲`, fresh && `初めての曲 ${fresh} 曲`].filter(Boolean).join("、")}。`,
   "queue.observationTruncated": "重複の確認は Spotify が表示するキューの範囲だけです。表示されていない部分と重なる可能性があります。",
   "queue.notAddedHeading": "まだ追加していない曲:",
   "queue.earlierReceipt": "これは前回のキュー操作の結果です。今回の補足では曲を再度追加していません。",
@@ -123,6 +127,9 @@ export default {
   "selection.note": ({ playlist, track }) => `\n\n続けて編集する対象: プレイリスト ${playlist}、曲 ${track}。`,
   "memory.spotifyExcluded": "\n\nSpotify の検索結果は一般の記憶には残しません。確認できるあなたの発言だけが対象で、それ以外は保存していません。",
   "memory.notSaved": "\n\n返事は完了しましたが、記憶は保存できませんでした。",
+  "choice.like": ({ title, artist }) => { const name = title ? `${artist}の「${title}」` : artist; return `\n\n保存しました: ${name}が好き。変えたいときはいつでも言ってください。`; },
+  "choice.avoid": ({ title, artist }) => { const name = title ? `${artist}の「${title}」` : artist; return `\n\n保存しました: ${name}は再生にもおすすめにも入れません。変えたいときはいつでも言ってください。`; },
+  "choice.retract": ({ title, artist }) => { const name = title ? `${artist}の「${title}」` : artist; return `\n\n取り消しました: ${name}についての前の選択。`; },
   "turn.cancelled": "以降の処理をキャンセルしました。",
   "turn.interrupted": "返事が中断されました。記録された Spotify の操作結果は下のとおりです。操作は繰り返していません。",
 };

package/src/i18n/messages/ko.mjs

@@ -34,6 +34,7 @@ export default {
   "failure.preparationStopped": ({ evidence }) => `재생 기기 확인을 마치지 못했습니다(${evidence}). 곡 재생 요청은 보내지 않았습니다. Spotify 기기 상태를 확인한 뒤 다시 시도해 주세요.`,
   "failure.queueRequestRequired": "곡을 대기열에 넣지 않았습니다. 이 답변을 대기열 추가 요청과 연결하지 못했습니다. 계속하려면 재생 대기열에 음악을 넣어 달라고 분명히 요청해 주세요.",
   "failure.notSent": ({ code }) => `Spotify에 아무것도 보내지 않았습니다. 방금 찾은 곡과 연결하지 못했습니다(${code}). 곡 제목이나 아티스트 이름을 넣어 다시 말해 주시면 다시 찾아볼게요.`,
+  "failure.avoided": "Spotify에 아무것도 보내지 않았습니다. 이 아티스트나 곡은 틀지 말라고 하셨어요. 바꾸고 싶으면 언제든 말해 주세요.",
   "failure.outcome.lookup": "Spotify 검색을 마치지 못했습니다",
   "failure.outcome.unknown": "Spotify 작업 결과가 확실하지 않습니다",
   "failure.outcome.unconfirmed": "Spotify 재생 작업이 확인되지 않았습니다",
@@ -61,7 +62,10 @@ export default {
   "queue.skippedDuplicates": ({ count }) => `중복된 곡 ${count}곡을 건너뛰었습니다.`,
   "queue.skippedUncertain": ({ count }) => `이전 대기열 결과가 불확실한 곡 ${count}곡은 중복을 피하려고 건너뛰었습니다. Spotify 대기열을 확인해 주세요.`,
   "queue.skippedAvoided": ({ count }) => `피해 달라고 한 곡 ${count}곡을 건너뛰었습니다.`,
+  "plan.avoidedLeftOut": ({ titles }) => `틀지 말라고 하신 곡은 뺐습니다: ${titles}.`,
   "queue.skippedKnown": ({ count }) => `요청대로 청취 기록에 있는 곡 ${count}곡을 건너뛰었습니다.`,
+  "queue.mix": ({ familiar = 0, returning = 0, heard = 0, known_artist: knownArtist = 0, new: fresh = 0 }) =>
+    `청취 기록 기준: ${[familiar && `잘 아는 곡 ${familiar}곡`, returning && `오랜만인 곡 ${returning}곡`, heard && `한두 번 들은 곡 ${heard}곡`, knownArtist && `아는 아티스트의 새 곡 ${knownArtist}곡`, fresh && `처음 듣는 곡 ${fresh}곡`].filter(Boolean).join(", ")}.`,
   "queue.observationTruncated": "Spotify가 돌려준 대기열의 일부만 확인했습니다. 보이지 않는 부분에 같은 곡이 있을 수 있습니다.",
   "queue.notAddedHeading": "추가하지 않은 곡:",
   "queue.earlierReceipt": "이것은 앞선 대기열 작업의 결과입니다. 이번 설명으로 곡을 다시 넣지는 않았습니다.",
@@ -123,6 +127,9 @@ export default {
   "selection.note": ({ playlist, track }) => `\n\n다음 편집에 쓸 항목: 플레이리스트 ${playlist}, 곡 ${track}.`,
   "memory.spotifyExcluded": "\n\nSpotify 결과는 일반 기억에 넣지 않습니다. 확인된 사용자 본인의 말만 기억할 수 있으며, 다른 내용은 저장하지 않았습니다.",
   "memory.notSaved": "\n\n답변은 끝났지만 기억을 저장하지 못했습니다.",
+  "choice.like": ({ title, artist }) => { const name = title ? `${artist}의 "${title}"` : artist; return `\n\n저장했습니다: ${name}을(를) 좋아하신다고요. 바꾸고 싶으면 언제든 말씀해 주세요.`; },
+  "choice.avoid": ({ title, artist }) => { const name = title ? `${artist}의 "${title}"` : artist; return `\n\n저장했습니다: ${name}은(는) 재생하거나 추천하지 않겠습니다. 바꾸고 싶으면 언제든 말씀해 주세요.`; },
+  "choice.retract": ({ title, artist }) => { const name = title ? `${artist}의 "${title}"` : artist; return `\n\n취소했습니다: ${name}에 대한 이전 선택.`; },
   "turn.cancelled": "남은 작업을 취소했습니다.",
   "turn.interrupted": "답변이 중단되었습니다. 기록된 Spotify 결과는 아래와 같으며, 어떤 작업도 다시 실행하지 않았습니다.",
 };

package/src/i18n/messages/pt.mjs

@@ -34,6 +34,7 @@ export default {
   "failure.preparationStopped": ({ evidence }) => `As verificações do dispositivo não terminaram (${evidence}); nenhum pedido de reprodução foi enviado. Confira o estado do dispositivo no Spotify antes de tentar de novo.`,
   "failure.queueRequestRequired": "Nenhuma música foi adicionada: não consegui ligar esta resposta a um pedido de fila. Para continuar, peça explicitamente para adicionar música à fila.",
   "failure.notSent": ({ code }) => `Não enviei nada ao Spotify: não consegui relacionar isso com as músicas que encontrei (${code}). Peça de novo com o nome da música ou do artista, e eu procuro outra vez.`,
+  "failure.avoided": "Não enviei nada ao Spotify: você pediu para eu deixar esse artista ou essa música de fora. Me diga quando quiser mudar isso.",
   "failure.outcome.lookup": "A busca no Spotify não terminou",
   "failure.outcome.unknown": "Não se sabe ao certo o resultado da ação no Spotify",
   "failure.outcome.unconfirmed": "O Spotify não confirmou a ação de reprodução",
@@ -61,7 +62,10 @@ export default {
   "queue.skippedDuplicates": ({ count }) => `Pulei ${count} músicas repetidas.`,
   "queue.skippedUncertain": ({ count }) => `Pulei ${count} músicas cujo resultado anterior na fila não ficou claro, para não repetir; confira a fila do Spotify.`,
   "queue.skippedAvoided": ({ count }) => `Pulei ${count} músicas que você marcou para evitar.`,
+  "plan.avoidedLeftOut": ({ titles }) => `Deixei de fora o que você pediu para evitar: ${titles}.`,
   "queue.skippedKnown": ({ count }) => `Pulei ${count} músicas que já aparecem no seu histórico, como você pediu.`,
+  "queue.mix": ({ familiar = 0, returning = 0, heard = 0, known_artist: knownArtist = 0, new: fresh = 0 }) =>
+    `Pelo seu histórico: ${[familiar && `${familiar} que você conhece bem`, returning && `${returning} ${returning === 1 ? "que volta" : "que voltam"} depois de um tempo`, heard && `${heard} que você ouviu uma ou duas vezes`, knownArtist && `${knownArtist} ${knownArtist === 1 ? "nova de um artista" : "novas de artistas"} que você conhece`, fresh && `${fresh} ${fresh === 1 ? "nova" : "novas"} para você`].filter(Boolean).join(", ")}.`,
   "queue.observationTruncated": "A checagem de repetidas só cobre a parte da fila que o Spotify mostra; o que não aparece ainda pode repetir alguma.",
   "queue.notAddedHeading": "Não adicionadas:",
   "queue.earlierReceipt": "Este é o resultado da fila anterior; este esclarecimento não adicionou as músicas de novo.",
@@ -123,6 +127,9 @@ export default {
   "selection.note": ({ playlist, track }) => `\n\nSelecionado para as próximas edições: playlist ${playlist}; música ${track}.`,
   "memory.spotifyExcluded": "\n\nOs resultados do Spotify não vão para a memória geral; só citações suas verificáveis podiam ser guardadas, e o resto não foi salvo.",
   "memory.notSaved": "\n\nA resposta terminou, mas não foi possível salvar a memória.",
+  "choice.like": ({ title, artist }) => { const name = title ? `"${title}" de ${artist}` : artist; return `\n\nSalvo: você gosta de ${name}. É só me dizer quando quiser mudar.`; },
+  "choice.avoid": ({ title, artist }) => { const name = title ? `"${title}" de ${artist}` : artist; return `\n\nSalvo: vou deixar ${name} fora do que eu toco e sugiro. É só me dizer quando quiser mudar.`; },
+  "choice.retract": ({ title, artist }) => { const name = title ? `"${title}" de ${artist}` : artist; return `\n\nDesfeito: sua escolha anterior sobre ${name}.`; },
   "turn.cancelled": "Cancelei o resto.",
   "turn.interrupted": "A resposta foi interrompida. Abaixo estão os resultados registrados no Spotify; nenhuma ação foi repetida.",
 };

package/src/i18n/messages/zh-Hant.mjs

@@ -34,6 +34,7 @@ export default {
   "failure.preparationStopped": ({ evidence }) => `播放前的裝置檢查沒有完成（${evidence}），沒有送出歌曲播放請求。請檢查 Spotify 裝置狀態後再試。`,
   "failure.queueRequestRequired": "這次沒有加入歌曲：我沒辦法把這則回覆對應到加入佇列的請求。需要明確請我加入播放佇列，才能繼續。",
   "failure.notSent": ({ code }) => `沒有向 Spotify 送出任何內容：我沒辦法把它對應到剛才找到的歌曲（${code}）。請帶上歌名或歌手再說一次，我會重新搜尋。`,
+  "failure.avoided": "沒有向 Spotify 送出任何內容：你要我別再放這位歌手或這首歌。想改的話隨時告訴我。",
   "failure.outcome.lookup": "Spotify 查詢沒有完成",
   "failure.outcome.unknown": "Spotify 操作結果尚不確定",
   "failure.outcome.unconfirmed": "Spotify 播放操作未獲確認",
@@ -61,7 +62,10 @@ export default {
   "queue.skippedDuplicates": ({ count }) => `略過 ${count} 首重複曲目。`,
   "queue.skippedUncertain": ({ count }) => `略過 ${count} 首先前加入結果不明的曲目，避免重複；請檢查 Spotify 佇列。`,
   "queue.skippedAvoided": ({ count }) => `略過 ${count} 首你要求避開的曲目。`,
+  "plan.avoidedLeftOut": ({ titles }) => `依你的要求略過了：${titles}。`,
   "queue.skippedKnown": ({ count }) => `依你的要求，略過 ${count} 首聆聽紀錄裡已有的曲目。`,
+  "queue.mix": ({ familiar = 0, returning = 0, heard = 0, known_artist: knownArtist = 0, new: fresh = 0 }) =>
+    `根據你的聆聽紀錄：${[familiar && `熟悉的 ${familiar} 首`, returning && `久違的 ${returning} 首`, heard && `聽過一兩次的 ${heard} 首`, knownArtist && `熟悉歌手的新歌 ${knownArtist} 首`, fresh && `沒聽過的 ${fresh} 首`].filter(Boolean).join("，")}。`,
   "queue.observationTruncated": "只檢查了 Spotify 回傳的有限佇列片段，沒顯示的部分仍可能重複。",
   "queue.notAddedHeading": "沒有加入：",
   "queue.earlierReceipt": "這是上一次佇列操作的結果；這次說明沒有再次加入歌曲。",
@@ -123,6 +127,9 @@ export default {
   "selection.note": ({ playlist, track }) => `\n\n接下來的編輯會用：播放清單 ${playlist}；歌曲 ${track}。`,
   "memory.spotifyExcluded": "\n\nSpotify 的結果不會進入一般記憶；只有可驗證的你的原話會被記住，其他內容沒有儲存。",
   "memory.notSaved": "\n\n這則回覆已完成，但記憶沒有儲存成功。",
+  "choice.like": ({ title, artist }) => { const name = title ? `${artist}的《${title}》` : artist; return `\n\n已儲存：你喜歡${name}。想改的話隨時告訴我。`; },
+  "choice.avoid": ({ title, artist }) => { const name = title ? `${artist}的《${title}》` : artist; return `\n\n已儲存：我播放和推薦時都會避開${name}。想改的話隨時告訴我。`; },
+  "choice.retract": ({ title, artist }) => { const name = title ? `${artist}的《${title}》` : artist; return `\n\n已撤銷：你之前對${name}的選擇。`; },
   "turn.cancelled": "已取消後續操作。",
   "turn.interrupted": "回覆中斷了。已記錄的 Spotify 結果如下；沒有重新執行任何操作。",
 };

package/src/i18n/messages/zh.mjs

@@ -34,6 +34,7 @@ export default {
   "failure.preparationStopped": ({ evidence }) => `播放前的设备检查未完成（${evidence}），没有发送歌曲播放请求。请检查 Spotify 设备状态后再试。`,
   "failure.queueRequestRequired": "这次没有加入歌曲：我没能把这条回复关联到入队请求。需要明确要加入播放队列，才能继续。",
   "failure.notSent": ({ code }) => `没有向 Spotify 发送任何内容：我没能把它对应到刚才找到的歌曲（${code}）。请带上歌名或歌手再说一次，我会重新搜索。`,
+  "failure.avoided": "没有向 Spotify 发送任何内容：你让我别再放这位歌手或这首歌。想改的话随时告诉我。",
   "failure.outcome.lookup": "Spotify 查询未完成",
   "failure.outcome.unknown": "Spotify 操作结果尚不确定",
   "failure.outcome.unconfirmed": "Spotify 播放操作未获确认",
@@ -61,7 +62,10 @@ export default {
   "queue.skippedDuplicates": ({ count }) => `跳过 ${count} 首重复曲目。`,
   "queue.skippedUncertain": ({ count }) => `跳过 ${count} 首此前入队结果不明的曲目，避免重复；请先检查 Spotify 队列。`,
   "queue.skippedAvoided": ({ count }) => `跳过 ${count} 首 Avoid 曲目。`,
+  "plan.avoidedLeftOut": ({ titles }) => `按你的要求略过了：${titles}。`,
   "queue.skippedKnown": ({ count }) => `按你的要求跳过 ${count} 首有保留听歌记录的曲目。`,
+  "queue.mix": ({ familiar = 0, returning = 0, heard = 0, known_artist: knownArtist = 0, new: fresh = 0 }) =>
+    `根据你的听歌记录：${[familiar && `熟悉的 ${familiar} 首`, returning && `久违的 ${returning} 首`, heard && `听过一两次的 ${heard} 首`, knownArtist && `熟悉歌手的新歌 ${knownArtist} 首`, fresh && `没听过的 ${fresh} 首`].filter(Boolean).join("，")}。`,
   "queue.observationTruncated": "仅检查了 Spotify 返回的有限队列片段，无法保证未显示部分没有重复。",
   "queue.notAddedHeading": "还没加入：",
   "queue.earlierReceipt": "这是上次队列操作的结果；这次澄清没有再次添加歌曲。",
@@ -123,6 +127,9 @@ export default {
   "selection.note": ({ playlist, track }) => `\n\n后续编辑选择：歌单 ${playlist}；歌曲 ${track}。`,
   "memory.spotifyExcluded": "\n\nSpotify 查询结果不进入通用记忆；仅保存可验证的用户原话，其他记忆未保存。",
   "memory.notSaved": "\n\n这条回复已经完成，但记忆没有成功保存。",
+  "choice.like": ({ title, artist }) => { const name = title ? `${artist}的《${title}》` : artist; return `\n\n已保存：你喜欢${name}。想改的话随时告诉我。`; },
+  "choice.avoid": ({ title, artist }) => { const name = title ? `${artist}的《${title}》` : artist; return `\n\n已保存：我播放和推荐时都会避开${name}。想改的话随时告诉我。`; },
+  "choice.retract": ({ title, artist }) => { const name = title ? `${artist}的《${title}》` : artist; return `\n\n已撤销：你之前对${name}的选择。`; },
   "turn.cancelled": "已取消后续操作。",
   "turn.interrupted": "回复中断；已确认的 Spotify 操作结果如下。未重新执行任何操作。",
 };

package/src/i18n/screen/es.mjs

@@ -868,6 +868,7 @@ export default {
   "Remember what you've told me": "Recordar lo que me has dicho",
   "Remember something you said": "Recordar algo que dijiste",
   "Forget something": "Olvidar algo",
+  "Save your choice": "Guardar tu elección",
   "Check what Spotify is playing": "Ver qué suena en Spotify",
   "See what's playing in detail": "Ver en detalle qué suena",
   "Control Spotify playback": "Controlar la reproducción de Spotify",

package/src/i18n/screen/ja.mjs

@@ -868,6 +868,7 @@ export default {
   "Remember what you've told me": "教えてもらったことを覚える",
   "Remember something you said": "あなたの言ったことを覚える",
   "Forget something": "忘れる",
+  "Save your choice": "あなたの選択を保存する",
   "Check what Spotify is playing": "Spotify で再生中のものを確認",
   "See what's playing in detail": "再生中の曲の詳細を見る",
   "Control Spotify playback": "Spotify の再生を操作",

package/src/i18n/screen/pt.mjs

@@ -868,6 +868,7 @@ export default {
   "Remember what you've told me": "Lembrar o que você me disse",
   "Remember something you said": "Lembrar algo que você disse",
   "Forget something": "Esquecer algo",
+  "Save your choice": "Salvar sua escolha",
   "Check what Spotify is playing": "Ver o que está tocando no Spotify",
   "See what's playing in detail": "Ver em detalhe o que está tocando",
   "Control Spotify playback": "Controlar a reprodução do Spotify",

package/src/i18n/screen/zh.mjs

@@ -868,6 +868,7 @@ export default {
   "Remember what you've told me": "记住你告诉我的",
   "Remember something you said": "记住你说过的一件事",
   "Forget something": "忘掉一件事",
+  "Save your choice": "保存你的选择",
   "Check what Spotify is playing": "查看 Spotify 正在放什么",
   "See what's playing in detail": "查看正在播放的详情",
   "Control Spotify playback": "控制 Spotify 播放",

package/src/integrations/apple-music/catalog.mjs

@@ -452,6 +452,15 @@ export function createAppleMusicCatalogClient({
     });
   }
 
+  // One artist's songs as Apple lists them. The keyword search has no entry for some albums, such as
+  // 刘森's 华北浪革, and their album lookup lists no songs, but the artist's lookup has them.
+  async function artistSongResults(artistId) {
+    const catalogId = cleanArtistCatalogId(artistId);
+    const key = `artist-songs|${storefront()}|${catalogId}`;
+    return cachedRequest(cache, key, cacheTtlMs, now, () =>
+      request("/lookup", { id: catalogId, country: storefront().toLowerCase(), entity: "song", limit: 200 }));
+  }
+
   return Object.freeze({
     async searchTracks(query) {
       const cleaned = cleanInputText(
@@ -491,8 +500,13 @@ export function createAppleMusicCatalogClient({
       return cachedRequest(cache, key, cacheTtlMs, now, async () => {
         const results = await request("/lookup", { id: catalogId, country: storefront().toLowerCase(), entity: "song", limit: 200 });
         const order = (raw) => (Number.isSafeInteger(raw?.discNumber) ? raw.discNumber : 1) * 1000 + (Number.isSafeInteger(raw?.trackNumber) ? raw.trackNumber : 999);
-        return results
-          .filter((raw) => isPlainObject(raw) && raw.kind === "song")
+        const song = (raw) => isPlainObject(raw) && raw.kind === "song";
+        let songs = results.filter(song);
+        const artistId = safeCatalogId(results.find((raw) => isPlainObject(raw) && raw.wrapperType === "collection")?.artistId);
+        if (!songs.length && artistId) {
+          songs = (await artistSongResults(artistId)).filter((raw) => song(raw) && safeCatalogId(raw.collectionId) === catalogId);
+        }
+        return songs
           .sort((left, right) => order(left) - order(right))
           .map(normalizeTrack)
           .filter(Boolean);
@@ -528,6 +542,10 @@ export function createAppleMusicCatalogClient({
     async artistReleases(artistId) {
       return (await artistCatalog(artistId)).releases;
     },
+
+    async artistSongs(artistId) {
+      return (await artistSongResults(artistId)).map(normalizeTrack).filter(Boolean);
+    },
   });
 }
 
@@ -555,6 +573,14 @@ export function createAppleMusicCatalog({
     throw new TypeError("The Apple Music catalog client is invalid.");
   }
 
+  // The artists with exactly this name, whose own catalog has what the keyword search misses.
+  async function namedArtists(name) {
+    const wanted = normalizeForMatch(name);
+    return (await client.searchArtists(name))
+      .filter((candidate) => normalizeForMatch(candidate.name) === wanted)
+      .slice(0, APPLE_MUSIC_CATALOG_LIMITS.exactArtistCandidatesMax);
+  }
+
   return Object.freeze({
     async searchTracks({ queries, limit = 8 } = {}) {
       if (
@@ -621,10 +647,18 @@ export function createAppleMusicCatalog({
       const cleanedArtist = cleanInputText(artist, APPLE_MUSIC_CATALOG_LIMITS.discoveryQueryLengthMax, "apple_music_catalog_query_invalid", "artist");
       const wantedTitle = normalizeForMatch(cleanedTitle);
       const wantedArtist = normalizeForMatch(cleanedArtist);
-      const results = (await client.searchTracks(`${cleanedArtist} ${cleanedTitle}`))
-        .filter((track) => track.preview_url && normalizeForMatch(track.artist_credit).includes(wantedArtist));
-      const track = results.find((candidate) => normalizeForMatch(candidate.title) === wantedTitle) ??
-        results.find((candidate) => normalizeForMatch(candidate.title).startsWith(wantedTitle));
+      const pick = (tracks) => {
+        const results = tracks.filter((track) => track.preview_url && normalizeForMatch(track.artist_credit).includes(wantedArtist));
+        return results.find((candidate) => normalizeForMatch(candidate.title) === wantedTitle) ??
+          results.find((candidate) => normalizeForMatch(candidate.title).startsWith(wantedTitle));
+      };
+      let track = pick(await client.searchTracks(`${cleanedArtist} ${cleanedTitle}`));
+      if (!track && typeof client.artistSongs === "function") {
+        for (const named of await namedArtists(cleanedArtist)) {
+          track = pick(await client.artistSongs(named.catalog_id));
+          if (track) break;
+        }
+      }
       return {
         state: track ? "resolved" : "not_found",
         source: sourceMetadata(now, storefront),
@@ -641,10 +675,19 @@ export function createAppleMusicCatalog({
       const cleanedArtist = cleanInputText(artist, APPLE_MUSIC_CATALOG_LIMITS.discoveryQueryLengthMax, "apple_music_catalog_query_invalid", "artist");
       const wantedTitle = normalizeForMatch(cleanedTitle);
       const wantedArtist = normalizeForMatch(cleanedArtist);
-      const albums = (await client.searchAlbums(`${cleanedArtist} ${cleanedTitle}`))
-        .filter((candidate) => normalizeForMatch(candidate.artist_credit).includes(wantedArtist));
-      const album = albums.find((candidate) => normalizeForMatch(candidate.title) === wantedTitle) ??
+      const pick = (albums) => albums.find((candidate) => normalizeForMatch(candidate.title) === wantedTitle) ??
         albums.find((candidate) => normalizeForMatch(candidate.title).startsWith(wantedTitle));
+      let album = pick((await client.searchAlbums(`${cleanedArtist} ${cleanedTitle}`))
+        .filter((candidate) => normalizeForMatch(candidate.artist_credit).includes(wantedArtist)));
+      if (!album) {
+        for (const named of await namedArtists(cleanedArtist)) {
+          const release = pick(await client.artistReleases(named.catalog_id));
+          if (!release) continue;
+          album = { catalog_id: release.catalog_id, title: release.title, artist_credit: release.artist_name,
+            ...(release.catalog_url ? { catalog_url: release.catalog_url } : {}) };
+          break;
+        }
+      }
       const tracks = album ? (await client.albumTracks(album.catalog_id)).filter((track) => track.preview_url).slice(0, 30) : [];
       return {
         state: tracks.length ? "resolved" : "not_found",

package/src/integrations/netease/ncm-cli-player.mjs

@@ -227,23 +227,29 @@ export function createNeteasePlayer({
     /**
      * Finds and plays songs: each item is a search result's id, or a title and artist to look
      * up. mode "play" replaces the queue and starts the first; "queue" adds after what is
-     * playing. Songs NetEase marks as not playable are never sent to the player.
+     * playing. Songs NetEase marks as not playable are never sent to the player, nor songs
+     * allow(song) refuses, such as the listener's Avoids; those are only counted. Before a lookup,
+     * allow gets the title and artist asked for, as { title, artist_credit }.
      */
-    async play({ items = [], mode = "play", intent } = {}) {
+    async play({ items = [], mode = "play", intent, allow = () => true } = {}) {
       const found = [];
       const unplayable = [];
       const notFound = [];
+      let avoided = 0;
       for (const item of items.slice(0, 20)) {
         if (item?.id) {
           const song = known.get(String(item.id));
           if (!song) notFound.push({ id: String(item.id) });
           else if (!song.playable) unplayable.push(song);
+          else if (!allow(song)) avoided += 1;
           else found.push({ song, other_artist: false });
           continue;
         }
         const wanted = { title: String(item?.title ?? ""), artist: String(item?.artist ?? "") };
+        if (!allow({ title: wanted.title, artist_credit: wanted.artist })) { avoided += 1; continue; }
         const result = pick(await player.search({ query: `${wanted.title} ${wanted.artist}`.trim(), limit: 10, intent }), wanted);
-        if (result.song) found.push(result);
+        if (result.song && !allow(result.song)) avoided += 1;
+        else if (result.song) found.push(result);
         else if (result.unplayable) unplayable.push({ title: wanted.title, artists: [wanted.artist].filter(Boolean) });
         else notFound.push(wanted);
       }
@@ -266,6 +272,7 @@ export function createNeteasePlayer({
         songs: found.map(({ song, other_artist: otherArtist }) => ({ ...song, other_artist: otherArtist })),
         unplayable,
         not_found: notFound,
+        ...(avoided ? { skipped_avoided_count: avoided } : {}),
       };
     },