gerdur-core 2.8.0 → 2.10.0

package/CHANGELOG.md

@@ -1,5 +1,35 @@
 # Changelog
 
+## 2.10.0 - 2026-08-31
+
+Leftovers — batch token refresh + podcast episodes. Additive.
+
+### Added
+
+- **`refreshTrackTokens(tracks, {graceSeconds?, session?})`** — one
+  `song.getListData` request refreshes every `TRACK_TOKEN` that has expired (or
+  is about to). Run a long playlist through this before `resolveDownloadUrls` so
+  it doesn't die on stale tokens at track 40. Also `session.refreshTrackTokens`.
+- **`getEpisode(episodeId)`** (`episode.getData`) and **`getShowEpisodes(showId,
+  nb?, start?)`** — podcast episodes; `EPISODE_DIRECT_STREAM_URL` is a plain MP3
+  (no licence, no decryption).
+
+## 2.9.0 - 2026-08-31
+
+Phase 3.2 (cont.) — downloads are session-aware. Additive.
+
+### Added
+
+- **`Session.getTrackDownloadUrl` / `resolveDownloadUrls` / `streamTrack` /
+  `getTrackBuffer`** — resolve and download **as a specific account**, so a
+  `createSession(arl)` client is now end-to-end usable.
+- **`downloadTrackBuffer(track, quality, options?)`** — download + decrypt a
+  track fully into a `Buffer` (no tagging), free-function form of
+  `session.getTrackBuffer`.
+- `getTrackDownloadUrl(track, quality, session?)`, `resolveDownloadUrls(tracks,
+  qualities?, session?)` and `streamTrackDownload(track, quality, {session})`
+  gained an optional session argument (defaults to the process default).
+
 ## 2.8.0 - 2026-08-31
 
 Phase 3.2 (cont.) — a `Session` is now usable per-account. Additive; free

package/README.md

@@ -127,9 +127,18 @@ responses carry account-specific `TRACK_TOKEN`s) and its own query methods:
 | `getArtistInfo(id)` / `getDiscography(id, nb?)` | artist metadata / discography |
 | `getProfile(userId)` | a public profile |
 | `searchMusic(query, types?, nb?)` | search (`deezer.pageSearch`) |
+| `getTrackDownloadUrl(track, quality)` | resolve a CDN URL **as this account** |
+| `resolveDownloadUrls(tracks, qualities?)` | batch-resolve, one request, as this account |
+| `streamTrack(track, quality, opts?)` | constant-memory stream of decrypted audio |
+| `getTrackBuffer(track, quality, opts?)` | download + decrypt fully into a `Buffer` |
 | `gw(body, method)` / `gwLight(body, method)` / `gwGet(method, params?)` | the raw coalesced request channels |
 | `init(arl?)` / `refreshApiToken()` / `loadUserData(force?)` / `invalidateUserData()` | lifecycle |
 
+The free `getTrackDownloadUrl(track, quality, session?)` / `resolveDownloadUrls(…, session?)`
+/ `streamTrackDownload(…, {session})` all take an optional session too;
+`downloadTrackBuffer(track, quality, opts?)` is the free-function form of
+`session.getTrackBuffer`.
+
 ```js
 await initDeezerApi(arl);                 // default session, as before
 const track = await getTrackInfo('3135556');
@@ -312,6 +321,13 @@ const {data: loved} = await getUserFavoriteTracks(me.USER_ID);
 const {data: eighties} = await getRadioTracks(38305);     // "The '80s"
 ```
 
+### Podcasts
+
+| Method | |
+| :--- | :--- |
+| `getShowEpisodes(showId, nb = 25, start = 0)` | a page of a show's episodes, newest first |
+| `getEpisode(episodeId)` | one episode — `EPISODE_DIRECT_STREAM_URL` is a plain MP3, no licence / decryption |
+
 ### `.getTrackDownloadUrl(track, quality);`
 
 | Parameters | Required |        Type |                        Description |
@@ -322,6 +338,19 @@ const {data: eighties} = await getRadioTracks(38305);     // "The '80s"
 Resolves `{trackUrl, isEncrypted, fileSize}`. `isEncrypted` now comes from the
 media API's `cipher` field (authoritative) rather than a URL guess.
 
