prismcast 1.6.0 → 1.8.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 { LOG, formatError, generateChannelKey, parseM3U, sanitizeString, stringifySorted } from "../../../utils/index.js";
+import { PREDEFINED_CHANNELS, PREDEFINED_TAGS } from "../../../channels/index.js";
+import { VALID_OPTIONAL_COLUMNS, buildChannelTablePatch, buildChannelTableState, generateTagFilterContent, generateTagManagerBody } 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 { getActiveTagVocabulary, getChannelEffectiveTags, getChannelListing, getEastWithPacificPredefinedKeys, getPacificPredefinedKeys, getPredefinedChannel, getPredefinedChannels, getTagRegistry, getUserChannels, isPredefinedChannel, isUserChannel, loadUserChannels, resolveStoredChannel, saveProviderSelections, saveTagRegistry, saveUserChannels, setTagRegistry, transformChannelTags, validateChannelKey, validateChannelName, validateChannelNumber, validateChannelProfile, validateChannelUrl, validateImportedChannels } from "../../../config/userChannels.js";
 import { CONFIG } from "../../../config/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.
@@ -33,7 +77,7 @@ export function setupChannelRoutes(app) {
             }
             res.setHeader("Content-Type", "application/json");
             res.setHeader("Content-Disposition", "attachment; filename=\"prismcast-channels.json\"");
