plexsonic 0.1.5 → 0.1.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "plexsonic",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "PlexMusic to OpenSubsonic bridge",
   "main": "./src/index.js",
   "bin": {

package/src/server.js

@@ -19,7 +19,7 @@
  */
 
 import { createHash, randomUUID } from 'node:crypto';
-import { Readable } from 'node:stream';
+import { PassThrough, Readable } from 'node:stream';
 import Fastify from 'fastify';
 import argon2 from 'argon2';
 import fastifyCookie from '@fastify/cookie';
@@ -868,6 +868,111 @@ function isPlexLiked(value) {
   return normalized != null && normalized >= 2 && normalized % 2 === 0;
 }
 
+function normalizePlainText(value) {
+  return String(value || '')
+    .replace(/<br\s*\/?>/gi, '\n')
+    .replace(/<\/p>/gi, '\n')
+    .replace(/<[^>]*>/g, '')
+    .replace(/\r\n/g, '\n')
+    .replace(/\n{3,}/g, '\n\n')
+    .trim();
+}
+
+function asArray(value) {
+  if (Array.isArray(value)) {
+    return value;
+  }
+  if (value == null) {
+    return [];
+  }
+  return [value];
+}
+
+function plexGuidIds(item) {
+  const candidates = [];
+
+  for (const guid of asArray(item?.Guid)) {
+    if (typeof guid === 'string') {
+      candidates.push(guid);
+      continue;
+    }
+    if (guid && typeof guid === 'object' && typeof guid.id === 'string') {
+      candidates.push(guid.id);
+    }
+  }
+
+  for (const raw of [item?.guid, item?.guids]) {
+    if (typeof raw === 'string') {
+      candidates.push(raw);
+    } else if (Array.isArray(raw)) {
+      for (const entry of raw) {
+        if (typeof entry === 'string') {
+          candidates.push(entry);
+        } else if (entry && typeof entry === 'object' && typeof entry.id === 'string') {
+          candidates.push(entry.id);
+        }
+      }
+    }
+  }
+
+  return uniqueNonEmptyValues(candidates);
+}
+
+function extractMusicBrainzArtistId(item) {
+  const guidIds = plexGuidIds(item);
+  const uuidPattern = /([0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12})/i;
+
+  for (const guid of guidIds) {
+    const lower = safeLower(guid);
+
+    if (lower.startsWith('mbid://')) {
+      const id = guid.slice('mbid://'.length).split(/[/?#]/, 1)[0].trim();
+      if (id) {
+        return id;
+      }
+    }
+
+    if (lower.startsWith('musicbrainz://')) {
+      const id = guid
+        .slice('musicbrainz://'.length)
+        .replace(/^artist\//i, '')
+        .split(/[?#]/, 1)[0]
+        .replace(/^\/+/, '')
+        .trim();
+      if (id) {
+        return id;
+      }
+    }
+
+    if (lower.includes('musicbrainz.org/artist/')) {
+      const match = guid.match(/musicbrainz\.org\/artist\/([^/?#]+)/i);
+      if (match?.[1]) {
+        return match[1];
+      }
+    }
+
+    if (lower.includes('musicbrainz')) {
+      const uuid = guid.match(uuidPattern)?.[1];
+      if (uuid) {
+        return uuid;
+      }
+    }
+  }
+
+  return '';
+}
+
+function artistBioFromPlex(item) {
+  return firstNonEmptyText(
+    [
+      normalizePlainText(item?.summary),
+      normalizePlainText(item?.tagline),
+      normalizePlainText(item?.description),
+    ],
+    '',
+  );
+}
+
 function subsonicRatingToPlexRating(value, { liked = false } = {}) {
   const rating = Number.parseInt(String(value ?? ''), 10);
   if (!Number.isFinite(rating) || rating <= 0) {
@@ -1694,6 +1799,35 @@ function isAbortError(error) {
   return error?.name === 'AbortError' || error?.code === 'ABORT_ERR';
 }
 
+function isUpstreamTerminationError(error) {
+  if (!error) {
+    return false;
+  }
+
+  const message = String(error?.message || '').toLowerCase();
+  const causeMessage = String(error?.cause?.message || '').toLowerCase();
+  const code = String(error?.code || error?.cause?.code || '').toUpperCase();
+  const causeName = String(error?.cause?.name || '').toLowerCase();
+
+  return (
+    code === 'ECONNRESET' ||
+    code === 'EPIPE' ||
+    message.includes('terminated') ||
+    message.includes('other side closed') ||
+    causeMessage.includes('other side closed') ||
+    causeName.includes('socketerror')
+  );
+}
+
+function isClientDisconnected(request, reply) {
+  return Boolean(
+    request?.raw?.aborted ||
+    request?.raw?.destroyed ||
+    reply?.raw?.destroyed ||
+    reply?.raw?.writableEnded,
+  );
+}
+
 const RETRYABLE_UPSTREAM_STATUSES = new Set([408, 429, 500, 502, 503, 504]);
 
 function waitMs(ms) {
@@ -2346,12 +2480,16 @@ export async function buildServer(config = loadConfig()) {
   });
 
   const playbackSessions = new Map();
+  const recentScrobblesByClient = new Map();
   const savedPlayQueues = new Map();
   const PLAYBACK_RECONCILE_INTERVAL_MS = 15000;
   const PLAYBACK_IDLE_TIMEOUT_MS = 120000;
   const STREAM_DISCONNECT_STOP_DELAY_MS = 4000;
   const PLAYBACK_MAX_DISCONNECT_WAIT_MS = 30 * 60 * 1000;
   const STREAM_PROGRESS_HEARTBEAT_MS = 10000;
+  const STREAM_PRELOAD_SUPPRESS_AFTER_SCROBBLE_MS = 1500;
+  const STREAM_SUPPRESSED_PROMOTE_DELAY_MS = 1200;
+  const PLAYBACK_CONTINUITY_AFTER_SCROBBLE_MS = 15000;
   const PLAY_QUEUE_IDLE_TTL_MS = 6 * 60 * 60 * 1000;
   const activeSearchRequests = new Map();
   const searchBrowseCache = new Map();
@@ -3161,6 +3299,116 @@ export async function buildServer(config = loadConfig()) {
     };
   }
 
+  function pruneRecentScrobbles(now = Date.now()) {
+    void now;
+    for (const [key, value] of recentScrobblesByClient.entries()) {
+      if (!value) {
+        recentScrobblesByClient.delete(key);
+      }
+    }
+  }
+
+  function getPlaybackContinuityState(accountId, clientName) {
+    const playbackClient = playbackClientContext(accountId, clientName);
+    let state = recentScrobblesByClient.get(playbackClient.sessionKey);
+    if (!state) {
+      state = {
+        at: 0,
+        trackId: '',
+        queueCurrentId: '',
+        queueIds: [],
+      };
+      recentScrobblesByClient.set(playbackClient.sessionKey, state);
+    }
+    return { playbackClient, state };
+  }
+
+  function resolveQueuedNextTrackId(state, currentTrackId) {
+    const normalizedCurrent = String(currentTrackId || '').trim();
+    if (!normalizedCurrent) {
+      return '';
+    }
+
+    const queueIds = Array.isArray(state?.queueIds) ? state.queueIds : [];
+    if (queueIds.length === 0) {
+      return '';
+    }
+
+    const index = queueIds.findIndex((id) => String(id || '').trim() === normalizedCurrent);
+    if (index === -1) {
+      return '';
+    }
+    const next = String(queueIds[index + 1] || '').trim();
+    return next;
+  }
+
+  function notePlaybackQueueContext({ accountId, clientName, currentTrackId = '', queueIds = [] }) {
+    const { state } = getPlaybackContinuityState(accountId, clientName);
+    state.queueCurrentId = String(currentTrackId || '').trim();
+    state.queueIds = uniqueNonEmptyValues(Array.isArray(queueIds) ? queueIds : []);
+  }
+
+  function noteRecentScrobble({ accountId, clientName, trackId = '' }) {
+    const now = Date.now();
+    const { state } = getPlaybackContinuityState(accountId, clientName);
+    state.at = now;
+    state.trackId = String(trackId || '').trim();
+    pruneRecentScrobbles(now);
+  }
+
+  function shouldSuppressPlaybackSyncForStreamLoad({ accountId, clientName, trackId }) {
+    const now = Date.now();
+    pruneRecentScrobbles(now);
+
+    const { playbackClient, state: recent } = getPlaybackContinuityState(accountId, clientName);
+    const current = playbackSessions.get(playbackClient.sessionKey);
+
+    const normalizedTrackId = String(trackId || '').trim();
+    if (!normalizedTrackId) {
+      return false;
+    }
+
+    const currentTrackId = String(current?.itemId || '').trim();
+    if (current?.state === 'playing' && currentTrackId && normalizedTrackId === currentTrackId) {
+      return false;
+    }
+
+    const queuedCurrentId = String(recent.queueCurrentId || '').trim();
+    if (queuedCurrentId && queuedCurrentId === normalizedTrackId) {
+      return false;
+    }
+
+    const recentTrackId = String(recent.trackId || '').trim();
+    if (
+      recentTrackId &&
+      recentTrackId === currentTrackId &&
+      (now - Number(recent.at || 0)) <= PLAYBACK_CONTINUITY_AFTER_SCROBBLE_MS
+    ) {
+      const queuedNextTrackId = resolveQueuedNextTrackId(recent, recentTrackId);
+      if (queuedNextTrackId && queuedNextTrackId === normalizedTrackId) {
+        return false;
+      }
+    }
+
+    // No confirmed playback and no trusted continuity signal: treat stream load as preload.
+    if (!current || current.state !== 'playing') {
+      return true;
+    }
+
+    // Current track exists but stale: still require explicit continuity signal to avoid preload flashes.
+    if ((now - Number(current.updatedAt || 0)) > PLAYBACK_IDLE_TIMEOUT_MS) {
+      return true;
+    }
+
+    // Suppress short-lived preloads right after a scrobble signal.
+    if ((now - Number(recent.at || 0)) <= STREAM_PRELOAD_SUPPRESS_AFTER_SCROBBLE_MS) {
+      return true;
+    }
+
+    // Continuity mode: keep current track authoritative unless trusted signal allows switch.
+    return true;
+  }
+
   async function syncClientPlaybackState({
     accountId,
     plexState,
@@ -5331,6 +5579,13 @@ export async function buildServer(config = loadConfig()) {
       updatedAt: now,
     });
     pruneSavedPlayQueues(now);
+    const clientName = getRequestParam(request, 'c') || 'Subsonic Client';
+    notePlaybackQueueContext({
+      accountId: account.id,
+      clientName,
+      currentTrackId: current,
+      queueIds: ids,
+    });
 
     return sendSubsonicOk(reply);
   });
@@ -5344,9 +5599,11 @@ export async function buildServer(config = loadConfig()) {
         return;
       }
 
+      const songIds = uniqueNonEmptyValues(getRequestParamValues(request, 'songId'));
+      const genericIds = uniqueNonEmptyValues(getRequestParamValues(request, 'id'));
       const ids = uniqueNonEmptyValues([
-        ...getRequestParamValues(request, 'id'),
-        ...getRequestParamValues(request, 'songId'),
+        ...songIds,
+        ...genericIds,
       ]);
 
       if (ids.length === 0) {
@@ -5377,43 +5634,113 @@ export async function buildServer(config = loadConfig()) {
           ? Math.round(parsedOffset * 1000)
           : 0;
       const clientName = getRequestParam(request, 'c') || 'Subsonic Client';
-      const primaryTrackId = ids[0] || '';
+      const primaryTrackId = firstNonEmptyText(
+        [
+          getRequestParam(request, 'songId'),
+          getRequestParam(request, 'id'),
+          songIds[0],
+          ids[0],
+        ],
+        '',
+      );
+      const submissionIds = shouldSubmit
+        ? uniqueNonEmptyValues([primaryTrackId, ...ids])
+        : [];
+      const isNowPlayingScrobble = !shouldSubmit;
       const shouldSyncPlayback =
         Boolean(primaryTrackId) &&
-        (!shouldSubmit || ids.length === 1 || hasExplicitState) &&
-        (hasPlaybackProgress || hasExplicitState);
+        (
+          hasPlaybackProgress ||
+          hasExplicitState ||
+          isNowPlayingScrobble
+        );
+      const playbackClient = playbackClientContext(account.id, clientName);
+
+      let playbackSyncPromise = null;
+      if (shouldSyncPlayback) {
+        playbackSyncPromise = syncClientPlaybackState({
+          accountId: account.id,
+          plexState,
+          clientName,
+          itemId: primaryTrackId,
+          state: playbackState,
+          positionMs: playbackPositionMs,
+          request,
+        }).catch((error) => {
+          request.log.warn(error, 'Failed to sync playback status to Plex');
+        });
+      }
 
       try {
-        if (shouldSubmit) {
-          await Promise.all(
-            ids.map((id) =>
-              scrobblePlexItem({
-                baseUrl: plexState.baseUrl,
-                plexToken: plexState.plexToken,
-                itemId: id,
-              }),
-            ),
-          );
+        if (submissionIds.length > 0) {
+          const [firstId, ...restIds] = submissionIds;
+          await scrobblePlexItem({
+            baseUrl: plexState.baseUrl,
+            plexToken: plexState.plexToken,
+            itemId: firstId,
+          });
+          if (restIds.length > 0) {
+            await Promise.all(
+              restIds.map((id) =>
+                scrobblePlexItem({
+                  baseUrl: plexState.baseUrl,
+                  plexToken: plexState.plexToken,
+                  itemId: id,
+                }),
+              ),
+            );
+          }
         }
       } catch (error) {
         request.log.error(error, 'Failed to sync scrobble to Plex');
         return sendSubsonicError(reply, 10, 'Failed to scrobble');
       }
 
-      try {
-        if (shouldSyncPlayback) {
-          await syncClientPlaybackState({
-            accountId: account.id,
-            plexState,
-            clientName,
-            itemId: primaryTrackId,
-            state: playbackState,
-            positionMs: playbackPositionMs,
-            request,
-          });
+      if (playbackSyncPromise) {
+        await playbackSyncPromise;
+      }
+
+      noteRecentScrobble({
+        accountId: account.id,
+        clientName,
+        trackId: primaryTrackId,
+      });
+
+      const allowQueuedPromotion =
+        shouldSubmit &&
+        Boolean(primaryTrackId) &&
+        (
+          (hasExplicitState && playbackState === 'stopped') ||
+          (hasPlaybackProgress && playbackPositionMs > 0)
+        );
+
+      if (allowQueuedPromotion) {
+        const continuity = recentScrobblesByClient.get(playbackClient.sessionKey);
+        const queuedNextTrackId = resolveQueuedNextTrackId(continuity, primaryTrackId);
+        if (queuedNextTrackId) {
+          const current = playbackSessions.get(playbackClient.sessionKey);
+          const currentTrackId = String(current?.itemId || '').trim();
+          const shouldPromoteQueuedNext =
+            !current ||
+            current.state !== 'playing' ||
+            currentTrackId === primaryTrackId;
+
+          if (shouldPromoteQueuedNext) {
+            try {
+              await syncClientPlaybackState({
+                accountId: account.id,
+                plexState,
+                clientName,
+                itemId: queuedNextTrackId,
+                state: 'playing',
+                positionMs: 0,
+                request,
+              });
+            } catch (error) {
+              request.log.warn(error, 'Failed to promote queued next track after scrobble');
+            }
+          }
         }
-      } catch (error) {
-        request.log.warn(error, 'Failed to sync playback status to Plex');
       }
 
       return sendSubsonicOk(reply);
@@ -6131,7 +6458,61 @@ export async function buildServer(config = loadConfig()) {
       return;
     }
 
-    return sendSubsonicOk(reply, node('artistInfo'));
+    const artistId = String(getRequestParam(request, 'id') || '').trim();
+    if (!artistId) {
+      return sendSubsonicError(reply, 70, 'Missing artist id');
+    }
+
+    const context = repo.getAccountPlexContext(account.id);
+    const plexState = requiredPlexStateForSubsonic(reply, context, tokenCipher);
+    if (!plexState) {
+      return;
+    }
+
+    try {
+      let artist = null;
+      try {
+        artist = await getArtist({
+          baseUrl: plexState.baseUrl,
+          plexToken: plexState.plexToken,
+          artistId,
+        });
+      } catch (error) {
+        if (!isPlexNotFoundError(error)) {
+          throw error;
+        }
+      }
+
+      if (!artist) {
+        const fallback = await resolveArtistFromCachedLibrary({
+          accountId: account.id,
+          plexState,
+          request,
+          artistId,
+        });
+        if (fallback?.artist) {
+          artist = fallback.artist;
+        }
+      }
+
+      if (!artist) {
+        return sendSubsonicError(reply, 70, 'Artist not found');
+      }
+
+      const biography = artistBioFromPlex(artist);
+      const musicBrainzId = extractMusicBrainzArtistId(artist);
+      const children = [
+        biography ? node('biography', {}, biography) : '',
+        musicBrainzId ? node('musicBrainzId', {}, musicBrainzId) : '',
+      ]
+        .filter(Boolean)
+        .join('');
+
+      return sendSubsonicOk(reply, node('artistInfo', {}, children));
+    } catch (error) {
+      request.log.error(error, 'Failed to load artist info');
+      return sendSubsonicError(reply, 10, 'Failed to load artist info');
+    }
   });
 
   app.get('/rest/getArtistInfo2.view', async (request, reply) => {
@@ -6140,7 +6521,61 @@ export async function buildServer(config = loadConfig()) {
       return;
     }
 
-    return sendSubsonicOk(reply, node('artistInfo2'));
+    const artistId = String(getRequestParam(request, 'id') || '').trim();
+    if (!artistId) {
+      return sendSubsonicError(reply, 70, 'Missing artist id');
+    }
+
+    const context = repo.getAccountPlexContext(account.id);
+    const plexState = requiredPlexStateForSubsonic(reply, context, tokenCipher);
+    if (!plexState) {
+      return;
+    }
+
+    try {
+      let artist = null;
+      try {
+        artist = await getArtist({
+          baseUrl: plexState.baseUrl,
+          plexToken: plexState.plexToken,
+          artistId,
+        });
+      } catch (error) {
+        if (!isPlexNotFoundError(error)) {
+          throw error;
+        }
+      }
+
+      if (!artist) {
+        const fallback = await resolveArtistFromCachedLibrary({
+          accountId: account.id,
+          plexState,
+          request,
+          artistId,
+        });
+        if (fallback?.artist) {
+          artist = fallback.artist;
+        }
+      }
+
+      if (!artist) {
+        return sendSubsonicError(reply, 70, 'Artist not found');
+      }
+
+      const biography = artistBioFromPlex(artist);
+      const musicBrainzId = extractMusicBrainzArtistId(artist);
+      const children = [
+        biography ? node('biography', {}, biography) : '',
+        musicBrainzId ? node('musicBrainzId', {}, musicBrainzId) : '',
+      ]
+        .filter(Boolean)
+        .join('');
+
+      return sendSubsonicOk(reply, node('artistInfo2', {}, children));
+    } catch (error) {
+      request.log.error(error, 'Failed to load artist info2');
+      return sendSubsonicError(reply, 10, 'Failed to load artist info');
+    }
   });
 
   app.get('/rest/getAlbum.view', async (request, reply) => {
@@ -6632,6 +7067,13 @@ export async function buildServer(config = loadConfig()) {
 
       const clientName = getRequestParam(request, 'c') || 'Subsonic Client';
       const playbackClient = playbackClientContext(account.id, clientName);
+      const { state: continuityState } = getPlaybackContinuityState(account.id, clientName);
+      const streamPlaybackAuthorityDisabled = Number(continuityState.at || 0) > 0;
+      const suppressStreamLoadPlaybackSync = shouldSuppressPlaybackSyncForStreamLoad({
+        accountId: account.id,
+        clientName,
+        trackId,
+      }) || streamPlaybackAuthorityDisabled;
       const offsetRaw = getRequestParam(request, 'timeOffset');
       const offsetSeconds = Number.parseFloat(offsetRaw);
       const offsetMs = Number.isFinite(offsetSeconds) && offsetSeconds > 0 ? Math.round(offsetSeconds * 1000) : 0;
@@ -6655,23 +7097,71 @@ export async function buildServer(config = loadConfig()) {
           progressTimer = null;
         }
       };
+      let streamClosed = false;
+      let streamTrackingStarted = false;
+      let suppressedPromoteTimer = null;
+      const clearSuppressedPromoteTimer = () => {
+        if (suppressedPromoteTimer) {
+          clearTimeout(suppressedPromoteTimer);
+          suppressedPromoteTimer = null;
+        }
+      };
 
-      try {
-        await syncClientPlaybackState({
-          accountId: account.id,
-          plexState,
-          clientName,
-          itemId: trackId,
-          state: 'playing',
-          positionMs: offsetMs,
-          durationMs: trackDurationMs,
-          request,
-        });
-      } catch (error) {
-        request.log.warn(error, 'Failed to sync stream-start playback status to Plex');
-      }
+      const startStreamPlaybackTracking = async (positionMs) => {
+        if (streamTrackingStarted || streamClosed) {
+          return;
+        }
+        streamTrackingStarted = true;
+
+        try {
+          await syncClientPlaybackState({
+            accountId: account.id,
+            plexState,
+            clientName,
+            itemId: trackId,
+            state: 'playing',
+            positionMs,
+            durationMs: trackDurationMs,
+            request,
+          });
+        } catch (error) {
+          request.log.warn(error, 'Failed to sync stream-start playback status to Plex');
+        }
+
+        progressTimer = setInterval(async () => {
+          if (progressSyncInFlight) {
+            return;
+          }
+
+          const current = playbackSessions.get(playbackClient.sessionKey);
+          if (!current || current.itemId !== String(trackId) || current.state !== 'playing') {
+            return;
+          }
+
+          progressSyncInFlight = true;
+          try {
+            await syncClientPlaybackState({
+              accountId: account.id,
+              plexState,
+              clientName,
+              itemId: trackId,
+              state: 'playing',
+              positionMs: estimatePlaybackPositionMs(),
+              durationMs: trackDurationMs,
+              request,
+            });
+          } catch (error) {
+            request.log.warn(error, 'Failed to sync stream progress playback status to Plex');
+          } finally {
+            progressSyncInFlight = false;
+          }
+        }, STREAM_PROGRESS_HEARTBEAT_MS);
+
+        if (typeof progressTimer.unref === 'function') {
+          progressTimer.unref();
+        }
+      };
 
-      let streamClosed = false;
       const handleStreamClosed = () => {
         if (streamClosed) {
           return;
@@ -6680,6 +7170,7 @@ export async function buildServer(config = loadConfig()) {
 
         const closedAt = Date.now();
         clearProgressTimer();
+        clearSuppressedPromoteTimer();
         const estimatedAtClose = estimatePlaybackPositionMs(closedAt);
         let currentAtClose = playbackSessions.get(playbackClient.sessionKey);
         if (currentAtClose && currentAtClose.itemId === String(trackId) && currentAtClose.state === 'playing') {
@@ -6761,51 +7252,71 @@ export async function buildServer(config = loadConfig()) {
           timer.unref();
         }
       };
+      if (!streamPlaybackAuthorityDisabled) {
+        reply.raw.once('close', handleStreamClosed);
+        reply.raw.once('finish', handleStreamClosed);
+      }
 
-      reply.raw.once('close', handleStreamClosed);
-      reply.raw.once('finish', handleStreamClosed);
-
-      progressTimer = setInterval(async () => {
-        if (progressSyncInFlight) {
-          return;
-        }
+      if (suppressStreamLoadPlaybackSync) {
+        request.log.debug(
+          { trackId, clientName, streamPlaybackAuthorityDisabled },
+          'Suppressing immediate stream-start playback sync; awaiting continuity/persistence',
+        );
 
-        const current = playbackSessions.get(playbackClient.sessionKey);
-        if (!current || current.itemId !== String(trackId) || current.state !== 'playing') {
-          return;
-        }
+        suppressedPromoteTimer = setTimeout(async () => {
+          if (streamClosed || streamTrackingStarted) {
+            return;
+          }
 
-        progressSyncInFlight = true;
-        try {
-          await syncClientPlaybackState({
+          const stillSuppressed = shouldSuppressPlaybackSyncForStreamLoad({
             accountId: account.id,
-            plexState,
             clientName,
-            itemId: trackId,
-            state: 'playing',
-            positionMs: estimatePlaybackPositionMs(),
-            durationMs: trackDurationMs,
-            request,
+            trackId,
           });
-        } catch (error) {
-          request.log.warn(error, 'Failed to sync stream progress playback status to Plex');
-        } finally {
-          progressSyncInFlight = false;
-        }
-      }, STREAM_PROGRESS_HEARTBEAT_MS);
+          if (!stillSuppressed) {
+            await startStreamPlaybackTracking(estimatePlaybackPositionMs());
+            return;
+          }
 
-      if (typeof progressTimer.unref === 'function') {
-        progressTimer.unref();
+          const hasScrobbleDrivenContinuity = Number(continuityState.at || 0) > 0;
+          if (hasScrobbleDrivenContinuity) {
+            request.log.debug(
+              { trackId, clientName },
+              'Keeping suppressed stream pending explicit scrobble/queue continuity',
+            );
+            return;
+          }
+
+          // Fallback only for clients that never provide continuity signals.
+          await startStreamPlaybackTracking(estimatePlaybackPositionMs());
+        }, STREAM_SUPPRESSED_PROMOTE_DELAY_MS);
+
+        if (typeof suppressedPromoteTimer.unref === 'function') {
+          suppressedPromoteTimer.unref();
+        }
+      } else {
+        await startStreamPlaybackTracking(offsetMs);
       }
 
       const streamUrl = buildPmsAssetUrl(plexState.baseUrl, plexState.plexToken, partKey);
       const rangeHeader = request.headers.range;
+      const upstreamController = new AbortController();
+      const abortUpstreamOnDisconnect = () => {
+        if (!upstreamController.signal.aborted) {
+          upstreamController.abort();
+        }
+      };
+      request.raw.once('aborted', abortUpstreamOnDisconnect);
+      request.raw.once('close', abortUpstreamOnDisconnect);
+      reply.raw.once('close', abortUpstreamOnDisconnect);
+
       const upstream = await fetchWithRetry({
         url: streamUrl,
         options: {
           headers: {
             ...(rangeHeader ? { Range: rangeHeader } : {}),
           },
+          signal: upstreamController.signal,
         },
         request,
         context: 'track stream proxy',
@@ -6815,6 +7326,7 @@ export async function buildServer(config = loadConfig()) {
 
       if (!upstream.ok || !upstream.body) {
         clearProgressTimer();
+        clearSuppressedPromoteTimer();
         request.log.warn({ status: upstream.status }, 'Failed to proxy track stream');
         return sendSubsonicError(reply, 70, 'Track stream unavailable');
       }
@@ -6835,8 +7347,34 @@ export async function buildServer(config = loadConfig()) {
         }
       }
 
-      return reply.send(Readable.fromWeb(upstream.body));
+      const proxiedBody = Readable.fromWeb(upstream.body);
+      const responseBody = new PassThrough();
+
+      proxiedBody.on('error', (streamError) => {
+        if (isAbortError(streamError) || isUpstreamTerminationError(streamError) || isClientDisconnected(request, reply)) {
+          request.log.debug({ trackId, clientName }, 'Ignoring expected stream termination');
+          responseBody.end();
+          return;
+        }
+        request.log.warn(streamError, 'Upstream stream error while proxying track');
+        responseBody.destroy(streamError);
+      });
+
+      responseBody.on('error', (streamError) => {
+        if (isAbortError(streamError) || isUpstreamTerminationError(streamError) || isClientDisconnected(request, reply)) {
+          request.log.debug({ trackId, clientName }, 'Ignoring expected response stream termination');
+          return;
+        }
+        request.log.warn(streamError, 'Response stream error while proxying track');
+      });
+
+      proxiedBody.pipe(responseBody);
+      return reply.send(responseBody);
     } catch (error) {
+      if (isAbortError(error) || isUpstreamTerminationError(error) || isClientDisconnected(request, reply)) {
+        request.log.debug({ trackId }, 'Ignoring expected stream disconnect');
+        return;
+      }
       request.log.error(error, 'Failed to proxy stream');
       return sendSubsonicError(reply, 10, 'Stream proxy failed');
     }

package/src/subsonic-xml.js

@@ -321,6 +321,11 @@ function nodeToJson(node) {
     }
   }
 
+  const keys = Object.keys(out);
+  if (keys.length === 1 && keys[0] === 'value') {
+    return out.value;
+  }
+
   if (node.name === 'openSubsonicExtensions') {
     const extensions = out.openSubsonicExtension;
     if (Array.isArray(extensions)) {