social-dl 0.9.5 → 0.9.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "social-dl",
-  "version": "0.9.5",
+  "version": "0.9.6",
   "license": "SEE LICENSE IN LICENSE",
   "description": "Direct CDN social downloader - YouTube, TikTok, Facebook, Instagram, Twitter, Pinterest, CapCut - No API, No keys, Never dies",
   "main": "src/index.js",

package/src/platforms/instagram.js

@@ -9,72 +9,78 @@ import { CREATOR } from '../constants.js';
 
 export const UA = 'Mozilla/5.0 (Linux; Android 15) AppleWebKit/537.36 Chrome/131 Mobile Safari/537.36';
 export const TMP_DIR = 'cache/temp';
+export const IG_APP_ID = '936619743392459';
 const IG_HEADERS = { 'User-Agent': UA, Accept: '*/*', 'Accept-Language': 'en-US,en;q=0.9', Referer: 'https://www.instagram.com/', Origin: 'https://www.instagram.com/' };
-const codeOf = url => new URL(url).pathname.match(/\/(?:p|reel|tv)\/([A-Za-z0-9_-]+)/)?.[1];
-async function headersFor(options = {}) { return options.cookiesPath ? { ...IG_HEADERS, Cookie: await readFile(options.cookiesPath, 'utf8') } : IG_HEADERS; }
+const codeOf = url => new URL(url).pathname.match(/\/(?:reel|reels|p|tv)\/([A-Za-z0-9_-]+)/i)?.[1];
 
 export function isInstagramUrl(value) {
-  try { return /instagram\.com\/(?:reel|p|tv)\//i.test(new URL(value).href); } catch { return false; }
+  try {
+    const parsed = new URL(String(value).trim());
+    const host = parsed.hostname.toLowerCase().replace(/^www\./, '');
+    return (parsed.protocol === 'http:' || parsed.protocol === 'https:') && host.endsWith('instagram.com') && /\/(?:reel|reels|p|tv)\//i.test(parsed.pathname);
+  } catch { return false; }
 }
 export function cleanInstagramUrl(value) { const parsed = new URL(value); return `${parsed.origin}${parsed.pathname.endsWith('/') ? parsed.pathname : `${parsed.pathname}/`}`; }
+async function cookieText(options = {}) { const path = options.cookies || options.cookiesPath; if (!path) return ''; try { return await readFile(path, 'utf8'); } catch { return ''; } }
+function cookieHeader(text) {
+  if (!text) return '';
+  if (!text.includes('\t')) return text.match(/(?:^|\n)Cookie:\s*(.+)/i)?.[1]?.trim() || text.trim();
+  return text.split(/\r?\n/).filter(line => line && !line.startsWith('#')).map(line => line.split('\t')).filter(parts => parts.length >= 7 && parts[5] && parts[6]).map(parts => `${parts[5]}=${parts[6]}`).join('; ');
+}
+async function headersFor(options = {}) { const cookie = cookieHeader(await cookieText(options)); return cookie ? { ...IG_HEADERS, Cookie: cookie } : IG_HEADERS; }
 function fromHtml(html) {
-  const find = key => { const m = html.match(new RegExp(`"${key}":"([^"]+)"`)); return m && unescapeJson(m[1]); };
-  const urls = [...html.matchAll(/"url":"(https:[^\"]+)"/g)].map(m => unescapeJson(m[1])).filter(url => /(?:scontent|cdninstagram)/i.test(url) && /\.mp4(?:[?&]|$)/i.test(url));
-  return sortFormats([find('video_url') || urls[0], ...urls].filter(Boolean).map((url, i) => ({ tag: i ? 'SD' : 'HD', quality: i ? '480p' : '720p', type: 'mp4', url })));
+  const find = key => { const match = html.match(new RegExp(`"${key}"\\s*:\\s*"([^"]+)"`)); return match && unescapeJson(match[1]); };
+  const urls = [...html.matchAll(/"url"\s*:\s*"(https:[^\"]+)"/g)].map(match => unescapeJson(match[1])).filter(url => /(?:scontent|cdninstagram)/i.test(url) && /\.mp4(?:[?&]|$)/i.test(url));
+  return sortFormats([find('video_url') || urls[0], ...urls].filter(Boolean).map((url, index) => ({ tag: index ? 'SD' : 'HD', quality: index ? '480p' : '720p', type: 'mp4', url })));
 }
 function fallbackError(error) { return error instanceof PrivateError || error instanceof NotFoundError || /PRIVATE|NOT_FOUND|LOGIN|404|403|empty|accounts\/login/i.test(error?.message || ''); }
-function outputFile(base) { return join(TMP_DIR, `${base}.mp4`); }
 async function validFile(file) { try { return (await stat(file)).isFile() && (await stat(file)).size > 4096; } catch { return false; } }
-async function cleanup(file) { await unlink(file).catch(() => {}); }
-async function ytdlpInfo(url, options = {}) {
-  const { stdout } = await runYtDlp(['--dump-json', '--no-download', '--no-playlist', '--skip-download', '--no-warnings', '--remote-components', 'ejs:github', '--js-runtimes', 'node', '--user-agent', UA, '--add-header', 'Referer:https://www.instagram.com/', '-f', 'best', ...cookieArgs(options), url]);
-  const line = stdout.trim().split(/\r?\n/).find(Boolean);
-  if (!line) throw new Error('yt-dlp returned no Instagram video information.');
-  return JSON.parse(line);
-}
-function normalizeFallback(data, url, id) {
-  const direct = data.url || data.requested_formats?.find(item => item.url)?.url;
-  return { creator: CREATOR, platform: 'instagram', id: data.id || id, username: data.uploader_id, author: data.uploader, caption: data.description, originalUrl: url, formats: direct ? [{ tag: 'BEST', quality: `${data.height || 720}p`, type: 'mp4', url: direct, hasAudio: true }] : [], fallback: true };
+
+async function runInstagramYtDlp(url, options = {}) {
+  const dir = join(process.cwd(), TMP_DIR);
+  await mkdir(dir, { recursive: true });
+  const tmp = join(dir, `ig-${Date.now()}-${Math.random().toString(36).slice(2, 8)}.mp4`);
+  const cookie = await cookieText(options);
+  const cookies = cookie ? cookieArgs({ cookiesPath: options.cookies || options.cookiesPath }) : [];
+  const common = ['--no-playlist', '--remote-components', 'ejs:github', '--js-runtimes', 'node', '--no-warnings', '--user-agent', UA, '--add-header', 'Referer:https://www.instagram.com/'];
+  const attempts = [
+    [...common, '-f', 'best', '-o', tmp, ...cookies, url],
+    [...common, '-f', 'bv*[ext=mp4]+ba[ext=m4a]/b[ext=mp4]/best', '--merge-output-format', 'mp4', '-o', tmp, ...cookies, url]
+  ];
+  try {
+    for (const args of attempts) {
+      try { await runYtDlp(args); } catch { /* retry with progressive video plus audio */ }
+      if (await validFile(tmp)) return await readFile(tmp);
+      await unlink(tmp).catch(() => {});
+    }
+    return null;
+  } finally { await unlink(tmp).catch(() => {}); }
 }
-async function ddinstagramFallback(url, id, options = {}) {
-  const cookie = options.cookiesPath ? await readFile(options.cookiesPath, 'utf8') : '';
-  const headers = cookie ? { ...IG_HEADERS, Cookie: cookie } : IG_HEADERS;
-  const parse = html => {
-    const match = html.match(/"video_url":"(https:[^"]+)"/) || html.match(/video_versions.*?"url":"(https:[^"]+)"/s);
-    if (!match) return null;
-    try { return decodeURIComponent(unescapeJson(match[1])); } catch { return unescapeJson(match[1]); }
-  };
-  for (const endpoint of [`https://www.ddinstagram.com/reel/${id}/`, ...(cookie ? [`https://www.instagram.com/reel/${id}/`] : [])]) {
+
+async function getDirect(id, options = {}) {
+  const cookie = cookieHeader(await cookieText(options));
+  const headers = cookie ? { 'User-Agent': UA, 'X-IG-App-ID': IG_APP_ID, Accept: '*/*', Cookie: cookie } : { 'User-Agent': UA, 'X-IG-App-ID': IG_APP_ID, Accept: '*/*' };
+  for (const pageUrl of [`https://www.instagram.com/reel/${id}/`, `https://www.instagram.com/p/${id}/`, `https://www.instagram.com/tv/${id}/`]) {
     try {
-      const response = await fetchWithRetry(endpoint, { headers: endpoint.includes('instagram.com/reel') ? { ...headers, 'X-IG-App-ID': '936619743392459' } : headers });
-      const video = parse(await response.text());
-      if (video) return { creator: CREATOR, platform: 'instagram', id, originalUrl: url, formats: [{ tag: 'DDINSTAGRAM', quality: 'best', type: 'mp4', url: video, hasAudio: true }], fallback: true, fallbackMethod: 'ddinstagram' };
-    } catch { /* try the next endpoint */ }
+      const response = await fetch(pageUrl, { headers, redirect: 'follow' });
+      if (!response.ok) continue;
+      const html = await response.text();
+      const match = html.match(/"video_url"\s*:\s*"(https:[^"]+)"/) || html.match(/"video_versions"\s*:\s*\[.*?\{"url"\s*:\s*"(https:[^"]+)"/s);
+      if (!match) continue;
+      const mediaUrl = unescapeJson(match[1]).replace(/\\u0026/g, '&').replace(/\\/g, '');
+      const media = await fetch(mediaUrl, { headers: { 'User-Agent': UA, Referer: 'https://www.instagram.com/' }, redirect: 'follow' });
+      if (!media.ok) continue;
+      const buffer = Buffer.from(await media.arrayBuffer());
+      if (buffer.length > 4096) return buffer;
+    } catch { /* try the next direct Instagram page */ }
   }
-  throw new NotFoundError('DDINSTAGRAM_EMPTY_MEDIA');
-}
-async function instagramFallbackInfo(url, id, options = {}) {
-  try { return normalizeFallback(await ytdlpInfo(url, options), url, id); }
-  catch { return ddinstagramFallback(url, id, options); }
-}
-async function instagramFallbackDownload(url, dest, options = {}) {
-  await mkdir(TMP_DIR, { recursive: true });
-  const base = `ig-${Date.now()}-${Math.random().toString(36).slice(2)}`;
-  const temp = outputFile(base);
-  try {
-    await runYtDlp(['--no-playlist', '--remote-components', 'ejs:github', '--js-runtimes', 'node', '--no-warnings', '--user-agent', UA, '--add-header', 'Referer:https://www.instagram.com/', '-f', 'best', '--merge-output-format', 'mp4', '-o', temp, ...cookieArgs(options), url]);
-    if (!await validFile(temp)) throw new Error('Instagram yt-dlp output was empty or too small.');
-    await rename(temp, dest);
-    return dest;
-  } catch (error) {
-    if (/ENOENT|not found|spawn/i.test(error.message)) throw new Error('Instagram blocked. Run npm i yt-dlp-exec or pip install yt-dlp');
-    throw error;
-  } finally { await cleanup(temp); }
+  return null;
 }
 
 async function instagramTier1(url, id, options = {}) {
   const requestHeaders = await headersFor(options);
-  const base = `https://www.instagram.com/${url.match(/\/(reel|p|tv)\//i)?.[1] || 'p'}/${id}/`;
+  const type = url.match(/\/(reel|reels|p|tv)\//i)?.[1] || 'p';
+  const base = `https://www.instagram.com/${type}/${id}/`;
   let response = await fetchWithRetry(`${base}?__a=1&__d=dis`, { headers: requestHeaders });
   let formats = [];
   let item;
@@ -84,7 +90,7 @@ async function instagramTier1(url, id, options = {}) {
       item = json.items?.[0] || json.data?.xdt_shortcode_media;
       const media = item?.carousel_media || [item];
       formats = sortFormats(media.flatMap((entry, index) => [
-        ...(entry?.video_versions || []).map(v => ({ tag: index ? `${index + 1}` : 'HD', quality: `${v.height || 720}p`, type: 'mp4', url: v.url })),
+        ...(entry?.video_versions || []).map(video => ({ tag: index ? `${index + 1}` : 'HD', quality: `${video.height || 720}p`, type: 'mp4', url: video.url })),
         entry?.image_versions2?.candidates?.[0] && { tag: 'IMG', quality: `${entry.image_versions2.candidates[0].width || 1080}x${entry.image_versions2.candidates[0].height || 1080}`, type: 'jpg', url: entry.image_versions2.candidates[0].url }
       ]));
     } catch { /* use embed fallback */ }
@@ -100,23 +106,24 @@ async function instagramTier1(url, id, options = {}) {
   return { creator: CREATOR, platform: 'instagram', id, username: item?.user?.username, author: item?.user?.username, caption: item?.caption?.text, originalUrl: url, formats };
 }
 
-/** Download metadata and direct formats for an Instagram post or reel. */
 export async function instagramDl(url, options = {}) {
   if (!isInstagramUrl(url)) throw new UnsupportedError('Invalid Instagram URL.');
   const cleanUrl = cleanInstagramUrl(url);
   const id = codeOf(cleanUrl);
   try { return await instagramTier1(cleanUrl, id, options); }
-  catch (error) {
-    if (!fallbackError(error)) throw error;
-    try { return await instagramFallbackInfo(cleanUrl, id, options); }
-    catch (fallback) { if (/ENOENT|not found|spawn/i.test(fallback.message)) throw new Error('Instagram blocked. Run npm i yt-dlp-exec or pip install yt-dlp'); throw fallback; }
-  }
+  catch (error) { if (!fallbackError(error)) throw error; return { creator: CREATOR, platform: 'instagram', id, originalUrl: cleanUrl, formats: [], fallback: true }; }
 }
 
-/** Save an Instagram video or image. */
 export async function instagramSave(url, dest = './ig.mp4', quality = 'best', options = {}) {
-  const result = await instagramDl(url, options);
-  if (result.fallback && result.fallbackMethod === 'ddinstagram') return downloadTo(result.formats[0].url, dest, { headers: await headersFor(options) });
-  if (result.fallback) return instagramFallbackDownload(cleanInstagramUrl(url), dest, options);
-  return saveResult(result, dest, quality, await headersFor(options));
+  if (!isInstagramUrl(url)) throw new UnsupportedError('Invalid Instagram URL.');
+  const cleanUrl = cleanInstagramUrl(url);
+  const id = codeOf(cleanUrl);
+  const ytDlpBuffer = await runInstagramYtDlp(cleanUrl, options);
+  if (ytDlpBuffer) { const { writeFile } = await import('node:fs/promises'); await writeFile(dest, ytDlpBuffer); return dest; }
+  const directBuffer = await getDirect(id, options);
+  if (directBuffer) { const { writeFile } = await import('node:fs/promises'); await writeFile(dest, directBuffer); return dest; }
+  try {
+    const result = await instagramTier1(cleanUrl, id, options);
+    return saveResult(result, dest, quality, await headersFor(options));
+  } catch { throw new NotFoundError('NOT_FOUND: Instagram empty media - use --cookies ~/cookies.txt'); }
 }

package/src/platforms/tiktok.js

@@ -8,7 +8,7 @@ import { saveResult, sortFormats } from '../utils/media.js';
 import { extractJson, getPath, unescapeJson } from '../utils/parser.js';
 import { NotFoundError, PrivateError, UnsupportedError } from '../errors.js';
 import { CREATOR } from '../constants.js';
-import { ytDlpDownloadUrl, ytDlpInfoUrl } from '../utils/ytdlp.js';
+import { cookieArgs, runYtDlp, ytDlpDownloadUrl, ytDlpInfoUrl } from '../utils/ytdlp.js';
 
 const execFileAsync = promisify(execFile);
 const UA = 'Mozilla/5.0 (Linux; Android 15) AppleWebKit/537.36 Chrome/131 Mobile Safari/537.36';
@@ -16,68 +16,79 @@ export const TIKWM_API = 'https://www.tikwm.com/api/';
 const clean = value => value && unescapeJson(value);
 
 export function isTikTokUrl(value) {
-  try { return new URL(value).hostname.toLowerCase().includes('tiktok.com'); } catch { return false; }
+  try {
+    const parsed = new URL(String(value).trim());
+    const host = parsed.hostname.toLowerCase().replace(/^www\./, '');
+    return (parsed.protocol === 'http:' || parsed.protocol === 'https:') && (host === 'tiktok.com' || host.endsWith('.tiktok.com'));
+  } catch { return false; }
 }
 
 export function validMediaBuffer(buffer) { return Buffer.isBuffer(buffer) && buffer.length > 4096; }
 
-async function tikwmApi(url) {
+async function resolveTikTokUrl(url) {
+  try {
+    const response = await fetch(url, { method: 'HEAD', redirect: 'follow', headers: { 'User-Agent': UA } });
+    return response.url || url;
+  } catch { return url; }
+}
+
+async function tikwmApi(inputUrl) {
+  const url = await resolveTikTokUrl(inputUrl);
   const response = await fetchWithRetry(TIKWM_API, {
     method: 'POST',
-    headers: { 'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8', 'User-Agent': UA, Referer: 'https://www.tikwm.com/' },
-    body: new URLSearchParams({ url, hd: '1' }).toString()
+    headers: { 'Content-Type': 'application/x-www-form-urlencoded', 'User-Agent': UA, Accept: '*/*', Referer: 'https://www.tikwm.com/', Origin: 'https://www.tikwm.com' },
+    body: new URLSearchParams({ url, hd: '1', full_data: '1' }).toString()
   });
-  if (!response.ok) throw new Error(`TIKWM_HTTP_${response.status}`);
-  const json = await response.json();
+  let json = response.ok ? await response.json() : null;
+  if (!json?.data) {
+    const retry = await fetchWithRetry(TIKWM_API, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/x-www-form-urlencoded', 'User-Agent': UA, Accept: '*/*', Referer: 'https://www.tikwm.com/' },
+      body: new URLSearchParams({ url, hd: '0' }).toString()
+    });
+    if (!retry.ok) throw new Error(`TIKWM_HTTP_${response.status || retry.status}`);
+    json = await retry.json();
+  }
   if (json?.code !== 0 || !json.data) throw new NotFoundError('TIKTOK_PRIVATE_OR_NOT_FOUND');
   return json.data;
 }
 
 async function getMedia(url) {
-  const response = await fetchWithRetry(url, { headers: { 'User-Agent': UA, Referer: 'https://www.tikwm.com/' } });
-  if (!response.ok) throw new Error(`TIKTOK_MEDIA_HTTP_${response.status}`);
-  const buffer = Buffer.from(await response.arrayBuffer());
-  if (!validMediaBuffer(buffer)) throw new Error('TIKTOK_MEDIA_TOO_SMALL');
-  return buffer;
+  const headersList = [
+    { Referer: 'https://www.tiktok.com/', Origin: 'https://www.tiktok.com' },
+    { Referer: 'https://www.tikwm.com/', Origin: 'https://www.tikwm.com' },
+    { Referer: 'https://m.tiktok.com/' }
+  ];
+  let lastError;
+  for (const extra of headersList) {
+    try {
+      const response = await fetchWithRetry(url, { headers: { 'User-Agent': UA, Accept: '*/*', ...extra } }, 0);
+      if (!response.ok) { lastError = new Error(`TIKTOK_MEDIA_HTTP_${response.status}`); continue; }
+      const buffer = Buffer.from(await response.arrayBuffer());
+      if (validMediaBuffer(buffer)) return buffer;
+      lastError = new Error('TIKTOK_MEDIA_TOO_SMALL');
+    } catch (error) { lastError = error; }
+  }
+  throw lastError || new Error('TIKTOK_MEDIA_FAILED');
 }
 
 function normalizeTikwm(data, originalUrl, id) {
   const author = data.author || {};
-  const video = data.hdplay || data.play;
+  const video = data.hdplay || data.play || data.wmplay;
   const formats = sortFormats([video && { tag: 'NOWM', quality: '720p', type: 'mp4', isNoWatermark: true, url: video }]);
-  return {
-    creator: CREATOR,
-    platform: 'tiktok',
-    id: String(data.id || id),
-    username: author.unique_id ? `@${author.unique_id}` : undefined,
-    author: author.nickname,
-    title: data.title,
-    views: data.play_count,
-    likes: data.digg_count,
-    comments: data.comment_count,
-    shares: data.share_count,
-    downloads: data.download_count,
-    originalUrl: data.share_url || originalUrl,
-    formats,
-    music: data.music,
-    fallback: true
-  };
+  return { creator: CREATOR, platform: 'tiktok', id: String(data.id || id), username: author.unique_id ? `@${author.unique_id}` : undefined, author: author.nickname, title: data.title, views: data.play_count, likes: data.digg_count, comments: data.comment_count, shares: data.share_count, downloads: data.download_count, originalUrl: data.share_url || originalUrl, formats, music: data.music, fallback: true };
 }
 function normalizeYtDlp(data, originalUrl, id) {
   const direct = data.url || data.requested_formats?.find(item => item.url)?.url;
   return { creator: CREATOR, platform: 'tiktok', id: data.id || id, author: data.uploader, title: data.title, originalUrl, formats: direct ? [{ tag: 'BEST', quality: `${data.height || 720}p`, type: 'mp4', url: direct, hasAudio: true }] : [], fallback: true, fallbackMethod: 'yt-dlp' };
 }
 
-async function tiktokFallback(url, id) {
-  const data = await tikwmApi(url);
-  return normalizeTikwm(data, url, id);
-}
+async function tiktokFallback(url, id) { return normalizeTikwm(await tikwmApi(url), url, id); }
 
-/** Download metadata and direct CDN formats for a TikTok video. */
 export async function tiktokDl(url, options = {}) {
   if (!isTikTokUrl(url)) throw new UnsupportedError('Invalid TikTok URL.');
   let resolved = url;
-  try { resolved = await resolveShortUrl(url); } catch { /* preserve the original URL for fallback providers */ }
+  try { resolved = await resolveShortUrl(url); } catch { resolved = await resolveTikTokUrl(url); }
   const id = resolved.match(/\/video\/(\d+)/)?.[1] || resolved.match(/\/v\/(\d+)/)?.[1] || new URL(resolved).pathname.split('/').filter(Boolean).pop() || url;
   if (!id) throw new UnsupportedError('Invalid TikTok URL.');
   const pageUrl = resolved.match(/\/video\//) ? resolved : `https://www.tiktok.com/@a/video/${id}`;
@@ -89,36 +100,38 @@ export async function tiktokDl(url, options = {}) {
     const item = getPath(json, '__DEFAULT_SCOPE__.webapp.video-detail.videoData.itemInfo.itemStruct');
     const play = clean(video?.playAddr) || clean(html.match(/"playAddr":"([^"]+)"/)?.[1]);
     const download = clean(video?.downloadAddr) || clean(html.match(/"downloadAddr":"([^"]+)"/)?.[1]);
-    const formats = sortFormats([
-      download && { tag: 'NOWM', quality: '720p', type: 'mp4', isNoWatermark: true, url: download },
-      play && { tag: 'WM', quality: '720p', type: 'mp4', isNoWatermark: false, url: play }
-    ]);
+    const formats = sortFormats([download && { tag: 'NOWM', quality: '720p', type: 'mp4', isNoWatermark: true, url: download }, play && { tag: 'WM', quality: '720p', type: 'mp4', isNoWatermark: false, url: play }]);
     if (!formats.length) throw new PrivateError('PRIVATE_OR_NOT_FOUND');
     return { creator: CREATOR, platform: 'tiktok', id, username: item?.author?.uniqueId ? `@${item.author.uniqueId}` : undefined, author: item?.author?.nickname, title: item?.desc, originalUrl: resolved, formats };
-  } catch (error) {
+  } catch {
     try { return normalizeYtDlp(await ytDlpInfoUrl(url, options), url, id); }
     catch { return tiktokFallback(url, id); }
   }
 }
 
-/** Download TikTok MP4 or MP3 bytes using Tier 1 first, then TikWM. */
-export async function tiktokDownload(url, format = 'mp4') {
+export async function tiktokDownload(url, format = 'mp4', options = {}) {
   const normalizedFormat = String(format).toLowerCase();
   if (!['mp3', 'mp4'].includes(normalizedFormat)) throw new UnsupportedError('Invalid TikTok format.');
-  const result = await tiktokDl(url);
+  const result = await tiktokDl(url, options);
+  if (result.fallbackMethod === 'yt-dlp') return ytDlpDownloadUrl(url, 'mp4', options);
   if (!result.fallback) {
     const wanted = result.formats[0];
     if (!wanted) throw new NotFoundError('PRIVATE_OR_NOT_FOUND');
-    if (normalizedFormat === 'mp4') return { buffer: await getMedia(wanted.url), mimetype: 'video/mp4', extension: 'mp4' };
+    if (normalizedFormat === 'mp4') {
+      try { return { buffer: await getMedia(wanted.url), mimetype: 'video/mp4', extension: 'mp4' }; }
+      catch { return ytDlpDownloadUrl(url, 'mp4', options); }
+    }
   }
   const data = await tikwmApi(url);
-  if (normalizedFormat === 'mp4') return { buffer: await getMedia(data.hdplay || data.play), mimetype: 'video/mp4', extension: 'mp4' };
+  if (normalizedFormat === 'mp4') {
+    try { return { buffer: await getMedia(data.hdplay || data.play || data.wmplay), mimetype: 'video/mp4', extension: 'mp4' }; }
+    catch { return ytDlpDownloadUrl(url, 'mp4', options); }
+  }
   if (data.music) return { buffer: await getMedia(data.music), mimetype: 'audio/mpeg', extension: 'mp3' };
-  const video = await getMedia(data.hdplay || data.play);
+  const video = await getMedia(data.hdplay || data.play || data.wmplay);
   const dir = join(process.cwd(), 'cache', 'temp');
   const base = join(dir, `tt-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`);
-  const input = `${base}.mp4`;
-  const output = `${base}.mp3`;
+  const input = `${base}.mp4`, output = `${base}.mp3`;
   await mkdir(dir, { recursive: true });
   try {
     await writeFile(input, video);
@@ -126,12 +139,9 @@ export async function tiktokDownload(url, format = 'mp4') {
     const buffer = await readFile(output);
     if (!validMediaBuffer(buffer)) throw new Error('TIKTOK_AUDIO_TOO_SMALL');
     return { buffer, mimetype: 'audio/mpeg', extension: 'mp3' };
-  } finally {
-    await Promise.allSettled([unlink(input), unlink(output)]);
-  }
+  } finally { await Promise.allSettled([unlink(input), unlink(output)]); }
 }
 
-/** Save a TikTok video to disk. */
 export async function tiktokSave(url, dest = './tt.mp4', quality = 'best', options = {}) {
   const result = await tiktokDl(url, options);
   if (result.fallbackMethod === 'yt-dlp') {
@@ -140,7 +150,7 @@ export async function tiktokSave(url, dest = './tt.mp4', quality = 'best', optio
     return dest;
   }
   if (result.fallback) {
-    const output = await tiktokDownload(url, dest.toLowerCase().endsWith('.mp3') ? 'mp3' : 'mp4');
+    const output = await tiktokDownload(url, dest.toLowerCase().endsWith('.mp3') ? 'mp3' : 'mp4', options);
     await writeFile(dest, output.buffer);
     return dest;
   }