diff --git a/.github/workflows/base-image.yml b/.github/workflows/base-image.yml
index 1da33d4f..f926d892 100644
--- a/.github/workflows/base-image.yml
+++ b/.github/workflows/base-image.yml
@@ -2,42 +2,37 @@ name: Base Image Build
 
 on:
   push:
-    branches: [ main, dev ]
+    branches: [main, dev]
     paths:
       - 'docker/DispatcharrBase'
       - '.github/workflows/base-image.yml'
       - 'requirements.txt'
   pull_request:
-    branches: [ main, dev ]
+    branches: [main, dev]
     paths:
       - 'docker/DispatcharrBase'
       - '.github/workflows/base-image.yml'
       - 'requirements.txt'
-  workflow_dispatch:  # Allow manual triggering
+  workflow_dispatch: # Allow manual triggering
 
 permissions:
-  contents: write    # For managing releases and pushing tags
-  packages: write    # For publishing to GitHub Container Registry
+  contents: write # For managing releases and pushing tags
+  packages: write # For publishing to GitHub Container Registry
 
 jobs:
-  build-base-image:
-    runs-on: ubuntu-latest
+  prepare:
+    runs-on: ubuntu-24.04
+    outputs:
+      repo_owner: ${{ steps.meta.outputs.repo_owner }}
+      repo_name: ${{ steps.meta.outputs.repo_name }}
+      branch_tag: ${{ steps.meta.outputs.branch_tag }}
+      timestamp: ${{ steps.timestamp.outputs.timestamp }}
     steps:
       - uses: actions/checkout@v3
         with:
           fetch-depth: 0
           token: ${{ secrets.GITHUB_TOKEN }}
 
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v2
-
-      - name: Login to GitHub Container Registry
-        uses: docker/login-action@v2
-        with:
-          registry: ghcr.io
-          username: ${{ github.actor }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-
       - name: Generate timestamp for build
         id: timestamp
         run: |
@@ -66,13 +61,111 @@ jobs:
             echo "branch_tag=base-${BRANCH}" >> $GITHUB_OUTPUT
           fi
 
+  docker:
+    needs: [prepare]
+    strategy:
+      fail-fast: false
+      matrix:
+        platform: [amd64, arm64]
+        include:
+          - platform: amd64
+            runner: ubuntu-24.04
+          - platform: arm64
+            runner: ubuntu-24.04-arm
+    runs-on: ${{ matrix.runner }}
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+          token: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Configure Git
+        run: |
+          git config user.name "GitHub Actions"
+          git config user.email "actions@github.com"
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v2
+
+      - name: Login to GitHub Container Registry
+        uses: docker/login-action@v2
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Login to Docker Hub
+        uses: docker/login-action@v2
+        with:
+          registry: docker.io
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+
       - name: Build and push Docker base image
         uses: docker/build-push-action@v4
         with:
           context: .
           file: ./docker/DispatcharrBase
-          push: true
-          platforms: linux/amd64,linux/arm64
+          push: ${{ github.event_name != 'pull_request' }}
+          platforms: linux/${{ matrix.platform }}
           tags: |
-            ghcr.io/${{ steps.meta.outputs.repo_owner }}/${{ steps.meta.outputs.repo_name }}:base
-            ghcr.io/${{ steps.meta.outputs.repo_owner }}/${{ steps.meta.outputs.repo_name }}:base-${{ steps.timestamp.outputs.timestamp }}
+            ghcr.io/${{ needs.prepare.outputs.repo_owner }}/${{ needs.prepare.outputs.repo_name }}:${{ needs.prepare.outputs.branch_tag }}-${{ matrix.platform }}
+            ghcr.io/${{ needs.prepare.outputs.repo_owner }}/${{ needs.prepare.outputs.repo_name }}:${{ needs.prepare.outputs.branch_tag }}-${{ needs.prepare.outputs.timestamp }}-${{ matrix.platform }}
+            docker.io/${{ secrets.DOCKERHUB_ORGANIZATION }}/${{ needs.prepare.outputs.repo_name }}:${{ needs.prepare.outputs.branch_tag }}-${{ matrix.platform }}
+            docker.io/${{ secrets.DOCKERHUB_ORGANIZATION }}/${{ needs.prepare.outputs.repo_name }}:${{ needs.prepare.outputs.branch_tag }}-${{ needs.prepare.outputs.timestamp }}-${{ matrix.platform }}
+          build-args: |
+            REPO_OWNER=${{ needs.prepare.outputs.repo_owner }}
+            REPO_NAME=${{ needs.prepare.outputs.repo_name }}
+            BRANCH=${{ github.ref_name }}
+            REPO_URL=https://github.com/${{ github.repository }}
+            TIMESTAMP=${{ needs.prepare.outputs.timestamp }}
+
+  create-manifest:
+    needs: [prepare, docker]
+    runs-on: ubuntu-24.04
+    if: ${{ github.event_name != 'pull_request' }}
+    steps:
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v2
+
+      - name: Login to GitHub Container Registry
+        uses: docker/login-action@v2
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Login to Docker Hub
+        uses: docker/login-action@v2
+        with:
+          registry: docker.io
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: Create multi-arch manifest tags
+        run: |
+          set -euo pipefail
+          OWNER=${{ needs.prepare.outputs.repo_owner }}
+          REPO=${{ needs.prepare.outputs.repo_name }}
+          BRANCH_TAG=${{ needs.prepare.outputs.branch_tag }}
+          TIMESTAMP=${{ needs.prepare.outputs.timestamp }}
+
+          echo "Creating multi-arch manifest for ${OWNER}/${REPO}"
+
+          # GitHub Container Registry manifests
+          # branch tag (e.g. base or base-dev)
+          docker buildx imagetools create --tag ghcr.io/${OWNER}/${REPO}:${BRANCH_TAG} \
+            ghcr.io/${OWNER}/${REPO}:${BRANCH_TAG}-amd64 ghcr.io/${OWNER}/${REPO}:${BRANCH_TAG}-arm64
+
+          # branch + timestamp tag
+          docker buildx imagetools create --tag ghcr.io/${OWNER}/${REPO}:${BRANCH_TAG}-${TIMESTAMP} \
+            ghcr.io/${OWNER}/${REPO}:${BRANCH_TAG}-${TIMESTAMP}-amd64 ghcr.io/${OWNER}/${REPO}:${BRANCH_TAG}-${TIMESTAMP}-arm64
+
+          # Docker Hub manifests
+          # branch tag (e.g. base or base-dev)
+          docker buildx imagetools create --tag docker.io/${{ secrets.DOCKERHUB_ORGANIZATION }}/${REPO}:${BRANCH_TAG} \
+            docker.io/${{ secrets.DOCKERHUB_ORGANIZATION }}/${REPO}:${BRANCH_TAG}-amd64 docker.io/${{ secrets.DOCKERHUB_ORGANIZATION }}/${REPO}:${BRANCH_TAG}-arm64
+
+          # branch + timestamp tag
+          docker buildx imagetools create --tag docker.io/${{ secrets.DOCKERHUB_ORGANIZATION }}/${REPO}:${BRANCH_TAG}-${TIMESTAMP} \
+            docker.io/${{ secrets.DOCKERHUB_ORGANIZATION }}/${REPO}:${BRANCH_TAG}-${TIMESTAMP}-amd64 docker.io/${{ secrets.DOCKERHUB_ORGANIZATION }}/${REPO}:${BRANCH_TAG}-${TIMESTAMP}-arm64
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 4a60ac49..5da4118c 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -2,19 +2,84 @@ name: CI Pipeline
 
 on:
   push:
-    branches: [ dev ]
+    branches: [dev]
   pull_request:
-    branches: [ dev ]
-  workflow_dispatch:  # Allow manual triggering
+    branches: [dev]
+  workflow_dispatch:
 
-# Add explicit permissions for the workflow
 permissions:
-  contents: write    # For managing releases and pushing tags
-  packages: write    # For publishing to GitHub Container Registry
+  contents: write
+  packages: write
 
 jobs:
-  build:
-    runs-on: ubuntu-latest
+  prepare:
+    runs-on: ubuntu-24.04
+    # compute a single timestamp, version, and repo metadata for the entire workflow
+    outputs:
+      repo_owner: ${{ steps.meta.outputs.repo_owner }}
+      repo_name: ${{ steps.meta.outputs.repo_name }}
+      branch_tag: ${{ steps.meta.outputs.branch_tag }}
+      version: ${{ steps.version.outputs.version }}
+      timestamp: ${{ steps.timestamp.outputs.timestamp }}
+
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+          token: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Generate timestamp for build
+        id: timestamp
+        run: |
+          TIMESTAMP=$(date -u +'%Y%m%d%H%M%S')
+          echo "timestamp=${TIMESTAMP}" >> $GITHUB_OUTPUT
+
+      - name: Extract version info
+        id: version
+        run: |
+          VERSION=$(python -c "import version; print(version.__version__)")
+          echo "version=${VERSION}" >> $GITHUB_OUTPUT
+
+      - name: Set repository and image metadata
+        id: meta
+        run: |
+          REPO_OWNER=$(echo "${{ github.repository_owner }}" | tr '[:upper:]' '[:lower:]')
+          echo "repo_owner=${REPO_OWNER}" >> $GITHUB_OUTPUT
+
+          REPO_NAME=$(echo "${{ github.repository }}" | cut -d '/' -f 2 | tr '[:upper:]' '[:lower:]')
+          echo "repo_name=${REPO_NAME}" >> $GITHUB_OUTPUT
+
+          if [[ "${{ github.ref }}" == "refs/heads/main" ]]; then
+            echo "branch_tag=latest" >> $GITHUB_OUTPUT
+            echo "is_main=true" >> $GITHUB_OUTPUT
+          elif [[ "${{ github.ref }}" == "refs/heads/dev" ]]; then
+            echo "branch_tag=dev" >> $GITHUB_OUTPUT
+            echo "is_main=false" >> $GITHUB_OUTPUT
+          else
+            BRANCH=$(echo "${{ github.ref }}" | sed 's/refs\/heads\///' | sed 's/[^a-zA-Z0-9]/-/g')
+            echo "branch_tag=${BRANCH}" >> $GITHUB_OUTPUT
+            echo "is_main=false" >> $GITHUB_OUTPUT
+          fi
+
+          if [[ "${{ github.event.pull_request.head.repo.fork }}" == "true" ]]; then
+            echo "is_fork=true" >> $GITHUB_OUTPUT
+          else
+            echo "is_fork=false" >> $GITHUB_OUTPUT
+          fi
+
+  docker:
+    needs: [prepare]
+    strategy:
+      fail-fast: false
+      matrix:
+        platform: [amd64, arm64]
+        include:
+          - platform: amd64
+            runner: ubuntu-24.04
+          - platform: arm64
+            runner: ubuntu-24.04-arm
+    runs-on: ${{ matrix.runner }}
+    # no per-job outputs here; shared metadata comes from the `prepare` job
     steps:
       - uses: actions/checkout@v3
         with:
@@ -45,66 +110,85 @@ jobs:
           username: ${{ github.actor }}
           password: ${{ secrets.GITHUB_TOKEN }}
 
-      - name: Generate timestamp for build
-        id: timestamp
-        run: |
-          TIMESTAMP=$(date -u +'%Y%m%d%H%M%S')
-          echo "timestamp=${TIMESTAMP}" >> $GITHUB_OUTPUT
+      - name: Login to Docker Hub
+        uses: docker/login-action@v2
+        with:
+          registry: docker.io
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
 
-      - name: Extract version info
-        id: version
-        run: |
-          VERSION=$(python -c "import version; print(version.__version__)")
-          echo "version=${VERSION}" >> $GITHUB_OUTPUT
-          echo "sha_short=${GITHUB_SHA::7}" >> $GITHUB_OUTPUT
-
-      - name: Set repository and image metadata
-        id: meta
-        run: |
-          # Get lowercase repository owner
-          REPO_OWNER=$(echo "${{ github.repository_owner }}" | tr '[:upper:]' '[:lower:]')
-          echo "repo_owner=${REPO_OWNER}" >> $GITHUB_OUTPUT
-
-          # Get repository name
-          REPO_NAME=$(echo "${{ github.repository }}" | cut -d '/' -f 2 | tr '[:upper:]' '[:lower:]')
-          echo "repo_name=${REPO_NAME}" >> $GITHUB_OUTPUT
-
-          # Determine branch name
-          if [[ "${{ github.ref }}" == "refs/heads/main" ]]; then
-            echo "branch_tag=latest" >> $GITHUB_OUTPUT
-            echo "is_main=true" >> $GITHUB_OUTPUT
-          elif [[ "${{ github.ref }}" == "refs/heads/dev" ]]; then
-            echo "branch_tag=dev" >> $GITHUB_OUTPUT
-            echo "is_main=false" >> $GITHUB_OUTPUT
-          else
-            # For other branches, use the branch name
-            BRANCH=$(echo "${{ github.ref }}" | sed 's/refs\/heads\///' | sed 's/[^a-zA-Z0-9]/-/g')
-            echo "branch_tag=${BRANCH}" >> $GITHUB_OUTPUT
-            echo "is_main=false" >> $GITHUB_OUTPUT
-          fi
-
-          # Determine if this is from a fork
-          if [[ "${{ github.event.pull_request.head.repo.fork }}" == "true" ]]; then
-            echo "is_fork=true" >> $GITHUB_OUTPUT
-          else
-            echo "is_fork=false" >> $GITHUB_OUTPUT
-          fi
+      # use metadata from the prepare job
 
       - name: Build and push Docker image
         uses: docker/build-push-action@v4
         with:
           context: .
           push: ${{ github.event_name != 'pull_request' }}
-          platforms: linux/amd64,linux/arm64
+          # Build only the platform for this matrix job to avoid running amd64
+          # stages under qemu on an arm64 runner (and vice-versa). This makes
+          # the matrix runner's platform the one built by buildx.
+          platforms: linux/${{ matrix.platform }}
+          # push arch-specific tags from each matrix job (they will be combined
+          # into a multi-arch manifest in a follow-up job)
           tags: |
-            ghcr.io/${{ steps.meta.outputs.repo_owner }}/${{ steps.meta.outputs.repo_name }}:${{ steps.meta.outputs.branch_tag }}
-            ghcr.io/${{ steps.meta.outputs.repo_owner }}/${{ steps.meta.outputs.repo_name }}:${{ steps.version.outputs.version }}-${{ steps.timestamp.outputs.timestamp }}
-            ghcr.io/${{ steps.meta.outputs.repo_owner }}/${{ steps.meta.outputs.repo_name }}:${{ steps.version.outputs.sha_short }}
+            ghcr.io/${{ needs.prepare.outputs.repo_owner }}/${{ needs.prepare.outputs.repo_name }}:${{ needs.prepare.outputs.branch_tag }}-${{ matrix.platform }}
+            ghcr.io/${{ needs.prepare.outputs.repo_owner }}/${{ needs.prepare.outputs.repo_name }}:${{ needs.prepare.outputs.version }}-${{ needs.prepare.outputs.timestamp }}-${{ matrix.platform }}
+            docker.io/${{ secrets.DOCKERHUB_ORGANIZATION }}/${{ needs.prepare.outputs.repo_name }}:${{ needs.prepare.outputs.branch_tag }}-${{ matrix.platform }}
+            docker.io/${{ secrets.DOCKERHUB_ORGANIZATION }}/${{ needs.prepare.outputs.repo_name }}:${{ needs.prepare.outputs.version }}-${{ needs.prepare.outputs.timestamp }}-${{ matrix.platform }}
           build-args: |
-            REPO_OWNER=${{ steps.meta.outputs.repo_owner }}
-            REPO_NAME=${{ steps.meta.outputs.repo_name }}
+            REPO_OWNER=${{ needs.prepare.outputs.repo_owner }}
+            REPO_NAME=${{ needs.prepare.outputs.repo_name }}
             BASE_TAG=base
             BRANCH=${{ github.ref_name }}
             REPO_URL=https://github.com/${{ github.repository }}
-            TIMESTAMP=${{ steps.timestamp.outputs.timestamp }}
+            TIMESTAMP=${{ needs.prepare.outputs.timestamp }}
           file: ./docker/Dockerfile
+
+  create-manifest:
+    # wait for prepare and all matrix builds to finish
+    needs: [prepare, docker]
+    runs-on: ubuntu-24.04
+    if: ${{ github.event_name != 'pull_request' }}
+    steps:
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v2
+
+      - name: Login to GitHub Container Registry
+        uses: docker/login-action@v2
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Login to Docker Hub
+        uses: docker/login-action@v2
+        with:
+          registry: docker.io
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: Create multi-arch manifest tags
+        run: |
+          set -euo pipefail
+          OWNER=${{ needs.prepare.outputs.repo_owner }}
+          REPO=${{ needs.prepare.outputs.repo_name }}
+          BRANCH_TAG=${{ needs.prepare.outputs.branch_tag }}
+          VERSION=${{ needs.prepare.outputs.version }}
+          TIMESTAMP=${{ needs.prepare.outputs.timestamp }}
+
+          echo "Creating multi-arch manifest for ${OWNER}/${REPO}"
+
+          # branch tag (e.g. latest or dev)
+          docker buildx imagetools create --tag ghcr.io/${OWNER}/${REPO}:${BRANCH_TAG} \
+            ghcr.io/${OWNER}/${REPO}:${BRANCH_TAG}-amd64 ghcr.io/${OWNER}/${REPO}:${BRANCH_TAG}-arm64
+
+          # version + timestamp tag
+          docker buildx imagetools create --tag ghcr.io/${OWNER}/${REPO}:${VERSION}-${TIMESTAMP} \
+            ghcr.io/${OWNER}/${REPO}:${VERSION}-${TIMESTAMP}-amd64 ghcr.io/${OWNER}/${REPO}:${VERSION}-${TIMESTAMP}-arm64
+
+          # also create Docker Hub manifests using the same username
+          docker buildx imagetools create --tag docker.io/${{ secrets.DOCKERHUB_ORGANIZATION }}/${REPO}:${BRANCH_TAG} \
+            docker.io/${{ secrets.DOCKERHUB_ORGANIZATION }}/${REPO}:${BRANCH_TAG}-amd64 docker.io/${{ secrets.DOCKERHUB_ORGANIZATION }}/${REPO}:${BRANCH_TAG}-arm64
+
+          docker buildx imagetools create --tag docker.io/${{ secrets.DOCKERHUB_ORGANIZATION }}/${REPO}:${VERSION}-${TIMESTAMP} \
+            docker.io/${{ secrets.DOCKERHUB_ORGANIZATION }}/${REPO}:${VERSION}-${TIMESTAMP}-amd64 docker.io/${{ secrets.DOCKERHUB_ORGANIZATION }}/${REPO}:${VERSION}-${TIMESTAMP}-arm64
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 52c2ada2..27356c9a 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -15,16 +15,21 @@ on:
 
 # Add explicit permissions for the workflow
 permissions:
-  contents: write    # For managing releases and pushing tags
-  packages: write    # For publishing to GitHub Container Registry
+  contents: write # For managing releases and pushing tags
+  packages: write # For publishing to GitHub Container Registry
 
 jobs:
-  release:
-    runs-on: ubuntu-latest
+  prepare:
+    runs-on: ubuntu-24.04
+    outputs:
+      new_version: ${{ steps.update_version.outputs.new_version }}
+      repo_owner: ${{ steps.meta.outputs.repo_owner }}
+      repo_name: ${{ steps.meta.outputs.repo_name }}
     steps:
       - uses: actions/checkout@v3
         with:
           fetch-depth: 0
+          token: ${{ secrets.GITHUB_TOKEN }}
 
       - name: Configure Git
         run: |
@@ -38,14 +43,45 @@ jobs:
           NEW_VERSION=$(python -c "import version; print(f'{version.__version__}')")
           echo "new_version=${NEW_VERSION}" >> $GITHUB_OUTPUT
 
-      - name: Set lowercase repo owner
-        id: repo_owner
+      - name: Set repository metadata
+        id: meta
         run: |
           REPO_OWNER=$(echo "${{ github.repository_owner }}" | tr '[:upper:]' '[:lower:]')
-          echo "lowercase=${REPO_OWNER}" >> $GITHUB_OUTPUT
+          echo "repo_owner=${REPO_OWNER}" >> $GITHUB_OUTPUT
 
-      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v2
+          REPO_NAME=$(echo "${{ github.repository }}" | cut -d '/' -f 2 | tr '[:upper:]' '[:lower:]')
+          echo "repo_name=${REPO_NAME}" >> $GITHUB_OUTPUT
+
+      - name: Commit and Tag
+        run: |
+          git add version.py
+          git commit -m "Release v${{ steps.update_version.outputs.new_version }}"
+          git tag -a "v${{ steps.update_version.outputs.new_version }}" -m "Release v${{ steps.update_version.outputs.new_version }}"
+          git push origin main --tags
+
+  docker:
+    needs: [prepare]
+    strategy:
+      fail-fast: false
+      matrix:
+        platform: [amd64, arm64]
+        include:
+          - platform: amd64
+            runner: ubuntu-24.04
+          - platform: arm64
+            runner: ubuntu-24.04-arm
+    runs-on: ${{ matrix.runner }}
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+          token: ${{ secrets.GITHUB_TOKEN }}
+          ref: main
+
+      - name: Configure Git
+        run: |
+          git config user.name "GitHub Actions"
+          git config user.email "actions@github.com"
 
       - name: Set up Docker Buildx
         uses: docker/setup-buildx-action@v2
@@ -57,36 +93,88 @@ jobs:
           username: ${{ github.actor }}
           password: ${{ secrets.GITHUB_TOKEN }}
 
-      - name: Commit and Tag
-        run: |
-          git add version.py
-          git commit -m "Release v${{ steps.update_version.outputs.new_version }}"
-          git tag -a "v${{ steps.update_version.outputs.new_version }}" -m "Release v${{ steps.update_version.outputs.new_version }}"
-          git push origin main --tags
+      - name: Login to Docker Hub
+        uses: docker/login-action@v2
+        with:
+          registry: docker.io
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
 
-      - name: Build and Push Release Image
+      - name: Build and push Docker image
         uses: docker/build-push-action@v4
         with:
           context: .
           push: true
-          platforms: linux/amd64,linux/arm64, #linux/arm/v7  # Multi-arch support for releases
+          platforms: linux/${{ matrix.platform }}
           tags: |
-            ghcr.io/${{ steps.repo_owner.outputs.lowercase }}/dispatcharr:latest
-            ghcr.io/${{ steps.repo_owner.outputs.lowercase }}/dispatcharr:${{ steps.update_version.outputs.new_version }}
-            ghcr.io/${{ steps.repo_owner.outputs.lowercase }}/dispatcharr:latest-amd64
-            ghcr.io/${{ steps.repo_owner.outputs.lowercase }}/dispatcharr:latest-arm64
-            ghcr.io/${{ steps.repo_owner.outputs.lowercase }}/dispatcharr:${{ steps.update_version.outputs.new_version }}-amd64
-            ghcr.io/${{ steps.repo_owner.outputs.lowercase }}/dispatcharr:${{ steps.update_version.outputs.new_version }}-arm64
+            ghcr.io/${{ needs.prepare.outputs.repo_owner }}/${{ needs.prepare.outputs.repo_name }}:latest-${{ matrix.platform }}
+            ghcr.io/${{ needs.prepare.outputs.repo_owner }}/${{ needs.prepare.outputs.repo_name }}:${{ needs.prepare.outputs.new_version }}-${{ matrix.platform }}
+            docker.io/${{ secrets.DOCKERHUB_ORGANIZATION }}/${{ needs.prepare.outputs.repo_name }}:latest-${{ matrix.platform }}
+            docker.io/${{ secrets.DOCKERHUB_ORGANIZATION }}/${{ needs.prepare.outputs.repo_name }}:${{ needs.prepare.outputs.new_version }}-${{ matrix.platform }}
           build-args: |
+            REPO_OWNER=${{ needs.prepare.outputs.repo_owner }}
+            REPO_NAME=${{ needs.prepare.outputs.repo_name }}
             BRANCH=${{ github.ref_name }}
             REPO_URL=https://github.com/${{ github.repository }}
           file: ./docker/Dockerfile
 
+  create-manifest:
+    needs: [prepare, docker]
+    runs-on: ubuntu-24.04
+    steps:
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v2
+
+      - name: Login to GitHub Container Registry
+        uses: docker/login-action@v2
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Login to Docker Hub
+        uses: docker/login-action@v2
+        with:
+          registry: docker.io
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: Create multi-arch manifest tags
+        run: |
+          set -euo pipefail
+          OWNER=${{ needs.prepare.outputs.repo_owner }}
+          REPO=${{ needs.prepare.outputs.repo_name }}
+          VERSION=${{ needs.prepare.outputs.new_version }}
+
+          echo "Creating multi-arch manifest for ${OWNER}/${REPO}"
+
+          # GitHub Container Registry manifests
+          # latest tag
+          docker buildx imagetools create --tag ghcr.io/${OWNER}/${REPO}:latest \
+            ghcr.io/${OWNER}/${REPO}:latest-amd64 ghcr.io/${OWNER}/${REPO}:latest-arm64
+
+          # version tag
+          docker buildx imagetools create --tag ghcr.io/${OWNER}/${REPO}:${VERSION} \
+            ghcr.io/${OWNER}/${REPO}:${VERSION}-amd64 ghcr.io/${OWNER}/${REPO}:${VERSION}-arm64
+
+          # Docker Hub manifests
+          # latest tag
+          docker buildx imagetools create --tag docker.io/${{ secrets.DOCKERHUB_ORGANIZATION }}/${REPO}:latest \
+            docker.io/${{ secrets.DOCKERHUB_ORGANIZATION }}/${REPO}:latest-amd64 docker.io/${{ secrets.DOCKERHUB_ORGANIZATION }}/${REPO}:latest-arm64
+
+          # version tag
+          docker buildx imagetools create --tag docker.io/${{ secrets.DOCKERHUB_ORGANIZATION }}/${REPO}:${VERSION} \
+            docker.io/${{ secrets.DOCKERHUB_ORGANIZATION }}/${REPO}:${VERSION}-amd64 docker.io/${{ secrets.DOCKERHUB_ORGANIZATION }}/${REPO}:${VERSION}-arm64
+
+  create-release:
+    needs: [prepare, create-manifest]
+    runs-on: ubuntu-24.04
+    steps:
       - name: Create GitHub Release
         uses: softprops/action-gh-release@v1
         with:
-          tag_name: v${{ steps.update_version.outputs.new_version }}
-          name: Release v${{ steps.update_version.outputs.new_version }}
+          tag_name: v${{ needs.prepare.outputs.new_version }}
+          name: Release v${{ needs.prepare.outputs.new_version }}
           draft: false
           prerelease: false
           token: ${{ secrets.GITHUB_TOKEN }}
diff --git a/apps/channels/api_views.py b/apps/channels/api_views.py
index e7991220..0c562974 100644
--- a/apps/channels/api_views.py
+++ b/apps/channels/api_views.py
@@ -567,6 +567,37 @@ class ChannelViewSet(viewsets.ModelViewSet):
             "channel_count": len(channel_ids)
         })
 
