@audiofool/moondog 0.1.0 → 0.2.0-beta.2

package/src/i18n/messages/it.mjs

@@ -0,0 +1,128 @@
+// Italiano. Keys match messages/en.mjs; a missing key falls back to English.
+export default {
+  "discovery.reason.listenbrainz": ({ adjacent, seed, release }) => `I dati d'ascolto di ListenBrainz collegano ${adjacent} a ${seed}; da "${release}".`,
+  "discovery.reason.appleMusic": ({ queries, release, genre }) => `Catalogo Apple Music: ${queries ? `corrisponde a ${queries}` : "candidato"}; da "${release}"${genre ? `, genere nel catalogo: ${genre}` : ""}.`,
+  "discovery.reason.external": ({ release }) => `Dal catalogo esterno consultato, su "${release}".`,
+  "discovery.order": ({ path }) => `Ascolta in quest'ordine: ${path}.`,
+  "discovery.unavailable": "Non sono riuscito a raggiungere i servizi di scoperta musicale, quindi questa richiesta non ha prodotto consigli. Invia di nuovo la richiesta per riprovare.",
+
+  "citations.heading": "Fonti musicali pubbliche (separate dai tuoi dati d'ascolto personali):",
+  "citations.item": ({ label, url, storefront, date }) => `- [${label}](<${url}>) - store ${storefront}, consultato il ${date}.`,
+  "citations.scope": "Ambito: queste pagine di catalogo pubbliche non dimostrano preferenze personali, una cronologia d'ascolto completa né la disponibilità su altre piattaforme.",
+  "web.sources.heading": ({ providers }) => `Fonti web pubbliche (${providers})`,
+  "web.sources.headingUnnamed": "Fonti web pubbliche",
+  "web.sources.published": ({ date }) => `data della fonte: ${date}`,
+  "web.sources.retrieved": ({ date }) => `consultato: ${date}`,
+
+  "external.neighbors": ({ seed }) => seed ? `vicini d'ascolto ListenBrainz di ${seed}` : "vicini d'ascolto ListenBrainz",
+  "external.listenbrainz": ({ neighbor, date }) => `${neighbor} (identità Wikidata, CC0, consultata il ${date}; non è una somiglianza sonora)`,
+  "external.appleMusic": ({ date }) => `corrispondenze di titoli su Apple Music US (consultate il ${date})`,
+  "external.limit": "È escluso solo ciò che compare nella tua libreria importata con lo stesso titolo e artista, quindi non significa che tu non li abbia mai sentiti. Sono suggerimenti d'ascolto.",
+  "external.from": ({ parts, limit }) => `Da ${parts.join(" e ")}. ${limit}`,
+
+  "failure.deviceList": ({ noMatch, names, code }) => `Il nome del dispositivo ${noMatch ? "non corrisponde a nessun dispositivo" : "corrisponde a più dispositivi"}. Spotify al momento mostra: ${names}. Di' "riproducilo su" seguito dal nome mostrato; il brano scelto resta selezionato. Non è stata inviata alcuna richiesta di riproduzione. (${code})`,
+  "failure.networkRead": ({ notSent, code }) => `Un errore di rete ha impedito di leggere lo stato di dispositivi e riproduzione di Spotify; la preparazione si è fermata.${notSent ? " La richiesta di riproduzione non è stata inviata." : ""} Controlla la connessione a Spotify e riprova. (${code})`,
+  "failure.readiness.spotify_device_selection_required": "Il brano scelto resta selezionato, ma il dispositivo di destinazione non è stabilito. Indica il dispositivo che vuoi; quello precedente non verrà usato al suo posto.",
+  "failure.readiness.spotify_device_not_found": "Spotify non vede il dispositivo di destinazione. Apri Spotify su quel dispositivo, poi richiedi di nuovo la riproduzione; nessun altro dispositivo è stato usato al suo posto.",
+  "failure.readiness.spotify_device_ambiguous": "Potrebbero essere disponibili più dispositivi Spotify. Indica il nome del dispositivo che vuoi.",
+  "failure.readiness.spotify_device_restricted": "Il dispositivo di destinazione non conferma il controllo tramite la Web API di Spotify. Scegli un altro dispositivo disponibile.",
+  "failure.readiness.spotify_device_changed": "Un altro dispositivo Spotify è diventato attivo. Scegli esplicitamente il dispositivo che vuoi; la riproduzione non è stata spostata in automatico.",
+  "failure.readiness.spotify_device_state_unconfirmed": "Lo stato di dispositivi e riproduzione di Spotify è incompleto o incoerente. Controlla il dispositivo attuale in Spotify prima di riprovare.",
+  "failure.readiness.spotify_device_not_ready": "Il dispositivo di destinazione non è stato pronto entro l'attesa prevista. Apri Spotify su quel dispositivo, poi richiedi di nuovo lo stesso brano.",
+  "failure.readiness.spotify_playback_restricted": "Al momento Spotify non permette di riprendere la riproduzione. Controlla il dispositivo di destinazione.",
+  "failure.songNotSent": " La richiesta di riproduzione non è stata inviata.",
+  "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.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",
+  "failure.reason": ({ reason }) => `Spotify ha segnalato: ${reason}.`,
+  "failure.reasonUnknown": "La causa precisa non è confermata.",
+  "failure.lookup": ({ outcome, evidence, reason }) => `${outcome} (${evidence}). ${reason} Non è stata inviata alcuna riproduzione né aggiunta alla coda.`,
+  "failure.general": ({ targets, outcome, evidence, reason, playbackNotSent, recovered }) =>
+    `${targets ? `Destinazione: ${targets}.\n` : ""}${outcome} (${evidence}). ${reason}${playbackNotSent ? " La richiesta di riproduzione non è stata inviata." : ""} ${recovered ? "Un recupero limitato del dispositivo si è concluso; non ci sono stati altri tentativi." : "L'azione non è stata ritentata."} Leggi lo stato della riproduzione e i dispositivi disponibili per approfondire.`,
+
+  "queue.unverified": ({ one }) => `Spotify ${one ? "l'ha accettato" : "li ha accettati"}, ma non sono riuscito a leggere la tua coda per controllare.`,
+  "queue.confirmedPlaying": ({ one }) => one ? "Riproduzione confermata su Spotify." : "Confermato su Spotify: il primo è in riproduzione e gli altri sono nella tua coda.",
+  "queue.confirmed": ({ count }) => count === 1 ? "Confermato nella tua coda di Spotify." : `Confermati nella tua coda di Spotify: tutti e ${count}.`,
+  "queue.partlyVisible": ({ accepted, confirmed, truncated }) => `Spotify ne ha accettati ${accepted}; ${confirmed} sono visibili nella tua coda in questo momento${truncated ? " (Spotify mostra solo una parte delle code lunghe)" : ""}.`,
+  "queue.noPlayback": "Su Spotify non c'è un brano in corso da usare come punto di partenza; non è stato messo in coda nulla.",
+  "queue.noCandidates": "Dopo il filtro non è rimasto alcun candidato; non è stato messo in coda nulla.",
+  "queue.requested": ({ requested, accepted, shortfall }) => `Richiesti ${requested}; Spotify ne ha accettati ${accepted}${shortfall ? `, ne mancano ${shortfall}` : ""}.`,
+  "queue.similarSeed": ({ artist }) => `Artisti simili a ${artist}, secondo gli ascoltatori:`,
+  "queue.cancelled": "Ho smesso di aggiungere brani dopo l'annullamento; quelli accettati restano in coda.",
+  "queue.stopped": ({ count, title, artist }) => `Messi ${count} in coda su Spotify, poi mi sono fermato a "${title}" - ${artist}.`,
+  "queue.queued": ({ count }) => `Messi ${count} in coda su Spotify:`,
+  "queue.queuedSome": ({ count, unmatched }) => `Messi in coda su Spotify ${count} su ${count + unmatched}:`,
+  "queue.outcomeUnknown": "Spotify non ha confermato se il brano su cui mi sono fermato sia stato aggiunto. Controlla la coda prima di riprovare; questa scrittura non è stata ripetuta.",
+  "queue.started": ({ title, device, more }) => `Non suonava niente, quindi ho avviato "${title}"${device ? ` su ${device}` : ""}${more ? " e messo in fila il resto" : ""}.`,
+  "queue.unmatchedHeading": "Non trovati su Spotify:",
+  "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.`,
+  "queue.skippedKnown": ({ count }) => `Saltati ${count} brani già presenti nella tua cronologia, come richiesto.`,
+  "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.",
+
+  "playlist.partialUnknown": ({ name }) => `Spotify ha creato la playlist privata "${name}", ma l'aggiunta dei brani non è stata confermata. Controllala prima di decidere se riprovare.`,
+  "playlist.partialEmpty": ({ name }) => `Spotify ha creato la playlist privata "${name}", ma non ha aggiunto i brani. La playlist vuota ora esiste; controllala prima di decidere se riprovare.`,
+  "playlist.saved": ({ name, count }) => `Salvata come playlist privata di Spotify "${name}" (${count} brani).`,
+
+  "action.playback.resume": "richiesta di riproduzione",
+  "action.playback.pause": "richiesta di pausa",
+  "action.playback.next": "richiesta del brano successivo",
+  "action.playback.previous": "richiesta del brano precedente",
+  "action.playback.volume.set": "modifica del volume",
+  "action.playback.seek": "modifica della posizione di riproduzione",
+  "action.playback.shuffle.set": "impostazione della riproduzione casuale",
+  "action.playback.repeat.set": "impostazione della ripetizione",
+  "action.playback.transfer": "cambio di dispositivo",
+  "action.playback.queue.add": "aggiunta alla coda",
+  "action.library.remove": "rimozione dalla libreria",
+  "action.library.save": "salvataggio in libreria",
+  "action.playlist.write": "creazione della playlist",
+  "action.playlist.edit": "modifica della playlist",
+  "action.playlist.rename": "cambio di nome della playlist",
+  "action.playlist.unfollow": "rimozione della playlist dalla libreria",
+  "action.playlist.remove_track": "rimozione di un brano dalla playlist",
+  "action.other": "modifica richiesta",
+  "write.unknown": ({ action, target }) => `Spotify non ha confermato l'operazione "${action}"${target ? ` per "${target}"` : ""}. Controlla lo stato prima di decidere se riprovare.`,
+  "write.unfollowed": ({ name }) => `"${name}" è stata rimossa dalla tua libreria di Spotify (non la segui più). La playlist può ancora esistere per altri ascoltatori; non è stata eliminata per tutti.`,
+  "write.renamed": ({ name }) => `Spotify ha accettato di rinominare la playlist in "${name}".`,
+  "write.trackRemoved": ({ name }) => `Spotify ha accettato la rimozione di un brano da "${name}".`,
+  "write.accepted": ({ action, count, targets }) => `Spotify ha accettato l'operazione "${action}"${count === null ? "" : ` (${count} brani)`}${targets ? `: ${targets}` : ""}.`,
+
+  "plan.heading.private_library": ({ count }) => `Selezione di ${count} brani dalla tua libreria:`,
+  "plan.heading.private_history": ({ count }) => `${count} brani da riascoltare, dalla tua cronologia:`,
+  "plan.heading.external_catalog": ({ count }) => `${count} brani:`,
+  "plan.heading.mixed": ({ count }) => `${count} brani:`,
+  "plan.heading.timeCapsule": ({ count }) => `Macchina del tempo in ${count} tappe attraverso i tuoi anni d'ascolto:`,
+  "plan.heading.historicalReturn": ({ count }) => `${count} brani tornati dopo una lunga pausa:`,
+  "plan.heading.backToBack": ({ count }) => `${count} brani che hai ascoltato uno dopo l'altro:`,
+  "plan.externalTrack": ({ line, release }) => `${line}, da "${release}"`,
+  "plan.rationale": ({ text }) => `   Perché l'ho scelto: ${text}`,
+  "plan.ordering": ({ text }) => `Perché quest'ordine: ${text}`,
+  "plan.notSaved": "Non ho ancora salvato né messo in coda nulla.",
+  "plan.previewing": "Le anteprime di 30 secondi stanno suonando nel tuo player; i brani completi sono su Apple Music.",
+  "plan.pending": "Limite: questa selezione attende conferma solo nella sessione in corso, non è stata scritta su Spotify e non ha effetti esterni.",
+  "plan.backToBackBoundary": "Limite d'interpretazione: ascolti registrati uno dopo l'altro non dimostrano la modalità ripetizione, un riascolto voluto né che il brano ti piaccia.",
+  "plan.validationScope": "Ambito della verifica: il pianificatore locale verifica identità dei brani, appartenenza ai candidati, numero e ordine; i motivi della scelta e l'adattamento alla situazione restano giudizi del modello basati sui metadati disponibili.",
+  "plan.unvalidated": "Non sono riuscito a verificare questa selezione, quindi non restituirò un elenco di brani non confrontato con candidati affidabili. Restringi o allarga la ricerca e riprova.",
+
+  "edit.previewHeading": ({ name, before, after }) => `Anteprima della modifica alla playlist privata di Spotify "${name}" (${before} -> ${after} brani):`,
+  "edit.status.added": "aggiunto",
+  "edit.status.moved": "spostato",
+  "edit.status.retained": "resta",
+  "edit.removeHeading": "Da rimuovere:",
+  "edit.summary": ({ added, removed, moved, retained }) => `Riepilogo: ${added} aggiunti, ${removed} rimossi, ${moved} spostati, ${retained} rimasti al loro posto.`,
+  "edit.boundary": "Limite: Spotify non è ancora cambiato. Conferma esplicitamente nel prossimo messaggio perché Moondog scriva esattamente questa versione conservata.",
+  "edit.updated": ({ name, before, after }) => `Ho aggiornato la playlist privata di Spotify "${name}" esattamente secondo l'anteprima confermata${before === null ? ` (ora ${after} brani)` : ` (${before} -> ${after} brani)`}.`,
+
+  "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.",
+  "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

@@ -0,0 +1,128 @@
+// 日本語（です・ます調）。Keys match messages/en.mjs; a missing key falls back to English.
+export default {
+  "discovery.reason.listenbrainz": ({ adjacent, seed, release }) => `ListenBrainz の再生データで ${adjacent} と ${seed} がつながっています。『${release}』収録。`,
+  "discovery.reason.appleMusic": ({ queries, release, genre }) => `Apple Music カタログ${queries ? `で ${queries} に一致` : "の候補"}。『${release}』収録${genre ? `、カタログ上のジャンル: ${genre}` : ""}。`,
+  "discovery.reason.external": ({ release }) => `取得した外部カタログから。『${release}』収録。`,
+  "discovery.order": ({ path }) => `この順に聴いてみてください: ${path}。`,
+  "discovery.unavailable": "音楽を探すサービスに接続できなかったため、今回はおすすめを出せませんでした。もう一度送ってみてください。",
+
+  "citations.heading": "公開されている音楽情報（個人の再生記録とは別のものです）:",
+  "citations.item": ({ label, url, storefront, date }) => `- [${label}](<${url}>) - ${storefront} ストア、${date} に取得。`,
+  "citations.scope": "範囲: これらの公開カタログページは、個人の好み、完全な再生履歴、他サービスでの配信状況を示すものではありません。",
+  "web.sources.heading": ({ providers }) => `公開 Web の出典（${providers}）`,
+  "web.sources.headingUnnamed": "公開 Web の出典",
+  "web.sources.published": ({ date }) => `出典の日付：${date}`,
+  "web.sources.retrieved": ({ date }) => `取得：${date}`,
+
+  "external.neighbors": ({ seed }) => seed ? `ListenBrainz で ${seed} を聴く人たちに近いアーティスト` : "ListenBrainz で近いリスナーが聴くアーティスト",
+  "external.listenbrainz": ({ neighbor, date }) => `${neighbor}（Wikidata の識別情報、CC0、${date} に取得。音が似ているという意味ではありません）`,
+  "external.appleMusic": ({ date }) => `Apple Music US の曲名一致（${date} に取得）`,
+  "external.limit": "取り込んだライブラリと曲名・アーティストが完全に一致するものだけを除いています。まだ聴いたことがない曲という意味ではありません。聴いてみるための提案です。",
+  "external.from": ({ parts, limit }) => `出典: ${parts.join("、および")}。${limit}`,
+
+  "failure.deviceList": ({ noMatch, names, code }) => `デバイス名が${noMatch ? "一致しませんでした" : "複数のデバイスに一致しました"}。Spotify に現在表示されているのは: ${names}。表示された名前で「〜で再生して」と伝えてください。選んだ曲はそのまま保持されます。再生リクエストは送っていません。 (${code})`,
+  "failure.networkRead": ({ notSent, code }) => `ネットワークエラーで Spotify のデバイスや再生状態を読み取れず、準備を中止しました。${notSent ? "再生リクエストは送っていません。" : ""}Spotify との接続を確認してから、もう一度試してください。 (${code})`,
+  "failure.readiness.spotify_device_selection_required": "選んだ曲は保持していますが、再生するデバイスが決まっていません。使うデバイスの名前を教えてください。前のデバイスに勝手に切り替えることはありません。",
+  "failure.readiness.spotify_device_not_found": "指定したデバイスが Spotify に表示されていません。そのデバイスで Spotify を開いてから、もう一度再生を頼んでください。別のデバイスには切り替えていません。",
+  "failure.readiness.spotify_device_ambiguous": "使える Spotify デバイスが複数あるかもしれません。使いたいデバイスの名前を教えてください。",
+  "failure.readiness.spotify_device_restricted": "指定したデバイスは Spotify Web API での操作が確認できません。別のデバイスを選んでください。",
+  "failure.readiness.spotify_device_changed": "別の Spotify デバイスがアクティブになりました。使うデバイスをはっきり選んでください。再生は自動で移していません。",
+  "failure.readiness.spotify_device_state_unconfirmed": "Spotify のデバイスや再生状態の情報が不完全か、食い違っています。Spotify で今のデバイスを確認してから、もう一度試してください。",
+  "failure.readiness.spotify_device_not_ready": "待ち時間内にデバイスの準備ができませんでした。そのデバイスで Spotify を開いてから、同じ曲をもう一度頼んでください。",
+  "failure.readiness.spotify_playback_restricted": "Spotify が現在、再生の再開を許可していません。デバイスを確認してください。",
+  "failure.songNotSent": " 再生リクエストは送っていません。",
+  "failure.preparationStopped": ({ evidence }) => `再生前のデバイス確認が完了しませんでした（${evidence}）。再生リクエストは送っていません。Spotify のデバイスの状態を確認してから、もう一度試してください。`,
+  "failure.queueRequestRequired": "曲は追加していません。この返事をキューへの追加リクエストと結びつけられませんでした。続けるには、キューに追加したいとはっきり伝えてください。",
+  "failure.notSent": ({ code }) => `Spotify には何も送っていません。さっき見つけた曲と結び付けられませんでした（${code}）。曲名かアーティスト名を添えてもう一度頼んでください。改めて探します。`,
+  "failure.outcome.lookup": "Spotify での検索が完了しませんでした",
+  "failure.outcome.unknown": "Spotify での操作結果がわかりません",
+  "failure.outcome.unconfirmed": "Spotify が再生操作を確認しませんでした",
+  "failure.reason": ({ reason }) => `Spotify からの理由: ${reason}。`,
+  "failure.reasonUnknown": "具体的な原因は確認できていません。",
+  "failure.lookup": ({ outcome, evidence, reason }) => `${outcome}（${evidence}）。${reason}再生やキューへの追加は送っていません。`,
+  "failure.general": ({ targets, outcome, evidence, reason, playbackNotSent, recovered }) =>
+    `${targets ? `対象: ${targets}。\n` : ""}${outcome}（${evidence}）。${reason}${playbackNotSent ? "再生リクエストは送っていません。" : ""}${recovered ? "デバイスの復旧を一度だけ試して終了しました。これ以上は再試行しません。" : "自動では再試行していません。"}再生状態と使えるデバイスを確認すると、原因を詳しく調べられます。`,
+
+  "queue.unverified": () => "Spotify は受け付けましたが、キューを読み取って確認できませんでした。",
+  "queue.confirmedPlaying": ({ one }) => one ? "Spotify で再生中であることを確認しました。" : "Spotify で確認しました。1 曲目が再生中で、残りはキューに入っています。",
+  "queue.confirmed": ({ count }) => count === 1 ? "Spotify のキューに入っていることを確認しました。" : `Spotify のキューに ${count} 曲すべて入っていることを確認しました。`,
+  "queue.partlyVisible": ({ accepted, confirmed, truncated }) => `Spotify は ${accepted} 曲を受け付け、今キューに見えているのは ${confirmed} 曲です${truncated ? "（長いキューは Spotify が一部しか表示しません）" : ""}。`,
+  "queue.noPlayback": "Spotify で再生中の曲がなく、手がかりにできないため、何も追加していません。",
+  "queue.noCandidates": "絞り込んだ結果、追加できる候補が残らなかったため、何も追加していません。",
+  "queue.requested": ({ requested, accepted, shortfall }) => `${requested} 曲のリクエストに対し、Spotify が受け付けたのは ${accepted} 曲です${shortfall ? `（${shortfall} 曲不足）` : ""}。`,
+  "queue.similarSeed": ({ artist }) => `${artist} を聴く人たちに近いアーティストから:`,
+  "queue.cancelled": "キャンセルを受けて追加を止めました。受け付け済みの曲はキューに残っています。",
+  "queue.stopped": ({ count, title, artist }) => `Spotify のキューに ${count} 曲追加し、「${title}」 - ${artist} で止まりました。`,
+  "queue.queued": ({ count }) => `Spotify のキューに ${count} 曲追加しました:`,
+  "queue.queuedSome": ({ count, unmatched }) => `Spotify のキューに ${count + unmatched} 曲中 ${count} 曲追加しました:`,
+  "queue.outcomeUnknown": "止まった曲が追加されたかどうか、Spotify が確認しませんでした。もう一度試す前にキューを確認してください。再送はしていません。",
+  "queue.started": ({ title, device, more }) => `何も再生していなかったので、${device ? `${device} で` : ""}「${title}」を再生し${more ? "、残りをキューに入れ" : ""}ました。`,
+  "queue.unmatchedHeading": "Spotify で見つからなかった曲:",
+  "queue.skippedDuplicates": ({ count }) => `重複していた ${count} 曲を飛ばしました。`,
+  "queue.skippedUncertain": ({ count }) => `前回キューへの追加結果がはっきりしなかった ${count} 曲を、重複を避けるため飛ばしました。Spotify のキューを確認してください。`,
+  "queue.skippedAvoided": ({ count }) => `避けるよう指定された ${count} 曲を飛ばしました。`,
+  "queue.skippedKnown": ({ count }) => `ご希望どおり、再生履歴にある ${count} 曲を飛ばしました。`,
+  "queue.observationTruncated": "重複の確認は Spotify が表示するキューの範囲だけです。表示されていない部分と重なる可能性があります。",
+  "queue.notAddedHeading": "まだ追加していない曲:",
+  "queue.earlierReceipt": "これは前回のキュー操作の結果です。今回の補足では曲を再度追加していません。",
+
+  "playlist.partialUnknown": ({ name }) => `Spotify に非公開プレイリスト「${name}」を作成しましたが、曲の追加は確認できませんでした。再試行する前にプレイリストを確認してください。`,
+  "playlist.partialEmpty": ({ name }) => `Spotify に非公開プレイリスト「${name}」を作成しましたが、曲は追加されませんでした。空のプレイリストが残っています。再試行する前に確認してください。`,
+  "playlist.saved": ({ name, count }) => `Spotify の非公開プレイリスト「${name}」として保存しました（${count} 曲）。`,
+
+  "action.playback.resume": "再生リクエスト",
+  "action.playback.pause": "一時停止",
+  "action.playback.next": "次の曲へのスキップ",
+  "action.playback.previous": "前の曲への移動",
+  "action.playback.volume.set": "音量の変更",
+  "action.playback.seek": "再生位置の変更",
+  "action.playback.shuffle.set": "シャッフルの設定",
+  "action.playback.repeat.set": "リピートの設定",
+  "action.playback.transfer": "デバイスの切り替え",
+  "action.playback.queue.add": "キューへの追加",
+  "action.library.remove": "ライブラリからの削除",
+  "action.library.save": "ライブラリへの保存",
+  "action.playlist.write": "プレイリストの作成",
+  "action.playlist.edit": "プレイリストの変更",
+  "action.playlist.rename": "プレイリスト名の変更",
+  "action.playlist.unfollow": "ライブラリからのプレイリストの削除",
+  "action.playlist.remove_track": "プレイリストからの曲の削除",
+  "action.other": "依頼された変更",
+  "write.unknown": ({ action, target }) => `Spotify で${target ? `「${target}」の` : ""}${action}が確認できませんでした。再試行する前に状態を確認してください。`,
+  "write.unfollowed": ({ name }) => `「${name}」を Spotify のライブラリから外しました（フォロー解除）。プレイリスト自体はほかのリスナーには残っている場合があり、削除はしていません。`,
+  "write.renamed": ({ name }) => `Spotify でプレイリスト名を「${name}」に変更しました。`,
+  "write.trackRemoved": ({ name }) => `Spotify で「${name}」から 1 曲削除しました。`,
+  "write.accepted": ({ action, count, targets }) => `Spotify が${action}を受け付けました${count === null ? "" : `（${count} 曲）`}${targets ? `: ${targets}` : ""}。`,
+
+  "plan.heading.private_library": ({ count }) => `あなたのライブラリから選んだ ${count} 曲のプラン:`,
+  "plan.heading.private_history": ({ count }) => `再生履歴からもう一度聴きたい ${count} 曲のプラン:`,
+  "plan.heading.external_catalog": ({ count }) => `${count} 曲:`,
+  "plan.heading.mixed": ({ count }) => `${count} 曲:`,
+  "plan.heading.timeCapsule": ({ count }) => `あなたの聴いてきた年をたどる ${count} 曲のタイムマシン:`,
+  "plan.heading.historicalReturn": ({ count }) => `長い空白のあとに戻ってきた ${count} 曲:`,
+  "plan.heading.backToBack": ({ count }) => `続けて再生していた ${count} 曲:`,
+  "plan.externalTrack": ({ line, release }) => `${line}（『${release}』収録）`,
+  "plan.rationale": ({ text }) => `   選んだ理由: ${text}`,
+  "plan.ordering": ({ text }) => `曲順の理由: ${text}`,
+  "plan.notSaved": "まだ保存もキューへの追加もしていません。",
+  "plan.previewing": "30秒のプレビューをプレーヤーで再生中です。フル尺の曲は Apple Music で聴けます。",
+  "plan.pending": "範囲: このプランは今のセッション内で保留中です。Spotify には書き込んでおらず、外部への影響はありません。",
+  "plan.backToBackBoundary": "読み方の注意: 保存された再生が続いていても、リピート再生だった、意図して聴き直した、気に入っている、とは限りません。",
+  "plan.validationScope": "確認した範囲: ローカルのプランナーが曲の同一性、候補への所属、曲数、順番を確認しています。選んだ理由や場面への合い方は、手元のメタデータにもとづくモデルの判断です。",
+  "plan.unvalidated": "このプランを検証できなかったため、信頼できる候補で確認していない曲リストはお出ししません。検索を絞るか広げて、もう一度試してください。",
+
+  "edit.previewHeading": ({ name, before, after }) => `Spotify の非公開プレイリスト「${name}」の編集プレビュー（${before} -> ${after} 曲）:`,
+  "edit.status.added": "追加",
+  "edit.status.moved": "移動",
+  "edit.status.retained": "維持",
+  "edit.removeHeading": "削除する曲:",
+  "edit.summary": ({ added, removed, moved, retained }) => `変更の概要: 追加 ${added}、削除 ${removed}、移動 ${moved}、そのまま ${retained}。`,
+  "edit.boundary": "範囲: Spotify はまだ変わっていません。次のメッセージではっきり確認してもらえたら、Moondog がこのとおりの内容で書き込みます。",
+  "edit.updated": ({ name, before, after }) => `確認済みのプレビューどおりに Spotify の非公開プレイリスト「${name}」を更新しました${before === null ? `（現在 ${after} 曲）` : `（${before} -> ${after} 曲）`}。`,
+
+  "selection.note": ({ playlist, track }) => `\n\n続けて編集する対象: プレイリスト ${playlist}、曲 ${track}。`,
+  "memory.spotifyExcluded": "\n\nSpotify の検索結果は一般の記憶には残しません。確認できるあなたの発言だけが対象で、それ以外は保存していません。",
+  "memory.notSaved": "\n\n返事は完了しましたが、記憶は保存できませんでした。",
+  "turn.cancelled": "以降の処理をキャンセルしました。",
+  "turn.interrupted": "返事が中断されました。記録された Spotify の操作結果は下のとおりです。操作は繰り返していません。",
+};

package/src/i18n/messages/ko.mjs

@@ -0,0 +1,128 @@
+// 한국어. Keys match messages/en.mjs; a missing key falls back to English.
+export default {
+  "discovery.reason.listenbrainz": ({ adjacent, seed, release }) => `ListenBrainz 청취 데이터에서 ${adjacent}, ${seed} 두 아티스트가 이어집니다. 수록: "${release}".`,
+  "discovery.reason.appleMusic": ({ queries, release, genre }) => `Apple Music 카탈로그 ${queries ? `검색어 ${queries}와 일치` : "후보"}. 수록: "${release}"${genre ? `, 카탈로그 장르: ${genre}` : ""}.`,
+  "discovery.reason.external": ({ release }) => `가져온 외부 카탈로그에서 찾았습니다. 수록: "${release}".`,
+  "discovery.order": ({ path }) => `이 순서로 들어 보세요: ${path}.`,
+  "discovery.unavailable": "음악 탐색 서비스에 연결하지 못해 이번에는 추천을 만들지 못했습니다. 같은 요청을 다시 보내 주세요.",
+
+  "citations.heading": "공개 음악 출처(개인 청취 증거와는 별개):",
+  "citations.item": ({ label, url, storefront, date }) => `- [${label}](<${url}>) - ${storefront} 스토어, ${date}에 확인.`,
+  "citations.scope": "범위: 이 공개 카탈로그 페이지는 개인 취향, 전체 청취 기록, 다른 플랫폼에서의 이용 가능 여부를 증명하지 않습니다.",
+  "web.sources.heading": ({ providers }) => `공개 웹 출처(${providers})`,
+  "web.sources.headingUnnamed": "공개 웹 출처",
+  "web.sources.published": ({ date }) => `출처 날짜: ${date}`,
+  "web.sources.retrieved": ({ date }) => `확인: ${date}`,
+
+  "external.neighbors": ({ seed }) => seed ? `${seed}에서 이어지는 ListenBrainz 청취자 이웃` : "ListenBrainz 청취자 이웃",
+  "external.listenbrainz": ({ neighbor, date }) => `${neighbor} (Wikidata 식별 정보, CC0, ${date}에 확인. 오디오 유사도가 아닙니다)`,
+  "external.appleMusic": ({ date }) => `Apple Music 미국 스토어 제목 일치 (${date}에 확인)`,
+  "external.limit": "가져온 라이브러리에서 제목과 아티스트가 같은 곡만 제외했기 때문에, 한 번도 들어 본 적 없는 곡이라는 뜻은 아닙니다. 들어 볼 만한 제안입니다.",
+  "external.from": ({ parts, limit }) => `출처: ${parts.join(", 그리고 ")}. ${limit}`,
+
+  "failure.deviceList": ({ noMatch, names, code }) => `기기 이름이 ${noMatch ? "일치하지 않았습니다" : "여러 기기와 일치했습니다"}. 현재 Spotify에 보이는 기기: ${names}. 표시된 기기 이름으로 "이 기기에서 재생해"라고 말해 주세요. 고른 곡은 그대로 남아 있습니다. 곡 재생 요청은 보내지 않았습니다. (${code})`,
+  "failure.networkRead": ({ notSent, code }) => `네트워크 오류로 Spotify 기기와 재생 상태를 읽지 못해 준비를 멈췄습니다.${notSent ? " 곡 재생 요청은 보내지 않았습니다." : ""} Spotify 연결을 확인한 뒤 다시 시도해 주세요. (${code})`,
+  "failure.readiness.spotify_device_selection_required": "고른 곡은 남아 있지만 재생할 기기가 정해지지 않았습니다. 원하는 기기 이름을 말해 주세요. 이전 기기로 대신 재생하지 않습니다.",
+  "failure.readiness.spotify_device_not_found": "Spotify에서 대상 기기가 보이지 않습니다. 그 기기에서 Spotify를 연 다음 다시 재생을 요청해 주세요. 다른 기기로 대신 재생하지 않았습니다.",
+  "failure.readiness.spotify_device_ambiguous": "사용할 수 있는 Spotify 기기가 여러 대일 수 있습니다. 원하는 기기 이름을 알려 주세요.",
+  "failure.readiness.spotify_device_restricted": "대상 기기가 Spotify Web API 제어를 허용하는지 확인되지 않습니다. 사용할 수 있는 다른 기기를 골라 주세요.",
+  "failure.readiness.spotify_device_changed": "다른 Spotify 기기가 활성화되었습니다. 원하는 기기를 직접 골라 주세요. 재생을 자동으로 옮기지 않았습니다.",
+  "failure.readiness.spotify_device_state_unconfirmed": "Spotify 기기와 재생 상태가 불완전하거나 서로 맞지 않습니다. Spotify에서 현재 기기를 확인한 뒤 다시 시도해 주세요.",
+  "failure.readiness.spotify_device_not_ready": "대상 기기가 정해진 대기 시간 안에 준비되지 않았습니다. 그 기기에서 Spotify를 연 다음 같은 곡을 다시 요청해 주세요.",
+  "failure.readiness.spotify_playback_restricted": "지금은 Spotify가 재생 재개를 허용하지 않습니다. 대상 기기를 확인해 주세요.",
+  "failure.songNotSent": " 곡 재생 요청은 보내지 않았습니다.",
+  "failure.preparationStopped": ({ evidence }) => `재생 기기 확인을 마치지 못했습니다(${evidence}). 곡 재생 요청은 보내지 않았습니다. Spotify 기기 상태를 확인한 뒤 다시 시도해 주세요.`,
+  "failure.queueRequestRequired": "곡을 대기열에 넣지 않았습니다. 이 답변을 대기열 추가 요청과 연결하지 못했습니다. 계속하려면 재생 대기열에 음악을 넣어 달라고 분명히 요청해 주세요.",
+  "failure.notSent": ({ code }) => `Spotify에 아무것도 보내지 않았습니다. 방금 찾은 곡과 연결하지 못했습니다(${code}). 곡 제목이나 아티스트 이름을 넣어 다시 말해 주시면 다시 찾아볼게요.`,
+  "failure.outcome.lookup": "Spotify 검색을 마치지 못했습니다",
+  "failure.outcome.unknown": "Spotify 작업 결과가 확실하지 않습니다",
+  "failure.outcome.unconfirmed": "Spotify 재생 작업이 확인되지 않았습니다",
+  "failure.reason": ({ reason }) => `Spotify가 알려 준 이유: ${reason}.`,
+  "failure.reasonUnknown": "정확한 원인은 확인되지 않았습니다.",
+  "failure.lookup": ({ outcome, evidence, reason }) => `${outcome} (${evidence}). ${reason} 재생이나 대기열 작업은 보내지 않았습니다.`,
+  "failure.general": ({ targets, outcome, evidence, reason, playbackNotSent, recovered }) =>
+    `${targets ? `대상: ${targets}.\n` : ""}${outcome} (${evidence}). ${reason}${playbackNotSent ? " 곡 재생 요청은 보내지 않았습니다." : ""} ${recovered ? "제한된 기기 복구를 한 번 마쳤고, 더 이상 다시 시도하지 않았습니다." : "작업을 다시 시도하지 않았습니다."} 재생 상태와 사용 가능한 기기를 읽으면 더 자세히 살펴볼 수 있습니다.`,
+
+  "queue.unverified": () => "Spotify가 받아들였지만, 대기열을 읽어 다시 확인하지는 못했습니다.",
+  "queue.confirmedPlaying": ({ one }) => one ? "Spotify에서 재생 중인 것을 확인했습니다." : "Spotify에서 확인했습니다. 첫 곡이 재생 중이고 나머지는 대기열에 있습니다.",
+  "queue.confirmed": ({ count }) => count === 1 ? "Spotify 대기열에서 확인했습니다." : `Spotify 대기열에서 ${count}곡 모두 확인했습니다.`,
+  "queue.partlyVisible": ({ accepted, confirmed, truncated }) => `Spotify가 ${accepted}곡을 받아들였고, 지금 대기열에는 ${confirmed}곡이 보입니다${truncated ? "(Spotify는 긴 대기열의 일부만 보여 줍니다)" : ""}.`,
+  "queue.noPlayback": "Spotify에 기준으로 삼을 현재 곡이 없어 아무것도 대기열에 넣지 않았습니다.",
+  "queue.noCandidates": "걸러 낸 뒤 남은 후보가 없어 아무것도 대기열에 넣지 않았습니다.",
+  "queue.requested": ({ requested, accepted, shortfall }) => `${requested}곡을 요청했고 Spotify가 ${accepted}곡을 받아들였습니다${shortfall ? `. ${shortfall}곡이 모자랍니다` : ""}.`,
+  "queue.similarSeed": ({ artist }) => `청취자 데이터로 본 비슷한 아티스트 (기준: ${artist}):`,
+  "queue.cancelled": "취소 요청에 따라 대기열 추가를 멈췄습니다. 이미 받아들여진 곡은 대기열에 남아 있습니다.",
+  "queue.stopped": ({ count, title, artist }) => `Spotify 대기열에 ${count}곡을 넣은 뒤 "${title}" - ${artist}에서 멈췄습니다.`,
+  "queue.queued": ({ count }) => `Spotify 대기열에 ${count}곡을 넣었습니다:`,
+  "queue.queuedSome": ({ count, unmatched }) => `Spotify 대기열에 ${count + unmatched}곡 중 ${count}곡을 넣었습니다:`,
+  "queue.outcomeUnknown": "멈춘 곡이 추가되었는지 Spotify가 확인해 주지 않았습니다. 다시 시도하기 전에 대기열을 확인해 주세요. 이 작업은 다시 보내지 않았습니다.",
+  "queue.started": ({ title, device, more }) => `재생 중인 곡이 없어서 ${device ? `${device}에서 ` : ""}"${title}" 재생을 시작했습니다${more ? ". 나머지는 그 뒤에 이어집니다" : ""}.`,
+  "queue.unmatchedHeading": "Spotify에서 찾지 못한 곡:",
+  "queue.skippedDuplicates": ({ count }) => `중복된 곡 ${count}곡을 건너뛰었습니다.`,
+  "queue.skippedUncertain": ({ count }) => `이전 대기열 결과가 불확실한 곡 ${count}곡은 중복을 피하려고 건너뛰었습니다. Spotify 대기열을 확인해 주세요.`,
+  "queue.skippedAvoided": ({ count }) => `피해 달라고 한 곡 ${count}곡을 건너뛰었습니다.`,
+  "queue.skippedKnown": ({ count }) => `요청대로 청취 기록에 있는 곡 ${count}곡을 건너뛰었습니다.`,
+  "queue.observationTruncated": "Spotify가 돌려준 대기열의 일부만 확인했습니다. 보이지 않는 부분에 같은 곡이 있을 수 있습니다.",
+  "queue.notAddedHeading": "추가하지 않은 곡:",
+  "queue.earlierReceipt": "이것은 앞선 대기열 작업의 결과입니다. 이번 설명으로 곡을 다시 넣지는 않았습니다.",
+
+  "playlist.partialUnknown": ({ name }) => `Spotify에 비공개 플레이리스트 "${name}" 생성은 끝났지만, 곡 추가는 확인되지 않았습니다. 다시 시도할지 정하기 전에 확인해 주세요.`,
+  "playlist.partialEmpty": ({ name }) => `Spotify에 비공개 플레이리스트 "${name}" 생성은 끝났지만 곡은 추가하지 않았습니다. 빈 플레이리스트가 생겼으니 다시 시도할지 정하기 전에 확인해 주세요.`,
+  "playlist.saved": ({ name, count }) => `Spotify 비공개 플레이리스트 "${name}"(${count}곡)으로 저장했습니다.`,
+
+  "action.playback.resume": "재생 요청",
+  "action.playback.pause": "일시 정지 요청",
+  "action.playback.next": "다음 곡 요청",
+  "action.playback.previous": "이전 곡 요청",
+  "action.playback.volume.set": "볼륨 변경",
+  "action.playback.seek": "재생 위치 변경",
+  "action.playback.shuffle.set": "셔플 설정",
+  "action.playback.repeat.set": "반복 설정",
+  "action.playback.transfer": "기기 전환",
+  "action.playback.queue.add": "대기열 추가",
+  "action.library.remove": "보관함에서 삭제",
+  "action.library.save": "보관함에 저장",
+  "action.playlist.write": "플레이리스트 만들기",
+  "action.playlist.edit": "플레이리스트 변경",
+  "action.playlist.rename": "플레이리스트 이름 변경",
+  "action.playlist.unfollow": "보관함에서 플레이리스트 삭제",
+  "action.playlist.remove_track": "플레이리스트 곡 삭제",
+  "action.other": "요청한 변경",
+  "write.unknown": ({ action, target }) => `Spotify에서 다음 작업이 확인되지 않았습니다: ${action}${target ? ` ("${target}")` : ""}. 다시 시도할지 정하기 전에 상태를 확인해 주세요.`,
+  "write.unfollowed": ({ name }) => `Spotify 보관함에서 "${name}" 플레이리스트를 삭제했습니다(팔로우 취소). 다른 청취자에게는 플레이리스트가 남아 있을 수 있으며, 완전히 삭제된 것은 아닙니다.`,
+  "write.renamed": ({ name }) => `Spotify가 플레이리스트 이름 변경을 받아들였습니다. 새 이름: "${name}".`,
+  "write.trackRemoved": ({ name }) => `Spotify가 "${name}"에서 곡 하나를 삭제하는 것을 받아들였습니다.`,
+  "write.accepted": ({ action, count, targets }) => `Spotify가 다음 작업을 받아들였습니다: ${action}${count === null ? "" : ` (${count}곡)`}${targets ? ` - ${targets}` : ""}.`,
+
+  "plan.heading.private_library": ({ count }) => `내 라이브러리에서 고른 ${count}곡 구성:`,
+  "plan.heading.private_history": ({ count }) => `청취 기록에서 다시 들어 볼 ${count}곡:`,
+  "plan.heading.external_catalog": ({ count }) => `${count}곡:`,
+  "plan.heading.mixed": ({ count }) => `${count}곡:`,
+  "plan.heading.timeCapsule": ({ count }) => `여러 해의 청취를 지나는 ${count}곡 타임머신:`,
+  "plan.heading.historicalReturn": ({ count }) => `오랜만에 다시 돌아온 ${count}곡:`,
+  "plan.heading.backToBack": ({ count }) => `연달아 재생했던 ${count}곡:`,
+  "plan.externalTrack": ({ line, release }) => `${line}, 수록: "${release}"`,
+  "plan.rationale": ({ text }) => `   고른 이유: ${text}`,
+  "plan.ordering": ({ text }) => `순서를 정한 이유: ${text}`,
+  "plan.notSaved": "아직 저장하거나 대기열에 넣지 않았습니다.",
+  "plan.previewing": "30초 미리 듣기가 플레이어에서 재생 중입니다. 전체 곡은 Apple Music에서 들을 수 있습니다.",
+  "plan.pending": "안내: 이 구성은 지금 실행 중인 세션에서만 확인을 기다리며, Spotify에 기록되지 않았고 다른 외부 영향도 없습니다.",
+  "plan.backToBackBoundary": "해석 안내: 연달아 남은 재생 기록만으로는 반복 재생 설정, 의도적인 다시 듣기, 좋아함을 증명할 수 없습니다.",
+  "plan.validationScope": "검증 범위: 로컬 플래너가 곡 식별 정보, 후보 범위, 곡 수, 순서를 검증했습니다. 고른 이유와 상황에 맞는지는 가진 정보에 바탕을 둔 모델의 판단입니다.",
+  "plan.unvalidated": "이 플레이리스트 구성을 검증하지 못해, 신뢰할 수 있는 후보와 대조하지 않은 곡 목록은 보여 드리지 않습니다. 검색 범위를 좁히거나 넓혀서 다시 시도해 주세요.",
+
+  "edit.previewHeading": ({ name, before, after }) => `Spotify 비공개 플레이리스트 "${name}" 편집 미리 보기 (${before} -> ${after}곡):`,
+  "edit.status.added": "추가",
+  "edit.status.moved": "이동",
+  "edit.status.retained": "유지",
+  "edit.removeHeading": "삭제할 곡:",
+  "edit.summary": ({ added, removed, moved, retained }) => `변경 요약: 추가 ${added}, 삭제 ${removed}, 이동 ${moved}, 제자리 유지 ${retained}.`,
+  "edit.boundary": "안내: Spotify는 아직 바뀌지 않았습니다. 다음 메시지에서 분명히 확인해 주시면 Moondog가 이 보관된 버전을 그대로 기록합니다.",
+  "edit.updated": ({ name, before, after }) => `Spotify 비공개 플레이리스트 "${name}" 업데이트를 마쳤습니다. 확인한 미리 보기 그대로입니다${before === null ? ` (지금 ${after}곡)` : ` (${before} -> ${after}곡)`}.`,
+
+  "selection.note": ({ playlist, track }) => `\n\n다음 편집에 쓸 항목: 플레이리스트 ${playlist}, 곡 ${track}.`,
+  "memory.spotifyExcluded": "\n\nSpotify 결과는 일반 기억에 넣지 않습니다. 확인된 사용자 본인의 말만 기억할 수 있으며, 다른 내용은 저장하지 않았습니다.",
+  "memory.notSaved": "\n\n답변은 끝났지만 기억을 저장하지 못했습니다.",
+  "turn.cancelled": "남은 작업을 취소했습니다.",
+  "turn.interrupted": "답변이 중단되었습니다. 기록된 Spotify 결과는 아래와 같으며, 어떤 작업도 다시 실행하지 않았습니다.",
+};

package/src/i18n/messages/pt.mjs

@@ -0,0 +1,128 @@
+// Português do Brasil, com "você". Keys match messages/en.mjs; a missing key falls back to English.
+export default {
+  "discovery.reason.listenbrainz": ({ adjacent, seed, release }) => `Os dados de escuta do ListenBrainz ligam ${adjacent} a ${seed}; do álbum "${release}".`,
+  "discovery.reason.appleMusic": ({ queries, release, genre }) => `${queries ? `Resultado do catálogo do Apple Music para ${queries}` : "Candidata do catálogo do Apple Music"}; do álbum "${release}"${genre ? `, gênero no catálogo: ${genre}` : ""}.`,
+  "discovery.reason.external": ({ release }) => `Do catálogo externo consultado, em "${release}".`,
+  "discovery.order": ({ path }) => `Ouça nesta ordem: ${path}.`,
+  "discovery.unavailable": "Não consegui acessar os serviços de descoberta de música, então este pedido não trouxe recomendações. Envie o pedido de novo para tentar outra vez.",
+
+  "citations.heading": "Fontes musicais públicas (separadas do seu histórico de escuta pessoal):",
+  "citations.item": ({ label, url, storefront, date }) => `- [${label}](<${url}>) - loja ${storefront}, consultada em ${date}.`,
+  "citations.scope": "Alcance: estas páginas públicas de catálogo não comprovam seu gosto pessoal, seu histórico completo nem a disponibilidade em outras plataformas.",
+  "web.sources.heading": ({ providers }) => `Fontes públicas da web (${providers})`,
+  "web.sources.headingUnnamed": "Fontes públicas da web",
+  "web.sources.published": ({ date }) => `data da fonte: ${date}`,
+  "web.sources.retrieved": ({ date }) => `consultado em ${date}`,
+
+  "external.neighbors": ({ seed }) => seed ? `ouvintes próximos de ${seed} no ListenBrainz` : "ouvintes próximos no ListenBrainz",
+  "external.listenbrainz": ({ neighbor, date }) => `${neighbor} (identidade do Wikidata, CC0, consultado em ${date}; isto não é semelhança de som)`,
+  "external.appleMusic": ({ date }) => `títulos correspondentes no Apple Music US (consultado em ${date})`,
+  "external.limit": "Só fica de fora o que coincide em título e artista com a sua biblioteca importada, então isso não quer dizer que você nunca ouviu essas músicas. São sugestões para ouvir.",
+  "external.from": ({ parts, limit }) => `A partir de ${parts.join(" e ")}. ${limit}`,
+
+  "failure.deviceList": ({ noMatch, names, code }) => `O nome do dispositivo ${noMatch ? "não corresponde a nenhum" : "corresponde a vários dispositivos"}. O Spotify mostra agora: ${names}. Diga "toca no" seguido do nome que aparece; a música escolhida fica guardada. Nenhum pedido de reprodução foi enviado. (${code})`,
+  "failure.networkRead": ({ notSent, code }) => `Um erro de rede impediu a leitura do estado dos dispositivos ou da reprodução do Spotify; a preparação parou.${notSent ? " O pedido de reprodução não foi enviado." : ""} Confira a conexão com o Spotify e tente de novo. (${code})`,
+  "failure.readiness.spotify_device_selection_required": "A música escolhida fica guardada, mas o dispositivo ainda não foi definido. Diga qual quer usar; o anterior não será usado no lugar.",
+  "failure.readiness.spotify_device_not_found": "O Spotify não vê o dispositivo escolhido. Abra o Spotify nele e peça a música de novo; nenhum outro dispositivo foi usado no lugar.",
+  "failure.readiness.spotify_device_ambiguous": "Pode haver vários dispositivos do Spotify disponíveis. Diga o nome do que você quer usar.",
+  "failure.readiness.spotify_device_restricted": "O dispositivo escolhido não confirma que pode ser controlado pela Web API do Spotify. Escolha outro dispositivo disponível.",
+  "failure.readiness.spotify_device_changed": "Outro dispositivo do Spotify ficou ativo. Escolha o dispositivo que você quer; a reprodução não foi movida automaticamente.",
+  "failure.readiness.spotify_device_state_unconfirmed": "O estado dos dispositivos ou da reprodução do Spotify está incompleto ou inconsistente. Confira o dispositivo atual no Spotify antes de tentar de novo.",
+  "failure.readiness.spotify_device_not_ready": "O dispositivo não ficou pronto dentro do tempo de espera. Abra o Spotify nele e peça a mesma música de novo.",
+  "failure.readiness.spotify_playback_restricted": "No momento, o Spotify não permite retomar a reprodução. Confira o dispositivo.",
+  "failure.songNotSent": " O pedido de reprodução não foi enviado.",
+  "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.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",
+  "failure.reason": ({ reason }) => `O Spotify informou: ${reason}.`,
+  "failure.reasonUnknown": "A causa exata não foi confirmada.",
+  "failure.lookup": ({ outcome, evidence, reason }) => `${outcome} (${evidence}). ${reason} Nenhuma ação de reprodução ou de fila foi enviada.`,
+  "failure.general": ({ targets, outcome, evidence, reason, playbackNotSent, recovered }) =>
+    `${targets ? `Alvo: ${targets}.\n` : ""}${outcome} (${evidence}). ${reason}${playbackNotSent ? " O pedido de reprodução não foi enviado." : ""} ${recovered ? "Uma tentativa limitada de recuperar o dispositivo terminou; não houve nova tentativa." : "A ação não foi repetida."} Consulte o estado da reprodução e os dispositivos disponíveis para entender melhor.`,
+
+  "queue.unverified": ({ one }) => `O Spotify ${one ? "aceitou" : "aceitou todas"}, mas não consegui ler sua fila para conferir.`,
+  "queue.confirmedPlaying": ({ one }) => one ? "Confirmado: está tocando no Spotify." : "Confirmado no Spotify: a primeira está tocando e as outras estão na sua fila.",
+  "queue.confirmed": ({ count }) => count === 1 ? "Confirmado na sua fila do Spotify." : `Confirmadas na sua fila do Spotify: todas as ${count}.`,
+  "queue.partlyVisible": ({ accepted, confirmed, truncated }) => `O Spotify aceitou ${accepted}; agora aparecem ${confirmed} na sua fila${truncated ? " (o Spotify só mostra parte de uma fila longa)" : ""}.`,
+  "queue.noPlayback": "O Spotify não tem nenhuma música tocando para servir de ponto de partida; nada foi adicionado.",
+  "queue.noCandidates": "Depois do filtro, não sobrou nenhuma candidata; nada foi adicionado.",
+  "queue.requested": ({ requested, accepted, shortfall }) => `Você pediu ${requested}; o Spotify aceitou ${accepted}${shortfall ? `, faltaram ${shortfall}` : ""}.`,
+  "queue.similarSeed": ({ artist }) => `Artistas próximos de ${artist} segundo outros ouvintes:`,
+  "queue.cancelled": "Parei de adicionar depois do cancelamento; as que já foram aceitas continuam na fila.",
+  "queue.stopped": ({ count, title, artist }) => `Adicionei ${count} à fila do Spotify e parei em "${title}" - ${artist}.`,
+  "queue.queued": ({ count }) => `Adicionei ${count} à fila do Spotify:`,
+  "queue.queuedSome": ({ count, unmatched }) => `Adicionei ${count} de ${count + unmatched} à fila do Spotify:`,
+  "queue.outcomeUnknown": "O Spotify não confirmou se a música em que parei foi adicionada. Confira a fila antes de tentar de novo; não reenviei.",
+  "queue.started": ({ title, device, more }) => `Nada estava tocando, então coloquei "${title}"${device ? ` no ${device}` : ""}${more ? " e deixei as outras na fila" : ""}.`,
+  "queue.unmatchedHeading": "Não encontradas no Spotify:",
+  "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.`,
+  "queue.skippedKnown": ({ count }) => `Pulei ${count} músicas que já aparecem no seu histórico, como você pediu.`,
+  "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.",
+
+  "playlist.partialUnknown": ({ name }) => `O Spotify criou a playlist privada "${name}", mas não confirmou que as músicas foram adicionadas. Confira antes de decidir se tenta de novo.`,
+  "playlist.partialEmpty": ({ name }) => `O Spotify criou a playlist privada "${name}", mas não adicionou as músicas. A playlist vazia já existe; confira antes de decidir se tenta de novo.`,
+  "playlist.saved": ({ name, count }) => `Salva como a playlist privada do Spotify "${name}" (${count} músicas).`,
+
+  "action.playback.resume": "o pedido de reprodução",
+  "action.playback.pause": "a pausa",
+  "action.playback.next": "o pulo para a próxima",
+  "action.playback.previous": "a volta para a anterior",
+  "action.playback.volume.set": "a mudança de volume",
+  "action.playback.seek": "a mudança de posição",
+  "action.playback.shuffle.set": "o ajuste do modo aleatório",
+  "action.playback.repeat.set": "o ajuste de repetição",
+  "action.playback.transfer": "a troca de dispositivo",
+  "action.playback.queue.add": "a adição à fila",
+  "action.library.remove": "a remoção da sua biblioteca",
+  "action.library.save": "o salvamento na sua biblioteca",
+  "action.playlist.write": "a criação da playlist",
+  "action.playlist.edit": "a mudança na playlist",
+  "action.playlist.rename": "a mudança de nome da playlist",
+  "action.playlist.unfollow": "a remoção da playlist da sua biblioteca",
+  "action.playlist.remove_track": "a remoção de uma música da playlist",
+  "action.other": "a mudança pedida",
+  "write.unknown": ({ action, target }) => `O Spotify não confirmou ${action}${target ? ` para "${target}"` : ""}. Confira o estado antes de decidir se tenta de novo.`,
+  "write.unfollowed": ({ name }) => `Tirei "${name}" da sua biblioteca do Spotify (você deixou de seguir). A playlist pode continuar existindo para outros ouvintes; ela não foi apagada.`,
+  "write.renamed": ({ name }) => `O Spotify aceitou o novo nome da playlist: "${name}".`,
+  "write.trackRemoved": ({ name }) => `O Spotify aceitou tirar uma música de "${name}".`,
+  "write.accepted": ({ action, count, targets }) => `O Spotify aceitou ${action}${count === null ? "" : ` (${count} músicas)`}${targets ? `: ${targets}` : ""}.`,
+
+  "plan.heading.private_library": ({ count }) => `Plano de ${count} músicas da sua biblioteca:`,
+  "plan.heading.private_history": ({ count }) => `Plano de ${count} músicas do seu histórico para ouvir de novo:`,
+  "plan.heading.external_catalog": ({ count }) => `${count} músicas:`,
+  "plan.heading.mixed": ({ count }) => `${count} músicas:`,
+  "plan.heading.timeCapsule": ({ count }) => `Máquina do tempo de ${count} paradas pelos seus anos de escuta:`,
+  "plan.heading.historicalReturn": ({ count }) => `${count} músicas do seu histórico que voltaram depois de uma longa pausa:`,
+  "plan.heading.backToBack": ({ count }) => `${count} músicas do seu histórico que você ouviu em sequência:`,
+  "plan.externalTrack": ({ line, release }) => `${line}, do álbum "${release}"`,
+  "plan.rationale": ({ text }) => `   Por que está aqui: ${text}`,
+  "plan.ordering": ({ text }) => `Por que esta ordem: ${text}`,
+  "plan.notSaved": "Nada foi salvo nem adicionado à fila ainda.",
+  "plan.previewing": "As prévias de 30 segundos estão tocando no seu player; as músicas completas estão no Apple Music.",
+  "plan.pending": "Limite: este plano só está pendente nesta sessão, não foi gravado no Spotify e não tem efeitos externos.",
+  "plan.backToBackBoundary": "Como ler: duas reproduções guardadas em sequência não provam que você usou a repetição, que tocou de novo de propósito nem que gosta da música.",
+  "plan.validationScope": "O que foi conferido: o planejador local verifica a identidade de cada música, se ela está entre as candidatas, a quantidade e a ordem; os motivos e o encaixe com o momento continuam sendo julgamentos do modelo a partir dos metadados disponíveis.",
+  "plan.unvalidated": "Não consegui validar este plano, então não vou devolver uma lista que não foi conferida contra candidatas confiáveis. Refine ou amplie a busca e tente de novo.",
+
+  "edit.previewHeading": ({ name, before, after }) => `Prévia das mudanças na playlist privada do Spotify "${name}" (${before} -> ${after} músicas):`,
+  "edit.status.added": "adicionar",
+  "edit.status.moved": "mover",
+  "edit.status.retained": "manter",
+  "edit.removeHeading": "Remover:",
+  "edit.summary": ({ added, removed, moved, retained }) => `Resumo: ${added} adicionadas, ${removed} removidas, ${moved} movidas e ${retained} sem mudança.`,
+  "edit.boundary": "Limite: o Spotify não mudou. Confirme explicitamente na sua próxima mensagem para o Moondog gravar exatamente esta versão.",
+  "edit.updated": ({ name, before, after }) => `Atualizei a playlist privada do Spotify "${name}" com a prévia que você confirmou${before === null ? ` (agora tem ${after} músicas)` : ` (${before} -> ${after} músicas)`}.`,
+
+  "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.",
+  "turn.cancelled": "Cancelei o resto.",
+  "turn.interrupted": "A resposta foi interrompida. Abaixo estão os resultados registrados no Spotify; nenhuma ação foi repetida.",
+};