plx-converter 0.1.0

package/dist/converter.js

@@ -0,0 +1,115 @@
+import { EMBED_TRACK_LIMIT, readPlaylist } from './spotify.js';
+import { writeCsv } from './csv.js';
+export class Converter {
+    deezer;
+    spotifyToken;
+    rows = [];
+    output;
+    constructor(deezer, spotifyToken, output) {
+        this.deezer = deezer;
+        this.spotifyToken = spotifyToken;
+        this.output = output;
+    }
+    record(row) { this.rows.push(row); }
+    async matchPlaylist(playlist, dryRun = false) {
+        let result;
+        try {
+            result = await readPlaylist(playlist.uri, this.spotifyToken);
+        }
+        catch (error) {
+            this.record({ playlist: playlist.name, title: '', artist: '', isrc: null, matched: false, note: `gagal baca playlist: ${error instanceof Error ? error.name : 'Error'}` });
+            return { matchedIds: [], total: 0, truncated: false };
+        }
+        if (result.truncated) {
+            this.record({ playlist: playlist.name, title: '', artist: '', isrc: null, matched: false, note: `PERINGATAN: terpotong di ${EMBED_TRACK_LIMIT} lagu; sisanya tidak dikonversi` });
+            console.log(`[${playlist.name}] ⚠️ Terpotong di ${EMBED_TRACK_LIMIT} lagu (fallback embed).`);
+        }
+        const matchedIds = [];
+        for (let i = 0; i < result.tracks.length; i += 1) {
+            const track = result.tracks[i];
+            let match = null;
+            for (let attempt = 0; attempt < 3; attempt += 1) {
+                try {
+                    match = await this.deezer.search(track);
+                    break;
+                }
+                catch (error) {
+                    if (attempt === 2)
+                        console.log(`  ⚠️ search gagal: ${error instanceof Error ? error.name : 'Error'}`);
+                    else
+                        await new Promise((resolve) => setTimeout(resolve, 2 ** attempt * 1000));
+                }
+            }
+            if (match) {
+                matchedIds.push(match.id);
+                this.record({ playlist: playlist.name, title: track.name, artist: track.artist, isrc: null, matched: true, deezer_id: match.id, method: match.method, note: dryRun ? 'dry-run' : null });
+                console.log(`  [${i + 1}/${result.tracks.length}] ✓ ${match.method} — ${track.name} — ${track.artist}`);
+            }
+            else {
+                this.record({ playlist: playlist.name, title: track.name, artist: track.artist, isrc: null, matched: false, note: dryRun ? 'dry-run: tidak ketemu' : 'tidak ketemu' });
+                console.log(`  [${i + 1}/${result.tracks.length}] ✗ tidak ditemukan — ${track.name} — ${track.artist}`);
+            }
+            await new Promise((resolve) => setTimeout(resolve, 300));
+        }
+        console.log(`[${playlist.name}] ${matchedIds.length}/${result.tracks.length} lagu cocok.`);
+        return { matchedIds, total: result.tracks.length, truncated: result.truncated };
+    }
+    async writePlaylist(name, ids, title = `[plx] ${name}`) {
+        if (!ids.length) {
+            console.log(`[${name}] Tidak ada lagu yang cocok — playlist tidak dibuat.`);
+            return;
+        }
+        const id = await this.deezer.createPlaylist(title);
+        const unique = [...new Set(ids)];
+        for (let start = 0; start < unique.length; start += 100) {
+            await this.deezer.addTracks(id, unique.slice(start, start + 100));
+            await new Promise((resolve) => setTimeout(resolve, 200));
+        }
+        console.log(`[${name}] playlist Deezer dibuat: ${title} (${unique.length} lagu)`);
+    }
+    // Append to an existing playlist, skipping tracks already present (dedupe), then reorder 1:1.
+    async writeToExisting(name, playlistId, ids) {
+        if (!ids.length) {
+            console.log(`[${name}] Tidak ada lagu yang cocok.`);
+            return;
+        }
+        const existing = await this.deezer.getPlaylistTrackIds(playlistId);
+        // Dedupe within the batch too — Deezer rejects any chunk containing a repeated id.
+        const unique = [...new Set(ids)];
+        const batchDupes = ids.length - unique.length;
+        const alreadyThere = unique.filter((id) => existing.has(id)).length;
+        const toAdd = unique.filter((id) => !existing.has(id));
+        let added = 0;
+        if (toAdd.length) {
+            for (let start = 0; start < toAdd.length; start += 100) {
+                added += await this.deezer.addTracks(playlistId, toAdd.slice(start, start + 100));
+                await new Promise((resolve) => setTimeout(resolve, 200));
+            }
+        }
+        const parts = [];
+        if (alreadyThere)
+            parts.push(`${alreadyThere} sudah ada`);
+        if (batchDupes)
+            parts.push(`${batchDupes} duplikat dihilangkan`);
+        console.log(`[${name}] ${added} lagu baru ditambahkan${parts.length ? ` (${parts.join(', ')})` : ''}.`);
+        await this.reorderToMatch(name, playlistId, ids);
+    }
+    // Reorder the target to mirror the source order (1:1 sync). Moves each matched track into place
+    // from the front, so matched tracks land in source order and anything extra is pushed to the end.
+    async reorderToMatch(name, playlistId, ids) {
+        const desired = [...new Set(ids)].filter((id) => id);
+        if (desired.length < 2)
+            return;
+        const current = await this.deezer.getPlaylistTrackOrder(playlistId);
+        const movable = new Set(desired);
+        const kept = current.filter((id) => movable.has(id));
+        if (kept.length === desired.length && desired.every((id, i) => kept[i] === id))
+            return;
+        for (let i = 0; i < desired.length; i += 1) {
+            await this.deezer.moveTrack(playlistId, desired[i], i === 0 ? null : desired[i - 1]);
+            await new Promise((resolve) => setTimeout(resolve, 100));
+        }
+        console.log(`[${name}] urutan playlist disamakan dengan sumber.`);
+    }
+    async writeReport() { await writeCsv(this.output, this.rows); }
+}

