prismcast 1.10.3 → 1.11.0

package/dist/config/userChannels.d.ts

@@ -106,8 +106,8 @@ declare function classifyEntry(key: string, stored: StoredChannel | undefined):
  * Computes the field-name allowlist for a stored entry's expected shape. Stored entries fall into two structural shapes determined by classification:
  *
  *  - Canonical-shaped (kind = canonical or standalone): allowed fields are DELTA_ELIGIBLE_IDENTITY_KEYS ∪ DELTA_ELIGIBLE_BINDING_KEYS. The full delta surface.
- *  - Variant-shaped (kind = variant): allowed fields are DELTA_ELIGIBLE_BINDING_KEYS plus the structural canonicalKey discriminator. Identity inherits from the
- *    canonical and must not appear on variants per the architectural principle.
+ *  - Variant-shaped (kind = variant): allowed fields are DELTA_ELIGIBLE_BINDING_KEYS plus the structural canonicalKey field that marks the kind. Identity
+ *    inherits from the canonical and must not appear on variants per the architectural principle.
  *
  * Single source of truth for the shape rule. Used by filterToDeltaSurface (normalizer pre-strip) and by the customization accessor's per-pass walks. Routes
  * shape determination through classifyEntry so any caller automatically picks up classifier improvements - no parallel logic for "is this a variant?".
