social-dl 0.9.7 → 1.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "social-dl",
-  "version": "0.9.7",
+  "version": "1.3.0",
   "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/facebook.js

@@ -1,100 +1,136 @@
-import { mkdir, rename, stat, unlink } from 'node:fs/promises';
-import { join } from 'node:path';
-import { fetchWithRetry } from '../utils/fetcher.js';
-import { sortFormats, saveResult } from '../utils/media.js';
-import { cookieArgs, runYtDlp } from '../utils/ytdlp.js';
-import { NotFoundError, PrivateError, UnsupportedError } from '../errors.js';
-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';
-const FB_HEADERS = { 'User-Agent': UA, Accept: '*/*', 'Accept-Language': 'en-US,en;q=0.9', Referer: 'https://www.facebook.com/', Origin: 'https://www.facebook.com/' };
-const unescape = value => { try { return JSON.parse(`"${value}"`); } catch { return value.replace(/\\u0025/g, '%').replace(/\\u0026/g, '&').replace(/\\\//g, '/'); } };
+import { execFile } from 'child_process'
+import { promisify } from 'util'
+import { mkdir, readFile, stat, unlink, writeFile } from 'fs/promises'
+import { join } from 'path'
+const execFileAsync = promisify(execFile)
+const TMP_DIR = 'cache/temp'
+const UA = 'Mozilla/5.0 (Linux; Android 15) AppleWebKit/537.36 Chrome/131 Mobile Safari/537.36'
+const FB_HEADERS = {
+  'User-Agent': UA,
+  'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+  'Accept-Language': 'en-US,en;q=0.9',
+  'Referer': 'https://www.facebook.com/',
+  'Sec-Fetch-Mode': 'navigate'
+}
 
-export function isFacebookUrl(value) {
+export const isUrl = (value) => {
   try {
-    const parsed = new URL(value);
-    return /facebook\.com\/share\/r\//i.test(parsed.href)
-      || /fb\.watch/i.test(parsed.hostname)
-      || /facebook\.com\/reel\//i.test(parsed.href)
-      || /web\.facebook\.com\/reel\//i.test(parsed.href)
-      || /facebook\.com\/watch/i.test(parsed.href);
-  } catch { return false; }
+    const u = new URL(String(value).trim())
+    const h = u.hostname.toLowerCase().replace(/^www\./,'')
+    return (h==='facebook.com' || h.endsWith('.facebook.com') || h==='fb.watch' || h==='fb.com') && /reel|watch|video|share|story/i.test(u.pathname + u.search)
+  } catch { return false }
 }
 
-function extract(html) {
-  const find = name => { const match = html.match(new RegExp(`"${name}":"([^"]+)"`)); return match && unescape(match[1]); };
-  const hd = find('browser_native_hd_url') || find('playable_url_quality_hd');
-  const sd = find('browser_native_sd_url') || find('playable_url');
-  return sortFormats([
-    hd && { tag: 'HD', quality: '720p', type: 'mp4', url: hd },
-    sd && { tag: 'SD', quality: '360p', type: 'mp4', url: sd }
-  ]);
+export function cleanFbUrl(value){
+  try{
+    const u = new URL(String(value).trim())
+    for(const k of [...u.searchParams.keys()]){
+      if(k.startsWith('utm_') || k==='fbclid' || k==='mibextid') u.searchParams.delete(k)
+    }
+    return u.toString()
+  }catch{ return String(value).split('?')[0] }
 }
 
-function idOf(url) { return url.match(/reel\/(\d+)|videos\/(\d+)|[?&]v=(\d+)|\/(\d+)\/?/)?.slice(1).find(Boolean) || url; }
-function fallbackError(error) { return error instanceof PrivateError || error instanceof NotFoundError || /PRIVATE|NOT_FOUND|empty|404|403|login|checkpoint/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, ...cookieArgs(options), url]);
-  const line = stdout.trim().split(/\r?\n/).find(Boolean);
-  if (!line) throw new Error('yt-dlp returned no Facebook video information.');
-  return JSON.parse(line);
+async function validFile(file){
+  try{ const s = await stat(file); return s.isFile() && s.size > 4096 }catch{ return false }
 }
-function normalizeFallback(data, url) {
-  const direct = data.url || data.requested_formats?.find(item => item.url)?.url;
-  return { creator: CREATOR, platform: 'facebook', id: data.id || idOf(url), title: data.title, author: data.uploader || data.channel, originalUrl: url, formats: direct ? [{ tag: 'BEST', quality: `${data.height || 720}p`, type: 'mp4', url: direct, hasAudio: true }] : [], fallback: true };
+
+async function runFbYtDlp(url){
+  const dir = join(process.cwd(), TMP_DIR); await mkdir(dir, {recursive:true})
+  const tmp = join(dir, `fb-${Date.now()}-${Math.random().toString(36).slice(2,8)}.mp4`)
+  const attempts = [
+    ['--remote-components','ejs:github','--js-runtimes','node','--no-playlist','--no-warnings','-o',tmp, url],
+    ['--remote-components','ejs:github','--js-runtimes','node','--no-playlist','-f','bv*+ba/best','--merge-output-format','mp4','-o',tmp, url],
+    ['--remote-components','ejs:github','--js-runtimes','node','--no-playlist','--user-agent',UA,'-o',tmp, url]
+  ]
+  try{
+    for(const args of attempts){
+      try{ await execFileAsync('yt-dlp', args, {maxBuffer:64*1024*1024}) }catch(e){}
+      if(await validFile(tmp)) return await readFile(tmp)
+      await unlink(tmp).catch(()=>{})
+    }
+    return null
+  }finally{ await unlink(tmp).catch(()=>{}) }
 }
-async function facebookFallbackInfo(url, options) { return normalizeFallback(await ytdlpInfo(url, options), url); }
 
-async function facebookFallbackDownload(url, dest, options = {}) {
-  await mkdir(TMP_DIR, { recursive: true });
-  const base = `fb-${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, '-f', 'bv*[ext=mp4][vcodec^=avc1][height<=1080]+ba[ext=m4a]/b[ext=mp4]/best', '--merge-output-format', 'mp4', '-o', temp, ...cookieArgs(options), url]);
-    if (!await validFile(temp)) throw new Error('Facebook 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('Facebook blocked. Run npm i yt-dlp-exec or pip install yt-dlp');
-    throw error;
-  } finally { await cleanup(temp); }
+function extractFbVideoUrl(html){
+  // Facebook stores urls escaped
+  const patterns = [
+    /"browser_native_hd_url":"([^"]+)"/,
+    /"browser_native_sd_url":"([^"]+)"/,
+    /"playable_url_quality_hd":"([^"]+)"/,
+    /"playable_url":"([^"]+)"/,
+    /"playable_url_low":"([^"]+)"/,
+    /hd_src":"([^"]+)"/,
+    /sd_src":"([^"]+)"/
+  ]
+  for(const re of patterns){
+    const m = html.match(re)
+    if(m){
+      let url = m[1]
+        .replace(/\\u0025/g,'%').replace(/\\u0026/g,'&').replace(/\\\//g,'/').replace(/\\/g,'')
+      try{ url = JSON.parse(`"${url}"`) }catch{}
+      try{ url = decodeURIComponent(url) }catch{}
+      if(url.startsWith('https://') && url.includes('.mp4')) return url
+    }
+  }
+  return null
 }
 
-async function facebookTier1(url) {
-  const resolved = await fetchWithRetry(url, { headers: FB_HEADERS });
-  const originalUrl = resolved.url || url;
-  const id = idOf(originalUrl);
-  let html = await (await fetchWithRetry(originalUrl, { headers: FB_HEADERS })).text();
-  let formats = extract(html);
-  if (html.length < 5000 || formats.length === 0) {
-    await new Promise(resolve => setTimeout(resolve, 1000));
-    const basicUrl = originalUrl.replace(/www\.facebook\.com/i, 'mbasic.facebook.com');
-    html = await (await fetchWithRetry(basicUrl, { headers: FB_HEADERS })).text();
-    formats = extract(html);
+async function getDirectFb(url){
+  // Try mobile and desktop UAs
+  const urlsToTry = [url, url.replace('www.facebook.com','m.facebook.com')]
+  for(const tryUrl of urlsToTry){
+    try{
+      const res = await fetch(tryUrl, { headers: FB_HEADERS, redirect:'follow' })
+      if(!res.ok) continue
+      const html = await res.text()
+      const videoUrl = extractFbVideoUrl(html)
+      if(!videoUrl) continue
+      const vRes = await fetch(videoUrl, { headers: { 'User-Agent': UA, 'Referer':'https://www.facebook.com/' }, redirect:'follow' })
+      if(!vRes.ok) continue
+      const buf = Buffer.from(await vRes.arrayBuffer())
+      if(buf.length > 4096) return buf
+    }catch{}
   }
-  if (!formats.length) { if (/login|checkpoint|not found/i.test(html)) throw new PrivateError(); throw new NotFoundError('PRIVATE_OR_NOT_FOUND'); }
-  return { creator: CREATOR, platform: 'facebook', id, originalUrl, formats };
+  return null
+}
+
+export async function info(url){
+  if(!isUrl(url)) throw new Error('Invalid Facebook URL')
+  const clean = cleanFbUrl(url)
+  return { url: clean, title: 'Facebook video', platform: 'facebook', originalUrl: clean }
 }
 
-/** Download metadata for a Facebook video or reel. */
-export async function facebookDl(url, options = {}) {
-  if (!isFacebookUrl(url)) throw new UnsupportedError('Invalid Facebook URL.');
-  try { return await facebookTier1(url); }
-  catch (error) {
-    if (!fallbackError(error)) throw error;
-    try { return await facebookFallbackInfo(url, options); }
-    catch (fallback) { if (/ENOENT|not found|spawn/i.test(fallback.message)) throw new Error('Facebook blocked. Run npm i yt-dlp-exec or pip install yt-dlp'); throw fallback; }
+export async function download(url, format='mp4'){
+  if(!isUrl(url)) throw new Error('Invalid Facebook URL')
+  const clean = cleanFbUrl(url)
+  // Tier1 yt-dlp (currently broken upstream but keep)
+  let buffer = await runFbYtDlp(clean)
+  // Tier2 direct scrape fallback - works even when yt-dlp parser broken
+  if(!buffer) buffer = await getDirectFb(clean)
+  if(!buffer || buffer.length <= 4096) throw new Error('NOT_FOUND: Facebook empty media - FB changed html. This is upstream yt-dlp bug, try different public reel or wait for yt-dlp update.')
+  format = String(format||'mp4').toLowerCase()
+  if(format === 'mp4') return { buffer, mimetype:'video/mp4', extension:'mp4' }
+  const dir = join(process.cwd(), TMP_DIR); await mkdir(dir,{recursive:true})
+  const base = `fb-${Date.now()}-${Math.random().toString(36).slice(2,8)}`
+  const input = join(dir, `${base}.mp4`); const output = join(dir, `${base}.mp3`)
+  try{
+    await writeFile(input, buffer)
+    await execFileAsync('ffmpeg',['-y','-i',input,'-vn','-c:a','libmp3lame','-q:a','2',output])
+    const audio = await readFile(output)
+    if(!audio || audio.length <= 4096) throw new Error('EMPTY_AUDIO')
+    return { buffer: audio, mimetype:'audio/mpeg', extension:'mp3' }
+  }finally{
+    await unlink(input).catch(()=>{})
+    await unlink(output).catch(()=>{})
   }
 }
 
-/** Save a Facebook video to disk. */
-export async function facebookSave(url, dest = './video.mp4', quality = 'best', options = {}) {
-  const result = await facebookDl(url, options);
-  if (result.fallback) return facebookFallbackDownload(url, dest, options);
-  return saveResult(result, dest, quality, FB_HEADERS);
+export const isFacebookUrl = isUrl
+export const facebookDl = info
+export const facebookSave = async (url, dest='./fb.mp4') => {
+  const { buffer } = await download(url, 'mp4')
+  await writeFile(dest, buffer)
+  return dest
 }

package/src/platforms/facebook.js#supposed to work

@@ -0,0 +1,100 @@
+import { mkdir, rename, stat, unlink } from 'node:fs/promises';
+import { join } from 'node:path';
+import { fetchWithRetry } from '../utils/fetcher.js';
+import { sortFormats, saveResult } from '../utils/media.js';
+import { cookieArgs, runYtDlp } from '../utils/ytdlp.js';
+import { NotFoundError, PrivateError, UnsupportedError } from '../errors.js';
+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';
+const FB_HEADERS = { 'User-Agent': UA, Accept: '*/*', 'Accept-Language': 'en-US,en;q=0.9', Referer: 'https://www.facebook.com/', Origin: 'https://www.facebook.com/' };
+const unescape = value => { try { return JSON.parse(`"${value}"`); } catch { return value.replace(/\\u0025/g, '%').replace(/\\u0026/g, '&').replace(/\\\//g, '/'); } };
+
+export function isFacebookUrl(value) {
+  try {
+    const parsed = new URL(value);
+    return /facebook\.com\/share\/r\//i.test(parsed.href)
+      || /fb\.watch/i.test(parsed.hostname)
+      || /facebook\.com\/reel\//i.test(parsed.href)
+      || /web\.facebook\.com\/reel\//i.test(parsed.href)
+      || /facebook\.com\/watch/i.test(parsed.href);
+  } catch { return false; }
+}
+
+function extract(html) {
+  const find = name => { const match = html.match(new RegExp(`"${name}":"([^"]+)"`)); return match && unescape(match[1]); };
+  const hd = find('browser_native_hd_url') || find('playable_url_quality_hd');
+  const sd = find('browser_native_sd_url') || find('playable_url');
+  return sortFormats([
+    hd && { tag: 'HD', quality: '720p', type: 'mp4', url: hd },
+    sd && { tag: 'SD', quality: '360p', type: 'mp4', url: sd }
+  ]);
+}
+
+function idOf(url) { return url.match(/reel\/(\d+)|videos\/(\d+)|[?&]v=(\d+)|\/(\d+)\/?/)?.slice(1).find(Boolean) || url; }
+function fallbackError(error) { return error instanceof PrivateError || error instanceof NotFoundError || /PRIVATE|NOT_FOUND|empty|404|403|login|checkpoint/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, ...cookieArgs(options), url]);
+  const line = stdout.trim().split(/\r?\n/).find(Boolean);
+  if (!line) throw new Error('yt-dlp returned no Facebook video information.');
+  return JSON.parse(line);
+}
+function normalizeFallback(data, url) {
+  const direct = data.url || data.requested_formats?.find(item => item.url)?.url;
+  return { creator: CREATOR, platform: 'facebook', id: data.id || idOf(url), title: data.title, author: data.uploader || data.channel, originalUrl: url, formats: direct ? [{ tag: 'BEST', quality: `${data.height || 720}p`, type: 'mp4', url: direct, hasAudio: true }] : [], fallback: true };
+}
+async function facebookFallbackInfo(url, options) { return normalizeFallback(await ytdlpInfo(url, options), url); }
+
+async function facebookFallbackDownload(url, dest, options = {}) {
+  await mkdir(TMP_DIR, { recursive: true });
+  const base = `fb-${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, '-f', 'bv*[ext=mp4][vcodec^=avc1][height<=1080]+ba[ext=m4a]/b[ext=mp4]/best', '--merge-output-format', 'mp4', '-o', temp, ...cookieArgs(options), url]);
+    if (!await validFile(temp)) throw new Error('Facebook 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('Facebook blocked. Run npm i yt-dlp-exec or pip install yt-dlp');
+    throw error;
+  } finally { await cleanup(temp); }
+}
+
+async function facebookTier1(url) {
+  const resolved = await fetchWithRetry(url, { headers: FB_HEADERS });
+  const originalUrl = resolved.url || url;
+  const id = idOf(originalUrl);
+  let html = await (await fetchWithRetry(originalUrl, { headers: FB_HEADERS })).text();
+  let formats = extract(html);
+  if (html.length < 5000 || formats.length === 0) {
+    await new Promise(resolve => setTimeout(resolve, 1000));
+    const basicUrl = originalUrl.replace(/www\.facebook\.com/i, 'mbasic.facebook.com');
+    html = await (await fetchWithRetry(basicUrl, { headers: FB_HEADERS })).text();
+    formats = extract(html);
+  }
+  if (!formats.length) { if (/login|checkpoint|not found/i.test(html)) throw new PrivateError(); throw new NotFoundError('PRIVATE_OR_NOT_FOUND'); }
+  return { creator: CREATOR, platform: 'facebook', id, originalUrl, formats };
+}
+
+/** Download metadata for a Facebook video or reel. */
+export async function facebookDl(url, options = {}) {
+  if (!isFacebookUrl(url)) throw new UnsupportedError('Invalid Facebook URL.');
+  try { return await facebookTier1(url); }
+  catch (error) {
+    if (!fallbackError(error)) throw error;
+    try { return await facebookFallbackInfo(url, options); }
+    catch (fallback) { if (/ENOENT|not found|spawn/i.test(fallback.message)) throw new Error('Facebook blocked. Run npm i yt-dlp-exec or pip install yt-dlp'); throw fallback; }
+  }
+}
+
+/** Save a Facebook video to disk. */
+export async function facebookSave(url, dest = './video.mp4', quality = 'best', options = {}) {
+  const result = await facebookDl(url, options);
+  if (result.fallback) return facebookFallbackDownload(url, dest, options);
+  return saveResult(result, dest, quality, FB_HEADERS);
+}

package/src/platforms/instagram.js

@@ -1,129 +1,107 @@
-import { mkdir, readFile, rename, stat, unlink } from 'node:fs/promises';
-import { join } from 'node:path';
-import { fetchWithRetry, downloadTo } from '../utils/fetcher.js';
-import { saveResult, sortFormats } from '../utils/media.js';
-import { cookieArgs, runYtDlp } from '../utils/ytdlp.js';
-import { unescapeJson } from '../utils/parser.js';
-import { NotFoundError, PrivateError, UnsupportedError } from '../errors.js';
-import { CREATOR } from '../constants.js';
+import { execFile } from 'child_process'
+import { promisify } from 'util'
+import { mkdir, readFile, stat, unlink, writeFile } from 'fs/promises'
+import { join } from 'path'
+const execFileAsync = promisify(execFile)
+const UA = 'Mozilla/5.0 (Linux; Android 15) AppleWebKit/537.36 Chrome/131 Mobile Safari/537.36'
+const TMP_DIR = 'cache/temp'
+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/' }
 
-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(/\/(?:reel|reels|p|tv)\/([A-Za-z0-9_-]+)/i)?.[1];
+const codeOf = url => new URL(url).pathname.match(/\/(?:reel|reels|p|tv)\/([A-Za-z0-9_-]+)/i)?.[1]
 
-export function isInstagramUrl(value) {
+export const isUrl = (value) => {
   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; }
+    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('; ');
+
+export function cleanIgUrl(value){
+  try{
+    const u = new URL(String(value).trim())
+    for(const k of [...u.searchParams.keys()]){
+      if(k.startsWith('utm_') || k==='igsh' || k==='igshid' || k.toLowerCase().includes('stkn') || k==='fbclid') u.searchParams.delete(k)
+    }
+    return `${u.origin}${u.pathname.endsWith('/')? u.pathname : `${u.pathname}/`}`
+  }catch{ return String(value).split('?')[0] }
 }
-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 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 })));
+export const cleanInstagramUrl = cleanIgUrl
+
+async function validFile(file){
+  try{ const s = await stat(file); return s.isFile() && s.size > 4096 }catch{ return false }
 }
-function fallbackError(error) { return error instanceof PrivateError || error instanceof NotFoundError || /PRIVATE|NOT_FOUND|LOGIN|404|403|empty|accounts\/login/i.test(error?.message || ''); }
-async function validFile(file) { try { return (await stat(file)).isFile() && (await stat(file)).size > 4096; } catch { return false; } }
 
-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(() => {});
+async function runInstagramYtDlp(url){
+  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 baseArgs = ['--remote-components','ejs:github','--js-runtimes','node','--no-playlist','-o',tmp, url]
+  const fallbackArgs = ['--remote-components','ejs:github','--js-runtimes','node','--no-playlist','-f','bv*+ba/best','--merge-output-format','mp4','-o',tmp, url]
+  try{
+    for(const args of [baseArgs, fallbackArgs]){
+      try{ await execFileAsync('yt-dlp', args, {maxBuffer:64*1024*1024}) }catch(e){ console.error('yt-dlp failed:', e?.stderr || e?.message) }
+      if(await validFile(tmp)) return await readFile(tmp)
+      await unlink(tmp).catch(()=>{})
     }
-    return null;
-  } finally { await unlink(tmp).catch(() => {}); }
+    return null
+  }finally{ await unlink(tmp).catch(()=>{}) }
 }
 
-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 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 */ }
+async function getDirect(id){
+  for(const pageUrl of [`https://www.instagram.com/reel/${id}/`, `https://www.instagram.com/p/${id}/`, `https://www.instagram.com/tv/${id}/`]){
+    try{
+      const res = await fetch(pageUrl, { headers: IG_HEADERS, redirect:'follow' })
+      if(!res.ok) continue
+      const html = await res.text()
+      const m = html.match(/"video_url"\s*:\s*"(https:[^"]+)"/) || html.match(/"video_versions"\s*:\s*\[.*?\{"url"\s*:\s*"(https:[^"]+)"/s)
+      if(!m) continue
+      let mediaUrl = m[1].replace(/\\u0026/g,'&').replace(/\\/g,'').replace(/\u0026/g,'&')
+      try{ mediaUrl = JSON.parse(`"${mediaUrl}"`) }catch{}
+      const media = await fetch(mediaUrl, { headers:{'User-Agent':UA, Referer:'https://www.instagram.com/'}, redirect:'follow' })
+      if(!media.ok) continue
+      const buf = Buffer.from(await media.arrayBuffer())
+      if(buf.length > 4096) return buf
+    }catch{}
   }