+    @action(detail=False, methods=["post"], url_path="set-tvg-ids-from-epg")
+    def set_tvg_ids_from_epg(self, request):
+        """
+        Trigger a Celery task to set channel TVG-IDs from EPG data
+        """
+        from .tasks import set_channels_tvg_ids_from_epg
+
+        data = request.data
+        channel_ids = data.get("channel_ids", [])
+
+        if not channel_ids:
+            return Response(
+                {"error": "channel_ids is required"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        if not isinstance(channel_ids, list):
+            return Response(
+                {"error": "channel_ids must be a list"},
+                status=status.HTTP_400_BAD_REQUEST,
+            )
+
+        # Start the Celery task
+        task = set_channels_tvg_ids_from_epg.delay(channel_ids)
+
+        return Response({
+            "message": f"Started EPG TVG-ID setting task for {len(channel_ids)} channels",
+            "task_id": task.id,
+            "channel_count": len(channel_ids)
+        })
+
     @action(detail=False, methods=["get"], url_path="ids")
     def get_ids(self, request, *args, **kwargs):
         # Get the filtered queryset
diff --git a/apps/channels/models.py b/apps/channels/models.py
index 5ee7c11e..6609f61d 100644
--- a/apps/channels/models.py
+++ b/apps/channels/models.py
@@ -119,11 +119,11 @@ class Stream(models.Model):
         return self.name or self.url or f"Stream ID {self.id}"
 
     @classmethod
-    def generate_hash_key(cls, name, url, tvg_id, keys=None):
+    def generate_hash_key(cls, name, url, tvg_id, keys=None, m3u_id=None):
         if keys is None:
             keys = CoreSettings.get_m3u_hash_key().split(",")
 
-        stream_parts = {"name": name, "url": url, "tvg_id": tvg_id}
+        stream_parts = {"name": name, "url": url, "tvg_id": tvg_id, "m3u_id": m3u_id}
 
         hash_parts = {key: stream_parts[key] for key in keys if key in stream_parts}
 
diff --git a/apps/channels/tasks.py b/apps/channels/tasks.py
index 23ae82b2..40758d47 100755
--- a/apps/channels/tasks.py
+++ b/apps/channels/tasks.py
@@ -229,6 +229,17 @@ def match_channels_to_epg(channels_data, epg_data, region_code=None, use_ml=True
                 logger.info(f"Channel {chan['id']} '{chan['name']}' => EPG found by secondary tvg_id={chan['tvg_id']}")
                 continue
 
+        # Step 2.5: Exact Gracenote ID match
+        normalized_gracenote_id = chan.get("gracenote_id", "")
+        if normalized_gracenote_id:
+            epg_by_gracenote_id = next((epg for epg in epg_data if epg["tvg_id"] == normalized_gracenote_id), None)
+            if epg_by_gracenote_id:
+                chan["epg_data_id"] = epg_by_gracenote_id["id"]
+                channels_to_update.append(chan)
+                matched_channels.append((chan['id'], fallback_name, f"gracenote:{epg_by_gracenote_id['tvg_id']}"))
+                logger.info(f"Channel {chan['id']} '{fallback_name}' => EPG found by exact gracenote_id={normalized_gracenote_id}")
+                continue
+
         # Step 3: Name-based fuzzy matching
         if not chan["norm_chan"]:
             logger.debug(f"Channel {chan['id']} '{chan['name']}' => empty after normalization, skipping")
@@ -431,11 +442,14 @@ def match_epg_channels():
         channels_data = []
         for channel in channels_without_epg:
             normalized_tvg_id = channel.tvg_id.strip().lower() if channel.tvg_id else ""
+            normalized_gracenote_id = channel.tvc_guide_stationid.strip().lower() if channel.tvc_guide_stationid else ""
             channels_data.append({
                 "id": channel.id,
                 "name": channel.name,
                 "tvg_id": normalized_tvg_id,
                 "original_tvg_id": channel.tvg_id,
+                "gracenote_id": normalized_gracenote_id,
+                "original_gracenote_id": channel.tvc_guide_stationid,
                 "fallback_name": normalized_tvg_id if normalized_tvg_id else channel.name,
                 "norm_chan": normalize_name(channel.name)  # Always use channel name for fuzzy matching!
             })
@@ -575,11 +589,14 @@ def match_selected_channels_epg(channel_ids):
         channels_data = []
         for channel in channels_without_epg:
             normalized_tvg_id = channel.tvg_id.strip().lower() if channel.tvg_id else ""
+            normalized_gracenote_id = channel.tvc_guide_stationid.strip().lower() if channel.tvc_guide_stationid else ""
             channels_data.append({
                 "id": channel.id,
                 "name": channel.name,
                 "tvg_id": normalized_tvg_id,
                 "original_tvg_id": channel.tvg_id,
+                "gracenote_id": normalized_gracenote_id,
+                "original_gracenote_id": channel.tvc_guide_stationid,
                 "fallback_name": normalized_tvg_id if normalized_tvg_id else channel.name,
                 "norm_chan": normalize_name(channel.name)
             })
@@ -696,16 +713,19 @@ def match_single_channel_epg(channel_id):
 
         # Prepare single channel data for matching (same format as bulk matching)
         normalized_tvg_id = channel.tvg_id.strip().lower() if channel.tvg_id else ""
+        normalized_gracenote_id = channel.tvc_guide_stationid.strip().lower() if channel.tvc_guide_stationid else ""
         channel_data = {
             "id": channel.id,
             "name": channel.name,
             "tvg_id": normalized_tvg_id,
             "original_tvg_id": channel.tvg_id,
+            "gracenote_id": normalized_gracenote_id,
+            "original_gracenote_id": channel.tvc_guide_stationid,
             "fallback_name": normalized_tvg_id if normalized_tvg_id else channel.name,
             "norm_chan": normalize_name(channel.name)  # Always use channel name for fuzzy matching!
         }
 
-        logger.info(f"Channel data prepared: name='{channel.name}', tvg_id='{normalized_tvg_id}', norm_chan='{channel_data['norm_chan']}'")
+        logger.info(f"Channel data prepared: name='{channel.name}', tvg_id='{normalized_tvg_id}', gracenote_id='{normalized_gracenote_id}', norm_chan='{channel_data['norm_chan']}'")
 
         # Debug: Test what the normalization does to preserve call signs
         test_name = "NBC 11 (KVLY) - Fargo"  # Example for testing
@@ -2446,7 +2466,9 @@ def bulk_create_channels_from_streams(self, stream_ids, channel_profile_ids=None
 
         for i in range(0, total_streams, batch_size):
             batch_stream_ids = stream_ids[i:i + batch_size]
-            batch_streams = Stream.objects.filter(id__in=batch_stream_ids)
+            # Fetch streams and preserve the order from batch_stream_ids
+            batch_streams_dict = {stream.id: stream for stream in Stream.objects.filter(id__in=batch_stream_ids)}
+            batch_streams = [batch_streams_dict[stream_id] for stream_id in batch_stream_ids if stream_id in batch_streams_dict]
 
             # Send progress update
             send_websocket_update('updates', 'update', {
@@ -2899,3 +2921,98 @@ def set_channels_logos_from_epg(self, channel_ids):
             'error': str(e)
         })
         raise
+
+
+@shared_task(bind=True)
+def set_channels_tvg_ids_from_epg(self, channel_ids):
+    """
+    Celery task to set channel TVG-IDs from EPG data for multiple channels
+    """
+    from core.utils import send_websocket_update
+
+    task_id = self.request.id
+    total_channels = len(channel_ids)
+    updated_count = 0
+    errors = []
+
+    try:
+        logger.info(f"Starting EPG TVG-ID setting task for {total_channels} channels")
+
+        # Send initial progress
+        send_websocket_update('updates', 'update', {
+            'type': 'epg_tvg_id_setting_progress',
+            'task_id': task_id,
+            'progress': 0,
+            'total': total_channels,
+            'status': 'running',
+            'message': 'Starting EPG TVG-ID setting...'
+        })
+
+        batch_size = 100
+        for i in range(0, total_channels, batch_size):
+            batch_ids = channel_ids[i:i + batch_size]
+            batch_updates = []
+
+            # Get channels and their EPG data
+            channels = Channel.objects.filter(id__in=batch_ids).select_related('epg_data')
+
+            for channel in channels:
+                try:
+                    if channel.epg_data and channel.epg_data.tvg_id:
+                        if channel.tvg_id != channel.epg_data.tvg_id:
+                            channel.tvg_id = channel.epg_data.tvg_id
+                            batch_updates.append(channel)
+                            updated_count += 1
+                except Exception as e:
+                    errors.append(f"Channel {channel.id}: {str(e)}")
+                    logger.error(f"Error processing channel {channel.id}: {e}")
+
+            # Bulk update the batch
+            if batch_updates:
+                Channel.objects.bulk_update(batch_updates, ['tvg_id'])
+
+            # Send progress update
+            progress = min(i + batch_size, total_channels)
+            send_websocket_update('updates', 'update', {
+                'type': 'epg_tvg_id_setting_progress',
+                'task_id': task_id,
+                'progress': progress,
+                'total': total_channels,
+                'status': 'running',
+                'message': f'Updated {updated_count} channel TVG-IDs...',
+                'updated_count': updated_count
+            })
+
+        # Send completion notification
+        send_websocket_update('updates', 'update', {
+            'type': 'epg_tvg_id_setting_progress',
+            'task_id': task_id,
+            'progress': total_channels,
+            'total': total_channels,
+            'status': 'completed',
+            'message': f'Successfully updated {updated_count} channel TVG-IDs from EPG data',
+            'updated_count': updated_count,
+            'error_count': len(errors),
+            'errors': errors
+        })
+
+        logger.info(f"EPG TVG-ID setting task completed. Updated {updated_count} channels")
+        return {
+            'status': 'completed',
+            'updated_count': updated_count,
+            'error_count': len(errors),
+            'errors': errors
+        }
+
+    except Exception as e:
+        logger.error(f"EPG TVG-ID setting task failed: {e}")
+        send_websocket_update('updates', 'update', {
+            'type': 'epg_tvg_id_setting_progress',
+            'task_id': task_id,
+            'progress': 0,
+            'total': total_channels,
+            'status': 'failed',
+            'message': f'Task failed: {str(e)}',
+            'error': str(e)
+        })
+        raise
diff --git a/apps/epg/migrations/0017_alter_epgsource_url.py b/apps/epg/migrations/0017_alter_epgsource_url.py
new file mode 100644
index 00000000..dcb55e20
--- /dev/null
+++ b/apps/epg/migrations/0017_alter_epgsource_url.py
@@ -0,0 +1,18 @@
+# Generated by Django 5.2.4 on 2025-09-24 21:07
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('epg', '0016_epgdata_icon_url'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='epgsource',
+            name='url',
+            field=models.URLField(blank=True, max_length=1000, null=True),
+        ),
+    ]
diff --git a/apps/epg/models.py b/apps/epg/models.py
index 3ed33ab2..da6ac8e6 100644
--- a/apps/epg/models.py
+++ b/apps/epg/models.py
@@ -28,7 +28,7 @@ class EPGSource(models.Model):
 
     name = models.CharField(max_length=255, unique=True)
     source_type = models.CharField(max_length=20, choices=SOURCE_TYPE_CHOICES)
-    url = models.URLField(blank=True, null=True)  # For XMLTV
+    url = models.URLField(max_length=1000, blank=True, null=True)  # For XMLTV
     api_key = models.CharField(max_length=255, blank=True, null=True)  # For Schedules Direct
     is_active = models.BooleanField(default=True)
     file_path = models.CharField(max_length=1024, blank=True, null=True)
diff --git a/apps/epg/tasks.py b/apps/epg/tasks.py
index 45b17bb7..d9ae5a5d 100644
--- a/apps/epg/tasks.py
+++ b/apps/epg/tasks.py
@@ -28,6 +28,23 @@ from core.utils import acquire_task_lock, release_task_lock, send_websocket_upda
 
 logger = logging.getLogger(__name__)
 
+
+def validate_icon_url_fast(icon_url, max_length=None):
+    """
+    Fast validation for icon URLs during parsing.
+    Returns None if URL is too long, original URL otherwise.
+    If max_length is None, gets it dynamically from the EPGData model field.
+    """
+    if max_length is None:
+        # Get max_length dynamically from the model field
+        max_length = EPGData._meta.get_field('icon_url').max_length
+
+    if icon_url and len(icon_url) > max_length:
+        logger.warning(f"Icon URL too long ({len(icon_url)} > {max_length}), skipping: {icon_url[:100]}...")
+        return None
+    return icon_url
+
+
 MAX_EXTRACT_CHUNK_SIZE = 65536 # 64kb (base2)
 
 
@@ -831,6 +848,7 @@ def parse_channels_only(source):
         processed_channels = 0
         batch_size = 500  # Process in batches to limit memory usage
         progress = 0  # Initialize progress variable here
+        icon_url_max_length = EPGData._meta.get_field('icon_url').max_length  # Get max length for icon_url field
 
         # Track memory at key points
         if process:
@@ -859,7 +877,7 @@ def parse_channels_only(source):
 
             # Change iterparse to look for both channel and programme elements
             logger.debug(f"Creating iterparse context for channels and programmes")
-            channel_parser = etree.iterparse(source_file, events=('end',), tag=('channel', 'programme'), remove_blank_text=True)
+            channel_parser = etree.iterparse(source_file, events=('end',), tag=('channel', 'programme'), remove_blank_text=True, recover=True)
             if process:
                 logger.debug(f"[parse_channels_only] Memory after creating iterparse: {process.memory_info().rss / 1024 / 1024:.2f} MB")
 
@@ -875,10 +893,11 @@ def parse_channels_only(source):
                         display_name = None
                         icon_url = None
                         for child in elem:
-                            if child.tag == 'display-name' and child.text:
+                            if display_name is None and child.tag == 'display-name' and child.text:
                                 display_name = child.text.strip()
                             elif child.tag == 'icon':
-                                icon_url = child.get('src', '').strip()
+                                raw_icon_url = child.get('src', '').strip()
+                                icon_url = validate_icon_url_fast(raw_icon_url, icon_url_max_length)
                             if display_name and icon_url:
                                 break  # No need to continue if we have both
 
@@ -1223,7 +1242,7 @@ def parse_programs_for_tvg_id(epg_id):
             source_file = open(file_path, 'rb')
 
             # Stream parse the file using lxml's iterparse
-            program_parser = etree.iterparse(source_file, events=('end',), tag='programme',  remove_blank_text=True)
+            program_parser = etree.iterparse(source_file, events=('end',), tag='programme',  remove_blank_text=True, recover=True)
 
             for _, elem in program_parser:
                 if elem.get('channel') == epg.tvg_id:
diff --git a/apps/m3u/tasks.py b/apps/m3u/tasks.py
index 2caeb519..b892caef 100644
--- a/apps/m3u/tasks.py
+++ b/apps/m3u/tasks.py
@@ -774,7 +774,7 @@ def process_xc_category_direct(account_id, batch, groups, hash_keys):
                         group_title = group_name
 
                         stream_hash = Stream.generate_hash_key(
-                            name, url, tvg_id, hash_keys
+                            name, url, tvg_id, hash_keys, m3u_id=account_id
                         )
                         stream_props = {
                             "name": name,
@@ -903,6 +903,8 @@ def process_m3u_batch_direct(account_id, batch, groups, hash_keys):
     stream_hashes = {}
 
     logger.debug(f"Processing batch of {len(batch)} for M3U account {account_id}")
+    if compiled_filters:
+        logger.debug(f"Using compiled filters: {[f[1].regex_pattern for f in compiled_filters]}")
     for stream_info in batch:
         try:
             name, url = stream_info["name"], stream_info["url"]
@@ -912,10 +914,10 @@ def process_m3u_batch_direct(account_id, batch, groups, hash_keys):
             group_title = get_case_insensitive_attr(
                 stream_info["attributes"], "group-title", "Default Group"
             )
-
+            logger.debug(f"Processing stream: {name} - {url} in group {group_title}")
             include = True
             for pattern, filter in compiled_filters:
-                logger.debug(f"Checking filter patterh {pattern}")
+                logger.trace(f"Checking filter pattern {pattern}")
                 target = name
                 if filter.filter_type == "url":
                     target = url
@@ -940,7 +942,7 @@ def process_m3u_batch_direct(account_id, batch, groups, hash_keys):
                 )
                 continue
 
-            stream_hash = Stream.generate_hash_key(name, url, tvg_id, hash_keys)
+            stream_hash = Stream.generate_hash_key(name, url, tvg_id, hash_keys, m3u_id=account_id)
             stream_props = {
                 "name": name,
                 "url": url,
@@ -2071,13 +2073,13 @@ def get_transformed_credentials(account, profile=None):
     base_url = account.server_url
     base_username = account.username
     base_password = account.password    # Build a complete URL with credentials (similar to how IPTV URLs are structured)
-    # Format: http://server.com:port/username/password/rest_of_path
+    # Format: http://server.com:port/live/username/password/1234.ts
     if base_url and base_username and base_password:
         # Remove trailing slash from server URL if present
         clean_server_url = base_url.rstrip('/')
 
         # Build the complete URL with embedded credentials
-        complete_url = f"{clean_server_url}/{base_username}/{base_password}/"
+        complete_url = f"{clean_server_url}/live/{base_username}/{base_password}/1234.ts"
         logger.debug(f"Built complete URL: {complete_url}")
 
         # Apply profile-specific transformations if profile is provided
@@ -2091,14 +2093,14 @@ def get_transformed_credentials(account, profile=None):
                 logger.info(f"Transformed complete URL: {complete_url} -> {transformed_complete_url}")
 
                 # Extract components from the transformed URL
-                # Pattern: http://server.com:port/username/password/
+                # Pattern: http://server.com:port/live/username/password/1234.ts
                 parsed_url = urllib.parse.urlparse(transformed_complete_url)
                 path_parts = [part for part in parsed_url.path.split('/') if part]
 
                 if len(path_parts) >= 2:
                     # Extract username and password from path
-                    transformed_username = path_parts[0]
-                    transformed_password = path_parts[1]
+                    transformed_username = path_parts[1]
+                    transformed_password = path_parts[2]
 
                     # Rebuild server URL without the username/password path
                     transformed_url = f"{parsed_url.scheme}://{parsed_url.netloc}"
diff --git a/apps/output/views.py b/apps/output/views.py
index bbf79acf..e4d05d59 100644
--- a/apps/output/views.py
+++ b/apps/output/views.py
@@ -62,7 +62,7 @@ def generate_m3u(request, profile_name=None, user=None):
                     channel_profiles
                 )
 
-            channels = Channel.objects.filter(**filters).order_by("channel_number")
+            channels = Channel.objects.filter(**filters).distinct().order_by("channel_number")
         else:
             channels = Channel.objects.filter(user_level__lte=user.user_level).order_by(
                 "channel_number"
@@ -95,7 +95,22 @@ def generate_m3u(request, profile_name=None, user=None):
     # Options: 'channel_number' (default), 'tvg_id', 'gracenote'
     tvg_id_source = request.GET.get('tvg_id_source', 'channel_number').lower()
 
-    m3u_content = "#EXTM3U\n"
+    # Build EPG URL with query parameters if needed
+    epg_base_url = build_absolute_uri_with_port(request, reverse('output:epg_endpoint', args=[profile_name]) if profile_name else reverse('output:epg_endpoint'))
+
+    # Optionally preserve certain query parameters
+    preserved_params = ['tvg_id_source', 'cachedlogos', 'days']
+    query_params = {k: v for k, v in request.GET.items() if k in preserved_params}
+    if query_params:
+        from urllib.parse import urlencode
+        epg_url = f"{epg_base_url}?{urlencode(query_params)}"
+    else:
+        epg_url = epg_base_url
+
+    # Add x-tvg-url and url-tvg attribute for EPG URL
+    m3u_content = f'#EXTM3U x-tvg-url="{epg_url}" url-tvg="{epg_url}"\n'
+
+    # Start building M3U content
     for channel in channels:
         group_title = channel.channel_group.name if channel.channel_group else "Default"
 
@@ -311,7 +326,7 @@ def generate_epg(request, profile_name=None, user=None):
                         channel_profiles
                     )
 
-                channels = Channel.objects.filter(**filters).order_by("channel_number")
+                channels = Channel.objects.filter(**filters).distinct().order_by("channel_number")
             else:
                 channels = Channel.objects.filter(user_level__lte=user.user_level).order_by(
                     "channel_number"
@@ -895,7 +910,7 @@ def xc_get_live_streams(request, user, category_id=None):
         if category_id is not None:
             filters["channel_group__id"] = category_id
 
-        channels = Channel.objects.filter(**filters).order_by("channel_number")
+        channels = Channel.objects.filter(**filters).distinct().order_by("channel_number")
     else:
         if not category_id:
             channels = Channel.objects.filter(user_level__lte=user.user_level).order_by("channel_number")
@@ -951,7 +966,10 @@ def xc_get_epg(request, user, short=False):
             channel_profiles = user.channel_profiles.all()
             filters["channelprofilemembership__channel_profile__in"] = channel_profiles
 
-        channel = get_object_or_404(Channel, **filters)
+        # Use filter().first() with distinct instead of get_object_or_404 to handle multiple profile memberships
+        channel = Channel.objects.filter(**filters).distinct().first()
+        if not channel:
+            raise Http404()
     else:
         channel = get_object_or_404(Channel, id=channel_id)
 
diff --git a/apps/proxy/ts_proxy/views.py b/apps/proxy/ts_proxy/views.py
index 582bcc49..e31d0418 100644
--- a/apps/proxy/ts_proxy/views.py
+++ b/apps/proxy/ts_proxy/views.py
@@ -127,9 +127,9 @@ def stream_ts(request, channel_id):
                 )
                 ChannelService.stop_channel(channel_id)
 
-            # Use max retry attempts and connection timeout from config
-            max_retries = ConfigHelper.max_retries()
-            retry_timeout = ConfigHelper.connection_timeout()
+            # Use fixed retry interval and timeout
+            retry_timeout = 1.5  # 1.5 seconds total timeout
+            retry_interval = 0.1  # 100ms between attempts
             wait_start_time = time.time()
 
             stream_url = None
@@ -137,16 +137,18 @@ def stream_ts(request, channel_id):
             transcode = False
             profile_value = None
             error_reason = None
+            attempt = 0
 
-            # Try to get a stream with configured retries
-            for attempt in range(max_retries):
+            # Try to get a stream with fixed interval retries
+            while time.time() - wait_start_time < retry_timeout:
+                attempt += 1
                 stream_url, stream_user_agent, transcode, profile_value = (
                     generate_stream_url(channel_id)
                 )
 
                 if stream_url is not None:
                     logger.info(
-                        f"[{client_id}] Successfully obtained stream for channel {channel_id}"
+                        f"[{client_id}] Successfully obtained stream for channel {channel_id} after {attempt} attempts"
                     )
                     break
 
@@ -158,21 +160,15 @@ def stream_ts(request, channel_id):
                     )
                     break
 
-                # Don't exceed the overall connection timeout
-                if time.time() - wait_start_time > retry_timeout:
-                    logger.warning(
-                        f"[{client_id}] Connection wait timeout exceeded ({retry_timeout}s)"
+                # Wait 100ms before retrying
+                elapsed_time = time.time() - wait_start_time
+                remaining_time = retry_timeout - elapsed_time
+                if remaining_time > retry_interval:
+                    logger.info(
+                        f"[{client_id}] Waiting {retry_interval*1000:.0f}ms for a connection to become available (attempt {attempt}, {remaining_time:.1f}s remaining)"
                     )
-                    break
-
-                # Wait before retrying (using exponential backoff with a cap)
-                wait_time = min(0.5 * (2**attempt), 2.0)  # Caps at 2 seconds
-                logger.info(
-                    f"[{client_id}] Waiting {wait_time:.1f}s for a connection to become available (attempt {attempt+1}/{max_retries})"
-                )
-                gevent.sleep(
-                    wait_time
-                )  # FIXED: Using gevent.sleep instead of time.sleep
+                    gevent.sleep(retry_interval)
+                    retry_interval += 0.025  # Increase wait time by 25ms for next attempt
 
             if stream_url is None:
                 # Make sure to release any stream locks that might have been acquired
diff --git a/apps/proxy/vod_proxy/multi_worker_connection_manager.py b/apps/proxy/vod_proxy/multi_worker_connection_manager.py
index 7577d2af..fefc8739 100644
--- a/apps/proxy/vod_proxy/multi_worker_connection_manager.py
+++ b/apps/proxy/vod_proxy/multi_worker_connection_manager.py
@@ -540,11 +540,9 @@ class RedisBackedVODConnection:
             }
         return {}
 
-    def cleanup(self, connection_manager=None):
-        """Clean up local resources and Redis state"""
-        # Get connection state before cleanup to handle profile decrementing
-        state = self._get_connection_state()
-
+    def cleanup(self, connection_manager=None, current_worker_id=None):
+        """Smart cleanup based on worker ownership and active streams"""
+        # Always clean up local resources first
         if self.local_response:
             self.local_response.close()
             self.local_response = None
@@ -552,38 +550,72 @@ class RedisBackedVODConnection:
             self.local_session.close()
             self.local_session = None
 
-        # Remove from Redis
-        if self.redis_client:
-            try:
-                # Use pipeline for atomic cleanup operations
-                pipe = self.redis_client.pipeline()
+        # Get current connection state to check ownership and active streams
+        state = self._get_connection_state()
 
-                # 1. Remove main connection state (now contains consolidated data)
-                pipe.delete(self.connection_key)
+        if not state:
+            logger.info(f"[{self.session_id}] No connection state found - local cleanup only")
+            return
 
-                # 2. Remove distributed lock
-                pipe.delete(self.lock_key)
+        # Check if there are active streams
+        if state.active_streams > 0:
+            # There are active streams - check ownership
+            if current_worker_id and state.worker_id == current_worker_id:
+                logger.info(f"[{self.session_id}] Active streams present ({state.active_streams}) and we own them - local cleanup only")
+            else:
+                logger.info(f"[{self.session_id}] Active streams present ({state.active_streams}) but owned by worker {state.worker_id} - local cleanup only")
+            return
 
-                # Execute all cleanup operations
-                pipe.execute()
+        # No active streams - we can clean up Redis state
+        if not self.redis_client:
+            logger.info(f"[{self.session_id}] No Redis client - local cleanup only")
+            return
 
-                logger.info(f"[{self.session_id}] Cleaned up all Redis keys (consolidated connection state, locks)")
+        # Acquire lock and do final check before cleanup to prevent race conditions
+        if not self._acquire_lock():
+            logger.warning(f"[{self.session_id}] Could not acquire lock for cleanup - skipping")
+            return
 
-                # Decrement profile connections if we have the state and connection manager
-                if state and state.m3u_profile_id and connection_manager:
-                    logger.info(f"[{self.session_id}] Decrementing profile connection count for profile {state.m3u_profile_id}")
-                    connection_manager._decrement_profile_connections(state.m3u_profile_id)
-                    logger.info(f"[{self.session_id}] Profile connection count decremented for profile {state.m3u_profile_id}")
-                else:
-                    if not state:
-                        logger.warning(f"[{self.session_id}] No connection state found during cleanup - cannot decrement profile connections")
-                    elif not state.m3u_profile_id:
-                        logger.warning(f"[{self.session_id}] No profile ID in connection state - cannot decrement profile connections")
-                    elif not connection_manager:
-                        logger.warning(f"[{self.session_id}] No connection manager provided - cannot decrement profile connections")
+        try:
+            # Re-check active streams with lock held to prevent race conditions
+            current_state = self._get_connection_state()
+            if not current_state:
+                logger.info(f"[{self.session_id}] Connection state no longer exists - cleanup already done")
+                return
 
-            except Exception as e:
-                logger.error(f"[{self.session_id}] Error cleaning up Redis state: {e}")
+            if current_state.active_streams > 0:
+                logger.info(f"[{self.session_id}] Active streams now present ({current_state.active_streams}) - skipping cleanup")
+                return
+
+            # Use pipeline for atomic cleanup operations
+            pipe = self.redis_client.pipeline()
+
+            # 1. Remove main connection state (contains consolidated data)
+            pipe.delete(self.connection_key)
+
+            # 2. Remove distributed lock (will be released below anyway)
+            pipe.delete(self.lock_key)
+
+            # Execute all cleanup operations
+            pipe.execute()
+
+            logger.info(f"[{self.session_id}] Cleaned up Redis keys (verified no active streams)")
+
+            # Decrement profile connections if we have the state and connection manager
+            if state.m3u_profile_id and connection_manager:
+                connection_manager._decrement_profile_connections(state.m3u_profile_id)
+                logger.info(f"[{self.session_id}] Profile connection count decremented for profile {state.m3u_profile_id}")
+            else:
+                if not state.m3u_profile_id:
+                    logger.warning(f"[{self.session_id}] No profile ID in connection state - cannot decrement profile connections")
+                elif not connection_manager:
+                    logger.warning(f"[{self.session_id}] No connection manager provided - cannot decrement profile connections")
+
+        except Exception as e:
+            logger.error(f"[{self.session_id}] Error cleaning up Redis state: {e}")
+        finally:
+            # Always release the lock
+            self._release_lock()
 
 
 # Modify the VODConnectionManager to use Redis-backed connections
@@ -694,6 +726,15 @@ class MultiWorkerVODConnectionManager:
                 logger.info(f"[{client_id}] Worker {self.worker_id} - Found matching idle session: {matching_session_id}")
                 effective_session_id = matching_session_id
                 client_id = matching_session_id  # Update client_id for logging consistency
+
+                # IMMEDIATELY reserve this session by incrementing active streams to prevent cleanup
+                temp_connection = RedisBackedVODConnection(effective_session_id, self.redis_client)
+                if temp_connection.increment_active_streams():
+                    logger.info(f"[{client_id}] Reserved idle session - incremented active streams")
+                else:
+                    logger.warning(f"[{client_id}] Failed to reserve idle session - falling back to new session")
+                    effective_session_id = session_id
+                    matching_session_id = None  # Clear the match so we create a new connection
             else:
                 logger.info(f"[{client_id}] Worker {self.worker_id} - No matching idle session found, using new session")
                 effective_session_id = session_id
@@ -761,14 +802,20 @@ class MultiWorkerVODConnectionManager:
             else:
                 logger.info(f"[{client_id}] Worker {self.worker_id} - Using existing Redis-backed connection")
 
-                # Update session activity in consolidated connection state
+                # Transfer ownership to current worker and update session activity
                 if redis_connection._acquire_lock():
                     try:
                         state = redis_connection._get_connection_state()
                         if state:
+                            old_worker = state.worker_id
                             state.last_activity = time.time()
-                            state.worker_id = self.worker_id  # Track which worker last accessed this
+                            state.worker_id = self.worker_id  # Transfer ownership to current worker
                             redis_connection._save_connection_state(state)
+
+                            if old_worker != self.worker_id:
+                                logger.info(f"[{client_id}] Ownership transferred from worker {old_worker} to {self.worker_id}")
+                            else:
+                                logger.debug(f"[{client_id}] Worker {self.worker_id} retaining ownership")
                     finally:
                         redis_connection._release_lock()
 
@@ -788,8 +835,13 @@ class MultiWorkerVODConnectionManager:
                 try:
                     logger.info(f"[{client_id}] Worker {self.worker_id} - Starting Redis-backed stream")
 
-                    # Increment active streams
-                    redis_connection.increment_active_streams()
+                    # Increment active streams (unless we already did it for session reuse)
+                    if not matching_session_id:
+                        # New session - increment active streams
+                        redis_connection.increment_active_streams()
+                    else:
+                        # Reused session - we already incremented when reserving the session
+                        logger.debug(f"[{client_id}] Using pre-reserved session - active streams already incremented")
 
                     bytes_sent = 0
                     chunk_count = 0
@@ -819,13 +871,13 @@ class MultiWorkerVODConnectionManager:
                     redis_connection.decrement_active_streams()
                     decremented = True
 
-                    # Schedule cleanup if no active streams after normal completion
+                    # Schedule smart cleanup if no active streams after normal completion
                     if not redis_connection.has_active_streams():
                         def delayed_cleanup():
                             time.sleep(1)  # Wait 1 second
-                            if not redis_connection.has_active_streams():
-                                logger.info(f"[{client_id}] Worker {self.worker_id} - Cleaning up idle Redis connection after normal completion")
-                                redis_connection.cleanup(connection_manager=self)
+                            # Smart cleanup: check active streams and ownership
+                            logger.info(f"[{client_id}] Worker {self.worker_id} - Checking for smart cleanup after normal completion")
+                            redis_connection.cleanup(connection_manager=self, current_worker_id=self.worker_id)
 
                         import threading
                         cleanup_thread = threading.Thread(target=delayed_cleanup)
@@ -838,13 +890,13 @@ class MultiWorkerVODConnectionManager:
                         redis_connection.decrement_active_streams()
                         decremented = True
 
-                    # Schedule cleanup if no active streams
+                    # Schedule smart cleanup if no active streams
                     if not redis_connection.has_active_streams():
                         def delayed_cleanup():
                             time.sleep(1)  # Wait 1 second
-                            if not redis_connection.has_active_streams():
-                                logger.info(f"[{client_id}] Worker {self.worker_id} - Cleaning up idle Redis connection")
-                                redis_connection.cleanup(connection_manager=self)
+                            # Smart cleanup: check active streams and ownership
+                            logger.info(f"[{client_id}] Worker {self.worker_id} - Checking for smart cleanup after client disconnect")
+                            redis_connection.cleanup(connection_manager=self, current_worker_id=self.worker_id)
 
                         import threading
                         cleanup_thread = threading.Thread(target=delayed_cleanup)
@@ -856,7 +908,8 @@ class MultiWorkerVODConnectionManager:
                     if not decremented:
                         redis_connection.decrement_active_streams()
                         decremented = True
-                    redis_connection.cleanup(connection_manager=self)
+                    # Smart cleanup on error - immediate cleanup since we're in error state
+                    redis_connection.cleanup(connection_manager=self, current_worker_id=self.worker_id)
                     yield b"Error: Stream interrupted"
 
                 finally:
diff --git a/apps/proxy/vod_proxy/views.py b/apps/proxy/vod_proxy/views.py
index f24dc3d8..00ed8a10 100644
--- a/apps/proxy/vod_proxy/views.py
+++ b/apps/proxy/vod_proxy/views.py
@@ -176,14 +176,15 @@ class VODStreamView(View):
                 logger.error(f"[VOD-ERROR] No stream URL available for {content_type} {content_id}")
                 return HttpResponse("No stream URL available", status=503)
 
-            # Get M3U profile
-            m3u_profile = self._get_m3u_profile(m3u_account, profile_id)
+            # Get M3U profile (returns profile and current connection count)
+            profile_result = self._get_m3u_profile(m3u_account, profile_id, session_id)
 
-            if not m3u_profile:
+            if not profile_result or not profile_result[0]:
                 logger.error(f"[VOD-ERROR] No suitable M3U profile found for {content_type} {content_id}")
                 return HttpResponse("No available stream", status=503)
 
-            logger.info(f"[VOD-PROFILE] Using M3U profile: {m3u_profile.id} (max_streams: {m3u_profile.max_streams}, current: {m3u_profile.current_viewers})")
+            m3u_profile, current_connections = profile_result
+            logger.info(f"[VOD-PROFILE] Using M3U profile: {m3u_profile.id} (max_streams: {m3u_profile.max_streams}, current: {current_connections})")
 
             # Connection tracking is handled by the connection manager
             # Transform URL based on profile
@@ -279,11 +280,13 @@ class VODStreamView(View):
                 logger.error(f"[VOD-HEAD] No stream URL available for {content_type} {content_id}")
                 return HttpResponse("No stream URL available", status=503)
 
-            # Get M3U profile
-            m3u_profile = self._get_m3u_profile(m3u_account, profile_id)
-            if not m3u_profile:
-                logger.error(f"[VOD-HEAD] No M3U profile found")
-                return HttpResponse("Profile not found", status=404)
+            # Get M3U profile (returns profile and current connection count)
+            profile_result = self._get_m3u_profile(m3u_account, profile_id, session_id)
+            if not profile_result or not profile_result[0]:
+                logger.error(f"[VOD-HEAD] No M3U profile found or all profiles at capacity")
+                return HttpResponse("No available stream", status=503)
+
+            m3u_profile, current_connections = profile_result
 
             # Transform URL if needed
             final_stream_url = self._transform_url(stream_url, m3u_profile)
@@ -517,10 +520,63 @@ class VODStreamView(View):
             logger.error(f"[VOD-URL] Error getting stream URL from relation: {e}", exc_info=True)
             return None
 
-    def _get_m3u_profile(self, m3u_account, profile_id):
-        """Get appropriate M3U profile for streaming"""
+    def _get_m3u_profile(self, m3u_account, profile_id, session_id=None):
+        """Get appropriate M3U profile for streaming using Redis-based viewer counts
+
+        Args:
+            m3u_account: M3UAccount instance
+            profile_id: Optional specific profile ID requested
+            session_id: Optional session ID to check for existing connections
+
+        Returns:
+            tuple: (M3UAccountProfile, current_connections) or None if no profile found
+        """
         try:
-            # If specific profile requested, try to use it
+            from core.utils import RedisClient
+            redis_client = RedisClient.get_client()
+
+            if not redis_client:
+                logger.warning("Redis not available, falling back to default profile")
+                default_profile = M3UAccountProfile.objects.filter(
+                    m3u_account=m3u_account,
+                    is_active=True,
+                    is_default=True
+                ).first()
+                return (default_profile, 0) if default_profile else None
+
+            # Check if this session already has an active connection
+            if session_id:
+                persistent_connection_key = f"vod_persistent_connection:{session_id}"
+                connection_data = redis_client.hgetall(persistent_connection_key)
+
+                if connection_data:
+                    # Decode Redis hash data
+                    decoded_data = {}
+                    for k, v in connection_data.items():
+                        k_str = k.decode('utf-8') if isinstance(k, bytes) else k
+                        v_str = v.decode('utf-8') if isinstance(v, bytes) else v
+                        decoded_data[k_str] = v_str
+
+                    existing_profile_id = decoded_data.get('m3u_profile_id')
+                    if existing_profile_id:
+                        try:
+                            existing_profile = M3UAccountProfile.objects.get(
+                                id=int(existing_profile_id),
+                                m3u_account=m3u_account,
+                                is_active=True
+                            )
+                            # Get current connections for logging
+                            profile_connections_key = f"profile_connections:{existing_profile.id}"
+                            current_connections = int(redis_client.get(profile_connections_key) or 0)
+
+                            logger.info(f"[PROFILE-SELECTION] Session {session_id} reusing existing profile {existing_profile.id}: {current_connections}/{existing_profile.max_streams} connections")
+                            return (existing_profile, current_connections)
+                        except (M3UAccountProfile.DoesNotExist, ValueError):
+                            logger.warning(f"[PROFILE-SELECTION] Session {session_id} has invalid profile ID {existing_profile_id}, selecting new profile")
+                        except Exception as e:
+                            logger.warning(f"[PROFILE-SELECTION] Error checking existing profile for session {session_id}: {e}")
+                    else:
+                        logger.debug(f"[PROFILE-SELECTION] Session {session_id} exists but has no profile ID stored")            # If specific profile requested, try to use it
             if profile_id:
                 try:
                     profile = M3UAccountProfile.objects.get(
@@ -528,24 +584,46 @@ class VODStreamView(View):
                         m3u_account=m3u_account,
                         is_active=True
                     )
-                    if profile.current_viewers < profile.max_streams or profile.max_streams == 0:
-                        return profile
-                except M3UAccountProfile.DoesNotExist:
-                    pass
+                    # Check Redis-based current connections
+                    profile_connections_key = f"profile_connections:{profile.id}"
+                    current_connections = int(redis_client.get(profile_connections_key) or 0)
 
-            # Find available profile ordered by current usage (least loaded first)
-            profiles = M3UAccountProfile.objects.filter(
+                    if profile.max_streams == 0 or current_connections < profile.max_streams:
+                        logger.info(f"[PROFILE-SELECTION] Using requested profile {profile.id}: {current_connections}/{profile.max_streams} connections")
+                        return (profile, current_connections)
+                    else:
+                        logger.warning(f"[PROFILE-SELECTION] Requested profile {profile.id} is at capacity: {current_connections}/{profile.max_streams}")
+                except M3UAccountProfile.DoesNotExist:
+                    logger.warning(f"[PROFILE-SELECTION] Requested profile {profile_id} not found")
+
+            # Get active profiles ordered by priority (default first)
+            m3u_profiles = M3UAccountProfile.objects.filter(
                 m3u_account=m3u_account,
                 is_active=True
-            ).order_by('current_viewers')
+            )
+
+            default_profile = m3u_profiles.filter(is_default=True).first()
+            if not default_profile:
+                logger.error(f"[PROFILE-SELECTION] No default profile found for M3U account {m3u_account.id}")
+                return None
+
+            # Check profiles in order: default first, then others
+            profiles = [default_profile] + list(m3u_profiles.filter(is_default=False))
 
             for profile in profiles:
-                # Check if profile has available connection slots
-                if profile.current_viewers < profile.max_streams or profile.max_streams == 0:
-                    return profile
+                profile_connections_key = f"profile_connections:{profile.id}"
+                current_connections = int(redis_client.get(profile_connections_key) or 0)
 
-            # Fallback to default profile even if over limit
-            return profiles.filter(is_default=True).first()
+                # Check if profile has available connection slots
+                if profile.max_streams == 0 or current_connections < profile.max_streams:
+                    logger.info(f"[PROFILE-SELECTION] Selected profile {profile.id} ({profile.name}): {current_connections}/{profile.max_streams} connections")
+                    return (profile, current_connections)
+                else:
+                    logger.debug(f"[PROFILE-SELECTION] Profile {profile.id} at capacity: {current_connections}/{profile.max_streams}")
+
+            # All profiles are at capacity - return None to trigger error response
+            logger.error(f"[PROFILE-SELECTION] All profiles at capacity for M3U account {m3u_account.id}, rejecting request")
+            return None
 
         except Exception as e:
             logger.error(f"Error getting M3U profile: {e}")
diff --git a/core/migrations/0009_m3u_hash_settings.py b/core/migrations/0009_m3u_hash_settings.py
index eab5f141..3c6283fa 100644
--- a/core/migrations/0009_m3u_hash_settings.py
+++ b/core/migrations/0009_m3u_hash_settings.py
@@ -8,7 +8,7 @@ def preload_core_settings(apps, schema_editor):
     CoreSettings.objects.create(
         key=slugify("M3U Hash Key"),
         name="M3U Hash Key",
-        value="name,url,tvg_id",
+        value="url",
     )
 
 class Migration(migrations.Migration):
diff --git a/core/tasks.py b/core/tasks.py
index 7bd3975b..f757613b 100644
--- a/core/tasks.py
+++ b/core/tasks.py
@@ -513,7 +513,7 @@ def rehash_streams(keys):
 
                 for obj in batch:
                     # Generate new hash
-                    new_hash = Stream.generate_hash_key(obj.name, obj.url, obj.tvg_id, keys)
+                    new_hash = Stream.generate_hash_key(obj.name, obj.url, obj.tvg_id, keys, m3u_id=obj.m3u_account_id)
 
                     # Check if this hash already exists in our tracking dict or in database
                     if new_hash in hash_keys:
diff --git a/docker/Dockerfile b/docker/Dockerfile
index ec24c818..dc437227 100644
--- a/docker/Dockerfile
+++ b/docker/Dockerfile
@@ -4,11 +4,15 @@ ARG REPO_NAME=dispatcharr
 ARG BASE_TAG=base
 
 # --- Build frontend ---
-FROM node:20 AS frontend-builder
+
+FROM node:24 AS frontend-builder
+
 WORKDIR /app/frontend
 COPY ./frontend /app/frontend
-RUN corepack enable && corepack prepare yarn@stable --activate && \
-    yarn install && yarn build && \
+# remove any node_modules that may have been copied from the host (x86)
+RUN rm -rf node_modules || true; \
+    npm install --no-audit --progress=false;
+RUN    npm run build; \
     rm -rf node_modules .cache
 
 # --- Redeclare build arguments for the next stage ---
diff --git a/docker/docker-compose.aio.yml b/docker/docker-compose.aio.yml
index 0cf387d5..90cd8654 100644
--- a/docker/docker-compose.aio.yml
+++ b/docker/docker-compose.aio.yml
@@ -9,7 +9,6 @@ services:
       - 9191:9191
     volumes:
       - dispatcharr_data:/data
-      - ./data:/data
     environment:
       - DISPATCHARR_ENV=aio
       - REDIS_HOST=localhost
diff --git a/docker/docker-compose.yml b/docker/docker-compose.yml
index 88f9fc84..dd989c81 100644
--- a/docker/docker-compose.yml
+++ b/docker/docker-compose.yml
@@ -53,7 +53,7 @@ services:
     command: >
       bash -c "
       cd /app &&
-      celery -A dispatcharr worker -l info
+      nice -n 5 celery -A dispatcharr worker -l info
       "
 
   db:
diff --git a/docker/uwsgi.debug.ini b/docker/uwsgi.debug.ini
index e049df87..fa94df92 100644
--- a/docker/uwsgi.debug.ini
+++ b/docker/uwsgi.debug.ini
@@ -8,8 +8,8 @@ exec-before = python /app/scripts/wait_for_redis.py
 ; Start Redis first
 attach-daemon = redis-server
 ; Then start other services
-attach-daemon = celery -A dispatcharr worker --autoscale=6,1
-attach-daemon = celery -A dispatcharr beat
+attach-daemon = nice -n 5 celery -A dispatcharr worker --autoscale=6,1
+attach-daemon = nice -n 5 celery -A dispatcharr beat
 attach-daemon = daphne -b 0.0.0.0 -p 8001 dispatcharr.asgi:application
 attach-daemon = cd /app/frontend && npm run dev
 
diff --git a/docker/uwsgi.dev.ini b/docker/uwsgi.dev.ini
index 7e50f2ef..6eca871d 100644
--- a/docker/uwsgi.dev.ini
+++ b/docker/uwsgi.dev.ini
@@ -10,8 +10,8 @@ exec-pre = python /app/scripts/wait_for_redis.py
 ; Start Redis first
 attach-daemon = redis-server
 ; Then start other services
-attach-daemon = celery -A dispatcharr worker --autoscale=6,1
-attach-daemon = celery -A dispatcharr beat
+attach-daemon = nice -n 5 celery -A dispatcharr worker --autoscale=6,1
+attach-daemon = nice -n 5 celery -A dispatcharr beat
 attach-daemon = daphne -b 0.0.0.0 -p 8001 dispatcharr.asgi:application
 attach-daemon = cd /app/frontend && npm run dev
 
diff --git a/docker/uwsgi.ini b/docker/uwsgi.ini
index b35ea5bf..f763c3bc 100644
--- a/docker/uwsgi.ini
+++ b/docker/uwsgi.ini
@@ -10,8 +10,8 @@ exec-pre = python /app/scripts/wait_for_redis.py
 ; Start Redis first
 attach-daemon = redis-server
 ; Then start other services
-attach-daemon = celery -A dispatcharr worker --autoscale=6,1
-attach-daemon = celery -A dispatcharr beat
+attach-daemon = nice -n 5 celery -A dispatcharr worker --autoscale=6,1
+attach-daemon = nice -n 5 celery -A dispatcharr beat
 attach-daemon = daphne -b 0.0.0.0 -p 8001 dispatcharr.asgi:application
 
 # Core settings
diff --git a/frontend/package-lock.json b/frontend/package-lock.json
index 5325ff6c..780aabe1 100644
--- a/frontend/package-lock.json
+++ b/frontend/package-lock.json
@@ -1,11 +1,11 @@
 {
-  "name": "vite",
+  "name": "frontend",
   "version": "0.0.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
-      "name": "vite",
+      "name": "frontend",
       "version": "0.0.0",
       "dependencies": {
         "@dnd-kit/core": "^6.3.1",
@@ -20,14 +20,14 @@
         "@mantine/hooks": "~8.0.1",
         "@mantine/notifications": "~8.0.1",
         "@tanstack/react-table": "^8.21.2",
-        "allotment": "^1.20.3",
+        "allotment": "^1.20.4",
         "dayjs": "^1.11.13",
         "formik": "^2.4.6",
         "hls.js": "^1.5.20",
         "lucide-react": "^0.511.0",
         "mpegts.js": "^1.8.0",
-        "react": "^19.0.0",
-        "react-dom": "^19.0.0",
+        "react": "^19.1.0",
+        "react-dom": "^19.1.0",
         "react-draggable": "^4.4.6",
         "react-pro-sidebar": "^1.1.0",
         "react-router-dom": "^7.3.0",
@@ -41,17 +41,66 @@
       },
       "devDependencies": {
         "@eslint/js": "^9.21.0",
-        "@types/react": "^19.0.10",
-        "@types/react-dom": "^19.0.4",
-        "@vitejs/plugin-react-swc": "^3.8.0",
+        "@swc/core": "npm:@swc/wasm@1.13.20",
+        "@swc/wasm": "^1.13.20",
+        "@testing-library/dom": "^10.4.1",
+        "@testing-library/jest-dom": "^6.8.0",
+        "@testing-library/react": "^16.3.0",
+        "@testing-library/user-event": "^14.6.1",
+        "@types/react": "^19.1.0",
+        "@types/react-dom": "^19.1.0",
+        "@vitejs/plugin-react-swc": "^4.1.0",
         "eslint": "^9.21.0",
         "eslint-plugin-react-hooks": "^5.1.0",
         "eslint-plugin-react-refresh": "^0.4.19",
         "globals": "^15.15.0",
+        "jsdom": "^27.0.0",
         "prettier": "^3.5.3",
-        "vite": "^6.2.0"
+        "vite": "^6.2.0",
+        "vitest": "^3.2.4"
       }
     },
+    "node_modules/@adobe/css-tools": {
+      "version": "4.4.4",
+      "resolved": "https://registry.npmjs.org/@adobe/css-tools/-/css-tools-4.4.4.tgz",
+      "integrity": "sha512-Elp+iwUx5rN5+Y8xLt5/GRoG20WGoDCQ/1Fb+1LiGtvwbDavuSk0jhD/eZdckHAuzcDzccnkv+rEjyWfRx18gg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@asamuzakjp/css-color": {
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/@asamuzakjp/css-color/-/css-color-4.0.4.tgz",
+      "integrity": "sha512-cKjSKvWGmAziQWbCouOsFwb14mp1betm8Y7Fn+yglDMUUu3r9DCbJ9iJbeFDenLMqFbIMC0pQP8K+B8LAxX3OQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@csstools/css-calc": "^2.1.4",
+        "@csstools/css-color-parser": "^3.0.10",
+        "@csstools/css-parser-algorithms": "^3.0.5",
+        "@csstools/css-tokenizer": "^3.0.4",
+        "lru-cache": "^11.1.0"
+      }
+    },
+    "node_modules/@asamuzakjp/dom-selector": {
+      "version": "6.5.5",
+      "resolved": "https://registry.npmjs.org/@asamuzakjp/dom-selector/-/dom-selector-6.5.5.tgz",
+      "integrity": "sha512-kI2MX9pmImjxWT8nxDZY+MuN6r1jJGe7WxizEbsAEPB/zxfW5wYLIiPG1v3UKgEOOP8EsDkp0ZL99oRFAdPM8g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@asamuzakjp/nwsapi": "^2.3.9",
+        "bidi-js": "^1.0.3",
+        "css-tree": "^3.1.0",
+        "is-potential-custom-element-name": "^1.0.1"
+      }
+    },
+    "node_modules/@asamuzakjp/nwsapi": {
+      "version": "2.3.9",
+      "resolved": "https://registry.npmjs.org/@asamuzakjp/nwsapi/-/nwsapi-2.3.9.tgz",
+      "integrity": "sha512-n8GuYSrI9bF7FFZ/SjhwevlHc8xaVlb/7HmHelnc/PZXBD2ZR49NnN9sMMuDdEGPeeRQ5d0hqlSlEpgCX3Wl0Q==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/@babel/code-frame": {
       "version": "7.26.2",
       "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.26.2.tgz",
@@ -194,6 +243,144 @@
         "node": ">=6.9.0"
       }
     },
+    "node_modules/@csstools/color-helpers": {
+      "version": "5.1.0",
+      "resolved": "https://registry.npmjs.org/@csstools/color-helpers/-/color-helpers-5.1.0.tgz",
+      "integrity": "sha512-S11EXWJyy0Mz5SYvRmY8nJYTFFd1LCNV+7cXyAgQtOOuzb4EsgfqDufL+9esx72/eLhsRdGZwaldu/h+E4t4BA==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        }
+      ],
+      "license": "MIT-0",
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@csstools/css-calc": {
+      "version": "2.1.4",
+      "resolved": "https://registry.npmjs.org/@csstools/css-calc/-/css-calc-2.1.4.tgz",
+      "integrity": "sha512-3N8oaj+0juUw/1H3YwmDDJXCgTB1gKU6Hc/bB502u9zR0q2vd786XJH9QfrKIEgFlZmhZiq6epXl4rHqhzsIgQ==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        }
+      ],
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@csstools/css-parser-algorithms": "^3.0.5",
+        "@csstools/css-tokenizer": "^3.0.4"
+      }
+    },
+    "node_modules/@csstools/css-color-parser": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/@csstools/css-color-parser/-/css-color-parser-3.1.0.tgz",
+      "integrity": "sha512-nbtKwh3a6xNVIp/VRuXV64yTKnb1IjTAEEh3irzS+HkKjAOYLTGNb9pmVNntZ8iVBHcWDA2Dof0QtPgFI1BaTA==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "@csstools/color-helpers": "^5.1.0",
+        "@csstools/css-calc": "^2.1.4"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@csstools/css-parser-algorithms": "^3.0.5",
+        "@csstools/css-tokenizer": "^3.0.4"
+      }
+    },
+    "node_modules/@csstools/css-parser-algorithms": {
+      "version": "3.0.5",
+      "resolved": "https://registry.npmjs.org/@csstools/css-parser-algorithms/-/css-parser-algorithms-3.0.5.tgz",
+      "integrity": "sha512-DaDeUkXZKjdGhgYaHNJTV9pV7Y9B3b644jCLs9Upc3VeNGg6LWARAT6O+Q+/COo+2gg/bM5rhpMAtf70WqfBdQ==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        }
+      ],
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@csstools/css-tokenizer": "^3.0.4"
+      }
+    },
+    "node_modules/@csstools/css-syntax-patches-for-csstree": {
+      "version": "1.0.14",
+      "resolved": "https://registry.npmjs.org/@csstools/css-syntax-patches-for-csstree/-/css-syntax-patches-for-csstree-1.0.14.tgz",
+      "integrity": "sha512-zSlIxa20WvMojjpCSy8WrNpcZ61RqfTfX3XTaOeVlGJrt/8HF3YbzgFZa01yTbT4GWQLwfTcC3EB8i3XnB647Q==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        }
+      ],
+      "license": "MIT-0",
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "postcss": "^8.4"
+      }
+    },
+    "node_modules/@csstools/css-tokenizer": {
+      "version": "3.0.4",
+      "resolved": "https://registry.npmjs.org/@csstools/css-tokenizer/-/css-tokenizer-3.0.4.tgz",
+      "integrity": "sha512-Vd/9EVDiu6PPJt9yAh6roZP6El1xHrdvIVGjyBsHR0RYwNHgL7FJPyIIW4fANJNG6FtyZfvlRPpFI4ZM/lubvw==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        }
+      ],
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      }
+    },
     "node_modules/@dnd-kit/accessibility": {
       "version": "3.1.1",
       "resolved": "https://registry.npmjs.org/@dnd-kit/accessibility/-/accessibility-3.1.1.tgz",
@@ -407,6 +594,278 @@
       "integrity": "sha512-snKqtPW01tN0ui7yu9rGv69aJXr/a/Ywvl11sUjNtEcRc+ng/mQriFL0wLXMef74iHa/EkftbDzU9F8iFbH+zg==",
       "license": "MIT"
     },