package/dist/csv.js

@@ -0,0 +1,10 @@
+import { writeFile } from 'node:fs/promises';
+const fields = ['playlist', 'title', 'artist', 'isrc', 'matched', 'deezer_id', 'method', 'note'];
+const cell = (value) => {
+    const text = value == null ? '' : String(value);
+    return /[",\n]/.test(text) ? `"${text.replaceAll('"', '""')}"` : text;
+};
+export async function writeCsv(path, rows) {
+    const lines = [fields.join(','), ...rows.map((row) => fields.map((field) => cell(row[field])).join(','))];
+    await writeFile(path, `${lines.join('\n')}\n`, 'utf8');
+}

package/dist/deezer.js

@@ -0,0 +1,145 @@
+import { z } from 'zod';
+import { fetchJson, retry } from './http.js';
+import { firstArtist, matchCandidates, searchQuery, stripFeat } from './matcher.js';
+const gqlSchema = z.object({ errors: z.array(z.object({ message: z.string() })).optional(), data: z.unknown() });
+const API = 'https://api.deezer.com';
+const GQL = 'https://pipe.deezer.com/api';
+export function parseDeezerPlaylistId(ref) {
+    const input = ref.trim();
+    if (input.includes('deezer.com'))
+        return new URL(input).pathname.replace(/\/+$/, '').split('/').pop() ?? input;
+    return input;
+}
+// Resolve a Deezer share shortlink (link.deezer.com/s/<code>) to its playlist id.
+export async function resolveDeezerPlaylistId(ref) {
+    const input = ref.trim();
+    if (input.includes('link.deezer.com')) {
+        const response = await fetch(input);
+        const match = decodeURIComponent(response.url).match(/playlist\/(\d+)/);
+        if (match)
+            return match[1];
+    }
+    return parseDeezerPlaylistId(input);
+}
+function jwtExpiryMs(jwt) {
+    try {
+        const payload = jwt.split('.')[1];
+        const padded = payload + '='.repeat((4 - (payload.length % 4)) % 4);
+        const decoded = JSON.parse(Buffer.from(padded, 'base64url').toString('utf8'));
+        return typeof decoded.exp === 'number' && decoded.exp > 0 ? decoded.exp * 1000 : Date.now() + 3600_000;
+    }
+    catch {
+        return Date.now() + 3600_000;
+    }
+}
+export class DeezerClient {
+    arl;
+    jwt;
+    jwtExpiresAt = 0;
+    constructor(arl) {
+        this.arl = arl;
+    }
+    async auth(force = false) {
+        if (!force && this.jwt && Date.now() < this.jwtExpiresAt - 30_000)
+            return this.jwt;
+        const response = await fetch('https://auth.deezer.com/login/arl?jo=p&rto=c&i=c', { method: 'POST', headers: { Cookie: `arl=${this.arl}` } });
+        if (!response.ok)
+            throw new Error(`Deezer auth failed: ${response.status}`);
+        const data = await response.json();
+        if (!data.jwt)
+            throw new Error('Deezer JWT missing');
+        this.jwt = data.jwt;
+        this.jwtExpiresAt = jwtExpiryMs(data.jwt);
+        return this.jwt;
+    }
+    async gql(query, operationName, variables) {
+        const run = async (jwt) => gqlSchema.parse(await fetchJson(GQL, { method: 'POST', headers: { Authorization: `Bearer ${jwt}`, 'Content-Type': 'application/json' }, body: JSON.stringify({ query, operationName, variables }) }));
+        let data = await run(await this.auth());
+        if (data.errors?.length && /not valid anymore|re-authenticate/i.test(data.errors[0].message))
+            data = await run(await this.auth(true));
+        if (data.errors?.length)
+            throw new Error(`${operationName}: ${data.errors[0].message}`);
+        return data.data;
+    }
+    async getMe() { return this.gql('query GetMe { me { id } }', 'GetMe', {}).then((x) => x.me); }
+    async search(track) {
+        const toCandidates = (data) => data.data.map((x) => ({ id: String(x.id), title: x.title, artist: x.artist.name, duration: x.duration }));
+        const free = `${API}/search?${new URLSearchParams({ q: searchQuery(track.name, track.artist), limit: '5' })}`;
+        const data = await retry(async () => fetchJson(free));
+        const match = matchCandidates(track.name, track.artist, track.durationMs, toCandidates(data));
+        if (match)
+            return match;
+        // Free-text relevance ranks covers/remixes above the real K-pop track; fall back to field syntax.
+        const field = `${API}/search?${new URLSearchParams({ q: `track:"${stripFeat(track.name)}" artist:"${firstArtist(track.artist)}"`, limit: '5' })}`;
+        const data2 = await retry(async () => fetchJson(field));
+        const match2 = matchCandidates(track.name, track.artist, track.durationMs, toCandidates(data2));
+        if (match2)
+            return match2;
+        return this.searchByAlbum(track);
+    }
+    // Artist → albums → album tracks, for tracks the search index never surfaces (e.g. "Salty & Sweet").
+    async searchByAlbum(track) {
+        const artistName = firstArtist(track.artist);
+        const artistRes = await retry(async () => fetchJson(`${API}/search/artist?${new URLSearchParams({ q: artistName, limit: '1' })}`));
+        const artist = artistRes.data[0];
+        if (!artist)
+            return null;
+        const albumsRes = await retry(async () => fetchJson(`${API}/artist/${artist.id}/albums?${new URLSearchParams({ limit: '50' })}`));
+        for (const album of albumsRes.data.slice(0, 25)) {
+            const tracksRes = await retry(async () => fetchJson(`${API}/album/${album.id}/tracks?${new URLSearchParams({ limit: '50' })}`));
+            const m = matchCandidates(track.name, track.artist, track.durationMs, tracksRes.data.map((x) => ({ id: String(x.id), title: x.title, artist: x.artist.name, duration: x.duration })));
+            if (m)
+                return m;
+        }
+        return null;
+    }
+    async createPlaylist(title) { const x = await this.gql('mutation CreatePlaylist($title:String!,$description:String="",$isPrivate:Boolean!=false,$isCollaborative:Boolean!=false){createPlaylist(input:{title:$title,description:$description,isPrivate:$isPrivate,isCollaborative:$isCollaborative}){playlist{id title}}}', 'CreatePlaylist', { title, description: '', isPrivate: true, isCollaborative: false }); return x.createPlaylist.playlist.id; }
+    async addTracks(id, trackIds) {
+        const x = await this.gql('mutation AddTracksToPlaylist($playlistId:String!,$trackIds:[String!]!){addTracksToPlaylist(input:{playlistId:$playlistId,trackIds:$trackIds}){__typename ... on PlaylistAddTracksOutput{addedTrackIds} ... on PlaylistAddTracksError{isNotAllowed}}}', 'AddTracksToPlaylist', { playlistId: id, trackIds });
+        const out = x.addTracksToPlaylist;
+        if (out.__typename === 'PlaylistAddTracksError')
+            throw new Error(out.isNotAllowed ? 'Tidak diizinkan mengubah playlist ini (bukan milikmu / hanya di-follow)' : 'Gagal menambah lagu');
+        if (!out.addedTrackIds || out.addedTrackIds.length !== trackIds.length)
+            throw new Error(`Hanya ${out.addedTrackIds?.length ?? 0}/${trackIds.length} lagu yang benar-benar ditambahkan`);
+        return out.addedTrackIds.length;
+    }
+    // The user's own playlists. ponytail: capped at first 50 — personal use, paginate only if someone hits it.
+    async listPlaylists() {
+        const data = await this.gql('query GetUserPlaylists($first:Int=50){me{playlists(first:$first){edges{node{id title}}}}}', 'GetUserPlaylists', { first: 50 });
+        return data.me.playlists.edges.map((e) => e.node);
+    }
+    // Full set of track ids currently in a playlist (paginated) — needed for dedupe.
+    async getPlaylistTrackIds(playlistId) {
+        return new Set(await this.getPlaylistTrackOrder(playlistId));
+    }
+    // Ordered list of track ids currently in a playlist (paginated) — preserves order.
+    async getPlaylistTrackOrder(playlistId) {
+        const ids = [];
+        let after = null;
+        for (;;) {
+            const data = await this.gql('query GetPlaylist($playlistId:String!,$first:Int=50,$after:String){playlist(playlistId:$playlistId){tracks(first:$first,after:$after){edges{node{id}} pageInfo{hasNextPage endCursor}}}}', 'GetPlaylist', { playlistId, first: 50, after });
+            for (const e of data.playlist.tracks.edges)
+                ids.push(e.node.id);
+            if (!data.playlist.tracks.pageInfo.hasNextPage || !data.playlist.tracks.pageInfo.endCursor)
+                return ids;
+            after = data.playlist.tracks.pageInfo.endCursor;
+        }
+    }
+    // Full track metadata (title/artist/duration) in playlist order — source read for the reverse flow.
+    async getPlaylistTracks(playlistId) {
+        const tracks = [];
+        let after = null;
+        for (;;) {
+            const data = await this.gql('query GetPlaylistTracks($playlistId:String!,$first:Int=50,$after:String){playlist(playlistId:$playlistId){tracks(first:$first,after:$after){edges{node{id title duration contributorNames}} pageInfo{hasNextPage endCursor}}}}', 'GetPlaylistTracks', { playlistId, first: 50, after });
+            for (const e of data.playlist.tracks.edges)
+                tracks.push({ name: e.node.title, artist: e.node.contributorNames[0] ?? '', durationMs: e.node.duration * 1000 });
+            if (!data.playlist.tracks.pageInfo.hasNextPage || !data.playlist.tracks.pageInfo.endCursor)
+                return tracks;
+            after = data.playlist.tracks.pageInfo.endCursor;
+        }
+    }
+    // Move a track to be after `afterTrackId` (null = move to front).
+    async moveTrack(playlistId, trackId, afterTrackId) {
+        await this.gql('mutation MoveTrackInPlaylist($playlistId:String!,$trackId:String!,$afterTrackId:String){moveTrackInPlaylist(input:{playlistId:$playlistId,trackId:$trackId,afterTrackId:$afterTrackId}){__typename}}', 'MoveTrackInPlaylist', { playlistId, trackId, afterTrackId });
+    }
+}

package/dist/http.js

@@ -0,0 +1,39 @@
+export class HttpError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+        this.name = 'HttpError';
+    }
+}
+export async function fetchText(url, init = {}, timeoutMs = 30_000) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const response = await fetch(url, { ...init, signal: controller.signal });
+        if (!response.ok)
+            throw new HttpError(response.status, `${response.status} ${response.statusText}`);
+        return await response.text();
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+export async function fetchJson(url, init = {}, timeoutMs = 30_000) {
+    return JSON.parse(await fetchText(url, init, timeoutMs));
+}
+export async function retry(operation, attempts = 3) {
+    for (let attempt = 0;; attempt += 1) {
+        try {
+            return await operation();
+        }
+        catch (error) {
+            if (attempt >= attempts - 1)
+                throw error;
+            await new Promise((resolve) => setTimeout(resolve, 2 ** attempt * 1000));
+        }
+    }
+}
+export const browserHeaders = {
+    'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 Chrome/126.0.0.0 Safari/537.36',
+};

