@audiofool/moondog 0.3.0-beta.1 → 0.3.0-beta.10

package/src/i18n/screen/zh.mjs

@@ -874,6 +874,7 @@ export default {
   "See what you're listening to": "查看你在听什么",
   "Control the Music app": "控制“音乐”App",
   "Choose a music service": "选择音乐服务",
+  "Read or change Moondog's settings": "读取或更改 Moondog 的设置",
   "Search outside your library": "在你的曲库之外搜索",
   "Find music nearby": "找附近的音乐",
   "Remember what you've told me": "记住你告诉我的",
@@ -1053,4 +1054,95 @@ export default {
   "Play a track Moondog made": "再放一首 Moondog 做的曲子",
   "Start a stream": "开始音乐流",
   "Stop the stream": "停止音乐流",
+  "Go on air: Moondog keeps making music from your taste": "开播：Moondog 照着你的口味一直做音乐",
+  "on air until {time}": "播出到 {time}",
+  "Cutting the next record": "正在刻下一张",
+  "Off air: the next record couldn't be made.": "停播了：下一张没刻成。",
+  "The next record is still being cut.": "下一张还在刻。",
+  "Off air.": "已停播。",
+  "Turn on music making first: /generation on.": "先开启音乐生成：/generation on。",
+  "Download a Stable Audio 3 model from Stability AI": "从 Stability AI 下载一个 Stable Audio 3 模型",
+  "Make music with a downloaded model": "用已下载的模型做音乐",
+  "Delete a downloaded model from this Mac": "从这台 Mac 删除一个已下载的模型",
+  "Stop the download": "停止下载",
+  "Medium: best sound, about 5.2 GB": "Medium：音质最好，约 5.2 GB",
+  "Small Music: faster, lighter, about 1.7 GB": "Small Music：更快更轻，约 1.7 GB",
+  "getting ready": "准备中",
+  "There isn't enough free space on this Mac for the download. Free some up, then use /generation download again.": "这台 Mac 的可用空间不够下载。腾出一些空间，再用一次 /generation download。",
+  "A downloaded file didn't match the one Stability AI publishes, so Moondog deleted it. Use /generation download to try again.": "有个下载的文件和 Stability AI 发布的不一致，Moondog 已把它删除。用 /generation download 重试。",
+  "The download couldn't reach its source. Check your connection, then use /generation download to try again.": "下载连不上来源。检查网络连接，再用 /generation download 重试。",
+  "Another Moondog window or terminal is already downloading. /generation shows how far it is.": "另一个 Moondog 窗口或终端已经在下载。/generation 可以看进度。",
+  "The download didn't finish: {error}. Use /generation download to try again.": "下载没有完成：{error}。用 /generation download 重试。",
+  "unknown error": "未知错误",
+  "Stable Audio 3 {model} is ready. Ask for a track.": "Stable Audio 3 {model} 已就绪。想听就让它做一首。",
+  "Stable Audio 3 {model} is downloaded. Use it with /generation use {choice}.": "Stable Audio 3 {model} 已下载。用 /generation use {choice} 来使用它。",
+  "Download stopped. /generation download {choice} picks it up where it left off.": "下载已停止。/generation download {choice} 会从停下的地方接着下。",
+  "download stopped on an error": "下载因错误停止",
+  "downloading": "下载中",
+  "downloading, {percent}%": "下载中，{percent}%",
+  "installed, in use": "已安装，使用中",
+  "installed": "已安装",
+  "partly downloaded": "已下载一部分",
+  "not downloaded": "未下载",
+  "{size} GB": "{size} GB",
+  "In use: your own install at {folder}.": "使用中：你自己在 {folder} 的安装。",
+  "Get a model with /generation download medium or small. /generation use, remove and cancel manage them.": "用 /generation download medium 或 small 获取模型。/generation use、remove 和 cancel 用来管理它们。",
+  "Making music on this Mac is off. Get Stable Audio 3 with /generation download medium, or small for a lighter model; music making turns on when it's done.": "在这台 Mac 上做音乐已关闭。用 /generation download medium 获取 Stable Audio 3，想要更轻的模型就用 small；下载完成后会开启音乐生成。",
+  "Stable Audio 3 {model} isn't downloaded yet. Get it with /generation download {choice}.": "Stable Audio 3 {model} 还没下载。用 /generation download {choice} 获取。",
+  "Making music on this Mac is off. Stable Audio 3 {model} is ready; turn it on with /generation on.": "在这台 Mac 上做音乐已关闭。Stable Audio 3 {model} 已准备好，用 /generation on 开启。",
+  "Use /generation download, use or remove with medium or small, or /generation cancel.": "用 /generation download、use 或 remove 加上 medium 或 small，或用 /generation cancel。",
+  "No download is running.": "没有正在进行的下载。",
+  "Stable Audio 3 {model} is already downloading.": "Stable Audio 3 {model} 已经在下载了。",
+  "Another download is running. /generation cancel stops it.": "另一个下载正在进行。/generation cancel 可以停止它。",
+  "Stable Audio 3 {model} is already on this Mac. Use it with /generation use {choice}.": "Stable Audio 3 {model} 已经在这台 Mac 上。用 /generation use {choice} 来使用它。",
+  "Already downloaded.": "已经下载过了。",
+  "Stable Audio 3 comes under the Stability AI Community License ({license}), and its text encoder, T5Gemma, under the Gemma Terms of Use ({gemma}). Moondog downloads it only from Stability AI's official sources and checks every file.\n\nTo agree and download {model} ({size} GB): /generation download {choice} --agree": "Stable Audio 3 适用 Stability AI Community License（{license}），它的文本编码器 T5Gemma 适用 Gemma Terms of Use（{gemma}）。Moondog 只从 Stability AI 的官方来源下载，并校验每个文件。\n\n同意并下载 {model}（{size} GB）：/generation download {choice} --agree",
+  "Waiting for your agreement.": "等你同意。",
+  "The download didn't finish.": "下载没有完成。",
+  "Downloading Stable Audio 3 {model} ({size} GB) from Stability AI's official sources. It runs in the background; /generation cancel stops it, and a later download picks up where it left off.": "正在从 Stability AI 的官方来源下载 Stable Audio 3 {model}（{size} GB）。它在后台进行；/generation cancel 可以停止，之后再下载会从停下的地方接着下。",
+  "Downloading Stable Audio 3 {model}.": "正在下载 Stable Audio 3 {model}。",
+  "Wait for the download to finish, or stop it with /generation cancel, before removing a model.": "删除模型前，先等下载完成，或用 /generation cancel 停止它。",
+  "A download is running.": "有下载正在进行。",
+  "Stable Audio 3 {model} isn't on this Mac.": "这台 Mac 上没有 Stable Audio 3 {model}。",
+  "Removing Stable Audio 3 {model} deletes its {size} GB from this Mac. It's the last model, so the rest of Moondog's Stable Audio 3 setup goes too. To go ahead: /generation remove {choice} --yes": "删除 Stable Audio 3 {model} 会从这台 Mac 删掉它的 {size} GB。这是最后一个模型，所以 Moondog 的 Stable Audio 3 其余部分也会一并删除。确定的话：/generation remove {choice} --yes",
+  "Removing Stable Audio 3 {model} deletes its {size} GB from this Mac. To go ahead: /generation remove {choice} --yes": "删除 Stable Audio 3 {model} 会从这台 Mac 删掉它的 {size} GB。确定的话：/generation remove {choice} --yes",
+  "Nothing removed yet.": "还没有删除任何东西。",
+  "Removed Stable Audio 3 {model} from this Mac.": "已从这台 Mac 删除 Stable Audio 3 {model}。",
+  "Removed.": "已删除。",
+  "Removed. Music making isn't ready.": "已删除。音乐生成还没准备好。",
+  "Use /generation, /generation on [folder] or off, or /generation download, use or remove with medium or small.": "用 /generation、/generation on [文件夹] 或 off，或用 /generation download、use 或 remove 加上 medium 或 small。",
+  "best sound": "音质最好",
+  "faster, lighter": "更快更轻",
+  "getting uv": "正在获取 uv",
+  "getting Stable Audio 3's code": "正在获取 Stable Audio 3 的代码",
+  "setting up Python": "正在准备 Python",
+  "downloading the model": "正在下载模型",
+  "checking the files": "正在校验文件",
+  "Stable Audio 3's Python environment couldn't be set up. Check your connection, then use /generation download to try again.": "没能准备好 Stable Audio 3 的 Python 环境。检查网络连接，再用 /generation download 重试。",
+  "The library isn't available here.": "这里用不了资料库。",
+  "Saved": "收藏",
+  "Play one with `/library play <name>`, or keep the song playing now with `/library save`.": "用 `/library play <名字>` 播放一个，或者用 `/library save` 收藏正在播放的歌。",
+  "No playlist is called “{name}”.": "没有叫“{name}”的播放列表。",
+  "{name} has nothing in it yet.": "{name} 里还是空的。",
+  "None of its songs could be found.": "里面的歌都没有找到。",
+  "Playing {name}.": "正在播放 {name}。",
+  "Moondog's tracks were left out. They play with Apple Music chosen.": "Moondog 做的曲子没有放。选择 Apple Music 时才会播放它们。",
+  "Some songs couldn't be found.": "有些歌没有找到。",
+  "Already in {name}.": "已经在“{name}”里了。",
+  "Saved.": "已收藏。",
+  "Saved to {name}.": "已收藏到“{name}”。",
+  "Your saved songs and playlists": "你收藏的歌和播放列表",
+  "Look in the library": "翻翻资料库",
+  "Save to the library": "收进资料库",
+  "Play from the library": "播放资料库里的歌",
+  "Paste a playlist link after /library import.": "在 /library import 后面粘贴歌单链接。",
+  "Reading the playlist…": "正在读取歌单…",
+  "{added} of {total} songs came in.": "{total} 首中导入了 {added} 首。",
+  "{count} songs came in.": { one: "导入了 {count} 首。", other: "导入了 {count} 首。" },
+  "It now shapes your taste.": "它现在会影响你的口味画像。",
+  "It couldn't shape your taste this time.": "这次没能把它加入你的口味画像。",
+  "It doesn't shape your taste; add taste after the link if it should.": "它不会影响你的口味；如果需要，在链接后加 taste。",
+  "Imported {name}.": "已导入“{name}”。",
+  "Use /library, /library play <name>, /library save [playlist], or /library import <link>.": "用 /library、/library play <名字>、/library save [播放列表] 或 /library import <链接>。",
+  "Import a playlist": "导入歌单",
 };

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

@@ -12,6 +12,8 @@ const READ_TIMEOUT_MS = 15_000;
 // A playlist longer than this is read as a window around the playing song.
 const PLAYLIST_WINDOW = 50;
 const PLAYLIST_BEFORE = 5;
+// Keeping the rest of a playlist reads up to as many songs as a library playlist holds.
+const REST_MAX = 2_000;
 const COLUMN_READ_MAX = 2_000;
 // Covers already drawn, by album, or by song for one without an album.
 const KNOWN_COVERS = 40;
@@ -47,13 +49,15 @@ function run(argv) {
     const playlist = music.currentPlaylist;
     answer.playlist = { id: playlist.persistentID(), name: playlist.name() };
     try { answer.playlist.special = playlist.specialKind(); } catch (error) {}
-    if (action === "tracks") {
+    if (action === "tracks" || action === "rest") {
       const tracks = playlist.tracks;
       const ids = tracks.persistentID();
       answer.playlist.count = ids.length;
       const at = answer.track ? ids.indexOf(answer.track.id) : -1;
-      const start = ids.length <= ${PLAYLIST_WINDOW} || at < 0 ? 0 : Math.max(0, Math.min(at - ${PLAYLIST_BEFORE}, ids.length - ${PLAYLIST_WINDOW}));
-      const end = Math.min(ids.length, start + ${PLAYLIST_WINDOW});
+      // "rest" reads from the playing song to the playlist's end, for keeping it in the library.
+      const start = action === "rest" ? Math.max(0, at)
+        : ids.length <= ${PLAYLIST_WINDOW} || at < 0 ? 0 : Math.max(0, Math.min(at - ${PLAYLIST_BEFORE}, ids.length - ${PLAYLIST_WINDOW}));
+      const end = Math.min(ids.length, start + (action === "rest" ? ${REST_MAX} : ${PLAYLIST_WINDOW}));
       answer.playlist.index = at;
       answer.playlist.start = start;
       answer.playlist.tracks = [];
@@ -197,6 +201,8 @@ export function createMusicAppPlayer({ platform = process.platform, run = osascr
   return {
     available,
     nowPlaying: ({ tracks = false } = {}) => read(tracks ? "tracks" : "read"),
+    // The playing song and the rest of its playlist, past the window nowPlaying reads, for keeping in the library.
+    remainingPlaylist: () => read("rest"),
     pause: () => read("pause"),
     resume: () => read("resume"),
     next: () => read("next"),

package/src/integrations/apple-music/terminal-preview-player.mjs

@@ -7,6 +7,8 @@ import { access, constants, rm, stat, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import path from "node:path";
 
+import { createPlayerNow } from "../../core/listening-now.mjs";
+
 // Players that play one file without a window and exit at its end, in order of preference.
 // None of them may read or write the terminal: the listening room owns it.
 const systemPlayers = {
@@ -17,6 +19,8 @@ const systemPlayers = {
   ],
 };
 const longestQueue = 30;
+// A library playlist plays as many entries as the application sends it, as the window does.
+const longestPlaylist = 50;
 const largestPreview = 10 * 1024 * 1024;
 // Some routes to Apple's audio host take over 20 seconds for one preview.
 const downloadTimeoutMs = 60_000;
@@ -69,8 +73,11 @@ export async function createTerminalPreviewPlayer({
   let queue = null;
   let child = null;
   let closed = false;
+  // What it plays, for the agent: the queue it holds, moved along by its own events.
+  const now = createPlayerNow();
 
   const emit = (event) => {
+    now.observe(event);
     for (const listener of listeners) {
       try { listener(event); } catch {}
     }
@@ -208,13 +215,29 @@ export async function createTerminalPreviewPlayer({
       });
       start(accepted);
     },
+    // A playlist from the listener's library: Apple Music previews and tracks Moondog made, in one queue.
+    // A song is { title, artist_credit, catalog_url, preview_url }; a made track { generated: true, id, title, file }.
+    playList(tracks) {
+      if (closed) return;
+      const accepted = (Array.isArray(tracks) ? tracks : []).map((track) => (track?.generated === true
+        ? { title: String(track.title ?? "").trim(), artist_credit: "", generated: true, id: String(track.id ?? ""),
+          file: typeof track.file === "string" && path.isAbsolute(track.file) ? track.file : null }
+        : { title: String(track?.title ?? "").trim(), artist_credit: String(track?.artist_credit ?? "").trim(),
+          catalog_url: https(track?.catalog_url, linkHost), preview: https(track?.preview_url, previewHost) }))
+        .filter((track) => track.title && (track.generated ? track.file : track.catalog_url && track.preview)).slice(0, longestPlaylist);
+      if (!accepted.length) return;
+      stop();
+      emit({ type: "queue", tracks: accepted.map(({ title, artist_credit, catalog_url, generated, id }) => (generated
+        ? { title, artist_credit: "", generated: true, id } : { title, artist_credit, catalog_url })), album: null });
+      start(accepted);
+    },
     // A track Moondog made on this Mac: { id, title, file }, played whole and kept after it ends.
     playGenerated({ id, title, file } = {}) {
       const name = String(title ?? "").trim();
       if (closed || !name || typeof file !== "string" || !path.isAbsolute(file)) return;
       stop();
       const track = { title: name, artist_credit: "", generated: true, id: String(id ?? "") };
-      emit({ type: "queue", tracks: [{ title: track.title, artist_credit: "", generated: true }], album: null });
+      emit({ type: "queue", tracks: [{ title: track.title, artist_credit: "", generated: true, id: track.id }], album: null });
       start([{ ...track, file }]);
     },
     // A made track queued behind the one playing, as Moondog's stream does; with nothing playing, it plays now.
@@ -223,6 +246,7 @@ export async function createTerminalPreviewPlayer({
       if (closed || !name || typeof file !== "string" || !path.isAbsolute(file)) return;
       if (!queue || !queue.tracks.every((track) => track.generated)) return this.playGenerated({ id, title, file });
       queue.tracks.push({ title: name, artist_credit: "", generated: true, id: String(id ?? ""), file });
+      now.appended({ title: name, generated: true, id: String(id ?? "") });
     },
     // Ends the song now playing, or still loading; the next one starts after it.
     skip() {
@@ -232,6 +256,12 @@ export async function createTerminalPreviewPlayer({
       return true;
     },
     stop,
+    // What plays now, as createPlayerNow reads it: null, or { state, song, position, count, next }.
+    nowPlaying: () => (closed ? null : now.read()),
+    // The song playing and every one after it, for keeping the whole queue in the library.
+    remaining: () => (closed ? [] : now.remaining()),
+    // Leaving Apple Music stops its previews here, never the tracks Moondog made.
+    holdsCatalogSongs: () => Boolean(queue?.tracks.some((track) => !track.generated)),
     subscribe(listener) {
       listeners.add(listener);
       return () => listeners.delete(listener);

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

@@ -245,9 +245,10 @@ export function createNeteasePlayer({
      * 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, 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 }.
+     * allow gets the title and artist asked for, as { title, artist_credit }. beforePlay runs just
+     * before a song starts, which a queue with nothing loaded does too.
      */
-    async play({ items = [], mode = "play", intent, allow = () => true } = {}) {
+    async play({ items = [], mode = "play", intent, allow = () => true, beforePlay } = {}) {
       const found = [];
       const unplayable = [];
       const notFound = [];
@@ -278,6 +279,7 @@ export function createNeteasePlayer({
           queue = [...queue, ...songs];
           outcome = "queued";
         } else {
+          await beforePlay?.();
           queue = songs;
           await playAt(0);
           outcome = "playing";
@@ -297,15 +299,19 @@ export function createNeteasePlayer({
       checked(await run(["resume"]), "resume");
       stayConnected();
     },
-    async next() {
+    // beforePlay runs just before a song starts, so the other players go quiet only for one.
+    async next({ beforePlay } = {}) {
       if (index + 1 >= queue.length) throw failure("netease_failed", "Nothing is queued after this song.");
+      await beforePlay?.();
       await playAt(index + 1);
     },
     // Back to the start of the song, or to the one before when it has only just begun.
-    async previous() {
+    async previous({ beforePlay } = {}) {
       const now = await state();
-      if (index > 0 && (Number(now.position) || 0) <= 3) await playAt(index - 1);
-      else checked(await run(["seek", "0"]), "go back to the start");
+      if (index > 0 && (Number(now.position) || 0) <= 3) {
+        await beforePlay?.();
+        await playAt(index - 1);
+      } else checked(await run(["seek", "0"]), "go back to the start");
     },
     async seek({ positionMs = 0 } = {}) {
       checked(await run(["seek", String(Math.max(0, Math.round(positionMs / 1000)))]), "move in the song");

package/src/integrations/playlist-links.mjs

@@ -0,0 +1,96 @@
+// Playlist links the listener pastes into the library: Spotify, Apple Music, NetEase Music and QQ Music.
+// Each link is read for its name and songs only; nothing signs in to a service it doesn't already have,
+// and nothing but the official hosts is ever fetched.
+import { fetchPublicPlaylist } from "./public-playlists.mjs";
+
+const fail = (code, message) => { throw Object.assign(new Error(message), { code }); };
+const PUBLIC_HOSTS = new Set(["y.qq.com", "c.y.qq.com", "i.y.qq.com", "m.y.qq.com", "music.163.com", "y.music.163.com", "163cn.tv"]);
+const APPLE_PAGE_MAX = 12 * 1024 * 1024;
+
+/** The one playlist link in some text: { provider, id, url } for Spotify and Apple Music, or { provider: "public", url } for NetEase and QQ. */
+export function parsePlaylistLink(text) {
+  const value = String(text ?? "").trim();
+  const uri = /^spotify:playlist:([A-Za-z0-9]{10,40})$/u.exec(value);
+  if (uri) return { provider: "spotify", id: uri[1], url: `https://open.spotify.com/playlist/${uri[1]}` };
+  const links = value.match(/https?:\/\/[^\s<>"“”]+/gu) ?? [];
+  if (links.length !== 1) fail("playlist_link_missing", "Paste one playlist link: Spotify, Apple Music, NetEase Music or QQ Music.");
+  let url;
+  try { url = new URL(links[0]); } catch { fail("playlist_link_missing", "That link can't be read."); }
+  if (url.username || url.password || url.port) fail("playlist_link_unsupported", "That link can't be read.");
+  if (url.hostname === "open.spotify.com") {
+    const match = /^\/(?:intl-[a-z-]+\/)?playlist\/([A-Za-z0-9]{10,40})\/?$/u.exec(url.pathname);
+    if (match) return { provider: "spotify", id: match[1], url: `https://open.spotify.com/playlist/${match[1]}` };
+  }
+  if (url.hostname === "music.apple.com" || url.hostname === "embed.music.apple.com") {
+    const match = /^\/([a-z]{2})\/playlist\/(?:[^/]+\/)?(pl\.[A-Za-z0-9.-]{6,80})\/?$/u.exec(url.pathname);
+    if (match) return { provider: "apple_music", id: match[2], storefront: match[1], url: `https://music.apple.com/${match[1]}/playlist/${match[2]}` };
+  }
+  if (PUBLIC_HOSTS.has(url.hostname)) return { provider: "public", url: url.href };
+  fail("playlist_link_unsupported", "Moondog reads playlist links from Spotify, Apple Music, NetEase Music and QQ Music.");
+}
+
+// The page's text, bounded, from Apple's own host only and never through a redirect elsewhere.
+async function applePage(url, fetchImpl, signal) {
+  let response;
+  try {
+    response = await fetchImpl(url, { redirect: "follow", signal: AbortSignal.any([AbortSignal.timeout(20_000), ...(signal ? [signal] : [])]),
+      headers: { "User-Agent": "Mozilla/5.0 (Macintosh; Moondog playlist import)", "Accept-Language": "en" } });
+  } catch (error) {
+    if (signal?.aborted) throw error;
+    fail("playlist_unreachable", "Couldn't reach Apple Music. Check your connection and try the link again.");
+  }
+  if (response.url && new URL(response.url).hostname !== "music.apple.com") fail("playlist_unavailable", "Apple Music answered from another address.");
+  if (!response.ok) { await response.body?.cancel(); fail("playlist_unavailable", "Apple Music didn't show this playlist. Check that it opens in a browser without signing in."); }
+  const chunks = [];
+  let size = 0;
+  for await (const chunk of response.body) {
+    size += chunk.length;
+    if (size > APPLE_PAGE_MAX) fail("playlist_too_large", "This playlist page is too large to read.");
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks).toString("utf8");
+}
+
+const text = (value, maximum = 200) => (typeof value === "string" ? Array.from(value.replace(/\s+/gu, " ").trim()).slice(0, maximum).join("") : "");
+
+/**
+ * An Apple Music playlist from its public page: its name, how many songs it has, and the songs the page
+ * lists with their Apple Music ids and covers. A long playlist's page may list only its first songs;
+ * read and total say how many.
+ */
+export async function readApplePlaylist({ id, url }, { fetchImpl = fetch, signal } = {}) {
+  const html = await applePage(url, fetchImpl, signal);
+  const block = (pattern) => { const match = pattern.exec(html); try { return match ? JSON.parse(match[1]) : null; } catch { return null; } };
+  const schema = block(/<script[^>]*id=schema:music-playlist[^>]*>([\s\S]*?)<\/script>/u) ?? block(/<script[^>]*application\/ld\+json[^>]*>([\s\S]*?)<\/script>/u);
+  const data = block(/<script[^>]*id="serialized-server-data"[^>]*>([\s\S]*?)<\/script>/u);
+  const tracks = [];
+  const seen = new Set();
+  // The server data lists each song as a track lockup with its title, its artist and its catalog id.
+  const walk = (node, depth) => {
+    if (!node || typeof node !== "object" || depth > 12 || tracks.length >= 2000) return;
+    if (Array.isArray(node)) { for (const each of node) walk(each, depth + 1); return; }
+    const catalog = node.contentDescriptor?.identifiers?.storeAdamID;
+    if (typeof node.title === "string" && typeof node.artistName === "string" && node.contentDescriptor?.kind === "song" && catalog) {
+      const key = String(catalog);
+      if (!seen.has(key)) {
+        seen.add(key);
+        const artwork = typeof node.artwork?.dictionary?.url === "string" ? node.artwork.dictionary.url.replace("{w}x{h}", "300x300").replace("{f}", "jpg") : null;
+        tracks.push({ id: key, title: text(node.title), artist: text(node.artistName), ...(artwork?.startsWith("https://") ? { artwork } : {}) });
+      }
+      return;
+    }
+    for (const value of Object.values(node)) walk(value, depth + 1);
+  };
+  walk(data, 0);
+  const name = text(schema?.name) || text(/<meta property="og:title" content="([^"]+)"/u.exec(html)?.[1]) || "Apple Music playlist";
+  const total = Number.isSafeInteger(Number(schema?.numTracks)) ? Number(schema.numTracks) : null;
+  if (!tracks.length) fail("playlist_unavailable", "Apple Music didn't list the songs of this playlist. Check that it is shared publicly.");
+  return { provider: "apple_music", id, url, name, total: total !== null && total >= tracks.length ? total : null, tracks: tracks.filter((track) => track.title && track.artist) };
+}
+
+/** A NetEase Music or QQ Music playlist through its public share link, as library songs. */
+export async function readPublicPlaylistLink({ url }, { fetchImpl = fetch } = {}) {
+  const playlist = await fetchPublicPlaylist({ input: url, fetchImpl });
+  return { provider: playlist.provider, id: playlist.id, url: playlist.url, name: playlist.name, total: playlist.total,
+    tracks: playlist.rows.map((row) => ({ id: row.id, title: row.title, artist: row.artist, ...(row.album ? { album: row.album } : {}) })).filter((track) => track.artist) };
+}

package/src/integrations/public-playlists.mjs

@@ -54,7 +54,8 @@ async function boundedJson(response) {
   catch { throw new Error("The service changed its playlist response or requires sign-in. No music was imported."); }
 }
 
-export async function readPublicPlaylist({ input, subjectId, capturedAt, provider, fetchImpl = fetch }) {
+/** A public QQ Music or NetEase playlist by its share link: { provider, id, url, name, total, rows, skipped }. */
+export async function fetchPublicPlaylist({ input, provider, fetchImpl = fetch }) {
   let url = playlistLink(input);
   let identity = playlistIdentity(url);
   // Follow only official share redirects, never arbitrary network destinations or cookies.
@@ -93,9 +94,14 @@ export async function readPublicPlaylist({ input, subjectId, capturedAt, provide
       playlistId: identity.id, playlistName: name, position: index + 1, member: "public-playlist.json",
     };
   }).filter((row) => row.id && row.title);
-  const bytes = Buffer.from(JSON.stringify({ provider: identity.provider, id: identity.id, name, rows }));
-  const prepared = prepareMusicBundle({ provider: identity.provider, subjectId, capturedAt, rows,
-    digest: musicHash(bytes), size: bytes.length, members: ["public-playlist.json"], fileName: name, skipped: songs.length - rows.length,
+  return { provider: identity.provider, id: identity.id, url: url.href, name, total, rows, skipped: songs.length - rows.length };
+}
+
+export async function readPublicPlaylist({ input, subjectId, capturedAt, provider, fetchImpl = fetch }) {
+  const { provider: source, id, name, total, rows, skipped } = await fetchPublicPlaylist({ input, provider, fetchImpl });
+  const bytes = Buffer.from(JSON.stringify({ provider: source, id, name, rows }));
+  const prepared = prepareMusicBundle({ provider: source, subjectId, capturedAt, rows,
+    digest: musicHash(bytes), size: bytes.length, members: ["public-playlist.json"], fileName: name, skipped,
     scopeNote: `${rows.length} of ${total ?? "an unknown number of"} songs could be read; the service hides some. Only this playlist is added. It shows what you keep, not what you played, and it may not be one you made.`,
   });
   prepared.preview.source = "public-playlist";

package/src/integrations/spotify/service.mjs

@@ -587,7 +587,8 @@ function refusedMove(error, target, player) {
   const refused = new SpotifyServiceError("spotify_device_refused",
     `Spotify would not move playback to ${clipText(target.name, 80)}, either as a transfer or as a song started there. ` +
     `${stayed ? `Playback stays on ${stayed}${player.is_playing === false ? ", paused" : ""}. ` : ""}` +
-    "The Spotify app on that device usually needs to be open and played once before it accepts remote control.");
+    "The Spotify app on that device usually needs to be open and played once before it accepts remote control. " +
+    "Both ways were already tried, so do not try another way in this turn; tell the listener.");
   refused.status = error?.status;
   refused.playbackStayedOn = stayed;
   return refused;
@@ -908,6 +909,26 @@ export function createSpotifyService(options = {}) {
         tracks: page ? page.items.map((entry) => entry.item).filter(Boolean) : null };
     },
 
+    // A whole playlist for the listener's library: its name, whether the signed-in listener owns it, and its
+    // songs page by page, up to 2,000. Spotify's own editorial playlists answer most apps with not found.
+    async readPlaylist({ playlistId } = {}, { signal } = {}) {
+      const id = requiredPlaylistId(String(playlistId ?? ""));
+      const playlist = await client.getPlaylist({ playlistId: id }, { signal });
+      if (!playlist) fail("spotify_playlist_unavailable", "Spotify did not describe this playlist.");
+      const tracks = [];
+      const pageSize = SPOTIFY_SERVICE_LIMITS.playlistItemsPageMax;
+      for (let offset = 0; offset < 2000; offset += pageSize) {
+        const page = await client.getPlaylistItems({ playlistId: id, limit: pageSize, offset }, { signal });
+        // A local file on the owner's computer has no catalog song to play or name; it stays out.
+        tracks.push(...page.items.filter((entry) => entry.is_local !== true).map((entry) => entry.item)
+          .filter((item) => item?.type === "track" && item.name && item.artists?.length && /^spotify:track:/u.test(item.uri ?? "")));
+        if (!page.has_more || !page.items.length) break;
+      }
+      const account = await client.getAccount({ signal }).catch((error) => (signal?.aborted ? Promise.reject(error) : null));
+      return { name: playlist.name, uri: playlist.uri, tracks_total: playlist.tracks_total ?? null,
+        owned: account?.account_id && playlist.owner_id ? account.account_id === playlist.owner_id : null, tracks };
+    },
+
     // One device decision for a whole queue request. An idle device cannot take a
     // queue entry, so the caller starts the first song there and queues the rest.
     async queueTarget(value, { signal } = {}) {