Update server.js

server.js

@@ -161,30 +161,110 @@ app.get('/constituent/health', (req, res) => {
 });
 
 // ═══════════════════════════════════════════════════════════════════════════
-// ADD MOVIE API
-// Called by main server when a user (who owns this constituent) adds a movie.
+// SHOWPLAY API — search by title name (no raw link needed)
+// Called by main server when a user (who owns this constituent) adds a movie or episode.
 // Only the constituent's owner can trigger this.
-// Body: { streamId, movieLink, movieTitle, thumbnail, tmdbInfo? }
+//
+// POST /constituent/add-movie  — body: { streamId, title }
+//   Searches iktracks for the title, picks the first movie result, downloads it.
+//
+// POST /constituent/add-episode  — body: { streamId, title, season, episode }
+//   Searches iktracks for the series, finds the matching S/E, downloads it.
 // ═══════════════════════════════════════════════════════════════════════════
 
-app.post('/constituent/add-movie', requireMainServer, async (req, res) => {
-  const { streamId, movieLink, movieTitle, thumbnail, tmdbInfo } = req.body;
+const IKTRACKS_BASE = 'https://iktracks.vercel.app';
+
+function spSeriesName(title) {
+  return (title || '').replace(/\s*\(?\d{4}\)?\s*$/, '').trim() || title;
+}
 
-  if (!streamId || !movieLink || !movieTitle) {
-    return res.status(400).json({ success: false, error: 'streamId, movieLink, and movieTitle are required' });
+function extractAllEpisodes(details) {
+  const allEps = [];
+  for (const season of (details.seasons || [])) {
+    for (const ep of (season.episodes || [])) {
+      if (ep && ep.downloadLink) {
+        allEps.push({ season: season.season, episode: ep.episode, downloadLink: ep.downloadLink });
+      }
+    }
   }
+  return allEps;
+}
+
+app.post('/constituent/add-movie', requireMainServer, async (req, res) => {
+  // Supports two modes:
+  //   1. { streamId, movieLink, movieTitle, thumbnail?, tmdbInfo? }  — direct link from server.js
+  //   2. { streamId, title }  — search by name (legacy / direct constituent use)
+  const { streamId, movieLink, movieTitle, title: titleOnly, thumbnail, tmdbInfo } = req.body;
 
-  // Only owner's streams are allowed
+  if (!streamId) {
+    return res.status(400).json({ success: false, error: 'streamId is required' });
+  }
   if (streamId !== constituentConfig.ownerId) {
     return res.status(403).json({ success: false, error: 'Only the constituent owner can add movies to this server' });
   }
 
-  res.json({ success: true, message: 'Movie queued for download and encoding', streamId, title: movieTitle });
+  // ── Mode 1: direct link provided ───────────────────────────────────────────
+  if (movieLink && movieTitle) {
+    res.json({ success: true, message: 'Movie queued for download and encoding', streamId, title: movieTitle });
+    setImmediate(async () => {
+      try {
+        const result = await showplayEnqueueLink(streamId, movieLink, movieTitle, thumbnail || DEFAULT_ARTWORK, tmdbInfo || null);
+        console.log(`✅ Movie added to stream ${streamId}: ${result.title}`);
+      } catch (err) {
+        console.error(`❌ Failed to add movie to stream ${streamId}:`, err.message);
+      }
+    });
+    return;
+  }
+
+  // ── Mode 2: search by title ────────────────────────────────────────────────
+  const title = titleOnly || movieTitle;
+  if (!title) {
+    return res.status(400).json({ success: false, error: 'Either (movieLink + movieTitle) or title is required' });
+  }
+
+  // Search for the title
+  let searchResults;
+  try {
+    const r = await axios.get(`${IKTRACKS_BASE}/search?query=${encodeURIComponent(title)}`, { timeout: 15000 });
+    searchResults = (r.data?.results || []).filter(r => r && r.link);
+  } catch (err) {
+    return res.status(500).json({ success: false, error: `Search failed: ${err.message}` });
+  }
+  if (!searchResults.length) {
+    return res.status(404).json({ success: false, error: `No results found for "${title}"` });
+  }
+
+  // Pick the first movie result (prefer type==='movie', fall back to first result)
+  const movieResult = searchResults.find(r => r.type === 'movie') || searchResults[0];
+
+  // Fetch details to get the download link
+  let details;
+  try {
+    const r = await axios.get(`${IKTRACKS_BASE}/details?url=${encodeURIComponent(movieResult.link)}`, { timeout: 15000 });
+    details = r.data;
+    if (!details) throw new Error('Empty details response');
+  } catch (err) {
+    return res.status(500).json({ success: false, error: `Details fetch failed: ${err.message}` });
+  }
+
+  if (details.type === 'series') {
+    return res.status(400).json({ success: false, error: 'This title is a series. Use /constituent/add-episode instead.' });
+  }
+
+  const link = details.downloadLinks?.[0]?.downloadLink;
+  if (!link) {
+    return res.status(404).json({ success: false, error: 'No download link found for this title' });
+  }
+
+  const pendingTitle = details.title || movieResult.title || title;
+  const pendingThumb = details.thumbnail || movieResult.thumbnail || DEFAULT_ARTWORK;
+
+  res.json({ success: true, message: 'Movie queued for download and encoding', streamId, title: pendingTitle });
 
-  // Process asynchronously so we don't block the response
   setImmediate(async () => {
     try {
-      const result = await showplayEnqueueLink(streamId, movieLink, movieTitle, thumbnail || DEFAULT_ARTWORK, tmdbInfo || null);
+      const result = await showplayEnqueueLink(streamId, link, pendingTitle, pendingThumb, tmdbInfo || null);
       console.log(`✅ Movie added to stream ${streamId}: ${result.title}`);
     } catch (err) {
       console.error(`❌ Failed to add movie to stream ${streamId}:`, err.message);
@@ -192,6 +272,125 @@ app.post('/constituent/add-movie', requireMainServer, async (req, res) => {
   });
 });
 
+// POST /constituent/add-episode  — body: { streamId, title, season, episode }
+app.post('/constituent/add-episode', requireMainServer, async (req, res) => {
+  const { streamId, title, season, episode } = req.body;
+
+  if (!streamId || !title) {
+    return res.status(400).json({ success: false, error: 'streamId and title are required' });
+  }
+  if (season == null || episode == null) {
+    return res.status(400).json({ success: false, error: 'season and episode are required' });
+  }
+  if (streamId !== constituentConfig.ownerId) {
+    return res.status(403).json({ success: false, error: 'Only the constituent owner can add episodes to this server' });
+  }
+
+  // Search for the series
+  let searchResults;
+  try {
+    const r = await axios.get(`${IKTRACKS_BASE}/search?query=${encodeURIComponent(title)}`, { timeout: 15000 });
+    searchResults = (r.data?.results || []).filter(r => r && r.link);
+  } catch (err) {
+    return res.status(500).json({ success: false, error: `Search failed: ${err.message}` });
+  }
+  if (!searchResults.length) {
+    return res.status(404).json({ success: false, error: `No results found for "${title}"` });
+  }
+
+  // Pick best series result
+  const seriesResult = searchResults.find(r => r.type === 'series') || searchResults[0];
+
+  // Fetch details
+  let details;
+  try {
+    const r = await axios.get(`${IKTRACKS_BASE}/details?url=${encodeURIComponent(seriesResult.link)}`, { timeout: 15000 });
+    details = r.data;
+    if (!details) throw new Error('Empty details response');
+  } catch (err) {
+    return res.status(500).json({ success: false, error: `Details fetch failed: ${err.message}` });
+  }
+
+  const allEps = extractAllEpisodes(details);
+  if (!allEps.length) {
+    return res.status(404).json({ success: false, error: 'No downloadable episodes found for this title' });
+  }
+
+  const ep = allEps.find(e => String(e.season) === String(season) && String(e.episode) === String(episode));
+  if (!ep) {
+    return res.status(404).json({ success: false, error: `Episode S${season}E${episode} not found` });
+  }
+
+  const seriesName   = spSeriesName(details.title || seriesResult.title || title);
+  const epLabel      = `S${String(ep.season).padStart(2,'0')} E${String(ep.episode).padStart(2,'0')}`;
+  const pendingTitle = `${seriesName} • ${epLabel}`;
+  const thumbnail    = details.thumbnail || seriesResult.thumbnail || DEFAULT_ARTWORK;
+
+  res.json({ success: true, message: 'Episode queued for download and encoding', streamId, title: pendingTitle });
+
+  setImmediate(async () => {
+    try {
+      const result = await showplayEnqueueLink(streamId, ep.downloadLink, pendingTitle, thumbnail, null);
+      console.log(`✅ Episode added to stream ${streamId}: ${result.title}`);
+    } catch (err) {
+      console.error(`❌ Failed to add episode to stream ${streamId}:`, err.message);
+    }
+  });
+});
+
+// POST /constituent/add-song  — body: { streamId, songUrl, title, thumbnail? }
+// Accepts a direct audio URL + title, downloads and enqueues without searching.
+app.post('/constituent/add-song', requireMainServer, async (req, res) => {
+  const { streamId, songUrl, title, thumbnail } = req.body;
+
+  if (!streamId || !songUrl || !title) {
+    return res.status(400).json({ success: false, error: 'streamId, songUrl, and title are required' });
+  }
+  if (streamId !== constituentConfig.ownerId) {
+    return res.status(403).json({ success: false, error: 'Only the constituent owner can add songs to this server' });
+  }
+
+  res.json({ success: true, message: 'Song queued for download and encoding', streamId, title });
+
+  setImmediate(async () => {
+    try {
+      if (!streams[streamId]) {
+        streams[streamId] = { queue: [], songStartTime: null, streamTimeOffset: 0, users: new Map(), ownerId: streamId, lastActivity: Date.now(), isActive: false };
+      }
+
+      // Download the audio
+      const fileName = crypto.randomUUID() + '.mp3';
+      const filePath = require('path').join(SONGS_DIR, fileName);
+      const writer   = require('fs').createWriteStream(filePath);
+      const response = await axios({ url: songUrl, method: 'GET', responseType: 'stream', httpsAgent: httpsAgentNoVerify });
+      response.data.pipe(writer);
+      await new Promise((resolve, reject) => {
+        writer.on('finish', resolve);
+        writer.on('error', (e) => { writer.destroy(); reject(e); });
+        response.data.on('error', reject);
+      });
+
+      const mediaMeta = await getAudioMeta(filePath);
+      const songInfo = {
+        fileName,
+        meta: {
+          title,
+          thumbnail: thumbnail || DEFAULT_ARTWORK,
+          duration:  mediaMeta.duration || 0,
+          views:     'N/A',
+          published: 'N/A',
+          source:    songUrl,
+          videoUrl:  null,
+        },
+      };
+      enqueueToStream(streamId, songInfo);
+      console.log(`✅ Song added to stream ${streamId}: ${title}`);
+    } catch (err) {
+      console.error(`❌ Failed to add song to stream ${streamId}:`, err.message);
+    }
+  });
+});
+
 // ─── Queue status for a stream ────────────────────────────────────────────────
 app.get('/constituent/queue/:streamId', requireMainServer, (req, res) => {
   const { streamId } = req.params;
@@ -367,19 +566,20 @@ function buildLivePlaylistAt(streamId, elapsed) {
   const state = hlsState[streamId];
   if (!state || !state.segments.length) return null;
   const segs = state.segments;
-  let startIdx = Math.max(0, segs.length - HLS_PLAYLIST_WINDOW);
+  let startIdx = -1;
   for (let i = 0; i < segs.length; i++) {
     if (segs[i].streamEnd > elapsed) { startIdx = i; break; }
   }
-  const window = segs.slice(startIdx, startIdx + HLS_PLAYLIST_WINDOW);
-  const lines  = [
-    '#EXTM3U',
-    '#EXT-X-VERSION:3',
-    `#EXT-X-TARGETDURATION:10`,
-    `#EXT-X-MEDIA-SEQUENCE:${state.mediaSeq + startIdx}`,
-    '#EXT-X-DISCONTINUITY-SEQUENCE:0',
-  ];
+  if (startIdx === -1) return null;
+  const window   = segs.slice(startIdx, startIdx + HLS_PLAYLIST_WINDOW);
+  const mediaSeq = state.mediaSeq + startIdx;
+  const lines = ['#EXTM3U','#EXT-X-VERSION:3','#EXT-X-TARGETDURATION:10',`#EXT-X-MEDIA-SEQUENCE:${mediaSeq}`];
+  let prevSid = null;
   for (const seg of window) {
+    if (prevSid !== null && seg.ownerSid && seg.ownerSid !== prevSid) {
+      lines.push('#EXT-X-DISCONTINUITY');
+    }
+    prevSid = seg.ownerSid || prevSid;
     lines.push(`#EXTINF:${seg.duration.toFixed(6)},`);
     lines.push(seg.uri);
   }
@@ -416,141 +616,237 @@ function parseM3u8Durations(playlistPath) {
 }
 
 function watchForSegments(streamId, dir, segPrefix, songHlsStart, onFirstSeg, ownerSid, state) {
-  let cursor = songHlsStart, firstFlushed = false;
-  let lastEntryCount = 0;
+  let cursor         = songHlsStart, firstFlushed = false;
+  const stitched     = new Set();
   const playlistPath = path.join(dir, segPrefix + '.m3u8');
-  const STABLE_NEEDED = 3;
-  let   stableCount  = 0;
+  let pollCount      = 0;
+  console.log(`👁  watchForSegments created: ownerSid=${ownerSid?.slice(0,8)} songHlsStart=${songHlsStart} playlistPath=${playlistPath}`);
 
-  const iv = setInterval(() => {
+  const flush = () => {
+    pollCount++;
     const entries = parseM3u8Durations(playlistPath);
-    if (!entries.length) return;
-
+    if (pollCount <= 3 || entries.length > 0) {
+      console.log(`👁  watch poll #${pollCount} [${ownerSid?.slice(0,8)}]: playlist=${fs.existsSync(playlistPath)} entries=${entries.length} stitched=${stitched.size} firstFlushed=${firstFlushed}`);
+    }
     for (const { file, dur } of entries) {
+      if (stitched.has(file)) continue;
       const segPath = path.join(dir, file);
-      if (!fs.existsSync(segPath)) continue;
+      try { if (fs.statSync(segPath).size < 188) continue; } catch { continue; }
+      stitched.add(file);
       const seg = { uri: `/hls/${streamId}/${file}`, _path: segPath, streamStart: cursor, streamEnd: cursor + dur, duration: dur, ownerSid };
-      state.segments.push(seg);
-      state.totalDuration = cursor + dur;
       cursor += dur;
-
+      state.segments.push(seg);
+      state.totalDuration = cursor;
       if (!firstFlushed) {
         firstFlushed = true;
-        const q0 = streams[streamId]?.queue[0];
-        const sidMatch   = q0?._sid === ownerSid;
-        const startMatch = typeof q0._hlsStart === 'number' && songHlsStart === q0._hlsStart;
-        if (sidMatch && startMatch) {
-          streams[streamId].songStartTime = Date.now();
+        state.generating = false;
+        if (streams[streamId]?.queue.length > 0) {
+          const q0 = streams[streamId].queue[0];
+          const sidMatch   = ownerSid ? q0._sid === ownerSid : true;
+          const startMatch = typeof q0._hlsStart === 'number' && songHlsStart === q0._hlsStart;
+          console.log(`🔑 Ownership check: sid=${q0._sid?.slice(0,8)}==${ownerSid?.slice(0,8)}:${sidMatch} hlsStart=${q0._hlsStart}==${songHlsStart}:${startMatch}`);
+          if (sidMatch && startMatch) {
+            streams[streamId].songStartTime = Date.now();
+            console.log(`⏱️  songStartTime reset for "${q0.meta.title}" [${q0._sid}] (first segment ready)`);
+          } else if (sidMatch && q0._hlsStart === undefined) {
+            // brief window before _hlsStart is set — harmless
+          } else {
+            console.log(`⚠️  watchForSegments ownership mismatch — skipping songStartTime reset. watcher=[${ownerSid}@${songHlsStart}] queue[0]=[${q0._sid}@${q0._hlsStart}]`);
+          }
         }
-        onFirstSeg();
+        if (onFirstSeg) onFirstSeg();
       }
     }
+  };
+
+  let lastEntryCount = -1;
+  let stablePolls    = 0;
+  const STABLE_NEEDED = 3;
 
+  const iv = setInterval(() => {
+    flush();
+    const entries = parseM3u8Durations(playlistPath);
     if (entries.length === lastEntryCount && !activeFFmpeg[streamId]) {
-      stableCount++;
-      if (stableCount >= STABLE_NEEDED) { clearInterval(iv); }
-    } else { stableCount = 0; }
-    lastEntryCount = entries.length;
-  }, 500);
+      stablePolls++;
+      if (stablePolls >= STABLE_NEEDED) {
+        console.log(`🛑 watchForSegments auto-stop [${ownerSid?.slice(0,8)}]: stable for ${STABLE_NEEDED} polls, FFmpeg done`);
+        clearInterval(iv);
+      }
+    } else {
+      stablePolls    = 0;
+      lastEntryCount = entries.length;
+    }
+  }, 800);
+  const markDone = () => { flush(); clearInterval(iv); return cursor; };
+  return { stop: () => clearInterval(iv), markDone };
 }
 
 async function generateSegmentsForSong(streamId, songInfo, isVideo, state) {
-  const dir       = ensureHlsDir(streamId);
-  const songPath  = path.join(SONGS_DIR, songInfo.fileName);
-  const segPrefix = `seg_${streamId}_${Date.now()}`;
-  const myGen     = hlsGeneration[streamId] || 0;
-
-  return new Promise((resolve, reject) => {
-    const segPattern   = path.join(dir, segPrefix + '_%03d.ts');
-    const playlistPath = path.join(dir, segPrefix + '.m3u8');
-    const songHlsStart = state.totalDuration;
+  const dir          = ensureHlsDir(streamId);
+  const songPath     = path.join(SONGS_DIR, songInfo.fileName);
+  const segPrefix    = `seg_${streamId}_${Date.now()}`;
 
-    let resolved = false;
-    function safeResolve(v) { if (!resolved) { resolved = true; resolve(v); } }
+  console.log(`🎬 FFmpeg starting: ${songPath} isVideo=${isVideo}`);
+  if (!fs.existsSync(songPath)) throw new Error(`Source file missing: ${songPath}`);
+  const fileStat = fs.statSync(songPath);
+  if (fileStat.size === 0) throw new Error('Source file is empty');
+  console.log(`📁 Source file: ${(fileStat.size / 1024 / 1024).toFixed(1)}MB`);
 
-    watchForSegments(
-      streamId, dir, segPrefix, songHlsStart,
-      () => safeResolve({ hlsStart: songHlsStart }),
-      songInfo._sid, state
-    );
+  const segPattern   = path.join(dir, segPrefix + '_%03d.ts');
+  const playlistPath = path.join(dir, segPrefix + '.m3u8');
+  const songHlsStart = state.totalDuration;
+  console.log(`🎯 segPrefix=${segPrefix} songHlsStart=${songHlsStart} ownerSid=${songInfo._sid?.slice(0,8)}`);
 
+  return new Promise((resolve, reject) => {
     const cmd = ffmpeg(songPath);
-    if (!isVideo) {
-      cmd.audioCodec('aac').audioBitrate('128k').noVideo();
+    if (isVideo) {
+      cmd.outputOptions([
+        '-map','0:v:0','-map','0:a:0',
+        '-c:v','libx264','-preset','ultrafast','-crf','28',
+        '-profile:v','main','-level','3.1','-pix_fmt','yuv420p',
+        '-vf','scale=854:480',
+        '-c:a','aac','-b:a','128k',
+        '-f','segment','-segment_time','8',
+        '-segment_list',playlistPath,'-segment_list_flags','+live','-segment_format','mpegts',
+      ]);
     } else {
-      cmd.videoCodec('libx264').audioCodec('aac').audioBitrate('128k')
-         .outputOptions(['-preset', 'ultrafast', '-tune', 'zerolatency', '-crf', '23',
-                         '-vf', 'scale=854:480:force_original_aspect_ratio=decrease,pad=854:480:(ow-iw)/2:(oh-ih)/2']);
+      cmd.outputOptions(['-vn','-c:a','aac','-b:a','128k','-f','segment','-segment_time','8','-segment_list',playlistPath,'-segment_list_flags','+live','-segment_format','mpegts']);
     }
-    cmd.outputOptions([
-      '-f', 'hls',
-      '-hls_time', '8',
-      '-hls_list_size', '0',
-      '-hls_segment_type', 'mpegts',
-      `-hls_segment_filename`, segPattern,
-      '-hls_flags', 'independent_segments',
-    ]).output(playlistPath);
-
-    activeFFmpeg[streamId] = cmd;
-
-    cmd.on('error', (err) => {
-      delete activeFFmpeg[streamId];
-      if (hlsGeneration[streamId] !== myGen) { safeResolve({ hlsStart: songHlsStart }); return; }
-      console.error(`FFmpeg error [${streamId}]:`, err.message);
-      if (state) state.generating = false;
-      if (!resolved) reject(err);
-    });
-    cmd.on('end', () => {
-      delete activeFFmpeg[streamId];
-      if (state) state.generating = false;
-      safeResolve({ hlsStart: songHlsStart });
-    });
-    cmd.run();
+    let watcher = null;
+    cmd.output(segPattern)
+      .on('start', () => {
+        activeFFmpeg[streamId] = cmd;
+        console.log(`🎬 FFmpeg process started [${streamId}] gen=${hlsGeneration[streamId]}`);
+        watcher = watchForSegments(streamId, dir, segPrefix, songHlsStart, () => {
+          console.log(`⚡ First segment ready for stream ${streamId}`);
+          sendStreamUpdate(streamId);
+        }, songInfo._sid, state);
+      })
+      .on('stderr', line => {
+        if (line.includes('Error') || line.includes('error') || line.includes('Invalid')) {
+          console.error(`FFmpeg stderr: ${line}`);
+        }
+      })
+      .on('end', () => {
+        console.log(`✅ FFmpeg done for ${streamId}`);
+        delete activeFFmpeg[streamId];
+        if (!watcher) { resolve(0); return; }
+        const finalCursor = watcher.markDone();
+        console.log(`📐 Final cursor from playlist: ${finalCursor.toFixed(3)}s`);
+        state.totalDuration = finalCursor;
+        try { fs.unlinkSync(playlistPath); } catch {}
+        resolve(finalCursor);
+      })
+      .on('error', (err) => {
+        console.log(`💥 FFmpeg error for ${streamId}: ${err.message}`);
+        delete activeFFmpeg[streamId];
+        if (err.message && (err.message.includes('SIGKILL') || err.message.includes('killed'))) {
+          console.log(`⚡ FFmpeg killed cleanly for ${streamId} (skip)`);
+          if (watcher) watcher.stop();
+          resolve(0);
+          return;
+        }
+        console.error(`❌ FFmpeg error for ${streamId}:`, err.message);
+        if (watcher) watcher.stop();
+        reject(err);
+      })
+      .run();
   });
 }
 
 async function appendSongToHls(streamId, songInfo) {
-  if (!hlsMutex[streamId]) hlsMutex[streamId] = Promise.resolve();
-  hlsMutex[streamId] = hlsMutex[streamId].then(async () => {
-    const myGen = hlsGeneration[streamId] || 0;
-    if (!hlsState[streamId]) {
-      hlsState[streamId] = { segments: [], totalDuration: 0, mediaSeq: 0, generating: false };
+  if (!hlsState[streamId]) {
+    hlsState[streamId] = { mediaSeq: 0, segments: [], totalDuration: 0, generating: true };
+    console.log(`📦 appendSongToHls: created fresh hlsState for ${streamId}`);
+  }
+  const myGeneration = hlsGeneration[streamId] || 0;
+  const prev = hlsMutex[streamId] || Promise.resolve();
+  console.log(`📌 appendSongToHls queued: "${songInfo.meta.title}" [${songInfo._sid?.slice(0,8)}] gen=${myGeneration}`);
+  const next = prev.then(async () => {
+    const currentGen = hlsGeneration[streamId] || 0;
+    if (currentGen !== myGeneration) {
+      console.log(`⏩ Skipping stale appendSongToHls for "${songInfo.meta.title}" (gen ${myGeneration} vs ${currentGen})`);
+      return;
+    }
+    const isVideo = !!(songInfo.meta && songInfo.meta.videoUrl);
+    const state   = hlsState[streamId];
+    if (!state) {
+      console.log(`⏩ Skipping appendSongToHls for "${songInfo.meta.title}" — hlsState gone`);
+      return;
     }
-    const state    = hlsState[streamId];
     state.generating = true;
-    const isVideo  = !!songInfo.meta.videoUrl;
+    songInfo._hlsStart = state.totalDuration;
+    console.log(`📍 _hlsStart set to ${songInfo._hlsStart.toFixed(2)}s for "${songInfo.meta.title}"`);
     try {
-      const { hlsStart } = await generateSegmentsForSong(streamId, songInfo, isVideo, state);
-      if (hlsGeneration[streamId] !== myGen) return;
-      songInfo._hlsStart    = hlsStart;
-      songInfo._hlsEnd      = state.totalDuration;
-      songInfo._hlsPregened = true;
+      const finalCursor = await generateSegmentsForSong(streamId, songInfo, isVideo, state);
+      if (typeof finalCursor === 'number' && finalCursor > 0) {
+        songInfo._hlsEnd = finalCursor;
+        const actualDuration = finalCursor - songInfo._hlsStart;
+        if (actualDuration > 0 && Math.abs(actualDuration - (songInfo.meta.duration || 0)) > 30) {
+          console.log(`📐 Correcting meta.duration for "${songInfo.meta.title}": ${(songInfo.meta.duration || 0).toFixed(1)}s → ${actualDuration.toFixed(1)}s`);
+          songInfo.meta.duration = actualDuration;
+        }
+        songInfo._hlsDurationTrusted = true;
+      } else {
+        songInfo._hlsEnd = state.totalDuration;
+        console.log(`⚡ Encode killed for "${songInfo.meta.title}" — hlsEnd set to ${songInfo._hlsEnd?.toFixed(2)}s`);
+      }
+      state.generating = false;
+      console.log(`📺 HLS done for "${songInfo.meta.title}": hlsStart=${songInfo._hlsStart?.toFixed(2)}s hlsEnd=${songInfo._hlsEnd?.toFixed(2)}s segs=${state.segments.length}`);
+      const finalGen   = hlsGeneration[streamId] || 0;
+      const liveStream = streams[streamId];
+      if (finalGen === myGeneration && liveStream && liveStream.queue[0]?._sid === songInfo._sid) {
+        if (!liveStream.songStartTime) {
+          liveStream.songStartTime = Date.now();
+          console.log(`⏱️  songStartTime set post-encode for "${songInfo.meta.title}" [${songInfo._sid}]`);
+          sendStreamUpdate(streamId);
+        }
+        preGenerateNextSong(streamId).catch(console.error);
+      }
     } catch (err) {
-      console.error(`appendSongToHls error [${streamId}]:`, err.message);
-      if (state) state.generating = false;
+      console.error(`HLS generation failed for stream ${streamId}:`, err);
+      if (hlsState[streamId]) hlsState[streamId].generating = false;
     }
   });
-  return hlsMutex[streamId];
+  hlsMutex[streamId] = next;
+  return next;
 }
 
 async function preGenerateNextSong(streamId) {
   const stream = streams[streamId];
   if (!stream || stream.queue.length < 2) return;
-  const next = stream.queue[1];
-  if (next._hlsPregened || next._hlsPregenInProgress) return;
-  next._hlsPregenInProgress = true;
+  const nextSong = stream.queue[1];
+  if (!nextSong || nextSong._hlsPregened || nextSong._hlsPregenInProgress) return;
+  nextSong._hlsPregenInProgress = true;
+  const sid = nextSong._sid;
+  console.log(`🔄 Pre-generating HLS for next: ${nextSong.meta.title} [${sid}]`);
   try {
-    await appendSongToHls(streamId, next);
-    next._hlsPregened = true;
+    await appendSongToHls(streamId, nextSong);
   } catch (err) {
-    next._hlsPregenInProgress = false;
-    console.error(`Pre-gen failed for "${next.meta.title}":`, err.message);
+    nextSong._hlsPregenInProgress = false;
+    console.error(`Pre-gen failed for "${nextSong.meta.title}":`, err.message);
+    return;
+  }
+  const streamNow      = streams[streamId];
+  const stillQueued    = streamNow && streamNow.queue.some(s => s._sid === sid);
+  const encodingFinished = typeof nextSong._hlsEnd === 'number' && typeof nextSong._hlsStart === 'number' && nextSong._hlsEnd > nextSong._hlsStart;
+  if (stillQueued && encodingFinished) {
+    nextSong._hlsPregened = true;
+    console.log(`✅ Pre-gen confirmed for "${nextSong.meta.title}" [${sid}]: hlsStart=${nextSong._hlsStart.toFixed(2)}s hlsEnd=${nextSong._hlsEnd.toFixed(2)}s`);
+  } else {
+    nextSong._hlsPregened        = false;
+    nextSong._hlsPregenInProgress = false;
+    delete nextSong._hlsStart;
+    delete nextSong._hlsEnd;
+    console.log(`⚠️  Pre-gen invalidated for "${nextSong.meta.title}" [${sid}]`);
   }
 }
 
 function advanceToNextSong(streamId, autoAdvance = false) {
   const stream = streams[streamId];
   if (!stream) return false;
+  if (autoAdvance) stream._notifyOnStart = true;
+  else delete stream._notifyOnStart;
   killActiveFFmpeg(streamId);
   const finishedSong = stream.queue.shift();
   const filePath     = path.join(SONGS_DIR, finishedSong.fileName);
@@ -568,6 +864,7 @@ function advanceToNextSong(streamId, autoAdvance = false) {
       delete hlsState[streamId]; delete hlsMutex[streamId];
     }
     hlsGeneration[streamId] = (hlsGeneration[streamId] || 0) + 1;
+    console.log(`🔄 Stream ${streamId} queue empty — HLS state reset for fresh start`);
     io.to(`stream:${streamId}`).emit('message', { type: 'stream_ended', message: 'Queue is empty.' });
     return false;
   }
@@ -580,6 +877,7 @@ function advanceToNextSong(streamId, autoAdvance = false) {
     stream.songStartTime    = Date.now();
     stream.lastActivity     = Date.now();
     stream.isActive         = true;
+    delete stream._notifyOnStart;
     sendStreamUpdate(streamId);
     preGenerateNextSong(streamId).catch(console.error);
   } else {
@@ -617,12 +915,17 @@ function enqueueToStream(streamId, songInfo) {
   stream.lastActivity = Date.now();
   const position = stream.queue.length;
   if (!stream.isActive && position === 1 && !stream._showplayInProgress) {
-    if (hlsState[streamId]) {
-      const hlsDir = path.join(HLS_DIR, streamId);
-      if (fs.existsSync(hlsDir)) { try { const files = fs.readdirSync(hlsDir); for (const f of files) { try { fs.unlinkSync(path.join(hlsDir, f)); } catch {} } } catch {} }
-      delete hlsState[streamId]; delete hlsMutex[streamId];
+    // Stream was idle/ended — ensure HLS state is fresh so this song starts at t=0.
+    if (!hlsState[streamId] || hlsState[streamId].totalDuration > 0) {
+      if (hlsState[streamId]) {
+        const hlsDir = path.join(HLS_DIR, streamId);
+        if (fs.existsSync(hlsDir)) {
+          try { const files = fs.readdirSync(hlsDir); for (const f of files) { try { fs.unlinkSync(path.join(hlsDir, f)); } catch {} } } catch {}
+        }
+        delete hlsState[streamId]; delete hlsMutex[streamId];
+      }
+      hlsGeneration[streamId] = (hlsGeneration[streamId] || 0) + 1;
     }
-    hlsGeneration[streamId] = (hlsGeneration[streamId] || 0) + 1;
     stream.streamTimeOffset = 0;
     stream.songStartTime    = null;
     stream.isActive         = true;
@@ -764,14 +1067,19 @@ setInterval(async () => {
       const current = stream.queue[0];
       if (!current) continue;
       let songDuration;
-      if (current.meta.duration > 0) songDuration = current.meta.duration;
-      else if (typeof current._hlsEnd === 'number' && typeof current._hlsStart === 'number') songDuration = current._hlsEnd - current._hlsStart;
-      else continue;
+      if (current._hlsDurationTrusted && typeof current._hlsEnd === 'number' && typeof current._hlsStart === 'number') {
+        songDuration = current._hlsEnd - current._hlsStart;
+      } else if (current.meta.duration > 0) {
+        songDuration = current.meta.duration;
+      } else if (typeof current._hlsEnd === 'number' && typeof current._hlsStart === 'number') {
+        songDuration = current._hlsEnd - current._hlsStart;
+      } else continue;
       if (songDuration < 5 || !stream.songStartTime) continue;
       const elapsed = (Date.now() - stream.songStartTime) / 1000;
       if (elapsed >= songDuration + 3) {
         if (stream._advancingFromSid === current._sid) continue;
         stream._advancingFromSid = current._sid;
+        console.log(`⏭️  Auto-advance "${current.meta.title}": elapsed=${elapsed.toFixed(1)}s duration=${songDuration.toFixed(1)}s`);
         advanceToNextSong(streamId, true);
         if (stream._advancingFromSid === current._sid) delete stream._advancingFromSid;
       }