package/dist/index.js

@@ -0,0 +1,2 @@
+export * from './types.js';
+export * from './matcher.js';

package/dist/matcher.js

@@ -0,0 +1,25 @@
+export function normalize(value) {
+    return value.normalize('NFKD').replace(/\p{M}/gu, '').toLowerCase().replace(/\(.*?\)/g, '').replace(/[\[(]\s*(feat\.?|ft\.?)\s*/gi, '').replace(/\]/g, '').replace(/[^\p{L}\p{N}_\s]/gu, '').replace(/\s+/g, ' ').trim();
+}
+export function firstArtist(artist) { return artist.split(',')[0].trim(); }
+function artistKey(artist) { return normalize(artist).replace(/\s+/g, ''); }
+export function stripFeat(title) { return title.replace(/\s*[([]\s*(feat|ft)\.?[^)\]]*[)\]]/gi, '').trim(); }
+export function matchDurationMs(spotifyMs, deezerSec, toleranceMs = 3000) { return spotifyMs == null || deezerSec == null || Math.abs(spotifyMs - deezerSec * 1000) <= toleranceMs; }
+export function searchQuery(title, artist) { return `${firstArtist(artist)} ${stripFeat(title)}`.trim(); }
+export function matchCandidates(title, artist, durationMs, candidates) {
+    const nt = normalize(stripFeat(title));
+    const na = artistKey(firstArtist(artist));
+    for (const c of candidates)
+        if (nt === normalize(c.title) && na === artistKey(c.artist) && matchDurationMs(durationMs, c.duration))
+            return { id: c.id, title: c.title, artist: c.artist, method: 'exact' };
+    for (const c of candidates)
+        if (nt === normalize(c.title) && na === artistKey(c.artist))
+            return { id: c.id, title: c.title, artist: c.artist, method: 'fuzzy-duration' };
+    for (const c of candidates) {
+        const ct = normalize(c.title);
+        if (na === artistKey(c.artist) && nt && ct && (nt.includes(ct) || ct.includes(nt)))
+            return { id: c.id, title: c.title, artist: c.artist, method: 'fuzzy-title' };
+    }
+    return null;
+}
+export function matchTrack(track, candidates) { return matchCandidates(track.name, track.artist, track.durationMs, candidates); }