-  return null;
+  return null
 }
 
-async function instagramTier1(url, id, options = {}) {
-  const requestHeaders = await headersFor(options);
-  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;
-  if (response.ok) {
-    try {
-      const json = await response.json();
-      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(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 */ }
-  }
-  if (!formats.length) {
-    response = await fetchWithRetry(`${base}embed/`, { headers: requestHeaders });
-    const html = await response.text();
-    if (response.url.includes('/accounts/login')) throw new PrivateError();
-    formats = fromHtml(html);
-    if (!formats.length) { const image = html.match(/"display_url":"([^"]+)"/); if (image) formats.push({ tag: 'IMG', quality: '1080x1080', type: 'jpg', url: unescapeJson(image[1]) }); }
-  }
-  if (!formats.length) throw new NotFoundError('NOT_FOUND');
-  return { creator: CREATOR, platform: 'instagram', id, username: item?.user?.username, author: item?.user?.username, caption: item?.caption?.text, originalUrl: url, formats };
+export async function info(url){
+  if(!isUrl(url)) throw new Error('Invalid Instagram URL')
+  const clean = cleanIgUrl(url)
+  const id = codeOf(clean)
+  return { id, url: clean, title: 'IG Reel', originalUrl: clean, thumbnail: null, platform: 'instagram' }
 }
 
-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; return { creator: CREATOR, platform: 'instagram', id, originalUrl: cleanUrl, formats: [], fallback: true }; }
+export async function download(url, format='mp4'){
+  if(!isUrl(url)) throw new Error('Invalid Instagram URL')
+  const clean = cleanIgUrl(url)
+  const id = codeOf(clean)
+  let buffer = await runInstagramYtDlp(clean)
+  if(!buffer) buffer = await getDirect(id)
+  if(!buffer || buffer.length <= 4096) throw new Error('NOT_FOUND: Instagram empty media - IG blocks datacenter. Test in Termux, not Cody.')
+  format = String(format||'mp4').toLowerCase()
+  if(format === 'mp4') return { buffer, mimetype:'video/mp4', extension:'mp4' }
+  const dir = join(process.cwd(), TMP_DIR); await mkdir(dir,{recursive:true})
+  const base = `ig-${Date.now()}-${Math.random().toString(36).slice(2,8)}`
+  const input = join(dir, `${base}.mp4`); const output = join(dir, `${base}.mp3`)
+  try{
+    await writeFile(input, buffer)
+    await execFileAsync('ffmpeg',['-y','-i',input,'-vn','-c:a','libmp3lame','-q:a','2',output])
+    const audio = await readFile(output)
+    if(!audio || audio.length <= 4096) throw new Error('EMPTY_AUDIO')
+    return { buffer: audio, mimetype:'audio/mpeg', extension:'mp3' }
+  }finally{
+    await unlink(input).catch(()=>{})
+    await unlink(output).catch(()=>{})
+  }
 }
 
-export async function instagramSave(url, dest = './ig.mp4', quality = 'best', 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'); }
+export const isInstagramUrl = isUrl
+export const instagramDl = info
+export const instagramSave = async (url, dest='./ig.mp4', quality='best') => {
+  const { buffer } = await download(url, 'mp4')
+  await writeFile(dest, buffer)
+  return dest
 }

package/src/platforms/instagram.js @,bro_says_failed

@@ -0,0 +1,129 @@
+import { mkdir, readFile, rename, stat, unlink } from 'node:fs/promises';
+import { join } from 'node:path';
+import { fetchWithRetry, downloadTo } from '../utils/fetcher.js';
+import { saveResult, sortFormats } from '../utils/media.js';
+import { cookieArgs, runYtDlp } from '../utils/ytdlp.js';
+import { unescapeJson } from '../utils/parser.js';
+import { NotFoundError, PrivateError, UnsupportedError } from '../errors.js';
+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(/\/(?:reel|reels|p|tv)\/([A-Za-z0-9_-]+)/i)?.[1];
+
+export function isInstagramUrl(value) {
+  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 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 || ''); }
+async function validFile(file) { try { return (await stat(file)).isFile() && (await stat(file)).size > 4096; } catch { return false; } }
+
+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 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 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 */ }
+  }
+  return null;
+}
+
+async function instagramTier1(url, id, options = {}) {
+  const requestHeaders = await headersFor(options);
+  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;
+  if (response.ok) {
+    try {
+      const json = await response.json();
+      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(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 */ }
+  }
+  if (!formats.length) {
+    response = await fetchWithRetry(`${base}embed/`, { headers: requestHeaders });
+    const html = await response.text();
+    if (response.url.includes('/accounts/login')) throw new PrivateError();
+    formats = fromHtml(html);
+    if (!formats.length) { const image = html.match(/"display_url":"([^"]+)"/); if (image) formats.push({ tag: 'IMG', quality: '1080x1080', type: 'jpg', url: unescapeJson(image[1]) }); }
+  }
+  if (!formats.length) throw new NotFoundError('NOT_FOUND');
+  return { creator: CREATOR, platform: 'instagram', id, username: item?.user?.username, author: item?.user?.username, caption: item?.caption?.text, originalUrl: url, formats };
+}
+
+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; return { creator: CREATOR, platform: 'instagram', id, originalUrl: cleanUrl, formats: [], fallback: true }; }
+}
+
+export async function instagramSave(url, dest = './ig.mp4', quality = 'best', 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/instagram.js#should have worked but mistake in wrapper

@@ -0,0 +1,110 @@
+import { execFile } from 'child_process'
+import { promisify } from 'util'
+import { mkdir, readFile, stat, unlink, writeFile } from 'fs/promises'
+import { join } from 'path'
+const execFileAsync = promisify(execFile)
+const UA = 'Mozilla/5.0 (Linux; Android 15) AppleWebKit/537.36 Chrome/131 Mobile Safari/537.36'
+const TMP_DIR = 'cache/temp'
+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(/\/(?:reel|reels|p|tv)\/([A-Za-z0-9_-]+)/i)?.[1]
+
+export const isUrl = (value) => {
+  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 cleanIgUrl(value){
+  try{
+    const u = new URL(String(value).trim())
+    for(const k of [...u.searchParams.keys()]){
+      if(k.startsWith('utm_') || k==='igsh' || k==='igshid' || k.toLowerCase().includes('stkn') || k==='fbclid') u.searchParams.delete(k)
+    }
+    return `${u.origin}${u.pathname.endsWith('/')? u.pathname : `${u.pathname}/`}`
+  }catch{ return String(value).split('?')[0] }
+}
+export const cleanInstagramUrl = cleanIgUrl
+
+async function validFile(file){
+  try{ const s = await stat(file); return s.isFile() && s.size > 4096 }catch{ return false }
+}
+
+async function runInstagramYtDlp(url){
+  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 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, url],
+    [...common,'-f','bv*[ext=mp4]+ba[ext=m4a]/b[ext=mp4]/best','--merge-output-format','mp4','-o',tmp, url]
+  ]
+  try{
+    for(const args of attempts){
+      try{ await execFileAsync('yt-dlp', args, {maxBuffer:64*1024*1024}) }catch{}
+      if(await validFile(tmp)) return await readFile(tmp)
+      await unlink(tmp).catch(()=>{})
+    }
+    return null
+  }finally{ await unlink(tmp).catch(()=>{}) }
+}
+
+async function getDirect(id){
+  for(const pageUrl of [`https://www.instagram.com/reel/${id}/`, `https://www.instagram.com/p/${id}/`, `https://www.instagram.com/tv/${id}/`]){
+    try{
+      const res = await fetch(pageUrl, { headers: IG_HEADERS, redirect:'follow' })
+      if(!res.ok) continue
+      const html = await res.text()
+      const m = html.match(/"video_url"\s*:\s*"(https:[^"]+)"/) || html.match(/"video_versions"\s*:\s*\[.*?\{"url"\s*:\s*"(https:[^"]+)"/s)
+      if(!m) continue
+      let mediaUrl = m[1].replace(/\\u0026/g,'&').replace(/\\/g,'').replace(/\u0026/g,'&')
+      try{ mediaUrl = JSON.parse(`"${mediaUrl}"`) }catch{}
+      const media = await fetch(mediaUrl, { headers:{'User-Agent':UA, Referer:'https://www.instagram.com/'}, redirect:'follow' })
+      if(!media.ok) continue
+      const buf = Buffer.from(await media.arrayBuffer())
+      if(buf.length > 4096) return buf
+    }catch{}
+  }
+  return null
+}
+
+export async function info(url){
+  if(!isUrl(url)) throw new Error('Invalid Instagram URL')
+  const clean = cleanIgUrl(url)
+  const id = codeOf(clean)
+  return { id, url: clean, title: 'IG Reel', originalUrl: clean, thumbnail: null, platform: 'instagram' }
+}
+
+export async function download(url, format='mp4'){
+  if(!isUrl(url)) throw new Error('Invalid Instagram URL')
+  const clean = cleanIgUrl(url)
+  const id = codeOf(clean)
+  let buffer = await runInstagramYtDlp(clean)
+  if(!buffer) buffer = await getDirect(id)
+  if(!buffer || buffer.length <= 4096) throw new Error('NOT_FOUND: Instagram empty media - IG blocks datacenter. Test in Termux, not Cody.')
+  format = String(format||'mp4').toLowerCase()
+  if(format === 'mp4') return { buffer, mimetype:'video/mp4', extension:'mp4' }
+  const dir = join(process.cwd(), TMP_DIR); await mkdir(dir,{recursive:true})
+  const base = `ig-${Date.now()}-${Math.random().toString(36).slice(2,8)}`
+  const input = join(dir, `${base}.mp4`); const output = join(dir, `${base}.mp3`)
+  try{
+    await writeFile(input, buffer)
+    await execFileAsync('ffmpeg',['-y','-i',input,'-vn','-c:a','libmp3lame','-q:a','2',output])
+    const audio = await readFile(output)
+    if(!audio || audio.length <= 4096) throw new Error('EMPTY_AUDIO')
+    return { buffer: audio, mimetype:'audio/mpeg', extension:'mp3' }
+  }finally{
+    await unlink(input).catch(()=>{})
+    await unlink(output).catch(()=>{})
+  }
+}
+
+export const isInstagramUrl = isUrl
+export const instagramDl = info
+export const instagramSave = async (url, dest='./ig.mp4', quality='best') => {
+  const { buffer } = await download(url, 'mp4')
+  await writeFile(dest, buffer)
+  return dest
+}

