streamify-audio 2.2.14 → 2.3.1

package/index.d.ts

@@ -203,6 +203,15 @@ declare module 'streamify-audio' {
             enabled?: boolean;
             maxTracks?: number;
         };
+        stream?: {
+            dataTimeout?: number;
+            pipeDataTimeout?: number;
+            liveDataTimeout?: number;
+            extractTimeout?: number;
+            urlCacheTTL?: number;
+            bufferSize?: string;
+            maxRetries?: number;
+        };
     }
 
     export interface ManagerStats {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "streamify-audio",
-  "version": "2.2.14",
+  "version": "2.3.1",
   "description": "Dual-mode audio library: HTTP streaming proxy + Discord player (Lavalink alternative). Supports YouTube, Spotify, SoundCloud with audio filters.",
   "main": "index.js",
   "types": "index.d.ts",

package/src/config.js

@@ -38,6 +38,19 @@ const defaults = {
         searchTTL: 300,
         infoTTL: 3600,
         redis: null
+    },
+    stream: {
+        dataTimeout: 8000,
+        pipeDataTimeout: 20000,
+        liveDataTimeout: 15000,
+        extractTimeout: 30000,
+        urlCacheTTL: 1800,
+        bufferSize: '1M',
+        maxRetries: 2
+    },
+    sponsorblock: {
+        enabled: false,
+        categories: ['sponsor', 'selfpromo']
     }
 };
 
@@ -107,6 +120,16 @@ function load(options = {}) {
             ...defaults.cache,
             ...fileConfig.cache,
             ...options.cache
+        },
+        stream: {
+            ...defaults.stream,
+            ...fileConfig.stream,
+            ...options.stream
+        },
+        sponsorblock: {
+            ...defaults.sponsorblock,
+            ...fileConfig.sponsorblock,
+            ...options.sponsorblock
         }
     };
 

package/src/discord/Manager.js

@@ -403,7 +403,7 @@ class Manager extends EventEmitter {
     }
 
     async _resolveSpotifyToYouTube(track) {
-        const videoId = await spotify.resolveToYouTube(track.id, this.config);
+        const videoId = await spotify.resolveToYouTube(track.id, this.config, track);
         return videoId;
     }
 

package/src/discord/Player.js

