gerdur-core 1.0.3 → 2.0.0

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;

package/dist/metadata-writer/id3.js

@@ -6,114 +6,121 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.writeMetadataMp3 = void 0;
 // @ts-ignore
 const browser_id3_writer_1 = __importDefault(require("browser-id3-writer"));
-const writeMetadataMp3 = (buffer, track, album, cover) => {
-    const writer = new browser_id3_writer_1.default(buffer);
-    const RELEASE_DATES = album && album.release_date.split('-');
-    writer
-        .setFrame('TIT2', track.SNG_TITLE)
-        .setFrame('TALB', track.ALB_TITLE)
-        .setFrame('TPE1', track.ARTISTS.map((a) => a.ART_NAME))
-        .setFrame('TLEN', Number(track.DURATION) * 1000)
-        .setFrame('TSRC', track.ISRC);
-    if (album) {
-        if (album.genres.data.length > 0) {
-            writer.setFrame('TCON', album.genres.data.map((g) => g.name));
-        }
-        if (RELEASE_DATES) {
-            writer.setFrame('TYER', RELEASE_DATES[0]).setFrame('TDAT', RELEASE_DATES[2] + RELEASE_DATES[1]);
-        }
-        writer
-            .setFrame('TPE2', album.artist.name)
-            .setFrame('TXXX', {
-            description: 'RELEASETYPE',
-            value: album.record_type,
-        })
-            .setFrame('TXXX', {
-            description: 'BARCODE',
-            value: album.upc,
-        })
-            .setFrame('TXXX', {
-            description: 'LABEL',
-            value: album.label,
-        })
-            .setFrame('TXXX', {
-            description: 'COMPILATION',
-            value: album.artist.name.match(/various/i) ? '1' : '0',
-        });
+const join = (arr) => arr.filter(Boolean).join('; ');
+/**
+ * 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`.
+ */
+const writeMetadataMp3 = (buffer, m) => {
+    const w = new browser_id3_writer_1.default(buffer);
+    const txxx = (description, value) => {
+        const v = Array.isArray(value) ? join(value) : value;
+        if (v)
+            w.setFrame('TXXX', { description, value: v });
+    };
+    w.setFrame('TIT2', m.title);
+    if (m.subtitle)
+        w.setFrame('TIT3', m.subtitle);
+    w.setFrame('TALB', m.album);
+    if (m.artists.length)
+        w.setFrame('TPE1', m.artists);
+    if (m.albumArtist)
+        w.setFrame('TPE2', m.albumArtist);
+    if (m.composers.length)
+        w.setFrame('TCOM', m.composers);
+    if (m.lyricists.length)
+        w.setFrame('TEXT', join(m.lyricists));
+    if (m.mixers.length)
+        w.setFrame('TPE4', join(m.mixers));
+    if (m.genres.length)
+        w.setFrame('TCON', m.genres);
+    if (m.label)
+        w.setFrame('TPUB', m.label);
+    if (m.isrc)
+        w.setFrame('TSRC', m.isrc);
+    if (m.durationMs)
+        w.setFrame('TLEN', m.durationMs);
+    if (m.bpm)
+        w.setFrame('TBPM', Math.round(m.bpm));
+    w.setFrame('TMED', 'Digital Media');
+    if (m.trackNumber) {
+        w.setFrame('TRCK', m.trackTotal ? `${m.trackNumber}/${m.trackTotal}` : String(m.trackNumber));
     }
-    writer
-        .setFrame('TMED', 'Digital Media')
-        .setFrame('TXXX', {
-        description: 'SOURCE',
-        value: 'Deezer',
-    })
-        .setFrame('TXXX', {
-        description: 'SOURCEID',
-        value: track.SNG_ID,
-    });
-    if (track.DISK_NUMBER) {
-        const TRACK_NUMBER = track.TRACK_NUMBER.toLocaleString('en-US', { minimumIntegerDigits: 2 });
-        writer.setFrame('TPOS', track.DISK_NUMBER).setFrame('TRCK', album
-            ? `${TRACK_NUMBER}/${album.nb_tracks.toLocaleString('en-US', {
-                minimumIntegerDigits: 2,
-            })}`
-            : TRACK_NUMBER);
+    if (m.discNumber) {
+        w.setFrame('TPOS', m.discTotal ? `${m.discNumber}/${m.discTotal}` : String(m.discNumber));
     }
-    if (track.SNG_CONTRIBUTORS && !Array.isArray(track.SNG_CONTRIBUTORS)) {
-        if (track.SNG_CONTRIBUTORS.main_artist) {
-            writer.setFrame('TCOP', `${RELEASE_DATES ? RELEASE_DATES[0] + ' ' : ''}${track.SNG_CONTRIBUTORS.main_artist[0]}`);
-        }
-        if (track.SNG_CONTRIBUTORS.publisher) {
-            writer.setFrame('TPUB', track.SNG_CONTRIBUTORS.publisher.join(', '));
-        }
-        if (track.SNG_CONTRIBUTORS.composer) {
-            writer.setFrame('TCOM', track.SNG_CONTRIBUTORS.composer);
-        }
-        if (track.SNG_CONTRIBUTORS.writer) {
-            writer.setFrame('TXXX', {
-                description: 'LYRICIST',
-                value: track.SNG_CONTRIBUTORS.writer.join(', '),
-            });
-        }
-        if (track.SNG_CONTRIBUTORS.author) {
-            writer.setFrame('TXXX', {
-                description: 'AUTHOR',
-                value: track.SNG_CONTRIBUTORS.author.join(', '),
-            });
-        }
-        if (track.SNG_CONTRIBUTORS.mixer) {
-            writer.setFrame('TXXX', {
-                description: 'MIXARTIST',
-                value: track.SNG_CONTRIBUTORS.mixer.join(', '),
-            });
-        }
-        if (track.SNG_CONTRIBUTORS.producer && track.SNG_CONTRIBUTORS.engineer) {
-            writer.setFrame('TXXX', {
-                description: 'INVOLVEDPEOPLE',
-                value: track.SNG_CONTRIBUTORS.producer.concat(track.SNG_CONTRIBUTORS.engineer).join(', '),
-            });
-        }
+    if (m.year)
+        w.setFrame('TYER', Number(m.year));
+    if (m.date && /^\d{4}-\d{2}-\d{2}$/.test(m.date)) {
+        const [, mm, dd] = m.date.split('-');
+        w.setFrame('TDAT', Number(dd + mm));
     }
-    if (track.LYRICS) {
-        writer.setFrame('USLT', {
-            description: '',
-            lyrics: track.LYRICS.LYRICS_TEXT,
-        });
+    if (m.copyright)
+        w.setFrame('TCOP', m.copyright);
+    // v2.3 has no native frames for these — user-defined text, Picard-compatible keys
+    txxx('DATE', m.date || '');
+    txxx('ORIGINALDATE', m.originalDate || '');
+    txxx('ORIGINALYEAR', m.originalYear || '');
+    txxx('BARCODE', m.barcode || '');
+    if (m.bpm)
+        txxx('BPM', String(m.bpm));
+    txxx('RELEASETYPE', m.releaseType || '');
+    txxx('COMPILATION', m.isCompilation ? '1' : '0');
+    txxx('ITUNESADVISORY', String(m.itunesAdvisory));
+    if (m.explicit !== 'unknown')
+        txxx('EXPLICIT', m.explicit === 'explicit' ? '1' : '0');
+    if (m.replayGainTrackGain)
+        txxx('REPLAYGAIN_TRACK_GAIN', m.replayGainTrackGain);
+    if (m.artists.length > 1)
+        txxx('ARTISTS', m.artists);
+    if (m.featuredArtists.length)
+        txxx('FEATURING', m.featuredArtists);
+    txxx('PRODUCER', m.producers);
+    txxx('MIXER', m.mixers);
+    txxx('PUBLISHER', m.publishers);
+    if (m.engineers.length) {
+        txxx('ENGINEER', m.engineers.map((e) => e.name));
+        txxx('INVOLVEDPEOPLE', m.engineers.map((e) => `${e.name} (${e.role})`));
     }
-    if (track.EXPLICIT_LYRICS) {
-        writer.setFrame('TXXX', {
-            description: 'EXPLICIT',
-            value: track.EXPLICIT_LYRICS,
-        });
+    if (m.performers.length) {
+        txxx('PERFORMER', m.performers.map((p) => `${p.name} (${p.role})`));
     }
-    if (cover) {
-        writer.setFrame('APIC', {
-            type: 3,
-            data: cover,
-            description: '',
-        });
+    if (m.lyricsWriters)
+        txxx('LYRICIST', m.lyricsWriters);
+    if (m.lyricsCopyright)
+        txxx('LYRICS_COPYRIGHT', m.lyricsCopyright);
+    if (m.producerLine)
+        txxx('PRODUCERLINE', m.producerLine);
+    if (m.rank !== undefined)
+        txxx('DEEZER_RANK', String(m.rank));
+    txxx('SOURCE', 'Deezer');
+    if (m.ids.deezerTrack) {
+        txxx('SOURCEID', m.ids.deezerTrack);
+        txxx('DEEZER_TRACK_ID', m.ids.deezerTrack);
+        w.setFrame('WOAS', `https://www.deezer.com/track/${m.ids.deezerTrack}`);
     }
-    writer.addTag();
-    return Buffer.isBuffer(writer.arrayBuffer) ? writer.arrayBuffer : Buffer.from(writer.arrayBuffer);
+    if (m.ids.deezerAlbum)
+        txxx('DEEZER_ALBUM_ID', m.ids.deezerAlbum);
+    if (m.ids.deezerArtist) {
+        txxx('DEEZER_ARTIST_ID', m.ids.deezerArtist);
+        w.setFrame('WOAR', `https://www.deezer.com/artist/${m.ids.deezerArtist}`);
+    }
+    if (m.ids.labelId)
+        txxx('DEEZER_LABEL_ID', m.ids.labelId);
+    if (m.ids.providerId)
+        txxx('DEEZER_PROVIDER_ID', m.ids.providerId);
+    if (m.lyrics) {
+        w.setFrame('USLT', { description: '', lyrics: m.lyrics, language: 'eng' });
+    }
+    if (m.cover) {
+        w.setFrame('APIC', { type: 3, data: m.cover, description: 'Front cover' });
+    }
+    if (m.artistImage) {
+        w.setFrame('APIC', { type: 8, data: m.artistImage, description: 'Artist' });
+    }
+    w.addTag();
+    return Buffer.isBuffer(w.arrayBuffer) ? w.arrayBuffer : Buffer.from(w.arrayBuffer);
 };
 exports.writeMetadataMp3 = writeMetadataMp3;