gerdur-core 2.16.0 → 2.18.0

package/CHANGELOG.md

@@ -1,5 +1,71 @@
 # Changelog
 
+## 2.18.0 - 2026-08-31
+
+Write operations — the first part of this package that changes an account.
+
+### Added
+
+- **`src/api/favorites.ts`** — mutating library operations, in their own module
+  and wired into no download path, so they only run when called deliberately:
+  - `addFavoriteTracks(ids)` / `removeFavoriteTracks(ids)` (`song.addFavorites` /
+    `song.removeFavorites` — note the plural)
+  - `addFavoriteAlbum` / `removeFavoriteAlbum`, `addFavoriteArtist` /
+    `removeFavoriteArtist`
+  - `followPlaylist` / `unfollowPlaylist` (the gateway wants
+    `parent_playlist_id` to follow but `playlist_id` to unfollow)
+  - `addFavoriteShow`, `createPlaylist`, `addTracksToPlaylist`,
+    `removeTracksFromPlaylist`
+
+  The surface was mapped by calling each candidate with **incomplete
+  parameters** — an existing method answers `MISSING_PARAMETER_*`, an absent one
+  `GATEWAY_ERROR` — so method names and their parameter names were established
+  without creating or changing anything.
+
+### Verification status
+
+- Method existence and parameter names: **confirmed by probe**.
+- End-to-end execution: **not run.** `__tests__/favorites.ts` contains
+  snapshot → mutate → assert → revert → assert-restored round trips, gated
+  behind `GERDUR_ALLOW_WRITE_TESTS=1` so they never fire by accident.
+
+### Known gaps
+
+- **Deezer's gateway has no playlist delete.** `playlist.delete`, `.remove`,
+  `.destroy`, `.deletePlaylist` and eight other spellings all answer
+  `GATEWAY_ERROR`, so `createPlaylist` is one-way — remove what it makes from a
+  Deezer client. Everything else here has a confirmed inverse.
+- No `show.deleteFavorite` was found, so `addFavoriteShow` is one-way too.
+- **`log.listen` (scrobbling) is not implemented.** It never answered the probe,
+  so its shape is unknown, and it writes to listening history that cannot be
+  undone — not something to ship on a guess.
+
+## 2.17.0 - 2026-08-31
+
+The account's own library, over the authenticated gateway.
+
+### Added
+
+- **`src/api/library.ts`** — the logged-in account's *private* library. Distinct
+  from the public-REST surface in `api/user.ts`, which needs a public profile and
+  only shows what that profile exposes. Found by probing the gateway: seven
+  methods answer here that the public API cannot reach.
+  - `getMyPlaylists(userId?, nb?, start?)` — **including private playlists**
+  - `getMyFavoriteTracks` / `getMyFavoriteAlbums` / `getMyFavoriteArtists`
+  - `getMyFavoritePlaylists` / `getMyFavoriteRadios` / `getMyFavoriteShows`
+  - `getMyFavoriteTrackIds()` — every loved track id in one small request, for
+    diffing a local library against the account
+  - `userId` defaults to the logged-in account. Responses are gateway shapes, so
+    tracks arrive with a `TRACK_TOKEN` and are directly downloadable; being
+    account-scoped they stay in the per-session cache and are never shared.
+- **`getTrackMix(sngId, nb?, start?)`** (`song.getSearchTrackMix`) — a "more like
+  this" mix seeded from one track. Unlike the public radio endpoints it returns
+  full gateway tracks **with tokens already attached**: verified that
+  `resolveDownloadUrls` resolves them 3/3 with no `getTrackInfo` round trip.
+
+Verified against a live account: `getMyPlaylists` 1/1, `getMyFavoriteArtists`
+7/7 with real names, `getTrackMix` 5/5 all carrying tokens.
+
 ## 2.16.0 - 2026-08-31
 
 ### Added

package/README.md