+    "node_modules/@esbuild/aix-ppc64": {
+      "version": "0.25.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.25.1.tgz",
+      "integrity": "sha512-kfYGy8IdzTGy+z0vFGvExZtxkFlA4zAxgKEahG9KE1ScBjpQnFsNOX8KTU5ojNru5ed5CVoJYXFtoxaq5nFbjQ==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "aix"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-arm": {
+      "version": "0.25.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.25.1.tgz",
+      "integrity": "sha512-dp+MshLYux6j/JjdqVLnMglQlFu+MuVeNrmT5nk6q07wNhCdSnB7QZj+7G8VMUGh1q+vj2Bq8kRsuyA00I/k+Q==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-arm64": {
+      "version": "0.25.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.25.1.tgz",
+      "integrity": "sha512-50tM0zCJW5kGqgG7fQ7IHvQOcAn9TKiVRuQ/lN0xR+T2lzEFvAi1ZcS8DiksFcEpf1t/GYOeOfCAgDHFpkiSmA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/android-x64": {
+      "version": "0.25.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.25.1.tgz",
+      "integrity": "sha512-GCj6WfUtNldqUzYkN/ITtlhwQqGWu9S45vUXs7EIYf+7rCiiqH9bCloatO9VhxsL0Pji+PF4Lz2XXCES+Q8hDw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/darwin-arm64": {
+      "version": "0.25.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.25.1.tgz",
+      "integrity": "sha512-5hEZKPf+nQjYoSr/elb62U19/l1mZDdqidGfmFutVUjjUZrOazAtwK+Kr+3y0C/oeJfLlxo9fXb1w7L+P7E4FQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/darwin-x64": {
+      "version": "0.25.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.25.1.tgz",
+      "integrity": "sha512-hxVnwL2Dqs3fM1IWq8Iezh0cX7ZGdVhbTfnOy5uURtao5OIVCEyj9xIzemDi7sRvKsuSdtCAhMKarxqtlyVyfA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/freebsd-arm64": {
+      "version": "0.25.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.25.1.tgz",
+      "integrity": "sha512-1MrCZs0fZa2g8E+FUo2ipw6jw5qqQiH+tERoS5fAfKnRx6NXH31tXBKI3VpmLijLH6yriMZsxJtaXUyFt/8Y4A==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/freebsd-x64": {
+      "version": "0.25.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.25.1.tgz",
+      "integrity": "sha512-0IZWLiTyz7nm0xuIs0q1Y3QWJC52R8aSXxe40VUxm6BB1RNmkODtW6LHvWRrGiICulcX7ZvyH6h5fqdLu4gkww==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-arm": {
+      "version": "0.25.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.25.1.tgz",
+      "integrity": "sha512-NdKOhS4u7JhDKw9G3cY6sWqFcnLITn6SqivVArbzIaf3cemShqfLGHYMx8Xlm/lBit3/5d7kXvriTUGa5YViuQ==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-arm64": {
+      "version": "0.25.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.25.1.tgz",
+      "integrity": "sha512-jaN3dHi0/DDPelk0nLcXRm1q7DNJpjXy7yWaWvbfkPvI+7XNSc/lDOnCLN7gzsyzgu6qSAmgSvP9oXAhP973uQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-ia32": {
+      "version": "0.25.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.25.1.tgz",
+      "integrity": "sha512-OJykPaF4v8JidKNGz8c/q1lBO44sQNUQtq1KktJXdBLn1hPod5rE/Hko5ugKKZd+D2+o1a9MFGUEIUwO2YfgkQ==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-loong64": {
+      "version": "0.25.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.25.1.tgz",
+      "integrity": "sha512-nGfornQj4dzcq5Vp835oM/o21UMlXzn79KobKlcs3Wz9smwiifknLy4xDCLUU0BWp7b/houtdrgUz7nOGnfIYg==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-mips64el": {
+      "version": "0.25.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.25.1.tgz",
+      "integrity": "sha512-1osBbPEFYwIE5IVB/0g2X6i1qInZa1aIoj1TdL4AaAb55xIIgbg8Doq6a5BzYWgr+tEcDzYH67XVnTmUzL+nXg==",
+      "cpu": [
+        "mips64el"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-ppc64": {
+      "version": "0.25.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.25.1.tgz",
+      "integrity": "sha512-/6VBJOwUf3TdTvJZ82qF3tbLuWsscd7/1w+D9LH0W/SqUgM5/JJD0lrJ1fVIfZsqB6RFmLCe0Xz3fmZc3WtyVg==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-riscv64": {
+      "version": "0.25.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.25.1.tgz",
+      "integrity": "sha512-nSut/Mx5gnilhcq2yIMLMe3Wl4FK5wx/o0QuuCLMtmJn+WeWYoEGDN1ipcN72g1WHsnIbxGXd4i/MF0gTcuAjQ==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/linux-s390x": {
+      "version": "0.25.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.25.1.tgz",
+      "integrity": "sha512-cEECeLlJNfT8kZHqLarDBQso9a27o2Zd2AQ8USAEoGtejOrCYHNtKP8XQhMDJMtthdF4GBmjR2au3x1udADQQQ==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
     "node_modules/@esbuild/linux-x64": {
       "version": "0.25.1",
       "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.25.1.tgz",
@@ -424,6 +883,142 @@
         "node": ">=18"
       }
     },
+    "node_modules/@esbuild/netbsd-arm64": {
+      "version": "0.25.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.25.1.tgz",
+      "integrity": "sha512-O96poM2XGhLtpTh+s4+nP7YCCAfb4tJNRVZHfIE7dgmax+yMP2WgMd2OecBuaATHKTHsLWHQeuaxMRnCsH8+5g==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/netbsd-x64": {
+      "version": "0.25.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.25.1.tgz",
+      "integrity": "sha512-X53z6uXip6KFXBQ+Krbx25XHV/NCbzryM6ehOAeAil7X7oa4XIq+394PWGnwaSQ2WRA0KI6PUO6hTO5zeF5ijA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "netbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openbsd-arm64": {
+      "version": "0.25.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.25.1.tgz",
+      "integrity": "sha512-Na9T3szbXezdzM/Kfs3GcRQNjHzM6GzFBeU1/6IV/npKP5ORtp9zbQjvkDJ47s6BCgaAZnnnu/cY1x342+MvZg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/openbsd-x64": {
+      "version": "0.25.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.25.1.tgz",
+      "integrity": "sha512-T3H78X2h1tszfRSf+txbt5aOp/e7TAz3ptVKu9Oyir3IAOFPGV6O9c2naym5TOriy1l0nNf6a4X5UXRZSGX/dw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "openbsd"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/sunos-x64": {
+      "version": "0.25.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.25.1.tgz",
+      "integrity": "sha512-2H3RUvcmULO7dIE5EWJH8eubZAI4xw54H1ilJnRNZdeo8dTADEZ21w6J22XBkXqGJbe0+wnNJtw3UXRoLJnFEg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "sunos"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-arm64": {
+      "version": "0.25.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.25.1.tgz",
+      "integrity": "sha512-GE7XvrdOzrb+yVKB9KsRMq+7a2U/K5Cf/8grVFRAGJmfADr/e/ODQ134RK2/eeHqYV5eQRFxb1hY7Nr15fv1NQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-ia32": {
+      "version": "0.25.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.25.1.tgz",
+      "integrity": "sha512-uOxSJCIcavSiT6UnBhBzE8wy3n0hOkJsBOzy7HDAuTDE++1DJMRRVCPGisULScHL+a/ZwdXPpXD3IyFKjA7K8A==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@esbuild/win32-x64": {
+      "version": "0.25.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.25.1.tgz",
+      "integrity": "sha512-Y1EQdcfwMSeQN/ujR5VayLOJ1BHaK+ssyk0AEzPjC+t1lITgsnccPqFjb6V+LsTp/9Iov4ysfjxLaGJ9RPtkVg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": ">=18"
+      }
+    },
     "node_modules/@eslint-community/eslint-utils": {
       "version": "4.5.0",
       "resolved": "https://registry.npmjs.org/@eslint-community/eslint-utils/-/eslint-utils-4.5.0.tgz",
@@ -576,22 +1171,22 @@
       }
     },
     "node_modules/@floating-ui/core": {
-      "version": "1.6.9",
-      "resolved": "https://registry.npmjs.org/@floating-ui/core/-/core-1.6.9.tgz",
-      "integrity": "sha512-uMXCuQ3BItDUbAMhIXw7UPXRfAlOAvZzdK9BWpE60MCn+Svt3aLn9jsPTi/WNGlRUu2uI0v5S7JiIUsbsvh3fw==",
+      "version": "1.7.3",
+      "resolved": "https://registry.npmjs.org/@floating-ui/core/-/core-1.7.3.tgz",
+      "integrity": "sha512-sGnvb5dmrJaKEZ+LDIpguvdX3bDlEllmv4/ClQ9awcmCZrlx5jQyyMWFM5kBI+EyNOCDDiKk8il0zeuX3Zlg/w==",
       "license": "MIT",
       "dependencies": {
-        "@floating-ui/utils": "^0.2.9"
+        "@floating-ui/utils": "^0.2.10"
       }
     },
     "node_modules/@floating-ui/dom": {
-      "version": "1.6.13",
-      "resolved": "https://registry.npmjs.org/@floating-ui/dom/-/dom-1.6.13.tgz",
-      "integrity": "sha512-umqzocjDgNRGTuO7Q8CU32dkHkECqI8ZdMZ5Swb6QAM0t5rnlrN3lGo1hdpscRd3WS8T6DKYK4ephgIH9iRh3w==",
+      "version": "1.7.4",
+      "resolved": "https://registry.npmjs.org/@floating-ui/dom/-/dom-1.7.4.tgz",
+      "integrity": "sha512-OOchDgh4F2CchOX94cRVqhvy7b3AFb+/rQXyswmzmGakRfkMgoWVjfnLWkRirfLEfuD4ysVW16eXzwt3jHIzKA==",
       "license": "MIT",
       "dependencies": {
-        "@floating-ui/core": "^1.6.0",
-        "@floating-ui/utils": "^0.2.9"
+        "@floating-ui/core": "^1.7.3",
+        "@floating-ui/utils": "^0.2.10"
       }
     },
     "node_modules/@floating-ui/react": {
@@ -610,12 +1205,12 @@
       }
     },
     "node_modules/@floating-ui/react-dom": {
-      "version": "2.1.2",
-      "resolved": "https://registry.npmjs.org/@floating-ui/react-dom/-/react-dom-2.1.2.tgz",
-      "integrity": "sha512-06okr5cgPzMNBy+Ycse2A6udMi4bqwW/zgBF/rwjcNqWkyr82Mcg8b0vjX8OJpZFy/FKjJmw6wV7t44kK6kW7A==",
+      "version": "2.1.6",
+      "resolved": "https://registry.npmjs.org/@floating-ui/react-dom/-/react-dom-2.1.6.tgz",
+      "integrity": "sha512-4JX6rEatQEvlmgU80wZyq9RT96HZJa88q8hp0pBd+LrczeDI4o6uA2M+uvxngVHo4Ihr8uibXxH6+70zhAFrVw==",
       "license": "MIT",
       "dependencies": {
-        "@floating-ui/dom": "^1.0.0"
+        "@floating-ui/dom": "^1.7.4"
       },
       "peerDependencies": {
         "react": ">=16.8.0",
@@ -623,9 +1218,9 @@
       }
     },
     "node_modules/@floating-ui/utils": {
-      "version": "0.2.9",
-      "resolved": "https://registry.npmjs.org/@floating-ui/utils/-/utils-0.2.9.tgz",
-      "integrity": "sha512-MDWhGtE+eHw5JW7lq4qhc5yRLS11ERl1c7Z6Xd0a58DozHES6EnNNwUWbMiG4J9Cgj053Bhk8zvlhFYKVhULwg==",
+      "version": "0.2.10",
+      "resolved": "https://registry.npmjs.org/@floating-ui/utils/-/utils-0.2.10.tgz",
+      "integrity": "sha512-aGTxbpbg8/b5JfU1HXSrbH3wXZuLPJcNEcZQFMxLs3oSzgtVu6nFPkbbGGUvBcUjKV2YyB9Wxxabo+HEH9tcRQ==",
       "license": "MIT"
     },
     "node_modules/@humanfs/core": {
@@ -727,9 +1322,9 @@
       }
     },
     "node_modules/@jridgewell/sourcemap-codec": {
-      "version": "1.5.0",
-      "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.0.tgz",
-      "integrity": "sha512-gv3ZRaISU3fjPAgNsriBRqGWQL6quFx04YMPW/zD8XMLsU32mhCCbfbO6KZFLjvYpCZ8zyDEgqsgf+PwPaM7GQ==",
+      "version": "1.5.5",
+      "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz",
+      "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==",
       "license": "MIT"
     },
     "node_modules/@jridgewell/trace-mapping": {
@@ -868,6 +1463,209 @@
         "url": "https://opencollective.com/popperjs"
       }
     },
+    "node_modules/@rolldown/pluginutils": {
+      "version": "1.0.0-beta.35",
+      "resolved": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.0-beta.35.tgz",
+      "integrity": "sha512-slYrCpoxJUqzFDDNlvrOYRazQUNRvWPjXA17dAOISY3rDMxX6k8K4cj2H+hEYMHF81HO3uNd5rHVigAWRM5dSg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@rollup/rollup-android-arm-eabi": {
+      "version": "4.35.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm-eabi/-/rollup-android-arm-eabi-4.35.0.tgz",
+      "integrity": "sha512-uYQ2WfPaqz5QtVgMxfN6NpLD+no0MYHDBywl7itPYd3K5TjjSghNKmX8ic9S8NU8w81NVhJv/XojcHptRly7qQ==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@rollup/rollup-android-arm64": {
+      "version": "4.35.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-android-arm64/-/rollup-android-arm64-4.35.0.tgz",
+      "integrity": "sha512-FtKddj9XZudurLhdJnBl9fl6BwCJ3ky8riCXjEw3/UIbjmIY58ppWwPEvU3fNu+W7FUsAsB1CdH+7EQE6CXAPA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "android"
+      ]
+    },
+    "node_modules/@rollup/rollup-darwin-arm64": {
+      "version": "4.35.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.35.0.tgz",
+      "integrity": "sha512-Uk+GjOJR6CY844/q6r5DR/6lkPFOw0hjfOIzVx22THJXMxktXG6CbejseJFznU8vHcEBLpiXKY3/6xc+cBm65Q==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-darwin-x64": {
+      "version": "4.35.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-x64/-/rollup-darwin-x64-4.35.0.tgz",
+      "integrity": "sha512-3IrHjfAS6Vkp+5bISNQnPogRAW5GAV1n+bNCrDwXmfMHbPl5EhTmWtfmwlJxFRUCBZ+tZ/OxDyU08aF6NI/N5Q==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rollup/rollup-freebsd-arm64": {
+      "version": "4.35.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-arm64/-/rollup-freebsd-arm64-4.35.0.tgz",
+      "integrity": "sha512-sxjoD/6F9cDLSELuLNnY0fOrM9WA0KrM0vWm57XhrIMf5FGiN8D0l7fn+bpUeBSU7dCgPV2oX4zHAsAXyHFGcQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-freebsd-x64": {
+      "version": "4.35.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-freebsd-x64/-/rollup-freebsd-x64-4.35.0.tgz",
+      "integrity": "sha512-2mpHCeRuD1u/2kruUiHSsnjWtHjqVbzhBkNVQ1aVD63CcexKVcQGwJ2g5VphOd84GvxfSvnnlEyBtQCE5hxVVw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "freebsd"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-gnueabihf": {
+      "version": "4.35.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-gnueabihf/-/rollup-linux-arm-gnueabihf-4.35.0.tgz",
+      "integrity": "sha512-mrA0v3QMy6ZSvEuLs0dMxcO2LnaCONs1Z73GUDBHWbY8tFFocM6yl7YyMu7rz4zS81NDSqhrUuolyZXGi8TEqg==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm-musleabihf": {
+      "version": "4.35.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm-musleabihf/-/rollup-linux-arm-musleabihf-4.35.0.tgz",
+      "integrity": "sha512-DnYhhzcvTAKNexIql8pFajr0PiDGrIsBYPRvCKlA5ixSS3uwo/CWNZxB09jhIapEIg945KOzcYEAGGSmTSpk7A==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-gnu": {
+      "version": "4.35.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-gnu/-/rollup-linux-arm64-gnu-4.35.0.tgz",
+      "integrity": "sha512-uagpnH2M2g2b5iLsCTZ35CL1FgyuzzJQ8L9VtlJ+FckBXroTwNOaD0z0/UF+k5K3aNQjbm8LIVpxykUOQt1m/A==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-arm64-musl": {
+      "version": "4.35.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-arm64-musl/-/rollup-linux-arm64-musl-4.35.0.tgz",
+      "integrity": "sha512-XQxVOCd6VJeHQA/7YcqyV0/88N6ysSVzRjJ9I9UA/xXpEsjvAgDTgH3wQYz5bmr7SPtVK2TsP2fQ2N9L4ukoUg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-loongarch64-gnu": {
+      "version": "4.35.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-loongarch64-gnu/-/rollup-linux-loongarch64-gnu-4.35.0.tgz",
+      "integrity": "sha512-5pMT5PzfgwcXEwOaSrqVsz/LvjDZt+vQ8RT/70yhPU06PTuq8WaHhfT1LW+cdD7mW6i/J5/XIkX/1tCAkh1W6g==",
+      "cpu": [
+        "loong64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-powerpc64le-gnu": {
+      "version": "4.35.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-powerpc64le-gnu/-/rollup-linux-powerpc64le-gnu-4.35.0.tgz",
+      "integrity": "sha512-c+zkcvbhbXF98f4CtEIP1EBA/lCic5xB0lToneZYvMeKu5Kamq3O8gqrxiYYLzlZH6E3Aq+TSW86E4ay8iD8EA==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-riscv64-gnu": {
+      "version": "4.35.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-riscv64-gnu/-/rollup-linux-riscv64-gnu-4.35.0.tgz",
+      "integrity": "sha512-s91fuAHdOwH/Tad2tzTtPX7UZyytHIRR6V4+2IGlV0Cej5rkG0R61SX4l4y9sh0JBibMiploZx3oHKPnQBKe4g==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rollup/rollup-linux-s390x-gnu": {
+      "version": "4.35.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-s390x-gnu/-/rollup-linux-s390x-gnu-4.35.0.tgz",
+      "integrity": "sha512-hQRkPQPLYJZYGP+Hj4fR9dDBMIM7zrzJDWFEMPdTnTy95Ljnv0/4w/ixFw3pTBMEuuEuoqtBINYND4M7ujcuQw==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
     "node_modules/@rollup/rollup-linux-x64-gnu": {
       "version": "4.35.0",
       "resolved": "https://registry.npmjs.org/@rollup/rollup-linux-x64-gnu/-/rollup-linux-x64-gnu-4.35.0.tgz",
@@ -896,95 +1694,62 @@
         "linux"
       ]
     },
+    "node_modules/@rollup/rollup-win32-arm64-msvc": {
+      "version": "4.35.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-arm64-msvc/-/rollup-win32-arm64-msvc-4.35.0.tgz",
+      "integrity": "sha512-OUOlGqPkVJCdJETKOCEf1mw848ZyJ5w50/rZ/3IBQVdLfR5jk/6Sr5m3iO2tdPgwo0x7VcncYuOvMhBWZq8ayg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-ia32-msvc": {
+      "version": "4.35.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-ia32-msvc/-/rollup-win32-ia32-msvc-4.35.0.tgz",
+      "integrity": "sha512-2/lsgejMrtwQe44glq7AFFHLfJBPafpsTa6JvP2NGef/ifOa4KBoglVf7AKN7EV9o32evBPRqfg96fEHzWo5kw==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rollup/rollup-win32-x64-msvc": {
+      "version": "4.35.0",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-win32-x64-msvc/-/rollup-win32-x64-msvc-4.35.0.tgz",
+      "integrity": "sha512-PIQeY5XDkrOysbQblSW7v3l1MDZzkTEzAfTPkj5VAu3FW8fS4ynyLg2sINp0fp3SjZ8xkRYpLqoKcYqAkhU1dw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
     "node_modules/@swc/core": {
-      "version": "1.11.8",
-      "resolved": "https://registry.npmjs.org/@swc/core/-/core-1.11.8.tgz",
-      "integrity": "sha512-UAL+EULxrc0J73flwYHfu29mO8CONpDJiQv1QPDXsyCvDUcEhqAqUROVTgC+wtJCFFqMQdyr4stAA5/s0KSOmA==",
-      "dev": true,
-      "hasInstallScript": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@swc/counter": "^0.1.3",
-        "@swc/types": "^0.1.19"
-      },
-      "engines": {
-        "node": ">=10"
-      },
-      "funding": {
-        "type": "opencollective",
-        "url": "https://opencollective.com/swc"
-      },
-      "optionalDependencies": {
-        "@swc/core-darwin-arm64": "1.11.8",
-        "@swc/core-darwin-x64": "1.11.8",
-        "@swc/core-linux-arm-gnueabihf": "1.11.8",
-        "@swc/core-linux-arm64-gnu": "1.11.8",
-        "@swc/core-linux-arm64-musl": "1.11.8",
-        "@swc/core-linux-x64-gnu": "1.11.8",
-        "@swc/core-linux-x64-musl": "1.11.8",
-        "@swc/core-win32-arm64-msvc": "1.11.8",
-        "@swc/core-win32-ia32-msvc": "1.11.8",
-        "@swc/core-win32-x64-msvc": "1.11.8"
-      },
-      "peerDependencies": {
-        "@swc/helpers": "*"
-      },
-      "peerDependenciesMeta": {
-        "@swc/helpers": {
-          "optional": true
-        }
-      }
-    },
-    "node_modules/@swc/core-linux-x64-gnu": {
-      "version": "1.11.8",
-      "resolved": "https://registry.npmjs.org/@swc/core-linux-x64-gnu/-/core-linux-x64-gnu-1.11.8.tgz",
-      "integrity": "sha512-r72onUEIU1iJi9EUws3R28pztQ/eM3EshNpsPRBfuLwKy+qn3et55vXOyDhIjGCUph5Eg2Yn8H3h6MTxDdLd+w==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "Apache-2.0 AND MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=10"
-      }
-    },
-    "node_modules/@swc/core-linux-x64-musl": {
-      "version": "1.11.8",
-      "resolved": "https://registry.npmjs.org/@swc/core-linux-x64-musl/-/core-linux-x64-musl-1.11.8.tgz",
-      "integrity": "sha512-294k8cLpO103++f4ZUEDr3vnBeUfPitW6G0a3qeVZuoXFhFgaW7ANZIWknUc14WiLOMfMecphJAEiy9C8OeYSw==",
-      "cpu": [
-        "x64"
-      ],
-      "dev": true,
-      "license": "Apache-2.0 AND MIT",
-      "optional": true,
-      "os": [
-        "linux"
-      ],
-      "engines": {
-        "node": ">=10"
-      }
-    },
-    "node_modules/@swc/counter": {
-      "version": "0.1.3",
-      "resolved": "https://registry.npmjs.org/@swc/counter/-/counter-0.1.3.tgz",
-      "integrity": "sha512-e2BR4lsJkkRlKZ/qCHPw9ZaSxc0MVUd7gtbtaB7aMvHeJVYe8sOB8DBZkP2DtISHGSku9sCK6T6cnY0CtXrOCQ==",
+      "name": "@swc/wasm",
+      "version": "1.13.20",
+      "resolved": "https://registry.npmjs.org/@swc/wasm/-/wasm-1.13.20.tgz",
+      "integrity": "sha512-NJzN+QrbdwXeVTfTYiHkqv13zleOCQA52NXBOrwKvjxWJQecRqakjUhUP2z8lqs7eWVthko4Cilqs+VeBrwo3Q==",
       "dev": true,
       "license": "Apache-2.0"
     },
-    "node_modules/@swc/types": {
-      "version": "0.1.19",
-      "resolved": "https://registry.npmjs.org/@swc/types/-/types-0.1.19.tgz",
-      "integrity": "sha512-WkAZaAfj44kh/UFdAQcrMP1I0nwRqpt27u+08LMBYMqmQfwwMofYoMh/48NGkMMRfC4ynpfwRbJuu8ErfNloeA==",
+    "node_modules/@swc/wasm": {
+      "version": "1.13.20",
+      "resolved": "https://registry.npmjs.org/@swc/wasm/-/wasm-1.13.20.tgz",
+      "integrity": "sha512-NJzN+QrbdwXeVTfTYiHkqv13zleOCQA52NXBOrwKvjxWJQecRqakjUhUP2z8lqs7eWVthko4Cilqs+VeBrwo3Q==",
       "dev": true,
-      "license": "Apache-2.0",
-      "dependencies": {
-        "@swc/counter": "^0.1.3"
-      }
+      "license": "Apache-2.0"
     },
     "node_modules/@tanstack/react-table": {
       "version": "8.21.3",
@@ -1019,6 +1784,112 @@
         "url": "https://github.com/sponsors/tannerlinsley"
       }
     },
+    "node_modules/@testing-library/dom": {
+      "version": "10.4.1",
+      "resolved": "https://registry.npmjs.org/@testing-library/dom/-/dom-10.4.1.tgz",
+      "integrity": "sha512-o4PXJQidqJl82ckFaXUeoAW+XysPLauYI43Abki5hABd853iMhitooc6znOnczgbTYmEP6U6/y1ZyKAIsvMKGg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/code-frame": "^7.10.4",
+        "@babel/runtime": "^7.12.5",
+        "@types/aria-query": "^5.0.1",
+        "aria-query": "5.3.0",
+        "dom-accessibility-api": "^0.5.9",
+        "lz-string": "^1.5.0",
+        "picocolors": "1.1.1",
+        "pretty-format": "^27.0.2"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@testing-library/jest-dom": {
+      "version": "6.8.0",
+      "resolved": "https://registry.npmjs.org/@testing-library/jest-dom/-/jest-dom-6.8.0.tgz",
+      "integrity": "sha512-WgXcWzVM6idy5JaftTVC8Vs83NKRmGJz4Hqs4oyOuO2J4r/y79vvKZsb+CaGyCSEbUPI6OsewfPd0G1A0/TUZQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@adobe/css-tools": "^4.4.0",
+        "aria-query": "^5.0.0",
+        "css.escape": "^1.5.1",
+        "dom-accessibility-api": "^0.6.3",
+        "picocolors": "^1.1.1",
+        "redent": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=14",
+        "npm": ">=6",
+        "yarn": ">=1"
+      }
+    },
+    "node_modules/@testing-library/jest-dom/node_modules/dom-accessibility-api": {
+      "version": "0.6.3",
+      "resolved": "https://registry.npmjs.org/dom-accessibility-api/-/dom-accessibility-api-0.6.3.tgz",
+      "integrity": "sha512-7ZgogeTnjuHbo+ct10G9Ffp0mif17idi0IyWNVA/wcwcm7NPOD/WEHVP3n7n3MhXqxoIYm8d6MuZohYWIZ4T3w==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@testing-library/react": {
+      "version": "16.3.0",
+      "resolved": "https://registry.npmjs.org/@testing-library/react/-/react-16.3.0.tgz",
+      "integrity": "sha512-kFSyxiEDwv1WLl2fgsq6pPBbw5aWKrsY2/noi1Id0TK0UParSF62oFQFGHXIyaG4pp2tEub/Zlel+fjjZILDsw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@babel/runtime": "^7.12.5"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@testing-library/dom": "^10.0.0",
+        "@types/react": "^18.0.0 || ^19.0.0",
+        "@types/react-dom": "^18.0.0 || ^19.0.0",
+        "react": "^18.0.0 || ^19.0.0",
+        "react-dom": "^18.0.0 || ^19.0.0"
+      },
+      "peerDependenciesMeta": {
+        "@types/react": {
+          "optional": true
+        },
+        "@types/react-dom": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@testing-library/user-event": {
+      "version": "14.6.1",
+      "resolved": "https://registry.npmjs.org/@testing-library/user-event/-/user-event-14.6.1.tgz",
+      "integrity": "sha512-vq7fv0rnt+QTXgPxr5Hjc210p6YKq2kmdziLgnsZGgLJ9e6VAShx1pACLuRjd/AS/sr7phAR58OIIpf0LlmQNw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12",
+        "npm": ">=6"
+      },
+      "peerDependencies": {
+        "@testing-library/dom": ">=7.21.4"
+      }
+    },
+    "node_modules/@types/aria-query": {
+      "version": "5.0.4",
+      "resolved": "https://registry.npmjs.org/@types/aria-query/-/aria-query-5.0.4.tgz",
+      "integrity": "sha512-rfT93uj5s0PRL7EzccGMs3brplhcrghnDoV26NqKhCAS1hVo+WdNsPvE/yb6ilfr5hi2MEk6d5EWJTKdxg8jVw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@types/chai": {
+      "version": "5.2.2",
+      "resolved": "https://registry.npmjs.org/@types/chai/-/chai-5.2.2.tgz",
+      "integrity": "sha512-8kB30R7Hwqf40JPiKhVzodJs2Qc1ZJ5zuT3uzw5Hq/dhNCl3G3l83jfpdI1e20BP348+fV7VIL/+FxaXkqBmWg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/deep-eql": "*"
+      }
+    },
     "node_modules/@types/d3-array": {
       "version": "3.2.1",
       "resolved": "https://registry.npmjs.org/@types/d3-array/-/d3-array-3.2.1.tgz",
@@ -1082,6 +1953,13 @@
       "integrity": "sha512-Ps3T8E8dZDam6fUyNiMkekK3XUsaUEik+idO9/YjPtfj2qruF8tFBXS7XhtE4iIXBLxhmLjP3SXpLhVf21I9Lw==",
       "license": "MIT"
     },
+    "node_modules/@types/deep-eql": {
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/@types/deep-eql/-/deep-eql-4.0.2.tgz",
+      "integrity": "sha512-c9h9dVVMigMPc4bwTvC5dxqtqJZwQPePsWjPlpSOnojbor6pGqdk541lfA7AqFQr5pB1BRdq0juY9db81BwyFw==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/@types/estree": {
       "version": "1.0.6",
       "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.6.tgz",
@@ -1113,18 +1991,18 @@
       "license": "MIT"
     },
     "node_modules/@types/react": {
-      "version": "19.0.10",
-      "resolved": "https://registry.npmjs.org/@types/react/-/react-19.0.10.tgz",
-      "integrity": "sha512-JuRQ9KXLEjaUNjTWpzuR231Z2WpIwczOkBEIvbHNCzQefFIT0L8IqE6NV6ULLyC1SI/i234JnDoMkfg+RjQj2g==",
+      "version": "19.1.16",
+      "resolved": "https://registry.npmjs.org/@types/react/-/react-19.1.16.tgz",
+      "integrity": "sha512-WBM/nDbEZmDUORKnh5i1bTnAz6vTohUf9b8esSMu+b24+srbaxa04UbJgWx78CVfNXA20sNu0odEIluZDFdCog==",
       "license": "MIT",
       "dependencies": {
         "csstype": "^3.0.2"
       }
     },
     "node_modules/@types/react-dom": {
-      "version": "19.0.4",
-      "resolved": "https://registry.npmjs.org/@types/react-dom/-/react-dom-19.0.4.tgz",
-      "integrity": "sha512-4fSQ8vWFkg+TGhePfUzVmat3eC14TXYSsiiDSLI0dVLsrm9gZFABjPy/Qu6TKgl1tq1Bu1yDsuQgY3A3DOjCcg==",
+      "version": "19.1.9",
+      "resolved": "https://registry.npmjs.org/@types/react-dom/-/react-dom-19.1.9.tgz",
+      "integrity": "sha512-qXRuZaOsAdXKFyOhRBg6Lqqc0yay13vN7KrIg4L7N4aaHN68ma9OK3NE1BoDFgFOTfM7zg+3/8+2n8rLUH3OKQ==",
       "dev": true,
       "license": "MIT",
       "peerDependencies": {
@@ -1180,16 +2058,135 @@
       }
     },
     "node_modules/@vitejs/plugin-react-swc": {
-      "version": "3.8.0",
-      "resolved": "https://registry.npmjs.org/@vitejs/plugin-react-swc/-/plugin-react-swc-3.8.0.tgz",
-      "integrity": "sha512-T4sHPvS+DIqDP51ifPqa9XIRAz/kIvIi8oXcnOZZgHmMotgmmdxe/DD5tMFlt5nuIRzT0/QuiwmKlH0503Aapw==",
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/@vitejs/plugin-react-swc/-/plugin-react-swc-4.1.0.tgz",
+      "integrity": "sha512-Ff690TUck0Anlh7wdIcnsVMhofeEVgm44Y4OYdeeEEPSKyZHzDI9gfVBvySEhDfXtBp8tLCbfsVKPWEMEjq8/g==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "@swc/core": "^1.10.15"
+        "@rolldown/pluginutils": "1.0.0-beta.35",
+        "@swc/core": "^1.13.5"
+      },
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
       },
       "peerDependencies": {
-        "vite": "^4 || ^5 || ^6"
+        "vite": "^4 || ^5 || ^6 || ^7"
+      }
+    },
+    "node_modules/@vitest/expect": {
+      "version": "3.2.4",
+      "resolved": "https://registry.npmjs.org/@vitest/expect/-/expect-3.2.4.tgz",
+      "integrity": "sha512-Io0yyORnB6sikFlt8QW5K7slY4OjqNX9jmJQ02QDda8lyM6B5oNgVWoSoKPac8/kgnCUzuHQKrSLtu/uOqqrig==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/chai": "^5.2.2",
+        "@vitest/spy": "3.2.4",
+        "@vitest/utils": "3.2.4",
+        "chai": "^5.2.0",
+        "tinyrainbow": "^2.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/mocker": {
+      "version": "3.2.4",
+      "resolved": "https://registry.npmjs.org/@vitest/mocker/-/mocker-3.2.4.tgz",
+      "integrity": "sha512-46ryTE9RZO/rfDd7pEqFl7etuyzekzEhUbTW3BvmeO/BcCMEgq59BKhek3dXDWgAj4oMK6OZi+vRr1wPW6qjEQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/spy": "3.2.4",
+        "estree-walker": "^3.0.3",
+        "magic-string": "^0.30.17"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      },
+      "peerDependencies": {
+        "msw": "^2.4.9",
+        "vite": "^5.0.0 || ^6.0.0 || ^7.0.0-0"
+      },
+      "peerDependenciesMeta": {
+        "msw": {
+          "optional": true
+        },
+        "vite": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@vitest/pretty-format": {
+      "version": "3.2.4",
+      "resolved": "https://registry.npmjs.org/@vitest/pretty-format/-/pretty-format-3.2.4.tgz",
+      "integrity": "sha512-IVNZik8IVRJRTr9fxlitMKeJeXFFFN0JaB9PHPGQ8NKQbGpfjlTx9zO4RefN8gp7eqjNy8nyK3NZmBzOPeIxtA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "tinyrainbow": "^2.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/runner": {
+      "version": "3.2.4",
+      "resolved": "https://registry.npmjs.org/@vitest/runner/-/runner-3.2.4.tgz",
+      "integrity": "sha512-oukfKT9Mk41LreEW09vt45f8wx7DordoWUZMYdY/cyAk7w5TWkTRCNZYF7sX7n2wB7jyGAl74OxgwhPgKaqDMQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/utils": "3.2.4",
+        "pathe": "^2.0.3",
+        "strip-literal": "^3.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/snapshot": {
+      "version": "3.2.4",
+      "resolved": "https://registry.npmjs.org/@vitest/snapshot/-/snapshot-3.2.4.tgz",
+      "integrity": "sha512-dEYtS7qQP2CjU27QBC5oUOxLE/v5eLkGqPE0ZKEIDGMs4vKWe7IjgLOeauHsR0D5YuuycGRO5oSRXnwnmA78fQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/pretty-format": "3.2.4",
+        "magic-string": "^0.30.17",
+        "pathe": "^2.0.3"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/spy": {
+      "version": "3.2.4",
+      "resolved": "https://registry.npmjs.org/@vitest/spy/-/spy-3.2.4.tgz",
+      "integrity": "sha512-vAfasCOe6AIK70iP5UD11Ac4siNUNJ9i/9PZ3NKx07sG6sUxeag1LWdNrMWeKKYBLlzuK+Gn65Yd5nyL6ds+nw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "tinyspy": "^4.0.3"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/@vitest/utils": {
+      "version": "3.2.4",
+      "resolved": "https://registry.npmjs.org/@vitest/utils/-/utils-3.2.4.tgz",
+      "integrity": "sha512-fB2V0JFrQSMsCo9HiSq3Ezpdv4iYaXRG1Sx8edX3MwxfyNn83mKiGzOcH+Fkxt4MHxr3y42fQi1oeAInqgX2QA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@vitest/pretty-format": "3.2.4",
+        "loupe": "^3.1.4",
+        "tinyrainbow": "^2.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
       }
     },
     "node_modules/@xmldom/xmldom": {
@@ -1236,6 +2233,16 @@
         "pkcs7": "^1.0.4"
       }
     },
+    "node_modules/agent-base": {
+      "version": "7.1.4",
+      "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-7.1.4.tgz",
+      "integrity": "sha512-MnA+YT8fwfJPgBx3m60MNqakm30XOkyIoH1y6huTQvC0PwZG7ki8NacLBcrPbNoo8vEZy7Jpuk7+jMO+CUovTQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 14"
+      }
+    },
     "node_modules/ajv": {
       "version": "6.12.6",
       "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz",
@@ -1254,9 +2261,9 @@
       }
     },
     "node_modules/allotment": {
-      "version": "1.20.3",
-      "resolved": "https://registry.npmjs.org/allotment/-/allotment-1.20.3.tgz",
-      "integrity": "sha512-JCnklt7j0OsyDjD7A9AdT6wqJ3FSoo1ASV6w02Am02lo6NwO25yhG1DcWW8ueBV38ppXQmvrXBXuzX7iVkq6Tw==",
+      "version": "1.20.4",
+      "resolved": "https://registry.npmjs.org/allotment/-/allotment-1.20.4.tgz",
+      "integrity": "sha512-LMM5Xe5nLePFOLAlW/5k3ARqznYGUyNekV4xJrfDKn1jimW3nlZE6hT/Tu0T8s0VgAkr9s2P7+uM0WvJKn5DAw==",
       "license": "MIT",
       "dependencies": {
         "classnames": "^2.3.0",
@@ -1271,17 +2278,14 @@
         "react-dom": "^17.0.0 || ^18.0.0 || ^19.0.0"
       }
     },
-    "node_modules/allotment/node_modules/use-resize-observer": {
-      "version": "9.1.0",
-      "resolved": "https://registry.npmjs.org/use-resize-observer/-/use-resize-observer-9.1.0.tgz",
-      "integrity": "sha512-R25VqO9Wb3asSD4eqtcxk8sJalvIOYBqS8MNZlpDSQ4l4xMQxC/J7Id9HoTqPq8FwULIn0PVW+OAqF2dyYbjow==",
+    "node_modules/ansi-regex": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-5.0.1.tgz",
+      "integrity": "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==",
+      "dev": true,
       "license": "MIT",
-      "dependencies": {
-        "@juggle/resize-observer": "^3.3.1"
-      },
-      "peerDependencies": {
-        "react": "16.8.0 - 18",
-        "react-dom": "16.8.0 - 18"
+      "engines": {
+        "node": ">=8"
       }
     },
     "node_modules/ansi-styles": {
@@ -1307,6 +2311,26 @@
       "dev": true,
       "license": "Python-2.0"
     },
+    "node_modules/aria-query": {
+      "version": "5.3.0",
+      "resolved": "https://registry.npmjs.org/aria-query/-/aria-query-5.3.0.tgz",
+      "integrity": "sha512-b0P0sZPKtyu8HkeRAfCq0IfURZK+SuwMjY1UXGBU27wpAiTwQAIlq56IbIO+ytk/JjS1fMR14ee5WBBfKi5J6A==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "dequal": "^2.0.3"
+      }
+    },
+    "node_modules/assertion-error": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/assertion-error/-/assertion-error-2.0.1.tgz",
+      "integrity": "sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      }
+    },
     "node_modules/attr-accept": {
       "version": "2.2.5",
       "resolved": "https://registry.npmjs.org/attr-accept/-/attr-accept-2.2.5.tgz",
@@ -1338,6 +2362,16 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/bidi-js": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/bidi-js/-/bidi-js-1.0.3.tgz",
+      "integrity": "sha512-RKshQI1R3YQ+n9YJz2QQ147P66ELpa1FQEg20Dk8oW9t2KgLbpDLLp9aGZ7y8WHSshDknG0bknqGw5/tyCs5tw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "require-from-string": "^2.0.2"
+      }
+    },
     "node_modules/brace-expansion": {
       "version": "1.1.11",
       "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz",
@@ -1349,6 +2383,16 @@
         "concat-map": "0.0.1"
       }
     },
+    "node_modules/cac": {
+      "version": "6.7.14",
+      "resolved": "https://registry.npmjs.org/cac/-/cac-6.7.14.tgz",
+      "integrity": "sha512-b6Ilus+c3RrdDk+JhLKUAQfzzgLEPy6wcXqS7f/xe1EETvsDP6GORG7SFuOs6cID5YkqchW/LXZbX5bc8j7ZcQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/callsites": {
       "version": "3.1.0",
       "resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz",
@@ -1358,6 +2402,23 @@
         "node": ">=6"
       }
     },
+    "node_modules/chai": {
+      "version": "5.3.3",
+      "resolved": "https://registry.npmjs.org/chai/-/chai-5.3.3.tgz",
+      "integrity": "sha512-4zNhdJD/iOjSH0A05ea+Ke6MU5mmpQcbQsSOkgdaUMJ9zTlDTD/GYlwohmIE2u0gaxHYiVHEn1Fw9mZ/ktJWgw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "assertion-error": "^2.0.1",
+        "check-error": "^2.1.1",
+        "deep-eql": "^5.0.1",
+        "loupe": "^3.1.0",
+        "pathval": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
     "node_modules/chalk": {
       "version": "4.1.2",
       "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz",
@@ -1375,6 +2436,16 @@
         "url": "https://github.com/chalk/chalk?sponsor=1"
       }
     },
+    "node_modules/check-error": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/check-error/-/check-error-2.1.1.tgz",
+      "integrity": "sha512-OAlb+T7V4Op9OwdkjmguYRqncdlx5JiofwOAUkmTF+jNdHwzTaTs4sRAGpzLF3oOz5xAyDGrPgeIDFQmDOTiJw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 16"
+      }
+    },
     "node_modules/classnames": {
       "version": "2.5.1",
       "resolved": "https://registry.npmjs.org/classnames/-/classnames-2.5.1.tgz",
@@ -1472,6 +2543,42 @@
         "node": ">= 8"
       }
     },
+    "node_modules/css-tree": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/css-tree/-/css-tree-3.1.0.tgz",
+      "integrity": "sha512-0eW44TGN5SQXU1mWSkKwFstI/22X2bG1nYzZTYMAWjylYURhse752YgbE4Cx46AC+bAvI+/dYTPRk1LqSUnu6w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "mdn-data": "2.12.2",
+        "source-map-js": "^1.0.1"
+      },
+      "engines": {
+        "node": "^10 || ^12.20.0 || ^14.13.0 || >=15.0.0"
+      }
+    },
+    "node_modules/css.escape": {
+      "version": "1.5.1",
+      "resolved": "https://registry.npmjs.org/css.escape/-/css.escape-1.5.1.tgz",
+      "integrity": "sha512-YUifsXXuknHlUsmlgyY0PKzgPOr7/FjCePfHNt0jxm83wHZi44VDMQ7/fGNkjY3/jV1MC+1CmZbaHzugyeRtpg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/cssstyle": {
+      "version": "5.3.1",
+      "resolved": "https://registry.npmjs.org/cssstyle/-/cssstyle-5.3.1.tgz",
+      "integrity": "sha512-g5PC9Aiph9eiczFpcgUhd9S4UUO3F+LHGRIi5NUMZ+4xtoIYbHNZwZnWA2JsFGe8OU8nl4WyaEFiZuGuxlutJQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@asamuzakjp/css-color": "^4.0.3",
+        "@csstools/css-syntax-patches-for-csstree": "^1.0.14",
+        "css-tree": "^3.1.0"
+      },
+      "engines": {
+        "node": ">=20"
+      }
+    },
     "node_modules/csstype": {
       "version": "3.1.3",
       "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.1.3.tgz",
@@ -1599,6 +2706,20 @@
         "node": ">=12"
       }
     },
+    "node_modules/data-urls": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/data-urls/-/data-urls-6.0.0.tgz",
+      "integrity": "sha512-BnBS08aLUM+DKamupXs3w2tJJoqU+AkaE/+6vQxi/G/DPmIZFJJp9Dkb1kM03AZx8ADehDUZgsNxju3mPXZYIA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "whatwg-mimetype": "^4.0.0",
+        "whatwg-url": "^15.0.0"
+      },
+      "engines": {
+        "node": ">=20"
+      }
+    },
     "node_modules/dayjs": {
       "version": "1.11.13",
       "resolved": "https://registry.npmjs.org/dayjs/-/dayjs-1.11.13.tgz",
@@ -1606,9 +2727,9 @@
       "license": "MIT"
     },
     "node_modules/debug": {
-      "version": "4.4.0",
-      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.0.tgz",
-      "integrity": "sha512-6WTZ/IxCY/T6BALoZHaE4ctp9xm+Z5kY/pzYaCHRFeyVhojxlrm+46y68HA6hr0TcwEssoxNiDEUJQjfPZ/RYA==",
+      "version": "4.4.3",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
+      "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==",
       "license": "MIT",
       "dependencies": {
         "ms": "^2.1.3"
@@ -1622,12 +2743,29 @@
         }
       }
     },
+    "node_modules/decimal.js": {
+      "version": "10.6.0",
+      "resolved": "https://registry.npmjs.org/decimal.js/-/decimal.js-10.6.0.tgz",
+      "integrity": "sha512-YpgQiITW3JXGntzdUmyUR1V812Hn8T1YVXhCu+wO3OpS4eU9l4YdD3qjyiKdV6mvV29zapkMeD390UVEf2lkUg==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/decimal.js-light": {
       "version": "2.5.1",
       "resolved": "https://registry.npmjs.org/decimal.js-light/-/decimal.js-light-2.5.1.tgz",
       "integrity": "sha512-qIMFpTMZmny+MMIitAB6D7iVPEorVw6YQRWkvarTkT4tBeSLLiHzcwj6q0MmYSFCiVpiqPJTJEYIrpcPzVEIvg==",
       "license": "MIT"
     },
+    "node_modules/deep-eql": {
+      "version": "5.0.2",
+      "resolved": "https://registry.npmjs.org/deep-eql/-/deep-eql-5.0.2.tgz",
+      "integrity": "sha512-h5k/5U50IJJFpzfL6nO9jaaumfjO/f2NjK/oYB2Djzm4p9L+3T9qWpZqZ2hAbLPuuYq9wrU08WQyBTL5GbPk5Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
     "node_modules/deep-is": {
       "version": "0.1.4",
       "resolved": "https://registry.npmjs.org/deep-is/-/deep-is-0.1.4.tgz",
@@ -1644,12 +2782,29 @@
         "node": ">=0.10.0"
       }
     },
+    "node_modules/dequal": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/dequal/-/dequal-2.0.3.tgz",
+      "integrity": "sha512-0je+qPKHEMohvfRTCEo3CrPG6cAzAYgmzKyxRiYSSDkS6eGJdyVJm7WaYA5ECaAD9wLB2T4EEeymA5aFVcYXCA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
     "node_modules/detect-node-es": {
       "version": "1.1.0",
       "resolved": "https://registry.npmjs.org/detect-node-es/-/detect-node-es-1.1.0.tgz",
       "integrity": "sha512-ypdmJU/TbBby2Dxibuv7ZLW3Bs1QEmM7nHjEANfohJLvE0XVujisn1qPJcZxg+qDucsr+bP6fLD1rPS3AhJ7EQ==",
       "license": "MIT"
     },
+    "node_modules/dom-accessibility-api": {
+      "version": "0.5.16",
+      "resolved": "https://registry.npmjs.org/dom-accessibility-api/-/dom-accessibility-api-0.5.16.tgz",
+      "integrity": "sha512-X7BJ2yElsnOJ30pZF4uIIDfBEVgF4XEBxL9Bxhy6dnrm5hkzqmsWHGTiHqRiITNhMyFLyAiWndIJP7Z1NTteDg==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/dom-helpers": {
       "version": "5.2.1",
       "resolved": "https://registry.npmjs.org/dom-helpers/-/dom-helpers-5.2.1.tgz",
@@ -1665,6 +2820,19 @@
       "resolved": "https://registry.npmjs.org/dom-walk/-/dom-walk-0.1.2.tgz",
       "integrity": "sha512-6QvTW9mrGeIegrFXdtQi9pk7O/nSK6lSdXW2eqUspN5LWD7UTji2Fqw5V2YLjBpHEoU9Xl/eUWNpDeZvoyOv2w=="
     },
+    "node_modules/entities": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/entities/-/entities-6.0.1.tgz",
+      "integrity": "sha512-aN97NXWF6AWBTahfVOIrB/NShkzi5H7F9r1s9mD3cDj4Ko5f2qhhVoYMibXF7GlLveb/D2ioWay8lxI97Ven3g==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=0.12"
+      },
+      "funding": {
+        "url": "https://github.com/fb55/entities?sponsor=1"
+      }
+    },
     "node_modules/error-ex": {
       "version": "1.3.2",
       "resolved": "https://registry.npmjs.org/error-ex/-/error-ex-1.3.2.tgz",
@@ -1674,6 +2842,13 @@
         "is-arrayish": "^0.2.1"
       }
     },
+    "node_modules/es-module-lexer": {
+      "version": "1.7.0",
+      "resolved": "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-1.7.0.tgz",
+      "integrity": "sha512-jEQoCwk8hyb2AZziIOLhDqpm5+2ww5uIE6lkO/6jcOCusfk6LhMHpXXfBLXTZ7Ydyt0j4VoUQv6uGNYbdW+kBA==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/es6-promise": {
       "version": "4.2.8",
       "resolved": "https://registry.npmjs.org/es6-promise/-/es6-promise-4.2.8.tgz",
@@ -1901,6 +3076,16 @@
         "node": ">=4.0"
       }
     },
+    "node_modules/estree-walker": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/estree-walker/-/estree-walker-3.0.3.tgz",
+      "integrity": "sha512-7RUKfXgSMMkzt6ZuXmqapOurLGPPfgj6l9uRZ7lRGolvk0y2yocc35LdcxKC5PQZdn2DMqioAQ2NoWcrTKmm6g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree": "^1.0.0"
+      }
+    },
     "node_modules/esutils": {
       "version": "2.0.3",
       "resolved": "https://registry.npmjs.org/esutils/-/esutils-2.0.3.tgz",
@@ -1917,6 +3102,16 @@
       "integrity": "sha512-GWkBvjiSZK87ELrYOSESUYeVIc9mvLLf/nXalMOS5dYrgZq9o5OVkbZAVM06CVxYsCwH9BDZFPlQTlPA1j4ahA==",
       "license": "MIT"
     },
+    "node_modules/expect-type": {
+      "version": "1.2.2",
+      "resolved": "https://registry.npmjs.org/expect-type/-/expect-type-1.2.2.tgz",
+      "integrity": "sha512-JhFGDVJ7tmDJItKhYgJCGLOWjuK9vPxiXoUFLwLDc99NlmklilbiQJwoctZtt13+xMw91MCk/REan6MWHqDjyA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=12.0.0"
+      }
+    },
     "node_modules/fast-deep-equal": {
       "version": "3.1.3",
       "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz",
@@ -1924,9 +3119,9 @@
       "license": "MIT"
     },
     "node_modules/fast-equals": {
-      "version": "5.2.2",
-      "resolved": "https://registry.npmjs.org/fast-equals/-/fast-equals-5.2.2.tgz",
-      "integrity": "sha512-V7/RktU11J3I36Nwq2JnZEM7tNm17eBJz+u25qdxBZeCKiX6BkVSZQjwWIr+IobgnZy+ag73tTZgZi7tr0LrBw==",
+      "version": "5.3.2",
+      "resolved": "https://registry.npmjs.org/fast-equals/-/fast-equals-5.3.2.tgz",
+      "integrity": "sha512-6rxyATwPCkaFIL3JLqw8qXqMpIZ942pTX/tbQFkRsDGblS8tNGtlUauA/+mt6RUfqn/4MoEr+WDkYoIQbibWuQ==",
       "license": "MIT",
       "engines": {
         "node": ">=6.0.0"
@@ -1947,11 +3142,14 @@
       "license": "MIT"
     },
     "node_modules/fdir": {
-      "version": "6.4.4",
-      "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.4.4.tgz",
-      "integrity": "sha512-1NZP+GK4GfuAv3PqKvxQRDMjdSRZjnkq7KfhlNrCNNlZ0ygQFpebfrnfnq/W7fpUnAv9aGWmY1zKx7FYL3gwhg==",
+      "version": "6.5.0",
+      "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz",
+      "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==",
       "dev": true,
       "license": "MIT",
+      "engines": {
+        "node": ">=12.0.0"
+      },
       "peerDependencies": {
         "picomatch": "^3 || ^4"
       },
@@ -2161,11 +3359,59 @@
         "react-is": "^16.7.0"
       }
     },
-    "node_modules/hoist-non-react-statics/node_modules/react-is": {
-      "version": "16.13.1",
-      "resolved": "https://registry.npmjs.org/react-is/-/react-is-16.13.1.tgz",
-      "integrity": "sha512-24e6ynE2H+OKt4kqsOvNd8kBpV65zoxbA4BVsEOB3ARVWQki/DHzaUoC5KuON/BiccDaCCTZBuOcfZs70kR8bQ==",
-      "license": "MIT"
+    "node_modules/html-encoding-sniffer": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/html-encoding-sniffer/-/html-encoding-sniffer-4.0.0.tgz",
+      "integrity": "sha512-Y22oTqIU4uuPgEemfz7NDJz6OeKf12Lsu+QC+s3BVpda64lTiMYCyGwg5ki4vFxkMwQdeZDl2adZoqUgdFuTgQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "whatwg-encoding": "^3.1.1"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/http-proxy-agent": {
+      "version": "7.0.2",
+      "resolved": "https://registry.npmjs.org/http-proxy-agent/-/http-proxy-agent-7.0.2.tgz",
+      "integrity": "sha512-T1gkAiYYDWYx3V5Bmyu7HcfcvL7mUrTWiM6yOfa3PIphViJ/gFPbvidQ+veqSOHci/PxBcDabeUNCzpOODJZig==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "agent-base": "^7.1.0",
+        "debug": "^4.3.4"
+      },
+      "engines": {
+        "node": ">= 14"
+      }
+    },
+    "node_modules/https-proxy-agent": {
+      "version": "7.0.6",
+      "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-7.0.6.tgz",
+      "integrity": "sha512-vK9P5/iUfdl95AI+JVyUuIcVtd4ofvtrOr3HNtM2yxC9bnMbEdp3x01OhQNnjb8IJYi38VlTE3mBXwcfvywuSw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "agent-base": "^7.1.2",
+        "debug": "4"
+      },
+      "engines": {
+        "node": ">= 14"
+      }
+    },
+    "node_modules/iconv-lite": {
+      "version": "0.6.3",
+      "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.6.3.tgz",
+      "integrity": "sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "safer-buffer": ">= 2.1.2 < 3.0.0"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
     },
     "node_modules/ignore": {
       "version": "5.3.2",
@@ -2203,6 +3449,16 @@
         "node": ">=0.8.19"
       }
     },
+    "node_modules/indent-string": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/indent-string/-/indent-string-4.0.0.tgz",
+      "integrity": "sha512-EdDDZu4A2OyIK7Lr/2zG+w5jmbuk1DVBnEwREQvBzspBJkCEbRa8GxU1lghYcaGJCnRWibjDXlq779X1/y5xwg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/internmap": {
       "version": "2.0.3",
       "resolved": "https://registry.npmjs.org/internmap/-/internmap-2.0.3.tgz",
@@ -2262,6 +3518,13 @@
         "node": ">=0.10.0"
       }
     },
+    "node_modules/is-potential-custom-element-name": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/is-potential-custom-element-name/-/is-potential-custom-element-name-1.0.1.tgz",
+      "integrity": "sha512-bCYeRA2rVibKZd+s2625gGnGF/t7DSqDs4dP7CrLA1m7jKWz6pps0LpYLJN8Q64HtmPKJ1hrN3nzPNKFEKOUiQ==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/isexe": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
@@ -2288,6 +3551,46 @@
         "js-yaml": "bin/js-yaml.js"
       }
     },
+    "node_modules/jsdom": {
+      "version": "27.0.0",
+      "resolved": "https://registry.npmjs.org/jsdom/-/jsdom-27.0.0.tgz",
+      "integrity": "sha512-lIHeR1qlIRrIN5VMccd8tI2Sgw6ieYXSVktcSHaNe3Z5nE/tcPQYQWOq00wxMvYOsz+73eAkNenVvmPC6bba9A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@asamuzakjp/dom-selector": "^6.5.4",
+        "cssstyle": "^5.3.0",
+        "data-urls": "^6.0.0",
+        "decimal.js": "^10.5.0",
+        "html-encoding-sniffer": "^4.0.0",
+        "http-proxy-agent": "^7.0.2",
+        "https-proxy-agent": "^7.0.6",
+        "is-potential-custom-element-name": "^1.0.1",
+        "parse5": "^7.3.0",
+        "rrweb-cssom": "^0.8.0",
+        "saxes": "^6.0.0",
+        "symbol-tree": "^3.2.4",
+        "tough-cookie": "^6.0.0",
+        "w3c-xmlserializer": "^5.0.0",
+        "webidl-conversions": "^8.0.0",
+        "whatwg-encoding": "^3.1.1",
+        "whatwg-mimetype": "^4.0.0",
+        "whatwg-url": "^15.0.0",
+        "ws": "^8.18.2",
+        "xml-name-validator": "^5.0.0"
+      },
+      "engines": {
+        "node": ">=20"
+      },
+      "peerDependencies": {
+        "canvas": "^3.0.0"
+      },
+      "peerDependenciesMeta": {
+        "canvas": {
+          "optional": true
+        }
+      }
+    },
     "node_modules/jsesc": {
       "version": "3.1.0",
       "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-3.1.0.tgz",
@@ -2432,6 +3735,23 @@
         "loose-envify": "cli.js"
       }
     },
+    "node_modules/loupe": {
+      "version": "3.2.1",
+      "resolved": "https://registry.npmjs.org/loupe/-/loupe-3.2.1.tgz",
+      "integrity": "sha512-CdzqowRJCeLU72bHvWqwRBBlLcMEtIvGrlvef74kMnV2AolS9Y8xUv1I0U/MNAWMhBlKIoyuEgoJ0t/bbwHbLQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/lru-cache": {
+      "version": "11.2.1",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.2.1.tgz",
+      "integrity": "sha512-r8LA6i4LP4EeWOhqBaZZjDWwehd1xUJPCJd9Sv300H0ZmcUER4+JPh7bqqZeqs1o5pgtgvXm+d9UGrB5zZGDiQ==",
+      "dev": true,
+      "license": "ISC",
+      "engines": {
+        "node": "20 || >=22"
+      }
+    },
     "node_modules/lucide-react": {
       "version": "0.511.0",
       "resolved": "https://registry.npmjs.org/lucide-react/-/lucide-react-0.511.0.tgz",
@@ -2441,6 +3761,16 @@
         "react": "^16.5.1 || ^17.0.0 || ^18.0.0 || ^19.0.0"
       }
     },
+    "node_modules/lz-string": {
+      "version": "1.5.0",
+      "resolved": "https://registry.npmjs.org/lz-string/-/lz-string-1.5.0.tgz",
+      "integrity": "sha512-h5bgJWpxJNswbU7qCrV0tIKQCaS3blPDrqKWx+QxzuzL1zGUzij9XCWLrSLsJPu5t+eWA/ycetzYAO5IOMcWAQ==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "lz-string": "bin/bin.js"
+      }
+    },
     "node_modules/m3u8-parser": {
       "version": "7.2.0",
       "resolved": "https://registry.npmjs.org/m3u8-parser/-/m3u8-parser-7.2.0.tgz",
@@ -2452,6 +3782,23 @@
         "global": "^4.4.0"
       }
     },
+    "node_modules/magic-string": {
+      "version": "0.30.19",
+      "resolved": "https://registry.npmjs.org/magic-string/-/magic-string-0.30.19.tgz",
+      "integrity": "sha512-2N21sPY9Ws53PZvsEpVtNuSW+ScYbQdp4b9qUaL+9QkHUrGFKo56Lg9Emg5s9V/qrtNBmiR01sYhUOwu3H+VOw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@jridgewell/sourcemap-codec": "^1.5.5"
+      }
+    },
+    "node_modules/mdn-data": {
+      "version": "2.12.2",
+      "resolved": "https://registry.npmjs.org/mdn-data/-/mdn-data-2.12.2.tgz",
+      "integrity": "sha512-IEn+pegP1aManZuckezWCO+XZQDplx1366JoVhTpMpBB1sPey/SbveZQUosKiKiGYjg1wH4pMlNgXbCiYgihQA==",
+      "dev": true,
+      "license": "CC0-1.0"
+    },
     "node_modules/memoize-one": {
       "version": "5.2.1",
       "resolved": "https://registry.npmjs.org/memoize-one/-/memoize-one-5.2.1.tgz",
@@ -2466,6 +3813,16 @@
         "dom-walk": "^0.1.0"
       }
     },
