gerdur-core 2.13.3 → 2.15.0

package/CHANGELOG.md

@@ -1,5 +1,77 @@
 # Changelog
 
+## 2.15.0 - 2026-08-31
+
+Streaming tag write — tagging no longer holds the audio.
+
+### Added
+
+- **`createTagStream(model, options?)`** — a `Transform` that rewrites a track's
+  tags as bytes flow through it. `addTrackTags` has to materialise the whole
+  file (`browser-id3-writer` allocates `audio.length + tag` and copies the audio
+  in, plus another copy to strip an existing ID3v2; the FLAC path concatenates
+  the same way), which is what caps concurrency on a server and what cancelled
+  `streamTrackDownload`'s constant-memory guarantee at the last step.
+
+  Both containers keep their metadata at the front, so none of that copying is
+  needed: MP3 emits a fresh ID3v2 and discards exactly the old tag's bytes as
+  they pass; FLAC buffers only the metadata block chain and passes the frames
+  through untouched. Peak memory is O(metadata), not O(file).
+
+  Measured, 40 MB tracks: **4 concurrent 239 MB -> 0 MB; 16 concurrent 965 MB ->
+  0 MB, and 6.5x faster** (986 ms -> 150 ms) from skipping the copies. Output is
+  byte-identical to `addTrackTags` — the tag bytes come from the same writers,
+  called with an empty / truncated source so they emit only the header.
+- **`resolveTagModel(track, options?)`** — the metadata resolution half of
+  `addTrackTags` (album, lyrics, cover, artist image, credits, BPM) without
+  touching audio, so a streaming caller can get a model to hand to
+  `createTagStream`. Same options, same coalescing. `addTrackTags` is now a thin
+  wrapper over it — no behaviour change.
+- **`probeAudioOffset(buffer)`** — where the audio starts in a source and which
+  container it is; exported for callers doing their own muxing.
+- `__tests__/tag-stream.ts` — byte-identical output asserted across chunk sizes
+  from 1 byte to whole-file, for MP3 and FLAC, with and without a pre-existing
+  tag.
+
+### Changed
+
+- README: streaming tag write documented under **Tag MP3 / FLAC** and in
+  **Running this on a server**.
+
+## 2.14.0 - 2026-08-31
+
+Multi-tenant caching — for backends where many accounts share one process.
+
+### Added
+
+- **Shared gateway metadata cache.** Most gw payloads embed a per-account
+  `TRACK_TOKEN`, so each `Session` keeps its own cache. Five methods carry
+  nothing account-scoped — `album.getData`, `artist.getData`, `song.getLyrics`,
+  `album.getDiscography`, `playlist.getData` — and now go to a process-wide cache
+  **partitioned by country**, with a shared in-flight map so a concurrent burst
+  collapses into one request. Measured with 500 sessions reading the same album:
+  **500 gateway requests → 1**, and 1.8 MB of duplicated payload → one copy.
+  Track-bearing methods (`song.getData`, `playlist.getSongs`,
+  `song.getListByAlbum`, `song.getListData`, `episode.getData`, `mobile.*`,
+  `deezer.pageSearch`, `user_getInfo`, …) are never shared.
+- **`configureCache({shared: {maxSize, ttl}})`** — size the shared cache to your
+  catalogue. Default `{maxSize: 2000, ttl: 3_600_000}`.
+- **`cacheStats()`** → `{shared: {size, maxSize, hits, misses, inFlight}}` — for
+  a `/metrics` or health endpoint.
+- **`clearSharedCaches()`** — drops the shared cache; per-session caches are
+  untouched.
+- `__tests__/caches.ts` — offline tests pinning the isolation guarantees: no
+  cross-account token reuse, no cross-country bleed, in-flight entries released.
+- README: a **Running this on a server** section (stream don't buffer, decrypt is
+  on the event loop, size the cache, evict idle sessions).
+
+### Not done, deliberately
+
+- Memoising the initialised Blowfish key schedule per track was implemented,
+  measured and **reverted**: key setup is 39.7 µs against 33 ms to decrypt an
+  8 MiB file — **0.12%**, with break-even at ~10 KiB decrypted per key. Not worth
+  a cache or the public knob it would need.
+
 ## 2.13.3 - 2026-08-31
 
 ### Docs

package/README.md

