refactor

more tidy
2025-12-21 17:33:29 +01:00 · 2022-07-29 13:45:57 +10:00 · 2022-07-08 15:24:07 +10:00 · 2022-04-24 10:35:50 +10:00 · 2022-04-24 10:35:50 +10:00 · 2022-04-24 10:35:50 +10:00
49 changed files with 16008 additions and 14343 deletions
--- a/.devcontainer/Dockerfile
+++ b/.devcontainer/Dockerfile
@@ -1,16 +0,0 @@
-FROM node:20-bullseye
-
-LABEL maintainer=simojenki
-
-ENV JEST_TIMEOUT=60000
-EXPOSE 4534
-
-RUN apt-get update && \
-    apt-get -y upgrade && \
-    apt-get -y install --no-install-recommends \
-        libvips-dev \
-        python3 \
-        make \
-        git \
-        g++ \
-        vim
--- a/.devcontainer/devcontainer.json
+++ b/.devcontainer/devcontainer.json
@@ -1,28 +0,0 @@
-{
-    "name": "bonob",
-    "build": { 
-        "dockerfile": "Dockerfile" 
-    },
-    "containerEnv": {
-        // these env vars need to be configured appropriately for your local dev env
-        "BNB_DEV_SONOS_DEVICE_IP": "${localEnv:BNB_DEV_SONOS_DEVICE_IP}",
-        "BNB_DEV_HOST_IP": "${localEnv:BNB_DEV_HOST_IP}",
-        "BNB_DEV_SUBSONIC_URL": "${localEnv:BNB_DEV_SUBSONIC_URL}"
-    },
-    "remoteUser": "node",
-    "forwardPorts": [4534],
-    "features": {
-        "ghcr.io/devcontainers/features/docker-in-docker:2": {
-            "version": "latest",
-            "moby": true
-        }
-    },
-    "customizations": {
-        "vscode": {
-          "extensions": [
-            "esbenp.prettier-vscode",
-            "redhat.vscode-xml"
-        ]
-        }
-    }
-}
--- a/.dockerignore
+++ b/.dockerignore
@@ -1,6 +0,0 @@
-.devcontainer
-.github
-.yarn/cache
-.yarn/install-state.gz
-build
-node_modules
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -15,64 +15,54 @@ jobs:
  build_and_test:
    runs-on: ubuntu-latest
    steps:
-      -
+      - 
        name: Check out the repo
-        uses: actions/checkout@v3
-      -
-        uses: actions/setup-node@v3
+        uses: actions/checkout@v2
+      - 
+        uses: actions/setup-node@v1
        with:
-          node-version: 20
-      -
-        run: npm install
-      -
-        run: npm test
+          node-version: '16'
+      - 
+        run: yarn install
+      - 
+        run: yarn test


  push_to_registry:
-    name: Push Docker image to Docker registries
+    name: Push Docker image to Docker Hub
    needs: build_and_test
    runs-on: ubuntu-latest
    steps:
-      -
+      - 
        name: Check out the repo
-        uses: actions/checkout@v3
+        uses: actions/checkout@v2
        with:
          fetch-depth: 0
      -
        name: Set up QEMU
-        uses: docker/setup-qemu-action@v2
+        uses: docker/setup-qemu-action@v1
      -
        name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v2
+        uses: docker/setup-buildx-action@v1
      -
        name: Docker meta
        id: meta
-        uses: docker/metadata-action@v4
+        uses: docker/metadata-action@v3
        with:
-          images: |
-            simojenki/bonob
-            ghcr.io/simojenki/bonob
+          images: simojenki/bonob
      -
        name: Login to DockerHub
        if: github.event_name != 'pull_request'
-        uses: docker/login-action@v2
+        uses: docker/login-action@v1
        with:
          username: ${{ secrets.DOCKERHUB_USERNAME }}
          password: ${{ secrets.DOCKERHUB_TOKEN }}
