deep-roon-mcp 0.1.0 → 0.2.1

package/README.md

@@ -1,8 +1,8 @@
 # Deep Roon MCP
 
 The parts of Roon the official API doesn't reach, for Claude and any other MCP client: the reviews and biographies Roon
-shows, search across your library and Qobuz at once, Qobuz's editorial shelves, album pages with credits, artist
-discographies, and your own play history with real "most played" counts.
+shows, search across your library and Qobuz or TIDAL at once, their editorial shelves and TIDAL's playlists and mixes,
+album pages with credits, artist discographies, and your own play history with real "most played" counts.
 
 > **Read this first.** Deep Roon MCP is unofficial: it is not made, endorsed or supported by Roon Labs. It uses Roon's
 > internal protocol — the one Roon's own apps use — through Arthur Soares'
@@ -22,19 +22,19 @@ server of its own and sends nothing anywhere else. What you ask goes to your MCP
 
 ## Status
 
-Version 0.1: fifty tools.
+Version 0.2: fifty-one tools. Qobuz, TIDAL or both — whatever is signed in on your Core.
 
 **Reading** — changes nothing in Roon:
 
 | Tool | What it does |
 |---|---|
-| `roon_search` | Your library and Qobuz at once: albums (with format), artists, tracks |
-| `roon_new` | Qobuz's shelves: new, qobuzissimes, press awards, top, trending, ideal discography — by genre |
-| `roon_genres` | Qobuz's genres and their ids |
+| `roon_search` | Your library, Qobuz and TIDAL at once: albums (with format), artists, tracks — each says where it's from |
+| `roon_new` | Qobuz's shelves (new, qobuzissimes, press awards, top, trending, ideal discography) or TIDAL's (new, recommended, top, rising, masters; albums or tracks) — by genre |
+| `roon_genres` | Qobuz's genres and their ids, or TIDAL's genres and moods |
 | `roon_album` | An album's page: tracks, release dates, label, barcode, credits |
 | `roon_review` | The review Roon shows, in full, with its author |
 | `roon_bio` | The biography Roon shows, in full, with related artists |
-| `roon_artist` | An artist's discography, oldest first |
+| `roon_artist` | An artist's discography at Qobuz or TIDAL, oldest first |
 | `roon_status` | How Deep Roon MCP stands: Core, pairing, internal protocol, self-test, newer version |
 | `roon_zones` | Roon's zones and groups |
 | `roon_now_playing` | What plays in each zone, with the volume |
@@ -50,9 +50,10 @@ Version 0.1: fifty tools.
 | `roon_new_for_you` | New releases Roon picked for you |
 | `roon_mixes` | Today's Daily Mixes |
 | `roon_playlists`, `roon_playlist` | Your playlists, and one playlist's tracks |
-| `roon_favorites` | Albums with a heart in Roon, or your Qobuz favourites |
+| `roon_tidal_playlists` | TIDAL's playlists: its editorial shelves, by genre or mood, and your own TIDAL mixes |
+| `roon_favorites` | Albums with a heart in Roon, or your Qobuz or TIDAL favourites |
 | `roon_listen_later` | Your Listen Later list |
-| `roon_versions` | Other versions of an album: remasters, hi-res, in your library and at Qobuz |
+| `roon_versions` | Other versions of an album: remasters, hi-res, in your library and streaming |
 | `roon_similar` | More like this, for an album or an artist |
 | `roon_signal_path` | Roon's signal path for what plays: is it bit-perfect, what happens on the way |
 | `roon_dsp` | MUSE: the DSP set up for a zone |
@@ -72,7 +73,7 @@ Version 0.1: fifty tools.
 | `roon_group`, `roon_ungroup` | Group zones, and undo it |
 | `roon_sleep` | A sleep timer |
 | `roon_standby` | Put a device in standby, or wake it |
-| `roon_play_playlist` | A playlist on a zone, optionally shuffled |
+| `roon_play_playlist` | A playlist on a zone (also a TIDAL one), optionally shuffled |
 | `roon_play_mix` | One of today's Daily Mixes |
 
 **Changing your library or sound** — only on your request; each one reads the result back and says if Roon didn't follow:
@@ -81,7 +82,7 @@ Version 0.1: fifty tools.
 |---|---|
 | `roon_favorite` | A heart on an album or track, or off |
 | `roon_listen_later_set` | On or off the Listen Later list |
-| `roon_library_add` | A Qobuz album into your library |
+| `roon_library_add` | A Qobuz or TIDAL album into your library |
 | `roon_playlist_create` | A new playlist from tracks |
 | `roon_dsp_set` | MUSE on or off, one part on or off, or a preset |
 
@@ -103,7 +104,7 @@ The settings (Claude Desktop › Settings › Extensions › Deep Roon MCP):
 | Setting | What it does |
 |---|---|
 | Roon Core address | Empty: found on your network. Fill in the Core's address for another subnet or a private VPN (Tailscale) |
-| Essentials only | Seventeen tools instead of fifty, for small models |
+| Essentials only | Seventeen tools instead of fifty-one, for small models |
 | Use Roon's internal protocol | Off: only the official API — zones, playback, volume, grouping; no search, reviews, Focus or history |
 
 ### Other clients