+    "node_modules/min-indent": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/min-indent/-/min-indent-1.0.1.tgz",
+      "integrity": "sha512-I9jwMn07Sy/IwOj3zVkVik2JTvgpaykDZEigL6Rx6N9LbMywwUSMtxET+7lVoDLLd3O3IXwJwvuuns8UB/HeAg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=4"
+      }
+    },
     "node_modules/minimatch": {
       "version": "3.1.2",
       "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
@@ -2642,6 +3999,19 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/parse5": {
+      "version": "7.3.0",
+      "resolved": "https://registry.npmjs.org/parse5/-/parse5-7.3.0.tgz",
+      "integrity": "sha512-IInvU7fabl34qmi9gY8XOVxhYyMyuH2xUNpb2q8/Y+7552KlejkRvqvD19nMoUW/uQGGbqNpA6Tufu5FL5BZgw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "entities": "^6.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/inikulin/parse5?sponsor=1"
+      }
+    },
     "node_modules/path-exists": {
       "version": "4.0.0",
       "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz",
@@ -2677,6 +4047,23 @@
         "node": ">=8"
       }
     },
+    "node_modules/pathe": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/pathe/-/pathe-2.0.3.tgz",
+      "integrity": "sha512-WUjGcAqP1gQacoQe+OBJsFA7Ld4DyXuUIjZ5cc75cLHvJ7dtNsTugphxIADwspS+AraAUePCKrSVtPLFj/F88w==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/pathval": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/pathval/-/pathval-2.0.1.tgz",
+      "integrity": "sha512-//nshmD55c46FuFw26xV/xFAaB5HF9Xdap7HJBBnrKdAd6/GxDBaNA1870O79+9ueg61cZLSVc+OaFlfmObYVQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 14.16"
+      }
+    },
     "node_modules/picocolors": {
       "version": "1.1.1",
       "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
@@ -2684,9 +4071,9 @@
       "license": "ISC"
     },
     "node_modules/picomatch": {
-      "version": "4.0.2",
-      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.2.tgz",
-      "integrity": "sha512-M7BAV6Rlcy5u+m6oPhAPFgJTzAioX/6B0DxyvDlo9l8+T3nLKbrczg2WLUyzd45L8RqfUMyGPzekbMvX2Ldkwg==",
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.3.tgz",
+      "integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==",
       "dev": true,
       "license": "MIT",
       "engines": {
@@ -2763,6 +4150,41 @@
         "url": "https://github.com/prettier/prettier?sponsor=1"
       }
     },
