plx-converter 0.1.5 → 0.1.6

package/dist/deezer.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { fetchJson, retry } from './http.js';
-import { firstArtist, matchCandidates, searchQuery, stripFeat } from './matcher.js';
+import { firstArtist, matchByDuration, 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';
@@ -67,16 +67,22 @@ export class DeezerClient {
         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));
+        const candidates = toCandidates(data);
+        const match = matchCandidates(track.name, track.artist, track.durationMs, candidates);
         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));
+        const candidates2 = toCandidates(data2);
+        const match2 = matchCandidates(track.name, track.artist, track.durationMs, candidates2);
         if (match2)
             return match2;
-        return this.searchByAlbum(track);
+        // The catalog scan still compares titles, so it stays ahead of the title-blind tier.
+        const byAlbum = await this.searchByAlbum(track);
+        if (byAlbum)
+            return byAlbum;
+        return matchByDuration(track.name, track.artist, track.durationMs, [...candidates, ...candidates2]);
     }
     // Artist → albums → album tracks, for tracks the search index never surfaces (e.g. "Salty & Sweet").
     async searchByAlbum(track) {

package/dist/matcher.js

@@ -22,6 +22,49 @@ export function matchCandidates(title, artist, durationMs, candidates) {
     }
     return null;
 }
+// A recording that is a *version* of the source rather than the source itself. Tested against the
+// raw title, not the normalized one: normalize() strips parenthesised text, which is exactly where
+// the marker lives ("estrangement(Instrumental)" and "estrangement" normalize to the same string).
+const VERSION_MARKER = /instrumental|karaoke|off ?vocal|acoustic|remix|live|cover|伴奏/i;
+function artistOverlaps(a, b) { return Boolean(a && b) && (a.includes(b) || b.includes(a)); }
+// Last-resort tier: the title is not compared at all. A catalog often carries a track under a
+// translated title — Deezer lists 红线 as "RED LINE", 愛你但說不出口 as "Hard to say" — so a search
+// built from the source title returns the right recording under a name that can never string-match.
+//
+// With the title gone, duration is the only real guard, so it tightens to 2s and a candidate
+// without one is rejected. Artist equality relaxes to containment (Spotify's "LBI利比" is Deezer's
+// "LBI"), and the guard that carries the weight is uniqueness: exactly one surviving candidate, or
+// no match. Version-marked candidates drop out first, unless the source is itself a version.
+//
+// Only ever call this on relevance-ranked search results. Run over a whole artist catalog it will
+// happily pair a source track with whatever unrelated release happens to share its length.
+export function matchByDuration(title, artist, durationMs, candidates) {
+    if (durationMs == null)
+        return null;
+    const na = artistKey(firstArtist(artist));
+    if (!na)
+        return null;
+    const sourceIsVersion = VERSION_MARKER.test(title);
+    const seen = new Set();
+    const hits = candidates.filter((c) => {
+        if (seen.has(c.id))
+            return false; // the same recording found by two queries is still one candidate
+        if (c.duration == null || !matchDurationMs(durationMs, c.duration, 2000))
+            return false;
+        if (!artistOverlaps(na, artistKey(c.artist)))
+            return false;
+        if (!sourceIsVersion && VERSION_MARKER.test(c.title))
+            return false;
+        seen.add(c.id);
+        return true;
+    });
+    // ponytail: two ids for the same recording (single + album release) read as ambiguous and are
+    // rejected. Collapse on normalized title if that turns out to cost real matches.
+    if (hits.length !== 1)
+        return null;
+    const [c] = hits;
+    return { id: c.id, title: c.title, artist: c.artist, method: 'duration-only' };
+}
 // Match rules for a music video, used only after the catalog has produced nothing.
 //
 // A music video's stated artist is usually the uploading channel, so the artist rule relaxes from

package/dist/spotify.js

@@ -1,7 +1,7 @@
 import { createHmac } from 'node:crypto';
 import { z } from 'zod';
 import { browserHeaders, fetchJson, fetchText } from './http.js';
-import { matchCandidates, searchQuery } from './matcher.js';
+import { matchByDuration, matchCandidates, searchQuery } from './matcher.js';
 const PATHFINDER_URL = 'https://api-partner.spotify.com/pathfinder/v1/query';
 const FETCH_PLAYLIST_SHA = 'a65e12194ed5fc443a1cdebed5fabe33ca5b07b987185d63c72483867ad13cb4';
 export const EMBED_TRACK_LIMIT = 100;
@@ -221,7 +221,8 @@ export class SpotifyProvider {
     readPlaylist(ref) { return readPlaylist(parsePlaylistId(ref), this.token); }
     async search(track) {
         const candidates = await searchTrack(searchQuery(track.name, track.artist), this.token);
-        return matchCandidates(track.name, track.artist, track.durationMs, candidates);
+        return matchCandidates(track.name, track.artist, track.durationMs, candidates)
+            ?? matchByDuration(track.name, track.artist, track.durationMs, candidates);
     }
     createPlaylist(title) { return createPlaylist(title, this.token); }
     // Returns the count submitted, not one the service confirmed: addToPlaylist reports transport

package/dist/ytmusic-provider.js

@@ -1,4 +1,4 @@
-import { matchCandidates, matchVideoCandidates, searchQuery } from './matcher.js';
+import { matchByDuration, matchCandidates, matchVideoCandidates, searchQuery } from './matcher.js';
 import { innertube, isMix, parsePlaylistRef } from './ytmusic.js';
 import { continuationToken, parseItems, playlistTitle, toCandidate } from './ytmusic-parse.js';
 // Search filter params, as the web client sends them: catalog songs, and music videos.
@@ -57,9 +57,14 @@ export class YtMusicProvider {
     // strategy, the matcher owns the rules).
     async search(track) {
         const songs = await this.searchItems(track, SONGS);
-        const song = matchCandidates(track.name, track.artist, track.durationMs, songs.filter((i) => i.isSong).map(toCandidate));
+        const songCandidates = songs.filter((i) => i.isSong).map(toCandidate);
+        const song = matchCandidates(track.name, track.artist, track.durationMs, songCandidates);
         if (song)
             return song;
+        // A catalog song under a translated title still beats a video — see matchByDuration.
+        const translated = matchByDuration(track.name, track.artist, track.durationMs, songCandidates);
+        if (translated)
+            return translated;
         const videos = await this.searchItems(track, VIDEOS);
         return matchVideoCandidates(track.name, track.artist, track.durationMs, videos.map(toCandidate));
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "plx-converter",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "description": "Convert playlists between Spotify, Deezer, and YouTube Music using your own browser session",
   "license": "MIT",
   "repository": {