Merge pull request 'fix(ha): gate library tasks on the scan leader by default' (#11) from benvin/scan-leader-default into main

Reviewed-on: #11

.config/dotnet-tools.json

@@ -3,7 +3,7 @@
   "isRoot": true,
   "tools": {
     "dotnet-ef": {
-      "version": "9.0.9",
+      "version": "10.0.11",
       "commands": [
         "dotnet-ef"
       ]

.devcontainer/devcontainer.json

@@ -1,17 +1,31 @@
 {
     "name": "Development Jellyfin Server",
-    "image": "mcr.microsoft.com/devcontainers/dotnet:9.0-bookworm",
+    "image": "mcr.microsoft.com/devcontainers/dotnet:10.0-noble",
     "service": "app",
     "workspaceFolder": "/workspaces/${localWorkspaceFolderBasename}",
     // restores nuget packages, installs the dotnet workloads and installs the dev https certificate
     "postStartCommand": "sudo dotnet restore; sudo dotnet workload update; sudo dotnet dev-certs https --trust; sudo bash \"./.devcontainer/install-ffmpeg.sh\"",
-    // reads the extensions list and installs them
-    "postAttachCommand": "cat .vscode/extensions.json | jq -r .recommendations[] | xargs -n 1 code --install-extension",
+    // The previous way of installing extensions via the vs command dont work on selfhosted devcontainers
+    "customizations": {
+        "vscode": {
+            "extensions": [
+                "ms-dotnettools.csharp",
+                "editorconfig.editorconfig",
+                "github.vscode-github-actions",
+                "ms-dotnettools.vscode-dotnet-runtime",
+                "ms-dotnettools.csdevkit",
+                "alexcvzz.vscode-sqlite",
+                "streetsidesoftware.code-spell-checker",
+                "eamodio.gitlens",
+                "redhat.vscode-xml"
+            ]
+        }
+    },
     "features": {
         "ghcr.io/devcontainers/features/dotnet:2": {
             "version": "none",
-            "dotnetRuntimeVersions": "9.0",
-            "aspNetCoreRuntimeVersions": "9.0"
+            "dotnetRuntimeVersions": "10.0",
+            "aspNetCoreRuntimeVersions": "10.0"
         },
         "ghcr.io/devcontainers-extra/features/apt-packages:1": {
             "preserve_apt_list": false,
@@ -19,7 +33,7 @@
                 "libfontconfig1"
             ]
         },
-        "ghcr.io/devcontainers/features/docker-in-docker:2": {
+        "ghcr.io/devcontainers/features/docker-in-docker:3": {
             "dockerDashComposeVersion": "v2"
         },
         "ghcr.io/devcontainers/features/github-cli:1": {},

.devcontainer/install-ffmpeg.sh

@@ -15,7 +15,7 @@ sudo apt-get install software-properties-common -y
 sudo add-apt-repository universe -y
 
 sudo mkdir -p /etc/apt/keyrings
-curl -fsSL https://repo.jellyfin.org/jellyfin_team.gpg.key | sudo gpg --dearmor -o /etc/apt/keyrings/jellyfin.gpg
+curl -fsSL https://repo.jellyfin.org/jellyfin_team.gpg.key | sudo gpg --batch --yes --dearmor -o /etc/apt/keyrings/jellyfin.gpg
 export VERSION_OS="$( awk -F'=' '/^ID=/{ print $NF }' /etc/os-release )"
 export VERSION_CODENAME="$( awk -F'=' '/^VERSION_CODENAME=/{ print $NF }' /etc/os-release )"
 export DPKG_ARCHITECTURE="$( dpkg --print-architecture )"

.editorconfig

@@ -379,6 +379,9 @@ dotnet_diagnostic.CA1720.severity = suggestion
 # disable warning CA1724: Type names should not match namespaces
 dotnet_diagnostic.CA1724.severity = suggestion
 
+# disable warning CA1873: Avoid potentially expensive logging
+dotnet_diagnostic.CA1873.severity = suggestion
+
 # disable warning CA1805: Do not initialize unnecessarily
 dotnet_diagnostic.CA1805.severity = suggestion
 
@@ -400,6 +403,10 @@ dotnet_diagnostic.CA1861.severity = suggestion
 # disable warning CA2000: Dispose objects before losing scope
 dotnet_diagnostic.CA2000.severity = suggestion
 
+# TODO: Reevaluate when false positives are fixed: https://github.com/dotnet/roslyn-analyzers/issues/7699
+# disable warning CA2025: Do not pass 'IDisposable' instances into unawaited tasks
+dotnet_diagnostic.CA2025.severity = suggestion
+
 # disable warning CA2253: Named placeholders should not be numeric values
 dotnet_diagnostic.CA2253.severity = suggestion
 

.github/CODEOWNERS

@@ -1,4 +1,11 @@
-# Joshua must review all changes to deployment and build.sh
-.ci/*           @joshuaboniface
-deployment/*    @joshuaboniface
-build.sh        @joshuaboniface
+# Joshua must review all changes to bump_version and any files it touches
+bump_version                                            @joshuaboniface
+.github/ISSUE_TEMPLATE                                  @joshuaboniface
+MediaBrowser.Common/MediaBrowser.Common.csproj          @joshuaboniface
+Jellyfin.Data/Jellyfin.Data.csproj                      @joshuaboniface
+MediaBrowser.Controller/MediaBrowser.Controller.csproj  @joshuaboniface
+MediaBrowser.Model/MediaBrowser.Model.csproj            @joshuaboniface
+Emby.Naming/Emby.Naming.csproj                          @joshuaboniface
+src/Jellyfin.Extensions/Jellyfin.Extensions.csproj      @joshuaboniface
+# Core must approve all changes within the repo config
+.github/                                                @jellyfin/core

.github/ISSUE_TEMPLATE/issue report.yml

@@ -87,7 +87,12 @@ body:
       label: Jellyfin Server version
       description: What version of Jellyfin are you using?
       options:
-        - 10.10.0+
+        - 10.11.11
+        - 10.11.10
+        - 10.11.9
+        - 10.11.8
+        - 10.11.7
+        - 10.11.6
         - Master
         - Unstable
         - Older*
@@ -136,13 +141,14 @@ body:
         - **FFmpeg Version**: [e.g. 5.1.2-Jellyfin]
         - **Playback**: [Direct Play, Remux, Direct Stream, Transcode]
         - **Hardware Acceleration**: [e.g. none, VAAPI, NVENC, etc.]
+        - **CPU Model**: [e.g. AMD Ryzen 5 9600X, Intel Core i7-8565U, etc.]
         - **GPU Model**: [e.g. none, UHD630, GTX1050, etc.]
         - **Installed Plugins**: [e.g. none, Fanart, Anime, etc.]
         - **Reverse Proxy**: [e.g. none, nginx, apache, etc.]
         - **Base URL**: [e.g. none, yes: /example]
         - **Networking**: [e.g. Host, Bridge/NAT]
-        - **Jellyfin Data Storage**: [e.g. local SATA SSD, local HDD]
-        - **Media Storage**: [e.g. Local HDD, SMB Share]
+        - **Jellyfin Data Storage & Filesystem**: [e.g. local SATA SSD - ext4, local HDD - NTFS]
+        - **Media Storage & Filesystem**: [e.g. Local HDD - ext4, SMB Share]
         - **External Integrations**: [e.g. Jellystat, Jellyseerr]
       value: |
         - OS:
@@ -153,13 +159,14 @@ body:
         - FFmpeg Version:
         - Playback Method:
         - Hardware Acceleration:
+        - CPU Model:
         - GPU Model:
         - Plugins:
         - Reverse Proxy:
         - Base URL:
         - Networking:
-        - Jellyfin Data Storage:
-        - Media Storage:
+        - Jellyfin Data Storage & Filesystem:
+        - Media Storage & Filesystem:
         - External Integrations:
       render: markdown
     validations:

.github/pull_request_template.md

@@ -1,11 +1,15 @@
 <!--
 Ensure your title is short, descriptive, and in the imperative mood (Fix X, Change Y, instead of Fixed X, Changed Y).
-For a good inspiration of what to write in commit messages and PRs please review https://chris.beams.io/posts/git-commit/ and our documentation.
+For a good inspiration of what to write in commit messages and PRs please review https://chris.beams.io/posts/git-commit/ and our https://jellyfin.org/docs/general/contributing/issues/ page.
 -->
 
 **Changes**
 <!-- Describe your changes here in 1-5 sentences. -->
 
+**Code assistance**
+<!-- If code assistance was used, describe how it contributed
+e.g., code generated by LLM, explanation of code base, debugging guidance. -->
+
 **Issues**
 <!-- Tag any issues that this PR solves here.
 ex. Fixes # -->

.github/workflows/ci-codeql-analysis.yml

@@ -1,37 +0,0 @@
-name: "CodeQL"
-
-on:
-  push:
-    branches: [ master ]
-  pull_request:
-    branches: [ master ]
-  schedule:
-    - cron: '24 2 * * 4'
-
-jobs:
-  analyze:
-    name: Analyze
-    runs-on: ubuntu-latest
-
-    strategy:
-      fail-fast: false
-      matrix:
-        language: [ 'csharp' ]
-
-    steps:
-    - name: Checkout repository
-      uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
-    - name: Setup .NET
-      uses: actions/setup-dotnet@d4c94342e560b34958eacfc5d055d21461ed1c5d # v5.0.0
-      with:
-        dotnet-version: '9.0.x'
-
-    - name: Initialize CodeQL
-      uses: github/codeql-action/init@3599b3baa15b485a2e49ef411a7a4bb2452e7f93 # v3.30.5
-      with:
-        languages: ${{ matrix.language }}
-        queries: +security-extended
-    - name: Autobuild
-      uses: github/codeql-action/autobuild@3599b3baa15b485a2e49ef411a7a4bb2452e7f93 # v3.30.5
-    - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@3599b3baa15b485a2e49ef411a7a4bb2452e7f93 # v3.30.5

.github/workflows/ci-compat.yml

@@ -1,159 +0,0 @@
-name: ABI Compatibility
-on:
-  pull_request_target:
-
-permissions: {}
-
-jobs:
-  abi-head:
-    name: ABI - HEAD
-    runs-on: ubuntu-latest
-    permissions: read-all
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
-        with:
-          ref: ${{ github.event.pull_request.head.sha }}
-          repository: ${{ github.event.pull_request.head.repo.full_name }}
-
-      - name: Setup .NET
-        uses: actions/setup-dotnet@d4c94342e560b34958eacfc5d055d21461ed1c5d # v5.0.0
-        with:
-          dotnet-version: '9.0.x'
-
-      - name: Build
-        run: |
-          dotnet build Jellyfin.Server -o ./out
-
-      - name: Upload Head
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
-        with:
-          name: abi-head
-          retention-days: 14
-          if-no-files-found: error
-          path: out/
-
-  abi-base:
-    name: ABI - BASE
-    if: ${{ github.base_ref != '' }}
-    runs-on: ubuntu-latest
-    permissions: read-all
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
-        with:
-          ref: ${{ github.event.pull_request.head.sha }}
-          repository: ${{ github.event.pull_request.head.repo.full_name }}
-          fetch-depth: 0
-
-      - name: Setup .NET
-        uses: actions/setup-dotnet@d4c94342e560b34958eacfc5d055d21461ed1c5d # v5.0.0
-        with:
-          dotnet-version: '9.0.x'
-
-      - name: Checkout common ancestor
-        env:
-          HEAD_REF: ${{ github.head_ref }}
-        run: |
-          git remote add upstream https://github.com/${{ github.event.pull_request.base.repo.full_name }}
-          git -c protocol.version=2 fetch --prune --progress --no-recurse-submodules upstream +refs/heads/*:refs/remotes/upstream/* +refs/tags/*:refs/tags/*
-          ANCESTOR_REF=$(git merge-base upstream/${{ github.base_ref }} origin/$HEAD_REF)
-          git checkout --progress --force $ANCESTOR_REF
-
-      - name: Build
-        run: |
-          dotnet build Jellyfin.Server -o ./out
-
-      - name: Upload Head
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
-        with:
-          name: abi-base
-          retention-days: 14
-          if-no-files-found: error
-          path: out/
-
-  abi-diff:
-    permissions:
-      pull-requests: write  #  to create or update comment (peter-evans/create-or-update-comment)
-
-    name: ABI - Difference
-    if: ${{ github.event_name == 'pull_request_target' }}
-    runs-on: ubuntu-latest
-    needs:
-      - abi-head
-      - abi-base
-
-    steps:
-      - name: Download abi-head
-        uses: actions/download-artifact@634f93cb2916e3fdff6788551b99b062d0335ce0 # v5.0.0
-        with:
-          name: abi-head
-          path: abi-head
-
-      - name: Download abi-base
-        uses: actions/download-artifact@634f93cb2916e3fdff6788551b99b062d0335ce0 # v5.0.0
-        with:
-          name: abi-base
-          path: abi-base
-
-      - name: Setup ApiCompat
-        run: |
-          dotnet tool install --global Microsoft.DotNet.ApiCompat.Tool
-
-      - name: Run ApiCompat
-        id: diff
-        run: |
-          {
-            echo 'body<<EOF'
-            for file in Jellyfin.Data.dll MediaBrowser.Common.dll MediaBrowser.Controller.dll MediaBrowser.Model.dll Emby.Naming.dll Jellyfin.Extensions.dll Jellyfin.MediaEncoding.Keyframes.dll Jellyfin.Database.Implementations.dll Jellyfin.CodeAnalysis.dll; do
-              COMPAT_OUTPUT="$( { apicompat --left ./abi-base/${file} --right ./abi-head/${file}; } 2>&1 )"
-              if [ "APICompat ran successfully without finding any breaking changes." != "${COMPAT_OUTPUT}" ]; then
-                printf "\n${file}\n${COMPAT_OUTPUT}\n"
-              fi
-            done
-            echo EOF
-          } >> $GITHUB_OUTPUT
-
-      - name: Find difference comment
-        uses: peter-evans/find-comment@3eae4d37986fb5a8592848f6a574fdf654e61f9e # v3.1.0
-        id: find-comment
-        with:
-          issue-number: ${{ github.event.pull_request.number }}
-          direction: last
-          body-includes: abi-diff-workflow-comment
-
-      - name: Reply or edit difference comment (changed)
-        uses: peter-evans/create-or-update-comment@71345be0265236311c031f5c7866368bd1eff043 # v4.0.0
-        if: ${{ steps.diff.outputs.body != '' }}
-        with:
-          issue-number: ${{ github.event.pull_request.number }}
-          comment-id: ${{ steps.find-comment.outputs.comment-id }}
-          edit-mode: replace
-          token: ${{ secrets.JF_BOT_TOKEN }}
-          body: |
-            <!--abi-diff-workflow-comment-->
-            <details>
-            <summary>ABI Difference</summary>
-
-            ```
-            ${{ steps.diff.outputs.body }}
-            ```
-
-            </details>
-
-      - name: Reply or edit difference comment (unchanged)
-        uses: peter-evans/create-or-update-comment@71345be0265236311c031f5c7866368bd1eff043 # v4.0.0
-        if: ${{ steps.diff.outputs.body == '' && steps.find-comment.outputs.comment-id != '' }}
-        with:
-          issue-number: ${{ github.event.pull_request.number }}
-          comment-id: ${{ steps.find-comment.outputs.comment-id }}
-          edit-mode: replace
-          token: ${{ secrets.JF_BOT_TOKEN }}
-          body: |
-            <!--abi-diff-workflow-comment-->
-            <details>
-            <summary>ABI Difference</summary>
-
-            No changes to the ABI found. See history of this comment for previous changes.
-
-            </details>

.github/workflows/ci-openapi.yml

@@ -1,271 +0,0 @@
-name: OpenAPI
-on:
-  push:
-    branches:
-      - master
-    tags:
-      - 'v*'
-  pull_request_target:
-
-permissions: {}
-
-jobs:
-  openapi-head:
-    name: OpenAPI - HEAD
-    runs-on: ubuntu-latest
-    permissions: read-all
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
-        with:
-          ref: ${{ github.event.pull_request.head.sha }}
-          repository: ${{ github.event.pull_request.head.repo.full_name }}
-      - name: Setup .NET
-        uses: actions/setup-dotnet@d4c94342e560b34958eacfc5d055d21461ed1c5d # v5.0.0
-        with:
-          dotnet-version: '9.0.x'
-      - name: Generate openapi.json
-        run: dotnet test tests/Jellyfin.Server.Integration.Tests/Jellyfin.Server.Integration.Tests.csproj -c Release --filter "Jellyfin.Server.Integration.Tests.OpenApiSpecTests"
-      - name: Upload openapi.json
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
-        with:
-          name: openapi-head
-          retention-days: 14
-          if-no-files-found: error
-          path: tests/Jellyfin.Server.Integration.Tests/bin/Release/net9.0/openapi.json
-
-  openapi-base:
-    name: OpenAPI - BASE
-    if: ${{ github.base_ref != '' }}
-    runs-on: ubuntu-latest
-    permissions: read-all
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
-        with:
-          ref: ${{ github.event.pull_request.head.sha }}
-          repository: ${{ github.event.pull_request.head.repo.full_name }}
-          fetch-depth: 0
-      - name: Checkout common ancestor
-        env:
-          HEAD_REF: ${{ github.head_ref }}
-        run: |
-          git remote add upstream https://github.com/${{ github.event.pull_request.base.repo.full_name }}
-          git -c protocol.version=2 fetch --prune --progress --no-recurse-submodules upstream +refs/heads/*:refs/remotes/upstream/* +refs/tags/*:refs/tags/*
-          ANCESTOR_REF=$(git merge-base upstream/${{ github.base_ref }} origin/$HEAD_REF)
-          git checkout --progress --force $ANCESTOR_REF
-      - name: Setup .NET
-        uses: actions/setup-dotnet@d4c94342e560b34958eacfc5d055d21461ed1c5d # v5.0.0
-        with:
-          dotnet-version: '9.0.x'
-      - name: Generate openapi.json
-        run: dotnet test tests/Jellyfin.Server.Integration.Tests/Jellyfin.Server.Integration.Tests.csproj -c Release --filter "Jellyfin.Server.Integration.Tests.OpenApiSpecTests"
-      - name: Upload openapi.json
-        uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4.6.2
-        with:
-          name: openapi-base
-          retention-days: 14
-          if-no-files-found: error
-          path: tests/Jellyfin.Server.Integration.Tests/bin/Release/net9.0/openapi.json
-
-  openapi-diff:
-    permissions:
-      pull-requests: write  #  to create or update comment (peter-evans/create-or-update-comment)
-
-    name: OpenAPI - Difference
-    if: ${{ github.event_name == 'pull_request_target' }}
-    runs-on: ubuntu-latest
-    needs:
-      - openapi-head
-      - openapi-base
-    steps:
-      - name: Download openapi-head
-        uses: actions/download-artifact@634f93cb2916e3fdff6788551b99b062d0335ce0 # v5.0.0
-        with:
-          name: openapi-head
-          path: openapi-head
-      - name: Download openapi-base
-        uses: actions/download-artifact@634f93cb2916e3fdff6788551b99b062d0335ce0 # v5.0.0
-        with:
-          name: openapi-base
-          path: openapi-base
-      - name: Workaround openapi-diff issue
-        run: |
-          sed -i 's/"allOf"/"oneOf"/g' openapi-head/openapi.json
-          sed -i 's/"allOf"/"oneOf"/g' openapi-base/openapi.json
-      - name: Calculate OpenAPI difference
-        uses: docker://openapitools/openapi-diff
-        continue-on-error: true
-        with:
-          args: --fail-on-changed --markdown openapi-changes.md openapi-base/openapi.json openapi-head/openapi.json
-      - id: read-diff
-        name: Read openapi-diff output
-        run: |
-          # Read and fix markdown
-          body=$(cat openapi-changes.md)
-          # Write to workflow summary
-          echo "$body" >> $GITHUB_STEP_SUMMARY
-          # Set ApiChanged var
-          if [ "$body" != '' ]; then
-            echo "ApiChanged=1" >> "$GITHUB_OUTPUT"
-          else
-            echo "ApiChanged=0" >> "$GITHUB_OUTPUT"
-          fi
-          # Add header/footer for diff comment
-          echo '<!--openapi-diff-workflow-comment-->' > openapi-changes-reply.md
-          echo "<details>" >> openapi-changes-reply.md
-          echo "<summary>Changes in OpenAPI specification found. Expand to see details.</summary>" >> openapi-changes-reply.md
-          echo "" >> openapi-changes-reply.md
-          echo "$body" >> openapi-changes-reply.md
-          echo "" >> openapi-changes-reply.md
-          echo "</details>" >> openapi-changes-reply.md
-      - name: Find difference comment
-        uses: peter-evans/find-comment@3eae4d37986fb5a8592848f6a574fdf654e61f9e # v3.1.0
-        id: find-comment
-        with:
-          issue-number: ${{ github.event.pull_request.number }}
-          direction: last
-          body-includes: openapi-diff-workflow-comment
-      - name: Reply or edit difference comment (changed)
-        uses: peter-evans/create-or-update-comment@71345be0265236311c031f5c7866368bd1eff043 # v4.0.0
-        if: ${{ steps.read-diff.outputs.ApiChanged == '1' }}
-        with:
-          issue-number: ${{ github.event.pull_request.number }}
-          comment-id: ${{ steps.find-comment.outputs.comment-id }}
-          edit-mode: replace
-          body-path: openapi-changes-reply.md
-      - name: Edit difference comment (unchanged)
-        uses: peter-evans/create-or-update-comment@71345be0265236311c031f5c7866368bd1eff043 # v4.0.0
-        if: ${{ steps.read-diff.outputs.ApiChanged == '0' && steps.find-comment.outputs.comment-id != '' }}
-        with:
-          issue-number: ${{ github.event.pull_request.number }}
-          comment-id: ${{ steps.find-comment.outputs.comment-id }}
-          edit-mode: replace
-          body: |
-            <!--openapi-diff-workflow-comment-->
-
-            No changes to OpenAPI specification found. See history of this comment for previous changes.
-
-  publish-unstable:
-    name: OpenAPI - Publish Unstable Spec
-    if: ${{ github.event_name != 'pull_request_target' && !startsWith(github.ref, 'refs/tags/v') && contains(github.repository_owner, 'jellyfin') }}
-    runs-on: ubuntu-latest
-    needs:
-      - openapi-head
-    steps:
-      - name: Set unstable dated version
-        id: version
-        run: |-
-          echo "JELLYFIN_VERSION=$(date +'%Y%m%d%H%M%S')" >> $GITHUB_ENV
-      - name: Download openapi-head
-        uses: actions/download-artifact@634f93cb2916e3fdff6788551b99b062d0335ce0 # v5.0.0
-        with:
-          name: openapi-head
-          path: openapi-head
-      - name: Upload openapi.json (unstable) to repository server
-        uses: appleboy/scp-action@ff85246acaad7bdce478db94a363cd2bf7c90345 # v1.0.0
-        with:
-          host: "${{ secrets.REPO_HOST }}"
-          username: "${{ secrets.REPO_USER }}"
-          key: "${{ secrets.REPO_KEY }}"
-          source: openapi-head/openapi.json
-          strip_components: 1
-          target: "/srv/incoming/openapi/unstable/jellyfin-openapi-${{ env.JELLYFIN_VERSION }}"
-      - name: Move openapi.json (unstable) into place
-        uses: appleboy/ssh-action@2ead5e36573f08b82fbfce1504f1a4b05a647c6f # v1.2.2
-        with:
-          host: "${{ secrets.REPO_HOST }}"
-          username: "${{ secrets.REPO_USER }}"
-          key: "${{ secrets.REPO_KEY }}"
-          debug: false
-          script_stop: false
-          script: |
-            if ! test -d /run/workflows; then
-                sudo mkdir -p /run/workflows
-                sudo chown ${{ secrets.REPO_USER }} /run/workflows
-            fi
-            (
-            flock -x -w 300 200 || exit 1
-            TGT_DIR="/srv/repository/main/openapi"
-            LAST_SPEC="$( ls -lt ${TGT_DIR}/unstable/ | grep 'jellyfin-openapi' | head -1 | awk '{ print $NF }' )"
-            # If new and previous spec don't differ (diff retcode 0), remove incoming and finish
-            if diff /srv/incoming/openapi/unstable/jellyfin-openapi-${{ env.JELLYFIN_VERSION }}/openapi.json ${TGT_DIR}/unstable/${LAST_SPEC} &>/dev/null; then
-                rm -r /srv/incoming/openapi/unstable/jellyfin-openapi-${{ env.JELLYFIN_VERSION }}
-                exit 0
-            fi
-            # Move new spec into place
-            sudo mv /srv/incoming/openapi/unstable/jellyfin-openapi-${{ env.JELLYFIN_VERSION }}/openapi.json ${TGT_DIR}/unstable/jellyfin-openapi-${{ env.JELLYFIN_VERSION }}.json
-            # Delete previous jellyfin-openapi-unstable_previous.json
-            sudo rm ${TGT_DIR}/jellyfin-openapi-unstable_previous.json
-            # Move current jellyfin-openapi-unstable.json symlink to jellyfin-openapi-unstable_previous.json
-            sudo mv ${TGT_DIR}/jellyfin-openapi-unstable.json ${TGT_DIR}/jellyfin-openapi-unstable_previous.json
-            # Create new jellyfin-openapi-unstable.json symlink
-            sudo ln -s unstable/jellyfin-openapi-${{ env.JELLYFIN_VERSION }}.json ${TGT_DIR}/jellyfin-openapi-unstable.json
-            # Check that the previous openapi unstable spec link is correct
-            if [[ "$( readlink ${TGT_DIR}/jellyfin-openapi-unstable_previous.json )" != "unstable/${LAST_SPEC}" ]]; then
-                sudo rm ${TGT_DIR}/jellyfin-openapi-unstable_previous.json
-                sudo ln -s unstable/${LAST_SPEC} ${TGT_DIR}/jellyfin-openapi-unstable_previous.json
-            fi
-            ) 200>/run/workflows/openapi-unstable.lock
-
-  publish-stable:
-    name: OpenAPI - Publish Stable Spec
-    if: ${{ startsWith(github.ref, 'refs/tags/v') && contains(github.repository_owner, 'jellyfin') }}
-    runs-on: ubuntu-latest
-    needs:
-      - openapi-head
-    steps:
-      - name: Set version number
-        id: version
-        run: |-
-          echo "JELLYFIN_VERSION=${GITHUB_REF#refs/tags/v}" >> $GITHUB_ENV
-      - name: Download openapi-head
-        uses: actions/download-artifact@634f93cb2916e3fdff6788551b99b062d0335ce0 # v5.0.0
-        with:
-          name: openapi-head
-          path: openapi-head
-      - name: Upload openapi.json (stable) to repository server
-        uses: appleboy/scp-action@ff85246acaad7bdce478db94a363cd2bf7c90345 # v1.0.0
-        with:
-          host: "${{ secrets.REPO_HOST }}"
-          username: "${{ secrets.REPO_USER }}"
-          key: "${{ secrets.REPO_KEY }}"
-          source: openapi-head/openapi.json
-          strip_components: 1
-          target: "/srv/incoming/openapi/stable/jellyfin-openapi-${{ env.JELLYFIN_VERSION }}"
-      - name: Move openapi.json (stable) into place
-        uses: appleboy/ssh-action@2ead5e36573f08b82fbfce1504f1a4b05a647c6f # v1.2.2
-        with:
-          host: "${{ secrets.REPO_HOST }}"
-          username: "${{ secrets.REPO_USER }}"
-          key: "${{ secrets.REPO_KEY }}"
-          debug: false
-          script_stop: false
-          script: |
-            if ! test -d /run/workflows; then
-                sudo mkdir -p /run/workflows
-                sudo chown ${{ secrets.REPO_USER }} /run/workflows
-            fi
-            (
-            flock -x -w 300 200 || exit 1
-            TGT_DIR="/srv/repository/main/openapi"
-            LAST_SPEC="$( ls -lt ${TGT_DIR}/stable/ | grep 'jellyfin-openapi' | head -1 | awk '{ print $NF }' )"
-            # If new and previous spec don't differ (diff retcode 0), remove incoming and finish
-            if diff /srv/incoming/openapi/stable/jellyfin-openapi-${{ env.JELLYFIN_VERSION }}/openapi.json ${TGT_DIR}/stable/${LAST_SPEC} &>/dev/null; then
-                rm -r /srv/incoming/openapi/stable/jellyfin-openapi-${{ env.JELLYFIN_VERSION }}
-                exit 0
-            fi
-            # Move new spec into place
-            sudo mv /srv/incoming/openapi/stable/jellyfin-openapi-${{ env.JELLYFIN_VERSION }}/openapi.json ${TGT_DIR}/stable/jellyfin-openapi-${{ env.JELLYFIN_VERSION }}.json
-            # Delete previous jellyfin-openapi-stable_previous.json
-            sudo rm ${TGT_DIR}/jellyfin-openapi-stable_previous.json
-            # Move current jellyfin-openapi-stable.json symlink to jellyfin-openapi-stable_previous.json
-            sudo mv ${TGT_DIR}/jellyfin-openapi-stable.json ${TGT_DIR}/jellyfin-openapi-stable_previous.json
-            # Create new jellyfin-openapi-stable.json symlink
-            sudo ln -s stable/jellyfin-openapi-${{ env.JELLYFIN_VERSION }}.json ${TGT_DIR}/jellyfin-openapi-stable.json
-            # Check that the previous openapi stable spec link is correct
-            if [[ "$( readlink ${TGT_DIR}/jellyfin-openapi-stable_previous.json )" != "stable/${LAST_SPEC}" ]]; then
-                sudo rm ${TGT_DIR}/jellyfin-openapi-stable_previous.json
-                sudo ln -s stable/${LAST_SPEC} ${TGT_DIR}/jellyfin-openapi-stable_previous.json
-            fi
-            ) 200>/run/workflows/openapi-stable.lock

.github/workflows/ci-tests.yml

@@ -1,45 +0,0 @@
-name: Tests
-on:
-  push:
-    branches:
-      - master
-  # Run tests against the forked branch, but
-  # do not allow access to secrets
-  # https://docs.github.com/en/actions/using-workflows/events-that-trigger-workflows#workflows-in-forked-repositories
-  pull_request:
-
-env:
-  SDK_VERSION: "9.0.x"
-
-jobs:
-  run-tests:
-    strategy:
-      matrix:
-        os: ["ubuntu-latest", "macos-latest", "windows-latest"]
-      fail-fast: false
-
-    runs-on: "${{ matrix.os }}"
-    steps:
-      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
-
-      - uses: actions/setup-dotnet@d4c94342e560b34958eacfc5d055d21461ed1c5d # v5.0.0
-        with:
-          dotnet-version: ${{ env.SDK_VERSION }}
-
-      - name: Run DotNet CLI Tests
-        run: >
-          dotnet test Jellyfin.sln
-          --configuration Release
-          --collect:"XPlat Code Coverage"
-          --settings tests/coverletArgs.runsettings
-          --verbosity minimal
-
-      - name: Merge code coverage results
-        uses: danielpalme/ReportGenerator-GitHub-Action@1978db745da4a573ca4baa2d0f67175df51a148c # v5.4.16
-        with:
-          reports: "**/coverage.cobertura.xml"
-          targetdir: "merged/"
-          reporttypes: "Cobertura"
-
-      # TODO - which action / tool to use to publish code coverage results?
-      # - name: Publish code coverage results

.github/workflows/commands.yml

@@ -1,60 +0,0 @@
-name: Commands
-on:
-  issue_comment:
-    types:
-      - created
-      - edited
-  pull_request_target:
-    types:
-      - labeled
-      - synchronize
-
-permissions: {}
-jobs:
-  rebase:
-    name: Rebase
-    if: github.event.issue.pull_request != '' && contains(github.event.comment.body, '@jellyfin-bot rebase') && github.event.comment.author_association == 'MEMBER'
-    runs-on: ubuntu-latest
-    steps:
-      - name: Notify as seen
-        uses: peter-evans/create-or-update-comment@71345be0265236311c031f5c7866368bd1eff043 # v4.0.0
-        with:
-          token: ${{ secrets.JF_BOT_TOKEN }}
-          comment-id: ${{ github.event.comment.id }}
-          reactions: '+1'
-
-      - name: Checkout the latest code
-        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
-        with:
-          token: ${{ secrets.JF_BOT_TOKEN }}
-          fetch-depth: 0
-
-      - name: Automatic Rebase
-        uses: cirrus-actions/rebase@b87d48154a87a85666003575337e27b8cd65f691 # 1.8
-        env:
-          GITHUB_TOKEN: ${{ secrets.JF_BOT_TOKEN }}
-
-  rename:
-    name: Rename
-    if: contains(github.event.comment.body, '@jellyfin-bot rename') && github.event.comment.author_association == 'MEMBER'
-    runs-on: ubuntu-latest
-    steps:
-      - name: pull in script
-        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
-        with:
-          repository: jellyfin/jellyfin-triage-script
-      - name: install python
-        uses: actions/setup-python@e797f83bcb11b83ae66e0230d6156d7c80228e7c # v6.0.0
-        with:
-          python-version: '3.13'
-          cache: 'pip'
-      - name: install python packages
-        run: pip install -r rename/requirements.txt
-      - name: run rename script
-        run: python3 rename.py
-        working-directory: ./rename
-        env:
-          GH_TOKEN: ${{ secrets.JF_BOT_TOKEN }}
-          GH_REPO: ${{ github.repository }}
-          ISSUE: ${{ github.event.issue.number }}
-          COMMENT_ID: ${{ github.event.comment.id }}

.github/workflows/issue-stale.yml

@@ -1,35 +0,0 @@
-name: Stale Issue Labeler
-
-on:
-  schedule:
-    - cron: '30 1 * * *'
-  workflow_dispatch:
-
-permissions:
-  issues: write
-  pull-requests: write
-  actions: write
-
-jobs:
-  issues:
-    name: Check for stale issues
-    runs-on: ubuntu-latest
-    if: ${{ contains(github.repository, 'jellyfin/') }}
-    steps:
-      - uses: actions/stale@3a9db7e6a41a89f618792c92c0e97cc736e1b13f # v10.0.0
-        with:
-          repo-token: ${{ secrets.JF_BOT_TOKEN }}
-          ascending: true
-          days-before-stale: 120
-          days-before-pr-stale: -1
-          days-before-close: 21
-          days-before-pr-close: -1
-          operations-per-run: 500
-          exempt-issue-labels: regression,security,roadmap,future,feature,enhancement,confirmed
-          stale-issue-label: stale
-          stale-issue-message: |-
-            This issue has gone 120 days without an update and will be closed within 21 days if there is no new activity. To prevent this issue from being closed, please confirm the issue has not already been fixed by providing updated examples or logs.
-
-            If you have any questions you can use one of several ways to [contact us](https://jellyfin.org/contact).
-          close-issue-message: |-
-            This issue was closed due to inactivity.

.github/workflows/issue-template-check.yml

@@ -1,29 +0,0 @@
-name: Check Issue Template
-on:
-  issues:
-    types:
-      - opened
-jobs:
-  check_issue:
-    runs-on: ubuntu-latest
-    permissions:
-      issues: write
-    steps:
-      - name: pull in script
-        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
-        with:
-          repository: jellyfin/jellyfin-triage-script
-      - name: install python
-        uses: actions/setup-python@e797f83bcb11b83ae66e0230d6156d7c80228e7c # v6.0.0
-        with:
-          python-version: '3.13'
-          cache: 'pip'
-      - name: install python packages
-        run: pip install -r main-repo-triage/requirements.txt
-      - name: check and comment issue
-        working-directory: ./main-repo-triage
-        run: python3 single_issue_gha.py
-        env:
-          GH_TOKEN: ${{ secrets.JF_BOT_TOKEN }}
-          GH_REPO: ${{ github.repository }}
-          ISSUE: ${{ github.event.issue.number }}

.github/workflows/project-automation.yml

@@ -1,65 +0,0 @@
-name: Project Automation
-
-on:
-  push:
-    branches:
-      - master
-  pull_request_target:
-  issue_comment:
-
-permissions: {}
-jobs:
-  project:
-    name: Project board
-    runs-on: ubuntu-latest
-    if: ${{ github.repository == 'jellyfin/jellyfin' }}
-    steps:
-      - name: Remove from 'Current Release' project
-        uses: alex-page/github-project-automation-plus@303f24a24c67ce7adf565a07e96720faf126fe36 # v0.9.0
-        if: (github.event.pull_request || github.event.issue.pull_request) && !contains(github.event.*.labels.*.name, 'stable backport')
-        continue-on-error: true
-        with:
-          project: Current Release
-          action: delete
-          repo-token: ${{ secrets.JF_BOT_TOKEN }}
-
-      - name: Add to 'Release Next' project
-        uses: alex-page/github-project-automation-plus@303f24a24c67ce7adf565a07e96720faf126fe36 # v0.9.0
-        if: (github.event.pull_request || github.event.issue.pull_request) && github.event.action == 'opened'
-        continue-on-error: true
-        with:
-          project: Release Next
-          column: In progress
-          repo-token: ${{ secrets.JF_BOT_TOKEN }}
-
-      - name: Add to 'Current Release' project
-        uses: alex-page/github-project-automation-plus@303f24a24c67ce7adf565a07e96720faf126fe36 # v0.9.0
-        if: (github.event.pull_request || github.event.issue.pull_request) && !contains(github.event.*.labels.*.name, 'stable backport')
-        continue-on-error: true
-        with:
-          project: Current Release
-          column: In progress
-          repo-token: ${{ secrets.JF_BOT_TOKEN }}
-
-      - name: Check number of comments from the team member
-        if: github.event.issue.pull_request == '' && github.event.comment.author_association == 'MEMBER'
-        id: member_comments
-        run: echo "::set-output name=number::$(curl -s ${{ github.event.issue.comments_url }} | jq '.[] | select(.author_association == "MEMBER") | .author_association' | wc -l)"
-
-      - name: Move issue to needs triage
-        uses: alex-page/github-project-automation-plus@303f24a24c67ce7adf565a07e96720faf126fe36 # v0.9.0
-        if: github.event.issue.pull_request == '' && github.event.comment.author_association == 'MEMBER' && steps.member_comments.outputs.number <= 1
-        continue-on-error: true
-        with:
-          project: Issue Triage for Main Repo
-          column: Needs triage
-          repo-token: ${{ secrets.JF_BOT_TOKEN }}
-
-      - name: Add issue to triage project
-        uses: alex-page/github-project-automation-plus@303f24a24c67ce7adf565a07e96720faf126fe36 # v0.9.0
-        if: github.event.issue.pull_request == '' && github.event.action == 'opened'
-        continue-on-error: true
-        with:
-          project: Issue Triage for Main Repo
-          column: Pending response
-          repo-token: ${{ secrets.JF_BOT_TOKEN }}

.github/workflows/pull-request-conflict.yml

@@ -1,23 +0,0 @@
-name: Merge Conflict Labeler
-
-on:
-  push:
-    branches:
-      - master
-  pull_request_target:
-  issue_comment:
-
-permissions: {}
-jobs:
-  label:
-    name: Labeling
-    runs-on: ubuntu-latest
-    if: ${{ github.repository == 'jellyfin/jellyfin' && github.event.issue.pull_request }}
-    steps:
-      - name: Apply label
-        uses: eps1lon/actions-label-merge-conflict@1df065ebe6e3310545d4f4c4e862e43bdca146f0 # v3.0.3
-        if: ${{ github.event_name == 'push' || github.event_name == 'pull_request_target'}}
-        with:
-          dirtyLabel: 'merge conflict'
-          commentOnDirty: 'This pull request has merge conflicts. Please resolve the conflicts so the PR can be successfully reviewed and merged.'
-          repoToken: ${{ secrets.JF_BOT_TOKEN }}

.github/workflows/pull-request-stale.yaml

@@ -1,30 +0,0 @@
-name: Stale PR Check
-
-on:
-  schedule:
-    - cron: '30 */12 * * *'
-  workflow_dispatch:
-
-permissions:
-  pull-requests: write
-  actions: write
-
-jobs:
-  prs-stale-conflicts:
-    name: Check PRs with merge conflicts
-    runs-on: ubuntu-latest
-    if: ${{ contains(github.repository, 'jellyfin/') }}
-    steps:
-      - uses: actions/stale@3a9db7e6a41a89f618792c92c0e97cc736e1b13f # v10.0.0
-        with:
-          repo-token: ${{ secrets.JF_BOT_TOKEN }}
-          ascending: true
-          operations-per-run: 150
-          # The merge conflict action will remove the label when updated
-          remove-stale-when-updated: false
-          days-before-stale: -1
-          days-before-close: 90
-          days-before-issue-close: -1
-          stale-pr-label: merge conflict
-          close-pr-message: |-
-            This PR has been closed due to having unresolved merge conflicts.

.github/workflows/release-bump-version.yaml

@@ -1,82 +0,0 @@
-name: '🆙 Auto bump_version'
-
-on:
-  release:
-    types:
-      - published
-  workflow_dispatch:
-    inputs:
-      TAG_BRANCH:
-        required: true
-        description: release-x.y.z
-      NEXT_VERSION:
-        required: true
-        description: x.y.z
-
-jobs:
-  auto_bump_version:
-    runs-on: ubuntu-latest
-    if: ${{ github.event_name == 'release' && !contains(github.event.release.tag_name, 'rc') }}
-    env:
-      TAG_BRANCH: ${{ github.event.release.target_commitish }}
-    steps:
-      - name: Wait for deploy checks to finish
-        uses: jitterbit/await-check-suites@292a541bb7618078395b2ce711a0d89cfb8a568a # v1
-        with:
-          ref: ${{ env.TAG_BRANCH }}
-          intervalSeconds: 60
-          timeoutSeconds: 3600
-
-      - name: Setup YQ
-        uses: chrisdickinson/setup-yq@latest
-        with:
-          yq-version: v4.9.8
-
-      - name: Checkout Repository
-        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
-        with:
-          ref: ${{ env.TAG_BRANCH }}
-
-      - name: Setup EnvVars
-        run: |-
-          CURRENT_VERSION=$(yq e '.version' build.yaml)
-          CURRENT_MAJOR_MINOR=${CURRENT_VERSION%.*}
-          CURRENT_PATCH=${CURRENT_VERSION##*.}
-          echo "CURRENT_VERSION=${CURRENT_VERSION}" >> $GITHUB_ENV
-          echo "CURRENT_MAJOR_MINOR=${CURRENT_MAJOR_MINOR}" >> $GITHUB_ENV
-          echo "CURRENT_PATCH=${CURRENT_PATCH}" >> $GITHUB_ENV
-          echo "NEXT_VERSION=${CURRENT_MAJOR_MINOR}.$(($CURRENT_PATCH + 1))" >> $GITHUB_ENV
-
-      - name: Run bump_version
-        run: ./bump_version ${{ env.NEXT_VERSION }}
-
-      - name: Commit Changes
-        run: |-
-          git config user.name "jellyfin-bot"
-          git config user.email "team@jellyfin.org"
-          git checkout ${{ env.TAG_BRANCH }}
-          git commit -am "Bump version to ${{ env.NEXT_VERSION }}"
-          git push origin ${{ env.TAG_BRANCH }}
-
-  manual_bump_version:
-    runs-on: ubuntu-latest
-    if: ${{ github.event_name == 'workflow_dispatch' }}
-    env:
-      TAG_BRANCH: ${{ github.event.inputs.TAG_BRANCH }}
-      NEXT_VERSION: ${{ github.event.inputs.NEXT_VERSION }}
-    steps:
-      - name: Checkout Repository
-        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
-        with:
-          ref: ${{ env.TAG_BRANCH }}
-
-      - name: Run bump_version
-        run: ./bump_version ${{ env.NEXT_VERSION }}
-
-      - name: Commit Changes
-        run: |-
-          git config user.name "jellyfin-bot"
-          git config user.email "team@jellyfin.org"
-          git checkout ${{ env.TAG_BRANCH }}
-          git commit -am "Bump version to ${{ env.NEXT_VERSION }}"
-          git push origin ${{ env.TAG_BRANCH }}

.gitignore

@@ -19,6 +19,7 @@ local.properties
 .classpath
 .settings/
 .loadpath
+*.lscache
 
 # External tool builders
 .externalToolBuilders/
@@ -277,3 +278,7 @@ apiclient/generated
 
 # Omnisharp crash logs
 mono_crash.*.json
+
+# Devcontainer temp files
+.devcontainer/devcontainer-lock.json
+dotnet/

.vscode/launch.json

@@ -6,7 +6,7 @@
             "type": "coreclr",
             "request": "launch",
             "preLaunchTask": "build",
-            "program": "${workspaceFolder}/Jellyfin.Server/bin/Debug/net9.0/jellyfin.dll",
+            "program": "${workspaceFolder}/Jellyfin.Server/bin/Debug/net10.0/jellyfin.dll",
             "args": [],
             "cwd": "${workspaceFolder}/Jellyfin.Server",
             "console": "internalConsole",
@@ -22,7 +22,7 @@
             "type": "coreclr",
             "request": "launch",
             "preLaunchTask": "build",
-            "program": "${workspaceFolder}/Jellyfin.Server/bin/Debug/net9.0/jellyfin.dll",
+            "program": "${workspaceFolder}/Jellyfin.Server/bin/Debug/net10.0/jellyfin.dll",
             "args": ["--nowebclient"],
             "cwd": "${workspaceFolder}/Jellyfin.Server",
             "console": "internalConsole",
@@ -34,7 +34,7 @@
             "type": "coreclr",
             "request": "launch",
             "preLaunchTask": "build",
-            "program": "${workspaceFolder}/Jellyfin.Server/bin/Debug/net9.0/jellyfin.dll",
+            "program": "${workspaceFolder}/Jellyfin.Server/bin/Debug/net10.0/jellyfin.dll",
             "args": ["--nowebclient", "--ffmpeg", "/usr/lib/jellyfin-ffmpeg/ffmpeg"],
             "cwd": "${workspaceFolder}/Jellyfin.Server",
             "console": "internalConsole",

.woodpecker/ci.yaml

@@ -0,0 +1,79 @@
+when:
+  - event: pull_request
+  - event: push
+
+steps:
+  # Restore, build and test in one step so the NuGet cache stays on the step's
+  # own ephemeral storage instead of the 10Gi workspace volume.
+  # global.json pins the .NET 10 SDK (10.0.0, rollForward latestMinor).
+  - name: build-test
+    image: mcr.microsoft.com/dotnet/sdk:10.0
+    environment:
+      DOTNET_CLI_TELEMETRY_OPTOUT: "1"
+      DOTNET_NOLOGO: "1"
+    commands:
+      - dotnet --info
+      - dotnet restore Jellyfin.sln
+      - dotnet build Jellyfin.sln -c Release --no-restore
+      # libSkiaSharp needs fontconfig to load and the SDK image does not ship it.
+      # The mirror occasionally serves a half-synced index, so update is retried.
+      - apt-get -o Acquire::Retries=3 update || apt-get -o Acquire::Retries=3 update
+      - apt-get install -y --no-install-recommends libfontconfig1
+      - ldconfig -p | grep -q libfontconfig
+      # BackupServiceTests is excluded because BackupService refuses to write a
+      # backup with less than 5GiB free on its target path. The clone and build
+      # output fill 5.7G of the 9.8G workspace volume, leaving 4.1G. Raising the
+      # agent's workspace volume size is the only way to run it here.
+      - df -h .
+      - dotnet test Jellyfin.sln -c Release --no-build --verbosity minimal --filter "Category!=RequiresDocker&FullyQualifiedName!~Integration&FullyQualifiedName!~BackupServiceTests"
+    backend_options:
+      kubernetes:
+        serviceAccountName: jellyfin-ha-src
+        resources:
+          requests:
+            memory: 2Gi
+            cpu: 2
+            ephemeral-storage: 10Gi
+          limits:
+            memory: 8Gi
+            cpu: 4
+            ephemeral-storage: 20Gi
+
+  # The PostgreSQL migration tests are the only ones that run the startup migration chain against
+  # the provider production uses, and the filter above has always skipped them.
+  # The server runs inside this step: the kubernetes backend has no docker daemon for
+  # testcontainers, and a postgres service container deadlocks the step because the backend mounts
+  # the ReadWriteOnce workspace volume into service pods and schedules them on another node.
+  # Its data directory lives on the step's ephemeral storage, not on the workspace volume.
+  # Scoped to Jellyfin.Server.Tests: the three classes in Jellyfin.Database.Tests.PostgreSQL still
+  # start their own container, and PostgreSqlProviderTests already fails on main - on an EF 10
+  # scalar query and on its own data - which a third test in the class then inherits.
+  - name: postgres-migration-chain
+    image: mcr.microsoft.com/dotnet/sdk:10.0
+    depends_on:
+      - build-test
+    environment:
+      DOTNET_CLI_TELEMETRY_OPTOUT: "1"
+      DOTNET_NOLOGO: "1"
+      JELLYFIN_TEST_POSTGRES: "Host=127.0.0.1;Port=5432;Database=postgres;Username=postgres"
+    commands:
+      - apt-get -o Acquire::Retries=3 update || apt-get -o Acquire::Retries=3 update
+      - DEBIAN_FRONTEND=noninteractive apt-get install -y --no-install-recommends postgresql
+      - install -d -o postgres -g postgres /tmp/pgdata /tmp/pgrun
+      - PGBIN=$(ls -d /usr/lib/postgresql/*/bin | tail -1)
+      - su postgres -c "$PGBIN/initdb -D /tmp/pgdata -A trust -U postgres"
+      - su postgres -c "$PGBIN/pg_ctl -D /tmp/pgdata -o \"-c listen_addresses=127.0.0.1 -k /tmp/pgrun\" -l /tmp/pg.log -w start"
+      - dotnet build tests/Jellyfin.Server.Tests/Jellyfin.Server.Tests.csproj -c Release
+      - dotnet test tests/Jellyfin.Server.Tests/Jellyfin.Server.Tests.csproj -c Release --no-build --verbosity minimal --filter "Category=RequiresDocker"
+    backend_options:
+      kubernetes:
+        serviceAccountName: jellyfin-ha-src
+        resources:
+          requests:
+            memory: 2Gi
+            cpu: 2
+            ephemeral-storage: 6Gi
+          limits:
+            memory: 6Gi
+            cpu: 4
+            ephemeral-storage: 12Gi

CONTRIBUTORS.md

@@ -1,5 +1,6 @@
 # Jellyfin Contributors
 
+ - [0x25CBFC4F](https://github.com/0x25CBFC4F)
  - [1337joe](https://github.com/1337joe)
  - [97carmine](https://github.com/97carmine)
  - [Abbe98](https://github.com/Abbe98)
@@ -14,7 +15,7 @@
  - [bilde2910](https://github.com/bilde2910)
  - [bfayers](https://github.com/bfayers)
  - [BnMcG](https://github.com/BnMcG)
- - [Bond-009](https://github.com/Bond-009)
+ - [Bond_009](https://github.com/Bond-009)
  - [brianjmurrell](https://github.com/brianjmurrell)
  - [bugfixin](https://github.com/bugfixin)
  - [chaosinnovator](https://github.com/chaosinnovator)
@@ -31,6 +32,7 @@
  - [DaveChild](https://github.com/DaveChild)
  - [DavidFair](https://github.com/DavidFair)
  - [Delgan](https://github.com/Delgan)
+ - [DerMaddis](https://github.com/dermaddis)
  - [Derpipose](https://github.com/Derpipose)
  - [dcrdev](https://github.com/dcrdev)
  - [dhartung](https://github.com/dhartung)
@@ -54,6 +56,7 @@
  - [geilername](https://github.com/geilername)
  - [GermanCoding](https://github.com/GermanCoding)
  - [gnattu](https://github.com/gnattu)
+ - [gnuyent](https://github.com/gnuyent)
  - [GodTamIt](https://github.com/GodTamIt)
  - [grafixeyehero](https://github.com/grafixeyehero)
  - [h1nk](https://github.com/h1nk)
@@ -61,6 +64,7 @@
  - [HelloWorld017](https://github.com/HelloWorld017)
  - [ikomhoog](https://github.com/ikomhoog)
  - [iwalton3](https://github.com/iwalton3)
+ - [Jakob Kukla](https://github.com/jakobkukla)
  - [jftuga](https://github.com/jftuga)
  - [jkhsjdhjs](https://github.com/jkhsjdhjs)
  - [jmshrv](https://github.com/jmshrv)
@@ -69,8 +73,10 @@
  - [JustAMan](https://github.com/JustAMan)
  - [justinfenn](https://github.com/justinfenn)
  - [JPVenson](https://github.com/JPVenson)
+ - [JPUC1143](https://github.com/Jpuc1143/)
  - [KerryRJ](https://github.com/KerryRJ)
  - [Larvitar](https://github.com/Larvitar)
+ - [lbenini](https://github.com/lbenini)
  - [LeoVerto](https://github.com/LeoVerto)
  - [Liggy](https://github.com/Liggy)
  - [lmaonator](https://github.com/lmaonator)
@@ -83,15 +89,20 @@
  - [marius-luca-87](https://github.com/marius-luca-87)
  - [mark-monteiro](https://github.com/mark-monteiro)
  - [MarkCiliaVincenti](https://github.com/MarkCiliaVincenti)
+ - [Martin Reuter](https://github.com/reuterma24)
+ - [Matt Teahan](https://github.com/matt-teahan)
  - [Matt07211](https://github.com/Matt07211)
+ - [Matthew Jones](https://github.com/matthew-jones-uk)
  - [Maxr1998](https://github.com/Maxr1998)
  - [mcarlton00](https://github.com/mcarlton00)
+ - [Michael McElroy](https://github.com/mcmcelro)
  - [mitchfizz05](https://github.com/mitchfizz05)
  - [mohd-akram](https://github.com/mohd-akram)
  - [MrTimscampi](https://github.com/MrTimscampi)
  - [n8225](https://github.com/n8225)
  - [Nalsai](https://github.com/Nalsai)
  - [Narfinger](https://github.com/Narfinger)
+ - [Nathan McCrina](https://github.com/nfmccrina)
  - [NathanPickard](https://github.com/NathanPickard)
  - [neilsb](https://github.com/neilsb)
  - [nevado](https://github.com/nevado)
@@ -102,21 +113,26 @@
  - [OancaAndrei](https://github.com/OancaAndrei)
  - [obradovichv](https://github.com/obradovichv)
  - [oddstr13](https://github.com/oddstr13)
+ - [olsh](https://github.com/olsh)
  - [orryverducci](https://github.com/orryverducci)
+ - [PCEWLKR](https://github.com/PCEWLKR)
  - [petermcneil](https://github.com/petermcneil)
  - [Phlogi](https://github.com/Phlogi)
  - [pjeanjean](https://github.com/pjeanjean)
  - [ploughpuff](https://github.com/ploughpuff)
+ - [poytiis](https://github.com/poytiis)
  - [pR0Ps](https://github.com/pR0Ps)
  - [PrplHaz4](https://github.com/PrplHaz4)
  - [RazeLighter777](https://github.com/RazeLighter777)
  - [redSpoutnik](https://github.com/redSpoutnik)
  - [ringmatter](https://github.com/ringmatter)
+ - [Robert Lützner](https://github.com/rluetzner)
  - [ryan-hartzell](https://github.com/ryan-hartzell)
  - [s0urcelab](https://github.com/s0urcelab)
  - [sachk](https://github.com/sachk)
  - [sammyrc34](https://github.com/sammyrc34)
  - [samuel9554](https://github.com/samuel9554)
+ - [SapientGuardian](https://github.com/SapientGuardian)
  - [scheidleon](https://github.com/scheidleon)
  - [sebPomme](https://github.com/sebPomme)
  - [SegiH](https://github.com/SegiH)
@@ -126,6 +142,8 @@
  - [sl1288](https://github.com/sl1288)
  - [Smith00101010](https://github.com/Smith00101010)
  - [sorinyo2004](https://github.com/sorinyo2004)
+ - [Soumyadip Auddy](https://github.com/SoumyadipAuddy)
+ - [st7105](https://github.com/st7105)
  - [sparky8251](https://github.com/sparky8251)
  - [spookbits](https://github.com/spookbits)
  - [ssenart](https://github.com/ssenart)
@@ -148,12 +166,14 @@
  - [twinkybot](https://github.com/twinkybot)
  - [Ullmie02](https://github.com/Ullmie02)
  - [Unhelpful](https://github.com/Unhelpful)
+ - [Utku Özdemir](https://github.com/utkuozdemir)
  - [viaregio](https://github.com/viaregio)
  - [vitorsemeano](https://github.com/vitorsemeano)
  - [voodoos](https://github.com/voodoos)
  - [whooo](https://github.com/whooo)
  - [WiiPlayer2](https://github.com/WiiPlayer2)
  - [WillWill56](https://github.com/WillWill56)
+ - [WizardOfYendor1](https://github.com/WizardOfYendor1)
  - [wtayl0r](https://github.com/wtayl0r)
  - [Wuerfelbecher](https://github.com/Wuerfelbecher)
  - [Wunax](https://github.com/Wunax)
@@ -163,6 +183,7 @@
  - [XVicarious](https://github.com/XVicarious)
  - [YouKnowBlom](https://github.com/YouKnowBlom)
  - [ZachPhelan](https://github.com/ZachPhelan)
+ - [ZeusCraft10](https://github.com/ZeusCraft10)
  - [KristupasSavickas](https://github.com/KristupasSavickas)
  - [Pusta](https://github.com/pusta)
  - [nielsvanvelzen](https://github.com/nielsvanvelzen)
@@ -205,6 +226,21 @@
  - [theshoeshiner](https://github.com/theshoeshiner)
  - [TokerX](https://github.com/TokerX)
  - [GeneMarks](https://github.com/GeneMarks)
+ - [Kirill Nikiforov](https://github.com/allmazz)
+ - [bjorntp](https://github.com/bjorntp)
+ - [martenumberto](https://github.com/martenumberto)
+ - [ZeusCraft10](https://github.com/ZeusCraft10)
+ - [MarcoCoreDuo](https://github.com/MarcoCoreDuo)
+ - [LiHRaM](https://github.com/LiHRaM)
+ - [MSalman5230](https://github.com/MSalman5230)
+ - [dwandw](https://github.com/dwandw)
+ - [Lampan-git](https://github.com/Lampan-git)
+ - [elio42](https://github.com/elio42)
+ - [rwebster85](https://github.com/rwebster85)
+ - [Florin-Popescu](https://github.com/Florin-Popescu)
+ - [m0g3r](https://github.com/m0g3r)
+ - [martin-77](https://github.com/martin-77)
+ - [Oggeb1](https://github.com/Oggeb1)
 
 # Emby Contributors
 
@@ -215,7 +251,7 @@
  - [Mark2xv](https://github.com/Mark2xv)
  - [ScottRapsey](https://github.com/ScottRapsey)
  - [skynet600](https://github.com/skynet600)
- - [Cheesegeezer](https://githum.com/Cheesegeezer)
+ - [Cheesegeezer](https://github.com/Cheesegeezer)
  - [Radeon](https://github.com/radeonorama)
  - [gcw07](https://github.com/gcw07)
  - [SivaramAdhiappan](https://github.com/shivaram1190)
@@ -268,16 +304,3 @@
  - [tikuf](https://github.com/tikuf/)
  - [Tim Hobbs](https://github.com/timhobbs)
  - [SvenVandenbrande](https://github.com/SvenVandenbrande)
- - [olsh](https://github.com/olsh)
- - [lbenini](https://github.com/lbenini)
- - [gnuyent](https://github.com/gnuyent)
- - [Matthew Jones](https://github.com/matthew-jones-uk)
- - [Jakob Kukla](https://github.com/jakobkukla)
- - [Utku Özdemir](https://github.com/utkuozdemir)
- - [JPUC1143](https://github.com/Jpuc1143/)
- - [0x25CBFC4F](https://github.com/0x25CBFC4F)
- - [Robert Lützner](https://github.com/rluetzner)
- - [Nathan McCrina](https://github.com/nfmccrina)
- - [Martin Reuter](https://github.com/reuterma24)
- - [Michael McElroy](https://github.com/mcmcelro)
- - [Soumyadip Auddy](https://github.com/SoumyadipAuddy)

Directory.Build.props

@@ -20,7 +20,7 @@
   </ItemGroup>
 
   <!-- Custom Analyzers -->
-  <ItemGroup Condition=" '$(MSBuildProjectName)' != 'Jellyfin.CodeAnalysis' ">
+  <ItemGroup Condition=" '$(MSBuildProjectName)' != 'Jellyfin.CodeAnalysis' AND '$(Configuration)' == 'Debug' ">
     <ProjectReference Include="$(MSBuildThisFileDirectory)src/Jellyfin.CodeAnalysis/Jellyfin.CodeAnalysis.csproj" OutputItemType="Analyzer" />
   </ItemGroup>
 

Directory.Packages.props

@@ -4,96 +4,94 @@
   </PropertyGroup>
   <!-- Run "dotnet list package (dash,dash)outdated" to see the latest versions of each package.-->
   <ItemGroup Label="Package Dependencies">
-    <PackageVersion Include="AsyncKeyedLock" Version="7.1.6" />
+    <PackageVersion Include="AsyncKeyedLock" Version="8.0.2" />
     <PackageVersion Include="AutoFixture.AutoMoq" Version="4.18.1" />
-    <PackageVersion Include="AutoFixture.Xunit2" Version="4.18.1" />
+    <PackageVersion Include="AutoFixture.Xunit3" Version="4.19.0" />
     <PackageVersion Include="AutoFixture" Version="4.18.1" />
+    <PackageVersion Include="AWSSDK.S3" Version="4.0.103.1" />
     <PackageVersion Include="BDInfo" Version="0.8.0" />
-    <PackageVersion Include="BitFaster.Caching" Version="2.5.4" />
+    <PackageVersion Include="BitFaster.Caching" Version="2.6.1" />
     <PackageVersion Include="BlurHashSharp.SkiaSharp" Version="1.4.0-pre.1" />
     <PackageVersion Include="BlurHashSharp" Version="1.4.0-pre.1" />
     <PackageVersion Include="CommandLineParser" Version="2.9.1" />
-    <PackageVersion Include="coverlet.collector" Version="6.0.4" />
-    <PackageVersion Include="Diacritics" Version="4.0.17" />
+    <PackageVersion Include="coverlet.collector" Version="10.0.1" />
+    <PackageVersion Include="Diacritics" Version="4.1.8" />
     <PackageVersion Include="DiscUtils.Udf" Version="0.16.13" />
     <PackageVersion Include="DotNet.Glob" Version="3.1.3" />
-    <PackageVersion Include="FsCheck.Xunit" Version="3.3.1" />
-    <PackageVersion Include="HarfBuzzSharp.NativeAssets.Linux" Version="8.3.1.1" />
+    <PackageVersion Include="FsCheck.Xunit.v3" Version="3.3.4" />
+    <PackageVersion Include="HarfBuzzSharp.NativeAssets.Linux" Version="8.3.1.5" />
     <PackageVersion Include="ICU4N.Transliterator" Version="60.1.0-alpha.356" />
     <PackageVersion Include="IDisposableAnalyzers" Version="4.0.8" />
     <PackageVersion Include="Ignore" Version="0.2.1" />
-    <PackageVersion Include="Jellyfin.XmlTv" Version="10.8.0" />
+    <PackageVersion Include="Jellyfin.XmlTv" Version="10.12.0-pre1" />
     <PackageVersion Include="libse" Version="4.0.12" />
     <PackageVersion Include="LrcParser" Version="2025.623.0" />
-    <PackageVersion Include="MetaBrainz.MusicBrainz" Version="6.1.0" />
-    <PackageVersion Include="Microsoft.AspNetCore.Authorization" Version="9.0.9" />
-    <PackageVersion Include="Microsoft.AspNetCore.Mvc.Testing" Version="9.0.9" />
-    <PackageVersion Include="Microsoft.CodeAnalysis.BannedApiAnalyzers" Version="4.14.0" />
-    <PackageVersion Include="Microsoft.CodeAnalysis.Common" Version="4.14.0" />
-    <PackageVersion Include="Microsoft.CodeAnalysis.CSharp" Version="4.14.0" />
-    <PackageVersion Include="Microsoft.CodeAnalysis.Analyzers" Version="3.11.0" />
-    <PackageVersion Include="Microsoft.Data.Sqlite" Version="9.0.9" />
-    <PackageVersion Include="Microsoft.EntityFrameworkCore.Design" Version="9.0.9" />
-    <PackageVersion Include="Microsoft.EntityFrameworkCore.Relational" Version="9.0.9" />
-    <PackageVersion Include="Microsoft.EntityFrameworkCore.Sqlite" Version="9.0.9" />
-    <PackageVersion Include="Microsoft.EntityFrameworkCore.Tools" Version="9.0.9" />
-    <PackageVersion Include="Microsoft.Extensions.Caching.Abstractions" Version="9.0.9" />
-    <PackageVersion Include="Microsoft.Extensions.Caching.Memory" Version="9.0.9" />
-    <PackageVersion Include="Microsoft.Extensions.Configuration.Abstractions" Version="9.0.9" />
-    <PackageVersion Include="Microsoft.Extensions.Configuration.Binder" Version="9.0.9" />
-    <PackageVersion Include="Microsoft.Extensions.Configuration.EnvironmentVariables" Version="9.0.9" />
-    <PackageVersion Include="Microsoft.Extensions.Configuration.Json" Version="9.0.9" />
-    <PackageVersion Include="Microsoft.Extensions.DependencyInjection.Abstractions" Version="9.0.9" />
-    <PackageVersion Include="Microsoft.Extensions.DependencyInjection" Version="9.0.9" />
-    <PackageVersion Include="Microsoft.Extensions.Diagnostics.HealthChecks.EntityFrameworkCore" Version="9.0.9" />
-    <PackageVersion Include="Microsoft.Extensions.Diagnostics.HealthChecks" Version="9.0.9" />
-    <PackageVersion Include="Microsoft.Extensions.Hosting.Abstractions" Version="9.0.9" />
-    <PackageVersion Include="Microsoft.Extensions.Http" Version="9.0.9" />
-    <PackageVersion Include="Microsoft.Extensions.Logging.Abstractions" Version="9.0.9" />
-    <PackageVersion Include="Microsoft.Extensions.Logging" Version="9.0.9" />
-    <PackageVersion Include="Microsoft.Extensions.Options" Version="9.0.9" />
-    <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="17.14.1" />
+    <PackageVersion Include="MetaBrainz.MusicBrainz" Version="8.0.1" />
+    <PackageVersion Include="Microsoft.AspNetCore.Authorization" Version="10.0.11" />
+    <PackageVersion Include="Microsoft.AspNetCore.Mvc.Testing" Version="10.0.11" />
+    <PackageVersion Include="Microsoft.CodeAnalysis.BannedApiAnalyzers" Version="5.6.0" />
+    <PackageVersion Include="Microsoft.CodeAnalysis.Common" Version="5.9.0" />
+    <PackageVersion Include="Microsoft.CodeAnalysis.CSharp" Version="5.9.0" />
+    <PackageVersion Include="Microsoft.CodeAnalysis.Analyzers" Version="5.9.0" />
+    <PackageVersion Include="Microsoft.Data.Sqlite" Version="10.0.11" />
+    <PackageVersion Include="Microsoft.EntityFrameworkCore.Design" Version="10.0.11" />
+    <PackageVersion Include="Microsoft.EntityFrameworkCore.Relational" Version="10.0.11" />
+    <PackageVersion Include="Microsoft.EntityFrameworkCore.Sqlite" Version="10.0.11" />
+    <PackageVersion Include="Microsoft.EntityFrameworkCore.Tools" Version="10.0.11" />
+    <PackageVersion Include="Microsoft.Extensions.Caching.Abstractions" Version="10.0.11" />
+    <PackageVersion Include="Microsoft.Extensions.Caching.Memory" Version="10.0.11" />
+    <PackageVersion Include="Microsoft.Extensions.Configuration.Abstractions" Version="10.0.11" />
+    <PackageVersion Include="Microsoft.Extensions.Configuration.Binder" Version="10.0.11" />
+    <PackageVersion Include="Microsoft.Extensions.DependencyInjection" Version="10.0.11" />
+    <PackageVersion Include="Microsoft.Extensions.Diagnostics.HealthChecks.EntityFrameworkCore" Version="10.0.11" />
+    <PackageVersion Include="Microsoft.Extensions.Hosting.Abstractions" Version="10.0.11" />
+    <PackageVersion Include="Microsoft.Extensions.Http" Version="10.0.11" />
+    <PackageVersion Include="Microsoft.Extensions.Logging" Version="10.0.11" />
+    <PackageVersion Include="Microsoft.Extensions.Logging.Abstractions" Version="10.0.11" />
+    <PackageVersion Include="Microsoft.Extensions.Options" Version="10.0.11" />
+    <PackageVersion Include="Microsoft.NET.Test.Sdk" Version="18.9.0" />
     <PackageVersion Include="MimeTypes" Version="2.5.2" />
-    <PackageVersion Include="Morestachio" Version="5.0.1.631" />
+    <PackageVersion Include="Morestachio" Version="5.0.1.670" />
     <PackageVersion Include="Moq" Version="4.18.4" />
     <PackageVersion Include="NEbml" Version="1.1.0.5" />
     <PackageVersion Include="Newtonsoft.Json" Version="13.0.4" />
+    <PackageVersion Include="Npgsql" Version="10.0.3" />
+    <PackageVersion Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="10.0.3" />
+    <PackageVersion Include="PDFtoImage" Version="5.2.1" />
     <PackageVersion Include="PlaylistsNET" Version="1.4.1" />
     <PackageVersion Include="prometheus-net.AspNetCore" Version="8.2.1" />
     <PackageVersion Include="prometheus-net.DotNetRuntime" Version="4.4.1" />
     <PackageVersion Include="prometheus-net" Version="8.2.1" />
-    <PackageVersion Include="Polly" Version="8.6.4" />
-    <PackageVersion Include="Serilog.AspNetCore" Version="9.0.0" />
+    <PackageVersion Include="Polly" Version="8.7.0" />
+    <PackageVersion Include="Serilog.AspNetCore" Version="10.0.0" />
     <PackageVersion Include="Serilog.Enrichers.Thread" Version="4.0.0" />
     <PackageVersion Include="Serilog.Expressions" Version="5.0.0" />
-    <PackageVersion Include="Serilog.Settings.Configuration" Version="9.0.0" />
+    <PackageVersion Include="Serilog.Settings.Configuration" Version="10.0.1" />
     <PackageVersion Include="Serilog.Sinks.Async" Version="2.1.0" />
-    <PackageVersion Include="Serilog.Sinks.Console" Version="6.0.0" />
+    <PackageVersion Include="Serilog.Sinks.Console" Version="6.1.1" />
     <PackageVersion Include="Serilog.Sinks.File" Version="7.0.0" />
     <PackageVersion Include="Serilog.Sinks.Graylog" Version="3.1.1" />
     <PackageVersion Include="SerilogAnalyzer" Version="0.15.0" />
-    <PackageVersion Include="SharpFuzz" Version="2.2.0" />
-    <!-- Pinned to 3.116.1 because https://github.com/jellyfin/jellyfin/pull/14255 -->
-    <PackageVersion Include="SkiaSharp" Version="3.116.1" />
-    <PackageVersion Include="SkiaSharp.HarfBuzz" Version="3.116.1" />
-    <PackageVersion Include="SkiaSharp.NativeAssets.Linux" Version="3.116.1" />
+    <PackageVersion Include="SharpCompress" Version="0.50.4" />
+    <PackageVersion Include="SharpFuzz" Version="2.3.0" />
+    <PackageVersion Include="SkiaSharp" Version="3.119.4" />
+    <PackageVersion Include="SkiaSharp.HarfBuzz" Version="3.119.4" />
+    <PackageVersion Include="SkiaSharp.NativeAssets.Linux" Version="3.119.4" />
     <PackageVersion Include="SmartAnalyzers.MultithreadingAnalyzer" Version="1.1.31" />
+    <PackageVersion Include="StackExchange.Redis" Version="2.13.17" />
     <PackageVersion Include="StyleCop.Analyzers" Version="1.2.0-beta.556" />
-    <PackageVersion Include="Svg.Skia" Version="3.2.1" />
-    <PackageVersion Include="Swashbuckle.AspNetCore.ReDoc" Version="6.5.0" />
-    <PackageVersion Include="Swashbuckle.AspNetCore" Version="6.2.3" />
-    <PackageVersion Include="System.Globalization" Version="4.3.0" />
-    <PackageVersion Include="System.Linq.Async" Version="6.0.3" />
-    <PackageVersion Include="System.Text.Encoding.CodePages" Version="9.0.9" />
-    <PackageVersion Include="System.Text.Json" Version="9.0.9" />
-    <PackageVersion Include="System.Threading.Tasks.Dataflow" Version="9.0.9" />
+    <PackageVersion Include="Svg.Skia" Version="3.7.0" />
+    <PackageVersion Include="Swashbuckle.AspNetCore.ReDoc" Version="10.2.3" />
+    <PackageVersion Include="Swashbuckle.AspNetCore" Version="10.2.3" />
+    <PackageVersion Include="System.Text.Json" Version="10.0.11" />
     <PackageVersion Include="TagLibSharp" Version="2.3.0" />
-    <PackageVersion Include="z440.atl.core" Version="7.5.0" />
-    <PackageVersion Include="TMDbLib" Version="2.3.0" />
-    <PackageVersion Include="UTF.Unknown" Version="2.6.0" />
-    <PackageVersion Include="Xunit.Priority" Version="1.1.6" />
-    <PackageVersion Include="xunit.runner.visualstudio" Version="2.8.2" />
-    <PackageVersion Include="Xunit.SkippableFact" Version="1.5.23" />
-    <PackageVersion Include="xunit" Version="2.9.3" />
+    <PackageVersion Include="Testcontainers.PostgreSql" Version="4.15.0" />
+    <PackageVersion Include="Testcontainers.Redis" Version="4.15.0" />
+    <PackageVersion Include="z440.atl.core" Version="7.16.0" />
+    <PackageVersion Include="TMDbLib" Version="3.0.0" />
+    <PackageVersion Include="UTF.Unknown" Version="2.7.0" />
+    <PackageVersion Include="xunit.runner.visualstudio" Version="3.1.5" />
+    <PackageVersion Include="xunit.v3" Version="3.2.2" />
+    <PackageVersion Include="Xunit.v3.Priority" Version="1.1.18" />
   </ItemGroup>
-</Project>
+</Project>

Dockerfile

@@ -0,0 +1,96 @@
+# syntax=docker/dockerfile:1
+
+# ── Build stage ──────────────────────────────────────────────────────────────
+FROM --platform=linux/amd64 mcr.microsoft.com/dotnet/sdk:10.0 AS build
+
+WORKDIR /src
+
+# Restore dependencies first (layer-cache friendly)
+COPY ["Jellyfin.sln", "global.json", "nuget.config", "Directory.Build.props", "Directory.Packages.props", "./"]
+COPY ["SharedVersion.cs", "BannedSymbols.txt", "stylecop.json", "./"]
+
+# Copy all project files so dotnet restore can resolve the full dependency graph
+COPY Emby.Naming/                                   Emby.Naming/
+COPY Emby.Photos/                                   Emby.Photos/
+COPY Emby.Server.Implementations/                  Emby.Server.Implementations/
+COPY Jellyfin.Api/                                  Jellyfin.Api/
+COPY Jellyfin.Data/                                 Jellyfin.Data/
+COPY Jellyfin.Server/                               Jellyfin.Server/
+COPY Jellyfin.Server.Implementations/              Jellyfin.Server.Implementations/
+COPY MediaBrowser.Common/                           MediaBrowser.Common/
+COPY MediaBrowser.Controller/                       MediaBrowser.Controller/
+COPY MediaBrowser.LocalMetadata/                    MediaBrowser.LocalMetadata/
+COPY MediaBrowser.MediaEncoding/                    MediaBrowser.MediaEncoding/
+COPY MediaBrowser.Model/                            MediaBrowser.Model/
+COPY MediaBrowser.Providers/                        MediaBrowser.Providers/
+COPY MediaBrowser.XbmcMetadata/                    MediaBrowser.XbmcMetadata/
+COPY src/                                           src/
+
+RUN dotnet restore Jellyfin.Server/Jellyfin.Server.csproj \
+      --runtime linux-x64
+
+# Publish the server (and all transitive dependencies, including the
+# PostgreSQL provider assembly added by this fork).
+# Note: TreatWarningsAsErrors is disabled for the Docker build — StyleCop
+# analyzer violations in upstream src/ projects would otherwise block the
+# image build. StyleCop is enforced in the CI pipeline, not the Dockerfile.
+RUN dotnet publish Jellyfin.Server/Jellyfin.Server.csproj \
+      --configuration Release \
+      --runtime linux-x64 \
+      --self-contained false \
+      --no-restore \
+      -p:TreatWarningsAsErrors=false \
+      --output /app
+
+# ── Web client stage ──────────────────────────────────────────────────────────
+# Install jellyfin-web via the official Jellyfin apt repo.
+# Package suffix in the bookworm repo is +deb12 (e.g. 12.0+deb12).
+# Web assets land at /usr/share/jellyfin/web/ — stable, prebuilt, no npm required.
+# The web client version must match the server version this fork is based on.
+FROM --platform=linux/amd64 debian:bookworm-slim AS webclient
+
+RUN apt-get update \
+ && apt-get install -y --no-install-recommends curl gnupg ca-certificates \
+ && curl -fsSL https://repo.jellyfin.org/jellyfin_team.gpg.key \
+    | gpg --dearmor -o /usr/share/keyrings/jellyfin.gpg \
+ && echo "deb [arch=amd64 signed-by=/usr/share/keyrings/jellyfin.gpg] https://repo.jellyfin.org/debian bookworm main" \
+    > /etc/apt/sources.list.d/jellyfin.list \
+ && apt-get update \
+ && apt-get install -y --no-install-recommends "jellyfin-web=12.0+deb12" \
+ && rm -rf /var/lib/apt/lists/* \
+ && echo "Web client files:" && ls /usr/share/jellyfin/web/ | head -10
+
+# ── Runtime stage ─────────────────────────────────────────────────────────────
+FROM --platform=linux/amd64 mcr.microsoft.com/dotnet/aspnet:10.0
+
+# Install FFmpeg and native dependencies required by SkiaSharp and fontconfig.
+# libicu, libssl, and liblttng-ust are already present in the dotnet/aspnet base image.
+RUN apt-get update \
+ && apt-get install -y --no-install-recommends \
+      ffmpeg \
+      fontconfig \
+      libfontconfig1 \
+      libfreetype6 \
+ && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /jellyfin
+
+COPY --from=build /app .
+COPY --from=webclient /usr/share/jellyfin/web ./jellyfin-web/
+
+# Jellyfin default ports
+EXPOSE 8096
+EXPOSE 8920
+
+# Data / config volumes
+VOLUME ["/config", "/cache", "/media"]
+
+ENV JELLYFIN_DATA_DIR=/config \
+    JELLYFIN_CACHE_DIR=/cache \
+    JELLYFIN_LOG_DIR=/config/log \
+    JELLYFIN_CONFIG_DIR=/config
+
+ENTRYPOINT ["./jellyfin", \
+            "--datadir", "/config", \
+            "--cachedir", "/cache", \
+            "--webdir", "/jellyfin/jellyfin-web"]

Dockerfile.runtime

@@ -0,0 +1,55 @@
+# syntax=docker/dockerfile:1
+# Runtime-only image — the .NET publish step runs on the CI host (runner),
+# not inside this Dockerfile.
+
+# ── Web client stage ──────────────────────────────────────────────────────────
+# Install jellyfin-web via the official Jellyfin apt repo.
+# Package suffix in the bookworm repo is +deb12 (e.g. 12.0+deb12).
+# Web assets land at /usr/share/jellyfin/web/ — stable, prebuilt, no npm required.
+# The web client version must match the server version this fork is based on.
+FROM --platform=linux/amd64 debian:bookworm-slim AS webclient
+
+RUN apt-get update \
+ && apt-get install -y --no-install-recommends curl gnupg ca-certificates \
+ && curl -fsSL https://repo.jellyfin.org/jellyfin_team.gpg.key \
+    | gpg --dearmor -o /usr/share/keyrings/jellyfin.gpg \
+ && echo "deb [arch=amd64 signed-by=/usr/share/keyrings/jellyfin.gpg] https://repo.jellyfin.org/debian bookworm main" \
+    > /etc/apt/sources.list.d/jellyfin.list \
+ && apt-get update \
+ && apt-get install -y --no-install-recommends "jellyfin-web=12.0+deb12" \
+ && rm -rf /var/lib/apt/lists/*
+
+# ── Runtime stage ─────────────────────────────────────────────────────────────
+FROM --platform=linux/amd64 mcr.microsoft.com/dotnet/aspnet:10.0
+
+# Install FFmpeg and native dependencies required by SkiaSharp and fontconfig.
+RUN apt-get update \
+ && apt-get install -y --no-install-recommends \
+      ffmpeg \
+      fontconfig \
+      libfontconfig1 \
+      libfreetype6 \
+ && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /jellyfin
+
+# Copy the pre-built publish output produced by `dotnet publish` on the CI host.
+COPY publish-output/ .
+# Copy the jellyfin-web client assets from the webclient stage.
+COPY --from=webclient /usr/share/jellyfin/web ./jellyfin-web/
+
+# Jellyfin default ports
+EXPOSE 8096
+EXPOSE 8920
+
+# Data / config volumes
+VOLUME ["/config", "/cache", "/media"]
+
+ENV JELLYFIN_DATA_DIR=/config \
+    JELLYFIN_CACHE_DIR=/cache \
+    JELLYFIN_LOG_DIR=/config/log
+
+ENTRYPOINT ["./jellyfin", \
+            "--datadir", "/config", \
+            "--cachedir", "/cache", \
+            "--webdir", "/jellyfin/jellyfin-web"]

Emby.Naming/AudioBook/AudioBookNameParserResult.cs

@@ -1,3 +1,5 @@
+#pragma warning disable CA1815
+
 namespace Emby.Naming.AudioBook
 {
     /// <summary>

Emby.Naming/Book/BookFileNameParser.cs

@@ -0,0 +1,94 @@
+using System;
+using System.Text.RegularExpressions;
+
+namespace Emby.Naming.Book
+{
+    /// <summary>
+    /// Helper class to retrieve basic metadata from a book filename.
+    /// </summary>
+    public static partial class BookFileNameParser
+    {
+        private const string NameMatchGroup = "name";
+        private const string IndexMatchGroup = "index";
+        private const string YearMatchGroup = "year";
+        private const string SeriesNameMatchGroup = "seriesName";
+
+        private static readonly Regex[] _nameMatches =
+        [
+            // seriesName (seriesYear) #index (of count) (year) where only seriesName and index are required
+            new Regex(@"^(?<seriesName>.+?)((\s\((?<seriesYear>[0-9]{4})\))?)\s#(?<index>[0-9]+)(?:\.0)?((\s\(of\s(?<count>[0-9]+)\))?)((\s\((?<year>[0-9]{4})\))?)$"),
+            new Regex(@"^(?<name>.+?)\s\((?<seriesName>.+?),\s#(?<index>[0-9]+)\)(?:\.0)?((\s\((?<year>[0-9]{4})\))?)$"),
+            new Regex(@"^(?<index>[0-9]+)(?:\.0)?\s\-\s(?<name>.+?)((\s\((?<year>[0-9]{4})\))?)$"),
+            new Regex(@"(?<name>.*)\((?<year>[0-9]{4})\)"),
+            // last resort matches the whole string as the name
+            new Regex(@"(?<name>.*)")
+        ];
+
+        [GeneratedRegex(@"^(?<name>.+?)(\sv(?<volume>[0-9]+))?(\sc(?<chapter>[0-9]+))?$")]
+        private static partial Regex ComicRegex();
+
+        /// <summary>
+        /// Parse a filename name to retrieve the book name, series name, index, and year.
+        /// </summary>
+        /// <param name="name">Book filename to parse for information.</param>
+        /// <returns>Returns <see cref="BookFileNameParserResult"/> object.</returns>
+        public static BookFileNameParserResult Parse(string? name)
+        {
+            var result = new BookFileNameParserResult();
+
+            if (name == null)
+            {
+                return result;
+            }
+
+            foreach (var regex in _nameMatches)
+            {
+                var match = regex.Match(name);
+
+                if (!match.Success)
+                {
+                    continue;
+                }
+
+                if (match.Groups.TryGetValue(NameMatchGroup, out Group? nameGroup) && nameGroup.Success)
+                {
+                    var comicMatch = ComicRegex().Match(nameGroup.Value.Trim());
+
+                    if (comicMatch.Success)
+                    {
+                        if (comicMatch.Groups.TryGetValue("volume", out Group? volumeGroup) && volumeGroup.Success && int.TryParse(volumeGroup.ValueSpan, out var volume))
+                        {
+                            result.ParentIndex = volume;
+                        }
+
+                        if (comicMatch.Groups.TryGetValue("chapter", out Group? chapterGroup) && chapterGroup.Success && int.TryParse(chapterGroup.ValueSpan, out var chapter))
+                        {
+                            result.Index = chapter;
+                        }
+                    }
+
+                    result.Name = nameGroup.ValueSpan.Trim().ToString();
+                }
+
+                if (match.Groups.TryGetValue(IndexMatchGroup, out Group? indexGroup) && indexGroup.Success && int.TryParse(indexGroup.Value, out var index))
+                {
+                    result.Index = index;
+                }
+
+                if (match.Groups.TryGetValue(YearMatchGroup, out Group? yearGroup) && yearGroup.Success && int.TryParse(yearGroup.Value, out var year))
+                {
+                    result.Year = year;
+                }
+
+                if (match.Groups.TryGetValue(SeriesNameMatchGroup, out Group? seriesGroup) && seriesGroup.Success)
+                {
+                    result.SeriesName = seriesGroup.Value.Trim();
+                }
+
+                break;
+            }
+
+            return result;
+        }
+    }
+}

Emby.Naming/Book/BookFileNameParserResult.cs

@@ -0,0 +1,45 @@
+namespace Emby.Naming.Book
+{
+    /// <summary>
+    /// Data object used to pass metadata parsed from a book filename.
+    /// </summary>
+    public class BookFileNameParserResult
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="BookFileNameParserResult"/> class.
+        /// </summary>
+        public BookFileNameParserResult()
+        {
+            Name = null;
+            Index = null;
+            ParentIndex = null;
+            Year = null;
+            SeriesName = null;
+        }
+
+        /// <summary>
+        /// Gets or sets the name of the book.
+        /// </summary>
+        public string? Name { get; set; }
+
+        /// <summary>
+        /// Gets or sets the book index.
+        /// </summary>
+        public int? Index { get; set; }
+
+        /// <summary>
+        /// Gets or sets the parent index number.
+        /// </summary>
+        public int? ParentIndex { get; set; }
+
+        /// <summary>
+        /// Gets or sets the publication year.
+        /// </summary>
+        public int? Year { get; set; }
+
+        /// <summary>
+        /// Gets or sets the series name.
+        /// </summary>
+        public string? SeriesName { get; set; }
+    }
+}

Emby.Naming/Common/NamingOptions.cs

@@ -57,7 +57,6 @@ namespace Emby.Naming.Common
                 ".nrg",
                 ".nsv",
                 ".nuv",
-                ".ogg",
                 ".ogm",
                 ".ogv",
                 ".pva",
@@ -152,8 +151,8 @@ namespace Emby.Naming.Common
 
             CleanStrings =
             [
-                @"^\s*(?<cleaned>.+?)[ _\,\.\(\)\[\]\-](3d|sbs|tab|hsbs|htab|mvc|HDR|HDC|UHD|UltraHD|4k|ac3|dts|custom|dc|divx|divx5|dsr|dsrip|dutch|dvd|dvdrip|dvdscr|dvdscreener|screener|dvdivx|cam|fragment|fs|hdtv|hdrip|hdtvrip|internal|limited|multi|subs|ntsc|ogg|ogm|pal|pdtv|proper|repack|rerip|retail|cd[1-9]|r5|bd5|bd|se|svcd|swedish|german|read.nfo|nfofix|unrated|ws|telesync|ts|telecine|tc|brrip|bdrip|480p|480i|576p|576i|720p|720i|1080p|1080i|2160p|hrhd|hrhdtv|hddvd|bluray|blu-ray|x264|x265|h264|h265|xvid|xvidvd|xxx|www.www|AAC|DTS|\[.*\])([ _\,\.\(\)\[\]\-]|$)",
-                @"^(?<cleaned>.+?)(\[.*\])",
+                @"^\s*(?<cleaned>.+?)[ _\,\.\(\)\[\]\-](3d|sbs|tab|hsbs|htab|mvc|HDR|HDC|UHD|UltraHD|4k|ac3|dts|custom|dc|divx|divx5|dsr|dsrip|dutch|dvd|dvdrip|dvdscr|dvdscreener|screener|dvdivx|cam|fragment|fs|hdtv|hdrip|hdtvrip|internal|limited|multi|subs|ntsc|ogg|ogm|pal|pdtv|proper|repack|rerip|retail|cd[1-9]|r5|bd5|bd|se|svcd|swedish|german|read.nfo|nfofix|unrated|ws|web-dl|telesync|ts|telecine|tc|brrip|bdrip|480p|480i|576p|576i|720p|720i|1080p|1080i|2160p|hrhd|hrhdtv|hddvd|bluray|blu-ray|x264|x265|h264|h265|xvid|xvidvd|xxx|www.www|AAC|DTS)(?=[ _\,\.\(\)\[\]\-]|$)",
+                @"^\s*(?<cleaned>.+?)((\s*\[[^\]]+\]\s*)+)(\.[^\s]+)?$",
                 @"^\s*(?<cleaned>.+?)\WE[0-9]+(-|~)E?[0-9]+(\W|$)",
                 @"^\s*\[[^\]]+\](?!\.\w+$)\s*(?<cleaned>.+)",
                 @"^\s*(?<cleaned>.+?)\s+-\s+[0-9]+\s*$",
@@ -225,6 +224,7 @@ namespace Emby.Naming.Common
                 ".afc",
                 ".amf",
                 ".aif",
+                ".aifc",
                 ".aiff",
                 ".alac",
                 ".amr",
@@ -361,7 +361,10 @@ namespace Emby.Naming.Common
                 // Not a Kodi rule as well, but the expression below also causes false positives,
                 // so we make sure this one gets tested first.
                 // "Foo Bar 889"
-                new EpisodeExpression(@".*[\\\/](?![Ee]pisode)(?<seriesname>[\w\s]+?)\s(?<epnumber>[0-9]{1,4})(-(?<endingepnumber>[0-9]{2,4}))*[^\\\/x]*$")
+                // Names carrying an SxxEyy marker are excluded because the Kodi expression above already covers them.
+                // Without that guard this expression reads digits out of the title instead, turning
+                // "S01E01 1-23-45 [Bluray-1080p]" into episodes 1 through 45.
+                new EpisodeExpression(@".*[\\\/](?![Ee]pisode)(?![^\\\/]*[Ss][0-9]+[][ ._-]*[Ee][0-9]+)(?<seriesname>[\w\s]+?)\s(?<epnumber>[0-9]{1,4})(-(?<endingepnumber>[0-9]{2,4}))*[^\\\/x]*$")
                 {
                     IsNamed = true
                 },
@@ -378,6 +381,14 @@ namespace Emby.Naming.Common
                     IsNamed = true
                 },
 
+                // "Name - 101.mkv", "Name - 101 [720p].mkv", "Name - 101 (2020).mkv"
+                // Handles absolute episode numbers with hyphen delimiter (common in anime)
+                // Without brackets (bracketed version handled above)
+                new EpisodeExpression(@".*[\\\/](?<seriesname>[^\\\/]+?)[\s_]+-[\s_]+(?<epnumber>[0-9]+)[\s_]*(?:\[.*?\]|\(.*?\))*[\s_]*(?:\.\w+)?$")
+                {
+                    IsNamed = true
+                },
+
                 // /server/anything_102.mp4
                 // /server/james.corden.2017.04.20.anne.hathaway.720p.hdtv.x264-crooks.mkv
                 // /server/anything_1996.11.14.mp4

Emby.Naming/Emby.Naming.csproj

@@ -6,7 +6,7 @@
   </PropertyGroup>
 
   <PropertyGroup>
-    <TargetFramework>net9.0</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
     <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
     <PublishRepositoryUrl>true</PublishRepositoryUrl>
@@ -36,7 +36,7 @@
   <PropertyGroup>
     <Authors>Jellyfin Contributors</Authors>
     <PackageId>Jellyfin.Naming</PackageId>
-    <VersionPrefix>10.11.0</VersionPrefix>
+    <VersionPrefix>12.0.0</VersionPrefix>
     <RepositoryUrl>https://github.com/jellyfin/jellyfin</RepositoryUrl>
     <PackageLicenseExpression>GPL-3.0-only</PackageLicenseExpression>
   </PropertyGroup>

Emby.Naming/ExternalFiles/ExternalPathParser.cs

@@ -44,7 +44,14 @@ namespace Emby.Naming.ExternalFiles
             }
 
             var extension = Path.GetExtension(path.AsSpan());
-            if (!(_type == DlnaProfileType.Subtitle && _namingOptions.SubtitleFileExtensions.Contains(extension, StringComparison.OrdinalIgnoreCase))
+
+            // .idx carries VobSub per-track language metadata. Recognize it here rather
+            // than adding it to NamingOptions.SubtitleFileExtensions, which also gates
+            // subtitle uploads/saves.
+            var isVobSubIndex = _type == DlnaProfileType.Subtitle && extension.Equals(".idx", StringComparison.OrdinalIgnoreCase);
+
+            if (!isVobSubIndex
+                && !(_type == DlnaProfileType.Subtitle && _namingOptions.SubtitleFileExtensions.Contains(extension, StringComparison.OrdinalIgnoreCase))
                 && !(_type == DlnaProfileType.Audio && _namingOptions.AudioFileExtensions.Contains(extension, StringComparison.OrdinalIgnoreCase))
                 && !(_type == DlnaProfileType.Lyric && _namingOptions.LyricFileExtensions.Contains(extension, StringComparison.OrdinalIgnoreCase)))
             {
@@ -70,7 +77,7 @@ namespace Emby.Naming.ExternalFiles
 
                     if (lastSeparator == -1)
                     {
-                          break;
+                        break;
                     }
 
                     string currentSlice = languageString[lastSeparator..];

Emby.Naming/TV/EpisodePathParser.cs

@@ -125,7 +125,7 @@ namespace Emby.Naming.TV
                             result.Success = true;
                         }
                     }
-                    else if (DateTime.TryParse(match.Groups[0].ValueSpan, out date))
+                    else if (DateTime.TryParse(match.Groups[0].ValueSpan, CultureInfo.InvariantCulture, out date))
                     {
                         result.Year = date.Year;
                         result.Month = date.Month;
@@ -158,7 +158,9 @@ namespace Emby.Naming.TV
                         if (nextIndex >= name.Length
                             || !"0123456789iIpP".Contains(name[nextIndex], StringComparison.Ordinal))
                         {
-                            if (int.TryParse(endingNumberGroup.ValueSpan, NumberStyles.Integer, CultureInfo.InvariantCulture, out num))
+                            // A range cannot end before it starts, so a lower number belongs to the episode title rather than to a range.
+                            if (int.TryParse(endingNumberGroup.ValueSpan, NumberStyles.Integer, CultureInfo.InvariantCulture, out num)
+                                && num >= result.EpisodeNumber)
                             {
                                 result.EndingEpisodeNumber = num;
                             }
@@ -226,7 +228,7 @@ namespace Emby.Naming.TV
                     info.SeriesName = result.SeriesName;
                 }
 
-                if (!info.EndingEpisodeNumber.HasValue && info.EpisodeNumber.HasValue)
+                if (!info.EndingEpisodeNumber.HasValue && result.EndingEpisodeNumber >= info.EpisodeNumber)
                 {
                     info.EndingEpisodeNumber = result.EndingEpisodeNumber;
                 }

Emby.Naming/TV/SeasonPathParser.cs

@@ -10,12 +10,25 @@ namespace Emby.Naming.TV
     /// </summary>
     public static partial class SeasonPathParser
     {
-        [GeneratedRegex(@"^\s*((?<seasonnumber>(?>\d+))(?:st|nd|rd|th|\.)*(?!\s*[Ee]\d+))\s*(?:[[시즌]*|[シーズン]*|[sS](?:eason|æson|aison|taffel|eries|tagione|äsong|eizoen|easong|ezon|ezona|ezóna|ezonul)*|[tT](?:emporada)*|[kK](?:ausi)*|[Сс](?:езон)*)\s*(?<rightpart>.*)$")]
+        private const string SeasonKeywordPattern =
+            @"시즌|シーズン|сезон" +
+            @"|season|sæson|saison|staffel|series|stagione|säsong|seizoen|seasong" +
+            @"|sezon|sezona|sezóna|sezonul|série|séria|serie|seria|temporada|kausi";
+
+        private static readonly Regex CleanNameRegex = new(@"[ ._\-\[\]]", RegexOptions.Compiled);
+
+        [GeneratedRegex(@"^\s*((?<seasonnumber>(?>\d+))(?:st|nd|rd|th|\.)*(?!\s*[Ee]\d+))\s*(?:" + SeasonKeywordPattern + @")\s*(?<rightpart>.*)$", RegexOptions.IgnoreCase)]
         private static partial Regex ProcessPre();
 
-        [GeneratedRegex(@"^\s*(?:[[시즌]*|[シーズン]*|[sS](?:eason|æson|aison|taffel|eries|tagione|äsong|eizoen|easong|ezon|ezona|ezóna|ezonul)*|[tT](?:emporada)*|[kK](?:ausi)*|[Сс](?:езон)*)\s*(?<seasonnumber>(?>\d+)(?!\s*[Ee]\d+))(?<rightpart>.*)$")]
+        [GeneratedRegex(@"^\s*(?:" + SeasonKeywordPattern + @")\s*(?<seasonnumber>\d+?)(?=\d{3,4}p|[^\d]|$)(?!\s*[Ee]\d)(?<rightpart>.*)$", RegexOptions.IgnoreCase)]
         private static partial Regex ProcessPost();
 
+        [GeneratedRegex(@"[sS](\d{1,4})(?!\d|[eE]\d)(?=\.|_|-|\[|\]|\s|$)", RegexOptions.None)]
+        private static partial Regex SeasonPrefix();
+
+        [GeneratedRegex(SeasonKeywordPattern, RegexOptions.IgnoreCase)]
+        private static partial Regex SeasonKeyword();
+
         /// <summary>
         /// Attempts to parse season number from path.
         /// </summary>
@@ -56,54 +69,55 @@ namespace Emby.Naming.TV
             bool supportSpecialAliases,
             bool supportNumericSeasonFolders)
         {
-            string filename = Path.GetFileName(path);
-            filename = Regex.Replace(filename, "[ ._-]", string.Empty);
+            var fileName = Path.GetFileName(path);
+
+            var seasonPrefixMatch = SeasonPrefix().Match(fileName);
+            if (seasonPrefixMatch.Success &&
+                int.TryParse(seasonPrefixMatch.Groups[1].Value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var val))
+            {
+                return (val, true);
+            }
+
+            string filename = CleanNameRegex.Replace(fileName, string.Empty);
 
             if (parentFolderName is not null)
             {
-                parentFolderName = Regex.Replace(parentFolderName, "[ ._-]", string.Empty);
-                filename = filename.Replace(parentFolderName, string.Empty, StringComparison.OrdinalIgnoreCase);
+                var cleanParent = CleanNameRegex.Replace(parentFolderName, string.Empty);
+                filename = filename.Replace(cleanParent, string.Empty, StringComparison.OrdinalIgnoreCase);
             }
 
-            if (supportSpecialAliases)
+            if (supportSpecialAliases &&
+                (filename.Equals("specials", StringComparison.OrdinalIgnoreCase) ||
+                 filename.Equals("extras", StringComparison.OrdinalIgnoreCase)))
             {
-                if (string.Equals(filename, "specials", StringComparison.OrdinalIgnoreCase))
-                {
-                    return (0, true);
-                }
-
-                if (string.Equals(filename, "extras", StringComparison.OrdinalIgnoreCase))
-                {
-                    return (0, true);
-                }
+                return (0, true);
             }
 
-            if (supportNumericSeasonFolders)
+            if (supportNumericSeasonFolders &&
+                int.TryParse(filename, NumberStyles.Integer, CultureInfo.InvariantCulture, out val))
             {
-                if (int.TryParse(filename, NumberStyles.Integer, CultureInfo.InvariantCulture, out var val))
-                {
-                    return (val, true);
-                }
-            }
-
-            if (filename.StartsWith('s'))
-            {
-                var testFilename = filename.AsSpan()[1..];
-
-                if (int.TryParse(testFilename, NumberStyles.Integer, CultureInfo.InvariantCulture, out var val))
-                {
-                    return (val, true);
-                }
+                return (val, true);
             }
 
+            bool isMixedLibrary = !supportNumericSeasonFolders && !supportSpecialAliases;
             var preMatch = ProcessPre().Match(filename);
             if (preMatch.Success)
             {
+                if (isMixedLibrary && !SeasonKeyword().IsMatch(fileName))
+                {
+                    return (null, false);
+                }
+
                 return CheckMatch(preMatch);
             }
             else
             {
                 var postMatch = ProcessPost().Match(filename);
+                if (postMatch.Success && isMixedLibrary && !SeasonKeyword().IsMatch(fileName))
+                {
+                    return (null, false);
+                }
+
                 return CheckMatch(postMatch);
             }
         }
@@ -113,8 +127,10 @@ namespace Emby.Naming.TV
             var numberString = match.Groups["seasonnumber"];
             if (numberString.Success)
             {
-                var seasonNumber = int.Parse(numberString.Value, CultureInfo.InvariantCulture);
-                return (seasonNumber, true);
+                if (int.TryParse(numberString.Value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var seasonNumber))
+                {
+                    return (seasonNumber, true);
+                }
             }
 
             return (null, false);

Emby.Naming/TV/SeriesInfo.cs

@@ -25,5 +25,11 @@ namespace Emby.Naming.TV
         /// </summary>
         /// <value>The name of the series.</value>
         public string? Name { get; set; }
+
+        /// <summary>
+        /// Gets or sets the year of the series.
+        /// </summary>
+        /// <value>The year of the series.</value>
+        public int? Year { get; set; }
     }
 }

Emby.Naming/TV/SeriesResolver.cs

@@ -17,6 +17,13 @@ namespace Emby.Naming.TV
         [GeneratedRegex(@"((?<a>[^\._]{2,})[\._]*)|([\._](?<b>[^\._]{2,}))")]
         private static partial Regex SeriesNameRegex();
 
+        /// <summary>
+        /// Regex that matches titles with year in parentheses. Captures the title (which may be
+        /// numeric) before the year, i.e. turns "1923 (2022)" into "1923".
+        /// </summary>
+        [GeneratedRegex(@"(?<title>.+?)\s*\((?<year>[0-9]{4})\)")]
+        private static partial Regex TitleWithYearRegex();
+
         /// <summary>
         /// Resolve information about series from path.
         /// </summary>
@@ -27,6 +34,21 @@ namespace Emby.Naming.TV
         {
             string seriesName = Path.GetFileName(path);
 
+            // First check if the filename matches a title with year pattern (handles numeric titles)
+            if (!string.IsNullOrEmpty(seriesName))
+            {
+                var titleWithYearMatch = TitleWithYearRegex().Match(seriesName);
+                if (titleWithYearMatch.Success)
+                {
+                    seriesName = titleWithYearMatch.Groups["title"].Value.Trim();
+                    return new SeriesInfo(path)
+                    {
+                        Name = seriesName,
+                        Year = int.TryParse(titleWithYearMatch.Groups["year"].ValueSpan, out var year) ? year : null
+                    };
+                }
+            }
+
             SeriesPathParserResult result = SeriesPathParser.Parse(options, path);
             if (result.Success)
             {

Emby.Naming/TV/TvParserHelpers.cs

@@ -18,7 +18,7 @@ public static class TvParserHelpers
     /// <param name="status">The status string.</param>
     /// <param name="enumValue">The <see cref="SeriesStatus"/>.</param>
     /// <returns>Returns true if parsing was successful.</returns>
-    public static bool TryParseSeriesStatus(string status, out SeriesStatus? enumValue)
+    public static bool TryParseSeriesStatus(string? status, out SeriesStatus? enumValue)
     {
         if (Enum.TryParse(status, true, out SeriesStatus seriesStatus))
         {

Emby.Naming/Video/CleanDateTimeResult.cs

@@ -1,3 +1,5 @@
+#pragma warning disable CA1815
+
 namespace Emby.Naming.Video
 {
     /// <summary>

Emby.Naming/Video/CleanStringParser.cs

@@ -44,7 +44,7 @@ namespace Emby.Naming.Video
             var match = expression.Match(name);
             if (match.Success && match.Groups.TryGetValue("cleaned", out var cleaned))
             {
-                newName = cleaned.Value;
+                newName = cleaned.Value.Trim();
                 return true;
             }
 

Emby.Naming/Video/Format3DParser.cs

@@ -52,13 +52,18 @@ namespace Emby.Naming.Video
             while (path.Length > 0)
             {
                 var index = path.IndexOfAny(delimiters);
+                ReadOnlySpan<char> currentSlice;
                 if (index == -1)
                 {
-                    index = path.Length - 1;
+                    // No delimiter left, the last token is the remainder of the path
+                    currentSlice = path;
+                    path = default;
+                }
+                else
+                {
+                    currentSlice = path[..index];
+                    path = path[(index + 1)..];
                 }
-
-                var currentSlice = path[..index];
-                path = path[(index + 1)..];
 
                 if (!foundPrefix)
                 {

Emby.Naming/Video/VideoInfo.cs

@@ -17,8 +17,8 @@ namespace Emby.Naming.Video
         {
             Name = name;
 
-            Files = Array.Empty<VideoFileInfo>();
-            AlternateVersions = Array.Empty<VideoFileInfo>();
+            Files = [];
+            AlternateVersions = [];
         }
 
         /// <summary>
@@ -40,10 +40,10 @@ namespace Emby.Naming.Video
         public IReadOnlyList<VideoFileInfo> Files { get; set; }
 
         /// <summary>
-        /// Gets or sets the alternate versions.
+        /// Gets or sets the alternate versions. Each alternate may itself span multiple files.
         /// </summary>
         /// <value>The alternate versions.</value>
-        public IReadOnlyList<VideoFileInfo> AlternateVersions { get; set; }
+        public IReadOnlyList<VideoInfo> AlternateVersions { get; set; }
 
         /// <summary>
         /// Gets or sets the extra type.

Emby.Naming/Video/VideoListResolver.cs

@@ -1,10 +1,12 @@
 using System;
 using System.Collections.Generic;
+using System.Globalization;
 using System.IO;
 using System.Linq;
 using System.Text.RegularExpressions;
 using Emby.Naming.Common;
-using Jellyfin.Extensions;
+using Emby.Naming.TV;
+using Jellyfin.Data.Enums;
 using MediaBrowser.Model.IO;
 
 namespace Emby.Naming.Video
@@ -12,8 +14,23 @@ namespace Emby.Naming.Video
     /// <summary>
     /// Resolves alternative versions and extras from list of video files.
     /// </summary>
-    public static partial class VideoListResolver
+    public partial class VideoListResolver
     {
+        private static readonly StringComparer _numericOrdinalComparer = StringComparer.Create(CultureInfo.InvariantCulture, CompareOptions.NumericOrdering);
+
+        private readonly NamingOptions _namingOptions;
+        private readonly EpisodePathParser _episodePathParser;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="VideoListResolver"/> class.
+        /// </summary>
+        /// <param name="namingOptions">The naming options.</param>
+        public VideoListResolver(NamingOptions namingOptions)
+        {
+            _namingOptions = namingOptions;
+            _episodePathParser = new EpisodePathParser(namingOptions);
+        }
+
         [GeneratedRegex("[0-9]{2}[0-9]+[ip]", RegexOptions.IgnoreCase)]
         private static partial Regex ResolutionRegex();
 
@@ -24,12 +41,12 @@ namespace Emby.Naming.Video
         /// Resolves alternative versions and extras from list of video files.
         /// </summary>
         /// <param name="videoInfos">List of related video files.</param>
-        /// <param name="namingOptions">The naming options.</param>
         /// <param name="supportMultiVersion">Indication we should consider multi-versions of content.</param>
         /// <param name="parseName">Whether to parse the name or use the filename.</param>
         /// <param name="libraryRoot">Top-level folder for the containing library.</param>
+        /// <param name="collectionType">The type of the containing collection, if known.</param>
         /// <returns>Returns enumerable of <see cref="VideoInfo"/> which groups files together when related.</returns>
-        public static IReadOnlyList<VideoInfo> Resolve(IReadOnlyList<VideoFileInfo> videoInfos, NamingOptions namingOptions, bool supportMultiVersion = true, bool parseName = true, string? libraryRoot = "")
+        public IReadOnlyList<VideoInfo> Resolve(IReadOnlyList<VideoFileInfo> videoInfos, bool supportMultiVersion = true, bool parseName = true, string? libraryRoot = "", CollectionType? collectionType = null)
         {
             // Filter out all extras, otherwise they could cause stacks to not be resolved
             // See the unit test TestStackedWithTrailer
@@ -37,7 +54,7 @@ namespace Emby.Naming.Video
                 .Where(i => i.ExtraType is null)
                 .Select(i => new FileSystemMetadata { FullName = i.Path, IsDirectory = i.IsDirectory });
 
-            var stackResult = StackResolver.Resolve(nonExtras, namingOptions).ToList();
+            var stackResult = StackResolver.Resolve(nonExtras, _namingOptions).ToList();
 
             var remainingFiles = new List<VideoFileInfo>();
             var standaloneMedia = new List<VideoFileInfo>();
@@ -66,7 +83,7 @@ namespace Emby.Naming.Video
             {
                 var info = new VideoInfo(stack.Name)
                 {
-                    Files = stack.Files.Select(i => VideoResolver.Resolve(i, stack.IsDirectoryStack, namingOptions, parseName, libraryRoot))
+                    Files = stack.Files.Select(i => VideoResolver.Resolve(i, stack.IsDirectoryStack, _namingOptions, parseName, libraryRoot))
                         .OfType<VideoFileInfo>()
                         .ToList()
                 };
@@ -85,7 +102,9 @@ namespace Emby.Naming.Video
 
             if (supportMultiVersion)
             {
-                list = GetVideosGroupedByVersion(list, namingOptions);
+                list = collectionType is CollectionType.tvshows
+                    ? GetEpisodesGroupedByVersion(list)
+                    : GetVideosGroupedByVersion(list);
             }
 
             // Whatever files are left, just add them
@@ -99,7 +118,7 @@ namespace Emby.Naming.Video
             return list;
         }
 
-        private static List<VideoInfo> GetVideosGroupedByVersion(List<VideoInfo> videos, NamingOptions namingOptions)
+        private List<VideoInfo> GetVideosGroupedByVersion(List<VideoInfo> videos)
         {
             if (videos.Count == 0)
             {
@@ -123,7 +142,7 @@ namespace Emby.Naming.Video
                     continue;
                 }
 
-                if (!IsEligibleForMultiVersion(folderName, video.Files[0].FileNameWithoutExtension, namingOptions))
+                if (!IsEligibleForMultiVersion(folderName, video.Files[0].FileNameWithoutExtension))
                 {
                     return videos;
                 }
@@ -134,37 +153,9 @@ namespace Emby.Naming.Video
                 }
             }
 
-            if (videos.Count > 1)
-            {
-                var groups = videos.GroupBy(x => ResolutionRegex().IsMatch(x.Files[0].FileNameWithoutExtension)).ToList();
-                videos.Clear();
-                foreach (var group in groups)
-                {
-                    if (group.Key)
-                    {
-                        videos.InsertRange(0, group
-                            .OrderByDescending(x => ResolutionRegex().Match(x.Files[0].FileNameWithoutExtension.ToString()).Value, new AlphanumericComparator())
-                            .ThenBy(x => x.Files[0].FileNameWithoutExtension.ToString(), new AlphanumericComparator()));
-                    }
-                    else
-                    {
-                        videos.AddRange(group.OrderBy(x => x.Files[0].FileNameWithoutExtension.ToString(), new AlphanumericComparator()));
-                    }
-                }
-            }
+            var organized = OrganizeAlternateVersions(videos, primary, folderName.ToString());
 
-            primary ??= videos[0];
-            videos.Remove(primary);
-
-            var list = new List<VideoInfo>
-            {
-                primary
-            };
-
-            list[0].AlternateVersions = videos.Select(x => x.Files[0]).ToArray();
-            list[0].Name = folderName.ToString();
-
-            return list;
+            return [organized];
         }
 
         private static bool HaveSameYear(IReadOnlyList<VideoInfo> videos)
@@ -186,7 +177,7 @@ namespace Emby.Naming.Video
             return true;
         }
 
-        private static bool IsEligibleForMultiVersion(ReadOnlySpan<char> folderName, ReadOnlySpan<char> testFilename, NamingOptions namingOptions)
+        private bool IsEligibleForMultiVersion(ReadOnlySpan<char> folderName, ReadOnlySpan<char> testFilename)
         {
             if (!testFilename.StartsWith(folderName, StringComparison.OrdinalIgnoreCase))
             {
@@ -200,7 +191,7 @@ namespace Emby.Naming.Video
             }
 
             // There are no span overloads for regex unfortunately
-            if (CleanStringParser.TryClean(testFilename.ToString(), namingOptions.CleanStringRegexes, out var cleanName))
+            if (CleanStringParser.TryClean(testFilename.ToString(), _namingOptions.CleanStringRegexes, out var cleanName))
             {
                 testFilename = cleanName.AsSpan().Trim();
             }
@@ -208,7 +199,117 @@ namespace Emby.Naming.Video
             // The CleanStringParser should have removed common keywords etc.
             return testFilename.IsEmpty
                    || testFilename[0] == '-'
+                   || testFilename[0] == '_'
+                   || testFilename[0] == '.'
                    || CheckMultiVersionRegex().IsMatch(testFilename);
         }
+
+        private List<VideoInfo> GetEpisodesGroupedByVersion(List<VideoInfo> videos)
+        {
+            if (videos.Count < 2)
+            {
+                return videos;
+            }
+
+            var result = new List<VideoInfo>();
+            var groups = new Dictionary<string, List<VideoInfo>>(StringComparer.OrdinalIgnoreCase);
+
+            for (var i = 0; i < videos.Count; i++)
+            {
+                var video = videos[i];
+                var episodeResult = _episodePathParser.Parse(video.Files[0].Path, false);
+                string? key = null;
+                if (episodeResult.Success)
+                {
+                    if (episodeResult.IsByDate
+                        && episodeResult.Year.HasValue
+                        && episodeResult.Month.HasValue
+                        && episodeResult.Day.HasValue)
+                    {
+                        key = FormattableString.Invariant(
+                            $"D{episodeResult.Year.Value}{episodeResult.Month.Value:D2}{episodeResult.Day.Value:D2}");
+                    }
+                    else if (episodeResult.EpisodeNumber.HasValue)
+                    {
+                        key = FormattableString.Invariant(
+                            $"S{episodeResult.SeasonNumber ?? 0}E{episodeResult.EpisodeNumber.Value}");
+                    }
+                }
+
+                if (key is null)
+                {
+                    result.Add(video);
+                    continue;
+                }
+
+                if (!groups.TryGetValue(key, out var group))
+                {
+                    group = [];
+                    groups[key] = group;
+                }
+
+                group.Add(video);
+            }
+
+            foreach (var group in groups.Values)
+            {
+                if (group.Count == 1)
+                {
+                    result.Add(group[0]);
+                    continue;
+                }
+
+                result.Add(OrganizeAlternateVersions(group));
+            }
+
+            return result;
+        }
+
+        private static VideoInfo OrganizeAlternateVersions(
+            List<VideoInfo> videos,
+            VideoInfo? primaryOverride = null,
+            string? nameOverride = null)
+        {
+            if (videos.Count > 1)
+            {
+                var groups = videos
+                    .Select(x => (filename: x.Files[0].FileNameWithoutExtension.ToString(), value: x))
+                    .Select(x => (x.filename, resolutionMatch: ResolutionRegex().Match(x.filename), x.value))
+                    .GroupBy(x => x.resolutionMatch.Success)
+                    .ToList();
+
+                videos = [];
+
+                foreach (var group in groups)
+                {
+                    if (group.Key)
+                    {
+                        videos.InsertRange(0, group
+                            .OrderByDescending(x => x.resolutionMatch.Value, _numericOrdinalComparer)
+                            .ThenBy(x => x.filename, _numericOrdinalComparer)
+                            .Select(x => x.value));
+                    }
+                    else
+                    {
+                        videos.AddRange(group.OrderBy(x => x.filename, _numericOrdinalComparer).Select(x => x.value));
+                    }
+                }
+            }
+
+            // Prefer a stacked entry (more than one part) as primary
+            var primary = primaryOverride
+                ?? videos.FirstOrDefault(v => v.Files.Count > 1)
+                ?? videos[0];
+            videos.Remove(primary);
+
+            primary.AlternateVersions = videos;
+
+            if (nameOverride is not null)
+            {
+                primary.Name = nameOverride;
+            }
+
+            return primary;
+        }
     }
 }

Emby.Photos/Emby.Photos.csproj

@@ -19,7 +19,7 @@
   </ItemGroup>
 
   <PropertyGroup>
-    <TargetFramework>net9.0</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
     <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
   </PropertyGroup>

Emby.Server.Implementations/AppBase/BaseApplicationPaths.cs

@@ -90,6 +90,7 @@ namespace Emby.Server.Implementations.AppBase
             CreateAndCheckMarker(ProgramDataPath, "data");
             CreateAndCheckMarker(CachePath, "cache");
             CreateAndCheckMarker(DataPath, "data");
+            CreateCacheDirTag(CachePath);
         }
 
         /// <inheritdoc />
@@ -100,6 +101,26 @@ namespace Emby.Server.Implementations.AppBase
             CheckOrCreateMarker(path, $".jellyfin-{markerName}", recursive);
         }
 
+        /// <summary>
+        /// Creates a CACHEDIR.TAG file in the specified directory per the Cache Directory Tagging specification.
+        /// This signals to backup tools (e.g. Restic, Borg) that the directory contains cached data
+        /// and can be excluded from backups.
+        /// </summary>
+        /// <param name="path">The cache directory path.</param>
+        internal static void CreateCacheDirTag(string path)
+        {
+            var tagPath = Path.Combine(path, "CACHEDIR.TAG");
+            if (!File.Exists(tagPath))
+            {
+                File.WriteAllText(
+                    tagPath,
+                    "Signature: 8a477f597d28d172789f06886806bc55\n"
+                    + "# This file is a cache directory tag created by Jellyfin.\n"
+                    + "# For information about cache directory tags, see:\n"
+                    + "#\thttps://bford.info/cachedir/\n");
+            }
+        }
+
         private IEnumerable<string> GetMarkers(string path, bool recursive = false)
         {
             return Directory.EnumerateFiles(path, ".jellyfin-*", recursive ? SearchOption.AllDirectories : SearchOption.TopDirectoryOnly);
@@ -107,10 +128,20 @@ namespace Emby.Server.Implementations.AppBase
 
         private void CheckOrCreateMarker(string path, string markerName, bool recursive = false)
         {
-            var otherMarkers = GetMarkers(path, recursive).FirstOrDefault(e => Path.GetFileName(e) != markerName);
+            string? otherMarkers = null;
+            try
+            {
+                otherMarkers = GetMarkers(path, recursive).FirstOrDefault(e => !Path.GetFileName(e.AsSpan()).Equals(markerName, StringComparison.OrdinalIgnoreCase));
+            }
+            catch
+            {
+                // Error while checking for marker files, assume none exist and keep going
+                // TODO: add some logging
+            }
+
             if (otherMarkers is not null)
             {
-                throw new InvalidOperationException($"Exepected to find only {markerName} but found marker for {otherMarkers}.");
+                throw new InvalidOperationException($"Expected to find only {markerName} but found marker for {otherMarkers}.");
             }
 
             var markerPath = Path.Combine(path, markerName);

Emby.Server.Implementations/AppBase/BaseConfigurationManager.cs

@@ -132,7 +132,7 @@ namespace Emby.Server.Implementations.AppBase
             }
             else
             {
-                _configurationFactories = [.._configurationFactories, factory];
+                _configurationFactories = [.. _configurationFactories, factory];
             }
 
             _configurationStores = _configurationFactories
@@ -228,6 +228,7 @@ namespace Emby.Server.Implementations.AppBase
             Logger.LogInformation("Setting cache path: {Path}", cachePath);
             ((BaseApplicationPaths)CommonApplicationPaths).CachePath = cachePath;
             CommonApplicationPaths.CreateAndCheckMarker(((BaseApplicationPaths)CommonApplicationPaths).CachePath, "cache");
+            BaseApplicationPaths.CreateCacheDirTag(cachePath);
         }
 
         /// <summary>

Emby.Server.Implementations/ApplicationHost.cs

@@ -14,6 +14,7 @@ using System.Reflection;
 using System.Security.Cryptography.X509Certificates;
 using System.Threading.Tasks;
 using Emby.Naming.Common;
+using Emby.Naming.Video;
 using Emby.Photos;
 using Emby.Server.Implementations.Chapters;
 using Emby.Server.Implementations.Collections;
@@ -25,6 +26,8 @@ using Emby.Server.Implementations.Dto;
 using Emby.Server.Implementations.HttpServer.Security;
 using Emby.Server.Implementations.IO;
 using Emby.Server.Implementations.Library;
+using Emby.Server.Implementations.Library.Search;
+using Emby.Server.Implementations.Library.SimilarItems;
 using Emby.Server.Implementations.Localization;
 using Emby.Server.Implementations.Playlists;
 using Emby.Server.Implementations.Plugins;
@@ -36,6 +39,8 @@ using Emby.Server.Implementations.SyncPlay;
 using Emby.Server.Implementations.TV;
 using Emby.Server.Implementations.Updates;
 using Jellyfin.Api.Helpers;
+using Jellyfin.Data;
+using Jellyfin.Database.Implementations.Enums;
 using Jellyfin.Drawing;
 using Jellyfin.MediaEncoding.Hls.Playlist;
 using Jellyfin.Networking.Manager;
@@ -90,9 +95,16 @@ using MediaBrowser.Model.Net;
 using MediaBrowser.Model.Serialization;
 using MediaBrowser.Model.System;
 using MediaBrowser.Model.Tasks;
+using MediaBrowser.Providers.Books;
+using MediaBrowser.Providers.Books.ComicBookInfo;
+using MediaBrowser.Providers.Books.ComicInfo;
 using MediaBrowser.Providers.Lyric;
 using MediaBrowser.Providers.Manager;
+using MediaBrowser.Providers.Plugins.ListenBrainz;
+using MediaBrowser.Providers.Plugins.ListenBrainz.Api;
 using MediaBrowser.Providers.Plugins.Tmdb;
+using MediaBrowser.Providers.Plugins.Tmdb.Movies;
+using MediaBrowser.Providers.Plugins.Tmdb.TV;
 using MediaBrowser.Providers.Subtitles;
 using MediaBrowser.XbmcMetadata.Providers;
 using Microsoft.AspNetCore.Http;
@@ -166,8 +178,6 @@ namespace Emby.Server.Implementations
                 ConfigurationManager.Configuration,
                 ApplicationPaths.PluginsPath,
                 ApplicationVersion);
-
-            _disposableParts.Add(_pluginManager);
         }
 
         /// <summary>
@@ -409,6 +419,8 @@ namespace Emby.Server.Implementations
         {
             Logger.LogInformation("Running startup tasks");
 
+            EnsureStartupWizardIntegrity();
+
             Resolve<ITaskManager>().AddTasks(GetExports<IScheduledTask>(false));
 
             ConfigurationManager.ConfigurationUpdated += OnConfigurationUpdated;
@@ -428,6 +440,24 @@ namespace Emby.Server.Implementations
             return Task.CompletedTask;
         }
 
+        private void EnsureStartupWizardIntegrity()
+        {
+            if (ConfigurationManager.CommonConfiguration.IsStartupWizardCompleted)
+            {
+                return;
+            }
+
+            var hasConfiguredAdministrator = Resolve<IUserManager>().GetUsers()
+                .Any(user => user.HasPermission(PermissionKind.IsAdministrator) && !string.IsNullOrEmpty(user.Password));
+
+            if (hasConfiguredAdministrator)
+            {
+                Logger.LogWarning("The startup wizard is marked incomplete but a configured administrator already exists. Marking setup as completed to prevent the unauthenticated setup endpoints from being reachable.");
+                ConfigurationManager.Configuration.IsStartupWizardCompleted = true;
+                ConfigurationManager.SaveConfiguration();
+            }
+        }
+
         /// <inheritdoc/>
         public void Init(IServiceCollection serviceCollection)
         {
@@ -485,6 +515,19 @@ namespace Emby.Server.Implementations
             serviceCollection.AddScoped<ISystemManager, SystemManager>();
 
             serviceCollection.AddSingleton<TmdbClientManager>();
+            serviceCollection.AddSingleton<TmdbMovieSimilarProvider>();
+            serviceCollection.AddSingleton<TmdbSeriesSimilarProvider>();
+
+            serviceCollection.AddSingleton<ListenBrainzLabsClient>();
+            serviceCollection.AddSingleton<ListenBrainzSimilarArtistProvider>();
+
+            // register the generic local metadata provider for comic files
+            serviceCollection.AddSingleton<ComicProvider>();
+
+            // register the actual implementations of the local metadata provider for comic files
+            serviceCollection.AddSingleton<IComicProvider, ComicBookInfoProvider>();
+            serviceCollection.AddSingleton<IComicProvider, ExternalComicInfoProvider>();
+            serviceCollection.AddSingleton<IComicProvider, InternalComicInfoProvider>();
 
             serviceCollection.AddSingleton(NetManager);
 
@@ -507,7 +550,13 @@ namespace Emby.Server.Implementations
 
             serviceCollection.AddSingleton<IUserDataManager, UserDataManager>();
 
-            serviceCollection.AddSingleton<IItemRepository, BaseItemRepository>();
+            serviceCollection.AddSingleton<BaseItemRepository>();
+            serviceCollection.AddSingleton<IItemRepository>(sp => sp.GetRequiredService<BaseItemRepository>());
+            serviceCollection.AddSingleton<IItemQueryHelpers>(sp => sp.GetRequiredService<BaseItemRepository>());
+            serviceCollection.AddSingleton<IItemPersistenceService, ItemPersistenceService>();
+            serviceCollection.AddSingleton<INextUpService, NextUpService>();
+            serviceCollection.AddSingleton<IItemCountService, ItemCountService>();
+            serviceCollection.AddSingleton<ILinkedChildrenService, LinkedChildrenService>();
             serviceCollection.AddSingleton<IPeopleRepository, PeopleRepository>();
             serviceCollection.AddSingleton<IChapterRepository, ChapterRepository>();
             serviceCollection.AddSingleton<IMediaAttachmentRepository, MediaAttachmentRepository>();
@@ -524,14 +573,20 @@ namespace Emby.Server.Implementations
             serviceCollection.AddTransient(provider => new Lazy<ILibraryMonitor>(provider.GetRequiredService<ILibraryMonitor>));
             serviceCollection.AddTransient(provider => new Lazy<IProviderManager>(provider.GetRequiredService<IProviderManager>));
             serviceCollection.AddTransient(provider => new Lazy<IUserViewManager>(provider.GetRequiredService<IUserViewManager>));
+            serviceCollection.AddTransient(provider => new Lazy<IExternalDataManager>(provider.GetRequiredService<IExternalDataManager>));
             serviceCollection.AddSingleton<ILibraryManager, LibraryManager>();
             serviceCollection.AddSingleton<NamingOptions>();
+            serviceCollection.AddSingleton<VideoListResolver>();
 
             serviceCollection.AddSingleton<IMusicManager, MusicManager>();
 
             serviceCollection.AddSingleton<ILibraryMonitor, LibraryMonitor>();
+            serviceCollection.AddSingleton<DotIgnoreIgnoreRule>();
 
-            serviceCollection.AddSingleton<ISearchEngine, SearchEngine>();
+            serviceCollection.AddSingleton<ISimilarItemsManager, SimilarItemsManager>();
+
+            serviceCollection.AddSingleton<ISearchManager, SearchManager>();
+            serviceCollection.AddSingleton<ISearchProvider, SqlSearchProvider>();
 
             serviceCollection.AddSingleton<IWebSocketManager, WebSocketManager>();
 
@@ -641,6 +696,7 @@ namespace Emby.Server.Implementations
             BaseItem.ConfigurationManager = ConfigurationManager;
             BaseItem.FileSystem = Resolve<IFileSystem>();
             BaseItem.ItemRepository = Resolve<IItemRepository>();
+            BaseItem.ItemCountService = Resolve<IItemCountService>();
             BaseItem.LibraryManager = Resolve<ILibraryManager>();
             BaseItem.LocalizationManager = Resolve<ILocalizationManager>();
             BaseItem.Logger = Resolve<ILogger<BaseItem>>();
@@ -687,6 +743,9 @@ namespace Emby.Server.Implementations
                 GetExports<IExternalUrlProvider>());
 
             Resolve<IMediaSourceManager>().AddParts(GetExports<IMediaSourceProvider>());
+
+            Resolve<ISimilarItemsManager>().AddParts(GetExports<ISimilarItemsProvider>());
+            Resolve<ISearchManager>().AddParts(GetExports<ISearchProvider>());
         }
 
         /// <summary>
@@ -928,8 +987,9 @@ namespace Emby.Server.Implementations
         /// <inheritdoc/>
         public string GetLocalApiUrl(string hostname, string scheme = null, int? port = null)
         {
-            // If the smartAPI doesn't start with http then treat it as a host or ip.
-            if (hostname.StartsWith("http", StringComparison.OrdinalIgnoreCase))
+            // If the smartAPI isn't already a complete URL then treat it as a host or ip.
+            if (hostname.StartsWith("http://", StringComparison.OrdinalIgnoreCase)
+                || hostname.StartsWith("https://", StringComparison.OrdinalIgnoreCase))
             {
                 return hostname.TrimEnd('/');
             }
@@ -1006,6 +1066,8 @@ namespace Emby.Server.Implementations
                 }
 
                 _disposableParts.Clear();
+
+                _pluginManager?.Dispose();
             }
 
             _disposed = true;

Emby.Server.Implementations/Chapters/ChapterManager.cs

@@ -1,6 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.Globalization;
 using System.IO;
 using System.Linq;
 using System.Threading;
@@ -8,6 +7,7 @@ using System.Threading.Tasks;
 using Jellyfin.Extensions;
 using MediaBrowser.Controller.Chapters;
 using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Entities.Audio;
 using MediaBrowser.Controller.IO;
 using MediaBrowser.Controller.Library;
 using MediaBrowser.Controller.MediaEncoding;
@@ -129,7 +129,7 @@ public class ChapterManager : IChapterManager
 
         var averageChapterDuration = GetAverageDurationBetweenChapters(chapters);
         var threshold = TimeSpan.FromSeconds(1).Ticks;
-        if (averageChapterDuration < threshold)
+        if (chapters.Count >= 2 && averageChapterDuration < threshold)
         {
             _logger.LogInformation("Skipping chapter image extraction for {Video} as the average chapter duration {AverageDuration} was lower than the minimum threshold {Threshold}", video.Name, averageChapterDuration, threshold);
             extractImages = false;
@@ -224,7 +224,7 @@ public class ChapterManager : IChapterManager
 
         if (saveChapters && changesMade)
         {
-            _chapterRepository.SaveChapters(video.Id, chapters);
+            SaveChapters(video, chapters);
         }
 
         DeleteDeadImages(currentImages, chapters);
@@ -233,9 +233,21 @@ public class ChapterManager : IChapterManager
     }
 
     /// <inheritdoc />
-    public void SaveChapters(Video video, IReadOnlyList<ChapterInfo> chapters)
+    public bool Supports(BaseItem item)
+        => item is Video or Audio;
+
+    /// <inheritdoc />
+    public void SaveChapters(BaseItem item, IReadOnlyList<ChapterInfo> chapters)
     {
-        _chapterRepository.SaveChapters(video.Id, chapters);
+        if (!Supports(item))
+        {
+            _logger.LogWarning("Attempted to save chapters for unsupported item type {Type}: {Name} ({Id})", item.GetType().Name, item.Name, item.Id);
+            return;
+        }
+
+        // Remove any chapters that are outside of the runtime of the item
+        var validChapters = chapters.Where(c => c.StartPositionTicks < item.RunTimeTicks).ToList();
+        _chapterRepository.SaveChapters(item.Id, validChapters);
     }
 
     /// <inheritdoc />
@@ -251,23 +263,9 @@ public class ChapterManager : IChapterManager
     }
 
     /// <inheritdoc />
-    public void DeleteChapterImages(Video video)
+    public async Task DeleteChapterDataAsync(Guid itemId, CancellationToken cancellationToken)
     {
-        var path = _pathManager.GetChapterImageFolderPath(video);
-        try
-        {
-            if (Directory.Exists(path))
-            {
-                _logger.LogInformation("Removing chapter images for {Name} [{Id}]", video.Name, video.Id);
-                Directory.Delete(path, true);
-            }
-        }
-        catch (Exception ex)
-        {
-            _logger.LogWarning("Failed to remove chapter image folder for {Item}: {Exception}", video.Id, ex);
-        }
-
-        _chapterRepository.DeleteChapters(video.Id);
+        await _chapterRepository.DeleteChaptersAsync(itemId, cancellationToken).ConfigureAwait(false);
     }
 
     private IReadOnlyList<string> GetSavedChapterImages(Video video, IDirectoryService directoryService)

Emby.Server.Implementations/Collections/CollectionManager.cs

@@ -4,12 +4,15 @@ using System.IO;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
+using Jellyfin.Data.Enums;
 using Jellyfin.Database.Implementations.Entities;
+using Jellyfin.Extensions;
 using MediaBrowser.Common.Configuration;
 using MediaBrowser.Controller.Collections;
 using MediaBrowser.Controller.Entities;
 using MediaBrowser.Controller.Entities.Movies;
 using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Persistence;
 using MediaBrowser.Controller.Providers;
 using MediaBrowser.Model.Configuration;
 using MediaBrowser.Model.Entities;
@@ -29,6 +32,7 @@ namespace Emby.Server.Implementations.Collections
         private readonly ILibraryMonitor _iLibraryMonitor;
         private readonly ILogger<CollectionManager> _logger;
         private readonly IProviderManager _providerManager;
+        private readonly ILinkedChildrenService _linkedChildrenService;
         private readonly ILocalizationManager _localizationManager;
         private readonly IApplicationPaths _appPaths;
 
@@ -42,6 +46,7 @@ namespace Emby.Server.Implementations.Collections
         /// <param name="iLibraryMonitor">The library monitor.</param>
         /// <param name="loggerFactory">The logger factory.</param>
         /// <param name="providerManager">The provider manager.</param>
+        /// <param name="linkedChildrenService">The linked children service.</param>
         public CollectionManager(
             ILibraryManager libraryManager,
             IApplicationPaths appPaths,
@@ -49,13 +54,15 @@ namespace Emby.Server.Implementations.Collections
             IFileSystem fileSystem,
             ILibraryMonitor iLibraryMonitor,
             ILoggerFactory loggerFactory,
-            IProviderManager providerManager)
+            IProviderManager providerManager,
+            ILinkedChildrenService linkedChildrenService)
         {
             _libraryManager = libraryManager;
             _fileSystem = fileSystem;
             _iLibraryMonitor = iLibraryMonitor;
             _logger = loggerFactory.CreateLogger<CollectionManager>();
             _providerManager = providerManager;
+            _linkedChildrenService = linkedChildrenService;
             _localizationManager = localizationManager;
             _appPaths = appPaths;
         }
@@ -100,10 +107,13 @@ namespace Emby.Server.Implementations.Collections
                 SaveLocalMetadata = true
             };
 
-            var name = _localizationManager.GetLocalizedString("Collections");
+            // This names a library for the whole server, so ignore the requesting client's language.
+            var name = _localizationManager.GetServerLocalizedString("Collections");
 
             await _libraryManager.AddVirtualFolder(name, CollectionTypeOptions.boxsets, libraryOptions, true).ConfigureAwait(false);
 
+            _libraryManager.RootFolder.Children = null;
+
             return FindFolders(path).First();
         }
 
@@ -118,6 +128,22 @@ namespace Emby.Server.Implementations.Collections
             return EnsureLibraryFolder(GetCollectionsFolderPath(), createIfNeeded);
         }
 
+        /// <inheritdoc />
+        public IEnumerable<BoxSet> GetCollectionsContainingItem(User user, Guid itemId)
+        {
+            ArgumentNullException.ThrowIfNull(user);
+
+            if (itemId.IsEmpty())
+            {
+                return Enumerable.Empty<BoxSet>();
+            }
+
+            return _linkedChildrenService
+                .GetManualLinkedParentIds(itemId, BaseItemKind.BoxSet)
+                .Select(parentId => _libraryManager.GetItemById<BoxSet>(parentId, user))
+                .OfType<BoxSet>();
+        }
+
         private IEnumerable<BoxSet> GetCollections(User user)
         {
             var folder = GetCollectionsFolder(false).GetAwaiter().GetResult();
@@ -270,7 +296,7 @@ namespace Emby.Server.Implementations.Collections
             {
                 var childItem = _libraryManager.GetItemById(guidId);
 
-                var child = collection.LinkedChildren.FirstOrDefault(i => (i.ItemId.HasValue && i.ItemId.Value.Equals(guidId)) || (childItem is not null && string.Equals(childItem.Path, i.Path, StringComparison.OrdinalIgnoreCase)));
+                var child = collection.LinkedChildren.FirstOrDefault(i => i.ItemId.HasValue && i.ItemId.Value.Equals(guidId));
 
                 if (child is null)
                 {
@@ -340,7 +366,7 @@ namespace Emby.Server.Implementations.Collections
                     // this is kind of a performance hack because only Video has alternate versions that should be in a box set?
                     if (item is Video video)
                     {
-                        foreach (var childId in video.GetLocalAlternateVersionIds())
+                        foreach (var childId in _libraryManager.GetLocalAlternateVersionIds(video))
                         {
                             if (!results.ContainsKey(childId))
                             {

Emby.Server.Implementations/Cryptography/CryptographyProvider.cs

@@ -39,22 +39,24 @@ namespace Emby.Server.Implementations.Cryptography
         {
             if (string.Equals(hash.Id, "PBKDF2", StringComparison.Ordinal))
             {
+                var iterations = GetIterationsParameter(hash);
                 return hash.Hash.SequenceEqual(
                     Rfc2898DeriveBytes.Pbkdf2(
                         password,
                         hash.Salt,
-                        int.Parse(hash.Parameters["iterations"], CultureInfo.InvariantCulture),
+                        iterations,
                         HashAlgorithmName.SHA1,
                         32));
             }
 
             if (string.Equals(hash.Id, "PBKDF2-SHA512", StringComparison.Ordinal))
             {
+                var iterations = GetIterationsParameter(hash);
                 return hash.Hash.SequenceEqual(
                     Rfc2898DeriveBytes.Pbkdf2(
                         password,
                         hash.Salt,
-                        int.Parse(hash.Parameters["iterations"], CultureInfo.InvariantCulture),
+                        iterations,
                         HashAlgorithmName.SHA512,
                         DefaultOutputLength));
             }
@@ -62,6 +64,27 @@ namespace Emby.Server.Implementations.Cryptography
             throw new NotSupportedException($"Can't verify hash with id: {hash.Id}");
         }
 
+        /// <summary>
+        /// Extracts and validates the iterations parameter from a password hash.
+        /// </summary>
+        /// <param name="hash">The password hash containing parameters.</param>
+        /// <returns>The number of iterations.</returns>
+        /// <exception cref="FormatException">Thrown when iterations parameter is missing or invalid.</exception>
+        private static int GetIterationsParameter(PasswordHash hash)
+        {
+            if (!hash.Parameters.TryGetValue("iterations", out var iterationsStr))
+            {
+                throw new FormatException($"Password hash with id '{hash.Id}' is missing required 'iterations' parameter.");
+            }
+
+            if (!int.TryParse(iterationsStr, CultureInfo.InvariantCulture, out var iterations))
+            {
+                throw new FormatException($"Password hash with id '{hash.Id}' has invalid 'iterations' parameter: '{iterationsStr}'.");
+            }
+
+            return iterations;
+        }
+
         /// <inheritdoc />
         public byte[] GenerateSalt()
             => GenerateSalt(DefaultSaltLength);

Emby.Server.Implementations/Data/CleanDatabaseScheduledTask.cs

@@ -5,10 +5,12 @@ using System.IO;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
+using Jellyfin.Data.Enums;
 using Jellyfin.Database.Implementations;
 using MediaBrowser.Controller.Entities;
 using MediaBrowser.Controller.IO;
 using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Playlists;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.Extensions.Logging;
 
@@ -35,7 +37,11 @@ public class CleanDatabaseScheduledTask : ILibraryPostScanTask
 
     public async Task Run(IProgress<double> progress, CancellationToken cancellationToken)
     {
-        await CleanDeadItems(cancellationToken, progress).ConfigureAwait(false);
+        var deadItemsProgress = new Progress<double>(val => progress.Report(val * 0.8));
+        await CleanDeadItems(cancellationToken, deadItemsProgress).ConfigureAwait(false);
+
+        var playlistProgress = new Progress<double>(val => progress.Report(80 + (val * 0.2)));
+        await CleanOrphanedFilePlaylistsAsync(cancellationToken, playlistProgress).ConfigureAwait(false);
     }
 
     private async Task CleanDeadItems(CancellationToken cancellationToken, IProgress<double> progress)
@@ -116,4 +122,32 @@ public class CleanDatabaseScheduledTask : ILibraryPostScanTask
 
         progress.Report(100);
     }
+
+    private async Task CleanOrphanedFilePlaylistsAsync(CancellationToken cancellationToken, IProgress<double> progress)
+    {
+        var playlists = _libraryManager.GetItemList(new InternalItemsQuery
+        {
+            IncludeItemTypes = [BaseItemKind.Playlist],
+            Recursive = true
+        }).OfType<Playlist>().ToList();
+
+        var numComplete = 0;
+        var numItems = Math.Max(playlists.Count, 1);
+
+        foreach (var playlist in playlists)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+
+            if (playlist.IsFile && !File.Exists(playlist.Path))
+            {
+                _logger.LogInformation("Removing file-based playlist {Name} because source file {Path} no longer exists", playlist.Name, playlist.Path);
+                _libraryManager.DeleteItem(playlist, new DeleteOptions { DeleteFileLocation = false });
+            }
+
+            numComplete++;
+            progress.Report((double)numComplete / numItems * 100);
+        }
+
+        progress.Report(100);
+    }
 }

Emby.Server.Implementations/Devices/DeviceId.cs

@@ -1,5 +1,3 @@
-#pragma warning disable CS1591
-
 using System;
 using System.Globalization;
 using System.IO;
@@ -10,6 +8,9 @@ using Microsoft.Extensions.Logging;
 
 namespace Emby.Server.Implementations.Devices
 {
+    /// <summary>
+    /// Provides the persistent unique identifier of this server installation.
+    /// </summary>
     public class DeviceId
     {
         private readonly IApplicationPaths _appPaths;
@@ -18,12 +19,20 @@ namespace Emby.Server.Implementations.Devices
 
         private string? _id;
 
+        /// <summary>
+        /// Initializes a new instance of the <see cref="DeviceId"/> class.
+        /// </summary>
+        /// <param name="appPaths">Instance of the <see cref="IApplicationPaths"/> interface.</param>
+        /// <param name="logger">Instance of the <see cref="ILogger{DeviceId}"/> interface.</param>
         public DeviceId(IApplicationPaths appPaths, ILogger<DeviceId> logger)
         {
             _appPaths = appPaths;
             _logger = logger;
         }
 
+        /// <summary>
+        /// Gets the device id, loading it from disk or generating and persisting a new one if none exists.
+        /// </summary>
         public string Value => _id ??= GetDeviceId();
 
         private string CachePath => Path.Combine(_appPaths.DataPath, "device.txt");

Emby.Server.Implementations/Dto/DtoService.cs

@@ -71,6 +71,8 @@ namespace Emby.Server.Implementations.Dto
             {
                 BaseItemKind.Person, [
                     BaseItemKind.Audio,
+                    BaseItemKind.AudioBook,
+                    BaseItemKind.Book,
                     BaseItemKind.Episode,
                     BaseItemKind.Movie,
                     BaseItemKind.LiveTvProgram,
@@ -153,17 +155,139 @@ namespace Emby.Server.Implementations.Dto
         private ILiveTvManager LivetvManager => _livetvManagerFactory.Value;
 
         /// <inheritdoc />
-        public IReadOnlyList<BaseItemDto> GetBaseItemDtos(IReadOnlyList<BaseItem> items, DtoOptions options, User? user = null, BaseItem? owner = null)
+        public IReadOnlyList<BaseItemDto> GetBaseItemDtos(
+            IReadOnlyList<BaseItem> items,
+            DtoOptions options,
+            User? user = null,
+            BaseItem? owner = null,
+            bool skipVisibilityCheck = false)
         {
-            var accessibleItems = user is null ? items : items.Where(x => x.IsVisible(user)).ToList();
+            var accessibleItems = skipVisibilityCheck || user is null ? items : items.Where(x => x.IsVisible(user)).ToList();
             var returnItems = new BaseItemDto[accessibleItems.Count];
             List<(BaseItem, BaseItemDto)>? programTuples = null;
             List<(BaseItemDto, LiveTvChannel)>? channelTuples = null;
 
+            // Batch-fetch user data for all items
+            Dictionary<Guid, UserItemData>? userDataBatch = null;
+            IReadOnlyDictionary<Guid, VersionResumeData>? resumeDataBatch = null;
+            if (user is not null && options.EnableUserData)
+            {
+                userDataBatch = _userDataRepository.GetUserDataBatch(accessibleItems, user);
+
+                // For items with alternate versions, the most recently played version drives resume.
+                resumeDataBatch = _userDataRepository.GetResumeUserDataBatch(accessibleItems, user);
+            }
+
+            // Pre-compute collection folders once to avoid N+1 queries in CanDelete
+            List<Folder>? allCollectionFolders = null;
+            if (user is not null && options.ContainsField(ItemFields.CanDelete))
+            {
+                allCollectionFolders = _libraryManager.GetUserRootFolder().Children.OfType<Folder>().ToList();
+            }
+
+            // Batch-fetch by-name item counts to avoid N+1 queries
+            Dictionary<Guid, ItemCounts>? itemCountsBatch = null;
+            if (options.ContainsField(ItemFields.ItemCounts))
+            {
+                itemCountsBatch = GetItemCountsBatch(accessibleItems, user);
+            }
+
+            // Batch-fetch child counts for all folders to avoid N+1 queries
+            Dictionary<Guid, int>? childCountBatch = null;
+            if (options.ContainsField(ItemFields.ChildCount))
+            {
+                var folderIds = accessibleItems.OfType<Folder>().Select(f => f.Id).ToList();
+                if (folderIds.Count > 0)
+                {
+                    childCountBatch = _libraryManager.GetChildCountBatch(folderIds, user);
+                }
+            }
+
+            // Batch-fetch played/total counts for all folders to avoid N+1 queries
+            Dictionary<Guid, (int Played, int Total)>? playedCountBatch = null;
+            if (user is not null && options.EnableUserData)
+            {
+                var folderIds = accessibleItems.OfType<Folder>()
+                    .Where(f => f.SupportsUserDataFromChildren && (f.SupportsPlayedStatus || options.ContainsField(ItemFields.RecursiveItemCount)))
+                    .Select(f => f.Id).ToList();
+                if (folderIds.Count > 0)
+                {
+                    playedCountBatch = _libraryManager.GetPlayedAndTotalCountBatch(folderIds, user);
+                }
+            }
+
+            // Batch-fetch MusicArtist lookups across all items to avoid N+1 queries.
+            IReadOnlyDictionary<string, MusicArtist[]>? artistsBatch = null;
+            var artistNames = new HashSet<string>(StringComparer.Ordinal);
+            foreach (var item in accessibleItems)
+            {
+                if (item is IHasArtist hasArtist)
+                {
+                    foreach (var name in hasArtist.Artists)
+                    {
+                        if (!string.IsNullOrWhiteSpace(name))
+                        {
+                            artistNames.Add(name);
+                        }
+                    }
+                }
+
+                if (item is IHasAlbumArtist hasAlbumArtist)
+                {
+                    foreach (var name in hasAlbumArtist.AlbumArtists)
+                    {
+                        if (!string.IsNullOrWhiteSpace(name))
+                        {
+                            artistNames.Add(name);
+                        }
+                    }
+                }
+            }
+
+            if (artistNames.Count > 0)
+            {
+                artistsBatch = _libraryManager.GetArtists(artistNames.ToArray());
+            }
+
+            // Batch-fetch people across all items to avoid one GetPeople query per item.
+            IReadOnlyDictionary<Guid, IReadOnlyList<PersonInfo>>? peopleBatch = null;
+            if (options.ContainsField(ItemFields.People))
+            {
+                var peopleItemIds = accessibleItems.Where(i => i.SupportsPeople).Select(i => i.Id).ToList();
+                if (peopleItemIds.Count > 0)
+                {
+                    peopleBatch = _libraryManager.GetPeopleByItems(peopleItemIds);
+                }
+            }
+
+            // Batch-detect which videos own alternate versions to avoid the per-item alternate-version
+            // queries in MediaSourceCount. Videos absent from this set have a single media source.
+            IReadOnlySet<Guid>? alternateVersionItemIds = null;
+            if (options.ContainsField(ItemFields.MediaSourceCount))
+            {
+                var versionItemIds = accessibleItems.OfType<Video>().Select(i => i.Id).ToList();
+                if (versionItemIds.Count > 0)
+                {
+                    alternateVersionItemIds = _libraryManager.GetItemIdsWithAlternateVersions(versionItemIds);
+                }
+            }
+
             for (int index = 0; index < accessibleItems.Count; index++)
             {
                 var item = accessibleItems[index];
-                var dto = GetBaseItemDtoInternal(item, options, user, owner);
+                var dto = GetBaseItemDtoInternal(
+                    item,
+                    options,
+                    user,
+                    owner,
+                    userDataBatch?.GetValueOrDefault(item.Id),
+                    allCollectionFolders,
+                    childCountBatch,
+                    playedCountBatch,
+                    artistsBatch,
+                    resumeDataBatch?.GetValueOrDefault(item.Id),
+                    peopleBatch,
+                    alternateVersionItemIds);
 
                 if (item is LiveTvChannel tvChannel)
                 {
@@ -176,7 +300,7 @@ namespace Emby.Server.Implementations.Dto
 
                 if (options.ContainsField(ItemFields.ItemCounts))
                 {
-                    SetItemByNameInfo(dto, user);
+                    SetItemByNameInfo(dto, user, itemCountsBatch);
                 }
 
                 returnItems[index] = dto;
@@ -197,7 +321,7 @@ namespace Emby.Server.Implementations.Dto
 
         public BaseItemDto GetBaseItemDto(BaseItem item, DtoOptions options, User? user = null, BaseItem? owner = null)
         {
-            var dto = GetBaseItemDtoInternal(item, options, user, owner);
+            var dto = GetBaseItemDtoInternal(item, options, user, owner, null);
             if (item is LiveTvChannel tvChannel)
             {
                 LivetvManager.AddChannelInfo(new[] { (dto, tvChannel) }, options, user);
@@ -215,7 +339,19 @@ namespace Emby.Server.Implementations.Dto
             return dto;
         }
 
-        private BaseItemDto GetBaseItemDtoInternal(BaseItem item, DtoOptions options, User? user = null, BaseItem? owner = null)
+        private BaseItemDto GetBaseItemDtoInternal(
+            BaseItem item,
+            DtoOptions options,
+            User? user = null,
+            BaseItem? owner = null,
+            UserItemData? userData = null,
+            List<Folder>? allCollectionFolders = null,
+            Dictionary<Guid, int>? childCountBatch = null,
+            Dictionary<Guid, (int Played, int Total)>? playedCountBatch = null,
+            IReadOnlyDictionary<string, MusicArtist[]>? artistsBatch = null,
+            VersionResumeData? resumeData = null,
+            IReadOnlyDictionary<Guid, IReadOnlyList<PersonInfo>>? peopleBatch = null,
+            IReadOnlySet<Guid>? alternateVersionItemIds = null)
         {
             var dto = new BaseItemDto
             {
@@ -229,7 +365,15 @@ namespace Emby.Server.Implementations.Dto
 
             if (options.ContainsField(ItemFields.People))
             {
-                AttachPeople(dto, item, user);
+                IReadOnlyList<PersonInfo>? prefetchedPeople = null;
+                if (peopleBatch is not null)
+                {
+                    // The batch omits items with no people, so a miss means "no people",
+                    // not "not fetched". Use an empty list to skip the per-item query.
+                    prefetchedPeople = peopleBatch.GetValueOrDefault(item.Id) ?? [];
+                }
+
+                AttachPeople(dto, item, user, prefetchedPeople);
             }
 
             if (options.ContainsField(ItemFields.PrimaryImageAspectRatio))
@@ -252,7 +396,15 @@ namespace Emby.Server.Implementations.Dto
 
             if (user is not null)
             {
-                AttachUserSpecificInfo(dto, item, user, options);
+                AttachUserSpecificInfo(
+                    dto,
+                    item,
+                    user,
+                    options,
+                    userData,
+                    childCountBatch,
+                    playedCountBatch,
+                    resumeData);
             }
 
             if (item is IHasMediaSources
@@ -268,13 +420,15 @@ namespace Emby.Server.Implementations.Dto
                 AttachStudios(dto, item);
             }
 
-            AttachBasicFields(dto, item, owner, options);
+            AttachBasicFields(dto, item, owner, options, artistsBatch, user, alternateVersionItemIds);
 
             if (options.ContainsField(ItemFields.CanDelete))
             {
                 dto.CanDelete = user is null
                     ? item.CanDelete()
-                    : item.CanDelete(user);
+                    : allCollectionFolders is not null
+                        ? item.CanDelete(user, allCollectionFolders)
+                        : item.CanDelete(user);
             }
 
             if (options.ContainsField(ItemFields.CanDownload))
@@ -371,44 +525,36 @@ namespace Emby.Server.Implementations.Dto
             return dto;
         }
 
-        private void SetItemByNameInfo(BaseItemDto dto, User? user)
+        private Dictionary<Guid, ItemCounts> GetItemCountsBatch(IReadOnlyList<BaseItem> items, User? user)
+        {
+            var result = new Dictionary<Guid, ItemCounts>();
+
+            foreach (var group in items.GroupBy(item => item.GetBaseItemKind()))
+            {
+                if (!_relatedItemKinds.TryGetValue(group.Key, out var relatedItemKinds))
+                {
+                    continue;
+                }
+
+                var ids = group.Select(item => item.Id).ToArray();
+                foreach (var (id, counts) in _libraryManager.GetItemCountsForNameItems(group.Key, ids, relatedItemKinds, user))
+                {
+                    result[id] = counts;
+                }
+            }
+
+            return result;
+        }
+
+        private void SetItemByNameInfo(BaseItemDto dto, User? user, IReadOnlyDictionary<Guid, ItemCounts>? prefetchedCounts = null)
         {
             if (!_relatedItemKinds.TryGetValue(dto.Type, out var relatedItemKinds))
             {
                 return;
             }
 
-            var query = new InternalItemsQuery(user)
-            {
-                Recursive = true,
-                DtoOptions = new DtoOptions(false) { EnableImages = false },
-                IncludeItemTypes = relatedItemKinds
-            };
-
-            switch (dto.Type)
-            {
-                case BaseItemKind.Genre:
-                case BaseItemKind.MusicGenre:
-                    query.GenreIds = [dto.Id];
-                    break;
-                case BaseItemKind.MusicArtist:
-                    query.ArtistIds = [dto.Id];
-                    break;
-                case BaseItemKind.Person:
-                    query.PersonIds = [dto.Id];
-                    break;
-                case BaseItemKind.Studio:
-                    query.StudioIds = [dto.Id];
-                    break;
-                case BaseItemKind.Year
-                    when int.TryParse(dto.Name, NumberStyles.Integer, CultureInfo.InvariantCulture, out var year):
-                    query.Years = [year];
-                    break;
-                default:
-                    return;
-            }
-
-            var counts = _libraryManager.GetItemCounts(query);
+            var counts = prefetchedCounts?.GetValueOrDefault(dto.Id)
+                ?? _libraryManager.GetItemCountsForNameItem(dto.Type, dto.Id, relatedItemKinds, user);
 
             dto.AlbumCount = counts.AlbumCount;
             dto.ArtistCount = counts.ArtistCount;
@@ -458,7 +604,15 @@ namespace Emby.Server.Implementations.Dto
         /// <summary>
         /// Attaches the user specific info.
         /// </summary>
-        private void AttachUserSpecificInfo(BaseItemDto dto, BaseItem item, User user, DtoOptions options)
+        private void AttachUserSpecificInfo(
+            BaseItemDto dto,
+            BaseItem item,
+            User user,
+            DtoOptions options,
+            UserItemData? userData = null,
+            Dictionary<Guid, int>? childCountBatch = null,
+            Dictionary<Guid, (int Played, int Total)>? playedCountBatch = null,
+            VersionResumeData? resumeData = null)
         {
             if (item.IsFolder)
             {
@@ -466,7 +620,19 @@ namespace Emby.Server.Implementations.Dto
 
                 if (options.EnableUserData)
                 {
-                    dto.UserData = _userDataRepository.GetUserDataDto(item, dto, user, options);
+                    if (userData is not null)
+                    {
+                        // Use pre-fetched user data
+                        dto.UserData = GetUserItemDataDto(userData, item.Id);
+                        (int Played, int Total)? precomputed = playedCountBatch is not null
+                            && playedCountBatch.TryGetValue(item.Id, out var counts) ? counts : null;
+                        item.FillUserDataDtoValues(dto.UserData, userData, dto, user, options, precomputed);
+                    }
+                    else
+                    {
+                        // Fall back to individual fetch
+                        dto.UserData = _userDataRepository.GetUserDataDto(item, dto, user, options);
+                    }
                 }
 
                 if (!dto.ChildCount.HasValue && item.SourceType == SourceType.Library)
@@ -474,7 +640,11 @@ namespace Emby.Server.Implementations.Dto
                     // For these types we can try to optimize and assume these values will be equal
                     if (item is MusicAlbum || item is Season || item is Playlist)
                     {
-                        dto.ChildCount = dto.RecursiveItemCount;
+                        if (dto.RecursiveItemCount > 0)
+                        {
+                            dto.ChildCount = dto.RecursiveItemCount;
+                        }
+
                         var folderChildCount = folder.LinkedChildren.Length;
                         // The default is an empty array, so we can't reliably use the count when it's empty
                         if (folderChildCount > 0)
@@ -485,7 +655,7 @@ namespace Emby.Server.Implementations.Dto
 
                     if (options.ContainsField(ItemFields.ChildCount))
                     {
-                        dto.ChildCount ??= GetChildCount(folder, user);
+                        dto.ChildCount ??= GetChildCount(folder, user, childCountBatch);
                     }
                 }
 
@@ -503,7 +673,20 @@ namespace Emby.Server.Implementations.Dto
             {
                 if (options.EnableUserData)
                 {
-                    dto.UserData = _userDataRepository.GetUserDataDto(item, user);
+                    if (userData is not null)
+                    {
+                        // Use pre-fetched user data
+                        dto.UserData = GetUserItemDataDto(userData, item.Id);
+                        item.FillUserDataDtoValues(dto.UserData, userData, dto, user, options);
+
+                        // For items with alternate versions, the most recently played version drives resume.
+                        resumeData?.ApplyTo(dto.UserData);
+                    }
+                    else
+                    {
+                        // Fall back to individual fetch
+                        dto.UserData = _userDataRepository.GetUserDataDto(item, user);
+                    }
                 }
             }
 
@@ -513,7 +696,25 @@ namespace Emby.Server.Implementations.Dto
             }
         }
 
-        private static int GetChildCount(Folder folder, User user)
+        private static UserItemDataDto GetUserItemDataDto(UserItemData data, Guid itemId)
+        {
+            ArgumentNullException.ThrowIfNull(data);
+
+            return new UserItemDataDto
+            {
+                IsFavorite = data.IsFavorite,
+                Likes = data.Likes,
+                PlaybackPositionTicks = data.PlaybackPositionTicks,
+                PlayCount = data.PlayCount,
+                Rating = data.Rating,
+                Played = data.Played,
+                LastPlayedDate = data.LastPlayedDate,
+                ItemId = itemId,
+                Key = data.Key
+            };
+        }
+
+        private static int GetChildCount(Folder folder, User user, Dictionary<Guid, int>? childCountBatch)
         {
             // Right now this is too slow to calculate for top level folders on a per-user basis
             // Just return something so that apps that are expecting a value won't think the folders are empty
@@ -522,6 +723,14 @@ namespace Emby.Server.Implementations.Dto
                 return Random.Shared.Next(1, 10);
             }
 
+            // Use pre-fetched batch data if available
+            if (childCountBatch is not null && childCountBatch.TryGetValue(folder.Id, out var count))
+            {
+                return count;
+            }
+
+            // Only reached when no batch was computed: the batch holds an entry for every folder it
+            // was asked about, zero included.
             return folder.GetChildCount(user);
         }
 
@@ -602,12 +811,18 @@ namespace Emby.Server.Implementations.Dto
         /// <param name="dto">The dto.</param>
         /// <param name="item">The item.</param>
         /// <param name="user">The requesting user.</param>
-        private void AttachPeople(BaseItemDto dto, BaseItem item, User? user = null)
+        /// <param name="prefetchedPeople">People fetched in batch by the caller; when null the people are queried per item.</param>
+        private void AttachPeople(BaseItemDto dto, BaseItem item, User? user = null, IReadOnlyList<PersonInfo>? prefetchedPeople = null)
         {
+            // When rendering a page of items the caller batch-fetches people for every item up
+            // front and passes them in, avoiding one GetPeople query per item. Fall back to the
+            // per-item query for the single item path where no batch is available.
+            var source = prefetchedPeople ?? _libraryManager.GetPeople(item);
+
             // Ordering by person type to ensure actors and artists are at the front.
             // This is taking advantage of the fact that they both begin with A
             // This should be improved in the future
-            var people = _libraryManager.GetPeople(item).OrderBy(i => i.SortOrder ?? int.MaxValue)
+            var people = source.OrderBy(i => i.SortOrder ?? int.MaxValue)
                 .ThenBy(i =>
                 {
                     if (i.IsType(PersonKind.Actor))
@@ -815,7 +1030,10 @@ namespace Emby.Server.Implementations.Dto
         /// <param name="item">The item.</param>
         /// <param name="owner">The owner.</param>
         /// <param name="options">The options.</param>
-        private void AttachBasicFields(BaseItemDto dto, BaseItem item, BaseItem? owner, DtoOptions options)
+        /// <param name="artistsBatch">Optional pre-fetched artist lookup shared across a batch of items.</param>
+        /// <param name="user">The user, for per-user values such as the accessible media source count.</param>
+        /// <param name="alternateVersionItemIds">Optional pre-fetched set of item IDs that own alternate versions, shared across a batch of items.</param>
+        private void AttachBasicFields(BaseItemDto dto, BaseItem item, BaseItem? owner, DtoOptions options, IReadOnlyDictionary<string, MusicArtist[]>? artistsBatch = null, User? user = null, IReadOnlySet<Guid>? alternateVersionItemIds = null)
         {
             if (options.ContainsField(ItemFields.DateCreated))
             {
@@ -939,12 +1157,14 @@ namespace Emby.Server.Implementations.Dto
                 dto.OriginalTitle = item.OriginalTitle;
             }
 
+            dto.OriginalLanguage = item.OriginalLanguage;
+
             if (options.ContainsField(ItemFields.ParentId))
             {
                 dto.ParentId = item.DisplayParentId;
             }
 
-            AddInheritedImages(dto, item, options, owner);
+            AddInheritedImages(dto, item, options, owner, artistsBatch);
 
             if (options.ContainsField(ItemFields.Path))
             {
@@ -1019,6 +1239,15 @@ namespace Emby.Server.Implementations.Dto
                 {
                     dto.AlbumId = albumParent.Id;
                     dto.AlbumPrimaryImageTag = GetTagAndFillBlurhash(dto, albumParent, ImageType.Primary);
+                    if (albumParent.LUFS.HasValue)
+                    {
+                        // -18 LUFS reference, same as ReplayGain 2.0, compatible with ReplayGain 1.0
+                        dto.AlbumNormalizationGain = -18f - albumParent.LUFS;
+                    }
+                    else if (albumParent.NormalizationGain.HasValue)
+                    {
+                        dto.AlbumNormalizationGain = albumParent.NormalizationGain;
+                    }
                 }
 
                 // if (options.ContainsField(ItemFields.MediaSourceCount))
@@ -1051,16 +1280,17 @@ namespace Emby.Server.Implementations.Dto
 
                 // Include artists that are not in the database yet, e.g., just added via metadata editor
                 // var foundArtists = artistItems.Items.Select(i => i.Item1.Name).ToList();
-                dto.ArtistItems = _libraryManager.GetArtists([.. hasArtist.Artists.Where(e => !string.IsNullOrWhiteSpace(e))])
-                    .Where(e => e.Value.Length > 0)
-                    .Select(i =>
-                    {
-                        return new NameGuidPair
-                        {
-                            Name = i.Key,
-                            Id = i.Value.First().Id
-                        };
-                    }).Where(i => i is not null).ToArray();
+                var artistsLookup = artistsBatch
+                    ?? _libraryManager.GetArtists([.. hasArtist.Artists.Where(e => !string.IsNullOrWhiteSpace(e))]);
+
+                dto.ArtistItems = hasArtist.Artists
+                    .Where(name => !string.IsNullOrWhiteSpace(name))
+                    .Distinct()
+                    .Select(name => artistsLookup.TryGetValue(name, out var artists) && artists.Length > 0
+                        ? new NameGuidPair { Name = name, Id = artists[0].Id }
+                        : null)
+                    .Where(item => item is not null)
+                    .ToArray();
             }
 
             if (item is IHasAlbumArtist hasAlbumArtist)
@@ -1085,31 +1315,17 @@ namespace Emby.Server.Implementations.Dto
                 //    })
                 //    .ToList();
 
+                var albumArtistsLookup = artistsBatch
+                    ?? _libraryManager.GetArtists([.. hasAlbumArtist.AlbumArtists.Where(e => !string.IsNullOrWhiteSpace(e))]);
+
                 dto.AlbumArtists = hasAlbumArtist.AlbumArtists
-                    // .Except(foundArtists, new DistinctNameComparer())
-                    .Select(i =>
-                    {
-                        // This should not be necessary but we're seeing some cases of it
-                        if (string.IsNullOrEmpty(i))
-                        {
-                            return null;
-                        }
-
-                        var artist = _libraryManager.GetArtist(i, new DtoOptions(false)
-                        {
-                            EnableImages = false
-                        });
-                        if (artist is not null)
-                        {
-                            return new NameGuidPair
-                            {
-                                Name = artist.Name,
-                                Id = artist.Id
-                            };
-                        }
-
-                        return null;
-                    }).Where(i => i is not null).ToArray();
+                    .Where(name => !string.IsNullOrWhiteSpace(name))
+                    .Distinct()
+                    .Select(name => albumArtistsLookup.TryGetValue(name, out var albumArtists) && albumArtists.Length > 0
+                        ? new NameGuidPair { Name = name, Id = albumArtists[0].Id }
+                        : null)
+                    .Where(item => item is not null)
+                    .ToArray();
             }
 
             // Add video info
@@ -1131,16 +1347,28 @@ namespace Emby.Server.Implementations.Dto
 
                 if (options.ContainsField(ItemFields.MediaSourceCount))
                 {
-                    var mediaSourceCount = video.MediaSourceCount;
-                    if (mediaSourceCount != 1)
-                    {
-                        dto.MediaSourceCount = mediaSourceCount;
-                    }
-                }
+                    // A video with no primary version and no alternate versions always has a single
+                    // media source. Only compute the count for videos that might have more: a primary
+                    // version, or membership in the batch's set of items that own alternate versions.
+                    // Without the batch we can't rule it out, so fall back to computing (the single-item
+                    // path). Everything else is the common case and keeps the default count of one.
+                    var mayHaveAlternateVersions = alternateVersionItemIds is null
+                        || video.PrimaryVersionId.HasValue
+                        || alternateVersionItemIds.Contains(video.Id);
 
-                if (options.ContainsField(ItemFields.Chapters))
-                {
-                    dto.Chapters = _chapterManager.GetChapters(item.Id).ToList();
+                    if (mayHaveAlternateVersions)
+                    {
+                        // Match the per-user filtering of the media sources: versions the user cannot
+                        // access are not selectable, so they must not count towards the badge either.
+                        var mediaSourceCount = user is null
+                            || (!video.PrimaryVersionId.HasValue && video.LinkedAlternateVersions.Length == 0 && !video.HasLocalAlternateVersions)
+                                ? video.MediaSourceCount
+                                : video.GetAllVersions().Count(v => v.Id.Equals(video.Id) || v.IsVisibleStandalone(user));
+                        if (mediaSourceCount != 1)
+                        {
+                            dto.MediaSourceCount = mediaSourceCount;
+                        }
+                    }
                 }
 
                 if (options.ContainsField(ItemFields.Trickplay))
@@ -1156,6 +1384,11 @@ namespace Emby.Server.Implementations.Dto
                 dto.ExtraType = video.ExtraType;
             }
 
+            if (options.ContainsField(ItemFields.Chapters))
+            {
+                dto.Chapters = _chapterManager.GetChapters(item.Id).ToList();
+            }
+
             if (options.ContainsField(ItemFields.MediaStreams))
             {
                 // Add VideoInfo
@@ -1240,6 +1473,25 @@ namespace Emby.Server.Implementations.Dto
                     }
                 }
 
+                if (options.GetImageLimit(ImageType.Primary) > 0)
+                {
+                    var episodeSeason = episode.Season;
+                    var seasonPrimaryTag = episodeSeason is not null
+                        ? GetTagAndFillBlurhash(dto, episodeSeason, ImageType.Primary)
+                        : null;
+
+                    if (seasonPrimaryTag is not null)
+                    {
+                        dto.ParentPrimaryImageItemId = episodeSeason!.Id;
+                        dto.ParentPrimaryImageTag = seasonPrimaryTag;
+                    }
+                    else if (episodeSeries is not null && dto.SeriesPrimaryImageTag is not null)
+                    {
+                        dto.ParentPrimaryImageItemId = episodeSeries.Id;
+                        dto.ParentPrimaryImageTag = dto.SeriesPrimaryImageTag;
+                    }
+                }
+
                 if (options.ContainsField(ItemFields.SeriesStudio))
                 {
                     episodeSeries ??= episode.Series;
@@ -1355,11 +1607,11 @@ namespace Emby.Server.Implementations.Dto
             }
         }
 
-        private BaseItem? GetImageDisplayParent(BaseItem currentItem, BaseItem originalItem)
+        private BaseItem? GetImageDisplayParent(BaseItem currentItem, BaseItem originalItem, IReadOnlyDictionary<string, MusicArtist[]>? artistsBatch)
         {
             if (currentItem is MusicAlbum musicAlbum)
             {
-                var artist = musicAlbum.GetMusicArtist(new DtoOptions(false));
+                var artist = GetBatchedAlbumArtist(musicAlbum, artistsBatch) ?? musicAlbum.GetMusicArtist(new DtoOptions(false));
                 if (artist is not null)
                 {
                     return artist;
@@ -1376,8 +1628,36 @@ namespace Emby.Server.Implementations.Dto
             return parent;
         }
 
-        private void AddInheritedImages(BaseItemDto dto, BaseItem item, DtoOptions options, BaseItem? owner)
+        private static MusicArtist? GetBatchedAlbumArtist(MusicAlbum album, IReadOnlyDictionary<string, MusicArtist[]>? artistsBatch)
         {
+            if (artistsBatch is null)
+            {
+                return null;
+            }
+
+            var name = album.AlbumArtists.Count > 0 ? album.AlbumArtists[0] : null;
+            return !string.IsNullOrEmpty(name) && artistsBatch.TryGetValue(name, out var artists) && artists.Length > 0
+                ? artists[0]
+                : null;
+        }
+
+        private void AddInheritedImages(BaseItemDto dto, BaseItem item, DtoOptions options, BaseItem? owner, IReadOnlyDictionary<string, MusicArtist[]>? artistsBatch)
+        {
+            if (item is UserView { ViewType: CollectionType.playlists } playlistsView
+                && options.GetImageLimit(ImageType.Primary) > 0
+                && !playlistsView.DisplayParentId.IsEmpty())
+            {
+                var displayParent = _libraryManager.GetItemById(playlistsView.DisplayParentId);
+                var displayParentPrimaryImage = displayParent?.GetImageInfo(ImageType.Primary, 0);
+
+                if (displayParentPrimaryImage is not null)
+                {
+                    dto.ImageTags?.Remove(ImageType.Primary);
+                    dto.ParentPrimaryImageItemId = displayParent!.Id;
+                    dto.ParentPrimaryImageTag = GetTagAndFillBlurhash(dto, displayParent, displayParentPrimaryImage);
+                }
+            }
+
             if (!item.SupportsInheritedParentImages)
             {
                 return;
@@ -1406,7 +1686,7 @@ namespace Emby.Server.Implementations.Dto
                 || (!(imageTags is not null && imageTags.ContainsKey(ImageType.Thumb)) && thumbLimit > 0)
                 || parent is Series)
             {
-                parent ??= isFirst ? GetImageDisplayParent(item, item) ?? owner : parent;
+                parent ??= isFirst ? GetImageDisplayParent(item, item, artistsBatch) ?? owner : parent;
                 if (parent is null)
                 {
                     break;
@@ -1465,7 +1745,7 @@ namespace Emby.Server.Implementations.Dto
                     break;
                 }
 
-                parent = GetImageDisplayParent(parent, item);
+                parent = GetImageDisplayParent(parent, item, artistsBatch);
             }
         }
 

Emby.Server.Implementations/Emby.Server.Implementations.csproj

@@ -27,7 +27,6 @@
     <PackageReference Include="Microsoft.Data.Sqlite" />
     <PackageReference Include="Microsoft.Extensions.DependencyInjection" />
     <PackageReference Include="Microsoft.Extensions.Caching.Memory" />
-    <PackageReference Include="Microsoft.Extensions.Configuration.Abstractions" />
     <PackageReference Include="Microsoft.Extensions.Hosting.Abstractions" />
     <PackageReference Include="Microsoft.EntityFrameworkCore.Relational" />
     <PackageReference Include="prometheus-net.DotNetRuntime" />
@@ -39,7 +38,7 @@
   </ItemGroup>
 
   <PropertyGroup>
-    <TargetFramework>net9.0</TargetFramework>
+    <TargetFramework>net10.0</TargetFramework>
     <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
   </PropertyGroup>
@@ -66,6 +65,7 @@
 
   <ItemGroup>
     <PackageReference Include="Ignore" />
+    <PackageReference Include="StackExchange.Redis" />
   </ItemGroup>
 
   <ItemGroup>

Emby.Server.Implementations/EntryPoints/LibraryChangedNotifier.cs

@@ -27,6 +27,11 @@ namespace Emby.Server.Implementations.EntryPoints;
 /// </summary>
 public sealed class LibraryChangedNotifier : IHostedService, IDisposable
 {
+    // A batch holds a live reference to every item it names, so it has to stay small enough that a
+    // library scan - which changes items faster than any batch window closes - cannot grow it without
+    // bound. Reached only by a scan; interactive use closes a batch on the window long before this.
+    internal const int MaxBatchSize = 2000;
+
     private readonly ILibraryManager _libraryManager;
     private readonly IServerConfigurationManager _configurationManager;
     private readonly IProviderManager _providerManager;
@@ -35,11 +40,11 @@ public sealed class LibraryChangedNotifier : IHostedService, IDisposable
     private readonly ILogger<LibraryChangedNotifier> _logger;
 
     private readonly Lock _libraryChangedSyncLock = new();
-    private readonly List<Folder> _foldersAddedTo = new();
-    private readonly List<Folder> _foldersRemovedFrom = new();
-    private readonly List<BaseItem> _itemsAdded = new();
-    private readonly List<BaseItem> _itemsRemoved = new();
-    private readonly List<BaseItem> _itemsUpdated = new();
+    private readonly Dictionary<Guid, Folder> _foldersAddedTo = [];
+    private readonly Dictionary<Guid, Folder> _foldersRemovedFrom = [];
+    private readonly Dictionary<Guid, BaseItem> _itemsAdded = [];
+    private readonly Dictionary<Guid, BaseItem> _itemsRemoved = [];
+    private readonly Dictionary<Guid, BaseItem> _itemsUpdated = [];
     private readonly ConcurrentDictionary<Guid, DateTime> _lastProgressMessageTimes = new();
 
     private Timer? _libraryUpdateTimer;
@@ -173,7 +178,7 @@ public sealed class LibraryChangedNotifier : IHostedService, IDisposable
     private void OnLibraryItemRemoved(object? sender, ItemChangeEventArgs e)
         => OnLibraryChange(e.Item, e.Parent, _itemsRemoved, _foldersRemovedFrom);
 
-    private void OnLibraryChange(BaseItem item, BaseItem parent, List<BaseItem> itemsList, List<Folder>? foldersList)
+    private void OnLibraryChange(BaseItem item, BaseItem parent, Dictionary<Guid, BaseItem> itemsList, Dictionary<Guid, Folder>? foldersList)
     {
         if (!FilterItem(item))
         {
@@ -182,23 +187,28 @@ public sealed class LibraryChangedNotifier : IHostedService, IDisposable
 
         lock (_libraryChangedSyncLock)
         {
-            var updateDuration = TimeSpan.FromSeconds(_configurationManager.Configuration.LibraryUpdateDuration);
-
+            // The window runs from the first change of a batch and is never extended. Extending it on
+            // every change would keep a library scan's batch open for the whole scan, and the batch
+            // holds the items it names alive, so it would grow to the size of the library.
             if (_libraryUpdateTimer is null)
             {
+                var updateDuration = TimeSpan.FromSeconds(_configurationManager.Configuration.LibraryUpdateDuration);
                 _libraryUpdateTimer = new Timer(LibraryUpdateTimerCallback, null, updateDuration, Timeout.InfiniteTimeSpan);
             }
-            else
-            {
-                _libraryUpdateTimer.Change(updateDuration, Timeout.InfiniteTimeSpan);
-            }
 
             if (foldersList is not null && parent is Folder folder)
             {
-                foldersList.Add(folder);
+                foldersList[folder.Id] = folder;
             }
 
-            itemsList.Add(item);
+            itemsList[item.Id] = item;
+
+            // A window long enough to cover a burst still has to give way once the batch is large
+            // enough to be worth sending on its own.
+            if (_itemsAdded.Count + _itemsRemoved.Count + _itemsUpdated.Count >= MaxBatchSize)
+            {
+                _libraryUpdateTimer.Change(TimeSpan.Zero, Timeout.InfiniteTimeSpan);
+            }
         }
     }
 
@@ -211,22 +221,16 @@ public sealed class LibraryChangedNotifier : IHostedService, IDisposable
         List<BaseItem> itemsRemoved;
         lock (_libraryChangedSyncLock)
         {
-            // Remove dupes in case some were saved multiple times
-            foldersAddedTo = _foldersAddedTo
-                .DistinctBy(x => x.Id)
-                .ToList();
-
-            foldersRemovedFrom = _foldersRemovedFrom
-                .DistinctBy(x => x.Id)
-                .ToList();
+            foldersAddedTo = _foldersAddedTo.Values.ToList();
+            foldersRemovedFrom = _foldersRemovedFrom.Values.ToList();
 
             itemsUpdated = _itemsUpdated
-                .Where(i => !_itemsAdded.Contains(i))
-                .DistinctBy(x => x.Id)
+                .Where(e => !_itemsAdded.ContainsKey(e.Key))
+                .Select(e => e.Value)
                 .ToList();
 
-            itemsAdded = _itemsAdded.ToList();
-            itemsRemoved = _itemsRemoved.ToList();
+            itemsAdded = _itemsAdded.Values.ToList();
+            itemsRemoved = _itemsRemoved.Values.ToList();
 
             if (_libraryUpdateTimer is not null)
             {
@@ -241,6 +245,15 @@ public sealed class LibraryChangedNotifier : IHostedService, IDisposable
             _foldersRemovedFrom.Clear();
         }
 
+        if (itemsAdded.Count == 0
+            && itemsUpdated.Count == 0
+            && itemsRemoved.Count == 0
+            && foldersAddedTo.Count == 0
+            && foldersRemovedFrom.Count == 0)
+        {
+            return;
+        }
+
         await SendChangeNotifications(itemsAdded, itemsUpdated, itemsRemoved, foldersAddedTo, foldersRemovedFrom, CancellationToken.None).ConfigureAwait(false);
     }
 

Emby.Server.Implementations/EntryPoints/UserDataChangeNotifier.cs

@@ -18,15 +18,17 @@ namespace Emby.Server.Implementations.EntryPoints
     public sealed class UserDataChangeNotifier : IHostedService, IDisposable
     {
         private const int UpdateDuration = 500;
+        internal const int MaxBatchSize = 2000;
 
         private readonly ISessionManager _sessionManager;
         private readonly IUserDataManager _userDataManager;
         private readonly IUserManager _userManager;
 
-        private readonly Dictionary<Guid, List<BaseItem>> _changedItems = new();
+        private readonly Dictionary<Guid, Dictionary<Guid, BaseItem>> _changedItems = [];
         private readonly Lock _syncLock = new();
 
         private Timer? _updateTimer;
+        private int _changedItemCount;
 
         /// <summary>
         /// Initializes a new instance of the <see cref="UserDataChangeNotifier"/> class.
@@ -69,50 +71,64 @@ namespace Emby.Server.Implementations.EntryPoints
 
             lock (_syncLock)
             {
-                if (_updateTimer is null)
-                {
-                    _updateTimer = new Timer(
-                        UpdateTimerCallback,
-                        null,
-                        UpdateDuration,
-                        Timeout.Infinite);
-                }
-                else
-                {
-                    _updateTimer.Change(UpdateDuration, Timeout.Infinite);
-                }
+                // The window runs from the first change of a batch and is never extended, so a stream
+                // of changes that never pauses - a library scan - still closes its batches instead of
+                // holding every item it touched alive until the stream stops.
+                _updateTimer ??= new Timer(
+                    UpdateTimerCallback,
+                    null,
+                    UpdateDuration,
+                    Timeout.Infinite);
 
-                if (!_changedItems.TryGetValue(e.UserId, out List<BaseItem>? keys))
+                if (!_changedItems.TryGetValue(e.UserId, out Dictionary<Guid, BaseItem>? keys))
                 {
-                    keys = new List<BaseItem>();
+                    keys = [];
                     _changedItems[e.UserId] = keys;
                 }
 
-                keys.Add(e.Item);
-
                 var baseItem = e.Item;
 
                 // Go up one level for indicators
                 if (baseItem is not null)
                 {
+                    Track(keys, baseItem);
+
                     var parent = baseItem.GetOwner() ?? baseItem.GetParent();
 
                     if (parent is not null)
                     {
-                        keys.Add(parent);
+                        Track(keys, parent);
                     }
                 }
+
+                // A window long enough to cover a burst still has to give way once the batch is
+                // large enough to be worth sending on its own.
+                if (_changedItemCount >= MaxBatchSize)
+                {
+                    _updateTimer.Change(0, Timeout.Infinite);
+                }
+            }
+        }
+
+        private void Track(Dictionary<Guid, BaseItem> keys, BaseItem item)
+        {
+            var before = keys.Count;
+            keys[item.Id] = item;
+
+            if (keys.Count != before)
+            {
+                _changedItemCount++;
             }
         }
 
         private async void UpdateTimerCallback(object? state)
         {
-            List<KeyValuePair<Guid, List<BaseItem>>> changes;
+            List<KeyValuePair<Guid, Dictionary<Guid, BaseItem>>> changes;
             lock (_syncLock)
             {
-                // Remove dupes in case some were saved multiple times
                 changes = _changedItems.ToList();
                 _changedItems.Clear();
+                _changedItemCount = 0;
 
                 if (_updateTimer is not null)
                 {
@@ -121,17 +137,22 @@ namespace Emby.Server.Implementations.EntryPoints
                 }
             }
 
+            if (changes.Count == 0)
+            {
+                return;
+            }
+
             foreach (var (userId, changedItems) in changes)
             {
                 await _sessionManager.SendMessageToUserSessions(
                     [userId],
                     SessionMessageType.UserDataChanged,
-                    () => GetUserDataChangeInfo(userId, changedItems),
+                    () => GetUserDataChangeInfo(userId, changedItems.Values),
                     default).ConfigureAwait(false);
             }
         }
 
-        private UserDataChangeInfo GetUserDataChangeInfo(Guid userId, List<BaseItem> changedItems)
+        private UserDataChangeInfo GetUserDataChangeInfo(Guid userId, IEnumerable<BaseItem> changedItems)
         {
             var user = _userManager.GetUserById(userId)
                 ?? throw new ArgumentException("Invalid user ID", nameof(userId));
@@ -140,7 +161,6 @@ namespace Emby.Server.Implementations.EntryPoints
             {
                 UserId = userId,
                 UserDataList = changedItems
-                    .DistinctBy(x => x.Id)
                     .Select(i =>
                     {
                         var dto = _userDataManager.GetUserDataDto(i, user);

Emby.Server.Implementations/HttpServer/WebSocketConnection.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Buffers;
+using System.Globalization;
 using System.IO.Pipelines;
 using System.Net;
 using System.Net.WebSockets;
@@ -69,6 +70,11 @@ namespace Emby.Server.Implementations.HttpServer
         /// <inheritdoc />
         public IPAddress? RemoteEndPoint { get; }
 
+        /// <summary>
+        /// Gets or initializes the UI culture captured from the upgrade request.
+        /// </summary>
+        public CultureInfo? RequestUICulture { get; init; }
+
         /// <inheritdoc />
         public Func<WebSocketMessageInfo, Task>? OnReceive { get; set; }
 
@@ -81,6 +87,17 @@ namespace Emby.Server.Implementations.HttpServer
         /// <inheritdoc />
         public WebSocketState State => _socket.State;
 
+        /// <inheritdoc />
+        public void ApplyRequestCulture()
+        {
+            if (RequestUICulture is null)
+            {
+                return;
+            }
+
+            CultureInfo.CurrentUICulture = RequestUICulture;
+        }
+
         /// <inheritdoc />
         public async Task SendAsync(OutboundWebSocketMessage message, CancellationToken cancellationToken)
         {
@@ -110,8 +127,12 @@ namespace Emby.Server.Implementations.HttpServer
                 {
                     receiveResult = await _socket.ReceiveAsync(memory, cancellationToken).ConfigureAwait(false);
                 }
-                catch (WebSocketException ex)
+                catch (Exception ex) when (ex is WebSocketException or ObjectDisposedException or OperationCanceledException)
                 {
+                    // ObjectDisposedException/OperationCanceledException: the socket was torn
+                    // down underneath us (e.g. by the keep-alive watchdog after the connection
+                    // was declared lost). Fall through so Closed is still raised and the
+                    // session can release this connection.
                     _logger.LogWarning("WS {IP} error receiving data: {Message}", RemoteEndPoint, ex.Message);
                     break;
                 }

Emby.Server.Implementations/HttpServer/WebSocketManager.cs

@@ -4,6 +4,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Globalization;
 using System.Linq;
 using System.Net.WebSockets;
 using System.Threading.Tasks;
@@ -47,14 +48,18 @@ namespace Emby.Server.Implementations.HttpServer
                 _logger.LogInformation("WS {IP} request", context.Connection.RemoteIpAddress);
 
                 WebSocket webSocket = await context.WebSockets.AcceptWebSocketAsync().ConfigureAwait(false);
-
                 var connection = new WebSocketConnection(
                     _loggerFactory.CreateLogger<WebSocketConnection>(),
                     webSocket,
                     authorizationInfo,
                     context.GetNormalizedRemoteIP())
                 {
-                    OnReceive = ProcessWebSocketMessageReceived
+                    RequestUICulture = CultureInfo.CurrentUICulture
+                };
+                connection.OnReceive = result =>
+                {
+                    connection.ApplyRequestCulture();
+                    return ProcessWebSocketMessageReceived(result);
                 };
                 await using (connection.ConfigureAwait(false))
                 {

Emby.Server.Implementations/IO/LibraryMonitor.cs

@@ -8,6 +8,7 @@ using Emby.Server.Implementations.Library;
 using MediaBrowser.Controller.Configuration;
 using MediaBrowser.Controller.Entities;
 using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Providers;
 using MediaBrowser.Model.IO;
 using Microsoft.Extensions.Hosting;
 using Microsoft.Extensions.Logging;
@@ -21,6 +22,8 @@ namespace Emby.Server.Implementations.IO
         private readonly ILibraryManager _libraryManager;
         private readonly IServerConfigurationManager _configurationManager;
         private readonly IFileSystem _fileSystem;
+        private readonly IDirectoryService _directoryService;
+        private readonly DotIgnoreIgnoreRule _dotIgnoreIgnoreRule;
 
         /// <summary>
         /// The file system watchers.
@@ -46,20 +49,27 @@ namespace Emby.Server.Implementations.IO
         /// <param name="libraryManager">The library manager.</param>
         /// <param name="configurationManager">The configuration manager.</param>
         /// <param name="fileSystem">The filesystem.</param>
+        /// <param name="directoryService">The directory service.</param>
         /// <param name="appLifetime">The <see cref="IHostApplicationLifetime"/>.</param>
+        /// <param name="dotIgnoreIgnoreRule">The .ignore rule handler.</param>
         public LibraryMonitor(
             ILogger<LibraryMonitor> logger,
             ILibraryManager libraryManager,
             IServerConfigurationManager configurationManager,
             IFileSystem fileSystem,
-            IHostApplicationLifetime appLifetime)
+            IDirectoryService directoryService,
+            IHostApplicationLifetime appLifetime,
+            DotIgnoreIgnoreRule dotIgnoreIgnoreRule)
         {
             _libraryManager = libraryManager;
             _logger = logger;
             _configurationManager = configurationManager;
             _fileSystem = fileSystem;
+            _directoryService = directoryService;
+            _dotIgnoreIgnoreRule = dotIgnoreIgnoreRule;
 
             appLifetime.ApplicationStarted.Register(Start);
+            appLifetime.ApplicationStopping.Register(Stop);
         }
 
         /// <inheritdoc />
@@ -352,6 +362,14 @@ namespace Emby.Server.Implementations.IO
                 return;
             }
 
+            var fileInfo = _fileSystem.GetFileSystemInfo(path);
+            if (_dotIgnoreIgnoreRule.ShouldIgnore(fileInfo, null))
+            {
+                return;
+            }
+
+            _directoryService.Invalidate(path);
+
             // Ignore certain files, If the parent of an ignored path has a change event, ignore that too
             foreach (var i in _tempIgnoredPaths.Keys)
             {

Emby.Server.Implementations/IO/ManagedFileSystem.cs

@@ -6,6 +6,7 @@ using System.Linq;
 using System.Security;
 using Jellyfin.Extensions;
 using MediaBrowser.Common.Configuration;
+using MediaBrowser.Controller.IO;
 using MediaBrowser.Model.IO;
 using Microsoft.Extensions.Logging;
 
@@ -152,6 +153,10 @@ namespace Emby.Server.Implementations.IO
         /// <inheritdoc />
         public void MoveDirectory(string source, string destination)
         {
+            // Make sure parent directory of target exists
+            var parent = Directory.GetParent(destination);
+            parent?.Create();
+
             try
             {
                 Directory.Move(source, destination);
@@ -248,47 +253,40 @@ namespace Emby.Server.Implementations.IO
             {
                 result.IsDirectory = info is DirectoryInfo || (info.Attributes & FileAttributes.Directory) == FileAttributes.Directory;
 
-                // if (!result.IsDirectory)
-                // {
-                //    result.IsHidden = (info.Attributes & FileAttributes.Hidden) == FileAttributes.Hidden;
-                // }
-
                 if (info is FileInfo fileInfo)
                 {
-                    result.Length = fileInfo.Length;
-
-                    // Issue #2354 get the size of files behind symbolic links. Also Enum.HasFlag is bad as it boxes!
-                    if ((fileInfo.Attributes & FileAttributes.ReparsePoint) == FileAttributes.ReparsePoint)
+                    result.CreationTimeUtc = GetCreationTimeUtc(info);
+                    result.LastWriteTimeUtc = GetLastWriteTimeUtc(info);
+                    if (fileInfo.LinkTarget is not null)
                     {
                         try
                         {
-                            using (var fileHandle = File.OpenHandle(fileInfo.FullName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
+                            var targetFileInfo = FileSystemHelper.ResolveLinkTarget(fileInfo, returnFinalTarget: true);
+                            if (targetFileInfo is not null)
                             {
-                                result.Length = RandomAccess.GetLength(fileHandle);
+                                result.Exists = targetFileInfo.Exists;
+                                if (result.Exists)
+                                {
+                                    result.Length = targetFileInfo.Length;
+                                    result.CreationTimeUtc = GetCreationTimeUtc(targetFileInfo);
+                                    result.LastWriteTimeUtc = GetLastWriteTimeUtc(targetFileInfo);
+                                }
+                            }
+                            else
+                            {
+                                result.Exists = false;
                             }
-                        }
-                        catch (FileNotFoundException ex)
-                        {
-                            // Dangling symlinks cannot be detected before opening the file unfortunately...
-                            _logger.LogError(ex, "Reading the file size of the symlink at {Path} failed. Marking the file as not existing.", fileInfo.FullName);
-                            result.Exists = false;
                         }
                         catch (UnauthorizedAccessException ex)
                         {
                             _logger.LogError(ex, "Reading the file at {Path} failed due to a permissions exception.", fileInfo.FullName);
                         }
-                        catch (IOException ex)
-                        {
-                            // IOException generally means the file is not accessible due to filesystem issues
-                            // Catch this exception and mark the file as not exist to ignore it
-                            _logger.LogError(ex, "Reading the file at {Path} failed due to an IO Exception. Marking the file as not existing", fileInfo.FullName);
-                            result.Exists = false;
-                        }
+                    }
+                    else
+                    {
+                        result.Length = fileInfo.Length;
                     }
                 }
-
-                result.CreationTimeUtc = GetCreationTimeUtc(info);
-                result.LastWriteTimeUtc = GetLastWriteTimeUtc(info);
             }
             else
             {
@@ -499,8 +497,17 @@ namespace Emby.Server.Implementations.IO
         /// <inheritdoc />
         public virtual bool AreEqual(string path1, string path2)
         {
-            return Path.TrimEndingDirectorySeparator(path1).Equals(
-                Path.TrimEndingDirectorySeparator(path2),
+            if (string.IsNullOrWhiteSpace(path1) || string.IsNullOrWhiteSpace(path2))
+            {
+                return false;
+            }
+
+            var normalized1 = Path.TrimEndingDirectorySeparator(path1);
+            var normalized2 = Path.TrimEndingDirectorySeparator(path2);
+
+            return string.Equals(
+                normalized1,
+                normalized2,
                 _isEnvironmentCaseInsensitive ? StringComparison.OrdinalIgnoreCase : StringComparison.Ordinal);
         }
 
@@ -579,6 +586,12 @@ namespace Emby.Server.Implementations.IO
         /// <inheritdoc />
         public virtual IEnumerable<FileSystemMetadata> GetFiles(string path, string searchPattern, IReadOnlyList<string>? extensions, bool enableCaseSensitiveExtensions, bool recursive = false)
         {
+            if (!Directory.Exists(path))
+            {
+                _logger.LogWarning("Directory does not exist: {Path}", path);
+                return [];
+            }
+
             var enumerationOptions = GetEnumerationOptions(recursive);
 
             // On linux and macOS the search pattern is case-sensitive
@@ -678,7 +691,7 @@ namespace Emby.Server.Implementations.IO
             }
             catch (Exception ex) when (ex is UnauthorizedAccessException or DirectoryNotFoundException or SecurityException)
             {
-                _logger.LogError(ex, "Failed to enumerate path {Path}", path);
+                _logger.LogWarning("Failed to enumerate path \"{Path}\": {Message}", path, ex.Message);
                 return Enumerable.Empty<string>();
             }
         }

Emby.Server.Implementations/Images/BaseDynamicImageProvider.cs

@@ -267,22 +267,24 @@ namespace Emby.Server.Implementations.Images
         {
             var image = item.GetImageInfo(type, 0);
 
-            if (image is not null)
+            if (image is null)
             {
-                if (!image.IsLocalFile)
-                {
-                    return false;
-                }
+                return GetItemsWithImages(item).Count is not 0;
+            }
 
-                if (!FileSystem.ContainsSubPath(item.GetInternalMetadataPath(), image.Path))
-                {
-                    return false;
-                }
+            if (!image.IsLocalFile)
+            {
+                return false;
+            }
 
-                if (!HasChangedByDate(item, image))
-                {
-                    return false;
-                }
+            if (!FileSystem.ContainsSubPath(item.GetInternalMetadataPath(), image.Path))
+            {
+                return false;
+            }
+
+            if (!HasChangedByDate(item, image))
+            {
+                return false;
             }
 
             return true;

Emby.Server.Implementations/Images/CollectionFolderImageProvider.cs

@@ -5,6 +5,7 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
+using Jellyfin.Api.Extensions;
 using Jellyfin.Data.Enums;
 using Jellyfin.Database.Implementations.Enums;
 using MediaBrowser.Common.Configuration;
@@ -14,7 +15,6 @@ using MediaBrowser.Controller.Entities;
 using MediaBrowser.Controller.Providers;
 using MediaBrowser.Model.Entities;
 using MediaBrowser.Model.IO;
-using MediaBrowser.Model.Querying;
 
 namespace Emby.Server.Implementations.Images
 {
@@ -28,51 +28,23 @@ namespace Emby.Server.Implementations.Images
         {
             var view = (CollectionFolder)item;
             var viewType = view.CollectionType;
-
-            BaseItemKind[] includeItemTypes;
-
-            switch (viewType)
-            {
-                case CollectionType.movies:
-                    includeItemTypes = new[] { BaseItemKind.Movie };
-                    break;
-                case CollectionType.tvshows:
-                    includeItemTypes = new[] { BaseItemKind.Series };
-                    break;
-                case CollectionType.music:
-                    includeItemTypes = new[] { BaseItemKind.MusicAlbum };
-                    break;
-                case CollectionType.musicvideos:
-                    includeItemTypes = new[] { BaseItemKind.MusicVideo };
-                    break;
-                case CollectionType.books:
-                    includeItemTypes = new[] { BaseItemKind.Book, BaseItemKind.AudioBook };
-                    break;
-                case CollectionType.boxsets:
-                    includeItemTypes = new[] { BaseItemKind.BoxSet };
-                    break;
-                case CollectionType.homevideos:
-                case CollectionType.photos:
-                    includeItemTypes = new[] { BaseItemKind.Video, BaseItemKind.Photo };
-                    break;
-                default:
-                    includeItemTypes = new[] { BaseItemKind.Video, BaseItemKind.Audio, BaseItemKind.Photo, BaseItemKind.Movie, BaseItemKind.Series };
-                    break;
-            }
-
+            var includeItemTypes = DtoExtensions.GetBaseItemKindsForCollectionType(viewType);
             var recursive = viewType != CollectionType.playlists;
 
+            if (viewType == CollectionType.music)
+            {
+                // Music albums usually don't have dedicated backdrops, so use artist instead
+                includeItemTypes = [BaseItemKind.MusicArtist];
+            }
+
             return view.GetItemList(new InternalItemsQuery
             {
                 CollapseBoxSetItems = false,
                 Recursive = recursive,
                 DtoOptions = new DtoOptions(false),
-                ImageTypes = new[] { ImageType.Primary },
+                ImageTypes = [ImageType.Primary],
                 Limit = 8,
-                OrderBy = new[]
-                {
-                    (ItemSortBy.Random, SortOrder.Ascending)
-                },
+                OrderBy = [(ItemSortBy.Random, SortOrder.Ascending)],
                 IncludeItemTypes = includeItemTypes
             });
         }
@@ -98,5 +70,11 @@ namespace Emby.Server.Implementations.Images
 
             return base.CreateImage(item, itemsWithImages, outputPath, imageType, imageIndex);
         }
+
+        protected override bool HasChangedByDate(BaseItem item, ItemImageInfo image)
+        {
+            var age = DateTime.UtcNow - image.DateModified;
+            return age.TotalDays > 7;
+        }
     }
 }

Emby.Server.Implementations/Library/DotIgnoreIgnoreRule.cs

@@ -1,6 +1,10 @@
 using System;
+using System.Collections.Generic;
 using System.IO;
+using System.Text.RegularExpressions;
+using BitFaster.Caching.Lru;
 using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.IO;
 using MediaBrowser.Controller.Resolvers;
 using MediaBrowser.Model.IO;
 
@@ -11,27 +15,37 @@ namespace Emby.Server.Implementations.Library;
 /// </summary>
 public class DotIgnoreIgnoreRule : IResolverIgnoreRule
 {
-    private static FileInfo? FindIgnoreFile(DirectoryInfo directory)
+    private static readonly bool IsWindows = OperatingSystem.IsWindows();
+
+    private readonly FastConcurrentLru<string, IgnoreFileCacheEntry> _directoryCache;
+    private readonly FastConcurrentLru<string, ParsedIgnoreCacheEntry> _rulesCache;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="DotIgnoreIgnoreRule"/> class.
+    /// </summary>
+    public DotIgnoreIgnoreRule()
     {
-        var ignoreFile = new FileInfo(Path.Join(directory.FullName, ".ignore"));
-        if (ignoreFile.Exists)
-        {
-            return ignoreFile;
-        }
-
-        var parentDir = directory.Parent;
-        if (parentDir is null)
-        {
-            return null;
-        }
-
-        return FindIgnoreFile(parentDir);
+        var cacheSize = Math.Max(100, Environment.ProcessorCount * 100);
+        _directoryCache = new FastConcurrentLru<string, IgnoreFileCacheEntry>(
+            Environment.ProcessorCount,
+            cacheSize,
+            StringComparer.Ordinal);
+        _rulesCache = new FastConcurrentLru<string, ParsedIgnoreCacheEntry>(
+            Environment.ProcessorCount,
+            Math.Max(32, cacheSize / 4),
+            StringComparer.Ordinal);
     }
 
     /// <inheritdoc />
-    public bool ShouldIgnore(FileSystemMetadata fileInfo, BaseItem? parent)
+    public bool ShouldIgnore(FileSystemMetadata fileInfo, BaseItem? parent) => IsIgnoredInternal(fileInfo, parent);
+
+    /// <summary>
+    /// Clears the directory lookup cache. The parsed rules cache is not cleared
+    /// as it validates file modification time on each access.
+    /// </summary>
+    public void ClearDirectoryCache()
     {
-        return IsIgnored(fileInfo, parent);
+        _directoryCache.Clear();
     }
 
     /// <summary>
@@ -40,62 +54,286 @@ public class DotIgnoreIgnoreRule : IResolverIgnoreRule
     /// <param name="fileInfo">The file information.</param>
     /// <param name="parent">The parent BaseItem.</param>
     /// <returns>True if the file should be ignored.</returns>
-    public static bool IsIgnored(FileSystemMetadata fileInfo, BaseItem? parent)
+    public bool IsIgnoredInternal(FileSystemMetadata fileInfo, BaseItem? parent)
     {
-        if (fileInfo.IsDirectory)
-        {
-            var dirIgnoreFile = FindIgnoreFile(new DirectoryInfo(fileInfo.FullName));
-            if (dirIgnoreFile is null)
-            {
-                return false;
-            }
+        var searchDirectory = fileInfo.IsDirectory
+            ? fileInfo.FullName
+            : Path.GetDirectoryName(fileInfo.FullName);
 
-            // Fast path in case the ignore files isn't a symlink and is empty
-            if ((dirIgnoreFile.Attributes & FileAttributes.ReparsePoint) == 0
-                && dirIgnoreFile.Length == 0)
-            {
-                return true;
-            }
-
-            // ignore the directory only if the .ignore file is empty
-            // evaluate individual files otherwise
-            return string.IsNullOrWhiteSpace(GetFileContent(dirIgnoreFile));
-        }
-
-        var parentDirPath = Path.GetDirectoryName(fileInfo.FullName);
-        if (string.IsNullOrEmpty(parentDirPath))
+        if (string.IsNullOrEmpty(searchDirectory))
         {
             return false;
         }
 
-        var folder = new DirectoryInfo(parentDirPath);
-        var ignoreFile = FindIgnoreFile(folder);
+        var ignoreFile = FindIgnoreFileCached(searchDirectory);
         if (ignoreFile is null)
         {
             return false;
         }
 
-        string ignoreFileString = GetFileContent(ignoreFile);
-
-        if (string.IsNullOrWhiteSpace(ignoreFileString))
+        var parsedEntry = GetParsedRules(ignoreFile);
+        if (parsedEntry is null)
+        {
+            // File was deleted after we cached the path - clear the directory cache entry and return false
+            _directoryCache.TryRemove(searchDirectory, out _);
+            return false;
+        }
+
+        // Empty file means ignore everything
+        if (parsedEntry.IsEmpty)
         {
-            // Ignore directory if we just have the file
             return true;
         }
 
-        // If file has content, base ignoring off the content .gitignore-style rules
-        var ignoreRules = ignoreFileString.Split('\n', StringSplitOptions.RemoveEmptyEntries);
-        var ignore = new Ignore.Ignore();
-        ignore.Add(ignoreRules);
-
-        return ignore.IsIgnored(fileInfo.FullName);
+        return parsedEntry.Rules.IsIgnored(GetPathToCheck(fileInfo.FullName, fileInfo.IsDirectory));
     }
 
-    private static string GetFileContent(FileInfo dirIgnoreFile)
+    /// <summary>
+    /// Checks whether a path should be ignored based on an array of ignore rules.
+    /// </summary>
+    /// <param name="path">The path to check.</param>
+    /// <param name="rules">The array of ignore rules.</param>
+    /// <param name="isDirectory">Whether the path is a directory.</param>
+    /// <returns>True if the path should be ignored.</returns>
+    internal static bool CheckIgnoreRules(string path, string[] rules, bool isDirectory)
+        => CheckIgnoreRules(path, rules, isDirectory, IsWindows);
+
+    /// <summary>
+    /// Checks whether a path should be ignored based on an array of ignore rules.
+    /// </summary>
+    /// <param name="path">The path to check.</param>
+    /// <param name="rules">The array of ignore rules.</param>
+    /// <param name="isDirectory">Whether the path is a directory.</param>
+    /// <param name="normalizePath">Whether to normalize backslashes to forward slashes (for Windows paths).</param>
+    /// <returns>True if the path should be ignored.</returns>
+    internal static bool CheckIgnoreRules(string path, string[] rules, bool isDirectory, bool normalizePath)
     {
-        using (var reader = dirIgnoreFile.OpenText())
+        var ignore = new Ignore.Ignore();
+
+        // Add each rule individually to catch and skip invalid patterns
+        var validRulesAdded = 0;
+        foreach (var rule in rules)
         {
-            return reader.ReadToEnd();
+            try
+            {
+                ignore.Add(rule);
+                validRulesAdded++;
+            }
+            catch (RegexParseException)
+            {
+                // Ignore invalid patterns
+            }
         }
+
+        // If no valid rules were added, fall back to ignoring everything (like an empty .ignore file)
+        if (validRulesAdded == 0)
+        {
+            return true;
+        }
+
+        // Mitigate the problem of the Ignore library not handling Windows paths correctly.
+        // See https://github.com/jellyfin/jellyfin/issues/15484
+        var pathToCheck = normalizePath ? path.NormalizePath('/') : path;
+
+        // Add trailing slash for directories to match "folder/"
+        if (isDirectory)
+        {
+            pathToCheck = string.Concat(pathToCheck.AsSpan().TrimEnd('/'), "/");
+        }
+
+        return ignore.IsIgnored(pathToCheck);
+    }
+
+    private FileInfo? FindIgnoreFileCached(string directory)
+    {
+        // Check if we have a cached result for this directory
+        if (_directoryCache.TryGet(directory, out var cached))
+        {
+            return cached.IgnoreFileDirectory is null
+                ? null
+                : new FileInfo(Path.Join(cached.IgnoreFileDirectory, ".ignore"));
+        }
+
+        DirectoryInfo startDir;
+        try
+        {
+            startDir = new DirectoryInfo(directory);
+        }
+        catch (ArgumentException)
+        {
+            return null;
+        }
+
+        // Walk up the directory tree to find .ignore file using DirectoryInfo.Parent
+        var checkedDirs = new List<string> { directory };
+
+        for (var current = startDir; current is not null; current = current.Parent)
+        {
+            var currentPath = current.FullName;
+
+            // Check if this intermediate directory is cached
+            if (current != startDir && _directoryCache.TryGet(currentPath, out var parentCached))
+            {
+                // Cache the result for all directories we checked
+                var entry = new IgnoreFileCacheEntry(parentCached.IgnoreFileDirectory);
+                foreach (var dir in checkedDirs)
+                {
+                    _directoryCache.AddOrUpdate(dir, entry);
+                }
+
+                return parentCached.IgnoreFileDirectory is null
+                    ? null
+                    : new FileInfo(Path.Join(parentCached.IgnoreFileDirectory, ".ignore"));
+            }
+
+            var ignoreFile = new FileInfo(Path.Join(currentPath, ".ignore"));
+            if (ignoreFile.Exists)
+            {
+                // Cache for all directories we checked
+                var entry = new IgnoreFileCacheEntry(currentPath);
+                foreach (var dir in checkedDirs)
+                {
+                    _directoryCache.AddOrUpdate(dir, entry);
+                }
+
+                return ignoreFile;
+            }
+
+            if (current != startDir)
+            {
+                checkedDirs.Add(currentPath);
+            }
+        }
+
+        // No .ignore file found - cache null result for all directories
+        var nullEntry = new IgnoreFileCacheEntry((string?)null);
+        foreach (var dir in checkedDirs)
+        {
+            _directoryCache.AddOrUpdate(dir, nullEntry);
+        }
+
+        return null;
+    }
+
+    private ParsedIgnoreCacheEntry? GetParsedRules(FileInfo ignoreFile)
+    {
+        if (!ignoreFile.Exists)
+        {
+            _rulesCache.TryRemove(ignoreFile.FullName, out _);
+            return null;
+        }
+
+        var lastModified = ignoreFile.LastWriteTimeUtc;
+        var fileLength = ignoreFile.Length;
+        var key = ignoreFile.FullName;
+
+        // Check cache
+        if (_rulesCache.TryGet(key, out var cached))
+        {
+            if (cached.FileLastModified == lastModified && cached.FileLength == fileLength)
+            {
+                return cached;
+            }
+
+            // Stale - need to reparse
+            _rulesCache.TryRemove(key, out _);
+        }
+
+        // Parse the file
+        var parsedEntry = ParseIgnoreFile(ignoreFile, lastModified, fileLength);
+        _rulesCache.AddOrUpdate(key, parsedEntry);
+        return parsedEntry;
+    }
+
+    private static ParsedIgnoreCacheEntry ParseIgnoreFile(FileInfo ignoreFile, DateTime lastModified, long fileLength)
+    {
+        if (ignoreFile.LinkTarget is null && fileLength == 0)
+        {
+            return new ParsedIgnoreCacheEntry
+            {
+                Rules = new Ignore.Ignore(),
+                FileLastModified = lastModified,
+                FileLength = fileLength,
+                IsEmpty = true
+            };
+        }
+
+        // Resolve symlinks
+        var resolvedFile = FileSystemHelper.ResolveLinkTarget(ignoreFile, returnFinalTarget: true) ?? ignoreFile;
+        if (!resolvedFile.Exists)
+        {
+            return new ParsedIgnoreCacheEntry
+            {
+                Rules = new Ignore.Ignore(),
+                FileLastModified = lastModified,
+                FileLength = fileLength,
+                IsEmpty = true
+            };
+        }
+
+        var content = File.ReadAllText(resolvedFile.FullName);
+        if (string.IsNullOrWhiteSpace(content))
+        {
+            return new ParsedIgnoreCacheEntry
+            {
+                Rules = new Ignore.Ignore(),
+                FileLastModified = lastModified,
+                FileLength = fileLength,
+                IsEmpty = true
+            };
+        }
+
+        var rules = content.Split('\n', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
+        var ignore = new Ignore.Ignore();
+        var validRulesAdded = 0;
+
+        foreach (var rule in rules)
+        {
+            try
+            {
+                ignore.Add(rule);
+                validRulesAdded++;
+            }
+            catch (RegexParseException)
+            {
+                // Ignore invalid patterns
+            }
+        }
+
+        // No valid rules means treat as empty (ignore all)
+        return new ParsedIgnoreCacheEntry
+        {
+            Rules = ignore,
+            FileLastModified = lastModified,
+            FileLength = fileLength,
+            IsEmpty = validRulesAdded == 0
+        };
+    }
+
+    private static string GetPathToCheck(string path, bool isDirectory)
+    {
+        // Normalize Windows paths
+        var pathToCheck = IsWindows ? path.NormalizePath('/') : path;
+
+        // Add trailing slash for directories to match "folder/"
+        if (isDirectory)
+        {
+            pathToCheck = string.Concat(pathToCheck.AsSpan().TrimEnd('/'), "/");
+        }
+
+        return pathToCheck;
+    }
+
+    private readonly record struct IgnoreFileCacheEntry(string? IgnoreFileDirectory);
+
+    private sealed class ParsedIgnoreCacheEntry
+    {
+        public required Ignore.Ignore Rules { get; init; }
+
+        public required DateTime FileLastModified { get; init; }
+
+        public required long FileLength { get; init; }
+
+        public required bool IsEmpty { get; init; }
     }
 }

Emby.Server.Implementations/Library/ExternalDataManager.cs

@@ -1,8 +1,8 @@
 using System;
 using System.IO;
-using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
+using MediaBrowser.Controller.Chapters;
 using MediaBrowser.Controller.Entities;
 using MediaBrowser.Controller.IO;
 using MediaBrowser.Controller.MediaSegments;
@@ -20,6 +20,7 @@ public class ExternalDataManager : IExternalDataManager
     private readonly IMediaSegmentManager _mediaSegmentManager;
     private readonly IPathManager _pathManager;
     private readonly ITrickplayManager _trickplayManager;
+    private readonly IChapterManager _chapterManager;
     private readonly ILogger<ExternalDataManager> _logger;
 
     /// <summary>
@@ -29,43 +30,54 @@ public class ExternalDataManager : IExternalDataManager
     /// <param name="mediaSegmentManager">The media segment manager.</param>
     /// <param name="pathManager">The path manager.</param>
     /// <param name="trickplayManager">The trickplay manager.</param>
+    /// <param name="chapterManager">The chapter manager.</param>
     /// <param name="logger">The logger.</param>
     public ExternalDataManager(
         IKeyframeManager keyframeManager,
         IMediaSegmentManager mediaSegmentManager,
         IPathManager pathManager,
         ITrickplayManager trickplayManager,
+        IChapterManager chapterManager,
         ILogger<ExternalDataManager> logger)
     {
         _keyframeManager = keyframeManager;
         _mediaSegmentManager = mediaSegmentManager;
         _pathManager = pathManager;
         _trickplayManager = trickplayManager;
+        _chapterManager = chapterManager;
         _logger = logger;
     }
 
     /// <inheritdoc/>
     public async Task DeleteExternalItemDataAsync(BaseItem item, CancellationToken cancellationToken)
     {
-        var validPaths = _pathManager.GetExtractedDataPaths(item).Where(Directory.Exists).ToList();
-        var itemId = item.Id;
-        if (validPaths.Count > 0)
-        {
-            foreach (var path in validPaths)
-            {
-                try
-                {
-                    Directory.Delete(path, true);
-                }
-                catch (Exception ex)
-                {
-                    _logger.LogWarning("Unable to prune external item data at {Path}: {Exception}", path, ex);
-                }
-            }
-        }
+        DeleteExternalItemFiles(item);
 
+        var itemId = item.Id;
         await _keyframeManager.DeleteKeyframeDataAsync(itemId, cancellationToken).ConfigureAwait(false);
         await _mediaSegmentManager.DeleteSegmentsAsync(itemId, cancellationToken).ConfigureAwait(false);
         await _trickplayManager.DeleteTrickplayDataAsync(itemId, cancellationToken).ConfigureAwait(false);
+        await _chapterManager.DeleteChapterDataAsync(itemId, cancellationToken).ConfigureAwait(false);
+    }
+
+    /// <inheritdoc/>
+    public void DeleteExternalItemFiles(BaseItem item)
+    {
+        foreach (var path in _pathManager.GetExtractedDataPaths(item))
+        {
+            if (!Directory.Exists(path))
+            {
+                continue;
+            }
+
+            try
+            {
+                Directory.Delete(path, true);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogWarning("Unable to prune external item data at {Path}: {Exception}", path, ex);
+            }
+        }
     }
 }

Emby.Server.Implementations/Library/IgnorePatterns.cs

@@ -31,6 +31,20 @@ namespace Emby.Server.Implementations.Library
             "**/*.sample.?????",
             "**/sample/*",
 
+            // Avoid adding Hungarian sample files
+            // https://github.com/jellyfin/jellyfin/issues/16237
+            "**/minta.?",
+            "**/minta.??",
+            "**/minta.???", // Matches minta.mkv
+            "**/minta.????", // Matches minta.webm
+            "**/minta.?????",
+            "**/*.minta.?",
+            "**/*.minta.??",
+            "**/*.minta.???",
+            "**/*.minta.????",
+            "**/*.minta.?????",
+            "**/minta/*",
+
             // Directories
             "**/metadata/**",
             "**/metadata",
@@ -50,6 +64,10 @@ namespace Emby.Server.Implementations.Library
             "**/lost+found",
             "**/subs/**",
             "**/subs",
+            "**/.snapshots/**",
+            "**/.snapshots",
+            "**/.snapshot/**",
+            "**/.snapshot",
 
             // Trickplay files
             "**/*.trickplay",

Emby.Server.Implementations/Library/MediaSourceManager.cs

@@ -23,6 +23,8 @@ using MediaBrowser.Common.Configuration;
 using MediaBrowser.Common.Extensions;
 using MediaBrowser.Controller;
 using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Entities.TV;
+using MediaBrowser.Controller.IO;
 using MediaBrowser.Controller.Library;
 using MediaBrowser.Controller.LiveTv;
 using MediaBrowser.Controller.MediaEncoding;
@@ -126,6 +128,11 @@ namespace Emby.Server.Implementations.Library
                 return true;
             }
 
+            if (stream.IsVobSubSubtitleStream)
+            {
+                return true;
+            }
+
             return false;
         }
 
@@ -170,6 +177,7 @@ namespace Emby.Server.Implementations.Library
         public async Task<IReadOnlyList<MediaSourceInfo>> GetPlaybackMediaSources(BaseItem item, User user, bool allowMediaProbe, bool enablePathSubstitution, CancellationToken cancellationToken)
         {
             var mediaSources = GetStaticMediaSources(item, enablePathSubstitution, user);
+            ResolveSymlinkPaths(mediaSources, enablePathSubstitution);
 
             // If file is strm or main media stream is missing, force a metadata refresh with remote probing
             if (allowMediaProbe && mediaSources[0].Type != MediaSourceType.Placeholder
@@ -186,6 +194,7 @@ namespace Emby.Server.Implementations.Library
                     cancellationToken).ConfigureAwait(false);
 
                 mediaSources = GetStaticMediaSources(item, enablePathSubstitution, user);
+                ResolveSymlinkPaths(mediaSources, enablePathSubstitution);
             }
 
             var dynamicMediaSources = await GetDynamicMediaSources(item, cancellationToken).ConfigureAwait(false);
@@ -220,12 +229,21 @@ namespace Emby.Server.Implementations.Library
                 list.Add(source);
             }
 
-            return SortMediaSources(list).ToArray();
+            var preferredId = mediaSources.Count > 0 && Guid.TryParse(mediaSources[0].Id, out var topSourceId)
+                ? topSourceId
+                : item.Id;
+
+            return SortMediaSources(list, preferredId).ToArray();
         }
 
         /// <inheritdoc />>
         public MediaProtocol GetPathProtocol(string path)
         {
+            if (string.IsNullOrEmpty(path))
+            {
+                return MediaProtocol.File;
+            }
+
             if (path.StartsWith("Rtsp", StringComparison.OrdinalIgnoreCase))
             {
                 return MediaProtocol.Rtsp;
@@ -313,6 +331,28 @@ namespace Emby.Server.Implementations.Library
             }
         }
 
+        /// <summary>
+        /// Resolves symlinked file paths on the supplied sources to the real on-disk target.
+        /// Skipped when <paramref name="enablePathSubstitution"/> is set because the path may
+        /// already have been rewritten to a UNC/URL meant for the client to consume directly.
+        /// </summary>
+        private static void ResolveSymlinkPaths(IReadOnlyList<MediaSourceInfo> sources, bool enablePathSubstitution)
+        {
+            if (enablePathSubstitution)
+            {
+                return;
+            }
+
+            foreach (var source in sources)
+            {
+                if (source.Protocol == MediaProtocol.File
+                    && FileSystemHelper.ResolveLinkTarget(source.Path, returnFinalTarget: true) is { Exists: true } target)
+                {
+                    source.Path = target.FullName;
+                }
+            }
+        }
+
         private static void SetKeyProperties(IMediaSourceProvider provider, MediaSourceInfo mediaSource)
         {
             var prefix = provider.GetType().FullName.GetMD5().ToString("N", CultureInfo.InvariantCulture) + LiveStreamIdDelimiter;
@@ -350,6 +390,12 @@ namespace Emby.Server.Implementations.Library
 
             if (user is not null)
             {
+                sources = sources
+                    .Where(source => !Guid.TryParse(source.Id, out var sourceId)
+                        || sourceId.Equals(item.Id)
+                        || _libraryManager.GetItemById<BaseItem>(sourceId, user) is not null)
+                    .ToArray();
+
                 foreach (var source in sources)
                 {
                     SetDefaultAudioAndSubtitleStreamIndices(item, source, user);
@@ -364,6 +410,59 @@ namespace Emby.Server.Implementations.Library
                         source.SupportsDirectStream = user.HasPermission(PermissionKind.EnablePlaybackRemuxing);
                     }
                 }
+
+                sources = SetAlternateVersionResumeStates(item, sources, user);
+            }
+
+            return sources;
+        }
+
+        /// <summary>
+        /// When the queried item is a primary, moves the most recently played version to the front so
+        /// that resuming without an explicit source selection plays the version that was last watched.
+        /// A directly queried alternate version keeps its own source first. Per-user playback position
+        /// is not surfaced on the source itself; it is carried by each version's own UserData.
+        /// </summary>
+        /// <param name="item">The queried item.</param>
+        /// <param name="sources">The item's media sources.</param>
+        /// <param name="user">The user.</param>
+        /// <returns>The media sources, reordered when a version drives resume.</returns>
+        private IReadOnlyList<MediaSourceInfo> SetAlternateVersionResumeStates(BaseItem item, IReadOnlyList<MediaSourceInfo> sources, User user)
+        {
+            // For a video, multiple sources means alternate versions.
+            if (item is not Video video || sources.Count < 2)
+            {
+                return sources;
+            }
+
+            var versions = video.GetAllVersions();
+            if (versions.Count < 2)
+            {
+                return sources;
+            }
+
+            var userDataByVersion = _userDataManager.GetUserDataBatch(versions, user);
+            var dataBySourceId = new Dictionary<string, UserItemData>(versions.Count, StringComparer.OrdinalIgnoreCase);
+            foreach (var version in versions)
+            {
+                if (userDataByVersion.TryGetValue(version.Id, out var data))
+                {
+                    dataBySourceId[version.Id.ToString("N", CultureInfo.InvariantCulture)] = data;
+                }
+            }
+
+            // Reorder only for a resumable (in-progress) version;
+            // a completed version has no position to resume, so it must not be pulled to the front here.
+            var resumeSource = VersionPlaybackSelector.SelectMostRecentlyPlayed(
+                sources,
+                source => source.Id is not null ? dataBySourceId.GetValueOrDefault(source.Id) : null,
+                data => data.PlaybackPositionTicks > 0);
+
+            if (resumeSource is not null && !video.PrimaryVersionId.HasValue && !ReferenceEquals(sources[0], resumeSource))
+            {
+                var reordered = new List<MediaSourceInfo>(sources.Count) { resumeSource };
+                reordered.AddRange(sources.Where(s => !ReferenceEquals(s, resumeSource)));
+                return reordered;
             }
 
             return sources;
@@ -418,7 +517,7 @@ namespace Emby.Server.Implementations.Library
             MediaStreamSelector.SetSubtitleStreamScores(source.MediaStreams, preferredSubs, user.SubtitleMode, audioLanguage);
         }
 
-        private void SetDefaultAudioStreamIndex(MediaSourceInfo source, UserItemData userData, User user, bool allowRememberingSelection)
+        private void SetDefaultAudioStreamIndex(MediaSourceInfo source, UserItemData userData, User user, bool allowRememberingSelection, string originalLanguage)
         {
             if (userData is not null && userData.AudioStreamIndex.HasValue && user.RememberAudioSelections && allowRememberingSelection)
             {
@@ -432,7 +531,38 @@ namespace Emby.Server.Implementations.Library
                 }
             }
 
-            var preferredAudio = NormalizeLanguage(user.AudioLanguagePreference);
+            if (string.Equals(user.AudioLanguagePreference, "OriginalLanguage", StringComparison.OrdinalIgnoreCase))
+            {
+                if (user.PlayDefaultAudioTrack)
+                {
+                    source.DefaultAudioStreamIndex = MediaStreamSelector.GetDefaultAudioStreamIndex(
+                        source.MediaStreams,
+                        NormalizeLanguage(originalLanguage),
+                        user.PlayDefaultAudioTrack);
+                    return;
+                }
+
+                var originalIndex = source.MediaStreams.FindIndex(i => i.Type == MediaStreamType.Audio && i.IsOriginal);
+
+                if (!string.IsNullOrWhiteSpace(originalLanguage) && originalIndex != -1)
+                {
+                    var mediaLanguageOriginal = source.MediaStreams[originalIndex].Language;
+                    if (NormalizeLanguage(mediaLanguageOriginal).Contains(NormalizeLanguage(originalLanguage).FirstOrDefault()))
+                    {
+                        source.DefaultAudioStreamIndex = originalIndex;
+                        return;
+                    }
+                }
+                else if (originalIndex != -1)
+                {
+                    source.DefaultAudioStreamIndex = originalIndex;
+                    return;
+                }
+            }
+
+            var preferredAudio = string.Equals(user.AudioLanguagePreference, "OriginalLanguage", StringComparison.OrdinalIgnoreCase) && !string.IsNullOrWhiteSpace(originalLanguage)
+                ? NormalizeLanguage(originalLanguage)
+                : NormalizeLanguage(user.AudioLanguagePreference);
 
             source.DefaultAudioStreamIndex = MediaStreamSelector.GetDefaultAudioStreamIndex(source.MediaStreams, preferredAudio, user.PlayDefaultAudioTrack);
             if (user.PlayDefaultAudioTrack)
@@ -457,7 +587,9 @@ namespace Emby.Server.Implementations.Library
 
                 var allowRememberingSelection = item is null || item.EnableRememberingTrackSelections;
 
-                SetDefaultAudioStreamIndex(source, userData, user, allowRememberingSelection);
+                var originalLanguage = item?.GetInheritedOriginalLanguage();
+
+                SetDefaultAudioStreamIndex(source, userData, user, allowRememberingSelection, originalLanguage);
                 SetDefaultSubtitleStreamIndex(source, userData, user, allowRememberingSelection);
             }
             else if (mediaType == MediaType.Audio)
@@ -471,24 +603,32 @@ namespace Emby.Server.Implementations.Library
             }
         }
 
-        private static IEnumerable<MediaSourceInfo> SortMediaSources(IEnumerable<MediaSourceInfo> sources)
+        private static IEnumerable<MediaSourceInfo> SortMediaSources(IEnumerable<MediaSourceInfo> sources, Guid preferredItemId = default)
         {
-            return sources.OrderBy(i =>
-            {
-                if (i.VideoType.HasValue && i.VideoType.Value == VideoType.VideoFile)
+            // The source belonging to the queried item sorts first so it stays the default that gets played.
+            var preferredId = preferredItemId.IsEmpty()
+                ? null
+                : preferredItemId.ToString("N", CultureInfo.InvariantCulture);
+
+            return sources
+                .OrderByDescending(i => preferredId is not null && string.Equals(i.Id, preferredId, StringComparison.OrdinalIgnoreCase))
+                .ThenBy(i =>
                 {
-                    return 0;
-                }
+                    if (i.VideoType.HasValue && i.VideoType.Value == VideoType.VideoFile)
+                    {
+                        return 0;
+                    }
 
-                return 1;
-            }).ThenBy(i => i.Video3DFormat.HasValue ? 1 : 0)
-            .ThenByDescending(i =>
-            {
-                var stream = i.VideoStream;
+                    return 1;
+                })
+                .ThenBy(i => i.Video3DFormat.HasValue ? 1 : 0)
+                .ThenByDescending(i =>
+                {
+                    var stream = i.VideoStream;
 
-                return stream?.Width ?? 0;
-            })
-            .Where(i => i.Type != MediaSourceType.Placeholder);
+                    return stream?.Width ?? 0;
+                })
+                .Where(i => i.Type != MediaSourceType.Placeholder);
         }
 
         public async Task<Tuple<LiveStreamResponse, IDirectStreamProvider>> OpenLiveStreamInternal(LiveStreamRequest request, CancellationToken cancellationToken)

Emby.Server.Implementations/Library/MusicManager.cs

@@ -28,7 +28,9 @@ namespace Emby.Server.Implementations.Library
 
         public IReadOnlyList<BaseItem> GetInstantMixFromSong(Audio item, User? user, DtoOptions dtoOptions)
         {
-            return GetInstantMixFromGenres(item.Genres, user, dtoOptions);
+            var instantMixItems = GetInstantMixFromGenres(item.Genres, user, dtoOptions);
+
+            return [item, .. instantMixItems.Where(i => !i.Id.Equals(item.Id))];
         }
 
         /// <inheritdoc />

Emby.Server.Implementations/Library/PathExtensions.cs

@@ -29,28 +29,79 @@ namespace Emby.Server.Implementations.Library
                 throw new ArgumentException("String can't be empty.", nameof(attribute));
             }
 
-            var attributeIndex = str.IndexOf(attribute, StringComparison.OrdinalIgnoreCase);
-
-            // Must be at least 3 characters after the attribute =, ], any character,
-            // then we offset it by 1, because we want the index and not length.
-            var maxIndex = str.Length - attribute.Length - 2;
-            while (attributeIndex > -1 && attributeIndex < maxIndex)
+            // Allow tmdb as an alias for tmdbid, tvdb for tvdbid, etc.
+            // The code below only supports aliases for attributes in the form of "<alias>id".
+            ReadOnlySpan<char> shortAttr = attribute switch
             {
-                var attributeEnd = attributeIndex + attribute.Length;
-                if (attributeIndex > 0
-                    && str[attributeIndex - 1] == '['
-                    && (str[attributeEnd] == '=' || str[attributeEnd] == '-'))
+                _ when attribute.Equals("tmdbid", StringComparison.OrdinalIgnoreCase) => "tmdb",
+                _ when attribute.Equals("tvdbid", StringComparison.OrdinalIgnoreCase) => "tvdb",
+                _ when attribute.Equals("imdbid", StringComparison.OrdinalIgnoreCase) => "imdb",
+                _ => ReadOnlySpan<char>.Empty
+            };
+
+            for (int strIndex = 0, attributeIndex = 0; attributeIndex > -1;)
+            {
+                // We may want to use imdbid pattern matching later, so we don't want to modify the original 'str'.
+                var subStr = str[strIndex..];
+                int attributeEnd = 0;
+
+                if (shortAttr.Length > 0)
                 {
-                    var closingIndex = str[attributeEnd..].IndexOf(']');
-                    // Must be at least 1 character before the closing bracket.
-                    if (closingIndex > 1)
-                    {
-                        return str[(attributeEnd + 1)..(attributeEnd + closingIndex)].Trim().ToString();
-                    }
+                    // If we are using an alias it should be shorter (and a prefix), so let's search for that.
+                    attributeIndex = subStr.IndexOf(shortAttr, StringComparison.OrdinalIgnoreCase);
+                    attributeEnd = attributeIndex + shortAttr.Length;
+                }
+                else
+                {
+                    attributeIndex = subStr.IndexOf(attribute, StringComparison.OrdinalIgnoreCase);
+                    attributeEnd = attributeIndex + attribute.Length;
                 }
 
-                str = str[attributeEnd..];
-                attributeIndex = str.IndexOf(attribute, StringComparison.OrdinalIgnoreCase);
+                // The next iteration should start at the end of the attribute we just found.
+                // If attributeIndex < 0, the loop will end and strIndex won't be used again.
+                strIndex += attributeEnd;
+
+                if (attributeIndex > 0)
+                {
+                    var attributeOpener = subStr[attributeIndex - 1];
+                    var attributeCloser = attributeOpener switch
+                    {
+                        '[' => ']',
+                        '(' => ')',
+                        '{' => '}',
+                        _ => '\0'
+                    };
+
+                    if (attributeCloser != '\0')
+                    {
+                        if (shortAttr.Length > 0
+                            && attributeEnd + 1 < subStr.Length
+                            && (subStr[attributeEnd] is 'i' or 'I')
+                            && (subStr[attributeEnd + 1] is 'd' or 'D'))
+                        {
+                            // We were searching for a shortened attribute, but it's followed by "id" - let's skip it.
+                            attributeEnd += 2;
+                        }
+
+                        // attributeEnd points at '='.
+                        // We need at least 1 more character and the closing bracket after that.
+                        if (attributeEnd + 2 < subStr.Length && (subStr[attributeEnd] is '=' or '-'))
+                        {
+                            var closingIndex = subStr[attributeEnd..].IndexOf(attributeCloser);
+
+                            // Must be at least 1 character before the closing bracket.
+                            if (closingIndex > 1)
+                            {
+                                var trimmed = subStr[(attributeEnd + 1)..(attributeEnd + closingIndex)].Trim();
+
+                                if (trimmed.Length > 0)
+                                {
+                                    return trimmed.ToString();
+                                }
+                            }
+                        }
+                    }
+                }
             }
 
             // for imdbid we also accept pattern matching

Emby.Server.Implementations/Library/PathManager.cs

@@ -2,10 +2,12 @@ using System;
 using System.Collections.Generic;
 using System.Globalization;
 using System.IO;
+using Jellyfin.Extensions;
 using MediaBrowser.Common.Configuration;
 using MediaBrowser.Controller.Configuration;
 using MediaBrowser.Controller.Entities;
 using MediaBrowser.Controller.IO;
+using Microsoft.Extensions.Logging;
 
 namespace Emby.Server.Implementations.Library;
 
@@ -14,18 +16,22 @@ namespace Emby.Server.Implementations.Library;
 /// </summary>
 public class PathManager : IPathManager
 {
+    private readonly ILogger<PathManager> _logger;
     private readonly IServerConfigurationManager _config;
     private readonly IApplicationPaths _appPaths;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="PathManager"/> class.
     /// </summary>
+    /// <param name="logger">The logger.</param>
     /// <param name="config">The server configuration manager.</param>
     /// <param name="appPaths">The application paths.</param>
     public PathManager(
+        ILogger<PathManager> logger,
         IServerConfigurationManager config,
         IApplicationPaths appPaths)
     {
+        _logger = logger;
         _config = config;
         _appPaths = appPaths;
     }
@@ -35,31 +41,55 @@ public class PathManager : IPathManager
     private string AttachmentCachePath => Path.Combine(_appPaths.DataPath, "attachments");
 
     /// <inheritdoc />
-    public string GetAttachmentPath(string mediaSourceId, string fileName)
+    public string? GetAttachmentPath(string mediaSourceId, string fileName)
     {
-        return Path.Combine(GetAttachmentFolderPath(mediaSourceId), fileName);
+        var folder = GetAttachmentFolderPath(mediaSourceId);
+        if (folder is null)
+        {
+            return null;
+        }
+
+        var safeName = PathHelper.GetSafeLeafFileName(fileName);
+        if (safeName is null)
+        {
+            _logger.LogWarning("Rejecting attachment filename '{FileName}' for MediaSource {MediaSourceId}: not a valid leaf name.", fileName, mediaSourceId);
+            return null;
+        }
+
+        return Path.Combine(folder, safeName);
     }
 
     /// <inheritdoc />
-    public string GetAttachmentFolderPath(string mediaSourceId)
+    public string? GetAttachmentFolderPath(string mediaSourceId)
     {
-        var id = Guid.Parse(mediaSourceId).ToString("D", CultureInfo.InvariantCulture).AsSpan();
+        if (!Guid.TryParse(mediaSourceId, out var parsed))
+        {
+            _logger.LogDebug("MediaSource Id '{MediaSourceId}' is not a GUID; no on-disk attachment folder.", mediaSourceId);
+            return null;
+        }
 
+        var id = parsed.ToString("D", CultureInfo.InvariantCulture).AsSpan();
         return Path.Join(AttachmentCachePath, id[..2], id);
     }
 
     /// <inheritdoc />
-    public string GetSubtitleFolderPath(string mediaSourceId)
+    public string? GetSubtitleFolderPath(string mediaSourceId)
     {
-        var id = Guid.Parse(mediaSourceId).ToString("D", CultureInfo.InvariantCulture).AsSpan();
+        if (!Guid.TryParse(mediaSourceId, out var parsed))
+        {
+            _logger.LogDebug("MediaSource Id '{MediaSourceId}' is not a GUID; no on-disk subtitle folder.", mediaSourceId);
+            return null;
+        }
 
+        var id = parsed.ToString("D", CultureInfo.InvariantCulture).AsSpan();
         return Path.Join(SubtitleCachePath, id[..2], id);
     }
 
     /// <inheritdoc />
-    public string GetSubtitlePath(string mediaSourceId, int streamIndex, string extension)
+    public string? GetSubtitlePath(string mediaSourceId, int streamIndex, string extension)
     {
-        return Path.Combine(GetSubtitleFolderPath(mediaSourceId), streamIndex.ToString(CultureInfo.InvariantCulture) + extension);
+        var folder = GetSubtitleFolderPath(mediaSourceId);
+        return folder is null ? null : Path.Combine(folder, streamIndex.ToString(CultureInfo.InvariantCulture) + extension);
     }
 
     /// <inheritdoc />
@@ -90,12 +120,27 @@ public class PathManager : IPathManager
     public IReadOnlyList<string> GetExtractedDataPaths(BaseItem item)
     {
         var mediaSourceId = item.Id.ToString("N", CultureInfo.InvariantCulture);
-        return [
-            GetAttachmentFolderPath(mediaSourceId),
-            GetSubtitleFolderPath(mediaSourceId),
-            GetTrickplayDirectory(item, false),
-            GetTrickplayDirectory(item, true),
-            GetChapterImageFolderPath(item)
-        ];
+        List<string> paths = [];
+        var attachmentFolder = GetAttachmentFolderPath(mediaSourceId);
+        if (attachmentFolder is not null)
+        {
+            paths.Add(attachmentFolder);
+        }
+
+        var subtitleFolder = GetSubtitleFolderPath(mediaSourceId);
+        if (subtitleFolder is not null)
+        {
+            paths.Add(subtitleFolder);
+        }
+
+        paths.Add(GetTrickplayDirectory(item, false));
+        if (!string.IsNullOrEmpty(item.Path))
+        {
+            paths.Add(GetTrickplayDirectory(item, true));
+        }
+
+        paths.Add(GetChapterImageFolderPath(item));
+
+        return paths;
     }
 }

Emby.Server.Implementations/Library/Resolvers/Books/BookResolver.cs

@@ -1,16 +1,14 @@
-#nullable disable
-
 #pragma warning disable CS1591
 
 using System;
 using System.IO;
 using System.Linq;
+using Emby.Naming.Book;
 using Jellyfin.Data.Enums;
 using Jellyfin.Extensions;
 using MediaBrowser.Controller.Entities;
 using MediaBrowser.Controller.Library;
 using MediaBrowser.Controller.Resolvers;
-using MediaBrowser.Model.Entities;
 
 namespace Emby.Server.Implementations.Library.Resolvers.Books
 {
@@ -18,7 +16,7 @@ namespace Emby.Server.Implementations.Library.Resolvers.Books
     {
         private readonly string[] _validExtensions = { ".azw", ".azw3", ".cb7", ".cbr", ".cbt", ".cbz", ".epub", ".mobi", ".pdf" };
 
-        protected override Book Resolve(ItemResolveArgs args)
+        protected override Book? Resolve(ItemResolveArgs args)
         {
             var collectionType = args.GetCollectionType();
 
@@ -35,20 +33,26 @@ namespace Emby.Server.Implementations.Library.Resolvers.Books
 
             var extension = Path.GetExtension(args.Path.AsSpan());
 
-            if (_validExtensions.Contains(extension, StringComparison.OrdinalIgnoreCase))
+            if (!_validExtensions.Contains(extension, StringComparison.OrdinalIgnoreCase))
             {
-                // It's a book
-                return new Book
-                {
-                    Path = args.Path,
-                    IsInMixedFolder = true
-                };
+                return null;
             }
 
-            return null;
+            var result = BookFileNameParser.Parse(Path.GetFileNameWithoutExtension(args.Path));
+
+            return new Book
+            {
+                Path = args.Path,
+                Name = result.Name ?? string.Empty,
+                IndexNumber = result.Index,
+                ParentIndexNumber = result.ParentIndex,
+                ProductionYear = result.Year,
+                SeriesName = result.SeriesName ?? Path.GetFileName(Path.GetDirectoryName(args.Path)),
+                IsInMixedFolder = true,
+            };
         }
 
-        private Book GetBook(ItemResolveArgs args)
+        private Book? GetBook(ItemResolveArgs args)
         {
             var bookFiles = args.FileSystemChildren.Where(f =>
             {
@@ -59,15 +63,23 @@ namespace Emby.Server.Implementations.Library.Resolvers.Books
                     StringComparison.OrdinalIgnoreCase);
             }).ToList();
 
-            // Don't return a Book if there is more (or less) than one document in the directory
+            // directory is only considered a book when it contains exactly one supported file
+            // other library structures with multiple books to a directory will get picked up as individual files
             if (bookFiles.Count != 1)
             {
                 return null;
             }
 
+            var result = BookFileNameParser.Parse(Path.GetFileName(args.Path));
+
             return new Book
             {
-                Path = bookFiles[0].FullName
+                Path = bookFiles[0].FullName,
+                Name = result.Name ?? string.Empty,
+                IndexNumber = result.Index,
+                ParentIndexNumber = result.ParentIndex,
+                ProductionYear = result.Year,
+                SeriesName = result.SeriesName ?? string.Empty,
             };
         }
     }

Emby.Server.Implementations/Library/Resolvers/ExtraResolver.cs

@@ -32,8 +32,8 @@ namespace Emby.Server.Implementations.Library.Resolvers
             : base(logger, namingOptions, directoryService)
         {
             _namingOptions = namingOptions;
-            _trailerResolvers = new IItemResolver[] { new GenericVideoResolver<Trailer>(logger, namingOptions, directoryService) };
-            _videoResolvers = new IItemResolver[] { this };
+            _trailerResolvers = [new GenericVideoResolver<Trailer>(logger, namingOptions, directoryService, parseName: true)];
+            _videoResolvers = [this];
         }
 
         protected override Video Resolve(ItemResolveArgs args)
@@ -54,12 +54,13 @@ namespace Emby.Server.Implementations.Library.Resolvers
             _ => _videoResolvers
         };
 
-        public bool TryGetExtraTypeForOwner(string path, VideoFileInfo ownerVideoFileInfo, [NotNullWhen(true)] out ExtraType? extraType, string? libraryRoot = "")
+        public bool TryGetExtraTypeForOwner(string path, VideoFileInfo ownerVideoFileInfo, [NotNullWhen(true)] out ExtraType? extraType, [NotNullWhen(true)] out ExtraRule? extraRule, string? libraryRoot = "")
         {
             var extraResult = GetExtraInfo(path, _namingOptions, libraryRoot);
-            if (extraResult.ExtraType is null)
+            if (extraResult.ExtraType is null || extraResult.Rule is null)
             {
                 extraType = null;
+                extraRule = null;
                 return false;
             }
 
@@ -88,6 +89,7 @@ namespace Emby.Server.Implementations.Library.Resolvers
             }
 
             extraType = extraResult.ExtraType;
+            extraRule = extraResult.Rule;
             return isValid;
         }
 

Emby.Server.Implementations/Library/Resolvers/GenericVideoResolver.cs

@@ -2,6 +2,7 @@
 
 using Emby.Naming.Common;
 using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Library;
 using MediaBrowser.Controller.Providers;
 using Microsoft.Extensions.Logging;
 
@@ -14,15 +15,25 @@ namespace Emby.Server.Implementations.Library.Resolvers
     public class GenericVideoResolver<T> : BaseVideoResolver<T>
         where T : Video, new()
     {
+        private readonly bool _parseName;
+
         /// <summary>
         /// Initializes a new instance of the <see cref="GenericVideoResolver{T}"/> class.
         /// </summary>
         /// <param name="logger">The logger.</param>
         /// <param name="namingOptions">The naming options.</param>
         /// <param name="directoryService">The directory service.</param>
-        public GenericVideoResolver(ILogger logger, NamingOptions namingOptions, IDirectoryService directoryService)
+        /// <param name="parseName">Whether to parse the file name for metadata such as the year.</param>
+        public GenericVideoResolver(ILogger logger, NamingOptions namingOptions, IDirectoryService directoryService, bool parseName = false)
             : base(logger, namingOptions, directoryService)
         {
+            _parseName = parseName;
+        }
+
+        /// <inheritdoc />
+        protected override T Resolve(ItemResolveArgs args)
+        {
+            return ResolveVideo<T>(args, _parseName);
         }
     }
 }

Emby.Server.Implementations/Library/Resolvers/Movies/MovieResolver.cs

@@ -28,15 +28,16 @@ namespace Emby.Server.Implementations.Library.Resolvers.Movies
     public partial class MovieResolver : BaseVideoResolver<Video>, IMultiItemResolver
     {
         private readonly IImageProcessor _imageProcessor;
+        private readonly VideoListResolver _videoListResolver;
 
-        private static readonly CollectionType[] _validCollectionTypes = new[]
-        {
+        private static readonly CollectionType[] _validCollectionTypes =
+        [
             CollectionType.movies,
             CollectionType.homevideos,
             CollectionType.musicvideos,
             CollectionType.tvshows,
             CollectionType.photos
-        };
+        ];
 
         /// <summary>
         /// Initializes a new instance of the <see cref="MovieResolver"/> class.
@@ -45,10 +46,12 @@ namespace Emby.Server.Implementations.Library.Resolvers.Movies
         /// <param name="logger">The logger.</param>
         /// <param name="namingOptions">The naming options.</param>
         /// <param name="directoryService">The directory service.</param>
-        public MovieResolver(IImageProcessor imageProcessor, ILogger<MovieResolver> logger, NamingOptions namingOptions, IDirectoryService directoryService)
+        /// <param name="videoListResolver">The video list resolver.</param>
+        public MovieResolver(IImageProcessor imageProcessor, ILogger<MovieResolver> logger, NamingOptions namingOptions, IDirectoryService directoryService, VideoListResolver videoListResolver)
             : base(logger, namingOptions, directoryService)
         {
             _imageProcessor = imageProcessor;
+            _videoListResolver = videoListResolver;
         }
 
         /// <summary>
@@ -228,7 +231,7 @@ namespace Emby.Server.Implementations.Library.Resolvers.Movies
 
             if (collectionType == CollectionType.tvshows)
             {
-                return ResolveVideos<Episode>(parent, files, false, collectionType, true);
+                return ResolveVideos<Episode>(parent, files, true, collectionType, true);
             }
 
             return null;
@@ -274,7 +277,7 @@ namespace Emby.Server.Implementations.Library.Resolvers.Movies
                 .Where(f => f is not null)
                 .ToList();
 
-            var resolverResult = VideoListResolver.Resolve(videoInfos, NamingOptions, supportMultiEditions, parseName, parent.ContainingFolderPath);
+            var resolverResult = _videoListResolver.Resolve(videoInfos, supportMultiEditions, parseName, parent.ContainingFolderPath, collectionType);
 
             var result = new MultiItemResolverResult
             {
@@ -302,7 +305,7 @@ namespace Emby.Server.Implementations.Library.Resolvers.Movies
                     ProductionYear = video.Year,
                     Name = parseName ? video.Name : firstVideo.Name,
                     AdditionalParts = additionalParts,
-                    LocalAlternateVersions = video.AlternateVersions.Select(i => i.Path).ToArray()
+                    LocalAlternateVersions = video.AlternateVersions.Select(av => av.Files[0].Path).ToArray()
                 };
 
                 SetVideoType(videoItem, firstVideo);
@@ -331,9 +334,13 @@ namespace Emby.Server.Implementations.Library.Resolvers.Movies
 
                 for (var j = 0; j < current.AlternateVersions.Count; j++)
                 {
-                    if (ContainsFile(current.AlternateVersions[j], file))
+                    var alternate = current.AlternateVersions[j];
+                    for (var k = 0; k < alternate.Files.Count; k++)
                     {
-                        return true;
+                        if (ContainsFile(alternate.Files[k], file))
+                        {
+                            return true;
+                        }
                     }
                 }
             }
@@ -369,11 +376,23 @@ namespace Emby.Server.Implementations.Library.Resolvers.Movies
                 // We need to only look at the name of this actual item (not parents)
                 var justName = item.IsInMixedFolder ? Path.GetFileName(item.Path.AsSpan()) : Path.GetFileName(item.ContainingFolderPath.AsSpan());
 
-                if (!justName.IsEmpty)
+                // The fallback filename is only used when the item isn't in a mixed folder
+                var fileName = item.IsInMixedFolder ? ReadOnlySpan<char>.Empty : Path.GetFileName(item.Path.AsSpan());
+
+                item.TrySetProviderId(MetadataProvider.Tmdb, GetIdFromNameOrPath(justName, fileName, "tmdbid"));
+                item.TrySetProviderId(MetadataProvider.Tvdb, GetIdFromNameOrPath(justName, fileName, "tvdbid"));
+
+                string GetIdFromNameOrPath(ReadOnlySpan<char> name, ReadOnlySpan<char> fallbackName, string attribute)
                 {
-                    // Check for TMDb id
-                    var tmdbid = justName.GetAttributeValue("tmdbid");
-                    item.TrySetProviderId(MetadataProvider.Tmdb, tmdbid);
+                    var id = name.GetAttributeValue(attribute);
+
+                    // If not in a mixed folder and ID not found in folder path, check filename
+                    if (string.IsNullOrEmpty(id) && !item.IsInMixedFolder)
+                    {
+                        id = fallbackName.GetAttributeValue(attribute);
+                    }
+
+                    return id;
                 }
 
                 if (!string.IsNullOrEmpty(item.Path))

Emby.Server.Implementations/Library/Resolvers/PlaylistResolver.cs

@@ -1,8 +1,10 @@
 #nullable disable
 
 using System;
+using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using Emby.Server.Implementations.Playlists;
 using Jellyfin.Data.Enums;
 using Jellyfin.Extensions;
 using MediaBrowser.Controller.Library;
@@ -45,8 +47,30 @@ namespace Emby.Server.Implementations.Library.Resolvers
                     };
                 }
 
+                // Anything directly inside the internal playlists folder is a playlist, even when its
+                // playlist.xml is missing: failing to resolve here makes the library scan treat the
+                // playlist as deleted from disk and remove it, taking its items with it.
+                if (args.Parent is PlaylistsFolder)
+                {
+                    return new Playlist
+                    {
+                        Path = args.Path,
+                        Name = filename,
+                        OpenAccess = true
+                    };
+                }
+
                 // It's a directory-based playlist if the directory contains a playlist file
-                var filePaths = Directory.EnumerateFiles(args.Path, "*", new EnumerationOptions { IgnoreInaccessible = true });
+                IEnumerable<string> filePaths;
+                try
+                {
+                    filePaths = Directory.EnumerateFiles(args.Path, "*", new EnumerationOptions { IgnoreInaccessible = true });
+                }
+                catch (IOException)
+                {
+                    return null;
+                }
+
                 if (filePaths.Any(f => f.EndsWith(PlaylistXmlSaver.DefaultPlaylistFilename, StringComparison.OrdinalIgnoreCase)))
                 {
                     return new Playlist

Emby.Server.Implementations/Library/Resolvers/TV/EpisodeResolver.cs

@@ -1,8 +1,10 @@
 #nullable disable
 
 using System;
+using System.IO;
 using System.Linq;
 using Emby.Naming.Common;
+using Emby.Server.Implementations.Library;
 using Jellyfin.Data.Enums;
 using MediaBrowser.Controller.Entities.TV;
 using MediaBrowser.Controller.Library;
@@ -81,10 +83,34 @@ namespace Emby.Server.Implementations.Library.Resolvers.TV
                     episode.ParentIndexNumber = 1;
                 }
 
+                SetProviderIdFromPath(episode, args.Path);
+
                 return episode;
             }
 
             return null;
         }
+
+        /// <summary>
+        /// Sets provider ids from the episode file name.
+        /// </summary>
+        /// <param name="item">The episode.</param>
+        /// <param name="path">The episode file path.</param>
+        private static void SetProviderIdFromPath(Episode item, string path)
+        {
+            var justName = Path.GetFileNameWithoutExtension(path.AsSpan());
+
+            var imdbId = justName.GetAttributeValue("imdbid");
+            item.TrySetProviderId(MetadataProvider.Imdb, imdbId);
+
+            var tvdbId = justName.GetAttributeValue("tvdbid");
+            item.TrySetProviderId(MetadataProvider.Tvdb, tvdbId);
+
+            var tvmazeId = justName.GetAttributeValue("tvmazeid");
+            item.TrySetProviderId(MetadataProvider.TvMaze, tvmazeId);
+
+            var tmdbId = justName.GetAttributeValue("tmdbid");
+            item.TrySetProviderId(MetadataProvider.Tmdb, tmdbId);
+        }
     }
 }

Emby.Server.Implementations/Library/Resolvers/TV/SeasonResolver.cs

@@ -1,10 +1,15 @@
 #nullable disable
 
+using System;
 using System.Globalization;
+using System.IO;
+using System.Linq;
 using Emby.Naming.Common;
 using Emby.Naming.TV;
+using Emby.Server.Implementations.Library;
 using MediaBrowser.Controller.Entities.TV;
 using MediaBrowser.Controller.Library;
+using MediaBrowser.Model.Entities;
 using MediaBrowser.Model.Globalization;
 using Microsoft.Extensions.Logging;
 
@@ -77,6 +82,14 @@ namespace Emby.Server.Implementations.Library.Resolvers.TV
 
                         return null;
                     }
+
+                    var hasAnyVideo = Directory.EnumerateFiles(path, "*", SearchOption.AllDirectories)
+                        .Any(file => _namingOptions.VideoFileExtensions.Contains(Path.GetExtension(file)));
+
+                    if (!hasAnyVideo)
+                    {
+                        return null;
+                    }
                 }
 
                 if (season.IndexNumber.HasValue && string.IsNullOrEmpty(season.Name))
@@ -86,15 +99,47 @@ namespace Emby.Server.Implementations.Library.Resolvers.TV
                         args.LibraryOptions.SeasonZeroDisplayName :
                         string.Format(
                             CultureInfo.InvariantCulture,
-                            _localization.GetLocalizedString("NameSeasonNumber"),
+                            _localization.GetServerLocalizedString("NameSeasonNumber"),
                             seasonNumber,
                             args.LibraryOptions.PreferredMetadataLanguage);
                 }
 
+                SetProviderIdFromPath(season, path);
+
                 return season;
             }
 
             return null;
         }
+
+        /// <summary>
+        /// Sets provider ids from the season folder name.
+        /// </summary>
+        /// <param name="item">The season.</param>
+        /// <param name="path">The season folder path.</param>
+        private static void SetProviderIdFromPath(Season item, string path)
+        {
+            var justName = Path.GetFileName(path.AsSpan());
+
+            var tvdbId = justName.GetAttributeValue("tvdbid");
+            item.TrySetProviderId(MetadataProvider.Tvdb, tvdbId);
+
+            var tvmazeId = justName.GetAttributeValue("tvmazeid");
+            item.TrySetProviderId(MetadataProvider.TvMaze, tvmazeId);
+
+            var tmdbId = justName.GetAttributeValue("tmdbid");
+            item.TrySetProviderId(MetadataProvider.Tmdb, tmdbId);
+
+            // Anime databases model a single cour as its own entry, so a multi-season
+            // series maps to one of these ids per season rather than one per series.
+            var anidbId = justName.GetAttributeValue("anidbid");
+            item.TrySetProviderId("AniDB", anidbId);
+
+            var aniListId = justName.GetAttributeValue("anilistid");
+            item.TrySetProviderId("AniList", aniListId);
+
+            var aniSearchId = justName.GetAttributeValue("anisearchid");
+            item.TrySetProviderId("AniSearch", aniSearchId);
+        }
     }
 }

Emby.Server.Implementations/Library/Resolvers/TV/SeriesResolver.cs

@@ -31,7 +31,7 @@ namespace Emby.Server.Implementations.Library.Resolvers.TV
         /// </summary>
         /// <param name="logger">The logger.</param>
         /// <param name="namingOptions">The naming options.</param>
-        public SeriesResolver(ILogger<SeriesResolver> logger,  NamingOptions namingOptions)
+        public SeriesResolver(ILogger<SeriesResolver> logger, NamingOptions namingOptions)
         {
             _logger = logger;
             _namingOptions = namingOptions;
@@ -57,6 +57,11 @@ namespace Emby.Server.Implementations.Library.Resolvers.TV
                     return null;
                 }
 
+                if (args.Parent is not null && args.Parent.IsRoot)
+                {
+                    return null;
+                }
+
                 var seriesInfo = Naming.TV.SeriesResolver.Resolve(_namingOptions, args.Path);
 
                 var collectionType = args.GetCollectionType();
@@ -69,7 +74,8 @@ namespace Emby.Server.Implementations.Library.Resolvers.TV
                         return new Series
                         {
                             Path = args.Path,
-                            Name = seriesInfo.Name
+                            Name = seriesInfo.Name,
+                            ProductionYear = seriesInfo.Year
                         };
                     }
                 }

Emby.Server.Implementations/Library/Search/SearchManager.cs

@@ -0,0 +1,453 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Data.Enums;
+using Jellyfin.Database.Implementations;
+using Jellyfin.Database.Implementations.Entities;
+using Jellyfin.Extensions;
+using MediaBrowser.Controller.Dto;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Persistence;
+using MediaBrowser.Model.Querying;
+using MediaBrowser.Model.Search;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+
+namespace Emby.Server.Implementations.Library.Search;
+
+/// <summary>
+/// Manages search providers and orchestrates search operations.
+/// </summary>
+public class SearchManager : ISearchManager
+{
+    private readonly ILibraryManager _libraryManager;
+    private readonly IUserManager _userManager;
+    private readonly IDbContextFactory<JellyfinDbContext> _dbProvider;
+    private readonly IItemQueryHelpers _queryHelpers;
+    private readonly ILogger<SearchManager> _logger;
+    private IExternalSearchProvider[] _externalProviders = [];
+    private IInternalSearchProvider[] _internalProviders = [];
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="SearchManager"/> class.
+    /// </summary>
+    /// <param name="libraryManager">The library manager.</param>
+    /// <param name="userManager">The user manager.</param>
+    /// <param name="dbProvider">The database context factory.</param>
+    /// <param name="queryHelpers">The shared item query helpers.</param>
+    /// <param name="logger">The logger.</param>
+    public SearchManager(
+        ILibraryManager libraryManager,
+        IUserManager userManager,
+        IDbContextFactory<JellyfinDbContext> dbProvider,
+        IItemQueryHelpers queryHelpers,
+        ILogger<SearchManager> logger)
+    {
+        _libraryManager = libraryManager;
+        _userManager = userManager;
+        _dbProvider = dbProvider;
+        _queryHelpers = queryHelpers;
+        _logger = logger;
+    }
+
+    /// <inheritdoc/>
+    public void AddParts(IEnumerable<ISearchProvider> providers)
+    {
+        var allProviders = providers.OrderBy(p => p.Priority).ToArray();
+
+        _externalProviders = allProviders.OfType<IExternalSearchProvider>().ToArray();
+        _internalProviders = allProviders.OfType<IInternalSearchProvider>().ToArray();
+
+        _logger.LogInformation(
+            "Registered {ExternalCount} external search providers: {ExternalProviders}. Fallback providers: {FallbackProviders}",
+            _externalProviders.Length,
+            string.Join(", ", _externalProviders.Select(p => $"{p.Name} (priority {p.Priority})")),
+            string.Join(", ", _internalProviders.Select(p => $"{p.Name} (priority {p.Priority})")));
+    }
+
+    /// <inheritdoc/>
+    public IReadOnlyList<ISearchProvider> GetProviders()
+    {
+        return [.. _externalProviders, .. _internalProviders];
+    }
+
+    /// <inheritdoc/>
+    public async Task<IReadOnlyList<SearchResult>> GetSearchResultsAsync(
+        SearchProviderQuery query,
+        CancellationToken cancellationToken = default)
+    {
+        ArgumentNullException.ThrowIfNull(query);
+        ArgumentException.ThrowIfNullOrWhiteSpace(query.SearchTerm);
+
+        var searchTerm = query.SearchTerm.Trim().RemoveDiacritics();
+
+        var externalTask = CollectFromProvidersAsync(_externalProviders, query, searchTerm, cancellationToken);
+        var internalTask = _internalProviders.Length > 0
+            ? CollectFromProvidersAsync(_internalProviders, query, searchTerm, cancellationToken)
+            : Task.FromResult<IReadOnlyList<SearchResult>>([]);
+
+        await Task.WhenAll(externalTask, internalTask).ConfigureAwait(false);
+
+        var externalResults = await externalTask.ConfigureAwait(false);
+
+        // Internal providers apply user-access filtering inline in their queries. External
+        // providers don't know about user permissions, so they may return IDs from hidden
+        // libraries or items the user is otherwise blocked from. Filter them here to close
+        // that gap. The Items controller's second roundtrip via folder.GetItems applies most
+        // of these again, but it does not restrict by TopParentIds when ItemIds is set.
+        if (externalResults.Count > 0 && query.UserId.HasValue && !query.UserId.Value.IsEmpty())
+        {
+            var user = _userManager.GetUserById(query.UserId.Value);
+            if (user is not null)
+            {
+                externalResults = await FilterByUserAccessAsync(externalResults, user, query, cancellationToken).ConfigureAwait(false);
+            }
+        }
+
+        if (externalResults.Count > 0)
+        {
+            return externalResults;
+        }
+
+        if (_internalProviders.Length > 0)
+        {
+            _logger.LogDebug("No results from external providers, using internal provider results");
+        }
+
+        return await internalTask.ConfigureAwait(false);
+    }
+
+    private async Task<IReadOnlyList<SearchResult>> FilterByUserAccessAsync(
+        IReadOnlyList<SearchResult> candidates,
+        User user,
+        SearchProviderQuery query,
+        CancellationToken cancellationToken)
+    {
+        // SetUser populates parental rating + blocked/allowed tags, Build populates TopParentIds
+        // for the user's accessible libraries. The candidate ids are applied to the query below
+        // rather than to the filter because LibraryManager.AddUserToQuery skips TopParentIds when
+        // ItemIds is non-empty.
+        var accessFilter = SearchQueryAccessFilter.Build(user, query, _libraryManager);
+
+        Guid[] candidateIds = [.. candidates.Select(c => c.ItemId)];
+
+        var dbContext = await _dbProvider.CreateDbContextAsync(cancellationToken).ConfigureAwait(false);
+        await using (dbContext.ConfigureAwait(false))
+        {
+            var baseQuery = dbContext.BaseItems
+                .AsNoTracking()
+                .WhereOneOrMany(candidateIds, e => e.Id);
+
+            baseQuery = _queryHelpers.ApplyAccessFiltering(dbContext, baseQuery, accessFilter);
+
+            var allowedIds = await baseQuery
+                .Select(e => e.Id)
+                .ToHashSetAsync(cancellationToken)
+                .ConfigureAwait(false);
+
+            if (allowedIds.Count == candidates.Count)
+            {
+                return candidates;
+            }
+
+            var filtered = candidates.Where(c => allowedIds.Contains(c.ItemId)).ToList();
+            if (filtered.Count < candidates.Count)
+            {
+                _logger.LogDebug(
+                    "Dropped {Dropped} of {Total} search candidates due to user access filtering",
+                    candidates.Count - filtered.Count,
+                    candidates.Count);
+            }
+
+            return filtered;
+        }
+    }
+
+    /// <inheritdoc/>
+    public async Task<QueryResult<SearchHintInfo>> GetSearchHintsAsync(SearchQuery query, CancellationToken cancellationToken = default)
+    {
+        ArgumentNullException.ThrowIfNull(query);
+        ArgumentException.ThrowIfNullOrWhiteSpace(query.SearchTerm);
+
+        var providerQuery = BuildProviderQuery(query);
+        var candidates = await GetSearchResultsAsync(providerQuery, cancellationToken).ConfigureAwait(false);
+        if (candidates.Count == 0)
+        {
+            return new QueryResult<SearchHintInfo>();
+        }
+
+        var candidateScores = BuildScoreLookup(candidates);
+        var user = query.UserId.IsEmpty() ? null : _userManager.GetUserById(query.UserId);
+
+        var excludeItemTypes = BuildExcludeItemTypes(query);
+        var includeItemTypes = BuildIncludeItemTypes(query);
+
+        var internalQuery = new InternalItemsQuery(user)
+        {
+            ItemIds = candidateScores.Keys.ToArray(),
+            ExcludeItemTypes = excludeItemTypes.ToArray(),
+            IncludeItemTypes = includeItemTypes.Count > 0 ? includeItemTypes.ToArray() : [],
+            MediaTypes = query.MediaTypes.ToArray(),
+            IncludeItemsByName = !query.ParentId.HasValue,
+            ParentId = query.ParentId ?? Guid.Empty,
+            Recursive = true,
+            IsKids = query.IsKids,
+            IsMovie = query.IsMovie,
+            IsNews = query.IsNews,
+            IsSeries = query.IsSeries,
+            IsSports = query.IsSports,
+            DtoOptions = new DtoOptions
+            {
+                Fields =
+                [
+                    ItemFields.AirTime,
+                    ItemFields.DateCreated,
+                    ItemFields.ChannelInfo,
+                    ItemFields.ParentId
+                ]
+            }
+        };
+
+        // MusicArtist items are "ItemsByName" entities - virtual items that aggregate content by artist name
+        // rather than being stored as regular library items. They require special handling:
+        // 1. Convert ParentId to AncestorIds (to filter by library folder)
+        // 2. Set IncludeItemsByName = true (to include these virtual items in results)
+        // 3. Clear IncludeItemTypes (GetAllArtists handles type filtering internally)
+        // 4. Use GetAllArtists() instead of GetItemList() to query the artist index
+        IReadOnlyList<BaseItem> items;
+        if (internalQuery.IncludeItemTypes.Length == 1 && internalQuery.IncludeItemTypes[0] == BaseItemKind.MusicArtist)
+        {
+            if (!internalQuery.ParentId.IsEmpty())
+            {
+                internalQuery.AncestorIds = [internalQuery.ParentId];
+                internalQuery.ParentId = Guid.Empty;
+            }
+
+            internalQuery.IncludeItemsByName = true;
+            internalQuery.IncludeItemTypes = [];
+            items = _libraryManager.GetAllArtists(internalQuery).Items.Select(i => i.Item).ToList();
+        }
+        else
+        {
+            items = _libraryManager.GetItemList(internalQuery);
+        }
+
+        var orderedResults = items
+            .Select(item => new SearchHintInfo { Item = item })
+            .OrderByDescending(hint => candidateScores.GetValueOrDefault(hint.Item.Id, 0f))
+            .ToList();
+
+        var totalCount = orderedResults.Count;
+
+        if (query.StartIndex.HasValue)
+        {
+            orderedResults = orderedResults.Skip(query.StartIndex.Value).ToList();
+        }
+
+        if (query.Limit.HasValue)
+        {
+            orderedResults = orderedResults.Take(query.Limit.Value).ToList();
+        }
+
+        return new QueryResult<SearchHintInfo>(query.StartIndex, totalCount, orderedResults);
+    }
+
+    private async Task<IReadOnlyList<SearchResult>> CollectFromProvidersAsync(
+        IEnumerable<ISearchProvider> providers,
+        SearchProviderQuery providerQuery,
+        string searchTerm,
+        CancellationToken cancellationToken)
+    {
+        var requestedLimit = providerQuery.Limit ?? 100;
+        var applicable = providers.Where(p => p.CanSearch(providerQuery)).ToArray();
+        if (applicable.Length == 0)
+        {
+            return [];
+        }
+
+        var perProvider = await Task.WhenAll(
+            applicable.Select(p => CollectFromProviderAsync(p, providerQuery, searchTerm, requestedLimit, cancellationToken)))
+            .ConfigureAwait(false);
+
+        var bestScores = new Dictionary<Guid, float>();
+        foreach (var providerResults in perProvider)
+        {
+            foreach (var result in providerResults)
+            {
+                UpdateBestScore(bestScores, result);
+            }
+        }
+
+        return bestScores
+            .Select(kvp => new SearchResult(kvp.Key, kvp.Value))
+            .OrderByDescending(r => r.Score)
+            .Take(requestedLimit)
+            .ToList();
+    }
+
+    private async Task<IReadOnlyList<SearchResult>> CollectFromProviderAsync(
+        ISearchProvider provider,
+        SearchProviderQuery providerQuery,
+        string searchTerm,
+        int requestedLimit,
+        CancellationToken cancellationToken)
+    {
+        try
+        {
+            var results = provider is IExternalSearchProvider externalProvider
+                ? await CollectFromExternalProviderAsync(externalProvider, providerQuery, requestedLimit, cancellationToken).ConfigureAwait(false)
+                : await provider.SearchAsync(providerQuery, cancellationToken).ConfigureAwait(false);
+
+            _logger.LogDebug(
+                "Provider {Provider} returned {Count} candidates for search term '{SearchTerm}'",
+                provider.Name,
+                results.Count,
+                searchTerm);
+            return results;
+        }
+        catch (Exception ex)
+        {
+            _logger.LogWarning(ex, "Search provider {Provider} failed for term '{SearchTerm}'", provider.Name, searchTerm);
+            return [];
+        }
+    }
+
+    private static async Task<IReadOnlyList<SearchResult>> CollectFromExternalProviderAsync(
+        IExternalSearchProvider provider,
+        SearchProviderQuery providerQuery,
+        int requestedLimit,
+        CancellationToken cancellationToken)
+    {
+        var results = new List<SearchResult>();
+        await foreach (var result in provider.SearchAsync(providerQuery, cancellationToken).ConfigureAwait(false))
+        {
+            results.Add(result);
+            if (results.Count >= requestedLimit)
+            {
+                break;
+            }
+        }
+
+        return results;
+    }
+
+    private static void UpdateBestScore(Dictionary<Guid, float> bestScores, SearchResult result)
+    {
+        if (!bestScores.TryGetValue(result.ItemId, out var existingScore) || result.Score > existingScore)
+        {
+            bestScores[result.ItemId] = result.Score;
+        }
+    }
+
+    private static Dictionary<Guid, float> BuildScoreLookup(IReadOnlyList<SearchResult> results)
+    {
+        var lookup = new Dictionary<Guid, float>(results.Count);
+        foreach (var result in results)
+        {
+            lookup[result.ItemId] = result.Score;
+        }
+
+        return lookup;
+    }
+
+    private static SearchProviderQuery BuildProviderQuery(SearchQuery query)
+    {
+        var excludeItemTypes = BuildExcludeItemTypes(query);
+        var includeItemTypes = BuildIncludeItemTypes(query);
+
+        // Remove any excluded types from includes
+        if (includeItemTypes.Count > 0 && excludeItemTypes.Count > 0)
+        {
+            includeItemTypes.RemoveAll(excludeItemTypes.Contains);
+        }
+
+        return new SearchProviderQuery
+        {
+            SearchTerm = query.SearchTerm,
+            UserId = query.UserId.IsEmpty() ? null : query.UserId,
+            IncludeItemTypes = includeItemTypes.ToArray(),
+            ExcludeItemTypes = excludeItemTypes.ToArray(),
+            MediaTypes = query.MediaTypes.ToArray(),
+            Limit = query.Limit,
+            ParentId = query.ParentId
+        };
+    }
+
+    private static List<BaseItemKind> BuildExcludeItemTypes(SearchQuery query)
+    {
+        var excludeItemTypes = query.ExcludeItemTypes.ToList();
+
+        excludeItemTypes.Add(BaseItemKind.Year);
+        excludeItemTypes.Add(BaseItemKind.Folder);
+        excludeItemTypes.Add(BaseItemKind.CollectionFolder);
+
+        if (!query.IncludeGenres)
+        {
+            AddIfMissing(excludeItemTypes, BaseItemKind.Genre);
+            AddIfMissing(excludeItemTypes, BaseItemKind.MusicGenre);
+        }
+
+        if (!query.IncludePeople)
+        {
+            AddIfMissing(excludeItemTypes, BaseItemKind.Person);
+        }
+
+        if (!query.IncludeStudios)
+        {
+            AddIfMissing(excludeItemTypes, BaseItemKind.Studio);
+        }
+
+        if (!query.IncludeArtists)
+        {
+            AddIfMissing(excludeItemTypes, BaseItemKind.MusicArtist);
+        }
+
+        return excludeItemTypes;
+    }
+
+    private static List<BaseItemKind> BuildIncludeItemTypes(SearchQuery query)
+    {
+        var includeItemTypes = query.IncludeItemTypes.ToList();
+        if (query.IncludeMedia)
+        {
+            return includeItemTypes;
+        }
+
+        if (query.IncludeGenres && IsEmptyOrContains(includeItemTypes, BaseItemKind.Genre))
+        {
+            AddIfMissing(includeItemTypes, BaseItemKind.Genre);
+            AddIfMissing(includeItemTypes, BaseItemKind.MusicGenre);
+        }
+
+        if (query.IncludePeople && IsEmptyOrContains(includeItemTypes, BaseItemKind.Person))
+        {
+            AddIfMissing(includeItemTypes, BaseItemKind.Person);
+        }
+
+        if (query.IncludeStudios && IsEmptyOrContains(includeItemTypes, BaseItemKind.Studio))
+        {
+            AddIfMissing(includeItemTypes, BaseItemKind.Studio);
+        }
+
+        if (query.IncludeArtists && IsEmptyOrContains(includeItemTypes, BaseItemKind.MusicArtist))
+        {
+            AddIfMissing(includeItemTypes, BaseItemKind.MusicArtist);
+        }
+
+        return includeItemTypes;
+    }
+
+    private static bool IsEmptyOrContains(List<BaseItemKind> list, BaseItemKind value)
+        => list.Count == 0 || list.Contains(value);
+
+    private static void AddIfMissing(List<BaseItemKind> list, BaseItemKind value)
+    {
+        if (!list.Contains(value))
+        {
+            list.Add(value);
+        }
+    }
+}

Emby.Server.Implementations/Library/Search/SearchQueryAccessFilter.cs

@@ -0,0 +1,38 @@
+using Jellyfin.Database.Implementations.Entities;
+using Jellyfin.Extensions;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Library;
+
+namespace Emby.Server.Implementations.Library.Search;
+
+/// <summary>
+/// Builds the access filter that decides which items a search may return for a user.
+/// </summary>
+internal static class SearchQueryAccessFilter
+{
+    /// <summary>
+    /// Builds an access filter carrying the search's library access and type filters.
+    /// </summary>
+    /// <param name="user">The user the search runs for.</param>
+    /// <param name="query">The search query.</param>
+    /// <param name="libraryManager">The library manager.</param>
+    /// <returns>The access filter.</returns>
+    public static InternalItemsQuery Build(User user, SearchProviderQuery query, ILibraryManager libraryManager)
+    {
+        // The type filters have to travel with the access filter: a by-name item belongs to no
+        // library, so it carries no TopParentId to match, and the library filter only knows to
+        // exempt it when the query says those types are wanted. A search scoped to a parent gets
+        // no exemption because a by-name item has no parent to descend from either.
+        var accessFilter = new InternalItemsQuery(user)
+        {
+            IncludeItemTypes = query.IncludeItemTypes,
+            ExcludeItemTypes = query.ExcludeItemTypes,
+            IncludeItemsByName = !query.ParentId.HasValue || query.ParentId.Value.IsEmpty()
+        };
+
+        // ConfigureUserAccess populates TopParentIds for the libraries the user may open.
+        libraryManager.ConfigureUserAccess(accessFilter, user);
+
+        return accessFilter;
+    }
+}

Emby.Server.Implementations/Library/Search/SqlSearchProvider.cs

@@ -0,0 +1,230 @@
+#pragma warning disable RS0030 // Do not use banned APIs
+#pragma warning disable CA1862 // Use the 'StringComparison' method overloads to perform case-insensitive string comparisons
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Data.Enums;
+using Jellyfin.Database.Implementations;
+using Jellyfin.Database.Implementations.Entities;
+using Jellyfin.Extensions;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Persistence;
+using MediaBrowser.Model.Configuration;
+using Microsoft.EntityFrameworkCore;
+
+namespace Emby.Server.Implementations.Library.Search;
+
+/// <summary>
+/// Built-in SQL-based search provider that queries the library database directly.
+/// </summary>
+public class SqlSearchProvider : IInternalSearchProvider
+{
+    private const int DefaultSearchLimit = 100;
+    private const float ExactMatchScore = 100f;
+    private const float PrefixMatchScore = 80f;
+    private const float WordPrefixMatchScore = 75f;
+    private const float ContainsMatchScore = 50f;
+
+    private static readonly Guid _placeholderId = Guid.Parse("00000000-0000-0000-0000-000000000001");
+
+    private readonly IDbContextFactory<JellyfinDbContext> _dbProvider;
+    private readonly IItemTypeLookup _itemTypeLookup;
+    private readonly ILibraryManager _libraryManager;
+    private readonly IUserManager _userManager;
+    private readonly IItemQueryHelpers _queryHelpers;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="SqlSearchProvider"/> class.
+    /// </summary>
+    /// <param name="dbProvider">The database context factory.</param>
+    /// <param name="itemTypeLookup">The item type lookup.</param>
+    /// <param name="libraryManager">The library manager.</param>
+    /// <param name="userManager">The user manager.</param>
+    /// <param name="queryHelpers">The shared item query helpers.</param>
+    public SqlSearchProvider(
+        IDbContextFactory<JellyfinDbContext> dbProvider,
+        IItemTypeLookup itemTypeLookup,
+        ILibraryManager libraryManager,
+        IUserManager userManager,
+        IItemQueryHelpers queryHelpers)
+    {
+        _dbProvider = dbProvider;
+        _itemTypeLookup = itemTypeLookup;
+        _libraryManager = libraryManager;
+        _userManager = userManager;
+        _queryHelpers = queryHelpers;
+    }
+
+    /// <inheritdoc/>
+    public string Name => "Database";
+
+    /// <inheritdoc/>
+    public MetadataPluginType Type => MetadataPluginType.SearchProvider;
+
+    /// <inheritdoc/>
+    public int Priority => 100; // Low priority - runs as fallback
+
+    /// <inheritdoc/>
+    public bool CanSearch(SearchProviderQuery query)
+    {
+        // SQL search can always handle any query
+        return true;
+    }
+
+    /// <inheritdoc/>
+    public async Task<IReadOnlyList<SearchResult>> SearchAsync(SearchProviderQuery query, CancellationToken cancellationToken)
+    {
+        ArgumentNullException.ThrowIfNull(query);
+        ArgumentException.ThrowIfNullOrWhiteSpace(query.SearchTerm);
+
+        var rawSearchTerm = query.SearchTerm.Trim().RemoveDiacritics();
+        if (string.IsNullOrEmpty(rawSearchTerm))
+        {
+            return [];
+        }
+
+        var cleanSearchTerm = rawSearchTerm.GetCleanValue();
+        if (string.IsNullOrEmpty(cleanSearchTerm))
+        {
+            return [];
+        }
+
+        var cleanPrefix = cleanSearchTerm + " ";
+        // OriginalTitle is stored mixed-case and isn't pre-normalized like CleanName,
+        // so match it via a case-insensitive LIKE rather than a per-row case conversion
+        // that may not translate to SQL on every provider.
+        var likeOriginal = $"%{rawSearchTerm}%";
+        var limit = query.Limit ?? DefaultSearchLimit;
+
+        var dbContext = await _dbProvider.CreateDbContextAsync(cancellationToken).ConfigureAwait(false);
+        await using (dbContext.ConfigureAwait(false))
+        {
+            // Lightweight projection: select only what's needed to score and identify items.
+            var dbQuery = dbContext.BaseItems
+                .AsNoTracking()
+                .Where(e => e.Id != _placeholderId)
+                .Where(e => !e.IsVirtualItem)
+                .Where(e => e.CleanName!.Contains(cleanSearchTerm)
+                    || (e.OriginalTitle != null && EF.Functions.Like(e.OriginalTitle, likeOriginal)));
+
+            dbQuery = ApplyTypeFilter(dbQuery, query.IncludeItemTypes, query.ExcludeItemTypes);
+            dbQuery = ApplyMediaTypeFilter(dbQuery, query.MediaTypes);
+            dbQuery = ApplyParentFilter(dbQuery, query.ParentId);
+            dbQuery = ApplyUserAccessFilter(dbContext, dbQuery, query);
+
+            // Compute the score in SQL: the ternary translates to a CASE WHEN. CleanName is
+            // the pre-normalized (lowercase, diacritic-stripped) form, so we score against it
+            // directly without any per-row case conversion. Items that match only via
+            // OriginalTitle fall through to the Contains tier.
+            // Tie-break by Id for deterministic ordering so the explicit OrderBy + Take
+            // satisfies EF Core's row-limiting-with-OrderBy requirement.
+            var scored = dbQuery.Select(e => new
+            {
+                e.Id,
+                Score =
+                    (e.CleanName == cleanSearchTerm) ? ExactMatchScore
+                    : e.CleanName!.StartsWith(cleanSearchTerm) ? PrefixMatchScore
+                    : e.CleanName!.Contains(cleanPrefix) ? WordPrefixMatchScore
+                    : ContainsMatchScore
+            });
+
+            return await scored
+                .OrderByDescending(x => x.Score)
+                .ThenBy(x => x.Id)
+                .Take(limit)
+                .Select(x => new SearchResult(x.Id, x.Score))
+                .ToArrayAsync(cancellationToken)
+                .ConfigureAwait(false);
+        }
+    }
+
+    private IQueryable<BaseItemEntity> ApplyTypeFilter(
+        IQueryable<BaseItemEntity> query,
+        BaseItemKind[] includeItemTypes,
+        BaseItemKind[] excludeItemTypes)
+    {
+        if (includeItemTypes.Length > 0)
+        {
+            var includeTypeNames = MapKindsToTypeNames(includeItemTypes);
+            if (includeTypeNames.Count > 0)
+            {
+                query = query.Where(e => includeTypeNames.Contains(e.Type));
+            }
+        }
+        else if (excludeItemTypes.Length > 0)
+        {
+            var excludeTypeNames = MapKindsToTypeNames(excludeItemTypes);
+            if (excludeTypeNames.Count > 0)
+            {
+                query = query.Where(e => !excludeTypeNames.Contains(e.Type));
+            }
+        }
+
+        return query;
+    }
+
+    private static IQueryable<BaseItemEntity> ApplyMediaTypeFilter(
+        IQueryable<BaseItemEntity> query,
+        MediaType[] mediaTypes)
+    {
+        if (mediaTypes.Length == 0)
+        {
+            return query;
+        }
+
+        var mediaTypeNames = mediaTypes.Select(m => m.ToString()).ToArray();
+        return query.Where(e => e.MediaType != null && mediaTypeNames.Contains(e.MediaType));
+    }
+
+    private static IQueryable<BaseItemEntity> ApplyParentFilter(
+        IQueryable<BaseItemEntity> query,
+        Guid? parentId)
+    {
+        if (!parentId.HasValue || parentId.Value.IsEmpty())
+        {
+            return query;
+        }
+
+        var pid = parentId.Value;
+        return query.Where(e => e.ParentId == pid || e.Parents!.Any(p => p.ParentItemId == pid));
+    }
+
+    private IQueryable<BaseItemEntity> ApplyUserAccessFilter(
+        JellyfinDbContext dbContext,
+        IQueryable<BaseItemEntity> query,
+        SearchProviderQuery searchQuery)
+    {
+        var userId = searchQuery.UserId;
+        if (!userId.HasValue || userId.Value.IsEmpty())
+        {
+            return query;
+        }
+
+        var user = _userManager.GetUserById(userId.Value);
+        if (user is null)
+        {
+            return query;
+        }
+
+        var accessFilter = SearchQueryAccessFilter.Build(user, searchQuery, _libraryManager);
+        return _queryHelpers.ApplyAccessFiltering(dbContext, query, accessFilter);
+    }
+
+    private List<string> MapKindsToTypeNames(BaseItemKind[] kinds)
+    {
+        var list = new List<string>(kinds.Length);
+        foreach (var kind in kinds)
+        {
+            if (_itemTypeLookup.BaseItemKindNames.TryGetValue(kind, out var name) && name is not null)
+            {
+                list.Add(name);
+            }
+        }
+
+        return list;
+    }
+}

Emby.Server.Implementations/Library/SearchEngine.cs

@@ -1,200 +0,0 @@
-#pragma warning disable CS1591
-
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using Jellyfin.Data.Enums;
-using Jellyfin.Database.Implementations.Entities;
-using Jellyfin.Database.Implementations.Enums;
-using Jellyfin.Extensions;
-using MediaBrowser.Controller.Dto;
-using MediaBrowser.Controller.Entities;
-using MediaBrowser.Controller.Library;
-using MediaBrowser.Model.Querying;
-using MediaBrowser.Model.Search;
-
-namespace Emby.Server.Implementations.Library
-{
-    public class SearchEngine : ISearchEngine
-    {
-        private readonly ILibraryManager _libraryManager;
-        private readonly IUserManager _userManager;
-
-        public SearchEngine(ILibraryManager libraryManager, IUserManager userManager)
-        {
-            _libraryManager = libraryManager;
-            _userManager = userManager;
-        }
-
-        public QueryResult<SearchHintInfo> GetSearchHints(SearchQuery query)
-        {
-            User? user = null;
-            if (!query.UserId.IsEmpty())
-            {
-                user = _userManager.GetUserById(query.UserId);
-            }
-
-            var results = GetSearchHints(query, user);
-            var totalRecordCount = results.Count;
-
-            if (query.StartIndex.HasValue)
-            {
-                results = results.GetRange(query.StartIndex.Value, totalRecordCount - query.StartIndex.Value);
-            }
-
-            if (query.Limit.HasValue)
-            {
-                results = results.GetRange(0, Math.Min(query.Limit.Value, results.Count));
-            }
-
-            return new QueryResult<SearchHintInfo>(
-                query.StartIndex,
-                totalRecordCount,
-                results);
-        }
-
-        private static void AddIfMissing(List<BaseItemKind> list, BaseItemKind value)
-        {
-            if (!list.Contains(value))
-            {
-                list.Add(value);
-            }
-        }
-
-        /// <summary>
-        /// Gets the search hints.
-        /// </summary>
-        /// <param name="query">The query.</param>
-        /// <param name="user">The user.</param>
-        /// <returns>IEnumerable{SearchHintResult}.</returns>
-        /// <exception cref="ArgumentException"><c>query.SearchTerm</c> is <c>null</c> or empty.</exception>
-        private List<SearchHintInfo> GetSearchHints(SearchQuery query, User? user)
-        {
-            var searchTerm = query.SearchTerm;
-
-            ArgumentException.ThrowIfNullOrEmpty(searchTerm);
-
-            searchTerm = searchTerm.Trim().RemoveDiacritics();
-
-            var excludeItemTypes = query.ExcludeItemTypes.ToList();
-            var includeItemTypes = query.IncludeItemTypes.ToList();
-
-            excludeItemTypes.Add(BaseItemKind.Year);
-            excludeItemTypes.Add(BaseItemKind.Folder);
-
-            if (query.IncludeGenres && (includeItemTypes.Count == 0 || includeItemTypes.Contains(BaseItemKind.Genre)))
-            {
-                if (!query.IncludeMedia)
-                {
-                    AddIfMissing(includeItemTypes, BaseItemKind.Genre);
-                    AddIfMissing(includeItemTypes, BaseItemKind.MusicGenre);
-                }
-            }
-            else
-            {
-                AddIfMissing(excludeItemTypes, BaseItemKind.Genre);
-                AddIfMissing(excludeItemTypes, BaseItemKind.MusicGenre);
-            }
-
-            if (query.IncludePeople && (includeItemTypes.Count == 0 || includeItemTypes.Contains(BaseItemKind.Person)))
-            {
-                if (!query.IncludeMedia)
-                {
-                    AddIfMissing(includeItemTypes, BaseItemKind.Person);
-                }
-            }
-            else
-            {
-                AddIfMissing(excludeItemTypes, BaseItemKind.Person);
-            }
-
-            if (query.IncludeStudios && (includeItemTypes.Count == 0 || includeItemTypes.Contains(BaseItemKind.Studio)))
-            {
-                if (!query.IncludeMedia)
-                {
-                    AddIfMissing(includeItemTypes, BaseItemKind.Studio);
-                }
-            }
-            else
-            {
-                AddIfMissing(excludeItemTypes, BaseItemKind.Studio);
-            }
-
-            if (query.IncludeArtists && (includeItemTypes.Count == 0 || includeItemTypes.Contains(BaseItemKind.MusicArtist)))
-            {
-                if (!query.IncludeMedia)
-                {
-                    AddIfMissing(includeItemTypes, BaseItemKind.MusicArtist);
-                }
-            }
-            else
-            {
-                AddIfMissing(excludeItemTypes, BaseItemKind.MusicArtist);
-            }
-
-            AddIfMissing(excludeItemTypes, BaseItemKind.CollectionFolder);
-            AddIfMissing(excludeItemTypes, BaseItemKind.Folder);
-            var mediaTypes = query.MediaTypes.ToList();
-
-            if (includeItemTypes.Count > 0)
-            {
-                excludeItemTypes.Clear();
-                mediaTypes.Clear();
-            }
-
-            var searchQuery = new InternalItemsQuery(user)
-            {
-                SearchTerm = searchTerm,
-                ExcludeItemTypes = excludeItemTypes.ToArray(),
-                IncludeItemTypes = includeItemTypes.ToArray(),
-                Limit = query.Limit,
-                IncludeItemsByName = !query.ParentId.HasValue,
-                ParentId = query.ParentId ?? Guid.Empty,
-                OrderBy = new[] { (ItemSortBy.SortName, SortOrder.Ascending) },
-                Recursive = true,
-
-                IsKids = query.IsKids,
-                IsMovie = query.IsMovie,
-                IsNews = query.IsNews,
-                IsSeries = query.IsSeries,
-                IsSports = query.IsSports,
-                MediaTypes = mediaTypes.ToArray(),
-
-                DtoOptions = new DtoOptions
-                {
-                    Fields = new ItemFields[]
-                    {
-                        ItemFields.AirTime,
-                        ItemFields.DateCreated,
-                        ItemFields.ChannelInfo,
-                        ItemFields.ParentId
-                    }
-                }
-            };
-
-            IReadOnlyList<BaseItem> mediaItems;
-
-            if (searchQuery.IncludeItemTypes.Length == 1 && searchQuery.IncludeItemTypes[0] == BaseItemKind.MusicArtist)
-            {
-                if (!searchQuery.ParentId.IsEmpty())
-                {
-                    searchQuery.AncestorIds = [searchQuery.ParentId];
-                    searchQuery.ParentId = Guid.Empty;
-                }
-
-                searchQuery.IncludeItemsByName = true;
-                searchQuery.IncludeItemTypes = Array.Empty<BaseItemKind>();
-                mediaItems = _libraryManager.GetAllArtists(searchQuery).Items.Select(i => i.Item).ToList();
-            }
-            else
-            {
-                mediaItems = _libraryManager.GetItemList(searchQuery);
-            }
-
-            return mediaItems.Select(i => new SearchHintInfo
-            {
-                Item = i
-            }).ToList();
-        }
-    }
-}

Emby.Server.Implementations/Library/SimilarItems/AudioSimilarItemsProvider.cs

@@ -0,0 +1,55 @@
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Data.Enums;
+using Jellyfin.Database.Implementations.Enums;
+using MediaBrowser.Controller.Dto;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Entities.Audio;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Model.Configuration;
+
+namespace Emby.Server.Implementations.Library.SimilarItems;
+
+/// <summary>
+/// Provides similar items for audio tracks.
+/// </summary>
+public class AudioSimilarItemsProvider : ILocalSimilarItemsProvider<Audio>
+{
+    private readonly ILibraryManager _libraryManager;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="AudioSimilarItemsProvider"/> class.
+    /// </summary>
+    /// <param name="libraryManager">The library manager.</param>
+    public AudioSimilarItemsProvider(ILibraryManager libraryManager)
+    {
+        _libraryManager = libraryManager;
+    }
+
+    /// <inheritdoc/>
+    public string Name => "Local Genre/Tag";
+
+    /// <inheritdoc/>
+    public MetadataPluginType Type => MetadataPluginType.LocalSimilarityProvider;
+
+    /// <inheritdoc/>
+    public Task<IReadOnlyList<BaseItem>> GetSimilarItemsAsync(Audio item, SimilarItemsQuery query, CancellationToken cancellationToken)
+    {
+        var internalQuery = new InternalItemsQuery(query.User)
+        {
+            Genres = item.Genres,
+            Tags = item.Tags,
+            Limit = query.Limit,
+            DtoOptions = query.DtoOptions ?? new DtoOptions(),
+            ExcludeItemIds = [.. query.ExcludeItemIds],
+            ExcludeArtistIds = [.. query.ExcludeArtistIds],
+            IncludeItemTypes = [BaseItemKind.Audio],
+            EnableGroupByMetadataKey = false,
+            EnableTotalRecordCount = true,
+            OrderBy = [(ItemSortBy.Random, SortOrder.Ascending)]
+        };
+
+        return Task.FromResult(_libraryManager.GetItemList(internalQuery));
+    }
+}

Emby.Server.Implementations/Library/SimilarItems/LiveTvProgramSimilarItemsProvider.cs

@@ -0,0 +1,94 @@
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Data.Enums;
+using Jellyfin.Database.Implementations.Enums;
+using MediaBrowser.Controller.Configuration;
+using MediaBrowser.Controller.Dto;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.LiveTv;
+using MediaBrowser.Model.Configuration;
+
+namespace Emby.Server.Implementations.Library.SimilarItems;
+
+/// <summary>
+/// Provides similar items for Live TV programs.
+/// </summary>
+public class LiveTvProgramSimilarItemsProvider : ILocalSimilarItemsProvider<LiveTvProgram>
+{
+    private readonly ILibraryManager _libraryManager;
+    private readonly IServerConfigurationManager _serverConfigurationManager;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="LiveTvProgramSimilarItemsProvider"/> class.
+    /// </summary>
+    /// <param name="libraryManager">The library manager.</param>
+    /// <param name="serverConfigurationManager">The server configuration manager.</param>
+    public LiveTvProgramSimilarItemsProvider(
+        ILibraryManager libraryManager,
+        IServerConfigurationManager serverConfigurationManager)
+    {
+        _libraryManager = libraryManager;
+        _serverConfigurationManager = serverConfigurationManager;
+    }
+
+    /// <inheritdoc/>
+    public string Name => "Local Genre/Tag";
+
+    /// <inheritdoc/>
+    public MetadataPluginType Type => MetadataPluginType.LocalSimilarityProvider;
+
+    /// <inheritdoc/>
+    public Task<IReadOnlyList<BaseItem>> GetSimilarItemsAsync(LiveTvProgram item, SimilarItemsQuery query, CancellationToken cancellationToken)
+    {
+        BaseItemKind[] includeItemTypes;
+        bool enableGroupByMetadataKey;
+        bool enableTotalRecordCount;
+
+        if (item.IsMovie)
+        {
+            // Movie-like program
+            var itemTypes = new List<BaseItemKind> { BaseItemKind.Movie };
+
+            if (_serverConfigurationManager.Configuration.EnableExternalContentInSuggestions)
+            {
+                itemTypes.Add(BaseItemKind.Trailer);
+                itemTypes.Add(BaseItemKind.LiveTvProgram);
+            }
+
+            includeItemTypes = [.. itemTypes];
+            enableGroupByMetadataKey = true;
+            enableTotalRecordCount = false;
+        }
+        else if (item.IsSeries)
+        {
+            // Series-like program
+            includeItemTypes = [BaseItemKind.Series];
+            enableGroupByMetadataKey = false;
+            enableTotalRecordCount = true;
+        }
+        else
+        {
+            // Default - match same type
+            includeItemTypes = [item.GetBaseItemKind()];
+            enableGroupByMetadataKey = false;
+            enableTotalRecordCount = true;
+        }
+
+        var internalQuery = new InternalItemsQuery(query.User)
+        {
+            Genres = item.Genres,
+            Tags = item.Tags,
+            Limit = query.Limit,
+            DtoOptions = query.DtoOptions ?? new DtoOptions(),
+            ExcludeItemIds = [.. query.ExcludeItemIds],
+            IncludeItemTypes = includeItemTypes,
+            EnableGroupByMetadataKey = enableGroupByMetadataKey,
+            EnableTotalRecordCount = enableTotalRecordCount,
+            OrderBy = [(ItemSortBy.Random, SortOrder.Ascending)]
+        };
+
+        return Task.FromResult(_libraryManager.GetItemList(internalQuery));
+    }
+}

Emby.Server.Implementations/Library/SimilarItems/MovieSimilarItemsProvider.cs

@@ -0,0 +1,343 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Data.Enums;
+using Jellyfin.Database.Implementations;
+using Jellyfin.Database.Implementations.Entities;
+using Jellyfin.Extensions;
+using MediaBrowser.Controller.Configuration;
+using MediaBrowser.Controller.Dto;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Entities.Movies;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Persistence;
+using MediaBrowser.Model.Configuration;
+using Microsoft.EntityFrameworkCore;
+using BaseItemDto = MediaBrowser.Controller.Entities.BaseItem;
+
+namespace Emby.Server.Implementations.Library.SimilarItems;
+
+/// <summary>
+/// Provides similar items for movies and trailers using weighted scoring.
+/// </summary>
+public sealed class MovieSimilarItemsProvider : ILocalSimilarItemsProvider<Movie>, ILocalSimilarItemsProvider<Trailer>, IBatchLocalSimilarItemsProvider
+{
+    private const int GenreWeight = 10;
+    private const int TagWeight = 5;
+    private const int StudioWeight = 5;
+    private const int DirectorWeight = 50;
+    private const int ActorWeight = 15;
+
+    // Caps the batch fan-out so downstream IN-list sizes (per-source scores, accessible-id
+    // load, navigation includes) stay bounded regardless of caller input.
+    private const int MaxBatchSourceItems = 64;
+
+    private static readonly (ItemValueType Type, int Weight)[] _itemValueDimensions =
+    [
+        (ItemValueType.Genre, GenreWeight),
+        (ItemValueType.Tags, TagWeight),
+        (ItemValueType.Studios, StudioWeight)
+    ];
+
+    private static readonly Dictionary<string, int> _personTypeWeights = new(StringComparer.Ordinal)
+    {
+        [nameof(PersonKind.Director)] = DirectorWeight,
+        [nameof(PersonKind.Actor)] = ActorWeight,
+        [nameof(PersonKind.GuestStar)] = ActorWeight,
+    };
+
+    private static readonly string[] _scoredPersonTypes = [.. _personTypeWeights.Keys];
+
+    private readonly IDbContextFactory<JellyfinDbContext> _dbProvider;
+    private readonly IItemQueryHelpers _queryHelpers;
+    private readonly IServerConfigurationManager _serverConfigurationManager;
+    private readonly ILibraryManager _libraryManager;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="MovieSimilarItemsProvider"/> class.
+    /// </summary>
+    /// <param name="dbProvider">The database context factory.</param>
+    /// <param name="queryHelpers">The shared query helpers.</param>
+    /// <param name="serverConfigurationManager">The server configuration manager.</param>
+    /// <param name="libraryManager">The library manager.</param>
+    public MovieSimilarItemsProvider(
+        IDbContextFactory<JellyfinDbContext> dbProvider,
+        IItemQueryHelpers queryHelpers,
+        IServerConfigurationManager serverConfigurationManager,
+        ILibraryManager libraryManager)
+    {
+        _dbProvider = dbProvider;
+        _queryHelpers = queryHelpers;
+        _serverConfigurationManager = serverConfigurationManager;
+        _libraryManager = libraryManager;
+    }
+
+    /// <inheritdoc/>
+    public string Name => "Local Genre/Tag";
+
+    /// <inheritdoc/>
+    public MetadataPluginType Type => MetadataPluginType.LocalSimilarityProvider;
+
+    /// <inheritdoc/>
+    public async Task<IReadOnlyList<BaseItemDto>> GetSimilarItemsAsync(Movie item, SimilarItemsQuery query, CancellationToken cancellationToken)
+    {
+        var results = await GetBatchSimilarItemsAsync([item], query, cancellationToken).ConfigureAwait(false);
+        return results.TryGetValue(item.Id, out var items) ? items : [];
+    }
+
+    /// <inheritdoc/>
+    public async Task<IReadOnlyList<BaseItemDto>> GetSimilarItemsAsync(Trailer item, SimilarItemsQuery query, CancellationToken cancellationToken)
+    {
+        var results = await GetBatchSimilarItemsAsync([item], query, cancellationToken).ConfigureAwait(false);
+        return results.TryGetValue(item.Id, out var items) ? items : [];
+    }
+
+    bool ILocalSimilarItemsProvider.Supports(Type itemType)
+        => typeof(Movie).IsAssignableFrom(itemType) || typeof(Trailer).IsAssignableFrom(itemType);
+
+    Task<IReadOnlyList<BaseItem>> ILocalSimilarItemsProvider.GetSimilarItemsAsync(BaseItem item, SimilarItemsQuery query, CancellationToken cancellationToken)
+        => item switch
+        {
+            Movie movie => GetSimilarItemsAsync(movie, query, cancellationToken),
+            Trailer trailer => GetSimilarItemsAsync(trailer, query, cancellationToken),
+            _ => throw new ArgumentException($"Unsupported item type {item.GetType()}", nameof(item))
+        };
+
+    /// <inheritdoc/>
+    public async Task<Dictionary<Guid, IReadOnlyList<BaseItemDto>>> GetBatchSimilarItemsAsync(
+        IReadOnlyList<BaseItemDto> sourceItems,
+        SimilarItemsQuery query,
+        CancellationToken cancellationToken)
+    {
+        var includeItemTypes = new List<BaseItemKind> { BaseItemKind.Movie };
+        if (_serverConfigurationManager.Configuration.EnableExternalContentInSuggestions)
+        {
+            includeItemTypes.Add(BaseItemKind.Trailer);
+            includeItemTypes.Add(BaseItemKind.LiveTvProgram);
+        }
+
+        var limit = query.Limit ?? 50;
+        var dtoOptions = query.DtoOptions ?? new DtoOptions();
+
+        if (sourceItems.Count > MaxBatchSourceItems)
+        {
+            sourceItems = sourceItems.Take(MaxBatchSourceItems).ToList();
+        }
+
+        var context = await _dbProvider.CreateDbContextAsync(cancellationToken).ConfigureAwait(false);
+        await using (context.ConfigureAwait(false))
+        {
+            // Phase 1: Score all candidates per source item
+            var sourceIds = sourceItems.Select(i => i.Id).ToList();
+            var perSourceScores = await ComputeBatchScoresAsync(sourceIds, context, cancellationToken).ConfigureAwait(false);
+
+            var allCandidateIds = new HashSet<Guid>();
+            foreach (var (_, scores) in perSourceScores)
+            {
+                allCandidateIds.UnionWith(
+                    scores.OrderByDescending(kvp => kvp.Value)
+                        .Take(limit * 3)
+                        .Select(kvp => kvp.Key));
+            }
+
+            var result = new Dictionary<Guid, IReadOnlyList<BaseItemDto>>();
+            if (allCandidateIds.Count == 0)
+            {
+                return result;
+            }
+
+            // Phase 2: One access filter for all candidates
+            var filter = new InternalItemsQuery(query.User)
+            {
+                IncludeItemTypes = [.. includeItemTypes],
+                ExcludeItemIds = [.. query.ExcludeItemIds],
+                DtoOptions = dtoOptions,
+                EnableGroupByMetadataKey = true,
+                EnableTotalRecordCount = false,
+                IsMovie = true,
+                IsPlayed = false
+            };
+
+            if (query.User is not null)
+            {
+                _libraryManager.ConfigureUserAccess(filter, query.User);
+            }
+
+            _queryHelpers.PrepareFilterQuery(filter);
+            var baseQuery = _queryHelpers.PrepareItemQuery(context, filter);
+            baseQuery = _queryHelpers.TranslateQuery(baseQuery, context, filter);
+
+            var allCandidateIdsList = allCandidateIds.ToList();
+            var accessibleItems = await baseQuery
+                .WhereOneOrMany(allCandidateIdsList, e => e.Id)
+                .Select(e => new { e.Id, e.PresentationUniqueKey })
+                .ToListAsync(cancellationToken).ConfigureAwait(false);
+
+            // Phase 3: Pick top IDs per source, dedup by PresentationUniqueKey
+            var allOrderedIds = new HashSet<Guid>();
+            var perSourceOrderedIds = new Dictionary<Guid, List<Guid>>();
+
+            foreach (var item in sourceItems)
+            {
+                if (!perSourceScores.TryGetValue(item.Id, out var scores))
+                {
+                    continue;
+                }
+
+                var orderedIds = accessibleItems
+                    .Where(x => scores.ContainsKey(x.Id))
+                    .OrderByDescending(x => scores.GetValueOrDefault(x.Id))
+                    .DistinctBy(x => x.PresentationUniqueKey)
+                    .Take(limit)
+                    .Select(x => x.Id)
+                    .ToList();
+
+                if (orderedIds.Count > 0)
+                {
+                    perSourceOrderedIds[item.Id] = orderedIds;
+                    allOrderedIds.UnionWith(orderedIds);
+                }
+            }
+
+            if (allOrderedIds.Count == 0)
+            {
+                return result;
+            }
+
+            // Phase 4: One entity load for all results
+            var allOrderedIdsList = allOrderedIds.ToList();
+            var entities = await _queryHelpers.ApplyNavigations(
+                    context.BaseItems.AsNoTracking().WhereOneOrMany(allOrderedIdsList, e => e.Id),
+                    filter)
+                .AsSplitQuery()
+                .ToListAsync(cancellationToken).ConfigureAwait(false);
+
+            var entitiesById = entities
+                .Select(e => _queryHelpers.DeserializeBaseItem(e, filter.SkipDeserialization))
+                .Where(dto => dto is not null)
+                .ToDictionary(i => i!.Id);
+
+            // Phase 5: Split by source, preserving score order
+            foreach (var (sourceId, orderedIds) in perSourceOrderedIds)
+            {
+                var items = orderedIds
+                    .Where(entitiesById.ContainsKey)
+                    .Select(id => entitiesById[id]!)
+                    .ToList();
+
+                if (items.Count > 0)
+                {
+                    result[sourceId] = items;
+                }
+            }
+
+            return result;
+        }
+    }
+
+    private static async Task<Dictionary<Guid, Dictionary<Guid, int>>> ComputeBatchScoresAsync(List<Guid> sourceIds, JellyfinDbContext context, CancellationToken cancellationToken)
+    {
+        var result = new Dictionary<Guid, Dictionary<Guid, int>>();
+        foreach (var id in sourceIds)
+        {
+            result[id] = [];
+        }
+
+        foreach (var (valueType, weight) in _itemValueDimensions)
+        {
+            var sourceRows = await context.ItemValuesMap.AsNoTracking()
+                .Where(m => sourceIds.Contains(m.ItemId) && m.ItemValue.Type == valueType)
+                .Select(m => new { m.ItemId, Key = m.ItemValue.CleanValue })
+                .ToListAsync(cancellationToken).ConfigureAwait(false);
+
+            var sourceMap = sourceRows.GroupBy(r => r.ItemId).ToDictionary(g => g.Key, g => g.Select(x => x.Key).ToHashSet());
+            var allKeys = sourceMap.Values.SelectMany(v => v).Distinct().ToList();
+            if (allKeys.Count == 0)
+            {
+                continue;
+            }
+
+            var candidateRows = await context.ItemValuesMap.AsNoTracking()
+                .Where(m => !m.Item.PrimaryVersionId.HasValue && m.ItemValue.Type == valueType && allKeys.Contains(m.ItemValue.CleanValue))
+                .Select(m => new { m.ItemId, Key = m.ItemValue.CleanValue })
+                .ToListAsync(cancellationToken).ConfigureAwait(false);
+
+            var keyToCandidates = candidateRows.GroupBy(r => r.Key).ToDictionary(g => g.Key, g => g.Select(x => x.ItemId).ToList());
+            ApplyDimensionScores(sourceIds, sourceMap, keyToCandidates, weight, result);
+        }
+
+        var personSourceRows = await context.PeopleBaseItemMap.AsNoTracking()
+            .Where(m => sourceIds.Contains(m.ItemId) && _scoredPersonTypes.Contains(m.People.PersonType))
+            .Select(m => new { m.ItemId, m.PeopleId, m.People.PersonType })
+            .ToListAsync(cancellationToken).ConfigureAwait(false);
+
+        if (personSourceRows.Count > 0)
+        {
+            var personCandidateRows = await context.PeopleBaseItemMap.AsNoTracking()
+                .Where(m => !m.Item.PrimaryVersionId.HasValue)
+                .Where(m => context.PeopleBaseItemMap
+                    .Where(s => sourceIds.Contains(s.ItemId) && _scoredPersonTypes.Contains(s.People.PersonType))
+                    .Select(s => s.PeopleId)
+                    .Contains(m.PeopleId))
+                .Select(m => new { m.ItemId, m.PeopleId })
+                .ToListAsync(cancellationToken).ConfigureAwait(false);
+
+            var personToCandidates = personCandidateRows
+                .GroupBy(r => r.PeopleId)
+                .ToDictionary(g => g.Key, g => g.Select(x => x.ItemId).ToList());
+
+            foreach (var weightGroup in personSourceRows.GroupBy(r => _personTypeWeights[r.PersonType!]))
+            {
+                var sourceMap = weightGroup
+                    .GroupBy(r => r.ItemId)
+                    .ToDictionary(g => g.Key, g => g.Select(x => x.PeopleId).ToHashSet());
+                ApplyDimensionScores(sourceIds, sourceMap, personToCandidates, weightGroup.Key, result);
+            }
+        }
+
+        foreach (var sourceId in sourceIds)
+        {
+            var scoreMap = result[sourceId];
+            scoreMap.Remove(sourceId);
+            if (scoreMap.Count == 0)
+            {
+                result.Remove(sourceId);
+            }
+        }
+
+        return result;
+    }
+
+    private static void ApplyDimensionScores<TKey>(
+        List<Guid> sourceIds,
+        Dictionary<Guid, HashSet<TKey>> sourceMap,
+        Dictionary<TKey, List<Guid>> keyToCandidates,
+        int weight,
+        Dictionary<Guid, Dictionary<Guid, int>> result)
+        where TKey : notnull
+    {
+        foreach (var sourceId in sourceIds)
+        {
+            if (!sourceMap.TryGetValue(sourceId, out var sourceKeys))
+            {
+                continue;
+            }
+
+            var scoreMap = result[sourceId];
+            foreach (var key in sourceKeys)
+            {
+                if (!keyToCandidates.TryGetValue(key, out var candidates))
+                {
+                    continue;
+                }
+
+                foreach (var candidateId in candidates)
+                {
+                    scoreMap[candidateId] = scoreMap.GetValueOrDefault(candidateId) + weight;
+                }
+            }
+        }
+    }
+}

Emby.Server.Implementations/Library/SimilarItems/MusicAlbumSimilarItemsProvider.cs

@@ -0,0 +1,55 @@
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Data.Enums;
+using Jellyfin.Database.Implementations.Enums;
+using MediaBrowser.Controller.Dto;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Entities.Audio;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Model.Configuration;
+
+namespace Emby.Server.Implementations.Library.SimilarItems;
+
+/// <summary>
+/// Provides similar items for music albums.
+/// </summary>
+public class MusicAlbumSimilarItemsProvider : ILocalSimilarItemsProvider<MusicAlbum>
+{
+    private readonly ILibraryManager _libraryManager;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="MusicAlbumSimilarItemsProvider"/> class.
+    /// </summary>
+    /// <param name="libraryManager">The library manager.</param>
+    public MusicAlbumSimilarItemsProvider(ILibraryManager libraryManager)
+    {
+        _libraryManager = libraryManager;
+    }
+
+    /// <inheritdoc/>
+    public string Name => "Local Genre/Tag";
+
+    /// <inheritdoc/>
+    public MetadataPluginType Type => MetadataPluginType.LocalSimilarityProvider;
+
+    /// <inheritdoc/>
+    public Task<IReadOnlyList<BaseItem>> GetSimilarItemsAsync(MusicAlbum item, SimilarItemsQuery query, CancellationToken cancellationToken)
+    {
+        var internalQuery = new InternalItemsQuery(query.User)
+        {
+            Genres = item.Genres,
+            Tags = item.Tags,
+            Limit = query.Limit,
+            DtoOptions = query.DtoOptions ?? new DtoOptions(),
+            ExcludeItemIds = [.. query.ExcludeItemIds],
+            ExcludeArtistIds = [.. query.ExcludeArtistIds],
+            IncludeItemTypes = [BaseItemKind.MusicAlbum],
+            EnableGroupByMetadataKey = false,
+            EnableTotalRecordCount = true,
+            OrderBy = [(ItemSortBy.Random, SortOrder.Ascending)]
+        };
+
+        return Task.FromResult(_libraryManager.GetItemList(internalQuery));
+    }
+}

Emby.Server.Implementations/Library/SimilarItems/MusicArtistSimilarItemsProvider.cs

@@ -0,0 +1,55 @@
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Data.Enums;
+using Jellyfin.Database.Implementations.Enums;
+using MediaBrowser.Controller.Dto;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Entities.Audio;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Model.Configuration;
+
+namespace Emby.Server.Implementations.Library.SimilarItems;
+
+/// <summary>
+/// Provides similar items for music artists.
+/// </summary>
+public class MusicArtistSimilarItemsProvider : ILocalSimilarItemsProvider<MusicArtist>
+{
+    private readonly ILibraryManager _libraryManager;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="MusicArtistSimilarItemsProvider"/> class.
+    /// </summary>
+    /// <param name="libraryManager">The library manager.</param>
+    public MusicArtistSimilarItemsProvider(ILibraryManager libraryManager)
+    {
+        _libraryManager = libraryManager;
+    }
+
+    /// <inheritdoc/>
+    public string Name => "Local Genre/Tag";
+
+    /// <inheritdoc/>
+    public MetadataPluginType Type => MetadataPluginType.LocalSimilarityProvider;
+
+    /// <inheritdoc/>
+    public Task<IReadOnlyList<BaseItem>> GetSimilarItemsAsync(MusicArtist item, SimilarItemsQuery query, CancellationToken cancellationToken)
+    {
+        var internalQuery = new InternalItemsQuery(query.User)
+        {
+            Genres = item.Genres,
+            Tags = item.Tags,
+            Limit = query.Limit,
+            DtoOptions = query.DtoOptions ?? new DtoOptions(),
+            ExcludeItemIds = [.. query.ExcludeItemIds],
+            ExcludeArtistIds = [.. query.ExcludeArtistIds],
+            IncludeItemTypes = [BaseItemKind.MusicArtist],
+            EnableGroupByMetadataKey = false,
+            EnableTotalRecordCount = true,
+            OrderBy = [(ItemSortBy.Random, SortOrder.Ascending)]
+        };
+
+        return Task.FromResult(_libraryManager.GetItemList(internalQuery));
+    }
+}

Emby.Server.Implementations/Library/SimilarItems/SeriesSimilarItemsProvider.cs

@@ -0,0 +1,54 @@
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Data.Enums;
+using Jellyfin.Database.Implementations.Enums;
+using MediaBrowser.Controller.Dto;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Entities.TV;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Model.Configuration;
+
+namespace Emby.Server.Implementations.Library.SimilarItems;
+
+/// <summary>
+/// Provides similar items for TV series.
+/// </summary>
+public class SeriesSimilarItemsProvider : ILocalSimilarItemsProvider<Series>
+{
+    private readonly ILibraryManager _libraryManager;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="SeriesSimilarItemsProvider"/> class.
+    /// </summary>
+    /// <param name="libraryManager">The library manager.</param>
+    public SeriesSimilarItemsProvider(ILibraryManager libraryManager)
+    {
+        _libraryManager = libraryManager;
+    }
+
+    /// <inheritdoc/>
+    public string Name => "Local Genre/Tag";
+
+    /// <inheritdoc/>
+    public MetadataPluginType Type => MetadataPluginType.LocalSimilarityProvider;
+
+    /// <inheritdoc/>
+    public Task<IReadOnlyList<BaseItem>> GetSimilarItemsAsync(Series item, SimilarItemsQuery query, CancellationToken cancellationToken)
+    {
+        var internalQuery = new InternalItemsQuery(query.User)
+        {
+            Genres = item.Genres,
+            Tags = item.Tags,
+            Limit = query.Limit,
+            DtoOptions = query.DtoOptions ?? new DtoOptions(),
+            ExcludeItemIds = [.. query.ExcludeItemIds],
+            IncludeItemTypes = [BaseItemKind.Series],
+            EnableGroupByMetadataKey = false,
+            EnableTotalRecordCount = true,
+            OrderBy = [(ItemSortBy.Random, SortOrder.Ascending)]
+        };
+
+        return Task.FromResult(_libraryManager.GetItemList(internalQuery));
+    }
+}

Emby.Server.Implementations/Library/SimilarItems/SimilarItemsAccessFilter.cs

@@ -0,0 +1,42 @@
+using Jellyfin.Data.Enums;
+using Jellyfin.Database.Implementations.Entities;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Library;
+
+namespace Emby.Server.Implementations.Library.SimilarItems;
+
+/// <summary>
+/// Builds the access filter that decides which items a similar-items lookup may return for a user.
+/// </summary>
+internal static class SimilarItemsAccessFilter
+{
+    private static readonly BaseItemKind[] _itemByNameKinds =
+    [
+        BaseItemKind.Person,
+        BaseItemKind.Genre,
+        BaseItemKind.MusicGenre,
+        BaseItemKind.MusicArtist,
+        BaseItemKind.Studio
+    ];
+
+    /// <summary>
+    /// Builds an access filter carrying the user's library access and parental restrictions.
+    /// </summary>
+    /// <param name="user">The user the lookup runs for.</param>
+    /// <param name="libraryManager">The library manager.</param>
+    /// <returns>The access filter.</returns>
+    public static InternalItemsQuery Build(User user, ILibraryManager libraryManager)
+    {
+        // IncludeItemTypes is read only for the by-name exemption here; the caller applies this
+        // filter through ApplyAccessFiltering, which does not translate it into a type restriction.
+        var accessFilter = new InternalItemsQuery(user)
+        {
+            IncludeItemTypes = _itemByNameKinds
+        };
+
+        // ConfigureUserAccess populates TopParentIds for the libraries the user may open.
+        libraryManager.ConfigureUserAccess(accessFilter, user);
+
+        return accessFilter;
+    }
+}

Emby.Server.Implementations/Library/SimilarItems/SimilarItemsManager.cs

@@ -0,0 +1,724 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Text.Json;
+using System.Threading;
+using System.Threading.Tasks;
+using Jellyfin.Data.Enums;
+using Jellyfin.Database.Implementations;
+using Jellyfin.Database.Implementations.Entities;
+using Jellyfin.Database.Implementations.Enums;
+using Jellyfin.Extensions;
+using Jellyfin.Extensions.Json;
+using MediaBrowser.Common.Extensions;
+using MediaBrowser.Controller;
+using MediaBrowser.Controller.Configuration;
+using MediaBrowser.Controller.Dto;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Persistence;
+using MediaBrowser.Model.Configuration;
+using MediaBrowser.Model.Dto;
+using MediaBrowser.Model.Entities;
+using MediaBrowser.Model.IO;
+using MediaBrowser.Model.Querying;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Logging;
+
+namespace Emby.Server.Implementations.Library.SimilarItems;
+
+/// <summary>
+/// Manages similar items providers and orchestrates similar items operations.
+/// </summary>
+public class SimilarItemsManager : ISimilarItemsManager
+{
+    private readonly ILogger<SimilarItemsManager> _logger;
+    private readonly IServerApplicationPaths _appPaths;
+    private readonly ILibraryManager _libraryManager;
+    private readonly IFileSystem _fileSystem;
+    private readonly IServerConfigurationManager _serverConfigurationManager;
+    private readonly IDbContextFactory<JellyfinDbContext> _dbProvider;
+    private readonly IItemQueryHelpers _queryHelpers;
+    private ISimilarItemsProvider[] _similarItemsProviders = [];
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="SimilarItemsManager"/> class.
+    /// </summary>
+    /// <param name="logger">The logger.</param>
+    /// <param name="appPaths">The server application paths.</param>
+    /// <param name="libraryManager">The library manager.</param>
+    /// <param name="fileSystem">The file system.</param>
+    /// <param name="serverConfigurationManager">The server configuration manager.</param>
+    /// <param name="dbProvider">The database context factory.</param>
+    /// <param name="queryHelpers">The shared item query helpers.</param>
+    public SimilarItemsManager(
+        ILogger<SimilarItemsManager> logger,
+        IServerApplicationPaths appPaths,
+        ILibraryManager libraryManager,
+        IFileSystem fileSystem,
+        IServerConfigurationManager serverConfigurationManager,
+        IDbContextFactory<JellyfinDbContext> dbProvider,
+        IItemQueryHelpers queryHelpers)
+    {
+        _logger = logger;
+        _appPaths = appPaths;
+        _libraryManager = libraryManager;
+        _fileSystem = fileSystem;
+        _serverConfigurationManager = serverConfigurationManager;
+        _dbProvider = dbProvider;
+        _queryHelpers = queryHelpers;
+    }
+
+    /// <inheritdoc/>
+    public void AddParts(IEnumerable<ISimilarItemsProvider> providers)
+    {
+        _similarItemsProviders = providers.ToArray();
+    }
+
+    /// <inheritdoc/>
+    public IReadOnlyList<ISimilarItemsProvider> GetSimilarItemsProviders<T>()
+        where T : BaseItem
+    {
+        var itemType = typeof(T);
+        return _similarItemsProviders
+            .Where(p => (p is ILocalSimilarItemsProvider local && local.Supports(itemType))
+                || (p is IRemoteSimilarItemsProvider remote && remote.Supports(itemType)))
+            .ToList();
+    }
+
+    /// <inheritdoc/>
+    public async Task<IReadOnlyList<BaseItem>> GetSimilarItemsAsync(
+        BaseItem item,
+        IReadOnlyList<Guid> excludeArtistIds,
+        User? user,
+        DtoOptions dtoOptions,
+        int? limit,
+        LibraryOptions? libraryOptions,
+        CancellationToken cancellationToken)
+    {
+        ArgumentNullException.ThrowIfNull(item);
+        ArgumentNullException.ThrowIfNull(excludeArtistIds);
+
+        var itemType = item.GetType();
+        var requestedLimit = limit ?? 50;
+        var itemKind = item.GetBaseItemKind();
+
+        // Ensure ProviderIds is included in DtoOptions for matching remote provider responses
+        if (!dtoOptions.Fields.Contains(ItemFields.ProviderIds))
+        {
+            dtoOptions.Fields = dtoOptions.Fields.Concat([ItemFields.ProviderIds]).ToArray();
+        }
+
+        // Local providers are always enabled. Remote providers must be explicitly enabled.
+        var localProviders = _similarItemsProviders
+            .OfType<ILocalSimilarItemsProvider>()
+            .Where(p => p.Supports(itemType))
+            .ToList();
+        var remoteProviders = _similarItemsProviders
+            .OfType<IRemoteSimilarItemsProvider>()
+            .Where(p => p.Supports(itemType));
+        var matchingProviders = new List<ISimilarItemsProvider>(localProviders);
+
+        var typeOptions = libraryOptions?.GetTypeOptions(itemType.Name);
+        if (typeOptions?.SimilarItemProviders?.Length > 0)
+        {
+            matchingProviders.AddRange(remoteProviders
+                .Where(p => typeOptions.SimilarItemProviders.Contains(p.Name, StringComparer.OrdinalIgnoreCase)));
+        }
+
+        var orderConfig = typeOptions?.SimilarItemProviderOrder is { Length: > 0 } order
+            ? order
+            : typeOptions?.SimilarItemProviders;
+        var orderedProviders = matchingProviders
+            .OrderBy(p => GetConfiguredSimilarProviderOrder(orderConfig, p.Name))
+            .ToList();
+
+        var allResults = new List<(BaseItem Item, float Score)>();
+        var excludeIds = new HashSet<Guid> { item.Id };
+        var excludeKeys = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { item.GetPresentationUniqueKey() };
+        foreach (var (providerOrder, provider) in orderedProviders.Index())
+        {
+            if (allResults.Count >= requestedLimit || cancellationToken.IsCancellationRequested)
+            {
+                break;
+            }
+
+            try
+            {
+                if (provider is ILocalSimilarItemsProvider localProvider)
+                {
+                    var query = new SimilarItemsQuery
+                    {
+                        User = user,
+                        Limit = requestedLimit - allResults.Count,
+                        DtoOptions = dtoOptions,
+                        ExcludeItemIds = [.. excludeIds],
+                        ExcludeArtistIds = excludeArtistIds
+                    };
+
+                    var items = await localProvider.GetSimilarItemsAsync(item, query, cancellationToken).ConfigureAwait(false);
+
+                    foreach (var (position, resultItem) in items.Index())
+                    {
+                        var isNewId = excludeIds.Add(resultItem.Id);
+                        var isNewKey = excludeKeys.Add(resultItem.GetPresentationUniqueKey());
+                        if (isNewId && isNewKey)
+                        {
+                            var score = CalculateScore(null, providerOrder, position);
+                            allResults.Add((resultItem, score));
+                        }
+                    }
+                }
+                else if (provider is IRemoteSimilarItemsProvider remoteProvider)
+                {
+                    var cachePath = GetSimilarItemsCachePath(provider.Name, itemType.Name, item.Id);
+
+                    var cachedReferences = await TryReadSimilarItemsCacheAsync(cachePath, cancellationToken).ConfigureAwait(false);
+                    if (cachedReferences is not null)
+                    {
+                        var resolvedItems = ResolveRemoteReferences(cachedReferences, providerOrder, user, dtoOptions, itemKind, excludeIds, excludeKeys);
+                        allResults.AddRange(resolvedItems);
+                        continue;
+                    }
+
+                    var query = new SimilarItemsQuery
+                    {
+                        User = user,
+                        Limit = requestedLimit - allResults.Count,
+                        DtoOptions = dtoOptions,
+                        ExcludeItemIds = [.. excludeIds],
+                        ExcludeArtistIds = excludeArtistIds
+                    };
+
+                    // Collect references in batches and resolve against local library.
+                    // Stop fetching once we have enough resolved local items.
+                    const int BatchSize = 20;
+                    const int MaxRemoteReferenceFetchLimit = 500;
+                    var remaining = requestedLimit - allResults.Count;
+                    var collectedReferences = new List<SimilarItemReference>();
+                    var pendingBatch = new List<SimilarItemReference>();
+
+                    await foreach (var reference in remoteProvider.GetSimilarItemsAsync(item, query, cancellationToken).ConfigureAwait(false))
+                    {
+                        collectedReferences.Add(reference);
+                        pendingBatch.Add(reference);
+
+                        if (pendingBatch.Count >= BatchSize)
+                        {
+                            var resolvedItems = ResolveRemoteReferences(pendingBatch, providerOrder, user, dtoOptions, itemKind, excludeIds, excludeKeys);
+                            allResults.AddRange(resolvedItems);
+                            remaining -= resolvedItems.Count;
+                            pendingBatch.Clear();
+
+                            if (remaining <= 0 || collectedReferences.Count >= MaxRemoteReferenceFetchLimit)
+                            {
+                                break;
+                            }
+                        }
+                    }
+
+                    // Resolve any remaining references in the last partial batch
+                    if (pendingBatch.Count > 0)
+                    {
+                        var resolvedItems = ResolveRemoteReferences(pendingBatch, providerOrder, user, dtoOptions, itemKind, excludeIds, excludeKeys);
+                        allResults.AddRange(resolvedItems);
+                    }
+
+                    if (collectedReferences.Count > 0 && provider.CacheDuration is not null)
+                    {
+                        await SaveSimilarItemsCacheAsync(cachePath, collectedReferences, provider.CacheDuration.Value, cancellationToken).ConfigureAwait(false);
+                    }
+                }
+            }
+            catch (OperationCanceledException)
+            {
+                break;
+            }
+            catch (Exception ex)
+            {
+                _logger.LogWarning(ex, "Similar items provider {ProviderName} failed for item {ItemId}", provider.Name, item.Id);
+            }
+        }
+
+        var ordered = allResults
+            .OrderByDescending(x => x.Score)
+            .Select(x => x.Item)
+            .Take(requestedLimit)
+            .ToList();
+
+        return await FilterByLibraryAccessAsync(ordered, user, cancellationToken).ConfigureAwait(false);
+    }
+
+    private async Task<IReadOnlyList<BaseItem>> FilterByLibraryAccessAsync(
+        IReadOnlyList<BaseItem> candidates,
+        User? user,
+        CancellationToken cancellationToken)
+    {
+        if (candidates.Count == 0 || user is null)
+        {
+            return candidates;
+        }
+
+        var accessFilter = SimilarItemsAccessFilter.Build(user, _libraryManager);
+
+        // No accessible libraries means nothing to compare against, and an empty TopParentIds set
+        // would disable the filter rather than reject everything.
+        if (accessFilter.TopParentIds.Length == 0)
+        {
+            return candidates;
+        }
+
+        Guid[] candidateIds = [.. candidates.Select(c => c.Id)];
+
+        var dbContext = await _dbProvider.CreateDbContextAsync(cancellationToken).ConfigureAwait(false);
+        await using (dbContext.ConfigureAwait(false))
+        {
+            var baseQuery = dbContext.BaseItems
+                .AsNoTracking()
+                .WhereOneOrMany(candidateIds, e => e.Id);
+
+            baseQuery = _queryHelpers.ApplyAccessFiltering(dbContext, baseQuery, accessFilter);
+
+            var allowedCount = await baseQuery.CountAsync(cancellationToken).ConfigureAwait(false);
+            if (allowedCount == candidates.Count)
+            {
+                return candidates;
+            }
+
+            var allowedIds = await baseQuery
+                .Select(e => e.Id)
+                .ToHashSetAsync(cancellationToken)
+                .ConfigureAwait(false);
+
+            var filtered = candidates.Where(c => allowedIds.Contains(c.Id)).ToList();
+            _logger.LogDebug(
+                "Dropped {Dropped} of {Total} similar-item candidates due to user access filtering",
+                candidates.Count - filtered.Count,
+                candidates.Count);
+
+            return filtered;
+        }
+    }
+
+    /// <inheritdoc/>
+    public async Task<IReadOnlyList<SimilarItemsRecommendation>> GetMovieRecommendationsAsync(
+        User? user,
+        Guid parentId,
+        int categoryLimit,
+        int itemLimit,
+        DtoOptions dtoOptions,
+        CancellationToken cancellationToken)
+    {
+        ArgumentNullException.ThrowIfNull(dtoOptions);
+
+        var recentlyPlayedMovies = _libraryManager.GetItemList(new InternalItemsQuery(user)
+        {
+            IncludeItemTypes = [BaseItemKind.Movie],
+            OrderBy = [(ItemSortBy.DatePlayed, SortOrder.Descending), (ItemSortBy.Random, SortOrder.Descending)],
+            Limit = 7,
+            ParentId = parentId,
+            Recursive = true,
+            IsPlayed = true,
+            EnableGroupByMetadataKey = true,
+            DtoOptions = dtoOptions
+        });
+
+        var itemTypes = new List<BaseItemKind> { BaseItemKind.Movie };
+        if (_serverConfigurationManager.Configuration.EnableExternalContentInSuggestions)
+        {
+            itemTypes.Add(BaseItemKind.Trailer);
+            itemTypes.Add(BaseItemKind.LiveTvProgram);
+        }
+
+        var likedMovies = _libraryManager.GetItemList(new InternalItemsQuery(user)
+        {
+            IncludeItemTypes = itemTypes.ToArray(),
+            IsMovie = true,
+            OrderBy = [(ItemSortBy.Random, SortOrder.Descending)],
+            Limit = 10,
+            IsFavoriteOrLiked = true,
+            ExcludeItemIds = recentlyPlayedMovies.Select(i => i.Id).ToArray(),
+            EnableGroupByMetadataKey = true,
+            ParentId = parentId,
+            Recursive = true,
+            DtoOptions = dtoOptions
+        });
+
+        var mostRecentMovies = recentlyPlayedMovies.Take(Math.Min(recentlyPlayedMovies.Count, 6)).ToList();
+        var recentDirectors = GetPeopleNames(mostRecentMovies, [PersonType.Director]);
+        var recentActors = GetPeopleNames(mostRecentMovies, [PersonType.Actor, PersonType.GuestStar]);
+
+        // Cap baseline items to categoryLimit - the round-robin can't use more categories than that.
+        var recentlyPlayedBaseline = recentlyPlayedMovies.Count > categoryLimit
+            ? recentlyPlayedMovies.Take(categoryLimit).ToList()
+            : recentlyPlayedMovies;
+        var likedBaseline = likedMovies.Count > categoryLimit
+            ? likedMovies.Take(categoryLimit).ToList()
+            : likedMovies;
+
+        var batchQuery = new SimilarItemsQuery
+        {
+            User = user,
+            Limit = itemLimit,
+            DtoOptions = dtoOptions
+        };
+
+        var similarToRecentlyPlayed = await GetSimilarItemsRecommendationsAsync(
+            recentlyPlayedBaseline,
+            RecommendationType.SimilarToRecentlyPlayed,
+            batchQuery,
+            cancellationToken).ConfigureAwait(false);
+
+        var similarToLiked = await GetSimilarItemsRecommendationsAsync(
+            likedBaseline,
+            RecommendationType.SimilarToLikedItem,
+            batchQuery,
+            cancellationToken).ConfigureAwait(false);
+
+        var hasDirectorFromRecentlyPlayed = GetPersonRecommendations(user, recentDirectors, itemLimit, dtoOptions, RecommendationType.HasDirectorFromRecentlyPlayed, itemTypes);
+        var hasActorFromRecentlyPlayed = GetPersonRecommendations(user, recentActors, itemLimit, dtoOptions, RecommendationType.HasActorFromRecentlyPlayed, itemTypes);
+
+        // Use a single enumerator per list, listed twice so MoveNext advances it
+        // twice per round-robin pass (giving these categories double weight).
+        // IMPORTANT: Declare as IEnumerator<T> to box the List<T>.Enumerator struct once;
+        // using var would box separately per list insertion, creating independent copies.
+        IEnumerator<SimilarItemsRecommendation> similarToRecentlyPlayedEnum = similarToRecentlyPlayed.GetEnumerator();
+        IEnumerator<SimilarItemsRecommendation> similarToLikedEnum = similarToLiked.GetEnumerator();
+
+        var categoryTypes = new List<IEnumerator<SimilarItemsRecommendation>>
+        {
+            similarToRecentlyPlayedEnum,
+            similarToRecentlyPlayedEnum,
+            similarToLikedEnum,
+            similarToLikedEnum,
+            hasDirectorFromRecentlyPlayed.GetEnumerator(),
+            hasActorFromRecentlyPlayed.GetEnumerator()
+        };
+
+        var categories = new List<SimilarItemsRecommendation>();
+        while (categories.Count < categoryLimit)
+        {
+            var allEmpty = true;
+            foreach (var category in categoryTypes)
+            {
+                if (category.MoveNext())
+                {
+                    categories.Add(category.Current);
+                    allEmpty = false;
+
+                    if (categories.Count >= categoryLimit)
+                    {
+                        break;
+                    }
+                }
+            }
+
+            if (allEmpty)
+            {
+                break;
+            }
+        }
+
+        return [.. categories.OrderBy(i => i.RecommendationType)];
+    }
+
+    private async Task<IReadOnlyList<SimilarItemsRecommendation>> GetSimilarItemsRecommendationsAsync(
+        IReadOnlyList<BaseItem> baselineItems,
+        RecommendationType recommendationType,
+        SimilarItemsQuery query,
+        CancellationToken cancellationToken)
+    {
+        var batchProvider = _similarItemsProviders
+            .OfType<IBatchLocalSimilarItemsProvider>()
+            .FirstOrDefault();
+
+        if (batchProvider is null || baselineItems.Count == 0)
+        {
+            return [];
+        }
+
+        var batchResults = await batchProvider.GetBatchSimilarItemsAsync(baselineItems, query, cancellationToken).ConfigureAwait(false);
+
+        // Filter once across every category rather than per baseline, so a batch provider costs one
+        // access query no matter how many categories it produced.
+        var allItems = batchResults.Values.SelectMany(items => items).DistinctBy(item => item.Id).ToList();
+        var allowed = await FilterByLibraryAccessAsync(allItems, query.User, cancellationToken).ConfigureAwait(false);
+
+        HashSet<Guid>? allowedIds = allowed.Count == allItems.Count
+            ? null
+            : [.. allowed.Select(item => item.Id)];
+
+        var recommendations = new List<SimilarItemsRecommendation>(baselineItems.Count);
+        foreach (var baseline in baselineItems)
+        {
+            if (!batchResults.TryGetValue(baseline.Id, out var similar) || similar.Count == 0)
+            {
+                continue;
+            }
+
+            if (allowedIds is not null)
+            {
+                similar = similar.Where(item => allowedIds.Contains(item.Id)).ToList();
+                if (similar.Count == 0)
+                {
+                    continue;
+                }
+            }
+
+            recommendations.Add(new SimilarItemsRecommendation
+            {
+                BaselineItemName = baseline.Name,
+                CategoryId = baseline.Id,
+                RecommendationType = recommendationType,
+                Items = similar
+            });
+        }
+
+        return recommendations;
+    }
+
+    private IEnumerable<SimilarItemsRecommendation> GetPersonRecommendations(
+        User? user,
+        IReadOnlyList<string> names,
+        int itemLimit,
+        DtoOptions dtoOptions,
+        RecommendationType type,
+        IReadOnlyList<BaseItemKind> itemTypes)
+    {
+        var personTypes = type == RecommendationType.HasDirectorFromRecentlyPlayed
+            ? [PersonType.Director]
+            : Array.Empty<string>();
+
+        foreach (var name in names)
+        {
+            var items = _libraryManager.GetItemList(new InternalItemsQuery(user)
+            {
+                Person = name,
+                Limit = itemLimit + 2,
+                PersonTypes = personTypes,
+                IncludeItemTypes = itemTypes.ToArray(),
+                IsMovie = true,
+                IsPlayed = false,
+                EnableGroupByMetadataKey = true,
+                DtoOptions = dtoOptions
+            })
+                .DistinctBy(i => i.GetProviderId(MetadataProvider.Imdb) ?? Guid.NewGuid().ToString("N", CultureInfo.InvariantCulture))
+                .Take(itemLimit)
+                .ToList();
+
+            if (items.Count > 0)
+            {
+                yield return new SimilarItemsRecommendation
+                {
+                    BaselineItemName = name,
+                    CategoryId = name.GetMD5(),
+                    RecommendationType = type,
+                    Items = items
+                };
+            }
+        }
+    }
+
+    private IReadOnlyList<string> GetPeopleNames(IReadOnlyList<BaseItem> items, IReadOnlyList<string> personTypes)
+    {
+        var itemIds = items.Select(i => i.Id).ToArray();
+        return _libraryManager.GetPeopleNamesByItems(itemIds, personTypes)
+            .Values
+            .SelectMany(names => names)
+            .Distinct()
+            .ToArray();
+    }
+
+    private List<(BaseItem Item, float Score)> ResolveRemoteReferences(
+        IReadOnlyList<SimilarItemReference> references,
+        int providerOrder,
+        User? user,
+        DtoOptions dtoOptions,
+        BaseItemKind itemKind,
+        HashSet<Guid> excludeIds,
+        HashSet<string> excludeKeys)
+    {
+        if (references.Count == 0)
+        {
+            return [];
+        }
+
+        var resolvedByKey = new Dictionary<string, (BaseItem Item, float Score)>(StringComparer.OrdinalIgnoreCase);
+        var providerLookup = new Dictionary<(string ProviderName, string ProviderId), (float? Score, int Position)>(StringTupleComparer.Instance);
+
+        foreach (var (position, match) in references.Index())
+        {
+            var lookupKey = (match.ProviderName, match.ProviderId);
+            if (!providerLookup.TryGetValue(lookupKey, out var existing))
+            {
+                providerLookup[lookupKey] = (match.Score, position);
+            }
+            else if (match.Score > existing.Score || (match.Score == existing.Score && position < existing.Position))
+            {
+                providerLookup[lookupKey] = (match.Score, position);
+            }
+        }
+
+        var allProviderIds = providerLookup
+            .GroupBy(kvp => kvp.Key.ProviderName)
+            .ToDictionary(g => g.Key, g => g.Select(x => x.Key.ProviderId).ToArray());
+
+        var query = new InternalItemsQuery(user)
+        {
+            HasAnyProviderIds = allProviderIds,
+            IncludeItemTypes = [itemKind],
+            DtoOptions = dtoOptions
+        };
+
+        var items = _libraryManager.GetItemList(query);
+
+        foreach (var item in items)
+        {
+            if (excludeIds.Contains(item.Id))
+            {
+                continue;
+            }
+
+            var presentationKey = item.GetPresentationUniqueKey();
+            if (excludeKeys.Contains(presentationKey))
+            {
+                continue;
+            }
+
+            foreach (var providerName in allProviderIds.Keys)
+            {
+                if (item.TryGetProviderId(providerName, out var itemProviderId) && providerLookup.TryGetValue((providerName, itemProviderId), out var matchInfo))
+                {
+                    var score = CalculateScore(matchInfo.Score, providerOrder, matchInfo.Position);
+                    if (!resolvedByKey.TryGetValue(presentationKey, out var existing) || existing.Score < score)
+                    {
+                        resolvedByKey[presentationKey] = (item, score);
+                    }
+
+                    break;
+                }
+            }
+        }
+
+        foreach (var (key, entry) in resolvedByKey)
+        {
+            excludeIds.Add(entry.Item.Id);
+            excludeKeys.Add(key);
+        }
+
+        return [.. resolvedByKey.Values];
+    }
+
+    private static float CalculateScore(float? matchScore, int providerOrder, int position)
+    {
+        // Use provider-supplied score if available, otherwise derive from position
+        var baseScore = matchScore ?? (1.0f - (position * 0.02f));
+
+        // Apply small boost based on provider order (higher priority providers get small bonus)
+        var priorityBoost = Math.Max(0, 10 - providerOrder) * 0.005f;
+
+        return Math.Clamp(baseScore + priorityBoost, 0f, 1f);
+    }
+
+    private static int GetConfiguredSimilarProviderOrder(string[]? orderConfig, string providerName)
+    {
+        if (orderConfig is null || orderConfig.Length == 0)
+        {
+            return int.MaxValue;
+        }
+
+        var index = Array.FindIndex(orderConfig, name => string.Equals(name, providerName, StringComparison.OrdinalIgnoreCase));
+        return index >= 0 ? index : int.MaxValue;
+    }
+
+    private string GetSimilarItemsCachePath(string providerName, string baseItemType, Guid itemId)
+    {
+        var dataPath = Path.Combine(
+            _appPaths.CachePath,
+            $"{providerName.ToLowerInvariant()}-similar-{baseItemType.ToLowerInvariant()}");
+        return Path.Combine(dataPath, $"{itemId.ToString("N", CultureInfo.InvariantCulture)}.json");
+    }
+
+    private async Task<List<SimilarItemReference>?> TryReadSimilarItemsCacheAsync(string cachePath, CancellationToken cancellationToken)
+    {
+        var fileInfo = _fileSystem.GetFileSystemInfo(cachePath);
+        if (!fileInfo.Exists || fileInfo.Length == 0)
+        {
+            return null;
+        }
+
+        try
+        {
+            var stream = File.OpenRead(cachePath);
+            await using (stream.ConfigureAwait(false))
+            {
+                var cache = await JsonSerializer.DeserializeAsync<SimilarItemsCache>(stream, JsonDefaults.Options, cancellationToken).ConfigureAwait(false);
+                if (cache?.References is not null && DateTime.UtcNow < cache.ExpiresAt)
+                {
+                    return cache.References;
+                }
+            }
+        }
+        catch (IOException ex)
+        {
+            _logger.LogWarning(ex, "Failed to read similar items cache from {CachePath}", cachePath);
+        }
+        catch (JsonException ex)
+        {
+            _logger.LogWarning(ex, "Failed to parse similar items cache from {CachePath}", cachePath);
+        }
+
+        return null;
+    }
+
+    private async Task SaveSimilarItemsCacheAsync(string cachePath, List<SimilarItemReference> references, TimeSpan cacheDuration, CancellationToken cancellationToken)
+    {
+        try
+        {
+            var directory = Path.GetDirectoryName(cachePath);
+            if (!string.IsNullOrEmpty(directory))
+            {
+                Directory.CreateDirectory(directory);
+            }
+
+            var cache = new SimilarItemsCache
+            {
+                References = references,
+                ExpiresAt = DateTime.UtcNow.Add(cacheDuration)
+            };
+
+            var stream = File.Create(cachePath);
+            await using (stream.ConfigureAwait(false))
+            {
+                await JsonSerializer.SerializeAsync(stream, cache, JsonDefaults.Options, cancellationToken).ConfigureAwait(false);
+            }
+        }
+        catch (IOException ex)
+        {
+            _logger.LogWarning(ex, "Failed to save similar items cache to {CachePath}", cachePath);
+        }
+    }
+
+    private sealed class SimilarItemsCache
+    {
+        public List<SimilarItemReference>? References { get; set; }
+
+        public DateTime ExpiresAt { get; set; }
+    }
+
+    private sealed class StringTupleComparer : IEqualityComparer<(string Key, string Value)>
+    {
+        public static readonly StringTupleComparer Instance = new();
+
+        public bool Equals((string Key, string Value) x, (string Key, string Value) y)
+            => string.Equals(x.Key, y.Key, StringComparison.OrdinalIgnoreCase) &&
+               string.Equals(x.Value, y.Value, StringComparison.OrdinalIgnoreCase);
+
+        public int GetHashCode((string Key, string Value) obj)
+            => HashCode.Combine(
+                StringComparer.OrdinalIgnoreCase.GetHashCode(obj.Key),
+                StringComparer.OrdinalIgnoreCase.GetHashCode(obj.Value));
+    }
+}

Emby.Server.Implementations/Library/SplashscreenPostScanTask.cs

@@ -80,7 +80,7 @@ public class SplashscreenPostScanTask : ILibraryPostScanTask
             ImageTypes = [imageType],
             Limit = 30,
             // TODO max parental rating configurable
-            MaxParentalRating = new(10, null),
+            MaxParentalRating = new(13, null),
             OrderBy =
             [
                 (ItemSortBy.Random, SortOrder.Ascending)

Emby.Server.Implementations/Library/UserDataManager.cs

@@ -177,53 +177,167 @@ namespace Emby.Server.Implementations.Library
             };
         }
 
-        private UserItemData? GetUserData(User user, Guid itemId, List<string> keys)
+        /// <inheritdoc />
+        public Dictionary<Guid, UserItemData> GetUserDataBatch(IReadOnlyList<BaseItem> items, User user)
         {
-            var cacheKey = GetCacheKey(user.InternalId, itemId);
+            var result = new Dictionary<Guid, UserItemData>(items.Count);
+            var itemsNeedingQuery = new List<(BaseItem Item, List<string> Keys)>();
 
-            if (_cache.TryGet(cacheKey, out var data))
+            foreach (var item in items)
             {
-                return data;
-            }
-
-            data = GetUserDataInternal(user.Id, itemId, keys);
-
-            if (data is null)
-            {
-                return new UserItemData()
+                var cacheKey = GetCacheKey(user.InternalId, item.Id);
+                if (_cache.TryGet(cacheKey, out var cachedData))
                 {
-                    Key = keys[0],
-                };
+                    result[item.Id] = cachedData;
+                }
+                else
+                {
+                    var userDataRow = ResolveUserDataRow(item, item.UserData?.Where(e => e.UserId.Equals(user.Id)));
+                    var userData = userDataRow is not null ? Map(userDataRow) : null;
+                    if (userData is not null)
+                    {
+                        result[item.Id] = userData;
+                        _cache.AddOrUpdate(cacheKey, userData);
+                    }
+                    else
+                    {
+                        var keys = item.GetUserDataKeys();
+                        itemsNeedingQuery.Add((item, keys));
+                    }
+                }
             }
 
-            return _cache.GetOrAdd(cacheKey, _ => data);
-        }
-
-        private UserItemData? GetUserDataInternal(Guid userId, Guid itemId, List<string> keys)
-        {
-            if (keys.Count == 0)
+            if (itemsNeedingQuery.Count == 0)
             {
-                return null;
+                return result;
             }
 
+            // Build a single query for all missing items. Fetch rows by item alone so rows kept
+            // under keys from older metadata resolve the same way as the in-memory path.
+            var allItemIds = itemsNeedingQuery.Select(x => x.Item.Id).ToList();
             using var context = _repository.CreateDbContext();
-            var userData = context.UserData.AsNoTracking().Where(e => e.ItemId == itemId && keys.Contains(e.CustomDataKey) && e.UserId.Equals(userId)).ToArray();
+            var userDataArray = context.UserData
+                .AsNoTracking()
+                .Where(e => e.UserId.Equals(user.Id))
+                .WhereOneOrMany(allItemIds, e => e.ItemId)
+                .ToArray();
 
-            if (userData.Length > 0)
+            var userDataByItem = userDataArray.GroupBy(e => e.ItemId).ToDictionary(g => g.Key, g => g.ToArray());
+            foreach (var (item, keys) in itemsNeedingQuery)
             {
-                var directDataReference = userData.FirstOrDefault(e => e.CustomDataKey == itemId.ToString("N"));
-                if (directDataReference is not null)
+                UserItemData userData;
+                if (userDataByItem.TryGetValue(item.Id, out var itemUserData) && itemUserData.Length > 0)
                 {
-                    return Map(directDataReference);
+                    userData = Map(ResolveUserDataRow(item, itemUserData)!);
+                }
+                else
+                {
+                    userData = new UserItemData { Key = keys.Count > 0 ? keys[0] : string.Empty };
                 }
 
-                return Map(userData.First());
+                result[item.Id] = userData;
+                var cacheKey = GetCacheKey(user.InternalId, item.Id);
+                _cache.AddOrUpdate(cacheKey, userData);
             }
 
-            return new UserItemData
+            return result;
+        }
+
+        /// <inheritdoc />
+        public VersionResumeData? GetResumeUserData(User user, BaseItem item)
+        {
+            return GetResumeUserDataBatch([item], user).GetValueOrDefault(item.Id);
+        }
+
+        /// <inheritdoc />
+        public IReadOnlyDictionary<Guid, VersionResumeData> GetResumeUserDataBatch(IReadOnlyList<BaseItem> items, User user)
+        {
+            ArgumentNullException.ThrowIfNull(user);
+
+            var result = new Dictionary<Guid, VersionResumeData>();
+
+            // Candidate primaries: a directly queried version (PrimaryVersionId set) keeps its own data.
+            // Linked alternates are already known in memory; only the local-alternate existence check
+            // would otherwise hit the database (one query per item via Video.HasLocalAlternateVersions),
+            // so collect those ids and resolve them all in a single query below.
+            List<Video>? candidates = null;
+            List<Guid>? localProbeIds = null;
+            foreach (var item in items)
             {
-                Key = keys.Last()!
-            };
+                if (item is not Video video || video.PrimaryVersionId.HasValue)
+                {
+                    continue;
+                }
+
+                (candidates ??= []).Add(video);
+
+                if (video.LinkedAlternateVersions.Length == 0)
+                {
+                    (localProbeIds ??= []).Add(video.Id);
+                }
+            }
+
+            if (candidates is null)
+            {
+                return result;
+            }
+
+            HashSet<Guid>? withLocalAlternates = null;
+            if (localProbeIds is not null)
+            {
+                using var dbContext = _repository.CreateDbContext();
+                withLocalAlternates = dbContext.LinkedChildren
+                    .Where(lc => lc.ChildType == Jellyfin.Database.Implementations.Entities.LinkedChildType.LocalAlternateVersion)
+                    .WhereOneOrMany(localProbeIds, lc => lc.ParentId)
+                    .Select(lc => lc.ParentId)
+                    .Distinct()
+                    .ToHashSet();
+            }
+
+            List<(Guid PrimaryId, IReadOnlyList<Video> Versions)>? versionGroups = null;
+            List<BaseItem>? allVersions = null;
+
+            foreach (var video in candidates)
+            {
+                // Only items that actually have alternate versions aggregate over them.
+                if (video.LinkedAlternateVersions.Length == 0
+                    && (withLocalAlternates is null || !withLocalAlternates.Contains(video.Id)))
+                {
+                    continue;
+                }
+
+                var versions = video.GetAllVersions();
+                if (versions.Count < 2)
+                {
+                    continue;
+                }
+
+                (versionGroups ??= []).Add((video.Id, versions));
+                (allVersions ??= []).AddRange(versions);
+            }
+
+            if (versionGroups is null)
+            {
+                return result;
+            }
+
+            var userDataByVersion = GetUserDataBatch(allVersions!.DistinctBy(i => i.Id).ToList(), user);
+
+            foreach (var (primaryId, versions) in versionGroups)
+            {
+                // Consider both in-progress and completed versions so a finished alternate still marks the primary as played.
+                var resumeVersion = VersionPlaybackSelector.SelectMostRecentlyPlayed(
+                    versions,
+                    version => userDataByVersion.GetValueOrDefault(version.Id),
+                    data => data.PlaybackPositionTicks > 0 || data.Played);
+
+                if (resumeVersion is not null)
+                {
+                    result[primaryId] = new VersionResumeData(resumeVersion.Id, userDataByVersion[resumeVersion.Id]);
+                }
+            }
+
+            return result;
         }
 
         /// <summary>
@@ -238,12 +352,41 @@ namespace Emby.Server.Implementations.Library
         /// <inheritdoc />
         public UserItemData? GetUserData(User user, BaseItem item)
         {
-            return item.UserData?.Where(e => e.UserId.Equals(user.Id)).Select(Map).FirstOrDefault() ?? new UserItemData()
+            ArgumentNullException.ThrowIfNull(user);
+            var row = ResolveUserDataRow(item, item.UserData?.Where(e => e.UserId.Equals(user.Id)));
+            return row is not null ? Map(row) : new UserItemData()
             {
                 Key = item.GetUserDataKeys()[0],
             };
         }
 
+        /// <summary>
+        /// Picks the row matching the item's current user data keys, in key order, so rows left behind
+        /// under keys from older metadata don't take priority over the rows the write path updates.
+        /// </summary>
+        /// <param name="item">The item whose keys to match.</param>
+        /// <param name="rows">The candidate user data rows for a single user.</param>
+        /// <returns>The best matching row, or <c>null</c> when there are none.</returns>
+        private static UserData? ResolveUserDataRow(BaseItem item, IEnumerable<UserData>? rows)
+        {
+            var candidates = rows?.ToList();
+            if (candidates is null || candidates.Count == 0)
+            {
+                return null;
+            }
+
+            foreach (var key in item.GetUserDataKeys())
+            {
+                var match = candidates.Find(e => string.Equals(e.CustomDataKey, key, StringComparison.Ordinal));
+                if (match is not null)
+                {
+                    return match;
+                }
+            }
+
+            return candidates[0];
+        }
+
         /// <inheritdoc />
         public UserItemDataDto? GetUserDataDto(BaseItem item, User user)
             => GetUserDataDto(item, null, user, new DtoOptions());
@@ -260,6 +403,10 @@ namespace Emby.Server.Implementations.Library
             var dto = GetUserItemDataDto(userData, item.Id);
 
             item.FillUserDataDtoValues(dto, userData, itemDto, user, options);
+
+            // For an item with alternate versions, surface the most recently played version's resume point.
+            GetResumeUserData(user, item)?.ApplyTo(dto);
+
             return dto;
         }
 
@@ -364,5 +511,41 @@ namespace Emby.Server.Implementations.Library
 
             return playedToCompletion;
         }
+
+        /// <inheritdoc />
+        public void ResetPlaybackStreamSelections(User user, BaseItem item)
+        {
+            ArgumentNullException.ThrowIfNull(user);
+            ArgumentNullException.ThrowIfNull(item);
+
+            using var dbContext = _repository.CreateDbContext();
+            var rows = dbContext.UserData
+                .Where(e => e.ItemId == item.Id && e.UserId == user.Id
+                            && (e.AudioStreamIndex != null || e.SubtitleStreamIndex != null))
+                .ToList();
+
+            if (rows.Count == 0)
+            {
+                return;
+            }
+
+            foreach (var row in rows)
+            {
+                row.AudioStreamIndex = null;
+                row.SubtitleStreamIndex = null;
+            }
+
+            dbContext.SaveChanges();
+
+            var cacheKey = GetCacheKey(user.InternalId, item.Id);
+            if (_cache.TryGet(cacheKey, out var cached))
+            {
+                cached.AudioStreamIndex = null;
+                cached.SubtitleStreamIndex = null;
+                _cache.AddOrUpdate(cacheKey, cached);
+            }
+
+            item.UserData = dbContext.UserData.Where(e => e.ItemId == item.Id).AsNoTracking().ToArray();
+        }
     }
 }

Emby.Server.Implementations/Library/UserViewManager.cs

@@ -59,8 +59,8 @@ namespace Emby.Server.Implementations.Library
                 var collectionFolder = folder as ICollectionFolder;
                 var folderViewType = collectionFolder?.CollectionType;
 
-                // Playlist library requires special handling because the folder only references user playlists
-                if (folderViewType == CollectionType.playlists)
+                // Playlist and BoxSet libraries require special handling because the folder only references linked items
+                if (folderViewType == CollectionType.playlists || folderViewType == CollectionType.boxsets)
                 {
                     var items = folder.GetItemList(new InternalItemsQuery(user)
                     {
@@ -112,7 +112,7 @@ namespace Emby.Server.Implementations.Library
 
             if (_config.Configuration.EnableFolderView)
             {
-                var name = _localizationManager.GetLocalizedString("Folders");
+                var name = _localizationManager.GetServerLocalizedString("Folders");
                 list.Add(_libraryManager.GetNamedView(name, CollectionType.folders, string.Empty));
             }
 
@@ -138,7 +138,7 @@ namespace Emby.Server.Implementations.Library
                 list = list.Where(i => !user.GetPreferenceValues<Guid>(PreferenceKind.MyMediaExcludes).Contains(i.Id)).ToList();
             }
 
-            var sorted = _libraryManager.Sort(list, user, new[] { ItemSortBy.SortName }, SortOrder.Ascending).ToList();
+            var sorted = _libraryManager.Sort(list, user, [ItemSortBy.SortName], SortOrder.Ascending).ToList();
             var orders = user.GetPreferenceValues<Guid>(PreferenceKind.OrderedViews);
 
             return list
@@ -168,7 +168,7 @@ namespace Emby.Server.Implementations.Library
 
         public UserView GetUserSubView(Guid parentId, CollectionType? type, string localizationKey, string sortName)
         {
-            var name = _localizationManager.GetLocalizedString(localizationKey);
+            var name = _localizationManager.GetServerLocalizedString(localizationKey);
 
             return GetUserSubViewWithName(name, parentId, type, sortName);
         }
@@ -191,7 +191,7 @@ namespace Emby.Server.Implementations.Library
                 return GetUserView((Folder)parents[0], viewType, string.Empty);
             }
 
-            var name = _localizationManager.GetLocalizedString(localizationKey);
+            var name = _localizationManager.GetServerLocalizedString(localizationKey);
             return _libraryManager.GetNamedView(user, name, viewType, sortName);
         }
 
@@ -205,7 +205,7 @@ namespace Emby.Server.Implementations.Library
             var libraryItems = GetItemsForLatestItems(request.User, request, options);
 
             var list = new List<Tuple<BaseItem, List<BaseItem>>>();
-
+            var containerIndexMap = new Dictionary<Guid, int>();
             foreach (var item in libraryItems)
             {
                 // Only grab the index container for media
@@ -213,20 +213,16 @@ namespace Emby.Server.Implementations.Library
 
                 if (container is null)
                 {
-                    list.Add(new Tuple<BaseItem, List<BaseItem>>(null, new List<BaseItem> { item }));
+                    list.Add(new Tuple<BaseItem, List<BaseItem>>(null!, new List<BaseItem> { item }));
+                }
+                else if (containerIndexMap.TryGetValue(container.Id, out var existingIndex))
+                {
+                    list[existingIndex].Item2.Add(item);
                 }
                 else
                 {
-                    var current = list.FirstOrDefault(i => i.Item1 is not null && i.Item1.Id.Equals(container.Id));
-
-                    if (current is not null)
-                    {
-                        current.Item2.Add(item);
-                    }
-                    else
-                    {
-                        list.Add(new Tuple<BaseItem, List<BaseItem>>(container, new List<BaseItem> { item }));
-                    }
+                    containerIndexMap[container.Id] = list.Count;
+                    list.Add(new Tuple<BaseItem, List<BaseItem>>(container, new List<BaseItem> { item }));
                 }
 
                 if (list.Count >= request.Limit)
@@ -255,7 +251,7 @@ namespace Emby.Server.Implementations.Library
                     return _channelManager.GetLatestChannelItemsInternal(
                         new InternalItemsQuery(user)
                         {
-                            ChannelIds = new[] { parentId },
+                            ChannelIds = [parentId],
                             IsPlayed = request.IsPlayed,
                             StartIndex = request.StartIndex,
                             Limit = request.Limit,
@@ -301,11 +297,11 @@ namespace Emby.Server.Implementations.Library
                 {
                     if (hasCollectionType.All(i => i.CollectionType == CollectionType.movies))
                     {
-                        includeItemTypes = new[] { BaseItemKind.Movie };
+                        includeItemTypes = [BaseItemKind.Movie];
                     }
                     else if (hasCollectionType.All(i => i.CollectionType == CollectionType.tvshows))
                     {
-                        includeItemTypes = new[] { BaseItemKind.Episode };
+                        includeItemTypes = [BaseItemKind.Episode];
                     }
                 }
             }
@@ -344,29 +340,29 @@ namespace Emby.Server.Implementations.Library
             }
 
             var excludeItemTypes = includeItemTypes.Length == 0 && mediaTypes.Length == 0
-                ? new[]
-                {
+                ?
+                [
                     BaseItemKind.Person,
                     BaseItemKind.Studio,
                     BaseItemKind.Year,
                     BaseItemKind.MusicGenre,
                     BaseItemKind.Genre
-                }
+                ]
                 : Array.Empty<BaseItemKind>();
 
             var query = new InternalItemsQuery(user)
             {
                 IncludeItemTypes = includeItemTypes,
-                OrderBy = new[]
-                {
+                OrderBy =
+                [
                     (ItemSortBy.DateCreated, SortOrder.Descending),
                     (ItemSortBy.SortName, SortOrder.Descending),
                     (ItemSortBy.ProductionYear, SortOrder.Descending)
-                },
+                ],
                 IsFolder = includeItemTypes.Length == 0 ? false : null,
                 ExcludeItemTypes = excludeItemTypes,
                 IsVirtualItem = false,
-                Limit = limit * 5,
+                Limit = limit * 2,
                 IsPlayed = isPlayed,
                 DtoOptions = options,
                 MediaTypes = mediaTypes
@@ -394,6 +390,18 @@ namespace Emby.Server.Implementations.Library
                     query.Limit = limit;
                     return _libraryManager.GetLatestItemList(query, parents, CollectionType.music);
                 }
+
+                if (collectionType == CollectionType.movies)
+                {
+                    query.Limit = limit;
+                    return _libraryManager.GetLatestItemList(query, parents, CollectionType.movies);
+                }
+
+                if (collectionType is null)
+                {
+                    query.Limit = limit;
+                    return _libraryManager.GetLatestItemList(query, parents, CollectionType.unknown);
+                }
             }
 
             return _libraryManager.GetItemList(query, parents);

Emby.Server.Implementations/Library/Validators/ArtistsValidator.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Globalization;
 using System.Linq;
 using System.Threading;
@@ -50,25 +51,55 @@ public class ArtistsValidator
     public async Task Run(IProgress<double> progress, CancellationToken cancellationToken)
     {
         var names = _itemRepo.GetAllArtistNames();
+        var existingArtistIds = _libraryManager.GetItemIds(new InternalItemsQuery
+        {
+            IncludeItemTypes = [BaseItemKind.MusicArtist]
+        }).ToHashSet();
+
+        var existingArtists = _libraryManager.GetArtists(names);
 
         var numComplete = 0;
         var count = names.Count;
+        var refreshed = 0;
+
+        var liveIds = new HashSet<Guid>();
+        var unresolved = 0;
 
         foreach (var name in names)
         {
             try
             {
-                var item = _libraryManager.GetArtist(name);
+                MusicArtist? item = null;
+                if (existingArtists.TryGetValue(name, out var artists) && artists.Length > 0)
+                {
+                    item = artists.OrderBy(i => i.IsAccessedByName ? 1 : 0).First();
+                }
 
-                await item.RefreshMetadata(cancellationToken).ConfigureAwait(false);
+                // Fall back to GetArtist if not found (creates new item if needed)
+                item ??= _libraryManager.GetArtist(name);
+
+                // A name with no item is nothing to refresh, and nothing to keep alive either.
+                if (item is not null)
+                {
+                    liveIds.Add(item.Id);
+
+                    var isNew = !existingArtistIds.Contains(item.Id);
+                    var neverRefreshed = item.DateLastRefreshed == default;
+
+                    if (isNew || neverRefreshed)
+                    {
+                        await item.RefreshMetadata(cancellationToken).ConfigureAwait(false);
+                        refreshed++;
+                    }
+                }
             }
             catch (OperationCanceledException)
             {
-                // Don't clutter the log
                 throw;
             }
             catch (Exception ex)
             {
+                unresolved++;
                 _logger.LogError(ex, "Error refreshing {ArtistName}", name);
             }
 
@@ -80,31 +111,37 @@ public class ArtistsValidator
             progress.Report(percent);
         }
 
+        _logger.LogInformation("Refreshed metadata for {RefreshedCount} new artists out of {TotalCount} total", refreshed, count);
+
+        // Every name that threw is a name whose artist is missing from the live set, and deleting against
+        // a live set with holes in it deletes artists the library still refers to. Leave the sweep to a
+        // run that got a clean read of them.
+        if (unresolved > 0)
+        {
+            _logger.LogWarning(
+                "Not removing dead artists: {Count} of {TotalCount} names could not be resolved this run",
+                unresolved,
+                count);
+
+            progress.Report(100);
+            return;
+        }
+
         var deadEntities = _libraryManager.GetItemList(new InternalItemsQuery
         {
             IncludeItemTypes = [BaseItemKind.MusicArtist],
-            IsDeadArtist = true,
             IsLocked = false
-        }).Cast<MusicArtist>().ToList();
+        }).OfType<MusicArtist>()
+        .Where(item => item.IsAccessedByName && !liveIds.Contains(item.Id))
+        .ToList();
 
         foreach (var item in deadEntities)
         {
-            if (!item.IsAccessedByName)
-            {
-                continue;
-            }
-
             _logger.LogInformation("Deleting dead {ItemType} {ItemId} {ItemName}", item.GetType().Name, item.Id.ToString("N", CultureInfo.InvariantCulture), item.Name);
-
-            _libraryManager.DeleteItem(
-                item,
-                new DeleteOptions
-                {
-                    DeleteFileLocation = false
-                },
-                false);
         }
 
+        _libraryManager.DeleteItemsUnsafeFast(deadEntities, deleteSourceFiles: true);
+
         progress.Report(100);
     }
 }

Emby.Server.Implementations/Library/Validators/CollectionPostScanTask.cs

@@ -74,7 +74,7 @@ public class CollectionPostScanTask : ILibraryPostScanTask
 
                 foreach (var m in movies)
                 {
-                    if (m is Movie movie && !string.IsNullOrEmpty(movie.CollectionName))
+                    if (m is Movie movie && !string.IsNullOrEmpty(movie.CollectionName) && !movie.PrimaryVersionId.HasValue)
                     {
                         if (collectionNameMoviesMap.TryGetValue(movie.CollectionName, out var movieList))
                         {

Emby.Server.Implementations/Library/Validators/CollectionPosterVerifyPostScanTask.cs

@@ -0,0 +1,64 @@
+using System;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Model.Entities;
+using Microsoft.Extensions.Logging;
+
+namespace Emby.Server.Implementations.Library.Validators;
+
+/// <summary>
+/// Ensures top-level library folders have a primary poster after scans.
+/// Poster extraction is attempted before library scanning. When a library is
+/// empty at that point, no poster can be extracted. This post-scan task reruns
+/// metadata extraction for top-level folders that are still missing images.
+/// </summary>
+public class CollectionPosterVerifyPostScanTask : ILibraryPostScanTask
+{
+    private readonly ILibraryManager _libraryManager;
+    private readonly ILogger<CollectionPosterVerifyPostScanTask> _logger;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="CollectionPosterVerifyPostScanTask" /> class.
+    /// </summary>
+    /// <param name="libraryManager">The library manager.</param>
+    /// <param name="logger">The logger.</param>
+    public CollectionPosterVerifyPostScanTask(
+        ILibraryManager libraryManager,
+        ILogger<CollectionPosterVerifyPostScanTask> logger)
+    {
+        _libraryManager = libraryManager;
+        _logger = logger;
+    }
+
+    /// <summary>
+    /// Runs the specified progress.
+    /// </summary>
+    /// <param name="progress">The progress.</param>
+    /// <param name="cancellationToken">The cancellation token.</param>
+    /// <returns>Task.</returns>
+    public async Task Run(IProgress<double> progress, CancellationToken cancellationToken)
+    {
+        var libraries = _libraryManager.GetUserRootFolder().Children.OfType<CollectionFolder>().ToList();
+        var totalLibraries = libraries.Count;
+        var processedLibraries = 0;
+
+        foreach (var library in libraries)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+
+            if (!library.HasImage(ImageType.Primary))
+            {
+                _logger.LogDebug("Library {LibraryName} is missing a primary image. Refreshing metadata.", library.Name);
+                await library.RefreshMetadata(cancellationToken).ConfigureAwait(false);
+            }
+
+            processedLibraries++;
+            progress.Report((double)processedLibraries / totalLibraries * 100);
+        }
+
+        progress.Report(100);
+    }
+}

Emby.Server.Implementations/Library/Validators/GenresValidator.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Globalization;
+using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using Jellyfin.Data.Enums;
@@ -48,17 +49,40 @@ public class GenresValidator
     public async Task Run(IProgress<double> progress, CancellationToken cancellationToken)
     {
         var names = _itemRepo.GetGenreNames();
+        var existingGenreIds = _libraryManager.GetItemIds(new InternalItemsQuery
+        {
+            IncludeItemTypes = [BaseItemKind.Genre]
+        }).ToHashSet();
+
+        var existingGenres = _libraryManager.GetItemList(new InternalItemsQuery
+        {
+            IncludeItemTypes = [BaseItemKind.Genre]
+        }).Cast<Genre>()
+        .GroupBy(g => g.Name, StringComparer.OrdinalIgnoreCase)
+        .ToDictionary(g => g.Key, g => g.First(), StringComparer.OrdinalIgnoreCase);
 
         var numComplete = 0;
         var count = names.Count;
+        var refreshed = 0;
 
         foreach (var name in names)
         {
             try
             {
-                var item = _libraryManager.GetGenre(name);
+                Genre? item = null;
+                if (existingGenres.TryGetValue(name, out var existingGenre))
+                {
+                    item = existingGenre;
+                }
 
-                await item.RefreshMetadata(cancellationToken).ConfigureAwait(false);
+                // Fall back to GetGenre if not found (creates new item if needed)
+                item ??= _libraryManager.GetGenre(name);
+
+                if (!existingGenreIds.Contains(item.Id))
+                {
+                    await item.RefreshMetadata(cancellationToken).ConfigureAwait(false);
+                    refreshed++;
+                }
             }
             catch (OperationCanceledException)
             {
@@ -78,6 +102,8 @@ public class GenresValidator
             progress.Report(percent);
         }
 
+        _logger.LogInformation("Refreshed metadata for {RefreshedCount} new genres out of {TotalCount} total", refreshed, count);
+
         var deadEntities = _libraryManager.GetItemList(new InternalItemsQuery
         {
             IncludeItemTypes = [BaseItemKind.Genre, BaseItemKind.MusicGenre],
@@ -88,16 +114,10 @@ public class GenresValidator
         foreach (var item in deadEntities)
         {
             _logger.LogInformation("Deleting dead {ItemType} {ItemId} {ItemName}", item.GetType().Name, item.Id.ToString("N", CultureInfo.InvariantCulture), item.Name);
-
-            _libraryManager.DeleteItem(
-                item,
-                new DeleteOptions
-                {
-                    DeleteFileLocation = false
-                },
-                false);
         }
 
+        _libraryManager.DeleteItemsUnsafeFast(deadEntities, deleteSourceFiles: true);
+
         progress.Report(100);
     }
 }

Emby.Server.Implementations/Library/Validators/MusicGenresValidator.cs

@@ -1,6 +1,9 @@
 using System;
+using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
+using Jellyfin.Data.Enums;
+using MediaBrowser.Controller.Entities;
 using MediaBrowser.Controller.Library;
 using MediaBrowser.Controller.Persistence;
 using Microsoft.Extensions.Logging;
@@ -45,17 +48,25 @@ public class MusicGenresValidator
     public async Task Run(IProgress<double> progress, CancellationToken cancellationToken)
     {
         var names = _itemRepo.GetMusicGenreNames();
+        var existingMusicGenreIds = _libraryManager.GetItemIds(new InternalItemsQuery
+        {
+            IncludeItemTypes = [BaseItemKind.MusicGenre]
+        }).ToHashSet();
 
         var numComplete = 0;
         var count = names.Count;
+        var refreshed = 0;
 
         foreach (var name in names)
         {
             try
             {
                 var item = _libraryManager.GetMusicGenre(name);
-
-                await item.RefreshMetadata(cancellationToken).ConfigureAwait(false);
+                if (!existingMusicGenreIds.Contains(item.Id))
+                {
+                    await item.RefreshMetadata(cancellationToken).ConfigureAwait(false);
+                    refreshed++;
+                }
             }
             catch (OperationCanceledException)
             {
@@ -75,6 +86,8 @@ public class MusicGenresValidator
             progress.Report(percent);
         }
 
+        _logger.LogInformation("Refreshed metadata for {RefreshedCount} new music genres out of {TotalCount} total", refreshed, count);
+
         progress.Report(100);
     }
 }

Emby.Server.Implementations/Library/Validators/PeopleValidator.cs

@@ -1,12 +1,12 @@
 using System;
+using System.Collections.Generic;
+using System.Globalization;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using Jellyfin.Data.Enums;
 using MediaBrowser.Controller.Entities;
 using MediaBrowser.Controller.Library;
-using MediaBrowser.Controller.Providers;
-using MediaBrowser.Model.IO;
 using Microsoft.Extensions.Logging;
 
 namespace Emby.Server.Implementations.Library.Validators;
@@ -17,104 +17,143 @@ namespace Emby.Server.Implementations.Library.Validators;
 public class PeopleValidator
 {
     /// <summary>
-    /// The _library manager.
+    /// The library manager.
     /// </summary>
     private readonly ILibraryManager _libraryManager;
 
     /// <summary>
-    /// The _logger.
+    /// The logger.
     /// </summary>
-    private readonly ILogger _logger;
-
-    private readonly IFileSystem _fileSystem;
+    private readonly ILogger<PeopleValidator> _logger;
 
     /// <summary>
     /// Initializes a new instance of the <see cref="PeopleValidator" /> class.
     /// </summary>
     /// <param name="libraryManager">The library manager.</param>
     /// <param name="logger">The logger.</param>
-    /// <param name="fileSystem">The file system.</param>
-    public PeopleValidator(ILibraryManager libraryManager, ILogger logger, IFileSystem fileSystem)
+    public PeopleValidator(ILibraryManager libraryManager, ILogger<PeopleValidator> logger)
     {
         _libraryManager = libraryManager;
         _logger = logger;
-        _fileSystem = fileSystem;
     }
 
     /// <summary>
     /// Validates the people.
     /// </summary>
-    /// <param name="cancellationToken">The cancellation token.</param>
     /// <param name="progress">The progress.</param>
+    /// <param name="cancellationToken">The cancellation token.</param>
     /// <returns>Task.</returns>
-    public async Task ValidatePeople(CancellationToken cancellationToken, IProgress<double> progress)
+    public async Task Run(IProgress<double> progress, CancellationToken cancellationToken)
     {
-        var people = _libraryManager.GetPeopleNames(new InternalPeopleQuery());
+        // Before the refresh below walks them: a credit no item maps to any more stands for nothing,
+        // and while it is there the person it names cannot reach the dead-person sweep either.
+        var numOrphaned = _libraryManager.DeleteOrphanedCredits();
+        if (numOrphaned > 0)
+        {
+            _logger.LogInformation("Deleted {Amount} credits no item maps to", numOrphaned);
+        }
+
+        var names = _libraryManager.GetPeopleNames(new InternalPeopleQuery());
+        var existingPersonIds = _libraryManager.GetItemIds(new InternalItemsQuery
+        {
+            IncludeItemTypes = [BaseItemKind.Person]
+        }).ToHashSet();
+
+        var (newNames, deadIds) = PartitionCreditsByPersonId(names, _libraryManager.GetPersonId, existingPersonIds);
 
         var numComplete = 0;
+        var count = names.Count;
+        var refreshed = 0;
 
-        var numPeople = people.Count;
-
-        IProgress<double> subProgress = new Progress<double>((val) => progress.Report(val / 2));
-
-        _logger.LogDebug("Will refresh {Amount} people", numPeople);
-
-        foreach (var person in people)
+        foreach (var name in names)
         {
             cancellationToken.ThrowIfCancellationRequested();
 
             try
             {
-                var item = _libraryManager.GetPerson(person);
-                if (item is null)
+                var item = _libraryManager.GetOrCreatePerson(name);
+                var isNew = !existingPersonIds.Contains(item.Id);
+                var neverRefreshed = item.DateLastRefreshed == default;
+
+                if (isNew || neverRefreshed)
                 {
-                    _logger.LogWarning("Failed to get person: {Name}", person);
-                    continue;
+                    await item.RefreshMetadata(cancellationToken).ConfigureAwait(false);
+                    refreshed++;
                 }
-
-                var options = new MetadataRefreshOptions(new DirectoryService(_fileSystem))
-                {
-                    ImageRefreshMode = MetadataRefreshMode.ValidationOnly,
-                    MetadataRefreshMode = MetadataRefreshMode.ValidationOnly
-                };
-
-                await item.RefreshMetadata(options, cancellationToken).ConfigureAwait(false);
             }
             catch (OperationCanceledException)
             {
+                // Don't clutter the log
                 throw;
             }
             catch (Exception ex)
             {
-                _logger.LogError(ex, "Error validating IBN entry {Person}", person);
+                _logger.LogError(ex, "Error refreshing {PersonName}", name);
             }
 
-            // Update progress
             numComplete++;
             double percent = numComplete;
-            percent /= numPeople;
+            percent /= count;
+            percent *= 100;
 
-            subProgress.Report(100 * percent);
+            progress.Report(percent);
         }
 
-        var deadEntities = _libraryManager.GetItemList(new InternalItemsQuery
-        {
-            IncludeItemTypes = [BaseItemKind.Person],
-            IsDeadPerson = true,
-            IsLocked = false
-        });
+        _logger.LogInformation(
+            "Refreshed metadata for {RefreshedCount} people out of {TotalCount} total, {NewCount} of which had no item yet",
+            refreshed,
+            count,
+            newNames.Count);
 
-        subProgress = new Progress<double>((val) => progress.Report((val / 2) + 50));
+        // A person somebody locked is theirs, not ours, however little the library still credits them.
+        var deadEntities = deadIds
+            .Select(_libraryManager.GetItemById)
+            .OfType<Person>()
+            .Where(item => !item.IsLocked)
+            .ToList();
 
-        var i = 0;
-        foreach (var item in deadEntities.Chunk(500))
+        foreach (var item in deadEntities)
         {
-            _libraryManager.DeleteItemsUnsafeFast(item);
-            subProgress.Report(100f / deadEntities.Count * (i++ * 100));
+            _logger.LogInformation("Deleting dead {ItemType} {ItemId} {ItemName}", item.GetType().Name, item.Id.ToString("N", CultureInfo.InvariantCulture), item.Name);
         }
 
+        _libraryManager.DeleteItemsUnsafeFast(deadEntities, deleteSourceFiles: true);
+
         progress.Report(100);
+    }
 
-        _logger.LogInformation("People validation complete");
+    /// <summary>
+    /// Splits the person items into the ones a credit still calls for and the ones nothing does.
+    /// </summary>
+    /// <param name="creditNames">Every name credited on an item, from the people table.</param>
+    /// <param name="getPersonId">Maps a credit name to the id its person item has.</param>
+    /// <param name="existingPersonIds">The ids of the person items that exist.</param>
+    /// <returns>The credits needing an item, and the ids of the items nothing credits.</returns>
+    internal static (List<string> NewNames, List<Guid> DeadIds) PartitionCreditsByPersonId(
+        IReadOnlyList<string> creditNames,
+        Func<string, Guid> getPersonId,
+        IReadOnlySet<Guid> existingPersonIds)
+    {
+        ArgumentNullException.ThrowIfNull(creditNames);
+        ArgumentNullException.ThrowIfNull(getPersonId);
+        ArgumentNullException.ThrowIfNull(existingPersonIds);
+
+        var newNames = new List<string>();
+        var liveIds = new HashSet<Guid>();
+
+        foreach (var name in creditNames)
+        {
+            var personId = getPersonId(name);
+
+            // Distinct credit names can normalize onto one id; only the first of them needs an item.
+            if (liveIds.Add(personId) && !existingPersonIds.Contains(personId))
+            {
+                newNames.Add(name);
+            }
+        }
+
+        var deadIds = existingPersonIds.Where(id => !liveIds.Contains(id)).ToList();
+
+        return (newNames, deadIds);
     }
 }

Emby.Server.Implementations/Library/Validators/StudiosValidator.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Globalization;
+using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
 using Jellyfin.Data.Enums;
@@ -49,17 +50,40 @@ public class StudiosValidator
     public async Task Run(IProgress<double> progress, CancellationToken cancellationToken)
     {
         var names = _itemRepo.GetStudioNames();
+        var existingStudioIds = _libraryManager.GetItemIds(new InternalItemsQuery
+        {
+            IncludeItemTypes = [BaseItemKind.Studio]
+        }).ToHashSet();
+
+        var existingStudios = _libraryManager.GetItemList(new InternalItemsQuery
+        {
+            IncludeItemTypes = [BaseItemKind.Studio]
+        }).Cast<Studio>()
+        .GroupBy(s => s.Name, StringComparer.OrdinalIgnoreCase)
+        .ToDictionary(g => g.Key, g => g.First(), StringComparer.OrdinalIgnoreCase);
 
         var numComplete = 0;
         var count = names.Count;
+        var refreshed = 0;
 
         foreach (var name in names)
         {
             try
             {
-                var item = _libraryManager.GetStudio(name);
+                Studio? item = null;
+                if (existingStudios.TryGetValue(name, out var existingStudio))
+                {
+                    item = existingStudio;
+                }
 
-                await item.RefreshMetadata(cancellationToken).ConfigureAwait(false);
+                // Fall back to GetStudio if not found (creates new item if needed)
+                item ??= _libraryManager.GetStudio(name);
+
+                if (!existingStudioIds.Contains(item.Id))
+                {
+                    await item.RefreshMetadata(cancellationToken).ConfigureAwait(false);
+                    refreshed++;
+                }
             }
             catch (OperationCanceledException)
             {
@@ -79,6 +103,8 @@ public class StudiosValidator
             progress.Report(percent);
         }
 
+        _logger.LogInformation("Refreshed metadata for {RefreshedCount} new studios out of {TotalCount} total", refreshed, count);
+
         var deadEntities = _libraryManager.GetItemList(new InternalItemsQuery
         {
             IncludeItemTypes = [BaseItemKind.Studio],
@@ -89,16 +115,10 @@ public class StudiosValidator
         foreach (var item in deadEntities)
         {
             _logger.LogInformation("Deleting dead {ItemType} {ItemId} {ItemName}", item.GetType().Name, item.Id.ToString("N", CultureInfo.InvariantCulture), item.Name);
-
-            _libraryManager.DeleteItem(
-                item,
-                new DeleteOptions
-                {
-                    DeleteFileLocation = false
-                },
-                false);
         }
 
+        _libraryManager.DeleteItemsUnsafeFast(deadEntities, deleteSourceFiles: true);
+
         progress.Report(100);
     }
 }

Emby.Server.Implementations/Localization/Core/ab.json

@@ -1,3 +1,3 @@
 {
-    "Albums": "аальбомқәа"
+    "AppDeviceValues": "Апп: {0}, Априбор: {1}"
 }