@@ -317,22 +317,23 @@ class Player extends EventEmitter {
         this.emit('trackStart', track);
 
         let newStream = null;
+        let resource = null;
+
         try {
             const filtersWithVolume = { ...this._filters, volume: this._volume };
 
-            if (startPosition === 0 && this._prefetchedTrack?.id === track.id && this._prefetchedStream) {
-                log.debug('PLAYER', `Using prefetched stream for ${track.id}`);
+            if (startPosition === 0 && this._prefetchedTrack?.id === track.id && this._prefetchedStream?.resource) {
+                log.info('PLAYER', `Using prefetched stream for ${track.id}`);
                 newStream = this._prefetchedStream;
+                resource = newStream.resource;
                 this._prefetchedStream = null;
                 this._prefetchedTrack = null;
             } else {
-                // If not using prefetch, we don't clear it yet in case we need to fallback
+                this._clearPrefetch();
                 newStream = createStream(track, filtersWithVolume, this.config);
+                resource = await newStream.start(startPosition);
             }
 
-            const resource = await newStream.create(startPosition);
-
-            // SEAMLESS SWAP: Only destroy old stream AFTER the new one is ready
             const oldStream = this.stream;
             this.stream = newStream;
             this.audioPlayer.play(resource);
@@ -362,7 +363,7 @@ class Player extends EventEmitter {
 
             log.error('PLAYER', `Failed to play track: ${error.message}`);
             this.emit('trackError', track, error);
-            
+
             const next = this.queue.shift();
             if (next) {
                 setImmediate(() => this._playTrack(next));
@@ -384,19 +385,35 @@ class Player extends EventEmitter {
         if (this._prefetching || this.queue.tracks.length === 0) return;
 
         const nextTrack = this.queue.tracks[0];
-        if (!nextTrack || nextTrack._directUrl) return; // Already prefetched or resolved
+        if (!nextTrack) return;
+
+        if (this._prefetchedTrack?.id === nextTrack.id && this._prefetchedStream) return;
 
+        this._clearPrefetch();
         this._prefetching = true;
-        log.debug('PLAYER', `Prefetching metadata: ${nextTrack.title}`);
+        log.debug('PLAYER', `Prefetching stream: ${nextTrack.title}`);
 
         try {
-            // Only resolve the metadata and stream URL
-            const result = await this.manager.getInfo(nextTrack.id, nextTrack.source);
-            if (result) {
-                // Merge prefetch data into the existing queue object
-                Object.assign(nextTrack, result);
-                log.debug('PLAYER', `Prefetch ready (Metadata only): ${nextTrack.id}`);
+            const filtersWithVolume = { ...this._filters, volume: this._volume };
+            const stream = createStream(nextTrack, filtersWithVolume, this.config);
+
+            await stream.prepare();
+
+            if (this._destroyed || this.queue.tracks[0]?.id !== nextTrack.id) {
+                stream.destroy();
+                return;
+            }
+
+            await stream.start(0);
+
+            if (this._destroyed || this.queue.tracks[0]?.id !== nextTrack.id) {
+                stream.destroy();
+                return;
             }
+
+            this._prefetchedStream = stream;
+            this._prefetchedTrack = nextTrack;
+            log.info('PLAYER', `Prefetch ready: ${nextTrack.title} (${stream.metrics.total}ms)`);
         } catch (error) {
             log.debug('PLAYER', `Prefetch failed: ${error.message}`);
         } finally {
@@ -651,6 +668,7 @@ class Player extends EventEmitter {
     }
 
     async setVolume(volume) {
+        this._clearPrefetch();
         const oldVolume = this._volume;
         this._volume = Math.max(0, Math.min(200, volume));
         log.info('PLAYER', `Volume adjusted: ${oldVolume}% -> ${this._volume}%`);
@@ -689,6 +707,7 @@ class Player extends EventEmitter {
     }
 
     async setFilter(name, value) {
+        this._clearPrefetch();
         this._filters[name] = value;
 
         if (this._playing && this.queue.current) {
@@ -787,6 +806,7 @@ class Player extends EventEmitter {
             }
         }
 
+        this._clearPrefetch();
         log.info('PLAYER', `Active effects: ${this._effectPresets.map(p => p.name).join(' + ') || 'NONE'}`);
 
         if (this._playing && this.queue.current) {

package/src/discord/Stream.js

@@ -11,6 +11,50 @@ try {
 
 const { createAudioResource, StreamType } = voiceModule || {};
 
+class StreamURLCache {
+    constructor(defaultTTL = 1800000) {
+        this._cache = new Map();
+        this._defaultTTL = defaultTTL;
+        this._cleanupInterval = setInterval(() => this._cleanup(), 300000);
+        if (this._cleanupInterval.unref) this._cleanupInterval.unref();
+    }
+
+    get(key) {
+        const entry = this._cache.get(key);
+        if (!entry) return null;
+        if (Date.now() > entry.expiry) {
+            this._cache.delete(key);
+            return null;
+        }
+        return { url: entry.url, headers: entry.headers };
+    }
+
+    set(key, url, headers = null, ttl = this._defaultTTL) {
+        this._cache.set(key, {
+            url,
+            headers,
+            expiry: Date.now() + ttl
+        });
+    }
+
+    invalidate(key) {
+        this._cache.delete(key);
+    }
+
+    get size() {
+        return this._cache.size;
+    }
+
+    _cleanup() {
+        const now = Date.now();
+        for (const [key, entry] of this._cache) {
+            if (now > entry.expiry) this._cache.delete(key);
+        }
+    }
+}
+
+const urlCache = new StreamURLCache();
+
 class StreamController {
     constructor(track, filters, config) {
         this.track = track;
@@ -23,54 +67,120 @@ class StreamController {
         this.startTime = null;
         this.ytdlpError = '';
         this.ffmpegError = '';
-        
-        // Timing metrics
+
+        this._videoId = null;
+        this._directStreamUrl = null;
+        this._directStreamHeaders = null;
+        this._useDirectUrl = false;
+        this._prepared = false;
+        this._ffmpegSpawnTime = null;
+
         this.metrics = {
             metadata: 0,
+            urlExtract: 0,
             spawn: 0,
             firstByte: 0,
             total: 0
         };
     }
 
-    async create(seekPosition = 0) {
-        if (this.destroyed) {
-            throw new Error('Stream already destroyed');
-        }
-
-        if (this.resource) {
-            return this.resource;
-        }
+    async prepare() {
+        if (this.destroyed) throw new Error('Stream already destroyed');
 
         this.startTime = Date.now();
-        const startTimestamp = this.startTime;
         const source = this.track.source || 'youtube';
-
         let videoId = this.track._resolvedId || this.track.id;
 
-        // Skip metadata resolution if we already have it
         if (source === 'spotify' && !this.track._resolvedId) {
             log.info('STREAM', `Resolving Spotify track to YouTube: ${this.track.title}`);
             try {
                 const spotify = require('../providers/spotify');
-                videoId = await spotify.resolveToYouTube(this.track.id, this.config);
+                videoId = await spotify.resolveToYouTube(this.track.id, this.config, this.track);
                 this.track._resolvedId = videoId;
-                this.metrics.metadata = Date.now() - startTimestamp;
+                this.metrics.metadata = Date.now() - this.startTime;
             } catch (error) {
-                log.error('STREAM', `Spotify resolution failed: ${error.message}`);
                 throw new Error(`Failed to resolve Spotify track: ${error.message}`);
             }
         } else {
-            this.metrics.metadata = 0; // Already resolved
+            this.metrics.metadata = 0;
         }
 
         if (!videoId || videoId === 'undefined') {
-            throw new Error(`Invalid track ID: ${videoId} (source: ${source}, title: ${this.track.title})`);
+            throw new Error(`Invalid track ID: ${videoId} (source: ${source})`);
+        }
+
+        this._videoId = videoId;
+        const isYouTube = source === 'youtube' || source === 'spotify';
+        const isLive = this.track.isLive === true || this.track.duration === 0;
+        const isLocal = source === 'local';
+
+        if (isLocal || isLive || !isYouTube) {
+            this._useDirectUrl = false;
+            this._prepared = true;
+            return;
         }
 
-        log.info('STREAM', `Creating stream for ${videoId} (${source})`);
-        
-        // Log Filter Chain Trace (No data impact)
+        const cacheKey = `${videoId}:${this.config.ytdlp.format}`;
+        const cached = urlCache.get(cacheKey);
+
+        if (cached) {
+            log.info('STREAM', `URL cache hit for ${videoId}`);
+            this._directStreamUrl = cached.url;
+            this._directStreamHeaders = cached.headers;
+            this._useDirectUrl = true;
+            this._prepared = true;
+            return;
+        }
+
+        const extractStart = Date.now();
+        const maxRetries = this.config.stream?.maxRetries || 2;
+
+        for (let attempt = 1; attempt <= maxRetries; attempt++) {
+            try {
+                const extractedUrl = await this._extractUrl(videoId, this.config, isYouTube);
+                this.metrics.urlExtract = Date.now() - extractStart;
+
+                const ttl = (this.config.stream?.urlCacheTTL || 1800) * 1000;
+                urlCache.set(cacheKey, extractedUrl, this.track._headers, ttl);
+
+                this._directStreamUrl = extractedUrl;
+                this._directStreamHeaders = this.track._headers;
+                this._useDirectUrl = true;
+                this._prepared = true;
+
+                log.info('STREAM', `URL extracted for ${videoId} (${this.metrics.urlExtract}ms, attempt ${attempt})`);
+                return;
+            } catch (error) {
+                log.warn('STREAM', `URL extraction attempt ${attempt}/${maxRetries} failed: ${error.message}`);
+                if (attempt === maxRetries) {
+                    log.warn('STREAM', `All extraction attempts failed for ${videoId}, falling back to pipe mode`);
+                    this._useDirectUrl = false;
+                    this._prepared = true;
+                    return;
+                }
+            }
+        }
+    }
+
+    async start(seekPosition = 0) {
+        if (this.destroyed) throw new Error('Stream already destroyed');
+        if (this.resource) return this.resource;
+
+        if (!this._prepared) {
+            await this.prepare();
+        }
+
+        if (!this.startTime) this.startTime = Date.now();
+        const startTimestamp = this.startTime;
+
+        const videoId = this._videoId || this.track._resolvedId || this.track.id;
+        const source = this.track.source || 'youtube';
+        const isLive = this.track.isLive === true || this.track.duration === 0;
+        const isLocal = source === 'local';
+        const isYouTube = source === 'youtube' || source === 'spotify';
+
+        log.info('STREAM', `Creating stream for ${videoId} (${source}, mode: ${this._useDirectUrl ? 'direct' : isLocal ? 'local' : 'pipe'})`);
+
         const filterNames = Object.keys(this.filters).filter(k => k !== 'start' && k !== '_trigger' && k !== 'volume');
         if (filterNames.length > 0) {
             const chain = filterNames.map(name => {
@@ -78,30 +188,14 @@ class StreamController {
                 let displayVal = typeof val === 'object' ? JSON.stringify(val) : val;
                 if (displayVal === true || displayVal === 'true') displayVal = 'ON';
                 return `[${name.toUpperCase()} (${displayVal})]`;
-            }).join(' ➔ ');
+            }).join(' > ');
             log.info('STREAM', `Filter Chain: ${chain}`);
         }
 
-        const isYouTube = source === 'youtube' || source === 'spotify';
-        const isLive = this.track.isLive === true || this.track.duration === 0;
-        const isLocal = source === 'local';
-
-        let ytdlp;
-        let ffmpegIn;
-
         const env = { ...process.env, PATH: '/usr/local/bin:/root/.deno/bin:' + process.env.PATH };
-        const spawnStart = Date.now();
+        const bufferSize = this.config.stream?.bufferSize || '1M';
 
-        if (isLocal) {
-            // Skip yt-dlp for local files
-            ffmpegIn = 'pipe:0'; // We'll just pass the file path to ffmpeg -i
-            this.metrics.spawn = Date.now() - spawnStart;
-        } else if (this.track._directUrl && !isLive && seekPosition === 0) {
-            // OPTIMIZATION: Bypass yt-dlp if we already have a direct stream URL
-            ffmpegIn = this.track._directUrl;
-            log.info('STREAM', `Bypassing yt-dlp, using direct URL for ${videoId}`);
-            this.metrics.spawn = 0;
-        } else {
+        if (!this._useDirectUrl && !isLocal) {
             let url;
             if (source === 'soundcloud') {
                 url = this.track.uri || `https://api.soundcloud.com/tracks/${videoId}/stream`;
@@ -111,13 +205,7 @@ class StreamController {
                 url = `https://www.youtube.com/watch?v=${videoId}`;
             }
 
-            let formatString;
-            if (isLive) {
-                formatString = 'bestaudio*/best';
-            } else {
-                formatString = this.config.ytdlp.format;
-            }
-
+            const formatString = isLive ? 'bestaudio*/best' : this.config.ytdlp.format;
             const ytdlpArgs = [
                 '-f', formatString,
                 '--no-playlist',
@@ -125,7 +213,7 @@ class StreamController {
                 '--no-warnings',
                 '--no-cache-dir',
                 '--no-mtime',
-                '--buffer-size', '256K',
+                '--buffer-size', bufferSize,
                 '--quiet',
                 '--retries', '3',
                 '--fragment-retries', '3',
@@ -150,19 +238,17 @@ class StreamController {
                 ytdlpArgs.unshift('--cookies', this.config.cookiesPath);
             }
 
-            if (this.config.sponsorblock?.enabled !== false && isYouTube) {
+            if (this.config.sponsorblock?.enabled === true && isYouTube) {
                 const categories = this.config.sponsorblock?.categories || ['sponsor', 'selfpromo'];
                 ytdlpArgs.push('--sponsorblock-remove', categories.join(','));
             }
 
             this.ytdlp = spawn(this.config.ytdlpPath, ytdlpArgs, { env });
-            ffmpegIn = 'pipe:0';
         }
 
         const ffmpegFilters = { ...this.filters };
         const ffmpegArgs = buildFfmpegArgs(ffmpegFilters, this.config);
-        
-        // Input injection - only override if NOT using pipe:0 (buildFfmpegArgs already includes -i pipe:0)
+
         if (isLocal) {
             const filePath = this.track.absolutePath || videoId.replace('file://', '');
             const pipeIndex = ffmpegArgs.indexOf('pipe:0');
@@ -173,23 +259,29 @@ class StreamController {
                     ffmpegArgs.splice(pipeIndex - 1, 0, '-ss', seekSeconds);
                 }
             }
-        } else if (ffmpegIn !== 'pipe:0') {
-            // Direct URL - replace the pipe:0 input with the direct URL
+        } else if (this._useDirectUrl) {
             const pipeIndex = ffmpegArgs.indexOf('pipe:0');
             if (pipeIndex > 0) {
-                ffmpegArgs[pipeIndex] = ffmpegIn;
-                if (this.track._headers) {
-                    const headers = Object.entries(this.track._headers)
+                if (seekPosition > 0) {
+                    const seekSeconds = (seekPosition / 1000).toFixed(3);
+                    ffmpegArgs.splice(pipeIndex - 1, 0, '-ss', seekSeconds);
+                }
+
+                const newPipeIndex = ffmpegArgs.indexOf('pipe:0');
+                ffmpegArgs[newPipeIndex] = this._directStreamUrl;
+
+                if (this._directStreamHeaders) {
+                    const headers = Object.entries(this._directStreamHeaders)
                         .map(([k, v]) => `${k}: ${v}`)
                         .join('\r\n');
-                    ffmpegArgs.splice(pipeIndex - 1, 0, '-headers', headers);
+                    ffmpegArgs.splice(newPipeIndex - 1, 0, '-headers', headers);
                 }
             }
         }
-        // else: pipe:0 - buildFfmpegArgs already has -i pipe:0, nothing to change
 
+        this._ffmpegSpawnTime = Date.now();
         this.ffmpeg = spawn(this.config.ffmpegPath, ffmpegArgs, { env });
-        this.metrics.spawn = Date.now() - spawnStart;
+        this.metrics.spawn = Date.now() - this._ffmpegSpawnTime;
 
         if (this.ytdlp) {
             this.ffmpeg.stdin.on('error', (err) => {
@@ -212,8 +304,6 @@ class StreamController {
                 this.ytdlpError += msg;
                 if (msg.includes('ERROR:') && !msg.includes('Retrying') && !msg.includes('Broken pipe')) {
                     log.error('YTDLP', msg.trim());
-                } else if (!msg.includes('[download]') && !msg.includes('ETA') && !msg.includes('[youtube]') && !msg.includes('Retrying fragment') && !msg.includes('Got error')) {
-                    log.debug('YTDLP', msg.trim());
                 }
             });
 
@@ -236,7 +326,17 @@ class StreamController {
             }
         });
 
-        await this._waitForData(isLive);
+        try {
+            await this._waitForData();
+        } catch (error) {
+            if (this._useDirectUrl && (error.message.includes('timed out') || error.message.includes('403'))) {
+                const cacheKey = `${videoId}:${this.config.ytdlp.format}`;
+                urlCache.invalidate(cacheKey);
+                log.warn('STREAM', `Invalidated cached URL for ${videoId} after error`);
+            }
+            this.destroy();
+            throw error;
+        }
 
         if (this.destroyed || !this.ffmpeg) {
             throw new Error('Stream destroyed during initialization');
@@ -250,31 +350,95 @@ class StreamController {
 
         const elapsed = Date.now() - startTimestamp;
         this.metrics.total = elapsed;
-        
-        log.info('STREAM', `Ready ${elapsed}ms | Metrics: [Metadata: ${this.metrics.metadata}ms | Spawn: ${this.metrics.spawn}ms | FirstByte: ${this.metrics.firstByte}ms]`);
+
+        log.info('STREAM', `Ready ${elapsed}ms | Metrics: [Metadata: ${this.metrics.metadata}ms | URLExtract: ${this.metrics.urlExtract}ms | Spawn: ${this.metrics.spawn}ms | FirstByte: ${this.metrics.firstByte}ms]`);
 
         return this.resource;
     }
 
-    _waitForData(isLive = false) {
+    async create(seekPosition = 0) {
+        return this.start(seekPosition);
+    }
+
+    _extractUrl(videoId, config, isYouTube) {
+        return new Promise((resolve, reject) => {
+            const url = `https://www.youtube.com/watch?v=${videoId}`;
+            const args = [
+                '--get-url',
+                '-f', 'bestaudio/best',
+                '--no-playlist',
+                '--no-warnings',
+                url
+            ];
+
+            if (isYouTube) {
+                args.push('--extractor-args', 'youtube:player_client=web_creator');
+            }
+
+            if (config.cookiesPath) {
+                args.unshift('--cookies', config.cookiesPath);
+            }
+
+            const env = { ...process.env, PATH: '/usr/local/bin:/root/.deno/bin:' + process.env.PATH };
+            const proc = spawn(config.ytdlpPath, args, { env });
+
+            let stdout = '';
+            let stderr = '';
+            const extractTimeout = config.stream?.extractTimeout || 30000;
+            const timeout = setTimeout(() => {
+                proc.kill('SIGKILL');
+                reject(new Error('URL extraction timed out'));
+            }, extractTimeout);
+
+            proc.stdout.on('data', (data) => { stdout += data; });
+            proc.stderr.on('data', (data) => { stderr += data; });
+
+            proc.on('close', (code) => {
+                clearTimeout(timeout);
+                if (code !== 0) {
+                    return reject(new Error(`yt-dlp --get-url failed (code ${code}): ${stderr.slice(-200)}`));
+                }
+                const urls = stdout.trim().split('\n').filter(Boolean);
+                if (urls.length === 0) {
+                    return reject(new Error('yt-dlp returned no URLs'));
+                }
+                resolve(urls[0]);
+            });
+
+            proc.on('error', (err) => {
+                clearTimeout(timeout);
+                reject(new Error(`yt-dlp spawn failed: ${err.message}`));
+            });
+        });
+    }
+
+    _waitForData() {
         const ffmpeg = this.ffmpeg;
         const ytdlp = this.ytdlp;
+        const isLive = this.track.isLive === true || this.track.duration === 0;
+        const isPipe = !!this.ytdlp;
+        const timeoutMs = isLive
+            ? (this.config.stream?.liveDataTimeout || 15000)
+            : isPipe
+                ? (this.config.stream?.pipeDataTimeout || 20000)
+                : (this.config.stream?.dataTimeout || 8000);
 
         return new Promise((resolve, reject) => {
             if (!ffmpeg) return resolve();
 
-            const timeoutMs = isLive ? 30000 : 15000;
+            let resolved = false;
+
             const timeout = setTimeout(() => {
-                log.warn('STREAM', `Timeout waiting for data, proceeding anyway`);
-                resolve();
+                if (resolved) return;
+                resolved = true;
+                if (ffmpeg.stdout) ffmpeg.stdout.removeListener('readable', onReadable);
+                reject(new Error(`Stream timed out after ${timeoutMs}ms waiting for audio data`));
             }, timeoutMs);
 
-            let resolved = false;
-
             const onReadable = () => {
                 if (resolved) return;
                 resolved = true;
-                this.metrics.firstByte = Date.now() - (this.startTime + this.metrics.metadata + this.metrics.spawn);
+                this.metrics.firstByte = Date.now() - this._ffmpegSpawnTime;
                 clearTimeout(timeout);
                 if (ffmpeg.stdout) ffmpeg.stdout.removeListener('readable', onReadable);
                 resolve();
@@ -284,19 +448,20 @@ class StreamController {
                 ffmpeg.stdout.on('readable', onReadable);
             }
 
-            ffmpeg.on('close', () => {
-                if (!resolved) {
-                    resolved = true;
-                    clearTimeout(timeout);
-                    if (ffmpeg.stdout) ffmpeg.stdout.removeListener('readable', onReadable);
-
-                    if (this.destroyed) {
-                        return reject(new Error('Stream destroyed during initialization'));
-                    }
+            ffmpeg.on('close', (code) => {
+                if (resolved) return;
+                resolved = true;
+                clearTimeout(timeout);
+                if (ffmpeg.stdout) ffmpeg.stdout.removeListener('readable', onReadable);
 
-                    const sourceErr = ytdlp ? `yt-dlp stderr: ${this.ytdlpError.slice(-200) || 'none'}` : `ffmpeg stderr: ${this.ffmpegError.slice(-200) || 'none'}`;
-                    reject(new Error(`ffmpeg closed before producing data. ${sourceErr}`));
+                if (this.destroyed) {
+                    return reject(new Error('Stream destroyed during initialization'));
                 }
+
+                const sourceErr = ytdlp
+                    ? `yt-dlp stderr: ${this.ytdlpError.slice(-200) || 'none'}`
+                    : `ffmpeg stderr: ${this.ffmpegError.slice(-200) || 'none'}`;
+                reject(new Error(`ffmpeg closed before producing data. ${sourceErr}`));
             });
 
             if (ytdlp) {
@@ -305,12 +470,10 @@ class StreamController {
                         resolved = true;
                         clearTimeout(timeout);
                         if (ffmpeg.stdout) ffmpeg.stdout.removeListener('readable', onReadable);
-
                         if (this.destroyed) {
                             return reject(new Error('Stream destroyed during initialization'));
                         }
-
-                        reject(new Error(`yt-dlp failed with code ${code}`));
+                        reject(new Error(`yt-dlp failed with code ${code}: ${this.ytdlpError.slice(-200)}`));
                     }
                 });
             }
@@ -355,4 +518,4 @@ function createStream(track, filters, config) {
     return new StreamController(track, filters, config);
 }
 
-module.exports = { createStream, StreamController };
+module.exports = { createStream, StreamController, urlCache };