gerdur-core 1.0.4 → 2.0.0

package/CHANGELOG.md

@@ -1,5 +1,56 @@
 # Changelog
 
+## 2.0.0 - 2026-08-31
+
+Metadata overhaul — extract everything Deezer actually exposes for a track.
+
+### Breaking
+
+- **`addTrackTags(buffer, track, options)`** — the third argument is now an
+  options object, not a cover-size number, and it resolves to
+  **`{buffer, model}`** instead of a bare `Buffer`. Migrate:
+  `await addTrackTags(buf, track, 500)` → `(await addTrackTags(buf, track, {coverSize: 500})).buffer`.
+  `model` is the full `TrackTagModel` (all resolved fields + `model.lyricsSynced`,
+  an LRC document).
+- `writeMetadataMp3` / `writeMetadataFlac` now take the `TrackTagModel`, not a
+  raw track + public-album payload.
+- `downloadAlbumCover` clamps its size to Deezer's real ceiling of **1800**
+  (was unbounded); `coverSize` is re-exported from here.
+
+### Added
+
+- **ReplayGain** — `GAIN` (present on every `song.getData`) is written as
+  `REPLAYGAIN_TRACK_GAIN` (`TXXX` on MP3, Vorbis comment on FLAC).
+- **Rich credits** via `normalizeContributors()` — `SNG_CONTRIBUTORS` has
+  inconsistent keys across the catalogue (`main_artist` / `mainartist` / `artist`,
+  `music publisher` with a space, …); this normalises them and surfaces
+  `featuring`, mastering / mixing / recording engineers, producers, mixers,
+  performers.
+- **Featured artists** from `SNG_CONTRIBUTORS.featuring` → `TXXX:FEATURING` /
+  `FEATURING`, plus a combined `ARTISTS` tag.
+- **Original release date** — `getRichAlbum()` merges gw `album.getData`
+  (`ORIGINAL_RELEASE_DATE`, `COPYRIGHT`/`PRODUCER_LINE`, `NUMBER_DISK`,
+  `SUBTYPES`) with the public `/album/` (label, genres, record type). Writes
+  `ORIGINALDATE`/`ORIGINALYEAR` distinct from the reissue `DATE`.
+- **BPM** from the public `/track/` endpoint (`TBPM` + precise `TXXX:BPM`).
+- **Synced lyrics** — `toLrc()` renders `LYRICS_SYNC_JSON` (already fetched with
+  the plain lyrics) as an LRC document, exposed on `model.lyricsSynced` and
+  embedded in FLAC `LYRICS`.
+- Real `©` / `℗` lines, disc totals, compilation/live flags from `SUBTYPES`,
+  proper `EXPLICIT_LYRICS_STATUS` enum handling (`1`/`4` = explicit; `2`/`6` =
+  unknown, not "explicit"), `iTunesAdvisory`, Deezer track/album/artist/label/
+  provider ids, `URL_REWRITING` slug, popularity rank, and the artist photo as a
+  second embedded picture.
+- New exports: `getRichAlbum`, `RichAlbum`, `normalizeContributors`,
+  `NormalizedContributors`, `toLrc`, `buildTagModel`, `TrackTagModel`, `Person`,
+  `AddTrackTagsOptions`, `TaggedTrack`, `downloadArtistImage`, `MAX_COVER_SIZE`.
+
+### Changed
+
+- Album/playlist tracks (which come without `SNG_CONTRIBUTORS` / `VERSION` /
+  `GAIN`) are transparently hydrated with one coalesced `song.getData` before
+  tagging. Disable via `addTrackTags(…, {richCredits: false})`.
+
 ## 1.0.4 - 2026-08-31
 
 ### Added

package/README.md

@@ -68,11 +68,14 @@ const data = await downloadBuffer(trackData.trackUrl);
 // Decrypt track if needed
 const outFile = trackData.isEncrypted ? api.decryptDownload(data, track.SNG_ID) : data;
 