+    "node_modules/pretty-format": {
+      "version": "27.5.1",
+      "resolved": "https://registry.npmjs.org/pretty-format/-/pretty-format-27.5.1.tgz",
+      "integrity": "sha512-Qb1gy5OrP5+zDf2Bvnzdl3jsTf1qXVMazbvCoKhtKqVs4/YK4ozX4gKQJJVyNe+cajNPn0KoC0MC3FUmaHWEmQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ansi-regex": "^5.0.1",
+        "ansi-styles": "^5.0.0",
+        "react-is": "^17.0.1"
+      },
+      "engines": {
+        "node": "^10.13.0 || ^12.13.0 || ^14.15.0 || >=15.0.0"
+      }
+    },
+    "node_modules/pretty-format/node_modules/ansi-styles": {
+      "version": "5.2.0",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-5.2.0.tgz",
+      "integrity": "sha512-Cxwpt2SfTzTtXcfOlzGEee8O+c+MmUgGrNiBcXnuWxuFJHe6a5Hz7qwhwe5OgaSYI0IJvkLqWX1ASG+cJOkEiA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+      }
+    },
+    "node_modules/pretty-format/node_modules/react-is": {
+      "version": "17.0.2",
+      "resolved": "https://registry.npmjs.org/react-is/-/react-is-17.0.2.tgz",
+      "integrity": "sha512-w2GsyukL62IJnlaff/nRegPQR94C/XXamvMWmSHRJ4y7Ts/4ocGRmTHvOs8PSE6pB3dWOrD/nueuU5sduBsQ4w==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/process": {
       "version": "0.11.10",
       "resolved": "https://registry.npmjs.org/process/-/process-0.11.10.tgz",
@@ -2783,12 +4205,6 @@
         "react-is": "^16.13.1"
       }
     },
-    "node_modules/prop-types/node_modules/react-is": {
-      "version": "16.13.1",
-      "resolved": "https://registry.npmjs.org/react-is/-/react-is-16.13.1.tgz",
-      "integrity": "sha512-24e6ynE2H+OKt4kqsOvNd8kBpV65zoxbA4BVsEOB3ARVWQki/DHzaUoC5KuON/BiccDaCCTZBuOcfZs70kR8bQ==",
-      "license": "MIT"
-    },
     "node_modules/property-expr": {
       "version": "2.0.6",
       "resolved": "https://registry.npmjs.org/property-expr/-/property-expr-2.0.6.tgz",
@@ -2806,24 +4222,24 @@
       }
     },
     "node_modules/react": {
-      "version": "19.0.0",
-      "resolved": "https://registry.npmjs.org/react/-/react-19.0.0.tgz",
-      "integrity": "sha512-V8AVnmPIICiWpGfm6GLzCR/W5FXLchHop40W4nXBmdlEceh16rCN8O8LNWm5bh5XUX91fh7KpA+W0TgMKmgTpQ==",
+      "version": "19.1.1",
+      "resolved": "https://registry.npmjs.org/react/-/react-19.1.1.tgz",
+      "integrity": "sha512-w8nqGImo45dmMIfljjMwOGtbmC/mk4CMYhWIicdSflH91J9TyCyczcPFXJzrZ/ZXcgGRFeP6BU0BEJTw6tZdfQ==",
       "license": "MIT",
       "engines": {
         "node": ">=0.10.0"
       }
     },
     "node_modules/react-dom": {
-      "version": "19.0.0",
-      "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-19.0.0.tgz",
-      "integrity": "sha512-4GV5sHFG0e/0AD4X+ySy6UJd3jVl1iNsNHdpad0qhABJ11twS3TTBnseqsKurKcsNqCEFeGL3uLpVChpIO3QfQ==",
+      "version": "19.1.1",
+      "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-19.1.1.tgz",
+      "integrity": "sha512-Dlq/5LAZgF0Gaz6yiqZCf6VCcZs1ghAJyrsu84Q/GT0gV+mCxbfmKNoGRKBYMJ8IEdGPqu49YWXD02GCknEDkw==",
       "license": "MIT",
       "dependencies": {
-        "scheduler": "^0.25.0"
+        "scheduler": "^0.26.0"
       },
       "peerDependencies": {
-        "react": "^19.0.0"
+        "react": "^19.1.1"
       }
     },
     "node_modules/react-draggable": {
@@ -2873,9 +4289,9 @@
       "license": "MIT"
     },
     "node_modules/react-is": {
-      "version": "18.3.1",
-      "resolved": "https://registry.npmjs.org/react-is/-/react-is-18.3.1.tgz",
-      "integrity": "sha512-/LLMVyas0ljjAtoYiPqYiL8VWXzUUdThrmU5+n20DZv+a+ClRoevUzw5JxU+Ieh5/c87ytoTBV9G1FiKfNJdmg==",
+      "version": "16.13.1",
+      "resolved": "https://registry.npmjs.org/react-is/-/react-is-16.13.1.tgz",
+      "integrity": "sha512-24e6ynE2H+OKt4kqsOvNd8kBpV65zoxbA4BVsEOB3ARVWQki/DHzaUoC5KuON/BiccDaCCTZBuOcfZs70kR8bQ==",
       "license": "MIT"
     },
     "node_modules/react-lifecycles-compat": {
@@ -2885,9 +4301,9 @@
       "license": "MIT"
     },
     "node_modules/react-number-format": {
-      "version": "5.4.3",
-      "resolved": "https://registry.npmjs.org/react-number-format/-/react-number-format-5.4.3.tgz",
-      "integrity": "sha512-VCY5hFg/soBighAoGcdE+GagkJq0230qN6jcS5sp8wQX1qy1fYN/RX7/BXkrs0oyzzwqR8/+eSUrqXbGeywdUQ==",
+      "version": "5.4.4",
+      "resolved": "https://registry.npmjs.org/react-number-format/-/react-number-format-5.4.4.tgz",
+      "integrity": "sha512-wOmoNZoOpvMminhifQYiYSTCLUDOiUbBunrMrMjA+dV52sY+vck1S4UhR6PkgnoCquvvMSeJjErXZ4qSaWCliA==",
       "license": "MIT",
       "peerDependencies": {
         "react": "^0.14 || ^15.0.0 || ^16.0.0 || ^17.0.0 || ^18.0.0 || ^19.0.0",
@@ -3157,12 +4573,42 @@
       "integrity": "sha512-8guHBZCwKnFhYdHr2ysuRWErTwhoN2X8XELRlrRwpmfeY2jjuUN4taQMsULKUVo1K4DvZl+0pgfyoysHxvmvEw==",
       "license": "MIT"
     },
+    "node_modules/recharts/node_modules/react-is": {
+      "version": "18.3.1",
+      "resolved": "https://registry.npmjs.org/react-is/-/react-is-18.3.1.tgz",
+      "integrity": "sha512-/LLMVyas0ljjAtoYiPqYiL8VWXzUUdThrmU5+n20DZv+a+ClRoevUzw5JxU+Ieh5/c87ytoTBV9G1FiKfNJdmg==",
+      "license": "MIT"
+    },
+    "node_modules/redent": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/redent/-/redent-3.0.0.tgz",
+      "integrity": "sha512-6tDA8g98We0zd0GvVeMT9arEOnTw9qM03L9cJXaCjrip1OO764RDBLBfrB4cwzNGDj5OA5ioymC9GkizgWJDUg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "indent-string": "^4.0.0",
+        "strip-indent": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/regenerator-runtime": {
       "version": "0.14.1",
       "resolved": "https://registry.npmjs.org/regenerator-runtime/-/regenerator-runtime-0.14.1.tgz",
       "integrity": "sha512-dYnhHh0nJoMfnkZs6GmmhFknAGRrLznOu5nc9ML+EJxGvrx6H7teuevqVqCuPcPK//3eDrrjQhehXVx9cnkGdw==",
       "license": "MIT"
     },
+    "node_modules/require-from-string": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/require-from-string/-/require-from-string-2.0.2.tgz",
+      "integrity": "sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
     "node_modules/resolve": {
       "version": "1.22.10",
       "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.10.tgz",
@@ -3231,10 +4677,37 @@
         "fsevents": "~2.3.2"
       }
     },
+    "node_modules/rrweb-cssom": {
+      "version": "0.8.0",
+      "resolved": "https://registry.npmjs.org/rrweb-cssom/-/rrweb-cssom-0.8.0.tgz",
+      "integrity": "sha512-guoltQEx+9aMf2gDZ0s62EcV8lsXR+0w8915TC3ITdn2YueuNjdAYh/levpU9nFaoChh9RUS5ZdQMrKfVEN9tw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/safer-buffer": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz",
+      "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/saxes": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/saxes/-/saxes-6.0.0.tgz",
+      "integrity": "sha512-xAg7SOnEhrm5zI3puOOKyy1OMcMlIJZYNJY7xLBwSze0UjhPLnWfj2GF2EpT0jmzaJKIWKHLsaSSajf35bcYnA==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "xmlchars": "^2.2.0"
+      },
+      "engines": {
+        "node": ">=v12.22.7"
+      }
+    },
     "node_modules/scheduler": {
-      "version": "0.25.0",
-      "resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.25.0.tgz",
-      "integrity": "sha512-xFVuu11jh+xcO7JOAGJNOXld8/TcEHK/4CituBUeUb5hqxJLj9YuemAEuvm9gQ/+pgXYfbQuqAkiYu+u7YEsNA==",
+      "version": "0.26.0",
+      "resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.26.0.tgz",
+      "integrity": "sha512-NlHwttCI/l5gCPR3D1nNXtWABUmBwvZpEQiD4IXSbIDq8BzLIK/7Ir5gTFSGZDUu37K5cMNp0hFtzO38sC7gWA==",
       "license": "MIT"
     },
     "node_modules/set-cookie-parser": {
@@ -3266,6 +4739,13 @@
         "node": ">=8"
       }
     },
+    "node_modules/siginfo": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/siginfo/-/siginfo-2.0.0.tgz",
+      "integrity": "sha512-ybx0WO1/8bSBLEWXZvEd7gMW3Sn3JFlW3TvX1nREbDLRNQNaeNN8WK0meBwPdAaOI7TtRRRJn/Es1zhrrCHu7g==",
+      "dev": true,
+      "license": "ISC"
+    },
     "node_modules/source-map": {
       "version": "0.5.7",
       "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.5.7.tgz",
@@ -3285,6 +4765,33 @@
         "node": ">=0.10.0"
       }
     },
+    "node_modules/stackback": {
+      "version": "0.0.2",
+      "resolved": "https://registry.npmjs.org/stackback/-/stackback-0.0.2.tgz",
+      "integrity": "sha512-1XMJE5fQo1jGH6Y/7ebnwPOBEkIEnT4QF32d5R1+VXdXveM0IBMJt8zfaxX1P3QhVwrYe+576+jkANtSS2mBbw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/std-env": {
+      "version": "3.9.0",
+      "resolved": "https://registry.npmjs.org/std-env/-/std-env-3.9.0.tgz",
+      "integrity": "sha512-UGvjygr6F6tpH7o2qyqR6QYpwraIjKSdtzyBdyytFOHmPZY917kwdwLG0RbOjWOnKmnm3PeHjaoLLMie7kPLQw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/strip-indent": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/strip-indent/-/strip-indent-3.0.0.tgz",
+      "integrity": "sha512-laJTa3Jb+VQpaC6DseHhF7dXVqHTfJPCRDaEbid/drOhgitgYku/letMUqOXFoWV0zIIUbjpdH2t+tYj4bQMRQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "min-indent": "^1.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/strip-json-comments": {
       "version": "3.1.1",
       "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-3.1.1.tgz",
@@ -3298,6 +4805,26 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/strip-literal": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/strip-literal/-/strip-literal-3.0.0.tgz",
+      "integrity": "sha512-TcccoMhJOM3OebGhSBEmp3UZ2SfDMZUEBdRA/9ynfLi8yYajyWX3JiXArcJt4Umh4vISpspkQIY8ZZoCqjbviA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "js-tokens": "^9.0.1"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/antfu"
+      }
+    },
+    "node_modules/strip-literal/node_modules/js-tokens": {
+      "version": "9.0.1",
+      "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-9.0.1.tgz",
+      "integrity": "sha512-mxa9E9ITFOt0ban3j6L5MpjwegGz6lBQmM1IJkWeBZGcMxto50+eWdjC/52xDbS2vy0k7vIMK0Fe2wfL9OQSpQ==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/stylis": {
       "version": "4.2.0",
       "resolved": "https://registry.npmjs.org/stylis/-/stylis-4.2.0.tgz",
@@ -3329,6 +4856,13 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/symbol-tree": {
+      "version": "3.2.4",
+      "resolved": "https://registry.npmjs.org/symbol-tree/-/symbol-tree-3.2.4.tgz",
+      "integrity": "sha512-9QNk5KwDF+Bvz+PyObkmSYjI5ksVUYtjW7AU22r2NKcfLJcXp96hkDWU3+XndOsUb+AQ9QhfzfCT2O+CNWT5Tw==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/tabbable": {
       "version": "6.2.0",
       "resolved": "https://registry.npmjs.org/tabbable/-/tabbable-6.2.0.tgz",
@@ -3353,15 +4887,29 @@
       "integrity": "sha512-lBN9zLN/oAf68o3zNXYrdCt1kP8WsiGW8Oo2ka41b2IM5JL/S1CTyX1rW0mb/zSuJun0ZUrDxx4sqvYS2FWzPA==",
       "license": "MIT"
     },
+    "node_modules/tinybench": {
+      "version": "2.9.0",
+      "resolved": "https://registry.npmjs.org/tinybench/-/tinybench-2.9.0.tgz",
+      "integrity": "sha512-0+DUvqWMValLmha6lr4kD8iAMK1HzV0/aKnCtWb9v9641TnP/MFb7Pc2bxoxQjTXAErryXVgUOfv2YqNllqGeg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/tinyexec": {
+      "version": "0.3.2",
+      "resolved": "https://registry.npmjs.org/tinyexec/-/tinyexec-0.3.2.tgz",
+      "integrity": "sha512-KQQR9yN7R5+OSwaK0XQoj22pwHoTlgYqmUscPYoknOoWCWfj/5/ABTMRi69FrKU5ffPVh5QcFikpWJI/P1ocHA==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/tinyglobby": {
-      "version": "0.2.13",
-      "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.13.tgz",
-      "integrity": "sha512-mEwzpUgrLySlveBwEVDMKk5B57bhLPYovRfPAXD5gA/98Opn0rCDj3GtLwFvCvH5RK9uPCExUROW5NjDwvqkxw==",
+      "version": "0.2.15",
+      "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.15.tgz",
+      "integrity": "sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
-        "fdir": "^6.4.4",
-        "picomatch": "^4.0.2"
+        "fdir": "^6.5.0",
+        "picomatch": "^4.0.3"
       },
       "engines": {
         "node": ">=12.0.0"
@@ -3370,12 +4918,88 @@
         "url": "https://github.com/sponsors/SuperchupuDev"
       }
     },
+    "node_modules/tinypool": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/tinypool/-/tinypool-1.1.1.tgz",
+      "integrity": "sha512-Zba82s87IFq9A9XmjiX5uZA/ARWDrB03OHlq+Vw1fSdt0I+4/Kutwy8BP4Y/y/aORMo61FQ0vIb5j44vSo5Pkg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^18.0.0 || >=20.0.0"
+      }
+    },
+    "node_modules/tinyrainbow": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/tinyrainbow/-/tinyrainbow-2.0.0.tgz",
+      "integrity": "sha512-op4nsTR47R6p0vMUUoYl/a+ljLFVtlfaXkLQmqfLR1qHma1h/ysYk4hEXZ880bf2CYgTskvTa/e196Vd5dDQXw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=14.0.0"
+      }
+    },
+    "node_modules/tinyspy": {
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/tinyspy/-/tinyspy-4.0.4.tgz",
+      "integrity": "sha512-azl+t0z7pw/z958Gy9svOTuzqIk6xq+NSheJzn5MMWtWTFywIacg2wUlzKFGtt3cthx0r2SxMK0yzJOR0IES7Q==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=14.0.0"
+      }
+    },
+    "node_modules/tldts": {
+      "version": "7.0.15",
+      "resolved": "https://registry.npmjs.org/tldts/-/tldts-7.0.15.tgz",
+      "integrity": "sha512-heYRCiGLhtI+U/D0V8YM3QRwPfsLJiP+HX+YwiHZTnWzjIKC+ZCxQRYlzvOoTEc6KIP62B1VeAN63diGCng2hg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "tldts-core": "^7.0.15"
+      },
+      "bin": {
+        "tldts": "bin/cli.js"
+      }
+    },
+    "node_modules/tldts-core": {
+      "version": "7.0.15",
+      "resolved": "https://registry.npmjs.org/tldts-core/-/tldts-core-7.0.15.tgz",
+      "integrity": "sha512-YBkp2VfS9VTRMPNL2PA6PMESmxV1JEVoAr5iBlZnB5JG3KUrWzNCB3yNNkRa2FZkqClaBgfNYCp8PgpYmpjkZw==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/toposort": {
       "version": "2.0.2",
       "resolved": "https://registry.npmjs.org/toposort/-/toposort-2.0.2.tgz",
       "integrity": "sha512-0a5EOkAUp8D4moMi2W8ZF8jcga7BgZd91O/yabJCFY8az+XSzeGyTKs0Aoo897iV1Nj6guFq8orWDS96z91oGg==",
       "license": "MIT"
     },
+    "node_modules/tough-cookie": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/tough-cookie/-/tough-cookie-6.0.0.tgz",
+      "integrity": "sha512-kXuRi1mtaKMrsLUxz3sQYvVl37B0Ns6MzfrtV5DvJceE9bPyspOqk9xxv7XbZWcfLWbFmm997vl83qUWVJA64w==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "tldts": "^7.0.5"
+      },
+      "engines": {
+        "node": ">=16"
+      }
+    },
+    "node_modules/tr46": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/tr46/-/tr46-6.0.0.tgz",
+      "integrity": "sha512-bLVMLPtstlZ4iMQHpFHTR7GAGj2jxi8Dg0s2h2MafAE4uSWF98FC/3MomU51iQAMf8/qDUbKWf5GxuvvVcXEhw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "punycode": "^2.3.1"
+      },
+      "engines": {
+        "node": ">=20"
+      }
+    },
     "node_modules/tslib": {
       "version": "2.8.1",
       "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
@@ -3483,6 +5107,19 @@
         }
       }
     },
+    "node_modules/use-resize-observer": {
+      "version": "9.1.0",
+      "resolved": "https://registry.npmjs.org/use-resize-observer/-/use-resize-observer-9.1.0.tgz",
+      "integrity": "sha512-R25VqO9Wb3asSD4eqtcxk8sJalvIOYBqS8MNZlpDSQ4l4xMQxC/J7Id9HoTqPq8FwULIn0PVW+OAqF2dyYbjow==",
+      "license": "MIT",
+      "dependencies": {
+        "@juggle/resize-observer": "^3.3.1"
+      },
+      "peerDependencies": {
+        "react": "16.8.0 - 18",
+        "react-dom": "16.8.0 - 18"
+      }
+    },
     "node_modules/use-sidecar": {
       "version": "1.1.3",
       "resolved": "https://registry.npmjs.org/use-sidecar/-/use-sidecar-1.1.3.tgz",
@@ -3653,11 +5290,168 @@
         }
       }
     },
+    "node_modules/vite-node": {
+      "version": "3.2.4",
+      "resolved": "https://registry.npmjs.org/vite-node/-/vite-node-3.2.4.tgz",
+      "integrity": "sha512-EbKSKh+bh1E1IFxeO0pg1n4dvoOTt0UDiXMd/qn++r98+jPO1xtJilvXldeuQ8giIB5IkpjCgMleHMNEsGH6pg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "cac": "^6.7.14",
+        "debug": "^4.4.1",
+        "es-module-lexer": "^1.7.0",
+        "pathe": "^2.0.3",
+        "vite": "^5.0.0 || ^6.0.0 || ^7.0.0-0"
+      },
+      "bin": {
+        "vite-node": "vite-node.mjs"
+      },
+      "engines": {
+        "node": "^18.0.0 || ^20.0.0 || >=22.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      }
+    },
+    "node_modules/vitest": {
+      "version": "3.2.4",
+      "resolved": "https://registry.npmjs.org/vitest/-/vitest-3.2.4.tgz",
+      "integrity": "sha512-LUCP5ev3GURDysTWiP47wRRUpLKMOfPh+yKTx3kVIEiu5KOMeqzpnYNsKyOoVrULivR8tLcks4+lga33Whn90A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@types/chai": "^5.2.2",
+        "@vitest/expect": "3.2.4",
+        "@vitest/mocker": "3.2.4",
+        "@vitest/pretty-format": "^3.2.4",
+        "@vitest/runner": "3.2.4",
+        "@vitest/snapshot": "3.2.4",
+        "@vitest/spy": "3.2.4",
+        "@vitest/utils": "3.2.4",
+        "chai": "^5.2.0",
+        "debug": "^4.4.1",
+        "expect-type": "^1.2.1",
+        "magic-string": "^0.30.17",
+        "pathe": "^2.0.3",
+        "picomatch": "^4.0.2",
+        "std-env": "^3.9.0",
+        "tinybench": "^2.9.0",
+        "tinyexec": "^0.3.2",
+        "tinyglobby": "^0.2.14",
+        "tinypool": "^1.1.1",
+        "tinyrainbow": "^2.0.0",
+        "vite": "^5.0.0 || ^6.0.0 || ^7.0.0-0",
+        "vite-node": "3.2.4",
+        "why-is-node-running": "^2.3.0"
+      },
+      "bin": {
+        "vitest": "vitest.mjs"
+      },
+      "engines": {
+        "node": "^18.0.0 || ^20.0.0 || >=22.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/vitest"
+      },
+      "peerDependencies": {
+        "@edge-runtime/vm": "*",
+        "@types/debug": "^4.1.12",
+        "@types/node": "^18.0.0 || ^20.0.0 || >=22.0.0",
+        "@vitest/browser": "3.2.4",
+        "@vitest/ui": "3.2.4",
+        "happy-dom": "*",
+        "jsdom": "*"
+      },
+      "peerDependenciesMeta": {
+        "@edge-runtime/vm": {
+          "optional": true
+        },
+        "@types/debug": {
+          "optional": true
+        },
+        "@types/node": {
+          "optional": true
+        },
+        "@vitest/browser": {
+          "optional": true
+        },
+        "@vitest/ui": {
+          "optional": true
+        },
+        "happy-dom": {
+          "optional": true
+        },
+        "jsdom": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/w3c-xmlserializer": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/w3c-xmlserializer/-/w3c-xmlserializer-5.0.0.tgz",
+      "integrity": "sha512-o8qghlI8NZHU1lLPrpi2+Uq7abh4GGPpYANlalzWxyWteJOCsr/P+oPBA49TOLu5FTZO4d3F9MnWJfiMo4BkmA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "xml-name-validator": "^5.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/webidl-conversions": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-8.0.0.tgz",
+      "integrity": "sha512-n4W4YFyz5JzOfQeA8oN7dUYpR+MBP3PIUsn2jLjWXwK5ASUzt0Jc/A5sAUZoCYFJRGF0FBKJ+1JjN43rNdsQzA==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=20"
+      }
+    },
     "node_modules/webworkify-webpack": {
       "version": "2.1.5",
-      "resolved": "git+ssh://git@github.com/xqq/webworkify-webpack.git#24d1e719b4a6cac37a518b2bb10fe124527ef4ef",
+      "resolved": "git+ssh://git@github.com/xqq/webworkify-webpack.git",
+      "integrity": "sha512-W8Bg+iLq52d2GFvwabPNCIDCgMHcW3g68Tr8zwpJliEz2cKBIKYL3T0VdYeZWhz5rOxWRBBEdF931fquSO6iCQ==",
       "license": "MIT"
     },
+    "node_modules/whatwg-encoding": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/whatwg-encoding/-/whatwg-encoding-3.1.1.tgz",
+      "integrity": "sha512-6qN4hJdMwfYBtE3YBTTHhoeuUrDBPZmbQaxWAqSALV/MeEnR5z1xd8UKud2RAkFoPkmB+hli1TZSnyi84xz1vQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "iconv-lite": "0.6.3"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/whatwg-mimetype": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/whatwg-mimetype/-/whatwg-mimetype-4.0.0.tgz",
+      "integrity": "sha512-QaKxh0eNIi2mE9p2vEdzfagOKHCcj1pJ56EEHGQOVxp8r9/iszLUUV7v89x9O1p/T+NlTM5W7jW6+cz4Fq1YVg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/whatwg-url": {
+      "version": "15.1.0",
+      "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-15.1.0.tgz",
+      "integrity": "sha512-2ytDk0kiEj/yu90JOAp44PVPUkO9+jVhyf+SybKlRHSDlvOOZhdPIrr7xTH64l4WixO2cP+wQIcgujkGBPPz6g==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "tr46": "^6.0.0",
+        "webidl-conversions": "^8.0.0"
+      },
+      "engines": {
+        "node": ">=20"
+      }
+    },
     "node_modules/which": {
       "version": "2.0.2",
       "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
@@ -3674,6 +5468,23 @@
         "node": ">= 8"
       }
     },
+    "node_modules/why-is-node-running": {
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/why-is-node-running/-/why-is-node-running-2.3.0.tgz",
+      "integrity": "sha512-hUrmaWBdVDcxvYqnyh09zunKzROWjbZTiNy8dBEjkS7ehEDQibXJ7XvlmtbwuTclUiIyN+CyXQD4Vmko8fNm8w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "siginfo": "^2.0.0",
+        "stackback": "0.0.2"
+      },
+      "bin": {
+        "why-is-node-running": "cli.js"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/word-wrap": {
       "version": "1.2.5",
       "resolved": "https://registry.npmjs.org/word-wrap/-/word-wrap-1.2.5.tgz",
@@ -3684,6 +5495,60 @@
         "node": ">=0.10.0"
       }
     },
+    "node_modules/ws": {
+      "version": "8.18.3",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.3.tgz",
+      "integrity": "sha512-PEIGCY5tSlUt50cqyMXfCzX+oOPqN0vuGqWzbcJ2xvnkzkq46oOpz7dQaTDBdfICb4N14+GARUDw2XV2N4tvzg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=10.0.0"
+      },
+      "peerDependencies": {
+        "bufferutil": "^4.0.1",
+        "utf-8-validate": ">=5.0.2"
+      },
+      "peerDependenciesMeta": {
+        "bufferutil": {
+          "optional": true
+        },
+        "utf-8-validate": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/xml-name-validator": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/xml-name-validator/-/xml-name-validator-5.0.0.tgz",
+      "integrity": "sha512-EvGK8EJ3DhaHfbRlETOWAS5pO9MZITeauHKJyb8wyajUfQUenkIg2MvLDTZ4T/TgIcm3HU0TFBgWWboAZ30UHg==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/xmlchars": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/xmlchars/-/xmlchars-2.2.0.tgz",
+      "integrity": "sha512-JZnDKK8B0RCDw84FNdDAIpZK+JuJw+s7Lz8nksI7SIuU3UXJJslUthsi+uWBUYOwPFwW7W7PRLRfUKpxjtjFCw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/yaml": {
+      "version": "2.8.1",
+      "resolved": "https://registry.npmjs.org/yaml/-/yaml-2.8.1.tgz",
+      "integrity": "sha512-lcYcMxX2PO9XMGvAJkJ3OsNMw+/7FKes7/hgerGUYWIoWu5j/+YQqcZr5JnPZWzOsEBgMbSbiSTn/dv/69Mkpw==",
+      "dev": true,
+      "license": "ISC",
+      "optional": true,
+      "peer": true,
+      "bin": {
+        "yaml": "bin.mjs"
+      },
+      "engines": {
+        "node": ">= 14.6"
+      }
+    },
     "node_modules/yocto-queue": {
       "version": "0.1.0",
       "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz",
diff --git a/frontend/package.json b/frontend/package.json
index 1f6c769d..fea6b73e 100644
--- a/frontend/package.json
+++ b/frontend/package.json
@@ -1,5 +1,5 @@
 {
-  "name": "vite",
+  "name": "frontend",
   "private": true,
   "version": "0.0.0",
   "type": "module",
@@ -7,7 +7,9 @@
     "dev": "vite --host",
     "build": "vite build",
     "lint": "eslint .",
-    "preview": "vite preview"
+    "preview": "vite preview",
+    "test": "vitest --run",
+    "test:watch": "vitest"
   },
   "dependencies": {
     "@dnd-kit/core": "^6.3.1",
@@ -22,14 +24,14 @@
     "@mantine/hooks": "~8.0.1",
     "@mantine/notifications": "~8.0.1",
     "@tanstack/react-table": "^8.21.2",
-    "allotment": "^1.20.3",
+    "allotment": "^1.20.4",
     "dayjs": "^1.11.13",
     "formik": "^2.4.6",
     "hls.js": "^1.5.20",
     "lucide-react": "^0.511.0",
     "mpegts.js": "^1.8.0",
-    "react": "^19.0.0",
-    "react-dom": "^19.0.0",
+    "react": "^19.1.0",
+    "react-dom": "^19.1.0",
     "react-draggable": "^4.4.6",
     "react-pro-sidebar": "^1.1.0",
     "react-router-dom": "^7.3.0",
@@ -43,14 +45,27 @@
   },
   "devDependencies": {
     "@eslint/js": "^9.21.0",
-    "@types/react": "^19.0.10",
-    "@types/react-dom": "^19.0.4",
-    "@vitejs/plugin-react-swc": "^3.8.0",
+    "@swc/core": "npm:@swc/wasm@1.13.20",
+    "@swc/wasm": "^1.13.20",
+    "@testing-library/dom": "^10.4.1",
+    "@testing-library/jest-dom": "^6.8.0",
+    "@testing-library/react": "^16.3.0",
+    "@testing-library/user-event": "^14.6.1",
+    "@types/react": "^19.1.0",
+    "@types/react-dom": "^19.1.0",
+    "@vitejs/plugin-react-swc": "^4.1.0",
     "eslint": "^9.21.0",
     "eslint-plugin-react-hooks": "^5.1.0",
     "eslint-plugin-react-refresh": "^0.4.19",
     "globals": "^15.15.0",
+    "jsdom": "^27.0.0",
     "prettier": "^3.5.3",
-    "vite": "^6.2.0"
+    "vite": "^6.2.0",
+    "vitest": "^3.2.4"
+  },
+  "resolutions": {
+    "vite": "7.1.7",
+    "react": "19.1.0",
+    "react-dom": "19.1.0"
   }
 }
diff --git a/frontend/src/api.js b/frontend/src/api.js
index fa2063e6..4ef5f97e 100644
--- a/frontend/src/api.js
+++ b/frontend/src/api.js
@@ -562,6 +562,29 @@ export default class API {
     }
   }
 