@@ -55,6 +55,7 @@ the CLI and the file-writing layer on top.
   - [Tag MP3 / FLAC](#tag-mp3--flac)
   - [Enrichment (MusicBrainz + Cover Art Archive)](#enrichment)
   - [Use multiple accounts](#use-multiple-accounts)
+  - [Running this on a server](#running-this-on-a-server)
   - [HTTP helpers](#http-helpers)
 - [Errors](#errors)
 - [Types](#types)
@@ -525,6 +526,29 @@ model.contributors;  // normalised producers / engineers / performers / …
 | `richCredits` | `true` | hydrate credits + BPM for album/playlist tracks that omit them |
 | `deezerIds` / `includeRank` | `true` | write `DEEZER_*_ID` / popularity rank |
 
+**On a server, tag as a stream instead.** `addTrackTags` must materialise the
+whole file, which is what caps concurrency. `createTagStream` produces
+byte-identical output without ever holding the audio — both containers keep
+their metadata at the front, so only the header is buffered (a few KB for MP3;
+the source's own metadata region for FLAC):
+
+```ts
+import {pipeline} from 'stream/promises';
+import {streamTrackDownload, resolveTagModel, createTagStream} from 'gerdur-core';
+
+const model = await resolveTagModel(track);          // the fetches, no audio
+const {stream} = await streamTrackDownload(track, 9);
+await pipeline(stream, createTagStream(model), createWriteStream('track.flac'));
+```
+
+| 40 MB tracks, concurrent | `addTrackTags` | `createTagStream` |
+| :--- | ---: | ---: |
+| 4 | +239 MB | **+0 MB** |
+| 16 | +965 MB, 986 ms | **+0 MB, 150 ms** |
+
+`resolveTagModel(track, options?)` does exactly what `addTrackTags` does minus
+the writing — same fetches, same coalescing, same `AddTrackTagsOptions`.
+
 Building blocks, if you want the model without writing tags:
 
 - **`getRichAlbum(albId)`** → merged gw + public album metadata (`RichAlbum`).
@@ -604,6 +628,40 @@ and the raw channels (`gw`, `gwLight`, `gwGet`).
 in tests). The free `getTrackDownloadUrl` / `resolveDownloadUrls` /
 `streamTrackDownload` / `refreshTrackTokens` all take an optional `session`.
 
+**Caching across sessions.** Most gw payloads embed a per-account `TRACK_TOKEN`,
+so each `Session` has its own response cache. Five methods carry nothing
+account-scoped — `album.getData`, `artist.getData`, `song.getLyrics`,
+`album.getDiscography`, `playlist.getData` — and those go to a **process-wide
+cache partitioned by country**, so one copy serves every session and a
+concurrent burst collapses into one request. Measured with 500 sessions reading
+the same album: **500 gateway requests → 1**, and 1.8 MB of duplicated payload →
+one copy. Track lists (`song.getData`, `playlist.getSongs`, `song.getListByAlbum`,
+`episode.getData`, …) are never shared.
+
+```ts
+import {configureCache, cacheStats, clearSharedCaches} from 'gerdur-core';
+
+configureCache({shared: {maxSize: 20_000, ttl: 30 * 60_000}}); // once, at startup
+cacheStats(); // {shared: {size, maxSize, hits, misses, inFlight}} — for /metrics
+```
+
+### Running this on a server
+
+- **Stream, don't buffer — including the tags.** `downloadTrackBuffer` /
+  `getTrackBuffer` hold the whole file, and `addTrackTags` holds it again (the
+  tag writers allocate a second copy). Use `streamTrackDownload` +
+  `resolveTagModel` + `createTagStream` for an end-to-end constant-memory path:
+  measured at 16 concurrent 40 MB tracks, **965 MB → ~0 MB**, and 6.5x faster.
+- **Decryption runs on the event loop.** Blowfish costs ~33 ms per 8 MiB
+  (~243 MiB/s), so heavy concurrent traffic will compete with everything else in
+  the process. Put the decrypt in a worker if you saturate a core.
+- **Size the shared cache** to your catalogue with `configureCache`, and export
+  `cacheStats()` so you can see the hit rate.
+- **Evict idle sessions yourself.** `createSession` has no lifecycle — a session
+  per user, kept forever, keeps its cache forever.
+- `httpAgent` / `httpsAgent` are process-global (`maxSockets: 64`) and shared
+  between API calls and CDN downloads.
+
 ### HTTP helpers
 
 The zero-dependency HTTP client (`get`/`post`/`head`, redirects, gzip/br/deflate,
@@ -744,7 +802,8 @@ import type {
 <details>
 <summary><b>Tagging</b></summary>
 
-`addTrackTags` · `buildTagModel` · `getRichAlbum` · `normalizeContributors` ·
+`addTrackTags` · `resolveTagModel` · `createTagStream` · `probeAudioOffset` ·
+`buildTagModel` · `getRichAlbum` · `normalizeContributors` ·
 `toLrc` · `downloadAlbumCover` · `downloadArtistImage` · `MAX_COVER_SIZE`
 </details>
 
@@ -759,7 +818,8 @@ import type {
 <details>
 <summary><b>HTTP &amp; errors</b></summary>
 
-`getJson` · `getText` · `getBuffer` · `getStream` · `HttpClient` · `httpAgent` ·
+`configureCache` · `cacheStats` · `clearSharedCaches` · `getJson` · `getText` ·
+`getBuffer` · `getStream` · `HttpClient` · `httpAgent` ·
 `httpsAgent` · `HttpStatusError` · `DeezerError` · `GeoBlocked` · `WrongLicense`
 · `ExpiredTrackToken`
 </details>

package/dist/index.d.ts

@@ -3,6 +3,8 @@ export { initDeezerApi, createSession, defaultSession, Session, RETRY_POLICY, DE
 export type { SessionUserData } from './lib/session';
 export { DeezerError } from './lib/errors';
 export type { DeezerErrorPayload } from './lib/errors';
+export { configureCache, cacheStats, clearSharedCaches } from './lib/caches';
+export type { CacheOptions, CacheStats } from './lib/caches';
 export * from './api';
 export * from './converter';
 export * from './lib/decrypt';

package/dist/index.js

@@ -14,7 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 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;
+exports.getStream = exports.getText = exports.getJson = exports.getBuffer = exports.httpsAgent = exports.httpAgent = exports.clearSharedCaches = exports.cacheStats = exports.configureCache = 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; } });
@@ -25,6 +25,10 @@ Object.defineProperty(exports, "RETRY_POLICY", { enumerable: true, get: function
 Object.defineProperty(exports, "DEFAULT_ARL", { enumerable: true, get: function () { return session_1.DEFAULT_ARL; } });
 var errors_1 = require("./lib/errors");
 Object.defineProperty(exports, "DeezerError", { enumerable: true, get: function () { return errors_1.DeezerError; } });
+var caches_1 = require("./lib/caches");
+Object.defineProperty(exports, "configureCache", { enumerable: true, get: function () { return caches_1.configureCache; } });
+Object.defineProperty(exports, "cacheStats", { enumerable: true, get: function () { return caches_1.cacheStats; } });
+Object.defineProperty(exports, "clearSharedCaches", { enumerable: true, get: function () { return caches_1.clearSharedCaches; } });
 __exportStar(require("./api"), exports);
 __exportStar(require("./converter"), exports);
 __exportStar(require("./lib/decrypt"), exports);

package/dist/lib/caches.d.ts

@@ -0,0 +1,59 @@
+/** An LRU that counts hits and misses and can be resized at runtime. */
+declare class CountingCache {
+    private lru;
+    private opts;
+    hits: number;
+    misses: number;
+    constructor(maxSize: number, ttl?: number);
+    get(key: string): any;
+    set(key: string, value: any): void;
+    clear(): void;
+    /** Resize / re-TTL. Drops the current contents (a new LRU is built). */
+    reconfigure(opts: {
+        maxSize?: number;
+        ttl?: number;
+    }): void;
+    get size(): number;
+    get maxSize(): number;
+}
+/**
+ * Account-independent gateway payloads, shared across every {@link Session}.
+ * Keyed by country + method + params — see `Session.gw`.
+ */
+export declare const sharedGatewayCache: CountingCache;
+/** In-flight requests for {@link sharedGatewayCache}, so concurrent sessions coalesce. */
+export declare const sharedInFlight: Map<string, Promise<any>>;
+export interface CacheOptions {
+    /**
+     * The shared gateway metadata cache. Default `{maxSize: 2000, ttl: 3_600_000}`.
+     * Raise `maxSize` for a large catalogue; entries are JSON payloads of a few KB.
+     */
+    shared?: {
+        maxSize?: number;
+        ttl?: number;
+    };
+}
+/**
+ * Resize the shared cache. Call once at startup — reconfiguring drops its
+ * contents.
+ *
+ * ```ts
+ * configureCache({shared: {maxSize: 20_000, ttl: 30 * 60_000}});
+ * ```
+ */
+export declare const configureCache: (options: CacheOptions) => void;
+/** Drop the shared cache. Per-session caches are untouched (`session.cache.clear()` for those). */
+export declare const clearSharedCaches: () => void;
+export interface CacheStats {
+    /** the shared account-independent gateway metadata cache */
+    shared: {
+        size: number;
+        maxSize: number;
+        hits: number;
+        misses: number;
+        inFlight: number;
+    };
+}
+/** A snapshot of shared-cache occupancy and hit rate — for metrics / health endpoints. */
+export declare const cacheStats: () => CacheStats;
+export {};

package/dist/lib/caches.js

@@ -0,0 +1,100 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cacheStats = exports.clearSharedCaches = exports.configureCache = exports.sharedInFlight = exports.sharedGatewayCache = void 0;
+/**
+ * The process-wide cache for account-independent gateway metadata.
+ *
+ * Each {@link Session} keeps its own response cache because most gw payloads
+ * embed a per-account `TRACK_TOKEN`. A handful of methods carry nothing
+ * account-scoped, though — album, artist, lyrics, discography and playlist
+ * metadata are the same bytes for every account in a country. Caching those per
+ * session multiplies one payload by the number of logged-in accounts, which is
+ * fine for a script and wrong for a server.
+ *
+ * Holding them here means they are stored once, and — via {@link sharedInFlight}
+ * — a burst of sessions asking for the same album shares a single request
+ * instead of issuing one each. Measured at 500 sessions reading one album:
+ * **500 gateway requests → 1**, and 1.8 MB of duplicated payload → one copy.
+ *
+ * Tune with {@link configureCache}, inspect with {@link cacheStats}.
+ */
+const fast_lru_1 = __importDefault(require("./fast-lru"));
+/** An LRU that counts hits and misses and can be resized at runtime. */
+class CountingCache {
+    constructor(maxSize, ttl = 0) {
+        this.hits = 0;
+        this.misses = 0;
+        this.opts = { maxSize, ttl };
+        this.lru = new fast_lru_1.default(this.opts);
+    }
+    get(key) {
+        const value = this.lru.get(key);
+        if (value === undefined) {
+            this.misses++;
+        }
+        else {
+            this.hits++;
+        }
+        return value;
+    }
+    set(key, value) {
+        this.lru.set(key, value);
+    }
+    clear() {
+        this.lru.clear();
+    }
+    /** Resize / re-TTL. Drops the current contents (a new LRU is built). */
+    reconfigure(opts) {
+        var _a, _b;
+        this.opts = { maxSize: (_a = opts.maxSize) !== null && _a !== void 0 ? _a : this.opts.maxSize, ttl: (_b = opts.ttl) !== null && _b !== void 0 ? _b : this.opts.ttl };
+        this.lru = new fast_lru_1.default(this.opts);
+    }
+    get size() {
+        return this.lru.size;
+    }
+    get maxSize() {
+        return this.opts.maxSize;
+    }
+}
+/**
+ * Account-independent gateway payloads, shared across every {@link Session}.
+ * Keyed by country + method + params — see `Session.gw`.
+ */
+exports.sharedGatewayCache = new CountingCache(2000, 60 * 60000);
+/** In-flight requests for {@link sharedGatewayCache}, so concurrent sessions coalesce. */
+exports.sharedInFlight = new Map();
+/**
+ * Resize the shared cache. Call once at startup — reconfiguring drops its
+ * contents.
+ *
+ * ```ts
+ * configureCache({shared: {maxSize: 20_000, ttl: 30 * 60_000}});
+ * ```
+ */
+const configureCache = (options) => {
+    if (options.shared) {
+        exports.sharedGatewayCache.reconfigure(options.shared);
+        exports.sharedInFlight.clear();
+    }
+};
+exports.configureCache = configureCache;
+/** Drop the shared cache. Per-session caches are untouched (`session.cache.clear()` for those). */
+const clearSharedCaches = () => {
+    exports.sharedGatewayCache.clear();
+    exports.sharedInFlight.clear();
+};
+exports.clearSharedCaches = clearSharedCaches;
+/** A snapshot of shared-cache occupancy and hit rate — for metrics / health endpoints. */
+const cacheStats = () => ({
+    shared: {
+        size: exports.sharedGatewayCache.size,
+        maxSize: exports.sharedGatewayCache.maxSize,
+        hits: exports.sharedGatewayCache.hits,
+        misses: exports.sharedGatewayCache.misses,
+        inFlight: exports.sharedInFlight.size,
+    },
+});
+exports.cacheStats = cacheStats;

package/dist/lib/decrypt.js

@@ -34,6 +34,9 @@ const getBlowfishKey = (trackId) => {
     return key;
 };
 const CHUNK = 2048;
+// Note: memoising the initialised Blowfish schedule per track was measured and
+// rejected — key setup is 39.7µs against 33ms to decrypt an 8 MiB file (0.12%),
+// break-even at ~10 KiB decrypted per key. Not worth the cache.
 /**
  * Decrypt a downloaded track. Deezer applies Blowfish-CBC "stripe" obfuscation:
  * the file is split into 2048-byte chunks and only every third chunk (0, 3, 6…)

package/dist/lib/rate-limit.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Breaker tuning. A plain object — mutate it at startup to change the policy
+ * process-wide, the same way {@link RETRY_POLICY} works.
+ */
+export declare const BREAKER_POLICY: {
+    /** consecutive rate-limited rounds before the circuit opens */
+    trip: number;
+    /** how long the circuit stays open (requests fail fast) once tripped */
+    openMs: number;
+    /** shared cooldown after the first rate-limited round; doubles per round */
+    cooldownMs: number;
+    /** ceiling on the shared cooldown */
+    maxCooldownMs: number;
+};
+/** A read-only view of a session's rate-limit state, for metrics / health checks. */
+export interface RateLimitState {
+    /** consecutive rate-limited rounds; `0` when healthy */
+    consecutive: number;
+    /** the circuit is open — requests are failing fast */
+    open: boolean;
+    /** ms until the circuit closes again (`0` when not open) */
+    openForMs: number;
+    /** a shared cooldown is in progress and new requests will wait on it */
+    cooling: boolean;
+}
+export declare class RateLimitGate {
+    private gate;
+    private consecutive;
+    private openUntil;
+    /**
+     * Called before every attempt. Throws when the circuit is open; otherwise
+     * waits out any cooldown already in progress.
+     */
+    pass(): Promise<void>;
+    /**
+     * Report a rate-limited response. The first caller in a round opens the shared
+     * cooldown; the rest join it. Returns the cooldown to await.
+     */
+    trip(): Promise<void>;
+    /** Report a clean response — the endpoint is healthy again. */
+    succeed(): void;
+    /** Current state, for `cacheStats`-style reporting. */
+    get state(): RateLimitState;
+    /** Forget everything (used by tests and by `Session.init` on an account change). */
+    reset(): void;
+}

package/dist/lib/rate-limit.js

@@ -0,0 +1,113 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RateLimitGate = exports.BREAKER_POLICY = void 0;
+/**
+ * Coordinated rate-limit handling for a {@link Session}.
+ *
+ * The retry loop already backs off when Deezer answers `code: 4` ("quota limit
+ * exceeded"). The problem is that it backs off *per request*: a session with 60
+ * concurrent gateway calls — tagging a long playlist, say — has all 60
+ * independently discover the limit, independently sleep, and independently
+ * retry, so the limiter keeps getting hit by the full fan-out and every caller
+ * burns its whole 30 s deadline before failing.
+ *
+ * This coordinates them:
+ *
+ * - **One shared cooldown.** The first request to see a rate limit opens a gate;
+ *   every other request in that round waits on the *same* timer instead of
+ *   starting its own. During a cooldown the wire sees nothing, rather than N
+ *   retries. The cooldown escalates per consecutive round and is jittered.
+ * - **A breaker.** After {@link BREAKER_POLICY}`.trip` consecutive rounds the
+ *   circuit opens and requests fail fast with a `DeezerError` for
+ *   `openMs`, instead of each holding a socket and a promise chain for the full
+ *   deadline. The next request after that window is the half-open probe: one
+ *   success resets everything.
+ *
+ * Scope is **per session**, which is the granularity Deezer's per-account quota
+ * uses and keeps one noisy tenant from failing everyone else's requests. If you
+ * also need to respect an IP-level limit shared by many sessions, coordinate
+ * that above this library.
+ */
+const delay_1 = __importDefault(require("delay"));
+const errors_1 = require("./errors");
+/**
+ * Breaker tuning. A plain object — mutate it at startup to change the policy
+ * process-wide, the same way {@link RETRY_POLICY} works.
+ */
+exports.BREAKER_POLICY = {
+    /** consecutive rate-limited rounds before the circuit opens */
+    trip: 5,
+    /** how long the circuit stays open (requests fail fast) once tripped */
+    openMs: 10000,
+    /** shared cooldown after the first rate-limited round; doubles per round */
+    cooldownMs: 1000,
+    /** ceiling on the shared cooldown */
+    maxCooldownMs: 15000,
+};
+class RateLimitGate {
+    constructor() {
+        this.gate = null;
+        this.consecutive = 0;
+        this.openUntil = 0;
+    }
+    /**
+     * Called before every attempt. Throws when the circuit is open; otherwise
+     * waits out any cooldown already in progress.
+     */
+    async pass() {
+        const openForMs = this.openUntil - Date.now();
+        if (openForMs > 0) {
+            throw new errors_1.DeezerError({
+                code: 4,
+                RATE_LIMIT_CIRCUIT_OPEN: `Deezer rate-limited this session; retrying in ${Math.ceil(openForMs / 1000)}s`,
+            });
+        }
+        if (this.gate) {
+            await this.gate;
+        }
+    }
+    /**
+     * Report a rate-limited response. The first caller in a round opens the shared
+     * cooldown; the rest join it. Returns the cooldown to await.
+     */
+    trip() {
+        if (!this.gate) {
+            // one increment per round, not per concurrent failure
+            this.consecutive++;
+            if (this.consecutive >= exports.BREAKER_POLICY.trip) {
+                this.openUntil = Date.now() + exports.BREAKER_POLICY.openMs;
+            }
+            const window = Math.min(exports.BREAKER_POLICY.cooldownMs * 2 ** (this.consecutive - 1), exports.BREAKER_POLICY.maxCooldownMs);
+            const jittered = window / 2 + Math.random() * (window / 2);
+            this.gate = (0, delay_1.default)(jittered).then(() => {
+                this.gate = null;
+            });
+        }
+        return this.gate;
+    }
+    /** Report a clean response — the endpoint is healthy again. */
+    succeed() {
+        this.consecutive = 0;
+        this.openUntil = 0;
+    }
+    /** Current state, for `cacheStats`-style reporting. */
+    get state() {
+        const openForMs = Math.max(0, this.openUntil - Date.now());
+        return {
+            consecutive: this.consecutive,
+            open: openForMs > 0,
+            openForMs,
+            cooling: this.gate !== null,
+        };
+    }
+    /** Forget everything (used by tests and by `Session.init` on an account change). */
+    reset() {
+        this.consecutive = 0;
+        this.openUntil = 0;
+        this.gate = null;
+    }
+}
+exports.RateLimitGate = RateLimitGate;

package/dist/lib/session.d.ts

@@ -102,7 +102,14 @@ export declare class Session {
      * backoff, and a wall-clock deadline. Throws `DeezerError` on exhaustion.
      */
     request<T>(method: 'GET' | 'POST', url: string, body?: unknown, config?: SessionRequestConfig): Promise<HttpResponse<T>>;
-    /** Single-flight + LRU around a fetcher, keyed per session. */
+    /**
+     * Single-flight + LRU around a fetcher.
+     *
+     * `shared` routes to the process-wide cache and in-flight map instead of this
+     * session's — used for gw methods whose payloads carry nothing account-scoped
+     * (see {@link ACCOUNT_INDEPENDENT_GW}). Two sessions asking for the same album
+     * concurrently then share one request rather than issuing one each.
+     */
     private coalesce;
     /** POST `gateway.php` — the main gw method channel. Coalesced + cached. */
     gw<T = any>(body: Record<string, unknown>, method: string): Promise<T>;

package/dist/lib/session.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.setDefaultSession = exports.createSession = exports.initDeezerApi = exports.defaultSession = exports.Session = exports.RETRY_POLICY = exports.DEFAULT_ARL = void 0;
 const delay_1 = __importDefault(require("delay"));
+const caches_1 = require("./caches");
 const errors_1 = require("./errors");
 const fast_lru_1 = __importDefault(require("./fast-lru"));
 const http_1 = require("./http");
@@ -33,6 +34,22 @@ exports.RETRY_POLICY = {
     /** overall wall-clock budget from the first attempt */
     deadlineMs: 30000,
 };
+// A shared cooldown + circuit breaker across a session's concurrent requests was
+// built and measured against this loop, then dropped. Numbers, 60 concurrent
+// requests against a permanently rate-limited endpoint (baseline 420 wire calls
+// / 8.5s):
+//   - as first written (trip after 5 rounds, escalating shared cooldown):
+//     420 calls / 36s — strictly worse. The retry cap is per request, so
+//     synchronising the waits changes nothing about total calls and only
+//     lengthens them.
+//   - tuned hard (open on the first rate-limited round, 300ms cooldown):
+//     60 calls / 0.2s, but a *single* request meeting one transient `code: 4`
+//     then fails outright, where this loop retries and succeeds.
+// The flaw is structural: the request that trips the breaker is immediately
+// blocked by its own trip. A correct version has to tell new work apart from an
+// in-flight retry — shed the former, never the latter — which means threading
+// per-request attempt state through the gate. Worth doing only with a real
+// workload to tune against; guessing made it worse twice.
 /** Exponential backoff (ms) with full jitter on the top half of the window. */
 const backoffDelay = (attempt) => {
     const windowMs = Math.min(exports.RETRY_POLICY.baseMs * 2 ** attempt, exports.RETRY_POLICY.maxDelayMs);
@@ -40,6 +57,27 @@ const backoffDelay = (attempt) => {
 };
 /** How long a loaded `deezer.getUserData` payload is trusted before a refresh. */
 const USER_DATA_TTL_MS = 25 * 60 * 1000;
+/**
+ * gw methods whose payloads carry **no account-scoped fields**, so one copy can
+ * serve every session instead of one copy per session.
+ *
+ * The account-scoped field that matters is `TRACK_TOKEN`, and it appears on
+ * exactly two response shapes — `trackType` and `showEpisodeType`. None of the
+ * methods below embed either, so their results are identical for every account
+ * in a given country. Everything else (`song.getData`, `playlist.getSongs`,
+ * `song.getListByAlbum`, `song.getListData`, `episode.getData`, `mobile.*`,
+ * `deezer.pageSearch`, `user_getInfo`, …) stays in the per-session cache.
+ *
+ * The shared key is prefixed with the session's country, so a multi-region
+ * deployment never serves one country's availability view to another.
+ */
+const ACCOUNT_INDEPENDENT_GW = new Set([
+    'album.getData',
+    'artist.getData',
+    'song.getLyrics',
+    'album.getDiscography',
+    'playlist.getData', // playlistInfo — metadata only (playlist.getSongs is NOT shared)
+]);
 /**
  * One Deezer session — owns the `arl`, the HTTP client (and its `sid` /
  * `api_token`), and the account's `license_token` / `country` / streaming
@@ -217,38 +255,52 @@ class Session {
         }
     }
     // ─── Cached request primitives ──────────────────────────────────────────────
-    /** Single-flight + LRU around a fetcher, keyed per session. */
-    coalesce(key, fetcher) {
-        const cached = this.cache.get(key);
+    /**
+     * Single-flight + LRU around a fetcher.
+     *
+     * `shared` routes to the process-wide cache and in-flight map instead of this
+     * session's — used for gw methods whose payloads carry nothing account-scoped
+     * (see {@link ACCOUNT_INDEPENDENT_GW}). Two sessions asking for the same album
+     * concurrently then share one request rather than issuing one each.
+     */
+    coalesce(key, fetcher, shared = false) {
+        const cache = shared ? caches_1.sharedGatewayCache : this.cache;
+        const inFlight = shared ? caches_1.sharedInFlight : this.inFlight;
+        const cached = cache.get(key);
         if (cached) {
             return Promise.resolve(cached);
         }
-        const pending = this.inFlight.get(key);
+        const pending = inFlight.get(key);
         if (pending) {
             return pending;
         }
         const promise = (async () => {
             try {
-                return await fetcher();
+                const value = await fetcher();
+                cache.set(key, value);
+                return value;
             }
             finally {
-                this.inFlight.delete(key);
+                inFlight.delete(key);
             }
         })();
-        this.inFlight.set(key, promise);
+        inFlight.set(key, promise);
         return promise;
     }
     /** POST `gateway.php` — the main gw method channel. Coalesced + cached. */
     gw(body, method) {
-        const key = `gw:${method}:${Object.entries(body).join(':')}`;
+        var _a;
+        const shared = ACCOUNT_INDEPENDENT_GW.has(method);
+        const key = shared
+            ? `${(_a = this.country) !== null && _a !== void 0 ? _a : 'XX'}:gw:${method}:${Object.entries(body).join(':')}`
+            : `gw:${method}:${Object.entries(body).join(':')}`;
         return this.coalesce(key, async () => {
             const { data: { error, results }, } = await this.request('POST', '/gateway.php', body, { params: { method } });
             if (results && Object.keys(results).length > 0) {
-                this.cache.set(key, results);
                 return results;
             }
             throw new errors_1.DeezerError(error);
-        });
+        }, shared);
     }
     /** POST `gw-light.php` — the lighter method channel (search, suggest, …). */
     gwLight(body, method) {
@@ -258,7 +310,6 @@ class Session {
                 params: { method, api_version: '1.0' },
             });
             if (results && Object.keys(results).length > 0) {
-                this.cache.set(key, results);
                 return results;
             }
             throw new errors_1.DeezerError(error);
@@ -272,7 +323,6 @@ class Session {
                 params: { method, ...params },
             });
             if (results && Object.keys(results).length > 0) {
-                this.cache.set(cacheKey, results);
                 return results;
             }
             throw new errors_1.DeezerError(error);

package/dist/metadata-writer/index.d.ts

@@ -10,6 +10,7 @@ export type { RichAlbum } from './rich-album';
 export { buildTagModel } from './model';
 export type { TrackTagModel, Person } from './model';
 export { downloadAlbumCover, downloadArtistImage, MAX_COVER_SIZE } from './abumCover';
+export { createTagStream, probeAudioOffset } from './tag-stream';
 export interface AddTrackTagsOptions {
     /** embedded cover size in px, 56–1800 (default 1000) */
     coverSize?: number;
@@ -48,6 +49,20 @@ export interface TaggedTrack {
     /** everything gerdur pulled together for this track — use `model.lyricsSynced` for a `.lrc` sidecar */
     model: TrackTagModel;
 }
+/**
+ * Resolve everything Deezer has for a track into the canonical tag model —
+ * without touching any audio.
+ *
+ * Fetches album info, lyrics, cover, artist image and (for album/playlist
+ * tracks, which ship without them) full credits + BPM, all in parallel; every
+ * call is memoised and in-flight-coalesced, so resolving all tracks of one album
+ * hits each metadata endpoint once. Pass any of
+ * `options.{album,lyrics,cover,publicTrack}` to skip the corresponding fetch.
+ *
+ * Feed the result to `createTagStream(model)` to tag a stream, or use
+ * {@link addTrackTags} to tag a `Buffer` in one call.
+ */
+export declare const resolveTagModel: (trackInput: trackType, options?: AddTrackTagsOptions) => Promise<TrackTagModel>;
 /**
  * Pull together everything Deezer has for a track and write it into the audio.
  *
@@ -57,6 +72,10 @@ export interface TaggedTrack {
  * tracks of one album hits each metadata endpoint once. Pass any of
  * `options.{album,lyrics,cover,publicTrack}` to skip the corresponding fetch.
  *
+ * This holds the whole file in memory (and the tag writers allocate another
+ * copy). On a server, prefer {@link resolveTagModel} + `createTagStream`, which
+ * produces byte-identical output without buffering the audio.
+ *
  * @returns `{buffer, model}` — `model` carries the structured metadata and,
  *   when available, `model.lyricsSynced` (an LRC document for a sidecar file).
  */

package/dist/metadata-writer/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.addTrackTags = exports.MAX_COVER_SIZE = exports.downloadArtistImage = exports.downloadAlbumCover = exports.buildTagModel = exports.getRichAlbum = exports.toLrc = exports.normalizeContributors = void 0;
+exports.addTrackTags = exports.resolveTagModel = exports.probeAudioOffset = exports.createTagStream = exports.MAX_COVER_SIZE = exports.downloadArtistImage = exports.downloadAlbumCover = exports.buildTagModel = exports.getRichAlbum = exports.toLrc = exports.normalizeContributors = void 0;
 const abumCover_1 = require("./abumCover");
 const getTrackLyrics_1 = require("./getTrackLyrics");
 const id3_1 = require("./id3");
@@ -20,6 +20,9 @@ var abumCover_2 = require("./abumCover");
 Object.defineProperty(exports, "downloadAlbumCover", { enumerable: true, get: function () { return abumCover_2.downloadAlbumCover; } });
 Object.defineProperty(exports, "downloadArtistImage", { enumerable: true, get: function () { return abumCover_2.downloadArtistImage; } });
 Object.defineProperty(exports, "MAX_COVER_SIZE", { enumerable: true, get: function () { return abumCover_2.MAX_COVER_SIZE; } });
+var tag_stream_1 = require("./tag-stream");
+Object.defineProperty(exports, "createTagStream", { enumerable: true, get: function () { return tag_stream_1.createTagStream; } });
+Object.defineProperty(exports, "probeAudioOffset", { enumerable: true, get: function () { return tag_stream_1.probeAudioOffset; } });
 const DEFAULTS = {
     coverSize: 1000,
     embedCover: true,
@@ -55,18 +58,19 @@ const hydrate = async (track) => {
     }
 };
 /**
- * Pull together everything Deezer has for a track and write it into the audio.
+ * Resolve everything Deezer has for a track into the canonical tag model —
+ * without touching any audio.
  *
- * Sniffs `fLaC` vs MP3 and dispatches to the FLAC / ID3 writer. Fetches album
- * info, lyrics, cover and (for album/playlist tracks) full credits + BPM in
- * parallel — every call is memoised and in-flight-coalesced, so tagging all
- * tracks of one album hits each metadata endpoint once. Pass any of
+ * Fetches album info, lyrics, cover, artist image and (for album/playlist
+ * tracks, which ship without them) full credits + BPM, all in parallel; every
+ * call is memoised and in-flight-coalesced, so resolving all tracks of one album
+ * hits each metadata endpoint once. Pass any of
  * `options.{album,lyrics,cover,publicTrack}` to skip the corresponding fetch.
  *
- * @returns `{buffer, model}` — `model` carries the structured metadata and,
- *   when available, `model.lyricsSynced` (an LRC document for a sidecar file).
+ * Feed the result to `createTagStream(model)` to tag a stream, or use
+ * {@link addTrackTags} to tag a `Buffer` in one call.
  */
-const addTrackTags = async (trackBuffer, trackInput, options = {}) => {
+const resolveTagModel = async (trackInput, options = {}) => {
     const opt = { ...DEFAULTS, ...options };
     const track = opt.richCredits ? await hydrate(trackInput) : trackInput;
     const [album, lyrics, publicTrack, cover, artistImage] = await Promise.all([
@@ -106,6 +110,28 @@ const addTrackTags = async (trackBuffer, trackInput, options = {}) => {
         deezerIds: opt.deezerIds,
         includeRank: opt.includeRank,
     });
+    return model;
+};
+exports.resolveTagModel = resolveTagModel;
+/**
+ * Pull together everything Deezer has for a track and write it into the audio.
+ *
+ * Sniffs `fLaC` vs MP3 and dispatches to the FLAC / ID3 writer. Fetches album
+ * info, lyrics, cover and (for album/playlist tracks) full credits + BPM in
+ * parallel — every call is memoised and in-flight-coalesced, so tagging all
+ * tracks of one album hits each metadata endpoint once. Pass any of
+ * `options.{album,lyrics,cover,publicTrack}` to skip the corresponding fetch.
+ *
+ * This holds the whole file in memory (and the tag writers allocate another
+ * copy). On a server, prefer {@link resolveTagModel} + `createTagStream`, which
+ * produces byte-identical output without buffering the audio.
+ *
+ * @returns `{buffer, model}` — `model` carries the structured metadata and,
+ *   when available, `model.lyricsSynced` (an LRC document for a sidecar file).
+ */
+const addTrackTags = async (trackBuffer, trackInput, options = {}) => {
+    const model = await (0, exports.resolveTagModel)(trackInput, options);
+    const opt = { ...DEFAULTS, ...options };
     const isFlac = trackBuffer.slice(0, 4).toString('ascii') === 'fLaC';
     const buffer = isFlac
         ? (0, flacmetata_1.writeMetadataFlac)(trackBuffer, model, { embedSyncedLyrics: opt.embedSyncedLyrics })

package/dist/metadata-writer/tag-stream.d.ts

@@ -0,0 +1,64 @@
+/// <reference types="node" />
+/**
+ * Streaming tag writer — rewrite a track's tags as bytes flow through, without
+ * ever holding the audio.
+ *
+ * `addTrackTags` has to materialise the whole file: `browser-id3-writer`
+ * allocates `audio.length + tag` and copies the audio into it (and copies again
+ * to strip an existing ID3v2), and the FLAC path concatenates the same way. That
+ * is ~2–3× the file size per concurrent call — measured at **+121 MB retained
+ * for a 40 MB MP3** — which is what caps concurrency on a server and what
+ * quietly cancels `streamTrackDownload`'s constant-memory guarantee at the last
+ * step.
+ *
+ * Both container formats put their metadata at the *front*, so none of that
+ * copying is necessary:
+ *
+ * - **MP3** — an ID3v2 tag is a 10-byte header plus a syncsafe length. Emit a
+ *   freshly built tag, discard exactly that many bytes of the source as they go
+ *   past, pass the rest through. Nothing is buffered at all.
+ * - **FLAC** — `fLaC` then a chain of metadata blocks, the last flagged. Buffer
+ *   only that chain (to parse STREAMINFO and friends), emit the rebuilt blocks,
+ *   pass the frames through untouched.
+ *
+ * Peak memory becomes O(metadata) instead of O(file): a few KB for MP3, and for
+ * FLAC whatever the source's own metadata region is.
+ *
+ * The tag bytes come from the exact same writers `addTrackTags` uses — called
+ * with an empty / truncated source so they emit only the header — so output is
+ * byte-identical to the buffered path.
+ *
+ * ```ts
+ * import {pipeline} from 'stream/promises';
+ * const {stream} = await streamTrackDownload(track, 9);
+ * await pipeline(stream, createTagStream(model), createWriteStream('out.flac'));
+ * ```
+ */
+import { Transform } from 'stream';
+import type { FlacWriteOptions } from './flacmetata';
+import type { TrackTagModel } from './model';
+type Probe = {
+    ready: false;
+} | {
+    ready: true;
+    audioOffset: number;
+    flac: boolean;
+};
+/**
+ * Where the audio starts in the source, and which container it is.
+ * `{ready: false}` means "need more bytes".
+ */
+export declare const probeAudioOffset: (buf: Buffer) => Probe;
+/**
+ * A `Transform` that replaces the tags on a track as it streams through.
+ *
+ * Feed it the decrypted audio (e.g. from {@link streamTrackDownload}); it emits
+ * the same bytes {@link addTrackTags} would produce, without buffering the file.
+ * Detects MP3 vs FLAC from the source itself.
+ *
+ * @param model   the canonical tag model — from `buildTagModel`, or the `model`
+ *                an earlier `addTrackTags` call returned
+ * @param options forwarded to the FLAC writer (e.g. `embedSyncedLyrics`)
+ */
+export declare const createTagStream: (model: TrackTagModel, options?: FlacWriteOptions) => Transform;
+export {};

package/dist/metadata-writer/tag-stream.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTagStream = exports.probeAudioOffset = void 0;
+/**
+ * Streaming tag writer — rewrite a track's tags as bytes flow through, without
+ * ever holding the audio.
+ *
+ * `addTrackTags` has to materialise the whole file: `browser-id3-writer`
+ * allocates `audio.length + tag` and copies the audio into it (and copies again
+ * to strip an existing ID3v2), and the FLAC path concatenates the same way. That
+ * is ~2–3× the file size per concurrent call — measured at **+121 MB retained
+ * for a 40 MB MP3** — which is what caps concurrency on a server and what
+ * quietly cancels `streamTrackDownload`'s constant-memory guarantee at the last
+ * step.
+ *
+ * Both container formats put their metadata at the *front*, so none of that
+ * copying is necessary:
+ *
+ * - **MP3** — an ID3v2 tag is a 10-byte header plus a syncsafe length. Emit a
+ *   freshly built tag, discard exactly that many bytes of the source as they go
+ *   past, pass the rest through. Nothing is buffered at all.
+ * - **FLAC** — `fLaC` then a chain of metadata blocks, the last flagged. Buffer
+ *   only that chain (to parse STREAMINFO and friends), emit the rebuilt blocks,
+ *   pass the frames through untouched.
+ *
+ * Peak memory becomes O(metadata) instead of O(file): a few KB for MP3, and for
+ * FLAC whatever the source's own metadata region is.
+ *
+ * The tag bytes come from the exact same writers `addTrackTags` uses — called
+ * with an empty / truncated source so they emit only the header — so output is
+ * byte-identical to the buffered path.
+ *
+ * ```ts
+ * import {pipeline} from 'stream/promises';
+ * const {stream} = await streamTrackDownload(track, 9);
+ * await pipeline(stream, createTagStream(model), createWriteStream('out.flac'));
+ * ```
+ */
+const stream_1 = require("stream");
+const flacmetata_1 = require("./flacmetata");
+const id3_1 = require("./id3");
+/**
+ * Cap on how much of the source is buffered while looking for the end of its
+ * metadata region. Only FLAC ever gets here, and only for its own metadata
+ * (STREAMINFO + SEEKTABLE + any embedded art). Past this the stream errors
+ * rather than growing without bound.
+ */
+const MAX_HEADER_BYTES = 16 * 1024 * 1024;
+/**
+ * Where the audio starts in the source, and which container it is.
+ * `{ready: false}` means "need more bytes".
+ */
+const probeAudioOffset = (buf) => {
+    if (buf.length >= 4 && buf.toString('ascii', 0, 4) === 'fLaC') {
+        // fLaC | (1 byte: last-block flag + type)(3 bytes: length)[body] ...
+        let offset = 4;
+        for (;;) {
+            if (offset + 4 > buf.length) {
+                return { ready: false };
+            }
+            const isLast = buf.readUInt8(offset) >= 128;
+            offset += 4 + buf.readUIntBE(offset + 1, 3);
+            if (isLast) {
+                // the whole chain must be present for the FLAC parser to walk it
+                return offset <= buf.length ? { ready: true, audioOffset: offset, flac: true } : { ready: false };
+            }
+        }
+    }
+    if (buf.length < 10) {
+        return { ready: false };
+    }
+    if (buf.toString('ascii', 0, 3) !== 'ID3') {
+        return { ready: true, audioOffset: 0, flac: false }; // no existing tag — audio from byte 0
+    }
+    // ID3v2 size is 4 syncsafe bytes (7 bits each) at offset 6
+    const size = (buf[6] << 21) | (buf[7] << 14) | (buf[8] << 7) | buf[9];
+    return { ready: true, audioOffset: 10 + size, flac: false };
+};
+exports.probeAudioOffset = probeAudioOffset;
+/**
+ * A `Transform` that replaces the tags on a track as it streams through.
+ *
+ * Feed it the decrypted audio (e.g. from {@link streamTrackDownload}); it emits
+ * the same bytes {@link addTrackTags} would produce, without buffering the file.
+ * Detects MP3 vs FLAC from the source itself.
+ *
+ * @param model   the canonical tag model — from `buildTagModel`, or the `model`
+ *                an earlier `addTrackTags` call returned
+ * @param options forwarded to the FLAC writer (e.g. `embedSyncedLyrics`)
+ */
+const createTagStream = (model, options = {}) => {
+    let head = [];
+    let headLength = 0;
+    /** 'probing' → reading the source header; 'skipping' → dropping its old tag; 'passthrough' → audio */
+    let mode = 'probing';
+    let toSkip = 0;
+    return new stream_1.Transform({
+        transform(chunk, _encoding, callback) {
+            const part = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+            if (mode === 'passthrough') {
+                this.push(part);
+                return callback();
+            }
+            if (mode === 'skipping') {
+                if (part.length <= toSkip) {
+                    toSkip -= part.length;
+                }
+                else {
+                    this.push(part.subarray(toSkip));
+                    toSkip = 0;
+                    mode = 'passthrough';
+                }
+                return callback();
+            }
+            head.push(part);
+            headLength += part.length;
+            if (headLength > MAX_HEADER_BYTES) {
+                return callback(new Error(`No audio found in the first ${MAX_HEADER_BYTES} bytes — is this a track?`));
+            }
+            const buffered = head.length === 1 ? head[0] : Buffer.concat(head, headLength);
+            const probe = (0, exports.probeAudioOffset)(buffered);
+            if (!probe.ready) {
+                head = [buffered];
+                return callback();
+            }
+            try {
+                if (probe.flac) {
+                    // truncating at audioOffset makes the writer's own `slice(framesOffset)`
+                    // empty, so it returns exactly `fLaC` + the rebuilt metadata blocks
+                    this.push((0, flacmetata_1.writeMetadataFlac)(buffered.subarray(0, probe.audioOffset), model, options));
+                    this.push(buffered.subarray(probe.audioOffset));
+                    mode = 'passthrough';
+                }
+                else {
+                    // an empty source makes the ID3 writer emit only the tag
+                    this.push((0, id3_1.writeMetadataMp3)(Buffer.alloc(0), model));
+                    if (buffered.length > probe.audioOffset) {
+                        this.push(buffered.subarray(probe.audioOffset));
+                        mode = 'passthrough';
+                    }
+                    else {
+                        toSkip = probe.audioOffset - buffered.length;
+                        mode = 'skipping';
+                    }
+                }
+            }
+            catch (err) {
+                return callback(err);
+            }
+            head = [];
+            headLength = 0;
+            return callback();
+        },
+        flush(callback) {
+            // a source too short to probe (or one that never closed its metadata
+            // chain) — tag what we have rather than dropping it
+            if (mode === 'probing' && headLength > 0) {
+                const buffered = head.length === 1 ? head[0] : Buffer.concat(head, headLength);
+                try {
+                    this.push((0, id3_1.writeMetadataMp3)(Buffer.alloc(0), model));
+                    this.push(buffered);
+                }
+                catch (err) {
+                    return callback(err);
+                }
+            }
+            return callback();
+        },
+    });
+};
+exports.createTagStream = createTagStream;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gerdur-core",
-  "version": "2.13.3",
+  "version": "2.15.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",