package/dist/reverse.js

@@ -0,0 +1,87 @@
+import { addTracks, createPlaylist, fetchTrackUris, resolveTrackMeta, searchTrack } from './spotify.js';
+import { matchCandidates, searchQuery } from './matcher.js';
+import { writeCsv } from './csv.js';
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+// Match a Deezer playlist's tracks to Spotify track URIs, then resolve each matched
+// URI back to its real Spotify metadata and compare to the source. `verified` counts
+// matches whose resolved title+artist still match the source (precision); a matched
+// URI whose metadata diverges is flagged `note: '⚠️ cek ulang (mungkin salah track)'`.
+export async function reverseMatch(deezer, token, sourceId, sourceName) {
+    const tracks = await deezer.getPlaylistTracks(sourceId);
+    const rows = [];
+    const matchedUris = [];
+    let verified = 0;
+    for (let i = 0; i < tracks.length; i += 1) {
+        const track = tracks[i];
+        let match = null;
+        for (let attempt = 0; attempt < 3; attempt += 1) {
+            try {
+                const candidates = await searchTrack(searchQuery(track.name, track.artist), token);
+                match = matchCandidates(track.name, track.artist, track.durationMs, candidates);
+                break;
+            }
+            catch (error) {
+                if (attempt === 2)
+                    console.log(`  ⚠️ search gagal: ${error instanceof Error ? error.name : 'Error'}`);
+                else
+                    await sleep(2 ** attempt * 1000);
+            }
+        }
+        if (match) {
+            let note = null;
+            try {
+                const meta = await resolveTrackMeta(match.id);
+                if (matchCandidates(track.name, track.artist, track.durationMs, [{ id: match.id, title: meta.name, artist: meta.artist, duration: meta.durationMs != null ? Math.round(meta.durationMs / 1000) : null }]))
+                    verified += 1;
+                else
+                    note = '⚠️ cek ulang (mungkin salah track)';
+            }
+            catch {
+                note = '⚠️ verifikasi gagal';
+            }
+            matchedUris.push(match.id);
+            rows.push({ playlist: sourceName, title: track.name, artist: track.artist, isrc: null, matched: true, deezer_id: match.id, method: match.method, note });
+            console.log(`  [${i + 1}/${tracks.length}] ✓ ${match.method} — ${track.name} — ${track.artist}${note ? ` — ${note}` : ''}`);
+        }
+        else {
+            rows.push({ playlist: sourceName, title: track.name, artist: track.artist, isrc: null, matched: false, note: 'tidak ketemu' });
+            console.log(`  [${i + 1}/${tracks.length}] ✗ tidak ditemukan — ${track.name} — ${track.artist}`);
+        }
+        await sleep(300);
+    }
+    const missed = tracks.length - matchedUris.length;
+    console.log(`[${sourceName}] ${matchedUris.length}/${tracks.length} cocok (${verified} terverifikasi${missed ? `, ${missed} gagal match` : ''}).`);
+    return { rows, matchedUris, total: tracks.length };
+}
+// Deezer playlist (source) → new Spotify playlist (target).
+export async function reverseConvert(deezer, token, sourceId, sourceName, output) {
+    const { rows, matchedUris } = await reverseMatch(deezer, token, sourceId, sourceName);
+    if (matchedUris.length) {
+        const uri = await createPlaylist(`[plx] ${sourceName}`, token);
+        for (let start = 0; start < matchedUris.length; start += 100) {
+            await addTracks(uri, matchedUris.slice(start, start + 100), token);
+            await sleep(200);
+        }
+        console.log(`[${sourceName}] playlist Spotify dibuat: ${uri} (${matchedUris.length} lagu)`);
+    }
+    await writeCsv(output, rows);
+}
+// Deezer playlist (source) → an existing Spotify playlist (target). Dedupe + append (no reorder — Spotify has no move primitive in scope).
+export async function reverseWriteToExisting(deezer, token, sourceId, sourceName, targetUri, output) {
+    const { rows, matchedUris } = await reverseMatch(deezer, token, sourceId, sourceName);
+    if (!matchedUris.length) {
+        await writeCsv(output, rows);
+        return;
+    }
+    const targetId = targetUri.split(':').pop() ?? targetUri;
+    const existing = new Set(await fetchTrackUris(targetId, token));
+    const toAdd = [...new Set(matchedUris)].filter((u) => !existing.has(u));
+    if (toAdd.length) {
+        for (let start = 0; start < toAdd.length; start += 100) {
+            await addTracks(targetUri, toAdd.slice(start, start + 100), token);
+            await sleep(200);
+        }
+    }
+    console.log(`[${sourceName}] ${toAdd.length} lagu baru ditambahkan (${matchedUris.length - toAdd.length} sudah ada, dilewati).`);
+    await writeCsv(output, rows);
+}