-      -
-        name: Log in to GitHub Container registry
-        if: github.event_name != 'pull_request'
-        uses: docker/login-action@v2
-        with:
-          registry: ghcr.io
-          username: ${{ github.actor }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-      -
-        name: Push image
-        uses: docker/build-push-action@v4
+      - 
+        name: Push to Docker Hub
+        uses: docker/build-push-action@v2
        with:
          context: .
          platforms: linux/amd64,linux/arm/v7,linux/arm64
          push: ${{ github.event_name != 'pull_request' }}
          tags: ${{ steps.meta.outputs.tags }}
-          labels: ${{ steps.meta.outputs.labels }}
+          labels: ${{ steps.meta.outputs.labels }}
--- a/.gitignore
+++ b/.gitignore
@@ -2,7 +2,6 @@
 .vscode
 build
 ignore
-.ignore
 node_modules
 .yarn/*
 !.yarn/patches
--- a/.npmrc
+++ b/.npmrc
@@ -1 +0,0 @@
-fetch-timeout=60000
--- a/.nvmrc
+++ b/.nvmrc
@@ -0,0 +1 @@
+16.6.2
--- a/.yarn/releases/yarn-berry.cjs
+++ b/.yarn/releases/yarn-berry.cjs
--- a/.yarnrc.yml
+++ b/.yarnrc.yml
@@ -0,0 +1,3 @@
+nodeLinker: node-modules
+
+yarnPath: .yarn/releases/yarn-berry.cjs
--- a/37
+++ b/37
@@ -1,4 +1,4 @@
-FROM node:20-bullseye-slim as build
+FROM node:16-bullseye as build

 WORKDIR /bonob

@@ -9,13 +9,14 @@ 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 JEST_TIMEOUT=30000
 ENV DEBIAN_FRONTEND=noninteractive

 RUN apt-get update && \
@@ -28,20 +29,13 @@ RUN apt-get update && \
        g++ && \
    apt-get clean && \
    rm -rf /var/lib/apt/lists/* && \
-    npm install && \
-    npm test && \
-    npm run gitinfo && \
-    npm run build && \
-    rm -Rf node_modules && \
-    NODE_ENV=production npm install --omit=dev
+    yarn install --immutable && \
+    yarn gitinfo && \
+    yarn test --no-cache && \
+    yarn build


-FROM node:20-bullseye-slim
-
-LABEL   maintainer="simojenki" \
-        org.opencontainers.image.source="https://github.com/simojenki/bonob" \
-        org.opencontainers.image.description="bonob SONOS SMAPI implementation" \
-        org.opencontainers.image.licenses="GPLv3"
+FROM node:16-bullseye

 ENV BNB_PORT=4534
 ENV DEBIAN_FRONTEND=noninteractive
@@ -52,7 +46,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
@@ -62,10 +56,7 @@ COPY src/Sonoswsdl-1.19.4-20190411.142401-3.wsdl ./src/Sonoswsdl-1.19.4-20190411

 RUN apt-get update && \
    apt-get -y upgrade && \
-    apt-get -y install --no-install-recommends \
-        libvips \
-        tzdata \
-        wget && \
+    apt-get -y install --no-install-recommends libvips tzdata && \
    apt-get clean && \
    rm -rf /var/lib/apt/lists/*

--- a/README.md
+++ b/README.md
@@ -16,33 +16,16 @@ 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 & 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
- Custom players by mime type, allowing custom transcoding rules for different file types
+- Transcoding support for flacs using a specific player for the flac mimeType bonob/sonos

 ## Running

-bonob is packaged as an OCI image to both the docker hub registry and github registry.
-
-ie. 
-```bash
-docker pull docker.io/simojenki/bonob
-```
-or
-```bash
-docker pull ghcr.io/simojenki/bonob
-```
-
-tag | description
--- | ---
-latest | Latest release, intended to be stable
-master | Lastest build from master, probably works, however is currently under test
-vX.Y.Z | Fixed release versions from tags, for those that want to pin to a specific release
-
+bonob is distributed via docker and can be run in a number of ways

 ### Full sonos device auto-discovery and auto-registration using docker --network host

@@ -143,8 +126,8 @@ services:
      # ip address of your machine running bonob
      BNB_URL: http://192.168.1.111:4534  
      BNB_SECRET: changeme
-      BNB_SONOS_AUTO_REGISTER: "true"
-      BNB_SONOS_DEVICE_DISCOVERY: "true"
+      BNB_SONOS_AUTO_REGISTER: true
+      BNB_SONOS_DEVICE_DISCOVERY: true
      BNB_SONOS_SERVICE_ID: 246
      # ip address of one of your sonos devices
      BNB_SONOS_SEED_HOST: 192.168.1.121
@@ -163,16 +146,14 @@ BNB_PORT | 4534 | Default http port for bonob to listen on
 BNB_URL | http://$(hostname):4534 | URL (including path) for bonob so that sonos devices can communicate. **This must be either the public IP or DNS entry of the bonob instance so that the sonos devices can communicate with it.**
 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_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.
 BNB_SONOS_SEED_HOST | undefined | sonos device seed host for discovery, or ommitted for for auto-discovery
 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. <P>Must specify the source mime type and optionally the transcoded mime type. <p>For example; <p>If you want to simply re-encode some flacs, then you could specify just "audio/flac".  <p>However; <p>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>Disclaimer: Getting this configuration wrong will cause sonos to refuse to play your music, by all means experiment, however know that this may well break your setup.
-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_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 as are sourced externally.  ie. Navidrome provides spotify URLs
 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
 BNB_ICON_FOREGROUND_COLOR | undefined | Icon foreground color in sonos app, must be a valid [svg color](https://www.december.com/html/spec/colorsvg.html)
@@ -207,33 +188,24 @@ Generally speaking you will not need to do this very often.  However on occassio

 Service should now be registered and everything should work as expected.

-## Multiple registrations within a single household.
-
-It's possible to register multiple Subsonic clone users for the bonob service in Sonos.
-Basically this consist of repeating the Sonos app ["Add a service"](#initialising-service-within-sonos-app) steps for each additional user.
-Afterwards the Sonos app displays a dropdown underneath the service, allowing to switch between users.
-
 ## Implementing a different music source other than a subsonic clone

 - Implement the MusicService/MusicLibrary interface
 - Startup bonob with your new implementation.

-## Transcoding
+## A note on transcoding

-### Transcode everything
+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).

-The simplest transcoding solution is to simply change the player ('bonob') in your subsonic server to transcode all content to something sonos supports (ie. mp3 & flac)
+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
+### Audio File type specific transcoding options within Subsonic

-Disclaimer: The following configuration is more complicated, and if you get the configuration wrong sonos will refuse to play your content.
-
-In some situations you may wish to have different 'Players' within your 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;

 ```bash
-# This is equivalent to setting BNB_SUBSONIC_CUSTOM_CLIENTS="audio/flac>audio/flac"
 BNB_SUBSONIC_CUSTOM_CLIENTS="audio/flac"
 ```

@@ -249,16 +221,7 @@ ffmpeg -i %s -af aformat=sample_fmts=s16|s32:sample_rates=8000|11025|16000|22050
 ffmpeg -i %s -af aformat=sample_fmts=s16:sample_rates=8000|11025|16000|22050|24000|32000|44100|48000 -f flac -
 ```

-Alternatively perhaps you have some aac (audio/mpeg) files that will not play in sonos (ie. voice recordings from an iPhone), however you do not want to transcode all everything, just those audio/mpeg files.  Let's say you want to transcode them to mp3s, you could set the following;
-
-```bash
-BNB_SUBSONIC_CUSTOM_CLIENTS="audio/mpeg>audio/mp3"
-```
-
-And then configure the 'bonob+audio/mpeg' player in your subsonic server.
-
-
-## Changing Icon colors
+### Changing Icon colors

 ```bash
 -e BNB_ICON_FOREGROUND_COLOR=white \
@@ -288,7 +251,6 @@ And then configure the 'bonob+audio/mpeg' player in your subsonic server.

 ![Spotify-ish](https://github.com/simojenki/bonob/blob/master/docs/images/spotify-ish.png?raw=true)

-
 ## Credits

 - Icons courtesy of: [Navidrome](https://www.navidrome.org/), [Vectornator](https://www.vectornator.io/icons), and @jicho
--- a/etc/docker-compose.yaml
+++ b/etc/docker-compose.yaml
@@ -27,8 +27,8 @@ services:
      BNB_URL: http://192.168.1.111:4534  
      BNB_SECRET: changeme
      BNB_SONOS_SERVICE_ID: 246 
-      BNB_SONOS_AUTO_REGISTER: "true"
-      BNB_SONOS_DEVICE_DISCOVERY: "true"
+      BNB_SONOS_AUTO_REGISTER: true
+      BNB_SONOS_DEVICE_DISCOVERY: true
      # ip address of one of your sonos devices
      BNB_SONOS_SEED_HOST: 192.168.1.121
      BNB_SUBSONIC_URL: http://navidrome:4533
--- a/jest.config.js
+++ b/jest.config.js
@@ -5,6 +5,5 @@ module.exports = {
  modulePathIgnorePatterns: [
    '<rootDir>/node_modules',
    '<rootDir>/build',
-  ],
-  testTimeout: Number.parseInt(process.env["JEST_TIMEOUT"] || "5000")
+    ],
 };
--- a/package-lock.json
+++ b/package-lock.json
--- a/package.json
+++ b/package.json
@@ -6,70 +6,64 @@
  "author": "simojenki <simojenki@users.noreply.github.com>",
  "license": "GPL-3.0-only",
  "dependencies": {
-    "@svrooij/sonos": "^2.6.0-beta.7",
-    "@types/express": "^4.17.21",
-    "@types/fs-extra": "^11.0.4",
-    "@types/jsonwebtoken": "^9.0.5",
-    "@types/jws": "^3.2.9",
-    "@types/morgan": "^1.9.9",
-    "@types/node": "^20.11.5",
-    "@types/randomstring": "^1.1.11",
-    "@types/underscore": "^1.11.15",
-    "@types/uuid": "^9.0.7",
-    "@types/xmldom": "0.1.34",
-    "axios": "^1.6.5",
-    "dayjs": "^1.11.10",
-    "eta": "^2.2.0",
-    "express": "^4.18.2",
-    "fp-ts": "^2.16.2",
-    "fs-extra": "^11.2.0",
-    "jsonwebtoken": "^9.0.2",
+    "@svrooij/sonos": "^2.4.0",
+    "@types/express": "^4.17.13",
+    "@types/fs-extra": "^9.0.13",
+    "@types/jsonwebtoken": "^8.5.5",
+    "@types/jws": "^3.2.4",
+    "@types/morgan": "^1.9.3",
+    "@types/node": "^16.7.13",
+    "@types/randomstring": "^1.1.8",
+    "@types/sharp": "^0.28.6",
+    "@types/underscore": "^1.11.3",
+    "@types/uuid": "^8.3.1",
+    "axios": "^0.21.4",
+    "dayjs": "^1.10.6",
+    "eta": "^1.12.3",
+    "express": "^4.17.1",
+    "fp-ts": "^2.11.1",
+    "fs-extra": "^10.0.0",
+    "jsonwebtoken": "^8.5.1",
    "jws": "^4.0.0",
-    "libxmljs2": "^0.33.0",
+    "libxmljs2": "^0.28.0",
    "morgan": "^1.10.0",
-    "node-html-parser": "^6.1.12",
-    "randomstring": "^1.3.0",
-    "sharp": "^0.33.2",
-    "soap": "^1.0.0",
-    "ts-md5": "^1.3.1",
-    "typescript": "^5.3.3",
-    "underscore": "^1.13.6",
+    "node-html-parser": "^4.1.4",
+    "randomstring": "^1.2.1",
+    "sharp": "^0.29.1",
+    "soap": "^0.42.0",
+    "ts-md5": "^1.2.9",
+    "typescript": "^4.4.2",
+    "underscore": "^1.13.1",
    "urn-lib": "^2.0.0",
-    "uuid": "^9.0.1",
-    "winston": "^3.11.0",
-    "xmldom-ts": "^0.3.1"
+    "uuid": "^8.3.2",
+    "winston": "^3.3.3"
  },
  "devDependencies": {
-    "@types/chai": "^4.3.11",
-    "@types/jest": "^29.5.11",
-    "@types/mocha": "^10.0.6",
-    "@types/supertest": "^6.0.2",
-    "@types/tmp": "^0.2.6",
-    "chai": "^5.0.0",
-    "get-port": "^7.0.0",
-    "image-js": "^0.35.5",
-    "jest": "^29.7.0",
-    "nodemon": "^3.0.3",
-    "supertest": "^6.3.4",
+    "@types/chai": "^4.2.21",
+    "@types/jest": "^27.0.1",
+    "@types/mocha": "^9.0.0",
+    "@types/supertest": "^2.0.11",
+    "@types/tmp": "^0.2.1",
+    "chai": "^4.3.4",
+    "get-port": "^5.1.1",
+    "image-js": "^0.33.0",
+    "jest": "^27.1.0",
+    "nodemon": "^2.0.12",
+    "supertest": "^6.1.6",
    "tmp": "^0.2.1",
-    "ts-jest": "^29.1.2",
+    "ts-jest": "^27.0.5",
    "ts-mockito": "^2.6.1",
-    "ts-node": "^10.9.2",
+    "ts-node": "^10.2.1",
    "xmldom-ts": "^0.3.1",
    "xpath-ts": "^1.3.13"
  },
-  "overrides": {
-    "axios-ntlm": "npm:dry-uninstall",
-    "axios": "$axios"
-  },
  "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",
-    "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",
-    "register-dev": "ts-node ./src/register.ts http://${BNB_DEV_HOST_IP}:4534",
+    "dev": "BNB_DEBUG=true BNB_SCROBBLE_TRACKS=false BNB_REPORT_NOW_PLAYING=false BNB_ICON_FOREGROUND_COLOR=white BNB_ICON_BACKGROUND_COLOR=darkgrey BNB_SONOS_SERVICE_NAME=z_bonobDev BNB_SONOS_DEVICE_DISCOVERY=true nodemon -V ./src/app.ts",
+    "devr": "BNB_DEBUG=true BNB_SCROBBLE_TRACKS=false BNB_REPORT_NOW_PLAYING=false BNB_ICON_FOREGROUND_COLOR=white BNB_ICON_BACKGROUND_COLOR=darkgrey BNB_SONOS_SERVICE_NAME=z_bonobDev BNB_SONOS_DEVICE_DISCOVERY=true BNB_SONOS_AUTO_REGISTER=true nodemon -V ./src/app.ts",
+    "register-dev": "ts-node ./src/register.ts http://$(hostname):4534",
    "test": "jest",
-    "testw": "jest --watch",
    "gitinfo": "git describe --tags > .gitinfo"
  }
 }
--- a/src/app.ts
+++ b/src/app.ts
@@ -4,11 +4,9 @@ import server from "./server";
 import logger from "./logger";

 import {
-  axiosImageFetcher,
-  cachingImageFetcher,
+  appendMimeTypeToClientFor,
+  DEFAULT,
  Subsonic,
-  TranscodingCustomPlayers,
-  NO_CUSTOM_PLAYERS
 } from "./subsonic";
 import { InMemoryAPITokens, sha256 } from "./api_tokens";
 import { InMemoryLinkCodes } from "./link_codes";
@@ -17,6 +15,7 @@ import sonos, { bonobService } from "./sonos";
 import { MusicService } from "./music_service";
 import { SystemClock } from "./clock";
 import { JWTSmapiLoginTokens } from "./smapi_auth";
+import { axiosImageFetcher, cachingImageFetcher } from "./images";

 const config = readConfig();
 const clock = SystemClock;
@@ -32,9 +31,10 @@ const bonob = bonobService(

 const sonosSystem = sonos(config.sonos.discovery);

-const customPlayers = config.subsonic.customClientsFor
-  ? TranscodingCustomPlayers.from(config.subsonic.customClientsFor)
-  : NO_CUSTOM_PLAYERS;
+// todo: just pass in the customClientsForStringArray into subsonic and make it sort it out.
+const streamUserAgent = config.subsonic.customClientsFor
+  ? appendMimeTypeToClientFor(config.subsonic.customClientsFor.split(","))
+  : 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
 );

@@ -88,14 +88,14 @@ const app = server(
    clock,
    iconColors: config.icons,
    applyContextPath: true,
-    logRequests: config.logRequests,
+    logRequests: true,
    version,
    smapiAuthTokens: new JWTSmapiLoginTokens(clock, config.secret, config.authTimeout),
    externalImageResolver: artistImageFetcher
  }
 );

-const expressServer = app.listen(config.port, () => {
+app.listen(config.port, () => {
  logger.info(`Listening on ${config.port} available @ ${config.bonobUrl}`);
 });

@@ -113,15 +113,6 @@ if (config.sonos.autoRegister) {
      logger.info(`Found device ${d.name}(${d.group}) @ ${d.ip}:${d.port}`);
    });
  });
-};
-
-process.on('SIGTERM', () => {
-  logger.info('SIGTERM signal received: closing HTTP server');
-  expressServer.close(() => {
-    logger.info('HTTP server closed');
-  });
-  process.exit(0);
-});
-
+}

 export default app;
--- a/src/config.ts
+++ b/src/config.ts
@@ -85,7 +85,6 @@ export default function () {
        validationPattern: COLOR,
      }),
    },
-    logRequests: bnbEnvVar<boolean>("SERVER_LOG_REQUESTS", { default: false, parser: asBoolean }),
    sonos: {
      serviceName: bnbEnvVar<string>("SONOS_SERVICE_NAME", { default: "bonob" })!,
      discovery: {
@@ -98,7 +97,7 @@ export default function () {
      sid: bnbEnvVar<number>("SONOS_SERVICE_ID", { default: 246, parser: asInt }),
    },
    subsonic: {
-      url: url(bnbEnvVar("SUBSONIC_URL", { legacy: ["BONOB_NAVIDROME_URL"], default: `http://${hostname()}:4533` })!),
+      url: bnbEnvVar("SUBSONIC_URL", { legacy: ["BONOB_NAVIDROME_URL"], default: `http://${hostname()}:4533` })!,
      customClientsFor: bnbEnvVar<string>("SUBSONIC_CUSTOM_CLIENTS", { legacy: ["BONOB_NAVIDROME_CUSTOM_CLIENTS"] }),
      artistImageCache: bnbEnvVar<string>("SUBSONIC_ARTIST_IMAGE_CACHE"),
    },
--- a/src/http.ts
+++ b/src/http.ts
@@ -0,0 +1,67 @@
+import {
+  AxiosPromise,
+  AxiosRequestConfig,
+  Method,
+  ResponseType,
+} from "axios";
+
+// todo: do i need this anymore?
+export interface Http {
+  (config: AxiosRequestConfig): AxiosPromise<any>;
+}
+export interface Http2 extends Http {
+  with: (params: Partial<RequestParams>) => Http2;
+}
+
+export type RequestParams = {
+  baseURL: string;
+  url: string;
+  params: any;
+  headers: any;
+  responseType: ResponseType;
+  method: Method;
+};
+
+const wrap = (http2: Http2, params: Partial<RequestParams>): Http2 => {
+  const f = ((config: AxiosRequestConfig) => http2(merge(params, config))) as Http2;
+  f.with = (params: Partial<RequestParams>) => wrap(f, params);
+  return f;
+};
+
+export const http2From = (http: Http): Http2 => {
+  const f = ((config: AxiosRequestConfig) => http(config)) as Http2;
+  f.with = (defaults: Partial<RequestParams>) => wrap(f, defaults);
+  return f;
+}
+
+const merge = (
+  defaults: Partial<RequestParams>,
+  config: AxiosRequestConfig
+) => {
+  let toApply = {
+    ...defaults,
+    ...config,
+  };
+  if (defaults.params) {
+    toApply = {
+      ...toApply,
+      params: {
+        ...defaults.params,
+        ...config.params,
+      },
+    };
+  }
+  if (defaults.headers) {
+    toApply = {
+      ...toApply,
+      headers: {
+        ...defaults.headers,
+        ...config.headers,
+      },
+    };
+  }
+  return toApply;
+};
+
+export const http =
+  (base: Http, defaults: Partial<RequestParams>): Http => (config: AxiosRequestConfig) => base(merge(defaults, config));
--- a/src/i8n.ts
+++ b/src/i8n.ts
@@ -4,12 +4,11 @@ import { option as O } from "fp-ts";
 import _ from "underscore";

 export type LANG = "en-US" | "da-DK" | "de-DE" | "es-ES" | "fr-FR" | "it-IT" | "ja-JP" | "nb-NO" | "nl-NL" | "pt-BR" | "sv-SE" | "zh-CN"
-export type SUPPORTED_LANG = "en-US" | "da-DK" | "fr-FR" | "nl-NL";
+export type SUPPORTED_LANG = "en-US" | "nl-NL";
 export type KEY =
  | "AppLinkMessage"
  | "artists"
  | "albums"
-  | "internetRadio"  
  | "playlists"
  | "genres"
  | "random"
@@ -52,7 +51,6 @@ const translations: Record<SUPPORTED_LANG, Record<KEY, string>> = {
    AppLinkMessage: "Linking sonos with $BNB_SONOS_SERVICE_NAME",
    artists: "Artists",
    albums: "Albums",
-    internetRadio: "Internet Radio",
    tracks: "Tracks",
    playlists: "Playlists",
    genres: "Genres",
@@ -90,95 +88,10 @@ const translations: Record<SUPPORTED_LANG, Record<KEY, string>> = {
    LOVE: "Love",
    LOVE_SUCCESS: "Track loved"
  },
-  "da-DK": {
-    AppLinkMessage: "Forbinder Sonos med $BNB_SONOS_SERVICE_NAME",
-    artists: "Kunstnere",
-    albums: "Album",
-    internetRadio: "Internet Radio",
-    tracks: "Numre",
-    playlists: "Afspilningslister",
-    genres: "Genre",
-    random: "Tilfældig",
-    topRated: "Højst vurderet",
-    recentlyAdded: "Senest tilføjet",
-    recentlyPlayed: "Senest afspillet",
-    mostPlayed: "Flest afspilninger",
-    success: "Succes",
-    failure: "Fejl",
-    expectedConfig: "Forventet konfiguration",
-    existingServiceConfig: "Eksisterende tjeneste konfiguration",
-    noExistingServiceRegistration: "Ingen eksisterende tjeneste registrering",
-    register: "Registrer",
-    removeRegistration: "Fjern registrering",
-    devices: "Enheder",
-    services: "Tjenester",
-    login: "Log på",
-    logInToBonob: "Log på $BNB_SONOS_SERVICE_NAME",
-    username: "Brugernavn",
-    password: "Adgangskode",
-    successfullyRegistered: "Registreret med succes",
-    registrationFailed: "Registrering fejlede!",
-    successfullyRemovedRegistration: "Registrering fjernet med succes",
-    failedToRemoveRegistration: "FJernelse af registrering fejlede!",
-    invalidLinkCode: "Ugyldig linkCode!",
-    loginSuccessful: "Log på succes!",
-    loginFailed: "Log på fejlede!",
-    noSonosDevices: "Ingen Sonos enheder",
-    favourites: "Favoritter",
-    STAR: "Tilføj stjerne",
-    UNSTAR: "Fjern stjerne",
-    STAR_SUCCESS: "Stjerne tilføjet",
-    UNSTAR_SUCCESS: "Stjerne fjernet",
-    LOVE: "Synes godt om",
-    LOVE_SUCCESS: "Syntes godt om"
-  },
-  "fr-FR": {
-    AppLinkMessage: "Associer Sonos à $BNB_SONOS_SERVICE_NAME",
-    artists: "Artistes",
-    albums: "Albums",
-    internetRadio: "Radio Internet",
-    tracks: "Pistes",
-    playlists: "Playlists",
-    genres: "Genres",
-    random: "Aléatoire",
-    topRated: "Les mieux notés",
-    recentlyAdded: "Récemment ajouté",
-    recentlyPlayed: "Récemment joué",
-    mostPlayed: "Les plus joué",
-    success: "Succès",
-    failure: "Échec",
-    expectedConfig: "Configuration attendue",
-    existingServiceConfig: "La configuration de service existe",
-    noExistingServiceRegistration: "Aucun enregistrement de service existant",
-    register: "Inscription",
-    removeRegistration: "Supprimer l'inscription",
-    devices: "Appareils",
-    services: "Services",
-    login: "Se connecter",
-    logInToBonob: "Se connecter à $BNB_SONOS_SERVICE_NAME",
-    username: "Nom d'utilisateur",
-    password: "Mot de passe",
-    successfullyRegistered: "Connecté avec succès",
-    registrationFailed: "Échec de la connexion !",
-    successfullyRemovedRegistration: "Inscription supprimée avec succès",
-    failedToRemoveRegistration: "Échec de la suppression de l'inscription !",
-    invalidLinkCode: "Code non valide !",
-    loginSuccessful: "Connexion réussie !",
-    loginFailed: "La connexion a échoué !",
-    noSonosDevices: "Aucun appareil Sonos",
-    favourites: "Favoris",
-    STAR: "Suivre",
-    UNSTAR: "Ne plus suivre",
-    STAR_SUCCESS: "Piste suivie",
-    UNSTAR_SUCCESS: "Piste non suivie",
-    LOVE: "Aimer",
-    LOVE_SUCCESS: "Pistes aimée"
-  },
  "nl-NL": {
    AppLinkMessage: "Sonos koppelen aan $BNB_SONOS_SERVICE_NAME",
    artists: "Artiesten",
    albums: "Albums",
-    internetRadio: "Internet Radio",
    tracks: "Nummers",
    playlists: "Afspeellijsten",
    genres: "Genres",
--- a/src/icon.ts
+++ b/src/icon.ts
@@ -163,7 +163,6 @@ export const HOLI_COLORS = [
 export type ICON =
  | "artists"
  | "albums"
-  | "radio"
  | "playlists"
  | "genres"
  | "random"
@@ -241,7 +240,6 @@ const iconFrom = (name: string) =>
 export const ICONS: Record<ICON, SvgIcon> = {
  artists: iconFrom("navidrome-artists.svg"),
  albums: iconFrom("navidrome-all.svg"),
-  radio: iconFrom("navidrome-radio.svg"),
  blank: iconFrom("blank.svg"),
  playlists: iconFrom("navidrome-playlists.svg"),
  genres: iconFrom("Theatre-Mask-111172.svg"),
--- a/src/images.ts
+++ b/src/images.ts
@@ -0,0 +1,48 @@
+
+import sharp from "sharp";
+import fse from "fs-extra";
+import path from "path";
+import { Md5 } from "ts-md5/dist/md5";
+import axios from "axios";
+
+import { CoverArt } from "./music_service";
+import { BROWSER_HEADERS } from "./utils";
+
+export type ImageFetcher = (url: string) => Promise<CoverArt | undefined>;
+
+export const cachingImageFetcher =
+  (cacheDir: string, delegate: ImageFetcher) =>
+  async (url: string): Promise<CoverArt | undefined> => {
+    const filename = path.join(cacheDir, `${Md5.hashStr(url)}.png`);
+    return fse
+      .readFile(filename)
+      .then((data) => ({ contentType: "image/png", data }))
+      .catch(() =>
+        delegate(url).then((image) => {
+          if (image) {
+            return sharp(image.data)
+              .png()
+              .toBuffer()
+              .then((png) => {
+                return fse
+                  .writeFile(filename, png)
+                  .then(() => ({ contentType: "image/png", data: png }));
+              });
+          } else {
+            return undefined;
+          }
+        })
+      );
+  };
+
+export const axiosImageFetcher = (url: string): Promise<CoverArt | undefined> =>
+  axios
+    .get(url, {
+      headers: BROWSER_HEADERS,
+      responseType: "arraybuffer",
+    })
+    .then((res) => ({
+      contentType: res.headers["content-type"],
+      data: Buffer.from(res.data, "binary"),
+    }))
+    .catch(() => undefined);
--- a/src/logger.ts
+++ b/src/logger.ts
@@ -6,7 +6,7 @@ export function debugIt<T>(thing: T): T {
 }

 const logger = createLogger({
-    level: process.env["BNB_LOG_LEVEL"] || 'info',
+    level: 'debug',
    format: format.combine(
      format.timestamp({
        format: 'YYYY-MM-DD HH:mm:ss'
--- a/src/music_service.ts
+++ b/src/music_service.ts
@@ -15,7 +15,13 @@ export class AuthFailure extends Error {
  }
 };

+export type IdName = {
+  id: string;
+  name: string;
+};
+
 export type ArtistSummary = {
+  // todo: why can this be undefined?
  id: string | undefined;
  name: string;
  image: BUrn | undefined;
@@ -51,15 +57,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;
@@ -69,16 +70,9 @@ export type Track = {
  rating: Rating;
 };

-export type RadioStation = {
-  id: string,
-  name: string,
-  url: string,
-  homePage?: string
-}
-
 export type Paging = {
-  _index: number;
-  _count: number;
+  _index: number | undefined;
+  _count: number | undefined;
 };

 export type Result<T> = {
@@ -86,9 +80,10 @@ export type Result<T> = {
  total: number;
 };

-export function slice2<T>({ _index, _count }: Paging) {
+export function slice2<T>({ _index, _count }: Partial<Paging> = {}) {
+  const i = _index || 0;
  return (things: T[]): [T[], number] => [
-    things.slice(_index, _index + _count),
+    _count ? things.slice(i, i + _count) : things.slice(i),
    things.length,
  ];
 }
@@ -125,8 +120,7 @@ export const albumToAlbumSummary = (it: Album): AlbumSummary => ({

 export const playlistToPlaylistSummary = (it: Playlist): PlaylistSummary => ({
  id: it.id,
-  name: it.name,
-  coverArt: it.coverArt
+  name: it.name
 })

 export type StreamingHeader = "content-type" | "content-length" | "content-range" | "accept-ranges";
@@ -144,14 +138,17 @@ export type CoverArt = {

 export type PlaylistSummary = {
  id: string,
-  name: string,
-  coverArt?: BUrn | undefined
+  name: string
 }

 export type Playlist = PlaylistSummary & {
  entries: Track[]
 }

+export type Sortable = {
+  sortName: string
+}
+
 export const range = (size: number) => [...Array(size).keys()];

 export const asArtistAlbumPairs = (artists: Artist[]): [Artist, Album][] =>
@@ -166,7 +163,7 @@ export interface MusicService {
 }

 export interface MusicLibrary {
-  artists(q: ArtistQuery): Promise<Result<ArtistSummary>>;
+  artists(q: ArtistQuery): Promise<Result<ArtistSummary & Sortable>>;
  artist(id: string): Promise<Artist>;
  albums(q: AlbumQuery): Promise<Result<AlbumSummary>>;
  album(id: string): Promise<Album>;
@@ -195,6 +192,4 @@ export interface MusicLibrary {
  removeFromPlaylist(playlistId: string, indicies: number[]): Promise<boolean>
  similarSongs(id: string): Promise<Track[]>;
  topSongs(artistId: string): Promise<Track[]>;
-  radioStation(id: string): Promise<RadioStation>
-  radioStations(): Promise<RadioStation[]>
 }
--- a/src/server.ts
+++ b/src/server.ts
@@ -31,14 +31,12 @@ 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 { mask, takeWithRepeats } from "./utils";
 import { parse } from "./burn";
-import { axiosImageFetcher, ImageFetcher } from "./subsonic";
-import {
-  JWTSmapiLoginTokens,
-  SmapiAuthTokens,
-} from "./smapi_auth";
+import { axiosImageFetcher, ImageFetcher } from "./images";
+import { JWTSmapiLoginTokens, SmapiAuthTokens } from "./smapi_auth";

 export const BONOB_ACCESS_TOKEN_HEADER = "bat";

@@ -306,13 +304,13 @@ function server(
      return `<Match propname="rating" value="${value}">
        <Ratings>
          <Rating Id="${ratingAsInt(
-        nextLove
-      )}" AutoSkip="NEVER" OnSuccessStringId="LOVE_SUCCESS" StringId="LOVE">
+            nextLove
+          )}" AutoSkip="NEVER" OnSuccessStringId="LOVE_SUCCESS" StringId="LOVE">
            <Icon Controller="universal" LastModified="${LastModified}" Uri="${loveRatingIcon}" />
          </Rating>
          <Rating Id="${-ratingAsInt(
-        nextStar
-      )}" AutoSkip="NEVER" OnSuccessStringId="STAR_SUCCESS" StringId="STAR">
+            nextStar
+          )}" AutoSkip="NEVER" OnSuccessStringId="STAR_SUCCESS" StringId="STAR">
            <Icon Controller="universal" LastModified="${LastModified}" Uri="${starsRatingIcon}" />
          </Rating>
        </Ratings>
@@ -326,9 +324,9 @@ function server(
        <Match>
          <imageSizeMap>
            ${SONOS_RECOMMENDED_IMAGE_SIZES.map(
-      (size) =>
-        `<sizeEntry size="${size}" substitution="/size/${size}"/>`
-    ).join("")}
+              (size) =>
+                `<sizeEntry size="${size}" substitution="/size/${size}"/>`
+            ).join("")}
          </imageSizeMap>
        </Match>
      </PresentationMap>
@@ -337,9 +335,9 @@ function server(
          <browseIconSizeMap>
              <sizeEntry size="0" substitution="/size/legacy"/>
              ${SONOS_RECOMMENDED_IMAGE_SIZES.map(
-      (size) =>
-        `<sizeEntry size="${size}" substitution="/size/${size}"/>`
-    ).join("")}
+                (size) =>
+                  `<sizeEntry size="${size}" substitution="/size/${size}"/>`
+              ).join("")}
            </browseIconSizeMap>
        </Match>
      </PresentationMap>
@@ -373,26 +371,31 @@ function server(
    const id = req.params["id"]!;
    const trace = uuid();

-    logger.debug(
+    logger.info(
      `${trace} bnb<- ${req.method} ${req.path}?${JSON.stringify(
        req.query
-      )}, headers=${JSON.stringify({ ...req.headers, "bnbt": "*****", "bnbk": "*****" })}`
+      )}, headers=${JSON.stringify(mask(req.headers, ["bnbt", "bnbk"]))}`
    );

    const serviceToken = pipe(
      E.fromNullable("Missing bnbt header")(req.headers["bnbt"] as string),
-      E.chain(token => pipe(
-        E.fromNullable("Missing bnbk header")(req.headers["bnbk"] as string),
-        E.map(key => ({ token, key }))
-      )),
+      E.chain((token) =>
+        pipe(
+          E.fromNullable("Missing bnbk header")(req.headers["bnbk"] as string),
+          E.map((key) => ({ token, key }))
+        )
+      ),
      E.chain((auth) =>
        pipe(
          smapiAuthTokens.verify(auth),
          E.mapLeft((_) => "Auth token failed to verify")
        )
      ),
-      E.getOrElseW(() => undefined)
-    )
+      E.getOrElseW((e: string) => {
+        logger.error(`Failed to get serviceToken for stream: ${e}`);
+        return undefined;
+      })
+    );

    if (!serviceToken) {
      return res.status(401).send();
@@ -405,17 +408,13 @@ function server(
              trackId: id,
              range: req.headers["range"] || undefined,
            })
-            .then((stream) => {
-              res.on('close', () => {
-                stream.stream.destroy()
-              });
-              return stream;
-            })
            .then((stream) => ({ musicLibrary: it, stream }))
        )
        .then(({ musicLibrary, stream }) => {
-          logger.debug(
-            `${trace} bnb<- stream response from music service for ${id}, status=${stream.status}, headers=(${JSON.stringify(stream.headers)})`
+          logger.info(
+            `${trace} bnb<- stream response from music service for ${id}, status=${
+              stream.status
+            }, headers=(${JSON.stringify(stream.headers)})`
          );

          const sonosisfyContentType = (contentType: string) =>
@@ -438,8 +437,10 @@ function server(
            sendStream: boolean;
            nowPlaying: boolean;
          }) => {
-            logger.debug(
-              `${trace} bnb-> ${req.path}, status=${status}, headers=${JSON.stringify(headers)}`
+            logger.info(
+              `${trace} bnb-> ${
+                req.path
+              }, status=${status}, headers=${JSON.stringify(headers)}`
            );
            (nowPlaying
              ? musicLibrary.nowPlaying(id)
@@ -451,8 +452,8 @@ function server(
                .forEach(([header, value]) => {
                  res.setHeader(header, value!);
                });
-              if (sendStream) stream.stream.pipe(filter).pipe(res)
-              else res.send()
+              if (sendStream) stream.stream.pipe(filter).pipe(res);
+              else res.send();
            });
          };

@@ -514,15 +515,15 @@ function server(
      const spec =
        size == "legacy"
          ? {
-            mimeType: "image/png",
-            responseFormatter: (svg: string): Promise<Buffer | string> =>
-              sharp(Buffer.from(svg)).resize(80).png().toBuffer(),
-          }
+              mimeType: "image/png",
+              responseFormatter: (svg: string): Promise<Buffer | string> =>
+                sharp(Buffer.from(svg)).resize(80).png().toBuffer(),
+            }
          : {
-            mimeType: "image/svg+xml",
-            responseFormatter: (svg: string): Promise<Buffer | string> =>
-              Promise.resolve(svg),
-          };
+              mimeType: "image/svg+xml",
+              responseFormatter: (svg: string): Promise<Buffer | string> =>
+                Promise.resolve(svg),
+            };

      return Promise.resolve(
        icon
@@ -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) => {
-        if (urn.system == "external") {
-          return serverOpts.externalImageResolver(urn.resource);
-        } else {
-          return musicLibrary.coverArt(urn, size);
-        }
-      })
-      .then((coverArt) => {
-        if(coverArt) {
+      .then((musicLibrary) =>
+        Promise.all(
+          urns.map((it) => {
+            if (it.system == "external") {
+              return serverOpts.externalImageResolver(it.resource);
+            } else {
+              return musicLibrary.coverArt(it, size);
+            }
+          })
+        )
+      )
+      .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();
--- a/src/smapi.ts
+++ b/src/smapi.ts
@@ -17,9 +17,9 @@ import {
  Genre,
  MusicService,
  Playlist,
-  RadioStation,
  Rating,
  slice2,
+  Sortable,
  Track,
 } from "./music_service";
 import { APITokens } from "./api_tokens";
@@ -27,7 +27,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,
@@ -254,7 +254,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,
@@ -263,9 +263,29 @@ const playlist = (bonobUrl: URLBuilder, playlist: Playlist) => ({
  },
 });

-export const coverArtURI = (
+export const playlistAlbumArtURL = (
  bonobUrl: URLBuilder,
-  { coverArt }: { coverArt?: BUrn | undefined }
+  playlist: Playlist
+) => {
+  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,
@@ -283,6 +303,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;

@@ -292,7 +327,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,
@@ -300,17 +335,10 @@ export const album = (bonobUrl: URLBuilder, album: AlbumSummary) => ({
  // canAddToFavorites: true
 });

-export const internetRadioStation = (station: RadioStation) => ({
-  itemType: "stream",
-  id: `internetRadioStation:${station.id}`,
-  title: station.name,
-  mimeType: "audio/mpeg",
-});
-
 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: {
@@ -318,7 +346,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,
@@ -336,9 +364,57 @@ 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(),
 });

+export const scrollIndicesFrom = (things: Sortable[]) => {
+  const indicies: Record<string, number | undefined> = {
+    "A":undefined,
+    "B":undefined,
+    "C":undefined,
+    "D":undefined,
+    "E":undefined,
+    "F":undefined,
+    "G":undefined,
+    "H":undefined,
+    "I":undefined,
+    "J":undefined,
+    "K":undefined,
+    "L":undefined,
+    "M":undefined,
+    "N":undefined,
+    "O":undefined,
+    "P":undefined,
+    "Q":undefined,
+    "R":undefined,
+    "S":undefined,
+    "T":undefined,
+    "U":undefined,
+    "V":undefined,
+    "W":undefined,
+    "X":undefined,
+    "Y":undefined,
+    "Z":undefined,
+  }
+  const upperNames = things.map(thing => thing.sortName.toUpperCase());
+  for(var i = 0; i < upperNames.length; i++) {
+    const char = upperNames[i]![0]!;
+    if(Object.keys(indicies).includes(char) && indicies[char] == undefined) {
+      indicies[char] = i;
+    }
+  }
+  var lastIndex = 0;
+  const result: string[] = [];
+  Object.entries(indicies).forEach(([letter, index]) => {
+    result.push(letter);
+    if(index) {
+      lastIndex = index;
+    }
+    result.push(`${lastIndex}`);
+  })
+  return result.join(",")
+}
+
 function splitId<T>(id: string) {
  const [type, typeId] = id.split(":");
  return (t: T) => ({
@@ -434,7 +510,9 @@ function bindSmapiSoapServiceToExpress(
            },
          },
        })),
-        TE.getOrElse(() => T.of(SMAPI_FAULT_LOGIN_UNAUTHORIZED))
+        TE.getOrElse(() =>
+          T.of(SMAPI_FAULT_LOGIN_UNAUTHORIZED)
+        )
      )();
    } else {
      throw authOrFail.toSmapiFault();
@@ -493,38 +571,27 @@ function bindSmapiSoapServiceToExpress(
          ) =>
            login(soapyHeaders?.credentials)
              .then(splitId(id))
-              .then(({ musicLibrary, credentials, type, typeId }) => {
-                switch (type) {
-                  case "internetRadioStation":
-                    return musicLibrary.radioStation(typeId).then((it) => ({
-                      getMediaURIResult: it.url,
-                    }));
-                  case "track":
-                    return {
-                      getMediaURIResult: bonobUrl
-                        .append({
-                          pathname: `/stream/${type}/${typeId}`,
-                        })
-                        .href(),
-                      httpHeaders: [
-                        {
-                          httpHeader: {
-                            header: "bnbt",
-                            value: credentials.loginToken.token,
-                          },
-                        },
-                        {
-                          httpHeader: {
-                            header: "bnbk",
-                            value: credentials.loginToken.key,
-                          },
-                        },
-                      ],
-                    };
-                  default:
-                    throw `Unsupported type:${type}`;
-                  }
-              }),
+              .then(({ credentials, type, typeId }) => ({
+                getMediaURIResult: bonobUrl
+                  .append({
+                    pathname: `/stream/${type}/${typeId}`,
+                  })
+                  .href(),
+                httpHeaders: [
+                  {
+                    httpHeader: {
+                      header: "bnbt",
+                      value: credentials.loginToken.token,
+                    },
+                  },
+                  {
+                    httpHeader: {
+                      header: "bnbk",
+                      value: credentials.loginToken.key,
+                    },
+                  },
+                ],
+              })),
          getMediaMetadata: async (
            { id }: { id: string },
            _,
@@ -532,20 +599,11 @@ function bindSmapiSoapServiceToExpress(
          ) =>
            login(soapyHeaders?.credentials)
              .then(splitId(id))
-              .then(async ({ musicLibrary, apiKey, type, typeId }) => {
-                switch (type) {
-                  case "internetRadioStation":
-                    return musicLibrary.radioStation(typeId).then((it) => ({
-                      getMediaMetadataResult: internetRadioStation(it),
-                    }));
-                  case "track":
-                    return musicLibrary.track(typeId!).then((it) => ({
-                      getMediaMetadataResult: track(urlWithToken(apiKey), it),
-                    }));
-                  default:
-                    throw `Unsupported type:${type}`;
-                }
-              }),
+              .then(async ({ musicLibrary, apiKey, typeId }) =>
+                musicLibrary.track(typeId!).then((it) => ({
+                  getMediaMetadataResult: track(urlWithToken(apiKey), it),
+                }))
+              ),
          search: async (
            { id, term }: { id: string; term: string },
            _,
@@ -698,6 +756,7 @@ function bindSmapiSoapServiceToExpress(
                          title: lang("artists"),
                          albumArtURI: iconArtURI(bonobUrl, "artists").href(),
                          itemType: "container",
+                          canScroll: true,
                        },
                        {
                          id: "albums",
@@ -767,12 +826,6 @@ function bindSmapiSoapServiceToExpress(
                          ).href(),
                          itemType: "albumList",
                        },
-                        {
-                          id: "internetRadio",
-                          title: lang("internetRadio"),
-                          albumArtURI: iconArtURI(bonobUrl, "radio").href(),
-                          itemType: "stream",
-                        },
                      ],
                    });
                  case "search":
@@ -847,19 +900,6 @@ function bindSmapiSoapServiceToExpress(
                      type: "mostPlayed",
                      ...paging,
                    });
-                  case "internetRadio":
-                    return musicLibrary
-                      .radioStations()
-                      .then(slice2(paging))
-                      .then(([page, total]) =>
-                        getMetadataResult({
-                          mediaMetadata: page.map((it) =>
-                            internetRadioStation(it)
-                          ),
-                          index: paging._index,
-                          total,
-                        })
-                      );
                  case "genres":
                    return musicLibrary
                      .genres()
@@ -878,16 +918,9 @@ function bindSmapiSoapServiceToExpress(
                      .playlists()
                      .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: [],
-                            };
-                          })
+                          it.map((playlist) =>
+                            musicLibrary.playlist(playlist.id)
+                          )
                        )
                      )
                      .then(slice2(paging))
@@ -919,15 +952,15 @@ function bindSmapiSoapServiceToExpress(
                      .artist(typeId!)
                      .then((artist) => artist.albums)
                      .then(slice2(paging))
-                      .then(([page, total]) =>
-                        getMetadataResult({
+                      .then(([page, total]) => {
+                        return getMetadataResult({
                          mediaCollection: page.map((it) =>
                            album(urlWithToken(apiKey), it)
                          ),
                          index: paging._index,
                          total,
-                        })
-                      );
+                        });
+                      });
                  case "relatedArtists":
                    return musicLibrary
                      .artist(typeId!)
@@ -962,6 +995,23 @@ function bindSmapiSoapServiceToExpress(
                    throw `Unsupported getMetadata id=${id}`;
                }
              }),
+          getScrollIndices: async (
+            { id }: { id: string },
+            _,
+            soapyHeaders: SoapyHeaders
+          ) => {
+            switch(id) {
+              case "artists": {
+                return login(soapyHeaders?.credentials)
+                  .then(({ musicLibrary }) => musicLibrary.artists({ _index: 0, _count: undefined }))
+                  .then((artists) => ({
+                    getScrollIndicesResult: scrollIndicesFrom(artists.results)
+                  }))
+                }
+              default: 
+                throw `Unsupported getScrollIndices id=${id}`;
+            }
+          },
          createContainer: async (
            { title, seedId }: { title: string; seedId: string | undefined },
            _,
@@ -1083,9 +1133,8 @@ function bindSmapiSoapServiceToExpress(

  soapyService.log = (type, data) => {
    switch (type) {
-      // routing all soap info messages to debug so less noisy
      case "info":
-        logger.debug({ level: "info", data });
+        logger.info({ level: "info", data });
        break;
      case "warn":
        logger.warn({ level: "warn", data });
--- a/src/sonos.ts
+++ b/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 [];
      });
  };
--- a/src/subsonic.ts
+++ b/src/subsonic.ts
--- a/src/subsonic/generic.ts
+++ b/src/subsonic/generic.ts
@@ -0,0 +1,770 @@
+import { option as O, taskEither as TE } from "fp-ts";
+import * as A from "fp-ts/Array";
+import { pipe } from "fp-ts/lib/function";
+import { ordString } from "fp-ts/lib/Ord";
+import { inject } from "underscore";
+import _ from "underscore";
+
+import logger from "../logger";
+import { b64Decode, b64Encode } from "../b64";
+import { assertSystem, BUrn, format } from "../burn";
+
+import {
+  Album,
+  AlbumQuery,
+  AlbumQueryType,
+  AlbumSummary,
+  Artist,
+  ArtistQuery,
+  ArtistSummary,
+  AuthFailure,
+  Credentials,
+  Genre,
+  IdName,
+  Rating,
+  Result,
+  slice2,
+  Sortable,
+  Track,
+} from "../music_service";
+import {
+  DODGY_IMAGE_NAME,
+  StreamClientApplication,
+  SubsonicCredentials,
+  SubsonicMusicLibrary,
+  SubsonicResponse,
+  USER_AGENT,
+} from ".";
+import axios from "axios";
+import { asURLSearchParams } from "../utils";
+import { artistSummaryFromNDArtist, NDArtist } from "./navidrome";
+import { Http2, RequestParams } from "../http";
+import { client } from "./subsonic_http";
+
+type album = {
+  id: string;
+  name: string;
+  artist: string | undefined;
+  artistId: string | undefined;
+  coverArt: string | undefined;
+  genre: string | undefined;
+  year: string | undefined;
+};
+
+type artist = {
+  id: string;
+  name: string;
+  albumCount: number;
+  artistImageUrl: string | undefined;
+};
+
+type GetArtistsResponse = SubsonicResponse & {
+  artists: {
+    index: {
+      artist: artist[];
+      name: string;
+    }[];
+  };
+};
+
+type GetAlbumListResponse = SubsonicResponse & {
+  albumList2: {
+    album: album[];
+  };
+};
+
+type genre = {
+  songCount: number;
+  albumCount: number;
+  value: string;
+};
+
+type GetGenresResponse = SubsonicResponse & {
+  genres: {
+    genre: genre[];
+  };
+};
+
+type GetArtistInfoResponse = SubsonicResponse & {
+  artistInfo2: artistInfo;
+};
+
+type GetArtistResponse = SubsonicResponse & {
+  artist: artist & {
+    album: album[];
+  };
+};
+
+export type images = {
+  smallImageUrl: string | undefined;
+  mediumImageUrl: string | undefined;
+  largeImageUrl: string | undefined;
+};
+
+type artistInfo = images & {
+  biography: string | undefined;
+  musicBrainzId: string | undefined;
+  lastFmUrl: string | undefined;
+  similarArtist: artist[];
+};
+
+export type song = {
+  id: string;
+  parent: string | undefined;
+  title: string;
+  album: string | undefined;
+  albumId: string | undefined;
+  artist: string | undefined;
+  artistId: string | undefined;
+  track: number | undefined;
+  year: string | undefined;
+  genre: string | undefined;
+  coverArt: string | undefined;
+  created: string | undefined;
+  duration: number | undefined;
+  bitRate: number | undefined;
+  suffix: string | undefined;
+  contentType: string | undefined;
+  type: string | undefined;
+  userRating: number | undefined;
+  starred: string | undefined;
+};
+
+type GetAlbumResponse = {
+  album: album & {
+    song: song[];
+  };
+};
+
+type playlist = {
+  id: string;
+  name: string;
+};
+
+type GetPlaylistResponse = {
+  playlist: {
+    id: string;
+    name: string;
+    entry: song[];
+  };
+};
+
+type GetPlaylistsResponse = {
+  playlists: { playlist: playlist[] };
+};
+
+type GetSimilarSongsResponse = {
+  similarSongs2: { song: song[] };
+};
+
+type GetTopSongsResponse = {
+  topSongs: { song: song[] };
+};
+
+type GetSongResponse = {
+  song: song;
+};
+
+type Search3Response = SubsonicResponse & {
+  searchResult3: {
+    artist: artist[];
+    album: album[];
+    song: song[];
+  };
+};
+
+const AlbumQueryTypeToSubsonicType: Record<AlbumQueryType, string> = {
+  alphabeticalByArtist: "alphabeticalByArtist",
+  alphabeticalByName: "alphabeticalByName",
+  byGenre: "byGenre",
+  random: "random",
+  recentlyPlayed: "recent",
+  mostPlayed: "frequent",
+  recentlyAdded: "newest",
+  favourited: "starred",
+  starred: "highest",
+};
+
+export const isValidImage = (url: string | undefined) =>
+  url != undefined && !url.endsWith(DODGY_IMAGE_NAME);
+
+const artistIsInLibrary = (artistId: string | undefined) =>
+  artistId != undefined && artistId != "-1";
+
+const coverArtURN = (coverArt: string | undefined): BUrn | undefined =>
+  pipe(
+    coverArt,
+    O.fromNullable,
+    O.map((it: string) => ({ system: "subsonic", resource: `art:${it}` })),
+    O.getOrElseW(() => undefined)
+  );
+
+// todo: is this the right place for this??
+export const artistImageURN = (
+  spec: Partial<{
+    artistId: string | undefined;
+    artistImageURL: string | undefined;
+  }>
+): BUrn | undefined => {
+  const deets = {
+    artistId: undefined,
+    artistImageURL: undefined,
+    ...spec,
+  };
+  if (deets.artistImageURL && isValidImage(deets.artistImageURL)) {
+    return {
+      system: "external",
+      resource: deets.artistImageURL,
+    };
+  } else if (artistIsInLibrary(deets.artistId)) {
+    return {
+      system: "subsonic",
+      resource: `art:${deets.artistId!}`,
+    };
+  } else {
+    return undefined;
+  }
+};
+
+export const asTrack = (album: Album, song: song): Track => ({
+  id: song.id,
+  name: song.title,
+  mimeType: song.contentType!,
+  duration: song.duration || 0,
+  number: song.track || 0,
+  genre: maybeAsGenre(song.genre),
+  coverArt: coverArtURN(song.coverArt),
+  album,
+  artist: {
+    id: song.artistId,
+    name: song.artist ? song.artist : "?",
+    image: song.artistId
+      ? artistImageURN({ artistId: song.artistId })
+      : undefined,
+  },
+  rating: {
+    love: song.starred != undefined,
+    stars:
+      song.userRating && song.userRating <= 5 && song.userRating >= 0
+        ? song.userRating
+        : 0,
+  },
+});
+
+const asAlbum = (album: album): Album => ({
+  id: album.id,
+  name: album.name,
+  year: album.year,
+  genre: maybeAsGenre(album.genre),
+  artistId: album.artistId,
+  artistName: album.artist,
+  coverArt: coverArtURN(album.coverArt),
+});
+
+export const asGenre = (genreName: string) => ({
+  id: b64Encode(genreName),
+  name: genreName,
+});
+
+const maybeAsGenre = (genreName: string | undefined): Genre | undefined =>
+  pipe(
+    genreName,
+    O.fromNullable,
+    O.map(asGenre),
+    O.getOrElseW(() => undefined)
+  );
+
+export class SubsonicGenericMusicLibrary implements SubsonicMusicLibrary {
+  streamClientApplication: StreamClientApplication;
+  subsonicHttp: Http2;
+
+  constructor(
+    streamClientApplication: StreamClientApplication,
+    subsonicHttp: Http2
+  ) {
+    this.streamClientApplication = streamClientApplication;
+    this.subsonicHttp = subsonicHttp;
+  }
+
+  GET = (query: Partial<RequestParams>) => client(this.subsonicHttp)({ method: 'get', ...query });
+
+  flavour = () => "subsonic";
+
+  bearerToken = (_: Credentials): TE.TaskEither<Error, string | undefined> =>
+    TE.right(undefined);
+
+  artists = async (q: ArtistQuery): Promise<Result<ArtistSummary & Sortable>> =>
+    this.getArtists()
+      .then(slice2(q))
+      .then(([page, total]) => ({
+        total,
+        results: page.map((it) => ({
+          id: it.id,
+          name: it.name,
+          sortName: it.name,
+          image: it.image,
+        })),
+      }));
+
+  artist = async (id: string): Promise<Artist> => this.getArtistWithInfo(id);
+
+  albums = async (q: AlbumQuery): Promise<Result<AlbumSummary>> =>
+    this.getAlbumList2(q);
+
+  album = (id: string): Promise<Album> => this.getAlbum(id);
+
+  genres = () =>
+    this.GET({
+      url: "/rest/getGenres",
+    })
+      .asJSON<GetGenresResponse>()
+      .then((it) =>
+        pipe(
+          it.genres.genre || [],
+          A.filter((it) => it.albumCount > 0),
+          A.map((it) => it.value),
+          A.sort(ordString),
+          A.map((it) => ({ id: b64Encode(it), name: it }))
+        )
+      );
+
+  tracks = (albumId: string) =>
+    this.GET({
+      url: "/rest/getAlbum",
+      params: {
+        id: albumId,
+      },
+    })
+      .asJSON<GetAlbumResponse>()
+      .then((it) => it.album)
+      .then((album) =>
+        (album.song || []).map((song) => asTrack(asAlbum(album), song))
+      );
+
+  track = (trackId: string) => this.getTrack(trackId);
+
+  rate = (trackId: string, rating: Rating) =>
+    Promise.resolve(true)
+      .then(() => {
+        if (rating.stars >= 0 && rating.stars <= 5) {
+          return this.getTrack(trackId);
+        } else {
+          throw `Invalid rating.stars value of ${rating.stars}`;
+        }
+      })
+      .then((track) => {
+        const thingsToUpdate = [];
+        if (track.rating.love != rating.love) {
+          thingsToUpdate.push(
+            this.GET({
+              url: `/rest/${rating.love ? "star" : "unstar"}`,
+              params: {
+                id: trackId,
+              },
+            }).asJSON()
+          );
+        }
+        if (track.rating.stars != rating.stars) {
+          thingsToUpdate.push(
+            this.GET({
+              url: `/rest/setRating`,
+              params: {
+                id: trackId,
+                rating: rating.stars,
+              },
+            }).asJSON()
+          );
+        }
+        return Promise.all(thingsToUpdate);
+      })
+      .then(() => true)
+      .catch(() => false);
+
+  stream = async ({
+    trackId,
+    range,
+  }: {
+    trackId: string;
+    range: string | undefined;
+  }) =>
+    this.getTrack(trackId).then((track) =>
+      this.GET({
+        url: "/rest/stream",
+        params: {
+          id: trackId,
+          c: this.streamClientApplication(track),
+        },
+        headers: range != undefined ? { Range: range } : {},
+        responseType: "stream",
+      })
+        .asRaw()
+        .then((res) => ({
+          status: res.status,
+          headers: {
+            "content-type": res.headers["content-type"],
+            "content-length": res.headers["content-length"],
+            "content-range": res.headers["content-range"],
+            "accept-ranges": res.headers["accept-ranges"],
+          },
+          stream: res.data,
+        }))
+    );
+
+  coverArt = async (coverArtURN: BUrn, size?: number) =>
+    Promise.resolve(coverArtURN)
+      .then((it) => assertSystem(it, "subsonic"))
+      .then((it) => it.resource.split(":")[1]!)
+      .then((it) => this.getCoverArt(it, size))
+      .then((res) => ({
+        contentType: res.headers["content-type"],
+        data: Buffer.from(res.data, "binary"),
+      }))
+      .catch((e) => {
+        logger.error(
+          `Failed getting coverArt for '${format(coverArtURN)}': ${e}`
+        );
+        return undefined;
+      });
+
+  scrobble = async (id: string) =>
+    this.GET({
+      url: `/rest/scrobble`,
+      params: {
+        id,
+        submission: true,
+      },
+    })
+      .asJSON()
+      .then((_) => true)
+      .catch(() => false);
+
+  nowPlaying = async (id: string) =>
+    this.GET({
+      url: `/rest/scrobble`,
+      params: {
+        id,
+        submission: false,
+      },
+    })
+      .asJSON()
+      .then((_) => true)
+      .catch(() => false);
+
+  searchArtists = async (query: string) =>
+    this.search3({ query, artistCount: 20 }).then(({ artists }) =>
+      artists.map((artist) => ({
+        id: artist.id,
+        name: artist.name,
+        image: artistImageURN({
+          artistId: artist.id,
+          artistImageURL: artist.artistImageUrl,
+        }),
+      }))
+    );
+
+  searchAlbums = async (query: string) =>
+    this.search3({ query, albumCount: 20 }).then(({ albums }) =>
+      this.toAlbumSummary(albums)
+    );
+
+  searchTracks = async (query: string) =>
+    this.search3({ query, songCount: 20 }).then(({ songs }) =>
+      Promise.all(songs.map((it) => this.getTrack(it.id)))
+    );
+
+  playlists = async () =>
+    this.GET({ url: "/rest/getPlaylists" })
+      .asJSON<GetPlaylistsResponse>()
+      .then((it) => it.playlists.playlist || [])
+      .then((playlists) =>
+        playlists.map((it) => ({ id: it.id, name: it.name }))
+      );
+
+  playlist = async (id: string) =>
+    this.GET({
+      url: "/rest/getPlaylist",
+      params: {
+        id,
+      },
+    })
+      .asJSON<GetPlaylistResponse>()
+      .then((it) => it.playlist)
+      .then((playlist) => {
+        let trackNumber = 1;
+        return {
+          id: playlist.id,
+          name: playlist.name,
+          entries: (playlist.entry || []).map((entry) => ({
+            ...asTrack(
+              {
+                id: entry.albumId!,
+                name: entry.album!,
+                year: entry.year,
+                genre: maybeAsGenre(entry.genre),
+                artistName: entry.artist,
+                artistId: entry.artistId,
+                coverArt: coverArtURN(entry.coverArt),
+              },
+              entry
+            ),
+            number: trackNumber++,
+          })),
+        };
+      });
+
+  createPlaylist = async (name: string) =>
+    this.GET({
+      url: "/rest/createPlaylist",
+      params: {
+        name,
+      },
+    })
+      .asJSON<GetPlaylistResponse>()
+      .then((it) => it.playlist)
+      .then((it) => ({ id: it.id, name: it.name }));
+
+  deletePlaylist = async (id: string) =>
+    this.GET({
+      url: "/rest/deletePlaylist",
+      params: {
+        id,
+      },
+    })
+      .asJSON<GetPlaylistResponse>()
+      .then((_) => true);
+
+  addToPlaylist = async (playlistId: string, trackId: string) =>
+    this.GET({
+      url: "/rest/updatePlaylist",
+      params: {
+        playlistId,
+        songIdToAdd: trackId,
+      },
+    })
+      .asJSON<GetPlaylistResponse>()
+      .then((_) => true);
+
+  removeFromPlaylist = async (playlistId: string, indicies: number[]) =>
+    this.GET({
+      url: "/rest/updatePlaylist",
+      params: {
+        playlistId,
+        songIndexToRemove: indicies,
+      },
+    })
+      .asJSON<GetPlaylistResponse>()
+      .then((_) => true);
+
+  similarSongs = async (id: string) =>
+    this.GET({
+      url: "/rest/getSimilarSongs2",
+      params: { id, count: 50 },
+    })
+      .asJSON<GetSimilarSongsResponse>()
+      .then((it) => it.similarSongs2.song || [])
+      .then((songs) =>
+        Promise.all(
+          songs.map((song) =>
+            this.getAlbum(song.albumId!).then((album) => asTrack(album, song))
+          )
+        )
+      );
+
+  topSongs = async (artistId: string) =>
+    this.getArtist(artistId).then(({ name }) =>
+      this.GET({
+        url: "/rest/getTopSongs",
+        params: {
+          artist: name,
+          count: 50,
+        },
+      })
+        .asJSON<GetTopSongsResponse>()
+        .then((it) => it.topSongs.song || [])
+        .then((songs) =>
+          Promise.all(
+            songs.map((song) =>
+              this.getAlbum(song.albumId!).then((album) => asTrack(album, song))
+            )
+          )
+        )
+    );
+
+  private getArtists = (): Promise<
+    (IdName & { albumCount: number; image: BUrn | undefined })[]
+  > =>
+    this.GET({ url: "/rest/getArtists" })
+      .asJSON<GetArtistsResponse>()
+      .then((it) => (it.artists.index || []).flatMap((it) => it.artist || []))
+      .then((artists) =>
+        artists.map((artist) => ({
+          id: `${artist.id}`,
+          name: artist.name,
+          albumCount: artist.albumCount,
+          image: artistImageURN({
+            artistId: artist.id,
+            artistImageURL: artist.artistImageUrl,
+          }),
+        }))
+      );
+
+  private getArtistInfo = (
+    id: string
+  ): Promise<{
+    similarArtist: (ArtistSummary & { inLibrary: boolean })[];
+    images: {
+      s: string | undefined;
+      m: string | undefined;
+      l: string | undefined;
+    };
+  }> =>
+    this.GET({
+      url: "/rest/getArtistInfo2",
+      params: {
+        id,
+        count: 50,
+        includeNotPresent: true,
+      },
+    })
+      .asJSON<GetArtistInfoResponse>()
+      .then((it) => it.artistInfo2)
+      .then((it) => ({
+        images: {
+          s: it.smallImageUrl,
+          m: it.mediumImageUrl,
+          l: it.largeImageUrl,
+        },
+        similarArtist: (it.similarArtist || []).map((artist) => ({
+          id: `${artist.id}`,
+          name: artist.name,
+          inLibrary: artistIsInLibrary(artist.id),
+          image: artistImageURN({
+            artistId: artist.id,
+            artistImageURL: artist.artistImageUrl,
+          }),
+        })),
+      }));
+
+  private getAlbum = (id: string): Promise<Album> =>
+    this.GET({ url: "/rest/getAlbum", params: { id } })
+      .asJSON<GetAlbumResponse>()
+      .then((it) => it.album)
+      .then((album) => ({
+        id: album.id,
+        name: album.name,
+        year: album.year,
+        genre: maybeAsGenre(album.genre),
+        artistId: album.artistId,
+        artistName: album.artist,
+        coverArt: coverArtURN(album.coverArt),
+      }));
+
+  private getArtist = (
+    id: string
+  ): Promise<
+    IdName & { artistImageUrl: string | undefined; albums: AlbumSummary[] }
+  > =>
+    this.GET({
+      url: "/rest/getArtist",
+      params: {
+        id,
+      },
+    })
+      .asJSON<GetArtistResponse>()
+      .then((it) => it.artist)
+      .then((it) => ({
+        id: it.id,
+        name: it.name,
+        artistImageUrl: it.artistImageUrl,
+        albums: this.toAlbumSummary(it.album || []),
+      }));
+
+  private getArtistWithInfo = (id: string) =>
+    Promise.all([this.getArtist(id), this.getArtistInfo(id)]).then(
+      ([artist, artistInfo]) => ({
+        id: artist.id,
+        name: artist.name,
+        image: artistImageURN({
+          artistId: artist.id,
+          artistImageURL: [
+            artist.artistImageUrl,
+            artistInfo.images.l,
+            artistInfo.images.m,
+            artistInfo.images.s,
+          ].find(isValidImage),
+        }),
+        albums: artist.albums,
+        similarArtists: artistInfo.similarArtist,
+      })
+    );
+
+  private getCoverArt = (id: string, size?: number) =>
+    this.GET({
+      url: "/rest/getCoverArt",
+      params: { id, size },
+      responseType: "arraybuffer",
+    }).asRaw();
+
+  private getTrack = (id: string) =>
+    this.GET({
+      url: "/rest/getSong",
+      params: {
+        id,
+      },
+    })
+      .asJSON<GetSongResponse>()
+      .then((it) => it.song)
+      .then((song) =>
+        this.getAlbum(song.albumId!).then((album) => asTrack(album, song))
+      );
+
+  private toAlbumSummary = (albumList: album[]): AlbumSummary[] =>
+    albumList.map((album) => ({
+      id: album.id,
+      name: album.name,
+      year: album.year,
+      genre: maybeAsGenre(album.genre),
+      artistId: album.artistId,
+      artistName: album.artist,
+      coverArt: coverArtURN(album.coverArt),
+    }));
+
+  private search3 = (q: any) =>
+    this.GET({
+      url: "/rest/search3",
+      params: {
+        artistCount: 0,
+        albumCount: 0,
+        songCount: 0,
+        ...q,
+      },
+    })
+      .asJSON<Search3Response>()
+      .then((it) => ({
+        artists: it.searchResult3.artist || [],
+        albums: it.searchResult3.album || [],
+        songs: it.searchResult3.song || [],
+      }));
+
+  private getAlbumList2 = (q: AlbumQuery) =>
+    Promise.all([
+      this.getArtists().then((it) =>
+        inject(it, (total, artist) => total + artist.albumCount, 0)
+      ),
+      this.GET({
+        url: "/rest/getAlbumList2",
+        params: {
+          type: AlbumQueryTypeToSubsonicType[q.type],
+          ...(q.genre ? { genre: b64Decode(q.genre) } : {}),
+          size: 500,
+          offset: q._index,
+        },
+      })
+        .asJSON<GetAlbumListResponse>()
+        .then((response) => response.albumList2.album || [])
+        .then(this.toAlbumSummary),
+    ]).then(([total, albums]) => ({
+      results: albums.slice(0, q._count),
+      total: albums.length == 500 ? total : (q._index || 0) + albums.length,
+    }));
+}
--- a/src/subsonic/index.ts
+++ b/src/subsonic/index.ts
@@ -0,0 +1,176 @@
+import { taskEither as TE } from "fp-ts";
+import { pipe } from "fp-ts/lib/function";
+import { Md5 } from "ts-md5/dist/md5";
+import axios from "axios";
+import randomstring from "randomstring";
+import _ from "underscore";
+// todo: rename http2 to http
+import { Http2, http2From } from "../http";
+
+import {
+  Credentials,
+  MusicService,
+  MusicLibrary,
+  Track,
+  AuthFailure,
+} from "../music_service";
+import { b64Encode, b64Decode } from "../b64";
+import { axiosImageFetcher, ImageFetcher } from "../images";
+import { navidromeMusicLibrary, SubsonicGenericMusicLibrary } from "./generic";
+import { client } from "./subsonic_http";
+
+export const t = (password: string, s: string) =>
+  Md5.hashStr(`${password}${s}`);
+
+export const t_and_s = (password: string) => {
+  const s = randomstring.generate();
+  return {
+    t: t(password, s),
+    s,
+  };
+};
+
+// todo: this is an ND thing
+export const DODGY_IMAGE_NAME = "2a96cbd8b46e442fc41c2b86b821562f.png";
+
+export type SubsonicEnvelope = {
+  "subsonic-response": SubsonicResponse;
+};
+
+export type SubsonicResponse = {
+  status: string;
+};
+
+export type SubsonicError = SubsonicResponse & {
+  error: {
+    code: string;
+    message: string;
+  };
+};
+
+export type PingResponse = {
+  status: string;
+  version: string;
+  type: string;
+  serverVersion: string;
+};
+
+export function isError(
+  subsonicResponse: SubsonicResponse
+): subsonicResponse is SubsonicError {
+  return (subsonicResponse as SubsonicError).error !== undefined;
+}
+
+// todo: is this a good name?
+export type StreamClientApplication = (track: Track) => string;
+
+export const DEFAULT_CLIENT_APPLICATION = "bonob";
+export 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 type SubsonicCredentials = Credentials & {
+  type: string;
+  bearer: string | undefined;
+};
+
+export const asToken = (credentials: SubsonicCredentials) =>
+  b64Encode(JSON.stringify(credentials));
+
+export const parseToken = (token: string): SubsonicCredentials =>
+  JSON.parse(b64Decode(token));
+
+export interface SubsonicMusicLibrary extends MusicLibrary {
+  flavour(): string;
+  bearerToken(
+    credentials: Credentials
+  ): TE.TaskEither<Error, string | undefined>;
+}
+
+export class Subsonic implements MusicService {
+  url: string;
+
+  // todo: does this need to be in here now?
+  streamClientApplication: StreamClientApplication;
+  // todo: why is this in here?
+  externalImageFetcher: ImageFetcher;
+
+  subsonicHttp: Http2;
+
+  constructor(
+    url: string,
+    streamClientApplication: StreamClientApplication = DEFAULT,
+    externalImageFetcher: ImageFetcher = axiosImageFetcher
+  ) {
+    this.url = url;
+    this.streamClientApplication = streamClientApplication;
+    this.externalImageFetcher = externalImageFetcher;
+    this.subsonicHttp = http2From(axios).with({
+      baseURL: this.url,
+      params: { v: "1.16.1", c: DEFAULT_CLIENT_APPLICATION },
+      headers: { "User-Agent": "bonob" },
+    });
+  }
+
+  asAuthParams = (credentials: Credentials) => ({
+    u: credentials.username,
+    ...t_and_s(credentials.password),
+  })
+
+  generateToken = (credentials: Credentials) =>
+    pipe(
+      TE.tryCatch(
+        () => client(this.subsonicHttp.with({ params: this.asAuthParams(credentials) } ))({ method: 'get', url: "/rest/ping.view" }).asJSON<PingResponse>(),
+        (e) => new AuthFailure(e as string)
+      ),
+      TE.chain(({ type }) =>
+        pipe(
+          TE.tryCatch(
+            () => this.libraryFor({ ...credentials, type, bearer: undefined }),
+            () => new AuthFailure("Failed to get library")
+          ),
+          TE.map((library) => ({ type, library }))
+        )
+      ),
+      TE.chain(({ library, type }) =>
+        pipe(
+          library.bearerToken(credentials),
+          TE.map((bearer) => ({ bearer, type }))
+        )
+      ),
+      TE.map(({ bearer, type }) => ({
+        serviceToken: asToken({ ...credentials, bearer, type }),
+        userId: credentials.username,
+        nickname: credentials.username,
+      }))
+    );
+
+  refreshToken = (serviceToken: string) =>
+    this.generateToken(parseToken(serviceToken));
+
+  login = async (token: string) => this.libraryFor(parseToken(token));
+
+  private libraryFor = (
+    credentials: SubsonicCredentials
+  ): Promise<SubsonicMusicLibrary> => {
+    const subsonicGenericLibrary = new SubsonicGenericMusicLibrary(
+      this.streamClientApplication,
+      this.subsonicHttp.with({ params: this.asAuthParams(credentials) } )
+    );
+    if (credentials.type == "navidrome") {
+      return Promise.resolve(
+        navidromeMusicLibrary(this.url, subsonicGenericLibrary, credentials)
+      );
+    } else {
+      return Promise.resolve(subsonicGenericLibrary);
+    }
+  };
+}
+
+export default Subsonic;
--- a/src/subsonic/navidrome.ts
+++ b/src/subsonic/navidrome.ts
@@ -0,0 +1,95 @@
+import { option as O, taskEither as TE } from "fp-ts";
+import * as A from "fp-ts/Array";
+import { pipe } from "fp-ts/lib/function";
+import { ordString } from "fp-ts/lib/Ord";
+import { inject } from "underscore";
+import _ from "underscore";
+import axios from "axios";
+
+import { SubsonicCredentials, SubsonicMusicLibrary } from ".";
+import { ArtistQuery, ArtistSummary, AuthFailure, Credentials, Result, Sortable } from "../music_service";
+import { artistImageURN } from "./generic";
+
+export type NDArtist = {
+  id: string;
+  name: string;
+  orderArtistName: string | undefined;
+  largeImageUrl: string | undefined;
+};
+
+export const artistSummaryFromNDArtist = (
+  artist: NDArtist
+): ArtistSummary & Sortable => ({
+  id: artist.id,
+  name: artist.name,
+  sortName: artist.orderArtistName || artist.name,
+  image: artistImageURN({
+    artistId: artist.id,
+    artistImageURL: artist.largeImageUrl,
+  }),
+});
+
+
+export const navidromeMusicLibrary = (
+  url: string,
+  subsonicLibrary: SubsonicMusicLibrary,
+  subsonicCredentials: SubsonicCredentials
+): SubsonicMusicLibrary => ({
+  ...subsonicLibrary,
+  flavour: () => "navidrome",
+  bearerToken: (
+    credentials: Credentials
+  ): TE.TaskEither<Error, string | undefined> =>
+    pipe(
+      TE.tryCatch(
+        () =>
+          // todo: not hardcode axios in here
+          axios({
+            method: "post",
+            baseURL: url,
+            url: `/auth/login`,
+            data: _.pick(credentials, "username", "password"),
+          }),
+        () => new AuthFailure("Failed to get bearerToken")
+      ),
+      TE.map((it) => it.data.token as string | undefined)
+    ),
+  artists: async (
+    q: ArtistQuery
+  ): Promise<Result<ArtistSummary & Sortable>> => {
+    let params: any = {
+      _sort: "name",
+      _order: "ASC",
+      _start: q._index || "0",
+    };
+    if (q._count) {
+      params = {
+        ...params,
+        _end: (q._index || 0) + q._count,
+      };
+    }
+
+    const x: Promise<Result<ArtistSummary & Sortable>> = axios
+      .get(`${url}/api/artist`, {
+        params: asURLSearchParams(params),
+        headers: {
+          "User-Agent": USER_AGENT,
+          "x-nd-authorization": `Bearer ${subsonicCredentials.bearer}`,
+        },
+      })
+      .catch((e) => {
+        throw `Navidrome failed with: ${e}`;
+      })
+      .then((response) => {
+        if (response.status != 200 && response.status != 206) {
+          throw `Navidrome failed with a ${response.status || "no!"} status`;
+        } else return response;
+      })
+      .then((it) => ({
+        results: (it.data as NDArtist[]).map(artistSummaryFromNDArtist),
+        total: Number.parseInt(it.headers["x-total-count"] || "0"),
+      }));
+
+    return x;
+  },
+});
--- a/src/subsonic/subsonic_http.ts
+++ b/src/subsonic/subsonic_http.ts
@@ -0,0 +1,51 @@
+import { AxiosResponse } from "axios";
+import { isError, SubsonicEnvelope } from ".";
+// todo: rename http2 to http
+import { Http2, RequestParams } from "../http";
+
+export type HttpResponse = {
+  data: any;
+  status: number;
+  headers: any;
+};
+
+const asJSON = <T>(response: HttpResponse): T => {
+  const subsonicResponse = (response.data as SubsonicEnvelope)[
+    "subsonic-response"
+  ];
+  if (isError(subsonicResponse))
+    throw `Subsonic error:${subsonicResponse.error.message}`;
+  else return subsonicResponse as unknown as T;
+};
+const throwUp = (error: any) => {
+  throw `Subsonic failed with: ${error}`;
+};
+const verifyResponse = (response: AxiosResponse<any>) => {
+  if (response.status != 200 && response.status != 206) {
+    throw `Subsonic failed with a ${response.status || "no!"} status`;
+  } else return response;
+};
+
+export interface SubsonicHttpResponse {
+  asRaw(): Promise<AxiosResponse<any>>;
+  asJSON<T>(): Promise<T>;
+}
+
+export interface SubsonicHttp {
+  (query: Partial<RequestParams>): SubsonicHttpResponse;
+}
+
+export const client = (http: Http2): SubsonicHttp => {
+  return (query: Partial<RequestParams>): SubsonicHttpResponse => {
+    return {
+      asRaw: () => http(query).catch(throwUp).then(verifyResponse),
+
+      asJSON: <T>() =>
+        http
+          .with({ params: { f: "json" } })(query)
+          .catch(throwUp)
+          .then(verifyResponse)
+          .then(asJSON) as Promise<T>,
+    };
+  };
+};
--- a/src/utils.ts
+++ b/src/utils.ts
@@ -1,7 +1,42 @@
-export function takeWithRepeats<T>(things:T[], count: number) {
+import { flatten } from "underscore";
+
+// todo: move this
+export const BROWSER_HEADERS = {
+  accept:
+    "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
+  "accept-encoding": "gzip, deflate, br",
+  "accept-language": "en-GB,en;q=0.5",
+  "upgrade-insecure-requests": "1",
+  "user-agent":
+    "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:86.0) Gecko/20100101 Firefox/86.0",
+};
+
+// todo: move this
+export const asURLSearchParams = (q: any) => {
+  const urlSearchParams = new URLSearchParams();
+  Object.keys(q).forEach((k) => {
+    flatten([q[k]]).forEach((v) => {
+      urlSearchParams.append(k, `${v}`);
+    });
+  });
+  return urlSearchParams;
+};
+
+export function takeWithRepeats<T>(things: T[], count: number) {
  const result = [];
-  for(let i = 0; i < count; i++) {
-    result.push(things[i % things.length])
+  for (let i = 0; i < count; i++) {
+    result.push(things[i % things.length]);
  }
  return result;
-}
+}
+
+export const mask = (thing: any, fields: string[]) =>
+  fields.reduce(
+    (res: any, key: string) => {
+      if (Object.keys(res).includes(key)) {
+        res[key] = "****";
+      }
+      return res;
+    },
+    { ...thing }
+  );
--- a/tests/builders.ts
+++ b/tests/builders.ts
@@ -14,11 +14,10 @@ import {
  Playlist,
  SimilarArtist,
  AlbumSummary,
-  RadioStation,
 } from "../src/music_service";

 import { b64Encode } from "../src/b64";
-import { artistImageURN } from "../src/subsonic";
+import { artistImageURN } from "../src/subsonic/generic";

 const randomInt = (max: number) => Math.floor(Math.random() * Math.floor(max));
 const randomIpAddress = () => `127.0.${randomInt(255)}.${randomInt(255)}`;
@@ -174,10 +173,7 @@ export function aTrack(fields: Partial<Track> = {}): Track {
  return {
    id,
    name: `Track ${id}`,
-    encoding: {
-      player: "bonob",
-      mimeType: `audio/mp3-${id}`
-    },
+    mimeType: `audio/mp3-${id}`,
    duration: randomInt(500),
    number: randomInt(100),
    genre,
@@ -205,17 +201,6 @@ export function anAlbum(fields: Partial<Album> = {}): Album {
  };
 };

-export function aRadioStation(fields: Partial<RadioStation> = {}): RadioStation {
-  const id = uuid()
-  const name = `Station-${id}`;
-  return {
-    id,
-    name,
-    url: `http://example.com/${name}`,
-    ...fields
-  }
-}
-
 export function anAlbumSummary(fields: Partial<AlbumSummary> = {}): AlbumSummary {
  const id = uuid();
  return {
--- a/tests/config.test.ts
+++ b/tests/config.test.ts
@@ -270,15 +270,6 @@ describe("config", () => {
      expect(config().authTimeout).toEqual("33s");
    });
  });
-  
-  describe("logRequests", () => {
-    describeBooleanConfigValue(
-      "logRequests",
-      "BNB_SERVER_LOG_REQUESTS",
-      false,
-      (config) => config.logRequests
-    );
-  });

  describe("sonos", () => {
    describe("serviceName", () => {
@@ -374,31 +365,23 @@ describe("config", () => {
        "BONOB_NAVIDROME_URL",
      ])("%s", (k) => {
        describe(`when ${k} is not specified`, () => {
-          it(`should default to http://${hostname()}:4533/`, () => {
-            expect(config().subsonic.url.href()).toEqual(`http://${hostname()}:4533/`);
+          it(`should default to http://${hostname()}:4533`, () => {
+            expect(config().subsonic.url).toEqual(`http://${hostname()}:4533`);
          });
        });

        describe(`when ${k} is ''`, () => {
-          it(`should default to http://${hostname()}:4533/`, () => {
+          it(`should default to http://${hostname()}:4533`, () => {
            process.env[k] = "";
-            expect(config().subsonic.url.href()).toEqual(`http://${hostname()}:4533/`);
+            expect(config().subsonic.url).toEqual(`http://${hostname()}:4533`);
          });
        });

        describe(`when ${k} is specified`, () => {
          it(`should use it for ${k}`, () => {
-            const url = "http://navidrome.example.com:1234/some-context-path";
+            const url = "http://navidrome.example.com:1234";
            process.env[k] = url;
-            expect(config().subsonic.url.href()).toEqual(url);
-          });
-        });
-
-        describe(`when ${k} is specified with trailing slash`, () => {
-          it(`should maintain the trailing slash as URLBuilder will remove it when required ${k}`, () => {
-            const url = "http://navidrome.example.com:1234/";
-            process.env[k] = url;
-            expect(config().subsonic.url.href()).toEqual(url);
+            expect(config().subsonic.url).toEqual(url);
          });
        });
      });
--- a/tests/http.test.ts
+++ b/tests/http.test.ts
@@ -0,0 +1,277 @@
+import { http, http2From, } from "../src/http";
+
+describe("http", () => {
+  const mockAxios = jest.fn();
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    jest.resetAllMocks();
+  });
+
+  describe.each([
+    ["baseURL"],
+    ["url"],
+    ["method"],
+  ])('%s', (field) => {
+    const getValue = (value: string) => {
+      const thing = {} as any;
+      thing[field] = value;
+      return thing;
+    };
+
+    const base = http(mockAxios, getValue('base'));
+
+    describe("using default", () => {
+      it("should use the default", () => {
+        base({})
+        expect(mockAxios).toHaveBeenCalledWith(getValue('base'));
+      });
+    });
+
+    describe("overriding", () => {
+      it("should use the override", () => {
+        base(getValue('override'))
+        expect(mockAxios).toHaveBeenCalledWith(getValue('override'));
+      });
+    });
+
+    describe("wrapping", () => {
+      const firstLayer = http(base, getValue('level1'));
+      const secondLayer = http(firstLayer, getValue('level2'));
+
+      describe("when the outter call provides a value", () => {
+        it("should apply it", () => {
+          secondLayer(getValue('outter'))
+          expect(mockAxios).toHaveBeenCalledWith(getValue('outter'));
+        });
+      });
+
+      describe("when the outter call does not provide a value", () => {
+        it("should use the second layer", () => {
+          secondLayer({ })
+          expect(mockAxios).toHaveBeenCalledWith(getValue('level2'));
+        });
+      });
+    });
+  });
+
+  describe("requestType", () => {
+    const base = http(mockAxios, { responseType: 'stream' });
+
+    describe("using default", () => {
+      it("should use the default", () => {
+        base({})
+        expect(mockAxios).toHaveBeenCalledWith({ responseType: 'stream' });
+      });
+    });
+
+    describe("overriding", () => {
+      it("should use the override", () => {
+        base({ responseType: 'arraybuffer' })
+        expect(mockAxios).toHaveBeenCalledWith({ responseType: 'arraybuffer' });
+      });
+    });
+
+    describe("wrapping", () => {
+      const firstLayer = http(base, { responseType: 'arraybuffer' });
+      const secondLayer = http(firstLayer, { responseType: 'blob' });
+
+      describe("when the outter call provides a value", () => {
+        it("should apply it", () => {
+          secondLayer({ responseType: 'text' })
+          expect(mockAxios).toHaveBeenCalledWith({ responseType: 'text' });
+        });
+      });
+
+      describe("when the outter call does not provide a value", () => {
+        it("should use the second layer", () => {
+          secondLayer({ })
+          expect(mockAxios).toHaveBeenCalledWith({ responseType: 'blob' });
+        });
+      });
+    });
+  });  
+
+  describe.each([
+    ["params"],
+    ["headers"],
+  ])('%s', (field) => {
+    const getValues = (values: any) => {
+      const thing = {} as any;
+      thing[field] = values;
+      return thing;
+    }
+    const base = http(mockAxios, getValues({ a: 1, b: 2, c: 3, d: 4 }));
+
+    describe("using default", () => {
+      it("should use the default", () => {
+        base({});
+        expect(mockAxios).toHaveBeenCalledWith(getValues({ a: 1, b: 2, c: 3, d: 4 }));
+      });
+    });
+
+    describe("overriding", () => {
+      it("should use the override", () => {
+        base(getValues({ b: 22, e: 5 }));
+        expect(mockAxios).toHaveBeenCalledWith(getValues({ a: 1, b: 22, c: 3, d: 4, e: 5 }));
+      });
+    });
+
+    describe("wrapping", () => {
+      const firstLayer = http(base, getValues({ b: 22 }));
+      const secondLayer = http(firstLayer, getValues({ c: 33 }));
+
+      describe("when the outter call provides a value", () => {
+        it("should apply it", () => {
+          secondLayer(getValues({ a: 11, e: 5 }));
+          expect(mockAxios).toHaveBeenCalledWith(getValues({ a: 11, b: 22, c: 33, d: 4, e: 5 }));
+        });
+      });
+
+      describe("when the outter call does not provide a value", () => {
+        it("should use the second layer", () => {
+          secondLayer({ });
+          expect(mockAxios).toHaveBeenCalledWith(getValues({ a: 1, b: 22, c: 33, d: 4 }));
+        });
+      });
+    });
+  })
+});
+
+describe("http2", () => {
+  const mockAxios = jest.fn();
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    jest.resetAllMocks();
+  });
+
+  describe.each([
+    ["baseURL"],
+    ["url"],
+    ["method"],
+  ])('%s', (field) => {
+    const fieldWithValue = (value: string) => {
+      const thing = {} as any;
+      thing[field] = value;
+      return thing;
+    };
+
+    const base = http2From(mockAxios).with(fieldWithValue('default'));
+
+    describe("using default", () => {
+      it("should use the default", () => {
+        base({})
+        expect(mockAxios).toHaveBeenCalledWith(fieldWithValue('default'));
+      });
+    });
+
+    describe("overriding", () => {
+      it("should use the override", () => {
+        base(fieldWithValue('override'))
+        expect(mockAxios).toHaveBeenCalledWith(fieldWithValue('override'));
+      });
+    });
+
+    describe("wrapping", () => {
+      const firstLayer = http2From(base).with(fieldWithValue('level1'));
+      const secondLayer = firstLayer.with(fieldWithValue('level2'));
+
+      describe("when the outter call provides a value", () => {
+        it("should apply it", () => {
+          secondLayer(fieldWithValue('outter'))
+          expect(mockAxios).toHaveBeenCalledWith(fieldWithValue('outter'));
+        });
+      });
+
+      describe("when the outter call does not provide a value", () => {
+        it("should use the second layer", () => {
+          secondLayer({ })
+          expect(mockAxios).toHaveBeenCalledWith(fieldWithValue('level2'));
+        });
+      });
+    });
+  });
+
+  describe("requestType", () => {
+    const base = http2From(mockAxios).with({ responseType: 'stream' });
+
+    describe("using default", () => {
+      it("should use the default", () => {
+        base({})
+        expect(mockAxios).toHaveBeenCalledWith({ responseType: 'stream' });
+      });
+    });
+
+    describe("overriding", () => {
+      it("should use the override", () => {
+        base({ responseType: 'arraybuffer' })
+        expect(mockAxios).toHaveBeenCalledWith({ responseType: 'arraybuffer' });
+      });
+    });
+
+    describe("wrapping", () => {
+      const firstLayer = base.with({ responseType: 'arraybuffer' });
+      const secondLayer = firstLayer.with({ responseType: 'blob' });
+
+      describe("when the outter call provides a value", () => {
+        it("should apply it", () => {
+          secondLayer({ responseType: 'text' })
+          expect(mockAxios).toHaveBeenCalledWith({ responseType: 'text' });
+        });
+      });
+
+      describe("when the outter call does not provide a value", () => {
+        it("should use the second layer", () => {
+          secondLayer({ })
+          expect(mockAxios).toHaveBeenCalledWith({ responseType: 'blob' });
+        });
+      });
+    });
+  });  
+
+  describe.each([
+    ["params"],
+    ["headers"],
+  ])('%s', (field) => {
+    const fieldWithValues = (values: any) => {
+      const thing = {} as any;
+      thing[field] = values;
+      return thing;
+    }
+    const base = http2From(mockAxios).with(fieldWithValues({ a: 1, b: 2, c: 3, d: 4 }));
+
+    describe("using default", () => {
+      it("should use the default", () => {
+        base({});
+        expect(mockAxios).toHaveBeenCalledWith(fieldWithValues({ a: 1, b: 2, c: 3, d: 4 }));
+      });
+    });
+
+    describe("overriding", () => {
+      it("should use the override", () => {
+        base(fieldWithValues({ b: 22, e: 5 }));
+        expect(mockAxios).toHaveBeenCalledWith(fieldWithValues({ a: 1, b: 22, c: 3, d: 4, e: 5 }));
+      });
+    });
+
+    describe("wrapping", () => {
+      const firstLayer = base.with(fieldWithValues({ b: 22 }));
+      const secondLayer = firstLayer.with(fieldWithValues({ c: 33 }));
+
+      describe("when the outter call provides a value", () => {
+        it("should apply it", () => {
+          secondLayer(fieldWithValues({ a: 11, e: 5 }));
+          expect(mockAxios).toHaveBeenCalledWith(fieldWithValues({ a: 11, b: 22, c: 33, d: 4, e: 5 }));
+        });
+      });
+
+      describe("when the outter call does not provide a value", () => {
+        it("should use the second layer", () => {
+          secondLayer({ });
+          expect(mockAxios).toHaveBeenCalledWith(fieldWithValues({ a: 1, b: 22, c: 33, d: 4 }));
+        });
+      });
+    });
+  })
+});
--- a/tests/i8n.test.ts
+++ b/tests/i8n.test.ts
@@ -34,7 +34,7 @@ describe("i8n", () => {

  describe("langs", () => {
    it("should be all langs that are explicitly defined", () => {
-      expect(langs()).toEqual(["en-US", "da-DK", "fr-FR", "nl-NL"]);
+      expect(langs()).toEqual(["en-US", "nl-NL"]);
    });
  });

--- a/tests/images.test.ts
+++ b/tests/images.test.ts
@@ -0,0 +1,78 @@
+
+import tmp from "tmp";
+import fse from "fs-extra";
+import path from "path";
+import { Md5 } from "ts-md5";
+
+import sharp from "sharp";
+jest.mock("sharp");
+
+import { cachingImageFetcher } from "../src/images";
+
+describe("cachingImageFetcher", () => {
+  const delegate = jest.fn();
+  const url = "http://test.example.com/someimage.jpg";
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    jest.resetAllMocks();
+  });
+
+  describe("when there is no image in the cache", () => {
+    it("should fetch the image from the source and then cache and return it", async () => {
+      const dir = tmp.dirSync();
+      const cacheFile = path.join(dir.name, `${Md5.hashStr(url)}.png`);
+      const jpgImage = Buffer.from("jpg-image", "utf-8");
+      const pngImage = Buffer.from("png-image", "utf-8");
+
+      delegate.mockResolvedValue({ contentType: "image/jpeg", data: jpgImage });
+      const png = jest.fn();
+      (sharp as unknown as jest.Mock).mockReturnValue({ png });
+      png.mockReturnValue({
+        toBuffer: () => Promise.resolve(pngImage),
+      });
+
+      const result = await cachingImageFetcher(dir.name, delegate)(url);
+
+      expect(result!.contentType).toEqual("image/png");
+      expect(result!.data).toEqual(pngImage);
+
+      expect(delegate).toHaveBeenCalledWith(url);
+      expect(fse.existsSync(cacheFile)).toEqual(true);
+      expect(fse.readFileSync(cacheFile)).toEqual(pngImage);
+    });
+  });
+
+  describe("when the image is already in the cache", () => {
+    it("should fetch the image from the cache and return it", async () => {
+      const dir = tmp.dirSync();
+      const cacheFile = path.join(dir.name, `${Md5.hashStr(url)}.png`);
+      const data = Buffer.from("foobar2", "utf-8");
+
+      fse.writeFileSync(cacheFile, data);
+
+      const result = await cachingImageFetcher(dir.name, delegate)(url);
+
+      expect(result!.contentType).toEqual("image/png");
+      expect(result!.data).toEqual(data);
+
+      expect(delegate).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("when the delegate returns undefined", () => {
+    it("should return undefined", async () => {
+      const dir = tmp.dirSync();
+      const cacheFile = path.join(dir.name, `${Md5.hashStr(url)}.png`);
+
+      delegate.mockResolvedValue(undefined);
+
+      const result = await cachingImageFetcher(dir.name, delegate)(url);
+
+      expect(result).toBeUndefined();
+
+      expect(delegate).toHaveBeenCalledWith(url);
+      expect(fse.existsSync(cacheFile)).toEqual(false);
+    });
+  });
+});
--- a/tests/in_memory_music_service.test.ts
+++ b/tests/in_memory_music_service.test.ts
@@ -6,6 +6,7 @@ import {
  MusicLibrary,
  artistToArtistSummary,
  albumToAlbumSummary,
+  Artist,
 } from "../src/music_service";
 import { v4 as uuid } from "uuid";
 import {
@@ -78,6 +79,11 @@ describe("InMemoryMusicService", () => {
      musicLibrary = (await service.login(token.serviceToken)) as MusicLibrary;
    });

+    const artistToArtistSummaryWithSortName = (artist: Artist) => ({
+      ...artistToArtistSummary(artist),
+      sortName: artist.name
+    })
+
    describe("artists", () => {
      const artist1 = anArtist();
      const artist2 = anArtist();
@@ -95,11 +101,11 @@ describe("InMemoryMusicService", () => {
            await musicLibrary.artists({ _index: 0, _count: 100 })
          ).toEqual({
            results: [
-              artistToArtistSummary(artist1),
-              artistToArtistSummary(artist2),
-              artistToArtistSummary(artist3),
-              artistToArtistSummary(artist4),
-              artistToArtistSummary(artist5),
+              artistToArtistSummaryWithSortName(artist1),
+              artistToArtistSummaryWithSortName(artist2),
+              artistToArtistSummaryWithSortName(artist3),
+              artistToArtistSummaryWithSortName(artist4),
+              artistToArtistSummaryWithSortName(artist5),
            ],
            total: 5,
          });
@@ -110,8 +116,8 @@ describe("InMemoryMusicService", () => {
        it("should provide an array of artists", async () => {
          expect(await musicLibrary.artists({ _index: 2, _count: 2 })).toEqual({
            results: [
-              artistToArtistSummary(artist3),
-              artistToArtistSummary(artist4),
+              artistToArtistSummaryWithSortName(artist3),
+              artistToArtistSummaryWithSortName(artist4),
            ],
            total: 5,
          });
@@ -121,7 +127,7 @@ describe("InMemoryMusicService", () => {
      describe("fetching the last page", () => {
        it("should provide an array of artists", async () => {
          expect(await musicLibrary.artists({ _index: 4, _count: 2 })).toEqual({
-            results: [artistToArtistSummary(artist5)],
+            results: [artistToArtistSummaryWithSortName(artist5)],
            total: 5,
          });
        });
--- a/tests/in_memory_music_service.ts
+++ b/tests/in_memory_music_service.ts
@@ -62,7 +62,7 @@ export class InMemoryMusicService implements MusicService {

    return Promise.resolve({
      artists: (q: ArtistQuery) =>
-        Promise.resolve(this.artists.map(artistToArtistSummary))
+        Promise.resolve(this.artists.map(artistToArtistSummary).map(it => ({ ...it, sortName: it.name })))
          .then(slice2(q))
          .then(asResult),
      artist: (id: string) =>
@@ -161,8 +161,6 @@ export class InMemoryMusicService implements MusicService {
        Promise.reject("Unsupported operation"),
      similarSongs: async (_: string) => Promise.resolve([]),
      topSongs: async (_: string) => Promise.resolve([]),
-      radioStations: async () => Promise.resolve([]),
-      radioStation: async (_: string) => Promise.reject("Unsupported operation"),
    });
  }

--- a/tests/music_service.test.ts
+++ b/tests/music_service.test.ts
@@ -1,7 +1,57 @@
 import { v4 as uuid } from "uuid";

 import { anArtist } from "./builders";
-import { artistToArtistSummary } from "../src/music_service";
+import { artistToArtistSummary, slice2 } from "../src/music_service";
+
+
+describe("slice2", () => {
+  const things = ["a", "b", "c", "d", "e", "f", "g", "h", "i"];
+  
+  describe("when slice is a subset of the things", () => {
+    it("should return the page", () => {
+      expect(slice2({ _index: 3, _count: 4 })(things)).toEqual([
+        ["d", "e", "f", "g"],
+        things.length
+      ])
+    });
+  });
+
+  describe("when slice goes off the end of the things", () => {
+    it("should return the page", () => {
+      expect(slice2({ _index: 5, _count: 100 })(things)).toEqual([
+        ["f", "g", "h", "i"],
+        things.length
+      ])
+    });
+  });
+
+  describe("when no _count is provided", () => {
+    it("should return from the index", () => {
+      expect(slice2({ _index: 5 })(things)).toEqual([
+        ["f", "g", "h", "i"],
+        things.length
+      ])
+    });
+  });
+
+  describe("when no _index is provided", () => {
+    it("should assume from the start", () => {
+      expect(slice2({ _count: 3 })(things)).toEqual([
+        ["a", "b", "c"],
+        things.length
+      ])
+    });
+  });
+
+  describe("when no _index or _count is provided", () => {
+    it("should return all the things", () => {
+      expect(slice2()(things)).toEqual([
+        things,
+        things.length
+      ])
+    });
+  });
+});

 describe("artistToArtistSummary", () => {
  it("should map fields correctly", () => {
--- a/tests/server.test.ts
+++ b/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, {
@@ -165,13 +167,15 @@ describe("RangeBytesFromFilter", () => {


 describe("server", () => {
+  jest.setTimeout(Number.parseInt(process.env["JEST_TIMEOUT"] || "5000"));
+  
  beforeEach(() => {
    jest.clearAllMocks();
    jest.resetAllMocks();
  });

-  const bonobUrlWithNoContextPath = url("http://localhost:1234");
-  const bonobUrlWithContextPath = url("http://localhost:1234/aContext");
+  const bonobUrlWithNoContextPath = url("http://bonob.localhost:1234");
+  const bonobUrlWithContextPath = url("http://bonob.localhost:1234/aContext");

  const langName = randomLang();
  const acceptLanguage = `le-ET,${langName};q=0.9,en;q=0.8`;
@@ -753,22 +757,15 @@ describe("server", () => {
        const trackId = `t-${uuid()}`;
        const smapiAuthToken: SmapiToken = { token: `token-${uuid()}`, key: `key-${uuid()}` };

-        const streamContent = (content: string) => {
-          const self = {
-            destroyed: false,
-            pipe: (_: Transform) => {
-              return {
-                pipe: (res: Response) => {
-                  res.send(content);
-                }
-              };
-            },
-            destroy: () => {
-              self.destroyed = true;
-            }
-          };
-          return self;
-        };
+        const streamContent = (content: string) => ({
+          pipe: (_: Transform) => {
+            return {
+              pipe: (res: Response) => {
+                res.send(content);
+              },
+            };
+          },
+        });

        describe("HEAD requests", () => {
          describe("when there is no Bearer token", () => {
@@ -834,8 +831,6 @@ describe("server", () => {
                );
                expect(res.headers["content-length"]).toEqual("123");
                expect(res.body).toEqual({});
-
-                expect(trackStream.stream.destroyed).toBe(true);
              });
            });

@@ -861,8 +856,6 @@ describe("server", () => {

                expect(res.status).toEqual(404);
                expect(res.body).toEqual({});
-
-                expect(trackStream.stream.destroyed).toBe(true);
              });
            });
          });
@@ -925,8 +918,6 @@ describe("server", () => {
  
                expect(musicLibrary.nowPlaying).not.toHaveBeenCalled();
                expect(musicLibrary.stream).toHaveBeenCalledWith({ trackId });
-
-                expect(stream.stream.destroyed).toBe(true);
              });
            });
  
@@ -970,8 +961,6 @@ describe("server", () => {
                  expect(musicService.login).toHaveBeenCalledWith(serviceToken);
                  expect(musicLibrary.nowPlaying).toHaveBeenCalledWith(trackId);
                  expect(musicLibrary.stream).toHaveBeenCalledWith({ trackId });
-
-                  expect(stream.stream.destroyed).toBe(true);
                });
              });
  
@@ -1013,8 +1002,6 @@ describe("server", () => {
                  expect(musicService.login).toHaveBeenCalledWith(serviceToken);
                  expect(musicLibrary.nowPlaying).toHaveBeenCalledWith(trackId);
                  expect(musicLibrary.stream).toHaveBeenCalledWith({ trackId });
-
-                  expect(stream.stream.destroyed).toBe(true);
                });
              });
  
@@ -1055,8 +1042,6 @@ describe("server", () => {
                  expect(musicService.login).toHaveBeenCalledWith(serviceToken);
                  expect(musicLibrary.nowPlaying).toHaveBeenCalledWith(trackId);
                  expect(musicLibrary.stream).toHaveBeenCalledWith({ trackId });
-
-                  expect(stream.stream.destroyed).toBe(true);
                });
              });
  
@@ -1100,8 +1085,6 @@ describe("server", () => {
                  expect(musicService.login).toHaveBeenCalledWith(serviceToken);
                  expect(musicLibrary.nowPlaying).toHaveBeenCalledWith(trackId);
                  expect(musicLibrary.stream).toHaveBeenCalledWith({ trackId });
-
-                  expect(stream.stream.destroyed).toBe(true);
                });
              });
            });
@@ -1150,8 +1133,6 @@ describe("server", () => {
                    trackId,
                    range: requestedRange,
                  });
-
-                  expect(stream.stream.destroyed).toBe(true);
                });
              });
  
@@ -1199,8 +1180,6 @@ describe("server", () => {
                    trackId,
                    range: "4000-5000",
                  });
-
-                  expect(stream.stream.destroyed).toBe(true);
                });
              });
            });
@@ -1321,6 +1300,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);
--- a/tests/smapi.test.ts
+++ b/tests/smapi.test.ts
@@ -18,13 +18,15 @@ import {
  track,
  artist,
  album,
-  coverArtURI,
+  defaultAlbumArtURI,
+  defaultArtistArtURI,
  searchResult,
  iconArtURI,
+  playlistAlbumArtURL,
  sonosifyMimeType,
  ratingAsInt,
  ratingFromInt,
-  internetRadioStation
+  scrollIndicesFrom,
 } from "../src/smapi";

 import { keys as i8nKeys } from "../src/i8n";
@@ -40,7 +42,7 @@ import {
  TRIP_HOP,
  PUNK,
  aPlaylist,
-  aRadioStation,
+  anAlbumSummary,
 } from "./builders";
 import { InMemoryMusicService } from "./in_memory_music_service";
 import supersoap from "./supersoap";
@@ -55,6 +57,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";

@@ -88,6 +91,8 @@ describe("rating to and from ints", () => {
 });

 describe("service config", () => {
+  jest.setTimeout(Number.parseInt(process.env["JEST_TIMEOUT"] || "5000"));
+  
  const bonobWithNoContextPath = url("http://localhost:1234");
  const bonobWithContextPath = url("http://localhost:5678/some-context-path");

@@ -118,7 +123,7 @@ describe("service config", () => {

      describe(STRINGS_ROUTE, () => {
        it("should return xml for the strings", async () => {
-          const xml: Document = await fetchStringsXml();
+          const xml = await fetchStringsXml();

          const sonosString = (id: string, lang: string) =>
            xpath.select(
@@ -133,8 +138,8 @@ describe("service config", () => {
            "Sonos koppelen aan music land"
          );

-          // no pt-BR translation, so use en-US
-          expect(sonosString("AppLinkMessage", "pt-BR")).toEqual(
+          // no fr-FR translation, so use en-US
+          expect(sonosString("AppLinkMessage", "fr-FR")).toEqual(
            "Linking sonos with music land"
          );
        });
@@ -354,10 +359,7 @@ describe("track", () => {
    const someTrack = aTrack({
      id: uuid(),
      // audio/x-flac should be mapped to audio/flac
-      encoding: {
-        player: "something",
-        mimeType: "audio/x-flac"
-      },
+      mimeType: "audio/x-flac",
      name: "great song",
      duration: randomInt(1000),
      number: randomInt(100),
@@ -412,10 +414,7 @@ describe("track", () => {
      const someTrack = aTrack({
        id: uuid(),
        // audio/x-flac should be mapped to audio/flac
-        encoding: {
-          player: "something",
-          mimeType: "audio/x-flac"
-        },
+        mimeType: "audio/x-flac",
        name: "great song",
        duration: randomInt(1000),
        number: randomInt(100),
@@ -475,7 +474,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}`,
@@ -483,18 +482,6 @@ describe("album", () => {
  });
 });

-describe("internetRadioStation", () => {
-  it("should map to a sonos internet stream", () => {
-    const station = aRadioStation()
-    expect(internetRadioStation(station)).toEqual({
-      itemType: "stream",
-      id: `internetRadioStation:${station.id}`,
-      title: station.name,
-      mimeType: "audio/mpeg"
-    })
-  });
-});
-
 describe("sonosifyMimeType", () => {
  describe("when is audio/x-flac", () => {
    it("should be mapped to audio/flac", () => {
@@ -511,8 +498,279 @@ 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", () => {
+    it("should format the url with encrypted urn", () => {
+      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" }),
+          }),
+        ],
+      });
+
+      expect(playlistAlbumArtURL(bonobUrl, playlist).href()).toEqual(
+        `http://localhost:1234/context-path/art/${encodeURIComponent(
+          formatForURL(externalArt1)
+        )}&${encodeURIComponent(
+          formatForURL(externalArt2)
+        )}/size/180?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"
  );
@@ -522,7 +780,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)
@@ -538,7 +796,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)
@@ -551,7 +809,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"
      );
@@ -559,6 +817,98 @@ 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("scrollIndicesFrom", () => {
+  describe("artists", () => {
+    describe("when sortName is the same as name", () => {
+      it("should be scroll indicies", () => {
+        const artistNames = [
+          "10,000 Maniacs",
+          "99 Bacon Sandwiches",
+          "[something with square brackets]",
+          "Aerosmith",
+          "Bob Marley",
+          "beatles", // intentionally lower case
+          "Cans",
+          "egg heads", // intentionally lower case
+          "Moon Cakes",
+          "Moon Boots",
+          "Numpty",
+          "Yellow brick road"
+        ]
+        const scrollIndicies = scrollIndicesFrom(artistNames.map(name => ({ name, sortName: name })))
+  
+        expect(scrollIndicies).toEqual("A,3,B,4,C,6,D,6,E,7,F,7,G,7,H,7,I,7,J,7,K,7,L,7,M,8,N,10,O,10,P,10,Q,10,R,10,S,10,T,10,U,10,V,10,W,10,X,10,Y,11,Z,11")
+      });
+    });
+
+    describe("when sortName is different to the name name", () => {
+      it("should be scroll indicies", () => {
+        const artistSortNames = [
+          "10,000 Maniacs",
+          "99 Bacon Sandwiches",
+          "[something with square brackets]",
+          "Aerosmith",
+          "Bob Marley",
+          "beatles", // intentionally lower case
+          "Cans",
+          "egg heads", // intentionally lower case
+          "Moon Cakes",
+          "Moon Boots",
+          "Numpty",
+          "Yellow brick road"
+        ]
+        const scrollIndicies = scrollIndicesFrom(artistSortNames.map(name => ({ name: uuid(), sortName: name })))
+  
+        expect(scrollIndicies).toEqual("A,3,B,4,C,6,D,6,E,7,F,7,G,7,H,7,I,7,J,7,K,7,L,7,M,8,N,10,O,10,P,10,Q,10,R,10,S,10,T,10,U,10,V,10,W,10,X,10,Y,11,Z,11")
+      });
+    })
+  });
+});
+
 describe("wsdl api", () => {
  const musicService = {
    generateToken: jest.fn(),
@@ -591,8 +941,6 @@ describe("wsdl api", () => {
    scrobble: jest.fn(),
    nowPlaying: jest.fn(),
    rate: jest.fn(),
-    radioStation: jest.fn(),
-    radioStations: jest.fn(),
  };
  const apiTokens = {
    mint: jest.fn(),
@@ -1111,6 +1459,7 @@ describe("wsdl api", () => {
                      title: "Artists",
                      albumArtURI: iconArtURI(bonobUrl, "artists").href(),
                      itemType: "container",
+                      canScroll: true,
                    },
                    {
                      id: "albums",
@@ -1174,12 +1523,6 @@ describe("wsdl api", () => {
                      albumArtURI: iconArtURI(bonobUrl, "mostPlayed").href(),
                      itemType: "albumList",
                    },
-                    {
-                      id: "internetRadio",
-                      title: "Internet Radio",
-                      albumArtURI: iconArtURI(bonobUrl, "radio").href(),
-                      itemType: "stream",
-                    },
                  ];
                  expect(root[0]).toEqual(
                    getMetadataResult({
@@ -1205,6 +1548,7 @@ describe("wsdl api", () => {
                      title: "Artiesten",
                      albumArtURI: iconArtURI(bonobUrl, "artists").href(),
                      itemType: "container",
+                      canScroll: true,
                    },
                    {
                      id: "albums",
@@ -1268,12 +1612,6 @@ describe("wsdl api", () => {
                      albumArtURI: iconArtURI(bonobUrl, "mostPlayed").href(),
                      itemType: "albumList",
                    },
-                    {
-                      id: "internetRadio",
-                      title: "Internet Radio",
-                      albumArtURI: iconArtURI(bonobUrl, "radio").href(),
-                      itemType: "stream",
-                    },
                  ];
                  expect(root[0]).toEqual(
                    getMetadataResult({
@@ -1366,10 +1704,10 @@ describe("wsdl api", () => {
            });

            describe("asking for playlists", () => {
-              const playlist1 = aPlaylist({ id: "1", name: "pl1", entries: []});
-              const playlist2 = aPlaylist({ id: "2", name: "pl2", entries: []});
-              const playlist3 = aPlaylist({ id: "3", name: "pl3", entries: []});
-              const playlist4 = aPlaylist({ id: "4", name: "pl4", entries: []});
+              const playlist1 = aPlaylist({ id: "1", name: "pl1" });
+              const playlist2 = aPlaylist({ id: "2", name: "pl2" });
+              const playlist3 = aPlaylist({ id: "3", name: "pl3" });
+              const playlist4 = aPlaylist({ id: "4", name: "pl4" });

              const playlists = [playlist1, playlist2, playlist3, playlist4];

@@ -1396,7 +1734,7 @@ describe("wsdl api", () => {
                        itemType: "playlist",
                        id: `playlist:${playlist.id}`,
                        title: playlist.name,
-                        albumArtURI: coverArtURI(
+                        albumArtURI: playlistAlbumArtURL(
                          bonobUrlWithAccessToken,
                          playlist
                        ).href(),
@@ -1428,7 +1766,7 @@ describe("wsdl api", () => {
                          itemType: "playlist",
                          id: `playlist:${playlist.id}`,
                          title: playlist.name,
-                          albumArtURI: coverArtURI(
+                          albumArtURI: playlistAlbumArtURL(
                            bonobUrlWithAccessToken,
                            playlist
                          ).href(),
@@ -1472,7 +1810,7 @@ describe("wsdl api", () => {
                          itemType: "album",
                          id: `album:${it.id}`,
                          title: it.name,
-                          albumArtURI: coverArtURI(
+                          albumArtURI: defaultAlbumArtURI(
                            bonobUrlWithAccessToken,
                            it
                          ).href(),
@@ -1509,7 +1847,7 @@ describe("wsdl api", () => {
                        itemType: "album",
                        id: `album:${it.id}`,
                        title: it.name,
-                        albumArtURI: coverArtURI(
+                        albumArtURI: defaultAlbumArtURI(
                          bonobUrlWithAccessToken,
                          it
                        ).href(),
@@ -1561,9 +1899,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,
@@ -1606,9 +1944,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,
@@ -1667,9 +2005,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,
@@ -1696,9 +2034,9 @@ describe("wsdl api", () => {
                            id: `artist:${it.id}`,
                            artistId: it.id,
                            title: it.name,
-                            albumArtURI: coverArtURI(
+                            albumArtURI: defaultArtistArtURI(
                              bonobUrlWithAccessToken,
-                              { coverArt: it.image }
+                              it
                            ).href(),
                          })
                        ),
@@ -1813,7 +2151,7 @@ describe("wsdl api", () => {
                        itemType: "album",
                        id: `album:${it.id}`,
                        title: it.name,
-                        albumArtURI: coverArtURI(
+                        albumArtURI: defaultAlbumArtURI(
                          bonobUrlWithAccessToken,
                          it
                        ).href(),
@@ -1861,7 +2199,7 @@ describe("wsdl api", () => {
                        itemType: "album",
                        id: `album:${it.id}`,
                        title: it.name,
-                        albumArtURI: coverArtURI(
+                        albumArtURI: defaultAlbumArtURI(
                          bonobUrlWithAccessToken,
                          it
                        ).href(),
@@ -1909,7 +2247,7 @@ describe("wsdl api", () => {
                        itemType: "album",
                        id: `album:${it.id}`,
                        title: it.name,
-                        albumArtURI: coverArtURI(
+                        albumArtURI: defaultAlbumArtURI(
                          bonobUrlWithAccessToken,
                          it
                        ).href(),
@@ -1957,7 +2295,7 @@ describe("wsdl api", () => {
                        itemType: "album",
                        id: `album:${it.id}`,
                        title: it.name,
-                        albumArtURI: coverArtURI(
+                        albumArtURI: defaultAlbumArtURI(
                          bonobUrlWithAccessToken,
                          it
                        ).href(),
@@ -2005,7 +2343,7 @@ describe("wsdl api", () => {
                        itemType: "album",
                        id: `album:${it.id}`,
                        title: it.name,
-                        albumArtURI: coverArtURI(
+                        albumArtURI: defaultAlbumArtURI(
                          bonobUrlWithAccessToken,
                          it
                        ).href(),
@@ -2053,7 +2391,7 @@ describe("wsdl api", () => {
                        itemType: "album",
                        id: `album:${it.id}`,
                        title: it.name,
-                        albumArtURI: coverArtURI(
+                        albumArtURI: defaultAlbumArtURI(
                          bonobUrlWithAccessToken,
                          it
                        ).href(),
@@ -2099,7 +2437,7 @@ describe("wsdl api", () => {
                        itemType: "album",
                        id: `album:${it.id}`,
                        title: it.name,
-                        albumArtURI: coverArtURI(
+                        albumArtURI: defaultAlbumArtURI(
                          bonobUrlWithAccessToken,
                          it
                        ).href(),
@@ -2145,7 +2483,7 @@ describe("wsdl api", () => {
                        itemType: "album",
                        id: `album:${it.id}`,
                        title: it.name,
-                        albumArtURI: coverArtURI(
+                        albumArtURI: defaultAlbumArtURI(
                          bonobUrlWithAccessToken,
                          it
                        ).href(),
@@ -2189,7 +2527,7 @@ describe("wsdl api", () => {
                        itemType: "album",
                        id: `album:${it.id}`,
                        title: it.name,
-                        albumArtURI: coverArtURI(
+                        albumArtURI: defaultAlbumArtURI(
                          bonobUrlWithAccessToken,
                          it
                        ).href(),
@@ -2236,7 +2574,7 @@ describe("wsdl api", () => {
                        itemType: "album",
                        id: `album:${it.id}`,
                        title: it.name,
-                        albumArtURI: coverArtURI(
+                        albumArtURI: defaultAlbumArtURI(
                          bonobUrlWithAccessToken,
                          it
                        ).href(),
@@ -2403,71 +2741,6 @@ describe("wsdl api", () => {
                });
              });
            });
-
-            describe("asking for internet radio stations", () => {
-              const station1 = aRadioStation();
-              const station2 = aRadioStation();
-              const station3 = aRadioStation();
-              const station4 = aRadioStation();
-
-              const stations = [station1, station2, station3, station4];
-
-              beforeEach(() => {
-                musicLibrary.radioStations.mockResolvedValue(stations);
-              });
-
-              describe("when they all fit on the page", () => {
-                it("should return them all", async () => {
-                  const paging = {
-                    index: 0,
-                    count: 100,
-                  };
-
-                  const result = await ws.getMetadataAsync({
-                    id: `internetRadio`,
-                    ...paging,
-                  });
-
-                  expect(result[0]).toEqual(
-                    getMetadataResult({
-                      mediaMetadata: stations.map((it) =>
-                        internetRadioStation(it)
-                      ),
-                      index: 0,
-                      total: stations.length,
-                    })
-                  );
-                  expect(musicLibrary.radioStations).toHaveBeenCalled();
-                });
-              });
-
-              describe("asking for a single page of stations", () => {
-                const pageOfStations = [station3, station4];
-
-                it("should return only that page", async () => {
-                  const paging = {
-                    index: 2,
-                    count: 2,
-                  };
-
-                  const result = await ws.getMetadataAsync({
-                    id: `internetRadio`,
-                    ...paging,
-                  });
-
-                  expect(result[0]).toEqual(
-                    getMetadataResult({
-                      mediaMetadata: pageOfStations.map((it) =>
-                        internetRadioStation(it)
-                      ),
-                      index: paging.index,
-                      total: stations.length,
-                    })
-                  );
-                  expect(musicLibrary.radioStations).toHaveBeenCalled();
-                });
-              });
-            });
          });
        });

@@ -2678,7 +2951,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,
@@ -2689,7 +2962,7 @@ describe("wsdl api", () => {
                          genre: track.genre?.name,
                          genreId: track.genre?.id,
                          duration: track.duration,
-                          albumArtURI: coverArtURI(
+                          albumArtURI: defaultAlbumArtURI(
                            bonobUrlWithAccessToken,
                            track
                          ).href(),
@@ -2726,7 +2999,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,
@@ -2737,7 +3010,7 @@ describe("wsdl api", () => {
                          genre: track.genre?.name,
                          genreId: track.genre?.id,
                          duration: track.duration,
-                          albumArtURI: coverArtURI(
+                          albumArtURI: defaultAlbumArtURI(
                            bonobUrlWithAccessToken,
                            track
                          ).href(),
@@ -2780,7 +3053,7 @@ describe("wsdl api", () => {
                      itemType: "album",
                      id: `album:${album.id}`,
                      title: album.name,
-                      albumArtURI: coverArtURI(
+                      albumArtURI: defaultAlbumArtURI(
                        bonobUrlWithAccessToken,
                        album
                      ).href(),
@@ -2845,27 +3118,6 @@ describe("wsdl api", () => {
                expect(musicService.login).toHaveBeenCalledWith(serviceToken);
              });
            });
-
-            describe("asking for a URI to stream a radio station", () => {
-              const someStation = aRadioStation()
-
-              beforeEach(() => {
-                musicLibrary.radioStation.mockResolvedValue(someStation);
-              })
-
-              it("should return the radio stations uri", async () => {
-                const root = await ws.getMediaURIAsync({
-                  id: `internetRadioStation:${someStation.id}`,
-                });
-
-                expect(root[0]).toEqual({
-                  getMediaURIResult: someStation.url,
-                });
-
-                expect(musicService.login).toHaveBeenCalledWith(serviceToken);
-                expect(musicLibrary.radioStation).toHaveBeenCalledWith(someStation.id);
-              });
-            });            
          });
        });

@@ -2877,6 +3129,7 @@ describe("wsdl api", () => {
          describe("when valid credentials are provided", () => {
            let ws: Client;

+            const someTrack = aTrack();

            beforeEach(async () => {
              ws = await createClientAsync(`${service.uri}?wsdl`, {
@@ -2884,15 +3137,10 @@ describe("wsdl api", () => {
                httpClient: supersoap(server),
              });
              setupAuthenticatedRequest(ws);
+              musicLibrary.track.mockResolvedValue(someTrack);
            });

            describe("asking for media metadata for a track", () => {
-              const someTrack = aTrack();
-
-              beforeEach(async () => {
-                musicLibrary.track.mockResolvedValue(someTrack);
-              });
-
              it("should return it with auth header", async () => {
                const root = await ws.getMediaMetadataAsync({
                  id: `track:${someTrack.id}`,
@@ -2911,28 +3159,52 @@ describe("wsdl api", () => {
                expect(musicLibrary.track).toHaveBeenCalledWith(someTrack.id);
              });
            });
+          });
+        });

-            describe("asking for media metadata for an internet radio station", () => {
-              const someStation = aRadioStation()
+        describe("getScrollIndices", () => {
+          itShouldHandleInvalidCredentials((ws) =>
+            ws.getScrollIndicesAsync({ id: `artists` })
+          );

-              beforeEach(() => {
-                musicLibrary.radioStation.mockResolvedValue(someStation);
-              })
+          describe("for artists", () => {
+            let ws: Client;

-              it("should return it with no auth header", async () => {
-                const root = await ws.getMediaMetadataAsync({
-                  id: `internetRadioStation:${someStation.id}`,
-                });
+            const artist1 = anArtist({ name: "Aerosmith" });
+            const artist2 = anArtist({ name: "Bob Marley" });
+            const artist3 = anArtist({ name: "Beatles" });
+            const artist4 = anArtist({ name: "Cat Empire" });
+            const artist5 = anArtist({ name: "Metallica" });
+            const artist6 = anArtist({ name: "Yellow Brick Road" });

-                expect(root[0]).toEqual({
-                  getMediaMetadataResult: internetRadioStation(someStation),
-                });
-                expect(musicService.login).toHaveBeenCalledWith(serviceToken);
-                expect(apiTokens.mint).toHaveBeenCalledWith(serviceToken);
-                expect(musicLibrary.radioStation).toHaveBeenCalledWith(someStation.id);
+            const artists = [artist1, artist2, artist3, artist4, artist5, artist6];
+            const artistsWithSortName = artists.map(it => ({ ...it, sortName: it.name }));
+
+            beforeEach(async () => {
+              ws = await createClientAsync(`${service.uri}?wsdl`, {
+                endpoint: service.uri,
+                httpClient: supersoap(server),
              });
-          });
-          });
+              setupAuthenticatedRequest(ws);
+              musicLibrary.artists.mockResolvedValue({
+                results: artistsWithSortName,
+                total: 6
+              });
+            });
+
+            it("should return paging information", async () => {
+              const root = await ws.getScrollIndicesAsync({
+                id: `artists`,
+              });
+
+              expect(root[0]).toEqual({
+                getScrollIndicesResult: scrollIndicesFrom(artistsWithSortName)
+              });
+              expect(musicService.login).toHaveBeenCalledWith(serviceToken);
+              expect(apiTokens.mint).toHaveBeenCalledWith(serviceToken);
+              expect(musicLibrary.artists).toHaveBeenCalledWith({ _index: 0, _count: undefined });
+            });
+        });
        });

        describe("createContainer", () => {
--- a/tests/subsonic.test.ts
+++ b/tests/subsonic.test.ts
--- a/tests/subsonic/generic.test.ts
+++ b/tests/subsonic/generic.test.ts
--- a/tests/subsonic/navidrome.test.ts
+++ b/tests/subsonic/navidrome.test.ts
@@ -0,0 +1,78 @@
+import { v4 as uuid } from "uuid";
+import { DODGY_IMAGE_NAME } from "../../src/subsonic";
+import { artistImageURN } from "../../src/subsonic/generic";
+import { artistSummaryFromNDArtist } from "../../src/subsonic/navidrome";
+
+
+describe("artistSummaryFromNDArtist", () => {
+  describe("when the orderArtistName is undefined", () => {
+    it("should use name", () => {
+      const artist = {
+        id: uuid(),
+        name: `name ${uuid()}`,
+        orderArtistName: undefined,
+        largeImageUrl: 'http://example.com/something.jpg'
+      }
+      expect(artistSummaryFromNDArtist(artist)).toEqual({
+        id: artist.id,
+        name: artist.name,
+        sortName: artist.name,
+        image: artistImageURN({ artistId: artist.id, artistImageURL: artist.largeImageUrl })
+      })
+    });
+  });
+
+  describe("when the artist image is valid", () => {
+    it("should create an ArtistSummary with Sortable", () => {
+      const artist = {
+        id: uuid(),
+        name: `name ${uuid()}`,
+        orderArtistName: `orderArtistName ${uuid()}`,
+        largeImageUrl: 'http://example.com/something.jpg'
+      }
+      expect(artistSummaryFromNDArtist(artist)).toEqual({
+        id: artist.id,
+        name: artist.name,
+        sortName: artist.orderArtistName,
+        image: artistImageURN({ artistId: artist.id, artistImageURL: artist.largeImageUrl })
+      })
+    });
+  });
+
+  describe("when the artist image is not valid", () => {
+    it("should create an ArtistSummary with Sortable", () => {
+      const artist = {
+        id: uuid(),
+        name: `name ${uuid()}`,
+        orderArtistName: `orderArtistName ${uuid()}`,
+        largeImageUrl: `http://example.com/${DODGY_IMAGE_NAME}`
+      }
+
+      expect(artistSummaryFromNDArtist(artist)).toEqual({
+        id: artist.id,
+        name: artist.name,
+        sortName: artist.orderArtistName,
+        image: artistImageURN({ artistId: artist.id, artistImageURL: artist.largeImageUrl })
+      });
+    });
+  });
+
+  describe("when the artist image is missing", () => {
+    it("should create an ArtistSummary with Sortable", () => {
+      const artist = {
+        id: uuid(),
+        name: `name ${uuid()}`,
+        orderArtistName: `orderArtistName ${uuid()}`,
+        largeImageUrl: undefined
+      }
+
+      expect(artistSummaryFromNDArtist(artist)).toEqual({
+        id: artist.id,
+        name: artist.name,
+        sortName: artist.orderArtistName,
+        image: artistImageURN({ artistId: artist.id, artistImageURL: artist.largeImageUrl })
+      });
+    });
+  });
+});
+
--- a/tests/utils.test.ts
+++ b/tests/utils.test.ts
@@ -1,4 +1,50 @@
-import { takeWithRepeats } from "../src/utils";
+import { asURLSearchParams, mask, takeWithRepeats } from "../src/utils";
+
+describe("asURLSearchParams", () => {
+  describe("empty q", () => {
+    it("should return empty params", () => {
+      const q = {};
+      const expected = new URLSearchParams();
+      expect(asURLSearchParams(q)).toEqual(expected);
+    });
+  });
+
+  describe("singular params", () => {
+    it("should append each", () => {
+      const q = {
+        a: 1,
+        b: "bee",
+        c: false,
+        d: true,
+      };
+      const expected = new URLSearchParams();
+      expected.append("a", "1");
+      expected.append("b", "bee");
+      expected.append("c", "false");
+      expected.append("d", "true");
+
+      expect(asURLSearchParams(q)).toEqual(expected);
+    });
+  });
+
+  describe("list params", () => {
+    it("should append each", () => {
+      const q = {
+        a: [1, "two", false, true],
+        b: "yippee",
+      };
+
+      const expected = new URLSearchParams();
+      expected.append("a", "1");
+      expected.append("a", "two");
+      expected.append("a", "false");
+      expected.append("a", "true");
+      expected.append("b", "yippee");
+
+      expect(asURLSearchParams(q)).toEqual(expected);
+    });
+  });
+});

 describe("takeWithRepeat", () => {
  describe("when there is nothing in the input", () => {
@@ -29,7 +75,32 @@ describe("takeWithRepeat", () => {
  describe("when there more than the amount required", () => {
    it("should return the first n items", () => {
      expect(takeWithRepeats(["a", "b", "c"], 2)).toEqual(["a", "b"]);
-      expect(takeWithRepeats(["a", undefined, "c"], 2)).toEqual(["a", undefined]);
+      expect(takeWithRepeats(["a", undefined, "c"], 2)).toEqual([
+        "a",
+        undefined,
+      ]);
    });
  });
 });
+
+describe("mask", () => {
+  it.each([
+    [{}, ["a", "b"], {}],
+    [{ foo: "bar" }, ["a", "b"], { foo: "bar" }],
+    [{ a: 1 }, ["a", "b"], { a: "****" }],
+    [{ a: 1, b: "dog" }, ["a", "b"], { a: "****", b: "****" }],
+    [
+      { a: 1, b: "dog", foo: "bar" },
+      ["a", "b"],
+      { a: "****", b: "****", foo: "bar" },
+    ],
+  ])(
+    "masking of %s, keys = %s, should result in %s",
+    (original: any, keys: string[], expected: any) => {
+      const copyOfOrig = JSON.parse(JSON.stringify(original));
+      const masked = mask(original, keys);
+      expect(masked).toEqual(expected);
+      expect(original).toEqual(copyOfOrig);
+    }
+  );
+});
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -50,7 +50,7 @@
    // "rootDirs": [],                        /* List of root folders whose combined content represents the structure of the project at runtime. */
    "typeRoots": [
      "./typings",
-      "./node_modules/@types"
+      "node_modules/@types"
    ]
     /* List of folders to include type definitions from. */,
    // "types": ["src/customTypes/scale-that-svg.d.ts"],                           /* Type declaration files to be included in compilation. */
--- a/web/icons/navidrome-radio.svg
+++ b/web/icons/navidrome-radio.svg
@@ -1,4 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24">
-    <path d="M20 6H8.3l8.26-3.34L15.88 1 3.24 6.15C2.51 6.43 2 7.17 2 8v12c0 1.1.89 2 2 2h16c1.11 0 2-.9 2-2V8c0-1.11-.89-2-2-2zm0 2v3h-2V9h-2v2H4V8h16zM4 20v-7h16v7H4z"></path>
-    <circle cx="8" cy="16.48" r="2.5"></circle>
-</svg>
--- a/yarn.lock
+++ b/yarn.lock
Author	SHA1	Message	Date
simojenki	add87e5df9	refactor	2022-07-29 13:45:57 +10:00
simojenki	38f53168fa	refactor	2022-07-08 15:24:07 +10:00
simojenki	166a4b5ec2	more tidy	2022-04-24 10:35:50 +10:00
simojenki	eb66393fe6	tidy	2022-04-24 10:35:50 +10:00
simojenki	730524d7a1	no more subsonic in the library	2022-04-24 10:35:50 +10:00
simojenki	1b14b88fb4	test workings	2022-04-24 10:35:50 +10:00
simojenki	d2f13416f6	tests working	2022-04-24 10:35:50 +10:00
simojenki	2997e5ac3b	prefer dev with z_ so goes to bottom of list	2022-04-24 10:35:50 +10:00
simojenki	d1ff224e89	moving things around	2022-04-24 10:35:50 +10:00
simojenki	ac266a3c46	Add index.ts for subsonic	2022-04-24 10:35:50 +10:00
simojenki	25857d7e5a	Extract ND into own class	2022-04-24 10:35:50 +10:00
simojenki	50cb5b2550	ref	2022-04-24 10:35:50 +10:00
simojenki	e37a09c266	ref	2022-04-24 10:35:50 +10:00
simojenki	88661d7c26	refactor	2022-04-24 10:35:50 +10:00
simojenki	6ad39ce044	refactor	2022-04-24 10:35:50 +10:00
simojenki	1c94a6d565	Move subsonic generic library into proper class	2022-04-24 10:35:50 +10:00
simojenki	00944a7a25	scoll indices based on ND sort name for artists	2022-04-24 10:35:50 +10:00
simojenki	c7352aefa3	scroll indicies based on name, for nd needs to be based on sortname from nd api	2022-04-24 10:35:50 +10:00