refactor: rename Configuration entities and merge UpdateOptions into Option

Class renames:
- BaseConfigInfo → UpdateConfiguration (abstract base)
- Configinfo → UpdateRequest (user-facing entry)
- GlobalConfigInfo → UpdateContext (runtime pipeline state)
- ProcessInfo → ProcessContract (IPC serialization contract)
- VersionInfo → VersionEntry (server response DTO)
- Packet → PushPayload (push notification payload)
- VersionOss → OssVersionRecord (OSS persistence)
- GlobalConfigInfoOss → OssConfiguration (OSS config)
- BlackListConfig → BlackPolicy (exclusion policy)
- ConfiginfoBuilder → UpdateRequestBuilder
- ConfigurationMapper (restored name)
- Hooks.UpdateContext → HookContext

Structural consolidation:
- Promote UpdateUrl/UpgradeClientVersion/ProductId to UpdateConfiguration base class
- Extract VersionIdentity base class for PushPayload/VersionEntry/OssVersionRecord
- Add ToBlackPolicy() bridge from UpdateConfiguration to BlackPolicy
- Merge UpdateOptions static catalog into Option class, delete UpdateOptions.cs
- Rename Option<T> method to SetOption<T> to avoid class name collision

Blacklist naming cleanup:
- UpdateConfiguration: BlackFiles→Files, BlackFormats→Formats, SkipDirectorys→Directories
- ProcessContract: same, removed legacy JsonPropertyName attributes
- BlackPolicy record fields: Files, Formats, Directories
- DefaultBlackListMatcher → BlackMatcher
- IBlackListMatcher → IBlackMatcher
- BlackListDefaults → BlackDefaults

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: JusterZhu

src/c#/GeneralUpdate.Bowl/Bowl.cs

@@ -296,7 +296,7 @@ internal static MonitorParameter CreateParameter()
                 "ProcessInfo environment variable not set.");
         }
 
