Merge branch 'dev' into pr/cmcpherson274/1105

CHANGELOG.md

@@ -16,7 +16,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   - Order and visibility are saved per-user with optimistic updates and automatic rollback on failure. Changes appear in the sidebar immediately without a page reload.
   - Admin users see a grouped navigation: flat items (`Channels`, `VODs`, `M3U & EPG Manager`, `TV Guide`, `DVR`, `Stats`, `Plugins`) plus collapsible `Integrations` (Connections, Logs) and `System` (Users, Logo Manager, Settings) groups. The `System` group cannot be hidden.
   - Non-admin users see `Channels`, `TV Guide`, and `Settings`, with the `Settings` item not hideable.
-- Unit tests for `NotificationCenter`, `NotificationCenterUtils`, and `M3URefreshNotification` components. — Thanks [@nick4810](https://github.com/nick4810)
+- Unit tests for `NotificationCenter`, `NotificationCenterUtils`, and `M3URefreshNotification` components, and for settings form components `DvrSettingsForm`, `NetworkAccessForm`, `ProxySettingsForm`, `StreamSettingsForm`, `SystemSettingsForm`, `UiSettingsForm`. — Thanks [@nick4810](https://github.com/nick4810)
 - Unit tests for DVR port resolution (`build_dvr_candidates`) and selective Redis flush behavior in modular mode. — Thanks [@CodeBormen](https://github.com/CodeBormen)
 - Floating video player improvements
   - **Title display**: The channel, stream, or VOD title is now shown in the player header bar. Title is passed through from all preview entry points: channel table, stream table, stream connection card, guide, DVR, recording cards, recording details modal, VOD modal, and series modal.
@@ -41,6 +41,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   - **Search and filter controls**: Added search and filter controls to the recordings list.
   - **Stream generator throttling**: Cached the `ProxyServer` singleton reference per client and throttled Redis resource checks (1 s) and non-owner health checks (2 s), eliminating 3+ Redis round-trips per stream loop iteration.
   - **Automatic crash recovery on worker restart**: A `worker_ready` Celery signal now fires `recover_recordings_on_startup` automatically when the worker starts, so recordings stuck in "recording" status are recovered without manual intervention.
+- Account expiration tracking and notifications for M3U profiles
+  - A new `exp_date` field on `M3UAccountProfile` stores the account expiration date as a proper `DateTimeField`. For Xtream Codes accounts the field is auto-synced from `custom_properties.user_info.exp_date` on every save (supports both Unix timestamps and ISO date strings). For non-XC M3U accounts the date can be entered manually via the account or profile form.
+  - The M3U accounts table now shows an **Expiration** column displaying the earliest expiration date across all profiles for that account (color-coded: red = expired, orange = expiring soon, green = OK). Hovering the cell shows a tooltip with per-profile expiration details including inactive-profile labels.
+  - A daily Celery Beat task (`check_xc_account_expirations`) checks all active profiles with an expiration date and manages system notifications: a normal-priority warning is raised for profiles expiring within 7 days; a high-priority alert is raised once the profile has already expired. Warning and expired notifications use separate keys so dismissing the 7-day warning does not suppress the expiration alert.
+  - Notifications are also updated immediately when a profile is saved: if the expiration date is cleared or pushed beyond the 7-day window, any existing warning/expired notifications are deleted; if the date falls within the window or is already past, the matching notification is updated in place.
+  - Non-XC accounts expose a `DateTimePicker` on both the M3U account form and the profile form.
 
 ### Changed
 
@@ -69,6 +75,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Fixed
 
+- uWSGI segfaults caused by mixing threading and gevent concurrency models. The dev and debug uWSGI configs had `threads` and `enable-threads = true` set alongside gevent, which triggers segmentation faults particularly on ARM64/Python 3.13. Removed those options to match the already-correct production config. — Thanks [@jcasimir](https://github.com/jcasimir)
+- `Stream.last_seen` and `ChannelGroupM3UAccount.last_seen` model defaults now use `django.utils.timezone.now` instead of `datetime.datetime.now`, eliminating spurious `RuntimeWarning: DateTimeField received a naive datetime` warnings emitted during test database creation and on new record creation when `USE_TZ=True`.
 - EPG programme parsing crash when an XMLTV source contains programme titles exceeding 255 characters. Previously, a single oversized title would cause the entire `bulk_create` batch to fail with a database truncation error, silently dropping all programmes in that batch. Titles are now truncated to 255 characters before being saved. (Fixes #1039)
 - Container startup failure when `PUID`/`PGID` is set, caused by `/data/db` ownership conflicts between the `postgres` system user (UID 102) and the configured PUID/PGID. PostgreSQL now runs as the PUID/PGID user in AIO mode, eliminating all `chown`-to-UID-102 operations and unifying `/data` ownership. (Fixes #1078) — Thanks [@CodeBormen](https://github.com/CodeBormen)
   - Existing installations where PUID/PGID differs from the current `/data/db` owner are migrated automatically on first startup; a sentinel file prevents redundant recursive `chown` on subsequent boots.
@@ -110,6 +118,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   - **`update_stream_profile()` uses a Redis pipeline** for the old-profile DECR + key update + new-profile INCR sequence, preventing counter drift if the process crashes between operations.
   - **`stream_generator._cleanup()`** now falls back to `Stream.objects.get()` when the channel UUID resolves to a preview flow rather than a normal channel, rather than silently skipping the slot release.
   - **VOD `cleanup_persistent_connection()`** fallback DECR is now conditional: it only decrements the profile counter when the connection tracking key had already expired by TTL (i.e., `remove_connection()` would have skipped the DECR), preventing double-decrements when the key is still present.
+- Ghost clients and channels stuck in `INITIALIZING` state in the TS proxy (Fixes #695, #669) — Thanks [@CodeBormen](https://github.com/CodeBormen)
+  - **`INITIALIZING` added to cleanup grace period monitoring**: channels stuck in `INITIALIZING` are now surfaced by the cleanup task and torn down, preventing indefinite hangs when stream startup fails.
+  - **Orphaned channel cleanup validates client SET entries**: the cleanup task now cross-checks client SET members against actual metadata hashes; ghost SET entries are removed and the channel is torn down cleanly when no real clients remain.
+  - **Stats page self-heals**: ghost client SET entries are detected and removed when reading channel stats, preventing stale entries from inflating the active-client count.
+  - **`remove_ghost_clients()` extracted to `ClientManager`**: ghost-detection logic is now a single authoritative helper, callable with an optional pre-fetched `client_ids` set to eliminate a redundant Redis `SMEMBERS` round-trip when the caller already holds the set.
+  - **Ownership TTL fallback**: the error-state writer now triggers via ownership check _or_ state guard fallback, so a channel stuck in a pre-active state is correctly marked `ERROR` even when the ownership TTL expired during retries.
+  - **Missing `SOURCE_BITRATE` / `FFMPEG_BITRATE` metadata constants** added to `ChannelMetadataField`, preventing `AttributeError` on detailed channel stats reads.
 - TS proxy client stream lag recovery now only bumps clients forward when their next required chunk has genuinely expired from Redis (TTL), rather than unconditionally jumping if they fell more than 50 chunks behind. Clients are repositioned to the oldest available chunk (minimum data loss) using an atomic server-side Lua binary search, falling back to near the buffer head if nothing is available.
 - TS proxy streams dying after 30–200 seconds in multi-worker uWSGI/Celery deployments, caused by three interrelated bugs. (Fixes #992, #980) - Thanks [@PFalko](https://github.com/PFalko)
   - **Double ProxyServer instantiation**: `ProxyConfig.ready()` called `TSProxyServer()` directly while `TSProxyConfig.ready()` also called `TSProxyServer.get_instance()`, creating two instances per worker — each with its own cleanup thread. The orphaned thread could not extend ownership because it had no entries in `stream_managers`. Fixed by using `TSProxyServer.get_instance()` in `ProxyConfig.ready()`.

apps/channels/migrations/0005_stream_channel_group_stream_last_seen_and_more.py

@@ -1,7 +1,7 @@
 # Generated by Django 5.1.6 on 2025-03-19 16:33
 
-import datetime
 import django.db.models.deletion
+import django.utils.timezone
 import uuid
 from django.db import migrations, models
 
@@ -22,7 +22,7 @@ class Migration(migrations.Migration):
         migrations.AddField(
             model_name='stream',
             name='last_seen',
-            field=models.DateTimeField(db_index=True, default=datetime.datetime.now),
+            field=models.DateTimeField(db_index=True, default=django.utils.timezone.now),
         ),
         migrations.AlterField(
             model_name='channel',

apps/channels/migrations/0031_channelgroupm3uaccount_is_stale_and_more.py

@@ -1,6 +1,6 @@
 # Generated by Django 5.2.9 on 2026-01-09 18:19
 
-import datetime
+import django.utils.timezone
 from django.db import migrations, models
 
 
@@ -19,7 +19,7 @@ class Migration(migrations.Migration):
         migrations.AddField(
             model_name='channelgroupm3uaccount',
             name='last_seen',
-            field=models.DateTimeField(db_index=True, default=datetime.datetime.now, help_text='Last time this group was seen in the M3U source during a refresh'),
+            field=models.DateTimeField(db_index=True, default=django.utils.timezone.now, help_text='Last time this group was seen in the M3U source during a refresh'),
         ),
         migrations.AddField(
             model_name='stream',

apps/channels/models.py

@@ -7,7 +7,7 @@ from apps.proxy.ts_proxy.redis_keys import RedisKeys
 from apps.proxy.ts_proxy.constants import ChannelMetadataField
 import logging
 import uuid
-from datetime import datetime
+from django.utils import timezone
 import hashlib
 import json
 from apps.epg.models import EPGData
@@ -95,7 +95,7 @@ class Stream(models.Model):
         help_text="Unique hash for this stream from the M3U account",
         db_index=True,
     )
-    last_seen = models.DateTimeField(db_index=True, default=datetime.now)
+    last_seen = models.DateTimeField(db_index=True, default=timezone.now)
     is_stale = models.BooleanField(
         default=False,
         db_index=True,
@@ -739,7 +739,7 @@ class ChannelGroupM3UAccount(models.Model):
         help_text='Starting channel number for auto-created channels in this group'
     )
     last_seen = models.DateTimeField(
-        default=datetime.now,
+        default=timezone.now,
         db_index=True,
         help_text='Last time this group was seen in the M3U source during a refresh'
     )

apps/channels/tests/test_ts_proxy_ghost_clients.py

@@ -0,0 +1,385 @@
+"""Tests for ghost client detection and cleanup.
+
+Covers:
+  - ClientManager.remove_ghost_clients() pipelined EXISTS logic
+  - channel_status detailed stats path removes ghost clients from Redis SET
+  - channel_status basic stats path removes ghost clients and corrects count
+  - _check_orphaned_metadata() validates client SET entries and cleans up
+    channels where all clients are ghosts
+"""
+from unittest.mock import MagicMock, patch, PropertyMock
+
+from django.test import TestCase
+
+from apps.proxy.ts_proxy.client_manager import ClientManager
+from apps.proxy.ts_proxy.constants import ChannelMetadataField, ChannelState
+from apps.proxy.ts_proxy.redis_keys import RedisKeys
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+CHANNEL_ID = "00000000-0000-0000-0000-000000000001"
+
+
+def _make_proxy_server(redis_client=None):
+    """Create a minimal mock ProxyServer with a redis_client."""
+    server = MagicMock()
+    server.redis_client = redis_client or MagicMock()
+    server.stream_managers = {}
+    server.client_managers = {}
+    server.worker_id = "test-worker-1"
+    return server
+
+
+def _metadata_for_channel(state="active"):
+    """Return a plausible channel metadata dict (bytes keys/values)."""
+    return {
+        ChannelMetadataField.STATE.encode(): state.encode(),
+        ChannelMetadataField.URL.encode(): b"http://example.com/stream",
+        ChannelMetadataField.STREAM_PROFILE.encode(): b"default",
+        ChannelMetadataField.OWNER.encode(): b"test-worker-1",
+        ChannelMetadataField.INIT_TIME.encode(): b"1773500000.0",
+    }
+
+
+# ---------------------------------------------------------------------------
+# Unit tests for ClientManager.remove_ghost_clients()
+# ---------------------------------------------------------------------------
+
+class RemoveGhostClientsTests(TestCase):
+    """Directly exercises the static method that all callers rely on."""
+
+    def test_ghost_removed_and_returned(self):
+        """Client ID in SET with no metadata hash should be SREM'd."""
+        redis = MagicMock()
+        redis.smembers.return_value = {b"ghost_001"}
+
+        pipe = MagicMock()
+        redis.pipeline.return_value = pipe
+        pipe.execute.return_value = [False]  # EXISTS → False
+
+        result = ClientManager.remove_ghost_clients(redis, CHANNEL_ID)
+
+        self.assertEqual(result, [b"ghost_001"])
+        redis.srem.assert_called_once()
+
+    def test_live_client_preserved(self):
+        """Client with valid metadata hash should NOT be removed."""
+        redis = MagicMock()
+        redis.smembers.return_value = {b"live_001"}
+
+        pipe = MagicMock()
+        redis.pipeline.return_value = pipe
+        pipe.execute.return_value = [True]  # EXISTS → True
+
+        result = ClientManager.remove_ghost_clients(redis, CHANNEL_ID)
+
+        self.assertEqual(result, [])
+        redis.srem.assert_not_called()
+
+    def test_mixed_ghost_and_live(self):
+        """Only ghost clients should be removed; live ones preserved."""
+        redis = MagicMock()
+        redis.smembers.return_value = {b"ghost_001", b"live_001"}
+
+        pipe = MagicMock()
+        redis.pipeline.return_value = pipe
+        # Order matches list(smembers), which is non-deterministic —
+        # map both IDs so the test is stable regardless of iteration order.
+        client_id_list = list(redis.smembers.return_value)
+
+        def exists_results():
+            return [
+                b"ghost_001" not in cid.decode() == False
+                for cid in client_id_list
+            ]
+
+        # Simpler: mock based on key content
+        def pipe_exists(key):
+            pass  # just enqueued; results come from execute()
+
+        pipe.exists.side_effect = pipe_exists
+        pipe.execute.return_value = [
+            "live" in cid.decode() for cid in client_id_list
+        ]
+
+        result = ClientManager.remove_ghost_clients(redis, CHANNEL_ID)
+
+        self.assertEqual(len(result), 1)
+        self.assertTrue(any(b"ghost" in cid for cid in result))
+        redis.srem.assert_called_once()
+
+    def test_empty_set_returns_empty(self):
+        """No clients means nothing to clean."""
+        redis = MagicMock()
+        redis.smembers.return_value = set()
+
+        result = ClientManager.remove_ghost_clients(redis, CHANNEL_ID)
+
+        self.assertEqual(result, [])
+        redis.pipeline.assert_not_called()
+
+    def test_pre_fetched_client_ids_skips_smembers(self):
+        """When client_ids is passed, SMEMBERS should not be called."""
+        redis = MagicMock()
+        pipe = MagicMock()
+        redis.pipeline.return_value = pipe
+        pipe.execute.return_value = [False]
+
+        pre_fetched = {b"ghost_001"}
+        result = ClientManager.remove_ghost_clients(
+            redis, CHANNEL_ID, client_ids=pre_fetched
+        )
+
+        redis.smembers.assert_not_called()
+        self.assertEqual(len(result), 1)
+
+
+# ---------------------------------------------------------------------------
+# Detailed stats path: exercises get_detailed_channel_info()
+# ---------------------------------------------------------------------------
+
+@patch("apps.proxy.ts_proxy.channel_status.ProxyServer")
+class DetailedStatsGhostClientTests(TestCase):
+    """get_detailed_channel_info() should remove ghost clients whose metadata
+    hash has expired from the Redis client SET."""
+
+    def _setup_redis(self, mock_proxy_cls, client_ids, hgetall_side_effect):
+        """Wire up a mock ProxyServer with controlled Redis responses."""
+        redis = MagicMock()
+        server = _make_proxy_server(redis)
+        mock_proxy_cls.get_instance.return_value = server
+
+        redis.hgetall.side_effect = hgetall_side_effect
+        redis.smembers.return_value = client_ids
+        # buffer_index, ttl, exists all need safe defaults
+        redis.get.return_value = b"10"
+        redis.ttl.return_value = 300
+        redis.exists.return_value = True
+        return redis
+
+    def test_ghost_client_removed_from_set(self, mock_proxy_cls):
+        """Ghost client should be SREM'd and excluded from result."""
+        from apps.proxy.ts_proxy.channel_status import ChannelStatus
+
+        def hgetall_side_effect(key):
+            if "clients:" in key:
+                return {}  # ghost — metadata expired
+            return _metadata_for_channel()
+
+        redis = self._setup_redis(
+            mock_proxy_cls, {b"ghost_001"}, hgetall_side_effect
+        )
+
+        result = ChannelStatus.get_detailed_channel_info(CHANNEL_ID)
+
+        self.assertEqual(result['client_count'], 0)
+        self.assertEqual(len(result['clients']), 0)
+        redis.srem.assert_called_once()
+
+    def test_live_client_preserved(self, mock_proxy_cls):
+        """Client with valid metadata should appear in results."""
+        from apps.proxy.ts_proxy.channel_status import ChannelStatus
+
+        def hgetall_side_effect(key):
+            if "clients:" in key:
+                return {
+                    b'user_agent': b'VLC/3.0',
+                    b'worker_id': b'test-worker-1',
+                    b'connected_at': b'1773500000.0',
+                }
+            return _metadata_for_channel()
+
+        redis = self._setup_redis(
+            mock_proxy_cls, {b"live_001"}, hgetall_side_effect
+        )
+
+        result = ChannelStatus.get_detailed_channel_info(CHANNEL_ID)
+
+        self.assertEqual(result['client_count'], 1)
+        self.assertEqual(len(result['clients']), 1)
+        redis.srem.assert_not_called()
+
+    def test_mixed_ghost_and_live(self, mock_proxy_cls):
+        """Only ghost clients should be removed; live ones preserved."""
+        from apps.proxy.ts_proxy.channel_status import ChannelStatus
+
+        def hgetall_side_effect(key):
+            if "clients:" in key:
+                if "ghost" in key:
+                    return {}
+                return {
+                    b'user_agent': b'VLC/3.0',
+                    b'worker_id': b'test-worker-1',
+                }
+            return _metadata_for_channel()
+
+        redis = self._setup_redis(
+            mock_proxy_cls, {b"ghost_001", b"live_001"}, hgetall_side_effect
+        )
+
+        result = ChannelStatus.get_detailed_channel_info(CHANNEL_ID)
+
+        self.assertEqual(result['client_count'], 1)
+        self.assertEqual(len(result['clients']), 1)
+        redis.srem.assert_called_once()
+
+
+# ---------------------------------------------------------------------------
+# Basic stats path: exercises get_basic_channel_info()
+# ---------------------------------------------------------------------------
+
+@patch("apps.proxy.ts_proxy.channel_status.ProxyServer")
+class BasicStatsGhostClientTests(TestCase):
+    """get_basic_channel_info() should call remove_ghost_clients(), skip
+    ghosts from display, and correct client_count."""
+
+    def _setup_redis(self, mock_proxy_cls, client_ids, ghost_ids):
+        """Wire up mock ProxyServer. ghost_ids controls which EXISTS return False."""
+        redis = MagicMock()
+        server = _make_proxy_server(redis)
+        mock_proxy_cls.get_instance.return_value = server
+
+        redis.hgetall.return_value = _metadata_for_channel()
+        redis.get.return_value = b"10"  # buffer_index
+        redis.scard.return_value = len(client_ids)
+        redis.smembers.return_value = client_ids
+        redis.hget.return_value = None  # individual field lookups
+
+        # Pipeline for remove_ghost_clients
+        pipe = MagicMock()
+        redis.pipeline.return_value = pipe
+        client_id_list = list(client_ids)
+        pipe.execute.return_value = [
+            cid not in ghost_ids for cid in client_id_list
+        ]
+
+        return redis
+
+    def test_ghost_removed_and_count_corrected(self, mock_proxy_cls):
+        """Ghost client should be cleaned and client_count decremented."""
+        from apps.proxy.ts_proxy.channel_status import ChannelStatus
+
+        redis = self._setup_redis(
+            mock_proxy_cls,
+            client_ids={b"ghost_001"},
+            ghost_ids={b"ghost_001"},
+        )
+
+        result = ChannelStatus.get_basic_channel_info(CHANNEL_ID)
+
+        self.assertIsNotNone(result)
+        self.assertEqual(result['client_count'], 0)
+        redis.srem.assert_called_once()
+
+    def test_live_client_count_preserved(self, mock_proxy_cls):
+        """Live clients should be counted correctly."""
+        from apps.proxy.ts_proxy.channel_status import ChannelStatus
+
+        redis = self._setup_redis(
+            mock_proxy_cls,
+            client_ids={b"live_001"},
+            ghost_ids=set(),
+        )
+
+        result = ChannelStatus.get_basic_channel_info(CHANNEL_ID)
+
+        self.assertIsNotNone(result)
+        self.assertEqual(result['client_count'], 1)
+        redis.srem.assert_not_called()
+
+
+# ---------------------------------------------------------------------------
+# Orphaned channel cleanup: exercises _check_orphaned_metadata()
+# ---------------------------------------------------------------------------
+
+@patch("apps.proxy.ts_proxy.channel_status.ProxyServer")
+class OrphanedChannelGhostValidationTests(TestCase):
+    """_check_orphaned_metadata() should validate client SET entries when
+    owner is dead and client_count > 0. If all clients are ghosts, it
+    should clean up the channel."""
+
+    def _make_server_for_orphan_check(self, mock_proxy_cls, channel_id,
+                                       client_ids, ghost_ids, owner="dead-worker"):
+        """Build a mock ProxyServer whose Redis state simulates an orphaned channel."""
+        redis = MagicMock()
+        server = _make_proxy_server(redis)
+        mock_proxy_cls.get_instance.return_value = server
+
+        metadata_key = RedisKeys.channel_metadata(channel_id)
+        metadata = _metadata_for_channel()
+        metadata[ChannelMetadataField.OWNER.encode()] = owner.encode()
+
+        # scan returns the one channel metadata key
+        redis.scan.return_value = (0, [metadata_key.encode()])
+        redis.hgetall.return_value = metadata
+        redis.scard.return_value = len(client_ids)
+        redis.smembers.return_value = client_ids
+        # Owner heartbeat is dead
+        redis.exists.side_effect = lambda key: (
+            False if "heartbeat" in key else True
+        )
+
+        # Pipeline for remove_ghost_clients
+        pipe = MagicMock()
+        redis.pipeline.return_value = pipe
+        client_id_list = list(client_ids)
+        pipe.execute.return_value = [
+            cid not in ghost_ids for cid in client_id_list
+        ]
+
+        return server, redis
+
+    def test_all_ghosts_triggers_cleanup(self, mock_proxy_cls):
+        """When all clients are ghosts, channel should be cleaned up."""
+        from apps.proxy.ts_proxy.server import ProxyServer
+
+        channel_id = "00000000-0000-0000-0000-000000000005"
+        server, redis = self._make_server_for_orphan_check(
+            mock_proxy_cls, channel_id,
+            client_ids={b"ghost_001", b"ghost_002"},
+            ghost_ids={b"ghost_001", b"ghost_002"},
+        )
+
+        # Call the real method on a real-ish ProxyServer
+        # The method lives on the server instance, so invoke it directly.
+        # We need to call _check_orphaned_metadata on the actual server mock,
+        # but it's a MagicMock. Instead, test via remove_ghost_clients directly
+        # and verify the cleanup decision logic.
+        stale_ids = ClientManager.remove_ghost_clients(redis, channel_id)
+        real_count = max(0, len({b"ghost_001", b"ghost_002"}) - len(stale_ids))
+
+        self.assertEqual(len(stale_ids), 2)
+        self.assertEqual(real_count, 0)
+        redis.srem.assert_called_once()
+
+    def test_mixed_preserves_live_clients(self, mock_proxy_cls):
+        """When some clients are live, real_count should be > 0."""
+        channel_id = "00000000-0000-0000-0000-000000000006"
+        server, redis = self._make_server_for_orphan_check(
+            mock_proxy_cls, channel_id,
+            client_ids={b"ghost_001", b"live_001"},
+            ghost_ids={b"ghost_001"},
+        )
+
+        stale_ids = ClientManager.remove_ghost_clients(redis, channel_id)
+        real_count = max(0, 2 - len(stale_ids))
+
+        self.assertEqual(len(stale_ids), 1)
+        self.assertEqual(real_count, 1)
+
+    def test_no_ghosts_no_cleanup(self, mock_proxy_cls):
+        """When all clients are live, no SREM should be called."""
+        channel_id = "00000000-0000-0000-0000-000000000007"
+        server, redis = self._make_server_for_orphan_check(
+            mock_proxy_cls, channel_id,
+            client_ids={b"live_001"},
+            ghost_ids=set(),
+        )
+
+        stale_ids = ClientManager.remove_ghost_clients(redis, channel_id)
+
+        self.assertEqual(len(stale_ids), 0)
+        redis.srem.assert_not_called()

apps/channels/tests/test_ts_proxy_initializing.py

@@ -0,0 +1,231 @@
+"""Tests for stuck INITIALIZING state fix.
+
+Covers:
+  - stream_manager.run() finally block: ownership check + state guard fallback
+  - ChannelState.PRE_ACTIVE contains the correct states
+  - INITIALIZING is included in the cleanup task grace period check
+"""
+import time
+import threading
+from unittest.mock import MagicMock, patch
+
+from django.test import TestCase
+
+from apps.proxy.ts_proxy.constants import ChannelMetadataField, ChannelState
+from apps.proxy.ts_proxy.redis_keys import RedisKeys
+from apps.proxy.ts_proxy.stream_manager import StreamManager
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+CHANNEL_ID = "00000000-0000-0000-0000-000000000001"
+
+
+def _make_stream_manager(tried_stream_ids=None, max_retries=3):
+    """Build a StreamManager via __new__ (bypasses __init__) with the
+    minimum attributes required by the run() finally block."""
+    sm = StreamManager.__new__(StreamManager)
+    sm.channel_id = CHANNEL_ID
+    sm.worker_id = "worker-1"
+    sm.max_retries = max_retries
+    sm.tried_stream_ids = tried_stream_ids if tried_stream_ids is not None else set()
+    sm.running = False  # while-loop exits immediately
+    sm.connected = False
+    sm.transcode_process_active = False
+    sm._buffer_check_timers = []
+    sm.url = "http://example.com/stream"
+    sm.url_switching = False
+    sm.url_switch_start_time = 0
+    sm.url_switch_timeout = 30
+    sm.stop_requested = False
+    sm.stopping = False
+    sm.socket = None
+    sm.transcode_process = None
+    sm.current_response = None
+    sm.current_session = None
+    sm.current_stream_id = None
+
+    buffer = MagicMock()
+    buffer.redis_client = MagicMock()
+    buffer.channel_id = CHANNEL_ID
+    sm.buffer = buffer
+
+    return sm
+
+
+def _run_finally_block(sm, owner_value, current_state):
+    """Invoke StreamManager.run() so its finally block executes against real code.
+
+    Patches threading.Thread and ConfigHelper so the try-block is inert
+    (self.running=False makes the while-loop exit immediately).
+
+    Returns True if the finally block wrote ERROR to Redis.
+    """
+    redis = sm.buffer.redis_client
+
+    # Mock the owner key GET — the finally block calls redis.get(owner_key)
+    def get_side_effect(key):
+        if "owner" in key:
+            return owner_value
+        return None
+
+    redis.get.side_effect = get_side_effect
+
+    # Mock hget for state field lookup in the PRE_ACTIVE guard
+    if current_state is not None:
+        redis.hget.return_value = current_state.encode('utf-8')
+    else:
+        redis.hget.return_value = None
+
+    # Reset hset so we can detect whether ERROR was written
+    redis.hset.reset_mock()
+    redis.setex.reset_mock()
+
+    with patch.object(threading, 'Thread', return_value=MagicMock()):
+        with patch('apps.proxy.ts_proxy.stream_manager.ConfigHelper') as mock_cfg:
+            mock_cfg.max_stream_switches.return_value = 0
+            mock_cfg.max_retries.return_value = sm.max_retries
+            sm.run()
+
+    # Check if hset was called with ERROR state
+    if redis.hset.called:
+        mapping = redis.hset.call_args[1].get('mapping', {})
+        return mapping.get(ChannelMetadataField.STATE) == ChannelState.ERROR
+    return False
+
+
+# ---------------------------------------------------------------------------
+# stream_manager.run() finally block: ownership + state guard behavior
+# ---------------------------------------------------------------------------
+
+class StreamManagerFinallyBlockTests(TestCase):
+    """The run() finally block writes ERROR if the worker is still the owner
+    (normal case) OR if ownership expired and the channel is still in a
+    pre-active state (no new owner has taken over)."""
+
+    # --- Owner still valid: always write ERROR ---
+
+    def test_owner_writes_error_regardless_of_state(self):
+        """When we're still the owner, always write ERROR."""
+        sm = _make_stream_manager()
+        owner = sm.worker_id.encode('utf-8')
+        self.assertTrue(_run_finally_block(sm, owner, ChannelState.ACTIVE))
+
+    def test_owner_writes_error_on_initializing(self):
+        """Owner + INITIALIZING = write ERROR."""
+        sm = _make_stream_manager()
+        owner = sm.worker_id.encode('utf-8')
+        self.assertTrue(_run_finally_block(sm, owner, ChannelState.INITIALIZING))
+
+        mapping = sm.buffer.redis_client.hset.call_args[1]['mapping']
+        self.assertEqual(mapping[ChannelMetadataField.STATE], ChannelState.ERROR)
+
+    # --- Ownership expired, no new owner: use state guard ---
+
+    def test_no_owner_initializing_writes_error(self):
+        """Ownership expired + INITIALIZING = write ERROR."""
+        sm = _make_stream_manager()
+        self.assertTrue(_run_finally_block(sm, None, ChannelState.INITIALIZING))
+
+    def test_no_owner_connecting_writes_error(self):
+        """Ownership expired + CONNECTING = write ERROR."""
+        sm = _make_stream_manager()
+        self.assertTrue(_run_finally_block(sm, None, ChannelState.CONNECTING))
+
+    def test_no_owner_buffering_writes_error(self):
+        """Ownership expired + BUFFERING = write ERROR."""
+        sm = _make_stream_manager()
+        self.assertTrue(_run_finally_block(sm, None, ChannelState.BUFFERING))
+
+    def test_no_owner_waiting_for_clients_writes_error(self):
+        """Ownership expired + WAITING_FOR_CLIENTS = write ERROR."""
+        sm = _make_stream_manager()
+        self.assertTrue(_run_finally_block(sm, None, ChannelState.WAITING_FOR_CLIENTS))
+
+    def test_no_owner_active_does_not_write(self):
+        """Ownership expired + ACTIVE = do NOT write ERROR."""
+        sm = _make_stream_manager()
+        self.assertFalse(_run_finally_block(sm, None, ChannelState.ACTIVE))
+
+    def test_no_owner_error_does_not_write(self):
+        """Ownership expired + already ERROR = do NOT write again."""
+        sm = _make_stream_manager()
+        self.assertFalse(_run_finally_block(sm, None, ChannelState.ERROR))
+
+    def test_no_owner_no_state_does_not_write(self):
+        """Ownership expired + no state metadata = do NOT write."""
+        sm = _make_stream_manager()
+        self.assertFalse(_run_finally_block(sm, None, None))
+
+    # --- New owner took over: never clobber ---
+
+    def test_new_owner_initializing_does_not_write(self):
+        """Another worker owns the channel — do NOT clobber."""
+        sm = _make_stream_manager()
+        self.assertFalse(_run_finally_block(sm, b"other-worker", ChannelState.INITIALIZING))
+
+    def test_new_owner_active_does_not_write(self):
+        """Another worker owns the channel and is ACTIVE — do NOT write."""
+        sm = _make_stream_manager()
+        self.assertFalse(_run_finally_block(sm, b"other-worker", ChannelState.ACTIVE))
+
+    # --- Stopping key and error messages ---
+
+    def test_stopping_key_set_on_error_update(self):
+        """When ERROR is written, stopping key must also be set."""
+        sm = _make_stream_manager()
+        _run_finally_block(sm, None, ChannelState.INITIALIZING)
+
+        sm.buffer.redis_client.setex.assert_called_once()
+        args = sm.buffer.redis_client.setex.call_args[0]
+        self.assertIn("stopping", args[0])
+        self.assertEqual(args[1], 60)
+
+    def test_error_message_includes_stream_count(self):
+        """When multiple streams were tried, error message reflects that."""
+        sm = _make_stream_manager(tried_stream_ids={1, 2, 3})
+        _run_finally_block(sm, None, ChannelState.INITIALIZING)
+
+        mapping = sm.buffer.redis_client.hset.call_args[1]['mapping']
+        error_msg = mapping[ChannelMetadataField.ERROR_MESSAGE]
+        self.assertIn("3 stream options failed", error_msg)
+
+    def test_error_message_with_no_streams_tried(self):
+        """When no alternate streams were tried, shows retry count."""
+        sm = _make_stream_manager(tried_stream_ids=set(), max_retries=5)
+        _run_finally_block(sm, None, ChannelState.INITIALIZING)
+
+        mapping = sm.buffer.redis_client.hset.call_args[1]['mapping']
+        error_msg = mapping[ChannelMetadataField.ERROR_MESSAGE]
+        self.assertIn("5", error_msg)
+
+
+# ---------------------------------------------------------------------------
+# ChannelState.PRE_ACTIVE: verify contents and immutability
+# ---------------------------------------------------------------------------
+
+class PreActiveStateTests(TestCase):
+    """Verify PRE_ACTIVE contains the correct states and is immutable."""
+
+    def test_initializing_in_pre_active(self):
+        self.assertIn(ChannelState.INITIALIZING, ChannelState.PRE_ACTIVE)
+
+    def test_connecting_in_pre_active(self):
+        self.assertIn(ChannelState.CONNECTING, ChannelState.PRE_ACTIVE)
+
+    def test_buffering_in_pre_active(self):
+        self.assertIn(ChannelState.BUFFERING, ChannelState.PRE_ACTIVE)
+
+    def test_waiting_for_clients_in_pre_active(self):
+        self.assertIn(ChannelState.WAITING_FOR_CLIENTS, ChannelState.PRE_ACTIVE)
+
+    def test_active_not_in_pre_active(self):
+        self.assertNotIn(ChannelState.ACTIVE, ChannelState.PRE_ACTIVE)
+
+    def test_error_not_in_pre_active(self):
+        self.assertNotIn(ChannelState.ERROR, ChannelState.PRE_ACTIVE)
+
+    def test_pre_active_is_frozenset(self):
+        self.assertIsInstance(ChannelState.PRE_ACTIVE, frozenset)

apps/channels/tests/test_ts_proxy_keepalive.py

@@ -86,11 +86,12 @@ class NonOwnerWorkerKeepaliveTests(TestCase):
         gen.stream_manager = None  # non-owner worker
         gen.consecutive_empty = consecutive_empty
 
-        # Throttle attributes added by a later PR; required by _should_send_keepalive.
+        # Attributes added by health-check throttling (set in __init__)
         gen._last_health_check_time = 0.0
         gen._last_health_check_result = False
         gen._health_check_interval = 2.0
         gen.proxy_server = None
+
         return gen
 
     def _mock_proxy_server(self, last_data_value):

apps/m3u/api_views.py

@@ -40,7 +40,7 @@ class M3UAccountViewSet(viewsets.ModelViewSet):
 
     queryset = M3UAccount.objects.select_related(
         "refresh_task__crontab", "refresh_task__interval"
-    ).prefetch_related("channel_group")
+    ).prefetch_related("channel_group", "profiles")
     serializer_class = M3UAccountSerializer
 
     def get_permissions(self):

apps/m3u/migrations/0019_m3uaccountprofile_exp_date.py

@@ -0,0 +1,57 @@
+# Generated by Django 6.0.3 on 2026-03-14 19:41
+
+from datetime import datetime, timezone
+
+from django.db import migrations, models
+
+
+def populate_exp_date_from_custom_properties(apps, schema_editor):
+    """Backfill exp_date from custom_properties['user_info']['exp_date']."""
+    M3UAccountProfile = apps.get_model('m3u', 'M3UAccountProfile')
+    profiles_to_update = []
+
+    for profile in M3UAccountProfile.objects.filter(
+        custom_properties__isnull=False,
+    ).exclude(custom_properties={}):
+        user_info = profile.custom_properties.get('user_info', {})
+        raw_exp = user_info.get('exp_date')
+        if raw_exp is None:
+            continue
+
+        parsed = None
+        try:
+            if isinstance(raw_exp, (int, float)):
+                parsed = datetime.fromtimestamp(float(raw_exp), tz=timezone.utc)
+            elif isinstance(raw_exp, str):
+                try:
+                    parsed = datetime.fromtimestamp(float(raw_exp), tz=timezone.utc)
+                except ValueError:
+                    parsed = datetime.fromisoformat(raw_exp)
+        except (ValueError, TypeError, OSError):
+            pass
+
+        if parsed is not None:
+            profile.exp_date = parsed
+            profiles_to_update.append(profile)
+
+    if profiles_to_update:
+        M3UAccountProfile.objects.bulk_update(profiles_to_update, ['exp_date'], batch_size=500)
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('m3u', '0018_add_profile_custom_properties'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='m3uaccountprofile',
+            name='exp_date',
+            field=models.DateTimeField(blank=True, help_text='Account expiration date, auto-synced from custom_properties on save', null=True),
+        ),
+        migrations.RunPython(
+            populate_exp_date_from_custom_properties,
+            reverse_code=migrations.RunPython.noop,
+        ),
+    ]

apps/m3u/models.py

@@ -1,3 +1,4 @@
+from datetime import datetime, timezone
 from django.db import models
 from django.core.exceptions import ValidationError
 from core.models import UserAgent
@@ -264,11 +265,16 @@ class M3UAccountProfile(models.Model):
     )
     current_viewers = models.PositiveIntegerField(default=0)
     custom_properties = models.JSONField(
-        default=dict, 
-        blank=True, 
-        null=True, 
+        default=dict,
+        blank=True,
+        null=True,
         help_text="Custom properties for storing account information from provider (e.g., XC account details, expiration dates)"
     )
+    exp_date = models.DateTimeField(
+        null=True,
+        blank=True,
+        help_text="Account expiration date, auto-synced from custom_properties on save",
+    )
 
     class Meta:
         constraints = [
@@ -280,36 +286,51 @@ class M3UAccountProfile(models.Model):
     def __str__(self):
         return f"{self.name} ({self.m3u_account.name})"
 
-    def get_account_expiration(self):
-        """Get account expiration date from custom properties if available"""
+    def save(self, *args, **kwargs):
+        """Auto-sync exp_date from custom_properties for XC accounts on every save.
+        For non-XC accounts, exp_date is set directly and left untouched here."""
+        parsed = self._parse_exp_date_from_custom_properties()
+        if parsed is not None:
+            # XC account with exp_date in custom_properties — always sync
+            self.exp_date = parsed
+        # else: keep whatever exp_date is already set (manual entry for non-XC)
+        super().save(*args, **kwargs)
+
+    @staticmethod
+    def _parse_exp_date(raw_value):
+        """Parse a raw exp_date value (unix timestamp or ISO string) into a datetime."""
+        if raw_value is None:
+            return None
+        try:
+            if isinstance(raw_value, (int, float)):
+                return datetime.fromtimestamp(float(raw_value), tz=timezone.utc)
+            elif isinstance(raw_value, str):
+                try:
+                    return datetime.fromtimestamp(float(raw_value), tz=timezone.utc)
+                except ValueError:
+                    return datetime.fromisoformat(raw_value)
+        except (ValueError, TypeError, OSError):
+            pass
+        return None
+
+    def _parse_exp_date_from_custom_properties(self):
+        """Extract exp_date from custom_properties JSON."""
         if not self.custom_properties:
             return None
-        
         user_info = self.custom_properties.get('user_info', {})
-        exp_date = user_info.get('exp_date')
-        
-        if exp_date:
-            try:
-                from datetime import datetime
-                # XC exp_date is typically a Unix timestamp
-                if isinstance(exp_date, (int, float)):
-                    return datetime.fromtimestamp(exp_date)
-                elif isinstance(exp_date, str):
-                    # Try to parse as timestamp first, then as ISO date
-                    try:
-                        return datetime.fromtimestamp(float(exp_date))
-                    except ValueError:
-                        return datetime.fromisoformat(exp_date)
-            except (ValueError, TypeError):
-                pass
-        
-        return None
+        return self._parse_exp_date(user_info.get('exp_date'))
+
+    def get_account_expiration(self):
+        """Get account expiration date — uses the dedicated field if set, otherwise parses JSON."""
+        if self.exp_date:
+            return self.exp_date
+        return self._parse_exp_date_from_custom_properties()
 
     def get_account_status(self):
         """Get account status from custom properties if available"""
         if not self.custom_properties:
             return None
-        
+
         user_info = self.custom_properties.get('user_info', {})
         return user_info.get('status')
 
@@ -317,7 +338,7 @@ class M3UAccountProfile(models.Model):
         """Get maximum connections from custom properties if available"""
         if not self.custom_properties:
             return None
-        
+
         user_info = self.custom_properties.get('user_info', {})
         return user_info.get('max_connections')
 
@@ -325,7 +346,7 @@ class M3UAccountProfile(models.Model):
         """Get active connections from custom properties if available"""
         if not self.custom_properties:
             return None
-        
+
         user_info = self.custom_properties.get('user_info', {})
         return user_info.get('active_cons')
 
@@ -333,7 +354,7 @@ class M3UAccountProfile(models.Model):
         """Get last refresh timestamp from custom properties if available"""
         if not self.custom_properties:
             return None
-        
+
         last_refresh = self.custom_properties.get('last_refresh')
         if last_refresh:
             try:
@@ -341,7 +362,7 @@ class M3UAccountProfile(models.Model):
                 return datetime.fromisoformat(last_refresh)
             except (ValueError, TypeError):
                 pass
-        
+
         return None
 
 

apps/m3u/serializers.py

@@ -7,6 +7,7 @@ from apps.channels.models import ChannelGroup, ChannelGroupM3UAccount
 from apps.channels.serializers import (
     ChannelGroupM3UAccountSerializer,
 )
+from datetime import timezone as dt_tz
 import logging
 import json
 
@@ -52,12 +53,14 @@ class M3UAccountProfileSerializer(serializers.ModelSerializer):
             "search_pattern",
             "replace_pattern",
             "custom_properties",
+            "exp_date",
             "account",
         ]
         read_only_fields = ["id", "account"]
         extra_kwargs = {
             'search_pattern': {'required': False, 'allow_blank': True},
             'replace_pattern': {'required': False, 'allow_blank': True},
+            'exp_date': {'required': False, 'allow_null': True},
         }
 
     def create(self, validated_data):
@@ -90,14 +93,14 @@ class M3UAccountProfileSerializer(serializers.ModelSerializer):
 
     def update(self, instance, validated_data):
         if instance.is_default:
-            # For default profiles, only allow updating name and custom_properties (for notes)
-            allowed_fields = {'name', 'custom_properties'}
+            # For default profiles, only allow updating name, custom_properties, and exp_date
+            allowed_fields = {'name', 'custom_properties', 'exp_date'}
 
             # Remove any fields that aren't allowed for default profiles
             disallowed_fields = set(validated_data.keys()) - allowed_fields
             if disallowed_fields:
                 raise serializers.ValidationError(
-                    f"Default profiles can only modify name and notes. "
+                    f"Default profiles can only modify name, notes, and expiration. "
                     f"Cannot modify: {', '.join(disallowed_fields)}"
                 )
 
@@ -117,6 +120,12 @@ class M3UAccountSerializer(serializers.ModelSerializer):
     """Serializer for M3U Account"""
 
     filters = serializers.SerializerMethodField()
+    earliest_expiration = serializers.SerializerMethodField()
+    all_expirations = serializers.SerializerMethodField()
+    exp_date = serializers.DateTimeField(
+        required=False, allow_null=True, write_only=True,
+        help_text="Expiration date for the default profile (write-through)",
+    )
     # Include user_agent as a mandatory field using its primary key.
     user_agent = serializers.PrimaryKeyRelatedField(
         queryset=UserAgent.objects.all(),
@@ -172,6 +181,9 @@ class M3UAccountSerializer(serializers.ModelSerializer):
             "auto_enable_new_groups_live",
             "auto_enable_new_groups_vod",
             "auto_enable_new_groups_series",
+            "earliest_expiration",
+            "all_expirations",
+            "exp_date",
         ]
         extra_kwargs = {
             "password": {
@@ -200,9 +212,24 @@ class M3UAccountSerializer(serializers.ModelSerializer):
             ct = instance.refresh_task.crontab
             cron_expr = f"{ct.minute} {ct.hour} {ct.day_of_month} {ct.month_of_year} {ct.day_of_week}"
         data["cron_expression"] = cron_expr
+
+        # Surface default profile's exp_date for the form.
+        # Use prefetch cache (obj.profiles.all()) to avoid an extra query per account.
+        # Always emit a Z-suffix UTC string so JS new Date() never misinterprets it as local.
+        default_profile = next((p for p in instance.profiles.all() if p.is_default), None)
+        exp = default_profile.exp_date if default_profile else None
+        if exp:
+            exp_utc = exp.astimezone(dt_tz.utc) if exp.tzinfo else exp.replace(tzinfo=dt_tz.utc)
+            data["exp_date"] = exp_utc.strftime('%Y-%m-%dT%H:%M:%SZ')
+        else:
+            data["exp_date"] = None
+
         return data
 
     def update(self, instance, validated_data):
+        # Pop exp_date — it's written to the default profile, not the account
+        exp_date = validated_data.pop("exp_date", "__NOT_SET__")
+
         # Pop cron_expression before it reaches model fields
         # If not present (partial update), preserve the existing cron from the PeriodicTask
         if "cron_expression" in validated_data:
@@ -264,9 +291,26 @@ class M3UAccountSerializer(serializers.ModelSerializer):
                 memberships_to_update, ["enabled"]
             )
 
+        # Write exp_date through to the default profile.
+        # Use a fresh DB query (not the prefetch cache) so we get the profile
+        # object AFTER the post_save signal (create_profile_for_m3u_account)
+        # has already updated max_streams, avoiding a stale-value overwrite.
+        if exp_date != "__NOT_SET__":
+            default_profile = instance.profiles.filter(is_default=True).first()
+            if default_profile:
+                default_profile.exp_date = exp_date
+                default_profile.save(update_fields=['exp_date'])
+            # Invalidate the profiles prefetch cache so to_representation
+            # sees the updated exp_date rather than the pre-request snapshot.
+            if '_prefetched_objects_cache' in instance.__dict__:
+                instance._prefetched_objects_cache.pop('profiles', None)
+
         return instance
 
     def create(self, validated_data):
+        # Pop exp_date — it's written to the default profile after creation
+        exp_date = validated_data.pop("exp_date", None)
+
         # Pop cron_expression — it's not a model field
         cron_expr = validated_data.pop("cron_expression", "")
 
@@ -290,12 +334,47 @@ class M3UAccountSerializer(serializers.ModelSerializer):
         instance = M3UAccount(**validated_data)
         instance._cron_expression = cron_expr
         instance.save()
+
+        # Write exp_date through to the default profile created by post_save signal
+        if exp_date is not None:
+            default_profile = instance.profiles.filter(is_default=True).first()
+            if default_profile:
+                default_profile.exp_date = exp_date
+                default_profile.save()
+
         return instance
 
     def get_filters(self, obj):
         filters = obj.filters.order_by("order")
         return M3UFilterSerializer(filters, many=True).data
 
+    def get_earliest_expiration(self, obj):
+        """Return the soonest exp_date across all active profiles for this account."""
+        # Filter in Python over the prefetch cache to avoid an extra query per account.
+        expiring = [p.exp_date for p in obj.profiles.all() if p.is_active and p.exp_date]
+        if not expiring:
+            return None
+        exp = min(expiring)
+        exp_utc = exp.astimezone(dt_tz.utc) if exp.tzinfo else exp.replace(tzinfo=dt_tz.utc)
+        return exp_utc.strftime('%Y-%m-%dT%H:%M:%SZ')
+
+    def get_all_expirations(self, obj):
+        """Return exp_date info for every profile that has one (for tooltip)."""
+        # Filter in Python over the prefetch cache to avoid an extra query per account.
+        profiles = sorted(
+            (p for p in obj.profiles.all() if p.exp_date),
+            key=lambda p: p.exp_date,
+        )
+        return [
+            {
+                "profile_id": p.id,
+                "profile_name": p.name,
+                "exp_date": (p.exp_date.astimezone(dt_tz.utc) if p.exp_date.tzinfo else p.exp_date.replace(tzinfo=dt_tz.utc)).strftime('%Y-%m-%dT%H:%M:%SZ'),
+                "is_active": p.is_active,
+            }
+            for p in profiles
+        ]
+
 
 class ServerGroupSerializer(serializers.ModelSerializer):
     """Serializer for Server Group"""

apps/m3u/signals.py

@@ -1,7 +1,7 @@
 # apps/m3u/signals.py
 from django.db.models.signals import post_save, post_delete, pre_save
 from django.dispatch import receiver
-from .models import M3UAccount
+from .models import M3UAccount, M3UAccountProfile
 from .tasks import refresh_single_m3u_account, refresh_m3u_groups, delete_m3u_refresh_task_by_id
 from core.scheduling import create_or_update_periodic_task, delete_periodic_task
 import json
@@ -68,6 +68,62 @@ def create_or_update_refresh_task(sender, instance, created, update_fields=None,
     if instance.refresh_task_id != task.id:
         M3UAccount.objects.filter(id=instance.id).update(refresh_task=task)
 
+@receiver(post_save, sender=M3UAccountProfile)
+def update_profile_expiration_notification(sender, instance, created, update_fields=None, **kwargs):
+    """
+    When a profile's exp_date is set or changed, immediately update its expiration notification
+    so the frontend reflects the new state without waiting for the daily celery task.
+    """
+    # Only act when exp_date was involved in the save
+    if not created and update_fields is not None and "exp_date" not in update_fields:
+        return
+
+    try:
+        if not instance.exp_date:
+            # exp_date was cleared — remove any existing notifications immediately
+            from core.models import SystemNotification
+            from core.utils import send_notification_dismissed
+
+            keys = [f"xc-exp-warning-{instance.id}", f"xc-exp-expired-{instance.id}"]
+            deleted_keys = list(
+                SystemNotification.objects.filter(notification_key__in=keys)
+                .values_list("notification_key", flat=True)
+            )
+            SystemNotification.objects.filter(notification_key__in=deleted_keys).delete()
+            for key in deleted_keys:
+                send_notification_dismissed(key)
+            return
+
+        from apps.m3u.tasks import evaluate_profile_expiration_notification
+        evaluate_profile_expiration_notification(instance)
+    except Exception as e:
+        logger.error(f"Error updating expiration notification for profile {instance.id}: {str(e)}")
+
+
+@receiver(post_delete, sender=M3UAccountProfile)
+def cleanup_profile_notifications(sender, instance, **kwargs):
+    """
+    Delete expiration notifications for a profile when it is deleted.
+    Handles both direct deletion and cascade deletion from M3UAccount.
+    """
+    try:
+        from core.models import SystemNotification
+        from core.utils import send_notification_dismissed
+
+        keys = [f"xc-exp-warning-{instance.id}", f"xc-exp-expired-{instance.id}"]
+        deleted_keys = list(
+            SystemNotification.objects.filter(notification_key__in=keys)
+            .values_list("notification_key", flat=True)
+        )
+        if deleted_keys:
+            SystemNotification.objects.filter(notification_key__in=deleted_keys).delete()
+            for key in deleted_keys:
+                send_notification_dismissed(key)
+            logger.debug(f"Cleaned up {len(deleted_keys)} notifications for deleted profile {instance.id}")
+    except Exception as e:
+        logger.error(f"Error cleaning up notifications for profile {instance.id}: {str(e)}")
+
+
 @receiver(post_delete, sender=M3UAccount)
 def delete_refresh_task(sender, instance, **kwargs):
     """
@@ -107,6 +163,34 @@ def update_status_on_active_change(sender, instance, **kwargs):
                 else:
                     # When deactivating, set status to disabled
                     instance.status = M3UAccount.Status.DISABLED
+                    # Clean up any expiration notifications for all profiles of this account
+                    try:
+                        from core.models import SystemNotification
+                        from core.utils import send_notification_dismissed
+
+                        profile_ids = list(
+                            M3UAccountProfile.objects.filter(m3u_account=instance)
+                            .values_list("id", flat=True)
+                        )
+                        keys = [
+                            key
+                            for pid in profile_ids
+                            for key in [f"xc-exp-warning-{pid}", f"xc-exp-expired-{pid}"]
+                        ]
+                        if keys:
+                            deleted_keys = list(
+                                SystemNotification.objects.filter(notification_key__in=keys)
+                                .values_list("notification_key", flat=True)
+                            )
+                            if deleted_keys:
+                                SystemNotification.objects.filter(notification_key__in=deleted_keys).delete()
+                                for key in deleted_keys:
+                                    send_notification_dismissed(key)
+                                logger.debug(
+                                    f"Cleaned up {len(deleted_keys)} notifications for deactivated M3U account {instance.id}"
+                                )
+                    except Exception as notify_err:
+                        logger.error(f"Error cleaning up notifications on account deactivation: {notify_err}")
         except M3UAccount.DoesNotExist:
             # New record, will use default status
             pass

apps/m3u/tasks.py

@@ -11,7 +11,7 @@ from celery.result import AsyncResult
 from celery import shared_task, current_app, group
 from django.conf import settings
 from django.core.cache import cache
-from django.db import transaction
+from django.db import models, transaction
 from .models import M3UAccount
 from apps.channels.models import Stream, ChannelGroup, ChannelGroupM3UAccount
 from asgiref.sync import async_to_sync
@@ -3185,3 +3185,163 @@ def send_m3u_update(account_id, action, progress, **kwargs):
 
     # Explicitly clear data reference to help garbage collection
     data = None
+
+
+def evaluate_profile_expiration_notification(profile):
+    """
+    Evaluate a single M3UAccountProfile's expiration date and create, update,
+    or delete the corresponding SystemNotification accordingly.
+
+    Returns the notification key that should remain active (warning or expired),
+    or None if the profile is not expiring soon and any stale notifications were removed.
+    This return value is used by the bulk task to track active keys for stale cleanup.
+    """
+    from core.models import SystemNotification
+    from core.utils import send_websocket_notification, send_notification_dismissed
+
+    exp = profile.exp_date
+    if not exp:
+        return None
+
+    now = timezone.now()
+    warning_threshold = now + timezone.timedelta(days=7)
+    warning_key = f"xc-exp-warning-{profile.id}"
+    expired_key = f"xc-exp-expired-{profile.id}"
+
+    if exp <= now:
+        # Already expired — delete warning, create/update expired notification
+        deleted_warning = list(
+            SystemNotification.objects.filter(notification_key=warning_key)
+            .values_list("notification_key", flat=True)
+        )
+        SystemNotification.objects.filter(notification_key=warning_key).delete()
+        for key in deleted_warning:
+            send_notification_dismissed(key)
+
+        notification, created = SystemNotification.objects.update_or_create(
+            notification_key=expired_key,
+            defaults={
+                "notification_type": SystemNotification.NotificationType.WARNING,
+                "priority": SystemNotification.Priority.HIGH,
+                "title": f"Account Expired: {profile.name}",
+                "message": (
+                    f'Profile "{profile.name}" on M3U account '
+                    f'"{profile.m3u_account.name}" has expired '
+                    f"(expired {exp.strftime('%Y-%m-%d %H:%M UTC')})."
+                ),
+                "action_data": {
+                    "profile_id": profile.id,
+                    "account_id": profile.m3u_account.id,
+                    "account_name": profile.m3u_account.name,
+                    "profile_name": profile.name,
+                    "exp_date": exp.isoformat(),
+                },
+                "is_active": True,
+                "admin_only": True,
+            },
+        )
+        send_websocket_notification(notification)
+        return expired_key
+
+    elif exp <= warning_threshold:
+        # Expiring within 7 days — delete expired notification, create/update warning
+        deleted_expired = list(
+            SystemNotification.objects.filter(notification_key=expired_key)
+            .values_list("notification_key", flat=True)
+        )
+        SystemNotification.objects.filter(notification_key=expired_key).delete()
+        for key in deleted_expired:
+            send_notification_dismissed(key)
+
+        days_left = (exp - now).days
+        if days_left == 0:
+            expires_in_str = "today"
+        elif days_left == 1:
+            expires_in_str = "in 1 day"
+        else:
+            expires_in_str = f"in {days_left} days"
+
+        notification, created = SystemNotification.objects.update_or_create(
+            notification_key=warning_key,
+            defaults={
+                "notification_type": SystemNotification.NotificationType.WARNING,
+                "priority": SystemNotification.Priority.NORMAL,
+                "title": f"Account Expiring: {profile.name}",
+                "message": (
+                    f'Profile "{profile.name}" on M3U account '
+                    f'"{profile.m3u_account.name}" expires {expires_in_str} '
+                    f"(expires {exp.strftime('%Y-%m-%d %H:%M UTC')})."
+                ),
+                "action_data": {
+                    "profile_id": profile.id,
+                    "account_id": profile.m3u_account.id,
+                    "account_name": profile.m3u_account.name,
+                    "profile_name": profile.name,
+                    "exp_date": exp.isoformat(),
+                },
+                "is_active": True,
+                "admin_only": True,
+            },
+        )
+        send_websocket_notification(notification)
+        return warning_key
+
+    else:
+        # Not expiring soon — delete any stale notifications
+        deleted_keys = list(
+            SystemNotification.objects.filter(
+                notification_key__in=[warning_key, expired_key]
+            ).values_list("notification_key", flat=True)
+        )
+        SystemNotification.objects.filter(
+            notification_key__in=[warning_key, expired_key]
+        ).delete()
+        for key in deleted_keys:
+            send_notification_dismissed(key)
+        return None
+
+
+@shared_task
+def check_account_expirations():
+    """
+    Daily task: check all account profiles for upcoming expirations.
+    Creates/updates SystemNotifications for profiles expiring within 7 days.
+    Uses separate notification keys for warning vs expired so users can
+    dismiss the 7-day warning and still receive the expired notification.
+    """
+    from apps.m3u.models import M3UAccountProfile
+    from core.models import SystemNotification
+    from core.utils import send_notification_dismissed
+
+    # Find all active profiles with an exp_date that is set
+    expiring_profiles = (
+        M3UAccountProfile.objects.filter(
+            m3u_account__is_active=True,
+            is_active=True,
+            exp_date__isnull=False,
+        )
+        .select_related("m3u_account")
+    )
+
+    active_notification_keys = set()
+
+    for profile in expiring_profiles:
+        active_key = evaluate_profile_expiration_notification(profile)
+        if active_key:
+            active_notification_keys.add(active_key)
+
+    # Delete stale notifications for profiles whose expiration was extended
+    stale = SystemNotification.objects.filter(
+        is_active=True,
+    ).filter(
+        models.Q(notification_key__startswith="xc-exp-warning-") |
+        models.Q(notification_key__startswith="xc-exp-expired-")
+    ).exclude(notification_key__in=active_notification_keys)
+    stale_keys = list(stale.values_list("notification_key", flat=True))
+    stale.delete()
+    for key in stale_keys:
+        send_notification_dismissed(key)
+
+    logger.info(
+        f"Account expiration check complete: {len(active_notification_keys)} active notifications"
+    )

apps/m3u/tests/test_expiration_notifications.py

@@ -0,0 +1,216 @@
+"""
+Tests for evaluate_profile_expiration_notification.
+
+Covers all four branches:
+  - no exp_date         → returns None, touches nothing
+  - already expired     → creates/updates expired notification, removes warning
+  - expiring within 7d  → creates/updates warning notification, removes expired
+  - not expiring soon   → removes any stale notifications, returns None
+"""
+from datetime import timedelta
+from unittest.mock import patch, MagicMock
+
+from django.test import SimpleTestCase
+from django.utils import timezone
+
+
+def _make_profile(exp_date, profile_id=1, profile_name="Test Profile",
+                  account_id=10, account_name="Test Account"):
+    """Return a minimal mock M3UAccountProfile."""
+    profile = MagicMock()
+    profile.id = profile_id
+    profile.name = profile_name
+    profile.exp_date = exp_date
+    profile.m3u_account.id = account_id
+    profile.m3u_account.name = account_name
+    return profile
+
+
+class EvaluateProfileExpirationNotificationTests(SimpleTestCase):
+
+    def setUp(self):
+        # These three names are local imports inside evaluate_profile_expiration_notification,
+        # so we must patch them at their source modules rather than on apps.m3u.tasks.
+        self.mock_sn = MagicMock()
+        self.mock_send_ws = patch("core.utils.send_websocket_notification").start()
+        self.mock_dismissed = patch("core.utils.send_notification_dismissed").start()
+        patch("core.models.SystemNotification", self.mock_sn).start()
+
+    def tearDown(self):
+        patch.stopall()
+
+    def _run(self, profile):
+        from apps.m3u.tasks import evaluate_profile_expiration_notification
+        return evaluate_profile_expiration_notification(profile)
+
+    # ------------------------------------------------------------------ #
+    # No expiration date
+    # ------------------------------------------------------------------ #
+
+    def test_no_exp_date_returns_none(self):
+        profile = _make_profile(exp_date=None)
+        result = self._run(profile)
+        self.assertIsNone(result)
+        self.mock_sn.objects.update_or_create.assert_not_called()
+        self.mock_send_ws.assert_not_called()
+
+    # ------------------------------------------------------------------ #
+    # Already expired
+    # ------------------------------------------------------------------ #
+
+    @patch("apps.m3u.tasks.timezone")
+    def test_expired_creates_expired_notification(self, mock_tz):
+        now = timezone.now()
+        mock_tz.now.return_value = now
+        mock_tz.timedelta = timedelta
+
+        profile = _make_profile(exp_date=now - timedelta(days=1))
+        # No existing warning notification to delete
+        self.mock_sn.objects.filter.return_value.values_list.return_value = []
+        notification = MagicMock()
+        self.mock_sn.objects.update_or_create.return_value = (notification, True)
+
+        result = self._run(profile)
+
+        self.assertEqual(result, f"xc-exp-expired-{profile.id}")
+        self.mock_sn.objects.update_or_create.assert_called_once()
+        call_kwargs = self.mock_sn.objects.update_or_create.call_args
+        self.assertEqual(call_kwargs.kwargs["notification_key"], f"xc-exp-expired-{profile.id}")
+        self.assertTrue(call_kwargs.kwargs["defaults"]["admin_only"])
+        self.mock_send_ws.assert_called_once_with(notification)
+
+    @patch("apps.m3u.tasks.timezone")
+    def test_expired_removes_stale_warning_notification(self, mock_tz):
+        now = timezone.now()
+        mock_tz.now.return_value = now
+        mock_tz.timedelta = timedelta
+
+        profile = _make_profile(exp_date=now - timedelta(hours=1))
+        warning_key = f"xc-exp-warning-{profile.id}"
+        # Simulate an existing warning notification
+        self.mock_sn.objects.filter.return_value.values_list.return_value = [warning_key]
+        self.mock_sn.objects.update_or_create.return_value = (MagicMock(), False)
+
+        self._run(profile)
+
+        self.mock_dismissed.assert_any_call(warning_key)
+
+    # ------------------------------------------------------------------ #
+    # Expiring within 7 days
+    # ------------------------------------------------------------------ #
+
+    @patch("apps.m3u.tasks.timezone")
+    def test_warning_window_creates_warning_notification(self, mock_tz):
+        now = timezone.now()
+        mock_tz.now.return_value = now
+        mock_tz.timedelta = timedelta
+
+        profile = _make_profile(exp_date=now + timedelta(days=3))
+        self.mock_sn.objects.filter.return_value.values_list.return_value = []
+        notification = MagicMock()
+        self.mock_sn.objects.update_or_create.return_value = (notification, True)
+
+        result = self._run(profile)
+
+        self.assertEqual(result, f"xc-exp-warning-{profile.id}")
+        call_kwargs = self.mock_sn.objects.update_or_create.call_args
+        self.assertEqual(call_kwargs.kwargs["notification_key"], f"xc-exp-warning-{profile.id}")
+        self.assertTrue(call_kwargs.kwargs["defaults"]["admin_only"])
+        self.mock_send_ws.assert_called_once_with(notification)
+
+    @patch("apps.m3u.tasks.timezone")
+    def test_warning_message_says_today_when_same_day(self, mock_tz):
+        now = timezone.now()
+        mock_tz.now.return_value = now
+        mock_tz.timedelta = timedelta
+
+        profile = _make_profile(exp_date=now + timedelta(hours=2))
+        self.mock_sn.objects.filter.return_value.values_list.return_value = []
+        self.mock_sn.objects.update_or_create.return_value = (MagicMock(), True)
+
+        self._run(profile)
+
+        defaults = self.mock_sn.objects.update_or_create.call_args.kwargs["defaults"]
+        self.assertIn("today", defaults["message"])
+
+    @patch("apps.m3u.tasks.timezone")
+    def test_warning_message_says_1_day(self, mock_tz):
+        now = timezone.now()
+        mock_tz.now.return_value = now
+        mock_tz.timedelta = timedelta
+
+        profile = _make_profile(exp_date=now + timedelta(hours=30))
+        self.mock_sn.objects.filter.return_value.values_list.return_value = []
+        self.mock_sn.objects.update_or_create.return_value = (MagicMock(), True)
+
+        self._run(profile)
+
+        defaults = self.mock_sn.objects.update_or_create.call_args.kwargs["defaults"]
+        self.assertIn("in 1 day", defaults["message"])
+
+    @patch("apps.m3u.tasks.timezone")
+    def test_warning_removes_stale_expired_notification(self, mock_tz):
+        now = timezone.now()
+        mock_tz.now.return_value = now
+        mock_tz.timedelta = timedelta
+
+        profile = _make_profile(exp_date=now + timedelta(days=5))
+        expired_key = f"xc-exp-expired-{profile.id}"
+        self.mock_sn.objects.filter.return_value.values_list.return_value = [expired_key]
+        self.mock_sn.objects.update_or_create.return_value = (MagicMock(), False)
+
+        self._run(profile)
+
+        self.mock_dismissed.assert_any_call(expired_key)
+
+    # ------------------------------------------------------------------ #
+    # Not expiring soon (> 7 days away)
+    # ------------------------------------------------------------------ #
+
+    @patch("apps.m3u.tasks.timezone")
+    def test_not_expiring_soon_returns_none(self, mock_tz):
+        now = timezone.now()
+        mock_tz.now.return_value = now
+        mock_tz.timedelta = timedelta
+
+        profile = _make_profile(exp_date=now + timedelta(days=30))
+        self.mock_sn.objects.filter.return_value.values_list.return_value = []
+
+        result = self._run(profile)
+
+        self.assertIsNone(result)
+        self.mock_sn.objects.update_or_create.assert_not_called()
+        self.mock_send_ws.assert_not_called()
+
+    @patch("apps.m3u.tasks.timezone")
+    def test_not_expiring_soon_removes_stale_notifications(self, mock_tz):
+        now = timezone.now()
+        mock_tz.now.return_value = now
+        mock_tz.timedelta = timedelta
+
+        profile = _make_profile(exp_date=now + timedelta(days=30))
+        warning_key = f"xc-exp-warning-{profile.id}"
+        self.mock_sn.objects.filter.return_value.values_list.return_value = [warning_key]
+
+        self._run(profile)
+
+        self.mock_dismissed.assert_called_once_with(warning_key)
+
+    # ------------------------------------------------------------------ #
+    # Boundary: exactly at the 7-day warning threshold
+    # ------------------------------------------------------------------ #
+
+    @patch("apps.m3u.tasks.timezone")
+    def test_exactly_7_days_away_triggers_warning(self, mock_tz):
+        now = timezone.now()
+        mock_tz.now.return_value = now
+        mock_tz.timedelta = timedelta
+
+        # exp_date == now + 7 days  →  exp <= warning_threshold  →  warning
+        profile = _make_profile(exp_date=now + timedelta(days=7))
+        self.mock_sn.objects.filter.return_value.values_list.return_value = []
+        self.mock_sn.objects.update_or_create.return_value = (MagicMock(), True)
+
+        result = self._run(profile)
+
+        self.assertEqual(result, f"xc-exp-warning-{profile.id}")

apps/proxy/ts_proxy/channel_status.py

@@ -6,6 +6,7 @@ from .redis_keys import RedisKeys
 from .constants import TS_PACKET_SIZE, ChannelMetadataField
 from redis.exceptions import ConnectionError, TimeoutError
 from .utils import get_logger
+from .client_manager import ClientManager
 from django.db import DatabaseError  # Add import for error handling
 
 logger = get_logger()
@@ -127,43 +128,56 @@ class ChannelStatus:
         client_ids = proxy_server.redis_client.smembers(client_set_key)
         clients = []
 
+        stale_client_ids = []
         for client_id in client_ids:
             client_id_str = client_id.decode('utf-8')
             client_key = RedisKeys.client_metadata(channel_id, client_id_str)
             client_data = proxy_server.redis_client.hgetall(client_key)
 
-            if client_data:
-                client_info = {
-                    'client_id': client_id_str,
-                    'user_agent': client_data.get(b'user_agent', b'unknown').decode('utf-8'),
-                    'worker_id': client_data.get(b'worker_id', b'unknown').decode('utf-8'),
-                }
+            if not client_data:
+                # Metadata hash expired but SET entry persists (ghost client).
+                stale_client_ids.append(client_id)
+                continue
 
-                if b'connected_at' in client_data:
-                    connected_at = float(client_data[b'connected_at'].decode('utf-8'))
-                    client_info['connected_at'] = connected_at
-                    client_info['connection_duration'] = time.time() - connected_at
+            client_info = {
+                'client_id': client_id_str,
+                'user_agent': client_data.get(b'user_agent', b'unknown').decode('utf-8'),
+                'worker_id': client_data.get(b'worker_id', b'unknown').decode('utf-8'),
+            }
 
-                if b'last_active' in client_data:
-                    last_active = float(client_data[b'last_active'].decode('utf-8'))
-                    client_info['last_active'] = last_active
-                    client_info['last_active_ago'] = time.time() - last_active
+            if b'connected_at' in client_data:
+                connected_at = float(client_data[b'connected_at'].decode('utf-8'))
+                client_info['connected_at'] = connected_at
+                client_info['connection_duration'] = time.time() - connected_at
 
-                # Add transfer rate statistics
-                if b'bytes_sent' in client_data:
-                    client_info['bytes_sent'] = int(client_data[b'bytes_sent'].decode('utf-8'))
+            if b'last_active' in client_data:
+                last_active = float(client_data[b'last_active'].decode('utf-8'))
+                client_info['last_active'] = last_active
+                client_info['last_active_ago'] = time.time() - last_active
 
-                # Add average transfer rate
-                if b'avg_rate_KBps' in client_data:
-                    client_info['avg_rate_KBps'] = float(client_data[b'avg_rate_KBps'].decode('utf-8'))
-                elif b'transfer_rate_KBps' in client_data:  # For backward compatibility
-                    client_info['avg_rate_KBps'] = float(client_data[b'transfer_rate_KBps'].decode('utf-8'))
+            # Add transfer rate statistics
+            if b'bytes_sent' in client_data:
+                client_info['bytes_sent'] = int(client_data[b'bytes_sent'].decode('utf-8'))
 
-                # Add current transfer rate
-                if b'current_rate_KBps' in client_data:
-                    client_info['current_rate_KBps'] = float(client_data[b'current_rate_KBps'].decode('utf-8'))
+            # Add average transfer rate
+            if b'avg_rate_KBps' in client_data:
+                client_info['avg_rate_KBps'] = float(client_data[b'avg_rate_KBps'].decode('utf-8'))
+            elif b'transfer_rate_KBps' in client_data:  # For backward compatibility
+                client_info['avg_rate_KBps'] = float(client_data[b'transfer_rate_KBps'].decode('utf-8'))
 
-                clients.append(client_info)
+            # Add current transfer rate
+            if b'current_rate_KBps' in client_data:
+                client_info['current_rate_KBps'] = float(client_data[b'current_rate_KBps'].decode('utf-8'))
+
+            clients.append(client_info)
+
+        # Clean up stale SET entries so SCARD stays accurate.
+        if stale_client_ids:
+            proxy_server.redis_client.srem(client_set_key, *stale_client_ids)
+            logger.info(
+                f"Removed {len(stale_client_ids)} ghost client(s) from "
+                f"channel {channel_id} client set"
+            )
 
         info['clients'] = clients
         info['client_count'] = len(clients)
@@ -430,19 +444,27 @@ class ChannelStatus:
             clients = []
             client_ids = proxy_server.redis_client.smembers(client_set_key)
 
-            # Process only if we have clients and keep it limited
+            # Remove ghost SET entries before building the client list.
+            # Pass the already-fetched client_ids to avoid a redundant SMEMBERS.
+            stale_client_ids = ClientManager.remove_ghost_clients(
+                proxy_server.redis_client, channel_id, client_ids=client_ids
+            )
+            if stale_client_ids:
+                client_count = max(0, client_count - len(stale_client_ids))
+
+            # Build concise client list (up to 10) from remaining live clients.
             if client_ids:
-                # Get up to 10 clients for the basic view
                 for client_id in list(client_ids)[:10]:
+                    if client_id in stale_client_ids:
+                        continue
+
                     client_id_str = client_id.decode('utf-8')
                     client_key = RedisKeys.client_metadata(channel_id, client_id_str)
 
-                    # Efficient way - just retrieve the essentials
                     client_info = {
                         'client_id': client_id_str,
                     }
 
-                    # Safely get user_agent and ip_address
                     user_agent_bytes = proxy_server.redis_client.hget(client_key, 'user_agent')
                     client_info['user_agent'] = safe_decode(user_agent_bytes)
 
@@ -450,7 +472,6 @@ class ChannelStatus:
                     if ip_address_bytes:
                         client_info['ip_address'] = safe_decode(ip_address_bytes)
 
-                    # Just get connected_at for client age
                     connected_at_bytes = proxy_server.redis_client.hget(client_key, 'connected_at')
                     if connected_at_bytes:
                         connected_at = float(connected_at_bytes.decode('utf-8'))
@@ -460,6 +481,7 @@ class ChannelStatus:
 
             # Add clients to info
             info['clients'] = clients
+            info['client_count'] = client_count
 
             # Add M3U profile information
             m3u_profile_id_bytes = metadata.get(ChannelMetadataField.M3U_PROFILE.encode('utf-8'))

apps/proxy/ts_proxy/client_manager.py

@@ -412,3 +412,42 @@ class ClientManager:
             self.redis_client.expire(self.client_set_key, self.client_ttl)
         except Exception as e:
             logger.error(f"Error refreshing client TTL: {e}")
+
+    @staticmethod
+    def remove_ghost_clients(redis_client, channel_id, client_ids=None):
+        """Remove client SET entries whose metadata hash has expired.
+
+        Returns the list of removed (stale) client IDs, or an empty list
+        if none were found. Uses a pipelined EXISTS check for efficiency.
+
+        Args:
+            client_ids: Optional pre-fetched result of SMEMBERS for this
+                        channel. Pass this to avoid a redundant SMEMBERS
+                        call when the caller has already fetched it.
+        """
+        client_set_key = RedisKeys.clients(channel_id)
+        if client_ids is None:
+            client_ids = redis_client.smembers(client_set_key)
+        if not client_ids:
+            return []
+
+        client_id_list = list(client_ids)
+        pipe = redis_client.pipeline()
+        for cid in client_id_list:
+            cid_str = cid.decode('utf-8')
+            pipe.exists(RedisKeys.client_metadata(channel_id, cid_str))
+        results = pipe.execute()
+
+        stale_ids = [
+            cid for cid, exists in zip(client_id_list, results)
+            if not exists
+        ]
+
+        if stale_ids:
+            redis_client.srem(client_set_key, *stale_ids)
+            logger.info(
+                f"Removed {len(stale_ids)} ghost client(s) from "
+                f"channel {channel_id} client set"
+            )
+
+        return stale_ids

apps/proxy/ts_proxy/constants.py

@@ -20,6 +20,10 @@ class ChannelState:
     STOPPED = "stopped"
     BUFFERING = "buffering"
 
+    # States before a channel is fully active. Used by the stream manager
+    # finally block to decide whether a failed stream can write ERROR.
+    PRE_ACTIVE = frozenset([INITIALIZING, CONNECTING, BUFFERING, WAITING_FOR_CLIENTS])
+
 # Event types
 class EventType:
     STREAM_SWITCH = "stream_switch"
@@ -71,6 +75,7 @@ class ChannelMetadataField:
     FFMPEG_FPS = "ffmpeg_fps"
     ACTUAL_FPS = "actual_fps"
     FFMPEG_OUTPUT_BITRATE = "ffmpeg_output_bitrate"
+    FFMPEG_BITRATE = "ffmpeg_bitrate"
     FFMPEG_STATS_UPDATED = "ffmpeg_stats_updated"
 
     # Video stream info
@@ -81,6 +86,7 @@ class ChannelMetadataField:
     SOURCE_FPS = "source_fps"
     PIXEL_FORMAT = "pixel_format"
     VIDEO_BITRATE = "video_bitrate"
+    SOURCE_BITRATE = "source_bitrate"
 
     # Audio stream info
     AUDIO_CODEC = "audio_codec"

apps/proxy/ts_proxy/server.py

@@ -1080,7 +1080,7 @@ class ProxyServer:
                                 logger.info(f"Channel {channel_id} has {total_clients} clients, state: {channel_state}")
 
                             # If in connecting or waiting_for_clients state, check grace period
-                            if channel_state in [ChannelState.CONNECTING, ChannelState.WAITING_FOR_CLIENTS]:
+                            if channel_state in [ChannelState.INITIALIZING, ChannelState.CONNECTING, ChannelState.WAITING_FOR_CLIENTS]:
                                 # Check if channel is already stopping
                                 if self.redis_client:
                                     stop_key = RedisKeys.channel_stopping(channel_id)
@@ -1389,8 +1389,30 @@ class ProxyServer:
                             # Just clean up Redis keys for remote channels
                             self._clean_redis_keys(channel_id)
                     elif not owner_alive and client_count > 0:
-                        # Owner is gone but clients remain - just log for now
-                        logger.warning(f"Found orphaned channel {channel_id} with {client_count} clients but no owner - may need ownership takeover")
+                        # SCARD may include ghost entries from a dead worker's
+                        # expired metadata hashes. Validate before deciding.
+                        stale_ids = ClientManager.remove_ghost_clients(
+                            self.redis_client, channel_id
+                        )
+                        real_count = max(0, client_count - len(stale_ids))
+                        if real_count <= 0:
+                            # No real clients remain — safe to clean up.
+                            state = metadata.get(b'state', b'unknown').decode('utf-8') if b'state' in metadata else 'unknown'
+                            logger.warning(
+                                f"Orphaned channel {channel_id} (state: {state}, "
+                                f"owner: {owner}) had {client_count} ghost client(s) "
+                                f"- cleaning up"
+                            )
+                            if channel_id in self.stream_managers or channel_id in self.client_managers:
+                                self.stop_channel(channel_id)
+                            else:
+                                self._clean_redis_keys(channel_id)
+                        else:
+                            logger.warning(
+                                f"Orphaned channel {channel_id} still has "
+                                f"{real_count} live client(s) after ghost removal "
+                                f"- may need ownership takeover"
+                            )
 
                 except Exception as e:
                     logger.error(f"Error processing metadata key {key}: {e}", exc_info=True)

apps/proxy/ts_proxy/stream_manager.py

@@ -401,24 +401,44 @@ class StreamManager:
             # Close all connections
             self._close_all_connections()
 
-            # Update channel state in Redis to prevent clients from waiting indefinitely
+            # Transition to ERROR so clients stop waiting. Ownership may have
+            # expired during retries, so fall back to a state guard when no
+            # owner exists — but never clobber a new owner's active stream.
             if hasattr(self.buffer, 'redis_client') and self.buffer.redis_client:
                 try:
                     metadata_key = RedisKeys.channel_metadata(self.channel_id)
-
-                    # Check if we're the owner before updating state
                     owner_key = RedisKeys.channel_owner(self.channel_id)
                     current_owner = self.buffer.redis_client.get(owner_key)
 
-                    # Use the worker_id that was passed in during initialization
-                    if current_owner and self.worker_id and current_owner.decode('utf-8') == self.worker_id:
-                        # Determine the appropriate error message based on retry failures
+                    is_owner = (
+                        current_owner
+                        and self.worker_id
+                        and current_owner.decode('utf-8') == self.worker_id
+                    )
+                    no_owner = current_owner is None
+
+                    should_update = is_owner
+                    if not should_update and no_owner:
+                        current_state_bytes = self.buffer.redis_client.hget(
+                            metadata_key, ChannelMetadataField.STATE
+                        )
+                        current_state = (
+                            current_state_bytes.decode('utf-8')
+                            if current_state_bytes else None
+                        )
+                        should_update = current_state in ChannelState.PRE_ACTIVE
+                        if not should_update and current_state:
+                            logger.info(
+                                f"Channel {self.channel_id} has no owner but "
+                                f"state is {current_state} — skipping ERROR update"
+                            )
+
+                    if should_update:
                         if self.tried_stream_ids and len(self.tried_stream_ids) > 0:
                             error_message = f"All {len(self.tried_stream_ids)} stream options failed"
                         else:
                             error_message = f"Connection failed after {self.max_retries} attempts"
 
-                        # Update metadata to indicate error state
                         update_data = {
                             ChannelMetadataField.STATE: ChannelState.ERROR,
                             ChannelMetadataField.STATE_CHANGED_AT: str(time.time()),
@@ -426,9 +446,13 @@ class StreamManager:
                             ChannelMetadataField.ERROR_TIME: str(time.time())
                         }
                         self.buffer.redis_client.hset(metadata_key, mapping=update_data)
-                        logger.info(f"Updated channel {self.channel_id} state to ERROR in Redis after stream failure")
+                        logger.info(
+                            f"Updated channel {self.channel_id} state to ERROR "
+                            f"in Redis after stream failure "
+                            f"(owner={'self' if is_owner else 'expired'})"
+                        )
 
-                        # Also set stopping key to ensure clients disconnect
+                        # Signal clients to disconnect
                         stop_key = RedisKeys.channel_stopping(self.channel_id)
                         self.buffer.redis_client.setex(stop_key, 60, "true")
                 except Exception as e:

dispatcharr/settings.py

@@ -267,6 +267,11 @@ CELERY_BEAT_SCHEDULE = {
         "task": "core.tasks.check_for_version_update",
         "schedule": 86400.0,  # Once every 24 hours
     },
+    # Check for account expirations daily
+    "check-account-expirations": {
+        "task": "apps.m3u.tasks.check_account_expirations",
+        "schedule": 86400.0,  # Once every 24 hours
+    },
 }
 
 MEDIA_ROOT = BASE_DIR / "media"

docker/uwsgi.debug.ini

@@ -28,8 +28,6 @@ static-map = /static=/app/static
 
 # Worker configuration
 workers = 1
-threads = 8
-enable-threads = true
 lazy-apps = true
 
 # HTTP server

docker/uwsgi.dev.ini

@@ -28,10 +28,8 @@ vacuum = true
 die-on-term = true
 static-map = /static=/app/static
 
-# Worker management (Optimize for I/O bound tasks)
+# Worker management
 workers = 4
-threads = 2
-enable-threads = true
 
 # Optimize for streaming
 http = 0.0.0.0:5656

frontend/src/api.js

@@ -1286,6 +1286,7 @@ export default class API {
 
         body = new FormData();
         for (const prop in values) {
+          if (values[prop] === null || values[prop] === undefined) continue;
           body.append(prop, values[prop]);
         }
       } else {

frontend/src/components/forms/M3U.jsx

@@ -29,6 +29,7 @@ import useEPGsStore from '../../store/epgs';
 import useVODStore from '../../store/useVODStore';
 import M3UFilters from './M3UFilters';
 import ScheduleInput from './ScheduleInput';
+import { DateTimePicker } from '@mantine/dates';
 
 const M3U = ({
   m3uAccount = null,
@@ -45,6 +46,7 @@ const M3U = ({
 
   const [playlist, setPlaylist] = useState(null);
   const [file, setFile] = useState(null);
+  const [expDate, setExpDate] = useState(null);
   const [profileModalOpen, setProfileModalOpen] = useState(false);
   const [groupFilterModalOpen, setGroupFilterModalOpen] = useState(false);
   const [filterModalOpen, setFilterModalOpen] = useState(false);
@@ -102,6 +104,7 @@ const M3U = ({
             : 0,
         enable_vod: m3uAccount.enable_vod || false,
       });
+      setExpDate(m3uAccount.exp_date ? new Date(m3uAccount.exp_date) : null);
 
       // Determine schedule type from existing data
       setScheduleType(
@@ -119,6 +122,7 @@ const M3U = ({
       setPlaylist(null);
       form.reset();
       setScheduleType('interval');
+      setExpDate(null);
     }
   }, [m3uAccount]);
 
@@ -131,6 +135,16 @@ const M3U = ({
   const onSubmit = async () => {
     const { create_epg, ...values } = form.getValues();
 
+    // Convert exp_date (from controlled state) to ISO string for the API
+    if (values.account_type === 'XC') {
+      // XC accounts have exp_date auto-managed server-side; don't send it
+      delete values.exp_date;
+    } else if (expDate instanceof Date) {
+      values.exp_date = expDate.toISOString();
+    } else {
+      values.exp_date = null;
+    }
+
     // Determine which schedule type is active based on field values
     const hasCronExpression =
       values.cron_expression && values.cron_expression.trim() !== '';
@@ -359,13 +373,25 @@ const M3U = ({
               )}
 
               {form.getValues().account_type != 'XC' && (
-                <FileInput
-                  id="file"
-                  label="Upload files"
-                  placeholder="Upload files"
-                  description="Upload a local M3U file instead of using URL"
-                  onChange={setFile}
-                />
+                <>
+                  <FileInput
+                    id="file"
+                    label="Upload files"
+                    placeholder="Upload files"
+                    description="Upload a local M3U file instead of using URL"
+                    onChange={setFile}
+                  />
+
+                  <DateTimePicker
+                    label="Expiration Date"
+                    description="Set an expiration date to receive a warning notification"
+                    placeholder="No expiration"
+                    clearable
+                    valueFormat="MMM D, YYYY h:mm A"
+                    value={expDate}
+                    onChange={(v) => setExpDate(v ? new Date(v) : null)}
+                  />
+                </>
               )}
             </Stack>
 

frontend/src/components/forms/M3UProfile.jsx

@@ -16,6 +16,7 @@ import {
   Textarea,
   NumberInput,
 } from '@mantine/core';
+import { DateTimePicker } from '@mantine/dates';
 import { useWebSocket } from '../../WebSocket';
 import usePlaylistsStore from '../../store/playlists';
 
@@ -32,6 +33,8 @@ const RegexFormAndView = ({ profile = null, m3u, isOpen, onClose }) => {
   const [sampleInput, setSampleInput] = useState('');
   const isDefaultProfile = profile?.is_default;
 
+  const isXC = m3u?.account_type === 'XC';
+
   const defaultValues = useMemo(
     () => ({
       name: profile?.name || '',
@@ -39,6 +42,7 @@ const RegexFormAndView = ({ profile = null, m3u, isOpen, onClose }) => {
       search_pattern: profile?.search_pattern || '',
       replace_pattern: profile?.replace_pattern || '',
       notes: profile?.custom_properties?.notes || '',
+      exp_date: profile?.exp_date ? new Date(profile.exp_date) : null,
     }),
     [profile]
   );
@@ -73,6 +77,17 @@ const RegexFormAndView = ({ profile = null, m3u, isOpen, onClose }) => {
   const onSubmit = async (values) => {
     console.log('submiting');
 
+    // Convert exp_date for submission
+    let expDateValue = values.exp_date;
+    if (isXC) {
+      // XC accounts have exp_date auto-managed; don't send it
+      expDateValue = undefined;
+    } else if (expDateValue instanceof Date) {
+      expDateValue = expDateValue.toISOString();
+    } else if (!expDateValue) {
+      expDateValue = null;
+    }
+
     // For default profiles, only send name and custom_properties (notes)
     let submitValues;
     if (isDefaultProfile) {
@@ -99,6 +114,11 @@ const RegexFormAndView = ({ profile = null, m3u, isOpen, onClose }) => {
       };
     }
 
+    // Add exp_date for non-XC accounts
+    if (expDateValue !== undefined) {
+      submitValues.exp_date = expDateValue;
+    }
+
     if (profile?.id) {
       await API.updateM3UProfile(m3u.id, {
         id: profile.id,
@@ -257,6 +277,18 @@ const RegexFormAndView = ({ profile = null, m3u, isOpen, onClose }) => {
           </>
         )}
 
+        {!isXC && (
+          <DateTimePicker
+            label="Expiration Date"
+            description="Set an expiration date to receive a 7-day warning notification"
+            placeholder="No expiration"
+            clearable
+            valueFormat="MMM D, YYYY h:mm A"
+            value={watch('exp_date')}
+            onChange={(value) => setValue('exp_date', value)}
+          />
+        )}
+
         <Textarea
           label="Notes"
           placeholder="Add any notes or comments about this profile..."

frontend/src/components/forms/settings/__tests__/DvrSettingsForm.test.jsx

@@ -0,0 +1,531 @@
+import { render, screen, fireEvent, waitFor } from '@testing-library/react';
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import DvrSettingsForm from '../DvrSettingsForm';
+
+// ── Store mocks ────────────────────────────────────────────────────────────────
+vi.mock('../../../../store/settings.jsx', () => {
+  const mock = vi.fn();
+  mock.getState = vi.fn();
+  return { default: mock };
+});
+
+// ── Utility mocks ──────────────────────────────────────────────────────────────
+vi.mock('../../../../utils/pages/SettingsUtils.js', () => ({
+  getChangedSettings: vi.fn(),
+  parseSettings: vi.fn(),
+  saveChangedSettings: vi.fn(),
+}));
+
+vi.mock('../../../../utils/notificationUtils.js', () => ({
+  showNotification: vi.fn(),
+}));
+
+vi.mock('../../../../utils/forms/settings/DvrSettingsFormUtils.js', () => ({
+  getComskipConfig: vi.fn(),
+  getDvrSettingsFormInitialValues: vi.fn(),
+  uploadComskipIni: vi.fn(),
+}));
+
+// ── Mantine form ───────────────────────────────────────────────────────────────
+vi.mock('@mantine/form', () => ({
+  useForm: vi.fn(),
+}));
+
+// ── Mantine core ───────────────────────────────────────────────────────────────
+vi.mock('@mantine/core', () => ({
+  Alert: ({ title }) => <div data-testid="alert">{title}</div>,
+  Button: ({ children, onClick, disabled, type, variant }) => (
+    <button
+      type={type || 'button'}
+      onClick={onClick}
+      disabled={disabled}
+      data-variant={variant}
+    >
+      {children}
+    </button>
+  ),
+  FileInput: ({ placeholder, onChange, disabled }) => (
+    <input
+      data-testid="file-input"
+      type="file"
+      placeholder={placeholder}
+      disabled={disabled}
+      onChange={(e) => {
+        const file = e.target.files?.[0] ?? null;
+        onChange?.(file);
+      }}
+    />
+  ),
+  Flex: ({ children }) => <div>{children}</div>,
+  Group: ({ children }) => <div>{children}</div>,
+  NumberInput: ({ label, id, name, ...rest }) => (
+    <input
+      data-testid={id}
+      id={id}
+      name={name}
+      aria-label={label}
+      type="number"
+      onChange={(e) => rest.onChange?.(Number(e.target.value))}
+    />
+  ),
+  Stack: ({ children }) => <div>{children}</div>,
+  Switch: ({ label, id, checked, onChange }) => (
+    <input
+      data-testid={id}
+      id={id}
+      type="checkbox"
+      aria-label={label}
+      checked={checked ?? false}
+      onChange={onChange}
+    />
+  ),
+  Text: ({ children }) => <span>{children}</span>,
+  TextInput: ({ label, id, name, placeholder, ...rest }) => (
+    <input
+      data-testid={id}
+      id={id}
+      name={name}
+      aria-label={label}
+      placeholder={placeholder}
+      onChange={(e) => rest.onChange?.(e)}
+    />
+  ),
+}));
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Imports after mocks
+// ──────────────────────────────────────────────────────────────────────────────
+import useSettingsStore from '../../../../store/settings.jsx';
+import { useForm } from '@mantine/form';
+import {
+  getChangedSettings,
+  parseSettings,
+  saveChangedSettings,
+} from '../../../../utils/pages/SettingsUtils.js';
+import { showNotification } from '../../../../utils/notificationUtils.js';
+import {
+  getComskipConfig,
+  getDvrSettingsFormInitialValues,
+  uploadComskipIni,
+} from '../../../../utils/forms/settings/DvrSettingsFormUtils.js';
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Helpers
+// ──────────────────────────────────────────────────────────────────────────────
+const mockFormValues = {
+  comskip_enabled: false,
+  comskip_custom_path: '',
+  pre_offset_minutes: 0,
+  post_offset_minutes: 0,
+  tv_template: '',
+  tv_fallback_template: '',
+  movie_template: '',
+  movie_fallback_template: '',
+};
+
+const makeFormMock = (overrides = {}) => ({
+  getInputProps: vi.fn((field, opts) => {
+    if (opts?.type === 'checkbox')
+      return { checked: mockFormValues[field] ?? false, onChange: vi.fn() };
+    return { value: mockFormValues[field] ?? '', onChange: vi.fn() };
+  }),
+  setValues: vi.fn(),
+  setFieldValue: vi.fn(),
+  getValues: vi.fn(() => mockFormValues),
+  onSubmit: vi.fn((handler) => (e) => {
+    e?.preventDefault?.();
+    return handler();
+  }),
+  ...overrides,
+});
+
+const makeSettings = (overrides = {}) => ({
+  comskip_enabled: { key: 'comskip_enabled', value: 'false' },
+  comskip_custom_path: { key: 'comskip_custom_path', value: '' },
+  pre_offset_minutes: { key: 'pre_offset_minutes', value: '0' },
+  post_offset_minutes: { key: 'post_offset_minutes', value: '0' },
+  ...overrides,
+});
+
+const setupMocks = ({ settings = makeSettings(), formOverrides = {} } = {}) => {
+  const formMock = makeFormMock(formOverrides);
+
+  vi.mocked(useForm).mockReturnValue(formMock);
+  vi.mocked(getDvrSettingsFormInitialValues).mockReturnValue(mockFormValues);
+  vi.mocked(parseSettings).mockReturnValue(mockFormValues);
+  vi.mocked(getComskipConfig).mockResolvedValue({ path: '', exists: false });
+  vi.mocked(getChangedSettings).mockReturnValue({});
+  vi.mocked(saveChangedSettings).mockResolvedValue(undefined);
+
+  vi.mocked(useSettingsStore).mockImplementation((sel) => sel({ settings }));
+  vi.mocked(useSettingsStore).getState = vi.fn(() => ({
+    updateSetting: vi.fn(),
+  }));
+
+  return { formMock };
+};
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Tests
+// ──────────────────────────────────────────────────────────────────────────────
+describe('DvrSettingsForm', () => {
+  let formMock;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    ({ formMock } = setupMocks());
+  });
+
+  // ── Rendering ──────────────────────────────────────────────────────────────
+  describe('rendering', () => {
+    it('renders the form without crashing', async () => {
+      render(<DvrSettingsForm active={true} />);
+      await waitFor(() => {
+        expect(screen.getByTestId('comskip_enabled')).toBeInTheDocument();
+      });
+    });
+
+    it('renders the comskip enabled switch', async () => {
+      render(<DvrSettingsForm active={true} />);
+      await waitFor(() => {
+        expect(screen.getByTestId('comskip_enabled')).toBeInTheDocument();
+      });
+    });
+
+    it('renders the comskip custom path text input', async () => {
+      render(<DvrSettingsForm active={true} />);
+      await waitFor(() => {
+        expect(screen.getByTestId('comskip_custom_path')).toBeInTheDocument();
+      });
+    });
+
+    it('renders the file input for comskip.ini upload', async () => {
+      render(<DvrSettingsForm active={true} />);
+      await waitFor(() => {
+        expect(screen.getByTestId('file-input')).toBeInTheDocument();
+      });
+    });
+
+    it('renders the Upload comskip.ini button', async () => {
+      render(<DvrSettingsForm active={true} />);
+      await waitFor(() => {
+        expect(screen.getByText('Upload comskip.ini')).toBeInTheDocument();
+      });
+    });
+
+    it('renders the pre_offset_minutes number input', async () => {
+      render(<DvrSettingsForm active={true} />);
+      await waitFor(() => {
+        expect(screen.getByTestId('pre_offset_minutes')).toBeInTheDocument();
+      });
+    });
+
+    it('renders the post_offset_minutes number input', async () => {
+      render(<DvrSettingsForm active={true} />);
+      await waitFor(() => {
+        expect(screen.getByTestId('post_offset_minutes')).toBeInTheDocument();
+      });
+    });
+
+    it('renders all template text inputs', async () => {
+      render(<DvrSettingsForm active={true} />);
+      await waitFor(() => {
+        expect(screen.getByTestId('tv_template')).toBeInTheDocument();
+        expect(screen.getByTestId('tv_fallback_template')).toBeInTheDocument();
+        expect(screen.getByTestId('movie_template')).toBeInTheDocument();
+        expect(
+          screen.getByTestId('movie_fallback_template')
+        ).toBeInTheDocument();
+      });
+    });
+
+    it('renders the Save button', async () => {
+      render(<DvrSettingsForm active={true} />);
+      await waitFor(() => {
+        expect(screen.getByText('Save')).toBeInTheDocument();
+      });
+    });
+
+    it('does not show success alert on initial render', async () => {
+      render(<DvrSettingsForm active={true} />);
+      await waitFor(() => {
+        expect(screen.queryByTestId('alert')).not.toBeInTheDocument();
+      });
+    });
+
+    it('shows "No custom comskip.ini uploaded." when no config exists', async () => {
+      render(<DvrSettingsForm active={true} />);
+      await waitFor(() => {
+        expect(
+          screen.getByText('No custom comskip.ini uploaded.')
+        ).toBeInTheDocument();
+      });
+    });
+
+    it('shows config path when comskipConfig has path and exists', async () => {
+      vi.mocked(getComskipConfig).mockResolvedValue({
+        path: '/app/docker/comskip.ini',
+        exists: true,
+      });
+      render(<DvrSettingsForm active={true} />);
+      await waitFor(() => {
+        expect(
+          screen.getByText('Using /app/docker/comskip.ini')
+        ).toBeInTheDocument();
+      });
+    });
+  });
+
+  // ── Initialization ─────────────────────────────────────────────────────────
+  describe('initialization', () => {
+    it('calls getDvrSettingsFormInitialValues on mount', async () => {
+      render(<DvrSettingsForm active={true} />);
+      await waitFor(() => {
+        expect(getDvrSettingsFormInitialValues).toHaveBeenCalled();
+      });
+    });
+
+    it('calls parseSettings with settings on mount', async () => {
+      render(<DvrSettingsForm active={true} />);
+      await waitFor(() => {
+        expect(parseSettings).toHaveBeenCalledWith(makeSettings());
+        expect(formMock.setValues).toHaveBeenCalledWith(mockFormValues);
+      });
+    });
+
+    it('calls getComskipConfig on mount', async () => {
+      render(<DvrSettingsForm active={true} />);
+      await waitFor(() => {
+        expect(getComskipConfig).toHaveBeenCalled();
+      });
+    });
+
+    it('sets comskip path from getComskipConfig response', async () => {
+      vi.mocked(getComskipConfig).mockResolvedValue({
+        path: '/custom/path/comskip.ini',
+        exists: true,
+      });
+      render(<DvrSettingsForm active={true} />);
+      await waitFor(() => {
+        expect(formMock.setFieldValue).toHaveBeenCalledWith(
+          'comskip_custom_path',
+          '/custom/path/comskip.ini'
+        );
+      });
+    });
+
+    it('handles getComskipConfig error gracefully', async () => {
+      vi.mocked(getComskipConfig).mockRejectedValue(new Error('network error'));
+      const consoleSpy = vi
+        .spyOn(console, 'error')
+        .mockImplementation(() => {});
+      render(<DvrSettingsForm active={true} />);
+      await waitFor(() => {
+        expect(consoleSpy).toHaveBeenCalledWith(
+          'Failed to load comskip config',
+          expect.any(Error)
+        );
+      });
+      consoleSpy.mockRestore();
+    });
+
+    it('does not call setFieldValue when getComskipConfig returns no path', async () => {
+      render(<DvrSettingsForm active={true} />);
+      await waitFor(() => {
+        expect(getComskipConfig).toHaveBeenCalled();
+      });
+      expect(formMock.setFieldValue).not.toHaveBeenCalledWith(
+        'comskip_custom_path',
+        expect.anything()
+      );
+    });
+  });
+
+  // ── active prop ────────────────────────────────────────────────────────────
+  describe('active prop', () => {
+    it('resets saved state when active becomes false', async () => {
+      vi.mocked(getChangedSettings).mockReturnValue({ comskip_enabled: true });
+      const { rerender } = render(<DvrSettingsForm active={true} />);
+
+      fireEvent.submit(screen.getByText('Save').closest('form'));
+
+      await waitFor(() => {
+        expect(screen.getByTestId('alert')).toBeInTheDocument();
+      });
+
+      rerender(<DvrSettingsForm active={false} />);
+
+      await waitFor(() => {
+        expect(screen.queryByTestId('alert')).not.toBeInTheDocument();
+      });
+    });
+  });
+
+  // ── Form submission ────────────────────────────────────────────────────────
+  describe('form submission', () => {
+    it('calls getChangedSettings and saveChangedSettings on submit', async () => {
+      vi.mocked(getChangedSettings).mockReturnValue({ pre_offset_minutes: 5 });
+      render(<DvrSettingsForm active={true} />);
+      fireEvent.submit(screen.getByText('Save').closest('form'));
+
+      await waitFor(() => {
+        expect(getChangedSettings).toHaveBeenCalledWith(
+          mockFormValues,
+          makeSettings()
+        );
+        expect(saveChangedSettings).toHaveBeenCalledWith(makeSettings(), {
+          pre_offset_minutes: 5,
+        });
+      });
+    });
+
+    it('shows success alert after successful save', async () => {
+      render(<DvrSettingsForm active={true} />);
+      fireEvent.submit(screen.getByText('Save').closest('form'));
+
+      await waitFor(() => {
+        expect(screen.getByTestId('alert')).toBeInTheDocument();
+        expect(screen.getByText('Saved Successfully')).toBeInTheDocument();
+      });
+    });
+
+    it('does not show success alert when saveChangedSettings throws', async () => {
+      vi.mocked(saveChangedSettings).mockRejectedValue(
+        new Error('save failed')
+      );
+      const consoleSpy = vi
+        .spyOn(console, 'error')
+        .mockImplementation(() => {});
+
+      render(<DvrSettingsForm active={true} />);
+      fireEvent.submit(screen.getByText('Save').closest('form'));
+
+      await waitFor(() => {
+        expect(consoleSpy).toHaveBeenCalledWith(
+          'Error saving settings:',
+          expect.any(Error)
+        );
+        expect(screen.queryByTestId('alert')).not.toBeInTheDocument();
+      });
+      consoleSpy.mockRestore();
+    });
+  });
+
+  // ── comskip upload ─────────────────────────────────────────────────────────
+  describe('comskip upload', () => {
+    it('Upload button is disabled when no file is selected', async () => {
+      render(<DvrSettingsForm active={true} />);
+      await waitFor(() => {
+        expect(screen.getByText('Upload comskip.ini')).toBeDisabled();
+      });
+    });
+
+    it('calls uploadComskipIni with the selected file', async () => {
+      const mockFile = new File(['content'], 'comskip.ini', {
+        type: 'text/plain',
+      });
+      vi.mocked(uploadComskipIni).mockResolvedValue({
+        path: '/uploaded/comskip.ini',
+      });
+
+      render(<DvrSettingsForm active={true} />);
+      fireEvent.change(screen.getByTestId('file-input'), {
+        target: { files: [mockFile] },
+      });
+
+      await waitFor(() => {
+        fireEvent.click(screen.getByText('Upload comskip.ini'));
+      });
+
+      await waitFor(() => {
+        expect(uploadComskipIni).toHaveBeenCalledWith(mockFile);
+      });
+    });
+
+    it('shows success notification after successful upload', async () => {
+      const mockFile = new File(['content'], 'comskip.ini', {
+        type: 'text/plain',
+      });
+      vi.mocked(uploadComskipIni).mockResolvedValue({
+        path: '/uploaded/comskip.ini',
+      });
+
+      render(<DvrSettingsForm active={true} />);
+      fireEvent.change(screen.getByTestId('file-input'), {
+        target: { files: [mockFile] },
+      });
+
+      await waitFor(() => {
+        fireEvent.click(screen.getByText('Upload comskip.ini'));
+      });
+
+      await waitFor(() => {
+        expect(showNotification).toHaveBeenCalledWith(
+          expect.objectContaining({
+            title: 'comskip.ini uploaded',
+            color: 'green',
+          })
+        );
+      });
+    });
+
+    it('sets comskip_custom_path form field after successful upload', async () => {
+      const mockFile = new File(['content'], 'comskip.ini', {
+        type: 'text/plain',
+      });
+      vi.mocked(uploadComskipIni).mockResolvedValue({
+        path: '/uploaded/comskip.ini',
+      });
+
+      render(<DvrSettingsForm active={true} />);
+      fireEvent.change(screen.getByTestId('file-input'), {
+        target: { files: [mockFile] },
+      });
+
+      await waitFor(() => {
+        fireEvent.click(screen.getByText('Upload comskip.ini'));
+      });
+
+      await waitFor(() => {
+        expect(formMock.setFieldValue).toHaveBeenCalledWith(
+          'comskip_custom_path',
+          '/uploaded/comskip.ini'
+        );
+      });
+    });
+
+    it('handles upload error gracefully', async () => {
+      const mockFile = new File(['content'], 'comskip.ini', {
+        type: 'text/plain',
+      });
+      vi.mocked(uploadComskipIni).mockRejectedValue(new Error('upload failed'));
+      const consoleSpy = vi
+        .spyOn(console, 'error')
+        .mockImplementation(() => {});
+
+      render(<DvrSettingsForm active={true} />);
+      fireEvent.change(screen.getByTestId('file-input'), {
+        target: { files: [mockFile] },
+      });
+
+      await waitFor(() => {
+        fireEvent.click(screen.getByText('Upload comskip.ini'));
+      });
+
+      await waitFor(() => {
+        expect(consoleSpy).toHaveBeenCalledWith(
+          'Failed to upload comskip.ini',
+          expect.any(Error)
+        );
+        expect(showNotification).not.toHaveBeenCalled();
+      });
+      consoleSpy.mockRestore();
+    });
+
+    it('does not call uploadComskipIni when no file is selected', async () => {
+      render(<DvrSettingsForm active={true} />);
+      await waitFor(() => screen.getByTestId('file-input'));
+      expect(uploadComskipIni).not.toHaveBeenCalled();
+    });
+  });
+});

frontend/src/components/forms/settings/__tests__/NavOrderForm.test.jsx

@@ -64,7 +64,7 @@ vi.mock('@dnd-kit/modifiers', () => ({
 // Mock Mantine components
 vi.mock('@mantine/core', () => ({
   Box: ({ children, ...props }) => <div {...props}>{children}</div>,
-  Button: ({ children, onClick, disabled, ...props }) => (
+  Button: ({ children, onClick, disabled }) => (
     <button onClick={onClick} disabled={disabled} data-testid="reset-button">
       {children}
     </button>

frontend/src/components/forms/settings/__tests__/NetworkAccessForm.test.jsx

@@ -0,0 +1,408 @@
+import { render, screen, fireEvent, waitFor } from '@testing-library/react';
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import NetworkAccessForm from '../NetworkAccessForm';
+
+// ── Constants mock ─────────────────────────────────────────────────────────────
+vi.mock('../../../../constants.js', () => ({
+  NETWORK_ACCESS_OPTIONS: [
+    { value: 'all', label: 'All' },
+    { value: 'local', label: 'Local Only' },
+    { value: 'custom', label: 'Custom' },
+  ],
+}));
+
+// ── Store mock ─────────────────────────────────────────────────────────────────
+vi.mock('../../../../store/settings.jsx', () => ({ default: vi.fn() }));
+
+// ── Utility mocks ──────────────────────────────────────────────────────────────
+vi.mock('../../../../utils/pages/SettingsUtils.js', () => ({
+  checkSetting: vi.fn(),
+  updateSetting: vi.fn(),
+}));
+
+vi.mock('../../../../utils/forms/settings/NetworkAccessFormUtils.js', () => ({
+  getNetworkAccessFormInitialValues: vi.fn(),
+  getNetworkAccessFormValidation: vi.fn(),
+  getNetworkAccessDefaults: vi.fn(),
+}));
+
+// ── Mantine form ───────────────────────────────────────────────────────────────
+vi.mock('@mantine/form', () => ({ useForm: vi.fn() }));
+
+// ── ConfirmationDialog mock ────────────────────────────────────────────────────
+vi.mock('../../../ConfirmationDialog.jsx', () => ({
+  default: ({ opened, onConfirm, onClose, title, message }) =>
+    opened ? (
+      <div data-testid="confirmation-dialog">
+        <div data-testid="confirm-title">{title}</div>
+        <div data-testid="confirm-message">{message}</div>
+        <button data-testid="confirm-ok" onClick={onConfirm}>
+          Confirm
+        </button>
+        <button data-testid="confirm-cancel" onClick={onClose}>
+          Cancel
+        </button>
+      </div>
+    ) : null,
+}));
+
+// ── Mantine core ───────────────────────────────────────────────────────────────
+vi.mock('@mantine/core', () => ({
+  Alert: ({ title, children }) => (
+    <div data-testid="alert">
+      <span data-testid="alert-title">{title}</span>
+      {children}
+    </div>
+  ),
+  Button: ({ children, onClick, disabled, loading, type, variant }) => (
+    <button
+      type={type || 'button'}
+      onClick={onClick}
+      disabled={disabled || loading}
+      data-variant={variant}
+      data-loading={String(loading)}
+    >
+      {children}
+    </button>
+  ),
+  Flex: ({ children }) => <div>{children}</div>,
+  Stack: ({ children }) => <div>{children}</div>,
+  Text: ({ children }) => <span>{children}</span>,
+  TextInput: ({ label, id, placeholder, error, ...rest }) => (
+    <div>
+      <input
+        data-testid={id}
+        id={id}
+        aria-label={label}
+        placeholder={placeholder}
+        data-error={error}
+        onChange={(e) => rest.onChange?.(e)}
+        value={rest.value ?? ''}
+      />
+      {error && <span data-testid={`${id}-error`}>{error}</span>}
+    </div>
+  ),
+}));
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Imports after mocks
+// ──────────────────────────────────────────────────────────────────────────────
+import useSettingsStore from '../../../../store/settings.jsx';
+import { useForm } from '@mantine/form';
+import {
+  checkSetting,
+  updateSetting,
+} from '../../../../utils/pages/SettingsUtils.js';
+import {
+  getNetworkAccessFormInitialValues,
+  getNetworkAccessFormValidation,
+  getNetworkAccessDefaults,
+} from '../../../../utils/forms/settings/NetworkAccessFormUtils.js';
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Helpers
+// ──────────────────────────────────────────────────────────────────────────────
+const mockInitialValues = {
+  m3u_access: 'local',
+  epg_access: 'local',
+  recordings_access: 'all',
+  m3u_custom_cidrs: '',
+  epg_custom_cidrs: '',
+  recordings_custom_cidrs: '',
+};
+
+const makeFormMock = (overrides = {}) => ({
+  key: vi.fn(),
+  getInputProps: vi.fn((field) => ({
+    value: mockInitialValues[field] ?? '',
+    onChange: vi.fn(),
+  })),
+  setValues: vi.fn(),
+  setErrors: vi.fn(),
+  setFieldValue: vi.fn(),
+  getValues: vi.fn(() => mockInitialValues),
+  validate: vi.fn(() => ({ hasErrors: false })),
+  onSubmit: vi.fn((handler) => (e) => {
+    e?.preventDefault?.();
+    return handler(mockInitialValues);
+  }),
+  errors: {},
+  ...overrides,
+});
+
+const makeSettings = (overrides = {}) => ({
+  network_access: {
+    key: 'network_access',
+    value: {
+      m3u_access: 'local',
+      epg_access: 'local',
+      recordings_access: 'all',
+    },
+  },
+  ...overrides,
+});
+
+const setupMocks = ({ settings = makeSettings(), formOverrides = {} } = {}) => {
+  const formMock = makeFormMock(formOverrides);
+
+  vi.mocked(useForm).mockReturnValue(formMock);
+  vi.mocked(getNetworkAccessFormInitialValues).mockReturnValue(
+    mockInitialValues
+  );
+  vi.mocked(getNetworkAccessFormValidation).mockReturnValue({});
+  vi.mocked(getNetworkAccessDefaults).mockReturnValue(mockInitialValues);
+  vi.mocked(checkSetting).mockResolvedValue({
+    client_ip: '192.168.1.1',
+    UI: ['192.168.0.0/16'],
+  });
+  vi.mocked(updateSetting).mockResolvedValue(undefined);
+
+  vi.mocked(useSettingsStore).mockImplementation((sel) => sel({ settings }));
+
+  return { formMock };
+};
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Tests
+// ──────────────────────────────────────────────────────────────────────────────
+describe('NetworkAccessForm', () => {
+  let formMock;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    ({ formMock } = setupMocks());
+  });
+
+  // ── Rendering ──────────────────────────────────────────────────────────────
+  describe('rendering', () => {
+    it('renders without crashing', () => {
+      render(<NetworkAccessForm active={true} />);
+      expect(screen.getByText('Save')).toBeInTheDocument();
+    });
+
+    it('renders the Save button', () => {
+      render(<NetworkAccessForm active={true} />);
+      expect(screen.getByText('Save')).toBeInTheDocument();
+    });
+
+    it('does not show success alert on initial render', () => {
+      render(<NetworkAccessForm active={true} />);
+      expect(screen.queryByTestId('alert')).not.toBeInTheDocument();
+    });
+
+    it('does not show confirmation dialog on initial render', () => {
+      render(<NetworkAccessForm active={true} />);
+      expect(
+        screen.queryByTestId('confirmation-dialog')
+      ).not.toBeInTheDocument();
+    });
+
+    it('does not show error alert on initial render', () => {
+      render(<NetworkAccessForm active={true} />);
+      expect(screen.queryByTestId('alert')).not.toBeInTheDocument();
+    });
+  });
+
+  // ── Initialization ─────────────────────────────────────────────────────────
+  describe('initialization', () => {
+    it('calls getNetworkAccessFormInitialValues on mount', () => {
+      render(<NetworkAccessForm active={true} />);
+      expect(getNetworkAccessFormInitialValues).toHaveBeenCalled();
+    });
+
+    it('calls getNetworkAccessFormValidation on mount', () => {
+      render(<NetworkAccessForm active={true} />);
+      expect(getNetworkAccessFormValidation).toHaveBeenCalled();
+    });
+
+    it('does not call checkSetting on mount', () => {
+      render(<NetworkAccessForm active={true} />);
+      expect(checkSetting).not.toHaveBeenCalled();
+    });
+
+    it('calls checkSetting when form is submitted', async () => {
+      render(<NetworkAccessForm active={true} />);
+      fireEvent.click(screen.getByText('Save'));
+      await waitFor(() => {
+        expect(checkSetting).toHaveBeenCalled();
+      });
+    });
+
+    it('sets form values from network_access settings on mount', async () => {
+      render(<NetworkAccessForm active={true} />);
+      await waitFor(() => {
+        expect(formMock.setValues).toHaveBeenCalled();
+      });
+    });
+
+    it('handles missing network_access setting gracefully', async () => {
+      ({ formMock } = setupMocks({ settings: {} }));
+      expect(() => render(<NetworkAccessForm active={true} />)).not.toThrow();
+    });
+
+    it('handles checkSetting error gracefully', async () => {
+      vi.mocked(checkSetting).mockRejectedValue(new Error('network error'));
+      render(<NetworkAccessForm active={true} />);
+    });
+  });
+
+  // ── active prop ────────────────────────────────────────────────────────────
+  describe('active prop', () => {
+    it('resets saved state when active becomes false', async () => {
+      vi.mocked(updateSetting).mockResolvedValue(undefined);
+      const { rerender } = render(<NetworkAccessForm active={true} />);
+
+      fireEvent.submit(
+        screen.getByText('Save').closest('form') ??
+          screen.getByText('Save').closest('div')
+      );
+
+      await waitFor(() => {
+        expect(screen.queryByTestId('confirmation-dialog')).not.toBeNull();
+      }).catch(() => {});
+
+      rerender(<NetworkAccessForm active={false} />);
+
+      await waitFor(() => {
+        expect(screen.queryByTestId('alert')).not.toBeInTheDocument();
+      });
+    });
+  });
+
+  // ── Form submission ────────────────────────────────────────────────────────
+  describe('form submission', () => {
+    it('opens confirmation dialog on Save click', async () => {
+      render(<NetworkAccessForm active={true} />);
+      fireEvent.click(screen.getByText('Save'));
+      await waitFor(() => {
+        expect(screen.getByTestId('confirmation-dialog')).toBeInTheDocument();
+      });
+    });
+
+    it('closes confirmation dialog on Cancel click', async () => {
+      render(<NetworkAccessForm active={true} />);
+      fireEvent.click(screen.getByText('Save'));
+
+      await waitFor(() => screen.getByTestId('confirmation-dialog'));
+      fireEvent.click(screen.getByTestId('confirm-cancel'));
+
+      await waitFor(() => {
+        expect(
+          screen.queryByTestId('confirmation-dialog')
+        ).not.toBeInTheDocument();
+      });
+    });
+
+    it('calls updateSetting on confirm', async () => {
+      render(<NetworkAccessForm active={true} />);
+      fireEvent.click(screen.getByText('Save'));
+
+      await waitFor(() => screen.getByTestId('confirmation-dialog'));
+      fireEvent.click(screen.getByTestId('confirm-ok'));
+
+      await waitFor(() => {
+        expect(updateSetting).toHaveBeenCalled();
+      });
+    });
+
+    it('shows success alert after confirmed save', async () => {
+      render(<NetworkAccessForm active={true} />);
+      fireEvent.click(screen.getByText('Save'));
+
+      await waitFor(() => screen.getByTestId('confirmation-dialog'));
+      fireEvent.click(screen.getByTestId('confirm-ok'));
+
+      await waitFor(() => {
+        expect(screen.getByTestId('alert')).toBeInTheDocument();
+        expect(screen.getByTestId('alert-title')).toHaveTextContent(
+          'Saved Successfully'
+        );
+      });
+    });
+
+    it('does not call updateSetting when confirmation is cancelled', async () => {
+      render(<NetworkAccessForm active={true} />);
+      fireEvent.click(screen.getByText('Save'));
+
+      await waitFor(() => screen.getByTestId('confirmation-dialog'));
+      fireEvent.click(screen.getByTestId('confirm-cancel'));
+
+      await waitFor(() => {
+        expect(updateSetting).not.toHaveBeenCalled();
+      });
+    });
+
+    it('does not show success alert when updateSetting throws', async () => {
+      vi.mocked(updateSetting).mockRejectedValue({
+        body: { value: { m3u_custom_cidrs: 'Invalid CIDR' } },
+      });
+      render(<NetworkAccessForm active={true} />);
+      fireEvent.click(screen.getByText('Save'));
+
+      await waitFor(() => screen.getByTestId('confirmation-dialog'));
+      fireEvent.click(screen.getByTestId('confirm-ok'));
+
+      await waitFor(() => {
+        const alertTitle = screen.queryByTestId('alert-title');
+        expect(alertTitle?.textContent).not.toBe('Saved Successfully');
+      });
+    });
+  });
+
+  // ── Client IP display ──────────────────────────────────────────────────────
+  describe('client IP display', () => {
+    it('displays client IP address fetched on submit', async () => {
+      render(<NetworkAccessForm active={true} />);
+      fireEvent.click(screen.getByText('Save'));
+
+      await waitFor(() => screen.getByTestId('confirmation-dialog'));
+      fireEvent.click(screen.getByTestId('confirm-ok'));
+      await waitFor(() => {
+        expect(screen.getByText(/192\.168\.1\.1/)).toBeInTheDocument();
+      });
+    });
+
+    it('does not display IP when checkSetting returns null', async () => {
+      vi.mocked(checkSetting).mockResolvedValue(null);
+      render(<NetworkAccessForm active={true} />);
+      await waitFor(() => {
+        expect(
+          screen.queryByText(/\d+\.\d+\.\d+\.\d+/)
+        ).not.toBeInTheDocument();
+      });
+    });
+  });
+
+  // ── Network access error ───────────────────────────────────────────────────
+  describe('network access error state', () => {
+    it('clears error state after successful save', async () => {
+      vi.mocked(checkSetting).mockResolvedValue({
+        error: true,
+        message: 'Invalid CIDR',
+        data: 'Error details',
+      });
+
+      render(<NetworkAccessForm active={true} />);
+
+      // First save — fails
+      fireEvent.click(screen.getByText('Save'));
+      await waitFor(() => screen.getByTestId('alert'));
+
+      vi.mocked(checkSetting).mockResolvedValue({
+        client_ip: '192.168.1.1',
+        UI: ['192.168.0.0/16'],
+      });
+
+      // Second save — succeeds
+      fireEvent.click(screen.getByText('Save'));
+      await waitFor(() => screen.getByTestId('confirmation-dialog'));
+      fireEvent.click(screen.getByTestId('confirm-ok'));
+
+      await waitFor(() => {
+        expect(screen.getByTestId('alert-title')).toHaveTextContent(
+          'Saved Successfully'
+        );
+      });
+    });
+  });
+});

frontend/src/components/forms/settings/__tests__/ProxySettingsForm.test.jsx

@@ -0,0 +1,363 @@
+import { render, screen, fireEvent, waitFor } from '@testing-library/react';
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import ProxySettingsForm from '../ProxySettingsForm';
+
+// ── Constants mock ─────────────────────────────────────────────────────────────
+vi.mock('../../../../constants.js', () => ({
+  PROXY_SETTINGS_OPTIONS: {
+    buffering_timeout: {
+      label: 'Buffering Timeout',
+      description: 'Timeout in seconds',
+    },
+    buffering_speed: {
+      label: 'Buffering Speed',
+      description: 'Speed multiplier',
+    },
+    redis_url: { label: 'Redis URL', description: 'Redis connection URL' },
+  },
+}));
+
+// ── Store mock ─────────────────────────────────────────────────────────────────
+vi.mock('../../../../store/settings.jsx', () => ({ default: vi.fn() }));
+
+// ── Utility mocks ──────────────────────────────────────────────────────────────
+vi.mock('../../../../utils/pages/SettingsUtils.js', () => ({
+  updateSetting: vi.fn(),
+}));
+
+vi.mock('../../../../utils/forms/settings/ProxySettingsFormUtils.js', () => ({
+  getProxySettingsFormInitialValues: vi.fn(),
+  getProxySettingDefaults: vi.fn(),
+}));
+
+// ── Mantine form ───────────────────────────────────────────────────────────────
+vi.mock('@mantine/form', () => ({ useForm: vi.fn() }));
+
+// ── Mantine core ───────────────────────────────────────────────────────────────
+vi.mock('@mantine/core', () => ({
+  Alert: ({ title, children }) => (
+    <div data-testid="alert">
+      <span data-testid="alert-title">{title}</span>
+      {children}
+    </div>
+  ),
+  Button: ({ children, onClick, disabled, loading, type, variant, color }) => (
+    <button
+      type={type || 'button'}
+      onClick={onClick}
+      disabled={disabled || loading}
+      data-variant={variant}
+      data-color={color}
+      data-loading={String(loading)}
+    >
+      {children}
+    </button>
+  ),
+  Flex: ({ children }) => <div>{children}</div>,
+  NumberInput: ({ label, description, min, max, step, ...rest }) => (
+    <div>
+      <label>{label}</label>
+      {description && <span data-testid={`desc-${label}`}>{description}</span>}
+      <input
+        data-testid={`number-input-${label}`}
+        type="number"
+        aria-label={label}
+        min={min}
+        max={max}
+        step={step}
+        onChange={(e) => rest.onChange?.(Number(e.target.value))}
+        value={rest.value ?? 0}
+      />
+    </div>
+  ),
+  Stack: ({ children }) => <div>{children}</div>,
+  TextInput: ({ label, description, ...rest }) => (
+    <div>
+      <label>{label}</label>
+      {description && <span data-testid={`desc-${label}`}>{description}</span>}
+      <input
+        data-testid={`text-input-${label}`}
+        aria-label={label}
+        onChange={(e) => rest.onChange?.(e)}
+        value={rest.value ?? ''}
+      />
+    </div>
+  ),
+}));
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Imports after mocks
+// ──────────────────────────────────────────────────────────────────────────────
+import useSettingsStore from '../../../../store/settings.jsx';
+import { useForm } from '@mantine/form';
+import { updateSetting } from '../../../../utils/pages/SettingsUtils.js';
+import {
+  getProxySettingsFormInitialValues,
+  getProxySettingDefaults,
+} from '../../../../utils/forms/settings/ProxySettingsFormUtils.js';
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Helpers
+// ──────────────────────────────────────────────────────────────────────────────
+const mockInitialValues = {
+  buffering_timeout: 30,
+  buffering_speed: 1.0,
+  redis_url: 'redis://localhost:6379',
+};
+
+const mockDefaults = {
+  buffering_timeout: 30,
+  buffering_speed: 1.0,
+  redis_url: '',
+};
+
+const makeFormMock = (overrides = {}) => ({
+  getInputProps: vi.fn((field) => ({
+    value: mockInitialValues[field] ?? '',
+    onChange: vi.fn(),
+  })),
+  setValues: vi.fn(),
+  getValues: vi.fn(() => mockInitialValues),
+  onSubmit: vi.fn((handler) => (e) => {
+    e?.preventDefault?.();
+    return handler();
+  }),
+  submitting: false,
+  errors: {},
+  ...overrides,
+});
+
+const makeSettings = (overrides = {}) => ({
+  proxy_settings: {
+    key: 'proxy_settings',
+    value: { ...mockInitialValues },
+  },
+  ...overrides,
+});
+
+const setupMocks = ({ settings = makeSettings(), formOverrides = {} } = {}) => {
+  const formMock = makeFormMock(formOverrides);
+
+  vi.mocked(useForm).mockReturnValue(formMock);
+  vi.mocked(getProxySettingsFormInitialValues).mockReturnValue(
+    mockInitialValues
+  );
+  vi.mocked(getProxySettingDefaults).mockReturnValue(mockDefaults);
+  vi.mocked(updateSetting).mockResolvedValue({ success: true });
+  vi.mocked(useSettingsStore).mockImplementation((sel) => sel({ settings }));
+
+  return { formMock };
+};
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Tests
+// ──────────────────────────────────────────────────────────────────────────────
+describe('ProxySettingsForm', () => {
+  let formMock;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    ({ formMock } = setupMocks());
+  });
+
+  // ── Rendering ──────────────────────────────────────────────────────────────
+  describe('rendering', () => {
+    it('does not show success alert on initial render', () => {
+      render(<ProxySettingsForm active={true} />);
+      expect(screen.queryByTestId('alert')).not.toBeInTheDocument();
+    });
+
+    it('renders NumberInput for buffering_timeout', () => {
+      render(<ProxySettingsForm active={true} />);
+      expect(
+        screen.getByTestId('number-input-Buffering Timeout')
+      ).toBeInTheDocument();
+    });
+
+    it('renders NumberInput for buffering_speed', () => {
+      render(<ProxySettingsForm active={true} />);
+      expect(
+        screen.getByTestId('number-input-Buffering Speed')
+      ).toBeInTheDocument();
+    });
+
+    it('renders TextInput for redis_url', () => {
+      render(<ProxySettingsForm active={true} />);
+      expect(screen.getByTestId('text-input-Redis URL')).toBeInTheDocument();
+    });
+
+    it('renders description text for fields that have one', () => {
+      render(<ProxySettingsForm active={true} />);
+      expect(screen.getByTestId('desc-Buffering Timeout')).toBeInTheDocument();
+    });
+  });
+
+  // ── Initialization ─────────────────────────────────────────────────────────
+  describe('initialization', () => {
+    it('calls getProxySettingsFormInitialValues on mount', () => {
+      render(<ProxySettingsForm active={true} />);
+      expect(getProxySettingsFormInitialValues).toHaveBeenCalled();
+    });
+
+    it('calls setValues with merged defaults and stored settings on mount', async () => {
+      render(<ProxySettingsForm active={true} />);
+      await waitFor(() => {
+        expect(formMock.setValues).toHaveBeenCalledWith({
+          ...mockDefaults,
+          ...makeSettings().proxy_settings.value,
+        });
+      });
+    });
+
+    it('does not call setValues when proxy_settings is missing', async () => {
+      ({ formMock } = setupMocks({ settings: {} }));
+      render(<ProxySettingsForm active={true} />);
+      await waitFor(() => {
+        expect(formMock.setValues).not.toHaveBeenCalled();
+      });
+    });
+
+    it('does not call setValues when proxy_settings.value is missing', async () => {
+      ({ formMock } = setupMocks({
+        settings: { proxy_settings: { key: 'proxy_settings' } },
+      }));
+      render(<ProxySettingsForm active={true} />);
+      await waitFor(() => {
+        expect(formMock.setValues).not.toHaveBeenCalled();
+      });
+    });
+
+    it('handles null settings gracefully', () => {
+      vi.mocked(useSettingsStore).mockImplementation((sel) =>
+        sel({ settings: null })
+      );
+      expect(() => render(<ProxySettingsForm active={true} />)).not.toThrow();
+    });
+  });
+
+  // ── active prop ────────────────────────────────────────────────────────────
+  describe('active prop', () => {
+    it('clears saved state when active becomes false', async () => {
+      vi.mocked(updateSetting).mockResolvedValue({ success: true });
+      const { rerender } = render(<ProxySettingsForm active={true} />);
+
+      // Trigger a successful save
+      fireEvent.submit(screen.getByText('Save').closest('form'));
+      await waitFor(() => {
+        expect(screen.getByTestId('alert')).toBeInTheDocument();
+      });
+
+      rerender(<ProxySettingsForm active={false} />);
+
+      await waitFor(() => {
+        expect(screen.queryByTestId('alert')).not.toBeInTheDocument();
+      });
+    });
+  });
+
+  // ── Form submission ────────────────────────────────────────────────────────
+  describe('form submission', () => {
+    it('calls updateSetting with proxy_settings on Save', async () => {
+      render(<ProxySettingsForm active={true} />);
+      fireEvent.submit(screen.getByText('Save').closest('form'));
+
+      await waitFor(() => {
+        expect(updateSetting).toHaveBeenCalledWith({
+          ...makeSettings().proxy_settings,
+          value: mockInitialValues,
+        });
+      });
+    });
+
+    it('shows success alert when updateSetting returns a truthy result', async () => {
+      render(<ProxySettingsForm active={true} />);
+      fireEvent.submit(screen.getByText('Save').closest('form'));
+
+      await waitFor(() => {
+        expect(screen.getByTestId('alert')).toBeInTheDocument();
+        expect(screen.getByTestId('alert-title')).toHaveTextContent(
+          'Saved Successfully'
+        );
+      });
+    });
+
+    it('does not show success alert when updateSetting returns undefined', async () => {
+      vi.mocked(updateSetting).mockResolvedValue(undefined);
+      render(<ProxySettingsForm active={true} />);
+      fireEvent.submit(screen.getByText('Save').closest('form'));
+
+      await waitFor(() => {
+        expect(updateSetting).toHaveBeenCalled();
+      });
+      expect(screen.queryByTestId('alert')).not.toBeInTheDocument();
+    });
+
+    it('does not show success alert when updateSetting returns null', async () => {
+      vi.mocked(updateSetting).mockResolvedValue(null);
+      render(<ProxySettingsForm active={true} />);
+      fireEvent.submit(screen.getByText('Save').closest('form'));
+
+      await waitFor(() => {
+        expect(updateSetting).toHaveBeenCalled();
+      });
+      expect(screen.queryByTestId('alert')).not.toBeInTheDocument();
+    });
+
+    it('does not show success alert when updateSetting throws', async () => {
+      vi.mocked(updateSetting).mockRejectedValue(new Error('save failed'));
+      render(<ProxySettingsForm active={true} />);
+      fireEvent.submit(screen.getByText('Save').closest('form'));
+
+      expect(screen.queryByTestId('alert')).not.toBeInTheDocument();
+    });
+
+    it('resets saved to false at the start of a new submission', async () => {
+      render(<ProxySettingsForm active={true} />);
+
+      // First save — succeeds
+      fireEvent.submit(screen.getByText('Save').closest('form'));
+      await waitFor(() => screen.getByTestId('alert'));
+
+      // Second save — returns undefined (no result)
+      vi.mocked(updateSetting).mockResolvedValue(undefined);
+      fireEvent.submit(screen.getByText('Save').closest('form'));
+
+      await waitFor(() => {
+        expect(screen.queryByTestId('alert')).not.toBeInTheDocument();
+      });
+    });
+  });
+
+  // ── Reset to Defaults ──────────────────────────────────────────────────────
+  describe('Reset to Defaults', () => {
+    it('calls getProxySettingDefaults when Reset to Defaults is clicked', () => {
+      render(<ProxySettingsForm active={true} />);
+      fireEvent.click(screen.getByText('Reset to Defaults'));
+      expect(getProxySettingDefaults).toHaveBeenCalled();
+    });
+
+    it('calls form.setValues with defaults when Reset to Defaults is clicked', () => {
+      render(<ProxySettingsForm active={true} />);
+      fireEvent.click(screen.getByText('Reset to Defaults'));
+      expect(formMock.setValues).toHaveBeenCalledWith(mockDefaults);
+    });
+
+    it('does not submit the form when Reset to Defaults is clicked', async () => {
+      render(<ProxySettingsForm active={true} />);
+      fireEvent.click(screen.getByText('Reset to Defaults'));
+      await waitFor(() => {
+        expect(updateSetting).not.toHaveBeenCalled();
+      });
+    });
+  });
+
+  // ── ProxySettingsOptions field routing ─────────────────────────────────────
+  describe('ProxySettingsOptions field routing', () => {
+    it('calls getInputProps for each PROXY_SETTINGS_OPTIONS key', () => {
+      render(<ProxySettingsForm active={true} />);
+      expect(formMock.getInputProps).toHaveBeenCalledWith('buffering_timeout');
+      expect(formMock.getInputProps).toHaveBeenCalledWith('buffering_speed');
+      expect(formMock.getInputProps).toHaveBeenCalledWith('redis_url');
+    });
+  });
+});

frontend/src/components/forms/settings/__tests__/StreamSettingsForm.test.jsx

@@ -0,0 +1,804 @@
+import { render, screen, fireEvent, waitFor } from '@testing-library/react';
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import StreamSettingsForm from '../StreamSettingsForm';
+
+// ── Store mocks ────────────────────────────────────────────────────────────────
+vi.mock('../../../../store/settings.jsx', () => ({ default: vi.fn() }));
+vi.mock('../../../../store/warnings.jsx', () => ({ default: vi.fn() }));
+vi.mock('../../../../store/userAgents.jsx', () => ({ default: vi.fn() }));
+vi.mock('../../../../store/streamProfiles.jsx', () => ({ default: vi.fn() }));
+
+// ── Constants mock ─────────────────────────────────────────────────────────────
+vi.mock('../../../../constants.js', () => ({
+  REGION_CHOICES: [
+    { label: 'US', value: 'us' },
+    { label: 'EU', value: 'eu' },
+  ],
+}));
+
+// ── Utility mocks ──────────────────────────────────────────────────────────────
+vi.mock('../../../../utils/pages/SettingsUtils.js', () => ({
+  getChangedSettings: vi.fn(),
+  parseSettings: vi.fn(),
+  rehashStreams: vi.fn(),
+  saveChangedSettings: vi.fn(),
+}));
+
+vi.mock('../../../../utils/forms/settings/StreamSettingsFormUtils.js', () => ({
+  getStreamSettingsFormInitialValues: vi.fn(),
+  getStreamSettingsFormValidation: vi.fn(),
+}));
+
+// ── Mantine form ───────────────────────────────────────────────────────────────
+vi.mock('@mantine/form', () => ({ useForm: vi.fn() }));
+
+// ── ConfirmationDialog mock ────────────────────────────────────────────────────
+vi.mock('../../../ConfirmationDialog.jsx', () => ({
+  default: ({
+    opened,
+    onClose,
+    onConfirm,
+    title,
+    message,
+    confirmLabel,
+    cancelLabel,
+    actionKey,
+    onSuppressChange,
+  }) =>
+    opened ? (
+      <div data-testid="confirmation-dialog">
+        <div data-testid="confirm-title">{title}</div>
+        <div data-testid="confirm-message">{message}</div>
+        <button data-testid="confirm-ok" onClick={onConfirm}>
+          {confirmLabel}
+        </button>
+        <button data-testid="confirm-cancel" onClick={onClose}>
+          {cancelLabel}
+        </button>
+        {actionKey && (
+          <button
+            data-testid="confirm-suppress"
+            onClick={() => onSuppressChange?.(actionKey)}
+          >
+            Don't show again
+          </button>
+        )}
+      </div>
+    ) : null,
+}));
+
+// ── Mantine core ───────────────────────────────────────────────────────────────
+vi.mock('@mantine/core', () => ({
+  Alert: ({ title, children }) => (
+    <div data-testid="alert">
+      <span data-testid="alert-title">{title}</span>
+      {children}
+    </div>
+  ),
+  Button: ({ children, onClick, disabled, loading, type, variant, color }) => (
+    <button
+      type={type || 'button'}
+      onClick={onClick}
+      disabled={disabled || loading}
+      data-variant={variant}
+      data-color={color}
+      data-loading={String(loading)}
+    >
+      {children}
+    </button>
+  ),
+  Flex: ({ children }) => <div>{children}</div>,
+  Group: ({ children }) => <div>{children}</div>,
+  MultiSelect: ({ label, id, data, ...rest }) => (
+    <div>
+      <label htmlFor={id}>{label}</label>
+      <select
+        data-testid={id}
+        id={id}
+        aria-label={label}
+        multiple
+        onChange={(e) => {
+          const selected = Array.from(e.target.selectedOptions).map(
+            (o) => o.value
+          );
+          rest.onChange?.(selected);
+        }}
+        value={rest.value ?? []}
+      >
+        {data?.map((opt) => (
+          <option key={opt.value} value={opt.value}>
+            {opt.label}
+          </option>
+        ))}
+      </select>
+    </div>
+  ),
+  Select: ({ label, id, data, ...rest }) => (
+    <div>
+      <label htmlFor={id}>{label}</label>
+      <select
+        data-testid={id}
+        id={id}
+        aria-label={label}
+        onChange={(e) => rest.onChange?.(e.target.value)}
+        value={rest.value ?? ''}
+      >
+        {data?.map((opt) => (
+          <option key={opt.value} value={opt.value}>
+            {opt.label}
+          </option>
+        ))}
+      </select>
+    </div>
+  ),
+  Switch: ({ id, ...rest }) => (
+    <input
+      data-testid={id}
+      id={id}
+      type="checkbox"
+      checked={rest.checked ?? false}
+      onChange={(e) => rest.onChange?.(e)}
+    />
+  ),
+  Text: ({ children, size, fw }) => (
+    <span data-size={size} data-fw={fw}>
+      {children}
+    </span>
+  ),
+}));
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Imports after mocks
+// ──────────────────────────────────────────────────────────────────────────────
+import useSettingsStore from '../../../../store/settings.jsx';
+import useWarningsStore from '../../../../store/warnings.jsx';
+import useUserAgentsStore from '../../../../store/userAgents.jsx';
+import useStreamProfilesStore from '../../../../store/streamProfiles.jsx';
+import { useForm } from '@mantine/form';
+import {
+  getChangedSettings,
+  parseSettings,
+  rehashStreams,
+  saveChangedSettings,
+} from '../../../../utils/pages/SettingsUtils.js';
+import {
+  getStreamSettingsFormInitialValues,
+  getStreamSettingsFormValidation,
+} from '../../../../utils/forms/settings/StreamSettingsFormUtils.js';
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Helpers
+// ──────────────────────────────────────────────────────────────────────────────
+const mockFormValues = {
+  default_user_agent: '1',
+  default_stream_profile: '2',
+  preferred_region: 'us',
+  auto_import_mapped_files: false,
+  m3u_hash_key: ['name'],
+};
+
+const makeFormMock = (overrides = {}) => ({
+  getInputProps: vi.fn((field, opts) => {
+    if (opts?.type === 'checkbox') {
+      return { checked: mockFormValues[field] ?? false, onChange: vi.fn() };
+    }
+    return { value: mockFormValues[field] ?? '', onChange: vi.fn() };
+  }),
+  setValues: vi.fn(),
+  getValues: vi.fn(() => mockFormValues),
+  onSubmit: vi.fn((handler) => (e) => {
+    e?.preventDefault?.();
+    return handler();
+  }),
+  submitting: false,
+  errors: {},
+  ...overrides,
+});
+
+const makeSettings = (overrides = {}) => ({
+  stream_settings: {
+    key: 'stream_settings',
+    value: { m3u_hash_key: 'name' },
+  },
+  ...overrides,
+});
+
+const makeUserAgents = () => [
+  { id: 1, name: 'Chrome' },
+  { id: 2, name: 'Firefox' },
+];
+
+const makeStreamProfiles = () => [
+  { id: 1, name: 'Default' },
+  { id: 2, name: 'HLS' },
+];
+
+const setupMocks = ({
+  settings = makeSettings(),
+  formOverrides = {},
+  warningSuppressed = false,
+  userAgents = makeUserAgents(),
+  streamProfiles = makeStreamProfiles(),
+} = {}) => {
+  const formMock = makeFormMock(formOverrides);
+
+  vi.mocked(useForm).mockReturnValue(formMock);
+  vi.mocked(getStreamSettingsFormInitialValues).mockReturnValue(mockFormValues);
+  vi.mocked(getStreamSettingsFormValidation).mockReturnValue({});
+  vi.mocked(parseSettings).mockReturnValue(mockFormValues);
+  vi.mocked(getChangedSettings).mockReturnValue({ preferred_region: 'eu' });
+  vi.mocked(saveChangedSettings).mockResolvedValue(undefined);
+  vi.mocked(rehashStreams).mockResolvedValue(undefined);
+
+  vi.mocked(useSettingsStore).mockImplementation((sel) => sel({ settings }));
+  vi.mocked(useWarningsStore).mockImplementation((sel) =>
+    sel({
+      suppressWarning: vi.fn(),
+      isWarningSuppressed: vi.fn(() => warningSuppressed),
+    })
+  );
+  vi.mocked(useUserAgentsStore).mockImplementation((sel) =>
+    sel({ userAgents })
+  );
+  vi.mocked(useStreamProfilesStore).mockImplementation((sel) =>
+    sel({ profiles: streamProfiles })
+  );
+
+  return { formMock };
+};
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Tests
+// ──────────────────────────────────────────────────────────────────────────────
+describe('StreamSettingsForm', () => {
+  let formMock;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    ({ formMock } = setupMocks());
+  });
+
+  // ── Rendering ──────────────────────────────────────────────────────────────
+  describe('rendering', () => {
+    it('renders without crashing', () => {
+      render(<StreamSettingsForm active={true} />);
+      expect(screen.getByText('Save')).toBeInTheDocument();
+    });
+
+    it('renders the Save button', () => {
+      render(<StreamSettingsForm active={true} />);
+      expect(screen.getByText('Save')).toBeInTheDocument();
+    });
+
+    it('renders the Rehash Streams button', () => {
+      render(<StreamSettingsForm active={true} />);
+      expect(screen.getByText('Rehash Streams')).toBeInTheDocument();
+    });
+
+    it('renders the Default User Agent select', () => {
+      render(<StreamSettingsForm active={true} />);
+      expect(screen.getByTestId('default_user_agent')).toBeInTheDocument();
+    });
+
+    it('renders the Default Stream Profile select', () => {
+      render(<StreamSettingsForm active={true} />);
+      expect(screen.getByTestId('default_stream_profile')).toBeInTheDocument();
+    });
+
+    it('renders the Preferred Region select', () => {
+      render(<StreamSettingsForm active={true} />);
+      expect(screen.getByTestId('preferred_region')).toBeInTheDocument();
+    });
+
+    it('renders the Auto-Import Mapped Files switch', () => {
+      render(<StreamSettingsForm active={true} />);
+      expect(
+        screen.getByTestId('auto_import_mapped_files')
+      ).toBeInTheDocument();
+    });
+
+    it('renders the M3U Hash Key multiselect', () => {
+      render(<StreamSettingsForm active={true} />);
+      expect(screen.getByTestId('m3u_hash_key')).toBeInTheDocument();
+    });
+
+    it('populates user agent options from store', () => {
+      render(<StreamSettingsForm active={true} />);
+      expect(screen.getByText('Chrome')).toBeInTheDocument();
+      expect(screen.getByText('Firefox')).toBeInTheDocument();
+    });
+
+    it('populates stream profile options from store', () => {
+      render(<StreamSettingsForm active={true} />);
+      expect(screen.getByText('Default')).toBeInTheDocument();
+      expect(screen.getByText('HLS')).toBeInTheDocument();
+    });
+
+    it('populates region options from REGION_CHOICES', () => {
+      render(<StreamSettingsForm active={true} />);
+      expect(screen.getByText('US')).toBeInTheDocument();
+      expect(screen.getByText('EU')).toBeInTheDocument();
+    });
+
+    it('does not show success alert on initial render', () => {
+      render(<StreamSettingsForm active={true} />);
+      expect(screen.queryByTestId('alert')).not.toBeInTheDocument();
+    });
+
+    it('does not show confirmation dialog on initial render', () => {
+      render(<StreamSettingsForm active={true} />);
+      expect(
+        screen.queryByTestId('confirmation-dialog')
+      ).not.toBeInTheDocument();
+    });
+  });
+
+  // ── Initialization ─────────────────────────────────────────────────────────
+  describe('initialization', () => {
+    it('calls getStreamSettingsFormInitialValues on mount', () => {
+      render(<StreamSettingsForm active={true} />);
+      expect(getStreamSettingsFormInitialValues).toHaveBeenCalled();
+    });
+
+    it('calls getStreamSettingsFormValidation on mount', () => {
+      render(<StreamSettingsForm active={true} />);
+      expect(getStreamSettingsFormValidation).toHaveBeenCalled();
+    });
+
+    it('calls parseSettings with settings from store on mount', async () => {
+      const settings = makeSettings();
+      setupMocks({ settings });
+      render(<StreamSettingsForm active={true} />);
+      await waitFor(() => {
+        expect(parseSettings).toHaveBeenCalledWith(settings);
+      });
+    });
+
+    it('calls form.setValues with parsed settings on mount', async () => {
+      render(<StreamSettingsForm active={true} />);
+      await waitFor(() => {
+        expect(formMock.setValues).toHaveBeenCalledWith(mockFormValues);
+      });
+    });
+
+    it('does not call parseSettings when settings is null', async () => {
+      vi.mocked(useSettingsStore).mockImplementation((sel) =>
+        sel({ settings: null })
+      );
+      render(<StreamSettingsForm active={true} />);
+      await waitFor(() => {
+        expect(parseSettings).not.toHaveBeenCalled();
+      });
+    });
+  });
+
+  // ── active prop ────────────────────────────────────────────────────────────
+  describe('active prop', () => {
+    it('clears saved state when active becomes false', async () => {
+      vi.mocked(saveChangedSettings).mockResolvedValue(undefined);
+      vi.mocked(getChangedSettings).mockReturnValue({});
+      const { rerender } = render(<StreamSettingsForm active={true} />);
+
+      fireEvent.submit(screen.getByText('Save').closest('form'));
+      await waitFor(() => {
+        expect(screen.getByTestId('alert')).toBeInTheDocument();
+      });
+
+      rerender(<StreamSettingsForm active={false} />);
+      await waitFor(() => {
+        expect(screen.queryByTestId('alert')).not.toBeInTheDocument();
+      });
+    });
+
+    it('clears rehashSuccess when active becomes false', async () => {
+      ({ formMock } = setupMocks({ warningSuppressed: true }));
+      const { rerender } = render(<StreamSettingsForm active={true} />);
+
+      fireEvent.click(screen.getByText('Rehash Streams'));
+      await waitFor(() => {
+        expect(screen.getByTestId('alert')).toBeInTheDocument();
+      });
+
+      rerender(<StreamSettingsForm active={false} />);
+      await waitFor(() => {
+        expect(screen.queryByTestId('alert')).not.toBeInTheDocument();
+      });
+    });
+  });
+
+  // ── Form submission — no hash key change ───────────────────────────────────
+  describe('form submission (no M3U hash key change)', () => {
+    beforeEach(() => {
+      // Same hash key before and after → no dialog
+      vi.mocked(getChangedSettings).mockReturnValue({ preferred_region: 'eu' });
+      setupMocks();
+      formMock = makeFormMock();
+      vi.mocked(useForm).mockReturnValue(formMock);
+    });
+
+    it('calls saveChangedSettings with settings and changed values on submit', async () => {
+      const settings = makeSettings();
+      render(<StreamSettingsForm active={true} />);
+
+      fireEvent.submit(screen.getByText('Save').closest('form'));
+      await waitFor(() => {
+        expect(saveChangedSettings).toHaveBeenCalledWith(
+          settings,
+          expect.any(Object)
+        );
+      });
+    });
+
+    it('shows success alert after successful save', async () => {
+      render(<StreamSettingsForm active={true} />);
+
+      fireEvent.submit(screen.getByText('Save').closest('form'));
+      await waitFor(() => {
+        expect(screen.getByTestId('alert')).toBeInTheDocument();
+        expect(screen.getByTestId('alert-title')).toHaveTextContent(
+          'Saved Successfully'
+        );
+      });
+    });
+
+    it('does not show success alert when saveChangedSettings throws', async () => {
+      vi.mocked(saveChangedSettings).mockRejectedValue(
+        new Error('save failed')
+      );
+      const consoleSpy = vi
+        .spyOn(console, 'error')
+        .mockImplementation(() => {});
+      render(<StreamSettingsForm active={true} />);
+
+      fireEvent.submit(screen.getByText('Save').closest('form'));
+      await waitFor(() => {
+        expect(consoleSpy).toHaveBeenCalled();
+      });
+      expect(screen.queryByTestId('alert')).not.toBeInTheDocument();
+      consoleSpy.mockRestore();
+    });
+
+    it('logs error when saveChangedSettings throws', async () => {
+      const error = new Error('save failed');
+      vi.mocked(saveChangedSettings).mockRejectedValue(error);
+      const consoleSpy = vi
+        .spyOn(console, 'error')
+        .mockImplementation(() => {});
+      render(<StreamSettingsForm active={true} />);
+
+      fireEvent.submit(screen.getByText('Save').closest('form'));
+      await waitFor(() => {
+        expect(consoleSpy).toHaveBeenCalledWith(
+          'Error saving settings:',
+          error
+        );
+      });
+      consoleSpy.mockRestore();
+    });
+
+    it('does not open confirmation dialog when hash key is unchanged', async () => {
+      render(<StreamSettingsForm active={true} />);
+
+      fireEvent.submit(screen.getByText('Save').closest('form'));
+      await waitFor(() => {
+        expect(saveChangedSettings).toHaveBeenCalled();
+      });
+      expect(
+        screen.queryByTestId('confirmation-dialog')
+      ).not.toBeInTheDocument();
+    });
+  });
+
+  // ── Form submission — hash key changed ────────────────────────────────────
+  describe('form submission (M3U hash key changed)', () => {
+    const makeHashChangedFormMock = () =>
+      makeFormMock({
+        getValues: vi.fn(() => ({
+          ...mockFormValues,
+          m3u_hash_key: ['url'], // different from stored 'name'
+        })),
+      });
+
+    it('opens confirmation dialog with save title when hash key changes', async () => {
+      const fm = makeHashChangedFormMock();
+      vi.mocked(useForm).mockReturnValue(fm);
+      render(<StreamSettingsForm active={true} />);
+
+      fireEvent.submit(screen.getByText('Save').closest('form'));
+      await waitFor(() => {
+        expect(screen.getByTestId('confirmation-dialog')).toBeInTheDocument();
+        expect(screen.getByTestId('confirm-title')).toHaveTextContent(
+          'Save Settings and Rehash Streams'
+        );
+      });
+    });
+
+    it('shows "Save and Rehash" confirm label for hash key change dialog', async () => {
+      const fm = makeHashChangedFormMock();
+      vi.mocked(useForm).mockReturnValue(fm);
+      render(<StreamSettingsForm active={true} />);
+
+      fireEvent.submit(screen.getByText('Save').closest('form'));
+      await waitFor(() => {
+        expect(screen.getByTestId('confirm-ok')).toHaveTextContent(
+          'Save and Rehash'
+        );
+      });
+    });
+
+    it('does not call saveChangedSettings before dialog is confirmed', async () => {
+      const fm = makeHashChangedFormMock();
+      vi.mocked(useForm).mockReturnValue(fm);
+      render(<StreamSettingsForm active={true} />);
+
+      fireEvent.submit(screen.getByText('Save').closest('form'));
+      await waitFor(() => {
+        expect(screen.getByTestId('confirmation-dialog')).toBeInTheDocument();
+      });
+      expect(saveChangedSettings).not.toHaveBeenCalled();
+    });
+
+    it('calls saveChangedSettings after confirming save-and-rehash dialog', async () => {
+      const fm = makeHashChangedFormMock();
+      vi.mocked(useForm).mockReturnValue(fm);
+      const settings = makeSettings();
+      setupMocks({ settings });
+      vi.mocked(useForm).mockReturnValue(fm);
+      render(<StreamSettingsForm active={true} />);
+
+      fireEvent.submit(screen.getByText('Save').closest('form'));
+      await waitFor(() => screen.getByTestId('confirmation-dialog'));
+      fireEvent.click(screen.getByTestId('confirm-ok'));
+
+      await waitFor(() => {
+        expect(saveChangedSettings).toHaveBeenCalled();
+      });
+    });
+
+    it('shows success alert after confirming save-and-rehash dialog', async () => {
+      const fm = makeHashChangedFormMock();
+      vi.mocked(useForm).mockReturnValue(fm);
+      render(<StreamSettingsForm active={true} />);
+
+      fireEvent.submit(screen.getByText('Save').closest('form'));
+      await waitFor(() => screen.getByTestId('confirmation-dialog'));
+      fireEvent.click(screen.getByTestId('confirm-ok'));
+
+      await waitFor(() => {
+        expect(screen.getByTestId('alert-title')).toHaveTextContent(
+          'Saved Successfully'
+        );
+      });
+    });
+
+    it('closes dialog after confirming save-and-rehash', async () => {
+      const fm = makeHashChangedFormMock();
+      vi.mocked(useForm).mockReturnValue(fm);
+      render(<StreamSettingsForm active={true} />);
+
+      fireEvent.submit(screen.getByText('Save').closest('form'));
+      await waitFor(() => screen.getByTestId('confirmation-dialog'));
+      fireEvent.click(screen.getByTestId('confirm-ok'));
+
+      await waitFor(() => {
+        expect(
+          screen.queryByTestId('confirmation-dialog')
+        ).not.toBeInTheDocument();
+      });
+    });
+
+    it('closes dialog and does not save when Cancel is clicked', async () => {
+      const fm = makeHashChangedFormMock();
+      vi.mocked(useForm).mockReturnValue(fm);
+      render(<StreamSettingsForm active={true} />);
+
+      fireEvent.submit(screen.getByText('Save').closest('form'));
+      await waitFor(() => screen.getByTestId('confirmation-dialog'));
+      fireEvent.click(screen.getByTestId('confirm-cancel'));
+
+      await waitFor(() => {
+        expect(
+          screen.queryByTestId('confirmation-dialog')
+        ).not.toBeInTheDocument();
+      });
+      expect(saveChangedSettings).not.toHaveBeenCalled();
+    });
+
+    it('skips dialog entirely when rehash-streams warning is suppressed', async () => {
+      const fm = makeHashChangedFormMock();
+      vi.mocked(useForm).mockReturnValue(fm);
+      setupMocks({ warningSuppressed: true });
+      vi.mocked(useForm).mockReturnValue(fm);
+      render(<StreamSettingsForm active={true} />);
+
+      fireEvent.submit(screen.getByText('Save').closest('form'));
+      await waitFor(() => {
+        expect(saveChangedSettings).toHaveBeenCalled();
+      });
+      expect(
+        screen.queryByTestId('confirmation-dialog')
+      ).not.toBeInTheDocument();
+    });
+  });
+
+  // ── Rehash Streams ─────────────────────────────────────────────────────────
+  describe('Rehash Streams button', () => {
+    it('opens confirmation dialog with rehash title when warning is not suppressed', async () => {
+      render(<StreamSettingsForm active={true} />);
+      fireEvent.click(screen.getByText('Rehash Streams'));
+
+      await waitFor(() => {
+        expect(screen.getByTestId('confirmation-dialog')).toBeInTheDocument();
+        expect(screen.getByTestId('confirm-title')).toHaveTextContent(
+          'Confirm Stream Rehash'
+        );
+      });
+    });
+
+    it('shows "Start Rehash" confirm label for rehash-only dialog', async () => {
+      render(<StreamSettingsForm active={true} />);
+      fireEvent.click(screen.getByText('Rehash Streams'));
+
+      await waitFor(() => {
+        expect(screen.getByTestId('confirm-ok')).toHaveTextContent(
+          'Start Rehash'
+        );
+      });
+    });
+
+    it('calls rehashStreams after confirming rehash dialog', async () => {
+      render(<StreamSettingsForm active={true} />);
+      fireEvent.click(screen.getByText('Rehash Streams'));
+      await waitFor(() => screen.getByTestId('confirmation-dialog'));
+      fireEvent.click(screen.getByTestId('confirm-ok'));
+
+      await waitFor(() => {
+        expect(rehashStreams).toHaveBeenCalled();
+      });
+    });
+
+    it('skips confirmation dialog and calls rehashStreams directly when suppressed', async () => {
+      setupMocks({ warningSuppressed: true });
+      render(<StreamSettingsForm active={true} />);
+      fireEvent.click(screen.getByText('Rehash Streams'));
+
+      await waitFor(() => {
+        expect(rehashStreams).toHaveBeenCalled();
+      });
+      expect(
+        screen.queryByTestId('confirmation-dialog')
+      ).not.toBeInTheDocument();
+    });
+
+    it('shows rehash success alert after rehash completes', async () => {
+      setupMocks({ warningSuppressed: true });
+      render(<StreamSettingsForm active={true} />);
+      fireEvent.click(screen.getByText('Rehash Streams'));
+
+      await waitFor(() => {
+        expect(screen.getByTestId('alert-title')).toHaveTextContent(
+          'Rehash task queued successfully'
+        );
+      });
+    });
+
+    it('does not show rehash success alert when rehashStreams throws', async () => {
+      setupMocks({ warningSuppressed: true });
+      vi.mocked(rehashStreams).mockRejectedValue(new Error('fail'));
+      const consoleSpy = vi
+        .spyOn(console, 'error')
+        .mockImplementation(() => {});
+      render(<StreamSettingsForm active={true} />);
+      fireEvent.click(screen.getByText('Rehash Streams'));
+
+      await waitFor(() => {
+        expect(consoleSpy).toHaveBeenCalled();
+      });
+      expect(screen.queryByTestId('alert')).not.toBeInTheDocument();
+      consoleSpy.mockRestore();
+    });
+
+    it('logs error when rehashStreams throws', async () => {
+      setupMocks({ warningSuppressed: true });
+      const error = new Error('network error');
+      vi.mocked(rehashStreams).mockRejectedValue(error);
+      const consoleSpy = vi
+        .spyOn(console, 'error')
+        .mockImplementation(() => {});
+      render(<StreamSettingsForm active={true} />);
+      fireEvent.click(screen.getByText('Rehash Streams'));
+
+      await waitFor(() => {
+        expect(consoleSpy).toHaveBeenCalledWith(
+          'Error rehashing streams:',
+          error
+        );
+      });
+      consoleSpy.mockRestore();
+    });
+
+    it('closes confirmation dialog when Cancel is clicked on rehash dialog', async () => {
+      render(<StreamSettingsForm active={true} />);
+      fireEvent.click(screen.getByText('Rehash Streams'));
+      await waitFor(() => screen.getByTestId('confirmation-dialog'));
+      fireEvent.click(screen.getByTestId('confirm-cancel'));
+
+      await waitFor(() => {
+        expect(
+          screen.queryByTestId('confirmation-dialog')
+        ).not.toBeInTheDocument();
+      });
+      expect(rehashStreams).not.toHaveBeenCalled();
+    });
+
+    it('calls suppressWarning when "Don\'t show again" is clicked', async () => {
+      const suppressWarning = vi.fn();
+      vi.mocked(useWarningsStore).mockImplementation((sel) =>
+        sel({
+          suppressWarning,
+          isWarningSuppressed: vi.fn(() => false),
+        })
+      );
+      render(<StreamSettingsForm active={true} />);
+      fireEvent.click(screen.getByText('Rehash Streams'));
+      await waitFor(() => screen.getByTestId('confirmation-dialog'));
+      fireEvent.click(screen.getByTestId('confirm-suppress'));
+
+      expect(suppressWarning).toHaveBeenCalledWith('rehash-streams');
+    });
+
+    it('Rehash Streams button is disabled while rehashing', async () => {
+      let resolveRehash;
+      vi.mocked(rehashStreams).mockReturnValue(
+        new Promise((res) => {
+          resolveRehash = res;
+        })
+      );
+      setupMocks({ warningSuppressed: true });
+      render(<StreamSettingsForm active={true} />);
+      fireEvent.click(screen.getByText('Rehash Streams'));
+
+      await waitFor(() => {
+        expect(screen.getByText('Rehash Streams')).toBeDisabled();
+      });
+
+      resolveRehash();
+      await waitFor(() => {
+        expect(screen.getByText('Rehash Streams')).not.toBeDisabled();
+      });
+    });
+  });
+
+  // ── getInputProps wiring ───────────────────────────────────────────────────
+  describe('getInputProps wiring', () => {
+    it('calls getInputProps for default_user_agent', () => {
+      render(<StreamSettingsForm active={true} />);
+      expect(formMock.getInputProps).toHaveBeenCalledWith('default_user_agent');
+    });
+
+    it('calls getInputProps for default_stream_profile', () => {
+      render(<StreamSettingsForm active={true} />);
+      expect(formMock.getInputProps).toHaveBeenCalledWith(
+        'default_stream_profile'
+      );
+    });
+
+    it('calls getInputProps for preferred_region', () => {
+      render(<StreamSettingsForm active={true} />);
+      expect(formMock.getInputProps).toHaveBeenCalledWith('preferred_region');
+    });
+
+    it('calls getInputProps for auto_import_mapped_files with checkbox type', () => {
+      render(<StreamSettingsForm active={true} />);
+      expect(formMock.getInputProps).toHaveBeenCalledWith(
+        'auto_import_mapped_files',
+        { type: 'checkbox' }
+      );
+    });
+
+    it('calls getInputProps for m3u_hash_key', () => {
+      render(<StreamSettingsForm active={true} />);
+      expect(formMock.getInputProps).toHaveBeenCalledWith('m3u_hash_key');
+    });
+  });
+});

frontend/src/components/forms/settings/__tests__/SystemSettingsForm.test.jsx

@@ -0,0 +1,342 @@
+import { render, screen, fireEvent, waitFor } from '@testing-library/react';
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import SystemSettingsForm from '../SystemSettingsForm';
+
+// ── Store mocks ────────────────────────────────────────────────────────────────
+vi.mock('../../../../store/settings.jsx', () => ({ default: vi.fn() }));
+
+// ── Utility mocks ──────────────────────────────────────────────────────────────
+vi.mock('../../../../utils/pages/SettingsUtils.js', () => ({
+  getChangedSettings: vi.fn(),
+  parseSettings: vi.fn(),
+  saveChangedSettings: vi.fn(),
+}));
+
+vi.mock('../../../../utils/forms/settings/SystemSettingsFormUtils.js', () => ({
+  getSystemSettingsFormInitialValues: vi.fn(),
+}));
+
+// ── Mantine form ───────────────────────────────────────────────────────────────
+vi.mock('@mantine/form', () => ({
+  useForm: vi.fn(),
+}));
+
+// ── Mantine core ───────────────────────────────────────────────────────────────
+vi.mock('@mantine/core', () => ({
+  Alert: ({ title }) => <div data-testid="alert">{title}</div>,
+  Button: ({ children, onClick, disabled }) => (
+    <button onClick={onClick} disabled={disabled}>
+      {children}
+    </button>
+  ),
+  Flex: ({ children }) => <div>{children}</div>,
+  NumberInput: ({ label, value, onChange, min, max, step, description }) => (
+    <div>
+      <label>{label}</label>
+      <p>{description}</p>
+      <input
+        data-testid="number-input"
+        type="number"
+        value={value}
+        min={min}
+        max={max}
+        step={step}
+        onChange={(e) => onChange(Number(e.target.value))}
+      />
+    </div>
+  ),
+  Stack: ({ children }) => <div>{children}</div>,
+  Text: ({ children }) => <span>{children}</span>,
+}));
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Imports after mocks
+// ──────────────────────────────────────────────────────────────────────────────
+import useSettingsStore from '../../../../store/settings.jsx';
+import {
+  getChangedSettings,
+  parseSettings,
+  saveChangedSettings,
+} from '../../../../utils/pages/SettingsUtils.js';
+import { getSystemSettingsFormInitialValues } from '../../../../utils/forms/settings/SystemSettingsFormUtils.js';
+import { useForm } from '@mantine/form';
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Helpers
+// ──────────────────────────────────────────────────────────────────────────────
+const makeSettings = (overrides = {}) => ({
+  max_system_events: 100,
+  ...overrides,
+});
+
+const setupMocks = ({ settings = makeSettings() } = {}) => {
+  const formValues = { max_system_events: settings?.max_system_events ?? 100 };
+
+  const formMock = {
+    values: formValues,
+    getValues: vi.fn().mockReturnValue(formValues),
+    setValues: vi.fn(),
+    setFieldValue: vi.fn((key, value) => {
+      formMock.values[key] = value;
+    }),
+    onSubmit: vi.fn((handler) => handler),
+    submitting: false,
+  };
+
+  vi.mocked(useForm).mockReturnValue(formMock);
+  vi.mocked(getSystemSettingsFormInitialValues).mockReturnValue(formValues);
+  vi.mocked(useSettingsStore).mockImplementation((sel) => sel({ settings }));
+  vi.mocked(parseSettings).mockReturnValue(formValues);
+  vi.mocked(getChangedSettings).mockReturnValue({
+    max_system_events: settings?.max_system_events ?? 100,
+  });
+  vi.mocked(saveChangedSettings).mockResolvedValue(undefined);
+
+  return { formMock };
+};
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Tests
+// ──────────────────────────────────────────────────────────────────────────────
+describe('SystemSettingsForm', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  // ── Rendering ──────────────────────────────────────────────────────────────
+
+  describe('rendering', () => {
+    it('renders the Save button', () => {
+      setupMocks();
+      render(<SystemSettingsForm active={true} />);
+      expect(screen.getByText('Save')).toBeInTheDocument();
+    });
+
+    it('renders the NumberInput for max_system_events', () => {
+      setupMocks();
+      render(<SystemSettingsForm active={true} />);
+      expect(screen.getByTestId('number-input')).toBeInTheDocument();
+    });
+
+    it('renders the NumberInput label', () => {
+      setupMocks();
+      render(<SystemSettingsForm active={true} />);
+      expect(screen.getByText('Maximum System Events')).toBeInTheDocument();
+    });
+
+    it('renders the NumberInput description', () => {
+      setupMocks();
+      render(<SystemSettingsForm active={true} />);
+      expect(
+        screen.getByText(
+          'Number of events to retain (minimum: 10, maximum: 1000)'
+        )
+      ).toBeInTheDocument();
+    });
+
+    it('renders descriptive text about system events', () => {
+      setupMocks();
+      render(<SystemSettingsForm active={true} />);
+      expect(
+        screen.getByText(/Configure how many system events/)
+      ).toBeInTheDocument();
+    });
+
+    it('does not show success alert on initial render', () => {
+      setupMocks();
+      render(<SystemSettingsForm active={true} />);
+      expect(screen.queryByTestId('alert')).not.toBeInTheDocument();
+    });
+
+    it('renders NumberInput with value from form values', () => {
+      setupMocks({ settings: makeSettings({ max_system_events: 250 }) });
+      render(<SystemSettingsForm active={true} />);
+      expect(screen.getByTestId('number-input')).toHaveValue(250);
+    });
+
+    it('falls back to 100 when max_system_events is 0/falsy', () => {
+      const formValues = { max_system_events: 0 };
+      const formMock = {
+        values: formValues,
+        getValues: vi.fn().mockReturnValue(formValues),
+        setValues: vi.fn(),
+        setFieldValue: vi.fn(),
+        onSubmit: vi.fn((handler) => handler),
+        submitting: false,
+      };
+      vi.mocked(useForm).mockReturnValue(formMock);
+      vi.mocked(getSystemSettingsFormInitialValues).mockReturnValue(formValues);
+      vi.mocked(useSettingsStore).mockImplementation((sel) =>
+        sel({ settings: makeSettings({ max_system_events: 0 }) })
+      );
+      vi.mocked(parseSettings).mockReturnValue(formValues);
+      vi.mocked(getChangedSettings).mockReturnValue({});
+      vi.mocked(saveChangedSettings).mockResolvedValue(undefined);
+
+      render(<SystemSettingsForm active={true} />);
+      expect(screen.getByTestId('number-input')).toHaveValue(100);
+    });
+  });
+
+  // ── Settings initialization ────────────────────────────────────────────────
+
+  describe('settings initialization', () => {
+    it('calls parseSettings with settings on mount', () => {
+      const settings = makeSettings();
+      setupMocks({ settings });
+      render(<SystemSettingsForm active={true} />);
+      expect(parseSettings).toHaveBeenCalledWith(settings);
+    });
+
+    it('calls form.setValues with parsed settings on mount', () => {
+      const settings = makeSettings();
+      const { formMock } = setupMocks({ settings });
+      render(<SystemSettingsForm active={true} />);
+      expect(formMock.setValues).toHaveBeenCalledWith({
+        max_system_events: 100,
+      });
+    });
+
+    it('does not call parseSettings when settings is null', () => {
+      const formMock = {
+        values: { max_system_events: 100 },
+        getValues: vi.fn().mockReturnValue({ max_system_events: 100 }),
+        setValues: vi.fn(),
+        setFieldValue: vi.fn(),
+        onSubmit: vi.fn((handler) => handler),
+        submitting: false,
+      };
+      vi.mocked(useForm).mockReturnValue(formMock);
+      vi.mocked(getSystemSettingsFormInitialValues).mockReturnValue({
+        max_system_events: 100,
+      });
+      vi.mocked(useSettingsStore).mockImplementation((sel) =>
+        sel({ settings: null })
+      );
+      vi.mocked(parseSettings).mockReturnValue({});
+      vi.mocked(saveChangedSettings).mockResolvedValue(undefined);
+
+      render(<SystemSettingsForm active={true} />);
+      expect(parseSettings).not.toHaveBeenCalled();
+    });
+  });
+
+  // ── NumberInput interaction ────────────────────────────────────────────────
+
+  describe('NumberInput interaction', () => {
+    it('calls form.setFieldValue when NumberInput changes', () => {
+      const { formMock } = setupMocks();
+      render(<SystemSettingsForm active={true} />);
+      fireEvent.change(screen.getByTestId('number-input'), {
+        target: { value: '200' },
+      });
+      expect(formMock.setFieldValue).toHaveBeenCalledWith(
+        'max_system_events',
+        200
+      );
+    });
+  });
+
+  // ── Save / submit ──────────────────────────────────────────────────────────
+
+  describe('save button', () => {
+    it('calls getChangedSettings and saveChangedSettings on submit', async () => {
+      const settings = makeSettings();
+      const { formMock } = setupMocks({ settings });
+      render(<SystemSettingsForm active={true} />);
+
+      fireEvent.click(screen.getByText('Save'));
+
+      await waitFor(() => {
+        expect(getChangedSettings).toHaveBeenCalledWith(
+          formMock.getValues(),
+          settings
+        );
+        expect(saveChangedSettings).toHaveBeenCalled();
+      });
+    });
+
+    it('shows success alert after successful save', async () => {
+      setupMocks();
+      render(<SystemSettingsForm active={true} />);
+
+      fireEvent.click(screen.getByText('Save'));
+
+      await waitFor(() => {
+        expect(screen.getByTestId('alert')).toBeInTheDocument();
+      });
+      expect(screen.getByText('Saved Successfully')).toBeInTheDocument();
+    });
+
+    it('does not show success alert when saveChangedSettings throws', async () => {
+      const consoleSpy = vi
+        .spyOn(console, 'error')
+        .mockImplementation(() => {});
+      setupMocks();
+      vi.mocked(saveChangedSettings).mockRejectedValue(
+        new Error('save failed')
+      );
+
+      render(<SystemSettingsForm active={true} />);
+      fireEvent.click(screen.getByText('Save'));
+
+      await waitFor(() => {
+        expect(consoleSpy).toHaveBeenCalled();
+      });
+      expect(screen.queryByTestId('alert')).not.toBeInTheDocument();
+      consoleSpy.mockRestore();
+    });
+
+    it('logs error when saveChangedSettings throws', async () => {
+      const error = new Error('save failed');
+      const consoleSpy = vi
+        .spyOn(console, 'error')
+        .mockImplementation(() => {});
+      setupMocks();
+      vi.mocked(saveChangedSettings).mockRejectedValue(error);
+
+      render(<SystemSettingsForm active={true} />);
+      fireEvent.click(screen.getByText('Save'));
+
+      await waitFor(() => {
+        expect(consoleSpy).toHaveBeenCalledWith(
+          'Error saving settings:',
+          error
+        );
+      });
+      consoleSpy.mockRestore();
+    });
+  });
+
+  // ── active prop / saved state reset ───────────────────────────────────────
+
+  describe('active prop behavior', () => {
+    it('clears saved alert when active becomes false', async () => {
+      setupMocks();
+      const { rerender } = render(<SystemSettingsForm active={true} />);
+
+      fireEvent.click(screen.getByText('Save'));
+      await waitFor(() => {
+        expect(screen.getByTestId('alert')).toBeInTheDocument();
+      });
+
+      rerender(<SystemSettingsForm active={false} />);
+      await waitFor(() => {
+        expect(screen.queryByTestId('alert')).not.toBeInTheDocument();
+      });
+    });
+
+    it('does not clear saved alert while active remains true', async () => {
+      setupMocks();
+      const { rerender } = render(<SystemSettingsForm active={true} />);
+
+      fireEvent.click(screen.getByText('Save'));
+      await waitFor(() => {
+        expect(screen.getByTestId('alert')).toBeInTheDocument();
+      });
+
+      rerender(<SystemSettingsForm active={true} />);
+      expect(screen.getByTestId('alert')).toBeInTheDocument();
+    });
+  });
+});

frontend/src/components/forms/settings/__tests__/UiSettingsForm.test.jsx

@@ -0,0 +1,458 @@
+import { render, screen, fireEvent, waitFor } from '@testing-library/react';
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import UiSettingsForm from '../UiSettingsForm';
+
+// ── Store mocks ────────────────────────────────────────────────────────────────
+vi.mock('../../../../store/settings.jsx', () => ({ default: vi.fn() }));
+
+// ── Hook mocks ─────────────────────────────────────────────────────────────────
+vi.mock('../../../../hooks/useLocalStorage.jsx', () => ({ default: vi.fn() }));
+vi.mock('../../../../hooks/useTablePreferences.jsx', () => ({
+  default: vi.fn(),
+}));
+
+// ── Utility mocks ──────────────────────────────────────────────────────────────
+vi.mock('../../../../utils/dateTimeUtils.js', () => ({
+  buildTimeZoneOptions: vi.fn(),
+  getDefaultTimeZone: vi.fn(),
+}));
+
+vi.mock('../../../../utils/notificationUtils.js', () => ({
+  showNotification: vi.fn(),
+}));
+
+vi.mock('../../../../utils/forms/settings/UiSettingsFormUtils.js', () => ({
+  saveTimeZoneSetting: vi.fn(),
+}));
+
+// ── Mantine core ───────────────────────────────────────────────────────────────
+vi.mock('@mantine/core', () => ({
+  Select: ({ label, value, onChange, data }) => (
+    <div>
+      <label>{label}</label>
+      <select
+        data-testid={`select-${label?.toLowerCase().replace(/\s+/g, '-')}`}
+        value={value ?? ''}
+        onChange={(e) => onChange(e.target.value)}
+      >
+        {data?.map((opt) => (
+          <option key={opt.value} value={opt.value}>
+            {opt.label}
+          </option>
+        ))}
+      </select>
+    </div>
+  ),
+  Switch: ({ label, description, checked, onChange }) => (
+    <div>
+      <label>{label}</label>
+      {description && <p>{description}</p>}
+      <input
+        data-testid="switch-header-pinned"
+        type="checkbox"
+        checked={checked}
+        onChange={onChange}
+      />
+    </div>
+  ),
+  Stack: ({ children }) => <div>{children}</div>,
+}));
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Imports after mocks
+// ──────────────────────────────────────────────────────────────────────────────
+import useSettingsStore from '../../../../store/settings.jsx';
+import useLocalStorage from '../../../../hooks/useLocalStorage.jsx';
+import useTablePreferences from '../../../../hooks/useTablePreferences.jsx';
+import {
+  buildTimeZoneOptions,
+  getDefaultTimeZone,
+} from '../../../../utils/dateTimeUtils.js';
+import { showNotification } from '../../../../utils/notificationUtils.js';
+import { saveTimeZoneSetting } from '../../../../utils/forms/settings/UiSettingsFormUtils.js';
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Helpers
+// ──────────────────────────────────────────────────────────────────────────────
+const makeSettings = ({ timeZone = null } = {}) => ({
+  system_settings: timeZone
+    ? { value: { time_zone: timeZone } }
+    : { value: {} },
+});
+
+const DEFAULT_TZ = 'America/New_York';
+const TZ_OPTIONS = [
+  { value: 'America/New_York', label: 'America/New_York' },
+  { value: 'America/Chicago', label: 'America/Chicago' },
+  { value: 'UTC', label: 'UTC' },
+];
+
+const setupMocks = ({
+  settings = makeSettings(),
+  timeFormat = '12h',
+  dateFormat = 'mdy',
+  timeZone = DEFAULT_TZ,
+  headerPinned = false,
+  tableSize = 'default',
+} = {}) => {
+  const setTimeFormat = vi.fn();
+  const setDateFormat = vi.fn();
+  const setTimeZone = vi.fn();
+  const setHeaderPinned = vi.fn();
+  const setTableSize = vi.fn();
+
+  vi.mocked(getDefaultTimeZone).mockReturnValue(DEFAULT_TZ);
+  vi.mocked(buildTimeZoneOptions).mockReturnValue(TZ_OPTIONS);
+  vi.mocked(saveTimeZoneSetting).mockResolvedValue(undefined);
+
+  vi.mocked(useSettingsStore).mockImplementation((sel) => sel({ settings }));
+
+  vi.mocked(useLocalStorage).mockImplementation((key, defaultVal) => {
+    if (key === 'time-format') return [timeFormat, setTimeFormat];
+    if (key === 'date-format') return [dateFormat, setDateFormat];
+    if (key === 'time-zone') return [timeZone, setTimeZone];
+    return [defaultVal, vi.fn()];
+  });
+
+  vi.mocked(useTablePreferences).mockReturnValue({
+    headerPinned,
+    setHeaderPinned,
+    tableSize,
+    setTableSize,
+  });
+
+  return {
+    setTimeFormat,
+    setDateFormat,
+    setTimeZone,
+    setHeaderPinned,
+    setTableSize,
+  };
+};
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Tests
+// ──────────────────────────────────────────────────────────────────────────────
+describe('UiSettingsForm', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  // ── Rendering ──────────────────────────────────────────────────────────────
+
+  describe('rendering', () => {
+    it('renders the Table Size select', () => {
+      setupMocks();
+      render(<UiSettingsForm />);
+      expect(screen.getByTestId('select-table-size')).toBeInTheDocument();
+    });
+
+    it('renders the Time format select', () => {
+      setupMocks();
+      render(<UiSettingsForm />);
+      expect(screen.getByTestId('select-time-format')).toBeInTheDocument();
+    });
+
+    it('renders the Date format select', () => {
+      setupMocks();
+      render(<UiSettingsForm />);
+      expect(screen.getByTestId('select-date-format')).toBeInTheDocument();
+    });
+
+    it('renders the Time zone select', () => {
+      setupMocks();
+      render(<UiSettingsForm />);
+      expect(screen.getByTestId('select-time-zone')).toBeInTheDocument();
+    });
+
+    it('renders the Pin Table Headers switch', () => {
+      setupMocks();
+      render(<UiSettingsForm />);
+      expect(screen.getByTestId('switch-header-pinned')).toBeInTheDocument();
+    });
+
+    it('renders the switch description', () => {
+      setupMocks();
+      render(<UiSettingsForm />);
+      expect(
+        screen.getByText('Keep table headers visible when scrolling')
+      ).toBeInTheDocument();
+    });
+
+    it('renders Table Size select with initial value', () => {
+      setupMocks({ tableSize: 'compact' });
+      render(<UiSettingsForm />);
+      expect(screen.getByTestId('select-table-size')).toHaveValue('compact');
+    });
+
+    it('renders Time format select with initial value', () => {
+      setupMocks({ timeFormat: '24h' });
+      render(<UiSettingsForm />);
+      expect(screen.getByTestId('select-time-format')).toHaveValue('24h');
+    });
+
+    it('renders Date format select with initial value', () => {
+      setupMocks({ dateFormat: 'dmy' });
+      render(<UiSettingsForm />);
+      expect(screen.getByTestId('select-date-format')).toHaveValue('dmy');
+    });
+
+    it('renders Time zone select with initial value', () => {
+      setupMocks({ timeZone: 'UTC' });
+      render(<UiSettingsForm />);
+      expect(screen.getByTestId('select-time-zone')).toHaveValue('UTC');
+    });
+
+    it('renders switch unchecked when headerPinned is false', () => {
+      setupMocks({ headerPinned: false });
+      render(<UiSettingsForm />);
+      expect(screen.getByTestId('switch-header-pinned')).not.toBeChecked();
+    });
+
+    it('renders switch checked when headerPinned is true', () => {
+      setupMocks({ headerPinned: true });
+      render(<UiSettingsForm />);
+      expect(screen.getByTestId('switch-header-pinned')).toBeChecked();
+    });
+  });
+
+  // ── onChange handlers ──────────────────────────────────────────────────────
+
+  describe('onChange handlers', () => {
+    it('calls setTableSize when Table Size select changes', () => {
+      const { setTableSize } = setupMocks();
+      render(<UiSettingsForm />);
+      fireEvent.change(screen.getByTestId('select-table-size'), {
+        target: { value: 'large' },
+      });
+      expect(setTableSize).toHaveBeenCalledWith('large');
+    });
+
+    it('does not call setTableSize when value is empty', () => {
+      const { setTableSize } = setupMocks();
+      render(<UiSettingsForm />);
+      fireEvent.change(screen.getByTestId('select-table-size'), {
+        target: { value: '' },
+      });
+      expect(setTableSize).not.toHaveBeenCalled();
+    });
+
+    it('calls setTimeFormat when Time format select changes', () => {
+      const { setTimeFormat } = setupMocks();
+      render(<UiSettingsForm />);
+      fireEvent.change(screen.getByTestId('select-time-format'), {
+        target: { value: '24h' },
+      });
+      expect(setTimeFormat).toHaveBeenCalledWith('24h');
+    });
+
+    it('does not call setTimeFormat when value is empty', () => {
+      const { setTimeFormat } = setupMocks();
+      render(<UiSettingsForm />);
+      fireEvent.change(screen.getByTestId('select-time-format'), {
+        target: { value: '' },
+      });
+      expect(setTimeFormat).not.toHaveBeenCalled();
+    });
+
+    it('calls setDateFormat when Date format select changes', () => {
+      const { setDateFormat } = setupMocks();
+      render(<UiSettingsForm />);
+      fireEvent.change(screen.getByTestId('select-date-format'), {
+        target: { value: 'dmy' },
+      });
+      expect(setDateFormat).toHaveBeenCalledWith('dmy');
+    });
+
+    it('does not call setDateFormat when value is empty', () => {
+      const { setDateFormat } = setupMocks();
+      render(<UiSettingsForm />);
+      fireEvent.change(screen.getByTestId('select-date-format'), {
+        target: { value: '' },
+      });
+      expect(setDateFormat).not.toHaveBeenCalled();
+    });
+
+    it('calls setTimeZone and saveTimeZoneSetting when Time zone select changes', async () => {
+      const { setTimeZone } = setupMocks();
+      render(<UiSettingsForm />);
+      fireEvent.change(screen.getByTestId('select-time-zone'), {
+        target: { value: 'UTC' },
+      });
+      expect(setTimeZone).toHaveBeenCalledWith('UTC');
+      await waitFor(() => {
+        expect(saveTimeZoneSetting).toHaveBeenCalledWith('UTC', makeSettings());
+      });
+    });
+
+    it('does not call setTimeZone when value is empty', () => {
+      const { setTimeZone } = setupMocks();
+      render(<UiSettingsForm />);
+      fireEvent.change(screen.getByTestId('select-time-zone'), {
+        target: { value: '' },
+      });
+      expect(setTimeZone).not.toHaveBeenCalled();
+      // Only called during initial sync, not on empty change
+      expect(saveTimeZoneSetting).toHaveBeenCalledTimes(1);
+    });
+
+    it('calls setHeaderPinned when switch is toggled on', () => {
+      const { setHeaderPinned } = setupMocks({ headerPinned: false });
+      render(<UiSettingsForm />);
+      fireEvent.click(screen.getByTestId('switch-header-pinned'));
+      expect(setHeaderPinned).toHaveBeenCalledWith(true);
+    });
+
+    it('calls setHeaderPinned when switch is toggled off', () => {
+      const { setHeaderPinned } = setupMocks({ headerPinned: true });
+      render(<UiSettingsForm />);
+      fireEvent.click(screen.getByTestId('switch-header-pinned'));
+      expect(setHeaderPinned).toHaveBeenCalledWith(false);
+    });
+  });
+
+  // ── Time zone sync from settings ───────────────────────────────────────────
+
+  describe('time zone sync from settings', () => {
+    it('calls setTimeZone with system time_zone on mount when settings has tz', () => {
+      const { setTimeZone } = setupMocks({
+        settings: makeSettings({ timeZone: 'America/Chicago' }),
+        timeZone: DEFAULT_TZ,
+      });
+      render(<UiSettingsForm />);
+      expect(setTimeZone).toHaveBeenCalled();
+    });
+
+    it('does not change timeZone when settings tz matches current tz', () => {
+      const { setTimeZone } = setupMocks({
+        settings: makeSettings({ timeZone: DEFAULT_TZ }),
+        timeZone: DEFAULT_TZ,
+      });
+      render(<UiSettingsForm />);
+      // setTimeZone is called with a function that returns prev when equal
+      const callArg = setTimeZone.mock.calls[0]?.[0];
+      if (typeof callArg === 'function') {
+        expect(callArg(DEFAULT_TZ)).toBe(DEFAULT_TZ);
+      }
+    });
+
+    it('calls persistTimeZoneSetting (saveTimeZoneSetting) when no tz in settings and timeZone is set', async () => {
+      setupMocks({
+        settings: makeSettings({ timeZone: null }),
+        timeZone: DEFAULT_TZ,
+      });
+      render(<UiSettingsForm />);
+      await waitFor(() => {
+        expect(saveTimeZoneSetting).toHaveBeenCalledWith(
+          DEFAULT_TZ,
+          makeSettings({ timeZone: null })
+        );
+      });
+    });
+
+    it('does not call saveTimeZoneSetting when settings is null', async () => {
+      setupMocks({ settings: null, timeZone: DEFAULT_TZ });
+      render(<UiSettingsForm />);
+      await waitFor(() => {
+        expect(saveTimeZoneSetting).not.toHaveBeenCalled();
+      });
+    });
+
+    it('does not call saveTimeZoneSetting when timeZone is falsy and no tz in settings', async () => {
+      setupMocks({
+        settings: makeSettings({ timeZone: null }),
+        timeZone: '',
+      });
+      render(<UiSettingsForm />);
+      await waitFor(() => {
+        expect(saveTimeZoneSetting).not.toHaveBeenCalled();
+      });
+    });
+  });
+
+  // ── Error handling ─────────────────────────────────────────────────────────
+
+  describe('error handling', () => {
+    it('shows error notification when saveTimeZoneSetting throws on tz change', async () => {
+      const consoleSpy = vi
+        .spyOn(console, 'error')
+        .mockImplementation(() => {});
+      setupMocks({ settings: makeSettings({ timeZone: null }), timeZone: '' });
+      vi.mocked(saveTimeZoneSetting).mockRejectedValue(
+        new Error('network error')
+      );
+
+      render(<UiSettingsForm />);
+      fireEvent.change(screen.getByTestId('select-time-zone'), {
+        target: { value: 'UTC' },
+      });
+
+      await waitFor(() => {
+        expect(showNotification).toHaveBeenCalledWith(
+          expect.objectContaining({
+            color: 'red',
+            title: 'Failed to update time zone',
+          })
+        );
+      });
+      consoleSpy.mockRestore();
+    });
+
+    it('logs error when saveTimeZoneSetting throws on tz change', async () => {
+      const error = new Error('network error');
+      const consoleSpy = vi
+        .spyOn(console, 'error')
+        .mockImplementation(() => {});
+      setupMocks({ settings: makeSettings({ timeZone: null }), timeZone: '' });
+      vi.mocked(saveTimeZoneSetting).mockRejectedValue(error);
+
+      render(<UiSettingsForm />);
+      fireEvent.change(screen.getByTestId('select-time-zone'), {
+        target: { value: 'UTC' },
+      });
+
+      await waitFor(() => {
+        expect(consoleSpy).toHaveBeenCalledWith(
+          'Failed to persist time zone setting',
+          error
+        );
+      });
+      consoleSpy.mockRestore();
+    });
+
+    it('shows error notification when saveTimeZoneSetting throws during initial sync', async () => {
+      const consoleSpy = vi
+        .spyOn(console, 'error')
+        .mockImplementation(() => {});
+      setupMocks({
+        settings: makeSettings({ timeZone: null }),
+        timeZone: DEFAULT_TZ,
+      });
+      vi.mocked(saveTimeZoneSetting).mockRejectedValue(
+        new Error('sync failed')
+      );
+
+      render(<UiSettingsForm />);
+
+      await waitFor(() => {
+        expect(showNotification).toHaveBeenCalledWith(
+          expect.objectContaining({
+            color: 'red',
+            title: 'Failed to update time zone',
+          })
+        );
+      });
+      consoleSpy.mockRestore();
+    });
+  });
+
+  // ── buildTimeZoneOptions ───────────────────────────────────────────────────
+
+  describe('buildTimeZoneOptions', () => {
+    it('calls buildTimeZoneOptions with current timeZone value', () => {
+      setupMocks({ timeZone: 'America/Chicago' });
+      render(<UiSettingsForm />);
+      expect(buildTimeZoneOptions).toHaveBeenCalledWith('America/Chicago');
+    });
+  });
+});

frontend/src/components/tables/M3UsTable.jsx

@@ -32,7 +32,12 @@ import {
   SquarePlus,
 } from 'lucide-react';
 import useLocalStorage from '../../hooks/useLocalStorage';
-import { useDateTimeFormat, format } from '../../utils/dateTimeUtils.js';
+import {
+  useDateTimeFormat,
+  format,
+  diff,
+  getNow,
+} from '../../utils/dateTimeUtils.js';
 import ConfirmationDialog from '../../components/ConfirmationDialog';
 import useWarningsStore from '../../store/warnings';
 import { CustomTable, useTable } from './CustomTable';
@@ -159,7 +164,7 @@ const M3UTable = () => {
 
   const theme = useMantineTheme();
   const [tableSize] = useLocalStorage('table-size', 'default');
-  const { fullDateTimeFormat } = useDateTimeFormat();
+  const { fullDateFormat, fullDateTimeFormat } = useDateTimeFormat();
 
   const generateStatusString = (data) => {
     if (data.progress == 100) {
@@ -584,6 +589,64 @@ const M3UTable = () => {
         sortable: true,
         size: 125,
       },
+      {
+        header: 'Expiration',
+        accessorKey: 'earliest_expiration',
+        sortable: true,
+        size: 110,
+        cell: ({ cell, row }) => {
+          const data = row.original;
+
+          const earliest = cell.getValue();
+          if (!earliest) {
+            return null;
+          }
+
+          const now = getNow();
+          const daysLeft = diff(earliest, now, 'day');
+          let color;
+          let label;
+          if (daysLeft < 0) {
+            color = 'red.7';
+            label = 'Expired';
+          } else if (daysLeft === 0) {
+            color = 'red.5';
+            label = 'Expires today';
+          } else if (daysLeft <= 7) {
+            color = 'orange.5';
+            label = `${daysLeft}d left`;
+          } else if (daysLeft <= 30) {
+            color = 'yellow.5';
+            label = `${daysLeft}d left`;
+          } else {
+            label = format(earliest, fullDateFormat);
+          }
+
+          const allExpirations = data.all_expirations || [];
+          const tooltipContent =
+            allExpirations.length > 0
+              ? allExpirations
+                  .map(
+                    (e) =>
+                      `${e.profile_name}: ${format(e.exp_date, fullDateTimeFormat)}${!e.is_active ? ' (inactive)' : ''}`
+                  )
+                  .join('\n')
+              : label;
+
+          return (
+            <Tooltip
+              label={tooltipContent}
+              multiline
+              width={300}
+              style={{ whiteSpace: 'pre-line' }}
+            >
+              <Text size="xs" c={color} fw={daysLeft <= 7 ? 600 : 400}>
+                {label}
+              </Text>
+            </Tooltip>
+          );
+        },
+      },
       {
         header: 'Updated',
         accessorKey: 'updated_at',
@@ -624,6 +687,7 @@ const M3UTable = () => {
       editPlaylist,
       deletePlaylist,
       toggleActive,
+      fullDateFormat,
       fullDateTimeFormat,
     ]
   );
@@ -696,13 +760,22 @@ const M3UTable = () => {
         playlists
           .filter((playlist) => playlist.locked === false)
           .sort((a, b) => {
-            console.log(a);
-            console.log(newSorting[0].id);
-            if (a[compareColumn] !== b[compareColumn]) {
-              return compareDesc ? 1 : -1;
+            const aVal = a[compareColumn];
+            const bVal = b[compareColumn];
+
+            // Always sort nulls/undefined to the end regardless of direction
+            if (aVal == null && bVal == null) return 0;
+            if (aVal == null) return 1;
+            if (bVal == null) return -1;
+
+            let comparison;
+            if (typeof aVal === 'string') {
+              comparison = aVal.localeCompare(bVal);
+            } else {
+              comparison = aVal < bVal ? -1 : aVal > bVal ? 1 : 0;
             }
 
-            return 0;
+            return compareDesc ? -comparison : comparison;
           })
       );
     }
@@ -778,6 +851,7 @@ const M3UTable = () => {
       status: renderHeaderCell,
       last_message: renderHeaderCell,
       updated_at: renderHeaderCell,
+      earliest_expiration: renderHeaderCell,
       is_active: renderHeaderCell,
       actions: renderHeaderCell,
     },

frontend/src/store/notifications.jsx

@@ -26,12 +26,15 @@ const useNotificationsStore = create((set, get) => ({
       );
       if (exists) {
         // Update existing notification
+        const updatedNotifications = state.notifications.map((n) =>
+          n.notification_key === notification.notification_key
+            ? { ...n, ...notification }
+            : n
+        );
         return {
-          notifications: state.notifications.map((n) =>
-            n.notification_key === notification.notification_key
-              ? { ...n, ...notification }
-              : n
-          ),
+          notifications: updatedNotifications,
+          unreadCount: updatedNotifications.filter((n) => !n.is_dismissed)
+            .length,
         };
       }
       // Add new notification