package/src/platforms/tiktok.js

@@ -1,163 +1,62 @@
-import { execFile } from 'node:child_process';
-import { promisify } from 'node:util';
-import { mkdir, readFile, unlink, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import { fetchWithRetry } from '../utils/fetcher.js';
-import { resolveShortUrl } from '../utils/resolver.js';
-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 { 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';
-export const TIKWM_API = 'https://www.tikwm.com/api/';
-const clean = value => value && unescapeJson(value);
-
-export function isTikTokUrl(value) {
-  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 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', 'User-Agent': UA, Accept: '*/*', Referer: 'https://www.tikwm.com/', Origin: 'https://www.tikwm.com' },
-    body: new URLSearchParams({ url, hd: '1', full_data: '1' }).toString()
-  });
-  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 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 || 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 };
-}
-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) { return normalizeTikwm(await tikwmApi(url), url, id); }
-
-export async function tiktokDl(url, options = {}) {
-  if (!isTikTokUrl(url)) throw new UnsupportedError('Invalid TikTok URL.');
-  let resolved = url;
-  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}`;
-  try {
-    const response = await fetchWithRetry(pageUrl, { headers: { 'User-Agent': UA, Accept: 'text/html' } });
-    const html = await response.text();
-    const json = extractJson(html, '__UNIVERSAL_DATA_FOR_REHYDRATION__');
-    const video = getPath(json, '__DEFAULT_SCOPE__.webapp.video-detail.videoData.itemInfo.itemStruct.video');
-    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 }]);
-    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 {
-    try { return normalizeYtDlp(await ytDlpInfoUrl(url, options), url, id); }
-    catch { return tiktokFallback(url, id); }
-  }
-}
-
-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, 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') {
-      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') {
-    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 || 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`, output = `${base}.mp3`;
-  await mkdir(dir, { recursive: true });
-  try {
-    await writeFile(input, video);
-    await execFileAsync('ffmpeg', ['-y', '-i', input, '-vn', '-c:a', 'libmp3lame', '-q:a', '2', output], { maxBuffer: 32 * 1024 * 1024 });
-    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)]); }
-}
-
-export async function tiktokSave(url, dest = './tt.mp4', quality = 'best', options = {}) {
-  const result = await tiktokDl(url, options);
-  if (result.fallbackMethod === 'yt-dlp') {
-    const output = await ytDlpDownloadUrl(url, 'mp4', options);
-    await writeFile(dest, output.buffer);
-    return dest;
-  }
-  if (result.fallback) {
-    const output = await tiktokDownload(url, dest.toLowerCase().endsWith('.mp3') ? 'mp3' : 'mp4', options);
-    await writeFile(dest, output.buffer);
-    return dest;
-  }
-  try { return await saveResult(result, dest, quality, { Referer: 'https://www.tiktok.com/' }); }
-  catch {
-    const output = await tiktokDownload(url, dest.toLowerCase().endsWith('.mp3') ? 'mp3' : 'mp4', options);
-    await writeFile(dest, output.buffer);
-    return dest;
-  }
+import{execFile}from'child_process'
+import{promisify}from'util'
+import{mkdir,readFile,unlink,writeFile}from'fs/promises'
+import{join}from'path'
+const execFileAsync=promisify(execFile)
+const API='https://www.tikwm.com/api/'
+const UA='Mozilla/5.0 (Linux; Android 15) AppleWebKit/537.36 Chrome/131 Mobile Safari/537.36'
+const run=async args=>{
+ try{
+  const{stdout,stderr}=await execFileAsync('ffmpeg',args,{maxBuffer:32*1024*1024})
+  return{stdout:String(stdout||''),stderr:String(stderr||'')}
+ }catch(e){
+  throw new Error(String(e?.stderr||e?.stdout||e?.message||'FFmpeg falló').trim())
+ }
+}
+const isUrl=x=>{
+ try{
+  const u=new URL(String(x||'').trim()),h=u.hostname.toLowerCase().replace(/^www\./,'')
+  return(u.protocol==='http:'||u.protocol==='https:')&&(h==='tiktok.com'||h.endsWith('.tiktok.com'))
+ }catch{return false}
+}
+const api=async url=>{
+ const r=await fetch(API,{method:'POST',headers:{'Content-Type':'application/x-www-form-urlencoded','User-Agent':UA,Referer:'https://www.tikwm.com/'},body:new URLSearchParams({url,hd:'1'})})
+ if(!r.ok)throw new Error(`TikWM respondió ${r.status}.`)
+ const x=await r.json()
+ if(x?.code!==0||!x?.data)throw new Error(x?.msg||'TikWM no pudo procesar el enlace.')
+ return x.data
+}
+const get=async url=>{
+ const r=await fetch(url,{headers:{'User-Agent':UA,Referer:'https://www.tikwm.com/'}})
+ if(!r.ok)throw new Error(`No se pudo descargar el archivo (${r.status}).`)
+ const b=Buffer.from(await r.arrayBuffer())
+ if(b.length<=4096)throw new Error('El archivo descargado está vacío.')
+ return b
+}
+export async function info(url){
+ if(!isUrl(url))throw new Error('Enlace de TikTok inválido.')
+ const x=await api(url)
+ return{id:x.id||null,url:x.share_url||url,title:x.title||'Sin título',author:x.author?.unique_id||x.author?.nickname||'',nickname:x.author?.nickname||'',views:Number(x.play_count)||null,likes:Number(x.digg_count)||null,comments:Number(x.comment_count)||null,shares:Number(x.share_count)||null,duration:Number(x.duration)||null,thumbnail:x.origin_cover||x.cover||null,video:x.hdplay||x.play||null,music:x.music||null}
+}
+export async function download(url,format){
+ if(!isUrl(url))throw new Error('Enlace de TikTok inválido.')
+ format=String(format||'').toLowerCase().trim()
+ if(!['mp3','mp4'].includes(format))throw new Error('Formato inválido.')
+ const x=await api(url)
+ if(format==='mp3'&&x.music){const buffer=await get(x.music);return{buffer,mimetype:'audio/mpeg',extension:'mp3'}}
+ if(!x.play&&!x.hdplay)throw new Error('TikWM no proporcionó el vídeo.')
+ const buffer=await get(x.hdplay||x.play)
+ if(format==='mp4')return{buffer,mimetype:'video/mp4',extension:'mp4'}
+ const dir=join(process.cwd(),'cache','temp');await mkdir(dir,{recursive:true})
+ const base=`tt-${Date.now()}-${Math.random().toString(36).slice(2,8)}`;const input=join(dir,`${base}.mp4`);const output=join(dir,`${base}.mp3`)
+ try{await writeFile(input,buffer);await run(['-y','-i',input,'-vn','-c:a','libmp3lame','-q:a','2',output]);const audio=await readFile(output);if(audio.length<=4096)throw new Error('No se pudo generar el audio.');return{buffer:audio,mimetype:'audio/mpeg',extension:'mp3'}}finally{await unlink(input).catch(()=>{});await unlink(output).catch(()=>{})}
+}
+export {isUrl}
+export const isTiktokUrl = isUrl
+export const tiktokDl = info
+export const tiktokSave = async (url, dest='./tt.mp4') => {
+  const { buffer } = await download(url, 'mp4')
+  const { writeFile } = await import('fs/promises')
+  await writeFile(dest, buffer)
+  return dest
 }

package/src/platforms/tiktok.js #403 errors

@@ -0,0 +1,163 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { mkdir, readFile, unlink, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { fetchWithRetry } from '../utils/fetcher.js';
+import { resolveShortUrl } from '../utils/resolver.js';
+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 { 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';
+export const TIKWM_API = 'https://www.tikwm.com/api/';
+const clean = value => value && unescapeJson(value);
+
+export function isTikTokUrl(value) {
+  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 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', 'User-Agent': UA, Accept: '*/*', Referer: 'https://www.tikwm.com/', Origin: 'https://www.tikwm.com' },
+    body: new URLSearchParams({ url, hd: '1', full_data: '1' }).toString()
+  });
+  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 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 || 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 };
+}
+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) { return normalizeTikwm(await tikwmApi(url), url, id); }
+
+export async function tiktokDl(url, options = {}) {
+  if (!isTikTokUrl(url)) throw new UnsupportedError('Invalid TikTok URL.');
+  let resolved = url;
+  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}`;
+  try {
+    const response = await fetchWithRetry(pageUrl, { headers: { 'User-Agent': UA, Accept: 'text/html' } });
+    const html = await response.text();
+    const json = extractJson(html, '__UNIVERSAL_DATA_FOR_REHYDRATION__');
+    const video = getPath(json, '__DEFAULT_SCOPE__.webapp.video-detail.videoData.itemInfo.itemStruct.video');
+    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 }]);
+    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 {
+    try { return normalizeYtDlp(await ytDlpInfoUrl(url, options), url, id); }
+    catch { return tiktokFallback(url, id); }
+  }
+}
+
+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, 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') {
+      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') {
+    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 || 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`, output = `${base}.mp3`;
+  await mkdir(dir, { recursive: true });
+  try {
+    await writeFile(input, video);
+    await execFileAsync('ffmpeg', ['-y', '-i', input, '-vn', '-c:a', 'libmp3lame', '-q:a', '2', output], { maxBuffer: 32 * 1024 * 1024 });
+    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)]); }
+}
+
+export async function tiktokSave(url, dest = './tt.mp4', quality = 'best', options = {}) {
+  const result = await tiktokDl(url, options);
+  if (result.fallbackMethod === 'yt-dlp') {
+    const output = await ytDlpDownloadUrl(url, 'mp4', options);
+    await writeFile(dest, output.buffer);
+    return dest;
+  }
+  if (result.fallback) {
+    const output = await tiktokDownload(url, dest.toLowerCase().endsWith('.mp3') ? 'mp3' : 'mp4', options);
+    await writeFile(dest, output.buffer);
+    return dest;
+  }
+  try { return await saveResult(result, dest, quality, { Referer: 'https://www.tiktok.com/' }); }
+  catch {
+    const output = await tiktokDownload(url, dest.toLowerCase().endsWith('.mp3') ? 'mp3' : 'mp4', options);
+    await writeFile(dest, output.buffer);
+    return dest;
+  }
+}