prismcast 1.5.2 → 1.7.0

package/dist/routes/config/channels/routes.js

@@ -1,10 +1,12 @@
 import { LOG, formatError, generateChannelKey, parseM3U, sanitizeString } from "../../../utils/index.js";
-import { VALID_OPTIONAL_COLUMNS, generateChannelRowHtml } from "./table.js";
-import { VALID_SORT_FIELDS, getAllProviderTags, getCanonicalKey, getChannelProviderLabel, getEnabledProviders, getProviderGroup, getProviderSelection, getProviderTagForChannel, getResolvedChannel, resolvePredefinedVariant, resolveProviderKey, setEnabledProviders, setProviderSelection } from "../../../config/providers.js";
+import { VALID_OPTIONAL_COLUMNS, buildChannelTablePatch, buildChannelTableState } from "./table.js";
+import { VALID_SORT_FIELDS, compareChannelSort, getAllProviderTags, getCanonicalKey, getChannelProviderLabel, getEnabledProviders, getProviderGroup, getProviderSelection, getProviderTagForChannel, getResolvedChannel, resolvePredefinedVariant, resolveProviderKey, setEnabledProviders, setProviderSelection } from "../../../config/providers.js";
 import { filterDefaults, loadUserConfig, saveUserConfig } from "../../../config/userConfig.js";
-import { getChannelListing, getEastWithPacificPredefinedKeys, getPacificPredefinedKeys, getPredefinedChannel, getPredefinedChannels, getPredefinedScopeCounts, getUserChannels, isPredefinedChannel, isUserChannel, loadUserChannels, resolveStoredChannel, saveProviderSelections, saveUserChannels, validateChannelKey, validateChannelName, validateChannelProfile, validateChannelUrl, validateImportedChannels } from "../../../config/userChannels.js";
+import { getChannelListing, getEastWithPacificPredefinedKeys, getPacificPredefinedKeys, getPredefinedChannel, getPredefinedChannels, getUserChannels, isPredefinedChannel, isUserChannel, loadUserChannels, resolveStoredChannel, saveProviderSelections, saveUserChannels, validateChannelKey, validateChannelName, validateChannelNumber, validateChannelProfile, validateChannelUrl, validateImportedChannels } from "../../../config/userChannels.js";
 import { CONFIG } from "../../../config/index.js";
+import { PREDEFINED_CHANNELS } from "../../../channels/index.js";
 import { getProfiles } from "../../../config/profiles.js";
+import { updateChannelLogo } from "../../../streaming/showInfo.js";
 // Fields that appear in the generated M3U playlist and affect Channels DVR's view of the channel. Used to decide whether the playlist reload hint is shown.
 const M3U_FIELDS = ["channelNumber", "name", "stationId", "tvgShift"];
 const PLAYLIST_HINT = " Reload the playlist in Channels DVR to see this change.";
@@ -17,6 +19,48 @@ const PLAYLIST_HINT = " Reload the playlist in Channels DVR to see this change."
 function playlistHintForStored(stored) {
     return M3U_FIELDS.some((f) => f in stored) ? PLAYLIST_HINT : "";
 }