@@ -116,6 +117,25 @@ Needs [Node.js](https://nodejs.org) 18 or newer. The package runs straight from
 claude mcp add deep-roon -- npx -y deep-roon-mcp
 ```
 
+**ChatGPT desktop app and Codex** — they share one configuration. In the ChatGPT desktop app: Settings › MCP servers ›
+Add server, name `deep-roon`, type STDIO, command `npx`, arguments `-y deep-roon-mcp`; save, then Restart. Or from a
+terminal:
+
+```sh
+codex mcp add deep-roon -- npx -y deep-roon-mcp
+```
+
+or by hand in `~/.codex/config.toml`:
+
+```toml
+[mcp_servers.deep-roon]
+command = "npx"
+args = ["-y", "deep-roon-mcp"]
+# env = { ROON_HOST = "", DEEP_ROON_TOOLS = "", DEEP_ROON_INTERNAL = "" }
+```
+
+ChatGPT on the web can't run a server on your computer — use the desktop app.
+
 **Cursor, VS Code, Windsurf, Cline, LM Studio, Claude Desktop by hand …** — in the client's MCP configuration:
 
 ```json
@@ -146,7 +166,8 @@ cd deep-roon-mcp && npm install && npm run build
 ## When something's wrong
 
 **"No Roon Core found" on a Mac:** macOS asks once whether the app may use the local network — for Claude Desktop that's
-Claude and Claude Helper. Allow both (System Settings › Privacy & Security › Local Network), then try again.
+Claude and Claude Helper, for the ChatGPT desktop app ChatGPT. Allow it (System Settings › Privacy & Security › Local
+Network), then try again.
 
 Ask your client to run **`roon_status`**: the Core it found, whether it's enabled in Roon, whether the internal protocol
 works, and a self-test of a few reads with the tools each stands for. After a Roon update a tool may break until Deep Roon
@@ -171,4 +192,4 @@ Arthur Soares for the protocol work (MIT, in `src/intern`). Roon Labs for allowi
 
 ## License
 
-Apache 2.0 — see `LICENSE` and `NOTICE`. Roon is a trademark of Roon Labs LLC; Qobuz of Xandrie SA.
+Apache 2.0 — see `LICENSE` and `NOTICE`. Roon is a trademark of Roon Labs LLC; Qobuz of Xandrie SA; TIDAL of TIDAL Music AS.

package/dist/deep-roon-mcp.js

@@ -8628,9 +8628,9 @@ function formatType(t) {
   if (EXPLICIT[t]) return EXPLICIT[t];
   return `${API_NS}${t}`;
 }
-function formatMethodSignature(service, method, params) {
+function formatMethodSignature(service2, method, params) {
   const args = params.map((p) => formatType(p.type)).join(", ");
-  return `${API_NS}${service}::${method}(${args})`;
+  return `${API_NS}${service2}::${method}(${args})`;
 }
 var API_NS, KEYWORD_PRIMITIVES, EXPLICIT, GENERIC_NS;
 var init_signature = __esm({
@@ -9250,9 +9250,9 @@ var init_client = __esm({
       }
       // --- generic call ---
       /** Call a method by service + name + params + pre-built args; returns the result. */
-      call(service, method, params, args, objectId) {
-        const sig = formatMethodSignature(service, method, params);
-        return this.remoting.callMethod(objectId ?? this.serviceOid(service), sig, args);
+      call(service2, method, params, args, objectId) {
+        const sig = formatMethodSignature(service2, method, params);
+        return this.remoting.callMethod(objectId ?? this.serviceOid(service2), sig, args);
       }
       /** Build a sparse value using the shared full schema and stable field indexes. */
       structArg(typeName, fields) {
@@ -9348,7 +9348,7 @@ var init_client = __esm({
           rootMembers.splice(3, 0, "Playlists", "Genres");
           for (const type of ["Playlist", "BrowserGenre", "GenreLite"]) leaves.add(type);
         }
-        const seen = /* @__PURE__ */ new Set();
+        const seen2 = /* @__PURE__ */ new Set();
         const out = [];
         let complete = true;
         const member2 = /* @__PURE__ */ __name((fields, name) => Object.entries(fields).find(([key]) => key.endsWith(`::${name}`))?.[1], "member");
@@ -9357,8 +9357,8 @@ var init_client = __esm({
           let type;
           let fields;
           if (isRef2(value)) {
-            if (seen.has(value.$ref)) return;
-            seen.add(value.$ref);
+            if (seen2.has(value.$ref)) return;
+            seen2.add(value.$ref);
             const object3 = this.graph.getObject(value.$ref);
             if (!object3) {
               complete = false;
@@ -15416,7 +15416,7 @@ var require_lib2 = __commonJS({
 var version2;
 var init_package = __esm({
   "package.json"() {
-    version2 = "0.1.0";
+    version2 = "0.2.1";
   }
 });
 
@@ -15731,41 +15731,12 @@ var init_session = __esm({
 });
 
 // src/roon/graph.ts
-var graph_exports = {};
-__export(graph_exports, {
-  albumRow: () => albumRow,
-  clean: () => clean,
-  dateText: () => dateText,
-  dotnetDate: () => dotnetDate,
-  duration: () => duration3,
-  field: () => field2,
-  flag: () => flag,
-  imageKey: () => imageKey,
-  items: () => items,
-  localTime: () => localTime,
-  obj: () => obj,
-  partialList: () => partialList,
-  refList: () => refList,
-  resultRow: () => resultRow,
-  short: () => short,
-  strings: () => strings,
-  typeOf: () => typeOf,
-  untilField: () => untilField,
-  untilLoaded: () => untilLoaded,
-  wait: () => wait,
-  yearOf: () => yearOf
-});
 function field2(o, name) {
   if (!o) return void 0;
   const f = o.fields || o;
   for (const [k, v] of Object.entries(f)) if (k.endsWith("::" + name)) return v;
   return void 0;
 }
-function imageKey(c, o, name = "Image") {
-  const url2 = field2(obj(c, field2(o, name)), "Url");
-  const m = /^broker:\/\/\/image\/([^.]+)\./.exec(String(url2 ?? ""));
-  return m ? m[1] : void 0;
-}
 function dateParts(v) {
   if (!Buffer.isBuffer(v) || v.length < 2) return void 0;
   const n = new BinaryReader(Uint8Array.from(v)).flexInt();
@@ -15842,12 +15813,20 @@ function localTime(iso) {
   const t = /* @__PURE__ */ __name((x) => String(x).padStart(2, "0"), "t");
   return `${d.getFullYear()}-${t(d.getMonth() + 1)}-${t(d.getDate())} ${t(d.getHours())}:${t(d.getMinutes())}`;
 }
+function sourceOf(...os2) {
+  for (const o of os2) {
+    const v = field2(o, "ContentSource") ?? field2(o, "Source");
+    if (v === 128) return "TIDAL";
+    if (v === 256) return "Qobuz";
+    if (v === 1) return "library";
+  }
+  return void 0;
+}
 function albumRow(c, o) {
   const fm = obj(c, field2(o, "AlbumFormat"));
-  const r = { kind: "album", key: String(field2(o, "AlbumId") ?? ""), title: field2(o, "Title") ?? "", artist: clean(field2(o, "PerformedBy")), source: "library" };
+  const r = { kind: "album", key: String(field2(o, "AlbumId") ?? ""), title: field2(o, "Title") ?? "", artist: clean(field2(o, "PerformedBy")), source: sourceOf(o) ?? (field2(fm, "IsStreaming") === true ? "streaming" : "library") };
   const f = field2(fm, "FormatString");
   if (f) r.format = f;
-  if (field2(fm, "IsStreaming") === true) r.source = "Qobuz";
   const y = yearOf(field2(o, "OriginalReleaseDate")) ?? yearOf(field2(o, "ReleaseDate"));
   if (y) r.year = y;
   const st = field2(o, "Rating");
@@ -15881,7 +15860,7 @@ function resultRow(c, o) {
     if (f) r.format = f;
     const l = field2(o, "LengthSeconds");
     if (typeof l === "number") r.length = duration3(l);
-    r.source = field2(o, "Source") === 256 ? "Qobuz" : "library";
+    r.source = sourceOf(o, al) ?? "library";
     return r;
   }
   return { kind: t, title: field2(o, "Title") ?? field2(o, "Name") ?? "" };
@@ -15902,7 +15881,6 @@ var init_graph = __esm({
       return (o?.fields?.$items ?? o?.$items ?? []).filter((x) => typeof x === "string");
     }, "strings");
     flag = /* @__PURE__ */ __name((v) => v === true || Buffer.isBuffer(v) && v.length > 1 && v[0] >= 1, "flag");
-    __name(imageKey, "imageKey");
     __name(dateParts, "dateParts");
     yearOf = /* @__PURE__ */ __name((v) => dateParts(v)?.[0], "yearOf");
     __name(dateText, "dateText");
@@ -15915,12 +15893,44 @@ var init_graph = __esm({
     __name(short, "short");
     __name(duration3, "duration");
     __name(localTime, "localTime");
+    __name(sourceOf, "sourceOf");
     __name(albumRow, "albumRow");
     __name(resultRow, "resultRow");
   }
 });
 
 // src/roon/library.ts
+function signedIn(c, s) {
+  const o = c.graph.findByType(SERVICE_TYPE[s])[0];
+  if (!o) return null;
+  const st = field2(o, "LoginStatus");
+  return st === void 0 || st === 4 ? o : null;
+}
+function streaming(c, wanted) {
+  if (wanted) {
+    const o = signedIn(c, wanted);
+    if (!o) throw new RoonError(`${SERVICE_NAME[wanted]} isn't signed in on this Roon Core`, "unavailable");
+    return { service: wanted, o };
+  }
+  for (const s of ["qobuz", "tidal"]) {
+    const o = signedIn(c, s);
+    if (o) return { service: s, o };
+  }
+  throw new RoonError("Neither Qobuz nor TIDAL is signed in on this Roon Core", "unavailable");
+}
+async function shelf(c, s, o, method, of, offset2, count, before = NONE2, after = NONE2) {
+  const res = await c.call(
+    SERVICE_TYPE[s],
+    method,
+    [...before.types, { type: "int", name: "offset" }, { type: "int", name: "count" }, ...after.types, { type: `ResultCallback<PartialList<${of}>>`, name: "cb_result" }],
+    Buffer.concat([before.args, buildArgs([Arg.int(Math.max(0, offset2)), Arg.int(Math.min(Math.max(1, count), 100))]), after.args]),
+    o.oid
+  );
+  if (!res.success) throw new RoonError(`${SERVICE_NAME[s]}::${method}: ${res.status}`);
+  const list = partialList(c, c.graph.decodeReturnValue(Uint8Array.from(res.payload)));
+  await untilLoaded(c, list.items);
+  return { total: list.total, items: list.items.map((x) => obj(c, x)).filter(Boolean) };
+}
 async function search(query, limit3, kind) {
   return withCore(async (c) => {
     const n = Math.min(Math.max(1, limit3), 100);
@@ -15930,39 +15940,107 @@ async function search(query, limit3, kind) {
     return { query, rows };
   });
 }
-async function section(name, limit3, offset2, genres2 = []) {
-  const method = SECTIONS[name];
-  if (!method) throw new RoonError(`Unknown section; choose from ${Object.keys(SECTIONS).join(", ")}`, "invalid");
+async function section(name, limit3, offset2, genres2 = [], wanted, what = "albums") {
   return withCore(async (c) => {
-    const q = qobuz(c);
-    const res = await c.call(
-      "Qobuz",
-      method,
-      [{ type: "int", name: "offset" }, { type: "int", name: "count" }, { type: "IList<string>", name: "filter_genre_ids" }, { type: "ResultCallback<PartialList<AlbumLite>>", name: "cb_result" }],
-      buildArgs([Arg.int(Math.max(0, offset2)), Arg.int(Math.min(Math.max(1, limit3), 100)), Arg.collection(genres2.map((g) => buildArgs([Arg.str(g)])))]),
-      q.oid
-    );
-    if (!res.success) throw new RoonError(`Qobuz::${method}: ${res.status}`);
-    const list = partialList(c, c.graph.decodeReturnValue(Uint8Array.from(res.payload)));
-    await untilLoaded(c, list.items);
+    const { service: service2, o } = streaming(c, wanted);
+    const methods = SECTIONS[service2];
+    if (!methods[name] && !(service2 === "tidal" && genres2.length)) throw new RoonError(`${SERVICE_NAME[service2]} has no shelf "${name}"; choose from ${Object.keys(methods).join(", ")}`, "invalid");
+    if (what === "tracks" && service2 !== "tidal") throw new RoonError("Shelves of tracks are TIDAL's; Qobuz's shelves are albums", "invalid");
+    if (what === "tracks" && name === "masters") throw new RoonError("TIDAL's masters shelf is albums only", "invalid");
+    let res;
+    if (service2 === "qobuz") {
+      if (genres2.some((g) => !/^\d+$/.test(g))) throw new RoonError("Qobuz genres are ids (numbers) \u2014 see roon_genres", "invalid");
+      res = await shelf(
+        c,
+        service2,
+        o,
+        methods[name],
+        "AlbumLite",
+        offset2,
+        limit3,
+        NONE2,
+        { types: [{ type: "IList<string>", name: "filter_genre_ids" }], args: buildArgs([Arg.collection(genres2.map((g) => buildArgs([Arg.str(g)])))]) }
+      );
+    } else if (genres2.length) {
+      const g = await tidalPick(c, o, "GetGenres", genres2[0]);
+      res = await shelf(
+        c,
+        service2,
+        o,
+        what === "tracks" ? "GetGenreTracks" : "GetGenreAlbums",
+        what === "tracks" ? "TrackLite" : "AlbumLite",
+        offset2,
+        limit3,
+        { types: [{ type: "TidalGenre", name: "genre" }], args: tidalStruct(c, "TidalGenre", g) }
+      );
+    } else {
+      res = await shelf(c, service2, o, methods[name] + (what === "tracks" ? "Tracks" : "Albums"), what === "tracks" ? "TrackLite" : "AlbumLite", offset2, limit3);
+    }
     return {
-      section: name,
+      service: SERVICE_NAME[service2],
+      section: genres2.length && service2 === "tidal" ? void 0 : name,
       genre: genres2.length ? genres2 : void 0,
-      total: list.total,
+      what: service2 === "tidal" ? what : void 0,
+      total: res.total,
       offset: offset2,
-      rows: list.items.map((x) => obj(c, x)).filter(Boolean).map((o) => albumRow(c, o))
+      rows: res.items.map((x) => resultRow(c, x))
     };
   });
 }
-async function genres(parent) {
+async function tidalList(c, o, method) {
+  const res = await c.call("Tidal", method, [{ type: `ResultCallback<IList<${method === "GetGenres" ? "TidalGenre" : "TidalMood"}>>`, name: "cb_result" }], Buffer.alloc(0), o.oid);
+  if (!res.success) throw new RoonError(`TIDAL::${method}: ${res.status}`);
+  const rows = [];
+  if (res.payload.length > 2) {
+    const r = new BinaryReader(Uint8Array.from(res.payload));
+    r.integer();
+    const n = r.flexInt();
+    for (let i = 0; i < n && r.remaining > 0; i++) {
+      r.flexInt();
+      r.flexInt();
+      const len = r.flexInt();
+      const m = new BinaryReader(r.bytes(len));
+      const g = {};
+      while (m.remaining > 0) {
+        const idx = m.flexInt();
+        if (idx !== 1 && idx !== 2) break;
+        const t = m.string();
+        if (idx === 1) g.name = t;
+        else g.path = t;
+      }
+      if (g.path) rows.push({ name: g.name ?? g.path, path: g.path });
+    }
+  }
+  return rows;
+}
+async function tidalPick(c, o, method, want) {
+  const all = await tidalList(c, o, method);
+  const w = want.trim().toLowerCase();
+  const g = all.find((x) => x.path.toLowerCase() === w) ?? all.find((x) => x.name.toLowerCase() === w);
+  if (!g) throw new RoonError(`TIDAL has no ${method === "GetGenres" ? "genre" : "mood"} "${want}"; choose from ${all.map((x) => x.path).join(", ")}`, "invalid");
+  return g;
+}
+function tidalStruct(c, type, g) {
+  const T = `Sooloos.Broker.Api.${type}`;
+  return c.structArg(T, [
+    { name: `string ${T}::Name`, propType: 20, value: new BinaryWriter().string(g.name).toBuffer() },
+    { name: `string ${T}::Path`, propType: 20, value: new BinaryWriter().string(g.path).toBuffer() }
+  ]);
+}
+async function genres(parent, wanted) {
   return withCore(async (c) => {
-    const q = qobuz(c);
+    const { service: service2, o } = streaming(c, wanted);
+    if (service2 === "tidal") {
+      if (parent) throw new RoonError("TIDAL's genres have no sub-genres", "invalid");
+      const [g, m] = [await tidalList(c, o, "GetGenres"), await tidalList(c, o, "GetMoods")];
+      return { service: "TIDAL", genres: g.map((x) => ({ id: x.path, name: x.name })), moods: m.map((x) => ({ id: x.path, name: x.name })) };
+    }
     const res = await c.call(
       "Qobuz",
       "GetGenres",
       [{ type: "string", name: "parentGenreId" }, { type: "ResultCallback<IList<QobuzGenre>>", name: "cb_result" }],
       buildArgs([Arg.str(parent || null)]),
-      q.oid
+      o.oid
     );
     if (!res.success) throw new RoonError(`Qobuz::GetGenres: ${res.status}`);
     const rows = [];
@@ -15986,7 +16064,7 @@ async function genres(parent) {
         if (g.id) rows.push({ id: g.id, name: g.name });
       }
     }
-    return { parent: parent || void 0, genres: rows };
+    return { service: "Qobuz", parent: parent || void 0, genres: rows };
   });
 }
 async function findAlbum(c, key) {
@@ -16177,16 +16255,16 @@ async function bio(key, max, wiki) {
     };
   });
 }
-async function discography(key) {
+async function discography(key, wanted) {
   return withCore(async (c) => {
-    const q = qobuz(c);
+    const { service: service2, o: q } = streaming(c, wanted);
     const pv = await performer(c, key);
     const end = Date.now() + 1500;
     while (Date.now() < end && field2(c.graph.getObject(pv.$ref), "Name") === void 0) await wait(40);
     const p = c.graph.getObject(pv.$ref);
     if (!p || field2(p, "Name") === void 0) throw new RoonError(`Roon knows no artist with key ${key}`, "not_found");
-    const res = await c.call("Qobuz", "GetPerformerMainAlbumLites", [{ type: "long", name: "performerid" }, { type: "ResultCallback<IList<AlbumLite>>", name: "cb_result" }], buildArgs([Arg.long(BigInt(key))]), q.oid);
-    if (!res.success) throw new RoonError(`Qobuz::GetPerformerMainAlbumLites: ${res.status}`);
+    const res = await c.call(SERVICE_TYPE[service2], "GetPerformerMainAlbumLites", [{ type: "long", name: "performerid" }, { type: "ResultCallback<IList<AlbumLite>>", name: "cb_result" }], buildArgs([Arg.long(BigInt(key))]), q.oid);
+    if (!res.success) throw new RoonError(`${SERVICE_NAME[service2]}::GetPerformerMainAlbumLites: ${res.status}`);
     const refs = refList(res.payload);
     await untilLoaded(c, refs.map((oid) => ({ $ref: oid })), 3e3);
     const albums = refs.map((oid) => c.graph.getObject(oid)).filter((o) => o && field2(o, "Title") !== void 0).map((o) => albumRow(c, o)).map((r, i) => ({ r, i })).sort((a, b) => (a.r.year ?? 9999) - (b.r.year ?? 9999) || a.i - b.i).map((x) => x.r);
@@ -16195,10 +16273,10 @@ async function discography(key) {
     if (typeof n === "number") artist.albums_in_library = n;
     const from = field2(p, "BirthPlace");
     if (from) artist.from = from;
-    return { artist, albums };
+    return { service: SERVICE_NAME[service2], artist, albums };
   });
 }
-var qobuz, SECTIONS, library, CREDIT_KIND, cut, choose;
+var SERVICE_NAME, SERVICE_TYPE, NONE2, SECTIONS, library, CREDIT_KIND, cut, choose;
 var init_library = __esm({
   "src/roon/library.ts"() {
     "use strict";
@@ -16208,21 +16286,28 @@ var init_library = __esm({
     init_writer();
     init_session();
     init_graph();
-    qobuz = /* @__PURE__ */ __name((c) => {
-      const q = c.graph.findByType("Qobuz")[0];
-      if (!q) throw new RoonError("This Roon Core has no Qobuz service (Qobuz isn't signed in?)", "unavailable");
-      return q;
-    }, "qobuz");
+    SERVICE_NAME = { qobuz: "Qobuz", tidal: "TIDAL" };
+    SERVICE_TYPE = { qobuz: "Qobuz", tidal: "Tidal" };
+    __name(signedIn, "signedIn");
+    __name(streaming, "streaming");
+    NONE2 = { types: [], args: Buffer.alloc(0) };
+    __name(shelf, "shelf");
     __name(search, "search");
     SECTIONS = {
-      new: "GetNewAlbums",
-      qobuzissimes: "GetQobuzissimesAlbums",
-      press_awards: "GetPressAwardsAlbums",
-      top: "GetTopAlbums",
-      trending: "GetStillTrendingAlbums",
-      ideal_discography: "GetIdealDiscographyAlbums"
+      qobuz: {
+        new: "GetNewAlbums",
+        qobuzissimes: "GetQobuzissimesAlbums",
+        press_awards: "GetPressAwardsAlbums",
+        top: "GetTopAlbums",
+        trending: "GetStillTrendingAlbums",
+        ideal_discography: "GetIdealDiscographyAlbums"
+      },
+      tidal: { new: "GetNew", recommended: "GetRecommended", top: "GetTop", rising: "GetRising", masters: "GetMasters" }
     };
     __name(section, "section");
+    __name(tidalList, "tidalList");
+    __name(tidalPick, "tidalPick");
+    __name(tidalStruct, "tidalStruct");
     __name(genres, "genres");
     library = /* @__PURE__ */ __name((c) => c.serviceOid("Library"), "library");
     __name(findAlbum, "findAlbum");
@@ -24017,12 +24102,12 @@ function handleCatchall(proms, input2, payload, ctx, def, inst, abortEarly) {
   const t = _catchall.def.type;
   const optin = _catchall.optin;
   const optout = _catchall.optout;
-  let seen = 0;
+  let seen2 = 0;
   for (const key in input2) {
-    if (abortEarly && payload.issues.length !== seen) {
-      if (aborted(payload, seen))
+    if (abortEarly && payload.issues.length !== seen2) {
+      if (aborted(payload, seen2))
         break;
-      seen = payload.issues.length;
+      seen2 = payload.issues.length;
     }
     if (keySet.has(key))
       continue;
@@ -24112,12 +24197,12 @@ var $ZodObject = /* @__PURE__ */ $constructor("$ZodObject", (inst, def) => {
     const proms = [];
     const shape = value.shape;
     const abortEarly = ctx?.abortEarly;
-    let seen = payload.issues.length;
+    let seen2 = payload.issues.length;
     for (const key of value.allKeys) {
-      if (abortEarly && payload.issues.length !== seen) {
-        if (aborted(payload, seen))
+      if (abortEarly && payload.issues.length !== seen2) {
+        if (aborted(payload, seen2))
           break;
-        seen = payload.issues.length;
+        seen2 = payload.issues.length;
       }
       if (key === "__proto__")
         continue;
@@ -24663,12 +24748,12 @@ var $ZodTuple = /* @__PURE__ */ $constructor("$ZodTuple", (inst, def) => {
     if (def.rest && !itemAborted) {
       let i = items2.length - 1;
       const rest = input2.slice(items2.length);
-      let seen = payload.issues.length;
+      let seen2 = payload.issues.length;
       for (const el of rest) {
-        if (abortEarly && payload.issues.length !== seen) {
-          if (aborted(payload, seen))
+        if (abortEarly && payload.issues.length !== seen2) {
+          if (aborted(payload, seen2))
             break;
-          seen = payload.issues.length;
+          seen2 = payload.issues.length;
         }
         i++;
         const result = def.rest._zod.run({ value: el, issues: [] }, ctx);
@@ -24901,12 +24986,12 @@ var $ZodMap = /* @__PURE__ */ $constructor("$ZodMap", (inst, def) => {
     const proms = [];
     payload.value = memo2 ? memo2.alloc(inst, payload, /* @__PURE__ */ new Map(), ctx) : /* @__PURE__ */ new Map();
     const abortEarly = ctx?.abortEarly;
-    let seen = payload.issues.length;
+    let seen2 = payload.issues.length;
     for (const [key, value] of input2) {
-      if (abortEarly && payload.issues.length !== seen) {
-        if (aborted(payload, seen))
+      if (abortEarly && payload.issues.length !== seen2) {
+        if (aborted(payload, seen2))
           break;
-        seen = payload.issues.length;
+        seen2 = payload.issues.length;
       }
       const keyResult = def.keyType._zod.run({ value: key, issues: [] }, ctx);
       const valueResult = def.valueType._zod.run({ value, issues: [] }, ctx);
@@ -24973,12 +25058,12 @@ var $ZodSet = /* @__PURE__ */ $constructor("$ZodSet", (inst, def) => {
     const proms = [];
     payload.value = memo2 ? memo2.alloc(inst, payload, /* @__PURE__ */ new Set(), ctx) : /* @__PURE__ */ new Set();
     const abortEarly = ctx?.abortEarly;
-    let seen = payload.issues.length;
+    let seen2 = payload.issues.length;
     for (const item of input2) {
-      if (abortEarly && payload.issues.length !== seen) {
-        if (aborted(payload, seen))
+      if (abortEarly && payload.issues.length !== seen2) {
+        if (aborted(payload, seen2))
           break;
-        seen = payload.issues.length;
+        seen2 = payload.issues.length;
       }
       const result = def.valueType._zod.run({ value: item, issues: [] }, ctx);
       if (result instanceof Promise) {
@@ -36558,14 +36643,14 @@ __name(handleUnrepresentable, "handleUnrepresentable");
 function processSchema(schema, ctx, _params = { path: [], schemaPath: [] }) {
   var _a3;
   const def = schema._zod.def;
-  const seen = ctx.seen.get(schema);
-  if (seen) {
-    seen.count++;
+  const seen2 = ctx.seen.get(schema);
+  if (seen2) {
+    seen2.count++;
     const isCycle = _params.schemaPath.includes(schema);
     if (isCycle) {
-      seen.cycle = _params.path;
+      seen2.cycle = _params.path;
     }
-    return seen.schema;
+    return seen2.schema;
   }
   const result = { schema: {}, count: 1, cycle: void 0, path: _params.path };
   ctx.seen.set(schema, result);
@@ -36657,12 +36742,12 @@ function extractDefs(ctx, schema) {
     if (entry[1].schema.$ref) {
       return;
     }
-    const seen = entry[1];
+    const seen2 = entry[1];
     const { ref, defId } = makeURI(entry);
-    seen.def = { ...seen.schema };
+    seen2.def = { ...seen2.schema };
     if (defId)
-      seen.defId = defId;
-    const schema2 = seen.schema;
+      seen2.defId = defId;
+    const schema2 = seen2.schema;
     for (const key in schema2) {
       delete schema2[key];
     }
@@ -36670,16 +36755,16 @@ function extractDefs(ctx, schema) {
   }, "extractToDef");
   if (ctx.cycles === "throw") {
     for (const entry of ctx.seen.entries()) {
-      const seen = entry[1];
-      if (seen.cycle) {
-        throw new Error(`Cycle detected: #/${seen.cycle?.join("/")}/<root>
+      const seen2 = entry[1];
+      if (seen2.cycle) {
+        throw new Error(`Cycle detected: #/${seen2.cycle?.join("/")}/<root>
 
 Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.`);
       }
     }
   }
   for (const entry of ctx.seen.entries()) {
-    const seen = entry[1];
+    const seen2 = entry[1];
     if (schema === entry[0]) {
       extractToDef(entry);
       continue;
@@ -36696,11 +36781,11 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
       extractToDef(entry);
       continue;
     }
-    if (seen.cycle) {
+    if (seen2.cycle) {
       extractToDef(entry);
       continue;
     }
-    if (seen.count > 1) {
+    if (seen2.count > 1) {
       if (ctx.reused === "ref") {
         extractToDef(entry);
       }
@@ -36765,7 +36850,7 @@ function foldObjects(members2) {
         const part = other.properties?.[key] ?? undeclaredConstraint(other);
         if (part === null || part === void 0)
           continue;
-        if (!parts.some((seen) => JSON.stringify(seen) === JSON.stringify(part)))
+        if (!parts.some((seen2) => JSON.stringify(seen2) === JSON.stringify(part)))
           parts.push(part);
       }
       const merged = parts.length === 1 ? parts[0] : foldObjects(parts) ?? { allOf: parts };
@@ -36783,7 +36868,7 @@ function foldObjects(members2) {
     const constraints = [];
     for (const object3 of objects) {
       const constraint = undeclaredConstraint(object3);
-      if (constraint && !constraints.some((seen) => JSON.stringify(seen) === JSON.stringify(constraint)))
+      if (constraint && !constraints.some((seen2) => JSON.stringify(seen2) === JSON.stringify(constraint)))
         constraints.push(constraint);
     }
     if (constraints.length === 1)
@@ -36827,13 +36912,13 @@ function finalize(ctx, schema) {
   if (!root)
     throw new Error("Unprocessed schema. This is a bug in Zod.");
   const flattenRef = /* @__PURE__ */ __name((zodSchema) => {
-    const seen = ctx.seen.get(zodSchema);
-    if (seen.ref === null)
+    const seen2 = ctx.seen.get(zodSchema);
+    if (seen2.ref === null)
       return;
-    const schema2 = seen.def ?? seen.schema;
+    const schema2 = seen2.def ?? seen2.schema;
     const _cached = { ...schema2 };
-    const ref = seen.ref;
-    seen.ref = null;
+    const ref = seen2.ref;
+    seen2.ref = null;
     if (ref) {
       flattenRef(ref);
       const refSeen = ctx.seen.get(ref);
@@ -36885,7 +36970,7 @@ function finalize(ctx, schema) {
     ctx.override({
       zodSchema,
       jsonSchema: schema2,
-      path: seen.path ?? []
+      path: seen2.path ?? []
     });
   }, "flattenRef");
   if (!ctx.external || ctx.sharedEmitDoneFor !== ctx.external) {
@@ -36901,8 +36986,8 @@ function finalize(ctx, schema) {
       rewrite();
     if (ctx.intersections.length) {
       const carriers = /* @__PURE__ */ new Map();
-      for (const seen of ctx.seen.values()) {
-        for (const json2 of [seen.schema, seen.def]) {
+      for (const seen2 of ctx.seen.values()) {
+        for (const json2 of [seen2.schema, seen2.def]) {
           const allOf = json2?.allOf;
           if (!Array.isArray(allOf))
             continue;
@@ -36942,11 +37027,11 @@ function finalize(ctx, schema) {
   const defs = ctx.external?.defs ?? {};
   if (!ctx.external || ctx.sharedEmitDoneFor !== ctx.external) {
     for (const entry of ctx.seen.entries()) {
-      const seen = entry[1];
-      if (seen.def && seen.defId) {
-        if (seen.def.id === seen.defId)
-          delete seen.def.id;
-        assignProp(defs, seen.defId, seen.def);
+      const seen2 = entry[1];
+      if (seen2.def && seen2.defId) {
+        if (seen2.def.id === seen2.defId)
+          delete seen2.def.id;
+        assignProp(defs, seen2.defId, seen2.def);
       }
     }
   }
@@ -37565,8 +37650,8 @@ function rewriteKeyNames(ctx) {
   }
   const rewrites = /* @__PURE__ */ new Map();
   for (const record2 of pendingRecords.get(ctx) ?? []) {
-    const seen = ctx.seen.get(record2);
-    const names2 = (seen?.def ?? seen?.schema)?.propertyNames;
+    const seen2 = ctx.seen.get(record2);
+    const names2 = (seen2?.def ?? seen2?.schema)?.propertyNames;
     if (!names2 || names2 === true || rewrites.has(names2))
       continue;
     const rewritten = stringifyKeyNames(bySchema, names2, /* @__PURE__ */ new Set());
@@ -37630,9 +37715,9 @@ var recordProcessor = /* @__PURE__ */ __name((schema, ctx, _json, params) => {
 var nullableProcessor = /* @__PURE__ */ __name((schema, ctx, json2, params) => {
   const def = schema._zod.def;
   const inner = processSchema(def.innerType, ctx, params);
-  const seen = ctx.seen.get(schema);
+  const seen2 = ctx.seen.get(schema);
   if (ctx.target === "openapi-3.0") {
-    seen.ref = def.innerType;
+    seen2.ref = def.innerType;
     json2.nullable = true;
   } else {
     json2.anyOf = [inner, { type: "null" }];
@@ -37641,8 +37726,8 @@ var nullableProcessor = /* @__PURE__ */ __name((schema, ctx, json2, params) => {
 var nonoptionalProcessor = /* @__PURE__ */ __name((schema, ctx, _json, params) => {
   const def = schema._zod.def;
   processSchema(def.innerType, ctx, params);
-  const seen = ctx.seen.get(schema);
-  seen.ref = def.innerType;
+  const seen2 = ctx.seen.get(schema);
+  seen2.ref = def.innerType;
 }, "nonoptionalProcessor");
 var UNREPRESENTABLE_DEFAULT = /* @__PURE__ */ Symbol();
 function serializeDefaultValue(value, schema, ctx, json2, params) {
@@ -37662,8 +37747,8 @@ __name(serializeDefaultValue, "serializeDefaultValue");
 var defaultProcessor = /* @__PURE__ */ __name((schema, ctx, json2, params) => {
   const def = schema._zod.def;
   processSchema(def.innerType, ctx, params);
-  const seen = ctx.seen.get(schema);
-  seen.ref = def.innerType;
+  const seen2 = ctx.seen.get(schema);
+  seen2.ref = def.innerType;
   const value = serializeDefaultValue(def.defaultValue, schema, ctx, json2, params);
   if (value !== UNREPRESENTABLE_DEFAULT)
     json2.default = value;
@@ -37671,8 +37756,8 @@ var defaultProcessor = /* @__PURE__ */ __name((schema, ctx, json2, params) => {
 var prefaultProcessor = /* @__PURE__ */ __name((schema, ctx, json2, params) => {
   const def = schema._zod.def;
   processSchema(def.innerType, ctx, params);
-  const seen = ctx.seen.get(schema);
-  seen.ref = def.innerType;
+  const seen2 = ctx.seen.get(schema);
+  seen2.ref = def.innerType;
   if (ctx.io !== "input")
     return;
   const value = serializeDefaultValue(def.defaultValue, schema, ctx, json2, params);
@@ -37682,8 +37767,8 @@ var prefaultProcessor = /* @__PURE__ */ __name((schema, ctx, json2, params) => {
 var catchProcessor = /* @__PURE__ */ __name((schema, ctx, json2, params) => {
   const def = schema._zod.def;
   processSchema(def.innerType, ctx, params);
-  const seen = ctx.seen.get(schema);
-  seen.ref = def.innerType;
+  const seen2 = ctx.seen.get(schema);
+  seen2.ref = def.innerType;
   let catchValue;
   try {
     catchValue = def.catchValue(void 0);
@@ -37698,33 +37783,33 @@ var pipeProcessor = /* @__PURE__ */ __name((schema, ctx, _json, params) => {
   const inIsTransform = def.in._zod.traits.has("$ZodTransform");
   const innerType = ctx.io === "input" ? inIsTransform ? def.out : def.in : def.out;
   processSchema(innerType, ctx, params);
-  const seen = ctx.seen.get(schema);
-  seen.ref = innerType;
+  const seen2 = ctx.seen.get(schema);
+  seen2.ref = innerType;
 }, "pipeProcessor");
 var readonlyProcessor = /* @__PURE__ */ __name((schema, ctx, json2, params) => {
   const def = schema._zod.def;
   processSchema(def.innerType, ctx, params);
-  const seen = ctx.seen.get(schema);
-  seen.ref = def.innerType;
+  const seen2 = ctx.seen.get(schema);
+  seen2.ref = def.innerType;
   json2.readOnly = true;
 }, "readonlyProcessor");
 var promiseProcessor = /* @__PURE__ */ __name((schema, ctx, _json, params) => {
   const def = schema._zod.def;
   processSchema(def.innerType, ctx, params);
-  const seen = ctx.seen.get(schema);
-  seen.ref = def.innerType;
+  const seen2 = ctx.seen.get(schema);
+  seen2.ref = def.innerType;
 }, "promiseProcessor");
 var optionalProcessor = /* @__PURE__ */ __name((schema, ctx, _json, params) => {
   const def = schema._zod.def;
   processSchema(def.innerType, ctx, params);
-  const seen = ctx.seen.get(schema);
-  seen.ref = def.innerType;
+  const seen2 = ctx.seen.get(schema);
+  seen2.ref = def.innerType;
 }, "optionalProcessor");
 var lazyProcessor = /* @__PURE__ */ __name((schema, ctx, _json, params) => {
   const innerType = schema._zod.innerType;
   processSchema(innerType, ctx, params);
-  const seen = ctx.seen.get(schema);
-  seen.ref = innerType;
+  const seen2 = ctx.seen.get(schema);
+  seen2.ref = innerType;
 }, "lazyProcessor");
 var allProcessors = {
   string: stringProcessor,
@@ -40609,7 +40694,7 @@ function checkObjectGuards(objectSchema, guards) {
   return guard.pipe(objectSchema);
 }
 __name(checkObjectGuards, "checkObjectGuards");
-function canonicalKey(value, seen) {
+function canonicalKey(value, seen2) {
   if (value === null)
     return "z";
   const type = typeof value;
@@ -40619,14 +40704,14 @@ function canonicalKey(value, seen) {
     const raw = String(value);
     return `${type[0]}${raw.length}:${raw}`;
   }
-  if (seen.has(value))
+  if (seen2.has(value))
     return null;
-  seen.add(value);
+  seen2.add(value);
   try {
     if (Array.isArray(value)) {
       const parts2 = [];
       for (const item of value) {
-        const key = canonicalKey(item, seen);
+        const key = canonicalKey(item, seen2);
         if (key === null)
           return null;
         parts2.push(key);
@@ -40636,14 +40721,14 @@ function canonicalKey(value, seen) {
     const keys = Object.keys(value).sort();
     const parts = [];
     for (const k of keys) {
-      const key = canonicalKey(value[k], seen);
+      const key = canonicalKey(value[k], seen2);
       if (key === null)
         return null;
       parts.push(`${k.length}:${k}=${key}`);
     }
     return `o${parts.length}:{${parts.join(",")}}`;
   } finally {
-    seen.delete(value);
+    seen2.delete(value);
   }
 }
 __name(canonicalKey, "canonicalKey");
@@ -47297,36 +47382,39 @@ __name(runImage, "runImage");
 
 // src/tools/read.ts
 var READ = { readOnlyHint: true, openWorldHint: false };
+var service = external_exports.enum(["qobuz", "tidal"]).optional().describe("qobuz or tidal \u2014 default: Qobuz when it is signed in in Roon, else TIDAL.");
 var limit = /* @__PURE__ */ __name((max, dflt) => external_exports.number().int().min(1).max(max).optional().describe(`How many (default ${dflt}, at most ${max}).`), "limit");
 function registerReadTools(server, internal = true) {
   const R = /* @__PURE__ */ __name((name) => internal || name === "roon_zones" || name === "roon_now_playing", "R");
   const reg = /* @__PURE__ */ __name(((name, cfg, cb) => R(name) ? server.registerTool.call(server, name, cfg, cb) : void 0), "reg");
   reg("roon_search", {
     title: "Search Roon",
-    description: 'Search Roon \u2014 the user\'s Roon library and the whole Qobuz catalogue at once. Returns albums (with format, e.g. FLAC 96kHz 24bit), artists and tracks. `kind` narrows to album, track or artist \u2014 use `kind: "track"` with the song title (and artist) to find one specific track; a broad query without `kind` can fill up with artists. Albums and tracks carry a `key` for `roon_album`; artists carry a `key` for `roon_artist` and `roon_bio`. Albums say their `year`, and `in_library` when the user has them in Roon. Keys stay valid between calls.',
+    description: 'Search Roon \u2014 the user\'s Roon library and the catalogues of the streaming services signed in (Qobuz, TIDAL) at once; each row says its `source` (library, Qobuz, TIDAL). Returns albums (with format, e.g. FLAC 96kHz 24bit), artists and tracks. `kind` narrows to album, track or artist \u2014 use `kind: "track"` with the song title (and artist) to find one specific track; a broad query without `kind` can fill up with artists. Albums and tracks carry a `key` for `roon_album`; artists carry a `key` for `roon_artist` and `roon_bio`. Albums say their `year`, and `in_library` when the user has them in Roon. Keys stay valid between calls.',
     inputSchema: { query: external_exports.string().min(1), kind: external_exports.enum(["album", "track", "artist"]).optional(), limit: limit(100, 30) },
     annotations: READ
   }, ({ query, kind, limit: n }) => run(() => search(query, n ?? 30, kind)));
   reg("roon_new", {
-    title: "Qobuz shelves in Roon",
-    description: 'Qobuz\'s editorial shelves as Roon shows them (the same for everyone): `new` (new albums), `qobuzissimes`, `press_awards`, `top`, `trending`, `ideal_discography`. Albums carry their format and a `key` for `roon_album`. `genre` narrows a shelf to one or more Qobuz genres \u2014 ids from `roon_genres`; use it for "new jazz", "what\'s new in classical". `offset` pages through the shelf; `total` says how many there are.',
+    title: "Streaming shelves in Roon",
+    description: 'The editorial shelves of Qobuz or TIDAL as Roon shows them (the same for everyone). Qobuz (`service: "qobuz"`): `new`, `qobuzissimes`, `press_awards`, `top`, `trending`, `ideal_discography` \u2014 albums; `genre` narrows a shelf to one or more Qobuz genre ids from `roon_genres`. TIDAL (`service: "tidal"`): `new`, `recommended`, `top`, `rising`, `masters` \u2014 albums, or tracks with `what: "tracks"` (not masters); `genre` (one TIDAL genre from `roon_genres`, e.g. "Jazz") gives TIDAL\'s page for that genre instead of a shelf. Use `genre` for "new jazz", "what\'s new in classical"; TIDAL\'s playlists are in roon_tidal_playlists. Albums carry their format and a `key` for `roon_album`; tracks a `key` for roon_play_tracks. `offset` pages through the shelf; `total` says how many there are.',
     inputSchema: {
-      section: external_exports.enum(["new", "qobuzissimes", "press_awards", "top", "trending", "ideal_discography"]).optional(),
-      genre: external_exports.string().regex(/^\s*\d+(\s*,\s*\d+)*\s*$/, "Qobuz genre ids (numbers), comma-separated \u2014 see roon_genres").optional().describe("Qobuz genre id(s) from roon_genres, comma-separated."),
+      service,
+      section: external_exports.string().optional().describe("The shelf (default new) \u2014 see the list for each service."),
+      genre: external_exports.string().optional().describe("Qobuz: genre id(s) from roon_genres, comma-separated. TIDAL: one genre from roon_genres."),
+      what: external_exports.enum(["albums", "tracks"]).optional().describe("TIDAL only: albums (default) or tracks."),
       limit: limit(100, 30),
       offset: external_exports.number().int().min(0).optional()
     },
     annotations: READ
-  }, ({ section: section2, genre, limit: n, offset: offset2 }) => run(() => section(section2 ?? "new", n ?? 30, offset2 ?? 0, (genre ?? "").split(",").map((x) => x.trim()).filter(Boolean))));
+  }, ({ service: sv, section: section2, genre, what, limit: n, offset: offset2 }) => run(() => section(section2 ?? "new", n ?? 30, offset2 ?? 0, (genre ?? "").split(",").map((x) => x.trim()).filter(Boolean), sv, what ?? "albums")));
   reg("roon_genres", {
-    title: "Qobuz genres",
-    description: "The genres of Qobuz with their ids, for the `genre` filter of `roon_new`. Without `parent`: the main genres (names as Qobuz gives them in the account's language). With `parent` (a genre id): its sub-genres, e.g. the kinds of jazz.",
-    inputSchema: { parent: external_exports.string().optional().describe("A genre id, to list its sub-genres.") },
+    title: "Streaming genres",
+    description: "The genres of Qobuz or TIDAL, for the `genre` filter of `roon_new` (and, for TIDAL, of `roon_tidal_playlists`). Qobuz: the main genres with their ids (names in the account's language); with `parent` (a genre id) its sub-genres, e.g. the kinds of jazz. TIDAL: its genres and its moods (Relax, Focus \u2026), each with an `id` to pass on.",
+    inputSchema: { service, parent: external_exports.string().optional().describe("Qobuz: a genre id, to list its sub-genres.") },
     annotations: READ
-  }, ({ parent }) => run(() => genres(parent)));
+  }, ({ service: sv, parent }) => run(() => genres(parent, sv)));
   reg("roon_album", {
     title: "Album page",
-    description: "One album in Roon, by its `key` (from roon_search, roon_new, roon_artist): the album with year, format, label and whether it is in the library, its genres, release date (and the date of this edition), barcode and \u2014 when Roon has them \u2014 catalogue number and country, its main artist(s) with a `key` for `roon_artist` / `roon_bio`, and every track with its own `key`. A Qobuz album that is also in the library comes back as the library copy (its key may differ; both work). `credits: true` adds who played, produced, engineered and wrote, grouped by role \u2014 Roon's own data.",
+    description: "One album in Roon, by its `key` (from roon_search, roon_new, roon_artist): the album with year, format, label and whether it is in the library, its genres, release date (and the date of this edition), barcode and \u2014 when Roon has them \u2014 catalogue number and country, its main artist(s) with a `key` for `roon_artist` / `roon_bio`, and every track with its own `key`. A streaming album that is also in the library comes back as the library copy (its key may differ; both work). `credits: true` adds who played, produced, engineered and wrote, grouped by role \u2014 Roon's own data.",
     inputSchema: { key: external_exports.string().describe("An album key."), credits: external_exports.boolean().optional() },
     annotations: READ
   }, ({ key, credits }) => run(() => album(key, credits === true)));
@@ -47344,10 +47432,10 @@ function registerReadTools(server, internal = true) {
   }, ({ key, wikipedia, max_chars }) => run(() => bio(key, max_chars ?? 1e9, wikipedia === true)));
   reg("roon_artist", {
     title: "Discography",
-    description: 'An artist\'s discography in Roon: the main albums Qobuz has, oldest first, each with year, format and a `key` for `roon_album`. The artist `key` comes from roon_search (`kind: "artist"`) or from the `artists` of roon_album. Use this for "the album before/after \u2026", "their debut", "what else did they make" \u2014 don\'t answer discography questions from memory. The year is the original release where Roon knows it; reissues and compilations are in the list too.',
-    inputSchema: { key: external_exports.string().describe("An artist key.") },
+    description: 'An artist\'s discography in Roon: the main albums Qobuz (or, with `service: "tidal"`, TIDAL) has, oldest first, each with year, format and a `key` for `roon_album`. The artist `key` comes from roon_search (`kind: "artist"`) or from the `artists` of roon_album. Use this for "the album before/after \u2026", "their debut", "what else did they make" \u2014 don\'t answer discography questions from memory. The year is the original release where Roon knows it; reissues and compilations are in the list too.',
+    inputSchema: { key: external_exports.string().describe("An artist key."), service },
     annotations: READ
-  }, ({ key }) => run(() => discography(key)));
+  }, ({ key, service: sv }) => run(() => discography(key, sv)));
   reg("roon_zones", {
     title: "Roon zones",
     description: "The zones Roon can play on (Roon's own names), and which are grouped right now (`groups`).",
@@ -47988,31 +48076,100 @@ init_official();
 init_log();
 init_graph();
 init_library();
+
+// src/roon/tidal.ts
+init_session();
+init_graph();
+init_library();
+var PLAYLIST_SHELVES = {
+  new: "GetNewPlaylists",
+  recommended: "GetRecommendedPlaylists",
+  exclusive: "GetExclusivePlaylists",
+  masters: "GetMastersPlaylists",
+  popular: "GetPopularPlaylists",
+  essential: "GetEssentialPlaylists",
+  hires_classics: "GetHiResHeadphoneClassicsPlaylists",
+  recently_updated: "GetRecentlyUpdatedPlaylists",
+  forgotten_favorites: "GetForgottenFavoritePlaylists",
+  my_mixes: "GetDailyMixes",
+  history_mixes: "GetHistoryMixes"
+};
+var seen = /* @__PURE__ */ new Map();
+var playlistKey = /* @__PURE__ */ __name((p) => {
+  const id = field2(p, "PlaylistId");
+  return Buffer.isBuffer(id) ? id.toString("hex") : String(id ?? "");
+}, "playlistKey");
+async function fetch2(c, w) {
+  const { o } = streaming(c, "tidal");
+  if (w.genre) {
+    const g = await tidalPick(c, o, "GetGenres", w.genre);
+    const r2 = await shelf(c, "tidal", o, "GetGenrePlaylists", "Playlist", w.offset, w.count, { types: [{ type: "TidalGenre", name: "genre" }], args: tidalStruct(c, "TidalGenre", g) });
+    return Object.assign(r2.items, { total: r2.total });
+  }
+  if (w.mood) {
+    const m = await tidalPick(c, o, "GetMoods", w.mood);
+    const r2 = await shelf(c, "tidal", o, "GetMoodPlaylists", "Playlist", w.offset, w.count, { types: [{ type: "TidalMood", name: "mood" }], args: tidalStruct(c, "TidalMood", m) });
+    return Object.assign(r2.items, { total: r2.total });
+  }
+  const method = PLAYLIST_SHELVES[w.shelf];
+  if (!method) throw new RoonError(`TIDAL has no playlist shelf "${w.shelf}"; choose from ${Object.keys(PLAYLIST_SHELVES).join(", ")}`, "invalid");
+  const r = await shelf(c, "tidal", o, method, "Playlist", w.offset, w.count);
+  return Object.assign(r.items, { total: r.total });
+}
+__name(fetch2, "fetch");
+async function playlists(shelfName, genre, mood, limit3, offset2) {
+  return withCore(async (c) => {
+    const w = { shelf: genre ? "genre" : mood ? "mood" : shelfName, genre, mood, offset: Math.max(0, offset2), count: Math.min(Math.max(1, limit3), 100) };
+    const list = await fetch2(c, w);
+    const rows = list.map((p) => {
+      const key = playlistKey(p);
+      seen.set(key, w);
+      const r = { key, name: String(field2(p, "Name") ?? "").trim() };
+      const d = field2(p, "Description");
+      if (d) r.description = clean(d).replace(/\s+/g, " ").trim().slice(0, 240);
+      const n = field2(p, "TrackCount") ?? field2(p, "ItemCount");
+      if (typeof n === "number") r.tracks = n;
+      const l = field2(p, "LengthSeconds");
+      if (typeof l === "number") r.length = duration3(l);
+      const a = strings(c, field2(p, "SampleArtistNames"));
+      if (a.length) r.artists = a.slice(0, 5);
+      return r;
+    });
+    return { service: "TIDAL", shelf: genre || mood ? void 0 : shelfName, genre, mood, total: list.total ?? void 0, offset: w.offset, rows };
+  });
+}
+__name(playlists, "playlists");
+async function findPlaylist(c, key) {
+  const here = [...c.graph.objects.values()].find((o) => /\.Playlist$/.test(o.typeName) && playlistKey(o) === key && field2(o, "Name") !== void 0);
+  if (here) return here;
+  const w = seen.get(key);
+  if (!w) return null;
+  return (await fetch2(c, w)).map((p) => obj(c, p)).find((p) => playlistKey(p) === key) ?? null;
+}
+__name(findPlaylist, "findPlaylist");
+
+// src/roon/more.ts
 var profileObject = /* @__PURE__ */ __name((c) => {
   const p = [...c.graph.objects.values()].find((o) => o.typeName.endsWith(".Profile"));
   if (!p) throw new RoonError("Roon gave no profile");
   return p;
 }, "profileObject");
 var decoded2 = /* @__PURE__ */ __name((c, payload) => payload.length ? c.graph.decodeReturnValue(Uint8Array.from(payload)) : null, "decoded");
-var PLAYLIST_KIND = { 1: "itunes", 5: "roon", 6: "roon (read-only)", 10: "tidal", 11: "file", 12: "qobuz", 13: "roon editorial", 15: "smart" };
+var PLAYLIST_KIND = { 1: "itunes", 5: "roon", 6: "roon (read-only)", 10: "TIDAL", 11: "file", 12: "qobuz", 13: "roon editorial", 15: "smart" };
 function allPlaylists(c) {
-  const service = c.graph.findByType("Playlists")[0];
-  if (!service) throw new RoonError("Roon gives no playlists service", "unavailable");
-  return { service, list: items(c, field2(service, "AllPlaylists")) };
+  const service2 = c.graph.findByType("Playlists")[0];
+  if (!service2) throw new RoonError("Roon gives no playlists service", "unavailable");
+  return { service: service2, list: items(c, field2(service2, "AllPlaylists")) };
 }
 __name(allPlaylists, "allPlaylists");
-var playlistKey = /* @__PURE__ */ __name((p) => {
-  const id = field2(p, "PlaylistId");
-  return Buffer.isBuffer(id) ? id.toString("hex") : String(id ?? "");
-}, "playlistKey");
-function findPlaylist(c, key) {
+async function findPlaylist2(c, key) {
   const { list } = allPlaylists(c);
-  const p = list.find((x) => playlistKey(x) === key) ?? list.find((x) => String(field2(x, "Name") ?? "").toLowerCase() === key.toLowerCase());
-  if (!p) throw new RoonError("Unknown playlist \u2014 read roon_playlists for the keys", "not_found");
+  const p = list.find((x) => playlistKey(x) === key) ?? list.find((x) => String(field2(x, "Name") ?? "").toLowerCase() === key.toLowerCase()) ?? await findPlaylist(c, key);
+  if (!p) throw new RoonError("Unknown playlist \u2014 read roon_playlists (or roon_tidal_playlists) for the keys", "not_found");
   return p;
 }
-__name(findPlaylist, "findPlaylist");
-async function playlists() {
+__name(findPlaylist2, "findPlaylist");
+async function playlists2() {
   return withCore(async (c) => ({ playlists: allPlaylists(c).list.map((p) => ({
     key: playlistKey(p),
     name: field2(p, "Name") ?? "",
@@ -48021,10 +48178,10 @@ async function playlists() {
     read_only: field2(p, "IsReadOnly") === true || void 0
   })) }));
 }
-__name(playlists, "playlists");
+__name(playlists2, "playlists");
 async function playlist(key, limit3) {
   return withCore(async (c) => {
-    const p = findPlaylist(c, key);
+    const p = await findPlaylist2(c, key);
     const res = await c.call("Playlist", "GetItems", [{ type: "ResultCallback<Query<PlaylistItem>>", name: "cb_result" }], Buffer.alloc(0), p.oid);
     if (!res.success) throw new RoonError(`Roon refused the playlist (${res.status})`);
     const v = decoded2(c, res.payload);
@@ -48047,7 +48204,7 @@ __name(playlist, "playlist");
 async function playPlaylist(key, zoneName, how, shuffle) {
   const p = PRIORITY[how];
   const r = await withCore(async (c) => {
-    const pl = findPlaylist(c, key);
+    const pl = await findPlaylist2(c, key);
     const z2 = findZone(c, zoneName);
     const args = Buffer.concat([buildArgs([Arg.ref(z2.oid), Arg.sooid(c.profile())]), playParams(c, p, shuffle), buildArgs([Arg.ref(pl.oid), Arg.ref(0n)])]);
     const res = await c.call(
@@ -48073,7 +48230,7 @@ async function playPlaylist(key, zoneName, how, shuffle) {
 __name(playPlaylist, "playPlaylist");
 async function playlistCreate(name, keys) {
   return withCore(async (c) => {
-    const { service } = allPlaylists(c);
+    const { service: service2 } = allPlaylists(c);
     await findTracks(c, keys);
     const res = await c.call(
       "Playlists",
@@ -48087,7 +48244,7 @@ async function playlistCreate(name, keys) {
         { type: "ResultCallback<Playlist>", name: "cb_result" }
       ],
       buildArgs([Arg.ref(profileObject(c).oid), Arg.str(name), Arg.str(""), Arg.bool(false), Arg.collection(keys.map((k) => buildArgs([Arg.long(BigInt(k))])))]),
-      service.oid
+      service2.oid
     );
     if (!res.success) throw new RoonError(`Roon refused the playlist (${res.status})`);
     const end = Date.now() + 3e3;
@@ -48106,20 +48263,9 @@ async function favorites(source, limit3) {
     return { source, total: r.total, rows: r.rows };
   }
   return withCore(async (c) => {
-    const q = c.graph.findByType("Qobuz")[0];
-    if (!q) throw new RoonError("This Roon Core has no Qobuz service", "unavailable");
-    const res = await c.call(
-      "Qobuz",
-      "GetFavoriteAlbums",
-      [{ type: "int", name: "offset" }, { type: "int", name: "count" }, { type: "ResultCallback<PartialList<AlbumLite>>", name: "cb_result" }],
-      buildArgs([Arg.int(0), Arg.int(n)]),
-      q.oid
-    );
-    if (!res.success) throw new RoonError(`Roon refused the Qobuz favourites (${res.status})`);
-    const { partialList: partialList2 } = await Promise.resolve().then(() => (init_graph(), graph_exports));
-    const list = partialList2(c, c.graph.decodeReturnValue(Uint8Array.from(res.payload)));
-    await untilLoaded(c, list.items);
-    return { source, total: list.total, rows: list.items.map((x) => obj(c, x)).filter(Boolean).map((o) => albumRow(c, o)) };
+    const { service: service2, o } = streaming(c, source);
+    const list = await shelf(c, service2, o, "GetFavoriteAlbums", "AlbumLite", 0, n);
+    return { source, total: list.total, rows: list.items.map((x) => albumRow(c, x)) };
   });
 }
 __name(favorites, "favorites");
@@ -48272,8 +48418,8 @@ async function similarAlbum(key, limit3) {
     const A = isRef2(full) ? c.graph.getObject(full.$ref) : null;
     const self = String(field2(al, "AlbumId"));
     const unique = /* @__PURE__ */ __name((l) => {
-      const seen = /* @__PURE__ */ new Set([self]);
-      return l.filter((o) => o && field2(o, "Title") !== void 0 && !seen.has(String(field2(o, "AlbumId"))) && seen.add(String(field2(o, "AlbumId")))).slice(0, limit3).map((o) => albumRow(c, o));
+      const seen2 = /* @__PURE__ */ new Set([self]);
+      return l.filter((o) => o && field2(o, "Title") !== void 0 && !seen2.has(String(field2(o, "AlbumId"))) && seen2.add(String(field2(o, "AlbumId")))).slice(0, limit3).map((o) => albumRow(c, o));
     }, "unique");
     const res = await short(c.call(
       "Library",
@@ -48657,13 +48803,13 @@ function registerLibraryTools(server) {
   }, ({ limit: n }) => run(() => dailyPicks(n ?? 8)));
   server.registerTool("roon_new_for_you", {
     title: "New releases for you",
-    description: '"New releases for you" from Roon\'s Home: new albums Roon picked for this user, from the artists and music they listen to \u2014 personal, unlike roon_new (Qobuz\'s editorial shelf, the same for everyone). Use it for "my new releases", "what\'s new for me". Albums carry year, format, sometimes a `review`, and a `key`.',
+    description: '"New releases for you" from Roon\'s Home: new albums Roon picked for this user, from the artists and music they listen to \u2014 personal, unlike roon_new (the streaming services\' editorial shelf, the same for everyone). Use it for "my new releases", "what\'s new for me". Albums carry year, format, sometimes a `review`, and a `key`.',
     inputSchema: { limit: limit2(100, 30), offset },
     annotations: READ2
   }, ({ limit: n, offset: o }) => run(() => newForYou(n ?? 30, o ?? 0)));
   server.registerTool("roon_mixes", {
     title: "Daily Mixes",
-    description: "The Daily Mixes from Roon's Home: today's personal mixes, each built around an artist (or genre) the user listens to, with a few `touchstones` and a `key` for roon_play_mix. They change every day.",
+    description: 'Roon\'s own Daily Mixes, from Roon\'s Home \u2014 NOT TIDAL\'s mixes: for "TIDAL mixes", "My Mix", "My Daily Discovery" or TIDAL\'s daily mixes use roon_tidal_playlists with `shelf: "my_mixes"`. These are today\'s personal Roon mixes, each built around an artist (or genre) the user listens to, with a few `touchstones` and a `key` for roon_play_mix. They change every day.',
     inputSchema: {},
     annotations: READ2
   }, () => run(() => mixes()));
@@ -48675,19 +48821,31 @@ function registerLibraryTools(server) {
   }, ({ key, zone: zn, mode: m }) => run(() => playMix(key, zn, m ?? "now")));
   server.registerTool("roon_playlists", {
     title: "Playlists",
-    description: "The playlists Roon knows: the user's own Roon playlists, Qobuz playlists and editorial ones \u2014 each with a `key` for roon_playlist and roon_play_playlist, the number of tracks, and whether it is read-only.",
+    description: "The playlists in the user's Roon: their own Roon playlists, Qobuz and TIDAL playlists they added, and editorial ones \u2014 each with a `key` for roon_playlist and roon_play_playlist, the number of tracks, and whether it is read-only.",
     inputSchema: {},
     annotations: READ2
-  }, () => run(() => playlists()));
+  }, () => run(() => playlists2()));
+  server.registerTool("roon_tidal_playlists", {
+    title: "TIDAL playlists",
+    description: "TIDAL's playlists as Roon shows them, when TIDAL is signed in: the editorial shelves `new`, `recommended`, `exclusive`, `masters`, `popular`, `essential`, `hires_classics`, `recently_updated`, `forgotten_favorites`; the user's own TIDAL mixes `my_mixes` (My Daily Discovery, My Mix 1 \u2026, My New Arrivals \u2014 what the user means by their TIDAL (daily) mixes; not roon_mixes, which are Roon's) and `history_mixes` (My Most Listened, the yearly ones \u2026); or the playlists of one TIDAL `genre` or `mood` (ids from roon_genres with `service: \"tidal\"`). Each playlist has a `key` for roon_playlist (its tracks \u2014 readable without playing) and roon_play_playlist, a description, the number of tracks and a few of its artists.",
+    inputSchema: {
+      shelf: external_exports.enum(Object.keys(PLAYLIST_SHELVES)).optional().describe("Default new."),
+      genre: external_exports.string().optional().describe("A TIDAL genre (roon_genres, service tidal)."),
+      mood: external_exports.string().optional().describe("A TIDAL mood (roon_genres, service tidal)."),
+      limit: limit2(100, 20),
+      offset
+    },
+    annotations: READ2
+  }, ({ shelf: shelf2, genre, mood, limit: n, offset: o }) => run(() => playlists(shelf2 ?? "new", genre, mood, n ?? 20, o ?? 0)));
   server.registerTool("roon_playlist", {
     title: "A playlist's tracks",
-    description: "The tracks of one Roon playlist (by its `key` from roon_playlists, or its exact name), each with a `key` for roon_play_tracks.",
+    description: "The tracks of one Roon playlist (by its `key` from roon_playlists or roon_tidal_playlists, or its exact name), each with a `key` for roon_play_tracks.",
     inputSchema: { key: external_exports.string(), limit: limit2(300, 100) },
     annotations: READ2
   }, ({ key, limit: n }) => run(() => playlist(key, n ?? 100)));
   server.registerTool("roon_play_playlist", {
     title: "Play a playlist",
-    description: 'Play a Roon playlist on a Roon zone (`key` from roon_playlists, or its exact name). `mode`: now (default), next or queue. `shuffle: true` starts it shuffled from the very first track (Roon\'s own Shuffle button) \u2014 THE way to "shuffle a playlist": one call, no roon_settings, no skip. Only on an explicit request, never as a probe.',
+    description: 'Play a Roon playlist on a Roon zone (`key` from roon_playlists or roon_tidal_playlists, or its exact name). `mode`: now (default), next or queue. `shuffle: true` starts it shuffled from the very first track (Roon\'s own Shuffle button) \u2014 THE way to "shuffle a playlist": one call, no roon_settings, no skip. Only on an explicit request, never as a probe.',
     inputSchema: { key: external_exports.string(), zone: zone2, mode: mode2, shuffle: external_exports.boolean().optional() },
     annotations: PLAYS2
   }, ({ key, zone: zn, mode: m, shuffle }) => run(() => playPlaylist(key, zn, m ?? "now", shuffle === true)));
@@ -48699,8 +48857,8 @@ function registerLibraryTools(server) {
   }, ({ name, keys }) => run(() => playlistCreate(name, keys)));
   server.registerTool("roon_favorites", {
     title: "Favourite albums",
-    description: 'The user\'s favourite albums: `source: "roon"` (default) are the albums with a heart in Roon, newest first; `source: "qobuz"` the favourites at Qobuz. Albums carry a `key`.',
-    inputSchema: { source: external_exports.enum(["roon", "qobuz"]).optional(), limit: limit2(100, 50) },
+    description: 'The user\'s favourite albums: `source: "roon"` (default) are the albums with a heart in Roon, newest first; `source: "qobuz"` or `"tidal"` the favourites at that service. Albums carry a `key`.',
+    inputSchema: { source: external_exports.enum(["roon", "qobuz", "tidal"]).optional(), limit: limit2(100, 50) },
     annotations: READ2
   }, ({ source, limit: n }) => run(() => favorites(source ?? "roon", n ?? 50)));
   server.registerTool("roon_favorite", {
@@ -48723,13 +48881,13 @@ function registerLibraryTools(server) {
   }, ({ kind, key, on }) => run(() => listenLaterSet(kind, key, on !== false)));
   server.registerTool("roon_library_add", {
     title: "Add to the library",
-    description: "Add a Qobuz album to the user's Roon library (the album `key` from a search, shelf or discography). Changes the library: only on an explicit request.",
+    description: "Add a Qobuz or TIDAL album to the user's Roon library (the album `key` from a search, shelf or discography). Changes the library: only on an explicit request.",
     inputSchema: { key: external_exports.string() },
     annotations: CHANGES
   }, ({ key }) => run(() => libraryAdd(key)));
   server.registerTool("roon_versions", {
     title: "Other versions",
-    description: 'The other versions Roon knows of an album (by album `key`): remasters, deluxe editions, mono/stereo, hi-res \u2014 `in_library` and `streaming` (at Qobuz), best format first, each with year, format, number of tracks and a `key`. For "is there a hi-res version", "which editions exist".',
+    description: 'The other versions Roon knows of an album (by album `key`): remasters, deluxe editions, mono/stereo, hi-res \u2014 `in_library` and `streaming` (at Qobuz or TIDAL \u2014 each row says its `source`), best format first, each with year, format, number of tracks and a `key`. For "is there a hi-res version", "which editions exist".',
     inputSchema: { key: external_exports.string().describe("An album key.") },
     annotations: READ2
   }, ({ key }) => run(() => versions(key)));
@@ -48792,12 +48950,12 @@ async function runSelfTest() {
     if (!a.tracks?.length) throw new Error("an album without tracks");
     return `${a.tracks.length} tracks`;
   }));
-  out.push(await timed("Qobuz shelf", "roon_new, roon_genres, roon_artist", async () => {
+  out.push(await timed("streaming shelf", "roon_new, roon_genres, roon_artist, roon_tidal_playlists", async () => {
     try {
       const s = await section("new", 1, 0);
-      return `${s.total ?? "?"} new albums`;
+      return `${s.total ?? "?"} new albums at ${s.service}`;
     } catch (e) {
-      if (/no Qobuz/i.test(e.message)) return "no Qobuz on this Core (not an error)";
+      if (/Neither Qobuz nor TIDAL/i.test(e.message)) return "no Qobuz or TIDAL signed in on this Core (not an error)";
       throw e;
     }
   }));
@@ -48836,10 +48994,11 @@ init_session();
 init_session();
 init_log();
 init_package();
-var INSTRUCTIONS = `Deep Roon MCP connects to the user's own Roon Core (music player software, with Qobuz behind it when the user has it).
+var INSTRUCTIONS = `Deep Roon MCP connects to the user's own Roon Core (music player software, with Qobuz and/or TIDAL behind it when the user has them).
 - Albums, tracks and artists come with a \`key\`; keys stay valid between calls \u2014 no need to search again.
 - Reviews and biographies are Roon's own texts: when asked for them, show them in full with the author's name.
 - What plays changes all the time: read roon_now_playing afresh before describing it.
+- "Daily Mixes" are Roon's own (roon_mixes); the user's TIDAL mixes (My Mix 1 \u2026, My Daily Discovery) are roon_tidal_playlists with shelf my_mixes, and their tracks can be read with roon_playlist.
 - Unofficial: this uses Roon's internal protocol, which a Roon update can change; if a tool says so, tell the user to check for an update.`;
 async function main() {
   const server = new McpServer({ name: "deep-roon-mcp", title: "Deep Roon MCP", version: version2, websiteUrl: "https://github.com/renebouwmeester/deep-roon-mcp" }, { instructions: INSTRUCTIONS });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "deep-roon-mcp",
-  "version": "0.1.0",
-  "description": "An MCP server for Roon that reaches the parts the official API doesn't: reviews, biographies, Qobuz's shelves, your history, search across your library and Qobuz",
+  "version": "0.2.1",
+  "description": "An MCP server for Roon that reaches the parts the official API doesn't: reviews, biographies, Qobuz's and TIDAL's shelves, TIDAL's playlists, your history, search across your library and the streaming services",
   "license": "Apache-2.0",
   "author": "René Bouwmeester <21277119+renebouwmeester@users.noreply.github.com>",
   "homepage": "https://github.com/renebouwmeester/deep-roon-mcp",
@@ -15,6 +15,7 @@
     "model-context-protocol",
     "claude",
     "qobuz",
+    "tidal",
     "music"
   ],
   "type": "commonjs",