-        var processInfo = JsonSerializer.Deserialize<ProcessInfo>(json);
+        var processInfo = JsonSerializer.Deserialize<ProcessContract>(json);
         if (processInfo == null)
         {
             GeneralTracer.Fatal("Bowl.CreateParameter: failed to deserialize ProcessInfo JSON.");

…Update.Bowl/Configuration/ProcessInfo.cs …te.Bowl/Configuration/ProcessContract.cssrc/c#/GeneralUpdate.Bowl/Configuration/ProcessInfo.cs renamed to src/c#/GeneralUpdate.Bowl/Configuration/ProcessContract.cs src/c#/GeneralUpdate.Bowl/Configuration/ProcessInfo.cs renamed to src/c#/GeneralUpdate.Bowl/Configuration/ProcessContract.cs

@@ -3,9 +3,9 @@
 namespace GeneralUpdate.Bowl.Configuration;
 
 /// <summary>
-/// Minimal ProcessInfo for Bowl — only the fields needed for crash monitoring and rollback.
+/// Minimal ProcessContract for Bowl — only the fields needed for crash monitoring and rollback.
 /// </summary>
-public class ProcessInfo
+public class ProcessContract
 {
     [JsonPropertyName("AppName")]
     public string AppName { get; set; } = string.Empty;

src/c#/GeneralUpdate.Core/Bootstrap/GeneralUpdateBootstrap.cs

@@ -25,7 +25,7 @@ namespace GeneralUpdate.Core;
 /// <remarks>
 /// <para><b>Core flow:</b></para>
 /// <para>
-/// 1. <b>Configuration</b> — <see cref="SetConfig(Configinfo)"/> loads parameters (versions, paths, URLs).<br/>
+/// 1. <b>Configuration</b> — <see cref="SetConfig(UpdateRequest)"/> loads parameters (versions, paths, URLs).<br/>
 /// 2. <b>Extension resolution</b> — <see cref="LaunchWithStrategy"/> resolves all registered
 ///    extension points (strategy, hooks, download components, network policies) and injects
 ///    them into the role strategy.<br/>
@@ -44,7 +44,7 @@ namespace GeneralUpdate.Core;
 ///    → PatchMiddleware</c> for each update version.<br/>
 /// 6. <b>App launch</b> — the OS strategy starts the updated main application.
 /// </para>
-/// <para><b>Silent mode:</b> when <c>Option(UpdateOptions.Silent, true)</c> is set on
+/// <para><b>Silent mode:</b> when <c>Option(Option.Silent, true)</c> is set on
 /// <see cref="AppType.Client"/>, launches a background poll loop via
 /// <see cref="Silent.SilentPollOrchestrator"/> and returns immediately. Updates are
 /// prepared on process exit.</para>
@@ -55,20 +55,20 @@ namespace GeneralUpdate.Core;
 /// <example>
 /// <code>
 /// var result = await new GeneralUpdateBootstrap()
-///     .SetConfig(new Configinfo {
+///     .SetConfig(new UpdateRequest {
 ///         UpdateUrl = "https://api.example.com",
 ///         ClientVersion = "1.0.0",
 ///         InstallPath = @"C:\MyApp",
 ///         AppSecretKey = "my-key"
 ///     })
-///     .Option(UpdateOptions.AppType, AppType.Client)
+///     .SetOption(Option.AppType, AppType.Client)
 ///     .Hooks&lt;MyCustomHooks&gt;()
 ///     .LaunchAsync();
 /// </code>
 /// </example>
 public class GeneralUpdateBootstrap : AbstractBootstrap<GeneralUpdateBootstrap, IStrategy>
 {
-    private GlobalConfigInfo _configInfo = new();
+    private UpdateContext _configInfo = new();
     private Func<UpdateInfoEventArgs, bool>? _updatePrecheck;
     private CancellationTokenSource? _cts;
     private DiffPipelineBuilder? _diffPipelineBuilder;
@@ -100,11 +100,11 @@ public void Cancel()
     /// <returns>This bootstrap instance for chaining.</returns>
     public override async Task<GeneralUpdateBootstrap> LaunchAsync()
     {
-        var appType = GetOption(UpdateOptions.AppType);
+        var appType = GetOption(Option.AppType);
         _configInfo.AppType = appType;
 
         // Silent mode: start background poll and return immediately
-        if (appType == AppType.Client && GetOption(UpdateOptions.Silent))
+        if (appType == AppType.Client && GetOption(Option.Silent))
         {
             await LaunchSilentAsync().ConfigureAwait(false);
             return this;
@@ -160,23 +160,23 @@ private async Task<GeneralUpdateBootstrap> LaunchWithStrategy(IStrategy roleStra
 
     /// <summary>
     /// Applies the primary configuration object. Validates required fields, maps to
-    /// the internal <see cref="GlobalConfigInfo"/>, and initialises the blacklist
+    /// the internal <see cref="UpdateContext"/>, and initialises the blacklist
     /// matcher for file exclusion during update operations.
     /// </summary>
     /// <param name="configInfo">User-facing configuration. All required fields must
     /// be set explicitly — no auto-discovery is performed. Use
     /// <see cref="SetSource"/> for the zero-config path.</param>
     /// <returns>This bootstrap instance for chaining.</returns>
-    public GeneralUpdateBootstrap SetConfig(Configinfo configInfo)
+    public GeneralUpdateBootstrap SetConfig(UpdateRequest configInfo)
     {
         configInfo.Validate();
-        _configInfo = ConfigurationMapper.MapToGlobalConfigInfo(configInfo);
+        _configInfo = ConfigurationMapper.MapToUpdateContext(configInfo);
 
-        var appType = GetOption(UpdateOptions.AppType);
+        var appType = GetOption(Option.AppType);
         if (appType != AppType.Upgrade)
         {
             _configInfo.TempPath = StorageManager.GetTempDirectory("upgrade_temp");
-            InitBlackList();
+            InitBlackPolicy();
         }
 
         return this;
@@ -193,11 +193,11 @@ public GeneralUpdateBootstrap SetConfig(Configinfo configInfo)
     /// <returns>This bootstrap instance for chaining.</returns>
     /// <exception cref="ArgumentNullException">Thrown when <paramref name="filePath"/> is <c>null</c> or whitespace.</exception>
     /// <exception cref="FileNotFoundException">Thrown when the specified file does not exist.</exception>
-    /// <exception cref="InvalidOperationException">Thrown when the JSON file cannot be deserialised into a valid <see cref="Configinfo"/>.</exception>
+    /// <exception cref="InvalidOperationException">Thrown when the JSON file cannot be deserialised into a valid <see cref="UpdateRequest"/>.</exception>
     /// <remarks>
-    /// Reads the file content as UTF-8 JSON, deserialises it into a <see cref="Configinfo"/>
+    /// Reads the file content as UTF-8 JSON, deserialises it into a <see cref="UpdateRequest"/>
     /// using the source-generated JSON serialisation context (<see cref="JsonContext.HttpParameterJsonContext"/>),
-    /// then delegates to <see cref="SetConfig(Configinfo)"/> for validation and mapping.
+    /// then delegates to <see cref="SetConfig(UpdateRequest)"/> for validation and mapping.
     /// </remarks>
     public GeneralUpdateBootstrap SetConfig(string filePath)
     {
@@ -215,7 +215,7 @@ public GeneralUpdateBootstrap SetConfig(string filePath)
             throw new FileNotFoundException($"Config file not found: {fullPath}");
 
         var json = File.ReadAllText(fullPath);
-        var config = JsonSerializer.Deserialize(json, JsonContext.HttpParameterJsonContext.Default.Configinfo);
+        var config = JsonSerializer.Deserialize(json, JsonContext.HttpParameterJsonContext.Default.UpdateRequest);
         if (config == null)
             throw new InvalidOperationException($"Failed to parse config file: {fullPath}");
 
@@ -234,7 +234,7 @@ public GeneralUpdateBootstrap SetSource(
         string? scheme = null,
         string? token = null)
     {
-        var config = new Configinfo
+        var config = new UpdateRequest
         {
             UpdateUrl = updateUrl,
             AppSecretKey = appSecretKey,
@@ -287,14 +287,14 @@ public GeneralUpdateBootstrap AddListenerUpdatePrecheck(Func<UpdateInfoEventArgs
 
     private void InitializeFromEnvironment()
     {
-        // Read ProcessInfo via AES-encrypted file IPC.
+        // Read ProcessContract via AES-encrypted file IPC.
         // The Upgrade process is only ever launched by the Client — no IPC means
         // there is nothing to do. The Client's manifest.json flows through IPC,
         // so the Upgrade never needs to load one directly.
-        var processInfo = new EncryptedFileProcessInfoProvider().Receive();
+        var processInfo = new EncryptedFileProcessContractProvider().Receive();
         if (processInfo == null) return;
 
-        _configInfo = new GlobalConfigInfo
+        _configInfo = new UpdateContext
         {
             MainAppName = processInfo.AppName,
             InstallPath = processInfo.InstallPath,
@@ -315,41 +315,41 @@ private void InitializeFromEnvironment()
             UpdatePath = processInfo.UpdatePath,
             LaunchClientAfterUpdate = processInfo.LaunchClientAfterUpdate,
             ReportType = processInfo.ReportType,
-            BlackFiles = processInfo.BlackFiles ?? BlackListDefaults.DefaultBlackFiles,
-            BlackFormats = processInfo.BlackFileFormats ?? BlackListDefaults.DefaultBlackFormats,
-            SkipDirectorys = processInfo.SkipDirectorys ?? BlackListDefaults.DefaultSkipDirectories
+            Files = processInfo.Files ?? BlackDefaults.DefaultFiles,
+            Formats = processInfo.Formats ?? BlackDefaults.DefaultFormats,
+            Directories = processInfo.Directories ?? BlackDefaults.DefaultDirectories
         };
 
-        StorageManager.BlackListMatcher = DefaultBlackListMatcher.FromConfigInfo(_configInfo);
+        StorageManager.BlackMatcher = BlackMatcher.FromConfigInfo(_configInfo);
     }
 
     /// <summary>
-    /// Applies UpdateOptions to _configInfo.
+    /// Applies Option to _configInfo.
     /// Uses ??= only for values that InitializeFromEnvironment() may have already
     /// populated on the Upgrade path (Encoding, Format, DownloadTimeOut).
-    /// All other options are always applied from UpdateOptions — their defaults
+    /// All other options are always applied from Option — their defaults
     /// are already functionally reasonable (e.g. MaxConcurrency=3, RetryCount=3).
     /// </summary>
     private void ApplyRuntimeOptions()
     {
         // Preserve Upgrade path values set by InitializeFromEnvironment()
-        _configInfo.Encoding ??= GetOption(UpdateOptions.Encoding);
-        _configInfo.Format = GetOption(UpdateOptions.Format);
+        _configInfo.Encoding ??= GetOption(Option.Encoding);
+        _configInfo.Format = GetOption(Option.Format);
         if (_configInfo.DownloadTimeOut <= 0)
-            _configInfo.DownloadTimeOut = GetOption(UpdateOptions.DownloadTimeout) ?? 60;
+            _configInfo.DownloadTimeOut = GetOption(Option.DownloadTimeout) ?? 60;
 
         // bool? options: use ??= so user-configured false is preserved
-        _configInfo.PatchEnabled ??= GetOption(UpdateOptions.PatchEnabled);
-        _configInfo.BackupEnabled ??= GetOption(UpdateOptions.BackupEnabled);
+        _configInfo.PatchEnabled ??= GetOption(Option.PatchEnabled);
+        _configInfo.BackupEnabled ??= GetOption(Option.BackupEnabled);
 
-        // Always apply from UpdateOptions — no other code sets these before
+        // Always apply from Option — no other code sets these before
         // ApplyRuntimeOptions() runs. Defaults are functionally reasonable.
-        _configInfo.MaxConcurrency = GetOption(UpdateOptions.MaxConcurrency);
-        _configInfo.EnableResume = GetOption(UpdateOptions.EnableResume);
-        _configInfo.RetryCount = GetOption(UpdateOptions.RetryCount);
-        _configInfo.RetryInterval = GetOption(UpdateOptions.RetryInterval);
-        _configInfo.VerifyChecksum = GetOption(UpdateOptions.VerifyChecksum);
-        _configInfo.DiffMode = GetOption(UpdateOptions.DiffMode);
+        _configInfo.MaxConcurrency = GetOption(Option.MaxConcurrency);
+        _configInfo.EnableResume = GetOption(Option.EnableResume);
+        _configInfo.RetryCount = GetOption(Option.RetryCount);
+        _configInfo.RetryInterval = GetOption(Option.RetryInterval);
+        _configInfo.VerifyChecksum = GetOption(Option.VerifyChecksum);
+        _configInfo.DiffMode = GetOption(Option.DiffMode);
     }
 
     /// <summary>
@@ -374,8 +374,8 @@ private async Task<GeneralUpdateBootstrap> LaunchSilentAsync()
 
         strategy.LaunchAfterPrepare = false;
 
-        var pollMinutes = GetOption(UpdateOptions.SilentPollIntervalMinutes);
-        var launchClient = GetOption(UpdateOptions.LaunchClientAfterUpdate);
+        var pollMinutes = GetOption(Option.SilentPollIntervalMinutes);
+        var launchClient = GetOption(Option.LaunchClientAfterUpdate);
         var silentOptions = new Silent.SilentOptions
         {
             PollInterval = TimeSpan.FromMinutes(pollMinutes),
@@ -477,18 +477,18 @@ private static Format ParseFormat(string? compressFormat)
         };
     }
 
-    private void InitBlackList()
+    private void InitBlackPolicy()
     {
-        // Build blacklist matcher from GlobalConfigInfo and set on StorageManager.
+        // Build blacklist matcher from UpdateContext and set on StorageManager.
         // The matcher combines user config with system defaults.
-        var effectiveConfig = new BlackListConfig(
-            _configInfo.BlackFiles?.Count > 0 ? _configInfo.BlackFiles : BlackListDefaults.DefaultBlackFiles,
-            _configInfo.BlackFormats?.Count > 0 ? _configInfo.BlackFormats : BlackListDefaults.DefaultBlackFormats,
-            _configInfo.SkipDirectorys?.Count > 0
-                ? _configInfo.SkipDirectorys
-                : BlackListDefaults.DefaultSkipDirectories
+        var effectiveConfig = new BlackPolicy(
+            _configInfo.Files?.Count > 0 ? _configInfo.Files : BlackDefaults.DefaultFiles,
+            _configInfo.Formats?.Count > 0 ? _configInfo.Formats : BlackDefaults.DefaultFormats,
+            _configInfo.Directories?.Count > 0
+                ? _configInfo.Directories
+                : BlackDefaults.DefaultDirectories
         );
-        StorageManager.BlackListMatcher = new DefaultBlackListMatcher(effectiveConfig);
+        StorageManager.BlackMatcher = new BlackMatcher(effectiveConfig);
     }
 
     private async Task CallSmallBowlHomeAsync(string processName)

src/c#/GeneralUpdate.Core/Configuration/AbstractBootstrap.cs

@@ -21,10 +21,10 @@ namespace GeneralUpdate.Core.Configuration
     ///   <c>.DownloadSource&lt;T&gt;()</c> and are lazily instantiated on demand through
     ///   <see cref="ResolveExtension{TExtension}"/>.<br/>
     /// - The <c>_instances</c> dictionary stores already-instantiated singleton objects
-    ///   (e.g., <c>BlackListConfig</c>). These take precedence over lazy registrations
+    ///   (e.g., <c>BlackPolicy</c>). These take precedence over lazy registrations
     ///   in <c>_extensions</c>.<br/>
-    /// - The <see cref="Option{T}(UpdateOption{T}, T)"/> method provides fluent configuration
-    ///   options, read via <see cref="GetOption{T}(UpdateOption{T}?)"/>, with a default-value
+    /// - The <see cref="Option{T}(Option{T}, T)"/> method provides fluent configuration
+    ///   options, read via <see cref="GetOption{T}(Option{T}?)"/>, with a default-value
     ///   fallback mechanism.
     /// </para>
     /// <para>Typical usage: chain extension registrations together, then call
@@ -34,17 +34,17 @@ public abstract class AbstractBootstrap<TBootstrap, TStrategy>
         where TBootstrap : AbstractBootstrap<TBootstrap, TStrategy>
         where TStrategy : IStrategy
     {
-        private readonly ConcurrentDictionary<UpdateOption, UpdateOptionValue> _options;
+        private readonly ConcurrentDictionary<Option, OptionValue> _options;
 
         /// <summary>User-registered extension type mappings (interface type → implementation type), used for lazy instantiation.</summary>
         private readonly Dictionary<Type, Type> _extensions = new();
 
-        /// <summary>Registered singleton instances (e.g., <c>BlackListConfig</c>).</summary>
+        /// <summary>Registered singleton instances (e.g., <c>BlackPolicy</c>).</summary>
         private readonly Dictionary<Type, object> _instances = new();
 
         protected internal AbstractBootstrap()
         {
-            _options = new ConcurrentDictionary<UpdateOption, UpdateOptionValue>();
+            _options = new ConcurrentDictionary<Option, OptionValue>();
         }
 
         public abstract Task<TBootstrap> LaunchAsync();
@@ -58,17 +58,17 @@ protected internal AbstractBootstrap()
         /// from the dictionary so that subsequent reads fall back to the default value.</param>
         /// <returns>The current <typeparamref name="TBootstrap"/> instance for chaining.</returns>
         /// <remarks>
-        /// Options are stored in a <c>ConcurrentDictionary</c> to guarantee thread safety.
+        /// Option are stored in a <c>ConcurrentDictionary</c> to guarantee thread safety.
         /// When <paramref name="value"/> is <c>null</c>, the entry is removed, causing
-        /// <see cref="GetOption{T}(UpdateOption{T}?)"/> to return
-        /// <see cref="UpdateOption{T}.DefaultValue"/>.
+        /// <see cref="GetOption{T}(Option{T}?)"/> to return
+        /// <see cref="Option{T}.DefaultValue"/>.
         /// </remarks>
-        public TBootstrap Option<T>(UpdateOption<T> option, T value)
+        public TBootstrap SetOption<T>(Option<T> option, T value)
         {
             if (value == null)
                 _options.TryRemove(option, out _);
             else
-                _options[option] = new UpdateOptionValue<T>(option, value);
+                _options[option] = new OptionValue<T>(option, value);
             return (TBootstrap)this;
         }
 
@@ -79,14 +79,14 @@ public TBootstrap Option<T>(UpdateOption<T> option, T value)
         /// <typeparam name="T">The type of the option value.</typeparam>
         /// <param name="option">The option key to retrieve; can be <c>null</c>.</param>
         /// <returns>
-        /// The registered value if found; otherwise, <see cref="UpdateOption{T}.DefaultValue"/>.
+        /// The registered value if found; otherwise, <see cref="Option{T}.DefaultValue"/>.
         /// </returns>
         /// <remarks>
         /// First attempts to look up the option in the <c>_options</c> dictionary.
-        /// If not found, falls back to <see cref="UpdateOption{T}.DefaultValue"/>.
-        /// This is the companion read method for <see cref="Option{T}(UpdateOption{T}, T)"/>.
+        /// If not found, falls back to <see cref="Option{T}.DefaultValue"/>.
+        /// This is the companion read method for <see cref="Option{T}(Option{T}, T)"/>.
         /// </remarks>
-        protected T GetOption<T>(UpdateOption<T>? option)
+        protected T GetOption<T>(Option<T>? option)
         {
             if (option == null) return default!;
             if (_options.TryGetValue(option, out var val) && val != null)

src/c#/GeneralUpdate.Core/Configuration/AppMetadataDiscoverer.cs

@@ -3,23 +3,23 @@
 namespace GeneralUpdate.Core.Configuration;
 
 /// <summary>
-///     Fills missing identity fields in a <see cref="Configinfo"/> by probing
+///     Fills missing identity fields in a <see cref="UpdateRequest"/> by probing
 ///     <c>generalupdate.manifest.json</c>, then falling back to hard-coded defaults.
 /// </summary>
 public static class AppMetadataDiscoverer
 {
     /// <summary>
     ///     Discover and fill every null-or-empty identity field in <paramref name="seed"/>.
     /// </summary>
-    public static Configinfo Discover(Configinfo seed)
+    public static UpdateRequest Discover(UpdateRequest seed)
     {
         if (seed == null)
             throw new System.ArgumentNullException(nameof(seed));
 
         var manifest = ManifestInfo.Load();
 
         // Identity fields — manifest overrides defaults, not just nulls.
-        // (BaseConfigInfo pre-fills UpdateAppName with "Update.exe", so simple
+        // (UpdateConfiguration pre-fills UpdateAppName with "Update.exe", so simple
         //  null-coalescing would never pick up the manifest value.)
         if (manifest != null)
         {

src/c#/GeneralUpdate.Core/Configuration/BlackListConfig.cs

@@ -0,0 +1,14 @@
+using System.Collections.Generic;
+
+namespace GeneralUpdate.Core.Configuration;
+
+public sealed record BlackPolicy(
+    IReadOnlyList<string>? Files = null,
+    IReadOnlyList<string>? Formats = null,
+    IReadOnlyList<string>? Directories = null
+)
+{
+    public static BlackPolicy Empty { get; } = new();
+    public bool HasRules =>
+        (Files?.Count > 0) || (Formats?.Count > 0) || (Directories?.Count > 0);
+}