+### `.refreshTrackTokens(tracks, options?);`
+
+`TRACK_TOKEN`s live ~1 hour, so a token fetched at the start of a long playlist
+download is dead by track 40 (surfacing as an opaque CDN 403). Run the selection
+through this first — **one** `song.getListData` request refreshes every token
+that has expired (or expires within `options.graceSeconds`, default 300).
+Tracks with a still-valid token come back untouched. Also `session.refreshTrackTokens(tracks, graceSeconds?)`.
+
+```js
+const fresh = await refreshTrackTokens(playlist.tracks);
+const urls = await resolveDownloadUrls(fresh, [9, 3, 1]);
+```
+
 ### Formats
 
 Deezer's `get_url` understands more than `1 / 3 / 9`. `DEEZER_FORMATS` lists them

package/dist/api/index.d.ts

@@ -4,3 +4,4 @@ export * from './search';
 export * from './browse';
 export * from './preview';
 export * from './user';
+export * from './podcast';

package/dist/api/index.js

@@ -20,3 +20,4 @@ __exportStar(require("./search"), exports);
 __exportStar(require("./browse"), exports);
 __exportStar(require("./preview"), exports);
 __exportStar(require("./user"), exports);
+__exportStar(require("./podcast"), exports);

package/dist/api/podcast.d.ts

@@ -0,0 +1,16 @@
+import type { publicApiList, showEpisodeType } from '../types';
+/**
+ * One podcast episode (`episode.getData`). Carries `EPISODE_DIRECT_STREAM_URL`
+ * (a plain MP3 — no licence, no decryption) plus `MD5_ORIGIN` / `FILESIZE_MP3_*`
+ * / `TRACK_TOKEN` for the licensed stream.
+ */
+export declare const getEpisode: (episodeId: string) => Promise<showEpisodeType>;
+/**
+ * A page of a show's episodes, newest first — a thin view over `getShowInfo`'s
+ * `EPISODES` block.
+ *
+ * @param showId `SHOW_ID`
+ * @param nb     page size (default 25)
+ * @param start  offset
+ */
+export declare const getShowEpisodes: (showId: string, nb?: number, start?: number) => Promise<publicApiList<showEpisodeType>>;

package/dist/api/podcast.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getShowEpisodes = exports.getEpisode = void 0;
+const request_1 = require("./request");
+const api_1 = require("./api");
+/**
+ * One podcast episode (`episode.getData`). Carries `EPISODE_DIRECT_STREAM_URL`
+ * (a plain MP3 — no licence, no decryption) plus `MD5_ORIGIN` / `FILESIZE_MP3_*`
+ * / `TRACK_TOKEN` for the licensed stream.
+ */
+const getEpisode = (episodeId) => (0, request_1.request)({ episode_id: episodeId }, 'episode.getData');
+exports.getEpisode = getEpisode;
+/**
+ * A page of a show's episodes, newest first — a thin view over `getShowInfo`'s
+ * `EPISODES` block.
+ *
+ * @param showId `SHOW_ID`
+ * @param nb     page size (default 25)
+ * @param start  offset
+ */
+const getShowEpisodes = async (showId, nb = 25, start = 0) => {
+    const { EPISODES } = await (0, api_1.getShowInfo)(showId, nb, start);
+    return { data: EPISODES.data, total: EPISODES.total };
+};
+exports.getShowEpisodes = getShowEpisodes;

package/dist/index.d.ts

@@ -1,3 +1,4 @@
+import './lib/session-augment';
 export { initDeezerApi, createSession, defaultSession, Session, RETRY_POLICY, DEFAULT_ARL } from './lib/session';
 export type { SessionUserData } from './lib/session';
 export { DeezerError } from './lib/errors';

package/dist/index.js

@@ -15,6 +15,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getStream = exports.getText = exports.getJson = exports.getBuffer = exports.httpsAgent = exports.httpAgent = exports.DeezerError = exports.DEFAULT_ARL = exports.RETRY_POLICY = exports.Session = exports.defaultSession = exports.createSession = exports.initDeezerApi = void 0;
+require("./lib/session-augment"); // wires the download methods onto Session.prototype
 var session_1 = require("./lib/session");
 Object.defineProperty(exports, "initDeezerApi", { enumerable: true, get: function () { return session_1.initDeezerApi; } });
 Object.defineProperty(exports, "createSession", { enumerable: true, get: function () { return session_1.createSession; } });

