diff --git a/CHANGELOG.md b/CHANGELOG.md
index 0517493d..55962c84 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,22 +7,109 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
-### Changed
+### Added
 
-- **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.
+- **XC catch-up (timeshift) support**. Adds a native `/timeshift/{user}/{pass}/{stream_id}/{timestamp}/{duration}.ts` endpoint that proxies replay sessions from an Xtream Codes provider to clients such as iPlayTV (Apple TV) and TiviMate. Auth reuses the same `xc_password` custom-property the live `/live/.../{id}.ts` endpoint already uses. Catch-up sessions appear on `/stats` with a violet `TIMESHIFT` badge alongside live sessions and respect per-channel access rules. — Thanks [@cedric-marcoux](https://github.com/cedric-marcoux) (#1242)
+  - **Catch-up flags** (`tv_archive`, `tv_archive_duration`) denormalized at import time for zero-cost output queries; end-of-refresh SQL rollup updates channels linked to the refreshed account and self-heals stale flags on those channels only (e.g. after catch-up streams are removed or an account is deactivated).
+  - **Strictly-UTC API surface, automatic per-provider timezone.** `server_info.timezone` is always `UTC` and the XC EPG `start`/`end` strings are emitted in UTC; the proxy converts the requested instant to the serving provider's own reported timezone (`server_info.timezone` captured on account refresh) at request time. No timezone to configure.
+  - **Multi-provider failover.** Catch-up walks the channel's catch-up streams in order (like live playback): if one provider cannot serve the archive the next is tried, each attempt with its own account context (credentials, reported timezone, user-agent). Accounts that fail with an auth/ban-class status are not retried via their other streams.
+  - **Provider pool accounting.** Catch-up reserves a provider profile slot (`connection_pool`) before connecting upstream — same contract as live and VOD — and releases it when the session ends. When the default profile is at capacity it walks the account's alternate profiles with their own resolved credentials, and answers `503` when every profile is full.
+  - **Per-client session pool.** The first request without `session_id` receives a `301` redirect to the same URL with a stable `?session_id=` query parameter; that ID becomes the client identity for stats, stop keys, and pool coordination. Each viewer gets their own Redis-backed pool entry even when watching the same programme; idle sessions can be reclaimed via fingerprint matching (same user and programme, IP + user-agent score). Real scrubs within a session stop the in-flight stream through the standard stop-key mechanism; parallel startup probes (full-file, open-ended, and EOF tail `Range` requests) are deferred with `503` instead of opening extra upstream connections. Stream-limit exemptions for `ignore_same_channel_connections` apply only to sibling requests from the same `session_id`.
+  - **`xmltv_prev_days_override` under `Settings → EPG`** (default `0` = auto-detect). Verbose timeshift logging follows the standard logger DEBUG level.
+  - **EPG XMLTV `prev_days` auto-detection** from the provider's largest `tv_archive_duration` (capped at 30 days), overridable via setting or `?prev_days=` URL parameter.
+  - **Byte path streams directly via `iter_content` + generator yield** (same pattern as the VOD proxy), with an upfront MPEG-TS sync peek that strips any PHP-warning preamble before bytes reach strict demuxers. Throughput stays comfortably above the typical 5 Mbps FHD bitrate so clients don't buffer.
 
 ### Performance
 
-- **XMLTV EPG output no longer N+1 queries streams or dummy-program checks.** `generate_epg()` prefetches ordered channel streams once (for custom dummy EPG logo/program parsing when `name_source` is `stream`) and bulk-checks which dummy `EPGData` rows have stored programmes in a single query instead of one `.exists()` per row. Large guides with hundreds of custom-dummy channels issue far fewer SQL round-trips per client refresh.
+- **M3U/XC stream refresh is faster on large accounts.** Steady-state refreshes split `bulk_update` into a lightweight touch pass (`last_seen` / `is_stale` only) for unchanged streams and a full column update only when provider metadata or catch-up fields actually change.
+- **M3U stream filters compile once per refresh.** Account filters are regex-compiled before batch workers start; accounts with no filters skip per-stream filter checks entirely.
+- **M3U refresh releases parse catalogs sooner.** Standard accounts stream-parse the on-disk M3U instead of loading the full file into RAM; `extinf_data` is dropped immediately after batch DB work, before stale cleanup and auto-sync.
+- **XC live refresh avoids redundant work during catalog filtering.** `collect_xc_streams` skips disabled categories before building entries and uses a shared URL prefix instead of formatting each stream URL separately. Auto-sync releases per-group logo/EPG caches after each group iteration.
+- **Celery workers return RSS after memory-intensive tasks.** `cleanup_memory()` accepts an optional `trim_heap` flag (glibc `malloc_trim`); Celery `task_postrun` enables it after `close_old_connections()` for M3U account/group refresh, EPG, VOD, and channel-matching tasks so worker memory drops back toward baseline instead of ratcheting across successive large jobs.
 
 ### Fixed
 
+- **M3U refresh completion counts now reflect actual stream changes.** The "updated" count previously included every existing stream because the summary treated `last_seen` touch-only rows as updates; it now counts only streams whose provider metadata changed. "Total processed" includes unchanged streams separately. The completion message, WebSocket payload, and parsing notification now also report how many streams were **marked stale** (missing from this refresh, pending retention-gated deletion) versus **removed** (deleted this run).
+- **M3U group processing retries on poisoned DB connections.** `_db_query_with_retry` now treats psycopg desync errors (`DatabaseError`, e.g. `lost synchronization with server`) as transient; `process_groups` relationship loading uses it so a stale Celery worker connection resets once instead of failing the whole refresh.
+- **Auto Channel Sync's Find and Replace preview now matches the rename it performs.** The preview rendered the literal `$1` instead of substituting numbered capture groups, and compiled patterns with a stricter engine than the rename, so patterns like `^*` previewed a change the sync silently skipped. The live rename now uses the same `regex` engine as the preview (with a substitution timeout to bound catastrophic backtracking), both apply the `$1`→`\1` conversion through one shared helper, and a rename whose result exceeds the channel-name column length is truncated instead of aborting the whole sync. (Fixes #1332) — Thanks [@CodeBormen](https://github.com/CodeBormen)
+
+## [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 `programme_index`.** The dummy-source guard uses a narrow existence query instead of `objects.get()`, so import triggers avoid pulling the multi-MB byte-offset index into the uWSGI worker. Request/response shape is unchanged for the UI, plugins, and external importers.
+- **`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
 
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/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 3d94cb10..3f28903c 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 (
@@ -24,6 +27,7 @@ from apps.accounts.permissions import (
 
 from core.models import UserAgent, CoreSettings
 from core.utils import RedisClient, safe_upload_path
+from apps.m3u.utils import convert_js_numbered_backreferences
 
 from .models import (
     Stream,
@@ -365,6 +369,17 @@ class StreamViewSet(viewsets.ModelViewSet):
             except re.error as e:
                 exclude_error = str(e)
 
+        # The replace field accepts JS-style $1 backreferences, but the regex
+        # engine honors \1. Convert once so the preview's "after" matches the
+        # name the live rename produces (apps/m3u/tasks.py sync_auto_channels
+        # applies the same conversion on the same engine).
+        replace_repl = convert_js_numbered_backreferences(replace_pat)
+
+        # The live rename caps the result at Channel.name's column length
+        # before bulk_create; mirror that cap so the preview never shows a
+        # name the sync would truncate.
+        name_max_len = Channel._meta.get_field("name").max_length
+
         # Capped at SCAN_CAP to bound memory on huge groups; the
         # separate COUNT lets the client surface scan_limit_hit when
         # the preview covers only a sample.
@@ -387,11 +402,12 @@ class StreamViewSet(viewsets.ModelViewSet):
             total_scanned += 1
             if find_re is not None:
                 try:
-                    new_name = find_re.sub(replace_pat, name, timeout=REGEX_TIMEOUT)
+                    new_name = find_re.sub(replace_repl, name, timeout=REGEX_TIMEOUT)
                 except (TimeoutError, re.error) as e:
                     find_error = find_error or f"Pattern timed out: {e}"
                     find_re = None
                     continue
+                new_name = new_name[:name_max_len]
                 if new_name != name:
                     find_match_count += 1
                     if len(find_matches) < limit:
@@ -3236,12 +3252,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:
@@ -3305,7 +3350,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.
 
@@ -3329,7 +3379,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")
@@ -3393,7 +3443,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.
 
@@ -3417,9 +3472,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
@@ -3432,16 +3488,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/migrations/0038_add_catchup_fields.py b/apps/channels/migrations/0038_add_catchup_fields.py
new file mode 100644
index 00000000..8f653a3c
--- /dev/null
+++ b/apps/channels/migrations/0038_add_catchup_fields.py
@@ -0,0 +1,101 @@
+"""Add denormalized catch-up fields to Stream and Channel."""
+
+from django.db import migrations, models
+
+
+def backfill_stream_catchup(apps, schema_editor):
+    """Derive is_catchup/catchup_days from Stream.custom_properties JSON."""
+    with schema_editor.connection.cursor() as cursor:
+        cursor.execute("""
+            UPDATE dispatcharr_channels_stream
+            SET is_catchup = TRUE,
+                catchup_days = COALESCE(
+                    CASE WHEN (custom_properties->>'tv_archive_duration') ~ '^\\d+$'
+                         THEN (custom_properties->>'tv_archive_duration')::int
+                         ELSE NULL
+                    END, 7
+                )
+            WHERE custom_properties IS NOT NULL
+              AND custom_properties != 'null'::jsonb
+              AND (
+                  custom_properties->>'tv_archive' = '1'
+                  -- JSON booleans extract as lowercase 'true' via ->>; the
+                  -- 'True' spelling covers Python-str values stored by
+                  -- older import code.
+                  OR custom_properties->>'tv_archive' = 'true'
+                  OR custom_properties->>'tv_archive' = 'True'
+              )
+        """)
+
+
+def backfill_channel_catchup(apps, schema_editor):
+    """Roll up catch-up fields from streams to channels."""
+    with schema_editor.connection.cursor() as cursor:
+        cursor.execute("""
+            UPDATE dispatcharr_channels_channel c SET
+                is_catchup = EXISTS (
+                    SELECT 1 FROM dispatcharr_channels_channelstream cs
+                    JOIN dispatcharr_channels_stream s ON s.id = cs.stream_id
+                    WHERE cs.channel_id = c.id AND s.is_catchup = TRUE
+                ),
+                catchup_days = COALESCE((
+                    SELECT MAX(s.catchup_days) FROM dispatcharr_channels_channelstream cs
+                    JOIN dispatcharr_channels_stream s ON s.id = cs.stream_id
+                    WHERE cs.channel_id = c.id AND s.is_catchup = TRUE
+                ), 0)
+        """)
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ("dispatcharr_channels", "0037_auto_sync_overhaul"),
+    ]
+
+    operations = [
+        # Stream fields
+        migrations.AddField(
+            model_name="stream",
+            name="is_catchup",
+            field=models.BooleanField(
+                default=False,
+                db_index=True,
+                help_text="Whether this stream supports catch-up/timeshift (tv_archive=1)",
+            ),
+        ),
+        migrations.AddField(
+            model_name="stream",
+            name="catchup_days",
+            field=models.PositiveIntegerField(
+                default=0,
+                help_text="Number of days of catch-up archive available (tv_archive_duration)",
+            ),
+        ),
+        # Channel fields
+        migrations.AddField(
+            model_name="channel",
+            name="is_catchup",
+            field=models.BooleanField(
+                default=False,
+                db_index=True,
+                help_text="Whether any stream on this channel supports catch-up (tv_archive=1)",
+            ),
+        ),
+        migrations.AddField(
+            model_name="channel",
+            name="catchup_days",
+            field=models.PositiveIntegerField(
+                default=0,
+                help_text="Max catch-up archive days across all streams on this channel",
+            ),
+        ),
+        # Backfill existing data
+        migrations.RunPython(
+            backfill_stream_catchup,
+            reverse_code=migrations.RunPython.noop,
+        ),
+        migrations.RunPython(
+            backfill_channel_catchup,
+            reverse_code=migrations.RunPython.noop,
+        ),
+    ]
diff --git a/apps/channels/models.py b/apps/channels/models.py
index 747d0b89..fb421080 100644
--- a/apps/channels/models.py
+++ b/apps/channels/models.py
@@ -135,6 +135,17 @@ class Stream(models.Model):
         db_index=True
     )
 
+    # Populated at import from tv_archive / tv_archive_duration.
+    is_catchup = models.BooleanField(
+        default=False,
+        db_index=True,
+        help_text="Whether this stream supports catch-up/timeshift (tv_archive=1)",
+    )
+    catchup_days = models.PositiveIntegerField(
+        default=0,
+        help_text="Number of days of catch-up archive available (tv_archive_duration)",
+    )
+
     class Meta:
         # If you use m3u_account, you might do unique_together = ('name','url','m3u_account')
         verbose_name = "Stream"
@@ -364,6 +375,17 @@ class Channel(models.Model):
         help_text="The M3U account that auto-created this channel"
     )
 
+    # Populated at import; rolled up via ChannelStream signal / m3u refresh.
+    is_catchup = models.BooleanField(
+        default=False,
+        db_index=True,
+        help_text="Whether any stream on this channel supports catch-up (tv_archive=1)",
+    )
+    catchup_days = models.PositiveIntegerField(
+        default=0,
+        help_text="Max catch-up archive days across all streams on this channel",
+    )
+
     # Hidden channels are excluded from HDHR, M3U, EPG, and XC output queries.
     # Auto-sync still recognizes them so they are not recreated when their
     # underlying provider stream persists; this is an output-layer concern, not
diff --git a/apps/channels/serializers.py b/apps/channels/serializers.py
index 61bbef8d..d62b480e 100644
--- a/apps/channels/serializers.py
+++ b/apps/channels/serializers.py
@@ -448,6 +448,7 @@ class ChannelSerializer(serializers.ModelSerializer):
             "logo_id",
             "user_level",
             "is_adult",
+            "is_catchup",
             "hidden_from_output",
             "auto_created",
             "auto_created_by",
diff --git a/apps/channels/signals.py b/apps/channels/signals.py
index 53f1ea33..1c3d00ef 100644
--- a/apps/channels/signals.py
+++ b/apps/channels/signals.py
@@ -5,7 +5,7 @@ from django.dispatch import receiver
 from django.utils.timezone import now, is_aware, make_aware
 from celery.result import AsyncResult
 from django_celery_beat.models import ClockedSchedule, PeriodicTask
-from .models import Channel, Stream, ChannelProfile, ChannelProfileMembership, Recording
+from .models import Channel, Stream, ChannelStream, ChannelProfile, ChannelProfileMembership, Recording
 from apps.m3u.models import M3UAccount
 from apps.epg.tasks import parse_programs_for_tvg_id
 import json
@@ -369,3 +369,20 @@ def schedule_task_on_save(sender, instance, created, **kwargs):
 @receiver(post_delete, sender=Recording)
 def revoke_task_on_delete(sender, instance, **kwargs):
     revoke_task(instance.task_id)
+
+
+@receiver([post_save, post_delete], sender=ChannelStream)
+def update_channel_catchup_fields(sender, instance, **kwargs):
+    """Roll up catch-up flags from active streams (UI path; import uses SQL rollup)."""
+    from django.db.models import Max
+
+    channel = instance.channel
+    catchup_qs = channel.streams.filter(
+        is_catchup=True,
+        m3u_account__is_active=True,
+    )
+    max_days = catchup_qs.aggregate(max_days=Max("catchup_days"))["max_days"]
+    Channel.objects.filter(pk=channel.pk).update(
+        is_catchup=catchup_qs.exists(),
+        catchup_days=max_days or 0,
+    )
diff --git a/apps/channels/tests/test_catchup_utils.py b/apps/channels/tests/test_catchup_utils.py
new file mode 100644
index 00000000..d79eec11
--- /dev/null
+++ b/apps/channels/tests/test_catchup_utils.py
@@ -0,0 +1,100 @@
+from unittest.mock import patch
+
+from django.test import RequestFactory, SimpleTestCase, TestCase
+
+from apps.accounts.models import User
+from apps.channels.models import Channel, ChannelStream, Stream
+from apps.channels.utils import resolve_xc_epg_prev_days
+from apps.m3u.models import M3UAccount
+
+
+class ResolveXcEpgPrevDaysTests(SimpleTestCase):
+    def setUp(self):
+        self.factory = RequestFactory()
+        self.user = User(username="xc-prev", custom_properties={})
+
+    def test_url_prev_days_zero_is_explicit(self):
+        request = self.factory.get("/xmltv.php?prev_days=0")
+        self.assertEqual(resolve_xc_epg_prev_days(request, self.user), 0)
+
+    def test_user_epg_prev_days_used_when_url_omitted(self):
+        self.user.custom_properties = {"epg_prev_days": 5}
+        request = self.factory.get("/xmltv.php")
+        self.assertEqual(resolve_xc_epg_prev_days(request, self.user), 5)
+
+    @patch("apps.channels.utils.compute_provider_archive_days_capped", return_value=14)
+    def test_auto_detect_only_when_no_url_or_user_default(self, mock_compute):
+        request = self.factory.get("/xmltv.php")
+        self.assertEqual(resolve_xc_epg_prev_days(request, self.user), 14)
+        mock_compute.assert_called_once()
+
+    @patch("apps.channels.utils.compute_provider_archive_days_capped", return_value=14)
+    def test_per_channel_epg_skips_global_auto_detect(self, mock_compute):
+        request = self.factory.get("/player_api.php")
+        self.assertEqual(
+            resolve_xc_epg_prev_days(request, self.user, auto_detect_fallback=False),
+            0,
+        )
+        mock_compute.assert_not_called()
+
+    @patch("apps.channels.utils.compute_provider_archive_days_capped", return_value=14)
+    def test_user_default_prevents_auto_detect(self, mock_compute):
+        self.user.custom_properties = {"epg_prev_days": 3}
+        request = self.factory.get("/xmltv.php")
+        self.assertEqual(resolve_xc_epg_prev_days(request, self.user), 3)
+        mock_compute.assert_not_called()
+
+    @patch("apps.channels.utils.compute_provider_archive_days_capped", return_value=14)
+    @patch("core.models.CoreSettings.get_xmltv_prev_days_override", return_value=7)
+    def test_epg_settings_override_prevents_auto_detect(self, _override, mock_compute):
+        request = self.factory.get("/xmltv.php")
+        self.assertEqual(resolve_xc_epg_prev_days(request, self.user), 7)
+        mock_compute.assert_not_called()
+
+
+class CatchupRollupActiveAccountTests(TestCase):
+    """Denormalized catch-up flags ignore disabled M3U accounts."""
+
+    @classmethod
+    def setUpTestData(cls):
+        cls.inactive = M3UAccount.objects.create(
+            name="catchup-inactive",
+            server_url="http://example.test",
+            account_type="XC",
+            is_active=False,
+        )
+
+    def test_channelstream_signal_ignores_inactive_catchup_stream(self):
+        channel = Channel.objects.create(name="inactive-only")
+        stream = Stream.objects.create(
+            name="inactive-catchup",
+            url="http://example.test/inactive",
+            m3u_account=self.inactive,
+            is_catchup=True,
+            catchup_days=9,
+        )
+        ChannelStream.objects.create(channel=channel, stream=stream, order=0)
+
+        channel.refresh_from_db()
+        self.assertFalse(channel.is_catchup)
+        self.assertEqual(channel.catchup_days, 0)
+
+    def test_rollup_ignores_inactive_catchup_stream(self):
+        from apps.m3u.tasks import rollup_channel_catchup_fields
+
+        channel = Channel.objects.create(name="rollup-inactive-only")
+        stream = Stream.objects.create(
+            name="rollup-inactive-catchup",
+            url="http://example.test/rollup-inactive",
+            m3u_account=self.inactive,
+            is_catchup=True,
+            catchup_days=9,
+        )
+        ChannelStream.objects.create(channel=channel, stream=stream, order=0)
+        Channel.objects.filter(pk=channel.pk).update(is_catchup=True, catchup_days=9)
+
+        rollup_channel_catchup_fields(self.inactive.id)
+
+        channel.refresh_from_db()
+        self.assertFalse(channel.is_catchup)
+        self.assertEqual(channel.catchup_days, 0)
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_teardown.py b/apps/channels/tests/test_ts_proxy_teardown.py
index 20fd92ea..b76918ac 100644
--- a/apps/channels/tests/test_ts_proxy_teardown.py
+++ b/apps/channels/tests/test_ts_proxy_teardown.py
@@ -1,6 +1,6 @@
 """Tests for multi-worker channel teardown coordination."""
 import time
-from unittest.mock import MagicMock, patch
+from unittest.mock import ANY, MagicMock, patch
 
 from django.test import TestCase
 
@@ -692,9 +692,8 @@ class InitWaitAbortTests(TestCase):
 
         self.assertEqual(generator._init_wait_abort_reason(server, time.time()), "client_gone")
 
-    def test_abort_when_connect_stalled_without_buffer(self):
-        from apps.proxy.config import TSConfig as Config
-
+    @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()
@@ -707,9 +706,128 @@ class InitWaitAbortTests(TestCase):
         server.redis_client.hget.return_value = b"connecting"
         server.redis_client.get.return_value = None
 
-        started = time.time() - (getattr(Config, "CONNECTION_TIMEOUT", 10) + 1)
+        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):
@@ -805,3 +923,62 @@ class StreamManagerStillOwnerTests(TestCase):
             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/channels/utils.py b/apps/channels/utils.py
index 60a27146..70b9eecd 100644
--- a/apps/channels/utils.py
+++ b/apps/channels/utils.py
@@ -1,8 +1,13 @@
 import logging
 import threading
 
+from django.core.cache import cache
+
 logger = logging.getLogger(__name__)
 
+PROVIDER_ARCHIVE_CACHE_TTL_SECONDS = 300
+MAX_AUTO_PREV_DAYS = 30
+
 # Bound memory/DB work per chunk for large libraries (20k+ channels).
 EPG_LOGO_APPLY_BATCH_SIZE = 500
 EPG_LOGO_APPLY_MAX_ERRORS = 100
@@ -23,6 +28,91 @@ def format_channel_number(value, empty=""):
         return int(value)
     return value
 
+
+def compute_provider_archive_days_capped():
+    """Max ``catchup_days`` across active XC catch-up streams (capped, cached).
+
+    Cached briefly so XC XMLTV exports without an explicit ``prev_days`` do not
+    repeat the aggregate query on every request.
+    """
+    def _scan():
+        from django.db.models import Max
+
+        from apps.channels.models import Stream
+
+        result = Stream.objects.filter(
+            m3u_account__account_type="XC",
+            m3u_account__is_active=True,
+            is_catchup=True,
+        ).aggregate(max_days=Max("catchup_days"))
+        return min(result["max_days"] or 0, MAX_AUTO_PREV_DAYS)
+
+    return cache.get_or_set(
+        "channels:provider_archive_days_capped",
+        _scan,
+        PROVIDER_ARCHIVE_CACHE_TTL_SECONDS,
+    )
+
+
+def resolve_xc_epg_prev_days(request, user, *, auto_detect_fallback=True):
+    """Resolve ``prev_days`` for XC XMLTV and player_api EPG.
+
+    Args:
+        request: HTTP request (reads ``?prev_days=``).
+        user: Authenticated user (reads ``custom_properties.epg_prev_days``).
+        auto_detect_fallback: When True (XC XMLTV), fall back to the largest
+            provider archive depth. When False (per-channel EPG), return 0 so
+            ``xc_get_epg`` can expand to each channel's ``catchup_days``.
+
+    Resolution order:
+        1. URL ``?prev_days=`` (explicit; 0 means no past programmes)
+        2. ``user.custom_properties.epg_prev_days``
+        3. ``CoreSettings.epg_settings.xmltv_prev_days_override`` when > 0
+        4. Auto-detect (only when *auto_detect_fallback* is True)
+    """
+    user_custom = (user.custom_properties or {}) if user else {}
+    url_prev = request.GET.get("prev_days")
+    user_prev = user_custom.get("epg_prev_days") if user_custom else None
+
+    if url_prev is not None:
+        try:
+            return max(0, min(int(url_prev), MAX_AUTO_PREV_DAYS))
+        except (ValueError, TypeError):
+            return 0
+    if user_prev not in (None, ""):
+        try:
+            return max(0, min(int(user_prev), MAX_AUTO_PREV_DAYS))
+        except (ValueError, TypeError):
+            return 0
+
+    from core.models import CoreSettings
+
+    try:
+        override = int(CoreSettings.get_xmltv_prev_days_override() or 0)
+    except (TypeError, ValueError):
+        override = 0
+    if override > 0:
+        return max(0, min(override, MAX_AUTO_PREV_DAYS))
+    if auto_detect_fallback:
+        return compute_provider_archive_days_capped()
+    return 0
+
+
+def get_channel_catchup_streams(channel):
+    """Active catch-up streams for a channel, in ``channelstream`` order.
+
+    Inactive M3U accounts are excluded, matching live dispatch.
+    """
+    if not getattr(channel, "is_catchup", False):
+        return []
+
+    return list(
+        channel.streams.filter(is_catchup=True, m3u_account__is_active=True)
+        .order_by("channelstream__order")
+        .select_related("m3u_account")
+    )
+
+
 def increment_stream_count(account):
     with lock:
         current_usage = active_streams_map.get(account.id, 0)
diff --git a/apps/epg/api_views.py b/apps/epg/api_views.py
index fbc419c5..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'))
@@ -986,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)
@@ -1082,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
 
 
 # ─────────────────────────────
@@ -1119,7 +1125,7 @@ class EPGImportAPIView(APIView):
         epg_id = request.data.get("id", None)
         force = bool(request.data.get("force", False))
 
-        # Reject dummy sources without loading programme_index (multi-MB JSON).
+        # Reject dummy sources with a narrow existence query, no full row load.
         if epg_id is not None:
             from .models import EPGSource
 
@@ -1236,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 9661c5b9..83aaa275 100644
--- a/apps/epg/tasks.py
+++ b/apps/epg/tasks.py
@@ -26,7 +26,7 @@ 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 .models import EPGSource, EPGSourceIndex, EPGData, ProgramData, SDScheduleMD5, SDProgramMD5
 from core.utils import (
     acquire_task_lock,
     is_task_lock_held,
@@ -653,7 +653,9 @@ def _refresh_epg_data_impl(source_id, force=False):
     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)
+        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
@@ -4484,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.
@@ -4573,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
@@ -4620,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
index c58f2a45..cc96c214 100644
--- a/apps/epg/tests/test_epg_import_api.py
+++ b/apps/epg/tests/test_epg_import_api.py
@@ -7,7 +7,7 @@ from django.test import TestCase
 from rest_framework import status
 from rest_framework.test import APIClient
 
-from apps.epg.models import EPGSource
+from apps.epg.models import EPGSource, EPGSourceIndex
 
 User = get_user_model()
 
@@ -47,7 +47,10 @@ class EPGImportAPITests(TestCase):
             name="Large Index XMLTV",
             source_type="xmltv",
             url="http://example.com/epg.xml",
-            programme_index={
+        )
+        EPGSourceIndex.objects.create(
+            source=source,
+            data={
                 "channels": {f"ch.{i}": {"offsets": [0, 100]} for i in range(200)},
                 "interleaved_channels": [],
             },
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/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/tasks.py b/apps/m3u/tasks.py
index 64f16fd7..fa207464 100644
--- a/apps/m3u/tasks.py
+++ b/apps/m3u/tasks.py
@@ -26,7 +26,7 @@ from core.utils import (
 from core.models import CoreSettings, UserAgent
 from core.xtream_codes import Client as XCClient
 from core.utils import send_websocket_update
-from .utils import normalize_stream_url
+from .utils import convert_js_numbered_backreferences, normalize_stream_url
 
 logger = logging.getLogger(__name__)
 
@@ -52,9 +52,9 @@ def _db_query_with_retry(fn, *, label="DB query", max_retries=2):
     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
+    from django.db import DatabaseError, InterfaceError, OperationalError
 
-    transient_errors = (OperationalError, InterfaceError, IndexError)
+    transient_errors = (OperationalError, InterfaceError, IndexError, DatabaseError)
     for attempt in range(max_retries):
         try:
             return fn()
@@ -134,11 +134,23 @@ def _ensure_m3u_refresh_terminal_status(account_id):
 _EXTINF_ATTR_RE = re.compile(r'([^\s=]+)\s*=\s*(["\'])(.*?)\2')
 
 
+def _open_m3u_text_source(source_path):
+    """Open an on-disk M3U (or .m3u.gz) file for line-by-line parsing."""
+    if source_path.endswith(".gz"):
+        return gzip.open(source_path, "rt", encoding="utf-8")
+    return open(source_path, "r", encoding="utf-8")
+
+
 def fetch_m3u_lines(account, use_cache=False):
+    """Fetch M3U source for parsing.
+
+    On success returns ``(source, True)`` where *source* is either a filesystem
+    path (streamed during parse) or, for ZIP uploads only, an in-memory line
+    list. Failures return ``(None, False)``.
+    """
     os.makedirs(m3u_dir, exist_ok=True)
     file_path = os.path.join(m3u_dir, f"{account.id}.m3u")
 
-    """Fetch M3U file lines efficiently."""
     if account.server_url:
         if not use_cache or not os.path.exists(file_path):
             try:
@@ -213,7 +225,7 @@ def fetch_m3u_lines(account, use_cache=False):
                         status="error",
                         error=error_msg,
                     )
-                    return [], False
+                    return None, False
 
                 # Only call raise_for_status if we have a success code (this should not raise now)
                 response.raise_for_status()
@@ -288,7 +300,7 @@ def fetch_m3u_lines(account, use_cache=False):
                             status="error",
                             error=error_msg,
                         )
-                        return [], False
+                        return None, False
 
                     # Validate the file by reading only the first portion from
                     # disk — no need to load the entire file into memory just
@@ -360,7 +372,7 @@ def fetch_m3u_lines(account, use_cache=False):
                                 status="error",
                                 error=error_msg,
                             )
-                            return [], False
+                            return None, False
 
                     except UnicodeDecodeError:
                         with open(temp_path, "rb") as vf:
@@ -378,7 +390,7 @@ def fetch_m3u_lines(account, use_cache=False):
                             status="error",
                             error=error_msg,
                         )
-                        return [], False
+                        return None, False
 
                     # Validation passed — promote temp file to final path
                     os.replace(temp_path, file_path)
@@ -433,7 +445,7 @@ def fetch_m3u_lines(account, use_cache=False):
                     status="error",
                     error=error_msg,
                 )
-                return [], False
+                return None, False
             except requests.exceptions.RequestException as e:
                 # Handle other request errors (connection, timeout, etc.)
                 if "timeout" in str(e).lower():
@@ -454,7 +466,7 @@ def fetch_m3u_lines(account, use_cache=False):
                     status="error",
                     error=error_msg,
                 )
-                return [], False
+                return None, False
             except Exception as e:
                 # Handle any other unexpected errors
                 error_msg = f"Unexpected error while fetching M3U file from URL: {account.server_url} - {str(e)}"
@@ -469,7 +481,7 @@ def fetch_m3u_lines(account, use_cache=False):
                     status="error",
                     error=error_msg,
                 )
-                return [], False
+                return None, False
 
         # Check if the file exists and is not empty (fallback check - should not happen with new validation)
         if not os.path.exists(file_path) or os.path.getsize(file_path) == 0:
@@ -481,27 +493,14 @@ def fetch_m3u_lines(account, use_cache=False):
             send_m3u_update(
                 account.id, "downloading", 100, status="error", error=error_msg
             )
-            return [], False  # Return empty list and False for success
+            return None, False
 
-        try:
-            with open(file_path, "r", encoding="utf-8") as f:
-                return f.readlines(), True
-        except Exception as e:
-            error_msg = f"Error reading M3U file: {str(e)}"
-            logger.error(error_msg)
-            account.status = M3UAccount.Status.ERROR
-            account.last_message = error_msg
-            account.save(update_fields=["status", "last_message"])
-            send_m3u_update(
-                account.id, "downloading", 100, status="error", error=error_msg
-            )
-            return [], False
+        return file_path, True
 
     elif account.file_path:
         try:
             if account.file_path.endswith(".gz"):
-                with gzip.open(account.file_path, "rt", encoding="utf-8") as f:
-                    return f.readlines(), True
+                return account.file_path, True
 
             elif account.file_path.endswith(".zip"):
                 with zipfile.ZipFile(account.file_path, "r") as zip_file:
@@ -522,11 +521,10 @@ def fetch_m3u_lines(account, use_cache=False):
                     send_m3u_update(
                         account.id, "downloading", 100, status="error", error=error_msg
                     )
-                    return [], False
+                    return None, False
 
             else:
-                with open(account.file_path, "r", encoding="utf-8") as f:
-                    return f.readlines(), True
+                return account.file_path, True
 
         except (IOError, OSError, zipfile.BadZipFile, gzip.BadGzipFile) as e:
             error_msg = f"Error opening file {account.file_path}: {e}"
@@ -537,7 +535,7 @@ def fetch_m3u_lines(account, use_cache=False):
             send_m3u_update(
                 account.id, "downloading", 100, status="error", error=error_msg
             )
-            return [], False
+            return None, False
 
     # Neither server_url nor uploaded_file is available
     error_msg = "No M3U source available (missing URL and file)"
@@ -546,7 +544,7 @@ def fetch_m3u_lines(account, use_cache=False):
     account.last_message = error_msg
     account.save(update_fields=["status", "last_message"])
     send_m3u_update(account.id, "downloading", 100, status="error", error=error_msg)
-    return [], False
+    return None, False
 
 
 def get_case_insensitive_attr(attributes, key, default=""):
@@ -746,13 +744,16 @@ def process_groups(account, groups, scan_start_time=None):
     all_group_objs = existing_group_objs + newly_created_group_objs
 
     # Get existing relationships for this account
-    existing_relationships = {
-        rel.channel_group.name: rel
-        for rel in ChannelGroupM3UAccount.objects.filter(
-            m3u_account=account,
-            channel_group__name__in=groups.keys()
-        ).select_related('channel_group')
-    }
+    existing_relationships = _db_query_with_retry(
+        lambda: {
+            rel.channel_group.name: rel
+            for rel in ChannelGroupM3UAccount.objects.filter(
+                m3u_account=account,
+                channel_group__name__in=groups.keys(),
+            ).select_related("channel_group")
+        },
+        label=f"process_groups relationships for account {account.id}",
+    )
 
     relations_to_create = []
     relations_to_update = []
@@ -905,6 +906,11 @@ def collect_xc_streams(account_id, enabled_groups):
             account.get_user_agent(),
         ) as xc_client:
 
+            stream_url_prefix = (
+                f"{xc_client.server_url.rstrip('/')}/live/"
+                f"{xc_client.username}/{xc_client.password}/"
+            )
+
             # Fetch ALL live streams in a single API call (much more efficient)
             logger.info("Fetching ALL live streams from XC provider...")
             all_xc_streams = xc_client.get_all_live_streams()  # Get all streams without category filter
@@ -917,46 +923,49 @@ def collect_xc_streams(account_id, enabled_groups):
 
             # Filter streams based on enabled categories
             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')}"
+                category_id = str(stream.get("category_id", ""))
+                if category_id not in enabled_category_ids:
+                    continue
+
+                group_info = enabled_category_ids[category_id]
+                stream_name = stream.get("name") or (
+                    f"{account.name} - {stream.get('stream_id', 'Unknown')}"
+                )
                 if not stream.get("name"):
                     logger.warning(
-                        f"XC stream has null/empty name; using generated name '{stream_name}' "
-                        f"(stream_id={stream.get('stream_id', 'unknown')})"
+                        "XC stream has null/empty name; using generated name '%s' "
+                        "(stream_id=%s)",
+                        stream_name, stream.get("stream_id", "unknown"),
                     )
 
-                # Get the category_id for this stream
-                category_id = str(stream.get("category_id", ""))
-
-                # Only include streams from enabled categories
-                if category_id in enabled_category_ids:
-                    group_info = enabled_category_ids[category_id]
-
-                    # Convert XC stream to our standard format with all properties preserved
-                    stream_data = {
-                        "name": stream_name,
-                        "url": xc_client.get_stream_url(stream["stream_id"]),
-                        "attributes": {
-                            "tvg-id": stream.get("epg_channel_id", ""),
-                            "tvg-logo": stream.get("stream_icon", ""),
-                            "group-title": group_info["name"],
-                            # Preserve all XC stream properties as custom attributes
-                            "stream_id": str(stream.get("stream_id", "")),
-                            "num": stream.get("num"),
-                            "category_id": category_id,
-                            "stream_type": stream.get("stream_type", ""),
-                            "added": stream.get("added", ""),
-                            "is_adult": str(stream.get("is_adult", "0")),
-                            "custom_sid": stream.get("custom_sid", ""),
-                            # Include any other properties that might be present
-                            **{k: str(v) for k, v in stream.items() if k not in [
-                                "name", "stream_id", "epg_channel_id", "stream_icon",
-                                "category_id", "stream_type", "added", "is_adult", "custom_sid", "num"
-                            ] and v is not None}
-                        }
-                    }
-                    all_streams.append(stream_data)
-                    filtered_count += 1
+                stream_id = stream.get("stream_id")
+                attributes = {
+                    "tvg-id": stream.get("epg_channel_id", ""),
+                    "tvg-logo": stream.get("stream_icon", ""),
+                    "group-title": group_info["name"],
+                    "stream_id": str(stream.get("stream_id", "")),
+                    "num": stream.get("num"),
+                    "category_id": category_id,
+                    "stream_type": stream.get("stream_type", ""),
+                    "added": stream.get("added", ""),
+                    "is_adult": str(stream.get("is_adult", "0")),
+                    "custom_sid": stream.get("custom_sid", ""),
+                    **{
+                        k: str(v)
+                        for k, v in stream.items()
+                        if k not in [
+                            "name", "stream_id", "epg_channel_id", "stream_icon",
+                            "category_id", "stream_type", "added", "is_adult",
+                            "custom_sid", "num",
+                        ] and v is not None
+                    },
+                }
+                all_streams.append({
+                    "name": stream_name,
+                    "url": f"{stream_url_prefix}{stream_id}.ts",
+                    "attributes": attributes,
+                })
+                filtered_count += 1
 
             # Drop the full provider catalog before returning; only filtered rows are needed.
             del all_xc_streams
@@ -971,6 +980,80 @@ def collect_xc_streams(account_id, enabled_groups):
     )
     return all_streams
 
+
+def _compile_m3u_stream_filters(filter_queryset):
+    """Compile account M3UFilter rows once per refresh for batch workers."""
+    compiled = []
+    for filter_obj in filter_queryset:
+        flags = (
+            re.IGNORECASE
+            if (filter_obj.custom_properties or {}).get("case_sensitive", True) is False
+            else 0
+        )
+        compiled.append((re.compile(filter_obj.regex_pattern, flags), filter_obj))
+    return compiled
+
+
+def _stream_passes_m3u_filters(name, url, group_title, compiled_filters):
+    """Return False when the first matching filter excludes the stream."""
+    for pattern, filter_obj in compiled_filters:
+        logger.trace("Checking filter pattern %s", pattern.pattern)
+        if filter_obj.filter_type == "url":
+            target = url
+        elif filter_obj.filter_type == "group":
+            target = group_title
+        else:
+            target = name
+
+        if pattern.search(target or ""):
+            logger.debug(
+                "Stream %s - %s matches filter pattern %s",
+                name, url, filter_obj.regex_pattern,
+            )
+            return not filter_obj.exclude
+    return True
+
+
+_STREAM_TOUCH_FIELDS = ("last_seen", "is_stale")
+_STREAM_CHANGED_FIELDS = (
+    "name", "url", "logo_url", "tvg_id", "custom_properties", "is_adult",
+    "last_seen", "updated_at", "is_stale", "stream_id", "stream_chno",
+    "channel_group_id", "is_catchup", "catchup_days",
+)
+
+
+def _bulk_update_stream_refresh_batches(changed_streams, touch_streams, *, batch_size):
+    """Unchanged streams only need last_seen/is_stale; changed rows get the full set."""
+    if touch_streams:
+        Stream.objects.bulk_update(
+            touch_streams, list(_STREAM_TOUCH_FIELDS), batch_size=batch_size,
+        )
+    if changed_streams:
+        Stream.objects.bulk_update(
+            changed_streams, list(_STREAM_CHANGED_FIELDS), batch_size=batch_size,
+        )
+
+
+def _batch_stream_count_message(created, updated, unchanged):
+    """Human-readable batch summary; unchanged = last_seen touch only."""
+    return (
+        f"{created} created, {updated} updated, {unchanged} unchanged."
+    )
+
+
+def _parse_batch_stream_counts(result):
+    """Extract (created, updated, unchanged) from a batch processing result string."""
+    if not isinstance(result, str):
+        return 0, 0, 0
+    try:
+        created = int(re.search(r"(\d+) created", result).group(1))
+        updated = int(re.search(r"(\d+) updated", result).group(1))
+        unchanged = int(re.search(r"(\d+) unchanged", result).group(1))
+        return created, updated, unchanged
+    except (AttributeError, ValueError):
+        return 0, 0, 0
+
+
 def process_xc_category_direct(account_id, batch, groups, hash_keys):
     from django.db import connections
 
@@ -981,6 +1064,7 @@ def process_xc_category_direct(account_id, batch, groups, hash_keys):
 
     streams_to_create = []
     streams_to_update = []
+    streams_to_touch = []
     stream_hashes = {}
 
     try:
@@ -1053,6 +1137,13 @@ def process_xc_category_direct(account_id, batch, groups, hash_keys):
                             name, url, tvg_id, hash_keys, m3u_id=account_id, group=group_title,
                             account_type='XC', stream_id=provider_stream_id
                         )
+                        _tv_archive = str(stream.get("tv_archive", "0"))
+                        _is_catchup = _tv_archive in ("1", "True")
+                        try:
+                            _catchup_days = int(stream.get("tv_archive_duration", 0) or 0)
+                        except (TypeError, ValueError):
+                            _catchup_days = 0
+
                         stream_props = {
                             "name": name,
                             "url": url,
@@ -1066,6 +1157,8 @@ def process_xc_category_direct(account_id, batch, groups, hash_keys):
                             "is_stale": False,
                             "stream_id": provider_stream_id,
                             "stream_chno": stream_chno,
+                            "is_catchup": _is_catchup,
+                            "catchup_days": _catchup_days,
                         }
 
                         if stream_hash not in stream_hashes:
@@ -1080,7 +1173,7 @@ def process_xc_category_direct(account_id, batch, groups, hash_keys):
         existing_streams = {
             s.stream_hash: s
             for s in Stream.objects.filter(stream_hash__in=stream_hashes.keys()).select_related('m3u_account').only(
-                'id', 'stream_hash', 'name', 'url', 'logo_url', 'tvg_id', 'custom_properties', 'last_seen', 'updated_at', 'm3u_account', 'stream_id', 'stream_chno', 'channel_group_id'
+                'id', 'stream_hash', 'name', 'url', 'logo_url', 'tvg_id', 'custom_properties', 'last_seen', 'updated_at', 'm3u_account', 'stream_id', 'stream_chno', 'channel_group_id', 'is_catchup', 'catchup_days'
             )
         }
 
@@ -1097,7 +1190,9 @@ def process_xc_category_direct(account_id, batch, groups, hash_keys):
                     obj.is_adult != stream_props["is_adult"] or
                     obj.stream_id != stream_props["stream_id"] or
                     obj.stream_chno != stream_props["stream_chno"] or
-                    obj.channel_group_id != stream_props["channel_group_id"]
+                    obj.channel_group_id != stream_props["channel_group_id"] or
+                    obj.is_catchup != stream_props["is_catchup"] or
+                    obj.catchup_days != stream_props["catchup_days"]
                 )
 
                 if changed:
@@ -1108,11 +1203,9 @@ def process_xc_category_direct(account_id, batch, groups, hash_keys):
                     obj.is_stale = False
                     streams_to_update.append(obj)
                 else:
-                    # Always update last_seen, even if nothing else changed
                     obj.last_seen = timezone.now()
                     obj.is_stale = False
-                    # Don't update updated_at for unchanged streams
-                    streams_to_update.append(obj)
+                    streams_to_touch.append(obj)
 
                 # Remove from existing_streams since we've processed it
                 del existing_streams[stream_hash]
@@ -1129,13 +1222,9 @@ def process_xc_category_direct(account_id, batch, groups, hash_keys):
                 if streams_to_create:
                     Stream.objects.bulk_create(streams_to_create, ignore_conflicts=True)
 
-                if streams_to_update:
-                    # Simplified bulk update for better performance
-                    Stream.objects.bulk_update(
-                        streams_to_update,
-                        ['name', 'url', 'logo_url', 'tvg_id', 'custom_properties', 'is_adult', 'last_seen', 'updated_at', 'is_stale', 'stream_id', 'stream_chno', 'channel_group_id'],
-                        batch_size=150  # Smaller batch size for XC processing
-                    )
+                _bulk_update_stream_refresh_batches(
+                    streams_to_update, streams_to_touch, batch_size=150,
+                )
 
                 # Update last_seen for any remaining existing streams that weren't processed
                 if len(existing_streams.keys()) > 0:
@@ -1143,7 +1232,14 @@ def process_xc_category_direct(account_id, batch, groups, hash_keys):
         except Exception as e:
             logger.error(f"Bulk operation failed for XC streams: {str(e)}")
 
-        retval = f"Batch processed: {len(streams_to_create)} created, {len(streams_to_update)} updated."
+        retval = (
+            "Batch processed: "
+            + _batch_stream_count_message(
+                len(streams_to_create),
+                len(streams_to_update),
+                len(streams_to_touch),
+            )
+        )
 
     except Exception as e:
         logger.error(f"XC category processing error: {str(e)}")
@@ -1153,14 +1249,18 @@ def process_xc_category_direct(account_id, batch, groups, hash_keys):
         connections.close_all()
 
     # Aggressive garbage collection
-    del streams_to_create, streams_to_update, stream_hashes, existing_streams
+    del streams_to_create, streams_to_update, streams_to_touch, stream_hashes, existing_streams
     gc.collect()
 
     return retval
 
 
-def process_m3u_batch_direct(account_id, batch, groups, hash_keys):
-    """Processes a batch of M3U streams using bulk operations with thread-safe DB connections."""
+def process_m3u_batch_direct(account_id, batch, groups, hash_keys, compiled_filters=None):
+    """Processes a batch of M3U streams using bulk operations with thread-safe DB connections.
+
+    ``compiled_filters`` should be pre-built once per account refresh and shared
+    across batch workers. Pass an empty list when the account has no filters.
+    """
     from django.db import connections
 
     # Ensure clean database connections for threading
@@ -1168,33 +1268,22 @@ def process_m3u_batch_direct(account_id, batch, groups, hash_keys):
 
     account = M3UAccount.objects.get(id=account_id)
 
-    compiled_filters = [
-        (
-            re.compile(
-                f.regex_pattern,
-                (
-                    re.IGNORECASE
-                    if (f.custom_properties or {}).get(
-                        "case_sensitive", True
-                    )
-                    == False
-                    else 0
-                ),
-            ),
-            f,
-        )
-        for f in account.filters.order_by("order")
-    ]
+    if compiled_filters is None:
+        compiled_filters = _compile_m3u_stream_filters(account.filters.order_by("order"))
 
     streams_to_create = []
     streams_to_update = []
+    streams_to_touch = []
     stream_hashes = {}
 
     name_max_length = Stream._meta.get_field('name').max_length
 
     logger.debug(f"Processing batch of {len(batch)} for M3U account {account_id}")
     if compiled_filters:
-        logger.debug(f"Using compiled filters: {[f[1].regex_pattern for f in compiled_filters]}")
+        logger.debug(
+            "Using compiled filters: %s",
+            [filter_obj.regex_pattern for _, filter_obj in compiled_filters],
+        )
     for stream_info in batch:
         try:
             name, url = stream_info["name"], stream_info["url"]
@@ -1215,25 +1304,12 @@ def process_m3u_batch_direct(account_id, batch, groups, hash_keys):
             group_title = get_case_insensitive_attr(
                 stream_info["attributes"], "group-title", "Default Group"
             )
-            logger.debug(f"Processing stream: {name} - {url} in group {group_title}")
-            include = True
-            for pattern, filter in compiled_filters:
-                logger.trace(f"Checking filter pattern {pattern}")
-                target = name
-                if filter.filter_type == "url":
-                    target = url
-                elif filter.filter_type == "group":
-                    target = group_title
+            logger.trace("Processing stream: %s - %s in group %s", name, url, group_title)
 
-                if pattern.search(target or ""):
-                    logger.debug(
-                        f"Stream {name} - {url} matches filter pattern {filter.regex_pattern}"
-                    )
-                    include = not filter.exclude
-                    break
-
-            if not include:
-                logger.debug(f"Stream excluded by filter, skipping.")
+            if compiled_filters and not _stream_passes_m3u_filters(
+                name, url, group_title, compiled_filters,
+            ):
+                logger.debug("Stream excluded by filter, skipping.")
                 continue
 
             # Filter out disabled groups for this account
@@ -1279,6 +1355,14 @@ def process_m3u_batch_direct(account_id, batch, groups, hash_keys):
                 account_type=account_type_for_hash, stream_id=provider_stream_id
             )
 
+            _attrs = stream_info["attributes"]
+            _tv_archive_m3u = str(_attrs.get("tv_archive", "0"))
+            _is_catchup_m3u = _tv_archive_m3u in ("1", "True")
+            try:
+                _catchup_days_m3u = int(_attrs.get("tv_archive_duration", 0) or 0)
+            except (TypeError, ValueError):
+                _catchup_days_m3u = 0
+
             stream_props = {
                 "name": name,
                 "url": url,
@@ -1287,11 +1371,13 @@ def process_m3u_batch_direct(account_id, batch, groups, hash_keys):
                 "m3u_account": account,
                 "channel_group_id": int(groups.get(group_title)),
                 "stream_hash": stream_hash,
-                "custom_properties": {**stream_info["attributes"], "vlc_opts": stream_info["vlc_opts"]} if "vlc_opts" in stream_info else stream_info["attributes"],
-                "is_adult": parse_is_adult(stream_info["attributes"].get("is_adult", 0)),
+                "custom_properties": {**_attrs, "vlc_opts": stream_info["vlc_opts"]} if "vlc_opts" in stream_info else _attrs,
+                "is_adult": parse_is_adult(_attrs.get("is_adult", 0)),
                 "is_stale": False,
                 "stream_id": provider_stream_id,
                 "stream_chno": channel_num,
+                "is_catchup": _is_catchup_m3u,
+                "catchup_days": _catchup_days_m3u,
             }
 
             if stream_hash not in stream_hashes:
@@ -1303,7 +1389,7 @@ def process_m3u_batch_direct(account_id, batch, groups, hash_keys):
     existing_streams = {
         s.stream_hash: s
         for s in Stream.objects.filter(stream_hash__in=stream_hashes.keys()).select_related('m3u_account').only(
-            'id', 'stream_hash', 'name', 'url', 'logo_url', 'tvg_id', 'custom_properties', 'last_seen', 'updated_at', 'm3u_account', 'stream_id', 'stream_chno', 'channel_group_id'
+            'id', 'stream_hash', 'name', 'url', 'logo_url', 'tvg_id', 'custom_properties', 'last_seen', 'updated_at', 'm3u_account', 'stream_id', 'stream_chno', 'channel_group_id', 'is_catchup', 'catchup_days'
         )
     }
 
@@ -1320,14 +1406,15 @@ def process_m3u_batch_direct(account_id, batch, groups, hash_keys):
                 obj.is_adult != stream_props["is_adult"] or
                 obj.stream_id != stream_props["stream_id"] or
                 obj.stream_chno != stream_props["stream_chno"] or
-                obj.channel_group_id != stream_props["channel_group_id"]
+                obj.channel_group_id != stream_props["channel_group_id"] or
+                obj.is_catchup != stream_props["is_catchup"] or
+                obj.catchup_days != stream_props["catchup_days"]
             )
 
-            # Always update last_seen
             obj.last_seen = timezone.now()
+            obj.is_stale = False
 
             if changed:
-                # Only update fields that changed and set updated_at
                 obj.name = stream_props["name"]
                 obj.url = stream_props["url"]
                 obj.logo_url = stream_props["logo_url"]
@@ -1337,12 +1424,12 @@ def process_m3u_batch_direct(account_id, batch, groups, hash_keys):
                 obj.stream_id = stream_props["stream_id"]
                 obj.stream_chno = stream_props["stream_chno"]
                 obj.channel_group_id = stream_props["channel_group_id"]
+                obj.is_catchup = stream_props["is_catchup"]
+                obj.catchup_days = stream_props["catchup_days"]
                 obj.updated_at = timezone.now()
-
-            # Always mark as not stale since we saw it in this refresh
-            obj.is_stale = False
-
-            streams_to_update.append(obj)
+                streams_to_update.append(obj)
+            else:
+                streams_to_touch.append(obj)
         else:
             # New stream
             stream_props["last_seen"] = timezone.now()
@@ -1355,23 +1442,26 @@ def process_m3u_batch_direct(account_id, batch, groups, hash_keys):
             if streams_to_create:
                 Stream.objects.bulk_create(streams_to_create, ignore_conflicts=True)
 
-            if streams_to_update:
-                # Update all streams in a single bulk operation
-                Stream.objects.bulk_update(
-                    streams_to_update,
-                    ['name', 'url', 'logo_url', 'tvg_id', 'custom_properties', 'is_adult', 'last_seen', 'updated_at', 'is_stale', 'stream_id', 'stream_chno', 'channel_group_id'],
-                    batch_size=200
-                )
+            _bulk_update_stream_refresh_batches(
+                streams_to_update, streams_to_touch, batch_size=200,
+            )
     except Exception as e:
         logger.error(f"Bulk operation failed: {str(e)}")
 
-    retval = f"M3U account: {account_id}, Batch processed: {len(streams_to_create)} created, {len(streams_to_update)} updated."
+    retval = (
+        f"M3U account: {account_id}, Batch processed: "
+        + _batch_stream_count_message(
+            len(streams_to_create),
+            len(streams_to_update),
+            len(streams_to_touch),
+        )
+    )
 
     # Clean up database connections for threading
     connections.close_all()
 
     # Free batch data structures (reference-counted deallocation)
-    del streams_to_create, streams_to_update, stream_hashes, existing_streams
+    del streams_to_create, streams_to_update, streams_to_touch, stream_hashes, existing_streams
     gc.collect()
 
     return retval
@@ -1658,28 +1748,49 @@ def refresh_m3u_groups(account_id, use_cache=False, full_refresh=False, scan_sta
             release_task_lock("refresh_m3u_account_groups", account_id)
             return error_msg, None
     else:
-        lines, success = fetch_m3u_lines(account, use_cache)
+        source, success = fetch_m3u_lines(account, use_cache)
         if not success:
             # If fetch failed, don't continue processing
             lock_renewer.stop()
             release_task_lock("refresh_m3u_account_groups", account_id)
             return f"Failed to fetch M3U data for account_id={account_id}.", None
 
-        # Log basic file structure for debugging
-        logger.debug(f"Processing {len(lines)} lines from M3U file")
-
         valid_stream_count = 0
 
-        for entry in iter_m3u_entries(lines):
-            valid_stream_count += 1
-            group_title_attr = get_case_insensitive_attr(entry["attributes"], "group-title", "")
-            if group_title_attr and group_title_attr not in groups:
-                logger.debug(f"Found new group for M3U account {account_id}: '{group_title_attr}'")
-                groups[group_title_attr] = {}
-            extinf_data.append(entry)
+        if isinstance(source, str):
+            logger.debug(f"Streaming M3U parse from {source}")
+            with _open_m3u_text_source(source) as m3u_file:
+                entry_iter = iter_m3u_entries(m3u_file)
+                for entry in entry_iter:
+                    valid_stream_count += 1
+                    group_title_attr = get_case_insensitive_attr(entry["attributes"], "group-title", "")
+                    if group_title_attr and group_title_attr not in groups:
+                        logger.debug(f"Found new group for M3U account {account_id}: '{group_title_attr}'")
+                        groups[group_title_attr] = {}
+                    extinf_data.append(entry)
 
-            if valid_stream_count % 1000 == 0:
-                logger.debug(f"Processed {valid_stream_count} valid streams so far for M3U account: {account_id}")
+                    if valid_stream_count % 1000 == 0:
+                        logger.debug(
+                            f"Processed {valid_stream_count} valid streams so far for M3U account: {account_id}"
+                        )
+        else:
+            logger.debug(f"Processing {len(source)} in-memory M3U lines (zip upload)")
+            try:
+                for entry in iter_m3u_entries(source):
+                    valid_stream_count += 1
+                    group_title_attr = get_case_insensitive_attr(entry["attributes"], "group-title", "")
+                    if group_title_attr and group_title_attr not in groups:
+                        logger.debug(f"Found new group for M3U account {account_id}: '{group_title_attr}'")
+                        groups[group_title_attr] = {}
+                    extinf_data.append(entry)
+
+                    if valid_stream_count % 1000 == 0:
+                        logger.debug(
+                            f"Processed {valid_stream_count} valid streams so far for M3U account: {account_id}"
+                        )
+            finally:
+                del source
+                gc.collect()
 
         logger.info(f"M3U parsing complete - Valid streams: {valid_stream_count}")
 
@@ -1865,6 +1976,60 @@ def _classify_sync_failure(exc):
     return "OTHER"
 
 
+def rollup_channel_catchup_fields(account_id):
+    """Roll up catch-up flags from streams to channels (active accounts only).
+
+    Both the aggregate update and the self-heal pass are limited to channels
+    that still have at least one stream from *account_id*.
+    """
+    from django.db import connection
+
+    account_channels = """
+        SELECT DISTINCT cs.channel_id
+        FROM dispatcharr_channels_channelstream cs
+        JOIN dispatcharr_channels_stream s ON s.id = cs.stream_id
+        WHERE s.m3u_account_id = %s
+    """
+
+    with connection.cursor() as cur:
+        cur.execute(f"""
+            WITH agg AS (
+                SELECT
+                    cs.channel_id,
+                    bool_or(s.is_catchup AND a.is_active)  AS any_catchup,
+                    MAX(s.catchup_days) FILTER (WHERE s.is_catchup AND a.is_active) AS max_days
+                FROM dispatcharr_channels_channelstream cs
+                JOIN dispatcharr_channels_stream s ON s.id = cs.stream_id
+                JOIN m3u_m3uaccount a ON a.id = s.m3u_account_id
+                WHERE cs.channel_id IN ({account_channels})
+                GROUP BY cs.channel_id
+            )
+            UPDATE dispatcharr_channels_channel c
+            SET
+                is_catchup   = COALESCE(agg.any_catchup, FALSE),
+                catchup_days = COALESCE(agg.max_days, 0)
+            FROM agg
+            WHERE c.id = agg.channel_id
+        """, [account_id])
+
+        # Self-heal stale is_catchup flags on account-linked channels only.
+        cur.execute(f"""
+            UPDATE dispatcharr_channels_channel c
+            SET is_catchup = FALSE, catchup_days = 0
+            WHERE c.is_catchup = TRUE
+              AND c.id IN ({account_channels})
+              AND NOT EXISTS (
+                  SELECT 1
+                  FROM dispatcharr_channels_channelstream cs
+                  JOIN dispatcharr_channels_stream s ON s.id = cs.stream_id
+                  JOIN m3u_m3uaccount a ON a.id = s.m3u_account_id
+                  WHERE cs.channel_id = c.id
+                    AND s.is_catchup = TRUE
+                    AND a.is_active = TRUE
+              )
+        """, [account_id])
+
+
 @shared_task
 def sync_auto_channels(account_id, scan_start_time=None):
     """
@@ -1882,6 +2047,11 @@ def sync_auto_channels(account_id, scan_start_time=None):
     from apps.epg.models import EPGData
     from django.utils import timezone
 
+    channel_name_max_len = Channel._meta.get_field("name").max_length
+    # Per-call cap on the rename substitution; bounds catastrophic
+    # backtracking on a user-supplied pattern so it cannot hang the worker.
+    rename_regex_timeout = 0.1
+
     try:
         account = M3UAccount.objects.get(id=account_id)
         logger.info(f"Starting auto channel sync for M3U account {account.name}")
@@ -2435,17 +2605,30 @@ def sync_auto_channels(account_id, scan_start_time=None):
                             else ""
                         )
                         try:
-                            # Convert $1, $2, etc. to \1, \2, etc. for consistency with M3U profiles
-                            safe_replace_pattern = re.sub(r'\$(\d+)', r'\\\1', replace)
-                            new_name = re.sub(
-                                name_regex_pattern, safe_replace_pattern, original_name
+                            # Use the regex module (not stdlib re) so rename
+                            # patterns match the JS-style semantics the UI
+                            # authors and the preview uses; the timeout bounds
+                            # catastrophic backtracking.
+                            safe_replace_pattern = convert_js_numbered_backreferences(replace)
+                            new_name = regex.sub(
+                                name_regex_pattern,
+                                safe_replace_pattern,
+                                original_name,
+                                timeout=rename_regex_timeout,
                             )
-                        except re.error as e:
+                        except (regex.error, TimeoutError) as e:
                             logger.warning(
                                 f"Regex error for group '{channel_group.name}': {e}. Using original name."
                             )
                             new_name = original_name
 
+                    # Channel.name is bounded by the column length; a rename
+                    # that expands past it would otherwise fail the whole
+                    # bulk_create and abort the sync. Cap it so one overlong
+                    # result cannot break the batch, and so the preview (which
+                    # applies the same cap) stays faithful.
+                    new_name = new_name[:channel_name_max_len]
+
                     # Check if we already have a channel for this stream
                     existing_channel = existing_channel_map.get(stream.id)
 
@@ -2798,6 +2981,17 @@ def sync_auto_channels(account_id, scan_start_time=None):
                     f"{pack_result['failed']} failed"
                 )
 
+            # Release per-group working sets before the next group iteration.
+            del (
+                current_streams,
+                logo_cache_by_url,
+                epg_cache_by_tvg_id,
+                existing_channel_map,
+                existing_channels_by_id,
+                existing_channel_streams,
+                processed_stream_ids,
+            )
+
         # Cleanup mode read from account.custom_properties.orphan_channel_cleanup:
         # "always" (default; key absent) removes every orphan auto channel;
         # "preserve_customized" keeps those with a ChannelOverride row;
@@ -2833,7 +3027,7 @@ def sync_auto_channels(account_id, scan_start_time=None):
             f"{channels_created} created, {channels_updated} updated, "
             f"{channels_deleted} deleted, {channels_failed} failed"
         )
-        return {
+        result = {
             "status": "ok",
             "channels_created": channels_created,
             "channels_updated": channels_updated,
@@ -2841,6 +3035,9 @@ def sync_auto_channels(account_id, scan_start_time=None):
             "channels_failed": channels_failed,
             "failed_stream_details": failed_stream_details,
         }
+        del failed_stream_details
+        gc.collect()
+        return result
 
     except Exception as e:
         logger.error(f"Error in auto channel sync for account {account_id}: {str(e)}")
@@ -3194,7 +3391,6 @@ def refresh_single_m3u_account(account_id):
             notify_error=True,
             ws_error=str(e)[:500],
         )
-        raise
     finally:
         _ensure_m3u_refresh_terminal_status(account_id)
         _release_task_db_connection()
@@ -3209,6 +3405,8 @@ def _refresh_single_m3u_account_impl(account_id):
     start_time = time.time()  # For tracking elapsed time as float
     streams_created = 0
     streams_updated = 0
+    streams_unchanged = 0
+    streams_stale = 0
     streams_deleted = 0
 
     try:
@@ -3225,7 +3423,15 @@ def _refresh_single_m3u_account_impl(account_id):
         )
         account = _get_active_m3u_account(account_id)
 
-        filters = list(account.filters.all())
+        compiled_stream_filters = _compile_m3u_stream_filters(
+            account.filters.order_by("order")
+        )
+        if compiled_stream_filters:
+            logger.debug(
+                "Account %s has %s stream filter(s) for this refresh",
+                account_id,
+                len(compiled_stream_filters),
+            )
 
         # Check if VOD is enabled for this account
         vod_enabled = ensure_custom_properties_dict(account.custom_properties).get(
@@ -3382,6 +3588,7 @@ def _refresh_single_m3u_account_impl(account_id):
         # Initialize stream counters
         streams_created = 0
         streams_updated = 0
+        streams_unchanged = 0
 
         if account.account_type == M3UAccount.Types.STADNARD:
             logger.debug(
@@ -3402,7 +3609,14 @@ def _refresh_single_m3u_account_impl(account_id):
             with ThreadPoolExecutor(max_workers=max_workers) as executor:
                 # Submit batch processing tasks using direct functions (now thread-safe)
                 future_to_batch = {
-                    executor.submit(process_m3u_batch_direct, account_id, batch, existing_groups, hash_keys): i
+                    executor.submit(
+                        process_m3u_batch_direct,
+                        account_id,
+                        batch,
+                        existing_groups,
+                        hash_keys,
+                        compiled_stream_filters,
+                    ): i
                     for i, batch in enumerate(batches)
                 }
 
@@ -3417,17 +3631,13 @@ def _refresh_single_m3u_account_impl(account_id):
                         completed_batches += 1
 
                         # Extract stream counts from result
-                        if isinstance(result, str):
-                            try:
-                                created_match = re.search(r"(\d+) created", result)
-                                updated_match = re.search(r"(\d+) updated", result)
-                                if created_match and updated_match:
-                                    created_count = int(created_match.group(1))
-                                    updated_count = int(updated_match.group(1))
-                                    streams_created += created_count
-                                    streams_updated += updated_count
-                            except (AttributeError, ValueError):
-                                pass
+                        created_count, updated_count, unchanged_count = (
+                            _parse_batch_stream_counts(result)
+                        )
+                        if created_count or updated_count or unchanged_count:
+                            streams_created += created_count
+                            streams_updated += updated_count
+                            streams_unchanged += unchanged_count
 
                         # Send progress update
                         progress = int((completed_batches / total_batches) * 100)
@@ -3445,7 +3655,7 @@ def _refresh_single_m3u_account_impl(account_id):
                             progress,
                             elapsed_time=current_elapsed,
                             time_remaining=time_remaining,
-                            streams_processed=streams_created + streams_updated,
+                            streams_processed=streams_created + streams_updated + streams_unchanged,
                         )
 
                         logger.debug(f"Thread batch {completed_batches}/{total_batches} completed")
@@ -3457,6 +3667,10 @@ def _refresh_single_m3u_account_impl(account_id):
                         batches[batch_idx] = None
 
             logger.info(f"Thread-based processing completed for account {account_id}")
+
+            # Parsed catalog is no longer needed; drop before stale cleanup / auto-sync.
+            del extinf_data, batches
+            gc.collect()
         else:
             # For XC accounts, get the groups with their custom properties containing xc_id
             logger.debug(f"Processing XC account with groups: {existing_groups}")
@@ -3494,6 +3708,8 @@ def _refresh_single_m3u_account_impl(account_id):
             logger.info("Fetching all XC streams from provider and filtering by enabled categories...")
             all_xc_streams = collect_xc_streams(account_id, filtered_groups)
 
+            del channel_group_relationships, filtered_groups
+
             if not all_xc_streams:
                 # collect_xc_streams() returns an empty list when the provider
                 # returned no live streams, the fetch raised, or no enabled
@@ -3537,7 +3753,14 @@ def _refresh_single_m3u_account_impl(account_id):
                 with ThreadPoolExecutor(max_workers=max_workers) as executor:
                     # Submit stream batch processing tasks (reuse standard M3U processing)
                     future_to_batch = {
-                        executor.submit(process_m3u_batch_direct, account_id, batch, existing_groups, hash_keys): i
+                        executor.submit(
+                            process_m3u_batch_direct,
+                            account_id,
+                            batch,
+                            existing_groups,
+                            hash_keys,
+                            compiled_stream_filters,
+                        ): i
                         for i, batch in enumerate(batches)
                     }
 
@@ -3552,17 +3775,13 @@ def _refresh_single_m3u_account_impl(account_id):
                             completed_batches += 1
 
                             # Extract stream counts from result
-                            if isinstance(result, str):
-                                try:
-                                    created_match = re.search(r"(\d+) created", result)
-                                    updated_match = re.search(r"(\d+) updated", result)
-                                    if created_match and updated_match:
-                                        created_count = int(created_match.group(1))
-                                        updated_count = int(updated_match.group(1))
-                                        streams_created += created_count
-                                        streams_updated += updated_count
-                                except (AttributeError, ValueError):
-                                    pass
+                            created_count, updated_count, unchanged_count = (
+                                _parse_batch_stream_counts(result)
+                            )
+                            if created_count or updated_count or unchanged_count:
+                                streams_created += created_count
+                                streams_updated += updated_count
+                                streams_unchanged += unchanged_count
 
                             # Send progress update
                             progress = int((completed_batches / total_batches) * 100)
@@ -3580,7 +3799,7 @@ def _refresh_single_m3u_account_impl(account_id):
                                 progress,
                                 elapsed_time=current_elapsed,
                                 time_remaining=time_remaining,
-                                streams_processed=streams_created + streams_updated,
+                                streams_processed=streams_created + streams_updated + streams_unchanged,
                             )
 
                             logger.debug(f"XC thread batch {completed_batches}/{total_batches} completed")
@@ -3593,6 +3812,9 @@ def _refresh_single_m3u_account_impl(account_id):
 
                 logger.info(f"XC thread-based processing completed for account {account_id}")
 
+                del batches
+                gc.collect()
+
         # Ensure all database transactions are committed before cleanup
         logger.info(
             f"All thread processing completed, ensuring DB transactions are committed before cleanup"
@@ -3603,11 +3825,11 @@ def _refresh_single_m3u_account_impl(account_id):
         ).exists()  # This will never find anything but ensures DB sync
 
         # Mark streams that weren't seen in this refresh as stale (pending deletion)
-        stale_stream_count = Stream.objects.filter(
+        streams_stale = Stream.objects.filter(
             m3u_account=account,
             last_seen__lt=refresh_start_timestamp
         ).update(is_stale=True)
-        logger.info(f"Marked {stale_stream_count} streams as stale for account {account_id}")
+        logger.info(f"Marked {streams_stale} streams as stale for account {account_id}")
 
         # Mark group relationships that weren't seen in this refresh as stale (pending deletion)
         stale_group_count = ChannelGroupM3UAccount.objects.filter(
@@ -3657,17 +3879,24 @@ def _refresh_single_m3u_account_impl(account_id):
                 f"Error running auto channel sync for account {account_id}: {str(e)}"
             )
 
+        try:
+            rollup_channel_catchup_fields(account_id)
+            logger.debug(f"Catch-up field rollup complete for account {account_id}")
+        except Exception as e:
+            logger.error(f"Error rolling up catch-up fields for account {account_id}: {str(e)}")
+
         # Calculate elapsed time
         elapsed_time = time.time() - start_time
 
         # Calculate total streams processed
-        streams_processed = streams_created + streams_updated
+        streams_processed = streams_created + streams_updated + streams_unchanged
 
         # Set status to success and update timestamp BEFORE sending the final update
         account.status = M3UAccount.Status.SUCCESS
         account.last_message = (
             f"Processing completed in {elapsed_time:.1f} seconds. "
-            f"Streams: {streams_created} created, {streams_updated} updated, {streams_deleted} removed. "
+            f"Streams: {streams_created} created, {streams_updated} updated, "
+            f"{streams_stale} marked stale, {streams_deleted} removed. "
             f"Total processed: {streams_processed}.{auto_sync_message}"
         )
         account.updated_at = timezone.now()
@@ -3680,6 +3909,7 @@ def _refresh_single_m3u_account_impl(account_id):
             elapsed_time=round(elapsed_time, 2),
             streams_created=streams_created,
             streams_updated=streams_updated,
+            streams_stale=streams_stale,
             streams_deleted=streams_deleted,
             total_processed=streams_processed,
         )
@@ -3695,6 +3925,7 @@ def _refresh_single_m3u_account_impl(account_id):
             streams_processed=streams_processed,
             streams_created=streams_created,
             streams_updated=streams_updated,
+            streams_stale=streams_stale,
             streams_deleted=streams_deleted,
             # Structured auto-sync counts so the frontend can render a
             # warning card when anything failed, without parsing the
@@ -3707,6 +3938,9 @@ def _refresh_single_m3u_account_impl(account_id):
             message=account.last_message,
         )
 
+        del auto_sync_result
+        gc.collect()
+
         # Trigger VOD refresh if enabled and account is XtreamCodes type
         if vod_enabled and account.account_type == M3UAccount.Types.XC:
             logger.info(f"VOD is enabled for account {account_id}, triggering VOD refresh")
@@ -3738,6 +3972,10 @@ def _refresh_single_m3u_account_impl(account_id):
             del filtered_groups
         if 'channel_group_relationships' in locals():
             del channel_group_relationships
+        if 'compiled_stream_filters' in locals():
+            del compiled_stream_filters
+
+        gc.collect()
 
         # Remove cache file after processing (success or failure)
         cache_path = os.path.join(m3u_dir, f"{account_id}.json")
@@ -3746,8 +3984,6 @@ 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_memory_cleanup.py b/apps/m3u/tests/test_memory_cleanup.py
index bfc964d0..b29ca947 100644
--- a/apps/m3u/tests/test_memory_cleanup.py
+++ b/apps/m3u/tests/test_memory_cleanup.py
@@ -30,7 +30,7 @@ class ProcessM3UBatchCleanupTests(SimpleTestCase):
         mock_stream_cls.generate_hash_key = MagicMock(return_value="hash123")
 
         with patch("django.db.connections") as mock_connections:
-            process_m3u_batch_direct(1, [], {}, ["name", "url"])
+            process_m3u_batch_direct(1, [], {}, ["name", "url"], compiled_filters=[])
             mock_connections.close_all.assert_called()
 
     @patch("apps.m3u.tasks.Stream")
@@ -48,9 +48,29 @@ class ProcessM3UBatchCleanupTests(SimpleTestCase):
         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"])
+            process_m3u_batch_direct(1, [], {}, ["name", "url"], compiled_filters=[])
             mock_gc.assert_called()
 
+    @patch("apps.m3u.tasks.Stream")
+    @patch("apps.m3u.tasks.M3UAccount")
+    def test_precompiled_empty_filters_skip_db_lookup(
+        self, mock_account_cls, mock_stream_cls,
+    ):
+        """When filters are precompiled as empty, batch workers must not query filters."""
+        from apps.m3u.tasks import process_m3u_batch_direct
+
+        mock_account = MagicMock()
+        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("django.db.connections"):
+            process_m3u_batch_direct(1, [], {}, ["name", "url"], compiled_filters=[])
+
+        mock_account.filters.order_by.assert_not_called()
+
 
 class LockReleaseTests(SimpleTestCase):
     """Verify task lock is released on all exit paths."""
diff --git a/apps/m3u/tests/test_rename_preview_parity.py b/apps/m3u/tests/test_rename_preview_parity.py
new file mode 100644
index 00000000..4650c50b
--- /dev/null
+++ b/apps/m3u/tests/test_rename_preview_parity.py
@@ -0,0 +1,212 @@
+"""
+Differential parity tests: the auto-sync rename preview must predict the exact
+name the live rename produces, across a broad matrix of regex strategies.
+
+Both the preview and the live rename compile with the third-party `regex`
+module (for its JS-aligned syntax and per-call timeout). They can only be
+trusted together if, for every find/replace a user might author, the preview's
+predicted `after` equals the channel name the sync actually writes.
+
+Each case is run end-to-end: real streams, the real sync_auto_channels rename,
+and the real regex-preview endpoint, compared per original stream name.
+"""
+from django.test import TestCase
+from django.utils import timezone
+
+from apps.channels.models import Channel, ChannelGroup, ChannelStream, Stream
+from apps.m3u.models import M3UAccount
+from apps.m3u.tasks import sync_auto_channels
+
+
+# Diverse names: distinct word-prefixes (collision-resistant), with quality
+# tags, brackets, pipes, ampersands, extra whitespace, underscores, dots, CJK,
+# and emoji, to exercise anchors, classes, boundaries, and Unicode handling.
+NAMES = [
+    "Alpha Channel 11",
+    "Bravo Sports HD",
+    "Charlie News FHD",
+    "Delta Movie (2024)",
+    "Echo [UK] 4K",
+    "Foxtrot   spaced",
+    "Golf|Pipe|Name",
+    "Hotel & Inn <x>",
+    "India 日本語 77",
+    "Juliet 📺 88",
+    "Kilo_under_9",
+    "Lima.dot.name",
+]
+
+# (find, replace) pairs spanning common user strategies and edge cases.
+STRATEGIES = [
+    # --- capture groups ---
+    (r"(.+) Channel (\d+)", r"$1 #$2"),
+    (r"(\w+) (\w+)", r"$2 $1"),
+    (r"(.+)", r"$1 - $1"),
+    (r"(.+)", r"[$1]"),
+    (r"(.+) (\d+)$", r"$2 $1"),
+    # --- strip / delete ---
+    (r" (HD|FHD|4K|SD)\b", r""),
+    (r"\s+", r" "),
+    (r"[\[\(].*?[\]\)]", r""),
+    (r"\d+", r""),
+    (r"[_.]", r" "),
+    # --- anchors / inserts ---
+    (r"^", r"NEW "),
+    (r"$", r" LIVE"),
+    (r"^(\w+)", r"<$1>"),
+    # --- char classes / Unicode (divergence hunters) ---
+    (r"\w+", r"W"),
+    (r"\b\w", r"_"),
+    (r"[A-Z]", r"*"),
+    (r"\s", r"_"),
+    (r"[^\x00-\x7F]+", r"?"),
+    # --- non-capturing / lookaround / in-pattern backref ---
+    (r"(?:Channel|Movie|News) ", r""),
+    (r"(\w)\1", r"$1"),
+    (r"\w+(?= )", r"X"),
+    (r"(?<=\d)\d", r"#"),
+    # --- literal $ and odd replacements ---
+    (r" ", r" $ "),
+    (r"o", r"0"),
+    # --- invalid group references (rejected by both engines) ---
+    (r"(.+)", r"$2"),
+    (r"(.+)", r"$10"),
+    # --- rename that expands past Channel.name's column length ---
+    (r"(.+)", r"$1" * 40),
+    # --- regex-module syntax: quantified anchor, JS-style and duplicate
+    #     named groups (these transform; both paths use the regex module) ---
+    (r"^*", r"$"),
+    (r"(?<season>\d+)", r"S$1"),
+    (r"(?P<n>x)(?P<n>y)", r"z"),
+]
+
+
+class RenamePreviewParityTests(TestCase):
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        from rest_framework.test import APIClient
+        from apps.accounts.models import User
+
+        admin = User.objects.create_superuser(
+            username="admin_rename_parity", password="pw", user_level=10
+        )
+        cls.client_api = APIClient()
+        cls.client_api.force_authenticate(user=admin)
+        cls.account = M3UAccount.objects.create(
+            name="Rename Parity Provider",
+            server_url="http://example.com/test.m3u",
+        )
+
+    def _sync(self):
+        return sync_auto_channels(
+            self.account.id,
+            scan_start_time=(
+                timezone.now() - timezone.timedelta(minutes=1)
+            ).isoformat(),
+        )
+
+    def _run_case(self, group_name, find, replace):
+        """Returns a list of human-readable mismatch strings (empty == parity)."""
+        group = ChannelGroup.objects.create(name=group_name)
+        from apps.channels.models import ChannelGroupM3UAccount
+
+        ChannelGroupM3UAccount.objects.create(
+            m3u_account=self.account,
+            channel_group=group,
+            enabled=True,
+            auto_channel_sync=True,
+            auto_sync_channel_start=1000,
+            custom_properties={
+                "name_regex_pattern": find,
+                "name_replace_pattern": replace,
+            },
+        )
+        for i, name in enumerate(NAMES):
+            Stream.objects.create(
+                name=name,
+                url=f"http://example.com/{group_name}_{i}.m3u8",
+                m3u_account=self.account,
+                channel_group=group,
+                tvg_id=f"{group_name}-{i}",
+                last_seen=timezone.now(),
+            )
+
+        # --- live rename via sync ---
+        result = self._sync()
+        if result.get("status") != "ok":
+            return [f"[{find!r} -> {replace!r}] sync status={result.get('status')}"]
+
+        channels = Channel.objects.filter(
+            auto_created_by=self.account, channel_group=group
+        )
+        cs_rows = ChannelStream.objects.filter(
+            channel__in=channels
+        ).select_related("channel", "stream")
+        sync_map = {row.stream.name: row.channel.name for row in cs_rows}
+
+        # --- preview endpoint ---
+        response = self.client_api.get(
+            "/api/channels/streams/regex-preview/",
+            {
+                "channel_group": group_name,
+                "find": find,
+                "replace": replace,
+                "limit": 50,
+            },
+        )
+        if response.status_code != 200:
+            return [f"[{find!r} -> {replace!r}] preview HTTP {response.status_code}"]
+        data = response.data
+        # When the preview reports find_error it predicts no rename at all.
+        preview_map = {name: name for name in NAMES}
+        if "find_error" not in data:
+            for m in data.get("find_matches", []):
+                preview_map[m["before"]] = m["after"]
+
+        mismatches = []
+        for name in NAMES:
+            sync_after = sync_map.get(name)
+            if sync_after is None:
+                mismatches.append(
+                    f"[{find!r} -> {replace!r}] {name!r}: no channel created"
+                )
+                continue
+            preview_after = preview_map[name]
+            if preview_after != sync_after:
+                mismatches.append(
+                    f"[{find!r} -> {replace!r}] {name!r}: "
+                    f"preview={preview_after!r} sync={sync_after!r} "
+                    f"(find_error={data.get('find_error')!r})"
+                )
+        return mismatches
+
+    def test_preview_predicts_rename_across_strategies(self):
+        all_mismatches = []
+        for idx, (find, replace) in enumerate(STRATEGIES):
+            all_mismatches.extend(
+                self._run_case(f"ParityG{idx}", find, replace)
+            )
+        self.assertEqual(
+            all_mismatches,
+            [],
+            "Preview diverged from the live rename:\n"
+            + "\n".join(all_mismatches),
+        )
+
+    def test_overlong_rename_is_bounded_not_aborting_sync(self):
+        # A rename that expands past Channel.name's column length must not
+        # abort the bulk_create sync. Both sync and preview cap at the column
+        # length so the channel is created (truncated) and the preview shows
+        # the same bounded name.
+        max_len = Channel._meta.get_field("name").max_length
+        mismatches = self._run_case("OverlongG", r"(.+)", "$1" * 40)
+        self.assertEqual(mismatches, [], "\n".join(mismatches))
+
+        group = ChannelGroup.objects.get(name="OverlongG")
+        channels = Channel.objects.filter(
+            auto_created_by=self.account, channel_group=group
+        )
+        self.assertEqual(channels.count(), len(NAMES))
+        self.assertTrue(all(len(c.name) <= max_len for c in channels))
+        self.assertTrue(any(len(c.name) == max_len for c in channels))
diff --git a/apps/m3u/tests/test_stream_filters.py b/apps/m3u/tests/test_stream_filters.py
new file mode 100644
index 00000000..aba1a262
--- /dev/null
+++ b/apps/m3u/tests/test_stream_filters.py
@@ -0,0 +1,156 @@
+"""Tests for M3U stream filter compilation and batch application."""
+from unittest.mock import MagicMock, patch
+
+from django.test import SimpleTestCase
+
+from apps.m3u.tasks import (
+    _compile_m3u_stream_filters,
+    _stream_passes_m3u_filters,
+    process_m3u_batch_direct,
+)
+
+
+class CompileM3UStreamFiltersTests(SimpleTestCase):
+    def test_compiles_case_insensitive_when_configured(self):
+        filter_obj = MagicMock()
+        filter_obj.regex_pattern = "news"
+        filter_obj.custom_properties = {"case_sensitive": False}
+
+        compiled = _compile_m3u_stream_filters([filter_obj])
+
+        self.assertEqual(len(compiled), 1)
+        pattern, _ = compiled[0]
+        self.assertTrue(pattern.search("NEWS"))
+
+    def test_compiles_case_sensitive_by_default(self):
+        filter_obj = MagicMock()
+        filter_obj.regex_pattern = "news"
+        filter_obj.custom_properties = {}
+
+        compiled = _compile_m3u_stream_filters([filter_obj])
+
+        pattern, _ = compiled[0]
+        self.assertIsNone(pattern.search("NEWS"))
+        self.assertTrue(pattern.search("news"))
+
+
+class StreamPassesM3UFiltersTests(SimpleTestCase):
+    def _compiled(self, *, filter_type="name", exclude=False, pattern="Adult"):
+        filter_obj = MagicMock()
+        filter_obj.filter_type = filter_type
+        filter_obj.exclude = exclude
+        filter_obj.regex_pattern = pattern
+        filter_obj.custom_properties = {}
+        return _compile_m3u_stream_filters([filter_obj])
+
+    def test_include_filter_passes_matching_stream(self):
+        compiled = self._compiled(exclude=False)
+        self.assertTrue(
+            _stream_passes_m3u_filters("Adult Channel", "http://x", "News", compiled)
+        )
+
+    def test_include_filter_passes_non_matching_stream(self):
+        """Non-matching streams still pass unless a matching exclude filter hits."""
+        compiled = self._compiled(exclude=False, pattern="news")
+        self.assertTrue(
+            _stream_passes_m3u_filters("Sports", "http://x", "Sports", compiled)
+        )
+
+    def test_exclude_filter_rejects_matching_stream(self):
+        compiled = self._compiled(exclude=True, pattern="Adult")
+        self.assertFalse(
+            _stream_passes_m3u_filters("Adult Channel", "http://x", "News", compiled)
+        )
+
+    def test_url_filter_type_targets_url(self):
+        compiled = self._compiled(filter_type="url", exclude=True, pattern="blocked")
+        self.assertFalse(
+            _stream_passes_m3u_filters("OK", "http://blocked.example/live", "News", compiled)
+        )
+        self.assertTrue(
+            _stream_passes_m3u_filters("blocked name", "http://ok.example/live", "News", compiled)
+        )
+
+    def test_group_filter_type_targets_group(self):
+        compiled = self._compiled(filter_type="group", exclude=True, pattern="Hidden")
+        self.assertFalse(
+            _stream_passes_m3u_filters("Channel", "http://x", "Hidden Group", compiled)
+        )
+
+
+class ProcessM3UBatchFilterTests(SimpleTestCase):
+    def _mock_stream_meta(self, mock_stream_cls, max_length=255):
+        mock_field = MagicMock()
+        mock_field.max_length = max_length
+        mock_stream_cls._meta.get_field.return_value = mock_field
+
+    @patch("apps.m3u.tasks._bulk_update_stream_refresh_batches")
+    @patch("apps.m3u.tasks.Stream")
+    @patch("apps.m3u.tasks.M3UAccount")
+    def test_exclude_filter_skips_stream_import(
+        self, mock_account_cls, mock_stream_cls, mock_bulk_update,
+    ):
+        self._mock_stream_meta(mock_stream_cls)
+        mock_account = MagicMock()
+        mock_account.account_type = "STD"
+        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")
+
+        filter_obj = MagicMock()
+        filter_obj.regex_pattern = "skip-me"
+        filter_obj.filter_type = "name"
+        filter_obj.exclude = True
+        filter_obj.custom_properties = {}
+        compiled = _compile_m3u_stream_filters([filter_obj])
+
+        batch = [{
+            "name": "skip-me channel",
+            "url": "http://example/live",
+            "attributes": {"group-title": "News"},
+            "vlc_opts": {},
+        }]
+
+        with patch("django.db.connections"):
+            result = process_m3u_batch_direct(
+                1, batch, {"News": 1}, ["name", "url"], compiled_filters=compiled,
+            )
+
+        self.assertIn("0 created", result)
+        mock_stream_cls.objects.bulk_create.assert_not_called()
+        mock_bulk_update.assert_called_once_with([], [], batch_size=200)
+
+    @patch("apps.m3u.tasks._bulk_update_stream_refresh_batches")
+    @patch("apps.m3u.tasks.Stream")
+    @patch("apps.m3u.tasks.M3UAccount")
+    def test_no_filters_imports_matching_stream(
+        self, mock_account_cls, mock_stream_cls, mock_bulk_update,
+    ):
+        self._mock_stream_meta(mock_stream_cls)
+        mock_account = MagicMock()
+        mock_account.account_type = "STD"
+        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")
+        mock_stream_cls.objects.bulk_create.return_value = []
+
+        batch = [{
+            "name": "News One",
+            "url": "http://example/live",
+            "attributes": {"group-title": "News"},
+            "vlc_opts": {},
+        }]
+
+        with patch("django.db.connections"), patch(
+            "apps.m3u.tasks.transaction.atomic",
+        ):
+            result = process_m3u_batch_direct(
+                1, batch, {"News": 1}, ["name", "url"], compiled_filters=[],
+            )
+
+        self.assertIn("1 created", result)
+        mock_stream_cls.objects.bulk_create.assert_called_once()
diff --git a/apps/m3u/tests/test_sync_correctness.py b/apps/m3u/tests/test_sync_correctness.py
index 3cc24942..75bc5d03 100644
--- a/apps/m3u/tests/test_sync_correctness.py
+++ b/apps/m3u/tests/test_sync_correctness.py
@@ -644,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
@@ -735,6 +763,128 @@ class RegexPreviewTests(TestCase):
         self.assertEqual(response.data["total_scanned"], 3)
         self.assertFalse(response.data["scan_limit_hit"])
 
+    def test_find_replace_applies_numbered_capture_group(self):
+        # The replace field accepts JS-style $1 backreferences, but the regex
+        # engine expects \1. Without the conversion the preview echoes the
+        # literal "$1", so the previewed "after" disagrees with the name the
+        # live rename produces.
+        account = self._make_account()
+        group = _make_group(name="Sports")
+        Stream.objects.create(
+            name="High Limit Racing at Eagle @ Jun 9 7:00 PM",
+            url="http://example.com/hlr.m3u8",
+            m3u_account=account,
+            channel_group=group,
+            last_seen=timezone.now(),
+        )
+        client = self._client()
+
+        response = client.get(
+            "/api/channels/streams/regex-preview/",
+            {"channel_group": "Sports", "find": r"(.+) @.*", "replace": "$1"},
+        )
+
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.data["find_match_count"], 1)
+        after = response.data["find_matches"][0]["after"]
+        self.assertEqual(after, "High Limit Racing at Eagle")
+        self.assertNotIn("$1", after)
+
+    def test_preview_after_matches_live_sync_rename(self):
+        # Guards the defect class: the preview and the live rename are
+        # separate code paths that must convert the replacement identically,
+        # so the preview can never promise an output the sync would not yield.
+        name = "High Limit Racing at Eagle @ Jun 9 7:00 PM"
+        account = self._make_account()
+        group = _make_group(name="Racing")
+        _attach_group_to_account(
+            account,
+            group,
+            custom_properties={
+                "name_regex_pattern": r"(.+) @.*",
+                "name_replace_pattern": "$1",
+            },
+        )
+        _make_stream(account, group, name=name, tvg_id="hlr")
+
+        result = _sync(account)
+        self.assertEqual(result.get("status"), "ok")
+        channel = Channel.objects.get(auto_created=True, auto_created_by=account)
+        live_name = channel.name
+
+        client = self._client()
+        response = client.get(
+            "/api/channels/streams/regex-preview/",
+            {"channel_group": "Racing", "find": r"(.+) @.*", "replace": "$1"},
+        )
+
+        self.assertEqual(response.status_code, 200)
+        preview_after = response.data["find_matches"][0]["after"]
+        self.assertEqual(preview_after, live_name)
+        self.assertEqual(preview_after, "High Limit Racing at Eagle")
+
+    def test_regex_engine_pattern_transforms_in_preview(self):
+        # Both the preview and the live rename use the regex module, which is
+        # more permissive than stdlib re and matches the JS-style syntax the UI
+        # authors. A quantified anchor like "^*" (which stdlib re rejects)
+        # compiles and transforms rather than reporting an error.
+        account = self._make_account()
+        group = _make_group(name="Sports")
+        Stream.objects.create(
+            name="Doc95",
+            url="http://example.com/doc95.m3u8",
+            m3u_account=account,
+            channel_group=group,
+            last_seen=timezone.now(),
+        )
+        client = self._client()
+
+        response = client.get(
+            "/api/channels/streams/regex-preview/",
+            {"channel_group": "Sports", "find": "^*", "replace": "$"},
+        )
+
+        self.assertEqual(response.status_code, 200)
+        self.assertNotIn("find_error", response.data)
+        self.assertEqual(response.data["find_match_count"], 1)
+        # ^* matches the empty string at every position, so the literal $
+        # replacement is inserted between characters.
+        self.assertEqual(
+            response.data["find_matches"][0]["after"], "$D$o$c$9$5$"
+        )
+
+    def test_preview_and_sync_agree_on_regex_only_pattern(self):
+        # Parity guard for the engine alignment: a pattern valid in regex but
+        # not stdlib re must transform identically in the sync and the preview,
+        # rather than diverging (the sync no longer silently keeps the
+        # original name for these patterns).
+        name = "Doc95"
+        account = self._make_account()
+        group = _make_group(name="Docs")
+        _attach_group_to_account(
+            account,
+            group,
+            custom_properties={
+                "name_regex_pattern": "^*",
+                "name_replace_pattern": "$",
+            },
+        )
+        _make_stream(account, group, name=name, tvg_id="doc95")
+
+        result = _sync(account)
+        self.assertEqual(result.get("status"), "ok")
+        channel = Channel.objects.get(auto_created=True, auto_created_by=account)
+        live_name = channel.name
+        self.assertNotEqual(live_name, name)
+
+        client = self._client()
+        response = client.get(
+            "/api/channels/streams/regex-preview/",
+            {"channel_group": "Docs", "find": "^*", "replace": "$"},
+        )
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(response.data["find_matches"][0]["after"], live_name)
+
     def test_filter_returns_matched_names_with_count(self):
         account = self._make_account()
         group = _make_group(name="Sports")
diff --git a/apps/m3u/utils.py b/apps/m3u/utils.py
index 598ef713..dbf8d91a 100644
--- a/apps/m3u/utils.py
+++ b/apps/m3u/utils.py
@@ -1,4 +1,5 @@
 # apps/m3u/utils.py
+import regex
 import threading
 import logging
 from django.db import models
@@ -9,6 +10,18 @@ active_streams_map = {}
 logger = logging.getLogger(__name__)
 
 
+def convert_js_numbered_backreferences(replacement):
+    """Translate JS-style ``$1``/``$2`` backreferences to Python ``\\1``/``\\2``.
+
+    Auto-sync replace patterns are authored in JS regex syntax, but Python's
+    regex engines honor backslash backreferences, not ``$1``. The live rename
+    and the UI preview must convert identically, so both call this single
+    helper and cannot drift apart (otherwise the preview promises an output
+    the sync would never produce).
+    """
+    return regex.sub(r"\$(\d+)", r"\\\1", replacement)
+
+
 def normalize_stream_url(url):
     """
     Normalize stream URLs for compatibility with FFmpeg.
diff --git a/apps/output/epg.py b/apps/output/epg.py
new file mode 100644
index 00000000..d34d209e
--- /dev/null
+++ b/apps/output/epg.py
@@ -0,0 +1,1732 @@
+"""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, *, xc_catchup_prev_days=False):
+    """
+    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
+    if xc_catchup_prev_days:
+        from apps.channels.utils import resolve_xc_epg_prev_days
+
+        prev_days = resolve_xc_epg_prev_days(request, user)
+    else:
+        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..25a38d18 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,689 @@ 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)
+
+
+class GenerateEpgPrevDaysTests(SimpleTestCase):
+    """Profile EPG keeps legacy prev_days=0 unless URL or user setting says otherwise."""
+
+    def setUp(self):
+        self.factory = RequestFactory()
+
+    @patch("apps.output.epg.stream_cached_response")
+    @patch("apps.output.epg.Channel.objects")
+    def test_non_xc_epg_defaults_prev_days_to_zero(self, _channels, mock_cache):
+        from apps.output.epg import generate_epg
+
+        mock_cache.side_effect = lambda cache_key, _source, **_kwargs: cache_key
+        request = self.factory.get("/epg/")
+
+        cache_key = generate_epg(request, profile_name="test", user=None)
+
+        self.assertIn(":p=0:", cache_key)
diff --git a/apps/output/views.py b/apps/output/views.py
index dba35951..a7e34c31 100644
--- a/apps/output/views.py
+++ b/apps/output/views.py
@@ -11,10 +11,9 @@ from apps.accounts.models import User
 from dispatcharr.utils import network_access_allowed
 from django.utils import timezone as django_timezone
 from django.shortcuts import get_object_or_404
-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, timezone as dt_timezone
 import html
 import time
-from tzlocal import get_localzone
 from urllib.parse import urlencode
 import base64
 import logging
@@ -23,11 +22,14 @@ import os
 from apps.m3u.utils import calculate_tuner_count
 from apps.proxy.utils import get_user_active_connections
 import regex
+from core.models import CoreSettings
 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,1663 +340,6 @@ def generate_m3u(request, profile_name=None, user=None):
     return response
 
 
-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):
-    """
-    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")
-            .prefetch_related(
-                Prefetch('streams', queryset=Stream.objects.order_by('channelstream__order'))
-            )
-        )
-
-        # 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_epg_ids_for_program_check = set()
-
-        # 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':
-                if channel.effective_epg_data_id:
-                    dummy_epg_ids_for_program_check.add(channel.effective_epg_data_id)
-                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}"
-            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
-
-        dummy_epg_with_programs = set()
-        if dummy_epg_ids_for_program_check:
-            dummy_epg_with_programs = set(
-                ProgramData.objects.filter(epg_id__in=dummy_epg_ids_for_program_check)
-                .values_list('epg_id', flat=True)
-                .distinct()
-            )
-
-        # 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, ...]
-
-        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
-                    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))
-            else:
-                if effective_epg_data.epg_source and effective_epg_data.epg_source.source_type == 'dummy':
-                    if effective_epg_data_id in dummy_epg_with_programs:
-                        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")
@@ -2023,6 +368,24 @@ def _xc_allowed_output_formats(user):
     return ['ts', 'mp4']
 
 
+def _build_xc_server_info(request, hostname, port):
+    """Build XC ``server_info``; keep timezone, ``time_now``, and EPG times in UTC.
+
+    XC clients use ``server_info.timezone`` to interpret EPG start/end strings.
+    Provider-local conversion happens in the timeshift proxy at request time.
+    """
+    # datetime.timezone.utc, not ZoneInfo("UTC"); avoids mis-set Docker /etc/timezone.
+    return {
+        "url": hostname,
+        "server_protocol": request.scheme,
+        "port": port,
+        "timezone": "UTC",
+        "timestamp_now": int(time.time()),
+        "time_now": datetime.now(dt_timezone.utc).strftime("%Y-%m-%d %H:%M:%S"),
+        "process": True,
+    }
+
+
 def xc_get_info(request, full=False):
     user = xc_get_user(request)
 
@@ -2055,15 +418,7 @@ def xc_get_info(request, full=False):
             "max_connections": str(max_connections),
             "allowed_output_formats": _xc_allowed_output_formats(user),
         },
-        "server_info": {
-            "url": hostname,
-            "server_protocol": request.scheme,
-            "port": port,
-            "timezone": get_localzone().key,
-            "timestamp_now": int(time.time()),
-            "time_now": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-            "process": True,
-        },
+        "server_info": _build_xc_server_info(request, hostname, port),
     }
 
     if full == True:
@@ -2189,7 +544,7 @@ def xc_xmltv(request):
         )
         return JsonResponse({'error': 'Unauthorized'}, status=401)
 
-    return generate_epg(request, None, user)
+    return generate_epg(request, None, user, xc_catchup_prev_days=True)
 
 
 def xc_get_live_categories(user):
@@ -2338,6 +693,14 @@ def _xc_channel_entry(channel, channel_num_map, _get_default_group_id, _logo_url
     effective_logo = channel.effective_logo_obj
     effective_group = channel.effective_channel_group_obj
     group_id = effective_group.id if effective_group else _get_default_group_id()
+
+    if channel.is_catchup:
+        tv_archive = 1
+        tv_archive_duration = channel.catchup_days
+    else:
+        tv_archive = 0
+        tv_archive_duration = 0
+
     return {
         "num": channel_num_int,
         "name": channel.effective_name,
@@ -2352,10 +715,10 @@ def _xc_channel_entry(channel, channel_num_map, _get_default_group_id, _logo_url
         "is_adult": int(channel.is_adult),
         "category_id": str(group_id),
         "category_ids": [group_id],
-        "custom_sid": None,
-        "tv_archive": 0,
+        "custom_sid": "",
+        "tv_archive": tv_archive,
         "direct_source": "",
-        "tv_archive_duration": 0,
+        "tv_archive_duration": tv_archive_duration,
     }
 
 
@@ -2388,10 +751,12 @@ def xc_get_epg(request, user, short=False):
     if not channel_id:
         raise Http404()
 
+    try:
+        resolved_channel_id = int(channel_id)
+    except (TypeError, ValueError):
+        raise Http404()
+
     channel = None
-    # Apply effective-value annotation + hidden-exclusion at every channel
-    # resolution path so a single channel lookup honors the same visibility
-    # rules as xc_get_live_streams.
     def _annotate(qs):
         return with_effective_values(qs, select_related_fks=True).exclude(hidden_from_output=True)
 
@@ -2402,7 +767,7 @@ def xc_get_epg(request, user, short=False):
         if user_profile_count == 0:
             # No profile filtering - user sees all channels based on user_level
             filters = {
-                "id": channel_id,
+                "id": resolved_channel_id,
                 "user_level__lte": user.user_level
             }
             # Hide adult content if user preference is set
@@ -2412,7 +777,7 @@ def xc_get_epg(request, user, short=False):
         else:
             # User has specific limited profiles assigned
             filters = {
-                "id": channel_id,
+                "id": resolved_channel_id,
                 "channelprofilemembership__enabled": True,
                 "user_level__lte": user.user_level,
                 "channelprofilemembership__channel_profile__in": user.channel_profiles.all()
@@ -2425,7 +790,7 @@ def xc_get_epg(request, user, short=False):
         if not channel:
             raise Http404()
     else:
-        channel = _annotate(Channel.objects.filter(id=channel_id).select_related('epg_data__epg_source')).first()
+        channel = _annotate(Channel.objects.filter(id=resolved_channel_id).select_related('epg_data__epg_source')).first()
         if not channel:
             raise Http404()
 
@@ -2473,6 +838,8 @@ def xc_get_epg(request, user, short=False):
         int(channel.effective_channel_number) if channel.effective_channel_number is not None else 0,
     )
 
+    from apps.channels.utils import resolve_xc_epg_prev_days
+
     limit = int(request.GET.get('limit', 4))
     user_custom = user.custom_properties or {}
     try:
@@ -2480,12 +847,15 @@ def xc_get_epg(request, user, short=False):
         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
+    prev_days = resolve_xc_epg_prev_days(request, user, auto_detect_fallback=False)
     now = django_timezone.now()
+
+    # XC catch-up clients expect past programmes when prev_days was not set.
+    _channel_is_catchup = getattr(channel, "is_catchup", False)
+    _channel_catchup_days = min(getattr(channel, "catchup_days", 0) or 0, 30)
+    if _channel_is_catchup and prev_days == 0:
+        prev_days = _channel_catchup_days
+
     lookback_cutoff = now - timedelta(days=prev_days)
     forward_cutoff = now + timedelta(days=num_days) if num_days > 0 else None
     effective_epg_data = channel.effective_epg_data_obj
@@ -2531,6 +901,13 @@ def xc_get_epg(request, user, short=False):
 
     output = {"epg_listings": []}
 
+    if _channel_is_catchup:
+        archive_window = timedelta(days=_channel_catchup_days)
+    else:
+        archive_window = None
+
+    _epg_utc = dt_timezone.utc
+
     for program in programs:
         title = program['title'] if isinstance(program, dict) else program.title
         description = program['description'] if isinstance(program, dict) else program.description
@@ -2555,8 +932,8 @@ def xc_get_epg(request, user, short=False):
             "epg_id": epg_id,
             "title": base64.b64encode((title or "").encode()).decode(),
             "lang": "",
-            "start": start.strftime("%Y-%m-%d %H:%M:%S"),
-            "end": end.strftime("%Y-%m-%d %H:%M:%S"),
+            "start": start.astimezone(_epg_utc).strftime("%Y-%m-%d %H:%M:%S"),
+            "end": end.astimezone(_epg_utc).strftime("%Y-%m-%d %H:%M:%S"),
             "description": base64.b64encode((description or "").encode()).decode(),
             "channel_id": str(channel_num_int),
             "start_timestamp": str(int(start.timestamp())),
@@ -2564,15 +941,88 @@ def xc_get_epg(request, user, short=False):
             "stream_id": f"{channel_id}",
         }
 
-        if short == False:
-            program_output["now_playing"] = 1 if start <= django_timezone.now() <= end else 0
+        if archive_window is not None and end < now and end > now - archive_window:
+            program_output["has_archive"] = 1
+        else:
             program_output["has_archive"] = 0
 
+        if short == False:
+            program_output["now_playing"] = 1 if start <= now <= end else 0
+
         output['epg_listings'].append(program_output)
 
     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
@@ -2598,33 +1048,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, "")
@@ -2633,44 +1069,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": "",
         })
@@ -2703,72 +1135,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/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/channel_status.py b/apps/proxy/live_proxy/channel_status.py
index 9bd1d284..300f3b0d 100644
--- a/apps/proxy/live_proxy/channel_status.py
+++ b/apps/proxy/live_proxy/channel_status.py
@@ -407,6 +407,20 @@ class ChannelStatus:
             if channel_name:
                 info['channel_name'] = channel_name
 
+            info['is_timeshift'] = bool(metadata.get(ChannelMetadataField.IS_TIMESHIFT))
+
+            for key, field in (
+                ('logo_id', ChannelMetadataField.LOGO_ID),
+                ('m3u_profile_id', ChannelMetadataField.M3U_PROFILE),
+            ):
+                raw = metadata.get(field)
+                if not raw:
+                    continue
+                try:
+                    info[key] = int(raw)
+                except (TypeError, ValueError):
+                    pass
+
             stream_id_bytes = metadata.get(ChannelMetadataField.STREAM_ID)
             if stream_id_bytes:
                 try:
diff --git a/apps/proxy/live_proxy/client_manager.py b/apps/proxy/live_proxy/client_manager.py
index ff031e5b..23f8e768 100644
--- a/apps/proxy/live_proxy/client_manager.py
+++ b/apps/proxy/live_proxy/client_manager.py
@@ -301,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})")
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/constants.py b/apps/proxy/live_proxy/constants.py
index b3839508..414e1a2f 100644
--- a/apps/proxy/live_proxy/constants.py
+++ b/apps/proxy/live_proxy/constants.py
@@ -54,6 +54,8 @@ class ChannelMetadataField:
     STREAM_ID = "stream_id"
     CHANNEL_NAME = "channel_name"
     STREAM_NAME = "stream_name"
+    IS_TIMESHIFT = "is_timeshift"
+    LOGO_ID = "logo_id"
 
     # Profile fields
     STREAM_PROFILE = "stream_profile"
diff --git a/apps/proxy/live_proxy/input/manager.py b/apps/proxy/live_proxy/input/manager.py
index 3c7c147d..8c76c1be 100644
--- a/apps/proxy/live_proxy/input/manager.py
+++ b/apps/proxy/live_proxy/input/manager.py
@@ -1420,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
@@ -1435,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:
@@ -1830,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/ts/generator.py b/apps/proxy/live_proxy/output/ts/generator.py
index 3524a2a6..88175fcd 100644
--- a/apps/proxy/live_proxy/output/ts/generator.py
+++ b/apps/proxy/live_proxy/output/ts/generator.py
@@ -159,8 +159,8 @@ class StreamGenerator:
                     return "client_gone"
 
         elapsed = time.time() - initialization_start
-        connection_timeout = getattr(Config, 'CONNECTION_TIMEOUT', 10)
-        if elapsed < connection_timeout or not proxy_server.redis_client:
+        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)
@@ -204,7 +204,7 @@ class StreamGenerator:
                 logger.warning(
                     f"[{self.client_id}] Channel {self.channel_id} stalled in connecting state "
                     f"with no buffer data after "
-                    f"{getattr(Config, 'CONNECTION_TIMEOUT', 10)}s, aborting init wait"
+                    f"{ConfigHelper.channel_init_grace_period()}s, aborting init wait"
                 )
                 yield create_ts_packet('error', "Error: Connection stalled")
                 return False
diff --git a/apps/proxy/live_proxy/server.py b/apps/proxy/live_proxy/server.py
index 8eca8572..08a029e3 100644
--- a/apps/proxy/live_proxy/server.py
+++ b/apps/proxy/live_proxy/server.py
@@ -789,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:
@@ -910,6 +910,26 @@ class ProxyServer:
         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
@@ -1758,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:
@@ -1799,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._coordinated_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._coordinated_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
@@ -2093,6 +2095,9 @@ class ProxyServer:
                     if not channel_id:
                         continue
 
+                    if channel_id.startswith("timeshift_"):
+                        continue
+
                     # Get metadata first
                     metadata = self.redis_client.hgetall(key)
                     if not metadata:
diff --git a/apps/proxy/live_proxy/services/channel_service.py b/apps/proxy/live_proxy/services/channel_service.py
index 7ad4e71b..e18e07af 100644
--- a/apps/proxy/live_proxy/services/channel_service.py
+++ b/apps/proxy/live_proxy/services/channel_service.py
@@ -192,6 +192,78 @@ class ChannelService:
             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):
         """
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/utils.py b/apps/proxy/utils.py
index 69ee15e4..fc157791 100644
--- a/apps/proxy/utils.py
+++ b/apps/proxy/utils.py
@@ -1,6 +1,7 @@
 import logging
 from core.utils import RedisClient
 from apps.proxy.vod_proxy.multi_worker_connection_manager import MultiWorkerVODConnectionManager, get_vod_client_stop_key
+from apps.proxy.live_proxy.redis_keys import RedisKeys
 from core.models import CoreSettings
 from apps.proxy.live_proxy.services.channel_service import ChannelService
 
@@ -61,6 +62,15 @@ def attempt_stream_termination(user_id, requesting_client_id, active_connections
                 result = ChannelService.stop_client(t['media_id'], t['client_id'])
                 if result.get("status") == "error":
                     logger.warning(f"[stream limits][{requesting_client_id}] Failed to stop client {t['client_id']} on channel {t['media_id']}")
+            elif t['type'] == 'timeshift':
+                # Same Redis stop key as live; timeshift generator polls it every 5s.
+                redis_client = RedisClient.get_client()
+                if not redis_client:
+                    # Deny the new stream if we cannot stop the old one.
+                    return False
+                stop_key = RedisKeys.client_stop(t['media_id'], t['client_id'])
+                redis_client.setex(stop_key, 60, "true")
+                logger.info(f"[stream limits][{requesting_client_id}] Set stop key for timeshift client {t['client_id']}")
             else:
                 connection_manager = MultiWorkerVODConnectionManager.get_instance()
                 redis_client = connection_manager.redis_client
@@ -106,13 +116,14 @@ def get_user_active_connections(user_id):
 
                 if user_id is None or (client_user_id and int(client_user_id) == user_id):
                     try:
-                        logger.debug(f"[stream limits] Found LIVE connection for user {user_id} on channel {channel_id} with client ID {client_id}")
+                        conn_type = 'timeshift' if channel_id.startswith('timeshift_') else 'live'
+                        logger.debug(f"[stream limits] Found {conn_type.upper()} connection for user {user_id} on channel {channel_id} with client ID {client_id}")
                         connected_at = float(connected_at) if connected_at else 0
                         connections.append({
                             'media_id': channel_id,
                             'client_id': client_id,
                             'connected_at': connected_at,
-                            'type': 'live',
+                            'type': conn_type,
                         })
                     except (ValueError, TypeError):
                         pass
@@ -172,6 +183,22 @@ def check_user_stream_limits(user, client_id, media_id=None):
             logger.debug(f"[stream limits][{client_id}] Same-channel reconnect for {media_id} allowed (ignore_same_channel=True)")
             return True
 
+        # Timeshift sibling range/probe requests share one provider slot per
+        # session_id. Each distinct client/session still consumes its own slot.
+        if ignore_same_channel and media_id:
+            media_id_str = str(media_id)
+            for conn in active_connections:
+                if conn.get('type') != 'timeshift':
+                    continue
+                if conn.get('client_id') != client_id:
+                    continue
+                conn_media_id = str(conn.get('media_id') or '')
+                if conn_media_id == media_id_str or conn_media_id.startswith(f"{media_id_str}_"):
+                    logger.debug(
+                        f"[stream limits][{client_id}] Same timeshift session probe for {media_id} allowed (ignore_same_channel=True)"
+                    )
+                    return True
+
         if user_stream_count >= user.stream_limit:
             if user_limit_settings.get("terminate_on_limit_exceeded", True) == False:
                 return False
@@ -186,3 +213,28 @@ def check_user_stream_limits(user, client_id, media_id=None):
                     return False
 
     return True
+
+
+_TS_PACKET_SIZE = 188
+_TS_SYNC_BYTE = 0x47
+
+
+def find_ts_sync(buf):
+    """Return byte offset of the first valid MPEG-TS sync chain in *buf*, or -1.
+
+    Args:
+        buf: Raw bytes from an upstream HTTP response (typically the first 1 KB).
+
+    Returns:
+        Offset of the first 0x47 byte that starts three consecutive 188-byte
+        packets, or -1. Used to strip PHP/HTML preamble before streaming.
+    """
+    end = len(buf) - 2 * _TS_PACKET_SIZE
+    for i in range(0, end):
+        if (
+            buf[i] == _TS_SYNC_BYTE
+            and buf[i + _TS_PACKET_SIZE] == _TS_SYNC_BYTE
+            and buf[i + 2 * _TS_PACKET_SIZE] == _TS_SYNC_BYTE
+        ):
+            return i
+    return -1
diff --git a/apps/timeshift/__init__.py b/apps/timeshift/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/apps/timeshift/apps.py b/apps/timeshift/apps.py
new file mode 100644
index 00000000..e4ecbfba
--- /dev/null
+++ b/apps/timeshift/apps.py
@@ -0,0 +1,7 @@
+from django.apps import AppConfig
+
+
+class TimeshiftConfig(AppConfig):
+    default_auto_field = "django.db.models.BigAutoField"
+    name = "apps.timeshift"
+    verbose_name = "Timeshift"
diff --git a/apps/timeshift/helpers.py b/apps/timeshift/helpers.py
new file mode 100644
index 00000000..98d10c36
--- /dev/null
+++ b/apps/timeshift/helpers.py
@@ -0,0 +1,252 @@
+"""URL builders and timestamp helpers for XC catch-up."""
+
+import logging
+import re
+from collections import namedtuple
+from datetime import datetime, timezone
+from urllib.parse import quote
+from zoneinfo import ZoneInfo
+
+logger = logging.getLogger(__name__)
+
+# Credentials for the profile whose pool slot was reserved (not raw account fields).
+TimeshiftCredentials = namedtuple(
+    "TimeshiftCredentials", ("server_url", "username", "password")
+)
+
+DEFAULT_DURATION_MINUTES = 120
+DURATION_BUFFER_MINUTES = 5
+MAX_DURATION_MINUTES = 480
+
+# Wall-clock shapes seen from XC / iPlayTV / TiviMate clients. Compiled once.
+_CATCHUP_WALL_CLOCK_RE = re.compile(
+    r"^"
+    r"(?P<date>\d{4}-\d{2}-\d{2})"
+    r"(?P<dtsep>[:_]| )"
+    r"(?P<hour>\d{2})"
+    r"(?P<hmsep>[-:])"
+    r"(?P<minute>\d{2})"
+    r"(?:"
+    r":"
+    r"(?P<second>\d{2})"
+    r")?"
+    r"$"
+)
+
+
+def normalize_catchup_timestamp_input(timestamp_str):
+    """Map a client catch-up timestamp to an ISO-8601 string for ``fromisoformat``.
+
+    Supported inputs:
+        - ``YYYY-MM-DD:HH-MM`` (iPlayTV/TiviMate colon-dash)
+        - ``YYYY-MM-DD_HH-MM`` (XC underscore)
+        - ``YYYY-MM-DD:HH:MM[:SS]`` (XC colon time in catch-up URLs)
+        - ``YYYY-MM-DD HH:MM[:SS]`` (EPG / SQL datetime)
+        - Unix epoch seconds (10 digits) or milliseconds (13 digits)
+
+    Returns:
+        An ISO-8601 date-time string (``YYYY-MM-DDTHH:MM:SS``), or None if
+        the value does not match a known catch-up shape.
+    """
+    if timestamp_str is None:
+        return None
+    if not isinstance(timestamp_str, str):
+        timestamp_str = str(timestamp_str)
+    value = timestamp_str.strip()
+    if not value:
+        return None
+
+    if value.isdigit():
+        length = len(value)
+        if length == 10:
+            dt = datetime.fromtimestamp(int(value), tz=timezone.utc)
+            return dt.replace(tzinfo=None).isoformat(timespec="seconds")
+        if length == 13:
+            dt = datetime.fromtimestamp(int(value) / 1000, tz=timezone.utc)
+            return dt.replace(tzinfo=None).isoformat(timespec="seconds")
+        return None
+
+    match = _CATCHUP_WALL_CLOCK_RE.match(value)
+    if not match:
+        return None
+
+    parts = match.groupdict()
+    second = parts["second"] or "00"
+    return f"{parts['date']}T{parts['hour']}:{parts['minute']}:{second}"
+
+
+def parse_catchup_timestamp(timestamp_str):
+    """Parse a catch-up timestamp string into a naive UTC wall-clock datetime.
+
+    See ``normalize_catchup_timestamp_input`` for supported input shapes.
+
+    Returns:
+        A naive datetime on success, or None.
+    """
+    iso_value = normalize_catchup_timestamp_input(timestamp_str)
+    if iso_value is None:
+        if timestamp_str is not None and str(timestamp_str).strip():
+            logger.debug(
+                "Timeshift: unrecognised catch-up timestamp: %r", timestamp_str
+            )
+        return None
+    try:
+        return datetime.fromisoformat(iso_value)
+    except ValueError:
+        logger.debug(
+            "Timeshift: invalid catch-up timestamp after normalize: %r -> %r",
+            timestamp_str,
+            iso_value,
+        )
+        return None
+
+
+def _reshape_timestamp(timestamp, strftime_fmt, label):
+    dt = parse_catchup_timestamp(timestamp)
+    if dt is None:
+        logger.error(
+            "Timeshift %s reshape failed for %r: unrecognised format", label, timestamp
+        )
+        return timestamp
+    return dt.strftime(strftime_fmt)
+
+
+def convert_timestamp_to_provider_tz(timestamp_str, provider_tz_name):
+    """Convert a UTC catch-up timestamp to the provider's local zone.
+
+    Args:
+        timestamp_str: UTC wall-clock in ``YYYY-MM-DD:HH-MM`` or underscore form.
+        provider_tz_name: IANA zone from the provider's ``server_info.timezone``
+            (e.g. ``Europe/Brussels``). Falsy, ``UTC``, or unknown: no conversion.
+
+    Returns:
+        ``YYYY-MM-DD:HH-MM`` in the provider zone, or the input unchanged on skip/failure.
+    """
+    if not provider_tz_name or provider_tz_name == "UTC":
+        return timestamp_str
+    dt = parse_catchup_timestamp(timestamp_str)
+    if dt is None:
+        return timestamp_str
+    try:
+        target = ZoneInfo(provider_tz_name)
+    except Exception:
+        logger.warning(
+            "Timeshift: unknown provider timezone %r, no conversion applied",
+            provider_tz_name,
+        )
+        return timestamp_str
+    # timezone.utc, not ZoneInfo("UTC"): avoids mis-set Docker /etc/timezone.
+    local_dt = dt.replace(tzinfo=timezone.utc).astimezone(target)
+    return local_dt.strftime("%Y-%m-%d:%H-%M")
+
+
+def get_programme_duration(channel, timestamp_str):
+    """Look up catch-up duration in minutes from EPG.
+
+    Args:
+        channel: Channel with optional ``epg_data`` relation loaded.
+        timestamp_str: Programme start in UTC (same shape as the client URL).
+
+    Returns:
+        Programme length plus a small buffer, capped at ``MAX_DURATION_MINUTES``,
+        or ``DEFAULT_DURATION_MINUTES`` when EPG lookup fails.
+    """
+    try:
+        dt = parse_catchup_timestamp(timestamp_str)
+        if dt is None:
+            return DEFAULT_DURATION_MINUTES
+        # EPG times are timezone-aware; parsed value must be too.
+        dt = dt.replace(tzinfo=timezone.utc)
+        if not channel.epg_data:
+            return DEFAULT_DURATION_MINUTES
+
+        programme = channel.epg_data.programs.filter(
+            start_time__lte=dt, end_time__gt=dt
+        ).first()
+        if not programme:
+            return DEFAULT_DURATION_MINUTES
+
+        duration_seconds = (programme.end_time - programme.start_time).total_seconds()
+        duration_minutes = int(duration_seconds / 60) + DURATION_BUFFER_MINUTES
+        return min(duration_minutes, MAX_DURATION_MINUTES)
+    except Exception:
+        return DEFAULT_DURATION_MINUTES
+
+
+def build_timeshift_url_format_a(creds, stream_id, timestamp, duration_minutes):
+    """QUERY layout: ``/streaming/timeshift.php?username=...&start=...``"""
+    return (
+        f"{creds.server_url.rstrip('/')}/streaming/timeshift.php"
+        f"?username={quote(str(creds.username), safe='')}"
+        f"&password={quote(str(creds.password), safe='')}"
+        f"&stream={stream_id}"
+        f"&start={timestamp}"
+        f"&duration={duration_minutes}"
+    )
+
+
+def build_timeshift_url_format_b(creds, stream_id, timestamp, duration_minutes):
+    """PATH layout: ``/timeshift/{user}/{pass}/{dur}/{start}/{id}.ts``"""
+    return (
+        f"{creds.server_url.rstrip('/')}/timeshift"
+        f"/{quote(str(creds.username), safe='')}"
+        f"/{quote(str(creds.password), safe='')}"
+        f"/{duration_minutes}"
+        f"/{timestamp}"
+        f"/{stream_id}.ts"
+    )
+
+
+def build_timeshift_candidate_urls(creds, stream_id, timestamp, duration_minutes):
+    """Build ordered upstream URL candidates (PATH forms first, QUERY last).
+
+    Args:
+        creds: ``TimeshiftCredentials`` for the reserved profile.
+        stream_id: Provider stream id from the catch-up stream's custom properties.
+        timestamp: Already converted to the serving provider's local zone.
+        duration_minutes: Archive window length passed to the provider.
+
+    Returns:
+        List of URL strings to try in order. QUERY forms are last because some
+        providers return live TV even when ``start`` is set.
+    """
+    dt = parse_catchup_timestamp(timestamp)
+    if dt is None:
+        colon_dash_ts = timestamp
+        underscore_ts = timestamp
+        colon_seconds_ts = timestamp
+        sql_ts = timestamp
+    else:
+        colon_dash_ts = dt.strftime("%Y-%m-%d:%H-%M")
+        underscore_ts = dt.strftime("%Y-%m-%d_%H-%M")
+        colon_seconds_ts = dt.strftime("%Y-%m-%d:%H:%M:%S")
+        sql_ts = dt.strftime("%Y-%m-%d %H:%M:%S")
+    return [
+        build_timeshift_url_format_b(creds, stream_id, colon_dash_ts, duration_minutes),
+        build_timeshift_url_format_b(creds, stream_id, underscore_ts, duration_minutes),
+        build_timeshift_url_format_b(creds, stream_id, colon_seconds_ts, duration_minutes),
+        build_timeshift_url_format_a(creds, stream_id, underscore_ts, duration_minutes),
+        build_timeshift_url_format_a(creds, stream_id, sql_ts, duration_minutes),
+        build_timeshift_url_format_a(creds, stream_id, colon_dash_ts, duration_minutes),
+        build_timeshift_url_format_a(creds, stream_id, colon_seconds_ts, duration_minutes),
+    ]
+
+
+def format_timestamp_as_colon_dash(timestamp):
+    """Reshape to ``YYYY-MM-DD:HH-MM`` without timezone conversion."""
+    return _reshape_timestamp(timestamp, "%Y-%m-%d:%H-%M", "colon-dash")
+
+
+def format_timestamp_as_colon_seconds(timestamp):
+    """Reshape to ``YYYY-MM-DD:HH:MM:SS`` without timezone conversion."""
+    return _reshape_timestamp(timestamp, "%Y-%m-%d:%H:%M:%S", "colon-seconds")
+
+
+def format_timestamp_as_underscore(timestamp):
+    """Reshape to ``YYYY-MM-DD_HH-MM`` without timezone conversion."""
+    return _reshape_timestamp(timestamp, "%Y-%m-%d_%H-%M", "underscore")
+
+
+def format_timestamp_as_sql_datetime(timestamp):
+    """Reshape to ``YYYY-MM-DD HH:MM:SS`` without timezone conversion."""
+    return _reshape_timestamp(timestamp, "%Y-%m-%d %H:%M:%S", "SQL")
diff --git a/apps/timeshift/tests/__init__.py b/apps/timeshift/tests/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/apps/timeshift/tests/test_helpers.py b/apps/timeshift/tests/test_helpers.py
new file mode 100644
index 00000000..4bd7e0e3
--- /dev/null
+++ b/apps/timeshift/tests/test_helpers.py
@@ -0,0 +1,325 @@
+"""Tests for `apps.timeshift.helpers`: timestamp shape conversion and URL build."""
+
+from datetime import datetime, timezone
+
+from django.test import TestCase
+
+from apps.timeshift.helpers import (
+    TimeshiftCredentials,
+    build_timeshift_candidate_urls,
+    build_timeshift_url_format_a,
+    build_timeshift_url_format_b,
+    convert_timestamp_to_provider_tz,
+    format_timestamp_as_colon_dash,
+    format_timestamp_as_colon_seconds,
+    format_timestamp_as_sql_datetime,
+    format_timestamp_as_underscore,
+    normalize_catchup_timestamp_input,
+    parse_catchup_timestamp,
+)
+
+
+def _make_creds():
+    # The builders consume resolved per-profile credentials, never an account
+    # object — get_transformed_credentials() produces these in the view.
+    return TimeshiftCredentials("http://example.test", "user", "pass")
+
+
+class TimestampFormatTests(TestCase):
+    """Timestamp reshape functions change format only; no timezone conversion."""
+
+    def test_normalize_colon_dash_shape(self):
+        self.assertEqual(
+            normalize_catchup_timestamp_input("2026-05-21:12-55"),
+            "2026-05-21T12:55:00",
+        )
+
+    def test_normalize_colon_seconds_xc_format(self):
+        self.assertEqual(
+            normalize_catchup_timestamp_input("2026-06-23:04:00:00"),
+            "2026-06-23T04:00:00",
+        )
+
+    def test_normalize_epg_sql_format(self):
+        self.assertEqual(
+            normalize_catchup_timestamp_input("2026-06-23 04:00:00"),
+            "2026-06-23T04:00:00",
+        )
+
+    def test_normalize_unix_epoch_seconds(self):
+        epoch = str(int(datetime(2026, 6, 23, 4, 0, 0, tzinfo=timezone.utc).timestamp()))
+        self.assertEqual(
+            normalize_catchup_timestamp_input(epoch),
+            "2026-06-23T04:00:00",
+        )
+
+    def test_normalize_unix_epoch_milliseconds(self):
+        epoch_ms = str(
+            int(datetime(2026, 6, 23, 4, 0, 0, tzinfo=timezone.utc).timestamp() * 1000)
+        )
+        self.assertEqual(
+            normalize_catchup_timestamp_input(epoch_ms),
+            "2026-06-23T04:00:00",
+        )
+
+    def test_normalize_rejects_garbage(self):
+        self.assertIsNone(normalize_catchup_timestamp_input("garbage"))
+        self.assertIsNone(normalize_catchup_timestamp_input(""))
+        self.assertIsNone(normalize_catchup_timestamp_input("12345"))
+
+    def test_parse_rejects_invalid_calendar_date(self):
+        self.assertIsNone(parse_catchup_timestamp("2026-13-45:04-00"))
+
+    def test_parse_colon_dash_format(self):
+        dt = parse_catchup_timestamp("2026-05-21:12-55")
+        self.assertEqual(dt, datetime(2026, 5, 21, 12, 55, 0))
+
+    def test_parse_underscore_format(self):
+        dt = parse_catchup_timestamp("2026-05-21_12-55")
+        self.assertEqual(dt, datetime(2026, 5, 21, 12, 55, 0))
+
+    def test_parse_colon_minutes_without_seconds(self):
+        dt = parse_catchup_timestamp("2026-06-23:04:00")
+        self.assertEqual(dt, datetime(2026, 6, 23, 4, 0, 0))
+
+    def test_parse_colon_seconds_xc_format(self):
+        dt = parse_catchup_timestamp("2026-06-23:04:00:00")
+        self.assertEqual(dt, datetime(2026, 6, 23, 4, 0, 0))
+
+    def test_parse_epg_sql_format(self):
+        dt = parse_catchup_timestamp("2026-06-23 04:00:00")
+        self.assertEqual(dt, datetime(2026, 6, 23, 4, 0, 0))
+
+    def test_format_colon_dash_from_colon_seconds(self):
+        self.assertEqual(
+            format_timestamp_as_colon_dash("2026-06-23:04:00:00"),
+            "2026-06-23:04-00",
+        )
+
+    def test_format_colon_seconds_from_colon_dash(self):
+        self.assertEqual(
+            format_timestamp_as_colon_seconds("2026-06-23:04-00"),
+            "2026-06-23:04:00:00",
+        )
+
+    def test_format_colon_seconds_from_unix_epoch(self):
+        epoch = str(int(datetime(2026, 6, 23, 4, 0, 0, tzinfo=timezone.utc).timestamp()))
+        self.assertEqual(
+            format_timestamp_as_colon_dash(epoch),
+            "2026-06-23:04-00",
+        )
+
+    def test_format_sql_reshapes_without_tz_conversion(self):
+        self.assertEqual(
+            format_timestamp_as_sql_datetime("2026-05-12:17-00"),
+            "2026-05-12 17:00:00",
+        )
+
+    def test_format_sql_accepts_underscore_input(self):
+        self.assertEqual(
+            format_timestamp_as_sql_datetime("2026-05-12_17-00"),
+            "2026-05-12 17:00:00",
+        )
+
+    def test_format_sql_invalid_falls_back(self):
+        self.assertEqual(format_timestamp_as_sql_datetime("garbage"), "garbage")
+
+    def test_format_underscore_from_colon_dash(self):
+        self.assertEqual(
+            format_timestamp_as_underscore("2026-05-21:12-55"),
+            "2026-05-21_12-55",
+        )
+
+    def test_format_underscore_idempotent(self):
+        # Underscore input → underscore output (no change)
+        self.assertEqual(
+            format_timestamp_as_underscore("2026-05-21_12-55"),
+            "2026-05-21_12-55",
+        )
+
+    def test_format_underscore_invalid_falls_back(self):
+        self.assertEqual(format_timestamp_as_underscore("garbage"), "garbage")
+
+
+class BuildTimeshiftUrlTests(TestCase):
+    def setUp(self):
+        self.creds = _make_creds()
+
+    def test_format_a_passes_dash_shape_unchanged(self):
+        url = build_timeshift_url_format_a(
+            self.creds, "22372", "2026-05-12:19-00", 40
+        )
+        self.assertIn("start=2026-05-12:19-00", url)
+        self.assertIn("stream=22372", url)
+        self.assertIn("duration=40", url)
+
+    def test_format_a_passes_sql_shape_unchanged(self):
+        url = build_timeshift_url_format_a(
+            self.creds, "22372", "2026-05-12 19:00:00", 40
+        )
+        self.assertIn("start=2026-05-12 19:00:00", url)
+
+    def test_format_b_path_with_dash_shape(self):
+        url = build_timeshift_url_format_b(
+            self.creds, "22372", "2026-05-12:19-00", 40
+        )
+        self.assertIn("/40/2026-05-12:19-00/22372.ts", url)
+
+
+class CandidateOrderingTests(TestCase):
+    """`build_timeshift_candidate_urls` must try the PATH form (which seeks the
+    archive) before the QUERY form (which returns LIVE on some providers,
+    silently ignoring the requested timestamp). Regression guard for the
+    "catch-up plays the live stream instead of the requested programme" bug."""
+
+    def setUp(self):
+        self.creds = _make_creds()
+
+    def _is_path_form(self, url):
+        return "/timeshift/" in url and url.endswith(".ts") and "timeshift.php" not in url
+
+    def _is_query_form(self, url):
+        return "timeshift.php?" in url
+
+    def test_every_path_candidate_precedes_every_query_candidate(self):
+        urls = build_timeshift_candidate_urls(self.creds, "22372", "2026-05-12:19-00", 40)
+        path_indices = [i for i, u in enumerate(urls) if self._is_path_form(u)]
+        query_indices = [i for i, u in enumerate(urls) if self._is_query_form(u)]
+        # Each URL is classified as exactly one form.
+        self.assertEqual(len(path_indices) + len(query_indices), len(urls))
+        self.assertTrue(path_indices and query_indices)
+        # The last PATH candidate still comes before the first QUERY candidate.
+        self.assertLess(max(path_indices), min(query_indices))
+
+    def test_first_candidate_is_path_form_with_canonical_dash_timestamp(self):
+        urls = build_timeshift_candidate_urls(self.creds, "22372", "2026-05-12:19-00", 40)
+        self.assertTrue(self._is_path_form(urls[0]))
+        # Canonical colon-dash timestamp, passed through unchanged.
+        self.assertIn("/40/2026-05-12:19-00/22372.ts", urls[0])
+
+    def test_accepts_colon_seconds_input_timestamp(self):
+        urls = build_timeshift_candidate_urls(
+            self.creds, "22372", "2026-06-23:04:00:00", 40
+        )
+        self.assertTrue(self._is_path_form(urls[0]))
+        self.assertIn("/40/2026-06-23:04-00/22372.ts", urls[0])
+        self.assertIn("/40/2026-06-23:04:00:00/22372.ts", urls[2])
+
+    def test_accepts_underscore_input_timestamp(self):
+        # Client may send the underscore shape; PATH form still leads.
+        urls = build_timeshift_candidate_urls(self.creds, "22372", "2026-05-12_19-00", 40)
+        self.assertTrue(self._is_path_form(urls[0]))
+
+
+class ConvertTimestampToProviderTzTests(TestCase):
+    """`convert_timestamp_to_provider_tz` shifts a UTC catch-up timestamp into the
+    serving provider's local zone (XC providers index archives in their own zone),
+    DST-correct, and is a no-op when the zone is UTC/unknown/missing."""
+
+    def test_utc_to_brussels_summer_is_plus_two(self):
+        # June → CEST (+02:00): 17:00 UTC == 19:00 Brussels (the 19h JT case).
+        self.assertEqual(
+            convert_timestamp_to_provider_tz("2026-06-08:17-00", "Europe/Brussels"),
+            "2026-06-08:19-00",
+        )
+
+    def test_utc_to_brussels_winter_is_plus_one(self):
+        # January → CET (+01:00): 17:00 UTC == 18:00 Brussels (DST handled).
+        self.assertEqual(
+            convert_timestamp_to_provider_tz("2026-01-08:17-00", "Europe/Brussels"),
+            "2026-01-08:18-00",
+        )
+
+    def test_day_rollover(self):
+        # 23:30 UTC + 2h (CEST) crosses midnight into the next day.
+        self.assertEqual(
+            convert_timestamp_to_provider_tz("2026-06-08:23-30", "Europe/Brussels"),
+            "2026-06-09:01-30",
+        )
+
+    def test_underscore_input_returns_colon_dash(self):
+        self.assertEqual(
+            convert_timestamp_to_provider_tz("2026-06-08_17-00", "Europe/Brussels"),
+            "2026-06-08:19-00",
+        )
+
+    def test_utc_zone_is_noop(self):
+        self.assertEqual(
+            convert_timestamp_to_provider_tz("2026-06-08:17-00", "UTC"),
+            "2026-06-08:17-00",
+        )
+
+    def test_none_zone_is_noop(self):
+        self.assertEqual(
+            convert_timestamp_to_provider_tz("2026-06-08:17-00", None),
+            "2026-06-08:17-00",
+        )
+
+    def test_unknown_zone_is_noop(self):
+        self.assertEqual(
+            convert_timestamp_to_provider_tz("2026-06-08:17-00", "Mars/Phobos"),
+            "2026-06-08:17-00",
+        )
+
+    def test_utc_to_brussels_from_unix_epoch(self):
+        epoch = str(int(datetime(2026, 6, 8, 17, 0, 0, tzinfo=timezone.utc).timestamp()))
+        self.assertEqual(
+            convert_timestamp_to_provider_tz(epoch, "Europe/Brussels"),
+            "2026-06-08:19-00",
+        )
+
+    def test_garbage_timestamp_passthrough(self):
+        self.assertEqual(
+            convert_timestamp_to_provider_tz("garbage", "Europe/Brussels"),
+            "garbage",
+        )
+
+
+class GetProgrammeDurationTests(TestCase):
+    """Duration window resolution: programme length + buffer, capped, with a
+    safe default whenever the EPG lookup cannot resolve."""
+
+    def _channel_with_programme(self, minutes):
+        from datetime import datetime, timedelta, timezone as dt_timezone
+        from unittest.mock import MagicMock
+
+        start = datetime(2026, 6, 8, 17, 0, tzinfo=dt_timezone.utc)
+        programme = MagicMock(
+            start_time=start, end_time=start + timedelta(minutes=minutes)
+        )
+        channel = MagicMock()
+        channel.epg_data.programs.filter.return_value.first.return_value = programme
+        return channel
+
+    def test_duration_is_programme_length_plus_buffer(self):
+        from apps.timeshift.helpers import get_programme_duration
+        # 40-minute programme + 5-minute buffer.
+        self.assertEqual(
+            get_programme_duration(self._channel_with_programme(40), "2026-06-08:17-00"),
+            45,
+        )
+
+    def test_duration_capped_at_max(self):
+        from apps.timeshift.helpers import get_programme_duration
+        self.assertEqual(
+            get_programme_duration(self._channel_with_programme(1000), "2026-06-08:17-00"),
+            480,
+        )
+
+    def test_no_epg_data_falls_back_to_default(self):
+        from unittest.mock import MagicMock
+        from apps.timeshift.helpers import get_programme_duration
+        channel = MagicMock(epg_data=None)
+        self.assertEqual(get_programme_duration(channel, "2026-06-08:17-00"), 120)
+
+    def test_no_matching_programme_falls_back_to_default(self):
+        from unittest.mock import MagicMock
+        from apps.timeshift.helpers import get_programme_duration
+        channel = MagicMock()
+        channel.epg_data.programs.filter.return_value.first.return_value = None
+        self.assertEqual(get_programme_duration(channel, "2026-06-08:17-00"), 120)
+
+    def test_garbage_timestamp_falls_back_to_default(self):
+        from unittest.mock import MagicMock
+        from apps.timeshift.helpers import get_programme_duration
+        self.assertEqual(get_programme_duration(MagicMock(), "garbage"), 120)
diff --git a/apps/timeshift/tests/test_views.py b/apps/timeshift/tests/test_views.py
new file mode 100644
index 00000000..1e45f53b
--- /dev/null
+++ b/apps/timeshift/tests/test_views.py
@@ -0,0 +1,2050 @@
+"""Tests for the timeshift proxy view, focused on upstream status mapping."""
+
+import fnmatch
+import time
+from unittest.mock import MagicMock, patch
+
+from django.test import RequestFactory, TestCase, override_settings
+
+from apps.timeshift import views
+from apps.proxy.utils import check_user_stream_limits as _check_user_stream_limits
+from apps.proxy.utils import find_ts_sync as _find_ts_sync
+
+TEST_SESSION_ID = "timeshift_testsession1"
+TEST_MEDIA_ID = "timeshift_8_2026-06-08-17-00"
+
+
+def _proxy_url(session_id=TEST_SESSION_ID):
+    base = "/timeshift/u/p/8/2026-06-08:17-00/8.ts"
+    return f"{base}?session_id={session_id}" if session_id else base
+
+
+def _seed_pool_session(
+    redis,
+    session_id=TEST_SESSION_ID,
+    media_id=TEST_MEDIA_ID,
+    *,
+    busy="1",
+    serving_range=None,
+    user_id=5,
+    client_ip="1.2.3.4",
+    client_user_agent="test-agent",
+):
+    views._create_pool_session(
+        redis,
+        session_id=session_id,
+        media_id=media_id,
+        user_id=user_id,
+        client_ip=client_ip,
+        client_user_agent=client_user_agent,
+        account_id=1,
+        profile_id=31,
+        stream_id="111",
+        provider_timestamp="2026-06-08:19-00",
+    )
+    if serving_range is not None:
+        redis.hset(f"timeshift_pool:{session_id}", "serving_range", serving_range)
+    if busy is not None:
+        redis.hset(f"timeshift_pool:{session_id}", "busy", busy)
+
+
+class FindTsSyncTests(TestCase):
+    """Locate the first MPEG-TS sync chain so a leading HTML/PHP preamble
+    can be skipped before the bytes reach the strict demuxer (ExoPlayer)."""
+
+    def test_returns_zero_when_buffer_already_aligned(self):
+        buf = b"\x47" + b"\x00" * 187 + b"\x47" + b"\x00" * 187 + b"\x47" + b"\x00" * 187
+        self.assertEqual(_find_ts_sync(buf), 0)
+
+    def test_returns_offset_of_first_chain_after_preamble(self):
+        preamble = b"<br />\n<b>Warning</b>"
+        aligned = b"\x47" + b"\x00" * 187 + b"\x47" + b"\x00" * 187 + b"\x47" + b"\x00" * 187
+        self.assertEqual(_find_ts_sync(preamble + aligned), len(preamble))
+
+    def test_returns_minus_one_when_no_chain_exists(self):
+        # Three lone 0x47 bytes that are NOT spaced at 188 — must not be
+        # mistaken for a sync chain.
+        self.assertEqual(_find_ts_sync(b"\x47\x00\x00\x47\x00\x00\x47" * 50), -1)
+
+    def test_returns_minus_one_for_short_buffer(self):
+        self.assertEqual(_find_ts_sync(b"\x47" * 10), -1)
+
+
+
+def _make_ts_payload(size=1024):
+    """Build a minimal valid MPEG-TS byte sequence with 0x47 sync markers."""
+    packet = b"\x47" + b"\x00" * 187
+    return (packet * ((size // 188) + 1))[:size]
+
+
+def _fake_upstream(status_code, *, content_type="video/mp2t", body=b""):
+    resp = MagicMock()
+    resp.status_code = status_code
+    resp.headers = {"Content-Type": content_type}
+    resp.iter_content = MagicMock(return_value=iter([body] if body else []))
+    resp.close = MagicMock()
+    # Simulate raw.read() for the TS sync peek in _stream_from_provider.
+    # For 200 responses, return valid TS bytes so the peek check passes.
+    if status_code in (200, 206) and not body:
+        ts_peek = _make_ts_payload()
+        resp.raw = MagicMock()
+        resp.raw.read = MagicMock(return_value=ts_peek)
+    elif status_code in (200, 206):
+        resp.raw = MagicMock()
+        resp.raw.read = MagicMock(return_value=body)
+    return resp
+
+
+class StreamFromProviderStatusMappingTests(TestCase):
+    """`_stream_from_provider` must translate upstream HTTP status codes into
+    semantically correct Django responses so downstream IPTV clients react
+    the right way (notably: stop retrying on 404)."""
+
+    def setUp(self):
+        self.factory = RequestFactory()
+        self.kwargs = dict(
+            candidate_urls=[
+                "http://example.test/streaming/timeshift.php?stream=1&start=2026-05-12:17-00",
+                "http://example.test/streaming/timeshift.php?stream=1&start=2026-05-12 17:00:00",
+                "http://example.test/timeshift/u/p/60/2026-05-12:17-00/1.ts",
+            ],
+            user_agent="test-agent",
+            range_header=None,
+            virtual_channel_id="timeshift_1_2026-05-12-17-00_1",
+            client_id="timeshift_test123",
+            client_ip="127.0.0.1",
+            user=None,
+            channel_display_name="Test",
+            timestamp_utc="2026-05-12:17-00",
+            channel_logo_id=None,
+            m3u_profile_id=None,
+            debug=False,
+        )
+
+    @patch.object(views, "_open_upstream")
+    def test_all_candidates_404_returns_404(self, mocked_open):
+        mocked_open.return_value = _fake_upstream(404)
+        response = views._stream_from_provider(**self.kwargs)
+        self.assertEqual(response.status_code, 404)
+        # Every candidate is attempted before giving up.
+        self.assertEqual(mocked_open.call_count, 3)
+
+    @patch.object(views, "_open_upstream")
+    def test_upstream_403_short_circuits_loop(self, mocked_open):
+        # 403 is decisive (auth) — no retry of further candidates.
+        mocked_open.return_value = _fake_upstream(403)
+        response = views._stream_from_provider(**self.kwargs)
+        self.assertEqual(response.status_code, 403)
+        self.assertEqual(mocked_open.call_count, 1)
+
+    @patch.object(views, "_open_upstream")
+    def test_upstream_302_short_circuits_loop(self, mocked_open):
+        # Any 3xx is decisive: for XC providers a 302 is the first sign of
+        # an IP ban, so the cascade must STOP hammering immediately instead
+        # of retrying other URL shapes (which escalates the ban).
+        mocked_open.return_value = _fake_upstream(302)
+        response = views._stream_from_provider(**self.kwargs)
+        self.assertEqual(response.status_code, 400)
+        self.assertEqual(mocked_open.call_count, 1)
+
+    @patch.object(views, "_open_upstream")
+    def test_upstream_500_continues_to_next_candidate(self, mocked_open):
+        # A 5xx is format-specific on many XC servers (PHP fatal with
+        # display_errors off turns an "Undefined array key" warning into a
+        # hard 500), so the cascade must keep trying — the next timestamp
+        # shape often succeeds.  Regression: providers that 500 on the first
+        # shape used to fail outright because the loop short-circuited.
+        mocked_open.side_effect = [
+            _fake_upstream(500),
+            _fake_upstream(200, body=_make_ts_payload()),
+        ]
+        with patch.object(views, "RedisClient"), \
+             patch.object(views, "_register_stats_client"), \
+             patch.object(views, "_unregister_stats_client"):
+            response = views._stream_from_provider(**self.kwargs)
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(mocked_open.call_count, 2)
+
+    @patch.object(views, "_open_upstream")
+    def test_all_candidates_500_returns_error(self, mocked_open):
+        # Every shape 500s → all candidates attempted, then a clean error.
+        mocked_open.return_value = _fake_upstream(500)
+        response = views._stream_from_provider(**self.kwargs)
+        self.assertEqual(response.status_code, 400)
+        self.assertEqual(mocked_open.call_count, 3)
+
+    @patch.object(views, "_open_upstream")
+    def test_first_candidate_succeeds(self, mocked_open):
+        mocked_open.side_effect = [_fake_upstream(200, body=_make_ts_payload())]
+        with patch.object(views, "RedisClient"), \
+             patch.object(views, "_register_stats_client"), \
+             patch.object(views, "_unregister_stats_client"):
+            response = views._stream_from_provider(**self.kwargs)
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(mocked_open.call_count, 1)
+
+    @patch.object(views, "_open_upstream")
+    def test_second_candidate_succeeds_after_404(self, mocked_open):
+        # Primary 404 → second candidate 200 → streams successfully.
+        mocked_open.side_effect = [
+            _fake_upstream(404),
+            _fake_upstream(200, body=_make_ts_payload()),
+        ]
+        with patch.object(views, "RedisClient"), \
+             patch.object(views, "_register_stats_client"), \
+             patch.object(views, "_unregister_stats_client"):
+            response = views._stream_from_provider(**self.kwargs)
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(mocked_open.call_count, 2)
+
+    @patch.object(views, "_open_upstream")
+    def test_third_candidate_succeeds_after_400_then_404(self, mocked_open):
+        mocked_open.side_effect = [
+            _fake_upstream(400),
+            _fake_upstream(404),
+            _fake_upstream(200, body=_make_ts_payload()),
+        ]
+        with patch.object(views, "RedisClient"), \
+             patch.object(views, "_register_stats_client"), \
+             patch.object(views, "_unregister_stats_client"):
+            response = views._stream_from_provider(**self.kwargs)
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(mocked_open.call_count, 3)
+
+    @override_settings(CACHES={
+        "default": {"BACKEND": "django.core.cache.backends.locmem.LocMemCache"}
+    })
+    @patch.object(views, "_open_upstream")
+    def test_cache_promotes_winning_index_to_first(self, mocked_open):
+        """Once a candidate succeeds for an account, the next request reorders
+        the list so the cached winner is tried first — saving cascade
+        overhead on fast-forward."""
+        # locmem cache: isolates this test from the shared Redis-backed django
+        # cache (which persists across runs and parallel test sessions).
+        from django.core.cache import cache as django_cache
+        django_cache.delete(views._FORMAT_CACHE_KEY.format(999))
+
+        # First request: candidate index 1 wins after index 0 returns 404.
+        mocked_open.side_effect = [
+            _fake_upstream(404),
+            _fake_upstream(200, body=_make_ts_payload()),
+        ]
+        kwargs = dict(self.kwargs, account_id=999)
+        with patch.object(views, "RedisClient"), \
+             patch.object(views, "_register_stats_client"), \
+             patch.object(views, "_unregister_stats_client"):
+            r1 = views._stream_from_provider(**kwargs)
+        self.assertEqual(r1.status_code, 200)
+        self.assertEqual(mocked_open.call_count, 2)
+
+        # Second request: cached winner (index 1) is tried first, succeeds
+        # immediately — no cascade.
+        mocked_open.reset_mock()
+        mocked_open.side_effect = [_fake_upstream(200, body=_make_ts_payload())]
+        with patch.object(views, "RedisClient"), \
+             patch.object(views, "_register_stats_client"), \
+             patch.object(views, "_unregister_stats_client"):
+            r2 = views._stream_from_provider(**kwargs)
+        self.assertEqual(r2.status_code, 200)
+        self.assertEqual(mocked_open.call_count, 1)
+        # Confirm the URL used is the SQL-datetime candidate (index 1 in the
+        # original list set up in setUp), not the dash-only one (index 0).
+        self.assertIn("17:00:00", mocked_open.call_args_list[0][0][0])
+
+    @patch.object(views, "_open_upstream")
+    def test_php_error_200_cascades_to_next_candidate(self, mocked_open):
+        """When the provider returns HTTP 200 but the body is PHP error text
+        (no TS sync), the cascade should try the next candidate URL."""
+        php_error = b'<br />\n<b>Warning</b>: Invalid argument supplied for foreach()'
+        php_resp = _fake_upstream(200, body=php_error)
+        php_resp.raw = MagicMock()
+        php_resp.raw.read = MagicMock(return_value=php_error)
+
+        ts_resp = _fake_upstream(200, body=_make_ts_payload())
+
+        mocked_open.side_effect = [php_resp, ts_resp]
+        with patch.object(views, "RedisClient"), \
+             patch.object(views, "_register_stats_client"), \
+             patch.object(views, "_unregister_stats_client"):
+            response = views._stream_from_provider(**self.kwargs)
+        self.assertEqual(response.status_code, 200)
+        # PHP response was rejected, second candidate accepted
+        self.assertEqual(mocked_open.call_count, 2)
+
+    @patch.object(views, "_open_upstream")
+    def test_416_range_not_satisfiable_passes_through(self, mocked_open):
+        # A tail/seek probe past EOF must go back to the client verbatim,
+        # never cascaded to other URL shapes (byte offsets are file-specific,
+        # so cascading only multiplies upstream connections).
+        resp = _fake_upstream(416)
+        resp.headers = {"Content-Type": "video/mp2t", "Content-Range": "bytes */1000"}
+        mocked_open.return_value = resp
+        kwargs = dict(self.kwargs, range_header="bytes=999999-")
+        response = views._stream_from_provider(**kwargs)
+        self.assertEqual(response.status_code, 416)
+        self.assertEqual(response["Content-Range"], "bytes */1000")
+        self.assertTrue(getattr(response, "timeshift_passthrough", False))
+        # No cascade: the first (and only) candidate decided the outcome.
+        self.assertEqual(mocked_open.call_count, 1)
+
+    @patch.object(views, "_open_upstream")
+    def test_partial_206_to_range_request_accepted_mid_packet(self, mocked_open):
+        # A 206 answering a Range request legitimately starts mid-TS-packet
+        # (no 0x47 sync at offset 0). It must be served, not rejected as a
+        # PHP error and cascaded across every URL shape and provider account.
+        mid_packet = b"\x00" * 300
+        self.assertEqual(_find_ts_sync(mid_packet), -1)
+        resp = _fake_upstream(206, body=mid_packet)
+        resp.raw = MagicMock()
+        resp.raw.read = MagicMock(return_value=mid_packet)
+        mocked_open.return_value = resp
+        kwargs = dict(self.kwargs, range_header="bytes=1000-")
+        with patch.object(views, "RedisClient"), \
+             patch.object(views, "_register_stats_client"), \
+             patch.object(views, "_unregister_stats_client"):
+            response = views._stream_from_provider(**kwargs)
+        self.assertEqual(response.status_code, 206)
+        self.assertEqual(mocked_open.call_count, 1)
+
+    @patch.object(views, "_open_upstream")
+    def test_partial_206_html_error_still_rejected(self, mocked_open):
+        # The mid-packet allowance is gated on content type: a 206 whose body
+        # is an HTML/PHP error page must still be rejected and cascaded.
+        html = b"<html><body>error</body></html>"
+        bad = _fake_upstream(206, content_type="text/html", body=html)
+        bad.raw = MagicMock()
+        bad.raw.read = MagicMock(return_value=html)
+        good = _fake_upstream(206, body=_make_ts_payload())
+        mocked_open.side_effect = [bad, good]
+        kwargs = dict(self.kwargs, range_header="bytes=0-")
+        with patch.object(views, "RedisClient"), \
+             patch.object(views, "_register_stats_client"), \
+             patch.object(views, "_unregister_stats_client"):
+            response = views._stream_from_provider(**kwargs)
+        self.assertEqual(response.status_code, 206)
+        self.assertEqual(mocked_open.call_count, 2)
+
+    @patch.object(views, "_open_upstream")
+    def test_206_without_range_header_still_requires_sync(self, mocked_open):
+        # Without a Range header a 206 is unexpected; it must still pass the
+        # TS-sync probe (the mid-packet allowance is range-only).
+        mid_packet = b"\x00" * 300
+        bad = _fake_upstream(206, body=mid_packet)
+        bad.raw = MagicMock()
+        bad.raw.read = MagicMock(return_value=mid_packet)
+        good = _fake_upstream(206, body=_make_ts_payload())
+        mocked_open.side_effect = [bad, good]
+        with patch.object(views, "RedisClient"), \
+             patch.object(views, "_register_stats_client"), \
+             patch.object(views, "_unregister_stats_client"):
+            response = views._stream_from_provider(**self.kwargs)
+        self.assertEqual(response.status_code, 206)
+        self.assertEqual(mocked_open.call_count, 2)
+
+
+class RedactUrlTests(TestCase):
+    """`_redact_url` is the guard that keeps XC credentials out of logs —
+    both URL forms carry them (query params in format A, path segments in
+    format B)."""
+
+    def test_redacts_query_credentials(self):
+        url = "http://example.test/streaming/timeshift.php?username=u&password=p&stream=1"
+        self.assertEqual(views._redact_url(url), "http://example.test/...")
+
+    def test_redacts_path_credentials(self):
+        url = "http://example.test/timeshift/user/pass/60/2026-05-12:17-00/1.ts"
+        self.assertEqual(views._redact_url(url), "http://example.test/...")
+
+    def test_redacts_userinfo_credentials(self):
+        url = "http://user:pass@example.test/timeshift/1.ts"
+        self.assertEqual(views._redact_url(url), "http://example.test/...")
+
+    def test_passes_through_non_urls(self):
+        self.assertEqual(views._redact_url("not a url"), "not a url")
+        self.assertIsNone(views._redact_url(None))
+
+
+def _make_catchup_stream(provider_tz="Europe/Brussels", *, account_id=9,
+                         stream_id="22372", account_type="XC", profile_id=31,
+                         extra_profiles=()):
+    """Build a mocked catch-up Stream with its own provider context.
+
+    The default (tz-bearing) profile leads the active-profile list the view
+    walks; ``extra_profiles`` appends alternate (non-default) profiles for
+    capacity-walk tests.
+    """
+    profile = MagicMock()
+    profile.id = profile_id
+    profile.is_default = True
+    profile.custom_properties = {"server_info": {"timezone": provider_tz}}
+    m3u_account = MagicMock()
+    m3u_account.account_type = account_type
+    m3u_account.id = account_id
+    m3u_account.profiles.filter.return_value = [profile, *extra_profiles]
+    stream = MagicMock()
+    stream.m3u_account = m3u_account
+    stream.custom_properties = {"stream_id": stream_id} if stream_id else {}
+    return stream
+
+
+def _make_alt_profile(profile_id):
+    """A non-default active profile for the capacity walk."""
+    profile = MagicMock()
+    profile.id = profile_id
+    profile.is_default = False
+    profile.custom_properties = {}
+    return profile
+
+
+class _FakeRedis:
+    """Just enough of the redis-py surface for the idle-session pool: setex/get/
+    delete plus a transactional pipeline doing GET+DEL, and the hash, set and
+    lock primitives the pool entries rely on."""
+
+    def __init__(self):
+        self.store = {}
+
+    def setex(self, key, ttl, value):
+        self.store[key] = str(value)
+
+    def set(self, key, value):
+        self.store[key] = str(value)
+
+    def get(self, key):
+        return self.store.get(key)
+
+    def delete(self, *keys):
+        return sum(1 for k in keys if self.store.pop(k, None) is not None)
+
+    def exists(self, key):
+        return 1 if key in self.store else 0
+
+    def pipeline(self, transaction=False):
+        return _FakeRedisPipeline(self)
+
+    # --- hash + lock surface for the session slot ---
+    def hgetall(self, key):
+        value = self.store.get(key)
+        return dict(value) if isinstance(value, dict) else {}
+
+    def hset(self, key, field=None, value=None, mapping=None, **kwargs):
+        hash_value = self.store.get(key)
+        if not isinstance(hash_value, dict):
+            hash_value = {}
+            self.store[key] = hash_value
+        if field is not None and value is not None:
+            hash_value[str(field)] = str(value)
+        for f, v in (mapping or {}).items():
+            hash_value[str(f)] = str(v)
+        for f, v in kwargs.items():
+            hash_value[str(f)] = str(v)
+        return len(hash_value)
+
+    def hincrby(self, key, field, amount=1):
+        hash_value = self.store.get(key)
+        if not isinstance(hash_value, dict):
+            hash_value = {}
+            self.store[key] = hash_value
+        new_value = int(hash_value.get(field, 0)) + amount
+        hash_value[field] = str(new_value)
+        return new_value
+
+    def hget(self, key, field):
+        hash_value = self.store.get(key)
+        return hash_value.get(field) if isinstance(hash_value, dict) else None
+
+    def expire(self, key, ttl):
+        return 1 if key in self.store else 0
+
+    # --- set surface for the idle-session pool ---
+    def sadd(self, key, *members):
+        existing = self.store.get(key)
+        if not isinstance(existing, set):
+            existing = set()
+            self.store[key] = existing
+        before = len(existing)
+        existing.update(str(m) for m in members)
+        return len(existing) - before
+
+    def srem(self, key, *members):
+        existing = self.store.get(key)
+        if not isinstance(existing, set):
+            return 0
+        removed = 0
+        for member in members:
+            if str(member) in existing:
+                existing.discard(str(member))
+                removed += 1
+        return removed
+
+    def smembers(self, key):
+        existing = self.store.get(key)
+        return set(existing) if isinstance(existing, set) else set()
+
+    def scard(self, key):
+        existing = self.store.get(key)
+        return len(existing) if isinstance(existing, set) else 0
+
+    def lock(self, name, timeout=None, blocking_timeout=None):
+        return _FakeRedisLock()
+
+    def scan(self, cursor=0, match=None, count=100):
+        keys = sorted(
+            k for k in self.store
+            if match is None or fnmatch.fnmatch(k, match)
+        )
+        if cursor >= len(keys):
+            return 0, []
+        batch = keys[cursor:cursor + count]
+        next_cursor = cursor + len(batch)
+        if next_cursor >= len(keys):
+            return 0, batch
+        return next_cursor, batch
+
+
+class _FakeRedisLock:
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *exc):
+        return False
+
+
+class _FakeRedisPipeline:
+    def __init__(self, redis):
+        self._redis = redis
+        self._ops = []
+
+    def get(self, key):
+        self._ops.append(("get", key))
+
+    def delete(self, key):
+        self._ops.append(("delete", key))
+
+    def execute(self):
+        results = []
+        for op, key in self._ops:
+            if op == "get":
+                results.append(self._redis.get(key))
+            else:
+                results.append(self._redis.delete(key))
+        self._ops = []
+        return results
+
+
+def _fake_creds(acc, prof):
+    """Distinguishable per-account credentials, mirroring what
+    get_transformed_credentials returns for the reserved profile."""
+    return (f"http://a{acc.id}.test", f"u{acc.id}", "p")
+
+
+class TimeshiftProxyTimestampWiringTests(TestCase):
+    """`timeshift_proxy` must convert the client's UTC timestamp to the
+    serving provider's zone for the upstream URL, while keeping the ORIGINAL
+    UTC timestamp for the EPG duration lookup — the only timezone conversion
+    in the chain."""
+
+    def setUp(self):
+        self.factory = RequestFactory()
+
+    def _call(self, timestamp, provider_tz="Europe/Brussels"):
+        request = self.factory.get(f"/timeshift/u/p/8/{timestamp}/8.ts?session_id={TEST_SESSION_ID}")
+        sentinel = MagicMock(status_code=200)
+        with patch.object(views, "_authenticate_user", return_value=MagicMock(id=5)), \
+             patch.object(views, "network_access_allowed", return_value=True), \
+             patch.object(views, "Channel") as channel_cls, \
+             patch.object(views, "_user_can_access_channel", return_value=True), \
+             patch.object(views, "get_channel_catchup_streams",
+                          return_value=[_make_catchup_stream(provider_tz)]), \
+             patch.object(views, "get_programme_duration", return_value=40) as duration_mock, \
+             patch.object(views, "build_timeshift_candidate_urls",
+                          return_value=["http://example.test/x.ts"]) as build_mock, \
+             patch.object(views, "check_user_stream_limits", return_value=True), \
+             patch.object(views, "RedisClient") as redis_cls, \
+             patch.object(views, "reserve_profile_slot", return_value=(True, 1, None)), \
+             patch.object(views, "release_profile_slot"), \
+             patch.object(views, "get_transformed_credentials", side_effect=_fake_creds), \
+             patch.object(views, "get_user_active_connections", return_value=[]), \
+             patch.object(views, "_stream_from_provider", return_value=sentinel) as stream_mock:
+            redis_cls.get_client.return_value = _FakeRedis()
+            channel_cls.objects.get.return_value = MagicMock(id=8, name="Test", logo_id=None)
+            response = views.timeshift_proxy(request, "u", "p", "8", timestamp, "8.ts")
+        return response, sentinel, build_mock, duration_mock, stream_mock
+
+    def test_candidates_get_provider_local_timestamp(self):
+        # June → CEST: 17:00 UTC must reach the URL builder as 19:00 Brussels.
+        response, sentinel, build_mock, duration_mock, _ = self._call("2026-06-08:17-00")
+        self.assertIs(response, sentinel)
+        self.assertEqual(build_mock.call_args[0][2], "2026-06-08:19-00")
+
+    def test_duration_lookup_keeps_original_utc_timestamp(self):
+        # The EPG is stored in UTC — the duration lookup must NOT receive the
+        # provider-converted value.
+        _, _, _, duration_mock, _ = self._call("2026-06-08:17-00")
+        self.assertEqual(duration_mock.call_args[0][1], "2026-06-08:17-00")
+
+    def test_utc_provider_passes_timestamp_unchanged(self):
+        _, _, build_mock, _, _ = self._call("2026-06-08:17-00", provider_tz="UTC")
+        self.assertEqual(build_mock.call_args[0][2], "2026-06-08:17-00")
+
+    def test_colon_seconds_timestamp_accepted(self):
+        response, sentinel, build_mock, duration_mock, _ = self._call(
+            "2026-06-23:04:00:00"
+        )
+        self.assertIs(response, sentinel)
+        self.assertEqual(duration_mock.call_args[0][1], "2026-06-23:04:00:00")
+
+    def test_invalid_timestamp_rejected_before_upstream(self):
+        request = self.factory.get("/timeshift/u/p/8/garbage/8.ts")
+        with patch.object(views, "_authenticate_user", return_value=MagicMock(id=5)), \
+             patch.object(views, "network_access_allowed", return_value=True), \
+             patch.object(views, "Channel") as channel_cls, \
+             patch.object(views, "_user_can_access_channel", return_value=True), \
+             patch.object(views, "get_channel_catchup_streams") as catchup_mock, \
+             patch.object(views, "_stream_from_provider") as stream_mock:
+            channel_cls.objects.get.return_value = MagicMock(id=8)
+            response = views.timeshift_proxy(request, "u", "p", "8", "garbage", "8.ts")
+        self.assertEqual(response.status_code, 400)
+        catchup_mock.assert_not_called()
+        stream_mock.assert_not_called()
+
+    def test_network_access_denied_returns_403(self):
+        # Same network gate as other XC API endpoints (player_api, xmltv, etc.).
+        request = self.factory.get(_proxy_url())
+        with patch.object(views, "_authenticate_user", return_value=MagicMock(id=5)), \
+             patch.object(views, "network_access_allowed", return_value=False) as gate, \
+             patch.object(views, "Channel") as channel_cls, \
+             patch.object(views, "_stream_from_provider") as stream_mock:
+            response = views.timeshift_proxy(
+                request, "u", "p", "8", "2026-06-08:17-00", "8.ts"
+            )
+        self.assertEqual(response.status_code, 403)
+        self.assertEqual(gate.call_args[0][1], "XC_API")
+        channel_cls.objects.get.assert_not_called()
+        stream_mock.assert_not_called()
+
+
+class TimeshiftProxyFailoverTests(TestCase):
+    """When the first catch-up stream's provider cannot serve the archive,
+    the proxy must fail over to the channel's next catch-up stream — each
+    attempt with its own provider context."""
+
+    def setUp(self):
+        self.factory = RequestFactory()
+
+    def _call(self, streams, provider_responses):
+        request = self.factory.get(_proxy_url())
+        with patch.object(views, "_authenticate_user", return_value=MagicMock(id=5)), \
+             patch.object(views, "network_access_allowed", return_value=True), \
+             patch.object(views, "Channel") as channel_cls, \
+             patch.object(views, "_user_can_access_channel", return_value=True), \
+             patch.object(views, "get_channel_catchup_streams", return_value=streams), \
+             patch.object(views, "get_programme_duration", return_value=40), \
+             patch.object(views, "build_timeshift_candidate_urls",
+                          return_value=["http://example.test/x.ts"]) as build_mock, \
+             patch.object(views, "check_user_stream_limits", return_value=True) as limits_mock, \
+             patch.object(views, "RedisClient") as redis_cls, \
+             patch.object(views, "reserve_profile_slot", return_value=(True, 1, None)), \
+             patch.object(views, "release_profile_slot"), \
+             patch.object(views, "get_transformed_credentials",
+                          side_effect=_fake_creds) as creds_mock, \
+             patch.object(views, "get_user_active_connections", return_value=[]), \
+             patch.object(views, "_stream_from_provider",
+                          side_effect=provider_responses) as stream_mock:
+            redis_cls.get_client.return_value = _FakeRedis()
+            channel_cls.objects.get.return_value = MagicMock(id=8, name="Test", logo_id=None)
+            response = views.timeshift_proxy(
+                request, "u", "p", "8", "2026-06-08:17-00", "8.ts"
+            )
+        self.creds_mock = creds_mock
+        return response, stream_mock, build_mock, limits_mock
+
+    def test_second_stream_serves_after_first_fails(self):
+        streams = [
+            _make_catchup_stream(account_id=1, stream_id="111"),
+            _make_catchup_stream(account_id=2, stream_id="222"),
+        ]
+        ok = MagicMock(status_code=200)
+        response, stream_mock, build_mock, _ = self._call(
+            streams, [MagicMock(status_code=404), ok]
+        )
+        self.assertIs(response, ok)
+        self.assertEqual(stream_mock.call_count, 2)
+        # Each attempt used its own provider context: credentials resolved per
+        # account/profile (via get_transformed_credentials) and its stream id.
+        self.assertEqual(
+            [c.args[0] for c in build_mock.call_args_list],
+            [("http://a1.test", "u1", "p"), ("http://a2.test", "u2", "p")],
+        )
+        self.assertEqual(
+            [c.args[0] for c in self.creds_mock.call_args_list],
+            [streams[0].m3u_account, streams[1].m3u_account],
+        )
+        self.assertEqual(
+            [c.args[1] for c in build_mock.call_args_list], ["111", "222"]
+        )
+        self.assertEqual(
+            [c.kwargs["account_id"] for c in stream_mock.call_args_list], [1, 2]
+        )
+
+    def test_all_streams_fail_returns_last_failure(self):
+        streams = [
+            _make_catchup_stream(account_id=1, stream_id="111"),
+            _make_catchup_stream(account_id=2, stream_id="222"),
+        ]
+        last = MagicMock(status_code=404)
+        response, stream_mock, _, _ = self._call(
+            streams, [MagicMock(status_code=400), last]
+        )
+        self.assertIs(response, last)
+        self.assertEqual(stream_mock.call_count, 2)
+
+    def test_non_xc_and_missing_stream_id_are_skipped(self):
+        streams = [
+            _make_catchup_stream(account_id=1, account_type="M3U"),
+            _make_catchup_stream(account_id=2, stream_id=None),
+            _make_catchup_stream(account_id=3, stream_id="333"),
+        ]
+        ok = MagicMock(status_code=200)
+        response, stream_mock, _, _ = self._call(streams, [ok])
+        self.assertIs(response, ok)
+        # Only the eligible third stream produced an upstream attempt.
+        self.assertEqual(stream_mock.call_count, 1)
+        self.assertEqual(stream_mock.call_args.kwargs["account_id"], 3)
+
+    def test_stream_limits_checked_once_for_the_request(self):
+        streams = [
+            _make_catchup_stream(account_id=1, stream_id="111"),
+            _make_catchup_stream(account_id=2, stream_id="222"),
+        ]
+        _, _, _, limits_mock = self._call(
+            streams, [MagicMock(status_code=404), MagicMock(status_code=200)]
+        )
+        self.assertEqual(limits_mock.call_count, 1)
+
+    def test_passthrough_is_not_failed_over_to_other_accounts(self):
+        # A terminal range answer (e.g. 416 past EOF) must be returned as-is;
+        # the loop must NOT try the next account, whose byte offsets would not
+        # match this file and which would just burn another provider slot.
+        streams = [
+            _make_catchup_stream(account_id=1, stream_id="111"),
+            _make_catchup_stream(account_id=2, stream_id="222"),
+        ]
+        passthrough = MagicMock(status_code=416)
+        passthrough.timeshift_passthrough = True
+        response, stream_mock, _, _ = self._call(streams, [passthrough])
+        self.assertIs(response, passthrough)
+        self.assertEqual(stream_mock.call_count, 1)
+
+
+class _ProxyLoopTestMixin:
+    """Shared driver for tests exercising the failover loop end to end —
+    pool reservation, credential resolution and Redis are all controlled."""
+
+    def setUp(self):
+        self.factory = RequestFactory()
+
+    def _call(self, streams, provider_responses, limits=True, reserve_results=None,
+              build_side_effect=None):
+        request = self.factory.get(_proxy_url())
+        self.fake_redis = _FakeRedis()
+        reserve_kwargs = (
+            {"side_effect": reserve_results}
+            if reserve_results is not None
+            else {"return_value": (True, 1, None)}
+        )
+        build_kwargs = (
+            {"side_effect": build_side_effect}
+            if build_side_effect is not None
+            else {"return_value": ["http://example.test/x.ts"]}
+        )
+        with patch.object(views, "_authenticate_user", return_value=MagicMock(id=5)), \
+             patch.object(views, "network_access_allowed", return_value=True), \
+             patch.object(views, "Channel") as channel_cls, \
+             patch.object(views, "_user_can_access_channel", return_value=True), \
+             patch.object(views, "get_channel_catchup_streams", return_value=streams), \
+             patch.object(views, "get_programme_duration", return_value=40), \
+             patch.object(views, "build_timeshift_candidate_urls",
+                          **build_kwargs) as build_mock, \
+             patch.object(views, "check_user_stream_limits", return_value=limits), \
+             patch.object(views, "RedisClient") as redis_cls, \
+             patch.object(views, "reserve_profile_slot", **reserve_kwargs) as reserve_mock, \
+             patch.object(views, "release_profile_slot") as release_mock, \
+             patch.object(views, "get_transformed_credentials",
+                          side_effect=_fake_creds) as creds_mock, \
+             patch.object(views, "get_user_active_connections", return_value=[]), \
+             patch.object(views, "_stream_from_provider",
+                          side_effect=provider_responses) as stream_mock:
+            redis_cls.get_client.return_value = self.fake_redis
+            channel_cls.objects.get.return_value = MagicMock(id=8, name="Test", logo_id=None)
+            # Exposed before the call so raising tests can still assert on them.
+            self.reserve_mock = reserve_mock
+            self.release_mock = release_mock
+            self.creds_mock = creds_mock
+            self.stream_mock = stream_mock
+            response = views.timeshift_proxy(
+                request, "u", "p", "8", "2026-06-08:17-00", "8.ts"
+            )
+        return response, stream_mock, build_mock
+
+
+class TimeshiftProxyFailoverHardeningTests(_ProxyLoopTestMixin, TestCase):
+    """Ban-safety and per-provider context guarantees of the failover loop."""
+
+    def test_decisive_failure_skips_same_accounts_other_streams(self):
+        # Account 1 carries two variants (e.g. FHD + HD). A decisive
+        # (auth/ban-class) failure on the first must NOT retry account 1's
+        # second stream — that would hammer a banning provider — but a
+        # DIFFERENT account stays fair game.
+        streams = [
+            _make_catchup_stream(account_id=1, stream_id="111"),
+            _make_catchup_stream(account_id=1, stream_id="112"),
+            _make_catchup_stream(account_id=2, stream_id="222"),
+        ]
+        decisive = MagicMock(status_code=403, timeshift_decisive=True)
+        ok = MagicMock(status_code=200)
+        response, stream_mock, _ = self._call(streams, [decisive, ok])
+        self.assertIs(response, ok)
+        self.assertEqual(stream_mock.call_count, 2)
+        self.assertEqual(
+            [c.kwargs["account_id"] for c in stream_mock.call_args_list], [1, 2]
+        )
+
+    def test_soft_failure_still_tries_same_accounts_other_streams(self):
+        # A soft failure (404: this stream's archive missing) is stream-
+        # specific — the same account's other variant may still have it.
+        streams = [
+            _make_catchup_stream(account_id=1, stream_id="111"),
+            _make_catchup_stream(account_id=1, stream_id="112"),
+        ]
+        soft = MagicMock(status_code=404, timeshift_decisive=False)
+        ok = MagicMock(status_code=200)
+        response, stream_mock, _ = self._call(streams, [soft, ok])
+        self.assertIs(response, ok)
+        self.assertEqual(stream_mock.call_count, 2)
+        self.assertEqual(
+            [c.kwargs["account_id"] for c in stream_mock.call_args_list], [1, 1]
+        )
+
+    def test_each_stream_uses_its_own_provider_timezone(self):
+        # June: 17:00 UTC = 19:00 Brussels (CEST) but 13:00 New York (EDT).
+        # The converted timestamp must be recomputed per attempt.
+        streams = [
+            _make_catchup_stream(account_id=1, stream_id="111",
+                                 provider_tz="Europe/Brussels"),
+            _make_catchup_stream(account_id=2, stream_id="222",
+                                 provider_tz="America/New_York"),
+        ]
+        response, _, build_mock = self._call(
+            streams,
+            [MagicMock(status_code=404, timeshift_decisive=False),
+             MagicMock(status_code=200)],
+        )
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(
+            [c.args[2] for c in build_mock.call_args_list],
+            ["2026-06-08:19-00", "2026-06-08:13-00"],
+        )
+
+    def test_stream_limit_exceeded_returns_403_before_upstream(self):
+        streams = [_make_catchup_stream(account_id=1, stream_id="111")]
+        response, stream_mock, _ = self._call(streams, [], limits=False)
+        self.assertEqual(response.status_code, 403)
+        stream_mock.assert_not_called()
+
+    def test_no_catchup_streams_returns_400(self):
+        response, stream_mock, _ = self._call([], [])
+        self.assertEqual(response.status_code, 400)
+        stream_mock.assert_not_called()
+
+    def test_all_streams_ineligible_returns_400(self):
+        streams = [
+            _make_catchup_stream(account_id=1, account_type="M3U"),
+            _make_catchup_stream(account_id=2, stream_id=None),
+        ]
+        response, stream_mock, _ = self._call(streams, [])
+        self.assertEqual(response.status_code, 400)
+        stream_mock.assert_not_called()
+
+
+class XcServerInfoUtcTests(TestCase):
+    """The XC server_info 'timezone triple' guarantee the timeshift chain
+    relies on: server_info.timezone is always UTC and time_now is UTC
+    wall-clock. (Tested here because catch-up seek correctness depends on
+    it: clients build the timeshift URL from this declared zone.)"""
+
+    def test_server_info_is_strictly_utc(self):
+        from datetime import datetime, timezone as dt_timezone
+        from apps.output.views import _build_xc_server_info
+
+        request = MagicMock(scheme="http")
+        info = _build_xc_server_info(request, "example.test", "9191")
+        self.assertEqual(info["timezone"], "UTC")
+        reported = datetime.strptime(info["time_now"], "%Y-%m-%d %H:%M:%S")
+        now_utc = datetime.now(dt_timezone.utc).replace(tzinfo=None)
+        self.assertLess(abs((now_utc - reported).total_seconds()), 60)
+        self.assertIsInstance(info["timestamp_now"], int)
+
+
+class StreamFromProviderDecisiveEdgeTests(TestCase):
+    """Remaining decisive-status and transport-error paths of the cascade."""
+
+    def setUp(self):
+        self.kwargs = dict(
+            candidate_urls=[
+                "http://example.test/timeshift/u/p/60/2026-05-12:17-00/1.ts",
+                "http://example.test/streaming/timeshift.php?stream=1&start=2026-05-12_17-00",
+            ],
+            user_agent="test-agent",
+            range_header=None,
+            virtual_channel_id="timeshift_1_2026-05-12-17-00_1",
+            client_id="timeshift_test456",
+            client_ip="127.0.0.1",
+            user=None,
+            channel_display_name="Test",
+            timestamp_utc="2026-05-12:17-00",
+            channel_logo_id=None,
+            m3u_profile_id=None,
+            debug=False,
+        )
+
+    @patch.object(views, "_open_upstream")
+    def test_406_is_decisive_and_marks_response(self, mocked_open):
+        # 406 = IP-wide block in the XC ban escalation — single attempt,
+        # generic 400 to the client, and the failover loop must see the
+        # decisive marker so it skips this account's other streams.
+        mocked_open.return_value = _fake_upstream(406)
+        response = views._stream_from_provider(**self.kwargs)
+        self.assertEqual(response.status_code, 400)
+        self.assertEqual(mocked_open.call_count, 1)
+        self.assertTrue(response.timeshift_decisive)
+
+    @patch.object(views, "_open_upstream")
+    def test_404_failure_is_not_decisive(self, mocked_open):
+        mocked_open.return_value = _fake_upstream(404)
+        response = views._stream_from_provider(**self.kwargs)
+        self.assertEqual(response.status_code, 404)
+        self.assertFalse(response.timeshift_decisive)
+
+    @patch.object(views, "_open_upstream")
+    def test_connection_error_returns_400_after_single_attempt(self, mocked_open):
+        import requests as _requests
+        mocked_open.side_effect = _requests.exceptions.ConnectionError("boom")
+        response = views._stream_from_provider(**self.kwargs)
+        self.assertEqual(response.status_code, 400)
+        self.assertEqual(mocked_open.call_count, 1)
+        # Transport errors are host-level, not auth/ban-class: the failover
+        # loop may still try a different account.
+        self.assertFalse(getattr(response, "timeshift_decisive", False))
+
+
+class CatchupStreamsDbTests(TestCase):
+    """get_channel_catchup_streams: the function that defines the failover
+    order — channelstream order, catch-up streams only, active accounts only."""
+
+    @classmethod
+    def setUpTestData(cls):
+        from apps.channels.models import Channel, ChannelStream, Stream
+        from apps.m3u.models import M3UAccount
+
+        cls.active = M3UAccount.objects.create(
+            name="ts-test-active", server_url="http://example.test",
+            account_type="XC", is_active=True,
+        )
+        cls.inactive = M3UAccount.objects.create(
+            name="ts-test-inactive", server_url="http://example.test",
+            account_type="XC", is_active=False,
+        )
+        cls.channel = Channel.objects.create(name="ts-test-channel", is_catchup=True)
+
+        def add(name, account, *, catchup, order):
+            s = Stream.objects.create(
+                name=name, url=f"http://example.test/{name}",
+                m3u_account=account, is_catchup=catchup,
+            )
+            ChannelStream.objects.create(channel=cls.channel, stream=s, order=order)
+            return s
+
+        cls.s_inactive = add("s-inactive", cls.inactive, catchup=True, order=0)
+        cls.s_second = add("s-second", cls.active, catchup=True, order=2)
+        cls.s_first = add("s-first", cls.active, catchup=True, order=1)
+        cls.s_live_only = add("s-live-only", cls.active, catchup=False, order=3)
+
+    def test_ordered_active_catchup_streams_only(self):
+        from apps.channels.utils import get_channel_catchup_streams
+
+        result = get_channel_catchup_streams(self.channel)
+        # Inactive-account and non-catchup streams excluded; channelstream order.
+        self.assertEqual([s.id for s in result], [self.s_first.id, self.s_second.id])
+
+    def test_channel_without_catchup_flag_returns_empty(self):
+        from apps.channels.models import Channel
+        from apps.channels.utils import get_channel_catchup_streams
+
+        ch = Channel.objects.create(name="ts-test-nocatchup", is_catchup=False)
+        self.assertEqual(get_channel_catchup_streams(ch), [])
+
+
+class AuthHelpersDbTests(TestCase):
+    """_authenticate_user (xc_password custom property) and
+    _user_can_access_channel (user_level gate) — exercised against real models
+    instead of being mocked away."""
+
+    @classmethod
+    def setUpTestData(cls):
+        from apps.accounts.models import User
+        from apps.channels.models import Channel
+
+        cls.viewer = User.objects.create(
+            username="ts-test-viewer", user_level=0,
+            custom_properties={"xc_password": "right-pass"},
+        )
+        cls.no_xc = User.objects.create(
+            username="ts-test-noxc", user_level=10,
+            custom_properties={},
+        )
+        cls.basic_channel = Channel.objects.create(name="ts-test-basic", user_level=0)
+        cls.admin_channel = Channel.objects.create(name="ts-test-adult", user_level=10)
+
+    def test_valid_xc_password_authenticates(self):
+        user = views._authenticate_user("ts-test-viewer", "right-pass")
+        self.assertIsNotNone(user)
+        self.assertEqual(user.id, self.viewer.id)
+
+    def test_wrong_xc_password_rejected(self):
+        self.assertIsNone(views._authenticate_user("ts-test-viewer", "wrong"))
+
+    def test_user_without_xc_password_rejected(self):
+        # Accounts with no xc_password set (e.g. admins) must be denied even
+        # if the caller guesses any string — there is nothing to compare to.
+        self.assertIsNone(views._authenticate_user("ts-test-noxc", ""))
+        self.assertIsNone(views._authenticate_user("ts-test-noxc", "anything"))
+
+    def test_unknown_username_rejected(self):
+        self.assertIsNone(views._authenticate_user("ts-test-ghost", "x"))
+
+    def test_user_level_gate(self):
+        # Level-0 viewer with no profiles: allowed on level-0, denied on level-10.
+        self.assertTrue(views._user_can_access_channel(self.viewer, self.basic_channel))
+        self.assertFalse(views._user_can_access_channel(self.viewer, self.admin_channel))
+
+
+class TimeshiftSlotPoolTests(_ProxyLoopTestMixin, TestCase):
+    """Provider pool participation: a profile slot is reserved before any
+    upstream attempt and released exactly once afterwards, the same accounting
+    contract live (Channel.get_stream) and VOD follow. Each active stream
+    reserves its own slot so concurrent provider connections stay capped by
+    max_streams."""
+
+    POOL_KEY = f"timeshift_pool:{TEST_SESSION_ID}"
+
+    def _pool_entry_ids(self):
+        return [k for k in self.fake_redis.store if k.startswith("timeshift_pool:")]
+
+    def test_reserve_called_with_default_profile_before_upstream(self):
+        streams = [_make_catchup_stream(account_id=1, stream_id="111", profile_id=31)]
+        response, stream_mock, _ = self._call(streams, [MagicMock(status_code=200)])
+        self.assertEqual(response.status_code, 200)
+        self.reserve_mock.assert_called_once()
+        reserved_profile = self.reserve_mock.call_args.args[0]
+        self.assertEqual(reserved_profile.id, 31)
+        # The reserved profile's id is what reaches the stats metadata.
+        self.assertEqual(stream_mock.call_args.kwargs["m3u_profile_id"], 31)
+
+    def test_slot_released_after_failed_attempt(self):
+        streams = [_make_catchup_stream(account_id=1, stream_id="111", profile_id=31)]
+        response, _, _ = self._call(
+            streams, [MagicMock(status_code=404, timeshift_decisive=False)]
+        )
+        self.assertEqual(response.status_code, 404)
+        # The failed attempt's slot was released and its pool entry removed.
+        self.release_mock.assert_called_once_with(31, self.fake_redis)
+        self.assertEqual(self._pool_entry_ids(), [])
+
+    def test_slot_kept_on_success_for_the_streaming_session(self):
+        streams = [_make_catchup_stream(account_id=1, stream_id="111", profile_id=31)]
+        response, _, _ = self._call(streams, [MagicMock(status_code=200)])
+        self.assertEqual(response.status_code, 200)
+        # Slot still owned by the (mocked) streaming session: a busy pool entry
+        # remains for the next request to reuse, nothing released yet.
+        self.release_mock.assert_not_called()
+        self.assertEqual(len(self._pool_entry_ids()), 1)
+
+    def test_decisive_failure_releases_slot_and_skips_account(self):
+        streams = [
+            _make_catchup_stream(account_id=1, stream_id="111", profile_id=31),
+            _make_catchup_stream(account_id=1, stream_id="112", profile_id=31),
+        ]
+        response, stream_mock, _ = self._call(
+            streams, [MagicMock(status_code=403, timeshift_decisive=True)]
+        )
+        self.assertEqual(response.status_code, 403)
+        self.assertEqual(stream_mock.call_count, 1)
+        self.release_mock.assert_called_once_with(31, self.fake_redis)
+        # Decisive skip means the second stream never reserved a slot.
+        self.assertEqual(self.reserve_mock.call_count, 1)
+
+    def test_profile_full_walks_to_next_profile_same_account(self):
+        alt = _make_alt_profile(32)
+        streams = [_make_catchup_stream(
+            account_id=1, stream_id="111", profile_id=31, extra_profiles=(alt,)
+        )]
+        response, stream_mock, _ = self._call(
+            streams, [MagicMock(status_code=200)],
+            reserve_results=[(False, 1, "profile_full"), (True, 1, None)],
+        )
+        self.assertEqual(response.status_code, 200)
+        # Default profile full -> alternate profile reserved and used.
+        self.assertEqual(
+            [c.args[0].id for c in self.reserve_mock.call_args_list], [31, 32]
+        )
+        self.assertEqual(stream_mock.call_args.kwargs["m3u_profile_id"], 32)
+        # Credentials were resolved for the RESERVED (alternate) profile.
+        self.assertIs(self.creds_mock.call_args.args[1], alt)
+
+    def test_all_profiles_full_returns_503_without_upstream_attempt(self):
+        streams = [
+            _make_catchup_stream(account_id=1, stream_id="111", profile_id=31),
+            _make_catchup_stream(account_id=2, stream_id="222", profile_id=41),
+        ]
+        response, stream_mock, _ = self._call(
+            streams, [],
+            reserve_results=[
+                (False, 1, "profile_full"),
+                (False, 1, "credential_full"),
+            ],
+        )
+        # Pool capacity exhausted everywhere: 503 (VOD's pool-exhausted
+        # status), and crucially the provider was never contacted.
+        self.assertEqual(response.status_code, 503)
+        stream_mock.assert_not_called()
+        self.release_mock.assert_not_called()
+
+    def test_capacity_failure_is_not_decisive_for_the_account(self):
+        # profile_full on account 1's first stream must NOT mark account 1
+        # decisive — capacity is transient, unlike a ban-class status.
+        streams = [
+            _make_catchup_stream(account_id=1, stream_id="111", profile_id=31),
+            _make_catchup_stream(account_id=1, stream_id="112", profile_id=31),
+        ]
+        response, stream_mock, _ = self._call(
+            streams, [MagicMock(status_code=200)],
+            reserve_results=[(False, 1, "profile_full"), (True, 1, None)],
+        )
+        self.assertEqual(response.status_code, 200)
+        # Second stream of the SAME account still got its reservation attempt.
+        self.assertEqual(self.reserve_mock.call_count, 2)
+        self.assertEqual(stream_mock.call_count, 1)
+
+    def test_account_without_active_default_profile_is_skipped(self):
+        # Mirrors live dispatch: no active default profile -> skip the account
+        # without reserving anything.
+        stream = _make_catchup_stream(account_id=1, stream_id="111")
+        stream.m3u_account.profiles.filter.return_value = [_make_alt_profile(32)]
+        response, stream_mock, _ = self._call([stream], [])
+        self.assertEqual(response.status_code, 400)
+        self.reserve_mock.assert_not_called()
+        stream_mock.assert_not_called()
+
+    def test_exception_from_provider_releases_slot(self):
+        # An unexpected exception between reserve and response construction
+        # must release the slot before propagating — otherwise the counter
+        # (no TTL) leaks until the next Redis flush.
+        streams = [_make_catchup_stream(account_id=1, stream_id="111", profile_id=31)]
+        with self.assertRaises(RuntimeError):
+            self._call(streams, RuntimeError("boom"))
+        self.release_mock.assert_called_once_with(31, self.fake_redis)
+        self.assertEqual(self._pool_entry_ids(), [])
+
+    def test_exception_before_upstream_releases_slot(self):
+        # Same guarantee for failures BEFORE the upstream call (URL building,
+        # credential resolution, user-agent lookup) — the guarded window
+        # starts right after the reservation.
+        streams = [_make_catchup_stream(account_id=1, stream_id="111", profile_id=31)]
+        with self.assertRaises(RuntimeError):
+            self._call(streams, [], build_side_effect=RuntimeError("boom"))
+        self.stream_mock.assert_not_called()
+        self.release_mock.assert_called_once_with(31, self.fake_redis)
+        self.assertEqual(self._pool_entry_ids(), [])
+
+    def test_mixed_capacity_then_upstream_failure_returns_failure(self):
+        # Mixed outcome: one stream capacity-blocked, another actually tried
+        # upstream and failed -> the REAL upstream failure wins over 503
+        # (capacity was not the sole blocker).
+        streams = [
+            _make_catchup_stream(account_id=1, stream_id="111", profile_id=31),
+            _make_catchup_stream(account_id=2, stream_id="222", profile_id=41),
+        ]
+        response, _, _ = self._call(
+            streams,
+            [MagicMock(status_code=404, timeshift_decisive=False)],
+            reserve_results=[(False, 1, "profile_full"), (True, 1, None)],
+        )
+        self.assertEqual(response.status_code, 404)
+
+    def test_mixed_upstream_failure_then_capacity_returns_failure(self):
+        # Same in the opposite order.
+        streams = [
+            _make_catchup_stream(account_id=1, stream_id="111", profile_id=31),
+            _make_catchup_stream(account_id=2, stream_id="222", profile_id=41),
+        ]
+        response, _, _ = self._call(
+            streams,
+            [MagicMock(status_code=404, timeshift_decisive=False)],
+            reserve_results=[(True, 1, None), (False, 1, "profile_full")],
+        )
+        self.assertEqual(response.status_code, 404)
+
+
+class TimeshiftPoolReleaseTests(TestCase):
+    """Pool slot release and response close paths for a pooled session."""
+
+    def setUp(self):
+        self.redis = _FakeRedis()
+        self.session_id = TEST_SESSION_ID
+
+    def _pool_key(self):
+        return f"timeshift_pool:{self.session_id}"
+
+    def test_release_callback_frees_slot_exactly_once(self):
+        _seed_pool_session(self.redis, session_id=self.session_id)
+        release = views._make_release_once(self.redis, self.session_id, 31)
+        with patch.object(views, "release_profile_slot") as release_mock:
+            release()
+            release()
+        release_mock.assert_called_once_with(31, self.redis)
+        self.assertEqual(self.redis.hget(self._pool_key(), "busy"), "0")
+        self.assertTrue(self.redis.exists(self._pool_key()))
+
+    def test_discard_frees_slot_and_removes_entry(self):
+        _seed_pool_session(self.redis, session_id=self.session_id)
+        with patch.object(views, "release_profile_slot") as release_mock:
+            views._discard_pool_session(self.redis, self.session_id, 31)
+        release_mock.assert_called_once_with(31, self.redis)
+        self.assertFalse(self.redis.exists(self._pool_key()))
+
+    def test_release_without_redis_is_noop(self):
+        release = views._make_release_once(None, self.session_id, 31)
+        with patch.object(views, "release_profile_slot") as release_mock:
+            release()
+        release_mock.assert_not_called()
+
+    def test_wrapper_close_releases_even_when_generator_never_started(self):
+        # The WSGI layer can close the response before the first chunk is
+        # pulled; closing a never-started generator runs NO body code, so the
+        # generator's own finally cannot be the only release point.
+        finally_ran = []
+
+        def gen():
+            try:
+                yield b"x"
+            finally:
+                finally_ran.append(True)
+
+        on_close = MagicMock()
+        wrapper = views._SlotReleasingStream(gen(), on_close)
+        wrapper.close()
+        on_close.assert_called_once()
+        self.assertEqual(finally_ran, [])  # proves the leak this wrapper fixes
+
+    def test_streaming_response_close_invokes_wrapper_close(self):
+        # Locks the Django contract the wrapper relies on: an iterator with a
+        # close() method is registered as a resource closer of the response.
+        from django.http import StreamingHttpResponse
+
+        on_close = MagicMock()
+        wrapper = views._SlotReleasingStream(iter([b"x"]), on_close)
+        response = StreamingHttpResponse(wrapper, content_type="video/mp2t")
+        response.close()
+        on_close.assert_called_once()
+
+
+class TimeshiftTakeoverTests(TestCase):
+    """A new request displaces the user's previous catch-up session(s) on the
+    same channel at a DIFFERENT position (stats unregister + stop key, leaving
+    the displaced generator to free its own slot), while leaving sibling range
+    requests of the same playback alone, and never touching other users,
+    channels, or live."""
+
+    def setUp(self):
+        self.redis = _FakeRedis()
+        self.user = MagicMock(id=5)
+
+    def _conn(self, media_id, client_id, conn_type="timeshift"):
+        return {
+            "media_id": media_id,
+            "client_id": client_id,
+            "connected_at": 0.0,
+            "type": conn_type,
+        }
+
+    def test_displaces_other_positions_on_same_channel(self):
+        connections = [
+            self._conn("timeshift_8_2026-06-08-17-00_111", "timeshift_old1"),
+            self._conn("timeshift_9_2026-06-08-17-00_222", "timeshift_other"),
+            self._conn("42", "live_client", conn_type="live"),
+        ]
+        with patch.object(views, "get_user_active_connections",
+                          return_value=connections) as conns_mock, \
+             patch.object(views, "release_profile_slot") as release_mock, \
+             patch.object(views, "_unregister_stats_client") as unregister_mock:
+            views._terminate_previous_timeshift_sessions(
+                self.redis, self.user, 8, "timeshift_8_2026-06-09-20-00", "timeshift_current",
+            )
+        conns_mock.assert_called_once_with(5)
+        # Takeover defers slot release to the displaced generator's stop path;
+        # it only drops stats and signals the stop key.
+        release_mock.assert_not_called()
+        unregister_mock.assert_called_once_with(
+            self.redis, "timeshift_8_2026-06-08-17-00_111", "timeshift_old1"
+        )
+        from apps.proxy.live_proxy.redis_keys import RedisKeys
+        stop_key = RedisKeys.client_stop(
+            "timeshift_8_2026-06-08-17-00_111", "timeshift_old1"
+        )
+        self.assertIn(stop_key, self.redis.store)
+        # Channel 9's session untouched: no stop key set for it.
+        other_stop = RedisKeys.client_stop(
+            "timeshift_9_2026-06-08-17-00_222", "timeshift_other"
+        )
+        self.assertNotIn(other_stop, self.redis.store)
+
+    def test_leaves_sibling_requests_of_current_playback(self):
+        # Concurrent range/probe requests of the SAME playback must not
+        # displace one another.
+        connections = [
+            self._conn("timeshift_8_2026-06-08-17-00_111", "timeshift_sibling"),
+        ]
+        with patch.object(views, "get_user_active_connections",
+                          return_value=connections), \
+             patch.object(views, "release_profile_slot") as release_mock, \
+             patch.object(views, "_unregister_stats_client") as unregister_mock:
+            views._terminate_previous_timeshift_sessions(
+                self.redis, self.user, 8, "timeshift_8_2026-06-08-17-00",
+                "timeshift_sibling",
+            )
+        release_mock.assert_not_called()
+        unregister_mock.assert_not_called()
+
+    def test_channel_id_prefix_cannot_match_other_channels(self):
+        # Channel 8 must not displace channel 80/81 sessions (prefix ends
+        # with an underscore).
+        connections = [
+            self._conn("timeshift_80_2026-06-08-17-00_111", "timeshift_c80"),
+        ]
+        with patch.object(views, "get_user_active_connections",
+                          return_value=connections), \
+             patch.object(views, "release_profile_slot") as release_mock, \
+             patch.object(views, "_unregister_stats_client") as unregister_mock:
+            views._terminate_previous_timeshift_sessions(
+                self.redis, self.user, 8, "timeshift_8_2026-06-08-17-00",
+                "timeshift_new",
+            )
+        release_mock.assert_not_called()
+        unregister_mock.assert_not_called()
+
+    def test_noop_without_redis_or_user(self):
+        with patch.object(views, "get_user_active_connections") as conns_mock:
+            views._terminate_previous_timeshift_sessions(
+                None, self.user, 8, "timeshift_8_ts", "timeshift_s"
+            )
+            views._terminate_previous_timeshift_sessions(
+                self.redis, None, 8, "timeshift_8_ts", "timeshift_s"
+            )
+        conns_mock.assert_not_called()
+
+    def test_proxy_runs_takeover_before_stream_limit_check(self):
+        # Order matters: with terminate_on_limit_exceeded=False a seek must
+        # displace its own predecessor BEFORE the limit check counts it, or
+        # the user's own seek gets denied.
+        call_order = []
+        request = RequestFactory().get(_proxy_url())
+        with patch.object(views, "_authenticate_user", return_value=MagicMock(id=5)), \
+             patch.object(views, "network_access_allowed", return_value=True), \
+             patch.object(views, "Channel") as channel_cls, \
+             patch.object(views, "_user_can_access_channel", return_value=True), \
+             patch.object(views, "get_channel_catchup_streams",
+                          return_value=[_make_catchup_stream()]), \
+             patch.object(views, "get_programme_duration", return_value=40), \
+             patch.object(views, "RedisClient") as redis_cls, \
+             patch.object(views, "_terminate_previous_timeshift_sessions",
+                          side_effect=lambda *a: call_order.append("takeover")) as takeover_mock, \
+             patch.object(views, "check_user_stream_limits",
+                          side_effect=lambda *a, **k: call_order.append("limits") or False):
+            redis_cls.get_client.return_value = self.redis
+            channel_cls.objects.get.return_value = MagicMock(id=8, name="Test", logo_id=None)
+            response = views.timeshift_proxy(
+                request, "u", "p", "8", "2026-06-08:17-00", "8.ts"
+            )
+        self.assertEqual(response.status_code, 403)
+        self.assertEqual(call_order, ["takeover", "limits"])
+        self.assertEqual(takeover_mock.call_args.args[2], 8)
+
+
+class TimeshiftSessionReuseTests(TestCase):
+    """Per-client session pool acquire/reuse paths."""
+
+    SESSION = TEST_SESSION_ID
+
+    def setUp(self):
+        self.redis = _FakeRedis()
+        self.factory = RequestFactory()
+        self.channel = MagicMock(id=8, name="Test")
+        self.user = MagicMock(id=5)
+
+    def _pool_key(self):
+        return f"timeshift_pool:{self.SESSION}"
+
+    def _make_idle_entry(self):
+        _seed_pool_session(self.redis, session_id=self.SESSION)
+        with patch.object(views, "release_profile_slot"):
+            views._release_pool_session(self.redis, self.SESSION, 31)
+
+    def test_wait_returns_none_without_blocking_when_pool_empty(self):
+        start = time.monotonic()
+        acquired = views._wait_for_idle_pool_session(self.redis, self.SESSION)
+        self.assertIsNone(acquired)
+        self.assertLess(time.monotonic() - start, 0.5)
+
+    def test_acquire_reuses_idle_entry_and_reserves_slot(self):
+        self._make_idle_entry()
+        profile = MagicMock(id=31)
+        with patch.object(views.M3UAccountProfile.objects, "get",
+                          return_value=profile), \
+             patch.object(views, "reserve_profile_slot",
+                          return_value=(True, 1, None)) as reserve_mock:
+            acquired = views._acquire_idle_pool_session(
+                self.redis, self.SESSION, user_id=5,
+            )
+        self.assertIsNotNone(acquired)
+        descriptor, got_profile = acquired
+        self.assertEqual(descriptor["stream_id"], "111")
+        self.assertIs(got_profile, profile)
+        reserve_mock.assert_called_once_with(profile, self.redis)
+        self.assertEqual(self.redis.hget(self._pool_key(), "busy"), "1")
+
+    def test_acquire_skips_busy_entry(self):
+        _seed_pool_session(self.redis, session_id=self.SESSION, busy="1")
+        with patch.object(views.M3UAccountProfile.objects, "get") as prof_mock, \
+             patch.object(views, "reserve_profile_slot") as reserve_mock:
+            acquired = views._acquire_idle_pool_session(
+                self.redis, self.SESSION, user_id=5,
+            )
+        self.assertIsNone(acquired)
+        prof_mock.assert_not_called()
+        reserve_mock.assert_not_called()
+
+    def test_acquire_rejects_foreign_user(self):
+        self._make_idle_entry()
+        profile = MagicMock(id=31)
+        with patch.object(views.M3UAccountProfile.objects, "get",
+                          return_value=profile), \
+             patch.object(views, "reserve_profile_slot",
+                          return_value=(True, 1, None)) as reserve_mock:
+            acquired = views._acquire_idle_pool_session(
+                self.redis, self.SESSION, user_id=99,
+            )
+        self.assertIsNone(acquired)
+        reserve_mock.assert_not_called()
+
+    def test_foreign_session_id_redirects_instead_of_reusing_pool(self):
+        victim_session = "timeshift_victim_session"
+        _seed_pool_session(self.redis, session_id=victim_session, user_id=99)
+        request = self.factory.get(_proxy_url(victim_session))
+        attacker = MagicMock(id=5)
+        with patch.object(views, "_authenticate_user", return_value=attacker), \
+             patch.object(views, "network_access_allowed", return_value=True), \
+             patch.object(views, "Channel") as channel_cls, \
+             patch.object(views, "_user_can_access_channel", return_value=True), \
+             patch.object(views, "get_channel_catchup_streams",
+                          return_value=[_make_catchup_stream()]), \
+             patch.object(views, "get_programme_duration", return_value=40), \
+             patch.object(views, "parse_catchup_timestamp", return_value=True), \
+             patch.object(views, "RedisClient") as redis_cls, \
+             patch.object(views, "_acquire_idle_pool_session") as acquire_mock, \
+             patch.object(views, "_attempt_timeshift_stream") as attempt_mock:
+            redis_cls.get_client.return_value = self.redis
+            channel_cls.objects.get.return_value = MagicMock(id=8)
+            response = views.timeshift_proxy(
+                request, "u", "p", "8", "2026-06-08:17-00", "8.ts",
+            )
+        self.assertEqual(response.status_code, 301)
+        self.assertIn("session_id=timeshift_", response["Location"])
+        self.assertNotIn(victim_session, response["Location"])
+        acquire_mock.assert_not_called()
+        attempt_mock.assert_not_called()
+
+    def test_find_matching_idle_session_requires_ip_and_user_agent(self):
+        _seed_pool_session(
+            self.redis, session_id="timeshift_other",
+            user_id=5, client_ip="1.2.3.4", client_user_agent="test-agent",
+        )
+        with patch.object(views, "release_profile_slot"):
+            views._release_pool_session(self.redis, "timeshift_other", 31)
+        matched = views._find_matching_idle_session(
+            self.redis,
+            media_id=TEST_MEDIA_ID,
+            user_id=5,
+            client_ip="1.2.3.4",
+            client_user_agent="test-agent",
+        )
+        self.assertEqual(matched, "timeshift_other")
+
+    def test_find_matching_idle_session_rejects_ip_only_partial_fingerprint(self):
+        _seed_pool_session(
+            self.redis, session_id="timeshift_other",
+            user_id=5, client_ip="1.2.3.4", client_user_agent="other-agent",
+        )
+        with patch.object(views, "release_profile_slot"):
+            views._release_pool_session(self.redis, "timeshift_other", 31)
+        matched = views._find_matching_idle_session(
+            self.redis,
+            media_id=TEST_MEDIA_ID,
+            user_id=5,
+            client_ip="1.2.3.4",
+            client_user_agent="test-agent",
+        )
+        self.assertIsNone(matched)
+
+    def test_find_matching_idle_session_rejects_different_user(self):
+        _seed_pool_session(
+            self.redis, session_id="timeshift_other",
+            user_id=99, client_ip="1.2.3.4", client_user_agent="test-agent",
+        )
+        with patch.object(views, "release_profile_slot"):
+            views._release_pool_session(self.redis, "timeshift_other", 31)
+        matched = views._find_matching_idle_session(
+            self.redis,
+            media_id=TEST_MEDIA_ID,
+            user_id=5,
+            client_ip="1.2.3.4",
+            client_user_agent="test-agent",
+        )
+        self.assertIsNone(matched)
+
+    def test_legacy_pool_entry_exists_helper_removed(self):
+        self.assertFalse(hasattr(views, "_pool_entry_exists"))
+
+    def test_new_session_uses_single_hgetall_before_pool_create(self):
+        redis = _FakeRedis()
+        request = self.factory.get(_proxy_url("timeshift_newsession1"))
+        with patch.object(views, "_authenticate_user", return_value=MagicMock(id=5)), \
+             patch.object(views, "network_access_allowed", return_value=True), \
+             patch.object(views, "Channel") as channel_cls, \
+             patch.object(views, "_user_can_access_channel", return_value=True), \
+             patch.object(views, "get_channel_catchup_streams",
+                          return_value=[_make_catchup_stream()]), \
+             patch.object(views, "get_programme_duration", return_value=40), \
+             patch.object(views, "check_user_stream_limits", return_value=True), \
+             patch.object(views, "_find_matching_idle_session", return_value=None), \
+             patch.object(views, "_attempt_timeshift_stream",
+                          return_value=MagicMock(status_code=200)), \
+             patch.object(views, "RedisClient") as redis_cls, \
+             patch.object(views, "reserve_profile_slot", return_value=(True, 1, None)), \
+             patch.object(views, "release_profile_slot"), \
+             patch.object(views, "get_transformed_credentials", side_effect=_fake_creds), \
+             patch.object(views, "get_user_active_connections", return_value=[]):
+            redis_cls.get_client.return_value = redis
+            channel_cls.objects.get.return_value = MagicMock(id=8, name="Test", logo_id=None)
+            with patch.object(redis, "hgetall", wraps=redis.hgetall) as hgetall_mock:
+                views.timeshift_proxy(
+                    request, "u", "p", "8", "2026-06-08:17-00", "8.ts",
+                )
+        pool_key = "timeshift_pool:timeshift_newsession1"
+        self.assertEqual(
+            sum(1 for c in hgetall_mock.call_args_list if c.args == (pool_key,)),
+            1,
+        )
+
+
+class TimeshiftSessionRedirectTests(TestCase):
+    """First request must establish a session via 301 redirect (VOD-style)."""
+
+    def setUp(self):
+        self.factory = RequestFactory()
+
+    def test_missing_session_id_redirects(self):
+        request = self.factory.get(_proxy_url(session_id=None))
+        with patch.object(views, "_authenticate_user", return_value=MagicMock(id=1)), \
+             patch.object(views, "network_access_allowed", return_value=True), \
+             patch.object(views, "Channel") as channel_cls, \
+             patch.object(views, "_user_can_access_channel", return_value=True), \
+             patch.object(views, "get_channel_catchup_streams",
+                          return_value=[_make_catchup_stream()]), \
+             patch.object(views, "get_programme_duration", return_value=40), \
+             patch.object(views, "parse_catchup_timestamp", return_value=True), \
+             patch.object(views, "RedisClient") as redis_cls:
+            redis_cls.get_client.return_value = _FakeRedis()
+            channel_cls.objects.get.return_value = MagicMock(id=8)
+            response = views.timeshift_proxy(
+                request, "u", "p", "8", "2026-06-08:17-00", "8.ts",
+            )
+        self.assertEqual(response.status_code, 301)
+        self.assertIn("session_id=timeshift_", response["Location"])
+
+    def test_redirect_preserves_existing_query_params(self):
+        request = self.factory.get(
+            "/timeshift/u/p/8/2026-06-08:17-00/8.ts?foo=bar&baz=1",
+        )
+        with patch.object(views, "_authenticate_user", return_value=MagicMock(id=1)), \
+             patch.object(views, "network_access_allowed", return_value=True), \
+             patch.object(views, "Channel") as channel_cls, \
+             patch.object(views, "_user_can_access_channel", return_value=True), \
+             patch.object(views, "get_channel_catchup_streams",
+                          return_value=[_make_catchup_stream()]), \
+             patch.object(views, "get_programme_duration", return_value=40), \
+             patch.object(views, "parse_catchup_timestamp", return_value=True), \
+             patch.object(views, "RedisClient") as redis_cls:
+            redis_cls.get_client.return_value = _FakeRedis()
+            channel_cls.objects.get.return_value = MagicMock(id=8)
+            response = views.timeshift_proxy(
+                request, "u", "p", "8", "2026-06-08:17-00", "8.ts",
+            )
+        self.assertEqual(response.status_code, 301)
+        location = response["Location"]
+        self.assertIn("session_id=timeshift_", location)
+        self.assertIn("foo=bar", location)
+        self.assertIn("baz=1", location)
+
+
+class TimeshiftStreamLimitExemptionTests(TestCase):
+    """Timeshift stream-limit bypass requires the same client session."""
+
+    MEDIA = TEST_MEDIA_ID
+
+    def setUp(self):
+        self.user = MagicMock(id=5, username="viewer", stream_limit=1)
+
+    def _limits_settings(self, ignore_same_channel=True):
+        return {
+            "ignore_same_channel_connections": ignore_same_channel,
+            "terminate_on_limit_exceeded": False,
+        }
+
+    def test_same_session_probe_allowed_at_limit(self):
+        connections = [{
+            "media_id": f"{self.MEDIA}_111",
+            "client_id": TEST_SESSION_ID,
+            "connected_at": 0.0,
+            "type": "timeshift",
+        }]
+        with patch("apps.proxy.utils.get_user_active_connections",
+                   return_value=connections), \
+             patch("apps.proxy.utils.CoreSettings.get_user_limits_settings",
+                   return_value=self._limits_settings()):
+            allowed = _check_user_stream_limits(
+                self.user, TEST_SESSION_ID, media_id=self.MEDIA,
+            )
+        self.assertTrue(allowed)
+
+    def test_different_session_same_programme_counts_against_limit(self):
+        connections = [{
+            "media_id": f"{self.MEDIA}_111",
+            "client_id": "timeshift_other_session",
+            "connected_at": 0.0,
+            "type": "timeshift",
+        }]
+        with patch("apps.proxy.utils.get_user_active_connections",
+                   return_value=connections), \
+             patch("apps.proxy.utils.CoreSettings.get_user_limits_settings",
+                   return_value=self._limits_settings()):
+            allowed = _check_user_stream_limits(
+                self.user, TEST_SESSION_ID, media_id=self.MEDIA,
+            )
+        self.assertFalse(allowed)
+
+
+class FakeRedisScanTests(TestCase):
+    """FakeRedis SCAN matches redis-py glob semantics used by the pool scanner."""
+
+    def setUp(self):
+        self.redis = _FakeRedis()
+        self.redis.store["timeshift_pool:timeshift_a"] = {"busy": "0"}
+        self.redis.store["timeshift_pool:timeshift_b"] = {"busy": "0"}
+        self.redis.store["timeshift_pool:other_c"] = {"busy": "0"}
+        self.redis.store["vod_persistent_connection:x"] = {}
+
+    def test_scan_glob_filters_pool_keys(self):
+        cursor = 0
+        seen = []
+        while True:
+            cursor, keys = self.redis.scan(
+                cursor, match="timeshift_pool:timeshift_*", count=1,
+            )
+            seen.extend(keys)
+            if cursor == 0:
+                break
+        self.assertEqual(
+            seen,
+            ["timeshift_pool:timeshift_a", "timeshift_pool:timeshift_b"],
+        )
+
+
+class TimeshiftRangeClassificationTests(TestCase):
+    """Startup probes must not be treated as scrubs."""
+
+    def test_full_file_request_is_not_displacing(self):
+        self.assertFalse(views._should_displace_busy_playback(None))
+
+    def test_bytes_zero_displaces_full_file_probe(self):
+        self.assertTrue(
+            views._should_displace_busy_playback("bytes=0-", busy_serving_range="none")
+        )
+
+    def test_bytes_zero_does_not_displace_active_start_stream(self):
+        self.assertFalse(
+            views._should_displace_busy_playback("bytes=0-", busy_serving_range="start")
+        )
+
+    def test_bytes_zero_without_busy_context_is_not_displacing(self):
+        self.assertFalse(views._should_displace_busy_playback("bytes=0-"))
+
+    def test_near_eof_probe_is_not_displacing(self):
+        self.assertTrue(views._is_near_eof_probe("bytes=2527702896-"))
+        self.assertFalse(views._should_displace_busy_playback("bytes=2527702896-"))
+
+    def test_near_eof_probe_uses_cached_content_length(self):
+        # 5 MB into a 10 MB file is a scrub, not a tail probe.
+        self.assertFalse(
+            views._is_near_eof_probe("bytes=5000000-", content_length="10000000")
+        )
+        self.assertTrue(
+            views._should_displace_busy_playback("bytes=5000000-", content_length="10000000")
+        )
+        # Within 512 KB of EOF is a tail probe once length is known.
+        self.assertTrue(
+            views._is_near_eof_probe("bytes=9990000-", content_length="10000000")
+        )
+
+    def test_midfile_seek_is_displacing(self):
+        self.assertTrue(views._should_displace_busy_playback("bytes=5000000-"))
+
+    def test_small_nonzero_range_is_displacing(self):
+        self.assertTrue(views._should_displace_busy_playback("bytes=1000-"))
+
+
+class TimeshiftScrubPreemptTests(TestCase):
+    """Scrub/range requests must stop the in-flight stream and reuse the pooled
+    provider slot instead of opening parallel upstream connections."""
+
+    def setUp(self):
+        self.redis = _FakeRedis()
+        self.user = MagicMock(id=5)
+        self.factory = RequestFactory()
+
+    def _conn(self, media_id, client_id):
+        return {
+            "media_id": media_id,
+            "client_id": client_id,
+            "connected_at": 0.0,
+            "type": "timeshift",
+        }
+
+    def test_preempt_stops_sibling_clients_of_same_playback(self):
+        connections = [
+            self._conn(f"{TEST_MEDIA_ID}_111", TEST_SESSION_ID),
+            self._conn("timeshift_9_2026-06-08-17-00_222", "timeshift_other"),
+        ]
+        with patch.object(views, "get_user_active_connections",
+                          return_value=connections), \
+             patch.object(views, "_unregister_stats_client") as unregister_mock:
+            views._preempt_playback_streams(self.redis, TEST_SESSION_ID, self.user)
+        unregister_mock.assert_called_once_with(
+            self.redis, f"{TEST_MEDIA_ID}_111", TEST_SESSION_ID,
+        )
+        from apps.proxy.live_proxy.redis_keys import RedisKeys
+        stop_key = RedisKeys.client_stop(f"{TEST_MEDIA_ID}_111", TEST_SESSION_ID)
+        self.assertIn(stop_key, self.redis.store)
+
+    def test_preempt_leaves_other_playbacks_alone(self):
+        connections = [
+            self._conn("timeshift_8_2026-06-09-20-00_111", "timeshift_other_pos"),
+        ]
+        with patch.object(views, "get_user_active_connections",
+                          return_value=connections), \
+             patch.object(views, "_unregister_stats_client") as unregister_mock:
+            views._preempt_playback_streams(self.redis, TEST_SESSION_ID, self.user)
+        unregister_mock.assert_not_called()
+
+    def test_busy_pool_returns_503_instead_of_second_provider_connection(self):
+        _seed_pool_session(self.redis, session_id=TEST_SESSION_ID)
+        request = self.factory.get(
+            _proxy_url(TEST_SESSION_ID),
+            HTTP_RANGE="bytes=1000-",
+        )
+        streams = [_make_catchup_stream(account_id=1, stream_id="111", profile_id=31)]
+        with patch.object(views, "_authenticate_user", return_value=MagicMock(id=5)), \
+             patch.object(views, "network_access_allowed", return_value=True), \
+             patch.object(views, "Channel") as channel_cls, \
+             patch.object(views, "_user_can_access_channel", return_value=True), \
+             patch.object(views, "get_channel_catchup_streams", return_value=streams), \
+             patch.object(views, "get_programme_duration", return_value=40), \
+             patch.object(views, "check_user_stream_limits", return_value=True), \
+             patch.object(views, "RedisClient") as redis_cls, \
+             patch.object(views, "reserve_profile_slot", return_value=(True, 1, None)), \
+             patch.object(views, "release_profile_slot"), \
+             patch.object(views, "get_transformed_credentials", side_effect=_fake_creds), \
+             patch.object(views, "get_user_active_connections", return_value=[]), \
+             patch.object(views, "_preempt_playback_streams") as preempt_mock, \
+             patch.object(views, "_wait_for_idle_pool_session", return_value=None), \
+             patch.object(views, "_attempt_timeshift_stream") as attempt_mock:
+            redis_cls.get_client.return_value = self.redis
+            channel_cls.objects.get.return_value = MagicMock(
+                id=8, name="Test", logo_id=None,
+            )
+            response = views.timeshift_proxy(
+                request, "u", "p", "8", "2026-06-08:17-00", "8.ts",
+            )
+        self.assertEqual(response.status_code, 503)
+        preempt_mock.assert_called_once()
+        attempt_mock.assert_not_called()
+        self.assertEqual(len(self._pool_entry_ids()), 1)
+
+    def _pool_entry_ids(self):
+        return [k for k in self.redis.store if k.startswith("timeshift_pool:")]
+
+    def test_startup_bytes_zero_deferred_without_preempt(self):
+        _seed_pool_session(
+            self.redis, session_id=TEST_SESSION_ID, serving_range="start",
+        )
+        request = self.factory.get(
+            _proxy_url(TEST_SESSION_ID),
+            HTTP_RANGE="bytes=0-",
+        )
+        streams = [_make_catchup_stream(account_id=1, stream_id="111", profile_id=31)]
+        with patch.object(views, "_authenticate_user", return_value=MagicMock(id=5)), \
+             patch.object(views, "network_access_allowed", return_value=True), \
+             patch.object(views, "Channel") as channel_cls, \
+             patch.object(views, "_user_can_access_channel", return_value=True), \
+             patch.object(views, "get_channel_catchup_streams", return_value=streams), \
+             patch.object(views, "get_programme_duration", return_value=40), \
+             patch.object(views, "check_user_stream_limits", return_value=True), \
+             patch.object(views, "RedisClient") as redis_cls, \
+             patch.object(views, "reserve_profile_slot", return_value=(True, 1, None)), \
+             patch.object(views, "release_profile_slot"), \
+             patch.object(views, "get_transformed_credentials", side_effect=_fake_creds), \
+             patch.object(views, "get_user_active_connections", return_value=[]), \
+             patch.object(views, "_preempt_playback_streams") as preempt_mock, \
+             patch.object(views, "_attempt_timeshift_stream") as attempt_mock:
+            redis_cls.get_client.return_value = self.redis
+            channel_cls.objects.get.return_value = MagicMock(
+                id=8, name="Test", logo_id=None,
+            )
+            response = views.timeshift_proxy(
+                request, "u", "p", "8", "2026-06-08:17-00", "8.ts",
+            )
+        self.assertEqual(response.status_code, 503)
+        preempt_mock.assert_not_called()
+        attempt_mock.assert_not_called()
+
+    def test_eof_probe_deferred_without_preempt(self):
+        _seed_pool_session(self.redis, session_id=TEST_SESSION_ID)
+        request = self.factory.get(
+            _proxy_url(TEST_SESSION_ID),
+            HTTP_RANGE="bytes=2527702896-",
+        )
+        streams = [_make_catchup_stream(account_id=1, stream_id="111", profile_id=31)]
+        with patch.object(views, "_authenticate_user", return_value=MagicMock(id=5)), \
+             patch.object(views, "network_access_allowed", return_value=True), \
+             patch.object(views, "Channel") as channel_cls, \
+             patch.object(views, "_user_can_access_channel", return_value=True), \
+             patch.object(views, "get_channel_catchup_streams", return_value=streams), \
+             patch.object(views, "get_programme_duration", return_value=40), \
+             patch.object(views, "check_user_stream_limits", return_value=True), \
+             patch.object(views, "RedisClient") as redis_cls, \
+             patch.object(views, "reserve_profile_slot", return_value=(True, 1, None)), \
+             patch.object(views, "release_profile_slot"), \
+             patch.object(views, "get_transformed_credentials", side_effect=_fake_creds), \
+             patch.object(views, "get_user_active_connections", return_value=[]), \
+             patch.object(views, "_preempt_playback_streams") as preempt_mock, \
+             patch.object(views, "_attempt_timeshift_stream") as attempt_mock:
+            redis_cls.get_client.return_value = self.redis
+            channel_cls.objects.get.return_value = MagicMock(
+                id=8, name="Test", logo_id=None,
+            )
+            response = views.timeshift_proxy(
+                request, "u", "p", "8", "2026-06-08:17-00", "8.ts",
+            )
+        self.assertEqual(response.status_code, 503)
+        preempt_mock.assert_not_called()
+        attempt_mock.assert_not_called()
+
+    def test_create_pool_session_rejects_duplicate_entry(self):
+        first = views._create_pool_session(
+            self.redis,
+            session_id=TEST_SESSION_ID,
+            media_id=TEST_MEDIA_ID,
+            user_id=5,
+            client_ip="1.2.3.4",
+            client_user_agent="test-agent",
+            account_id=1,
+            profile_id=31,
+            stream_id="111",
+            provider_timestamp="2026",
+        )
+        second = views._create_pool_session(
+            self.redis,
+            session_id=TEST_SESSION_ID,
+            media_id=TEST_MEDIA_ID,
+            user_id=5,
+            client_ip="1.2.3.4",
+            client_user_agent="test-agent",
+            account_id=2,
+            profile_id=41,
+            stream_id="222",
+            provider_timestamp="2026",
+        )
+        self.assertTrue(first)
+        self.assertFalse(second)
+        self.assertTrue(self.redis.exists(f"timeshift_pool:{TEST_SESSION_ID}"))
+
+    def test_scrub_reuses_idle_pool_without_opening_failover(self):
+        _seed_pool_session(self.redis, session_id=TEST_SESSION_ID)
+        with patch.object(views, "release_profile_slot"):
+            views._release_pool_session(self.redis, TEST_SESSION_ID, 31)
+
+        request = self.factory.get(
+            _proxy_url(TEST_SESSION_ID),
+            HTTP_RANGE="bytes=5000-",
+        )
+        streams = [_make_catchup_stream(account_id=1, stream_id="111", profile_id=31)]
+        profile = MagicMock(id=31)
+        ok = MagicMock(status_code=206)
+        with patch.object(views, "_authenticate_user", return_value=MagicMock(id=5)), \
+             patch.object(views, "network_access_allowed", return_value=True), \
+             patch.object(views, "Channel") as channel_cls, \
+             patch.object(views, "_user_can_access_channel", return_value=True), \
+             patch.object(views, "get_channel_catchup_streams", return_value=streams), \
+             patch.object(views, "get_programme_duration", return_value=40), \
+             patch.object(views, "check_user_stream_limits", return_value=True), \
+             patch.object(views, "RedisClient") as redis_cls, \
+             patch.object(views, "reserve_profile_slot",
+                          return_value=(True, 1, None)) as reserve_mock, \
+             patch.object(views, "release_profile_slot"), \
+             patch.object(views.M3UAccountProfile.objects, "get",
+                          return_value=profile), \
+             patch.object(views, "get_transformed_credentials", side_effect=_fake_creds), \
+             patch.object(views, "get_user_active_connections", return_value=[]), \
+             patch.object(views, "_preempt_playback_streams") as preempt_mock, \
+             patch.object(views, "_stream_reused_session", return_value=ok) as reuse_mock, \
+             patch.object(views, "_attempt_timeshift_stream") as attempt_mock:
+            redis_cls.get_client.return_value = self.redis
+            channel_cls.objects.get.return_value = MagicMock(
+                id=8, name="Test", logo_id=None,
+            )
+            response = views.timeshift_proxy(
+                request, "u", "p", "8", "2026-06-08:17-00", "8.ts",
+            )
+        self.assertIs(response, ok)
+        preempt_mock.assert_not_called()
+        reuse_mock.assert_called_once()
+        attempt_mock.assert_not_called()
+        # Pool acquire re-reserves the idle slot once; failover must not add another.
+        reserve_mock.assert_called_once_with(profile, self.redis)
+
+
+
+class RollupSelfHealDbTests(TestCase):
+    """Catch-up flag consistency after stream removal.
+
+    The ChannelStream signal handles bulk deletes (locked by a regression test).
+    The account-scoped rollup self-heals stale flags on channels still linked
+    to that account.
+    """
+
+    @classmethod
+    def setUpTestData(cls):
+        from apps.m3u.models import M3UAccount
+
+        cls.account = M3UAccount.objects.create(
+            name="ts-rollup-account", server_url="http://example.test",
+            account_type="XC", is_active=True,
+        )
+
+    def _make_channel_with_catchup_stream(self, name, days=5):
+        from apps.channels.models import Channel, ChannelStream, Stream
+
+        channel = Channel.objects.create(name=name)
+        stream = Stream.objects.create(
+            name=f"{name}-stream", url=f"http://example.test/{name}",
+            m3u_account=self.account, is_catchup=True, catchup_days=days,
+        )
+        ChannelStream.objects.create(channel=channel, stream=stream, order=0)
+        return channel, stream
+
+    def test_bulk_stream_delete_resets_channel_flags_via_signal(self):
+        # cleanup_streams() removes stale streams with a queryset bulk delete;
+        # the cascaded ChannelStream rows still fire post_delete (signal
+        # listeners disable Django's fast-delete path), which must reset the
+        # channel's denormalized catch-up fields.
+        from apps.channels.models import Stream
+
+        channel, stream = self._make_channel_with_catchup_stream("ts-rollup-bulk")
+        channel.refresh_from_db()
+        self.assertTrue(channel.is_catchup)
+        self.assertEqual(channel.catchup_days, 5)
+
+        Stream.objects.filter(id=stream.id).delete()
+
+        channel.refresh_from_db()
+        self.assertFalse(channel.is_catchup)
+        self.assertEqual(channel.catchup_days, 0)
+
+    def test_rollup_self_heals_stale_channel_with_non_catchup_stream(self):
+        # Channel still linked to the account but no active catch-up streams
+        # (e.g. catch-up flag cleared on import). Rollup must reset stale flags.
+        from apps.channels.models import Channel, ChannelStream, Stream
+        from apps.m3u.tasks import rollup_channel_catchup_fields
+
+        channel = Channel.objects.create(name="ts-rollup-stale")
+        stream = Stream.objects.create(
+            name="ts-rollup-stale-stream",
+            url="http://example.test/ts-rollup-stale",
+            m3u_account=self.account,
+            is_catchup=False,
+            catchup_days=0,
+        )
+        ChannelStream.objects.create(channel=channel, stream=stream, order=0)
+        Channel.objects.filter(pk=channel.pk).update(is_catchup=True, catchup_days=9)
+
+        rollup_channel_catchup_fields(self.account.id)
+
+        channel.refresh_from_db()
+        self.assertFalse(channel.is_catchup)
+        self.assertEqual(channel.catchup_days, 0)
+
+    def test_rollup_self_heal_skips_channels_not_linked_to_account(self):
+        from apps.channels.models import Channel
+        from apps.m3u.models import M3UAccount
+        from apps.m3u.tasks import rollup_channel_catchup_fields
+
+        other_account = M3UAccount.objects.create(
+            name="ts-rollup-other",
+            server_url="http://example.test/other",
+            account_type="XC",
+            is_active=True,
+        )
+        channel = Channel.objects.create(name="ts-rollup-unrelated")
+        Channel.objects.filter(pk=channel.pk).update(is_catchup=True, catchup_days=9)
+
+        rollup_channel_catchup_fields(other_account.id)
+
+        channel.refresh_from_db()
+        self.assertTrue(channel.is_catchup)
+        self.assertEqual(channel.catchup_days, 9)
+
+    def test_rollup_keeps_and_corrects_channels_with_catchup_streams(self):
+        # The self-heal pass must not touch channels that legitimately have
+        # catch-up streams. The account-scoped pass still corrects their values.
+        from apps.channels.models import Channel
+        from apps.m3u.tasks import rollup_channel_catchup_fields
+
+        channel, _ = self._make_channel_with_catchup_stream("ts-rollup-valid", days=7)
+        # Knock the denormalized values out of sync (bypasses signals).
+        Channel.objects.filter(pk=channel.pk).update(is_catchup=False, catchup_days=0)
+
+        rollup_channel_catchup_fields(self.account.id)
+
+        channel.refresh_from_db()
+        self.assertTrue(channel.is_catchup)
+        self.assertEqual(channel.catchup_days, 7)
diff --git a/apps/timeshift/views.py b/apps/timeshift/views.py
new file mode 100644
index 00000000..0ba3a5a7
--- /dev/null
+++ b/apps/timeshift/views.py
@@ -0,0 +1,1355 @@
+"""XC catch-up (timeshift) proxy with multi-provider failover."""
+
+import hmac
+import itertools
+import logging
+import secrets
+import time
+from urllib.parse import urlencode
+
+import requests
+from django.core.cache import cache
+from django.http import (
+    Http404,
+    HttpResponse,
+    HttpResponseBadRequest,
+    HttpResponseForbidden,
+    HttpResponseNotFound,
+    StreamingHttpResponse,
+)
+
+from apps.accounts.models import User
+from apps.channels.models import Channel
+from apps.channels.utils import get_channel_catchup_streams
+from apps.m3u.connection_pool import release_profile_slot, reserve_profile_slot
+from apps.m3u.models import M3UAccount, M3UAccountProfile
+from apps.m3u.tasks import get_transformed_credentials
+from apps.proxy.live_proxy.config_helper import ConfigHelper
+from apps.proxy.live_proxy.constants import ChannelMetadataField, ChannelState
+from apps.proxy.live_proxy.redis_keys import RedisKeys
+from apps.proxy.live_proxy.utils import get_client_ip
+from apps.proxy.utils import (
+    check_user_stream_limits,
+    find_ts_sync,
+    get_user_active_connections,
+)
+from core.utils import RedisClient
+from dispatcharr.utils import network_access_allowed
+
+from .helpers import (
+    TimeshiftCredentials,
+    build_timeshift_candidate_urls,
+    convert_timestamp_to_provider_tz,
+    get_programme_duration,
+    parse_catchup_timestamp,
+)
+
+logger = logging.getLogger(__name__)
+
+CLIENT_TTL_SECONDS = 60
+_MATCH_SCORE_THRESHOLD = 8  # client_ip (5) + client_user_agent (3)
+
+
+def timeshift_proxy(request, username, password, stream_id, timestamp, duration):  # noqa: ARG001 stream_id
+    """Proxy an XC catch-up request to the provider with multi-stream failover.
+
+    URL shape (iPlayTV / TiviMate):
+        ``stream_id``: EPG channel number (ignored here).
+        ``duration``: Dispatcharr ``Channel.id`` (XC API exposes channel.id as stream_id).
+        ``timestamp``: UTC programme start (``YYYY-MM-DD:HH-MM`` or XC colon form
+            ``YYYY-MM-DD:HH:MM:SS``).
+    """
+    raw_id = duration[:-3] if duration.endswith(".ts") else duration
+
+    user = _authenticate_user(username, password)
+    if user is None:
+        return HttpResponseForbidden("Invalid credentials")
+
+    if not network_access_allowed(request, "XC_API", user):
+        return HttpResponseForbidden("Access denied")
+
+    try:
+        channel = Channel.objects.get(id=int(raw_id))
+    except (Channel.DoesNotExist, ValueError, TypeError):
+        raise Http404("Channel not found") from None
+
+    if not _user_can_access_channel(user, channel):
+        return HttpResponseForbidden("Access denied")
+
+    # Shape helpers pass through on parse failure; reject bad input before upstream.
+    if parse_catchup_timestamp(timestamp) is None:
+        return HttpResponseBadRequest("Invalid timestamp")
+
+    catchup_streams = get_channel_catchup_streams(channel)
+    if not catchup_streams:
+        return HttpResponseBadRequest("Timeshift not supported for this channel")
+
+    debug = logger.isEnabledFor(logging.DEBUG)
+
+    # EPG duration lookup stays in UTC; provider TZ conversion is per-attempt below.
+    duration_minutes = get_programme_duration(channel, timestamp)
+
+    safe_ts = timestamp.replace(":", "-").replace("/", "-")
+    client_ip = get_client_ip(request)
+    client_user_agent = request.META.get("HTTP_USER_AGENT", "") or ""
+    range_header = request.META.get("HTTP_RANGE")
+    channel_logo_id = getattr(channel, "logo_id", None)
+
+    redis_client = RedisClient.get_client()
+
+    # Content identity (channel + catch-up position). Provider slot sharing is
+    # scoped per client session; never assume all requests for the same
+    # programme belong to one viewer.
+    media_id = f"timeshift_{channel.id}_{safe_ts}"
+
+    session_id = request.GET.get("session_id")
+    if not session_id:
+        logger.debug("Timeshift session redirect: %s (new session)", request.path)
+        return _redirect_with_new_session(request)
+
+    session_entry = _get_pool_entry(redis_client, session_id)
+    if session_entry and not _pool_entry_owned_by_user(session_entry, user.id):
+        logger.info(
+            "Timeshift: rejecting foreign session_id for user %s", user.id,
+        )
+        return _redirect_with_new_session(request)
+
+    # Stable client identity for stats, stop keys, and the provider pool.
+    effective_session_id = session_id
+    client_id = session_id
+
+    # Reuse an idle pool owned by this session, or fingerprint-match a prior
+    # idle session from the same client (VOD-style) before opening upstream.
+    if not session_entry:
+        matched = _find_matching_idle_session(
+            redis_client,
+            media_id=media_id,
+            user_id=user.id,
+            client_ip=client_ip,
+            client_user_agent=client_user_agent,
+        )
+        if matched:
+            logger.info(
+                "Timeshift fingerprint matched idle session %s for %s",
+                matched, session_id,
+            )
+            effective_session_id = matched
+            client_id = matched
+
+    if debug:
+        if effective_session_id != session_id:
+            logger.debug(
+                "Timeshift request: channel=%s media=%s session=%s "
+                "effective=%s user=%s range=%s ip=%s",
+                channel.name, media_id, session_id, effective_session_id,
+                user.id, range_header or "(none)", client_ip,
+            )
+        else:
+            logger.debug(
+                "Timeshift request: channel=%s media=%s session=%s "
+                "user=%s range=%s ip=%s",
+                channel.name, media_id, effective_session_id, user.id,
+                range_header or "(none)", client_ip,
+            )
+
+    # Displace this user's prior catch-up on other positions of this channel.
+    _terminate_previous_timeshift_sessions(
+        redis_client, user, channel.id, media_id, effective_session_id,
+    )
+
+    if not check_user_stream_limits(user, client_id, media_id=media_id):
+        return HttpResponseForbidden("Stream limit exceeded")
+
+    if effective_session_id == session_id:
+        pool = _snapshot_from_entry(session_entry)
+    else:
+        pool = _pool_snapshot(redis_client, effective_session_id)
+    pool_exists = pool is not None
+    pool_busy = pool["busy"] if pool else False
+    pool_content_length = pool["content_length"] if pool else None
+    busy_serving_range = pool["serving_range"] if pool else None
+
+    acquired = None
+    if pool_exists:
+        if pool_busy:
+            if _should_displace_busy_playback(
+                range_header, pool_content_length, busy_serving_range,
+            ):
+                _preempt_playback_streams(redis_client, effective_session_id, user)
+                acquired = _wait_for_idle_pool_session(
+                    redis_client,
+                    effective_session_id,
+                    user_id=user.id,
+                    wait_seconds=_POOL_PREEMPT_WAIT_SECONDS,
+                )
+        else:
+            acquired = _acquire_idle_pool_session(
+                redis_client, effective_session_id, user_id=user.id,
+            )
+
+    if acquired is not None:
+        descriptor, profile = acquired
+        reuse_response = _stream_reused_session(
+            redis_client,
+            session_id=effective_session_id,
+            descriptor=descriptor,
+            profile=profile,
+            channel=channel,
+            safe_ts=safe_ts,
+            timestamp=timestamp,
+            duration_minutes=duration_minutes,
+            client_id=client_id,
+            client_ip=client_ip,
+            range_header=range_header,
+            channel_logo_id=channel_logo_id,
+            user=user,
+            debug=debug,
+        )
+        if reuse_response is not None:
+            return reuse_response
+
+    if pool_exists and pool_busy and not _should_displace_busy_playback(
+            range_header, pool_content_length, busy_serving_range,
+        ):
+        logger.debug(
+            "Timeshift: deferring non-displacing request for session %s range=%s",
+            effective_session_id, range_header or "(none)",
+        )
+        return HttpResponse("Stream slot busy", status=503)
+
+    if pool_exists and pool_busy:
+        logger.warning(
+            "Timeshift: session %s did not become idle in time",
+            effective_session_id,
+        )
+        return HttpResponse("Stream slot busy", status=503)
+
+    last_response = None
+    decisive_accounts = set()
+    capacity_blocked = False
+    for catchup_stream in catchup_streams:
+        m3u_account = catchup_stream.m3u_account
+        if m3u_account is None or m3u_account.account_type != "XC":
+            continue
+        if m3u_account.id in decisive_accounts:
+            continue
+
+        stream_id_value = (catchup_stream.custom_properties or {}).get("stream_id")
+        if stream_id_value is None:
+            continue
+
+        m3u_profiles = list(m3u_account.profiles.filter(is_active=True))
+        default_profile = next((p for p in m3u_profiles if p.is_default), None)
+        if default_profile is None:
+            logger.debug(
+                "Timeshift: account %s has no active default profile, skipping",
+                m3u_account.id,
+            )
+            continue
+        profile_walk = [default_profile] + [
+            p for p in m3u_profiles if not p.is_default
+        ]
+
+        # Providers index archives in their own timezone (from server_info on auth).
+        provider_tz_name = None
+        _server_info = (default_profile.custom_properties or {}).get("server_info") or {}
+        if isinstance(_server_info, dict):
+            provider_tz_name = _server_info.get("timezone")
+        provider_timestamp = convert_timestamp_to_provider_tz(timestamp, provider_tz_name)
+
+        # Reserve a provider profile slot before connecting (same contract as live/VOD).
+        reserved_profile = None
+        for profile in profile_walk:
+            if redis_client is None:
+                reserved_profile = profile
+                break
+            reserved, _count, reason = reserve_profile_slot(profile, redis_client)
+            if reserved:
+                reserved_profile = profile
+                break
+            logger.info(
+                "Timeshift: profile %s %s on account %s, trying next profile",
+                profile.id, reason or "unavailable", m3u_account.id,
+            )
+        if reserved_profile is None:
+            capacity_blocked = True
+            logger.warning(
+                "Timeshift: all profiles at capacity on account %s for channel %s",
+                m3u_account.id, channel.name,
+            )
+            continue
+
+        if not _create_pool_session(
+            redis_client,
+            session_id=effective_session_id,
+            media_id=media_id,
+            user_id=user.id,
+            client_ip=client_ip,
+            client_user_agent=client_user_agent,
+            account_id=m3u_account.id,
+            profile_id=reserved_profile.id,
+            stream_id=stream_id_value,
+            provider_timestamp=provider_timestamp,
+        ):
+            try:
+                release_profile_slot(reserved_profile.id, redis_client)
+            except Exception as exc:
+                logger.warning(
+                    "Timeshift slot release failed after pool race on profile %s: %s",
+                    reserved_profile.id, exc,
+                )
+            logger.debug(
+                "Timeshift: pool entry already exists for session %s, deferring",
+                effective_session_id,
+            )
+            return HttpResponse("Stream slot busy", status=503)
+        release_cb = _make_release_once(
+            redis_client, effective_session_id, reserved_profile.id
+        )
+
+        try:
+            response = _attempt_timeshift_stream(
+                m3u_account=m3u_account,
+                profile=reserved_profile,
+                stream_id_value=stream_id_value,
+                provider_timestamp=provider_timestamp,
+                provider_tz_name=provider_tz_name,
+                duration_minutes=duration_minutes,
+                channel=channel,
+                safe_ts=safe_ts,
+                timestamp=timestamp,
+                client_id=client_id,
+                client_ip=client_ip,
+                range_header=range_header,
+                channel_logo_id=channel_logo_id,
+                user=user,
+                redis_client=redis_client,
+                debug=debug,
+                release_cb=release_cb,
+                pool_session_id=effective_session_id,
+            )
+        except Exception:
+            _discard_pool_session(redis_client, effective_session_id, reserved_profile.id)
+            raise
+        if response.status_code < 400:
+            # Streaming: the generator's close path frees the slot via release_cb.
+            return response
+
+        if getattr(response, "timeshift_passthrough", False) is True:
+            # Terminal range answer (e.g. 416 past EOF): the upstream session is
+            # healthy, so free the slot but keep the entry idle for the next
+            # probe, and return verbatim without failing over to other accounts.
+            release_cb()
+            return response
+
+        # Real failure: drop this session entirely and fail over.
+        _discard_pool_session(redis_client, effective_session_id, reserved_profile.id)
+        last_response = response
+        if getattr(response, "timeshift_decisive", False):
+            decisive_accounts.add(m3u_account.id)
+        logger.warning(
+            "Timeshift attempt failed (HTTP %d%s) on account %s for channel %s, "
+            "trying next catch-up stream",
+            response.status_code,
+            ", decisive: skipping this account's other streams"
+            if m3u_account.id in decisive_accounts else "",
+            m3u_account.id, channel.name,
+        )
+
+    if last_response is not None:
+        return last_response
+    if capacity_blocked:
+        return HttpResponse("No available stream slot", status=503)
+    return HttpResponseBadRequest("Cannot build timeshift URL")
+
+
+def _authenticate_user(username, password):
+    try:
+        user = User.objects.get(username=username)
+    except User.DoesNotExist:
+        return None
+    expected = (user.custom_properties or {}).get("xc_password")
+    if not expected:
+        return None
+    if not hmac.compare_digest(str(expected), str(password)):
+        return None
+    return user
+
+
+def _user_can_access_channel(user, channel):
+    if user.user_level < channel.user_level:
+        return False
+    if user.user_level >= User.UserLevel.ADMIN:
+        return True
+    profile_count = user.channel_profiles.count()
+    if profile_count == 0:
+        return True
+    return (
+        type(channel).objects.filter(
+            id=channel.id,
+            channelprofilemembership__enabled=True,
+            channelprofilemembership__channel_profile__in=user.channel_profiles.all(),
+        )
+        .exists()
+    )
+
+
+# Per-client session pool (keyed by session_id from the 301 redirect). Each
+# viewer gets their own provider slot even when watching the same catch-up
+# programme. Idle sessions can be fingerprint-matched (VOD-style) when a client
+# returns without its prior session_id.
+_POOL_KEY = "timeshift_pool:{session_id}"
+_POOL_LOCK_KEY = "timeshift_pool_lock:{session_id}"
+_POOL_ENTRY_TTL = 6 * 3600
+_POOL_IDLE_TTL = 30
+_POOL_WAIT_SECONDS = 1.0
+_POOL_PREEMPT_WAIT_SECONDS = 5.0
+_POOL_POLL_INTERVAL = 0.05
+_EOF_PROBE_TAIL_BYTES = 512_000
+_EOF_PROBE_UNKNOWN_LENGTH_MIN = 100_000_000
+
+
+def _pool_key(session_id):
+    return _POOL_KEY.format(session_id=session_id)
+
+
+def _parse_range_start(range_header):
+    """Return the byte offset from a ``Range: bytes=START-`` header, or None."""
+    if not range_header or not range_header.startswith("bytes="):
+        return None
+    start_part = range_header[6:].split("-", 1)[0]
+    if not start_part:
+        return None
+    try:
+        return int(start_part)
+    except (TypeError, ValueError):
+        return None
+
+
+def _is_near_eof_probe(range_header, content_length=None):
+    """True for tail/duration probes IPTV clients fire during startup."""
+    start = _parse_range_start(range_header)
+    if start is None:
+        return False
+    if content_length is not None:
+        try:
+            total = int(content_length)
+        except (TypeError, ValueError):
+            total = None
+        else:
+            return start >= max(0, total - _EOF_PROBE_TAIL_BYTES)
+    return start >= _EOF_PROBE_UNKNOWN_LENGTH_MIN
+
+
+def _should_displace_busy_playback(
+    range_header, content_length=None, busy_serving_range=None,
+):
+    """True when this request should stop the in-flight stream (actual scrub)."""
+    if not range_header:
+        return False
+    start = _parse_range_start(range_header)
+    if start is None:
+        return False
+    if _is_near_eof_probe(range_header, content_length):
+        return False
+    if start == 0:
+        # Only displace a known full-file probe; unknown busy context is not a scrub.
+        return busy_serving_range == "none"
+    return True
+
+
+def _score_pool_fingerprint(entry, client_ip, client_user_agent):
+    """Score IP/UA overlap for fingerprint adoption (user and media pre-filtered)."""
+    score = 0
+    if entry.get("client_ip") and entry.get("client_ip") == client_ip:
+        score += 5
+    if entry.get("client_user_agent") and entry.get("client_user_agent") == client_user_agent:
+        score += 3
+    return score
+
+
+def _mint_timeshift_session_id():
+    return f"timeshift_{secrets.token_urlsafe(16)}"
+
+
+def _redirect_with_new_session(request):
+    session_id = _mint_timeshift_session_id()
+    query_params = {k: request.GET.getlist(k) for k in request.GET}
+    query_params["session_id"] = [session_id]
+    redirect_url = f"{request.path}?{urlencode(query_params, doseq=True)}"
+    return HttpResponse(status=301, headers={"Location": redirect_url})
+
+
+def _pool_entry_owned_by_user(entry, user_id):
+    """True when *entry* is unclaimed or owned by *user_id*."""
+    if not entry or not entry.get("profile_id"):
+        return True
+    owner = entry.get("user_id")
+    if owner is None or owner == "":
+        return False
+    return str(owner) == str(user_id)
+
+
+def _find_matching_idle_session(
+    redis_client, *, media_id, user_id, client_ip, client_user_agent,
+):
+    """Find an idle pooled session that likely belongs to the same client."""
+    if redis_client is None:
+        return None
+    matches = []
+    try:
+        cursor = 0
+        while True:
+            cursor, keys = redis_client.scan(
+                cursor, match="timeshift_pool:timeshift_*", count=100,
+            )
+            for key in keys:
+                try:
+                    data = redis_client.hgetall(key)
+                    if not data or data.get("busy") == "1":
+                        continue
+                    if str(data.get("user_id") or "") != str(user_id):
+                        continue
+                    if str(data.get("media_id") or "") != str(media_id):
+                        continue
+                    session_id = key.rsplit(":", 1)[-1]
+                    score = _score_pool_fingerprint(
+                        data, client_ip, client_user_agent,
+                    )
+                    if score >= _MATCH_SCORE_THRESHOLD:
+                        last_activity = float(data.get("last_activity") or "0")
+                        matches.append((session_id, score, last_activity))
+                except Exception as exc:
+                    logger.debug("Timeshift pool scan skip %s: %s", key, exc)
+            if cursor == 0:
+                break
+    except Exception as exc:
+        logger.warning("Timeshift idle session search failed: %s", exc)
+        return None
+
+    if not matches:
+        return None
+    matches.sort(key=lambda item: (item[1], item[2]), reverse=True)
+    best = matches[0][0]
+    logger.debug(
+        "Timeshift idle match: session=%s score=%s media=%s",
+        best, matches[0][1], media_id,
+    )
+    return best
+
+
+def _get_pool_entry(redis_client, session_id):
+    if redis_client is None or not session_id:
+        return {}
+    try:
+        return redis_client.hgetall(_pool_key(session_id)) or {}
+    except Exception:
+        return {}
+
+
+def _snapshot_from_entry(entry):
+    if not entry:
+        return None
+    busy = entry.get("busy") == "1"
+    return {
+        "entry": entry,
+        "busy": busy,
+        "serving_range": (entry.get("serving_range") or "none") if busy else None,
+        "content_length": entry.get("content_length"),
+    }
+
+
+def _pool_snapshot(redis_client, session_id):
+    """Single HGETALL view of pool state for request handling."""
+    return _snapshot_from_entry(_get_pool_entry(redis_client, session_id))
+
+
+def _store_pool_serving_range(redis_client, session_id, range_header):
+    if redis_client is None or not session_id:
+        return
+    start = _parse_range_start(range_header)
+    if not range_header:
+        serving_range = "none"
+    elif start == 0:
+        serving_range = "start"
+    else:
+        serving_range = "range"
+    try:
+        redis_client.hset(_pool_key(session_id), "serving_range", serving_range)
+    except Exception as exc:
+        logger.debug("Timeshift pool serving_range store failed: %s", exc)
+
+
+def _store_pool_content_length(redis_client, session_id, upstream_response):
+    if redis_client is None or not session_id or upstream_response is None:
+        return
+    content_length = upstream_response.headers.get("Content-Length")
+    content_range = upstream_response.headers.get("Content-Range", "")
+    if content_range and "/" in content_range:
+        total = content_range.rsplit("/", 1)[-1]
+        if total != "*":
+            content_length = total
+    if not content_length:
+        return
+    try:
+        redis_client.hset(
+            _pool_key(session_id), "content_length", str(content_length),
+        )
+    except Exception as exc:
+        logger.debug("Timeshift pool content_length store failed: %s", exc)
+
+
+def _pool_lock(redis_client, session_id):
+    return redis_client.lock(
+        _POOL_LOCK_KEY.format(session_id=session_id),
+        timeout=10,
+        blocking_timeout=5,
+    )
+
+
+def _acquire_idle_pool_session(redis_client, session_id, *, user_id=None):
+    """Re-reserve an idle session's profile slot and mark it busy."""
+    if redis_client is None or not session_id:
+        return None
+    key = _pool_key(session_id)
+    try:
+        with _pool_lock(redis_client, session_id):
+            data = redis_client.hgetall(key)
+            if not data or not data.get("profile_id"):
+                return None
+            if user_id is not None and not _pool_entry_owned_by_user(data, user_id):
+                return None
+            if data.get("busy") == "1":
+                return None
+            try:
+                profile = M3UAccountProfile.objects.get(id=int(data["profile_id"]))
+            except M3UAccountProfile.DoesNotExist:
+                redis_client.delete(key)
+                return None
+            reserved, _count, _reason = reserve_profile_slot(profile, redis_client)
+            if not reserved:
+                return None
+            redis_client.hset(key, mapping={
+                "busy": "1",
+                "last_activity": str(time.time()),
+            })
+            redis_client.expire(key, _POOL_ENTRY_TTL)
+            return dict(data), profile
+    except Exception as exc:
+        logger.warning("Timeshift pool acquire failed for %s: %s", session_id, exc)
+    return None
+
+
+def _wait_for_idle_pool_session(
+    redis_client, session_id, *, user_id=None, wait_seconds=_POOL_WAIT_SECONDS,
+):
+    if redis_client is None or not session_id:
+        return None
+    deadline = time.time() + wait_seconds
+    while True:
+        acquired = _acquire_idle_pool_session(
+            redis_client, session_id, user_id=user_id,
+        )
+        if acquired is not None:
+            return acquired
+        if not _get_pool_entry(redis_client, session_id):
+            return None
+        if time.time() >= deadline:
+            return None
+        time.sleep(_POOL_POLL_INTERVAL)
+
+
+def _create_pool_session(
+    redis_client,
+    *,
+    session_id,
+    media_id,
+    user_id,
+    client_ip,
+    client_user_agent,
+    account_id,
+    profile_id,
+    stream_id,
+    provider_timestamp,
+):
+    """Register an already-reserved slot for this client session."""
+    if redis_client is None or not session_id:
+        return False
+    key = _pool_key(session_id)
+    now = str(time.time())
+    try:
+        with _pool_lock(redis_client, session_id):
+            if redis_client.exists(key):
+                return False
+            redis_client.hset(key, mapping={
+                "media_id": str(media_id),
+                "user_id": str(user_id),
+                "client_ip": str(client_ip or ""),
+                "client_user_agent": str(client_user_agent or ""),
+                "account_id": str(account_id),
+                "profile_id": str(profile_id),
+                "stream_id": str(stream_id),
+                "provider_timestamp": str(provider_timestamp),
+                "busy": "1",
+                "last_activity": now,
+            })
+            redis_client.expire(key, _POOL_ENTRY_TTL)
+        return True
+    except Exception as exc:
+        logger.warning("Timeshift pool create failed for %s: %s", session_id, exc)
+        return False
+
+
+def _release_pool_session(redis_client, session_id, profile_id):
+    if redis_client is None:
+        return
+    if profile_id is not None:
+        try:
+            release_profile_slot(int(profile_id), redis_client)
+        except Exception as exc:
+            logger.warning(
+                "Timeshift slot release failed for profile %s: %s", profile_id, exc
+            )
+    if not session_id:
+        return
+    key = _pool_key(session_id)
+    try:
+        with _pool_lock(redis_client, session_id):
+            if redis_client.exists(key):
+                redis_client.hset(key, mapping={
+                    "busy": "0",
+                    "last_activity": str(time.time()),
+                })
+                redis_client.expire(key, _POOL_IDLE_TTL)
+    except Exception as exc:
+        logger.warning("Timeshift pool release failed for %s: %s", session_id, exc)
+
+
+def _discard_pool_session(redis_client, session_id, profile_id):
+    if redis_client is None:
+        return
+    if profile_id is not None:
+        try:
+            release_profile_slot(int(profile_id), redis_client)
+        except Exception as exc:
+            logger.warning(
+                "Timeshift slot release failed for profile %s: %s", profile_id, exc
+            )
+    if not session_id:
+        return
+    try:
+        with _pool_lock(redis_client, session_id):
+            redis_client.delete(_pool_key(session_id))
+    except Exception as exc:
+        logger.warning("Timeshift pool discard failed for %s: %s", session_id, exc)
+
+
+def _make_release_once(redis_client, session_id, profile_id):
+    state = {"done": False}
+
+    def _release():
+        if state["done"]:
+            return
+        state["done"] = True
+        _release_pool_session(redis_client, session_id, profile_id)
+
+    return _release
+
+
+def _preempt_playback_streams(redis_client, session_id, user):
+    """Stop in-flight streams for this client session only."""
+    if redis_client is None or not session_id or user is None:
+        return
+    try:
+        for conn in get_user_active_connections(user.id):
+            if conn.get("type") != "timeshift":
+                continue
+            if conn.get("client_id") != session_id:
+                continue
+            conn_media_id = str(conn.get("media_id") or "")
+            old_client_id = conn.get("client_id")
+            logger.debug(
+                "Timeshift preempt: stopping client %s on %s for reuse",
+                old_client_id, conn_media_id,
+            )
+            _unregister_stats_client(redis_client, conn_media_id, old_client_id)
+            stop_key = RedisKeys.client_stop(conn_media_id, old_client_id)
+            redis_client.setex(stop_key, 60, "true")
+    except Exception as exc:
+        logger.warning("Timeshift preempt failed: %s", exc)
+
+
+def _terminate_previous_timeshift_sessions(
+    redis_client, user, channel_id, current_media_id, current_session_id,
+):
+    """Displace this user's other catch-up positions on the same channel."""
+    if redis_client is None or user is None:
+        return
+    prefix = f"timeshift_{channel_id}_"
+    try:
+        for conn in get_user_active_connections(user.id):
+            if conn.get("type") != "timeshift":
+                continue
+            if conn.get("client_id") == current_session_id:
+                continue
+            conn_media_id = str(conn.get("media_id") or "")
+            if not conn_media_id.startswith(prefix):
+                continue
+            if conn_media_id.startswith(f"{current_media_id}_") or conn_media_id == current_media_id:
+                continue
+            old_client_id = conn.get("client_id")
+            logger.info(
+                "Timeshift takeover: displacing session %s on %s",
+                old_client_id, conn_media_id,
+            )
+            _unregister_stats_client(redis_client, conn_media_id, old_client_id)
+            stop_key = RedisKeys.client_stop(conn_media_id, old_client_id)
+            redis_client.setex(stop_key, 60, "true")
+    except Exception as exc:
+        logger.warning("Timeshift takeover check failed: %s", exc)
+
+
+def _attempt_timeshift_stream(
+    *,
+    m3u_account,
+    profile,
+    stream_id_value,
+    provider_timestamp,
+    provider_tz_name,
+    duration_minutes,
+    channel,
+    safe_ts,
+    timestamp,
+    client_id,
+    client_ip,
+    range_header,
+    channel_logo_id,
+    user,
+    redis_client,
+    debug,
+    release_cb=None,
+    pool_session_id=None,
+):
+    """Build the provider URL set for one (account, profile, stream) and stream it."""
+    server_url, xc_username, xc_password = get_transformed_credentials(
+        m3u_account, profile
+    )
+    creds = TimeshiftCredentials(server_url, xc_username, xc_password)
+    candidate_urls = build_timeshift_candidate_urls(
+        creds, stream_id_value, provider_timestamp, duration_minutes
+    )
+
+    try:
+        user_agent = m3u_account.get_user_agent().user_agent
+    except AttributeError:
+        user_agent = ""
+
+    virtual_channel_id = f"timeshift_{channel.id}_{safe_ts}_{stream_id_value}"
+
+    if debug:
+        logger.debug(
+            "Timeshift attempt: channel=%s ts=%s (provider tz=%s -> %s) "
+            "account=%s profile=%s provider_sid=%s vid=%s client=%s range=%s",
+            channel.name, timestamp, provider_tz_name, provider_timestamp,
+            m3u_account.id, profile.id, stream_id_value,
+            virtual_channel_id, client_id, range_header or "(none)",
+        )
+
+    return _stream_from_provider(
+        candidate_urls=candidate_urls,
+        user_agent=user_agent,
+        range_header=range_header,
+        virtual_channel_id=virtual_channel_id,
+        client_id=client_id,
+        client_ip=client_ip,
+        user=user,
+        channel_display_name=channel.name,
+        timestamp_utc=timestamp,
+        channel_logo_id=channel_logo_id,
+        m3u_profile_id=profile.id,
+        debug=debug,
+        account_id=m3u_account.id,
+        redis_client=redis_client,
+        release_cb=release_cb,
+        pool_session_id=pool_session_id,
+    )
+
+
+def _stream_reused_session(
+    redis_client,
+    *,
+    session_id,
+    descriptor,
+    profile,
+    channel,
+    safe_ts,
+    timestamp,
+    duration_minutes,
+    client_id,
+    client_ip,
+    range_header,
+    channel_logo_id,
+    user,
+    debug,
+):
+    """Stream an idle pooled session that was just re-reserved for this request."""
+    try:
+        m3u_account = M3UAccount.objects.get(id=int(descriptor["account_id"]))
+    except (M3UAccount.DoesNotExist, ValueError, TypeError):
+        _discard_pool_session(redis_client, session_id, profile.id)
+        return None
+
+    provider_timestamp = descriptor.get("provider_timestamp")
+    if not provider_timestamp:
+        provider_tz_name = None
+        server_info = (profile.custom_properties or {}).get("server_info") or {}
+        if isinstance(server_info, dict):
+            provider_tz_name = server_info.get("timezone")
+        provider_timestamp = convert_timestamp_to_provider_tz(
+            timestamp, provider_tz_name
+        )
+
+    release_cb = _make_release_once(redis_client, session_id, profile.id)
+    try:
+        response = _attempt_timeshift_stream(
+            m3u_account=m3u_account,
+            profile=profile,
+            stream_id_value=descriptor["stream_id"],
+            provider_timestamp=provider_timestamp,
+            provider_tz_name=None,
+            duration_minutes=duration_minutes,
+            channel=channel,
+            safe_ts=safe_ts,
+            timestamp=timestamp,
+            client_id=client_id,
+            client_ip=client_ip,
+            range_header=range_header,
+            channel_logo_id=channel_logo_id,
+            user=user,
+            redis_client=redis_client,
+            debug=debug,
+            release_cb=release_cb,
+            pool_session_id=session_id,
+        )
+    except Exception:
+        _discard_pool_session(redis_client, session_id, profile.id)
+        raise
+
+    if response.status_code < 400:
+        return response
+
+    if getattr(response, "timeshift_passthrough", False) is True:
+        release_cb()
+        return response
+
+    _discard_pool_session(redis_client, session_id, profile.id)
+    return None
+
+
+class _SlotReleasingStream:
+    """Iterator wrapper that releases the pool slot when WSGI closes the response."""
+
+    def __init__(self, generator, on_close):
+        self._generator = generator
+        self._on_close = on_close
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        return next(self._generator)
+
+    def close(self):
+        try:
+            self._generator.close()
+        finally:
+            self._on_close()
+
+
+def _register_stats_client(
+    redis_client,
+    virtual_channel_id,
+    client_id,
+    client_ip,
+    user_agent,
+    user,
+    *,
+    channel_display_name,
+    timestamp_utc,
+    primary_url,
+    channel_logo_id=None,
+    m3u_profile_id=None,
+):
+    """Write Redis keys so catch-up viewers appear on ``/stats``."""
+    if redis_client is None:
+        return
+    client_set_key = RedisKeys.clients(virtual_channel_id)
+    client_key = RedisKeys.client_metadata(virtual_channel_id, client_id)
+    metadata_key = RedisKeys.channel_metadata(virtual_channel_id)
+    now = str(time.time())
+    client_payload = {
+        "user_agent": user_agent or "unknown",
+        "ip_address": client_ip,
+        "connected_at": now,
+        "last_active": now,
+        "user_id": str(user.id) if user is not None else "0",
+        "username": user.username if user is not None else "unknown",
+    }
+    metadata_payload = {
+        ChannelMetadataField.STATE: ChannelState.ACTIVE,
+        ChannelMetadataField.INIT_TIME: now,
+        ChannelMetadataField.OWNER: "timeshift",
+        ChannelMetadataField.CHANNEL_NAME: channel_display_name or "Timeshift",
+        ChannelMetadataField.STREAM_NAME: f"Catch-up @ {timestamp_utc} UTC" if timestamp_utc else "Catch-up",
+        ChannelMetadataField.URL: _redact_url(primary_url) if primary_url else "",
+        ChannelMetadataField.IS_TIMESHIFT: "1",
+    }
+    if channel_logo_id is not None:
+        metadata_payload[ChannelMetadataField.LOGO_ID] = str(channel_logo_id)
+    if m3u_profile_id is not None:
+        metadata_payload[ChannelMetadataField.M3U_PROFILE] = str(m3u_profile_id)
+    try:
+        pipe = redis_client.pipeline(transaction=False)
+        pipe.hset(client_key, mapping=client_payload)
+        pipe.expire(client_key, CLIENT_TTL_SECONDS)
+        pipe.sadd(client_set_key, client_id)
+        pipe.expire(client_set_key, CLIENT_TTL_SECONDS)
+        pipe.hset(metadata_key, mapping=metadata_payload)
+        pipe.expire(metadata_key, CLIENT_TTL_SECONDS)
+        pipe.execute()
+    except Exception as exc:
+        logger.warning("Timeshift stats register failed: %s", exc)
+
+
+def _heartbeat_stats_client(redis_client, virtual_channel_id, client_id, bytes_delta=0):
+    if redis_client is None:
+        return
+    client_set_key = RedisKeys.clients(virtual_channel_id)
+    client_key = RedisKeys.client_metadata(virtual_channel_id, client_id)
+    metadata_key = RedisKeys.channel_metadata(virtual_channel_id)
+    try:
+        pipe = redis_client.pipeline(transaction=False)
+        pipe.hset(client_key, "last_active", str(time.time()))
+        pipe.expire(client_key, CLIENT_TTL_SECONDS)
+        pipe.expire(client_set_key, CLIENT_TTL_SECONDS)
+        if bytes_delta > 0:
+            pipe.hincrby(metadata_key, ChannelMetadataField.TOTAL_BYTES, bytes_delta)
+        pipe.expire(metadata_key, CLIENT_TTL_SECONDS)
+        pipe.execute()
+    except Exception as exc:
+        logger.debug("Timeshift stats heartbeat failed: %s", exc)
+
+
+def _unregister_stats_client(redis_client, virtual_channel_id, client_id):
+    if redis_client is None:
+        return
+    client_set_key = RedisKeys.clients(virtual_channel_id)
+    client_key = RedisKeys.client_metadata(virtual_channel_id, client_id)
+    metadata_key = RedisKeys.channel_metadata(virtual_channel_id)
+    try:
+        redis_client.srem(client_set_key, client_id)
+        redis_client.delete(client_key)
+        if (redis_client.scard(client_set_key) or 0) == 0:
+            redis_client.delete(client_set_key)
+            redis_client.delete(metadata_key)
+    except Exception as exc:
+        logger.warning("Timeshift stats unregister failed: %s", exc)
+
+
+def _open_upstream(url, user_agent, range_header):
+    """Open upstream HTTP; redirects are followed (XC load-balancer nodes)."""
+    # identity: raw peek bytes are not gzip-transparent.
+    headers = {"Accept-Encoding": "identity"}
+    if user_agent:
+        headers["User-Agent"] = user_agent
+    if range_header:
+        headers["Range"] = range_header
+    return requests.get(
+        url,
+        headers=headers,
+        stream=True,
+        timeout=ConfigHelper.connection_timeout(),
+    )
+
+
+_FORMAT_CACHE_KEY = "timeshift:format_idx:{}"
+_FORMAT_CACHE_TTL = 3600  # 1 hour
+
+
+def _get_cached_format_index(account_id):
+    """Index of the URL shape that last worked for this account, or None."""
+    if account_id is None:
+        return None
+    return cache.get(_FORMAT_CACHE_KEY.format(account_id))
+
+
+def _set_cached_format_index(account_id, index):
+    if account_id is None:
+        return
+    cache.set(_FORMAT_CACHE_KEY.format(account_id), index, _FORMAT_CACHE_TTL)
+
+
+def _passthrough_response(status, content_range=None):
+    """A terminal response handed straight to the client (no streaming).
+
+    Marked so the failover loop and reuse path return it verbatim instead of
+    cascading other URL shapes or failing over to another provider.
+    """
+    response = HttpResponse(status=status)
+    if content_range:
+        response["Content-Range"] = content_range
+    response.timeshift_passthrough = True
+    return response
+
+
+def _stream_from_provider(
+    *,
+    candidate_urls,
+    user_agent,
+    range_header,
+    virtual_channel_id,
+    client_id,
+    client_ip,
+    user,
+    channel_display_name,
+    timestamp_utc,
+    channel_logo_id,
+    m3u_profile_id,
+    debug,
+    account_id=None,
+    redis_client=None,
+    release_cb=None,
+    pool_session_id=None,
+):
+    """Try each upstream URL until one returns streamable MPEG-TS.
+
+    Sets ``timeshift_decisive`` on auth/ban-class failures (401/403/406) so the
+    failover loop skips the rest of that account's streams. ``release_cb`` frees
+    the provider slot when the streaming response is closed.
+    """
+    chunk_size = max(ConfigHelper.chunk_size(), 262144)
+    if release_cb is None:
+        release_cb = lambda: None  # noqa: E731
+
+    cached_index = _get_cached_format_index(account_id)
+    if cached_index is not None and 0 <= cached_index < len(candidate_urls):
+        ordered_urls = [candidate_urls[cached_index]] + [
+            u for i, u in enumerate(candidate_urls) if i != cached_index
+        ]
+        original_indices = [cached_index] + [
+            i for i in range(len(candidate_urls)) if i != cached_index
+        ]
+    else:
+        ordered_urls = list(candidate_urls)
+        original_indices = list(range(len(candidate_urls)))
+
+    # Peek for MPEG-TS sync; some providers return HTTP 200 with PHP/HTML errors.
+    upstream = None
+    last_status = None
+    last_url = ordered_urls[0]
+    winning_index = None
+    decisive_failure = False
+    for url, orig_idx in zip(ordered_urls, original_indices):
+        try:
+            response = _open_upstream(url, user_agent, range_header)
+        except requests.exceptions.RequestException as exc:
+            logger.error(
+                "Timeshift provider unreachable (%s): %s",
+                _redact_url(url), type(exc).__name__,
+            )
+            return HttpResponseBadRequest("Provider connection error")
+        last_status = response.status_code
+        last_url = url
+        if debug:
+            logger.debug(
+                "Timeshift cascade[%d]: status=%d type=%s url=%s",
+                orig_idx, response.status_code,
+                response.headers.get("Content-Type", "?"),
+                _redact_url(url),
+            )
+        if response.status_code == 416:
+            # Range Not Satisfiable: a seek/tail probe past EOF. Hand it back to
+            # the client verbatim. Byte offsets are file-specific, so trying
+            # other URL shapes or failing over to another provider is pointless
+            # and only multiplies upstream connections.
+            content_range = response.headers.get("Content-Range")
+            response.close()
+            return _passthrough_response(416, content_range)
+        if response.status_code in (200, 206):
+            peek = response.raw.read(1024)
+            sync_offset = find_ts_sync(peek) if peek else -1
+            if sync_offset >= 0:
+                response._peek_data = peek[sync_offset:]
+                upstream = response
+                winning_index = orig_idx
+                break
+            # A 206 to a Range request legitimately starts mid-packet, so the
+            # sync byte rarely lands at offset 0. Trust the partial status and
+            # content type rather than the sync probe; only a full 200 carrying
+            # a PHP/HTML error page must be rejected here.
+            content_type = response.headers.get("Content-Type", "")
+            is_partial = response.status_code == 206 and bool(range_header)
+            if is_partial and peek and "html" not in content_type and "json" not in content_type:
+                response._peek_data = peek
+                upstream = response
+                winning_index = orig_idx
+                break
+            snippet = peek[:200].decode("utf-8", errors="replace") if peek else "(empty)"
+            logger.warning(
+                "Timeshift upstream returned %d but no TS sync in first %d "
+                "bytes (likely PHP error): %s, url=%s",
+                response.status_code,
+                len(peek) if peek else 0,
+                snippet.replace("\n", " ")[:120],
+                _redact_url(url),
+            )
+            response.close()
+            last_status = 404  # Treat as soft rejection for cascade
+            continue
+        response.close()
+        # Auth/ban-class statuses stop trying more shapes on this account; 5xx does not.
+        code = response.status_code
+        if code in (401, 403, 406) or 300 <= code < 400:
+            decisive_failure = True
+            break
+
+    if winning_index is not None:
+        _set_cached_format_index(account_id, winning_index)
+
+    if upstream is None:
+        logger.error("Timeshift upstream rejected: status=%s url=%s",
+                     last_status, _redact_url(last_url))
+        # Map 404/403 to meaningful client responses; other failures stay 400.
+        if last_status == 404:
+            failure = HttpResponseNotFound("Catch-up not available yet")
+        elif last_status == 403:
+            failure = HttpResponseForbidden("Provider denied access")
+        else:
+            failure = HttpResponseBadRequest("Provider error")
+        failure.timeshift_decisive = decisive_failure
+        return failure
+
+    content_type = upstream.headers.get("Content-Type", "video/mp2t")
+    content_range = upstream.headers.get("Content-Range", "")
+    status = upstream.status_code
+
+    _store_pool_content_length(redis_client, pool_session_id, upstream)
+    _store_pool_serving_range(redis_client, pool_session_id, range_header)
+
+    _register_stats_client(
+        redis_client,
+        virtual_channel_id,
+        client_id,
+        client_ip,
+        user_agent,
+        user,
+        channel_display_name=channel_display_name,
+        timestamp_utc=timestamp_utc,
+        primary_url=last_url,
+        channel_logo_id=channel_logo_id,
+        m3u_profile_id=m3u_profile_id,
+    )
+
+    peek_data = getattr(upstream, "_peek_data", None)
+    chunks_iter = upstream.iter_content(chunk_size=chunk_size)
+    if peek_data:
+        chunks_iter = itertools.chain([peek_data], chunks_iter)
+
+    session_closed = {"done": False}
+
+    def _finish_session(*, close_upstream=False):
+        if session_closed["done"]:
+            return
+        session_closed["done"] = True
+        if close_upstream:
+            try:
+                upstream.close()
+            except Exception:
+                pass
+        _unregister_stats_client(redis_client, virtual_channel_id, client_id)
+        release_cb()
+
+    def stream_generator():
+        last_heartbeat = time.time()
+        bytes_since_heartbeat = 0
+        total_yielded = 0
+        loop_start = time.time()
+        stop_key = RedisKeys.client_stop(virtual_channel_id, client_id)
+        stream_started_logged = False
+        try:
+            for data in chunks_iter:
+                if not data:
+                    continue
+                if debug and not stream_started_logged:
+                    stream_started_logged = True
+                    logger.debug(
+                        "Timeshift stream started: client=%s vid=%s range=%s status=%d",
+                        client_id, virtual_channel_id, range_header or "(none)", status,
+                    )
+                yield data
+                bytes_since_heartbeat += len(data)
+                total_yielded += len(data)
+
+                now = time.time()
+                if redis_client and redis_client.exists(stop_key):
+                    logger.info("Timeshift client %s received stop signal", client_id)
+                    redis_client.delete(stop_key)
+                    break
+                # Refresh stats every 5 seconds.
+                if now - last_heartbeat >= 5:
+                    if debug and total_yielded > 0:
+                        elapsed = now - loop_start
+                        mbps = (total_yielded * 8) / elapsed / 1_000_000 if elapsed > 0 else 0
+                        logger.debug(
+                            "Timeshift streaming: client=%s range=%s total=%d bytes "
+                            "in %.1fs (%.2f Mbps avg)",
+                            client_id, range_header or "(none)",
+                            total_yielded, elapsed, mbps,
+                        )
+                    _heartbeat_stats_client(
+                        redis_client, virtual_channel_id, client_id,
+                        bytes_delta=bytes_since_heartbeat,
+                    )
+                    last_heartbeat = now
+                    bytes_since_heartbeat = 0
+        except GeneratorExit:
+            pass
+        except Exception:
+            logger.exception("Timeshift stream loop error")
+        finally:
+            elapsed = time.time() - loop_start
+            if bytes_since_heartbeat > 0:
+                _heartbeat_stats_client(
+                    redis_client, virtual_channel_id, client_id,
+                    bytes_delta=bytes_since_heartbeat,
+                )
+            if debug and total_yielded > 0:
+                mbps = (total_yielded * 8) / elapsed / 1_000_000 if elapsed > 0 else 0
+                logger.debug(
+                    "Timeshift disconnect: vid=%s client=%s yielded=%d bytes in %.1fs (%.2f Mbps avg)",
+                    virtual_channel_id, client_id, total_yielded, elapsed, mbps,
+                )
+            _finish_session(close_upstream=True)
+
+    stream_iter = _SlotReleasingStream(stream_generator(), _finish_session)
+    response = StreamingHttpResponse(
+        stream_iter,
+        content_type=content_type,
+        status=status,
+    )
+    response["X-Accel-Buffering"] = "no"  # avoid nginx throttling the stream
+    if content_range:
+        response["Content-Range"] = content_range
+    response["Accept-Ranges"] = "bytes"
+    return response
+
+
+def _redact_url(url):
+    """Truncate *url* to ``scheme://host/...`` for safe logging (drops credentials)."""
+    if not url or "://" not in url:
+        return url
+    scheme, rest = url.split("://", 1)
+    if "@" in rest:
+        rest = rest.split("@", 1)[1]
+    host = rest.split("/", 1)[0]
+    return f"{scheme}://{host}/..."
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..676ef02d 100644
--- a/core/models.py
+++ b/core/models.py
@@ -280,8 +280,18 @@ class CoreSettings(models.Model):
             "epg_match_ignore_prefixes": [],
             "epg_match_ignore_suffixes": [],
             "epg_match_ignore_custom": [],
+            # XC catch-up: forced XMLTV lookback (0 = auto-detect, capped at 30).
+            "xmltv_prev_days_override": 0,
         })
 
+    @classmethod
+    def get_xmltv_prev_days_override(cls):
+        """Global XC XMLTV prev_days default (0 = auto-detect from provider archives)."""
+        try:
+            return int(cls.get_epg_settings().get("xmltv_prev_days_override", 0) or 0)
+        except (TypeError, ValueError):
+            return 0
+
     @classmethod
     def _safe_string_list(cls, value):
         """Return a list of strings, filtering out non-list or non-string values."""
@@ -394,7 +404,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 b562f335..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:
diff --git a/core/tests.py b/core/tests.py
index 7b2f1986..2af52f07 100644
--- a/core/tests.py
+++ b/core/tests.py
@@ -1,8 +1,8 @@
 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
 
 
@@ -37,14 +37,10 @@ class DispatcharrUserAgentTests(TestCase):
 
 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:
@@ -301,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 29c613b3..16d9ed85 100644
--- a/core/utils.py
+++ b/core/utils.py
@@ -546,13 +546,34 @@ def monitor_memory_usage(func):
         return result
     return wrapper
 
-def cleanup_memory(log_usage=False, force_collection=True):
+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, trim_heap=False):
     """
     Comprehensive memory cleanup function to reduce memory footprint
 
     Args:
         log_usage: Whether to log memory usage before and after cleanup
         force_collection: Whether to force garbage collection
+        trim_heap: Return freed C heap pages to the OS. Only use after DB
+            connections are closed (e.g. Celery task_postrun).
     """
     logger.trace("Starting memory cleanup django memory cleanup")
     # Skip logging if log level is not set to debug or more verbose (like trace)
@@ -587,8 +608,33 @@ def cleanup_memory(log_usage=False, force_collection=True):
             logger.debug(f"Memory after cleanup: {after_mem:.2f} MB (change: {after_mem-before_mem:.2f} MB)")
         except (ImportError, Exception):
             pass
+    if trim_heap:
+        trim_c_allocator_heap()
     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_heap=True)
+
+    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.
 
diff --git a/dispatcharr/celery.py b/dispatcharr/celery.py
index 18be81eb..16a393dc 100644
--- a/dispatcharr/celery.py
+++ b/dispatcharr/celery.py
@@ -99,6 +99,7 @@ def cleanup_task_memory(**kwargs):
     memory_intensive_tasks = [
         'apps.m3u.tasks.refresh_single_m3u_account',
         'apps.m3u.tasks.refresh_m3u_accounts',
+        'apps.m3u.tasks.refresh_m3u_groups',
         'apps.m3u.tasks.process_m3u_batch',
         'apps.m3u.tasks.process_xc_category',
         'apps.m3u.tasks.sync_auto_channels',
@@ -121,7 +122,7 @@ def cleanup_task_memory(**kwargs):
         from core.utils import cleanup_memory
 
         # Use the comprehensive cleanup function
-        cleanup_memory(log_usage=True, force_collection=True)
+        cleanup_memory(log_usage=True, force_collection=True, trim_heap=True)
 
         # Log memory usage if psutil is installed
         try:
diff --git a/dispatcharr/settings.py b/dispatcharr/settings.py
index a22e5f9c..a1e2b798 100644
--- a/dispatcharr/settings.py
+++ b/dispatcharr/settings.py
@@ -99,6 +99,7 @@ INSTALLED_APPS = [
     "django_filters",
     "django_celery_beat",
     "apps.plugins",
+    "apps.timeshift.apps.TimeshiftConfig",
 ]
 
 # EPG Processing optimization settings
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/dispatcharr/urls.py b/dispatcharr/urls.py
index 9123f3da..cdedb0c4 100644
--- a/dispatcharr/urls.py
+++ b/dispatcharr/urls.py
@@ -7,6 +7,7 @@ from .routing import websocket_urlpatterns
 from apps.output.views import xc_player_api, xc_panel_api, xc_get, xc_xmltv
 from apps.proxy.live_proxy.views import stream_xc
 from apps.proxy.vod_proxy.views import stream_xc_movie, stream_xc_episode
+from apps.timeshift.views import timeshift_proxy
 
 urlpatterns = [
     # API Routes
@@ -41,6 +42,11 @@ urlpatterns = [
         stream_xc,
         name="xc_stream_endpoint",
     ),
+    path(
+        "timeshift/<str:username>/<str:password>/<str:stream_id>/<str:timestamp>/<str:duration>",
+        timeshift_proxy,
+        name="timeshift_proxy",
+    ),
     # XC VOD endpoints
     path(
         "movie/<str:username>/<str:password>/<str:stream_id>.<str:extension>",
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 4cbb3d89..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,
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/M3URefreshNotification.jsx b/frontend/src/components/M3URefreshNotification.jsx
index 8e24bdb3..f1966295 100644
--- a/frontend/src/components/M3URefreshNotification.jsx
+++ b/frontend/src/components/M3URefreshNotification.jsx
@@ -52,6 +52,22 @@ const M3uSetupSuccess = ({ data }) => {
 };
 
 // One-line outcome summary for the notification body.
+const buildStreamSummary = (data) => {
+  if (data.streams_processed == null && data.streams_created == null) {
+    return null;
+  }
+  const created = data.streams_created || 0;
+  const updated = data.streams_updated || 0;
+  const stale = data.streams_stale || 0;
+  const removed = data.streams_deleted || 0;
+  const processed = data.streams_processed || 0;
+  return (
+    `Streams: ${created} created, ${updated} updated, ` +
+    `${stale} marked stale, ${removed} removed. ` +
+    `Total processed: ${processed}.`
+  );
+};
+
 const buildAutoSyncSummary = (data) => {
   const created = data.channels_created || 0;
   const updated = data.channels_updated || 0;
@@ -211,21 +227,29 @@ export default function M3URefreshNotification() {
 
     let body = message;
     let autoClose = 2000;
-    // Surface auto-sync counts attached to the parsing-complete event
-    // so the channel-side outcome appears in the notification body.
+    // Surface stream and auto-sync counts attached to the parsing-complete
+    // event so the outcome appears in the notification body.
     if (data.progress == 100 && data.action === 'parsing') {
+      const streamSummary = buildStreamSummary(data);
       const autoSyncSummary = buildAutoSyncSummary(data);
       const failed = data.channels_failed || 0;
       const failedDetails = Array.isArray(data.failed_stream_details)
         ? data.failed_stream_details
         : [];
-      if (autoSyncSummary) {
+      if (streamSummary || autoSyncSummary) {
         body = (
           <Stack gap={4}>
             <Text size="sm">{message}</Text>
-            <Text size="xs" c="dimmed">
-              {autoSyncSummary}
-            </Text>
+            {streamSummary && (
+              <Text size="xs" c="dimmed">
+                {streamSummary}
+              </Text>
+            )}
+            {autoSyncSummary && (
+              <Text size="xs" c="dimmed">
+                {autoSyncSummary}
+              </Text>
+            )}
             {failed > 0 && failedDetails.length > 0 && (
               <Button
                 size="xs"
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__/M3URefreshNotification.test.jsx b/frontend/src/components/__tests__/M3URefreshNotification.test.jsx
index 734d83e4..5faaf46d 100644
--- a/frontend/src/components/__tests__/M3URefreshNotification.test.jsx
+++ b/frontend/src/components/__tests__/M3URefreshNotification.test.jsx
@@ -851,4 +851,37 @@ describe('M3URefreshNotification', () => {
       expect(call[0].autoClose).toBe(12000);
     });
   });
+
+  describe('Stream count rendering on parsing complete', () => {
+    it('inlines stream summary including marked stale count', async () => {
+      mockPlaylistsStore.refreshProgress = {
+        1: {
+          account: 1,
+          action: 'parsing',
+          progress: 100,
+          status: 'success',
+          streams_created: 2,
+          streams_updated: 5,
+          streams_stale: 18,
+          streams_deleted: 3,
+          streams_processed: 1200,
+        },
+      };
+
+      renderWithProviders(<M3URefreshNotification />);
+
+      await waitFor(() => {
+        expect(showNotification).toHaveBeenCalled();
+      });
+      const call = showNotification.mock.calls.find(
+        (c) => typeof c[0]?.message === 'object'
+      );
+      expect(call).toBeDefined();
+      const { container } = render(<>{call[0].message}</>);
+      expect(container.textContent).toContain('Stream parsing complete!');
+      expect(container.textContent).toContain('18 marked stale');
+      expect(container.textContent).toContain('3 removed');
+      expect(container.textContent).toContain('Total processed: 1200');
+    });
+  });
 });
diff --git a/frontend/src/components/cards/StreamConnectionCard.jsx b/frontend/src/components/cards/StreamConnectionCard.jsx
index a1748143..ae85b410 100644
--- a/frontend/src/components/cards/StreamConnectionCard.jsx
+++ b/frontend/src/components/cards/StreamConnectionCard.jsx
@@ -22,6 +22,7 @@ import {
   Gauge,
   HardDriveDownload,
   HardDriveUpload,
+  Rewind,
   SquareX,
   Timer,
   Users,
@@ -486,7 +487,10 @@ const StreamConnectionCard = ({
   }, [channel.name, channel.stream_id]);
 
   const channelName =
-    channel.name || previewedStream?.name || 'Unnamed Channel';
+    channel.name ||
+    channel.channel_name ||
+    previewedStream?.name ||
+    'Unnamed Channel';
   const uptime = channel.uptime || 0;
   const bitrates = channel.bitrates || [];
   const totalBytes = channel.total_bytes || 0;
@@ -661,6 +665,18 @@ const StreamConnectionCard = ({
 
         {/* Add stream information badges */}
         <Group gap="xs" mt="5">
+          {channel.is_timeshift && (
+            <Tooltip label="Catch-up (timeshift)">
+              <Badge
+                size="sm"
+                variant="light"
+                color="violet"
+                leftSection={<Rewind size={12} />}
+              >
+                TIMESHIFT
+              </Badge>
+            </Tooltip>
+          )}
           {channel.resolution && (
             <Tooltip label="Video resolution">
               <Badge size="sm" variant="light" color="red">
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/settings/EpgSettingsForm.jsx b/frontend/src/components/forms/settings/EpgSettingsForm.jsx
new file mode 100644
index 00000000..5668dbdd
--- /dev/null
+++ b/frontend/src/components/forms/settings/EpgSettingsForm.jsx
@@ -0,0 +1,81 @@
+import useSettingsStore from '../../../store/settings.jsx';
+import React, { useEffect, useState } from 'react';
+import { useForm } from '@mantine/form';
+import {
+  Alert,
+  Button,
+  Flex,
+  NumberInput,
+  Stack,
+  Text,
+} from '@mantine/core';
+import { EPG_SETTINGS_OPTIONS } from '../../../constants.js';
+import {
+  getChangedSettings,
+  parseSettings,
+  saveChangedSettings,
+} from '../../../utils/pages/SettingsUtils.js';
+import { getEpgSettingsFormInitialValues } from '../../../utils/forms/settings/EpgSettingsFormUtils.js';
+
+const EpgSettingsForm = React.memo(({ active }) => {
+  const settings = useSettingsStore((s) => s.settings);
+  const [saved, setSaved] = useState(false);
+
+  const form = useForm({
+    mode: 'controlled',
+    initialValues: getEpgSettingsFormInitialValues(),
+  });
+
+  useEffect(() => {
+    if (!active) setSaved(false);
+  }, [active]);
+
+  useEffect(() => {
+    if (settings) {
+      const parsed = parseSettings(settings);
+      form.setFieldValue(
+        'xmltv_prev_days_override',
+        parsed.xmltv_prev_days_override ?? 0,
+      );
+    }
+  }, [settings]);
+
+  const onSubmit = async () => {
+    setSaved(false);
+    const changedSettings = getChangedSettings(form.getValues(), settings);
+    try {
+      await saveChangedSettings(settings, changedSettings);
+      setSaved(true);
+    } catch (error) {
+      console.error('Error saving EPG settings:', error);
+    }
+  };
+
+  const prevDaysConfig = EPG_SETTINGS_OPTIONS.xmltv_prev_days_override;
+
+  return (
+    <form onSubmit={form.onSubmit(onSubmit)}>
+      <Stack gap="md">
+        {saved && (
+          <Alert variant="light" color="green" title="Saved Successfully" />
+        )}
+        <NumberInput
+          label={prevDaysConfig.label}
+          description={prevDaysConfig.description}
+          min={0}
+          max={30}
+          {...form.getInputProps('xmltv_prev_days_override')}
+        />
+        <Text size="xs" c="dimmed">
+          Per-user defaults and URL parameters still override this global value.
+          EPG channel matching options are configured from the Channels page.
+        </Text>
+        <Flex justify="flex-end">
+          <Button type="submit">Save</Button>
+        </Flex>
+      </Stack>
+    </form>
+  );
+});
+
+export default EpgSettingsForm;
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/constants.js b/frontend/src/constants.js
index 92aba531..ecb7daca 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)',
@@ -62,6 +71,14 @@ export const PROXY_SETTINGS_OPTIONS = {
   },
 };
 
+export const EPG_SETTINGS_OPTIONS = {
+  xmltv_prev_days_override: {
+    label: 'XMLTV prev_days Override (catch-up)',
+    description:
+      'Days of past programmes in the XC EPG output. 0 = auto-detect from the providers’ tv_archive_duration (capped at 30).',
+  },
+};
+
 export const USER_LIMITS_OPTIONS = {
   terminate_on_limit_exceeded: {
     label: 'Terminate on Limit Exceeded',
diff --git a/frontend/src/pages/Settings.jsx b/frontend/src/pages/Settings.jsx
index 29d46dd8..1c7964cc 100644
--- a/frontend/src/pages/Settings.jsx
+++ b/frontend/src/pages/Settings.jsx
@@ -45,6 +45,9 @@ const DvrSettingsForm = React.lazy(
 const SystemSettingsForm = React.lazy(
   () => import('../components/forms/settings/SystemSettingsForm.jsx')
 );
+const EpgSettingsForm = React.lazy(
+  () => import('../components/forms/settings/EpgSettingsForm.jsx')
+);
 const NavOrderForm = React.lazy(
   () => import('../components/forms/settings/NavOrderForm.jsx')
 );
@@ -122,6 +125,19 @@ const SettingsPage = () => {
                 </AccordionPanel>
               </AccordionItem>
 
+              <AccordionItem value="epg-settings">
+                <AccordionControl>EPG</AccordionControl>
+                <AccordionPanel>
+                  <ErrorBoundary>
+                    <Suspense fallback={<Loader />}>
+                      <EpgSettingsForm
+                        active={accordianValue === 'epg-settings'}
+                      />
+                    </Suspense>
+                  </ErrorBoundary>
+                </AccordionPanel>
+              </AccordionItem>
+
               <AccordionItem value="system-settings">
                 <AccordionControl>System Settings</AccordionControl>
                 <AccordionPanel>
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/__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/EpgSettingsFormUtils.js b/frontend/src/utils/forms/settings/EpgSettingsFormUtils.js
new file mode 100644
index 00000000..d2138b6a
--- /dev/null
+++ b/frontend/src/utils/forms/settings/EpgSettingsFormUtils.js
@@ -0,0 +1,3 @@
+export const getEpgSettingsFormInitialValues = () => ({
+  xmltv_prev_days_override: 0,
+});
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/frontend/src/utils/pages/SettingsUtils.js b/frontend/src/utils/pages/SettingsUtils.js
index b097accd..bd46ac52 100644
--- a/frontend/src/utils/pages/SettingsUtils.js
+++ b/frontend/src/utils/pages/SettingsUtils.js
@@ -39,6 +39,7 @@ export const saveChangedSettings = async (settings, changedSettings) => {
     'epg_match_ignore_prefixes',
     'epg_match_ignore_suffixes',
     'epg_match_ignore_custom',
+    'xmltv_prev_days_override',
   ];
   const dvrFields = [
     'tv_template',
@@ -125,6 +126,7 @@ export const saveChangedSettings = async (settings, changedSettings) => {
       'retention_count',
       'schedule_day_of_week',
       'max_system_events',
+      'xmltv_prev_days_override',
     ];
     if (numericFields.includes(formKey) && value != null) {
       value = typeof value === 'number' ? value : parseInt(value, 10);
@@ -222,6 +224,20 @@ export const getChangedSettings = (values, settings) => {
       continue;
     }
 
+    if (settingKey === 'xmltv_prev_days_override') {
+      const baseline = Number(
+        settings['epg_settings']?.value?.xmltv_prev_days_override ?? 0,
+      );
+      const nextVal =
+        typeof actualValue === 'number'
+          ? actualValue
+          : parseInt(actualValue, 10) || 0;
+      if (nextVal !== baseline) {
+        changedSettings[settingKey] = nextVal;
+      }
+      continue;
+    }
+
     // Convert array values (like m3u_hash_key) to comma-separated strings for comparison
     if (Array.isArray(actualValue)) {
       actualValue = actualValue.join(',');
@@ -296,6 +312,12 @@ export const parseSettings = (settings) => {
     epgSettings && Array.isArray(epgSettings.epg_match_ignore_custom)
       ? epgSettings.epg_match_ignore_custom
       : [];
+  parsed.xmltv_prev_days_override =
+    epgSettings && epgSettings.xmltv_prev_days_override != null
+      ? typeof epgSettings.xmltv_prev_days_override === 'number'
+        ? epgSettings.xmltv_prev_days_override
+        : parseInt(epgSettings.xmltv_prev_days_override, 10) || 0
+      : 0;
 
   // DVR settings - direct mapping with underscore keys
   const dvrSettings = settings['dvr_settings']?.value;
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/tests/test_process_label.py b/tests/test_process_label.py
index bb4c8429..e4525a85 100644
--- a/tests/test_process_label.py
+++ b/tests/test_process_label.py
@@ -17,13 +17,13 @@ class ProcessLabelTests(SimpleTestCase):
         self.assertEqual(role, "uwsgi")
 
     def test_uwsgi_labeled_when_worker_module_present(self):
-        fake_uwsgi = type("uwsgi", (), {"worker_id": lambda: 2})()
+        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": lambda: 0})()
+        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 87a27e3c..25ccd35c 100644
--- a/version.py
+++ b/version.py
@@ -1,5 +1,5 @@
 """
 Dispatcharr version information.
 """
-__version__ = '0.27.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