package/dist/spotify.js

@@ -0,0 +1,227 @@
+import { createHmac } from 'node:crypto';
+import { z } from 'zod';
+import { browserHeaders, fetchJson, fetchText } from './http.js';
+const PATHFINDER_URL = 'https://api-partner.spotify.com/pathfinder/v1/query';
+const FETCH_PLAYLIST_SHA = 'a65e12194ed5fc443a1cdebed5fabe33ca5b07b987185d63c72483867ad13cb4';
+export const EMBED_TRACK_LIMIT = 100;
+const pathfinderItemData = z.object({
+    uri: z.string().optional(),
+    name: z.string().optional(),
+    artists: z.object({ items: z.array(z.object({ profile: z.object({ name: z.string().optional() }) })) }).optional(),
+    trackDuration: z.object({ totalMilliseconds: z.number().optional() }).optional(),
+});
+const pathfinderItem = z.object({ itemV2: z.object({ data: pathfinderItemData.optional() }).optional() });
+const pathfinderContent = z.object({ totalCount: z.number(), items: z.array(pathfinderItem) });
+const pathfinderTrackSchema = z.object({
+    errors: z.array(z.object({ message: z.string() })).optional(),
+    data: z.object({ playlistV2: z.object({ content: pathfinderContent }) }),
+});
+async function nextData(url, cookie) {
+    const headers = cookie ? { ...browserHeaders, Cookie: cookie } : browserHeaders;
+    const html = await fetchText(url, { headers });
+    const match = html.match(/<script id="__NEXT_DATA__"[^>]*>(.*?)<\/script>/s);
+    if (!match)
+        throw new Error('__NEXT_DATA__ not found');
+    return JSON.parse(match[1]);
+}
+export async function anonymousToken() {
+    const data = await nextData('https://open.spotify.com/embed/track/4uLU6hMCjMI75M1A2tKUQC');
+    const token = data.props?.pageProps?.state?.settings?.session?.accessToken;
+    if (!token)
+        throw new Error('Spotify anonymous token missing');
+    return token;
+}
+export async function playlistName(id) {
+    try {
+        const entity = (await nextData(`https://open.spotify.com/embed/playlist/${id}`)).props?.pageProps?.state?.data?.entity;
+        if (typeof entity?.name === 'string' && entity.name)
+            return entity.name;
+    }
+    catch { /* fallback below */ }
+    return `playlist-${id.slice(0, 8)}`;
+}
+export async function fetchTracksEmbed(id) {
+    const entity = (await nextData(`https://open.spotify.com/embed/playlist/${id}`)).props?.pageProps?.state?.data?.entity;
+    const list = Array.isArray(entity?.trackList) ? entity.trackList : [];
+    const tracks = list.map((item) => {
+        const track = item;
+        return { name: String(track.title ?? ''), artist: String(track.subtitle ?? ''), durationMs: typeof track.duration === 'number' ? track.duration : null };
+    });
+    return { tracks, truncated: tracks.length >= EMBED_TRACK_LIMIT };
+}
+export async function fetchTracks(id, token) {
+    const tracks = [];
+    for (let offset = 0;;) {
+        const variables = { uri: `spotify:playlist:${id}`, offset, limit: 100, enableWatchFeedEntrypoint: false };
+        const params = new URLSearchParams({ operationName: 'fetchPlaylist', variables: JSON.stringify(variables), extensions: JSON.stringify({ persistedQuery: { version: 1, sha256Hash: FETCH_PLAYLIST_SHA } }) });
+        const raw = pathfinderTrackSchema.parse(await fetchJson(`${PATHFINDER_URL}?${params}`, { headers: { ...browserHeaders, Authorization: `Bearer ${token}`, 'app-platform': 'WebPlayer' } }));
+        if (raw.errors?.length)
+            throw new Error(`pathfinder: ${raw.errors[0].message}`);
+        const content = raw.data.playlistV2.content;
+        const items = content.items;
+        for (const item of items) {
+            const data = item.itemV2?.data;
+            if (!data?.uri)
+                continue;
+            tracks.push({ name: data.name ?? '', artist: data.artists?.items?.[0]?.profile?.name ?? '', durationMs: data.trackDuration?.totalMilliseconds ?? null });
+        }
+        offset += items.length;
+        if (!items.length || offset >= content.totalCount)
+            return { tracks, truncated: false };
+    }
+}
+export async function readPlaylist(id, token) {
+    try {
+        return await fetchTracks(id, token);
+    }
+    catch {
+        return fetchTracksEmbed(id);
+    }
+}
+export function parsePlaylistId(ref) {
+    const input = ref.trim();
+    if (input.includes('open.spotify.com'))
+        return new URL(input).pathname.replace(/\/+$/, '').split('/').pop() ?? input;
+    if (input.startsWith('spotify:playlist:'))
+        return input.split(':').pop() ?? input;
+    return input;
+}
+// Resolve a spotify:track:ID URI to its real title/artist/duration via the anonymous
+// embed endpoint — used to verify reverse-flow matches (precision check).
+export async function resolveTrackMeta(uri) {
+    const id = uri.split(':').pop() ?? uri;
+    const entity = (await nextData(`https://open.spotify.com/embed/track/${id}`)).props?.pageProps?.state?.data?.entity;
+    const artists = Array.isArray(entity?.artists) ? entity.artists : [];
+    return {
+        name: typeof entity?.name === 'string' ? entity.name : '',
+        artist: artists[0]?.name ?? '',
+        durationMs: typeof entity?.duration === 'number' ? entity.duration : null,
+    };
+}
+// --- Authenticated write (reverse flow: Deezer → Spotify) ---
+const PATHFINDER_V2_URL = 'https://api-partner.spotify.com/pathfinder/v2/query';
+const SPCLIENT_URL = 'https://spclient.wg.spotify.com';
+// Persisted-query hashes for write/search — captured from the web player; they rotate (see CONTINUATION.md).
+const ADD_TO_PLAYLIST_SHA = '47b2a1234b17748d332dd0431534f22450e9ecbb3d5ddcdacbd83368636a0990';
+const SEARCH_TRACKS_SHA = 'bc1ca2fcd0ba1013a0fc88e6cc4f190af501851e3dafd3e1ef85840297694428';
+const LIBRARY_V3_SHA = '973e511ca44261fda7eebac8b653155e7caee3675abb4fb110cc1b8c78b091c3';
+const ADD_ITEMS_TO_ROOTLIST_SHA = 'bd9c5cae1ee80ebca05d7ed12fd394216f49a20ce72d9dc762868df0f14522ea';
+const writeHeaders = (token) => ({ ...browserHeaders, Authorization: `Bearer ${token}`, 'Content-Type': 'application/json', 'Accept': 'application/json', 'app-platform': 'WebPlayer' });
+// Authenticated token from a logged-in browser session (sp_dc cookie).
+// The web player obtains its API token at /api/token with a TOTP derived from a
+// rotating "nuance" secret + Spotify server time; the embed __NEXT_DATA__ token
+// only covers playback/reads, not search+write mutations.
+const NUANCE_URL = 'https://gist.githubusercontent.com/raw/22ed9c6ba463899e933427f7de1f0eef/nuances.json';
+function base32Decode(input) {
+    const alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567';
+    let bits = 0;
+    let value = 0;
+    const out = [];
+    for (const c of input.replace(/=+$/, '').toUpperCase()) {
+        const idx = alphabet.indexOf(c);
+        if (idx === -1)
+            continue;
+        value = (value << 5) | idx;
+        bits += 5;
+        if (bits >= 8) {
+            out.push((value >>> (bits - 8)) & 0xff);
+            bits -= 8;
+        }
+    }
+    return Buffer.from(out);
+}
+function totp(secret, timestampSec) {
+    const counter = Math.floor(timestampSec / 30);
+    const msg = Buffer.alloc(8);
+    msg.writeUInt32BE(Math.floor(counter / 0x100000000), 0);
+    msg.writeUInt32BE(counter >>> 0, 4);
+    const mac = createHmac('sha1', base32Decode(secret)).update(msg).digest();
+    const offset = mac[mac.length - 1] & 0xf;
+    const code = ((mac[offset] & 0x7f) << 24) | ((mac[offset + 1] & 0xff) << 16) | ((mac[offset + 2] & 0xff) << 8) | (mac[offset + 3] & 0xff);
+    return String(code % 1_000_000).padStart(6, '0');
+}
+async function tokenFromSpDc(spDc) {
+    const nuances = await fetchJson(NUANCE_URL);
+    const nuance = nuances.reduce((best, n) => (best && best.v >= n.v ? best : n), undefined);
+    if (!nuance)
+        throw new Error('Spotify nuance secret not found');
+    const serverTime = await fetchJson('https://open.spotify.com/api/server-time');
+    const otp = totp(nuance.s, serverTime.serverTime);
+    const url = `https://open.spotify.com/api/token?reason=transport&productType=web-player&totp=${otp}&totpServer=${otp}&totpVer=${nuance.v}`;
+    const token = await fetchJson(url, { headers: { ...browserHeaders, Cookie: `sp_dc=${spDc}` } });
+    if (!token.accessToken)
+        throw new Error('Spotify token missing');
+    return token.accessToken;
+}
+// Authenticated write token from an sp_dc cookie (full web-player scope: search + write).
+export function authenticatedToken(spDc) { return tokenFromSpDc(spDc); }
+// Spotify search, shaped as DeezerCandidate (duration in seconds) so matchCandidates is reusable.
+export async function searchTrack(term, token) {
+    const body = { variables: { searchTerm: term, offset: 0, limit: 10, numberOfTopResults: 10, includePreReleases: false, includeAudiobooks: false, includeAuthors: false }, operationName: 'searchTracks', extensions: { persistedQuery: { version: 1, sha256Hash: SEARCH_TRACKS_SHA } } };
+    const raw = await fetchJson(PATHFINDER_V2_URL, { method: 'POST', headers: writeHeaders(token), body: JSON.stringify(body) });
+    if (raw.errors?.length)
+        throw new Error(`searchTracks: ${raw.errors[0].message}`);
+    const items = raw.data?.searchV2?.tracksV2?.items ?? [];
+    return items.flatMap((it) => {
+        const d = it.item?.data;
+        if (!d?.uri || !d.name)
+            return [];
+        return [{ id: d.uri, title: d.name, artist: d.artists?.items?.[0]?.profile?.name ?? '', duration: d.duration?.totalMilliseconds != null ? Math.round(d.duration.totalMilliseconds / 1000) : null }];
+    });
+}
+export async function createPlaylist(name, token) {
+    const body = { ops: [{ kind: 'UPDATE_LIST_ATTRIBUTES', updateListAttributes: { newAttributes: { values: { name, description: '' } } } }] };
+    const raw = await fetchJson(`${SPCLIENT_URL}/playlist/v2/playlist?format=json`, { method: 'POST', headers: writeHeaders(token), body: JSON.stringify(body) });
+    if (!raw.uri)
+        throw new Error('Spotify create playlist: no uri');
+    await addItemsToRootlist(raw.uri, token);
+    return raw.uri;
+}
+// The REST create above makes a playlist but does NOT attach it to the account's
+// library/rootlist — without this follow it never shows in the sidebar.
+async function addItemsToRootlist(uri, token) {
+    const body = { variables: { uris: [uri] }, operationName: 'addItemsToRootlist', extensions: { persistedQuery: { version: 1, sha256Hash: ADD_ITEMS_TO_ROOTLIST_SHA } } };
+    const raw = await fetchJson(PATHFINDER_V2_URL, { method: 'POST', headers: writeHeaders(token), body: JSON.stringify(body) });
+    if (raw.errors?.length)
+        throw new Error(`addItemsToRootlist: ${raw.errors[0].message}`);
+}
+export async function addTracks(playlistUri, trackUris, token) {
+    const body = { variables: { playlistItemUris: trackUris, playlistUri, newPosition: { moveType: 'BOTTOM_OF_PLAYLIST', fromUid: null } }, operationName: 'addToPlaylist', extensions: { persistedQuery: { version: 1, sha256Hash: ADD_TO_PLAYLIST_SHA } } };
+    const raw = await fetchJson(PATHFINDER_V2_URL, { method: 'POST', headers: writeHeaders(token), body: JSON.stringify(body) });
+    if (raw.errors?.length)
+        throw new Error(`addToPlaylist: ${raw.errors[0].message}`);
+}
+// The user's own (writable) playlists. Filters out Liked Songs and followed playlists (canEditItems: false).
+export async function listPlaylists(token) {
+    const body = { variables: { limit: 50, offset: 0, folderUri: null }, operationName: 'libraryV3', extensions: { persistedQuery: { version: 1, sha256Hash: LIBRARY_V3_SHA } } };
+    const raw = await fetchJson(PATHFINDER_V2_URL, { method: 'POST', headers: writeHeaders(token), body: JSON.stringify(body) });
+    if (raw.errors?.length)
+        throw new Error(`libraryV3: ${raw.errors[0].message}`);
+    const items = raw.data?.me?.libraryV3?.items ?? [];
+    return items.flatMap((it) => {
+        const d = it.item?.data;
+        if (it.item?.__typename !== 'PlaylistResponseWrapper' || !d?.uri || !d.name || d.currentUserCapabilities?.canEditItems !== true)
+            return [];
+        return [{ uri: d.uri, name: d.name }];
+    });
+}
+// Track URIs currently in a playlist — for dedupe on the reverse flow. Reuses the proven v1 fetchPlaylist read path.
+export async function fetchTrackUris(id, token) {
+    const uris = [];
+    for (let offset = 0;;) {
+        const variables = { uri: `spotify:playlist:${id}`, offset, limit: 100, enableWatchFeedEntrypoint: false };
+        const params = new URLSearchParams({ operationName: 'fetchPlaylist', variables: JSON.stringify(variables), extensions: JSON.stringify({ persistedQuery: { version: 1, sha256Hash: FETCH_PLAYLIST_SHA } }) });
+        const raw = pathfinderTrackSchema.parse(await fetchJson(`${PATHFINDER_URL}?${params}`, { headers: { ...browserHeaders, Authorization: `Bearer ${token}`, 'app-platform': 'WebPlayer' } }));
+        if (raw.errors?.length)
+            throw new Error(`pathfinder: ${raw.errors[0].message}`);
+        const content = raw.data.playlistV2.content;
+        for (const item of content.items) {
+            const u = item.itemV2?.data?.uri;
+            if (u)
+                uris.push(u);
+        }
+        offset += content.items.length;
+        if (!content.items.length || offset >= content.totalCount)
+            return uris;
+    }
+}