package/dist/lib/get-url.d.ts

@@ -1,3 +1,4 @@
+import { Session } from '../lib/session';
 import type { trackType } from '../types';
 export declare class WrongLicense extends Error {
     constructor(format: string);
@@ -34,8 +35,9 @@ export declare const formatName: (quality: Quality) => string;
 /**
  * @param track Track info json returned from `getTrackInfo`
  * @param quality 1 = 128kbps, 3 = 320kbps and 9 = flac (around 1411kbps)
+ * @param session which account to resolve for — defaults to the process default
  */
-export declare const getTrackDownloadUrl: (track: trackType, quality: number) => Promise<{
+export declare const getTrackDownloadUrl: (track: trackType, quality: number, session?: Session) => Promise<{
     trackUrl: string;
     isEncrypted: boolean;
     fileSize: number;
@@ -60,5 +62,24 @@ export interface ResolvedUrl {
  *
  * @param tracks    from `getTrackInfo` / `parseInfo` (needs `TRACK_TOKEN`, `SNG_ID`, `FILESIZE_*`)
  * @param qualities preference order — default `[9, 3, 1]` (FLAC → MP3 320 → MP3 128)
+ * @param session   which account to resolve for — defaults to the process default
  */
-export declare const resolveDownloadUrls: (tracks: trackType[], qualities?: Quality[]) => Promise<(ResolvedUrl | null)[]>;
+export declare const resolveDownloadUrls: (tracks: trackType[], qualities?: Quality[], session?: Session) => Promise<(ResolvedUrl | null)[]>;
+/**
+ * Batch-refresh `TRACK_TOKEN`s that have (or are about to) expire — one
+ * `song.getListData` request for the lot, instead of a `getTrackInfo` per track.
+ * `TRACK_TOKEN`s live ~1 hour, so a token fetched at the start of a long
+ * playlist download is dead by track 40 and surfaces as an opaque CDN 403; run
+ * the selection through this first.
+ *
+ * Returns the input tracks with fresh `TRACK_TOKEN` / `TRACK_TOKEN_EXPIRE`
+ * merged in; tracks whose token is still comfortably valid are returned as-is.
+ *
+ * @param tracks  from `getTrackInfo` / `getAlbumTracks` / `parseInfo`
+ * @param options `graceSeconds` — treat a token expiring within this window as
+ *   stale (default 300); `session` — which account (default: process default)
+ */
+export declare const refreshTrackTokens: (tracks: trackType[], options?: {
+    graceSeconds?: number;
+    session?: Session;
+}) => Promise<trackType[]>;

package/dist/lib/get-url.js

@@ -3,12 +3,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveDownloadUrls = exports.getTrackDownloadUrl = exports.formatName = exports.toFormat = exports.DEEZER_FORMATS = exports.ExpiredTrackToken = exports.GeoBlocked = exports.WrongLicense = void 0;
+exports.refreshTrackTokens = exports.resolveDownloadUrls = exports.getTrackDownloadUrl = exports.formatName = exports.toFormat = exports.DEEZER_FORMATS = exports.ExpiredTrackToken = exports.GeoBlocked = exports.WrongLicense = void 0;
 const delay_1 = __importDefault(require("delay"));
 const decrypt_1 = require("../lib/decrypt");
 const errors_1 = require("../lib/errors");
 const http_1 = require("../lib/http");
-const request_1 = __importDefault(require("../lib/request"));
 const session_1 = require("../lib/session");
 class WrongLicense extends Error {
     constructor(format) {
@@ -92,11 +91,11 @@ const MEDIA_MAX_RETRIES = 3;
 const formatName = (quality) => (0, exports.toFormat)(quality);
 exports.formatName = formatName;
 /** POST media.deezer.com/v1/get_url with re-auth + exponential-backoff retry on 403/429/5xx. */
-const mediaGetUrl = async (track_tokens, formats, attempt = 0) => {
+const mediaGetUrl = async (session, track_tokens, formats, attempt = 0) => {
     var _a;
-    const user = await (0, session_1.defaultSession)().loadUserData();
+    const user = await session.loadUserData();
     try {
-        const { data } = await request_1.default.post('https://media.deezer.com/v1/get_url', {
+        const { data } = await session.request('POST', 'https://media.deezer.com/v1/get_url', {
             license_token: user.licenseToken,
             media: [{ type: 'FULL', formats }],
             track_tokens,
@@ -107,9 +106,9 @@ const mediaGetUrl = async (track_tokens, formats, attempt = 0) => {
         const status = err instanceof http_1.HttpStatusError ? err.statusCode : 0;
         if ((status === 403 || status === 429 || status >= 500) && attempt < MEDIA_MAX_RETRIES) {
             // a stale license token is a common cause — force a refresh before the retry
-            await (0, session_1.defaultSession)().loadUserData(true);
+            await session.loadUserData(true);
             await (0, delay_1.default)(500 * 2 ** attempt + Math.floor(Math.random() * 250));
-            return mediaGetUrl(track_tokens, formats, attempt + 1);
+            return mediaGetUrl(session, track_tokens, formats, attempt + 1);
         }
         throw err;
     }
@@ -132,12 +131,12 @@ const parseMediaEntry = (entry, token, country) => {
 };
 /** Whether a track fetched with the given cipher needs Blowfish stripe decryption. */
 const cipherIsEncrypted = (cipher, url) => cipher ? cipher !== 'NONE' : url.includes('/mobile/') || url.includes('/media/');
-const getTrackUrlFromServer = async (track_token, format) => {
-    const user = await (0, session_1.defaultSession)().loadUserData();
+const getTrackUrlFromServer = async (session, track_token, format) => {
+    const user = await session.loadUserData();
     if ((format === 'FLAC' && !user.canStreamLossless) || (format === 'MP3_320' && !user.canStreamHq)) {
         throw new WrongLicense(format);
     }
-    const { data, country } = await mediaGetUrl([track_token], [{ format, cipher: 'BF_CBC_STRIPE' }]);
+    const { data, country } = await mediaGetUrl(session, [track_token], [{ format, cipher: 'BF_CBC_STRIPE' }]);
     if (!data.length)
         return null;
     return parseMediaEntry(data[0], track_token, country);
@@ -145,8 +144,9 @@ const getTrackUrlFromServer = async (track_token, format) => {
 /**
  * @param track Track info json returned from `getTrackInfo`
  * @param quality 1 = 128kbps, 3 = 320kbps and 9 = flac (around 1411kbps)
+ * @param session which account to resolve for — defaults to the process default
  */
-const getTrackDownloadUrl = async (track, quality) => {
+const getTrackDownloadUrl = async (track, quality, session = (0, session_1.defaultSession)()) => {
     let wrongLicense = null;
     let geoBlocked = null;
     let expiredToken = null;
@@ -161,7 +161,7 @@ const getTrackDownloadUrl = async (track, quality) => {
     else {
         // Get URL with the official API
         try {
-            const resolved = await getTrackUrlFromServer(track.TRACK_TOKEN, format);
+            const resolved = await getTrackUrlFromServer(session, track.TRACK_TOKEN, format);
             if (resolved) {
                 return {
                     trackUrl: resolved.url,
@@ -237,12 +237,13 @@ const testUrl = async (url) => {
  *
  * @param tracks    from `getTrackInfo` / `parseInfo` (needs `TRACK_TOKEN`, `SNG_ID`, `FILESIZE_*`)
  * @param qualities preference order — default `[9, 3, 1]` (FLAC → MP3 320 → MP3 128)
+ * @param session   which account to resolve for — defaults to the process default
  */
-const resolveDownloadUrls = async (tracks, qualities = [9, 3, 1]) => {
+const resolveDownloadUrls = async (tracks, qualities = [9, 3, 1], session = (0, session_1.defaultSession)()) => {
     if (!tracks.length)
         return [];
     const formats = qualities.map((q) => ({ format: (0, exports.formatName)(q), cipher: 'BF_CBC_STRIPE' }));
-    const { data, country } = await mediaGetUrl(tracks.map((t) => t.TRACK_TOKEN), formats);
+    const { data, country } = await mediaGetUrl(session, tracks.map((t) => t.TRACK_TOKEN), formats);
     return tracks.map((track, i) => {
         let parsed;
         try {
@@ -264,3 +265,35 @@ const resolveDownloadUrls = async (tracks, qualities = [9, 3, 1]) => {
     });
 };
 exports.resolveDownloadUrls = resolveDownloadUrls;
+/**
+ * Batch-refresh `TRACK_TOKEN`s that have (or are about to) expire — one
+ * `song.getListData` request for the lot, instead of a `getTrackInfo` per track.
+ * `TRACK_TOKEN`s live ~1 hour, so a token fetched at the start of a long
+ * playlist download is dead by track 40 and surfaces as an opaque CDN 403; run
+ * the selection through this first.
+ *
+ * Returns the input tracks with fresh `TRACK_TOKEN` / `TRACK_TOKEN_EXPIRE`
+ * merged in; tracks whose token is still comfortably valid are returned as-is.
+ *
+ * @param tracks  from `getTrackInfo` / `getAlbumTracks` / `parseInfo`
+ * @param options `graceSeconds` — treat a token expiring within this window as
+ *   stale (default 300); `session` — which account (default: process default)
+ */
+const refreshTrackTokens = async (tracks, options = {}) => {
+    var _a, _b;
+    const session = (_a = options.session) !== null && _a !== void 0 ? _a : (0, session_1.defaultSession)();
+    const graceMs = ((_b = options.graceSeconds) !== null && _b !== void 0 ? _b : 300) * 1000;
+    const now = Date.now();
+    const staleIds = new Set(tracks
+        .filter((t) => !t.TRACK_TOKEN || !t.TRACK_TOKEN_EXPIRE || t.TRACK_TOKEN_EXPIRE * 1000 - now < graceMs)
+        .map((t) => t.SNG_ID));
+    if (!staleIds.size)
+        return tracks;
+    const { data } = await session.gw({ sng_ids: [...staleIds] }, 'song.getListData');
+    const fresh = new Map(data.map((d) => [d.SNG_ID, d]));
+    return tracks.map((track) => {
+        const f = fresh.get(track.SNG_ID);
+        return f ? { ...track, TRACK_TOKEN: f.TRACK_TOKEN, TRACK_TOKEN_EXPIRE: Number(f.TRACK_TOKEN_EXPIRE) } : track;
+    });
+};
+exports.refreshTrackTokens = refreshTrackTokens;

package/dist/lib/session-augment.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="node" />
+import type { Quality, ResolvedUrl } from './get-url';
+import type { StreamTrackOptions, TrackStream } from './stream-download';
+import type { trackType } from '../types';
+declare module './session' {
+    interface Session {
+        /** Resolve a downloadable URL for a track **as this account** (`1 | 3 | 9`). */
+        getTrackDownloadUrl(track: trackType, quality: number): Promise<{
+            trackUrl: string;
+            isEncrypted: boolean;
+            fileSize: number;
+        } | null>;
+        /** Batch-resolve download URLs for many tracks in one request, as this account. */
+        resolveDownloadUrls(tracks: trackType[], qualities?: Quality[]): Promise<(ResolvedUrl | null)[]>;
+        /** Download a track as a constant-memory stream of decrypted audio, as this account. */
+        streamTrack(track: trackType, quality: number, options?: Omit<StreamTrackOptions, 'session'>): Promise<TrackStream>;
+        /** Download + decrypt a track fully into a `Buffer`, as this account. */
+        getTrackBuffer(track: trackType, quality: number, options?: Omit<StreamTrackOptions, 'session' | 'resumeFrom'>): Promise<Buffer | null>;
+        /** Batch-refresh the `TRACK_TOKEN`s on these tracks (as this account) before a long download. */
+        refreshTrackTokens(tracks: trackType[], graceSeconds?: number): Promise<trackType[]>;
+    }
+}

package/dist/lib/session-augment.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Download methods on {@link Session}, kept in a separate module so `session.ts`
+ * doesn't have to import the download stack (which imports `session.ts` back).
+ * `import`ing this file for its side effect wires the methods onto the prototype;
+ * `src/index.ts` does that.
+ */
+const get_url_1 = require("./get-url");
+const session_1 = require("./session");
+const stream_download_1 = require("./stream-download");
+session_1.Session.prototype.getTrackDownloadUrl = function (track, quality) {
+    return (0, get_url_1.getTrackDownloadUrl)(track, quality, this);
+};
+session_1.Session.prototype.resolveDownloadUrls = function (tracks, qualities) {
+    return (0, get_url_1.resolveDownloadUrls)(tracks, qualities, this);
+};
+session_1.Session.prototype.streamTrack = function (track, quality, options = {}) {
+    return (0, stream_download_1.streamTrackDownload)(track, quality, { ...options, session: this });
+};
+session_1.Session.prototype.getTrackBuffer = function (track, quality, options = {}) {
+    return (0, stream_download_1.downloadTrackBuffer)(track, quality, { ...options, session: this });
+};
+session_1.Session.prototype.refreshTrackTokens = function (tracks, graceSeconds) {
+    return (0, get_url_1.refreshTrackTokens)(tracks, { graceSeconds, session: this });
+};

package/dist/lib/stream-download.d.ts

@@ -1,5 +1,7 @@
 /// <reference types="node" />
+/// <reference types="node" />
 import { Readable } from 'stream';
+import type { Session } from './session';
 import type { trackType } from '../types';
 export interface StreamTrackOptions {
     /**
@@ -10,6 +12,8 @@ export interface StreamTrackOptions {
     resumeFrom?: number;
     /** progress callback — `(bytesReceived, totalBytes)`; `total` is 0 when unknown */
     onProgress?: (received: number, total: number) => void;
+    /** which account to download as — defaults to the process default session */
+    session?: Session;
 }
 export interface TrackStream {
     /** decrypted audio bytes, ready to pipe to a file or a tag muxer */
@@ -35,3 +39,10 @@ export interface TrackStream {
  *   track+quality can't be resolved at all.
  */
 export declare const streamTrackDownload: (track: trackType, quality: number, options?: StreamTrackOptions) => Promise<TrackStream>;
+/**
+ * Download + decrypt a track fully into memory. Convenience over
+ * {@link streamTrackDownload} for callers that just want the bytes (no tagging —
+ * pipe through `addTrackTags` yourself). `null` when the track+quality can't be
+ * resolved. Does **not** support resume.
+ */
+export declare const downloadTrackBuffer: (track: trackType, quality: number, options?: Omit<StreamTrackOptions, 'resumeFrom'>) => Promise<Buffer | null>;

package/dist/lib/stream-download.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.streamTrackDownload = void 0;
+exports.downloadTrackBuffer = exports.streamTrackDownload = void 0;
 const stream_1 = require("stream");
 const decrypt_1 = require("./decrypt");
 const http_1 = require("./http");
@@ -20,7 +20,7 @@ const CHUNK = 2048;
  *   track+quality can't be resolved at all.
  */
 const streamTrackDownload = async (track, quality, options = {}) => {
-    const resolved = await (0, get_url_1.getTrackDownloadUrl)(track, quality);
+    const resolved = await (0, get_url_1.getTrackDownloadUrl)(track, quality, options.session);
     if (!resolved) {
         throw new Error(`Track ${track.SNG_ID} is unavailable at quality ${quality}`);
     }
@@ -52,3 +52,27 @@ const streamTrackDownload = async (track, quality, options = {}) => {
     };
 };
 exports.streamTrackDownload = streamTrackDownload;
+/**
+ * Download + decrypt a track fully into memory. Convenience over
+ * {@link streamTrackDownload} for callers that just want the bytes (no tagging —
+ * pipe through `addTrackTags` yourself). `null` when the track+quality can't be
+ * resolved. Does **not** support resume.
+ */
+const downloadTrackBuffer = async (track, quality, options = {}) => {
+    let ts;
+    try {
+        ts = await (0, exports.streamTrackDownload)(track, quality, { onProgress: options.onProgress, session: options.session });
+    }
+    catch (err) {
+        if (err instanceof Error && /unavailable at quality/.test(err.message)) {
+            return null;
+        }
+        throw err;
+    }
+    const chunks = [];
+    for await (const chunk of ts.stream) {
+        chunks.push(chunk);
+    }
+    return Buffer.concat(chunks);
+};
+exports.downloadTrackBuffer = downloadTrackBuffer;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gerdur-core",
-  "version": "2.8.0",
+  "version": "2.10.0",
   "description": "Core module for gerdur.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",