prismcast 1.9.0 → 1.10.0

package/dist/config/services.js

@@ -1,17 +1,15 @@
-/* Copyright(C) 2024-2026, HJD (https://github.com/hjdhjd). All rights reserved.
- *
- * services.ts: Service group management for multi-service channels.
- */
-import { CHANNEL_IDENTITY_FIELDS, PREDEFINED_CHANNELS } from "../channels/index.js";
 import { DOMAIN_CONFIG, getDomainConfig } from "./sites.js";
 import { LOG, extractDomain } from "../utils/index.js";
-import { getChannelEffectiveTags } from "./userChannels.js";
+import { getChannelEffectiveTags, getEffectiveHdhrEnabled, mutateChannels, pickIdentity } from "./userChannels.js";
+import { CONFIG } from "./index.js";
+import { PREDEFINED_CHANNELS } from "../channels/index.js";
 import { getProfileForChannel } from "./profiles.js";
 import { getUserDomains } from "./userProfiles.js";
+import { mutateConfig } from "./userConfig.js";
 /* Service groups allow multiple streaming services to offer the same content. For example, ESPN can be watched via ESPN.com (native) or Disney+.
  *
- * All variant relationships — predefined and user-defined — are expressed via the canonicalKey field on Channel. The flattener sets canonicalKey on predefined
- * variant entries, the browse modal sets it on user variant entries, and the one-time migration stamps it on pre-existing user entries. buildServiceGroups
+ * All variant relationships - predefined and user-defined - are expressed via the canonicalKey field on Channel. The flattener sets canonicalKey on predefined
+ * variant entries, the browse modal sets it on user variant entries, and the schema-version migration stamps it on entries that lack it. buildServiceGroups
  * scans all channels once and groups by canonicalKey. One field, one mechanism, one code path.
  *
  * User overrides: When a user defines a channel with the same key as a predefined channel, both versions appear in the service dropdown. The user's custom version
@@ -21,11 +19,12 @@ import { getUserDomains } from "./userProfiles.js";
  * User selections are stored in channels.json (in the data directory) under the `serviceSelections` key and persist across restarts.
  */
 // Suffix appended to channel keys to reference the original predefined channel when a user has overridden it. For example, "espn:predefined" references the original
-// predefined ESPN channel when the user has created a custom "espn" entry.
-const PREDEFINED_SUFFIX = ":predefined";
+// predefined ESPN channel when the user has created a custom "espn" entry. Exported so other modules (e.g., channelForm) can detect synthetic entries via the
+// canonical constant instead of stringly-typed substring checks.
+export const PREDEFINED_SUFFIX = ":predefined";
 /**
  * Strips the :predefined suffix from a channel key if present, returning the base key. Synthetic keys like "pbs:predefined" are created when a user overrides a
- * predefined channel — the original predefined entry gets this suffix to coexist with the user's custom version in the service dropdown. Functions that look up
+ * predefined channel - the original predefined entry gets this suffix to coexist with the user's custom version in the service dropdown. Functions that look up
  * channel data by key must strip the suffix to find the actual channel entry.
  * @param key - The channel key, possibly with :predefined suffix.
  * @returns The base key without the suffix.
@@ -35,7 +34,8 @@ function stripPredefinedSuffix(key) {
 }
 // Module-level storage for service groups, keyed by canonical channel key.
 const serviceGroups = new Map();
-// Reference to the channels map for inheritance resolution.
+// Reference to the resolved channels map (post canonical+variant inheritance). All consumer reads go through here, so it stores ResolvedChannel values where
+// every entry has both identity and binding populated.
 let channelsRef = {};
 // User's service selections, keyed by canonical channel key. Values are the selected service key (e.g., "espn-disneyplus").
 let serviceSelections = new Map();
@@ -63,7 +63,7 @@ function resolveServiceTag(channel) {
 /**
  * Gets the service tag for a channel key. For channels in a service group, reads the pre-computed tag from the group variant entry (computed at group-building
  * time by buildServiceGroups). For standalone channels not in any group, derives the tag from the channel's URL domain. This function should not be called with
- * :predefined synthetic keys — those only exist inside service groups and their tags are available via the group's variant entries.
+ * :predefined synthetic keys - those only exist inside service groups and their tags are available via the group's variant entries.
  * @param key - The channel key.
  * @returns The service tag string.
  */