@@ -269,9 +269,10 @@ export declare function inferTargetVariant(canonicalKey: string, submittedUrl: s
  */
 declare function normalizeChannelDeltas(data: ChannelsFileData): void;
 /**
- * Prepares channels data for writing to disk. Injects metadata from module state (serviceSelections, tagRegistry) into the serializable output. The metadata
- * is always pulled from module state rather than from the file data, because route handlers may have modified metadata in memory since the last file read.
- * Delta normalization is handled by mutateChannels() before the data reaches this hook.
+ * Prepares channels data for writing to disk. This is a pure function of the passed envelope: channels, schemaVersion, migrationsApplied, serviceSelections,
+ * and tagRegistry are all sourced from `data`, never from module-state caches. The framework guarantees `data` is the source of truth at write time, so reading
+ * module state here would be a side channel that breaks correctness when the boot persist runs before module state is populated. Delta normalization is handled
+ * by mutateChannels() before the data reaches this hook.
  * @param data - The compound channels data with already-normalized channels.
  * @returns The serializable output with channels and current metadata.
  */
@@ -339,7 +340,7 @@ export declare function mutateChannels(fn: (data: ChannelsFileData) => void): Pr
  * - Canonical-binding overlap heal: invoked indirectly by the post-callback normalizer (normalizeChannelDeltas) which runs against the freshly-read data
  *   inside mutateChannels. Any canonical override carrying binding whose URL extracts to a sibling variant's domain is healed in place - binding stripped
  *   from the canonical, propagated to the matching variant entry, serviceSelections updated. The normalizer always runs post-callback; the heal happening
- *   automatically is the load-bearing behavior, not the explicit body of this function.
+ *   automatically is required for the cleanup to take effect, not the explicit body of this function.
  *
  * Existence as a named function is the architectural point: a bare `mutateChannels(() => {})` would correctly trigger the normalizer but obscure the intent
  * at the call site. The name documents what the pass does so callers see "run startup cleanup" rather than "do nothing inside a mutation."
@@ -433,7 +434,7 @@ declare function overlayDelta(base: ResolvedChannel, stored: StoredChannel): Res
  * Shared overlay kernel used by overlayDelta and overlayVariantBinding. Walks the stored entry's fields and applies them to a clone of base under three rules:
  * fields in allowedFields apply with delta semantics (null clears, undefined skips, value overrides); non-allowed fields either pass through (delta) or are
  * silently dropped (variant overlay) per passThroughOthers; canonicalKey is always allowed regardless of the gate so resolved variants retain their relationship
- * metadata. The kernel exists to keep the two overlays from drifting - identical control flow lived in both call sites before this consolidation.
+ * metadata. The kernel exists to keep the two overlays from drifting - both share one control-flow path rather than duplicating it in each call site.
  * @param base - The base channel to clone and overlay onto.
  * @param stored - The stored entry whose fields override the base.
  * @param options - allowedFields selects which fields apply with delta semantics; passThroughOthers controls whether non-allowed fields flow through or are
@@ -527,7 +528,7 @@ export declare function getVisibleChannels(): ChannelListingEntry[];
 export declare function getAllChannels(): ResolvedChannelMap;
 /**
  * Returns a copy of the raw stored user channels map - the unresolved entries as they exist in channels.json. Used by the consistency probe to check
- * cross-store invariants without applying delta resolution. Callers should not rely on the shape for anything beyond key/canonicalKey inspection.
+ * cross-store consistency rules without applying delta resolution. Callers should not rely on the shape for anything beyond key/canonicalKey inspection.
  * @returns Shallow copy of the loaded user channels.
  */
 export declare function getStoredUserChannels(): StoredChannelMap;
@@ -711,7 +712,8 @@ export declare function getChannelLogo(channelKey: string): string | undefined;
 export declare function isUserChannel(key: string): boolean;
 /**
  * Checks if a predefined channel is disabled. The disabled state is determined solely by the disabledPredefined list in config - the user's explicit visibility
- * intent. Property overrides (HDHR toggle, name change, tag edits) stored as deltas in channels.json are orthogonal and do not affect the enabled/disabled state.
+ * intent. Property overrides (HDHR toggle, name change, tag edits) stored as deltas in channels.json are independent and do not affect the enabled/disabled
+ * state.
  * @param key - The channel key to check.
  * @returns True if the channel is predefined and disabled.
  */
@@ -722,19 +724,20 @@ export declare function isPredefinedChannelDisabled(key: string): boolean;
  */
 export declare function getDisabledPredefinedChannels(): string[];
 /**
- * Disables one or more predefined channels by adding their keys to the disabledPredefined list in user config. Idempotent.
- * @param keys - The predefined channel keys to disable. Duplicates within the input array and pre-existing disabled entries are handled idempotently.
+ * Disables one or more predefined channels by adding their keys to the disabledPredefined list in user config. Safe to call again with the same keys.
+ * @param keys - The predefined channel keys to disable. Duplicates within the input array and pre-existing disabled entries are handled without producing
+ * duplicate list entries.
  */
 export declare function disablePredefinedChannels(keys: readonly string[]): Promise<void>;
 /**
- * Enables one or more predefined channels by removing their keys from the disabledPredefined list in user config. Idempotent.
+ * Enables one or more predefined channels by removing their keys from the disabledPredefined list in user config. Safe to call again with the same keys.
  * @param keys - The predefined channel keys to enable. Entries that aren't in the disabled list are ignored.
  */
 export declare function enablePredefinedChannels(keys: readonly string[]): Promise<void>;
 /**
  * Persists a partial update of channel-table display preferences (sort field, sort direction, visible columns) to config.json. Only fields present in `prefs`
  * are written; absent fields are left untouched. The mutate fn copies the new values into data and the runtime CONFIG cache is updated post-write to match.
- * Single-call replacement for the prior set-then-save pattern, consistent with mutateServiceSelections, mutateEnabledServices, and setTagRegistry.
+ * Persists and hydrates the runtime cache in a single call, consistent with mutateServiceSelections, mutateEnabledServices, and setTagRegistry.
  * @param prefs - Subset of display preferences to update.
  * @throws FileStoreParseError if config.json contains invalid JSON and the .bak rotation is also unparseable.
  */
@@ -828,10 +831,11 @@ export declare function validateChannelName(name: string): string | undefined;
 /**
  * Validates a profile name.
  * @param profile - The profile name to validate (can be empty for autodetect).
- * @param validProfiles - Array of valid profile names.
+ * @param isKnownProfile - Predicate answering whether a profile name exists. Callers test each name against the single builtin lookup plus the user's own
+ * profiles, so that a channel may reference a provider profile as well as a general or user-defined one.
  * @returns Error message if invalid, undefined if valid.
  */
-export declare function validateChannelProfile(profile: string | undefined, validProfiles: string[]): string | undefined;
+export declare function validateChannelProfile(profile: string | undefined, isKnownProfile: (name: string) => boolean): string | undefined;
 /**
  * Result of validating imported channels.
  */
@@ -843,14 +847,14 @@ export interface ChannelsValidationResult {
 /**
  * Validates an imported channels object for structure and content.
  * @param data - The raw imported data to validate.
- * @param validProfiles - Array of valid profile names.
+ * @param isKnownProfile - Predicate answering whether a referenced profile name exists, passed through to the per-channel profile check.
  * @returns Validation result with errors if invalid.
  */
-export declare function validateImportedChannels(data: unknown, validProfiles: string[]): ChannelsValidationResult;
+export declare function validateImportedChannels(data: unknown, isKnownProfile: (name: string) => boolean): ChannelsValidationResult;
 /**
  * Sorts tags case-insensitively using locale-aware comparison. This is the single source of truth for tag ordering. Every write path (parseTagInput, PATCH
  * handlers, computePredefinedDelta, transformChannelTags, setTagRegistry) routes through this so stored tag arrays share one canonical ordering. The channels
- * normalizer is a READER of that invariant - it uses sortTags on both sides when comparing a delta's tags against a predefined's tags, making the
+ * normalizer depends on that ordering guarantee - it uses sortTags on both sides when comparing a delta's tags against a predefined's tags, making the
  * isDeepStrictEqual comparison canonical regardless of how either side was originally populated.
  * @param tags - Any iterable of tag strings (array, Set, generator). Not mutated.
  * @returns A new array with the same elements in canonical case-insensitive order.
@@ -885,3 +889,4 @@ export declare const __internalForTests: {
     warnDanglingCanonical: typeof warnDanglingCanonical;
 };
 export {};
+//# sourceMappingURL=userChannels.d.ts.map

package/dist/config/userChannels.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"userChannels.d.ts","sourceRoot":"","sources":["../../src/config/userChannels.ts"],"names":[],"mappings":"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"}

package/dist/config/userChannels.js

@@ -46,8 +46,9 @@ export function getChannelsParseErrorMessage() {
     return userChannelsParseErrorMessage;
 }
 /* Transactional store for channels.json. The store uses a compound type that carries channel data alongside metadata (serviceSelections, tagRegistry). The parse
- * function extracts all three from the JSON file. The mutateChannels() wrapper normalizes predefined channel deltas before the write and adapts the compound
- * type so callers work directly with StoredChannelMap. The beforeWrite hook injects metadata from module state.
+ * function extracts the channel data and its metadata fields from the JSON file. The mutateChannels() wrapper normalizes predefined channel deltas before the
+ * write and adapts the compound type so callers work directly with StoredChannelMap. The beforeWrite hook (prepareChannelsForWrite) derives every field of the
+ * on-disk shape from the mutation's data envelope itself, never from module state.
  */
 /* Current schema version for channels.json. Migrations are declared in channelsMigrations below; the framework runs them in order from the file's stored
  * version up to this constant, stamps the new version after each, and records the audit trail in migrationsApplied.
@@ -58,7 +59,7 @@ export function getChannelsParseErrorMessage() {
  *       stamping canonicalKey on entries whose identity fields match the canonical (shape-compatible with a legitimate variant) and skipping entries whose
  *       fields differ (user standalones that happened to share a hyphenated key with a predefined canonical).
  *   3 - Foxone-era service naming. The v2 -> v3 migration renames "foxcom" -> "foxone" in service selections and channel keys, and the special-case
- *       "fox-site" -> "fox-foxone" rename for the FoxOne variant briefly mis-keyed in v1.8.0. Bumping this version also flushes parser-side legacy field
+ *       "fox-site" -> "fox-foxone" rename for the FoxOne variant stored under the "fox-site" key. Bumping this version also flushes parser-side legacy field
  *       cleanups (provider -> service field, providerSelections -> serviceSelections key) to disk on the same write that lands the foxone rename.
  */
 const CURRENT_CHANNELS_SCHEMA_VERSION = 3;
@@ -79,7 +80,7 @@ function parseChannelsFile(raw) {
     let schemaVersion = 1;
     for (const [key, value] of Object.entries(parsed)) {
         if (key === "schemaVersion") {
-            // Tolerate bad data by falling back to version 1 - any plausibly-legacy value is fine, since migrations are idempotent when no work is needed.
+            // Tolerate bad data by falling back to version 1 - any plausibly-legacy value is fine, since migrations are a no-op when no work is needed.
             if ((typeof value === "number") && Number.isFinite(value) && (value >= 1)) {
                 schemaVersion = Math.floor(value);
             }
@@ -237,8 +238,8 @@ function classifyEntry(key, stored) {
  * Computes the field-name allowlist for a stored entry's expected shape. Stored entries fall into two structural shapes determined by classification:
  *
  *  - Canonical-shaped (kind = canonical or standalone): allowed fields are DELTA_ELIGIBLE_IDENTITY_KEYS ∪ DELTA_ELIGIBLE_BINDING_KEYS. The full delta surface.
- *  - Variant-shaped (kind = variant): allowed fields are DELTA_ELIGIBLE_BINDING_KEYS plus the structural canonicalKey discriminator. Identity inherits from the
- *    canonical and must not appear on variants per the architectural principle.
+ *  - Variant-shaped (kind = variant): allowed fields are DELTA_ELIGIBLE_BINDING_KEYS plus the structural canonicalKey field that marks the kind. Identity
+ *    inherits from the canonical and must not appear on variants per the architectural principle.
  *
  * Single source of truth for the shape rule. Used by filterToDeltaSurface (normalizer pre-strip) and by the customization accessor's per-pass walks. Routes
  * shape determination through classifyEntry so any caller automatically picks up classifier improvements - no parallel logic for "is this a variant?".
@@ -297,7 +298,7 @@ function filterToDeltaSurface(key, stored) {
 function resolveVariant(canonical, predefined, stored) {
     // Identity-only base. The url field (required on ResolvedChannel) is supplied by the predefined variant or stored delta below; the cast acknowledges that
     // intermediate state. After the chain completes, the result has url populated when at least one of the binding-bearing layers (predefined or stored) is
-    // present - which is the documented invariant for any well-formed variant entry.
+    // present - which is the documented guarantee for any well-formed variant entry.
     let resolved = pickIdentity(canonical);
     // Variant overlays apply binding fields only - identity stays from the canonical per the architectural principle that variants are pure tuning data. Both
     // the predefined variant and the user's stored variant entry use the same binding-only overlay.
@@ -350,7 +351,7 @@ function warnDanglingCanonical(variantKey, canonicalKey) {
  */
 function buildResolvedCanonicals(stored) {
     const result = {};
-    const allKeys = new Set([...Object.keys(PREDEFINED_CHANNELS), ...Object.keys(stored)]);
+    const allKeys = new Set(Object.keys(PREDEFINED_CHANNELS)).union(new Set(Object.keys(stored)));
     for (const key of allKeys) {
         const classification = classifyEntry(key, stored[key]);
         if (classification.kind === "variant") {
@@ -515,7 +516,7 @@ export function inferTargetVariant(canonicalKey, submittedUrl, channels) {
         }
     }
     // Sort for deterministic pick when multiple siblings share a domain.
-    const sortedKeys = [...siblingKeys].sort();
+    const sortedKeys = Array.from(siblingKeys).toSorted();
     for (const siblingKey of sortedKeys) {
         // Effective URL: user override (when string-valued) takes precedence over the predefined variant's URL. A null delta value clears the field, falling back
         // to the predefined; an absent field inherits, also falling back. Both collapse to "use the predefined URL."
@@ -645,7 +646,7 @@ function normalizeChannelDeltas(data) {
             continue;
         }
         // Variant. The normalization base is identity-from-canonical layered with the predefined variant's binding (if any) - the same shape the user sees in the
-        // form/table, so the delta records only what differs from that. Critically, this matches the inheritance shape used by resolveVariant: identity from
+        // form/table, so the delta records only what differs from that. This matches the inheritance shape used by resolveVariant: identity from
         // canonical, binding from variant. Without the pickIdentity strip, the canonical service's binding would leak into the normalization base and stored
         // overrides matching the canonical's binding would be incorrectly stripped as no-ops. A dangling canonical falls back to standalone-style normalization so
         // the user does not silently lose data.
@@ -668,9 +669,10 @@ function normalizeChannelDeltas(data) {
     }
 }
 /**
- * Prepares channels data for writing to disk. Injects metadata from module state (serviceSelections, tagRegistry) into the serializable output. The metadata
- * is always pulled from module state rather than from the file data, because route handlers may have modified metadata in memory since the last file read.
- * Delta normalization is handled by mutateChannels() before the data reaches this hook.
+ * Prepares channels data for writing to disk. This is a pure function of the passed envelope: channels, schemaVersion, migrationsApplied, serviceSelections,
+ * and tagRegistry are all sourced from `data`, never from module-state caches. The framework guarantees `data` is the source of truth at write time, so reading
+ * module state here would be a side channel that breaks correctness when the boot persist runs before module state is populated. Delta normalization is handled
+ * by mutateChannels() before the data reaches this hook.
  * @param data - The compound channels data with already-normalized channels.
  * @returns The serializable output with channels and current metadata.
  */
@@ -718,6 +720,7 @@ const channelsMigrations = {
             // persist that writes the cleaned shape via prepareChannelsForWrite.
             for (const [canonicalKey, selectedVariant] of Object.entries(data.serviceSelections)) {
                 if (selectedVariant.endsWith("-foxcom")) {
+                    // Strip only "foxcom" (6 chars), not the full "-foxcom" guard (7), so the separating hyphen survives into the foxone-suffixed result.
                     data.serviceSelections[canonicalKey] = selectedVariant.slice(0, -6) + "foxone";
                 }
                 if ((canonicalKey === "fox") && (selectedVariant === "fox-site")) {
@@ -726,6 +729,7 @@ const channelsMigrations = {
             }
             for (const [key, value] of Object.entries(data.channels)) {
                 if (key.endsWith("-foxcom")) {
+                    // Strip only "foxcom" (6 chars), not the full "-foxcom" guard (7), so the separating hyphen survives into the foxone-suffixed result.
                     data.channels[key.slice(0, -6) + "foxone"] = value;
                     Reflect.deleteProperty(data.channels, key);
                 }
@@ -920,7 +924,7 @@ export async function mutateChannels(fn) {
  * - Canonical-binding overlap heal: invoked indirectly by the post-callback normalizer (normalizeChannelDeltas) which runs against the freshly-read data
  *   inside mutateChannels. Any canonical override carrying binding whose URL extracts to a sibling variant's domain is healed in place - binding stripped
  *   from the canonical, propagated to the matching variant entry, serviceSelections updated. The normalizer always runs post-callback; the heal happening
- *   automatically is the load-bearing behavior, not the explicit body of this function.
+ *   automatically is required for the cleanup to take effect, not the explicit body of this function.
  *
  * Existence as a named function is the architectural point: a bare `mutateChannels(() => {})` would correctly trigger the normalizer but obscure the intent
  * at the call site. The name documents what the pass does so callers see "run startup cleanup" rather than "do nothing inside a mutation."
@@ -1146,7 +1150,7 @@ export async function initializeUserChannels() {
 const VARIANT_OVERLAY_ALLOWED_FIELDS = new Set(CHANNEL_BINDING_KEYS);
 // The runtime delta surface: every field that may legitimately appear in a stored ChannelDelta override. Derived from the partition arrays in types/channels.ts
 // so adding or removing a delta-eligible field in one place propagates everywhere. Typed as Set<string> for ergonomics at .has() call sites that take string-keyed
-// values from Object.entries iteration; the contents are statically-known CustomizableField values via the spread above.
+// values from Object.entries iteration; the contents are statically-known CustomizableField values via the spread below.
 const DELTA_ALLOWED_FIELDS = new Set([...DELTA_ELIGIBLE_IDENTITY_KEYS, ...DELTA_ELIGIBLE_BINDING_KEYS]);
 /**
  * Extracts the identity-only subset of a channel. Used by resolveVariant and normalizeChannelDeltas to compute the inheritance base for variants: a variant
@@ -1196,7 +1200,7 @@ function overlayDelta(base, stored) {
  * Shared overlay kernel used by overlayDelta and overlayVariantBinding. Walks the stored entry's fields and applies them to a clone of base under three rules:
  * fields in allowedFields apply with delta semantics (null clears, undefined skips, value overrides); non-allowed fields either pass through (delta) or are
  * silently dropped (variant overlay) per passThroughOthers; canonicalKey is always allowed regardless of the gate so resolved variants retain their relationship
- * metadata. The kernel exists to keep the two overlays from drifting - identical control flow lived in both call sites before this consolidation.
+ * metadata. The kernel exists to keep the two overlays from drifting - both share one control-flow path rather than duplicating it in each call site.
  * @param base - The base channel to clone and overlay onto.
  * @param stored - The stored entry whose fields override the base.
  * @param options - allowedFields selects which fields apply with delta semantics; passThroughOthers controls whether non-allowed fields flow through or are
@@ -1280,7 +1284,7 @@ export function resolveStoredChannel(key, stored) {
  */
 function getMergedChannelMap() {
     const result = buildResolvedCanonicals(loadedUserChannels);
-    const allKeys = new Set([...Object.keys(PREDEFINED_CHANNELS), ...Object.keys(loadedUserChannels)]);
+    const allKeys = new Set(Object.keys(PREDEFINED_CHANNELS)).union(new Set(Object.keys(loadedUserChannels)));
     for (const key of allKeys) {
         const stored = loadedUserChannels[key];
         const classification = classifyEntry(key, stored);
@@ -1333,7 +1337,7 @@ function getMergedChannelMap() {
  * @returns Sorted array of channel listing entries.
  */
 export function getChannelListing() {
-    const allKeys = new Set([...Object.keys(PREDEFINED_CHANNELS), ...Object.keys(loadedUserChannels)]);
+    const allKeys = new Set(Object.keys(PREDEFINED_CHANNELS)).union(new Set(Object.keys(loadedUserChannels)));
     const listing = [];
     for (const key of allKeys) {
         // Skip service variants - they're accessed via service selection, not as separate channels.
@@ -1414,7 +1418,7 @@ export function getAllChannels() {
 }
 /**
  * Returns a copy of the raw stored user channels map - the unresolved entries as they exist in channels.json. Used by the consistency probe to check
- * cross-store invariants without applying delta resolution. Callers should not rely on the shape for anything beyond key/canonicalKey inspection.
+ * cross-store consistency rules without applying delta resolution. Callers should not rely on the shape for anything beyond key/canonicalKey inspection.
  * @returns Shallow copy of the loaded user channels.
  */
 export function getStoredUserChannels() {
@@ -1767,7 +1771,8 @@ export function getChannelStationId(channelKey) {
         return resolveStoredChannel(effectiveKey, userEntry).stationId;
     }
     // PREDEFINED_CHANNELS is a discriminated union; only canonicals carry stationId. The lookup here is by canonical-equivalent key (Pacific resolved to East),
-    // so a hit is structurally a canonical. Narrow via the canonicalKey discriminator: a defined canonicalKey marks a VariantChannel, which has no stationId.
+    // so a hit is structurally a canonical. Narrow via the canonicalKey field that marks the kind: a defined canonicalKey marks a VariantChannel, which has no
+    // stationId.
     const predefined = PREDEFINED_CHANNELS[effectiveKey];
     if (!predefined || (predefined.canonicalKey !== undefined)) {
         return undefined;
@@ -1800,7 +1805,8 @@ export function isUserChannel(key) {
  */
 /**
  * Checks if a predefined channel is disabled. The disabled state is determined solely by the disabledPredefined list in config - the user's explicit visibility
- * intent. Property overrides (HDHR toggle, name change, tag edits) stored as deltas in channels.json are orthogonal and do not affect the enabled/disabled state.
+ * intent. Property overrides (HDHR toggle, name change, tag edits) stored as deltas in channels.json are independent and do not affect the enabled/disabled
+ * state.
  * @param key - The channel key to check.
  * @returns True if the channel is predefined and disabled.
  */
@@ -1842,14 +1848,15 @@ async function mutateDisabledPredefined(op, keys) {
     CONFIG.channels.disabledPredefined = updatedList;
 }
 /**
- * Disables one or more predefined channels by adding their keys to the disabledPredefined list in user config. Idempotent.
- * @param keys - The predefined channel keys to disable. Duplicates within the input array and pre-existing disabled entries are handled idempotently.
+ * Disables one or more predefined channels by adding their keys to the disabledPredefined list in user config. Safe to call again with the same keys.
+ * @param keys - The predefined channel keys to disable. Duplicates within the input array and pre-existing disabled entries are handled without producing
+ * duplicate list entries.
  */
 export async function disablePredefinedChannels(keys) {
     await mutateDisabledPredefined("add", keys);
 }
 /**
- * Enables one or more predefined channels by removing their keys from the disabledPredefined list in user config. Idempotent.
+ * Enables one or more predefined channels by removing their keys from the disabledPredefined list in user config. Safe to call again with the same keys.
  * @param keys - The predefined channel keys to enable. Entries that aren't in the disabled list are ignored.
  */
 export async function enablePredefinedChannels(keys) {
@@ -1858,7 +1865,7 @@ export async function enablePredefinedChannels(keys) {
 /**
  * Persists a partial update of channel-table display preferences (sort field, sort direction, visible columns) to config.json. Only fields present in `prefs`
  * are written; absent fields are left untouched. The mutate fn copies the new values into data and the runtime CONFIG cache is updated post-write to match.
- * Single-call replacement for the prior set-then-save pattern, consistent with mutateServiceSelections, mutateEnabledServices, and setTagRegistry.
+ * Persists and hydrates the runtime cache in a single call, consistent with mutateServiceSelections, mutateEnabledServices, and setTagRegistry.
  * @param prefs - Subset of display preferences to update.
  * @throws FileStoreParseError if config.json contains invalid JSON and the .bak rotation is also unparseable.
  */
@@ -2075,27 +2082,31 @@ export function validateChannelName(name) {
 /**
  * Validates a profile name.
  * @param profile - The profile name to validate (can be empty for autodetect).
- * @param validProfiles - Array of valid profile names.
+ * @param isKnownProfile - Predicate answering whether a profile name exists. Callers test each name against the single builtin lookup plus the user's own
+ * profiles, so that a channel may reference a provider profile as well as a general or user-defined one.
  * @returns Error message if invalid, undefined if valid.
  */
-export function validateChannelProfile(profile, validProfiles) {
+export function validateChannelProfile(profile, isKnownProfile) {
     // Empty profile means autodetect, which is valid.
     if (!profile || (profile.trim() === "")) {
         return undefined;
     }
-    // Check if profile exists.
-    if (!validProfiles.includes(profile)) {
-        return "Unknown profile: " + profile + ". Valid profiles: " + validProfiles.join(", ") + ".";
+    /* Check if profile exists. The message names the rejected value alone. The set of acceptable names includes the provider profiles, which the web UI's profile
+     * picker deliberately omits, so spelling that set out here would offer names the picker will never present. The picker is the discovery surface for a valid
+     * profile name; this message's job is to say which value was not one.
+     */
+    if (!isKnownProfile(profile)) {
+        return "Unknown profile: " + profile + ".";
     }
     return undefined;
 }
 /**
  * Validates an imported channels object for structure and content.
  * @param data - The raw imported data to validate.
- * @param validProfiles - Array of valid profile names.
+ * @param isKnownProfile - Predicate answering whether a referenced profile name exists, passed through to the per-channel profile check.
  * @returns Validation result with errors if invalid.
  */
-export function validateImportedChannels(data, validProfiles) {
+export function validateImportedChannels(data, isKnownProfile) {
     const errors = [];
     // Check that input is an object.
     if ((typeof data !== "object") || (data === null) || Array.isArray(data)) {
@@ -2140,7 +2151,7 @@ export function validateImportedChannels(data, validProfiles) {
         }
         // Validate optional profile field. Sanitize after type check.
         const profile = (typeof channelData["profile"] === "string") ? sanitizeString(channelData["profile"]) : undefined;
-        const profileError = validateChannelProfile(profile, validProfiles);
+        const profileError = validateChannelProfile(profile, isKnownProfile);
         if (profileError) {
             errors.push("Channel '" + key + "': " + profileError);
             continue;
@@ -2201,7 +2212,7 @@ export function validateImportedChannels(data, validProfiles) {
 /**
  * Sorts tags case-insensitively using locale-aware comparison. This is the single source of truth for tag ordering. Every write path (parseTagInput, PATCH
  * handlers, computePredefinedDelta, transformChannelTags, setTagRegistry) routes through this so stored tag arrays share one canonical ordering. The channels
- * normalizer is a READER of that invariant - it uses sortTags on both sides when comparing a delta's tags against a predefined's tags, making the
+ * normalizer depends on that ordering guarantee - it uses sortTags on both sides when comparing a delta's tags against a predefined's tags, making the
  * isDeepStrictEqual comparison canonical regardless of how either side was originally populated.
  * @param tags - Any iterable of tag strings (array, Set, generator). Not mutated.
  * @returns A new array with the same elements in canonical case-insensitive order.