Extended managed configuration (#560)

app/MindWork AI Studio/Components/ConfigurationMultiSelect.razor.cs

@@ -33,8 +33,10 @@ public partial class ConfigurationMultiSelect<TData> : ConfigurationBaseCore
     /// <inheritdoc />
     protected override bool Stretch => true;
 
+    /// <inheritdoc />
     protected override Variant Variant => Variant.Outlined;
 
+    /// <inheritdoc />
     protected override string Label => this.OptionDescription;
 
     #endregion

app/MindWork AI Studio/Components/ConfigurationSelect.razor.cs

@@ -36,6 +36,7 @@ public partial class ConfigurationSelect<TConfig> : ConfigurationBaseCore
     /// <inheritdoc />
     protected override string Label => this.OptionDescription;
 
+    /// <inheritdoc />
     protected override Variant Variant => Variant.Outlined;
 
     #endregion

app/MindWork AI Studio/Components/Settings/SettingsPanelApp.razor

@@ -16,14 +16,14 @@
     <ConfigurationSelect OptionDescription="@T("Check for updates")" SelectedValue="@(() => this.SettingsManager.ConfigurationData.App.UpdateInterval)" Data="@ConfigurationSelectDataFactory.GetUpdateIntervalData()" SelectionUpdate="@(selectedValue => this.SettingsManager.ConfigurationData.App.UpdateInterval = selectedValue)" OptionHelp="@T("How often should we check for app updates?")" IsLocked="() => ManagedConfiguration.TryGet(x => x.App, x => x.UpdateInterval, out var meta) && meta.IsLocked"/>
     <ConfigurationSelect OptionDescription="@T("Update installation method")" SelectedValue="@(() => this.SettingsManager.ConfigurationData.App.UpdateInstallation)" Data="@ConfigurationSelectDataFactory.GetUpdateBehaviourData()" SelectionUpdate="@(selectedValue => this.SettingsManager.ConfigurationData.App.UpdateInstallation = selectedValue)" OptionHelp="@T("Should updates be installed automatically or manually?")" IsLocked="() => ManagedConfiguration.TryGet(x => x.App, x => x.UpdateInstallation, out var meta) && meta.IsLocked"/>
     <ConfigurationSelect OptionDescription="@T("Navigation bar behavior")" SelectedValue="@(() => this.SettingsManager.ConfigurationData.App.NavigationBehavior)" Data="@ConfigurationSelectDataFactory.GetNavBehaviorData()" SelectionUpdate="@(selectedValue => this.SettingsManager.ConfigurationData.App.NavigationBehavior = selectedValue)" OptionHelp="@T("Select the desired behavior for the navigation bar.")"/>
-    <ConfigurationSelect OptionDescription="@T("Preview feature visibility")" SelectedValue="@(() => this.SettingsManager.ConfigurationData.App.PreviewVisibility)" Data="@ConfigurationSelectDataFactory.GetPreviewVisibility()" SelectionUpdate="@this.UpdatePreviewFeatures" OptionHelp="@T("Do you want to show preview features in the app?")"/>
+    <ConfigurationSelect OptionDescription="@T("Preview feature visibility")" SelectedValue="@(() => this.SettingsManager.ConfigurationData.App.PreviewVisibility)" Data="@ConfigurationSelectDataFactory.GetPreviewVisibility()" SelectionUpdate="@this.UpdatePreviewFeatures" OptionHelp="@T("Do you want to show preview features in the app?")" IsLocked="() => ManagedConfiguration.TryGet(x => x.App, x => x.PreviewVisibility, out var meta) && meta.IsLocked"/>
 
     @if (this.SettingsManager.ConfigurationData.App.PreviewVisibility > PreviewVisibility.NONE)
     {
         var availablePreviewFeatures = ConfigurationSelectDataFactory.GetPreviewFeaturesData(this.SettingsManager).ToList();
         if (availablePreviewFeatures.Count > 0)
         {
-            <ConfigurationMultiSelect OptionDescription="@T("Select preview features")" SelectedValues="@(() => this.SettingsManager.ConfigurationData.App.EnabledPreviewFeatures.Where(x => !x.IsReleased()).ToHashSet())" Data="@availablePreviewFeatures" SelectionUpdate="@(selectedValue => this.SettingsManager.ConfigurationData.App.EnabledPreviewFeatures = selectedValue)" OptionHelp="@T("Which preview features would you like to enable?")"/>
+            <ConfigurationMultiSelect OptionDescription="@T("Select preview features")" SelectedValues="@(() => this.SettingsManager.ConfigurationData.App.EnabledPreviewFeatures.Where(x => !x.IsReleased()).ToHashSet())" Data="@availablePreviewFeatures" SelectionUpdate="@(selectedValue => this.SettingsManager.ConfigurationData.App.EnabledPreviewFeatures = selectedValue)" OptionHelp="@T("Which preview features would you like to enable?")" IsLocked="() => ManagedConfiguration.TryGet(x => x.App, x => x.EnabledPreviewFeatures, out var meta) && meta.IsLocked"/>
         }
     }
 

app/MindWork AI Studio/Plugins/configuration/plugin.lua

@@ -74,6 +74,18 @@ CONFIG["SETTINGS"] = {}
 -- Allowed values are: true, false
 -- CONFIG["SETTINGS"]["DataApp.AllowUserToAddProvider"] = false
 
+-- Configure the visibility of preview features:
+-- Allowed values are: NONE, RELEASE_CANDIDATE, BETA, ALPHA, PROTOTYPE, EXPERIMENTAL
+-- Please note:
+--      I: that this setting does not hide features that are already enabled.
+--     II: lower levels include all features of the higher levels. E.g. BETA includes RELEASE_CANDIDATE features.
+-- CONFIG["SETTINGS"]["DataApp.PreviewVisibility"] = "NONE"
+
+-- Configure the enabled preview features:
+-- Allowed values are can be found in https://github.com/MindWorkAI/AI-Studio/app/MindWork%20AI%20Studio/Settings/DataModel/PreviewFeatures.cs
+-- Examples are PRE_WRITER_MODE_2024, PRE_RAG_2024, PRE_DOCUMENT_ANALYSIS_2025.
+-- CONFIG["SETTINGS"]["DataApp.EnabledPreviewFeatures"] = { "PRE_RAG_2024", "PRE_DOCUMENT_ANALYSIS_2025" }
+
 -- Example chat templates for this configuration:
 CONFIG["CHAT_TEMPLATES"] = {}
 

app/MindWork AI Studio/Settings/DataModel/DataApp.cs

@@ -60,7 +60,7 @@ public sealed class DataApp(Expression<Func<Data, DataApp>>? configSelection = n
     /// <summary>
     /// The enabled preview features.
     /// </summary>
-    public HashSet<PreviewFeatures> EnabledPreviewFeatures { get; set; } = new();
+    public HashSet<PreviewFeatures> EnabledPreviewFeatures { get; set; } = ManagedConfiguration.Register(configSelection, n => n.EnabledPreviewFeatures, []);
     
     /// <summary>
     /// Should we preselect a provider for the entire app?

app/MindWork AI Studio/Settings/ManagedConfiguration.Parsing.cs

@@ -0,0 +1,736 @@
+using System.Globalization;
+using System.Linq.Expressions;
+
+using AIStudio.Settings.DataModel;
+
+using Lua;
+
+namespace AIStudio.Settings;
+
+public static partial class ManagedConfiguration
+{
+    /// <summary>
+    /// Attempts to process the configuration settings from a Lua table for enum types.
+    /// </summary>
+    /// <remarks>
+    /// When the configuration is successfully processed, it updates the configuration metadata with the configured value.
+    /// Furthermore, it locks the managed state of the configuration metadata to the provided configuration plugin ID.
+    /// The setting's value is set to the configured value.
+    /// </remarks>
+    /// <param name="configPluginId">The ID of the related configuration plugin.</param>
+    /// <param name="settings">The Lua table containing the settings to process.</param>
+    /// <param name="configSelection">The expression to select the configuration class.</param>
+    /// <param name="propertyExpression">The expression to select the property within the configuration class.</param>
+    /// <param name="dryRun">When true, the method will not apply any changes, but only check if the configuration can be read.</param>
+    /// <param name="_">An unused parameter to help with type inference for enum types. You might ignore it when calling the method.</param>
+    /// <typeparam name="TClass">The type of the configuration class.</typeparam>
+    /// <typeparam name="TValue">The type of the property within the configuration class.</typeparam>
+    /// <returns>True when the configuration was successfully processed, otherwise false.</returns>
+    public static bool TryProcessConfiguration<TClass, TValue>(
+        Expression<Func<Data, TClass>> configSelection,
+        Expression<Func<TClass, TValue>> propertyExpression,
+        Guid configPluginId,
+        LuaTable settings,
+        bool dryRun,
+        TValue? _ = default)
+        where TValue : Enum
+    {
+        //
+        // Handle configured enum values
+        //
+        
+        // Check if that configuration was registered:
+        if(!TryGet(configSelection, propertyExpression, out var configMeta))
+            return false;
+
+        var successful = false;
+        var configuredValue = configMeta.Default;
+        
+        // Step 1 -- try to read the Lua value out of the Lua table:
+        if(settings.TryGetValue(SettingsManager.ToSettingName(propertyExpression), out var configuredEnumValue))
+        {
+            // Step 2 -- try to read the Lua value as a string:
+            if(configuredEnumValue.TryRead<string>(out var configuredEnumText))
+            {
+                // Step 3 -- try to parse the string as the enum type:
+                if (Enum.TryParse(typeof(TValue), configuredEnumText, true, out var configuredEnum))
+                {
+                    configuredValue = (TValue)configuredEnum;
+                    successful = true;
+                }
+            }
+        }
+        
+        if(dryRun)
+            return successful;
+        
+        return HandleParsedValue(configPluginId, dryRun, successful, configMeta, configuredValue);
+    }
+
+    /// <summary>
+    /// Attempts to process the configuration settings from a Lua table for ISpanParsable types.
+    /// </summary>
+    /// <remarks>
+    /// When the configuration is successfully processed, it updates the configuration metadata with the configured value.
+    /// Furthermore, it locks the managed state of the configuration metadata to the provided configuration plugin ID.
+    /// The setting's value is set to the configured value.
+    /// </remarks>
+    /// <param name="configPluginId">The ID of the related configuration plugin.</param>
+    /// <param name="settings">The Lua table containing the settings to process.</param>
+    /// <param name="configSelection">The expression to select the configuration class.</param>
+    /// <param name="propertyExpression">The expression to select the property within the configuration class.</param>
+    /// <param name="dryRun">When true, the method will not apply any changes, but only check if the configuration can be read.</param>
+    /// <param name="_">An unused parameter to help with type inference. You might ignore it when calling the method.</param>
+    /// <typeparam name="TClass">The type of the configuration class.</typeparam>
+    /// <typeparam name="TValue">The type of the property within the configuration class.</typeparam>
+    /// <returns>True when the configuration was successfully processed, otherwise false.</returns>
+    public static bool TryProcessConfiguration<TClass, TValue>(
+        Expression<Func<Data, TClass>> configSelection,
+        Expression<Func<TClass, TValue>> propertyExpression,
+        Guid configPluginId,
+        LuaTable settings,
+        bool dryRun,
+        ISpanParsable<TValue>? _ = null)
+        where TValue : struct, ISpanParsable<TValue>
+    {
+        //
+        // Handle configured ISpanParsable values
+        //
+        
+        // Check if that configuration was registered:
+        if(!TryGet(configSelection, propertyExpression, out var configMeta))
+            return false;
+        
+        var successful = false;
+        var configuredValue = configMeta.Default;
+        
+        // Step 1 -- try to read the Lua value out of the Lua table:
+        if (settings.TryGetValue(SettingsManager.ToSettingName(propertyExpression), out var configuredLuaValue))
+        {
+            // Step 2a -- try to read the Lua value as a string:
+            if (configuredLuaValue.Type is LuaValueType.String && configuredLuaValue.TryRead<string>(out var configuredLuaValueText))
+            {
+                // Step 3 -- try to parse the string as the target type:
+                if (TValue.TryParse(configuredLuaValueText, CultureInfo.InvariantCulture, out var configuredParsedValue))
+                {
+                    configuredValue = configuredParsedValue;
+                    successful = true;
+                }
+            }
+            
+            // Step 2b -- try to read the Lua value:
+            if(configuredLuaValue.TryRead<TValue>(out var configuredLuaValueInstance))
+            {
+                configuredValue = configuredLuaValueInstance;
+                successful = true;
+            }
+        }
+
+        if(dryRun)
+            return successful;
+        
+        return HandleParsedValue(configPluginId, dryRun, successful, configMeta, configuredValue);
+    }
+    
+    /// <summary>
+    /// Attempts to process the configuration settings from a Lua table for string values.
+    /// </summary>
+    /// <remarks>
+    /// When the configuration is successfully processed, it updates the configuration metadata with the configured value.
+    /// Furthermore, it locks the managed state of the configuration metadata to the provided configuration plugin ID.
+    /// The setting's value is set to the configured value.
+    /// </remarks>
+    /// <param name="configPluginId">The ID of the related configuration plugin.</param>
+    /// <param name="settings">The Lua table containing the settings to process.</param>
+    /// <param name="configSelection">The expression to select the configuration class.</param>
+    /// <param name="propertyExpression">The expression to select the property within the configuration class.</param>
+    /// <param name="dryRun">When true, the method will not apply any changes, but only check if the configuration can be read.</param>
+    /// <typeparam name="TClass">The type of the configuration class.</typeparam>
+    /// <returns>True when the configuration was successfully processed, otherwise false.</returns>
+    public static bool TryProcessConfiguration<TClass>(
+        Expression<Func<Data, TClass>> configSelection,
+        Expression<Func<TClass, string>> propertyExpression,
+        Guid configPluginId,
+        LuaTable settings,
+        bool dryRun)
+    {
+        //
+        // Handle configured string values
+        //
+        
+        // Check if that configuration was registered:
+        if(!TryGet(configSelection, propertyExpression, out var configMeta))
+            return false;
+        
+        var successful = false;
+        var configuredValue = configMeta.Default;
+        
+        // Step 1 -- try to read the Lua value out of the Lua table:
+        if(settings.TryGetValue(SettingsManager.ToSettingName(propertyExpression), out var configuredTextValue))
+        {
+            // Step 2 -- try to read the Lua value as a string:
+            if(configuredTextValue.TryRead<string>(out var configuredText))
+            {
+                configuredValue = configuredText;
+                successful = true;
+            }
+        }
+        
+        return HandleParsedValue(configPluginId, dryRun, successful, configMeta, configuredValue);
+    }
+
+    /// <summary>
+    /// Attempts to process the configuration settings from a Lua table for ISpanParsable list types.
+    /// </summary>
+    /// <remarks>
+    /// When the configuration is successfully processed, it updates the configuration metadata with the configured value.
+    /// Furthermore, it locks the managed state of the configuration metadata to the provided configuration plugin ID.
+    /// The setting's value is set to the configured value.
+    /// </remarks>
+    /// <param name="configPluginId">The ID of the related configuration plugin.</param>
+    /// <param name="settings">The Lua table containing the settings to process.</param>
+    /// <param name="configSelection">The expression to select the configuration class.</param>
+    /// <param name="propertyExpression">The expression to select the property within the configuration class.</param>
+    /// <param name="dryRun">When true, the method will not apply any changes but only check if the configuration can be read.</param>
+    /// <param name="_">An unused parameter to help with type inference for ISpanParsable types. You might ignore it when calling the method.</param>
+    /// <typeparam name="TClass">The type of the configuration class.</typeparam>
+    /// <typeparam name="TValue">The type of the property within the configuration class. It is also the type of the list
+    /// elements, which must implement ISpanParsable.</typeparam>
+    /// <returns>True when the configuration was successfully processed, otherwise false.</returns>
+
+    // ReSharper disable MethodOverloadWithOptionalParameter
+    public static bool TryProcessConfiguration<TClass, TValue>(
+        Expression<Func<Data, TClass>> configSelection,
+        Expression<Func<TClass, IList<TValue>>> propertyExpression,
+        Guid configPluginId,
+        LuaTable settings,
+        bool dryRun,
+        ISpanParsable<TValue>? _ = null)
+        where TValue : ISpanParsable<TValue>
+    {
+        //
+        // Handle configured ISpanParsable lists
+        //
+
+        // Check if that configuration was registered:
+        if (!TryGet(configSelection, propertyExpression, out var configMeta))
+            return false;
+
+        var successful = false;
+        var configuredValue = configMeta.Default;
+
+        // Step 1 -- try to read the Lua value (we expect a table) out of the Lua table:
+        if (settings.TryGetValue(SettingsManager.ToSettingName(propertyExpression), out var configuredLuaList) &&
+            configuredLuaList.Type is LuaValueType.Table &&
+            configuredLuaList.TryRead<LuaTable>(out var valueTable))
+        {
+            // Determine the length of the Lua table and prepare a list to hold the parsed values:
+            var len = valueTable.ArrayLength;
+            var list = new List<TValue>(len);
+            
+            // Iterate over each entry in the Lua table:
+            for (var index = 1; index <= len; index++)
+            {
+                // Retrieve the Lua value at the current index:
+                var value = valueTable[index];
+                
+                // Step 2a -- try to read the Lua value as a string:
+                if (value.Type is LuaValueType.String && value.TryRead<string>(out var configuredLuaValueText))
+                {
+                    // Step 3 -- try to parse the string as the target type:
+                    if (TValue.TryParse(configuredLuaValueText, CultureInfo.InvariantCulture, out var configuredParsedValue))
+                        list.Add(configuredParsedValue);
+                }
+
+                // Step 2b -- try to read the Lua value:
+                if (value.TryRead<TValue>(out var configuredLuaValueInstance))
+                    list.Add(configuredLuaValueInstance);
+            }
+
+            configuredValue = list;
+            successful = true;
+        }
+
+        if (dryRun)
+            return successful;
+
+        return HandleParsedValue(configPluginId, dryRun, successful, configMeta, configuredValue);
+    }
+
+    // ReSharper restore MethodOverloadWithOptionalParameter
+    
+    /// <summary>
+    /// Attempts to process the configuration settings from a Lua table for enum list types.
+    /// </summary>
+    /// <remarks>
+    /// When the configuration is successfully processed, it updates the configuration metadata with the configured value.
+    /// Furthermore, it locks the managed state of the configuration metadata to the provided configuration plugin ID.
+    /// The setting's value is set to the configured value.
+    /// </remarks>
+    /// <param name="configPluginId">The ID of the related configuration plugin.</param>
+    /// <param name="settings">The Lua table containing the settings to process.</param>
+    /// <param name="configSelection">The expression to select the configuration class.</param>
+    /// <param name="propertyExpression">The expression to select the property within the configuration class.</param>
+    /// <param name="dryRun">When true, the method will not apply any changes but only check if the configuration can be read.</param>
+    /// <typeparam name="TClass">The type of the configuration class.</typeparam>
+    /// <typeparam name="TValue">The type of the property within the configuration class. It is also the type of the list
+    /// elements, which must be an enum.</typeparam>
+    /// <returns>True when the configuration was successfully processed, otherwise false.</returns>
+    public static bool TryProcessConfiguration<TClass, TValue>(
+        Expression<Func<Data, TClass>> configSelection,
+        Expression<Func<TClass, IList<TValue>>> propertyExpression,
+        Guid configPluginId,
+        LuaTable settings,
+        bool dryRun)
+        where TValue : Enum
+    {
+        //
+        // Handle configured enum lists
+        //
+        
+        // Check if that configuration was registered:
+        if(!TryGet(configSelection, propertyExpression, out var configMeta))
+            return false;
+        
+        var successful = false;
+        var configuredValue = configMeta.Default;
+        
+        // Step 1 -- try to read the Lua value (we expect a table) out of the Lua table:
+        if (settings.TryGetValue(SettingsManager.ToSettingName(propertyExpression), out var configuredLuaList) &&
+            configuredLuaList.Type is LuaValueType.Table &&
+            configuredLuaList.TryRead<LuaTable>(out var valueTable))
+        {
+            // Determine the length of the Lua table and prepare a list to hold the parsed values:
+            var len = valueTable.ArrayLength;
+            var list = new List<TValue>(len);
+            
+            // Iterate over each entry in the Lua table:
+            for (var index = 1; index <= len; index++)
+            {
+                // Retrieve the Lua value at the current index:
+                var value = valueTable[index];
+                
+                // Step 2 -- try to read the Lua value as a string:
+                if (value.Type is LuaValueType.String && value.TryRead<string>(out var configuredLuaValueText))
+                {
+                    // Step 3 -- try to parse the string as the target type:
+                    if (Enum.TryParse(typeof(TValue), configuredLuaValueText, true, out var configuredEnum))
+                        list.Add((TValue)configuredEnum);
+                }
+            }
+		
+            configuredValue = list;
+            successful = true;
+        }
+        
+        if(dryRun)
+            return successful;
+        
+        return HandleParsedValue(configPluginId, dryRun, successful, configMeta, configuredValue);
+    }
+    
+    /// <summary>
+    /// Attempts to process the configuration settings from a Lua table for string list types.
+    /// </summary>
+    /// <remarks>
+    /// When the configuration is successfully processed, it updates the configuration metadata with the configured value.
+    /// Furthermore, it locks the managed state of the configuration metadata to the provided configuration plugin ID.
+    /// The setting's value is set to the configured value.
+    /// </remarks>
+    /// <param name="configPluginId">The ID of the related configuration plugin.</param>
+    /// <param name="settings">The Lua table containing the settings to process.</param>
+    /// <param name="configSelection">The expression to select the configuration class.</param>
+    /// <param name="propertyExpression">The expression to select the property within the configuration class.</param>
+    /// <param name="dryRun">When true, the method will not apply any changes but only check if the configuration can be read.</param>
+    /// <typeparam name="TClass">The type of the configuration class.</typeparam>
+    /// <returns>True when the configuration was successfully processed, otherwise false.</returns>
+    public static bool TryProcessConfiguration<TClass>(
+        Expression<Func<Data, TClass>> configSelection,
+        Expression<Func<TClass, IList<string>>> propertyExpression,
+        Guid configPluginId,
+        LuaTable settings,
+        bool dryRun)
+    {
+        //
+        // Handle configured string lists
+        //
+        
+        // Check if that configuration was registered:
+        if(!TryGet(configSelection, propertyExpression, out var configMeta))
+            return false;
+        
+        var successful = false;
+        var configuredValue = configMeta.Default;
+        
+        // Step 1 -- try to read the Lua value (we expect a table) out of the Lua table:
+        if (settings.TryGetValue(SettingsManager.ToSettingName(propertyExpression), out var configuredLuaList) &&
+            configuredLuaList.Type is LuaValueType.Table &&
+            configuredLuaList.TryRead<LuaTable>(out var valueTable))
+        {
+            // Determine the length of the Lua table and prepare a list to hold the parsed values:
+            var len = valueTable.ArrayLength;
+            var list = new List<string>(len);
+            
+            // Iterate over each entry in the Lua table:
+            for (var index = 1; index <= len; index++)
+            {
+                // Retrieve the Lua value at the current index:
+                var value = valueTable[index];
+                
+                // Step 2 -- try to read the Lua value as a string:
+                if (value.Type is LuaValueType.String && value.TryRead<string>(out var configuredLuaValueText))
+                    list.Add(configuredLuaValueText);
+            }
+		
+            configuredValue = list;
+            successful = true;
+        }
+        
+        if(dryRun)
+            return successful;
+        
+        return HandleParsedValue(configPluginId, dryRun, successful, configMeta, configuredValue);
+    }
+
+    /// <summary>
+    /// Attempts to process the configuration settings from a Lua table for ISpanParsable set types.
+    /// </summary>
+    /// <remarks>
+    /// When the configuration is successfully processed, it updates the configuration metadata with the configured value.
+    /// Furthermore, it locks the managed state of the configuration metadata to the provided configuration plugin ID.
+    /// The setting's value is set to the configured value.
+    /// </remarks>
+    /// <param name="configPluginId">The ID of the related configuration plugin.</param>
+    /// <param name="settings">The Lua table containing the settings to process.</param>
+    /// <param name="configSelection">The expression to select the configuration class.</param>
+    /// <param name="propertyExpression">The expression to select the property within the configuration class.</param>
+    /// <param name="dryRun">When true, the method will not apply any changes but only check if the configuration can be read.</param>
+    /// <param name="_">An unused parameter to help with type inference for ISpanParsable types. You might ignore it when calling the method.</param>
+    /// <typeparam name="TClass">The type of the configuration class.</typeparam>
+    /// <typeparam name="TValue">The type of the property within the configuration class. It is also the type of the set
+    /// elements, which must implement ISpanParsable.</typeparam>
+    /// <returns>True when the configuration was successfully processed, otherwise false.</returns>
+
+    // ReSharper disable MethodOverloadWithOptionalParameter
+    public static bool TryProcessConfiguration<TClass, TValue>(
+        Expression<Func<Data, TClass>> configSelection,
+        Expression<Func<TClass, ISet<TValue>>> propertyExpression,
+        Guid configPluginId,
+        LuaTable settings,
+        bool dryRun,
+        ISpanParsable<TValue>? _ = null)
+        where TValue : ISpanParsable<TValue>
+    {
+        //
+        // Handle configured ISpanParsable sets
+        //
+
+        // Check if that configuration was registered:
+        if (!TryGet(configSelection, propertyExpression, out var configMeta))
+            return false;
+
+        var successful = false;
+        var configuredValue = configMeta.Default;
+
+        // Step 1 -- try to read the Lua value (we expect a table) out of the Lua table:
+        if (settings.TryGetValue(SettingsManager.ToSettingName(propertyExpression), out var configuredLuaList) &&
+            configuredLuaList.Type is LuaValueType.Table &&
+            configuredLuaList.TryRead<LuaTable>(out var valueTable))
+        {
+            // Determine the length of the Lua table and prepare a set to hold the parsed values:
+            var len = valueTable.ArrayLength;
+            var set = new HashSet<TValue>(len);
+            
+            // Iterate over each entry in the Lua table:
+            for (var index = 1; index <= len; index++)
+            {
+                // Retrieve the Lua value at the current index:
+                var value = valueTable[index];
+                
+                // Step 2a -- try to read the Lua value as a string:
+                if (value.Type is LuaValueType.String && value.TryRead<string>(out var configuredLuaValueText))
+                {
+                    // Step 3 -- try to parse the string as the target type:
+                    if (TValue.TryParse(configuredLuaValueText, CultureInfo.InvariantCulture, out var configuredParsedValue))
+                        set.Add(configuredParsedValue);
+                }
+
+                // Step 2b -- try to read the Lua value:
+                if (value.TryRead<TValue>(out var configuredLuaValueInstance))
+                    set.Add(configuredLuaValueInstance);
+            }
+
+            configuredValue = set;
+            successful = true;
+        }
+
+        if (dryRun)
+            return successful;
+
+        return HandleParsedValue(configPluginId, dryRun, successful, configMeta, configuredValue);
+    }
+
+    // ReSharper restore MethodOverloadWithOptionalParameter
+    
+    /// <summary>
+    /// Attempts to process the configuration settings from a Lua table for enum set types.
+    /// </summary>
+    /// <remarks>
+    /// When the configuration is successfully processed, it updates the configuration metadata with the configured value.
+    /// Furthermore, it locks the managed state of the configuration metadata to the provided configuration plugin ID.
+    /// The setting's value is set to the configured value.
+    /// </remarks>
+    /// <param name="configPluginId">The ID of the related configuration plugin.</param>
+    /// <param name="settings">The Lua table containing the settings to process.</param>
+    /// <param name="configSelection">The expression to select the configuration class.</param>
+    /// <param name="propertyExpression">The expression to select the property within the configuration class.</param>
+    /// <param name="dryRun">When true, the method will not apply any changes but only check if the configuration can be read.</param>
+    /// <typeparam name="TClass">The type of the configuration class.</typeparam>
+    /// <typeparam name="TValue">The type of the property within the configuration class. It is also the type of the set
+    /// elements, which must be an enum.</typeparam>
+    /// <returns>True when the configuration was successfully processed, otherwise false.</returns>
+    public static bool TryProcessConfiguration<TClass, TValue>(
+        Expression<Func<Data, TClass>> configSelection,
+        Expression<Func<TClass, ISet<TValue>>> propertyExpression,
+        Guid configPluginId,
+        LuaTable settings,
+        bool dryRun)
+        where TValue : Enum
+    {
+        //
+        // Handle configured enum sets
+        //
+        
+        // Check if that configuration was registered:
+        if(!TryGet(configSelection, propertyExpression, out var configMeta))
+            return false;
+        
+        var successful = false;
+        var configuredValue = configMeta.Default;
+        
+        // Step 1 -- try to read the Lua value (we expect a table) out of the Lua table:
+        if (settings.TryGetValue(SettingsManager.ToSettingName(propertyExpression), out var configuredLuaList) &&
+            configuredLuaList.Type is LuaValueType.Table &&
+            configuredLuaList.TryRead<LuaTable>(out var valueTable))
+        {
+            // Determine the length of the Lua table and prepare a set to hold the parsed values:
+            var len = valueTable.ArrayLength;
+            var set = new HashSet<TValue>(len);
+            
+            // Iterate over each entry in the Lua table:
+            for (var index = 1; index <= len; index++)
+            {
+                // Retrieve the Lua value at the current index:
+                var value = valueTable[index];
+                
+                // Step 2 -- try to read the Lua value as a string:
+                if (value.Type is LuaValueType.String && value.TryRead<string>(out var configuredLuaValueText))
+                {
+                    // Step 3 -- try to parse the string as the target type:
+                    if (Enum.TryParse(typeof(TValue), configuredLuaValueText, true, out var configuredEnum))
+                        set.Add((TValue)configuredEnum);
+                }
+            }
+		
+            configuredValue = set;
+            successful = true;
+        }
+        
+        if(dryRun)
+            return successful;
+        
+        return HandleParsedValue(configPluginId, dryRun, successful, configMeta, configuredValue);
+    }
+    
+    /// <summary>
+    /// Attempts to process the configuration settings from a Lua table for string set types.
+    /// </summary>
+    /// <remarks>
+    /// When the configuration is successfully processed, it updates the configuration metadata with the configured value.
+    /// Furthermore, it locks the managed state of the configuration metadata to the provided configuration plugin ID.
+    /// The setting's value is set to the configured value.
+    /// </remarks>
+    /// <param name="configPluginId">The ID of the related configuration plugin.</param>
+    /// <param name="settings">The Lua table containing the settings to process.</param>
+    /// <param name="configSelection">The expression to select the configuration class.</param>
+    /// <param name="propertyExpression">The expression to select the property within the configuration class.</param>
+    /// <param name="dryRun">When true, the method will not apply any changes but only check if the configuration can be read.</param>
+    /// <typeparam name="TClass">The type of the configuration class.</typeparam>
+    /// <returns>True when the configuration was successfully processed, otherwise false.</returns>
+    public static bool TryProcessConfiguration<TClass>(
+        Expression<Func<Data, TClass>> configSelection,
+        Expression<Func<TClass, ISet<string>>> propertyExpression,
+        Guid configPluginId,
+        LuaTable settings,
+        bool dryRun)
+    {
+        //
+        // Handle configured string sets
+        //
+        
+        // Check if that configuration was registered:
+        if(!TryGet(configSelection, propertyExpression, out var configMeta))
+            return false;
+        
+        var successful = false;
+        var configuredValue = configMeta.Default;
+        
+        // Step 1 -- try to read the Lua value (we expect a table) out of the Lua table:
+        if (settings.TryGetValue(SettingsManager.ToSettingName(propertyExpression), out var configuredLuaList) &&
+            configuredLuaList.Type is LuaValueType.Table &&
+            configuredLuaList.TryRead<LuaTable>(out var valueTable))
+        {
+            // Determine the length of the Lua table and prepare a set to hold the parsed values:
+            var len = valueTable.ArrayLength;
+            var set = new HashSet<string>(len);
+            
+            // Iterate over each entry in the Lua table:
+            for (var index = 1; index <= len; index++)
+            {
+                // Retrieve the Lua value at the current index:
+                var value = valueTable[index];
+                
+                // Step 2 -- try to read the Lua value as a string:
+                if (value.Type is LuaValueType.String && value.TryRead<string>(out var configuredLuaValueText))
+                    set.Add(configuredLuaValueText);
+            }
+		
+            configuredValue = set;
+            successful = true;
+        }
+        
+        if(dryRun)
+            return successful;
+        
+        return HandleParsedValue(configPluginId, dryRun, successful, configMeta, configuredValue);
+    }
+    
+    /// <summary>
+    /// Attempts to process the configuration settings from a Lua table for string dictionary types.
+    /// </summary>
+    /// <remarks>
+    /// When the configuration is successfully processed, it updates the configuration metadata with the configured value.
+    /// Furthermore, it locks the managed state of the configuration metadata to the provided configuration plugin ID.
+    /// The setting's value is set to the configured value.
+    /// </remarks>
+    /// <param name="configPluginId">The ID of the related configuration plugin.</param>
+    /// <param name="settings">The Lua table containing the settings to process.</param>
+    /// <param name="configSelection">The expression to select the configuration class.</param>
+    /// <param name="propertyExpression">The expression to select the property within the configuration class.</param>
+    /// <param name="dryRun">When true, the method will not apply any changes but only check if the configuration can be read.</param>
+    /// <typeparam name="TClass">The type of the configuration class.</typeparam>
+    /// <returns>True when the configuration was successfully processed, otherwise false.</returns>
+    public static bool TryProcessConfiguration<TClass>(
+        Expression<Func<Data, TClass>> configSelection,
+        Expression<Func<TClass, IDictionary<string, string>>> propertyExpression,
+        Guid configPluginId,
+        LuaTable settings,
+        bool dryRun)
+    {
+        //
+        // Handle configured string dictionaries (both keys and values are strings)
+        //
+        
+        // Check if that configuration was registered:
+        if(!TryGet(configSelection, propertyExpression, out var configMeta))
+            return false;
+        
+        var successful = false;
+        var configuredValue = configMeta.Default;
+        
+        // Step 1 -- try to read the Lua value (we expect a table) out of the Lua table:
+        if (settings.TryGetValue(SettingsManager.ToSettingName(propertyExpression), out var configuredLuaList) &&
+            configuredLuaList.Type is LuaValueType.Table &&
+            configuredLuaList.TryRead<LuaTable>(out var valueTable))
+        {
+            // Determine the length of the Lua table and prepare a dictionary to hold the parsed key-value pairs.
+            // Instead of using ArrayLength, we use HashMapCount to get the number of key-value pairs:
+            var len = valueTable.HashMapCount;
+            if (len > 0)
+                configuredValue.Clear();
+            
+            // In order to iterate over all key-value pairs in the Lua table, we have to use TryGetNext.
+            // Thus, we initialize the previous key variable to Nil and keep calling TryGetNext until
+            // there are no more pairs:
+            var previousKey = LuaValue.Nil;
+            while(valueTable.TryGetNext(previousKey, out var pair))
+            {
+                // Update the previous key for the next iteration:
+                previousKey = pair.Key;
+                
+                // Try to read both the key and the value as strings:
+                var hadKey = pair.Key.TryRead<string>(out var key);
+                var hadValue = pair.Value.TryRead<string>(out var value);
+                
+                // If both key and value were read successfully, add them to the dictionary:
+                if (hadKey && hadValue)
+                    configuredValue[key] = value;
+            }
+		
+            successful = true;
+        }
+        
+        if(dryRun)
+            return successful;
+
+        return HandleParsedValue(configPluginId, dryRun, successful, configMeta, configuredValue);
+    }
+
+    /// <summary>
+    /// Handles the parsed configuration value based on whether the parsing was successful and whether it's a dry run.
+    /// </summary>
+    /// <param name="configPluginId">The ID of the related configuration plugin.</param>
+    /// <param name="dryRun">When true, no changes will be applied.</param>
+    /// <param name="successful">Indicates whether the configuration value was successfully parsed.</param>
+    /// <param name="configMeta">The configuration metadata.</param>
+    /// <param name="configuredValue">>The parsed configuration value.</param>
+    /// <typeparam name="TClass">The type of the configuration class.</typeparam>
+    /// <typeparam name="TValue">The type of the configuration property value.</typeparam>
+    /// <returns>True when the configuration was successfully processed, otherwise false.</returns>
+    private static bool HandleParsedValue<TClass, TValue>(
+        Guid configPluginId,
+        bool dryRun,
+        bool successful,
+        ConfigMeta<TClass, TValue> configMeta,
+        TValue configuredValue)
+    {
+        if(dryRun)
+            return successful;
+        
+        switch (successful)
+        {
+            case true:
+                //
+                // Case: the setting was configured, and we could read the value successfully.
+                //
+                
+                // Set the configured value and lock the managed state:
+                configMeta.SetValue(configuredValue);
+                configMeta.LockManagedState(configPluginId);
+                break;
+
+            case false when configMeta.IsLocked && configMeta.MangedByConfigPluginId == configPluginId:
+                //
+                // Case: the setting was configured previously, but we could not read the value successfully.
+                // This happens when the setting was removed from the configuration plugin. We handle that
+                // case only when the setting was locked and managed by the same configuration plugin.
+                //
+                // The other case, when the setting was locked and managed by a different configuration plugin,
+                // is handled by the IsConfigurationLeftOver method, which checks if the configuration plugin
+                // is still available. If it is not available, it resets the managed state of the
+                // configuration setting, allowing it to be reconfigured by a different plugin or left unchanged.
+                //
+                configMeta.ResetManagedState();
+                break;
+            
+            case false:
+                //
+                // Case: the setting was not configured, or we could not read the value successfully.
+                // We do not change the setting, and it remains at whatever value it had before.
+                //
+                break;
+        }
+
+        return successful;
+    }
+}

app/MindWork AI Studio/Settings/ManagedConfiguration.Register.cs

@@ -0,0 +1,274 @@
+using System.Linq.Expressions;
+
+using AIStudio.Settings.DataModel;
+
+namespace AIStudio.Settings;
+
+public static partial class ManagedConfiguration
+{
+    /// <summary>
+    /// Registers a configuration setting with a default value.
+    /// </summary>
+    /// <remarks>
+    /// When called from the JSON deserializer, the configSelection parameter will be null.
+    /// In this case, the method will return the default value without registering the setting.
+    /// </remarks>
+    /// <param name="configSelection">The expression to select the configuration class.</param>
+    /// <param name="propertyExpression">The expression to select the property within the configuration class.</param>
+    /// <param name="defaultValue">The default value to use when the setting is not configured.</param>
+    /// <typeparam name="TClass">The type of the configuration class.</typeparam>
+    /// <typeparam name="TValue">The type of the property within the configuration class.</typeparam>
+    /// <returns>The default value.</returns>
+    public static TValue Register<TClass, TValue>(
+        Expression<Func<Data, TClass>>? configSelection,
+        Expression<Func<TClass, TValue>> propertyExpression,
+        TValue defaultValue)
+        where TValue : struct
+    {
+        // When called from the JSON deserializer by using the standard constructor,
+        // we ignore the register call and return the default value:
+        if (configSelection is null)
+            return defaultValue;
+
+        var configPath = Path(configSelection, propertyExpression);
+
+        // If the metadata already exists for this configuration path, we return the default value:
+        if (METADATA.ContainsKey(configPath))
+            return defaultValue;
+
+        // Not registered yet, so we register it now:
+        METADATA[configPath] = new ConfigMeta<TClass, TValue>(configSelection, propertyExpression)
+        {
+            Default = defaultValue,
+        };
+
+        return defaultValue;
+    }
+
+    /// <summary>
+    /// Registers a configuration setting with a default value.
+    /// </summary>
+    /// <remarks>
+    /// When called from the JSON deserializer, the configSelection parameter will be null.
+    /// In this case, the method will return the default value without registering the setting.
+    /// </remarks>
+    /// <param name="configSelection">The expression to select the configuration class.</param>
+    /// <param name="propertyExpression">The expression to select the property within the configuration class.</param>
+    /// <param name="defaultValue">The default value to use when the setting is not configured.</param>
+    /// <typeparam name="TClass">The type of the configuration class.</typeparam>
+    /// <returns>The default value.</returns>
+    public static string Register<TClass>(
+        Expression<Func<Data, TClass>>? configSelection,
+        Expression<Func<TClass, string>> propertyExpression,
+        string defaultValue)
+    {
+        // When called from the JSON deserializer by using the standard constructor,
+        // we ignore the register call and return the default value:
+        if(configSelection is null)
+            return defaultValue;
+		
+        var configPath = Path(configSelection, propertyExpression);
+
+        // If the metadata already exists for this configuration path, we return the default value:
+        if (METADATA.ContainsKey(configPath))
+            return defaultValue;
+        
+        // Not registered yet, so we register it now:
+        METADATA[configPath] = new ConfigMeta<TClass, string>(configSelection, propertyExpression)
+        {
+            Default = defaultValue,
+        };
+
+        return defaultValue;
+    }
+
+    /// <summary>
+    /// Registers a configuration setting with a default value for a IList of TValue.
+    /// </summary>
+    /// <remarks>
+    /// If the configSelection parameter is null, the method returns a list containing the default value
+    /// without registering the configuration setting.
+    /// </remarks>
+    /// <param name="configSelection">The expression to select the configuration class.</param>
+    /// <param name="propertyExpression">The expression to select the property within the configuration class.</param>
+    /// <param name="defaultValue">The default value to use when the setting is not configured.</param>
+    /// <typeparam name="TClass">The type of the configuration class.</typeparam>
+    /// <typeparam name="TValue">The type of the elements in the list within the configuration class.</typeparam>
+    /// <returns>A list containing the default value.</returns>
+    public static List<TValue> Register<TClass, TValue>(
+        Expression<Func<Data, TClass>>? configSelection,
+        Expression<Func<TClass, IList<TValue>>> propertyExpression,
+        TValue defaultValue)
+    {
+        // When called from the JSON deserializer by using the standard constructor,
+        // we ignore the register call and return the default value:
+        if(configSelection is null)
+            return [defaultValue];
+		
+        var configPath = Path(configSelection, propertyExpression);
+
+        // If the metadata already exists for this configuration path, we return the default value:
+        if (METADATA.ContainsKey(configPath))
+            return [defaultValue];
+        
+        // Not registered yet, so we register it now:
+        METADATA[configPath] = new ConfigMeta<TClass, IList<TValue>>(configSelection, propertyExpression)
+        {
+            Default = [defaultValue],
+        };
+
+        return [defaultValue];
+    }
+
+    /// <summary>
+    /// Registers a configuration setting with multiple default values.
+    /// </summary>
+    /// <remarks>
+    /// When called with a null configSelection parameter, the method ignores the register call and directly returns the default values.
+    /// If the configuration path already exists in the metadata, the method also returns the default values without registering new metadata.
+    /// </remarks>
+    /// <param name="configSelection">The expression used to select the configuration class.</param>
+    /// <param name="propertyExpression">The expression used to select the property within the configuration class.</param>
+    /// <param name="defaultValues">The list of default values to be used when the configuration setting is not defined.</param>
+    /// <typeparam name="TClass">The type of the configuration class.</typeparam>
+    /// <typeparam name="TValue">The type of the elements within the property list.</typeparam>
+    /// <returns>The list of default values.</returns>
+    public static List<TValue> Register<TClass, TValue>(
+        Expression<Func<Data, TClass>>? configSelection,
+        Expression<Func<TClass, IList<TValue>>> propertyExpression,
+        IList<TValue> defaultValues)
+    {
+        // When called from the JSON deserializer by using the standard constructor,
+        // we ignore the register call and return the default value:
+        if(configSelection is null)
+            return [..defaultValues];
+		
+        var configPath = Path(configSelection, propertyExpression);
+
+        // If the metadata already exists for this configuration path, we return the default value:
+        if (METADATA.ContainsKey(configPath))
+            return [..defaultValues];
+        
+        // Not registered yet, so we register it now:
+        METADATA[configPath] = new ConfigMeta<TClass, IList<TValue>>(configSelection, propertyExpression)
+        {
+            Default = [..defaultValues],
+        };
+
+        return [..defaultValues];
+    }
+
+    /// <summary>
+    /// Registers a configuration setting with a default value.
+    /// </summary>
+    /// <remarks>
+    /// When called with a null configSelection, this method returns the default value without registering the setting.
+    /// </remarks>
+    /// <param name="configSelection">The expression to select the configuration class.</param>
+    /// <param name="propertyExpression">The expression to select the set within the configuration class.</param>
+    /// <param name="defaultValue">The default value to use when the setting is not configured.</param>
+    /// <typeparam name="TClass">The type of the configuration class.</typeparam>
+    /// <typeparam name="TValue">The type of the values within the set.</typeparam>
+    /// <returns>A set containing the default value.</returns>
+    public static HashSet<TValue> Register<TClass, TValue>(
+        Expression<Func<Data, TClass>>? configSelection,
+        Expression<Func<TClass, ISet<TValue>>> propertyExpression,
+        TValue defaultValue)
+    {
+        // When called from the JSON deserializer by using the standard constructor,
+        // we ignore the register call and return the default value:
+        if (configSelection is null)
+            return [defaultValue];
+		
+        var configPath = Path(configSelection, propertyExpression);
+
+        // If the metadata already exists for this configuration path, we return the default value:
+        if (METADATA.ContainsKey(configPath))
+            return [defaultValue];
+        
+        // Not registered yet, so we register it now:
+        METADATA[configPath] = new ConfigMeta<TClass, ISet<TValue>>(configSelection, propertyExpression)
+        {
+            Default = new HashSet<TValue> { defaultValue },
+        };
+
+        return [defaultValue];
+    }
+
+    /// <summary>
+    /// Registers a configuration setting with a collection of default values.
+    /// </summary>
+    /// <remarks>
+    /// When the method is invoked with a null configSelection, the configuration path
+    /// is ignored, and the specified default values are returned without registration.
+    /// </remarks>
+    /// <param name="configSelection">The expression that selects the configuration class from the root Data model.</param>
+    /// <param name="propertyExpression">The expression to select the property within the configuration class.</param>
+    /// <param name="defaultValues">The default collection of values to use when the setting is not configured.</param>
+    /// <typeparam name="TClass">The type of the configuration class from which the property is selected.</typeparam>
+    /// <typeparam name="TValue">The type of the elements in the collection associated with the configuration property.</typeparam>
+    /// <returns>A set containing the default values.</returns>
+    public static HashSet<TValue> Register<TClass, TValue>(
+        Expression<Func<Data, TClass>>? configSelection,
+        Expression<Func<TClass, ISet<TValue>>> propertyExpression,
+        IList<TValue> defaultValues)
+    {
+        // When called from the JSON deserializer by using the standard constructor,
+        // we ignore the register call and return the default value:
+        if (configSelection is null)
+            return [..defaultValues];
+		
+        var configPath = Path(configSelection, propertyExpression);
+
+        // If the metadata already exists for this configuration path, we return the default value:
+        if (METADATA.ContainsKey(configPath))
+            return [..defaultValues];
+        
+        // Not registered yet, so we register it now:
+        METADATA[configPath] = new ConfigMeta<TClass, ISet<TValue>>(configSelection, propertyExpression)
+        {
+            Default = new HashSet<TValue>(defaultValues),
+        };
+
+        return [..defaultValues];
+    }
+
+    /// <summary>
+    /// Registers a configuration setting with a default dictionary of string key-value pairs.
+    /// </summary>
+    /// <remarks>
+    /// When the method is invoked with a null configSelection, the configuration path
+    /// is ignored, and the specified default values are returned without registration.
+    /// </remarks>
+    /// <param name="configSelection">The expression that selects the configuration class from the root Data model.</param>
+    /// <param name="propertyExpression">The expression to select the property within the configuration class.</param>
+    /// <param name="defaultValues">The default dictionary of values to use when the setting is not configured.</param>
+    /// <typeparam name="TClass">The type of the configuration class from which the property is selected.</typeparam>
+    /// <typeparam name="TDict">>The type of the dictionary within the configuration class.</typeparam>
+    /// <returns>A dictionary containing the default values.</returns>
+    public static TDict Register<TClass, TDict>(
+        Expression<Func<Data, TClass>>? configSelection,
+        Expression<Func<TClass, IDictionary<string, string>>> propertyExpression,
+        TDict defaultValues)
+        where TDict : IDictionary<string, string>, new()
+    {
+        // When called from the JSON deserializer by using the standard constructor,
+        // we ignore the register call and return the default value:
+        if (configSelection is null)
+            return new();
+
+        var configPath = Path(configSelection, propertyExpression);
+
+        // If the metadata already exists for this configuration path, we return the default value:
+        if (METADATA.ContainsKey(configPath))
+            return defaultValues;
+
+        // Not registered yet, so we register it now:
+        METADATA[configPath] = new ConfigMeta<TClass, IDictionary<string, string>>(configSelection, propertyExpression)
+        {
+            Default = defaultValues,
+        };
+        
+        return defaultValues;
+    }
+}

app/MindWork AI Studio/Settings/ManagedConfiguration.cs

@@ -4,62 +4,34 @@ using System.Linq.Expressions;
 using AIStudio.Settings.DataModel;
 using AIStudio.Tools.PluginSystem;
 
-using Lua;
-
 namespace AIStudio.Settings;
 
-public static class ManagedConfiguration
+public static partial class ManagedConfiguration
 {
     private static readonly ConcurrentDictionary<string, IConfig> METADATA = new();
 
     /// <summary>
-    /// Registers a configuration setting with a default value.
+    /// Attempts to retrieve the configuration metadata for a given configuration selection and
+    /// property expression (enum-based).
     /// </summary>
     /// <remarks>
-    /// When called from the JSON deserializer, the configSelection parameter will be null.
-    /// In this case, the method will return the default value without registering the setting.
+    /// When no configuration metadata is found, it returns a NoConfig instance with the default
+    /// value set to default(TValue). This allows the caller to handle the absence of configuration
+    /// gracefully. In such cases, the return value of the method will be false.
     /// </remarks>
     /// <param name="configSelection">The expression to select the configuration class.</param>
-    /// <param name="propertyExpression">The expression to select the property within the configuration class.</param>
-    /// <param name="defaultValue">The default value to use when the setting is not configured.</param>
-    /// <typeparam name="TClass">The type of the configuration class.</typeparam>
-    /// <typeparam name="TValue">The type of the property within the configuration class.</typeparam>
-    /// <returns>The default value.</returns>
-    public static TValue Register<TClass, TValue>(Expression<Func<Data, TClass>>? configSelection, Expression<Func<TClass, TValue>> propertyExpression, TValue defaultValue)
-    {
-        // When called from the JSON deserializer by using the standard constructor,
-        // we ignore the register call and return the default value:
-        if(configSelection is null)
-            return defaultValue;
-		
-        var configPath = Path(configSelection, propertyExpression);
-
-        // If the metadata already exists for this configuration path, we return the default value:
-        if (METADATA.ContainsKey(configPath))
-            return defaultValue;
-        
-        METADATA[configPath] = new ConfigMeta<TClass, TValue>(configSelection, propertyExpression)
-        {
-            Default = defaultValue,
-        };
-
-        return defaultValue;
-    }
-
-    /// <summary>
-    /// Attempts to retrieve the configuration metadata for a given configuration selection and property expression.
-    /// </summary>
-    /// <remarks>
-    /// When no configuration metadata is found, it returns a NoConfig instance with the default value set to default(TValue).
-    /// This allows the caller to handle the absence of configuration gracefully. In such cases, the return value of the method will be false.
-    /// </remarks>
-    /// <param name="configSelection">The expression to select the configuration class.</param>
-    /// <param name="propertyExpression">The expression to select the property within the configuration class.</param>
-    /// <param name="configMeta">The output parameter that will hold the configuration metadata if found.</param>
+    /// <param name="propertyExpression">The expression to select the property within the
+    /// configuration class.</param>
+    /// <param name="configMeta">The output parameter that will hold the configuration metadata
+    /// if found.</param>
     /// <typeparam name="TClass">The type of the configuration class.</typeparam>
     /// <typeparam name="TValue">The type of the property within the configuration class.</typeparam>
     /// <returns>True if the configuration metadata was found, otherwise false.</returns>
-    public static bool TryGet<TClass, TValue>(Expression<Func<Data, TClass>> configSelection, Expression<Func<TClass, TValue>> propertyExpression, out ConfigMeta<TClass, TValue> configMeta)
+    public static bool TryGet<TClass, TValue>(
+        Expression<Func<Data, TClass>> configSelection,
+        Expression<Func<TClass, TValue>> propertyExpression,
+        out ConfigMeta<TClass, TValue> configMeta)
+        where TValue : Enum
     {
         var configPath = Path(configSelection, propertyExpression);
         if (METADATA.TryGetValue(configPath, out var value) && value is ConfigMeta<TClass, TValue> meta)
@@ -77,77 +49,185 @@ public static class ManagedConfiguration
     }
 
     /// <summary>
-    /// Attempts to process the configuration settings from a Lua table.
+    /// Attempts to retrieve the configuration metadata for a given configuration selection and
+    /// property expression (string-based).
     /// </summary>
     /// <remarks>
-    /// When the configuration is successfully processed, it updates the configuration metadata with the configured value.
-    /// Furthermore, it locks the managed state of the configuration metadata to the provided configuration plugin ID.
-    /// The setting's value is set to the configured value.
+    /// When no configuration metadata is found, it returns a NoConfig instance with the default
+    /// value set to default(TValue). This allows the caller to handle the absence of configuration
+    /// gracefully. In such cases, the return value of the method will be false.
     /// </remarks>
-    /// <param name="configPluginId">The ID of the related configuration plugin.</param>
-    /// <param name="settings">The Lua table containing the settings to process.</param>
     /// <param name="configSelection">The expression to select the configuration class.</param>
-    /// <param name="propertyExpression">The expression to select the property within the configuration class.</param>
-    /// <param name="dryRun">When true, the method will not apply any changes, but only check if the configuration can be read.</param>
+    /// <param name="propertyExpression">The expression to select the property within the
+    /// configuration class.</param>
+    /// <param name="configMeta">The output parameter that will hold the configuration metadata
+    /// if found.</param>
     /// <typeparam name="TClass">The type of the configuration class.</typeparam>
-    /// <typeparam name="TValue">The type of the property within the configuration class.</typeparam>
-    /// <returns>True when the configuration was successfully processed, otherwise false.</returns>
-    public static bool TryProcessConfiguration<TClass, TValue>(Expression<Func<Data, TClass>> configSelection, Expression<Func<TClass, TValue>> propertyExpression, Guid configPluginId, LuaTable settings, bool dryRun)
+    /// <returns>True if the configuration metadata was found, otherwise false.</returns>
+    public static bool TryGet<TClass>(
+        Expression<Func<Data, TClass>> configSelection,
+        Expression<Func<TClass, string>> propertyExpression,
+        out ConfigMeta<TClass, string> configMeta)
     {
-        if(!TryGet(configSelection, propertyExpression, out var configMeta))
-            return false;
-        
-        var (configuredValue, successful) = configMeta.Default switch
+        var configPath = Path(configSelection, propertyExpression);
+        if (METADATA.TryGetValue(configPath, out var value) && value is ConfigMeta<TClass, string> meta)
         {
-            Enum => settings.TryGetValue(SettingsManager.ToSettingName(propertyExpression), out var configuredEnumValue) && configuredEnumValue.TryRead<string>(out var configuredEnumText) && Enum.TryParse(typeof(TValue), configuredEnumText, true, out var configuredEnum) ? ((TValue)configuredEnum, true) : (configMeta.Default, false),
-            Guid => settings.TryGetValue(SettingsManager.ToSettingName(propertyExpression), out var configuredGuidValue) && configuredGuidValue.TryRead<string>(out var configuredGuidText) && Guid.TryParse(configuredGuidText, out var configuredGuid) ? ((TValue)(object)configuredGuid, true) : (configMeta.Default, false),
-
-            string => settings.TryGetValue(SettingsManager.ToSettingName(propertyExpression), out var configuredTextValue) && configuredTextValue.TryRead<string>(out var configuredText) ? ((TValue)(object)configuredText, true) : (configMeta.Default, false),
-            bool => settings.TryGetValue(SettingsManager.ToSettingName(propertyExpression), out var configuredBoolValue) && configuredBoolValue.TryRead<bool>(out var configuredState) ? ((TValue)(object)configuredState, true) : (configMeta.Default, false),
-
-            int => settings.TryGetValue(SettingsManager.ToSettingName(propertyExpression), out var configuredIntValue) && configuredIntValue.TryRead<int>(out var configuredInt) ? ((TValue)(object)configuredInt, true) : (configMeta.Default, false),
-            double => settings.TryGetValue(SettingsManager.ToSettingName(propertyExpression), out var configuredDoubleValue) && configuredDoubleValue.TryRead<double>(out var configuredDouble) ? ((TValue)(object)configuredDouble, true) : (configMeta.Default, false),
-            float => settings.TryGetValue(SettingsManager.ToSettingName(propertyExpression), out var configuredFloatValue) && configuredFloatValue.TryRead<float>(out var configuredFloat) ? ((TValue)(object)configuredFloat, true) : (configMeta.Default, false),
-
-            _ => (configMeta.Default, false),
-        };
-
-        if(dryRun)
-            return successful;
-        
-        switch (successful)
-        {
-            case true:
-                //
-                // Case: the setting was configured, and we could read the value successfully.
-                //
-                configMeta.SetValue(configuredValue);
-                configMeta.LockManagedState(configPluginId);
-                break;
-
-            case false when configMeta.IsLocked && configMeta.MangedByConfigPluginId == configPluginId:
-                //
-                // Case: the setting was configured previously, but we could not read the value successfully.
-                // This happens when the setting was removed from the configuration plugin. We handle that
-                // case only when the setting was locked and managed by the same configuration plugin.
-                //
-                // The other case, when the setting was locked and managed by a different configuration plugin,
-                // is handled by the IsConfigurationLeftOver method, which checks if the configuration plugin
-                // is still available. If it is not available, it resets the managed state of the
-                // configuration setting, allowing it to be reconfigured by a different plugin or left unchanged.
-                //
-                configMeta.ResetManagedState();
-                break;
-            
-            case false:
-                //
-                // Case: the setting was not configured, or we could not read the value successfully.
-                // We do not change the setting, and it remains at whatever value it had before.
-                //
-                break;
+            configMeta = meta;
+            return true;
         }
 
-        return successful;
+        configMeta = new NoConfig<TClass, string>(configSelection, propertyExpression)
+        {
+            Default = string.Empty,
+        };
+        return false;
+    }
+
+    /// <summary>
+    /// Attempts to retrieve the configuration metadata for a given configuration selection and
+    /// property expression (ISpanParsable-based).
+    /// </summary>
+    /// <remarks>
+    /// When no configuration metadata is found, it returns a NoConfig instance with the default
+    /// value set to default(TValue). This allows the caller to handle the absence of configuration
+    /// gracefully. In such cases, the return value of the method will be false.
+    /// </remarks>
+    /// <param name="configSelection">The expression to select the configuration class.</param>
+    /// <param name="propertyExpression">The expression to select the property within the
+    /// configuration class.</param>
+    /// <param name="configMeta">The output parameter that will hold the configuration metadata
+    /// if found.</param>
+    /// <param name="_">An optional parameter to help with method overload resolution.</param>
+    /// <typeparam name="TClass">The type of the configuration class.</typeparam>
+    /// <typeparam name="TValue">The type of the property within the configuration class.</typeparam>
+    /// <returns>True if the configuration metadata was found, otherwise false.</returns>
+
+    // ReSharper disable MethodOverloadWithOptionalParameter
+    public static bool TryGet<TClass, TValue>(
+        Expression<Func<Data, TClass>> configSelection,
+        Expression<Func<TClass, TValue>> propertyExpression,
+        out ConfigMeta<TClass, TValue> configMeta,
+        ISpanParsable<TValue>? _ = null)
+        where TValue : struct, ISpanParsable<TValue>
+    {
+        var configPath = Path(configSelection, propertyExpression);
+        if (METADATA.TryGetValue(configPath, out var value) && value is ConfigMeta<TClass, TValue> meta)
+        {
+            configMeta = meta;
+            return true;
+        }
+
+        configMeta = new NoConfig<TClass, TValue>(configSelection, propertyExpression)
+        {
+            Default = default!,
+        };
+        return false;
+    }
+
+    // ReSharper restore MethodOverloadWithOptionalParameter
+
+    /// <summary>
+    /// Attempts to retrieve the configuration metadata for a list-based setting.
+    /// </summary>
+    /// <remarks>
+    /// When no configuration metadata is found, it returns a NoConfig instance with the default
+    /// value set to an empty list. This allows the caller to handle the absence of configuration
+    /// gracefully. In such cases, the return value of the method will be false.
+    /// </remarks>
+    /// <param name="configSelection">The expression to select the configuration class.</param>
+    /// <param name="propertyExpression">The expression to select the property within the
+    /// configuration class.</param>
+    /// <param name="configMeta">The output parameter that will hold the configuration metadata
+    /// if found.</param>
+    /// <typeparam name="TClass">The type of the configuration class.</typeparam>
+    /// <typeparam name="TValue">The type of the property within the configuration class.</typeparam>
+    /// <returns>True if the configuration metadata was found, otherwise false.</returns>
+    public static bool TryGet<TClass, TValue>(
+        Expression<Func<Data, TClass>> configSelection,
+        Expression<Func<TClass, IList<TValue>>> propertyExpression,
+        out ConfigMeta<TClass, IList<TValue>> configMeta)
+    {
+        var configPath = Path(configSelection, propertyExpression);
+        if (METADATA.TryGetValue(configPath, out var value) && value is ConfigMeta<TClass, IList<TValue>> meta)
+        {
+            configMeta = meta;
+            return true;
+        }
+
+        configMeta = new NoConfig<TClass, IList<TValue>>(configSelection, propertyExpression)
+        {
+            Default = [],
+        };
+        return false;
+    }
+
+    /// <summary>
+    /// Attempts to retrieve the configuration metadata for a set-based setting.
+    /// </summary>
+    /// <remarks>
+    /// When no configuration metadata is found, it returns a NoConfig instance with the default
+    /// value set to an empty set. This allows the caller to handle the absence of configuration
+    /// gracefully. In such cases, the return value of the method will be false.
+    /// </remarks>
+    /// <param name="configSelection">The expression to select the configuration class.</param>
+    /// <param name="propertyExpression">The expression to select the property within the
+    /// configuration class.</param>
+    /// <param name="configMeta">The output parameter that will hold the configuration metadata
+    /// if found.</param>
+    /// <typeparam name="TClass">The type of the configuration class.</typeparam>
+    /// <typeparam name="TValue">The type of the property within the configuration class.</typeparam>
+    /// <returns>True if the configuration metadata was found, otherwise false.</returns>
+    public static bool TryGet<TClass, TValue>(
+        Expression<Func<Data, TClass>> configSelection,
+        Expression<Func<TClass, ISet<TValue>>> propertyExpression,
+        out ConfigMeta<TClass, ISet<TValue>> configMeta)
+    {
+        var configPath = Path(configSelection, propertyExpression);
+        if (METADATA.TryGetValue(configPath, out var value) && value is ConfigMeta<TClass, ISet<TValue>> meta)
+        {
+            configMeta = meta;
+            return true;
+        }
+
+        configMeta = new NoConfig<TClass, ISet<TValue>>(configSelection, propertyExpression)
+        {
+            Default = new HashSet<TValue>(),
+        };
+        return false;
+    }
+    
+    /// <summary>
+    /// Attempts to retrieve the configuration metadata for a string dictionary-based setting.
+    /// </summary>
+    /// <remarks>
+    /// When no configuration metadata is found, it returns a NoConfig instance with the default
+    /// value set to an empty dictionary. This allows the caller to handle the absence of configuration
+    /// gracefully. In such cases, the return value of the method will be false.
+    /// </remarks>
+    /// <param name="configSelection">The expression to select the configuration class.</param>
+    /// <param name="propertyExpression">The expression to select the property within the
+    /// configuration class.</param>
+    /// <param name="configMeta">The output parameter that will hold the configuration metadata
+    /// if found.</param>
+    /// <typeparam name="TClass">The type of the configuration class.</typeparam>
+    /// <returns>True if the configuration metadata was found, otherwise false.</returns>
+    public static bool TryGet<TClass>(
+        Expression<Func<Data, TClass>> configSelection,
+        Expression<Func<TClass, IDictionary<string, string>>> propertyExpression,
+        out ConfigMeta<TClass, IDictionary<string, string>> configMeta)
+    {
+        var configPath = Path(configSelection, propertyExpression);
+        if (METADATA.TryGetValue(configPath, out var value) && value is ConfigMeta<TClass, IDictionary<string, string>> meta)
+        {
+            configMeta = meta;
+            return true;
+        }
+
+        configMeta = new NoConfig<TClass, IDictionary<string, string>>(configSelection, propertyExpression)
+        {
+            Default = new Dictionary<string, string>(),
+        };
+        return false;
     }
 
     /// <summary>
@@ -162,19 +242,131 @@ public static class ManagedConfiguration
     /// <typeparam name="TClass">The type of the configuration class.</typeparam>
     /// <typeparam name="TValue">The type of the property within the configuration class.</typeparam>
     /// <returns>True if the configuration setting is left over and was reset, otherwise false.</returns>
-    public static bool IsConfigurationLeftOver<TClass, TValue>(Expression<Func<Data, TClass>> configSelection, Expression<Func<TClass, TValue>> propertyExpression, IEnumerable<IAvailablePlugin> availablePlugins)
+    public static bool IsConfigurationLeftOver<TClass, TValue>(
+        Expression<Func<Data, TClass>> configSelection,
+        Expression<Func<TClass, TValue>> propertyExpression,
+        IEnumerable<IAvailablePlugin> availablePlugins)
+        where TValue : Enum
     {
         if (!TryGet(configSelection, propertyExpression, out var configMeta))
             return false;
 
-        if(configMeta.MangedByConfigPluginId == Guid.Empty || !configMeta.IsLocked)
+        if (configMeta.MangedByConfigPluginId == Guid.Empty || !configMeta.IsLocked)
+            return false;
+
+        var plugin = availablePlugins.FirstOrDefault(x => x.Id == configMeta.MangedByConfigPluginId);
+        if (plugin is null)
+        {
+            configMeta.ResetManagedState();
+            return true;
+        }
+
+        return false;
+    }
+
+    public static bool IsConfigurationLeftOver<TClass>(
+        Expression<Func<Data, TClass>> configSelection,
+        Expression<Func<TClass, string>> propertyExpression,
+        IEnumerable<IAvailablePlugin> availablePlugins)
+    {
+        if (!TryGet(configSelection, propertyExpression, out var configMeta))
+            return false;
+
+        if (configMeta.MangedByConfigPluginId == Guid.Empty || !configMeta.IsLocked)
+            return false;
+
+        var plugin = availablePlugins.FirstOrDefault(x => x.Id == configMeta.MangedByConfigPluginId);
+        if (plugin is null)
+        {
+            configMeta.ResetManagedState();
+            return true;
+        }
+
+        return false;
+    }
+
+    // ReSharper disable MethodOverloadWithOptionalParameter
+    public static bool IsConfigurationLeftOver<TClass, TValue>(
+        Expression<Func<Data, TClass>> configSelection,
+        Expression<Func<TClass, TValue>> propertyExpression,
+        IEnumerable<IAvailablePlugin> availablePlugins,
+        ISpanParsable<TValue>? _ = null)
+        where TValue : struct, ISpanParsable<TValue>
+    {
+        if (!TryGet(configSelection, propertyExpression, out var configMeta))
+            return false;
+
+        if (configMeta.MangedByConfigPluginId == Guid.Empty || !configMeta.IsLocked)
+            return false;
+
+        var plugin = availablePlugins.FirstOrDefault(x => x.Id == configMeta.MangedByConfigPluginId);
+        if (plugin is null)
+        {
+            configMeta.ResetManagedState();
+            return true;
+        }
+
+        return false;
+    }
+
+    // ReSharper restore MethodOverloadWithOptionalParameter
+
+    public static bool IsConfigurationLeftOver<TClass, TValue>(
+        Expression<Func<Data, TClass>> configSelection,
+        Expression<Func<TClass, IList<TValue>>> propertyExpression,
+        IEnumerable<IAvailablePlugin> availablePlugins)
+    {
+        if (!TryGet(configSelection, propertyExpression, out var configMeta))
+            return false;
+
+        if (configMeta.MangedByConfigPluginId == Guid.Empty || !configMeta.IsLocked)
+            return false;
+
+        var plugin = availablePlugins.FirstOrDefault(x => x.Id == configMeta.MangedByConfigPluginId);
+        if (plugin is null)
+        {
+            configMeta.ResetManagedState();
+            return true;
+        }
+
+        return false;
+    }
+
+    public static bool IsConfigurationLeftOver<TClass, TValue>(
+        Expression<Func<Data, TClass>> configSelection,
+        Expression<Func<TClass, ISet<TValue>>> propertyExpression,
+        IEnumerable<IAvailablePlugin> availablePlugins)
+    {
+        if (!TryGet(configSelection, propertyExpression, out var configMeta))
+            return false;
+
+        if (configMeta.MangedByConfigPluginId == Guid.Empty || !configMeta.IsLocked)
+            return false;
+
+        var plugin = availablePlugins.FirstOrDefault(x => x.Id == configMeta.MangedByConfigPluginId);
+        if (plugin is null)
+        {
+            configMeta.ResetManagedState();
+            return true;
+        }
+
+        return false;
+    }
+
+    public static bool IsConfigurationLeftOver<TClass>(
+        Expression<Func<Data, TClass>> configSelection,
+        Expression<Func<TClass, IDictionary<string, string>>> propertyExpression,
+        IEnumerable<IAvailablePlugin> availablePlugins)
+    {
+        if (!TryGet(configSelection, propertyExpression, out var configMeta))
+            return false;
+
+        if (configMeta.MangedByConfigPluginId == Guid.Empty || !configMeta.IsLocked)
             return false;
 
-        // Check if the configuration plugin ID is valid against the available plugin IDs:
         var plugin = availablePlugins.FirstOrDefault(x => x.Id == configMeta.MangedByConfigPluginId);
         if (plugin is null)
         {
-            // Remove the locked state:
             configMeta.ResetManagedState();
             return true;
         }

app/MindWork AI Studio/Tools/PluginSystem/PluginConfiguration.cs

@@ -61,6 +61,12 @@ public sealed class PluginConfiguration(bool isInternal, LuaState state, PluginT
         // Config: allow the user to add providers?
         ManagedConfiguration.TryProcessConfiguration(x => x.App, x => x.AllowUserToAddProvider, this.Id, settingsTable, dryRun);
         
+        // Config: preview features visibility
+        ManagedConfiguration.TryProcessConfiguration(x => x.App, x => x.PreviewVisibility, this.Id, settingsTable, dryRun);
+        
+        // Config: enabled preview features
+        ManagedConfiguration.TryProcessConfiguration(x => x.App, x => x.EnabledPreviewFeatures, this.Id, settingsTable, dryRun);
+        
         // Handle configured LLM providers:
         PluginConfigurationObject.TryParse(PluginConfigurationObjectType.LLM_PROVIDER, x => x.Providers, x => x.NextProviderNum, mainTable, this.Id, ref this.configObjects, dryRun);
         

app/MindWork AI Studio/Tools/PluginSystem/PluginFactory.Loading.cs

@@ -1,7 +1,6 @@
 using System.Text;
 
 using AIStudio.Settings;
-using AIStudio.Settings.DataModel;
 
 using Lua;
 using Lua.Standard;
@@ -138,16 +137,24 @@ public static partial class PluginFactory
         if(PluginConfigurationObject.CleanLeftOverConfigurationObjects(PluginConfigurationObjectType.CHAT_TEMPLATE, x => x.ChatTemplates, AVAILABLE_PLUGINS, configObjectList))
             wasConfigurationChanged = true;
         
-        // Check for update behavior:
-        if(ManagedConfiguration.IsConfigurationLeftOver<DataApp, UpdateInterval>(x => x.App, x => x.UpdateInterval, AVAILABLE_PLUGINS))
+        // Check for the update interval:
+        if(ManagedConfiguration.IsConfigurationLeftOver(x => x.App, x => x.UpdateInterval, AVAILABLE_PLUGINS))
             wasConfigurationChanged = true;
         
-        // Check for update installation behavior:
-        if(ManagedConfiguration.IsConfigurationLeftOver<DataApp, UpdateInstallation>(x => x.App, x => x.UpdateInstallation, AVAILABLE_PLUGINS))
+        // Check for the update installation method:
+        if(ManagedConfiguration.IsConfigurationLeftOver(x => x.App, x => x.UpdateInstallation, AVAILABLE_PLUGINS))
             wasConfigurationChanged = true;
         
         // Check for users allowed to added providers:
-        if(ManagedConfiguration.IsConfigurationLeftOver<DataApp, bool>(x => x.App, x => x.AllowUserToAddProvider, AVAILABLE_PLUGINS))
+        if(ManagedConfiguration.IsConfigurationLeftOver(x => x.App, x => x.AllowUserToAddProvider, AVAILABLE_PLUGINS))
+            wasConfigurationChanged = true;
+        
+        // Check for preview visibility:
+        if(ManagedConfiguration.IsConfigurationLeftOver(x => x.App, x => x.PreviewVisibility, AVAILABLE_PLUGINS))
+            wasConfigurationChanged = true;
+        
+        // Check for enabled preview features:
+        if(ManagedConfiguration.IsConfigurationLeftOver(x => x.App, x => x.EnabledPreviewFeatures, AVAILABLE_PLUGINS))
             wasConfigurationChanged = true;
         
         if (wasConfigurationChanged)

app/MindWork AI Studio/wwwroot/changelog/v0.9.52.md

@@ -1,4 +1,5 @@
 # v0.9.52, build 227 (2025-09-xx xx:xx UTC)
 - Added a feature so that matching results from data sources (local data sources as well as external ones via the ERI interface) are now also displayed at the end of a chat. All sources that come directly from the AI (like web searches) appear first, followed by those that come from the data sources. This source display works regardless of whether the AI actually used these sources, so users always get all the relevant information.
+- Added the ability to manage the preview feature visibility and enabled preview features by using enterprise IT configurations.
 - Improved developer experience by detecting development environments and disabling update prompts in those environments.
 - Fixed an issue where external data sources using the ERI interface weren't using the correct source names during the augmentation phase.