+/**
+ * Disables one or more predefined channels by adding their keys to the disabledPredefined list in user config. Updates both the config file and the runtime
+ * CONFIG object. Shared by the toggle-predefined and bulk-add handlers to avoid duplicating the config load/save/update pattern.
+ * @param keys - The predefined channel keys to disable.
+ */
+async function disablePredefinedChannels(keys) {
+    if (keys.length === 0) {
+        return;
+    }
+    const configResult = await loadUserConfig();
+    const userConfig = configResult.config;
+    userConfig.channels ??= {};
+    userConfig.channels.disabledPredefined ??= [];
+    const disabledSet = new Set(userConfig.channels.disabledPredefined);
+    for (const key of keys) {
+        disabledSet.add(key);
+    }
+    userConfig.channels.disabledPredefined = [...disabledSet].sort();
+    await saveUserConfig(userConfig);
+    CONFIG.channels.disabledPredefined = userConfig.channels.disabledPredefined;
+}
+/**
+ * Enables one or more predefined channels by removing their keys from the disabledPredefined list in user config. Updates both the config file and the
+ * runtime CONFIG object. Shared by the toggle-predefined and bulk-add handlers to avoid duplicating the config load/save/update pattern.
+ * @param keys - The predefined channel keys to enable.
+ */
+async function enablePredefinedChannels(keys) {
+    if (keys.length === 0) {
+        return;
+    }
+    const configResult = await loadUserConfig();
+    const userConfig = configResult.config;
+    userConfig.channels ??= {};
+    userConfig.channels.disabledPredefined ??= [];
+    const disabledSet = new Set(userConfig.channels.disabledPredefined);
+    for (const key of keys) {
+        disabledSet.delete(key);
+    }
+    userConfig.channels.disabledPredefined = [...disabledSet].sort();
+    await saveUserConfig(userConfig);
+    CONFIG.channels.disabledPredefined = userConfig.channels.disabledPredefined;
+}
 /**
  * Installs all channel-related route handlers on the Express application.
  * @param app - The Express application.
@@ -54,8 +98,10 @@ export function setupChannelRoutes(app) {
             // Save the imported channels, replacing all existing user channels.
             await saveUserChannels(validationResult.channels);
             const channelCount = Object.keys(validationResult.channels).length;
-            // Send success response. Changes take effect immediately due to hot-reloading in saveUserChannels().
-            res.json({ message: "Imported " + String(channelCount) + " channel" + (channelCount === 1 ? "" : "s") + " successfully.", success: true });
+            // Return a full table patch since a bulk JSON import replaces all user channels — every row in the listing may have changed.
+            const allKeys = getChannelListing().map((entry) => entry.key);
+            res.json({ message: "Imported " + String(channelCount) + " channel" + (channelCount === 1 ? "" : "s") + " successfully.",
+                patch: buildChannelTablePatch(allKeys, getProfiles()), success: true });
         }
         catch (error) {
             LOG.error("Failed to import channels: %s.", formatError(error));
@@ -92,6 +138,7 @@ export function setupChannelRoutes(app) {
             const loadResult = await loadUserChannels();
             const existingChannels = loadResult.parseError ? {} : loadResult.channels;
             // Track import statistics.
+            const affectedKeys = [];
             const conflicts = [];
             const importErrors = [];
             const seenKeys = new Set();
@@ -151,16 +198,18 @@ export function setupChannelRoutes(app) {
                 }
                 // Add to channels collection.
                 existingChannels[key] = channel;
+                affectedKeys.push(key);
             }
             // Save the updated channels.
             await saveUserChannels(existingChannels);
             // Log the import.
             LOG.info("M3U import completed: %d imported, %d replaced, %d skipped.", imported, replaced, skipped);
-            // Build response.
+            // Build response with patch for in-place UI update.
             res.json({
                 conflicts,
                 errors: [...parseResult.errors, ...importErrors],
                 imported,
+                patch: ((imported > 0) || (replaced > 0)) ? buildChannelTablePatch(affectedKeys, getProfiles()) : undefined,
                 replaced,
                 skipped,
                 success: true
@@ -171,6 +220,177 @@ export function setupChannelRoutes(app) {
             res.status(500).json({ error: "Failed to import channels: " + formatError(error), success: false });
         }
     });
+    // POST /config/channels/modify - Apply channel modifications from the browse modal. Handles four action types: 'add' creates new user channels, 'enable'
+    // re-enables a disabled predefined channel and sets its provider, 'switch' changes the provider selection for an existing channel, and 'remove' reverts a
+    // channel to its canonical provider (disabling it if no alternative provider is available). Channel writes and provider selection changes are batched into
+    // single saves to avoid redundant file I/O.
+    app.post("/config/channels/modify", async (req, res) => {
+        try {
+            const body = req.body;
+            const channels = body.channels;
+            // Validate that channels array is provided and non-empty.
+            if (!Array.isArray(channels) || (channels.length === 0)) {
+                res.status(400).json({ error: "No channels provided.", success: false });
+                return;
+            }
+            // Load existing user channels.
+            const loadResult = await loadUserChannels();
+            const existingChannels = loadResult.parseError ? {} : loadResult.channels;
+            // Build a set of all existing channel keys (predefined + user) for deduplication.
+            const allKeys = new Set([...Object.keys(PREDEFINED_CHANNELS), ...Object.keys(existingChannels)]);
+            const affectedKeys = new Set();
+            const disablePredefined = new Set();
+            const errors = [];
+            let added = 0;
+            let removed = 0;
+            let switched = 0;
+            let channelsChanged = false;
+            let selectionsChanged = false;
+            // Build a UserChannel object from an entry's fields. Shared by the switch/enable and add paths to avoid duplicating channel construction logic.
+            function buildUserChannel(entry, channelName, channelUrl, selector) {
+                const channel = {
+                    channelSelector: selector || undefined,
+                    name: channelName,
+                    url: channelUrl
+                };
+                if (entry.stationId) {
+                    channel.stationId = sanitizeString(entry.stationId);
+                }
+                return channel;
+            }
+            for (const entry of channels) {
+                const action = entry.action ?? "add";
+                const name = sanitizeString(entry.name?.trim() ?? "");
+                const providerSlug = entry.providerSlug?.trim() ?? "";
+                // Handle enable and switch. Enable re-enables a disabled predefined channel, then falls through to the switch logic to set the provider selection.
+                // Switch changes the provider selection for an existing channel to point to the browsed provider's variant, creating the variant if needed.
+                if ((action === "switch") || (action === "enable")) {
+                    const canonicalKey = entry.canonicalKey?.trim() ?? "";
+                    if (!canonicalKey) {
+                        errors.push("Entry for '" + name + "' missing canonical key.");
+                        continue;
+                    }
+                    // Re-enable the channel if it was disabled. Must complete before setting the provider selection since the config write makes the channel
+                    // visible in the lineup.
+                    if (action === "enable") {
+                        // eslint-disable-next-line no-await-in-loop -- Sequential: config state must be updated before setting provider selection.
+                        await enablePredefinedChannels([canonicalKey]);
+                    }
+                    const variantKey = canonicalKey + "-" + providerSlug;
+                    // If no variant exists for this provider, create one as a user channel.
+                    if (!allKeys.has(variantKey)) {
+                        existingChannels[variantKey] = buildUserChannel(entry, name, sanitizeString(entry.url?.trim() ?? ""), sanitizeString(entry.channelSelector?.trim() ?? ""));
+                        allKeys.add(variantKey);
+                        channelsChanged = true;
+                    }
+                    setProviderSelection(canonicalKey, variantKey);
+                    selectionsChanged = true;
+                    switched++;
+                    affectedKeys.add(canonicalKey);
+                    continue;
+                }
+                // Handle provider removal. Reverts the channel away from this provider using a three-tier fallback: (1) clear the selection and let
+                // resolveProviderKey find the next enabled variant or canonical, (2) if the resolved provider is still this provider (no alternative exists),
+                // disable the predefined channel or delete the user channel.
+                if (action === "remove") {
+                    const canonicalKey = entry.canonicalKey?.trim() ?? "";
+                    if (!canonicalKey) {
+                        errors.push("Remove entry for '" + name + "' missing canonical key.");
+                        continue;
+                    }
+                    // Clear the provider selection. resolveProviderKey will now return the canonical or the first enabled alternative variant.
+                    setProviderSelection(canonicalKey, canonicalKey);
+                    selectionsChanged = true;
+                    // Check if the resolved provider is still this provider. If so, there is no alternative — disable or delete the channel.
+                    const resolvedKey = resolveProviderKey(canonicalKey);
+                    const resolvedTag = getProviderTagForChannel(resolvedKey);
+                    if (resolvedTag === providerSlug) {
+                        // No alternative provider exists. Disable predefined channels or delete user channels.
+                        if (isPredefinedChannel(canonicalKey)) {
+                            disablePredefined.add(canonicalKey);
+                        }
+                        else {
+                            Reflect.deleteProperty(existingChannels, canonicalKey);
+                            channelsChanged = true;
+                        }
+                    }
+                    removed++;
+                    affectedKeys.add(canonicalKey);
+                    continue;
+                }
+                // Handle add. Creates a new user channel for channels not yet in the lineup. The browse modal sends 'add' only for genuinely new channels (no
+                // existing canonical). Channels that match existing canonicals appear as 'switch' state in the modal instead.
+                const url = sanitizeString(entry.url?.trim() ?? "");
+                const channelSelector = sanitizeString(entry.channelSelector?.trim() ?? "");
+                if (!name) {
+                    errors.push("Channel entry missing name.");
+                    continue;
+                }
+                if (!url) {
+                    errors.push("Channel '" + name + "' missing URL.");
+                    continue;
+                }
+                const urlError = validateChannelUrl(url);
+                if (urlError) {
+                    errors.push("Channel '" + name + "': " + urlError);
+                    continue;
+                }
+                const baseKey = generateChannelKey(name);
+                if (!baseKey) {
+                    errors.push("Could not generate key for channel '" + name + "'.");
+                    continue;
+                }
+                const canonicalExists = allKeys.has(baseKey);
+                const key = (canonicalExists && providerSlug) ? baseKey + "-" + providerSlug : baseKey;
+                // Skip channels that already exist in the lineup.
+                if (allKeys.has(key)) {
+                    continue;
+                }
+                const newChannel = buildUserChannel(entry, name, url, channelSelector);
+                // When this is a provider variant (key differs from baseKey), store the canonical relationship explicitly so that buildProviderGroups can
+                // associate the user channel with its canonical via the canonicalKey field.
+                if (key !== baseKey) {
+                    newChannel.canonicalKey = baseKey;
+                }
+                existingChannels[key] = newChannel;
+                allKeys.add(key);
+                channelsChanged = true;
+                added++;
+                affectedKeys.add(canonicalExists ? baseKey : key);
+            }
+            // Save changes. saveUserChannels() persists both channel data and provider selections in a single file write, so we only need saveProviderSelections()
+            // (which writes the same file using the module-level cache) when selections changed but no new channels were added.
+            if (channelsChanged) {
+                await saveUserChannels(existingChannels);
+            }
+            else if (selectionsChanged) {
+                await saveProviderSelections();
+            }
+            // Disable predefined channels that had no alternative provider after removal.
+            await disablePredefinedChannels([...disablePredefined]);
+            for (const disabledKey of disablePredefined) {
+                affectedKeys.add(disabledKey);
+            }
+            // Build a descriptive response message.
+            const parts = [];
+            if (added > 0) {
+                parts.push("Added " + String(added) + " channel" + (added === 1 ? "" : "s") + ".");
+            }
+            if (switched > 0) {
+                parts.push("Switched " + String(switched) + " channel" + (switched === 1 ? "" : "s") + ".");
+            }
+            if (removed > 0) {
+                parts.push("Reverted " + String(removed) + " channel" + (removed === 1 ? "" : "s") + ".");
+            }
+            const message = (parts.length > 0 ? parts.join(" ") : "No changes made.") + PLAYLIST_HINT;
+            LOG.info("Browse channels completed: %d added, %d switched, %d removed.", added, switched, removed);
+            res.json({ added, errors, message, patch: buildChannelTablePatch([...affectedKeys], getProfiles()), removed, success: true, switched });
+        }
+        catch (error) {
+            LOG.error("Failed to apply browse changes: %s.", formatError(error));
+            res.status(500).json({ error: "Failed to apply changes: " + formatError(error), success: false });
+        }
+    });
     // POST /config/channels/toggle-predefined - Toggle a single predefined channel's enabled/disabled state.
     app.post("/config/channels/toggle-predefined", async (req, res) => {
         try {
@@ -192,28 +412,15 @@ export function setupChannelRoutes(app) {
                 res.status(400).json({ error: "Channel '" + key + "' is not a predefined channel.", success: false });
                 return;
             }
-            // Load current config.
-            const configResult = await loadUserConfig();
-            const userConfig = configResult.config;
-            // Initialize channels.disabledPredefined if not present.
-            userConfig.channels ??= {};
-            userConfig.channels.disabledPredefined ??= [];
-            const disabledSet = new Set(userConfig.channels.disabledPredefined);
+            // Enable or disable the channel using the shared helpers that handle config file I/O and runtime CONFIG update.
             if (enabled) {
-                // Enable: remove from disabled list.
-                disabledSet.delete(key);
+                await enablePredefinedChannels([key]);
             }
             else {
-                // Disable: add to disabled list.
-                disabledSet.add(key);
+                await disablePredefinedChannels([key]);
             }
-            // Update and save config.
-            userConfig.channels.disabledPredefined = [...disabledSet].sort();
-            await saveUserConfig(userConfig);
-            // Update the runtime CONFIG to reflect the change immediately.
-            CONFIG.channels.disabledPredefined = userConfig.channels.disabledPredefined;
             LOG.info("Predefined channel '%s' %s.", key, enabled ? "enabled" : "disabled");
-            res.json({ counts: getPredefinedScopeCounts(), enabled, key, success: true });
+            res.json({ enabled, key, patch: buildChannelTablePatch([key], getProfiles()), success: true });
         }
         catch (error) {
             LOG.error("Failed to toggle predefined channel: %s.", formatError(error));
@@ -260,10 +467,9 @@ export function setupChannelRoutes(app) {
             const channelName = canonicalChannel?.name ?? canonicalKey;
             const providerLabel = variantChannel ? getChannelProviderLabel(variantChannel) : providerKey;
             LOG.info("Provider for %s changed to %s.", channelName, providerLabel);
-            // Return full row HTML so the client can replace both the display and edit rows, keeping the edit form in sync with the selected provider.
+            // Return a channel table patch so the client can update the row and summary counts in place.
             const profiles = getProfiles();
-            const rowHtml = generateChannelRowHtml(canonicalKey, profiles);
-            res.json({ channel: canonicalKey, html: { displayRow: rowHtml.displayRow, editRow: rowHtml.editRow }, provider: providerKey, success: true });
+            res.json({ channel: canonicalKey, patch: buildChannelTablePatch([canonicalKey], profiles), provider: providerKey, success: true });
         }
         catch (error) {
             LOG.error("Failed to update provider selection: %s.", formatError(error));
@@ -330,15 +536,121 @@ export function setupChannelRoutes(app) {
             const affected = targetKeys.length;
             const scopeLabel = (scope === "all") ? "All" : (scope === "pacific") ? "Pacific" : "East";
             LOG.info("%s predefined channels %s (%d affected).", scopeLabel, enabled ? "enabled" : "disabled", affected);
-            // Compute updated counts for all three scopes so the client can update all toggle rows from a single response.
-            const counts = getPredefinedScopeCounts();
-            res.json({ affected, counts, enabled, keys: targetKeys, scope, success: true });
+            res.json({ affected, enabled, keys: targetKeys, patch: buildChannelTablePatch(targetKeys, getProfiles()), scope, success: true });
         }
         catch (error) {
             LOG.error("Failed to toggle predefined channels: %s.", formatError(error));
             res.status(500).json({ error: "Failed to toggle channels: " + formatError(error), success: false });
         }
     });
+    // POST /config/channels/auto-number - Assign sequential channel numbers to visible channels in the current sort order, or clear all channel numbers when
+    // start is 0. Overwrites existing channel numbers for affected channels. Only channels that are enabled and available by provider filter are affected.
+    app.post("/config/channels/auto-number", async (req, res) => {
+        try {
+            const body = req.body;
+            const start = (typeof body.start === "number") ? body.start : 1;
+            const clearMode = (start === 0);
+            const sortField = body.sortField ?? "name";
+            const sortDir = (body.sortDirection === "desc") ? "desc" : "asc";
+            if (!clearMode && ((start < 1) || (start > 99999))) {
+                res.status(400).json({ error: "Starting number must be between 1 and 99999.", success: false });
+                return;
+            }
+            if (!VALID_SORT_FIELDS.has(sortField)) {
+                res.status(400).json({ error: "Invalid sort field.", success: false });
+                return;
+            }
+            // Get visible channels (enabled + available by provider filter) sorted by the user's current sort order.
+            const listing = getChannelListing().filter((entry) => entry.enabled && entry.availableByProvider);
+            listing.sort((a, b) => compareChannelSort(a.channel, a.key, b.channel, b.key, sortField, sortDir));
+            // Load user channels for modification.
+            const result = await loadUserChannels();
+            if (result.parseError) {
+                res.status(400).json({ error: "Cannot auto-number: channels file contains invalid JSON.", success: false });
+                return;
+            }
+            const affectedKeys = [];
+            if (clearMode) {
+                // Clear channel numbers from all visible channels. For predefined channels, use null to signal removal in the delta. For user channels, use undefined.
+                for (const entry of listing) {
+                    const existing = result.channels[entry.key] ?? {};
+                    const clearValue = isPredefinedChannel(entry.key) ? null : undefined;
+                    existing.channelNumber = clearValue;
+                    result.channels[entry.key] = existing;
+                    affectedKeys.push(entry.key);
+                }
+            }
+            else {
+                // Assign sequential numbers starting from the requested start value.
+                for (let i = 0; i < listing.length; i++) {
+                    const entry = listing[i];
+                    const num = start + i;
+                    if (num > 99999) {
+                        break;
+                    }
+                    const existing = result.channels[entry.key] ?? {};
+                    existing.channelNumber = num;
+                    result.channels[entry.key] = existing;
+                    affectedKeys.push(entry.key);
+                }
+            }
+            await saveUserChannels(result.channels);
+            const action = clearMode ? "Cleared" : "Numbered";
+            LOG.info("%s channel numbers for %d channels.", action, affectedKeys.length);
+            const profiles = getProfiles();
+            const message = clearMode ?
+                "Cleared channel numbers from " + String(affectedKeys.length) + " channels." + PLAYLIST_HINT :
+                "Numbered " + String(affectedKeys.length) + " channels." + PLAYLIST_HINT;
+            res.json({ affected: affectedKeys.length, message, patch: buildChannelTablePatch(affectedKeys, profiles), success: true });
+        }
+        catch (error) {
+            LOG.error("Failed to auto-number channels: %s.", formatError(error));
+            res.status(500).json({ error: "Failed to auto-number channels: " + formatError(error), success: false });
+        }
+    });
+    // POST /config/channels/hdhr-bulk - Toggle HDHomeRun lineup inclusion for all visible channels. When enable is true, all channels are included (hdhrEnabled
+    // cleared). When false, all channels are excluded (hdhrEnabled set to false).
+    app.post("/config/channels/hdhr-bulk", async (req, res) => {
+        try {
+            const body = req.body;
+            const enable = body.enable === true;
+            // Get visible channels (enabled + available by provider filter).
+            const listing = getChannelListing().filter((entry) => entry.enabled && entry.availableByProvider);
+            // Load user channels for modification.
+            const result = await loadUserChannels();
+            if (result.parseError) {
+                res.status(400).json({ error: "Cannot update HDHR settings: channels file contains invalid JSON.", success: false });
+                return;
+            }
+            const affectedKeys = [];
+            for (const entry of listing) {
+                const current = entry.channel.hdhrEnabled !== false;
+                // Skip channels that already match the target state.
+                if (current === enable) {
+                    continue;
+                }
+                const existing = result.channels[entry.key] ?? {};
+                const clearValue = isPredefinedChannel(entry.key) ? null : undefined;
+                existing.hdhrEnabled = enable ? clearValue : false;
+                result.channels[entry.key] = existing;
+                affectedKeys.push(entry.key);
+            }
+            if (affectedKeys.length === 0) {
+                res.json({ affected: 0, message: "No changes needed.", success: true });
+                return;
+            }
+            await saveUserChannels(result.channels);
+            const action = enable ? "included in" : "excluded from";
+            LOG.info("Bulk HDHR toggle: %d channels %s HDHR lineup.", affectedKeys.length, action);
+            const profiles = getProfiles();
+            const message = String(affectedKeys.length) + " channel(s) " + action + " the HDHomeRun lineup.";
+            res.json({ affected: affectedKeys.length, message, patch: buildChannelTablePatch(affectedKeys, profiles), success: true });
+        }
+        catch (error) {
+            LOG.error("Failed to bulk-toggle HDHR: %s.", formatError(error));
+            res.status(500).json({ error: "Failed to toggle HDHR settings: " + formatError(error), success: false });
+        }
+    });
     // POST /config/provider-filter - Update the provider filter (enabled provider tags).
     app.post("/config/provider-filter", async (req, res) => {
         try {
@@ -370,13 +682,33 @@ export function setupChannelRoutes(app) {
             userConfig.channels.enabledProviders = tags;
             await saveUserConfig(filterDefaults(userConfig));
             LOG.info("Provider filter updated: %s.", tags.length > 0 ? tags.join(", ") : "all providers");
-            res.json({ enabledProviders: tags, success: true });
+            // Return counts patch so the client can update summary counts after filter change. No rows — the client applies CSS visibility changes itself.
+            const { counts, scopeCounts } = buildChannelTableState();
+            res.json({ enabledProviders: tags, patch: { counts, rows: [], scopeCounts }, success: true });
         }
         catch (error) {
             LOG.error("Failed to update provider filter: %s.", formatError(error));
             res.status(500).json({ error: "Failed to update provider filter: " + formatError(error), success: false });
         }
     });
+    // POST /config/channels/setup-completed - Mark the Provider Setup flow as completed. Called when the wizard finishes or the user explicitly skips.
+    app.post("/config/channels/setup-completed", async (_req, res) => {
+        try {
+            CONFIG.channels.setupCompleted = true;
+            const configResult = await loadUserConfig();
+            configResult.config.channels ??= {};
+            configResult.config.channels.setupCompleted = true;
+            await saveUserConfig(configResult.config);
+            // Return a full patch so the client can refresh the channel table after the setup wizard completes. The wizard's browse step may have added channels
+            // via the modify endpoint, and the provider filter may have changed — the patch ensures the table reflects the current state.
+            const { counts, scopeCounts } = buildChannelTableState();
+            res.json({ patch: { counts, rows: [], scopeCounts }, success: true });
+        }
+        catch (error) {
+            LOG.error("Failed to save setup completed state: %s.", formatError(error));
+            res.status(500).json({ error: "Failed to save setup state: " + formatError(error), success: false });
+        }
+    });
     // POST /config/channels/display-prefs - Update channel table display preferences (visible columns, sort field, sort direction).
     app.post("/config/channels/display-prefs", async (req, res) => {
         try {
@@ -545,10 +877,59 @@ export function setupChannelRoutes(app) {
                 Reflect.deleteProperty(result.channels, key);
                 await saveUserChannels(result.channels);
                 LOG.info("Channel '%s' reverted to predefined defaults.", key);
-                // Generate the predefined row HTML so the client can replace the override row.
-                const rowHtml = generateChannelRowHtml(key, profiles);
-                res.json({ html: { displayRow: rowHtml.displayRow, editRow: rowHtml.editRow }, key,
-                    message: "Channel '" + key + "' reverted to defaults." + revertHint, success: true });
+                res.json({ key, message: "Channel '" + key + "' reverted to defaults." + revertHint,
+                    patch: buildChannelTablePatch([key], profiles), success: true });
+                return;
+            }
+            // Handle inline-edit action — update a single field on an existing channel without requiring all fields. Used by the inline cell editing UI for channel
+            // number, station ID, and HDHR lineup toggles.
+            if (action === "inline-edit") {
+                if (!key) {
+                    res.status(400).json({ message: "Channel key is required.", success: false });
+                    return;
+                }
+                const field = body.field;
+                const value = sanitizeString(body.value ?? "");
+                if ((field !== "channelNumber") && (field !== "hdhrEnabled") && (field !== "stationId")) {
+                    res.status(400).json({ message: "Invalid inline-edit field.", success: false });
+                    return;
+                }
+                // Validate channel number if the field is channelNumber.
+                if (field === "channelNumber") {
+                    const numberError = validateChannelNumber(value, key);
+                    if (numberError) {
+                        res.status(400).json({ message: numberError, success: false });
+                        return;
+                    }
+                }
+                // Load and update the channel. For predefined channels, store a delta override with null to clear fields. For user channels, use undefined to delete.
+                const result = await loadUserChannels();
+                if (result.parseError) {
+                    res.status(400).json({ message: "Cannot edit: channels file contains invalid JSON.", success: false });
+                    return;
+                }
+                // Use a StoredChannelMap-compatible update. The ?? {} creates an empty ChannelDelta for predefined channels that don't have a user override yet.
+                const stored = result.channels[key] ?? {};
+                const clearValue = isPredefinedChannel(key) ? null : undefined;
+                if (field === "channelNumber") {
+                    stored.channelNumber = value ? parseInt(value, 10) : clearValue;
+                }
+                else if (field === "hdhrEnabled") {
+                    // hdhrEnabled: "true" means enabled (clear the override), "false" means disabled. For predefined channels, null clears the delta. For user channels,
+                    // delete the field entirely to revert to the default (included).
+                    stored.hdhrEnabled = (value === "false") ? false : clearValue;
+                }
+                else {
+                    stored.stationId = value || clearValue;
+                }
+                result.channels[key] = stored;
+                await saveUserChannels(result.channels);
+                const fieldLabels = { channelNumber: "Channel number", hdhrEnabled: "HDHR lineup", stationId: "Station ID" };
+                const fieldLabel = fieldLabels[field] ?? field;
+                const displayValue = (field === "hdhrEnabled") ? ((value === "false") ? "excluded" : "included") : (value || "(cleared)");
+                LOG.info("Inline edit: %s for '%s' set to '%s'.", fieldLabel, key, displayValue);
+                const playlistHint = (field === "hdhrEnabled") ? "" : PLAYLIST_HINT;
+                res.json({ key, message: fieldLabel + " updated." + playlistHint, patch: buildChannelTablePatch([key], profiles), success: true });
                 return;
             }
             // Handle delete action.
@@ -570,12 +951,10 @@ export function setupChannelRoutes(app) {
                 Reflect.deleteProperty(result.channels, key);
                 await saveUserChannels(result.channels);
                 LOG.info("User channel '%s' deleted.", key);
-                // If a predefined channel exists with the same key, generate its HTML so the client can replace the user channel row with the predefined version instead of
-                // just removing it. Without this, deleting a user override of a predefined channel would leave the predefined channel invisible until a page refresh.
-                const predefined = isPredefinedChannel(key) ? generateChannelRowHtml(key, profiles) : undefined;
-                // Return success response with key for client-side DOM update. Changes take effect immediately due to hot-reloading in saveUserChannels().
-                res.json({ html: predefined, key,
-                    message: "Channel '" + key + "' deleted successfully." + PLAYLIST_HINT, success: true });
+                // Return a patch. If a predefined channel exists with the same key, the patch includes an "update" row for the predefined version (so the client replaces
+                // the user channel row with the predefined original). Otherwise, the patch includes a "remove" action for the deleted key.
+                res.json({ key, message: "Channel '" + key + "' deleted successfully." + PLAYLIST_HINT,
+                    patch: buildChannelTablePatch([key], profiles), success: true });
                 return;
             }
             // Handle add and edit actions.
@@ -597,21 +976,11 @@ export function setupChannelRoutes(app) {
             const stationId = sanitizeString(body.stationId ?? "");
             const channelSelector = sanitizeString(body.channelSelector ?? "");
             const channelNumberStr = sanitizeString(body.channelNumber ?? "");
+            const hdhrEnabled = body.hdhrEnabled !== "false";
             // Validate channel number if provided.
-            if (channelNumberStr) {
-                const num = parseInt(channelNumberStr, 10);
-                if (Number.isNaN(num) || (num < 1) || (num > 99999)) {
-                    formErrors.channelNumber = "Channel number must be between 1 and 99999.";
-                }
-                else {
-                    // Check for duplicate channel numbers across all resolved channels.
-                    for (const entry of getChannelListing()) {
-                        if ((entry.channel.channelNumber === num) && (entry.key !== key)) {
-                            formErrors.channelNumber = "Channel number " + String(num) + " is already used by '" + entry.key + "'.";
-                            break;
-                        }
-                    }
-                }
+            const channelNumberError = validateChannelNumber(channelNumberStr, key);
+            if (channelNumberError) {
+                formErrors.channelNumber = channelNumberError;
             }
             // Validate key (only for add action, not edit).
             if (action === "add") {
@@ -657,19 +1026,23 @@ export function setupChannelRoutes(app) {
             const predefinedBase = getPredefinedChannel(key);
             if ((action === "edit") && predefinedBase) {
                 // Build a record of submitted form values keyed by channel property name. This record drives both the displayChannel comparison and the predefined delta
-                // computation, so adding a new form field only requires adding it here. String fields use "" for empty; channelNumber uses undefined.
+                // computation, so adding a new form field only requires adding it here. String fields use "" for empty; channelNumber uses undefined; hdhrEnabled uses boolean.
                 const formValues = {
                     channelNumber: channelNumberStr ? parseInt(channelNumberStr, 10) : undefined,
                     channelSelector,
+                    hdhrEnabled,
                     name,
                     profile,
                     stationId,
                     url
                 };
                 // Helper to read a comparable value from a Channel object. String fields default to "" when undefined so they match the form's empty-string representation.
-                // channelNumber stays as number | undefined since the form value uses the same representation.
+                // channelNumber stays as number | undefined since the form value uses the same representation. hdhrEnabled defaults to true when absent.
                 const channelValue = (ch, field) => {
                     const val = ch[field];
+                    if (field === "hdhrEnabled") {
+                        return val !== false;
+                    }
                     return (field === "channelNumber") ? val : val ?? "";
                 };
                 // First check: did the user change anything from what the form showed? The edit form is pre-populated with the selected provider's resolved channel, which
@@ -702,9 +1075,8 @@ export function setupChannelRoutes(app) {
                         Reflect.deleteProperty(result.channels, key);
                         await saveUserChannels(result.channels);
                         LOG.info("Channel '%s' reverted to predefined defaults (edit matched predefined values).", key);
-                        const rowHtml = generateChannelRowHtml(key, profiles);
-                        res.json({ html: { displayRow: rowHtml.displayRow, editRow: rowHtml.editRow }, key,
-                            message: "Channel '" + key + "' reverted to defaults." + implicitRevertHint, success: true });
+                        res.json({ key, message: "Channel '" + key + "' reverted to defaults." + implicitRevertHint,
+                            patch: buildChannelTablePatch([key], profiles), success: true });
                         return;
                     }
                     res.json({ key, message: "No changes to save.", success: true });
@@ -738,9 +1110,8 @@ export function setupChannelRoutes(app) {
                     setProviderSelection(key, matchedVariantKey);
                     await saveUserChannels(result.channels);
                     LOG.info("Channel '%s' reverted to variant '%s' (edit matched variant values).", key, matchedVariantKey);
-                    const rowHtml = generateChannelRowHtml(key, profiles);
-                    res.json({ html: { displayRow: rowHtml.displayRow, editRow: rowHtml.editRow }, key,
-                        message: "Channel '" + key + "' reverted to defaults." + variantRevertHint, success: true });
+                    res.json({ key, message: "Channel '" + key + "' reverted to defaults." + variantRevertHint,
+                        patch: buildChannelTablePatch([key], profiles), success: true });
                     return;
                 }
                 // No variant match — store the delta and switch the provider selection to the canonical key (the custom override). This ensures the provider dropdown shows
@@ -768,6 +1139,10 @@ export function setupChannelRoutes(app) {
                 if (channelNumberStr) {
                     channel.channelNumber = parseInt(channelNumberStr, 10);
                 }
+                // Only store hdhrEnabled when explicitly disabled. Absent = true (included in HDHR lineup by default).
+                if (!hdhrEnabled) {
+                    channel.hdhrEnabled = false;
+                }
                 result.channels[key] = channel;
                 // For adds the playlist always changes. For edits, check whether any M3U-relevant field differs from the old stored values.
                 playlistChanged = (action === "add") ||
@@ -775,18 +1150,21 @@ export function setupChannelRoutes(app) {
                         M3U_FIELDS.some((f) => channel[f] !== oldChannel[f]));
             }
             await saveUserChannels(result.channels);
+            // Trigger a logo lookup for the new or updated station ID. Fire-and-forget - the logo appears on the next page load.
+            if (stationId) {
+                updateChannelLogo(name || key, stationId);
+            }
             const actionLabel = (action === "add") ? "added" : "updated";
             LOG.info("User channel '%s' %s.", key, actionLabel);
             // Generate HTML for the channel row so the client can update the DOM without a full page reload.
-            const rowHtml = generateChannelRowHtml(key, profiles);
             // Append a playlist reload hint when the change affects M3U content that Channels DVR consumes.
             const playlistHint = playlistChanged ? PLAYLIST_HINT : "";
-            // Return success response with HTML for client-side DOM update. Changes take effect immediately due to hot-reloading in saveUserChannels().
+            // Return success response with patch for client-side DOM update. Changes take effect immediately due to hot-reloading in saveUserChannels().
             res.json({
-                html: { displayRow: rowHtml.displayRow, editRow: rowHtml.editRow },
                 isNew: action === "add",
                 key,
                 message: "Channel '" + key + "' " + actionLabel + " successfully." + playlistHint,
+                patch: buildChannelTablePatch([key], profiles),
                 success: true
             });
         }