plx-converter 0.1.5 → 0.1.7

package/dist/browser.js

@@ -6,12 +6,12 @@ import { join } from 'node:path';
 import { DatabaseSync } from 'node:sqlite';
 import { YTMUSIC_COOKIES, cookieHeader } from './ytmusic.js';
 const CHROMIUM_BROWSERS = [
-    { dir: 'BraveSoftware/Brave-Browser', keychain: 'Brave Safe Storage' },
-    { dir: 'Google/Chrome', keychain: 'Chrome Safe Storage' },
-    { dir: 'Microsoft Edge', keychain: 'Microsoft Edge Safe Storage' },
-    { dir: 'Chromium', keychain: 'Chromium Safe Storage' },
-    { dir: 'Vivaldi', keychain: 'Vivaldi Safe Storage' },
-    { dir: 'com.operasoftware.Opera', keychain: 'Opera Safe Storage' },
+    { key: 'brave', label: 'Brave', dir: 'BraveSoftware/Brave-Browser', keychain: 'Brave Safe Storage' },
+    { key: 'chrome', label: 'Chrome', dir: 'Google/Chrome', keychain: 'Chrome Safe Storage' },
+    { key: 'edge', label: 'Edge', dir: 'Microsoft Edge', keychain: 'Microsoft Edge Safe Storage' },
+    { key: 'chromium', label: 'Chromium', dir: 'Chromium', keychain: 'Chromium Safe Storage' },
+    { key: 'vivaldi', label: 'Vivaldi', dir: 'Vivaldi', keychain: 'Vivaldi Safe Storage' },
+    { key: 'opera', label: 'Opera', dir: 'com.operasoftware.Opera', keychain: 'Opera Safe Storage' },
 ];
 // Chromium v10 blob: 3-byte "v10" prefix + AES-128-CBC (IV = 16 × 0x20, PKCS7).
 // Key = PBKDF2-HMAC-SHA1(keychain pw string, "saltysalt", 1003, 16 bytes).
@@ -79,20 +79,27 @@ function collect(rows) {
     }
     return Object.fromEntries([...best].map(([name, { value }]) => [name, value]));
 }