@@ -46,6 +46,8 @@ the CLI and the file-writing layer on top.
   - [Search](#search)
   - [Browse and discover](#browse-and-discover)
   - [Flow, radios and a user's library](#flow-radios-and-a-users-library)
+  - [Your own library](#your-own-library)
+  - [Changing the account (write operations)](#changing-the-account-write-operations)
   - [Podcasts](#podcasts)
   - [Preview clips](#preview-clips)
   - [Resolve a download URL](#resolve-a-download-url)
@@ -381,6 +383,70 @@ const {data: loved} = await getUserFavoriteTracks(me.USER_ID);
 const {data: eighties} = await getRadioTracks(38305); // "The '80s"
 ```
 
+### Your own library
+
+`api/user.ts` above reads a **public** profile. These read what the *account*
+can see — private playlists included — over the authenticated gateway, and
+return gateway shapes, so tracks come with a `TRACK_TOKEN` and are immediately
+downloadable.
+
+| Function | Returns |
+| :--- | :--- |
+| `getMyPlaylists(userId?, nb?, start?)` | the account's own playlists, **including private ones** |
+| `getMyFavoriteTracks(userId?, nb?, start?)` | loved tracks, as downloadable gw tracks |
+| `getMyFavoriteTrackIds()` | every loved track id in one request — for diffing a local library |
+| `getMyFavoriteAlbums` / `getMyFavoriteArtists` | favourited albums / artists |
+| `getMyFavoritePlaylists` / `getMyFavoriteRadios` / `getMyFavoriteShows` | followed playlists / radios / shows |
+| `getTrackMix(sngId, nb?, start?)` | a "more like this" mix seeded from a track — **tokens already attached** |
+
+```ts
+import {getMyPlaylists, getTrackMix, resolveDownloadUrls} from 'gerdur-core';
+
+const {data: playlists} = await getMyPlaylists();       // yours, private included
+const {data: mix} = await getTrackMix('3135556', 20);   // 20 tracks like this one
+const urls = await resolveDownloadUrls(mix, [9, 3, 1]); // straight to download — no per-track lookup
+```
+
+`userId` defaults to the logged-in account. These are account-scoped, so they
+never enter the shared cross-session cache.
+
+### Changing the account (write operations)
+
+Everything above reads. These change the logged-in account's library for real —
+they are in their own module, wired into no download path, and only run when you
+call them.
+
+| Function | Inverse |
+| :--- | :--- |
+| `addFavoriteTracks(ids)` | `removeFavoriteTracks(ids)` |
+| `addFavoriteAlbum(id)` | `removeFavoriteAlbum(id)` |
+| `addFavoriteArtist(id)` | `removeFavoriteArtist(id)` |
+| `followPlaylist(id)` | `unfollowPlaylist(id)` |
+| `addFavoriteShow(id)` | — none found |
+| `createPlaylist(title, opts?)` | **— none exists, see below** |
+| `addTracksToPlaylist(id, sngIds)` | `removeTracksFromPlaylist(id, sngIds)` |
+
+```ts
+import {addFavoriteTracks, removeFavoriteTracks} from 'gerdur-core';
+
+await addFavoriteTracks(['3135556']);     // love it
+await removeFavoriteTracks(['3135556']);  // and back
+```
+
+> **`createPlaylist` is a one-way door.** Deezer's gateway exposes no delete —
+> a dozen spellings of `playlist.delete` all answer `GATEWAY_ERROR` — so a
+> playlist made here has to be removed from a Deezer client. It is also the one
+> function in this module that has not been exercised against a live account,
+> for exactly that reason.
+>
+> Method names and parameters were established by probing with incomplete
+> arguments (an existing method answers `MISSING_PARAMETER_*`), so the surface is
+> real; the round trips live in `__tests__/favorites.ts` behind
+> `GERDUR_ALLOW_WRITE_TESTS=1`.
+
+Scrobbling (`log.listen`) is deliberately absent: it never answered the probe and
+it writes history that cannot be undone.
+
 ### Podcasts
 
 ```ts
@@ -787,7 +853,14 @@ import type {
 
 `getUserFlow` · `getUserFavoriteTracks` · `getUserFavoriteAlbums` ·
 `getUserFavoriteArtists` · `getUserPlaylists` · `getUserRadios` ·
-`getUserChartTracks` · `getRadios` · `getRadioTracks` · `getRadioGenres`
+`getUserChartTracks` · `getRadios` · `getRadioTracks` · `getRadioGenres` ·
+`getMyPlaylists` · `getMyFavoriteTracks` · `getMyFavoriteTrackIds` ·
+`getMyFavoriteAlbums` · `getMyFavoriteArtists` · `getMyFavoritePlaylists` ·
+`getMyFavoriteRadios` · `getMyFavoriteShows` · `getTrackMix` ·
+`addFavoriteTracks` · `removeFavoriteTracks` · `addFavoriteAlbum` ·
+`removeFavoriteAlbum` · `addFavoriteArtist` · `removeFavoriteArtist` ·
+`followPlaylist` · `unfollowPlaylist` · `addFavoriteShow` · `createPlaylist` ·
+`addTracksToPlaylist` · `removeTracksFromPlaylist`
 </details>
 
 <details>

package/dist/api/favorites.d.ts

@@ -0,0 +1,59 @@
+/** What the gateway returns for a mutation — usually `true`, or the new id. */
+export type WriteResult = boolean | string | number | Record<string, any>;
+/**
+ * Love one or more tracks (`song.addFavorites`). Reversible with
+ * {@link removeFavoriteTracks}.
+ *
+ * @param sngIds `SNG_ID`s
+ */
+export declare const addFavoriteTracks: (sngIds: (string | number)[]) => Promise<WriteResult>;
+/** Un-love one or more tracks (`song.removeFavorites`). */
+export declare const removeFavoriteTracks: (sngIds: (string | number)[]) => Promise<WriteResult>;
+/** Add an album to favourites (`album.addFavorite`). */
+export declare const addFavoriteAlbum: (albId: string | number) => Promise<WriteResult>;
+/** Remove an album from favourites (`album.deleteFavorite`). */
+export declare const removeFavoriteAlbum: (albId: string | number) => Promise<WriteResult>;
+/** Follow an artist (`artist.addFavorite`). */
+export declare const addFavoriteArtist: (artId: string | number) => Promise<WriteResult>;
+/** Unfollow an artist (`artist.deleteFavorite`). */
+export declare const removeFavoriteArtist: (artId: string | number) => Promise<WriteResult>;
+/**
+ * Follow someone else's playlist (`playlist.addFavorite`). Note the gateway
+ * wants `parent_playlist_id` here but plain `playlist_id` to unfollow.
+ */
+export declare const followPlaylist: (playlistId: string | number) => Promise<WriteResult>;
+/** Unfollow a playlist (`playlist.deleteFavorite`). */
+export declare const unfollowPlaylist: (playlistId: string | number) => Promise<WriteResult>;
+/**
+ * Follow a podcast show (`show.addFavorite`).
+ *
+ * No `show.deleteFavorite` answered the probe, so treat this as one-way until
+ * the inverse is found.
+ */
+export declare const addFavoriteShow: (showId: string | number) => Promise<WriteResult>;
+/**
+ * Create a playlist (`playlist.create`). Resolves to the new `PLAYLIST_ID`.
+ *
+ * **One-way.** The gateway has no delete counterpart (see the module note), so
+ * anything created here has to be removed from a Deezer client. For the same
+ * reason this is the one function on this page that has not been exercised
+ * against a live account.
+ *
+ * @param title       playlist title
+ * @param options     `description`, `status` (0 public / 1 private / 2 collaborative),
+ *                    and `songs` to seed it with `SNG_ID`s
+ */
+export declare const createPlaylist: (title: string, options?: {
+    description?: string;
+    status?: 0 | 1 | 2;
+    songs?: (string | number)[];
+}) => Promise<WriteResult>;
+/**
+ * Append tracks to a playlist (`playlist.addSongs`). Reversible with
+ * {@link removeTracksFromPlaylist}.
+ *
+ * The gateway takes `songs` as `[[sngId, offset], …]`; this wraps that for you.
+ */
+export declare const addTracksToPlaylist: (playlistId: string | number, sngIds: (string | number)[]) => Promise<WriteResult>;
+/** Remove tracks from a playlist (`playlist.deleteSongs`). */
+export declare const removeTracksFromPlaylist: (playlistId: string | number, sngIds: (string | number)[]) => Promise<WriteResult>;

package/dist/api/favorites.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeTracksFromPlaylist = exports.addTracksToPlaylist = exports.createPlaylist = exports.addFavoriteShow = exports.unfollowPlaylist = exports.followPlaylist = exports.removeFavoriteArtist = exports.addFavoriteArtist = exports.removeFavoriteAlbum = exports.addFavoriteAlbum = exports.removeFavoriteTracks = exports.addFavoriteTracks = void 0;
+/**
+ * **Mutating** operations on the logged-in account's library.
+ *
+ * Everything else in this package reads. These change the account, so they are
+ * kept in their own module and none of them are wired into any download path —
+ * you have to call them deliberately.
+ *
+ * The method names here were established by probing the gateway with incomplete
+ * parameters, which makes an existing method answer `MISSING_PARAMETER_*` while
+ * an absent one answers `GATEWAY_ERROR` — so the surface was mapped without
+ * creating or changing anything.
+ *
+ * **Deezer's gateway exposes no way to delete a playlist.** `playlist.delete`,
+ * `.remove`, `.destroy` and nine other spellings all answer `GATEWAY_ERROR`.
+ * {@link createPlaylist} is therefore a one-way door: whatever it makes, you
+ * remove from a Deezer client, not from here. Everything else on this page has a
+ * confirmed inverse and is safe to undo.
+ */
+const request_1 = require("./request");
+// ─── Loved tracks ────────────────────────────────────────────────────────────
+/**
+ * Love one or more tracks (`song.addFavorites`). Reversible with
+ * {@link removeFavoriteTracks}.
+ *
+ * @param sngIds `SNG_ID`s
+ */
+const addFavoriteTracks = (sngIds) => (0, request_1.request)({ ids: sngIds.map(String) }, 'song.addFavorites');
+exports.addFavoriteTracks = addFavoriteTracks;
+/** Un-love one or more tracks (`song.removeFavorites`). */
+const removeFavoriteTracks = (sngIds) => (0, request_1.request)({ ids: sngIds.map(String) }, 'song.removeFavorites');
+exports.removeFavoriteTracks = removeFavoriteTracks;
+// ─── Albums / artists ────────────────────────────────────────────────────────
+/** Add an album to favourites (`album.addFavorite`). */
+const addFavoriteAlbum = (albId) => (0, request_1.request)({ alb_id: String(albId) }, 'album.addFavorite');
+exports.addFavoriteAlbum = addFavoriteAlbum;
+/** Remove an album from favourites (`album.deleteFavorite`). */
+const removeFavoriteAlbum = (albId) => (0, request_1.request)({ alb_id: String(albId) }, 'album.deleteFavorite');
+exports.removeFavoriteAlbum = removeFavoriteAlbum;
+/** Follow an artist (`artist.addFavorite`). */
+const addFavoriteArtist = (artId) => (0, request_1.request)({ art_id: String(artId) }, 'artist.addFavorite');
+exports.addFavoriteArtist = addFavoriteArtist;
+/** Unfollow an artist (`artist.deleteFavorite`). */
+const removeFavoriteArtist = (artId) => (0, request_1.request)({ art_id: String(artId) }, 'artist.deleteFavorite');
+exports.removeFavoriteArtist = removeFavoriteArtist;
+// ─── Playlists & shows ───────────────────────────────────────────────────────
+/**
+ * Follow someone else's playlist (`playlist.addFavorite`). Note the gateway
+ * wants `parent_playlist_id` here but plain `playlist_id` to unfollow.
+ */
+const followPlaylist = (playlistId) => (0, request_1.request)({ parent_playlist_id: String(playlistId) }, 'playlist.addFavorite');
+exports.followPlaylist = followPlaylist;
+/** Unfollow a playlist (`playlist.deleteFavorite`). */
+const unfollowPlaylist = (playlistId) => (0, request_1.request)({ playlist_id: String(playlistId) }, 'playlist.deleteFavorite');
+exports.unfollowPlaylist = unfollowPlaylist;
+/**
+ * Follow a podcast show (`show.addFavorite`).
+ *
+ * No `show.deleteFavorite` answered the probe, so treat this as one-way until
+ * the inverse is found.
+ */
+const addFavoriteShow = (showId) => (0, request_1.request)({ show_id: String(showId) }, 'show.addFavorite');
+exports.addFavoriteShow = addFavoriteShow;
+// ─── Playlist contents ───────────────────────────────────────────────────────
+/**
+ * Create a playlist (`playlist.create`). Resolves to the new `PLAYLIST_ID`.
+ *
+ * **One-way.** The gateway has no delete counterpart (see the module note), so
+ * anything created here has to be removed from a Deezer client. For the same
+ * reason this is the one function on this page that has not been exercised
+ * against a live account.
+ *
+ * @param title       playlist title
+ * @param options     `description`, `status` (0 public / 1 private / 2 collaborative),
+ *                    and `songs` to seed it with `SNG_ID`s
+ */
+const createPlaylist = (title, options = {}) => {
+    var _a, _b, _c;
+    return (0, request_1.request)({
+        title,
+        description: (_a = options.description) !== null && _a !== void 0 ? _a : '',
+        status: (_b = options.status) !== null && _b !== void 0 ? _b : 1,
+        songs: ((_c = options.songs) !== null && _c !== void 0 ? _c : []).map((id) => [String(id), 0]),
+    }, 'playlist.create');
+};
+exports.createPlaylist = createPlaylist;
+/**
+ * Append tracks to a playlist (`playlist.addSongs`). Reversible with
+ * {@link removeTracksFromPlaylist}.
+ *
+ * The gateway takes `songs` as `[[sngId, offset], …]`; this wraps that for you.
+ */
+const addTracksToPlaylist = (playlistId, sngIds) => (0, request_1.request)({ playlist_id: String(playlistId), songs: sngIds.map((id) => [String(id), 0]) }, 'playlist.addSongs');
+exports.addTracksToPlaylist = addTracksToPlaylist;
+/** Remove tracks from a playlist (`playlist.deleteSongs`). */
+const removeTracksFromPlaylist = (playlistId, sngIds) => (0, request_1.request)({ playlist_id: String(playlistId), songs: sngIds.map((id) => [String(id), 0]) }, 'playlist.deleteSongs');
+exports.removeTracksFromPlaylist = removeTracksFromPlaylist;

package/dist/api/index.d.ts

@@ -5,3 +5,5 @@ export * from './browse';
 export * from './preview';
 export * from './user';
 export * from './podcast';
+export * from './library';
+export * from './favorites';

package/dist/api/index.js

@@ -21,3 +21,5 @@ __exportStar(require("./browse"), exports);
 __exportStar(require("./preview"), exports);
 __exportStar(require("./user"), exports);
 __exportStar(require("./podcast"), exports);
+__exportStar(require("./library"), exports);
+__exportStar(require("./favorites"), exports);

package/dist/api/library.d.ts

@@ -0,0 +1,72 @@
+import type { playlistInfoMinimal, trackType } from '../types';
+/** Envelope the gateway wraps these listings in. */
+export interface GwList<T> {
+    data: T[];
+    count: number;
+    total: number;
+    filtered_count?: number;
+    checksum?: string;
+}
+/** A favourited artist, as the library returns it. */
+export interface FavoriteArtist {
+    ART_ID: string;
+    ART_NAME: string;
+    ART_PICTURE: string;
+    /** when it was favourited — `YYYY-MM-DD HH:MM:SS` */
+    DATE_ADD?: string;
+    NB_ALBUM?: number;
+    NB_FAN?: number;
+    ARTIST_IS_DUMMY?: boolean;
+    __TYPE__?: string;
+}
+/** A favourited album, as the library returns it. */
+export interface FavoriteAlbum {
+    ALB_ID: string;
+    ALB_TITLE: string;
+    ALB_PICTURE: string;
+    ART_ID?: string;
+    ART_NAME?: string;
+    DATE_ADD?: string;
+    NUMBER_TRACK?: number;
+    PHYSICAL_RELEASE_DATE?: string;
+    __TYPE__?: string;
+}
+/**
+ * The account's own playlists (`playlist.getList`) — **including private ones**,
+ * which the public `/user/{id}/playlists` endpoint will not show you.
+ *
+ * @param userId defaults to the logged-in account
+ */
+export declare const getMyPlaylists: (userId?: string | number, nb?: number, start?: number) => Promise<GwList<playlistInfoMinimal>>;
+/**
+ * Loved tracks (`song.getFavorites`). Gateway track objects, so each carries a
+ * `TRACK_TOKEN` and can go straight to `resolveDownloadUrls`.
+ */
+export declare const getMyFavoriteTracks: (userId?: string | number, nb?: number, start?: number) => Promise<GwList<trackType>>;
+/**
+ * Just the ids of every loved track (`song.getFavoriteIds`) — one small request
+ * for the whole set, for diffing a local library against the account.
+ */
+export declare const getMyFavoriteTrackIds: () => Promise<GwList<{
+    SNG_ID: string;
+}>>;
+/** Favourited albums (`album.getFavorites`). */
+export declare const getMyFavoriteAlbums: (userId?: string | number, nb?: number, start?: number) => Promise<GwList<FavoriteAlbum>>;
+/** Favourited artists (`artist.getFavorites`). */
+export declare const getMyFavoriteArtists: (userId?: string | number, nb?: number, start?: number) => Promise<GwList<FavoriteArtist>>;
+/** Playlists the account follows (`playlist.getFavorites`). */
+export declare const getMyFavoritePlaylists: (userId?: string | number, nb?: number, start?: number) => Promise<GwList<playlistInfoMinimal>>;
+/** Favourited radios (`radio.getFavorites`). */
+export declare const getMyFavoriteRadios: (userId?: string | number, nb?: number, start?: number) => Promise<GwList<Record<string, any>>>;
+/** Favourited podcast shows (`show.getFavorites`). */
+export declare const getMyFavoriteShows: (userId?: string | number, nb?: number, start?: number) => Promise<GwList<Record<string, any>>>;
+/**
+ * A "more like this" mix seeded from one track (`song.getSearchTrackMix`).
+ *
+ * Returns full gateway tracks **with `TRACK_TOKEN`s**, so unlike the public
+ * radio endpoints the results are immediately downloadable — no `getTrackInfo`
+ * round trip per hit.
+ *
+ * @param sngId the seed track's `SNG_ID`
+ */
+export declare const getTrackMix: (sngId: string, nb?: number, start?: number) => Promise<GwList<trackType>>;

package/dist/api/library.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTrackMix = exports.getMyFavoriteShows = exports.getMyFavoriteRadios = exports.getMyFavoritePlaylists = exports.getMyFavoriteArtists = exports.getMyFavoriteAlbums = exports.getMyFavoriteTrackIds = exports.getMyFavoriteTracks = exports.getMyPlaylists = void 0;
+/**
+ * The **logged-in account's own library**, over the authenticated gateway.
+ *
+ * This is not the same surface as `src/api/user.ts`. Those functions read the
+ * *public* REST profile (`/user/{id}/tracks` …), which needs the profile to be
+ * public and shows only what that profile exposes. These read what the account
+ * itself can see — including a private library — and return gateway shapes, so
+ * tracks arrive with a `TRACK_TOKEN` and are directly downloadable.
+ *
+ * Every response here is account-scoped, so it lives in the per-session cache
+ * and is never shared between sessions.
+ */
+const request_1 = require("./request");
+const api_1 = require("./api");
+/** Resolve the caller's own user id when one wasn't supplied. */
+const ownUserId = async (userId) => userId !== undefined ? String(userId) : String((await (0, api_1.getUser)()).USER_ID);
+/**
+ * The account's own playlists (`playlist.getList`) — **including private ones**,
+ * which the public `/user/{id}/playlists` endpoint will not show you.
+ *
+ * @param userId defaults to the logged-in account
+ */
+const getMyPlaylists = async (userId, nb = 50, start = 0) => (0, request_1.request)({ user_id: await ownUserId(userId), nb, start, tab: 'all' }, 'playlist.getList');
+exports.getMyPlaylists = getMyPlaylists;
+/**
+ * Loved tracks (`song.getFavorites`). Gateway track objects, so each carries a
+ * `TRACK_TOKEN` and can go straight to `resolveDownloadUrls`.
+ */
+const getMyFavoriteTracks = async (userId, nb = 50, start = 0) => (0, request_1.request)({ user_id: await ownUserId(userId), nb, start }, 'song.getFavorites');
+exports.getMyFavoriteTracks = getMyFavoriteTracks;
+/**
+ * Just the ids of every loved track (`song.getFavoriteIds`) — one small request
+ * for the whole set, for diffing a local library against the account.
+ */
+const getMyFavoriteTrackIds = () => (0, request_1.request)({}, 'song.getFavoriteIds');
+exports.getMyFavoriteTrackIds = getMyFavoriteTrackIds;
+/** Favourited albums (`album.getFavorites`). */
+const getMyFavoriteAlbums = async (userId, nb = 50, start = 0) => (0, request_1.request)({ user_id: await ownUserId(userId), nb, start }, 'album.getFavorites');
+exports.getMyFavoriteAlbums = getMyFavoriteAlbums;
+/** Favourited artists (`artist.getFavorites`). */
+const getMyFavoriteArtists = async (userId, nb = 50, start = 0) => (0, request_1.request)({ user_id: await ownUserId(userId), nb, start }, 'artist.getFavorites');
+exports.getMyFavoriteArtists = getMyFavoriteArtists;
+/** Playlists the account follows (`playlist.getFavorites`). */
+const getMyFavoritePlaylists = async (userId, nb = 50, start = 0) => (0, request_1.request)({ user_id: await ownUserId(userId), nb, start }, 'playlist.getFavorites');
+exports.getMyFavoritePlaylists = getMyFavoritePlaylists;
+/** Favourited radios (`radio.getFavorites`). */
+const getMyFavoriteRadios = async (userId, nb = 50, start = 0) => (0, request_1.request)({ user_id: await ownUserId(userId), nb, start }, 'radio.getFavorites');
+exports.getMyFavoriteRadios = getMyFavoriteRadios;
+/** Favourited podcast shows (`show.getFavorites`). */
+const getMyFavoriteShows = async (userId, nb = 50, start = 0) => (0, request_1.request)({ user_id: await ownUserId(userId), nb, start }, 'show.getFavorites');
+exports.getMyFavoriteShows = getMyFavoriteShows;
+/**
+ * A "more like this" mix seeded from one track (`song.getSearchTrackMix`).
+ *
+ * Returns full gateway tracks **with `TRACK_TOKEN`s**, so unlike the public
+ * radio endpoints the results are immediately downloadable — no `getTrackInfo`
+ * round trip per hit.
+ *
+ * @param sngId the seed track's `SNG_ID`
+ */
+const getTrackMix = (sngId, nb = 40, start = 0) => (0, request_1.request)({ sng_id: sngId, start, nb }, 'song.getSearchTrackMix');
+exports.getTrackMix = getTrackMix;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gerdur-core",
-  "version": "2.16.0",
+  "version": "2.18.0",
   "description": "Deezer API client, cross-service URL resolution, Blowfish track decryption and MP3/FLAC metadata tagging — the engine behind the gerdur CLI.",
   "keywords": [
     "deezer",