diff --git a/.github/workflows/backend-tests.yml b/.github/workflows/backend-tests.yml
new file mode 100644
index 00000000..036d6ece
--- /dev/null
+++ b/.github/workflows/backend-tests.yml
@@ -0,0 +1,161 @@
+name: Backend Tests
+
+on:
+  push:
+    branches: [main, dev]
+    paths:
+      - 'apps/**'
+      - 'core/**'
+      - 'tests/**'
+      - 'dispatcharr/**'
+      - 'pyproject.toml'
+      - 'version.py'
+      - 'manage.py'
+      - 'scripts/ci_backend_test_labels.py'
+      - 'scripts/ci_bootstrap_backend.sh'
+      - '.github/workflows/backend-tests.yml'
+  pull_request:
+    branches: [main, dev]
+    paths:
+      - 'apps/**'
+      - 'core/**'
+      - 'tests/**'
+      - 'dispatcharr/**'
+      - 'pyproject.toml'
+      - 'version.py'
+      - 'manage.py'
+      - 'scripts/ci_backend_test_labels.py'
+      - 'scripts/ci_bootstrap_backend.sh'
+      - '.github/workflows/backend-tests.yml'
+  workflow_dispatch:
+    inputs:
+      full_suite:
+        description: Run the full backend test suite
+        type: boolean
+        default: true
+
+permissions:
+  contents: read
+  packages: read
+
+concurrency:
+  group: backend-tests-${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  plan:
+    name: Plan test groups
+    runs-on: ubuntu-latest
+    outputs:
+      labels: ${{ steps.resolve.outputs.labels }}
+      has_tests: ${{ steps.resolve.outputs.has_tests }}
+      base_image: ${{ steps.base_image.outputs.image }}
+      sync_python_deps: ${{ steps.base_image.outputs.sync_python_deps }}
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v6
+        with:
+          fetch-depth: 0
+
+      - name: Collect changed paths
+        id: changed
+        shell: bash
+        run: |
+          set -euo pipefail
+          : > /tmp/changed_paths.txt
+
+          if [ "${{ github.event_name }}" = "workflow_dispatch" ]; then
+            if [ "${{ inputs.full_suite }}" = "true" ]; then
+              : > /tmp/changed_paths.txt
+              echo "mode=full" >> "$GITHUB_OUTPUT"
+            else
+              git diff --name-only HEAD~1 HEAD > /tmp/changed_paths.txt || true
+              echo "mode=diff" >> "$GITHUB_OUTPUT"
+            fi
+          elif [ "${{ github.event_name }}" = "pull_request" ]; then
+            git fetch origin "${{ github.base_ref }}"
+            git diff --name-only "origin/${{ github.base_ref }}...HEAD" > /tmp/changed_paths.txt
+            echo "mode=pr" >> "$GITHUB_OUTPUT"
+          else
+            if [ "${{ github.event.before }}" = "0000000000000000000000000000000000000000" ]; then
+              git ls-files > /tmp/changed_paths.txt
+              echo "mode=initial-push" >> "$GITHUB_OUTPUT"
+            else
+              git diff --name-only "${{ github.event.before }}" "${{ github.sha }}" > /tmp/changed_paths.txt
+              echo "mode=push" >> "$GITHUB_OUTPUT"
+            fi
+          fi
+
+      - name: Select base image
+        id: base_image
+        shell: bash
+        run: |
+          set -euo pipefail
+          if [ "${{ github.event_name }}" = "pull_request" ]; then
+            TARGET_BRANCH="${{ github.base_ref }}"
+          else
+            TARGET_BRANCH="${{ github.ref_name }}"
+          fi
+          if [ "$TARGET_BRANCH" = "main" ]; then
+            TAG="base"
+          else
+            TAG="base-dev"
+          fi
+          REPO_OWNER="$(echo "${{ github.repository_owner }}" | tr '[:upper:]' '[:lower:]')"
+          REPO_NAME="$(echo "${{ github.event.repository.name }}" | tr '[:upper:]' '[:lower:]')"
+          echo "image=ghcr.io/${REPO_OWNER}/${REPO_NAME}:${TAG}" >> "$GITHUB_OUTPUT"
+          if grep -qx 'pyproject.toml' /tmp/changed_paths.txt || [ "${{ github.event_name }}" = "workflow_dispatch" ]; then
+            echo "sync_python_deps=true" >> "$GITHUB_OUTPUT"
+          else
+            echo "sync_python_deps=false" >> "$GITHUB_OUTPUT"
+          fi
+          echo "Using base image: ghcr.io/${REPO_OWNER}/${REPO_NAME}:${TAG}"
+
+      - name: Resolve Django test labels
+        id: resolve
+        env:
+          FULL_SUITE: ${{ github.event_name == 'workflow_dispatch' && inputs.full_suite == true && 'true' || 'false' }}
+        run: |
+          set -euo pipefail
+          LABELS=$(python scripts/ci_backend_test_labels.py < /tmp/changed_paths.txt)
+          echo "labels=${LABELS}" >> "$GITHUB_OUTPUT"
+          if [ "${LABELS}" = "[]" ]; then
+            echo "has_tests=false" >> "$GITHUB_OUTPUT"
+          else
+            echo "has_tests=true" >> "$GITHUB_OUTPUT"
+          fi
+          echo "Selected labels: ${LABELS}"
+
+  test:
+    name: ${{ matrix.label }}
+    needs: plan
+    if: needs.plan.outputs.has_tests == 'true'
+    runs-on: ubuntu-latest
+    container:
+      image: ${{ needs.plan.outputs.base_image }}
+      credentials:
+        username: ${{ github.actor }}
+        password: ${{ secrets.GITHUB_TOKEN }}
+      options: --entrypoint ""
+    strategy:
+      max-parallel: 6
+      fail-fast: false
+      matrix:
+        label: ${{ fromJSON(needs.plan.outputs.labels) }}
+    env:
+      DISPATCHARR_ENV: aio
+      DJANGO_SECRET_KEY: ci-test-secret-key
+      POSTGRES_DB: dispatcharr
+      POSTGRES_USER: dispatch
+      POSTGRES_PASSWORD: secret
+      DISPATCHARR_LOG_LEVEL: WARNING
+      SYNC_PYTHON_DEPS: ${{ needs.plan.outputs.sync_python_deps }}
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v6
+
+      - name: Run tests in base image
+        env:
+          GITHUB_WORKSPACE: ${{ github.workspace }}
+        run: bash scripts/ci_bootstrap_backend.sh "${{ matrix.label }}" -v2
diff --git a/CHANGELOG.md b/CHANGELOG.md
index b8d19b94..a97f5158 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,6 +7,152 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.27.2] - 2026-06-30
+
+### Added
+
+- **New proxy setting: Client Connect Grace Period (`channel_client_wait_period`, default 5s).** Adds a dedicated timeout for channels that have filled their buffer but still have no viewers (`waiting_for_clients`). Previously that window reused `channel_shutdown_delay` (default 0s), so those channels were torn down almost immediately.
+
+### Changed
+
+- **Proxy grace-period settings are now split into three distinct timeouts.** The cleanup watchdog already applied `channel_init_grace_period` while a channel was still connecting (buffer not ready) and reused `channel_shutdown_delay` once `connection_ready_time` was set, including for `waiting_for_clients` with zero viewers. With the default `channel_shutdown_delay` of 0s, a buffered channel waiting for its first viewer was stopped almost immediately; raising shutdown delay was the only workaround, but that also delayed teardown after real disconnects. Behaviour is now:
+  - **`channel_init_grace_period` (default 60s, max 300s):** how long the proxy may spend connecting and cycling failover streams before giving up on startup.
+  - **`channel_client_wait_period` (default 5s):** how long a ready channel with no viewers stays up waiting for the first client (the original grace-period use case).
+  - **`channel_shutdown_delay` (default 0s):** delay after the last client disconnects only; no longer applies when the buffer is ready but no viewer has connected yet.
+- **Migration 0026 bumps `channel_init_grace_period` to 60s when the stored value is below 60.** Existing installs on the old 5s default (or any custom value under 60) are raised automatically. Values already at 60s or higher are unchanged. If you previously raised `channel_shutdown_delay` to keep buffered channels alive with no viewers, set `channel_client_wait_period` instead (Settings → Proxy → Advanced).
+- **Proxy settings UI: less-used options moved under Advanced.** Settings → Proxy now shows the day-to-day tuning fields by default (`buffering_timeout`, `buffering_speed`, `channel_shutdown_delay`, `new_client_behind_seconds`). **Buffer Chunk TTL**, **Channel Initialization Timeout**, and **Client Connect Grace Period** are tucked under **Show Advanced Settings**.
+
+## [0.27.1] - 2026-06-25
+
+### Security
+
+- Updated `Django` 6.0.5 → 6.0.6, resolving the following CVEs:
+  - **CVE-2026-6873**: Signed cookie salt namespace collision in `HttpRequest.get_signed_cookie()`.
+  - **CVE-2026-7666**: Potential unencrypted email transmission via STARTTLS in the SMTP backend.
+  - **CVE-2026-8404**: Potential private data exposure via case-sensitive `Cache-Control` directives in `UpdateCacheMiddleware`.
+  - **CVE-2026-35193**: Potential private data exposure via missing `Vary: Authorization` in `UpdateCacheMiddleware`.
+  - **CVE-2026-48587**: Potential private data exposure via whitespace padding in the `Vary` header.
+- Updated frontend npm dependencies to resolve 4 audit vulnerabilities (1 low, 2 moderate, 1 high):
+  - Updated `vite` 7.3.2 → 7.3.5, resolving **moderate** NTLMv2 hash disclosure via UNC path handling on Windows ([GHSA-v6wh-96g9-6wx3](https://github.com/advisories/GHSA-v6wh-96g9-6wx3)) and **high** `server.fs.deny` bypass on Windows alternate paths ([GHSA-fx2h-pf6j-xcff](https://github.com/advisories/GHSA-fx2h-pf6j-xcff))
+  - Updated `js-yaml` 4.1.1 → 5.1.0, resolving **moderate** quadratic-complexity DoS in merge key handling via repeated aliases ([GHSA-h67p-54hq-rp68](https://github.com/advisories/GHSA-h67p-54hq-rp68))
+  - Updated `esbuild` 0.27.3 → 0.28.1, resolving **low** arbitrary file read when running the development server on Windows ([GHSA-g7r4-m6w7-qqqr](https://github.com/advisories/GHSA-g7r4-m6w7-qqqr))
+
+### Added
+
+- **Isolated backend test settings (`dispatcharr.settings_test`).** `python manage.py test` now switches to this module automatically (via `manage.py`). It creates an empty PostgreSQL `test_<dbname>` database (same engine as production), uses the standard Postgres backend instead of geventpool so `TestCase` transactions isolate correctly, and leaves Celery tasks queued (no eager `post_save` signal runs during tests). Set `TEST_USE_SQLITE=1` for an in-memory SQLite fallback when Postgres is unavailable.
+
+### Performance
+
+- **`get_vod_streams` and `get_series` XC API endpoints are faster and no longer exhaust Docker `/dev/shm`.** Large libraries (e.g. 125k movies) previously ran one wide `DISTINCT ON` query with parallel workers, which could fail with `could not resize shared memory segment … No space left on device` on the default 64MB container shm. Both endpoints now fetch display columns via `.values()` (no ORM model instantiation per row). Redundant `category` and `logo` joins were dropped in favor of FK ids; alphabetical sort runs in SQL. Typical full-library response time drops from ~23–28s to ~8–10s with stable shm usage.
+- **XMLTV EPG export is faster and no longer balloons worker memory.** `generate_epg()` was reworked end-to-end for large guides. (Fixes #1366)
+  - Streams incrementally: on a cache miss each chunk is pushed to a Redis list as it is yielded (no `''.join()` in the worker); repeat requests within 300s stream chunks back from Redis. `malloc_trim` runs after cold builds.
+  - Channel streams are prefetched once (only `id`/`name`) instead of one query per custom-dummy channel; dummy `EPGData` programme existence is bulk-checked in a single query.
+  - The primary channel id is escaped once per `epg_id` group instead of once per programme (~750k fewer `html.escape` calls on a large guide).
+  - The channel query no longer JOINs multi-MB `programme_index` blobs per channel (~13s saved on a ~2000-channel guide; indices live in `EPGSourceIndex`).
+  - Programme export uses `(epg_id, id)` keyset pagination with a per-source `start_time` sort; a matching composite index on `ProgramData` (created `CONCURRENTLY` on PostgreSQL) lets each chunk use an ordered index range scan instead of re-sorting every chunk.
+- **EPG grid endpoint releases its payload memory back to the OS.** `/api/epg/grid/` drops the redundant full-list copy when appending dummy programmes and runs `malloc_trim` once the response is sent, so worker RSS no longer ratchets up ~20MB per request.
+
+### Changed
+
+- **`programme_index` moved off `EPGSource` into a dedicated `EPGSourceIndex` table.** The multi-MB byte-offset index was repeatedly pulled into web and Celery workers by ordinary `EPGSource` queries and `select_related` JOINs (which ignore manager-level `defer()`). It now lives in a one-to-one `EPGSourceIndex` row, read only when explicitly accessed through the `EPGSource.programme_index` property, so no list, detail, or JOIN query can load it by accident. Migration `0026` copies existing indices across. No API or index-build behavior change.
+
+- **EPG generation extracted into `apps/output/epg.py`.** All XMLTV output logic (`generate_epg`, `generate_dummy_programs`, `generate_custom_dummy_programs`, `generate_dummy_epg`, and supporting helpers) moved from `apps/output/views.py` into a dedicated module. `views.py` retains the thin HTTP endpoint wrappers and auth checks; `epg.py` handles all content generation. No behavior change.
+
+- **Channel list with nested streams loads faster.** `GET /api/channels/channels/?include_streams=true` (Channels UI and single-channel fetch) now builds nested stream payloads from the prefetched `channelstream_set` instead of issuing one extra streams M2M query per channel.
+
+- Dependency updates:
+  - `Django` 6.0.5 → 6.0.6 (security patch; see Security section)
+  - `requests` 2.33.1 → 2.34.2
+  - `gevent` 26.4.0 → 26.5.0
+  - `torch` 2.11.0+cpu → 2.12.1+cpu
+  - `sentence-transformers` 5.4.1 → 5.6.0
+  - `lxml` 6.1.0 → 6.1.1
+
+
+### Fixed
+
+- **Channel Initialization Grace Period is honoured during live stream startup.** Preview and playback no longer abort after a hardcoded 10s while the channel is still connecting with an empty buffer; the TS generator init-wait stall check and upstream health monitor now use the configured `channel_init_grace_period` (same as the server cleanup watchdog) instead of `CONNECTION_TIMEOUT`. (Fixes #1380)
+- **Channels are marked `active` as soon as the buffer threshold is met and a client is streaming.** Once the initial buffer fills, state is set to `active` immediately when viewers are attached, or `waiting_for_clients` when the buffer is ready but no client is connected yet (e.g. proxy API warmup). The cleanup watchdog no longer waits an extra grace period before promoting to `active`. Proxy settings copy now describes `channel_init_grace_period` as an initialization buffer timeout.
+- **DVR recording playback auth is complete for native video, HLS segments, and redirects.** Completed recordings use `/file/` with native `<video src>`, which cannot send `Authorization` headers. Playback accepts `?token=` query-param JWT (matching VOD streams), and the floating video player appends the token when assigning native URLs. The explicit HLS URL route (`/api/channels/recordings/.../hls/...`) now registers the same authenticators as the ViewSet `@action` handlers—previously only header JWT applied on that path, so `?token=` failed for native HLS clients. When the request used `?token=`, rewritten playlist segment URLs and `/file/`↔`/hls/` redirects preserve the token; hls.js clients that authenticate via `Authorization` are unchanged. `QueryParamJWTAuthentication` reads `request.query_params` on DRF requests.
+- **In-progress DVR playback no longer jumps to the live edge.** The floating video player still opens in-progress recordings at the start of the seekable range, but hls.js was configured with `liveMaxLatencyDurationCount: 10`, which forced the playhead forward to "now" shortly after playback began. Live-edge sync is now disabled for recording HLS so users can watch, pause, and scrub from the beginning while the recording continues. (Fixes #1329)
+- **`refresh_single_m3u_account` no longer re-raises after setting account ERROR.** Matches `refresh_epg_data`: the account status and UI already reflect the failure; Celery no longer marks the task FAILED after the terminal error state is persisted.
+- **M3U refresh recovers DB connections and account status after failures.** Celery workers now call `close_old_connections()` before and after every task; `refresh_single_m3u_account` also resets its DB connection at task start and retries account loads once after a connection reset (avoids opaque `list index out of range` errors from poisoned worker connections). Accounts leave `fetching`/`parsing` for a terminal `error` or `success` state when refresh aborts. Error-path status updates use `QuerySet.update()` on a clean connection instead of `save()` on a connection that may already be INTRANS after `refresh_m3u_groups` or batch ORM failures. Failed group downloads now set `error` instead of returning silently. Refresh start replaces stale `last_message` text. `refresh_account_profiles` releases DB connections after each profile failure. (Fixes #1338)
+- **EPG refresh recovers DB connections and source status after failures.** `refresh_epg_data` now mirrors the M3U hardening: connection reset at task start/end, retried source load after a poisoned-worker connection reset, `QuerySet.update()` for error status on a clean connection, and a `finally` guard that moves sources stuck in `fetching`/`parsing` to `error`. Programme index builds are skipped when programme parsing fails. `parse_channels_only` now persists the error status when a missing file has no URL to refetch.
+- **M3U `custom_properties` JSON normalization.** Legacy rows and some API writes could store a JSON-encoded string instead of an object in `custom_properties`, causing refresh, profile sync, and auto-sync to fail with `'str' object has no attribute 'get'`. M3U account, profile, and group-relation models normalize on `save()`; group settings bulk writes and read/merge paths use shared helpers in `core.utils` without re-parsing dict values.
+- **`POST /api/epg/import/` no longer loads the full EPG source row.** The dummy-source guard uses a narrow existence query instead of `objects.get()`, keeping the import trigger lightweight. Request/response shape is unchanged for the UI, plugins, and external importers.
+- **XC live playback URL building now normalizes account server URLs.** On-demand live URLs (introduced for Server Group profile rotation in 0.27.0) rebuild `/live/{user}/{pass}/{stream_id}.ts` from current credentials instead of reusing the synced `stream.url`. That path now runs `normalize_server_url()` so pasted API URLs (e.g. `/player_api.php` with query params) are stripped while sub-paths like `/server1` are preserved. `get_transformed_credentials()` normalizes the base URL at the source; VOD movie and episode relations use the same helper instead of constructing a throwaway `XCClient` (which also avoided per-request HTTP session setup). (Fixes #1363)
+- **Live proxy now releases geventpool DB connections on more paths.** `stream_ts()` calls `close_old_connections()` before `StreamingHttpResponse` so clients waiting on channel init do not keep a pool slot while the generator polls Redis. `generate_stream_url()`, `get_stream_info_for_switch()`, `get_alternate_streams()`, and `get_connections_left()` release in `finally` blocks after ORM work on stream-manager failover paths that run outside Django's request cycle. TS client disconnect cleanup matches fMP4, and `ChannelService` metadata helpers release after their ORM lookups.
+- **OpenAPI schema paths for nested M3U profiles and filters no longer contain escaped slashes.** Router regex prefixes used unnecessary `\/`, which drf-spectacular serialized literally into the schema and broke client generators (e.g. oapi-codegen). Runtime URL matching is unchanged. (Fixes #1384)
+- **Auto-sync range conflict warning no longer flags a group's own channels when using a channel-group override.** The M3U group settings "Range conflict" check compared occupant channel groups against the source group being configured. Auto-sync with `group_override` creates channels in the override target group, so those channels were misclassified as conflicts. The frontend now resolves the effective target group (override target when set, otherwise the source group) for classification. Genuine conflicts—manual channels, other accounts, different groups, or user-pinned numbers—still surface. (Fixes #1331) — Thanks [@CodeBormen](https://github.com/CodeBormen)
+
+## [0.27.0] - 2026-06-16
+
+### Added
+
+- **Manual Server Groups for shared M3U connection limits.** The existing `ServerGroup` model and account FK are now wired into live and VOD playback. Accounts assigned to the same group share a credential-scoped Redis counter when their provider logins match (hashed fingerprint); unrelated logins in the same group keep separate counters. Enforcement uses each profile's `max_streams` - not a group-wide cap - and profiles with `max_streams=0` skip credential pooling for that profile while still rotating on their own per-profile counter. New `apps/m3u/connection_pool.py` centralizes reserve/release, profile rotation, and credential moves on profile switch. (Closes #1137) — Thanks [@Goldenfreddy0703](https://github.com/Goldenfreddy0703)
+  - **Server Groups manager UI** on the M3U Accounts page: create, rename, and delete groups with account counts and delete confirmation. Groups load on login via a new Zustand store and REST helpers (`/api/m3u/server-groups/`).
+  - **M3U account form** adds a Server Group picker (including inline “add group”), reorganized into three columns (source/auth, connection limits, sync/content), and a Manage server groups shortcut.
+  - **VOD profile selection** uses `pool_has_capacity_for_profile()` so grouped accounts respect shared credential limits before a profile is chosen (non-grouped accounts behave as before).
+  - **Live profile switches** move the shared credential counter when the new profile uses a different provider login; same-login switches leave the credential counter unchanged.
+  - **Credential release keys** stored at reserve time allow counters to be released even if the M3U profile row is deleted afterward.
+- **PostgreSQL `application_name` tagging by process role.** Pool connections now set `application_name` at connect time (e.g. `Dispatcharr-uwsgi-{pid}`, `Dispatcharr-celery-worker-{pid}`, `Dispatcharr-celery-dvr-{pid}`) so `pg_stat_activity` shows which Dispatcharr process owns each backend instead of a generic client label.
+
+### Changed
+
+- **Plugin repo manifests support split download and metadata base URLs.** `download_base_url` and `metadata_base_url` are optional alternatives to `root_url` in the plugin repository manifest, so repo authors can serve metadata (manifests, icons) and release zips from different origins without absolute URLs everywhere. Manifest and icon URLs resolve via `metadata_base_url` then `root_url`; latest/download URLs resolve via `download_base_url` then `root_url`. When `metadata_base_url` is set and a plugin entry has `manifest_url` but no `icon_url`, the icon defaults to `logo.png` in the same directory as the per-plugin manifest. Manifests using only `root_url` behave identically to before. — Thanks [@sethwv](https://github.com/sethwv)
+- **Live and VOD connection slot logic now routes through `connection_pool`.** `Channel.get_stream()`, direct `Stream.get_stream()`, VOD profile selection, and the multi-worker VOD connection manager all call `reserve_profile_slot()` / `release_profile_slot()` instead of inline Redis INCR/DECR. VOD profile selection also checks `pool_has_capacity_for_profile()` before choosing a profile.
+- **Live XC upstream URLs use current credentials.** `_resolve_live_stream_url()` builds `/live/{user}/{pass}/{stream_id}.ts` from transformed account credentials and the stream's provider `stream_id`, so playback stays aligned with the active login after credential or profile changes instead of reusing a stale `stream.url` from sync.
+- **Channel stream switches check pooled capacity.** `get_stream_info_for_switch()` uses `profile_available_for_channel_switch()` when targeting a specific stream, and releases a reserved slot if URL assembly fails after `get_stream()` allocated one.
+- **Live proxy init reads Redis assignment once.** After `generate_stream_url()` reserves a slot, the stream handler reads `channel_stream` / `stream_profile` from Redis instead of calling `get_stream()` again, avoiding double INCR under concurrent release.
+- **Centralized Dispatcharr User-Agent construction in `core.utils`.** Outbound HTTP calls (Schedules Direct API, update checks, logo/VOD fallbacks, DVR recording clients) now use `dispatcharr_user_agent()`, `dispatcharr_dvr_user_agent()`, and `dispatcharr_http_headers()` instead of ad-hoc `Dispatcharr/{version}` strings and stale `Dispatcharr/1.0` fallbacks.
+- **EPG auto-match overhaul** — matching logic moved to `apps/channels/epg_matching.py`; Celery tasks in `tasks.py` are thin wrappers.
+  - Single-channel auto-match is now asynchronous: the API returns `202 Accepted` and pushes the result over WebSocket (`single_channel_epg_match`), so large EPG libraries no longer hit the previous 30-second HTTP timeout.
+  - Progress, bulk completion, and single-channel results use `send_websocket_update` instead of `async_to_sync(channel_layer.group_send)`, so notifications work reliably under gevent-patched uWSGI and Celery workers.
+  - Single-channel and selected-channel auto-match always run, even when the channel already has EPG assigned; match-all (no channel IDs) still only processes channels without EPG.
+  - Rematching to the same EPG no longer re-saves the channel or queues program-parse tasks; only assignments that actually change are written and refreshed.
+- **Easier EPG search when editing a channel.** The filter in the EPG picker now works more like a normal search box. You can type several words at once (e.g. `sky uk`) and it finds channels where every word appears somewhere in the name or TVG-ID, the order doesn't matter, and a word in the name can pair with one in the ID. Accents are ignored too, so `decale` matches `Décalé` and the other way around. — Thanks [@FiveBoroughs](https://github.com/FiveBoroughs)
+
+### Performance
+
+- **XC live refresh releases bulk catalog data sooner during batch processing.** After filtering the single `get_all_live_streams` response, the full provider catalog list is dropped before batch DB work. `process_m3u_batch_direct` (the path XC refreshes use) now runs `gc.collect()` after each batch and clears batch slice references as thread futures complete. Large structures are still `del`'d in the refresh `finally` block before Celery's `task_postrun` runs `cleanup_memory()`.
+- **VOD movie/series batch matching no longer scans the full no-ID catalog.** `process_movie_batch` and `process_series_batch` previously loaded every `Movie`/`Series` row without TMDB or IMDB IDs on each 1000-item chunk to resolve name+year duplicates. Lookup is now scoped to the names in the current batch via `lookup_by_name_year()`, which reduces memory and DB time per chunk. `refresh_vod_content` and `batch_refresh_series_episodes` are registered for Celery post-task memory cleanup (one GC pass at task end, not per chunk).
+- **EPG programme parse now streams through PostgreSQL staging instead of holding the full catalogue in Python.** `parse_programs_for_source` writes parsed rows into a session-scoped temp table in batches (`_EPG_PARSE_BATCH_SIZE=2500`), then atomically swaps them into `ProgramData` with batched `DELETE ... RETURNING` + `INSERT` (`_EPG_SWAP_BATCH_SIZE=5000`) so Postgres never materializes the entire guide in one statement. Peak Celery memory during large XMLTV refreshes drops sharply compared with building a monolithic in-memory list before bulk insert. The byte-offset programme index build is deferred until after the swap completes so index construction no longer competes with parse for memory and I/O. `refresh_epg_data` closes its DB connection in `finally`, and `build_programme_index_task` is registered as a memory-intensive Celery task. SQLite/dev installs keep an in-memory fallback path.
+- **Pooled PostgreSQL connections now rotate on a bounded lifetime.** psycopg3 client-side cache grows on handles kept open indefinitely by `django-db-geventpool`; recycling uWSGI workers would interrupt live streams. A thin custom backend (`dispatcharr.db.backends.postgresql_psycopg3`) closes and replaces pool connections after `DATABASE_POOL_CONN_MAX_LIFETIME` seconds (default 600, env-overridable; set `0` to disable) on checkout and return while preserving warm-pool reuse within the window. (Fixes #1343)
+- **Schedules Direct refresh only fetches guide data for mapped channels.** Schedule MD5 checks and schedule downloads now target mapped lineup stations instead of the entire lineup, and schedule MD5 cache for unmapped stations is pruned each refresh. Unmapped lineup entries no longer trigger wasted schedule API calls when their MD5 changes.
+- **EPG auto-match memory and throughput improvements.**
+  - Single-channel matching streams active EPG rows and keeps only the best match plus the top 20 candidates in memory; ML validates at most 21 names per channel instead of embedding the full catalog.
+  - Strong fuzzy matches (≥75% single channel, ≥80% bulk) skip ML entirely, avoiding a ~500MB PyTorch load when the fuzzy result is already reliable.
+  - Bulk matching uses a single fuzzy pass per channel instead of scanning the full catalog twice for best match and top candidates.
+  - Bulk exact `tvg_id` / Gracenote matching uses an in-memory index built alongside the EPG catalog (`build_epg_matching_catalog()`), giving O(1) lookups with no extra database queries.
+  - Bulk match apply uses batched queries (two fetches plus `bulk_update`) instead of one `EPGData.objects.get()` per matched channel.
+  - EPG normalization settings are cached once per matching run, avoiding repeated `CoreSettings` reads when normalizing thousands of names.
+
+### Fixed
+
+- **Live proxy channels could remain running with no clients after disconnect.** `stop_channel` called `log_system_event('channel_stop')` synchronously before local cleanup and Redis key deletion; Connect integrations or DB event writes on that path could block teardown indefinitely while the cleanup thread kept refreshing metadata TTL for a stale `stream_buffers` entry. Teardown now signals shutdown (`buffer.stopping`), runs model `release_stream()` and Redis key deletion, releases ownership, stops ffmpeg/output managers and local buffers, and only then logs the stop event asynchronously. Metadata TTL refresh skips channels mid-shutdown and non-owned channels; a stuck-stop watchdog forces cleanup if `stop_channel` does not return within ~10s (or 2× `channel_shutdown_delay`, whichever is greater). Stream buffers ignore late `add_chunk()` writes once shutdown begins (`buffer.stopping` set at teardown start).
+- **Client reconnect during channel teardown could wedge the channel across uWSGI workers.** The disconnect path called `proxy_server.stop_channel()` directly, so other workers were not notified and reconnecting clients could attach while ownership was released on the owner worker. The cleanup thread then re-acquired expired ownership and looped on orphaned clients while the upstream connection stayed open. All lifecycle stops now go through coordinated Redis teardown (`channel_stopping` flag, metadata `stopping` state, and `CHANNEL_STOP` pubsub). New stream requests are rejected with `503 Retry-After` only during active teardown (not during the post-disconnect shutdown delay grace period); `initialize_channel()` and ownership re-acquisition refuse to proceed in those states; non-owner workers clean local resources only on pubsub; and orphaned-client sweeps force cleanup when teardown is already active. (Fixes #1342)
+- **Orphaned upstream threads kept writing Redis after teardown.** Partial cleanup could remove a channel from `stream_managers` while the `stream-{uuid}` OS thread kept running, so orphan metadata sweeps only deleted Redis keys and chunks/metadata were immediately recreated (bare `total_bytes` hash with TTL -1). Stream managers now stop upstream when ownership is lost, orphan cleanup stops local ffmpeg/stream threads even when registry entries are gone (`_live_stream_managers` tracks managers until the thread exits), and forced recovery stops processes before Redis deletion instead of dropping dict entries without calling `stop()`.
+- **Rapid channel switching could leave bare `buffer:index` keys in Redis.** `buffer.stop()` flushed a final partial chunk via `INCR` during teardown, creating a persistent index key (TTL -1) after chunk keys expired; under load overlapping disconnect and cleanup-thread stops could race on `_stop_local_stream_activity`, blocking on ffmpeg stderr join before `_clean_redis_keys` ever ran. Teardown no longer writes to Redis from `buffer.stop()`, disconnect uses coordinated stop only (no duplicate upstream stop), model `release_stream()` runs before Redis keys are scanned/deleted (so `profile_connections` counters are not left stuck), ownership is released after Redis cleanup but before the blocking local ffmpeg stop, and a `finally` block guarantees Redis cleanup if local teardown raises.
+- **Live proxy could leak geventpool DB checkouts outside HTTP requests.** With `django-db-geventpool`, `connection.close()` returns handles to the per-worker pool (`MAX_CONNS=8`); without it, greenlets and OS threads keep connections checked out until the pool blocks on `pool.get()`. Proxy paths that touch the ORM outside Django's request cycle now call `close_old_connections()` after work completes: `_clean_redis_keys()`, profile lookup in `_establish_transcode_connection()` before spawning ffmpeg, and fMP4 client disconnect cleanup when releasing streams (TS disconnect relies on `log_system_event()`). (Fixes #1345)
+- **System events could block callers on Connect and plugin handlers.** `log_system_event()` ran Connect subscriptions and plugin `"events"` hooks synchronously after the DB write, so slow integrations could stall live-proxy and streaming paths even when inserting the event row was fast. Connect/plugin dispatch now runs on a separate gevent when the hub is available (synchronously in Celery workers without a hub). `log_system_event()` and `dispatch_event_system()` also call `close_old_connections()` in `finally` blocks so integration work does not leave pool slots checked out on the caller or dispatch greenlet.
+- **Plugins could leak geventpool DB checkouts after UI or Connect event runs.** Third-party plugins run inline on uWSGI greenlets (manual actions and Connect `"events"` hooks) with no guaranteed connection cleanup at the plugin boundary. `PluginManager.run_action()` and `stop_plugin()` now call `close_old_connections()` in a `finally` block so each action returns its pool slot whether the plugin succeeds or raises.
+- **Connect events repeatedly queried the full plugin catalog during streaming.** `trigger_event()` called `list_plugins()` on every `client_connect` / `client_disconnect`, loading all `PluginConfig` rows and sometimes hitting plugin-repo work even when no plugin subscribed to the event. Dispatch now walks the in-memory registry via `iter_actions_for_event()`, returns immediately when no handlers exist, and runs a single batched `enabled` lookup for matching plugins only. Failed plugin actions are logged per handler instead of aborting the rest.
+- **Plugin discovery left idle Postgres backends after worker boot.** `discover_plugins()` runs outside Django's request cycle during uWSGI and Celery startup; it now calls `close_old_connections()` in a `finally` block so bootstrap `PluginConfig` queries return their pool slot instead of appearing as long-lived idle connections in `pg_stat_activity`.
+- **VOD proxy could leak geventpool DB checkouts during playback and stats updates.** `stream_vod()` ran ORM lookups for content and M3U profiles, then returned a long-lived `StreamingHttpResponse` without releasing the checkout, so each movie/episode stream could hold a pool slot for its full duration. Background VOD stats refresh (`build_vod_stats_data()`, triggered on start/stop and by the admin stats API) also queried movie, episode, and profile rows from daemon threads with no cleanup. `stream_vod()` now calls `close_old_connections()` before handing off to the streaming generator, and `build_vod_stats_data()` releases its checkout in a `finally` block.
+- **Channel shutdown delay did not reset after a reconnect within the grace period.** `handle_client_disconnect()` used a fixed `gevent.sleep(shutdown_delay)` from the first last-client disconnect. If a client reconnected and disconnected again during the delay, an earlier disconnect handler could still stop the channel on the original timer instead of waiting the full delay from the latest disconnect. Shutdown now polls Redis (`last_client_disconnect` timestamp and client count) so concurrent disconnect handlers and multi-worker reconnects always honour the latest disconnect time.
+- **Zombie ffmpeg could survive owner-lock expiry and orphan Redis sweeps.** When the 30s owner lock lapsed under single-worker load, disconnect handling treated the worker as non-owner so coordinated stop never ran, while ffmpeg kept writing and the orphan sweeper only deleted Redis keys (recreating them immediately). Disconnect now re-acquires ownership when local upstream is still active, stops locally when the last client leaves without a lock, orphan cleanup stops local ffmpeg before Redis deletion via `_has_local_upstream_activity`, re-init stops lingering upstream before starting a duplicate thread, and `is_channel_teardown_active` includes channels mid-`stop_channel` on this worker so rapid reconnect gets 503 during teardown.
+- **Stale `channel_stream` Redis keys after a channel stopped could skip connection accounting on retune.** On `dev`, `get_stream()` reused any existing `channel_stream` / `stream_profile` assignment without reserving a new slot. If those keys were left behind after a stop, the next tune-in could reach the provider without incrementing Redis counters. `get_stream()` now releases stale assignments when proxy metadata shows the channel is inactive, then reserves fresh slots.
+- **EPG auto-match reliability fixes.**
+  - Memory could spike to multiple GB on large EPG sources when building a full in-memory catalog before fuzzy matching; single-channel matching now streams rows and bounds ML work to a small candidate set.
+  - Wrong channel assignments from global ML similarity; ML validation now checks the fuzzy best match (or top fuzzy candidates as a last resort) instead of scoring the entire catalog.
+  - Channel form auto-match spinner could stick after errors or early task exits; all single-channel outcomes now push a WebSocket result, and the UI clears loading state after a 3-minute timeout.
+  - Bulk auto-match completion no longer calls `batch-set-epg` from the WebSocket handler, which had been re-applying every match and queueing redundant `parse_programs_for_tvg_id` tasks even when assignments were unchanged.
+- **Schedules Direct lineup search country dropdown.** The country list was fetched directly from the SD API in the browser, which failed due to CORS and silently fell back to a 14-country hardcoded list. Countries are now included in the `GET sd-lineups` response (server-side fetch with proper User-Agent) so the full SD country list populates correctly. — Thanks [@sethwv](https://github.com/sethwv)
+- **Schedules Direct program poster proxy omitted User-Agent on image requests.** The poster endpoint authenticated with SD correctly but fetched images with only the `token` header, which violates SD's API requirements (error 1003). Image requests now include the standard `Dispatcharr/{version}` User-Agent via `dispatcharr_http_headers()`.
+- **Schedules Direct guide data missing after mapping a channel.** Lineup refreshes cached schedule MD5s for all stations, but `ProgramData` was only written for mapped channels. Mapping a channel later could leave MD5s looking unchanged so schedules were skipped and the channel had no guide until dates rolled outside the cached window. Refreshes now backfill fetch-window dates that lack `ProgramData` (including newly mapped stations with stale cache), fetch program metadata when no local `ProgramData` exists for a `programID`, and clean up orphaned `ProgramData` on unmapped `EPGData` entries. — Thanks [@sethwv](https://github.com/sethwv)
+- **Schedules Direct guide fetch on channel map.** Mapping a channel (or bulk-assigning EPG) now triggers a targeted guide fetch for that `EPGData` entry—mirroring XMLTV's `parse_programs_for_tvg_id` flow—without waiting for the next full source refresh. Skips the fetch when `ProgramData` already exists so additional channels sharing the same `tvg-id` do not trigger redundant API calls. Bulk assignment of three or more SD stations without guide data on the same source queues one batched mapped-station fetch instead of separate per-station API sessions. Concurrent batch and single-EPG fetches coordinate via source-level locks with deferred retries so mappings are not dropped and overlapping SD API sessions are avoided when possible.
+- **Auto-sync numbering modes now read only the fields each mode's UI exposes.** After the auto-sync overhaul, switching between Provider, Next Available, and Fixed modes left stale `auto_sync_channel_start` / `auto_sync_channel_end` values in the database while each mode's UI only edits a subset of those fields. Sync treated the hidden values as authoritative in every mode, which discarded valid provider numbers (floored at an auto-computed start), capped Next Available at a stale End, and ran range-enforcement deletes against provider- and next-available-numbered channels. Provider mode now honors `stream_chno` verbatim when free (Start/End bound only the fallback for numberless streams); Next Available ignores End; overflow-delete runs in Fixed mode only. Duplicate or already-taken provider numbers fall back to a free slot instead of being dropped or overwriting an existing channel. Provider mode's Start # field now drops End when it would invert the fallback range (matching Fixed mode). (Closes #1273) — Thanks [@CodeBormen](https://github.com/CodeBormen)
+
 ## [0.26.0] - 2026-06-07
 
 ### Added
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 725e21e8..6da68a61 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -144,7 +144,19 @@ Untested code is significantly less likely to be merged.
 
 - Use Django's `TestCase` for unit/integration tests.
 - Test files live at `apps/<app>/tests/`.
-- Run the test suite with: `uv run python manage.py test`
+- Run the backend test suite with:
+
+  ```bash
+  python manage.py test
+  ```
+
+  `manage.py` automatically uses `dispatcharr.settings_test`, which creates an empty PostgreSQL database `test_<dbname>` (same engine as production), runs migrations, and rolls back each test in a transaction. Your live VOD/channels data is not used.
+
+  Optional: `TEST_USE_SQLITE=1` for machines without Postgres (some PostgreSQL-only tests skip automatically).
+
+  Tests that exercise Celery task bodies should use `@override_settings(CELERY_TASK_ALWAYS_EAGER=True)` locally. Global eager mode is off because `post_save` signals on M3U/EPG models call `.delay()` and would break `TestCase` transaction isolation.
+
+- Do **not** override with `--settings=dispatcharr.settings` on a live instance.
 
 ### Frontend
 
diff --git a/Plugin_repo.md b/Plugin_repo.md
index 1e02efb7..608233a3 100644
--- a/Plugin_repo.md
+++ b/Plugin_repo.md
@@ -120,12 +120,14 @@ If the name contains any of these, the repo will be rejected on add and skipped
 
 ### Top-Level Metadata
 
-| Field           | Required | Description                                                                                                                                                                   |
-| --------------- | -------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `registry_name` | **Yes**  | Display name for the repo. Must not contain words like "official" or "dispatcharr" that could be mistaken for an official repo (see [Name Restrictions](#name-restrictions)). |
-| `registry_url`  | No       | URL to the repo's home page (e.g. GitHub). Used as a fallback for generating icon URLs.                                                                                       |
-| `root_url`      | No       | Base URL for resolving relative URLs in plugin entries. Trailing slashes are stripped.                                                                                        |
-| `plugins`       | **Yes**  | Array of plugin entry objects.                                                                                                                                                |
+| Field                | Required | Description                                                                                                                                                                                                          |
+| -------------------- | -------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `registry_name`      | **Yes**  | Display name for the repo. Must not contain words like "official" or "dispatcharr" that could be mistaken for an official repo (see [Name Restrictions](#name-restrictions)).                                        |
+| `registry_url`       | No       | URL to the repo's home page (e.g. GitHub). Used as a fallback for generating icon URLs.                                                                                                                              |
+| `root_url`           | No       | Generic base URL for resolving all relative URLs in plugin entries. Trailing slashes are stripped. Used as the fallback when neither `download_base_url` nor `metadata_base_url` is set.                             |
+| `download_base_url`  | No       | Base URL for resolving relative download URLs (`latest_url` in plugin entries; `url` and `latest_url` inside per-plugin manifest `versions`/`latest`). Overrides `root_url` for download assets when set.           |
+| `metadata_base_url`  | No       | Base URL for resolving relative metadata URLs (`manifest_url` and `icon_url` in plugin entries). Overrides `root_url` for metadata assets when set.                                                                 |
+| `plugins`            | **Yes**  | Array of plugin entry objects.                                                                                                                                                                                       |
 
 ### Plugin Entry Fields
 
@@ -155,13 +157,18 @@ Extra fields in a plugin entry are passed through to the frontend as-is, so you
 
 ### URL Resolution
 
-If `root_url` is set and a URL field (`manifest_url`, `latest_url`, `icon_url`) does not start with `http://` or `https://`, it is treated as relative and resolved as:
+Relative URL fields are resolved against a base URL. Dispatcharr uses two separate base URLs (one for metadata assets and one for download assets) so you can serve them from different origins (e.g., manifests and icons on GitHub Pages, release zips on a CDN).
 
-```
-{root_url}/{field_value}
-```
+**Resolution priority:**
 
-This lets you keep plugin entries compact:
+| Field(s) | Priority |
+| --------- | -------- |
+| `manifest_url`, `icon_url` | `metadata_base_url` → `root_url` |
+| `latest_url` (plugin entries); `url`, `latest_url` (per-plugin manifest versions/latest) | `download_base_url` → `root_url` |
+
+A field value is treated as relative if it does not start with `http://` or `https://`. Relative values are resolved as `{base_url}/{field_value}`. All base URL fields are optional; if none are set, URL fields must be absolute.
+
+**Single base URL (simplest):** use `root_url` for everything:
 
 ```json
 {
@@ -177,12 +184,45 @@ This lets you keep plugin entries compact:
 }
 ```
 
-**Icon fallback:** If `icon_url` is missing and `registry_url` is set, Dispatcharr generates a fallback URL by converting the GitHub URL to a raw content URL:
+**Split base URLs:** use `metadata_base_url` and `download_base_url` when assets are served from different origins:
 
+```json
+{
+  "metadata_base_url": "https://raw.githubusercontent.com/myorg/my-plugins/main",
+  "download_base_url": "https://cdn.example.com/releases",
+  "plugins": [
+    {
+      "slug": "my_plugin",
+      "manifest_url": "plugins/my_plugin/manifest.json",
+      "icon_url": "plugins/my_plugin/logo.png",
+      "latest_url": "my_plugin/my_plugin-1.0.0.zip"
+    }
+  ]
+}
 ```
-{registry_url => raw.githubusercontent.com}/refs/heads/main/plugins/{slug}/logo.png
+
+You can also combine `root_url` with one specific field. The specific field overrides for its consumers, and `root_url` covers the rest:
+
+```json
+{
+  "root_url": "https://raw.githubusercontent.com/myorg/my-plugins/main",
+  "download_base_url": "https://cdn.example.com/releases"
+}
 ```
 
+**Icon fallback:** If `icon_url` is missing, Dispatcharr tries two fallbacks in order:
+
+1. **Manifest-directory fallback**: if a base URL is set (`root_url`, `metadata_base_url`, etc.) and `manifest_url` is present, the logo is assumed to live in the same directory as the per-plugin manifest:
+   ```
+   {directory of resolved manifest_url}/logo.png
+   ```
+   For example, if `manifest_url` resolves to `https://example.com/plugins/my_plugin/manifest.json`, the fallback icon URL is `https://example.com/plugins/my_plugin/logo.png`.
+
+2. **GitHub fallback**: if `registry_url` is a GitHub URL, Dispatcharr converts it to a raw content URL:
+   ```
+   {registry_url => raw.githubusercontent.com}/refs/heads/main/plugins/{slug}/logo.png
+   ```
+
 ---
 
 ## Per-Plugin Manifest (Optional)
@@ -563,7 +603,9 @@ You can host release zips as GitHub Release assets and reference them with absol
   "manifest": {
     "registry_name": "string (required)",
     "registry_url": "string (optional)",
-    "root_url": "string (optional)",
+    "root_url": "string (optional, generic base URL fallback)",
+    "download_base_url": "string (optional, overrides root_url for zip download URLs)",
+    "metadata_base_url": "string (optional, overrides root_url for manifest_url and icon_url)",
     "plugins": [
       {
         "slug": "string (required)",
diff --git a/Plugins.md b/Plugins.md
index d528f1e4..4dc15a55 100644
--- a/Plugins.md
+++ b/Plugins.md
@@ -307,6 +307,18 @@ Plugins are server-side Python code running within the Django application. You c
 
 Prefer Celery tasks (`.delay()`) to keep `run` fast and non-blocking.
 
+### Database connections
+
+Dispatcharr uses `django-db-geventpool` with a bounded per-uWSGI-worker pool (`MAX_CONNS=8`). Each greenlet or OS thread that runs ORM code checks out a connection until Django closes it.
+
+`PluginManager.run_action()` and `stop_plugin()` always call `close_old_connections()` in a `finally` block after your plugin returns (success or error). That returns the current greenlet's checkout to the pool. **You do not need to call `close_old_connections()` yourself for normal inline ORM inside `run()` or `stop()`.**
+
+Still follow these rules:
+
+- **Heavy or long work:** dispatch a Celery task (`.delay()`) and return quickly from `run()`. Celery workers close connections after each task; blocking the uWSGI gevent hub with `time.sleep`, sync HTTP, or large CPU work can freeze the whole worker regardless of DB cleanup.
+- **Background threads or greenlets you spawn:** each thread/greenlet that uses the ORM must call `close_old_connections()` (or `connection.close()`) in its own `finally` block when done. The wrapper only covers the thread/greenlet that called `run_action()`.
+- **Connect event hooks:** actions with an `"events"` list are dispatched from `log_system_event()` on a separate gevent when uWSGI has an active hub (otherwise synchronously, e.g. Celery). Keep handlers short or defer heavy work to Celery.
+
 ### Important: Don’t Ask Users for URL/User/Password
 Dispatcharr plugins run **inside** the Dispatcharr backend process. That means they already have direct access to the app’s models, tasks, and internal utilities.  
 Plugins **should not** ask users for “Dispatcharr URL”, “Admin Username”, or “Admin Password” just to call the API. That is unnecessary and unsafe because:
diff --git a/apps/accounts/authentication.py b/apps/accounts/authentication.py
index e8551e5d..c472028f 100644
--- a/apps/accounts/authentication.py
+++ b/apps/accounts/authentication.py
@@ -93,7 +93,8 @@ class QueryParamJWTAuthentication(JWTAuthentication):
     where the browser cannot set Authorization headers (e.g. <video src>)."""
 
     def authenticate(self, request):
-        raw_token = request.GET.get('token')
+        params = getattr(request, "query_params", request.GET)
+        raw_token = params.get("token")
         if not raw_token:
             return None
         try:
diff --git a/apps/channels/api_urls.py b/apps/channels/api_urls.py
index ff00e0f7..036bc50d 100644
--- a/apps/channels/api_urls.py
+++ b/apps/channels/api_urls.py
@@ -13,6 +13,7 @@ from .api_views import (
     UpdateChannelMembershipAPIView,
     BulkUpdateChannelMembershipAPIView,
     RecordingViewSet,
+    RECORDING_PLAYBACK_AUTHENTICATORS,
     RecurringRecordingRuleViewSet,
     GetChannelStreamsAPIView,
     GetChannelStreamStatsAPIView,
@@ -53,7 +54,10 @@ urlpatterns = [
     path('recordings/bulk-delete-upcoming/', BulkDeleteUpcomingRecordingsAPIView.as_view(), name='bulk_delete_upcoming_recordings'),
     path(
         'recordings/<int:pk>/hls/<path:seg_path>',
-        RecordingViewSet.as_view({'get': 'hls'}),
+        RecordingViewSet.as_view(
+            {'get': 'hls'},
+            authentication_classes=RECORDING_PLAYBACK_AUTHENTICATORS,
+        ),
         name='recording-hls',
     ),
     path('dvr/comskip-config/', ComskipConfigAPIView.as_view(), name='comskip_config'),
diff --git a/apps/channels/api_views.py b/apps/channels/api_views.py
index 9fd47400..fd8a4758 100644
--- a/apps/channels/api_views.py
+++ b/apps/channels/api_views.py
@@ -3,6 +3,8 @@ from rest_framework.response import Response
 from rest_framework.views import APIView
 from rest_framework.permissions import AllowAny
 from rest_framework.decorators import action
+from rest_framework_simplejwt.authentication import JWTAuthentication
+from apps.accounts.authentication import ApiKeyAuthentication, QueryParamJWTAuthentication
 from rest_framework.parsers import MultiPartParser, FormParser, JSONParser
 from drf_spectacular.utils import extend_schema, OpenApiParameter, inline_serializer
 from drf_spectacular.types import OpenApiTypes
@@ -12,6 +14,7 @@ from django.db import connection, transaction
 from django.db.models import Count, F, Prefetch
 from django.db.models import Q
 import os, json, requests, logging, mimetypes, threading, time
+from urllib.parse import urlencode
 from datetime import timedelta
 from django.utils.http import http_date
 from apps.accounts.permissions import (
@@ -2087,7 +2090,7 @@ class ChannelViewSet(viewsets.ModelViewSet):
             fields={
                 'channel_ids': serializers.ListField(
                     child=serializers.IntegerField(),
-                    help_text='List of channel IDs to process. If empty or not provided, all channels without EPG will be processed.',
+                    help_text='List of channel IDs to process (includes channels that already have EPG). If empty or not provided, only channels without EPG are processed.',
                     required=False,
                 )
             }
@@ -2120,23 +2123,15 @@ class ChannelViewSet(viewsets.ModelViewSet):
     def match_channel_epg(self, request, pk=None):
         channel = self.get_object()
 
-        # Import the matching logic
-        from apps.channels.tasks import match_single_channel_epg
-
-        try:
-            # Try to match this specific channel - call synchronously for immediate response
-            result = match_single_channel_epg.apply_async(args=[channel.id]).get(timeout=30)
-
-            # Refresh the channel from DB to get any updates
-            channel.refresh_from_db()
-
-            return Response({
-                "message": result.get("message", "Channel matching completed"),
-                "matched": result.get("matched", False),
-                "channel": self.get_serializer(channel).data
-            })
-        except Exception as e:
-            return Response({"error": str(e)}, status=400)
+        match_single_channel_epg.delay(channel.id)
+        return Response(
+            {
+                "message": f"EPG matching started for channel '{channel.name}'",
+                "accepted": True,
+                "channel_id": channel.id,
+            },
+            status=status.HTTP_202_ACCEPTED,
+        )
 
     # ─────────────────────────────────────────────────────────
     # 7) Set EPG and Refresh
@@ -2171,22 +2166,14 @@ class ChannelViewSet(viewsets.ModelViewSet):
 
             epg_data = EPGData.objects.get(pk=epg_data_id)
 
-            # Set the EPG data and save
+            # Set the EPG data and save. refresh_epg_programs (post_save) queues
+            # parse_programs_for_tvg_id for non-dummy sources — no second dispatch here.
             channel.epg_data = epg_data
             channel.save(update_fields=["epg_data"])
 
-            # Only trigger program refresh for non-dummy EPG sources
             status_message = None
             if epg_data.epg_source.source_type != 'dummy':
-                # Explicitly trigger program refresh for this EPG
-                from apps.epg.tasks import parse_programs_for_tvg_id
-
-                task_result = parse_programs_for_tvg_id.delay(epg_data.id)
-
-                # Prepare response with task status info
                 status_message = "EPG refresh queued"
-                if task_result.result == "Task already running":
-                    status_message = "EPG refresh already in progress"
 
             # Build response message
             message = f"EPG data set to {epg_data.tvg_id} for channel {channel.name}"
@@ -2321,7 +2308,6 @@ class ChannelViewSet(viewsets.ModelViewSet):
 
         # Extract channel IDs upfront
         channel_updates = {}
-        unique_epg_ids = set()
 
         for assoc in associations:
             channel_id = assoc.get("channel_id")
@@ -2331,24 +2317,28 @@ class ChannelViewSet(viewsets.ModelViewSet):
                 continue
 
             channel_updates[channel_id] = epg_data_id
-            if epg_data_id:
-                unique_epg_ids.add(epg_data_id)
 
         # Batch fetch all channels (single query)
         channels_dict = {
             c.id: c for c in Channel.objects.filter(id__in=channel_updates.keys())
         }
 
-        # Collect channels to update
+        # Collect channels whose EPG assignment actually changes
         channels_to_update = []
+        changed_epg_ids = set()
         for channel_id, epg_data_id in channel_updates.items():
             if channel_id not in channels_dict:
                 logger.error(f"Channel with ID {channel_id} not found")
                 continue
 
             channel = channels_dict[channel_id]
+            if channel.epg_data_id == epg_data_id:
+                continue
+
             channel.epg_data_id = epg_data_id
             channels_to_update.append(channel)
+            if epg_data_id:
+                changed_epg_ids.add(epg_data_id)
 
         # Bulk update all channels (single query)
         if channels_to_update:
@@ -2361,27 +2351,9 @@ class ChannelViewSet(viewsets.ModelViewSet):
 
         channels_updated = len(channels_to_update)
 
-        # Trigger program refresh for unique EPG data IDs (skip dummy EPGs)
-        from apps.epg.tasks import parse_programs_for_tvg_id
-        from apps.epg.models import EPGData
+        from apps.epg.tasks import dispatch_program_refresh_for_epg_ids
 
-        # Batch fetch EPG data (single query)
-        epg_data_dict = {
-            epg.id: epg
-            for epg in EPGData.objects.filter(id__in=unique_epg_ids).select_related('epg_source')
-        }
-
-        programs_refreshed = 0
-        for epg_id in unique_epg_ids:
-            epg_data = epg_data_dict.get(epg_id)
-            if not epg_data:
-                logger.error(f"EPGData with ID {epg_id} not found")
-                continue
-
-            # Only refresh non-dummy EPG sources
-            if epg_data.epg_source.source_type != 'dummy':
-                parse_programs_for_tvg_id.delay(epg_id)
-                programs_refreshed += 1
+        programs_refreshed = dispatch_program_refresh_for_epg_ids(changed_epg_ids)
 
         return Response(
             {
@@ -2805,8 +2777,9 @@ class LogoViewSet(viewsets.ModelViewSet):
                     user_agent_obj = UserAgent.objects.get(id=int(default_user_agent_id))
                     user_agent = user_agent_obj.user_agent
                 except (CoreSettings.DoesNotExist, UserAgent.DoesNotExist, ValueError):
-                    # Fallback to hardcoded if default not found
-                    user_agent = 'Dispatcharr/1.0'
+                    # Fallback if default not found
+                    from core.utils import dispatcharr_user_agent
+                    user_agent = dispatcharr_user_agent()
 
                 # Hard total timeout (connect + full download) prevents a slow
                 # server dripping bytes from holding a greenlet indefinitely.
@@ -3266,12 +3239,41 @@ def _stop_dvr_clients(channel_uuid, recording_id=None):
     return stopped
 
 
+# QueryParamJWTAuthentication supports native <video src> clients that cannot
+# send Authorization headers. Authorization still requires an authenticated
+# user via _user_can_play_recording; these classes only populate request.user.
+RECORDING_PLAYBACK_AUTHENTICATORS = [
+    JWTAuthentication,
+    ApiKeyAuthentication,
+    QueryParamJWTAuthentication,
+]
+
+
+def _recording_auth_query_suffix(request):
+    """Suffix for rewritten recording URLs when auth used ?token= (native <video>).
+
+    hls.js clients authenticate via Authorization on each XHR and do not need
+    tokens embedded in playlist segment lines.
+    """
+    from rest_framework.request import Request as DRFRequest
+
+    if isinstance(request, DRFRequest):
+        params = request.query_params
+    else:
+        params = request.GET
+    token = params.get("token")
+    if not token:
+        return ""
+    return "?" + urlencode({"token": token})
+
+
 class RecordingViewSet(viewsets.ModelViewSet):
     queryset = Recording.objects.all()
     serializer_class = RecordingSerializer
 
     def get_permissions(self):
-        # Allow unauthenticated playback of recording files (like other streaming endpoints)
+        # file/hls use AllowAny so DRF does not reject requests before auth
+        # classes run; _user_can_play_recording enforces authenticated access.
         if self.action in ('file', 'hls'):
             return [AllowAny()]
         try:
@@ -3335,7 +3337,12 @@ class RecordingViewSet(viewsets.ModelViewSet):
         except Exception as e:
             return Response({"success": False, "error": str(e)}, status=400)
 
-    @action(detail=True, methods=["get"], url_path="file")
+    @action(
+        detail=True,
+        methods=["get"],
+        url_path="file",
+        authentication_classes=RECORDING_PLAYBACK_AUTHENTICATORS,
+    )
     def file(self, request, pk=None):
         """Stream a completed recording file with HTTP Range support for seeking.
 
@@ -3359,7 +3366,7 @@ class RecordingViewSet(viewsets.ModelViewSet):
             if hls_dir and os.path.isdir(hls_dir):
                 hls_url = request.build_absolute_uri(
                     f"/api/channels/recordings/{pk}/hls/index.m3u8"
-                )
+                ) + _recording_auth_query_suffix(request)
                 return HttpResponseRedirect(hls_url)
             if not file_path or not os.path.exists(file_path):
                 raise Http404("Recording file not found")
@@ -3423,7 +3430,12 @@ class RecordingViewSet(viewsets.ModelViewSet):
         response["Content-Disposition"] = f"inline; filename=\"{file_name}\""
         return response
 
-    @action(detail=True, methods=["get"], url_path="hls/(?P<seg_path>.+)")
+    @action(
+        detail=True,
+        methods=["get"],
+        url_path="hls/(?P<seg_path>.+)",
+        authentication_classes=RECORDING_PLAYBACK_AUTHENTICATORS,
+    )
     def hls(self, request, pk=None, seg_path=None):
         """Serve HLS playlist and segment files for an in-progress (or completed) recording.
 
@@ -3447,9 +3459,10 @@ class RecordingViewSet(viewsets.ModelViewSet):
             cp = recording.custom_properties or {}
             file_path = cp.get("file_path")
             if seg_path.endswith(".m3u8") and file_path and os.path.exists(file_path) and os.path.getsize(file_path) > 0:
-                return HttpResponseRedirect(
-                    request.build_absolute_uri(f"/api/channels/recordings/{pk}/file/")
-                )
+                file_url = request.build_absolute_uri(
+                    f"/api/channels/recordings/{pk}/file/"
+                ) + _recording_auth_query_suffix(request)
+                return HttpResponseRedirect(file_url)
             raise Http404("HLS content not available for this recording")
 
         # Security: prevent path traversal outside the HLS directory
@@ -3462,16 +3475,18 @@ class RecordingViewSet(viewsets.ModelViewSet):
             raise Http404(f"HLS file not found: {seg_path}")
 
         if seg_path.endswith(".m3u8"):
-            # Rewrite relative segment lines to absolute URLs through this API
+            # Rewrite relative segment lines to absolute URLs through this API.
+            # Propagate ?token= only for native <video> clients (see helper).
             base_url = request.build_absolute_uri(
                 f"/api/channels/recordings/{pk}/hls/"
             )
+            auth_suffix = _recording_auth_query_suffix(request)
             lines = []
             with open(requested) as _f:
                 for line in _f:
                     stripped = line.strip()
                     if stripped and not stripped.startswith("#"):
-                        lines.append(f"{base_url}{stripped}\n")
+                        lines.append(f"{base_url}{stripped}{auth_suffix}\n")
                     else:
                         lines.append(line)
             return HttpResponse("".join(lines), content_type="application/x-mpegURL")
diff --git a/apps/channels/compact_numbering.py b/apps/channels/compact_numbering.py
index fd29a153..27a26cb6 100644
--- a/apps/channels/compact_numbering.py
+++ b/apps/channels/compact_numbering.py
@@ -25,7 +25,8 @@ import logging
 from django.db import transaction
 
 from .models import Channel, ChannelOverride, ChannelGroupM3UAccount
-from apps.m3u.tasks import _custom_properties_as_dict, _next_available_number
+from apps.m3u.tasks import _next_available_number
+from core.utils import ensure_custom_properties_dict
 from core.utils import (
     acquire_task_lock,
     natural_sort_key,
@@ -37,7 +38,7 @@ logger = logging.getLogger(__name__)
 
 def is_compact_group(group_relation):
     """Return True if the given ChannelGroupM3UAccount is in compact mode."""
-    cp = _custom_properties_as_dict(group_relation.custom_properties)
+    cp = ensure_custom_properties_dict(group_relation.custom_properties)
     return bool(cp.get("compact_numbering"))
 
 
@@ -72,7 +73,7 @@ def get_group_relation_for_channel(channel):
     for rel in ChannelGroupM3UAccount.objects.filter(
         m3u_account_id=channel.auto_created_by_id
     ):
-        cp = _custom_properties_as_dict(rel.custom_properties)
+        cp = ensure_custom_properties_dict(rel.custom_properties)
         if str(cp.get("group_override", "")) == target:
             return rel
     return None
@@ -179,7 +180,7 @@ def assign_compact_numbers_for_channels(channel_ids):
         for rel in ChannelGroupM3UAccount.objects.filter(
             m3u_account_id__in={k[0] for k in unresolved}
         ):
-            cp = _custom_properties_as_dict(rel.custom_properties)
+            cp = ensure_custom_properties_dict(rel.custom_properties)
             target = cp.get("group_override")
             if not target:
                 continue
@@ -295,7 +296,7 @@ def _repack_inner(group_relation):
     account_id = group_relation.m3u_account_id
     group_id = group_relation.channel_group_id
 
-    cp = _custom_properties_as_dict(group_relation.custom_properties)
+    cp = ensure_custom_properties_dict(group_relation.custom_properties)
     sort_order = cp.get("channel_sort_order") or ""
     sort_reverse = bool(cp.get("channel_sort_reverse"))
 
diff --git a/apps/channels/epg_matching.py b/apps/channels/epg_matching.py
new file mode 100644
index 00000000..76e17c06
--- /dev/null
+++ b/apps/channels/epg_matching.py
@@ -0,0 +1,927 @@
+"""
+EPG channel matching: fuzzy scoring, optional ML validation, and UI notifications.
+
+Celery tasks in tasks.py call into this module; keep orchestration here and
+task wiring thin so matching logic stays testable without a worker.
+"""
+import gc
+import heapq
+import logging
+import os
+import re
+
+from rapidfuzz import fuzz
+
+from apps.epg.models import EPGData
+from core.models import CoreSettings
+from core.utils import send_websocket_update
+
+logger = logging.getLogger(__name__)
+
+_ml_model_cache = {'sentence_transformer': None}
+_normalize_settings_cache = None
+
+ML_CANDIDATE_LIMIT = 20
+SINGLE_CHANNEL_MATCH_TIMEOUT_MS = 180_000
+
+COMMON_EXTRANEOUS_WORDS = [
+    "tv", "channel", "network", "television",
+    "east", "west", "hd", "uhd", "24/7",
+    "1080p", "720p", "540p", "480p",
+    "film", "movie", "movies",
+]
+
+
+def release_ml_models():
+    """Unload sentence transformer and encourage PyTorch to release memory."""
+    if _ml_model_cache['sentence_transformer'] is None:
+        return
+    logger.info("Cleaning up ML models from memory")
+    model = _ml_model_cache['sentence_transformer']
+    _ml_model_cache['sentence_transformer'] = None
+    del model
+    try:
+        import torch
+        if hasattr(torch, 'cuda') and torch.cuda.is_available():
+            torch.cuda.empty_cache()
+    except ImportError:
+        pass
+    gc.collect()
+
+
+def clear_normalize_settings_cache():
+    """Reset cached normalization settings after a matching run."""
+    global _normalize_settings_cache
+    _normalize_settings_cache = None
+
+
+def cleanup_after_matching():
+    """Release ML models and normalization cache after a matching run."""
+    release_ml_models()
+    clear_normalize_settings_cache()
+
+
+def get_sentence_transformer():
+    """Lazy load the sentence transformer model only when needed."""
+    if _ml_model_cache['sentence_transformer'] is None:
+        try:
+            from sentence_transformers import SentenceTransformer
+            from sentence_transformers import util
+
+            model_name = "sentence-transformers/all-MiniLM-L6-v2"
+            cache_dir = "/data/models"
+            disable_downloads = os.environ.get('DISABLE_ML_DOWNLOADS', 'false').lower() == 'true'
+
+            if disable_downloads:
+                hf_model_path = os.path.join(cache_dir, f"models--{model_name.replace('/', '--')}")
+                if not os.path.exists(hf_model_path):
+                    logger.warning(
+                        "ML model not found and downloads disabled (DISABLE_ML_DOWNLOADS=true). "
+                        "Skipping ML matching."
+                    )
+                    return None, None
+
+            os.makedirs(cache_dir, exist_ok=True)
+            logger.info(f"Loading sentence transformer model (cache: {cache_dir})")
+            _ml_model_cache['sentence_transformer'] = SentenceTransformer(
+                model_name,
+                cache_folder=cache_dir,
+            )
+            return _ml_model_cache['sentence_transformer'], util
+        except ImportError:
+            logger.warning("sentence-transformers not available - ML-enhanced matching disabled")
+            return None, None
+        except Exception as e:
+            logger.error(f"Failed to load sentence transformer: {e}")
+            return None, None
+
+    from sentence_transformers import util
+    return _ml_model_cache['sentence_transformer'], util
+
+
+def normalize_name(name: str) -> str:
+    """Normalize a channel/EPG name for fuzzy matching."""
+    if not name:
+        return ""
+
+    global _normalize_settings_cache
+    if _normalize_settings_cache is None:
+        prefixes = []
+        suffixes = []
+        custom_strings = []
+        try:
+            settings = CoreSettings.get_epg_settings()
+            mode = settings.get("epg_match_mode", "default")
+            if mode == "advanced":
+                prefixes = settings.get("epg_match_ignore_prefixes", [])
+                suffixes = settings.get("epg_match_ignore_suffixes", [])
+                custom_strings = settings.get("epg_match_ignore_custom", [])
+                if not isinstance(prefixes, list):
+                    prefixes = []
+                if not isinstance(suffixes, list):
+                    suffixes = []
+                if not isinstance(custom_strings, list):
+                    custom_strings = []
+        except Exception as e:
+            logger.debug(f"Could not load EPG matching settings: {e}")
+        _normalize_settings_cache = (prefixes, suffixes, custom_strings)
+
+    prefixes, suffixes, custom_strings = _normalize_settings_cache
+    result = name
+
+    for prefix in prefixes:
+        if not prefix or not isinstance(prefix, str):
+            continue
+        if result.startswith(prefix):
+            result = result[len(prefix):]
+            break
+
+    for suffix in suffixes:
+        if not suffix or not isinstance(suffix, str):
+            continue
+        if result.endswith(suffix):
+            result = result[:-len(suffix)]
+            break
+
+    for custom in custom_strings:
+        if not custom or not isinstance(custom, str):
+            continue
+        try:
+            result = result.replace(custom, "")
+        except Exception as e:
+            logger.debug(f"Failed to remove custom string '{custom}': {e}")
+
+    norm = result.lower()
+    norm = re.sub(r"\[.*?\]", "", norm)
+
+    call_sign_match = re.search(r"\(([A-Z]{3,5})\)", name)
+    preserved_call_sign = ""
+    if call_sign_match:
+        preserved_call_sign = " " + call_sign_match.group(1).lower()
+
+    norm = re.sub(r"\(.*?\)", "", norm)
+    norm = norm + preserved_call_sign
+    norm = re.sub(r"[^\w\s]", "", norm)
+    tokens = [t for t in norm.split() if t not in COMMON_EXTRANEOUS_WORDS]
+    return " ".join(tokens).strip()
+
+
+def send_epg_matching_progress(total_channels, matched_channels, current_channel_name="", stage="matching"):
+    """Send bulk EPG matching progress via WebSocket."""
+    matched_count = (
+        len(matched_channels) if isinstance(matched_channels, list) else matched_channels
+    )
+    send_websocket_update(
+        'updates',
+        'update',
+        {
+            'type': 'epg_matching_progress',
+            'total': total_channels,
+            'matched': matched_count,
+            'remaining': total_channels - matched_count,
+            'current_channel': current_channel_name,
+            'stage': stage,
+            'progress_percent': round(matched_count / total_channels * 100, 1) if total_channels > 0 else 0,
+        },
+    )
+
+
+def send_single_channel_epg_match_result(channel_id, matched, message, channel=None, epg_data=None):
+    """Notify the UI that a single-channel EPG match attempt has finished."""
+    try:
+        from apps.channels.serializers import ChannelSerializer
+
+        payload = {
+            "type": "single_channel_epg_match",
+            "channel_id": channel_id,
+            "matched": matched,
+            "message": message,
+        }
+        if channel is not None:
+            payload["channel"] = ChannelSerializer(channel).data
+        if epg_data is not None:
+            payload["epg_id"] = epg_data.id
+            payload["epg_name"] = epg_data.name
+
+        send_websocket_update('updates', 'update', payload)
+    except Exception as e:
+        logger.warning(f"Failed to send single channel EPG match result: {e}")
+
+
+def _compute_fuzzy_score(chan_norm, row, region_code=None):
+    """Compute fuzzy match score with optional region bonus/penalty."""
+    if not row.get("norm_name"):
+        return 0
+    base_score = fuzz.ratio(chan_norm, row["norm_name"])
+    bonus = 0
+    if region_code and row.get("tvg_id"):
+        combined_text = row["tvg_id"].lower() + " " + row["name"].lower()
+        dot_regions = re.findall(r'\.([a-z]{2})', combined_text)
+        if dot_regions:
+            bonus = 15 if region_code in dot_regions else -15
+        elif region_code in combined_text:
+            bonus = 10
+    return base_score + bonus
+
+
+def _ml_cosine_similarities(st_model, util, query_text, candidate_texts):
+    """Encode only the query plus candidate texts (not the full EPG database)."""
+    if not candidate_texts:
+        return []
+    texts = [query_text] + list(candidate_texts)
+    embeddings = st_model.encode(texts, convert_to_tensor=True, show_progress_bar=False)
+    sim_scores = util.cos_sim(embeddings[0:1], embeddings[1:])[0]
+    return [float(s) for s in sim_scores]
+
+
+def _active_epg_lookup_queryset():
+    """Lightweight queryset for exact EPG lookups (includes nameless entries)."""
+    return (
+        EPGData.objects
+        .filter(epg_source__is_active=True)
+        .values('id', 'tvg_id', 'name', 'epg_source_id', 'epg_source__priority')
+    )
+
+
+def _active_epg_fuzzy_queryset():
+    """Lightweight queryset for fuzzy EPG matching (requires a display name)."""
+    return (
+        _active_epg_lookup_queryset()
+        .filter(name__isnull=False)
+        .exclude(name='')
+    )
+
+
+def _row_from_epg_values(values_row):
+    tvg_id = values_row.get('tvg_id') or ''
+    normalized_tvg_id = tvg_id.strip().lower() if tvg_id else ''
+    return {
+        'id': values_row['id'],
+        'tvg_id': normalized_tvg_id,
+        'original_tvg_id': tvg_id,
+        'name': values_row['name'],
+        'epg_source_id': values_row['epg_source_id'],
+        'epg_source_priority': values_row.get('epg_source__priority') or 0,
+    }
+
+
+def lookup_epg_by_tvg_id(tvg_id):
+    """Exact tvg_id lookup without loading the full EPG catalog into memory."""
+    if not tvg_id:
+        return None
+    values_row = _active_epg_lookup_queryset().filter(tvg_id__iexact=tvg_id.strip()).first()
+    return _row_from_epg_values(values_row) if values_row else None
+
+
+def build_epg_matching_catalog():
+    """
+    Build the in-memory EPG catalog for bulk matching using a streaming DB cursor.
+
+    Returns (epg_data, tvg_id_index): the full catalog plus an O(1) in-memory
+    tvg_id lookup table (no extra DB queries). The index prefers the first entry
+    per tvg_id after priority sorting.
+    """
+    epg_data = []
+    for values_row in _active_epg_fuzzy_queryset().iterator(chunk_size=500):
+        row = _row_from_epg_values(values_row)
+        row['norm_name'] = normalize_name(row['name'])
+        epg_data.append(row)
+    epg_data.sort(key=lambda x: x['epg_source_priority'], reverse=True)
+    return epg_data, build_epg_tvg_id_index(epg_data)
+
+
+def build_epg_tvg_id_index(epg_data):
+    """
+    Build an in-memory tvg_id -> row index from an EPG catalog (no DB queries).
+    epg_data must be sorted by source priority (highest first) so the first
+    entry wins when multiple sources share the same tvg_id.
+    """
+    index = {}
+    for row in epg_data:
+        tvg_id = row.get("tvg_id")
+        if tvg_id and tvg_id not in index:
+            index[tvg_id] = row
+    return index
+
+
+def _dispatch_program_parse_for_epg_assignments(changed_associations):
+    """
+    Queue guide/program refresh for newly assigned EPG ids.
+
+    bulk_update bypasses post_save, so callers must invoke this when epg_data
+    actually changes (mirrors the M3U sync path).
+    """
+    if not changed_associations:
+        return 0
+
+    from apps.epg.tasks import dispatch_program_refresh_for_epg_ids
+
+    epg_ids = {
+        assoc["epg_data_id"]
+        for assoc in changed_associations
+        if assoc.get("epg_data_id")
+    }
+    return dispatch_program_refresh_for_epg_ids(epg_ids)
+
+
+def _log_unchanged_epg_assignment(chan, epg_id, epg_name, epg_tvg_id, match_method):
+    chan_name = chan.get("name") or f"id={chan['id']}"
+    chan_tvg = chan.get("original_tvg_id") or chan.get("tvg_id") or ""
+    logger.debug(
+        f"Channel '{chan_name}' (id={chan['id']}, tvg_id={chan_tvg!r}) "
+        f"unchanged - already on EPG '{epg_name or '?'}' "
+        f"(id={epg_id}, tvg_id={(epg_tvg_id or '?')!r}, via {match_method})"
+    )
+
+
+def _record_epg_match(
+    chan,
+    epg_id,
+    *,
+    epg_name,
+    epg_tvg_id,
+    match_method,
+    channels_to_update,
+    matched_channels,
+    unchanged_channels,
+):
+    """Record a match result; skip channels_to_update when assignment is already correct."""
+    if chan.get("current_epg_data_id") == epg_id:
+        unchanged_channels.append((chan["id"], chan.get("name") or "", epg_tvg_id or ""))
+        _log_unchanged_epg_assignment(chan, epg_id, epg_name, epg_tvg_id, match_method)
+        return
+
+    chan_name = chan.get("name") or f"id={chan['id']}"
+    chan_tvg = chan.get("original_tvg_id") or chan.get("tvg_id") or ""
+    fallback_name = chan.get("fallback_name") or chan_name
+    chan["epg_data_id"] = epg_id
+    channels_to_update.append(chan)
+    matched_channels.append((chan["id"], fallback_name, epg_tvg_id or ""))
+    logger.info(
+        f"Channel '{chan_name}' (id={chan['id']}, tvg_id={chan_tvg!r}) "
+        f"=> EPG '{epg_name or '?'}' (id={epg_id}, tvg_id={(epg_tvg_id or '?')!r}, via {match_method})"
+    )
+
+
+def apply_matched_epg_to_channels(channels_to_update_dicts):
+    """
+    Assign matched EPG rows to channels using two DB queries (channels + EPG).
+
+    Skips channels that already have the matched EPG. Returns association dicts
+    for channels whose epg_data assignment actually changed, and dispatches
+    program-parse tasks only for those new assignments.
+    """
+    from apps.channels.models import Channel
+
+    if not channels_to_update_dicts:
+        return []
+
+    channel_ids = [d["id"] for d in channels_to_update_dicts]
+    epg_mapping = {d["id"]: d["epg_data_id"] for d in channels_to_update_dicts}
+    epg_ids = {epg_id for epg_id in epg_mapping.values() if epg_id}
+
+    epg_by_id = {epg.id: epg for epg in EPGData.objects.filter(id__in=epg_ids)}
+    channels_list = list(Channel.objects.filter(id__in=channel_ids))
+
+    changed_associations = []
+    channels_to_bulk = []
+    for channel_obj in channels_list:
+        epg_data_id = epg_mapping.get(channel_obj.id)
+        if not epg_data_id:
+            continue
+        if channel_obj.epg_data_id == epg_data_id:
+            epg_row = epg_by_id.get(epg_data_id)
+            _log_unchanged_epg_assignment(
+                {
+                    "id": channel_obj.id,
+                    "name": channel_obj.name,
+                    "original_tvg_id": channel_obj.tvg_id,
+                },
+                epg_data_id,
+                epg_row.name if epg_row else None,
+                epg_row.tvg_id if epg_row else None,
+                "apply",
+            )
+            continue
+        epg_data_obj = epg_by_id.get(epg_data_id)
+        if epg_data_obj:
+            channel_obj.epg_data = epg_data_obj
+            channels_to_bulk.append(channel_obj)
+            changed_associations.append(
+                {"channel_id": channel_obj.id, "epg_data_id": epg_data_id}
+            )
+        else:
+            logger.error(f"EPG data {epg_data_id} not found for channel {channel_obj.id}")
+
+    if channels_to_bulk:
+        Channel.objects.bulk_update(channels_to_bulk, ["epg_data"])
+
+    parse_dispatched = _dispatch_program_parse_for_epg_assignments(changed_associations)
+    if parse_dispatched:
+        logger.info(
+            f"Dispatched {parse_dispatched} EPG program parse task(s) for changed assignments"
+        )
+
+    return changed_associations
+
+
+def get_preferred_region_code():
+    try:
+        region_obj = CoreSettings.objects.get(key="preferred-region")
+        return region_obj.value.strip().lower()
+    except CoreSettings.DoesNotExist:
+        return None
+
+
+def _fuzzy_scan_core(chan_norm, rows, region_code=None, candidate_limit=ML_CANDIDATE_LIMIT):
+    """
+    Single-pass fuzzy scan: track best match and top-K candidates.
+    Rows must already include norm_name when scanning an in-memory catalog.
+    """
+    best_score = 0
+    best_epg = None
+    top_heap = []
+    seq = 0
+    scanned = 0
+
+    for row in rows:
+        if not row.get("norm_name"):
+            continue
+
+        scanned += 1
+        score = _compute_fuzzy_score(chan_norm, row, region_code)
+        if score <= 0:
+            continue
+
+        if score > 50:
+            logger.debug(f"  EPG '{row['name']}' (norm: '{row['norm_name']}') => score: {score}")
+
+        priority = row['epg_source_priority']
+        if score > best_score or (
+            score == best_score
+            and priority > (best_epg.get('epg_source_priority', 0) if best_epg else -1)
+        ):
+            best_score = score
+            best_epg = row
+
+        seq += 1
+        if len(top_heap) < candidate_limit:
+            heapq.heappush(top_heap, (score, priority, seq, row))
+        else:
+            smallest_score, smallest_priority, _, _ = top_heap[0]
+            if score > smallest_score or (score == smallest_score and priority > smallest_priority):
+                heapq.heapreplace(top_heap, (score, priority, seq, row))
+
+    top_candidates = sorted(top_heap, key=lambda item: (item[0], item[1]), reverse=True)
+    return best_score, best_epg, [(score, row) for score, _, _, row in top_candidates], scanned
+
+
+def fuzzy_scan_epg_list(chan_norm, epg_data, region_code=None, candidate_limit=ML_CANDIDATE_LIMIT):
+    """Fuzzy scan over a pre-built in-memory EPG catalog (bulk matching)."""
+    logger.debug(f"Fuzzy matching '{chan_norm}' against EPG entries...")
+    return _fuzzy_scan_core(chan_norm, epg_data, region_code, candidate_limit)
+
+
+def stream_fuzzy_epg_scan(chan_norm, region_code=None, candidate_limit=ML_CANDIDATE_LIMIT):
+    """Stream fuzzy scan over active EPG entries (single-channel matching)."""
+
+    def row_iterator():
+        for values_row in _active_epg_fuzzy_queryset().iterator(chunk_size=500):
+            row = _row_from_epg_values(values_row)
+            row['norm_name'] = normalize_name(row['name'])
+            yield row
+
+    logger.debug(f"Fuzzy matching '{chan_norm}' against EPG entries...")
+    return _fuzzy_scan_core(chan_norm, row_iterator(), region_code, candidate_limit)
+
+
+def _get_epg_match_thresholds(is_bulk_matching):
+    if is_bulk_matching:
+        return {
+            'FUZZY_HIGH_CONFIDENCE': 90,
+            'FUZZY_SKIP_ML': 80,
+            'FUZZY_MEDIUM_CONFIDENCE': 70,
+            'ML_HIGH_CONFIDENCE': 0.75,
+            'ML_LAST_RESORT': 0.65,
+            'FUZZY_LAST_RESORT_MIN': 50,
+        }
+    return {
+        'FUZZY_HIGH_CONFIDENCE': 85,
+        'FUZZY_SKIP_ML': 75,
+        'FUZZY_MEDIUM_CONFIDENCE': 40,
+        'ML_HIGH_CONFIDENCE': 0.65,
+        'ML_LAST_RESORT': 0.50,
+        'FUZZY_LAST_RESORT_MIN': 20,
+    }
+
+
+def try_epg_name_match(chan, best_score, best_epg, top_candidates, is_bulk_matching,
+                       use_ml=True, ml_state=None):
+    """
+    Apply fuzzy/ML thresholds to a channel's best fuzzy result.
+    Returns the matched EPG row dict, or None.
+    """
+    if not best_epg:
+        return None
+
+    thresholds = _get_epg_match_thresholds(is_bulk_matching)
+    fuzzy_high = thresholds['FUZZY_HIGH_CONFIDENCE']
+    fuzzy_skip_ml = thresholds['FUZZY_SKIP_ML']
+    fuzzy_medium = thresholds['FUZZY_MEDIUM_CONFIDENCE']
+    ml_high = thresholds['ML_HIGH_CONFIDENCE']
+    ml_last_resort = thresholds['ML_LAST_RESORT']
+    fuzzy_last_resort_min = thresholds['FUZZY_LAST_RESORT_MIN']
+
+    if best_score >= fuzzy_high:
+        logger.info(
+            f"Channel {chan['id']} '{chan['name']}' => matched tvg_id={best_epg['tvg_id']} "
+            f"(score={best_score})"
+        )
+        return best_epg
+
+    if best_score >= fuzzy_skip_ml:
+        logger.info(
+            f"Channel {chan['id']} '{chan['name']}' => matched tvg_id={best_epg['tvg_id']} "
+            f"(fuzzy={best_score}, ML skipped)"
+        )
+        return best_epg
+
+    if ml_state is None:
+        ml_state = {}
+
+    st_model = ml_state.get('st_model')
+    util = ml_state.get('util')
+
+    if best_score >= fuzzy_medium and use_ml:
+        if st_model is None:
+            st_model, util = get_sentence_transformer()
+            ml_state['st_model'] = st_model
+            ml_state['util'] = util
+
+        if st_model:
+            try:
+                logger.info("Validating fuzzy best match with ML model (single candidate)")
+                sims = _ml_cosine_similarities(st_model, util, chan["norm_chan"], [best_epg["norm_name"]])
+                top_value = sims[0] if sims else 0.0
+
+                if top_value >= ml_high - 1e-9:
+                    logger.info(
+                        f"Channel {chan['id']} '{chan['name']}' => matched EPG tvg_id={best_epg['tvg_id']} "
+                        f"(fuzzy={best_score}, ML-sim={top_value:.2f})"
+                    )
+                    return best_epg
+                if top_value >= ml_last_resort - 1e-9:
+                    logger.info(
+                        f"Channel {chan['id']} '{chan['name']}' => LAST RESORT match EPG "
+                        f"tvg_id={best_epg['tvg_id']} (fuzzy={best_score}, ML-sim={top_value:.2f})"
+                    )
+                    return best_epg
+                logger.info(
+                    f"Channel {chan['id']} '{chan['name']}' => fuzzy={best_score}, "
+                    f"ML-sim={top_value:.2f} < {ml_last_resort}, skipping"
+                )
+            except Exception as e:
+                logger.warning(f"ML matching failed for channel {chan['id']}: {e}")
+                logger.info(
+                    f"Channel {chan['id']} '{chan['name']}' => fuzzy score {best_score} below threshold, skipping"
+                )
+        return None
+
+    if best_score >= fuzzy_last_resort_min and use_ml:
+        if st_model is None:
+            st_model, util = get_sentence_transformer()
+            ml_state['st_model'] = st_model
+            ml_state['util'] = util
+
+        if st_model and top_candidates:
+            try:
+                logger.info(
+                    f"Channel {chan['id']} '{chan['name']}' => trying ML last resort against "
+                    f"top {len(top_candidates)} fuzzy candidates (fuzzy={best_score})"
+                )
+                candidate_rows = [row for _, row in top_candidates]
+                sims = _ml_cosine_similarities(
+                    st_model,
+                    util,
+                    chan["norm_chan"],
+                    [row["norm_name"] for row in candidate_rows],
+                )
+                top_index = max(range(len(sims)), key=lambda i: sims[i])
+                top_value = sims[top_index]
+                matched_epg = candidate_rows[top_index]
+
+                if top_value >= ml_last_resort - 1e-9:
+                    logger.info(
+                        f"Channel {chan['id']} '{chan['name']}' => DESPERATE LAST RESORT match "
+                        f"EPG tvg_id={matched_epg['tvg_id']} (fuzzy={best_score}, ML-sim={top_value:.2f})"
+                    )
+                    return matched_epg
+                logger.info(
+                    f"Channel {chan['id']} '{chan['name']}' => desperate last resort "
+                    f"ML-sim {top_value:.2f} < {ml_last_resort}, giving up"
+                )
+            except Exception as e:
+                logger.warning(f"Last resort ML matching failed for channel {chan['id']}: {e}")
+                logger.info(
+                    f"Channel {chan['id']} '{chan['name']}' => best fuzzy score={best_score} "
+                    f"< {fuzzy_medium}, giving up"
+                )
+        return None
+
+    logger.info(
+        f"Channel {chan['id']} '{chan['name']}' => best fuzzy score={best_score} "
+        f"< {fuzzy_medium}, no ML fallback available"
+    )
+    return None
+
+
+def prepare_channel_match_data(channel):
+    """Build the channel dict used by matching logic."""
+    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 ""
+    )
+    return {
+        "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),
+        "current_epg_data_id": channel.epg_data_id,
+    }
+
+
+def match_channels_to_epg(
+    channels_data,
+    epg_data,
+    region_code=None,
+    use_ml=True,
+    send_progress=True,
+    epg_tvg_id_index=None,
+):
+    """
+    Match channels to EPG rows using exact ID, fuzzy, and optional ML strategies.
+
+    epg_tvg_id_index: optional pre-built tvg_id -> row map from build_epg_matching_catalog().
+    """
+    channels_to_update = []
+    matched_channels = []
+    unchanged_channels = []
+    total_channels = len(channels_data)
+
+    if send_progress:
+        send_epg_matching_progress(total_channels, 0, stage="starting")
+
+    is_bulk_matching = len(channels_data) > 1
+    ml_state = {}
+    epg_by_tvg_id = epg_tvg_id_index if epg_tvg_id_index is not None else build_epg_tvg_id_index(epg_data)
+
+    if is_bulk_matching:
+        logger.info(f"Using conservative thresholds for bulk matching ({total_channels} channels)")
+    else:
+        logger.info("Using aggressive thresholds for single channel matching")
+
+    for index, chan in enumerate(channels_data):
+        normalized_tvg_id = chan.get("tvg_id", "")
+        fallback_name = chan["tvg_id"].strip() if chan["tvg_id"] else chan["name"]
+
+        resolved_count = len(matched_channels) + len(unchanged_channels)
+        if send_progress and (index < 5 or index % 5 == 0 or index == total_channels - 1):
+            send_epg_matching_progress(
+                total_channels,
+                resolved_count,
+                current_channel_name=chan["name"][:50],
+                stage="matching",
+            )
+
+        if normalized_tvg_id:
+            epg_row = epg_by_tvg_id.get(normalized_tvg_id)
+            if epg_row:
+                _record_epg_match(
+                    chan,
+                    epg_row["id"],
+                    epg_name=epg_row.get("name"),
+                    epg_tvg_id=epg_row.get("original_tvg_id") or epg_row.get("tvg_id"),
+                    match_method="exact tvg_id",
+                    channels_to_update=channels_to_update,
+                    matched_channels=matched_channels,
+                    unchanged_channels=unchanged_channels,
+                )
+                continue
+
+        normalized_gracenote_id = chan.get("gracenote_id", "")
+        if normalized_gracenote_id:
+            epg_by_gracenote_id = epg_by_tvg_id.get(normalized_gracenote_id)
+            if epg_by_gracenote_id:
+                _record_epg_match(
+                    chan,
+                    epg_by_gracenote_id["id"],
+                    epg_name=epg_by_gracenote_id.get("name"),
+                    epg_tvg_id=epg_by_gracenote_id.get("original_tvg_id")
+                    or epg_by_gracenote_id.get("tvg_id"),
+                    match_method="exact gracenote_id",
+                    channels_to_update=channels_to_update,
+                    matched_channels=matched_channels,
+                    unchanged_channels=unchanged_channels,
+                )
+                continue
+
+        if not chan["norm_chan"]:
+            logger.debug(f"Channel {chan['id']} '{chan['name']}' => empty after normalization, skipping")
+            continue
+
+        best_score, best_epg, top_candidates, _scanned = fuzzy_scan_epg_list(
+            chan["norm_chan"], epg_data, region_code
+        )
+        if not best_epg:
+            logger.debug(f"Channel {chan['id']} '{chan['name']}' => no EPG entries with valid norm_name found")
+            continue
+
+        matched_epg = try_epg_name_match(
+            chan,
+            best_score,
+            best_epg,
+            top_candidates,
+            is_bulk_matching,
+            use_ml=use_ml,
+            ml_state=ml_state,
+        )
+        if matched_epg:
+            _record_epg_match(
+                chan,
+                matched_epg["id"],
+                epg_name=matched_epg.get("name"),
+                epg_tvg_id=matched_epg.get("original_tvg_id") or matched_epg.get("tvg_id"),
+                match_method=f"fuzzy (score={best_score})",
+                channels_to_update=channels_to_update,
+                matched_channels=matched_channels,
+                unchanged_channels=unchanged_channels,
+            )
+
+    if send_progress:
+        send_epg_matching_progress(
+            total_channels,
+            len(matched_channels) + len(unchanged_channels),
+            stage="completed",
+        )
+
+    return {
+        "channels_to_update": channels_to_update,
+        "matched_channels": matched_channels,
+        "unchanged_channels": unchanged_channels,
+    }
+
+
+def run_single_channel_epg_match(channel_id):
+    """
+    Match one channel to EPG data. Always notifies the UI via WebSocket before returning.
+    """
+    from apps.channels.models import Channel
+
+    channel = None
+    try:
+        logger.info(f"Starting integrated single channel EPG matching for channel ID {channel_id}")
+
+        try:
+            channel = Channel.objects.get(id=channel_id)
+        except Channel.DoesNotExist:
+            message = "Channel not found"
+            send_single_channel_epg_match_result(channel_id, False, message)
+            return {"matched": False, "message": message}
+
+        channel_data = prepare_channel_match_data(channel)
+        logger.info(
+            f"Channel data prepared: name='{channel.name}', tvg_id='{channel_data['tvg_id']}', "
+            f"gracenote_id='{channel_data['gracenote_id']}', norm_chan='{channel_data['norm_chan']}'"
+        )
+
+        send_epg_matching_progress(1, 0, current_channel_name=channel.name, stage="matching")
+        region_code = get_preferred_region_code()
+
+        fallback_name = channel_data["tvg_id"] if channel_data["tvg_id"] else channel.name
+        matched_epg_row = None
+        match_via = None
+
+        if channel_data["tvg_id"]:
+            matched_epg_row = lookup_epg_by_tvg_id(channel_data["tvg_id"])
+            if matched_epg_row:
+                match_via = matched_epg_row["tvg_id"]
+                logger.info(
+                    f"Channel {channel.id} '{fallback_name}' => EPG found by exact tvg_id={match_via}"
+                )
+
+        if not matched_epg_row and channel_data["gracenote_id"]:
+            matched_epg_row = lookup_epg_by_tvg_id(channel_data["gracenote_id"])
+            if matched_epg_row:
+                match_via = f"gracenote:{matched_epg_row['tvg_id']}"
+                logger.info(
+                    f"Channel {channel.id} '{fallback_name}' => EPG found by exact "
+                    f"gracenote_id={channel_data['gracenote_id']}"
+                )
+
+        if not matched_epg_row and channel_data["norm_chan"]:
+            best_score, best_epg, top_candidates, scanned = stream_fuzzy_epg_scan(
+                channel_data["norm_chan"], region_code
+            )
+            logger.info(
+                f"Matching single channel '{channel.name}' against {scanned} EPG entries"
+            )
+            if best_epg:
+                logger.info(
+                    f"Channel {channel.id} '{channel.name}' => best match: '{best_epg['name']}' "
+                    f"(score: {best_score})"
+                )
+                matched_epg_row = try_epg_name_match(
+                    channel_data,
+                    best_score,
+                    best_epg,
+                    top_candidates,
+                    is_bulk_matching=False,
+                    use_ml=True,
+                )
+                if matched_epg_row:
+                    match_via = matched_epg_row["tvg_id"]
+        elif not channel_data["norm_chan"]:
+            logger.debug(f"Channel {channel.id} '{channel.name}' => empty after normalization, skipping")
+
+        if not matched_epg_row:
+            has_fuzzy_epg = _active_epg_fuzzy_queryset().exists()
+            if not has_fuzzy_epg and not channel_data["tvg_id"] and not channel_data["gracenote_id"]:
+                message = "No EPG data available for matching (from active sources)"
+                send_epg_matching_progress(1, 0, current_channel_name=channel.name, stage="completed")
+                send_single_channel_epg_match_result(channel.id, False, message, channel=channel)
+                return {"matched": False, "message": message}
+
+        if matched_epg_row:
+            try:
+                matched_epg_id = matched_epg_row["id"]
+                epg_data = (
+                    channel.epg_data
+                    if channel.epg_data_id == matched_epg_id
+                    else EPGData.objects.get(id=matched_epg_id)
+                )
+
+                if channel.epg_data_id == matched_epg_id:
+                    success_msg = (
+                        f"Channel '{channel.name}' already matched with EPG '{epg_data.name}'"
+                    )
+                    if match_via:
+                        success_msg += f" (matched via: {match_via})"
+                    logger.info(success_msg)
+                    send_epg_matching_progress(1, 1, current_channel_name=channel.name, stage="completed")
+                    send_single_channel_epg_match_result(
+                        channel.id, True, success_msg, channel=channel, epg_data=epg_data
+                    )
+                    return {
+                        "matched": True,
+                        "unchanged": True,
+                        "message": success_msg,
+                        "epg_name": epg_data.name,
+                        "epg_id": epg_data.id,
+                    }
+
+                channel.epg_data = epg_data
+                channel.save(update_fields=["epg_data"])
+
+                success_msg = f"Channel '{channel.name}' matched with EPG '{epg_data.name}'"
+                if match_via:
+                    success_msg += f" (matched via: {match_via})"
+
+                logger.info(success_msg)
+                send_epg_matching_progress(1, 1, current_channel_name=channel.name, stage="completed")
+                channel.refresh_from_db()
+                send_single_channel_epg_match_result(
+                    channel.id, True, success_msg, channel=channel, epg_data=epg_data
+                )
+                return {
+                    "matched": True,
+                    "message": success_msg,
+                    "epg_name": epg_data.name,
+                    "epg_id": epg_data.id,
+                }
+            except EPGData.DoesNotExist:
+                message = "Matched EPG data not found"
+                send_single_channel_epg_match_result(channel.id, False, message, channel=channel)
+                return {"matched": False, "message": message}
+
+        send_epg_matching_progress(1, 0, current_channel_name=channel.name, stage="completed")
+        message = f"No suitable EPG match found for channel '{channel.name}'"
+        send_single_channel_epg_match_result(channel.id, False, message, channel=channel)
+        return {"matched": False, "message": message}
+
+    except Exception as e:
+        logger.error(f"Error in integrated single channel EPG matching: {e}", exc_info=True)
+        message = f"Error during matching: {str(e)}"
+        send_single_channel_epg_match_result(
+            channel_id,
+            False,
+            message,
+            channel=channel,
+        )
+        return {"matched": False, "message": message}
+
+    finally:
+        cleanup_after_matching()
diff --git a/apps/channels/models.py b/apps/channels/models.py
index 320470bb..747d0b89 100644
--- a/apps/channels/models.py
+++ b/apps/channels/models.py
@@ -2,9 +2,9 @@ from django.db import models
 from django.core.exceptions import ValidationError
 from django.conf import settings
 from core.models import StreamProfile, CoreSettings
-from core.utils import RedisClient
+from core.utils import RedisClient, custom_properties_as_dict
 from apps.proxy.live_proxy.redis_keys import RedisKeys
-from apps.proxy.live_proxy.constants import ChannelMetadataField
+from apps.proxy.live_proxy.constants import ChannelMetadataField, ChannelState
 import logging
 import uuid
 from django.utils import timezone
@@ -17,6 +17,7 @@ logger = logging.getLogger(__name__)
 
 # If you have an M3UAccount model in apps.m3u, you can still import it:
 from apps.m3u.models import M3UAccount
+from apps.m3u.connection_pool import reserve_profile_slot, release_profile_slot
 
 
 # Add fallback functions if Redis isn't available
@@ -209,13 +210,14 @@ class Stream(models.Model):
         Finds an available profile for this stream and reserves a connection slot.
 
         Returns:
-            Tuple[Optional[int], Optional[int], Optional[str]]: (stream_id, profile_id, error_reason)
+            Tuple[Optional[int], Optional[int], Optional[str], bool]:
+            (stream_id, profile_id, error_reason, slot_reserved)
         """
         redis_client = RedisClient.get_client()
         profile_id = redis_client.get(f"stream_profile:{self.id}")
         if profile_id:
             profile_id = int(profile_id)
-            return self.id, profile_id, None
+            return self.id, profile_id, None, False
 
         # Retrieve the M3U account associated with the stream.
         m3u_account = self.m3u_account
@@ -226,29 +228,22 @@ class Stream(models.Model):
         ]
 
         for profile in profiles:
-            logger.info(profile)
+            logger.debug("Evaluating profile %s for stream %s", profile.id, self.id)
             # Skip inactive profiles
             if profile.is_active == False:
                 continue
 
-            # Atomic slot reservation: INCR first, check, rollback if over capacity
-            if profile.max_streams == 0:
-                reserved = True
-            else:
-                profile_connections_key = f"profile_connections:{profile.id}"
-                new_count = redis_client.incr(profile_connections_key)
-                if new_count <= profile.max_streams:
-                    reserved = True
-                else:
-                    redis_client.decr(profile_connections_key)
-                    reserved = False
+            # Atomic slot reservation via shared connection pool helper
+            reserved, _count, _failure_reason = reserve_profile_slot(
+                profile, redis_client
+            )
 
             if reserved:
                 redis_client.set(f"channel_stream:{self.id}", self.id)
                 redis_client.set(f"stream_profile:{self.id}", profile.id)
-                return self.id, profile.id, None
+                return self.id, profile.id, None, True
 
-        return None, None, "All active M3U profiles have reached maximum connection limits"
+        return None, None, "All active M3U profiles have reached maximum connection limits", False
 
     def release_stream(self):
         """
@@ -277,12 +272,7 @@ class Stream(models.Model):
             f"Stream {stream_id}: found profile_id={profile_id}"
         )
 
-        profile_connections_key = f"profile_connections:{profile_id}"
-
-        # Only decrement if the profile had a max_connections limit
-        current_count = int(redis_client.get(profile_connections_key) or 0)
-        if current_count > 0:
-            redis_client.decr(profile_connections_key)
+        release_profile_slot(profile_id, redis_client)
 
         return True
 
@@ -599,44 +589,91 @@ class Channel(models.Model):
 
         return victim_id
 
-    def _check_and_reserve_profile_slot(self, profile, redis_client):
+    def _channel_proxy_is_active(self, redis_client) -> bool:
+        """True when live proxy metadata shows this channel is still running."""
+        metadata_key = RedisKeys.channel_metadata(str(self.uuid))
+        if not redis_client.exists(metadata_key):
+            return False
+        state = redis_client.hget(metadata_key, ChannelMetadataField.STATE)
+        if state is None:
+            return False
+        if isinstance(state, bytes):
+            state = state.decode()
+        return state in (
+            ChannelState.ACTIVE,
+            ChannelState.WAITING_FOR_CLIENTS,
+            ChannelState.BUFFERING,
+            ChannelState.INITIALIZING,
+            ChannelState.CONNECTING,
+        )
+
+    def _stream_assignment_is_reusable(self, redis_client, stream_id: int) -> bool:
         """
-        Atomically check and reserve a connection slot for the given profile.
+        Return True when an existing channel_stream assignment should be reused.
 
-        Uses an INCR-first-then-check pattern to eliminate the TOCTOU race
-        condition where separate GET + check + INCR operations could allow
-        concurrent requests to both pass the capacity check.
-
-        For profiles with max_streams=0 (unlimited), no reservation is needed.
-
-        Args:
-            profile: M3UAccountProfile instance
-            redis_client: Redis client instance
-
-        Returns:
-            tuple: (reserved: bool, current_count: int)
+        Reuse when the proxy is active, or when metadata is not written yet
+        (between get_stream() reserving slots and initialize_channel() starting).
+        When metadata exists but the proxy is inactive, the assignment is stale.
         """
-        if profile.max_streams == 0:
-            return (True, 0)
+        if self._channel_proxy_is_active(redis_client):
+            return True
 
-        profile_connections_key = f"profile_connections:{profile.id}"
+        metadata_key = RedisKeys.channel_metadata(str(self.uuid))
+        if not redis_client.exists(metadata_key):
+            return redis_client.get(f"stream_profile:{stream_id}") is not None
 
-        # Atomically increment first — this is a single Redis command
-        new_count = redis_client.incr(profile_connections_key)
+        return False
 
-        if new_count <= profile.max_streams:
-            return (True, new_count)
+    def _release_stale_stream_assignment(self, redis_client, stream_id: int) -> None:
+        """Release pool counters and remove stale channel/stream assignment keys."""
+        profile_id = None
+        profile_id_bytes = redis_client.get(f"stream_profile:{stream_id}")
+        if profile_id_bytes:
+            try:
+                profile_id = int(profile_id_bytes)
+            except (ValueError, TypeError):
+                logger.debug(
+                    "Invalid profile ID for stale assignment on stream %s: %s",
+                    stream_id,
+                    profile_id_bytes,
+                )
 
-        # Over capacity — roll back the increment
-        redis_client.decr(profile_connections_key)
-        return (False, new_count - 1)
+        if profile_id is None:
+            metadata_key = RedisKeys.channel_metadata(str(self.uuid))
+            meta_profile_id = redis_client.hget(
+                metadata_key, ChannelMetadataField.M3U_PROFILE
+            )
+            if meta_profile_id:
+                try:
+                    profile_id = int(meta_profile_id)
+                except (ValueError, TypeError):
+                    logger.debug(
+                        "Invalid profile ID in metadata for stale assignment on "
+                        "channel %s: %s",
+                        self.uuid,
+                        meta_profile_id,
+                    )
+
+        if profile_id is not None:
+            release_profile_slot(profile_id, redis_client)
+        else:
+            logger.warning(
+                "Channel %s: releasing stale stream %s assignment without profile "
+                "info - profile_connections may leak",
+                self.uuid,
+                stream_id,
+            )
+
+        redis_client.delete(f"channel_stream:{self.id}")
+        redis_client.delete(f"stream_profile:{stream_id}")
 
     def get_stream(self, requester=None):
         """
         Finds an available stream for the requested channel and returns the selected stream and profile.
 
         Returns:
-            Tuple[Optional[int], Optional[int], Optional[str]]: (stream_id, profile_id, error_reason)
+            Tuple[Optional[int], Optional[int], Optional[str], bool]:
+            (stream_id, profile_id, error_reason, slot_reserved)
         """
         redis_client = RedisClient.get_client()
         error_reason = None
@@ -644,26 +681,42 @@ class Channel(models.Model):
         # Check if this channel has any streams
         if not self.streams.exists():
             error_reason = "No streams assigned to channel"
-            return None, None, error_reason
+            return None, None, error_reason, False
 
-        # Check if a stream is already active for this channel
+        # Reuse assignment only when this channel is still active in the proxy.
+        # Stale channel_stream keys after stop/disconnect skip INCR and break pool
+        # accounting, which lets a second stream reach the provider and fail validation.
         stream_id_bytes = redis_client.get(f"channel_stream:{self.id}")
         if stream_id_bytes:
             try:
                 stream_id = int(stream_id_bytes)
-                profile_id_bytes = redis_client.get(f"stream_profile:{stream_id}")
-                if profile_id_bytes:
-                    try:
-                        profile_id = int(profile_id_bytes)
-                        return stream_id, profile_id, None
-                    except (ValueError, TypeError):
-                        logger.debug(
-                            f"Invalid profile ID retrieved from Redis: {profile_id_bytes}"
-                        )
             except (ValueError, TypeError):
                 logger.debug(
                     f"Invalid stream ID retrieved from Redis: {stream_id_bytes}"
                 )
+                stream_id = None
+
+            if stream_id is not None:
+                if self._stream_assignment_is_reusable(redis_client, stream_id):
+                    profile_id_bytes = redis_client.get(f"stream_profile:{stream_id}")
+                    if profile_id_bytes:
+                        try:
+                            profile_id = int(profile_id_bytes)
+                            logger.debug(
+                                f"Channel {self.uuid}: reusing stream assignment "
+                                f"stream={stream_id} profile={profile_id}"
+                            )
+                            return stream_id, profile_id, None, False
+                        except (ValueError, TypeError):
+                            logger.debug(
+                                f"Invalid profile ID retrieved from Redis: {profile_id_bytes}"
+                            )
+                else:
+                    logger.info(
+                        f"Channel {self.uuid}: releasing stale stream assignment "
+                        f"(stream={stream_id}, proxy not active)"
+                    )
+                    self._release_stale_stream_assignment(redis_client, stream_id)
 
         # No existing active stream, attempt to assign a new one
         has_streams_but_maxed_out = False
@@ -697,7 +750,7 @@ class Channel(models.Model):
                 has_active_profiles = True
 
                 # Atomically check and reserve a slot (INCR-first pattern)
-                reserved, current_count = self._check_and_reserve_profile_slot(
+                reserved, current_count, failure_reason = reserve_profile_slot(
                     profile, redis_client
                 )
 
@@ -705,11 +758,16 @@ class Channel(models.Model):
                     # Slot reserved — assign stream to this channel
                     redis_client.set(f"channel_stream:{self.id}", stream.id)
                     redis_client.set(f"stream_profile:{stream.id}", profile.id)
+                    logger.info(
+                        f"Channel {self.uuid}: assigned stream {stream.id} "
+                        f"profile {profile.id} ({profile.name})"
+                    )
 
                     return (
                         stream.id,
                         profile.id,
                         None,
+                        True,
                     )  # Return newly assigned stream and matched profile
                 else:
                     # At capacity: try to preempt a lower-impact channel on this profile
@@ -723,12 +781,21 @@ class Channel(models.Model):
                         logger.info(f"Preempting channel {victim_channel_id} for new stream on profile {profile.id}")
                         # return self.id, profile.id, victim_channel_id
 
-                    # This profile is at max connections
                     has_streams_but_maxed_out = True
-                    logger.debug(
-                        f"Profile {profile.id} at max connections: "
-                        f"{current_count}/{profile.max_streams}"
-                    )
+                    if failure_reason == "profile_full":
+                        logger.info(
+                            f"Profile {profile.id} at max connections: "
+                            f"{current_count}/{profile.max_streams}, trying next profile"
+                        )
+                    elif failure_reason == "credential_full":
+                        logger.info(
+                            f"Profile {profile.id} shared login pool full, trying next profile"
+                        )
+                    else:
+                        logger.debug(
+                            f"Profile {profile.id} reservation failed: "
+                            f"{current_count}/{profile.max_streams}"
+                        )
 
         # No available streams - determine specific reason
         if has_streams_but_maxed_out:
@@ -738,7 +805,7 @@ class Channel(models.Model):
         else:
             error_reason = "No active profiles found for any assigned stream"
 
-        return None, None, error_reason
+        return None, None, error_reason, False
 
     def release_stream(self):
         """
@@ -782,12 +849,7 @@ class Channel(models.Model):
                     ChannelMetadataField.M3U_PROFILE,
                 )
 
-                profile_connections_key = f"profile_connections:{profile_id}"
-                current_count = int(
-                    redis_client.get(profile_connections_key) or 0
-                )
-                if current_count > 0:
-                    redis_client.decr(profile_connections_key)
+                release_profile_slot(profile_id, redis_client)
                 return True
 
             logger.debug(
@@ -832,12 +894,7 @@ class Channel(models.Model):
             f"stream {stream_id}"
         )
 
-        profile_connections_key = f"profile_connections:{profile_id}"
-
-        # Only decrement if the profile had a max_connections limit
-        current_count = int(redis_client.get(profile_connections_key) or 0)
-        if current_count > 0:
-            redis_client.decr(profile_connections_key)
+        release_profile_slot(profile_id, redis_client)
 
         # Clear metadata fields so duplicate release_stream() calls
         # (e.g. from _clean_redis_keys or ChannelService.stop_channel)
@@ -883,10 +940,31 @@ class Channel(models.Model):
         if current_profile_id == new_profile_id:
             return True
 
-        # Use pipeline for atomic profile switch to prevent counter drift
-        # if an exception occurs between DECR and INCR
-        old_profile_connections_key = f"profile_connections:{current_profile_id}"
-        new_profile_connections_key = f"profile_connections:{new_profile_id}"
+        from apps.m3u.connection_pool import (
+            move_credential_slot_on_profile_switch,
+            profile_connections_key,
+        )
+        from apps.m3u.models import M3UAccountProfile
+
+        old_profile = M3UAccountProfile.objects.select_related(
+            "m3u_account__server_group"
+        ).get(id=current_profile_id)
+        new_profile = M3UAccountProfile.objects.select_related(
+            "m3u_account__server_group"
+        ).get(id=new_profile_id)
+
+        if not move_credential_slot_on_profile_switch(
+            old_profile, new_profile, redis_client
+        ):
+            logger.warning(
+                "Shared login pool full for profile %s during stream profile switch",
+                new_profile_id,
+            )
+            return False
+
+        # Profile counters always move on switch; credential totals move only when login changes.
+        old_profile_connections_key = profile_connections_key(current_profile_id)
+        new_profile_connections_key = profile_connections_key(new_profile_id)
         old_count = int(redis_client.get(old_profile_connections_key) or 0)
 
         pipe = redis_client.pipeline()
@@ -1041,6 +1119,13 @@ class ChannelGroupM3UAccount(models.Model):
     def __str__(self):
         return f"{self.channel_group.name} - {self.m3u_account.name} (Enabled: {self.enabled})"
 
+    def save(self, *args, **kwargs):
+        if self.custom_properties is not None and not isinstance(
+            self.custom_properties, dict
+        ):
+            self.custom_properties = custom_properties_as_dict(self.custom_properties)
+        super().save(*args, **kwargs)
+
 
 class Logo(models.Model):
     name = models.CharField(max_length=255)
diff --git a/apps/channels/serializers.py b/apps/channels/serializers.py
index 9b7d3a2a..61bbef8d 100644
--- a/apps/channels/serializers.py
+++ b/apps/channels/serializers.py
@@ -221,17 +221,6 @@ class ChannelGroupM3UAccountSerializer(serializers.ModelSerializer):
 
         return data
 
-    def to_internal_value(self, data):
-        # Accept both dict and JSON string for custom_properties (for backward compatibility)
-        val = data.get("custom_properties")
-        if isinstance(val, str):
-            try:
-                data["custom_properties"] = json.loads(val)
-            except Exception:
-                pass
-
-        return super().to_internal_value(data)
-
     def validate(self, attrs):
         # Partial PATCHes only carry submitted fields; fill missing
         # start/end from the instance so the validator catches a PATCH
@@ -562,10 +551,13 @@ class ChannelSerializer(serializers.ModelSerializer):
         return LogoSerializer(obj.logo).data
 
     def get_streams(self, obj):
-        """Retrieve ordered stream IDs for GET requests."""
-        return StreamSerializer(
-            obj.streams.all().order_by("channelstream__order"), many=True
-        ).data
+        """Retrieve ordered streams for GET requests using prefetched channelstream_set."""
+        ordered_streams = [
+            cs.stream
+            for cs in obj.channelstream_set.all()
+            if cs.stream_id is not None
+        ]
+        return StreamSerializer(ordered_streams, many=True).data
 
     def create(self, validated_data):
         streams = validated_data.pop("streams", [])
diff --git a/apps/channels/signals.py b/apps/channels/signals.py
index 54dd30fc..53f1ea33 100644
--- a/apps/channels/signals.py
+++ b/apps/channels/signals.py
@@ -201,18 +201,13 @@ def refresh_epg_programs(sender, instance, created, **kwargs):
     if not created and kwargs.get('update_fields') and 'epg_data' in kwargs['update_fields']:
         logger.info(f"Channel {instance.id} ({instance.name}) EPG data updated, refreshing program data")
         if instance.epg_data:
-            # Skip XMLTV program parser for SD sources — program data is handled
-            # by fetch_schedules_direct() directly.
-            if instance.epg_data.epg_source and instance.epg_data.epg_source.source_type == 'schedules_direct':
-                logger.info(f"Skipping XMLTV parse for SD source {instance.epg_data.tvg_id}")
+            if instance.epg_data.epg_source and instance.epg_data.epg_source.source_type == 'dummy':
                 return
             logger.info(f"Triggering EPG program refresh for {instance.epg_data.tvg_id}")
             parse_programs_for_tvg_id.delay(instance.epg_data.id)
     # For new channels with EPG data, also refresh
     elif created and instance.epg_data:
-        # Skip XMLTV program parser for SD sources
-        if instance.epg_data.epg_source and instance.epg_data.epg_source.source_type == 'schedules_direct':
-            logger.info(f"Skipping XMLTV parse for SD source {instance.epg_data.tvg_id}")
+        if instance.epg_data.epg_source and instance.epg_data.epg_source.source_type == 'dummy':
             return
         logger.info(f"New channel {instance.id} ({instance.name}) created with EPG data, refreshing program data")
         parse_programs_for_tvg_id.delay(instance.epg_data.id)
diff --git a/apps/channels/tasks.py b/apps/channels/tasks.py
index aae62ef4..1250607f 100755
--- a/apps/channels/tasks.py
+++ b/apps/channels/tasks.py
@@ -18,8 +18,15 @@ import gc
 from celery import shared_task
 from celery.signals import worker_shutting_down
 from django.utils.text import slugify
-from rapidfuzz import fuzz
 
+from apps.channels.epg_matching import (
+    apply_matched_epg_to_channels,
+    build_epg_matching_catalog,
+    cleanup_after_matching,
+    match_channels_to_epg,
+    normalize_name,
+    run_single_channel_epg_match,
+)
 from apps.channels.models import Channel
 from apps.epg.models import EPGData
 from core.models import CoreSettings
@@ -200,469 +207,6 @@ def validate_logo_url(logo_url, max_length=2000):
         return None
     return logo_url
 
-def send_epg_matching_progress(total_channels, matched_channels, current_channel_name="", stage="matching"):
-    """
-    Send EPG matching progress via WebSocket
-    """
-    try:
-        channel_layer = get_channel_layer()
-        if channel_layer:
-            progress_data = {
-                'type': 'epg_matching_progress',
-                'total': total_channels,
-                'matched': len(matched_channels) if isinstance(matched_channels, list) else matched_channels,
-                'remaining': total_channels - (len(matched_channels) if isinstance(matched_channels, list) else matched_channels),
-                'current_channel': current_channel_name,
-                'stage': stage,
-                'progress_percent': round((len(matched_channels) if isinstance(matched_channels, list) else matched_channels) / total_channels * 100, 1) if total_channels > 0 else 0
-            }
-
-            async_to_sync(channel_layer.group_send)(
-                "updates",
-                {
-                    "type": "update",
-                    "data": {
-                        "type": "epg_matching_progress",
-                        **progress_data
-                    }
-                }
-            )
-    except Exception as e:
-        logger.warning(f"Failed to send EPG matching progress: {e}")
-
-# Lazy loading for ML models - only imported/loaded when needed
-_ml_model_cache = {
-    'sentence_transformer': None
-}
-
-def get_sentence_transformer():
-    """Lazy load the sentence transformer model only when needed"""
-    if _ml_model_cache['sentence_transformer'] is None:
-        try:
-            from sentence_transformers import SentenceTransformer
-            from sentence_transformers import util
-
-            model_name = "sentence-transformers/all-MiniLM-L6-v2"
-            cache_dir = "/data/models"
-
-            # Check environment variable to disable downloads
-            disable_downloads = os.environ.get('DISABLE_ML_DOWNLOADS', 'false').lower() == 'true'
-
-            if disable_downloads:
-                # Check if model exists before attempting to load
-                hf_model_path = os.path.join(cache_dir, f"models--{model_name.replace('/', '--')}")
-                if not os.path.exists(hf_model_path):
-                    logger.warning("ML model not found and downloads disabled (DISABLE_ML_DOWNLOADS=true). Skipping ML matching.")
-                    return None, None
-
-            # Ensure cache directory exists
-            os.makedirs(cache_dir, exist_ok=True)
-
-            # Let sentence-transformers handle all cache detection and management
-            logger.info(f"Loading sentence transformer model (cache: {cache_dir})")
-            _ml_model_cache['sentence_transformer'] = SentenceTransformer(
-                model_name,
-                cache_folder=cache_dir
-            )
-
-            return _ml_model_cache['sentence_transformer'], util
-        except ImportError:
-            logger.warning("sentence-transformers not available - ML-enhanced matching disabled")
-            return None, None
-        except Exception as e:
-            logger.error(f"Failed to load sentence transformer: {e}")
-            return None, None
-    else:
-        from sentence_transformers import util
-        return _ml_model_cache['sentence_transformer'], util
-
-# ML matching thresholds (same as original script)
-BEST_FUZZY_THRESHOLD = 85
-LOWER_FUZZY_THRESHOLD = 40
-EMBED_SIM_THRESHOLD = 0.65
-
-# Words we remove to help with fuzzy + embedding matching
-COMMON_EXTRANEOUS_WORDS = [
-    "tv", "channel", "network", "television",
-    "east", "west", "hd", "uhd", "24/7",
-    "1080p", "720p", "540p", "480p",
-    "film", "movie", "movies"
-]
-
-def normalize_name(name: str) -> str:
-    """
-    A more aggressive normalization that:
-      - Removes user-configured prefixes/suffixes/custom strings (only if mode is 'advanced')
-      - Lowercases
-      - Removes bracketed/parenthesized text
-      - Removes punctuation
-      - Strips extraneous words
-      - Collapses extra spaces
-    """
-    if not name:
-        return ""
-
-    # Load user-configured EPG matching rules (fail gracefully)
-    prefixes = []
-    suffixes = []
-    custom_strings = []
-
-    try:
-        from core.models import CoreSettings
-        settings = CoreSettings.get_epg_settings()
-
-        # Check if user has enabled advanced mode
-        mode = settings.get("epg_match_mode", "default")
-
-        # Only use custom settings if mode is 'advanced'
-        if mode == "advanced":
-            prefixes = settings.get("epg_match_ignore_prefixes", [])
-            suffixes = settings.get("epg_match_ignore_suffixes", [])
-            custom_strings = settings.get("epg_match_ignore_custom", [])
-
-            # Ensure we have lists
-            if not isinstance(prefixes, list):
-                prefixes = []
-            if not isinstance(suffixes, list):
-                suffixes = []
-            if not isinstance(custom_strings, list):
-                custom_strings = []
-
-    except Exception as e:
-        # Settings unavailable or error - continue with empty lists (graceful degradation)
-        logger.debug(f"Could not load EPG matching settings: {e}")
-        prefixes = []
-        suffixes = []
-        custom_strings = []
-
-    result = name
-
-    # Step 1: Remove prefixes (from START only - exact string match)
-    for prefix in prefixes:
-        # Skip empty or non-string entries
-        if not prefix or not isinstance(prefix, str):
-            continue
-        # Exact match at start
-        if result.startswith(prefix):
-            result = result[len(prefix):]
-            break  # Only remove first matching prefix
-
-    # Step 2: Remove suffixes (from END only - exact string match)
-    for suffix in suffixes:
-        # Skip empty or non-string entries
-        if not suffix or not isinstance(suffix, str):
-            continue
-        # Exact match at end
-        if result.endswith(suffix):
-            result = result[:-len(suffix)]
-            break  # Only remove first matching suffix
-
-    # Step 3: Remove custom strings (from ANYWHERE - exact string match)
-    for custom in custom_strings:
-        # Skip empty or non-string entries
-        if not custom or not isinstance(custom, str):
-            continue
-        try:
-            # Exact string removal (replace with empty string)
-            result = result.replace(custom, "")
-        except Exception as e:
-            # If removal fails for any reason, skip this entry
-            logger.debug(f"Failed to remove custom string '{custom}': {e}")
-            continue
-
-    # Step 4: Existing normalization logic (unchanged)
-    norm = result.lower()
-    norm = re.sub(r"\[.*?\]", "", norm)
-
-    # Extract and preserve important call signs from parentheses before removing them
-    # This captures call signs like (KVLY), (KING), (KARE), etc.
-    call_sign_match = re.search(r"\(([A-Z]{3,5})\)", name)
-    preserved_call_sign = ""
-    if call_sign_match:
-        preserved_call_sign = " " + call_sign_match.group(1).lower()
-
-    # Now remove all parentheses content
-    norm = re.sub(r"\(.*?\)", "", norm)
-
-    # Add back the preserved call sign
-    norm = norm + preserved_call_sign
-
-    norm = re.sub(r"[^\w\s]", "", norm)
-    tokens = norm.split()
-    tokens = [t for t in tokens if t not in COMMON_EXTRANEOUS_WORDS]
-    norm = " ".join(tokens).strip()
-    return norm
-
-def match_channels_to_epg(channels_data, epg_data, region_code=None, use_ml=True, send_progress=True):
-    """
-    EPG matching logic that finds the best EPG matches for channels using
-    multiple matching strategies including fuzzy matching and ML models.
-
-    Automatically uses conservative thresholds for bulk matching (multiple channels)
-    to avoid bad matches that create user cleanup work, and aggressive thresholds
-    for single channel matching where users specifically requested a match attempt.
-    """
-    channels_to_update = []
-    matched_channels = []
-    total_channels = len(channels_data)
-
-    # Send initial progress
-    if send_progress:
-        send_epg_matching_progress(total_channels, 0, stage="starting")
-
-    # Try to get ML models if requested (but don't load yet - lazy loading)
-    st_model, util = None, None
-    epg_embeddings = None
-    ml_available = use_ml
-
-    # Automatically determine matching strategy based on number of channels
-    is_bulk_matching = len(channels_data) > 1
-
-    # Adjust matching thresholds based on operation type
-    if is_bulk_matching:
-        # Conservative thresholds for bulk matching to avoid creating cleanup work
-        FUZZY_HIGH_CONFIDENCE = 90      # Only very high fuzzy scores
-        FUZZY_MEDIUM_CONFIDENCE = 70    # Higher threshold for ML enhancement
-        ML_HIGH_CONFIDENCE = 0.75       # Higher ML confidence required
-        ML_LAST_RESORT = 0.65          # More conservative last resort
-        FUZZY_LAST_RESORT_MIN = 50     # Higher fuzzy minimum for last resort
-        logger.info(f"Using conservative thresholds for bulk matching ({total_channels} channels)")
-    else:
-        # More aggressive thresholds for single channel matching (user requested specific match)
-        FUZZY_HIGH_CONFIDENCE = 85      # Original threshold
-        FUZZY_MEDIUM_CONFIDENCE = 40    # Original threshold
-        ML_HIGH_CONFIDENCE = 0.65       # Original threshold
-        ML_LAST_RESORT = 0.50          # Original desperate threshold
-        FUZZY_LAST_RESORT_MIN = 20     # Original minimum
-        logger.info("Using aggressive thresholds for single channel matching")    # Process each channel
-    for index, chan in enumerate(channels_data):
-        normalized_tvg_id = chan.get("tvg_id", "")
-        fallback_name = chan["tvg_id"].strip() if chan["tvg_id"] else chan["name"]
-
-        # Send progress update every 5 channels or for the first few
-        if send_progress and (index < 5 or index % 5 == 0 or index == total_channels - 1):
-            send_epg_matching_progress(
-                total_channels,
-                len(matched_channels),
-                current_channel_name=chan["name"][:50],  # Truncate long names
-                stage="matching"
-            )
-        normalized_tvg_id = chan.get("tvg_id", "")
-        fallback_name = chan["tvg_id"].strip() if chan["tvg_id"] else chan["name"]
-
-        # Step 1: Exact TVG ID match
-        epg_by_tvg_id = next((epg for epg in epg_data if epg["tvg_id"] == normalized_tvg_id), None)
-        if normalized_tvg_id and epg_by_tvg_id:
-            chan["epg_data_id"] = epg_by_tvg_id["id"]
-            channels_to_update.append(chan)
-            matched_channels.append((chan['id'], fallback_name, epg_by_tvg_id["tvg_id"]))
-            logger.info(f"Channel {chan['id']} '{fallback_name}' => EPG found by exact tvg_id={epg_by_tvg_id['tvg_id']}")
-            continue
-
-        # Step 2: Secondary TVG ID check (legacy compatibility)
-        if chan["tvg_id"]:
-            epg_match = [epg["id"] for epg in epg_data if epg["tvg_id"] == chan["tvg_id"]]
-            if epg_match:
-                chan["epg_data_id"] = epg_match[0]
-                channels_to_update.append(chan)
-                matched_channels.append((chan['id'], fallback_name, chan["tvg_id"]))
-                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")
-            continue
-
-        best_score = 0
-        best_epg = None
-
-        # Debug: show what we're matching against
-        logger.debug(f"Fuzzy matching '{chan['norm_chan']}' against EPG entries...")
-
-        # Find best fuzzy match
-        for row in epg_data:
-            if not row.get("norm_name"):
-                continue
-
-            base_score = fuzz.ratio(chan["norm_chan"], row["norm_name"])
-            bonus = 0
-
-            # Apply region-based bonus/penalty
-            if region_code and row.get("tvg_id"):
-                combined_text = row["tvg_id"].lower() + " " + row["name"].lower()
-                dot_regions = re.findall(r'\.([a-z]{2})', combined_text)
-
-                if dot_regions:
-                    if region_code in dot_regions:
-                        bonus = 15  # Bigger bonus for matching region
-                    else:
-                        bonus = -15  # Penalty for different region
-                elif region_code in combined_text:
-                    bonus = 10
-
-            score = base_score + bonus
-
-            # Debug the best few matches
-            if score > 50:  # Only show decent matches
-                logger.debug(f"  EPG '{row['name']}' (norm: '{row['norm_name']}') => score: {score} (base: {base_score}, bonus: {bonus})")
-
-            # When scores are equal, prefer higher priority EPG source
-            row_priority = row.get('epg_source_priority', 0)
-            best_priority = best_epg.get('epg_source_priority', 0) if best_epg else -1
-
-            if score > best_score or (score == best_score and row_priority > best_priority):
-                best_score = score
-                best_epg = row
-
-        # Log the best score we found
-        if best_epg:
-            logger.info(f"Channel {chan['id']} '{chan['name']}' => best match: '{best_epg['name']}' (score: {best_score})")
-        else:
-            logger.debug(f"Channel {chan['id']} '{chan['name']}' => no EPG entries with valid norm_name found")
-            continue
-
-        # High confidence match - accept immediately
-        if best_score >= FUZZY_HIGH_CONFIDENCE:
-            chan["epg_data_id"] = best_epg["id"]
-            channels_to_update.append(chan)
-            matched_channels.append((chan['id'], chan['name'], best_epg["tvg_id"]))
-            logger.info(f"Channel {chan['id']} '{chan['name']}' => matched tvg_id={best_epg['tvg_id']} (score={best_score})")
-
-        # Medium confidence - use ML if available (lazy load models here)
-        elif best_score >= FUZZY_MEDIUM_CONFIDENCE and ml_available:
-            # Lazy load ML models only when we actually need them
-            if st_model is None:
-                st_model, util = get_sentence_transformer()
-
-            # Lazy generate embeddings only when we actually need them
-            if epg_embeddings is None and st_model and any(row.get("norm_name") for row in epg_data):
-                try:
-                    logger.info("Generating embeddings for EPG data using ML model (lazy loading)")
-                    epg_embeddings = st_model.encode(
-                        [row["norm_name"] for row in epg_data if row.get("norm_name")],
-                        convert_to_tensor=True
-                    )
-                except Exception as e:
-                    logger.warning(f"Failed to generate embeddings: {e}")
-                    epg_embeddings = None
-
-            if epg_embeddings is not None and st_model:
-                try:
-                    # Generate embedding for this channel
-                    chan_embedding = st_model.encode(chan["norm_chan"], convert_to_tensor=True)
-
-                    # Calculate similarity with all EPG embeddings
-                    sim_scores = util.cos_sim(chan_embedding, epg_embeddings)[0]
-                    top_index = int(sim_scores.argmax())
-                    top_value = float(sim_scores[top_index])
-
-                    if top_value >= ML_HIGH_CONFIDENCE:
-                        # Find the EPG entry that corresponds to this embedding index
-                        epg_with_names = [epg for epg in epg_data if epg.get("norm_name")]
-                        matched_epg = epg_with_names[top_index]
-
-                        chan["epg_data_id"] = matched_epg["id"]
-                        channels_to_update.append(chan)
-                        matched_channels.append((chan['id'], chan['name'], matched_epg["tvg_id"]))
-                        logger.info(f"Channel {chan['id']} '{chan['name']}' => matched EPG tvg_id={matched_epg['tvg_id']} (fuzzy={best_score}, ML-sim={top_value:.2f})")
-                    else:
-                        logger.info(f"Channel {chan['id']} '{chan['name']}' => fuzzy={best_score}, ML-sim={top_value:.2f} < {ML_HIGH_CONFIDENCE}, trying last resort...")
-
-                        # Last resort: try ML with very low fuzzy threshold
-                        if top_value >= ML_LAST_RESORT:  # Dynamic last resort threshold
-                            epg_with_names = [epg for epg in epg_data if epg.get("norm_name")]
-                            matched_epg = epg_with_names[top_index]
-
-                            chan["epg_data_id"] = matched_epg["id"]
-                            channels_to_update.append(chan)
-                            matched_channels.append((chan['id'], chan['name'], matched_epg["tvg_id"]))
-                            logger.info(f"Channel {chan['id']} '{chan['name']}' => LAST RESORT match EPG tvg_id={matched_epg['tvg_id']} (fuzzy={best_score}, ML-sim={top_value:.2f})")
-                        else:
-                            logger.info(f"Channel {chan['id']} '{chan['name']}' => even last resort ML-sim {top_value:.2f} < {ML_LAST_RESORT}, skipping")
-
-                except Exception as e:
-                    logger.warning(f"ML matching failed for channel {chan['id']}: {e}")
-                    # Fall back to non-ML decision
-                    logger.info(f"Channel {chan['id']} '{chan['name']}' => fuzzy score {best_score} below threshold, skipping")
-
-        # Last resort: Try ML matching even with very low fuzzy scores
-        elif best_score >= FUZZY_LAST_RESORT_MIN and ml_available:
-            # Lazy load ML models for last resort attempts
-            if st_model is None:
-                st_model, util = get_sentence_transformer()
-
-            # Lazy generate embeddings for last resort attempts
-            if epg_embeddings is None and st_model and any(row.get("norm_name") for row in epg_data):
-                try:
-                    logger.info("Generating embeddings for EPG data using ML model (last resort lazy loading)")
-                    epg_embeddings = st_model.encode(
-                        [row["norm_name"] for row in epg_data if row.get("norm_name")],
-                        convert_to_tensor=True
-                    )
-                except Exception as e:
-                    logger.warning(f"Failed to generate embeddings for last resort: {e}")
-                    epg_embeddings = None
-
-            if epg_embeddings is not None and st_model:
-                try:
-                    logger.info(f"Channel {chan['id']} '{chan['name']}' => trying ML as last resort (fuzzy={best_score})")
-                    # Generate embedding for this channel
-                    chan_embedding = st_model.encode(chan["norm_chan"], convert_to_tensor=True)
-
-                    # Calculate similarity with all EPG embeddings
-                    sim_scores = util.cos_sim(chan_embedding, epg_embeddings)[0]
-                    top_index = int(sim_scores.argmax())
-                    top_value = float(sim_scores[top_index])
-
-                    if top_value >= ML_LAST_RESORT:  # Dynamic threshold for desperate attempts
-                        # Find the EPG entry that corresponds to this embedding index
-                        epg_with_names = [epg for epg in epg_data if epg.get("norm_name")]
-                        matched_epg = epg_with_names[top_index]
-
-                        chan["epg_data_id"] = matched_epg["id"]
-                        channels_to_update.append(chan)
-                        matched_channels.append((chan['id'], chan['name'], matched_epg["tvg_id"]))
-                        logger.info(f"Channel {chan['id']} '{chan['name']}' => DESPERATE LAST RESORT match EPG tvg_id={matched_epg['tvg_id']} (fuzzy={best_score}, ML-sim={top_value:.2f})")
-                    else:
-                        logger.info(f"Channel {chan['id']} '{chan['name']}' => desperate last resort ML-sim {top_value:.2f} < {ML_LAST_RESORT}, giving up")
-                except Exception as e:
-                    logger.warning(f"Last resort ML matching failed for channel {chan['id']}: {e}")
-                    logger.info(f"Channel {chan['id']} '{chan['name']}' => best fuzzy score={best_score} < {FUZZY_MEDIUM_CONFIDENCE}, giving up")
-        else:
-            # No ML available or very low fuzzy score
-            logger.info(f"Channel {chan['id']} '{chan['name']}' => best fuzzy score={best_score} < {FUZZY_MEDIUM_CONFIDENCE}, no ML fallback available")
-
-    # Clean up ML models from memory after matching (infrequent operation)
-    if _ml_model_cache['sentence_transformer'] is not None:
-        logger.info("Cleaning up ML models from memory")
-        _ml_model_cache['sentence_transformer'] = None
-        gc.collect()
-
-    # Send final progress update
-    if send_progress:
-        send_epg_matching_progress(
-            total_channels,
-            len(matched_channels),
-            stage="completed"
-        )
-
-    return {
-        "channels_to_update": channels_to_update,
-        "matched_channels": matched_channels
-    }
-
 @shared_task
 def match_epg_channels():
     """
@@ -695,97 +239,74 @@ def match_epg_channels():
                 "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!
+                "norm_chan": normalize_name(channel.name),  # Always use channel name for fuzzy matching!
+                "current_epg_data_id": channel.epg_data_id,
             })
 
-        # Get all EPG data from active sources, ordered by source priority (highest first) so we prefer higher priority matches
-        epg_data = []
-        for epg in EPGData.objects.select_related('epg_source').filter(epg_source__is_active=True):
-            normalized_tvg_id = epg.tvg_id.strip().lower() if epg.tvg_id else ""
-            epg_data.append({
-                'id': epg.id,
-                'tvg_id': normalized_tvg_id,
-                'original_tvg_id': epg.tvg_id,
-                'name': epg.name,
-                'norm_name': normalize_name(epg.name),
-                'epg_source_id': epg.epg_source.id if epg.epg_source else None,
-                'epg_source_priority': epg.epg_source.priority if epg.epg_source else 0,
-            })
-
-        # Sort EPG data by source priority (highest first) so we prefer higher priority matches
-        epg_data.sort(key=lambda x: x['epg_source_priority'], reverse=True)
-
+        epg_data, epg_tvg_id_index = build_epg_matching_catalog()
         logger.info(f"Processing {len(channels_data)} channels against {len(epg_data)} EPG entries (from active sources only)")
 
         # Run EPG matching with progress updates - automatically uses conservative thresholds for bulk operations
-        result = match_channels_to_epg(channels_data, epg_data, region_code, use_ml=True, send_progress=True)
+        result = match_channels_to_epg(
+            channels_data,
+            epg_data,
+            region_code,
+            use_ml=True,
+            send_progress=True,
+            epg_tvg_id_index=epg_tvg_id_index,
+        )
         channels_to_update_dicts = result["channels_to_update"]
         matched_channels = result["matched_channels"]
+        unchanged_channels = result.get("unchanged_channels", [])
 
-        # Update channels in database
-        if channels_to_update_dicts:
-            channel_ids = [d["id"] for d in channels_to_update_dicts]
-            channels_qs = Channel.objects.filter(id__in=channel_ids)
-            channels_list = list(channels_qs)
+        changed_associations = apply_matched_epg_to_channels(channels_to_update_dicts)
 
-            # Create mapping from channel_id to epg_data_id
-            epg_mapping = {d["id"]: d["epg_data_id"] for d in channels_to_update_dicts}
-
-            # Update each channel with matched EPG data
-            for channel_obj in channels_list:
-                epg_data_id = epg_mapping.get(channel_obj.id)
-                if epg_data_id:
-                    try:
-                        epg_data_obj = EPGData.objects.get(id=epg_data_id)
-                        channel_obj.epg_data = epg_data_obj
-                    except EPGData.DoesNotExist:
-                        logger.error(f"EPG data {epg_data_id} not found for channel {channel_obj.id}")
-
-            # Bulk update all channels
-            Channel.objects.bulk_update(channels_list, ["epg_data"])
-
-        total_matched = len(matched_channels)
-        if total_matched:
-            logger.info(f"Match Summary: {total_matched} channel(s) matched.")
+        channels_updated = len(changed_associations)
+        if channels_updated:
+            logger.info(f"Match Summary: {channels_updated} channel(s) updated.")
             for (cid, cname, tvg) in matched_channels:
-                logger.info(f"  - Channel ID={cid}, Name='{cname}' => tvg_id='{tvg}'")
-        else:
-            logger.info("No new channels were matched.")
+                logger.info(f"  - Channel '{cname}' (id={cid}) => tvg_id={tvg!r}")
+        if unchanged_channels:
+            logger.debug(
+                f"{len(unchanged_channels)} channel(s) already correctly matched (unchanged)"
+            )
+        if not channels_updated and not unchanged_channels:
+            logger.info("No channels were matched.")
 
         logger.info("Finished integrated EPG matching.")
 
-        # Send WebSocket update
-        channel_layer = get_channel_layer()
-        associations = [
-            {"channel_id": chan["id"], "epg_data_id": chan["epg_data_id"]}
-            for chan in channels_to_update_dicts
-        ]
+        from core.utils import send_websocket_update
 
-        async_to_sync(channel_layer.group_send)(
+        if channels_updated:
+            match_message = f"EPG matching complete: {channels_updated} channel(s) updated"
+        elif unchanged_channels:
+            match_message = (
+                f"EPG matching complete: {len(unchanged_channels)} channel(s) "
+                f"already correctly matched"
+            )
+        else:
+            match_message = "EPG matching complete: no matches found"
+
+        send_websocket_update(
             'updates',
+            'update',
             {
-                'type': 'update',
-                "data": {
-                    "success": True,
-                    "type": "epg_match",
-                    "refresh_channels": True,
-                    "matches_count": total_matched,
-                    "message": f"EPG matching complete: {total_matched} channel(s) matched",
-                    "associations": associations
-                }
-            }
+                "success": True,
+                "type": "epg_match",
+                "refresh_channels": True,
+                "matches_count": channels_updated,
+                "message": match_message,
+                "associations": changed_associations,
+            },
         )
 
-        return f"Done. Matched {total_matched} channel(s)."
+        return (
+            f"Done. {channels_updated} channel(s) updated "
+            f"({len(unchanged_channels)} unchanged)."
+        )
 
     finally:
-        # Clean up ML models from memory after bulk matching
-        if _ml_model_cache['sentence_transformer'] is not None:
-            logger.info("Cleaning up ML models from memory")
-            _ml_model_cache['sentence_transformer'] = None
-
-        # Memory cleanup
-        gc.collect()
+        cleanup_after_matching()
         from core.utils import cleanup_memory
         cleanup_memory(log_usage=True, force_collection=True)
 
@@ -806,36 +327,31 @@ def match_selected_channels_epg(channel_ids):
         except CoreSettings.DoesNotExist:
             region_code = None
 
-        # Get only the specified channels that don't have EPG data assigned
-        channels_without_epg = Channel.objects.filter(
-            id__in=channel_ids,
-            epg_data__isnull=True
-        )
-        logger.info(f"Found {channels_without_epg.count()} selected channels without EPG data")
+        # Selected-channel matching always runs, including channels that already have EPG.
+        selected_channels = Channel.objects.filter(id__in=channel_ids)
+        logger.info(f"Processing {selected_channels.count()} selected channel(s) for EPG matching")
 
-        if not channels_without_epg.exists():
-            logger.info("No selected channels need EPG matching.")
+        if not selected_channels.exists():
+            logger.info("No selected channels found for EPG matching.")
 
-            # Send WebSocket update
-            channel_layer = get_channel_layer()
-            async_to_sync(channel_layer.group_send)(
+            from core.utils import send_websocket_update
+
+            send_websocket_update(
                 'updates',
+                'update',
                 {
-                    'type': 'update',
-                    "data": {
-                        "success": True,
-                        "type": "epg_match",
-                        "refresh_channels": True,
-                        "matches_count": 0,
-                        "message": "No selected channels need EPG matching",
-                        "associations": []
-                    }
-                }
+                    "success": True,
+                    "type": "epg_match",
+                    "refresh_channels": True,
+                    "matches_count": 0,
+                    "message": "No selected channels found for EPG matching",
+                    "associations": [],
+                },
             )
-            return "No selected channels needed EPG matching."
+            return "No selected channels found for EPG matching."
 
         channels_data = []
-        for channel in channels_without_epg:
+        for channel in selected_channels:
             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({
@@ -846,246 +362,91 @@ def match_selected_channels_epg(channel_ids):
                 "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)
+                "norm_chan": normalize_name(channel.name),
+                "current_epg_data_id": channel.epg_data_id,
             })
 
-        # Get all EPG data from active sources, ordered by source priority (highest first) so we prefer higher priority matches
-        epg_data = []
-        for epg in EPGData.objects.select_related('epg_source').filter(epg_source__is_active=True):
-            normalized_tvg_id = epg.tvg_id.strip().lower() if epg.tvg_id else ""
-            epg_data.append({
-                'id': epg.id,
-                'tvg_id': normalized_tvg_id,
-                'original_tvg_id': epg.tvg_id,
-                'name': epg.name,
-                'norm_name': normalize_name(epg.name),
-                'epg_source_id': epg.epg_source.id if epg.epg_source else None,
-                'epg_source_priority': epg.epg_source.priority if epg.epg_source else 0,
-            })
-
-        # Sort EPG data by source priority (highest first) so we prefer higher priority matches
-        epg_data.sort(key=lambda x: x['epg_source_priority'], reverse=True)
-
+        epg_data, epg_tvg_id_index = build_epg_matching_catalog()
         logger.info(f"Processing {len(channels_data)} selected channels against {len(epg_data)} EPG entries (from active sources only)")
 
         # Run EPG matching with progress updates - automatically uses appropriate thresholds
-        result = match_channels_to_epg(channels_data, epg_data, region_code, use_ml=True, send_progress=True)
+        result = match_channels_to_epg(
+            channels_data,
+            epg_data,
+            region_code,
+            use_ml=True,
+            send_progress=True,
+            epg_tvg_id_index=epg_tvg_id_index,
+        )
         channels_to_update_dicts = result["channels_to_update"]
         matched_channels = result["matched_channels"]
+        unchanged_channels = result.get("unchanged_channels", [])
 
-        # Update channels in database
-        if channels_to_update_dicts:
-            channel_ids_to_update = [d["id"] for d in channels_to_update_dicts]
-            channels_qs = Channel.objects.filter(id__in=channel_ids_to_update)
-            channels_list = list(channels_qs)
+        changed_associations = apply_matched_epg_to_channels(channels_to_update_dicts)
 
-            # Create mapping from channel_id to epg_data_id
-            epg_mapping = {d["id"]: d["epg_data_id"] for d in channels_to_update_dicts}
-
-            # Update each channel with matched EPG data
-            for channel_obj in channels_list:
-                epg_data_id = epg_mapping.get(channel_obj.id)
-                if epg_data_id:
-                    try:
-                        epg_data_obj = EPGData.objects.get(id=epg_data_id)
-                        channel_obj.epg_data = epg_data_obj
-                    except EPGData.DoesNotExist:
-                        logger.error(f"EPG data {epg_data_id} not found for channel {channel_obj.id}")
-
-            # Bulk update all channels
-            Channel.objects.bulk_update(channels_list, ["epg_data"])
-
-        total_matched = len(matched_channels)
-        if total_matched:
-            logger.info(f"Selected Channel Match Summary: {total_matched} channel(s) matched.")
+        channels_updated = len(changed_associations)
+        if channels_updated:
+            logger.info(
+                f"Selected Channel Match Summary: {channels_updated} channel(s) updated."
+            )
             for (cid, cname, tvg) in matched_channels:
-                logger.info(f"  - Channel ID={cid}, Name='{cname}' => tvg_id='{tvg}'")
-        else:
+                logger.info(f"  - Channel '{cname}' (id={cid}) => tvg_id={tvg!r}")
+        if unchanged_channels:
+            logger.debug(
+                f"{len(unchanged_channels)} selected channel(s) already correctly matched "
+                f"(unchanged)"
+            )
+        if not channels_updated and not unchanged_channels:
             logger.info("No selected channels were matched.")
 
         logger.info("Finished integrated EPG matching for selected channels.")
 
-        # Send WebSocket update
-        channel_layer = get_channel_layer()
-        associations = [
-            {"channel_id": chan["id"], "epg_data_id": chan["epg_data_id"]}
-            for chan in channels_to_update_dicts
-        ]
+        from core.utils import send_websocket_update
 
-        async_to_sync(channel_layer.group_send)(
+        if channels_updated:
+            match_message = (
+                f"EPG matching complete: {channels_updated} selected channel(s) updated"
+            )
+        elif unchanged_channels:
+            match_message = (
+                f"EPG matching complete: {len(unchanged_channels)} selected channel(s) "
+                f"already correctly matched"
+            )
+        else:
+            match_message = "EPG matching complete: no matches found"
+
+        send_websocket_update(
             'updates',
+            'update',
             {
-                'type': 'update',
-                "data": {
-                    "success": True,
-                    "type": "epg_match",
-                    "refresh_channels": True,
-                    "matches_count": total_matched,
-                    "message": f"EPG matching complete: {total_matched} selected channel(s) matched",
-                    "associations": associations
-                }
-            }
+                "success": True,
+                "type": "epg_match",
+                "refresh_channels": True,
+                "matches_count": channels_updated,
+                "message": match_message,
+                "associations": changed_associations,
+            },
         )
 
-        return f"Done. Matched {total_matched} selected channel(s)."
+        return (
+            f"Done. {channels_updated} selected channel(s) updated "
+            f"({len(unchanged_channels)} unchanged)."
+        )
 
     finally:
-        # Clean up ML models from memory after bulk matching
-        if _ml_model_cache['sentence_transformer'] is not None:
-            logger.info("Cleaning up ML models from memory")
-            _ml_model_cache['sentence_transformer'] = None
-
-        # Memory cleanup
-        gc.collect()
+        cleanup_after_matching()
         from core.utils import cleanup_memory
         cleanup_memory(log_usage=True, force_collection=True)
 
 
 @shared_task
 def match_single_channel_epg(channel_id):
-    """
-    Try to match a single channel with EPG data using the integrated matching logic
-    that includes both fuzzy and ML-enhanced matching. Returns a dict with match status and message.
-    """
+    """Match one channel to EPG data (async; results pushed via WebSocket)."""
     try:
-        from apps.channels.models import Channel
-        from apps.epg.models import EPGData
-
-        logger.info(f"Starting integrated single channel EPG matching for channel ID {channel_id}")
-
-        # Get the channel
-        try:
-            channel = Channel.objects.get(id=channel_id)
-        except Channel.DoesNotExist:
-            return {"matched": False, "message": "Channel not found"}
-
-        # If channel already has EPG data, skip
-        if channel.epg_data:
-            return {"matched": False, "message": f"Channel '{channel.name}' already has EPG data assigned"}
-
-        # 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}', 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
-        test_normalized = normalize_name(test_name)
-        logger.debug(f"DEBUG normalization example: '{test_name}' → '{test_normalized}' (call sign preserved)")
-
-        # Get all EPG data for matching from active sources - must include norm_name field
-        # Ordered by source priority (highest first) so we prefer higher priority matches
-        epg_data_list = []
-        for epg in EPGData.objects.select_related('epg_source').filter(epg_source__is_active=True, name__isnull=False).exclude(name=''):
-            normalized_epg_tvg_id = epg.tvg_id.strip().lower() if epg.tvg_id else ""
-            epg_data_list.append({
-                'id': epg.id,
-                'tvg_id': normalized_epg_tvg_id,
-                'original_tvg_id': epg.tvg_id,
-                'name': epg.name,
-                'norm_name': normalize_name(epg.name),
-                'epg_source_id': epg.epg_source.id if epg.epg_source else None,
-                'epg_source_priority': epg.epg_source.priority if epg.epg_source else 0,
-            })
-
-        # Sort EPG data by source priority (highest first) so we prefer higher priority matches
-        epg_data_list.sort(key=lambda x: x['epg_source_priority'], reverse=True)
-
-        if not epg_data_list:
-            return {"matched": False, "message": "No EPG data available for matching (from active sources)"}
-
-        logger.info(f"Matching single channel '{channel.name}' against {len(epg_data_list)} EPG entries")
-
-        # Send progress for single channel matching
-        send_epg_matching_progress(1, 0, current_channel_name=channel.name, stage="matching")
-
-        # Use the EPG matching function - automatically uses aggressive thresholds for single channel
-        result = match_channels_to_epg([channel_data], epg_data_list, send_progress=False)
-        channels_to_update = result.get("channels_to_update", [])
-        matched_channels = result.get("matched_channels", [])
-
-        if channels_to_update:
-            # Find our channel in the results
-            channel_match = None
-            for update in channels_to_update:
-                if update["id"] == channel.id:
-                    channel_match = update
-                    break
-
-            if channel_match:
-                # Apply the match to the channel
-                try:
-                    epg_data = EPGData.objects.get(id=channel_match['epg_data_id'])
-                    channel.epg_data = epg_data
-                    channel.save(update_fields=["epg_data"])
-
-                    # Find match details from matched_channels for better reporting
-                    match_details = None
-                    for match_info in matched_channels:
-                        if match_info[0] == channel.id:  # matched_channels format: (channel_id, channel_name, epg_info)
-                            match_details = match_info
-                            break
-
-                    success_msg = f"Channel '{channel.name}' matched with EPG '{epg_data.name}'"
-                    if match_details:
-                        success_msg += f" (matched via: {match_details[2]})"
-
-                    logger.info(success_msg)
-
-                    # Send completion progress for single channel
-                    send_epg_matching_progress(1, 1, current_channel_name=channel.name, stage="completed")
-
-                    # Clean up ML models from memory after single channel matching
-                    if _ml_model_cache['sentence_transformer'] is not None:
-                        logger.info("Cleaning up ML models from memory")
-                        _ml_model_cache['sentence_transformer'] = None
-                        gc.collect()
-
-                    return {
-                        "matched": True,
-                        "message": success_msg,
-                        "epg_name": epg_data.name,
-                        "epg_id": epg_data.id
-                    }
-                except EPGData.DoesNotExist:
-                    return {"matched": False, "message": "Matched EPG data not found"}
-
-        # No match found
-        # Send completion progress for single channel (failed)
-        send_epg_matching_progress(1, 0, current_channel_name=channel.name, stage="completed")
-
-        # Clean up ML models from memory after single channel matching
-        if _ml_model_cache['sentence_transformer'] is not None:
-            logger.info("Cleaning up ML models from memory")
-            _ml_model_cache['sentence_transformer'] = None
-            gc.collect()
-
-        return {
-            "matched": False,
-            "message": f"No suitable EPG match found for channel '{channel.name}'"
-        }
-
-    except Exception as e:
-        logger.error(f"Error in integrated single channel EPG matching: {e}", exc_info=True)
-
-        # Clean up ML models from memory even on error
-        if _ml_model_cache['sentence_transformer'] is not None:
-            logger.info("Cleaning up ML models from memory after error")
-            _ml_model_cache['sentence_transformer'] = None
-            gc.collect()
-
-        return {"matched": False, "message": f"Error during matching: {str(e)}"}
+        return run_single_channel_epg_match(channel_id)
+    finally:
+        from core.utils import cleanup_memory
+        cleanup_memory(log_usage=True, force_collection=True)
 
 
 def evaluate_series_rules_impl(tvg_id: str | None = None):
@@ -1820,12 +1181,13 @@ def _dvr_ffmpeg_retry_backoff_seconds(retry_index):
 
 def _dvr_build_ffmpeg_cmd(stream_url, recording_id, hls_m3u8, hls_seg_pattern, hls_start_number):
     """Build the FFmpeg command for DVR HLS segment recording."""
+    from core.utils import dispatcharr_dvr_user_agent
     return [
         "ffmpeg", "-y",
         "-reconnect", "1",
         "-reconnect_streamed", "1",
         "-reconnect_delay_max", "5",
-        "-user_agent", f"Dispatcharr-DVR/recording-{recording_id}",
+        "-user_agent", dispatcharr_dvr_user_agent(recording_id),
         # Regenerate monotonic PTS to handle erratic/discontinuous timestamps
         # from IPTV sources.
         "-fflags", "+genpts",
diff --git a/apps/channels/tests/test_channel_api.py b/apps/channels/tests/test_channel_api.py
index 363f5925..5d60a8da 100644
--- a/apps/channels/tests/test_channel_api.py
+++ b/apps/channels/tests/test_channel_api.py
@@ -504,3 +504,72 @@ class SeriesRuleAPITests(TestCase):
     def test_bulk_remove_requires_tvg_id_or_title(self):
         resp = self.client.post(self.bulk_remove_url, {}, format="json")
         self.assertEqual(resp.status_code, status.HTTP_400_BAD_REQUEST)
+
+
+class ChannelListIncludeStreamsQueryTests(TestCase):
+    """include_streams=true must not issue one stream query per channel."""
+
+    def setUp(self):
+        from apps.channels.models import ChannelStream, Stream
+        from apps.m3u.models import M3UAccount
+
+        self.user = User.objects.create_user(username="list_admin", password="x")
+        self.user.user_level = 10
+        self.user.save()
+        self.client = APIClient()
+        self.client.force_authenticate(user=self.user)
+
+        self.account = M3UAccount.objects.create(
+            name="list-test-account",
+            account_type="XC",
+            username="user",
+            password="pass",
+        )
+        self.group = ChannelGroup.objects.create(name=f"List Group {self.id}")
+
+    def _add_channel_with_stream(self, number):
+        from apps.channels.models import ChannelStream, Stream
+
+        channel = Channel.objects.create(
+            channel_number=float(number),
+            name=f"Channel {number}",
+            channel_group=self.group,
+        )
+        stream = Stream.objects.create(
+            name=f"Stream {number}",
+            url=f"http://example.com/{number}.ts",
+            m3u_account=self.account,
+        )
+        ChannelStream.objects.create(channel=channel, stream=stream, order=0)
+        return channel
+
+    def _query_count_for_list(self):
+        from django.db import connection
+        from django.test.utils import CaptureQueriesContext
+
+        with CaptureQueriesContext(connection) as ctx:
+            response = self.client.get(
+                "/api/channels/channels/",
+                {"page": 1, "page_size": 50, "include_streams": "true"},
+            )
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        return len(ctx.captured_queries)
+
+    def test_include_streams_query_count_stable_as_channels_grow(self):
+        self._add_channel_with_stream(1)
+        self._add_channel_with_stream(2)
+        self._add_channel_with_stream(3)
+        q_small = self._query_count_for_list()
+
+        self._add_channel_with_stream(4)
+        self._add_channel_with_stream(5)
+        self._add_channel_with_stream(6)
+        self._add_channel_with_stream(7)
+        q_large = self._query_count_for_list()
+
+        self.assertEqual(
+            q_small,
+            q_large,
+            "include_streams list should use prefetched channelstream_set, "
+            "not one streams M2M query per channel",
+        )
diff --git a/apps/channels/tests/test_epg_match_apply.py b/apps/channels/tests/test_epg_match_apply.py
new file mode 100644
index 00000000..4d0cc2e5
--- /dev/null
+++ b/apps/channels/tests/test_epg_match_apply.py
@@ -0,0 +1,58 @@
+"""Tests for applying EPG auto-match results to channels."""
+from unittest.mock import patch
+
+from django.test import TestCase
+
+from apps.channels.epg_matching import apply_matched_epg_to_channels
+from apps.channels.models import Channel
+from apps.epg.models import EPGData, EPGSource
+
+
+class ApplyMatchedEpgToChannelsTests(TestCase):
+    def setUp(self):
+        self.source = EPGSource.objects.create(
+            name="XML EPG",
+            source_type="xmltv",
+            url="http://example.com/epg.xml",
+        )
+        self.epg_one = EPGData.objects.create(
+            tvg_id="ch.one",
+            name="Channel One",
+            epg_source=self.source,
+        )
+        self.epg_two = EPGData.objects.create(
+            tvg_id="ch.two",
+            name="Channel Two",
+            epg_source=self.source,
+        )
+        self.channel = Channel.objects.create(
+            channel_number=1,
+            name="Channel One",
+            tvg_id="ch.one",
+            epg_data=self.epg_one,
+        )
+
+    @patch("apps.epg.tasks.parse_programs_for_tvg_id.delay")
+    def test_skips_unchanged_assignment(self, mock_delay):
+        changed = apply_matched_epg_to_channels(
+            [{"id": self.channel.id, "epg_data_id": self.epg_one.id}]
+        )
+
+        self.assertEqual(changed, [])
+        mock_delay.assert_not_called()
+        self.channel.refresh_from_db()
+        self.assertEqual(self.channel.epg_data_id, self.epg_one.id)
+
+    @patch("apps.epg.tasks.parse_programs_for_tvg_id.delay")
+    def test_updates_changed_assignment_and_dispatches_parse(self, mock_delay):
+        changed = apply_matched_epg_to_channels(
+            [{"id": self.channel.id, "epg_data_id": self.epg_two.id}]
+        )
+
+        self.assertEqual(
+            changed,
+            [{"channel_id": self.channel.id, "epg_data_id": self.epg_two.id}],
+        )
+        mock_delay.assert_called_once_with(self.epg_two.id)
+        self.channel.refresh_from_db()
+        self.assertEqual(self.channel.epg_data_id, self.epg_two.id)
diff --git a/apps/channels/tests/test_epg_name_normalize.py b/apps/channels/tests/test_epg_name_normalize.py
new file mode 100644
index 00000000..0fa6df5f
--- /dev/null
+++ b/apps/channels/tests/test_epg_name_normalize.py
@@ -0,0 +1,117 @@
+"""Tests for EPG channel name normalization (prefix/suffix/custom ignore rules)."""
+from django.test import TestCase
+
+from apps.channels.epg_matching import (
+    build_epg_tvg_id_index,
+    clear_normalize_settings_cache,
+    normalize_name,
+)
+from core.models import CoreSettings, EPG_SETTINGS_KEY
+
+
+class NormalizeNameSettingsTest(TestCase):
+    def _set_epg_settings(self, **kwargs):
+        obj, _ = CoreSettings.objects.get_or_create(
+            key=EPG_SETTINGS_KEY,
+            defaults={"name": "EPG Settings", "value": {}},
+        )
+        current = obj.value if isinstance(obj.value, dict) else {}
+        current.update(kwargs)
+        obj.value = current
+        obj.save()
+        clear_normalize_settings_cache()
+
+    def test_default_mode_does_not_apply_ignore_lists(self):
+        self._set_epg_settings(
+            epg_match_mode="default",
+            epg_match_ignore_prefixes=["HD:"],
+            epg_match_ignore_suffixes=[" 4K"],
+            epg_match_ignore_custom=["Plus"],
+        )
+        result_default = normalize_name("HD:HBO Plus East 4K")
+
+        self._set_epg_settings(
+            epg_match_mode="advanced",
+            epg_match_ignore_prefixes=["HD:"],
+            epg_match_ignore_suffixes=[" 4K"],
+            epg_match_ignore_custom=["Plus"],
+        )
+        result_advanced = normalize_name("HD:HBO Plus East 4K")
+
+        self.assertNotEqual(result_default, result_advanced)
+        self.assertEqual(result_advanced, "hbo east")
+
+    def test_advanced_mode_strips_prefix(self):
+        self._set_epg_settings(
+            epg_match_mode="advanced",
+            epg_match_ignore_prefixes=["HD:"],
+        )
+        self.assertEqual(
+            normalize_name("HD:ABC 7 (WXYZ) - Springfield"),
+            "abc 7 springfield wxyz",
+        )
+
+    def test_advanced_mode_strips_suffix(self):
+        self._set_epg_settings(
+            epg_match_mode="advanced",
+            epg_match_ignore_suffixes=[" 4K"],
+        )
+        self.assertEqual(
+            normalize_name("NBC 5 (KABC) - Metro 4K"),
+            "nbc 5 metro kabc",
+        )
+
+    def test_advanced_mode_removes_custom_strings(self):
+        self._set_epg_settings(
+            epg_match_mode="advanced",
+            epg_match_ignore_custom=["Plus"],
+        )
+        self.assertEqual(
+            normalize_name("HBO Plus East"),
+            "hbo east",
+        )
+
+    def test_advanced_mode_applies_prefix_suffix_and_custom_in_order(self):
+        self._set_epg_settings(
+            epg_match_mode="advanced",
+            epg_match_ignore_prefixes=["Sling:"],
+            epg_match_ignore_suffixes=[" HD"],
+            epg_match_ignore_custom=["Plus"],
+        )
+        self.assertEqual(
+            normalize_name("Sling:HBO Plus East HD"),
+            "hbo east",
+        )
+
+    def test_only_first_matching_prefix_is_removed(self):
+        self._set_epg_settings(
+            epg_match_mode="advanced",
+            epg_match_ignore_prefixes=["HD:", "SD:"],
+        )
+        self.assertEqual(normalize_name("HD:SD:Channel 5"), "sd channel 5")
+
+    def test_call_sign_preserved_from_original_name(self):
+        self._set_epg_settings(epg_match_mode="default")
+        self.assertEqual(
+            normalize_name("NBC 5 (KABC) - Metro"),
+            "nbc 5 metro kabc",
+        )
+
+    def test_tvg_id_index_prefers_first_entry_when_catalog_sorted_by_priority(self):
+        # Catalog from build_epg_matching_catalog() is highest-priority first.
+        epg_data = [
+            {"id": 2, "tvg_id": "abc.us", "epg_source_priority": 50, "name": "High"},
+            {"id": 1, "tvg_id": "abc.us", "epg_source_priority": 10, "name": "Low"},
+        ]
+        index = build_epg_tvg_id_index(epg_data)
+        self.assertEqual(index["abc.us"]["id"], 2)
+
+    def test_settings_cache_refresh_picks_up_new_rules(self):
+        self._set_epg_settings(epg_match_mode="default")
+        self.assertEqual(normalize_name("HD:ABC"), "hdabc")
+
+        self._set_epg_settings(
+            epg_match_mode="advanced",
+            epg_match_ignore_prefixes=["HD:"],
+        )
+        self.assertEqual(normalize_name("HD:ABC"), "abc")
diff --git a/apps/channels/tests/test_get_stream_assignment.py b/apps/channels/tests/test_get_stream_assignment.py
new file mode 100644
index 00000000..bd5fea2e
--- /dev/null
+++ b/apps/channels/tests/test_get_stream_assignment.py
@@ -0,0 +1,173 @@
+"""Tests for Channel.get_stream() assignment reuse and stale cleanup."""
+
+from unittest.mock import patch
+
+from django.test import TestCase
+
+from apps.channels.models import Channel, ChannelStream, Stream
+from apps.m3u.models import M3UAccount, M3UAccountProfile
+from apps.proxy.live_proxy.constants import ChannelMetadataField, ChannelState
+from apps.proxy.live_proxy.redis_keys import RedisKeys
+
+
+class FakeAssignmentRedis:
+    """In-memory Redis for channel_stream assignment tests."""
+
+    def __init__(self):
+        self._strings = {}
+        self._hashes = {}
+
+    def _decode(self, value):
+        if isinstance(value, bytes):
+            return value.decode()
+        return value
+
+    def get(self, key):
+        value = self._strings.get(key)
+        if value is None:
+            return None
+        if isinstance(value, int):
+            return str(value).encode()
+        return str(value).encode()
+
+    def set(self, key, value):
+        self._strings[key] = value
+
+    def delete(self, key):
+        self._strings.pop(key, None)
+        self._hashes.pop(key, None)
+
+    def exists(self, key):
+        return key in self._strings or key in self._hashes
+
+    def hget(self, key, field):
+        return self._hashes.get(key, {}).get(field)
+
+    def hset(self, key, mapping=None, **kwargs):
+        bucket = self._hashes.setdefault(key, {})
+        if mapping:
+            bucket.update(mapping)
+        bucket.update(kwargs)
+
+    def incr(self, key):
+        current = int(self._decode(self.get(key)) or 0)
+        current += 1
+        self._strings[key] = current
+        return current
+
+    def decr(self, key):
+        current = int(self._decode(self.get(key)) or 0)
+        current -= 1
+        self._strings[key] = current
+        return current
+
+
+class ChannelGetStreamAssignmentTests(TestCase):
+    def setUp(self):
+        self.redis = FakeAssignmentRedis()
+        self.account = M3UAccount.objects.create(
+            name="assignment-test",
+            account_type="XC",
+            username="user",
+            password="pass",
+            max_streams=5,
+        )
+        self.profile = M3UAccountProfile.objects.get(
+            m3u_account=self.account, is_default=True
+        )
+        self.profile.max_streams = 2
+        self.profile.save()
+
+        self.stream = Stream.objects.create(
+            name="Test Stream",
+            url="http://example.com/live/user/pass/1.ts",
+            m3u_account=self.account,
+        )
+        self.channel = Channel.objects.create(channel_number=501, name="Assignment Ch")
+        ChannelStream.objects.create(channel=self.channel, stream=self.stream, order=0)
+
+        self.metadata_key = RedisKeys.channel_metadata(str(self.channel.uuid))
+
+    def _seed_assignment(self):
+        self.redis.set(f"channel_stream:{self.channel.id}", self.stream.id)
+        self.redis.set(f"stream_profile:{self.stream.id}", self.profile.id)
+
+    @patch("apps.channels.models.RedisClient.get_client")
+    @patch("apps.channels.models.reserve_profile_slot")
+    def test_reuses_assignment_when_proxy_active(
+        self, mock_reserve, mock_get_client
+    ):
+        mock_get_client.return_value = self.redis
+        self._seed_assignment()
+        self.redis.hset(
+            self.metadata_key,
+            {ChannelMetadataField.STATE: ChannelState.ACTIVE},
+        )
+
+        stream_id, profile_id, error, slot_reserved = self.channel.get_stream()
+
+        self.assertEqual(stream_id, self.stream.id)
+        self.assertEqual(profile_id, self.profile.id)
+        self.assertIsNone(error)
+        self.assertFalse(slot_reserved)
+        mock_reserve.assert_not_called()
+
+    @patch("apps.channels.models.RedisClient.get_client")
+    @patch("apps.channels.models.reserve_profile_slot")
+    def test_reuses_assignment_during_init_before_metadata(
+        self, mock_reserve, mock_get_client
+    ):
+        mock_get_client.return_value = self.redis
+        self._seed_assignment()
+
+        stream_id, profile_id, error, slot_reserved = self.channel.get_stream()
+
+        self.assertEqual(stream_id, self.stream.id)
+        self.assertEqual(profile_id, self.profile.id)
+        self.assertIsNone(error)
+        self.assertFalse(slot_reserved)
+        mock_reserve.assert_not_called()
+
+    @patch("apps.channels.models.RedisClient.get_client")
+    @patch("apps.channels.models.release_profile_slot")
+    @patch("apps.channels.models.reserve_profile_slot")
+    def test_releases_stale_assignment_when_proxy_stopped(
+        self, mock_reserve, mock_release, mock_get_client
+    ):
+        mock_get_client.return_value = self.redis
+        mock_reserve.return_value = (True, 1, None)
+        self._seed_assignment()
+        self.redis.hset(
+            self.metadata_key,
+            {ChannelMetadataField.STATE: ChannelState.STOPPED},
+        )
+
+        stream_id, profile_id, error, slot_reserved = self.channel.get_stream()
+
+        mock_release.assert_called_once_with(self.profile.id, self.redis)
+        mock_reserve.assert_called_once()
+        self.assertEqual(stream_id, self.stream.id)
+        self.assertEqual(profile_id, self.profile.id)
+        self.assertTrue(slot_reserved)
+
+    @patch("apps.channels.models.RedisClient.get_client")
+    def test_stream_assignment_is_reusable_during_init_pending(self, mock_get_client):
+        mock_get_client.return_value = self.redis
+        self._seed_assignment()
+
+        self.assertTrue(
+            self.channel._stream_assignment_is_reusable(self.redis, self.stream.id)
+        )
+
+    @patch("apps.channels.models.RedisClient.get_client")
+    def test_stream_assignment_not_reusable_when_stopped(self, mock_get_client):
+        mock_get_client.return_value = self.redis
+        self._seed_assignment()
+        self.redis.hset(
+            self.metadata_key,
+            {ChannelMetadataField.STATE: ChannelState.STOPPED},
+        )
+
+        self.assertFalse(
+            self.channel._stream_assignment_is_reusable(self.redis, self.stream.id)
+        )
diff --git a/apps/channels/tests/test_recording_playback_auth.py b/apps/channels/tests/test_recording_playback_auth.py
new file mode 100644
index 00000000..87cc251f
--- /dev/null
+++ b/apps/channels/tests/test_recording_playback_auth.py
@@ -0,0 +1,193 @@
+"""Tests for DVR recording playback authentication (file/hls endpoints)."""
+import os
+import shutil
+import tempfile
+from types import SimpleNamespace
+from unittest.mock import patch
+
+from django.test import TestCase, override_settings
+from django.utils import timezone
+from rest_framework.test import APIClient
+from rest_framework_simplejwt.tokens import RefreshToken
+
+from apps.channels.api_views import _recording_auth_query_suffix
+from apps.channels.models import Channel, Recording
+
+
+def _make_admin():
+    from django.contrib.auth import get_user_model
+
+    User = get_user_model()
+    user, _ = User.objects.get_or_create(
+        username="recording_playback_admin",
+        defaults={"user_level": User.UserLevel.ADMIN},
+    )
+    user.user_level = User.UserLevel.ADMIN
+    user.set_password("pass")
+    user.save()
+    return user
+
+
+@override_settings(ALLOWED_HOSTS=["testserver"])
+@patch("apps.channels.api_views.network_access_allowed", return_value=True)
+class RecordingPlaybackAuthTests(TestCase):
+    def setUp(self):
+        self.channel = Channel.objects.create(channel_number=42, name="Playback Auth Channel")
+        self.user = _make_admin()
+        self.client = APIClient()
+        self.tmp = tempfile.NamedTemporaryFile(suffix=".mkv", delete=False)
+        self.tmp.write(b"\x00" * 1024)
+        self.tmp.close()
+        self.hls_dir = tempfile.mkdtemp(prefix="dvr_playback_auth_hls_")
+        with open(os.path.join(self.hls_dir, "index.m3u8"), "w", encoding="utf-8") as playlist:
+            playlist.write("#EXTM3U\n#EXTINF:4.0,\nseg_00001.ts\n")
+        with open(os.path.join(self.hls_dir, "seg_00001.ts"), "wb") as segment:
+            segment.write(b"\x00" * 188)
+        now = timezone.now()
+        self.recording = Recording.objects.create(
+            channel=self.channel,
+            start_time=now,
+            end_time=now,
+            custom_properties={
+                "status": "completed",
+                "file_path": self.tmp.name,
+                "file_name": "test.mkv",
+            },
+        )
+
+    def tearDown(self):
+        if os.path.exists(self.tmp.name):
+            os.unlink(self.tmp.name)
+        if os.path.isdir(self.hls_dir):
+            shutil.rmtree(self.hls_dir, ignore_errors=True)
+
+    @staticmethod
+    def _jwt_for(user):
+        return str(RefreshToken.for_user(user).access_token)
+
+    def test_file_requires_authentication(self, _mock_network):
+        response = self.client.get(
+            f"/api/channels/recordings/{self.recording.id}/file/"
+        )
+        self.assertEqual(response.status_code, 403)
+
+    def test_file_accepts_jwt_query_param(self, _mock_network):
+        token = self._jwt_for(self.user)
+        response = self.client.get(
+            f"/api/channels/recordings/{self.recording.id}/file/",
+            {"token": token},
+        )
+        self.assertEqual(response.status_code, 200)
+
+    def test_file_redirect_to_hls_preserves_token(self, _mock_network):
+        pending = os.path.join(self.hls_dir, "pending.mkv")
+        now = timezone.now()
+        in_progress = Recording.objects.create(
+            channel=self.channel,
+            start_time=now,
+            end_time=now,
+            custom_properties={
+                "status": "recording",
+                "_hls_dir": self.hls_dir,
+                "file_path": pending,
+            },
+        )
+        token = self._jwt_for(self.user)
+        response = self.client.get(
+            f"/api/channels/recordings/{in_progress.id}/file/",
+            {"token": token},
+        )
+        self.assertEqual(response.status_code, 302)
+        self.assertIn("token=", response["Location"])
+        self.assertIn("/hls/index.m3u8", response["Location"])
+
+    def test_hls_playlist_rewrites_segments_with_token_when_present(self, _mock_network):
+        now = timezone.now()
+        hls_rec = Recording.objects.create(
+            channel=self.channel,
+            start_time=now,
+            end_time=now,
+            custom_properties={
+                "status": "recording",
+                "_hls_dir": self.hls_dir,
+            },
+        )
+        token = self._jwt_for(self.user)
+        response = self.client.get(
+            f"/api/channels/recordings/{hls_rec.id}/hls/index.m3u8",
+            {"token": token},
+        )
+        self.assertEqual(response.status_code, 200)
+        body = response.content.decode("utf-8")
+        self.assertIn("token=", body)
+        self.assertIn("seg_00001.ts", body)
+
+    def test_hls_playlist_omits_token_when_not_in_request(self, _mock_network):
+        now = timezone.now()
+        hls_rec = Recording.objects.create(
+            channel=self.channel,
+            start_time=now,
+            end_time=now,
+            custom_properties={
+                "status": "recording",
+                "_hls_dir": self.hls_dir,
+            },
+        )
+        token = self._jwt_for(self.user)
+        response = self.client.get(
+            f"/api/channels/recordings/{hls_rec.id}/hls/index.m3u8",
+            HTTP_AUTHORIZATION=f"Bearer {token}",
+        )
+        self.assertEqual(response.status_code, 200)
+        body = response.content.decode("utf-8")
+        self.assertIn("seg_00001.ts", body)
+        self.assertNotIn("token=", body)
+
+    def test_hls_segment_accepts_jwt_query_param(self, _mock_network):
+        now = timezone.now()
+        hls_rec = Recording.objects.create(
+            channel=self.channel,
+            start_time=now,
+            end_time=now,
+            custom_properties={
+                "status": "recording",
+                "_hls_dir": self.hls_dir,
+            },
+        )
+        token = self._jwt_for(self.user)
+        response = self.client.get(
+            f"/api/channels/recordings/{hls_rec.id}/hls/seg_00001.ts",
+            {"token": token},
+        )
+        self.assertEqual(response.status_code, 200)
+
+    def test_hls_redirect_to_file_preserves_token(self, _mock_network):
+        now = timezone.now()
+        hls_rec = Recording.objects.create(
+            channel=self.channel,
+            start_time=now,
+            end_time=now,
+            custom_properties={
+                "status": "completed",
+                "file_path": self.tmp.name,
+                "file_name": "test.mkv",
+            },
+        )
+        token = self._jwt_for(self.user)
+        response = self.client.get(
+            f"/api/channels/recordings/{hls_rec.id}/hls/index.m3u8",
+            {"token": token},
+        )
+        self.assertEqual(response.status_code, 302)
+        self.assertIn("token=", response["Location"])
+        self.assertIn("/file/", response["Location"])
+
+
+class RecordingAuthQuerySuffixTests(TestCase):
+    def test_empty_when_no_token(self):
+        request = SimpleNamespace(GET={})
+        self.assertEqual(_recording_auth_query_suffix(request), "")
+
+    def test_includes_token_when_present(self):
+        request = SimpleNamespace(GET={"token": "abc123"})
+        self.assertEqual(_recording_auth_query_suffix(request), "?token=abc123")
diff --git a/apps/channels/tests/test_ts_proxy_ghost_clients.py b/apps/channels/tests/test_ts_proxy_ghost_clients.py
index 6742cf4b..3cc7aa9e 100644
--- a/apps/channels/tests/test_ts_proxy_ghost_clients.py
+++ b/apps/channels/tests/test_ts_proxy_ghost_clients.py
@@ -247,6 +247,14 @@ class BasicStatsGhostClientTests(TestCase):
         redis.scard.return_value = len(client_ids)
         redis.smembers.return_value = client_ids
         redis.hget.return_value = None  # individual field lookups
+        redis.hmget.return_value = [
+            b'VLC/3.0',
+            b'127.0.0.1',
+            b'1773500000.0',
+            None,
+            b'mpegts',
+            None,
+        ]
 
         # Pipeline for remove_ghost_clients
         pipe = MagicMock()
diff --git a/apps/channels/tests/test_ts_proxy_keepalive.py b/apps/channels/tests/test_ts_proxy_keepalive.py
index b8fb524a..8645a158 100644
--- a/apps/channels/tests/test_ts_proxy_keepalive.py
+++ b/apps/channels/tests/test_ts_proxy_keepalive.py
@@ -218,7 +218,7 @@ class DoStatsUpdateTests(TestCase):
         mock_redis.scan.return_value = (0, [])
 
         with patch("apps.proxy.live_proxy.client_manager.send_websocket_update") as mock_ws, \
-             patch("redis.Redis.from_url", return_value=mock_redis):
+             patch("core.utils.RedisClient.get_client", return_value=mock_redis):
             cm._do_stats_update()
 
         mock_ws.assert_called_once()
@@ -231,25 +231,25 @@ class DoStatsUpdateTests(TestCase):
         """Redis failure must be swallowed (logged), not propagated."""
         cm = self._make_client_manager()
 
-        with patch("redis.Redis.from_url", side_effect=Exception("Redis down")):
+        with patch("core.utils.RedisClient.get_client", side_effect=Exception("Redis down")):
             try:
                 cm._do_stats_update()
             except Exception as e:
                 self.fail(f"_do_stats_update raised an exception: {e}")
 
-    def test_do_stats_update_scans_channel_client_keys(self):
-        """Must scan for live:channel:*:clients pattern."""
+    def test_do_stats_update_scans_channel_metadata_keys(self):
+        """Must scan for live:channel:*:metadata pattern."""
         cm = self._make_client_manager()
 
         mock_redis = MagicMock()
         mock_redis.scan.return_value = (0, [])
 
         with patch("apps.proxy.live_proxy.client_manager.send_websocket_update"), \
-             patch("redis.Redis.from_url", return_value=mock_redis):
+             patch("core.utils.RedisClient.get_client", return_value=mock_redis):
             cm._do_stats_update()
 
         scan_call = mock_redis.scan.call_args
-        self.assertIn("live:channel:*:clients", str(scan_call))
+        self.assertIn("live:channel:*:metadata", str(scan_call))
 
 
 # ---------------------------------------------------------------------------
diff --git a/apps/channels/tests/test_ts_proxy_teardown.py b/apps/channels/tests/test_ts_proxy_teardown.py
new file mode 100644
index 00000000..b76918ac
--- /dev/null
+++ b/apps/channels/tests/test_ts_proxy_teardown.py
@@ -0,0 +1,984 @@
+"""Tests for multi-worker channel teardown coordination."""
+import time
+from unittest.mock import ANY, MagicMock, patch
+
+from django.test import TestCase
+
+from apps.proxy.live_proxy.constants import ChannelMetadataField, ChannelState
+from apps.proxy.live_proxy.input.buffer import StreamBuffer
+from apps.proxy.live_proxy.input.manager import StreamManager
+from apps.proxy.live_proxy.redis_keys import RedisKeys
+from apps.proxy.live_proxy.server import ProxyServer
+from apps.proxy.live_proxy.services.channel_service import ChannelService
+
+
+CHANNEL_ID = "00000000-0000-0000-0000-000000000099"
+
+
+def _configure_ownership_pipeline(
+    redis,
+    *,
+    stop_exists=0,
+    metadata_exists=1,
+    client_count=0,
+    owner=None,
+    disconnect=None,
+    state=None,
+):
+    pipe = MagicMock()
+    redis.pipeline.return_value = pipe
+    pipe.execute.return_value = (
+        stop_exists,
+        metadata_exists,
+        client_count,
+        owner,
+        disconnect,
+        state,
+    )
+    return pipe
+
+
+def _mock_proxy_server(redis_client=None):
+    server = MagicMock()
+    server.redis_client = redis_client or MagicMock()
+    server._stopping_channels = set()
+    return server
+
+
+class ChannelTeardownAvailabilityTests(TestCase):
+    @patch("apps.proxy.live_proxy.services.channel_service.ProxyServer.get_instance")
+    def test_teardown_active_when_stopping_key_exists(self, mock_get_instance):
+        redis = MagicMock()
+        redis.exists.side_effect = lambda key: key == RedisKeys.channel_stopping(CHANNEL_ID)
+        mock_get_instance.return_value = _mock_proxy_server(redis)
+
+        self.assertTrue(ChannelService.is_channel_teardown_active(CHANNEL_ID))
+
+    @patch("apps.proxy.live_proxy.services.channel_service.ProxyServer.get_instance")
+    def test_teardown_active_when_metadata_state_is_stopping(self, mock_get_instance):
+        redis = MagicMock()
+        redis.exists.return_value = False
+        redis.hget.return_value = ChannelState.STOPPING.encode()
+        mock_get_instance.return_value = _mock_proxy_server(redis)
+
+        self.assertTrue(ChannelService.is_channel_teardown_active(CHANNEL_ID))
+
+    @patch("apps.proxy.live_proxy.services.channel_service.ConfigHelper.channel_shutdown_delay")
+    @patch("apps.proxy.live_proxy.services.channel_service.ProxyServer.get_instance")
+    def test_shutdown_pending_within_delay_window(self, mock_get_instance, mock_delay):
+        mock_delay.return_value = 5
+        redis = MagicMock()
+        redis.exists.return_value = False
+        redis.get.return_value = str(time.time() - 2).encode()
+        mock_get_instance.return_value = _mock_proxy_server(redis)
+
+        self.assertTrue(ChannelService.is_shutdown_pending(CHANNEL_ID))
+        self.assertFalse(ChannelService.is_channel_unavailable_for_new_clients(CHANNEL_ID))
+
+    @patch("apps.proxy.live_proxy.services.channel_service.ConfigHelper.channel_shutdown_delay")
+    @patch("apps.proxy.live_proxy.services.channel_service.ProxyServer.get_instance")
+    def test_cancel_pending_shutdown_clears_disconnect_key(self, mock_get_instance, mock_delay):
+        mock_delay.return_value = 30
+        redis = MagicMock()
+        redis.exists.side_effect = lambda key: "last_client_disconnect" in key
+        redis.get.return_value = None
+        redis.hget.return_value = ChannelState.ACTIVE.encode()
+        mock_get_instance.return_value = _mock_proxy_server(redis)
+
+        self.assertTrue(ChannelService.cancel_pending_shutdown(CHANNEL_ID))
+        redis.delete.assert_any_call(RedisKeys.last_client_disconnect(CHANNEL_ID))
+
+    @patch("apps.proxy.live_proxy.services.channel_service.ConfigHelper.channel_shutdown_delay")
+    @patch("apps.proxy.live_proxy.services.channel_service.ProxyServer.get_instance")
+    def test_cancel_pending_shutdown_skips_during_active_stop(self, mock_get_instance, mock_delay):
+        mock_delay.return_value = 30
+        redis = MagicMock()
+        redis.exists.return_value = True
+        server = _mock_proxy_server(redis)
+        server._stopping_channels = {CHANNEL_ID}
+        mock_get_instance.return_value = server
+
+        self.assertFalse(ChannelService.cancel_pending_shutdown(CHANNEL_ID))
+        redis.delete.assert_not_called()
+
+    @patch("apps.proxy.live_proxy.services.channel_service.ConfigHelper.channel_shutdown_delay")
+    @patch("apps.proxy.live_proxy.services.channel_service.ProxyServer.get_instance")
+    def test_cancel_pending_shutdown_skips_real_teardown_without_grace(self, mock_get_instance, mock_delay):
+        mock_delay.return_value = 30
+        redis = MagicMock()
+        redis.exists.side_effect = lambda key: "stopping" in key
+        redis.get.return_value = None
+        redis.hget.return_value = ChannelState.STOPPING.encode()
+        mock_get_instance.return_value = _mock_proxy_server(redis)
+
+        self.assertFalse(ChannelService.cancel_pending_shutdown(CHANNEL_ID))
+        redis.hset.assert_not_called()
+        redis.delete.assert_not_called()
+
+    @patch("apps.proxy.live_proxy.services.channel_service.ConfigHelper.channel_shutdown_delay")
+    @patch("apps.proxy.live_proxy.services.channel_service.ProxyServer.get_instance")
+    def test_shutdown_pending_expired_after_delay(self, mock_get_instance, mock_delay):
+        mock_delay.return_value = 5
+        redis = MagicMock()
+        redis.exists.return_value = False
+        redis.get.return_value = str(time.time() - 10).encode()
+        mock_get_instance.return_value = _mock_proxy_server(redis)
+
+        self.assertFalse(ChannelService.is_shutdown_pending(CHANNEL_ID))
+
+
+class ClientManagerAddClientTests(TestCase):
+    @patch("apps.proxy.live_proxy.services.channel_service.ChannelService.cancel_pending_shutdown", return_value=False)
+    @patch("apps.proxy.live_proxy.client_manager.send_websocket_update")
+    def test_add_client_stores_ip_and_user_agent_in_redis(self, _mock_ws, _mock_cancel):
+        from apps.proxy.live_proxy.client_manager import ClientManager
+
+        redis = MagicMock()
+        cm = ClientManager(CHANNEL_ID, redis_client=redis, worker_id="worker-1")
+        cm.proxy_server = MagicMock()
+
+        result = cm.add_client(
+            "client-1",
+            "10.0.2.163",
+            user_agent="VLC/3.0.21",
+        )
+
+        self.assertEqual(result, 1)
+        mapping = redis.hset.call_args[1]["mapping"]
+        self.assertEqual(mapping["ip_address"], "10.0.2.163")
+        self.assertEqual(mapping["user_agent"], "VLC/3.0.21")
+
+
+class LocalStreamActivityTests(TestCase):
+    def _make_server(self):
+        with patch("apps.proxy.live_proxy.server.RedisClient.get_client", return_value=MagicMock()):
+            server = ProxyServer()
+        server.worker_id = "testhost:1"
+        server.stream_managers = {}
+        server.stream_buffers = {}
+        server.client_managers = {}
+        server.profile_managers = {}
+        server.profile_buffers = {}
+        server._live_stream_managers = {}
+        server._stopping_channels = set()
+        server.redis_client = MagicMock()
+        server.stop_all_output_formats = MagicMock()
+        server.stop_all_output_profiles = MagicMock()
+        return server
+
+    @patch.object(ProxyServer, "_join_stream_thread")
+    def test_stop_local_stream_activity_stops_live_manager(self, mock_join):
+        server = self._make_server()
+        manager = MagicMock()
+        server._live_stream_managers[CHANNEL_ID] = manager
+
+        server._stop_local_stream_activity(CHANNEL_ID)
+
+        manager.stop.assert_called_once()
+        mock_join.assert_called_once_with(CHANNEL_ID)
+        self.assertNotIn(CHANNEL_ID, server._live_stream_managers)
+
+
+class OrphanMetadataCleanupTests(TestCase):
+    def _make_server(self):
+        with patch("apps.proxy.live_proxy.server.RedisClient.get_client", return_value=MagicMock()):
+            server = ProxyServer()
+        server.worker_id = "testhost:1"
+        server.stream_managers = {}
+        server.stream_buffers = {}
+        server.client_managers = {}
+        server.profile_managers = {}
+        server.profile_buffers = {}
+        server._live_stream_managers = {}
+        server._stopping_channels = set()
+        server.redis_client = MagicMock()
+        return server
+
+    @patch.object(ProxyServer, "_clean_redis_keys")
+    @patch.object(ProxyServer, "_stop_local_stream_activity")
+    @patch.object(ProxyServer, "_has_local_upstream_activity", return_value=True)
+    def test_orphan_metadata_stops_local_processes_before_redis(
+        self, mock_has_upstream, mock_stop_local, mock_clean_redis
+    ):
+        server = self._make_server()
+        metadata_key = RedisKeys.channel_metadata(CHANNEL_ID)
+        server.redis_client.keys.return_value = [metadata_key.encode()]
+        server.redis_client.hgetall.return_value = {
+            b"owner": b"",
+            b"state": b"unknown",
+        }
+        server.redis_client.exists.return_value = False
+        server.redis_client.scard.return_value = 0
+
+        server._check_orphaned_metadata()
+
+        mock_has_upstream.assert_called_with(CHANNEL_ID)
+        mock_stop_local.assert_called_once_with(CHANNEL_ID)
+        mock_clean_redis.assert_called_once_with(CHANNEL_ID)
+
+    @patch.object(ProxyServer, "_clean_redis_keys")
+    @patch.object(ProxyServer, "_broadcast_upstream_stop")
+    @patch.object(ProxyServer, "_stop_local_stream_activity")
+    @patch.object(ProxyServer, "_has_local_upstream_activity", return_value=False)
+    def test_orphan_metadata_remote_channel_broadcasts_stop(
+        self, mock_has_upstream, mock_stop_local, mock_broadcast, mock_clean_redis
+    ):
+        server = self._make_server()
+        metadata_key = RedisKeys.channel_metadata(CHANNEL_ID)
+        server.redis_client.keys.return_value = [metadata_key.encode()]
+        server.redis_client.hgetall.return_value = {b"owner": b"", b"state": b"unknown"}
+        server.redis_client.exists.return_value = False
+        server.redis_client.scard.return_value = 0
+
+        server._check_orphaned_metadata()
+
+        mock_broadcast.assert_called_once_with(CHANNEL_ID)
+        mock_stop_local.assert_not_called()
+        mock_clean_redis.assert_called_once_with(CHANNEL_ID)
+
+
+class OrphanChannelCleanupTests(TestCase):
+    def _make_server(self):
+        with patch("apps.proxy.live_proxy.server.RedisClient.get_client", return_value=MagicMock()):
+            server = ProxyServer()
+        server.worker_id = "testhost:1"
+        server.stream_managers = {}
+        server.stream_buffers = {}
+        server.client_managers = {}
+        server.profile_managers = {}
+        server.profile_buffers = {}
+        server._live_stream_managers = {}
+        server._stopping_channels = set()
+        server.redis_client = MagicMock()
+        server.get_channel_owner = MagicMock(return_value=None)
+        return server
+
+    @patch.object(ProxyServer, "_clean_redis_keys")
+    @patch.object(ProxyServer, "_stop_local_stream_activity")
+    @patch.object(ProxyServer, "_has_local_upstream_activity", return_value=True)
+    def test_orphan_channel_stops_local_before_redis(
+        self, mock_has_upstream, mock_stop_local, mock_clean_redis
+    ):
+        server = self._make_server()
+        metadata_key = RedisKeys.channel_metadata(CHANNEL_ID)
+        server.redis_client.keys.return_value = [metadata_key.encode()]
+        server.redis_client.scard.return_value = 0
+
+        server._check_orphaned_channels()
+
+        mock_stop_local.assert_called_once_with(CHANNEL_ID)
+        mock_clean_redis.assert_called_once_with(CHANNEL_ID)
+
+
+class StreamManagerOwnershipTests(TestCase):
+    def test_still_owner_false_when_different_worker(self):
+        buffer = MagicMock()
+        _configure_ownership_pipeline(
+            buffer.redis_client,
+            owner=b"worker-b",
+        )
+        manager = StreamManager(
+            CHANNEL_ID, "http://example/stream", buffer, worker_id="worker-a"
+        )
+
+        self.assertFalse(manager._still_owner())
+
+    def test_still_owner_true_when_owner_lock_expired_but_not_stopping(self):
+        buffer = MagicMock()
+        _configure_ownership_pipeline(
+            buffer.redis_client,
+            client_count=0,
+            owner=None,
+            state=ChannelState.CONNECTING.encode(),
+        )
+        manager = StreamManager(
+            CHANNEL_ID, "http://example/stream", buffer, worker_id="worker-a"
+        )
+
+        self.assertTrue(manager._still_owner())
+
+    def test_still_owner_false_when_channel_stopping_key_set(self):
+        buffer = MagicMock()
+        _configure_ownership_pipeline(
+            buffer.redis_client,
+            stop_exists=1,
+        )
+        manager = StreamManager(
+            CHANNEL_ID, "http://example/stream", buffer, worker_id="worker-a"
+        )
+
+        self.assertFalse(manager._still_owner())
+
+    def test_update_bytes_skipped_after_ownership_lost(self):
+        buffer = MagicMock()
+        _configure_ownership_pipeline(
+            buffer.redis_client,
+            owner=b"other-worker",
+        )
+        manager = StreamManager(
+            CHANNEL_ID, "http://example/stream", buffer, worker_id="worker-a"
+        )
+        manager.bytes_processed = 1000
+
+        manager._update_bytes_processed(500)
+
+        buffer.redis_client.hincrby.assert_not_called()
+
+
+class StreamBufferStopTests(TestCase):
+    def test_stop_discards_local_data_without_redis_writes(self):
+        redis = MagicMock()
+        buffer = StreamBuffer(channel_id=CHANNEL_ID, redis_client=redis)
+        buffer._write_buffer = bytearray(b"x" * 376)
+
+        buffer.stop()
+
+        self.assertTrue(buffer.stopping)
+        self.assertEqual(len(buffer._write_buffer), 0)
+        redis.incr.assert_not_called()
+        redis.setex.assert_not_called()
+        redis.delete.assert_not_called()
+
+
+class StopChannelTeardownTests(TestCase):
+    def _make_server(self):
+        with patch("apps.proxy.live_proxy.server.RedisClient.get_client", return_value=MagicMock()):
+            server = ProxyServer()
+        server.worker_id = "testhost:1"
+        server.stream_managers = {}
+        server.stream_buffers = {}
+        server.client_managers = {}
+        server.profile_managers = {}
+        server.profile_buffers = {}
+        server._live_stream_managers = {}
+        server._stopping_channels = set()
+        server._stopping_since = {}
+        server.redis_client = MagicMock()
+        server.redis_client.exists.return_value = False
+        server.am_i_owner = MagicMock(return_value=False)
+        server._collect_channel_stop_event_data = MagicMock(return_value=None)
+        server.release_ownership = MagicMock()
+        return server
+
+    @patch.object(ProxyServer, "_spawn_channel_stop_event")
+    @patch.object(ProxyServer, "_clean_redis_keys")
+    @patch.object(ProxyServer, "_stop_local_stream_activity")
+    def test_stop_channel_cleans_redis_before_blocking_local_stop(
+        self, mock_stop_local, mock_clean_redis, mock_spawn_event
+    ):
+        server = self._make_server()
+        call_order = []
+
+        def stop_local(channel_id):
+            call_order.append("local")
+
+        def clean_redis(channel_id):
+            call_order.append("redis")
+
+        mock_stop_local.side_effect = stop_local
+        mock_clean_redis.side_effect = clean_redis
+
+        server.stop_channel(CHANNEL_ID)
+
+        self.assertEqual(call_order, ["redis", "local"])
+        mock_spawn_event.assert_called_once_with(None)
+
+    @patch.object(ProxyServer, "_spawn_channel_stop_event")
+    @patch.object(ProxyServer, "_clean_redis_keys")
+    @patch.object(ProxyServer, "_stop_local_stream_activity", side_effect=RuntimeError("boom"))
+    def test_stop_channel_cleans_redis_in_finally_when_local_stop_fails(
+        self, mock_stop_local, mock_clean_redis, mock_spawn_event
+    ):
+        server = self._make_server()
+
+        result = server.stop_channel(CHANNEL_ID)
+
+        self.assertFalse(result)
+        mock_clean_redis.assert_called_once_with(CHANNEL_ID)
+        mock_spawn_event.assert_not_called()
+        self.assertNotIn(CHANNEL_ID, server._stopping_channels)
+
+    @patch.object(ProxyServer, "_spawn_channel_stop_event")
+    @patch.object(ProxyServer, "_clean_redis_keys")
+    @patch.object(ProxyServer, "_stop_local_stream_activity")
+    def test_stop_channel_owner_releases_after_redis_cleanup(
+        self, mock_stop_local, mock_clean_redis, mock_spawn_event
+    ):
+        server = self._make_server()
+        server.am_i_owner.return_value = True
+        stop_data = {"channel_id": CHANNEL_ID}
+        server._collect_channel_stop_event_data.return_value = stop_data
+        call_order = []
+
+        def stop_local(channel_id):
+            call_order.append("local")
+
+        def release(channel_id):
+            call_order.append("release")
+
+        def clean_redis(channel_id):
+            call_order.append("redis")
+
+        mock_stop_local.side_effect = stop_local
+        server.release_ownership.side_effect = release
+        mock_clean_redis.side_effect = clean_redis
+
+        server.stop_channel(CHANNEL_ID)
+
+        self.assertEqual(call_order, ["redis", "release", "local"])
+        server._collect_channel_stop_event_data.assert_called_once_with(CHANNEL_ID)
+        mock_spawn_event.assert_called_once_with(stop_data)
+
+
+class CleanRedisKeysOrderTests(TestCase):
+    @patch("apps.proxy.live_proxy.server.Stream.objects.get")
+    @patch("apps.proxy.live_proxy.server.Channel.objects.get")
+    def test_clean_redis_keys_releases_profile_slot_before_live_keys_deleted(
+        self, mock_channel_get, mock_stream_get
+    ):
+        from apps.channels.models import Channel, Stream
+
+        with patch("apps.proxy.live_proxy.server.RedisClient.get_client", return_value=MagicMock()):
+            server = ProxyServer()
+        server.redis_client = MagicMock()
+        call_order = []
+
+        channel = MagicMock()
+        channel.release_stream.return_value = True
+
+        def channel_get(uuid):
+            call_order.append("release")
+            return channel
+
+        mock_channel_get.side_effect = channel_get
+        mock_stream_get.side_effect = Stream.DoesNotExist
+
+        channel_key = f"live:channel:{CHANNEL_ID}:input:buffer:index".encode()
+
+        def scan(cursor, match=None, count=100):
+            call_order.append("redis")
+            if match == f"live:channel:{CHANNEL_ID}:*":
+                return (0, [channel_key])
+            return (0, [])
+
+        server.redis_client.scan.side_effect = scan
+
+        server._clean_redis_keys(CHANNEL_ID)
+
+        self.assertEqual(call_order, ["release", "redis", "redis"])
+        channel.release_stream.assert_called_once()
+        server.redis_client.delete.assert_called_once_with(channel_key)
+
+
+class LocalUpstreamActivityTests(TestCase):
+    def _make_server(self):
+        with patch("apps.proxy.live_proxy.server.RedisClient.get_client", return_value=MagicMock()):
+            server = ProxyServer()
+        server.worker_id = "testhost:1"
+        server.stream_managers = {}
+        server.stream_buffers = {}
+        server.client_managers = {}
+        server._live_stream_managers = {}
+        return server
+
+    def test_upstream_activity_excludes_reader_only_client_manager(self):
+        server = self._make_server()
+        server.client_managers[CHANNEL_ID] = MagicMock()
+        server.stream_buffers[CHANNEL_ID] = MagicMock()
+        self.assertFalse(server._has_local_upstream_activity(CHANNEL_ID))
+
+    def test_upstream_activity_from_live_registry(self):
+        server = self._make_server()
+        server._live_stream_managers[CHANNEL_ID] = MagicMock()
+        self.assertTrue(server._has_local_upstream_activity(CHANNEL_ID))
+
+
+class ClientDisconnectOwnershipTests(TestCase):
+    def test_last_client_triggers_stop_when_upstream_active_without_owner_lock(self):
+        from apps.proxy.live_proxy.client_manager import ClientManager
+
+        proxy_server = MagicMock()
+        proxy_server.worker_id = "testhost:1"
+        proxy_server.am_i_owner.return_value = False
+        proxy_server._has_local_upstream_activity.return_value = True
+        proxy_server.extend_ownership.return_value = False
+
+        redis = MagicMock()
+        redis.hget.return_value = b"viewer"
+        redis.scard.return_value = 0
+
+        manager = ClientManager(
+            channel_id=CHANNEL_ID,
+            redis_client=redis,
+            worker_id="testhost:1",
+        )
+        manager.proxy_server = proxy_server
+        manager.clients = {"client-1"}
+        manager.client_set_key = RedisKeys.clients(CHANNEL_ID)
+        manager._notify_owner_of_activity = MagicMock()
+        manager._trigger_stats_update = MagicMock()
+        manager.get_total_client_count = MagicMock(return_value=0)
+        proxy_server._spawn_on_hub = MagicMock()
+
+        manager.remove_client("client-1")
+
+        proxy_server._spawn_on_hub.assert_called_once_with(
+            proxy_server.handle_client_disconnect, CHANNEL_ID
+        )
+
+
+class TeardownActiveLocalStopTests(TestCase):
+    @patch("apps.proxy.live_proxy.services.channel_service.ProxyServer.get_instance")
+    def test_teardown_active_when_local_stop_in_progress(self, mock_get_instance):
+        server = MagicMock()
+        server._stopping_channels = {CHANNEL_ID}
+        server.redis_client = MagicMock()
+        server.redis_client.exists.return_value = False
+        mock_get_instance.return_value = server
+
+        self.assertTrue(ChannelService.is_channel_teardown_active(CHANNEL_ID))
+
+
+class HandleClientDisconnectUpstreamFirstTests(TestCase):
+    def _make_server(self):
+        with patch("apps.proxy.live_proxy.server.RedisClient.get_client", return_value=MagicMock()):
+            server = ProxyServer()
+        server.worker_id = "testhost:1"
+        server.client_managers = {CHANNEL_ID: MagicMock()}
+        server.stream_managers = {CHANNEL_ID: MagicMock()}
+        server._live_stream_managers = {}
+        server.profile_managers = {}
+        server.output_managers = {}
+        server.redis_client = MagicMock()
+        server.redis_client.scard.return_value = 0
+        server._stopping_channels = set()
+        return server
+
+    @patch.object(ProxyServer, "_coordinated_stop_channel")
+    @patch.object(ProxyServer, "_stop_upstream_before_redis_cleanup")
+    @patch.object(ProxyServer, "_has_local_upstream_activity", return_value=True)
+    def test_last_client_uses_coordinated_stop_only(
+        self, _mock_upstream, mock_stop_upstream, mock_coordinated
+    ):
+        server = self._make_server()
+
+        with patch(
+            "apps.proxy.live_proxy.server.ConfigHelper.channel_shutdown_delay",
+            return_value=0,
+        ):
+            server.handle_client_disconnect(CHANNEL_ID)
+
+        mock_stop_upstream.assert_not_called()
+        mock_coordinated.assert_called_once_with(CHANNEL_ID)
+
+
+class ShutdownDelayWaitTests(TestCase):
+    def _make_server(self):
+        with patch("apps.proxy.live_proxy.server.RedisClient.get_client", return_value=MagicMock()):
+            with patch.object(ProxyServer, "_start_cleanup_thread"):
+                server = ProxyServer()
+        server.redis_client = MagicMock()
+        server.redis_client.scard.return_value = 0
+        return server
+
+    @patch("apps.proxy.live_proxy.server.gevent.sleep")
+    @patch("apps.proxy.live_proxy.server.time.time", return_value=1000.0)
+    @patch("apps.proxy.live_proxy.server.ConfigHelper.channel_shutdown_delay", return_value=30)
+    def test_aborts_when_disconnect_key_deleted(self, _mock_delay, _mock_time, mock_sleep):
+        server = self._make_server()
+        server.redis_client.get.side_effect = [b"1000.0", None]
+
+        result = server._wait_for_shutdown_delay(CHANNEL_ID)
+
+        self.assertFalse(result)
+        self.assertGreaterEqual(mock_sleep.call_count, 1)
+
+    @patch("apps.proxy.live_proxy.server.gevent.sleep")
+    @patch("apps.proxy.live_proxy.server.time.time", return_value=1000.0)
+    @patch("apps.proxy.live_proxy.server.ConfigHelper.channel_shutdown_delay", return_value=30)
+    def test_aborts_when_clients_reconnect(self, _mock_delay, _mock_time, _mock_sleep):
+        server = self._make_server()
+        server.redis_client.get.return_value = b"1000.0"
+        server.redis_client.scard.side_effect = [0, 1]
+
+        result = server._wait_for_shutdown_delay(CHANNEL_ID)
+
+        self.assertFalse(result)
+        server.redis_client.delete.assert_called_with(
+            RedisKeys.last_client_disconnect(CHANNEL_ID)
+        )
+
+    @patch("apps.proxy.live_proxy.server.gevent.sleep")
+    @patch("apps.proxy.live_proxy.server.time.time")
+    @patch("apps.proxy.live_proxy.server.ConfigHelper.channel_shutdown_delay", return_value=30)
+    def test_timer_resets_when_disconnect_timestamp_updated(
+        self, _mock_delay, mock_time, mock_sleep
+    ):
+        server = self._make_server()
+        disconnect_key = RedisKeys.last_client_disconnect(CHANNEL_ID)
+        current_time = [1000.0]
+        disconnect_timestamp = [1000.0]
+        poll_count = [0]
+
+        mock_time.side_effect = lambda: current_time[0]
+
+        def get_side_effect(key):
+            poll_count[0] += 1
+            if poll_count[0] >= 3:
+                disconnect_timestamp[0] = 1020.0
+            if key == disconnect_key:
+                return str(disconnect_timestamp[0]).encode()
+            return None
+
+        server.redis_client.get.side_effect = get_side_effect
+
+        def advance_sleep(duration):
+            current_time[0] += duration
+
+        mock_sleep.side_effect = advance_sleep
+
+        result = server._wait_for_shutdown_delay(CHANNEL_ID)
+
+        self.assertTrue(result)
+        self.assertGreaterEqual(current_time[0], 1050.0)
+
+    @patch.object(ProxyServer, "_coordinated_stop_channel")
+    @patch.object(ProxyServer, "_wait_for_shutdown_delay", return_value=True)
+    @patch("apps.proxy.live_proxy.server.ConfigHelper.channel_shutdown_delay", return_value=30)
+    def test_handle_client_disconnect_uses_polling_wait(
+        self, _mock_delay, mock_wait, mock_coordinated
+    ):
+        server = HandleClientDisconnectUpstreamFirstTests()._make_server()
+        server.redis_client.get.return_value = b"1700000000.0"
+
+        server.handle_client_disconnect(CHANNEL_ID)
+
+        mock_wait.assert_called_once_with(CHANNEL_ID)
+        mock_coordinated.assert_called_once_with(CHANNEL_ID)
+
+    @patch.object(ProxyServer, "_coordinated_stop_channel")
+    @patch.object(ProxyServer, "_wait_for_shutdown_delay", return_value=False)
+    @patch("apps.proxy.live_proxy.server.ConfigHelper.channel_shutdown_delay", return_value=30)
+    def test_handle_client_disconnect_skips_stop_when_wait_aborted(
+        self, _mock_delay, _mock_wait, mock_coordinated
+    ):
+        server = HandleClientDisconnectUpstreamFirstTests()._make_server()
+        server.redis_client.get.return_value = b"1700000000.0"
+
+        server.handle_client_disconnect(CHANNEL_ID)
+
+        mock_coordinated.assert_not_called()
+
+
+class InitWaitAbortTests(TestCase):
+    def _make_generator(self):
+        from apps.proxy.live_proxy.output.ts.generator import StreamGenerator
+
+        return StreamGenerator(
+            CHANNEL_ID,
+            "client-1",
+            "127.0.0.1",
+            "test-agent",
+            channel_initializing=True,
+        )
+
+    def test_abort_when_client_removed_locally(self):
+        generator = self._make_generator()
+        server = MagicMock()
+        client_manager = MagicMock()
+        client_manager.clients = set()
+        server.client_managers = {CHANNEL_ID: client_manager}
+        server.redis_client = MagicMock()
+
+        self.assertEqual(generator._init_wait_abort_reason(server, time.time()), "client_gone")
+
+    @patch("apps.proxy.live_proxy.output.ts.generator.ConfigHelper.channel_init_grace_period", return_value=10)
+    def test_abort_when_connect_stalled_without_buffer(self, _mock_grace):
+        generator = self._make_generator()
+        server = MagicMock()
+        client_manager = MagicMock()
+        client_manager.clients = {"client-1"}
+        server.client_managers = {CHANNEL_ID: client_manager}
+        buffer = MagicMock()
+        buffer.index = 0
+        server.stream_buffers = {CHANNEL_ID: buffer}
+        server.redis_client = MagicMock()
+        server.redis_client.hget.return_value = b"connecting"
+        server.redis_client.get.return_value = None
+
+        started = time.time() - 11
+        self.assertEqual(generator._init_wait_abort_reason(server, started), "stalled")
+
+    @patch("apps.proxy.live_proxy.output.ts.generator.ConfigHelper.channel_init_grace_period", return_value=30)
+    def test_no_stall_abort_within_init_grace_period(self, _mock_grace):
+        generator = self._make_generator()
+        server = MagicMock()
+        client_manager = MagicMock()
+        client_manager.clients = {"client-1"}
+        server.client_managers = {CHANNEL_ID: client_manager}
+        buffer = MagicMock()
+        buffer.index = 0
+        server.stream_buffers = {CHANNEL_ID: buffer}
+        server.redis_client = MagicMock()
+        server.redis_client.hget.return_value = b"connecting"
+        server.redis_client.get.return_value = None
+
+        started = time.time() - 15
+        self.assertIsNone(generator._init_wait_abort_reason(server, started))
+
+    @patch("apps.proxy.live_proxy.output.ts.generator.ConfigHelper.channel_init_grace_period", return_value=30)
+    def test_stall_abort_after_init_grace_period(self, _mock_grace):
+        generator = self._make_generator()
+        server = MagicMock()
+        client_manager = MagicMock()
+        client_manager.clients = {"client-1"}
+        server.client_managers = {CHANNEL_ID: client_manager}
+        buffer = MagicMock()
+        buffer.index = 0
+        server.stream_buffers = {CHANNEL_ID: buffer}
+        server.redis_client = MagicMock()
+        server.redis_client.hget.return_value = b"connecting"
+        server.redis_client.get.return_value = None
+
+        started = time.time() - 31
+        self.assertEqual(generator._init_wait_abort_reason(server, started), "stalled")
+
+
+class PromoteChannelWhenBufferReadyTests(TestCase):
+    def _mock_proxy(self, redis_client):
+        proxy_server = MagicMock()
+        proxy_server.redis_client = redis_client
+        return patch(
+            "apps.proxy.live_proxy.services.channel_service.ProxyServer.get_instance",
+            return_value=proxy_server,
+        ), proxy_server
+
+    @patch("apps.proxy.live_proxy.services.channel_service.ConfigHelper.initial_behind_chunks", return_value=4)
+    def test_buffer_ready_with_clients_becomes_active(self, _mock_chunks):
+        redis = MagicMock()
+        redis.hget.return_value = ChannelState.CONNECTING.encode()
+        redis.get.return_value = b"4"
+        redis.scard.return_value = 2
+
+        ctx, proxy_server = self._mock_proxy(redis)
+        with ctx:
+            result = ChannelService.promote_channel_when_buffer_ready(CHANNEL_ID)
+
+        self.assertEqual(result, ChannelState.ACTIVE)
+        proxy_server.update_channel_state.assert_called_once()
+        args = proxy_server.update_channel_state.call_args[0]
+        self.assertEqual(args[1], ChannelState.ACTIVE)
+        self.assertEqual(args[2]["clients_at_activation"], "2")
+
+    @patch("apps.proxy.live_proxy.services.channel_service.ConfigHelper.initial_behind_chunks", return_value=4)
+    def test_buffer_ready_without_clients_becomes_waiting(self, _mock_chunks):
+        redis = MagicMock()
+        redis.hget.return_value = ChannelState.CONNECTING.encode()
+        redis.get.return_value = b"5"
+        redis.scard.return_value = 0
+
+        ctx, proxy_server = self._mock_proxy(redis)
+        with ctx:
+            result = ChannelService.promote_channel_when_buffer_ready(CHANNEL_ID)
+
+        self.assertEqual(result, ChannelState.WAITING_FOR_CLIENTS)
+        proxy_server.update_channel_state.assert_called_once_with(
+            CHANNEL_ID,
+            ChannelState.WAITING_FOR_CLIENTS,
+            {
+                ChannelMetadataField.CONNECTION_READY_TIME: ANY,
+                ChannelMetadataField.BUFFER_CHUNKS: "5",
+            },
+        )
+
+    @patch("apps.proxy.live_proxy.services.channel_service.ConfigHelper.initial_behind_chunks", return_value=4)
+    def test_buffer_not_ready_does_not_promote(self, _mock_chunks):
+        redis = MagicMock()
+        redis.hget.return_value = ChannelState.CONNECTING.encode()
+        redis.get.return_value = b"2"
+
+        ctx, proxy_server = self._mock_proxy(redis)
+        with ctx:
+            result = ChannelService.promote_channel_when_buffer_ready(CHANNEL_ID)
+
+        self.assertIsNone(result)
+        proxy_server.update_channel_state.assert_not_called()
+
+    def test_waiting_for_clients_with_clients_becomes_active(self):
+        redis = MagicMock()
+
+        def hget_side_effect(key, field):
+            if field == ChannelMetadataField.STATE:
+                return ChannelState.WAITING_FOR_CLIENTS.encode()
+            if field == ChannelMetadataField.CONNECTION_READY_TIME:
+                return b"1700000000.0"
+            return None
+
+        redis.hget.side_effect = hget_side_effect
+        redis.scard.return_value = 1
+
+        ctx, proxy_server = self._mock_proxy(redis)
+        with ctx:
+            result = ChannelService.promote_channel_when_buffer_ready(CHANNEL_ID)
+
+        self.assertEqual(result, ChannelState.ACTIVE)
+        proxy_server.update_channel_state.assert_called_once_with(
+            CHANNEL_ID,
+            ChannelState.ACTIVE,
+            {"clients_at_activation": "1"},
+        )
+
+
+class UpstreamStopBroadcastTests(TestCase):
+    def _make_server(self):
+        with patch("apps.proxy.live_proxy.server.RedisClient.get_client", return_value=MagicMock()):
+            server = ProxyServer()
+        server.worker_id = "testhost:1"
+        server.stream_managers = {}
+        server._live_stream_managers = {}
+        server.redis_client = MagicMock()
+        return server
+
+    @patch.object(ProxyServer, "_stop_local_stream_activity")
+    @patch.object(ProxyServer, "_broadcast_upstream_stop")
+    @patch.object(ProxyServer, "_has_local_upstream_activity", return_value=True)
+    def test_local_upstream_stops_locally_without_broadcast(
+        self, _mock_has, mock_broadcast, mock_stop_local
+    ):
+        server = self._make_server()
+        server._stop_upstream_before_redis_cleanup(CHANNEL_ID)
+        mock_stop_local.assert_called_once_with(CHANNEL_ID)
+        mock_broadcast.assert_not_called()
+
+    @patch.object(ProxyServer, "_stop_local_stream_activity")
+    @patch.object(ProxyServer, "_broadcast_upstream_stop")
+    @patch.object(ProxyServer, "_has_local_upstream_activity", return_value=False)
+    def test_orphan_cleanup_broadcasts_when_no_local_upstream(
+        self, _mock_has, mock_broadcast, mock_stop_local
+    ):
+        server = self._make_server()
+        server._stop_upstream_before_redis_cleanup(CHANNEL_ID)
+        mock_broadcast.assert_called_once_with(CHANNEL_ID)
+        mock_stop_local.assert_not_called()
+
+
+class StreamManagerStillOwnerTests(TestCase):
+    def _make_manager(self, redis_client):
+        buffer = MagicMock()
+        buffer.redis_client = redis_client
+        buffer.channel_id = CHANNEL_ID
+        manager = StreamManager(
+            CHANNEL_ID,
+            "http://example/stream.ts",
+            buffer,
+            worker_id="testhost:1",
+        )
+        return manager
+
+    def test_stops_when_metadata_removed(self):
+        redis = MagicMock()
+        _configure_ownership_pipeline(redis, metadata_exists=0)
+        manager = self._make_manager(redis)
+        self.assertFalse(manager._still_owner())
+
+    def test_keeps_running_during_connecting_before_client_registered(self):
+        redis = MagicMock()
+        _configure_ownership_pipeline(
+            redis,
+            client_count=0,
+            owner=b"testhost:1",
+            state=ChannelState.CONNECTING.encode(),
+        )
+        manager = self._make_manager(redis)
+        self.assertTrue(manager._still_owner())
+
+    def test_stops_after_disconnect_when_shutdown_delay_is_zero(self):
+        redis = MagicMock()
+        _configure_ownership_pipeline(
+            redis,
+            client_count=0,
+            owner=b"testhost:1",
+            disconnect=b"1700000000.0",
+            state=ChannelState.ACTIVE.encode(),
+        )
+        manager = self._make_manager(redis)
+        with patch(
+            "apps.proxy.live_proxy.input.manager.ConfigHelper.channel_shutdown_delay",
+            return_value=0,
+        ):
+            self.assertFalse(manager._still_owner())
+
+    def test_keeps_running_during_shutdown_delay(self):
+        redis = MagicMock()
+        _configure_ownership_pipeline(
+            redis,
+            client_count=0,
+            owner=b"testhost:1",
+            disconnect=str(time.time()).encode(),
+            state=ChannelState.ACTIVE.encode(),
+        )
+        manager = self._make_manager(redis)
+        with patch(
+            "apps.proxy.live_proxy.input.manager.ConfigHelper.channel_shutdown_delay",
+            return_value=5,
+        ):
+            self.assertTrue(manager._still_owner())
+
+
+class PreActiveNoClientsTimeoutTests(TestCase):
+    @patch("apps.proxy.live_proxy.server.ConfigHelper.channel_client_wait_period", return_value=5)
+    def test_buffer_ready_uses_client_wait_period(self, _mock_client_wait):
+        should_stop, timeout, reason = ProxyServer._pre_active_no_clients_should_stop(
+            connection_ready_time=1000.0,
+            start_time=900.0,
+            now=1006.0,
+        )
+        self.assertTrue(should_stop)
+        self.assertEqual(timeout, 5)
+        self.assertEqual(reason, "client_wait")
+
+    @patch("apps.proxy.live_proxy.server.ConfigHelper.channel_client_wait_period", return_value=5)
+    def test_buffer_ready_within_client_wait_period(self, _mock_client_wait):
+        should_stop, timeout, reason = ProxyServer._pre_active_no_clients_should_stop(
+            connection_ready_time=1000.0,
+            start_time=900.0,
+            now=1003.0,
+        )
+        self.assertFalse(should_stop)
+        self.assertEqual(timeout, 5)
+        self.assertEqual(reason, "client_wait")
+
+    @patch("apps.proxy.live_proxy.server.ConfigHelper.channel_init_grace_period", return_value=60)
+    def test_startup_uses_init_grace_period(self, _mock_init_grace):
+        should_stop, timeout, reason = ProxyServer._pre_active_no_clients_should_stop(
+            connection_ready_time=None,
+            start_time=1000.0,
+            now=1070.0,
+        )
+        self.assertTrue(should_stop)
+        self.assertEqual(timeout, 60)
+        self.assertEqual(reason, "startup")
+
+    @patch("apps.proxy.live_proxy.server.ConfigHelper.channel_init_grace_period", return_value=60)
+    def test_startup_within_init_grace_period(self, _mock_init_grace):
+        should_stop, timeout, reason = ProxyServer._pre_active_no_clients_should_stop(
+            connection_ready_time=None,
+            start_time=1000.0,
+            now=1030.0,
+        )
+        self.assertFalse(should_stop)
+        self.assertEqual(timeout, 60)
+        self.assertEqual(reason, "startup")
+
+    @patch("apps.proxy.live_proxy.server.ConfigHelper.channel_shutdown_delay", return_value=30)
+    @patch("apps.proxy.live_proxy.server.ConfigHelper.channel_client_wait_period", return_value=5)
+    def test_buffer_ready_does_not_use_shutdown_delay(self, mock_client_wait, mock_shutdown_delay):
+        should_stop, _, reason = ProxyServer._pre_active_no_clients_should_stop(
+            connection_ready_time=1000.0,
+            start_time=900.0,
+            now=1006.0,
+        )
+        self.assertTrue(should_stop)
+        self.assertEqual(reason, "client_wait")
+        mock_client_wait.assert_called_once()
+        mock_shutdown_delay.assert_not_called()
diff --git a/apps/connect/tests/test_trigger_event.py b/apps/connect/tests/test_trigger_event.py
index 8a1c011d..5977d01c 100644
--- a/apps/connect/tests/test_trigger_event.py
+++ b/apps/connect/tests/test_trigger_event.py
@@ -35,43 +35,56 @@ def _empty_subscription_chain():
 
 
 class TriggerEventDispatchTests(SimpleTestCase):
-    def _run_trigger_event(self, plugins, event_name, payload):
+    def _run_trigger_event(self, handlers, event_name, payload, enabled_keys=None):
         pm = MagicMock()
-        pm.list_plugins.return_value = plugins
+        pm.iter_actions_for_event.return_value = handlers
+        if enabled_keys is None:
+            enabled_keys = [key for key, _ in handlers]
+
+        enabled_qs = MagicMock()
+        enabled_qs.values_list.return_value = enabled_keys
+
         with patch(
             "apps.connect.utils.PluginManager.get", return_value=pm
         ), patch(
             "apps.connect.utils.EventSubscription.objects.filter",
             return_value=_empty_subscription_chain(),
-        ):
+        ), patch(
+            "apps.plugins.models.PluginConfig"
+        ) as mock_cfg:
+            mock_cfg.objects.filter.return_value = enabled_qs
             from apps.connect.utils import trigger_event
 
             trigger_event(event_name, payload)
         return pm
 
     def test_disabled_plugin_does_not_abort_dispatch_for_later_enabled_plugin(self):
-        """The original bug: AttributeError on a disabled plugin's debug log
-        aborted the loop, so any plugin iterated AFTER a disabled one never
-        received events."""
-        plugins = [
-            {
-                "key": "disabled-plugin",
-                "name": "Disabled Plugin",
-                "enabled": False,
-                "actions": [],
-            },
-            {
-                "key": "enabled-plugin",
-                "name": "Enabled Plugin",
-                "enabled": True,
-                "actions": [
-                    {"id": "on_event", "events": ["channel_start"]},
-                ],
-            },
+        """Enabled handlers still run when other plugins are disabled in DB."""
+        handlers = [
+            ("enabled-plugin", "on_event"),
         ]
 
         pm = self._run_trigger_event(
-            plugins, "channel_start", {"channel_name": "TEST"}
+            handlers, "channel_start", {"channel_name": "TEST"}
+        )
+
+        pm.run_action.assert_called_once_with(
+            "enabled-plugin",
+            "on_event",
+            {"event": "channel_start", "payload": {"channel_name": "TEST"}},
+        )
+
+    def test_skips_handlers_for_disabled_plugins(self):
+        handlers = [
+            ("disabled-plugin", "on_event"),
+            ("enabled-plugin", "on_event"),
+        ]
+
+        pm = self._run_trigger_event(
+            handlers,
+            "channel_start",
+            {"channel_name": "TEST"},
+            enabled_keys=["enabled-plugin"],
         )
 
         pm.run_action.assert_called_once_with(
@@ -81,22 +94,64 @@ class TriggerEventDispatchTests(SimpleTestCase):
         )
 
     def test_action_without_matching_event_is_not_dispatched(self):
-        """Sanity check: actions whose `events` list doesn't include the
-        fired event, or which have no `events` key at all, are skipped."""
-        plugins = [
-            {
-                "key": "plugin",
-                "name": "Plugin",
-                "enabled": True,
-                "actions": [
-                    {"id": "on_event", "events": ["channel_stop"]},
-                    {"id": "manual_button"},  # no events key
-                ],
-            },
-        ]
-
+        """When no handlers are registered for the event, run_action is not called."""
         pm = self._run_trigger_event(
-            plugins, "channel_start", {"channel_name": "TEST"}
+            [], "channel_start", {"channel_name": "TEST"}
         )
 
         pm.run_action.assert_not_called()
+
+    def test_no_plugin_config_query_when_no_handlers(self):
+        pm = MagicMock()
+        pm.iter_actions_for_event.return_value = []
+        with patch(
+            "apps.connect.utils.PluginManager.get", return_value=pm
+        ), patch(
+            "apps.connect.utils.EventSubscription.objects.filter",
+            return_value=_empty_subscription_chain(),
+        ), patch(
+            "apps.plugins.models.PluginConfig"
+        ) as mock_cfg:
+            from apps.connect.utils import trigger_event
+
+            trigger_event("channel_start", {"channel_name": "TEST"})
+
+        mock_cfg.objects.filter.assert_not_called()
+
+    def test_plugin_action_failure_does_not_block_sibling_handlers(self):
+        handlers = [
+            ("failing-plugin", "on_event"),
+            ("working-plugin", "on_event"),
+        ]
+
+        pm = MagicMock()
+        pm.iter_actions_for_event.return_value = handlers
+        pm.run_action.side_effect = [RuntimeError("boom"), {"status": "ok"}]
+
+        enabled_qs = MagicMock()
+        enabled_qs.values_list.return_value = ["failing-plugin", "working-plugin"]
+
+        with patch(
+            "apps.connect.utils.PluginManager.get", return_value=pm
+        ), patch(
+            "apps.connect.utils.EventSubscription.objects.filter",
+            return_value=_empty_subscription_chain(),
+        ), patch(
+            "apps.plugins.models.PluginConfig"
+        ) as mock_cfg:
+            mock_cfg.objects.filter.return_value = enabled_qs
+            from apps.connect.utils import trigger_event
+
+            trigger_event("channel_start", {"channel_name": "TEST"})
+
+        self.assertEqual(pm.run_action.call_count, 2)
+        pm.run_action.assert_any_call(
+            "failing-plugin",
+            "on_event",
+            {"event": "channel_start", "payload": {"channel_name": "TEST"}},
+        )
+        pm.run_action.assert_any_call(
+            "working-plugin",
+            "on_event",
+            {"event": "channel_start", "payload": {"channel_name": "TEST"}},
+        )
diff --git a/apps/connect/utils.py b/apps/connect/utils.py
index b71c38e5..d8ef59b7 100644
--- a/apps/connect/utils.py
+++ b/apps/connect/utils.py
@@ -1,5 +1,5 @@
 # connect/utils.py
-import logging, json
+import logging
 from django.template import Template, Context
 from .models import EventSubscription, DeliveryLog, SUPPORTED_EVENTS
 from .handlers.webhook import WebhookHandler
@@ -94,23 +94,44 @@ def trigger_event(event_name, payload):
 
     pm = PluginManager.get()
     pm.discover_plugins(sync_db=False, use_cache=True)
-    plugins = pm.list_plugins()
+    handlers = list(pm.iter_actions_for_event(event_name))
+    if not handlers:
+        return
 
-    logger.debug(f"Checking {len(plugins)} plugins for event '{event_name}'")
-    for plugin in plugins:
-        if not plugin["enabled"]:
-            logger.debug(f"Skipping disabled plugin id={plugin['key']} name={plugin['name']}")
+    from apps.plugins.models import PluginConfig
+
+    handler_keys = {key for key, _ in handlers}
+    enabled_keys = set(
+        PluginConfig.objects.filter(enabled=True, key__in=handler_keys).values_list(
+            "key", flat=True
+        )
+    )
+
+    logger.debug(
+        "Dispatching event '%s' to %d plugin action(s) (%d enabled)",
+        event_name,
+        len(handlers),
+        len(enabled_keys),
+    )
+    params = {"event": event_name, "payload": payload}
+    for key, action_id in handlers:
+        if key not in enabled_keys:
+            logger.debug(
+                "Skipping disabled plugin id=%s for event '%s'", key, event_name
+            )
             continue
-
-        logger.debug(json.dumps(plugin))
-        for action in plugin["actions"]:
-            if "events" in action and event_name in action["events"]:
-                key = plugin["key"]
-                params = {"event": event_name, "payload": payload}
-                action_name = action.get("label") or action.get("id")
-                action_id = action.get("id")
-                logger.debug(
-                    f"Triggering plugin action for event '{event_name}' on plugin id={key} action={action_name}"
-                )
-                if action_id:
-                    pm.run_action(key, action_id, params)
+        logger.debug(
+            "Triggering plugin action for event '%s' on plugin id=%s action=%s",
+            event_name,
+            key,
+            action_id,
+        )
+        try:
+            pm.run_action(key, action_id, params)
+        except Exception:
+            logger.exception(
+                "Plugin action failed for event '%s' on plugin id=%s action=%s",
+                event_name,
+                key,
+                action_id,
+            )
diff --git a/apps/epg/api_views.py b/apps/epg/api_views.py
index 547be152..cdb39a47 100644
--- a/apps/epg/api_views.py
+++ b/apps/epg/api_views.py
@@ -64,8 +64,6 @@ class EPGSourceViewSet(viewsets.ModelViewSet):
         from apps.channels.models import Channel
         return EPGSource.objects.select_related(
             "refresh_task__crontab", "refresh_task__interval"
-        ).defer(
-            'programme_index'
         ).annotate(
             has_channels=Exists(
                 Channel.objects.filter(epg_data__epg_source_id=OuterRef('pk'))
@@ -128,7 +126,7 @@ class EPGSourceViewSet(viewsets.ModelViewSet):
         import hashlib
         import requests as http_requests
         from apps.epg.tasks import SD_BASE_URL
-        from version import __version__ as dispatcharr_version
+        from core.utils import dispatcharr_http_headers
 
         username = (source.username or '').strip()
         password = (source.password or '').strip()
@@ -143,7 +141,7 @@ class EPGSourceViewSet(viewsets.ModelViewSet):
             auth_response = http_requests.post(
                 f"{SD_BASE_URL}/token",
                 json={'username': username, 'password': sha1_password},
-                headers={'Content-Type': 'application/json', 'User-Agent': f'Dispatcharr/{dispatcharr_version}'},
+                headers=dispatcharr_http_headers(),
                 timeout=15,
             )
             auth_response.raise_for_status()
@@ -227,6 +225,24 @@ class EPGSourceViewSet(viewsets.ModelViewSet):
             f"Lockout set until {reset_at.isoformat()}."
         )
 
+    def _fetch_sd_countries(self):
+        """Fetch the SD country list (token not required; User-Agent is)."""
+        import requests as http_requests
+        from apps.epg.tasks import SD_BASE_URL
+        from core.utils import dispatcharr_http_headers
+
+        try:
+            resp = http_requests.get(
+                f"{SD_BASE_URL}/available/countries",
+                headers=dispatcharr_http_headers(content_type=None),
+                timeout=15,
+            )
+            resp.raise_for_status()
+            return resp.json()
+        except http_requests.exceptions.RequestException as e:
+            logger.warning(f"Failed to fetch SD countries: {e}")
+            return None
+
     @action(detail=True, methods=["get", "post", "delete"], url_path="sd-lineups")
     def sd_lineups(self, request, pk=None):
         """
@@ -236,7 +252,7 @@ class EPGSourceViewSet(viewsets.ModelViewSet):
         """
         import requests as http_requests
         from apps.epg.tasks import SD_BASE_URL
-        from version import __version__ as dispatcharr_version
+        from core.utils import dispatcharr_http_headers
 
         source = self.get_object()
         if source.source_type != 'schedules_direct':
@@ -249,13 +265,10 @@ class EPGSourceViewSet(viewsets.ModelViewSet):
         if error:
             return error
 
-        headers = {
-            'Content-Type': 'application/json',
-            'User-Agent': f'Dispatcharr/{dispatcharr_version}',
-            'token': token,
-        }
+        headers = dispatcharr_http_headers(token=token)
 
         if request.method == "GET":
+            countries = self._fetch_sd_countries()
             try:
                 resp = http_requests.get(
                     f"{SD_BASE_URL}/lineups",
@@ -272,6 +285,7 @@ class EPGSourceViewSet(viewsets.ModelViewSet):
                             "changes_remaining": self._get_sd_changes_remaining(source),
                             "changes_reset_at": self._get_sd_reset_at(source),
                             "notice": "No lineups are currently configured on this Schedules Direct account. Use the search below to add one.",
+                            "countries": countries,
                         })
                 resp.raise_for_status()
                 data = resp.json()
@@ -281,6 +295,7 @@ class EPGSourceViewSet(viewsets.ModelViewSet):
                     "max_lineups": 4,
                     "changes_remaining": self._get_sd_changes_remaining(source),
                     "changes_reset_at": self._get_sd_reset_at(source),
+                    "countries": countries,
                 })
             except http_requests.exceptions.RequestException as e:
                 return Response(
@@ -399,7 +414,7 @@ class EPGSourceViewSet(viewsets.ModelViewSet):
         """
         import requests as http_requests
         from apps.epg.tasks import SD_BASE_URL
-        from version import __version__ as dispatcharr_version
+        from core.utils import dispatcharr_http_headers
 
         source = self.get_object()
         if source.source_type != 'schedules_direct':
@@ -420,11 +435,7 @@ class EPGSourceViewSet(viewsets.ModelViewSet):
         if error:
             return error
 
-        headers = {
-            'Content-Type': 'application/json',
-            'User-Agent': f'Dispatcharr/{dispatcharr_version}',
-            'token': token,
-        }
+        headers = dispatcharr_http_headers(token=token)
 
         try:
             resp = http_requests.get(
@@ -493,6 +504,7 @@ class ProgramViewSet(viewsets.ModelViewSet):
         """Proxy endpoint for SD program poster images. Nginx caches the response."""
         import requests as http_requests
         from apps.epg.tasks import SD_BASE_URL
+        from core.utils import dispatcharr_http_headers
 
         program = self.get_object()
         poster_sd_url = (program.custom_properties or {}).get('sd_icon')
@@ -516,14 +528,10 @@ class ProgramViewSet(viewsets.ModelViewSet):
         if not token:
             sha1_password = hashlib.sha1(source.password.encode('utf-8')).hexdigest()
             try:
-                from version import __version__ as dispatcharr_version
                 auth_resp = http_requests.post(
                     f"{SD_BASE_URL}/token",
                     json={'username': source.username, 'password': sha1_password},
-                    headers={
-                        'Content-Type': 'application/json',
-                        'User-Agent': f'Dispatcharr/{dispatcharr_version}',
-                    },
+                    headers=dispatcharr_http_headers(),
                     timeout=10,
                 )
                 auth_data = auth_resp.json()
@@ -549,7 +557,7 @@ class ProgramViewSet(viewsets.ModelViewSet):
         try:
             img_resp = http_requests.get(
                 poster_sd_url,
-                headers={'token': token},
+                headers=dispatcharr_http_headers(token=token, content_type=None),
                 timeout=15,
                 allow_redirects=True,
             )
@@ -976,7 +984,9 @@ class EPGGridAPIView(APIView):
                     channel_name=name_to_parse,
                     num_days=1,
                     program_length_hours=4,
-                    epg_source=epg_source
+                    epg_source=epg_source,
+                    export_lookback=one_hour_ago,
+                    export_cutoff=twenty_four_hours_later,
                 )
 
                 # Custom dummy should always return data (either from patterns or fallback)
@@ -1072,13 +1082,19 @@ class EPGGridAPIView(APIView):
                     f"Error creating standard dummy programs for channel {channel.name} (ID: {channel.id}): {str(e)}"
                 )
 
-        # Combine regular and dummy programs
-        all_programs = list(serialized_programs) + dummy_programs
+        # Combine regular and dummy programs in place to avoid copying the large list
+        serialized_programs.extend(dummy_programs)
         logger.debug(
-            f"EPGGridAPIView: Returning {len(all_programs)} total programs (including {len(dummy_programs)} dummy programs)."
+            f"EPGGridAPIView: Returning {len(serialized_programs)} total programs (including {len(dummy_programs)} dummy programs)."
         )
 
-        return Response({"data": all_programs}, status=status.HTTP_200_OK)
+        # The grid materializes tens of thousands of program dicts plus the
+        # rendered JSON; trim once the response is sent so worker RSS does not
+        # ratchet up per request.
+        from core.utils import spawn_memory_trim
+        response = Response({"data": serialized_programs}, status=status.HTTP_200_OK)
+        response._resource_closers.append(spawn_memory_trim)
+        return response
 
 
 # ─────────────────────────────
@@ -1109,18 +1125,24 @@ class EPGImportAPIView(APIView):
         epg_id = request.data.get("id", None)
         force = bool(request.data.get("force", False))
 
-        # Check if this is a dummy EPG source
-        try:
+        # Reject dummy sources with a narrow existence query, no full row load.
+        if epg_id is not None:
             from .models import EPGSource
-            epg_source = EPGSource.objects.get(id=epg_id)
-            if epg_source.source_type == 'dummy':
-                logger.info(f"EPGImportAPIView: Skipping refresh for dummy EPG source {epg_id}")
+
+            if EPGSource.objects.filter(
+                id=epg_id, source_type="dummy"
+            ).exists():
+                logger.info(
+                    "EPGImportAPIView: Skipping refresh for dummy EPG source %s",
+                    epg_id,
+                )
                 return Response(
-                    {"success": False, "message": "Dummy EPG sources do not require refreshing."},
+                    {
+                        "success": False,
+                        "message": "Dummy EPG sources do not require refreshing.",
+                    },
                     status=status.HTTP_400_BAD_REQUEST,
                 )
-        except EPGSource.DoesNotExist:
-            pass  # Let the task handle the missing source
 
         refresh_epg_data.delay(epg_id, force=force)  # Trigger Celery task
         logger.info("EPGImportAPIView: Task dispatched to refresh EPG data.")
@@ -1220,10 +1242,9 @@ class CurrentProgramsAPIView(APIView):
             # Limit to 50 IDs per request
             epg_data_ids = epg_data_ids[:50]
 
-            # Defer the multi-MB programme_index the JOIN would pull once per row. The lookup reads it via a targeted refresh_from_db
-            epg_data_entries = EPGData.objects.select_related('epg_source').defer(
-                'epg_source__programme_index'
-            ).filter(id__in=epg_data_ids)
+            epg_data_entries = EPGData.objects.select_related('epg_source').filter(
+                id__in=epg_data_ids
+            )
 
             # Batch-fetch current programs for all requested EPG entries in one query
             db_programs = ProgramData.objects.filter(
diff --git a/apps/epg/migrations/0025_programdata_epg_id_index.py b/apps/epg/migrations/0025_programdata_epg_id_index.py
new file mode 100644
index 00000000..1a350b20
--- /dev/null
+++ b/apps/epg/migrations/0025_programdata_epg_id_index.py
@@ -0,0 +1,40 @@
+from django.contrib.postgres.operations import AddIndexConcurrently
+from django.db import migrations, models
+
+
+class AddIndexConcurrentlyIfPostgres(AddIndexConcurrently):
+    """Create the index CONCURRENTLY on PostgreSQL (no table lock on large
+    tables), falling back to a normal blocking AddIndex on other backends
+    such as the sqlite dev/test fallback."""
+
+    def database_forwards(self, app_label, schema_editor, from_state, to_state):
+        if schema_editor.connection.vendor == 'postgresql':
+            super().database_forwards(app_label, schema_editor, from_state, to_state)
+        else:
+            migrations.AddIndex.database_forwards(
+                self, app_label, schema_editor, from_state, to_state
+            )
+
+    def database_backwards(self, app_label, schema_editor, from_state, to_state):
+        if schema_editor.connection.vendor == 'postgresql':
+            super().database_backwards(app_label, schema_editor, from_state, to_state)
+        else:
+            migrations.AddIndex.database_backwards(
+                self, app_label, schema_editor, from_state, to_state
+            )
+
+
+class Migration(migrations.Migration):
+    # CREATE INDEX CONCURRENTLY cannot run inside a transaction.
+    atomic = False
+
+    dependencies = [
+        ('epg', '0024_remove_epgsource_api_key_epgsource_password_and_more'),
+    ]
+
+    operations = [
+        AddIndexConcurrentlyIfPostgres(
+            model_name='programdata',
+            index=models.Index(fields=['epg', 'id'], name='epg_prog_epg_id_idx'),
+        ),
+    ]
diff --git a/apps/epg/migrations/0026_epgsourceindex.py b/apps/epg/migrations/0026_epgsourceindex.py
new file mode 100644
index 00000000..75d9d4eb
--- /dev/null
+++ b/apps/epg/migrations/0026_epgsourceindex.py
@@ -0,0 +1,52 @@
+import django.db.models.deletion
+from django.db import migrations, models
+
+
+def copy_index_forward(apps, schema_editor):
+    EPGSource = apps.get_model('epg', 'EPGSource')
+    EPGSourceIndex = apps.get_model('epg', 'EPGSourceIndex')
+    rows = list(
+        EPGSource.objects.exclude(programme_index__isnull=True).values_list(
+            'id', 'programme_index'
+        )
+    )
+    for source_id, data in rows:
+        EPGSourceIndex.objects.update_or_create(
+            source_id=source_id, defaults={'data': data}
+        )
+
+
+def copy_index_backward(apps, schema_editor):
+    EPGSource = apps.get_model('epg', 'EPGSource')
+    EPGSourceIndex = apps.get_model('epg', 'EPGSourceIndex')
+    for source_id, data in EPGSourceIndex.objects.values_list('source_id', 'data'):
+        EPGSource.objects.filter(id=source_id).update(programme_index=data)
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('epg', '0025_programdata_epg_id_index'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='EPGSourceIndex',
+            fields=[
+                ('source', models.OneToOneField(
+                    on_delete=django.db.models.deletion.CASCADE,
+                    primary_key=True,
+                    related_name='index_record',
+                    serialize=False,
+                    to='epg.epgsource',
+                )),
+                ('data', models.JSONField(blank=True, default=None, null=True)),
+                ('updated_at', models.DateTimeField(auto_now=True)),
+            ],
+        ),
+        migrations.RunPython(copy_index_forward, copy_index_backward),
+        migrations.RemoveField(
+            model_name='epgsource',
+            name='programme_index',
+        ),
+    ]
diff --git a/apps/epg/models.py b/apps/epg/models.py
index 025945db..b85453af 100644
--- a/apps/epg/models.py
+++ b/apps/epg/models.py
@@ -62,12 +62,6 @@ class EPGSource(models.Model):
         blank=True,
         help_text="Last status message, including success results or error information"
     )
-    programme_index = models.JSONField(
-        null=True,
-        blank=True,
-        default=None,
-        help_text="Byte-offset index mapping tvg_id to file positions, built after each EPG refresh"
-    )
     created_at = models.DateTimeField(
         auto_now_add=True,
         help_text="Time when this source was created"
@@ -124,6 +118,37 @@ class EPGSource(models.Model):
                 kwargs['update_fields'].remove('updated_at')
         super().save(*args, **kwargs)
 
+    @property
+    def programme_index(self):
+        """Byte-offset index for this source, read on demand from the separate
+        EPGSourceIndex table so the multi-MB blob is never pulled into EPGSource
+        queries or select_related JOINs. Returns the stored dict or None."""
+        return (
+            EPGSourceIndex.objects.filter(source_id=self.pk)
+            .values_list('data', flat=True)
+            .first()
+        )
+
+
+class EPGSourceIndex(models.Model):
+    """Byte-offset programme index for an EPGSource, stored in its own table.
+
+    Kept out of EPGSource so the multi-MB JSON blob is only loaded when read
+    explicitly, never when querying or joining EPGSource rows.
+    """
+    source = models.OneToOneField(
+        EPGSource,
+        on_delete=models.CASCADE,
+        related_name='index_record',
+        primary_key=True,
+    )
+    data = models.JSONField(null=True, blank=True, default=None)
+    updated_at = models.DateTimeField(auto_now=True)
+
+    def __str__(self):
+        return f"Programme index for source {self.source_id}"
+
+
 class EPGData(models.Model):
     tvg_id = models.CharField(max_length=255, null=True, blank=True, db_index=True)
     name = models.CharField(max_length=512)
@@ -153,6 +178,11 @@ class ProgramData(models.Model):
     program_id = models.CharField(max_length=64, null=True, blank=True, help_text='Schedules Direct programID (e.g. EP123456789). Null for XMLTV sources.')
     custom_properties = models.JSONField(default=dict, blank=True, null=True)
 
+    class Meta:
+        indexes = [
+            models.Index(fields=['epg', 'id'], name='epg_prog_epg_id_idx'),
+        ]
+
     def __str__(self):
         return f"{self.title} ({self.start_time} - {self.end_time})"
 
diff --git a/apps/epg/tasks.py b/apps/epg/tasks.py
index d868dfeb..83aaa275 100644
--- a/apps/epg/tasks.py
+++ b/apps/epg/tasks.py
@@ -26,14 +26,190 @@ from core.models import UserAgent, CoreSettings
 from asgiref.sync import async_to_sync
 from channels.layers import get_channel_layer
 
-from .models import EPGSource, EPGData, ProgramData, SDScheduleMD5, SDProgramMD5
-from core.utils import acquire_task_lock, release_task_lock, TaskLockRenewer, send_websocket_update, cleanup_memory, log_system_event
+from .models import EPGSource, EPGSourceIndex, EPGData, ProgramData, SDScheduleMD5, SDProgramMD5
+from core.utils import (
+    acquire_task_lock,
+    is_task_lock_held,
+    release_task_lock,
+    TaskLockRenewer,
+    send_websocket_update,
+    cleanup_memory,
+    log_system_event,
+)
 
 logger = logging.getLogger(__name__)
 
+_NON_TERMINAL_REFRESH_STATUSES = frozenset({
+    EPGSource.STATUS_FETCHING,
+    EPGSource.STATUS_PARSING,
+})
+
+
+def _release_task_db_connection():
+    """Return the Celery worker's DB connection to a clean state after ORM errors."""
+    from django.db import close_old_connections
+    close_old_connections()
+
+
+def _db_query_with_retry(fn, *, label="DB query", max_retries=2):
+    """
+    Run an ORM read with one connection reset + retry on transient failures.
+
+    Poisoned Celery worker connections often surface as OperationalError or as
+    ``IndexError: list index out of range`` inside Django's row converters.
+    """
+    from django.db import InterfaceError, OperationalError
+
+    transient_errors = (OperationalError, InterfaceError, IndexError)
+    for attempt in range(max_retries):
+        try:
+            return fn()
+        except transient_errors as exc:
+            if attempt + 1 >= max_retries:
+                raise
+            logger.warning(
+                "%s failed (%s), resetting DB connection (%s/%s)",
+                label,
+                exc,
+                attempt + 1,
+                max_retries,
+            )
+            _release_task_db_connection()
+
+
+def _get_epg_source(source_id):
+    return _db_query_with_retry(
+        lambda: EPGSource.objects.get(id=source_id),
+        label=f"load EPG source {source_id}",
+    )
+
+
+def _set_epg_source_status(
+    source_id,
+    status,
+    last_message=None,
+    *,
+    notify_error=False,
+    ws_action="refresh",
+    ws_error=None,
+):
+    """Update source status using a fresh connection (safe after DB failures)."""
+    _release_task_db_connection()
+    update = {"status": status}
+    if last_message is not None:
+        update["last_message"] = last_message
+    try:
+        EPGSource.objects.filter(id=source_id).update(**update)
+        if notify_error:
+            send_epg_update(
+                source_id,
+                ws_action,
+                100,
+                status="error",
+                error=ws_error or last_message,
+            )
+    except Exception as e:
+        logger.error(
+            f"Failed to set EPG source {source_id} status to {status}: {e}"
+        )
+
+
+def _ensure_epg_refresh_terminal_status(source_id):
+    """Mark refresh as failed when the task exits while still in progress."""
+    _release_task_db_connection()
+    try:
+        current_status = (
+            EPGSource.objects.filter(id=source_id)
+            .values_list("status", flat=True)
+            .first()
+        )
+        if current_status in _NON_TERMINAL_REFRESH_STATUSES:
+            message = "Refresh did not complete successfully"
+            EPGSource.objects.filter(id=source_id).update(
+                status=EPGSource.STATUS_ERROR,
+                last_message=message,
+            )
+            send_epg_update(
+                source_id, "refresh", 100, status="error", error=message
+            )
+    except Exception as e:
+        logger.debug(
+            f"Could not verify terminal refresh status for EPG source {source_id}: {e}"
+        )
+
+
 SD_BASE_URL = 'https://json.schedulesdirect.org/20141201'
 SD_DAYS_TO_FETCH = 20
 SD_PROGRAM_BATCH_SIZE = 5000
+SD_BULK_GUIDE_FETCH_THRESHOLD = 3
+SD_MAPPED_GUIDE_BATCH_DEFER_SECONDS = 90
+SD_MAPPED_GUIDE_FETCH_DEFER_MAX_RETRIES = 2
+
+def _sd_compute_schedule_changes_from_md5(server_md5s, cached_md5s, date_list):
+    """Return station_id -> [date_str] for dates whose schedule MD5 differs from cache."""
+    changed_by_station = {}
+    for (sid, date_str), server_info in server_md5s.items():
+        if date_str not in date_list:
+            continue
+        cached = cached_md5s.get((sid, date_str))
+        if cached != server_info['md5']:
+            changed_by_station.setdefault(sid, []).append(date_str)
+    return changed_by_station
+
+
+def _sd_backfill_schedule_dates_without_data(
+    changed_by_station,
+    server_md5s,
+    date_list,
+    mapped_station_ids,
+    epg_id_map,
+    dates_with_data,
+    cached_md5s,
+    stations_without_any_data,
+):
+    """
+    Add fetch-window dates that lack ProgramData to changed_by_station.
+
+    Dates with a cached schedule MD5 are treated as already fetched (e.g. legitimately
+    empty airings). Stations with zero ProgramData still backfill all missing dates
+    so stale cache from unmapped lineup refreshes cannot block guide population.
+    """
+    from datetime import date as date_type
+
+    stations_without_any_data = set(stations_without_any_data)
+    backfilled_count = 0
+    for sid in mapped_station_ids:
+        epg_db_id = epg_id_map.get(sid)
+        if not epg_db_id:
+            continue
+        force_despite_cache = sid in stations_without_any_data
+        already_changing = set(changed_by_station.get(sid, []))
+        for ds in date_list:
+            if ds in already_changing or (sid, ds) not in server_md5s:
+                continue
+            if (epg_db_id, date_type.fromisoformat(ds)) in dates_with_data:
+                continue
+            if (sid, ds) in cached_md5s and not force_despite_cache:
+                continue
+            changed_by_station.setdefault(sid, []).append(ds)
+            backfilled_count += 1
+    return backfilled_count
+
+
+def _sd_programs_needing_metadata(
+    program_ids_needed,
+    schedule_program_md5s,
+    cached_prog_md5s,
+    programs_with_data,
+):
+    """Return programIDs that need metadata download from Schedules Direct."""
+    programs_with_data = set(programs_with_data)
+    return {
+        pid for pid in program_ids_needed
+        if schedule_program_md5s.get(pid) != cached_prog_md5s.get(pid)
+        or pid not in programs_with_data
+    }
+
 
 SD_POSTER_CATEGORIES = (
     'Iconic', 'Banner-L1', 'Banner-L2', 'Banner-L3', 'Banner',
@@ -421,102 +597,92 @@ def refresh_epg_data(source_id, force=False):
     lock_renewer = TaskLockRenewer('refresh_epg_data', source_id)
     lock_renewer.start()
 
-    source = None
+    _release_task_db_connection()
+
     try:
-        # Try to get the EPG source
-        try:
-            source = EPGSource.objects.get(id=source_id)
-        except EPGSource.DoesNotExist:
-            # The EPG source doesn't exist, so delete the periodic task if it exists
-            logger.warning(f"EPG source with ID {source_id} not found, but task was triggered. Cleaning up orphaned task.")
-
-            # Call the shared function to delete the task
-            if delete_epg_refresh_task_by_id(source_id):
-                logger.info(f"Successfully cleaned up orphaned task for EPG source {source_id}")
-            else:
-                logger.info(f"No orphaned task found for EPG source {source_id}")
-
-            # Release the lock and exit
-            lock_renewer.stop()
-            release_task_lock('refresh_epg_data', source_id)
-            # Force garbage collection before exit
-            gc.collect()
-            return f"EPG source {source_id} does not exist, task cleaned up"
-
-        # The source exists but is not active, just skip processing
-        if not source.is_active:
-            logger.info(f"EPG source {source_id} is not active. Skipping.")
-            lock_renewer.stop()
-            release_task_lock('refresh_epg_data', source_id)
-            # Force garbage collection before exit
-            gc.collect()
-            return
-
-        # Skip refresh for dummy EPG sources - they don't need refreshing
-        if source.source_type == 'dummy':
-            logger.info(f"Skipping refresh for dummy EPG source {source.name} (ID: {source_id})")
-            lock_renewer.stop()
-            release_task_lock('refresh_epg_data', source_id)
-            gc.collect()
-            return
-
-        # Continue with the normal processing...
-        logger.info(f"Processing EPGSource: {source.name} (type: {source.source_type})")
-        if source.source_type == 'xmltv':
-            # Invalidate the byte-offset index before downloading the new file
-            # so stale offsets are never used during the refresh window.
-            EPGSource.objects.filter(id=source.id).update(programme_index=None)
-            fetch_success = fetch_xmltv(source)
-            if not fetch_success:
-                logger.error(f"Failed to fetch XMLTV for source {source.name}")
-                lock_renewer.stop()
-                release_task_lock('refresh_epg_data', source_id)
-                # Force garbage collection before exit
-                gc.collect()
-                return
-
-            parse_channels_success = parse_channels_only(source)
-            if not parse_channels_success:
-                logger.error(f"Failed to parse channels for source {source.name}")
-                lock_renewer.stop()
-                release_task_lock('refresh_epg_data', source_id)
-                # Force garbage collection before exit
-                gc.collect()
-                return
-
-            # Build byte-offset index for preview lookups in the background so refresh isn't blocked by it
-            build_programme_index_task.delay(source.id)
-            parse_programs_for_source(source)
-
-        elif source.source_type == 'schedules_direct':
-            fetch_schedules_direct(source, force=force)
-
-        source.save(update_fields=['updated_at'])
-        # After successful EPG refresh, evaluate DVR series rules to schedule new episodes
-        try:
-            from apps.channels.tasks import evaluate_series_rules
-            evaluate_series_rules.delay()
-        except Exception:
-            pass
+        return _refresh_epg_data_impl(source_id, force=force)
     except Exception as e:
-        logger.error(f"Error in refresh_epg_data for source {source_id}: {e}", exc_info=True)
-        try:
-            if source:
-                source.status = 'error'
-                source.last_message = f"Error refreshing EPG data: {str(e)}"
-                source.save(update_fields=['status', 'last_message'])
-                send_epg_update(source_id, "refresh", 100, status="error", error=str(e))
-        except Exception as inner_e:
-            logger.error(f"Error updating source status: {inner_e}")
+        logger.error(
+            f"Error in refresh_epg_data for source {source_id}: {e}",
+            exc_info=True,
+        )
+        _set_epg_source_status(
+            source_id,
+            EPGSource.STATUS_ERROR,
+            f"Error refreshing EPG data: {str(e)[:500]}",
+            notify_error=True,
+            ws_error=str(e)[:500],
+        )
     finally:
-        # Clear references to ensure proper garbage collection
-        source = None
-        # Force garbage collection before releasing the lock
+        _ensure_epg_refresh_terminal_status(source_id)
+        _release_task_db_connection()
         gc.collect()
         lock_renewer.stop()
         release_task_lock('refresh_epg_data', source_id)
 
 
+def _refresh_epg_data_impl(source_id, force=False):
+    try:
+        source = _get_epg_source(source_id)
+    except EPGSource.DoesNotExist:
+        logger.warning(
+            f"EPG source with ID {source_id} not found, but task was triggered. "
+            "Cleaning up orphaned task."
+        )
+
+        if delete_epg_refresh_task_by_id(source_id):
+            logger.info(
+                f"Successfully cleaned up orphaned task for EPG source {source_id}"
+            )
+        else:
+            logger.info(f"No orphaned task found for EPG source {source_id}")
+
+        return f"EPG source {source_id} does not exist, task cleaned up"
+
+    if not source.is_active:
+        logger.info(f"EPG source {source_id} is not active. Skipping.")
+        return
+
+    if source.source_type == 'dummy':
+        logger.info(
+            f"Skipping refresh for dummy EPG source {source.name} (ID: {source_id})"
+        )
+        return
+
+    logger.info(f"Processing EPGSource: {source.name} (type: {source.source_type})")
+    if source.source_type == 'xmltv':
+        # Invalidate the byte-offset index before downloading the new file
+        # so stale offsets are never used during the refresh window.
+        EPGSourceIndex.objects.update_or_create(
+            source_id=source.id, defaults={'data': None}
+        )
+        if not fetch_xmltv(source):
+            logger.error(f"Failed to fetch XMLTV for source {source.name}")
+            return
+
+        if not parse_channels_only(source):
+            logger.error(f"Failed to parse channels for source {source.name}")
+            return
+
+        # Build byte-offset index after programme data is committed so refresh
+        # does not compete for memory/IO during the programme swap.
+        if not parse_programs_for_source(source):
+            logger.error(f"Failed to parse programs for source {source.name}")
+            return
+
+        build_programme_index_task.delay(source.id)
+
+    elif source.source_type == 'schedules_direct':
+        fetch_schedules_direct(source, force=force)
+
+    EPGSource.objects.filter(id=source.id).update(updated_at=timezone.now())
+    try:
+        from apps.channels.tasks import evaluate_series_rules
+        evaluate_series_rules.delay()
+    except Exception:
+        pass
+
+
 def fetch_xmltv(source):
     # Handle cases with local file but no URL
     if not source.url and source.file_path and os.path.exists(source.file_path):
@@ -1088,7 +1254,15 @@ def parse_channels_only(source):
                 # Update status to error
                 source.status = 'error'
                 source.last_message = f"No URL provided, cannot fetch EPG data"
-                source.save(update_fields=['updated_at'])
+                source.save(update_fields=['status', 'last_message'])
+                send_epg_update(
+                    source.id,
+                    "parsing_channels",
+                    100,
+                    status="error",
+                    error="No URL provided",
+                )
+                return False
 
         # Initialize process variable for memory tracking only in debug mode
         try:
@@ -1429,14 +1603,11 @@ def parse_channels_only(source):
 
 @shared_task(time_limit=3600, soft_time_limit=3500)
 def parse_programs_for_tvg_id(epg_id, force=False):
-    # Skip XMLTV file parsing for Schedules Direct sources. Program data is
-    # fetched and persisted directly by fetch_schedules_direct().
     try:
         from apps.epg.models import EPGData
         epg_obj = EPGData.objects.select_related('epg_source').filter(id=epg_id).first()
         if epg_obj and epg_obj.epg_source and epg_obj.epg_source.source_type == 'schedules_direct':
-            logger.info(f"Skipping XMLTV parse for SD EPGData id={epg_id} (source: {epg_obj.epg_source.name})")
-            return "Skipped (Schedules Direct source)"
+            return fetch_sd_guide_for_epg(epg_id, force=force)
     except Exception as e:
         logger.warning(f"Could not check EPG source type for id={epg_id}: {e}")
 
@@ -1730,6 +1901,163 @@ def parse_programs_for_tvg_id(epg_id, force=False):
         release_task_lock('parse_epg_programs', epg_id)
 
 
+_EPG_PROGRAM_STAGING_TABLE = 'epg_program_staging'
+# Parse batches bound Python memory during XML iterparse; swap batches bound each
+# DELETE/INSERT statement inside the single atomic swap transaction.
+_EPG_PARSE_BATCH_SIZE = 2500
+_EPG_SWAP_BATCH_SIZE = 5000
+
+
+def _epg_program_staging_supported():
+    return connection.vendor == 'postgresql'
+
+
+def _prepare_epg_program_staging_table():
+    """Create/truncate a session-scoped temp table for streaming EPG programme inserts."""
+    if not _epg_program_staging_supported():
+        return False
+
+    with connection.cursor() as cursor:
+        cursor.execute(
+            f"""
+            CREATE TEMP TABLE IF NOT EXISTS {_EPG_PROGRAM_STAGING_TABLE} (
+                epg_id bigint NOT NULL,
+                start_time timestamptz NOT NULL,
+                end_time timestamptz NOT NULL,
+                title varchar(255) NOT NULL,
+                sub_title text,
+                description text,
+                tvg_id varchar(255),
+                custom_properties jsonb
+            ) ON COMMIT PRESERVE ROWS
+            """
+        )
+        cursor.execute(f"TRUNCATE {_EPG_PROGRAM_STAGING_TABLE}")
+    return True
+
+
+def _clear_epg_program_staging_table():
+    if not _epg_program_staging_supported():
+        return
+    with connection.cursor() as cursor:
+        cursor.execute(f"TRUNCATE {_EPG_PROGRAM_STAGING_TABLE}")
+
+
+def _flush_epg_program_staging_batch(programs_batch):
+    """Insert a batch of unsaved ProgramData rows into the session staging table."""
+    if not programs_batch or not _epg_program_staging_supported():
+        return
+
+    values_sql = []
+    params = []
+    for program in programs_batch:
+        values_sql.append("(%s, %s, %s, %s, %s, %s, %s, %s)")
+        custom_properties = program.custom_properties
+        if custom_properties is not None and not isinstance(custom_properties, str):
+            custom_properties = json.dumps(custom_properties)
+        params.extend([
+            program.epg_id,
+            program.start_time,
+            program.end_time,
+            program.title,
+            program.sub_title,
+            program.description,
+            program.tvg_id,
+            custom_properties,
+        ])
+
+    with connection.cursor() as cursor:
+        cursor.execute(
+            f"""
+            INSERT INTO {_EPG_PROGRAM_STAGING_TABLE} (
+                epg_id, start_time, end_time, title, sub_title, description, tvg_id, custom_properties
+            ) VALUES {', '.join(values_sql)}
+            """,
+            params,
+        )
+
+
+def _swap_staged_epg_programs(mapped_epg_ids, epg_source, batch_size=_EPG_SWAP_BATCH_SIZE):
+    """
+    Atomically replace mapped programme rows with staged data.
+    Must be called inside transaction.atomic().
+
+    Staged rows are moved in batches (DELETE ... RETURNING + INSERT) so Postgres
+    does not need to materialize the entire catalogue in one statement.
+    """
+    with connection.cursor() as cursor:
+        cursor.execute("SET LOCAL statement_timeout = '10min'")
+
+    deleted_count = ProgramData.objects.filter(epg_id__in=mapped_epg_ids).delete()[0]
+    logger.debug(f"Deleted {deleted_count} existing programs")
+
+    unmapped_epg_ids = list(
+        EPGData.objects.filter(epg_source=epg_source)
+        .exclude(id__in=mapped_epg_ids)
+        .values_list('id', flat=True)
+    )
+    if unmapped_epg_ids:
+        orphaned_count = ProgramData.objects.filter(epg_id__in=unmapped_epg_ids).delete()[0]
+        if orphaned_count > 0:
+            logger.info(
+                f"Cleaned up {orphaned_count} orphaned programs for "
+                f"{len(unmapped_epg_ids)} unmapped EPG entries"
+            )
+
+    if not _epg_program_staging_supported():
+        raise RuntimeError('_swap_staged_epg_programs requires PostgreSQL staging support')
+
+    program_table = ProgramData._meta.db_table
+    total_inserted = 0
+    while True:
+        with connection.cursor() as cursor:
+            cursor.execute(
+                f"""
+                WITH moved AS (
+                    DELETE FROM {_EPG_PROGRAM_STAGING_TABLE}
+                    WHERE ctid IN (
+                        SELECT ctid FROM {_EPG_PROGRAM_STAGING_TABLE} LIMIT %s
+                    )
+                    RETURNING
+                        epg_id, start_time, end_time, title, sub_title,
+                        description, tvg_id, custom_properties
+                )
+                INSERT INTO {program_table} (
+                    epg_id, start_time, end_time, title, sub_title,
+                    description, tvg_id, custom_properties
+                )
+                SELECT
+                    epg_id, start_time, end_time, title, sub_title,
+                    description, tvg_id, custom_properties
+                FROM moved
+                """,
+                [batch_size],
+            )
+            moved_count = cursor.rowcount
+        if moved_count == 0:
+            break
+        total_inserted += moved_count
+
+    logger.debug(f"Inserted {total_inserted} staged programs in batches of {batch_size}")
+
+    return deleted_count
+
+
+def _swap_parsed_epg_programs(mapped_epg_ids, epg_source, programs_to_create, batch_size=_EPG_SWAP_BATCH_SIZE):
+    """SQLite/dev fallback: atomic delete + bulk insert from an in-memory batch list."""
+    with transaction.atomic():
+        deleted_count = ProgramData.objects.filter(epg_id__in=mapped_epg_ids).delete()[0]
+        unmapped_epg_ids = list(
+            EPGData.objects.filter(epg_source=epg_source)
+            .exclude(id__in=mapped_epg_ids)
+            .values_list('id', flat=True)
+        )
+        if unmapped_epg_ids:
+            ProgramData.objects.filter(epg_id__in=unmapped_epg_ids).delete()
+        for i in range(0, len(programs_to_create), batch_size):
+            ProgramData.objects.bulk_create(programs_to_create[i:i + batch_size])
+    return deleted_count
+
 
 def parse_programs_for_source(epg_source, tvg_id=None):
     """
@@ -1836,106 +2164,164 @@ def parse_programs_for_source(epg_source, tvg_id=None):
                 send_epg_update(epg_source.id, "parsing_programs", 100, status="error", error="No URL provided")
                 return False
 
-        # SINGLE PASS PARSING: Parse the XML file once and collect all programs in memory
-        # We parse FIRST, then do an atomic delete+insert to avoid race conditions
-        # where clients might see empty/partial EPG data during the transition
-        all_programs_to_create = []
-        programs_by_channel = {tvg_id: 0 for tvg_id in mapped_tvg_ids}  # Track count per channel
+        # Stream parsed rows into a session temp table, then swap in a short transaction.
+        # This bounds Python memory (batched staging inserts) and Postgres memory (no
+        # long-lived transaction spanning the entire XML parse).
+        programs_by_channel = {tvg_id: 0 for tvg_id in mapped_tvg_ids}
         total_programs = 0
         skipped_programs = 0
         last_progress_update = 0
+        parse_batch_size = _EPG_PARSE_BATCH_SIZE
+        swap_batch_size = _EPG_SWAP_BATCH_SIZE
+        programs_batch = []
+        deleted_count = 0
+        staging_prepared = False
+        use_staging = False
+        programs_accumulator = []
+
+        send_epg_update(epg_source.id, "parsing_programs", 10, message="Parsing programs...")
 
         try:
-            logger.debug(f"Opening file for single-pass parsing: {file_path}")
+            staging_prepared = _prepare_epg_program_staging_table()
+            use_staging = staging_prepared
+
+            logger.debug(f"Opening file for streaming parse: {file_path}")
             source_file = _open_xmltv_file(file_path)
+            try:
+                program_parser = etree.iterparse(
+                    source_file,
+                    events=('end',),
+                    tag='programme',
+                    remove_blank_text=True,
+                    recover=True,
+                )
 
-            # Stream parse the file using lxml's iterparse
-            program_parser = etree.iterparse(source_file, events=('end',), tag='programme', remove_blank_text=True, recover=True)
+                for _, elem in program_parser:
+                    channel_id = elem.get('channel')
 
-            for _, elem in program_parser:
-                channel_id = elem.get('channel')
+                    if channel_id not in mapped_tvg_ids:
+                        skipped_programs += 1
+                        clear_element(elem)
+                        continue
 
-                # Skip programmes for unmapped channels immediately
-                if channel_id not in mapped_tvg_ids:
-                    skipped_programs += 1
-                    # Clear element to free memory
-                    clear_element(elem)
-                    continue
+                    try:
+                        start_time = parse_xmltv_time(elem.get('start'))
+                        end_time = parse_xmltv_time(elem.get('stop'))
+                        title = None
+                        desc = None
+                        sub_title = None
 
-                # This programme is for a mapped channel - process it
-                try:
-                    start_time = parse_xmltv_time(elem.get('start'))
-                    end_time = parse_xmltv_time(elem.get('stop'))
-                    title = None
-                    desc = None
-                    sub_title = None
+                        for child in elem:
+                            if child.tag == 'title':
+                                title = child.text or 'No Title'
+                            elif child.tag == 'desc':
+                                desc = child.text or ''
+                            elif child.tag == 'sub-title':
+                                sub_title = child.text or ''
 
-                    # Efficiently process child elements
-                    for child in elem:
-                        if child.tag == 'title':
-                            title = child.text or 'No Title'
-                        elif child.tag == 'desc':
-                            desc = child.text or ''
-                        elif child.tag == 'sub-title':
-                            sub_title = child.text or ''
+                        if not title:
+                            title = 'No Title'
 
-                    if not title:
-                        title = 'No Title'
+                        custom_props = extract_custom_properties(elem)
+                        custom_properties_json = custom_props if custom_props else None
 
-                    # Extract custom properties
-                    custom_props = extract_custom_properties(elem)
-                    custom_properties_json = custom_props if custom_props else None
+                        if desc:
+                            has_season = (custom_properties_json or {}).get('season') is not None
+                            has_episode = (custom_properties_json or {}).get('episode') is not None
+                            if not has_season or not has_episode:
+                                d_season, d_episode, cleaned_desc = extract_season_episode_from_description(desc)
+                                if d_season is not None and d_episode is not None:
+                                    if custom_properties_json is None:
+                                        custom_properties_json = {}
+                                    if not has_season:
+                                        custom_properties_json['season'] = d_season
+                                    if not has_episode:
+                                        custom_properties_json['episode'] = d_episode
+                                    custom_properties_json['season_episode_source'] = 'description'
+                                    desc = cleaned_desc
 
-                    # Fallback: extract S/E from description when episode-num
-                    # elements didn't provide them
-                    if desc:
-                        has_season = (custom_properties_json or {}).get('season') is not None
-                        has_episode = (custom_properties_json or {}).get('episode') is not None
-                        if not has_season or not has_episode:
-                            d_season, d_episode, cleaned_desc = extract_season_episode_from_description(desc)
-                            if d_season is not None and d_episode is not None:
-                                if custom_properties_json is None:
-                                    custom_properties_json = {}
-                                if not has_season:
-                                    custom_properties_json['season'] = d_season
-                                if not has_episode:
-                                    custom_properties_json['episode'] = d_episode
-                                custom_properties_json['season_episode_source'] = 'description'
-                                desc = cleaned_desc
+                        epg_id = tvg_id_to_epg_id[channel_id]
+                        programs_batch.append(ProgramData(
+                            epg_id=epg_id,
+                            start_time=start_time,
+                            end_time=end_time,
+                            title=title[:255],
+                            description=desc,
+                            sub_title=sub_title,
+                            tvg_id=channel_id,
+                            custom_properties=custom_properties_json,
+                        ))
+                        total_programs += 1
+                        programs_by_channel[channel_id] += 1
+                        clear_element(elem)
 
-                    epg_id = tvg_id_to_epg_id[channel_id]
-                    all_programs_to_create.append(ProgramData(
-                        epg_id=epg_id,
-                        start_time=start_time,
-                        end_time=end_time,
-                        title=title[:255],
-                        description=desc,
-                        sub_title=sub_title,
-                        tvg_id=channel_id,
-                        custom_properties=custom_properties_json
-                    ))
-                    total_programs += 1
-                    programs_by_channel[channel_id] += 1
+                        if len(programs_batch) >= parse_batch_size:
+                            if use_staging:
+                                _flush_epg_program_staging_batch(programs_batch)
+                                programs_batch = []
+                            else:
+                                programs_accumulator.extend(programs_batch)
+                                programs_batch = []
 
-                    # Clear the element to free memory
-                    clear_element(elem)
+                        if total_programs - last_progress_update >= 5000:
+                            last_progress_update = total_programs
+                            progress = min(
+                                85,
+                                10 + int((total_programs / max(total_programs + 10000, 1)) * 75),
+                            )
+                            send_epg_update(
+                                epg_source.id,
+                                "parsing_programs",
+                                progress,
+                                processed=total_programs,
+                                channels=mapped_count,
+                                message=f"Staging programs... {total_programs:,}",
+                            )
 
-                    # Send progress update (estimate based on programs processed)
-                    if total_programs - last_progress_update >= 5000:
-                        last_progress_update = total_programs
-                        # Cap at 70% during parsing phase (save 30% for DB operations)
-                        progress = min(70, 10 + int((total_programs / max(total_programs + 10000, 1)) * 60))
-                        send_epg_update(epg_source.id, "parsing_programs", progress,
-                                      processed=total_programs, channels=mapped_count)
+                        if total_programs % 5000 == 0:
+                            gc.collect()
 
-                    # Periodic garbage collection during parsing
-                    if total_programs % 5000 == 0:
-                        gc.collect()
+                    except Exception as e:
+                        logger.error(f"Error processing program for {channel_id}: {e}", exc_info=True)
+                        clear_element(elem)
+                        continue
 
-                except Exception as e:
-                    logger.error(f"Error processing program for {channel_id}: {e}", exc_info=True)
-                    clear_element(elem)
-                    continue
+                if programs_batch:
+                    if use_staging:
+                        _flush_epg_program_staging_batch(programs_batch)
+                    else:
+                        programs_accumulator.extend(programs_batch)
+                    programs_batch = []
+            finally:
+                if source_file:
+                    source_file.close()
+                    source_file = None
+
+            try:
+                send_epg_update(epg_source.id, "parsing_programs", 90, message="Updating database...")
+                if use_staging:
+                    with transaction.atomic():
+                        deleted_count = _swap_staged_epg_programs(
+                            mapped_epg_ids, epg_source, batch_size=swap_batch_size
+                        )
+                else:
+                    deleted_count = _swap_parsed_epg_programs(
+                        mapped_epg_ids, epg_source, programs_accumulator, batch_size=swap_batch_size
+                    )
+                    programs_accumulator = []
+
+                logger.info(
+                    f"Atomic update complete: deleted {deleted_count}, inserted {total_programs} programs"
+                )
+            except Exception as db_error:
+                logger.error(f"Database error during atomic update: {db_error}", exc_info=True)
+                epg_source.status = EPGSource.STATUS_ERROR
+                epg_source.last_message = f"Database error: {str(db_error)}"
+                epg_source.save(update_fields=['status', 'last_message'])
+                send_epg_update(
+                    epg_source.id, "parsing_programs", 100, status="error", message=str(db_error)
+                )
+                return False
 
         except etree.XMLSyntaxError as xml_error:
             logger.error(f"XML syntax error parsing program data: {xml_error}")
@@ -1944,63 +2330,23 @@ def parse_programs_for_source(epg_source, tvg_id=None):
             epg_source.save(update_fields=['status', 'last_message'])
             send_epg_update(epg_source.id, "parsing_programs", 100, status="error", message=str(xml_error))
             return False
-        except Exception as e:
-            logger.error(f"Error parsing XML for programs: {e}", exc_info=True)
-            raise
-        finally:
-            if source_file:
-                source_file.close()
-                source_file = None
-
-        # Now perform atomic delete + bulk insert
-        # This ensures clients never see empty/partial EPG data
-        logger.info(f"Parsed {total_programs} programs, performing atomic database update...")
-        send_epg_update(epg_source.id, "parsing_programs", 75, message="Updating database...")
-
-        batch_size = 1000
-        try:
-            with transaction.atomic():
-                # Kill any individual statement that hangs longer than 10 minutes.
-                # SET LOCAL automatically resets when this transaction ends (commit or rollback).
-                with connection.cursor() as cursor:
-                    cursor.execute("SET LOCAL statement_timeout = '10min'")
-                # Delete existing programs for mapped EPGs
-                deleted_count = ProgramData.objects.filter(epg_id__in=mapped_epg_ids).delete()[0]
-                logger.debug(f"Deleted {deleted_count} existing programs")
-
-                # Clean up orphaned programs for unmapped EPG entries
-                unmapped_epg_ids = list(EPGData.objects.filter(
-                    epg_source=epg_source
-                ).exclude(id__in=mapped_epg_ids).values_list('id', flat=True))
-
-                if unmapped_epg_ids:
-                    orphaned_count = ProgramData.objects.filter(epg_id__in=unmapped_epg_ids).delete()[0]
-                    if orphaned_count > 0:
-                        logger.info(f"Cleaned up {orphaned_count} orphaned programs for {len(unmapped_epg_ids)} unmapped EPG entries")
-
-                # Bulk insert all new programs in batches within the same transaction
-                for i in range(0, len(all_programs_to_create), batch_size):
-                    batch = all_programs_to_create[i:i + batch_size]
-                    ProgramData.objects.bulk_create(batch)
-
-                    # Update progress during insertion
-                    progress = 75 + int((i / len(all_programs_to_create)) * 20) if all_programs_to_create else 95
-                    if i % (batch_size * 5) == 0:
-                        send_epg_update(epg_source.id, "parsing_programs", min(95, progress),
-                                      message=f"Inserting programs... {i}/{len(all_programs_to_create)}")
-
-            logger.info(f"Atomic update complete: deleted {deleted_count}, inserted {total_programs} programs")
-
-        except Exception as db_error:
-            logger.error(f"Database error during atomic update: {db_error}", exc_info=True)
+        except Exception as parse_error:
+            logger.error(f"Error parsing programs from XML: {parse_error}", exc_info=True)
             epg_source.status = EPGSource.STATUS_ERROR
-            epg_source.last_message = f"Database error: {str(db_error)}"
+            epg_source.last_message = f"Error parsing programs: {str(parse_error)}"
             epg_source.save(update_fields=['status', 'last_message'])
-            send_epg_update(epg_source.id, "parsing_programs", 100, status="error", message=str(db_error))
+            send_epg_update(
+                epg_source.id, "parsing_programs", 100, status="error", message=str(parse_error)
+            )
             return False
         finally:
-            # Clear the large list to free memory
-            all_programs_to_create = None
+            programs_batch = None
+            programs_accumulator = None
+            if staging_prepared:
+                try:
+                    _clear_epg_program_staging_table()
+                except Exception:
+                    pass
             gc.collect()
 
         # Count channels that actually got programs
@@ -2056,7 +2402,7 @@ def parse_programs_for_source(epg_source, tvg_id=None):
             source_file = None
 
         # Explicitly release any remaining large data structures
-        programs_to_create = None
+        programs_batch = None
         programs_by_channel = None
         mapped_epg_ids = None
         mapped_tvg_ids = None
@@ -2070,6 +2416,261 @@ def parse_programs_for_source(epg_source, tvg_id=None):
             logger.info(f"[parse_programs_for_source] Final memory usage: {final_memory:.2f} MB difference: {final_memory - initial_memory:.2f} MB")
             # Explicitly clear the process object to prevent potential memory leaks
             process = None
+
+
+def _sd_fetch_lineup_country(token, sd_headers_fn):
+    """Return country code prefix from the first subscribed lineup (poster metadata)."""
+    try:
+        lineups_response = requests.get(
+            f"{SD_BASE_URL}/lineups",
+            headers=sd_headers_fn(token),
+            timeout=30,
+        )
+        if lineups_response.ok:
+            for lineup in lineups_response.json().get('lineups', []):
+                lid = lineup.get('lineupID') or lineup.get('lineup') or ''
+                if '-' in lid:
+                    return lid.split('-')[0]
+    except requests.exceptions.RequestException as e:
+        logger.warning(f"Could not fetch lineups for country code: {e}")
+    return None
+
+
+def _sd_setup_single_epg_fetch(source, epg_id, token, sd_headers_fn):
+    """Build station_map / epg_id_map for a single mapped EPG entry."""
+    epg = EPGData.objects.filter(id=epg_id, epg_source=source).first()
+    if not epg or not epg.tvg_id:
+        msg = f"Schedules Direct EPG entry {epg_id} not found or missing station ID."
+        logger.error(msg)
+        source.last_message = msg
+        source.save(update_fields=['last_message'])
+        send_epg_update(source.id, "parsing_programs", 100, status="error", error=msg)
+        return None
+
+    sd_lineup_country = _sd_fetch_lineup_country(token, sd_headers_fn)
+
+    send_epg_update(
+        source.id, "parsing_programs", 15,
+        message=f"Fetching guide data for {epg.name or epg.tvg_id}...",
+    )
+    station_map = {epg.tvg_id: {'name': epg.name or epg.tvg_id, 'logo_url': epg.icon_url}}
+    epg_id_map = {epg.tvg_id: epg.id}
+    return station_map, epg_id_map, sd_lineup_country, epg
+
+
+def _sd_setup_mapped_guide_fetch(source, token, sd_headers_fn):
+    """Build station_map / epg_id_map for all channels mapped to this SD source."""
+    from apps.channels.models import Channel
+
+    mapped_epg_ids = set(
+        Channel.objects.filter(
+            epg_data__epg_source=source,
+            epg_data__isnull=False,
+        ).values_list('epg_data_id', flat=True)
+    )
+    if not mapped_epg_ids:
+        msg = "No channels mapped to this Schedules Direct source."
+        logger.info(msg)
+        source.last_message = msg
+        source.save(update_fields=['last_message'])
+        send_epg_update(source.id, "parsing_programs", 100, status="idle", message=msg)
+        return None
+
+    station_map = {}
+    epg_id_map = {}
+    for epg in EPGData.objects.filter(id__in=mapped_epg_ids, epg_source=source):
+        if not epg.tvg_id:
+            continue
+        station_map[epg.tvg_id] = {
+            'name': epg.name or epg.tvg_id,
+            'logo_url': epg.icon_url,
+        }
+        epg_id_map[epg.tvg_id] = epg.id
+
+    if not station_map:
+        msg = "Mapped channels have no valid Schedules Direct station IDs."
+        logger.warning(msg)
+        source.last_message = msg
+        source.save(update_fields=['last_message'])
+        send_epg_update(source.id, "parsing_programs", 100, status="error", error=msg)
+        return None
+
+    sd_lineup_country = _sd_fetch_lineup_country(token, sd_headers_fn)
+    send_epg_update(
+        source.id, "parsing_programs", 15,
+        message=f"Fetching guide data for {len(station_map)} mapped stations...",
+    )
+    return station_map, epg_id_map, sd_lineup_country
+
+
+def dispatch_program_refresh_for_epg_ids(epg_ids):
+    """
+    Queue guide/program refresh for newly assigned EPGData rows.
+
+    XMLTV and other non-SD sources use parse_programs_for_tvg_id per id.
+    Schedules Direct uses per-EPG fetches for small batches and one batched
+    mapped-station fetch per source when the threshold is exceeded.
+    """
+    if not epg_ids:
+        return 0
+
+    epg_ids = {eid for eid in epg_ids if eid}
+    if not epg_ids:
+        return 0
+
+    epgs = list(
+        EPGData.objects.filter(id__in=epg_ids).select_related('epg_source')
+    )
+    epgs_with_program_data = set(
+        ProgramData.objects.filter(epg_id__in=epg_ids)
+        .values_list('epg_id', flat=True)
+        .distinct()
+    )
+
+    non_sd_epg_ids = []
+    sd_by_source = {}
+    for epg in epgs:
+        if not epg.epg_source:
+            non_sd_epg_ids.append(epg.id)
+            continue
+        source_type = epg.epg_source.source_type
+        if source_type == 'dummy':
+            continue
+        if source_type == 'schedules_direct':
+            sd_by_source.setdefault(epg.epg_source_id, []).append(epg)
+        else:
+            non_sd_epg_ids.append(epg.id)
+
+    dispatched = 0
+    for epg_id in non_sd_epg_ids:
+        parse_programs_for_tvg_id.delay(epg_id)
+        dispatched += 1
+
+    for source_id, source_epgs in sd_by_source.items():
+        needs_fetch = [
+            epg for epg in source_epgs
+            if epg.id not in epgs_with_program_data
+        ]
+        if not needs_fetch:
+            continue
+        if len(needs_fetch) >= SD_BULK_GUIDE_FETCH_THRESHOLD:
+            logger.info(
+                f"SD source {source_id}: {len(needs_fetch)} new mapping(s) exceed "
+                f"threshold ({SD_BULK_GUIDE_FETCH_THRESHOLD}); "
+                "queueing batched mapped guide fetch"
+            )
+            fetch_sd_mapped_guide_batch.delay(source_id)
+            dispatched += 1
+        else:
+            for epg in needs_fetch:
+                parse_programs_for_tvg_id.delay(epg.id)
+                dispatched += 1
+
+    return dispatched
+
+
+@shared_task(time_limit=3600, soft_time_limit=3500)
+def fetch_sd_mapped_guide_batch(source_id, force=False, _defer_retry=0):
+    """
+    Fetch Schedules Direct guide data for all mapped stations on one source.
+
+    Used when bulk EPG assignment would otherwise queue many per-EPG tasks.
+    """
+    try:
+        source = EPGSource.objects.get(id=source_id)
+    except EPGSource.DoesNotExist:
+        logger.error(f"EPGSource {source_id} not found for SD mapped guide batch")
+        return
+
+    if source.source_type != 'schedules_direct':
+        return "Not a Schedules Direct source"
+
+    if not acquire_task_lock('sd_mapped_guide_fetch', source_id):
+        if _defer_retry < SD_MAPPED_GUIDE_FETCH_DEFER_MAX_RETRIES:
+            logger.info(
+                f"SD mapped guide batch for source {source_id} already in progress, "
+                f"deferring retry {_defer_retry + 1}/"
+                f"{SD_MAPPED_GUIDE_FETCH_DEFER_MAX_RETRIES}"
+            )
+            fetch_sd_mapped_guide_batch.apply_async(
+                args=[source_id],
+                kwargs={
+                    'force': force,
+                    '_defer_retry': _defer_retry + 1,
+                },
+                countdown=SD_MAPPED_GUIDE_BATCH_DEFER_SECONDS,
+            )
+            return "Deferred - batch already in progress"
+        logger.warning(
+            f"SD mapped guide batch for source {source_id} still locked after "
+            f"{_defer_retry} deferrals; giving up"
+        )
+        return "Task already running"
+
+    lock_renewer = TaskLockRenewer('sd_mapped_guide_fetch', source_id)
+    lock_renewer.start()
+    try:
+        logger.info(f"Fetching Schedules Direct guide for mapped stations (source: {source.name})")
+        fetch_schedules_direct(source, mapped_guide_batch=True, force=force)
+        return "SD mapped guide batch complete"
+    finally:
+        lock_renewer.stop()
+        release_task_lock('sd_mapped_guide_fetch', source_id)
+
+
+@shared_task(time_limit=3600, soft_time_limit=3500)
+def fetch_sd_guide_for_epg(epg_id, force=False, _defer_retry=0):
+    """
+    Fetch Schedules Direct guide data for one mapped EPG entry (channel map flow).
+
+    Skips when ProgramData already exists so additional channels sharing the
+    same EPGData / tvg_id do not trigger redundant API calls.
+    """
+    epg = EPGData.objects.select_related('epg_source').filter(id=epg_id).first()
+    if not epg or not epg.epg_source or epg.epg_source.source_type != 'schedules_direct':
+        return "Not a Schedules Direct EPG entry"
+
+    if not force and ProgramData.objects.filter(epg_id=epg_id).exists():
+        logger.info(f"SD guide fetch skipped for EPG {epg_id}: ProgramData already present")
+        return "Guide data already present"
+
+    source_id = epg.epg_source_id
+    if is_task_lock_held('sd_mapped_guide_fetch', source_id):
+        if _defer_retry < SD_MAPPED_GUIDE_FETCH_DEFER_MAX_RETRIES:
+            logger.info(
+                f"SD mapped batch in progress for source {source_id}; "
+                f"deferring single-EPG fetch for {epg_id} "
+                f"(retry {_defer_retry + 1}/{SD_MAPPED_GUIDE_FETCH_DEFER_MAX_RETRIES})"
+            )
+            fetch_sd_guide_for_epg.apply_async(
+                args=[epg_id],
+                kwargs={
+                    'force': force,
+                    '_defer_retry': _defer_retry + 1,
+                },
+                countdown=SD_MAPPED_GUIDE_BATCH_DEFER_SECONDS,
+            )
+            return "Deferred - mapped batch in progress"
+        logger.warning(
+            f"SD mapped batch still running for source {source_id} after "
+            f"{_defer_retry} deferrals; proceeding with single-EPG fetch for {epg_id}"
+        )
+
+    if not acquire_task_lock('parse_epg_programs', epg_id):
+        logger.info(f"SD guide fetch for EPG {epg_id} already in progress, skipping duplicate task")
+        return "Task already running"
+
+    lock_renewer = TaskLockRenewer('parse_epg_programs', epg_id)
+    lock_renewer.start()
+    try:
+        logger.info(f"Fetching Schedules Direct guide for EPG {epg_id} ({epg.tvg_id})")
+        fetch_schedules_direct(epg.epg_source, epg_id_only=epg_id, force=force)
+        return "SD guide fetch complete"
+    finally:
+        lock_renewer.stop()
+        release_task_lock('parse_epg_programs', epg_id)
+
+
 @shared_task(bind=True)
 def fetch_schedules_direct_stations(self, source_id):
     """
@@ -2085,7 +2686,13 @@ def fetch_schedules_direct_stations(self, source_id):
     fetch_schedules_direct(source, stations_only=True)
 
 
-def fetch_schedules_direct(source, stations_only=False, force=False):
+def fetch_schedules_direct(
+    source,
+    stations_only=False,
+    force=False,
+    epg_id_only=None,
+    mapped_guide_batch=False,
+):
     """
     Fetch EPG data from the Schedules Direct JSON API and persist it to the
     EPGData / ProgramData models.
@@ -2116,8 +2723,21 @@ def fetch_schedules_direct(source, stations_only=False, force=False):
     import hashlib
     from datetime import date
 
+    single_epg_fetch = epg_id_only is not None
+    lightweight_sd_fetch = single_epg_fetch or mapped_guide_batch
 
-    logger.info(f"Fetching Schedules Direct data for source: {source.name}")
+    if single_epg_fetch:
+        logger.info(
+            f"Fetching Schedules Direct guide for EPG {epg_id_only} "
+            f"(source: {source.name})"
+        )
+    elif mapped_guide_batch:
+        logger.info(
+            f"Fetching Schedules Direct guide for mapped stations "
+            f"(source: {source.name})"
+        )
+    else:
+        logger.info(f"Fetching Schedules Direct data for source: {source.name}")
 
     # -------------------------------------------------------------------------
     # Validate credentials
@@ -2144,7 +2764,7 @@ def fetch_schedules_direct(source, stations_only=False, force=False):
     # updated_at, which would otherwise incorrectly trigger this guard). Always
     # allow the first full refresh through so guide data is immediately available.
     # -------------------------------------------------------------------------
-    if not stations_only and not force and source.updated_at:
+    if not stations_only and not force and not lightweight_sd_fetch and source.updated_at:
         from apps.epg.models import SDScheduleMD5 as _SDScheduleMD5
         has_prior_full_refresh = _SDScheduleMD5.objects.filter(epg_source=source).exists()
         if has_prior_full_refresh:
@@ -2165,7 +2785,7 @@ def fetch_schedules_direct(source, stations_only=False, force=False):
                 return
         else:
             logger.info(f"SD source {source.id}: No prior full refresh detected, skipping 2-hour guard for first full fetch.")
-    elif force and not stations_only:
+    elif force and not stations_only and not lightweight_sd_fetch:
         logger.info(f"SD source {source.id}: Force flag set, bypassing 2-hour refresh guard.")
 
     # -------------------------------------------------------------------------
@@ -2173,17 +2793,10 @@ def fetch_schedules_direct(source, stations_only=False, force=False):
     # SD API spec requires the User-Agent to identify the application and version.
     # SergeantPanda confirmed Dispatcharr should identify itself properly.
     # -------------------------------------------------------------------------
-    from version import __version__ as dispatcharr_version
-    sd_user_agent = f"Dispatcharr/{dispatcharr_version}"
+    from core.utils import dispatcharr_http_headers
 
     def _sd_headers(token=None):
-        h = {
-            'Content-Type': 'application/json',
-            'User-Agent': sd_user_agent,
-        }
-        if token:
-            h['token'] = token
-        return h
+        return dispatcharr_http_headers(token=token)
 
     def _sd_post_refresh_tasks(mapped_epg_ids, program_metadata, today):
         """Poster fetch, logo auto-apply, and pruning — runs even when schedules are unchanged."""
@@ -2211,7 +2824,7 @@ def fetch_schedules_direct(source, stations_only=False, force=False):
                 )
 
         if fetch_posters and poster_program_ids:
-            logger.info("Poster fetch enabled — retrieving program artwork from Schedules Direct.")
+            logger.info("Poster fetch enabled, retrieving program artwork from Schedules Direct.")
             send_epg_update(source.id, "parsing_programs", 98,
                             message="Fetching program artwork...")
             try:
@@ -2299,6 +2912,24 @@ def fetch_schedules_direct(source, stations_only=False, force=False):
         from apps.channels.utils import maybe_auto_apply_epg_logos
         maybe_auto_apply_epg_logos(source)
 
+        try:
+            unmapped_epg_ids = list(
+                EPGData.objects.filter(epg_source=source).exclude(
+                    id__in=mapped_epg_ids,
+                ).values_list('id', flat=True)
+            )
+            if unmapped_epg_ids:
+                orphaned_count = ProgramData.objects.filter(
+                    epg_id__in=unmapped_epg_ids,
+                ).delete()[0]
+                if orphaned_count:
+                    logger.info(
+                        f"Cleaned up {orphaned_count} orphaned ProgramData records "
+                        f"for {len(unmapped_epg_ids)} unmapped EPG entries."
+                    )
+        except Exception as prune_err:
+            logger.warning(f"Failed to clean up orphaned SD ProgramData: {prune_err}")
+
         today_utc = datetime(today.year, today.month, today.day, tzinfo=dt_timezone.utc)
         try:
             expired_count = ProgramData.objects.filter(epg_id__in=mapped_epg_ids, end_time__lt=today_utc).delete()[0]
@@ -2326,9 +2957,10 @@ def fetch_schedules_direct(source, stations_only=False, force=False):
     # This is a requirement of the Schedules Direct API specification, not an
     # architectural choice.
     # -------------------------------------------------------------------------
-    source.status = EPGSource.STATUS_FETCHING
-    source.last_message = "Authenticating with Schedules Direct..."
-    source.save(update_fields=['status', 'last_message'])
+    if not lightweight_sd_fetch:
+        source.status = EPGSource.STATUS_FETCHING
+        source.last_message = "Authenticating with Schedules Direct..."
+        source.save(update_fields=['status', 'last_message'])
     send_epg_update(source.id, "parsing_programs", 2, message="Authenticating with Schedules Direct...")
 
     try:
@@ -2411,219 +3043,291 @@ def fetch_schedules_direct(source, stations_only=False, force=False):
     except requests.exceptions.RequestException as e:
         logger.warning(f"Could not fetch SD system status, proceeding anyway: {e}")
 
-    # -------------------------------------------------------------------------
-    # Step 3: Fetch subscribed lineups and build station map
-    # -------------------------------------------------------------------------
-    send_epg_update(source.id, "parsing_programs", 10, message="Fetching subscribed lineups...")
-    try:
-        lineups_response = requests.get(
-            f"{SD_BASE_URL}/lineups",
-            headers=_sd_headers(token),
-            timeout=30,
-        )
-        # SD returns 400 with code 4102 when no lineups are configured.
-        # This is a valid account state. The user needs to add lineups via
-        # the Manage Lineups UI. Treat as idle rather than error.
-        if lineups_response.status_code == 400:
-            sd_data = lineups_response.json()
-            if sd_data.get('code') == 4102:
+    station_map = None
+    epg_id_map = None
+    sd_lineup_country = None
+
+    if epg_id_only is not None:
+        setup = _sd_setup_single_epg_fetch(source, epg_id_only, token, _sd_headers)
+        if setup is None:
+            return
+        station_map, epg_id_map, sd_lineup_country, _single_epg = setup
+    elif mapped_guide_batch:
+        setup = _sd_setup_mapped_guide_fetch(source, token, _sd_headers)
+        if setup is None:
+            return
+        station_map, epg_id_map, sd_lineup_country = setup
+    else:
+        # -------------------------------------------------------------------------
+        # Step 3: Fetch subscribed lineups and build station map
+        # -------------------------------------------------------------------------
+        send_epg_update(source.id, "parsing_programs", 10, message="Fetching subscribed lineups...")
+        try:
+            lineups_response = requests.get(
+                f"{SD_BASE_URL}/lineups",
+                headers=_sd_headers(token),
+                timeout=30,
+            )
+            # SD returns 400 with code 4102 when no lineups are configured.
+            # This is a valid account state. The user needs to add lineups via
+            # the Manage Lineups UI. Treat as idle rather than error.
+            if lineups_response.status_code == 400:
+                sd_data = lineups_response.json()
+                if sd_data.get('code') == 4102:
+                    msg = "No lineups configured. Use the Manage Lineups option in the EPG source settings to add a lineup."
+                    logger.warning(f"SD source {source.id}: no lineups configured on account (4102).")
+                    source.status = EPGSource.STATUS_IDLE
+                    source.last_message = msg
+                    source.save(update_fields=['status', 'last_message'])
+                    send_epg_update(source.id, "refresh", 100, status="idle", message=msg)
+                    return
+            lineups_response.raise_for_status()
+            lineups_data = lineups_response.json()
+            lineups = [l for l in lineups_data.get('lineups', []) if not l.get('isDeleted', False)]
+            if not lineups:
                 msg = "No lineups configured. Use the Manage Lineups option in the EPG source settings to add a lineup."
-                logger.warning(f"SD source {source.id}: no lineups configured on account (4102).")
+                logger.warning(f"SD source {source.id}: no active lineups found.")
                 source.status = EPGSource.STATUS_IDLE
                 source.last_message = msg
                 source.save(update_fields=['status', 'last_message'])
                 send_epg_update(source.id, "refresh", 100, status="idle", message=msg)
                 return
-        lineups_response.raise_for_status()
-        lineups_data = lineups_response.json()
-        lineups = [l for l in lineups_data.get('lineups', []) if not l.get('isDeleted', False)]
-        if not lineups:
-            msg = "No lineups configured. Use the Manage Lineups option in the EPG source settings to add a lineup."
-            logger.warning(f"SD source {source.id}: no active lineups found.")
-            source.status = EPGSource.STATUS_IDLE
+            logger.info(f"Found {len(lineups)} lineup(s) in SD account.")
+
+            # Extract country from lineup IDs (format: "USA-NJ29486-X", "GBR-...", etc.)
+            sd_lineup_country = None
+            for l in lineups:
+                lid = l.get('lineupID') or l.get('lineup') or ''
+                if '-' in lid:
+                    sd_lineup_country = lid.split('-')[0]
+                    break
+            logger.debug(f"SD lineup country: {sd_lineup_country}")
+        except requests.exceptions.RequestException as e:
+            msg = f"Failed to fetch Schedules Direct lineups: {e}"
+            logger.error(msg, exc_info=True)
+            source.status = EPGSource.STATUS_ERROR
             source.last_message = msg
             source.save(update_fields=['status', 'last_message'])
-            send_epg_update(source.id, "refresh", 100, status="idle", message=msg)
+            send_epg_update(source.id, "refresh", 100, status="error", error=msg)
             return
-        logger.info(f"Found {len(lineups)} lineup(s) in SD account.")
 
-        # Extract country from lineup IDs (format: "USA-NJ29486-X", "GBR-...", etc.)
-        sd_lineup_country = None
-        for l in lineups:
-            lid = l.get('lineupID') or l.get('lineup') or ''
-            if '-' in lid:
-                sd_lineup_country = lid.split('-')[0]
-                break
-        logger.debug(f"SD lineup country: {sd_lineup_country}")
-    except requests.exceptions.RequestException as e:
-        msg = f"Failed to fetch Schedules Direct lineups: {e}"
-        logger.error(msg, exc_info=True)
-        source.status = EPGSource.STATUS_ERROR
-        source.last_message = msg
+        # Build station metadata map: stationID -> {name, callsign, logo_url}
+        station_map = {}
+        send_epg_update(source.id, "parsing_programs", 18, message=f"Fetching station metadata for {len(lineups)} lineup(s)...")
+        for lineup in lineups:
+            lineup_id = lineup.get('lineupID') or lineup.get('lineup')
+            if not lineup_id:
+                continue
+            try:
+                detail_response = requests.get(
+                    f"{SD_BASE_URL}/lineups/{lineup_id}",
+                    headers=_sd_headers(token),
+                    timeout=30,
+                )
+                detail_response.raise_for_status()
+                detail_data = detail_response.json()
+                for station in detail_data.get('stations', []):
+                    sid = station.get('stationID')
+                    if not sid:
+                        continue
+                    logo_url = None
+                    logos = station.get('stationLogo') or station.get('logo') or []
+                    if isinstance(logos, list) and logos:
+                        # Read preferred logo style from source settings; default to 'dark'
+                        logo_style = (source.custom_properties or {}).get('logo_style', 'dark')
+                        preferred = next((l for l in logos if l.get('category') == logo_style), logos[0])
+                        logo_url = preferred.get('URL') or preferred.get('url')
+                    elif isinstance(logos, dict):
+                        logo_url = logos.get('URL') or logos.get('url')
+                    station_map[sid] = {
+                        'name': station.get('name', sid),
+                        'callsign': station.get('callsign', ''),
+                        'logo_url': logo_url,
+                    }
+                logger.debug(f"Fetched {len(detail_data.get('stations', []))} stations from lineup {lineup_id}")
+            except requests.exceptions.RequestException as e:
+                logger.warning(f"Failed to fetch lineup details for {lineup_id}: {e}")
+
+        if not station_map:
+            msg = "No stations found across all Schedules Direct lineups."
+            logger.warning(msg)
+            source.status = EPGSource.STATUS_ERROR
+            source.last_message = msg
+            source.save(update_fields=['status', 'last_message'])
+            send_epg_update(source.id, "refresh", 100, status="error", error=msg)
+            return
+
+        logger.info(f"Built station map with {len(station_map)} stations.")
+
+        # -------------------------------------------------------------------------
+        # Step 4: Persist station metadata to EPGData
+        # -------------------------------------------------------------------------
+        source.status = EPGSource.STATUS_PARSING
+        source.last_message = f"Syncing {len(station_map)} stations..."
         source.save(update_fields=['status', 'last_message'])
-        send_epg_update(source.id, "refresh", 100, status="error", error=msg)
-        return
+        send_epg_update(source.id, "parsing_programs", 28, message=f"Syncing {len(station_map)} stations to database...")
 
-    # Build station metadata map: stationID -> {name, callsign, logo_url}
-    station_map = {}
-    send_epg_update(source.id, "parsing_programs", 18, message=f"Fetching station metadata for {len(lineups)} lineup(s)...")
-    for lineup in lineups:
-        lineup_id = lineup.get('lineupID') or lineup.get('lineup')
-        if not lineup_id:
-            continue
-        try:
-            detail_response = requests.get(
-                f"{SD_BASE_URL}/lineups/{lineup_id}",
-                headers=_sd_headers(token),
-                timeout=30,
+        existing_epg_map = {
+            epg.tvg_id: epg
+            for epg in EPGData.objects.filter(epg_source=source)
+        }
+
+        epgs_to_create = []
+        epgs_to_update = []
+        icon_max_length = EPGData._meta.get_field('icon_url').max_length
+        name_max_length = EPGData._meta.get_field('name').max_length
+
+        for sid, info in station_map.items():
+            display_name = (info['name'] or sid)[:name_max_length]
+            logo = info['logo_url']
+            if logo and len(logo) > icon_max_length:
+                logo = None
+
+            if sid in existing_epg_map:
+                epg_obj = existing_epg_map[sid]
+                needs_update = False
+                if epg_obj.name != display_name:
+                    epg_obj.name = display_name
+                    needs_update = True
+                if epg_obj.icon_url != logo:
+                    epg_obj.icon_url = logo
+                    needs_update = True
+                if needs_update:
+                    epgs_to_update.append(epg_obj)
+            else:
+                epgs_to_create.append(EPGData(
+                    tvg_id=sid,
+                    name=display_name,
+                    icon_url=logo,
+                    epg_source=source,
+                ))
+
+        if epgs_to_create:
+            EPGData.objects.bulk_create(epgs_to_create, ignore_conflicts=True)
+            logger.info(f"Created {len(epgs_to_create)} new EPGData entries.")
+        if epgs_to_update:
+            EPGData.objects.bulk_update(epgs_to_update, ['name', 'icon_url'])
+            logger.info(f"Updated {len(epgs_to_update)} existing EPGData entries.")
+
+        gc.collect()
+
+        # Rebuild map with fresh DB ids for all stations
+        epg_id_map = {
+            epg.tvg_id: epg.id
+            for epg in EPGData.objects.filter(epg_source=source, tvg_id__in=list(station_map.keys()))
+        }
+
+        # Station sync complete. Send progress update before continuing into programs phase.
+        # We deliberately do NOT send parsing_channels at 100 with status=success here
+        # because that would cause the frontend to mark the source as complete and
+        # stop rendering progress updates for the subsequent program fetch phases.
+        send_epg_update(source.id, "parsing_programs", 30,
+                        message=f"Stations synced ({len(station_map)} stations). Preparing schedule fetch...")
+
+        # -------------------------------------------------------------------------
+        # Stations-only mode. Used on initial source creation.
+        # Stop here so the user can run Auto-match EPG before the full program fetch.
+        # -------------------------------------------------------------------------
+        if stations_only:
+            success_msg = (
+                f"{len(station_map)} stations loaded from Schedules Direct. "
+                f"Run Auto-match EPG to map your channels, then use the Refresh "
+                f"button to populate guide data."
             )
-            detail_response.raise_for_status()
-            detail_data = detail_response.json()
-            for station in detail_data.get('stations', []):
-                sid = station.get('stationID')
-                if not sid:
-                    continue
-                logo_url = None
-                logos = station.get('stationLogo') or station.get('logo') or []
-                if isinstance(logos, list) and logos:
-                    # Read preferred logo style from source settings; default to 'dark'
-                    logo_style = (source.custom_properties or {}).get('logo_style', 'dark')
-                    preferred = next((l for l in logos if l.get('category') == logo_style), logos[0])
-                    logo_url = preferred.get('URL') or preferred.get('url')
-                elif isinstance(logos, dict):
-                    logo_url = logos.get('URL') or logos.get('url')
-                station_map[sid] = {
-                    'name': station.get('name', sid),
-                    'callsign': station.get('callsign', ''),
-                    'logo_url': logo_url,
-                }
-            logger.debug(f"Fetched {len(detail_data.get('stations', []))} stations from lineup {lineup_id}")
-        except requests.exceptions.RequestException as e:
-            logger.warning(f"Failed to fetch lineup details for {lineup_id}: {e}")
-
-    if not station_map:
-        msg = "No stations found across all Schedules Direct lineups."
-        logger.warning(msg)
-        source.status = EPGSource.STATUS_ERROR
-        source.last_message = msg
-        source.save(update_fields=['status', 'last_message'])
-        send_epg_update(source.id, "refresh", 100, status="error", error=msg)
-        return
-
-    logger.info(f"Built station map with {len(station_map)} stations.")
+            source.status = EPGSource.STATUS_SUCCESS
+            source.last_message = success_msg
+            source.updated_at = timezone.now()
+            source.save(update_fields=['status', 'last_message', 'updated_at'])
+            send_epg_update(source.id, "parsing_channels", 100, status="success",
+                            message=success_msg, channels_count=len(station_map))
+            logger.info(f"Stations-only fetch complete for source: {source.name} ({len(station_map)} stations)")
+            return
 
     # -------------------------------------------------------------------------
-    # Step 4: Persist station metadata to EPGData
+    # Step 5: MD5-delta schedule fetch
+    # Only mapped channels need guide data. Fetch MD5 hashes and schedules for
+    # mapped stations only; never cache schedule MD5s for unmapped lineup entries.
     # -------------------------------------------------------------------------
-    source.status = EPGSource.STATUS_PARSING
-    source.last_message = f"Syncing {len(station_map)} stations..."
-    source.save(update_fields=['status', 'last_message'])
-    send_epg_update(source.id, "parsing_programs", 28, message=f"Syncing {len(station_map)} stations to database...")
+    from django.utils.dateparse import parse_datetime
 
-    existing_epg_map = {
-        epg.tvg_id: epg
-        for epg in EPGData.objects.filter(epg_source=source)
-    }
+    station_ids = list(station_map.keys())
+    today = date.today()
+    date_list = [(today + timedelta(days=i)).strftime('%Y-%m-%d') for i in range(SD_DAYS_TO_FETCH)]
 
-    epgs_to_create = []
-    epgs_to_update = []
-    icon_max_length = EPGData._meta.get_field('icon_url').max_length
-    name_max_length = EPGData._meta.get_field('name').max_length
+    mapped_epg_ids = set(
+        Channel.objects.filter(
+            epg_data__epg_source=source,
+            epg_data__isnull=False,
+        ).values_list('epg_data_id', flat=True)
+    )
+    mapped_tvg_ids = set(
+        EPGData.objects.filter(
+            id__in=mapped_epg_ids,
+            epg_source=source,
+        ).values_list('tvg_id', flat=True)
+    )
+    mapped_station_ids = [sid for sid in station_ids if sid in mapped_tvg_ids]
 
-    for sid, info in station_map.items():
-        display_name = (info['name'] or sid)[:name_max_length]
-        logo = info['logo_url']
-        if logo and len(logo) > icon_max_length:
-            logo = None
+    # Prune expired schedule MD5s and drop cache for unmapped stations.
+    pruned_sched_md5_count = SDScheduleMD5.objects.filter(
+        epg_source=source, date__lt=today,
+    ).delete()[0]
+    if pruned_sched_md5_count:
+        logger.info(f"Pruned {pruned_sched_md5_count} expired SDScheduleMD5 records (before {today}).")
 
-        if sid in existing_epg_map:
-            epg_obj = existing_epg_map[sid]
-            needs_update = False
-            if epg_obj.name != display_name:
-                epg_obj.name = display_name
-                needs_update = True
-            if epg_obj.icon_url != logo:
-                epg_obj.icon_url = logo
-                needs_update = True
-            if needs_update:
-                epgs_to_update.append(epg_obj)
-        else:
-            epgs_to_create.append(EPGData(
-                tvg_id=sid,
-                name=display_name,
-                icon_url=logo,
-                epg_source=source,
-            ))
+    if mapped_tvg_ids:
+        unmapped_cache_pruned = SDScheduleMD5.objects.filter(
+            epg_source=source,
+        ).exclude(station_id__in=mapped_tvg_ids).delete()[0]
+    else:
+        unmapped_cache_pruned = SDScheduleMD5.objects.filter(epg_source=source).delete()[0]
+    if unmapped_cache_pruned:
+        logger.info(f"Pruned {unmapped_cache_pruned} SDScheduleMD5 records for unmapped lineup stations.")
 
-    if epgs_to_create:
-        EPGData.objects.bulk_create(epgs_to_create, ignore_conflicts=True)
-        logger.info(f"Created {len(epgs_to_create)} new EPGData entries.")
-    if epgs_to_update:
-        EPGData.objects.bulk_update(epgs_to_update, ['name', 'icon_url'])
-        logger.info(f"Updated {len(epgs_to_update)} existing EPGData entries.")
-
-    gc.collect()
-
-    # Rebuild map with fresh DB ids for all stations
-    epg_id_map = {
-        epg.tvg_id: epg.id
-        for epg in EPGData.objects.filter(epg_source=source, tvg_id__in=list(station_map.keys()))
-    }
-
-    # Station sync complete. Send progress update before continuing into programs phase.
-    # We deliberately do NOT send parsing_channels at 100 with status=success here
-    # because that would cause the frontend to mark the source as complete and
-    # stop rendering progress updates for the subsequent program fetch phases.
-    send_epg_update(source.id, "parsing_programs", 30,
-                    message=f"Stations synced ({len(station_map)} stations). Preparing schedule fetch...")
-
-    # -------------------------------------------------------------------------
-    # Stations-only mode. Used on initial source creation.
-    # Stop here so the user can run Auto-match EPG before the full program fetch.
-    # -------------------------------------------------------------------------
-    if stations_only:
+    if not mapped_station_ids:
+        logger.info("No channels mapped to this SD source; skipping schedule MD5 check and downloads.")
+        _sd_post_refresh_tasks(mapped_epg_ids, {}, today)
+        if single_epg_fetch:
+            msg = "No mapped channel found for this EPG entry; guide fetch skipped."
+            source.last_message = msg
+            source.save(update_fields=['last_message'])
+            send_epg_update(source.id, "parsing_programs", 100, status="idle", message=msg)
+            return
+        if mapped_guide_batch:
+            msg = "No mapped channels with guide data to fetch."
+            source.last_message = msg
+            source.save(update_fields=['last_message'])
+            send_epg_update(source.id, "parsing_programs", 100, status="idle", message=msg)
+            return
         success_msg = (
-            f"{len(station_map)} stations loaded from Schedules Direct. "
-            f"Run Auto-match EPG to map your channels, then use the Refresh "
-            f"button to populate guide data."
+            f"{len(station_map)} lineup stations synced. "
+            "Map channels to EPG entries, then refresh to populate guide data."
         )
         source.status = EPGSource.STATUS_SUCCESS
         source.last_message = success_msg
         source.updated_at = timezone.now()
         source.save(update_fields=['status', 'last_message', 'updated_at'])
-        send_epg_update(source.id, "parsing_channels", 100, status="success",
-                        message=success_msg, channels_count=len(station_map))
-        logger.info(f"Stations-only fetch complete for source: {source.name} ({len(station_map)} stations)")
+        send_epg_update(source.id, "parsing_programs", 100, status="success", message=success_msg)
         return
 
-    # -------------------------------------------------------------------------
-    # Step 5: MD5-delta schedule fetch
-    # First fetch MD5 hashes for all stations/dates. Compare against our
-    # locally cached hashes to determine which schedules have changed.
-    # Only download schedules that have actually changed; this minimises
-    # API calls against SD's rate-limited endpoints.
-    # -------------------------------------------------------------------------
-    from apps.epg.models import SDScheduleMD5
-    from django.utils.dateparse import parse_datetime
+    send_epg_update(
+        source.id, "parsing_programs", 33,
+        message=f"Checking schedule MD5s for {len(mapped_station_ids)} mapped stations over {SD_DAYS_TO_FETCH} days...",
+    )
 
-    send_epg_update(source.id, "parsing_programs", 33, message=f"Checking schedule MD5s for {len(station_map)} stations over {SD_DAYS_TO_FETCH} days...")
-    station_ids = list(station_map.keys())
-    today = date.today()
-    date_list = [(today + timedelta(days=i)).strftime('%Y-%m-%d') for i in range(SD_DAYS_TO_FETCH)]
-
-    # Prune SDScheduleMD5 records whose dates have rolled off the fetch window.
-    # These accumulate one row per station per day and are never useful once past.
-    pruned_sched_md5_count = SDScheduleMD5.objects.filter(epg_source=source, date__lt=today).delete()[0]
-    if pruned_sched_md5_count:
-        logger.info(f"Pruned {pruned_sched_md5_count} expired SDScheduleMD5 records (before {today}).")
-
-    # Fetch MD5 hashes for all stations in batches of 5000
+    # Fetch MD5 hashes for mapped stations in batches of 5000
     STATION_BATCH_SIZE = 5000
     server_md5s = {}  # (station_id, date) -> {md5, last_modified}
 
-    logger.info(f"Fetching schedule MD5s for {len(station_ids)} stations over {SD_DAYS_TO_FETCH} days.")
+    logger.info(
+        f"Fetching schedule MD5s for {len(mapped_station_ids)} mapped stations "
+        f"(of {len(station_ids)} lineup stations) over {SD_DAYS_TO_FETCH} days."
+    )
 
-    station_batches = [station_ids[i:i + STATION_BATCH_SIZE] for i in range(0, len(station_ids), STATION_BATCH_SIZE)]
+    station_batches = [
+        mapped_station_ids[i:i + STATION_BATCH_SIZE]
+        for i in range(0, len(mapped_station_ids), STATION_BATCH_SIZE)
+    ]
     for batch in station_batches:
         try:
             md5_response = requests.post(
@@ -2644,41 +3348,71 @@ def fetch_schedules_direct(source, stations_only=False, force=False):
         except requests.exceptions.RequestException as e:
             logger.warning(f"Failed to fetch schedule MD5s: {e}")
 
-    # Load our cached MD5s from DB
+    # Load our cached MD5s from DB (mapped stations only)
     cached_md5s = {
         (r.station_id, r.date.strftime('%Y-%m-%d')): r.md5
-        for r in SDScheduleMD5.objects.filter(epg_source=source, station_id__in=station_ids)
+        for r in SDScheduleMD5.objects.filter(
+            epg_source=source, station_id__in=mapped_station_ids,
+        )
     }
 
-    # Determine which station/date combinations need downloading
-    changed_by_station = {}  # station_id -> [date_str, ...]
-    for (sid, date_str), server_info in server_md5s.items():
-        if date_str not in date_list:
-            continue
-        cached = cached_md5s.get((sid, date_str))
-        if cached != server_info['md5']:
-            changed_by_station.setdefault(sid, []).append(date_str)
+    changed_by_station = _sd_compute_schedule_changes_from_md5(
+        server_md5s, cached_md5s, date_list,
+    )
+
+    window_start = datetime(today.year, today.month, today.day, tzinfo=dt_timezone.utc)
+    window_end = window_start + timedelta(days=SD_DAYS_TO_FETCH)
+    dates_with_data = set()
+    if mapped_epg_ids:
+        for epg_id, start_time in ProgramData.objects.filter(
+            epg_id__in=mapped_epg_ids,
+            start_time__gte=window_start,
+            start_time__lt=window_end,
+        ).values_list('epg_id', 'start_time'):
+            dates_with_data.add((epg_id, start_time.date()))
+
+    stations_without_any_data = mapped_tvg_ids - set(
+        ProgramData.objects.filter(epg_id__in=mapped_epg_ids)
+        .values_list('tvg_id', flat=True).distinct()
+    )
+    backfilled_count = _sd_backfill_schedule_dates_without_data(
+        changed_by_station,
+        server_md5s,
+        date_list,
+        mapped_station_ids,
+        epg_id_map,
+        dates_with_data,
+        cached_md5s,
+        stations_without_any_data,
+    )
+    if backfilled_count:
+        logger.info(
+            f"Backfilling {backfilled_count} station/date combinations with no ProgramData "
+            f"in the {SD_DAYS_TO_FETCH}-day fetch window."
+        )
 
     total_changed = sum(len(v) for v in changed_by_station.values())
-    total_possible = len(station_ids) * len(date_list)
-    logger.info(f"Schedule MD5 check: {len(server_md5s)} hashes checked, {total_changed} station/date combinations changed (of {total_possible} possible).")
+    total_possible = len(mapped_station_ids) * len(date_list)
+    logger.info(
+        f"Schedule MD5 check: {len(server_md5s)} hashes checked, "
+        f"{total_changed} station/date combinations to fetch (of {total_possible} possible)."
+    )
     send_epg_update(source.id, "parsing_programs", 38,
                     message=f"MD5 check complete: {len(changed_by_station)} stations have schedule updates.")
 
     # schedules_by_station: stationID -> list of {programID, airDateTime, duration, ...}
-    schedules_by_station = {sid: [] for sid in station_ids}
+    schedules_by_station = {sid: [] for sid in mapped_station_ids}
     program_ids_needed = set()
 
     if not changed_by_station:
         logger.info("No schedule changes detected, skipping schedule and program downloads.")
-        from apps.channels.models import Channel as ChannelModel
-        mapped_epg_ids_no_change = set(
-            ChannelModel.objects.filter(
-                epg_data__epg_source=source,
-                epg_data__isnull=False,
-            ).values_list('epg_data_id', flat=True)
-        )
-        _sd_post_refresh_tasks(mapped_epg_ids_no_change, {}, today)
+        _sd_post_refresh_tasks(mapped_epg_ids, {}, today)
+        if lightweight_sd_fetch:
+            msg = "No schedule updates needed; guide data is up to date."
+            source.last_message = msg
+            source.save(update_fields=['last_message'])
+            send_epg_update(source.id, "parsing_programs", 100, status="success", message=msg)
+            return
         send_epg_update(source.id, "parsing_programs", 100, status="success",
                         message="No schedule changes detected since last refresh. Guide data is up to date.")
         source.status = EPGSource.STATUS_SUCCESS
@@ -2814,11 +3548,21 @@ def fetch_schedules_direct(source, stations_only=False, force=False):
         ).only('program_id', 'md5')
     }
 
-    # Only fetch programs where MD5 differs from our cached value
-    programs_to_fetch = {
-        pid for pid in program_ids_needed
-        if schedule_program_md5s.get(pid) != cached_prog_md5s.get(pid)
-    }
+    programs_with_data = set()
+    if program_ids_needed:
+        programs_with_data = set(
+            ProgramData.objects.filter(
+                epg__epg_source=source,
+                program_id__in=program_ids_needed,
+            ).values_list('program_id', flat=True).distinct()
+        )
+
+    programs_to_fetch = _sd_programs_needing_metadata(
+        program_ids_needed,
+        schedule_program_md5s,
+        cached_prog_md5s,
+        programs_with_data,
+    )
 
     logger.info(
         f"Program MD5 delta: {len(program_ids_needed)} programs in schedules, "
@@ -2875,22 +3619,6 @@ def fetch_schedules_direct(source, stations_only=False, force=False):
     logger.info("Building program records...")
     send_epg_update(source.id, "parsing_programs", 80)
 
-    # Only process stations that are mapped to channels to match the existing
-    # XMLTV flow (parse_programs_for_source only processes mapped channels).
-    from apps.channels.models import Channel as ChannelModel
-    mapped_epg_ids = set(
-        ChannelModel.objects.filter(
-            epg_data__epg_source=source,
-            epg_data__isnull=False,
-        ).values_list('epg_data_id', flat=True)
-    )
-    mapped_tvg_ids = set(
-        EPGData.objects.filter(
-            id__in=mapped_epg_ids,
-            epg_source=source,
-        ).values_list('tvg_id', flat=True)
-    )
-
     # Cache existing program data for unchanged programs BEFORE surgical delete.
     # When a station/date schedule MD5 changes, ALL airings are re-fetched, but only
     # programs with changed program MD5s get metadata re-downloaded. The surgical delete
@@ -3240,6 +3968,44 @@ def fetch_schedules_direct(source, stations_only=False, force=False):
     # -------------------------------------------------------------------------
     # Done
     # -------------------------------------------------------------------------
+    if single_epg_fetch:
+        epg_label = EPGData.objects.filter(id=epg_id_only).values_list('name', flat=True).first()
+        success_msg = (
+            f"Fetched {total_programs:,} programs for "
+            f"{epg_label or epg_id_only} from Schedules Direct."
+        )
+        source.last_message = success_msg
+        source.save(update_fields=['last_message'])
+        send_epg_update(source.id, "parsing_programs", 100, status="success", message=success_msg)
+        log_system_event(
+            event_type='epg_refresh',
+            source_name=source.name,
+            programs=total_programs,
+            channels=1,
+            skipped_programs=skipped_unmapped,
+        )
+        logger.info(f"Schedules Direct single-EPG fetch complete for source: {source.name}")
+        return
+
+    if mapped_guide_batch:
+        success_msg = (
+            f"Fetched {total_programs:,} programs for "
+            f"{len(mapped_tvg_ids)} mapped stations from Schedules Direct "
+            f"({skipped_unmapped:,} programs skipped for unmapped stations)."
+        )
+        source.last_message = success_msg
+        source.save(update_fields=['last_message'])
+        send_epg_update(source.id, "parsing_programs", 100, status="success", message=success_msg)
+        log_system_event(
+            event_type='epg_refresh',
+            source_name=source.name,
+            programs=total_programs,
+            channels=len(mapped_tvg_ids),
+            skipped_programs=skipped_unmapped,
+        )
+        logger.info(f"Schedules Direct mapped guide batch complete for source: {source.name}")
+        return
+
     success_msg = (
         f"Successfully fetched {total_programs:,} programs for "
         f"{len(mapped_tvg_ids)} mapped stations from Schedules Direct "
@@ -3309,9 +4075,7 @@ def parse_xmltv_time(time_str):
 def parse_schedules_direct_time(time_str):
     try:
         dt_obj = datetime.strptime(time_str, '%Y-%m-%dT%H:%M:%SZ')
-        aware_dt = timezone.make_aware(dt_obj, timezone=dt_timezone.utc)
-        logger.debug(f"Parsed Schedules Direct time '{time_str}' to {aware_dt}")
-        return aware_dt
+        return timezone.make_aware(dt_obj, timezone=dt_timezone.utc)
     except Exception as e:
         logger.error(f"Error parsing Schedules Direct time '{time_str}': {e}", exc_info=True)
         raise
@@ -3722,7 +4486,7 @@ def _programme_to_dict(elem, start_time, end_time):
 def build_programme_index(source_id):
     """
     Scan the XML file with raw binary I/O to build a {tvg_id: [byte_offset, ...]} map.
-    Persists the result to EPGSource.programme_index. Most XMLTV files group programmes
+    Persists the result to the EPGSourceIndex table. Most XMLTV files group programmes
     by channel, but some split a channel across multiple non-contiguous blocks, so we
     record block starts up to _OFFSET_CAP and mark only channels that exceed the cap
     as interleaved.
@@ -3811,7 +4575,9 @@ def build_programme_index(source_id):
         'channels': index,
         'interleaved_channels': sorted(interleaved_channels),
     }
-    EPGSource.objects.filter(id=source_id).update(programme_index=result)
+    EPGSourceIndex.objects.update_or_create(
+        source_id=source_id, defaults={'data': result}
+    )
 
 
 @shared_task
@@ -3858,9 +4624,8 @@ def find_current_program_for_tvg_id(epg_or_id):
         return None
 
     now = timezone.now()
-    # Force a fresh read of the DB-backed index to avoid using stale related-object
-    # state when an EPG refresh invalidates/rebuilds the index concurrently.
-    source.refresh_from_db(fields=['programme_index'])
+    # The property reads the EPGSourceIndex table fresh on each access, so a
+    # concurrent refresh invalidating/rebuilding the index can't serve stale state.
     index = source.programme_index
 
     if index is not None:
diff --git a/apps/epg/tests/test_epg_import_api.py b/apps/epg/tests/test_epg_import_api.py
new file mode 100644
index 00000000..cc96c214
--- /dev/null
+++ b/apps/epg/tests/test_epg_import_api.py
@@ -0,0 +1,98 @@
+from unittest.mock import patch
+
+from django.contrib.auth import get_user_model
+from django.db import connection
+from django.test.utils import CaptureQueriesContext
+from django.test import TestCase
+from rest_framework import status
+from rest_framework.test import APIClient
+
+from apps.epg.models import EPGSource, EPGSourceIndex
+
+User = get_user_model()
+
+IMPORT_URL = "/api/epg/import/"
+
+
+class EPGImportAPITests(TestCase):
+    def setUp(self):
+        self.user = User.objects.create_user(
+            username="epg_import_admin", password="testpass123"
+        )
+        self.user.user_level = 10
+        self.user.save()
+        self.client = APIClient()
+        self.client.force_authenticate(user=self.user)
+
+    @patch("apps.epg.api_views.refresh_epg_data.delay")
+    def test_import_dummy_source_rejected_without_dispatch(self, mock_delay):
+        source = EPGSource.objects.create(
+            name="Dummy EPG",
+            source_type="dummy",
+        )
+
+        response = self.client.post(
+            IMPORT_URL, {"id": source.id}, format="json"
+        )
+
+        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
+        self.assertFalse(response.data["success"])
+        mock_delay.assert_not_called()
+
+    @patch("apps.epg.api_views.refresh_epg_data.delay")
+    def test_import_xmltv_dispatches_without_loading_programme_index(
+        self, mock_delay
+    ):
+        source = EPGSource.objects.create(
+            name="Large Index XMLTV",
+            source_type="xmltv",
+            url="http://example.com/epg.xml",
+        )
+        EPGSourceIndex.objects.create(
+            source=source,
+            data={
+                "channels": {f"ch.{i}": {"offsets": [0, 100]} for i in range(200)},
+                "interleaved_channels": [],
+            },
+        )
+        mock_delay.reset_mock()
+
+        with CaptureQueriesContext(connection) as ctx:
+            response = self.client.post(
+                IMPORT_URL, {"id": source.id}, format="json"
+            )
+
+        self.assertEqual(response.status_code, status.HTTP_202_ACCEPTED)
+        self.assertTrue(response.data["success"])
+        mock_delay.assert_called_once_with(source.id, force=False)
+        for query in ctx.captured_queries:
+            self.assertNotIn(
+                "programme_index",
+                query["sql"].lower(),
+                "import trigger should not read programme_index",
+            )
+
+    @patch("apps.epg.api_views.refresh_epg_data.delay")
+    def test_import_missing_source_still_dispatches(self, mock_delay):
+        response = self.client.post(IMPORT_URL, {"id": 99999}, format="json")
+
+        self.assertEqual(response.status_code, status.HTTP_202_ACCEPTED)
+        mock_delay.assert_called_once_with(99999, force=False)
+
+    @patch("apps.epg.api_views.refresh_epg_data.delay")
+    def test_import_honours_force_flag(self, mock_delay):
+        source = EPGSource.objects.create(
+            name="Force XMLTV",
+            source_type="xmltv",
+            url="http://example.com/epg.xml",
+        )
+        mock_delay.reset_mock()
+
+        response = self.client.post(
+            IMPORT_URL,
+            {"id": source.id, "force": True},
+            format="json",
+        )
+
+        self.assertEqual(response.status_code, status.HTTP_202_ACCEPTED)
+        mock_delay.assert_called_once_with(source.id, force=True)
diff --git a/apps/epg/tests/test_parse_programs_for_source.py b/apps/epg/tests/test_parse_programs_for_source.py
new file mode 100644
index 00000000..f49a5d70
--- /dev/null
+++ b/apps/epg/tests/test_parse_programs_for_source.py
@@ -0,0 +1,238 @@
+import os
+import tempfile
+from datetime import timedelta
+from unittest.mock import patch
+
+from django.db import connection, transaction
+from django.test import TestCase
+from django.utils import timezone
+
+from apps.channels.models import Channel
+from apps.epg.models import EPGSource, EPGData, ProgramData
+from apps.epg.tasks import (
+    parse_programs_for_source,
+    _flush_epg_program_staging_batch,
+    _swap_staged_epg_programs,
+    _EPG_PARSE_BATCH_SIZE,
+)
+
+
+def _programme_xml(channel_id, title, start, stop):
+    return (
+        f'  <programme start="{start}" stop="{stop}" channel="{channel_id}">\n'
+        f'    <title>{title}</title>\n'
+        f'  </programme>\n'
+    )
+
+
+def _xmltv_file(programmes):
+    body = (
+        '<?xml version="1.0" encoding="UTF-8"?>\n'
+        '<tv generator-info-name="test">\n'
+        f'{programmes}'
+        '</tv>\n'
+    )
+    handle = tempfile.NamedTemporaryFile(
+        mode='w',
+        suffix='.xml',
+        delete=False,
+        encoding='utf-8',
+    )
+    handle.write(body)
+    handle.close()
+    return handle.name
+
+
+class ParseProgramsForSourceTests(TestCase):
+    def setUp(self):
+        self.source = EPGSource.objects.create(
+            name='XMLTV Parse Test',
+            source_type='xmltv',
+        )
+        self.mapped_epg = EPGData.objects.create(
+            epg_source=self.source,
+            tvg_id='mapped.channel',
+            name='Mapped Channel',
+        )
+        self.unmapped_epg = EPGData.objects.create(
+            epg_source=self.source,
+            tvg_id='unmapped.channel',
+            name='Unmapped Channel',
+        )
+        Channel.objects.create(
+            channel_number=1,
+            name='Mapped Channel',
+            epg_data=self.mapped_epg,
+        )
+        self.base_time = timezone.now().replace(minute=0, second=0, microsecond=0)
+        self.start = self.base_time.strftime('%Y%m%d%H%M%S +0000')
+        self.stop = (self.base_time + timedelta(hours=1)).strftime('%Y%m%d%H%M%S +0000')
+
+    def tearDown(self):
+        if getattr(self, 'xml_path', None) and os.path.exists(self.xml_path):
+            os.unlink(self.xml_path)
+
+    def _configure_source_file(self, programmes):
+        self.xml_path = _xmltv_file(programmes)
+        self.source.file_path = self.xml_path
+        self.source.save(update_fields=['file_path'])
+
+    @patch('apps.epg.tasks.log_system_event')
+    @patch('apps.epg.tasks.send_epg_update')
+    def test_replaces_programs_for_mapped_channels(self, _send_update, _log_event):
+        old_start = self.base_time - timedelta(days=1)
+        ProgramData.objects.create(
+            epg=self.mapped_epg,
+            start_time=old_start,
+            end_time=old_start + timedelta(hours=1),
+            title='Old Programme',
+            tvg_id=self.mapped_epg.tvg_id,
+        )
+        orphan_start = self.base_time - timedelta(days=1)
+        ProgramData.objects.create(
+            epg=self.unmapped_epg,
+            start_time=orphan_start,
+            end_time=orphan_start + timedelta(hours=1),
+            title='Orphan Programme',
+            tvg_id=self.unmapped_epg.tvg_id,
+        )
+
+        programmes = (
+            _programme_xml('mapped.channel', 'New Show', self.start, self.stop)
+            + _programme_xml('unmapped.channel', 'Skipped Show', self.start, self.stop)
+        )
+        self._configure_source_file(programmes)
+
+        result = parse_programs_for_source(self.source)
+
+        self.assertTrue(result)
+        mapped_programs = ProgramData.objects.filter(epg=self.mapped_epg)
+        self.assertEqual(mapped_programs.count(), 1)
+        self.assertEqual(mapped_programs.get().title, 'New Show')
+        self.assertFalse(ProgramData.objects.filter(epg=self.unmapped_epg).exists())
+
+    @patch('apps.epg.tasks.log_system_event')
+    @patch('apps.epg.tasks.send_epg_update')
+    def test_atomic_failure_rolls_back_and_preserves_existing_programs(self, _send_update, _log_event):
+        old_start = self.base_time - timedelta(days=1)
+        ProgramData.objects.create(
+            epg=self.mapped_epg,
+            start_time=old_start,
+            end_time=old_start + timedelta(hours=1),
+            title='Keep Me',
+            tvg_id=self.mapped_epg.tvg_id,
+        )
+
+        self._configure_source_file(
+            _programme_xml('mapped.channel', 'Replacement', self.start, self.stop)
+        )
+
+        swap_path = (
+            'apps.epg.tasks._swap_staged_epg_programs'
+            if connection.vendor == 'postgresql'
+            else 'apps.epg.tasks._swap_parsed_epg_programs'
+        )
+        with patch(swap_path, side_effect=RuntimeError('simulated insert failure')):
+            result = parse_programs_for_source(self.source)
+
+        self.assertFalse(result)
+        self.assertEqual(ProgramData.objects.filter(epg=self.mapped_epg).count(), 1)
+        self.assertEqual(
+            ProgramData.objects.get(epg=self.mapped_epg).title,
+            'Keep Me',
+        )
+
+    @patch('apps.epg.tasks.log_system_event')
+    @patch('apps.epg.tasks.send_epg_update')
+    def test_streams_batches_without_holding_full_program_list(self, _send_update, _log_event):
+        if connection.vendor != 'postgresql':
+            self.skipTest('PostgreSQL staging batches are required for this assertion')
+
+        programme_count = _EPG_PARSE_BATCH_SIZE * 2
+        programmes = ''.join(
+            _programme_xml(
+                'mapped.channel',
+                f'Show {idx}',
+                self.start,
+                self.stop,
+            )
+            for idx in range(programme_count)
+        )
+        self._configure_source_file(programmes)
+        flush_sizes = []
+        original_flush = _flush_epg_program_staging_batch
+
+        def tracking_flush(batch):
+            flush_sizes.append(len(batch))
+            return original_flush(batch)
+
+        with patch('apps.epg.tasks._flush_epg_program_staging_batch', side_effect=tracking_flush):
+            result = parse_programs_for_source(self.source)
+
+        self.assertTrue(result)
+        self.assertEqual(ProgramData.objects.filter(epg=self.mapped_epg).count(), programme_count)
+        self.assertEqual(sum(flush_sizes), programme_count)
+        self.assertTrue(all(size <= _EPG_PARSE_BATCH_SIZE for size in flush_sizes))
+        self.assertGreater(len(flush_sizes), 1)
+
+    @patch('apps.epg.tasks.log_system_event')
+    @patch('apps.epg.tasks.send_epg_update')
+    def test_live_programs_remain_until_swap_commits(self, _send_update, _log_event):
+        if connection.vendor != 'postgresql':
+            self.skipTest('PostgreSQL staging swap is required for this assertion')
+
+        old_start = self.base_time - timedelta(days=1)
+        ProgramData.objects.create(
+            epg=self.mapped_epg,
+            start_time=old_start,
+            end_time=old_start + timedelta(hours=1),
+            title='Old Programme',
+            tvg_id=self.mapped_epg.tvg_id,
+        )
+        self._configure_source_file(
+            _programme_xml('mapped.channel', 'New Show', self.start, self.stop)
+        )
+
+        observed_titles_at_swap = []
+
+        def swap_with_visibility_check(mapped_epg_ids, epg_source, *args, **kwargs):
+            observed_titles_at_swap.append(
+                ProgramData.objects.get(epg=self.mapped_epg).title
+            )
+            return _swap_staged_epg_programs(mapped_epg_ids, epg_source, *args, **kwargs)
+
+        with patch('apps.epg.tasks._swap_staged_epg_programs', side_effect=swap_with_visibility_check):
+            result = parse_programs_for_source(self.source)
+
+        self.assertTrue(result)
+        self.assertEqual(observed_titles_at_swap, ['Old Programme'])
+        self.assertEqual(ProgramData.objects.get(epg=self.mapped_epg).title, 'New Show')
+
+    @patch('apps.epg.tasks.log_system_event')
+    @patch('apps.epg.tasks.send_epg_update')
+    def test_swap_delete_is_rolled_back_when_insert_fails(self, _send_update, _log_event):
+        if connection.vendor != 'postgresql':
+            self.skipTest('PostgreSQL staging swap is required for this assertion')
+
+        old_start = self.base_time - timedelta(days=1)
+        ProgramData.objects.create(
+            epg=self.mapped_epg,
+            start_time=old_start,
+            end_time=old_start + timedelta(hours=1),
+            title='Keep Me',
+            tvg_id=self.mapped_epg.tvg_id,
+        )
+        self._configure_source_file(
+            _programme_xml('mapped.channel', 'Replacement', self.start, self.stop)
+        )
+
+        def failing_swap(mapped_epg_ids, epg_source, *args, **kwargs):
+            with transaction.atomic():
+                ProgramData.objects.filter(epg_id__in=mapped_epg_ids).delete()
+                raise RuntimeError('simulated insert failure')
+
+        with patch('apps.epg.tasks._swap_staged_epg_programs', side_effect=failing_swap):
+            result = parse_programs_for_source(self.source)
+
+        self.assertFalse(result)
+        self.assertEqual(ProgramData.objects.get(epg=self.mapped_epg).title, 'Keep Me')
diff --git a/apps/epg/tests/test_programme_index.py b/apps/epg/tests/test_programme_index.py
index 5ece0ae1..829afc87 100644
--- a/apps/epg/tests/test_programme_index.py
+++ b/apps/epg/tests/test_programme_index.py
@@ -519,7 +519,6 @@ class FindCurrentProgramTests(TestCase):
             name="No Index",
             source_type="xmltv",
             file_path=FIXTURE_XML,
-            programme_index=None,
         )
         epg = EPGData.objects.create(
             tvg_id="channel.current",
diff --git a/apps/epg/tests/test_refresh_db_recovery.py b/apps/epg/tests/test_refresh_db_recovery.py
new file mode 100644
index 00000000..11885b34
--- /dev/null
+++ b/apps/epg/tests/test_refresh_db_recovery.py
@@ -0,0 +1,106 @@
+from unittest.mock import MagicMock, patch
+
+from django.test import SimpleTestCase
+
+from apps.epg.tasks import (
+    _db_query_with_retry,
+    _ensure_epg_refresh_terminal_status,
+    _get_epg_source,
+    _release_task_db_connection,
+    refresh_epg_data,
+)
+
+
+class DbQueryWithRetryTests(SimpleTestCase):
+    def test_retries_after_index_error_from_poisoned_connection(self):
+        fn = MagicMock(side_effect=[IndexError("list index out of range"), "ok"])
+
+        with patch(
+            "apps.epg.tasks._release_task_db_connection"
+        ) as mock_release:
+            result = _db_query_with_retry(fn, label="test query")
+
+        self.assertEqual(result, "ok")
+        self.assertEqual(fn.call_count, 2)
+        mock_release.assert_called_once()
+
+    def test_raises_after_exhausting_retries(self):
+        fn = MagicMock(side_effect=IndexError("list index out of range"))
+
+        with patch("apps.epg.tasks._release_task_db_connection"):
+            with self.assertRaises(IndexError):
+                _db_query_with_retry(fn, label="test query", max_retries=2)
+
+        self.assertEqual(fn.call_count, 2)
+
+
+class RefreshTaskDbStartupTests(SimpleTestCase):
+    @patch("apps.epg.tasks._ensure_epg_refresh_terminal_status")
+    @patch("apps.epg.tasks._refresh_epg_data_impl")
+    @patch("apps.epg.tasks.release_task_lock")
+    @patch("apps.epg.tasks.acquire_task_lock", return_value=True)
+    @patch("apps.epg.tasks.TaskLockRenewer")
+    @patch("apps.epg.tasks._release_task_db_connection")
+    def test_refresh_releases_db_connection_before_impl(
+        self,
+        mock_release,
+        _mock_renewer,
+        _mock_acquire,
+        _mock_release_lock,
+        mock_impl,
+        _mock_ensure_terminal,
+    ):
+        call_order = []
+
+        def track_release():
+            call_order.append("release")
+
+        mock_release.side_effect = track_release
+        mock_impl.side_effect = lambda *_a, **_k: call_order.append("impl") or "done"
+
+        result = refresh_epg_data(42)
+
+        self.assertEqual(result, "done")
+        self.assertEqual(call_order[:2], ["release", "impl"])
+
+    @patch("apps.epg.tasks.EPGSource")
+    def test_get_epg_source_uses_retry_helper(self, mock_model):
+        mock_source = MagicMock(id=42)
+        mock_model.objects.get.return_value = mock_source
+
+        with patch("apps.epg.tasks._db_query_with_retry") as mock_retry:
+            mock_retry.side_effect = lambda fn, **_: fn()
+            source = _get_epg_source(42)
+
+        mock_retry.assert_called_once()
+        mock_model.objects.get.assert_called_once_with(id=42)
+        self.assertIs(source, mock_source)
+
+
+class EnsureEpgTerminalStatusTests(SimpleTestCase):
+    @patch("apps.epg.tasks.send_epg_update")
+    @patch("apps.epg.tasks._release_task_db_connection")
+    def test_marks_stuck_fetching_as_error(self, _mock_release, mock_ws):
+        with patch("apps.epg.tasks.EPGSource") as mock_model:
+            mock_model.STATUS_ERROR = "error"
+            qs = MagicMock()
+            mock_model.objects.filter.return_value = qs
+            qs.values_list.return_value.first.return_value = "fetching"
+
+            _ensure_epg_refresh_terminal_status(7)
+
+            qs.update.assert_called_once()
+            mock_ws.assert_called_once()
+
+    @patch("apps.epg.tasks.send_epg_update")
+    @patch("apps.epg.tasks._release_task_db_connection")
+    def test_leaves_success_unchanged(self, _mock_release, mock_ws):
+        with patch("apps.epg.tasks.EPGSource") as mock_model:
+            qs = MagicMock()
+            mock_model.objects.filter.return_value = qs
+            qs.values_list.return_value.first.return_value = "success"
+
+            _ensure_epg_refresh_terminal_status(7)
+
+            qs.update.assert_not_called()
+            mock_ws.assert_not_called()
diff --git a/apps/epg/tests/test_schedules_direct.py b/apps/epg/tests/test_schedules_direct.py
index 77334112..52a59330 100644
--- a/apps/epg/tests/test_schedules_direct.py
+++ b/apps/epg/tests/test_schedules_direct.py
@@ -7,19 +7,27 @@ Covers:
 - fetch_schedules_direct: credential validation
 - fetch_schedules_direct: SHA1 password hashing and token exchange
 - fetch_schedules_direct: graceful error handling on auth failure
+- fetch_schedules_direct: schedule MD5 delta, backfill, and cache invalidation
 - parse_schedules_direct_time: correct UTC parsing
-- EPG signals: SD sources skip the XMLTV program parser
+- fetch_sd_guide_for_epg: per-channel guide fetch on map
+- EPG signals: SD sources queue guide fetch when a channel is mapped
 """
 
 import hashlib
-from datetime import datetime
+from datetime import date, datetime, timedelta, timezone as dt_timezone
 from unittest.mock import MagicMock, patch
 
 from django.test import TestCase
 from django.utils import timezone
 
-from apps.epg.models import EPGSource, EPGData
+from apps.channels.models import Channel
+from apps.epg.models import EPGSource, EPGData, ProgramData, SDScheduleMD5
 from apps.epg.serializers import EPGSourceSerializer
+from apps.epg.tasks import (
+    _sd_backfill_schedule_dates_without_data,
+    _sd_compute_schedule_changes_from_md5,
+    _sd_programs_needing_metadata,
+)
 
 
 # ---------------------------------------------------------------------------
@@ -270,6 +278,469 @@ class FetchSchedulesDirectStationsOnlyTests(TestCase):
         self.assertEqual(complete_call[1]['channels_count'], 1)
 
 
+# ---------------------------------------------------------------------------
+# Schedule MD5 delta, backfill, and cache tests
+# ---------------------------------------------------------------------------
+
+class SDScheduleMd5DeltaTests(TestCase):
+    """Pure-function tests for schedule MD5 comparison."""
+
+    DATE_LIST = ['2026-06-11', '2026-06-12', '2026-06-13']
+
+    def test_detects_changed_md5(self):
+        server_md5s = {
+            ('10001', '2026-06-11'): {'md5': 'abc', 'last_modified': ''},
+            ('10001', '2026-06-12'): {'md5': 'def', 'last_modified': ''},
+        }
+        cached_md5s = {
+            ('10001', '2026-06-11'): 'abc',
+            ('10001', '2026-06-12'): 'old',
+        }
+        changed = _sd_compute_schedule_changes_from_md5(
+            server_md5s, cached_md5s, self.DATE_LIST,
+        )
+        self.assertEqual(changed['10001'], ['2026-06-12'])
+
+    def test_missing_cache_treated_as_changed(self):
+        server_md5s = {
+            ('10001', '2026-06-11'): {'md5': 'abc', 'last_modified': ''},
+        }
+        changed = _sd_compute_schedule_changes_from_md5(server_md5s, {}, self.DATE_LIST)
+        self.assertEqual(changed['10001'], ['2026-06-11'])
+
+    def test_ignores_dates_outside_fetch_window(self):
+        server_md5s = {
+            ('10001', '2026-06-01'): {'md5': 'abc', 'last_modified': ''},
+        }
+        changed = _sd_compute_schedule_changes_from_md5(server_md5s, {}, self.DATE_LIST)
+        self.assertEqual(changed, {})
+
+
+class SDScheduleBackfillTests(TestCase):
+    """Backfill must fix stale-cache gaps without re-fetching empty cached days."""
+
+    DATE_LIST = ['2026-06-11', '2026-06-12', '2026-06-13']
+    EPG_ID = 42
+    EPG_ID_MAP = {'10001': 42}
+
+    def _server_md5s(self):
+        return {
+            (sid, ds): {'md5': 'hash', 'last_modified': ''}
+            for sid in ('10001', '10002')
+            for ds in self.DATE_LIST
+        }
+
+    def test_backfills_when_no_cache_and_no_program_data(self):
+        changed = {}
+        count = _sd_backfill_schedule_dates_without_data(
+            changed,
+            self._server_md5s(),
+            self.DATE_LIST,
+            ['10001'],
+            self.EPG_ID_MAP,
+            set(),
+            {},
+            {'10001'},
+        )
+        self.assertEqual(count, 3)
+        self.assertEqual(len(changed['10001']), 3)
+
+    def test_stale_cache_ignored_when_station_has_zero_program_data(self):
+        """Newly mapped channel: stale MD5 cache must not block backfill."""
+        changed = {}
+        cached_md5s = {
+            (sid, ds): 'hash'
+            for sid in ('10001',)
+            for ds in self.DATE_LIST
+        }
+        count = _sd_backfill_schedule_dates_without_data(
+            changed,
+            self._server_md5s(),
+            self.DATE_LIST,
+            ['10001'],
+            self.EPG_ID_MAP,
+            set(),
+            cached_md5s,
+            {'10001'},
+        )
+        self.assertEqual(count, 3)
+        self.assertEqual(len(changed['10001']), 3)
+
+    def test_skips_cached_empty_day_when_station_has_other_program_data(self):
+        """Legitimately empty schedule day must not be re-fetched every refresh."""
+        changed = {}
+        cached_md5s = {('10001', '2026-06-12'): 'hash'}
+        dates_with_data = {(self.EPG_ID, date(2026, 6, 11))}
+        count = _sd_backfill_schedule_dates_without_data(
+            changed,
+            self._server_md5s(),
+            self.DATE_LIST,
+            ['10001'],
+            self.EPG_ID_MAP,
+            dates_with_data,
+            cached_md5s,
+            set(),
+        )
+        self.assertEqual(count, 1)
+        self.assertEqual(changed['10001'], ['2026-06-13'])
+
+    def test_does_not_duplicate_dates_already_marked_changed(self):
+        changed = {'10001': ['2026-06-11']}
+        count = _sd_backfill_schedule_dates_without_data(
+            changed,
+            self._server_md5s(),
+            self.DATE_LIST,
+            ['10001'],
+            self.EPG_ID_MAP,
+            set(),
+            {},
+            {'10001'},
+        )
+        self.assertEqual(count, 2)
+        self.assertEqual(sorted(changed['10001']), self.DATE_LIST)
+
+
+class SDProgramMetadataDeltaTests(TestCase):
+    def test_fetches_when_md5_changed(self):
+        needed = _sd_programs_needing_metadata(
+            {'EP0001'},
+            {'EP0001': 'new'},
+            {'EP0001': 'old'},
+            {'EP0001'},
+        )
+        self.assertEqual(needed, {'EP0001'})
+
+    def test_fetches_when_no_local_program_data(self):
+        needed = _sd_programs_needing_metadata(
+            {'EP0001', 'EP0002'},
+            {'EP0001': 'same', 'EP0002': 'same'},
+            {'EP0001': 'same', 'EP0002': 'same'},
+            {'EP0001'},
+        )
+        self.assertEqual(needed, {'EP0002'})
+
+    def test_skips_when_md5_matches_and_program_data_exists(self):
+        needed = _sd_programs_needing_metadata(
+            {'EP0001'},
+            {'EP0001': 'same'},
+            {'EP0001': 'same'},
+            {'EP0001'},
+        )
+        self.assertEqual(needed, set())
+
+
+class SDScheduleDeltaIntegrationTests(TestCase):
+    """DB-backed tests for cache pruning and mapped-only MD5 API calls."""
+
+    MAPPED_STATION = '10001'
+    UNMAPPED_STATION = '10002'
+
+    def _make_sd_source(self):
+        return EPGSource.objects.create(
+            name='SD Integration',
+            source_type='schedules_direct',
+            username='sduser',
+            password='sdpass',
+        )
+
+    def _lineup_get_side_effect(self, url, **kwargs):
+        if url.endswith('/status'):
+            return MagicMock(
+                status_code=200,
+                json=MagicMock(return_value={'systemStatus': [{'status': 'Online'}]}),
+            )
+        if url.endswith('/lineups'):
+            return MagicMock(
+                status_code=200,
+                json=MagicMock(return_value={'lineups': [{'lineupID': 'USA-TEST-X'}]}),
+            )
+        if '/lineups/USA-TEST-X' in url:
+            return MagicMock(
+                status_code=200,
+                json=MagicMock(return_value={
+                    'stations': [
+                        {
+                            'stationID': self.MAPPED_STATION,
+                            'name': 'Mapped Station',
+                            'callsign': 'MAP',
+                        },
+                        {
+                            'stationID': self.UNMAPPED_STATION,
+                            'name': 'Unmapped Station',
+                            'callsign': 'UNM',
+                        },
+                    ],
+                }),
+            )
+        raise AssertionError(f'Unexpected GET URL: {url}')
+
+    def _build_date_list(self, days=3):
+        today = date.today()
+        return [(today + timedelta(days=i)).strftime('%Y-%m-%d') for i in range(days)]
+
+    def _seed_full_window_program_data(self, epg, days=3):
+        today = date.today()
+        for i in range(days):
+            day = today + timedelta(days=i)
+            start = datetime(day.year, day.month, day.day, 12, 0, tzinfo=dt_timezone.utc)
+            ProgramData.objects.create(
+                epg=epg,
+                start_time=start,
+                end_time=start + timedelta(hours=1),
+                title='Show',
+                tvg_id=epg.tvg_id,
+            )
+
+    @patch('apps.epg.tasks.SD_DAYS_TO_FETCH', 3)
+    @patch('apps.epg.tasks.send_epg_update')
+    @patch('apps.epg.tasks.requests.get')
+    @patch('apps.epg.tasks.requests.post')
+    def test_md5_api_only_requests_mapped_stations(
+        self, mock_post, mock_get, mock_send_epg_update,
+    ):
+        from apps.epg.tasks import fetch_schedules_direct
+
+        source = self._make_sd_source()
+        mapped_epg = EPGData.objects.create(
+            tvg_id=self.MAPPED_STATION,
+            name='Mapped',
+            epg_source=source,
+        )
+        Channel.objects.create(name='Mapped Ch', epg_data=mapped_epg)
+
+        date_list = self._build_date_list(3)
+        self._seed_full_window_program_data(mapped_epg, days=3)
+
+        today = date.today()
+        for i, ds in enumerate(date_list):
+            SDScheduleMD5.objects.create(
+                epg_source=source,
+                station_id=self.MAPPED_STATION,
+                date=today + timedelta(days=i),
+                md5=f'md5-{ds}',
+                last_modified=timezone.now(),
+            )
+        SDScheduleMD5.objects.create(
+            epg_source=source,
+            station_id=self.UNMAPPED_STATION,
+            date=today,
+            md5='unmapped-stale',
+            last_modified=timezone.now(),
+        )
+
+        mock_get.side_effect = self._lineup_get_side_effect
+
+        md5_response_payload = {
+            self.MAPPED_STATION: {
+                ds: {'code': 0, 'md5': f'md5-{ds}', 'lastModified': '2026-06-11T00:00:00Z'}
+                for ds in date_list
+            },
+        }
+
+        def post_side_effect(url, **kwargs):
+            if url.endswith('/token'):
+                return MagicMock(
+                    status_code=200,
+                    json=MagicMock(return_value={'code': 0, 'token': 'tok'}),
+                )
+            if url.endswith('/schedules/md5'):
+                return MagicMock(
+                    status_code=200,
+                    json=MagicMock(return_value=md5_response_payload),
+                )
+            raise AssertionError(f'Unexpected POST URL: {url}')
+
+        mock_post.side_effect = post_side_effect
+
+        fetch_schedules_direct(source, force=True)
+
+        md5_calls = [c for c in mock_post.call_args_list if c[0][0].endswith('/schedules/md5')]
+        self.assertEqual(len(md5_calls), 1)
+        request_body = md5_calls[0][1]['json']
+        station_ids_in_request = {entry['stationID'] for entry in request_body}
+        self.assertEqual(station_ids_in_request, {self.MAPPED_STATION})
+
+        self.assertFalse(
+            SDScheduleMD5.objects.filter(
+                epg_source=source,
+                station_id=self.UNMAPPED_STATION,
+            ).exists()
+        )
+
+        schedule_calls = [c for c in mock_post.call_args_list if c[0][0].endswith('/schedules')]
+        self.assertEqual(len(schedule_calls), 0)
+
+        source.refresh_from_db()
+        self.assertEqual(source.status, EPGSource.STATUS_SUCCESS)
+
+    @patch('apps.epg.tasks.SD_DAYS_TO_FETCH', 3)
+    @patch('apps.epg.tasks.send_epg_update')
+    @patch('apps.epg.tasks.requests.get')
+    @patch('apps.epg.tasks.requests.post')
+    def test_newly_mapped_station_fetches_despite_stale_cache(
+        self, mock_post, mock_get, mock_send_epg_update,
+    ):
+        from apps.epg.tasks import fetch_schedules_direct
+
+        source = self._make_sd_source()
+        mapped_epg = EPGData.objects.create(
+            tvg_id=self.MAPPED_STATION,
+            name='Mapped',
+            epg_source=source,
+        )
+        Channel.objects.create(name='Mapped Ch', epg_data=mapped_epg)
+
+        date_list = self._build_date_list(3)
+        today = date.today()
+        for i, ds in enumerate(date_list):
+            SDScheduleMD5.objects.create(
+                epg_source=source,
+                station_id=self.MAPPED_STATION,
+                date=today + timedelta(days=i),
+                md5=f'md5-{ds}',
+                last_modified=timezone.now(),
+            )
+
+        mock_get.side_effect = self._lineup_get_side_effect
+
+        schedule_payload = [{
+            'stationID': self.MAPPED_STATION,
+            'metadata': {'startDate': date_list[0], 'md5': 'md5-' + date_list[0], 'modified': '2026-06-11T00:00:00Z'},
+            'programs': [{
+                'programID': 'EP000000000001',
+                'airDateTime': f'{date_list[0]}T12:00:00Z',
+                'duration': 3600,
+                'md5': 'prog-md5-1',
+            }],
+        }]
+        program_payload = [{
+            'programID': 'EP000000000001',
+            'titles': [{'title120': 'Test Show'}],
+        }]
+
+        def post_side_effect(url, **kwargs):
+            if url.endswith('/token'):
+                return MagicMock(
+                    status_code=200,
+                    json=MagicMock(return_value={'code': 0, 'token': 'tok'}),
+                )
+            if url.endswith('/schedules/md5'):
+                return MagicMock(
+                    status_code=200,
+                    json=MagicMock(return_value={
+                        self.MAPPED_STATION: {
+                            ds: {'code': 0, 'md5': f'md5-{ds}', 'lastModified': '2026-06-11T00:00:00Z'}
+                            for ds in date_list
+                        },
+                    }),
+                )
+            if url.endswith('/schedules'):
+                return MagicMock(status_code=200, json=MagicMock(return_value=schedule_payload))
+            if url.endswith('/programs'):
+                return MagicMock(status_code=200, json=MagicMock(return_value=program_payload))
+            raise AssertionError(f'Unexpected POST URL: {url}')
+
+        mock_post.side_effect = post_side_effect
+
+        fetch_schedules_direct(source, force=True)
+
+        schedule_calls = [c for c in mock_post.call_args_list if c[0][0].endswith('/schedules')]
+        self.assertGreaterEqual(len(schedule_calls), 1)
+        self.assertEqual(
+            ProgramData.objects.filter(epg=mapped_epg).count(),
+            1,
+        )
+
+    @patch('apps.epg.tasks.SD_DAYS_TO_FETCH', 3)
+    @patch('apps.epg.tasks.send_epg_update')
+    @patch('apps.epg.tasks.requests.get')
+    @patch('apps.epg.tasks.requests.post')
+    def test_orphan_program_data_removed_on_post_refresh(
+        self, mock_post, mock_get, mock_send_epg_update,
+    ):
+        from apps.epg.tasks import fetch_schedules_direct
+
+        source = self._make_sd_source()
+        mapped_epg = EPGData.objects.create(
+            tvg_id=self.MAPPED_STATION,
+            name='Mapped',
+            epg_source=source,
+        )
+        orphan_epg = EPGData.objects.create(
+            tvg_id=self.UNMAPPED_STATION,
+            name='Orphan',
+            epg_source=source,
+        )
+        Channel.objects.create(name='Mapped Ch', epg_data=mapped_epg)
+
+        date_list = self._build_date_list(3)
+        self._seed_full_window_program_data(mapped_epg, days=3)
+
+        start = timezone.now()
+        ProgramData.objects.create(
+            epg=orphan_epg,
+            start_time=start,
+            end_time=start + timedelta(hours=1),
+            title='Orphan Show',
+            tvg_id=orphan_epg.tvg_id,
+        )
+
+        today = date.today()
+        for i, ds in enumerate(date_list):
+            SDScheduleMD5.objects.create(
+                epg_source=source,
+                station_id=self.MAPPED_STATION,
+                date=today + timedelta(days=i),
+                md5=f'md5-{ds}',
+                last_modified=timezone.now(),
+            )
+
+        mock_get.side_effect = self._lineup_get_side_effect
+
+        def post_side_effect(url, **kwargs):
+            if url.endswith('/token'):
+                return MagicMock(
+                    status_code=200,
+                    json=MagicMock(return_value={'code': 0, 'token': 'tok'}),
+                )
+            if url.endswith('/schedules/md5'):
+                return MagicMock(
+                    status_code=200,
+                    json=MagicMock(return_value={
+                        self.MAPPED_STATION: {
+                            ds: {'code': 0, 'md5': f'md5-{ds}', 'lastModified': '2026-06-11T00:00:00Z'}
+                            for ds in date_list
+                        },
+                    }),
+                )
+            raise AssertionError(f'Unexpected POST URL: {url}')
+
+        mock_post.side_effect = post_side_effect
+
+        fetch_schedules_direct(source, force=True)
+
+        self.assertFalse(ProgramData.objects.filter(epg=orphan_epg).exists())
+
+    def test_stale_program_md5_fetched_when_no_program_data(self):
+        programs_with_data = set()
+        needed = _sd_programs_needing_metadata(
+            {'EP0001'},
+            {'EP0001': 'cached-md5'},
+            {'EP0001': 'cached-md5'},
+            programs_with_data,
+        )
+        self.assertEqual(needed, {'EP0001'})
+
+    def test_shared_program_skips_metadata_when_cached(self):
+        needed = _sd_programs_needing_metadata(
+            {'EP0001'},
+            {'EP0001': 'cached-md5'},
+            {'EP0001': 'cached-md5'},
+            {'EP0001'},
+        )
+        self.assertEqual(needed, set())
+
+
 # ---------------------------------------------------------------------------
 # parse_schedules_direct_time tests
 # ---------------------------------------------------------------------------
@@ -298,17 +769,400 @@ class ParseSchedulesDirectTimeTests(TestCase):
             parse_schedules_direct_time('not-a-timestamp')
 
 
+# ---------------------------------------------------------------------------
+# dispatch_program_refresh_for_epg_ids tests
+# ---------------------------------------------------------------------------
+
+class SDDispatchProgramRefreshTests(TestCase):
+    """Bulk SD assignment should batch guide fetches above the threshold."""
+
+    STATION = '10001'
+
+    def _make_sd_source(self):
+        return EPGSource.objects.create(
+            name='SD Dispatch Test',
+            source_type='schedules_direct',
+            username='sduser',
+            password='sdpass',
+        )
+
+    def _make_xml_source(self):
+        return EPGSource.objects.create(
+            name='XML Dispatch Test',
+            source_type='xmltv',
+            url='http://example.com/epg.xml',
+        )
+
+    @patch('apps.epg.tasks.fetch_sd_mapped_guide_batch.delay')
+    @patch('apps.epg.tasks.parse_programs_for_tvg_id.delay')
+    def test_xmltv_still_uses_parse_programs_per_id(
+        self, mock_parse_delay, mock_batch_delay,
+    ):
+        from apps.epg.tasks import dispatch_program_refresh_for_epg_ids
+
+        xml_source = self._make_xml_source()
+        epg = EPGData.objects.create(
+            tvg_id='xml-1',
+            name='XML Channel',
+            epg_source=xml_source,
+        )
+
+        count = dispatch_program_refresh_for_epg_ids({epg.id})
+
+        self.assertEqual(count, 1)
+        mock_parse_delay.assert_called_once_with(epg.id)
+        mock_batch_delay.assert_not_called()
+
+    @patch('apps.epg.tasks.fetch_sd_mapped_guide_batch.delay')
+    @patch('apps.epg.tasks.parse_programs_for_tvg_id.delay')
+    def test_sd_below_threshold_uses_per_epg_tasks(
+        self, mock_parse_delay, mock_batch_delay,
+    ):
+        from apps.epg.tasks import dispatch_program_refresh_for_epg_ids
+
+        source = self._make_sd_source()
+        epgs = [
+            EPGData.objects.create(
+                tvg_id=f'{self.STATION}{i}',
+                name=f'Station {i}',
+                epg_source=source,
+            )
+            for i in range(2)
+        ]
+
+        count = dispatch_program_refresh_for_epg_ids({e.id for e in epgs})
+
+        self.assertEqual(count, 2)
+        self.assertEqual(mock_parse_delay.call_count, 2)
+        mock_batch_delay.assert_not_called()
+
+    @patch('apps.epg.tasks.fetch_sd_mapped_guide_batch.delay')
+    @patch('apps.epg.tasks.parse_programs_for_tvg_id.delay')
+    def test_sd_at_threshold_uses_batched_fetch(
+        self, mock_parse_delay, mock_batch_delay,
+    ):
+        from apps.epg.tasks import dispatch_program_refresh_for_epg_ids
+
+        source = self._make_sd_source()
+        epgs = [
+            EPGData.objects.create(
+                tvg_id=f'{self.STATION}{i}',
+                name=f'Station {i}',
+                epg_source=source,
+            )
+            for i in range(3)
+        ]
+
+        count = dispatch_program_refresh_for_epg_ids({e.id for e in epgs})
+
+        self.assertEqual(count, 1)
+        mock_batch_delay.assert_called_once_with(source.id)
+        mock_parse_delay.assert_not_called()
+
+    @patch('apps.epg.tasks.fetch_sd_mapped_guide_batch.delay')
+    @patch('apps.epg.tasks.parse_programs_for_tvg_id.delay')
+    def test_sd_skips_when_program_data_exists(
+        self, mock_parse_delay, mock_batch_delay,
+    ):
+        from apps.epg.tasks import dispatch_program_refresh_for_epg_ids
+
+        source = self._make_sd_source()
+        epg = EPGData.objects.create(
+            tvg_id=self.STATION,
+            name='Has Data',
+            epg_source=source,
+        )
+        start = timezone.now()
+        ProgramData.objects.create(
+            epg=epg,
+            start_time=start,
+            end_time=start + timedelta(hours=1),
+            title='Show',
+            tvg_id=epg.tvg_id,
+        )
+
+        count = dispatch_program_refresh_for_epg_ids({epg.id})
+
+        self.assertEqual(count, 0)
+        mock_parse_delay.assert_not_called()
+        mock_batch_delay.assert_not_called()
+
+
+class SDGuideFetchCoordinationTests(TestCase):
+    """Batch and single-EPG SD fetches coordinate via locks and deferred retries."""
+
+    STATION = '10001'
+
+    def _make_sd_source(self):
+        return EPGSource.objects.create(
+            name='SD Coordination',
+            source_type='schedules_direct',
+            username='sduser',
+            password='sdpass',
+        )
+
+    @patch('apps.epg.tasks.fetch_schedules_direct')
+    @patch('apps.epg.tasks.acquire_task_lock', return_value=False)
+    @patch('apps.epg.tasks.fetch_sd_mapped_guide_batch.apply_async')
+    def test_batch_fetch_defers_when_lock_held(
+        self, mock_apply_async, mock_acquire, mock_fetch,
+    ):
+        from apps.epg.tasks import (
+            fetch_sd_mapped_guide_batch,
+            SD_MAPPED_GUIDE_BATCH_DEFER_SECONDS,
+        )
+
+        source = self._make_sd_source()
+        result = fetch_sd_mapped_guide_batch(source.id)
+
+        self.assertEqual(result, 'Deferred - batch already in progress')
+        mock_apply_async.assert_called_once_with(
+            args=[source.id],
+            kwargs={'force': False, '_defer_retry': 1},
+            countdown=SD_MAPPED_GUIDE_BATCH_DEFER_SECONDS,
+        )
+        mock_fetch.assert_not_called()
+
+    @patch('apps.epg.tasks.fetch_schedules_direct')
+    @patch('apps.epg.tasks.acquire_task_lock', return_value=False)
+    @patch('apps.epg.tasks.fetch_sd_mapped_guide_batch.apply_async')
+    def test_batch_fetch_stops_after_max_defer_retries(
+        self, mock_apply_async, mock_acquire, mock_fetch,
+    ):
+        from apps.epg.tasks import fetch_sd_mapped_guide_batch
+
+        source = self._make_sd_source()
+        result = fetch_sd_mapped_guide_batch(source.id, _defer_retry=2)
+
+        self.assertEqual(result, 'Task already running')
+        mock_apply_async.assert_not_called()
+        mock_fetch.assert_not_called()
+
+    @patch('apps.epg.tasks.fetch_schedules_direct')
+    @patch('apps.epg.tasks.acquire_task_lock', return_value=True)
+    @patch('apps.epg.tasks.release_task_lock')
+    @patch('apps.epg.tasks.TaskLockRenewer')
+    @patch('apps.epg.tasks.is_task_lock_held', return_value=True)
+    @patch('apps.epg.tasks.fetch_sd_guide_for_epg.apply_async')
+    def test_single_epg_defers_while_batch_running(
+        self, mock_apply_async, mock_batch_held, mock_renewer,
+        mock_release, mock_acquire, mock_fetch,
+    ):
+        from apps.epg.tasks import (
+            fetch_sd_guide_for_epg,
+            SD_MAPPED_GUIDE_BATCH_DEFER_SECONDS,
+        )
+
+        source = self._make_sd_source()
+        epg = EPGData.objects.create(
+            tvg_id=self.STATION,
+            name='Deferred Station',
+            epg_source=source,
+        )
+
+        result = fetch_sd_guide_for_epg(epg.id)
+
+        self.assertEqual(result, 'Deferred - mapped batch in progress')
+        mock_apply_async.assert_called_once_with(
+            args=[epg.id],
+            kwargs={'force': False, '_defer_retry': 1},
+            countdown=SD_MAPPED_GUIDE_BATCH_DEFER_SECONDS,
+        )
+        mock_fetch.assert_not_called()
+        mock_acquire.assert_not_called()
+
+    @patch('apps.epg.tasks.fetch_schedules_direct')
+    @patch('apps.epg.tasks.acquire_task_lock', return_value=True)
+    @patch('apps.epg.tasks.release_task_lock')
+    @patch('apps.epg.tasks.TaskLockRenewer')
+    @patch('apps.epg.tasks.is_task_lock_held', return_value=True)
+    @patch('apps.epg.tasks.fetch_sd_guide_for_epg.apply_async')
+    def test_single_epg_proceeds_after_max_batch_deferrals(
+        self, mock_apply_async, mock_batch_held, mock_renewer,
+        mock_release, mock_acquire, mock_fetch,
+    ):
+        from apps.epg.tasks import fetch_sd_guide_for_epg
+
+        source = self._make_sd_source()
+        epg = EPGData.objects.create(
+            tvg_id=self.STATION,
+            name='Fallback Station',
+            epg_source=source,
+        )
+
+        result = fetch_sd_guide_for_epg(epg.id, _defer_retry=2)
+
+        self.assertEqual(result, 'SD guide fetch complete')
+        mock_apply_async.assert_not_called()
+        mock_fetch.assert_called_once()
+        mock_acquire.assert_called_once_with('parse_epg_programs', epg.id)
+
+
 # ---------------------------------------------------------------------------
 # Signal tests
 # ---------------------------------------------------------------------------
 
+class SDSingleEpgFetchTests(TestCase):
+    """Per-channel SD guide fetch on map (epg_id_only path)."""
+
+    MAPPED_STATION = '10001'
+
+    def _make_sd_source(self, updated_at=None):
+        source = EPGSource.objects.create(
+            name='SD Single EPG',
+            source_type='schedules_direct',
+            username='sduser',
+            password='sdpass',
+        )
+        if updated_at is not None:
+            EPGSource.objects.filter(id=source.id).update(updated_at=updated_at)
+            source.refresh_from_db()
+        return source
+
+    def _lineup_get_side_effect(self, url, **kwargs):
+        if url.endswith('/status'):
+            return MagicMock(
+                status_code=200,
+                json=MagicMock(return_value={'systemStatus': [{'status': 'Online'}]}),
+            )
+        if url.endswith('/lineups'):
+            return MagicMock(
+                status_code=200,
+                json=MagicMock(return_value={'lineups': [{'lineupID': 'USA-TEST-X'}]}),
+            )
+        raise AssertionError(f'Unexpected GET URL: {url}')
+
+    @patch('apps.epg.tasks.acquire_task_lock', return_value=True)
+    @patch('apps.epg.tasks.release_task_lock')
+    @patch('apps.epg.tasks.TaskLockRenewer')
+    def test_fetch_sd_guide_skips_when_program_data_exists(
+        self, mock_renewer, mock_release, mock_acquire,
+    ):
+        from apps.epg.tasks import fetch_sd_guide_for_epg
+
+        source = self._make_sd_source()
+        epg = EPGData.objects.create(
+            tvg_id=self.MAPPED_STATION,
+            name='Mapped',
+            epg_source=source,
+        )
+        start = timezone.now()
+        ProgramData.objects.create(
+            epg=epg,
+            start_time=start,
+            end_time=start + timedelta(hours=1),
+            title='Existing',
+            tvg_id=epg.tvg_id,
+        )
+
+        with patch('apps.epg.tasks.fetch_schedules_direct') as mock_fetch:
+            result = fetch_sd_guide_for_epg(epg.id)
+
+        self.assertEqual(result, 'Guide data already present')
+        mock_fetch.assert_not_called()
+
+    @patch('apps.epg.tasks.acquire_task_lock', return_value=True)
+    @patch('apps.epg.tasks.release_task_lock')
+    @patch('apps.epg.tasks.TaskLockRenewer')
+    def test_parse_programs_for_tvg_id_delegates_to_sd_fetch(
+        self, mock_renewer, mock_release, mock_acquire,
+    ):
+        from apps.epg.tasks import parse_programs_for_tvg_id
+
+        source = self._make_sd_source()
+        epg = EPGData.objects.create(
+            tvg_id=self.MAPPED_STATION,
+            name='Mapped',
+            epg_source=source,
+        )
+
+        with patch('apps.epg.tasks.fetch_sd_guide_for_epg', return_value='SD guide fetch complete') as mock_sd:
+            result = parse_programs_for_tvg_id(epg.id)
+
+        mock_sd.assert_called_once_with(epg.id, force=False)
+        self.assertEqual(result, 'SD guide fetch complete')
+
+    @patch('apps.epg.tasks.SD_DAYS_TO_FETCH', 3)
+    @patch('apps.epg.tasks.send_epg_update')
+    @patch('apps.epg.tasks.requests.get')
+    @patch('apps.epg.tasks.requests.post')
+    def test_single_epg_fetch_skips_lineup_sync_and_updated_at(
+        self, mock_post, mock_get, mock_send_epg_update,
+    ):
+        from apps.epg.tasks import fetch_schedules_direct
+
+        prior_updated = timezone.now() - timedelta(hours=1)
+        source = self._make_sd_source(updated_at=prior_updated)
+        epg = EPGData.objects.create(
+            tvg_id=self.MAPPED_STATION,
+            name='Mapped',
+            epg_source=source,
+        )
+        Channel.objects.create(name='Mapped Ch', epg_data=epg)
+
+        date_list = [
+            (date.today() + timedelta(days=i)).strftime('%Y-%m-%d')
+            for i in range(3)
+        ]
+        mock_get.side_effect = self._lineup_get_side_effect
+
+        schedule_payload = [{
+            'stationID': self.MAPPED_STATION,
+            'metadata': {'startDate': date_list[0], 'md5': 'md5-new', 'modified': '2026-06-11T00:00:00Z'},
+            'programs': [{
+                'programID': 'EP000000000001',
+                'airDateTime': f'{date_list[0]}T12:00:00Z',
+                'duration': 3600,
+                'md5': 'prog-md5-1',
+            }],
+        }]
+        program_payload = [{
+            'programID': 'EP000000000001',
+            'titles': [{'title120': 'Test Show'}],
+        }]
+
+        def post_side_effect(url, **kwargs):
+            if url.endswith('/token'):
+                return MagicMock(
+                    status_code=200,
+                    json=MagicMock(return_value={'code': 0, 'token': 'tok'}),
+                )
+            if url.endswith('/schedules/md5'):
+                return MagicMock(
+                    status_code=200,
+                    json=MagicMock(return_value={
+                        self.MAPPED_STATION: {
+                            ds: {'code': 0, 'md5': f'md5-{ds}', 'lastModified': '2026-06-11T00:00:00Z'}
+                            for ds in date_list
+                        },
+                    }),
+                )
+            if url.endswith('/schedules'):
+                return MagicMock(status_code=200, json=MagicMock(return_value=schedule_payload))
+            if url.endswith('/programs'):
+                return MagicMock(status_code=200, json=MagicMock(return_value=program_payload))
+            raise AssertionError(f'Unexpected POST URL: {url}')
+
+        mock_post.side_effect = post_side_effect
+
+        fetch_schedules_direct(source, epg_id_only=epg.id)
+
+        lineup_detail_calls = [
+            c for c in mock_get.call_args_list
+            if '/lineups/' in c[0][0] and not c[0][0].endswith('/lineups')
+        ]
+        self.assertEqual(lineup_detail_calls, [])
+
+        source.refresh_from_db()
+        self.assertEqual(source.updated_at, prior_updated)
+        self.assertEqual(ProgramData.objects.filter(epg=epg).count(), 1)
+
+
 class SDSourceSignalTests(TestCase):
-    """SD EPG sources must skip the XMLTV program parser signal."""
+    """SD EPG sources queue per-EPG guide fetch when a channel is mapped."""
 
     @patch('apps.channels.signals.parse_programs_for_tvg_id')
-    def test_sd_source_skips_xmltv_parse_on_channel_create(self, mock_parse):
-        """Creating a channel linked to an SD EPG source must not trigger
-        the XMLTV program parser — SD data is handled by fetch_schedules_direct."""
+    def test_sd_source_queues_guide_fetch_on_channel_create(self, mock_parse):
         from apps.epg.models import EPGData
         from apps.channels.models import Channel
 
@@ -329,7 +1183,7 @@ class SDSourceSignalTests(TestCase):
             epg_data=epg_data,
         )
 
-        mock_parse.delay.assert_not_called()
+        mock_parse.delay.assert_called_once_with(epg_data.id)
 
 
 # ---------------------------------------------------------------------------
diff --git a/apps/m3u/api_urls.py b/apps/m3u/api_urls.py
index 6a80a1fe..6b007447 100644
--- a/apps/m3u/api_urls.py
+++ b/apps/m3u/api_urls.py
@@ -16,12 +16,12 @@ app_name = "m3u"
 router = DefaultRouter()
 router.register(r"accounts", M3UAccountViewSet, basename="m3u-account")
 router.register(
-    r"accounts\/(?P<account_id>\d+)\/profiles",
+    r"accounts/(?P<account_id>\d+)/profiles",
     M3UAccountProfileViewSet,
     basename="m3u-account-profiles",
 )
 router.register(
-    r"accounts\/(?P<account_id>\d+)\/filters",
+    r"accounts/(?P<account_id>\d+)/filters",
     M3UFilterViewSet,
     basename="m3u-filters",
 )
diff --git a/apps/m3u/api_views.py b/apps/m3u/api_views.py
index a49ddd6f..1117a226 100644
--- a/apps/m3u/api_views.py
+++ b/apps/m3u/api_views.py
@@ -23,7 +23,7 @@ logger = logging.getLogger(__name__)
 
 from .models import M3UAccount, M3UFilter, ServerGroup, M3UAccountProfile
 from core.models import UserAgent
-from core.utils import safe_upload_path
+from core.utils import safe_upload_path, ensure_custom_properties_dict
 from apps.channels.models import ChannelGroupM3UAccount
 from core.serializers import UserAgentSerializer
 from apps.vod.models import M3UVODCategoryRelation
@@ -536,7 +536,9 @@ class M3UAccountViewSet(viewsets.ModelViewSet):
                         auto_channel_sync=setting.get("auto_channel_sync", False),
                         auto_sync_channel_start=setting.get("auto_sync_channel_start"),
                         auto_sync_channel_end=setting.get("auto_sync_channel_end"),
-                        custom_properties=setting.get("custom_properties", {}),
+                        custom_properties=ensure_custom_properties_dict(
+                            setting.get("custom_properties")
+                        ),
                     )
                     for setting in group_settings
                     if setting.get("channel_group")
@@ -561,7 +563,9 @@ class M3UAccountViewSet(viewsets.ModelViewSet):
                         category_id=setting["id"],
                         m3u_account=account,
                         enabled=setting.get("enabled", True),
-                        custom_properties=setting.get("custom_properties", {}),
+                        custom_properties=ensure_custom_properties_dict(
+                            setting.get("custom_properties")
+                        ),
                     )
                     for setting in category_settings
                     if setting.get("id")
diff --git a/apps/m3u/connection_pool.py b/apps/m3u/connection_pool.py
new file mode 100644
index 00000000..375714ee
--- /dev/null
+++ b/apps/m3u/connection_pool.py
@@ -0,0 +1,323 @@
+"""
+Shared connection pool enforcement for M3U accounts in the same ServerGroup.
+
+Profile selection rotates across M3UAccountProfile rows using each profile's own
+Redis counter (the pre-pool behavior). When an account belongs to a ServerGroup, a credential-scoped counter is checked on reserve/release
+so accounts sharing the same provider login share one limit without blocking
+unrelated logins on the same group. Account profiles with max_streams=0 skip
+credential enforcement for that profile.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import logging
+import re
+from typing import Literal, Optional, Tuple
+
+logger = logging.getLogger(__name__)
+
+ReserveFailureReason = Literal["profile_full", "credential_full"]
+
+PROFILE_CONNECTIONS_KEY = "profile_connections:{profile_id}"
+PROFILE_CREDENTIAL_RELEASE_KEY = "profile_credential_release:{profile_id}"
+SERVER_GROUP_CONNECTIONS_KEY = "server_group_connections:{group_id}:{fingerprint}"
+
+_XC_URL_CREDENTIALS_RE = re.compile(
+    r"/(?:live|movie|series)/([^/]+)/([^/]+)/",
+    re.IGNORECASE,
+)
+
+
+def profile_connections_key(profile_id: int) -> str:
+    return PROFILE_CONNECTIONS_KEY.format(profile_id=profile_id)
+
+
+def profile_credential_release_key(profile_id: int) -> str:
+    """Redis key storing the credential counter to release when the profile row is gone."""
+    return PROFILE_CREDENTIAL_RELEASE_KEY.format(profile_id=profile_id)
+
+
+def server_group_connections_key(group_id: int, fingerprint: str) -> str:
+    """Redis key for per-credential usage within a ServerGroup."""
+    return SERVER_GROUP_CONNECTIONS_KEY.format(
+        group_id=group_id,
+        fingerprint=fingerprint[:16],
+    )
+
+
+def compute_credential_fingerprint(username: str, password: str) -> Optional[str]:
+    """Return a stable hash for grouping accounts with the same IPTV login."""
+    if not username or not password:
+        return None
+    normalized = f"{username.strip().lower()}\0{password.strip()}"
+    return hashlib.sha256(normalized.encode("utf-8")).hexdigest()
+
+
+def extract_credentials_from_stream_url(url: str) -> Tuple[Optional[str], Optional[str]]:
+    """Parse username/password embedded in an Xtream-style stream URL."""
+    if not url:
+        return None, None
+    match = _XC_URL_CREDENTIALS_RE.search(url)
+    if not match:
+        return None, None
+    return match.group(1), match.group(2)
+
+
+def _fingerprint_from_profile_stream_url(profile) -> Optional[str]:
+    """STD/M3U: fingerprint from a sample stream URL after profile rewrite."""
+    from apps.channels.models import Stream
+
+    sample_url = (
+        Stream.objects.filter(m3u_account=profile.m3u_account)
+        .exclude(url="")
+        .values_list("url", flat=True)
+        .first()
+    )
+    if not sample_url:
+        return None
+
+    try:
+        from apps.proxy.live_proxy.url_utils import transform_url
+
+        transformed = transform_url(
+            sample_url,
+            profile.search_pattern or "",
+            profile.replace_pattern or "",
+        )
+        url_user, url_pass = extract_credentials_from_stream_url(
+            transformed or sample_url
+        )
+        return compute_credential_fingerprint(url_user or "", url_pass or "")
+    except Exception as exc:
+        logger.debug(
+            "Could not derive profile %s fingerprint from stream URL: %s",
+            profile.pk,
+            exc,
+        )
+        return None
+
+
+def get_profile_credential_fingerprint(profile) -> Optional[str]:
+    """Fingerprint for credentials this profile uses at playback time."""
+    m3u_account = profile.m3u_account
+
+    if m3u_account.account_type == "XC":
+        try:
+            from apps.m3u.tasks import get_transformed_credentials
+
+            _url, username, password = get_transformed_credentials(m3u_account, profile)
+            fingerprint = compute_credential_fingerprint(username or "", password or "")
+            if fingerprint:
+                return fingerprint
+        except Exception as exc:
+            logger.debug(
+                "Could not resolve transformed credentials for profile %s: %s",
+                profile.pk,
+                exc,
+            )
+
+    fingerprint = _fingerprint_from_profile_stream_url(profile)
+    if fingerprint:
+        return fingerprint
+
+    return compute_credential_fingerprint(
+        m3u_account.username or "",
+        m3u_account.password or "",
+    )
+
+
+def get_enforced_server_group_for_profile(profile):
+    """Return the ServerGroup for credential pooling when the account is assigned to one."""
+    group = profile.m3u_account.server_group
+    if group:
+        return group
+    return None
+
+
+def _credential_counter_key(profile, group) -> Optional[str]:
+    fingerprint = get_profile_credential_fingerprint(profile)
+    if not fingerprint:
+        return None
+    return server_group_connections_key(group.id, fingerprint)
+
+
+def get_profile_connection_count(profile, redis_client) -> int:
+    return int(redis_client.get(profile_connections_key(profile.id)) or 0)
+
+
+def get_credential_connection_count(profile, redis_client) -> int:
+    group = get_enforced_server_group_for_profile(profile)
+    if not group:
+        return 0
+    cred_key = _credential_counter_key(profile, group)
+    if not cred_key:
+        return 0
+    return int(redis_client.get(cred_key) or 0)
+
+
+def profile_has_capacity_for_selection(profile, redis_client) -> bool:
+    """Per-profile capacity check used when rotating across profiles on one account."""
+    if profile.max_streams == 0:
+        return True
+    return get_profile_connection_count(profile, redis_client) < profile.max_streams
+
+
+def group_has_capacity_for_profile(profile, redis_client) -> bool:
+    # Profiles with max_streams=0 skip credential enforcement entirely. An unlimited
+    # profile in a pooled group can still stream while other accounts share the login.
+    group = get_enforced_server_group_for_profile(profile)
+    if not group or profile.max_streams == 0:
+        return True
+    cred_key = _credential_counter_key(profile, group)
+    if not cred_key:
+        return True
+    return int(redis_client.get(cred_key) or 0) < profile.max_streams
+
+
+def pool_has_capacity_for_profile(profile, redis_client) -> bool:
+    """Non-mutating check before reserve: profile slot and credential slot if applicable."""
+    return profile_has_capacity_for_selection(profile, redis_client) and group_has_capacity_for_profile(
+        profile, redis_client
+    )
+
+
+def profile_available_for_channel_switch(
+    profile, redis_client, *, channel_already_on_profile: bool
+) -> bool:
+    """
+    Non-mutating capacity check when selecting a profile for an in-flight channel.
+
+    If the channel already holds this profile's slots, skip re-checking capacity.
+    """
+    if channel_already_on_profile:
+        return True
+    return pool_has_capacity_for_profile(profile, redis_client)
+
+
+def move_credential_slot_on_profile_switch(
+    old_profile, new_profile, redis_client
+) -> bool:
+    """
+    Move the shared credential counter when switching to a different provider login.
+
+    Profile counters are managed separately by Channel.update_stream_profile().
+    Returns False when the new profile's credential pool is full.
+    """
+    old_fp = get_profile_credential_fingerprint(old_profile)
+    new_fp = get_profile_credential_fingerprint(new_profile)
+    if old_fp == new_fp:
+        return True
+
+    _release_credential_slot_by_profile_id(old_profile.id, redis_client)
+
+    cred_reserved, cred_key = _reserve_server_group_slot_for_profile(
+        new_profile, redis_client
+    )
+    if not cred_reserved:
+        restore_reserved, restore_key = _reserve_server_group_slot_for_profile(
+            old_profile, redis_client
+        )
+        if restore_reserved and restore_key:
+            _remember_credential_release_key(
+                old_profile.id, restore_key, redis_client
+            )
+        return False
+
+    if cred_key:
+        _remember_credential_release_key(new_profile.id, cred_key, redis_client)
+    return True
+
+
+def _safe_decr(redis_client, key: str) -> None:
+    current = int(redis_client.get(key) or 0)
+    if current <= 0:
+        return
+    new_count = redis_client.decr(key)
+    if new_count < 0:
+        redis_client.set(key, 0)
+
+
+def _remember_credential_release_key(
+    profile_id: int, cred_key: str, redis_client
+) -> None:
+    redis_client.set(profile_credential_release_key(profile_id), cred_key)
+
+
+def _release_credential_slot_by_profile_id(profile_id: int, redis_client) -> bool:
+    """Release a reserved credential counter using the key stored at reserve time."""
+    release_key = profile_credential_release_key(profile_id)
+    cred_key = redis_client.get(release_key)
+    if not cred_key:
+        return False
+
+    if isinstance(cred_key, bytes):
+        cred_key = cred_key.decode()
+    _safe_decr(redis_client, cred_key)
+    redis_client.delete(release_key)
+    return True
+
+
+def _reserve_server_group_slot_for_profile(
+    profile, redis_client
+) -> Tuple[bool, Optional[str]]:
+    group = get_enforced_server_group_for_profile(profile)
+    if not group or profile.max_streams == 0:
+        return True, None
+
+    cred_key = _credential_counter_key(profile, group)
+    if not cred_key:
+        return True, None
+
+    cred_count = redis_client.incr(cred_key)
+    if cred_count <= profile.max_streams:
+        return True, cred_key
+
+    redis_client.decr(cred_key)
+    return False, None
+
+
+def reserve_profile_slot(
+    profile, redis_client
+) -> Tuple[bool, int, Optional[ReserveFailureReason]]:
+    """
+    Atomically reserve profile + optional credential slots (INCR-first).
+
+    Returns (reserved, profile_count_after_attempt, failure_reason).
+    failure_reason is set when reserved is False.
+    """
+    profile_key = profile_connections_key(profile.id)
+    profile_count = 0
+
+    if profile.max_streams > 0:
+        profile_count = redis_client.incr(profile_key)
+        if profile_count > profile.max_streams:
+            redis_client.decr(profile_key)
+            return False, profile_count - 1, "profile_full"
+
+    cred_reserved, cred_key = _reserve_server_group_slot_for_profile(
+        profile, redis_client
+    )
+    if not cred_reserved:
+        if profile.max_streams > 0:
+            redis_client.decr(profile_key)
+        return (
+            False,
+            profile_count - 1 if profile.max_streams > 0 else 0,
+            "credential_full",
+        )
+
+    if cred_key:
+        _remember_credential_release_key(profile.id, cred_key, redis_client)
+
+    return True, profile_count, None
+
+
+def release_profile_slot(profile_id: int, redis_client) -> None:
+    """Release profile and shared credential slots after a stream end."""
+    _release_credential_slot_by_profile_id(profile_id, redis_client)
+
+    profile_key = profile_connections_key(profile_id)
+    current = int(redis_client.get(profile_key) or 0)
+    if current > 0:
+        redis_client.decr(profile_key)
diff --git a/apps/m3u/forms.py b/apps/m3u/forms.py
index cf6586c3..af4d6072 100644
--- a/apps/m3u/forms.py
+++ b/apps/m3u/forms.py
@@ -1,6 +1,7 @@
 # apps/m3u/forms.py
 from django import forms
 from .models import M3UAccount, M3UFilter
+from core.utils import ensure_custom_properties_dict
 import re
 
 class M3UAccountForm(forms.ModelForm):
@@ -28,7 +29,9 @@ class M3UAccountForm(forms.ModelForm):
 
         # Set initial value for enable_vod from custom_properties
         if self.instance and self.instance.custom_properties:
-            custom_props = self.instance.custom_properties or {}
+            custom_props = self.instance.custom_properties
+            if not isinstance(custom_props, dict):
+                custom_props = ensure_custom_properties_dict(custom_props)
             self.fields['enable_vod'].initial = custom_props.get('enable_vod', False)
 
     def save(self, commit=True):
@@ -37,8 +40,9 @@ class M3UAccountForm(forms.ModelForm):
         # Handle enable_vod field
         enable_vod = self.cleaned_data.get('enable_vod', False)
 
-        # Parse existing custom_properties
         custom_props = instance.custom_properties or {}
+        if not isinstance(custom_props, dict):
+            custom_props = ensure_custom_properties_dict(custom_props)
 
         # Update VOD preference
         custom_props['enable_vod'] = enable_vod
diff --git a/apps/m3u/models.py b/apps/m3u/models.py
index 6fc48bec..7d4fe65a 100644
--- a/apps/m3u/models.py
+++ b/apps/m3u/models.py
@@ -7,6 +7,7 @@ from django.dispatch import receiver
 from apps.channels.models import StreamProfile
 from django_celery_beat.models import PeriodicTask
 from core.models import CoreSettings, UserAgent
+from core.utils import custom_properties_as_dict
 
 CUSTOM_M3U_ACCOUNT_NAME = "custom"
 
@@ -124,6 +125,11 @@ class M3UAccount(models.Model):
         return user_agent
 
     def save(self, *args, **kwargs):
+        if self.custom_properties is not None and not isinstance(
+            self.custom_properties, dict
+        ):
+            self.custom_properties = custom_properties_as_dict(self.custom_properties)
+
         # Prevent auto_now behavior by handling updated_at manually
         if "update_fields" in kwargs and "updated_at" not in kwargs["update_fields"]:
             # Don't modify updated_at for regular updates
@@ -194,7 +200,13 @@ class M3UFilter(models.Model):
 
 
 class ServerGroup(models.Model):
-    """Represents a logical grouping of servers or channels."""
+    """
+    Groups M3U accounts that share provider credentials.
+
+    Accounts assigned to the same server group share credential-scoped connection
+    counters when their logins match. Limits come from each account profile's
+    max_streams, not from the group itself.
+    """
 
     name = models.CharField(
         max_length=100, unique=True, help_text="Unique name for this server group."
@@ -257,6 +269,11 @@ class M3UAccountProfile(models.Model):
     def save(self, *args, **kwargs):
         """Auto-sync exp_date from custom_properties for XC accounts on every save.
         For non-XC accounts, exp_date is set directly and left untouched here."""
+        if self.custom_properties is not None and not isinstance(
+            self.custom_properties, dict
+        ):
+            self.custom_properties = custom_properties_as_dict(self.custom_properties)
+
         parsed = self._parse_exp_date_from_custom_properties()
         if parsed is not None:
             # XC account with exp_date in custom_properties — always sync
diff --git a/apps/m3u/serializers.py b/apps/m3u/serializers.py
index 485a3687..c1dc6f92 100644
--- a/apps/m3u/serializers.py
+++ b/apps/m3u/serializers.py
@@ -1,4 +1,4 @@
-from core.utils import validate_flexible_url
+from core.utils import validate_flexible_url, ensure_custom_properties_dict
 from rest_framework import serializers, status
 from rest_framework.response import Response
 from .models import M3UAccount, M3UFilter, ServerGroup, M3UAccountProfile
@@ -270,11 +270,15 @@ class M3UAccountSerializer(serializers.ModelSerializer):
         # overwrite their corresponding keys; clients should set those via
         # the typed top-level fields rather than the custom_properties
         # payload.
-        incoming_custom = validated_data.get("custom_properties") or {}
-        custom_props = {
-            **(instance.custom_properties or {}),
-            **incoming_custom,
-        }
+        incoming_custom = {}
+        if "custom_properties" in validated_data:
+            incoming_custom = validated_data["custom_properties"] or {}
+            if not isinstance(incoming_custom, dict):
+                incoming_custom = ensure_custom_properties_dict(incoming_custom)
+        existing_custom = instance.custom_properties or {}
+        if not isinstance(existing_custom, dict):
+            existing_custom = ensure_custom_properties_dict(existing_custom)
+        custom_props = {**existing_custom, **incoming_custom}
 
         if enable_vod is not None:
             custom_props["enable_vod"] = enable_vod
@@ -346,7 +350,9 @@ class M3UAccountSerializer(serializers.ModelSerializer):
         auto_enable_new_groups_series = validated_data.pop("auto_enable_new_groups_series", True)
 
         # Parse existing custom_properties or create new
-        custom_props = validated_data.get("custom_properties", {})
+        custom_props = validated_data.get("custom_properties") or {}
+        if not isinstance(custom_props, dict):
+            custom_props = ensure_custom_properties_dict(custom_props)
 
         # Set preferences (default to True for auto_enable_new_groups)
         custom_props["enable_vod"] = enable_vod
diff --git a/apps/m3u/tasks.py b/apps/m3u/tasks.py
index 3b504ebf..462f45db 100644
--- a/apps/m3u/tasks.py
+++ b/apps/m3u/tasks.py
@@ -7,29 +7,23 @@ import os
 import gc
 import gzip, zipfile
 from concurrent.futures import ThreadPoolExecutor, as_completed
-from celery.app.control import Inspect
-from celery.result import AsyncResult
-from celery import shared_task, current_app, group
+from celery import shared_task
 from django.conf import settings
-from django.core.cache import cache
 from django.db import models, transaction
 from .models import M3UAccount
 from apps.channels.models import Stream, ChannelGroup, ChannelGroupM3UAccount
-from asgiref.sync import async_to_sync
-from channels.layers import get_channel_layer
 from django.utils import timezone
 import time
 import json
 from core.utils import (
-    RedisClient,
     acquire_task_lock,
     release_task_lock,
     TaskLockRenewer,
     natural_sort_key,
     log_system_event,
+    ensure_custom_properties_dict,
 )
 from core.models import CoreSettings, UserAgent
-from asgiref.sync import async_to_sync
 from core.xtream_codes import Client as XCClient
 from core.utils import send_websocket_update
 from .utils import normalize_stream_url
@@ -39,6 +33,104 @@ logger = logging.getLogger(__name__)
 BATCH_SIZE = 1500  # Optimized batch size for threading
 m3u_dir = os.path.join(settings.MEDIA_ROOT, "cached_m3u")
 
+_NON_TERMINAL_REFRESH_STATUSES = frozenset({
+    M3UAccount.Status.FETCHING,
+    M3UAccount.Status.PARSING,
+})
+
+
+def _release_task_db_connection():
+    """Return the Celery worker's DB connection to a clean state after ORM errors."""
+    from django.db import close_old_connections
+    close_old_connections()
+
+
+def _db_query_with_retry(fn, *, label="DB query", max_retries=2):
+    """
+    Run an ORM read with one connection reset + retry on transient failures.
+
+    Poisoned Celery worker connections often surface as OperationalError or as
+    ``IndexError: list index out of range`` inside Django's row converters.
+    """
+    from django.db import InterfaceError, OperationalError
+
+    transient_errors = (OperationalError, InterfaceError, IndexError)
+    for attempt in range(max_retries):
+        try:
+            return fn()
+        except transient_errors as exc:
+            if attempt + 1 >= max_retries:
+                raise
+            logger.warning(
+                "%s failed (%s), resetting DB connection (%s/%s)",
+                label,
+                exc,
+                attempt + 1,
+                max_retries,
+            )
+            _release_task_db_connection()
+
+
+def _get_active_m3u_account(account_id):
+    return _db_query_with_retry(
+        lambda: M3UAccount.objects.get(id=account_id, is_active=True),
+        label=f"load active M3U account {account_id}",
+    )
+
+
+def _set_m3u_account_status(
+    account_id,
+    status,
+    last_message=None,
+    *,
+    notify_error=False,
+    ws_action="parsing",
+    ws_error=None,
+):
+    """Update account status using a fresh connection (safe after DB failures)."""
+    _release_task_db_connection()
+    update = {"status": status}
+    if last_message is not None:
+        update["last_message"] = last_message
+    try:
+        M3UAccount.objects.filter(id=account_id).update(**update)
+        if notify_error:
+            send_m3u_update(
+                account_id,
+                ws_action,
+                100,
+                status="error",
+                error=ws_error or last_message,
+            )
+    except Exception as e:
+        logger.error(
+            f"Failed to set account {account_id} status to {status}: {e}"
+        )
+
+
+def _ensure_m3u_refresh_terminal_status(account_id):
+    """Mark refresh as failed when the task exits while still in progress."""
+    _release_task_db_connection()
+    try:
+        current_status = (
+            M3UAccount.objects.filter(id=account_id)
+            .values_list("status", flat=True)
+            .first()
+        )
+        if current_status in _NON_TERMINAL_REFRESH_STATUSES:
+            message = "Refresh did not complete successfully"
+            M3UAccount.objects.filter(id=account_id).update(
+                status=M3UAccount.Status.ERROR,
+                last_message=message,
+            )
+            send_m3u_update(
+                account_id, "parsing", 100, status="error", error=message
+            )
+    except Exception as e:
+        logger.debug(
+            f"Could not verify terminal refresh status for account {account_id}: {e}"
+        )
+
 _EXTINF_ATTR_RE = re.compile(r'([^\s=]+)\s*=\s*(["\'])(.*?)\2')
 
 
@@ -630,7 +722,7 @@ def process_groups(account, groups, scan_start_time=None):
     logger.info(f"Currently {len(existing_groups)} existing groups")
 
     # Check if we should auto-enable new groups based on account settings
-    account_custom_props = account.custom_properties or {}
+    account_custom_props = ensure_custom_properties_dict(account.custom_properties)
     auto_enable_new_groups_live = account_custom_props.get("auto_enable_new_groups_live", True)
 
     # Separate existing groups from groups that need to be created
@@ -673,7 +765,9 @@ def process_groups(account, groups, scan_start_time=None):
             existing_rel = existing_relationships[group.name]
 
             # Get existing custom properties (now JSONB, no need to parse)
-            existing_custom_props = existing_rel.custom_properties or {}
+            existing_custom_props = ensure_custom_properties_dict(
+                existing_rel.custom_properties
+            )
 
             # Get the new xc_id from groups data
             new_xc_id = custom_props.get("xc_id")
@@ -696,6 +790,8 @@ def process_groups(account, groups, scan_start_time=None):
                 logger.debug(f"Updated xc_id for group '{group.name}' from '{existing_xc_id}' to '{new_xc_id}' - account {account.id}")
             else:
                 # Update last_seen even if xc_id hasn't changed
+                if isinstance(existing_rel.custom_properties, str):
+                    existing_rel.custom_properties = existing_custom_props
                 existing_rel.last_seen = scan_start_time
                 existing_rel.is_stale = False
                 relations_to_update.append(existing_rel)
@@ -790,6 +886,7 @@ def collect_xc_streams(account_id, enabled_groups):
     """Collect all XC streams in a single API call and filter by enabled groups."""
     account = M3UAccount.objects.get(id=account_id)
     all_streams = []
+    filtered_count = 0
 
     # Create a mapping from category_id to group info for filtering
     enabled_category_ids = {}
@@ -819,7 +916,6 @@ def collect_xc_streams(account_id, enabled_groups):
             logger.info(f"Retrieved {len(all_xc_streams)} total live streams from provider")
 
             # Filter streams based on enabled categories
-            filtered_count = 0
             for stream in all_xc_streams:
                 # Fall back to a generated name if the provider returns null/empty
                 stream_name = stream.get("name") or f"{account.name} - {stream.get('stream_id', 'Unknown')}"
@@ -862,11 +958,17 @@ def collect_xc_streams(account_id, enabled_groups):
                     all_streams.append(stream_data)
                     filtered_count += 1
 
+            # Drop the full provider catalog before returning; only filtered rows are needed.
+            del all_xc_streams
+            gc.collect()
+
     except Exception as e:
         logger.error(f"Failed to fetch XC streams: {str(e)}")
         return []
 
-    logger.info(f"Filtered {filtered_count} streams from {len(enabled_category_ids)} enabled categories")
+    logger.info(
+        f"Filtered {filtered_count} streams from {len(enabled_category_ids)} enabled categories"
+    )
     return all_streams
 
 def process_xc_category_direct(account_id, batch, groups, hash_keys):
@@ -1270,6 +1372,7 @@ def process_m3u_batch_direct(account_id, batch, groups, hash_keys):
 
     # Free batch data structures (reference-counted deallocation)
     del streams_to_create, streams_to_update, stream_hashes, existing_streams
+    gc.collect()
 
     return retval
 
@@ -1716,70 +1819,36 @@ def _pick_target_number(
     fixed_cursor,
     fallback_start,
     end_number=None,
-    range_start=None,
 ):
     """
-    Return the channel number a given stream should claim under the group's
-    numbering mode, or None if the configured range is exhausted.
+    Return the channel number a stream should claim under the group's numbering
+    mode, or None if the range is exhausted. Shared by the renumber and create
+    passes. Each mode reads only the fields its UI exposes:
 
-    Shared by the existing-channel renumber pass and the new-channel create
-    pass so both honor identical mode semantics: provider-supplied number
-    when available and free, otherwise fall back; or always next-available;
-    or fixed-cursor sequential.
-
-    `range_start`, when provided, is the inclusive lower bound for the
-    group's configured numbering range. Provider-supplied numbers below
-    this bound fall back to the next-available picker so freshly-created
-    channels never land outside the configured range.
+    - provider: the provider number is authoritative and used as-is when free.
+      Start (`channel_numbering_fallback`) and End bound only the fallback for
+      streams with no provider number; `auto_sync_channel_start` does not apply.
+    - next_available: lowest free number from 1; End does not apply (its UI has
+      no range, so a stale End must not cap it).
+    - fixed: sequential from the cursor, bounded by End.
     """
     if mode == "provider":
         chno = stream.stream_chno
-        if (
-            chno is not None
-            and chno not in used_numbers
-            and (range_start is None or chno >= range_start)
-            and (end_number is None or chno <= end_number)
-        ):
+        if chno is not None and chno not in used_numbers:
             return chno
-        # No usable provider number: walk from fallback_start, bumped up
-        # to range_start when set so the fallback never lands below the
-        # configured range.
-        effective_start = (
-            max(fallback_start, range_start)
-            if range_start is not None
-            else fallback_start
-        )
-        return _next_available_number(used_numbers, effective_start, end=end_number)
+        # No usable provider number: fall back into the configured range.
+        return _next_available_number(used_numbers, fallback_start, end=end_number)
     if mode == "next_available":
-        return _next_available_number(used_numbers, 1, end=end_number)
+        return _next_available_number(used_numbers, 1)
     return _next_available_number(used_numbers, fixed_cursor, end=end_number)
 
 
-def _custom_properties_as_dict(value):
-    """
-    Normalize a JSONField-backed custom_properties value into a dict.
-
-    Historical data has rows where the field holds a JSON-encoded string
-    instead of a dict. Django's JSONField serializes whatever it gets, so
-    `.get()` on one of those rows raises AttributeError and aborts the
-    entire sync. Treat string values as JSON to parse, and fall back to an
-    empty dict for anything that isn't a dict after parsing.
-    """
-    import json
-
-    if isinstance(value, dict):
-        return value
-    if isinstance(value, str):
-        try:
-            parsed = json.loads(value)
-        except (ValueError, TypeError):
-            logger.warning(
-                "custom_properties stored as non-JSON string; ignoring: %r",
-                value[:100],
-            )
-            return {}
-        return parsed if isinstance(parsed, dict) else {}
-    return {}
+def _range_exhausted_error(mode, start_number, end_number, fallback_start):
+    """User-facing range text for RANGE_EXHAUSTED failures."""
+    range_start = (
+        int(fallback_start) if mode == "provider" else int(start_number)
+    )
+    return f"Channel number range {range_start}-{int(end_number)} is full"
 
 
 def _classify_sync_failure(exc):
@@ -1890,7 +1959,7 @@ def sync_auto_channels(account_id, scan_start_time=None):
             custom_epg_id = None  # New option: select specific EPG source (takes priority over force_dummy_epg)
             channel_numbering_mode = "fixed"  # Default mode
             channel_numbering_fallback = 1  # Default fallback for provider mode
-            group_custom_props = _custom_properties_as_dict(
+            group_custom_props = ensure_custom_properties_dict(
                 group_relation.custom_properties
             )
             if group_custom_props:
@@ -2253,7 +2322,6 @@ def sync_auto_channels(account_id, scan_start_time=None):
                         temp_channel_number,
                         channel_numbering_fallback,
                         end_number=end_number,
-                        range_start=start_number,
                     )
 
                     # Range exhausted: leave the channel at its existing
@@ -2290,17 +2358,16 @@ def sync_auto_channels(account_id, scan_start_time=None):
                     f"Renumbered {len(channels_to_renumber)} channels to maintain sort order"
                 )
 
-            # When the group's configured range is narrower than its existing
-            # channels span, any non-hidden auto-created channel whose number
-            # falls outside [start, end] gets deleted. The new-channel
-            # creation loop below picks up the freed stream and re-creates
-            # the channel at a slot inside the new range, so the net user
-            # outcome is a renumber, not a failure. Counted in
-            # channels_deleted; the replacement counts in channels_created.
-            # Hidden channels are preserved. Runs BEFORE new-channel creation
-            # so slots freed by the deletions are available to incoming
-            # streams.
-            if end_number is not None:
+            # Range enforcement runs in fixed mode only: it is the one mode with
+            # a user-set [start, end]. Provider numbers are authoritative and
+            # next_available has no range, so their channels are never deleted
+            # for falling outside start/end.
+            #
+            # Channels outside the range are deleted (hidden ones preserved);
+            # the creation loop below re-adds the freed streams inside the range,
+            # so the net effect is a renumber, not a failure. Runs first so the
+            # freed slots are available.
+            if end_number is not None and channel_numbering_mode == "fixed":
                 overflow_delete_ids = []
                 for stream_id, ch in list(existing_channel_map.items()):
                     if ch.hidden_from_output:
@@ -2461,7 +2528,6 @@ def sync_auto_channels(account_id, scan_start_time=None):
                             current_channel_number,
                             channel_numbering_fallback,
                             end_number=end_number,
-                            range_start=start_number,
                         )
 
                         if target_number is None:
@@ -2472,9 +2538,11 @@ def sync_auto_channels(account_id, scan_start_time=None):
                                     "stream_id": stream.id,
                                     "group": channel_group.name,
                                     "reason": "RANGE_EXHAUSTED",
-                                    "error": (
-                                        f"Channel number range "
-                                        f"{int(start_number)}-{int(end_number)} is full"
+                                    "error": _range_exhausted_error(
+                                        channel_numbering_mode,
+                                        start_number,
+                                        end_number,
+                                        channel_numbering_fallback,
                                     ),
                                 })
                             processed_stream_ids.add(stream.id)
@@ -2570,20 +2638,18 @@ def sync_auto_channels(account_id, scan_start_time=None):
 
                 channels_created += len(channel_objs)
 
-                # One EPG parse task per unique EPGData replaces the
-                # per-channel post_save dispatch bypassed by bulk_create.
-                from apps.epg.tasks import parse_programs_for_tvg_id
+                from apps.epg.tasks import dispatch_program_refresh_for_epg_ids
 
                 unique_epg_ids = {
                     ch.epg_data_id for ch in channel_objs if ch.epg_data_id
                 }
-                for epg_id in unique_epg_ids:
-                    parse_programs_for_tvg_id.delay(epg_id)
+                parse_dispatched = dispatch_program_refresh_for_epg_ids(unique_epg_ids)
 
                 logger.debug(
                     f"Bulk created {len(channel_objs)} channels in group "
                     f"'{channel_group.name}'; dispatched "
-                    f"{len(unique_epg_ids)} unique EPG parse task(s)"
+                    f"{parse_dispatched} EPG refresh task(s) for "
+                    f"{len(unique_epg_ids)} unique EPG id(s)"
                 )
 
             # bulk_update writes only the columns named in `fields` and
@@ -2597,17 +2663,14 @@ def sync_auto_channels(account_id, scan_start_time=None):
                     batch_size=500,
                 )
                 if epg_dirty_channel_ids:
-                    from apps.epg.tasks import parse_programs_for_tvg_id
+                    from apps.epg.tasks import dispatch_program_refresh_for_epg_ids
 
-                    # Dispatch only for channels whose epg_data_id changed.
-                    # Other dirty channels would queue redundant parses.
                     unique_epg_ids = {
                         ch.epg_data_id
                         for ch in existing_dirty_channels
                         if ch.id in epg_dirty_channel_ids and ch.epg_data_id
                     }
-                    for epg_id in unique_epg_ids:
-                        parse_programs_for_tvg_id.delay(epg_id)
+                    dispatch_program_refresh_for_epg_ids(unique_epg_ids)
                 logger.debug(
                     f"Bulk updated {len(existing_dirty_channels)} existing "
                     f"channels (fields: {sorted(existing_dirty_field_set)})"
@@ -2740,7 +2803,7 @@ def sync_auto_channels(account_id, scan_start_time=None):
         # "preserve_customized" keeps those with a ChannelOverride row;
         # "never" disables cleanup. Hidden channels are preserved across all
         # modes so event/PPV channels that come and go are not silently lost.
-        cleanup_mode = (account.custom_properties or {}).get(
+        cleanup_mode = ensure_custom_properties_dict(account.custom_properties).get(
             "orphan_channel_cleanup", "always"
         )
         if cleanup_mode != "never":
@@ -2822,12 +2885,13 @@ def get_transformed_credentials(account, profile=None):
             logger.warning(f"Could not get primary profile for account {account.name}: {e}")
             profile = None
 
-    base_url = account.server_url
+    from core.xtream_codes import normalize_server_url
+
+    base_url = normalize_server_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/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
@@ -2953,12 +3017,19 @@ def refresh_account_profiles(account_id):
                     if profile_client.authenticate():
                         # Get account information specific to this profile's credentials
                         profile_account_info = profile_client.get_account_info()
+                        if not isinstance(profile_account_info, dict):
+                            raise TypeError(
+                                f"Unexpected account info type: {type(profile_account_info).__name__}"
+                            )
 
                         # Merge with existing custom_properties if they exist
-                        existing_props = profile.custom_properties or {}
-                        existing_props.update(profile_account_info)
-                        profile.custom_properties = existing_props
-                        profile.save(update_fields=['custom_properties'])
+                        profile.custom_properties = {
+                            **ensure_custom_properties_dict(
+                                profile.custom_properties
+                            ),
+                            **profile_account_info,
+                        }
+                        profile.save(update_fields=['custom_properties', 'exp_date'])
 
                         profiles_updated += 1
                         logger.info(f"Updated account information for profile '{profile.name}' ({profiles_updated}/{profiles.count()})")
@@ -2969,6 +3040,7 @@ def refresh_account_profiles(account_id):
             except Exception as profile_error:
                 profiles_failed += 1
                 logger.error(f"Failed to update account information for profile '{profile.name}': {str(profile_error)}")
+                _release_task_db_connection()
                 # Continue with other profiles even if one fails
 
         result_msg = f"Profile refresh complete for account {account.name}: {profiles_updated} updated, {profiles_failed} failed"
@@ -2983,6 +3055,8 @@ def refresh_account_profiles(account_id):
         error_msg = f"Error refreshing profiles for account {account_id}: {str(e)}"
         logger.error(error_msg)
         return error_msg
+    finally:
+        _release_task_db_connection()
 
 
 @shared_task
@@ -3037,10 +3111,11 @@ def refresh_account_info(profile_id):
         account_info = client.get_account_info()
 
         # Update only this specific profile with the new account info
-        if not profile.custom_properties:
-            profile.custom_properties = {}
-        profile.custom_properties.update(account_info)
-        profile.save()
+        profile.custom_properties = {
+            **ensure_custom_properties_dict(profile.custom_properties),
+            **account_info,
+        }
+        profile.save(update_fields=['custom_properties', 'exp_date'])
 
         # Send success notification to frontend via websocket
         send_websocket_update(
@@ -3103,10 +3178,25 @@ def refresh_single_m3u_account(account_id):
     lock_renewer = TaskLockRenewer("refresh_single_m3u_account", account_id)
     lock_renewer.start()
 
+    _release_task_db_connection()
+
     try:
         return _refresh_single_m3u_account_impl(account_id)
+    except Exception as e:
+        logger.error(
+            f"refresh_single_m3u_account failed for account {account_id}: {e}",
+            exc_info=True,
+        )
+        _set_m3u_account_status(
+            account_id,
+            M3UAccount.Status.ERROR,
+            f"Error processing M3U: {str(e)[:500]}",
+            notify_error=True,
+            ws_error=str(e)[:500],
+        )
     finally:
-        # Guaranteed cleanup on all exit paths (success, exception, early return)
+        _ensure_m3u_refresh_terminal_status(account_id)
+        _release_task_db_connection()
         lock_renewer.stop()
         release_task_lock("refresh_single_m3u_account", account_id)
 
@@ -3121,22 +3211,25 @@ def _refresh_single_m3u_account_impl(account_id):
     streams_deleted = 0
 
     try:
-        account = M3UAccount.objects.get(id=account_id, is_active=True)
+        account = _get_active_m3u_account(account_id)
         if not account.is_active:
             logger.debug(f"Account {account_id} is not active, skipping.")
             return
 
-        # Set status to fetching
-        account.status = M3UAccount.Status.FETCHING
-        account.save(update_fields=['status'])
+        # Set status to fetching and replace stale completion messages.
+        _set_m3u_account_status(
+            account_id,
+            M3UAccount.Status.FETCHING,
+            "Refresh in progress...",
+        )
+        account = _get_active_m3u_account(account_id)
 
         filters = list(account.filters.all())
 
         # Check if VOD is enabled for this account
-        vod_enabled = False
-        if account.custom_properties:
-            custom_props = account.custom_properties or {}
-            vod_enabled = custom_props.get('enable_vod', False)
+        vod_enabled = ensure_custom_properties_dict(account.custom_properties).get(
+            'enable_vod', False
+        )
 
     except M3UAccount.DoesNotExist:
         # The M3U account doesn't exist, so delete the periodic task if it exists
@@ -3202,6 +3295,16 @@ def _refresh_single_m3u_account_impl(account_id):
                 logger.error(
                     f"Failed to refresh M3U groups for account {account_id}: {result}"
                 )
+                error_msg = (
+                    "Failed to refresh M3U groups - download failed or other error"
+                )
+                _set_m3u_account_status(
+                    account_id,
+                    M3UAccount.Status.ERROR,
+                    error_msg,
+                    notify_error=True,
+                    ws_error=error_msg,
+                )
                 return "Failed to update m3u account - download failed or other error"
 
             extinf_data, groups = result
@@ -3216,23 +3319,23 @@ def _refresh_single_m3u_account_impl(account_id):
             # For XC accounts, empty extinf_data is normal at this stage
             if not extinf_data and not is_xc_account:
                 logger.error(f"No streams found for non-XC account {account_id}")
-                account.status = M3UAccount.Status.ERROR
-                account.last_message = "No streams found in M3U source"
-                account.save(update_fields=["status", "last_message"])
-                send_m3u_update(
-                    account_id, "parsing", 100, status="error", error="No streams found"
+                error_msg = "No streams found in M3U source"
+                _set_m3u_account_status(
+                    account_id,
+                    M3UAccount.Status.ERROR,
+                    error_msg,
+                    notify_error=True,
+                    ws_error=error_msg,
                 )
         except Exception as e:
             logger.error(f"Exception in refresh_m3u_groups: {str(e)}", exc_info=True)
-            account.status = M3UAccount.Status.ERROR
-            account.last_message = f"Error refreshing M3U groups: {str(e)}"
-            account.save(update_fields=["status", "last_message"])
-            send_m3u_update(
+            error_msg = f"Error refreshing M3U groups: {str(e)[:500]}"
+            _set_m3u_account_status(
                 account_id,
-                "parsing",
-                100,
-                status="error",
-                error=f"Error refreshing M3U groups: {str(e)}",
+                M3UAccount.Status.ERROR,
+                error_msg,
+                notify_error=True,
+                ws_error=error_msg,
             )
             return "Failed to update m3u account"
 
@@ -3246,15 +3349,13 @@ def _refresh_single_m3u_account_impl(account_id):
     # Modified validation logic for different account types
     if (not groups) or (not is_xc_account and not extinf_data):
         logger.error(f"No data to process for account {account_id}")
-        account.status = M3UAccount.Status.ERROR
-        account.last_message = "No data available for processing"
-        account.save(update_fields=["status", "last_message"])
-        send_m3u_update(
+        error_msg = "No data available for processing"
+        _set_m3u_account_status(
             account_id,
-            "parsing",
-            100,
-            status="error",
-            error="No data available for processing",
+            M3UAccount.Status.ERROR,
+            error_msg,
+            notify_error=True,
+            ws_error=error_msg,
         )
         return "Failed to update m3u account, no data available"
 
@@ -3351,6 +3452,8 @@ def _refresh_single_m3u_account_impl(account_id):
                     except Exception as e:
                         logger.error(f"Error in thread batch {batch_idx}: {str(e)}")
                         completed_batches += 1  # Still count it to avoid hanging
+                    finally:
+                        batches[batch_idx] = None
 
             logger.info(f"Thread-based processing completed for account {account_id}")
         else:
@@ -3368,7 +3471,7 @@ def _refresh_single_m3u_account_impl(account_id):
                 group_id = rel.channel_group.id
 
                 # Load the custom properties with the xc_id
-                custom_props = rel.custom_properties or {}
+                custom_props = ensure_custom_properties_dict(rel.custom_properties)
                 if "xc_id" in custom_props:
                     filtered_groups[group_name] = {
                         "xc_id": custom_props["xc_id"],
@@ -3462,6 +3565,8 @@ def _refresh_single_m3u_account_impl(account_id):
                         except Exception as e:
                             logger.error(f"Error in XC thread batch {batch_idx}: {str(e)}")
                             completed_batches += 1  # Still count it to avoid hanging
+                        finally:
+                            batches[batch_idx] = None
 
                 logger.info(f"XC thread-based processing completed for account {account_id}")
 
@@ -3591,13 +3696,7 @@ def _refresh_single_m3u_account_impl(account_id):
 
     except Exception as e:
         logger.error(f"Error processing M3U for account {account_id}: {str(e)}")
-        try:
-            account.status = M3UAccount.Status.ERROR
-            account.last_message = f"Error processing M3U: {str(e)}"
-            account.save(update_fields=["status", "last_message"])
-        except Exception:
-            logger.debug(f"Failed to update account {account_id} status during error handling")
-        raise  # Re-raise the exception for Celery to handle
+        raise
     finally:
         # Free large data structures regardless of success or failure
         if 'existing_groups' in locals():
@@ -3624,6 +3723,8 @@ def _refresh_single_m3u_account_impl(account_id):
         except OSError:
             pass
 
+        _release_task_db_connection()
+
     return f"Dispatched jobs complete."
 
 
diff --git a/apps/m3u/tests/test_connection_pool.py b/apps/m3u/tests/test_connection_pool.py
new file mode 100644
index 00000000..443c5bd8
--- /dev/null
+++ b/apps/m3u/tests/test_connection_pool.py
@@ -0,0 +1,594 @@
+"""Tests for shared ServerGroup connection pools (#1137)."""
+
+from django.test import TestCase
+from unittest.mock import patch
+
+from apps.m3u.connection_pool import (
+    extract_credentials_from_stream_url,
+    get_credential_connection_count,
+    get_enforced_server_group_for_profile,
+    get_profile_connection_count,
+    get_profile_credential_fingerprint,
+    group_has_capacity_for_profile,
+    pool_has_capacity_for_profile,
+    profile_has_capacity_for_selection,
+    profile_connections_key,
+    profile_credential_release_key,
+    release_profile_slot,
+    reserve_profile_slot,
+    server_group_connections_key,
+)
+from apps.m3u.models import M3UAccount, M3UAccountProfile, ServerGroup
+
+
+class FakeRedis:
+    """Minimal in-memory Redis stand-in for counter tests."""
+
+    def __init__(self):
+        self._data = {}
+
+    def get(self, key):
+        val = self._data.get(key)
+        if val is None:
+            return None
+        if isinstance(val, str):
+            return val.encode()
+        return str(val).encode()
+
+    def set(self, key, value, ex=None):
+        try:
+            self._data[key] = int(value)
+        except (ValueError, TypeError):
+            self._data[key] = value
+
+    def incr(self, key):
+        self._data[key] = self._data.get(key, 0) + 1
+        return self._data[key]
+
+    def decr(self, key):
+        self._data[key] = self._data.get(key, 0) - 1
+        return self._data[key]
+
+    def delete(self, key):
+        self._data.pop(key, None)
+
+    def pipeline(self):
+        return FakeRedisPipeline(self)
+
+
+class FakeRedisPipeline:
+    def __init__(self, redis):
+        self.redis = redis
+        self._ops = []
+
+    def decr(self, key):
+        self._ops.append(("decr", key))
+        return self
+
+    def incr(self, key):
+        self._ops.append(("incr", key))
+        return self
+
+    def set(self, key, value):
+        self._ops.append(("set", key, value))
+        return self
+
+    def execute(self):
+        for op in self._ops:
+            if op[0] == "decr":
+                self.redis.decr(op[1])
+            elif op[0] == "incr":
+                self.redis.incr(op[1])
+            elif op[0] == "set":
+                self.redis.set(op[1], op[2])
+        self._ops = []
+
+
+class ExtractCredentialsTests(TestCase):
+    def test_extract_credentials_from_xc_style_url(self):
+        url = "http://example.com/live/alice/secret123/99999.ts"
+        user, password = extract_credentials_from_stream_url(url)
+        self.assertEqual(user, "alice")
+        self.assertEqual(password, "secret123")
+
+
+class ManualServerGroupTests(TestCase):
+    def test_group_enforced_when_account_assigned(self):
+        group = ServerGroup.objects.create(name="provider-a")
+        account = M3UAccount.objects.create(
+            name="Account A",
+            account_type="XC",
+            username="user",
+            password="pass",
+            server_group=group,
+        )
+        profile = M3UAccountProfile.objects.get(m3u_account=account, is_default=True)
+
+        self.assertEqual(get_enforced_server_group_for_profile(profile), group)
+
+    def test_accounts_in_same_group_share_credential_counter(self):
+        group = ServerGroup.objects.create(name="shared")
+        account1 = M3UAccount.objects.create(
+            name="XC Account",
+            account_type="XC",
+            username="user",
+            password="pass",
+            server_url="http://xc.example.com",
+            server_group=group,
+            max_streams=5,
+        )
+        account2 = M3UAccount.objects.create(
+            name="M3U Account",
+            account_type="STD",
+            username="user",
+            password="pass",
+            server_group=group,
+            max_streams=5,
+        )
+        profile1 = M3UAccountProfile.objects.get(m3u_account=account1, is_default=True)
+        profile2 = M3UAccountProfile.objects.get(m3u_account=account2, is_default=True)
+        profile1.max_streams = 1
+        profile1.save()
+        profile2.max_streams = 1
+        profile2.save()
+
+        redis = FakeRedis()
+        reserved1, _, _ = reserve_profile_slot(profile1, redis)
+        self.assertTrue(reserved1)
+
+        reserved2, _, _ = reserve_profile_slot(profile2, redis)
+        self.assertFalse(reserved2)
+        self.assertFalse(group_has_capacity_for_profile(profile2, redis))
+
+    def test_profile_rotation_when_default_profile_full(self):
+        account = M3UAccount.objects.create(
+            name="Multi-profile",
+            account_type="XC",
+            max_streams=1,
+        )
+        default = M3UAccountProfile.objects.get(m3u_account=account, is_default=True)
+        default.max_streams = 1
+        default.save()
+
+        alt = M3UAccountProfile.objects.create(
+            m3u_account=account,
+            name="alt_profile",
+            is_default=False,
+            is_active=True,
+            max_streams=1,
+            search_pattern="",
+            replace_pattern="",
+        )
+
+        redis = FakeRedis()
+        reserved, _, _ = reserve_profile_slot(default, redis)
+        self.assertTrue(reserved)
+        self.assertFalse(profile_has_capacity_for_selection(default, redis))
+        self.assertTrue(profile_has_capacity_for_selection(alt, redis))
+
+
+class PoolEnforcementTests(TestCase):
+    def setUp(self):
+        self.redis = FakeRedis()
+        self.group = ServerGroup.objects.create(name="test-pool")
+        self.account = M3UAccount.objects.create(
+            name="Test Account",
+            account_type="XC",
+            username="user",
+            password="pass",
+            server_url="http://xc.example.com",
+            server_group=self.group,
+            max_streams=5,
+        )
+        self.profile = M3UAccountProfile.objects.get(
+            m3u_account=self.account, is_default=True
+        )
+        self.profile.max_streams = 1
+        self.profile.save()
+
+    def test_group_has_capacity_reads_credential_counter_directly(self):
+        cred_key = server_group_connections_key(
+            self.group.id,
+            get_profile_credential_fingerprint(self.profile),
+        )
+        self.redis.set(cred_key, 1)
+
+        self.assertFalse(group_has_capacity_for_profile(self.profile, self.redis))
+
+        self.redis.set(cred_key, 0)
+        self.assertTrue(group_has_capacity_for_profile(self.profile, self.redis))
+
+    def test_reserve_and_release_both_counters(self):
+        reserved, count, _ = reserve_profile_slot(self.profile, self.redis)
+        self.assertTrue(reserved)
+        self.assertEqual(count, 1)
+
+        cred_key = server_group_connections_key(
+            self.group.id,
+            get_profile_credential_fingerprint(self.profile),
+        )
+        profile_key = profile_connections_key(self.profile.id)
+        self.assertEqual(self.redis._data[cred_key], 1)
+        self.assertEqual(self.redis._data[profile_key], 1)
+
+        release_profile_slot(self.profile.id, self.redis)
+        self.assertEqual(self.redis._data[cred_key], 0)
+        self.assertEqual(self.redis._data[profile_key], 0)
+
+    def test_same_credential_capped_at_profile_max(self):
+        """Shared credential counter is capped by each profile's max_streams."""
+        account2 = M3UAccount.objects.create(
+            name="Second Account",
+            account_type="XC",
+            username="user",
+            password="pass",
+            server_url="http://xc.example.com",
+            server_group=self.group,
+            max_streams=5,
+        )
+        profile2 = M3UAccountProfile.objects.get(m3u_account=account2, is_default=True)
+        profile2.max_streams = 1
+        profile2.save()
+
+        self.assertTrue(reserve_profile_slot(self.profile, self.redis)[0])
+        self.assertFalse(reserve_profile_slot(profile2, self.redis)[0])
+
+        fp = get_profile_credential_fingerprint(self.profile)
+        cred_key = server_group_connections_key(self.group.id, fp)
+        self.assertEqual(self.redis._data[cred_key], 1)
+
+    def test_different_logins_both_stream_in_same_group(self):
+        """Different provider logins keep separate credential counters in one group."""
+        account = M3UAccount.objects.create(
+            name="Grouped multi-login",
+            account_type="XC",
+            username="login_a",
+            password="pass_a",
+            server_group=self.group,
+            max_streams=5,
+        )
+        default = M3UAccountProfile.objects.get(m3u_account=account, is_default=True)
+        default.max_streams = 1
+        default.save()
+
+        alt = M3UAccountProfile.objects.create(
+            m3u_account=account,
+            name="alt_login",
+            is_default=False,
+            is_active=True,
+            max_streams=1,
+            search_pattern="",
+            replace_pattern="",
+        )
+
+        fp_a = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+        fp_b = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
+
+        with patch(
+            "apps.m3u.connection_pool.get_profile_credential_fingerprint",
+            side_effect=lambda profile: fp_a if profile.id == default.id else fp_b,
+        ):
+            self.assertTrue(reserve_profile_slot(default, self.redis)[0])
+            self.assertTrue(reserve_profile_slot(alt, self.redis)[0])
+
+            key_a = server_group_connections_key(self.group.id, fp_a)
+            key_b = server_group_connections_key(self.group.id, fp_b)
+            self.assertEqual(self.redis._data[key_a], 1)
+            self.assertEqual(self.redis._data[key_b], 1)
+
+    def test_no_fingerprint_skips_credential_counter(self):
+        account = M3UAccount.objects.create(
+            name="No creds",
+            account_type="STD",
+            server_group=self.group,
+            max_streams=5,
+        )
+        profile = M3UAccountProfile.objects.get(m3u_account=account, is_default=True)
+        profile.max_streams = 1
+        profile.save()
+
+        with patch(
+            "apps.m3u.connection_pool.get_profile_credential_fingerprint",
+            return_value=None,
+        ):
+            self.assertTrue(reserve_profile_slot(profile, self.redis)[0])
+            self.assertEqual(get_credential_connection_count(profile, self.redis), 0)
+            self.assertEqual(get_credential_connection_count(profile, self.redis), 0)
+
+    def test_release_when_profile_row_deleted(self):
+        profile_id = self.profile.id
+        fp = get_profile_credential_fingerprint(self.profile)
+        cred_key = server_group_connections_key(self.group.id, fp)
+
+        reserved, _, failure_reason = reserve_profile_slot(
+            self.profile, self.redis
+        )
+        self.assertTrue(reserved)
+        self.assertIsNone(failure_reason)
+        self.profile.delete()
+
+        release_profile_slot(profile_id, self.redis)
+
+        self.assertEqual(self.redis._data[profile_connections_key(profile_id)], 0)
+        self.assertEqual(self.redis._data[cred_key], 0)
+        self.assertNotIn(profile_credential_release_key(profile_id), self.redis._data)
+
+    def test_release_uses_stored_credential_key_without_db_lookup(self):
+        profile_id = self.profile.id
+        cred_key = server_group_connections_key(
+            self.group.id,
+            get_profile_credential_fingerprint(self.profile),
+        )
+
+        self.assertTrue(reserve_profile_slot(self.profile, self.redis)[0])
+
+        with patch("apps.m3u.models.M3UAccountProfile.objects.get") as mock_get:
+            release_profile_slot(profile_id, self.redis)
+            mock_get.assert_not_called()
+
+        self.assertEqual(self.redis._data[profile_connections_key(profile_id)], 0)
+        self.assertEqual(self.redis._data[cred_key], 0)
+
+    def test_reserve_returns_failure_reason_without_extra_checks(self):
+        account2 = M3UAccount.objects.create(
+            name="Reason Account",
+            account_type="XC",
+            username="user",
+            password="pass",
+            server_url="http://xc.example.com",
+            server_group=self.group,
+            max_streams=5,
+        )
+        profile2 = M3UAccountProfile.objects.get(m3u_account=account2, is_default=True)
+        profile2.max_streams = 1
+        profile2.save()
+
+        self.assertTrue(reserve_profile_slot(self.profile, self.redis)[0])
+        reserved, _count, reason = reserve_profile_slot(profile2, self.redis)
+        self.assertFalse(reserved)
+        self.assertEqual(reason, "credential_full")
+
+
+class StaleAssignmentTests(TestCase):
+    def test_stale_assignment_releases_counters(self):
+        from apps.channels.models import Channel, Stream
+
+        redis = FakeRedis()
+        group = ServerGroup.objects.create(name="stale-group")
+        account = M3UAccount.objects.create(
+            name="Stale Account",
+            account_type="XC",
+            username="user",
+            password="pass",
+            server_url="http://xc.example.com",
+            server_group=group,
+            max_streams=5,
+        )
+        profile = M3UAccountProfile.objects.get(m3u_account=account, is_default=True)
+        profile.max_streams = 1
+        profile.save()
+
+        stream = Stream.objects.create(name="Stale Stream", m3u_account=account)
+        channel = Channel.objects.create(channel_number=502, name="Stale Channel")
+        channel.streams.add(stream)
+
+        reserve_profile_slot(profile, redis)
+        redis.set(f"channel_stream:{channel.id}", stream.id)
+        redis.set(f"stream_profile:{stream.id}", profile.id)
+
+        profile_key = profile_connections_key(profile.id)
+        cred_key = server_group_connections_key(
+            group.id, get_profile_credential_fingerprint(profile)
+        )
+        self.assertEqual(redis._data[profile_key], 1)
+        self.assertEqual(redis._data[cred_key], 1)
+
+        with patch("core.utils.RedisClient.get_client", return_value=redis):
+            channel._release_stale_stream_assignment(redis, stream.id)
+
+        self.assertNotIn(f"channel_stream:{channel.id}", redis._data)
+        self.assertNotIn(f"stream_profile:{stream.id}", redis._data)
+        self.assertEqual(redis._data[profile_key], 0)
+        self.assertEqual(redis._data[cred_key], 0)
+
+
+class UpdateStreamProfileTests(TestCase):
+    def test_switch_updates_profile_counters_when_group_assigned(self):
+        from apps.channels.models import Channel, Stream
+
+        redis = FakeRedis()
+        group = ServerGroup.objects.create(name="switch-group")
+        account = M3UAccount.objects.create(
+            name="Switch Account",
+            account_type="XC",
+            username="user",
+            password="pass",
+            server_url="http://xc.example.com",
+            server_group=group,
+            max_streams=5,
+        )
+        profile_a = M3UAccountProfile.objects.get(m3u_account=account, is_default=True)
+        profile_a.max_streams = 1
+        profile_a.save()
+        profile_b = M3UAccountProfile.objects.create(
+            m3u_account=account,
+            name="alt",
+            is_default=False,
+            is_active=True,
+            max_streams=1,
+            search_pattern="",
+            replace_pattern="",
+        )
+
+        stream = Stream.objects.create(name="Test Stream", m3u_account=account)
+        channel = Channel.objects.create(channel_number=501, name="Switch Channel")
+        channel.streams.add(stream)
+
+        reserve_profile_slot(profile_a, redis)
+        redis.set(f"channel_stream:{channel.id}", stream.id)
+        redis.set(f"stream_profile:{stream.id}", profile_a.id)
+
+        cred_key = server_group_connections_key(
+            group.id, get_profile_credential_fingerprint(profile_a)
+        )
+        cred_before = redis._data[cred_key]
+
+        with patch("core.utils.RedisClient.get_client", return_value=redis):
+            self.assertTrue(channel.update_stream_profile(profile_b.id))
+
+        self.assertEqual(int(redis.get(f"stream_profile:{stream.id}")), profile_b.id)
+        self.assertEqual(redis._data[profile_connections_key(profile_a.id)], 0)
+        self.assertEqual(redis._data[profile_connections_key(profile_b.id)], 1)
+        self.assertEqual(redis._data[cred_key], cred_before)
+
+    def test_switch_moves_credential_counter_when_login_changes(self):
+        from apps.channels.models import Channel, Stream
+
+        redis = FakeRedis()
+        group = ServerGroup.objects.create(name="cred-switch-group")
+        account = M3UAccount.objects.create(
+            name="Cred Switch Account",
+            account_type="XC",
+            username="login_a",
+            password="pass_a",
+            server_url="http://xc.example.com",
+            server_group=group,
+            max_streams=5,
+        )
+        profile_a = M3UAccountProfile.objects.get(m3u_account=account, is_default=True)
+        profile_a.max_streams = 1
+        profile_a.save()
+        profile_b = M3UAccountProfile.objects.create(
+            m3u_account=account,
+            name="alt_login",
+            is_default=False,
+            is_active=True,
+            max_streams=1,
+            search_pattern="",
+            replace_pattern="",
+        )
+
+        fp_a = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
+        fp_b = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"
+        key_a = server_group_connections_key(group.id, fp_a)
+        key_b = server_group_connections_key(group.id, fp_b)
+
+        stream = Stream.objects.create(name="Cred Switch Stream", m3u_account=account)
+        channel = Channel.objects.create(channel_number=503, name="Cred Switch Channel")
+        channel.streams.add(stream)
+
+        with patch(
+            "apps.m3u.connection_pool.get_profile_credential_fingerprint",
+            side_effect=lambda profile: fp_a if profile.id == profile_a.id else fp_b,
+        ):
+            reserve_profile_slot(profile_a, redis)
+            redis.set(f"channel_stream:{channel.id}", stream.id)
+            redis.set(f"stream_profile:{stream.id}", profile_a.id)
+            self.assertEqual(redis._data[key_a], 1)
+            self.assertNotIn(key_b, redis._data)
+
+            with patch("core.utils.RedisClient.get_client", return_value=redis):
+                self.assertTrue(channel.update_stream_profile(profile_b.id))
+
+            self.assertEqual(redis._data[key_a], 0)
+            self.assertEqual(redis._data[key_b], 1)
+
+
+class VodProfileSelectionTests(TestCase):
+    def test_get_m3u_profile_skips_default_when_profile_full(self):
+        from apps.proxy.vod_proxy.views import _get_m3u_profile
+
+        account = M3UAccount.objects.create(
+            name="VOD multi-profile",
+            account_type="XC",
+            username="xc_user_a",
+            password="xc_pass_a",
+            server_url="http://xc.example.com",
+            max_streams=1,
+        )
+        default = M3UAccountProfile.objects.get(m3u_account=account, is_default=True)
+        default.max_streams = 1
+        default.save()
+
+        alt = M3UAccountProfile.objects.create(
+            m3u_account=account,
+            name="alt_profile",
+            is_default=False,
+            is_active=True,
+            max_streams=1,
+            search_pattern="",
+            replace_pattern="",
+        )
+
+        redis = FakeRedis()
+        self.assertTrue(reserve_profile_slot(default, redis)[0])
+
+        with patch("core.utils.RedisClient.get_client", return_value=redis):
+            result = _get_m3u_profile(account, None, None)
+
+        self.assertIsNotNone(result)
+        selected, _connections = result
+        self.assertEqual(selected.id, alt.id)
+
+    def test_get_m3u_profile_skips_default_when_credential_pool_full(self):
+        from apps.proxy.vod_proxy.views import _get_m3u_profile
+
+        group = ServerGroup.objects.create(name="vod-cred-pool")
+        account = M3UAccount.objects.create(
+            name="VOD pooled",
+            account_type="XC",
+            username="shared_user",
+            password="shared_pass",
+            server_url="http://xc.example.com",
+            server_group=group,
+            max_streams=5,
+        )
+        default = M3UAccountProfile.objects.get(m3u_account=account, is_default=True)
+        default.max_streams = 1
+        default.save()
+
+        alt = M3UAccountProfile.objects.create(
+            m3u_account=account,
+            name="alt_login",
+            is_default=False,
+            is_active=True,
+            max_streams=1,
+            search_pattern="",
+            replace_pattern="",
+        )
+
+        other_account = M3UAccount.objects.create(
+            name="Other pooled account",
+            account_type="XC",
+            username="shared_user",
+            password="shared_pass",
+            server_url="http://xc.example.com",
+            server_group=group,
+            max_streams=5,
+        )
+        other_profile = M3UAccountProfile.objects.get(
+            m3u_account=other_account, is_default=True
+        )
+        other_profile.max_streams = 1
+        other_profile.save()
+
+        fp_shared = "cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc"
+        fp_alt = "dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd"
+
+        redis = FakeRedis()
+        with patch(
+            "apps.m3u.connection_pool.get_profile_credential_fingerprint",
+            side_effect=lambda profile: (
+                fp_shared
+                if profile.id in (default.id, other_profile.id)
+                else fp_alt
+            ),
+        ):
+            self.assertTrue(reserve_profile_slot(other_profile, redis)[0])
+
+            with patch("core.utils.RedisClient.get_client", return_value=redis):
+                result = _get_m3u_profile(account, None, None)
+
+        self.assertIsNotNone(result)
+        selected, _connections = result
+        self.assertEqual(selected.id, alt.id)
diff --git a/apps/m3u/tests/test_memory_cleanup.py b/apps/m3u/tests/test_memory_cleanup.py
index bd556e4c..bfc964d0 100644
--- a/apps/m3u/tests/test_memory_cleanup.py
+++ b/apps/m3u/tests/test_memory_cleanup.py
@@ -33,6 +33,24 @@ class ProcessM3UBatchCleanupTests(SimpleTestCase):
             process_m3u_batch_direct(1, [], {}, ["name", "url"])
             mock_connections.close_all.assert_called()
 
+    @patch("apps.m3u.tasks.Stream")
+    @patch("apps.m3u.tasks.M3UAccount")
+    def test_batch_calls_gc_collect(self, mock_account_cls, mock_stream_cls):
+        """gc.collect() must run after each batch so XC refresh threads release promptly."""
+        from apps.m3u.tasks import process_m3u_batch_direct
+
+        mock_account = MagicMock()
+        mock_account.filters.order_by.return_value = []
+        mock_account_cls.objects.get.return_value = mock_account
+        mock_stream_cls.objects.filter.return_value.select_related.return_value.only.return_value = (
+            []
+        )
+        mock_stream_cls.generate_hash_key = MagicMock(return_value="hash123")
+
+        with patch("gc.collect") as mock_gc, patch("django.db.connections"):
+            process_m3u_batch_direct(1, [], {}, ["name", "url"])
+            mock_gc.assert_called()
+
 
 class LockReleaseTests(SimpleTestCase):
     """Verify task lock is released on all exit paths."""
diff --git a/apps/m3u/tests/test_refresh_db_recovery.py b/apps/m3u/tests/test_refresh_db_recovery.py
new file mode 100644
index 00000000..42db8bd5
--- /dev/null
+++ b/apps/m3u/tests/test_refresh_db_recovery.py
@@ -0,0 +1,74 @@
+from unittest.mock import MagicMock, patch
+
+from django.test import SimpleTestCase
+
+from apps.m3u.tasks import (
+    _db_query_with_retry,
+    _get_active_m3u_account,
+    _release_task_db_connection,
+    refresh_single_m3u_account,
+)
+
+
+class DbQueryWithRetryTests(SimpleTestCase):
+    def test_retries_after_index_error_from_poisoned_connection(self):
+        fn = MagicMock(side_effect=[IndexError("list index out of range"), "ok"])
+
+        with patch(
+            "apps.m3u.tasks._release_task_db_connection"
+        ) as mock_release:
+            result = _db_query_with_retry(fn, label="test query")
+
+        self.assertEqual(result, "ok")
+        self.assertEqual(fn.call_count, 2)
+        mock_release.assert_called_once()
+
+    def test_raises_after_exhausting_retries(self):
+        fn = MagicMock(side_effect=IndexError("list index out of range"))
+
+        with patch("apps.m3u.tasks._release_task_db_connection"):
+            with self.assertRaises(IndexError):
+                _db_query_with_retry(fn, label="test query", max_retries=2)
+
+        self.assertEqual(fn.call_count, 2)
+
+
+class RefreshTaskDbStartupTests(SimpleTestCase):
+    @patch("apps.m3u.tasks._ensure_m3u_refresh_terminal_status")
+    @patch("apps.m3u.tasks._refresh_single_m3u_account_impl")
+    @patch("apps.m3u.tasks.release_task_lock")
+    @patch("apps.m3u.tasks.acquire_task_lock", return_value=True)
+    @patch("apps.m3u.tasks.TaskLockRenewer")
+    @patch("apps.m3u.tasks._release_task_db_connection")
+    def test_refresh_releases_db_connection_before_impl(
+        self,
+        mock_release,
+        _mock_renewer,
+        _mock_acquire,
+        _mock_release_lock,
+        mock_impl,
+        _mock_ensure_terminal,
+    ):
+        call_order = []
+
+        def track_release():
+            call_order.append("release")
+
+        mock_release.side_effect = track_release
+        mock_impl.side_effect = lambda *_a, **_k: call_order.append("impl") or "done"
+
+        result = refresh_single_m3u_account(140)
+
+        self.assertEqual(result, "done")
+        self.assertEqual(call_order[:2], ["release", "impl"])
+
+    @patch("apps.m3u.tasks.M3UAccount")
+    def test_get_active_m3u_account_uses_retry_helper(self, mock_model):
+        mock_model.objects.get.return_value = MagicMock(is_active=True)
+
+        with patch("apps.m3u.tasks._db_query_with_retry") as mock_retry:
+            mock_retry.side_effect = lambda fn, **_: fn()
+            account = _get_active_m3u_account(140)
+
+        mock_retry.assert_called_once()
+        self.assertTrue(account.is_active)
diff --git a/apps/m3u/tests/test_sync_correctness.py b/apps/m3u/tests/test_sync_correctness.py
index 9f8b87a2..8ae09fa8 100644
--- a/apps/m3u/tests/test_sync_correctness.py
+++ b/apps/m3u/tests/test_sync_correctness.py
@@ -46,13 +46,14 @@ def _attach_group_to_account(account, group, custom_properties=None):
     )
 
 
-def _make_stream(account, group, name="ESPN", tvg_id="espn"):
+def _make_stream(account, group, name="ESPN", tvg_id="espn", stream_chno=None):
     return Stream.objects.create(
         name=name,
         url=f"http://example.com/{name.lower()}.m3u8",
         m3u_account=account,
         channel_group=group,
         tvg_id=tvg_id,
+        stream_chno=stream_chno,
         last_seen=timezone.now(),
     )
 
@@ -413,21 +414,21 @@ class RangeEnforcementTests(TestCase):
             "new auto-channel duplicates A's effective channel number.",
         )
 
-    def test_provider_mode_fallback_respects_range_start(self):
-        # Provider-mode streams without a usable stream_chno fall back to
-        # the next-available picker. The fallback must honor the group's
-        # configured `auto_sync_channel_start` so freshly-created channels
-        # never land below the user's chosen range. Without this, a group
-        # configured for [100, 200] silently spawned channels at #1 when
-        # the provider omitted channel-number metadata.
+    def test_provider_mode_numberless_fallback_uses_visible_start(self):
+        # In provider mode the visible "Start #" is channel_numbering_fallback,
+        # so a numberless stream's fallback walks from there, not from the
+        # hidden auto_sync_channel_start (set far above the range here to prove
+        # it is ignored).
+        # Fail signature: 0 channels created, or a channel below 100 = fallback
+        # seeded from the wrong field.
         account = _make_account()
         group = _make_group(name="Sports")
         rel = _attach_group_to_account(account, group)
-        rel.auto_sync_channel_start = 100
+        rel.auto_sync_channel_start = 5000  # hidden; must be ignored
         rel.auto_sync_channel_end = 200
         rel.custom_properties = {
             "channel_numbering_mode": "provider",
-            "channel_numbering_fallback": 1,
+            "channel_numbering_fallback": 100,  # the visible "Start #"
         }
         rel.save()
 
@@ -643,6 +644,34 @@ class NumbersInRangeLookupTests(TestCase):
         )
         self.assertFalse(occupant["has_channel_number_override"])
 
+    def test_group_override_channel_reports_target_group(self):
+        # When auto-sync routes channels into a different group via
+        # group_override, the occupant's channel_group_id is the override
+        # target, not the source group being configured. The frontend relies
+        # on this to recognize override-routed channels as the config's own
+        # output (effectiveSyncGroupId), so the warning does not flag them.
+        account = _make_account()
+        source = _make_group(name="SourceGrp")
+        target = _make_group(name="TargetGrp")
+        Channel.objects.create(
+            name="Routed",
+            channel_number=3210,
+            channel_group=target,
+            auto_created=True,
+            auto_created_by=account,
+        )
+        client = self._client()
+
+        response = client.get(
+            "/api/channels/channels/numbers-in-range/?start=3210&end=3210"
+        )
+
+        occupant = response.data["occupants"][0]
+        self.assertEqual(occupant["channel_group_id"], target.id)
+        self.assertNotEqual(occupant["channel_group_id"], source.id)
+        self.assertTrue(occupant["auto_created"])
+        self.assertEqual(occupant["auto_created_by_account_id"], account.id)
+
     def test_manual_channel_exposed_with_auto_created_false(self):
         # Manual channels are always a real collision worth surfacing.
         # The response must flag them with auto_created=False and a null
@@ -2300,3 +2329,315 @@ class CompactNumberingIdempotencyTests(TransactionTestCase):
             "pass with no hide or override change. _repack_inner is following "
             "physical row order instead of id order.",
         )
+
+
+class ProviderNumberingHonorsProviderNumberTests(TestCase):
+    """
+    Provider numbering uses a stream's provider number (stream_chno) verbatim.
+    The group start is auto-populated by the UI and is not editable in provider
+    mode (the UI binds "Start #" to channel_numbering_fallback), so treating it
+    as a lower bound silently discarded valid provider numbers: on a lineup
+    topping out near 5000, provider numbers 100-150 landed at ~5000.
+
+    The start and end bound only the fallback for numberless streams.
+    """
+
+    def test_provider_number_below_high_auto_start_is_honored(self):
+        # Provider numbers 100-104 with an auto-set start of 5000 must land at
+        # their provider numbers.
+        # Fail signature: channels at 5000-5004 = start used as a hard floor.
+        account = _make_account()
+        group = _make_group(name="PPV")
+        rel = _attach_group_to_account(account, group)
+        rel.auto_sync_channel_start = 5000
+        rel.auto_sync_channel_end = None
+        rel.custom_properties = {
+            "channel_numbering_mode": "provider",
+            "channel_numbering_fallback": 1,
+        }
+        rel.save()
+        for i in range(5):
+            _make_stream(
+                account, group, name=f"PPV {i}", tvg_id=f"ppv{i}",
+                stream_chno=100 + i,
+            )
+
+        result = _sync(account)
+
+        self.assertEqual(result["status"], "ok")
+        numbers = sorted(
+            Channel.objects.filter(
+                auto_created=True, auto_created_by=account
+            ).values_list("channel_number", flat=True)
+        )
+        self.assertEqual(numbers, [100.0, 101.0, 102.0, 103.0, 104.0])
+
+    def test_provider_number_honored_when_start_unset(self):
+        # start blank -> defaults to 1.0; provider numbers still honored.
+        account = _make_account()
+        group = _make_group(name="PPV")
+        rel = _attach_group_to_account(account, group)
+        rel.auto_sync_channel_start = None
+        rel.auto_sync_channel_end = None
+        rel.custom_properties = {"channel_numbering_mode": "provider"}
+        rel.save()
+        _make_stream(account, group, name="PPV", tvg_id="ppv", stream_chno=100)
+
+        result = _sync(account)
+
+        self.assertEqual(result["status"], "ok")
+        created = Channel.objects.get(auto_created=True, auto_created_by=account)
+        self.assertEqual(created.channel_number, 100.0)
+
+    def test_numberless_stream_uses_fallback_not_hidden_start(self):
+        # In provider mode without a range, a stream lacking a provider
+        # number falls back to channel_numbering_fallback (the visible
+        # "Start #"), not the hidden auto_sync_channel_start.
+        # Fail signature: channel at 5000 = fallback bumped to hidden start.
+        account = _make_account()
+        group = _make_group(name="PPV")
+        rel = _attach_group_to_account(account, group)
+        rel.auto_sync_channel_start = 5000
+        rel.auto_sync_channel_end = None
+        rel.custom_properties = {
+            "channel_numbering_mode": "provider",
+            "channel_numbering_fallback": 300,
+        }
+        rel.save()
+        _make_stream(account, group, name="NoChno", tvg_id="nc")
+
+        result = _sync(account)
+
+        self.assertEqual(result["status"], "ok")
+        created = Channel.objects.get(auto_created=True, auto_created_by=account)
+        self.assertEqual(created.channel_number, 300.0)
+
+    def test_provider_number_below_range_is_honored_verbatim(self):
+        # A provider number below the group's Start/End is used as-is, not
+        # coerced into the range.
+        # Fail signature: channel pulled to >= 100 = range coercing a provider
+        # number.
+        account = _make_account()
+        group = _make_group(name="PPV")
+        rel = _attach_group_to_account(account, group)
+        rel.auto_sync_channel_end = 200
+        rel.custom_properties = {
+            "channel_numbering_mode": "provider",
+            "channel_numbering_fallback": 100,
+        }
+        rel.save()
+        _make_stream(account, group, name="Low", tvg_id="low", stream_chno=50)
+
+        result = _sync(account)
+
+        self.assertEqual(result["status"], "ok")
+        created = Channel.objects.get(auto_created=True, auto_created_by=account)
+        self.assertEqual(created.channel_number, 50.0)
+
+    def test_provider_number_above_end_is_honored_verbatim(self):
+        # Provider numbers above the configured End are also honored as-is;
+        # the End caps only the fallback for numberless streams.
+        account = _make_account()
+        group = _make_group(name="PPV")
+        rel = _attach_group_to_account(account, group)
+        rel.auto_sync_channel_end = 200
+        rel.custom_properties = {
+            "channel_numbering_mode": "provider",
+            "channel_numbering_fallback": 1,
+        }
+        rel.save()
+        _make_stream(account, group, name="High", tvg_id="high", stream_chno=5000)
+
+        result = _sync(account)
+
+        self.assertEqual(result["status"], "ok")
+        created = Channel.objects.get(auto_created=True, auto_created_by=account)
+        self.assertEqual(created.channel_number, 5000.0)
+
+    def test_provider_number_within_range_is_honored(self):
+        # An in-range provider number is used as-is.
+        account = _make_account()
+        group = _make_group(name="PPV")
+        rel = _attach_group_to_account(account, group)
+        rel.auto_sync_channel_end = 200
+        rel.custom_properties = {
+            "channel_numbering_mode": "provider",
+            "channel_numbering_fallback": 1,
+        }
+        rel.save()
+        _make_stream(account, group, name="Mid", tvg_id="mid", stream_chno=150)
+
+        result = _sync(account)
+
+        self.assertEqual(result["status"], "ok")
+        created = Channel.objects.get(auto_created=True, auto_created_by=account)
+        self.assertEqual(created.channel_number, 150.0)
+
+    def test_duplicate_provider_numbers_keep_one_and_fall_back_the_other(self):
+        # Two streams claim the same provider number (common in messy event
+        # feeds). One keeps it; the colliding one falls back to a different free
+        # number rather than being dropped or overwriting the first.
+        account = _make_account()
+        group = _make_group(name="PPV")
+        rel = _attach_group_to_account(account, group)
+        rel.custom_properties = {
+            "channel_numbering_mode": "provider",
+            "channel_numbering_fallback": 1,
+        }
+        rel.save()
+        _make_stream(account, group, name="A", tvg_id="a", stream_chno=77250)
+        _make_stream(account, group, name="B", tvg_id="b", stream_chno=77250)
+
+        result = _sync(account)
+
+        self.assertEqual(result["status"], "ok")
+        numbers = sorted(
+            Channel.objects.filter(
+                auto_created=True, auto_created_by=account
+            ).values_list("channel_number", flat=True)
+        )
+        self.assertEqual(len(numbers), 2)
+        self.assertIn(77250.0, numbers)
+        self.assertNotEqual(numbers[0], numbers[1])
+
+    def test_provider_number_colliding_with_manual_channel_falls_back(self):
+        # A provider number matching an existing channel must not overwrite it;
+        # the auto-created channel falls back to a different free number.
+        account = _make_account()
+        group = _make_group(name="PPV")
+        rel = _attach_group_to_account(account, group)
+        rel.custom_properties = {
+            "channel_numbering_mode": "provider",
+            "channel_numbering_fallback": 1,
+        }
+        rel.save()
+        manual = Channel.objects.create(name="Manual", channel_number=88250)
+        _make_stream(account, group, name="P", tvg_id="p", stream_chno=88250)
+
+        result = _sync(account)
+
+        self.assertEqual(result["status"], "ok")
+        created = Channel.objects.get(auto_created=True, auto_created_by=account)
+        self.assertNotEqual(created.channel_number, 88250.0)
+        manual.refresh_from_db()
+        self.assertEqual(manual.channel_number, 88250.0)
+
+    def test_provider_fallback_exhaustion_reports_visible_start(self):
+        # RANGE_EXHAUSTED must cite the fallback range (channel_numbering_fallback
+        # to End), not the hidden auto_sync_channel_start left from another mode.
+        account = _make_account()
+        group = _make_group(name="PPV")
+        rel = _attach_group_to_account(account, group)
+        rel.auto_sync_channel_start = 5000
+        rel.auto_sync_channel_end = 102
+        rel.custom_properties = {
+            "channel_numbering_mode": "provider",
+            "channel_numbering_fallback": 100,
+        }
+        rel.save()
+        for i in range(4):
+            _make_stream(account, group, name=f"S{i}", tvg_id=f"s{i}")
+
+        result = _sync(account)
+
+        self.assertEqual(result["channels_created"], 3)
+        self.assertEqual(result["channels_failed"], 1)
+        error = result["failed_stream_details"][0]["error"]
+        self.assertIn("100-102", error)
+        self.assertNotIn("5000", error)
+
+
+class CrossModeNumberingFieldTests(TestCase):
+    """
+    Each numbering mode's UI exposes only a subset of the persisted fields,
+    and switching modes does not reset the others. The backend must therefore
+    read only the fields a mode actually owns, so a stale/hidden value left by
+    another mode cannot silently change numbering. These guard the two
+    remaining facets of that family (the provider-floor facet is covered by
+    ProviderNumberingHonorsProviderNumberTests).
+    """
+
+    def _restamp(self, account):
+        Stream.objects.filter(m3u_account=account).update(
+            last_seen=timezone.now()
+        )
+
+    def test_next_available_ignores_configured_end(self):
+        # next_available exposes no Start/End in its UI, so a stale End left
+        # over from a prior mode must not cap it. Every stream gets the lowest
+        # free number from 1 regardless of the End.
+        # Fail signature: streams beyond the End fail = next_available honoring
+        # a hidden cap.
+        account = _make_account()
+        group = _make_group(name="PPV")
+        rel = _attach_group_to_account(account, group)
+        rel.auto_sync_channel_start = 1
+        rel.auto_sync_channel_end = 3  # stale cap from a prior mode
+        rel.custom_properties = {"channel_numbering_mode": "next_available"}
+        rel.save()
+        for i in range(5):
+            _make_stream(account, group, name=f"S{i}", tvg_id=f"s{i}")
+
+        result = _sync(account)
+
+        self.assertEqual(result["status"], "ok")
+        self.assertEqual(result["channels_created"], 5)
+        self.assertEqual(result["channels_failed"], 0)
+
+    def test_provider_channels_outside_range_are_not_deleted(self):
+        # Range enforcement (the overflow-delete) is fixed-mode only. A provider
+        # channel whose number is outside [start, end] is authoritative and must
+        # survive sync, not be deleted and churned into a new row.
+        # Fail signature: channels_deleted > 0 on the second sync = overflow
+        # delete firing in provider mode.
+        account = _make_account()
+        group = _make_group(name="PPV")
+        rel = _attach_group_to_account(account, group)
+        rel.auto_sync_channel_end = 200
+        rel.custom_properties = {
+            "channel_numbering_mode": "provider",
+            "channel_numbering_fallback": 1,
+        }
+        rel.save()
+        _make_stream(account, group, name="High", tvg_id="high", stream_chno=5000)
+
+        first = _sync(account)
+        self.assertEqual(first["channels_created"], 1)
+        original = Channel.objects.get(auto_created=True, auto_created_by=account)
+        self.assertEqual(original.channel_number, 5000.0)
+
+        self._restamp(account)
+        second = _sync(account)
+
+        self.assertEqual(second["channels_deleted"], 0)
+        survivor = Channel.objects.get(auto_created=True, auto_created_by=account)
+        self.assertEqual(survivor.id, original.id)
+        self.assertEqual(survivor.channel_number, 5000.0)
+
+    def test_next_available_channels_outside_stale_range_not_deleted(self):
+        # Same gate for next_available: tightening a stale End must not delete
+        # already-assigned channels (range enforcement is fixed-mode only).
+        account = _make_account()
+        group = _make_group(name="PPV")
+        rel = _attach_group_to_account(account, group)
+        rel.auto_sync_channel_start = 1
+        rel.auto_sync_channel_end = None
+        rel.custom_properties = {"channel_numbering_mode": "next_available"}
+        rel.save()
+        for i in range(5):
+            _make_stream(account, group, name=f"S{i}", tvg_id=f"s{i}")
+
+        self.assertEqual(_sync(account)["channels_created"], 5)
+
+        rel.auto_sync_channel_end = 3  # stale cap appears
+        rel.save()
+        self._restamp(account)
+        second = _sync(account)
+
+        self.assertEqual(second["channels_deleted"], 0)
+        self.assertEqual(
+            Channel.objects.filter(
+                auto_created=True, auto_created_by=account
+            ).count(),
+            5,
+        )
diff --git a/apps/m3u/tests/test_xc_live_url.py b/apps/m3u/tests/test_xc_live_url.py
new file mode 100644
index 00000000..8353241d
--- /dev/null
+++ b/apps/m3u/tests/test_xc_live_url.py
@@ -0,0 +1,139 @@
+"""Tests for XC stream URL normalization and on-demand URL building."""
+
+from django.test import TestCase
+
+from apps.channels.models import Stream
+from apps.m3u.models import M3UAccount, M3UAccountProfile
+from apps.m3u.tasks import get_transformed_credentials
+from apps.proxy.live_proxy.url_utils import _resolve_live_stream_url
+from apps.vod.models import Episode, M3UEpisodeRelation, M3UMovieRelation, Movie, Series
+from core.xtream_codes import normalize_server_url
+
+
+class NormalizeServerUrlTests(TestCase):
+    def test_preserves_sub_path(self):
+        url = "https://myserver.fun/server1"
+        self.assertEqual(normalize_server_url(url), "https://myserver.fun/server1")
+
+    def test_strips_player_api_php_and_query_params(self):
+        url = "https://myserver.fun/server1/player_api.php?username=foo&password=bar"
+        self.assertEqual(normalize_server_url(url), "https://myserver.fun/server1")
+
+    def test_strips_trailing_slash(self):
+        url = "https://myserver.fun/server1/"
+        self.assertEqual(normalize_server_url(url), "https://myserver.fun/server1")
+
+    def test_nested_sub_path_with_php_endpoint(self):
+        url = "http://server/Pluto/gb/player_api.php"
+        self.assertEqual(normalize_server_url(url), "http://server/Pluto/gb")
+
+
+class GetTransformedCredentialsTests(TestCase):
+    def test_returns_normalized_server_url(self):
+        account = M3UAccount.objects.create(
+            name="Sub-path XC",
+            account_type="XC",
+            server_url="https://myserver.fun/server1/player_api.php?username=foo",
+            username="alice",
+            password="secret",
+        )
+        profile = M3UAccountProfile.objects.get(m3u_account=account, is_default=True)
+
+        server_url, username, password = get_transformed_credentials(account, profile)
+
+        self.assertEqual(server_url, "https://myserver.fun/server1")
+        self.assertEqual(username, "alice")
+        self.assertEqual(password, "secret")
+
+
+class ResolveLiveStreamUrlTests(TestCase):
+    def test_builds_url_from_normalized_base_not_raw_account_url(self):
+        account = M3UAccount.objects.create(
+            name="Live sub-path",
+            account_type="XC",
+            server_url="https://myserver.fun/server1/player_api.php?username=foo",
+            username="alice",
+            password="secret",
+        )
+        profile = M3UAccountProfile.objects.get(m3u_account=account, is_default=True)
+        stream = Stream.objects.create(
+            name="Test Channel",
+            m3u_account=account,
+            stream_id="12345",
+            url="https://myserver.fun/server1/live/olduser/oldpass/12345.ts",
+        )
+
+        url = _resolve_live_stream_url(stream, account, profile)
+
+        self.assertEqual(
+            url,
+            "https://myserver.fun/server1/live/alice/secret/12345.ts",
+        )
+
+    def test_std_account_uses_stored_stream_url(self):
+        account = M3UAccount.objects.create(
+            name="STD account",
+            account_type="STD",
+            server_url="https://example.com/list.m3u",
+            username="alice",
+            password="secret",
+        )
+        profile = M3UAccountProfile.objects.get(m3u_account=account, is_default=True)
+        stream = Stream.objects.create(
+            name="STD Stream",
+            m3u_account=account,
+            url="https://provider.example/stream/abc123",
+        )
+
+        url = _resolve_live_stream_url(stream, account, profile)
+
+        self.assertEqual(url, "https://provider.example/stream/abc123")
+
+
+class VodStreamUrlTests(TestCase):
+    def setUp(self):
+        self.account = M3UAccount.objects.create(
+            name="VOD sub-path",
+            account_type="XC",
+            server_url="https://myserver.fun/server1/player_api.php?username=foo",
+            username="alice",
+            password="secret",
+        )
+
+    def test_movie_relation_builds_normalized_url(self):
+        movie = Movie.objects.create(name="Test Movie")
+        relation = M3UMovieRelation.objects.create(
+            m3u_account=self.account,
+            movie=movie,
+            stream_id="999",
+            container_extension="mkv",
+        )
+
+        url = relation.get_stream_url()
+
+        self.assertEqual(
+            url,
+            "https://myserver.fun/server1/movie/alice/secret/999.mkv",
+        )
+
+    def test_episode_relation_builds_normalized_url(self):
+        series = Series.objects.create(name="Test Series")
+        episode = Episode.objects.create(
+            series=series,
+            name="Pilot",
+            season_number=1,
+            episode_number=1,
+        )
+        relation = M3UEpisodeRelation.objects.create(
+            m3u_account=self.account,
+            episode=episode,
+            stream_id="888",
+            container_extension="mp4",
+        )
+
+        url = relation.get_stream_url()
+
+        self.assertEqual(
+            url,
+            "https://myserver.fun/server1/series/alice/secret/888.mp4",
+        )
diff --git a/apps/output/epg.py b/apps/output/epg.py
new file mode 100644
index 00000000..626b21aa
--- /dev/null
+++ b/apps/output/epg.py
@@ -0,0 +1,1727 @@
+"""XMLTV (EPG) output generation.
+
+Consolidates the EPG export logic that backs the `/epg` endpoint and the XC
+XMLTV endpoint: real programme streaming, dummy/custom dummy program
+generation, and the streaming XMLTV builder. HTTP endpoints live in views.py
+and call into this module; Redis chunk caching lives in streaming_chunk_cache.py.
+"""
+
+import html
+import logging
+from datetime import datetime, timedelta
+
+import regex
+
+from django.db.models import Prefetch
+from django.http import Http404
+from django.urls import reverse
+from django.utils import timezone as django_timezone
+
+from apps.channels.models import Channel, ChannelProfile, Stream
+from apps.channels.utils import format_channel_number
+from apps.epg.models import ProgramData
+from apps.output.streaming_chunk_cache import stream_cached_response
+from core.utils import build_absolute_uri_with_port, log_system_event
+
+logger = logging.getLogger(__name__)
+
+_EPG_CHANNEL_XML_BATCH_SIZE = 200
+_EPG_PROGRAM_YIELD_BATCH_SIZE = 1000
+_EPG_PROGRAM_DB_CHUNK_SIZE = 20000
+
+
+def _programme_overlaps_export_window(start_time, end_time, lookback_cutoff, cutoff_date):
+    if end_time < lookback_cutoff:
+        return False
+    if cutoff_date is not None and start_time >= cutoff_date:
+        return False
+    return True
+
+
+def _ceil_to_half_hour(dt):
+    """Round a datetime up to the next :00 or :30 boundary."""
+    original = dt.replace(microsecond=0)
+    aligned = dt.replace(second=0, microsecond=0)
+    remainder = aligned.minute % 30
+    if remainder != 0:
+        aligned += timedelta(minutes=30 - remainder)
+    if aligned < original:
+        aligned += timedelta(minutes=30)
+    return aligned
+
+
+def _epg_export_teardown():
+    from core.utils import spawn_memory_trim
+
+    spawn_memory_trim(close_connections=True)
+
+
+def _ordered_channel_streams(channel):
+    """Return a channel's streams ordered by channelstream join order."""
+    prefetched = getattr(channel, '_prefetched_objects_cache', {}).get('streams')
+    if prefetched is not None:
+        return list(prefetched)
+    return list(channel.streams.all().order_by('channelstream__order'))
+
+
+def _pattern_match_name_from_custom_props(channel, effective_name, custom_props):
+    """Name used for custom dummy EPG regex matching (channel or stream title).
+
+    Returns (name, stream_lookup_failed). stream_lookup_failed is True only when
+    name_source is 'stream' but the configured index is missing or out of range.
+    """
+    if custom_props.get('name_source') != 'stream':
+        return effective_name, False
+    stream_index = custom_props.get('stream_index', 1) - 1
+    streams = _ordered_channel_streams(channel)
+    if 0 <= stream_index < len(streams):
+        return streams[stream_index].name, False
+    return effective_name, True
+
+
+def generate_fallback_programs(channel_id, channel_name, now, num_days, program_length_hours, fallback_title, fallback_description):
+    """
+    Generate dummy programs using custom fallback templates when patterns don't match.
+
+    Args:
+        channel_id: Channel ID for the programs
+        channel_name: Channel name to use as fallback in templates
+        now: Current datetime (in UTC)
+        num_days: Number of days to generate programs for
+        program_length_hours: Length of each program in hours
+        fallback_title: Custom fallback title template (empty string if not provided)
+        fallback_description: Custom fallback description template (empty string if not provided)
+
+    Returns:
+        List of program dictionaries
+    """
+    programs = []
+
+    # Use custom fallback title or channel name as default
+    title = fallback_title if fallback_title else channel_name
+
+    # Use custom fallback description or a simple default message
+    if fallback_description:
+        description = fallback_description
+    else:
+        description = f"EPG information is currently unavailable for {channel_name}"
+
+    # Create programs for each day
+    for day in range(num_days):
+        day_start = now + timedelta(days=day)
+
+        # Create programs with specified length throughout the day
+        for hour_offset in range(0, 24, program_length_hours):
+            # Calculate program start and end times
+            start_time = day_start + timedelta(hours=hour_offset)
+            end_time = start_time + timedelta(hours=program_length_hours)
+
+            programs.append({
+                "channel_id": channel_id,
+                "start_time": start_time,
+                "end_time": end_time,
+                "title": title,
+                "description": description,
+            })
+
+    return programs
+
+
+def generate_dummy_programs(
+    channel_id,
+    channel_name,
+    num_days=1,
+    program_length_hours=4,
+    epg_source=None,
+    export_lookback=None,
+    export_cutoff=None,
+):
+    """
+    Generate dummy EPG programs for channels.
+
+    If epg_source is provided and it's a custom dummy EPG with patterns,
+    use those patterns to generate programs from the channel title.
+    Otherwise, generate default dummy programs.
+
+    Args:
+        channel_id: Channel ID for the programs
+        channel_name: Channel title/name
+        num_days: Number of days to generate programs for
+        program_length_hours: Length of each program in hours
+        epg_source: Optional EPGSource for custom dummy EPG with patterns
+
+    Returns:
+        List of program dictionaries
+    """
+    # Get current time rounded to hour
+    now = django_timezone.now()
+    now = now.replace(minute=0, second=0, microsecond=0)
+
+    # Check if this is a custom dummy EPG with regex patterns
+    if epg_source and epg_source.source_type == 'dummy' and epg_source.custom_properties:
+        custom_programs = generate_custom_dummy_programs(
+            channel_id, channel_name, now, num_days,
+            epg_source.custom_properties,
+            export_lookback=export_lookback,
+            export_cutoff=export_cutoff,
+        )
+        if custom_programs is not None:
+            return custom_programs
+
+        logger.info(f"Custom pattern didn't match for '{channel_name}', checking for custom fallback templates")
+
+        custom_props = epg_source.custom_properties
+        fallback_title = custom_props.get('fallback_title_template', '').strip()
+        fallback_description = custom_props.get('fallback_description_template', '').strip()
+
+        if fallback_title or fallback_description:
+            logger.info(f"Using custom fallback templates for '{channel_name}'")
+            return generate_fallback_programs(
+                channel_id, channel_name, now, num_days,
+                program_length_hours, fallback_title, fallback_description
+            )
+        logger.info(f"No custom fallback templates found, using default dummy EPG")
+
+    # Default humorous program descriptions based on time of day
+    time_descriptions = {
+        (0, 4): [
+            f"Late Night with {channel_name} - Where insomniacs unite!",
+            f"The 'Why Am I Still Awake?' Show on {channel_name}",
+            f"Counting Sheep - A {channel_name} production for the sleepless",
+        ],
+        (4, 8): [
+            f"Dawn Patrol - Rise and shine with {channel_name}!",
+            f"Early Bird Special - Coffee not included",
+            f"Morning Zombies - Before coffee viewing on {channel_name}",
+        ],
+        (8, 12): [
+            f"Mid-Morning Meetings - Pretend you're paying attention while watching {channel_name}",
+            f"The 'I Should Be Working' Hour on {channel_name}",
+            f"Productivity Killer - {channel_name}'s daytime programming",
+        ],
+        (12, 16): [
+            f"Lunchtime Laziness with {channel_name}",
+            f"The Afternoon Slump - Brought to you by {channel_name}",
+            f"Post-Lunch Food Coma Theater on {channel_name}",
+        ],
+        (16, 20): [
+            f"Rush Hour - {channel_name}'s alternative to traffic",
+            f"The 'What's For Dinner?' Debate on {channel_name}",
+            f"Evening Escapism - {channel_name}'s remedy for reality",
+        ],
+        (20, 24): [
+            f"Prime Time Placeholder - {channel_name}'s finest not-programming",
+            f"The 'Netflix Was Too Complicated' Show on {channel_name}",
+            f"Family Argument Avoider - Courtesy of {channel_name}",
+        ],
+    }
+
+    programs = []
+
+    # Create programs for each day
+    for day in range(num_days):
+        day_start = now + timedelta(days=day)
+
+        # Create programs with specified length throughout the day
+        for hour_offset in range(0, 24, program_length_hours):
+            # Calculate program start and end times
+            start_time = day_start + timedelta(hours=hour_offset)
+            end_time = start_time + timedelta(hours=program_length_hours)
+
+            # Get the hour for selecting a description
+            hour = start_time.hour
+
+            # Find the appropriate time slot for description
+            for time_range, descriptions in time_descriptions.items():
+                start_range, end_range = time_range
+                if start_range <= hour < end_range:
+                    # Pick a description using the sum of the hour and day as seed
+                    # This makes it somewhat random but consistent for the same timeslot
+                    description = descriptions[(hour + day) % len(descriptions)]
+                    break
+            else:
+                # Fallback description if somehow no range matches
+                description = f"Placeholder program for {channel_name} - EPG data went on vacation"
+
+            programs.append({
+                "channel_id": channel_id,
+                "start_time": start_time,
+                "end_time": end_time,
+                "title": channel_name,
+                "description": description,
+            })
+
+    return programs
+
+
+def generate_custom_dummy_programs(
+    channel_id,
+    channel_name,
+    now,
+    num_days,
+    custom_properties,
+    export_lookback=None,
+    export_cutoff=None,
+):
+    """
+    Generate programs using custom dummy EPG regex patterns.
+
+    Extracts information from channel title using regex patterns and generates
+    programs based on the extracted data.
+
+    TIMEZONE HANDLING:
+    ------------------
+    The timezone parameter specifies the timezone of the event times in your channel
+    titles using standard timezone names (e.g., 'US/Eastern', 'US/Pacific', 'Europe/London').
+    DST (Daylight Saving Time) is handled automatically by pytz.
+
+    Examples:
+    - Channel: "NHL 01: Bruins VS Maple Leafs @ 8:00PM ET"
+    - Set timezone = "US/Eastern"
+    - In October (DST): 8:00PM EDT → 12:00AM UTC (automatically uses UTC-4)
+    - In January (no DST): 8:00PM EST → 1:00AM UTC (automatically uses UTC-5)
+
+    Args:
+        channel_id: Channel ID for the programs
+        channel_name: Channel title to parse
+        now: Current datetime (in UTC)
+        num_days: Number of days to generate programs for
+        custom_properties: Dict with title_pattern, time_pattern, templates, etc.
+            - timezone: Timezone name (e.g., 'US/Eastern')
+
+    Returns:
+        List of program dictionaries with start_time/end_time in UTC
+    """
+    import pytz
+
+    logger.info(f"Generating custom dummy programs for channel: {channel_name}")
+
+    # Extract patterns from custom properties
+    title_pattern = custom_properties.get('title_pattern', '')
+    time_pattern = custom_properties.get('time_pattern', '')
+    date_pattern = custom_properties.get('date_pattern', '')
+
+    # Get timezone name (e.g., 'US/Eastern', 'US/Pacific', 'Europe/London')
+    timezone_value = custom_properties.get('timezone', 'UTC')
+    output_timezone_value = custom_properties.get('output_timezone', '')  # Optional: display times in different timezone
+    program_duration = custom_properties.get('program_duration', 180)  # Minutes
+    title_template = custom_properties.get('title_template', '')
+    subtitle_template = custom_properties.get('subtitle_template', '')
+    description_template = custom_properties.get('description_template', '')
+
+    # Templates for upcoming/ended programs
+    upcoming_title_template = custom_properties.get('upcoming_title_template', '')
+    upcoming_description_template = custom_properties.get('upcoming_description_template', '')
+    ended_title_template = custom_properties.get('ended_title_template', '')
+    ended_description_template = custom_properties.get('ended_description_template', '')
+
+    # Image URL templates
+    channel_logo_url_template = custom_properties.get('channel_logo_url', '')
+    program_poster_url_template = custom_properties.get('program_poster_url', '')
+
+    # EPG metadata options
+    category_string = custom_properties.get('category', '')
+    # Split comma-separated categories and strip whitespace, filter out empty strings
+    categories = [cat.strip() for cat in category_string.split(',') if cat.strip()] if category_string else []
+    include_date = custom_properties.get('include_date', True)
+    include_live = custom_properties.get('include_live', False)
+    include_new = custom_properties.get('include_new', False)
+
+    # Parse timezone name
+    try:
+        source_tz = pytz.timezone(timezone_value)
+        logger.debug(f"Using timezone: {timezone_value} (DST will be handled automatically)")
+    except pytz.exceptions.UnknownTimeZoneError:
+        logger.warning(f"Unknown timezone: {timezone_value}, defaulting to UTC")
+        source_tz = pytz.utc
+
+    # Parse output timezone if provided (for display purposes)
+    output_tz = None
+    if output_timezone_value:
+        try:
+            output_tz = pytz.timezone(output_timezone_value)
+            logger.debug(f"Using output timezone for display: {output_timezone_value}")
+        except pytz.exceptions.UnknownTimeZoneError:
+            logger.warning(f"Unknown output timezone: {output_timezone_value}, will use source timezone")
+            output_tz = None
+
+    if not title_pattern:
+        logger.warning(f"No title_pattern in custom_properties, falling back to default")
+        return None
+
+    logger.debug(f"Title pattern from DB: {repr(title_pattern)}")
+
+    # Convert PCRE/JavaScript named groups (?<name>) to Python format (?P<name>)
+    # This handles patterns created with JavaScript regex syntax
+    # Use negative lookahead to avoid matching lookbehind (?<=) and negative lookbehind (?<!)
+    title_pattern = regex.sub(r'\(\?<(?![=!])([^>]+)>', r'(?P<\1>', title_pattern)
+    logger.debug(f"Converted title pattern: {repr(title_pattern)}")
+
+    # Compile regex patterns using the enhanced regex module
+    # (supports variable-width lookbehinds like JavaScript)
+    try:
+        title_regex = regex.compile(title_pattern)
+    except Exception as e:
+        logger.error(f"Invalid title regex pattern after conversion: {e}")
+        logger.error(f"Pattern was: {repr(title_pattern)}")
+        return None
+
+    time_regex = None
+    if time_pattern:
+        # Convert PCRE/JavaScript named groups to Python format
+        # Use negative lookahead to avoid matching lookbehind (?<=) and negative lookbehind (?<!)
+        time_pattern = regex.sub(r'\(\?<(?![=!])([^>]+)>', r'(?P<\1>', time_pattern)
+        logger.debug(f"Converted time pattern: {repr(time_pattern)}")
+        try:
+            time_regex = regex.compile(time_pattern)
+        except Exception as e:
+            logger.warning(f"Invalid time regex pattern after conversion: {e}")
+            logger.warning(f"Pattern was: {repr(time_pattern)}")
+
+    # Compile date regex if provided
+    date_regex = None
+    if date_pattern:
+        # Convert PCRE/JavaScript named groups to Python format
+        # Use negative lookahead to avoid matching lookbehind (?<=) and negative lookbehind (?<!)
+        date_pattern = regex.sub(r'\(\?<(?![=!])([^>]+)>', r'(?P<\1>', date_pattern)
+        logger.debug(f"Converted date pattern: {repr(date_pattern)}")
+        try:
+            date_regex = regex.compile(date_pattern)
+        except Exception as e:
+            logger.warning(f"Invalid date regex pattern after conversion: {e}")
+            logger.warning(f"Pattern was: {repr(date_pattern)}")
+
+    # Try to match the channel name with the title pattern
+    # Use search() instead of match() to match JavaScript behavior where .match() searches anywhere in the string
+    title_match = title_regex.search(channel_name)
+    if not title_match:
+        logger.debug(f"Channel name '{channel_name}' doesn't match title pattern")
+        return None
+
+    groups = title_match.groupdict()
+    logger.debug(f"Title pattern matched. Groups: {groups}")
+
+    # Helper function to format template with matched groups
+    def format_template(template, groups, url_encode=False):
+        """Replace {groupname} placeholders with matched group values
+
+        Args:
+            template: Template string with {groupname} placeholders
+            groups: Dict of group names to values
+            url_encode: If True, URL encode the group values for safe use in URLs
+        """
+        if not template:
+            return ''
+        result = template
+        for key, value in groups.items():
+            if url_encode and value:
+                # URL encode the value to handle spaces and special characters
+                from urllib.parse import quote
+                encoded_value = quote(str(value), safe='')
+                result = result.replace(f'{{{key}}}', encoded_value)
+            else:
+                result = result.replace(f'{{{key}}}', str(value) if value else '')
+        return result
+
+    # Extract time from title if time pattern exists
+    time_info = None
+    time_groups = {}
+    if time_regex:
+        time_match = time_regex.search(channel_name)
+        if time_match:
+            time_groups = time_match.groupdict()
+            try:
+                hour = int(time_groups.get('hour'))
+                # Handle optional minute group - could be None if not captured
+                minute_value = time_groups.get('minute')
+                minute = int(minute_value) if minute_value is not None else 0
+                ampm = time_groups.get('ampm')
+                ampm = ampm.lower() if ampm else None
+
+                # Determine if this is 12-hour or 24-hour format
+                if ampm in ('am', 'pm'):
+                    # 12-hour format: convert to 24-hour
+                    if ampm == 'pm' and hour != 12:
+                        hour += 12
+                    elif ampm == 'am' and hour == 12:
+                        hour = 0
+                    logger.debug(f"Extracted time (12-hour): {hour}:{minute:02d} {ampm}")
+                else:
+                    # 24-hour format: hour is already in 24-hour format
+                    # Validate that it's actually a 24-hour time (0-23)
+                    if hour > 23:
+                        logger.warning(f"Invalid 24-hour time: {hour}. Must be 0-23.")
+                        hour = hour % 24  # Wrap around just in case
+                    logger.debug(f"Extracted time (24-hour): {hour}:{minute:02d}")
+
+                time_info = {'hour': hour, 'minute': minute}
+            except (ValueError, TypeError) as e:
+                logger.warning(f"Error parsing time: {e}")
+
+    # Extract date from title if date pattern exists
+    date_info = None
+    date_groups = {}
+    if date_regex:
+        date_match = date_regex.search(channel_name)
+        if date_match:
+            date_groups = date_match.groupdict()
+            try:
+                # Support various date group names: month, day, year
+                month_str = date_groups.get('month', '')
+                day_str = date_groups.get('day', '')
+                year_str = date_groups.get('year', '')
+
+                # Parse day - default to current day if empty or invalid
+                day = int(day_str) if day_str else now.day
+
+                # Parse year - default to current year if empty or invalid (matches frontend behavior)
+                year = int(year_str) if year_str else now.year
+
+                # Parse month - can be numeric (1-12) or text (Jan, January, etc.)
+                month = None
+                if month_str:
+                    if month_str.isdigit():
+                        month = int(month_str)
+                    else:
+                        # Try to parse text month names
+                        import calendar
+                        month_str_lower = month_str.lower()
+                        # Check full month names
+                        for i, month_name in enumerate(calendar.month_name):
+                            if month_name.lower() == month_str_lower:
+                                month = i
+                                break
+                        # Check abbreviated month names if not found
+                        if month is None:
+                            for i, month_abbr in enumerate(calendar.month_abbr):
+                                if month_abbr.lower() == month_str_lower:
+                                    month = i
+                                    break
+
+                # Default to current month if not extracted or invalid
+                if month is None:
+                    month = now.month
+
+                if month and 1 <= month <= 12 and 1 <= day <= 31:
+                    date_info = {'year': year, 'month': month, 'day': day}
+                    logger.debug(f"Extracted date: {year}-{month:02d}-{day:02d}")
+                else:
+                    logger.warning(f"Invalid date values: month={month}, day={day}, year={year}")
+            except (ValueError, TypeError) as e:
+                logger.warning(f"Error parsing date: {e}")
+
+    # Merge title groups, time groups, and date groups for template formatting
+    all_groups = {**groups, **time_groups, **date_groups}
+
+    # Add normalized versions of all groups for cleaner URLs
+    # These remove all non-alphanumeric characters and convert to lowercase
+    for key, value in list(all_groups.items()):
+        if value:
+            # Remove all non-alphanumeric characters (except spaces temporarily)
+            # then replace spaces with nothing, and convert to lowercase
+            normalized = regex.sub(r'[^a-zA-Z0-9\s]', '', str(value))
+            normalized = regex.sub(r'\s+', '', normalized).lower()
+            all_groups[f'{key}_normalize'] = normalized
+
+    # Format channel logo URL if template provided (with URL encoding)
+    channel_logo_url = None
+    if channel_logo_url_template:
+        channel_logo_url = format_template(channel_logo_url_template, all_groups, url_encode=True)
+        logger.debug(f"Formatted channel logo URL: {channel_logo_url}")
+
+    # Format program poster URL if template provided (with URL encoding)
+    program_poster_url = None
+    if program_poster_url_template:
+        program_poster_url = format_template(program_poster_url_template, all_groups, url_encode=True)
+        logger.debug(f"Formatted program poster URL: {program_poster_url}")
+
+    # Add formatted time strings for better display (handles minutes intelligently)
+    if time_info:
+        hour_24 = time_info['hour']
+        minute = time_info['minute']
+
+        # Determine the base date to use for placeholders
+        # If date was extracted, use it; otherwise use current date
+        if date_info:
+            base_date = datetime(date_info['year'], date_info['month'], date_info['day'])
+        else:
+            base_date = datetime.now()
+
+        # If output_timezone is specified, convert the display time to that timezone
+        if output_tz:
+            # Create a datetime in the source timezone using the base date
+            temp_date = source_tz.localize(base_date.replace(hour=hour_24, minute=minute, second=0, microsecond=0))
+            # Convert to output timezone
+            temp_date_output = temp_date.astimezone(output_tz)
+            # Extract converted hour and minute for display
+            hour_24 = temp_date_output.hour
+            minute = temp_date_output.minute
+            logger.debug(f"Converted display time from {source_tz} to {output_tz}: {hour_24}:{minute:02d}")
+
+            # Add date placeholders based on the OUTPUT timezone
+            # This ensures {date}, {month}, {day}, {year} reflect the converted timezone
+            all_groups['date'] = temp_date_output.strftime('%Y-%m-%d')
+            all_groups['month'] = str(temp_date_output.month)
+            all_groups['day'] = str(temp_date_output.day)
+            all_groups['year'] = str(temp_date_output.year)
+            logger.debug(f"Converted date placeholders to {output_tz}: {all_groups['date']}")
+        else:
+            # No output timezone conversion - use source timezone for date
+            # Create temp date to get proper date in source timezone using the base date
+            temp_date_source = source_tz.localize(base_date.replace(hour=hour_24, minute=minute, second=0, microsecond=0))
+            all_groups['date'] = temp_date_source.strftime('%Y-%m-%d')
+            all_groups['month'] = str(temp_date_source.month)
+            all_groups['day'] = str(temp_date_source.day)
+            all_groups['year'] = str(temp_date_source.year)
+
+        # Format 24-hour start time string - only include minutes if non-zero
+        if minute > 0:
+            all_groups['starttime24'] = f"{hour_24}:{minute:02d}"
+        else:
+            all_groups['starttime24'] = f"{hour_24:02d}:00"
+
+        # Convert 24-hour to 12-hour format for {starttime} placeholder
+        # Note: hour_24 is ALWAYS in 24-hour format at this point (converted earlier if needed)
+        ampm = 'AM' if hour_24 < 12 else 'PM'
+        hour_12 = hour_24
+        if hour_24 == 0:
+            hour_12 = 12
+        elif hour_24 > 12:
+            hour_12 = hour_24 - 12
+
+        # Format 12-hour start time string - only include minutes if non-zero
+        if minute > 0:
+            all_groups['starttime'] = f"{hour_12}:{minute:02d} {ampm}"
+        else:
+            all_groups['starttime'] = f"{hour_12} {ampm}"
+
+        # Format long version that always includes minutes (e.g., "9:00 PM" instead of "9 PM")
+        all_groups['starttime_long'] = f"{hour_12}:{minute:02d} {ampm}"
+
+        # Calculate end time based on program duration
+        # Create a datetime for calculations
+        temp_start = datetime.now(source_tz).replace(hour=hour_24, minute=minute, second=0, microsecond=0)
+        temp_end = temp_start + timedelta(minutes=program_duration)
+
+        # Extract end time components (already in correct timezone if output_tz was applied above)
+        end_hour_24 = temp_end.hour
+        end_minute = temp_end.minute
+
+        # Format 24-hour end time string - only include minutes if non-zero
+        if end_minute > 0:
+            all_groups['endtime24'] = f"{end_hour_24}:{end_minute:02d}"
+        else:
+            all_groups['endtime24'] = f"{end_hour_24:02d}:00"
+
+        # Convert 24-hour to 12-hour format for {endtime} placeholder
+        end_ampm = 'AM' if end_hour_24 < 12 else 'PM'
+        end_hour_12 = end_hour_24
+        if end_hour_24 == 0:
+            end_hour_12 = 12
+        elif end_hour_24 > 12:
+            end_hour_12 = end_hour_24 - 12
+
+        # Format 12-hour end time string - only include minutes if non-zero
+        if end_minute > 0:
+            all_groups['endtime'] = f"{end_hour_12}:{end_minute:02d} {end_ampm}"
+        else:
+            all_groups['endtime'] = f"{end_hour_12} {end_ampm}"
+
+        # Format long version that always includes minutes (e.g., "9:00 PM" instead of "9 PM")
+        all_groups['endtime_long'] = f"{end_hour_12}:{end_minute:02d} {end_ampm}"
+
+    # Generate programs
+    programs = []
+
+    # If we have extracted time AND date, the event happens on a SPECIFIC date
+    # If we have time but NO date, generate for multiple days (existing behavior)
+    # All other days and times show "Upcoming" before or "Ended" after
+    event_happened = False
+
+    # Determine how many iterations we need
+    if date_info and time_info:
+        # Specific date extracted - only generate for that one date
+        iterations = 1
+        logger.debug(f"Date extracted, generating single event for specific date")
+    else:
+        # No specific date - use num_days (existing behavior)
+        iterations = num_days
+
+    for day in range(iterations):
+        event_overlaps_window = True
+        if date_info and time_info:
+            current_date = datetime(
+                date_info['year'],
+                date_info['month'],
+                date_info['day'],
+            ).date()
+            event_start_naive = datetime.combine(
+                current_date,
+                datetime.min.time().replace(
+                    hour=time_info['hour'],
+                    minute=time_info['minute'],
+                ),
+            )
+            try:
+                event_start_utc = source_tz.localize(event_start_naive).astimezone(pytz.utc)
+            except Exception as e:
+                logger.error(f"Error localizing time to {source_tz}: {e}")
+                event_start_utc = django_timezone.make_aware(event_start_naive, pytz.utc)
+            event_end_utc = event_start_utc + timedelta(minutes=program_duration)
+
+            lookback = export_lookback if export_lookback is not None else now
+            event_overlaps_window = _programme_overlaps_export_window(
+                event_start_utc, event_end_utc, lookback, export_cutoff
+            )
+            if not event_overlaps_window:
+                logger.debug(
+                    "Custom dummy event outside export window; filling window only: %s",
+                    channel_name,
+                )
+                event_happened = event_end_utc < lookback
+                day_start = _ceil_to_half_hour(lookback)
+                if export_cutoff is not None:
+                    day_end = export_cutoff
+                else:
+                    day_end = now + timedelta(days=num_days if num_days > 0 else 3)
+            else:
+                day_start = source_tz.localize(
+                    datetime.combine(current_date, datetime.min.time())
+                ).astimezone(pytz.utc)
+                day_end = day_start + timedelta(days=1)
+                if export_lookback is not None:
+                    day_start = max(day_start, export_lookback)
+                if export_cutoff is not None:
+                    day_end = min(day_end, export_cutoff)
+        else:
+            day_start = now + timedelta(days=day)
+            day_end = day_start + timedelta(days=1)
+            if export_lookback is not None:
+                day_start = max(day_start, export_lookback)
+            if export_cutoff is not None:
+                day_end = min(day_end, export_cutoff)
+
+        if day_start >= day_end:
+            continue
+
+        if time_info:
+            if not date_info:
+                now_in_source_tz = now.astimezone(source_tz)
+                current_date = (now_in_source_tz + timedelta(days=day)).date()
+                logger.debug(f"No date extracted, using day offset in {source_tz}: {current_date}")
+
+                event_start_naive = datetime.combine(
+                    current_date,
+                    datetime.min.time().replace(
+                        hour=time_info['hour'],
+                        minute=time_info['minute'],
+                    ),
+                )
+                try:
+                    event_start_local = source_tz.localize(event_start_naive)
+                    event_start_utc = event_start_local.astimezone(pytz.utc)
+                    logger.debug(f"Converted {event_start_local} to UTC: {event_start_utc}")
+                except Exception as e:
+                    logger.error(f"Error localizing time to {source_tz}: {e}")
+                    event_start_utc = django_timezone.make_aware(event_start_naive, pytz.utc)
+
+                event_end_utc = event_start_utc + timedelta(minutes=program_duration)
+
+                lookback = export_lookback if export_lookback is not None else now
+                if not _programme_overlaps_export_window(
+                    event_start_utc, event_end_utc, lookback, export_cutoff
+                ):
+                    continue
+            else:
+                logger.debug(f"Using extracted date: {current_date}")
+
+            # Pre-generate the main event title and description for reuse
+            if title_template:
+                main_event_title = format_template(title_template, all_groups)
+            else:
+                title_parts = []
+                if 'league' in all_groups and all_groups['league']:
+                    title_parts.append(all_groups['league'])
+                if 'team1' in all_groups and 'team2' in all_groups:
+                    title_parts.append(f"{all_groups['team1']} vs {all_groups['team2']}")
+                elif 'title' in all_groups and all_groups['title']:
+                    title_parts.append(all_groups['title'])
+                main_event_title = ' - '.join(title_parts) if title_parts else channel_name
+
+            if subtitle_template:
+                main_event_subtitle = format_template(subtitle_template, all_groups)
+            else:
+                main_event_subtitle = None
+
+            if description_template:
+                main_event_description = format_template(description_template, all_groups)
+            else:
+                main_event_description = main_event_title
+
+
+
+            # Determine if this day is before, during, or after the event
+            # Event only happens on day 0 (first day) when it falls inside the window
+            is_event_day = (day == 0) and event_overlaps_window
+
+            if is_event_day and not event_happened:
+                current_time = day_start
+
+                while current_time < event_start_utc and current_time < day_end:
+                    program_start_utc = current_time
+                    program_end_utc = min(current_time + timedelta(minutes=program_duration), event_start_utc)
+
+                    # Use custom upcoming templates if provided, otherwise use defaults
+                    if upcoming_title_template:
+                        upcoming_title = format_template(upcoming_title_template, all_groups)
+                    else:
+                        upcoming_title = main_event_title
+
+                    if upcoming_description_template:
+                        upcoming_description = format_template(upcoming_description_template, all_groups)
+                    else:
+                        upcoming_description = f"Upcoming: {main_event_description}"
+
+                    # Build custom_properties for upcoming programs (only date, no category/live)
+                    program_custom_properties = {}
+
+                    # Add date if requested (YYYY-MM-DD format from start time in event timezone)
+                    if include_date:
+                        # Convert UTC time to event timezone for date calculation
+                        local_time = program_start_utc.astimezone(source_tz)
+                        date_str = local_time.strftime('%Y-%m-%d')
+                        program_custom_properties['date'] = date_str
+
+                    # Add program poster URL if provided
+                    if program_poster_url:
+                        program_custom_properties['icon'] = program_poster_url
+
+                    programs.append({
+                        "channel_id": channel_id,
+                        "start_time": program_start_utc,
+                        "end_time": program_end_utc,
+                        "title": upcoming_title,
+                        "sub_title": None,  # No subtitle for filler programs
+                        "description": upcoming_description,
+                        "custom_properties": program_custom_properties,
+                        "channel_logo_url": channel_logo_url,  # Pass channel logo for EPG generation
+                    })
+
+                    current_time += timedelta(minutes=program_duration)
+
+                # Add the MAIN EVENT at the extracted time
+                # Build custom_properties for main event (includes category and live)
+                main_event_custom_properties = {}
+
+                # Add categories if provided
+                if categories:
+                    main_event_custom_properties['categories'] = categories
+
+                # Add date if requested (YYYY-MM-DD format from start time in event timezone)
+                if include_date:
+                    # Convert UTC time to event timezone for date calculation
+                    local_time = event_start_utc.astimezone(source_tz)
+                    date_str = local_time.strftime('%Y-%m-%d')
+                    main_event_custom_properties['date'] = date_str
+
+                # Add live flag if requested
+                if include_live:
+                    main_event_custom_properties['live'] = True
+
+                # Add new flag if requested
+                if include_new:
+                    main_event_custom_properties['new'] = True
+
+                # Add program poster URL if provided
+                if program_poster_url:
+                    main_event_custom_properties['icon'] = program_poster_url
+
+                programs.append({
+                    "channel_id": channel_id,
+                    "start_time": event_start_utc,
+                    "end_time": event_end_utc,
+                    "title": main_event_title,
+                    "sub_title": main_event_subtitle,
+                    "description": main_event_description,
+                    "custom_properties": main_event_custom_properties,
+                    "channel_logo_url": channel_logo_url,  # Pass channel logo for EPG generation
+                })
+
+                event_happened = True
+
+                # Fill programs AFTER the event until end of export day window
+                current_time = max(event_end_utc, day_start)
+
+                while current_time < day_end:
+                    program_start_utc = current_time
+                    program_end_utc = min(current_time + timedelta(minutes=program_duration), day_end)
+
+                    # Use custom ended templates if provided, otherwise use defaults
+                    if ended_title_template:
+                        ended_title = format_template(ended_title_template, all_groups)
+                    else:
+                        ended_title = main_event_title
+
+                    if ended_description_template:
+                        ended_description = format_template(ended_description_template, all_groups)
+                    else:
+                        ended_description = f"Ended: {main_event_description}"
+
+                    # Build custom_properties for ended programs (only date, no category/live)
+                    program_custom_properties = {}
+
+                    # Add date if requested (YYYY-MM-DD format from start time in event timezone)
+                    if include_date:
+                        # Convert UTC time to event timezone for date calculation
+                        local_time = program_start_utc.astimezone(source_tz)
+                        date_str = local_time.strftime('%Y-%m-%d')
+                        program_custom_properties['date'] = date_str
+
+                    # Add program poster URL if provided
+                    if program_poster_url:
+                        program_custom_properties['icon'] = program_poster_url
+
+                    programs.append({
+                        "channel_id": channel_id,
+                        "start_time": program_start_utc,
+                        "end_time": program_end_utc,
+                        "title": ended_title,
+                        "sub_title": None,  # No subtitle for filler programs
+                        "description": ended_description,
+                        "custom_properties": program_custom_properties,
+                        "channel_logo_url": channel_logo_url,  # Pass channel logo for EPG generation
+                    })
+
+                    current_time += timedelta(minutes=program_duration)
+            else:
+                # This day is either before the event (future days) or after the event happened
+                # Fill entire day with appropriate message
+                current_time = day_start
+
+                # If event already happened, all programs show "Ended"
+                # If event hasn't happened yet (shouldn't occur with day 0 logic), show "Upcoming"
+                is_ended = event_happened
+
+                while current_time < day_end:
+                    program_start_utc = current_time
+                    program_end_utc = min(current_time + timedelta(minutes=program_duration), day_end)
+
+                    # Use custom templates based on whether event has ended or is upcoming
+                    if is_ended:
+                        if ended_title_template:
+                            program_title = format_template(ended_title_template, all_groups)
+                        else:
+                            program_title = main_event_title
+
+                        if ended_description_template:
+                            program_description = format_template(ended_description_template, all_groups)
+                        else:
+                            program_description = f"Ended: {main_event_description}"
+                    else:
+                        if upcoming_title_template:
+                            program_title = format_template(upcoming_title_template, all_groups)
+                        else:
+                            program_title = main_event_title
+
+                        if upcoming_description_template:
+                            program_description = format_template(upcoming_description_template, all_groups)
+                        else:
+                            program_description = f"Upcoming: {main_event_description}"
+
+                    # Build custom_properties (only date for upcoming/ended filler programs)
+                    program_custom_properties = {}
+
+                    # Add date if requested (YYYY-MM-DD format from start time in event timezone)
+                    if include_date:
+                        # Convert UTC time to event timezone for date calculation
+                        local_time = program_start_utc.astimezone(source_tz)
+                        date_str = local_time.strftime('%Y-%m-%d')
+                        program_custom_properties['date'] = date_str
+
+                    # Add program poster URL if provided
+                    if program_poster_url:
+                        program_custom_properties['icon'] = program_poster_url
+
+                    programs.append({
+                        "channel_id": channel_id,
+                        "start_time": program_start_utc,
+                        "end_time": program_end_utc,
+                        "title": program_title,
+                        "sub_title": None,  # No subtitle for filler programs
+                        "description": program_description,
+                        "custom_properties": program_custom_properties,
+                        "channel_logo_url": channel_logo_url,
+                    })
+
+                    current_time += timedelta(minutes=program_duration)
+        else:
+            # No extracted time - fill entire day with regular intervals
+            # day_start and day_end are already in UTC, so no conversion needed
+            programs_per_day = max(1, int(24 / (program_duration / 60)))
+
+            for program_num in range(programs_per_day):
+                program_start_utc = day_start + timedelta(minutes=program_num * program_duration)
+                program_end_utc = program_start_utc + timedelta(minutes=program_duration)
+
+                if title_template:
+                    title = format_template(title_template, all_groups)
+                else:
+                    title_parts = []
+                    if 'league' in all_groups and all_groups['league']:
+                        title_parts.append(all_groups['league'])
+                    if 'team1' in all_groups and 'team2' in all_groups:
+                        title_parts.append(f"{all_groups['team1']} vs {all_groups['team2']}")
+                    elif 'title' in all_groups and all_groups['title']:
+                        title_parts.append(all_groups['title'])
+                    title = ' - '.join(title_parts) if title_parts else channel_name
+
+                if subtitle_template:
+                    subtitle = format_template(subtitle_template, all_groups)
+                else:
+                    subtitle = None
+
+                if description_template:
+                    description = format_template(description_template, all_groups)
+                else:
+                    description = title
+
+                # Build custom_properties for this program
+                program_custom_properties = {}
+
+                # Add categories if provided
+                if categories:
+                    program_custom_properties['categories'] = categories
+
+                # Add date if requested (YYYY-MM-DD format from start time in event timezone)
+                if include_date:
+                    # Convert UTC time to event timezone for date calculation
+                    local_time = program_start_utc.astimezone(source_tz)
+                    date_str = local_time.strftime('%Y-%m-%d')
+                    program_custom_properties['date'] = date_str
+
+                # Add live flag if requested
+                if include_live:
+                    program_custom_properties['live'] = True
+
+                # Add new flag if requested
+                if include_new:
+                    program_custom_properties['new'] = True
+
+                # Add program poster URL if provided
+                if program_poster_url:
+                    program_custom_properties['icon'] = program_poster_url
+
+                programs.append({
+                    "channel_id": channel_id,
+                    "start_time": program_start_utc,
+                    "end_time": program_end_utc,
+                    "title": title,
+                    "sub_title": subtitle,
+                    "description": description,
+                    "custom_properties": program_custom_properties,
+                    "channel_logo_url": channel_logo_url,  # Pass channel logo for EPG generation
+                })
+
+    logger.info(f"Generated {len(programs)} custom dummy programs for {channel_name}")
+    return programs
+
+
+def generate_dummy_epg(
+    channel_id, channel_name, xml_lines=None, num_days=1, program_length_hours=4
+):
+    """
+    Generate dummy EPG programs for channels without EPG data.
+    Creates program blocks for a specified number of days.
+
+    Args:
+        channel_id: The channel ID to use in the program entries
+        channel_name: The name of the channel to use in program titles
+        xml_lines: Optional list to append lines to, otherwise returns new list
+        num_days: Number of days to generate EPG data for (default: 1)
+        program_length_hours: Length of each program block in hours (default: 4)
+
+    Returns:
+        List of XML lines for the dummy EPG entries
+    """
+    if xml_lines is None:
+        xml_lines = []
+
+    for program in generate_dummy_programs(channel_id, channel_name, num_days=1, program_length_hours=4):
+        # Format times in XMLTV format
+        start_str = program['start_time'].strftime("%Y%m%d%H%M%S %z")
+        stop_str = program['end_time'].strftime("%Y%m%d%H%M%S %z")
+
+        # Create program entry with escaped channel name
+        xml_lines.append(
+            f'  <programme start="{start_str}" stop="{stop_str}" channel="{html.escape(program["channel_id"])}">'
+        )
+        xml_lines.append(f"    <title>{html.escape(program['title'])}</title>")
+
+        # Add subtitle if available
+        if program.get('sub_title'):
+            xml_lines.append(f"    <sub-title>{html.escape(program['sub_title'])}</sub-title>")
+
+        xml_lines.append(f"    <desc>{html.escape(program['description'])}</desc>")
+
+        # Add custom_properties if present
+        custom_data = program.get('custom_properties', {})
+
+        # Categories
+        if 'categories' in custom_data:
+            for cat in custom_data['categories']:
+                xml_lines.append(f"    <category>{html.escape(cat)}</category>")
+
+        # Date tag
+        if 'date' in custom_data:
+            xml_lines.append(f"    <date>{html.escape(custom_data['date'])}</date>")
+
+        # Live tag
+        if custom_data.get('live', False):
+            xml_lines.append(f"    <live />")
+
+        # New tag
+        if custom_data.get('new', False):
+            xml_lines.append(f"    <new />")
+
+        xml_lines.append(f"  </programme>")
+
+    return xml_lines
+
+
+def generate_epg(request, profile_name=None, user=None):
+    """
+    Dynamically generate an XMLTV (EPG) file using a streaming response.
+    Since the EPG data is stored independently of Channels, we group programmes
+    by their associated EPGData record.
+    """
+    user_custom = (user.custom_properties or {}) if user else {}
+    try:
+        num_days = int(request.GET.get('days', user_custom.get('epg_days', 0)))
+        num_days = max(0, min(num_days, 365))
+    except (ValueError, TypeError):
+        num_days = 0
+    try:
+        prev_days = int(request.GET.get('prev_days', user_custom.get('epg_prev_days', 0)))
+        prev_days = max(0, min(prev_days, 30))
+    except (ValueError, TypeError):
+        prev_days = 0
+    use_cached_logos = request.GET.get('cachedlogos', 'true').lower() != 'false'
+    tvg_id_source = request.GET.get('tvg_id_source', 'channel_number').lower()
+    cache_params = (
+        f"{profile_name or 'all'}:{user.username if user else 'anonymous'}"
+        f":d={num_days}:p={prev_days}:logos={use_cached_logos}:tvgid={tvg_id_source}"
+    )
+    content_cache_key = f"epg_content:{cache_params}"
+
+    def epg_generator():
+        """Generator function that yields EPG data with keep-alives during processing."""
+
+        yield '<?xml version="1.0" encoding="UTF-8"?>\n'
+        yield (
+            '<tv generator-info-name="Dispatcharr" '
+            'generator-info-url="https://github.com/Dispatcharr/Dispatcharr">\n'
+        )
+
+        # Get channels based on user/profile
+        if user is not None:
+            if user.user_level < 10:
+                user_profile_count = user.channel_profiles.count()
+
+                # If user has ALL profiles or NO profiles, give unrestricted access
+                if user_profile_count == 0:
+                    # No profile filtering - user sees all channels based on user_level
+                    filters = {"user_level__lte": user.user_level}
+                    # Hide adult content if user preference is set
+                    if (user.custom_properties or {}).get('hide_adult_content', False):
+                        filters["is_adult"] = False
+                    base_qs = Channel.objects.filter(**filters).select_related('logo', 'epg_data__epg_source')
+                else:
+                    # User has specific limited profiles assigned
+                    filters = {
+                        "channelprofilemembership__enabled": True,
+                        "user_level__lte": user.user_level,
+                        "channelprofilemembership__channel_profile__in": user.channel_profiles.all()
+                    }
+                    # Hide adult content if user preference is set
+                    if (user.custom_properties or {}).get('hide_adult_content', False):
+                        filters["is_adult"] = False
+                    base_qs = Channel.objects.filter(**filters).select_related('logo', 'epg_data__epg_source').distinct()
+            else:
+                base_qs = Channel.objects.filter(user_level__lte=user.user_level).select_related('logo', 'epg_data__epg_source')
+        else:
+            if profile_name is not None:
+                try:
+                    channel_profile = ChannelProfile.objects.get(name=profile_name)
+                except ChannelProfile.DoesNotExist:
+                    logger.warning("Requested channel profile (%s) during epg generation does not exist", profile_name)
+                    raise Http404(f"Channel profile '{profile_name}' not found")
+                base_qs = Channel.objects.filter(
+                    channelprofilemembership__channel_profile=channel_profile,
+                    channelprofilemembership__enabled=True,
+                ).select_related('logo', 'epg_data__epg_source')
+            else:
+                base_qs = Channel.objects.all().select_related('logo', 'epg_data__epg_source')
+
+        # Resolve effective values at SQL level and exclude hidden channels
+        # so output ordering/display honors user overrides.
+        from apps.channels.managers import with_effective_values
+        channels = list(
+            with_effective_values(base_qs, select_related_fks=True)
+            .exclude(hidden_from_output=True)
+            .order_by("effective_channel_number")
+            .prefetch_related(
+                Prefetch('streams', queryset=Stream.objects.only('id', 'name').order_by('channelstream__order'))
+            )
+        )
+        channel_count = len(channels)
+
+        # For dummy EPG, use either the specified value or default to 3 days
+        dummy_days = num_days if num_days > 0 else 3
+
+        # Calculate cutoff dates for EPG data filtering
+        now = django_timezone.now()
+        cutoff_date = now + timedelta(days=num_days) if num_days > 0 else None
+        lookback_cutoff = now - timedelta(days=prev_days)
+
+        # Build collision-free channel number mapping for XC clients (if user is authenticated)
+        # XC clients require integer channel numbers, so we need to ensure no conflicts
+        channel_num_map = {}
+        if user is not None:
+            # This is an XC client - build collision-free mapping
+            used_numbers = set()
+
+            # First pass: assign integers for channels that already have integer numbers
+            for channel in channels:
+                effective_num = channel.effective_channel_number
+                if effective_num is not None and effective_num == int(effective_num):
+                    num = int(effective_num)
+                    channel_num_map[channel.id] = num
+                    used_numbers.add(num)
+
+            # Second pass: assign integers for channels with float numbers
+            for channel in channels:
+                effective_num = channel.effective_channel_number
+                if effective_num is not None and effective_num != int(effective_num):
+                    candidate = int(effective_num)
+                    while candidate in used_numbers:
+                        candidate += 1
+                    channel_num_map[channel.id] = candidate
+                    used_numbers.add(candidate)
+
+        # Host/port/scheme are constant per request; precompute logo URL prefix once.
+        _base_url = build_absolute_uri_with_port(request, "")
+        _sample_logo_path = reverse("api:channels:logo-cache", args=[0])
+        _logo_prefix_raw, _, _logo_suffix_raw = _sample_logo_path.partition("/0/")
+        _logo_url_prefix = _base_url + _logo_prefix_raw + "/"
+        _logo_url_suffix = "/" + _logo_suffix_raw
+
+        dummy_program_list = []
+        real_epg_map = {}
+        channel_xml_batch = []
+
+        for channel in channels:
+            effective_name = channel.effective_name
+            effective_epg_data = channel.effective_epg_data_obj
+            effective_epg_data_id = channel.effective_epg_data_id
+            effective_logo = channel.effective_logo_obj
+            effective_number = channel.effective_channel_number
+
+            # user is set only for XC clients, which require integer channel numbers
+            if user is not None:
+                formatted_channel_number = channel_num_map[channel.id]
+            else:
+                formatted_channel_number = format_channel_number(effective_number)
+
+            # Determine the channel ID based on the selected source
+            if tvg_id_source == 'tvg_id' and channel.effective_tvg_id:
+                channel_id = channel.effective_tvg_id
+            elif tvg_id_source == 'gracenote' and channel.effective_tvc_guide_stationid:
+                channel_id = channel.effective_tvc_guide_stationid
+            else:
+                channel_id = str(formatted_channel_number) if formatted_channel_number != "" else str(channel.id)
+
+            tvg_logo = ""
+
+            # Check if this is a custom dummy EPG with channel logo URL template
+            if effective_epg_data and effective_epg_data.epg_source and effective_epg_data.epg_source.source_type == 'dummy':
+                epg_source = effective_epg_data.epg_source
+                if epg_source.custom_properties:
+                    custom_props = epg_source.custom_properties
+                    channel_logo_url_template = custom_props.get('channel_logo_url', '')
+
+                    if channel_logo_url_template:
+                        pattern_match_name, _ = _pattern_match_name_from_custom_props(
+                            channel, effective_name, custom_props
+                        )
+
+                        # Try to extract groups from the channel/stream name and build the logo URL
+                        title_pattern = custom_props.get('title_pattern', '')
+                        if title_pattern:
+                            try:
+                                # Convert PCRE/JavaScript named groups to Python format
+                                title_pattern = regex.sub(r'\(\?<(?![=!])([^>]+)>', r'(?P<\1>', title_pattern)
+                                title_regex = regex.compile(title_pattern)
+                                title_match = title_regex.search(pattern_match_name)
+
+                                if title_match:
+                                    groups = title_match.groupdict()
+
+                                    # Add normalized versions of all groups for cleaner URLs
+                                    for key, value in list(groups.items()):
+                                        if value:
+                                            # Remove all non-alphanumeric characters and convert to lowercase
+                                            normalized = regex.sub(r'[^a-zA-Z0-9\s]', '', str(value))
+                                            normalized = regex.sub(r'\s+', '', normalized).lower()
+                                            groups[f'{key}_normalize'] = normalized
+
+                                    # Format the logo URL template with the matched groups (with URL encoding)
+                                    from urllib.parse import quote
+                                    for key, value in groups.items():
+                                        if value:
+                                            encoded_value = quote(str(value), safe='')
+                                            channel_logo_url_template = channel_logo_url_template.replace(f'{{{key}}}', encoded_value)
+                                        else:
+                                            channel_logo_url_template = channel_logo_url_template.replace(f'{{{key}}}', '')
+                                    tvg_logo = channel_logo_url_template
+                                    logger.debug(f"Built channel logo URL from template: {tvg_logo}")
+                            except Exception as e:
+                                logger.warning(f"Failed to build channel logo URL for {effective_name}: {e}")
+
+            # If no custom dummy logo, use regular logo logic
+            if not tvg_logo and effective_logo:
+                if use_cached_logos:
+                    tvg_logo = f"{_logo_url_prefix}{effective_logo.id}{_logo_url_suffix}"
+                else:
+                    # Use direct URL if available, otherwise fall back to cached version
+                    direct_logo = effective_logo.url if effective_logo.url.startswith(('http://', 'https://')) else None
+                    if direct_logo:
+                        tvg_logo = direct_logo
+                    else:
+                        tvg_logo = f"{_logo_url_prefix}{effective_logo.id}{_logo_url_suffix}"
+            channel_xml_batch.append(f'  <channel id="{html.escape(channel_id)}">')
+            channel_xml_batch.append(f'    <display-name>{html.escape(effective_name)}</display-name>')
+            channel_xml_batch.append(f'    <icon src="{html.escape(tvg_logo)}" />')
+            channel_xml_batch.append("  </channel>")
+
+            if len(channel_xml_batch) >= _EPG_CHANNEL_XML_BATCH_SIZE * 4:
+                yield '\n'.join(channel_xml_batch) + '\n'
+                channel_xml_batch = []
+
+            pattern_match_name = effective_name
+            if effective_epg_data and effective_epg_data.epg_source:
+                epg_source = effective_epg_data.epg_source
+                if epg_source.custom_properties:
+                    custom_props = epg_source.custom_properties
+                    pattern_match_name, stream_lookup_failed = _pattern_match_name_from_custom_props(
+                        channel, effective_name, custom_props
+                    )
+                    if (
+                        custom_props.get('name_source') == 'stream'
+                        and not stream_lookup_failed
+                        and pattern_match_name != effective_name
+                    ):
+                        stream_index = custom_props.get('stream_index', 1) - 1
+                        logger.debug(
+                            f"Using stream name for parsing: {pattern_match_name} "
+                            f"(stream index: {stream_index})"
+                        )
+                    elif stream_lookup_failed:
+                        stream_index = custom_props.get('stream_index', 1) - 1
+                        logger.warning(
+                            f"Stream index {stream_index} not found for channel "
+                            f"{effective_name}, falling back to channel name"
+                        )
+
+            if not effective_epg_data:
+                dummy_program_list.append((channel_id, pattern_match_name, None))
+            elif effective_epg_data.epg_source and effective_epg_data.epg_source.source_type == 'dummy':
+                dummy_program_list.append((channel_id, pattern_match_name, effective_epg_data.epg_source))
+            else:
+                real_epg_map.setdefault(effective_epg_data_id, []).append(channel_id)
+
+        if channel_xml_batch:
+            yield '\n'.join(channel_xml_batch) + '\n'
+
+        del channels
+        del channel_num_map
+
+        batch_size = _EPG_PROGRAM_YIELD_BATCH_SIZE
+
+        all_epg_ids = list(real_epg_map.keys())
+        if all_epg_ids:
+            if num_days > 0:
+                programs_qs = ProgramData.objects.filter(
+                    epg_id__in=all_epg_ids,
+                    end_time__gte=lookback_cutoff,
+                    start_time__lt=cutoff_date,
+                )
+            else:
+                programs_qs = ProgramData.objects.filter(
+                    epg_id__in=all_epg_ids,
+                    end_time__gte=lookback_cutoff,
+                )
+
+            programs_base_qs = programs_qs.order_by('epg_id', 'id').values(
+                'id', 'epg_id', 'start_time', 'end_time', 'title', 'sub_title',
+                'description', 'custom_properties',
+            )
+
+            current_epg_id = None
+            channel_ids_for_epg = None
+            escaped_primary_cid = None
+            pending = []
+            program_batch = []
+            chunk_size = _EPG_PROGRAM_DB_CHUNK_SIZE
+            last_epg_id = 0
+            last_id = 0
+            _poster_url_base = build_absolute_uri_with_port(request, "/api/epg/programs/")
+
+            def flush_pending():
+                nonlocal program_batch, pending
+                if not pending:
+                    return
+                pending.sort(key=lambda row: (row[0], row[1]))
+                escaped_primary = (
+                    escaped_primary_cid if len(channel_ids_for_epg) > 1 else None
+                )
+                for _, _, xml_text in pending:
+                    program_batch.append(xml_text)
+                    if escaped_primary:
+                        for cid in channel_ids_for_epg[1:]:
+                            program_batch.append(xml_text.replace(
+                                f'channel="{escaped_primary}"',
+                                f'channel="{html.escape(cid)}"',
+                                1,
+                            ))
+                    if len(program_batch) >= batch_size:
+                        yield '\n'.join(program_batch) + '\n'
+                        program_batch = []
+                pending.clear()
+
+            while True:
+                program_chunk = list(
+                    programs_base_qs.filter(epg_id__gte=last_epg_id)
+                    .exclude(epg_id=last_epg_id, id__lte=last_id)[:chunk_size]
+                )
+                if not program_chunk:
+                    break
+
+                last_row = program_chunk[-1]
+                last_epg_id = last_row['epg_id']
+                last_id = last_row['id']
+
+                for prog in program_chunk:
+                    epg_id = prog['epg_id']
+
+                    if epg_id != current_epg_id:
+                        yield from flush_pending()
+                        current_epg_id = epg_id
+                        channel_ids_for_epg = real_epg_map[epg_id]
+                        escaped_primary_cid = html.escape(channel_ids_for_epg[0])
+
+                    # DB datetimes are UTC (USE_TZ=True, TIME_ZONE=UTC); format
+                    # directly instead of strftime("%Y%m%d%H%M%S %z"), which is
+                    # ~10x slower and dominates XML build over 750k rows.
+                    st = prog['start_time']
+                    et = prog['end_time']
+                    start_str = f"{st.year:04d}{st.month:02d}{st.day:02d}{st.hour:02d}{st.minute:02d}{st.second:02d} +0000"
+                    stop_str = f"{et.year:04d}{et.month:02d}{et.day:02d}{et.hour:02d}{et.minute:02d}{et.second:02d} +0000"
+
+                    program_xml = [f'  <programme start="{start_str}" stop="{stop_str}" channel="{escaped_primary_cid}">']
+                    program_xml.append(f'    <title>{html.escape(prog["title"])}</title>')
+
+                    if prog['sub_title']:
+                        program_xml.append(f"    <sub-title>{html.escape(prog['sub_title'])}</sub-title>")
+
+                    if prog['description']:
+                        program_xml.append(f"    <desc>{html.escape(prog['description'])}</desc>")
+
+                    custom_data = prog['custom_properties'] or {}
+                    if custom_data:
+
+                        if "categories" in custom_data and custom_data["categories"]:
+                            for category in custom_data["categories"]:
+                                program_xml.append(f"    <category>{html.escape(category)}</category>")
+
+                        if "keywords" in custom_data and custom_data["keywords"]:
+                            for keyword in custom_data["keywords"]:
+                                program_xml.append(f"    <keyword>{html.escape(keyword)}</keyword>")
+
+                        # onscreen_episode takes priority over episode for the onscreen system
+                        if "onscreen_episode" in custom_data:
+                            program_xml.append(f'    <episode-num system="onscreen">{html.escape(custom_data["onscreen_episode"])}</episode-num>')
+                        elif "episode" in custom_data:
+                            program_xml.append(f'    <episode-num system="onscreen">E{custom_data["episode"]}</episode-num>')
+
+                        # Handle dd_progid format
+                        if 'dd_progid' in custom_data:
+                            program_xml.append(f'    <episode-num system="dd_progid">{html.escape(custom_data["dd_progid"])}</episode-num>')
+
+                        # Handle external database IDs
+                        for system in ['thetvdb.com', 'themoviedb.org', 'imdb.com']:
+                            if f'{system}_id' in custom_data:
+                                program_xml.append(f'    <episode-num system="{system}">{html.escape(custom_data[f"{system}_id"])}</episode-num>')
+
+                        # Add season and episode numbers in xmltv_ns format if available
+                        if "season" in custom_data and "episode" in custom_data:
+                            season = (
+                                int(custom_data["season"]) - 1
+                                if str(custom_data["season"]).isdigit()
+                                else 0
+                            )
+                            episode = (
+                                int(custom_data["episode"]) - 1
+                                if str(custom_data["episode"]).isdigit()
+                                else 0
+                            )
+                            program_xml.append(f'    <episode-num system="xmltv_ns">{season}.{episode}.</episode-num>')
+
+                        if "language" in custom_data:
+                            program_xml.append(f'    <language>{html.escape(custom_data["language"])}</language>')
+
+                        if "original_language" in custom_data:
+                            program_xml.append(f'    <orig-language>{html.escape(custom_data["original_language"])}</orig-language>')
+
+                        if "length" in custom_data and isinstance(custom_data["length"], dict):
+                            length_value = custom_data["length"].get("value", "")
+                            length_units = custom_data["length"].get("units", "minutes")
+                            program_xml.append(f'    <length units="{html.escape(length_units)}">{html.escape(str(length_value))}</length>')
+
+                        if "video" in custom_data and isinstance(custom_data["video"], dict):
+                            program_xml.append("    <video>")
+                            for attr in ['present', 'colour', 'aspect', 'quality']:
+                                if attr in custom_data["video"]:
+                                    program_xml.append(f"      <{attr}>{html.escape(custom_data['video'][attr])}</{attr}>")
+                            program_xml.append("    </video>")
+
+                        if "audio" in custom_data and isinstance(custom_data["audio"], dict):
+                            program_xml.append("    <audio>")
+                            for attr in ['present', 'stereo']:
+                                if attr in custom_data["audio"]:
+                                    program_xml.append(f"      <{attr}>{html.escape(custom_data['audio'][attr])}</{attr}>")
+                            program_xml.append("    </audio>")
+
+                        if "subtitles" in custom_data and isinstance(custom_data["subtitles"], list):
+                            for subtitle in custom_data["subtitles"]:
+                                if isinstance(subtitle, dict):
+                                    subtitle_type = subtitle.get("type", "")
+                                    type_attr = f' type="{html.escape(subtitle_type)}"' if subtitle_type else ""
+                                    program_xml.append(f"    <subtitles{type_attr}>")
+                                    if "language" in subtitle:
+                                        program_xml.append(f"      <language>{html.escape(subtitle['language'])}</language>")
+                                    program_xml.append("    </subtitles>")
+
+                        if "rating" in custom_data:
+                            rating_system = custom_data.get("rating_system", "TV Parental Guidelines")
+                            program_xml.append(f'    <rating system="{html.escape(rating_system)}">')
+                            program_xml.append(f'      <value>{html.escape(custom_data["rating"])}</value>')
+                            program_xml.append(f"    </rating>")
+
+                        if "star_ratings" in custom_data and isinstance(custom_data["star_ratings"], list):
+                            for star_rating in custom_data["star_ratings"]:
+                                if isinstance(star_rating, dict) and "value" in star_rating:
+                                    system_attr = f' system="{html.escape(star_rating["system"])}"' if "system" in star_rating else ""
+                                    program_xml.append(f"    <star-rating{system_attr}>")
+                                    program_xml.append(f"      <value>{html.escape(star_rating['value'])}</value>")
+                                    program_xml.append("    </star-rating>")
+
+                        if "reviews" in custom_data and isinstance(custom_data["reviews"], list):
+                            for review in custom_data["reviews"]:
+                                if isinstance(review, dict) and "content" in review:
+                                    review_type = review.get("type", "text")
+                                    attrs = [f'type="{html.escape(review_type)}"']
+                                    if "source" in review:
+                                        attrs.append(f'source="{html.escape(review["source"])}"')
+                                    if "reviewer" in review:
+                                        attrs.append(f'reviewer="{html.escape(review["reviewer"])}"')
+                                    attr_str = " ".join(attrs)
+                                    program_xml.append(f'    <review {attr_str}>{html.escape(review["content"])}</review>')
+
+                        if "images" in custom_data and isinstance(custom_data["images"], list):
+                            for image in custom_data["images"]:
+                                if isinstance(image, dict) and "url" in image:
+                                    attrs = []
+                                    for attr in ['type', 'size', 'orient', 'system']:
+                                        if attr in image:
+                                            attrs.append(f'{attr}="{html.escape(image[attr])}"')
+                                    attr_str = " " + " ".join(attrs) if attrs else ""
+                                    program_xml.append(f'    <image{attr_str}>{html.escape(image["url"])}</image>')
+
+                        # Add enhanced credits handling
+                        if "credits" in custom_data:
+                            program_xml.append("    <credits>")
+                            credits = custom_data["credits"]
+
+                            for role in ['director', 'writer', 'adapter', 'producer', 'composer', 'editor', 'presenter', 'commentator', 'guest']:
+                                if role in credits:
+                                    people = credits[role]
+                                    if isinstance(people, list):
+                                        for person in people:
+                                            program_xml.append(f"      <{role}>{html.escape(person)}</{role}>")
+                                    else:
+                                        program_xml.append(f"      <{role}>{html.escape(people)}</{role}>")
+
+                            # Handle actors separately to include role and guest attributes
+                            if "actor" in credits:
+                                actors = credits["actor"]
+                                if isinstance(actors, list):
+                                    for actor in actors:
+                                        if isinstance(actor, dict):
+                                            name = actor.get("name", "")
+                                            role_attr = f' role="{html.escape(actor["role"])}"' if "role" in actor else ""
+                                            guest_attr = ' guest="yes"' if actor.get("guest") else ""
+                                            program_xml.append(f"      <actor{role_attr}{guest_attr}>{html.escape(name)}</actor>")
+                                        else:
+                                            program_xml.append(f"      <actor>{html.escape(actor)}</actor>")
+                                else:
+                                    program_xml.append(f"      <actor>{html.escape(actors)}</actor>")
+
+                            program_xml.append("    </credits>")
+
+                        if "date" in custom_data:
+                            program_xml.append(f'    <date>{html.escape(custom_data["date"])}</date>')
+
+                        if "country" in custom_data:
+                            program_xml.append(f'    <country>{html.escape(custom_data["country"])}</country>')
+
+                        if "icon" in custom_data:
+                            program_xml.append(f'    <icon src="{html.escape(custom_data["icon"])}" />')
+                        elif "sd_icon" in custom_data:
+                            program_xml.append(f'    <icon src="{html.escape(_poster_url_base)}{prog["id"]}/poster/" />')
+
+                        # Add special flags as proper tags with enhanced handling
+                        if custom_data.get("previously_shown", False):
+                            prev_shown_details = custom_data.get("previously_shown_details", {})
+                            attrs = []
+                            if "start" in prev_shown_details:
+                                attrs.append(f'start="{html.escape(prev_shown_details["start"])}"')
+                            if "channel" in prev_shown_details:
+                                attrs.append(f'channel="{html.escape(prev_shown_details["channel"])}"')
+                            attr_str = " " + " ".join(attrs) if attrs else ""
+                            program_xml.append(f"    <previously-shown{attr_str} />")
+
+                        if custom_data.get("premiere", False):
+                            premiere_text = custom_data.get("premiere_text", "")
+                            if premiere_text:
+                                program_xml.append(f"    <premiere>{html.escape(premiere_text)}</premiere>")
+                            else:
+                                program_xml.append("    <premiere />")
+
+                        if custom_data.get("last_chance", False):
+                            last_chance_text = custom_data.get("last_chance_text", "")
+                            if last_chance_text:
+                                program_xml.append(f"    <last-chance>{html.escape(last_chance_text)}</last-chance>")
+                            else:
+                                program_xml.append("    <last-chance />")
+
+                        if custom_data.get("new", False):
+                            program_xml.append("    <new />")
+
+                        if custom_data.get('live', False):
+                            program_xml.append('    <live />')
+
+                    program_xml.append("  </programme>")
+
+                    xml_text = '\n'.join(program_xml)
+                    pending.append((prog['start_time'], prog['id'], xml_text))
+
+                del program_chunk
+
+            yield from flush_pending()
+
+            if program_batch:
+                yield '\n'.join(program_batch) + '\n'
+
+        del real_epg_map
+
+        for channel_id, pattern_match_name, epg_source in dummy_program_list:
+            program_length_hours = 4
+            dummy_programs = generate_dummy_programs(
+                channel_id, pattern_match_name,
+                num_days=dummy_days,
+                program_length_hours=program_length_hours,
+                epg_source=epg_source,
+                export_lookback=lookback_cutoff,
+                export_cutoff=cutoff_date,
+            )
+            if not dummy_programs:
+                continue
+            dummy_batch = []
+            for program in dummy_programs:
+                start_str = program['start_time'].strftime("%Y%m%d%H%M%S %z")
+                stop_str = program['end_time'].strftime("%Y%m%d%H%M%S %z")
+                lines = [
+                    f'  <programme start="{start_str}" stop="{stop_str}" channel="{html.escape(channel_id)}">',
+                    f"    <title>{html.escape(program['title'])}</title>",
+                ]
+                if program.get('sub_title'):
+                    lines.append(f"    <sub-title>{html.escape(program['sub_title'])}</sub-title>")
+                lines.append(f"    <desc>{html.escape(program['description'])}</desc>")
+                custom_data = program.get('custom_properties', {})
+                if 'categories' in custom_data:
+                    for cat in custom_data['categories']:
+                        lines.append(f"    <category>{html.escape(cat)}</category>")
+                if 'date' in custom_data:
+                    lines.append(f"    <date>{html.escape(custom_data['date'])}</date>")
+                if custom_data.get('live', False):
+                    lines.append("    <live />")
+                if custom_data.get('new', False):
+                    lines.append("    <new />")
+                if 'icon' in custom_data:
+                    lines.append(f'    <icon src="{html.escape(custom_data["icon"])}" />')
+                lines.append("  </programme>")
+                dummy_batch.append('\n'.join(lines))
+                if len(dummy_batch) >= batch_size:
+                    yield '\n'.join(dummy_batch) + '\n'
+                    dummy_batch = []
+            del dummy_programs
+            if dummy_batch:
+                yield '\n'.join(dummy_batch) + '\n'
+
+        del dummy_program_list
+
+        yield "</tv>\n"
+
+        from apps.output.views import get_client_identifier
+
+        client_id, client_ip, user_agent = get_client_identifier(request)
+        event_cache_key = f"epg_download:{user.username if user else 'anonymous'}:{profile_name or 'all'}:{client_id}"
+
+        def _log_epg_download():
+            from django.core.cache import cache as event_cache
+
+            if not event_cache.get(event_cache_key):
+                log_system_event(
+                    event_type='epg_download',
+                    profile=profile_name or 'all',
+                    user=user.username if user else 'anonymous',
+                    channels=channel_count,
+                    client_ip=client_ip,
+                    user_agent=user_agent,
+                )
+                event_cache.set(event_cache_key, True, 2)
+
+        try:
+            from core.utils import _is_gevent_monkey_patched
+
+            if _is_gevent_monkey_patched():
+                import gevent
+
+                gevent.spawn(_log_epg_download)
+            else:
+                _log_epg_download()
+        except Exception:
+            _log_epg_download()
+
+    def build_epg_stream():
+        try:
+            yield from epg_generator()
+        finally:
+            _epg_export_teardown()
+
+    return stream_cached_response(
+        content_cache_key,
+        build_epg_stream,
+        content_type="application/xml",
+        filename="Dispatcharr.xml",
+    )
diff --git a/apps/output/streaming_chunk_cache.py b/apps/output/streaming_chunk_cache.py
new file mode 100644
index 00000000..4373f5ce
--- /dev/null
+++ b/apps/output/streaming_chunk_cache.py
@@ -0,0 +1,239 @@
+"""Single-flight Redis chunk cache for large streaming HTTP responses."""
+
+import logging
+import time
+
+from django.http import StreamingHttpResponse
+
+logger = logging.getLogger(__name__)
+
+STATUS_BUILDING = "building"
+STATUS_READY = "ready"
+STATUS_ERROR = "error"
+
+DEFAULT_CACHE_TTL = 300
+DEFAULT_LOCK_TTL = 120
+DEFAULT_POLL_INTERVAL = 0.05
+DEFAULT_MAX_FOLLOWER_WAIT = 600
+
+
+def _chunks_key(base_key):
+    return f"{base_key}:chunks"
+
+
+def _ready_key(base_key):
+    return f"{base_key}:ready"
+
+
+def _status_key(base_key):
+    return f"{base_key}:status"
+
+
+def _lock_key(base_key):
+    return f"{base_key}:lock"
+
+
+def _decode_chunk(chunk):
+    if chunk is None:
+        return None
+    if isinstance(chunk, bytes):
+        return chunk.decode("utf-8")
+    return chunk
+
+
+def _encode_chunk(chunk):
+    if isinstance(chunk, bytes):
+        return chunk
+    return chunk.encode("utf-8")
+
+
+def _poll_wait(interval):
+    try:
+        from core.utils import _is_gevent_monkey_patched
+
+        if _is_gevent_monkey_patched():
+            import gevent
+
+            gevent.sleep(interval)
+            return
+    except ImportError:
+        pass
+    time.sleep(interval)
+
+
+def _get_redis():
+    from django_redis import get_redis_connection
+
+    return get_redis_connection("default")
+
+
+def _get_status(redis, base_key):
+    raw = redis.get(_status_key(base_key))
+    if raw is None:
+        return None
+    return _decode_chunk(raw)
+
+
+def _clear_build_keys(redis, base_key):
+    redis.delete(
+        _chunks_key(base_key),
+        _status_key(base_key),
+        _ready_key(base_key),
+        _lock_key(base_key),
+    )
+
+
+def _try_acquire_lock(redis, base_key, lock_ttl):
+    return bool(redis.set(_lock_key(base_key), "1", nx=True, ex=lock_ttl))
+
+
+def _refresh_build_ttl(redis, base_key, lock_ttl):
+    redis.expire(_lock_key(base_key), lock_ttl)
+    redis.expire(_status_key(base_key), lock_ttl)
+    redis.expire(_chunks_key(base_key), lock_ttl)
+
+
+def _stream_ready(redis, base_key):
+    offset = 0
+    chunks_key = _chunks_key(base_key)
+    while True:
+        chunk = redis.lindex(chunks_key, offset)
+        if chunk is None:
+            break
+        yield _decode_chunk(chunk)
+        offset += 1
+
+
+def _stream_build(redis, base_key, source, cache_ttl, lock_ttl):
+    """Leader: stream to client and append each chunk to Redis."""
+    chunks_key = _chunks_key(base_key)
+    status_key = _status_key(base_key)
+    try:
+        from django.core.cache import cache as django_cache
+
+        django_cache.delete(base_key)  # clear any non-chunked entry under this key
+        redis.delete(chunks_key, _ready_key(base_key))
+        redis.set(status_key, STATUS_BUILDING, ex=lock_ttl)
+        refresh_interval = max(1, lock_ttl // 4)
+        last_refresh = 0.0
+        for chunk in source():
+            redis.rpush(chunks_key, _encode_chunk(chunk))
+            now = time.monotonic()
+            if now - last_refresh >= refresh_interval:
+                _refresh_build_ttl(redis, base_key, lock_ttl)
+                last_refresh = now
+            yield chunk
+        redis.set(status_key, STATUS_READY)
+        redis.set(_ready_key(base_key), "1")
+        redis.expire(chunks_key, cache_ttl)
+        redis.expire(status_key, cache_ttl)
+        redis.expire(_ready_key(base_key), cache_ttl)
+        logger.debug("Cached response in %s chunks", redis.llen(chunks_key))
+    except Exception:
+        logger.exception("Chunk cache build failed for %s", base_key)
+        redis.delete(chunks_key)
+        redis.set(status_key, STATUS_ERROR, ex=60)
+        raise
+    finally:
+        redis.delete(_lock_key(base_key))
+
+
+def _stream_follow(redis, base_key, source, cache_ttl, lock_ttl, poll_interval, max_follower_wait):
+    """Follower: read chunks as the leader writes them."""
+    offset = 0
+    deadline = time.monotonic() + max_follower_wait
+    idle_polls = 0
+    chunks_key = _chunks_key(base_key)
+    lock_key = _lock_key(base_key)
+
+    while True:
+        chunk = redis.lindex(chunks_key, offset)
+        if chunk is not None:
+            idle_polls = 0
+            yield _decode_chunk(chunk)
+            offset += 1
+            continue
+
+        status = _get_status(redis, base_key)
+        if status == STATUS_READY:
+            break
+
+        if status == STATUS_ERROR:
+            _clear_build_keys(redis, base_key)
+            if offset == 0 and _try_acquire_lock(redis, base_key, lock_ttl):
+                yield from _stream_build(redis, base_key, source, cache_ttl, lock_ttl)
+                return
+            raise RuntimeError("Chunk cache build failed")
+
+        if time.monotonic() >= deadline:
+            if offset == 0 and _try_acquire_lock(redis, base_key, lock_ttl):
+                logger.warning("Chunk cache follower timed out; rebuilding %s", base_key)
+                yield from _stream_build(redis, base_key, source, cache_ttl, lock_ttl)
+                return
+            logger.warning("Chunk cache follower timed out after partial read for %s", base_key)
+            break
+
+        lock_active = bool(redis.exists(lock_key))
+        if status != STATUS_BUILDING and not lock_active:
+            idle_polls += 1
+            if offset == 0 and idle_polls >= max(1, int(1.0 / poll_interval)):
+                if _try_acquire_lock(redis, base_key, lock_ttl):
+                    logger.warning("Chunk cache leader lost; rebuilding %s", base_key)
+                    yield from _stream_build(redis, base_key, source, cache_ttl, lock_ttl)
+                    return
+        else:
+            idle_polls = 0
+
+        _poll_wait(poll_interval)
+
+
+def stream_cached_response(
+    cache_key,
+    source,
+    *,
+    content_type="application/xml",
+    filename=None,
+    cache_ttl=DEFAULT_CACHE_TTL,
+    lock_ttl=DEFAULT_LOCK_TTL,
+    poll_interval=DEFAULT_POLL_INTERVAL,
+    max_follower_wait=DEFAULT_MAX_FOLLOWER_WAIT,
+    redis=None,
+):
+    """
+    Stream a large response with single-flight Redis chunk caching.
+
+    ``source`` must be a callable returning a chunk iterator. Only the leader
+    invokes it; concurrent followers replay chunks already written to Redis, so
+    the expensive ``source`` runs at most once per ``cache_key``.
+    """
+    if redis is None:
+        redis = _get_redis()
+
+    if redis.get(_ready_key(cache_key)):
+        logger.debug("Serving response from chunk cache")
+        stream = _stream_ready(redis, cache_key)
+    else:
+        status = _get_status(redis, cache_key)
+        if status == STATUS_ERROR:
+            _clear_build_keys(redis, cache_key)
+
+        if _try_acquire_lock(redis, cache_key, lock_ttl):
+            logger.debug("Building response (cache leader)")
+            stream = _stream_build(redis, cache_key, source, cache_ttl, lock_ttl)
+        else:
+            logger.debug("Following in-flight cache build")
+            stream = _stream_follow(
+                redis,
+                cache_key,
+                source,
+                cache_ttl,
+                lock_ttl,
+                poll_interval,
+                max_follower_wait,
+            )
+
+    response = StreamingHttpResponse(stream, content_type=content_type)
+    if filename:
+        response["Content-Disposition"] = f'attachment; filename="{filename}"'
+    response["Cache-Control"] = "no-cache"
+    return response
diff --git a/apps/output/test_streaming_chunk_cache.py b/apps/output/test_streaming_chunk_cache.py
new file mode 100644
index 00000000..599501b7
--- /dev/null
+++ b/apps/output/test_streaming_chunk_cache.py
@@ -0,0 +1,187 @@
+import threading
+import time
+from unittest import TestCase
+
+from apps.output.streaming_chunk_cache import (
+    STATUS_BUILDING,
+    STATUS_READY,
+    _chunks_key,
+    _lock_key,
+    _ready_key,
+    _status_key,
+    stream_cached_response,
+)
+
+
+class FakeRedis:
+    """Minimal Redis stand-in for chunk-cache unit tests."""
+
+    def __init__(self):
+        self._strings = {}
+        self._lists = {}
+        self._expires_at = {}
+
+    def _purge_expired(self):
+        now = time.monotonic()
+        expired = [key for key, deadline in self._expires_at.items() if deadline <= now]
+        for key in expired:
+            self._strings.pop(key, None)
+            self._lists.pop(key, None)
+            self._expires_at.pop(key, None)
+
+    def get(self, key):
+        self._purge_expired()
+        return self._strings.get(key)
+
+    def set(self, key, value, nx=False, ex=None):
+        self._purge_expired()
+        if nx and key in self._strings:
+            return None
+        self._strings[key] = value
+        if ex is not None:
+            self._expires_at[key] = time.monotonic() + ex
+        return True
+
+    def delete(self, *keys):
+        for key in keys:
+            self._strings.pop(key, None)
+            self._lists.pop(key, None)
+            self._expires_at.pop(key, None)
+
+    def exists(self, key):
+        self._purge_expired()
+        return key in self._strings or key in self._lists
+
+    def expire(self, key, ttl):
+        if key in self._strings or key in self._lists:
+            self._expires_at[key] = time.monotonic() + ttl
+        return True
+
+    def rpush(self, key, value):
+        self._lists.setdefault(key, []).append(value)
+
+    def lindex(self, key, offset):
+        items = self._lists.get(key, [])
+        if offset < len(items):
+            return items[offset]
+        return None
+
+    def llen(self, key):
+        return len(self._lists.get(key, []))
+
+
+def _consume(response):
+    return b"".join(response.streaming_content).decode("utf-8")
+
+
+class StreamingChunkCacheTests(TestCase):
+    def test_leader_caches_chunks_and_sets_ready(self):
+        redis = FakeRedis()
+        calls = []
+
+        def source():
+            calls.append(1)
+            yield "<tv>"
+            yield "</tv>"
+
+        body = _consume(stream_cached_response("cache:test", source, redis=redis))
+
+        self.assertEqual(body, "<tv></tv>")
+        self.assertEqual(calls, [1])
+        self.assertEqual(redis.get(_ready_key("cache:test")), "1")
+        self.assertEqual(redis.get(_status_key("cache:test")), STATUS_READY)
+        self.assertEqual(redis.llen(_chunks_key("cache:test")), 2)
+        self.assertFalse(redis.exists(_lock_key("cache:test")))
+
+    def test_cache_hit_skips_source(self):
+        redis = FakeRedis()
+        calls = []
+
+        def source():
+            calls.append(1)
+            yield "<tv>"
+            yield "</tv>"
+
+        _consume(stream_cached_response("cache:test", source, redis=redis))
+        calls.clear()
+        body = _consume(stream_cached_response("cache:test", source, redis=redis))
+
+        self.assertEqual(body, "<tv></tv>")
+        self.assertEqual(calls, [])
+
+    def test_follower_reads_leader_chunks_without_rebuilding(self):
+        redis = FakeRedis()
+        base = "cache:follow"
+        leader_started = threading.Event()
+        rebuild_calls = []
+
+        def slow_source():
+            rebuild_calls.append(1)
+            leader_started.set()
+            yield "a"
+            time.sleep(0.05)
+            yield "b"
+
+        def forbidden_source():
+            rebuild_calls.append(2)
+            yield "SHOULD_NOT_RUN"
+
+        def leader():
+            _consume(
+                stream_cached_response(
+                    base,
+                    slow_source,
+                    redis=redis,
+                    poll_interval=0.01,
+                )
+            )
+
+        leader_thread = threading.Thread(target=leader)
+        leader_thread.start()
+        leader_started.wait(timeout=5)
+        follower_body = _consume(
+            stream_cached_response(
+                base,
+                forbidden_source,
+                redis=redis,
+                poll_interval=0.01,
+            )
+        )
+        leader_thread.join(timeout=5)
+
+        self.assertEqual(follower_body, "ab")
+        self.assertEqual(rebuild_calls, [1])
+
+    def test_only_one_leader_when_two_clients_start_together(self):
+        redis = FakeRedis()
+        build_calls = []
+        barrier = threading.Barrier(2)
+        results = {}
+
+        def source():
+            build_calls.append(threading.current_thread().name)
+            yield "x"
+
+        def worker():
+            barrier.wait()
+            results[threading.current_thread().name] = _consume(
+                stream_cached_response(
+                    "cache:race",
+                    source,
+                    redis=redis,
+                    poll_interval=0.01,
+                )
+            )
+
+        threads = [
+            threading.Thread(target=worker, name="t1"),
+            threading.Thread(target=worker, name="t2"),
+        ]
+        for thread in threads:
+            thread.start()
+        for thread in threads:
+            thread.join(timeout=10)
+
+        self.assertEqual(results["t1"], "x")
+        self.assertEqual(results["t2"], "x")
+        self.assertEqual(len(build_calls), 1)
diff --git a/apps/output/tests.py b/apps/output/tests.py
index b1c7d589..30b22a18 100644
--- a/apps/output/tests.py
+++ b/apps/output/tests.py
@@ -1,31 +1,131 @@
-from django.test import TestCase, Client
+from django.test import TestCase, Client, SimpleTestCase, RequestFactory
 from django.urls import reverse
-from apps.channels.models import Channel, ChannelGroup
+from unittest import skipUnless
+from unittest.mock import patch
+from uuid import uuid4
+from django.db import connection
+from django.test.utils import CaptureQueriesContext
+from apps.channels.models import Channel, ChannelGroup, ChannelProfile, ChannelProfileMembership
 from apps.epg.models import EPGData, EPGSource
+from apps.accounts.models import User
+from apps.m3u.models import M3UAccount
+from apps.output.views import xc_get_series, xc_get_vod_streams
+from apps.vod.models import (
+    M3UMovieRelation,
+    M3USeriesRelation,
+    Movie,
+    Series,
+    VODCategory,
+    VODLogo,
+)
 import xml.etree.ElementTree as ET
+from datetime import timedelta
+
+
+def _response_text(response):
+    """Read body from HttpResponse or StreamingHttpResponse."""
+    if getattr(response, "streaming", False):
+        return b"".join(response.streaming_content).decode()
+    return response.content.decode()
+
+
+def _epg_response_without_redis(cache_key, source, **kwargs):
+    """Test helper: stream EPG directly without Redis chunk caching."""
+    from django.http import StreamingHttpResponse
+
+    response = StreamingHttpResponse(source(), content_type="application/xml")
+    response["Content-Disposition"] = 'attachment; filename="Dispatcharr.xml"'
+    response["Cache-Control"] = "no-cache"
+    return response
+
+
+class OutputEndpointTestMixin:
+    """Isolate HTTP endpoint tests from network ACL, logging, DB teardown, and Redis."""
 
-class OutputM3UTest(TestCase):
     def setUp(self):
+        super().setUp()
+        self._network_patch = patch(
+            "apps.output.views.network_access_allowed",
+            return_value=True,
+        )
+        self._epg_teardown_patch = patch("apps.output.epg._epg_export_teardown")
+        self._log_event_patch = patch("apps.output.views.log_system_event")
+        self._epg_log_event_patch = patch("apps.output.epg.log_system_event")
+        self._close_db_patch = patch("django.db.close_old_connections")
+        self._epg_cache_patch = patch(
+            "apps.output.epg.stream_cached_response",
+            side_effect=_epg_response_without_redis,
+        )
+        self._network_patch.start()
+        self._epg_teardown_patch.start()
+        self._log_event_patch.start()
+        self._epg_log_event_patch.start()
+        self._close_db_patch.start()
+        self._epg_cache_patch.start()
+
+    def tearDown(self):
+        from django.core.cache import cache
+
+        cache.clear()
+        self._epg_cache_patch.stop()
+        self._close_db_patch.stop()
+        self._epg_log_event_patch.stop()
+        self._log_event_patch.stop()
+        self._epg_teardown_patch.stop()
+        self._network_patch.stop()
+        super().tearDown()
+
+    def _create_isolated_profile(self, prefix):
+        """New profiles auto-include every channel via signal; clear that for tests."""
+        profile = ChannelProfile.objects.create(name=f"{prefix}-{uuid4().hex[:8]}")
+        ChannelProfileMembership.objects.filter(channel_profile=profile).delete()
+        return profile
+
+    def _add_channel_to_profile(self, profile, group, **kwargs):
+        channel = Channel.objects.create(channel_group=group, **kwargs)
+        ChannelProfileMembership.objects.create(
+            channel_profile=profile,
+            channel=channel,
+            enabled=True,
+        )
+        return channel
+
+
+class OutputM3UTest(OutputEndpointTestMixin, TestCase):
+    def setUp(self):
+        super().setUp()
         self.client = Client()
-    
+        self.group = ChannelGroup.objects.create(name=f"M3U Group {uuid4().hex[:8]}")
+        self.profile = self._create_isolated_profile("m3u")
+        self._add_channel_to_profile(
+            self.profile,
+            self.group,
+            channel_number=1.0,
+            name="Test M3U Channel",
+        )
+
+    def _m3u_url(self):
+        return reverse("output:m3u_endpoint", kwargs={"profile_name": self.profile.name})
+
     def test_generate_m3u_response(self):
         """
         Test that the M3U endpoint returns a valid M3U file.
         """
-        url = reverse('output:generate_m3u')
-        response = self.client.get(url)
+        response = self.client.get(self._m3u_url())
         self.assertEqual(response.status_code, 200)
-        content = response.content.decode()
+        content = _response_text(response)
         self.assertIn("#EXTM3U", content)
 
     def test_generate_m3u_response_post_empty_body(self):
         """
         Test that a POST request with an empty body returns 200 OK.
         """
-        url = reverse('output:generate_m3u')
-
-        response = self.client.post(url, data=None, content_type='application/x-www-form-urlencoded')
-        content = response.content.decode()
+        response = self.client.post(
+            self._m3u_url(),
+            data=None,
+            content_type="application/x-www-form-urlencoded",
+        )
+        content = _response_text(response)
 
         self.assertEqual(response.status_code, 200, "POST with empty body should return 200 OK")
         self.assertIn("#EXTM3U", content)
@@ -34,35 +134,40 @@ class OutputM3UTest(TestCase):
         """
         Test that a POST request with a non-empty body returns 403 Forbidden.
         """
-        url = reverse('output:generate_m3u')
-
-        response = self.client.post(url, data={'evilstring': 'muhahaha'})
+        response = self.client.post(self._m3u_url(), data={"evilstring": "muhahaha"})
 
         self.assertEqual(response.status_code, 403, "POST with body should return 403 Forbidden")
-        self.assertIn("POST requests with body are not allowed, body is:", response.content.decode())
+        self.assertIn("POST requests with body are not allowed", _response_text(response))
 
 
-class OutputEPGXMLEscapingTest(TestCase):
+class OutputEPGXMLEscapingTest(OutputEndpointTestMixin, TestCase):
     """Test XML escaping of channel_id attributes in EPG generation"""
 
     def setUp(self):
+        super().setUp()
         self.client = Client()
-        self.group = ChannelGroup.objects.create(name="Test Group")
+        self.group = ChannelGroup.objects.create(name=f"Test Group {uuid4().hex[:8]}")
+        self.profile = self._create_isolated_profile("epg-xml")
+
+    def _add_channel(self, **kwargs):
+        return self._add_channel_to_profile(self.profile, self.group, **kwargs)
+
+    def _epg_url(self, query="tvg_id_source=tvg_id&days=0&prev_days=0"):
+        base = reverse("output:epg_endpoint", kwargs={"profile_name": self.profile.name})
+        return f"{base}?{query}"
 
     def test_channel_id_with_ampersand(self):
         """Test channel ID with ampersand is properly escaped"""
-        channel = Channel.objects.create(
+        self._add_channel(
             channel_number=1.0,
             name="Test Channel",
             tvg_id="News & Sports",
-            channel_group=self.group
         )
 
-        url = reverse('output:generate_epg') + '?tvg_id_source=tvg_id'
-        response = self.client.get(url)
+        response = self.client.get(self._epg_url())
 
         self.assertEqual(response.status_code, 200)
-        content = response.content.decode()
+        content = _response_text(response)
 
         # Should contain escaped ampersand
         self.assertIn('id="News &amp; Sports"', content)
@@ -76,17 +181,15 @@ class OutputEPGXMLEscapingTest(TestCase):
 
     def test_channel_id_with_angle_brackets(self):
         """Test channel ID with < and > characters"""
-        channel = Channel.objects.create(
+        self._add_channel(
             channel_number=2.0,
             name="HD Channel",
             tvg_id="Channel <HD>",
-            channel_group=self.group
         )
 
-        url = reverse('output:generate_epg') + '?tvg_id_source=tvg_id'
-        response = self.client.get(url)
+        response = self.client.get(self._epg_url())
 
-        content = response.content.decode()
+        content = _response_text(response)
         self.assertIn('id="Channel &lt;HD&gt;"', content)
 
         try:
@@ -96,23 +199,28 @@ class OutputEPGXMLEscapingTest(TestCase):
 
     def test_channel_id_with_all_special_chars(self):
         """Test channel ID with all XML special characters"""
-        channel = Channel.objects.create(
+        expected_id = 'Test & "Special" <Chars>'
+        self._add_channel(
             channel_number=3.0,
             name="Complex Channel",
-            tvg_id='Test & "Special" <Chars>',
-            channel_group=self.group
+            tvg_id=expected_id,
         )
 
-        url = reverse('output:generate_epg') + '?tvg_id_source=tvg_id'
-        response = self.client.get(url)
+        response = self.client.get(self._epg_url())
 
-        content = response.content.decode()
+        content = _response_text(response)
         self.assertIn('id="Test &amp; &quot;Special&quot; &lt;Chars&gt;"', content)
 
         try:
             tree = ET.fromstring(content)
-            # Verify we can find the channel with correct ID in parsed tree
-            channel_elem = tree.find('.//channel[@id="Test & \\"Special\\" <Chars>"]')
+            channel_elem = next(
+                (
+                    elem
+                    for elem in tree.findall(".//channel")
+                    if elem.get("id") == expected_id
+                ),
+                None,
+            )
             self.assertIsNotNone(channel_elem)
         except ET.ParseError as e:
             self.fail(f"Generated EPG with all special chars is not valid XML: {e}")
@@ -121,25 +229,670 @@ class OutputEPGXMLEscapingTest(TestCase):
         """Test that programme elements also have escaped channel attributes"""
         epg_source = EPGSource.objects.create(name="Test EPG", source_type="dummy")
         epg_data = EPGData.objects.create(name="Test EPG Data", epg_source=epg_source)
-        channel = Channel.objects.create(
+        self._add_channel(
             channel_number=4.0,
             name="Program Test",
             tvg_id="News & Sports",
             epg_data=epg_data,
-            channel_group=self.group
         )
 
-        url = reverse('output:generate_epg') + '?tvg_id_source=tvg_id'
-        response = self.client.get(url)
+        response = self.client.get(self._epg_url())
 
-        content = response.content.decode()
+        content = _response_text(response)
 
         # Check programme elements have escaped channel attributes
         self.assertIn('channel="News &amp; Sports"', content)
 
         try:
             tree = ET.fromstring(content)
-            programmes = tree.findall('.//programme[@channel="News & Sports"]')
+            programmes = [
+                programme
+                for programme in tree.findall(".//programme")
+                if programme.get("channel") == "News & Sports"
+            ]
             self.assertGreater(len(programmes), 0)
         except ET.ParseError as e:
             self.fail(f"Generated EPG with programme elements is not valid XML: {e}")
+
+    def test_programmes_emitted_in_start_time_order(self):
+        """Programmes for a channel are emitted in start_time order, not insert order."""
+        from django.utils import timezone
+        from apps.epg.models import ProgramData
+
+        epg_source = EPGSource.objects.create(name="Real EPG", source_type="xmltv")
+        epg_data = EPGData.objects.create(name="Station", epg_source=epg_source, tvg_id="station1")
+        self._add_channel(
+            channel_number=149.0,
+            name="Food Network",
+            tvg_id="station1",
+            epg_data=epg_data,
+        )
+        now = timezone.now()
+        # Insert out of chronological order so id order != start_time order.
+        ProgramData.objects.create(
+            epg=epg_data,
+            start_time=now + timedelta(days=3),
+            end_time=now + timedelta(days=3, hours=1),
+            title="Third",
+            tvg_id="station1",
+        )
+        ProgramData.objects.create(
+            epg=epg_data,
+            start_time=now + timedelta(days=1),
+            end_time=now + timedelta(days=1, hours=1),
+            title="First",
+            tvg_id="station1",
+        )
+        ProgramData.objects.create(
+            epg=epg_data,
+            start_time=now + timedelta(days=2),
+            end_time=now + timedelta(days=2, hours=1),
+            title="Second",
+            tvg_id="station1",
+        )
+
+        content = _response_text(self.client.get(self._epg_url("tvg_id_source=tvg_id&days=7")))
+
+        self.assertLess(content.find('<title>First</title>'), content.find('<title>Second</title>'))
+        self.assertLess(content.find('<title>Second</title>'), content.find('<title>Third</title>'))
+
+
+class OutputEPGCustomDummyTest(TestCase):
+    """Custom dummy EPG must not fall back to default when pattern matched but event is outside window."""
+
+    def setUp(self):
+        self.group = ChannelGroup.objects.create(name="Sports Group")
+
+    def test_custom_dummy_outside_window_fills_with_ended_programmes(self):
+        from django.utils import timezone
+        from apps.output.views import generate_dummy_programs
+
+        epg_source = EPGSource.objects.create(
+            name="NHL Dummy",
+            source_type="dummy",
+            custom_properties={
+                "title_pattern": r"(?<league>.*)\s\d+:\s(?<team1>.*?)(?:\s+vs\s+)(?<team2>.*?)\s*@.*",
+                "time_pattern": r"(?<hour>\d{1,2}):(?<minute>\d{2})\s*(?<ampm>AM|PM)",
+                "date_pattern": r"@ (?<month>[A-Za-z]+)\s+(?<day>\d{1,2})",
+                "timezone": "US/Eastern",
+                "program_duration": 180,
+            },
+        )
+        channel_name = (
+            "NHL 01: Washington Capitals vs Philadelphia Flyers @ April 16 07:30 PM ET"
+        )
+        now = timezone.now()
+        lookback = now - timedelta(days=7)
+
+        programs = generate_dummy_programs(
+            channel_id="nhl01",
+            channel_name=channel_name,
+            num_days=7,
+            epg_source=epg_source,
+            export_lookback=lookback,
+            export_cutoff=now + timedelta(days=7),
+        )
+
+        self.assertGreater(len(programs), 0)
+        self.assertTrue(
+            all(p['end_time'] >= lookback for p in programs),
+            "All programmes should fall inside the export window",
+        )
+        self.assertTrue(
+            any('Ended' in p['description'] for p in programs),
+            "Past events outside the window should still show ended filler",
+        )
+        for program in programs:
+            start = program['start_time']
+            self.assertEqual(start.second, 0)
+            self.assertEqual(start.microsecond, 0)
+            self.assertIn(
+                start.minute, (0, 30),
+                "Filler programmes should start on half-hour boundaries",
+            )
+        self.assertGreaterEqual(programs[0]['start_time'], lookback)
+
+    def test_custom_dummy_future_event_fills_grid_window_with_upcoming(self):
+        """Grid-style window: future event should show upcoming filler, not empty."""
+        from django.utils import timezone
+        from apps.output.epg import _programme_overlaps_export_window, generate_dummy_programs
+
+        epg_source = EPGSource.objects.create(
+            name="NHL Dummy Future",
+            source_type="dummy",
+            custom_properties={
+                "title_pattern": r"(?<league>.*)\s\d+:\s(?<team1>.*?)(?:\s+vs\s+)(?<team2>.*?)\s*@.*",
+                "time_pattern": r"(?<hour>\d{1,2}):(?<minute>\d{2})\s*(?<ampm>AM|PM)",
+                "date_pattern": r"@ (?<month>[A-Za-z]+)\s+(?<day>\d{1,2})",
+                "timezone": "US/Eastern",
+                "program_duration": 180,
+            },
+        )
+        now = timezone.now()
+        grid_start = now - timedelta(hours=1)
+        grid_end = now + timedelta(hours=24)
+        future = now + timedelta(days=3)
+        channel_name = (
+            f"NHL 01: Washington Capitals vs Philadelphia Flyers @ "
+            f"{future.strftime('%B')} {future.day} 07:30 PM ET"
+        )
+
+        programs = generate_dummy_programs(
+            channel_id="nhl01",
+            channel_name=channel_name,
+            num_days=1,
+            epg_source=epg_source,
+            export_lookback=grid_start,
+            export_cutoff=grid_end,
+        )
+
+        self.assertGreater(len(programs), 0)
+        self.assertTrue(
+            all(
+                _programme_overlaps_export_window(
+                    p["start_time"], p["end_time"], grid_start, grid_end
+                )
+                for p in programs
+            ),
+            "All programmes should overlap the grid query window",
+        )
+        self.assertTrue(
+            any("Upcoming" in p.get("description", "") for p in programs),
+            "Future events outside the window should show upcoming filler",
+        )
+
+
+class OutputEPGHelperTest(SimpleTestCase):
+    def test_ceil_to_half_hour_on_boundary(self):
+        from django.utils import timezone
+        from apps.output.epg import _ceil_to_half_hour
+
+        dt = timezone.now().replace(minute=30, second=0, microsecond=0)
+        self.assertEqual(_ceil_to_half_hour(dt), dt)
+
+    def test_ceil_to_half_hour_rounds_up(self):
+        from django.utils import timezone
+        from apps.output.epg import _ceil_to_half_hour
+
+        dt = timezone.now().replace(minute=17, second=42, microsecond=123456)
+        aligned = _ceil_to_half_hour(dt)
+        self.assertEqual(aligned.minute, 30)
+        self.assertEqual(aligned.second, 0)
+        self.assertGreaterEqual(aligned, dt.replace(microsecond=0))
+
+    def test_ceil_to_half_hour_past_boundary_second(self):
+        from django.utils import timezone
+        from apps.output.epg import _ceil_to_half_hour
+
+        dt = timezone.now().replace(minute=0, second=52, microsecond=123456)
+        aligned = _ceil_to_half_hour(dt)
+        self.assertEqual(aligned.minute, 30)
+        self.assertEqual(aligned.second, 0)
+        self.assertGreaterEqual(aligned, dt.replace(microsecond=0))
+
+
+class XcVodSeriesDistinctTests(TestCase):
+    def setUp(self):
+        self.factory = RequestFactory()
+        self.user = User.objects.create_user(
+            username=f"xc-{uuid4().hex[:8]}",
+            password="pass",
+            custom_properties={"xc_password": "xcpass"},
+        )
+        self.request = self.factory.get("/player_api.php")
+
+    def _account(self, name, *, priority=0, is_active=True):
+        return M3UAccount.objects.create(
+            name=name,
+            server_url="http://example.com",
+            priority=priority,
+            is_active=is_active,
+        )
+
+    def test_vod_streams_picks_highest_priority_relation(self):
+        low = self._account(f"low-{uuid4().hex[:6]}", priority=1)
+        high = self._account(f"high-{uuid4().hex[:6]}", priority=10)
+        movie = Movie.objects.create(name="Shared Movie", year=2020)
+        M3UMovieRelation.objects.create(
+            m3u_account=low,
+            movie=movie,
+            stream_id="low-stream",
+            container_extension="mkv",
+        )
+        M3UMovieRelation.objects.create(
+            m3u_account=high,
+            movie=movie,
+            stream_id="high-stream",
+            container_extension="mp4",
+        )
+
+        streams = xc_get_vod_streams(self.request, self.user)
+
+        self.assertEqual(len(streams), 1)
+        self.assertEqual(streams[0]["name"], "Shared Movie")
+        self.assertEqual(streams[0]["container_extension"], "mp4")
+
+    def test_vod_streams_excludes_inactive_accounts(self):
+        active = self._account(f"active-{uuid4().hex[:6]}", priority=1)
+        inactive = self._account(
+            f"inactive-{uuid4().hex[:6]}", priority=99, is_active=False
+        )
+        active_movie = Movie.objects.create(name="Active Movie")
+        inactive_movie = Movie.objects.create(name="Inactive Only Movie")
+        M3UMovieRelation.objects.create(
+            m3u_account=active,
+            movie=active_movie,
+            stream_id="active-1",
+        )
+        M3UMovieRelation.objects.create(
+            m3u_account=inactive,
+            movie=inactive_movie,
+            stream_id="inactive-1",
+        )
+
+        streams = xc_get_vod_streams(self.request, self.user)
+
+        names = {s["name"] for s in streams}
+        self.assertEqual(names, {"Active Movie"})
+
+    def test_vod_streams_category_filter(self):
+        account = self._account(f"acct-{uuid4().hex[:6]}")
+        action = VODCategory.objects.create(name="Action", category_type="movie")
+        comedy = VODCategory.objects.create(name="Comedy", category_type="movie")
+        action_movie = Movie.objects.create(name="Action Movie")
+        comedy_movie = Movie.objects.create(name="Comedy Movie")
+        M3UMovieRelation.objects.create(
+            m3u_account=account,
+            movie=action_movie,
+            category=action,
+            stream_id="action-1",
+        )
+        M3UMovieRelation.objects.create(
+            m3u_account=account,
+            movie=comedy_movie,
+            category=comedy,
+            stream_id="comedy-1",
+        )
+
+        streams = xc_get_vod_streams(self.request, self.user, category_id=action.id)
+
+        self.assertEqual(len(streams), 1)
+        self.assertEqual(streams[0]["name"], "Action Movie")
+        self.assertEqual(streams[0]["category_id"], str(action.id))
+
+    def test_vod_streams_sorted_alphabetically_by_name(self):
+        account = self._account(f"acct-{uuid4().hex[:6]}")
+        zebra = Movie.objects.create(name="Zebra Film")
+        apple = Movie.objects.create(name="Apple Film")
+        M3UMovieRelation.objects.create(
+            m3u_account=account, movie=zebra, stream_id="z-1"
+        )
+        M3UMovieRelation.objects.create(
+            m3u_account=account, movie=apple, stream_id="a-1"
+        )
+
+        streams = xc_get_vod_streams(self.request, self.user)
+
+        self.assertEqual([s["name"] for s in streams], ["Apple Film", "Zebra Film"])
+
+    def test_vod_streams_includes_metadata_fields(self):
+        account = self._account(f"acct-{uuid4().hex[:6]}")
+        movie = Movie.objects.create(
+            name="Rich Movie",
+            description="A plot",
+            genre="Drama",
+            year=2021,
+            rating="8",
+            custom_properties={
+                "director": "Dir",
+                "actors": "Cast",
+                "release_date": "2021-01-01",
+                "youtube_trailer": "yt123",
+            },
+        )
+        M3UMovieRelation.objects.create(
+            m3u_account=account,
+            movie=movie,
+            stream_id="rich-1",
+            container_extension="avi",
+        )
+
+        stream = xc_get_vod_streams(self.request, self.user)[0]
+
+        self.assertEqual(stream["plot"], "A plot")
+        self.assertEqual(stream["genre"], "Drama")
+        self.assertEqual(stream["year"], 2021)
+        self.assertEqual(stream["director"], "Dir")
+        self.assertEqual(stream["cast"], "Cast")
+        self.assertEqual(stream["release_date"], "2021-01-01")
+        self.assertEqual(stream["trailer"], "yt123")
+        self.assertEqual(stream["container_extension"], "avi")
+
+    def test_vod_streams_stream_icon_uses_logo_id_without_logo_join(self):
+        account = self._account(f"acct-{uuid4().hex[:6]}")
+        logo = VODLogo.objects.create(name="Poster", url="http://example.com/poster.png")
+        movie = Movie.objects.create(name="Logo Movie", logo=logo)
+        M3UMovieRelation.objects.create(
+            m3u_account=account,
+            movie=movie,
+            stream_id="logo-1",
+        )
+
+        stream = xc_get_vod_streams(self.request, self.user)[0]
+
+        self.assertIn(f"/{logo.id}/", stream["stream_icon"])
+
+    def test_series_picks_highest_priority_relation(self):
+        low = self._account(f"low-{uuid4().hex[:6]}", priority=1)
+        high = self._account(f"high-{uuid4().hex[:6]}", priority=10)
+        series = Series.objects.create(name="Shared Series", year=2019)
+        M3USeriesRelation.objects.create(
+            m3u_account=low,
+            series=series,
+            external_series_id="low-series",
+        )
+        high_rel = M3USeriesRelation.objects.create(
+            m3u_account=high,
+            series=series,
+            external_series_id="high-series",
+        )
+
+        results = xc_get_series(self.request, self.user)
+
+        self.assertEqual(len(results), 1)
+        self.assertEqual(results[0]["name"], "Shared Series")
+        self.assertEqual(results[0]["series_id"], high_rel.id)
+
+    def test_series_excludes_inactive_accounts(self):
+        active = self._account(f"active-{uuid4().hex[:6]}")
+        inactive = self._account(f"inactive-{uuid4().hex[:6]}", is_active=False)
+        active_series = Series.objects.create(name="Active Series")
+        inactive_series = Series.objects.create(name="Inactive Only Series")
+        M3USeriesRelation.objects.create(
+            m3u_account=active,
+            series=active_series,
+            external_series_id="active-s",
+        )
+        M3USeriesRelation.objects.create(
+            m3u_account=inactive,
+            series=inactive_series,
+            external_series_id="inactive-s",
+        )
+
+        results = xc_get_series(self.request, self.user)
+
+        self.assertEqual({r["name"] for r in results}, {"Active Series"})
+
+    def test_series_sorted_alphabetically_by_name(self):
+        account = self._account(f"acct-{uuid4().hex[:6]}")
+        z = Series.objects.create(name="Zulu Show")
+        a = Series.objects.create(name="Alpha Show")
+        M3USeriesRelation.objects.create(
+            m3u_account=account, series=z, external_series_id="z"
+        )
+        M3USeriesRelation.objects.create(
+            m3u_account=account, series=a, external_series_id="a"
+        )
+
+        results = xc_get_series(self.request, self.user)
+
+        self.assertEqual([r["name"] for r in results], ["Alpha Show", "Zulu Show"])
+
+    @skipUnless(connection.vendor == "postgresql", "PostgreSQL-specific query shape")
+    def test_vod_streams_dedupe_query_avoids_movie_join(self):
+        account = self._account(f"acct-{uuid4().hex[:6]}")
+        movie = Movie.objects.create(name="Query Shape Movie")
+        M3UMovieRelation.objects.create(
+            m3u_account=account, movie=movie, stream_id="qs-1"
+        )
+
+        with CaptureQueriesContext(connection) as ctx:
+            xc_get_vod_streams(self.request, self.user)
+
+        distinct_queries = [q for q in ctx.captured_queries if "DISTINCT" in q["sql"]]
+        self.assertEqual(len(distinct_queries), 1)
+        self.assertNotIn('"vod_movie"', distinct_queries[0]["sql"])
+        self.assertNotIn('"vod_vodlogo"', distinct_queries[0]["sql"])
+
+        fetch_queries = [
+            q
+            for q in ctx.captured_queries
+            if '"vod_movie"' in q["sql"] and "DISTINCT" not in q["sql"]
+        ]
+        self.assertGreaterEqual(len(fetch_queries), 1)
+        fetch_sql = fetch_queries[0]["sql"]
+        self.assertNotIn('"vod_vodlogo"', fetch_sql)
+        self.assertNotIn('"vod_vodcategory"', fetch_sql)
+
+    @skipUnless(connection.vendor == "postgresql", "PostgreSQL-specific query shape")
+    def test_series_dedupe_query_avoids_series_join(self):
+        account = self._account(f"acct-{uuid4().hex[:6]}")
+        series = Series.objects.create(name="Query Shape Series")
+        M3USeriesRelation.objects.create(
+            m3u_account=account, series=series, external_series_id="qs-s"
+        )
+
+        with CaptureQueriesContext(connection) as ctx:
+            xc_get_series(self.request, self.user)
+
+        distinct_queries = [q for q in ctx.captured_queries if "DISTINCT" in q["sql"]]
+        self.assertEqual(len(distinct_queries), 1)
+        self.assertNotIn('"vod_series"', distinct_queries[0]["sql"])
+
+        fetch_queries = [
+            q
+            for q in ctx.captured_queries
+            if '"vod_series"' in q["sql"] and "DISTINCT" not in q["sql"]
+        ]
+        self.assertGreaterEqual(len(fetch_queries), 1)
+        fetch_sql = fetch_queries[0]["sql"]
+        self.assertNotIn('"vod_vodlogo"', fetch_sql)
+        self.assertNotIn('"vod_vodcategory"', fetch_sql)
+
+
+XC_VOD_STREAM_KEYS = frozenset({
+    "num", "name", "stream_type", "stream_id", "stream_icon", "rating",
+    "rating_5based", "added", "is_adult", "tmdb_id", "imdb_id", "trailer",
+    "plot", "genre", "year", "director", "cast", "release_date", "category_id",
+    "category_ids", "container_extension", "custom_sid", "direct_source",
+})
+
+XC_SERIES_KEYS = frozenset({
+    "num", "name", "series_id", "cover", "plot", "cast", "director", "genre",
+    "release_date", "releaseDate", "last_modified", "rating", "rating_5based",
+    "backdrop_path", "youtube_trailer", "episode_run_time", "category_id",
+    "category_ids", "tmdb_id", "imdb_id",
+})
+
+
+class XcVodSeriesRegressionTests(TestCase):
+    """Full output-shape and edge-case regressions for XC list endpoints."""
+
+    def setUp(self):
+        self.factory = RequestFactory()
+        self.user = User.objects.create_user(
+            username=f"xc-reg-{uuid4().hex[:8]}",
+            password="pass",
+            custom_properties={"xc_password": "xcpass"},
+        )
+        self.request = self.factory.get("/player_api.php")
+
+    def _account(self, name, *, priority=0):
+        return M3UAccount.objects.create(
+            name=name,
+            server_url="http://example.com",
+            priority=priority,
+        )
+
+    def test_vod_streams_empty_library(self):
+        self.assertEqual(xc_get_vod_streams(self.request, self.user), [])
+
+    def test_series_empty_library(self):
+        self.assertEqual(xc_get_series(self.request, self.user), [])
+
+    def test_vod_streams_response_keys(self):
+        account = self._account(f"acct-{uuid4().hex[:6]}")
+        movie = Movie.objects.create(name="Schema Movie", rating="10")
+        M3UMovieRelation.objects.create(
+            m3u_account=account, movie=movie, stream_id="schema-1"
+        )
+
+        stream = xc_get_vod_streams(self.request, self.user)[0]
+
+        self.assertEqual(set(stream.keys()), XC_VOD_STREAM_KEYS)
+        self.assertEqual(stream["stream_type"], "movie")
+        self.assertEqual(stream["stream_id"], movie.id)
+        self.assertEqual(stream["rating_5based"], 5.0)
+        self.assertEqual(stream["custom_sid"], None)
+        self.assertEqual(stream["direct_source"], "")
+
+    def test_vod_streams_null_optional_fields(self):
+        account = self._account(f"acct-{uuid4().hex[:6]}")
+        movie = Movie.objects.create(name="Sparse Movie")
+        M3UMovieRelation.objects.create(
+            m3u_account=account,
+            movie=movie,
+            stream_id="sparse-1",
+            container_extension=None,
+        )
+
+        stream = xc_get_vod_streams(self.request, self.user)[0]
+
+        self.assertIsNone(stream["stream_icon"])
+        self.assertEqual(stream["category_id"], "0")
+        self.assertEqual(stream["category_ids"], [])
+        self.assertEqual(stream["container_extension"], "mp4")
+        self.assertEqual(stream["plot"], "")
+        self.assertEqual(stream["trailer"], "")
+        self.assertEqual(stream["tmdb_id"], "")
+        self.assertEqual(stream["imdb_id"], "")
+
+    def test_vod_streams_category_from_winning_relation(self):
+        """Category must come from the highest-priority relation, not any relation."""
+        low = self._account(f"low-{uuid4().hex[:6]}", priority=1)
+        high = self._account(f"high-{uuid4().hex[:6]}", priority=10)
+        action = VODCategory.objects.create(name="Action", category_type="movie")
+        comedy = VODCategory.objects.create(name="Comedy", category_type="movie")
+        movie = Movie.objects.create(name="Dual Category Movie")
+        M3UMovieRelation.objects.create(
+            m3u_account=low,
+            movie=movie,
+            category=action,
+            stream_id="low-cat",
+        )
+        M3UMovieRelation.objects.create(
+            m3u_account=high,
+            movie=movie,
+            category=comedy,
+            stream_id="high-cat",
+        )
+
+        stream = xc_get_vod_streams(self.request, self.user)[0]
+
+        self.assertEqual(stream["category_id"], str(comedy.id))
+        self.assertEqual(stream["category_ids"], [comedy.id])
+
+    def test_series_response_keys_and_metadata(self):
+        account = self._account(f"acct-{uuid4().hex[:6]}")
+        logo = VODLogo.objects.create(name="Cover", url="http://example.com/cover.png")
+        category = VODCategory.objects.create(name="Drama", category_type="series")
+        series = Series.objects.create(
+            name="Schema Series",
+            description="Series plot",
+            genre="Sci-Fi",
+            year=2022,
+            rating="8",
+            tmdb_id="tm123",
+            imdb_id="tt123",
+            logo=logo,
+            custom_properties={
+                "cast": "Actor A",
+                "director": "Director B",
+                "release_date": "2022-06-01",
+                "backdrop_path": ["/img1.jpg"],
+                "youtube_trailer": "yt-series",
+                "episode_run_time": "45",
+            },
+        )
+        relation = M3USeriesRelation.objects.create(
+            m3u_account=account,
+            series=series,
+            category=category,
+            external_series_id="schema-s",
+        )
+
+        row = xc_get_series(self.request, self.user)[0]
+
+        self.assertEqual(set(row.keys()), XC_SERIES_KEYS)
+        self.assertEqual(row["series_id"], relation.id)
+        self.assertIn(f"/{logo.id}/", row["cover"])
+        self.assertEqual(row["plot"], "Series plot")
+        self.assertEqual(row["cast"], "Actor A")
+        self.assertEqual(row["director"], "Director B")
+        self.assertEqual(row["genre"], "Sci-Fi")
+        self.assertEqual(row["release_date"], "2022-06-01")
+        self.assertEqual(row["releaseDate"], "2022-06-01")
+        self.assertEqual(row["backdrop_path"], ["/img1.jpg"])
+        self.assertEqual(row["youtube_trailer"], "yt-series")
+        self.assertEqual(row["episode_run_time"], "45")
+        self.assertEqual(row["tmdb_id"], "tm123")
+        self.assertEqual(row["imdb_id"], "tt123")
+        self.assertEqual(row["category_id"], str(category.id))
+        self.assertEqual(row["category_ids"], [category.id])
+        self.assertEqual(row["last_modified"], str(int(relation.updated_at.timestamp())))
+
+    def test_series_null_optional_fields(self):
+        account = self._account(f"acct-{uuid4().hex[:6]}")
+        series = Series.objects.create(name="Sparse Series")
+        M3USeriesRelation.objects.create(
+            m3u_account=account,
+            series=series,
+            external_series_id="sparse-s",
+        )
+
+        row = xc_get_series(self.request, self.user)[0]
+
+        self.assertIsNone(row["cover"])
+        self.assertEqual(row["category_id"], "0")
+        self.assertEqual(row["category_ids"], [])
+        self.assertEqual(row["release_date"], "")
+        self.assertEqual(row["releaseDate"], "")
+        self.assertEqual(row["backdrop_path"], [])
+        self.assertEqual(row["youtube_trailer"], "")
+        self.assertEqual(row["episode_run_time"], "")
+
+    def test_series_release_date_falls_back_to_year(self):
+        account = self._account(f"acct-{uuid4().hex[:6]}")
+        series = Series.objects.create(name="Year Only", year=2018)
+        M3USeriesRelation.objects.create(
+            m3u_account=account,
+            series=series,
+            external_series_id="year-s",
+        )
+
+        row = xc_get_series(self.request, self.user)[0]
+
+        self.assertEqual(row["release_date"], "2018")
+        self.assertEqual(row["releaseDate"], "2018")
+
+    def test_priority_tiebreaker_uses_lower_relation_id(self):
+        """Same priority: DISTINCT ON tie-breaks on relation id ascending."""
+        a1 = self._account(f"a1-{uuid4().hex[:6]}", priority=5)
+        a2 = self._account(f"a2-{uuid4().hex[:6]}", priority=5)
+        movie = Movie.objects.create(name="Tie Movie")
+        first = M3UMovieRelation.objects.create(
+            m3u_account=a1,
+            movie=movie,
+            stream_id="first",
+            container_extension="mkv",
+        )
+        M3UMovieRelation.objects.create(
+            m3u_account=a2,
+            movie=movie,
+            stream_id="second",
+            container_extension="mp4",
+        )
+
+        stream = xc_get_vod_streams(self.request, self.user)[0]
+
+        self.assertEqual(stream["container_extension"], first.container_extension)
diff --git a/apps/output/views.py b/apps/output/views.py
index 8bcc37dc..6c4e7c13 100644
--- a/apps/output/views.py
+++ b/apps/output/views.py
@@ -25,9 +25,11 @@ from apps.proxy.utils import get_user_active_connections
 import regex
 from core.utils import log_system_event, build_absolute_uri_with_port
 import hashlib
+from apps.output.epg import generate_epg, generate_dummy_programs
 
 logger = logging.getLogger(__name__)
 
+
 def get_client_identifier(request):
     """Get client information including IP, user agent, and a unique hash identifier
 
@@ -112,6 +114,10 @@ def generate_m3u(request, profile_name=None, user=None):
     # Check if this is a POST request and the body is not empty (which we don't want to allow)
     logger.debug("Generating M3U for profile: %s, user: %s, method: %s", profile_name, user.username if user else "Anonymous", request.method)
 
+    if request.method == "POST" and request.body:
+        if request.body.decode() != '{}':
+            return HttpResponseForbidden("POST requests with body are not allowed.")
+
     # Check cache for recent identical request (helps with double-GET from browsers)
     from django.core.cache import cache
     cache_params = f"{profile_name or 'all'}:{user.username if user else 'anonymous'}:{request.GET.urlencode()}"
@@ -123,10 +129,6 @@ def generate_m3u(request, profile_name=None, user=None):
         response = HttpResponse(cached_content, content_type="audio/x-mpegurl")
         response["Content-Disposition"] = 'attachment; filename="channels.m3u"'
         return response
-    # Check if this is a POST request with data (which we don't want to allow)
-    if request.method == "POST" and request.body:
-        if request.body.decode() != '{}':
-            return HttpResponseForbidden("POST requests with body are not allowed.")
 
     if user is not None:
         if user.user_level < 10:
@@ -338,1630 +340,6 @@ def generate_m3u(request, profile_name=None, user=None):
     return response
 
 
-def generate_fallback_programs(channel_id, channel_name, now, num_days, program_length_hours, fallback_title, fallback_description):
-    """
-    Generate dummy programs using custom fallback templates when patterns don't match.
-
-    Args:
-        channel_id: Channel ID for the programs
-        channel_name: Channel name to use as fallback in templates
-        now: Current datetime (in UTC)
-        num_days: Number of days to generate programs for
-        program_length_hours: Length of each program in hours
-        fallback_title: Custom fallback title template (empty string if not provided)
-        fallback_description: Custom fallback description template (empty string if not provided)
-
-    Returns:
-        List of program dictionaries
-    """
-    programs = []
-
-    # Use custom fallback title or channel name as default
-    title = fallback_title if fallback_title else channel_name
-
-    # Use custom fallback description or a simple default message
-    if fallback_description:
-        description = fallback_description
-    else:
-        description = f"EPG information is currently unavailable for {channel_name}"
-
-    # Create programs for each day
-    for day in range(num_days):
-        day_start = now + timedelta(days=day)
-
-        # Create programs with specified length throughout the day
-        for hour_offset in range(0, 24, program_length_hours):
-            # Calculate program start and end times
-            start_time = day_start + timedelta(hours=hour_offset)
-            end_time = start_time + timedelta(hours=program_length_hours)
-
-            programs.append({
-                "channel_id": channel_id,
-                "start_time": start_time,
-                "end_time": end_time,
-                "title": title,
-                "description": description,
-            })
-
-    return programs
-
-
-def generate_dummy_programs(channel_id, channel_name, num_days=1, program_length_hours=4, epg_source=None):
-    """
-    Generate dummy EPG programs for channels.
-
-    If epg_source is provided and it's a custom dummy EPG with patterns,
-    use those patterns to generate programs from the channel title.
-    Otherwise, generate default dummy programs.
-
-    Args:
-        channel_id: Channel ID for the programs
-        channel_name: Channel title/name
-        num_days: Number of days to generate programs for
-        program_length_hours: Length of each program in hours
-        epg_source: Optional EPGSource for custom dummy EPG with patterns
-
-    Returns:
-        List of program dictionaries
-    """
-    # Get current time rounded to hour
-    now = django_timezone.now()
-    now = now.replace(minute=0, second=0, microsecond=0)
-
-    # Check if this is a custom dummy EPG with regex patterns
-    if epg_source and epg_source.source_type == 'dummy' and epg_source.custom_properties:
-        custom_programs = generate_custom_dummy_programs(
-            channel_id, channel_name, now, num_days,
-            epg_source.custom_properties
-        )
-        # If custom generation succeeded, return those programs
-        # If it returned empty (pattern didn't match), check for custom fallback templates
-        if custom_programs:
-            return custom_programs
-        else:
-            logger.info(f"Custom pattern didn't match for '{channel_name}', checking for custom fallback templates")
-
-            # Check if custom fallback templates are provided
-            custom_props = epg_source.custom_properties
-            fallback_title = custom_props.get('fallback_title_template', '').strip()
-            fallback_description = custom_props.get('fallback_description_template', '').strip()
-
-            # If custom fallback templates exist, use them instead of default
-            if fallback_title or fallback_description:
-                logger.info(f"Using custom fallback templates for '{channel_name}'")
-                return generate_fallback_programs(
-                    channel_id, channel_name, now, num_days,
-                    program_length_hours, fallback_title, fallback_description
-                )
-            else:
-                logger.info(f"No custom fallback templates found, using default dummy EPG")
-
-    # Default humorous program descriptions based on time of day
-    time_descriptions = {
-        (0, 4): [
-            f"Late Night with {channel_name} - Where insomniacs unite!",
-            f"The 'Why Am I Still Awake?' Show on {channel_name}",
-            f"Counting Sheep - A {channel_name} production for the sleepless",
-        ],
-        (4, 8): [
-            f"Dawn Patrol - Rise and shine with {channel_name}!",
-            f"Early Bird Special - Coffee not included",
-            f"Morning Zombies - Before coffee viewing on {channel_name}",
-        ],
-        (8, 12): [
-            f"Mid-Morning Meetings - Pretend you're paying attention while watching {channel_name}",
-            f"The 'I Should Be Working' Hour on {channel_name}",
-            f"Productivity Killer - {channel_name}'s daytime programming",
-        ],
-        (12, 16): [
-            f"Lunchtime Laziness with {channel_name}",
-            f"The Afternoon Slump - Brought to you by {channel_name}",
-            f"Post-Lunch Food Coma Theater on {channel_name}",
-        ],
-        (16, 20): [
-            f"Rush Hour - {channel_name}'s alternative to traffic",
-            f"The 'What's For Dinner?' Debate on {channel_name}",
-            f"Evening Escapism - {channel_name}'s remedy for reality",
-        ],
-        (20, 24): [
-            f"Prime Time Placeholder - {channel_name}'s finest not-programming",
-            f"The 'Netflix Was Too Complicated' Show on {channel_name}",
-            f"Family Argument Avoider - Courtesy of {channel_name}",
-        ],
-    }
-
-    programs = []
-
-    # Create programs for each day
-    for day in range(num_days):
-        day_start = now + timedelta(days=day)
-
-        # Create programs with specified length throughout the day
-        for hour_offset in range(0, 24, program_length_hours):
-            # Calculate program start and end times
-            start_time = day_start + timedelta(hours=hour_offset)
-            end_time = start_time + timedelta(hours=program_length_hours)
-
-            # Get the hour for selecting a description
-            hour = start_time.hour
-
-            # Find the appropriate time slot for description
-            for time_range, descriptions in time_descriptions.items():
-                start_range, end_range = time_range
-                if start_range <= hour < end_range:
-                    # Pick a description using the sum of the hour and day as seed
-                    # This makes it somewhat random but consistent for the same timeslot
-                    description = descriptions[(hour + day) % len(descriptions)]
-                    break
-            else:
-                # Fallback description if somehow no range matches
-                description = f"Placeholder program for {channel_name} - EPG data went on vacation"
-
-            programs.append({
-                "channel_id": channel_id,
-                "start_time": start_time,
-                "end_time": end_time,
-                "title": channel_name,
-                "description": description,
-            })
-
-    return programs
-
-
-def generate_custom_dummy_programs(channel_id, channel_name, now, num_days, custom_properties):
-    """
-    Generate programs using custom dummy EPG regex patterns.
-
-    Extracts information from channel title using regex patterns and generates
-    programs based on the extracted data.
-
-    TIMEZONE HANDLING:
-    ------------------
-    The timezone parameter specifies the timezone of the event times in your channel
-    titles using standard timezone names (e.g., 'US/Eastern', 'US/Pacific', 'Europe/London').
-    DST (Daylight Saving Time) is handled automatically by pytz.
-
-    Examples:
-    - Channel: "NHL 01: Bruins VS Maple Leafs @ 8:00PM ET"
-    - Set timezone = "US/Eastern"
-    - In October (DST): 8:00PM EDT → 12:00AM UTC (automatically uses UTC-4)
-    - In January (no DST): 8:00PM EST → 1:00AM UTC (automatically uses UTC-5)
-
-    Args:
-        channel_id: Channel ID for the programs
-        channel_name: Channel title to parse
-        now: Current datetime (in UTC)
-        num_days: Number of days to generate programs for
-        custom_properties: Dict with title_pattern, time_pattern, templates, etc.
-            - timezone: Timezone name (e.g., 'US/Eastern')
-
-    Returns:
-        List of program dictionaries with start_time/end_time in UTC
-    """
-    import pytz
-
-    logger.info(f"Generating custom dummy programs for channel: {channel_name}")
-
-    # Extract patterns from custom properties
-    title_pattern = custom_properties.get('title_pattern', '')
-    time_pattern = custom_properties.get('time_pattern', '')
-    date_pattern = custom_properties.get('date_pattern', '')
-
-    # Get timezone name (e.g., 'US/Eastern', 'US/Pacific', 'Europe/London')
-    timezone_value = custom_properties.get('timezone', 'UTC')
-    output_timezone_value = custom_properties.get('output_timezone', '')  # Optional: display times in different timezone
-    program_duration = custom_properties.get('program_duration', 180)  # Minutes
-    title_template = custom_properties.get('title_template', '')
-    subtitle_template = custom_properties.get('subtitle_template', '')
-    description_template = custom_properties.get('description_template', '')
-
-    # Templates for upcoming/ended programs
-    upcoming_title_template = custom_properties.get('upcoming_title_template', '')
-    upcoming_description_template = custom_properties.get('upcoming_description_template', '')
-    ended_title_template = custom_properties.get('ended_title_template', '')
-    ended_description_template = custom_properties.get('ended_description_template', '')
-
-    # Image URL templates
-    channel_logo_url_template = custom_properties.get('channel_logo_url', '')
-    program_poster_url_template = custom_properties.get('program_poster_url', '')
-
-    # EPG metadata options
-    category_string = custom_properties.get('category', '')
-    # Split comma-separated categories and strip whitespace, filter out empty strings
-    categories = [cat.strip() for cat in category_string.split(',') if cat.strip()] if category_string else []
-    include_date = custom_properties.get('include_date', True)
-    include_live = custom_properties.get('include_live', False)
-    include_new = custom_properties.get('include_new', False)
-
-    # Parse timezone name
-    try:
-        source_tz = pytz.timezone(timezone_value)
-        logger.debug(f"Using timezone: {timezone_value} (DST will be handled automatically)")
-    except pytz.exceptions.UnknownTimeZoneError:
-        logger.warning(f"Unknown timezone: {timezone_value}, defaulting to UTC")
-        source_tz = pytz.utc
-
-    # Parse output timezone if provided (for display purposes)
-    output_tz = None
-    if output_timezone_value:
-        try:
-            output_tz = pytz.timezone(output_timezone_value)
-            logger.debug(f"Using output timezone for display: {output_timezone_value}")
-        except pytz.exceptions.UnknownTimeZoneError:
-            logger.warning(f"Unknown output timezone: {output_timezone_value}, will use source timezone")
-            output_tz = None
-
-    if not title_pattern:
-        logger.warning(f"No title_pattern in custom_properties, falling back to default")
-        return []  # Return empty, will use default
-
-    logger.debug(f"Title pattern from DB: {repr(title_pattern)}")
-
-    # Convert PCRE/JavaScript named groups (?<name>) to Python format (?P<name>)
-    # This handles patterns created with JavaScript regex syntax
-    # Use negative lookahead to avoid matching lookbehind (?<=) and negative lookbehind (?<!)
-    title_pattern = regex.sub(r'\(\?<(?![=!])([^>]+)>', r'(?P<\1>', title_pattern)
-    logger.debug(f"Converted title pattern: {repr(title_pattern)}")
-
-    # Compile regex patterns using the enhanced regex module
-    # (supports variable-width lookbehinds like JavaScript)
-    try:
-        title_regex = regex.compile(title_pattern)
-    except Exception as e:
-        logger.error(f"Invalid title regex pattern after conversion: {e}")
-        logger.error(f"Pattern was: {repr(title_pattern)}")
-        return []
-
-    time_regex = None
-    if time_pattern:
-        # Convert PCRE/JavaScript named groups to Python format
-        # Use negative lookahead to avoid matching lookbehind (?<=) and negative lookbehind (?<!)
-        time_pattern = regex.sub(r'\(\?<(?![=!])([^>]+)>', r'(?P<\1>', time_pattern)
-        logger.debug(f"Converted time pattern: {repr(time_pattern)}")
-        try:
-            time_regex = regex.compile(time_pattern)
-        except Exception as e:
-            logger.warning(f"Invalid time regex pattern after conversion: {e}")
-            logger.warning(f"Pattern was: {repr(time_pattern)}")
-
-    # Compile date regex if provided
-    date_regex = None
-    if date_pattern:
-        # Convert PCRE/JavaScript named groups to Python format
-        # Use negative lookahead to avoid matching lookbehind (?<=) and negative lookbehind (?<!)
-        date_pattern = regex.sub(r'\(\?<(?![=!])([^>]+)>', r'(?P<\1>', date_pattern)
-        logger.debug(f"Converted date pattern: {repr(date_pattern)}")
-        try:
-            date_regex = regex.compile(date_pattern)
-        except Exception as e:
-            logger.warning(f"Invalid date regex pattern after conversion: {e}")
-            logger.warning(f"Pattern was: {repr(date_pattern)}")
-
-    # Try to match the channel name with the title pattern
-    # Use search() instead of match() to match JavaScript behavior where .match() searches anywhere in the string
-    title_match = title_regex.search(channel_name)
-    if not title_match:
-        logger.debug(f"Channel name '{channel_name}' doesn't match title pattern")
-        return []  # Return empty, will use default
-
-    groups = title_match.groupdict()
-    logger.debug(f"Title pattern matched. Groups: {groups}")
-
-    # Helper function to format template with matched groups
-    def format_template(template, groups, url_encode=False):
-        """Replace {groupname} placeholders with matched group values
-
-        Args:
-            template: Template string with {groupname} placeholders
-            groups: Dict of group names to values
-            url_encode: If True, URL encode the group values for safe use in URLs
-        """
-        if not template:
-            return ''
-        result = template
-        for key, value in groups.items():
-            if url_encode and value:
-                # URL encode the value to handle spaces and special characters
-                from urllib.parse import quote
-                encoded_value = quote(str(value), safe='')
-                result = result.replace(f'{{{key}}}', encoded_value)
-            else:
-                result = result.replace(f'{{{key}}}', str(value) if value else '')
-        return result
-
-    # Extract time from title if time pattern exists
-    time_info = None
-    time_groups = {}
-    if time_regex:
-        time_match = time_regex.search(channel_name)
-        if time_match:
-            time_groups = time_match.groupdict()
-            try:
-                hour = int(time_groups.get('hour'))
-                # Handle optional minute group - could be None if not captured
-                minute_value = time_groups.get('minute')
-                minute = int(minute_value) if minute_value is not None else 0
-                ampm = time_groups.get('ampm')
-                ampm = ampm.lower() if ampm else None
-
-                # Determine if this is 12-hour or 24-hour format
-                if ampm in ('am', 'pm'):
-                    # 12-hour format: convert to 24-hour
-                    if ampm == 'pm' and hour != 12:
-                        hour += 12
-                    elif ampm == 'am' and hour == 12:
-                        hour = 0
-                    logger.debug(f"Extracted time (12-hour): {hour}:{minute:02d} {ampm}")
-                else:
-                    # 24-hour format: hour is already in 24-hour format
-                    # Validate that it's actually a 24-hour time (0-23)
-                    if hour > 23:
-                        logger.warning(f"Invalid 24-hour time: {hour}. Must be 0-23.")
-                        hour = hour % 24  # Wrap around just in case
-                    logger.debug(f"Extracted time (24-hour): {hour}:{minute:02d}")
-
-                time_info = {'hour': hour, 'minute': minute}
-            except (ValueError, TypeError) as e:
-                logger.warning(f"Error parsing time: {e}")
-
-    # Extract date from title if date pattern exists
-    date_info = None
-    date_groups = {}
-    if date_regex:
-        date_match = date_regex.search(channel_name)
-        if date_match:
-            date_groups = date_match.groupdict()
-            try:
-                # Support various date group names: month, day, year
-                month_str = date_groups.get('month', '')
-                day_str = date_groups.get('day', '')
-                year_str = date_groups.get('year', '')
-
-                # Parse day - default to current day if empty or invalid
-                day = int(day_str) if day_str else now.day
-
-                # Parse year - default to current year if empty or invalid (matches frontend behavior)
-                year = int(year_str) if year_str else now.year
-
-                # Parse month - can be numeric (1-12) or text (Jan, January, etc.)
-                month = None
-                if month_str:
-                    if month_str.isdigit():
-                        month = int(month_str)
-                    else:
-                        # Try to parse text month names
-                        import calendar
-                        month_str_lower = month_str.lower()
-                        # Check full month names
-                        for i, month_name in enumerate(calendar.month_name):
-                            if month_name.lower() == month_str_lower:
-                                month = i
-                                break
-                        # Check abbreviated month names if not found
-                        if month is None:
-                            for i, month_abbr in enumerate(calendar.month_abbr):
-                                if month_abbr.lower() == month_str_lower:
-                                    month = i
-                                    break
-
-                # Default to current month if not extracted or invalid
-                if month is None:
-                    month = now.month
-
-                if month and 1 <= month <= 12 and 1 <= day <= 31:
-                    date_info = {'year': year, 'month': month, 'day': day}
-                    logger.debug(f"Extracted date: {year}-{month:02d}-{day:02d}")
-                else:
-                    logger.warning(f"Invalid date values: month={month}, day={day}, year={year}")
-            except (ValueError, TypeError) as e:
-                logger.warning(f"Error parsing date: {e}")
-
-    # Merge title groups, time groups, and date groups for template formatting
-    all_groups = {**groups, **time_groups, **date_groups}
-
-    # Add normalized versions of all groups for cleaner URLs
-    # These remove all non-alphanumeric characters and convert to lowercase
-    for key, value in list(all_groups.items()):
-        if value:
-            # Remove all non-alphanumeric characters (except spaces temporarily)
-            # then replace spaces with nothing, and convert to lowercase
-            normalized = regex.sub(r'[^a-zA-Z0-9\s]', '', str(value))
-            normalized = regex.sub(r'\s+', '', normalized).lower()
-            all_groups[f'{key}_normalize'] = normalized
-
-    # Format channel logo URL if template provided (with URL encoding)
-    channel_logo_url = None
-    if channel_logo_url_template:
-        channel_logo_url = format_template(channel_logo_url_template, all_groups, url_encode=True)
-        logger.debug(f"Formatted channel logo URL: {channel_logo_url}")
-
-    # Format program poster URL if template provided (with URL encoding)
-    program_poster_url = None
-    if program_poster_url_template:
-        program_poster_url = format_template(program_poster_url_template, all_groups, url_encode=True)
-        logger.debug(f"Formatted program poster URL: {program_poster_url}")
-
-    # Add formatted time strings for better display (handles minutes intelligently)
-    if time_info:
-        hour_24 = time_info['hour']
-        minute = time_info['minute']
-
-        # Determine the base date to use for placeholders
-        # If date was extracted, use it; otherwise use current date
-        if date_info:
-            base_date = datetime(date_info['year'], date_info['month'], date_info['day'])
-        else:
-            base_date = datetime.now()
-
-        # If output_timezone is specified, convert the display time to that timezone
-        if output_tz:
-            # Create a datetime in the source timezone using the base date
-            temp_date = source_tz.localize(base_date.replace(hour=hour_24, minute=minute, second=0, microsecond=0))
-            # Convert to output timezone
-            temp_date_output = temp_date.astimezone(output_tz)
-            # Extract converted hour and minute for display
-            hour_24 = temp_date_output.hour
-            minute = temp_date_output.minute
-            logger.debug(f"Converted display time from {source_tz} to {output_tz}: {hour_24}:{minute:02d}")
-
-            # Add date placeholders based on the OUTPUT timezone
-            # This ensures {date}, {month}, {day}, {year} reflect the converted timezone
-            all_groups['date'] = temp_date_output.strftime('%Y-%m-%d')
-            all_groups['month'] = str(temp_date_output.month)
-            all_groups['day'] = str(temp_date_output.day)
-            all_groups['year'] = str(temp_date_output.year)
-            logger.debug(f"Converted date placeholders to {output_tz}: {all_groups['date']}")
-        else:
-            # No output timezone conversion - use source timezone for date
-            # Create temp date to get proper date in source timezone using the base date
-            temp_date_source = source_tz.localize(base_date.replace(hour=hour_24, minute=minute, second=0, microsecond=0))
-            all_groups['date'] = temp_date_source.strftime('%Y-%m-%d')
-            all_groups['month'] = str(temp_date_source.month)
-            all_groups['day'] = str(temp_date_source.day)
-            all_groups['year'] = str(temp_date_source.year)
-
-        # Format 24-hour start time string - only include minutes if non-zero
-        if minute > 0:
-            all_groups['starttime24'] = f"{hour_24}:{minute:02d}"
-        else:
-            all_groups['starttime24'] = f"{hour_24:02d}:00"
-
-        # Convert 24-hour to 12-hour format for {starttime} placeholder
-        # Note: hour_24 is ALWAYS in 24-hour format at this point (converted earlier if needed)
-        ampm = 'AM' if hour_24 < 12 else 'PM'
-        hour_12 = hour_24
-        if hour_24 == 0:
-            hour_12 = 12
-        elif hour_24 > 12:
-            hour_12 = hour_24 - 12
-
-        # Format 12-hour start time string - only include minutes if non-zero
-        if minute > 0:
-            all_groups['starttime'] = f"{hour_12}:{minute:02d} {ampm}"
-        else:
-            all_groups['starttime'] = f"{hour_12} {ampm}"
-
-        # Format long version that always includes minutes (e.g., "9:00 PM" instead of "9 PM")
-        all_groups['starttime_long'] = f"{hour_12}:{minute:02d} {ampm}"
-
-        # Calculate end time based on program duration
-        # Create a datetime for calculations
-        temp_start = datetime.now(source_tz).replace(hour=hour_24, minute=minute, second=0, microsecond=0)
-        temp_end = temp_start + timedelta(minutes=program_duration)
-
-        # Extract end time components (already in correct timezone if output_tz was applied above)
-        end_hour_24 = temp_end.hour
-        end_minute = temp_end.minute
-
-        # Format 24-hour end time string - only include minutes if non-zero
-        if end_minute > 0:
-            all_groups['endtime24'] = f"{end_hour_24}:{end_minute:02d}"
-        else:
-            all_groups['endtime24'] = f"{end_hour_24:02d}:00"
-
-        # Convert 24-hour to 12-hour format for {endtime} placeholder
-        end_ampm = 'AM' if end_hour_24 < 12 else 'PM'
-        end_hour_12 = end_hour_24
-        if end_hour_24 == 0:
-            end_hour_12 = 12
-        elif end_hour_24 > 12:
-            end_hour_12 = end_hour_24 - 12
-
-        # Format 12-hour end time string - only include minutes if non-zero
-        if end_minute > 0:
-            all_groups['endtime'] = f"{end_hour_12}:{end_minute:02d} {end_ampm}"
-        else:
-            all_groups['endtime'] = f"{end_hour_12} {end_ampm}"
-
-        # Format long version that always includes minutes (e.g., "9:00 PM" instead of "9 PM")
-        all_groups['endtime_long'] = f"{end_hour_12}:{end_minute:02d} {end_ampm}"
-
-    # Generate programs
-    programs = []
-
-    # If we have extracted time AND date, the event happens on a SPECIFIC date
-    # If we have time but NO date, generate for multiple days (existing behavior)
-    # All other days and times show "Upcoming" before or "Ended" after
-    event_happened = False
-
-    # Determine how many iterations we need
-    if date_info and time_info:
-        # Specific date extracted - only generate for that one date
-        iterations = 1
-        logger.debug(f"Date extracted, generating single event for specific date")
-    else:
-        # No specific date - use num_days (existing behavior)
-        iterations = num_days
-
-    for day in range(iterations):
-        # Start from current time (like standard dummy) instead of midnight
-        # This ensures programs appear in the guide's current viewing window
-        day_start = now + timedelta(days=day)
-        day_end = day_start + timedelta(days=1)
-
-        if time_info:
-            # We have an extracted event time - this is when the MAIN event starts
-            # The extracted time is in the SOURCE timezone (e.g., 8PM ET)
-            # We need to convert it to UTC for storage
-
-            # Determine which date to use
-            if date_info:
-                # Use the extracted date from the channel title
-                current_date = datetime(
-                    date_info['year'],
-                    date_info['month'],
-                    date_info['day']
-                ).date()
-                logger.debug(f"Using extracted date: {current_date}")
-            else:
-                # No date extracted, use day offset from current time in SOURCE timezone
-                # This ensures we calculate "today" in the event's timezone, not UTC
-                # For example: 8:30 PM Central (1:30 AM UTC next day) for a 10 PM ET event
-                # should use today's date in ET, not tomorrow's date in UTC
-                now_in_source_tz = now.astimezone(source_tz)
-                current_date = (now_in_source_tz + timedelta(days=day)).date()
-                logger.debug(f"No date extracted, using day offset in {source_tz}: {current_date}")
-
-            # Create a naive datetime (no timezone info) representing the event in source timezone
-            event_start_naive = datetime.combine(
-                current_date,
-                datetime.min.time().replace(
-                    hour=time_info['hour'],
-                    minute=time_info['minute']
-                )
-            )
-
-            # Use pytz to localize the naive datetime to the source timezone
-            # This automatically handles DST!
-            try:
-                event_start_local = source_tz.localize(event_start_naive)
-                # Convert to UTC
-                event_start_utc = event_start_local.astimezone(pytz.utc)
-                logger.debug(f"Converted {event_start_local} to UTC: {event_start_utc}")
-            except Exception as e:
-                logger.error(f"Error localizing time to {source_tz}: {e}")
-                # Fallback: treat as UTC
-                event_start_utc = django_timezone.make_aware(event_start_naive, pytz.utc)
-
-            event_end_utc = event_start_utc + timedelta(minutes=program_duration)
-
-            # Pre-generate the main event title and description for reuse
-            if title_template:
-                main_event_title = format_template(title_template, all_groups)
-            else:
-                title_parts = []
-                if 'league' in all_groups and all_groups['league']:
-                    title_parts.append(all_groups['league'])
-                if 'team1' in all_groups and 'team2' in all_groups:
-                    title_parts.append(f"{all_groups['team1']} vs {all_groups['team2']}")
-                elif 'title' in all_groups and all_groups['title']:
-                    title_parts.append(all_groups['title'])
-                main_event_title = ' - '.join(title_parts) if title_parts else channel_name
-
-            if subtitle_template:
-                main_event_subtitle = format_template(subtitle_template, all_groups)
-            else:
-                main_event_subtitle = None
-
-            if description_template:
-                main_event_description = format_template(description_template, all_groups)
-            else:
-                main_event_description = main_event_title
-
-
-
-            # Determine if this day is before, during, or after the event
-            # Event only happens on day 0 (first day)
-            is_event_day = (day == 0)
-
-            if is_event_day and not event_happened:
-                # This is THE day the event happens
-                # Fill programs BEFORE the event
-                current_time = day_start
-
-                while current_time < event_start_utc:
-                    program_start_utc = current_time
-                    program_end_utc = min(current_time + timedelta(minutes=program_duration), event_start_utc)
-
-                    # Use custom upcoming templates if provided, otherwise use defaults
-                    if upcoming_title_template:
-                        upcoming_title = format_template(upcoming_title_template, all_groups)
-                    else:
-                        upcoming_title = main_event_title
-
-                    if upcoming_description_template:
-                        upcoming_description = format_template(upcoming_description_template, all_groups)
-                    else:
-                        upcoming_description = f"Upcoming: {main_event_description}"
-
-                    # Build custom_properties for upcoming programs (only date, no category/live)
-                    program_custom_properties = {}
-
-                    # Add date if requested (YYYY-MM-DD format from start time in event timezone)
-                    if include_date:
-                        # Convert UTC time to event timezone for date calculation
-                        local_time = program_start_utc.astimezone(source_tz)
-                        date_str = local_time.strftime('%Y-%m-%d')
-                        program_custom_properties['date'] = date_str
-
-                    # Add program poster URL if provided
-                    if program_poster_url:
-                        program_custom_properties['icon'] = program_poster_url
-
-                    programs.append({
-                        "channel_id": channel_id,
-                        "start_time": program_start_utc,
-                        "end_time": program_end_utc,
-                        "title": upcoming_title,
-                        "sub_title": None,  # No subtitle for filler programs
-                        "description": upcoming_description,
-                        "custom_properties": program_custom_properties,
-                        "channel_logo_url": channel_logo_url,  # Pass channel logo for EPG generation
-                    })
-
-                    current_time += timedelta(minutes=program_duration)
-
-                # Add the MAIN EVENT at the extracted time
-                # Build custom_properties for main event (includes category and live)
-                main_event_custom_properties = {}
-
-                # Add categories if provided
-                if categories:
-                    main_event_custom_properties['categories'] = categories
-
-                # Add date if requested (YYYY-MM-DD format from start time in event timezone)
-                if include_date:
-                    # Convert UTC time to event timezone for date calculation
-                    local_time = event_start_utc.astimezone(source_tz)
-                    date_str = local_time.strftime('%Y-%m-%d')
-                    main_event_custom_properties['date'] = date_str
-
-                # Add live flag if requested
-                if include_live:
-                    main_event_custom_properties['live'] = True
-
-                # Add new flag if requested
-                if include_new:
-                    main_event_custom_properties['new'] = True
-
-                # Add program poster URL if provided
-                if program_poster_url:
-                    main_event_custom_properties['icon'] = program_poster_url
-
-                programs.append({
-                    "channel_id": channel_id,
-                    "start_time": event_start_utc,
-                    "end_time": event_end_utc,
-                    "title": main_event_title,
-                    "sub_title": main_event_subtitle,
-                    "description": main_event_description,
-                    "custom_properties": main_event_custom_properties,
-                    "channel_logo_url": channel_logo_url,  # Pass channel logo for EPG generation
-                })
-
-                event_happened = True
-
-                # Fill programs AFTER the event until end of day
-                current_time = event_end_utc
-
-                while current_time < day_end:
-                    program_start_utc = current_time
-                    program_end_utc = min(current_time + timedelta(minutes=program_duration), day_end)
-
-                    # Use custom ended templates if provided, otherwise use defaults
-                    if ended_title_template:
-                        ended_title = format_template(ended_title_template, all_groups)
-                    else:
-                        ended_title = main_event_title
-
-                    if ended_description_template:
-                        ended_description = format_template(ended_description_template, all_groups)
-                    else:
-                        ended_description = f"Ended: {main_event_description}"
-
-                    # Build custom_properties for ended programs (only date, no category/live)
-                    program_custom_properties = {}
-
-                    # Add date if requested (YYYY-MM-DD format from start time in event timezone)
-                    if include_date:
-                        # Convert UTC time to event timezone for date calculation
-                        local_time = program_start_utc.astimezone(source_tz)
-                        date_str = local_time.strftime('%Y-%m-%d')
-                        program_custom_properties['date'] = date_str
-
-                    # Add program poster URL if provided
-                    if program_poster_url:
-                        program_custom_properties['icon'] = program_poster_url
-
-                    programs.append({
-                        "channel_id": channel_id,
-                        "start_time": program_start_utc,
-                        "end_time": program_end_utc,
-                        "title": ended_title,
-                        "sub_title": None,  # No subtitle for filler programs
-                        "description": ended_description,
-                        "custom_properties": program_custom_properties,
-                        "channel_logo_url": channel_logo_url,  # Pass channel logo for EPG generation
-                    })
-
-                    current_time += timedelta(minutes=program_duration)
-            else:
-                # This day is either before the event (future days) or after the event happened
-                # Fill entire day with appropriate message
-                current_time = day_start
-
-                # If event already happened, all programs show "Ended"
-                # If event hasn't happened yet (shouldn't occur with day 0 logic), show "Upcoming"
-                is_ended = event_happened
-
-                while current_time < day_end:
-                    program_start_utc = current_time
-                    program_end_utc = min(current_time + timedelta(minutes=program_duration), day_end)
-
-                    # Use custom templates based on whether event has ended or is upcoming
-                    if is_ended:
-                        if ended_title_template:
-                            program_title = format_template(ended_title_template, all_groups)
-                        else:
-                            program_title = main_event_title
-
-                        if ended_description_template:
-                            program_description = format_template(ended_description_template, all_groups)
-                        else:
-                            program_description = f"Ended: {main_event_description}"
-                    else:
-                        if upcoming_title_template:
-                            program_title = format_template(upcoming_title_template, all_groups)
-                        else:
-                            program_title = main_event_title
-
-                        if upcoming_description_template:
-                            program_description = format_template(upcoming_description_template, all_groups)
-                        else:
-                            program_description = f"Upcoming: {main_event_description}"
-
-                    # Build custom_properties (only date for upcoming/ended filler programs)
-                    program_custom_properties = {}
-
-                    # Add date if requested (YYYY-MM-DD format from start time in event timezone)
-                    if include_date:
-                        # Convert UTC time to event timezone for date calculation
-                        local_time = program_start_utc.astimezone(source_tz)
-                        date_str = local_time.strftime('%Y-%m-%d')
-                        program_custom_properties['date'] = date_str
-
-                    # Add program poster URL if provided
-                    if program_poster_url:
-                        program_custom_properties['icon'] = program_poster_url
-
-                    programs.append({
-                        "channel_id": channel_id,
-                        "start_time": program_start_utc,
-                        "end_time": program_end_utc,
-                        "title": program_title,
-                        "sub_title": None,  # No subtitle for filler programs
-                        "description": program_description,
-                        "custom_properties": program_custom_properties,
-                        "channel_logo_url": channel_logo_url,
-                    })
-
-                    current_time += timedelta(minutes=program_duration)
-        else:
-            # No extracted time - fill entire day with regular intervals
-            # day_start and day_end are already in UTC, so no conversion needed
-            programs_per_day = max(1, int(24 / (program_duration / 60)))
-
-            for program_num in range(programs_per_day):
-                program_start_utc = day_start + timedelta(minutes=program_num * program_duration)
-                program_end_utc = program_start_utc + timedelta(minutes=program_duration)
-
-                if title_template:
-                    title = format_template(title_template, all_groups)
-                else:
-                    title_parts = []
-                    if 'league' in all_groups and all_groups['league']:
-                        title_parts.append(all_groups['league'])
-                    if 'team1' in all_groups and 'team2' in all_groups:
-                        title_parts.append(f"{all_groups['team1']} vs {all_groups['team2']}")
-                    elif 'title' in all_groups and all_groups['title']:
-                        title_parts.append(all_groups['title'])
-                    title = ' - '.join(title_parts) if title_parts else channel_name
-
-                if subtitle_template:
-                    subtitle = format_template(subtitle_template, all_groups)
-                else:
-                    subtitle = None
-
-                if description_template:
-                    description = format_template(description_template, all_groups)
-                else:
-                    description = title
-
-                # Build custom_properties for this program
-                program_custom_properties = {}
-
-                # Add categories if provided
-                if categories:
-                    program_custom_properties['categories'] = categories
-
-                # Add date if requested (YYYY-MM-DD format from start time in event timezone)
-                if include_date:
-                    # Convert UTC time to event timezone for date calculation
-                    local_time = program_start_utc.astimezone(source_tz)
-                    date_str = local_time.strftime('%Y-%m-%d')
-                    program_custom_properties['date'] = date_str
-
-                # Add live flag if requested
-                if include_live:
-                    program_custom_properties['live'] = True
-
-                # Add new flag if requested
-                if include_new:
-                    program_custom_properties['new'] = True
-
-                # Add program poster URL if provided
-                if program_poster_url:
-                    program_custom_properties['icon'] = program_poster_url
-
-                programs.append({
-                    "channel_id": channel_id,
-                    "start_time": program_start_utc,
-                    "end_time": program_end_utc,
-                    "title": title,
-                    "sub_title": subtitle,
-                    "description": description,
-                    "custom_properties": program_custom_properties,
-                    "channel_logo_url": channel_logo_url,  # Pass channel logo for EPG generation
-                })
-
-    logger.info(f"Generated {len(programs)} custom dummy programs for {channel_name}")
-    return programs
-
-
-def generate_dummy_epg(
-    channel_id, channel_name, xml_lines=None, num_days=1, program_length_hours=4
-):
-    """
-    Generate dummy EPG programs for channels without EPG data.
-    Creates program blocks for a specified number of days.
-
-    Args:
-        channel_id: The channel ID to use in the program entries
-        channel_name: The name of the channel to use in program titles
-        xml_lines: Optional list to append lines to, otherwise returns new list
-        num_days: Number of days to generate EPG data for (default: 1)
-        program_length_hours: Length of each program block in hours (default: 4)
-
-    Returns:
-        List of XML lines for the dummy EPG entries
-    """
-    if xml_lines is None:
-        xml_lines = []
-
-    for program in generate_dummy_programs(channel_id, channel_name, num_days=1, program_length_hours=4):
-        # Format times in XMLTV format
-        start_str = program['start_time'].strftime("%Y%m%d%H%M%S %z")
-        stop_str = program['end_time'].strftime("%Y%m%d%H%M%S %z")
-
-        # Create program entry with escaped channel name
-        xml_lines.append(
-            f'  <programme start="{start_str}" stop="{stop_str}" channel="{html.escape(program["channel_id"])}">'
-        )
-        xml_lines.append(f"    <title>{html.escape(program['title'])}</title>")
-
-        # Add subtitle if available
-        if program.get('sub_title'):
-            xml_lines.append(f"    <sub-title>{html.escape(program['sub_title'])}</sub-title>")
-
-        xml_lines.append(f"    <desc>{html.escape(program['description'])}</desc>")
-
-        # Add custom_properties if present
-        custom_data = program.get('custom_properties', {})
-
-        # Categories
-        if 'categories' in custom_data:
-            for cat in custom_data['categories']:
-                xml_lines.append(f"    <category>{html.escape(cat)}</category>")
-
-        # Date tag
-        if 'date' in custom_data:
-            xml_lines.append(f"    <date>{html.escape(custom_data['date'])}</date>")
-
-        # Live tag
-        if custom_data.get('live', False):
-            xml_lines.append(f"    <live />")
-
-        # New tag
-        if custom_data.get('new', False):
-            xml_lines.append(f"    <new />")
-
-        xml_lines.append(f"  </programme>")
-
-    return xml_lines
-
-
-def generate_epg(request, profile_name=None, user=None):
-    """
-    Dynamically generate an XMLTV (EPG) file using streaming response to handle keep-alives.
-    Since the EPG data is stored independently of Channels, we group programmes
-    by their associated EPGData record.
-    This version filters data based on the 'days' parameter and sends keep-alives during processing.
-    """
-    # Check cache for recent identical request (helps with double-GET from browsers)
-    from django.core.cache import cache
-    # Resolve all effective parameter values once here so they are reused for both
-    # the cache key and inside epg_generator() via closure.
-    # The cache key is built from resolved values only — not from the raw query string —
-    # so equivalent requests (e.g. days=7 via URL param vs. user default of 7) share
-    # the same cache entry regardless of how the value was supplied.
-    user_custom = (user.custom_properties or {}) if user else {}
-    try:
-        num_days = int(request.GET.get('days', user_custom.get('epg_days', 0)))
-        num_days = max(0, min(num_days, 365))
-    except (ValueError, TypeError):
-        num_days = 0
-    try:
-        prev_days = int(request.GET.get('prev_days', user_custom.get('epg_prev_days', 0)))
-        prev_days = max(0, min(prev_days, 30))
-    except (ValueError, TypeError):
-        prev_days = 0
-    use_cached_logos = request.GET.get('cachedlogos', 'true').lower() != 'false'
-    tvg_id_source = request.GET.get('tvg_id_source', 'channel_number').lower()
-    cache_params = (
-        f"{profile_name or 'all'}:{user.username if user else 'anonymous'}"
-        f":d={num_days}:p={prev_days}:logos={use_cached_logos}:tvgid={tvg_id_source}"
-    )
-    content_cache_key = f"epg_content:{cache_params}"
-
-    cached_content = cache.get(content_cache_key)
-    if cached_content:
-        logger.debug("Serving EPG from cache")
-        response = HttpResponse(cached_content, content_type="application/xml")
-        response["Content-Disposition"] = 'attachment; filename="Dispatcharr.xml"'
-        response["Cache-Control"] = "no-cache"
-        return response
-
-    def epg_generator():
-        """Generator function that yields EPG data with keep-alives during processing."""
-
-        xml_lines = []
-        xml_lines.append('<?xml version="1.0" encoding="UTF-8"?>')
-        xml_lines.append(
-            '<tv generator-info-name="Dispatcharr" generator-info-url="https://github.com/Dispatcharr/Dispatcharr">'
-        )
-
-        # Get channels based on user/profile
-        if user is not None:
-            if user.user_level < 10:
-                user_profile_count = user.channel_profiles.count()
-
-                # If user has ALL profiles or NO profiles, give unrestricted access
-                if user_profile_count == 0:
-                    # No profile filtering - user sees all channels based on user_level
-                    filters = {"user_level__lte": user.user_level}
-                    # Hide adult content if user preference is set
-                    if (user.custom_properties or {}).get('hide_adult_content', False):
-                        filters["is_adult"] = False
-                    base_qs = Channel.objects.filter(**filters).select_related('logo', 'epg_data__epg_source')
-                else:
-                    # User has specific limited profiles assigned
-                    filters = {
-                        "channelprofilemembership__enabled": True,
-                        "user_level__lte": user.user_level,
-                        "channelprofilemembership__channel_profile__in": user.channel_profiles.all()
-                    }
-                    # Hide adult content if user preference is set
-                    if (user.custom_properties or {}).get('hide_adult_content', False):
-                        filters["is_adult"] = False
-                    base_qs = Channel.objects.filter(**filters).select_related('logo', 'epg_data__epg_source').distinct()
-            else:
-                base_qs = Channel.objects.filter(user_level__lte=user.user_level).select_related('logo', 'epg_data__epg_source')
-        else:
-            if profile_name is not None:
-                try:
-                    channel_profile = ChannelProfile.objects.get(name=profile_name)
-                except ChannelProfile.DoesNotExist:
-                    logger.warning("Requested channel profile (%s) during epg generation does not exist", profile_name)
-                    raise Http404(f"Channel profile '{profile_name}' not found")
-                base_qs = Channel.objects.filter(
-                    channelprofilemembership__channel_profile=channel_profile,
-                    channelprofilemembership__enabled=True,
-                ).select_related('logo', 'epg_data__epg_source')
-            else:
-                base_qs = Channel.objects.all().select_related('logo', 'epg_data__epg_source')
-
-        # Resolve effective values at SQL level and exclude hidden channels
-        # so output ordering/display honors user overrides.
-        from apps.channels.managers import with_effective_values
-        channels = (
-            with_effective_values(base_qs, select_related_fks=True)
-            .exclude(hidden_from_output=True)
-            .order_by("effective_channel_number")
-        )
-
-
-        # For dummy EPG, use either the specified value or default to 3 days
-        dummy_days = num_days if num_days > 0 else 3
-
-        # Calculate cutoff dates for EPG data filtering
-        now = django_timezone.now()
-        cutoff_date = now + timedelta(days=num_days) if num_days > 0 else None
-        lookback_cutoff = now - timedelta(days=prev_days)
-
-        # Build collision-free channel number mapping for XC clients (if user is authenticated)
-        # XC clients require integer channel numbers, so we need to ensure no conflicts
-        channel_num_map = {}
-        if user is not None:
-            # This is an XC client - build collision-free mapping
-            used_numbers = set()
-
-            # First pass: assign integers for channels that already have integer numbers
-            for channel in channels:
-                effective_num = channel.effective_channel_number
-                if effective_num is not None and effective_num == int(effective_num):
-                    num = int(effective_num)
-                    channel_num_map[channel.id] = num
-                    used_numbers.add(num)
-
-            # Second pass: assign integers for channels with float numbers
-            for channel in channels:
-                effective_num = channel.effective_channel_number
-                if effective_num is not None and effective_num != int(effective_num):
-                    candidate = int(effective_num)
-                    while candidate in used_numbers:
-                        candidate += 1
-                    channel_num_map[channel.id] = candidate
-                    used_numbers.add(candidate)
-
-        # Host/port/scheme are constant per request; precompute logo URL prefix once.
-        _base_url = build_absolute_uri_with_port(request, "")
-        _sample_logo_path = reverse("api:channels:logo-cache", args=[0])
-        _logo_prefix_raw, _, _logo_suffix_raw = _sample_logo_path.partition("/0/")
-        _logo_url_prefix = _base_url + _logo_prefix_raw + "/"
-        _logo_url_suffix = "/" + _logo_suffix_raw
-
-        # Process channels for the <channel> section
-        for channel in channels:
-            effective_name = channel.effective_name
-            effective_epg_data = channel.effective_epg_data_obj
-            effective_logo = channel.effective_logo_obj
-            effective_number = channel.effective_channel_number
-
-            # user is set only for XC clients, which require integer channel numbers
-            if user is not None:
-                formatted_channel_number = channel_num_map[channel.id]
-            else:
-                formatted_channel_number = format_channel_number(effective_number)
-
-            # Determine the channel ID based on the selected source
-            if tvg_id_source == 'tvg_id' and channel.effective_tvg_id:
-                channel_id = channel.effective_tvg_id
-            elif tvg_id_source == 'gracenote' and channel.effective_tvc_guide_stationid:
-                channel_id = channel.effective_tvc_guide_stationid
-            else:
-                channel_id = str(formatted_channel_number) if formatted_channel_number != "" else str(channel.id)
-
-            tvg_logo = ""
-
-            # Check if this is a custom dummy EPG with channel logo URL template
-            if effective_epg_data and effective_epg_data.epg_source and effective_epg_data.epg_source.source_type == 'dummy':
-                epg_source = effective_epg_data.epg_source
-                if epg_source.custom_properties:
-                    custom_props = epg_source.custom_properties
-                    channel_logo_url_template = custom_props.get('channel_logo_url', '')
-
-                    if channel_logo_url_template:
-                        # Determine which name to use for pattern matching (same logic as program generation)
-                        pattern_match_name = effective_name
-                        name_source = custom_props.get('name_source')
-
-                        if name_source == 'stream':
-                            stream_index = custom_props.get('stream_index', 1) - 1
-                            channel_streams = channel.streams.all().order_by('channelstream__order')
-
-                            if channel_streams.exists() and 0 <= stream_index < channel_streams.count():
-                                stream = list(channel_streams)[stream_index]
-                                pattern_match_name = stream.name
-
-                        # Try to extract groups from the channel/stream name and build the logo URL
-                        title_pattern = custom_props.get('title_pattern', '')
-                        if title_pattern:
-                            try:
-                                # Convert PCRE/JavaScript named groups to Python format
-                                title_pattern = regex.sub(r'\(\?<(?![=!])([^>]+)>', r'(?P<\1>', title_pattern)
-                                title_regex = regex.compile(title_pattern)
-                                title_match = title_regex.search(pattern_match_name)
-
-                                if title_match:
-                                    groups = title_match.groupdict()
-
-                                    # Add normalized versions of all groups for cleaner URLs
-                                    for key, value in list(groups.items()):
-                                        if value:
-                                            # Remove all non-alphanumeric characters and convert to lowercase
-                                            normalized = regex.sub(r'[^a-zA-Z0-9\s]', '', str(value))
-                                            normalized = regex.sub(r'\s+', '', normalized).lower()
-                                            groups[f'{key}_normalize'] = normalized
-
-                                    # Format the logo URL template with the matched groups (with URL encoding)
-                                    from urllib.parse import quote
-                                    for key, value in groups.items():
-                                        if value:
-                                            encoded_value = quote(str(value), safe='')
-                                            channel_logo_url_template = channel_logo_url_template.replace(f'{{{key}}}', encoded_value)
-                                        else:
-                                            channel_logo_url_template = channel_logo_url_template.replace(f'{{{key}}}', '')
-                                    tvg_logo = channel_logo_url_template
-                                    logger.debug(f"Built channel logo URL from template: {tvg_logo}")
-                            except Exception as e:
-                                logger.warning(f"Failed to build channel logo URL for {effective_name}: {e}")
-
-            # If no custom dummy logo, use regular logo logic
-            if not tvg_logo and effective_logo:
-                if use_cached_logos:
-                    tvg_logo = f"{_logo_url_prefix}{effective_logo.id}{_logo_url_suffix}"
-                else:
-                    # Use direct URL if available, otherwise fall back to cached version
-                    direct_logo = effective_logo.url if effective_logo.url.startswith(('http://', 'https://')) else None
-                    if direct_logo:
-                        tvg_logo = direct_logo
-                    else:
-                        tvg_logo = f"{_logo_url_prefix}{effective_logo.id}{_logo_url_suffix}"
-            display_name = effective_name
-            xml_lines.append(f'  <channel id="{html.escape(channel_id)}">')
-            xml_lines.append(f'    <display-name>{html.escape(display_name)}</display-name>')
-            xml_lines.append(f'    <icon src="{html.escape(tvg_logo)}" />')
-            xml_lines.append("  </channel>")
-
-        # Send all channel definitions
-        channel_xml = '\n'.join(xml_lines) + '\n'
-        yield channel_xml
-        xml_lines = []  # Clear to save memory
-
-        # Pre-pass: categorize channels into dummy and real EPG groups
-        dummy_program_list = []  # (channel_id, pattern_match_name, epg_source_or_None)
-        real_epg_map = {}  # epg_data_id -> [channel_id, ...]
-        dummy_epg_checked = {}  # epg_data_id -> bool (has stored programs)
-
-        for channel in channels:
-            effective_name = channel.effective_name
-            effective_epg_data = channel.effective_epg_data_obj
-            effective_epg_data_id = channel.effective_epg_data_id
-            effective_number = channel.effective_channel_number
-
-            # Determine channel_id (same logic as channel section)
-            if tvg_id_source == 'tvg_id' and channel.effective_tvg_id:
-                channel_id = channel.effective_tvg_id
-            elif tvg_id_source == 'gracenote' and channel.effective_tvc_guide_stationid:
-                channel_id = channel.effective_tvc_guide_stationid
-            else:
-                if user is not None:
-                    formatted_channel_number = channel_num_map[channel.id]
-                else:
-                    formatted_channel_number = format_channel_number(effective_number)
-                channel_id = str(formatted_channel_number) if formatted_channel_number != "" else str(channel.id)
-
-            display_name = effective_epg_data.name if effective_epg_data else effective_name
-            pattern_match_name = effective_name
-
-            # Check if we should use stream name instead of channel name
-            if effective_epg_data and effective_epg_data.epg_source:
-                epg_source = effective_epg_data.epg_source
-                if epg_source.custom_properties:
-                    custom_props = epg_source.custom_properties
-                    name_source = custom_props.get('name_source')
-
-                    if name_source == 'stream':
-                        stream_index = custom_props.get('stream_index', 1) - 1
-                        channel_streams = channel.streams.all().order_by('channelstream__order')
-
-                        if channel_streams.exists() and 0 <= stream_index < channel_streams.count():
-                            stream = list(channel_streams)[stream_index]
-                            pattern_match_name = stream.name
-                            logger.debug(f"Using stream name for parsing: {pattern_match_name} (stream index: {stream_index})")
-                        else:
-                            logger.warning(f"Stream index {stream_index} not found for channel {effective_name}, falling back to channel name")
-
-            if not effective_epg_data:
-                dummy_program_list.append((channel_id, pattern_match_name, None))
-            else:
-                if effective_epg_data.epg_source and effective_epg_data.epg_source.source_type == 'dummy':
-                    if effective_epg_data_id not in dummy_epg_checked:
-                        dummy_epg_checked[effective_epg_data_id] = effective_epg_data.programs.exists()
-                    if dummy_epg_checked[effective_epg_data_id]:
-                        real_epg_map.setdefault(effective_epg_data_id, []).append(channel_id)
-                    else:
-                        dummy_program_list.append((channel_id, pattern_match_name, effective_epg_data.epg_source))
-                    continue
-
-                real_epg_map.setdefault(effective_epg_data_id, []).append(channel_id)
-
-        # Emit dummy programmes
-        for channel_id, pattern_match_name, epg_source in dummy_program_list:
-            program_length_hours = 4
-            dummy_programs = generate_dummy_programs(
-                channel_id, pattern_match_name,
-                num_days=dummy_days,
-                program_length_hours=program_length_hours,
-                epg_source=epg_source
-            )
-            for program in dummy_programs:
-                start_str = program['start_time'].strftime("%Y%m%d%H%M%S %z")
-                stop_str = program['end_time'].strftime("%Y%m%d%H%M%S %z")
-                yield f'  <programme start="{start_str}" stop="{stop_str}" channel="{html.escape(channel_id)}">\n'
-                yield f"    <title>{html.escape(program['title'])}</title>\n"
-                if program.get('sub_title'):
-                    yield f"    <sub-title>{html.escape(program['sub_title'])}</sub-title>\n"
-                yield f"    <desc>{html.escape(program['description'])}</desc>\n"
-                custom_data = program.get('custom_properties', {})
-                if 'categories' in custom_data:
-                    for cat in custom_data['categories']:
-                        yield f"    <category>{html.escape(cat)}</category>\n"
-                if 'date' in custom_data:
-                    yield f"    <date>{html.escape(custom_data['date'])}</date>\n"
-                if custom_data.get('live', False):
-                    yield f"    <live />\n"
-                if custom_data.get('new', False):
-                    yield f"    <new />\n"
-                if 'icon' in custom_data:
-                    yield f'    <icon src="{html.escape(custom_data["icon"])}" />\n'
-                yield f"  </programme>\n"
-
-        # Emit real programmes: single bulk query, chunked to avoid server-side cursor issues.
-        all_epg_ids = list(real_epg_map.keys())
-        if all_epg_ids:
-            if num_days > 0:
-                programs_qs = ProgramData.objects.filter(
-                    epg_id__in=all_epg_ids,
-                    end_time__gte=lookback_cutoff,
-                    start_time__lt=cutoff_date,
-                )
-            else:
-                programs_qs = ProgramData.objects.filter(
-                    epg_id__in=all_epg_ids,
-                    end_time__gte=lookback_cutoff,
-                )
-
-            programs_base_qs = programs_qs.order_by('epg_id', 'id').values(
-                'id', 'epg_id', 'start_time', 'end_time', 'title', 'sub_title',
-                'description', 'custom_properties',
-            )
-
-            current_epg_id = None
-            channel_ids_for_epg = None
-            is_multi = False
-            multi_buffer = []
-            program_batch = []
-            batch_size = 1000
-            chunk_size = 5000
-            # Keyset pagination: track last (epg_id, id) instead of OFFSET
-            # to avoid skipping/duplicating rows if the table changes mid-stream.
-            last_epg_id = 0
-            last_id = 0
-            _poster_url_base = build_absolute_uri_with_port(request, "/api/epg/programs/")
-
-            while True:
-                program_chunk = list(
-                    programs_base_qs.filter(epg_id__gte=last_epg_id)
-                    .exclude(epg_id=last_epg_id, id__lte=last_id)[:chunk_size]
-                )
-
-                if not program_chunk:
-                    break
-
-                # Advance keyset cursor to last row in this chunk
-                last_row = program_chunk[-1]
-                last_epg_id = last_row['epg_id']
-                last_id = last_row['id']
-
-                for prog in program_chunk:
-                    epg_id = prog['epg_id']
-
-                    # When epg_id changes, flush multi-channel buffer for previous group
-                    if epg_id != current_epg_id:
-                        if is_multi and multi_buffer:
-                            escaped_primary = html.escape(channel_ids_for_epg[0])
-                            for extra_cid in channel_ids_for_epg[1:]:
-                                escaped_extra = html.escape(extra_cid)
-                                for xml_text in multi_buffer:
-                                    program_batch.append(xml_text.replace(
-                                        f'channel="{escaped_primary}"',
-                                        f'channel="{escaped_extra}"',
-                                        1,
-                                    ))
-                                    if len(program_batch) >= batch_size:
-                                        yield '\n'.join(program_batch) + '\n'
-                                        program_batch = []
-                            multi_buffer = []
-
-                        current_epg_id = epg_id
-                        channel_ids_for_epg = real_epg_map[epg_id]
-                        is_multi = len(channel_ids_for_epg) > 1
-
-                    # Build programme XML for primary channel_id
-                    primary_cid = channel_ids_for_epg[0]
-                    start_str = prog['start_time'].strftime("%Y%m%d%H%M%S %z")
-                    stop_str = prog['end_time'].strftime("%Y%m%d%H%M%S %z")
-
-                    program_xml = [f'  <programme start="{start_str}" stop="{stop_str}" channel="{html.escape(primary_cid)}">']
-                    program_xml.append(f'    <title>{html.escape(prog["title"])}</title>')
-
-                    if prog['sub_title']:
-                        program_xml.append(f"    <sub-title>{html.escape(prog['sub_title'])}</sub-title>")
-
-                    if prog['description']:
-                        program_xml.append(f"    <desc>{html.escape(prog['description'])}</desc>")
-
-                    custom_data = prog['custom_properties'] or {}
-                    if custom_data:
-
-                        if "categories" in custom_data and custom_data["categories"]:
-                            for category in custom_data["categories"]:
-                                program_xml.append(f"    <category>{html.escape(category)}</category>")
-
-                        if "keywords" in custom_data and custom_data["keywords"]:
-                            for keyword in custom_data["keywords"]:
-                                program_xml.append(f"    <keyword>{html.escape(keyword)}</keyword>")
-
-                        # onscreen_episode takes priority over episode for the onscreen system
-                        if "onscreen_episode" in custom_data:
-                            program_xml.append(f'    <episode-num system="onscreen">{html.escape(custom_data["onscreen_episode"])}</episode-num>')
-                        elif "episode" in custom_data:
-                            program_xml.append(f'    <episode-num system="onscreen">E{custom_data["episode"]}</episode-num>')
-
-                        # Handle dd_progid format
-                        if 'dd_progid' in custom_data:
-                            program_xml.append(f'    <episode-num system="dd_progid">{html.escape(custom_data["dd_progid"])}</episode-num>')
-
-                        # Handle external database IDs
-                        for system in ['thetvdb.com', 'themoviedb.org', 'imdb.com']:
-                            if f'{system}_id' in custom_data:
-                                program_xml.append(f'    <episode-num system="{system}">{html.escape(custom_data[f"{system}_id"])}</episode-num>')
-
-                        # Add season and episode numbers in xmltv_ns format if available
-                        if "season" in custom_data and "episode" in custom_data:
-                            season = (
-                                int(custom_data["season"]) - 1
-                                if str(custom_data["season"]).isdigit()
-                                else 0
-                            )
-                            episode = (
-                                int(custom_data["episode"]) - 1
-                                if str(custom_data["episode"]).isdigit()
-                                else 0
-                            )
-                            program_xml.append(f'    <episode-num system="xmltv_ns">{season}.{episode}.</episode-num>')
-
-                        if "language" in custom_data:
-                            program_xml.append(f'    <language>{html.escape(custom_data["language"])}</language>')
-
-                        if "original_language" in custom_data:
-                            program_xml.append(f'    <orig-language>{html.escape(custom_data["original_language"])}</orig-language>')
-
-                        if "length" in custom_data and isinstance(custom_data["length"], dict):
-                            length_value = custom_data["length"].get("value", "")
-                            length_units = custom_data["length"].get("units", "minutes")
-                            program_xml.append(f'    <length units="{html.escape(length_units)}">{html.escape(str(length_value))}</length>')
-
-                        if "video" in custom_data and isinstance(custom_data["video"], dict):
-                            program_xml.append("    <video>")
-                            for attr in ['present', 'colour', 'aspect', 'quality']:
-                                if attr in custom_data["video"]:
-                                    program_xml.append(f"      <{attr}>{html.escape(custom_data['video'][attr])}</{attr}>")
-                            program_xml.append("    </video>")
-
-                        if "audio" in custom_data and isinstance(custom_data["audio"], dict):
-                            program_xml.append("    <audio>")
-                            for attr in ['present', 'stereo']:
-                                if attr in custom_data["audio"]:
-                                    program_xml.append(f"      <{attr}>{html.escape(custom_data['audio'][attr])}</{attr}>")
-                            program_xml.append("    </audio>")
-
-                        if "subtitles" in custom_data and isinstance(custom_data["subtitles"], list):
-                            for subtitle in custom_data["subtitles"]:
-                                if isinstance(subtitle, dict):
-                                    subtitle_type = subtitle.get("type", "")
-                                    type_attr = f' type="{html.escape(subtitle_type)}"' if subtitle_type else ""
-                                    program_xml.append(f"    <subtitles{type_attr}>")
-                                    if "language" in subtitle:
-                                        program_xml.append(f"      <language>{html.escape(subtitle['language'])}</language>")
-                                    program_xml.append("    </subtitles>")
-
-                        if "rating" in custom_data:
-                            rating_system = custom_data.get("rating_system", "TV Parental Guidelines")
-                            program_xml.append(f'    <rating system="{html.escape(rating_system)}">')
-                            program_xml.append(f'      <value>{html.escape(custom_data["rating"])}</value>')
-                            program_xml.append(f"    </rating>")
-
-                        if "star_ratings" in custom_data and isinstance(custom_data["star_ratings"], list):
-                            for star_rating in custom_data["star_ratings"]:
-                                if isinstance(star_rating, dict) and "value" in star_rating:
-                                    system_attr = f' system="{html.escape(star_rating["system"])}"' if "system" in star_rating else ""
-                                    program_xml.append(f"    <star-rating{system_attr}>")
-                                    program_xml.append(f"      <value>{html.escape(star_rating['value'])}</value>")
-                                    program_xml.append("    </star-rating>")
-
-                        if "reviews" in custom_data and isinstance(custom_data["reviews"], list):
-                            for review in custom_data["reviews"]:
-                                if isinstance(review, dict) and "content" in review:
-                                    review_type = review.get("type", "text")
-                                    attrs = [f'type="{html.escape(review_type)}"']
-                                    if "source" in review:
-                                        attrs.append(f'source="{html.escape(review["source"])}"')
-                                    if "reviewer" in review:
-                                        attrs.append(f'reviewer="{html.escape(review["reviewer"])}"')
-                                    attr_str = " ".join(attrs)
-                                    program_xml.append(f'    <review {attr_str}>{html.escape(review["content"])}</review>')
-
-                        if "images" in custom_data and isinstance(custom_data["images"], list):
-                            for image in custom_data["images"]:
-                                if isinstance(image, dict) and "url" in image:
-                                    attrs = []
-                                    for attr in ['type', 'size', 'orient', 'system']:
-                                        if attr in image:
-                                            attrs.append(f'{attr}="{html.escape(image[attr])}"')
-                                    attr_str = " " + " ".join(attrs) if attrs else ""
-                                    program_xml.append(f'    <image{attr_str}>{html.escape(image["url"])}</image>')
-
-                        # Add enhanced credits handling
-                        if "credits" in custom_data:
-                            program_xml.append("    <credits>")
-                            credits = custom_data["credits"]
-
-                            for role in ['director', 'writer', 'adapter', 'producer', 'composer', 'editor', 'presenter', 'commentator', 'guest']:
-                                if role in credits:
-                                    people = credits[role]
-                                    if isinstance(people, list):
-                                        for person in people:
-                                            program_xml.append(f"      <{role}>{html.escape(person)}</{role}>")
-                                    else:
-                                        program_xml.append(f"      <{role}>{html.escape(people)}</{role}>")
-
-                            # Handle actors separately to include role and guest attributes
-                            if "actor" in credits:
-                                actors = credits["actor"]
-                                if isinstance(actors, list):
-                                    for actor in actors:
-                                        if isinstance(actor, dict):
-                                            name = actor.get("name", "")
-                                            role_attr = f' role="{html.escape(actor["role"])}"' if "role" in actor else ""
-                                            guest_attr = ' guest="yes"' if actor.get("guest") else ""
-                                            program_xml.append(f"      <actor{role_attr}{guest_attr}>{html.escape(name)}</actor>")
-                                        else:
-                                            program_xml.append(f"      <actor>{html.escape(actor)}</actor>")
-                                else:
-                                    program_xml.append(f"      <actor>{html.escape(actors)}</actor>")
-
-                            program_xml.append("    </credits>")
-
-                        if "date" in custom_data:
-                            program_xml.append(f'    <date>{html.escape(custom_data["date"])}</date>')
-
-                        if "country" in custom_data:
-                            program_xml.append(f'    <country>{html.escape(custom_data["country"])}</country>')
-
-                        if "icon" in custom_data:
-                            program_xml.append(f'    <icon src="{html.escape(custom_data["icon"])}" />')
-                        elif "sd_icon" in custom_data:
-                            program_xml.append(f'    <icon src="{html.escape(_poster_url_base)}{prog["id"]}/poster/" />')
-
-                        # Add special flags as proper tags with enhanced handling
-                        if custom_data.get("previously_shown", False):
-                            prev_shown_details = custom_data.get("previously_shown_details", {})
-                            attrs = []
-                            if "start" in prev_shown_details:
-                                attrs.append(f'start="{html.escape(prev_shown_details["start"])}"')
-                            if "channel" in prev_shown_details:
-                                attrs.append(f'channel="{html.escape(prev_shown_details["channel"])}"')
-                            attr_str = " " + " ".join(attrs) if attrs else ""
-                            program_xml.append(f"    <previously-shown{attr_str} />")
-
-                        if custom_data.get("premiere", False):
-                            premiere_text = custom_data.get("premiere_text", "")
-                            if premiere_text:
-                                program_xml.append(f"    <premiere>{html.escape(premiere_text)}</premiere>")
-                            else:
-                                program_xml.append("    <premiere />")
-
-                        if custom_data.get("last_chance", False):
-                            last_chance_text = custom_data.get("last_chance_text", "")
-                            if last_chance_text:
-                                program_xml.append(f"    <last-chance>{html.escape(last_chance_text)}</last-chance>")
-                            else:
-                                program_xml.append("    <last-chance />")
-
-                        if custom_data.get("new", False):
-                            program_xml.append("    <new />")
-
-                        if custom_data.get('live', False):
-                            program_xml.append('    <live />')
-
-                    program_xml.append("  </programme>")
-
-                    xml_text = '\n'.join(program_xml)
-                    program_batch.append(xml_text)
-
-                    if is_multi:
-                        multi_buffer.append(xml_text)
-
-                    if len(program_batch) >= batch_size:
-                        yield '\n'.join(program_batch) + '\n'
-                        program_batch = []
-
-            # Final flush of multi-channel buffer
-            if is_multi and multi_buffer:
-                escaped_primary = html.escape(channel_ids_for_epg[0])
-                for extra_cid in channel_ids_for_epg[1:]:
-                    escaped_extra = html.escape(extra_cid)
-                    for xml_text in multi_buffer:
-                        program_batch.append(xml_text.replace(
-                            f'channel="{escaped_primary}"',
-                            f'channel="{escaped_extra}"',
-                            1,
-                        ))
-
-            if program_batch:
-                yield '\n'.join(program_batch) + '\n'
-
-        # Send final closing tag and completion message
-        yield "</tv>\n"
-
-        # Log system event for EPG download after streaming completes (with deduplication based on client)
-        client_id, client_ip, user_agent = get_client_identifier(request)
-        event_cache_key = f"epg_download:{user.username if user else 'anonymous'}:{profile_name or 'all'}:{client_id}"
-        if not cache.get(event_cache_key):
-            # `len()` reuses the queryset's iteration cache populated above;
-            # `count()` would issue a separate SELECT COUNT(*).
-            log_system_event(
-                event_type='epg_download',
-                profile=profile_name or 'all',
-                user=user.username if user else 'anonymous',
-                channels=len(channels),
-                client_ip=client_ip,
-                user_agent=user_agent,
-            )
-            cache.set(event_cache_key, True, 2)  # Prevent duplicate events for 2 seconds
-
-    # Wrapper generator that collects content for caching
-    def caching_generator():
-        collected_content = []
-        for chunk in epg_generator():
-            collected_content.append(chunk)
-            yield chunk
-        # After streaming completes, cache the full content
-        full_content = ''.join(collected_content)
-        cache.set(content_cache_key, full_content, 300)
-        logger.debug("Cached EPG content (%d bytes)", len(full_content))
-
-    response = StreamingHttpResponse(
-        streaming_content=caching_generator(),
-        content_type="application/xml"
-    )
-    response["Content-Disposition"] = 'attachment; filename="Dispatcharr.xml"'
-    response["Cache-Control"] = "no-cache"
-    return response
-
-
 def xc_get_user(request):
     username = request.GET.get("username")
     password = request.GET.get("password")
@@ -2540,6 +918,75 @@ def xc_get_epg(request, user, short=False):
     return output
 
 
+XC_MOVIE_VALUE_FIELDS = (
+    'id', 'movie_id', 'category_id', 'container_extension',
+    'movie__id', 'movie__name', 'movie__rating', 'movie__created_at',
+    'movie__tmdb_id', 'movie__imdb_id', 'movie__description', 'movie__genre',
+    'movie__year', 'movie__custom_properties', 'movie__logo_id',
+)
+
+XC_SERIES_VALUE_FIELDS = (
+    'id', 'series_id', 'category_id', 'updated_at',
+    'series__id', 'series__name', 'series__description', 'series__genre',
+    'series__year', 'series__rating', 'series__custom_properties', 'series__logo_id',
+    'series__tmdb_id', 'series__imdb_id',
+)
+
+
+def _xc_fetch_priority_distinct_relations(
+    *,
+    manager,
+    rel_filters,
+    distinct_field,
+    value_fields,
+    order_by_name_field,
+):
+    """
+    Return one row dict per distinct content ID (highest account priority wins).
+
+    On PostgreSQL, dedupe on narrow relation rows first, then fetch display
+    columns via values() (no ORM model instantiation). That avoids sorting
+    wide joined rows during DISTINCT ON and reduces parallel worker /dev/shm
+    pressure in Docker.
+    """
+    from django.db import connection, transaction
+
+    narrow_qs = manager.filter(**rel_filters)
+
+    def _fetch_by_ids(ids):
+        return list(
+            manager.filter(pk__in=ids)
+            .values(*value_fields)
+            .order_by(Lower(order_by_name_field))
+        )
+
+    if connection.vendor == 'postgresql':
+        winning_ids_qs = (
+            narrow_qs
+            .order_by(distinct_field, '-m3u_account__priority', 'id')
+            .distinct(distinct_field)
+            .values('pk')
+        )
+        with transaction.atomic():
+            # Optional: disable parallel gather for this DISTINCT ON query if Docker
+            # /dev/shm pressure causes worker OOM on very large VOD libraries.
+            #with connection.cursor() as cursor:
+            #    cursor.execute("SET LOCAL max_parallel_workers_per_gather = 0")
+            winning_ids = list(winning_ids_qs.values_list('pk', flat=True))
+            if not winning_ids:
+                return []
+            return _fetch_by_ids(winning_ids)
+
+    seen = {}
+    for row in narrow_qs.values(*value_fields).order_by('-m3u_account__priority', 'id'):
+        key = row[distinct_field]
+        if key not in seen:
+            seen[key] = row
+    rows = list(seen.values())
+    rows.sort(key=lambda r: (r[order_by_name_field] or '').lower())
+    return rows
+
+
 def xc_get_vod_categories(user):
     """Get VOD categories for XtreamCodes API"""
     from apps.vod.models import VODCategory, M3UMovieRelation
@@ -2565,33 +1012,19 @@ def xc_get_vod_categories(user):
 def xc_get_vod_streams(request, user, category_id=None):
     """Get VOD streams (movies) for XtreamCodes API"""
     from apps.vod.models import M3UMovieRelation
-    from django.db import connection
 
     rel_filters = {"m3u_account__is_active": True}
     if category_id:
         rel_filters["category_id"] = category_id
 
-    base_qs = (
-        M3UMovieRelation.objects
-        .filter(**rel_filters)
-        .select_related('movie', 'movie__logo', 'category')
+    relations = _xc_fetch_priority_distinct_relations(
+        manager=M3UMovieRelation.objects,
+        rel_filters=rel_filters,
+        distinct_field='movie_id',
+        value_fields=XC_MOVIE_VALUE_FIELDS,
+        order_by_name_field='movie__name',
     )
 
-    if connection.vendor == 'postgresql':
-        # DISTINCT ON returns one row per movie (highest-priority active relation)
-        # in a single query. ORDER BY must lead with the DISTINCT field.
-        relations = list(
-            base_qs.order_by('movie_id', '-m3u_account__priority', 'id')
-            .distinct('movie_id')
-        )
-    else:
-        # SQLite fallback: fetch all matching relations, deduplicate in Python.
-        seen: dict = {}
-        for rel in base_qs.order_by('-m3u_account__priority', 'id'):
-            if rel.movie_id not in seen:
-                seen[rel.movie_id] = rel
-        relations = list(seen.values())
-
     # Precompute logo URL prefix/suffix once (mirrors _xc_live_streams_setup)
     # so each row only needs a string concat instead of reverse() + URI build.
     _base_url = build_absolute_uri_with_port(request, "")
@@ -2600,44 +1033,40 @@ def xc_get_vod_streams(request, user, category_id=None):
     _logo_url_prefix = _base_url + _logo_prefix_raw + "/"
     _logo_url_suffix = "/" + _logo_suffix_raw
 
-    # Sort by name (DISTINCT ON forces ORDER BY movie_id; SQLite path is unsorted).
-    relations.sort(key=lambda r: (r.movie.name or "").lower())
-
     streams = []
     append = streams.append
-    for num, relation in enumerate(relations, 1):
-        movie = relation.movie
-        custom_props = movie.custom_properties or {}
-        category = relation.category
-        category_id_str = str(category.id) if category else "0"
-        category_id_list = [category.id] if category else []
-        rating = movie.rating
-        logo = movie.logo
+    for num, row in enumerate(relations, 1):
+        custom_props = row['movie__custom_properties'] or {}
+        category_id = row['category_id']
+        category_id_str = str(category_id) if category_id else "0"
+        category_id_list = [category_id] if category_id else []
+        rating = row['movie__rating']
+        logo_id = row['movie__logo_id']
 
         append({
             "num": num,
-            "name": movie.name,
+            "name": row['movie__name'],
             "stream_type": "movie",
-            "stream_id": movie.id,
+            "stream_id": row['movie__id'],
             "stream_icon": (
-                f"{_logo_url_prefix}{logo.id}{_logo_url_suffix}" if logo else None
+                f"{_logo_url_prefix}{logo_id}{_logo_url_suffix}" if logo_id else None
             ),
             "rating": rating or "0",
             "rating_5based": round(float(rating or 0) / 2, 2) if rating else 0,
-            "added": str(int(movie.created_at.timestamp())),
+            "added": str(int(row['movie__created_at'].timestamp())),
             "is_adult": 0,
-            "tmdb_id": movie.tmdb_id or "",
-            "imdb_id": movie.imdb_id or "",
+            "tmdb_id": row['movie__tmdb_id'] or "",
+            "imdb_id": row['movie__imdb_id'] or "",
             "trailer": custom_props.get('youtube_trailer') or "",
-            "plot": movie.description or "",
-            "genre": movie.genre or "",
-            "year": movie.year or "",
+            "plot": row['movie__description'] or "",
+            "genre": row['movie__genre'] or "",
+            "year": row['movie__year'] or "",
             "director": custom_props.get('director', ''),
             "cast": custom_props.get('actors', ''),
             "release_date": custom_props.get('release_date', ''),
             "category_id": category_id_str,
             "category_ids": category_id_list,
-            "container_extension": relation.container_extension or "mp4",
+            "container_extension": row['container_extension'] or "mp4",
             "custom_sid": None,
             "direct_source": "",
         })
@@ -2670,72 +1099,58 @@ def xc_get_series_categories(user):
 def xc_get_series(request, user, category_id=None):
     """Get series list for XtreamCodes API"""
     from apps.vod.models import M3USeriesRelation
-    from django.db import connection
 
     rel_filters = {"m3u_account__is_active": True}
     if category_id:
         rel_filters["category_id"] = category_id
 
-    base_qs = (
-        M3USeriesRelation.objects
-        .filter(**rel_filters)
-        .select_related('series', 'series__logo', 'category')
+    relations = _xc_fetch_priority_distinct_relations(
+        manager=M3USeriesRelation.objects,
+        rel_filters=rel_filters,
+        distinct_field='series_id',
+        value_fields=XC_SERIES_VALUE_FIELDS,
+        order_by_name_field='series__name',
     )
 
-    if connection.vendor == 'postgresql':
-        relations = list(
-            base_qs.order_by('series_id', '-m3u_account__priority', 'id')
-            .distinct('series_id')
-        )
-    else:
-        seen: dict = {}
-        for rel in base_qs.order_by('-m3u_account__priority', 'id'):
-            if rel.series_id not in seen:
-                seen[rel.series_id] = rel
-        relations = list(seen.values())
-
     _base_url = build_absolute_uri_with_port(request, "")
     _sample_logo_path = reverse("api:vod:vodlogo-cache", args=[0])
     _logo_prefix_raw, _, _logo_suffix_raw = _sample_logo_path.partition("/0/")
     _logo_url_prefix = _base_url + _logo_prefix_raw + "/"
     _logo_url_suffix = "/" + _logo_suffix_raw
 
-    relations.sort(key=lambda r: (r.series.name or "").lower())
-
     series_list = []
     append = series_list.append
-    for num, relation in enumerate(relations, 1):
-        series = relation.series
-        custom_props = series.custom_properties or {}
-        category = relation.category
-        rating = series.rating
-        logo = series.logo
-        year_str = str(series.year) if series.year else ""
+    for num, row in enumerate(relations, 1):
+        custom_props = row['series__custom_properties'] or {}
+        category_id = row['category_id']
+        rating = row['series__rating']
+        logo_id = row['series__logo_id']
+        year_str = str(row['series__year']) if row['series__year'] else ""
         release_date = custom_props.get('release_date', year_str)
 
         append({
             "num": num,
-            "name": series.name,
-            "series_id": relation.id,
+            "name": row['series__name'],
+            "series_id": row['id'],
             "cover": (
-                f"{_logo_url_prefix}{logo.id}{_logo_url_suffix}" if logo else None
+                f"{_logo_url_prefix}{logo_id}{_logo_url_suffix}" if logo_id else None
             ),
-            "plot": series.description or "",
+            "plot": row['series__description'] or "",
             "cast": custom_props.get('cast', ''),
             "director": custom_props.get('director', ''),
-            "genre": series.genre or "",
+            "genre": row['series__genre'] or "",
             "release_date": release_date,
             "releaseDate": release_date,
-            "last_modified": str(int(relation.updated_at.timestamp())),
+            "last_modified": str(int(row['updated_at'].timestamp())),
             "rating": str(rating or "0"),
             "rating_5based": str(round(float(rating or 0) / 2, 2)) if rating else "0",
             "backdrop_path": custom_props.get('backdrop_path', []),
             "youtube_trailer": custom_props.get('youtube_trailer', ''),
             "episode_run_time": custom_props.get('episode_run_time', ''),
-            "category_id": str(category.id) if category else "0",
-            "category_ids": [category.id] if category else [],
-            "tmdb_id": series.tmdb_id or "",
-            "imdb_id": series.imdb_id or "",
+            "category_id": str(category_id) if category_id else "0",
+            "category_ids": [category_id] if category_id else [],
+            "tmdb_id": row['series__tmdb_id'] or "",
+            "imdb_id": row['series__imdb_id'] or "",
         })
 
     return series_list
diff --git a/apps/plugins/api_views.py b/apps/plugins/api_views.py
index 80ab591a..08abe00e 100644
--- a/apps/plugins/api_views.py
+++ b/apps/plugins/api_views.py
@@ -335,16 +335,28 @@ def _save_fetched_manifest_to_repo(repo, data, verified):
     return None
 
 
+def _resolve_manifest_base_urls(manifest: dict) -> tuple[str, str]:
+    """Return (download_base_url, metadata_base_url) from a manifest dict.
+
+    Both fields fall back to root_url when not set. All base URL fields are
+    optional; callers must guard against empty strings before building URLs.
+    """
+    root_url = manifest.get("root_url", "").rstrip("/")
+    download_base_url = manifest.get("download_base_url", "").rstrip("/") or root_url
+    metadata_base_url = manifest.get("metadata_base_url", "").rstrip("/") or root_url
+    return download_base_url, metadata_base_url
+
+
 def _invalidate_plugin_detail_cache(repo_id, manifest_data):
     manifest = manifest_data.get("manifest", manifest_data)
-    root_url = manifest.get("root_url", "").rstrip("/")
+    _, metadata_base_url = _resolve_manifest_base_urls(manifest)
     keys = []
     for p in manifest.get("plugins", []):
         url = p.get("manifest_url", "")
         if not url:
             continue
-        if root_url and not url.startswith(("http://", "https://")):
-            url = f"{root_url}/{url}"
+        if metadata_base_url and not url.startswith(("http://", "https://")):
+            url = f"{metadata_base_url}/{url}"
         keys.append(f"plugin_detail:{repo_id}:{hashlib.md5(url.encode()).hexdigest()}")
     if keys:
         cache.delete_many(keys)
@@ -1045,18 +1057,28 @@ class AvailablePluginsAPIView(PluginAuthMixin, APIView):
         for repo in repos:
             manifest_data = repo.cached_manifest or {}
             manifest = manifest_data.get("manifest", manifest_data)
-            root_url = manifest.get("root_url", "").rstrip("/")
+            download_base_url, metadata_base_url = _resolve_manifest_base_urls(manifest)
             registry_url = manifest.get("registry_url", "").rstrip("/")
             repo_plugins = manifest.get("plugins", [])
             for p in repo_plugins:
                 slug = p.get("slug", "")
                 plugin_data = {**p}
-                # Resolve relative URLs against root_url; absolute URLs pass through
-                if root_url:
-                    for url_field in ("manifest_url", "latest_url", "icon_url"):
+                # Resolve relative URLs; metadata and download assets use separate bases
+                if metadata_base_url:
+                    for url_field in ("manifest_url", "icon_url"):
                         val = plugin_data.get(url_field, "")
                         if val and not val.startswith(("http://", "https://")):
-                            plugin_data[url_field] = f"{root_url}/{val}"
+                            plugin_data[url_field] = f"{metadata_base_url}/{val}"
+                if download_base_url:
+                    val = plugin_data.get("latest_url", "")
+                    if val and not val.startswith(("http://", "https://")):
+                        plugin_data["latest_url"] = f"{download_base_url}/{val}"
+                # Fallback icon_url: if metadata_base_url is explicitly set and manifest_url
+                # is known, assume logo.png lives in the same directory as the per-plugin
+                # manifest. Guard against root_url-only manifests to preserve the GitHub fallback.
+                if not plugin_data.get("icon_url") and manifest.get("metadata_base_url") and plugin_data.get("manifest_url"):
+                    manifest_dir = plugin_data["manifest_url"].rsplit("/", 1)[0]
+                    plugin_data["icon_url"] = f"{manifest_dir}/logo.png"
                 # Fallback icon_url from main branch when not provided
                 if not plugin_data.get("icon_url") and registry_url:
                     # registry_url is e.g. https://github.com/Dispatcharr/Plugins
@@ -1161,18 +1183,18 @@ class PluginDetailManifestAPIView(PluginAuthMixin, APIView):
             # Resolve relative URLs in versions
             repo_manifest = repo.cached_manifest or {}
             inner = repo_manifest.get("manifest", repo_manifest)
-            root_url = inner.get("root_url", "").rstrip("/")
+            download_base_url, _ = _resolve_manifest_base_urls(inner)
 
-            if root_url and isinstance(manifest_obj.get("versions"), list):
+            if download_base_url and isinstance(manifest_obj.get("versions"), list):
                 for v in manifest_obj["versions"]:
                     url_val = v.get("url", "")
                     if url_val and not url_val.startswith(("http://", "https://")):
-                        v["url"] = f"{root_url}/{url_val}"
-            if root_url and isinstance(manifest_obj.get("latest"), dict):
+                        v["url"] = f"{download_base_url}/{url_val}"
+            if download_base_url and isinstance(manifest_obj.get("latest"), dict):
                 for url_field in ("url", "latest_url"):
                     url_val = manifest_obj["latest"].get(url_field, "")
                     if url_val and not url_val.startswith(("http://", "https://")):
-                        manifest_obj["latest"][url_field] = f"{root_url}/{url_val}"
+                        manifest_obj["latest"][url_field] = f"{download_base_url}/{url_val}"
 
             result = {
                 "manifest": manifest_obj,
diff --git a/apps/plugins/loader.py b/apps/plugins/loader.py
index a7ecb255..d49da0f8 100644
--- a/apps/plugins/loader.py
+++ b/apps/plugins/loader.py
@@ -8,9 +8,9 @@ import sys
 import threading
 import types
 from dataclasses import dataclass, field
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, Iterator, List, Optional, Tuple
 
-from django.db import transaction
+from django.db import close_old_connections, transaction
 
 from .models import PluginConfig
 
@@ -92,6 +92,29 @@ class PluginManager:
                 key: lp.path for key, lp in self._registry.items() if lp and lp.path
             }
 
+        try:
+            return self._discover_plugins_impl(
+                sync_db=sync_db,
+                force_reload=force_reload,
+                previous_packages=previous_packages,
+                previous_aliases=previous_aliases,
+                previous_paths=previous_paths,
+                token=token,
+            )
+        finally:
+            # Discovery runs outside Django's request/task cycle (boot, worker_ready).
+            close_old_connections()
+
+    def _discover_plugins_impl(
+        self,
+        *,
+        sync_db: bool,
+        force_reload: bool,
+        previous_packages: Dict[str, str],
+        previous_aliases: Dict[str, str],
+        previous_paths: Dict[str, str],
+        token: int,
+    ) -> Dict[str, LoadedPlugin]:
         try:
             configs: Optional[Dict[str, PluginConfig]] = None
             try:
@@ -247,6 +270,23 @@ class PluginManager:
                 logger.exception("Deferring plugin DB sync; database not ready yet")
         return self._registry
 
+    def iter_actions_for_event(self, event_name: str) -> Iterator[Tuple[str, str]]:
+        """Yield (plugin_key, action_id) pairs from the in-memory registry."""
+        with self._lock:
+            registry = list(self._registry.items())
+        for key, lp in registry:
+            for action in lp.actions or []:
+                if not isinstance(action, dict):
+                    continue
+                action_id = action.get("id")
+                events = action.get("events")
+                if (
+                    action_id
+                    and isinstance(events, (list, tuple))
+                    and event_name in events
+                ):
+                    yield key, action_id
+
     def _load_plugin(
         self,
         key: str,
@@ -492,79 +532,85 @@ class PluginManager:
         return cfg.settings
 
     def run_action(self, key: str, action_id: str, params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
-        lp = self.get_plugin(key)
-        if not lp or not lp.instance:
-            # Attempt a lightweight re-discovery in case the registry was rebuilt
-            self.discover_plugins(sync_db=False, force_reload=False, use_cache=False)
+        try:
             lp = self.get_plugin(key)
             if not lp or not lp.instance:
-                raise ValueError(f"Plugin '{key}' not found")
+                # Attempt a lightweight re-discovery in case the registry was rebuilt
+                self.discover_plugins(sync_db=False, force_reload=False, use_cache=False)
+                lp = self.get_plugin(key)
+                if not lp or not lp.instance:
+                    raise ValueError(f"Plugin '{key}' not found")
 
-        cfg = PluginConfig.objects.get(key=key)
-        if not cfg.enabled:
-            raise PermissionError(f"Plugin '{key}' is disabled")
-        params = params or {}
+            cfg = PluginConfig.objects.get(key=key)
+            if not cfg.enabled:
+                raise PermissionError(f"Plugin '{key}' is disabled")
+            params = params or {}
 
-        context = self._build_context(lp, cfg)
+            context = self._build_context(lp, cfg)
 
-        # Run either via Celery if plugin provides a delayed method, or inline
-        run_method = getattr(lp.instance, "run", None)
-        if not callable(run_method):
-            raise ValueError(f"Plugin '{key}' has no runnable 'run' method")
+            run_method = getattr(lp.instance, "run", None)
+            if not callable(run_method):
+                raise ValueError(f"Plugin '{key}' has no runnable 'run' method")
 
-        try:
-            result = run_method(action_id, params, context)
-        except Exception:
-            logger.exception(f"Plugin '{key}' action '{action_id}' failed")
-            raise
+            try:
+                result = run_method(action_id, params, context)
+            except Exception:
+                logger.exception(f"Plugin '{key}' action '{action_id}' failed")
+                raise
 
-        # Normalize return
-        if isinstance(result, dict):
-            return result
-        return {"status": "ok", "result": result}
+            if isinstance(result, dict):
+                return result
+            return {"status": "ok", "result": result}
+        finally:
+            # Return geventpool checkouts for this greenlet/thread after every action,
+            # including Connect event hooks and manual UI runs.
+            close_old_connections()
 
     def stop_plugin(self, key: str, reason: Optional[str] = None) -> bool:
-        lp = self.get_plugin(key)
-        if not lp or not lp.instance:
-            return False
         try:
-            cfg = PluginConfig.objects.get(key=key)
-        except PluginConfig.DoesNotExist:
-            return False
-        if not cfg.enabled:
-            return False
-
-        context = self._build_context(lp, cfg)
-        if reason:
-            context["reason"] = reason
-
-        stop_method = getattr(lp.instance, "stop", None)
-        if callable(stop_method):
+            lp = self.get_plugin(key)
+            if not lp or not lp.instance:
+                return False
             try:
-                stop_method(context)
-                return True
-            except TypeError:
+                cfg = PluginConfig.objects.get(key=key)
+            except PluginConfig.DoesNotExist:
+                return False
+            if not cfg.enabled:
+                return False
+
+            context = self._build_context(lp, cfg)
+            if reason:
+                context["reason"] = reason
+
+            stop_method = getattr(lp.instance, "stop", None)
+            if callable(stop_method):
                 try:
-                    stop_method()
+                    stop_method(context)
                     return True
+                except TypeError:
+                    try:
+                        stop_method()
+                        return True
+                    except Exception:
+                        logger.exception("Plugin '%s' stop() failed", key)
+                        return False
                 except Exception:
                     logger.exception("Plugin '%s' stop() failed", key)
                     return False
-            except Exception:
-                logger.exception("Plugin '%s' stop() failed", key)
-                return False
 
-        run_method = getattr(lp.instance, "run", None)
-        if callable(run_method):
-            actions = {a.get("id") for a in (lp.actions or []) if isinstance(a, dict)}
-            if "stop" in actions:
-                try:
-                    run_method("stop", {}, context)
-                    return True
-                except Exception:
-                    logger.exception("Plugin '%s' stop action failed", key)
-                    return False
-        return False
+            run_method = getattr(lp.instance, "run", None)
+            if callable(run_method):
+                actions = {a.get("id") for a in (lp.actions or []) if isinstance(a, dict)}
+                if "stop" in actions:
+                    try:
+                        run_method("stop", {}, context)
+                        return True
+                    except Exception:
+                        logger.exception("Plugin '%s' stop action failed", key)
+                        return False
+            return False
+        finally:
+            close_old_connections()
 
     def stop_all_plugins(self, reason: Optional[str] = None) -> int:
         stopped = 0
diff --git a/apps/plugins/tests/__init__.py b/apps/plugins/tests/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/apps/plugins/tests/test_iter_actions_for_event.py b/apps/plugins/tests/test_iter_actions_for_event.py
new file mode 100644
index 00000000..05888157
--- /dev/null
+++ b/apps/plugins/tests/test_iter_actions_for_event.py
@@ -0,0 +1,51 @@
+from django.test import SimpleTestCase
+
+from apps.plugins.loader import LoadedPlugin, PluginManager
+
+
+class IterActionsForEventTests(SimpleTestCase):
+    def test_yields_matching_handlers(self):
+        pm = PluginManager()
+        pm._registry = {
+            "alpha": LoadedPlugin(
+                key="alpha",
+                name="Alpha",
+                actions=[
+                    {"id": "on_start", "events": ["channel_start"]},
+                    {"id": "manual"},
+                ],
+            ),
+            "beta": LoadedPlugin(
+                key="beta",
+                name="Beta",
+                actions=[
+                    {"id": "on_both", "events": ["channel_start", "channel_stop"]},
+                ],
+            ),
+        }
+
+        self.assertEqual(
+            list(pm.iter_actions_for_event("channel_start")),
+            [("alpha", "on_start"), ("beta", "on_both")],
+        )
+        self.assertEqual(list(pm.iter_actions_for_event("channel_stop")), [("beta", "on_both")])
+
+    def test_ignores_string_events_value(self):
+        pm = PluginManager()
+        pm._registry = {
+            "bad": LoadedPlugin(
+                key="bad",
+                name="Bad",
+                actions=[{"id": "hook", "events": "client_connect"}],
+            ),
+            "good": LoadedPlugin(
+                key="good",
+                name="Good",
+                actions=[{"id": "hook", "events": ["client_connect"]}],
+            ),
+        }
+
+        self.assertEqual(
+            list(pm.iter_actions_for_event("client_connect")),
+            [("good", "hook")],
+        )
diff --git a/apps/plugins/tests/test_run_action_db_cleanup.py b/apps/plugins/tests/test_run_action_db_cleanup.py
new file mode 100644
index 00000000..6313473d
--- /dev/null
+++ b/apps/plugins/tests/test_run_action_db_cleanup.py
@@ -0,0 +1,81 @@
+"""PluginManager must release geventpool checkouts after every run/stop."""
+
+from contextlib import contextmanager
+from unittest.mock import MagicMock, patch
+
+from django.test import SimpleTestCase
+
+from apps.plugins.loader import LoadedPlugin, PluginManager
+
+
+class PluginRunActionDbCleanupTests(SimpleTestCase):
+    @contextmanager
+    def _manager_with_plugin(self, run_impl):
+        instance = MagicMock()
+        instance.run = run_impl
+        lp = LoadedPlugin(
+            key="test_plugin",
+            name="Test Plugin",
+            instance=instance,
+            actions=[{"id": "do_work"}],
+        )
+        pm = PluginManager()
+        cfg = MagicMock(enabled=True, settings={})
+        with patch.object(pm, "get_plugin", return_value=lp), patch(
+            "apps.plugins.loader.PluginConfig.objects.get", return_value=cfg
+        ):
+            yield pm
+
+    @patch("apps.plugins.loader.close_old_connections")
+    def test_run_action_closes_connections_on_success(self, mock_close):
+        with self._manager_with_plugin(lambda *_a, **_k: {"status": "ok"}) as pm:
+            result = pm.run_action("test_plugin", "do_work")
+
+        self.assertEqual(result, {"status": "ok"})
+        mock_close.assert_called_once()
+
+    @patch("apps.plugins.loader.close_old_connections")
+    def test_run_action_closes_connections_on_plugin_error(self, mock_close):
+        def _boom(*_a, **_k):
+            raise RuntimeError("plugin failed")
+
+        with self._manager_with_plugin(_boom) as pm:
+            with self.assertRaises(RuntimeError):
+                pm.run_action("test_plugin", "do_work")
+
+        mock_close.assert_called_once()
+
+    @patch("apps.plugins.loader.close_old_connections")
+    def test_stop_plugin_closes_connections(self, mock_close):
+        instance = MagicMock()
+        instance.stop = MagicMock()
+        lp = LoadedPlugin(
+            key="test_plugin",
+            name="Test Plugin",
+            instance=instance,
+        )
+        pm = PluginManager()
+        cfg = MagicMock(enabled=True, settings={})
+        with patch.object(pm, "get_plugin", return_value=lp), patch(
+            "apps.plugins.loader.PluginConfig.objects.get", return_value=cfg
+        ):
+            self.assertTrue(pm.stop_plugin("test_plugin", reason="shutdown"))
+
+        mock_close.assert_called_once()
+
+
+class PluginDiscoverDbCleanupTests(SimpleTestCase):
+    @patch("apps.plugins.loader.close_old_connections")
+    @patch.object(PluginManager, "_discover_plugins_impl", return_value={})
+    def test_discover_plugins_closes_connections(self, _mock_impl, mock_close):
+        pm = PluginManager()
+        pm.discover_plugins(sync_db=False)
+        mock_close.assert_called_once()
+
+    @patch("apps.plugins.loader.close_old_connections")
+    def test_discover_plugins_cache_hit_skips_close(self, mock_close):
+        pm = PluginManager()
+        pm._discovery_completed = True
+        pm._last_reload_token = pm._get_reload_token()
+        pm.discover_plugins(sync_db=False, use_cache=True)
+        mock_close.assert_not_called()
diff --git a/apps/proxy/config.py b/apps/proxy/config.py
index 999b7cfb..48d9fc9b 100644
--- a/apps/proxy/config.py
+++ b/apps/proxy/config.py
@@ -42,7 +42,8 @@ class BaseConfig:
                 "buffering_speed": 1.0,
                 "redis_chunk_ttl": 60,
                 "channel_shutdown_delay": 0,
-                "channel_init_grace_period": 5,
+                "channel_init_grace_period": 60,
+                "channel_client_wait_period": 5,
                 "new_client_behind_seconds": 5,
             }
 
@@ -133,9 +134,15 @@ class TSConfig(BaseConfig):
 
     @classmethod
     def get_channel_init_grace_period(cls):
-        """Get channel init grace period from database or default"""
+        """Max seconds to wait for initial buffer fill during channel startup."""
         settings = cls.get_proxy_settings()
-        return settings.get("channel_init_grace_period", 5)
+        return settings.get("channel_init_grace_period", 60)
+
+    @classmethod
+    def get_channel_client_wait_period(cls):
+        """Seconds to keep a ready channel alive waiting for the first client to connect."""
+        settings = cls.get_proxy_settings()
+        return settings.get("channel_client_wait_period", 5)
 
     # Dynamic property access for these settings
     @property
@@ -154,5 +161,6 @@ class TSConfig(BaseConfig):
     def CHANNEL_INIT_GRACE_PERIOD(self):
         return self.get_channel_init_grace_period()
 
-
-
+    @property
+    def CHANNEL_CLIENT_WAIT_PERIOD(self):
+        return self.get_channel_client_wait_period()
diff --git a/apps/proxy/live_proxy/client_manager.py b/apps/proxy/live_proxy/client_manager.py
index 3ab1861c..23f8e768 100644
--- a/apps/proxy/live_proxy/client_manager.py
+++ b/apps/proxy/live_proxy/client_manager.py
@@ -102,6 +102,7 @@ class ClientManager:
                         break
 
                     # Send heartbeat for all local clients
+                    clients_to_remove = set()
                     with self.lock:
                         # Skip this cycle if we have no local clients
                         if not self.clients:
@@ -109,7 +110,6 @@ class ClientManager:
 
                         # IMPROVED GHOST DETECTION: Check for stale clients before sending heartbeats
                         current_time = time.time()
-                        clients_to_remove = set()
 
                         # First identify clients that should be removed
                         for client_id in self.clients:
@@ -132,12 +132,11 @@ class ClientManager:
                                     logger.debug(f"Client {client_id} inactive for {current_time - last_active_time:.1f}s, removing as ghost")
                                     clients_to_remove.add(client_id)
 
-                        # Remove ghost clients in a separate step
-                        for client_id in clients_to_remove:
-                            self.remove_client(client_id)
-
                         if clients_to_remove:
-                            logger.info(f"Removed {len(clients_to_remove)} ghost clients from channel {self.channel_id}")
+                            logger.info(
+                                f"Identified {len(clients_to_remove)} ghost clients "
+                                f"for channel {self.channel_id}"
+                            )
 
                         # Now send heartbeats only for remaining clients
                         pipe = self.redis_client.pipeline()
@@ -172,6 +171,9 @@ class ClientManager:
                         if self.clients and not all(c in clients_to_remove for c in self.clients):
                             self._notify_owner_of_activity()
 
+                    for client_id in clients_to_remove:
+                        self.remove_client(client_id)
+
                 except Exception as e:
                     logger.error(f"Error in client heartbeat thread: {e}")
 
@@ -254,6 +256,14 @@ class ClientManager:
 
                 # Store in Redis
                 if self.redis_client:
+                    from .services.channel_service import ChannelService
+
+                    if ChannelService.cancel_pending_shutdown(self.channel_id):
+                        logger.info(
+                            f"Cancelled pending shutdown for channel {self.channel_id} "
+                            f"(client {client_id} reconnected)"
+                        )
+
                     self.redis_client.hset(client_key, mapping=client_data)
                     self.redis_client.expire(client_key, self.client_ttl)
 
@@ -291,6 +301,8 @@ class ClientManager:
                     # Trigger channel stats update via WebSocket
                     self._trigger_stats_update()
 
+                    ChannelService.promote_channel_when_buffer_ready(self.channel_id)
+
                 # Get total clients across all workers
                 total_clients = self.get_total_client_count()
                 logger.info(f"New client connected: {client_id} (local: {len(self.clients)}, total: {total_clients})")
@@ -300,11 +312,17 @@ class ClientManager:
                 return len(self.clients)
 
         except Exception as e:
-            logger.error(f"Error adding client {client_id}: {e}")
+            logger.error(f"Error adding client {client_id}: {e}", exc_info=True)
+            with self.lock:
+                self.clients.discard(client_id)
+            self._registered_clients.discard(client_id)
             return False
 
     def remove_client(self, client_id):
         """Remove a client from this channel and Redis"""
+        client_username = "unknown"
+        remaining = None
+
         with self.lock:
             if client_id in self.clients:
                 self.clients.remove(client_id)
@@ -315,61 +333,81 @@ class ClientManager:
             self.last_active_time = time.time()
 
             if self.redis_client:
-                # Get client data before removing the data
                 client_key = f"live:channel:{self.channel_id}:clients:{client_id}"
                 client_username = self.redis_client.hget(client_key, "username") or "unknown"
                 if isinstance(client_username, bytes):
                     client_username = client_username.decode("utf-8")
 
-                # Remove from channel's client set
                 self.redis_client.srem(self.client_set_key, client_id)
-
-                client_key = f"live:channel:{self.channel_id}:clients:{client_id}"
                 self.redis_client.delete(client_key)
-
-                # Check if this was the last client
                 remaining = self.redis_client.scard(self.client_set_key) or 0
-                if remaining == 0:
-                    logger.warning(f"Last client removed: {client_id} - channel may shut down soon")
 
-                    # Trigger disconnect time tracking even if we're not the owner
-                    disconnect_key = RedisKeys.last_client_disconnect(self.channel_id)
-                    self.redis_client.setex(disconnect_key, 60, str(time.time()))
+            local_count = len(self.clients)
 
-                self._notify_owner_of_activity()
+        if not self.redis_client:
+            return local_count
 
-                # Check if we're the owner - if so, handle locally; if not, publish event
-                am_i_owner = self.proxy_server and self.proxy_server.am_i_owner(self.channel_id)
+        if remaining == 0:
+            logger.warning(f"Last client removed: {client_id} - channel may shut down soon")
+            disconnect_key = RedisKeys.last_client_disconnect(self.channel_id)
+            ttl = max(int(ConfigHelper.channel_shutdown_delay() * 2), 60)
+            self.redis_client.setex(disconnect_key, ttl, str(time.time()))
 
-                if am_i_owner:
-                    # We're the owner - handle the disconnect directly
-                    logger.debug(f"Owner handling CLIENT_DISCONNECTED for client {client_id} locally (not publishing)")
-                    if (remaining == 0
-                            or self.proxy_server.output_managers.get(self.channel_id)
-                            or self.proxy_server.profile_managers.get(self.channel_id)):
-                        import gevent
-                        gevent.spawn(self.proxy_server.handle_client_disconnect, self.channel_id)
-                else:
-                    # We're not the owner - publish event so owner can handle it
-                    logger.debug(f"Non-owner publishing CLIENT_DISCONNECTED event for client {client_id} on channel {self.channel_id} from worker {self.worker_id}")
-                    event_data = json.dumps({
-                        "event": EventType.CLIENT_DISCONNECTED,
-                        "channel_id": self.channel_id,
-                        "client_id": client_id,
-                        "worker_id": self.worker_id or "unknown",
-                        "timestamp": time.time(),
-                        "remaining_clients": remaining,
-                        "username": client_username
-                    })
-                    self.redis_client.publish(RedisKeys.events_channel(self.channel_id), event_data)
+        self._notify_owner_of_activity()
 
-                # Trigger channel stats update via WebSocket
-                self._trigger_stats_update()
+        am_i_owner = self.proxy_server and self.proxy_server.am_i_owner(self.channel_id)
 
-            total_clients = self.get_total_client_count()
-            logger.info(f"Client disconnected: {client_id} (local: {len(self.clients)}, total: {total_clients})")
+        # Owner lock TTL can expire while local ffmpeg is still running on this worker.
+        if (not am_i_owner and self.proxy_server
+                and self.proxy_server._has_local_upstream_activity(self.channel_id)):
+            if self.proxy_server.extend_ownership(self.channel_id):
+                am_i_owner = True
 
-        return len(self.clients)
+        schedule_disconnect = False
+        if am_i_owner:
+            logger.debug(
+                f"Owner handling CLIENT_DISCONNECTED for client {client_id} locally (not publishing)"
+            )
+            if (remaining == 0
+                    or self.proxy_server.output_managers.get(self.channel_id)
+                    or self.proxy_server.profile_managers.get(self.channel_id)):
+                schedule_disconnect = True
+        elif (remaining == 0 and self.proxy_server
+              and self.proxy_server._has_local_upstream_activity(self.channel_id)):
+            logger.warning(
+                f"Last client removed while local upstream still active for "
+                f"{self.channel_id} without owner lock - stopping channel"
+            )
+            schedule_disconnect = True
+        else:
+            logger.debug(
+                f"Non-owner publishing CLIENT_DISCONNECTED event for client {client_id} "
+                f"on channel {self.channel_id} from worker {self.worker_id}"
+            )
+            event_data = json.dumps({
+                "event": EventType.CLIENT_DISCONNECTED,
+                "channel_id": self.channel_id,
+                "client_id": client_id,
+                "worker_id": self.worker_id or "unknown",
+                "timestamp": time.time(),
+                "remaining_clients": remaining,
+                "username": client_username
+            })
+            self.redis_client.publish(RedisKeys.events_channel(self.channel_id), event_data)
+
+        if schedule_disconnect and self.proxy_server:
+            self.proxy_server._spawn_on_hub(
+                self.proxy_server.handle_client_disconnect, self.channel_id
+            )
+
+        self._trigger_stats_update()
+
+        total_clients = self.get_total_client_count()
+        logger.info(
+            f"Client disconnected: {client_id} (local: {local_count}, total: {total_clients})"
+        )
+
+        return local_count
 
     def get_client_count(self):
         """Get local client count"""
@@ -442,3 +480,19 @@ class ClientManager:
             )
 
         return stale_ids
+
+    @staticmethod
+    def clear_all_clients(redis_client, channel_id):
+        """Remove every client entry from Redis for a channel."""
+        client_set_key = RedisKeys.clients(channel_id)
+        client_ids = redis_client.smembers(client_set_key)
+        if not client_ids:
+            return 0
+
+        pipe = redis_client.pipeline(transaction=False)
+        for cid in client_ids:
+            cid_str = cid.decode() if isinstance(cid, bytes) else cid
+            pipe.delete(RedisKeys.client_metadata(channel_id, cid_str))
+        pipe.delete(client_set_key)
+        pipe.execute()
+        return len(client_ids)
diff --git a/apps/proxy/live_proxy/config_helper.py b/apps/proxy/live_proxy/config_helper.py
index f9a0418e..846b0153 100644
--- a/apps/proxy/live_proxy/config_helper.py
+++ b/apps/proxy/live_proxy/config_helper.py
@@ -107,9 +107,14 @@ class ConfigHelper:
 
     @staticmethod
     def channel_init_grace_period():
-        """Get channel initialization grace period in seconds"""
+        """Max seconds to wait for initial buffer fill during channel startup."""
         return Config.get_channel_init_grace_period()
 
+    @staticmethod
+    def channel_client_wait_period():
+        """Seconds to keep a ready channel alive waiting for the first client to connect."""
+        return Config.get_channel_client_wait_period()
+
     @staticmethod
     def chunk_timeout():
         """
diff --git a/apps/proxy/live_proxy/input/buffer.py b/apps/proxy/live_proxy/input/buffer.py
index e26ed3ff..3d3fb091 100644
--- a/apps/proxy/live_proxy/input/buffer.py
+++ b/apps/proxy/live_proxy/input/buffer.py
@@ -64,7 +64,7 @@ class StreamBuffer:
 
     def add_chunk(self, chunk):
         """Add data with optimized Redis storage and TS packet alignment"""
-        if not chunk:
+        if not chunk or self.stopping:
             return False
 
         try:
@@ -309,38 +309,16 @@ class StreamBuffer:
         self.fill_timers.clear()
 
         try:
-            # Flush any remaining data in the write buffer
-            if hasattr(self, '_write_buffer') and len(self._write_buffer) > 0:
-                # Ensure remaining data is aligned to TS packets
-                complete_size = (len(self._write_buffer) // 188) * 188
-
-                if complete_size > 0:
-                    final_chunk = self._write_buffer[:complete_size]
-
-                    # Write final chunk to Redis
-                    with self.lock:
-                        if self.redis_client:
-                            try:
-                                chunk_index = self.redis_client.incr(self.buffer_index_key)
-                                chunk_key = f"{self.buffer_prefix}{chunk_index}"
-                                self.redis_client.setex(chunk_key, self.chunk_ttl, bytes(final_chunk))
-                                self.index = chunk_index
-                                logger.info(f"Flushed final chunk of {len(final_chunk)} bytes to Redis")
-                            except Exception as e:
-                                logger.error(f"Error flushing final chunk: {e}")
-
-                # Clear buffers
-                self._write_buffer = bytearray()
-                if hasattr(self, '_partial_packet'):
-                    self._partial_packet = bytearray()
-
-            # Clean up the chunk timestamps sorted set
-            if self.redis_client and self.chunk_timestamps_key:
-                try:
-                    self.redis_client.delete(self.chunk_timestamps_key)
-                except Exception as e:
-                    logger.error(f"Error deleting chunk timestamps key: {e}")
-
+            with self.lock:
+                if hasattr(self, '_write_buffer') and len(self._write_buffer) > 0:
+                    discarded = len(self._write_buffer)
+                    self._write_buffer = bytearray()
+                    if hasattr(self, '_partial_packet'):
+                        self._partial_packet = bytearray()
+                    logger.debug(
+                        f"Discarded {discarded} bytes from local write buffer "
+                        f"for channel {self.channel_id}"
+                    )
         except Exception as e:
             logger.error(f"Error during buffer stop: {e}")
 
diff --git a/apps/proxy/live_proxy/input/manager.py b/apps/proxy/live_proxy/input/manager.py
index ccc52318..8c76c1be 100644
--- a/apps/proxy/live_proxy/input/manager.py
+++ b/apps/proxy/live_proxy/input/manager.py
@@ -67,6 +67,7 @@ class StreamManager:
         # Add to your __init__ method
         self._buffer_check_timers = []
         self.stopping = False
+        self.stop_requested = False
 
         # Add tracking for tried streams and current stream
         self.current_stream_id = stream_id
@@ -112,6 +113,11 @@ class StreamManager:
         # Add tracking for data throughput
         self.bytes_processed = 0
         self.last_bytes_update = time.time()
+
+        # Cached result of the pipelined Redis ownership audit (hot read path).
+        self._ownership_cache_valid_until = 0.0
+        self._ownership_cached = True
+        self._OWNERSHIP_CHECK_INTERVAL = 1.0
         self.bytes_update_interval = 5  # Update Redis every 5 seconds
 
         # Add stderr reader thread property
@@ -182,6 +188,153 @@ class StreamManager:
         logger.warning(f"Timeout waiting for existing processes to close for channel {self.channel_id} after {timeout}s")
         return False
 
+    def _invalidate_ownership_cache(self):
+        self._ownership_cache_valid_until = 0.0
+
+    @staticmethod
+    def _decode_redis_value(value):
+        if value is None:
+            return None
+        if isinstance(value, bytes):
+            return value.decode()
+        return value
+
+    def _disconnect_shutdown_ready(self, disconnect_value):
+        """True when last-client disconnect has passed the configured shutdown delay."""
+        if not disconnect_value:
+            return False
+
+        shutdown_delay = ConfigHelper.channel_shutdown_delay()
+        if shutdown_delay <= 0:
+            return True
+
+        disconnect_value = self._decode_redis_value(disconnect_value)
+        try:
+            disconnect_time = float(disconnect_value)
+        except (ValueError, TypeError):
+            return False
+        return (time.time() - disconnect_time) >= shutdown_delay
+
+    def _evaluate_ownership_from_redis(self, redis_client):
+        """Single pipelined Redis round-trip for the full ownership audit."""
+        stop_key = RedisKeys.channel_stopping(self.channel_id)
+        metadata_key = RedisKeys.channel_metadata(self.channel_id)
+        clients_key = RedisKeys.clients(self.channel_id)
+        owner_key = RedisKeys.channel_owner(self.channel_id)
+        disconnect_key = RedisKeys.last_client_disconnect(self.channel_id)
+
+        pipe = redis_client.pipeline(transaction=False)
+        pipe.exists(stop_key)
+        pipe.exists(metadata_key)
+        pipe.scard(clients_key)
+        pipe.get(owner_key)
+        pipe.get(disconnect_key)
+        pipe.hget(metadata_key, ChannelMetadataField.STATE)
+        (
+            stop_exists,
+            metadata_exists,
+            client_count,
+            current_owner,
+            disconnect_value,
+            state_raw,
+        ) = pipe.execute()
+
+        if stop_exists:
+            return False
+
+        if not metadata_exists:
+            logger.warning(
+                f"Channel {self.channel_id} metadata removed from Redis - stopping upstream"
+            )
+            return False
+
+        client_count = client_count or 0
+        state = self._decode_redis_value(state_raw)
+        current_owner = self._decode_redis_value(current_owner)
+
+        if current_owner and current_owner != self.worker_id:
+            return False
+
+        if not current_owner:
+            if client_count == 0 and state not in ChannelState.PRE_ACTIVE:
+                logger.warning(
+                    f"Channel {self.channel_id} has no owner and no clients - stopping upstream"
+                )
+                return False
+            return True
+
+        if client_count == 0 and self._disconnect_shutdown_ready(disconnect_value):
+            logger.info(
+                f"Channel {self.channel_id} disconnect shutdown ready - stopping upstream"
+            )
+            return False
+
+        return True
+
+    def _still_owner(self, *, force=False):
+        """Return True while this worker should keep the upstream connection open."""
+        if self.stopping or self.stop_requested:
+            return False
+
+        if not self.worker_id:
+            return True
+
+        redis_client = getattr(self.buffer, 'redis_client', None)
+        if not redis_client:
+            return True
+
+        now = time.time()
+        if not force and now < self._ownership_cache_valid_until:
+            return self._ownership_cached
+
+        try:
+            result = self._evaluate_ownership_from_redis(redis_client)
+            self._ownership_cached = result
+            self._ownership_cache_valid_until = now + self._OWNERSHIP_CHECK_INTERVAL
+            return result
+        except Exception as e:
+            logger.debug(f"Ownership check failed for channel {self.channel_id}: {e}")
+            return True
+
+    def _upstream_may_continue(self):
+        """
+        Per-chunk gate for the hot read path.
+
+        Local stop flags are checked every chunk. The coordinated-teardown Redis
+        flag is checked every chunk (one EXISTS). The full ownership audit is
+        pipelined and cached for ~1s — enough for loop boundaries while avoiding
+        6+ Redis round-trips per chunk during steady streaming.
+        """
+        if self.stopping or self.stop_requested or not self.running:
+            return False
+        if self.buffer is not None and self.buffer.stopping:
+            return False
+
+        redis_client = getattr(self.buffer, 'redis_client', None)
+        if redis_client and self.worker_id:
+            try:
+                if redis_client.exists(RedisKeys.channel_stopping(self.channel_id)):
+                    self._ownership_cached = False
+                    self._ownership_cache_valid_until = 0.0
+                    return False
+            except Exception as e:
+                logger.debug(
+                    f"Channel stopping check failed for {self.channel_id}: {e}"
+                )
+
+        return self._still_owner()
+
+    def _ensure_owner_or_stop(self):
+        if self._still_owner(force=True):
+            return True
+
+        logger.warning(
+            f"Stream manager for channel {self.channel_id} lost ownership "
+            f"(worker {self.worker_id}) - stopping upstream"
+        )
+        self.stop()
+        return False
+
     def run(self):
         """Main execution loop using HTTP streaming with improved connection handling and stream switching"""
         # Add a stop flag to the class properties
@@ -203,6 +356,8 @@ class StreamManager:
             # Main stream switching loop - we'll try different streams if needed
             while self.running and stream_switch_attempts <= max_stream_switches:
                 close_old_connections()
+                if not self._ensure_owner_or_stop():
+                    break
                 # Check for stuck switching state
                 if self.url_switching and time.time() - self.url_switch_start_time > self.url_switch_timeout:
                     logger.warning(f"URL switching state appears stuck for channel {self.channel_id} "
@@ -255,6 +410,8 @@ class StreamManager:
                     continue
                 # Connection retry loop for current URL
                 while self.running and self.retry_count < self.max_retries and not url_failed and not self.needs_stream_switch:
+                    if not self._ensure_owner_or_stop():
+                        break
 
                     logger.info(f"Connection attempt {self.retry_count + 1}/{self.max_retries} for URL: {self.url} for channel {self.channel_id}")
 
@@ -382,6 +539,12 @@ class StreamManager:
         except Exception as e:
             logger.error(f"Stream error: {e}", exc_info=True)
         finally:
+            try:
+                from ..server import ProxyServer
+                ProxyServer.get_instance()._live_stream_managers.pop(self.channel_id, None)
+            except Exception:
+                pass
+
             # Enhanced cleanup in the finally block
             self.connected = False
 
@@ -410,7 +573,9 @@ class StreamManager:
                 try:
                     metadata_key = RedisKeys.channel_metadata(self.channel_id)
                     owner_key = RedisKeys.channel_owner(self.channel_id)
-                    current_owner = self.buffer.redis_client.get(owner_key)
+                    current_owner = self._decode_redis_value(
+                        self.buffer.redis_client.get(owner_key)
+                    )
 
                     is_owner = (
                         current_owner
@@ -421,12 +586,10 @@ class StreamManager:
 
                     should_update = is_owner
                     if not should_update and no_owner:
-                        current_state_bytes = self.buffer.redis_client.hget(
-                            metadata_key, ChannelMetadataField.STATE
-                        )
-                        current_state = (
-                            current_state_bytes
-                            if current_state_bytes else None
+                        current_state = self._decode_redis_value(
+                            self.buffer.redis_client.hget(
+                                metadata_key, ChannelMetadataField.STATE
+                            )
                         )
                         should_update = current_state in ChannelState.PRE_ACTIVE
                         if not should_update and current_state:
@@ -488,44 +651,48 @@ class StreamManager:
                 logger.debug(f"Closing existing HTTP connections before establishing transcode connection for channel {self.channel_id}")
                 self._close_connection()
 
-            channel = get_stream_object(self.channel_id)
+            try:
+                channel = get_stream_object(self.channel_id)
 
-            # Use FFmpeg specifically for HLS streams
-            if hasattr(self, 'force_ffmpeg') and self.force_ffmpeg:
-                from core.models import StreamProfile
-                try:
-                    stream_profile = StreamProfile.objects.get(name='ffmpeg', locked=True)
-                    logger.info("Using FFmpeg stream profile for unsupported proxy content (HLS/RTSP/UDP)")
-                except StreamProfile.DoesNotExist:
-                    # Fall back to channel's profile if FFmpeg not found
+                # Use FFmpeg specifically for HLS streams
+                if hasattr(self, 'force_ffmpeg') and self.force_ffmpeg:
+                    from core.models import StreamProfile
+                    try:
+                        stream_profile = StreamProfile.objects.get(name='ffmpeg', locked=True)
+                        logger.info("Using FFmpeg stream profile for unsupported proxy content (HLS/RTSP/UDP)")
+                    except StreamProfile.DoesNotExist:
+                        # Fall back to channel's profile if FFmpeg not found
+                        stream_profile = channel.get_stream_profile()
+                        logger.warning(f"FFmpeg profile not found, using channel default profile for channel: {self.channel_id}")
+                else:
                     stream_profile = channel.get_stream_profile()
-                    logger.warning(f"FFmpeg profile not found, using channel default profile for channel: {self.channel_id}")
-            else:
-                stream_profile = channel.get_stream_profile()
 
-            # Build and start transcode command
-            self.transcode_cmd = stream_profile.build_command(self.url, self.user_agent)
+                # Build and start transcode command
+                self.transcode_cmd = stream_profile.build_command(self.url, self.user_agent)
 
-            # Store stream command for efficient log parser routing
-            self.stream_command = stream_profile.command
-            # Map actual commands to parser types for direct routing
-            command_to_parser = {
-                'ffmpeg': 'ffmpeg',
-                'cvlc': 'vlc',
-                'vlc': 'vlc',
-                'streamlink': 'streamlink'
-            }
-            self.parser_type = command_to_parser.get(self.stream_command.lower())
-            if self.parser_type:
-                logger.debug(f"Using {self.parser_type} parser for log parsing (command: {self.stream_command})")
-            else:
-                logger.debug(f"Unknown stream command '{self.stream_command}', will use auto-detection for log parsing")
+                # Store stream command for efficient log parser routing
+                self.stream_command = stream_profile.command
+                # Map actual commands to parser types for direct routing
+                command_to_parser = {
+                    'ffmpeg': 'ffmpeg',
+                    'cvlc': 'vlc',
+                    'vlc': 'vlc',
+                    'streamlink': 'streamlink'
+                }
+                self.parser_type = command_to_parser.get(self.stream_command.lower())
+                if self.parser_type:
+                    logger.debug(f"Using {self.parser_type} parser for log parsing (command: {self.stream_command})")
+                else:
+                    logger.debug(f"Unknown stream command '{self.stream_command}', will use auto-detection for log parsing")
 
-            # For UDP streams, remove any user_agent parameters from the command
-            if hasattr(self, 'stream_type') and self.stream_type == StreamType.UDP:
-                # Filter out any arguments that contain the user_agent value or related headers
-                self.transcode_cmd = [arg for arg in self.transcode_cmd if self.user_agent not in arg and 'user-agent' not in arg.lower() and 'user_agent' not in arg.lower()]
-                logger.debug(f"Removed user_agent parameters from UDP stream command for channel: {self.channel_id}")
+                # For UDP streams, remove any user_agent parameters from the command
+                if hasattr(self, 'stream_type') and self.stream_type == StreamType.UDP:
+                    # Filter out any arguments that contain the user_agent value or related headers
+                    self.transcode_cmd = [arg for arg in self.transcode_cmd if self.user_agent not in arg and 'user-agent' not in arg.lower() and 'user_agent' not in arg.lower()]
+                    logger.debug(f"Removed user_agent parameters from UDP stream command for channel: {self.channel_id}")
+            finally:
+                # Release the pool slot before posix_spawn or before returning on profile errors.
+                close_old_connections()
 
             logger.debug(f"Starting transcode process: {self.transcode_cmd} for channel: {self.channel_id}")
 
@@ -1020,6 +1187,9 @@ class StreamManager:
 
     def _update_bytes_processed(self, chunk_size):
         """Update the total bytes processed in Redis metadata"""
+        if not self._upstream_may_continue():
+            return
+
         try:
             # Update local counter
             self.bytes_processed += chunk_size
@@ -1092,14 +1262,10 @@ class StreamManager:
         """Stop the stream manager and cancel all timers"""
         logger.info(f"Stopping stream manager for channel {self.channel_id}")
 
-        # Add at the beginning of your stop method
         self.stopping = True
-
-        # Release stream resources if we're the owner
-        if self.current_stream_id and hasattr(self, 'worker_id') and self.worker_id:
-            if hasattr(self.buffer, 'redis_client') and self.buffer.redis_client:
-                owner_key = RedisKeys.channel_owner(self.channel_id)
-                current_owner = self.buffer.redis_client.get(owner_key)
+        self._invalidate_ownership_cache()
+        if self.buffer is not None:
+            self.buffer.stopping = True
 
         # Cancel all buffer check timers
         for timer in list(self._buffer_check_timers):
@@ -1254,6 +1420,12 @@ class StreamManager:
         """Check if connection retry is allowed"""
         return self.retry_count < self.max_retries
 
+    def _health_inactivity_threshold(self):
+        """How long without data before marking the stream unhealthy."""
+        if self.connected and getattr(self.buffer, 'index', 0) == 0:
+            return ConfigHelper.channel_init_grace_period()
+        return getattr(Config, 'CONNECTION_TIMEOUT', 10)
+
     def _monitor_health(self):
         """Monitor stream health and set flags for the main loop to handle recovery"""
         consecutive_unhealthy_checks = 0
@@ -1269,7 +1441,7 @@ class StreamManager:
             try:
                 now = time.time()
                 inactivity_duration = now - self.last_data_time
-                timeout_threshold = getattr(Config, 'CONNECTION_TIMEOUT', 10)
+                timeout_threshold = self._health_inactivity_threshold()
 
                 if inactivity_duration > timeout_threshold and self.connected:
                     if self.healthy:
@@ -1489,7 +1661,8 @@ class StreamManager:
             if hasattr(self, 'stderr_reader_thread') and self.stderr_reader_thread and self.stderr_reader_thread.is_alive():
                 try:
                     logger.debug(f"Waiting for stderr reader thread to terminate for channel {self.channel_id}")
-                    self.stderr_reader_thread.join(timeout=2.0)
+                    stderr_join_timeout = 0.25 if self.stopping else 2.0
+                    self.stderr_reader_thread.join(timeout=stderr_join_timeout)
                     if self.stderr_reader_thread.is_alive():
                         logger.warning(f"Stderr reader thread did not terminate within timeout for channel {self.channel_id}")
                 except Exception as e:
@@ -1582,6 +1755,10 @@ class StreamManager:
                 self.connected = False
                 return False
 
+            if not self._upstream_may_continue():
+                self.stop()
+                return False
+
             # Track chunk size before adding to buffer
             chunk_size = len(chunk)
             self._update_bytes_processed(chunk_size)
@@ -1589,7 +1766,6 @@ class StreamManager:
             # Add directly to buffer without TS-specific processing
             success = self.buffer.add_chunk(chunk)
 
-            # Update last data timestamp in Redis if successful
             if success and hasattr(self.buffer, 'redis_client') and self.buffer.redis_client:
                 last_data_key = RedisKeys.last_data(self.buffer.channel_id)
                 self.buffer.redis_client.set(last_data_key, str(time.time()), ex=60)
@@ -1660,19 +1836,9 @@ class StreamManager:
                             timer.start()
                             return False
 
-                        # We have enough buffer, proceed with state change
-                        update_data = {
-                            ChannelMetadataField.STATE: ChannelState.WAITING_FOR_CLIENTS,
-                            ChannelMetadataField.CONNECTION_READY_TIME: current_time,
-                            ChannelMetadataField.STATE_CHANGED_AT: current_time,
-                            ChannelMetadataField.BUFFER_CHUNKS: str(current_buffer_index)
-                        }
-                        redis_client.hset(metadata_key, mapping=update_data)
+                        from ..services.channel_service import ChannelService
 
-                        # Get configured grace period or default
-                        grace_period = ConfigHelper.channel_init_grace_period()
-                        logger.info(f"STREAM MANAGER: Updated channel {channel_id} state: {current_state or 'None'} -> {ChannelState.WAITING_FOR_CLIENTS} with {current_buffer_index} buffer chunks")
-                        logger.info(f"Started initial connection grace period ({grace_period}s) for channel {channel_id}")
+                        ChannelService.promote_channel_when_buffer_ready(channel_id)
                     else:
                         logger.debug(f"Not changing state: channel {channel_id} already in {current_state} state")
         except Exception as e:
diff --git a/apps/proxy/live_proxy/output/fmp4/generator.py b/apps/proxy/live_proxy/output/fmp4/generator.py
index 65a8c5c7..d967b5f9 100644
--- a/apps/proxy/live_proxy/output/fmp4/generator.py
+++ b/apps/proxy/live_proxy/output/fmp4/generator.py
@@ -11,6 +11,7 @@ import time
 import gevent
 from apps.channels.models import Channel, Stream
 from core.utils import log_system_event
+from django.db import close_old_connections
 from ...server import ProxyServer
 from ...redis_keys import RedisKeys
 from ...constants import ChannelMetadataField
@@ -331,46 +332,53 @@ class FMP4StreamGenerator:
     # ------------------------------------------------------------------
 
     def _cleanup(self):
-        elapsed = time.time() - self.stream_start_time
-        proxy_server = ProxyServer.get_instance()
+        try:
+            elapsed = time.time() - self.stream_start_time
+            proxy_server = ProxyServer.get_instance()
 
-        # Release stream allocation if last client (mirrors StreamGenerator)
-        if proxy_server.redis_client:
-            try:
-                meta_key = RedisKeys.channel_metadata(self.channel_id)
-                stream_id_bytes = proxy_server.redis_client.hget(
-                    meta_key, ChannelMetadataField.STREAM_ID
-                )
-                if stream_id_bytes:
-                    if self.channel_id in proxy_server.client_managers:
-                        client_count = proxy_server.client_managers[
-                            self.channel_id
-                        ].get_total_client_count()
-                        if client_count <= 1 and proxy_server.am_i_owner(self.channel_id):
-                            try:
+            # Release stream allocation if last client (mirrors StreamGenerator)
+            if proxy_server.redis_client:
+                try:
+                    meta_key = RedisKeys.channel_metadata(self.channel_id)
+                    stream_id_bytes = proxy_server.redis_client.hget(
+                        meta_key, ChannelMetadataField.STREAM_ID
+                    )
+                    if stream_id_bytes:
+                        if self.channel_id in proxy_server.client_managers:
+                            client_count = proxy_server.client_managers[
+                                self.channel_id
+                            ].get_total_client_count()
+                            if (
+                                client_count <= 1
+                                and proxy_server.am_i_owner(self.channel_id)
+                                and ConfigHelper.channel_shutdown_delay() <= 0
+                            ):
                                 try:
-                                    obj = Channel.objects.get(uuid=self.channel_id)
-                                except (Channel.DoesNotExist, Exception):
-                                    obj = Stream.objects.get(stream_hash=self.channel_id)
-                                obj.release_stream()
-                            except Exception as e:
-                                logger.error(
-                                    f"[{self.client_id}] Error releasing stream: {e}"
-                                )
-            except Exception as e:
-                logger.error(f"[{self.client_id}] Error in stream release check: {e}")
+                                    try:
+                                        obj = Channel.objects.get(uuid=self.channel_id)
+                                    except (Channel.DoesNotExist, Exception):
+                                        obj = Stream.objects.get(stream_hash=self.channel_id)
+                                    obj.release_stream()
+                                except Exception as e:
+                                    logger.error(
+                                        f"[{self.client_id}] Error releasing stream: {e}"
+                                    )
+                except Exception as e:
+                    logger.error(f"[{self.client_id}] Error in stream release check: {e}")
 
-        # Remove from MAIN ClientManager - this is what triggers handle_client_disconnect
-        # and the zero-clients → stop_channel path, same as TS clients.
-        local_clients = 0
-        total_clients = 0
-        if self.channel_id in proxy_server.client_managers:
-            client_manager = proxy_server.client_managers[self.channel_id]
-            local_clients = client_manager.remove_client(self.client_id)
-            total_clients = client_manager.get_total_client_count()
+            # Remove from MAIN ClientManager - this is what triggers handle_client_disconnect
+            # and the zero-clients → stop_channel path, same as TS clients.
+            local_clients = 0
+            total_clients = 0
+            if self.channel_id in proxy_server.client_managers:
+                client_manager = proxy_server.client_managers[self.channel_id]
+                local_clients = client_manager.remove_client(self.client_id)
+                total_clients = client_manager.get_total_client_count()
 
-        logger.info(
-            f"[{self.client_id}] fMP4 client disconnected after {elapsed:.2f}s "
-            f"({self.bytes_sent / 1024:.1f} KB sent, "
-            f"local: {local_clients}, total: {total_clients})"
-        )
+            logger.info(
+                f"[{self.client_id}] fMP4 client disconnected after {elapsed:.2f}s "
+                f"({self.bytes_sent / 1024:.1f} KB sent, "
+                f"local: {local_clients}, total: {total_clients})"
+            )
+        finally:
+            close_old_connections()
diff --git a/apps/proxy/live_proxy/output/ts/generator.py b/apps/proxy/live_proxy/output/ts/generator.py
index 64bb4e1d..88175fcd 100644
--- a/apps/proxy/live_proxy/output/ts/generator.py
+++ b/apps/proxy/live_proxy/output/ts/generator.py
@@ -7,6 +7,7 @@ import time
 import gevent
 from apps.proxy.config import TSConfig as Config
 from apps.channels.models import Channel, Stream
+from django.db import close_old_connections
 from core.utils import log_system_event
 from ...server import ProxyServer
 from ...utils import create_ts_packet, get_logger
@@ -139,12 +140,75 @@ class StreamGenerator:
         finally:
             self._cleanup()
 
+    def _init_wait_abort_reason(self, proxy_server, initialization_start):
+        """Return a reason string when init wait should end early, else None."""
+        from ...services.channel_service import ChannelService
+
+        if ChannelService.is_channel_teardown_active(self.channel_id):
+            return "stopping"
+
+        client_mgr = proxy_server.client_managers.get(self.channel_id)
+        if client_mgr is not None:
+            if self.client_id not in client_mgr.clients:
+                return "client_gone"
+        elif proxy_server.redis_client:
+            client_key = RedisKeys.client_metadata(self.channel_id, self.client_id)
+            if not proxy_server.redis_client.exists(client_key):
+                total = proxy_server.redis_client.scard(RedisKeys.clients(self.channel_id)) or 0
+                if total == 0:
+                    return "client_gone"
+
+        elapsed = time.time() - initialization_start
+        init_grace_period = ConfigHelper.channel_init_grace_period()
+        if elapsed < init_grace_period or not proxy_server.redis_client:
+            return None
+
+        metadata_key = RedisKeys.channel_metadata(self.channel_id)
+        state_raw = proxy_server.redis_client.hget(metadata_key, 'state')
+        if not state_raw:
+            return None
+
+        state = state_raw.decode() if isinstance(state_raw, bytes) else state_raw
+        if state not in ('connecting', 'initializing', 'buffering'):
+            return None
+
+        buffer = proxy_server.stream_buffers.get(self.channel_id)
+        if buffer is not None and buffer.index > 0:
+            return None
+
+        if proxy_server.redis_client.get(RedisKeys.last_data(self.channel_id)):
+            return None
+
+        return "stalled"
+
     def _wait_for_initialization(self):
         initialization_start = time.time()
         max_init_wait = ConfigHelper.client_wait_timeout()
         proxy_server = ProxyServer.get_instance()
 
         while time.time() - initialization_start < max_init_wait:
+            abort_reason = self._init_wait_abort_reason(proxy_server, initialization_start)
+            if abort_reason == "stopping":
+                logger.error(
+                    f"[{self.client_id}] Channel {self.channel_id} teardown active during initialization"
+                )
+                yield create_ts_packet('error', "Error: Channel is stopping")
+                return False
+            if abort_reason == "client_gone":
+                logger.info(
+                    f"[{self.client_id}] Client disconnected during initialization wait, aborting"
+                )
+                yield create_ts_packet('error', "Error: Client disconnected")
+                return False
+            if abort_reason == "stalled":
+                logger.warning(
+                    f"[{self.client_id}] Channel {self.channel_id} stalled in connecting state "
+                    f"with no buffer data after "
+                    f"{ConfigHelper.channel_init_grace_period()}s, aborting init wait"
+                )
+                yield create_ts_packet('error', "Error: Connection stalled")
+                return False
+
             if proxy_server.redis_client:
                 metadata_key = RedisKeys.channel_metadata(self.channel_id)
                 metadata = proxy_server.redis_client.hgetall(metadata_key)
@@ -527,63 +591,63 @@ class StreamGenerator:
 
     def _cleanup(self):
         """Clean up resources and report final statistics."""
-        # Client cleanup
-        elapsed = time.time() - self.stream_start_time
-        local_clients = 0
-        total_clients = 0
-        proxy_server = ProxyServer.get_instance()
+        try:
+            # Client cleanup
+            elapsed = time.time() - self.stream_start_time
+            local_clients = 0
+            total_clients = 0
+            proxy_server = ProxyServer.get_instance()
 
-        # Release M3U profile stream allocation if this is the last client
-        stream_released = False
-        if proxy_server.redis_client:
-            try:
-                metadata_key = RedisKeys.channel_metadata(self.channel_id)
-                metadata = proxy_server.redis_client.hgetall(metadata_key)
-                if metadata:
-                    stream_id_bytes = proxy_server.redis_client.hget(metadata_key, ChannelMetadataField.STREAM_ID)
-                    if stream_id_bytes:
-                        # Check if we're the last client
-                        if self.channel_id in proxy_server.client_managers:
-                            client_count = proxy_server.client_managers[self.channel_id].get_total_client_count()
-                            # Only the last client or owner should release the stream
-                            if client_count <= 1 and proxy_server.am_i_owner(self.channel_id):
+            # Release M3U profile stream allocation if this is the last client
+            stream_released = False
+            if proxy_server.redis_client:
+                try:
+                    if self.channel_id in proxy_server.client_managers:
+                        client_count = proxy_server.client_managers[self.channel_id].get_total_client_count()
+                        # Pool slots are global; the last client on any worker must release.
+                        # During shutdown_delay, keep the slot until coordinated stop runs.
+                        if client_count <= 1 and ConfigHelper.channel_shutdown_delay() <= 0:
+                            try:
                                 try:
-                                    # Try Channel first (normal flow), fall back to Stream (preview flow)
-                                    try:
-                                        obj = Channel.objects.get(uuid=self.channel_id)
-                                    except (Channel.DoesNotExist, Exception):
-                                        obj = Stream.objects.get(stream_hash=self.channel_id)
-                                    stream_released = obj.release_stream()
-                                    if stream_released:
-                                        logger.debug(f"[{self.client_id}] Released stream for channel {self.channel_id}")
-                                    else:
-                                        logger.warning(f"[{self.client_id}] release_stream found no keys for channel {self.channel_id}")
-                                except Exception as e:
-                                    logger.error(f"[{self.client_id}] Error releasing stream for channel {self.channel_id}: {e}")
-            except Exception as e:
-                logger.error(f"[{self.client_id}] Error checking stream data for release: {e}")
+                                    obj = Channel.objects.get(uuid=self.channel_id)
+                                except (Channel.DoesNotExist, Exception):
+                                    obj = Stream.objects.get(stream_hash=self.channel_id)
+                                stream_released = obj.release_stream()
+                                if stream_released:
+                                    logger.debug(f"[{self.client_id}] Released stream for channel {self.channel_id}")
+                                else:
+                                    logger.warning(f"[{self.client_id}] release_stream found no keys for channel {self.channel_id}")
+                            except Exception as e:
+                                logger.error(f"[{self.client_id}] Error releasing stream for channel {self.channel_id}: {e}")
+                except Exception as e:
+                    logger.error(f"[{self.client_id}] Error checking stream data for release: {e}")
 
-        if self.channel_id in proxy_server.client_managers:
-            client_manager = proxy_server.client_managers[self.channel_id]
-            local_clients = client_manager.remove_client(self.client_id)
-            total_clients = client_manager.get_total_client_count()
-            logger.info(f"[{self.client_id}] Disconnected after {elapsed:.2f}s (local: {local_clients}, total: {total_clients})")
+            if self.channel_id in proxy_server.client_managers:
+                client_manager = proxy_server.client_managers[self.channel_id]
+                if self.client_id in client_manager.clients:
+                    local_clients = client_manager.remove_client(self.client_id)
+                else:
+                    local_clients = client_manager.get_client_count()
+                total_clients = client_manager.get_total_client_count()
+                logger.info(f"[{self.client_id}] Disconnected after {elapsed:.2f}s (local: {local_clients}, total: {total_clients})")
 
-            # Log client disconnect event
-            try:
-                log_system_event(
-                    'client_disconnect',
-                    channel_id=self.channel_id,
-                    channel_name=self.channel_name,
-                    client_ip=self.client_ip,
-                    client_id=self.client_id,
-                    user_agent=self.client_user_agent[:100] if self.client_user_agent else None,
-                    duration=round(elapsed, 2),
-                    bytes_sent=self.bytes_sent,
-                    username=self.user.username if self.user else None
-                )
-            except Exception as e:
-                logger.error(f"Could not log client disconnect event: {e}")
+                # Log client disconnect event
+                try:
+                    log_system_event(
+                        'client_disconnect',
+                        channel_id=self.channel_id,
+                        channel_name=self.channel_name,
+                        client_ip=self.client_ip,
+                        client_id=self.client_id,
+                        user_agent=self.client_user_agent[:100] if self.client_user_agent else None,
+                        duration=round(elapsed, 2),
+                        bytes_sent=self.bytes_sent,
+                        username=self.user.username if self.user else None
+                    )
+                except Exception as e:
+                    logger.error(f"Could not log client disconnect event: {e}")
+        finally:
+            close_old_connections()
 
 
 def create_stream_generator(channel_id, client_id, client_ip, client_user_agent, channel_initializing=False, user=None, buffer=None):
diff --git a/apps/proxy/live_proxy/server.py b/apps/proxy/live_proxy/server.py
index 879de2ec..97c5b68b 100644
--- a/apps/proxy/live_proxy/server.py
+++ b/apps/proxy/live_proxy/server.py
@@ -71,6 +71,10 @@ class ProxyServer:
         self.profile_buffers = {}   # {channel_id: {profile_id: StreamBuffer}}
         self._channel_names = {}
         self._stopping_channels = set()  # channels with an active stop_channel call in progress
+        self._stopping_since = {}  # channel_id -> time.time() when stop_channel began
+        self._local_stop_locks = {}
+        # Managers kept until the stream OS thread exits (may outlive stream_managers dict)
+        self._live_stream_managers = {}
 
         # Generate a unique worker ID
         pid = os.getpid()
@@ -138,6 +142,18 @@ class ProxyServer:
             logger.error(f"Redis command error: {e}")
             return None
 
+    def _spawn_on_hub(self, fn, *args, **kwargs):
+        """Schedule fn on the gevent hub from any thread without blocking the caller."""
+        import gevent
+
+        try:
+            hub = gevent.get_hub()
+            hub.loop.run_callback_threadsafe(
+                lambda: gevent.spawn(fn, *args, **kwargs)
+            )
+        except Exception as e:
+            logger.error(f"Failed to schedule {getattr(fn, '__name__', fn)} on hub: {e}")
+
     def _start_event_listener(self):
         """Listen for events from other workers"""
         if not self.redis_client:
@@ -294,22 +310,36 @@ class ProxyServer:
                                                     json.dumps(switch_result)
                                                 )
                                     elif event_type == EventType.CHANNEL_STOP:
-                                        logger.info(f"Received {EventType.CHANNEL_STOP} event for channel {channel_id}")
-                                        # First mark channel as stopping in Redis
-                                        if self.redis_client:
-                                            # Set stopping state in metadata
-                                            metadata_key = RedisKeys.channel_metadata(channel_id)
-                                            if self.redis_client.exists(metadata_key):
-                                                self.redis_client.hset(metadata_key, mapping={
-                                                    "state": ChannelState.STOPPING,
-                                                    "state_changed_at": str(time.time())
-                                                })
+                                        requester_worker_id = data.get("requester_worker_id")
+                                        logger.info(
+                                            f"Received {EventType.CHANNEL_STOP} event for channel {channel_id} "
+                                            f"from worker {requester_worker_id}"
+                                        )
 
-                                        # If we have local resources for this channel, clean them up
-                                        if channel_id in self.stream_buffers or channel_id in self.client_managers:
-                                            # Use existing stop_channel method
-                                            logger.info(f"Stopping local resources for channel {channel_id}")
+                                        # Initiating worker already runs local stop_channel()
+                                        if requester_worker_id and requester_worker_id == self.worker_id:
+                                            logger.debug(
+                                                f"Ignoring {EventType.CHANNEL_STOP} for {channel_id}; "
+                                                f"this worker initiated teardown"
+                                            )
+                                        elif (
+                                            channel_id in self.stream_managers
+                                            or channel_id in self._live_stream_managers
+                                        ):
+                                            logger.info(
+                                                f"Owner worker stopping local upstream for channel {channel_id}"
+                                            )
                                             self.stop_channel(channel_id)
+                                        elif (
+                                            channel_id in self.stream_buffers
+                                            or channel_id in self.client_managers
+                                            or channel_id in self.profile_managers
+                                            or channel_id in self.output_managers
+                                        ):
+                                            logger.info(
+                                                f"Non-owner worker cleaning local resources for channel {channel_id}"
+                                            )
+                                            self._cleanup_local_resources(channel_id)
 
                                         # Acknowledge stop by publishing a response
                                         stop_response = {
@@ -490,8 +520,16 @@ class ProxyServer:
             current = self.redis_client.get(lock_key)
 
             if current is None:
-                # Key expired — re-acquire if we have the stream_manager
-                if channel_id in self.stream_managers:
+                # Key expired, re-acquire if we still run local upstream, but never
+                # during coordinated teardown (multi-worker reconnect-during-stop race).
+                if channel_id in self.stream_managers or channel_id in self._live_stream_managers:
+                    if self._channel_unavailable_for_new_clients(channel_id):
+                        logger.info(
+                            f"Refusing ownership re-acquisition for {channel_id}; "
+                            f"teardown or pending shutdown active"
+                        )
+                        return False
+
                     acquired = self.redis_client.set(lock_key, self.worker_id, nx=True, ex=ttl)
                     if acquired:
                         logger.warning(f"Re-acquired expired ownership for channel {channel_id}")
@@ -514,6 +552,19 @@ class ProxyServer:
     def initialize_channel(self, url, channel_id, user_agent=None, transcode=False, stream_id=None):
         """Initialize a channel without redundant active key"""
         try:
+            if self._channel_unavailable_for_new_clients(channel_id):
+                logger.warning(
+                    f"Refusing to initialize channel {channel_id}; "
+                    f"teardown or pending shutdown active"
+                )
+                return False
+
+            if self._has_local_upstream_activity(channel_id):
+                logger.warning(
+                    f"Stopping lingering local upstream before initializing channel {channel_id}"
+                )
+                self._stop_local_stream_activity(channel_id)
+
             if self.redis_client:
                 metadata_key = RedisKeys.channel_metadata(channel_id)
                 if self.redis_client.exists(metadata_key):
@@ -709,6 +760,7 @@ class ProxyServer:
                 )
             except Exception as e:
                 logger.error(f"Could not log channel start event: {e}")
+                close_old_connections()
 
             # Create client manager with channel_id, redis_client AND worker_id (only if not already exists)
             if channel_id not in self.client_managers:
@@ -720,6 +772,7 @@ class ProxyServer:
                 self.client_managers[channel_id] = client_manager
 
             # Start stream manager thread only for the owner
+            self._live_stream_managers[channel_id] = stream_manager
             thread = threading.Thread(target=stream_manager.run, daemon=True)
             thread.name = f"stream-{channel_id}"
             thread.start()
@@ -736,7 +789,7 @@ class ProxyServer:
                 attempt_key = RedisKeys.connection_attempt(channel_id)
                 self.redis_client.setex(attempt_key, 60, str(time.time()))
 
-                logger.info(f"Channel {channel_id} in {ChannelState.CONNECTING} state - will start grace period after connection")
+                logger.info(f"Channel {channel_id} in {ChannelState.CONNECTING} state - waiting for buffer to fill")
             return True
 
         except Exception as e:
@@ -846,31 +899,107 @@ class ProxyServer:
                 owner = metadata.get('owner', 'unknown')
                 logger.info(f"Zombie channel details - state: {state}, owner: {owner}")
 
-            # Clean up Redis keys
             self._clean_redis_keys(channel_id)
-
-            # Force release resources in the Channel model
-            try:
-                channel = Channel.objects.get(uuid=channel_id)
-                if not channel.release_stream():
-                    logger.warning(f"Failed to release stream for zombie channel {channel_id}")
-                else:
-                    logger.info(f"Released stream allocation for zombie channel {channel_id}")
-            except Exception as e:
-                try:
-                    stream = Stream.objects.get(stream_hash=channel_id)
-                    if not stream.release_stream():
-                        logger.warning(f"Failed to release stream for zombie channel {channel_id}")
-                    else:
-                        logger.info(f"Released stream allocation for zombie channel {channel_id}")
-                except Exception as e:
-                    logger.error(f"Error releasing stream for zombie channel {channel_id}: {e}")
-
             return True
         except Exception as e:
             logger.error(f"Error cleaning zombie channel {channel_id}: {e}", exc_info=True)
             return False
 
+    @staticmethod
+    def _shutdown_disconnect_ttl():
+        delay = ConfigHelper.channel_shutdown_delay()
+        return max(int(delay * 2), 60)
+
+    @staticmethod
+    def _pre_active_no_clients_should_stop(connection_ready_time, start_time, now=None):
+        """
+        Decide whether a pre-active channel with zero clients should be stopped.
+
+        Returns (should_stop, timeout_seconds, reason) where reason is
+        'client_wait' (buffer ready, waiting for first viewer) or 'startup'
+        (still connecting / filling buffer).
+        """
+        now = now if now is not None else time.time()
+        if connection_ready_time:
+            elapsed = now - connection_ready_time
+            timeout = ConfigHelper.channel_client_wait_period()
+            return elapsed > timeout, timeout, "client_wait"
+        if start_time:
+            elapsed = now - start_time
+            timeout = ConfigHelper.channel_init_grace_period()
+            return elapsed > timeout, timeout, "startup"
+        return False, None, None
+
+    def _wait_for_shutdown_delay(self, channel_id):
+        """
+        Wait until shutdown_delay has elapsed since the Redis disconnect
+        timestamp. Returns False if clients reconnect or the timer is cancelled.
+        Uses Redis state so concurrent disconnect handlers and multi-worker
+        reconnects always honour the latest last-client disconnect time.
+        """
+        if not self.redis_client:
+            return True
+
+        shutdown_delay = ConfigHelper.channel_shutdown_delay()
+        if shutdown_delay <= 0:
+            return True
+
+        disconnect_key = RedisKeys.last_client_disconnect(channel_id)
+        client_set_key = RedisKeys.clients(channel_id)
+        poll_interval = 1.0
+
+        logger.info(
+            f"Waiting up to {shutdown_delay}s before stopping channel {channel_id}..."
+        )
+
+        while True:
+            total = self.redis_client.scard(client_set_key) or 0
+            if total > 0:
+                logger.info(
+                    f"New clients connected during shutdown delay for "
+                    f"{channel_id} - aborting shutdown"
+                )
+                self.redis_client.delete(disconnect_key)
+                return False
+
+            disconnect_value = self.redis_client.get(disconnect_key)
+            if not disconnect_value:
+                logger.info(
+                    f"Shutdown delay cancelled for {channel_id} - aborting shutdown"
+                )
+                return False
+
+            try:
+                if isinstance(disconnect_value, bytes):
+                    disconnect_value = disconnect_value.decode()
+                disconnect_time = float(disconnect_value)
+            except (ValueError, TypeError):
+                logger.warning(
+                    f"Invalid disconnect timestamp for {channel_id}, aborting wait"
+                )
+                return False
+
+            elapsed = time.time() - disconnect_time
+            if elapsed >= shutdown_delay:
+                total = self.redis_client.scard(client_set_key) or 0
+                if total > 0:
+                    logger.info(
+                        f"Clients connected at end of shutdown delay for "
+                        f"{channel_id} - aborting shutdown"
+                    )
+                    self.redis_client.delete(disconnect_key)
+                    return False
+                return True
+
+            elapsed_display = max(0.0, elapsed)
+            remaining = max(0.0, shutdown_delay - elapsed)
+            logger.debug(
+                f"Channel {channel_id[:8]} shutdown timer: "
+                f"{elapsed_display:.1f}s of {shutdown_delay}s elapsed "
+                f"({remaining:.1f}s remaining)"
+            )
+            gevent.sleep(min(poll_interval, remaining))
+
     def handle_client_disconnect(self, channel_id):
         """
         Handle client disconnect event - check if channel should shut down and
@@ -881,8 +1010,10 @@ class ProxyServer:
         # to manage for this channel at all.
         if (channel_id not in self.client_managers
                 and channel_id not in self.stream_managers
+                and channel_id not in self._live_stream_managers
                 and channel_id not in self.profile_managers
-                and channel_id not in self.output_managers):
+                and channel_id not in self.output_managers
+                and not self._has_local_upstream_activity(channel_id)):
             return
 
         try:
@@ -954,25 +1085,58 @@ class ProxyServer:
 
             if total == 0:
                 logger.debug(f"No clients left after disconnect event - stopping channel {channel_id}")
-                disconnect_key = RedisKeys.last_client_disconnect(channel_id)
-                self.redis_client.setex(disconnect_key, 60, str(time.time()))
 
                 shutdown_delay = ConfigHelper.channel_shutdown_delay()
+                disconnect_key = RedisKeys.last_client_disconnect(channel_id)
 
                 if shutdown_delay > 0:
-                    logger.info(f"Waiting {shutdown_delay}s before stopping channel...")
-                    gevent.sleep(shutdown_delay)
-
-                    total = self.redis_client.scard(client_set_key) or 0
-                    if total > 0:
-                        logger.info(f"New clients connected during shutdown delay - aborting shutdown")
-                        self.redis_client.delete(disconnect_key)
+                    if not self.redis_client.get(disconnect_key):
+                        self.redis_client.setex(
+                            disconnect_key,
+                            self._shutdown_disconnect_ttl(),
+                            str(time.time()),
+                        )
+                    if not self._wait_for_shutdown_delay(channel_id):
                         return
+                else:
+                    self.redis_client.setex(
+                        disconnect_key,
+                        self._shutdown_disconnect_ttl(),
+                        str(time.time()),
+                    )
 
-                self.stop_channel(channel_id)
+                # Coordinated stop runs local teardown + Redis cleanup once.
+                # Do not call _stop_upstream_before_redis_cleanup here — it races
+                # with stop_channel and can leave stop_channel blocked on stderr join
+                # before _clean_redis_keys ever runs (orphaned buffer:index keys).
+                self._coordinated_stop_channel(channel_id)
         except Exception as e:
             logger.error(f"Error handling client disconnect for channel {channel_id}: {e}")
 
+    def _channel_unavailable_for_new_clients(self, channel_id):
+        """True when new clients or ownership re-acquisition should be refused."""
+        from .services.channel_service import ChannelService
+        return ChannelService.is_channel_unavailable_for_new_clients(channel_id)
+
+    def _channel_teardown_active(self, channel_id):
+        """True when a coordinated stop is in progress (Redis-visible to all workers)."""
+        from .services.channel_service import ChannelService
+        return ChannelService.is_channel_teardown_active(channel_id)
+
+    def _coordinated_stop_channel(self, channel_id):
+        """Stop a channel with Redis markers and pubsub visible to all uWSGI workers."""
+        from .services.channel_service import ChannelService
+        return ChannelService.stop_channel(channel_id)
+
+    def _force_clear_channel_clients(self, channel_id):
+        """Remove all client entries from Redis for a wedged channel."""
+        if not self.redis_client:
+            return 0
+        removed = ClientManager.clear_all_clients(self.redis_client, channel_id)
+        if removed:
+            logger.warning(f"Force-cleared {removed} client(s) from channel {channel_id}")
+        return removed
+
     # ------------------------------------------------------------------
     # Output format lifecycle
     # ------------------------------------------------------------------
@@ -1266,150 +1430,270 @@ class ProxyServer:
         for pid in list(self.profile_managers.get(channel_id, {}).keys()):
             self.stop_output_profile(channel_id, pid)
 
+    def _collect_channel_stop_event_data(self, channel_id):
+        """Snapshot metadata for channel_stop logging before Redis keys are deleted."""
+        channel_name = self._channel_names.pop(channel_id, None) or str(channel_id)
+        runtime = None
+        total_bytes = None
+        if self.redis_client:
+            metadata_key = RedisKeys.channel_metadata(channel_id)
+            metadata = self.redis_client.hgetall(metadata_key)
+            if metadata:
+                if 'init_time' in metadata:
+                    try:
+                        init_time = float(metadata['init_time'])
+                        runtime = round(time.time() - init_time, 2)
+                    except Exception:
+                        pass
+                if 'total_bytes' in metadata:
+                    try:
+                        total_bytes = int(metadata['total_bytes'])
+                    except Exception:
+                        pass
+        return {
+            'channel_id': channel_id,
+            'channel_name': channel_name,
+            'runtime': runtime,
+            'total_bytes': total_bytes,
+        }
+
+    def _spawn_channel_stop_event(self, stop_event_data):
+        """Log channel_stop without blocking teardown (DB/connect dispatch can hang)."""
+        if not stop_event_data:
+            return
+
+        def _log_stop():
+            log_system_event('channel_stop', **stop_event_data)
+
+        gevent.spawn(_log_stop)
+
+    def _get_stream_thread(self, channel_id):
+        thread_name = f"stream-{channel_id}"
+        for thread in threading.enumerate():
+            if thread.name == thread_name:
+                return thread
+        return None
+
+    def _has_local_upstream_activity(self, channel_id):
+        """True when this worker runs a local ffmpeg / stream-{uuid} OS thread."""
+        if channel_id in self.stream_managers:
+            return True
+        if channel_id in self._live_stream_managers:
+            return True
+        thread = self._get_stream_thread(channel_id)
+        return thread is not None and thread.is_alive()
+
+    def _broadcast_upstream_stop(self, channel_id):
+        """Ask every uWSGI worker to stop local ffmpeg for this channel."""
+        from .services.channel_service import ChannelService
+
+        if not self.redis_client:
+            return
+        try:
+            ChannelService.mark_channel_stopping(channel_id, broadcast=True)
+            logger.info(
+                f"Broadcast upstream stop for channel {channel_id} to all workers"
+            )
+        except Exception as e:
+            logger.error(
+                f"Error broadcasting upstream stop for channel {channel_id}: {e}"
+            )
+
+    @staticmethod
+    def _channel_id_from_metadata_key(key):
+        if isinstance(key, bytes):
+            key = key.decode('utf-8', errors='replace')
+        parts = key.split(':')
+        if len(parts) >= 3:
+            return parts[2]
+        return None
+
+    def _stop_upstream_before_redis_cleanup(self, channel_id):
+        """Stop local ffmpeg before deleting Redis keys (prevents delete/recreate loops)."""
+        if self._has_local_upstream_activity(channel_id):
+            logger.info(
+                f"Channel {channel_id} has local upstream activity - stopping processes"
+            )
+            self._stop_local_stream_activity(channel_id)
+            return
+        self._broadcast_upstream_stop(channel_id)
+
+    def _join_stream_thread(self, channel_id, timeout=2.0):
+        thread = self._get_stream_thread(channel_id)
+        if thread and thread.is_alive():
+            logger.info(f"Waiting for stream thread to terminate for channel {channel_id}")
+            try:
+                thread.join(timeout=timeout)
+                if thread.is_alive():
+                    logger.warning(
+                        f"Stream thread for channel {channel_id} did not terminate within {timeout}s"
+                    )
+            except RuntimeError:
+                logger.debug(f"Could not join stream thread for channel {channel_id}")
+
+    def _resolve_stream_manager(self, channel_id):
+        manager = self.stream_managers.pop(channel_id, None)
+        if manager is None:
+            manager = self._live_stream_managers.pop(channel_id, None)
+        return manager
+
+    def _signal_upstream_shutdown(self, channel_id):
+        """Halt upstream Redis writes immediately without blocking on ffmpeg join."""
+        if channel_id in self.stream_buffers:
+            self.stream_buffers[channel_id].stopping = True
+        for registry in (self.stream_managers, self._live_stream_managers):
+            manager = registry.get(channel_id)
+            if manager is None:
+                continue
+            manager.stopping = True
+            manager.stop_requested = True
+            if getattr(manager, 'buffer', None) is not None:
+                manager.buffer.stopping = True
+
+    def _get_local_stop_lock(self, channel_id):
+        lock = self._local_stop_locks.get(channel_id)
+        if lock is None:
+            lock = threading.Lock()
+            self._local_stop_locks[channel_id] = lock
+        return lock
+
+    def _stop_local_stream_activity(self, channel_id):
+        """Stop local ffmpeg/stream threads regardless of registry state."""
+        lock = self._get_local_stop_lock(channel_id)
+        if not lock.acquire(blocking=False):
+            logger.debug(
+                f"Local stop already in progress for channel {channel_id}, skipping duplicate"
+            )
+            return
+        try:
+            self._stop_local_stream_activity_locked(channel_id)
+        finally:
+            lock.release()
+            self._local_stop_locks.pop(channel_id, None)
+
+    def _stop_local_stream_activity_locked(self, channel_id):
+        stream_manager = self._resolve_stream_manager(channel_id)
+        if stream_manager is not None:
+            if hasattr(stream_manager, 'stop'):
+                try:
+                    stream_manager.stop()
+                except Exception as e:
+                    logger.error(f"Error stopping stream manager for channel {channel_id}: {e}")
+            logger.info(f"Stopped stream manager for channel {channel_id}")
+        elif self._get_stream_thread(channel_id):
+            logger.warning(
+                f"Found live stream thread for channel {channel_id} without a manager reference"
+            )
+            if channel_id in self.stream_buffers:
+                self.stream_buffers[channel_id].stopping = True
+
+        self._join_stream_thread(channel_id)
+
+        if channel_id in self.stream_buffers:
+            buffer = self.stream_buffers.pop(channel_id)
+            if hasattr(buffer, 'stop'):
+                try:
+                    buffer.stop()
+                except Exception as e:
+                    logger.error(f"Error stopping buffer for channel {channel_id}: {e}")
+            logger.info(f"Removed stream buffer for channel {channel_id}")
+
+        if channel_id in self.client_managers:
+            try:
+                client_manager = self.client_managers.pop(channel_id)
+                if hasattr(client_manager, 'stop'):
+                    client_manager.stop()
+                logger.info(f"Removed client manager for channel {channel_id}")
+            except KeyError:
+                logger.debug(f"Client manager for channel {channel_id} already removed")
+
+        self.stop_all_output_formats(channel_id)
+        self.stop_all_output_profiles(channel_id)
+        self.profile_managers.pop(channel_id, None)
+        self.profile_buffers.pop(channel_id, None)
+        self._live_stream_managers.pop(channel_id, None)
+
+    def _recover_stuck_channel_stops(self):
+        """Force cleanup when stop_channel never finishes (e.g. blocked on logging)."""
+        if not self._stopping_channels:
+            return
+
+        now = time.time()
+        stuck_threshold = max(10, ConfigHelper.channel_shutdown_delay() * 2)
+
+        for channel_id in list(self._stopping_channels):
+            started = self._stopping_since.get(channel_id, now)
+            if now - started < stuck_threshold:
+                continue
+
+            logger.error(
+                f"Channel {channel_id} stop_channel stuck for {now - started:.0f}s "
+                f"- forcing local and Redis cleanup"
+            )
+            self._stopping_channels.discard(channel_id)
+            self._stopping_since.pop(channel_id, None)
+
+            try:
+                self._stop_local_stream_activity(channel_id)
+                self._clean_redis_keys(channel_id)
+            except Exception as e:
+                logger.error(f"Error during forced cleanup for channel {channel_id}: {e}")
+
     def stop_channel(self, channel_id):
         """Stop a channel with proper ownership handling"""
         if channel_id in self._stopping_channels:
             logger.debug(f"stop_channel already in progress for {channel_id}, ignoring duplicate call")
             return
         self._stopping_channels.add(channel_id)
+        self._stopping_since[channel_id] = time.time()
+        stop_event_data = None
+        redis_cleaned = False
         try:
             logger.info(f"Stopping channel {channel_id}")
 
-            # First set a stopping key that clients will check
             if self.redis_client:
                 stop_key = RedisKeys.channel_stopping(channel_id)
-                self.redis_client.setex(stop_key, 10, "true")
+                if self.redis_client.exists(stop_key):
+                    self.redis_client.expire(stop_key, 60)
+                else:
+                    self.redis_client.setex(stop_key, 60, "true")
 
-            # Only stop the actual stream manager if we're the owner
-            if self.am_i_owner(channel_id):
-                logger.info(f"This worker ({self.worker_id}) is the owner - closing provider connection")
-                if channel_id in self.stream_managers:
-                    stream_manager = self.stream_managers[channel_id]
+            was_owner = self.am_i_owner(channel_id)
+            if was_owner:
+                logger.info(
+                    f"This worker ({self.worker_id}) is the owner - closing provider connection"
+                )
+                stop_event_data = self._collect_channel_stop_event_data(channel_id)
 
-                    # Signal thread to stop and close resources
-                    if hasattr(stream_manager, 'stop'):
-                        stream_manager.stop()
-                    else:
-                        stream_manager.running = False
-                        if hasattr(stream_manager, '_close_socket'):
-                            stream_manager._close_socket()
+            # Stop new chunk writes before Redis cleanup; do not block on ffmpeg join yet.
+            self._signal_upstream_shutdown(channel_id)
 
-                # Wait for stream thread to finish
-                stream_thread_name = f"stream-{channel_id}"
-                stream_thread = None
+            # Release profile slots and delete Redis keys before any blocking local stop.
+            # A concurrent disconnect + cleanup-thread stop used to wedge here behind a
+            # 2s stderr join, never reaching scan/delete (bare buffer:index with TTL -1).
+            self._clean_redis_keys(channel_id)
+            redis_cleaned = True
 
-                for thread in threading.enumerate():
-                    if thread.name == stream_thread_name:
-                        stream_thread = thread
-                        break
-
-                if stream_thread and stream_thread.is_alive():
-                    logger.info(f"Waiting for stream thread to terminate")
-                    try:
-                        # Very short timeout to prevent hanging the app
-                        stream_thread.join(timeout=2.0)
-                        if stream_thread.is_alive():
-                            logger.warning(f"Stream thread did not terminate within timeout")
-                    except RuntimeError:
-                        logger.debug(f"Could not join stream thread (may be current thread)")
-
-                # Stop all output format managers before releasing ownership
-                self.stop_all_output_formats(channel_id)
-
-                # Stop all output profile transcodes before releasing ownership
-                self.stop_all_output_profiles(channel_id)
-
-                # Release ownership
+            if was_owner:
                 self.release_ownership(channel_id)
 
-                # Log channel stop event (after cleanup, before releasing ownership section ends)
-                try:
-                    channel_name = self._channel_names.pop(channel_id, None) or str(channel_id)
-
-                    # Calculate runtime and get total bytes from metadata
-                    runtime = None
-                    total_bytes = None
-                    if self.redis_client:
-                        metadata_key = RedisKeys.channel_metadata(channel_id)
-                        metadata = self.redis_client.hgetall(metadata_key)
-                        if metadata:
-                            # Calculate runtime from init_time
-                            if 'init_time' in metadata:
-                                try:
-                                    init_time = float(metadata['init_time'])
-                                    runtime = round(time.time() - init_time, 2)
-                                except Exception:
-                                    pass
-                            # Get total bytes transferred
-                            if 'total_bytes' in metadata:
-                                try:
-                                    total_bytes = int(metadata['total_bytes'])
-                                except Exception:
-                                    pass
-
-                    log_system_event(
-                        'channel_stop',
-                        channel_id=channel_id,
-                        channel_name=channel_name,
-                        runtime=runtime,
-                        total_bytes=total_bytes
-                    )
-                except Exception as e:
-                    logger.error(f"Could not log channel stop event: {e}")
-
-            # Always clean up local resources - WITH SAFE CHECKS
-            if channel_id in self.stream_managers:
-                del self.stream_managers[channel_id]
-                logger.info(f"Removed stream manager for channel {channel_id}")
-
-            # Stop buffer and ensure all its timers are cancelled - SAFE CHECK HERE
-            if channel_id in self.stream_buffers:
-                buffer = self.stream_buffers[channel_id]
-                # Call stop on buffer to properly shut it down
-                if hasattr(buffer, 'stop'):
-                    try:
-                        buffer.stop()
-                        logger.debug(f"Buffer for channel {channel_id} properly stopped")
-                    except Exception as e:
-                        logger.error(f"Error stopping buffer: {e}")
-
-                # Save reference and check again before deleting
-                try:
-                    if channel_id in self.stream_buffers:  # Check again to prevent race conditions
-                        del self.stream_buffers[channel_id]
-                        logger.info(f"Removed stream buffer for channel {channel_id}")
-                except KeyError:
-                    logger.debug(f"Buffer for channel {channel_id} already removed")
-
-            # Clean up client manager - SAFE CHECK HERE TOO
-            if channel_id in self.client_managers:
-                try:
-                    client_manager = self.client_managers[channel_id]
-                    # Stop the heartbeat thread before deleting
-                    if hasattr(client_manager, 'stop'):
-                        client_manager.stop()
-                    del self.client_managers[channel_id]
-                    logger.info(f"Removed client manager for channel {channel_id}")
-                except KeyError:
-                    logger.debug(f"Client manager for channel {channel_id} already removed")
-
-            # Clean up profile managers and buffers. Owner workers clean profile_managers
-            # (and their profile_buffers) via stop_all_output_profiles above. Non-owner
-            # workers only populate profile_buffers (not profile_managers), and that block
-            # is skipped for them, so we always clean both here to avoid stale entries on
-            # the next connect.
-            self.profile_managers.pop(channel_id, None)
-            self.profile_buffers.pop(channel_id, None)
-
-            # Clean up Redis keys
-            self._clean_redis_keys(channel_id)
+            self._stop_local_stream_activity(channel_id)
+            self._spawn_channel_stop_event(stop_event_data)
 
             return True
         except Exception as e:
             logger.error(f"Error stopping channel {channel_id}: {e}")
             return False
         finally:
+            if not redis_cleaned:
+                try:
+                    self._clean_redis_keys(channel_id)
+                except Exception as e:
+                    logger.error(
+                        f"Error cleaning Redis keys for channel {channel_id} during finally: {e}"
+                    )
             self._stopping_channels.discard(channel_id)
+            self._stopping_since.pop(channel_id, None)
 
     def check_inactive_channels(self):
         """Check for inactive channels (no clients) and stop them"""
@@ -1421,7 +1705,7 @@ class ProxyServer:
 
         for channel_id in channels_to_stop:
             logger.info(f"Auto-stopping inactive channel {channel_id}")
-            self.stop_channel(channel_id)
+            self._coordinated_stop_channel(channel_id)
 
     def _cleanup_channel(self, channel_id: str) -> None:
         """Remove channel resources"""
@@ -1432,7 +1716,7 @@ class ProxyServer:
     def shutdown(self) -> None:
         """Stop all channels and cleanup"""
         for channel_id in list(self.stream_managers.keys()):
-            self.stop_channel(channel_id)
+            self._coordinated_stop_channel(channel_id)
 
     def _start_cleanup_thread(self):
         """Start background thread to maintain ownership and clean up resources"""
@@ -1450,8 +1734,15 @@ class ProxyServer:
                     # Refresh channel registry
                     self.refresh_channel_registry()
 
+                    # Recover channels whose stop_channel call never returned
+                    self._recover_stuck_channel_stops()
+
                     # Create a unified list of all channels we have locally
-                    all_local_channels = set(self.stream_managers.keys()) | set(self.client_managers.keys())
+                    all_local_channels = (
+                        set(self.stream_managers.keys())
+                        | set(self.client_managers.keys())
+                        | set(self._live_stream_managers.keys())
+                    )
 
                     # Single loop through all channels - process each exactly once
                     for channel_id in list(all_local_channels):
@@ -1487,7 +1778,7 @@ class ProxyServer:
                             if time.time() % 30 < 1:  # Every ~30 seconds
                                 logger.info(f"Channel {channel_id} has {total_clients} clients, state: {channel_state}")
 
-                            # If in connecting or waiting_for_clients state, check grace period
+                            # Pre-active channels: init timeouts and buffer-ready promotion
                             if channel_state in [ChannelState.INITIALIZING, ChannelState.CONNECTING, ChannelState.WAITING_FOR_CLIENTS]:
                                 # Check if channel is already stopping
                                 if self.redis_client:
@@ -1528,52 +1819,34 @@ class ProxyServer:
                                     start_time = connection_attempt_time or init_time
 
                                     if start_time:
-                                        # Check which timeout to apply based on channel lifecycle
-                                        if connection_ready_time:
-                                            # Already reached ready - use shutdown_delay
-                                            time_since_ready = time.time() - connection_ready_time
-                                            shutdown_delay = ConfigHelper.channel_shutdown_delay()
-
-                                            if time_since_ready > shutdown_delay:
+                                        should_stop, timeout, reason = (
+                                            self._pre_active_no_clients_should_stop(
+                                                connection_ready_time,
+                                                start_time,
+                                            )
+                                        )
+                                        if should_stop:
+                                            if reason == "client_wait":
+                                                time_since_ready = time.time() - connection_ready_time
                                                 logger.warning(
                                                     f"Channel {channel_id} in {channel_state} state with 0 clients for {time_since_ready:.1f}s "
-                                                    f"(after reaching ready, shutdown_delay: {shutdown_delay}s) - stopping channel"
+                                                    f"(buffer ready, no client connected, client_wait_period: {timeout}s) - stopping channel"
                                                 )
-                                                self.stop_channel(channel_id)
-                                                continue
-                                        else:
-                                            # Never reached ready - use grace_period timeout
-                                            time_since_start = time.time() - start_time
-                                            connecting_timeout = ConfigHelper.channel_init_grace_period()
-
-                                            if time_since_start > connecting_timeout:
+                                            else:
+                                                time_since_start = time.time() - start_time
                                                 logger.warning(
                                                     f"Channel {channel_id} stuck in {channel_state} state for {time_since_start:.1f}s "
-                                                    f"with no clients (timeout: {connecting_timeout}s) - stopping channel due to upstream issues"
+                                                    f"with no clients (timeout: {timeout}s) - stopping channel due to upstream issues"
                                                 )
-                                                self.stop_channel(channel_id)
-                                                continue
-                                elif connection_ready_time:
-                                    # We have clients now, but check grace period for state transition
-                                    grace_period = ConfigHelper.channel_init_grace_period()
-                                    time_since_ready = time.time() - connection_ready_time
+                                            self._coordinated_stop_channel(channel_id)
+                                            continue
+                                elif (
+                                    channel_state == ChannelState.WAITING_FOR_CLIENTS
+                                    and total_clients > 0
+                                ):
+                                    from .services.channel_service import ChannelService
 
-                                    logger.debug(f"GRACE PERIOD CHECK: Channel {channel_id} in {channel_state} state, "
-                                                 f"time_since_ready={time_since_ready:.1f}s, grace_period={grace_period}s, "
-                                                 f"total_clients={total_clients}")
-
-                                    if time_since_ready <= grace_period:
-                                        # Still within grace period
-                                        logger.debug(f"Channel {channel_id} in grace period - {time_since_ready:.1f}s of {grace_period}s elapsed")
-                                        continue
-                                    else:
-                                        # Grace period expired with clients - mark channel as active
-                                        logger.info(f"Grace period expired with {total_clients} clients - marking channel {channel_id} as active")
-                                        if self.update_channel_state(channel_id, ChannelState.ACTIVE, {
-                                            "grace_period_ended_at": str(time.time()),
-                                            "clients_at_activation": str(total_clients)
-                                        }):
-                                            logger.info(f"Channel {channel_id} activated with {total_clients} clients after grace period")
+                                    ChannelService.promote_channel_when_buffer_ready(channel_id)
                             # If active and no clients, start normal shutdown procedure
                             elif channel_state not in [ChannelState.CONNECTING, ChannelState.WAITING_FOR_CLIENTS] and total_clients == 0:
                                 # Check if channel is already stopping
@@ -1600,12 +1873,16 @@ class ProxyServer:
                                 if not disconnect_time:
                                     # First time seeing zero clients, set timestamp
                                     if self.redis_client:
-                                        self.redis_client.setex(disconnect_key, 60, str(current_time))
+                                        self.redis_client.setex(
+                                            disconnect_key,
+                                            self._shutdown_disconnect_ttl(),
+                                            str(current_time),
+                                        )
                                     logger.warning(f"No clients detected for channel {channel_id}, starting shutdown timer")
                                 elif current_time - disconnect_time > ConfigHelper.channel_shutdown_delay():
                                     # We've had no clients for the shutdown delay period
                                     logger.warning(f"No clients for {current_time - disconnect_time:.1f}s, stopping channel {channel_id}")
-                                    self.stop_channel(channel_id)
+                                    self._coordinated_stop_channel(channel_id)
                                 else:
                                     # Still in shutdown delay period
                                     logger.debug(f"Channel {channel_id} shutdown timer: "
@@ -1614,17 +1891,29 @@ class ProxyServer:
                             else:
                                 # There are clients or we're still connecting - clear any disconnect timestamp
                                 if self.redis_client:
-                                    self.redis_client.delete(f"live:channel:{channel_id}:last_client_disconnect_time")
+                                    self.redis_client.delete(
+                                        RedisKeys.last_client_disconnect(channel_id)
+                                    )
 
                         else:
                             # === NON-OWNER CHANNEL HANDLING ===
                             # Safety: if we have a stream_manager, we ARE the real owner
                             # but the Redis key may have expired. Try to re-acquire.
-                            if channel_id in self.stream_managers:
+                            if (channel_id in self.stream_managers
+                                    or channel_id in self._live_stream_managers):
                                 # Ownership was explicitly released by an active stop_channel call -
                                 # don't fight the shutdown by trying to re-acquire.
                                 if channel_id in self._stopping_channels:
                                     continue
+
+                                if self._channel_unavailable_for_new_clients(channel_id):
+                                    logger.info(
+                                        f"Channel {channel_id} teardown active with local stream_manager; "
+                                        f"finishing stop instead of re-acquiring ownership"
+                                    )
+                                    self.stop_channel(channel_id)
+                                    continue
+
                                 logger.warning(
                                     f"Ownership gap for {channel_id}: this worker has stream_manager "
                                     f"but am_i_owner returned False. Attempting re-acquisition."
@@ -1760,7 +2049,9 @@ class ProxyServer:
 
             for key in channel_keys:
                 try:
-                    channel_id = key.split(':')[2]
+                    channel_id = self._channel_id_from_metadata_key(key)
+                    if not channel_id:
+                        continue
 
                     # Check if this channel has an owner
                     owner = self.get_channel_owner(channel_id)
@@ -1777,13 +2068,8 @@ class ProxyServer:
                             # Orphaned channel with no clients - clean it up
                             logger.info(f"Cleaning up orphaned channel {channel_id}")
 
-                            # If we have it locally, stop it properly to clean up processes
-                            if channel_id in self.stream_managers or channel_id in self.client_managers:
-                                logger.info(f"Orphaned channel {channel_id} is local - calling stop_channel")
-                                self.stop_channel(channel_id)
-                            else:
-                                # Just clean up Redis keys for remote channels
-                                self._clean_redis_keys(channel_id)
+                            self._stop_upstream_before_redis_cleanup(channel_id)
+                            self._clean_redis_keys(channel_id)
                 except Exception as e:
                     logger.error(f"Error processing channel key {key}: {e}")
 
@@ -1805,18 +2091,17 @@ class ProxyServer:
 
             for key in channel_keys:
                 try:
-                    channel_id = key.split(':')[2]
+                    channel_id = self._channel_id_from_metadata_key(key)
+                    if not channel_id:
+                        continue
 
                     # Get metadata first
                     metadata = self.redis_client.hgetall(key)
                     if not metadata:
                         # Empty metadata - clean it up
                         logger.warning(f"Found empty metadata for channel {channel_id} - cleaning up")
-                        # If we have it locally, stop it properly
-                        if channel_id in self.stream_managers or channel_id in self.client_managers:
-                            self.stop_channel(channel_id)
-                        else:
-                            self._clean_redis_keys(channel_id)
+                        self._stop_upstream_before_redis_cleanup(channel_id)
+                        self._clean_redis_keys(channel_id)
                         continue
 
                     # Get owner
@@ -1837,13 +2122,8 @@ class ProxyServer:
                         state = metadata.get('state', 'unknown')
                         logger.warning(f"Found orphaned metadata for channel {channel_id} (state: {state}, owner: {owner}, clients: {client_count}) - cleaning up")
 
-                        # If we have it locally, stop it properly to clean up transcode/proxy processes
-                        if channel_id in self.stream_managers or channel_id in self.client_managers:
-                            logger.info(f"Channel {channel_id} is local - calling stop_channel to clean up processes")
-                            self.stop_channel(channel_id)
-                        else:
-                            # Just clean up Redis keys for remote channels
-                            self._clean_redis_keys(channel_id)
+                        self._stop_upstream_before_redis_cleanup(channel_id)
+                        self._clean_redis_keys(channel_id)
                     elif not owner_alive and client_count > 0:
                         # SCARD may include ghost entries from a dead worker's
                         # expired metadata hashes. Validate before deciding.
@@ -1859,16 +2139,23 @@ class ProxyServer:
                                 f"owner: {owner}) had {client_count} ghost client(s) "
                                 f"- cleaning up"
                             )
-                            if channel_id in self.stream_managers or channel_id in self.client_managers:
-                                self.stop_channel(channel_id)
-                            else:
-                                self._clean_redis_keys(channel_id)
+                            self._stop_upstream_before_redis_cleanup(channel_id)
+                            self._clean_redis_keys(channel_id)
                         else:
-                            logger.warning(
-                                f"Orphaned channel {channel_id} still has "
-                                f"{real_count} live client(s) after ghost removal "
-                                f"- may need ownership takeover"
-                            )
+                            if self._channel_teardown_active(channel_id):
+                                logger.warning(
+                                    f"Orphaned channel {channel_id} still has "
+                                    f"{real_count} client(s) during teardown; forcing cleanup"
+                                )
+                                self._force_clear_channel_clients(channel_id)
+                                self._stop_upstream_before_redis_cleanup(channel_id)
+                                self._clean_redis_keys(channel_id)
+                            else:
+                                logger.warning(
+                                    f"Orphaned channel {channel_id} still has "
+                                    f"{real_count} live client(s) after ghost removal "
+                                    f"- may need ownership takeover"
+                                )
 
                 except Exception as e:
                     logger.error(f"Error processing metadata key {key}: {e}", exc_info=True)
@@ -1878,58 +2165,64 @@ class ProxyServer:
 
     def _clean_redis_keys(self, channel_id):
         """Clean up all Redis keys for a channel more efficiently"""
-        # Release the channel, stream, and profile keys from the channel
+        total_deleted = 0
+
         try:
-            channel = Channel.objects.get(uuid=channel_id)
-            if not channel.release_stream():
-                logger.debug(f"Channel {channel_id}: release_stream found no keys to clean")
-        except (Channel.DoesNotExist, Exception):
+            # Release the M3U profile slot while channel_stream / metadata still exist.
+            # Scanning live:channel keys first deletes metadata and breaks release_stream()
+            # fallback, leaving profile_connections counters stuck (e.g. profile_connections:70 = 1).
             try:
-                stream = Stream.objects.get(stream_hash=channel_id)
-                if not stream.release_stream():
-                    logger.debug(f"Stream {channel_id}: release_stream found no keys to clean")
-            except (Stream.DoesNotExist, Exception):
-                logger.debug(f"No Channel or Stream found for {channel_id}")
+                channel = Channel.objects.get(uuid=channel_id)
+                if not channel.release_stream():
+                    logger.debug(f"Channel {channel_id}: release_stream found no keys to clean")
+            except (Channel.DoesNotExist, Exception):
+                try:
+                    stream = Stream.objects.get(stream_hash=channel_id)
+                    if not stream.release_stream():
+                        logger.debug(f"Stream {channel_id}: release_stream found no keys to clean")
+                except (Stream.DoesNotExist, Exception):
+                    logger.debug(f"No Channel or Stream found for {channel_id}")
 
-        if not self.redis_client:
-            return 0
+            if self.redis_client:
+                try:
+                    patterns = [
+                        f"live:channel:{channel_id}:*",
+                        RedisKeys.events_channel(channel_id),
+                    ]
 
-        try:
-            # Define key patterns to scan for
-            patterns = [
-                f"live:channel:{channel_id}:*",  # All channel keys
-                RedisKeys.events_channel(channel_id)  # Event channel
-            ]
+                    for pattern in patterns:
+                        cursor = 0
+                        while True:
+                            cursor, keys = self.redis_client.scan(cursor, match=pattern, count=100)
+                            if keys:
+                                self.redis_client.delete(*keys)
+                                total_deleted += len(keys)
 
-            total_deleted = 0
+                            if cursor == 0:
+                                break
 
-            for pattern in patterns:
-                cursor = 0
-                while True:
-                    cursor, keys = self.redis_client.scan(cursor, match=pattern, count=100)
-                    if keys:
-                        self.redis_client.delete(*keys)
-                        total_deleted += len(keys)
+                    logger.info(f"Cleaned up {total_deleted} Redis keys for channel {channel_id}")
+                except Exception as e:
+                    logger.error(f"Error cleaning Redis keys for channel {channel_id}: {e}")
+        finally:
+            close_old_connections()
 
-                    # Exit when cursor returns to 0
-                    if cursor == 0:
-                        break
-
-            logger.info(f"Cleaned up {total_deleted} Redis keys for channel {channel_id}")
-            return total_deleted
-
-        except Exception as e:
-            logger.error(f"Error cleaning Redis keys for channel {channel_id}: {e}")
-            return 0
+        return total_deleted
 
     def refresh_channel_registry(self):
         """Refresh TTL for active channels using standard keys"""
         if not self.redis_client:
             return
 
-        # Refresh registry entries for channels we own
+        # Refresh registry entries for channels we own and are actively serving.
+        # Skip channels mid-shutdown. Refreshing their TTL keeps zombie metadata alive.
         for channel_id in list(self.stream_buffers.keys()):
-            # Use standard key pattern
+            if channel_id in self._stopping_channels:
+                continue
+
+            if not self.am_i_owner(channel_id):
+                continue
+
             metadata_key = RedisKeys.channel_metadata(channel_id)
 
             # Update activity timestamp in metadata only
@@ -1979,14 +2272,28 @@ class ProxyServer:
     def _cleanup_local_resources(self, channel_id):
         """Clean up local resources for a channel without affecting Redis keys"""
         try:
-            if channel_id in self.stream_managers:
-                if hasattr(self.stream_managers[channel_id], 'stop'):
-                    self.stream_managers[channel_id].stop()
-                del self.stream_managers[channel_id]
-                logger.info(f"Non-owner cleanup: Removed stream manager for channel {channel_id}")
+            stream_manager = self._resolve_stream_manager(channel_id)
+            if stream_manager is not None:
+                if hasattr(stream_manager, 'stop'):
+                    stream_manager.stop()
+                logger.info(f"Non-owner cleanup: Stopped stream manager for channel {channel_id}")
+            elif self._get_stream_thread(channel_id):
+                logger.warning(
+                    f"Non-owner cleanup: Found orphaned stream thread for channel {channel_id}"
+                )
+                if channel_id in self.stream_buffers:
+                    self.stream_buffers[channel_id].stopping = True
+
+            self._join_stream_thread(channel_id)
+            self._live_stream_managers.pop(channel_id, None)
 
             if channel_id in self.stream_buffers:
-                del self.stream_buffers[channel_id]
+                buffer = self.stream_buffers.pop(channel_id)
+                if hasattr(buffer, 'stop'):
+                    try:
+                        buffer.stop()
+                    except Exception as e:
+                        logger.error(f"Non-owner cleanup: Error stopping buffer for {channel_id}: {e}")
                 logger.info(f"Non-owner cleanup: Removed stream buffer for channel {channel_id}")
 
             if channel_id in self.client_managers:
diff --git a/apps/proxy/live_proxy/services/channel_service.py b/apps/proxy/live_proxy/services/channel_service.py
index 8cc4a030..e18e07af 100644
--- a/apps/proxy/live_proxy/services/channel_service.py
+++ b/apps/proxy/live_proxy/services/channel_service.py
@@ -10,6 +10,7 @@ from apps.channels.models import Channel, Stream
 from ..server import ProxyServer
 from ..redis_keys import RedisKeys
 from ..constants import EventType, ChannelState, ChannelMetadataField
+from ..config_helper import ConfigHelper
 from ..url_utils import get_stream_info_for_switch
 from core.utils import log_system_event
 from .log_parsers import LogParserFactory
@@ -19,6 +20,250 @@ logger = logging.getLogger("live_proxy")
 class ChannelService:
     """Service class for channel operations"""
 
+    @staticmethod
+    def mark_channel_stopping(channel_id, broadcast=False):
+        """Mark a channel as stopping in Redis so all uWSGI workers converge on teardown."""
+        proxy_server = ProxyServer.get_instance()
+        if not proxy_server.redis_client:
+            return False
+
+        try:
+            metadata_key = RedisKeys.channel_metadata(channel_id)
+            if proxy_server.redis_client.exists(metadata_key):
+                proxy_server.redis_client.hset(metadata_key, mapping={
+                    ChannelMetadataField.STATE: ChannelState.STOPPING,
+                    ChannelMetadataField.STATE_CHANGED_AT: str(time.time()),
+                })
+
+            stop_key = RedisKeys.channel_stopping(channel_id)
+            proxy_server.redis_client.setex(stop_key, 60, "true")
+
+            if broadcast:
+                ChannelService._publish_channel_stop_event(channel_id)
+            return True
+        except Exception as e:
+            logger.error(f"Error marking channel {channel_id} as stopping: {e}")
+            return False
+
+    @staticmethod
+    def is_shutdown_pending(channel_id):
+        """True while the post-disconnect shutdown delay has started but stop has not run."""
+        proxy_server = ProxyServer.get_instance()
+        if not proxy_server.redis_client:
+            return False
+
+        delay = ConfigHelper.channel_shutdown_delay()
+        if delay <= 0:
+            return False
+
+        disconnect_value = proxy_server.redis_client.get(
+            RedisKeys.last_client_disconnect(channel_id)
+        )
+        if not disconnect_value:
+            return False
+
+        try:
+            disconnect_time = float(disconnect_value)
+        except (ValueError, TypeError):
+            return False
+
+        return (time.time() - disconnect_time) < delay
+
+    @staticmethod
+    def is_channel_teardown_active(channel_id):
+        """True when a coordinated channel stop is in progress (visible to all workers)."""
+        proxy_server = ProxyServer.get_instance()
+        if channel_id in proxy_server._stopping_channels:
+            return True
+
+        if not proxy_server.redis_client:
+            return False
+
+        if proxy_server.redis_client.exists(RedisKeys.channel_stopping(channel_id)):
+            return True
+
+        metadata_key = RedisKeys.channel_metadata(channel_id)
+        state = proxy_server.redis_client.hget(metadata_key, ChannelMetadataField.STATE)
+        if state:
+            state_str = state.decode() if isinstance(state, bytes) else state
+            if state_str == ChannelState.STOPPING:
+                return True
+
+        return False
+
+    @staticmethod
+    def is_channel_unavailable_for_new_clients(channel_id):
+        """Reject new stream requests only while coordinated teardown is active."""
+        return ChannelService.is_channel_teardown_active(channel_id)
+
+    @staticmethod
+    def cancel_pending_shutdown(channel_id):
+        """
+        Abort the post-disconnect grace timer when a client reconnects.
+
+        Clears the disconnect timestamp and any leaked stopping markers. When
+        upstream is still active but the last client released its profile slot
+        during the grace window, re-reserve the slot from Redis metadata.
+
+        Does not run during coordinated stop_channel() — clearing teardown
+        markers mid-stop would leave clients attached to upstream that is
+        about to be torn down.
+        """
+        from django.db import close_old_connections
+
+        proxy_server = ProxyServer.get_instance()
+        if not proxy_server.redis_client:
+            return False
+
+        if channel_id in proxy_server._stopping_channels:
+            return False
+
+        disconnect_key = RedisKeys.last_client_disconnect(channel_id)
+        had_pending = bool(proxy_server.redis_client.exists(disconnect_key))
+        in_grace = had_pending or ChannelService.is_shutdown_pending(channel_id)
+
+        if not in_grace:
+            return False
+
+        try:
+            proxy_server.redis_client.delete(disconnect_key)
+
+            metadata_key = RedisKeys.channel_metadata(channel_id)
+            state = proxy_server.redis_client.hget(
+                metadata_key, ChannelMetadataField.STATE
+            )
+            if state:
+                state_str = state.decode() if isinstance(state, bytes) else state
+                if state_str == ChannelState.STOPPING:
+                    proxy_server.redis_client.hset(metadata_key, mapping={
+                        ChannelMetadataField.STATE: ChannelState.ACTIVE,
+                        ChannelMetadataField.STATE_CHANGED_AT: str(time.time()),
+                    })
+
+            stop_key = RedisKeys.channel_stopping(channel_id)
+            if proxy_server.redis_client.exists(stop_key):
+                proxy_server.redis_client.delete(stop_key)
+
+            if ChannelService._channel_proxy_is_active(
+                proxy_server.redis_client, channel_id
+            ):
+                from apps.channels.models import Channel
+
+                channel = Channel.objects.filter(uuid=channel_id).first()
+                if channel and not proxy_server.redis_client.get(
+                    f"channel_stream:{channel.id}"
+                ):
+                    sid, pid, error, slot_reserved = channel.get_stream()
+                    if error:
+                        logger.warning(
+                            f"Could not re-reserve stream for {channel_id} "
+                            f"after shutdown cancel: {error}"
+                        )
+                    elif slot_reserved and sid and pid:
+                        proxy_server.redis_client.hset(metadata_key, mapping={
+                            ChannelMetadataField.STREAM_ID: str(sid),
+                            ChannelMetadataField.M3U_PROFILE: str(pid),
+                        })
+                        logger.info(
+                            f"Re-reserved profile slot for {channel_id} "
+                            f"(stream={sid}, profile={pid})"
+                        )
+        finally:
+            close_old_connections()
+
+        return True
+
+    @staticmethod
+    def _channel_proxy_is_active(redis_client, channel_id):
+        """True when live proxy metadata shows this channel is still running."""
+        metadata_key = RedisKeys.channel_metadata(channel_id)
+        if not redis_client.exists(metadata_key):
+            return False
+        state = redis_client.hget(metadata_key, ChannelMetadataField.STATE)
+        if state is None:
+            return False
+        if isinstance(state, bytes):
+            state = state.decode()
+        return state in (
+            ChannelState.ACTIVE,
+            ChannelState.WAITING_FOR_CLIENTS,
+            ChannelState.BUFFERING,
+            ChannelState.INITIALIZING,
+            ChannelState.CONNECTING,
+        )
+
+    @staticmethod
+    def promote_channel_when_buffer_ready(channel_id):
+        """
+        Promote channel state once the initial buffer threshold is met.
+
+        - connecting/initializing + buffer ready + clients -> active
+        - connecting/initializing + buffer ready + no clients -> waiting_for_clients
+        - waiting_for_clients + clients -> active
+
+        Returns the resulting state, or None when no promotion applies.
+        """
+        proxy_server = ProxyServer.get_instance()
+        redis_client = proxy_server.redis_client
+        if not redis_client:
+            return None
+
+        metadata_key = RedisKeys.channel_metadata(channel_id)
+        state_raw = redis_client.hget(metadata_key, ChannelMetadataField.STATE)
+        if not state_raw:
+            return None
+
+        state = state_raw.decode() if isinstance(state_raw, bytes) else state_raw
+        if state == ChannelState.ACTIVE:
+            return ChannelState.ACTIVE
+
+        if state == ChannelState.WAITING_FOR_CLIENTS:
+            ready_raw = redis_client.hget(
+                metadata_key, ChannelMetadataField.CONNECTION_READY_TIME
+            )
+            if not ready_raw:
+                return None
+            client_count = redis_client.scard(RedisKeys.clients(channel_id)) or 0
+            if client_count <= 0:
+                return ChannelState.WAITING_FOR_CLIENTS
+            proxy_server.update_channel_state(
+                channel_id,
+                ChannelState.ACTIVE,
+                {"clients_at_activation": str(client_count)},
+            )
+            return ChannelState.ACTIVE
+
+        if state not in (ChannelState.INITIALIZING, ChannelState.CONNECTING):
+            return None
+
+        try:
+            buffer_index = int(redis_client.get(RedisKeys.buffer_index(channel_id)) or 0)
+        except (TypeError, ValueError):
+            buffer_index = 0
+
+        chunks_needed = ConfigHelper.initial_behind_chunks()
+        if buffer_index < chunks_needed:
+            return None
+
+        client_count = redis_client.scard(RedisKeys.clients(channel_id)) or 0
+        new_state = (
+            ChannelState.ACTIVE if client_count > 0 else ChannelState.WAITING_FOR_CLIENTS
+        )
+        current_time = str(time.time())
+        extra = {
+            ChannelMetadataField.CONNECTION_READY_TIME: current_time,
+            ChannelMetadataField.BUFFER_CHUNKS: str(buffer_index),
+        }
+        if new_state == ChannelState.ACTIVE:
+            extra["clients_at_activation"] = str(client_count)
+
+        proxy_server.update_channel_state(channel_id, new_state, extra)
+        logger.info(
+            f"Channel {channel_id} buffer ready ({buffer_index}/{chunks_needed} chunks) "
+            f"-> {new_state} (clients={client_count})"
+        )
+        return new_state
+
     @staticmethod
     def initialize_channel(channel_id, stream_url, user_agent, transcode=False, stream_profile_value=None, stream_id=None, m3u_profile_id=None, channel_name=None, stream_name=None):
         """
@@ -39,6 +284,7 @@ class ChannelService:
             bool: Success status
         """
         proxy_server = ProxyServer.get_instance()
+
         if stream_id and proxy_server.redis_client:
             metadata_key = RedisKeys.channel_metadata(channel_id)
             # Check if metadata already exists
@@ -67,34 +313,38 @@ class ChannelService:
 
         # Store additional metadata if initialization was successful
         if success and proxy_server.redis_client:
-            metadata_key = RedisKeys.channel_metadata(channel_id)
-            update_data = {}
-            if stream_profile_value:
-                update_data[ChannelMetadataField.STREAM_PROFILE] = stream_profile_value
-            if stream_id:
-                update_data[ChannelMetadataField.STREAM_ID] = str(stream_id)
-            if m3u_profile_id:
-                update_data[ChannelMetadataField.M3U_PROFILE] = str(m3u_profile_id)
-
-            # Store channel name and stream name so stats workers don't need DB calls
             try:
-                if not channel_name:
-                    from apps.channels.models import Channel
-                    channel_name = Channel.objects.filter(uuid=channel_id).values_list('name', flat=True).first()
-                if channel_name:
-                    update_data[ChannelMetadataField.CHANNEL_NAME] = channel_name
-                else:
-                    # No channel name means stream preview mode, use stream name as display fallback
-                    if stream_id and not stream_name:
-                        from apps.channels.models import Stream
-                        stream_name = Stream.objects.filter(id=stream_id).values_list('name', flat=True).first()
-                    if stream_name:
-                        update_data[ChannelMetadataField.STREAM_NAME] = stream_name
-            except Exception as e:
-                logger.warning(f"Failed to store channel/stream names in Redis for {channel_id}: {e}")
+                metadata_key = RedisKeys.channel_metadata(channel_id)
+                update_data = {}
+                if stream_profile_value:
+                    update_data[ChannelMetadataField.STREAM_PROFILE] = stream_profile_value
+                if stream_id:
+                    update_data[ChannelMetadataField.STREAM_ID] = str(stream_id)
+                if m3u_profile_id:
+                    update_data[ChannelMetadataField.M3U_PROFILE] = str(m3u_profile_id)
 
-            if update_data:
-                proxy_server.redis_client.hset(metadata_key, mapping=update_data)
+                # Store channel name and stream name so stats workers don't need DB calls
+                try:
+                    if not channel_name:
+                        from apps.channels.models import Channel
+                        channel_name = Channel.objects.filter(uuid=channel_id).values_list('name', flat=True).first()
+                    if channel_name:
+                        update_data[ChannelMetadataField.CHANNEL_NAME] = channel_name
+                    else:
+                        # No channel name means stream preview mode, use stream name as display fallback
+                        if stream_id and not stream_name:
+                            from apps.channels.models import Stream
+                            stream_name = Stream.objects.filter(id=stream_id).values_list('name', flat=True).first()
+                        if stream_name:
+                            update_data[ChannelMetadataField.STREAM_NAME] = stream_name
+                except Exception as e:
+                    logger.warning(f"Failed to store channel/stream names in Redis for {channel_id}: {e}")
+
+                if update_data:
+                    proxy_server.redis_client.hset(metadata_key, mapping=update_data)
+            finally:
+                from django.db import close_old_connections
+                close_old_connections()
 
         return success
 
@@ -263,58 +513,23 @@ class ChannelService:
             try:
                 metadata = proxy_server.redis_client.hgetall(metadata_key)
                 if metadata and 'state' in metadata:
-                    state = metadata['state']
-                    channel_info = {"state": state}
-
-                    # Immediately mark as stopping in metadata so clients detect it faster
-                    proxy_server.redis_client.hset(metadata_key, ChannelMetadataField.STATE, ChannelState.STOPPING)
-                    proxy_server.redis_client.hset(metadata_key, ChannelMetadataField.STATE_CHANGED_AT, str(time.time()))
+                    channel_info = {"state": metadata['state']}
             except Exception as e:
                 logger.error(f"Error fetching channel state: {e}")
 
-        # Set stopping flag with higher TTL to ensure it persists
+        # Mark stopping in Redis and notify all workers before local teardown.
+        # stop_channel() releases profile slots via _clean_redis_keys() before Redis deletion.
         if proxy_server.redis_client:
-            stop_key = RedisKeys.channel_stopping(channel_id)
-            proxy_server.redis_client.setex(stop_key, 60, "true")  # Higher TTL of 60 seconds
-            logger.info(f"Set channel stopping flag with 60s TTL for channel {channel_id}")
-
-        # Broadcast stop event to all workers via PubSub
-        if proxy_server.redis_client:
-            ChannelService._publish_channel_stop_event(channel_id)
-
-            # Also stop locally to ensure this worker cleans up right away
-            local_result = proxy_server.stop_channel(channel_id)
-        else:
-            # No Redis, just stop locally
-            local_result = proxy_server.stop_channel(channel_id)
-
-        # Release the channel in the channel model if applicable
-        try:
-            channel = Channel.objects.get(uuid=channel_id)
-            model_released = channel.release_stream()
-            if model_released:
-                logger.info(f"Released channel {channel_id} stream allocation")
-            else:
-                logger.warning(f"Channel {channel_id}: release_stream found no keys to clean")
-        except (Channel.DoesNotExist, Exception):
-            logger.warning(f"Could not find Channel model for UUID {channel_id}, attempting stream hash")
-            try:
-                stream = Stream.objects.get(stream_hash=channel_id)
-                model_released = stream.release_stream()
-                if model_released:
-                    logger.info(f"Released stream {channel_id} stream allocation")
-                else:
-                    logger.warning(f"Stream {channel_id}: release_stream found no keys to clean")
-            except (Stream.DoesNotExist, Exception) as e:
-                logger.error(f"No Channel or Stream found for {channel_id}: {e}")
-                model_released = False
+            ChannelService.mark_channel_stopping(channel_id, broadcast=True)
+            logger.info(f"Marked channel {channel_id} stopping and broadcast stop to all workers")
+        local_result = proxy_server.stop_channel(channel_id)
 
         return {
             'status': 'success',
             'message': 'Channel stop request sent',
             'channel_id': channel_id,
             'previous_state': channel_info,
-            'model_released': model_released,
+            'model_released': bool(local_result),
             'local_stop_result': local_result
         }
 
@@ -597,53 +812,57 @@ class ChannelService:
     @staticmethod
     def _update_channel_metadata(channel_id, url, user_agent=None, stream_id=None, m3u_profile_id=None, stream_name=None):
         """Update channel metadata in Redis"""
-        proxy_server = ProxyServer.get_instance()
+        try:
+            proxy_server = ProxyServer.get_instance()
 
-        if not proxy_server.redis_client:
-            return False
+            if not proxy_server.redis_client:
+                return False
 
-        metadata_key = RedisKeys.channel_metadata(channel_id)
+            metadata_key = RedisKeys.channel_metadata(channel_id)
 
-        # First check if the key exists and what type it is
-        key_type = proxy_server.redis_client.type(metadata_key)
-        logger.debug(f"Redis key {metadata_key} is of type: {key_type}")
+            # First check if the key exists and what type it is
+            key_type = proxy_server.redis_client.type(metadata_key)
+            logger.debug(f"Redis key {metadata_key} is of type: {key_type}")
 
-        # Build metadata update dict
-        metadata = {ChannelMetadataField.URL: url}
-        if user_agent:
-            metadata[ChannelMetadataField.USER_AGENT] = user_agent
-        if stream_id:
-            metadata[ChannelMetadataField.STREAM_ID] = str(stream_id)
-            if not stream_name:
-                try:
-                    from apps.channels.models import Stream
-                    stream_name = Stream.objects.filter(id=stream_id).values_list('name', flat=True).first()
-                except Exception as e:
-                    logger.warning(f"Failed to update stream name in Redis for stream {stream_id}: {e}")
-            if stream_name:
-                metadata[ChannelMetadataField.STREAM_NAME] = stream_name
-        if m3u_profile_id:
-            metadata[ChannelMetadataField.M3U_PROFILE] = str(m3u_profile_id)
+            # Build metadata update dict
+            metadata = {ChannelMetadataField.URL: url}
+            if user_agent:
+                metadata[ChannelMetadataField.USER_AGENT] = user_agent
+            if stream_id:
+                metadata[ChannelMetadataField.STREAM_ID] = str(stream_id)
+                if not stream_name:
+                    try:
+                        from apps.channels.models import Stream
+                        stream_name = Stream.objects.filter(id=stream_id).values_list('name', flat=True).first()
+                    except Exception as e:
+                        logger.warning(f"Failed to update stream name in Redis for stream {stream_id}: {e}")
+                if stream_name:
+                    metadata[ChannelMetadataField.STREAM_NAME] = stream_name
+            if m3u_profile_id:
+                metadata[ChannelMetadataField.M3U_PROFILE] = str(m3u_profile_id)
 
-        # Also update the stream switch time field
-        metadata[ChannelMetadataField.STREAM_SWITCH_TIME] = str(time.time())
+            # Also update the stream switch time field
+            metadata[ChannelMetadataField.STREAM_SWITCH_TIME] = str(time.time())
 
-        # Use the appropriate method based on the key type
-        if key_type == 'hash':
-            proxy_server.redis_client.hset(metadata_key, mapping=metadata)
-        elif key_type == 'none':  # Key doesn't exist yet
-            proxy_server.redis_client.hset(metadata_key, mapping=metadata)
-        else:
-            # If key exists with wrong type, delete it and recreate
-            proxy_server.redis_client.delete(metadata_key)
-            proxy_server.redis_client.hset(metadata_key, mapping=metadata)
+            # Use the appropriate method based on the key type
+            if key_type == 'hash':
+                proxy_server.redis_client.hset(metadata_key, mapping=metadata)
+            elif key_type == 'none':  # Key doesn't exist yet
+                proxy_server.redis_client.hset(metadata_key, mapping=metadata)
+            else:
+                # If key exists with wrong type, delete it and recreate
+                proxy_server.redis_client.delete(metadata_key)
+                proxy_server.redis_client.hset(metadata_key, mapping=metadata)
 
-        # Set switch request flag to ensure all workers see it
-        switch_key = RedisKeys.switch_request(channel_id)
-        proxy_server.redis_client.setex(switch_key, 30, url)  # 30 second TTL
+            # Set switch request flag to ensure all workers see it
+            switch_key = RedisKeys.switch_request(channel_id)
+            proxy_server.redis_client.setex(switch_key, 30, url)  # 30 second TTL
 
-        logger.debug(f"Updated metadata for channel {channel_id} in Redis")
-        return True
+            logger.debug(f"Updated metadata for channel {channel_id} in Redis")
+            return True
+        finally:
+            from django.db import close_old_connections
+            close_old_connections()
 
     @staticmethod
     def _publish_stream_switch_event(channel_id, new_url, user_agent=None, stream_id=None, m3u_profile_id=None):
diff --git a/apps/proxy/live_proxy/tests/test_live_db_cleanup.py b/apps/proxy/live_proxy/tests/test_live_db_cleanup.py
new file mode 100644
index 00000000..f2015a41
--- /dev/null
+++ b/apps/proxy/live_proxy/tests/test_live_db_cleanup.py
@@ -0,0 +1,142 @@
+"""Live proxy must release geventpool checkouts after ORM on stream and URL paths."""
+
+from unittest.mock import MagicMock, patch
+
+from django.http import StreamingHttpResponse
+from django.test import RequestFactory, SimpleTestCase
+
+
+class StreamTsDbCleanupTests(SimpleTestCase):
+    def setUp(self):
+        self.factory = RequestFactory()
+
+    @patch("apps.proxy.live_proxy.views.close_old_connections")
+    @patch("apps.proxy.live_proxy.views.create_stream_generator")
+    @patch("apps.proxy.live_proxy.views._resolve_output_format", return_value="mpegts")
+    @patch("apps.proxy.live_proxy.views._resolve_output_profile", return_value=None)
+    @patch("apps.proxy.live_proxy.views.ChannelService.is_channel_unavailable_for_new_clients", return_value=False)
+    @patch("apps.proxy.live_proxy.views.get_stream_object")
+    @patch("apps.proxy.live_proxy.views.network_access_allowed", return_value=True)
+    @patch("apps.proxy.live_proxy.views.ProxyServer")
+    def test_stream_ts_closes_db_before_streaming_response(
+        self,
+        mock_proxy_cls,
+        _network_ok,
+        mock_get_stream_object,
+        _unavailable,
+        _output_profile,
+        _output_format,
+        mock_create_generator,
+        mock_close,
+    ):
+        channel = MagicMock()
+        channel.id = 1
+        channel.uuid = "channel-uuid"
+        channel.name = "Test Channel"
+        mock_get_stream_object.return_value = channel
+
+        client_manager = MagicMock()
+        proxy_server = MagicMock()
+        proxy_server.redis_client = MagicMock()
+        proxy_server.redis_client.exists.return_value = True
+        proxy_server.redis_client.hgetall.return_value = {"state": "active"}
+        proxy_server.stream_buffers = {"channel-uuid": MagicMock()}
+        proxy_server.client_managers = {"channel-uuid": client_manager}
+        proxy_server.check_if_channel_exists.return_value = True
+        proxy_server.get_buffer.return_value = MagicMock()
+        mock_proxy_cls.get_instance.return_value = proxy_server
+
+        def _generate():
+            yield b"chunk"
+
+        mock_create_generator.return_value = lambda: _generate()
+
+        request = self.factory.get("/proxy/live/channel-uuid/")
+        request.user = MagicMock(is_authenticated=False)
+
+        from apps.proxy.live_proxy.views import stream_ts
+
+        response = stream_ts(request, "channel-uuid")
+
+        self.assertIsInstance(response, StreamingHttpResponse)
+        mock_close.assert_called_once()
+
+
+class UrlUtilsDbCleanupTests(SimpleTestCase):
+    @patch("apps.proxy.live_proxy.url_utils.close_old_connections")
+    @patch("apps.proxy.live_proxy.url_utils.get_stream_object")
+    def test_generate_stream_url_closes_db(self, mock_get_object, mock_close):
+        channel = MagicMock()
+        channel.get_stream.return_value = (None, None, "no streams", False)
+        mock_get_object.return_value = channel
+
+        from apps.proxy.live_proxy.url_utils import generate_stream_url
+
+        result = generate_stream_url("channel-uuid")
+
+        self.assertIsNone(result[0])
+        mock_close.assert_called_once()
+
+    @patch("apps.proxy.live_proxy.url_utils.close_old_connections")
+    @patch("apps.proxy.live_proxy.url_utils.get_stream_object")
+    def test_get_alternate_streams_closes_db(self, mock_get_object, mock_close):
+        channel = MagicMock()
+        channel.streams.all.return_value.order_by.return_value.exists.return_value = False
+        mock_get_object.return_value = channel
+
+        from apps.proxy.live_proxy.url_utils import get_alternate_streams
+
+        result = get_alternate_streams("channel-uuid", current_stream_id=1)
+
+        self.assertEqual(result, [])
+        mock_close.assert_called_once()
+
+    @patch("apps.proxy.live_proxy.url_utils.close_old_connections")
+    @patch("apps.proxy.live_proxy.url_utils.get_object_or_404")
+    def test_get_stream_info_for_switch_closes_db_on_error(self, mock_get_404, mock_close):
+        mock_get_404.side_effect = RuntimeError("db error")
+
+        from apps.proxy.live_proxy.url_utils import get_stream_info_for_switch
+
+        result = get_stream_info_for_switch("channel-uuid", target_stream_id=99)
+
+        self.assertIn("error", result)
+        mock_close.assert_called_once()
+
+    @patch("apps.proxy.live_proxy.url_utils.close_old_connections")
+    @patch("apps.proxy.live_proxy.url_utils.M3UAccountProfile.objects.get")
+    def test_get_connections_left_closes_db(self, mock_get, mock_close):
+        mock_get.side_effect = Exception("not found")
+
+        from apps.proxy.live_proxy.url_utils import get_connections_left
+
+        result = get_connections_left(999)
+
+        self.assertEqual(result, 0)
+        mock_close.assert_called_once()
+
+
+class TsGeneratorDbCleanupTests(SimpleTestCase):
+    @patch("apps.proxy.live_proxy.output.ts.generator.close_old_connections")
+    @patch("apps.proxy.live_proxy.output.ts.generator.ProxyServer.get_instance")
+    def test_ts_cleanup_closes_db(self, mock_proxy_cls, mock_close):
+        proxy_server = MagicMock()
+        proxy_server.redis_client = None
+        proxy_server.client_managers = {}
+        mock_proxy_cls.return_value = proxy_server
+
+        from apps.proxy.live_proxy.output.ts.generator import StreamGenerator
+
+        gen = StreamGenerator.__new__(StreamGenerator)
+        gen.channel_id = "channel-uuid"
+        gen.client_id = "client-1"
+        gen.stream_start_time = 0
+        gen.channel_name = "Test"
+        gen.client_ip = "127.0.0.1"
+        gen.client_user_agent = "agent"
+        gen.bytes_sent = 0
+        gen.user = None
+
+        gen._cleanup()
+
+        mock_close.assert_called_once()
diff --git a/apps/proxy/live_proxy/tests/test_proxy_settings.py b/apps/proxy/live_proxy/tests/test_proxy_settings.py
new file mode 100644
index 00000000..e821f1cb
--- /dev/null
+++ b/apps/proxy/live_proxy/tests/test_proxy_settings.py
@@ -0,0 +1,143 @@
+"""Tests for proxy settings defaults, serializer validation, and migration 0026."""
+
+from importlib import import_module
+from unittest.mock import patch
+
+from django.apps import apps
+from django.test import SimpleTestCase, TestCase
+
+from apps.proxy.config import TSConfig
+from core.models import CoreSettings
+from core.serializers import ProxySettingsSerializer
+
+MIGRATION_0026 = import_module("core.migrations.0026_add_channel_client_wait_period")
+
+
+class TSConfigProxySettingsDefaultsTests(SimpleTestCase):
+    @patch.object(TSConfig, "get_proxy_settings", return_value={})
+    def test_channel_init_grace_period_default(self, _mock_settings):
+        self.assertEqual(TSConfig.get_channel_init_grace_period(), 60)
+
+    @patch.object(TSConfig, "get_proxy_settings", return_value={})
+    def test_channel_client_wait_period_default(self, _mock_settings):
+        self.assertEqual(TSConfig.get_channel_client_wait_period(), 5)
+
+    @patch.object(
+        TSConfig,
+        "get_proxy_settings",
+        return_value={
+            "channel_init_grace_period": 120,
+            "channel_client_wait_period": 15,
+        },
+    )
+    def test_settings_override_db_values(self, _mock_settings):
+        self.assertEqual(TSConfig.get_channel_init_grace_period(), 120)
+        self.assertEqual(TSConfig.get_channel_client_wait_period(), 15)
+
+
+class ProxySettingsSerializerTests(SimpleTestCase):
+    def _valid_payload(self, **overrides):
+        payload = {
+            "buffering_timeout": 15,
+            "buffering_speed": 1.0,
+            "redis_chunk_ttl": 60,
+            "channel_shutdown_delay": 0,
+            "channel_init_grace_period": 60,
+            "channel_client_wait_period": 5,
+            "new_client_behind_seconds": 5,
+        }
+        payload.update(overrides)
+        return payload
+
+    def test_accepts_new_client_wait_period(self):
+        serializer = ProxySettingsSerializer(data=self._valid_payload())
+        self.assertTrue(serializer.is_valid(), serializer.errors)
+        self.assertEqual(serializer.validated_data["channel_client_wait_period"], 5)
+
+    def test_init_grace_period_allows_up_to_300(self):
+        serializer = ProxySettingsSerializer(
+            data=self._valid_payload(channel_init_grace_period=300)
+        )
+        self.assertTrue(serializer.is_valid(), serializer.errors)
+
+    def test_init_grace_period_rejects_above_300(self):
+        serializer = ProxySettingsSerializer(
+            data=self._valid_payload(channel_init_grace_period=301)
+        )
+        self.assertFalse(serializer.is_valid())
+        self.assertIn("channel_init_grace_period", serializer.errors)
+
+
+class CoreSettingsProxyDefaultsTests(TestCase):
+    def test_get_proxy_settings_defaults_when_missing(self):
+        CoreSettings.objects.filter(key="proxy_settings").delete()
+        defaults = CoreSettings.get_proxy_settings()
+        self.assertEqual(defaults["channel_init_grace_period"], 60)
+        self.assertEqual(defaults["channel_client_wait_period"], 5)
+
+
+class Migration0026ProxySettingsTests(TestCase):
+    def _run_migration_forward(self):
+        MIGRATION_0026.add_channel_client_wait_period(apps, None)
+
+    def _set_proxy_settings(self, value):
+        settings_obj, _ = CoreSettings.objects.get_or_create(
+            key="proxy_settings",
+            defaults={"name": "Proxy Settings", "value": value},
+        )
+        settings_obj.value = value
+        settings_obj.save(update_fields=["value"])
+        return settings_obj
+
+    def test_bumps_legacy_init_grace_and_adds_client_wait(self):
+        settings_obj = self._set_proxy_settings(
+            {
+                "buffering_timeout": 15,
+                "buffering_speed": 1.0,
+                "redis_chunk_ttl": 60,
+                "channel_shutdown_delay": 0,
+                "channel_init_grace_period": 5,
+                "new_client_behind_seconds": 5,
+            }
+        )
+
+        self._run_migration_forward()
+        settings_obj.refresh_from_db()
+
+        self.assertEqual(settings_obj.value["channel_init_grace_period"], 60)
+        self.assertEqual(settings_obj.value["channel_client_wait_period"], 5)
+
+    def test_bumps_init_grace_below_new_default(self):
+        settings_obj = self._set_proxy_settings(
+            {
+                "buffering_timeout": 15,
+                "buffering_speed": 1.0,
+                "redis_chunk_ttl": 60,
+                "channel_shutdown_delay": 0,
+                "channel_init_grace_period": 45,
+                "new_client_behind_seconds": 5,
+            }
+        )
+
+        self._run_migration_forward()
+        settings_obj.refresh_from_db()
+
+        self.assertEqual(settings_obj.value["channel_init_grace_period"], 60)
+
+    def test_preserves_init_grace_at_or_above_new_default(self):
+        settings_obj = self._set_proxy_settings(
+            {
+                "buffering_timeout": 15,
+                "buffering_speed": 1.0,
+                "redis_chunk_ttl": 60,
+                "channel_shutdown_delay": 0,
+                "channel_init_grace_period": 90,
+                "new_client_behind_seconds": 5,
+            }
+        )
+
+        self._run_migration_forward()
+        settings_obj.refresh_from_db()
+
+        self.assertEqual(settings_obj.value["channel_init_grace_period"], 90)
+        self.assertEqual(settings_obj.value["channel_client_wait_period"], 5)
diff --git a/apps/proxy/live_proxy/url_utils.py b/apps/proxy/live_proxy/url_utils.py
index 5227a3fa..2b32f7e6 100644
--- a/apps/proxy/live_proxy/url_utils.py
+++ b/apps/proxy/live_proxy/url_utils.py
@@ -5,9 +5,14 @@ Utilities for handling stream URLs and transformations.
 import logging
 import regex
 from typing import Optional, Tuple, List
+from django.db import close_old_connections
 from django.shortcuts import get_object_or_404
 from apps.channels.models import Channel, Stream
 from apps.m3u.models import M3UAccount, M3UAccountProfile
+from apps.m3u.connection_pool import (
+    get_profile_connection_count,
+    profile_available_for_channel_switch,
+)
 from core.models import UserAgent, CoreSettings, StreamProfile
 from .utils import get_logger
 from uuid import UUID
@@ -15,6 +20,35 @@ import requests
 
 logger = get_logger()
 
+
+def _resolve_live_stream_url(stream, m3u_account, m3u_profile):
+    """
+    Build the upstream URL for live playback.
+
+    XC accounts use current transformed credentials plus provider stream_id so
+    playback matches the account login (not a stale stream.url from an old sync).
+    STD/M3U accounts keep using the URL stored on the stream row.
+    """
+    if (
+        m3u_account.account_type == M3UAccount.Types.XC
+        and stream.stream_id
+    ):
+        from apps.m3u.tasks import get_transformed_credentials
+
+        server_url, username, password = get_transformed_credentials(
+            m3u_account, m3u_profile
+        )
+        if server_url and username and password:
+            base = server_url.rstrip("/")
+            return f"{base}/live/{username}/{password}/{stream.stream_id}.ts"
+
+    return transform_url(
+        stream.url or "",
+        m3u_profile.search_pattern,
+        m3u_profile.replace_pattern,
+    )
+
+
 def get_stream_object(id: str):
     try:
         logger.info(f"Fetching channel ID {id}")
@@ -24,15 +58,14 @@ def get_stream_object(id: str):
         logger.info(f"Fetching stream hash {id}")
         return get_object_or_404(Stream, stream_hash=id)
 
-def generate_stream_url(channel_id: str) -> Tuple[str, str, bool, Optional[int]]:
+def generate_stream_url(
+    channel_id: str,
+) -> Tuple[str, str, bool, Optional[int], bool, Optional[str]]:
     """
     Generate the appropriate stream URL for a channel or stream based on its profile settings.
 
-    Args:
-        channel_id: The UUID of the channel or stream hash
-
     Returns:
-        Tuple[str, str, bool, Optional[int]]: (stream_url, user_agent, transcode_flag, profile_id)
+        Tuple: (stream_url, user_agent, transcode_flag, profile_id, slot_reserved, error_reason)
     """
     try:
         channel_or_stream = get_stream_object(channel_id)
@@ -44,15 +77,12 @@ def generate_stream_url(channel_id: str) -> Tuple[str, str, bool, Optional[int]]
 
             if not stream.m3u_account:
                 logger.error(f"Stream {stream.id} has no M3U account")
-                return None, None, False, None
+                return None, None, False, None, False, "Stream has no M3U account"
 
-            # Use get_stream() to atomically reserve a slot and write the
-            # channel_stream / stream_profile Redis keys, matching the channel
-            # path so stream_name and stream_stats work correctly.
-            stream_id, profile_id, error_reason = stream.get_stream()
+            stream_id, profile_id, error_reason, slot_reserved = stream.get_stream()
             if not stream_id or not profile_id:
                 logger.error(f"No profile available for stream {stream.id}: {error_reason}")
-                return None, None, False, None
+                return None, None, False, None, False, error_reason
 
             try:
                 profile = M3UAccountProfile.objects.get(id=profile_id)
@@ -63,7 +93,7 @@ def generate_stream_url(channel_id: str) -> Tuple[str, str, bool, Optional[int]]
                     stream_user_agent = UserAgent.objects.get(id=CoreSettings.get_default_user_agent_id())
                     logger.debug(f"No user agent found for account, using default: {stream_user_agent}")
 
-                stream_url = transform_url(stream.url, profile.search_pattern, profile.replace_pattern)
+                stream_url = _resolve_live_stream_url(stream, m3u_account, profile)
 
                 stream_profile = stream.get_stream_profile()
                 logger.debug(f"Using stream profile: {stream_profile.name}")
@@ -71,23 +101,23 @@ def generate_stream_url(channel_id: str) -> Tuple[str, str, bool, Optional[int]]
                 transcode = not stream_profile.is_proxy()
                 stream_profile_id = stream_profile.id
 
-                return stream_url, stream_user_agent, transcode, stream_profile_id
+                return stream_url, stream_user_agent, transcode, stream_profile_id, slot_reserved, None
             except Exception as e:
                 logger.error(f"Error generating stream URL for stream {stream.id}: {e}")
-                stream.release_stream()
-                return None, None, False, None
+                if slot_reserved:
+                    stream.release_stream()
+                return None, None, False, None, False, str(e)
 
 
         # Handle channel preview (existing logic)
         channel = channel_or_stream
 
         # Get stream and profile for this channel
-        # Note: get_stream now returns 3 values (stream_id, profile_id, error_reason)
-        stream_id, profile_id, error_reason = channel.get_stream()
+        stream_id, profile_id, error_reason, slot_reserved = channel.get_stream()
 
         if not stream_id or not profile_id:
             logger.error(f"No stream available for channel {channel_id}: {error_reason}")
-            return None, None, False, None
+            return None, None, False, None, False, error_reason
 
         # get_stream() allocated a connection slot - ensure it's released on any error
         try:
@@ -106,9 +136,7 @@ def generate_stream_url(channel_id: str) -> Tuple[str, str, bool, Optional[int]]
                 stream_user_agent = UserAgent.objects.get(id=CoreSettings.get_default_user_agent_id())
                 logger.debug(f"No user agent found for account, using default: {stream_user_agent}")
 
-            # Generate stream URL based on the selected profile
-            input_url = stream.url
-            stream_url = transform_url(input_url, m3u_profile.search_pattern, m3u_profile.replace_pattern)
+            stream_url = _resolve_live_stream_url(stream, m3u_account, m3u_profile)
 
             # Check if transcoding is needed
             stream_profile = channel.get_stream_profile()
@@ -119,15 +147,18 @@ def generate_stream_url(channel_id: str) -> Tuple[str, str, bool, Optional[int]]
 
             stream_profile_id = stream_profile.id
 
-            return stream_url, stream_user_agent, transcode, stream_profile_id
+            return stream_url, stream_user_agent, transcode, stream_profile_id, slot_reserved, None
         except Exception as e:
             logger.error(f"Error generating stream URL for channel {channel_id}: {e}")
-            if not channel.release_stream():
-                logger.warning(f"Failed to release stream for channel {channel_id} after URL generation error")
-            return None, None, False, None
+            if slot_reserved:
+                if not channel.release_stream():
+                    logger.warning(f"Failed to release stream for channel {channel_id} after URL generation error")
+            return None, None, False, None, False, str(e)
     except Exception as e:
         logger.error(f"Error generating stream URL: {e}")
-        return None, None, False, None
+        return None, None, False, None, False, str(e)
+    finally:
+        close_old_connections()
 
 def transform_url(input_url: str, search_pattern: str, replace_pattern: str) -> str:
     """
@@ -175,6 +206,8 @@ def get_stream_info_for_switch(channel_id: str, target_stream_id: Optional[int]
     Returns:
         dict: Stream information including URL, user agent and transcode flag
     """
+    slot_reserved = False
+    channel = None
     try:
         from core.utils import RedisClient
 
@@ -204,35 +237,34 @@ def get_stream_info_for_switch(channel_id: str, target_stream_id: Optional[int]
 
             selected_profile = None
             for profile in profiles:
-
-                # Check connection availability
                 if redis_client:
-                    profile_connections_key = f"profile_connections:{profile.id}"
-                    current_connections = int(redis_client.get(profile_connections_key) or 0)
-
-                    # Check if this channel is already using this profile
                     channel_using_profile = False
                     existing_stream_id = redis_client.get(f"channel_stream:{channel.id}")
                     if existing_stream_id:
-                        # Decode bytes to string/int for proper Redis key lookup
-                        existing_stream_id = existing_stream_id
-                        existing_profile_id = redis_client.get(f"stream_profile:{existing_stream_id}")
+                        existing_profile_id = redis_client.get(
+                            f"stream_profile:{existing_stream_id}"
+                        )
                         if existing_profile_id and int(existing_profile_id) == profile.id:
                             channel_using_profile = True
-                            logger.debug(f"Channel {channel.id} already using profile {profile.id}")
 
-                    # Calculate effective connections (subtract 1 if channel already using this profile)
-                    effective_connections = current_connections - (1 if channel_using_profile else 0)
-
-                    # Check if profile has available slots
-                    if profile.max_streams == 0 or effective_connections < profile.max_streams:
+                    if profile_available_for_channel_switch(
+                        profile,
+                        redis_client,
+                        channel_already_on_profile=channel_using_profile,
+                    ):
+                        current_connections = get_profile_connection_count(
+                            profile, redis_client
+                        )
                         selected_profile = profile
-                        logger.debug(f"Selected profile {profile.id} with {effective_connections}/{profile.max_streams} effective connections (current: {current_connections}, already using: {channel_using_profile})")
+                        logger.debug(
+                            f"Selected profile {profile.id} with "
+                            f"{current_connections}/{profile.max_streams} connections"
+                        )
                         break
-                    else:
-                        logger.debug(f"Profile {profile.id} at max connections: {effective_connections}/{profile.max_streams} (current: {current_connections}, already using: {channel_using_profile})")
+                    logger.debug(
+                        f"Profile {profile.id} unavailable for channel switch"
+                    )
                 else:
-                    # No Redis available, assume first active profile is okay
                     selected_profile = profile
                     break
 
@@ -241,29 +273,18 @@ def get_stream_info_for_switch(channel_id: str, target_stream_id: Optional[int]
 
             m3u_profile_id = selected_profile.id
         else:
-            stream_id, m3u_profile_id, error_reason = channel.get_stream()
+            stream_id, m3u_profile_id, error_reason, slot_reserved = channel.get_stream()
             if stream_id is None or m3u_profile_id is None:
                 return {'error': error_reason or 'No stream assigned to channel'}
 
-        # Get the stream and profile objects directly
         stream = get_object_or_404(Stream, pk=stream_id)
         profile = get_object_or_404(M3UAccountProfile, pk=m3u_profile_id)
 
-        # Check connections left
         m3u_account = M3UAccount.objects.get(id=profile.m3u_account.id)
-        #connections_left = get_connections_left(m3u_profile_id)
-
-        #if connections_left <= 0:
-            #logger.warning(f"No connections left for M3U account {m3u_account.id}")
-            #return {'error': 'No connections left'}
-
-        # Get the user agent from the M3U account
         user_agent = m3u_account.get_user_agent().user_agent
 
-        # Generate URL using the transform function directly
-        stream_url = transform_url(stream.url, profile.search_pattern, profile.replace_pattern)
+        stream_url = _resolve_live_stream_url(stream, m3u_account, profile)
 
-        # Get transcode info from the channel's stream profile
         stream_profile = channel.get_stream_profile()
         transcode = not (stream_profile.is_proxy() or stream_profile is None)
         profile_value = stream_profile.id
@@ -278,8 +299,12 @@ def get_stream_info_for_switch(channel_id: str, target_stream_id: Optional[int]
             'stream_name': stream.name,
         }
     except Exception as e:
+        if slot_reserved and channel is not None:
+            channel.release_stream()
         logger.error(f"Error getting stream info for switch: {e}", exc_info=True)
         return {'error': f'Error: {str(e)}'}
+    finally:
+        close_old_connections()
 
 def get_alternate_streams(channel_id: str, current_stream_id: Optional[int] = None) -> List[dict]:
     """
@@ -344,34 +369,38 @@ def get_alternate_streams(channel_id: str, current_stream_id: Optional[int] = No
 
                 selected_profile = None
                 for profile in profiles:
-                    # Check connection availability
                     if redis_client:
-                        profile_connections_key = f"profile_connections:{profile.id}"
-                        current_connections = int(redis_client.get(profile_connections_key) or 0)
-
-                        # Check if this channel is already using this profile
                         channel_using_profile = False
                         existing_stream_id = redis_client.get(f"channel_stream:{channel.id}")
                         if existing_stream_id:
-                            # Decode bytes to string/int for proper Redis key lookup
-                            existing_stream_id = existing_stream_id
-                            existing_profile_id = redis_client.get(f"stream_profile:{existing_stream_id}")
+                            existing_profile_id = redis_client.get(
+                                f"stream_profile:{existing_stream_id}"
+                            )
                             if existing_profile_id and int(existing_profile_id) == profile.id:
                                 channel_using_profile = True
-                                logger.debug(f"Channel {channel.id} already using profile {profile.id}")
+                                logger.debug(
+                                    f"Channel {channel.id} already using profile {profile.id}"
+                                )
 
-                        # Calculate effective connections (subtract 1 if channel already using this profile)
-                        effective_connections = current_connections - (1 if channel_using_profile else 0)
-
-                        # Check if profile has available slots
-                        if profile.max_streams == 0 or effective_connections < profile.max_streams:
+                        if profile_available_for_channel_switch(
+                            profile,
+                            redis_client,
+                            channel_already_on_profile=channel_using_profile,
+                        ):
+                            current_connections = get_profile_connection_count(
+                                profile, redis_client
+                            )
                             selected_profile = profile
-                            logger.debug(f"Found available profile {profile.id} for stream {stream.id}: {effective_connections}/{profile.max_streams} effective (current: {current_connections}, already using: {channel_using_profile})")
+                            logger.debug(
+                                f"Found available profile {profile.id} for stream {stream.id}: "
+                                f"{current_connections}/{profile.max_streams} "
+                                f"(already using: {channel_using_profile})"
+                            )
                             break
-                        else:
-                            logger.debug(f"Profile {profile.id} at max connections: {effective_connections}/{profile.max_streams} (current: {current_connections}, already using: {channel_using_profile})")
+                        logger.debug(
+                            f"Profile {profile.id} unavailable for alternate stream {stream.id}"
+                        )
                     else:
-                        # No Redis available, assume first active profile is okay
                         selected_profile = profile
                         break
 
@@ -398,6 +427,8 @@ def get_alternate_streams(channel_id: str, current_stream_id: Optional[int] = No
     except Exception as e:
         logger.error(f"Error getting alternate streams for channel {channel_id}: {e}", exc_info=True)
         return []
+    finally:
+        close_old_connections()
 
 def validate_stream_url(url, user_agent=None, timeout=(5, 5)):
     """
@@ -568,3 +599,5 @@ def get_connections_left(m3u_profile_id: int) -> int:
     except Exception as e:
         logger.error(f"Error getting connections left for M3U profile {m3u_profile_id}: {e}")
         return 0
+    finally:
+        close_old_connections()
diff --git a/apps/proxy/live_proxy/views.py b/apps/proxy/live_proxy/views.py
index d882bfca..001cfc14 100644
--- a/apps/proxy/live_proxy/views.py
+++ b/apps/proxy/live_proxy/views.py
@@ -3,6 +3,7 @@ import time
 import random
 import re
 import pathlib
+from django.db import close_old_connections
 from django.http import StreamingHttpResponse, JsonResponse, HttpResponseRedirect, HttpResponse
 from django.views.decorators.csrf import csrf_exempt
 from django.shortcuts import get_object_or_404
@@ -43,6 +44,15 @@ from apps.proxy.utils import check_user_stream_limits
 logger = get_logger()
 
 
+def _channel_stopping_response():
+    response = JsonResponse(
+        {"error": "Channel is stopping, retry shortly"},
+        status=503,
+    )
+    response["Retry-After"] = "1"
+    return response
+
+
 def _resolve_output_format(user, force=None, request=None):
     """Return the output format string to use for this client."""
     _FORMAT_ALIASES = {
@@ -123,6 +133,12 @@ def stream_ts(request, channel_id, user=None, force_output_format=None):
                     status=429
                 )
 
+        if ChannelService.is_channel_unavailable_for_new_clients(channel_id):
+            logger.info(
+                f"[{client_id}] Channel {channel_id} unavailable. Teardown or pending shutdown"
+            )
+            return _channel_stopping_response()
+
         # Check if we need to reinitialize the channel
         needs_initialization = True
         channel_state = None
@@ -144,7 +160,6 @@ def stream_ts(request, channel_id, user=None, force_output_format=None):
                         ChannelState.BUFFERING,
                         ChannelState.INITIALIZING,
                         ChannelState.CONNECTING,
-                        ChannelState.STOPPING,
                     ]:
                         needs_initialization = False
                         logger.debug(
@@ -160,6 +175,11 @@ def stream_ts(request, channel_id, user=None, force_output_format=None):
                             logger.debug(
                                 f"[{client_id}] Channel {channel_id} is still initializing, client will wait"
                             )
+                    elif channel_state == ChannelState.STOPPING:
+                        logger.info(
+                            f"[{client_id}] Channel {channel_id} is stopping, rejecting request"
+                        )
+                        return _channel_stopping_response()
                     # Terminal states - channel needs cleanup before reinitialization
                     elif channel_state in [
                         ChannelState.ERROR,
@@ -192,6 +212,12 @@ def stream_ts(request, channel_id, user=None, force_output_format=None):
 
         # Start initialization if needed
         if needs_initialization or not proxy_server.check_if_channel_exists(channel_id):
+            if ChannelService.is_channel_unavailable_for_new_clients(channel_id):
+                logger.info(
+                    f"[{client_id}] Channel {channel_id} became unavailable before init, rejecting"
+                )
+                return _channel_stopping_response()
+
             logger.info(f"[{client_id}] Starting channel {channel_id} initialization")
             # Force cleanup of any previous instance if in terminal state
             if channel_state in [
@@ -213,6 +239,7 @@ def stream_ts(request, channel_id, user=None, force_output_format=None):
             stream_user_agent = None
             transcode = False
             profile_value = None
+            slot_reserved = False
             error_reason = None
             attempt = 0
             should_retry = True
@@ -220,9 +247,14 @@ def stream_ts(request, channel_id, user=None, force_output_format=None):
             # Try to get a stream with fixed interval retries
             while should_retry and time.time() - wait_start_time < retry_timeout:
                 attempt += 1
-                stream_url, stream_user_agent, transcode, profile_value = (
-                    generate_stream_url(channel_id)
-                )
+                (
+                    stream_url,
+                    stream_user_agent,
+                    transcode,
+                    profile_value,
+                    slot_reserved,
+                    error_reason,
+                ) = generate_stream_url(channel_id)
 
                 if stream_url is not None:
                     logger.info(
@@ -232,7 +264,6 @@ def stream_ts(request, channel_id, user=None, force_output_format=None):
 
                 # On first failure, check if the error is retryable
                 if attempt == 1:
-                    _, _, error_reason = channel.get_stream()
                     if error_reason and "maximum connection limits" not in error_reason:
                         logger.warning(
                             f"[{client_id}] Can't retry - error not related to connection limits: {error_reason}"
@@ -265,18 +296,21 @@ def stream_ts(request, channel_id, user=None, force_output_format=None):
                 logger.info(
                     f"[{client_id}] Making final attempt {attempt} at timeout boundary"
                 )
-                stream_url, stream_user_agent, transcode, profile_value = (
-                    generate_stream_url(channel_id)
-                )
+                (
+                    stream_url,
+                    stream_user_agent,
+                    transcode,
+                    profile_value,
+                    slot_reserved,
+                    error_reason,
+                ) = generate_stream_url(channel_id)
                 if stream_url is not None:
                     logger.info(
                         f"[{client_id}] Successfully obtained stream on final attempt for channel {channel_id}"
                     )
 
             if stream_url is None:
-                # Release any connection slot that may have been allocated
-                # by the error-checking get_stream() call during retries
-                if not channel.release_stream():
+                if slot_reserved and not channel.release_stream():
                     logger.debug(f"[{client_id}] release_stream found no keys during failed init cleanup")
 
                 # Get the specific error message if available
@@ -295,7 +329,7 @@ def stream_ts(request, channel_id, user=None, force_output_format=None):
 
             # generate_stream_url() called get_stream() which allocated a connection
             # slot (INCR'd profile_connections) - track this for cleanup on error
-            if needs_initialization:
+            if needs_initialization and slot_reserved:
                 connection_allocated = True
 
             # Read stream assignment from Redis (already set by generate_stream_url → get_stream).
@@ -378,8 +412,8 @@ def stream_ts(request, channel_id, user=None, force_output_format=None):
                             logger.warning(
                                 f"[{client_id}] Alternate stream #{alt['stream_id']} failed validation: {message}"
                             )
-                # Release stream lock before redirecting
-                if not channel.release_stream():
+                # Release stream lock before redirecting only if we reserved a slot
+                if connection_allocated and not channel.release_stream():
                     logger.warning(f"[{client_id}] Failed to release stream before redirect")
                 connection_allocated = False
                 # Final decision based on validation results
@@ -406,6 +440,16 @@ def stream_ts(request, channel_id, user=None, force_output_format=None):
                     )  # 502 Bad Gateway
 
             # Initialize channel with the stream's user agent (not the client's)
+            if ChannelService.is_channel_unavailable_for_new_clients(channel_id):
+                if connection_allocated:
+                    if not channel.release_stream():
+                        logger.warning(f"[{client_id}] Failed to release stream before teardown reject")
+                    connection_allocated = False
+                logger.info(
+                    f"[{client_id}] Channel {channel_id} unavailable before init call, rejecting"
+                )
+                return _channel_stopping_response()
+
             success = ChannelService.initialize_channel(
                 channel_id,
                 stream_url,
@@ -514,6 +558,16 @@ def stream_ts(request, channel_id, user=None, force_output_format=None):
                 f"[{client_id}] Successfully initialized channel {channel_id} locally"
             )
 
+        if ChannelService.is_channel_unavailable_for_new_clients(channel_id):
+            if _client_pre_registered:
+                mgr = proxy_server.client_managers.get(channel_id)
+                if mgr:
+                    mgr.remove_client(client_id)
+            logger.info(
+                f"[{client_id}] Channel {channel_id} became unavailable during setup, rejecting"
+            )
+            return _channel_stopping_response()
+
         # Register client
         output_profile = _resolve_output_profile(request, user)
         if output_profile:
@@ -564,7 +618,9 @@ def stream_ts(request, channel_id, user=None, force_output_format=None):
             )
             content_type = "video/mp2t"
 
-        # Return the StreamingHttpResponse from the main function
+        # Release ORM checkout before returning a long-lived StreamingHttpResponse.
+        close_old_connections()
+
         response = StreamingHttpResponse(
             streaming_content=generate(), content_type=content_type
         )
diff --git a/apps/proxy/vod_proxy/multi_worker_connection_manager.py b/apps/proxy/vod_proxy/multi_worker_connection_manager.py
index 7d367531..8d803dcf 100644
--- a/apps/proxy/vod_proxy/multi_worker_connection_manager.py
+++ b/apps/proxy/vod_proxy/multi_worker_connection_manager.py
@@ -735,68 +735,35 @@ class MultiWorkerVODConnectionManager:
         """Get Redis key for tracking connections per profile - STANDARDIZED with TS proxy"""
         return f"profile_connections:{profile_id}"
 
-    def _check_profile_limits(self, m3u_profile) -> bool:
-        """Check if profile has available connection slots"""
-        if m3u_profile.max_streams == 0:  # Unlimited
-            return True
-
-        try:
-            profile_connections_key = self._get_profile_connections_key(m3u_profile.id)
-            current_connections = int(self.redis_client.get(profile_connections_key) or 0)
-
-            logger.info(f"[PROFILE-CHECK] Profile {m3u_profile.id} has {current_connections}/{m3u_profile.max_streams} connections")
-            return current_connections < m3u_profile.max_streams
-
-        except Exception as e:
-            logger.error(f"Error checking profile limits: {e}")
-            return False
-
     def _check_and_reserve_profile_slot(self, m3u_profile) -> bool:
         """
         Atomically check and reserve a connection slot for the given profile.
 
-        Uses an INCR-first-then-check pattern to eliminate the TOCTOU race
-        condition where separate GET > check > INCR operations could allow
-        concurrent requests to both pass the capacity check.
-
-        For profiles with max_streams=0 (unlimited), no reservation is needed.
-
         Returns:
             bool: True if slot was reserved (or unlimited), False if at capacity
         """
-        if m3u_profile.max_streams == 0:  # Unlimited
-            return True
+        from apps.m3u.connection_pool import reserve_profile_slot
 
         try:
-            profile_connections_key = self._get_profile_connections_key(m3u_profile.id)
-
-            # Atomically increment first — single Redis command eliminates race window
-            new_count = self.redis_client.incr(profile_connections_key)
-
-            if new_count <= m3u_profile.max_streams:
-                logger.info(f"[PROFILE-RESERVE] Profile {m3u_profile.id} slot reserved: {new_count}/{m3u_profile.max_streams}")
-                return True
-
-            # Over capacity — roll back the increment
-            self.redis_client.decr(profile_connections_key)
-            logger.info(f"[PROFILE-RESERVE] Profile {m3u_profile.id} at capacity: {new_count - 1}/{m3u_profile.max_streams}")
-            return False
+            reserved, new_count, _failure_reason = reserve_profile_slot(
+                m3u_profile, self.redis_client
+            )
+            if reserved:
+                logger.info(
+                    f"[PROFILE-RESERVE] Profile {m3u_profile.id} slot reserved: "
+                    f"{new_count}/{m3u_profile.max_streams}"
+                )
+            else:
+                logger.info(
+                    f"[PROFILE-RESERVE] Profile {m3u_profile.id} at capacity: "
+                    f"{new_count}/{m3u_profile.max_streams}"
+                )
+            return reserved
 
         except Exception as e:
             logger.error(f"Error reserving profile slot: {e}")
             return False
 
-    def _increment_profile_connections(self, m3u_profile):
-        """Increment profile connection count"""
-        try:
-            profile_connections_key = self._get_profile_connections_key(m3u_profile.id)
-            new_count = self.redis_client.incr(profile_connections_key)
-            logger.info(f"[PROFILE-INCR] Profile {m3u_profile.id} connections: {new_count}")
-            return new_count
-        except Exception as e:
-            logger.error(f"Error incrementing profile connections: {e}")
-            return None
-
     def _trigger_vod_stats_update(self):
         """Trigger a VOD stats WebSocket update in a background thread."""
         threading.Thread(target=self._do_vod_stats_update, daemon=True).start()
@@ -859,21 +826,14 @@ class MultiWorkerVODConnectionManager:
             logger.error(f"Failed to trigger VOD stats update: {e}")
 
     def _decrement_profile_connections(self, m3u_profile_id: int):
-        """Decrement profile connection count.
+        """Decrement profile and shared pool connection counters."""
+        from apps.m3u.connection_pool import release_profile_slot
 
-        Uses a single atomic DECR (no GET-before-DECR) to avoid the race condition
-        where two concurrent decrements both pass a >0 guard and both fire, sending
-        the counter negative. If the counter would go below zero it is clamped to 0.
-        """
         try:
-            profile_connections_key = self._get_profile_connections_key(m3u_profile_id)
-            new_count = self.redis_client.decr(profile_connections_key)
-            if new_count < 0:
-                self.redis_client.set(profile_connections_key, 0)
-                new_count = 0
-                logger.warning(f"[PROFILE-DECR] Profile {m3u_profile_id} counter went negative, clamped to 0")
-            else:
-                logger.info(f"[PROFILE-DECR] Profile {m3u_profile_id} connections: {new_count}")
+            release_profile_slot(m3u_profile_id, self.redis_client)
+            profile_key = self._get_profile_connections_key(m3u_profile_id)
+            new_count = int(self.redis_client.get(profile_key) or 0)
+            logger.info(f"[PROFILE-DECR] Profile {m3u_profile_id} connections: {new_count}")
             return new_count
         except Exception as e:
             logger.error(f"Error decrementing profile connections: {e}")
diff --git a/apps/proxy/vod_proxy/tests/test_vod_db_cleanup.py b/apps/proxy/vod_proxy/tests/test_vod_db_cleanup.py
new file mode 100644
index 00000000..5d009803
--- /dev/null
+++ b/apps/proxy/vod_proxy/tests/test_vod_db_cleanup.py
@@ -0,0 +1,146 @@
+"""VOD proxy must release geventpool checkouts after ORM on stream and stats paths."""
+
+from unittest.mock import MagicMock, patch
+
+from django.http import StreamingHttpResponse
+from django.test import RequestFactory, SimpleTestCase
+
+
+class StreamVodDbCleanupTests(SimpleTestCase):
+    def setUp(self):
+        self.factory = RequestFactory()
+
+    @patch("apps.proxy.vod_proxy.views.close_old_connections")
+    @patch("apps.proxy.vod_proxy.views.MultiWorkerVODConnectionManager")
+    @patch("apps.proxy.vod_proxy.views._transform_url", return_value="http://example.com/movie.mp4")
+    @patch("apps.proxy.vod_proxy.views._get_m3u_profile")
+    @patch("apps.proxy.vod_proxy.views._get_stream_url_from_relation", return_value="http://upstream/movie.mp4")
+    @patch("apps.proxy.vod_proxy.views._get_content_and_relation")
+    @patch("apps.proxy.vod_proxy.views.network_access_allowed", return_value=True)
+    def test_stream_vod_closes_db_before_streaming_response(
+        self,
+        _network_ok,
+        mock_content,
+        _stream_url,
+        mock_profile,
+        _transform,
+        mock_manager_cls,
+        mock_close,
+    ):
+        movie = MagicMock()
+        movie.name = "Test Movie"
+        relation = MagicMock()
+        relation.m3u_account.name = "Provider"
+        mock_content.return_value = (movie, relation)
+
+        profile = MagicMock()
+        profile.id = 1
+        profile.max_streams = 5
+        mock_profile.return_value = (profile, 0)
+
+        mock_manager = MagicMock()
+        mock_manager.stream_content_with_session.return_value = StreamingHttpResponse(
+            streaming_content=iter([b"data"]),
+            content_type="video/mp4",
+        )
+        mock_manager_cls.get_instance.return_value = mock_manager
+
+        request = self.factory.get(
+            "/proxy/vod/movie/uuid/session123/",
+            HTTP_USER_AGENT="test-agent",
+        )
+        request.user = MagicMock(is_authenticated=False)
+
+        from apps.proxy.vod_proxy.views import stream_vod
+
+        response = stream_vod(
+            request,
+            content_type="movie",
+            content_id="uuid",
+            session_id="session123",
+        )
+
+        self.assertIsInstance(response, StreamingHttpResponse)
+        mock_close.assert_called_once()
+        mock_manager.stream_content_with_session.assert_called_once()
+
+
+class BuildVodStatsDbCleanupTests(SimpleTestCase):
+    @patch("apps.proxy.vod_proxy.views.close_old_connections")
+    @patch("apps.proxy.vod_proxy.views.Movie")
+    def test_build_vod_stats_data_closes_db(self, mock_movie, mock_close):
+        redis_client = MagicMock()
+        redis_client.scan.side_effect = [
+            (0, ["vod_persistent_connection:s1"]),
+        ]
+        redis_client.hgetall.return_value = {
+            "content_obj_type": "movie",
+            "content_uuid": "movie-uuid",
+            "content_name": "Test Movie",
+            "m3u_profile_id": "1",
+            "client_ip": "127.0.0.1",
+            "client_user_agent": "agent",
+            "connected_at": "1000.0",
+            "last_activity": "1001.0",
+            "active_streams": "1",
+        }
+
+        movie_obj = MagicMock(
+            name="Test Movie",
+            logo=None,
+            year=2020,
+            rating=7.5,
+            genre="Action",
+            description="Desc",
+            tmdb_id="1",
+            imdb_id="tt1",
+        )
+        mock_movie.objects.select_related.return_value.get.return_value = movie_obj
+
+        with patch("apps.m3u.models.M3UAccountProfile") as mock_profile_model:
+            mock_profile_model.objects.select_related.return_value.get.return_value = MagicMock(
+                name="Profile 1",
+                m3u_account=MagicMock(name="Account", id=1),
+            )
+
+            from apps.proxy.vod_proxy.views import build_vod_stats_data
+
+            stats = build_vod_stats_data(redis_client)
+
+        self.assertEqual(stats["total_connections"], 1)
+        mock_close.assert_called_once()
+
+    @patch("apps.proxy.vod_proxy.views.close_old_connections")
+    def test_build_vod_stats_data_closes_db_on_error(self, mock_close):
+        redis_client = MagicMock()
+        redis_client.scan.side_effect = RuntimeError("redis down")
+
+        from apps.proxy.vod_proxy.views import build_vod_stats_data
+
+        stats = build_vod_stats_data(redis_client)
+
+        self.assertEqual(stats["total_connections"], 0)
+        mock_close.assert_called_once()
+
+
+class VodStatsUpdateDbCleanupTests(SimpleTestCase):
+    @patch("core.utils.send_websocket_update")
+    @patch("apps.proxy.vod_proxy.views.build_vod_stats_data")
+    def test_do_vod_stats_update_uses_build_vod_stats_data(self, mock_build, mock_ws):
+        mock_build.return_value = {
+            "vod_connections": [],
+            "total_connections": 0,
+            "timestamp": 0,
+        }
+
+        from apps.proxy.vod_proxy.multi_worker_connection_manager import (
+            MultiWorkerVODConnectionManager,
+        )
+
+        manager = MultiWorkerVODConnectionManager.__new__(MultiWorkerVODConnectionManager)
+        manager.redis_client = MagicMock()
+
+        manager._do_vod_stats_update()
+
+        mock_build.assert_called_once_with(manager.redis_client)
+        mock_ws.assert_called_once()
diff --git a/apps/proxy/vod_proxy/views.py b/apps/proxy/vod_proxy/views.py
index 9b330197..fef8fed0 100644
--- a/apps/proxy/vod_proxy/views.py
+++ b/apps/proxy/vod_proxy/views.py
@@ -8,6 +8,7 @@ import random
 import logging
 import requests
 from urllib.parse import urlencode
+from django.db import close_old_connections
 from django.http import  JsonResponse, Http404, HttpResponse
 from django.shortcuts import get_object_or_404
 from django.views.decorators.csrf import csrf_exempt
@@ -23,6 +24,7 @@ from rest_framework_simplejwt.authentication import JWTAuthentication
 from apps.accounts.authentication import ApiKeyAuthentication, QueryParamJWTAuthentication
 from apps.proxy.utils import check_user_stream_limits
 from dispatcharr.utils import network_access_allowed
+from core.utils import dispatcharr_user_agent
 
 logger = logging.getLogger(__name__)
 
@@ -260,6 +262,10 @@ def _get_m3u_profile(m3u_account, profile_id, session_id=None):
     """
     try:
         from core.utils import RedisClient
+        from apps.m3u.connection_pool import (
+            get_profile_connection_count,
+            pool_has_capacity_for_profile,
+        )
         redis_client = RedisClient.get_client()
 
         if not redis_client:
@@ -296,7 +302,11 @@ def _get_m3u_profile(m3u_account, profile_id, session_id=None):
                     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
+                    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(
@@ -306,13 +316,12 @@ def _get_m3u_profile(m3u_account, profile_id, session_id=None):
                 )
                 # Check Redis-based current connections
                 profile_connections_key = f"profile_connections:{profile.id}"
-                current_connections = int(redis_client.get(profile_connections_key) or 0)
+                current_connections = get_profile_connection_count(profile, redis_client)
 
-                if profile.max_streams == 0 or current_connections < profile.max_streams:
+                if pool_has_capacity_for_profile(profile, redis_client):
                     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}")
+                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")
 
@@ -331,15 +340,16 @@ def _get_m3u_profile(m3u_account, profile_id, session_id=None):
         profiles = [default_profile] + list(m3u_profiles.filter(is_default=False))
 
         for profile in profiles:
-            profile_connections_key = f"profile_connections:{profile.id}"
-            current_connections = int(redis_client.get(profile_connections_key) or 0)
+            current_connections = get_profile_connection_count(profile, redis_client)
 
-            # Check if profile has available connection slots
-            if profile.max_streams == 0 or current_connections < profile.max_streams:
+            if pool_has_capacity_for_profile(profile, redis_client):
                 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}")
+                logger.debug(
+                    f"[PROFILE-SELECTION] Profile {profile.id} unavailable "
+                    f"(profile={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")
@@ -592,6 +602,9 @@ def stream_vod(request, content_type, content_id, session_id=None, profile_id=No
         # Get connection manager (Redis-backed for multi-worker support)
         connection_manager = MultiWorkerVODConnectionManager.get_instance()
 
+        # Release ORM checkout before returning a long-lived StreamingHttpResponse.
+        close_old_connections()
+
         # Stream the content with session-based connection reuse
         logger.info("[VOD-STREAM] Calling connection manager to stream content")
         response = connection_manager.stream_content_with_session(
@@ -696,7 +709,7 @@ def head_vod(request, content_type, content_id, session_id=None, profile_id=None
         # Use M3U account's user agent as primary, client user agent as fallback
         m3u_user_agent = m3u_account.get_user_agent().user_agent if m3u_account.get_user_agent() else None
         headers = {
-            'User-Agent': m3u_user_agent or client_user_agent or 'Dispatcharr/1.0',
+            'User-Agent': m3u_user_agent or client_user_agent or dispatcharr_user_agent(),
             'Accept': '*/*',
             'Range': 'bytes=0-1'  # Request only first 2 bytes
         }
@@ -906,13 +919,14 @@ def build_vod_stats_data(redis_client):
                         if m3u_profile_id:
                             try:
                                 from apps.m3u.models import M3UAccountProfile
+
                                 profile = M3UAccountProfile.objects.select_related('m3u_account').get(id=m3u_profile_id)
                                 m3u_profile_info = {
                                     'profile_name': profile.name,
                                     'account_name': profile.m3u_account.name,
                                     'account_id': profile.m3u_account.id,
                                     'max_streams': profile.m3u_account.max_streams,
-                                    'm3u_profile_id': int(m3u_profile_id)
+                                    'm3u_profile_id': int(m3u_profile_id),
                                 }
                             except Exception as e:
                                 logger.warning(f"Could not fetch M3U profile {m3u_profile_id}: {e}")
@@ -1053,6 +1067,8 @@ def build_vod_stats_data(redis_client):
     except Exception as e:
         logger.error(f"Error building VOD stats: {e}")
         return {'vod_connections': [], 'total_connections': 0, 'timestamp': time.time()}
+    finally:
+        close_old_connections()
 
 
 @api_view(["GET"])
diff --git a/apps/vod/models.py b/apps/vod/models.py
index dd7d1753..f609be81 100644
--- a/apps/vod/models.py
+++ b/apps/vod/models.py
@@ -243,12 +243,12 @@ class M3UMovieRelation(models.Model):
 
     def get_stream_url(self):
         """Get the full stream URL for this movie from this provider"""
-        # Build URL dynamically for XtreamCodes accounts
         if self.m3u_account.account_type == 'XC':
-            from core.xtream_codes import Client as XCClient
-            # Use XC client's URL normalization to handle malformed URLs
-            # (e.g., URLs with /player_api.php or query parameters)
-            normalized_url = XCClient(self.m3u_account.server_url, '', '')._normalize_url(self.m3u_account.server_url)
+            from core.xtream_codes import normalize_server_url
+
+            normalized_url = normalize_server_url(self.m3u_account.server_url)
+            if not normalized_url:
+                return None
             username = self.m3u_account.username
             password = self.m3u_account.password
             return f"{normalized_url}/movie/{username}/{password}/{self.stream_id}.{self.container_extension or 'mp4'}"
@@ -292,13 +292,12 @@ class M3UEpisodeRelation(models.Model):
 
     def get_stream_url(self):
         """Get the full stream URL for this episode from this provider"""
-        from core.xtream_codes import Client as XtreamCodesClient
-
         if self.m3u_account.account_type == 'XC':
-            # For XtreamCodes accounts, build the URL dynamically
-            # Use XC client's URL normalization to handle malformed URLs
-            # (e.g., URLs with /player_api.php or query parameters)
-            normalized_url = XtreamCodesClient(self.m3u_account.server_url, '', '')._normalize_url(self.m3u_account.server_url)
+            from core.xtream_codes import normalize_server_url
+
+            normalized_url = normalize_server_url(self.m3u_account.server_url)
+            if not normalized_url:
+                return None
             username = self.m3u_account.username
             password = self.m3u_account.password
             return f"{normalized_url}/series/{username}/{password}/{self.stream_id}.{self.container_extension or 'mp4'}"
diff --git a/apps/vod/tasks.py b/apps/vod/tasks.py
index 367baff3..66566745 100644
--- a/apps/vod/tasks.py
+++ b/apps/vod/tasks.py
@@ -16,6 +16,27 @@ import re
 logger = logging.getLogger(__name__)
 
 
+def lookup_by_name_year(model, name_year_pairs):
+    """Return {(name, year): row} for rows without TMDB/IMDB IDs.
+
+    Scoped to the names in this batch instead of scanning the full table.
+    """
+    if not name_year_pairs:
+        return {}
+    wanted = set(name_year_pairs)
+    names = {name for name, _ in wanted}
+    found = {}
+    for row in model.objects.filter(
+        tmdb_id__isnull=True,
+        imdb_id__isnull=True,
+        name__in=names,
+    ):
+        key = (row.name, row.year)
+        if key in wanted:
+            found[key] = row
+    return found
+
+
 @shared_task
 def refresh_vod_content(account_id):
     """Refresh VOD content for an M3U account with batch processing for improved performance"""
@@ -176,6 +197,7 @@ def refresh_movies(client, account, categories_by_provider, relations, scan_star
         logger.info(f"Processing movie chunk {chunk_num}/{total_chunks} ({len(chunk)} movies)")
         process_movie_batch(account, chunk, categories_by_provider, relations, scan_start_time)
 
+    del all_movies_data
     logger.info(f"Completed processing all {total_movies} movies in {total_chunks} chunks")
 
 
@@ -230,6 +252,7 @@ def refresh_series(client, account, categories_by_provider, relations, scan_star
         logger.info(f"Processing series chunk {chunk_num}/{total_chunks} ({len(chunk)} series)")
         process_series_batch(account, chunk, categories_by_provider, relations, scan_start_time)
 
+    del all_series_data
     logger.info(f"Completed processing all {total_series} series in {total_chunks} chunks")
 
 
@@ -539,10 +562,12 @@ def process_movie_batch(account, batch, categories, relations, scan_start_time=N
     # Query by name+year for movies without external IDs
     name_year_keys = [k for k in movie_keys.keys() if k.startswith('name_')]
     if name_year_keys:
-        for movie in Movie.objects.filter(tmdb_id__isnull=True, imdb_id__isnull=True):
-            key = f"name_{movie.name}_{movie.year or 'None'}"
-            if key in name_year_keys:
-                existing_movies[key] = movie
+        name_year_pairs = [
+            (movie_keys[k]['props']['name'], movie_keys[k]['props'].get('year'))
+            for k in name_year_keys
+        ]
+        for key_tuple, movie in lookup_by_name_year(Movie, name_year_pairs).items():
+            existing_movies[f"name_{key_tuple[0]}_{key_tuple[1] or 'None'}"] = movie
 
     # Get existing relations
     stream_ids = [data['stream_id'] for data in movie_keys.values()]
@@ -659,12 +684,7 @@ def process_movie_batch(account, batch, categories, relations, scan_start_time=N
                 existing_by_tmdb = {m.tmdb_id: m for m in Movie.objects.filter(tmdb_id__in=tmdb_ids)} if tmdb_ids else {}
                 existing_by_imdb = {m.imdb_id: m for m in Movie.objects.filter(imdb_id__in=imdb_ids)} if imdb_ids else {}
 
-                existing_by_name_year = {}
-                if name_year_pairs:
-                    for movie in Movie.objects.filter(tmdb_id__isnull=True, imdb_id__isnull=True):
-                        key = (movie.name, movie.year)
-                        if key in name_year_pairs:
-                            existing_by_name_year[key] = movie
+                existing_by_name_year = lookup_by_name_year(Movie, name_year_pairs)
 
                 # Check each movie against the bulk query results
                 movies_actually_created = []
@@ -911,10 +931,12 @@ def process_series_batch(account, batch, categories, relations, scan_start_time=
     # Query by name+year for series without external IDs
     name_year_keys = [k for k in series_keys.keys() if k.startswith('name_')]
     if name_year_keys:
-        for series in Series.objects.filter(tmdb_id__isnull=True, imdb_id__isnull=True):
-            key = f"name_{series.name}_{series.year or 'None'}"
-            if key in name_year_keys:
-                existing_series[key] = series
+        name_year_pairs = [
+            (series_keys[k]['props']['name'], series_keys[k]['props'].get('year'))
+            for k in name_year_keys
+        ]
+        for key_tuple, series in lookup_by_name_year(Series, name_year_pairs).items():
+            existing_series[f"name_{key_tuple[0]}_{key_tuple[1] or 'None'}"] = series
 
     # Get existing relations
     series_ids = [data['series_id'] for data in series_keys.values()]
@@ -1023,12 +1045,7 @@ def process_series_batch(account, batch, categories, relations, scan_start_time=
                 existing_by_tmdb = {s.tmdb_id: s for s in Series.objects.filter(tmdb_id__in=tmdb_ids)} if tmdb_ids else {}
                 existing_by_imdb = {s.imdb_id: s for s in Series.objects.filter(imdb_id__in=imdb_ids)} if imdb_ids else {}
 
-                existing_by_name_year = {}
-                if name_year_pairs:
-                    for series in Series.objects.filter(tmdb_id__isnull=True, imdb_id__isnull=True):
-                        key = (series.name, series.year)
-                        if key in name_year_pairs:
-                            existing_by_name_year[key] = series
+                existing_by_name_year = lookup_by_name_year(Series, name_year_pairs)
 
                 # Check each series against the bulk query results
                 series_actually_created = []
diff --git a/core/api_views.py b/core/api_views.py
index ec66d69a..ee7d1db1 100644
--- a/core/api_views.py
+++ b/core/api_views.py
@@ -225,7 +225,8 @@ class ProxySettingsViewSet(viewsets.ViewSet):
                 "buffering_speed": 1.0,
                 "redis_chunk_ttl": 60,
                 "channel_shutdown_delay": 0,
-                "channel_init_grace_period": 5,
+                "channel_init_grace_period": 60,
+                "channel_client_wait_period": 5,
                 "new_client_behind_seconds": 5,
             }
             settings_obj, created = CoreSettings.objects.get_or_create(
diff --git a/core/migrations/0026_add_channel_client_wait_period.py b/core/migrations/0026_add_channel_client_wait_period.py
new file mode 100644
index 00000000..6119eb66
--- /dev/null
+++ b/core/migrations/0026_add_channel_client_wait_period.py
@@ -0,0 +1,51 @@
+from django.db import migrations
+
+PROXY_SETTINGS_KEY = "proxy_settings"
+
+
+def add_channel_client_wait_period(apps, schema_editor):
+    CoreSettings = apps.get_model("core", "CoreSettings")
+
+    try:
+        obj = CoreSettings.objects.get(key=PROXY_SETTINGS_KEY)
+    except CoreSettings.DoesNotExist:
+        return
+
+    value = obj.value if isinstance(obj.value, dict) else {}
+
+    # Add the new client-connect grace period default.
+    value.setdefault("channel_client_wait_period", 5)
+
+    # channel_init_grace_period was repurposed in 0.27.1 as the channel startup
+    # timeout (replacing a hardcoded 10s). Values below the new 60s default are
+    # too short when a channel has many failover streams to cycle through.
+    current_init = value.get("channel_init_grace_period", 5)
+    if current_init < 60:
+        value["channel_init_grace_period"] = 60
+
+    obj.value = value
+    obj.save()
+
+
+def remove_channel_client_wait_period(apps, schema_editor):
+    CoreSettings = apps.get_model("core", "CoreSettings")
+
+    try:
+        obj = CoreSettings.objects.get(key=PROXY_SETTINGS_KEY)
+    except CoreSettings.DoesNotExist:
+        return
+
+    value = obj.value if isinstance(obj.value, dict) else {}
+    value.pop("channel_client_wait_period", None)
+    obj.value = value
+    obj.save()
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("core", "0025_move_preferred_region_and_auto_import_to_system_settings"),
+    ]
+
+    operations = [
+        migrations.RunPython(add_channel_client_wait_period, remove_channel_client_wait_period),
+    ]
diff --git a/core/models.py b/core/models.py
index 60be2f0e..ad9677c6 100644
--- a/core/models.py
+++ b/core/models.py
@@ -394,7 +394,8 @@ class CoreSettings(models.Model):
             "buffering_speed": 1.0,
             "redis_chunk_ttl": 60,
             "channel_shutdown_delay": 0,
-            "channel_init_grace_period": 5,
+            "channel_init_grace_period": 60,
+            "channel_client_wait_period": 5,
             "new_client_behind_seconds": 5,
         })
 
diff --git a/core/serializers.py b/core/serializers.py
index 1a940f23..1398b194 100644
--- a/core/serializers.py
+++ b/core/serializers.py
@@ -96,7 +96,8 @@ class ProxySettingsSerializer(serializers.Serializer):
     buffering_speed = serializers.FloatField(min_value=0.1, max_value=10.0)
     redis_chunk_ttl = serializers.IntegerField(min_value=10, max_value=3600)
     channel_shutdown_delay = serializers.IntegerField(min_value=0, max_value=300)
-    channel_init_grace_period = serializers.IntegerField(min_value=0, max_value=60)
+    channel_init_grace_period = serializers.IntegerField(min_value=0, max_value=300)
+    channel_client_wait_period = serializers.IntegerField(min_value=0, max_value=300, required=False, default=5)
     new_client_behind_seconds = serializers.IntegerField(min_value=0, max_value=120, required=False, default=5)
 
     def validate_buffering_timeout(self, value):
@@ -120,8 +121,17 @@ class ProxySettingsSerializer(serializers.Serializer):
         return value
 
     def validate_channel_init_grace_period(self, value):
-        if value < 0 or value > 60:
-            raise serializers.ValidationError("Channel init grace period must be between 0 and 60 seconds")
+        if value < 0 or value > 300:
+            raise serializers.ValidationError(
+                "Channel initialization timeout must be between 0 and 300 seconds"
+            )
+        return value
+
+    def validate_channel_client_wait_period(self, value):
+        if value < 0 or value > 300:
+            raise serializers.ValidationError(
+                "Client connect grace period must be between 0 and 300 seconds"
+            )
         return value
 
     def validate_new_client_behind_seconds(self, value):
diff --git a/core/tasks.py b/core/tasks.py
index e9d79d37..a64469b4 100644
--- a/core/tasks.py
+++ b/core/tasks.py
@@ -398,12 +398,16 @@ def scan_and_process_files():
 def _rebuild_programme_indices():
     """Queue index builds for active EPG sources that are missing their DB index."""
     try:
+        from django.db.models import Q
         from apps.epg.tasks import build_programme_index_task
 
         sources = EPGSource.objects.filter(
             is_active=True,
-            programme_index__isnull=True,
-        ).exclude(source_type__in=('dummy', 'schedules_direct'))
+        ).exclude(
+            source_type__in=('dummy', 'schedules_direct')
+        ).filter(
+            Q(index_record__isnull=True) | Q(index_record__data__isnull=True)
+        )
 
         count = 0
         for source in sources:
@@ -796,11 +800,11 @@ def check_for_version_update():
     from packaging import version as pkg_version
     from version import __version__, __timestamp__
     from core.models import SystemNotification
-    from core.utils import send_websocket_notification
+    from core.utils import dispatcharr_http_headers, send_websocket_notification
 
     try:
         is_dev_build = __timestamp__ is not None
-        DISPATCHARR_HEADERS = {'User-Agent': f'Dispatcharr/{__version__}'}
+        DISPATCHARR_HEADERS = dispatcharr_http_headers(content_type=None)
 
         if is_dev_build:
             # Check Docker Hub for newer dev builds
diff --git a/core/tests.py b/core/tests.py
index e7f45c5a..2af52f07 100644
--- a/core/tests.py
+++ b/core/tests.py
@@ -1,21 +1,46 @@
 from unittest.mock import patch, MagicMock
 
-from django.test import TestCase
+from django.test import TestCase, SimpleTestCase
 
-from apps.epg.models import EPGSource
+from apps.epg.models import EPGSource, EPGSourceIndex
 from core.models import CoreSettings, DVR_SETTINGS_KEY, EPG_SETTINGS_KEY
 
 
+class DispatcharrUserAgentTests(TestCase):
+    @patch('version.__version__', '1.2.3')
+    def test_dispatcharr_user_agent(self):
+        from core.utils import dispatcharr_user_agent
+        self.assertEqual(dispatcharr_user_agent(), 'Dispatcharr/1.2.3')
+
+    def test_dispatcharr_dvr_user_agent(self):
+        from core.utils import dispatcharr_dvr_user_agent
+        self.assertEqual(dispatcharr_dvr_user_agent(42), 'Dispatcharr-DVR/recording-42')
+
+    @patch('version.__version__', '1.2.3')
+    def test_dispatcharr_http_headers_with_token(self):
+        from core.utils import dispatcharr_http_headers
+        headers = dispatcharr_http_headers(token='tok123')
+        self.assertEqual(headers, {
+            'User-Agent': 'Dispatcharr/1.2.3',
+            'Content-Type': 'application/json',
+            'token': 'tok123',
+        })
+
+    @patch('version.__version__', '1.2.3')
+    def test_dispatcharr_http_headers_without_content_type(self):
+        from core.utils import dispatcharr_http_headers
+        self.assertEqual(
+            dispatcharr_http_headers(content_type=None),
+            {'User-Agent': 'Dispatcharr/1.2.3'},
+        )
+
+
 class ProgrammeIndexRebuildTests(TestCase):
     def test_startup_rebuild_does_not_lock_out_queued_build_task(self):
-        EPGSource.objects.update(
-            programme_index={"channels": {}, "interleaved_channels": []}
-        )
         source = EPGSource.objects.create(
             name="Missing Index",
             source_type="xmltv",
             is_active=True,
-            programme_index=None,
         )
 
         class FakeRedis:
@@ -272,3 +297,14 @@ class DropDBCommandTlsTest(TestCase):
             host='localhost', port=5432,
             autocommit=True,
         )
+
+
+class MallocTrimTests(SimpleTestCase):
+    def test_trim_is_noop_when_libc_has_no_malloc_trim(self):
+        from core.utils import trim_c_allocator_heap
+
+        fake_libc = MagicMock(spec=[])
+        with patch('ctypes.util.find_library', return_value='libc.so.6'), patch(
+            'ctypes.CDLL', return_value=fake_libc
+        ):
+            self.assertFalse(trim_c_allocator_heap())
diff --git a/core/utils.py b/core/utils.py
index 6a13c472..44504b6a 100644
--- a/core/utils.py
+++ b/core/utils.py
@@ -1,3 +1,4 @@
+import json
 import redis
 import logging
 import time
@@ -7,7 +8,6 @@ from pathlib import Path
 import re
 from django.conf import settings
 from redis.exceptions import ConnectionError, TimeoutError
-from django.core.cache import cache
 from asgiref.sync import async_to_sync
 from channels.layers import get_channel_layer
 from django.core.validators import URLValidator
@@ -21,6 +21,33 @@ logger = logging.getLogger(__name__)
 # Import the command detector
 from .command_utils import is_management_command
 
+
+def dispatcharr_user_agent():
+    """Return the standard Dispatcharr User-Agent string (Dispatcharr/{version})."""
+    from version import __version__
+    return f'Dispatcharr/{__version__}'
+
+
+def dispatcharr_dvr_user_agent(recording_id):
+    """Return the User-Agent string used by DVR FFmpeg clients for a recording."""
+    return f'Dispatcharr-DVR/recording-{recording_id}'
+
+
+def dispatcharr_http_headers(*, token=None, content_type='application/json'):
+    """
+    Build HTTP headers for outbound Dispatcharr requests.
+
+    content_type=None omits Content-Type (e.g. simple GET proxies).
+    token is included when authenticating with Schedules Direct.
+    """
+    headers = {'User-Agent': dispatcharr_user_agent()}
+    if content_type:
+        headers['Content-Type'] = content_type
+    if token:
+        headers['token'] = token
+    return headers
+
+
 def natural_sort_key(text):
     """
     Convert a string into a list of string and number chunks for natural sorting.
@@ -44,6 +71,46 @@ def natural_sort_key(text):
 
     return [convert(c) for c in re.split('([0-9]+)', text)]
 
+
+def custom_properties_as_dict(value):
+    """
+    Normalize a JSONField-backed custom_properties value into a dict.
+
+    Historical rows (TextField era and early JSONField migration) may store a
+    JSON-encoded string instead of an object. API clients can also submit a
+    string value because JSONField accepts any JSON type. Call this before
+    reading or merging custom_properties.
+    """
+    if isinstance(value, dict):
+        return value
+    if isinstance(value, str):
+        try:
+            parsed = json.loads(value)
+        except (ValueError, TypeError):
+            logger.warning(
+                "custom_properties stored as non-JSON string; ignoring: %r",
+                value[:100],
+            )
+            return {}
+        return parsed if isinstance(parsed, dict) else {}
+    if value is None:
+        return {}
+    return {}
+
+
+def ensure_custom_properties_dict(value):
+    """
+    Return a dict for read/merge/bulk-write paths. Dict values pass through
+    without re-parsing. Use model ``save()`` (not this) as the canonical
+    normalizer for ORM writes that go through ``save()``.
+    """
+    if isinstance(value, dict):
+        return value
+    if value is None:
+        return {}
+    return custom_properties_as_dict(value)
+
+
 class RedisClient:
     _client = None
     _buffer = None
@@ -244,6 +311,15 @@ def release_task_lock(task_name, id):
     redis_client.delete(lock_id)
 
 
+def is_task_lock_held(task_name, id):
+    """Return True when another worker holds the task lock (read-only check)."""
+    redis_client = RedisClient.get_client()
+    if redis_client is None:
+        return False
+    lock_id = f"task_lock_{task_name}_{id}"
+    return bool(redis_client.exists(lock_id))
+
+
 class TaskLockRenewer:
     """Periodically renews a Redis task lock to prevent expiry during long-running tasks.
 
@@ -470,6 +546,25 @@ def monitor_memory_usage(func):
         return result
     return wrapper
 
+def trim_c_allocator_heap():
+    """Return unused C heap pages to the OS where supported (glibc malloc_trim)."""
+    try:
+        import ctypes
+        import ctypes.util
+
+        libc_name = ctypes.util.find_library("c")
+        if not libc_name:
+            return False
+        libc = ctypes.CDLL(libc_name)
+        if not hasattr(libc, "malloc_trim"):
+            return False
+        libc.malloc_trim(0)
+        return True
+    except Exception:
+        logger.debug("malloc_trim unavailable or failed", exc_info=True)
+        return False
+
+
 def cleanup_memory(log_usage=False, force_collection=True):
     """
     Comprehensive memory cleanup function to reduce memory footprint
@@ -513,6 +608,30 @@ def cleanup_memory(log_usage=False, force_collection=True):
             pass
     logger.trace("Memory cleanup complete for django")
 
+
+def spawn_memory_trim(close_connections=False):
+    """Reclaim a request's heap pages: GC, then return freed C pages to the OS.
+
+    On gevent uWSGI workers the trim runs in a spawned greenlet so it never
+    blocks the caller; Celery prefork workers (no gevent hub) run it inline.
+    Set close_connections=True when called from a streaming generator's teardown
+    so the pooled DB connection is released first.
+    """
+    def _run():
+        cleanup_memory(force_collection=True)
+        trim_c_allocator_heap()
+
+    if close_connections:
+        from django.db import close_old_connections
+        close_old_connections()
+
+    if _is_gevent_monkey_patched():
+        import gevent
+        gevent.spawn(_run)
+    else:
+        _run()
+
+
 def safe_upload_path(filename: str, base_dir) -> str:
     """Return a safe absolute path for an uploaded file within base_dir.
 
@@ -587,6 +706,8 @@ def validate_flexible_url(value):
         raise ValidationError("Enter a valid URL.")
 
 def dispatch_event_system(event_type, channel_id=None, channel_name=None, **details):
+    from django.db import close_old_connections
+
     try:
         from apps.connect.utils import trigger_event
         from apps.channels.models import Channel, Stream
@@ -660,9 +781,48 @@ def dispatch_event_system(event_type, channel_id=None, channel_name=None, **deta
 
         trigger_event(event_type, payload)
 
-    except Exception as e:
+    except Exception:
         # Don't fail main path if connect dispatch fails
         pass
+    finally:
+        close_old_connections()
+
+
+def _dispatch_system_event_integrations(
+    event_type, channel_id=None, channel_name=None, **details
+):
+    """
+    Run Connect subscriptions and plugin event hooks without blocking the caller.
+
+    On gevent uWSGI workers, dispatch runs in a spawned greenlet so slow webhooks,
+    scripts, or plugin handlers cannot stall live-proxy teardown or streaming paths.
+    Celery prefork workers (gevent patched but no hub) run synchronously instead.
+    """
+
+    def _run():
+        try:
+            dispatch_event_system(
+                event_type,
+                channel_id=channel_id,
+                channel_name=channel_name,
+                **details,
+            )
+        except Exception as e:
+            logger.error(
+                "Failed to dispatch Connect/plugin handlers for event %s: %s",
+                event_type,
+                e,
+            )
+
+    if _should_use_sync_websocket_send():
+        _run()
+    elif _is_gevent_monkey_patched():
+        import gevent
+
+        gevent.spawn(_run)
+    else:
+        _run()
+
 
 def log_system_event(event_type, channel_id=None, channel_name=None, **details):
     """
@@ -679,6 +839,7 @@ def log_system_event(event_type, channel_id=None, channel_name=None, **details):
                         stream_url='http://...', user='admin')
     """
     from core.models import SystemEvent, CoreSettings
+    from django.db import close_old_connections
 
     try:
         # Create the event
@@ -689,8 +850,13 @@ def log_system_event(event_type, channel_id=None, channel_name=None, **details):
             details=details
         )
 
-        # Trigger connect integrations for specific events
-        dispatch_event_system(event_type, channel_id=channel_id, channel_name=channel_name, **details)
+        # Connect integrations and plugin event hooks (non-blocking on gevent uWSGI)
+        _dispatch_system_event_integrations(
+            event_type,
+            channel_id=channel_id,
+            channel_name=channel_name,
+            **details,
+        )
 
         # Get max events from settings (default 100)
         try:
@@ -714,6 +880,10 @@ def log_system_event(event_type, channel_id=None, channel_name=None, **details):
     except Exception as e:
         # Don't let event logging break the main application
         logger.error(f"Failed to log system event {event_type}: {e}")
+    finally:
+        # geventpool keeps checked-out connections until close(); release promptly
+        # when logging from proxy greenlets/threads outside a normal request cycle.
+        close_old_connections()
 
 
 def _send_async(channel_layer, group, message):
diff --git a/core/xtream_codes.py b/core/xtream_codes.py
index 195d4428..bcbe22e2 100644
--- a/core/xtream_codes.py
+++ b/core/xtream_codes.py
@@ -5,6 +5,26 @@ import json
 
 logger = logging.getLogger(__name__)
 
+
+def normalize_server_url(url):
+    """Normalize server URL: strip XC API endpoints and query params, preserve base path."""
+    if not url:
+        return url
+
+    from urllib.parse import urlparse, urlunparse
+
+    parsed = urlparse(url.strip())
+    path = parsed.path.rstrip('/')
+
+    # XC API endpoints are always .php files; legitimate base paths never are.
+    # Stripping the trailing segment when it ends in .php handles any pasted API URL.
+    last_segment = path.rsplit('/', 1)[-1]
+    if last_segment.endswith('.php'):
+        path = path[:-(len(last_segment) + 1)] if '/' in path else ''
+
+    return urlunparse((parsed.scheme, parsed.netloc, path, '', '', ''))
+
+
 class Client:
     """Xtream Codes API Client with robust error handling"""
 
@@ -43,22 +63,10 @@ class Client:
         self.server_info = None
 
     def _normalize_url(self, url):
-        """Normalize server URL: strip XC API endpoints and query params, preserve base path."""
-        if not url:
+        normalized = normalize_server_url(url)
+        if not normalized:
             raise ValueError("Server URL cannot be empty")
-
-        from urllib.parse import urlparse, urlunparse
-
-        parsed = urlparse(url.strip())
-        path = parsed.path.rstrip('/')
-
-        # XC API endpoints are always .php files; legitimate base paths never are.
-        # Stripping the trailing segment when it ends in .php handles any pasted API URL.
-        last_segment = path.rsplit('/', 1)[-1]
-        if last_segment.endswith('.php'):
-            path = path[:-(len(last_segment) + 1)] if '/' in path else ''
-
-        return urlunparse((parsed.scheme, parsed.netloc, path, '', '', ''))
+        return normalized
 
     def _make_request(self, endpoint, params=None):
         """Make request with detailed error handling"""
diff --git a/dispatcharr/celery.py b/dispatcharr/celery.py
index 81f26fe2..18be81eb 100644
--- a/dispatcharr/celery.py
+++ b/dispatcharr/celery.py
@@ -2,7 +2,7 @@
 import os
 from celery import Celery
 import logging
-from celery.signals import task_postrun, worker_ready
+from celery.signals import task_postrun, task_prerun, worker_ready
 
 logger = logging.getLogger(__name__)
 
@@ -68,18 +68,30 @@ app.conf.task_routes = {
     'apps.channels.tasks.run_recording': {'queue': 'dvr'},
 }
 
+
+@task_prerun.connect
+def reset_db_connection_before_task(**kwargs):
+    """Discard stale DB connections before each task (Celery workers are long-lived)."""
+    from django.db import close_old_connections
+
+    try:
+        close_old_connections()
+    except Exception:
+        pass
+
+
 # Add memory cleanup after task completion
 @task_postrun.connect  # Use the imported signal
 def cleanup_task_memory(**kwargs):
     """Clean up memory and database connections after each task completes"""
-    from django.db import connection
+    from django.db import close_old_connections
 
     # Get task name from kwargs
     task_name = kwargs.get('task').name if kwargs.get('task') else ''
 
-    # Close database connection for this Celery worker process
+    # Return all DB connections to the pool in a clean state
     try:
-        connection.close()
+        close_old_connections()
     except Exception:
         pass
 
@@ -94,8 +106,13 @@ def cleanup_task_memory(**kwargs):
         'apps.epg.tasks.refresh_all_epg_data',
         'apps.epg.tasks.parse_programs_for_source',
         'apps.epg.tasks.parse_programs_for_tvg_id',
+        'apps.epg.tasks.build_programme_index_task',
         'apps.channels.tasks.match_epg_channels',
-        'core.tasks.rehash_streams'
+        'apps.channels.tasks.match_selected_channels_epg',
+        'apps.channels.tasks.match_single_channel_epg',
+        'core.tasks.rehash_streams',
+        'apps.vod.tasks.refresh_vod_content',
+        'apps.vod.tasks.batch_refresh_series_episodes',
     ]
 
     # Check if this is a memory-intensive task
diff --git a/dispatcharr/db/__init__.py b/dispatcharr/db/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/dispatcharr/db/backends/__init__.py b/dispatcharr/db/backends/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/dispatcharr/db/backends/postgresql_psycopg3/__init__.py b/dispatcharr/db/backends/postgresql_psycopg3/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/dispatcharr/db/backends/postgresql_psycopg3/base.py b/dispatcharr/db/backends/postgresql_psycopg3/base.py
new file mode 100644
index 00000000..098a01f4
--- /dev/null
+++ b/dispatcharr/db/backends/postgresql_psycopg3/base.py
@@ -0,0 +1,47 @@
+try:
+    import psycopg
+except ImportError as e:
+    from django.core.exceptions import ImproperlyConfigured
+
+    raise ImproperlyConfigured("Error loading psycopg3 module: %s" % e) from e
+
+from django.db.backends.postgresql.base import DatabaseWrapper as OriginalDatabaseWrapper
+from django_db_geventpool.backends.base import DatabaseWrapperMixin
+
+from .pool import DatabaseConnectionPool
+
+
+class PostgresConnectionPool(DatabaseConnectionPool):
+    DBERROR = psycopg.DatabaseError
+
+    def __init__(self, *args, **kwargs):
+        self.connect = kwargs.pop("connect", psycopg.connect)
+        self.connection = None
+        maxsize = kwargs.pop("MAX_CONNS", 4)
+        reuse = kwargs.pop("REUSE_CONNS", maxsize)
+        max_lifetime = kwargs.pop("CONN_MAX_LIFETIME", None)
+        self.args = args
+        self.kwargs = kwargs
+        self.kwargs["client_encoding"] = "UTF8"
+        super().__init__(maxsize, reuse, max_lifetime=max_lifetime)
+
+    def create_connection(self):
+        return self.connect(*self.args, **self.kwargs)
+
+    def check_usable(self, connection):
+        connection.cursor().execute("SELECT 1")
+
+
+class DatabaseWrapper(DatabaseWrapperMixin, OriginalDatabaseWrapper):
+    pool_class = PostgresConnectionPool
+    INTRANS = psycopg.pq.TransactionStatus.INTRANS
+
+    def get_connection_params(self) -> dict:
+        from dispatcharr.db.process_label import db_application_name
+
+        conn_params = super().get_connection_params()
+        conn_params["application_name"] = db_application_name()
+        for attr in ("MAX_CONNS", "REUSE_CONNS", "CONN_MAX_LIFETIME"):
+            if attr in self.settings_dict["OPTIONS"]:
+                conn_params[attr] = self.settings_dict["OPTIONS"][attr]
+        return conn_params
diff --git a/dispatcharr/db/backends/postgresql_psycopg3/pool.py b/dispatcharr/db/backends/postgresql_psycopg3/pool.py
new file mode 100644
index 00000000..8d50a2ae
--- /dev/null
+++ b/dispatcharr/db/backends/postgresql_psycopg3/pool.py
@@ -0,0 +1,92 @@
+"""geventpool with bounded connection lifetime.
+
+django-db-geventpool keeps warm connections open indefinitely. psycopg3 accumulates
+cache on long-lived handles. We close and replace after
+CONN_MAX_LIFETIME rather than recycling uWSGI workers, which would interrupt
+live stream backends.
+"""
+import logging
+import time
+
+try:
+    from gevent import queue
+except ImportError:
+    from eventlet import queue
+
+from django_db_geventpool.backends.pool import DatabaseConnectionPool as BasePool
+
+logger = logging.getLogger("django.geventpool")
+
+
+class DatabaseConnectionPool(BasePool):
+    def __init__(self, maxsize: int = 100, reuse: int = 100, max_lifetime: float | None = None):
+        super().__init__(maxsize, reuse)
+        self.max_lifetime = max_lifetime
+
+    def _stamp_connection(self, conn) -> None:
+        conn._dispatcharr_pool_created_at = time.monotonic()
+
+    def _connection_expired(self, conn) -> bool:
+        if not self.max_lifetime:
+            return False
+        created_at = getattr(conn, "_dispatcharr_pool_created_at", None)
+        if created_at is None:
+            return False
+        return (time.monotonic() - created_at) >= self.max_lifetime
+
+    def _close_connection(self, conn) -> None:
+        try:
+            conn.close()
+        except Exception:
+            logger.debug("Error closing pool connection", exc_info=True)
+        finally:
+            self._conns.discard(conn)
+
+    def get(self):
+        conn = None
+        try:
+            if self.size >= self.maxsize or self.pool.qsize():
+                conn = self.pool.get()
+            else:
+                conn = self.pool.get_nowait()
+
+            if conn is not None and self._connection_expired(conn):
+                logger.debug(
+                    "DB connection expired after %ss, replacing",
+                    int(self.max_lifetime),
+                )
+                self._close_connection(conn)
+                conn = None
+            elif conn is not None:
+                try:
+                    self.check_usable(conn)
+                    logger.trace("DB connection reused")
+                except self.DBERROR:
+                    logger.debug("DB connection was closed, creating a new one")
+                    self._close_connection(conn)
+                    conn = None
+        except queue.Empty:
+            conn = None
+            logger.trace("DB connection queue empty, creating a new one")
+
+        if conn is None:
+            conn = self.create_connection()
+            self._stamp_connection(conn)
+            self._conns.add(conn)
+
+        return conn
+
+    def put(self, item):
+        if self._connection_expired(item):
+            logger.debug(
+                "DB connection expired after %ss on return, closing",
+                int(self.max_lifetime),
+            )
+            self._close_connection(item)
+            return
+
+        try:
+            self.pool.put_nowait(item)
+            logger.trace("DB connection returned to the pool")
+        except queue.Full:
+            self._close_connection(item)
diff --git a/dispatcharr/db/process_label.py b/dispatcharr/db/process_label.py
new file mode 100644
index 00000000..209ad291
--- /dev/null
+++ b/dispatcharr/db/process_label.py
@@ -0,0 +1,43 @@
+"""Label Postgres connections by Dispatcharr process role (for pg_stat_activity)."""
+
+from __future__ import annotations
+
+import os
+import sys
+
+
+def _is_uwsgi_worker() -> bool:
+    """True when running inside a uWSGI worker (not master or a non-uWSGI process)."""
+    try:
+        import uwsgi
+    except ImportError:
+        return False
+    return uwsgi.worker_id() > 0
+
+
+def get_process_role(argv: list[str] | None = None) -> str:
+    argv = argv if argv is not None else sys.argv
+    argv0 = os.path.basename(argv[0]) if argv else ""
+    cmdline = " ".join(argv)
+
+    if "celery" in argv0 or any("celery" in arg for arg in argv):
+        if "beat" in cmdline:
+            return "celery-beat"
+        if "-Q" in argv:
+            try:
+                if "dvr" in argv[argv.index("-Q") + 1]:
+                    return "celery-dvr"
+            except (IndexError, ValueError):
+                pass
+        return "celery-worker"
+    if "daphne" in argv0:
+        return "daphne"
+    if argv0 == "manage.py" and len(argv) > 1:
+        return f"manage-{argv[1]}"
+    if _is_uwsgi_worker() or argv0 == "uwsgi":
+        return "uwsgi"
+    return "django"
+
+
+def db_application_name() -> str:
+    return f"Dispatcharr-{get_process_role()}-{os.getpid()}"
diff --git a/dispatcharr/settings.py b/dispatcharr/settings.py
index 51d5bc49..a22e5f9c 100644
--- a/dispatcharr/settings.py
+++ b/dispatcharr/settings.py
@@ -114,6 +114,12 @@ XC_PROFILE_REFRESH_DELAY = float(os.environ.get('XC_PROFILE_REFRESH_DELAY', '2.5
 # Database optimization settings
 DATABASE_STATEMENT_TIMEOUT = 300  # Seconds before timing out long-running queries
 DATABASE_CONN_MAX_AGE = 0  # geventpool intercepts close(); pool handles reuse
+# Pooled connections are closed and replaced after this many seconds (per worker).
+# psycopg3 cache grows on long-lived handles; rotating bounds RAM without recycling
+# uWSGI workers (which would interrupt live streams). Reuse within the window keeps
+# the warm-pool performance win over opening a new TCP session every request.
+# Override via DATABASE_POOL_CONN_MAX_LIFETIME; set 0 to disable. Default 600 (10 min).
+DATABASE_POOL_CONN_MAX_LIFETIME = int(os.environ.get("DATABASE_POOL_CONN_MAX_LIFETIME", "600"))
 
 # Disable atomic requests for performance-sensitive views
 ATOMIC_REQUESTS = False
@@ -223,7 +229,7 @@ if os.getenv("DB_ENGINE", None) == "sqlite":
 else:
     DATABASES = {
         "default": {
-            "ENGINE": "django_db_geventpool.backends.postgresql_psycopg3",
+            "ENGINE": "dispatcharr.db.backends.postgresql_psycopg3",
             "NAME": os.environ.get("POSTGRES_DB", "dispatcharr"),
             "USER": os.environ.get("POSTGRES_USER", "dispatch"),
             "PASSWORD": os.environ.get("POSTGRES_PASSWORD", "secret"),
@@ -234,6 +240,7 @@ else:
                 "MAX_CONNS": 8,   # Per-worker pool size; 4 workers × 8 = 32 total < pg max_connections=100
                 "REUSE_CONNS": 3, # Connections to keep warm between requests
                 "pool": False,    # Disable Django's native psycopg3 pool; geventpool manages connections
+                "CONN_MAX_LIFETIME": DATABASE_POOL_CONN_MAX_LIFETIME or None,
             },
         }
     }
@@ -557,6 +564,12 @@ LOGGING = {
             "level": LOG_LEVEL,  # Use configured log level for scheduler logs
             "propagate": False,
         },
+        # geventpool connection lifecycle
+        "django.geventpool": {
+            "handlers": ["console"],
+            "level": LOG_LEVEL,
+            "propagate": False,
+        },
         # Add any other loggers you need to capture TRACE logs from
     },
     "root": {
diff --git a/dispatcharr/settings_test.py b/dispatcharr/settings_test.py
new file mode 100644
index 00000000..fe4225fa
--- /dev/null
+++ b/dispatcharr/settings_test.py
@@ -0,0 +1,58 @@
+"""
+Django settings for running the backend test suite in isolation.
+
+Always use this module instead of dispatcharr.settings when running tests:
+
+    python manage.py test
+
+`manage.py` selects this module automatically for the ``test`` command.
+
+Django creates a separate empty database (``test_<POSTGRES_DB>``) and runs
+migrations — your live data under /data/db is not used.
+
+Why not dispatcharr.settings?
+- Production/AIO points at the live ``dispatcharr`` database.
+- django-db-geventpool breaks TestCase transaction isolation on pooled connections.
+
+SQLite (``TEST_USE_SQLITE=1``) is an optional fallback for machines without
+Postgres; production and CI should use the default Postgres test database.
+"""
+import os
+
+from dispatcharr.settings import *  # noqa: F401,F403
+
+# Fast password hashing for tests.
+PASSWORD_HASHERS = ["django.contrib.auth.hashers.MD5PasswordHasher"]
+
+# Do NOT run Celery tasks inline during tests. post_save signals on M3UAccount and
+# EPGSource call .delay(); eager mode runs them inside TestCase transactions and
+# closes/poisons the DB connection for subsequent queries in the same test.
+CELERY_TASK_ALWAYS_EAGER = False
+CELERY_TASK_EAGER_PROPAGATES = False
+
+_use_sqlite = os.environ.get("TEST_USE_SQLITE", "").lower() in ("1", "true", "yes")
+
+if _use_sqlite:
+    DATABASES = {
+        "default": {
+            "ENGINE": "django.db.backends.sqlite3",
+            "NAME": ":memory:",
+        }
+    }
+else:
+    # Default: PostgreSQL with Django-managed test_dispatcharr (matches production).
+    # Uses the standard backend (not geventpool) so TestCase transactions isolate.
+    _pg_name = os.environ.get("POSTGRES_DB", "dispatcharr")
+    DATABASES = {
+        "default": {
+            "ENGINE": "django.db.backends.postgresql",
+            "NAME": _pg_name,
+            "USER": os.environ.get("POSTGRES_USER", "dispatch"),
+            "PASSWORD": os.environ.get("POSTGRES_PASSWORD", "secret"),
+            "HOST": os.environ.get("POSTGRES_HOST", "localhost"),
+            "PORT": int(os.environ.get("POSTGRES_PORT", 5432)),
+            "TEST": {
+                "NAME": "test_" + _pg_name,
+            },
+        }
+    }
diff --git a/docker/uwsgi.debug.ini b/docker/uwsgi.debug.ini
index d5f577b3..37a5253b 100644
--- a/docker/uwsgi.debug.ini
+++ b/docker/uwsgi.debug.ini
@@ -70,7 +70,6 @@ py-autoreload = 1
 honour-stdin = true
 
 # Environment variables
-env = GEVENT_SUPPORT=True
 env = PYTHONPATH=/app
 env = PYTHONUNBUFFERED=1
 env = PYDEVD_DISABLE_FILE_VALIDATION=1
diff --git a/frontend/package-lock.json b/frontend/package-lock.json
index 8ca15bc7..ad8ad268 100644
--- a/frontend/package-lock.json
+++ b/frontend/package-lock.json
@@ -57,7 +57,7 @@
         "globals": "^15.15.0",
         "jsdom": "^27.0.0",
         "prettier": "^3.5.3",
-        "vite": "^7.1.7",
+        "vite": "^7.3.5",
         "vitest": "^4.1.8"
       }
     },
@@ -595,9 +595,9 @@
       "license": "MIT"
     },
     "node_modules/@esbuild/aix-ppc64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.27.3.tgz",
-      "integrity": "sha512-9fJMTNFTWZMh5qwrBItuziu834eOCUcEqymSH7pY+zoMVEZg3gcPuBNxH1EvfVYe9h0x/Ptw8KBzv7qxb7l8dg==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.28.1.tgz",
+      "integrity": "sha512-Svl7tq8k/08+p6CXPpRjQ1fKX+1odH/BQbb48fV6fj3CWHhsoIOoY87w1oHXm0qEpkIK3ZfVgp0hed3XBXzXMQ==",
       "cpu": [
         "ppc64"
       ],
@@ -612,9 +612,9 @@
       }
     },
     "node_modules/@esbuild/android-arm": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.27.3.tgz",
-      "integrity": "sha512-i5D1hPY7GIQmXlXhs2w8AWHhenb00+GxjxRncS2ZM7YNVGNfaMxgzSGuO8o8SJzRc/oZwU2bcScvVERk03QhzA==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.28.1.tgz",
+      "integrity": "sha512-0k2F129Xdio1TdJfzJ8sy1Q47vUD2NnwdhiAf7drUN1EBTfPf4hsFCtmMgu/6m8JSzsBrlmVjudMBQqOfG8usQ==",
       "cpu": [
         "arm"
       ],
@@ -629,9 +629,9 @@
       }
     },
     "node_modules/@esbuild/android-arm64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.27.3.tgz",
-      "integrity": "sha512-YdghPYUmj/FX2SYKJ0OZxf+iaKgMsKHVPF1MAq/P8WirnSpCStzKJFjOjzsW0QQ7oIAiccHdcqjbHmJxRb/dmg==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.28.1.tgz",
+      "integrity": "sha512-34EGEbCIAgosYz6goLcopX6Mo7NyGv9tfwEM2/7Ce2VcVRk568iSvniGWcUXIy7wEDR1wzolcxcriFVrWYcwBg==",
       "cpu": [
         "arm64"
       ],
@@ -646,9 +646,9 @@
       }
     },
     "node_modules/@esbuild/android-x64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.27.3.tgz",
-      "integrity": "sha512-IN/0BNTkHtk8lkOM8JWAYFg4ORxBkZQf9zXiEOfERX/CzxW3Vg1ewAhU7QSWQpVIzTW+b8Xy+lGzdYXV6UZObQ==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.28.1.tgz",
+      "integrity": "sha512-dbwY7ltSMDWsRatcRpCnES4F+im88OCUgGZjy52shC7GqHRE/cYlxNbB4Z4UpJswpcc4Qxd2oE/ufM0p61IKng==",
       "cpu": [
         "x64"
       ],
@@ -663,9 +663,9 @@
       }
     },
     "node_modules/@esbuild/darwin-arm64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.27.3.tgz",
-      "integrity": "sha512-Re491k7ByTVRy0t3EKWajdLIr0gz2kKKfzafkth4Q8A5n1xTHrkqZgLLjFEHVD+AXdUGgQMq+Godfq45mGpCKg==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.28.1.tgz",
+      "integrity": "sha512-TZbWkQY7kvTAXbXUT7uVACR5cMHsDiSz9z7ZKAX/RTq/WJEk3QyRr0wZpNhBDX+/0CtdqUIJlOiodQcta6tY3Q==",
       "cpu": [
         "arm64"
       ],
@@ -680,9 +680,9 @@
       }
     },
     "node_modules/@esbuild/darwin-x64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.27.3.tgz",
-      "integrity": "sha512-vHk/hA7/1AckjGzRqi6wbo+jaShzRowYip6rt6q7VYEDX4LEy1pZfDpdxCBnGtl+A5zq8iXDcyuxwtv3hNtHFg==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.28.1.tgz",
+      "integrity": "sha512-zfdzgK9ACBNZLI/CyHTOx81SyNbM6YXn7rxSgX97VjyiPl9W1i4Ka4fgKECEoFCKGpvBj5qArWIGgQjOwkgskQ==",
       "cpu": [
         "x64"
       ],
@@ -697,9 +697,9 @@
       }
     },
     "node_modules/@esbuild/freebsd-arm64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.27.3.tgz",
-      "integrity": "sha512-ipTYM2fjt3kQAYOvo6vcxJx3nBYAzPjgTCk7QEgZG8AUO3ydUhvelmhrbOheMnGOlaSFUoHXB6un+A7q4ygY9w==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.28.1.tgz",
+      "integrity": "sha512-wG2EA8ENdEI0qhkSZMjfqrdY+ziCYCPMmtZjjIwOmXFjmyzEHn+UUxk5of+SYsjtfs3VpnlC7QLzSI5hY/rOAw==",
       "cpu": [
         "arm64"
       ],
@@ -714,9 +714,9 @@
       }
     },
     "node_modules/@esbuild/freebsd-x64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.27.3.tgz",
-      "integrity": "sha512-dDk0X87T7mI6U3K9VjWtHOXqwAMJBNN2r7bejDsc+j03SEjtD9HrOl8gVFByeM0aJksoUuUVU9TBaZa2rgj0oA==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.28.1.tgz",
+      "integrity": "sha512-i7dZ9vQgnvSCzi/rYCXNgtF/U+eKZNJBzu3eTQbRgHnM7tNSizLOkRFAl3qzVc/Op/u5YkHHa4pf/3DOYHthLQ==",
       "cpu": [
         "x64"
       ],
@@ -731,9 +731,9 @@
       }
     },
     "node_modules/@esbuild/linux-arm": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.27.3.tgz",
-      "integrity": "sha512-s6nPv2QkSupJwLYyfS+gwdirm0ukyTFNl3KTgZEAiJDd+iHZcbTPPcWCcRYH+WlNbwChgH2QkE9NSlNrMT8Gfw==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.28.1.tgz",
+      "integrity": "sha512-qVXBOHQS+d5Y722GwJzJUtOLlX7km3CraOaGormF1pDtPd2C/l1SHRPgjLunLGe51Sh5YYWKMFDyV4SxgMQYTQ==",
       "cpu": [
         "arm"
       ],
@@ -748,9 +748,9 @@
       }
     },
     "node_modules/@esbuild/linux-arm64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.27.3.tgz",
-      "integrity": "sha512-sZOuFz/xWnZ4KH3YfFrKCf1WyPZHakVzTiqji3WDc0BCl2kBwiJLCXpzLzUBLgmp4veFZdvN5ChW4Eq/8Fc2Fg==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.28.1.tgz",
+      "integrity": "sha512-yHs+0uc8+nvEAfAfxrWQKK5peSNzBc4PegcMO0EJ2hT71uA7vB8Ihg2e77R2P7SG5uYjPbHlLLmve4LLLRCf0g==",
       "cpu": [
         "arm64"
       ],
@@ -765,9 +765,9 @@
       }
     },
     "node_modules/@esbuild/linux-ia32": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.27.3.tgz",
-      "integrity": "sha512-yGlQYjdxtLdh0a3jHjuwOrxQjOZYD/C9PfdbgJJF3TIZWnm/tMd/RcNiLngiu4iwcBAOezdnSLAwQDPqTmtTYg==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.28.1.tgz",
+      "integrity": "sha512-d1z4ZuP0ajrfz/FhGT4vv278rX8KnPPJx8i5+AtK7TYbx9Le9F1hyzurZpkEyjkGa9dUGhQow4C1NmeGvqxN2w==",
       "cpu": [
         "ia32"
       ],
@@ -782,9 +782,9 @@
       }
     },
     "node_modules/@esbuild/linux-loong64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.27.3.tgz",
-      "integrity": "sha512-WO60Sn8ly3gtzhyjATDgieJNet/KqsDlX5nRC5Y3oTFcS1l0KWba+SEa9Ja1GfDqSF1z6hif/SkpQJbL63cgOA==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.28.1.tgz",
+      "integrity": "sha512-M5sRjUVZrkm1OAPR3dlOYzNmN+loZKGVi1VUQGrwuqLcbR6qeAz+famMhjASeH3YVKvZz+zT1jlh/keC3Rj/lg==",
       "cpu": [
         "loong64"
       ],
@@ -799,9 +799,9 @@
       }
     },
     "node_modules/@esbuild/linux-mips64el": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.27.3.tgz",
-      "integrity": "sha512-APsymYA6sGcZ4pD6k+UxbDjOFSvPWyZhjaiPyl/f79xKxwTnrn5QUnXR5prvetuaSMsb4jgeHewIDCIWljrSxw==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.28.1.tgz",
+      "integrity": "sha512-mRObBZeHh2OxcBFPWE/FjylkRgZdYuiTR3vaTozquCGOH14iP9oN4x4Ge81CoIDYQrXmIxpFumJBu5MtZpnQJQ==",
       "cpu": [
         "mips64el"
       ],
@@ -816,9 +816,9 @@
       }
     },
     "node_modules/@esbuild/linux-ppc64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.27.3.tgz",
-      "integrity": "sha512-eizBnTeBefojtDb9nSh4vvVQ3V9Qf9Df01PfawPcRzJH4gFSgrObw+LveUyDoKU3kxi5+9RJTCWlj4FjYXVPEA==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.28.1.tgz",
+      "integrity": "sha512-slScBsMAb3GFDcdrCgLwZtPYRoH2H/youv10QiZyRjmsP48fznoveWytSgCI/R0ZcUgpc0ZhIUEx6LHts8yrfQ==",
       "cpu": [
         "ppc64"
       ],
@@ -833,9 +833,9 @@
       }
     },
     "node_modules/@esbuild/linux-riscv64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.27.3.tgz",
-      "integrity": "sha512-3Emwh0r5wmfm3ssTWRQSyVhbOHvqegUDRd0WhmXKX2mkHJe1SFCMJhagUleMq+Uci34wLSipf8Lagt4LlpRFWQ==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.28.1.tgz",
+      "integrity": "sha512-kw0owk1o0GFETUJyW0jc0G4Yzs0BHZn0JDZ8JRT088vjJYX777BAs1fDGxAC+q831qOs2DTC96mNsG2opdfyyQ==",
       "cpu": [
         "riscv64"
       ],
@@ -850,9 +850,9 @@
       }
     },
     "node_modules/@esbuild/linux-s390x": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.27.3.tgz",
-      "integrity": "sha512-pBHUx9LzXWBc7MFIEEL0yD/ZVtNgLytvx60gES28GcWMqil8ElCYR4kvbV2BDqsHOvVDRrOxGySBM9Fcv744hw==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.28.1.tgz",
+      "integrity": "sha512-/lAIjX8aYFRByhh6L5rYtPEDRqa9de/4V/juOXcta5frjvzXO4/sqEtyytse0g3zZFuWu5cDN0MkLz2qRDD2Ag==",
       "cpu": [
         "s390x"
       ],
@@ -867,9 +867,9 @@
       }
     },
     "node_modules/@esbuild/linux-x64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.27.3.tgz",
-      "integrity": "sha512-Czi8yzXUWIQYAtL/2y6vogER8pvcsOsk5cpwL4Gk5nJqH5UZiVByIY8Eorm5R13gq+DQKYg0+JyQoytLQas4dA==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.28.1.tgz",
+      "integrity": "sha512-u/anNYF2mmVOEDwLtnQ1wOr3EZ9sTNGLWrsYGYwHWzGA3Si84IOkHXlbWTD1NB+9/1lcnweYKO54uhxZydNzfA==",
       "cpu": [
         "x64"
       ],
@@ -884,9 +884,9 @@
       }
     },
     "node_modules/@esbuild/netbsd-arm64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.27.3.tgz",
-      "integrity": "sha512-sDpk0RgmTCR/5HguIZa9n9u+HVKf40fbEUt+iTzSnCaGvY9kFP0YKBWZtJaraonFnqef5SlJ8/TiPAxzyS+UoA==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.28.1.tgz",
+      "integrity": "sha512-oks0DYbLwWMmaakTsCb+zL4E+aHRVLom9IJZOAthMQEPiQmydXHkziYEsGYRx0uNV/IjEKGAV941JzH02pflqw==",
       "cpu": [
         "arm64"
       ],
@@ -901,9 +901,9 @@
       }
     },
     "node_modules/@esbuild/netbsd-x64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.27.3.tgz",
-      "integrity": "sha512-P14lFKJl/DdaE00LItAukUdZO5iqNH7+PjoBm+fLQjtxfcfFE20Xf5CrLsmZdq5LFFZzb5JMZ9grUwvtVYzjiA==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.28.1.tgz",
+      "integrity": "sha512-aeL6lAnN89Hz43Mlh1G8ARasbuoYvSITDEx0tHh5b7jJnHcssqgjy9Yx430GDpmCa6OyrKoS0aNRjKundRizGg==",
       "cpu": [
         "x64"
       ],
@@ -918,9 +918,9 @@
       }
     },
     "node_modules/@esbuild/openbsd-arm64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.27.3.tgz",
-      "integrity": "sha512-AIcMP77AvirGbRl/UZFTq5hjXK+2wC7qFRGoHSDrZ5v5b8DK/GYpXW3CPRL53NkvDqb9D+alBiC/dV0Fb7eJcw==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.28.1.tgz",
+      "integrity": "sha512-MEFJe5C3R8pwXdZ5Y21oo6m7ePiS0d9pWucn99O/wvyJZChoIQKrQDxKrGeW8F5+T0okTHesAmDeiHDTIq0V/Q==",
       "cpu": [
         "arm64"
       ],
@@ -935,9 +935,9 @@
       }
     },
     "node_modules/@esbuild/openbsd-x64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.27.3.tgz",
-      "integrity": "sha512-DnW2sRrBzA+YnE70LKqnM3P+z8vehfJWHXECbwBmH/CU51z6FiqTQTHFenPlHmo3a8UgpLyH3PT+87OViOh1AQ==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.28.1.tgz",
+      "integrity": "sha512-i/ZLIOafE0Z8cI/XANJAixoJL/uRAoS2xOA3rb0xN+KK0K177cMAsQYkzHtBrtMXAKuAc7HGgcWiZ/sRC1Nxgw==",
       "cpu": [
         "x64"
       ],
@@ -952,9 +952,9 @@
       }
     },
     "node_modules/@esbuild/openharmony-arm64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.27.3.tgz",
-      "integrity": "sha512-NinAEgr/etERPTsZJ7aEZQvvg/A6IsZG/LgZy+81wON2huV7SrK3e63dU0XhyZP4RKGyTm7aOgmQk0bGp0fy2g==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.28.1.tgz",
+      "integrity": "sha512-ge+Z7EXFNt2BO1oAMsVpiQ8EwndV9i1xXerAeTIK7AtPs3bKFXQM7nlRxDSIUIMeueR1CNXxqztLzdNeReKBJg==",
       "cpu": [
         "arm64"
       ],
@@ -969,9 +969,9 @@
       }
     },
     "node_modules/@esbuild/sunos-x64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.27.3.tgz",
-      "integrity": "sha512-PanZ+nEz+eWoBJ8/f8HKxTTD172SKwdXebZ0ndd953gt1HRBbhMsaNqjTyYLGLPdoWHy4zLU7bDVJztF5f3BHA==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.28.1.tgz",
+      "integrity": "sha512-BEjgtECkL3vY+SaSQ6nzVfiALUeFxpawyp8Jmf5PtYhf1Ug40N1h/hxlhts+f1FvSvarEigdxS3BlSMI2PJLcQ==",
       "cpu": [
         "x64"
       ],
@@ -986,9 +986,9 @@
       }
     },
     "node_modules/@esbuild/win32-arm64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.27.3.tgz",
-      "integrity": "sha512-B2t59lWWYrbRDw/tjiWOuzSsFh1Y/E95ofKz7rIVYSQkUYBjfSgf6oeYPNWHToFRr2zx52JKApIcAS/D5TUBnA==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.28.1.tgz",
+      "integrity": "sha512-lCv9eK/H6ZJWbE7bh2nw54CZ9M2nupBxJcTsdk/QQnWkdSjKGuxmmH8/GWrlT1eMmZfn4dGcCjRte397WqfQXA==",
       "cpu": [
         "arm64"
       ],
@@ -1003,9 +1003,9 @@
       }
     },
     "node_modules/@esbuild/win32-ia32": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.27.3.tgz",
-      "integrity": "sha512-QLKSFeXNS8+tHW7tZpMtjlNb7HKau0QDpwm49u0vUp9y1WOF+PEzkU84y9GqYaAVW8aH8f3GcBck26jh54cX4Q==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.28.1.tgz",
+      "integrity": "sha512-zvb/mB2bSCoJOpoCBgYKKpX6YM6mJBlBUVUtVj41DlZJVEB6/0CKlRYxP5wWl1C1ILiCoAU5wZZ4q1P3qeS6Eg==",
       "cpu": [
         "ia32"
       ],
@@ -1020,9 +1020,9 @@
       }
     },
     "node_modules/@esbuild/win32-x64": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.27.3.tgz",
-      "integrity": "sha512-4uJGhsxuptu3OcpVAzli+/gWusVGwZZHTlS63hh++ehExkVT8SgiEf7/uC/PclrPPkLhZqGgCTjd0VWLo6xMqA==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.28.1.tgz",
+      "integrity": "sha512-bm4Mowrv+GXMlpWX++EcXw/iLyd1o3+bJkC2DkWXYVvgZCqD/bSj9ctZeAMC3cIxgjRVR2Dufaiu4YPxr5gW1A==",
       "cpu": [
         "x64"
       ],
@@ -3163,9 +3163,9 @@
       "license": "MIT"
     },
     "node_modules/esbuild": {
-      "version": "0.27.3",
-      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.27.3.tgz",
-      "integrity": "sha512-8VwMnyGCONIs6cWue2IdpHxHnAjzxnw2Zr7MkVxB2vjmQ2ivqGFb4LEG3SMnv0Gb2F/G/2yA8zUaiL1gywDCCg==",
+      "version": "0.28.1",
+      "resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.28.1.tgz",
+      "integrity": "sha512-HrJrvZv5ayxBzPfwphOoNzkzOIIlifzk0KJrGK2c8R4+LKpMtpYLQeUdjnwjWv/LZlkH2laZk+4w78pi99D4Vw==",
       "dev": true,
       "hasInstallScript": true,
       "license": "MIT",
@@ -3176,32 +3176,32 @@
         "node": ">=18"
       },
       "optionalDependencies": {
-        "@esbuild/aix-ppc64": "0.27.3",
-        "@esbuild/android-arm": "0.27.3",
-        "@esbuild/android-arm64": "0.27.3",
-        "@esbuild/android-x64": "0.27.3",
-        "@esbuild/darwin-arm64": "0.27.3",
-        "@esbuild/darwin-x64": "0.27.3",
-        "@esbuild/freebsd-arm64": "0.27.3",
-        "@esbuild/freebsd-x64": "0.27.3",
-        "@esbuild/linux-arm": "0.27.3",
-        "@esbuild/linux-arm64": "0.27.3",
-        "@esbuild/linux-ia32": "0.27.3",
-        "@esbuild/linux-loong64": "0.27.3",
-        "@esbuild/linux-mips64el": "0.27.3",
-        "@esbuild/linux-ppc64": "0.27.3",
-        "@esbuild/linux-riscv64": "0.27.3",
-        "@esbuild/linux-s390x": "0.27.3",
-        "@esbuild/linux-x64": "0.27.3",
-        "@esbuild/netbsd-arm64": "0.27.3",
-        "@esbuild/netbsd-x64": "0.27.3",
-        "@esbuild/openbsd-arm64": "0.27.3",
-        "@esbuild/openbsd-x64": "0.27.3",
-        "@esbuild/openharmony-arm64": "0.27.3",
-        "@esbuild/sunos-x64": "0.27.3",
-        "@esbuild/win32-arm64": "0.27.3",
-        "@esbuild/win32-ia32": "0.27.3",
-        "@esbuild/win32-x64": "0.27.3"
+        "@esbuild/aix-ppc64": "0.28.1",
+        "@esbuild/android-arm": "0.28.1",
+        "@esbuild/android-arm64": "0.28.1",
+        "@esbuild/android-x64": "0.28.1",
+        "@esbuild/darwin-arm64": "0.28.1",
+        "@esbuild/darwin-x64": "0.28.1",
+        "@esbuild/freebsd-arm64": "0.28.1",
+        "@esbuild/freebsd-x64": "0.28.1",
+        "@esbuild/linux-arm": "0.28.1",
+        "@esbuild/linux-arm64": "0.28.1",
+        "@esbuild/linux-ia32": "0.28.1",
+        "@esbuild/linux-loong64": "0.28.1",
+        "@esbuild/linux-mips64el": "0.28.1",
+        "@esbuild/linux-ppc64": "0.28.1",
+        "@esbuild/linux-riscv64": "0.28.1",
+        "@esbuild/linux-s390x": "0.28.1",
+        "@esbuild/linux-x64": "0.28.1",
+        "@esbuild/netbsd-arm64": "0.28.1",
+        "@esbuild/netbsd-x64": "0.28.1",
+        "@esbuild/openbsd-arm64": "0.28.1",
+        "@esbuild/openbsd-x64": "0.28.1",
+        "@esbuild/openharmony-arm64": "0.28.1",
+        "@esbuild/sunos-x64": "0.28.1",
+        "@esbuild/win32-arm64": "0.28.1",
+        "@esbuild/win32-ia32": "0.28.1",
+        "@esbuild/win32-x64": "0.28.1"
       }
     },
     "node_modules/escape-string-regexp": {
@@ -3814,16 +3814,26 @@
       "license": "MIT"
     },
     "node_modules/js-yaml": {
-      "version": "4.1.1",
-      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-4.1.1.tgz",
-      "integrity": "sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA==",
+      "version": "5.1.0",
+      "resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-5.1.0.tgz",
+      "integrity": "sha512-s8VA5jkR8f22S3NAXmhKPFqGUduqZGlsufabVOgN14iTdw/RXcym7bKkbwjxLK9Yw2lEvvmJjFp119+KPeo8Kg==",
       "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/puzrin"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/nodeca"
+        }
+      ],
       "license": "MIT",
       "dependencies": {
         "argparse": "^2.0.1"
       },
       "bin": {
-        "js-yaml": "bin/js-yaml.js"
+        "js-yaml": "bin/js-yaml.mjs"
       }
     },
     "node_modules/jsdom": {
@@ -5425,9 +5435,9 @@
       }
     },
     "node_modules/vite": {
-      "version": "7.3.2",
-      "resolved": "https://registry.npmjs.org/vite/-/vite-7.3.2.tgz",
-      "integrity": "sha512-Bby3NOsna2jsjfLVOHKes8sGwgl4TT0E6vvpYgnAYDIF/tie7MRaFthmKuHx1NSXjiTueXH3do80FMQgvEktRg==",
+      "version": "7.3.5",
+      "resolved": "https://registry.npmjs.org/vite/-/vite-7.3.5.tgz",
+      "integrity": "sha512-KuOaNhcnGFN2zIPGA7wRmzF+lJA1sea7rHq17aiJ++9lzY1WWG6Jpwqwe1KNbRVPIqHmr8GLYx7jbrQcN/7/ww==",
       "dev": true,
       "license": "MIT",
       "dependencies": {
diff --git a/frontend/package.json b/frontend/package.json
index 2c1b78f5..8675351d 100644
--- a/frontend/package.json
+++ b/frontend/package.json
@@ -61,16 +61,17 @@
     "globals": "^15.15.0",
     "jsdom": "^27.0.0",
     "prettier": "^3.5.3",
-    "vite": "^7.1.7",
+    "vite": "^7.3.5",
     "vitest": "^4.1.8"
   },
   "resolutions": {
-    "vite": "7.1.7",
+    "vite": "7.3.5",
     "react": "19.1.0",
     "react-dom": "19.1.0"
   },
   "overrides": {
-    "js-yaml": "^4.1.1",
+    "esbuild": "^0.28.1",
+    "js-yaml": "^5.1.0",
     "minimatch": "^10.2.1"
   }
 }
diff --git a/frontend/src/WebSocket.jsx b/frontend/src/WebSocket.jsx
index 0e70a46c..89b1a1ef 100644
--- a/frontend/src/WebSocket.jsx
+++ b/frontend/src/WebSocket.jsx
@@ -203,7 +203,7 @@ export const WebsocketProvider = ({ children }) => {
                 notifications.update({
                   id,
                   title: 'Commercials removed',
-                  message: `${title} — kept ${parsedEvent.data.segments_kept} segments`,
+                  message: `${title}: kept ${parsedEvent.data.segments_kept} segments`,
                   color: 'green.5',
                   loading: false,
                   autoClose: 4000,
@@ -366,22 +366,26 @@ export const WebsocketProvider = ({ children }) => {
               fetchEPGData();
               break;
 
+            case 'single_channel_epg_match': {
+              const matchResult = parsedEvent.data;
+              if (matchResult.channel) {
+                useChannelsStore.getState().updateChannel(matchResult.channel);
+              }
+              window.dispatchEvent(
+                new CustomEvent('single-channel-epg-match', {
+                  detail: matchResult,
+                })
+              );
+              break;
+            }
+
             case 'epg_match':
               notifications.show({
                 message: parsedEvent.data.message || 'EPG match is complete!',
                 color: 'green.5',
               });
 
-              // Check if we have associations data and use the more efficient batch API
-              if (
-                parsedEvent.data.associations &&
-                parsedEvent.data.associations.length > 0
-              ) {
-                API.batchSetEPG(parsedEvent.data.associations);
-              }
-
-              // Refresh EPG store first, then requery channels so the table
-              // cross-references updated epg_data_id assignments immediately
+              // Celery already applied assignments server-side; refresh local state.
               fetchEPGData();
               API.requeryChannels();
               break;
@@ -647,8 +651,13 @@ export const WebsocketProvider = ({ children }) => {
               // Read from the store directly. connectWebSocket closes over a stale
               // epgs snapshot, so a newly created source is missed and the old early-
               // return path never reached fetchEPGData on parsing_channels completion.
-              let { epgs: epgsState, updateEPG, updateEPGProgress, fetchEPGs, fetchEPGData } =
-                useEPGsStore.getState();
+              let {
+                epgs: epgsState,
+                updateEPG,
+                updateEPGProgress,
+                fetchEPGs,
+                fetchEPGData,
+              } = useEPGsStore.getState();
 
               if (!epgsState[sourceId]) {
                 try {
@@ -694,8 +703,7 @@ export const WebsocketProvider = ({ children }) => {
                 updateEPG({
                   ...epg,
                   status: parsedEvent.data.status || 'success',
-                  last_message:
-                    parsedEvent.data.message || epg.last_message,
+                  last_message: parsedEvent.data.message || epg.last_message,
                   ...(parsedEvent.data.updated_at && {
                     updated_at: parsedEvent.data.updated_at,
                   }),
diff --git a/frontend/src/api.js b/frontend/src/api.js
index 8fd95fd9..1c826465 100644
--- a/frontend/src/api.js
+++ b/frontend/src/api.js
@@ -3,6 +3,7 @@ import useAuthStore from './store/auth';
 import useChannelsStore from './store/channels';
 import useLogosStore from './store/logos';
 import useUserAgentsStore from './store/userAgents';
+import useServerGroupsStore from './store/serverGroups';
 import usePlaylistsStore from './store/playlists';
 import useEPGsStore from './store/epgs';
 import useStreamsStore from './store/streams';
@@ -1305,6 +1306,59 @@ export default class API {
     }
   }
 
+  static async getServerGroups() {
+    try {
+      const response = await request(`${host}/api/m3u/server-groups/`);
+
+      return response;
+    } catch (e) {
+      errorNotification('Failed to retrieve server groups', e);
+    }
+  }
+
+  static async addServerGroup(values) {
+    try {
+      const response = await request(`${host}/api/m3u/server-groups/`, {
+        method: 'POST',
+        body: values,
+      });
+
+      useServerGroupsStore.getState().addServerGroup(response);
+
+      return response;
+    } catch (e) {
+      errorNotification('Failed to create server group', e);
+    }
+  }
+
+  static async updateServerGroup(values) {
+    try {
+      const { id, ...payload } = values;
+      const response = await request(`${host}/api/m3u/server-groups/${id}/`, {
+        method: 'PUT',
+        body: payload,
+      });
+
+      useServerGroupsStore.getState().updateServerGroup(response);
+
+      return response;
+    } catch (e) {
+      errorNotification('Failed to update server group', e);
+    }
+  }
+
+  static async deleteServerGroup(id) {
+    try {
+      await request(`${host}/api/m3u/server-groups/${id}/`, {
+        method: 'DELETE',
+      });
+
+      useServerGroupsStore.getState().removeServerGroups([id]);
+    } catch (e) {
+      errorNotification('Failed to delete server group', e);
+    }
+  }
+
   static async getPlaylist(id) {
     try {
       const response = await request(`${host}/api/m3u/accounts/${id}/`);
diff --git a/frontend/src/components/FloatingVideo.jsx b/frontend/src/components/FloatingVideo.jsx
index 507e0caf..e8dab9b7 100644
--- a/frontend/src/components/FloatingVideo.jsx
+++ b/frontend/src/components/FloatingVideo.jsx
@@ -16,6 +16,20 @@ import {
   savePlayerPrefs,
 } from '../utils/components/FloatingVideoUtils.js';
 
+// Native <video src> cannot send Authorization headers. Append ?token= at playback
+// time (not when building the URL in cards/modals) so the JWT is fresh. hls.js
+// paths authenticate via xhrSetup instead and do not need this helper.
+const withRecordingAuthToken = (url) => {
+  if (!url || typeof url !== 'string') return url;
+  if (!url.includes('/api/channels/recordings/')) return url;
+  const token = useAuthStore.getState().accessToken;
+  if (!token) return url;
+  const [base, query = ''] = url.split('?');
+  const params = new URLSearchParams(query);
+  params.set('token', token);
+  return `${base}?${params.toString()}`;
+};
+
 const ResizeHandles = ({ startResize }) => {
   const HANDLE_SIZE = 18;
   const HANDLE_OFFSET = 0;
@@ -333,72 +347,75 @@ export default function FloatingVideo() {
     let hls = null;
 
     if (isHls && Hls.isSupported()) {
-      hls = new Hls({
-        // Open at the very beginning of the recording rather than the live
-        // edge.  Without this, an in-progress recording would start at "now"
-        // and hide everything already recorded.  hls.js applies this AFTER
-        // MEDIA_ATTACHED, so the listener-driven `seekToStart()` above is
-        // also kept as a safety net for the Safari native-HLS path and for
-        // edge cases where this initial-position logic loses to the user's
-        // first interaction.
-        startPosition: 0,
-        // Allow seeking back to the start of the recording, regardless of
-        // current playhead position.  Recordings can be hours long and the
-        // user may want to scrub anywhere; we explicitly disable buffer
-        // eviction by setting a very large back-buffer length.
-        backBufferLength: 90 * 60, // 90 minutes
-        maxBufferLength: 60,
-        maxMaxBufferLength: 600,
-        // For an in-progress recording, hls.js refreshes the playlist on
-        // its target-duration cadence; let it follow the live edge but keep
-        // the full DVR window seekable.
-        liveSyncDurationCount: 3,
-        liveMaxLatencyDurationCount: 10,
-        enableWorker: true,
-        lowLatencyMode: false,
-        // Inject the JWT into every playlist + segment XHR.  Read the token
-        // from the auth store at request time rather than capturing the
-        // closure value at hls.js init, so a refreshed access token mid-
-        // playback is picked up on the next segment fetch.
-        xhrSetup: (xhr) => {
-          const token = useAuthStore.getState().accessToken;
-          if (token) {
-            xhr.setRequestHeader('Authorization', `Bearer ${token}`);
-          }
-        },
-      });
-      hls.on(Hls.Events.ERROR, (_evt, data) => {
-        if (data.fatal) {
-          // eslint-disable-next-line no-console
-          console.error('HLS fatal error:', data.type, data.details);
-          if (data.type === Hls.ErrorTypes.NETWORK_ERROR) {
-            try {
-              hls.startLoad();
-            } catch {
-              // ignore
+      try {
+        hls = new Hls({
+          // Open at the very beginning of the recording rather than the live
+          // edge.  Without this, an in-progress recording would start at "now"
+          // and hide everything already recorded.  hls.js applies this AFTER
+          // MEDIA_ATTACHED, so the listener-driven `seekToStart()` above is
+          // also kept as a safety net for the Safari native-HLS path and for
+          // edge cases where this initial-position logic loses to the user's
+          // first interaction.
+          startPosition: 0,
+          // Allow seeking back to the start of the recording, regardless of
+          // current playhead position.  Recordings can be hours long and the
+          // user may want to scrub anywhere; we explicitly disable buffer
+          // eviction by setting a very large back-buffer length.
+          backBufferLength: 90 * 60, // 90 minutes
+          maxBufferLength: 60,
+          maxMaxBufferLength: 600,
+          // Leave liveMaxLatencyDurationCount at the hls.js default (Infinity).
+          // A finite value forces the playhead to the live edge during playback.
+          enableWorker: true,
+          lowLatencyMode: false,
+          // Inject the JWT into every playlist + segment XHR.  Read the token
+          // from the auth store at request time rather than capturing the
+          // closure value at hls.js init, so a refreshed access token mid-
+          // playback is picked up on the next segment fetch.
+          xhrSetup: (xhr) => {
+            const token = useAuthStore.getState().accessToken;
+            if (token) {
+              xhr.setRequestHeader('Authorization', `Bearer ${token}`);
             }
-          } else if (data.type === Hls.ErrorTypes.MEDIA_ERROR) {
-            try {
-              hls.recoverMediaError();
-            } catch {
-              // ignore
+          },
+        });
+        hls.on(Hls.Events.ERROR, (_evt, data) => {
+          if (data.fatal) {
+            // eslint-disable-next-line no-console
+            console.error('HLS fatal error:', data.type, data.details);
+            if (data.type === Hls.ErrorTypes.NETWORK_ERROR) {
+              try {
+                hls.startLoad();
+              } catch {
+                // ignore
+              }
+            } else if (data.type === Hls.ErrorTypes.MEDIA_ERROR) {
+              try {
+                hls.recoverMediaError();
+              } catch {
+                // ignore
+              }
+            } else {
+              setLoadError(`HLS playback error: ${data.details || data.type}`);
             }
-          } else {
-            setLoadError(`HLS playback error: ${data.details || data.type}`);
           }
-        }
-      });
-      hls.attachMedia(video);
-      hls.on(Hls.Events.MEDIA_ATTACHED, () => {
-        hls.loadSource(streamUrl);
-      });
+        });
+        hls.attachMedia(video);
+        hls.on(Hls.Events.MEDIA_ATTACHED, () => {
+          hls.loadSource(streamUrl);
+        });
+      } catch (error) {
+        setIsLoading(false);
+        setLoadError(`HLS initialization error: ${error.message}`);
+        return;
+      }
     } else if (isHls && video.canPlayType('application/vnd.apple.mpegurl')) {
       // Safari path: native HLS support, including seekable DVR windows.
-      video.src = streamUrl;
+      video.src = withRecordingAuthToken(streamUrl);
       video.load();
     } else {
       // Plain progressive file (MKV/MP4): native HTML5.
-      video.src = streamUrl;
+      video.src = withRecordingAuthToken(streamUrl);
       video.load();
     }
 
diff --git a/frontend/src/components/ServerGroupsManagerModal.jsx b/frontend/src/components/ServerGroupsManagerModal.jsx
new file mode 100644
index 00000000..2d403aa1
--- /dev/null
+++ b/frontend/src/components/ServerGroupsManagerModal.jsx
@@ -0,0 +1,28 @@
+import { Modal } from '@mantine/core';
+import ServerGroupsTable from './tables/ServerGroupsTable';
+
+const ServerGroupsManagerModal = ({
+  isOpen,
+  onClose,
+  onGroupCreated,
+  openCreateOnMount = false,
+}) => {
+  return (
+    <Modal
+      opened={isOpen}
+      onClose={onClose}
+      title="Server Groups"
+      size="md"
+      centered
+    >
+      {isOpen ? (
+        <ServerGroupsTable
+          onGroupCreated={onGroupCreated}
+          openCreateOnMount={openCreateOnMount}
+        />
+      ) : null}
+    </Modal>
+  );
+};
+
+export default ServerGroupsManagerModal;
diff --git a/frontend/src/components/__tests__/FloatingVideo.test.jsx b/frontend/src/components/__tests__/FloatingVideo.test.jsx
index f99a3dcc..9683fc59 100644
--- a/frontend/src/components/__tests__/FloatingVideo.test.jsx
+++ b/frontend/src/components/__tests__/FloatingVideo.test.jsx
@@ -20,8 +20,49 @@ vi.mock('mpegts.js', () => ({
   },
 }));
 
+const mockHlsInstance = {
+  attachMedia: vi.fn(),
+  loadSource: vi.fn(),
+  destroy: vi.fn(),
+  on: vi.fn(),
+};
+
+let capturedHlsConfig = null;
+let forceHlsInitError = false;
+
+vi.mock('hls.js', () => ({
+  default: class MockHls {
+    static isSupported = vi.fn(() => true);
+
+    static Events = {
+      ERROR: 'error',
+      MEDIA_ATTACHED: 'media_attached',
+    };
+
+    static ErrorTypes = {
+      NETWORK_ERROR: 'networkError',
+      MEDIA_ERROR: 'mediaError',
+    };
+
+    constructor(config) {
+      if (forceHlsInitError) {
+        throw new Error('Illegal hls.js config');
+      }
+      capturedHlsConfig = config;
+      Object.assign(this, mockHlsInstance);
+    }
+  },
+}));
+
+vi.mock('../../store/auth', () => ({
+  default: {
+    getState: vi.fn(() => ({ accessToken: 'test-token' })),
+  },
+}));
+
 // Import the mocked module after mocking
 const mpegts = (await import('mpegts.js')).default;
+const Hls = (await import('hls.js')).default;
 
 // Mock react-draggable
 vi.mock('react-draggable', () => ({
@@ -53,6 +94,8 @@ describe('FloatingVideo', () => {
 
   beforeEach(async () => {
     vi.clearAllMocks();
+    capturedHlsConfig = null;
+    forceHlsInitError = false;
 
     // Mock HTMLVideoElement methods
     HTMLVideoElement.prototype.load = vi.fn();
@@ -239,6 +282,57 @@ describe('FloatingVideo', () => {
       expect(video.poster).toBe('http://example.com/poster.jpg');
     });
 
+    it('should disable live-edge sync for in-progress recording HLS', () => {
+      useVideoStore.mockImplementation((selector) => {
+        const state = {
+          isVisible: true,
+          streamUrl:
+            'http://example.com/api/channels/recordings/1/hls/index.m3u8',
+          contentType: 'vod',
+          metadata: { name: 'News Recording' },
+          hideVideo: mockHideVideo,
+        };
+        return selector ? selector(state) : state;
+      });
+
+      Hls.isSupported.mockReturnValue(true);
+
+      render(<FloatingVideo />);
+
+      expect(capturedHlsConfig).toEqual(
+        expect.objectContaining({
+          startPosition: 0,
+        })
+      );
+      expect(capturedHlsConfig).not.toHaveProperty(
+        'liveMaxLatencyDurationCount'
+      );
+      expect(capturedHlsConfig).not.toHaveProperty('liveSyncDurationCount');
+    });
+
+    it('shows an in-player error when hls.js config is invalid', () => {
+      useVideoStore.mockImplementation((selector) => {
+        const state = {
+          isVisible: true,
+          streamUrl:
+            'http://example.com/api/channels/recordings/1/hls/index.m3u8',
+          contentType: 'vod',
+          metadata: { name: 'News Recording' },
+          hideVideo: mockHideVideo,
+        };
+        return selector ? selector(state) : state;
+      });
+
+      Hls.isSupported.mockReturnValue(true);
+      forceHlsInitError = true;
+
+      render(<FloatingVideo />);
+
+      expect(
+        screen.getByText(/HLS initialization error: Illegal hls.js config/i)
+      ).toBeInTheDocument();
+    });
+
     it('should show metadata overlay', () => {
       const { container } = render(<FloatingVideo />);
       const video = container.querySelector('video');
diff --git a/frontend/src/components/__tests__/ServerGroupsManagerModal.test.jsx b/frontend/src/components/__tests__/ServerGroupsManagerModal.test.jsx
new file mode 100644
index 00000000..c35b1be1
--- /dev/null
+++ b/frontend/src/components/__tests__/ServerGroupsManagerModal.test.jsx
@@ -0,0 +1,61 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { render, screen, waitFor } from '@testing-library/react';
+import { MantineProvider } from '@mantine/core';
+import ServerGroupsManagerModal from '../ServerGroupsManagerModal';
+
+vi.mock('../../api', () => ({
+  default: {
+    deleteServerGroup: vi.fn(),
+  },
+}));
+
+vi.mock('../../store/serverGroups', () => ({
+  default: (selector) =>
+    selector({
+      serverGroups: [
+        { id: 1, name: 'Pool A' },
+        { id: 2, name: 'Pool B' },
+      ],
+      isLoading: false,
+      error: null,
+      fetchServerGroups: vi.fn().mockResolvedValue(undefined),
+    }),
+}));
+
+vi.mock('../../store/playlists', () => ({
+  default: (selector) =>
+    selector({
+      playlists: [{ id: 10, server_group: 2 }],
+    }),
+}));
+
+vi.mock('../forms/ServerGroup', () => ({
+  default: () => null,
+}));
+
+vi.mock('../../hooks/useLocalStorage', () => ({
+  default: () => ['default', vi.fn()],
+}));
+
+const renderModal = (props = {}) =>
+  render(
+    <MantineProvider>
+      <ServerGroupsManagerModal isOpen onClose={vi.fn()} {...props} />
+    </MantineProvider>
+  );
+
+describe('ServerGroupsManagerModal', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('opens without Mantine Tooltip errors', async () => {
+    expect(() => renderModal()).not.toThrow();
+
+    await waitFor(() => {
+      expect(screen.getByText('Pool A')).toBeInTheDocument();
+      expect(screen.getByText('Pool B')).toBeInTheDocument();
+      expect(screen.getByText('Accounts')).toBeInTheDocument();
+    });
+  });
+});
diff --git a/frontend/src/components/forms/AutoSyncBasic.jsx b/frontend/src/components/forms/AutoSyncBasic.jsx
index 6cab8ea7..a3a0b5ba 100644
--- a/frontend/src/components/forms/AutoSyncBasic.jsx
+++ b/frontend/src/components/forms/AutoSyncBasic.jsx
@@ -37,13 +37,24 @@ const AutoSyncBasic = ({
         ? 1
         : clampChannelNumber(value);
     if (mode === 'provider') {
-      onApplyGroupChange({
+      // Provider's Start # seeds the fallback for numberless streams. Mirror
+      // Fixed mode: if it exceeds End, drop End so the fallback range is never
+      // inverted (an inverted range fails every numberless stream).
+      const next = {
         ...group,
         custom_properties: {
           ...(group.custom_properties || {}),
           channel_numbering_fallback: normalized,
         },
-      });
+      };
+      if (
+        endValue !== null &&
+        endValue !== undefined &&
+        normalized > endValue
+      ) {
+        next.auto_sync_channel_end = null;
+      }
+      onApplyGroupChange(next);
     } else {
       // If End is set and the new Start exceeds it, drop End so the user
       // is not left holding an invalid range silently.
diff --git a/frontend/src/components/forms/Channel.jsx b/frontend/src/components/forms/Channel.jsx
index c904641c..260bd4ad 100644
--- a/frontend/src/components/forms/Channel.jsx
+++ b/frontend/src/components/forms/Channel.jsx
@@ -163,12 +163,24 @@ const ChannelForm = ({ channel: channelProp = null, isOpen, onClose }) => {
     }
 
     setAutoMatchLoading(true);
+    let accepted = false;
     try {
       const response = await matchChannelEpg(channel);
 
+      if (response?.accepted) {
+        accepted = true;
+        showNotification({
+          title: 'Matching in Progress',
+          message:
+            response.message ||
+            'EPG auto-match is running. Results will appear when complete.',
+          color: 'blue',
+        });
+        return;
+      }
+
       if (response.matched) {
-        // Update the form with the new EPG data
-        if (response.channel && response.channel.epg_data_id) {
+        if (response.channel?.epg_data_id) {
           setValue('epg_data_id', response.channel.epg_data_id);
         }
 
@@ -192,7 +204,9 @@ const ChannelForm = ({ channel: channelProp = null, isOpen, onClose }) => {
       });
       console.error('Auto-match error:', error);
     } finally {
-      setAutoMatchLoading(false);
+      if (!accepted) {
+        setAutoMatchLoading(false);
+      }
     }
   };
 
@@ -354,6 +368,48 @@ const ChannelForm = ({ channel: channelProp = null, isOpen, onClose }) => {
     resolver: yupResolver(validationSchema),
   });
 
+  useEffect(() => {
+    const onMatchResult = (event) => {
+      const data = event.detail;
+      if (!channel?.id || String(data.channel_id) !== String(channel.id)) {
+        return;
+      }
+
+      if (data.matched && data.channel?.epg_data_id) {
+        setValue('epg_data_id', data.channel.epg_data_id);
+      }
+
+      showNotification({
+        title: data.matched ? 'Success' : 'No Match Found',
+        message: data.message,
+        color: data.matched ? 'green' : 'orange',
+      });
+      setAutoMatchLoading(false);
+    };
+
+    window.addEventListener('single-channel-epg-match', onMatchResult);
+    return () =>
+      window.removeEventListener('single-channel-epg-match', onMatchResult);
+  }, [channel?.id, setValue]);
+
+  useEffect(() => {
+    if (!autoMatchLoading) {
+      return undefined;
+    }
+
+    const timeoutId = window.setTimeout(() => {
+      setAutoMatchLoading(false);
+      showNotification({
+        title: 'Matching Timed Out',
+        message:
+          'EPG auto-match is taking longer than expected. Check back shortly or try again.',
+        color: 'orange',
+      });
+    }, 180_000);
+
+    return () => window.clearTimeout(timeoutId);
+  }, [autoMatchLoading]);
+
   const clearOverrides = async () => {
     if (!channel) return;
     try {
@@ -485,13 +541,21 @@ const ChannelForm = ({ channel: channelProp = null, isOpen, onClose }) => {
     return <></>;
   }
 
+  // Case- and accent-insensitive.
+  const foldText = (text) =>
+    text
+      .toLowerCase()
+      .normalize('NFD')
+      .replace(/[\u0300-\u036f]/g, '');
+
+  // Every term must match, against name and id combined.
+  const tvgFilterTerms = foldText(tvgFilter).split(/\s+/).filter(Boolean);
   const filteredTvgs = tvgs
     .filter((tvg) => tvg.epg_source == selectedEPG)
-    .filter(
-      (tvg) =>
-        tvg.name.toLowerCase().includes(tvgFilter.toLowerCase()) ||
-        tvg.tvg_id.toLowerCase().includes(tvgFilter.toLowerCase())
-    );
+    .filter((tvg) => {
+      const haystack = foldText(`${tvg.name} ${tvg.tvg_id}`);
+      return tvgFilterTerms.every((term) => haystack.includes(term));
+    });
 
   const filteredLogos = logoOptions.filter((logo) =>
     logo.name.toLowerCase().includes(logoFilter.toLowerCase())
@@ -1072,6 +1136,7 @@ const ChannelForm = ({ channel: channelProp = null, isOpen, onClose }) => {
                     {/* Filter Input */}
                     <TextInput
                       label="Filter"
+                      name="tvg-filter"
                       value={tvgFilter}
                       onChange={(event) =>
                         setTvgFilter(event.currentTarget.value)
diff --git a/frontend/src/components/forms/EPG.jsx b/frontend/src/components/forms/EPG.jsx
index f7e6ec92..7b8118de 100644
--- a/frontend/src/components/forms/EPG.jsx
+++ b/frontend/src/components/forms/EPG.jsx
@@ -29,7 +29,7 @@ import { showNotification } from '../../utils/notificationUtils.js';
 import API from '../../api.js';
 import useEPGsStore from '../../store/epgs';
 
-// Countries are fetched dynamically from the SD API on component mount.
+// Countries are fetched with lineups from the backend on component mount.
 // Fallback list used if the API call fails.
 const SD_COUNTRIES_FALLBACK = [
   { value: 'USA', label: 'United States' },
@@ -48,6 +48,16 @@ const SD_COUNTRIES_FALLBACK = [
   { value: 'NZL', label: 'New Zealand' },
 ];
 
+const mapSDCountries = (data) => {
+  if (!data) return null;
+  const all = Object.values(data).flat();
+  const mapped = all
+    .filter((c) => c.shortName && c.fullName)
+    .map((c) => ({ value: c.shortName, label: c.fullName }))
+    .sort((a, b) => a.label.localeCompare(b.label));
+  return mapped.length > 0 ? mapped : null;
+};
+
 // ESPN HD logo previews — packaged as static URLs so no API call is needed.
 // These are publicly accessible S3 URLs that don't require authentication.
 const SD_LOGO_PREVIEW_BASE =
@@ -309,6 +319,8 @@ const SDLineupManager = ({ sourceId }) => {
       if (data) {
         setActiveLineups(data.lineups || []);
         setLineupNotice(data.notice || null);
+        const mappedCountries = mapSDCountries(data.countries);
+        if (mappedCountries) setCountries(mappedCountries);
         // Always update changesRemaining from server — includes null (unknown) and 0 (locked)
         if (data.changes_remaining !== undefined) {
           setChangesRemaining(data.changes_remaining);
@@ -325,18 +337,6 @@ const SDLineupManager = ({ sourceId }) => {
   useEffect(() => {
     if (sourceId) {
       fetchActiveLineups();
-      // Fetch country list from SD API per their recommendation to not hardcode
-      fetch('https://json.schedulesdirect.org/20141201/available/countries')
-        .then((r) => r.json())
-        .then((data) => {
-          const all = Object.values(data).flat();
-          const mapped = all
-            .filter((c) => c.shortName && c.fullName)
-            .map((c) => ({ value: c.shortName, label: c.fullName }))
-            .sort((a, b) => a.label.localeCompare(b.label));
-          if (mapped.length > 0) setCountries(mapped);
-        })
-        .catch(() => {}); // fallback list remains if fetch fails
     }
   }, [sourceId, fetchActiveLineups]);
 
diff --git a/frontend/src/components/forms/LiveGroupFilter.jsx b/frontend/src/components/forms/LiveGroupFilter.jsx
index 626ec55e..5ed2be94 100644
--- a/frontend/src/components/forms/LiveGroupFilter.jsx
+++ b/frontend/src/components/forms/LiveGroupFilter.jsx
@@ -34,6 +34,7 @@ import {
   getRegexOptions,
   getStreamsRegexPreview,
   isExpectedOccupantForGroup,
+  effectiveSyncGroupId,
   isGroupVisible,
   rangeFor,
 } from '../../utils/forms/LiveGroupFilterUtils.js';
@@ -131,7 +132,12 @@ const LiveGroupFilter = ({
   // (in-memory range overlap with sibling groups) sources so the sweep
   // can refresh form-overlap synchronously without firing HTTP for
   // groups that did not change.
-  const scheduleConflictScan = (groupId, rawStart, rawEnd) => {
+  const scheduleConflictScan = (
+    groupId,
+    rawStart,
+    rawEnd,
+    expectedGroupId = groupId
+  ) => {
     if (conflictTimersRef.current[groupId]) {
       clearTimeout(conflictTimersRef.current[groupId]);
     }
@@ -156,7 +162,7 @@ const LiveGroupFilter = ({
           ? result.occupants
           : [];
         const unexpected = occupants.filter(
-          (o) => !isExpectedOccupantForGroup(o, groupId, playlist)
+          (o) => !isExpectedOccupantForGroup(o, expectedGroupId, playlist)
         );
         setConflictSource(groupId, 'occupant', unexpected.length > 0);
       } catch (e) {
@@ -221,7 +227,8 @@ const LiveGroupFilter = ({
         scheduleConflictScan(
           g.channel_group,
           range.startRaw,
-          g.auto_sync_channel_end
+          g.auto_sync_channel_end,
+          effectiveSyncGroupId(g)
         );
       }
     }
diff --git a/frontend/src/components/forms/M3U.jsx b/frontend/src/components/forms/M3U.jsx
index e27570db..07b430ef 100644
--- a/frontend/src/components/forms/M3U.jsx
+++ b/frontend/src/components/forms/M3U.jsx
@@ -1,11 +1,11 @@
 // Modal.js
 import React, { useEffect, useState } from 'react';
 import useUserAgentsStore from '../../store/userAgents';
+import useServerGroupsStore from '../../store/serverGroups';
 import M3UProfiles from './M3UProfiles';
 import {
   Box,
   Button,
-  Checkbox,
   Divider,
   FileInput,
   Flex,
@@ -35,6 +35,7 @@ import {
   prepareSubmitValues,
   updatePlaylist,
 } from '../../utils/forms/M3uUtils.js';
+import ServerGroupsManagerModal from '../ServerGroupsManagerModal';
 
 const M3U = ({
   m3uAccount = null,
@@ -43,6 +44,7 @@ const M3U = ({
   playlistCreated = false,
 }) => {
   const userAgents = useUserAgentsStore((s) => s.userAgents);
+  const serverGroups = useServerGroupsStore((s) => s.serverGroups);
   const fetchChannelGroups = useChannelsStore((s) => s.fetchChannelGroups);
   const fetchEPGs = useEPGsStore((s) => s.fetchEPGs);
   const fetchCategories = useVODStore((s) => s.fetchCategories);
@@ -54,6 +56,9 @@ const M3U = ({
   const [groupFilterModalOpen, setGroupFilterModalOpen] = useState(false);
   const [filterModalOpen, setFilterModalOpen] = useState(false);
   const [scheduleType, setScheduleType] = useState('interval');
+  const [serverGroupsManagerOpen, setServerGroupsManagerOpen] = useState(false);
+  const [serverGroupsCreateOnOpen, setServerGroupsCreateOnOpen] =
+    useState(false);
 
   const form = useForm({
     mode: 'uncontrolled',
@@ -61,6 +66,7 @@ const M3U = ({
       name: '',
       server_url: '',
       user_agent: '0',
+      server_group: '0',
       is_active: true,
       max_streams: 0,
       refresh_interval: 24,
@@ -88,6 +94,9 @@ const M3U = ({
         server_url: m3uAccount.server_url,
         max_streams: m3uAccount.max_streams,
         user_agent: m3uAccount.user_agent ? `${m3uAccount.user_agent}` : '0',
+        server_group: m3uAccount.server_group
+          ? `${m3uAccount.server_group}`
+          : '0',
         is_active: m3uAccount.is_active,
         refresh_interval: m3uAccount.refresh_interval,
         cron_expression: m3uAccount.cron_expression || '',
@@ -203,7 +212,7 @@ const M3U = ({
   return (
     <>
       <Modal
-        size={700}
+        size={960}
         opened={isOpen}
         onClose={close}
         title="M3U Account"
@@ -216,10 +225,9 @@ const M3U = ({
         <LoadingOverlay visible={form.submitting} overlayBlur={2} />
 
         <form onSubmit={form.onSubmit(onSubmit)}>
-          <Group justify="space-between" align="top">
-            <Stack gap="5" style={{ flex: 1, minWidth: 0 }}>
+          <Group align="flex-start" gap="md" wrap="nowrap">
+            <Stack gap="xs" style={{ flex: 1, minWidth: 0 }}>
               <TextInput
-                style={{ width: '100%' }}
                 id="name"
                 name="name"
                 label="Name"
@@ -228,7 +236,6 @@ const M3U = ({
                 key={form.key('name')}
               />
               <TextInput
-                style={{ width: '100%' }}
                 id="server_url"
                 name="server_url"
                 label="URL"
@@ -236,7 +243,6 @@ const M3U = ({
                 {...form.getInputProps('server_url')}
                 key={form.key('server_url')}
               />
-
               <Select
                 id="account_type"
                 name="account_type"
@@ -248,49 +254,15 @@ const M3U = ({
                   </>
                 }
                 data={[
-                  {
-                    value: 'STD',
-                    label: 'Standard',
-                  },
-                  {
-                    value: 'XC',
-                    label: 'Xtream Codes',
-                  },
+                  { value: 'STD', label: 'Standard' },
+                  { value: 'XC', label: 'Xtream Codes' },
                 ]}
                 key={form.key('account_type')}
                 {...form.getInputProps('account_type')}
               />
 
               {form.getValues().account_type == 'XC' && (
-                <Box>
-                  {!m3uAccount && (
-                    <Group justify="space-between">
-                      <Box>Create EPG</Box>
-                      <Switch
-                        id="create_epg"
-                        name="create_epg"
-                        description="Automatically create matching EPG source for this Xtream account"
-                        key={form.key('create_epg')}
-                        {...form.getInputProps('create_epg', {
-                          type: 'checkbox',
-                        })}
-                      />
-                    </Group>
-                  )}
-
-                  <Group justify="space-between">
-                    <Box>Enable VOD Scanning</Box>
-                    <Switch
-                      id="enable_vod"
-                      name="enable_vod"
-                      description="Scan and import VOD content (movies/series) from this Xtream account"
-                      key={form.key('enable_vod')}
-                      {...form.getInputProps('enable_vod', {
-                        type: 'checkbox',
-                      })}
-                    />
-                  </Group>
-
+                <>
                   <TextInput
                     id="username"
                     name="username"
@@ -298,7 +270,6 @@ const M3U = ({
                     description="Username for Xtream Codes authentication"
                     {...form.getInputProps('username')}
                   />
-
                   <PasswordInput
                     id="password"
                     name="password"
@@ -306,7 +277,7 @@ const M3U = ({
                     description="Password for Xtream Codes authentication (leave empty to keep existing)"
                     {...form.getInputProps('password')}
                   />
-                </Box>
+                </>
               )}
 
               {form.getValues().account_type != 'XC' && (
@@ -326,7 +297,6 @@ const M3U = ({
                       },
                     }}
                   />
-
                   <DateTimePicker
                     label="Expiration Date"
                     description="Set an expiration date to receive a warning notification"
@@ -342,9 +312,8 @@ const M3U = ({
 
             <Divider size="sm" orientation="vertical" />
 
-            <Stack gap="5" style={{ flex: 1 }}>
+            <Stack gap="xs" style={{ flex: 1, minWidth: 0 }}>
               <NumberInput
-                style={{ width: '100%' }}
                 id="max_streams"
                 name="max_streams"
                 label="Max Streams"
@@ -354,7 +323,41 @@ const M3U = ({
                 {...form.getInputProps('max_streams')}
                 key={form.key('max_streams')}
               />
-
+              <Select
+                id="server_group"
+                name="server_group"
+                label="Server Group"
+                description="Share login limits across accounts in a server group. Set max streams on each profile (unlimited profiles skip group enforcement)."
+                key={form.key('server_group')}
+                value={form.getValues().server_group}
+                onChange={(value) => {
+                  if (value === '__new__') {
+                    setServerGroupsCreateOnOpen(true);
+                    setServerGroupsManagerOpen(true);
+                    return;
+                  }
+                  form.setFieldValue('server_group', value);
+                }}
+                data={[
+                  { value: '0', label: '(None)' },
+                  ...serverGroups.map((group) => ({
+                    label: group.name,
+                    value: `${group.id}`,
+                  })),
+                  { value: '__new__', label: '+ Add server group...' },
+                ]}
+              />
+              <Button
+                variant="subtle"
+                size="compact-xs"
+                onClick={() => {
+                  setServerGroupsCreateOnOpen(false);
+                  setServerGroupsManagerOpen(true);
+                }}
+                style={{ alignSelf: 'flex-start' }}
+              >
+                Manage server groups
+              </Button>
               <Select
                 id="user_agent"
                 name="user_agent"
@@ -369,7 +372,11 @@ const M3U = ({
                   }))
                 )}
               />
+            </Stack>
 
+            <Divider size="sm" orientation="vertical" />
+
+            <Stack gap="xs" style={{ flex: 1, minWidth: 0 }}>
               <ScheduleInput
                 scheduleType={scheduleType}
                 onScheduleTypeChange={setScheduleType}
@@ -390,7 +397,6 @@ const M3U = ({
                   </>
                 }
               />
-
               <NumberInput
                 min={0}
                 max={365}
@@ -399,74 +405,114 @@ const M3U = ({
                 {...form.getInputProps('stale_stream_days')}
               />
 
-              <NumberInput
-                min={0}
-                max={999}
-                label="VOD Priority"
-                description="Priority for VOD provider selection (higher numbers = higher priority). Used when multiple providers offer the same content."
-                {...form.getInputProps('priority')}
-                key={form.key('priority')}
-              />
+              {form.getValues().account_type == 'XC' && (
+                <Box>
+                  <NumberInput
+                    min={0}
+                    max={999}
+                    label="VOD Priority"
+                    description="Priority for VOD provider selection (higher numbers = higher priority). Used when multiple providers offer the same content."
+                    {...form.getInputProps('priority')}
+                    key={form.key('priority')}
+                  />
+
+                  <Group justify="space-between">
+                    <Box>Enable VOD Scanning</Box>
+                    <Switch
+                      id="enable_vod"
+                      name="enable_vod"
+                      description="Scan and import VOD content (movies/series) from this Xtream account"
+                      key={form.key('enable_vod')}
+                      {...form.getInputProps('enable_vod', {
+                        type: 'checkbox',
+                      })}
+                    />
+                  </Group>
+
+                  {!m3uAccount && (
+                    <Group justify="space-between">
+                      <Box>Create EPG</Box>
+                      <Switch
+                        id="create_epg"
+                        name="create_epg"
+                        description="Automatically create matching EPG source for this Xtream account"
+                        key={form.key('create_epg')}
+                        {...form.getInputProps('create_epg', {
+                          type: 'checkbox',
+                        })}
+                      />
+                    </Group>
+                  )}
+                </Box>
+              )}
             </Stack>
           </Group>
 
           <Divider my="md" />
 
-          <Flex gap="xl" wrap="wrap">
-            <Checkbox
+          <Flex
+            gap="md"
+            justify="space-between"
+            align="center"
+            wrap="wrap"
+            mih={50}
+          >
+            <Switch
+              id="is_active"
+              name="is_active"
               label="Is Active"
               description="Enable or disable this M3U account"
-              {...form.getInputProps('is_active', { type: 'checkbox' })}
               key={form.key('is_active')}
+              {...form.getInputProps('is_active', { type: 'checkbox' })}
             />
-          </Flex>
 
-          <Flex mih={50} gap="xs" justify="flex-end" align="flex-end">
-            {playlist && (
-              <>
-                <Button
-                  variant="filled"
-                  size="sm"
-                  onClick={() => setFilterModalOpen(true)}
-                >
-                  Filters
-                </Button>
-                <Button
-                  variant="filled"
-                  // color={theme.custom.colors.buttonPrimary}
-                  size="sm"
-                  onClick={() => {
-                    // If this is an XC account with VOD enabled, fetch VOD categories
-                    if (
-                      m3uAccount?.account_type === 'XC' &&
-                      m3uAccount?.enable_vod
-                    ) {
-                      fetchCategories();
-                    }
-                    setGroupFilterModalOpen(true);
-                  }}
-                >
-                  Groups
-                </Button>
-                <Button
-                  variant="filled"
-                  // color={theme.custom.colors.buttonPrimary}
-                  size="sm"
-                  onClick={() => setProfileModalOpen(true)}
-                >
-                  Profiles
-                </Button>
-              </>
-            )}
+            <Flex gap="xs" align="center">
+              {playlist && (
+                <>
+                  <Button
+                    variant="filled"
+                    size="sm"
+                    onClick={() => setFilterModalOpen(true)}
+                  >
+                    Filters
+                  </Button>
+                  <Button
+                    variant="filled"
+                    // color={theme.custom.colors.buttonPrimary}
+                    size="sm"
+                    onClick={() => {
+                      // If this is an XC account with VOD enabled, fetch VOD categories
+                      if (
+                        m3uAccount?.account_type === 'XC' &&
+                        m3uAccount?.enable_vod
+                      ) {
+                        fetchCategories();
+                      }
+                      setGroupFilterModalOpen(true);
+                    }}
+                  >
+                    Groups
+                  </Button>
+                  <Button
+                    variant="filled"
+                    // color={theme.custom.colors.buttonPrimary}
+                    size="sm"
+                    onClick={() => setProfileModalOpen(true)}
+                  >
+                    Profiles
+                  </Button>
+                </>
+              )}
 
-            <Button
-              type="submit"
-              variant="filled"
-              disabled={form.submitting}
-              size="sm"
-            >
-              Save
-            </Button>
+              <Button
+                type="submit"
+                variant="filled"
+                disabled={form.submitting}
+                size="sm"
+              >
+                Save
+              </Button>
+            </Flex>
           </Flex>
         </form>
       </Modal>
@@ -489,6 +535,20 @@ const M3U = ({
           />
         </>
       )}
+
+      <ServerGroupsManagerModal
+        isOpen={serverGroupsManagerOpen}
+        onClose={() => {
+          setServerGroupsManagerOpen(false);
+          setServerGroupsCreateOnOpen(false);
+        }}
+        openCreateOnMount={serverGroupsCreateOnOpen}
+        onGroupCreated={(group) => {
+          if (group?.id) {
+            form.setFieldValue('server_group', `${group.id}`);
+          }
+        }}
+      />
     </>
   );
 };
diff --git a/frontend/src/components/forms/ServerGroup.jsx b/frontend/src/components/forms/ServerGroup.jsx
new file mode 100644
index 00000000..80c8c1a4
--- /dev/null
+++ b/frontend/src/components/forms/ServerGroup.jsx
@@ -0,0 +1,86 @@
+import React, { useEffect, useMemo } from 'react';
+import { useForm } from 'react-hook-form';
+import { yupResolver } from '@hookform/resolvers/yup';
+import * as Yup from 'yup';
+import API from '../../api';
+import { Button, Flex, Modal, TextInput } from '@mantine/core';
+
+const schema = Yup.object({
+  name: Yup.string().required('Name is required'),
+});
+
+const ServerGroupForm = ({
+  serverGroup = null,
+  isOpen,
+  onClose,
+  onSaved,
+}) => {
+  const defaultValues = useMemo(
+    () => ({
+      name: serverGroup?.name || '',
+    }),
+    [serverGroup]
+  );
+
+  const {
+    register,
+    handleSubmit,
+    formState: { errors, isSubmitting },
+    reset,
+  } = useForm({
+    defaultValues,
+    resolver: yupResolver(schema),
+  });
+
+  const onSubmit = async (values) => {
+    let response;
+    if (serverGroup?.id) {
+      response = await API.updateServerGroup({ id: serverGroup.id, ...values });
+    } else {
+      response = await API.addServerGroup(values);
+    }
+
+    if (response) {
+      onSaved?.(response);
+    }
+
+    reset();
+    onClose();
+  };
+
+  useEffect(() => {
+    reset(defaultValues);
+  }, [defaultValues, reset]);
+
+  if (!isOpen) {
+    return null;
+  }
+
+  return (
+    <Modal
+      opened={isOpen}
+      onClose={onClose}
+      title="Server Group"
+      centered
+      withinPortal
+      zIndex={400}
+    >
+      <form onSubmit={handleSubmit(onSubmit)}>
+        <TextInput
+          label="Name"
+          description="Accounts in this group share connection limits when they use the same provider login. Limits come from each account profile's max streams."
+          {...register('name')}
+          error={errors.name?.message}
+        />
+
+        <Flex mih={50} gap="xs" justify="flex-end" align="flex-end">
+          <Button size="small" type="submit" disabled={isSubmitting}>
+            Submit
+          </Button>
+        </Flex>
+      </form>
+    </Modal>
+  );
+};
+
+export default ServerGroupForm;
diff --git a/frontend/src/components/forms/__tests__/AutoSyncBasic.test.jsx b/frontend/src/components/forms/__tests__/AutoSyncBasic.test.jsx
index 67055a4a..8392171f 100644
--- a/frontend/src/components/forms/__tests__/AutoSyncBasic.test.jsx
+++ b/frontend/src/components/forms/__tests__/AutoSyncBasic.test.jsx
@@ -289,6 +289,25 @@ describe('AutoSyncBasic', () => {
       const call = onApplyGroupChange.mock.calls[0][0];
       expect(call.custom_properties.channel_numbering_fallback).toBe(1);
     });
+
+    it('drops End when the fallback start exceeds End in provider mode', () => {
+      // Mirrors fixed mode: an inverted fallback range would fail every
+      // numberless stream, so End is dropped rather than silently kept.
+      const { onApplyGroupChange } = renderComponent({
+        custom_properties: {
+          channel_numbering_mode: 'provider',
+          channel_numbering_fallback: 1,
+        },
+        auto_sync_channel_end: 200,
+      });
+      vi.mocked(clampChannelNumber).mockReturnValueOnce(500);
+      fireEvent.change(screen.getByTestId(/start/i), {
+        target: { value: '500' },
+      });
+      const call = onApplyGroupChange.mock.calls[0][0];
+      expect(call.custom_properties.channel_numbering_fallback).toBe(500);
+      expect(call.auto_sync_channel_end).toBeFalsy();
+    });
   });
 
   // ── updateEnd ──────────────────────────────────────────────────────────────
diff --git a/frontend/src/components/forms/__tests__/Channel.test.jsx b/frontend/src/components/forms/__tests__/Channel.test.jsx
index 7b00775a..d822c9e1 100644
--- a/frontend/src/components/forms/__tests__/Channel.test.jsx
+++ b/frontend/src/components/forms/__tests__/Channel.test.jsx
@@ -703,6 +703,25 @@ describe('ChannelForm', () => {
       expect(autoMatch).not.toBeDisabled();
     });
 
+    it('shows in-progress notification when matchChannelEpg returns accepted', async () => {
+      const channel = makeChannel();
+      vi.mocked(ChannelUtils.matchChannelEpg).mockResolvedValue({
+        accepted: true,
+        message: 'EPG matching started',
+      });
+      setupMocks({ channel });
+      render(<ChannelForm {...defaultProps({ channel })} />);
+      fireEvent.click(screen.getByText('Auto Match'));
+      await waitFor(() => {
+        expect(showNotification).toHaveBeenCalledWith(
+          expect.objectContaining({
+            title: 'Matching in Progress',
+            color: 'blue',
+          })
+        );
+      });
+    });
+
     it('calls matchChannelEpg with the channel on click', async () => {
       const channel = makeChannel();
       vi.mocked(ChannelUtils.matchChannelEpg).mockResolvedValue({
@@ -1206,4 +1225,153 @@ describe('ChannelForm', () => {
       expect(screen.queryByText(/Clear All Overrides/)).not.toBeInTheDocument();
     });
   });
+
+  // ── EPG filter search ──────────────────────────────────────────────────────
+  describe('EPG filter search', () => {
+    const skyText = 'Sky Sports Ultra HD (SkySportUltraHD.1.uk)';
+    const btText = 'BT Sport 1 (BTSport1.uk)';
+
+    const epgTvgs = [
+      {
+        id: 'tvg-sky',
+        name: 'Sky Sports Ultra HD',
+        tvg_id: 'SkySportUltraHD.1.uk',
+        epg_source: 10,
+        icon_url: '',
+      },
+      {
+        id: 'tvg-bt',
+        name: 'BT Sport 1',
+        tvg_id: 'BTSport1.uk',
+        epg_source: 10,
+        icon_url: '',
+      },
+      // Accent in the name, but the id does NOT mirror it ("decale"): an ascii
+      // query only matches if the haystack is accent-folded.
+      {
+        id: 'tvg-canal',
+        name: 'Canal Décalé',
+        tvg_id: 'CPLUS42.fr',
+        epg_source: 10,
+        icon_url: '',
+      },
+      // Plain ascii everywhere: an accented query only matches if the query
+      // itself is accent-folded.
+      {
+        id: 'tvg-decaleplus',
+        name: 'Decale Plus',
+        tvg_id: 'DECP.fr',
+        epg_source: 10,
+        icon_url: '',
+      },
+    ];
+    const canalText = 'Canal Décalé (CPLUS42.fr)';
+    const decaleText = 'Decale Plus (DECP.fr)';
+
+    // Render the form, point the store at our two same-source tvgs, and pick the
+    // EPG source so the dropdown list is populated.
+    const renderAndSelectSource = () => {
+      setupMocks();
+      // Stable references — recreating these per selector call would retrigger
+      // the epgs-dependent effect and loop forever.
+      const epgs = makeEpgs();
+      const tvgsById = {};
+      vi.mocked(useEPGsStore).mockImplementation((sel) =>
+        sel({ epgs, tvgs: epgTvgs, tvgsById })
+      );
+      render(<ChannelForm {...defaultProps()} />);
+      fireEvent.change(screen.getByTestId('select-Source'), {
+        target: { value: '10' },
+      });
+    };
+
+    const typeFilter = (value) =>
+      fireEvent.change(screen.getByTestId('text-input-tvg-filter'), {
+        target: { value },
+      });
+
+    it('matches when space-separated terms each appear across name and id', () => {
+      renderAndSelectSource();
+      typeFilter('Sky uk');
+      expect(screen.getByText(skyText)).toBeInTheDocument();
+      expect(screen.queryByText(btText)).not.toBeInTheDocument();
+    });
+
+    it('matches regardless of term order', () => {
+      renderAndSelectSource();
+      typeFilter('uk sky');
+      expect(screen.getByText(skyText)).toBeInTheDocument();
+      expect(screen.queryByText(btText)).not.toBeInTheDocument();
+    });
+
+    it('still matches a single substring term', () => {
+      renderAndSelectSource();
+      typeFilter('sky');
+      expect(screen.getByText(skyText)).toBeInTheDocument();
+      expect(screen.queryByText(btText)).not.toBeInTheDocument();
+    });
+
+    it('shows every row for the source when the filter is empty', () => {
+      renderAndSelectSource();
+      expect(screen.getByText(skyText)).toBeInTheDocument();
+      expect(screen.getByText(btText)).toBeInTheDocument();
+    });
+
+    it('shows no rows when a term matches nothing', () => {
+      renderAndSelectSource();
+      typeFilter('sky zzz');
+      expect(screen.queryByText(skyText)).not.toBeInTheDocument();
+      expect(screen.queryByText(btText)).not.toBeInTheDocument();
+    });
+
+    it('ignores case, including all-caps', () => {
+      renderAndSelectSource();
+      typeFilter('SKY UK');
+      expect(screen.getByText(skyText)).toBeInTheDocument();
+      expect(screen.queryByText(btText)).not.toBeInTheDocument();
+    });
+
+    it('matches when one term hits the name and another hits the id', () => {
+      renderAndSelectSource();
+      typeFilter('Sports uk');
+      expect(screen.getByText(skyText)).toBeInTheDocument();
+      expect(screen.queryByText(btText)).not.toBeInTheDocument();
+    });
+
+    it('tolerates leading, trailing and repeated whitespace', () => {
+      renderAndSelectSource();
+      typeFilter('  sky   uk  ');
+      expect(screen.getByText(skyText)).toBeInTheDocument();
+      expect(screen.queryByText(btText)).not.toBeInTheDocument();
+    });
+
+    it('matches an id fragment that is not in the display name', () => {
+      renderAndSelectSource();
+      typeFilter('skysport');
+      expect(screen.getByText(skyText)).toBeInTheDocument();
+      expect(screen.queryByText(btText)).not.toBeInTheDocument();
+    });
+
+    it('matches a name word combined with a channel number', () => {
+      renderAndSelectSource();
+      typeFilter('bt 1');
+      expect(screen.getByText(btText)).toBeInTheDocument();
+      expect(screen.queryByText(skyText)).not.toBeInTheDocument();
+    });
+
+    it('folds accents in the data so a plain ascii query matches', () => {
+      renderAndSelectSource();
+      typeFilter('canal decale');
+      expect(screen.getByText(canalText)).toBeInTheDocument();
+      expect(screen.queryByText(decaleText)).not.toBeInTheDocument();
+      expect(screen.queryByText(skyText)).not.toBeInTheDocument();
+    });
+
+    it('folds accents in the query so it matches plain ascii data', () => {
+      renderAndSelectSource();
+      typeFilter('décalé');
+      expect(screen.getByText(decaleText)).toBeInTheDocument();
+      expect(screen.queryByText(skyText)).not.toBeInTheDocument();
+    });
+  });
 });
diff --git a/frontend/src/components/forms/__tests__/EPG.test.jsx b/frontend/src/components/forms/__tests__/EPG.test.jsx
index 1e64a563..0597f0a0 100644
--- a/frontend/src/components/forms/__tests__/EPG.test.jsx
+++ b/frontend/src/components/forms/__tests__/EPG.test.jsx
@@ -215,12 +215,20 @@ vi.mock('@mantine/core', async () => ({
       {(data ?? []).map((opt) => {
         const val = typeof opt === 'string' ? opt : opt.value;
         const lbl = typeof opt === 'string' ? opt : opt.label;
-        return <option key={val} value={val}>{lbl}</option>;
+        return (
+          <option key={val} value={val}>
+            {lbl}
+          </option>
+        );
       })}
     </select>
   ),
   Loader: ({ size }) => <div data-testid="loader" data-size={size} />,
-  Badge: ({ children, color }) => <span data-testid="badge" data-color={color}>{children}</span>,
+  Badge: ({ children, color }) => (
+    <span data-testid="badge" data-color={color}>
+      {children}
+    </span>
+  ),
   ScrollArea: ({ children }) => <div data-testid="scroll-area">{children}</div>,
   Table: ({ children }) => <table>{children}</table>,
   Tooltip: ({ children }) => <div>{children}</div>,
@@ -237,10 +245,15 @@ vi.mock('@mantine/core', async () => ({
     </label>
   ),
   UnstyledButton: ({ children, onClick, ...props }) => (
-    <button type="button" onClick={onClick} {...props}>{children}</button>
+    <button type="button" onClick={onClick} {...props}>
+      {children}
+    </button>
   ),
   Alert: ({ children, title, color, icon }) => (
-    <div data-testid="alert" data-color={color}><strong>{title}</strong>{children}</div>
+    <div data-testid="alert" data-color={color}>
+      <strong>{title}</strong>
+      {children}
+    </div>
   ),
   Stack: ({ children, gap }) => <div data-testid="stack">{children}</div>,
   Text: ({ children, ...props }) => <span>{children}</span>,
diff --git a/frontend/src/components/forms/settings/ProxySettingsForm.jsx b/frontend/src/components/forms/settings/ProxySettingsForm.jsx
index 52440769..91b36bb7 100644
--- a/frontend/src/components/forms/settings/ProxySettingsForm.jsx
+++ b/frontend/src/components/forms/settings/ProxySettingsForm.jsx
@@ -5,80 +5,119 @@ import { updateSetting } from '../../../utils/pages/SettingsUtils.js';
 import {
   Alert,
   Button,
+  Collapse,
   Flex,
   NumberInput,
   Stack,
   TextInput,
 } from '@mantine/core';
+import { ChevronDown, ChevronRight } from 'lucide-react';
 import { PROXY_SETTINGS_OPTIONS } from '../../../constants.js';
 import {
   getProxySettingDefaults,
   getProxySettingsFormInitialValues,
 } from '../../../utils/forms/settings/ProxySettingsFormUtils.js';
 
+const isNumericField = (key) => {
+  return [
+    'buffering_timeout',
+    'redis_chunk_ttl',
+    'channel_shutdown_delay',
+    'channel_init_grace_period',
+    'channel_client_wait_period',
+    'new_client_behind_seconds',
+  ].includes(key);
+};
+
+const isFloatField = (key) => key === 'buffering_speed';
+
+const getNumericFieldMax = (key) => {
+  if (key === 'buffering_timeout') return 300;
+  if (key === 'redis_chunk_ttl') return 3600;
+  if (key === 'channel_shutdown_delay') return 300;
+  if (key === 'channel_client_wait_period') return 300;
+  if (key === 'new_client_behind_seconds') return 120;
+  return 300;
+};
+
+const renderProxySettingField = (key, config, proxySettingsForm) => {
+  if (isNumericField(key)) {
+    return (
+      <NumberInput
+        key={key}
+        label={config.label}
+        {...proxySettingsForm.getInputProps(key)}
+        description={config.description || null}
+        min={0}
+        max={getNumericFieldMax(key)}
+      />
+    );
+  }
+
+  if (isFloatField(key)) {
+    return (
+      <NumberInput
+        key={key}
+        label={config.label}
+        {...proxySettingsForm.getInputProps(key)}
+        description={config.description || null}
+        min={0.0}
+        max={10.0}
+        step={0.01}
+        precision={1}
+      />
+    );
+  }
+
+  return (
+    <TextInput
+      key={key}
+      label={config.label}
+      {...proxySettingsForm.getInputProps(key)}
+      description={config.description || null}
+    />
+  );
+};
+
 const ProxySettingsOptions = React.memo(({ proxySettingsForm }) => {
-  const isNumericField = (key) => {
-    // Determine if this field should be a NumberInput
-    return [
-      'buffering_timeout',
-      'redis_chunk_ttl',
-      'channel_shutdown_delay',
-      'channel_init_grace_period',
-      'new_client_behind_seconds',
-    ].includes(key);
-  };
-  const isFloatField = (key) => {
-    return key === 'buffering_speed';
-  };
-  const getNumericFieldMax = (key) => {
-    return key === 'buffering_timeout'
-      ? 300
-      : key === 'redis_chunk_ttl'
-        ? 3600
-        : key === 'channel_shutdown_delay'
-          ? 300
-          : key === 'new_client_behind_seconds'
-            ? 120
-            : 60;
-  };
+  const [advancedOpen, setAdvancedOpen] = useState(false);
+  const entries = Object.entries(PROXY_SETTINGS_OPTIONS);
+  const mainEntries = entries.filter(([, config]) => !config.advanced);
+  const advancedEntries = entries.filter(([, config]) => config.advanced);
+
   return (
     <>
-      {Object.entries(PROXY_SETTINGS_OPTIONS).map(([key, config]) => {
-        if (isNumericField(key)) {
-          return (
-            <NumberInput
-              key={key}
-              label={config.label}
-              {...proxySettingsForm.getInputProps(key)}
-              description={config.description || null}
-              min={0}
-              max={getNumericFieldMax(key)}
-            />
-          );
-        } else if (isFloatField(key)) {
-          return (
-            <NumberInput
-              key={key}
-              label={config.label}
-              {...proxySettingsForm.getInputProps(key)}
-              description={config.description || null}
-              min={0.0}
-              max={10.0}
-              step={0.01}
-              precision={1}
-            />
-          );
-        } else {
-          return (
-            <TextInput
-              key={key}
-              label={config.label}
-              {...proxySettingsForm.getInputProps(key)}
-              description={config.description || null}
-            />
-          );
-        }
-      })}
+      {mainEntries.map(([key, config]) =>
+        renderProxySettingField(key, config, proxySettingsForm)
+      )}
+
+      {advancedEntries.length > 0 && (
+        <>
+          <Button
+            variant="subtle"
+            size="xs"
+            leftSection={
+              advancedOpen ? (
+                <ChevronDown size={12} />
+              ) : (
+                <ChevronRight size={12} />
+              )
+            }
+            onClick={() => setAdvancedOpen((open) => !open)}
+            c="dimmed"
+            styles={{ root: { alignSelf: 'flex-start' } }}
+          >
+            {advancedOpen ? 'Hide' : 'Show'} Advanced Settings
+          </Button>
+          <Collapse in={advancedOpen}>
+            <Stack gap="sm">
+              {advancedEntries.map(([key, config]) =>
+                renderProxySettingField(key, config, proxySettingsForm)
+              )}
+            </Stack>
+          </Collapse>
+        </>
+      )}
     </>
   );
 });
diff --git a/frontend/src/components/forms/settings/__tests__/ProxySettingsForm.test.jsx b/frontend/src/components/forms/settings/__tests__/ProxySettingsForm.test.jsx
index c874b3e6..2b0dc55f 100644
--- a/frontend/src/components/forms/settings/__tests__/ProxySettingsForm.test.jsx
+++ b/frontend/src/components/forms/settings/__tests__/ProxySettingsForm.test.jsx
@@ -14,6 +14,21 @@ vi.mock('../../../../constants.js', () => ({
       description: 'Speed multiplier',
     },
     redis_url: { label: 'Redis URL', description: 'Redis connection URL' },
+    redis_chunk_ttl: {
+      label: 'Buffer Chunk TTL',
+      advanced: true,
+      description: 'Chunk TTL',
+    },
+    channel_init_grace_period: {
+      label: 'Channel Initialization Timeout',
+      advanced: true,
+      description: 'Init timeout',
+    },
+    channel_client_wait_period: {
+      label: 'Client Connect Grace Period',
+      advanced: true,
+      description: 'Advanced grace period',
+    },
   },
 }));
 
@@ -71,6 +86,8 @@ vi.mock('@mantine/core', () => ({
     </div>
   ),
   Stack: ({ children }) => <div>{children}</div>,
+  Collapse: ({ in: isOpen, children }) =>
+    isOpen ? <div data-testid="collapse-open">{children}</div> : null,
   TextInput: ({ label, description, ...rest }) => (
     <div>
       <label>{label}</label>
@@ -353,11 +370,38 @@ describe('ProxySettingsForm', () => {
 
   // ── ProxySettingsOptions field routing ─────────────────────────────────────
   describe('ProxySettingsOptions field routing', () => {
-    it('calls getInputProps for each PROXY_SETTINGS_OPTIONS key', () => {
+    it('binds main settings on initial render', () => {
       render(<ProxySettingsForm active={true} />);
       expect(formMock.getInputProps).toHaveBeenCalledWith('buffering_timeout');
       expect(formMock.getInputProps).toHaveBeenCalledWith('buffering_speed');
       expect(formMock.getInputProps).toHaveBeenCalledWith('redis_url');
     });
+
+    it('hides advanced settings until expanded', () => {
+      render(<ProxySettingsForm active={true} />);
+      expect(
+        screen.queryByTestId('number-input-Client Connect Grace Period')
+      ).not.toBeInTheDocument();
+      expect(
+        screen.queryByTestId('number-input-Channel Initialization Timeout')
+      ).not.toBeInTheDocument();
+      expect(
+        screen.queryByTestId('number-input-Buffer Chunk TTL')
+      ).not.toBeInTheDocument();
+      expect(screen.getByText('Show Advanced Settings')).toBeInTheDocument();
+    });
+
+    it('shows advanced settings when expanded', () => {
+      render(<ProxySettingsForm active={true} />);
+      fireEvent.click(screen.getByText('Show Advanced Settings'));
+      expect(screen.getByTestId('collapse-open')).toBeInTheDocument();
+      expect(
+        screen.getByTestId('number-input-Client Connect Grace Period')
+      ).toBeInTheDocument();
+      expect(
+        screen.getByTestId('number-input-Channel Initialization Timeout')
+      ).toBeInTheDocument();
+      expect(screen.getByTestId('number-input-Buffer Chunk TTL')).toBeInTheDocument();
+    });
   });
 });
diff --git a/frontend/src/components/tables/M3UsTable.jsx b/frontend/src/components/tables/M3UsTable.jsx
index 6384adc5..4a1d7e6f 100644
--- a/frontend/src/components/tables/M3UsTable.jsx
+++ b/frontend/src/components/tables/M3UsTable.jsx
@@ -8,6 +8,7 @@ import React, {
 import API from '../../api';
 import usePlaylistsStore from '../../store/playlists';
 import M3UForm from '../forms/M3U';
+import ServerGroupsManagerModal from '../ServerGroupsManagerModal';
 import { TableHelper } from '../../helpers';
 import {
   useMantineTheme,
@@ -144,6 +145,7 @@ const M3UTable = () => {
   const [data, setData] = useState([]);
   const [sorting, setSorting] = useState([{ id: 'name', desc: '' }]);
   const [deleting, setDeleting] = useState(false);
+  const [serverGroupsManagerOpen, setServerGroupsManagerOpen] = useState(false);
 
   const playlists = usePlaylistsStore((s) => s.playlists);
   const refreshProgress = usePlaylistsStore((s) => s.refreshProgress);
@@ -988,21 +990,31 @@ const M3UTable = () => {
         >
           M3U Accounts
         </Text>
-        <Button
-          leftSection={<SquarePlus size={14} />}
-          variant="light"
-          size="xs"
-          onClick={() => editPlaylist()}
-          p={5}
-          color="green"
-          style={{
-            borderWidth: '1px',
-            borderColor: 'green',
-            color: 'white',
-          }}
-        >
-          Add M3U
-        </Button>
+        <Flex gap={6}>
+          <Button
+            variant="light"
+            size="xs"
+            onClick={() => setServerGroupsManagerOpen(true)}
+            p={5}
+          >
+            Server Groups
+          </Button>
+          <Button
+            leftSection={<SquarePlus size={14} />}
+            variant="light"
+            size="xs"
+            onClick={() => editPlaylist()}
+            p={5}
+            color="green"
+            style={{
+              borderWidth: '1px',
+              borderColor: 'green',
+              color: 'white',
+            }}
+          >
+            Add M3U
+          </Button>
+        </Flex>
       </Flex>
 
       <Paper
@@ -1051,6 +1063,11 @@ const M3UTable = () => {
         playlistCreated={playlistCreated}
       />
 
+      <ServerGroupsManagerModal
+        isOpen={serverGroupsManagerOpen}
+        onClose={() => setServerGroupsManagerOpen(false)}
+      />
+
       <ConfirmationDialog
         opened={confirmDeleteOpen}
         onClose={() => setConfirmDeleteOpen(false)}
diff --git a/frontend/src/components/tables/ServerGroupsTable.jsx b/frontend/src/components/tables/ServerGroupsTable.jsx
new file mode 100644
index 00000000..ee3d07e4
--- /dev/null
+++ b/frontend/src/components/tables/ServerGroupsTable.jsx
@@ -0,0 +1,298 @@
+import { useEffect, useMemo, useRef, useState } from 'react';
+import API from '../../api';
+import useServerGroupsStore from '../../store/serverGroups';
+import usePlaylistsStore from '../../store/playlists';
+import useWarningsStore from '../../store/warnings';
+import ServerGroupForm from '../forms/ServerGroup';
+import ConfirmationDialog from '../ConfirmationDialog';
+import {
+  ActionIcon,
+  Box,
+  Button,
+  Center,
+  Flex,
+  Stack,
+  Text,
+} from '@mantine/core';
+import { SquareMinus, SquarePen, SquarePlus } from 'lucide-react';
+import { CustomTable, useTable } from './CustomTable';
+import './table.css';
+
+const TABLE_WIDTH = 360;
+const ACTIONS_COLUMN_SIZE = 76;
+const ACCOUNTS_COLUMN_SIZE = 72;
+
+const RowActions = ({ row, editServerGroup, deleteServerGroup }) => (
+  <Flex gap={4} justify="center" w="100%">
+    <ActionIcon
+      variant="transparent"
+      size="sm"
+      color="yellow.5"
+      onClick={() => editServerGroup(row.original)}
+    >
+      <SquarePen size="18" />
+    </ActionIcon>
+    <ActionIcon
+      variant="transparent"
+      size="sm"
+      color="red.9"
+      onClick={() => deleteServerGroup(row.original.id)}
+    >
+      <SquareMinus size="18" />
+    </ActionIcon>
+  </Flex>
+);
+
+const ServerGroupsTable = ({ onGroupCreated, openCreateOnMount = false }) => {
+  const [serverGroup, setServerGroup] = useState(null);
+  const [serverGroupModalOpen, setServerGroupModalOpen] = useState(false);
+  const [confirmDeleteOpen, setConfirmDeleteOpen] = useState(false);
+  const [deleteTarget, setDeleteTarget] = useState(null);
+  const [groupToDelete, setGroupToDelete] = useState(null);
+  const [deleting, setDeleting] = useState(false);
+  const openedCreateOnMount = useRef(false);
+
+  const isWarningSuppressed = useWarningsStore((s) => s.isWarningSuppressed);
+  const suppressWarning = useWarningsStore((s) => s.suppressWarning);
+
+  const serverGroups = useServerGroupsStore((state) => state.serverGroups);
+  const isLoading = useServerGroupsStore((state) => state.isLoading);
+  const error = useServerGroupsStore((state) => state.error);
+  const fetchServerGroups = useServerGroupsStore(
+    (state) => state.fetchServerGroups
+  );
+  const playlists = usePlaylistsStore((state) => state.playlists);
+
+  const tableData = useMemo(
+    () =>
+      serverGroups.map((group) => ({
+        ...group,
+        accountCount: playlists.filter(
+          (playlist) => playlist.server_group === group.id
+        ).length,
+      })),
+    [serverGroups, playlists]
+  );
+
+  const columns = useMemo(
+    () => [
+      {
+        header: 'Name',
+        accessorKey: 'name',
+        grow: true,
+        minSize: 100,
+        cell: ({ cell }) => (
+          <Text size="sm" truncate>
+            {cell.getValue()}
+          </Text>
+        ),
+      },
+      {
+        header: 'Accounts',
+        accessorKey: 'accountCount',
+        size: ACCOUNTS_COLUMN_SIZE,
+        minSize: 65,
+        cell: ({ cell }) => (
+          <Center w="100%">
+            <Text size="sm">{cell.getValue() ?? 0}</Text>
+          </Center>
+        ),
+      },
+      {
+        id: 'actions',
+        header: 'Actions',
+        size: ACTIONS_COLUMN_SIZE,
+        minSize: 65,
+      },
+    ],
+    []
+  );
+
+  const editServerGroup = (group = null) => {
+    setServerGroup(group);
+    setServerGroupModalOpen(true);
+  };
+
+  const executeDeleteServerGroup = async (id) => {
+    setDeleting(true);
+    try {
+      await API.deleteServerGroup(id);
+    } finally {
+      setDeleting(false);
+      setConfirmDeleteOpen(false);
+    }
+  };
+
+  const deleteServerGroup = (id) => {
+    const group = tableData.find((item) => item.id === id);
+    setGroupToDelete(group);
+    setDeleteTarget(id);
+
+    if (isWarningSuppressed('delete-server-group')) {
+      return executeDeleteServerGroup(id);
+    }
+
+    setConfirmDeleteOpen(true);
+  };
+
+  const closeServerGroupForm = () => {
+    setServerGroup(null);
+    setServerGroupModalOpen(false);
+  };
+
+  const handleServerGroupSaved = (savedGroup) => {
+    if (!serverGroup?.id) {
+      onGroupCreated?.(savedGroup);
+    }
+  };
+
+  useEffect(() => {
+    fetchServerGroups();
+  }, [fetchServerGroups]);
+
+  useEffect(() => {
+    if (!openCreateOnMount) {
+      openedCreateOnMount.current = false;
+      return;
+    }
+    if (!isLoading && !openedCreateOnMount.current) {
+      openedCreateOnMount.current = true;
+      editServerGroup();
+    }
+  }, [openCreateOnMount, isLoading]);
+
+  const renderHeaderCell = (header) => (
+    <Text size="sm" name={header.id}>
+      {header.column.columnDef.header}
+    </Text>
+  );
+
+  const renderBodyCell = ({ row }) => (
+    <RowActions
+      row={row}
+      editServerGroup={editServerGroup}
+      deleteServerGroup={deleteServerGroup}
+    />
+  );
+
+  const table = useTable({
+    columns,
+    data: tableData,
+    allRowIds: tableData.map((group) => group.id),
+    bodyCellRenderFns: {
+      actions: renderBodyCell,
+    },
+    headerCellRenderFns: {
+      name: renderHeaderCell,
+      accountCount: renderHeaderCell,
+      actions: renderHeaderCell,
+    },
+  });
+
+  if (isLoading) {
+    return (
+      <Center py="md">
+        <Text size="sm">Loading server groups...</Text>
+      </Center>
+    );
+  }
+
+  if (error) {
+    return (
+      <Center py="md">
+        <Text size="sm" c="red">
+          {error}
+        </Text>
+      </Center>
+    );
+  }
+
+  return (
+    <Stack gap="md">
+      <Text size="sm" c="dimmed">
+        Group accounts that share the same provider login so their connection
+        limits are enforced together. Assign a group when editing an M3U
+        account.
+      </Text>
+
+      <Flex justify="center">
+        <Stack gap="xs" w={TABLE_WIDTH} maw="100%">
+          <Flex justify="flex-end">
+            <Button
+              leftSection={<SquarePlus size={18} />}
+              variant="light"
+              size="xs"
+              onClick={() => editServerGroup()}
+              p={5}
+              color="green"
+              title="Create a shared connection pool for multiple accounts"
+              style={{
+                borderWidth: '1px',
+                borderColor: 'green',
+                color: 'white',
+              }}
+            >
+              Add Server Group
+            </Button>
+          </Flex>
+
+          <Box
+            style={{
+              maxHeight: 280,
+              overflowY: 'auto',
+              overflowX: 'auto',
+              border: 'solid 1px rgb(68,68,68)',
+              borderRadius: 'var(--mantine-radius-default)',
+            }}
+          >
+            {tableData.length === 0 ? (
+              <Center py="lg" px="xl">
+                <Text size="sm" c="dimmed">
+                  No server groups yet.
+                </Text>
+              </Center>
+            ) : (
+              <CustomTable table={table} />
+            )}
+          </Box>
+        </Stack>
+      </Flex>
+
+      <ServerGroupForm
+        serverGroup={serverGroup}
+        isOpen={serverGroupModalOpen}
+        onClose={closeServerGroupForm}
+        onSaved={handleServerGroupSaved}
+      />
+
+      <ConfirmationDialog
+        opened={confirmDeleteOpen}
+        onClose={() => setConfirmDeleteOpen(false)}
+        onConfirm={() => executeDeleteServerGroup(deleteTarget)}
+        loading={deleting}
+        title="Confirm Server Group Deletion"
+        message={
+          groupToDelete ? (
+            <div style={{ whiteSpace: 'pre-line' }}>
+              {`Are you sure you want to delete the following server group?
+
+Name: ${groupToDelete.name}
+Accounts: ${groupToDelete.accountCount ?? 0}
+
+Accounts in this group will no longer share connection limits. This action cannot be undone.`}
+            </div>
+          ) : (
+            'Are you sure you want to delete this server group? This action cannot be undone.'
+          )
+        }
+        confirmLabel="Delete"
+        cancelLabel="Cancel"
+        actionKey="delete-server-group"
+        onSuppressChange={suppressWarning}
+        zIndex={401}
+      />
+    </Stack>
+  );
+};
+
+export default ServerGroupsTable;
diff --git a/frontend/src/components/tables/__tests__/ServerGroupsTable.test.jsx b/frontend/src/components/tables/__tests__/ServerGroupsTable.test.jsx
new file mode 100644
index 00000000..3896d133
--- /dev/null
+++ b/frontend/src/components/tables/__tests__/ServerGroupsTable.test.jsx
@@ -0,0 +1,83 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { render, screen, waitFor } from '@testing-library/react';
+import { MantineProvider } from '@mantine/core';
+import ServerGroupsTable from '../ServerGroupsTable';
+
+const mockServerGroupsState = vi.hoisted(() => ({
+  serverGroups: [
+    { id: 1, name: 'Pool A' },
+    { id: 2, name: 'Pool B' },
+  ],
+  isLoading: false,
+  error: null,
+  fetchServerGroups: vi.fn().mockResolvedValue(undefined),
+}));
+
+const renderTable = () =>
+  render(
+    <MantineProvider>
+      <ServerGroupsTable />
+    </MantineProvider>
+  );
+
+vi.mock('../../../api', () => ({
+  default: {
+    deleteServerGroup: vi.fn(),
+  },
+}));
+
+vi.mock('../../../store/serverGroups', () => ({
+  default: (selector) => selector(mockServerGroupsState),
+}));
+
+vi.mock('../../../store/playlists', () => ({
+  default: (selector) =>
+    selector({
+      playlists: [
+        { id: 10, server_group: 2 },
+        { id: 11, server_group: 1 },
+      ],
+    }),
+}));
+
+vi.mock('../../forms/ServerGroup', () => ({
+  default: () => null,
+}));
+
+describe('ServerGroupsTable', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockServerGroupsState.serverGroups = [
+      { id: 1, name: 'Pool A' },
+      { id: 2, name: 'Pool B' },
+    ];
+    mockServerGroupsState.isLoading = false;
+    mockServerGroupsState.error = null;
+    mockServerGroupsState.fetchServerGroups = vi
+      .fn()
+      .mockResolvedValue(undefined);
+  });
+
+  it('renders server groups without tooltip errors', async () => {
+    expect(() => renderTable()).not.toThrow();
+
+    await waitFor(() => {
+      expect(screen.getByText('Pool A')).toBeInTheDocument();
+      expect(screen.getByText('Pool B')).toBeInTheDocument();
+      expect(screen.getByText('Accounts')).toBeInTheDocument();
+    });
+  });
+
+  it('shows store error message when fetch fails', async () => {
+    mockServerGroupsState.serverGroups = [];
+    mockServerGroupsState.error = 'Failed to load server groups.';
+
+    renderTable();
+
+    await waitFor(() => {
+      expect(
+        screen.getByText('Failed to load server groups.')
+      ).toBeInTheDocument();
+    });
+  });
+});
diff --git a/frontend/src/constants.js b/frontend/src/constants.js
index 92aba531..ea6dec13 100644
--- a/frontend/src/constants.js
+++ b/frontend/src/constants.js
@@ -43,17 +43,26 @@ export const PROXY_SETTINGS_OPTIONS = {
   },
   redis_chunk_ttl: {
     label: 'Buffer Chunk TTL',
+    advanced: true,
     description:
       'Time-to-live for buffer chunks in seconds (how long stream data is cached)',
   },
   channel_shutdown_delay: {
     label: 'Channel Shutdown Delay',
     description:
-      'Delay in seconds before shutting down a channel after last client disconnects',
+      'Delay in seconds before shutting down a channel after the last client disconnects',
   },
   channel_init_grace_period: {
-    label: 'Channel Initialization Grace Period',
-    description: 'Grace period in seconds during channel initialization',
+    label: 'Channel Initialization Timeout',
+    advanced: true,
+    description:
+      'Maximum seconds to wait for the initial buffer to fill while a channel is connecting. Channels that never receive enough buffered data are stopped after this limit.',
+  },
+  channel_client_wait_period: {
+    label: 'Client Connect Grace Period',
+    advanced: true,
+    description:
+      'Seconds to keep a buffered channel alive when no viewer is connected yet. Rarely needed unless you start channels programmatically.',
   },
   new_client_behind_seconds: {
     label: 'New Client Buffer (seconds)',
diff --git a/frontend/src/store/auth.jsx b/frontend/src/store/auth.jsx
index cfea5d4f..8f362357 100644
--- a/frontend/src/store/auth.jsx
+++ b/frontend/src/store/auth.jsx
@@ -6,6 +6,7 @@ import useEPGsStore from './epgs';
 import useStreamProfilesStore from './streamProfiles';
 import useOutputProfilesStore from './outputProfiles';
 import useUserAgentsStore from './userAgents';
+import useServerGroupsStore from './serverGroups';
 import useUsersStore from './users';
 import API from '../api';
 import { USER_LEVELS } from '../constants';
@@ -124,6 +125,7 @@ const useAuthStore = create((set, get) => ({
         useStreamProfilesStore.getState().fetchProfiles(),
         useOutputProfilesStore.getState().fetchProfiles(),
         useUserAgentsStore.getState().fetchUserAgents(),
+        useServerGroupsStore.getState().fetchServerGroups(),
         useChannelsStore.getState().fetchChannelIds(),
       ]);
 
diff --git a/frontend/src/store/serverGroups.jsx b/frontend/src/store/serverGroups.jsx
new file mode 100644
index 00000000..42406d70
--- /dev/null
+++ b/frontend/src/store/serverGroups.jsx
@@ -0,0 +1,40 @@
+import { create } from 'zustand';
+import api from '../api';
+
+const useServerGroupsStore = create((set) => ({
+  serverGroups: [],
+  isLoading: false,
+  error: null,
+
+  fetchServerGroups: async () => {
+    set({ isLoading: true, error: null });
+    try {
+      const serverGroups = await api.getServerGroups();
+      set({ serverGroups: serverGroups || [], isLoading: false });
+    } catch (error) {
+      console.error('Failed to fetch server groups:', error);
+      set({ error: 'Failed to load server groups.', isLoading: false });
+    }
+  },
+
+  addServerGroup: (serverGroup) =>
+    set((state) => ({
+      serverGroups: [...state.serverGroups, serverGroup],
+    })),
+
+  updateServerGroup: (serverGroup) =>
+    set((state) => ({
+      serverGroups: state.serverGroups.map((group) =>
+        group.id === serverGroup.id ? serverGroup : group
+      ),
+    })),
+
+  removeServerGroups: (serverGroupIds) =>
+    set((state) => ({
+      serverGroups: state.serverGroups.filter(
+        (group) => !serverGroupIds.includes(group.id)
+      ),
+    })),
+}));
+
+export default useServerGroupsStore;
diff --git a/frontend/src/utils/cards/__tests__/RecordingCardUtils.test.js b/frontend/src/utils/cards/__tests__/RecordingCardUtils.test.js
index 2e601120..c7b23f09 100644
--- a/frontend/src/utils/cards/__tests__/RecordingCardUtils.test.js
+++ b/frontend/src/utils/cards/__tests__/RecordingCardUtils.test.js
@@ -272,34 +272,36 @@ describe('RecordingCardUtils', () => {
 
   describe('getRecordingUrl', () => {
     it('returns file_url when available', () => {
-      const customProps = { file_url: '/recordings/file.mp4' };
+      const customProps = { file_url: '/api/channels/recordings/67/file/' };
       const result = getRecordingUrl(customProps, 'production');
 
-      expect(result).toBe('/recordings/file.mp4');
+      expect(result).toBe('/api/channels/recordings/67/file/');
     });
 
     it('returns output_file_url when file_url is not available', () => {
-      const customProps = { output_file_url: '/output/file.mp4' };
+      const customProps = { output_file_url: '/api/channels/recordings/1/file/' };
       const result = getRecordingUrl(customProps, 'production');
 
-      expect(result).toBe('/output/file.mp4');
+      expect(result).toBe('/api/channels/recordings/1/file/');
     });
 
     it('prefers file_url over output_file_url', () => {
       const customProps = {
-        file_url: '/recordings/file.mp4',
-        output_file_url: '/output/file.mp4',
+        file_url: '/api/channels/recordings/2/file/',
+        output_file_url: '/api/channels/recordings/3/file/',
       };
       const result = getRecordingUrl(customProps, 'production');
 
-      expect(result).toBe('/recordings/file.mp4');
+      expect(result).toBe('/api/channels/recordings/2/file/');
     });
 
     it('prepends dev server URL in dev mode for relative paths', () => {
-      const customProps = { file_url: '/recordings/file.mp4' };
+      const customProps = { file_url: '/api/channels/recordings/4/hls/index.m3u8' };
       const result = getRecordingUrl(customProps, 'dev');
 
-      expect(result).toMatch(/^https?:\/\/.*:5656\/recordings\/file\.mp4$/);
+      expect(result).toMatch(
+        /^https?:\/\/.*:5656\/api\/channels\/recordings\/4\/hls\/index\.m3u8$/
+      );
     });
 
     it('does not prepend dev URL for absolute URLs', () => {
diff --git a/frontend/src/utils/forms/LiveGroupFilterUtils.js b/frontend/src/utils/forms/LiveGroupFilterUtils.js
index a1372887..3cb62bf5 100644
--- a/frontend/src/utils/forms/LiveGroupFilterUtils.js
+++ b/frontend/src/utils/forms/LiveGroupFilterUtils.js
@@ -57,6 +57,18 @@ export const isExpectedOccupantForGroup = (
   );
 };
 
+// The group the sync's own channels actually land in. A group_override
+// routes auto-created channels into a different ChannelGroup, so the
+// conflict check must recognize occupants of that target group as this
+// config's own output rather than flagging them against the source group.
+export const effectiveSyncGroupId = (group) => {
+  const override = group?.custom_properties?.group_override;
+  if (override !== undefined && override !== null && override !== '') {
+    return Number(override);
+  }
+  return group?.channel_group;
+};
+
 export const rangeFor = (g) => {
   if (!g.enabled || !g.auto_channel_sync) return null;
   const mode = g.custom_properties?.channel_numbering_mode || 'fixed';
diff --git a/frontend/src/utils/forms/M3uUtils.js b/frontend/src/utils/forms/M3uUtils.js
index 7fc7e369..44692b78 100644
--- a/frontend/src/utils/forms/M3uUtils.js
+++ b/frontend/src/utils/forms/M3uUtils.js
@@ -50,5 +50,9 @@ export const prepareSubmitValues = (values, expDate) => {
     prepared.user_agent = null;
   }
 
+  if (prepared.server_group == '0') {
+    prepared.server_group = null;
+  }
+
   return prepared;
 };
diff --git a/frontend/src/utils/forms/__tests__/LiveGroupFilterUtils.test.js b/frontend/src/utils/forms/__tests__/LiveGroupFilterUtils.test.js
index feb878e1..86874f23 100644
--- a/frontend/src/utils/forms/__tests__/LiveGroupFilterUtils.test.js
+++ b/frontend/src/utils/forms/__tests__/LiveGroupFilterUtils.test.js
@@ -4,6 +4,7 @@ import {
   getChannelsInRange,
   getStreamsRegexPreview,
   isExpectedOccupantForGroup,
+  effectiveSyncGroupId,
   rangeFor,
   abortTimers,
   getRegexOptions,
@@ -227,6 +228,116 @@ describe('LiveGroupFilterUtils', () => {
     });
   });
 
+  // ── effectiveSyncGroupId ───────────────────────────────────────────────────
+  describe('effectiveSyncGroupId', () => {
+    it('returns the source channel_group when there is no override', () => {
+      expect(effectiveSyncGroupId(makeGroup({ channel_group: 7 }))).toBe(7);
+    });
+
+    it('returns the group_override target when set', () => {
+      const group = makeGroup({
+        channel_group: 7,
+        custom_properties: { group_override: 9 },
+      });
+      expect(effectiveSyncGroupId(group)).toBe(9);
+    });
+
+    it('coerces a string-stored group_override to a number', () => {
+      const group = makeGroup({
+        channel_group: 7,
+        custom_properties: { group_override: '9' },
+      });
+      expect(effectiveSyncGroupId(group)).toBe(9);
+    });
+
+    it('falls back to the source group when group_override is blank', () => {
+      const group = makeGroup({
+        channel_group: 7,
+        custom_properties: { group_override: '' },
+      });
+      expect(effectiveSyncGroupId(group)).toBe(7);
+    });
+
+    // Regression guard for the group-override range-conflict false positive:
+    // the auto-sync's own channels land in the override target group, so
+    // comparing against the source group (pre-fix) flags them as a conflict,
+    // while comparing against the effective target recognizes them as this
+    // config's own output.
+    it("makes group-override occupants count as this group's own", () => {
+      const group = makeGroup({
+        channel_group: 7,
+        custom_properties: { group_override: 9 },
+      });
+      const occupant = makeOccupant({ channel_group_id: 9 });
+      // Pre-fix comparison (source group) treats own channels as a conflict.
+      expect(
+        isExpectedOccupantForGroup(
+          occupant,
+          group.channel_group,
+          makePlaylist()
+        )
+      ).toBe(false);
+      // Comparing against the effective target recognizes them as expected.
+      expect(
+        isExpectedOccupantForGroup(
+          occupant,
+          effectiveSyncGroupId(group),
+          makePlaylist()
+        )
+      ).toBe(true);
+    });
+
+    // Guards against over-suppression: resolving the effective target group
+    // must still surface genuine collisions in an override config's range.
+    // Only the config's own output (auto-created, this account, in the
+    // target group, unpinned) is excluded.
+    it('still flags genuine collisions in a group-override config', () => {
+      const group = makeGroup({
+        channel_group: 7,
+        custom_properties: { group_override: 9 },
+      });
+      const target = effectiveSyncGroupId(group);
+      // Manual channel sitting in the range.
+      expect(
+        isExpectedOccupantForGroup(
+          makeOccupant({ channel_group_id: 9, auto_created: false }),
+          target,
+          makePlaylist()
+        )
+      ).toBe(false);
+      // Auto-created by a different account.
+      expect(
+        isExpectedOccupantForGroup(
+          makeOccupant({
+            channel_group_id: 9,
+            auto_created_by_account_id: 999,
+          }),
+          target,
+          makePlaylist()
+        )
+      ).toBe(false);
+      // A channel in a different group than the override target.
+      expect(
+        isExpectedOccupantForGroup(
+          makeOccupant({ channel_group_id: 123 }),
+          target,
+          makePlaylist()
+        )
+      ).toBe(false);
+      // A user-pinned channel number.
+      expect(
+        isExpectedOccupantForGroup(
+          makeOccupant({
+            channel_group_id: 9,
+            has_channel_number_override: true,
+          }),
+          target,
+          makePlaylist()
+        )
+      ).toBe(false);
+    });
+  });
+
   // ── rangeFor ──────────────────────────────────────────────────────────────
   describe('rangeFor', () => {
     it('returns null when group is disabled', () => {
diff --git a/frontend/src/utils/forms/settings/ProxySettingsFormUtils.js b/frontend/src/utils/forms/settings/ProxySettingsFormUtils.js
index eddbba91..ccbabdeb 100644
--- a/frontend/src/utils/forms/settings/ProxySettingsFormUtils.js
+++ b/frontend/src/utils/forms/settings/ProxySettingsFormUtils.js
@@ -13,7 +13,8 @@ export const getProxySettingDefaults = () => {
     buffering_speed: 1.0,
     redis_chunk_ttl: 60,
     channel_shutdown_delay: 0,
-    channel_init_grace_period: 5,
+    channel_init_grace_period: 60,
+    channel_client_wait_period: 5,
     new_client_behind_seconds: 5,
   };
 };
diff --git a/frontend/src/utils/forms/settings/__tests__/ProxySettingsFormUtils.test.js b/frontend/src/utils/forms/settings/__tests__/ProxySettingsFormUtils.test.js
index 21c48269..3c17c42e 100644
--- a/frontend/src/utils/forms/settings/__tests__/ProxySettingsFormUtils.test.js
+++ b/frontend/src/utils/forms/settings/__tests__/ProxySettingsFormUtils.test.js
@@ -60,7 +60,8 @@ describe('ProxySettingsFormUtils', () => {
         buffering_speed: 1.0,
         redis_chunk_ttl: 60,
         channel_shutdown_delay: 0,
-        channel_init_grace_period: 5,
+        channel_init_grace_period: 60,
+        channel_client_wait_period: 5,
         new_client_behind_seconds: 5,
       });
     });
@@ -81,6 +82,7 @@ describe('ProxySettingsFormUtils', () => {
       expect(typeof result.redis_chunk_ttl).toBe('number');
       expect(typeof result.channel_shutdown_delay).toBe('number');
       expect(typeof result.channel_init_grace_period).toBe('number');
+      expect(typeof result.channel_client_wait_period).toBe('number');
       expect(typeof result.new_client_behind_seconds).toBe('number');
     });
   });
diff --git a/manage.py b/manage.py
index f3c22dfd..f0a85a39 100644
--- a/manage.py
+++ b/manage.py
@@ -5,7 +5,12 @@ import sys
 
 def main():
     """Run administrative tasks."""
-    os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'dispatcharr.settings')
+    # Use isolated test DB settings for `manage.py test` (empty test_<dbname>).
+    # Override with --settings=... on the command line if needed.
+    if len(sys.argv) > 1 and sys.argv[1] == "test":
+        os.environ["DJANGO_SETTINGS_MODULE"] = "dispatcharr.settings_test"
+    else:
+        os.environ.setdefault("DJANGO_SETTINGS_MODULE", "dispatcharr.settings")
     try:
         from django.core.management import execute_from_command_line
     except ImportError as exc:
diff --git a/pyproject.toml b/pyproject.toml
index a003bc5c..8d4fad78 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -6,18 +6,18 @@ license = "AGPL-3.0-only"
 requires-python = ">=3.13"
 dynamic = ["version"]
 dependencies = [
-    "Django==6.0.5",
+    "Django==6.0.6",
     "psycopg[binary]",
     "celery[redis]==5.6.3",
     "djangorestframework==3.17.1",
-    "requests==2.33.1",
+    "requests==2.34.2",
     "psutil==7.2.2",
     "pillow",
     "drf-spectacular>=0.29.0",
     "streamlink",
     "python-vlc",
     "yt-dlp",
-    "gevent==26.4.0",
+    "gevent==26.5.0",
     "django-db-geventpool",
     "daphne",
     "uwsgi",
@@ -28,14 +28,14 @@ dependencies = [
     "regex",
     "tzlocal",
     "pytz",
-    "torch==2.11.0+cpu",
-    "sentence-transformers==5.4.1",
+    "torch==2.12.1+cpu",
+    "sentence-transformers==5.6.0",
     "channels",
     "channels-redis==4.3.0",
     "django-filter",
     "django-redis",
     "django-celery-beat>=2.9.0",
-    "lxml==6.1.0",
+    "lxml==6.1.1",
     "packaging",
 ]
 
diff --git a/scripts/ci_backend_test_labels.py b/scripts/ci_backend_test_labels.py
new file mode 100644
index 00000000..e69356c4
--- /dev/null
+++ b/scripts/ci_backend_test_labels.py
@@ -0,0 +1,104 @@
+#!/usr/bin/env python3
+"""Map changed repository paths to Django test package labels for CI."""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+from pathlib import PurePosixPath
+
+# Keep in sync with dispatcharr.test_runner package discovery.
+ALL_LABELS: tuple[str, ...] = (
+    "apps.accounts.tests",
+    "apps.backups.tests",
+    "apps.channels.tests",
+    "apps.connect.tests",
+    "apps.dashboard.tests",
+    "apps.epg.tests",
+    "apps.m3u.tests",
+    "apps.output.tests",
+    "apps.plugins.tests",
+    "apps.timeshift.tests",
+    "apps.proxy.live_proxy.tests",
+    "apps.proxy.vod_proxy.tests",
+    "core.tests",
+    "tests",
+)
+
+# Longest-prefix wins; order matters for overlapping rules.
+_PATH_RULES: tuple[tuple[str, tuple[str, ...]], ...] = (
+    ("apps/channels/", ("apps.channels.tests",)),
+    ("apps/epg/", ("apps.epg.tests",)),
+    ("apps/m3u/", ("apps.m3u.tests",)),
+    ("apps/proxy/", ("apps.proxy.live_proxy.tests", "apps.proxy.vod_proxy.tests")),
+    ("apps/connect/", ("apps.connect.tests",)),
+    ("apps/output/", ("apps.output.tests",)),
+    ("apps/accounts/", ("apps.accounts.tests",)),
+    ("apps/backups/", ("apps.backups.tests",)),
+    ("apps/dashboard/", ("apps.dashboard.tests",)),
+    ("apps/plugins/", ("apps.plugins.tests",)),
+    ("apps/timeshift/", ("apps.timeshift.tests",)),
+    ("apps/vod/", ("apps.output.tests",)),
+    ("apps/hdhr/", ("apps.output.tests", "apps.channels.tests")),
+    ("apps/api/", ALL_LABELS),
+    ("core/", ("core.tests", "tests")),
+    ("tests/", ("tests",)),
+)
+
+_SHARED_PREFIXES: tuple[str, ...] = (
+    "dispatcharr/",
+    "pyproject.toml",
+    "manage.py",
+    "version.py",
+    "scripts/ci_backend_test_labels.py",
+    "scripts/ci_bootstrap_backend.sh",
+    ".github/workflows/backend-tests.yml",
+)
+
+
+def _normalize(path: str) -> str:
+    return PurePosixPath(path.strip().replace("\\", "/")).as_posix()
+
+
+def labels_for_paths(paths: list[str], *, full_suite: bool = False) -> list[str]:
+    if full_suite:
+        return list(ALL_LABELS)
+
+    labels: set[str] = set()
+    for raw in paths:
+        path = _normalize(raw)
+        if not path:
+            continue
+        if any(path == prefix.rstrip("/") or path.startswith(prefix) for prefix in _SHARED_PREFIXES):
+            return list(ALL_LABELS)
+        for prefix, group_labels in _PATH_RULES:
+            if path.startswith(prefix):
+                labels.update(group_labels)
+                break
+
+    return sorted(labels)
+
+
+def _read_paths(argv: list[str]) -> list[str]:
+    if argv:
+        return argv
+    if not sys.stdin.isatty():
+        return [line for line in sys.stdin.read().splitlines() if line.strip()]
+    return []
+
+
+def main(argv: list[str] | None = None) -> int:
+    argv = argv if argv is not None else sys.argv[1:]
+    full_suite = os.environ.get("FULL_SUITE", "").lower() in {"1", "true", "yes"}
+    if full_suite:
+        print(json.dumps(list(ALL_LABELS)))
+        return 0
+    paths = _read_paths(argv)
+    labels = labels_for_paths(paths, full_suite=False)
+    print(json.dumps(labels))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/scripts/ci_bootstrap_backend.sh b/scripts/ci_bootstrap_backend.sh
new file mode 100644
index 00000000..d13e0218
--- /dev/null
+++ b/scripts/ci_bootstrap_backend.sh
@@ -0,0 +1,77 @@
+#!/bin/bash
+# Bootstrap internal Postgres/Redis (AIO-style) and run Django tests in the base image.
+set -euo pipefail
+
+REPO_ROOT="${GITHUB_WORKSPACE:-$(pwd)}"
+cd "${REPO_ROOT}"
+
+export DISPATCHARR_ENV="${DISPATCHARR_ENV:-aio}"
+export PUID="${PUID:-1000}"
+export PGID="${PGID:-1000}"
+export POSTGRES_DB="${POSTGRES_DB:-dispatcharr}"
+export POSTGRES_USER="${POSTGRES_USER:-dispatch}"
+export POSTGRES_PASSWORD="${POSTGRES_PASSWORD:-secret}"
+export POSTGRES_PORT="${POSTGRES_PORT:-5432}"
+export POSTGRES_DIR="${POSTGRES_DIR:-/tmp/dispatcharr-ci/db}"
+export REDIS_HOST="${REDIS_HOST:-localhost}"
+export REDIS_PORT="${REDIS_PORT:-6379}"
+export REDIS_DB="${REDIS_DB:-0}"
+export DJANGO_SECRET_KEY="${DJANGO_SECRET_KEY:-ci-test-secret-key}"
+export DISPATCHARR_LOG_LEVEL="${DISPATCHARR_LOG_LEVEL:-WARNING}"
+export PATH="/dispatcharrpy/bin:${PATH}"
+export PG_VERSION
+PG_VERSION="$(ls /usr/lib/postgresql/ | sort -V | tail -n 1)"
+export PG_BINDIR="/usr/lib/postgresql/${PG_VERSION}/bin"
+
+if [[ "$DISPATCHARR_ENV" == "aio" ]]; then
+  export POSTGRES_HOST="${POSTGRES_HOST:-/var/run/postgresql}"
+else
+  export POSTGRES_HOST="${POSTGRES_HOST:-localhost}"
+fi
+
+if [[ "${SYNC_PYTHON_DEPS:-}" == "true" ]]; then
+  echo "Syncing Python dependencies with uv..."
+  uv sync --python /dispatcharrpy/bin/python --no-install-project --no-dev
+fi
+
+echo "Setting up CI user and PostgreSQL data directory..."
+# shellcheck source=docker/init/01-user-setup.sh
+. "${REPO_ROOT}/docker/init/01-user-setup.sh"
+mkdir -p "${POSTGRES_DIR}"
+chown "${PUID}:${PGID}" "${POSTGRES_DIR}"
+chmod 700 "${POSTGRES_DIR}"
+# shellcheck source=docker/init/02-postgres.sh
+. "${REPO_ROOT}/docker/init/02-postgres.sh"
+
+echo "Starting internal PostgreSQL..."
+prepare_pg_socket_dir
+su - "$POSTGRES_USER" -c "$PG_BINDIR/pg_ctl -D ${POSTGRES_DIR} start -w -t 120 -o '-c port=${POSTGRES_PORT}'"
+until su - "$POSTGRES_USER" -c "$PG_BINDIR/pg_isready -h ${POSTGRES_HOST} -p ${POSTGRES_PORT}" >/dev/null 2>&1; do
+  sleep 1
+done
+set +e
+promote_app_role
+_promote_status=$?
+ensure_app_database
+_ensure_status=$?
+set -e
+if [ "$_promote_status" -ne 0 ] || [ "$_ensure_status" -ne 0 ]; then
+  echo "Failed to configure PostgreSQL role/database (promote=${_promote_status}, ensure=${_ensure_status})"
+  exit 1
+fi
+
+echo "Starting internal Redis..."
+if redis-cli -p "${REDIS_PORT}" ping >/dev/null 2>&1; then
+  echo "Redis already listening on port ${REDIS_PORT}"
+else
+  redis-server --daemonize yes --protected-mode no --bind 127.0.0.1 --port "${REDIS_PORT}"
+fi
+python "${REPO_ROOT}/scripts/wait_for_redis.py"
+
+cleanup() {
+  redis-cli -p "${REDIS_PORT}" shutdown nosave >/dev/null 2>&1 || true
+  su - "$POSTGRES_USER" -c "$PG_BINDIR/pg_ctl -D ${POSTGRES_DIR} stop -m fast" >/dev/null 2>&1 || true
+}
+trap cleanup EXIT
+
+exec python manage.py test --keepdb "$@"
diff --git a/tests/test_custom_properties_as_dict.py b/tests/test_custom_properties_as_dict.py
new file mode 100644
index 00000000..bd863fdc
--- /dev/null
+++ b/tests/test_custom_properties_as_dict.py
@@ -0,0 +1,74 @@
+import uuid
+
+from django.test import SimpleTestCase, TestCase
+
+from core.utils import custom_properties_as_dict, ensure_custom_properties_dict
+from apps.m3u.models import M3UAccount, M3UAccountProfile
+from apps.channels.models import ChannelGroupM3UAccount, ChannelGroup
+
+
+class CustomPropertiesAsDictTests(SimpleTestCase):
+    def test_dict_passthrough(self):
+        value = {"enable_vod": True}
+        self.assertIs(custom_properties_as_dict(value), value)
+
+    def test_json_string_parsed(self):
+        self.assertEqual(
+            custom_properties_as_dict('{"enable_vod": true}'),
+            {"enable_vod": True},
+        )
+
+    def test_non_json_string_returns_empty_dict(self):
+        self.assertEqual(custom_properties_as_dict("not-json"), {})
+
+    def test_json_array_returns_empty_dict(self):
+        self.assertEqual(custom_properties_as_dict("[1, 2]"), {})
+
+    def test_none_returns_empty_dict(self):
+        self.assertEqual(custom_properties_as_dict(None), {})
+
+
+class EnsureCustomPropertiesDictTests(SimpleTestCase):
+    def test_dict_passthrough_without_reparse(self):
+        value = {"enable_vod": True}
+        self.assertIs(ensure_custom_properties_dict(value), value)
+
+    def test_none_returns_empty_dict(self):
+        self.assertEqual(ensure_custom_properties_dict(None), {})
+
+
+class CustomPropertiesSaveNormalizationTests(TestCase):
+    def test_m3u_account_save_rewrites_string_custom_properties(self):
+        account = M3UAccount.objects.create(
+            name=f"Test Account {uuid.uuid4().hex[:8]}",
+            custom_properties='{"enable_vod": true}',
+        )
+        account.refresh_from_db()
+        self.assertEqual(account.custom_properties, {"enable_vod": True})
+
+    def test_profile_save_rewrites_string_custom_properties(self):
+        account = M3UAccount.objects.create(
+            name=f"Test Account {uuid.uuid4().hex[:8]}"
+        )
+        profile = M3UAccountProfile.objects.get(
+            m3u_account=account, is_default=True
+        )
+        profile.custom_properties = '{"notes": "hello"}'
+        profile.save(update_fields=["custom_properties"])
+        profile.refresh_from_db()
+        self.assertEqual(profile.custom_properties, {"notes": "hello"})
+
+    def test_group_relation_save_rewrites_string_custom_properties(self):
+        account = M3UAccount.objects.create(
+            name=f"Test Account {uuid.uuid4().hex[:8]}"
+        )
+        group = ChannelGroup.objects.create(
+            name=f"Sports {uuid.uuid4().hex[:8]}"
+        )
+        rel = ChannelGroupM3UAccount.objects.create(
+            m3u_account=account,
+            channel_group=group,
+            custom_properties='{"force_dummy_epg": true}',
+        )
+        rel.refresh_from_db()
+        self.assertEqual(rel.custom_properties, {"force_dummy_epg": True})
diff --git a/tests/test_geventpool_conn_lifetime.py b/tests/test_geventpool_conn_lifetime.py
new file mode 100644
index 00000000..3f939034
--- /dev/null
+++ b/tests/test_geventpool_conn_lifetime.py
@@ -0,0 +1,65 @@
+"""Tests for dispatcharr geventpool connection max lifetime."""
+from unittest import TestCase
+from unittest.mock import MagicMock, patch
+
+from dispatcharr.db.backends.postgresql_psycopg3.pool import DatabaseConnectionPool
+
+
+class _TestPool(DatabaseConnectionPool):
+    DBERROR = Exception
+
+    def create_connection(self):
+        return MagicMock(name="connection", closed=False)
+
+    def check_usable(self, connection):
+        return None
+
+
+class GeventPoolConnLifetimeTests(TestCase):
+    def test_fresh_connection_is_stamped_on_create(self):
+        pool = _TestPool(maxsize=2, reuse=2, max_lifetime=3600)
+        conn = pool.get()
+        self.assertIsNotNone(getattr(conn, "_dispatcharr_pool_created_at", None))
+
+    def test_expired_connection_on_get_is_replaced(self):
+        pool = _TestPool(maxsize=2, reuse=2, max_lifetime=60)
+        conn = pool.create_connection()
+        pool._stamp_connection(conn)
+        conn._dispatcharr_pool_created_at = 0
+        conn.close = MagicMock()
+        pool._conns.add(conn)
+        pool.pool.put_nowait(conn)
+
+        with patch("dispatcharr.db.backends.postgresql_psycopg3.pool.time.monotonic", return_value=120):
+            new_conn = pool.get()
+
+        conn.close.assert_called_once()
+        self.assertIsNot(new_conn, conn)
+
+    def test_expired_connection_on_put_is_closed_not_pooled(self):
+        pool = _TestPool(maxsize=2, reuse=2, max_lifetime=60)
+        conn = pool.get()
+        conn.close = MagicMock()
+        conn._dispatcharr_pool_created_at = 0
+
+        with patch("dispatcharr.db.backends.postgresql_psycopg3.pool.time.monotonic", return_value=120):
+            pool.put(conn)
+
+        conn.close.assert_called_once()
+        self.assertEqual(pool.pool.qsize(), 0)
+
+    def test_non_expired_connection_is_returned_to_pool(self):
+        pool = _TestPool(maxsize=2, reuse=2, max_lifetime=3600)
+        conn = pool.get()
+        pool.put(conn)
+        self.assertEqual(pool.pool.qsize(), 1)
+
+    def test_max_lifetime_disabled_when_none(self):
+        pool = _TestPool(maxsize=2, reuse=2, max_lifetime=None)
+        conn = pool.get()
+        conn._dispatcharr_pool_created_at = 0
+
+        with patch("dispatcharr.db.backends.postgresql_psycopg3.pool.time.monotonic", return_value=999999):
+            pool.put(conn)
+
+        self.assertEqual(pool.pool.qsize(), 1)
diff --git a/tests/test_log_system_event.py b/tests/test_log_system_event.py
new file mode 100644
index 00000000..6ff92ff4
--- /dev/null
+++ b/tests/test_log_system_event.py
@@ -0,0 +1,55 @@
+"""Tests for log_system_event Connect/plugin dispatch and DB cleanup."""
+
+from unittest.mock import patch
+
+from django.test import SimpleTestCase
+
+
+class LogSystemEventDispatchTests(SimpleTestCase):
+    @patch("django.db.close_old_connections")
+    @patch("core.utils._dispatch_system_event_integrations")
+    @patch("core.models.SystemEvent.objects")
+    @patch("core.models.CoreSettings.objects")
+    def test_log_system_event_dispatches_integrations_and_closes_db(
+        self, mock_core_settings, mock_system_event, mock_dispatch, mock_close
+    ):
+        mock_system_event.count.return_value = 1
+        mock_core_settings.filter.return_value.first.return_value = None
+
+        from core.utils import log_system_event
+
+        log_system_event("channel_start", channel_id="abc", channel_name="Test")
+
+        mock_dispatch.assert_called_once_with(
+            "channel_start",
+            channel_id="abc",
+            channel_name="Test",
+        )
+        mock_close.assert_called_once()
+
+    @patch("django.db.close_old_connections")
+    @patch("apps.connect.utils.trigger_event")
+    def test_integration_dispatch_closes_db_on_sync_path(
+        self, mock_trigger, mock_close
+    ):
+        from core.utils import _dispatch_system_event_integrations
+
+        with patch("core.utils._should_use_sync_websocket_send", return_value=True):
+            _dispatch_system_event_integrations("client_connect", channel_id="abc")
+
+        mock_trigger.assert_called_once()
+        mock_close.assert_called_once()
+
+    @patch("core.utils.dispatch_event_system")
+    def test_integration_dispatch_spawns_on_gevent_uwsgi(
+        self, mock_dispatch
+    ):
+        from core.utils import _dispatch_system_event_integrations
+
+        with patch("core.utils._should_use_sync_websocket_send", return_value=False), patch(
+            "core.utils._is_gevent_monkey_patched", return_value=True
+        ), patch("gevent.spawn") as mock_spawn:
+            _dispatch_system_event_integrations("channel_stop", channel_id="abc")
+
+        mock_spawn.assert_called_once()
+        mock_dispatch.assert_not_called()
diff --git a/tests/test_process_label.py b/tests/test_process_label.py
new file mode 100644
index 00000000..e4525a85
--- /dev/null
+++ b/tests/test_process_label.py
@@ -0,0 +1,29 @@
+from unittest.mock import patch
+
+from django.test import SimpleTestCase
+
+from dispatcharr.db.process_label import get_process_role
+
+
+class ProcessLabelTests(SimpleTestCase):
+    def test_celery_worker_not_labeled_as_uwsgi(self):
+        role = get_process_role(
+            ["/dispatcharrpy/bin/celery", "-A", "dispatcharr", "worker"]
+        )
+        self.assertEqual(role, "celery-worker")
+
+    def test_uwsgi_labeled_from_argv(self):
+        role = get_process_role(["/dispatcharrpy/bin/uwsgi", "--ini", "/app/docker/uwsgi.ini"])
+        self.assertEqual(role, "uwsgi")
+
+    def test_uwsgi_labeled_when_worker_module_present(self):
+        fake_uwsgi = type("uwsgi", (), {"worker_id": staticmethod(lambda: 2)})()
+        with patch.dict("sys.modules", {"uwsgi": fake_uwsgi}):
+            role = get_process_role(["/dispatcharrpy/bin/python", "-c", "pass"])
+        self.assertEqual(role, "uwsgi")
+
+    def test_uwsgi_master_not_labeled_as_uwsgi(self):
+        fake_uwsgi = type("uwsgi", (), {"worker_id": staticmethod(lambda: 0)})()
+        with patch.dict("sys.modules", {"uwsgi": fake_uwsgi}):
+            role = get_process_role(["/dispatcharrpy/bin/python", "-c", "pass"])
+        self.assertEqual(role, "django")
diff --git a/tests/test_user_preferences.py b/tests/test_user_preferences.py
index 5749011a..80dcc992 100644
--- a/tests/test_user_preferences.py
+++ b/tests/test_user_preferences.py
@@ -128,13 +128,13 @@ class UserPreferencesAPITests(TestCase):
         self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)
 
     def test_patch_me_cannot_escalate_privileges(self):
-        """Test PATCH /me/ rejects attempts to change user_level or is_staff"""
+        """PATCH /me/ ignores privilege fields; they are stripped before save."""
         original_level = self.user.user_level
 
         data = {"user_level": 99, "is_staff": True, "is_superuser": True}
         response = self.client.patch(self.me_url, data, format="json")
 
-        self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
 
         self.user.refresh_from_db()
         self.assertEqual(self.user.user_level, original_level)
diff --git a/version.py b/version.py
index 362d955e..25ccd35c 100644
--- a/version.py
+++ b/version.py
@@ -1,5 +1,5 @@
 """
 Dispatcharr version information.
 """
-__version__ = '0.26.0'  # Follow semantic versioning (MAJOR.MINOR.PATCH)
+__version__ = '0.27.2'  # Follow semantic versioning (MAJOR.MINOR.PATCH)
 __timestamp__ = None    # Set during CI/CD build process