-function readChromium(browser) {
-    const dbPath = join(homedir(), 'Library', 'Application Support', browser.dir, 'Default', 'Cookies');
+export function readChromiumDb(dbPath, getPassword) {
     if (!existsSync(dbPath))
         return {};
-    const pw = keychainPassword(browser.keychain);
-    if (pw == null)
-        return {};
-    const key = pbkdf2Sync(pw, PBKDF2_SALT, PBKDF2_ITER, PBKDF2_KEYLEN, 'sha1');
-    const db = new DatabaseSync(dbPath, { readOnly: true });
+    let db;
+    try {
+        db = new DatabaseSync(dbPath, { readOnly: true });
+    }
+    catch {
+        return {}; // TCC-denied or unreadable — skip before touching the Keychain
+    }
     try {
         const meta = db.prepare("SELECT value FROM meta WHERE key = 'version'").get();
         const dbVersion = meta?.value ? Number(meta.value) : 0;
         const query = `SELECT name, host_key, encrypted_value FROM cookies WHERE name IN (${COOKIE_NAMES.map(() => '?').join(',')})`;
         const rows = db.prepare(query).all(...COOKIE_NAMES);
+        if (!rows.length)
+            return {};
+        const pw = getPassword();
+        if (pw == null)
+            return {};
+        const key = pbkdf2Sync(pw, PBKDF2_SALT, PBKDF2_ITER, PBKDF2_KEYLEN, 'sha1');
         return collect(rows.flatMap((row) => {
             const value = decryptCookie(Buffer.from(row.encrypted_value), key, dbVersion >= 24);
             return value ? [{ name: row.name, host: row.host_key, value }] : [];
@@ -105,6 +112,31 @@ function readChromium(browser) {
         db.close();
     }
 }
+function sortedProfileDbs(base, cookieFile, includeDir = () => true) {
+    try {
+        return readdirSync(base, { withFileTypes: true })
+            .filter((entry) => entry.isDirectory() && includeDir(entry.name))
+            .map((entry) => join(base, entry.name, cookieFile))
+            .filter(existsSync)
+            .sort((a, b) => statSync(b).mtimeMs - statSync(a).mtimeMs);
+    }
+    catch {
+        return [];
+    }
+}
+// Every user profile (`Default`, `Profile 1`, `Profile 6`, …) holding a `Cookies` DB inside a
+// Chromium browser's Application Support dir, most-recently-written first.
+export function chromiumProfiles(browserDir) {
+    return sortedProfileDbs(browserDir, 'Cookies', (name) => name === 'Default' || name.startsWith('Profile '));
+}
+function readChromium(browser, appSupportDir = join(homedir(), 'Library', 'Application Support')) {
+    const profiles = chromiumProfiles(join(appSupportDir, browser.dir));
+    if (!profiles.length)
+        return [];
+    let cachedPw;
+    const getPassword = () => (cachedPw === undefined ? (cachedPw = keychainPassword(browser.keychain)) : cachedPw);
+    return profiles.map((dbPath) => readChromiumDb(dbPath, getPassword));
+}
 // Safari `Cookies.binarycookies` layout (mirrors browser_cookie3):
 // "cook" magic + big-endian page table, then little-endian cookie records with
 // null-terminated host/name/value strings at cookie-relative offsets.
@@ -172,16 +204,7 @@ const FIREFOX_ROOTS = {
 export function firefoxProfiles(root = FIREFOX_ROOTS[platform()] ?? FIREFOX_ROOTS.linux) {
     const nested = join(root, 'Profiles');
     const base = existsSync(nested) ? nested : root; // some Linux packagings drop the Profiles/ level
-    try {
-        return readdirSync(base, { withFileTypes: true })
-            .filter((entry) => entry.isDirectory())
-            .map((entry) => join(base, entry.name, 'cookies.sqlite'))
-            .filter(existsSync)
-            .sort((a, b) => statSync(b).mtimeMs - statSync(a).mtimeMs);
-    }
-    catch {
-        return []; // no Firefox installed, or an unreadable profile root
-    }
+    return sortedProfileDbs(base, 'cookies.sqlite');
 }
 // Firefox keeps the DB in WAL mode and holds it open while running — on Windows that lock is
 // enforced, so reading the file in place fails outright. Copy it to a temp dir and read the copy.
@@ -214,19 +237,43 @@ export function readFirefox(dbPath) {
             rmSync(dir, { recursive: true, force: true });
     }
 }
-// Auto-retrieve credentials from the first logged-in browser that has them, keyed by provider —
-// the parsers above speak in cookie names, and this is where that becomes one opaque string per
-// provider for the config layer to store. Never throws: a missing browser, locked DB, denied
-// keychain, or TCC block just yields {}. Manual paste stays the fallback.
-export function fetchBrowserCredentials() {
-    // The keychain-backed backends stay gated on macOS; Firefox runs everywhere and is all that
-    // Windows and Linux get. macOS keeps its original order, so nothing changes for anyone who
-    // already relied on this — Firefox only fills what the others left empty.
-    const keychainBacked = platform() === 'darwin' ? [...CHROMIUM_BROWSERS.map(readChromium), readSafari()] : [];
+// Browsers available to pick on this OS: on macOS, every Chromium browser with at least one profile
+// cookie DB on disk plus Safari (whose container is TCC-gated until tried), plus Firefox when a
+// profile exists. On Windows and Linux, Firefox is the only supported backend.
+export function detectedBrowsers(os = platform(), appSupportDir = join(homedir(), 'Library', 'Application Support'), firefoxRoot) {
+    const options = [];
+    if (os === 'darwin') {
+        for (const browser of CHROMIUM_BROWSERS) {
+            if (chromiumProfiles(join(appSupportDir, browser.dir)).length > 0) {
+                options.push({ key: browser.key, label: browser.label });
+            }
+        }
+        options.push({ key: 'safari', label: 'Safari' });
+    }
+    if (firefoxProfiles(firefoxRoot).length > 0) {
+        options.push({ key: 'firefox', label: 'Firefox' });
+    }
+    return options;
+}
+function readBrowserProfiles(browser) {
+    if (browser === 'firefox')
+        return firefoxProfiles().map(readFirefox);
+    if (browser === 'safari')
+        return platform() === 'darwin' ? [readSafari()] : [];
+    if (browser) {
+        const chromium = CHROMIUM_BROWSERS.find((b) => b.key === browser);
+        return platform() === 'darwin' && chromium ? readChromium(chromium) : [];
+    }
+    const keychainBacked = platform() === 'darwin' ? [...CHROMIUM_BROWSERS.flatMap((b) => readChromium(b)), readSafari()] : [];
+    return [...keychainBacked, ...firefoxProfiles().map(readFirefox)];
+}
+// Auto-retrieve credentials from the selected browser (or the first logged-in browser when none is
+// named), keyed by provider — the parsers above speak in cookie names, and this is where that
+// becomes one opaque string per provider for the config layer to store. Never throws: a missing
+// browser, locked DB, denied keychain, or TCC block just yields {}. Manual paste stays the fallback.
+export function fetchBrowserCredentials(browser) {
     const credentials = {};
-    // Every backend is read rather than stopping at the first: a user may be logged into Deezer in one
-    // browser and YouTube Music in another.
-    for (const found of [...keychainBacked, ...firefoxProfiles().map(readFirefox)]) {
+    for (const found of readBrowserProfiles(browser)) {
         if (!credentials.deezer && found.arl)
             credentials.deezer = found.arl;
         if (!credentials.spotify && found.sp_dc)
@@ -248,11 +295,20 @@ export function fetchBrowserCredentials() {
 // backend, so the useful thing to report is which half of that is missing. This says *why* only —
 // the caller owns pointing at the manual paste, so that instruction lives in one place. Both inputs
 // are injected so the branches are testable without a browser or a second OS.
-export function autoFetchHint(os = platform(), firefoxFound = firefoxProfiles().length > 0) {
-    if (os === 'darwin')
-        return 'No browser was logged in, or the macOS Keychain prompt was denied.';
-    if (firefoxFound)
+export function autoFetchHint(os = platform(), firefoxFound = firefoxProfiles().length > 0, browser) {
+    if (browser === 'safari') {
+        return 'Safari held none of the cookies, or your terminal lacks Full Disk Access (System Settings → Privacy & Security → Full Disk Access).';
+    }
+    if (browser === 'firefox' || (os !== 'darwin' && !browser && firefoxFound)) {
         return 'A Firefox profile was found but held none of the cookies — log in at the provider in Firefox and retry.';
+    }
+    if (browser) {
+        const label = CHROMIUM_BROWSERS.find((b) => b.key === browser)?.label ?? browser;
+        return `${label} held none of the cookies, the macOS Keychain prompt was denied, or macOS blocked your terminal from reading ${label}'s app data (System Settings → Privacy & Security → App Management / Full Disk Access).`;
+    }
+    if (os === 'darwin') {
+        return 'No browser was logged in, the macOS Keychain prompt was denied, or macOS blocked your terminal from reading browser data (System Settings → Privacy & Security → Full Disk Access).';
+    }
     const why = os === 'win32'
         ? 'Chrome/Edge cookies are sealed by App-Bound Encryption that only a SYSTEM process can unwrap'
         : 'the Chromium keyring backends are not implemented here';

package/dist/cli.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { confirm, intro, isCancel, outro, password, select, text } from '@clack/prompts';
-import { autoFetchHint } from './browser.js';
+import { autoFetchHint, detectedBrowsers } from './browser.js';
 import { credential, loadConfig, saveCredential, saveRecentUrl, tryAutoFillCredentials } from './config.js';
 import { Conversion } from './conversion.js';
 import { PROVIDERS, inferSource, providerFor, targetKeys } from './registry.js';
@@ -9,9 +9,9 @@ function args() { return process.argv.slice(2); }
 // --- Credentials -----------------------------------------------------------
 // Why the browser read came back with nothing for this provider, and what to do instead. Every
 // auto-fetch failure says this, so the user never sees a bare "could not be fetched".
-function explainAutoFetchFailure(spec) {
+function explainAutoFetchFailure(spec, browser) {
     const what = spec ? `${spec.label} cookies` : 'No credentials';
-    console.log(`✗ ${what} could not be read from your browser. ${autoFetchHint()}`);
+    console.log(`✗ ${what} could not be read from your browser. ${autoFetchHint(undefined, undefined, browser)}`);
 }
 // One manual paste, with where to find the value and what a correct one looks like.
 async function promptCredential(cfg, spec) {
@@ -23,44 +23,52 @@ async function promptCredential(cfg, spec) {
     await saveCredential(cfg, spec.key, String(entered).trim()); // pasted values carry stray whitespace
     return true;
 }
-// Fill one provider's credential mid-conversion: browser auto-fill first, then a manual paste.
-// Persists what it gets. Returns the credential, or null when the user cancels.
-async function ensureCredential(cfg, spec) {
-    if (credential(cfg, spec.key))
-        return credential(cfg, spec.key);
-    const filled = await tryAutoFillCredentials(cfg);
-    if (filled.includes(spec.key))
-        return credential(cfg, spec.key);
-    explainAutoFetchFailure(spec);
-    if (!(await promptCredential(cfg, spec)))
-        return null;
-    return credential(cfg, spec.key);
-}
-// Settings entry for one provider's credential. The two ways in are offered as a choice rather than
-// auto-first-then-manual, so someone who knows the browser read will fail (or who wants to replace a
-// saved-but-expired value with a cookie of their own) can go straight to the paste. Auto-fetch here
-// overwrites, scoped to this provider, so an expired credential is actually replaced.
-// Proves whatever lands against the live service before saying it worked.
-async function reenterCredential(cfg, spec) {
+// Pick which detected browser to read from, or 'manual' to paste directly. When no supported
+// browser is detected on this OS, explains why and goes straight to the manual paste.
+async function chooseCredentialSource(spec) {
+    const browsers = detectedBrowsers();
+    if (!browsers.length) {
+        explainAutoFetchFailure(spec);
+        return 'manual';
+    }
     const how = await select({
         message: `${spec.credentialLabel}`,
         options: [
-            { value: 'auto', label: 'Auto-fetch from browser' },
+            ...browsers.map((b) => ({ value: b.key, label: `Auto-fetch from ${b.label}` })),
             { value: 'manual', label: 'Paste cookies manually' },
         ],
     });
-    if (isCancel(how))
-        return;
-    if (how === 'auto') {
+    return isCancel(how) ? null : how;
+}
+// Choose a detected browser (or manual paste) and populate `spec`'s credential, falling back to
+// manual paste when the chosen browser has nothing for `spec`.
+async function acquireCredential(cfg, spec, overwrite, only) {
+    const source = await chooseCredentialSource(spec);
+    if (!source)
+        return false;
+    if (source !== 'manual') {
         warnLogin(spec.loginSite);
-        if ((await tryAutoFillCredentials(cfg, true, spec.key)).includes(spec.key)) {
-            await report(cfg, spec);
-            return;
-        }
-        explainAutoFetchFailure(spec);
+        if ((await tryAutoFillCredentials(cfg, overwrite, only, source)).includes(spec.key))
+            return true;
+        explainAutoFetchFailure(spec, source);
         console.log('   Paste it manually instead:');
     }
-    if (!(await promptCredential(cfg, spec)))
+    return promptCredential(cfg, spec);
+}
+// Fill one provider's credential mid-conversion: pick a detected browser (or manual paste), and
+// fall back to manual paste if the chosen browser had no cookie for this provider.
+async function ensureCredential(cfg, spec) {
+    if (credential(cfg, spec.key))
+        return credential(cfg, spec.key);
+    if (!(await acquireCredential(cfg, spec, false)))
+        return null;
+    return credential(cfg, spec.key);
+}
+// Settings entry for one provider's credential. Offers each detected browser alongside manual
+// paste in a single menu, and overwrites scoped to this provider so an expired credential is
+// replaced without touching the other two. Proves whatever lands against the live service.
+async function reenterCredential(cfg, spec) {
+    if (!(await acquireCredential(cfg, spec, true, spec.key)))
         return;
     await report(cfg, spec);
 }
@@ -101,6 +109,18 @@ async function build(cfg, spec, needsWrite) {
 function warnLogin(sites) {
     console.log(`⚠️ Make sure you're logged in at ${sites} in your browser, then grab the credentials.`);
 }
+async function pickBrowser() {
+    const browsers = detectedBrowsers();
+    if (!browsers.length) {
+        explainAutoFetchFailure();
+        return null;
+    }
+    const pick = await select({
+        message: 'From which browser?',
+        options: browsers.map((b) => ({ value: b.key, label: b.label })),
+    });
+    return isCancel(pick) ? null : pick;
+}
 // Pick a provider by role. Adding a provider adds an option here, never a menu entry.
 async function pickProvider(message, from, exclude) {
     const choices = from.filter((p) => p !== exclude);
@@ -270,24 +290,28 @@ async function runInteractive(options) {
             continue;
         }
         if (choice === 'autofetch') {
-            warnLogin(PROVIDERS.map((p) => p.label).join(' & '));
-            const filled = await tryAutoFillCredentials(cfg, true);
-            if (filled.length) {
-                console.log(`Fetched from browser: ${filled.join(', ')}. Checking…`);
-                for (const key of filled) {
-                    const spec = providerFor(key);
-                    if (spec)
-                        await report(cfg, spec);
+            const browser = await pickBrowser();
+            if (browser) {
+                warnLogin(PROVIDERS.map((p) => p.label).join(' & '));
+                const filled = await tryAutoFillCredentials(cfg, true, undefined, browser);
+                if (filled.length) {
+                    console.log(`Fetched from browser: ${filled.join(', ')}. Checking…`);
+                    for (const key of filled) {
+                        const spec = providerFor(key);
+                        if (spec)
+                            await report(cfg, spec);
+                    }
+                }
+                else {
+                    explainAutoFetchFailure(undefined, browser);
                 }
-            }
-            else {
-                explainAutoFetchFailure();
             }
             // Whatever auto-fetch managed, the manual path is what closes the gap — name it and the menu
             // entry that leads to it, rather than leaving the user at a dead end.
+            const nowSaved = PROVIDERS.filter((p) => credential(cfg, p.key)).length;
             const missing = PROVIDERS.filter((p) => !credential(cfg, p.key));
             if (missing.length)
-                console.log(`→ Still missing: ${missing.map((p) => p.label).join(', ')}. Add them from "Credentials: ${saved}/${PROVIDERS.length} saved" → pick the provider → "Paste cookies manually".`);
+                console.log(`→ Still missing: ${missing.map((p) => p.label).join(', ')}. Add them from "Credentials: ${nowSaved}/${PROVIDERS.length} saved" → pick the provider → "Paste cookies manually".`);
             continue;
         }
         if (choice === 'output') {

package/dist/config.js

@@ -66,12 +66,12 @@ async function write(patch) {
 // refetch and replace, and `only` to confine that to one provider — the Credentials menu refetches
 // the provider being edited without quietly replacing the other two. Never throws — a denied
 // keychain / TCC block just fills nothing, and the caller falls back to the manual paste prompt.
-export async function tryAutoFillCredentials(cfg, overwrite = false, only) {
+export async function tryAutoFillCredentials(cfg, overwrite = false, only, browser) {
     const wanted = only ? [only] : Object.keys(ENV_VAR);
     if (!overwrite && wanted.every((provider) => cfg.credentials[provider]))
         return [];
     const filled = [];
-    for (const [provider, value] of Object.entries(fetchBrowserCredentials())) {
+    for (const [provider, value] of Object.entries(fetchBrowserCredentials(browser))) {
         if (!value || !wanted.includes(provider) || (!overwrite && cfg.credentials[provider]))
             continue;
         cfg.credentials[provider] = value;

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.7",
   "description": "Convert playlists between Spotify, Deezer, and YouTube Music using your own browser session",
   "license": "MIT",
   "repository": {