Bump axios from 1.5.1 to 1.6.0

Bumps [axios](https://github.com/axios/axios) from 1.5.1 to 1.6.0.
- [Release notes](https://github.com/axios/axios/releases)
- [Changelog](https://github.com/axios/axios/blob/v1.x/CHANGELOG.md)
- [Commits](https://github.com/axios/axios/compare/v1.5.1...v1.6.0)

---
updated-dependencies:
- dependency-name: axios
  dependency-type: direct:production
...

Signed-off-by: dependabot[bot] <support@github.com>

.devcontainer/Dockerfile

@@ -1,4 +1,4 @@
-FROM node:20-bullseye
+FROM node:16-bullseye
 
 LABEL maintainer=simojenki
 

.devcontainer/devcontainer.json

@@ -10,18 +10,10 @@
         "BNB_DEV_SUBSONIC_URL": "${localEnv:BNB_DEV_SUBSONIC_URL}"
     },
     "remoteUser": "node",
-    "forwardPorts": [4534],
     "features": {
-        "ghcr.io/devcontainers/features/docker-in-docker:2": {
+        "ghcr.io/devcontainers/features/docker-in-docker:1": {
             "version": "latest",
             "moby": true
         }
-    },
-    "customizations": {
-        "vscode": {
-          "extensions": [
-            "esbenp.prettier-vscode"
-          ]
-        }
     }
 }

.github/workflows/ci.yml

@@ -21,11 +21,11 @@ jobs:
       -
         uses: actions/setup-node@v3
         with:
-          node-version: 20
+          node-version: '16'
       -
-        run: npm install
+        run: yarn install
       -
-        run: npm test
+        run: yarn test
 
 
   push_to_registry:

.npmrc

@@ -1 +0,0 @@
-fetch-timeout=60000

.nvmrc

@@ -0,0 +1 @@
+16.6.2

.yarnrc.yml

@@ -0,0 +1,3 @@
+nodeLinker: node-modules
+
+yarnPath: .yarn/releases/yarn-1.22.19.cjs

Dockerfile

@@ -1,4 +1,4 @@
-FROM node:20-bullseye-slim as build
+FROM node:16-bullseye-slim as build
 
 WORKDIR /bonob
 
@@ -9,11 +9,12 @@ COPY typings ./typings
 COPY web ./web
 COPY tests ./tests
 COPY jest.config.js .
-COPY register.js .
-COPY .npmrc .
-COPY tsconfig.json .
 COPY package.json .
-COPY package-lock.json .
+COPY register.js .
+COPY tsconfig.json .
+COPY yarn.lock .
+COPY .yarnrc.yml .
+COPY .yarn/releases ./.yarn/releases
 
 ENV JEST_TIMEOUT=60000
 ENV DEBIAN_FRONTEND=noninteractive
@@ -28,15 +29,24 @@ RUN apt-get update && \
         g++ && \
     apt-get clean && \
     rm -rf /var/lib/apt/lists/* && \
-    npm install && \
+    yarn config set network-timeout 600000 -g && \
-    npm test && \
+    yarn install \
-    npm run gitinfo && \
+        --prefer-offline \
-    npm run build && \
+        --frozen-lockfile \
+        --non-interactive \
+        --production=false && \
+    yarn test --no-cache && \
+    yarn gitinfo && \
+    yarn build && \
     rm -Rf node_modules && \
-    NODE_ENV=production npm install --omit=dev
+    NODE_ENV=production yarn install \
+        --prefer-offline \
+        --pure-lockfile \
+        --non-interactive \
+        --production=true
 
 
-FROM node:20-bullseye-slim
+FROM node:16-bullseye-slim
 
 LABEL   maintainer="simojenki" \
         org.opencontainers.image.source="https://github.com/simojenki/bonob" \
@@ -52,7 +62,7 @@ EXPOSE $BNB_PORT
 WORKDIR /bonob
 
 COPY package.json .
-COPY package-lock.json .
+COPY yarn.lock .
 
 COPY --from=build /bonob/build/src ./src
 COPY --from=build /bonob/node_modules ./node_modules

README.md

@@ -16,13 +16,12 @@ Support for Subsonic API clones (tested against Navidrome and Gonic).
 - Search by Album, Artist, Track
 - Playlist editing through sonos app.
 - Marking of songs as favourites and with ratings through the sonos app.
-- Localization (only en-US, da-DK & nl-NL supported currently, require translations for other languages).  [Sonos localization and supported languages](https://docs.sonos.com/docs/localization)
+- Localization (only en-US, da-DK & nl-NL supported currently, require translations for other languages).  [Sonos localization and supported languages](https://developer.sonos.com/build/content-service-add-features/strings-and-localization/)
 - Auto discovery of sonos devices
 - Discovery of sonos devices using seed IP address
 - Auto registration with sonos on start
 - Multiple registrations within a single household.
-- Transcoding within subsonic clone
+- Transcoding support for flacs using a specific player for the flac mimeType bonob/sonos
-- Custom players by mime type, allowing custom transcoding rules for different file types
 
 ## Running
 
@@ -164,6 +163,7 @@ BNB_URL | http://$(hostname):4534 | URL (including path) for bonob so that sonos
 BNB_SECRET | bonob | secret used for encrypting credentials
 BNB_AUTH_TIMEOUT | 1h | Timeout for the sonos auth token, described in the format [ms](https://github.com/vercel/ms), ie. '5s' == 5 seconds, '11h' == 11 hours.  In the case of using Navidrome this should be less than the value for ND_SESSIONTIMEOUT
 BNB_LOG_LEVEL | info | Log level. One of ['debug', 'info', 'warn', 'error']
+BNB_DISABLE_PLAYLIST_ART | undefined | Disables playlist art generation, ie. when there are many playlists and art generation takes too long
 BNB_SERVER_LOG_REQUESTS | false | Whether or not to log http requests
 BNB_SONOS_AUTO_REGISTER | false | Whether or not to try and auto-register on startup
 BNB_SONOS_DEVICE_DISCOVERY | true | Enable/Disable sonos device discovery entirely.  Setting this to 'false' will disable sonos device search, regardless of whether a seed host is specified.
@@ -171,7 +171,7 @@ BNB_SONOS_SEED_HOST | undefined | sonos device seed host for discovery, or ommit
 BNB_SONOS_SERVICE_NAME | bonob | service name for sonos
 BNB_SONOS_SERVICE_ID | 246 | service id for sonos
 BNB_SUBSONIC_URL | http://$(hostname):4533 | URL for subsonic clone
-BNB_SUBSONIC_CUSTOM_CLIENTS | undefined | Comma delimeted mime types for custom subsonic clients when streaming. Must specify by the source mime type and the transcoded mime type. For example; <p>If you want to simply re-encode some flacs, then you could specify just "audio/flac".  <p>However; if your subsonic server will transcode the track then you need to specify the resulting mime type, ie. "audio/flac>audio/mp3" <p>If you want to specify many something like; "audio/flac>audio/mp3,audio/ogg" would use client = 'bonob+audio/flac' for flacs, and 'bonob+audio/ogg' for oggs.  <p>!!! Getting this configuration wrong will confuse SONOS as it will expect the wrong mime type for a track, as a result it will not play. Use with care...
+BNB_SUBSONIC_CUSTOM_CLIENTS | undefined | Comma delimeted mime types for custom subsonic clients when streaming. ie. "audio/flac,audio/ogg" would use client = 'bonob+audio/flac' for flacs, and 'bonob+audio/ogg' for oggs.
 BNB_SUBSONIC_ARTIST_IMAGE_CACHE | undefined | Path for caching of artist images that are sourced externally. ie. Navidrome provides spotify URLs. Remember to provide a volume-mapping for Docker, when enabling this cache.
 BNB_SCROBBLE_TRACKS | true | Whether to scrobble the playing of a track if it has been played for >30s
 BNB_REPORT_NOW_PLAYING | true | Whether to report a track as now playing
@@ -218,9 +218,15 @@ Afterwards the Sonos app displays a dropdown underneath the service, allowing to
 - Implement the MusicService/MusicLibrary interface
 - Startup bonob with your new implementation.
 
+## A note on transcoding
+
+tldr; Transcoding to mp3/m4a is not supported as sonos devices will not play the track.  However transcoding to flac does work, use BNB_SUBSONIC_CUSTOM_CLIENTS=audio/flac if you want to transcode flac->flac ie. to downsample HD flacs (see below).
+
+Sonos devices are very particular about how audio streams are presented to them, see [streaming basics](https://developer.sonos.com/build/content-service-add-features/streaming-basics/).  When using transcoding both Navidrome and Gonic report no 'content-length', nor do they support range queries, this will cause the sonos device to fail to play the track.
+
 ### Audio File type specific transcoding options within Subsonic
 
-In some situations you may wish to have different 'Players' within you Subsonic server so that you can configure different transcoding options depending on the file type.  For example if you have flacs with a mixture of frequency formats where not all are supported by sonos [See issue #52](https://github.com/simojenki/bonob/issues/52) & [Sonos supported audio formats](https://docs.sonos.com/docs/supported-audio-formats)
+In some situations you may wish to have different 'Players' within you Subsonic server so that you can configure different transcoding options depending on the file type.  For example if you have flacs with a mixture of frequency formats where not all are supported by sonos [See issue #52](https://github.com/simojenki/bonob/issues/52) & [Sonos supported audio formats](https://developer.sonos.com/build/content-service-add-features/supported-audio-formats/)
 
 In this case you could set;
 

package.json

@@ -7,32 +7,32 @@
   "license": "GPL-3.0-only",
   "dependencies": {
     "@svrooij/sonos": "^2.5.0",
-    "@types/express": "^4.17.21",
+    "@types/express": "^4.17.19",
-    "@types/fs-extra": "^11.0.4",
+    "@types/fs-extra": "^11.0.2",
-    "@types/jsonwebtoken": "^9.0.5",
+    "@types/jsonwebtoken": "^9.0.3",
-    "@types/jws": "^3.2.9",
+    "@types/jws": "^3.2.6",
-    "@types/morgan": "^1.9.9",
+    "@types/morgan": "^1.9.6",
-    "@types/node": "^20.11.5",
+    "@types/node": "^16.11.7",
-    "@types/randomstring": "^1.1.11",
+    "@types/randomstring": "^1.1.9",
-    "@types/underscore": "^1.11.15",
+    "@types/underscore": "^1.11.11",
-    "@types/uuid": "^9.0.7",
+    "@types/uuid": "^9.0.5",
-    "@types/xmldom": "0.1.34",
+    "@types/xmldom": "0.1.32",
-    "axios": "^1.6.5",
+    "axios": "^1.6.0",
     "dayjs": "^1.11.10",
-    "eta": "^2.2.0",
+    "eta": "^2.0.1",
     "express": "^4.18.2",
-    "fp-ts": "^2.16.2",
+    "fp-ts": "^2.16.1",
-    "fs-extra": "^11.2.0",
+    "fs-extra": "^11.1.1",
     "jsonwebtoken": "^9.0.2",
     "jws": "^4.0.0",
-    "libxmljs2": "^0.33.0",
+    "libxmljs2": "^0.32.0",
     "morgan": "^1.10.0",
-    "node-html-parser": "^6.1.12",
+    "node-html-parser": "^6.1.10",
     "randomstring": "^1.3.0",
-    "sharp": "^0.33.2",
+    "sharp": "^0.32.6",
     "soap": "^1.0.0",
     "ts-md5": "^1.3.1",
-    "typescript": "^5.3.3",
+    "typescript": "^5.2.2",
     "underscore": "^1.13.6",
     "urn-lib": "^2.0.0",
     "uuid": "^9.0.1",
@@ -40,39 +40,32 @@
     "xmldom-ts": "^0.3.1"
   },
   "devDependencies": {
-    "@types/chai": "^4.3.11",
+    "@types/chai": "^4.3.7",
-    "@types/jest": "^29.5.11",
+    "@types/jest": "^29.5.5",
-    "@types/mocha": "^10.0.6",
+    "@types/mocha": "^10.0.2",
-    "@types/supertest": "^6.0.2",
+    "@types/supertest": "^2.0.14",
-    "@types/tmp": "^0.2.6",
+    "@types/tmp": "^0.2.4",
-    "chai": "^5.0.0",
+    "chai": "^4.3.10",
     "get-port": "^7.0.0",
-    "image-js": "^0.35.5",
+    "image-js": "^0.35.4",
     "jest": "^29.7.0",
-    "nodemon": "^3.0.3",
+    "nodemon": "^3.0.1",
-    "supertest": "^6.3.4",
+    "supertest": "^6.3.3",
     "tmp": "^0.2.1",
-    "ts-jest": "^29.1.2",
+    "ts-jest": "^29.1.1",
     "ts-mockito": "^2.6.1",
-    "ts-node": "^10.9.2",
+    "ts-node": "^10.9.1",
     "xmldom-ts": "^0.3.1",
     "xpath-ts": "^1.3.13"
   },
-  "overrides": {
-    "axios-ntlm": "npm:dry-uninstall",
-    "axios": "$axios",
-    "@svrooij/sonos": {
-      "fast-xml-parser": "^3.21.1"
-    }
-  },
   "scripts": {
     "clean": "rm -Rf build node_modules",
     "build": "tsc",
-    "dev": "BNB_SUBSONIC_CUSTOM_CLIENTS1=audio/flac,audio/mpeg,audio/mp4\\>audio/flac BNB_LOG_LEVEL=debug BNB_DEBUG=true BNB_SCROBBLE_TRACKS=false BNB_REPORT_NOW_PLAYING=false BNB_SONOS_SEED_HOST=$BNB_DEV_SONOS_DEVICE_IP BNB_SONOS_SERVICE_NAME=z_bonobDev BNB_URL=\"http://${BNB_DEV_HOST_IP}:4534\" BNB_SUBSONIC_URL=\"${BNB_DEV_SUBSONIC_URL}\" nodemon -V ./src/app.ts",
+    "dev": "BNB_LOG_LEVEL=debug BNB_DEBUG=true BNB_SCROBBLE_TRACKS=false BNB_REPORT_NOW_PLAYING=false BNB_SONOS_SEED_HOST=$BNB_DEV_SONOS_DEVICE_IP BNB_SONOS_SERVICE_NAME=z_bonobDev BNB_URL=\"http://${BNB_DEV_HOST_IP}:4534\" BNB_SUBSONIC_URL=\"${BNB_DEV_SUBSONIC_URL}\" nodemon -V ./src/app.ts",
-    "devr": "BNB_LOG_LEVEL=debug BNB_DEBUG=true BNB_SCROBBLE_TRACKS=false BNB_REPORT_NOW_PLAYING=false BNB_SONOS_SEED_HOST=$BNB_DEV_SONOS_DEVICE_IP BNB_SONOS_SERVICE_NAME=z_bonobDev BNB_SONOS_DEVICE_DISCOVERY=true BNB_SONOS_AUTO_REGISTER=true BNB_URL=\"http://${BNB_DEV_HOST_IP}:4534\" BNB_SUBSONIC_URL=\"${BNB_DEV_SUBSONIC_URL}\" nodemon -V ./src/app.ts",
+    "devr": "BNB_DISABLE_PLAYLIST_ART=true BNB_LOG_LEVEL=debug BNB_DEBUG=true BNB_SCROBBLE_TRACKS=false BNB_REPORT_NOW_PLAYING=false BNB_ICON_FOREGROUND_COLOR=white BNB_ICON_BACKGROUND_COLOR=darkgrey BNB_SONOS_SEED_HOST=$BNB_DEV_SONOS_DEVICE_IP BNB_SONOS_SERVICE_NAME=z_bonobDev BNB_SONOS_DEVICE_DISCOVERY=true BNB_SONOS_AUTO_REGISTER=true BNB_URL=\"http://${BNB_DEV_HOST_IP}:4534\" BNB_SUBSONIC_URL=\"${BNB_DEV_SUBSONIC_URL}\" nodemon -V ./src/app.ts",
     "register-dev": "ts-node ./src/register.ts http://${BNB_DEV_HOST_IP}:4534",
     "test": "jest",
-    "testw": "jest --watch",
     "gitinfo": "git describe --tags > .gitinfo"
-  }
+  },
+  "packageManager": "yarn@1.22.19"
 }

src/app.ts

@@ -4,11 +4,11 @@ import server from "./server";
 import logger from "./logger";
 
 import {
+  appendMimeTypeToClientFor,
   axiosImageFetcher,
   cachingImageFetcher,
+  DEFAULT,
   Subsonic,
-  TranscodingCustomPlayers,
-  NO_CUSTOM_PLAYERS
 } from "./subsonic";
 import { InMemoryAPITokens, sha256 } from "./api_tokens";
 import { InMemoryLinkCodes } from "./link_codes";
@@ -32,9 +32,9 @@ const bonob = bonobService(
 
 const sonosSystem = sonos(config.sonos.discovery);
 
-const customPlayers = config.subsonic.customClientsFor
+const streamUserAgent = config.subsonic.customClientsFor
-  ? TranscodingCustomPlayers.from(config.subsonic.customClientsFor)
+  ? appendMimeTypeToClientFor(config.subsonic.customClientsFor.split(","))
-  : NO_CUSTOM_PLAYERS;
+  : DEFAULT;
 
 const artistImageFetcher = config.subsonic.artistImageCache
   ? cachingImageFetcher(config.subsonic.artistImageCache, axiosImageFetcher)
@@ -42,7 +42,7 @@ const artistImageFetcher = config.subsonic.artistImageCache
 
 const subsonic = new Subsonic(
   config.subsonic.url,
-  customPlayers,
+  streamUserAgent,
   artistImageFetcher
 );
 

src/music_service.ts

@@ -51,15 +51,10 @@ export type Rating = {
   stars: number;
 }
 
-export type Encoding = {
-  player: string,
-  mimeType: string
-}
-
 export type Track = {
   id: string;
   name: string;
-  encoding: Encoding,
+  mimeType: string;
   duration: number;
   number: number | undefined;
   genre: Genre | undefined;
@@ -118,8 +113,7 @@ export const albumToAlbumSummary = (it: Album): AlbumSummary => ({
 
 export const playlistToPlaylistSummary = (it: Playlist): PlaylistSummary => ({
   id: it.id,
-  name: it.name,
+  name: it.name
-  coverArt: it.coverArt
 })
 
 export type StreamingHeader = "content-type" | "content-length" | "content-range" | "accept-ranges";
@@ -137,8 +131,7 @@ export type CoverArt = {
 
 export type PlaylistSummary = {
   id: string,
-  name: string,
+  name: string
-  coverArt?: BUrn | undefined
 }
 
 export type Playlist = PlaylistSummary & {

src/server.ts

@@ -31,8 +31,9 @@ import { pipe } from "fp-ts/lib/function";
 import { URLBuilder } from "./url_builder";
 import makeI8N, { asLANGs, KEY, keys as i8nKeys, LANG } from "./i8n";
 import { Icon, ICONS, festivals, features } from "./icon";
-import _ from "underscore";
+import _, { shuffle } from "underscore";
 import morgan from "morgan";
+import { takeWithRepeats } from "./utils";
 import { parse } from "./burn";
 import { axiosImageFetcher, ImageFetcher } from "./subsonic";
 import {
@@ -557,11 +558,23 @@ function server(
     });
   });
 
-  app.get("/art/:burn/size/:size", (req, res) => {
+  const GRAVITY_9 = [
+    "north",
+    "northeast",
+    "east",
+    "southeast",
+    "south",
+    "southwest",
+    "west",
+    "northwest",
+    "centre",
+  ];
+
+  app.get("/art/:burns/size/:size", (req, res) => {
     const serviceToken = apiTokens.authTokenFor(
       req.query[BONOB_ACCESS_TOKEN_HEADER] as string
     );
-    const urn = parse(req.params["burn"]!);
+    const urns = req.params["burns"]!.split("&").map(parse);
     const size = Number.parseInt(req.params["size"]!);
 
     if (!serviceToken) {
@@ -572,24 +585,55 @@ function server(
 
     return musicService
       .login(serviceToken)
-      .then((musicLibrary) => {
+      .then((musicLibrary) =>
-        if (urn.system == "external") {
+        Promise.all(
-          return serverOpts.externalImageResolver(urn.resource);
+          urns.map((it) => {
+            if (it.system == "external") {
+              return serverOpts.externalImageResolver(it.resource);
             } else {
-          return musicLibrary.coverArt(urn, size);
+              return musicLibrary.coverArt(it, size);
             }
           })
-      .then((coverArt) => {
+        )
-        if(coverArt) {
+      )
+      .then((coverArts) => coverArts.filter((it) => it))
+      .then(shuffle)
+      .then((coverArts) => {
+        if (coverArts.length == 1) {
+          const coverArt = coverArts[0]!;
           res.status(200);
           res.setHeader("content-type", coverArt.contentType);
           return res.send(coverArt.data);
+        } else if (coverArts.length > 1) {
+          const gravity = [...GRAVITY_9];
+          return sharp({
+            create: {
+              width: size * 3,
+              height: size * 3,
+              channels: 3,
+              background: { r: 255, g: 255, b: 255 },
+            },
+          })
+            .composite(
+              takeWithRepeats(coverArts, 9).map((art) => ({
+                input: art?.data,
+                gravity: gravity.pop(),
+              }))
+            )
+            .png()
+            .toBuffer()
+            .then((image) => sharp(image).resize(size).png().toBuffer())
+            .then((image) => {
+              res.status(200);
+              res.setHeader("content-type", "image/png");
+              return res.send(image);
+            });
         } else {
           return res.status(404).send();
         }
       })
       .catch((e: Error) => {
-        logger.error(`Failed fetching image ${urn}/size/${size}`, {
+        logger.error(`Failed fetching image ${urns.join("&")}/size/${size}`, {
           cause: e,
         });
         return res.status(500).send();

src/smapi.ts

@@ -26,7 +26,7 @@ import { Clock } from "./clock";
 import { URLBuilder } from "./url_builder";
 import { asLANGs, I8N } from "./i8n";
 import { ICON, iconForGenre } from "./icon";
-import _ from "underscore";
+import _, { uniq } from "underscore";
 import { BUrn, formatForURL } from "./burn";
 import {
   isExpiredTokenError,
@@ -253,7 +253,7 @@ const playlist = (bonobUrl: URLBuilder, playlist: Playlist) => ({
   itemType: "playlist",
   id: `playlist:${playlist.id}`,
   title: playlist.name,
-  albumArtURI: coverArtURI(bonobUrl, playlist).href(),
+  albumArtURI: playlistAlbumArtURL(bonobUrl, playlist).href(),
   canPlay: true,
   attributes: {
     readOnly: false,
@@ -262,9 +262,32 @@ const playlist = (bonobUrl: URLBuilder, playlist: Playlist) => ({
   },
 });
 
-export const coverArtURI = (
+export const playlistAlbumArtURL = (
   bonobUrl: URLBuilder,
-  { coverArt }: { coverArt?: BUrn | undefined }
+  playlist: Playlist
+) => {
+  // todo: this should be put into config, or even just removed for the ND music source
+  if(process.env["BNB_DISABLE_PLAYLIST_ART"]) return iconArtURI(bonobUrl, "music");
+
+  const burns: BUrn[] = uniq(
+    playlist.entries.filter((it) => it.coverArt != undefined),
+    (it) => it.album.id
+  ).map((it) => it.coverArt!);
+  if (burns.length == 0) {
+    return iconArtURI(bonobUrl, "error");
+  } else {
+    return bonobUrl.append({
+      pathname: `/art/${burns
+        .slice(0, 9)
+        .map((it) => encodeURIComponent(formatForURL(it)))
+        .join("&")}/size/180`,
+    });
+  }
+};
+
+export const defaultAlbumArtURI = (
+  bonobUrl: URLBuilder,
+  { coverArt }: { coverArt: BUrn | undefined }
 ) =>
   pipe(
     coverArt,
@@ -282,6 +305,21 @@ export const iconArtURI = (bonobUrl: URLBuilder, icon: ICON) =>
     pathname: `/icon/${icon}/size/legacy`,
   });
 
+export const defaultArtistArtURI = (
+  bonobUrl: URLBuilder,
+  artist: ArtistSummary
+) =>
+  pipe(
+    artist.image,
+    O.fromNullable,
+    O.map((it) =>
+      bonobUrl.append({
+        pathname: `/art/${encodeURIComponent(formatForURL(it))}/size/180`,
+      })
+    ),
+    O.getOrElseW(() => iconArtURI(bonobUrl, "vinyl"))
+  );
+
 export const sonosifyMimeType = (mimeType: string) =>
   mimeType == "audio/x-flac" ? "audio/flac" : mimeType;
 
@@ -291,7 +329,7 @@ export const album = (bonobUrl: URLBuilder, album: AlbumSummary) => ({
   artist: album.artistName,
   artistId: `artist:${album.artistId}`,
   title: album.name,
-  albumArtURI: coverArtURI(bonobUrl, album).href(),
+  albumArtURI: defaultAlbumArtURI(bonobUrl, album).href(),
   canPlay: true,
   // defaults
   // canScroll: false,
@@ -302,7 +340,7 @@ export const album = (bonobUrl: URLBuilder, album: AlbumSummary) => ({
 export const track = (bonobUrl: URLBuilder, track: Track) => ({
   itemType: "track",
   id: `track:${track.id}`,
-  mimeType: sonosifyMimeType(track.encoding.mimeType),
+  mimeType: sonosifyMimeType(track.mimeType),
   title: track.name,
 
   trackMetadata: {
@@ -310,7 +348,7 @@ export const track = (bonobUrl: URLBuilder, track: Track) => ({
     albumId: `album:${track.album.id}`,
     albumArtist: track.artist.name,
     albumArtistId: track.artist.id ? `artist:${track.artist.id}` : undefined,
-    albumArtURI: coverArtURI(bonobUrl, track).href(),
+    albumArtURI: defaultAlbumArtURI(bonobUrl, track).href(),
     artist: track.artist.name,
     artistId: track.artist.id ? `artist:${track.artist.id}` : undefined,
     duration: track.duration,
@@ -328,7 +366,7 @@ export const artist = (bonobUrl: URLBuilder, artist: ArtistSummary) => ({
   id: `artist:${artist.id}`,
   artistId: artist.id,
   title: artist.name,
-  albumArtURI: coverArtURI(bonobUrl, { coverArt: artist.image }).href(),
+  albumArtURI: defaultArtistArtURI(bonobUrl, artist).href(),
 });
 
 function splitId<T>(id: string) {
@@ -834,12 +872,9 @@ function bindSmapiSoapServiceToExpress(
                       .then((it) =>
                         Promise.all(
                           it.map((playlist) => {
-                            // todo: whats this odd copy all about, can we just delete it?
                             return {
                               id: playlist.id,
                               name: playlist.name,
-                              coverArt: playlist.coverArt,
-                              // todo: are these every important?
                               entries: []
                             };
                            }

src/sonos.ts

@@ -176,7 +176,7 @@ export function autoDiscoverySonos(sonosSeedHost?: string): Sonos {
         }
       })
       .catch((e) => {
-        logger.error(`Failed looking for sonos devices - ${e}`, { cause: e });
+        logger.error(`Failed looking for sonos devices`, { cause: e });
         return [];
       });
   };

src/subsonic.ts

@@ -20,8 +20,6 @@ import {
   AlbumQueryType,
   Artist,
   AuthFailure,
-  PlaylistSummary,
-  Encoding,
 } from "./music_service";
 import sharp from "sharp";
 import _ from "underscore";
@@ -164,8 +162,7 @@ export type song = {
   duration: number | undefined;
   bitRate: number | undefined;
   suffix: string | undefined;
-  contentType: string;
+  contentType: string | undefined;
-  transcodedContentType: string | undefined;
   type: string | undefined;
   userRating: number | undefined;
   starred: string | undefined;
@@ -180,15 +177,12 @@ type GetAlbumResponse = {
 type playlist = {
   id: string;
   name: string;
-  coverArt: string | undefined;
 };
 
 type GetPlaylistResponse = {
-  // todo: isnt the type here a composite? playlistSummary && { entry: song[]; }
   playlist: {
     id: string;
     name: string;
-    coverArt: string | undefined;
     entry: song[];
   };
 };
@@ -276,16 +270,10 @@ export const artistImageURN = (
   }
 };
 
-export const asTrack = (album: Album, song: song, customPlayers: CustomPlayers): Track => ({
+export const asTrack = (album: Album, song: song): Track => ({
   id: song.id,
   name: song.title,
-  encoding: pipe(
+  mimeType: song.contentType!,
-    customPlayers.encodingFor({ mimeType: song.contentType }),
-    O.getOrElse(() => ({ 
-      player: DEFAULT_CLIENT_APPLICATION, 
-      mimeType: song.transcodedContentType ? song.transcodedContentType : song.contentType
-    }))
-  ),
   duration: song.duration || 0,
   number: song.track || 0,
   genre: maybeAsGenre(song.genre),
@@ -317,13 +305,6 @@ const asAlbum = (album: album): Album => ({
   coverArt: coverArtURN(album.coverArt),
 });
 
-// coverArtURN
-const asPlayListSummary = (playlist: playlist): PlaylistSummary => ({
-  id: playlist.id,
-  name: playlist.name,
-  coverArt: coverArtURN(playlist.coverArt),
-});
-
 export const asGenre = (genreName: string) => ({
   id: b64Encode(genreName),
   name: genreName,
@@ -337,53 +318,19 @@ const maybeAsGenre = (genreName: string | undefined): Genre | undefined =>
     O.getOrElseW(() => undefined)
   );
 
-export interface CustomPlayers {
+export type StreamClientApplication = (track: Track) => string;
-  encodingFor({ mimeType }: { mimeType: string }): O.Option<Encoding>
-}
-
-export type CustomClient = {
-  mimeType: string;
-  transcodedMimeType: string;
-};
-
-export class TranscodingCustomPlayers implements CustomPlayers {
-  transcodings: Map<string, string>;
-
-  constructor(transcodings: Map<string, string>) {
-    this.transcodings = transcodings;
-  }
-
-  static from(config: string): TranscodingCustomPlayers {
-    const parts: [string, string][] = config
-      .split(",")
-      .map((it) => it.split(">"))
-      .map((pair) => {
-        if (pair.length == 1) return [pair[0]!, pair[0]!];
-        else if (pair.length == 2) return [pair[0]!, pair[1]!];
-        else throw new Error(`Invalid configuration item ${config}`);
-      });
-    return new TranscodingCustomPlayers(new Map(parts));
-  }
-
-  encodingFor = ({ mimeType }: { mimeType: string }): O.Option<Encoding> => pipe(
-    this.transcodings.get(mimeType),
-    O.fromNullable,
-    O.map(transcodedMimeType => ({ 
-      player:`${DEFAULT_CLIENT_APPLICATION}+${mimeType}`, 
-      mimeType: transcodedMimeType
-    }))
-  )
-}
-
-export const NO_CUSTOM_PLAYERS: CustomPlayers = {
-  encodingFor(_) {
-    return O.none
-  },
-}
 
 const DEFAULT_CLIENT_APPLICATION = "bonob";
 const USER_AGENT = "bonob";
 
+export const DEFAULT: StreamClientApplication = (_: Track) =>
+  DEFAULT_CLIENT_APPLICATION;
+
+export function appendMimeTypeToClientFor(mimeTypes: string[]) {
+  return (track: Track) =>
+    mimeTypes.includes(track.mimeType) ? `bonob+${track.mimeType}` : "bonob";
+}
+
 export const asURLSearchParams = (q: any) => {
   const urlSearchParams = new URLSearchParams();
   Object.keys(q).forEach((k) => {
@@ -467,16 +414,16 @@ interface SubsonicMusicLibrary extends MusicLibrary {
 
 export class Subsonic implements MusicService {
   url: URLBuilder;
-  customPlayers: CustomPlayers;
+  streamClientApplication: StreamClientApplication;
   externalImageFetcher: ImageFetcher;
 
   constructor(
     url: URLBuilder,
-    customPlayers: CustomPlayers = NO_CUSTOM_PLAYERS,
+    streamClientApplication: StreamClientApplication = DEFAULT,
     externalImageFetcher: ImageFetcher = axiosImageFetcher
   ) {
     this.url = url;
-    this.customPlayers = customPlayers;
+    this.streamClientApplication = streamClientApplication;
     this.externalImageFetcher = externalImageFetcher;
   }
 
@@ -671,7 +618,7 @@ export class Subsonic implements MusicService {
       .then((it) => it.song)
       .then((song) =>
         this.getAlbum(credentials, song.albumId!).then((album) =>
-          asTrack(album, song, this.customPlayers)
+          asTrack(album, song)
         )
       );
 
@@ -774,7 +721,7 @@ export class Subsonic implements MusicService {
           })
           .then((it) => it.album)
           .then((album) =>
-            (album.song || []).map((song) => asTrack(asAlbum(album), song, this.customPlayers))
+            (album.song || []).map((song) => asTrack(asAlbum(album), song))
           ),
       track: (trackId: string) => subsonic.getTrack(credentials, trackId),
       rate: (trackId: string, rating: Rating) =>
@@ -825,7 +772,7 @@ export class Subsonic implements MusicService {
               `/rest/stream`,
               {
                 id: trackId,
-                c: track.encoding.player,
+                c: this.streamClientApplication(track),
               },
               {
                 headers: pipe(
@@ -842,15 +789,15 @@ export class Subsonic implements MusicService {
                 responseType: "stream",
               }
             )
-            .then((stream) => ({
+            .then((res) => ({
-              status: stream.status,
+              status: res.status,
               headers: {
-                "content-type": stream.headers["content-type"],
+                "content-type": res.headers["content-type"],
-                "content-length": stream.headers["content-length"],
+                "content-length": res.headers["content-length"],
-                "content-range": stream.headers["content-range"],
+                "content-range": res.headers["content-range"],
-                "accept-ranges": stream.headers["accept-ranges"],
+                "accept-ranges": res.headers["accept-ranges"],
               },
-              stream: stream.data,
+              stream: res.data,
             }))
         ),
       coverArt: async (coverArtURN: BUrn, size?: number) =>
@@ -913,7 +860,9 @@ export class Subsonic implements MusicService {
         subsonic
           .getJSON<GetPlaylistsResponse>(credentials, "/rest/getPlaylists")
           .then((it) => it.playlists.playlist || [])
-          .then((playlists) => playlists.map(asPlayListSummary)),
+          .then((playlists) =>
+            playlists.map((it) => ({ id: it.id, name: it.name }))
+          ),
       playlist: async (id: string) =>
         subsonic
           .getJSON<GetPlaylistResponse>(credentials, "/rest/getPlaylist", {
@@ -925,7 +874,6 @@ export class Subsonic implements MusicService {
             return {
               id: playlist.id,
               name: playlist.name,
-              coverArt: coverArtURN(playlist.coverArt),
               entries: (playlist.entry || []).map((entry) => ({
                 ...asTrack(
                   {
@@ -937,8 +885,7 @@ export class Subsonic implements MusicService {
                     artistId: entry.artistId,
                     coverArt: coverArtURN(entry.coverArt),
                   },
-                  entry,
+                  entry
-                  this.customPlayers
                 ),
                 number: trackNumber++,
               })),
@@ -950,12 +897,7 @@ export class Subsonic implements MusicService {
             name,
           })
           .then((it) => it.playlist)
-          // todo: why is this line so similar to other playlist lines??
+          .then((it) => ({ id: it.id, name: it.name })),
-          .then((it) => ({
-            id: it.id,
-            name: it.name,
-            coverArt: coverArtURN(it.coverArt),
-          })),
       deletePlaylist: async (id: string) =>
         subsonic
           .getJSON<GetPlaylistResponse>(credentials, "/rest/deletePlaylist", {
@@ -989,7 +931,7 @@ export class Subsonic implements MusicService {
               songs.map((song) =>
                 subsonic
                   .getAlbum(credentials, song.albumId!)
-                  .then((album) => asTrack(album, song, this.customPlayers))
+                  .then((album) => asTrack(album, song))
               )
             )
           ),
@@ -1006,7 +948,7 @@ export class Subsonic implements MusicService {
                 songs.map((song) =>
                   subsonic
                     .getAlbum(credentials, song.albumId!)
-                    .then((album) => asTrack(album, song, this.customPlayers))
+                    .then((album) => asTrack(album, song))
                 )
               )
             )
@@ -1023,7 +965,7 @@ export class Subsonic implements MusicService {
             TE.tryCatch(
               () =>
                 axios.post(
-                  this.url.append({ pathname: "/auth/login" }).href(),
+                  this.url.append({ pathname: '/auth/login' }).href(),
                   _.pick(credentials, "username", "password")
                 ),
               () => new AuthFailure("Failed to get bearerToken")

tests/builders.ts

@@ -173,10 +173,7 @@ export function aTrack(fields: Partial<Track> = {}): Track {
   return {
     id,
     name: `Track ${id}`,
-    encoding: {
+    mimeType: `audio/mp3-${id}`,
-      player: "bonob",
-      mimeType: `audio/mp3-${id}`
-    },
     duration: randomInt(500),
     number: randomInt(100),
     genre,

tests/server.test.ts

@@ -2,7 +2,9 @@ import { v4 as uuid } from "uuid";
 import dayjs from "dayjs";
 import request from "supertest";
 import Image from "image-js";
+import fs from "fs";
 import { either as E, taskEither as TE } from "fp-ts";
+import path from "path";
 
 import { AuthFailure, MusicService } from "../src/music_service";
 import makeServer, {
@@ -1321,6 +1323,279 @@ describe("server", () => {
               });
             });
 
+            describe("fetching multiple images as a collage", () => {
+              const png = fs.readFileSync(
+                path.join(
+                  __dirname,
+                  "..",
+                  "docs",
+                  "images",
+                  "chartreuseFuchsia.png"
+                )
+              );
+
+              describe("fetching a collage of 4 when all are available", () => {
+                it("should return the image and a 200", async () => {
+                  const urns = [
+                    "art:1",
+                    "art:2",
+                    "art:3",
+                    "art:4",
+                  ].map(resource => ({ system:"subsonic", resource }));
+
+                  musicService.login.mockResolvedValue(musicLibrary);
+
+                  urns.forEach((_) => {
+                    musicLibrary.coverArt.mockResolvedValueOnce(
+                      coverArtResponse({
+                        data: png,
+                      })
+                    );
+                  });
+
+                  const res = await request(server)
+                    .get(
+                      `/art/${urns.map(it => encodeURIComponent(formatForURL(it))).join(
+                        "&"
+                      )}/size/200?${BONOB_ACCESS_TOKEN_HEADER}=${apiToken}`
+                    )
+                    .set(BONOB_ACCESS_TOKEN_HEADER, apiToken);
+
+                  expect(res.status).toEqual(200);
+                  expect(res.header["content-type"]).toEqual("image/png");
+
+                  expect(musicService.login).toHaveBeenCalledWith(serviceToken);
+                  urns.forEach((it) => {
+                    expect(musicLibrary.coverArt).toHaveBeenCalledWith(it, 200);
+                  });
+
+                  const image = await Image.load(res.body);
+                  expect(image.width).toEqual(200);
+                  expect(image.height).toEqual(200);
+                });
+              });
+
+              describe("fetching a collage of 4, however only 1 is available", () => {
+                it("should return the single image", async () => {
+                  const urns = ["art:1", "art:2", "art:3", "art:4"].map(resource => ({ system:"subsonic", resource }));
+
+                  musicService.login.mockResolvedValue(musicLibrary);
+
+                  musicLibrary.coverArt.mockResolvedValueOnce(undefined);
+                  musicLibrary.coverArt.mockResolvedValueOnce(undefined);
+                  musicLibrary.coverArt.mockResolvedValueOnce(undefined);
+                  musicLibrary.coverArt.mockResolvedValueOnce(
+                    coverArtResponse({
+                      data: png,
+                      contentType: "image/some-mime-type",
+                    })
+                  );
+
+                  const res = await request(server)
+                    .get(
+                      `/art/${urns.map(it => encodeURIComponent(formatForURL(it))).join(
+                        "&"
+                      )}/size/200?${BONOB_ACCESS_TOKEN_HEADER}=${apiToken}`
+                    )
+                    .set(BONOB_ACCESS_TOKEN_HEADER, apiToken);
+
+                  expect(res.status).toEqual(200);
+                  expect(res.header["content-type"]).toEqual(
+                    "image/some-mime-type"
+                  );
+                });
+              });
+
+              describe("fetching a collage of 4 and all are missing", () => {
+                it("should return a 404", async () => {
+                  const urns = ["art:1", "art:2", "art:3", "art:4"].map(resource => ({ system:"subsonic", resource }));
+
+                  musicService.login.mockResolvedValue(musicLibrary);
+
+                  urns.forEach((_) => {
+                    musicLibrary.coverArt.mockResolvedValueOnce(undefined);
+                  });
+
+                  const res = await request(server)
+                    .get(
+                      `/art/${urns.map(it => encodeURIComponent(formatForURL(it))).join(
+                        "&"
+                      )}/size/200?${BONOB_ACCESS_TOKEN_HEADER}=${apiToken}`
+                    )
+                    .set(BONOB_ACCESS_TOKEN_HEADER, apiToken);
+
+                  expect(res.status).toEqual(404);
+                });
+              });
+
+              describe("fetching a collage of 9 when all are available", () => {
+                it("should return the image and a 200", async () => {
+                  const urns = [
+                    "artist:1",
+                    "artist:2",
+                    "coverArt:3",
+                    "artist:4",
+                    "artist:5",
+                    "artist:6",
+                    "artist:7",
+                    "artist:8",
+                    "artist:9",
+                  ].map(resource => ({ system:"subsonic", resource }));
+
+                  musicService.login.mockResolvedValue(musicLibrary);
+
+                  urns.forEach((_) => {
+                    musicLibrary.coverArt.mockResolvedValueOnce(
+                      coverArtResponse({
+                        data: png,
+                      })
+                    );
+                  });
+
+                  const res = await request(server)
+                    .get(
+                      `/art/${urns.map(it => encodeURIComponent(formatForURL(it))).join(
+                        "&"
+                      )}/size/180?${BONOB_ACCESS_TOKEN_HEADER}=${apiToken}`
+                    )
+                    .set(BONOB_ACCESS_TOKEN_HEADER, apiToken);
+
+                  expect(res.status).toEqual(200);
+                  expect(res.header["content-type"]).toEqual("image/png");
+
+                  expect(musicService.login).toHaveBeenCalledWith(serviceToken);
+                  urns.forEach((it) => {
+                    expect(musicLibrary.coverArt).toHaveBeenCalledWith(it, 180);
+                  });
+
+                  const image = await Image.load(res.body);
+                  expect(image.width).toEqual(180);
+                  expect(image.height).toEqual(180);
+                });
+              });
+
+              describe("fetching a collage of 9 when only 2 are available", () => {
+                it("should still return an image and a 200", async () => {
+                  const urns = [
+                    "artist:1",
+                    "artist:2",
+                    "artist:3",
+                    "artist:4",
+                    "artist:5",
+                    "artist:6",
+                    "artist:7",
+                    "artist:8",
+                    "artist:9",
+                  ].map(resource => ({ system:"subsonic", resource }));
+
+                  musicService.login.mockResolvedValue(musicLibrary);
+
+                  musicLibrary.coverArt.mockResolvedValueOnce(
+                    coverArtResponse({
+                      data: png,
+                    })
+                  );
+                  musicLibrary.coverArt.mockResolvedValueOnce(
+                    coverArtResponse({
+                      data: png,
+                    })
+                  );
+                  musicLibrary.coverArt.mockResolvedValueOnce(undefined);
+                  musicLibrary.coverArt.mockResolvedValueOnce(undefined);
+                  musicLibrary.coverArt.mockResolvedValueOnce(undefined);
+                  musicLibrary.coverArt.mockResolvedValueOnce(undefined);
+                  musicLibrary.coverArt.mockResolvedValueOnce(undefined);
+                  musicLibrary.coverArt.mockResolvedValueOnce(undefined);
+                  musicLibrary.coverArt.mockResolvedValueOnce(undefined);
+
+                  const res = await request(server)
+                    .get(
+                      `/art/${urns.map(it => encodeURIComponent(formatForURL(it))).join(
+                        "&"
+                      )}/size/180?${BONOB_ACCESS_TOKEN_HEADER}=${apiToken}`
+                    )
+                    .set(BONOB_ACCESS_TOKEN_HEADER, apiToken);
+
+                  expect(res.status).toEqual(200);
+                  expect(res.header["content-type"]).toEqual("image/png");
+
+                  expect(musicService.login).toHaveBeenCalledWith(serviceToken);
+                  urns.forEach((urn) => {
+                    expect(musicLibrary.coverArt).toHaveBeenCalledWith(urn, 180);
+                  });
+
+                  const image = await Image.load(res.body);
+                  expect(image.width).toEqual(180);
+                  expect(image.height).toEqual(180);
+                });
+              });
+
+              describe("fetching a collage of 11", () => {
+                it("should still return an image and a 200, though will only display 9", async () => {
+                  const urns = [
+                    "artist:1",
+                    "artist:2",
+                    "artist:3",
+                    "artist:4",
+                    "artist:5",
+                    "artist:6",
+                    "artist:7",
+                    "artist:8",
+                    "artist:9",
+                    "artist:10",
+                    "artist:11",
+                  ].map(resource => ({ system:"subsonic", resource }));
+
+                  musicService.login.mockResolvedValue(musicLibrary);
+
+                  urns.forEach((_) => {
+                    musicLibrary.coverArt.mockResolvedValueOnce(
+                      coverArtResponse({
+                        data: png,
+                      })
+                    );
+                  });
+
+                  const res = await request(server)
+                    .get(
+                      `/art/${urns.map(it => encodeURIComponent(formatForURL(it))).join(
+                        "&"
+                      )}/size/180?${BONOB_ACCESS_TOKEN_HEADER}=${apiToken}`
+                    )
+                    .set(BONOB_ACCESS_TOKEN_HEADER, apiToken);
+
+                  expect(res.status).toEqual(200);
+                  expect(res.header["content-type"]).toEqual("image/png");
+
+                  expect(musicService.login).toHaveBeenCalledWith(serviceToken);
+                  urns.forEach((it) => {
+                    expect(musicLibrary.coverArt).toHaveBeenCalledWith(it, 180);
+                  });
+
+                  const image = await Image.load(res.body);
+                  expect(image.width).toEqual(180);
+                  expect(image.height).toEqual(180);
+                });
+              });
+
+              describe("when the image is not available", () => {
+                it("should return a 404", async () => {
+                  const coverArtURN = { system:"subsonic", resource:"art:404"};
+
+                  musicService.login.mockResolvedValue(musicLibrary);
+                  musicLibrary.coverArt.mockResolvedValue(undefined);
+
+                  const res = await request(server)
+                    .get(
+                      `/art/${encodeURIComponent(formatForURL(coverArtURN))}/size/180?${BONOB_ACCESS_TOKEN_HEADER}=${apiToken}`
+                    )
+                    .set(BONOB_ACCESS_TOKEN_HEADER, apiToken);
+
+                  expect(res.status).toEqual(404);
+                });
+              });
+            });
+
             describe("when there is an error", () => {
               it("should return a 500", async () => {
                 musicService.login.mockResolvedValue(musicLibrary);

tests/smapi.test.ts

@@ -18,9 +18,11 @@ import {
   track,
   artist,
   album,
-  coverArtURI,
+  defaultAlbumArtURI,
+  defaultArtistArtURI,
   searchResult,
   iconArtURI,
+  playlistAlbumArtURL,
   sonosifyMimeType,
   ratingAsInt,
   ratingFromInt,
@@ -39,6 +41,7 @@ import {
   TRIP_HOP,
   PUNK,
   aPlaylist,
+  anAlbumSummary,
 } from "./builders";
 import { InMemoryMusicService } from "./in_memory_music_service";
 import supersoap from "./supersoap";
@@ -53,6 +56,7 @@ import dayjs from "dayjs";
 import url, { URLBuilder } from "../src/url_builder";
 import { iconForGenre } from "../src/icon";
 import { formatForURL } from "../src/burn";
+import { range } from "underscore";
 import { FixedClock } from "../src/clock";
 import { ExpiredTokenError, InvalidTokenError, SmapiAuthTokens, SmapiToken, ToSmapiFault } from "../src/smapi_auth";
 
@@ -352,10 +356,7 @@ describe("track", () => {
     const someTrack = aTrack({
       id: uuid(),
       // audio/x-flac should be mapped to audio/flac
-      encoding: {
+      mimeType: "audio/x-flac",
-        player: "something",
-        mimeType: "audio/x-flac"
-      },
       name: "great song",
       duration: randomInt(1000),
       number: randomInt(100),
@@ -410,10 +411,7 @@ describe("track", () => {
       const someTrack = aTrack({
         id: uuid(),
         // audio/x-flac should be mapped to audio/flac
-        encoding: {
+        mimeType: "audio/x-flac",
-          player: "something",
-          mimeType: "audio/x-flac"
-        },
         name: "great song",
         duration: randomInt(1000),
         number: randomInt(100),
@@ -473,7 +471,7 @@ describe("album", () => {
       itemType: "album",
       id: `album:${someAlbum.id}`,
       title: someAlbum.name,
-      albumArtURI: coverArtURI(bonobUrl, someAlbum).href(),
+      albumArtURI: defaultAlbumArtURI(bonobUrl, someAlbum).href(),
       canPlay: true,
       artist: someAlbum.artistName,
       artistId: `artist:${someAlbum.artistId}`,
@@ -497,8 +495,299 @@ describe("sonosifyMimeType", () => {
   });
 });
 
+describe("playlistAlbumArtURL", () => {
+  const coverArt1 = { system: "subsonic", resource: "1" };
+  const coverArt2 = { system: "subsonic", resource: "2" };
+  const coverArt3 = { system: "subsonic", resource: "3" };
+  const coverArt4 = { system: "subsonic", resource: "4" };
+  const coverArt5 = { system: "subsonic", resource: "5" };
 
-describe("coverArtURI", () => {
+  describe("when the playlist has no coverArt ids", () => {
+    it("should return question mark icon", () => {
+      const bonobUrl = url("http://localhost:1234/context-path?search=yes");
+      const playlist = aPlaylist({
+        entries: [
+          aTrack({ coverArt: undefined }),
+          aTrack({ coverArt: undefined }),
+        ],
+      });
+
+      expect(playlistAlbumArtURL(bonobUrl, playlist).href()).toEqual(
+        `http://localhost:1234/context-path/icon/error/size/legacy?search=yes`
+      );
+    });
+  });
+
+  describe("when the playlist has external ids", () => {
+    const bonobUrl = url("http://localhost:1234/context-path?search=yes");
+    const externalArt1 = {
+      system: "external",
+      resource: "http://example.com/image1.jpg",
+    };
+    const externalArt2 = {
+      system: "external",
+      resource: "http://example.com/image2.jpg",
+    };
+
+    const playlist = aPlaylist({
+      entries: [
+        aTrack({
+          coverArt: externalArt1,
+          album: anAlbumSummary({ id: "album1" }),
+        }),
+        aTrack({
+          coverArt: externalArt2,
+          album: anAlbumSummary({ id: "album2" }),
+        }),
+      ],
+    });
+
+    it("should format the url with encrypted urn", () => {
+      expect(playlistAlbumArtURL(bonobUrl, playlist).href()).toEqual(
+        `http://localhost:1234/context-path/art/${encodeURIComponent(
+          formatForURL(externalArt1)
+        )}&${encodeURIComponent(
+          formatForURL(externalArt2)
+        )}/size/180?search=yes`
+      );
+    }); 
+
+    describe("when BNB_NO_PLAYLIST_ART is set", () => {
+      const OLD_ENV = process.env;
+
+      beforeEach(() => {
+        process.env = { ...OLD_ENV };
+    
+        process.env["BNB_DISABLE_PLAYLIST_ART"] = "true";
+      });
+    
+      afterEach(() => {
+        process.env = OLD_ENV;
+      });
+    
+      it("should return an icon", () => {
+        expect(playlistAlbumArtURL(bonobUrl, playlist).href()).toEqual(
+          `http://localhost:1234/context-path/icon/music/size/legacy?search=yes`
+        );
+      });
+    });
+  });
+
+  describe("when the playlist has 4 tracks from 2 different albums, including some tracks that are missing coverArt urns", () => {
+    it("should use the cover art once per album", () => {
+      const bonobUrl = url("http://localhost:1234/context-path?search=yes");
+      const playlist = aPlaylist({
+        entries: [
+          aTrack({
+            coverArt: undefined,
+            album: anAlbumSummary({ id: "album1" }),
+          }),
+          aTrack({
+            coverArt: coverArt1,
+            album: anAlbumSummary({ id: "album1" }),
+          }),
+          aTrack({
+            coverArt: coverArt2,
+            album: anAlbumSummary({ id: "album2" }),
+          }),
+          aTrack({
+            coverArt: undefined,
+            album: anAlbumSummary({ id: "album2" }),
+          }),
+          aTrack({
+            coverArt: coverArt3,
+            album: anAlbumSummary({ id: "album1" }),
+          }),
+          aTrack({
+            coverArt: coverArt4,
+            album: anAlbumSummary({ id: "album2" }),
+          }),
+          aTrack({
+            coverArt: undefined,
+            album: anAlbumSummary({ id: "album2" }),
+          }),
+        ],
+      });
+
+      expect(playlistAlbumArtURL(bonobUrl, playlist).href()).toEqual(
+        `http://localhost:1234/context-path/art/${encodeURIComponent(
+          formatForURL(coverArt1)
+        )}&${encodeURIComponent(formatForURL(coverArt2))}/size/180?search=yes`
+      );
+    });
+  });
+
+  describe("when the playlist has 4 tracks from 2 different albums", () => {
+    it("should use the cover art once per album", () => {
+      const bonobUrl = url("http://localhost:1234/context-path?search=yes");
+      const playlist = aPlaylist({
+        entries: [
+          aTrack({
+            coverArt: coverArt1,
+            album: anAlbumSummary({ id: "album1" }),
+          }),
+          aTrack({
+            coverArt: coverArt2,
+            album: anAlbumSummary({ id: "album2" }),
+          }),
+          aTrack({
+            coverArt: coverArt3,
+            album: anAlbumSummary({ id: "album1" }),
+          }),
+          aTrack({
+            coverArt: coverArt4,
+            album: anAlbumSummary({ id: "album2" }),
+          }),
+        ],
+      });
+
+      expect(playlistAlbumArtURL(bonobUrl, playlist).href()).toEqual(
+        `http://localhost:1234/context-path/art/${encodeURIComponent(
+          formatForURL(coverArt1)
+        )}&${encodeURIComponent(formatForURL(coverArt2))}/size/180?search=yes`
+      );
+    });
+  });
+
+  describe("when the playlist has 4 tracks from 3 different albums", () => {
+    it("should use the cover art once per album", () => {
+      const bonobUrl = url("http://localhost:1234/context-path?search=yes");
+      const playlist = aPlaylist({
+        entries: [
+          aTrack({
+            coverArt: coverArt1,
+            album: anAlbumSummary({ id: "album1" }),
+          }),
+          aTrack({
+            coverArt: coverArt2,
+            album: anAlbumSummary({ id: "album2" }),
+          }),
+          aTrack({
+            coverArt: coverArt3,
+            album: anAlbumSummary({ id: "album1" }),
+          }),
+          aTrack({
+            coverArt: coverArt4,
+            album: anAlbumSummary({ id: "album3" }),
+          }),
+        ],
+      });
+
+      expect(playlistAlbumArtURL(bonobUrl, playlist).href()).toEqual(
+        `http://localhost:1234/context-path/art/${encodeURIComponent(
+          formatForURL(coverArt1)
+        )}&${encodeURIComponent(formatForURL(coverArt2))}&${encodeURIComponent(
+          formatForURL(coverArt4)
+        )}/size/180?search=yes`
+      );
+    });
+  });
+
+  describe("when the playlist has 4 tracks from 4 different albums", () => {
+    it("should return them on the url to the image", () => {
+      const bonobUrl = url("http://localhost:1234/context-path?search=yes");
+      const playlist = aPlaylist({
+        entries: [
+          aTrack({
+            coverArt: coverArt1,
+            album: anAlbumSummary({ id: "album1" }),
+          }),
+          aTrack({
+            coverArt: coverArt2,
+            album: anAlbumSummary({ id: "album2" }),
+          }),
+          aTrack({
+            coverArt: coverArt3,
+            album: anAlbumSummary({ id: "album3" }),
+          }),
+          aTrack({
+            coverArt: coverArt4,
+            album: anAlbumSummary({ id: "album4" }),
+          }),
+          aTrack({
+            coverArt: coverArt5,
+            album: anAlbumSummary({ id: "album1" }),
+          }),
+        ],
+      });
+
+      expect(playlistAlbumArtURL(bonobUrl, playlist).href()).toEqual(
+        `http://localhost:1234/context-path/art/${encodeURIComponent(
+          formatForURL(coverArt1)
+        )}&${encodeURIComponent(formatForURL(coverArt2))}&${encodeURIComponent(
+          formatForURL(coverArt3)
+        )}&${encodeURIComponent(formatForURL(coverArt4))}/size/180?search=yes`
+      );
+    });
+  });
+
+  describe("when the playlist has at least 9 distinct albumIds", () => {
+    it("should return the first 9 of the ids on the url", () => {
+      const bonobUrl = url("http://localhost:1234/context-path?search=yes");
+      const playlist = aPlaylist({
+        entries: [
+          aTrack({
+            coverArt: { system: "subsonic", resource: "1" },
+            album: anAlbumSummary({ id: "1" }),
+          }),
+          aTrack({
+            coverArt: { system: "subsonic", resource: "2" },
+            album: anAlbumSummary({ id: "2" }),
+          }),
+          aTrack({
+            coverArt: { system: "subsonic", resource: "3" },
+            album: anAlbumSummary({ id: "3" }),
+          }),
+          aTrack({
+            coverArt: { system: "subsonic", resource: "4" },
+            album: anAlbumSummary({ id: "4" }),
+          }),
+          aTrack({
+            coverArt: { system: "subsonic", resource: "5" },
+            album: anAlbumSummary({ id: "5" }),
+          }),
+          aTrack({
+            coverArt: { system: "subsonic", resource: "6" },
+            album: anAlbumSummary({ id: "6" }),
+          }),
+          aTrack({
+            coverArt: { system: "subsonic", resource: "7" },
+            album: anAlbumSummary({ id: "7" }),
+          }),
+          aTrack({
+            coverArt: { system: "subsonic", resource: "8" },
+            album: anAlbumSummary({ id: "8" }),
+          }),
+          aTrack({
+            coverArt: { system: "subsonic", resource: "9" },
+            album: anAlbumSummary({ id: "9" }),
+          }),
+          aTrack({
+            coverArt: { system: "subsonic", resource: "10" },
+            album: anAlbumSummary({ id: "10" }),
+          }),
+          aTrack({
+            coverArt: { system: "subsonic", resource: "11" },
+            album: anAlbumSummary({ id: "11" }),
+          }),
+        ],
+      });
+
+      const burns = range(1, 10)
+        .map((i) =>
+          encodeURIComponent(
+            formatForURL({ system: "subsonic", resource: `${i}` })
+          )
+        )
+        .join("&");
+      expect(playlistAlbumArtURL(bonobUrl, playlist).href()).toEqual(
+        `http://localhost:1234/context-path/art/${burns}/size/180?search=yes`
+      );
+    });
+  });
+});
+
+describe("defaultAlbumArtURI", () => {
   const bonobUrl = new URLBuilder(
     "http://bonob.example.com:8080/context?search=yes"
   );
@@ -508,7 +797,7 @@ describe("coverArtURI", () => {
       it("should use it", () => {
         const coverArt = { system: "subsonic", resource: "12345" };
         expect(
-          coverArtURI(bonobUrl, anAlbum({ coverArt })).href()
+          defaultAlbumArtURI(bonobUrl, anAlbum({ coverArt })).href()
         ).toEqual(
           `http://bonob.example.com:8080/context/art/${encodeURIComponent(
             formatForURL(coverArt)
@@ -524,7 +813,7 @@ describe("coverArtURI", () => {
           resource: "http://example.com/someimage.jpg",
         };
         expect(
-          coverArtURI(bonobUrl, anAlbum({ coverArt })).href()
+          defaultAlbumArtURI(bonobUrl, anAlbum({ coverArt })).href()
         ).toEqual(
           `http://bonob.example.com:8080/context/art/${encodeURIComponent(
             formatForURL(coverArt)
@@ -537,7 +826,7 @@ describe("coverArtURI", () => {
   describe("when there is no album coverArt", () => {
     it("should return a vinly icon image", () => {
       expect(
-        coverArtURI(bonobUrl, anAlbum({ coverArt: undefined })).href()
+        defaultAlbumArtURI(bonobUrl, anAlbum({ coverArt: undefined })).href()
       ).toEqual(
         "http://bonob.example.com:8080/context/icon/vinyl/size/legacy?search=yes"
       );
@@ -545,6 +834,50 @@ describe("coverArtURI", () => {
   });
 });
 
+describe("defaultArtistArtURI", () => {
+  describe("when the artist has no image", () => {
+    it("should return an icon", () => {
+      const bonobUrl = url("http://localhost:1234/something?s=123");
+      const artist = anArtist({ image: undefined });
+
+      expect(defaultArtistArtURI(bonobUrl, artist).href()).toEqual(
+        `http://localhost:1234/something/icon/vinyl/size/legacy?s=123`
+      );
+    });
+  });
+
+  describe("when the resource is subsonic", () => {
+    it("should use the resource", () => {
+      const bonobUrl = url("http://localhost:1234/something?s=123");
+      const image = { system: "subsonic", resource: "art:1234" };
+      const artist = anArtist({ image });
+
+      expect(defaultArtistArtURI(bonobUrl, artist).href()).toEqual(
+        `http://localhost:1234/something/art/${encodeURIComponent(
+          formatForURL(image)
+        )}/size/180?s=123`
+      );
+    });
+  });
+
+  describe("when the resource is external", () => {
+    it("should encrypt the resource", () => {
+      const bonobUrl = url("http://localhost:1234/something?s=123");
+      const image = {
+        system: "external",
+        resource: "http://example.com/something.jpg",
+      };
+      const artist = anArtist({ image });
+
+      expect(defaultArtistArtURI(bonobUrl, artist).href()).toEqual(
+        `http://localhost:1234/something/art/${encodeURIComponent(
+          formatForURL(image)
+        )}/size/180?s=123`
+      );
+    });
+  });
+});
+
 describe("wsdl api", () => {
   const musicService = {
     generateToken: jest.fn(),
@@ -1368,7 +1701,7 @@ describe("wsdl api", () => {
                         itemType: "playlist",
                         id: `playlist:${playlist.id}`,
                         title: playlist.name,
-                        albumArtURI: coverArtURI(
+                        albumArtURI: playlistAlbumArtURL(
                           bonobUrlWithAccessToken,
                           playlist
                         ).href(),
@@ -1400,7 +1733,7 @@ describe("wsdl api", () => {
                           itemType: "playlist",
                           id: `playlist:${playlist.id}`,
                           title: playlist.name,
-                          albumArtURI: coverArtURI(
+                          albumArtURI: playlistAlbumArtURL(
                             bonobUrlWithAccessToken,
                             playlist
                           ).href(),
@@ -1444,7 +1777,7 @@ describe("wsdl api", () => {
                           itemType: "album",
                           id: `album:${it.id}`,
                           title: it.name,
-                          albumArtURI: coverArtURI(
+                          albumArtURI: defaultAlbumArtURI(
                             bonobUrlWithAccessToken,
                             it
                           ).href(),
@@ -1481,7 +1814,7 @@ describe("wsdl api", () => {
                         itemType: "album",
                         id: `album:${it.id}`,
                         title: it.name,
-                        albumArtURI: coverArtURI(
+                        albumArtURI: defaultAlbumArtURI(
                           bonobUrlWithAccessToken,
                           it
                         ).href(),
@@ -1533,9 +1866,9 @@ describe("wsdl api", () => {
                         id: `artist:${it.id}`,
                         artistId: it.id,
                         title: it.name,
-                        albumArtURI: coverArtURI(
+                        albumArtURI: defaultArtistArtURI(
                           bonobUrlWithAccessToken,
-                          { coverArt: it.image }
+                          it
                         ).href(),
                       })),
                       index: 0,
@@ -1578,9 +1911,9 @@ describe("wsdl api", () => {
                         id: `artist:${it.id}`,
                         artistId: it.id,
                         title: it.name,
-                        albumArtURI: coverArtURI(
+                        albumArtURI: defaultArtistArtURI(
                           bonobUrlWithAccessToken,
-                          { coverArt: it.image }
+                          it
                         ).href(),
                       })),
                       index: 1,
@@ -1639,9 +1972,9 @@ describe("wsdl api", () => {
                           id: `artist:${it.id}`,
                           artistId: it.id,
                           title: it.name,
-                          albumArtURI: coverArtURI(
+                          albumArtURI: defaultArtistArtURI(
                             bonobUrlWithAccessToken,
-                            { coverArt: it.image }
+                            it
                           ).href(),
                         })),
                         index: 0,
@@ -1668,9 +2001,9 @@ describe("wsdl api", () => {
                             id: `artist:${it.id}`,
                             artistId: it.id,
                             title: it.name,
-                            albumArtURI: coverArtURI(
+                            albumArtURI: defaultArtistArtURI(
                               bonobUrlWithAccessToken,
-                              { coverArt: it.image }
+                              it
                             ).href(),
                           })
                         ),
@@ -1785,7 +2118,7 @@ describe("wsdl api", () => {
                         itemType: "album",
                         id: `album:${it.id}`,
                         title: it.name,
-                        albumArtURI: coverArtURI(
+                        albumArtURI: defaultAlbumArtURI(
                           bonobUrlWithAccessToken,
                           it
                         ).href(),
@@ -1833,7 +2166,7 @@ describe("wsdl api", () => {
                         itemType: "album",
                         id: `album:${it.id}`,
                         title: it.name,
-                        albumArtURI: coverArtURI(
+                        albumArtURI: defaultAlbumArtURI(
                           bonobUrlWithAccessToken,
                           it
                         ).href(),
@@ -1881,7 +2214,7 @@ describe("wsdl api", () => {
                         itemType: "album",
                         id: `album:${it.id}`,
                         title: it.name,
-                        albumArtURI: coverArtURI(
+                        albumArtURI: defaultAlbumArtURI(
                           bonobUrlWithAccessToken,
                           it
                         ).href(),
@@ -1929,7 +2262,7 @@ describe("wsdl api", () => {
                         itemType: "album",
                         id: `album:${it.id}`,
                         title: it.name,
-                        albumArtURI: coverArtURI(
+                        albumArtURI: defaultAlbumArtURI(
                           bonobUrlWithAccessToken,
                           it
                         ).href(),
@@ -1977,7 +2310,7 @@ describe("wsdl api", () => {
                         itemType: "album",
                         id: `album:${it.id}`,
                         title: it.name,
-                        albumArtURI: coverArtURI(
+                        albumArtURI: defaultAlbumArtURI(
                           bonobUrlWithAccessToken,
                           it
                         ).href(),
@@ -2025,7 +2358,7 @@ describe("wsdl api", () => {
                         itemType: "album",
                         id: `album:${it.id}`,
                         title: it.name,
-                        albumArtURI: coverArtURI(
+                        albumArtURI: defaultAlbumArtURI(
                           bonobUrlWithAccessToken,
                           it
                         ).href(),
@@ -2071,7 +2404,7 @@ describe("wsdl api", () => {
                         itemType: "album",
                         id: `album:${it.id}`,
                         title: it.name,
-                        albumArtURI: coverArtURI(
+                        albumArtURI: defaultAlbumArtURI(
                           bonobUrlWithAccessToken,
                           it
                         ).href(),
@@ -2117,7 +2450,7 @@ describe("wsdl api", () => {
                         itemType: "album",
                         id: `album:${it.id}`,
                         title: it.name,
-                        albumArtURI: coverArtURI(
+                        albumArtURI: defaultAlbumArtURI(
                           bonobUrlWithAccessToken,
                           it
                         ).href(),
@@ -2161,7 +2494,7 @@ describe("wsdl api", () => {
                         itemType: "album",
                         id: `album:${it.id}`,
                         title: it.name,
-                        albumArtURI: coverArtURI(
+                        albumArtURI: defaultAlbumArtURI(
                           bonobUrlWithAccessToken,
                           it
                         ).href(),
@@ -2208,7 +2541,7 @@ describe("wsdl api", () => {
                         itemType: "album",
                         id: `album:${it.id}`,
                         title: it.name,
-                        albumArtURI: coverArtURI(
+                        albumArtURI: defaultAlbumArtURI(
                           bonobUrlWithAccessToken,
                           it
                         ).href(),
@@ -2585,7 +2918,7 @@ describe("wsdl api", () => {
                         id: `track:${track.id}`,
                         itemType: "track",
                         title: track.name,
-                        mimeType: track.encoding.mimeType,
+                        mimeType: track.mimeType,
                         trackMetadata: {
                           artistId: `artist:${track.artist.id}`,
                           artist: track.artist.name,
@@ -2596,7 +2929,7 @@ describe("wsdl api", () => {
                           genre: track.genre?.name,
                           genreId: track.genre?.id,
                           duration: track.duration,
-                          albumArtURI: coverArtURI(
+                          albumArtURI: defaultAlbumArtURI(
                             bonobUrlWithAccessToken,
                             track
                           ).href(),
@@ -2633,7 +2966,7 @@ describe("wsdl api", () => {
                         id: `track:${track.id}`,
                         itemType: "track",
                         title: track.name,
-                        mimeType: track.encoding.mimeType,
+                        mimeType: track.mimeType,
                         trackMetadata: {
                           artistId: `artist:${track.artist.id}`,
                           artist: track.artist.name,
@@ -2644,7 +2977,7 @@ describe("wsdl api", () => {
                           genre: track.genre?.name,
                           genreId: track.genre?.id,
                           duration: track.duration,
-                          albumArtURI: coverArtURI(
+                          albumArtURI: defaultAlbumArtURI(
                             bonobUrlWithAccessToken,
                             track
                           ).href(),
@@ -2687,7 +3020,7 @@ describe("wsdl api", () => {
                       itemType: "album",
                       id: `album:${album.id}`,
                       title: album.name,
-                      albumArtURI: coverArtURI(
+                      albumArtURI: defaultAlbumArtURI(
                         bonobUrlWithAccessToken,
                         album
                       ).href(),

tests/subsonic.test.ts

@@ -12,6 +12,7 @@ import {
   t,
   DODGY_IMAGE_NAME,
   asGenre,
+  appendMimeTypeToClientFor,
   asURLSearchParams,
   cachingImageFetcher,
   asTrack,
@@ -21,9 +22,6 @@ import {
   PingResponse,
   parseToken,
   asToken,
-  TranscodingCustomPlayers,
-  CustomPlayers,
-  NO_CUSTOM_PLAYERS
 } from "../src/subsonic";
 
 import axios from "axios";
@@ -49,7 +47,7 @@ import {
   SimilarArtist,
   Rating,
   Credentials,
-  AuthFailure
+  AuthFailure,
 } from "../src/music_service";
 import {
   aGenre,
@@ -94,24 +92,36 @@ describe("isValidImage", () => {
   });
 });
 
-
+describe("appendMimeTypeToUserAgentFor", () => {
-describe("StreamClient(s)", () => {
+  describe("when empty array", () => {
-  describe("CustomStreamClientApplications", () => {
+    it("should return bonob", () => {
-    const customClients = TranscodingCustomPlayers.from("audio/flac,audio/mp3>audio/ogg")
+      expect(appendMimeTypeToClientFor([])(aTrack())).toEqual("bonob");
-  
-    describe("clientFor", () => {
-      describe("when there is a match", () => {
-        it("should return the match", () => {
-          expect(customClients.encodingFor({ mimeType: "audio/flac" })).toEqual(O.of({player: "bonob+audio/flac", mimeType:"audio/flac"}))
-          expect(customClients.encodingFor({ mimeType: "audio/mp3" })).toEqual(O.of({player: "bonob+audio/mp3", mimeType:"audio/ogg"}))
     });
   });
 
-      describe("when there is no match", () => {
+  describe("when contains some mimeTypes", () => {
-        it("should return undefined", () => {
+    const streamUserAgent = appendMimeTypeToClientFor([
-          expect(customClients.encodingFor({ mimeType: "audio/bob" })).toEqual(O.none)
+      "audio/flac",
+      "audio/ogg",
+    ]);
+
+    describe("and the track mimeType is in the array", () => {
+      it("should return bonob+mimeType", () => {
+        expect(streamUserAgent(aTrack({ mimeType: "audio/flac" }))).toEqual(
+          "bonob+audio/flac"
+        );
+        expect(streamUserAgent(aTrack({ mimeType: "audio/ogg" }))).toEqual(
+          "bonob+audio/ogg"
+        );
       });
     });
+
+    describe("and the track mimeType is not in the array", () => {
+      it("should return bonob", () => {
+        expect(streamUserAgent(aTrack({ mimeType: "audio/mp3" }))).toEqual(
+          "bonob"
+        );
+      });
     });
   });
 });
@@ -311,8 +321,7 @@ const asSongJson = (track: Track) => ({
   bitRate: 128,
   size: "5624132",
   suffix: "mp3",
-  contentType: track.encoding.mimeType,
+  contentType: track.mimeType,
-  transcodedContentType: undefined,
   isVideo: "false",
   path: "ACDC/High voltage/ACDC - The Jack.mp3",
   albumId: track.album.id,
@@ -438,7 +447,7 @@ const getPlayListJson = (playlist: Playlist) =>
         genre: it.album.genre?.name,
         coverArt: maybeIdFromCoverArtUrn(it.coverArt),
         size: 123,
-        contentType: it.encoding.mimeType,
+        contentType: it.mimeType,
         suffix: "mp3",
         duration: it.duration,
         bitRate: 128,
@@ -636,17 +645,12 @@ describe("artistURN", () => {
 });
 
 describe("asTrack", () => {
-  beforeEach(() => {
-    jest.clearAllMocks();
-    jest.resetAllMocks();
-  });
-
   describe("when the song has no artistId", () => {
     const album = anAlbum();
     const track = aTrack({ artist: { id: undefined, name: "Not in library so no id", image: undefined }});
 
     it("should provide no artistId", () => {
-      const result = asTrack(album, { ...asSongJson(track) }, NO_CUSTOM_PLAYERS);
+      const result = asTrack(album, { ...asSongJson(track) });
       expect(result.artist.id).toBeUndefined();
       expect(result.artist.name).toEqual("Not in library so no id");
       expect(result.artist.image).toBeUndefined();
@@ -657,7 +661,7 @@ describe("asTrack", () => {
     const album = anAlbum();
 
     it("should provide a ? to sonos", () => {
-      const result = asTrack(album, { id: '1' } as any as song, NO_CUSTOM_PLAYERS);
+      const result = asTrack(album, { id: '1' } as any as song);
       expect(result.artist.id).toBeUndefined();
       expect(result.artist.name).toEqual("?");
       expect(result.artist.image).toBeUndefined();
@@ -670,103 +674,18 @@ describe("asTrack", () => {
 
     describe("a value greater than 5", () => {
       it("should be returned as 0", () => {
-        const result = asTrack(album, { ...asSongJson(track), userRating: 6 }, NO_CUSTOM_PLAYERS);
+        const result = asTrack(album, { ...asSongJson(track), userRating: 6 });
         expect(result.rating.stars).toEqual(0);
       });
     });
 
     describe("a value less than 0", () => {
       it("should be returned as 0", () => {
-        const result = asTrack(album, { ...asSongJson(track), userRating: -1 }, NO_CUSTOM_PLAYERS);
+        const result = asTrack(album, { ...asSongJson(track), userRating: -1 });
         expect(result.rating.stars).toEqual(0);
       });
     });
   });
-
-  describe("content types", () => {
-    const album = anAlbum();
-    const track = aTrack();
-
-    describe("when there are no custom players", () => {
-      describe("when subsonic reports no transcodedContentType", () => {
-        it("should use the default client and default contentType", () => {
-          const result = asTrack(album, { 
-            ...asSongJson(track),
-            contentType: "nonTranscodedContentType",
-            transcodedContentType: undefined 
-          }, NO_CUSTOM_PLAYERS);
-
-          expect(result.encoding).toEqual({ player: "bonob", mimeType: "nonTranscodedContentType" })
-        });
-      });
-
-      describe("when subsonic reports a transcodedContentType", () => {
-        it("should use the default client and transcodedContentType", () => {
-          const result = asTrack(album, { 
-            ...asSongJson(track),
-            contentType: "nonTranscodedContentType",
-            transcodedContentType: "transcodedContentType" 
-          }, NO_CUSTOM_PLAYERS);
-
-          expect(result.encoding).toEqual({ player: "bonob", mimeType: "transcodedContentType" })
-        });
-      });
-    });
-
-    describe("when there are custom players registered", () => {
-      const streamClient = {
-        encodingFor: jest.fn()
-      }
-
-      describe("however no player is found for the default mimeType", () => {
-        describe("and there is no transcodedContentType", () => {
-          it("should use the default player with the default content type", () => {
-            streamClient.encodingFor.mockReturnValue(O.none)
-
-            const result = asTrack(album, { 
-              ...asSongJson(track),
-              contentType: "nonTranscodedContentType",
-              transcodedContentType: undefined 
-            },  streamClient as unknown as CustomPlayers);
-  
-            expect(result.encoding).toEqual({ player: "bonob", mimeType: "nonTranscodedContentType" });
-            expect(streamClient.encodingFor).toHaveBeenCalledWith({ mimeType: "nonTranscodedContentType" });
-          });
-        });
-
-        describe("and there is a transcodedContentType", () => {
-          it("should use the default player with the transcodedContentType", () => {
-            streamClient.encodingFor.mockReturnValue(O.none)
-
-            const result = asTrack(album, { 
-              ...asSongJson(track),
-              contentType: "nonTranscodedContentType",
-              transcodedContentType: "transcodedContentType1" 
-            },  streamClient as unknown as CustomPlayers);
-  
-            expect(result.encoding).toEqual({ player: "bonob", mimeType: "transcodedContentType1" });
-            expect(streamClient.encodingFor).toHaveBeenCalledWith({ mimeType: "nonTranscodedContentType" });
-          });
-        });
-      });
-
-      describe("there is a player with the matching content type", () => {
-        it("should use it", () => {
-          const customEncoding = { player: "custom-player", mimeType: "audio/some-mime-type" };
-          streamClient.encodingFor.mockReturnValue(O.of(customEncoding));
-    
-          const result = asTrack(album, { 
-            ...asSongJson(track), 
-            contentType: "sourced-from/subsonic", 
-            transcodedContentType: "sourced-from/subsonic2" 
-          }, streamClient as unknown as CustomPlayers);
-    
-          expect(result.encoding).toEqual(customEncoding);
-          expect(streamClient.encodingFor).toHaveBeenCalledWith({ mimeType: "sourced-from/subsonic" });
-        });    
-      });
-    });
-  });
 });
 
 describe("Subsonic", () => {
@@ -775,13 +694,10 @@ describe("Subsonic", () => {
   const password = `pass1-${uuid()}`;
   const salt = "saltysalty";
 
-  const customPlayers = {
+  const streamClientApplication = jest.fn();
-    encodingFor: jest.fn()
-  };
-  
   const subsonic = new Subsonic(
     url,
-    customPlayers as unknown as CustomPlayers
+    streamClientApplication
   );
 
   const mockRandomstring = jest.fn();
@@ -821,7 +737,8 @@ describe("Subsonic", () => {
     TE.fold(e => { throw e }, T.of)
   )
 
-  const login = (credentials: Credentials) => tokenFor(credentials)().then((it) => subsonic.login(it.serviceToken))
+  const login = (credentials: Credentials) => tokenFor(credentials)()
+  .then((it) => subsonic.login(it.serviceToken))
 
   describe("generateToken", () => {
     describe("when the credentials are valid", () => {
@@ -2704,10 +2621,6 @@ describe("Subsonic", () => {
   });
 
   describe("getting an album", () => {
-    beforeEach(() => {
-      customPlayers.encodingFor.mockReturnValue(O.none);
-    });
-
     describe("when it exists", () => {
       const genre = asGenre("Pop");
 
@@ -2749,11 +2662,6 @@ describe("Subsonic", () => {
 
   describe("getting tracks", () => {
     describe("for an album", () => {
-      describe("when there are no custom players", () => {
-        beforeEach(() => {
-          customPlayers.encodingFor.mockReturnValue(O.none);
-        });
-
       describe("when the album has multiple tracks, some of which are rated", () => {
         const hipHop = asGenre("Hip-Hop");
         const tripHop = asGenre("Trip-Hop");
@@ -2912,115 +2820,6 @@ describe("Subsonic", () => {
       });
     });
 
-      describe("when a custom player is configured for the mime type", () => {
-        const hipHop = asGenre("Hip-Hop");
-        const tripHop = asGenre("Trip-Hop");
-  
-        const album = anAlbum({ id: "album1", name: "Burnin", genre: hipHop });
-  
-        const artist = anArtist({
-          id: "artist1",
-          name: "Bob Marley",
-          albums: [album],
-        });
-  
-        const alac = aTrack({
-          artist: artistToArtistSummary(artist),
-          album: albumToAlbumSummary(album),
-          encoding: {
-            player: "bonob",
-            mimeType: "audio/alac"
-          },
-          genre: hipHop,
-          rating: {
-            love: true,
-            stars: 3,
-          },
-        });
-        const m4a = aTrack({
-          artist: artistToArtistSummary(artist),
-          album: albumToAlbumSummary(album),
-          encoding: {
-            player: "bonob",
-            mimeType: "audio/m4a"
-          },
-          genre: hipHop,
-          rating: {
-            love: false,
-            stars: 0,
-          },
-        });
-        const mp3 = aTrack({
-          artist: artistToArtistSummary(artist),
-          album: albumToAlbumSummary(album),
-          encoding: {
-            player: "bonob",
-            mimeType: "audio/mp3"
-          },
-          genre: tripHop,
-          rating: {
-            love: true,
-            stars: 5,
-          },
-        });
-  
-        beforeEach(() => {
-          customPlayers.encodingFor
-            .mockReturnValueOnce(O.of({ player: "bonob+audio/alac", mimeType: "audio/flac" }))
-            .mockReturnValueOnce(O.of({ player: "bonob+audio/m4a", mimeType: "audio/opus" }))
-            .mockReturnValueOnce(O.none)
-          
-          mockGET
-            .mockImplementationOnce(() => Promise.resolve(ok(PING_OK)))
-            .mockImplementationOnce(() =>
-              Promise.resolve(ok(getAlbumJson(artist, album, [alac, m4a, mp3])))
-            );
-        });
-  
-        it("should return the album with custom players applied", async () => {
-          const result = await login({ username, password })
-            .then((it) => it.tracks(album.id));
-  
-          expect(result).toEqual([
-            {
-              ...alac,
-              encoding: { 
-                player: "bonob+audio/alac", 
-                mimeType: "audio/flac" 
-              }
-            },
-            {
-              ...m4a,
-              encoding: { 
-                player: "bonob+audio/m4a", 
-                mimeType: "audio/opus" 
-              }
-            },
-            {
-              ...mp3,
-              encoding: {
-                player: "bonob",
-                mimeType: "audio/mp3"
-              }
-            },
-          ]);
-  
-          expect(axios.get).toHaveBeenCalledWith(url.append({ pathname: '/rest/getAlbum' }).href(), {
-            params: asURLSearchParams({
-              ...authParamsPlusJson,
-              id: album.id,
-            }),
-            headers,
-          });
-  
-          expect(customPlayers.encodingFor).toHaveBeenCalledTimes(3);
-          expect(customPlayers.encodingFor).toHaveBeenNthCalledWith(1, { mimeType: "audio/alac" })
-          expect(customPlayers.encodingFor).toHaveBeenNthCalledWith(2, { mimeType: "audio/m4a" })
-          expect(customPlayers.encodingFor).toHaveBeenNthCalledWith(3, { mimeType: "audio/mp3" })
-        });
-      });      
-    });
-
     describe("a single track", () => {
       const pop = asGenre("Pop");
 
@@ -3032,11 +2831,6 @@ describe("Subsonic", () => {
         albums: [album],
       });
 
-      describe("when there are no custom players", () => {
-        beforeEach(() => {
-          customPlayers.encodingFor.mockReturnValue(O.none);
-        });
-  
       describe("that is starred", () => {
         it("should return the track", async () => {
           const track = aTrack({
@@ -3132,10 +2926,8 @@ describe("Subsonic", () => {
       });
     });
   });
-  });
 
   describe("streaming a track", () => {
-
     const trackId = uuid();
     const genre = aGenre("foo");
 
@@ -3150,12 +2942,11 @@ describe("Subsonic", () => {
       genre,
     });
 
-    describe("when there are no custom players registered", () => {
+    describe("content-range, accept-ranges or content-length", () => {
       beforeEach(() => {
-        customPlayers.encodingFor.mockReturnValue(O.none);
+        streamClientApplication.mockReturnValue("bonob");
       });
 
-      describe("content-range, accept-ranges or content-length", () => {
       describe("when navidrome doesnt return a content-range, accept-ranges or content-length", () => {
         it("should return undefined values", async () => {
           const stream = {
@@ -3391,24 +3182,13 @@ describe("Subsonic", () => {
         });
       });
     });
-    });
-
-    describe("when there are custom players registered", () => {
-      const customEncoding = {
-        player: `bonob-${uuid()}`,
-        mimeType: "transocodedMimeType"
-      };
-      const trackWithCustomPlayer: Track = {
-        ...track,
-        encoding: customEncoding
-      };
-
-      beforeEach(() => {
-        customPlayers.encodingFor.mockReturnValue(O.of(customEncoding));
-      });
 
+    describe("when navidrome has a custom StreamClientApplication registered", () => {
       describe("when no range specified", () => {
-        it("should user the custom client specified by the stream client", async () => {
+        it("should user the custom StreamUserAgent when calling navidrome", async () => {
+          const clientApplication = `bonob-${uuid()}`;
+          streamClientApplication.mockReturnValue(clientApplication);
+
           const streamResponse = {
             status: 200,
             headers: {
@@ -3420,21 +3200,22 @@ describe("Subsonic", () => {
           mockGET
             .mockImplementationOnce(() => Promise.resolve(ok(PING_OK)))
             .mockImplementationOnce(() =>
-              Promise.resolve(ok(getSongJson(trackWithCustomPlayer)))
+              Promise.resolve(ok(getSongJson(track)))
             )
             .mockImplementationOnce(() =>
-              Promise.resolve(ok(getAlbumJson(artist, album, [trackWithCustomPlayer])))
+              Promise.resolve(ok(getAlbumJson(artist, album, [track])))
             )
             .mockImplementationOnce(() => Promise.resolve(streamResponse));
 
           await login({ username, password })
             .then((it) => it.stream({ trackId, range: undefined }));
 
+          expect(streamClientApplication).toHaveBeenCalledWith(track);
           expect(axios.get).toHaveBeenCalledWith(url.append({ pathname: '/rest/stream' }).href(), {
             params: asURLSearchParams({
               ...authParams,
               id: trackId,
-              c: trackWithCustomPlayer.encoding.player,
+              c: clientApplication,
             }),
             headers: {
               "User-Agent": "bonob",
@@ -3445,8 +3226,10 @@ describe("Subsonic", () => {
       });
 
       describe("when range specified", () => {
-        it("should user the custom client specified by the stream client", async () => {
+        it("should user the custom StreamUserAgent when calling navidrome", async () => {
           const range = "1000-2000";
+          const clientApplication = `bonob-${uuid()}`;
+          streamClientApplication.mockReturnValue(clientApplication);
 
           const streamResponse = {
             status: 200,
@@ -3459,21 +3242,22 @@ describe("Subsonic", () => {
           mockGET
             .mockImplementationOnce(() => Promise.resolve(ok(PING_OK)))
             .mockImplementationOnce(() =>
-              Promise.resolve(ok(getSongJson(trackWithCustomPlayer)))
+              Promise.resolve(ok(getSongJson(track)))
             )
             .mockImplementationOnce(() =>
-              Promise.resolve(ok(getAlbumJson(artist, album, [trackWithCustomPlayer])))
+              Promise.resolve(ok(getAlbumJson(artist, album, [track])))
             )
             .mockImplementationOnce(() => Promise.resolve(streamResponse));
 
           await login({ username, password })
             .then((it) => it.stream({ trackId, range }));
 
+          expect(streamClientApplication).toHaveBeenCalledWith(track);
           expect(axios.get).toHaveBeenCalledWith(url.append({ pathname: '/rest/stream' }).href(), {
             params: asURLSearchParams({
               ...authParams,
               id: trackId,
-              c: trackWithCustomPlayer.encoding.player,
+              c: clientApplication,
             }),
             headers: {
               "User-Agent": "bonob",
@@ -3716,10 +3500,6 @@ describe("Subsonic", () => {
     const artist = anArtist();
     const album = anAlbum({ id: "album1", name: "Burnin", genre: POP });
 
-    beforeEach(() => {
-      customPlayers.encodingFor.mockReturnValue(O.none);
-    });
-
     describe("rating a track", () => {
       describe("loving a track that isnt already loved", () => {
         it("should mark the track as loved", async () => {
@@ -4263,10 +4043,6 @@ describe("Subsonic", () => {
   });
 
   describe("searchSongs", () => {
-    beforeEach(() => {
-      customPlayers.encodingFor.mockReturnValue(O.none);
-    });
-
     describe("when there is 1 search results", () => {
       it("should return true", async () => {
         const pop = asGenre("Pop");
@@ -4411,10 +4187,6 @@ describe("Subsonic", () => {
   });
 
   describe("playlists", () => {
-    beforeEach(() => {
-      customPlayers.encodingFor.mockReturnValue(O.none);
-    });
-
     describe("getting playlists", () => {
       describe("when there is 1 playlist results", () => {
         it("should return it", async () => {
@@ -4704,10 +4476,6 @@ describe("Subsonic", () => {
   });
 
   describe("similarSongs", () => {
-    beforeEach(() => {
-      customPlayers.encodingFor.mockReturnValue(O.none);
-    });
-
     describe("when there is one similar songs", () => {
       it("should return it", async () => {
         const id = "idWithTracks";
@@ -4869,10 +4637,6 @@ describe("Subsonic", () => {
   });
 
   describe("topSongs", () => {
-    beforeEach(() => {
-      customPlayers.encodingFor.mockReturnValue(O.none);
-    });
-
     describe("when there is one top song", () => {
       it("should return it", async () => {
         const artistId = "bobMarleyId";