-// Add id3 metadata
-const trackWithMetadata = await api.addTrackTags(outFile, track, 500);
+// Add metadata — resolves album info, credits, lyrics and cover from Deezer
+const {buffer, model} = await api.addTrackTags(outFile, track, {coverSize: 500});
 
 // Save file to disk
-fs.writeFileSync(track.SNG_TITLE + '.mp3', trackWithMetadata);
+fs.writeFileSync(track.SNG_TITLE + '.mp3', buffer);
+
+// Time-synced lyrics, when Deezer has them, come back as an LRC document
+if (model.lyricsSynced) fs.writeFileSync(track.SNG_TITLE + '.lrc', model.lyricsSynced);
 ```
 
 ### [Read FAQ](docs/faq.md)
@@ -173,13 +176,18 @@ All method returns `Object` or throws `Error`. Make sure to catch error on your
 | `data`     |   Yes    | `buffer` | downloaded song buffer |
 | `song_id`  |   Yes    | `string` |               track id |
 
-### `.addTrackTags(data, track,coverSize)`
+### `.addTrackTags(data, track, options?)`
+
+Resolves album info, credits, lyrics and artwork from Deezer and writes them into
+the audio (ID3v2.3 for MP3, Vorbis comments for FLAC). Returns
+`{buffer, model}` — `model` is the full `TrackTagModel`, including
+`model.lyricsSynced` (an LRC document) when the track has time-synced lyrics.
 
-| Parameters  | Required |      Type |            Description |
-| ----------- | :------: | --------: | ---------------------: |
-| `data`      |   Yes    |  `buffer` | downloaded song buffer |
-| `track`     |   Yes    |  `string` |           track object |
-| `coverSize` |    No    | `56-1800` |         cover art size |
+| Parameters | Required |     Type | Description                                    |
+| ---------- | :------: | -------: | --------------------------------------------- |
+| `data`     |   Yes    | `buffer` | downloaded, decrypted song buffer             |
+| `track`    |   Yes    | `object` | track object from `getTrackInfo` / `parseInfo` |
+| `options`  |    No    | `object` | `AddTrackTagsOptions` — `coverSize` (56–1800), pre-fetched `album`/`lyrics`/`cover`, and toggles (`richCredits`, `embedArtistImage`, `deezerIds`, …) |
 
 ###
 

package/dist/lib/metaflac-js.d.ts

@@ -91,7 +91,7 @@ declare class Metaflac {
      *
      * @param {string} filename
      */
-    importPicture(picture: Buffer, dimension: number, mime: 'image/jpeg' | 'image/png'): void;
+    importPicture(picture: Buffer, dimension: number, mime: 'image/jpeg' | 'image/png', type?: number, description?: string): void;
     /**
      * Return all tags.
      */

package/dist/lib/metaflac-js.js

@@ -236,9 +236,11 @@ class Metaflac {
      *
      * @param {string} filename
      */
-    importPicture(picture, dimension, mime) {
+    importPicture(picture, dimension, mime, type = 3, description = '') {
         const spec = this.buildSpecification({
+            type,
             mime,
+            description,
             width: dimension,
             height: dimension,
         });

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

@@ -1,10 +1,14 @@
 /// <reference types="node" />
 import type { trackType } from '../types';
-type coverSize = 56 | 250 | 500 | 1000 | 1500 | 1800 | number;
+export type coverSize = 56 | 250 | 500 | 1000 | 1200 | 1500 | 1800 | number;
+export declare const MAX_COVER_SIZE = 1800;
 /**
- *
- * @param {Object} track track info json from deezer api
- * @param {Number} albumCoverSize in pixel, between 56-1800
+ * @param track track info json from deezer api
+ * @param albumCoverSize in pixels, 56–1800 (clamped)
  */
 export declare const downloadAlbumCover: (track: trackType, albumCoverSize: coverSize) => Promise<Buffer | null>;
-export {};
+/**
+ * Artist photo (`ART_PICTURE` md5). Returns null when the track has no artist
+ * image (common for small-catalogue artists).
+ */
+export declare const downloadArtistImage: (track: trackType, size?: coverSize) => Promise<Buffer | null>;

package/dist/metadata-writer/abumCover.js

@@ -3,35 +3,49 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.downloadAlbumCover = void 0;
+exports.downloadArtistImage = exports.downloadAlbumCover = exports.MAX_COVER_SIZE = void 0;
 const fast_lru_1 = __importDefault(require("../lib/fast-lru"));
 const http_1 = require("../lib/http");
+exports.MAX_COVER_SIZE = 1800;
 // expire cache in 30 minutes
 const lru = new fast_lru_1.default({
     maxSize: 50,
     ttl: 30 * 60000,
 });
-/**
- *
- * @param {Object} track track info json from deezer api
- * @param {Number} albumCoverSize in pixel, between 56-1800
- */
-const downloadAlbumCover = async (track, albumCoverSize) => {
-    if (!track.ALB_PICTURE) {
+const clampSize = (n) => Math.max(56, Math.min(exports.MAX_COVER_SIZE, Math.round(n) || 500));
+const imageUrl = (kind, md5, size) => `https://e-cdns-images.dzcdn.net/images/${kind}/${md5}/${size}x${size}-000000-80-0-0.jpg`;
+const fetchImage = async (kind, md5, size) => {
+    if (!md5) {
         return null;
     }
-    const cache = lru.get(track.ALB_PICTURE + albumCoverSize);
-    if (cache) {
-        return cache;
+    const px = clampSize(size);
+    const key = `${kind}:${md5}:${px}`;
+    const cached = lru.get(key);
+    if (cached) {
+        return cached;
     }
     try {
-        const url = `https://e-cdns-images.dzcdn.net/images/cover/${track.ALB_PICTURE}/${albumCoverSize}x${albumCoverSize}-000000-80-0-0.jpg`;
-        const data = await (0, http_1.getBuffer)(url);
-        lru.set(track.ALB_PICTURE + albumCoverSize, data);
+        const data = await (0, http_1.getBuffer)(imageUrl(kind, md5, px));
+        lru.set(key, data);
         return data;
     }
     catch (err) {
         return null;
     }
 };
+/**
+ * @param track track info json from deezer api
+ * @param albumCoverSize in pixels, 56–1800 (clamped)
+ */
+const downloadAlbumCover = (track, albumCoverSize) => fetchImage('cover', track.ALB_PICTURE, albumCoverSize);
 exports.downloadAlbumCover = downloadAlbumCover;
+/**
+ * Artist photo (`ART_PICTURE` md5). Returns null when the track has no artist
+ * image (common for small-catalogue artists).
+ */
+const downloadArtistImage = (track, size = 1000) => {
+    var _a, _b;
+    const md5 = track.ART_PICTURE || ((_b = (_a = track.ARTISTS) === null || _a === void 0 ? void 0 : _a.find((a) => a.ART_PICTURE)) === null || _b === void 0 ? void 0 : _b.ART_PICTURE);
+    return fetchImage('artist', md5, size);
+};
+exports.downloadArtistImage = downloadArtistImage;

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

@@ -0,0 +1,31 @@
+import type { sngContributors } from '../types';
+export interface NormalizedContributors {
+    /** billed / lead artists */
+    mainArtists: string[];
+    /** "feat." artists */
+    featuring: string[];
+    composers: string[];
+    /** author / writer / lyricist, de-duplicated */
+    lyricists: string[];
+    producers: string[];
+    /** {role, name} for mastering / mixing / recording (+ "second") engineers */
+    engineers: {
+        role: string;
+        name: string;
+    }[];
+    mixers: string[];
+    /** other performers Deezer credits by role, e.g. background vocalist */
+    performers: {
+        role: string;
+        name: string;
+    }[];
+    publishers: string[];
+}
+/**
+ * Turn Deezer's inconsistent `SNG_CONTRIBUTORS` bag into a stable shape.
+ *
+ * The role keys vary across the catalogue (`main_artist` / `mainartist` /
+ * `artist`, `musicpublisher` / `music publisher`, …) and the value is
+ * occasionally an empty array — this hides all of that.
+ */
+export declare const normalizeContributors: (raw: sngContributors | undefined) => NormalizedContributors;

package/dist/metadata-writer/contributors.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeContributors = void 0;
+/** collapse `Music Publisher`, `music_publisher`, `musicpublisher` → `musicpublisher` */
+const canon = (key) => key.toLowerCase().replace(/[\s_-]+/g, '');
+const ENGINEER_LABELS = {
+    masteringengineer: 'mastering engineer',
+    mixingengineer: 'mixing engineer',
+    recordingengineer: 'recording engineer',
+    recordingsecondengineer: 'assistant recording engineer',
+    assistantengineer: 'assistant engineer',
+    engineer: 'engineer',
+    studiopersonnel: 'engineer',
+};
+const uniq = (arr) => [...new Set(arr.filter((x) => x && x.trim()))].map((x) => x.trim());
+/**
+ * Turn Deezer's inconsistent `SNG_CONTRIBUTORS` bag into a stable shape.
+ *
+ * The role keys vary across the catalogue (`main_artist` / `mainartist` /
+ * `artist`, `musicpublisher` / `music publisher`, …) and the value is
+ * occasionally an empty array — this hides all of that.
+ */
+const normalizeContributors = (raw) => {
+    const out = {
+        mainArtists: [],
+        featuring: [],
+        composers: [],
+        lyricists: [],
+        producers: [],
+        engineers: [],
+        mixers: [],
+        performers: [],
+        publishers: [],
+    };
+    if (!raw || Array.isArray(raw)) {
+        return out;
+    }
+    const bucket = {};
+    for (const [key, value] of Object.entries(raw)) {
+        if (!Array.isArray(value)) {
+            continue;
+        }
+        const k = canon(key);
+        bucket[k] = (bucket[k] || []).concat(value);
+    }
+    out.mainArtists = uniq([...(bucket.mainartist || []), ...(bucket.artist || [])]);
+    out.featuring = uniq([...(bucket.featuring || []), ...(bucket.featuredartist || []), ...(bucket.feat || [])]);
+    out.composers = uniq(bucket.composer || []);
+    out.lyricists = uniq([
+        ...(bucket.author || []),
+        ...(bucket.writer || []),
+        ...(bucket.lyricist || []),
+        ...(bucket.songwriter || []),
+    ]);
+    out.producers = uniq([...(bucket.producer || []), ...(bucket.coproducer || []), ...(bucket.executiveproducer || [])]);
+    out.mixers = uniq([...(bucket.mixer || []), ...(bucket.remixer || [])]);
+    out.publishers = uniq([
+        ...(bucket.publisher || []),
+        ...(bucket.musicpublisher || []),
+        ...(bucket.originalpublisher || []),
+    ]);
+    for (const [canonKey, label] of Object.entries(ENGINEER_LABELS)) {
+        for (const name of uniq(bucket[canonKey] || [])) {
+            out.engineers.push({ role: label, name });
+        }
+    }
+    for (const [canonKey, names] of Object.entries(bucket)) {
+        if (canonKey === 'mainartist' ||
+            canonKey === 'artist' ||
+            canonKey === 'featuring' ||
+            canonKey === 'composer' ||
+            canonKey === 'mixer' ||
+            canonKey === 'producer' ||
+            canonKey in ENGINEER_LABELS ||
+            /publisher|author|writer|lyricist/.test(canonKey)) {
+            continue;
+        }
+        // remaining roles: vocalist, backgroundvocalist, instruments, arranger, …
+        const role = canonKey.replace(/([a-z])([A-Z])/g, '$1 $2');
+        for (const name of uniq(names)) {
+            out.performers.push({ role, name });
+        }
+    }
+    return out;
+};
+exports.normalizeContributors = normalizeContributors;

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

@@ -1,3 +1,12 @@
 /// <reference types="node" />
-import type { albumTypePublicApi, trackType } from '../types';
-export declare const writeMetadataFlac: (buffer: Buffer, track: trackType, album: albumTypePublicApi | null, dimension: number, cover?: Buffer | null) => Buffer;
+import type { TrackTagModel } from './model';
+export interface FlacWriteOptions {
+    /** embed the LRC document as a `SYNCEDLYRICS` Vorbis comment. default true */
+    embedSyncedLyrics?: boolean;
+}
+/**
+ * Write Vorbis comments + PICTURE blocks from the canonical model. Vorbis
+ * comments are free-form, so every field Deezer gives us lands here — including
+ * multi-valued credits (one comment per value) and synced lyrics.
+ */
+export declare const writeMetadataFlac: (buffer: Buffer, m: TrackTagModel, options?: FlacWriteOptions) => Buffer;

package/dist/metadata-writer/flacmetata.js

@@ -5,76 +5,101 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.writeMetadataFlac = void 0;
 const metaflac_js_1 = __importDefault(require("../lib/metaflac-js"));
-const writeMetadataFlac = (buffer, track, album, dimension, cover) => {
+/**
+ * Write Vorbis comments + PICTURE blocks from the canonical model. Vorbis
+ * comments are free-form, so every field Deezer gives us lands here — including
+ * multi-valued credits (one comment per value) and synced lyrics.
+ */
+const writeMetadataFlac = (buffer, m, options = {}) => {
     const flac = new metaflac_js_1.default(buffer);
-    const RELEASE_YEAR = album ? album.release_date.split('-')[0] : null;
-    flac.setTag('TITLE=' + track.SNG_TITLE);
-    flac.setTag('ALBUM=' + track.ALB_TITLE);
-    flac.setTag('ARTIST=' + track.ARTISTS.map((a) => a.ART_NAME).join(', '));
-    flac.setTag('TRACKNUMBER=' + track.TRACK_NUMBER.toLocaleString('en-US', { minimumIntegerDigits: 2 }));
-    if (album) {
-        const TOTALTRACKS = album.nb_tracks.toLocaleString('en-US', { minimumIntegerDigits: 2 });
-        if (album.genres.data.length > 0) {
-            for (const genre of album.genres.data) {
-                flac.setTag('GENRE=' + genre.name);
-            }
-        }
-        flac.setTag('TRACKTOTAL=' + TOTALTRACKS);
-        flac.setTag('TOTALTRACKS=' + TOTALTRACKS);
-        flac.setTag('RELEASETYPE=' + album.record_type);
-        flac.setTag('ALBUMARTIST=' + album.artist.name);
-        flac.setTag('BARCODE=' + album.upc);
-        flac.setTag('LABEL=' + album.label);
-        flac.setTag('DATE=' + album.release_date);
-        flac.setTag('YEAR=' + RELEASE_YEAR);
-        flac.setTag(`COMPILATION=${album.artist.name.match(/various/i) ? '1' : '0'}`);
+    const tag = (key, value) => {
+        if (value !== undefined && value !== null && value !== '')
+            flac.setTag(`${key}=${value}`);
+    };
+    const multi = (key, values) => {
+        for (const v of values)
+            if (v)
+                flac.setTag(`${key}=${v}`);
+    };
+    tag('TITLE', m.title);
+    tag('SUBTITLE', m.subtitle);
+    if (m.subtitle)
+        tag('VERSION', m.subtitle);
+    tag('ALBUM', m.album);
+    multi('ARTIST', m.artists);
+    multi('ARTISTS', m.artists);
+    tag('ALBUMARTIST', m.albumArtist);
+    multi('COMPOSER', m.composers);
+    multi('LYRICIST', m.lyricists);
+    multi('WRITER', m.lyricists);
+    multi('PRODUCER', m.producers);
+    multi('MIXER', [...m.mixers, ...m.engineers.filter((e) => e.role.startsWith('mixing')).map((e) => e.name)]);
+    multi('PUBLISHER', m.publishers);
+    for (const e of m.engineers)
+        tag('ENGINEER', e.name);
+    // one human-readable line keeping the role breakdown (Picard-style)
+    for (const e of m.engineers)
+        tag('CREDITS', `${e.name} (${e.role})`);
+    for (const p of m.performers)
+        tag('PERFORMER', `${p.name} (${p.role})`);
+    multi('FEATURING', m.featuredArtists);
+    tag('TRACKNUMBER', m.trackNumber || '');
+    tag('TRACKTOTAL', m.trackTotal);
+    tag('TOTALTRACKS', m.trackTotal);
+    tag('DISCNUMBER', m.discNumber || '');
+    tag('DISCTOTAL', m.discTotal);
+    tag('TOTALDISCS', m.discTotal);
+    tag('ISRC', m.isrc);
+    tag('BARCODE', m.barcode);
+    tag('LENGTH', Math.round(m.durationMs / 1000) || '');
+    if (m.bpm)
+        tag('BPM', m.bpm);
+    tag('MEDIA', 'Digital Media');
+    multi('GENRE', m.genres);
+    tag('LABEL', m.label);
+    tag('ORGANIZATION', m.label);
+    tag('RELEASETYPE', m.releaseType);
+    tag('COMPILATION', m.isCompilation ? '1' : '0');
+    tag('DATE', m.date);
+    tag('YEAR', m.year);
+    tag('ORIGINALDATE', m.originalDate);
+    tag('ORIGINALYEAR', m.originalYear);
+    tag('COPYRIGHT', m.copyright);
+    tag('PRODUCERLINE', m.producerLine);
+    tag('REPLAYGAIN_TRACK_GAIN', m.replayGainTrackGain);
+    tag('ITUNESADVISORY', m.itunesAdvisory);
+    if (m.explicit !== 'unknown')
+        tag('EXPLICIT', m.explicit === 'explicit' ? '1' : '0');
+    // `LYRICS` carries the synced LRC when we have it (players auto-detect the
+    // timestamps); `UNSYNCEDLYRICS` is always the plain fallback.
+    const synced = m.lyricsSynced && options.embedSyncedLyrics !== false ? m.lyricsSynced : null;
+    if (synced || m.lyrics) {
+        tag('LYRICS', synced || m.lyrics);
     }
-    if (track.DISK_NUMBER) {
-        flac.setTag('DISCNUMBER=' + track.DISK_NUMBER);
+    if (m.lyrics) {
+        tag('UNSYNCEDLYRICS', m.lyrics);
     }
-    flac.setTag('ISRC=' + track.ISRC);
-    flac.setTag('LENGTH=' + track.DURATION);
-    flac.setTag('MEDIA=Digital Media');
-    if (track.LYRICS) {
-        flac.setTag('LYRICS=' + track.LYRICS.LYRICS_TEXT);
+    tag('LYRICS_WRITER', m.lyricsWriters);
+    tag('LYRICS_COPYRIGHT', m.lyricsCopyright);
+    if (m.rank !== undefined)
+        tag('DEEZER_RANK', m.rank);
+    tag('SOURCE', 'Deezer');
+    if (m.ids.deezerTrack) {
+        tag('SOURCEID', m.ids.deezerTrack);
+        tag('DEEZER_TRACK_ID', m.ids.deezerTrack);
     }
-    if (track.EXPLICIT_LYRICS) {
-        flac.setTag('EXPLICIT=' + track.EXPLICIT_LYRICS);
+    tag('DEEZER_ALBUM_ID', m.ids.deezerAlbum);
+    tag('DEEZER_ARTIST_ID', m.ids.deezerArtist);
+    tag('DEEZER_LABEL_ID', m.ids.labelId);
+    tag('DEEZER_PROVIDER_ID', m.ids.providerId);
+    if (m.ids.slug)
+        tag('WEBSITE', `https://www.deezer.com/track/${m.ids.deezerTrack}`);
+    if (m.cover) {
+        flac.importPicture(m.cover, m.coverSize, 'image/jpeg', 3, 'Front cover');
     }
-    if (track.SNG_CONTRIBUTORS && !Array.isArray(track.SNG_CONTRIBUTORS)) {
-        if (track.SNG_CONTRIBUTORS.main_artist) {
-            flac.setTag(`COPYRIGHT=${RELEASE_YEAR ? RELEASE_YEAR + ' ' : ''}${track.SNG_CONTRIBUTORS.main_artist[0]}`);
-        }
-        if (track.SNG_CONTRIBUTORS.publisher) {
-            flac.setTag('ORGANIZATION=' + track.SNG_CONTRIBUTORS.publisher.join(', '));
-        }
-        if (track.SNG_CONTRIBUTORS.composer) {
-            flac.setTag('COMPOSER=' + track.SNG_CONTRIBUTORS.composer.join(', '));
-        }
-        if (track.SNG_CONTRIBUTORS.publisher) {
-            flac.setTag('ORGANIZATION=' + track.SNG_CONTRIBUTORS.publisher.join(', '));
-        }
-        if (track.SNG_CONTRIBUTORS.producer) {
-            flac.setTag('PRODUCER=' + track.SNG_CONTRIBUTORS.producer.join(', '));
-        }
-        if (track.SNG_CONTRIBUTORS.engineer) {
-            flac.setTag('ENGINEER=' + track.SNG_CONTRIBUTORS.engineer.join(', '));
-        }
-        if (track.SNG_CONTRIBUTORS.writer) {
-            flac.setTag('WRITER=' + track.SNG_CONTRIBUTORS.writer.join(', '));
-        }
-        if (track.SNG_CONTRIBUTORS.author) {
-            flac.setTag('AUTHOR=' + track.SNG_CONTRIBUTORS.author.join(', '));
-        }
-        if (track.SNG_CONTRIBUTORS.mixer) {
-            flac.setTag('MIXER=' + track.SNG_CONTRIBUTORS.mixer.join(', '));
-        }
+    if (m.artistImage) {
+        flac.importPicture(m.artistImage, 1000, 'image/jpeg', 8, 'Artist');
     }
-    if (cover) {
-        flac.importPicture(cover, dimension, 'image/jpeg');
-    }
-    flac.setTag('SOURCE=Deezer');
-    flac.setTag('SOURCEID=' + track.SNG_ID);
     return flac.getBuffer();
 };
 exports.writeMetadataFlac = writeMetadataFlac;

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

@@ -1,3 +1,9 @@
 /// <reference types="node" />
-import type { albumTypePublicApi, trackType } from '../types';
-export declare const writeMetadataMp3: (buffer: Buffer, track: trackType, album: albumTypePublicApi | null, cover?: Buffer | null) => Buffer;
+import type { TrackTagModel } from './model';
+/**
+ * Write an ID3v2.3 tag from the canonical model. `browser-id3-writer` is a v2.3
+ * writer, so there is no `SYLT` (synced lyrics) or `TDRC`/`TDOR` — synced lyrics
+ * ship as a `.lrc` sidecar from the CLI, and dates use `TYER`/`TDAT` plus
+ * `TXXX:ORIGINALDATE`.
+ */
+export declare const writeMetadataMp3: (buffer: Buffer, m: TrackTagModel) => Buffer;