@@ -79,14 +79,13 @@ export function getServiceTagForChannel(key) {
     }
     // For standalone channels not in any group, derive from the channel's URL domain.
     const channel = channelsRef[effectiveKey] ?? PREDEFINED_CHANNELS[effectiveKey];
-    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
     if (!channel) {
         return "direct";
     }
     return resolveServiceTag(channel);
 }
 /**
- * Returns the auth domain for a channel key. Domain is the natural auth boundary — browser cookies and sessions scope to it. Multi-channel services work correctly
+ * Returns the auth domain for a channel key. Domain is the natural auth boundary - browser cookies and sessions scope to it. Multi-channel services work correctly
  * because all their channels share one domain, and canonical channels work correctly because each has its own domain.
  * @param key - The channel key.
  * @returns The extracted domain from the channel's URL, or empty string if the channel or URL cannot be resolved.
@@ -94,7 +93,6 @@ export function getServiceTagForChannel(key) {
 export function getAuthDomainForChannel(key) {
     const effectiveKey = stripPredefinedSuffix(key);
     const channel = channelsRef[effectiveKey] ?? PREDEFINED_CHANNELS[effectiveKey];
-    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
     if (!channel?.url) {
         return "";
     }
@@ -111,7 +109,7 @@ export function getChannelServiceTags(canonicalKey) {
     if (group) {
         const tags = new Set();
         for (const variant of group.variants) {
-            // Skip predefined suffix variants — they share the canonical's tag (but derived from the predefined URL, which may differ from the user override).
+            // Skip predefined suffix variants - they share the canonical's tag (but derived from the predefined URL, which may differ from the user override).
             if (variant.key.endsWith(PREDEFINED_SUFFIX)) {
                 continue;
             }
@@ -119,7 +117,7 @@ export function getChannelServiceTags(canonicalKey) {
         }
         return [...tags];
     }
-    // Standalone channel — derive tag from the channel directly.
+    // Standalone channel - derive tag from the channel directly.
     return [getServiceTagForChannel(canonicalKey)];
 }
 /**
@@ -132,7 +130,7 @@ export function getAllServiceTags() {
     // Scan all channels (not just grouped ones) to find all service tags.
     const allKeys = new Set([...Object.keys(channelsRef), ...Object.keys(PREDEFINED_CHANNELS)]);
     for (const key of allKeys) {
-        // Skip variant keys — they are covered by getChannelServiceTags() on the canonical.
+        // Skip variant keys - they are covered by getChannelServiceTags() on the canonical.
         const group = serviceGroups.get(key);
         if (group && (group.canonicalKey !== key)) {
             continue;
@@ -189,11 +187,31 @@ export function getEnabledServices() {
     return [...enabledServices];
 }
 /**
- * Sets the enabled service tags. Empty array means "no filter" (all services shown).
- * @param tags - The service tags to enable.
+ * Hydrates the in-memory enabled-services cache from a serialized list. Called by initializeUserChannels at startup with the validated tags list and by the
+ * consistency probe's auto-fix after stripping unknown tags. Never called by route code directly - mutations go through mutateEnabledServices, which is the
+ * single async path that updates both the cache and the persisted file in one atomic operation.
+ * @param tags - The service tags to load into the cache. Empty array means "no filter" (all services shown).
  */
 export function setEnabledServices(tags) {
     enabledServices = [...tags];
+    CONFIG.channels.enabledServices = [...tags];
+}
+/**
+ * Persists a new enabled-services list through the file store. Goes through mutateConfig so the file write, snapshot machinery, and post-mutate cache update
+ * all run uniformly - after the call returns, both disk and the module-state cache reflect the new value. Empty array means "no filter" (all services shown).
+ * @param tags - The new enabled service tags.
+ * @throws FileStoreParseError if config.json contains invalid JSON and the .bak rotation is also unparseable.
+ */
+export async function mutateEnabledServices(tags) {
+    const next = [...tags];
+    await mutateConfig((config) => {
+        config.channels ??= {};
+        config.channels.enabledServices = next;
+    });
+    // Module-state cache hydration after successful write. Mirrors the post-mutate hydration done in mutateChannels for serviceSelections and tagRegistry,
+    // keeping the in-memory view consistent with what was just persisted.
+    enabledServices = next;
+    CONFIG.channels.enabledServices = next;
 }
 /**
  * Checks if a service tag is currently enabled. Returns true if the tag is enabled, if no filter is active (empty set), or if the tag is "direct".
@@ -201,7 +219,7 @@ export function setEnabledServices(tags) {
  * @returns True if the service is available.
  */
 export function isServiceTagEnabled(tag) {
-    // No filter active — all services are enabled.
+    // No filter active - all services are enabled.
     if (enabledServices.length === 0) {
         return true;
     }
@@ -217,7 +235,7 @@ export function isServiceTagEnabled(tag) {
  * @returns True if the channel passes the service filter.
  */
 export function isChannelAvailableByService(canonicalKey) {
-    // No filter active — all channels are available.
+    // No filter active - all channels are available.
     if (enabledServices.length === 0) {
         return true;
     }
@@ -225,7 +243,7 @@ export function isChannelAvailableByService(canonicalKey) {
     return tags.some((tag) => isServiceTagEnabled(tag));
 }
 /**
- * Checks if a channel in the merged map is a user override of a predefined channel. This uses object reference comparison — getAllChannels() spreads
+ * Checks if a channel in the merged map is a user override of a predefined channel. This uses object reference comparison - getAllChannels() spreads
  * PREDEFINED_CHANNELS directly into the result, so if the reference differs, a user channel has replaced the predefined one.
  * @param key - The channel key to check.
  * @param channels - The merged channel map.
@@ -237,16 +255,14 @@ function isUserOverride(key, channels) {
     return Boolean(predefined) && (channels[key] !== predefined);
 }
 /**
- * Builds service groups by scanning all channels and grouping by canonicalKey. Variant entries declare their canonical via the canonicalKey field (set by the
- * flattener for predefined channels, by the browse modal for user channels, and by the one-time migration for pre-existing user entries). This is a single
- * pass over the merged channel map — one field, one mechanism for both predefined and user-defined variant relationships.
+ * Builds service groups by scanning all channels and grouping by canonicalKey. The flattener sets canonicalKey on predefined variants, the browse modal sets it
+ * on user variants, and the schema-version migration stamps it on entries that lack it. One field, one mechanism, one pass.
  *
  * User overrides of predefined channels (same key, different object reference) produce a two-entry group with "Custom" and the original predefined version,
  * even for single-service channels that don't have canonicalKey-based variants.
  *
- * After building groups, validates stored service selections against the new variant structure and reverts any stale selections to the canonical default. This
- * catches all staleness sources in one place: service key renames across versions, variant removal in code, user-deleted custom variants, and reverted
- * predefined overrides.
+ * After grouping, every stored service selection is validated against the rebuilt variant structure. Selections that no longer correspond to a real variant are
+ * reverted to the canonical default. This is the single resolution boundary for stale selections; read-side resolvers stay pure.
  * @param channels - The merged channel map (predefined + user channels).
  * @returns Canonical keys whose service selections were stale and reverted. Empty array if all selections are valid. The caller decides whether to persist.
  */
@@ -270,20 +286,24 @@ export function buildServiceGroups(channels) {
     // Pass 2: Build groups from the collected variants.
     for (const [canonicalKey, variantKeys] of variantsByCanonical) {
         const canonical = channels[canonicalKey];
-        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
         if (!canonical) {
             continue;
         }
         const variants = [];
         // Handle user override of the canonical entry. Two scenarios: (A) the user customized properties (station ID, tags, etc.) but the URL still matches a known
-        // service domain — no "Custom" variant needed, just the normal service label with a visual override indicator in the table; (B) the user set a genuinely
-        // non-standard URL — "Custom (domain)" is a real service variant and the :predefined entry gives access to the original service URL.
-        if (isUserOverride(canonicalKey, channels)) {
-            const predefined = PREDEFINED_CHANNELS[canonicalKey];
+        // service domain - no "Custom" variant needed, just the normal service label with a visual override indicator in the table; (B) the user set a genuinely
+        // non-standard URL - "Custom (domain)" is a real service variant and the :predefined entry gives access to the original service URL.
+        // isUserOverride returned true means predefined exists for canonicalKey (it's defined as `Boolean(predefined) && (channels[key] !== predefined)`). Look it
+        // up here and narrow away the undefined so the scenarios below can rely on the predefined reference.
+        const predefined = isUserOverride(canonicalKey, channels) ? PREDEFINED_CHANNELS[canonicalKey] : undefined;
+        if (predefined) {
             const userDomain = extractDomain(canonical.url);
             const knownDomains = new Set([extractDomain(predefined.url)]);
             for (const variantKey of variantKeys) {
-                knownDomains.add(extractDomain(channels[variantKey].url));
+                const variantChannel = channels[variantKey];
+                if (variantChannel) {
+                    knownDomains.add(extractDomain(variantChannel.url));
+                }
             }
             if (knownDomains.has(userDomain)) {
                 // Scenario A: property override on a known service. The canonical gets the same label as if it weren't overridden. The modified-dot indicator in the
@@ -304,7 +324,10 @@ export function buildServiceGroups(channels) {
         variantKeys.sort();
         for (const variantKey of variantKeys) {
             const variant = channels[variantKey];
-            variants.push({ key: variantKey, label: getChannelServiceLabel(variant), tag: resolveServiceTag(variant) });
+            // Defensive: every variantKey in variantKeys came from Pass 1's scan of this same channels map, so the lookup succeeds. The narrowing keeps the types honest.
+            if (variant) {
+                variants.push({ key: variantKey, label: getChannelServiceLabel(variant), tag: resolveServiceTag(variant) });
+            }
         }
         const group = { canonicalKey, variants };
         // Map canonical and all variant keys to this group for easy lookup.
@@ -314,7 +337,7 @@ export function buildServiceGroups(channels) {
         }
         LOG.debug("config:general", "Service group '%s': variants=%s.", canonicalKey, variants.map((v) => v.key).join(", "));
     }
-    // Pass 3: Create groups for user overrides of single-service predefined channels. Only Scenario B (genuinely custom URL) gets a service group — the user needs
+    // Pass 3: Create groups for user overrides of single-service predefined channels. Only Scenario B (genuinely custom URL) gets a service group - the user needs
     // a dropdown to switch between their custom URL and the predefined service. Scenario A (property override on the same domain) skips group creation entirely
     // because there is only one service and no dropdown is needed; the modified-dot indicator in the table renderer signals the override.
     for (const key of Object.keys(channels)) {
@@ -326,7 +349,12 @@ export function buildServiceGroups(channels) {
         }
         const userChannel = channels[key];
         const predefined = PREDEFINED_CHANNELS[key];
-        // Scenario A: URL domain matches the predefined service. No service group needed — renders as a single-service channel with a modified-dot indicator.
+        // Defensive: isUserOverride returning true means both predefined and the user entry exist. The narrowing here satisfies the type-checker and guards
+        // against an impossible edge case.
+        if (!userChannel || !predefined) {
+            continue;
+        }
+        // Scenario A: URL domain matches the predefined service. No service group needed - renders as a single-service channel with a modified-dot indicator.
         if (extractDomain(userChannel.url) === extractDomain(predefined.url)) {
             continue;
         }
@@ -343,7 +371,7 @@ export function buildServiceGroups(channels) {
     // channel. Scans only canonical entries in PREDEFINED_CHANNELS (variants share the canonical's URL domain and would produce duplicate results).
     predefinedByDomain.clear();
     for (const [key, channel] of Object.entries(PREDEFINED_CHANNELS)) {
-        if (channel.canonicalKey) {
+        if (channel.canonicalKey !== undefined) {
             continue;
         }
         const domain = extractDomain(channel.url);
@@ -357,9 +385,8 @@ export function buildServiceGroups(channels) {
             predefinedByDomain.set(domain, [entry]);
         }
     }
-    // Validate stored service selections against the rebuilt groups. Any selection whose variant key no longer exists in the group is stale and reverted to the
-    // canonical default. This handles all staleness sources: service key renames across versions, variant removal, user-deleted custom variants, and reverted
-    // predefined overrides. The caller decides whether to persist based on whether any keys were cleaned.
+    // Validate stored service selections against the rebuilt groups. Any selection whose variant key is not present in the group is stale and reverted to the
+    // canonical default. The caller decides whether to persist based on whether any keys were cleaned.
     const staleKeys = [];
     for (const [canonicalKey, selection] of serviceSelections) {
         const group = serviceGroups.get(canonicalKey);
@@ -400,7 +427,7 @@ export function getPredefinedDomainMap() {
 /**
  * Resolves a URL to a friendly service display name. Checks built-in DOMAIN_CONFIG first for a stable, well-known service name, then falls back to
  * getDomainConfig() which includes user domain mappings. This ordering prevents user domain overrides from corrupting display labels for predefined channel
- * variants — a user mapping a built-in domain to a custom profile should not rename every service dropdown entry that uses that domain.
+ * variants - a user mapping a built-in domain to a custom profile should not rename every service dropdown entry that uses that domain.
  * @param url - The URL to resolve a service display name for.
  * @returns The service display name, or the concise domain if no service name is configured.
  */
@@ -410,19 +437,17 @@ export function getServiceDisplayName(url) {
     try {
         const hostname = new URL(url).hostname;
         const builtinFull = DOMAIN_CONFIG[hostname];
-        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
         if (builtinFull?.service) {
             return builtinFull.service;
         }
         const concise = extractDomain(url);
         const builtinConcise = DOMAIN_CONFIG[concise];
-        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
         if (builtinConcise?.service) {
             return builtinConcise.service;
         }
     }
     catch {
-        // Invalid URL — fall through to getDomainConfig.
+        // Invalid URL - fall through to getDomainConfig.
     }
     // For domains not in DOMAIN_CONFIG, fall back to getDomainConfig() which includes user domain mappings.
     const config = getDomainConfig(url);
@@ -430,7 +455,7 @@ export function getServiceDisplayName(url) {
 }
 /**
  * Resolves service identity (tag and display name) for a user-defined profile by scanning its domain mappings. Returns the first matching domain config's
- * serviceTag and service name. This is the single source of truth for "profile key → service identity" resolution, used by both tag and label lookups to avoid
+ * serviceTag and service name. This is the single source of truth for "profile key -> service identity" resolution, used by both tag and label lookups to avoid
  * duplicating the domain scan logic.
  * @param profileKey - The user profile key to resolve.
  * @returns The service identity from the profile's domain mappings, or undefined if no matching domain mapping exists.
@@ -477,7 +502,7 @@ export const VALID_SORT_FIELDS = new Set(["channelNumber", "channelSelector", "h
  * @returns A lowercase string suitable for comparison-based sorting.
  */
 export function getChannelSortKey(channel, key, field) {
-    // Resolve the selected service variant so all sort keys reflect the user's service selection. For URL-dependent fields (profile, service), this is essential —
+    // Resolve the selected service variant so all sort keys reflect the user's service selection. For URL-dependent fields (profile, service), this is essential -
     // a canonical's URL may differ from the selected variant's (e.g., bbcnews canonical uses cox but the user selected the directv variant). For identity fields
     // (name, stationId, channelNumber), the flattener eagerly sets these on all entries, so the resolved channel has identical values regardless of variant.
     const effective = getResolvedChannel(resolveServiceKey(key)) ?? channel;
@@ -490,8 +515,9 @@ export function getChannelSortKey(channel, key, field) {
             return (effective.channelSelector ?? "").toLowerCase();
         }
         case "hdhrEnabled": {
-            // Sort enabled channels before disabled. "0" (enabled/absent) sorts before "1" (disabled).
-            return (effective.hdhrEnabled === false) ? "1" : "0";
+            // Sort enabled channels before disabled. "0" (enabled/absent) sorts before "1" (disabled). The effective-view helper centralizes the implicit-true
+            // convention so the sort key here, the table's checked attribute, and every other consumer agree on the meaning of an absent value.
+            return getEffectiveHdhrEnabled(effective) ? "0" : "1";
         }
         case "key": {
             return key.toLowerCase();
@@ -531,8 +557,8 @@ export function getChannelSortKey(channel, key, field) {
 }
 /**
  * Compares two channels for sorting by the specified field and direction with a built-in channel name tiebreaker. The tiebreaker is always ascending so that rows
- * within each group maintain a consistent alphabetical order regardless of the primary sort direction. This is the single comparator for all sort sites — server HTML
- * render, client re-sort, and M3U playlist — to prevent ordering divergence.
+ * within each group maintain a consistent alphabetical order regardless of the primary sort direction. This is the single comparator for all sort sites - server HTML
+ * render, client re-sort, and M3U playlist - to prevent ordering divergence.
  * @param channelA - First channel definition.
  * @param keyA - First channel key.
  * @param channelB - Second channel definition.
@@ -592,14 +618,15 @@ export function getCanonicalKey(key) {
     return group?.canonicalKey ?? baseKey;
 }
 /**
- * Sets the user's service selections. Called when loading from channels.json.
+ * Hydrates the in-memory selections cache from a serialized record. Called by mutateChannels' post-write hook (with the freshly-written disk state) and by
+ * initializeUserChannels at startup. Never called by route code directly - mutations go through setServiceSelection (single) or mutateServiceSelections (bulk).
  * @param selections - Service selections keyed by canonical channel key.
  */
 export function setServiceSelections(selections) {
     serviceSelections = new Map(Object.entries(selections));
 }
 /**
- * Gets all service selections.
+ * Gets all service selections from the in-memory cache. Cache is hydrated from disk on every successful mutate, so this is always consistent with the file.
  * @returns Copy of the service selections object.
  */
 export function getServiceSelections() {
@@ -614,39 +641,66 @@ export function getServiceSelection(canonicalKey) {
     return serviceSelections.get(canonicalKey);
 }
 /**
- * Sets the service selection for a channel.
+ * Persists a single service selection through the file store. Goes through mutateChannels so the file write, integrity validation, and post-mutate cache
+ * hydration all run uniformly - after the call returns, both disk and the module-state Map reflect the new value. Selecting the canonical key itself (the
+ * default service) deletes the selection rather than storing a redundant entry.
+ *
+ * For bulk updates, prefer mutateServiceSelections to coalesce multiple changes into a single atomic write.
  * @param canonicalKey - The canonical channel key.
- * @param serviceKey - The selected service key.
+ * @param serviceKey - The selected service key. When equal to canonicalKey, the selection is removed.
+ * @throws FileStoreParseError if channels.json contains invalid JSON and the .bak rotation is also unparseable.
  */
-export function setServiceSelection(canonicalKey, serviceKey) {
-    // If selecting the canonical (default), remove the selection instead of storing it.
-    if (serviceKey === canonicalKey) {
-        serviceSelections.delete(canonicalKey);
-    }
-    else {
-        serviceSelections.set(canonicalKey, serviceKey);
-    }
+export async function setServiceSelection(canonicalKey, serviceKey) {
+    await mutateChannels((data) => {
+        if (serviceKey === canonicalKey) {
+            Reflect.deleteProperty(data.serviceSelections, canonicalKey);
+        }
+        else {
+            data.serviceSelections[canonicalKey] = serviceKey;
+        }
+    });
+}
+/**
+ * Bulk variant of setServiceSelection. Applies multiple selection changes inside a single mutate transaction so all changes land atomically with one disk
+ * write. Use this whenever a single user action (e.g., browse-modal submit, bulk service assignment) updates more than one selection - serial awaits over
+ * setServiceSelection would produce N writes and N intermediate disk states.
+ *
+ * Each entry follows the same canonical-key-equals-service-key convention as setServiceSelection: when the value matches the key, the selection is removed.
+ * @param updates - Object mapping canonical channel keys to their new service keys.
+ * @throws FileStoreParseError if channels.json contains invalid JSON and the .bak rotation is also unparseable.
+ */
+export async function mutateServiceSelections(updates) {
+    await mutateChannels((data) => {
+        for (const [canonicalKey, serviceKey] of Object.entries(updates)) {
+            if (serviceKey === canonicalKey) {
+                Reflect.deleteProperty(data.serviceSelections, canonicalKey);
+            }
+            else {
+                data.serviceSelections[canonicalKey] = serviceKey;
+            }
+        }
+    });
 }
 /**
  * Resolves a canonical channel key to the actual channel key based on user selection. If the user has selected a specific service for this channel, returns that
  * service's key. Otherwise returns the canonical key (default service). When the service filter is active, falls back to the first enabled variant if the stored
  * selection's service is filtered out.
  *
- * This function is a pure resolver with no side effects. Stale selection cleanup is handled by buildServiceGroups(), which validates all stored selections
- * against the rebuilt variant structure every time groups are rebuilt - both at startup and after runtime channel mutations.
+ * Pure resolver with no side effects. Stale selection cleanup belongs to buildServiceGroups(), which validates all stored selections against the rebuilt variant
+ * structure on startup and after runtime channel mutations. Reads are safe to call from any context, including inside other mutations.
  * @param canonicalKey - The canonical channel key.
  * @returns The resolved service key to use for streaming.
  */
 export function resolveServiceKey(canonicalKey) {
     const selection = serviceSelections.get(canonicalKey);
-    // No selection stored — use the canonical key (default service). If the canonical's service tag is filtered out, fall back to the first enabled variant.
+    // No selection stored - use the canonical key (default service). If the canonical's service tag is filtered out, fall back to the first enabled variant.
     if (!selection) {
         if ((enabledServices.length > 0) && !isServiceTagEnabled(getServiceTagForChannel(canonicalKey))) {
             return findFirstEnabledVariant(canonicalKey) ?? canonicalKey;
         }
         return canonicalKey;
     }
-    // Valid selection — if its service tag is filtered out, fall back to the first enabled variant.
+    // Valid selection - if its service tag is filtered out, fall back to the first enabled variant.
     if ((enabledServices.length > 0) && !isServiceTagEnabled(getServiceTagForChannel(selection))) {
         return findFirstEnabledVariant(canonicalKey) ?? selection;
     }
@@ -674,85 +728,45 @@ function findFirstEnabledVariant(canonicalKey) {
     return undefined;
 }
 /**
- * Applies variant inheritance: the variant contributes service-specific fields (url, channelSelector, profile, etc.) while identity fields always come from the
- * canonical base. Identity fields describe what the channel IS — name, station ID, tags, channel number — and are independent of which service serves it. The
- * spread brings in all variant fields, then identity fields are unconditionally overwritten from the canonical. This ensures user overrides on the canonical
- * (e.g., renaming a channel or adding tags) propagate to all service variants, rather than being masked by stale flattener-copied values on the variant.
- * The field list comes from CHANNEL_IDENTITY_FIELDS — the single source of truth for the identity/service-specific separation.
- * @param variant - The variant channel definition (service-specific fields).
- * @param base - The canonical (base) channel with user overrides applied (identity fields).
- * @returns A new Channel with identity fields from the canonical and service-specific fields from the variant.
- */
-function applyVariantInheritance(variant, base) {
-    const result = { ...variant };
-    for (const field of CHANNEL_IDENTITY_FIELDS) {
-        copyField(result, base, field);
-    }
-    return result;
-}
-// Type-safe field copy using a generic to preserve the field-value relationship. TypeScript can't prove that result[field] and base[field] have compatible types
-// when field is a union of literal keys (each key maps to a different type). The generic K narrows to a single key per call, making the assignment type-safe.
-// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- K is necessary to correlate the key type between target and source assignments.
-function copyField(target, source, key) {
-    target[key] = source[key];
-}
-/**
- * Gets a channel with inheritance applied. For service variants, this merges the variant's properties with inherited properties from the canonical entry
- * using the live channel data (which includes user overrides). Use `resolvePredefinedVariant()` when you need resolution against pure predefined data.
- * @param key - The channel key (canonical or variant).
- * @returns The complete channel with inheritance applied, or undefined if the channel doesn't exist.
+ * Gets a channel with inheritance applied. Variant inheritance is resolved at load time by resolveStoredChannel in userChannels.ts - entries in channelsRef
+ * are already fully merged with their canonical (variant values win when set, canonical fills in the rest). This function is a thin accessor that also
+ * handles the synthetic :predefined suffix used when a user overrides a canonical but the service dropdown references the original predefined variant.
+ * @param key - The channel key (canonical, variant, or :predefined suffix).
+ * @returns The complete channel, or undefined if the channel doesn't exist.
  */
 export function getResolvedChannel(key) {
-    // Handle predefined suffix — return the original predefined channel when user has overridden the canonical but selects the predefined service.
+    // Handle the :predefined suffix - return the original predefined channel when the user has overridden the canonical but selects the predefined service. The
+    // suffix is only meaningful for canonical keys, so the lookup target is structurally a CanonicalChannel (which is a valid ResolvedChannel).
     if (key.endsWith(PREDEFINED_SUFFIX)) {
-        const baseKey = key.slice(0, -PREDEFINED_SUFFIX.length);
-        return PREDEFINED_CHANNELS[baseKey];
-    }
-    const channel = channelsRef[key];
-    // Runtime check needed even though TypeScript thinks channel is always defined (Record indexing quirk).
-    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-    if (!channel) {
-        return undefined;
-    }
-    const group = serviceGroups.get(key);
-    // If not part of a group or is the canonical entry, return as-is.
-    if (!group || (group.canonicalKey === key)) {
-        return channel;
-    }
-    // This is a variant — merge with canonical entry.
-    const canonical = channelsRef[group.canonicalKey];
-    // Runtime check — canonical entry should exist if the group exists, but we check defensively.
-    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-    if (!canonical) {
-        // Canonical entry missing (shouldn't happen), return variant as-is.
-        return channel;
+        const predefined = PREDEFINED_CHANNELS[key.slice(0, -PREDEFINED_SUFFIX.length)];
+        return (predefined && (predefined.canonicalKey === undefined)) ? predefined : undefined;
     }
-    return applyVariantInheritance(channel, canonical);
+    return channelsRef[key];
 }
 /**
- * Resolves a variant channel key against pure predefined data (ignoring user overrides). This is used for revert detection — when the user's edits match a
- * variant's predefined definition, the custom override can be removed and the service selection switched to that variant. For canonical keys, returns the raw
- * predefined channel. For variant keys, applies the same inheritance rules as `getResolvedChannel()` but against `PREDEFINED_CHANNELS` instead of `channelsRef`.
+ * Resolves a variant channel key against pure predefined data (ignoring user overrides). Used for revert detection: when an edit's values match a variant's
+ * predefined definition, the custom override can be dropped and the service selection switched to that variant. Predefined variant entries carry only
+ * service-specific fields and canonicalKey; identity inherits from the canonical. This resolver layers the variant's service fields onto the canonical so
+ * findMatchingVariant can compare form values against a fully-populated variant view.
  * @param key - The channel key (canonical or variant).
- * @returns The channel with inheritance applied against predefined data, or undefined if the key has no predefined definition.
+ * @returns The resolved predefined channel, or undefined when the key has no predefined definition.
  */
 export function resolvePredefinedVariant(key) {
-    const channel = PREDEFINED_CHANNELS[key];
-    // Runtime check — the key may not exist in PREDEFINED_CHANNELS.
-    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-    if (!channel) {
+    const entry = PREDEFINED_CHANNELS[key];
+    if (!entry) {
         return undefined;
     }
-    const group = serviceGroups.get(key);
-    // If not part of a group or is the canonical entry, return the predefined channel as-is.
-    if (!group || (group.canonicalKey === key)) {
-        return channel;
+    // Canonical entries (and standalones, but those are not in PREDEFINED_CHANNELS) carry full identity already. Narrow on the canonicalKey discriminator to
+    // confirm: undefined canonicalKey means CanonicalChannel.
+    if (entry.canonicalKey === undefined) {
+        return entry;
     }
-    const canonical = PREDEFINED_CHANNELS[group.canonicalKey];
-    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-    if (!canonical) {
-        return channel;
+    // Predefined variant: identity inherits from the canonical, binding comes from the variant. We start with canonical identity ONLY (via pickIdentity) so the
+    // canonical service's binding does not leak into a different service's variant. The variant's own binding fields then populate via spread.
+    const canonical = PREDEFINED_CHANNELS[entry.canonicalKey];
+    if (!canonical || (canonical.canonicalKey !== undefined)) {
+        return undefined;
     }
-    return applyVariantInheritance(channel, canonical);
+    return { ...pickIdentity(canonical), ...entry };
 }
 //# sourceMappingURL=services.js.map