-            res.send(JSON.stringify(resolved, null, 2) + "\n");
+            res.send(stringifySorted(resolved) + "\n");
         }
         catch (error) {
             LOG.error("Failed to export channels: %s.", formatError(error));
@@ -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. When
+            // canonicalKey is provided, the channel is a provider variant — identity fields (name, stationId) are omitted because they're resolved from the canonical
+            // at runtime via applyVariantInheritance. Standalone channels (no canonicalKey) include all fields.
+            function buildUserChannel(entry, channelName, channelUrl, selector, canonicalKey) {
+                const channel = {
+                    ...(canonicalKey ? { canonicalKey } : { name: channelName }),
+                    channelSelector: selector || undefined,
+                    url: channelUrl
+                };
+                if (!canonicalKey && 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. The canonicalKey parameter tells buildUserChannel to produce a variant
+                    // (provider-specific fields only, no identity fields).
+                    if (!allKeys.has(variantKey)) {
+                        existingChannels[variantKey] = buildUserChannel(entry, name, sanitizeString(entry.url?.trim() ?? ""), sanitizeString(entry.channelSelector?.trim() ?? ""), canonicalKey);
+                        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;
+                }
+                // When the key differs from baseKey, this is a provider variant — pass baseKey as canonicalKey so buildUserChannel produces a variant with only
+                // provider-specific fields. Standalone channels (key === baseKey) get the full channel object with identity fields.
+                const newChannel = buildUserChannel(entry, name, url, channelSelector, (key !== baseKey) ? baseKey : undefined);
+                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,168 @@ 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. Null signals "clear this field" — the normalizer in saveUserChannels() handles the storage conventions.
+                for (const entry of listing) {
+                    const existing = result.channels[entry.key] ?? {};
+                    existing.channelNumber = null;
+                    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] ?? {};
+                existing.hdhrEnabled = enable ? null : 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/channels/bulk-tags - Add or remove a tag on all enabled, provider-available channels. Operates on the same channel set as other bulk actions.
+    // transformChannelTags handles loading, delta normalization, and persistence. Returns a channel table patch for all affected rows and an updated tag manager
+    // modal body.
+    app.post("/config/channels/bulk-tags", async (req, res) => {
+        try {
+            const body = req.body;
+            const action = body.action;
+            const tag = typeof body.tag === "string" ? body.tag.trim().toLowerCase() : "";
+            if ((action !== "add") && (action !== "remove")) {
+                res.status(400).json({ error: "Action must be 'add' or 'remove'.", success: false });
+                return;
+            }
+            if (!tag) {
+                res.status(400).json({ error: "Tag is required.", success: false });
+                return;
+            }
+            // Validate the tag is in the active vocabulary.
+            const vocabulary = new Set(getActiveTagVocabulary());
+            if (!vocabulary.has(tag)) {
+                res.status(400).json({ error: "Unknown tag: " + tag + ".", success: false });
+                return;
+            }
+            const { affectedKeys, error } = await transformChannelTags((entry) => entry.enabled && entry.availableByProvider, (tags) => (action === "add") ? (tags.includes(tag) ? tags : [...tags, tag]) : tags.filter((t) => t !== tag));
+            if (error) {
+                res.status(400).json({ error, success: false });
+                return;
+            }
+            if (affectedKeys.length === 0) {
+                res.json({ affected: 0, message: "No changes needed.", success: true });
+                return;
+            }
+            const verb = (action === "add") ? "added to" : "removed from";
+            LOG.info("Bulk tag %s: %s on %d channels.", action, tag, affectedKeys.length);
+            const profiles = getProfiles();
+            const message = "Tag '" + tag + "' " + verb + " " + String(affectedKeys.length) + " channel(s).";
+            res.json({
+                affected: affectedKeys.length,
+                filterContent: generateTagFilterContent(),
+                message,
+                modalBody: generateTagManagerBody(),
+                patch: buildChannelTablePatch(affectedKeys, profiles),
+                success: true
+            });
+        }
+        catch (error) {
+            LOG.error("Failed to bulk-update tags: %s.", formatError(error));
+            res.status(500).json({ error: "Failed to update tags: " + 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 +729,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 +924,64 @@ 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") && (field !== "tags")) {
+                    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. Null signals
+                // "clear this field" for all channel types — the normalizer in saveUserChannels() handles delta comparison for predefined channels and null-stripping for
+                // user channels.
+                const stored = result.channels[key] ?? {};
+                if (field === "channelNumber") {
+                    stored.channelNumber = value ? parseInt(value, 10) : null;
+                }
+                else if (field === "hdhrEnabled") {
+                    stored.hdhrEnabled = (value === "false") ? false : null;
+                }
+                else if (field === "tags") {
+                    const tags = value ? [...new Set(value.split(",").map((t) => t.trim().toLowerCase()).filter((t) => t.length > 0))].sort() : [];
+                    stored.tags = (tags.length > 0) ? tags : null;
+                }
+                else {
+                    stored.stationId = value || null;
+                }
+                result.channels[key] = stored;
+                await saveUserChannels(result.channels);
+                const fieldLabels = {
+                    channelNumber: "Channel number", hdhrEnabled: "HDHR lineup", stationId: "Station ID", tags: "Tags"
+                };
+                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 +1003,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 +1028,14 @@ export function setupChannelRoutes(app) {
             const stationId = sanitizeString(body.stationId ?? "");
             const channelSelector = sanitizeString(body.channelSelector ?? "");
             const channelNumberStr = sanitizeString(body.channelNumber ?? "");
+            const hdhrEnabled = body.hdhrEnabled !== "false";
+            // Parse tags from comma-separated input. Trim, lowercase, filter empty, sort, deduplicate.
+            const tagsRaw = sanitizeString(body.tags ?? "");
+            const tags = tagsRaw ? [...new Set(tagsRaw.split(",").map((t) => t.trim().toLowerCase()).filter((t) => t.length > 0))].sort() : [];
             // 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,32 +1081,41 @@ 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
                 // may differ from the canonical predefined base when a variant is selected (e.g., the Hulu variant has a different URL and channelSelector). If the submitted
                 // values match the displayChannel exactly, the user saved without modification — no override should be created, and any existing override is preserved.
+                // Tags are compared separately (array comparison) after the scalar fields.
                 const resolvedKey = resolveProviderKey(key);
                 const displayChannel = getResolvedChannel(resolvedKey) ?? predefinedBase;
-                if (Object.keys(formValues).every((field) => formValues[field] === channelValue(displayChannel, field))) {
+                const displayTags = getChannelEffectiveTags(displayChannel);
+                const scalarUnchanged = Object.keys(formValues).every((field) => formValues[field] === channelValue(displayChannel, field));
+                const tagsUnchanged = JSON.stringify(tags) === JSON.stringify(displayTags);
+                if (scalarUnchanged && tagsUnchanged) {
                     res.json({ key, message: "No changes to save.", success: true });
                     return;
                 }
                 // Second check: compute a delta against the canonical predefined base. This determines whether the user's changes create a custom override or effectively
-                // revert the channel to predefined defaults. Changed fields store their new value; empty/undefined fields store null (explicit clear).
+                // revert the channel to predefined defaults. Changed fields store their new value; empty/undefined fields store null (explicit clear). Tags are handled
+                // separately from the scalar loop since they require array comparison.
                 const delta = {};
                 let hasChanges = false;
                 for (const field of Object.keys(formValues)) {
@@ -692,8 +1125,17 @@ export function setupChannelRoutes(app) {
                         hasChanges = true;
                     }
                 }
-                // Helper to check if form values match a given channel's properties.
-                const formMatchesChannel = (ch) => Object.keys(formValues).every((field) => formValues[field] === channelValue(ch, field));
+                // Tags delta: compare the submitted tags against the predefined base's vocabulary-filtered tags. Using effective tags (not raw) ensures that editing an
+                // unrelated field while a predefined tag is deleted from the vocabulary doesn't spuriously bake the deletion into the channel's stored delta.
+                const predefinedEffectiveTags = getChannelEffectiveTags(predefinedBase);
+                if (JSON.stringify(tags) !== JSON.stringify(predefinedEffectiveTags)) {
+                    delta.tags = (tags.length > 0) ? tags : null;
+                    hasChanges = true;
+                }
+                // Helper to check if form values (scalars + tags) match a given channel's properties. Tags use vocabulary-filtered comparison so variant matching works
+                // correctly when predefined tags are deleted from the vocabulary.
+                const formMatchesChannel = (ch) => Object.keys(formValues).every((field) => formValues[field] === channelValue(ch, field)) &&
+                    (JSON.stringify(tags) === JSON.stringify(getChannelEffectiveTags(ch)));
                 if (!hasChanges) {
                     // The submitted values match the predefined base exactly. If an override exists, this means the user edited their customizations away — treat it as an
                     // implicit revert by removing the override and returning the predefined row HTML.
@@ -702,9 +1144,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 +1179,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 +1208,13 @@ export function setupChannelRoutes(app) {
                 if (channelNumberStr) {
                     channel.channelNumber = parseInt(channelNumberStr, 10);
                 }
+                if (tags.length > 0) {
+                    channel.tags = tags;
+                }
+                // 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 +1222,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
             });
         }
@@ -795,5 +1245,233 @@ export function setupChannelRoutes(app) {
             res.status(500).json({ message: "Failed to save channel: " + formatError(error), success: false });
         }
     });
+    // Tag Management Endpoints.
+    // GET /config/tags - Returns the tag vocabulary and registry state. The active vocabulary is the computed merge of predefined tags (minus deleted) plus user
+    // tags. The registry contains the raw user state for the tag management UI.
+    app.get("/config/tags", (_req, res) => {
+        res.json({
+            active: getActiveTagVocabulary(),
+            predefined: [...PREDEFINED_TAGS],
+            registry: getTagRegistry(),
+            success: true
+        });
+    });
+    // POST /config/tags - Create a new user tag. Validates the tag name (lowercase alphanumeric + hyphens, max 30 chars) and checks for duplicates against the
+    // active vocabulary and deleted predefined tags (which should be restored, not re-created).
+    app.post("/config/tags", async (req, res) => {
+        try {
+            const body = req.body;
+            const tag = typeof body.tag === "string" ? body.tag.trim().toLowerCase() : "";
+            if (tag.length === 0) {
+                res.status(400).json({ error: "Tag name is required.", success: false });
+                return;
+            }
+            if (tag.length > 30) {
+                res.status(400).json({ error: "Tag name must be 30 characters or less.", success: false });
+                return;
+            }
+            if (!(/^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/).test(tag)) {
+                res.status(400).json({ error: "Tag name must start and end with a letter or number, and contain only lowercase letters, numbers, and hyphens.", success: false });
+                return;
+            }
+            // Check if the tag already exists in the active vocabulary.
+            const vocabulary = new Set(getActiveTagVocabulary());
+            if (vocabulary.has(tag)) {
+                res.status(409).json({ error: "Tag '" + tag + "' already exists.", success: false });
+                return;
+            }
+            // Check if the tag is a deleted predefined tag — the user should restore it instead of creating a duplicate.
+            const registry = getTagRegistry();
+            if (registry.deletedTags.includes(tag)) {
+                res.status(409).json({ error: "Tag '" + tag + "' is a deleted predefined tag. Use restore instead of creating a new one.", success: false });
+                return;
+            }
+            // Add the tag to the user registry and persist. No channels are affected (new tag has no assignments yet).
+            registry.tags.push(tag);
+            setTagRegistry(registry);
+            await saveTagRegistry();
+            LOG.info("Created tag: %s.", tag);
+            res.json({
+                active: getActiveTagVocabulary(), filterContent: generateTagFilterContent(), modalBody: generateTagManagerBody(),
+                registry: getTagRegistry(), success: true
+            });
+        }
+        catch (error) {
+            LOG.error("Failed to create tag: %s.", formatError(error));
+            res.status(500).json({ error: "Failed to create tag: " + formatError(error), success: false });
+        }
+    });
+    // DELETE /config/tags/:tag - Delete a tag from the vocabulary and cascade to all channel assignments. For predefined tags, the tag is added to deletedTags. For
+    // user-created tags, the tag is removed from the user registry. In both cases, the tag is stripped from every channel that has it — predefined channels via delta
+    // override, user channels via direct modification. This ensures re-creating a tag with the same name starts fresh with no ghost assignments.
+    app.delete("/config/tags/:tag", async (req, res) => {
+        try {
+            const tag = req.params.tag?.toLowerCase() ?? "";
+            if (tag.length === 0) {
+                res.status(400).json({ error: "Tag name is required.", success: false });
+                return;
+            }
+            const registry = getTagRegistry();
+            const isPredefined = PREDEFINED_TAGS.includes(tag);
+            const isUserTag = registry.tags.includes(tag);
+            if (!isPredefined && !isUserTag) {
+                res.status(404).json({ error: "Tag '" + tag + "' not found.", success: false });
+                return;
+            }
+            if (isPredefined) {
+                // Already deleted — no-op, return current state without unnecessary I/O.
+                if (registry.deletedTags.includes(tag)) {
+                    res.json({
+                        active: getActiveTagVocabulary(), filterContent: generateTagFilterContent(), modalBody: generateTagManagerBody(),
+                        registry: getTagRegistry(), success: true
+                    });
+                    return;
+                }
+                registry.deletedTags.push(tag);
+            }
+            else {
+                // Remove from user tags.
+                registry.tags = registry.tags.filter((t) => t !== tag);
+            }
+            setTagRegistry(registry);
+            // Cascade: strip the deleted tag from all channel assignments. transformChannelTags handles loading, delta normalization, and persistence.
+            const { affectedKeys, error } = await transformChannelTags((entry) => entry.channel.tags?.includes(tag) === true, (tags) => tags.filter((t) => t !== tag));
+            if (error) {
+                res.status(400).json({ error, success: false });
+                return;
+            }
+            LOG.info("Deleted tag '%s' from vocabulary and %d channel assignments.", tag, affectedKeys.length);
+            const profiles = getProfiles();
+            res.json({
+                active: getActiveTagVocabulary(),
+                filterContent: generateTagFilterContent(), modalBody: generateTagManagerBody(),
+                patch: (affectedKeys.length > 0) ? buildChannelTablePatch(affectedKeys, profiles) : undefined,
+                registry: getTagRegistry(),
+                success: true
+            });
+        }
+        catch (error) {
+            LOG.error("Failed to delete tag: %s.", formatError(error));
+            res.status(500).json({ error: "Failed to delete tag: " + formatError(error), success: false });
+        }
+    });
+    // POST /config/tags/restore - Restore a previously deleted predefined tag. Removes it from deletedTags so it reappears in the active vocabulary, then
+    // cascade-restores the tag on predefined channels whose definition includes it. This reverses the cascade delete — predefined channels go back to their default
+    // tag assignments. User channels are not affected (their tag assignments were permanently removed during cascade delete with no source of truth to restore from).
+    app.post("/config/tags/restore", async (req, res) => {
+        try {
+            const body = req.body;
+            const tag = typeof body.tag === "string" ? body.tag.trim().toLowerCase() : "";
+            if (tag.length === 0) {
+                res.status(400).json({ error: "Tag name is required.", success: false });
+                return;
+            }
+            const registry = getTagRegistry();
+            if (!registry.deletedTags.includes(tag)) {
+                res.status(404).json({ error: "Tag '" + tag + "' is not a deleted predefined tag.", success: false });
+                return;
+            }
+            registry.deletedTags = registry.deletedTags.filter((t) => t !== tag);
+            setTagRegistry(registry);
+            // Cascade-restore: add the tag back to predefined channels whose definition includes it but whose current resolved tags don't (stripped during cascade
+            // delete). transformChannelTags handles loading, delta normalization, and persistence. The normalizer strips the tags delta when the result matches the
+            // predefined definition, cleanly reverting the channel to its default state.
+            const { affectedKeys, error } = await transformChannelTags((entry) => {
+                const predefined = getPredefinedChannel(entry.key);
+                return (predefined?.tags?.includes(tag) === true) && (entry.channel.tags?.includes(tag) !== true);
+            }, (tags) => [...tags, tag]);
+            if (error) {
+                res.status(400).json({ error, success: false });
+                return;
+            }
+            LOG.info("Restored predefined tag '%s' on %d channels.", tag, affectedKeys.length);
+            const profiles = getProfiles();
+            res.json({
+                active: getActiveTagVocabulary(),
+                filterContent: generateTagFilterContent(), modalBody: generateTagManagerBody(),
+                patch: (affectedKeys.length > 0) ? buildChannelTablePatch(affectedKeys, profiles) : undefined,
+                registry: getTagRegistry(),
+                success: true
+            });
+        }
+        catch (error) {
+            LOG.error("Failed to restore tag: %s.", formatError(error));
+            res.status(500).json({ error: "Failed to restore tag: " + formatError(error), success: false });
+        }
+    });
+    // POST /config/tags/rename - Rename a tag atomically across the vocabulary and all channel assignments. For predefined tags, the old name is added to
+    // deletedTags and the new name is added to user tags. For user tags, the old name is replaced with the new name. All channels with the old tag get the
+    // new tag substituted in their stored data (predefined channels via delta, user channels via direct modification).
+    app.post("/config/tags/rename", async (req, res) => {
+        try {
+            const body = req.body;
+            const oldTag = typeof body.oldTag === "string" ? body.oldTag.trim().toLowerCase() : "";
+            const newTag = typeof body.newTag === "string" ? body.newTag.trim().toLowerCase() : "";
+            if (!oldTag || !newTag) {
+                res.status(400).json({ error: "Both old and new tag names are required.", success: false });
+                return;
+            }
+            if (oldTag === newTag) {
+                res.status(400).json({ error: "New tag name must differ from the old name.", success: false });
+                return;
+            }
+            if (!(/^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/).test(newTag)) {
+                res.status(400).json({
+                    error: "Tag name must start and end with a letter or number, and contain only lowercase letters, numbers, and hyphens.", success: false
+                });
+                return;
+            }
+            if (newTag.length > 30) {
+                res.status(400).json({ error: "Tag name must be 30 characters or less.", success: false });
+                return;
+            }
+            // Validate old tag exists in the active vocabulary.
+            const vocabulary = new Set(getActiveTagVocabulary());
+            if (!vocabulary.has(oldTag)) {
+                res.status(404).json({ error: "Tag '" + oldTag + "' not found.", success: false });
+                return;
+            }
+            // Validate new tag doesn't already exist.
+            if (vocabulary.has(newTag)) {
+                res.status(409).json({ error: "Tag '" + newTag + "' already exists.", success: false });
+                return;
+            }
+            // Update the tag registry: replace old with new in the appropriate list.
+            const registry = getTagRegistry();
+            const oldIsPredefined = PREDEFINED_TAGS.includes(oldTag);
+            if (oldIsPredefined) {
+                // Predefined tag: "delete" the old (add to deletedTags) and create the new as a user tag.
+                if (!registry.deletedTags.includes(oldTag)) {
+                    registry.deletedTags.push(oldTag);
+                }
+                registry.tags.push(newTag);
+            }
+            else {
+                // User tag: replace in the user tags list.
+                registry.tags = registry.tags.map((t) => (t === oldTag) ? newTag : t);
+            }
+            setTagRegistry(registry);
+            // Cascade: substitute the old tag with the new tag across all channel assignments. transformChannelTags handles loading, delta normalization, and persistence.
+            const { affectedKeys, error } = await transformChannelTags((entry) => entry.channel.tags?.includes(oldTag) === true, (tags) => tags.map((t) => (t === oldTag) ? newTag : t));
+            if (error) {
+                res.status(400).json({ error, success: false });
+                return;
+            }
+            LOG.info("Renamed tag '%s' to '%s' across %d channels.", oldTag, newTag, affectedKeys.length);
+            const profiles = getProfiles();
+            res.json({
+                active: getActiveTagVocabulary(),
+                filterContent: generateTagFilterContent(),
+                modalBody: generateTagManagerBody(),
+                patch: (affectedKeys.length > 0) ? buildChannelTablePatch(affectedKeys, profiles) : undefined,
+                registry: getTagRegistry(),
+                success: true
+            });
+        }
+        catch (error) {
+            LOG.error("Failed to rename tag: %s.", formatError(error));
+            res.status(500).json({ error: "Failed to rename tag: " + formatError(error), success: false });
+        }
+    });
 }
 //# sourceMappingURL=routes.js.map