+  static async setChannelTvgIdsFromEpg(channelIds) {
+    try {
+      const response = await request(
+        `${host}/api/channels/channels/set-tvg-ids-from-epg/`,
+        {
+          method: 'POST',
+          body: { channel_ids: channelIds },
+        }
+      );
+
+      notifications.show({
+        title: 'Task Started',
+        message: response.message,
+        color: 'blue',
+      });
+
+      return response;
+    } catch (e) {
+      errorNotification('Failed to start EPG TVG-ID setting task', e);
+      throw e;
+    }
+  }
+
   static async assignChannelNumbers(channelIds, startingNum = 1) {
     try {
       const response = await request(`${host}/api/channels/channels/assign/`, {
diff --git a/frontend/src/components/forms/Channel.jsx b/frontend/src/components/forms/Channel.jsx
index 53ecddd2..fd2e5312 100644
--- a/frontend/src/components/forms/Channel.jsx
+++ b/frontend/src/components/forms/Channel.jsx
@@ -11,6 +11,7 @@ import logo from '../../images/logo.png';
 import { useChannelLogoSelection } from '../../hooks/useSmartLogos';
 import useLogosStore from '../../store/logos';
 import LazyLogo from '../LazyLogo';
+import LogoForm from './Logo';
 import {
   Box,
   Button,
@@ -37,7 +38,7 @@ import {
 import { notifications } from '@mantine/notifications';
 import { ListOrdered, SquarePlus, SquareX, X, Zap } from 'lucide-react';
 import useEPGsStore from '../../store/epgs';
-import { Dropzone } from '@mantine/dropzone';
+
 import { FixedSizeList as List } from 'react-window';
 import { USER_LEVELS, USER_LEVEL_LABELS } from '../../constants';
 
@@ -71,7 +72,7 @@ const ChannelForm = ({ channel = null, isOpen, onClose }) => {
   const tvgs = useEPGsStore((s) => s.tvgs);
   const tvgsById = useEPGsStore((s) => s.tvgsById);
 
-  const [logoPreview, setLogoPreview] = useState(null);
+  const [logoModalOpen, setLogoModalOpen] = useState(false);
   const [channelStreams, setChannelStreams] = useState([]);
   const [channelGroupModelOpen, setChannelGroupModalOpen] = useState(false);
   const [epgPopoverOpened, setEpgPopoverOpened] = useState(false);
@@ -97,33 +98,12 @@ const ChannelForm = ({ channel = null, isOpen, onClose }) => {
     setChannelStreams(Array.from(streamSet));
   };
 
-  const handleLogoChange = async (files) => {
-    if (files.length === 1) {
-      const file = files[0];
-
-      // Validate file size on frontend first
-      if (file.size > 5 * 1024 * 1024) {
-        // 5MB
-        notifications.show({
-          title: 'Error',
-          message: 'File too large. Maximum size is 5MB.',
-          color: 'red',
-        });
-        return;
-      }
-
-      try {
-        const retval = await API.uploadLogo(file);
-        // Note: API.uploadLogo already adds the logo to the store, no need to fetch
-        setLogoPreview(retval.cache_url);
-        formik.setFieldValue('logo_id', retval.id);
-      } catch (error) {
-        console.error('Logo upload failed:', error);
-        // Error notification is already handled in API.uploadLogo
-      }
-    } else {
-      setLogoPreview(null);
+  const handleLogoSuccess = ({ logo }) => {
+    if (logo && logo.id) {
+      formik.setFieldValue('logo_id', logo.id);
+      ensureLogosLoaded(); // Refresh logos
     }
+    setLogoModalOpen(false);
   };
 
   const handleAutoMatchEpg = async () => {
@@ -283,6 +263,34 @@ const ChannelForm = ({ channel = null, isOpen, onClose }) => {
     }
   };
 
+  const handleSetTvgIdFromEpg = () => {
+    const epgDataId = formik.values.epg_data_id;
+    if (!epgDataId) {
+      notifications.show({
+        title: 'No EPG Selected',
+        message: 'Please select an EPG source first.',
+        color: 'orange',
+      });
+      return;
+    }
+
+    const tvg = tvgsById[epgDataId];
+    if (tvg && tvg.tvg_id) {
+      formik.setFieldValue('tvg_id', tvg.tvg_id);
+      notifications.show({
+        title: 'Success',
+        message: `TVG-ID set to "${tvg.tvg_id}"`,
+        color: 'green',
+      });
+    } else {
+      notifications.show({
+        title: 'No TVG-ID Available',
+        message: 'No TVG-ID found in the selected EPG data.',
+        color: 'orange',
+      });
+    }
+  };
+
   const formik = useFormik({
     initialValues: {
       name: '',
@@ -809,35 +817,13 @@ const ChannelForm = ({ channel = null, isOpen, onClose }) => {
                 </Stack>
               </Group>
 
-              <Group>
-                <Divider size="xs" style={{ flex: 1 }} />
-                <Text size="xs" c="dimmed">
-                  OR
-                </Text>
-                <Divider size="xs" style={{ flex: 1 }} />
-              </Group>
-
-              <Stack>
-                <Text size="sm">Upload Logo</Text>
-                <Dropzone
-                  onDrop={handleLogoChange}
-                  onReject={(files) => console.log('rejected files', files)}
-                  maxSize={5 * 1024 ** 2}
-                >
-                  <Group
-                    justify="center"
-                    gap="xl"
-                    mih={40}
-                    style={{ pointerEvents: 'none' }}
-                  >
-                    <Text size="sm" inline>
-                      Drag images here or click to select files
-                    </Text>
-                  </Group>
-                </Dropzone>
-
-                <Center></Center>
-              </Stack>
+              <Button
+                onClick={() => setLogoModalOpen(true)}
+                fullWidth
+                variant="default"
+              >
+                Upload or Create Logo
+              </Button>
             </Stack>
 
             <Divider size="sm" orientation="vertical" />
@@ -865,7 +851,23 @@ const ChannelForm = ({ channel = null, isOpen, onClose }) => {
               <TextInput
                 id="tvg_id"
                 name="tvg_id"
-                label="TVG-ID"
+                label={
+                  <Group gap="xs">
+                    <span>TVG-ID</span>
+                    {formik.values.epg_data_id && (
+                      <Button
+                        size="xs"
+                        variant="transparent"
+                        onClick={handleSetTvgIdFromEpg}
+                        title="Set TVG-ID from EPG data"
+                        p={0}
+                        h="auto"
+                      >
+                        Use EPG TVG-ID
+                      </Button>
+                    )}
+                  </Group>
+                }
                 value={formik.values.tvg_id}
                 onChange={formik.handleChange}
                 error={formik.errors.tvg_id ? formik.touched.tvg_id : ''}
@@ -1057,6 +1059,12 @@ const ChannelForm = ({ channel = null, isOpen, onClose }) => {
         isOpen={channelGroupModelOpen}
         onClose={handleChannelGroupModalClose}
       />
+
+      <LogoForm
+        isOpen={logoModalOpen}
+        onClose={() => setLogoModalOpen(false)}
+        onSuccess={handleLogoSuccess}
+      />
     </>
   );
 };
diff --git a/frontend/src/components/forms/ChannelBatch.jsx b/frontend/src/components/forms/ChannelBatch.jsx
index ad61fb26..0527a3b6 100644
--- a/frontend/src/components/forms/ChannelBatch.jsx
+++ b/frontend/src/components/forms/ChannelBatch.jsx
@@ -29,18 +29,34 @@ import { FixedSizeList as List } from 'react-window';
 import { useForm } from '@mantine/form';
 import { notifications } from '@mantine/notifications';
 import { USER_LEVELS, USER_LEVEL_LABELS } from '../../constants';
+import { useChannelLogoSelection } from '../../hooks/useSmartLogos';
+import LazyLogo from '../LazyLogo';
+import logo from '../../images/logo.png';
+import ConfirmationDialog from '../ConfirmationDialog';
+import useWarningsStore from '../../store/warnings';
 
 const ChannelBatchForm = ({ channelIds, isOpen, onClose }) => {
   const theme = useMantineTheme();
 
   const groupListRef = useRef(null);
+  const logoListRef = useRef(null);
 
   const channelGroups = useChannelsStore((s) => s.channelGroups);
+  const {
+    logos: channelLogos,
+    ensureLogosLoaded,
+    isLoading: logosLoading,
+  } = useChannelLogoSelection();
+
+  useEffect(() => {
+    ensureLogosLoaded();
+  }, [ensureLogosLoaded]);
 
   const streamProfiles = useStreamProfilesStore((s) => s.profiles);
 
   const [channelGroupModelOpen, setChannelGroupModalOpen] = useState(false);
   const [selectedChannelGroup, setSelectedChannelGroup] = useState('-1');
+  const [selectedLogoId, setSelectedLogoId] = useState('-1');
   const [isSubmitting, setIsSubmitting] = useState(false);
   const [regexFind, setRegexFind] = useState('');
   const [regexReplace, setRegexReplace] = useState('');
@@ -49,10 +65,21 @@ const ChannelBatchForm = ({ channelIds, isOpen, onClose }) => {
   const [groupFilter, setGroupFilter] = useState('');
   const groupOptions = Object.values(channelGroups);
 
+  const [logoPopoverOpened, setLogoPopoverOpened] = useState(false);
+  const [logoFilter, setLogoFilter] = useState('');
+  // Confirmation dialog states
+  const [confirmSetNamesOpen, setConfirmSetNamesOpen] = useState(false);
+  const [confirmSetLogosOpen, setConfirmSetLogosOpen] = useState(false);
+  const [confirmSetTvgIdsOpen, setConfirmSetTvgIdsOpen] = useState(false);
+  const [confirmClearEpgsOpen, setConfirmClearEpgsOpen] = useState(false);
+  const isWarningSuppressed = useWarningsStore((s) => s.isWarningSuppressed);
+  const suppressWarning = useWarningsStore((s) => s.suppressWarning);
+
   const form = useForm({
     mode: 'uncontrolled',
     initialValues: {
       channel_group: '(no change)',
+      logo: '(no change)',
       stream_profile_id: '-1',
       user_level: '-1',
     },
@@ -70,6 +97,15 @@ const ChannelBatchForm = ({ channelIds, isOpen, onClose }) => {
       delete values.channel_group_id;
     }
 
+    if (selectedLogoId && selectedLogoId !== '-1') {
+      if (selectedLogoId === '0') {
+        values.logo_id = null;
+      } else {
+        values.logo_id = parseInt(selectedLogoId);
+      }
+    }
+    delete values.logo;
+
     // Handle stream profile ID - convert special values
     if (!values.stream_profile_id || values.stream_profile_id === '-1') {
       delete values.stream_profile_id;
@@ -144,6 +180,15 @@ const ChannelBatchForm = ({ channelIds, isOpen, onClose }) => {
       return;
     }
 
+    // Skip warning if suppressed
+    if (isWarningSuppressed('batch-set-names-from-epg')) {
+      return executeSetNamesFromEpg();
+    }
+
+    setConfirmSetNamesOpen(true);
+  };
+
+  const executeSetNamesFromEpg = async () => {
     try {
       // Start the backend task
       await API.setChannelNamesFromEpg(channelIds);
@@ -157,6 +202,7 @@ const ChannelBatchForm = ({ channelIds, isOpen, onClose }) => {
       });
 
       // Close the modal since the task is now running in background
+      setConfirmSetNamesOpen(false);
       onClose();
     } catch (error) {
       console.error('Failed to start EPG name setting task:', error);
@@ -165,6 +211,7 @@ const ChannelBatchForm = ({ channelIds, isOpen, onClose }) => {
         message: 'Failed to start EPG name setting task.',
         color: 'red',
       });
+      setConfirmSetNamesOpen(false);
     }
   };
 
@@ -178,6 +225,15 @@ const ChannelBatchForm = ({ channelIds, isOpen, onClose }) => {
       return;
     }
 
+    // Skip warning if suppressed
+    if (isWarningSuppressed('batch-set-logos-from-epg')) {
+      return executeSetLogosFromEpg();
+    }
+
+    setConfirmSetLogosOpen(true);
+  };
+
+  const executeSetLogosFromEpg = async () => {
     try {
       // Start the backend task
       await API.setChannelLogosFromEpg(channelIds);
@@ -191,6 +247,7 @@ const ChannelBatchForm = ({ channelIds, isOpen, onClose }) => {
       });
 
       // Close the modal since the task is now running in background
+      setConfirmSetLogosOpen(false);
       onClose();
     } catch (error) {
       console.error('Failed to start EPG logo setting task:', error);
@@ -199,6 +256,95 @@ const ChannelBatchForm = ({ channelIds, isOpen, onClose }) => {
         message: 'Failed to start EPG logo setting task.',
         color: 'red',
       });
+      setConfirmSetLogosOpen(false);
+    }
+  };
+
+  const handleSetTvgIdsFromEpg = async () => {
+    if (!channelIds || channelIds.length === 0) {
+      notifications.show({
+        title: 'No Channels Selected',
+        message: 'No channels to update.',
+        color: 'orange',
+      });
+      return;
+    }
+
+    // Skip warning if suppressed
+    if (isWarningSuppressed('batch-set-tvg-ids-from-epg')) {
+      return executeSetTvgIdsFromEpg();
+    }
+
+    setConfirmSetTvgIdsOpen(true);
+  };
+
+  const executeSetTvgIdsFromEpg = async () => {
+    try {
+      // Start the backend task
+      await API.setChannelTvgIdsFromEpg(channelIds);
+
+      // The task will send WebSocket updates for progress
+      // Just show that it started successfully
+      notifications.show({
+        title: 'Task Started',
+        message: `Started setting TVG-IDs from EPG for ${channelIds.length} channels. Progress will be shown in notifications.`,
+        color: 'blue',
+      });
+
+      // Close the modal since the task is now running in background
+      setConfirmSetTvgIdsOpen(false);
+      onClose();
+    } catch (error) {
+      console.error('Failed to start EPG TVG-ID setting task:', error);
+      notifications.show({
+        title: 'Error',
+        message: 'Failed to start EPG TVG-ID setting task.',
+        color: 'red',
+      });
+      setConfirmSetTvgIdsOpen(false);
+    }
+  };
+
+  const handleClearEpgs = async () => {
+    if (!channelIds || channelIds.length === 0) {
+      notifications.show({
+        title: 'No Channels Selected',
+        message: 'No channels to update.',
+        color: 'orange',
+      });
+      return;
+    }
+
+    // Skip warning if suppressed
+    if (isWarningSuppressed('batch-clear-epgs')) {
+      return executeClearEpgs();
+    }
+
+    setConfirmClearEpgsOpen(true);
+  };
+
+  const executeClearEpgs = async () => {
+    try {
+      // Clear EPG assignments (set to null/dummy) using existing batchSetEPG API
+      const associations = channelIds.map((id) => ({
+        channel_id: id,
+        epg_data_id: null,
+      }));
+
+      await API.batchSetEPG(associations);
+
+      // batchSetEPG already shows a notification and refreshes channels
+      // Close the modal
+      setConfirmClearEpgsOpen(false);
+      onClose();
+    } catch (error) {
+      console.error('Failed to clear EPG assignments:', error);
+      notifications.show({
+        title: 'Error',
+        message: 'Failed to clear EPG assignments.',
+        color: 'red',
+      });
+      setConfirmClearEpgsOpen(false);
     }
   };
 
@@ -242,6 +388,18 @@ const ChannelBatchForm = ({ channelIds, isOpen, onClose }) => {
     ),
   ];
 
+  const logoOptions = useMemo(() => {
+    return [
+      { id: '-1', name: '(no change)' },
+      { id: '0', name: 'Use Default', isDefault: true },
+      ...Object.values(channelLogos),
+    ];
+  }, [channelLogos]);
+
+  const filteredLogos = logoOptions.filter((logo) =>
+    logo.name.toLowerCase().includes(logoFilter.toLowerCase())
+  );
+
   if (!isOpen) {
     return <></>;
   }
@@ -317,10 +475,29 @@ const ChannelBatchForm = ({ channelIds, isOpen, onClose }) => {
                   >
                     Set Logos from EPG
                   </Button>
+                  <Button
+                    size="xs"
+                    variant="light"
+                    onClick={handleSetTvgIdsFromEpg}
+                    style={{ flex: 1 }}
+                  >
+                    Set TVG-IDs from EPG
+                  </Button>
+                </Group>
+                <Group gap="xs" wrap="nowrap" mt="xs">
+                  <Button
+                    size="xs"
+                    variant="light"
+                    color="red"
+                    onClick={handleClearEpgs}
+                    style={{ flex: 1 }}
+                  >
+                    Clear EPG (Set to Dummy)
+                  </Button>
                 </Group>
                 <Text size="xs" c="dimmed" mt="xs">
-                  Updates channel names and logos based on their assigned EPG
-                  data
+                  Updates channel names, logos, and TVG-IDs based on their
+                  assigned EPG data, or clear EPG assignments to use dummy EPG
                 </Text>
               </Paper>
 
@@ -445,6 +622,163 @@ const ChannelBatchForm = ({ channelIds, isOpen, onClose }) => {
                 </Popover.Dropdown>
               </Popover>
 
+              <Group style={{ width: '100%' }} align="flex-end" gap="xs">
+                <Popover
+                  opened={logoPopoverOpened}
+                  onChange={setLogoPopoverOpened}
+                  withArrow
+                >
+                  <Popover.Target>
+                    <TextInput
+                      label="Logo"
+                      readOnly
+                      {...form.getInputProps('logo')}
+                      key={form.key('logo')}
+                      onClick={() => setLogoPopoverOpened(true)}
+                      size="xs"
+                      style={{ flex: 1 }}
+                      rightSection={
+                        selectedLogoId !== '-1' && (
+                          <ActionIcon
+                            size="xs"
+                            variant="subtle"
+                            onClick={(e) => {
+                              e.stopPropagation();
+                              setSelectedLogoId('-1');
+                              form.setValues({ logo: '(no change)' });
+                            }}
+                          >
+                            <X size={12} />
+                          </ActionIcon>
+                        )
+                      }
+                    />
+                  </Popover.Target>
+                  <Popover.Dropdown onMouseDown={(e) => e.stopPropagation()}>
+                    <Group>
+                      <TextInput
+                        placeholder="Filter"
+                        value={logoFilter}
+                        onChange={(event) =>
+                          setLogoFilter(event.currentTarget.value)
+                        }
+                        mb="xs"
+                        size="xs"
+                      />
+                      {logosLoading && (
+                        <Text size="xs" c="dimmed">
+                          Loading...
+                        </Text>
+                      )}
+                    </Group>
+                    <ScrollArea style={{ height: 200 }}>
+                      {filteredLogos.length === 0 ? (
+                        <Center style={{ height: 200 }}>
+                          <Text size="sm" c="dimmed">
+                            {logoFilter
+                              ? 'No logos match your filter'
+                              : 'No logos available'}
+                          </Text>
+                        </Center>
+                      ) : (
+                        <List
+                          height={200}
+                          itemCount={filteredLogos.length}
+                          itemSize={55}
+                          style={{ width: '100%' }}
+                          ref={logoListRef}
+                        >
+                          {({ index, style }) => {
+                            const item = filteredLogos[index];
+                            return (
+                              <div
+                                style={{
+                                  ...style,
+                                  cursor: 'pointer',
+                                  padding: '5px',
+                                  borderRadius: '4px',
+                                }}
+                                onClick={() => {
+                                  setSelectedLogoId(item.id);
+                                  form.setValues({
+                                    logo: item.name,
+                                  });
+                                  setLogoPopoverOpened(false);
+                                }}
+                                onMouseEnter={(e) => {
+                                  e.currentTarget.style.backgroundColor =
+                                    'rgb(68, 68, 68)';
+                                }}
+                                onMouseLeave={(e) => {
+                                  e.currentTarget.style.backgroundColor =
+                                    'transparent';
+                                }}
+                              >
+                                <Center
+                                  style={{
+                                    flexDirection: 'column',
+                                    gap: '2px',
+                                  }}
+                                >
+                                  {item.isDefault ? (
+                                    <img
+                                      src={logo}
+                                      height="30"
+                                      style={{
+                                        maxWidth: 80,
+                                        objectFit: 'contain',
+                                      }}
+                                      alt="Default Logo"
+                                    />
+                                  ) : item.id > 0 ? (
+                                    <img
+                                      src={item.cache_url || logo}
+                                      height="30"
+                                      style={{
+                                        maxWidth: 80,
+                                        objectFit: 'contain',
+                                      }}
+                                      alt={item.name || 'Logo'}
+                                      onError={(e) => {
+                                        if (e.target.src !== logo) {
+                                          e.target.src = logo;
+                                        }
+                                      }}
+                                    />
+                                  ) : (
+                                    <Box h={30} />
+                                  )}
+                                  <Text
+                                    size="xs"
+                                    c="dimmed"
+                                    ta="center"
+                                    style={{
+                                      maxWidth: 80,
+                                      overflow: 'hidden',
+                                      textOverflow: 'ellipsis',
+                                      whiteSpace: 'nowrap',
+                                    }}
+                                  >
+                                    {item.name}
+                                  </Text>
+                                </Center>
+                              </div>
+                            );
+                          }}
+                        </List>
+                      )}
+                    </ScrollArea>
+                  </Popover.Dropdown>
+                </Popover>
+                {selectedLogoId > 0 && (
+                  <LazyLogo
+                    logoId={selectedLogoId}
+                    alt="channel logo"
+                    style={{ height: 24, marginBottom: 5 }}
+                  />
+                )}
+              </Group>
+
               <Select
                 id="stream_profile_id"
                 label="Stream Profile"
@@ -496,6 +830,90 @@ const ChannelBatchForm = ({ channelIds, isOpen, onClose }) => {
         isOpen={channelGroupModelOpen}
         onClose={handleChannelGroupModalClose}
       />
+
+      <ConfirmationDialog
+        opened={confirmSetNamesOpen}
+        onClose={() => setConfirmSetNamesOpen(false)}
+        onConfirm={executeSetNamesFromEpg}
+        title="Confirm Set Names from EPG"
+        message={
+          <div style={{ whiteSpace: 'pre-line' }}>
+            {`Are you sure you want to set names from EPG for ${channelIds?.length || 0} selected channels?
+
+This will replace the current channel names with the names from their assigned EPG data.
+
+This action cannot be undone.`}
+          </div>
+        }
+        confirmLabel="Set Names"
+        cancelLabel="Cancel"
+        actionKey="batch-set-names-from-epg"
+        onSuppressChange={suppressWarning}
+        size="md"
+      />
+
+      <ConfirmationDialog
+        opened={confirmSetLogosOpen}
+        onClose={() => setConfirmSetLogosOpen(false)}
+        onConfirm={executeSetLogosFromEpg}
+        title="Confirm Set Logos from EPG"
+        message={
+          <div style={{ whiteSpace: 'pre-line' }}>
+            {`Are you sure you want to set logos from EPG for ${channelIds?.length || 0} selected channels?
+
+This will replace the current channel logos with logos from their assigned EPG data. New logos will be created if needed.
+
+This action cannot be undone.`}
+          </div>
+        }
+        confirmLabel="Set Logos"
+        cancelLabel="Cancel"
+        actionKey="batch-set-logos-from-epg"
+        onSuppressChange={suppressWarning}
+        size="md"
+      />
+
+      <ConfirmationDialog
+        opened={confirmSetTvgIdsOpen}
+        onClose={() => setConfirmSetTvgIdsOpen(false)}
+        onConfirm={executeSetTvgIdsFromEpg}
+        title="Confirm Set TVG-IDs from EPG"
+        message={
+          <div style={{ whiteSpace: 'pre-line' }}>
+            {`Are you sure you want to set TVG-IDs from EPG for ${channelIds?.length || 0} selected channels?
+
+This will replace the current TVG-IDs with the TVG-IDs from their assigned EPG data.
+
+This action cannot be undone.`}
+          </div>
+        }
+        confirmLabel="Set TVG-IDs"
+        cancelLabel="Cancel"
+        actionKey="batch-set-tvg-ids-from-epg"
+        onSuppressChange={suppressWarning}
+        size="md"
+      />
+
+      <ConfirmationDialog
+        opened={confirmClearEpgsOpen}
+        onClose={() => setConfirmClearEpgsOpen(false)}
+        onConfirm={executeClearEpgs}
+        title="Confirm Clear EPG Assignments"
+        message={
+          <div style={{ whiteSpace: 'pre-line' }}>
+            {`Are you sure you want to clear EPG assignments for ${channelIds?.length || 0} selected channels?
+
+This will set all selected channels to use dummy EPG data.
+
+This action cannot be undone.`}
+          </div>
+        }
+        confirmLabel="Clear EPGs"
+        cancelLabel="Cancel"
+        actionKey="batch-clear-epgs"
+        onSuppressChange={suppressWarning}
+        size="md"
+      />
     </>
   );
 };
diff --git a/frontend/src/components/forms/Logo.jsx b/frontend/src/components/forms/Logo.jsx
index 25847ce8..8362b891 100644
--- a/frontend/src/components/forms/Logo.jsx
+++ b/frontend/src/components/forms/Logo.jsx
@@ -106,13 +106,12 @@ const LogoForm = ({ logo = null, isOpen, onClose, onSuccess }) => {
           onSuccess?.({ type: 'create', logo: newLogo }); // Call onSuccess for creates
         } else {
           // File was uploaded and logo was already created
-          // Note: API.uploadLogo already calls addLogo() in the store, so no need to call onSuccess
           notifications.show({
             title: 'Success',
             message: 'Logo uploaded successfully',
             color: 'green',
           });
-          // No onSuccess call needed - API.uploadLogo already updated the store
+          onSuccess?.({ type: 'create', logo: uploadResponse });
         }
         onClose();
       } catch (error) {
@@ -211,6 +210,24 @@ const LogoForm = ({ logo = null, isOpen, onClose, onSuccess }) => {
     }
   };
 
+  const handleUrlBlur = (event) => {
+    const urlValue = event.target.value;
+    if (urlValue) {
+      try {
+        const url = new URL(urlValue);
+        const pathname = url.pathname;
+        const filename = pathname.substring(pathname.lastIndexOf('/') + 1);
+        const nameWithoutExtension = filename.replace(/\.[^/.]+$/, '');
+        if (nameWithoutExtension) {
+          formik.setFieldValue('name', nameWithoutExtension);
+        }
+      } catch (error) {
+        // If the URL is invalid, do nothing.
+        // The validation schema will catch this.
+      }
+    }
+  };
+
   // Clean up object URLs when component unmounts or preview changes
   useEffect(() => {
     return () => {
@@ -323,6 +340,7 @@ const LogoForm = ({ logo = null, isOpen, onClose, onSuccess }) => {
             placeholder="https://example.com/logo.png"
             {...formik.getFieldProps('url')}
             onChange={handleUrlChange}
+            onBlur={handleUrlBlur}
             error={formik.touched.url && formik.errors.url}
             disabled={!!selectedFile} // Disable when file is selected
           />
diff --git a/frontend/src/components/forms/M3UFilter.jsx b/frontend/src/components/forms/M3UFilter.jsx
index dcb3323f..aaf5a1d7 100644
--- a/frontend/src/components/forms/M3UFilter.jsx
+++ b/frontend/src/components/forms/M3UFilter.jsx
@@ -51,8 +51,7 @@ const M3UFilter = ({ filter = null, m3u, isOpen, onClose }) => {
     values.custom_properties = setCustomProperty(
       filter ? filter.custom_properties : {},
       'case_sensitive',
-      values.case_sensitive,
-      true
+      values.case_sensitive
     );
 
     delete values.case_sensitive;
diff --git a/frontend/src/components/tables/StreamsTable.jsx b/frontend/src/components/tables/StreamsTable.jsx
index ef944bbd..c4ab3652 100644
--- a/frontend/src/components/tables/StreamsTable.jsx
+++ b/frontend/src/components/tables/StreamsTable.jsx
@@ -282,7 +282,7 @@ const StreamsTable = () => {
         cell: ({ getValue }) => (
           <Box
             style={{
-              whiteSpace: 'nowrap',
+              whiteSpace: 'pre',
               overflow: 'hidden',
               textOverflow: 'ellipsis',
             }}
@@ -301,7 +301,7 @@ const StreamsTable = () => {
         cell: ({ getValue }) => (
           <Box
             style={{
-              whiteSpace: 'nowrap',
+              whiteSpace: 'pre',
               overflow: 'hidden',
               textOverflow: 'ellipsis',
             }}
diff --git a/frontend/src/pages/Guide.jsx b/frontend/src/pages/Guide.jsx
index 7671fb57..50bd1222 100644
--- a/frontend/src/pages/Guide.jsx
+++ b/frontend/src/pages/Guide.jsx
@@ -1,5 +1,11 @@
 // frontend/src/pages/Guide.js
-import React, { useMemo, useState, useEffect, useRef } from 'react';
+import React, {
+  useMemo,
+  useState,
+  useEffect,
+  useRef,
+  useCallback,
+} from 'react';
 import dayjs from 'dayjs';
 import API from '../api';
 import useChannelsStore from '../store/channels';
@@ -23,23 +29,220 @@ import {
   Transition,
   Modal,
   Stack,
-  useMantineTheme,
 } from '@mantine/core';
 import { Search, X, Clock, Video, Calendar, Play } from 'lucide-react';
 import './guide.css';
 import useEPGsStore from '../store/epgs';
 import useLocalStorage from '../hooks/useLocalStorage';
+import { useElementSize } from '@mantine/hooks';
+import { VariableSizeList } from 'react-window';
+import {
+  PROGRAM_HEIGHT,
+  EXPANDED_PROGRAM_HEIGHT,
+  buildChannelIdMap,
+  mapProgramsByChannel,
+  computeRowHeights,
+} from './guideUtils';
 
 /** Layout constants */
 const CHANNEL_WIDTH = 120; // Width of the channel/logo column
-const PROGRAM_HEIGHT = 90; // Height of each channel row
-const EXPANDED_PROGRAM_HEIGHT = 180; // Height for expanded program rows
 const HOUR_WIDTH = 450; // Increased from 300 to 450 to make each program wider
 const MINUTE_INCREMENT = 15; // For positioning programs every 15 min
 const MINUTE_BLOCK_WIDTH = HOUR_WIDTH / (60 / MINUTE_INCREMENT);
 
+const GuideRow = React.memo(({ index, style, data }) => {
+  const {
+    filteredChannels,
+    programsByChannelId,
+    expandedProgramId,
+    rowHeights,
+    logos,
+    hoveredChannelId,
+    setHoveredChannelId,
+    renderProgram,
+    handleLogoClick,
+    contentWidth,
+  } = data;
+
+  const channel = filteredChannels[index];
+  if (!channel) {
+    return null;
+  }
+
+  const channelPrograms = programsByChannelId.get(channel.id) || [];
+  const rowHeight =
+    rowHeights[index] ??
+    (channelPrograms.some((program) => program.id === expandedProgramId)
+      ? EXPANDED_PROGRAM_HEIGHT
+      : PROGRAM_HEIGHT);
+
+  return (
+    <div
+      data-testid="guide-row"
+      style={{ ...style, width: contentWidth, height: rowHeight }}
+    >
+      <Box
+        style={{
+          display: 'flex',
+          height: '100%',
+          borderBottom: '0px solid #27272A',
+          transition: 'height 0.2s ease',
+          position: 'relative',
+          overflow: 'visible',
+        }}
+      >
+        <Box
+          className="channel-logo"
+          style={{
+            width: CHANNEL_WIDTH,
+            minWidth: CHANNEL_WIDTH,
+            flexShrink: 0,
+            display: 'flex',
+            alignItems: 'center',
+            justifyContent: 'center',
+            backgroundColor: '#18181B',
+            borderRight: '1px solid #27272A',
+            borderBottom: '1px solid #27272A',
+            boxShadow: '2px 0 5px rgba(0,0,0,0.2)',
+            left: 0,
+            zIndex: 30,
+            height: '100%',
+            transition: 'height 0.2s ease',
+            cursor: 'pointer',
+            position: 'relative',
+          }}
+          onClick={(event) => handleLogoClick(channel, event)}
+          onMouseEnter={() => setHoveredChannelId(channel.id)}
+          onMouseLeave={() => setHoveredChannelId(null)}
+        >
+          {hoveredChannelId === channel.id && (
+            <Flex
+              align="center"
+              justify="center"
+              style={{
+                position: 'absolute',
+                top: 0,
+                left: 0,
+                right: 0,
+                bottom: 0,
+                width: '100%',
+                height: '100%',
+                backgroundColor: 'rgba(0, 0, 0, 0.7)',
+                zIndex: 10,
+                animation: 'fadeIn 0.2s',
+              }}
+            >
+              <Play size={32} color="#fff" fill="#fff" />
+            </Flex>
+          )}
+
+          <Flex
+            direction="column"
+            align="center"
+            justify="space-between"
+            style={{
+              width: '100%',
+              height: '100%',
+              padding: '4px',
+              boxSizing: 'border-box',
+              zIndex: 5,
+              position: 'relative',
+            }}
+          >
+            <Box
+              style={{
+                width: '100%',
+                height: `${rowHeight - 32}px`,
+                display: 'flex',
+                alignItems: 'center',
+                justifyContent: 'center',
+                overflow: 'hidden',
+                padding: '4px',
+                marginBottom: '4px',
+              }}
+            >
+              <img
+                src={logos[channel.logo_id]?.cache_url || logo}
+                alt={channel.name}
+                style={{
+                  maxWidth: '100%',
+                  maxHeight: '100%',
+                  objectFit: 'contain',
+                }}
+              />
+            </Box>
+
+            <Text
+              size="sm"
+              weight={600}
+              style={{
+                position: 'absolute',
+                bottom: '4px',
+                left: '50%',
+                transform: 'translateX(-50%)',
+                backgroundColor: '#18181B',
+                padding: '2px 8px',
+                borderRadius: 4,
+                fontSize: '0.85em',
+                border: '1px solid #27272A',
+                height: '24px',
+                display: 'flex',
+                alignItems: 'center',
+                justifyContent: 'center',
+                minWidth: '36px',
+              }}
+            >
+              {channel.channel_number || '-'}
+            </Text>
+          </Flex>
+        </Box>
+
+        <Box
+          style={{
+            flex: 1,
+            position: 'relative',
+            height: '100%',
+            transition: 'height 0.2s ease',
+            paddingLeft: 0,
+          }}
+        >
+          {channelPrograms.length > 0 ? (
+            channelPrograms.map((program) =>
+              renderProgram(program, undefined, channel)
+            )
+          ) : (
+            <>
+              {Array.from({ length: Math.ceil(24 / 2) }).map(
+                (_, placeholderIndex) => (
+                  <Box
+                    key={`placeholder-${channel.id}-${placeholderIndex}`}
+                    style={{
+                      position: 'absolute',
+                      left: placeholderIndex * (HOUR_WIDTH * 2),
+                      top: 0,
+                      width: HOUR_WIDTH * 2,
+                      height: rowHeight - 4,
+                      border: '1px dashed #2D3748',
+                      borderRadius: '4px',
+                      display: 'flex',
+                      alignItems: 'center',
+                      justifyContent: 'center',
+                      color: '#4A5568',
+                    }}
+                  >
+                    <Text size="sm">No program data</Text>
+                  </Box>
+                )
+              )}
+            </>
+          )}
+        </Box>
+      </Box>
+    </div>
+  );
+});
+
 export default function TVChannelGuide({ startDate, endDate }) {
-  const theme = useMantineTheme();
   const channels = useChannelsStore((s) => s.channels);
   const recordings = useChannelsStore((s) => s.recordings);
   const channelGroups = useChannelsStore((s) => s.channelGroups);
@@ -59,7 +262,6 @@ export default function TVChannelGuide({ startDate, endDate }) {
   const [existingRuleMode, setExistingRuleMode] = useState(null);
   const [rulesOpen, setRulesOpen] = useState(false);
   const [rules, setRules] = useState([]);
-  const [loading, setLoading] = useState(true);
   const [initialScrollComplete, setInitialScrollComplete] = useState(false);
 
   // New filter states
@@ -71,6 +273,15 @@ export default function TVChannelGuide({ startDate, endDate }) {
 
   const guideRef = useRef(null);
   const timelineRef = useRef(null); // New ref for timeline scrolling
+  const listRef = useRef(null);
+  const isSyncingScroll = useRef(false);
+  const guideScrollLeftRef = useRef(0);
+  const {
+    ref: guideContainerRef,
+    width: guideWidth,
+    height: guideHeight,
+  } = useElementSize();
+  const [guideScrollLeft, setGuideScrollLeft] = useState(0);
 
   // Add new state to track hovered logo
   const [hoveredChannelId, setHoveredChannelId] = useState(null);
@@ -80,7 +291,6 @@ export default function TVChannelGuide({ startDate, endDate }) {
     if (!Object.keys(channels).length === 0) {
       console.warn('No channels provided or empty channels array');
       notifications.show({ title: 'No channels available', color: 'red.5' });
-      setLoading(false);
       return;
     }
 
@@ -97,10 +307,19 @@ export default function TVChannelGuide({ startDate, endDate }) {
 
       console.log(`Using all ${sortedChannels.length} available channels`);
 
+      const processedPrograms = fetched.map((program) => {
+        const start = dayjs(program.start_time);
+        const end = dayjs(program.end_time);
+        return {
+          ...program,
+          startMs: start.valueOf(),
+          endMs: end.valueOf(),
+        };
+      });
+
       setGuideChannels(sortedChannels);
       setFilteredChannels(sortedChannels); // Initialize filtered channels
-      setPrograms(fetched);
-      setLoading(false);
+      setPrograms(processedPrograms);
     };
 
     fetchPrograms();
@@ -180,38 +399,79 @@ export default function TVChannelGuide({ startDate, endDate }) {
     ? latestProgramEnd
     : defaultEnd;
 
-  // Time increments in 15-min steps (for placing programs)
-  const programTimeline = useMemo(() => {
-    const times = [];
-    let current = start;
-    while (current.isBefore(end)) {
-      times.push(current);
-      current = current.add(MINUTE_INCREMENT, 'minute');
-    }
-    return times;
-  }, [start, end]);
+  const channelIdByTvgId = useMemo(
+    () => buildChannelIdMap(guideChannels, tvgsById),
+    [guideChannels, tvgsById]
+  );
+
+  const channelById = useMemo(() => {
+    const map = new Map();
+    guideChannels.forEach((channel) => {
+      map.set(channel.id, channel);
+    });
+    return map;
+  }, [guideChannels]);
+
+  const programsByChannelId = useMemo(
+    () => mapProgramsByChannel(programs, channelIdByTvgId),
+    [programs, channelIdByTvgId]
+  );
+
+  const recordingsByProgramId = useMemo(() => {
+    const map = new Map();
+    (recordings || []).forEach((recording) => {
+      const programId = recording?.custom_properties?.program?.id;
+      if (programId != null) {
+        map.set(programId, recording);
+      }
+    });
+    return map;
+  }, [recordings]);
+
+  const rowHeights = useMemo(
+    () =>
+      computeRowHeights(
+        filteredChannels,
+        programsByChannelId,
+        expandedProgramId
+      ),
+    [filteredChannels, programsByChannelId, expandedProgramId]
+  );
+
+  const getItemSize = useCallback(
+    (index) => rowHeights[index] ?? PROGRAM_HEIGHT,
+    [rowHeights]
+  );
+
+  const [timeFormatSetting] = useLocalStorage('time-format', '12h');
+  const [dateFormatSetting] = useLocalStorage('date-format', 'mdy');
+  // Use user preference for time format
+  const timeFormat = timeFormatSetting === '12h' ? 'h:mm A' : 'HH:mm';
+  const dateFormat = dateFormatSetting === 'mdy' ? 'MMMM D' : 'D MMMM';
 
   // Format day label using relative terms when possible (Today, Tomorrow, etc)
-  const formatDayLabel = (time) => {
-    const today = dayjs().startOf('day');
-    const tomorrow = today.add(1, 'day');
-    const dayAfterTomorrow = today.add(2, 'day');
-    const weekLater = today.add(7, 'day');
+  const formatDayLabel = useCallback(
+    (time) => {
+      const today = dayjs().startOf('day');
+      const tomorrow = today.add(1, 'day');
+      const weekLater = today.add(7, 'day');
 
-    const day = time.startOf('day');
+      const day = time.startOf('day');
 
-    if (day.isSame(today, 'day')) {
-      return 'Today';
-    } else if (day.isSame(tomorrow, 'day')) {
-      return 'Tomorrow';
-    } else if (day.isBefore(weekLater)) {
-      // Within a week, show day name
-      return time.format('dddd');
-    } else {
-      // Beyond a week, show month and day
-      return time.format(dateFormat);
-    }
-  };
+      if (day.isSame(today, 'day')) {
+        return 'Today';
+      } else if (day.isSame(tomorrow, 'day')) {
+        return 'Tomorrow';
+      } else if (day.isBefore(weekLater)) {
+        // Within a week, show day name
+        return time.format('dddd');
+      } else {
+        // Beyond a week, show month and day
+        return time.format(dateFormat);
+      }
+    },
+    [dateFormat]
+  );
 
   // Hourly marks with day labels
   const hourTimeline = useMemo(() => {
@@ -238,34 +498,42 @@ export default function TVChannelGuide({ startDate, endDate }) {
       current = current.add(1, 'hour');
     }
     return hours;
-  }, [start, end]);
+  }, [start, end, formatDayLabel]);
 
-  // Scroll to the nearest half-hour mark ONLY on initial load
   useEffect(() => {
-    if (
-      guideRef.current &&
-      timelineRef.current &&
-      programs.length > 0 &&
-      !initialScrollComplete
-    ) {
-      // Round the current time to the nearest half-hour mark
-      const roundedNow =
-        now.minute() < 30
-          ? now.startOf('hour')
-          : now.startOf('hour').add(30, 'minute');
-      const nowOffset = roundedNow.diff(start, 'minute');
-      const scrollPosition =
-        (nowOffset / MINUTE_INCREMENT) * MINUTE_BLOCK_WIDTH -
-        MINUTE_BLOCK_WIDTH;
+    const node = guideRef.current;
+    if (!node) return undefined;
 
-      const scrollPos = Math.max(scrollPosition, 0);
-      guideRef.current.scrollLeft = scrollPos;
-      timelineRef.current.scrollLeft = scrollPos; // Sync timeline scroll
+    const handleScroll = () => {
+      const { scrollLeft } = node;
+      if (scrollLeft === guideScrollLeftRef.current) {
+        return;
+      }
 
-      // Mark initial scroll as complete
-      setInitialScrollComplete(true);
-    }
-  }, [programs, start, now, initialScrollComplete]);
+      guideScrollLeftRef.current = scrollLeft;
+      setGuideScrollLeft(scrollLeft);
+
+      if (isSyncingScroll.current) {
+        return;
+      }
+
+      if (
+        timelineRef.current &&
+        timelineRef.current.scrollLeft !== scrollLeft
+      ) {
+        isSyncingScroll.current = true;
+        timelineRef.current.scrollLeft = scrollLeft;
+        requestAnimationFrame(() => {
+          isSyncingScroll.current = false;
+        });
+      }
+    };
+
+    node.addEventListener('scroll', handleScroll, { passive: true });
+    return () => {
+      node.removeEventListener('scroll', handleScroll);
+    };
+  }, []);
 
   // Update “now” every second
   useEffect(() => {
@@ -282,179 +550,39 @@ export default function TVChannelGuide({ startDate, endDate }) {
     return (minutesSinceStart / MINUTE_INCREMENT) * MINUTE_BLOCK_WIDTH;
   }, [now, start, end]);
 
-  // Helper: find channel by tvg_id
-  function findChannelByTvgId(tvgId) {
-    return guideChannels.find(
-      (ch) =>
-        tvgsById[ch.epg_data_id]?.tvg_id === tvgId ||
-        (!ch.epg_data_id && ch.uuid === tvgId)
-    );
-  }
+  const syncScrollLeft = useCallback((nextLeft, behavior = 'auto') => {
+    const guideNode = guideRef.current;
+    const timelineNode = timelineRef.current;
 
-  const openRecordChoice = async (program) => {
-    setRecordChoiceProgram(program);
-    setRecordChoiceOpen(true);
-    try {
-      const rules = await API.listSeriesRules();
-      // Only treat as existing if the rule matches this specific show's title (or has no title constraint)
-      const rule = (rules || []).find(
-        (r) => String(r.tvg_id) === String(program.tvg_id) && (!r.title || r.title === program.title)
-      );
-      setExistingRuleMode(rule ? rule.mode : null);
-    } catch {}
-    // Also detect if this program already has a scheduled recording
-    try {
-      const rec = (recordings || []).find((r) => r?.custom_properties?.program?.id == program.id);
-      setRecordingForProgram(rec || null);
-    } catch {}
-  };
+    isSyncingScroll.current = true;
 
-  const recordOne = async (program) => {
-    const channel = findChannelByTvgId(program.tvg_id);
-    await API.createRecording({
-      channel: `${channel.id}`,
-      start_time: program.start_time,
-      end_time: program.end_time,
-      custom_properties: { program },
-    });
-    notifications.show({ title: 'Recording scheduled' });
-  };
-
-  const saveSeriesRule = async (program, mode) => {
-    await API.createSeriesRule({ tvg_id: program.tvg_id, mode, title: program.title });
-    await API.evaluateSeriesRules(program.tvg_id);
-    // Refresh recordings so icons and DVR reflect new schedules
-    try {
-      await useChannelsStore.getState().fetchRecordings();
-    } catch (e) {
-      console.warn('Failed to refresh recordings after saving series rule', e);
-    }
-    notifications.show({ title: mode === 'new' ? 'Record new episodes' : 'Record all episodes' });
-  };
-
-  const openRules = async () => {
-    setRulesOpen(true);
-    try {
-      const r = await API.listSeriesRules();
-      setRules(r);
-    } catch (e) {
-      // handled by API
-    }
-  };
-
-  const deleteAllUpcoming = async () => {
-    const ok = window.confirm('Delete ALL upcoming recordings?');
-    if (!ok) return;
-    await API.deleteAllUpcomingRecordings();
-    try { await useChannelsStore.getState().fetchRecordings(); } catch {}
-  };
-
-  // The “Watch Now” click => show floating video
-  const showVideo = useVideoStore((s) => s.showVideo);
-  function handleWatchStream(program) {
-    const matched = findChannelByTvgId(program.tvg_id);
-    if (!matched) {
-      console.warn(`No channel found for tvg_id=${program.tvg_id}`);
-      return;
-    }
-    // Build a playable stream URL for that channel
-    let vidUrl = `/proxy/ts/stream/${matched.uuid}`;
-    if (env_mode == 'dev') {
-      vidUrl = `${window.location.protocol}//${window.location.hostname}:5656${vidUrl}`;
-    }
-
-    showVideo(vidUrl);
-  }
-
-  // Function to handle logo click to play channel
-  function handleLogoClick(channel, event) {
-    // Prevent event from bubbling up
-    event.stopPropagation();
-
-    // Build a playable stream URL for the channel
-    let vidUrl = `/proxy/ts/stream/${channel.uuid}`;
-    if (env_mode === 'dev') {
-      vidUrl = `${window.location.protocol}//${window.location.hostname}:5656${vidUrl}`;
-    }
-
-    // Use the existing showVideo function
-    showVideo(vidUrl);
-  }
-
-  // On program click, toggle the expanded state
-  function handleProgramClick(program, event) {
-    // Prevent event from bubbling up to parent elements
-    event.stopPropagation();
-
-    // Get the program's start time and calculate its position
-    const programStart = dayjs(program.start_time);
-    const startOffsetMinutes = programStart.diff(start, 'minute');
-    const leftPx = (startOffsetMinutes / MINUTE_INCREMENT) * MINUTE_BLOCK_WIDTH;
-
-    // Calculate desired scroll position (account for channel column width)
-    const desiredScrollPosition = Math.max(0, leftPx - 20); // 20px buffer
-
-    // If already expanded, collapse it
-    if (expandedProgramId === program.id) {
-      setExpandedProgramId(null);
-      setRecordingForProgram(null);
-      return;
-    }
-
-    // Otherwise expand this program
-    setExpandedProgramId(program.id);
-
-    // Check if this program has a recording
-    const programRecording = recordings.find((recording) => {
-      if (recording.custom_properties) {
-        const customProps = recording.custom_properties || {};
-        if (customProps.program && customProps.program.id == program.id) {
-          return true;
-        }
-      }
-      return false;
-    });
-
-    setRecordingForProgram(programRecording);
-
-    // Scroll to show the start of the program if it's not already fully visible
-    if (guideRef.current && timelineRef.current) {
-      const currentScrollPosition = guideRef.current.scrollLeft;
-
-      // Check if we need to scroll (if program start is before current view or too close to edge)
-      if (
-        desiredScrollPosition < currentScrollPosition ||
-        leftPx - currentScrollPosition < 100
-      ) {
-        // 100px from left edge
-
-        // Smooth scroll to the program's start
-        guideRef.current.scrollTo({
-          left: desiredScrollPosition,
-          behavior: 'smooth',
-        });
-
-        // Also sync the timeline scroll
-        timelineRef.current.scrollTo({
-          left: desiredScrollPosition,
-          behavior: 'smooth',
-        });
+    if (guideNode) {
+      if (typeof guideNode.scrollTo === 'function') {
+        guideNode.scrollTo({ left: nextLeft, behavior });
+      } else {
+        guideNode.scrollLeft = nextLeft;
       }
     }
-  }
 
-  // Close the expanded program when clicking elsewhere
-  const handleClickOutside = () => {
-    if (expandedProgramId) {
-      setExpandedProgramId(null);
-      setRecordingForProgram(null);
+    if (timelineNode) {
+      if (typeof timelineNode.scrollTo === 'function') {
+        timelineNode.scrollTo({ left: nextLeft, behavior });
+      } else {
+        timelineNode.scrollLeft = nextLeft;
+      }
     }
-  };
 
-  // Function to scroll to current time - matches initial loading position
-  const scrollToNow = () => {
-    if (guideRef.current && timelineRef.current && nowPosition >= 0) {
-      // Round the current time to the nearest half-hour mark
+    guideScrollLeftRef.current = nextLeft;
+    setGuideScrollLeft(nextLeft);
+
+    requestAnimationFrame(() => {
+      isSyncingScroll.current = false;
+    });
+  }, []);
+
+  // Scroll to the nearest half-hour mark ONLY on initial load
+  useEffect(() => {
+    if (programs.length > 0 && !initialScrollComplete) {
       const roundedNow =
         now.minute() < 30
           ? now.startOf('hour')
@@ -465,61 +593,236 @@ export default function TVChannelGuide({ startDate, endDate }) {
         MINUTE_BLOCK_WIDTH;
 
       const scrollPos = Math.max(scrollPosition, 0);
-      guideRef.current.scrollLeft = scrollPos;
-      timelineRef.current.scrollLeft = scrollPos; // Sync timeline scroll
+      syncScrollLeft(scrollPos);
+
+      setInitialScrollComplete(true);
+    }
+  }, [programs, start, now, initialScrollComplete, syncScrollLeft]);
+
+  const findChannelByTvgId = useCallback(
+    (tvgId) => {
+      const channelIds = channelIdByTvgId.get(String(tvgId));
+      if (!channelIds || channelIds.length === 0) {
+        return null;
+      }
+      // Return the first channel that matches this TVG ID
+      return channelById.get(channelIds[0]) || null;
+    },
+    [channelById, channelIdByTvgId]
+  );
+
+  const openRecordChoice = useCallback(
+    async (program) => {
+      setRecordChoiceProgram(program);
+      setRecordChoiceOpen(true);
+      try {
+        const rules = await API.listSeriesRules();
+        const rule = (rules || []).find(
+          (r) =>
+            String(r.tvg_id) === String(program.tvg_id) &&
+            (!r.title || r.title === program.title)
+        );
+        setExistingRuleMode(rule ? rule.mode : null);
+      } catch (error) {
+        console.warn('Failed to fetch series rules metadata', error);
+      }
+
+      const existingRecording = recordingsByProgramId.get(program.id) || null;
+      setRecordingForProgram(existingRecording);
+    },
+    [recordingsByProgramId]
+  );
+
+  const recordOne = useCallback(
+    async (program) => {
+      const channel = findChannelByTvgId(program.tvg_id);
+      if (!channel) {
+        notifications.show({
+          title: 'Unable to schedule recording',
+          message: 'No channel found for this program.',
+          color: 'red.6',
+        });
+        return;
+      }
+
+      await API.createRecording({
+        channel: `${channel.id}`,
+        start_time: program.start_time,
+        end_time: program.end_time,
+        custom_properties: { program },
+      });
+      notifications.show({ title: 'Recording scheduled' });
+    },
+    [findChannelByTvgId]
+  );
+
+  const saveSeriesRule = useCallback(async (program, mode) => {
+    await API.createSeriesRule({
+      tvg_id: program.tvg_id,
+      mode,
+      title: program.title,
+    });
+    await API.evaluateSeriesRules(program.tvg_id);
+    try {
+      await useChannelsStore.getState().fetchRecordings();
+    } catch (error) {
+      console.warn(
+        'Failed to refresh recordings after saving series rule',
+        error
+      );
+    }
+    notifications.show({
+      title: mode === 'new' ? 'Record new episodes' : 'Record all episodes',
+    });
+  }, []);
+
+  const openRules = useCallback(async () => {
+    setRulesOpen(true);
+    try {
+      const r = await API.listSeriesRules();
+      setRules(r);
+    } catch (error) {
+      console.warn('Failed to load series rules', error);
+    }
+  }, []);
+
+  // The “Watch Now” click => show floating video
+  const showVideo = useVideoStore((s) => s.showVideo);
+  const handleWatchStream = useCallback(
+    (program) => {
+      const matched = findChannelByTvgId(program.tvg_id);
+      if (!matched) {
+        console.warn(`No channel found for tvg_id=${program.tvg_id}`);
+        return;
+      }
+
+      let vidUrl = `/proxy/ts/stream/${matched.uuid}`;
+      if (env_mode === 'dev') {
+        vidUrl = `${window.location.protocol}//${window.location.hostname}:5656${vidUrl}`;
+      }
+
+      showVideo(vidUrl);
+    },
+    [env_mode, findChannelByTvgId, showVideo]
+  );
+
+  const handleLogoClick = useCallback(
+    (channel, event) => {
+      event.stopPropagation();
+
+      let vidUrl = `/proxy/ts/stream/${channel.uuid}`;
+      if (env_mode === 'dev') {
+        vidUrl = `${window.location.protocol}//${window.location.hostname}:5656${vidUrl}`;
+      }
+
+      showVideo(vidUrl);
+    },
+    [env_mode, showVideo]
+  );
+
+  const handleProgramClick = useCallback(
+    (program, event) => {
+      event.stopPropagation();
+
+      const programStartMs =
+        program.startMs ?? dayjs(program.start_time).valueOf();
+      const startOffsetMinutes = (programStartMs - start.valueOf()) / 60000;
+      const leftPx =
+        (startOffsetMinutes / MINUTE_INCREMENT) * MINUTE_BLOCK_WIDTH;
+      const desiredScrollPosition = Math.max(0, leftPx - 20);
+
+      if (expandedProgramId === program.id) {
+        setExpandedProgramId(null);
+        setRecordingForProgram(null);
+      } else {
+        setExpandedProgramId(program.id);
+        setRecordingForProgram(recordingsByProgramId.get(program.id) || null);
+      }
+
+      const guideNode = guideRef.current;
+      if (guideNode) {
+        const currentScrollPosition = guideNode.scrollLeft;
+        if (
+          desiredScrollPosition < currentScrollPosition ||
+          leftPx - currentScrollPosition < 100
+        ) {
+          syncScrollLeft(desiredScrollPosition, 'smooth');
+        }
+      }
+    },
+    [expandedProgramId, recordingsByProgramId, start, syncScrollLeft]
+  );
+
+  // Close the expanded program when clicking elsewhere
+  const handleClickOutside = () => {
+    if (expandedProgramId) {
+      setExpandedProgramId(null);
+      setRecordingForProgram(null);
     }
   };
 
-  // Sync scrolling between timeline and main content
-  const handleTimelineScroll = () => {
-    if (timelineRef.current && guideRef.current) {
-      guideRef.current.scrollLeft = timelineRef.current.scrollLeft;
+  const scrollToNow = useCallback(() => {
+    if (nowPosition < 0) {
+      return;
     }
-  };
 
-  // Sync scrolling between main content and timeline
-  const handleGuideScroll = () => {
-    if (guideRef.current && timelineRef.current) {
-      timelineRef.current.scrollLeft = guideRef.current.scrollLeft;
+    const roundedNow =
+      now.minute() < 30
+        ? now.startOf('hour')
+        : now.startOf('hour').add(30, 'minute');
+    const nowOffset = roundedNow.diff(start, 'minute');
+    const scrollPosition =
+      (nowOffset / MINUTE_INCREMENT) * MINUTE_BLOCK_WIDTH - MINUTE_BLOCK_WIDTH;
+
+    const scrollPos = Math.max(scrollPosition, 0);
+    syncScrollLeft(scrollPos, 'smooth');
+  }, [now, nowPosition, start, syncScrollLeft]);
+
+  const handleTimelineScroll = useCallback(() => {
+    if (!timelineRef.current) {
+      return;
     }
-  };
 
-  // Handle wheel events on the timeline for horizontal scrolling
-  const handleTimelineWheel = (e) => {
-    if (timelineRef.current) {
-      // Prevent the default vertical scroll
-      e.preventDefault();
+    const nextLeft = timelineRef.current.scrollLeft;
+    guideScrollLeftRef.current = nextLeft;
+    setGuideScrollLeft(nextLeft);
 
-      // Determine scroll amount (with shift key for faster scrolling)
-      const scrollAmount = e.shiftKey ? 250 : 125;
+    if (isSyncingScroll.current) {
+      return;
+    }
 
-      // Scroll horizontally based on wheel direction
-      timelineRef.current.scrollLeft +=
-        e.deltaY > 0 ? scrollAmount : -scrollAmount;
-
-      // Sync the main content scroll position
-      if (guideRef.current) {
-        guideRef.current.scrollLeft = timelineRef.current.scrollLeft;
+    isSyncingScroll.current = true;
+    if (guideRef.current) {
+      if (typeof guideRef.current.scrollTo === 'function') {
+        guideRef.current.scrollTo({ left: nextLeft });
+      } else {
+        guideRef.current.scrollLeft = nextLeft;
       }
     }
-  };
 
-  // Function to handle timeline time clicks with 15-minute snapping
-  const handleTimeClick = (clickedTime, event) => {
-    if (timelineRef.current && guideRef.current) {
-      // Calculate where in the hour block the click happened
-      const hourBlockElement = event.currentTarget;
-      const rect = hourBlockElement.getBoundingClientRect();
-      const clickPositionX = event.clientX - rect.left; // Position within the hour block
-      const percentageAcross = clickPositionX / rect.width; // 0 to 1 value
+    requestAnimationFrame(() => {
+      isSyncingScroll.current = false;
+    });
+  }, []);
 
-      // Calculate the minute within the hour based on click position
+  const handleTimelineWheel = useCallback((event) => {
+    if (!timelineRef.current) {
+      return;
+    }
+
+    event.preventDefault();
+    const scrollAmount = event.shiftKey ? 250 : 125;
+    const delta = event.deltaY > 0 ? scrollAmount : -scrollAmount;
+    timelineRef.current.scrollBy({ left: delta, behavior: 'smooth' });
+  }, []);
+
+  const handleTimeClick = useCallback(
+    (clickedTime, event) => {
+      const rect = event.currentTarget.getBoundingClientRect();
+      const clickPositionX = event.clientX - rect.left;
+      const percentageAcross = clickPositionX / rect.width;
       const minuteWithinHour = Math.floor(percentageAcross * 60);
 
-      // Create a new time object with the calculated minute
-      const exactTime = clickedTime.minute(minuteWithinHour);
-
-      // Determine the nearest 15-minute interval (0, 15, 30, 45)
       let snappedMinute;
       if (minuteWithinHour < 7.5) {
         snappedMinute = 0;
@@ -530,176 +833,106 @@ export default function TVChannelGuide({ startDate, endDate }) {
       } else if (minuteWithinHour < 52.5) {
         snappedMinute = 45;
       } else {
-        // If we're past 52.5 minutes, snap to the next hour
         snappedMinute = 0;
         clickedTime = clickedTime.add(1, 'hour');
       }
 
-      // Create the snapped time
       const snappedTime = clickedTime.minute(snappedMinute);
-
-      // Calculate the offset from the start of the timeline to the snapped time
       const snappedOffset = snappedTime.diff(start, 'minute');
-
-      // Convert to pixels
       const scrollPosition =
         (snappedOffset / MINUTE_INCREMENT) * MINUTE_BLOCK_WIDTH;
 
-      // Scroll both containers to the snapped position
-      timelineRef.current.scrollLeft = scrollPosition;
-      guideRef.current.scrollLeft = scrollPosition;
-    }
-  };
-  // Renders each program block
-  function renderProgram(program, channelStart) {
-    const programKey = `${program.tvg_id}-${program.start_time}`;
-    const programStart = dayjs(program.start_time);
-    const programEnd = dayjs(program.end_time);
-    const startOffsetMinutes = programStart.diff(channelStart, 'minute');
-    const durationMinutes = programEnd.diff(programStart, 'minute');
-    const leftPx = (startOffsetMinutes / MINUTE_INCREMENT) * MINUTE_BLOCK_WIDTH;
+      syncScrollLeft(scrollPosition, 'smooth');
+    },
+    [start, syncScrollLeft]
+  );
+  const renderProgram = useCallback(
+    (program, channelStart = start, channel = null) => {
+      const programStartMs =
+        program.startMs ?? dayjs(program.start_time).valueOf();
+      const programEndMs = program.endMs ?? dayjs(program.end_time).valueOf();
+      const programStart = dayjs(programStartMs);
+      const programEnd = dayjs(programEndMs);
 
-    // Calculate width with a small gap (2px on each side)
-    const gapSize = 2;
-    const widthPx =
-      (durationMinutes / MINUTE_INCREMENT) * MINUTE_BLOCK_WIDTH - gapSize * 2;
+      const startOffsetMinutes =
+        (programStartMs - channelStart.valueOf()) / 60000;
+      const durationMinutes = (programEndMs - programStartMs) / 60000;
+      const leftPx =
+        (startOffsetMinutes / MINUTE_INCREMENT) * MINUTE_BLOCK_WIDTH;
 
-    // Check if we have a recording for this program
-    const recording = recordings.find((recording) => {
-      if (recording.custom_properties) {
-        const customProps = recording.custom_properties || {};
-        if (customProps.program && customProps.program.id == program.id) {
-          return recording;
-        }
+      const gapSize = 2;
+      const widthPx =
+        (durationMinutes / MINUTE_INCREMENT) * MINUTE_BLOCK_WIDTH - gapSize * 2;
+
+      const recording = recordingsByProgramId.get(program.id);
+
+      const isLive = now.isAfter(programStart) && now.isBefore(programEnd);
+      const isPast = now.isAfter(programEnd);
+      const isExpanded = expandedProgramId === program.id;
+
+      const rowHeight = isExpanded ? EXPANDED_PROGRAM_HEIGHT : PROGRAM_HEIGHT;
+      const MIN_EXPANDED_WIDTH = 450;
+      const expandedWidthPx = Math.max(widthPx, MIN_EXPANDED_WIDTH);
+
+      const programStartInView = leftPx + gapSize;
+      const programEndInView = leftPx + gapSize + widthPx;
+      const viewportLeft = guideScrollLeft;
+      const startsBeforeView = programStartInView < viewportLeft;
+      const extendsIntoView = programEndInView > viewportLeft;
+
+      let textOffsetLeft = 0;
+      if (startsBeforeView && extendsIntoView) {
+        const visibleStart = Math.max(viewportLeft - programStartInView, 0);
+        const maxOffset = widthPx - 200;
+        textOffsetLeft = Math.min(visibleStart, maxOffset);
       }
-      return null;
-    });
 
-    // Highlight if currently live
-    const isLive = now.isAfter(programStart) && now.isBefore(programEnd);
-
-    // Determine if the program has ended
-    const isPast = now.isAfter(programEnd); // Check if this program is expanded
-    const isExpanded = expandedProgramId === program.id;
-
-    // Set the height based on expanded state
-    const rowHeight = isExpanded ? EXPANDED_PROGRAM_HEIGHT : PROGRAM_HEIGHT;
-
-    // Determine expanded width - if program is short, ensure it has a minimum expanded width
-    // This will allow it to overlap programs to the right
-    const MIN_EXPANDED_WIDTH = 450; // Minimum width in pixels when expanded
-    const expandedWidthPx = Math.max(widthPx, MIN_EXPANDED_WIDTH);
-
-    // Calculate text positioning for long programs that start before the visible area
-    const currentScrollLeft = guideRef.current?.scrollLeft || 0;
-    const programStartInView = leftPx + gapSize;
-    const programEndInView = leftPx + gapSize + widthPx;
-    const viewportLeft = currentScrollLeft;
-
-    // Check if program starts before viewport but extends into it
-    const startsBeforeView = programStartInView < viewportLeft;
-    const extendsIntoView = programEndInView > viewportLeft;
-
-    // Calculate text offset to position it at the visible portion
-    let textOffsetLeft = 0;
-    if (startsBeforeView && extendsIntoView) {
-      // Position text at the start of the visible area, but not beyond the program end
-      const visibleStart = Math.max(viewportLeft - programStartInView, 0);
-      const maxOffset = widthPx - 200; // Leave some space for text, don't push to very end
-      textOffsetLeft = Math.min(visibleStart, maxOffset);
-    }
-
-    return (
-      <Box
-        className="guide-program-container"
-        key={programKey}
-        style={{
-          position: 'absolute',
-          left: leftPx + gapSize, // Add gap to left position
-          top: 0,
-          width: isExpanded ? expandedWidthPx : widthPx, // Width already has gap factored in
-          height: rowHeight - 4, // Adjust for the parent row padding
-          cursor: 'pointer',
-          zIndex: isExpanded ? 25 : 5, // Increase z-index when expanded
-          transition: isExpanded
-            ? 'height 0.2s ease, width 0.2s ease'
-            : 'height 0.2s ease',
-        }}
-        onClick={(e) => handleProgramClick(program, e)}
-      >
-        <Paper
-          elevation={isExpanded ? 4 : 2}
-          className={`guide-program ${isLive ? 'live' : isPast ? 'past' : 'not-live'} ${isExpanded ? 'expanded' : ''}`}
+      return (
+        <Box
+          className="guide-program-container"
+          key={`${channel?.id || 'unknown'}-${program.id || `${program.tvg_id}-${program.start_time}`}`}
           style={{
-            width: '100%', // Fill container width (which may be expanded)
-            height: '100%',
-            overflow: 'hidden',
-            position: 'relative',
-            display: 'flex',
-            flexDirection: 'column',
-            justifyContent: isExpanded ? 'flex-start' : 'space-between',
-            padding: isExpanded ? '12px' : '8px',
-            backgroundColor: isExpanded
-              ? isLive
-                ? '#1a365d' // Darker blue when expanded and live
-                : isPast
-                  ? '#18181B' // Darker gray when expanded and past
-                  : '#1e40af' // Darker blue when expanded and upcoming
-              : isLive
-                ? '#18181B' // Default live program color
-                : isPast
-                  ? '#27272A' // Slightly darker color for past programs
-                  : '#2c5282', // Default color for upcoming programs
-            color: isPast ? '#a0aec0' : '#fff', // Dim text color for past programs
-            boxShadow: isExpanded ? '0 4px 8px rgba(0,0,0,0.4)' : 'none',
-            transition: 'all 0.2s ease',
+            position: 'absolute',
+            left: leftPx + gapSize,
+            top: 0,
+            width: isExpanded ? expandedWidthPx : widthPx,
+            height: rowHeight - 4,
+            cursor: 'pointer',
+            zIndex: isExpanded ? 25 : 5,
+            transition: isExpanded
+              ? 'height 0.2s ease, width 0.2s ease'
+              : 'height 0.2s ease',
           }}
+          onClick={(event) => handleProgramClick(program, event)}
         >
-          <Box
+          <Paper
+            elevation={isExpanded ? 4 : 2}
+            className={`guide-program ${isLive ? 'live' : isPast ? 'past' : 'not-live'} ${isExpanded ? 'expanded' : ''}`}
             style={{
-              transform: `translateX(${textOffsetLeft}px)`,
-              transition: 'transform 0.1s ease-out',
+              width: '100%',
+              height: '100%',
+              overflow: 'hidden',
+              position: 'relative',
+              display: 'flex',
+              flexDirection: 'column',
+              justifyContent: isExpanded ? 'flex-start' : 'space-between',
+              padding: isExpanded ? '12px' : '8px',
+              backgroundColor: isExpanded
+                ? isLive
+                  ? '#1a365d'
+                  : isPast
+                    ? '#18181B'
+                    : '#1e40af'
+                : isLive
+                  ? '#18181B'
+                  : isPast
+                    ? '#27272A'
+                    : '#2c5282',
+              color: isPast ? '#a0aec0' : '#fff',
+              boxShadow: isExpanded ? '0 4px 8px rgba(0,0,0,0.4)' : 'none',
+              transition: 'all 0.2s ease',
             }}
           >
-            <Text
-              component="div"
-              size={isExpanded ? 'lg' : 'md'}
-              style={{
-                fontWeight: 'bold',
-                whiteSpace: 'nowrap',
-                textOverflow: 'ellipsis',
-                overflow: 'hidden',
-              }}
-            >
-              <Group gap="xs">
-                {recording && (
-                  <div
-                    style={{
-                      borderRadius: '50%',
-                      width: '10px',
-                      height: '10px',
-                      display: 'flex',
-                      backgroundColor: 'red',
-                    }}
-                  ></div>
-                )}
-                {program.title}
-              </Group>
-            </Text>
-            <Text
-              size="sm"
-              style={{
-                whiteSpace: 'nowrap',
-                textOverflow: 'ellipsis',
-                overflow: 'hidden',
-              }}
-            >
-              {programStart.format(timeFormat)} -{' '}
-              {programEnd.format(timeFormat)}
-            </Text>
-          </Box>{' '}
-          {/* Description is always shown but expands when row is expanded */}
-          {program.description && (
             <Box
               style={{
                 transform: `translateX(${textOffsetLeft}px)`,
@@ -707,61 +940,178 @@ export default function TVChannelGuide({ startDate, endDate }) {
               }}
             >
               <Text
-                size="xs"
+                component="div"
+                size={isExpanded ? 'lg' : 'md'}
                 style={{
-                  marginTop: '4px',
-                  whiteSpace: isExpanded ? 'normal' : 'nowrap',
-                  textOverflow: isExpanded ? 'clip' : 'ellipsis',
-                  overflow: isExpanded ? 'auto' : 'hidden',
-                  color: isPast ? '#718096' : '#cbd5e0',
-                  maxHeight: isExpanded ? '80px' : 'unset',
+                  fontWeight: 'bold',
+                  whiteSpace: 'nowrap',
+                  textOverflow: 'ellipsis',
+                  overflow: 'hidden',
                 }}
               >
-                {program.description}
+                <Group gap="xs">
+                  {recording && (
+                    <div
+                      style={{
+                        borderRadius: '50%',
+                        width: '10px',
+                        height: '10px',
+                        display: 'flex',
+                        backgroundColor: 'red',
+                      }}
+                    ></div>
+                  )}
+                  {program.title}
+                </Group>
+              </Text>
+              <Text
+                size="sm"
+                style={{
+                  whiteSpace: 'nowrap',
+                  textOverflow: 'ellipsis',
+                  overflow: 'hidden',
+                }}
+              >
+                {programStart.format(timeFormat)} -{' '}
+                {programEnd.format(timeFormat)}
               </Text>
             </Box>
-          )}
-          {/* Expanded content */}
-          {isExpanded && (
-            <Box style={{ marginTop: 'auto' }}>
-              <Flex gap="md" justify="flex-end" mt={8}>
-                {/* Always show Record for not-past; it opens options (schedule/remove) */}
-                {!isPast && (
-                  <Button
-                    leftSection={<Calendar size={14} />}
-                    variant="filled"
-                    color="red"
-                    size="xs"
-                    onClick={(e) => {
-                      e.stopPropagation();
-                      openRecordChoice(program);
-                    }}
-                  >
-                    Record
-                  </Button>
-                )}
 
-                {isLive && (
-                  <Button
-                    leftSection={<Video size={14} />}
-                    variant="filled"
-                    color="blue"
-                    size="xs"
-                    onClick={(e) => {
-                      e.stopPropagation();
-                      handleWatchStream(program);
-                    }}
-                  >
-                    Watch Now
-                  </Button>
-                )}
-              </Flex>
-            </Box>
-          )}
-        </Paper>
-      </Box>
-    );
-  }
+            {program.description && (
+              <Box
+                style={{
+                  transform: `translateX(${textOffsetLeft}px)`,
+                  transition: 'transform 0.1s ease-out',
+                }}
+              >
+                <Text
+                  size="xs"
+                  style={{
+                    marginTop: '4px',
+                    whiteSpace: isExpanded ? 'normal' : 'nowrap',
+                    textOverflow: isExpanded ? 'clip' : 'ellipsis',
+                    overflow: isExpanded ? 'auto' : 'hidden',
+                    color: isPast ? '#718096' : '#cbd5e0',
+                    maxHeight: isExpanded ? '80px' : 'unset',
+                  }}
+                >
+                  {program.description}
+                </Text>
+              </Box>
+            )}
+
+            {isExpanded && (
+              <Box style={{ marginTop: 'auto' }}>
+                <Flex gap="md" justify="flex-end" mt={8}>
+                  {!isPast && (
+                    <Button
+                      leftSection={<Calendar size={14} />}
+                      variant="filled"
+                      color="red"
+                      size="xs"
+                      onClick={(event) => {
+                        event.stopPropagation();
+                        openRecordChoice(program);
+                      }}
+                    >
+                      Record
+                    </Button>
+                  )}
+
+                  {isLive && (
+                    <Button
+                      leftSection={<Video size={14} />}
+                      variant="filled"
+                      color="blue"
+                      size="xs"
+                      onClick={(event) => {
+                        event.stopPropagation();
+                        handleWatchStream(program);
+                      }}
+                    >
+                      Watch Now
+                    </Button>
+                  )}
+                </Flex>
+              </Box>
+            )}
+          </Paper>
+        </Box>
+      );
+    },
+    [
+      expandedProgramId,
+      guideScrollLeft,
+      handleProgramClick,
+      handleWatchStream,
+      now,
+      openRecordChoice,
+      recordingsByProgramId,
+      start,
+      timeFormat,
+    ]
+  );
+
+  const contentWidth = useMemo(
+    () => hourTimeline.length * HOUR_WIDTH + CHANNEL_WIDTH,
+    [hourTimeline]
+  );
+
+  const virtualizedHeight = useMemo(() => guideHeight || 600, [guideHeight]);
+
+  const virtualizedWidth = useMemo(() => {
+    if (guideWidth) {
+      return guideWidth;
+    }
+    if (typeof window !== 'undefined') {
+      return Math.min(window.innerWidth, contentWidth);
+    }
+    return contentWidth;
+  }, [guideWidth, contentWidth]);
+
+  const itemKey = useCallback(
+    (index) => filteredChannels[index]?.id ?? index,
+    [filteredChannels]
+  );
+
+  const listData = useMemo(
+    () => ({
+      filteredChannels,
+      programsByChannelId,
+      expandedProgramId,
+      rowHeights,
+      logos,
+      hoveredChannelId,
+      setHoveredChannelId,
+      renderProgram,
+      handleLogoClick,
+      contentWidth,
+    }),
+    [
+      filteredChannels,
+      programsByChannelId,
+      expandedProgramId,
+      rowHeights,
+      logos,
+      hoveredChannelId,
+      renderProgram,
+      handleLogoClick,
+      contentWidth,
+      setHoveredChannelId,
+    ]
+  );
+
+  useEffect(() => {
+    if (listRef.current) {
+      listRef.current.resetAfterIndex(0, true);
+    }
+  }, [rowHeights]);
+
+  useEffect(() => {
+    if (listRef.current) {
+      listRef.current.scrollToItem(0);
+    }
+  }, [searchQuery, selectedGroupId, selectedProfileId]);
 
   // Create group options for dropdown - but only include groups used by guide channels
   const groupOptions = useMemo(() => {
@@ -825,12 +1175,6 @@ export default function TVChannelGuide({ startDate, endDate }) {
     setSelectedProfileId(value || 'all');
   };
 
-  // Handle date-time formats
-  const [timeFormatSetting] = useLocalStorage('time-format', '12h');
-  const [dateFormatSetting] = useLocalStorage('date-format', 'mdy');
-  const timeFormat = timeFormatSetting === '12h' ? 'h:mm A' : 'HH:mm';
-  const dateFormat = dateFormatSetting === 'mdy' ? 'MMMM D' : 'D MMMM';
-
   return (
     <Box
       className="tv-guide"
@@ -1108,263 +1452,59 @@ export default function TVChannelGuide({ startDate, endDate }) {
 
         {/* Main scrollable container for program content */}
         <Box
-          ref={guideRef}
+          ref={guideContainerRef}
           style={{
             flex: 1,
-            overflowY: 'auto',
-            overflowX: 'hidden',
             position: 'relative',
+            overflow: 'hidden',
           }}
-          onScroll={handleGuideScroll}
         >
-          {/* Content wrapper with min-width to ensure scroll range */}
-          <Box
-            style={{
-              width: hourTimeline.length * HOUR_WIDTH + CHANNEL_WIDTH,
-              position: 'relative',
-              display: 'flex',
-              flexDirection: 'column',
-            }}
-          >
-            {/* Now line - positioned absolutely within content */}
-            {nowPosition >= 0 && (
-              <Box
-                style={{
-                  position: 'absolute',
-                  left: nowPosition + CHANNEL_WIDTH,
-                  top: 0,
-                  height: '100%',
-                  width: '2px',
-                  backgroundColor: '#38b2ac',
-                  zIndex: 15,
-                  pointerEvents: 'none', // Allow clicking through the line
-                }}
-              />
-            )}
+          {nowPosition >= 0 && (
+            <Box
+              style={{
+                position: 'absolute',
+                left: nowPosition + CHANNEL_WIDTH - guideScrollLeft,
+                top: 0,
+                bottom: 0,
+                width: '2px',
+                backgroundColor: '#38b2ac',
+                zIndex: 15,
+                pointerEvents: 'none',
+              }}
+            />
+          )}
 
-            {/* Channel rows with logos and programs */}
-            {filteredChannels.length > 0 ? (
-              filteredChannels.map((channel) => {
-                const channelPrograms = programs.filter(
-                  (p) =>
-                    (channel.epg_data_id &&
-                      p.tvg_id === tvgsById[channel.epg_data_id].tvg_id) ||
-                    (!channel.epg_data_id && p.tvg_id === channel.uuid)
-                );
-                // Check if any program in this channel is expanded
-                const hasExpandedProgram = channelPrograms.some(
-                  (prog) => prog.id === expandedProgramId
-                );
-                const rowHeight = hasExpandedProgram
-                  ? EXPANDED_PROGRAM_HEIGHT
-                  : PROGRAM_HEIGHT;
-
-                return (
-                  <Box
-                    key={channel.id}
-                    style={{
-                      display: 'flex',
-                      height: rowHeight,
-                      borderBottom: '0px solid #27272A', // Increased border width for better visibility
-                      transition: 'height 0.2s ease',
-                      position: 'relative', // Added for proper stacking
-                      overflow: 'visible', // Changed from 'hidden' to 'visible' to allow expanded programs to overflow
-                    }}
-                  >
-                    {/* Channel logo - sticky horizontally */}
-                    <Box
-                      className="channel-logo"
-                      style={{
-                        width: CHANNEL_WIDTH,
-                        minWidth: CHANNEL_WIDTH,
-                        flexShrink: 0,
-                        display: 'flex',
-                        alignItems: 'center',
-                        justifyContent: 'center',
-                        backgroundColor: '#18181B',
-                        borderRight: '1px solid #27272A', // Increased border width for visibility
-                        borderBottom: '1px solid #27272A', // Match the row border
-                        boxShadow: '2px 0 5px rgba(0,0,0,0.2)', // Added shadow for depth
-                        //position: 'sticky',
-                        left: 0,
-                        zIndex: 30, // Higher than expanded programs to prevent overlap
-                        height: rowHeight,
-                        transition: 'height 0.2s ease',
-                        cursor: 'pointer', // Add cursor pointer to indicate clickable
-                        position: 'relative', // Remove duplicate, keep only this one
-                      }}
-                      onClick={(e) => handleLogoClick(channel, e)}
-                      onMouseEnter={() => setHoveredChannelId(channel.id)}
-                      onMouseLeave={() => setHoveredChannelId(null)}
-                    >
-                      {/* Play icon overlay - visible on hover (moved outside to cover entire box) */}
-                      {hoveredChannelId === channel.id && (
-                        <Flex
-                          align="center"
-                          justify="center"
-                          style={{
-                            position: 'absolute',
-                            top: 0,
-                            left: 0,
-                            right: 0,
-                            bottom: 0,
-                            width: '100%',
-                            height: '100%',
-                            backgroundColor: 'rgba(0, 0, 0, 0.7)',
-                            zIndex: 10,
-                            animation: 'fadeIn 0.2s',
-                          }}
-                        >
-                          <Play size={32} color="#fff" fill="#fff" />{' '}
-                          {/* Changed from Video to Play and increased size */}
-                        </Flex>
-                      )}
-
-                      {/* Logo content - restructured for better positioning */}
-                      <Flex
-                        direction="column"
-                        align="center"
-                        justify="space-between"
-                        style={{
-                          width: '100%',
-                          height: '100%',
-                          padding: '4px',
-                          boxSizing: 'border-box',
-                          zIndex: 5,
-                          position: 'relative', // Add this for absolute positioning
-                        }}
-                      >
-                        {/* Logo container with padding */}
-                        <Box
-                          style={{
-                            width: '100%',
-                            height: `${rowHeight - 32}px`, // Height minus channel number height
-                            display: 'flex',
-                            alignItems: 'center',
-                            justifyContent: 'center',
-                            overflow: 'hidden',
-                            padding: '4px',
-                            marginBottom: '4px',
-                          }}
-                        >
-                          <img
-                            src={logos[channel.logo_id]?.cache_url || logo}
-                            alt={channel.name}
-                            style={{
-                              maxWidth: '100%',
-                              maxHeight: '100%',
-                              objectFit: 'contain',
-                            }}
-                          />
-                        </Box>
-
-                        {/* Channel number - fixed position at bottom with consistent height */}
-                        <Text
-                          size="sm"
-                          weight={600}
-                          style={{
-                            position: 'absolute',
-                            bottom: '4px',
-                            left: '50%',
-                            transform: 'translateX(-50%)',
-                            backgroundColor: '#18181B',
-                            padding: '2px 8px',
-                            borderRadius: 4,
-                            fontSize: '0.85em',
-                            border: '1px solid #27272A',
-                            height: '24px',
-                            display: 'flex',
-                            alignItems: 'center',
-                            justifyContent: 'center',
-                            minWidth: '36px',
-                          }}
-                        >
-                          {channel.channel_number || '-'}
-                        </Text>
-                      </Flex>
-                    </Box>
-
-                    {/* Programs for this channel */}
-                    <Box
-                      style={{
-                        flex: 1,
-                        position: 'relative',
-                        height: rowHeight,
-                        transition: 'height 0.2s ease',
-                        paddingLeft: 0, // Remove any padding that might push content
-                      }}
-                    >
-                      {channelPrograms.length > 0 ? (
-                        channelPrograms.map((program) => (
-                          <div
-                            key={`${channel.id}-${program.id}-${program.start_time}`}
-                          >
-                            {renderProgram(program, start)}
-                          </div>
-                        ))
-                      ) : (
-                        // Simple placeholder for channels with no program data - 2 hour blocks
-                        <>
-                          {/* Generate repeating placeholder blocks every 2 hours across the timeline */}
-                          {Array.from({
-                            length: Math.ceil(hourTimeline.length / 2),
-                          }).map((_, index) => (
-                            <Box
-                              key={`placeholder-${channel.id}-${index}`}
-                              style={{
-                                position: 'absolute',
-                                left: index * 2 * HOUR_WIDTH + 2,
-                                top: 0,
-                                width: 2 * HOUR_WIDTH - 4,
-                                height: rowHeight - 4,
-                                display: 'flex',
-                                alignItems: 'center',
-                                justifyContent: 'center',
-                              }}
-                            >
-                              <Paper
-                                style={{
-                                  width: '100%',
-                                  height: '100%',
-                                  display: 'flex',
-                                  alignItems: 'center',
-                                  justifyContent: 'center',
-                                  backgroundColor: '#2D3748',
-                                  color: '#A0AEC0',
-                                  opacity: 0.8,
-                                  border: '1px dashed #718096',
-                                }}
-                              >
-                                <Text size="sm" align="center">
-                                  No Program Information Available
-                                </Text>
-                              </Paper>
-                            </Box>
-                          ))}
-                        </>
-                      )}
-                    </Box>
-                  </Box>
-                );
-              })
-            ) : (
-              <Box
-                style={{
-                  padding: '30px',
-                  textAlign: 'center',
-                  color: '#a0aec0',
-                }}
-              >
-                <Text size="lg">No channels match your filters</Text>
-                <Button variant="subtle" onClick={clearFilters} mt={10}>
-                  Clear Filters
-                </Button>
-              </Box>
-            )}
-          </Box>
+          {filteredChannels.length > 0 ? (
+            <VariableSizeList
+              height={virtualizedHeight}
+              width={virtualizedWidth}
+              itemCount={filteredChannels.length}
+              itemSize={getItemSize}
+              estimatedItemSize={PROGRAM_HEIGHT}
+              itemKey={itemKey}
+              itemData={listData}
+              ref={listRef}
+              outerRef={guideRef}
+              overscanCount={8}
+            >
+              {GuideRow}
+            </VariableSizeList>
+          ) : (
+            <Box
+              style={{
+                padding: '30px',
+                textAlign: 'center',
+                color: '#a0aec0',
+              }}
+            >
+              <Text size="lg">No channels match your filters</Text>
+              <Button variant="subtle" onClick={clearFilters} mt={10}>
+                Clear Filters
+              </Button>
+            </Box>
+          )}
         </Box>
       </Box>
-
       {/* Record choice modal */}
       {recordChoiceOpen && recordChoiceProgram && (
         <Modal
@@ -1382,28 +1522,104 @@ export default function TVChannelGuide({ startDate, endDate }) {
           }}
         >
           <Flex direction="column" gap="sm">
-            <Button onClick={() => { recordOne(recordChoiceProgram); setRecordChoiceOpen(false); }}>Just this one</Button>
-            <Button variant="light" onClick={() => { saveSeriesRule(recordChoiceProgram, 'all'); setRecordChoiceOpen(false); }}>Every episode</Button>
-            <Button variant="light" onClick={() => { saveSeriesRule(recordChoiceProgram, 'new'); setRecordChoiceOpen(false); }}>New episodes only</Button>
+            <Button
+              onClick={() => {
+                recordOne(recordChoiceProgram);
+                setRecordChoiceOpen(false);
+              }}
+            >
+              Just this one
+            </Button>
+            <Button
+              variant="light"
+              onClick={() => {
+                saveSeriesRule(recordChoiceProgram, 'all');
+                setRecordChoiceOpen(false);
+              }}
+            >
+              Every episode
+            </Button>
+            <Button
+              variant="light"
+              onClick={() => {
+                saveSeriesRule(recordChoiceProgram, 'new');
+                setRecordChoiceOpen(false);
+              }}
+            >
+              New episodes only
+            </Button>
             {recordingForProgram && (
               <>
-                <Button color="orange" variant="light" onClick={async () => {
-                  try { await API.deleteRecording(recordingForProgram.id); } catch {}
-                  try { await useChannelsStore.getState().fetchRecordings(); } catch {}
-                  setRecordChoiceOpen(false);
-                }}>Remove this recording</Button>
-                <Button color="red" variant="light" onClick={async () => {
-                  try {
-                    await API.bulkRemoveSeriesRecordings({ tvg_id: recordChoiceProgram.tvg_id, title: recordChoiceProgram.title, scope: 'title' });
-                  } catch {}
-                  try { await API.deleteSeriesRule(recordChoiceProgram.tvg_id); } catch {}
-                  try { await useChannelsStore.getState().fetchRecordings(); } catch {}
-                  setRecordChoiceOpen(false);
-                }}>Remove this series (scheduled)</Button>
+                <Button
+                  color="orange"
+                  variant="light"
+                  onClick={async () => {
+                    try {
+                      await API.deleteRecording(recordingForProgram.id);
+                    } catch (error) {
+                      console.warn('Failed to delete recording', error);
+                    }
+                    try {
+                      await useChannelsStore.getState().fetchRecordings();
+                    } catch (error) {
+                      console.warn(
+                        'Failed to refresh recordings after delete',
+                        error
+                      );
+                    }
+                    setRecordChoiceOpen(false);
+                  }}
+                >
+                  Remove this recording
+                </Button>
+                <Button
+                  color="red"
+                  variant="light"
+                  onClick={async () => {
+                    try {
+                      await API.bulkRemoveSeriesRecordings({
+                        tvg_id: recordChoiceProgram.tvg_id,
+                        title: recordChoiceProgram.title,
+                        scope: 'title',
+                      });
+                    } catch (error) {
+                      console.warn(
+                        'Failed to remove scheduled series recordings',
+                        error
+                      );
+                    }
+                    try {
+                      await API.deleteSeriesRule(recordChoiceProgram.tvg_id);
+                    } catch (error) {
+                      console.warn('Failed to delete series rule', error);
+                    }
+                    try {
+                      await useChannelsStore.getState().fetchRecordings();
+                    } catch (error) {
+                      console.warn(
+                        'Failed to refresh recordings after series delete',
+                        error
+                      );
+                    }
+                    setRecordChoiceOpen(false);
+                  }}
+                >
+                  Remove this series (scheduled)
+                </Button>
               </>
             )}
             {existingRuleMode && (
-              <Button color="red" variant="subtle" onClick={async () => { await API.deleteSeriesRule(recordChoiceProgram.tvg_id); setExistingRuleMode(null); setRecordChoiceOpen(false); }}>Remove series rule ({existingRuleMode})</Button>
+              <Button
+                color="red"
+                variant="subtle"
+                onClick={async () => {
+                  await API.deleteSeriesRule(recordChoiceProgram.tvg_id);
+                  setExistingRuleMode(null);
+                  setRecordChoiceOpen(false);
+                }}
+              >
+                Remove series rule ({existingRuleMode})
+              </Button>
             )}
           </Flex>
         </Modal>
@@ -1427,27 +1643,78 @@ export default function TVChannelGuide({ startDate, endDate }) {
         >
           <Stack gap="sm">
             {(!rules || rules.length === 0) && (
-              <Text size="sm" c="dimmed">No series rules configured</Text>
+              <Text size="sm" c="dimmed">
+                No series rules configured
+              </Text>
             )}
-            {rules && rules.map((r) => (
-              <Flex key={`${r.tvg_id}-${r.mode}`} justify="space-between" align="center">
-                <Text size="sm">{r.title || r.tvg_id} — {r.mode === 'new' ? 'New episodes' : 'Every episode'}</Text>
-                <Group gap="xs">
-                  <Button size="xs" variant="subtle" onClick={async () => {
-                    await API.evaluateSeriesRules(r.tvg_id);
-                    try { await useChannelsStore.getState().fetchRecordings(); } catch {}
-                    notifications.show({ title: 'Evaluated', message: 'Checked for episodes' });
-                  }}>Evaluate Now</Button>
-                  <Button size="xs" variant="light" color="orange" onClick={async () => {
-                    await API.bulkRemoveSeriesRecordings({ tvg_id: r.tvg_id, title: r.title, scope: 'title' });
-                    try { await API.deleteSeriesRule(r.tvg_id); } catch {}
-                    try { await useChannelsStore.getState().fetchRecordings(); } catch {}
-                    const updated = await API.listSeriesRules();
-                    setRules(updated);
-                  }}>Remove this series (scheduled)</Button>
-                </Group>
-              </Flex>
-            ))}
+            {rules &&
+              rules.map((r) => (
+                <Flex
+                  key={`${r.tvg_id}-${r.mode}`}
+                  justify="space-between"
+                  align="center"
+                >
+                  <Text size="sm">
+                    {r.title || r.tvg_id} —{' '}
+                    {r.mode === 'new' ? 'New episodes' : 'Every episode'}
+                  </Text>
+                  <Group gap="xs">
+                    <Button
+                      size="xs"
+                      variant="subtle"
+                      onClick={async () => {
+                        await API.evaluateSeriesRules(r.tvg_id);
+                        try {
+                          await useChannelsStore.getState().fetchRecordings();
+                        } catch (error) {
+                          console.warn(
+                            'Failed to refresh recordings after evaluation',
+                            error
+                          );
+                        }
+                        notifications.show({
+                          title: 'Evaluated',
+                          message: 'Checked for episodes',
+                        });
+                      }}
+                    >
+                      Evaluate Now
+                    </Button>
+                    <Button
+                      size="xs"
+                      variant="light"
+                      color="orange"
+                      onClick={async () => {
+                        await API.bulkRemoveSeriesRecordings({
+                          tvg_id: r.tvg_id,
+                          title: r.title,
+                          scope: 'title',
+                        });
+                        try {
+                          await API.deleteSeriesRule(r.tvg_id);
+                        } catch (error) {
+                          console.warn(
+                            'Failed to delete series rule during removal',
+                            error
+                          );
+                        }
+                        try {
+                          await useChannelsStore.getState().fetchRecordings();
+                        } catch (error) {
+                          console.warn(
+                            'Failed to refresh recordings after bulk removal',
+                            error
+                          );
+                        }
+                        const updated = await API.listSeriesRules();
+                        setRules(updated);
+                      }}
+                    >
+                      Remove this series (scheduled)
+                    </Button>
+                  </Group>
+                </Flex>
+              ))}
           </Stack>
         </Modal>
       )}
diff --git a/frontend/src/pages/Settings.jsx b/frontend/src/pages/Settings.jsx
index 865358df..d61b3b80 100644
--- a/frontend/src/pages/Settings.jsx
+++ b/frontend/src/pages/Settings.jsx
@@ -199,6 +199,8 @@ const SettingsPage = () => {
   // Add a new state to track the dialog type
   const [rehashDialogType, setRehashDialogType] = useState(null); // 'save' or 'rehash'
 
+  // Store pending changed settings when showing the dialog
+  const [pendingChangedSettings, setPendingChangedSettings] = useState(null);
   const [comskipFile, setComskipFile] = useState(null);
   const [comskipUploadLoading, setComskipUploadLoading] = useState(false);
   const [comskipConfig, setComskipConfig] = useState({
@@ -422,6 +424,8 @@ const SettingsPage = () => {
 
     // If M3U hash key changed, show warning (unless suppressed)
     if (m3uHashKeyChanged && !isWarningSuppressed('rehash-streams')) {
+      // Store the changed settings before showing dialog
+      setPendingChangedSettings(changedSettings);
       setRehashDialogType('save'); // Set dialog type to save
       setRehashConfirmOpen(true);
       return;
@@ -565,23 +569,28 @@ const SettingsPage = () => {
   const executeSettingsSaveAndRehash = async () => {
     setRehashConfirmOpen(false);
 
-    // First save the settings
-    const values = form.getValues();
-    const changedSettings = {};
+    // Use the stored pending values that were captured before the dialog was shown
+    const changedSettings = pendingChangedSettings || {};
 
-    for (const settingKey in values) {
-      if (String(values[settingKey]) !== String(settings[settingKey].value)) {
-        changedSettings[settingKey] = `${values[settingKey]}`;
+    // Update each changed setting in the backend (create if missing)
+    for (const updatedKey in changedSettings) {
+      const existing = settings[updatedKey];
+      if (existing && existing.id) {
+        await API.updateSetting({
+          ...existing,
+          value: changedSettings[updatedKey],
+        });
+      } else {
+        await API.createSetting({
+          key: updatedKey,
+          name: updatedKey.replace(/-/g, ' '),
+          value: changedSettings[updatedKey],
+        });
       }
     }
 
-    // Update each changed setting in the backend
-    for (const updatedKey in changedSettings) {
-      await API.updateSetting({
-        ...settings[updatedKey],
-        value: changedSettings[updatedKey],
-      });
-    }
+    // Clear the pending values
+    setPendingChangedSettings(null);
   };
 
   const executeRehashStreamsOnly = async () => {
@@ -661,7 +670,7 @@ const SettingsPage = () => {
                 data={[
                   {
                     value: '12h',
-                    label: '12h hour time',
+                    label: '12 hour time',
                   },
                   {
                     value: '24h',
@@ -959,6 +968,10 @@ const SettingsPage = () => {
                           value: 'tvg_id',
                           label: 'TVG-ID',
                         },
+                        {
+                          value: 'm3u_id',
+                          label: 'M3U ID',
+                        },
                       ]}
                       {...form.getInputProps('m3u-hash-key')}
                       key={form.key('m3u-hash-key')}
@@ -1180,6 +1193,8 @@ const SettingsPage = () => {
         onClose={() => {
           setRehashConfirmOpen(false);
           setRehashDialogType(null);
+          // Clear pending values when dialog is cancelled
+          setPendingChangedSettings(null);
         }}
         onConfirm={handleRehashConfirm}
         title={
diff --git a/frontend/src/pages/__tests__/guideUtils.test.js b/frontend/src/pages/__tests__/guideUtils.test.js
new file mode 100644
index 00000000..58a6d292
--- /dev/null
+++ b/frontend/src/pages/__tests__/guideUtils.test.js
@@ -0,0 +1,100 @@
+import { describe, it, expect } from 'vitest';
+import dayjs from 'dayjs';
+import {
+  PROGRAM_HEIGHT,
+  EXPANDED_PROGRAM_HEIGHT,
+  buildChannelIdMap,
+  mapProgramsByChannel,
+  computeRowHeights,
+} from '../guideUtils.js';
+
+describe('guideUtils', () => {
+  describe('buildChannelIdMap', () => {
+    it('maps tvg ids from epg records and falls back to channel uuid', () => {
+      const channels = [
+        { id: 1, epg_data_id: 'epg-1', uuid: 'uuid-1' },
+        { id: 2, epg_data_id: null, uuid: 'uuid-2' },
+      ];
+      const tvgsById = {
+        'epg-1': { tvg_id: 'alpha' },
+      };
+
+      const map = buildChannelIdMap(channels, tvgsById);
+
+      expect(map.get('alpha')).toBe(1);
+      expect(map.get('uuid-2')).toBe(2);
+    });
+  });
+
+  describe('mapProgramsByChannel', () => {
+    it('groups programs by channel and sorts them by start time', () => {
+      const programs = [
+        {
+          id: 10,
+          tvg_id: 'alpha',
+          start_time: dayjs('2025-01-01T02:00:00Z').toISOString(),
+          end_time: dayjs('2025-01-01T03:00:00Z').toISOString(),
+          title: 'Late Show',
+        },
+        {
+          id: 11,
+          tvg_id: 'alpha',
+          start_time: dayjs('2025-01-01T01:00:00Z').toISOString(),
+          end_time: dayjs('2025-01-01T02:00:00Z').toISOString(),
+          title: 'Evening News',
+        },
+        {
+          id: 20,
+          tvg_id: 'beta',
+          start_time: dayjs('2025-01-01T00:00:00Z').toISOString(),
+          end_time: dayjs('2025-01-01T01:00:00Z').toISOString(),
+          title: 'Morning Show',
+        },
+      ];
+
+      const channelIdByTvgId = new Map([
+        ['alpha', 1],
+        ['beta', 2],
+      ]);
+
+      const map = mapProgramsByChannel(programs, channelIdByTvgId);
+
+      expect(map.get(1)).toHaveLength(2);
+      expect(map.get(1)?.map((item) => item.id)).toEqual([11, 10]);
+      expect(map.get(2)).toHaveLength(1);
+      expect(map.get(2)?.[0].startMs).toBeTypeOf('number');
+      expect(map.get(2)?.[0].endMs).toBeTypeOf('number');
+    });
+  });
+
+  describe('computeRowHeights', () => {
+    it('returns program heights with expanded rows when needed', () => {
+      const filteredChannels = [
+        { id: 1 },
+        { id: 2 },
+      ];
+
+      const programsByChannel = new Map([
+        [1, [{ id: 10 }, { id: 11 }]],
+        [2, [{ id: 20 }]],
+      ]);
+
+      const collapsed = computeRowHeights(
+        filteredChannels,
+        programsByChannel,
+        null
+      );
+      expect(collapsed).toEqual([PROGRAM_HEIGHT, PROGRAM_HEIGHT]);
+
+      const expanded = computeRowHeights(
+        filteredChannels,
+        programsByChannel,
+        10
+      );
+      expect(expanded).toEqual([
+        EXPANDED_PROGRAM_HEIGHT,
+        PROGRAM_HEIGHT,
+      ]);
+    });
+  });
+});
diff --git a/frontend/src/pages/guideUtils.js b/frontend/src/pages/guideUtils.js
new file mode 100644
index 00000000..5b52b938
--- /dev/null
+++ b/frontend/src/pages/guideUtils.js
@@ -0,0 +1,79 @@
+import dayjs from 'dayjs';
+
+export const PROGRAM_HEIGHT = 90;
+export const EXPANDED_PROGRAM_HEIGHT = 180;
+
+export function buildChannelIdMap(channels, tvgsById) {
+  const map = new Map();
+  channels.forEach((channel) => {
+    const tvgRecord = channel.epg_data_id
+      ? tvgsById[channel.epg_data_id]
+      : null;
+    const tvgId = tvgRecord?.tvg_id ?? channel.uuid;
+    if (tvgId) {
+      const tvgKey = String(tvgId);
+      if (!map.has(tvgKey)) {
+        map.set(tvgKey, []);
+      }
+      map.get(tvgKey).push(channel.id);
+    }
+  });
+  return map;
+}
+
+export function mapProgramsByChannel(programs, channelIdByTvgId) {
+  if (!programs?.length || !channelIdByTvgId?.size) {
+    return new Map();
+  }
+
+  const map = new Map();
+  programs.forEach((program) => {
+    const channelIds = channelIdByTvgId.get(String(program.tvg_id));
+    if (!channelIds || channelIds.length === 0) {
+      return;
+    }
+
+    const startMs = program.startMs ?? dayjs(program.start_time).valueOf();
+    const endMs = program.endMs ?? dayjs(program.end_time).valueOf();
+
+    const programData = {
+      ...program,
+      startMs,
+      endMs,
+    };
+
+    // Add this program to all channels that share the same TVG ID
+    channelIds.forEach((channelId) => {
+      if (!map.has(channelId)) {
+        map.set(channelId, []);
+      }
+      map.get(channelId).push(programData);
+    });
+  });
+
+  map.forEach((list) => {
+    list.sort((a, b) => a.startMs - b.startMs);
+  });
+
+  return map;
+}
+
+export function computeRowHeights(
+  filteredChannels,
+  programsByChannelId,
+  expandedProgramId,
+  defaultHeight = PROGRAM_HEIGHT,
+  expandedHeight = EXPANDED_PROGRAM_HEIGHT
+) {
+  if (!filteredChannels?.length) {
+    return [];
+  }
+
+  return filteredChannels.map((channel) => {
+    const channelPrograms = programsByChannelId.get(channel.id) || [];
+    const expanded = channelPrograms.some(
+      (program) => program.id === expandedProgramId
+    );
+    return expanded ? expandedHeight : defaultHeight;
+  });
+}
diff --git a/frontend/src/test/setupTests.js b/frontend/src/test/setupTests.js
new file mode 100644
index 00000000..b5f53af0
--- /dev/null
+++ b/frontend/src/test/setupTests.js
@@ -0,0 +1,42 @@
+import '@testing-library/jest-dom/vitest';
+import { afterEach, vi } from 'vitest';
+import { cleanup } from '@testing-library/react';
+
+afterEach(() => {
+  cleanup();
+});
+
+if (typeof window !== 'undefined' && !window.matchMedia) {
+  window.matchMedia = vi.fn().mockImplementation((query) => ({
+    matches: false,
+    media: query,
+    onchange: null,
+    addListener: vi.fn(),
+    removeListener: vi.fn(),
+    addEventListener: vi.fn(),
+    removeEventListener: vi.fn(),
+    dispatchEvent: vi.fn(),
+  }));
+}
+
+if (typeof window !== 'undefined' && !window.ResizeObserver) {
+  class ResizeObserver {
+    constructor(callback) {
+      this.callback = callback;
+    }
+    observe() {}
+    unobserve() {}
+    disconnect() {}
+  }
+
+  window.ResizeObserver = ResizeObserver;
+}
+
+if (typeof window !== 'undefined') {
+  if (!window.requestAnimationFrame) {
+    window.requestAnimationFrame = (cb) => setTimeout(cb, 16);
+  }
+  if (!window.cancelAnimationFrame) {
+    window.cancelAnimationFrame = (id) => clearTimeout(id);
+  }
+}
diff --git a/frontend/vite.config.js b/frontend/vite.config.js
index 9ce8189b..1026e519 100644
--- a/frontend/vite.config.js
+++ b/frontend/vite.config.js
@@ -26,4 +26,10 @@ export default defineConfig({
     //   },
     // },
   },
+
+  test: {
+    environment: 'jsdom',
+    setupFiles: ['./src/test/setupTests.js'],
+    globals: true,
+  },
 });
diff --git a/version.py b/version.py
index 39334b6c..750836e7 100644
--- a/version.py
+++ b/version.py
@@ -1,5 +1,5 @@
 """
 Dispatcharr version information.
 """
-__version__ = '0.9.1'  # Follow semantic versioning (MAJOR.MINOR.PATCH)
+__version__ = '0.10.3'  # Follow semantic versioning (MAJOR.MINOR.PATCH)
 __timestamp__ = None    # Set during CI/CD build process