0.5.3

试验性引入渲染模式切换

.gitignore

@@ -482,3 +482,12 @@ $RECYCLE.BIN/
 *.swp
 nul
 /publish-test
+/_build_verify
+/_build_verify_tray
+/_build_verify_plugin
+/_build_verify_plugin_tabs
+/_build_verify_sample_plugin
+/_build_verify_sample_plugin_capabilities
+/_build_verify_plugin_page_host
+/_build_verify_plugin_services
+/_build_obj

LanMountainDesktop.PluginSdk/IPlugin.cs

@@ -0,0 +1,6 @@
+namespace LanMountainDesktop.PluginSdk;
+
+public interface IPlugin
+{
+    void Initialize(IPluginContext context);
+}

LanMountainDesktop.PluginSdk/IPluginContext.cs

@@ -0,0 +1,27 @@
+using System.Collections.Generic;
+
+namespace LanMountainDesktop.PluginSdk;
+
+public interface IPluginContext
+{
+    PluginManifest Manifest { get; }
+
+    string PluginDirectory { get; }
+
+    string DataDirectory { get; }
+
+    IServiceProvider Services { get; }
+
+    IReadOnlyDictionary<string, object?> Properties { get; }
+
+    T? GetService<T>();
+
+    bool TryGetProperty<T>(string key, out T? value);
+
+    void RegisterService<TService>(TService service)
+        where TService : class;
+
+    void RegisterSettingsPage(PluginSettingsPageRegistration registration);
+
+    void RegisterDesktopComponent(PluginDesktopComponentRegistration registration);
+}

LanMountainDesktop.PluginSdk/IPluginMessageBus.cs

@@ -0,0 +1,8 @@
+namespace LanMountainDesktop.PluginSdk;
+
+public interface IPluginMessageBus
+{
+    IDisposable Subscribe<TMessage>(Action<TMessage> handler);
+
+    void Publish<TMessage>(TMessage message);
+}

LanMountainDesktop.PluginSdk/LanMountainDesktop.PluginSdk.csproj

@@ -0,0 +1,14 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <Version>1.0.0</Version>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Avalonia" Version="11.3.12" />
+  </ItemGroup>
+
+</Project>

LanMountainDesktop.PluginSdk/LoadedPlugin.cs

@@ -0,0 +1,83 @@
+using System.Reflection;
+using System.Threading;
+
+namespace LanMountainDesktop.PluginSdk;
+
+public sealed class LoadedPlugin : IDisposable, IAsyncDisposable
+{
+    private int _disposed;
+
+    internal LoadedPlugin(
+        PluginManifest manifest,
+        string sourcePath,
+        string assemblyPath,
+        Assembly assembly,
+        IPlugin plugin,
+        IPluginContext context,
+        IReadOnlyList<PluginSettingsPageRegistration> settingsPages,
+        IReadOnlyList<PluginDesktopComponentRegistration> desktopComponents,
+        PluginLoadContext loadContext)
+    {
+        Manifest = manifest;
+        SourcePath = sourcePath;
+        AssemblyPath = assemblyPath;
+        Assembly = assembly;
+        Plugin = plugin;
+        Context = context;
+        SettingsPages = settingsPages;
+        DesktopComponents = desktopComponents;
+        LoadContext = loadContext;
+    }
+
+    public PluginManifest Manifest { get; }
+
+    public string SourcePath { get; }
+
+    public string AssemblyPath { get; }
+
+    public Assembly Assembly { get; }
+
+    public IPlugin Plugin { get; }
+
+    public IPluginContext Context { get; }
+
+    public IReadOnlyList<PluginSettingsPageRegistration> SettingsPages { get; }
+
+    public IReadOnlyList<PluginDesktopComponentRegistration> DesktopComponents { get; }
+
+    public PluginLoadContext LoadContext { get; }
+
+    public void Dispose()
+    {
+        DisposeAsync().AsTask().GetAwaiter().GetResult();
+    }
+
+    public async ValueTask DisposeAsync()
+    {
+        if (Interlocked.Exchange(ref _disposed, 1) != 0)
+        {
+            return;
+        }
+
+        if (Plugin is IAsyncDisposable asyncDisposable)
+        {
+            await asyncDisposable.DisposeAsync();
+        }
+        else if (Plugin is IDisposable disposable)
+        {
+            disposable.Dispose();
+        }
+
+        if (Context is IAsyncDisposable asyncContext)
+        {
+            await asyncContext.DisposeAsync();
+        }
+        else if (Context is IDisposable disposableContext)
+        {
+            disposableContext.Dispose();
+        }
+
+        LoadContext.Unload();
+        GC.SuppressFinalize(this);
+    }
+}

LanMountainDesktop.PluginSdk/PluginBase.cs

@@ -0,0 +1,8 @@
+namespace LanMountainDesktop.PluginSdk;
+
+public abstract class PluginBase : IPlugin
+{
+    public virtual void Initialize(IPluginContext context)
+    {
+    }
+}

LanMountainDesktop.PluginSdk/PluginDesktopComponentContext.cs

@@ -0,0 +1,66 @@
+namespace LanMountainDesktop.PluginSdk;
+
+public sealed class PluginDesktopComponentContext
+{
+    public PluginDesktopComponentContext(
+        PluginManifest manifest,
+        string pluginDirectory,
+        string dataDirectory,
+        IServiceProvider services,
+        IReadOnlyDictionary<string, object?> properties,
+        string componentId,
+        string? placementId,
+        double cellSize)
+    {
+        ArgumentNullException.ThrowIfNull(manifest);
+        ArgumentException.ThrowIfNullOrWhiteSpace(pluginDirectory);
+        ArgumentException.ThrowIfNullOrWhiteSpace(dataDirectory);
+        ArgumentException.ThrowIfNullOrWhiteSpace(componentId);
+        ArgumentNullException.ThrowIfNull(services);
+        ArgumentNullException.ThrowIfNull(properties);
+
+        Manifest = manifest;
+        PluginDirectory = pluginDirectory;
+        DataDirectory = dataDirectory;
+        Services = services;
+        Properties = properties;
+        ComponentId = componentId.Trim();
+        PlacementId = string.IsNullOrWhiteSpace(placementId) ? null : placementId.Trim();
+        CellSize = Math.Max(1, cellSize);
+    }
+
+    public PluginManifest Manifest { get; }
+
+    public string PluginDirectory { get; }
+
+    public string DataDirectory { get; }
+
+    public IServiceProvider Services { get; }
+
+    public IReadOnlyDictionary<string, object?> Properties { get; }
+
+    public string ComponentId { get; }
+
+    public string? PlacementId { get; }
+
+    public double CellSize { get; }
+
+    public T? GetService<T>()
+    {
+        return (T?)Services.GetService(typeof(T));
+    }
+
+    public bool TryGetProperty<T>(string key, out T? value)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(key);
+
+        if (Properties.TryGetValue(key, out var rawValue) && rawValue is T typedValue)
+        {
+            value = typedValue;
+            return true;
+        }
+
+        value = default;
+        return false;
+    }
+}

LanMountainDesktop.PluginSdk/PluginDesktopComponentRegistration.cs

@@ -0,0 +1,66 @@
+using Avalonia.Controls;
+
+namespace LanMountainDesktop.PluginSdk;
+
+public sealed class PluginDesktopComponentRegistration
+{
+    public PluginDesktopComponentRegistration(
+        string componentId,
+        string displayName,
+        Func<PluginDesktopComponentContext, Control> controlFactory,
+        string iconKey = "PuzzlePiece",
+        string category = "Plugins",
+        int minWidthCells = 2,
+        int minHeightCells = 2,
+        bool allowDesktopPlacement = true,
+        bool allowStatusBarPlacement = false,
+        PluginDesktopComponentResizeMode resizeMode = PluginDesktopComponentResizeMode.Proportional,
+        string? displayNameLocalizationKey = null,
+        Func<double, double>? cornerRadiusResolver = null)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(componentId);
+        ArgumentException.ThrowIfNullOrWhiteSpace(displayName);
+        ArgumentException.ThrowIfNullOrWhiteSpace(iconKey);
+        ArgumentException.ThrowIfNullOrWhiteSpace(category);
+        ArgumentNullException.ThrowIfNull(controlFactory);
+
+        ComponentId = componentId.Trim();
+        DisplayName = displayName.Trim();
+        DisplayNameLocalizationKey = string.IsNullOrWhiteSpace(displayNameLocalizationKey)
+            ? null
+            : displayNameLocalizationKey.Trim();
+        ControlFactory = controlFactory;
+        IconKey = iconKey.Trim();
+        Category = category.Trim();
+        MinWidthCells = Math.Max(1, minWidthCells);
+        MinHeightCells = Math.Max(1, minHeightCells);
+        AllowDesktopPlacement = allowDesktopPlacement;
+        AllowStatusBarPlacement = allowStatusBarPlacement;
+        ResizeMode = resizeMode;
+        CornerRadiusResolver = cornerRadiusResolver;
+    }
+
+    public string ComponentId { get; }
+
+    public string DisplayName { get; }
+
+    public string? DisplayNameLocalizationKey { get; }
+
+    public Func<PluginDesktopComponentContext, Control> ControlFactory { get; }
+
+    public string IconKey { get; }
+
+    public string Category { get; }
+
+    public int MinWidthCells { get; }
+
+    public int MinHeightCells { get; }
+
+    public bool AllowDesktopPlacement { get; }
+
+    public bool AllowStatusBarPlacement { get; }
+
+    public PluginDesktopComponentResizeMode ResizeMode { get; }
+
+    public Func<double, double>? CornerRadiusResolver { get; }
+}

LanMountainDesktop.PluginSdk/PluginDesktopComponentResizeMode.cs

@@ -0,0 +1,7 @@
+namespace LanMountainDesktop.PluginSdk;
+
+public enum PluginDesktopComponentResizeMode
+{
+    Proportional = 0,
+    Free = 1
+}

LanMountainDesktop.PluginSdk/PluginEntranceAttribute.cs

@@ -0,0 +1,6 @@
+namespace LanMountainDesktop.PluginSdk;
+
+[AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = false)]
+public sealed class PluginEntranceAttribute : Attribute
+{
+}

LanMountainDesktop.PluginSdk/PluginLoadContext.cs

@@ -0,0 +1,66 @@
+using System.Reflection;
+using System.Runtime.Loader;
+
+namespace LanMountainDesktop.PluginSdk;
+
+public sealed class PluginLoadContext : AssemblyLoadContext
+{
+    private readonly AssemblyDependencyResolver _resolver;
+    private readonly HashSet<string> _sharedAssemblyNames;
+
+    public PluginLoadContext(string mainAssemblyPath, IEnumerable<string>? sharedAssemblyNames = null)
+        : base($"{Path.GetFileNameWithoutExtension(mainAssemblyPath)}_{Guid.NewGuid():N}", isCollectible: true)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(mainAssemblyPath);
+
+        MainAssemblyPath = Path.GetFullPath(mainAssemblyPath);
+        _resolver = new AssemblyDependencyResolver(MainAssemblyPath);
+        _sharedAssemblyNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
+        {
+            typeof(IPlugin).Assembly.GetName().Name!
+        };
+
+        if (sharedAssemblyNames is null)
+        {
+            return;
+        }
+
+        foreach (var assemblyName in sharedAssemblyNames)
+        {
+            if (!string.IsNullOrWhiteSpace(assemblyName))
+            {
+                _sharedAssemblyNames.Add(assemblyName.Trim());
+            }
+        }
+    }
+
+    public string MainAssemblyPath { get; }
+
+    protected override Assembly? Load(AssemblyName assemblyName)
+    {
+        var simpleName = assemblyName.Name;
+        if (string.IsNullOrWhiteSpace(simpleName))
+        {
+            return null;
+        }
+
+        if (_sharedAssemblyNames.Contains(simpleName))
+        {
+            return Default.Assemblies.FirstOrDefault(
+                    assembly => string.Equals(
+                        assembly.GetName().Name,
+                        simpleName,
+                        StringComparison.OrdinalIgnoreCase))
+                ?? null;
+        }
+
+        var assemblyPath = _resolver.ResolveAssemblyToPath(assemblyName);
+        return assemblyPath is null ? null : LoadFromAssemblyPath(assemblyPath);
+    }
+
+    protected override nint LoadUnmanagedDll(string unmanagedDllName)
+    {
+        var libraryPath = _resolver.ResolveUnmanagedDllToPath(unmanagedDllName);
+        return libraryPath is null ? nint.Zero : LoadUnmanagedDllFromPath(libraryPath);
+    }
+}

LanMountainDesktop.PluginSdk/PluginLoadResult.cs

@@ -0,0 +1,20 @@
+namespace LanMountainDesktop.PluginSdk;
+
+public sealed record PluginLoadResult(
+    string SourcePath,
+    PluginManifest? Manifest,
+    LoadedPlugin? LoadedPlugin,
+    Exception? Error)
+{
+    public bool IsSuccess => LoadedPlugin is not null && Error is null;
+
+    public static PluginLoadResult Success(string sourcePath, PluginManifest manifest, LoadedPlugin loadedPlugin)
+    {
+        return new PluginLoadResult(sourcePath, manifest, loadedPlugin, null);
+    }
+
+    public static PluginLoadResult Failure(string sourcePath, PluginManifest? manifest, Exception error)
+    {
+        return new PluginLoadResult(sourcePath, manifest, null, error);
+    }
+}

LanMountainDesktop.PluginSdk/PluginLoader.cs

@@ -0,0 +1,924 @@
+using System.Collections.ObjectModel;
+using System.IO.Compression;
+using System.Reflection;
+using System.Security.Cryptography;
+using System.Text;
+
+namespace LanMountainDesktop.PluginSdk;
+
+public sealed class PluginLoader
+{
+    private readonly PluginLoaderOptions _options;
+
+    public PluginLoader(PluginLoaderOptions? options = null)
+    {
+        _options = options ?? new PluginLoaderOptions();
+    }
+
+    public IReadOnlyList<PluginLoadResult> LoadAll(
+        string pluginsRootDirectory,
+        IServiceProvider? services = null,
+        IReadOnlyDictionary<string, object?>? properties = null)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(pluginsRootDirectory);
+
+        if (!Directory.Exists(pluginsRootDirectory))
+        {
+            return Array.Empty<PluginLoadResult>();
+        }
+
+        var results = new List<PluginLoadResult>();
+        var candidates = DiscoverCandidates(pluginsRootDirectory, results);
+        var selectedPluginIds = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+
+        foreach (var candidate in candidates)
+        {
+            if (!selectedPluginIds.Add(candidate.Manifest.Id))
+            {
+                results.Add(PluginLoadResult.Failure(
+                    candidate.SourcePath,
+                    candidate.Manifest,
+                    new InvalidOperationException(
+                        $"Duplicate plugin id '{candidate.Manifest.Id}' was found. Source '{candidate.SourcePath}' was ignored because a higher-priority source was already selected.")));
+                continue;
+            }
+
+            results.Add(candidate.SourceKind switch
+            {
+                PluginSourceKind.Package => LoadFromPackage(
+                    candidate.SourcePath,
+                    pluginsRootDirectory,
+                    candidate.Manifest,
+                    services,
+                    properties),
+                _ => LoadFromManifest(
+                    candidate.SourcePath,
+                    candidate.Manifest,
+                    services,
+                    properties)
+            });
+        }
+
+        return results;
+    }
+
+    public PluginLoadResult LoadFromManifest(
+        string manifestPath,
+        IServiceProvider? services = null,
+        IReadOnlyDictionary<string, object?>? properties = null)
+    {
+        PluginManifest? manifest = null;
+
+        try
+        {
+            manifest = PluginManifest.Load(manifestPath);
+            return LoadFromManifest(manifestPath, manifest, services, properties);
+        }
+        catch (Exception ex)
+        {
+            return PluginLoadResult.Failure(Path.GetFullPath(manifestPath), manifest, ex);
+        }
+    }
+
+    public PluginLoadResult LoadFromPackage(
+        string packagePath,
+        string pluginsRootDirectory,
+        IServiceProvider? services = null,
+        IReadOnlyDictionary<string, object?>? properties = null)
+    {
+        PluginManifest? manifest = null;
+
+        try
+        {
+            manifest = ReadManifestFromPackage(packagePath);
+            return LoadFromPackage(packagePath, pluginsRootDirectory, manifest, services, properties);
+        }
+        catch (Exception ex)
+        {
+            return PluginLoadResult.Failure(Path.GetFullPath(packagePath), manifest, ex);
+        }
+    }
+
+    public PluginLoadResult LoadFromAssembly(
+        string assemblyPath,
+        PluginManifest manifest,
+        IServiceProvider? services = null,
+        IReadOnlyDictionary<string, object?>? properties = null)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(assemblyPath);
+        ArgumentNullException.ThrowIfNull(manifest);
+
+        var fullAssemblyPath = Path.GetFullPath(assemblyPath);
+        var pluginDirectory = Path.GetDirectoryName(fullAssemblyPath)
+            ?? throw new InvalidOperationException($"Failed to determine the plugin directory of '{fullAssemblyPath}'.");
+        var dataDirectory = Path.Combine(pluginDirectory, _options.DataDirectoryName);
+        return LoadCore(fullAssemblyPath, fullAssemblyPath, pluginDirectory, dataDirectory, manifest, services, properties);
+    }
+
+    private PluginLoadResult LoadCore(
+        string sourcePath,
+        string assemblyPath,
+        string pluginDirectory,
+        string dataDirectory,
+        PluginManifest manifest,
+        IServiceProvider? services,
+        IReadOnlyDictionary<string, object?>? properties)
+    {
+        PluginLoadContext? loadContext = null;
+        IPlugin? plugin = null;
+        PluginContext? context = null;
+
+        try
+        {
+            loadContext = new PluginLoadContext(assemblyPath, _options.SharedAssemblyNames);
+            var assembly = loadContext.LoadFromAssemblyPath(assemblyPath);
+            var pluginType = ResolvePluginType(assembly);
+            plugin = CreatePluginInstance(pluginType);
+            context = CreateContext(manifest, pluginDirectory, dataDirectory, services, properties);
+
+            plugin.Initialize(context);
+            var settingsPages = context.GetSettingsPagesSnapshot();
+            var desktopComponents = context.GetDesktopComponentsSnapshot();
+
+            var loadedPlugin = new LoadedPlugin(
+                manifest,
+                sourcePath,
+                assemblyPath,
+                assembly,
+                plugin,
+                context,
+                settingsPages,
+                desktopComponents,
+                loadContext);
+
+            return PluginLoadResult.Success(sourcePath, manifest, loadedPlugin);
+        }
+        catch (Exception ex)
+        {
+            DisposeInstance(plugin);
+            DisposeInstance(context);
+            loadContext?.Unload();
+            return PluginLoadResult.Failure(sourcePath, manifest, ex);
+        }
+    }
+
+    private PluginLoadResult LoadFromManifest(
+        string manifestPath,
+        PluginManifest manifest,
+        IServiceProvider? services,
+        IReadOnlyDictionary<string, object?>? properties)
+    {
+        try
+        {
+            var fullManifestPath = Path.GetFullPath(manifestPath);
+            var assemblyPath = manifest.ResolveEntranceAssemblyPath(fullManifestPath);
+            if (!File.Exists(assemblyPath))
+            {
+                throw new FileNotFoundException(
+                    $"Plugin '{manifest.Id}' entrance assembly '{assemblyPath}' was not found.",
+                    assemblyPath);
+            }
+
+            var pluginDirectory = Path.GetDirectoryName(assemblyPath)
+                ?? throw new InvalidOperationException($"Failed to determine the plugin directory of '{assemblyPath}'.");
+            var dataDirectory = Path.Combine(pluginDirectory, _options.DataDirectoryName);
+            return LoadCore(fullManifestPath, assemblyPath, pluginDirectory, dataDirectory, manifest, services, properties);
+        }
+        catch (Exception ex)
+        {
+            return PluginLoadResult.Failure(Path.GetFullPath(manifestPath), manifest, ex);
+        }
+    }
+
+    private PluginLoadResult LoadFromPackage(
+        string packagePath,
+        string pluginsRootDirectory,
+        PluginManifest manifest,
+        IServiceProvider? services,
+        IReadOnlyDictionary<string, object?>? properties)
+    {
+        try
+        {
+            var fullPackagePath = Path.GetFullPath(packagePath);
+            var extractionDirectory = ExtractPackage(fullPackagePath, pluginsRootDirectory);
+            var extractedManifestPath = Path.Combine(extractionDirectory, _options.ManifestFileName);
+
+            if (!File.Exists(extractedManifestPath))
+            {
+                throw new FileNotFoundException(
+                    $"Plugin package '{fullPackagePath}' does not contain '{_options.ManifestFileName}'.",
+                    extractedManifestPath);
+            }
+
+            var extractedManifest = PluginManifest.Load(extractedManifestPath);
+            if (!string.Equals(extractedManifest.Id, manifest.Id, StringComparison.OrdinalIgnoreCase))
+            {
+                throw new InvalidOperationException(
+                    $"Plugin package '{fullPackagePath}' manifest id changed after extraction. Expected '{manifest.Id}', actual '{extractedManifest.Id}'.");
+            }
+
+            var assemblyPath = extractedManifest.ResolveEntranceAssemblyPath(extractedManifestPath);
+            if (!File.Exists(assemblyPath))
+            {
+                throw new FileNotFoundException(
+                    $"Plugin '{extractedManifest.Id}' entrance assembly '{assemblyPath}' was not found after package extraction.",
+                    assemblyPath);
+            }
+
+            var dataDirectory = GetPackagedDataDirectory(pluginsRootDirectory, extractedManifest);
+            return LoadCore(fullPackagePath, assemblyPath, extractionDirectory, dataDirectory, extractedManifest, services, properties);
+        }
+        catch (Exception ex)
+        {
+            return PluginLoadResult.Failure(Path.GetFullPath(packagePath), manifest, ex);
+        }
+    }
+
+    private PluginContext CreateContext(
+        PluginManifest manifest,
+        string pluginDirectory,
+        string dataDirectory,
+        IServiceProvider? services,
+        IReadOnlyDictionary<string, object?>? properties)
+    {
+        Directory.CreateDirectory(dataDirectory);
+
+        return new PluginContext(
+            manifest,
+            pluginDirectory,
+            dataDirectory,
+            services ?? NullServiceProvider.Instance,
+            CreateReadOnlyProperties(properties));
+    }
+
+    private IReadOnlyList<PluginCandidate> DiscoverCandidates(
+        string pluginsRootDirectory,
+        List<PluginLoadResult> preparationFailures)
+    {
+        var candidates = new List<PluginCandidate>();
+
+        foreach (var packagePath in EnumerateCandidatePaths(
+                     pluginsRootDirectory,
+                     "*" + NormalizePackageExtension(_options.PackageFileExtension)))
+        {
+            try
+            {
+                var manifest = ReadManifestFromPackage(packagePath);
+                candidates.Add(new PluginCandidate(Path.GetFullPath(packagePath), manifest, PluginSourceKind.Package));
+            }
+            catch (Exception ex)
+            {
+                preparationFailures.Add(PluginLoadResult.Failure(Path.GetFullPath(packagePath), null, ex));
+            }
+        }
+
+        foreach (var manifestPath in EnumerateCandidatePaths(pluginsRootDirectory, _options.ManifestFileName))
+        {
+            try
+            {
+                var manifest = PluginManifest.Load(manifestPath);
+                candidates.Add(new PluginCandidate(Path.GetFullPath(manifestPath), manifest, PluginSourceKind.Manifest));
+            }
+            catch (Exception ex)
+            {
+                preparationFailures.Add(PluginLoadResult.Failure(Path.GetFullPath(manifestPath), null, ex));
+            }
+        }
+
+        return candidates
+            .OrderBy(candidate => candidate.SourceKind)
+            .ThenBy(candidate => candidate.SourcePath, StringComparer.OrdinalIgnoreCase)
+            .ToArray();
+    }
+
+    private IEnumerable<string> EnumerateCandidatePaths(string pluginsRootDirectory, string searchPattern)
+    {
+        var runtimeRootDirectory = EnsureTrailingSeparator(GetRuntimeRootDirectory(pluginsRootDirectory));
+
+        return Directory
+            .EnumerateFiles(pluginsRootDirectory, searchPattern, SearchOption.AllDirectories)
+            .Select(Path.GetFullPath)
+            .Where(path => !path.StartsWith(runtimeRootDirectory, StringComparison.OrdinalIgnoreCase))
+            .OrderBy(path => path, StringComparer.OrdinalIgnoreCase);
+    }
+
+    private PluginManifest ReadManifestFromPackage(string packagePath)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(packagePath);
+
+        var fullPackagePath = Path.GetFullPath(packagePath);
+        if (!File.Exists(fullPackagePath))
+        {
+            throw new FileNotFoundException($"Plugin package '{fullPackagePath}' was not found.", fullPackagePath);
+        }
+
+        using var archive = ZipFile.OpenRead(fullPackagePath);
+        var manifestEntries = archive.Entries
+            .Where(entry =>
+                !string.IsNullOrWhiteSpace(entry.Name) &&
+                string.Equals(entry.Name, _options.ManifestFileName, StringComparison.OrdinalIgnoreCase))
+            .ToArray();
+
+        if (manifestEntries.Length == 0)
+        {
+            throw new InvalidOperationException(
+                $"Plugin package '{fullPackagePath}' does not contain '{_options.ManifestFileName}'.");
+        }
+
+        if (manifestEntries.Length > 1)
+        {
+            throw new InvalidOperationException(
+                $"Plugin package '{fullPackagePath}' contains multiple '{_options.ManifestFileName}' files.");
+        }
+
+        using var stream = manifestEntries[0].Open();
+        return PluginManifest.Load(stream, $"{fullPackagePath}!/{manifestEntries[0].FullName}");
+    }
+
+    private string ExtractPackage(string packagePath, string pluginsRootDirectory)
+    {
+        var extractionDirectory = GetPackageExtractionDirectory(pluginsRootDirectory, packagePath);
+        RecreateDirectory(extractionDirectory);
+        ZipFile.ExtractToDirectory(packagePath, extractionDirectory, overwriteFiles: true);
+        return extractionDirectory;
+    }
+
+    private string GetPackageExtractionDirectory(string pluginsRootDirectory, string packagePath)
+    {
+        var packageName = SanitizeDirectoryName(Path.GetFileNameWithoutExtension(packagePath));
+        var packageHash = Convert.ToHexString(
+            SHA256.HashData(Encoding.UTF8.GetBytes(Path.GetFullPath(packagePath))))
+            .Substring(0, 12);
+
+        return Path.Combine(
+            GetRuntimeRootDirectory(pluginsRootDirectory),
+            _options.ExtractedPackagesDirectoryName,
+            $"{packageName}_{packageHash}");
+    }
+
+    private string GetPackagedDataDirectory(string pluginsRootDirectory, PluginManifest manifest)
+    {
+        return Path.Combine(
+            GetRuntimeRootDirectory(pluginsRootDirectory),
+            _options.PackagedDataDirectoryName,
+            SanitizeDirectoryName(manifest.Id));
+    }
+
+    private string GetRuntimeRootDirectory(string pluginsRootDirectory)
+    {
+        return Path.Combine(Path.GetFullPath(pluginsRootDirectory), _options.RuntimeDirectoryName);
+    }
+
+    private static void RecreateDirectory(string directoryPath)
+    {
+        if (Directory.Exists(directoryPath))
+        {
+            Directory.Delete(directoryPath, recursive: true);
+        }
+
+        Directory.CreateDirectory(directoryPath);
+    }
+
+    private static string NormalizePackageExtension(string extension)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(extension);
+        return extension.StartsWith(".", StringComparison.Ordinal) ? extension : "." + extension;
+    }
+
+    private static string EnsureTrailingSeparator(string path)
+    {
+        var fullPath = Path.GetFullPath(path);
+        return fullPath.EndsWith(Path.DirectorySeparatorChar.ToString(), StringComparison.Ordinal)
+            ? fullPath
+            : fullPath + Path.DirectorySeparatorChar;
+    }
+
+    private static string SanitizeDirectoryName(string value)
+    {
+        var invalidCharacters = Path.GetInvalidFileNameChars();
+        var builder = new StringBuilder(value.Length);
+
+        foreach (var ch in value)
+        {
+            builder.Append(invalidCharacters.Contains(ch) ? '_' : ch);
+        }
+
+        return string.IsNullOrWhiteSpace(builder.ToString()) ? "_plugin" : builder.ToString().Trim();
+    }
+
+    private static ReadOnlyDictionary<string, object?> CreateReadOnlyProperties(
+        IReadOnlyDictionary<string, object?>? properties)
+    {
+        if (properties is null || properties.Count == 0)
+        {
+            return new ReadOnlyDictionary<string, object?>(
+                new Dictionary<string, object?>(StringComparer.OrdinalIgnoreCase));
+        }
+
+        var map = new Dictionary<string, object?>(StringComparer.OrdinalIgnoreCase);
+        foreach (var pair in properties)
+        {
+            map[pair.Key] = pair.Value;
+        }
+
+        return new ReadOnlyDictionary<string, object?>(map);
+    }
+
+    private static Type ResolvePluginType(Assembly assembly)
+    {
+        var candidateTypes = GetLoadableTypes(assembly)
+            .Where(type =>
+                typeof(IPlugin).IsAssignableFrom(type) &&
+                !type.IsAbstract &&
+                !type.IsInterface &&
+                !type.ContainsGenericParameters)
+            .ToArray();
+
+        if (candidateTypes.Length == 0)
+        {
+            throw new InvalidOperationException(
+                $"Assembly '{assembly.Location}' does not contain a concrete type implementing '{nameof(IPlugin)}'.");
+        }
+
+        var attributedTypes = candidateTypes
+            .Where(type => type.IsDefined(typeof(PluginEntranceAttribute), inherit: false))
+            .ToArray();
+
+        if (attributedTypes.Length == 1)
+        {
+            return attributedTypes[0];
+        }
+
+        if (attributedTypes.Length > 1)
+        {
+            throw new InvalidOperationException(
+                $"Assembly '{assembly.Location}' contains multiple plugin entrance types. Mark only one type with '{nameof(PluginEntranceAttribute)}'.");
+        }
+
+        if (candidateTypes.Length == 1)
+        {
+            return candidateTypes[0];
+        }
+
+        throw new InvalidOperationException(
+            $"Assembly '{assembly.Location}' contains multiple '{nameof(IPlugin)}' implementations. Mark the intended entrance type with '{nameof(PluginEntranceAttribute)}'.");
+    }
+
+    private static IPlugin CreatePluginInstance(Type pluginType)
+    {
+        if (pluginType.GetConstructor(Type.EmptyTypes) is null)
+        {
+            throw new InvalidOperationException(
+                $"Plugin type '{pluginType.FullName}' must expose a public parameterless constructor.");
+        }
+
+        if (Activator.CreateInstance(pluginType) is not IPlugin plugin)
+        {
+            throw new InvalidOperationException(
+                $"Failed to create plugin instance of type '{pluginType.FullName}'.");
+        }
+
+        return plugin;
+    }
+
+    private static void DisposeInstance(object? instance)
+    {
+        if (instance is null)
+        {
+            return;
+        }
+
+        try
+        {
+            if (instance is IAsyncDisposable asyncDisposable)
+            {
+                asyncDisposable.DisposeAsync().AsTask().GetAwaiter().GetResult();
+                return;
+            }
+
+            if (instance is IDisposable disposable)
+            {
+                disposable.Dispose();
+            }
+        }
+        catch (Exception disposeError)
+        {
+            System.Diagnostics.Debug.WriteLine(
+                $"[PluginLoader] Disposal of '{instance.GetType().FullName}' failed: {disposeError}");
+        }
+    }
+
+    private static Type[] GetLoadableTypes(Assembly assembly)
+    {
+        try
+        {
+            return assembly.GetTypes();
+        }
+        catch (ReflectionTypeLoadException ex)
+        {
+            var loaderMessages = ex.LoaderExceptions
+                .Where(exception => exception is not null)
+                .Select(exception => exception!.Message)
+                .ToArray();
+
+            var detail = loaderMessages.Length == 0
+                ? "No additional loader diagnostics were provided."
+                : string.Join(Environment.NewLine, loaderMessages);
+
+            throw new InvalidOperationException(
+                $"Failed to inspect plugin assembly '{assembly.Location}'.{Environment.NewLine}{detail}",
+                ex);
+        }
+    }
+
+    private sealed class PluginContext : IPluginContext, IDisposable, IAsyncDisposable
+    {
+        private readonly Dictionary<string, PluginSettingsPageRegistration> _settingsPages =
+            new(StringComparer.OrdinalIgnoreCase);
+        private readonly Dictionary<string, PluginDesktopComponentRegistration> _desktopComponents =
+            new(StringComparer.OrdinalIgnoreCase);
+        private readonly Dictionary<Type, object> _registeredServices = [];
+        private readonly List<object> _serviceRegistrationOrder = [];
+        private readonly object _serviceGate = new();
+        private readonly IServiceProvider _hostServices;
+        private int _disposed;
+
+        public PluginContext(
+            PluginManifest manifest,
+            string pluginDirectory,
+            string dataDirectory,
+            IServiceProvider services,
+            IReadOnlyDictionary<string, object?> properties)
+        {
+            Manifest = manifest;
+            PluginDirectory = pluginDirectory;
+            DataDirectory = dataDirectory;
+            _hostServices = services;
+            Services = new PluginCompositeServiceProvider(this);
+            Properties = properties;
+
+            RegisterBuiltInService<IPluginContext>(this);
+            RegisterBuiltInService<IPluginMessageBus>(new PluginMessageBus());
+        }
+
+        public PluginManifest Manifest { get; }
+
+        public string PluginDirectory { get; }
+
+        public string DataDirectory { get; }
+
+        public IServiceProvider Services { get; }
+
+        public IReadOnlyDictionary<string, object?> Properties { get; }
+
+        public T? GetService<T>()
+        {
+            return (T?)Services.GetService(typeof(T));
+        }
+
+        public bool TryGetProperty<T>(string key, out T? value)
+        {
+            ArgumentException.ThrowIfNullOrWhiteSpace(key);
+
+            if (Properties.TryGetValue(key, out var rawValue) && rawValue is T typedValue)
+            {
+                value = typedValue;
+                return true;
+            }
+
+            value = default;
+            return false;
+        }
+
+        public void RegisterService<TService>(TService service)
+            where TService : class
+        {
+            RegisterServiceCore(typeof(TService), service, allowOverride: false);
+        }
+
+        public void RegisterSettingsPage(PluginSettingsPageRegistration registration)
+        {
+            ArgumentNullException.ThrowIfNull(registration);
+            ThrowIfDisposed();
+
+            if (!_settingsPages.TryAdd(registration.Id, registration))
+            {
+                throw new InvalidOperationException(
+                    $"Plugin '{Manifest.Id}' already registered a settings page with id '{registration.Id}'.");
+            }
+        }
+
+        public void RegisterDesktopComponent(PluginDesktopComponentRegistration registration)
+        {
+            ArgumentNullException.ThrowIfNull(registration);
+            ThrowIfDisposed();
+
+            if (!_desktopComponents.TryAdd(registration.ComponentId, registration))
+            {
+                throw new InvalidOperationException(
+                    $"Plugin '{Manifest.Id}' already registered a desktop component with id '{registration.ComponentId}'.");
+            }
+        }
+
+        public IReadOnlyList<PluginSettingsPageRegistration> GetSettingsPagesSnapshot()
+        {
+            ThrowIfDisposed();
+            return _settingsPages.Values
+                .OrderBy(page => page.SortOrder)
+                .ThenBy(page => page.Title, StringComparer.OrdinalIgnoreCase)
+                .ToArray();
+        }
+
+        public IReadOnlyList<PluginDesktopComponentRegistration> GetDesktopComponentsSnapshot()
+        {
+            ThrowIfDisposed();
+            return _desktopComponents.Values
+                .OrderBy(component => component.Category, StringComparer.OrdinalIgnoreCase)
+                .ThenBy(component => component.DisplayName, StringComparer.OrdinalIgnoreCase)
+                .ToArray();
+        }
+
+        internal object? ResolveService(Type serviceType)
+        {
+            if (Volatile.Read(ref _disposed) != 0)
+            {
+                return null;
+            }
+
+            if (serviceType == typeof(IServiceProvider))
+            {
+                return Services;
+            }
+
+            lock (_serviceGate)
+            {
+                if (_registeredServices.TryGetValue(serviceType, out var service))
+                {
+                    return service;
+                }
+
+                foreach (var registeredService in _registeredServices.Values)
+                {
+                    if (serviceType.IsInstanceOfType(registeredService))
+                    {
+                        return registeredService;
+                    }
+                }
+            }
+
+            return _hostServices.GetService(serviceType);
+        }
+
+        private void RegisterBuiltInService<TService>(TService service)
+            where TService : class
+        {
+            RegisterServiceCore(typeof(TService), service, allowOverride: true);
+        }
+
+        public void Dispose()
+        {
+            DisposeAsync().AsTask().GetAwaiter().GetResult();
+        }
+
+        public async ValueTask DisposeAsync()
+        {
+            if (Interlocked.Exchange(ref _disposed, 1) != 0)
+            {
+                return;
+            }
+
+            object[] services;
+            lock (_serviceGate)
+            {
+                services = _serviceRegistrationOrder.ToArray();
+                _registeredServices.Clear();
+                _serviceRegistrationOrder.Clear();
+            }
+
+            _settingsPages.Clear();
+            _desktopComponents.Clear();
+
+            var disposedServices = new HashSet<object>(ReferenceEqualityComparer.Instance);
+            for (var i = services.Length - 1; i >= 0; i--)
+            {
+                var service = services[i];
+                if (ReferenceEquals(service, this) || !disposedServices.Add(service))
+                {
+                    continue;
+                }
+
+                if (service is IAsyncDisposable asyncDisposable)
+                {
+                    await asyncDisposable.DisposeAsync();
+                }
+                else if (service is IDisposable disposable)
+                {
+                    disposable.Dispose();
+                }
+            }
+        }
+
+        private void RegisterServiceCore(Type serviceType, object service, bool allowOverride)
+        {
+            ArgumentNullException.ThrowIfNull(serviceType);
+            ArgumentNullException.ThrowIfNull(service);
+            ThrowIfDisposed();
+
+            if (!serviceType.IsInstanceOfType(service))
+            {
+                throw new InvalidOperationException(
+                    $"Service instance '{service.GetType().FullName}' is not assignable to '{serviceType.FullName}'.");
+            }
+
+            lock (_serviceGate)
+            {
+                if (!allowOverride && _registeredServices.ContainsKey(serviceType))
+                {
+                    throw new InvalidOperationException(
+                        $"Plugin '{Manifest.Id}' already registered a service for '{serviceType.FullName}'.");
+                }
+
+                _registeredServices[serviceType] = service;
+                _serviceRegistrationOrder.Add(service);
+            }
+        }
+
+        private void ThrowIfDisposed()
+        {
+            if (Volatile.Read(ref _disposed) != 0)
+            {
+                throw new ObjectDisposedException(nameof(PluginContext));
+            }
+        }
+    }
+
+    private sealed class PluginCompositeServiceProvider : IServiceProvider
+    {
+        private readonly PluginContext _context;
+
+        public PluginCompositeServiceProvider(PluginContext context)
+        {
+            _context = context;
+        }
+
+        public object? GetService(Type serviceType)
+        {
+            ArgumentNullException.ThrowIfNull(serviceType);
+            return _context.ResolveService(serviceType);
+        }
+    }
+
+    private sealed class PluginMessageBus : IPluginMessageBus, IDisposable
+    {
+        private readonly Dictionary<Type, List<Subscription>> _subscriptions = [];
+        private readonly object _gate = new();
+        private int _disposed;
+
+        public IDisposable Subscribe<TMessage>(Action<TMessage> handler)
+        {
+            ArgumentNullException.ThrowIfNull(handler);
+            if (Volatile.Read(ref _disposed) != 0)
+            {
+                throw new ObjectDisposedException(nameof(PluginMessageBus));
+            }
+
+            var subscription = new Subscription(this, typeof(TMessage), message => handler((TMessage)message!));
+            lock (_gate)
+            {
+                if (!_subscriptions.TryGetValue(subscription.MessageType, out var handlers))
+                {
+                    handlers = [];
+                    _subscriptions[subscription.MessageType] = handlers;
+                }
+
+                handlers.Add(subscription);
+            }
+
+            return subscription;
+        }
+
+        public void Publish<TMessage>(TMessage message)
+        {
+            if (Volatile.Read(ref _disposed) != 0)
+            {
+                return;
+            }
+
+            Subscription[] handlers;
+            lock (_gate)
+            {
+                if (!_subscriptions.TryGetValue(typeof(TMessage), out var subscriptions) || subscriptions.Count == 0)
+                {
+                    return;
+                }
+
+                handlers = subscriptions.ToArray();
+            }
+
+            foreach (var handler in handlers)
+            {
+                try
+                {
+                    handler.Invoke(message);
+                }
+                catch (Exception ex)
+                {
+                    System.Diagnostics.Debug.WriteLine(
+                        $"[PluginMessageBus] Handler for '{typeof(TMessage).FullName}' failed: {ex}");
+                }
+            }
+        }
+
+        public void Dispose()
+        {
+            if (Interlocked.Exchange(ref _disposed, 1) != 0)
+            {
+                return;
+            }
+
+            lock (_gate)
+            {
+                _subscriptions.Clear();
+            }
+        }
+
+        private void Unsubscribe(Subscription subscription)
+        {
+            lock (_gate)
+            {
+                if (!_subscriptions.TryGetValue(subscription.MessageType, out var handlers))
+                {
+                    return;
+                }
+
+                handlers.Remove(subscription);
+                if (handlers.Count == 0)
+                {
+                    _subscriptions.Remove(subscription.MessageType);
+                }
+            }
+        }
+
+        private sealed class Subscription : IDisposable
+        {
+            private readonly PluginMessageBus _owner;
+            private int _disposed;
+
+            public Subscription(PluginMessageBus owner, Type messageType, Action<object?> handler)
+            {
+                _owner = owner;
+                MessageType = messageType;
+                Handler = handler;
+            }
+
+            public Type MessageType { get; }
+
+            public Action<object?> Handler { get; }
+
+            public void Invoke(object? message)
+            {
+                if (_disposed != 0)
+                {
+                    return;
+                }
+
+                Handler(message);
+            }
+
+            public void Dispose()
+            {
+                if (Interlocked.Exchange(ref _disposed, 1) != 0)
+                {
+                    return;
+                }
+
+                _owner.Unsubscribe(this);
+            }
+        }
+    }
+
+    private sealed class NullServiceProvider : IServiceProvider
+    {
+        public static NullServiceProvider Instance { get; } = new();
+
+        private NullServiceProvider()
+        {
+        }
+
+        public object? GetService(Type serviceType)
+        {
+            return null;
+        }
+    }
+
+    private enum PluginSourceKind
+    {
+        Package = 0,
+        Manifest = 1
+    }
+
+    private sealed record PluginCandidate(
+        string SourcePath,
+        PluginManifest Manifest,
+        PluginSourceKind SourceKind);
+}

LanMountainDesktop.PluginSdk/PluginLoaderOptions.cs

@@ -0,0 +1,21 @@
+namespace LanMountainDesktop.PluginSdk;
+
+public sealed class PluginLoaderOptions
+{
+    public string ManifestFileName { get; init; } = PluginSdkInfo.ManifestFileName;
+
+    public string PackageFileExtension { get; init; } = PluginSdkInfo.PackageFileExtension;
+
+    public string DataDirectoryName { get; init; } = PluginSdkInfo.DataDirectoryName;
+
+    public string RuntimeDirectoryName { get; init; } = PluginSdkInfo.RuntimeDirectoryName;
+
+    public string ExtractedPackagesDirectoryName { get; init; } = PluginSdkInfo.ExtractedPackagesDirectoryName;
+
+    public string PackagedDataDirectoryName { get; init; } = PluginSdkInfo.PackagedDataDirectoryName;
+
+    public ISet<string> SharedAssemblyNames { get; } = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
+    {
+        typeof(IPlugin).Assembly.GetName().Name!
+    };
+}

LanMountainDesktop.PluginSdk/PluginManifest.cs

@@ -0,0 +1,107 @@
+using System.Text.Json;
+
+namespace LanMountainDesktop.PluginSdk;
+
+public sealed record PluginManifest(
+    string Id,
+    string Name,
+    string EntranceAssembly,
+    string? Description = null,
+    string? Author = null,
+    string? Version = null,
+    string? ApiVersion = null)
+{
+    private static readonly JsonSerializerOptions SerializerOptions = new()
+    {
+        PropertyNameCaseInsensitive = true,
+        ReadCommentHandling = JsonCommentHandling.Skip,
+        AllowTrailingCommas = true
+    };
+
+    public static PluginManifest Load(string manifestPath)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(manifestPath);
+
+        using var stream = File.OpenRead(manifestPath);
+        return Load(stream, manifestPath);
+    }
+
+    public static PluginManifest Load(Stream stream, string sourceName)
+    {
+        ArgumentNullException.ThrowIfNull(stream);
+        ArgumentException.ThrowIfNullOrWhiteSpace(sourceName);
+
+        var manifest = JsonSerializer.Deserialize<PluginManifest>(stream, SerializerOptions);
+        if (manifest is null)
+        {
+            throw new InvalidOperationException($"Failed to deserialize plugin manifest '{sourceName}'.");
+        }
+
+        return manifest.NormalizeAndValidate(sourceName);
+    }
+
+    public string ResolveEntranceAssemblyPath(string manifestPath)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(manifestPath);
+
+        if (Path.IsPathRooted(EntranceAssembly))
+        {
+            return Path.GetFullPath(EntranceAssembly);
+        }
+
+        var manifestDirectory = Path.GetDirectoryName(Path.GetFullPath(manifestPath))
+            ?? throw new InvalidOperationException($"Failed to determine the directory of '{manifestPath}'.");
+
+        return Path.GetFullPath(Path.Combine(manifestDirectory, EntranceAssembly));
+    }
+
+    private PluginManifest NormalizeAndValidate(string manifestPath)
+    {
+        var normalized = this with
+        {
+            Id = RequireValue(Id, nameof(Id), manifestPath),
+            Name = RequireValue(Name, nameof(Name), manifestPath),
+            EntranceAssembly = RequireValue(EntranceAssembly, nameof(EntranceAssembly), manifestPath),
+            Description = NormalizeOptionalValue(Description),
+            Author = NormalizeOptionalValue(Author),
+            Version = NormalizeOptionalValue(Version),
+            ApiVersion = NormalizeOptionalValue(ApiVersion) ?? PluginSdkInfo.ApiVersion
+        };
+
+        if (!System.Version.TryParse(normalized.ApiVersion, out var requestedVersion))
+        {
+            throw new InvalidOperationException(
+                $"Plugin manifest '{manifestPath}' declares an invalid API version '{normalized.ApiVersion}'.");
+        }
+
+        if (!System.Version.TryParse(PluginSdkInfo.ApiVersion, out var currentVersion))
+        {
+            throw new InvalidOperationException($"Plugin SDK API version '{PluginSdkInfo.ApiVersion}' is invalid.");
+        }
+
+        if (requestedVersion.Major != currentVersion.Major)
+        {
+            throw new InvalidOperationException(
+                $"Plugin '{normalized.Id}' targets API version '{normalized.ApiVersion}', but the host provides '{PluginSdkInfo.ApiVersion}'.");
+        }
+
+        return normalized;
+    }
+
+    private static string RequireValue(string? value, string propertyName, string manifestPath)
+    {
+        var normalized = NormalizeOptionalValue(value);
+        if (string.IsNullOrWhiteSpace(normalized))
+        {
+            throw new InvalidOperationException(
+                $"Plugin manifest '{manifestPath}' is missing required property '{propertyName}'.");
+        }
+
+        return normalized;
+    }
+
+    private static string? NormalizeOptionalValue(string? value)
+    {
+        return string.IsNullOrWhiteSpace(value) ? null : value.Trim();
+    }
+}

LanMountainDesktop.PluginSdk/PluginSdkInfo.cs

@@ -0,0 +1,12 @@
+namespace LanMountainDesktop.PluginSdk;
+
+public static class PluginSdkInfo
+{
+    public const string ApiVersion = "1.0.0";
+    public const string ManifestFileName = "plugin.json";
+    public const string PackageFileExtension = ".laapp";
+    public const string DataDirectoryName = "Data";
+    public const string RuntimeDirectoryName = ".runtime";
+    public const string ExtractedPackagesDirectoryName = "packages";
+    public const string PackagedDataDirectoryName = "data";
+}

LanMountainDesktop.PluginSdk/PluginSettingsPageRegistration.cs

@@ -0,0 +1,30 @@
+using Avalonia.Controls;
+
+namespace LanMountainDesktop.PluginSdk;
+
+public sealed class PluginSettingsPageRegistration
+{
+    public PluginSettingsPageRegistration(
+        string id,
+        string title,
+        Func<Control> contentFactory,
+        int sortOrder = 0)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(id);
+        ArgumentException.ThrowIfNullOrWhiteSpace(title);
+        ArgumentNullException.ThrowIfNull(contentFactory);
+
+        Id = id.Trim();
+        Title = title.Trim();
+        ContentFactory = contentFactory;
+        SortOrder = sortOrder;
+    }
+
+    public string Id { get; }
+
+    public string Title { get; }
+
+    public int SortOrder { get; }
+
+    public Func<Control> ContentFactory { get; }
+}

LanMountainDesktop.SamplePlugin/LanMountainDesktop.SamplePlugin.csproj

@@ -0,0 +1,29 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <Version>1.0.0</Version>
+    <EnableDynamicLoading>true</EnableDynamicLoading>
+    <OutputPath>bin\$(Configuration)\$(TargetFramework)\content\</OutputPath>
+    <AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
+    <AppendRuntimeIdentifierToOutputPath>false</AppendRuntimeIdentifierToOutputPath>
+    <PluginPackageOutputDirectory>..\LanMountainDesktop\bin\$(Configuration)\$(TargetFramework)\Extensions\Plugins\</PluginPackageOutputDirectory>
+    <PluginPackagePath>$(PluginPackageOutputDirectory)$(AssemblyName).laapp</PluginPackagePath>
+    <LegacyLoosePluginOutputDirectory>..\LanMountainDesktop\bin\$(Configuration)\$(TargetFramework)\Extensions\Plugins\SamplePlugin\</LegacyLoosePluginOutputDirectory>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\LanMountainDesktop.PluginSdk\LanMountainDesktop.PluginSdk.csproj" Private="false" />
+    <None Include="plugin.json" CopyToOutputDirectory="PreserveNewest" />
+  </ItemGroup>
+
+  <Target Name="CreateLaappPackage" AfterTargets="Build">
+    <MakeDir Directories="$(PluginPackageOutputDirectory)" />
+    <RemoveDir Directories="$(LegacyLoosePluginOutputDirectory)" />
+    <Delete Files="$(PluginPackagePath)" TreatErrorsAsWarnings="true" />
+    <ZipDirectory SourceDirectory="$(OutputPath)" DestinationFile="$(PluginPackagePath)" />
+  </Target>
+
+</Project>

LanMountainDesktop.SamplePlugin/SamplePlugin.cs

@@ -0,0 +1,84 @@
+using LanMountainDesktop.PluginSdk;
+
+namespace LanMountainDesktop.SamplePlugin;
+
+[PluginEntrance]
+public sealed class SamplePlugin : PluginBase, IDisposable
+{
+    private SamplePluginRuntimeStateService? _stateService;
+    private SamplePluginClockService? _clockService;
+
+    public override void Initialize(IPluginContext context)
+    {
+        Directory.CreateDirectory(context.DataDirectory);
+
+        var hostName = GetHostProperty(context, "HostApplicationName", "UnknownHost");
+        var hostVersion = GetHostProperty(context, "HostVersion", "UnknownVersion");
+        var sdkApiVersion = GetHostProperty(context, "PluginSdkApiVersion", "UnknownApiVersion");
+        var messageBus = context.GetService<IPluginMessageBus>()
+            ?? throw new InvalidOperationException("Plugin message bus is not available.");
+
+        _stateService = new SamplePluginRuntimeStateService(
+            context.Manifest,
+            context.PluginDirectory,
+            context.DataDirectory,
+            hostName,
+            hostVersion,
+            sdkApiVersion,
+            messageBus);
+        context.RegisterService(_stateService);
+
+        _clockService = new SamplePluginClockService(context.DataDirectory, _stateService, messageBus);
+        context.RegisterService(_clockService);
+        _stateService.AttachClockService(_clockService);
+
+        var logPath = Path.Combine(context.DataDirectory, "sample-plugin.log");
+        var initMessage =
+            $"[{DateTimeOffset.UtcNow:O}] {context.Manifest.Name} initialized in {hostName} (plugin version {context.Manifest.Version ?? "dev"}).";
+
+        try
+        {
+            File.AppendAllText(logPath, initMessage + Environment.NewLine);
+            _stateService.MarkBackendReady($"Initialization log written to {logPath}.");
+        }
+        catch (Exception ex)
+        {
+            _stateService.MarkBackendFaulted($"Initialization log write failed: {ex.Message}");
+            throw;
+        }
+
+        _clockService.Start();
+
+        context.RegisterSettingsPage(new PluginSettingsPageRegistration(
+            "status",
+            "Plugin Status",
+            () => new SamplePluginSettingsView(context)));
+
+        context.RegisterDesktopComponent(new PluginDesktopComponentRegistration(
+            "LanMountainDesktop.SamplePlugin.StatusClock",
+            "Sample Plugin Status Clock",
+            widgetContext => new SamplePluginStatusClockWidget(widgetContext),
+            iconKey: "PuzzlePiece",
+            category: "Plugins",
+            minWidthCells: 4,
+            minHeightCells: 4,
+            allowDesktopPlacement: true,
+            allowStatusBarPlacement: false,
+            resizeMode: PluginDesktopComponentResizeMode.Proportional,
+            cornerRadiusResolver: cellSize => Math.Clamp(cellSize * 0.34, 18, 34)));
+    }
+
+    public void Dispose()
+    {
+        _clockService?.Dispose();
+        _clockService = null;
+        _stateService = null;
+    }
+
+    private static string GetHostProperty(IPluginContext context, string key, string fallback)
+    {
+        return context.TryGetProperty<string>(key, out var value) && !string.IsNullOrWhiteSpace(value)
+            ? value
+            : fallback;
+    }
+}

LanMountainDesktop.SamplePlugin/SamplePluginRuntimeStatus.cs

@@ -0,0 +1,465 @@
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Threading;
+using LanMountainDesktop.PluginSdk;
+
+namespace LanMountainDesktop.SamplePlugin;
+
+internal enum SamplePluginHealthState
+{
+    Healthy,
+    Pending,
+    Faulted
+}
+
+internal sealed record SamplePluginStatusEntry(
+    string Key,
+    string Title,
+    SamplePluginHealthState State,
+    string Summary,
+    string Detail,
+    DateTimeOffset UpdatedAt);
+
+internal sealed record SamplePluginCapabilityItem(
+    string Title,
+    string Detail);
+
+internal sealed record SamplePluginRuntimeSnapshot(
+    PluginManifest Manifest,
+    string PluginDirectory,
+    string DataDirectory,
+    string HostApplicationName,
+    string HostVersion,
+    string SdkApiVersion,
+    IReadOnlyList<SamplePluginStatusEntry> StatusEntries,
+    bool HasPlacedComponent,
+    int PlacedCount,
+    int PreviewCount,
+    IReadOnlyList<string> PlacementIds,
+    string? LastComponentId,
+    double LastCellSize,
+    DateTimeOffset? ServiceClockTime);
+
+internal sealed record SamplePluginClockTickMessage(DateTimeOffset CurrentTime);
+
+internal sealed record SamplePluginStateChangedMessage(string Reason);
+
+internal sealed record SamplePluginComponentInstance(
+    string ComponentId,
+    string? PlacementId,
+    double CellSize)
+{
+    public bool IsPlaced => !string.IsNullOrWhiteSpace(PlacementId);
+}
+
+internal sealed class SamplePluginRuntimeStateService
+{
+    private readonly object _gate = new();
+    private readonly IPluginMessageBus _messageBus;
+    private readonly Dictionary<string, SamplePluginComponentInstance> _componentInstances =
+        new(StringComparer.OrdinalIgnoreCase);
+
+    private readonly PluginManifest _manifest;
+    private readonly string _pluginDirectory;
+    private readonly string _dataDirectory;
+    private readonly string _hostApplicationName;
+    private readonly string _hostVersion;
+    private readonly string _sdkApiVersion;
+
+    private SamplePluginStatusEntry _frontend;
+    private SamplePluginStatusEntry _component;
+    private SamplePluginStatusEntry _backend;
+    private SamplePluginStatusEntry _service;
+    private string? _lastComponentId;
+    private double _lastCellSize;
+    private DateTimeOffset? _serviceClockTime;
+
+    public SamplePluginRuntimeStateService(
+        PluginManifest manifest,
+        string pluginDirectory,
+        string dataDirectory,
+        string hostApplicationName,
+        string hostVersion,
+        string sdkApiVersion,
+        IPluginMessageBus messageBus)
+    {
+        _manifest = manifest;
+        _pluginDirectory = pluginDirectory;
+        _dataDirectory = dataDirectory;
+        _hostApplicationName = hostApplicationName;
+        _hostVersion = hostVersion;
+        _sdkApiVersion = sdkApiVersion;
+        _messageBus = messageBus;
+
+        _frontend = CreateEntry(
+            "frontend",
+            "Frontend",
+            SamplePluginHealthState.Pending,
+            "Pending",
+            "Waiting for a plugin UI surface to connect.");
+
+        _component = CreateEntry(
+            "component",
+            "Component",
+            SamplePluginHealthState.Pending,
+            "Pending",
+            "No component instance has been created yet.");
+
+        _backend = CreateEntry(
+            "backend",
+            "Backend",
+            SamplePluginHealthState.Pending,
+            "Pending",
+            "Plugin initialization is in progress.");
+
+        _service = CreateEntry(
+            "service",
+            "Clock Service",
+            SamplePluginHealthState.Pending,
+            "Pending",
+            "Clock service is not attached yet.");
+    }
+
+    public void AttachClockService(SamplePluginClockService clockService)
+    {
+        ArgumentNullException.ThrowIfNull(clockService);
+
+        lock (_gate)
+        {
+            _serviceClockTime = clockService.CurrentTime;
+            _service = CreateEntry(
+                "service",
+                "Clock Service",
+                SamplePluginHealthState.Pending,
+                "Attached",
+                "Clock service was attached and is waiting for the first tick.");
+        }
+
+        PublishStateChanged("Clock service attached");
+    }
+
+    public void MarkFrontendReady(string detail)
+    {
+        lock (_gate)
+        {
+            _frontend = CreateEntry(
+                "frontend",
+                "Frontend",
+                SamplePluginHealthState.Healthy,
+                "Healthy",
+                detail);
+        }
+
+        PublishStateChanged("Frontend updated");
+    }
+
+    public void MarkBackendReady(string detail)
+    {
+        lock (_gate)
+        {
+            _backend = CreateEntry(
+                "backend",
+                "Backend",
+                SamplePluginHealthState.Healthy,
+                "Healthy",
+                detail);
+        }
+
+        PublishStateChanged("Backend updated");
+    }
+
+    public void MarkBackendFaulted(string detail)
+    {
+        lock (_gate)
+        {
+            _backend = CreateEntry(
+                "backend",
+                "Backend",
+                SamplePluginHealthState.Faulted,
+                "Faulted",
+                detail);
+        }
+
+        PublishStateChanged("Backend faulted");
+    }
+
+    public void MarkClockServiceTick(DateTimeOffset currentTime)
+    {
+        lock (_gate)
+        {
+            _serviceClockTime = currentTime;
+            _service = CreateEntry(
+                "service",
+                "Clock Service",
+                SamplePluginHealthState.Healthy,
+                "Healthy",
+                $"Clock service is running. Current service time: {currentTime.LocalDateTime:HH:mm:ss}");
+        }
+
+        PublishStateChanged("Clock service tick");
+    }
+
+    public void MarkClockServiceFaulted(string detail)
+    {
+        lock (_gate)
+        {
+            _service = CreateEntry(
+                "service",
+                "Clock Service",
+                SamplePluginHealthState.Faulted,
+                "Faulted",
+                detail);
+        }
+
+        PublishStateChanged("Clock service faulted");
+    }
+
+    public string RegisterComponentInstance(string componentId, string? placementId, double cellSize)
+    {
+        var instanceId = Guid.NewGuid().ToString("N");
+
+        lock (_gate)
+        {
+            _componentInstances[instanceId] = new SamplePluginComponentInstance(componentId, placementId, cellSize);
+            _lastComponentId = componentId;
+            _lastCellSize = cellSize;
+            UpdateComponentStatusNoLock();
+        }
+
+        PublishStateChanged("Component attached");
+        return instanceId;
+    }
+
+    public void UnregisterComponentInstance(string instanceId)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(instanceId);
+
+        var removed = false;
+        lock (_gate)
+        {
+            removed = _componentInstances.Remove(instanceId);
+            if (removed)
+            {
+                UpdateComponentStatusNoLock();
+            }
+        }
+
+        if (removed)
+        {
+            PublishStateChanged("Component detached");
+        }
+    }
+
+    public SamplePluginRuntimeSnapshot GetSnapshot()
+    {
+        lock (_gate)
+        {
+            var placementIds = _componentInstances.Values
+                .Where(instance => instance.IsPlaced)
+                .Select(instance => instance.PlacementId!)
+                .Distinct(StringComparer.OrdinalIgnoreCase)
+                .OrderBy(id => id, StringComparer.OrdinalIgnoreCase)
+                .ToArray();
+
+            var previewCount = _componentInstances.Values.Count(instance => !instance.IsPlaced);
+
+            return new SamplePluginRuntimeSnapshot(
+                _manifest,
+                _pluginDirectory,
+                _dataDirectory,
+                _hostApplicationName,
+                _hostVersion,
+                _sdkApiVersion,
+                [_frontend, _component, _backend, _service],
+                placementIds.Length > 0,
+                placementIds.Length,
+                previewCount,
+                placementIds,
+                _lastComponentId,
+                _lastCellSize,
+                _serviceClockTime);
+        }
+    }
+
+    public IReadOnlyList<SamplePluginCapabilityItem> GetCapabilities(
+        IPluginContext context,
+        bool hasStateService,
+        bool hasClockService,
+        bool hasMessageBus)
+    {
+        ArgumentNullException.ThrowIfNull(context);
+
+        var propertyNames = context.Properties.Count == 0
+            ? "(none)"
+            : string.Join(", ", context.Properties.Keys.OrderBy(key => key, StringComparer.OrdinalIgnoreCase));
+
+        return
+        [
+            new SamplePluginCapabilityItem(
+                "IPluginContext.Manifest",
+                $"Readable. Current plugin id: {context.Manifest.Id}; version: {context.Manifest.Version ?? "dev"}."),
+            new SamplePluginCapabilityItem(
+                "IPluginContext.PluginDirectory / DataDirectory",
+                $"Readable. Plugin directory: {context.PluginDirectory}; data directory: {context.DataDirectory}."),
+            new SamplePluginCapabilityItem(
+                "IPluginContext.Properties",
+                $"Readable. Host properties currently exposed: {propertyNames}."),
+            new SamplePluginCapabilityItem(
+                "IPluginContext.GetService<T>()",
+                $"Callable. State service resolved: {hasStateService}; clock service resolved: {hasClockService}; message bus resolved: {hasMessageBus}."),
+            new SamplePluginCapabilityItem(
+                "IPluginContext.RegisterService<TService>()",
+                "Callable during plugin initialization. This plugin registers SamplePluginRuntimeStateService and SamplePluginClockService into the plugin service container."),
+            new SamplePluginCapabilityItem(
+                "Plugin communication bus",
+                "This plugin uses IPluginMessageBus to push clock ticks and state change notifications into plugin UI surfaces."),
+            new SamplePluginCapabilityItem(
+                "PluginDesktopComponentContext",
+                "Widgets can read ComponentId, PlacementId, CellSize, and call GetService<T>() against the same plugin service container.")
+        ];
+    }
+
+    private void UpdateComponentStatusNoLock()
+    {
+        var placementIds = _componentInstances.Values
+            .Where(instance => instance.IsPlaced)
+            .Select(instance => instance.PlacementId!)
+            .Distinct(StringComparer.OrdinalIgnoreCase)
+            .OrderBy(id => id, StringComparer.OrdinalIgnoreCase)
+            .ToArray();
+
+        var previewCount = _componentInstances.Values.Count(instance => !instance.IsPlaced);
+
+        if (placementIds.Length > 0)
+        {
+            _component = CreateEntry(
+                "component",
+                "Component",
+                SamplePluginHealthState.Healthy,
+                "Placed",
+                $"Placed count: {placementIds.Length}; preview count: {previewCount}; placements: {string.Join(", ", placementIds)}");
+            return;
+        }
+
+        if (previewCount > 0)
+        {
+            _component = CreateEntry(
+                "component",
+                "Component",
+                SamplePluginHealthState.Healthy,
+                "Preview",
+                $"Preview instances: {previewCount}; no placed desktop instance is active yet.");
+            return;
+        }
+
+        _component = CreateEntry(
+            "component",
+            "Component",
+            SamplePluginHealthState.Pending,
+            "Pending",
+            "No component instance is active.");
+    }
+
+    private void PublishStateChanged(string reason)
+    {
+        _messageBus.Publish(new SamplePluginStateChangedMessage(reason));
+    }
+
+    private static SamplePluginStatusEntry CreateEntry(
+        string key,
+        string title,
+        SamplePluginHealthState state,
+        string summary,
+        string detail)
+    {
+        return new SamplePluginStatusEntry(
+            key,
+            title,
+            state,
+            summary,
+            detail,
+            DateTimeOffset.Now);
+    }
+}
+
+internal sealed class SamplePluginClockService : IDisposable
+{
+    private readonly object _gate = new();
+    private readonly string _clockStateFilePath;
+    private readonly SamplePluginRuntimeStateService _stateService;
+    private readonly IPluginMessageBus _messageBus;
+    private readonly Timer _timer;
+    private DateTimeOffset _currentTime = DateTimeOffset.Now;
+    private int _disposed;
+
+    public SamplePluginClockService(
+        string dataDirectory,
+        SamplePluginRuntimeStateService stateService,
+        IPluginMessageBus messageBus)
+    {
+        _clockStateFilePath = Path.Combine(dataDirectory, "clock-service.txt");
+        _stateService = stateService;
+        _messageBus = messageBus;
+        _timer = new Timer(OnTimerTick);
+    }
+
+    public DateTimeOffset CurrentTime
+    {
+        get
+        {
+            lock (_gate)
+            {
+                return _currentTime;
+            }
+        }
+    }
+
+    public void Start()
+    {
+        PublishTick();
+        _timer.Change(TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(1));
+    }
+
+    public void Dispose()
+    {
+        if (Interlocked.Exchange(ref _disposed, 1) != 0)
+        {
+            return;
+        }
+
+        _timer.Dispose();
+    }
+
+    private void OnTimerTick(object? state)
+    {
+        PublishTick();
+    }
+
+    private void PublishTick()
+    {
+        if (Volatile.Read(ref _disposed) != 0)
+        {
+            return;
+        }
+
+        var now = DateTimeOffset.Now;
+        lock (_gate)
+        {
+            _currentTime = now;
+        }
+
+        try
+        {
+            File.WriteAllText(
+                _clockStateFilePath,
+                now.ToString("O", CultureInfo.InvariantCulture));
+            _stateService.MarkClockServiceTick(now);
+            _messageBus.Publish(new SamplePluginClockTickMessage(now));
+        }
+        catch (Exception ex)
+        {
+            _stateService.MarkClockServiceFaulted($"Clock state write failed: {ex.Message}");
+        }
+    }
+}

LanMountainDesktop.SamplePlugin/SamplePluginSettingsView.cs

@@ -0,0 +1,339 @@
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Layout;
+using Avalonia.Media;
+using Avalonia.Threading;
+using LanMountainDesktop.PluginSdk;
+
+namespace LanMountainDesktop.SamplePlugin;
+
+internal sealed class SamplePluginSettingsView : UserControl
+{
+    private readonly IPluginContext _context;
+    private readonly SamplePluginRuntimeStateService _stateService;
+    private readonly SamplePluginClockService _clockService;
+    private readonly IPluginMessageBus _messageBus;
+    private readonly StackPanel _pluginInfoPanel = new() { Spacing = 8 };
+    private readonly StackPanel _capabilityPanel = new() { Spacing = 8 };
+    private readonly StackPanel _statusPanel = new() { Spacing = 10 };
+    private readonly List<IDisposable> _subscriptions = [];
+
+    public SamplePluginSettingsView(IPluginContext context)
+    {
+        _context = context;
+        _stateService = context.GetService<SamplePluginRuntimeStateService>()
+            ?? throw new InvalidOperationException("SamplePluginRuntimeStateService is not available.");
+        _clockService = context.GetService<SamplePluginClockService>()
+            ?? throw new InvalidOperationException("SamplePluginClockService is not available.");
+        _messageBus = context.GetService<IPluginMessageBus>()
+            ?? throw new InvalidOperationException("IPluginMessageBus is not available.");
+
+        _stateService.MarkFrontendReady("Settings page is connected to plugin services and communication.");
+
+        AttachedToVisualTree += OnAttachedToVisualTree;
+        DetachedFromVisualTree += OnDetachedFromVisualTree;
+
+        Content = new Border
+        {
+            Background = new LinearGradientBrush
+            {
+                StartPoint = new RelativePoint(0, 0, RelativeUnit.Relative),
+                EndPoint = new RelativePoint(1, 1, RelativeUnit.Relative),
+                GradientStops =
+                [
+                    new GradientStop(Color.Parse("#1F0B1120"), 0),
+                    new GradientStop(Color.Parse("#260C4A6E"), 1)
+                ]
+            },
+            BorderBrush = new SolidColorBrush(Color.Parse("#6628B2FF")),
+            BorderThickness = new Thickness(1),
+            CornerRadius = new CornerRadius(18),
+            Padding = new Thickness(18),
+            Child = new StackPanel
+            {
+                Spacing = 14,
+                Children =
+                {
+                    new TextBlock
+                    {
+                        Text = "Sample Plugin Capability Inspector",
+                        FontSize = 22,
+                        FontWeight = FontWeight.SemiBold,
+                        Foreground = Brushes.White
+                    },
+                    CreateSection("Plugin Info", _pluginInfoPanel),
+                    CreateSection("Accessible Capabilities", _capabilityPanel),
+                    CreateSection("Live Runtime Status", _statusPanel)
+                }
+            }
+        };
+
+        RefreshView();
+    }
+
+    private void OnAttachedToVisualTree(object? sender, VisualTreeAttachmentEventArgs e)
+    {
+        SubscribeToPluginBus();
+        RefreshView();
+    }
+
+    private void OnDetachedFromVisualTree(object? sender, VisualTreeAttachmentEventArgs e)
+    {
+        foreach (var subscription in _subscriptions)
+        {
+            subscription.Dispose();
+        }
+
+        _subscriptions.Clear();
+    }
+
+    private void SubscribeToPluginBus()
+    {
+        if (_subscriptions.Count > 0)
+        {
+            return;
+        }
+
+        _subscriptions.Add(_messageBus.Subscribe<SamplePluginClockTickMessage>(_ =>
+            Dispatcher.UIThread.Post(RefreshView)));
+
+        _subscriptions.Add(_messageBus.Subscribe<SamplePluginStateChangedMessage>(_ =>
+            Dispatcher.UIThread.Post(RefreshView)));
+    }
+
+    private void RefreshView()
+    {
+        var snapshot = _stateService.GetSnapshot();
+        RefreshPluginInfo(snapshot);
+        RefreshCapabilities();
+        RefreshStatuses(snapshot);
+    }
+
+    private void RefreshPluginInfo(SamplePluginRuntimeSnapshot snapshot)
+    {
+        _pluginInfoPanel.Children.Clear();
+        _pluginInfoPanel.Children.Add(CreateInfoLine("Plugin Name", snapshot.Manifest.Name));
+        _pluginInfoPanel.Children.Add(CreateInfoLine("Plugin Id", snapshot.Manifest.Id));
+        _pluginInfoPanel.Children.Add(CreateInfoLine("Version", snapshot.Manifest.Version ?? "dev"));
+        _pluginInfoPanel.Children.Add(CreateInfoLine("Author", snapshot.Manifest.Author ?? "(none)"));
+        _pluginInfoPanel.Children.Add(CreateInfoLine("Description", snapshot.Manifest.Description ?? "(none)"));
+        _pluginInfoPanel.Children.Add(CreateInfoLine("Plugin Directory", snapshot.PluginDirectory));
+        _pluginInfoPanel.Children.Add(CreateInfoLine("Data Directory", snapshot.DataDirectory));
+        _pluginInfoPanel.Children.Add(CreateInfoLine("Host Application", snapshot.HostApplicationName));
+        _pluginInfoPanel.Children.Add(CreateInfoLine("Host Version", snapshot.HostVersion));
+        _pluginInfoPanel.Children.Add(CreateInfoLine("SDK API Version", snapshot.SdkApiVersion));
+        _pluginInfoPanel.Children.Add(CreateInfoLine("State Service Resolved", (_context.GetService<SamplePluginRuntimeStateService>() is not null).ToString()));
+        _pluginInfoPanel.Children.Add(CreateInfoLine("Clock Service Resolved", (_context.GetService<SamplePluginClockService>() is not null).ToString()));
+        _pluginInfoPanel.Children.Add(CreateInfoLine("Message Bus Resolved", (_context.GetService<IPluginMessageBus>() is not null).ToString()));
+        _pluginInfoPanel.Children.Add(CreateInfoLine("Component Placed", snapshot.HasPlacedComponent ? "Yes" : "No"));
+        _pluginInfoPanel.Children.Add(CreateInfoLine("Placed Count", snapshot.PlacedCount.ToString()));
+        _pluginInfoPanel.Children.Add(CreateInfoLine("Preview Count", snapshot.PreviewCount.ToString()));
+        _pluginInfoPanel.Children.Add(CreateInfoLine(
+            "Placement Ids",
+            snapshot.PlacementIds.Count == 0 ? "(none)" : string.Join(", ", snapshot.PlacementIds)));
+        _pluginInfoPanel.Children.Add(CreateInfoLine("Last Component Id", snapshot.LastComponentId ?? "(none)"));
+        _pluginInfoPanel.Children.Add(CreateInfoLine(
+            "Last Cell Size",
+            snapshot.LastCellSize > 0 ? $"{snapshot.LastCellSize:F0}px" : "(unknown)"));
+        _pluginInfoPanel.Children.Add(CreateInfoLine(
+            "Clock Service Time",
+            _clockService.CurrentTime.LocalDateTime.ToString("HH:mm:ss")));
+    }
+
+    private void RefreshCapabilities()
+    {
+        var capabilities = _stateService.GetCapabilities(
+            _context,
+            _context.GetService<SamplePluginRuntimeStateService>() is not null,
+            _context.GetService<SamplePluginClockService>() is not null,
+            _context.GetService<IPluginMessageBus>() is not null);
+
+        _capabilityPanel.Children.Clear();
+        foreach (var capability in capabilities)
+        {
+            _capabilityPanel.Children.Add(CreateCapabilityCard(capability));
+        }
+    }
+
+    private void RefreshStatuses(SamplePluginRuntimeSnapshot snapshot)
+    {
+        _statusPanel.Children.Clear();
+
+        foreach (var entry in snapshot.StatusEntries)
+        {
+            var palette = GetPalette(entry.State);
+            _statusPanel.Children.Add(new Border
+            {
+                Background = new SolidColorBrush(palette.Background),
+                BorderBrush = new SolidColorBrush(palette.Border),
+                BorderThickness = new Thickness(1),
+                CornerRadius = new CornerRadius(12),
+                Padding = new Thickness(12, 10),
+                Child = new StackPanel
+                {
+                    Spacing = 4,
+                    Children =
+                    {
+                        CreateStatusHeader(entry, palette),
+                        new TextBlock
+                        {
+                            Text = entry.Detail,
+                            Foreground = new SolidColorBrush(Color.Parse("#FFE0F2FE")),
+                            TextWrapping = TextWrapping.Wrap
+                        },
+                        new TextBlock
+                        {
+                            Text = $"Updated: {entry.UpdatedAt.LocalDateTime:HH:mm:ss}",
+                            Foreground = new SolidColorBrush(Color.Parse("#FF93C5FD"))
+                        }
+                    }
+                }
+            });
+        }
+    }
+
+    private Border CreateSection(string title, Control content)
+    {
+        return new Border
+        {
+            Background = new SolidColorBrush(Color.Parse("#14000000")),
+            BorderBrush = new SolidColorBrush(Color.Parse("#3328B2FF")),
+            BorderThickness = new Thickness(1),
+            CornerRadius = new CornerRadius(14),
+            Padding = new Thickness(14),
+            Child = new StackPanel
+            {
+                Spacing = 12,
+                Children =
+                {
+                    new TextBlock
+                    {
+                        Text = title,
+                        FontSize = 16,
+                        FontWeight = FontWeight.SemiBold,
+                        Foreground = Brushes.White
+                    },
+                    content
+                }
+            }
+        };
+    }
+
+    private Control CreateInfoLine(string label, string value)
+    {
+        var grid = new Grid
+        {
+            ColumnDefinitions = new ColumnDefinitions("180,*"),
+            ColumnSpacing = 10
+        };
+
+        var labelText = new TextBlock
+        {
+            Text = label,
+            Foreground = new SolidColorBrush(Color.Parse("#FFBAE6FD")),
+            FontWeight = FontWeight.SemiBold,
+            TextWrapping = TextWrapping.Wrap
+        };
+        var valueText = new TextBlock
+        {
+            Text = value,
+            Foreground = Brushes.White,
+            TextWrapping = TextWrapping.Wrap
+        };
+
+        grid.Children.Add(labelText);
+        grid.Children.Add(valueText);
+        Grid.SetColumn(valueText, 1);
+        return grid;
+    }
+
+    private Control CreateCapabilityCard(SamplePluginCapabilityItem item)
+    {
+        return new Border
+        {
+            Background = new SolidColorBrush(Color.Parse("#0F082F49")),
+            BorderBrush = new SolidColorBrush(Color.Parse("#3338BDF8")),
+            BorderThickness = new Thickness(1),
+            CornerRadius = new CornerRadius(12),
+            Padding = new Thickness(12, 10),
+            Child = new StackPanel
+            {
+                Spacing = 4,
+                Children =
+                {
+                    new TextBlock
+                    {
+                        Text = item.Title,
+                        Foreground = Brushes.White,
+                        FontWeight = FontWeight.SemiBold
+                    },
+                    new TextBlock
+                    {
+                        Text = item.Detail,
+                        Foreground = new SolidColorBrush(Color.Parse("#FFE0F2FE")),
+                        TextWrapping = TextWrapping.Wrap
+                    }
+                }
+            }
+        };
+    }
+
+    private static Control CreateStatusHeader(
+        SamplePluginStatusEntry entry,
+        (Color Background, Color Border, Color Dot) palette)
+    {
+        var grid = new Grid
+        {
+            ColumnDefinitions = new ColumnDefinitions("Auto,*,Auto"),
+            ColumnSpacing = 8
+        };
+
+        var dot = new Border
+        {
+            Width = 10,
+            Height = 10,
+            CornerRadius = new CornerRadius(999),
+            Background = new SolidColorBrush(palette.Dot),
+            VerticalAlignment = VerticalAlignment.Center
+        };
+        var title = new TextBlock
+        {
+            Text = entry.Title,
+            FontSize = 15,
+            FontWeight = FontWeight.SemiBold,
+            Foreground = Brushes.White
+        };
+        var summary = new TextBlock
+        {
+            Text = entry.Summary,
+            Foreground = new SolidColorBrush(Color.Parse("#FFD7F2FF")),
+            HorizontalAlignment = HorizontalAlignment.Right
+        };
+
+        grid.Children.Add(dot);
+        grid.Children.Add(title);
+        grid.Children.Add(summary);
+        Grid.SetColumn(title, 1);
+        Grid.SetColumn(summary, 2);
+        return grid;
+    }
+
+    private static (Color Background, Color Border, Color Dot) GetPalette(SamplePluginHealthState state)
+    {
+        return state switch
+        {
+            SamplePluginHealthState.Healthy => (
+                Color.Parse("#1F115E59"),
+                Color.Parse("#665EEAD4"),
+                Color.Parse("#5EEAD4")),
+            SamplePluginHealthState.Faulted => (
+                Color.Parse("#291B1B"),
+                Color.Parse("#66F87171"),
+                Color.Parse("#F87171")),
+            _ => (
+                Color.Parse("#2B3A2A0D"),
+                Color.Parse("#66FBBF24"),
+                Color.Parse("#FBBF24"))
+        };
+    }
+}

LanMountainDesktop.SamplePlugin/SamplePluginStatusClockWidget.cs

@@ -0,0 +1,284 @@
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Layout;
+using Avalonia.Media;
+using Avalonia.Threading;
+using LanMountainDesktop.PluginSdk;
+
+namespace LanMountainDesktop.SamplePlugin;
+
+internal sealed class SamplePluginStatusClockWidget : Border
+{
+    private readonly PluginDesktopComponentContext _context;
+    private readonly SamplePluginRuntimeStateService _stateService;
+    private readonly SamplePluginClockService _clockService;
+    private readonly IPluginMessageBus _messageBus;
+    private readonly TextBlock _timeTextBlock;
+    private readonly TextBlock _subtitleTextBlock;
+    private readonly StackPanel _statusPanel;
+    private readonly Border _statusHost;
+    private readonly List<IDisposable> _subscriptions = [];
+    private string? _instanceId;
+
+    public SamplePluginStatusClockWidget(PluginDesktopComponentContext context)
+    {
+        _context = context;
+        _stateService = context.GetService<SamplePluginRuntimeStateService>()
+            ?? throw new InvalidOperationException("SamplePluginRuntimeStateService is not available.");
+        _clockService = context.GetService<SamplePluginClockService>()
+            ?? throw new InvalidOperationException("SamplePluginClockService is not available.");
+        _messageBus = context.GetService<IPluginMessageBus>()
+            ?? throw new InvalidOperationException("IPluginMessageBus is not available.");
+
+        _timeTextBlock = new TextBlock
+        {
+            Foreground = Brushes.White,
+            FontWeight = FontWeight.Bold,
+            HorizontalAlignment = HorizontalAlignment.Left
+        };
+        _subtitleTextBlock = new TextBlock
+        {
+            Foreground = new SolidColorBrush(Color.Parse("#FFBFE9FF")),
+            HorizontalAlignment = HorizontalAlignment.Left,
+            TextWrapping = TextWrapping.Wrap
+        };
+        _statusPanel = new StackPanel
+        {
+            Spacing = 8
+        };
+        _statusHost = new Border
+        {
+            Background = new SolidColorBrush(Color.Parse("#1F082F49")),
+            BorderBrush = new SolidColorBrush(Color.Parse("#5538BDF8")),
+            BorderThickness = new Thickness(1),
+            Child = _statusPanel
+        };
+
+        Background = new LinearGradientBrush
+        {
+            StartPoint = new RelativePoint(0, 0, RelativeUnit.Relative),
+            EndPoint = new RelativePoint(1, 1, RelativeUnit.Relative),
+            GradientStops =
+            [
+                new GradientStop(Color.Parse("#FF07111F"), 0),
+                new GradientStop(Color.Parse("#FF0C4A6E"), 0.55),
+                new GradientStop(Color.Parse("#FF0EA5E9"), 1)
+            ]
+        };
+        BorderBrush = new SolidColorBrush(Color.Parse("#6648C7FF"));
+        BorderThickness = new Thickness(1);
+        HorizontalAlignment = HorizontalAlignment.Stretch;
+        VerticalAlignment = VerticalAlignment.Stretch;
+        Child = new Grid
+        {
+            RowDefinitions = new RowDefinitions("Auto,*"),
+            RowSpacing = 14,
+            Children =
+            {
+                new StackPanel
+                {
+                    Spacing = 4,
+                    HorizontalAlignment = HorizontalAlignment.Left,
+                    Children =
+                    {
+                        _timeTextBlock,
+                        _subtitleTextBlock
+                    }
+                },
+                _statusHost
+            }
+        };
+
+        Grid.SetRow(((Grid)Child).Children[1], 1);
+
+        AttachedToVisualTree += OnAttachedToVisualTree;
+        DetachedFromVisualTree += OnDetachedFromVisualTree;
+        SizeChanged += OnSizeChanged;
+
+        RefreshClock(_clockService.CurrentTime);
+        UpdateSubtitle();
+        RefreshStatusPanel();
+        ApplyScale();
+    }
+
+    private void OnAttachedToVisualTree(object? sender, VisualTreeAttachmentEventArgs e)
+    {
+        if (string.IsNullOrWhiteSpace(_instanceId))
+        {
+            _instanceId = _stateService.RegisterComponentInstance(
+                _context.ComponentId,
+                _context.PlacementId,
+                _context.CellSize);
+        }
+
+        _stateService.MarkFrontendReady("Widget surface is connected to plugin services and communication.");
+        SubscribeToPluginBus();
+
+        RefreshClock(_clockService.CurrentTime);
+        UpdateSubtitle();
+        RefreshStatusPanel();
+    }
+
+    private void OnDetachedFromVisualTree(object? sender, VisualTreeAttachmentEventArgs e)
+    {
+        foreach (var subscription in _subscriptions)
+        {
+            subscription.Dispose();
+        }
+
+        _subscriptions.Clear();
+
+        if (string.IsNullOrWhiteSpace(_instanceId))
+        {
+            return;
+        }
+
+        _stateService.UnregisterComponentInstance(_instanceId);
+        _instanceId = null;
+    }
+
+    private void OnSizeChanged(object? sender, SizeChangedEventArgs e)
+    {
+        ApplyScale();
+        RefreshStatusPanel();
+    }
+
+    private void SubscribeToPluginBus()
+    {
+        if (_subscriptions.Count > 0)
+        {
+            return;
+        }
+
+        _subscriptions.Add(_messageBus.Subscribe<SamplePluginClockTickMessage>(message =>
+            Dispatcher.UIThread.Post(() => RefreshClock(message.CurrentTime))));
+
+        _subscriptions.Add(_messageBus.Subscribe<SamplePluginStateChangedMessage>(_ =>
+            Dispatcher.UIThread.Post(() =>
+            {
+                UpdateSubtitle();
+                RefreshStatusPanel();
+            })));
+    }
+
+    private void RefreshClock(DateTimeOffset currentTime)
+    {
+        _timeTextBlock.Text = currentTime.LocalDateTime.ToString("HH:mm:ss");
+    }
+
+    private void UpdateSubtitle()
+    {
+        var snapshot = _stateService.GetSnapshot();
+        _subtitleTextBlock.Text = string.IsNullOrWhiteSpace(_context.PlacementId)
+            ? $"Preview surface | placed: {snapshot.PlacedCount}"
+            : $"Placement {_context.PlacementId} | placed: {snapshot.PlacedCount}";
+    }
+
+    private void RefreshStatusPanel()
+    {
+        _statusPanel.Children.Clear();
+
+        var snapshot = _stateService.GetSnapshot();
+        var basis = GetLayoutBasis();
+        var titleSize = Math.Clamp(basis * 0.068, 11, 16);
+        var detailSize = Math.Clamp(basis * 0.052, 9, 13);
+
+        foreach (var entry in snapshot.StatusEntries)
+        {
+            var palette = GetPalette(entry.State);
+            _statusPanel.Children.Add(new Border
+            {
+                Background = new SolidColorBrush(palette.Background),
+                BorderBrush = new SolidColorBrush(palette.Border),
+                BorderThickness = new Thickness(1),
+                CornerRadius = new CornerRadius(12),
+                Padding = new Thickness(10, 8),
+                Child = new Grid
+                {
+                    RowDefinitions = new RowDefinitions("Auto,Auto"),
+                    ColumnDefinitions = new ColumnDefinitions("Auto,*,Auto"),
+                    ColumnSpacing = 8,
+                    Children =
+                    {
+                        new Border
+                        {
+                            Width = Math.Clamp(basis * 0.038, 8, 11),
+                            Height = Math.Clamp(basis * 0.038, 8, 11),
+                            CornerRadius = new CornerRadius(999),
+                            Background = new SolidColorBrush(palette.Dot),
+                            VerticalAlignment = VerticalAlignment.Center
+                        },
+                        new TextBlock
+                        {
+                            Text = entry.Title,
+                            FontSize = titleSize,
+                            FontWeight = FontWeight.SemiBold,
+                            Foreground = Brushes.White,
+                            TextWrapping = TextWrapping.Wrap
+                        },
+                        new TextBlock
+                        {
+                            Text = entry.Summary,
+                            FontSize = detailSize,
+                            Foreground = new SolidColorBrush(Color.Parse("#FFD7F2FF")),
+                            HorizontalAlignment = HorizontalAlignment.Right,
+                            TextAlignment = TextAlignment.Right,
+                            VerticalAlignment = VerticalAlignment.Center
+                        },
+                        new TextBlock
+                        {
+                            Text = entry.Detail,
+                            FontSize = detailSize,
+                            Foreground = new SolidColorBrush(Color.Parse("#FFD7F2FF")),
+                            TextWrapping = TextWrapping.Wrap
+                        }
+                    }
+                }
+            });
+
+            var row = (Grid)((Border)_statusPanel.Children[^1]).Child!;
+            Grid.SetColumn(row.Children[1], 1);
+            Grid.SetColumn(row.Children[2], 2);
+            Grid.SetColumnSpan(row.Children[3], 3);
+            Grid.SetRow(row.Children[3], 1);
+        }
+    }
+
+    private void ApplyScale()
+    {
+        var basis = GetLayoutBasis();
+        Padding = new Thickness(Math.Clamp(basis * 0.09, 16, 26));
+        CornerRadius = new CornerRadius(Math.Clamp(basis * 0.14, 20, 34));
+        _timeTextBlock.FontSize = Math.Clamp(basis * 0.22, 30, 58);
+        _subtitleTextBlock.FontSize = Math.Clamp(basis * 0.062, 11, 17);
+        _statusHost.Padding = new Thickness(Math.Clamp(basis * 0.045, 10, 18));
+        _statusHost.CornerRadius = new CornerRadius(Math.Clamp(basis * 0.09, 14, 22));
+        _statusPanel.Spacing = Math.Clamp(basis * 0.024, 6, 10);
+    }
+
+    private double GetLayoutBasis()
+    {
+        var width = Bounds.Width > 1 ? Bounds.Width : _context.CellSize * 4;
+        var height = Bounds.Height > 1 ? Bounds.Height : _context.CellSize * 4;
+        return Math.Max(_context.CellSize * 4, Math.Min(width, height));
+    }
+
+    private static (Color Background, Color Border, Color Dot) GetPalette(SamplePluginHealthState state)
+    {
+        return state switch
+        {
+            SamplePluginHealthState.Healthy => (
+                Color.Parse("#1F0F766E"),
+                Color.Parse("#4D5EEAD4"),
+                Color.Parse("#5EEAD4")),
+            SamplePluginHealthState.Faulted => (
+                Color.Parse("#29B91C1C"),
+                Color.Parse("#66F87171"),
+                Color.Parse("#F87171")),
+            _ => (
+                Color.Parse("#1F7C2D12"),
+                Color.Parse("#66FDBA74"),
+                Color.Parse("#FDBA74"))
+        };
+    }
+}

LanMountainDesktop.SamplePlugin/plugin.json

@@ -0,0 +1,9 @@
+{
+  "id": "LanMountainDesktop.SamplePlugin",
+  "name": "LanMountain Sample Plugin",
+  "description": "Example plugin used to validate PluginSdk loading and isolation.",
+  "author": "LanMountainDesktop",
+  "version": "1.0.0",
+  "apiVersion": "1.0.0",
+  "entranceAssembly": "LanMountainDesktop.SamplePlugin.dll"
+}

LanMountainDesktop.sln

@@ -5,6 +5,10 @@ VisualStudioVersion = 17.0.31903.59
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "LanMountainDesktop", "LanMountainDesktop\LanMountainDesktop.csproj", "{00000001-0000-0000-0000-000000000001}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "LanMountainDesktop.SamplePlugin", "LanMountainDesktop.SamplePlugin\LanMountainDesktop.SamplePlugin.csproj", "{BDCD028D-DB6E-4BD5-994A-65889DBDEE0C}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "LanMountainDesktop.PluginSdk", "LanMountainDesktop.PluginSdk\LanMountainDesktop.PluginSdk.csproj", "{30A0F689-AACC-48C8-8BFE-BC7BFBA6CC55}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -15,5 +19,13 @@ Global
 		{00000001-0000-0000-0000-000000000001}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{00000001-0000-0000-0000-000000000001}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{00000001-0000-0000-0000-000000000001}.Release|Any CPU.Build.0 = Release|Any CPU
+		{BDCD028D-DB6E-4BD5-994A-65889DBDEE0C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{BDCD028D-DB6E-4BD5-994A-65889DBDEE0C}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{BDCD028D-DB6E-4BD5-994A-65889DBDEE0C}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{BDCD028D-DB6E-4BD5-994A-65889DBDEE0C}.Release|Any CPU.Build.0 = Release|Any CPU
+		{30A0F689-AACC-48C8-8BFE-BC7BFBA6CC55}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{30A0F689-AACC-48C8-8BFE-BC7BFBA6CC55}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{30A0F689-AACC-48C8-8BFE-BC7BFBA6CC55}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{30A0F689-AACC-48C8-8BFE-BC7BFBA6CC55}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 EndGlobal

LanMountainDesktop/App.axaml

@@ -22,6 +22,8 @@
                       ToolTipText="LanMountainDesktop">
                 <TrayIcon.Menu>
                     <NativeMenu>
+                        <NativeMenuItem Header="设置" Click="OnTraySettingsClick" />
+                        <NativeMenuItemSeparator />
                         <NativeMenuItem Header="重启应用" Click="OnTrayRestartClick" />
                         <NativeMenuItemSeparator />
                         <NativeMenuItem Header="退出应用" Click="OnTrayExitClick" />

LanMountainDesktop/App.axaml.cs

@@ -6,6 +6,7 @@ using System;
 using System.Diagnostics;
 using System.Linq;
 using Avalonia.Markup.Xaml;
+using Avalonia.Threading;
 using LanMountainDesktop.Services;
 using LanMountainDesktop.ViewModels;
 using LanMountainDesktop.Views;
@@ -15,6 +16,11 @@ namespace LanMountainDesktop;
 
 public partial class App : Application
 {
+    private SettingsWindow? _traySettingsWindow;
+    private PluginRuntimeService? _pluginRuntimeService;
+
+    public PluginRuntimeService? PluginRuntimeService => _pluginRuntimeService;
+
     public override void Initialize()
     {
         ConfigureWebViewUserDataFolder();
@@ -25,12 +31,14 @@ public partial class App : Application
     public override void OnFrameworkInitializationCompleted()
     {
         LinuxDesktopEntryInstaller.EnsureInstalled();
+        InitializePluginRuntime();
 
         if (ApplicationLifetime is IClassicDesktopStyleApplicationLifetime desktop)
         {
             // Avoid duplicate validations from both Avalonia and the CommunityToolkit. 
             // More info: https://docs.avaloniaui.net/docs/guides/development-guides/data-validation#manage-validationplugins
             DisableAvaloniaDataAnnotationValidation();
+            desktop.ShutdownMode = Avalonia.Controls.ShutdownMode.OnExplicitShutdown;
             desktop.MainWindow = new MainWindow
             {
                 DataContext = new MainWindowViewModel(),
@@ -48,6 +56,44 @@ public partial class App : Application
         }
     }
 
+    private void OnTraySettingsClick(object? sender, EventArgs e)
+    {
+        if (ApplicationLifetime is not IClassicDesktopStyleApplicationLifetime)
+        {
+            return;
+        }
+
+        Dispatcher.UIThread.Post(() =>
+        {
+            try
+            {
+                if (_traySettingsWindow is { } existingWindow && existingWindow.IsVisible)
+                {
+                    existingWindow.WindowState = Avalonia.Controls.WindowState.Normal;
+                    existingWindow.Activate();
+                    return;
+                }
+
+                var settingsWindow = new SettingsWindow();
+                settingsWindow.Closed += (_, _) =>
+                {
+                    if (ReferenceEquals(_traySettingsWindow, settingsWindow))
+                    {
+                        _traySettingsWindow = null;
+                    }
+                };
+
+                _traySettingsWindow = settingsWindow;
+                settingsWindow.Show();
+                settingsWindow.Activate();
+            }
+            catch (Exception ex)
+            {
+                Debug.WriteLine($"[TraySettings] Failed to open settings window: {ex}");
+            }
+        }, DispatcherPriority.Normal);
+    }
+
     private void OnTrayRestartClick(object? sender, EventArgs e)
     {
         if (ApplicationLifetime is not IClassicDesktopStyleApplicationLifetime desktop)
@@ -130,4 +176,18 @@ public partial class App : Application
             // Keep startup resilient if user profile folders are unavailable.
         }
     }
+
+    private void InitializePluginRuntime()
+    {
+        try
+        {
+            _pluginRuntimeService?.Dispose();
+            _pluginRuntimeService = new PluginRuntimeService();
+            _pluginRuntimeService.LoadInstalledPlugins();
+        }
+        catch (Exception ex)
+        {
+            Debug.WriteLine($"[PluginRuntime] Failed to initialize plugin runtime: {ex}");
+        }
+    }
 }

LanMountainDesktop/ComponentSystem/ComponentRegistry.cs

@@ -385,6 +385,13 @@ public sealed class ComponentRegistry
         return new ComponentRegistry(merged);
     }
 
+    public ComponentRegistry RegisterComponents(IEnumerable<DesktopComponentDefinition> definitions)
+    {
+        var merged = _definitions.Values.ToList();
+        merged.AddRange(definitions);
+        return new ComponentRegistry(merged);
+    }
+
     public bool TryGetDefinition(string componentId, out DesktopComponentDefinition definition)
     {
         return _definitions.TryGetValue(componentId, out definition!);

LanMountainDesktop/ComponentSystem/DesktopComponentRuntimeContext.cs

@@ -0,0 +1,8 @@
+using LanMountainDesktop.Services;
+
+namespace LanMountainDesktop.ComponentSystem;
+
+public sealed record DesktopComponentRuntimeContext(
+    string ComponentId,
+    string? PlacementId,
+    IComponentInstanceSettingsStore ComponentSettingsStore);

LanMountainDesktop/ComponentSystem/IComponentPlacementContextAware.cs

@@ -0,0 +1,6 @@
+namespace LanMountainDesktop.ComponentSystem;
+
+public interface IComponentPlacementContextAware
+{
+    void SetComponentPlacementContext(string componentId, string? placementId);
+}

LanMountainDesktop/ComponentSystem/IComponentRuntimeContextAware.cs

@@ -0,0 +1,6 @@
+namespace LanMountainDesktop.ComponentSystem;
+
+public interface IComponentRuntimeContextAware
+{
+    void SetComponentRuntimeContext(DesktopComponentRuntimeContext context);
+}

LanMountainDesktop/ComponentSystem/IComponentSettingsStoreAware.cs

@@ -0,0 +1,8 @@
+using LanMountainDesktop.Services;
+
+namespace LanMountainDesktop.ComponentSystem;
+
+public interface IComponentSettingsStoreAware
+{
+    void SetComponentSettingsStore(IComponentInstanceSettingsStore settingsStore);
+}

LanMountainDesktop/LanMountainDesktop.csproj

@@ -24,6 +24,10 @@
     <None Include="Extensions\Components\*.json" CopyToOutputDirectory="PreserveNewest" />
   </ItemGroup>
 
+  <ItemGroup>
+    <ProjectReference Include="..\LanMountainDesktop.PluginSdk\LanMountainDesktop.PluginSdk.csproj" />
+  </ItemGroup>
+
   <ItemGroup>
     <PackageReference Include="Avalonia" Version="11.3.12" />
     <PackageReference Include="Avalonia.Desktop" Version="11.3.12" />

LanMountainDesktop/Localization/en-US.json

@@ -237,6 +237,13 @@
     "settings.about.startup_header":  "Windows Startup",
     "settings.about.startup_desc":  "Launch the app automatically when signing in to Windows.",
     "settings.about.startup_toggle":  "Launch at Windows sign-in",
+    "settings.about.render_mode_header":  "App Rendering Mode",
+    "settings.about.render_mode_desc":  "Choose the rendering backend. Restart the app after changing this option. Unsupported modes fall back to software.",
+    "settings.about.render_mode.default":  "Default",
+    "settings.about.render_mode.software":  "Software",
+    "settings.about.render_mode.angle_egl":  "angleEgl",
+    "settings.about.render_mode.wgl":  "WGL",
+    "settings.about.render_mode.vulkan":  "Vulkan",
     "settings.footer":  "LanMountainDesktop Settings",
     "filepicker.title":  "Select wallpaper",
     "filepicker.image_files":  "Image files",
@@ -268,9 +275,30 @@
     "settings.launcher.restore_button":  "Show Again",
     "settings.plugins.title":  "Plugins",
     "settings.plugins.runtime_header":  "Plugin Runtime",
-    "settings.plugins.runtime_desc":  "Manage plugin loading and backend isolation.",
-    "settings.plugins.runtime_hint":  "This page will host installed plugin management, permission review, and sandboxed backend runtime controls.",
-    "settings.plugins.runtime_status":  "Plugin management UI is not connected yet. Next step is wiring the loader, permissions, and worker isolation state into this panel.",
+    "settings.plugins.runtime_desc":  "Review plugin runtime state and load results.",
+    "settings.plugins.runtime_hint":  "This page shows discovery status, load results, and runtime diagnostics for installed plugins.",
+    "settings.plugins.runtime_status":  "Plugin runtime status will appear here after plugin discovery completes.",
+    "settings.plugins.installed_header":  "Installed Plugins",
+    "settings.plugins.installed_desc":  "Enable or disable plugins here. Detailed plugin settings appear as separate settings pages.",
+    "settings.plugins.restart_hint":  "Plugin enable state changes take effect after restarting the app.",
+    "settings.plugins.empty":  "No plugins found.",
+    "settings.plugins.runtime_unavailable":  "Plugin runtime is not available.",
+    "settings.plugins.summary_format":  "Detected {0} plugin(s); enabled {1}; loaded {2}; settings pages {3}; widgets {4}; failures {5}.",
+    "settings.plugins.summary_item_format":  "{0}  v{1}  |  {2}",
+    "settings.plugins.state.enabled":  "Enabled",
+    "settings.plugins.state.enabled_failed":  "Enabled / failed to load",
+    "settings.plugins.state.disabled":  "Disabled",
+    "settings.plugins.state.loaded":  "Loaded",
+    "settings.plugins.state.load_failed":  "Load failed",
+    "settings.plugins.toggle_on":  "Enabled",
+    "settings.plugins.toggle_off":  "Disabled",
+    "settings.plugins.toggle_result_format":  "Plugin '{0}' was {1} for the next launch. Restart the app to apply page and widget changes.",
+    "settings.plugins.toggle_state_enabled":  "enabled",
+    "settings.plugins.toggle_state_disabled":  "disabled",
+    "settings.plugins.source_package":  ".laapp package",
+    "settings.plugins.source_manifest":  "Loose manifest",
+    "settings.plugins.subtitle_format":  "{0} | {1} | {2}",
+    "settings.plugins.detail_format":  "Settings pages: {0} | Widgets: {1}",
     "button.component_library":  "Edit Desktop",
     "tooltip.component_library":  "Edit Desktop",
     "component_library.title":  "Widgets",
@@ -617,3 +645,5 @@
     "placement.center":  "Center",
     "placement.tile":  "Tile"
 }
+
+

LanMountainDesktop/Localization/zh-CN.json

@@ -237,6 +237,13 @@
     "settings.about.startup_header":  "Windows 自启动",
     "settings.about.startup_desc":  "在登录 Windows 时自动启动应用。",
     "settings.about.startup_toggle":  "登录 Windows 时启动",
+    "settings.about.render_mode_header":  "应用渲染模式",
+    "settings.about.render_mode_desc":  "选择应用渲染后端。更改后需要重启应用生效。不支持的模式会回退到软件渲染。",
+    "settings.about.render_mode.default":  "默认",
+    "settings.about.render_mode.software":  "软件",
+    "settings.about.render_mode.angle_egl":  "angleEgl",
+    "settings.about.render_mode.wgl":  "WGL",
+    "settings.about.render_mode.vulkan":  "Vulkan",
     "settings.footer":  "LanMountainDesktop 设置",
     "filepicker.title":  "选择壁纸",
     "filepicker.image_files":  "图片文件",
@@ -268,9 +275,30 @@
     "settings.launcher.restore_button":  "重新显示",
     "settings.plugins.title":  "插件",
     "settings.plugins.runtime_header":  "插件运行时",
-    "settings.plugins.runtime_desc":  "管理插件加载与后端隔离运行。",
-    "settings.plugins.runtime_hint":  "这里将承载已安装插件、权限审查和沙盒后端运行时控制。",
-    "settings.plugins.runtime_status":  "插件管理界面尚未接入实际数据。下一步是把加载器、权限和 worker 隔离状态接到这里。",
+    "settings.plugins.runtime_desc":  "查看插件运行时状态、加载结果与诊断信息。",
+    "settings.plugins.runtime_hint":  "这里展示已安装插件的发现结果、加载状态和运行时诊断信息。",
+    "settings.plugins.runtime_status":  "插件扫描完成后，运行时状态会显示在这里。",
+    "settings.plugins.installed_header":  "已安装插件",
+    "settings.plugins.installed_desc":  "在这里启用或禁用插件。插件自己的详细设置会作为独立设置页出现。",
+    "settings.plugins.restart_hint":  "插件启用状态变更会在重启应用后生效。",
+    "settings.plugins.empty":  "未找到插件。",
+    "settings.plugins.runtime_unavailable":  "插件运行时不可用。",
+    "settings.plugins.summary_format":  "共检测到 {0} 个插件；已启用 {1} 个；已加载 {2} 个；设置页 {3} 个；组件 {4} 个；失败 {5} 个。",
+    "settings.plugins.summary_item_format":  "{0}  v{1}  |  {2}",
+    "settings.plugins.state.enabled":  "已启用",
+    "settings.plugins.state.enabled_failed":  "已启用 / 加载失败",
+    "settings.plugins.state.disabled":  "已禁用",
+    "settings.plugins.state.loaded":  "已加载",
+    "settings.plugins.state.load_failed":  "加载失败",
+    "settings.plugins.toggle_on":  "启用",
+    "settings.plugins.toggle_off":  "禁用",
+    "settings.plugins.toggle_result_format":  "插件“{0}”已在下次启动时设为{1}。重启应用后，设置页和组件变更才会生效。",
+    "settings.plugins.toggle_state_enabled":  "启用",
+    "settings.plugins.toggle_state_disabled":  "禁用",
+    "settings.plugins.source_package":  ".laapp 包",
+    "settings.plugins.source_manifest":  "散装清单",
+    "settings.plugins.subtitle_format":  "{0} | {1} | {2}",
+    "settings.plugins.detail_format":  "设置页：{0} | 组件：{1}",
     "button.component_library":  "桌面编辑",
     "tooltip.component_library":  "桌面编辑",
     "component_library.title":  "桌面编辑",
@@ -617,3 +645,5 @@
     "placement.center":  "居中",
     "placement.tile":  "平铺"
 }
+
+

LanMountainDesktop/Models/AppSettingsSnapshot.cs

@@ -20,6 +20,8 @@ public sealed class AppSettingsSnapshot
 
     public int SettingsTabIndex { get; set; } = 0;
 
+    public string? SettingsTabTag { get; set; }
+
     public string LanguageCode { get; set; } = "zh-CN";
 
     public string? TimeZoneId { get; set; }
@@ -46,6 +48,8 @@ public sealed class AppSettingsSnapshot
 
     public bool AutoStartWithWindows { get; set; }
 
+    public string AppRenderMode { get; set; } = "Default";
+
     public bool AutoCheckUpdates { get; set; } = true;
 
     public bool IncludePrereleaseUpdates { get; set; }
@@ -70,15 +74,7 @@ public sealed class AppSettingsSnapshot
 
     public int StatusBarCustomSpacingPercent { get; set; } = 12;
 
-    public int DesktopPageCount { get; set; } = 1;
-
-    public int CurrentDesktopSurfaceIndex { get; set; } = 0;
-
-    public List<DesktopComponentPlacementSnapshot> DesktopComponentPlacements { get; set; } = [];
-
-    public List<string> HiddenLauncherFolderPaths { get; set; } = [];
-
-    public List<string> HiddenLauncherAppPaths { get; set; } = [];
+    public List<string> DisabledPluginIds { get; set; } = [];
 
     public AppSettingsSnapshot Clone()
     {
@@ -90,35 +86,8 @@ public sealed class AppSettingsSnapshot
         clone.PinnedTaskbarActions = PinnedTaskbarActions is { Count: > 0 }
             ? new List<string>(PinnedTaskbarActions)
             : [];
-
-        var placements = new List<DesktopComponentPlacementSnapshot>(DesktopComponentPlacements?.Count ?? 0);
-        if (DesktopComponentPlacements is not null)
-        {
-            foreach (var placement in DesktopComponentPlacements)
-            {
-                if (placement is null)
-                {
-                    continue;
-                }
-
-                placements.Add(new DesktopComponentPlacementSnapshot
-                {
-                    PlacementId = placement.PlacementId,
-                    PageIndex = placement.PageIndex,
-                    ComponentId = placement.ComponentId,
-                    Row = placement.Row,
-                    Column = placement.Column,
-                    WidthCells = placement.WidthCells,
-                    HeightCells = placement.HeightCells
-                });
-            }
-        }
-        clone.DesktopComponentPlacements = placements;
-        clone.HiddenLauncherFolderPaths = HiddenLauncherFolderPaths is { Count: > 0 }
-            ? new List<string>(HiddenLauncherFolderPaths)
-            : [];
-        clone.HiddenLauncherAppPaths = HiddenLauncherAppPaths is { Count: > 0 }
-            ? new List<string>(HiddenLauncherAppPaths)
+        clone.DisabledPluginIds = DisabledPluginIds is { Count: > 0 }
+            ? new List<string>(DisabledPluginIds)
             : [];
 
         return clone;

LanMountainDesktop/Models/DesktopLayoutSettingsSnapshot.cs

@@ -0,0 +1,43 @@
+using System.Collections.Generic;
+
+namespace LanMountainDesktop.Models;
+
+public sealed class DesktopLayoutSettingsSnapshot
+{
+    public int DesktopPageCount { get; set; } = 1;
+
+    public int CurrentDesktopSurfaceIndex { get; set; }
+
+    public List<DesktopComponentPlacementSnapshot> DesktopComponentPlacements { get; set; } = [];
+
+    public DesktopLayoutSettingsSnapshot Clone()
+    {
+        var clone = (DesktopLayoutSettingsSnapshot)MemberwiseClone();
+        var placements = new List<DesktopComponentPlacementSnapshot>(DesktopComponentPlacements?.Count ?? 0);
+
+        if (DesktopComponentPlacements is not null)
+        {
+            foreach (var placement in DesktopComponentPlacements)
+            {
+                if (placement is null)
+                {
+                    continue;
+                }
+
+                placements.Add(new DesktopComponentPlacementSnapshot
+                {
+                    PlacementId = placement.PlacementId,
+                    PageIndex = placement.PageIndex,
+                    ComponentId = placement.ComponentId,
+                    Row = placement.Row,
+                    Column = placement.Column,
+                    WidthCells = placement.WidthCells,
+                    HeightCells = placement.HeightCells
+                });
+            }
+        }
+
+        clone.DesktopComponentPlacements = placements;
+        return clone;
+    }
+}

LanMountainDesktop/Models/LauncherSettingsSnapshot.cs

@@ -0,0 +1,22 @@
+using System.Collections.Generic;
+
+namespace LanMountainDesktop.Models;
+
+public sealed class LauncherSettingsSnapshot
+{
+    public List<string> HiddenLauncherFolderPaths { get; set; } = [];
+
+    public List<string> HiddenLauncherAppPaths { get; set; } = [];
+
+    public LauncherSettingsSnapshot Clone()
+    {
+        var clone = (LauncherSettingsSnapshot)MemberwiseClone();
+        clone.HiddenLauncherFolderPaths = HiddenLauncherFolderPaths is { Count: > 0 }
+            ? new List<string>(HiddenLauncherFolderPaths)
+            : [];
+        clone.HiddenLauncherAppPaths = HiddenLauncherAppPaths is { Count: > 0 }
+            ? new List<string>(HiddenLauncherAppPaths)
+            : [];
+        return clone;
+    }
+}

LanMountainDesktop/Program.cs

@@ -1,5 +1,6 @@
-using Avalonia;
+using Avalonia;
 using Avalonia.WebView.Desktop;
+using LanMountainDesktop.Services;
 using System;
 
 namespace LanMountainDesktop;
@@ -10,14 +11,42 @@ sealed class Program
     // SynchronizationContext-reliant code before AppMain is called: things aren't initialized
     // yet and stuff might break.
     [STAThread]
-    public static void Main(string[] args) => BuildAvaloniaApp()
+    public static void Main(string[] args) => BuildAvaloniaApp(LoadConfiguredRenderMode())
         .StartWithClassicDesktopLifetime(args);
 
     // Avalonia configuration, don't remove; also used by visual designer.
-    public static AppBuilder BuildAvaloniaApp()
-        => AppBuilder.Configure<App>()
+    public static AppBuilder BuildAvaloniaApp(string renderMode = AppRenderingModeHelper.Default)
+    {
+        var builder = AppBuilder.Configure<App>()
             .UsePlatformDetect()
             .UseDesktopWebView()
             .WithInterFont()
             .LogToTrace();
+
+        if (OperatingSystem.IsWindows())
+        {
+            var configuredModes = AppRenderingModeHelper.GetWin32RenderingModes(renderMode);
+            if (configuredModes is { Length: > 0 })
+            {
+                builder = builder.With(new Win32PlatformOptions
+                {
+                    RenderingMode = configuredModes
+                });
+            }
+        }
+
+        return builder;
+    }
+
+    private static string LoadConfiguredRenderMode()
+    {
+        try
+        {
+            return AppRenderingModeHelper.Normalize(new AppSettingsService().Load().AppRenderMode);
+        }
+        catch
+        {
+            return AppRenderingModeHelper.Default;
+        }
+    }
 }

LanMountainDesktop/Services/AppRenderingModeHelper.cs

@@ -0,0 +1,42 @@
+using Avalonia;
+
+namespace LanMountainDesktop.Services;
+
+public static class AppRenderingModeHelper
+{
+    public const string Default = "Default";
+    public const string Software = "Software";
+    public const string AngleEgl = "AngleEgl";
+    public const string Wgl = "Wgl";
+    public const string Vulkan = "Vulkan";
+
+    public static string Normalize(string? value)
+    {
+        if (string.IsNullOrWhiteSpace(value))
+        {
+            return Default;
+        }
+
+        return value.Trim().ToUpperInvariant() switch
+        {
+            "SOFTWARE" => Software,
+            "ANGLEEGL" => AngleEgl,
+            "ANGLE_EGL" => AngleEgl,
+            "WGL" => Wgl,
+            "VULKAN" => Vulkan,
+            _ => Default
+        };
+    }
+
+    public static Win32RenderingMode[]? GetWin32RenderingModes(string? value)
+    {
+        return Normalize(value) switch
+        {
+            Software => [Win32RenderingMode.Software],
+            AngleEgl => [Win32RenderingMode.AngleEgl, Win32RenderingMode.Software],
+            Wgl => [Win32RenderingMode.Wgl, Win32RenderingMode.Software],
+            Vulkan => [Win32RenderingMode.Vulkan, Win32RenderingMode.Software],
+            _ => null
+        };
+    }
+}

LanMountainDesktop/Services/AppSettingsService.cs

@@ -7,6 +7,8 @@ namespace LanMountainDesktop.Services;
 
 public sealed class AppSettingsService
 {
+    public static event Action<string>? SettingsSaved;
+
     private static readonly JsonSerializerOptions SerializerOptions = new()
     {
         WriteIndented = true
@@ -21,6 +23,8 @@ public sealed class AppSettingsService
 
     private readonly string _settingsPath;
 
+    public string InstanceId { get; } = Guid.NewGuid().ToString("N");
+
     public AppSettingsService()
     {
         var appData = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
@@ -88,6 +92,8 @@ public sealed class AppSettingsService
             {
                 UpdateCache(snapshotToPersist, writeTimeUtc, DateTime.UtcNow);
             }
+
+            SettingsSaved?.Invoke(InstanceId);
         }
         catch
         {

LanMountainDesktop/Services/ComponentSettingsService.cs

@@ -2,12 +2,13 @@ using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Reflection;
 using System.Text.Json;
 using LanMountainDesktop.Models;
 
 namespace LanMountainDesktop.Services;
 
-public sealed class ComponentSettingsService
+public sealed class ComponentSettingsService : IComponentInstanceSettingsStore
 {
     private static readonly JsonSerializerOptions SerializerOptions = new()
     {
@@ -18,12 +19,14 @@ public sealed class ComponentSettingsService
     private static readonly TimeSpan CacheProbeInterval = TimeSpan.FromMilliseconds(400);
 
     private static string? _cachedPath;
-    private static ComponentSettingsSnapshot? _cachedSnapshot;
+    private static ComponentSettingsDocumentSnapshot? _cachedSnapshot;
     private static DateTime _cachedWriteTimeUtc = DateTime.MinValue;
     private static DateTime _lastProbeUtc = DateTime.MinValue;
 
     private readonly string _settingsPath;
     private readonly string _legacyAppSettingsPath;
+    private string _scopedComponentId = string.Empty;
+    private string _scopedPlacementId = string.Empty;
 
     public ComponentSettingsService()
     {
@@ -35,51 +38,17 @@ public sealed class ComponentSettingsService
 
     public ComponentSettingsSnapshot Load()
     {
+        if (HasScopedComponentContext())
+        {
+            return LoadForComponent(_scopedComponentId, _scopedPlacementId);
+        }
+
         try
         {
             lock (CacheGate)
             {
-                var nowUtc = DateTime.UtcNow;
-                if (TryGetCachedWithoutProbe(nowUtc, out var cached))
-                {
-                    return cached;
-                }
-
-                var hasFile = File.Exists(_settingsPath);
-                var writeTimeUtc = hasFile
-                    ? File.GetLastWriteTimeUtc(_settingsPath)
-                    : DateTime.MinValue;
-
-                _lastProbeUtc = nowUtc;
-                if (TryGetCachedAfterProbe(writeTimeUtc, out cached))
-                {
-                    return cached;
-                }
-
-                ComponentSettingsSnapshot loadedSnapshot;
-                var loadedFromLegacy = false;
-                if (hasFile)
-                {
-                    loadedSnapshot = LoadSnapshotFromDisk();
-                }
-                else if (TryLoadLegacySnapshot(out var migratedSnapshot))
-                {
-                    loadedSnapshot = migratedSnapshot;
-                    loadedFromLegacy = true;
-                }
-                else
-                {
-                    loadedSnapshot = new ComponentSettingsSnapshot();
-                }
-
-                var normalizedSnapshot = NormalizeSnapshot(loadedSnapshot);
-                if (loadedFromLegacy)
-                {
-                    writeTimeUtc = PersistSnapshotToDisk(normalizedSnapshot);
-                }
-
-                UpdateCache(normalizedSnapshot, writeTimeUtc, nowUtc);
-                return normalizedSnapshot.Clone();
+                var document = LoadDocumentLocked();
+                return document.DefaultSettings.Clone();
             }
         }
         catch
@@ -90,15 +59,21 @@ public sealed class ComponentSettingsService
 
     public void Save(ComponentSettingsSnapshot snapshot)
     {
+        if (HasScopedComponentContext())
+        {
+            SaveForComponent(_scopedComponentId, _scopedPlacementId, snapshot);
+            return;
+        }
+
         var snapshotToPersist = NormalizeSnapshot(snapshot);
 
         try
         {
-            var writeTimeUtc = PersistSnapshotToDisk(snapshotToPersist);
-
             lock (CacheGate)
             {
-                UpdateCache(snapshotToPersist, writeTimeUtc, DateTime.UtcNow);
+                var document = LoadDocumentLocked();
+                document.DefaultSettings = snapshotToPersist;
+                PersistDocumentLocked(document);
             }
         }
         catch
@@ -107,7 +82,201 @@ public sealed class ComponentSettingsService
         }
     }
 
-    private bool TryGetCachedWithoutProbe(DateTime nowUtc, out ComponentSettingsSnapshot snapshot)
+    public ComponentSettingsSnapshot LoadForComponent(string componentId, string? placementId)
+    {
+        try
+        {
+            lock (CacheGate)
+            {
+                var document = LoadDocumentLocked();
+                var instanceKey = BuildInstanceKey(componentId, placementId);
+                if (!string.IsNullOrWhiteSpace(instanceKey) &&
+                    document.InstanceSettings.TryGetValue(instanceKey, out var snapshot))
+                {
+                    return snapshot.Clone();
+                }
+
+                return document.DefaultSettings.Clone();
+            }
+        }
+        catch
+        {
+            return new ComponentSettingsSnapshot();
+        }
+    }
+
+    public void SaveForComponent(string componentId, string? placementId, ComponentSettingsSnapshot snapshot)
+    {
+        var normalizedSnapshot = NormalizeSnapshot(snapshot);
+        var instanceKey = BuildInstanceKey(componentId, placementId);
+        if (string.IsNullOrWhiteSpace(instanceKey))
+        {
+            Save(normalizedSnapshot);
+            return;
+        }
+
+        try
+        {
+            lock (CacheGate)
+            {
+                var document = LoadDocumentLocked();
+                document.InstanceSettings[instanceKey] = normalizedSnapshot;
+                PersistDocumentLocked(document);
+            }
+        }
+        catch
+        {
+            // Swallow persistence errors to keep UI interactions uninterrupted.
+        }
+    }
+
+    public void DeleteForComponent(string componentId, string? placementId)
+    {
+        var instanceKey = BuildInstanceKey(componentId, placementId);
+        if (string.IsNullOrWhiteSpace(instanceKey))
+        {
+            return;
+        }
+
+        try
+        {
+            lock (CacheGate)
+            {
+                var document = LoadDocumentLocked();
+                var changed = document.InstanceSettings.Remove(instanceKey);
+                changed |= document.PluginSettings.Remove(instanceKey);
+                if (changed)
+                {
+                    PersistDocumentLocked(document);
+                }
+            }
+        }
+        catch
+        {
+            // Swallow persistence errors to keep UI interactions uninterrupted.
+        }
+    }
+
+    public T LoadPluginSettings<T>(string componentId, string? placementId) where T : new()
+    {
+        try
+        {
+            lock (CacheGate)
+            {
+                var document = LoadDocumentLocked();
+                var instanceKey = BuildInstanceKey(componentId, placementId);
+                if (string.IsNullOrWhiteSpace(instanceKey) ||
+                    !document.PluginSettings.TryGetValue(instanceKey, out var settingsElement))
+                {
+                    return new T();
+                }
+
+                return JsonSerializer.Deserialize<T>(settingsElement.GetRawText(), SerializerOptions) ?? new T();
+            }
+        }
+        catch
+        {
+            return new T();
+        }
+    }
+
+    public void SavePluginSettings<T>(string componentId, string? placementId, T settings)
+    {
+        var instanceKey = BuildInstanceKey(componentId, placementId);
+        if (string.IsNullOrWhiteSpace(instanceKey))
+        {
+            return;
+        }
+
+        try
+        {
+            lock (CacheGate)
+            {
+                var document = LoadDocumentLocked();
+                document.PluginSettings[instanceKey] = JsonSerializer.SerializeToElement(settings, SerializerOptions).Clone();
+                PersistDocumentLocked(document);
+            }
+        }
+        catch
+        {
+            // Swallow persistence errors to keep UI interactions uninterrupted.
+        }
+    }
+
+    public void DeletePluginSettings(string componentId, string? placementId)
+    {
+        var instanceKey = BuildInstanceKey(componentId, placementId);
+        if (string.IsNullOrWhiteSpace(instanceKey))
+        {
+            return;
+        }
+
+        try
+        {
+            lock (CacheGate)
+            {
+                var document = LoadDocumentLocked();
+                if (document.PluginSettings.Remove(instanceKey))
+                {
+                    PersistDocumentLocked(document);
+                }
+            }
+        }
+        catch
+        {
+            // Swallow persistence errors to keep UI interactions uninterrupted.
+        }
+    }
+
+    public void SetScopedComponentContext(string componentId, string? placementId)
+    {
+        _scopedComponentId = componentId?.Trim() ?? string.Empty;
+        _scopedPlacementId = placementId?.Trim() ?? string.Empty;
+    }
+
+    public void ClearScopedComponentContext()
+    {
+        _scopedComponentId = string.Empty;
+        _scopedPlacementId = string.Empty;
+    }
+
+    public static void ApplyScopedContextToTarget(object? target, string componentId, string? placementId)
+    {
+        if (target is null)
+        {
+            return;
+        }
+
+        var flags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
+        foreach (var field in target.GetType().GetFields(flags))
+        {
+            if (field.FieldType != typeof(ComponentSettingsService))
+            {
+                continue;
+            }
+
+            if (field.GetValue(target) is ComponentSettingsService settingsService)
+            {
+                settingsService.SetScopedComponentContext(componentId, placementId);
+            }
+        }
+
+        foreach (var property in target.GetType().GetProperties(flags))
+        {
+            if (property.PropertyType != typeof(ComponentSettingsService) ||
+                !property.CanRead)
+            {
+                continue;
+            }
+
+            if (property.GetValue(target) is ComponentSettingsService settingsService)
+            {
+                settingsService.SetScopedComponentContext(componentId, placementId);
+            }
+        }
+    }
+
+    private bool TryGetCachedWithoutProbe(DateTime nowUtc, out ComponentSettingsDocumentSnapshot snapshot)
     {
         if (string.Equals(_cachedPath, _settingsPath, StringComparison.Ordinal) &&
             _cachedSnapshot is not null &&
@@ -121,7 +290,7 @@ public sealed class ComponentSettingsService
         return false;
     }
 
-    private bool TryGetCachedAfterProbe(DateTime writeTimeUtc, out ComponentSettingsSnapshot snapshot)
+    private bool TryGetCachedAfterProbe(DateTime writeTimeUtc, out ComponentSettingsDocumentSnapshot snapshot)
     {
         if (string.Equals(_cachedPath, _settingsPath, StringComparison.Ordinal) &&
             _cachedSnapshot is not null &&
@@ -135,17 +304,78 @@ public sealed class ComponentSettingsService
         return false;
     }
 
-    private ComponentSettingsSnapshot LoadSnapshotFromDisk()
+    private ComponentSettingsDocumentSnapshot LoadDocumentLocked()
+    {
+        var nowUtc = DateTime.UtcNow;
+        if (TryGetCachedWithoutProbe(nowUtc, out var cached))
+        {
+            return cached;
+        }
+
+        var hasFile = File.Exists(_settingsPath);
+        var writeTimeUtc = hasFile
+            ? File.GetLastWriteTimeUtc(_settingsPath)
+            : DateTime.MinValue;
+
+        _lastProbeUtc = nowUtc;
+        if (TryGetCachedAfterProbe(writeTimeUtc, out cached))
+        {
+            return cached;
+        }
+
+        ComponentSettingsDocumentSnapshot loadedSnapshot;
+        var loadedFromLegacy = false;
+        if (hasFile)
+        {
+            loadedSnapshot = LoadSnapshotFromDisk();
+        }
+        else if (TryLoadLegacySnapshot(out var migratedSnapshot))
+        {
+            loadedSnapshot = new ComponentSettingsDocumentSnapshot
+            {
+                DefaultSettings = NormalizeSnapshot(migratedSnapshot)
+            };
+            loadedFromLegacy = true;
+        }
+        else
+        {
+            loadedSnapshot = new ComponentSettingsDocumentSnapshot();
+        }
+
+        var normalizedSnapshot = NormalizeDocument(loadedSnapshot);
+        if (loadedFromLegacy)
+        {
+            writeTimeUtc = PersistSnapshotToDisk(normalizedSnapshot);
+        }
+
+        UpdateCache(normalizedSnapshot, writeTimeUtc, nowUtc);
+        return normalizedSnapshot.Clone();
+    }
+
+    private ComponentSettingsDocumentSnapshot LoadSnapshotFromDisk()
     {
         try
         {
             var json = File.ReadAllText(_settingsPath);
-            var snapshot = JsonSerializer.Deserialize<ComponentSettingsSnapshot>(json, SerializerOptions);
-            return NormalizeSnapshot(snapshot);
+            using var document = JsonDocument.Parse(json);
+            if (document.RootElement.ValueKind == JsonValueKind.Object &&
+                (document.RootElement.TryGetProperty("defaultSettings", out _) ||
+                 document.RootElement.TryGetProperty("instanceSettings", out _) ||
+                 document.RootElement.TryGetProperty("pluginSettings", out _)))
+            {
+                var snapshot = JsonSerializer.Deserialize<ComponentSettingsDocumentSnapshot>(json, SerializerOptions);
+                return NormalizeDocument(snapshot);
+            }
+
+            var legacySnapshot = JsonSerializer.Deserialize<ComponentSettingsSnapshot>(json, SerializerOptions);
+            return new ComponentSettingsDocumentSnapshot
+            {
+                DefaultSettings = NormalizeSnapshot(legacySnapshot)
+            };
         }
         catch
         {
-            return new ComponentSettingsSnapshot();
+            return new ComponentSettingsDocumentSnapshot();
         }
     }
 
@@ -204,7 +434,13 @@ public sealed class ComponentSettingsService
         }
     }
 
-    private DateTime PersistSnapshotToDisk(ComponentSettingsSnapshot snapshot)
+    private void PersistDocumentLocked(ComponentSettingsDocumentSnapshot snapshot)
+    {
+        var writeTimeUtc = PersistSnapshotToDisk(snapshot);
+        UpdateCache(snapshot, writeTimeUtc, DateTime.UtcNow);
+    }
+
+    private DateTime PersistSnapshotToDisk(ComponentSettingsDocumentSnapshot snapshot)
     {
         var directory = Path.GetDirectoryName(_settingsPath);
         if (!string.IsNullOrWhiteSpace(directory))
@@ -257,6 +493,40 @@ public sealed class ComponentSettingsService
         return normalized;
     }
 
+    private static ComponentSettingsDocumentSnapshot NormalizeDocument(ComponentSettingsDocumentSnapshot? snapshot)
+    {
+        var normalized = snapshot?.Clone() ?? new ComponentSettingsDocumentSnapshot();
+        normalized.DefaultSettings = NormalizeSnapshot(normalized.DefaultSettings);
+
+        var instanceSettings = new Dictionary<string, ComponentSettingsSnapshot>(StringComparer.OrdinalIgnoreCase);
+        foreach (var pair in normalized.InstanceSettings)
+        {
+            var key = NormalizeInstanceKey(pair.Key);
+            if (string.IsNullOrWhiteSpace(key))
+            {
+                continue;
+            }
+
+            instanceSettings[key] = NormalizeSnapshot(pair.Value);
+        }
+
+        var pluginSettings = new Dictionary<string, JsonElement>(StringComparer.OrdinalIgnoreCase);
+        foreach (var pair in normalized.PluginSettings)
+        {
+            var key = NormalizeInstanceKey(pair.Key);
+            if (string.IsNullOrWhiteSpace(key))
+            {
+                continue;
+            }
+
+            pluginSettings[key] = pair.Value.Clone();
+        }
+
+        normalized.InstanceSettings = instanceSettings;
+        normalized.PluginSettings = pluginSettings;
+        return normalized;
+    }
+
     private static List<ImportedClassScheduleSnapshot> NormalizeImportedSchedules(
         IReadOnlyList<ImportedClassScheduleSnapshot>? schedules)
     {
@@ -360,7 +630,30 @@ public sealed class ComponentSettingsService
         return RefreshIntervalCatalog.Normalize(minutes, 20);
     }
 
-    private void UpdateCache(ComponentSettingsSnapshot snapshot, DateTime writeTimeUtc, DateTime probeTimeUtc)
+    private static string BuildInstanceKey(string componentId, string? placementId)
+    {
+        var normalizedComponentId = componentId?.Trim() ?? string.Empty;
+        var normalizedPlacementId = placementId?.Trim() ?? string.Empty;
+        if (string.IsNullOrWhiteSpace(normalizedComponentId) || string.IsNullOrWhiteSpace(normalizedPlacementId))
+        {
+            return string.Empty;
+        }
+
+        return $"{normalizedComponentId}::{normalizedPlacementId}";
+    }
+
+    private static string NormalizeInstanceKey(string? key)
+    {
+        return key?.Trim() ?? string.Empty;
+    }
+
+    private bool HasScopedComponentContext()
+    {
+        return !string.IsNullOrWhiteSpace(_scopedComponentId) &&
+               !string.IsNullOrWhiteSpace(_scopedPlacementId);
+    }
+
+    private void UpdateCache(ComponentSettingsDocumentSnapshot snapshot, DateTime writeTimeUtc, DateTime probeTimeUtc)
     {
         _cachedPath = _settingsPath;
         _cachedSnapshot = snapshot.Clone();
@@ -368,6 +661,39 @@ public sealed class ComponentSettingsService
         _lastProbeUtc = probeTimeUtc;
     }
 
+    private sealed class ComponentSettingsDocumentSnapshot
+    {
+        public ComponentSettingsSnapshot DefaultSettings { get; set; } = new();
+
+        public Dictionary<string, ComponentSettingsSnapshot> InstanceSettings { get; set; } =
+            new(StringComparer.OrdinalIgnoreCase);
+
+        public Dictionary<string, JsonElement> PluginSettings { get; set; } =
+            new(StringComparer.OrdinalIgnoreCase);
+
+        public ComponentSettingsDocumentSnapshot Clone()
+        {
+            var clone = new ComponentSettingsDocumentSnapshot
+            {
+                DefaultSettings = DefaultSettings?.Clone() ?? new ComponentSettingsSnapshot(),
+                InstanceSettings = new Dictionary<string, ComponentSettingsSnapshot>(StringComparer.OrdinalIgnoreCase),
+                PluginSettings = new Dictionary<string, JsonElement>(StringComparer.OrdinalIgnoreCase)
+            };
+
+            foreach (var pair in InstanceSettings)
+            {
+                clone.InstanceSettings[pair.Key] = pair.Value?.Clone() ?? new ComponentSettingsSnapshot();
+            }
+
+            foreach (var pair in PluginSettings)
+            {
+                clone.PluginSettings[pair.Key] = pair.Value.Clone();
+            }
+
+            return clone;
+        }
+    }
+
     private sealed class LegacyComponentSettingsSnapshot
     {
         public string DailyArtworkMirrorSource { get; set; } = DailyArtworkMirrorSources.Overseas;

LanMountainDesktop/Services/DesktopComponentRegistryFactory.cs

@@ -0,0 +1,174 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using System.Linq;
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Layout;
+using Avalonia.Media;
+using LanMountainDesktop.ComponentSystem;
+using LanMountainDesktop.ComponentSystem.Extensions;
+using LanMountainDesktop.PluginSdk;
+using LanMountainDesktop.Views.Components;
+
+namespace LanMountainDesktop.Services;
+
+public static class DesktopComponentRegistryFactory
+{
+    public static ComponentRegistry Create(PluginRuntimeService? pluginRuntimeService)
+    {
+        var registry = ComponentRegistry
+            .CreateDefault()
+            .RegisterExtensions(
+                JsonComponentExtensionProvider.LoadProvidersFromDirectory(
+                    Path.Combine(AppContext.BaseDirectory, "Extensions", "Components")));
+
+        var pluginDefinitions = GetPluginDefinitions(registry, pluginRuntimeService);
+        return pluginDefinitions.Count == 0
+            ? registry
+            : registry.RegisterComponents(pluginDefinitions);
+    }
+
+    public static DesktopComponentRuntimeRegistry CreateRuntimeRegistry(
+        ComponentRegistry componentRegistry,
+        PluginRuntimeService? pluginRuntimeService)
+    {
+        var registrations = DesktopComponentRuntimeRegistry.GetDefaultRegistrations().ToList();
+        var registeredIds = new HashSet<string>(
+            registrations.Select(registration => registration.ComponentId),
+            StringComparer.OrdinalIgnoreCase);
+
+        if (pluginRuntimeService is not null)
+        {
+            foreach (var contribution in pluginRuntimeService.DesktopComponents)
+            {
+                var registration = contribution.Registration;
+                if (!componentRegistry.TryGetDefinition(registration.ComponentId, out _))
+                {
+                    continue;
+                }
+
+                if (!registeredIds.Add(registration.ComponentId))
+                {
+                    Debug.WriteLine(
+                        $"[PluginRuntime] Skipped plugin widget '{registration.ComponentId}' from '{contribution.Plugin.Manifest.Id}' because a runtime registration already exists.");
+                    continue;
+                }
+
+                registrations.Add(new DesktopComponentRuntimeRegistration(
+                    registration.ComponentId,
+                    registration.DisplayNameLocalizationKey,
+                    factoryContext => CreatePluginControl(contribution, factoryContext),
+                    registration.CornerRadiusResolver));
+            }
+        }
+
+        return new DesktopComponentRuntimeRegistry(componentRegistry, registrations);
+    }
+
+    private static List<DesktopComponentDefinition> GetPluginDefinitions(
+        ComponentRegistry baseRegistry,
+        PluginRuntimeService? pluginRuntimeService)
+    {
+        var definitions = new List<DesktopComponentDefinition>();
+        if (pluginRuntimeService is null)
+        {
+            return definitions;
+        }
+
+        var knownIds = new HashSet<string>(
+            baseRegistry.GetAll().Select(definition => definition.Id),
+            StringComparer.OrdinalIgnoreCase);
+
+        foreach (var contribution in pluginRuntimeService.DesktopComponents)
+        {
+            var registration = contribution.Registration;
+            if (!knownIds.Add(registration.ComponentId))
+            {
+                Debug.WriteLine(
+                    $"[PluginRuntime] Skipped plugin widget '{registration.ComponentId}' from '{contribution.Plugin.Manifest.Id}' because the component id already exists.");
+                continue;
+            }
+
+            definitions.Add(new DesktopComponentDefinition(
+                registration.ComponentId,
+                registration.DisplayName,
+                registration.IconKey,
+                registration.Category,
+                registration.MinWidthCells,
+                registration.MinHeightCells,
+                registration.AllowStatusBarPlacement,
+                registration.AllowDesktopPlacement,
+                registration.ResizeMode == PluginDesktopComponentResizeMode.Free
+                    ? DesktopComponentResizeMode.Free
+                    : DesktopComponentResizeMode.Proportional));
+        }
+
+        return definitions;
+    }
+
+    private static Control CreatePluginControl(
+        PluginDesktopComponentContribution contribution,
+        DesktopComponentControlFactoryContext context)
+    {
+        try
+        {
+            var pluginContext = new PluginDesktopComponentContext(
+                contribution.Plugin.Manifest,
+                contribution.Plugin.Context.PluginDirectory,
+                contribution.Plugin.Context.DataDirectory,
+                contribution.Plugin.Context.Services,
+                contribution.Plugin.Context.Properties,
+                contribution.Registration.ComponentId,
+                context.PlacementId,
+                context.CellSize);
+
+            return contribution.Registration.ControlFactory(pluginContext);
+        }
+        catch (Exception ex)
+        {
+            Debug.WriteLine(
+                $"[PluginRuntime] Failed to create widget '{contribution.Registration.ComponentId}' from '{contribution.Plugin.Manifest.Id}': {ex}");
+            return CreatePluginErrorControl(contribution, ex);
+        }
+    }
+
+    private static Control CreatePluginErrorControl(
+        PluginDesktopComponentContribution contribution,
+        Exception exception)
+    {
+        return new Border
+        {
+            Background = new SolidColorBrush(Color.Parse("#332B0F16")),
+            BorderBrush = new SolidColorBrush(Color.Parse("#66F97316")),
+            BorderThickness = new Thickness(1),
+            CornerRadius = new CornerRadius(16),
+            Padding = new Thickness(12),
+            Child = new StackPanel
+            {
+                Spacing = 6,
+                Children =
+                {
+                    new TextBlock
+                    {
+                        Text = contribution.Registration.DisplayName,
+                        FontSize = 14,
+                        FontWeight = FontWeight.SemiBold,
+                        TextWrapping = TextWrapping.Wrap
+                    },
+                    new TextBlock
+                    {
+                        Text = $"Plugin {contribution.Plugin.Manifest.Name} failed to create this widget.",
+                        TextWrapping = TextWrapping.Wrap
+                    },
+                    new TextBlock
+                    {
+                        Text = exception.Message,
+                        TextWrapping = TextWrapping.Wrap
+                    }
+                }
+            }
+        };
+    }
+}

LanMountainDesktop/Services/DesktopLayoutSettingsService.cs

@@ -0,0 +1,248 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text.Json;
+using LanMountainDesktop.Models;
+
+namespace LanMountainDesktop.Services;
+
+public sealed class DesktopLayoutSettingsService
+{
+    private static readonly JsonSerializerOptions SerializerOptions = new()
+    {
+        WriteIndented = true
+    };
+    private static readonly object CacheGate = new();
+    private static readonly TimeSpan CacheProbeInterval = TimeSpan.FromMilliseconds(400);
+
+    private static string? _cachedPath;
+    private static DesktopLayoutSettingsSnapshot? _cachedSnapshot;
+    private static DateTime _cachedWriteTimeUtc = DateTime.MinValue;
+    private static DateTime _lastProbeUtc = DateTime.MinValue;
+
+    private readonly string _settingsPath;
+    private readonly string _legacyAppSettingsPath;
+
+    public DesktopLayoutSettingsService()
+    {
+        var appData = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
+        var settingsDirectory = Path.Combine(appData, "LanMountainDesktop");
+        _settingsPath = Path.Combine(settingsDirectory, "desktop-layout-settings.json");
+        _legacyAppSettingsPath = Path.Combine(settingsDirectory, "settings.json");
+    }
+
+    public DesktopLayoutSettingsSnapshot Load()
+    {
+        try
+        {
+            lock (CacheGate)
+            {
+                var nowUtc = DateTime.UtcNow;
+                if (TryGetCachedWithoutProbe(nowUtc, out var cached))
+                {
+                    return cached;
+                }
+
+                var hasFile = File.Exists(_settingsPath);
+                var writeTimeUtc = hasFile
+                    ? File.GetLastWriteTimeUtc(_settingsPath)
+                    : DateTime.MinValue;
+
+                _lastProbeUtc = nowUtc;
+                if (TryGetCachedAfterProbe(writeTimeUtc, out cached))
+                {
+                    return cached;
+                }
+
+                DesktopLayoutSettingsSnapshot loadedSnapshot;
+                var loadedFromLegacy = false;
+                if (hasFile)
+                {
+                    loadedSnapshot = LoadSnapshotFromDisk();
+                }
+                else if (TryLoadLegacySnapshot(out var migratedSnapshot))
+                {
+                    loadedSnapshot = migratedSnapshot;
+                    loadedFromLegacy = true;
+                }
+                else
+                {
+                    loadedSnapshot = new DesktopLayoutSettingsSnapshot();
+                }
+
+                var normalizedSnapshot = NormalizeSnapshot(loadedSnapshot);
+                if (loadedFromLegacy)
+                {
+                    writeTimeUtc = PersistSnapshotToDisk(normalizedSnapshot);
+                }
+
+                UpdateCache(normalizedSnapshot, writeTimeUtc, nowUtc);
+                return normalizedSnapshot.Clone();
+            }
+        }
+        catch
+        {
+            return new DesktopLayoutSettingsSnapshot();
+        }
+    }
+
+    public void Save(DesktopLayoutSettingsSnapshot snapshot)
+    {
+        var snapshotToPersist = NormalizeSnapshot(snapshot);
+
+        try
+        {
+            var writeTimeUtc = PersistSnapshotToDisk(snapshotToPersist);
+
+            lock (CacheGate)
+            {
+                UpdateCache(snapshotToPersist, writeTimeUtc, DateTime.UtcNow);
+            }
+        }
+        catch
+        {
+            // Swallow persistence errors to keep UI interactions uninterrupted.
+        }
+    }
+
+    private bool TryGetCachedWithoutProbe(DateTime nowUtc, out DesktopLayoutSettingsSnapshot snapshot)
+    {
+        if (string.Equals(_cachedPath, _settingsPath, StringComparison.Ordinal) &&
+            _cachedSnapshot is not null &&
+            nowUtc - _lastProbeUtc < CacheProbeInterval)
+        {
+            snapshot = _cachedSnapshot.Clone();
+            return true;
+        }
+
+        snapshot = null!;
+        return false;
+    }
+
+    private bool TryGetCachedAfterProbe(DateTime writeTimeUtc, out DesktopLayoutSettingsSnapshot snapshot)
+    {
+        if (string.Equals(_cachedPath, _settingsPath, StringComparison.Ordinal) &&
+            _cachedSnapshot is not null &&
+            writeTimeUtc == _cachedWriteTimeUtc)
+        {
+            snapshot = _cachedSnapshot.Clone();
+            return true;
+        }
+
+        snapshot = null!;
+        return false;
+    }
+
+    private DesktopLayoutSettingsSnapshot LoadSnapshotFromDisk()
+    {
+        try
+        {
+            var json = File.ReadAllText(_settingsPath);
+            var snapshot = JsonSerializer.Deserialize<DesktopLayoutSettingsSnapshot>(json, SerializerOptions);
+            return NormalizeSnapshot(snapshot);
+        }
+        catch
+        {
+            return new DesktopLayoutSettingsSnapshot();
+        }
+    }
+
+    private bool TryLoadLegacySnapshot(out DesktopLayoutSettingsSnapshot snapshot)
+    {
+        snapshot = new DesktopLayoutSettingsSnapshot();
+
+        try
+        {
+            if (!File.Exists(_legacyAppSettingsPath))
+            {
+                return false;
+            }
+
+            var legacyJson = File.ReadAllText(_legacyAppSettingsPath);
+            var legacy = JsonSerializer.Deserialize<LegacyDesktopLayoutSettingsSnapshot>(legacyJson, SerializerOptions);
+            if (legacy is null)
+            {
+                return false;
+            }
+
+            snapshot = new DesktopLayoutSettingsSnapshot
+            {
+                DesktopPageCount = legacy.DesktopPageCount,
+                CurrentDesktopSurfaceIndex = legacy.CurrentDesktopSurfaceIndex,
+                DesktopComponentPlacements = legacy.DesktopComponentPlacements ?? []
+            };
+
+            return true;
+        }
+        catch
+        {
+            return false;
+        }
+    }
+
+    private DateTime PersistSnapshotToDisk(DesktopLayoutSettingsSnapshot snapshot)
+    {
+        var directory = Path.GetDirectoryName(_settingsPath);
+        if (!string.IsNullOrWhiteSpace(directory))
+        {
+            Directory.CreateDirectory(directory);
+        }
+
+        var json = JsonSerializer.Serialize(snapshot, SerializerOptions);
+        File.WriteAllText(_settingsPath, json);
+
+        return File.Exists(_settingsPath)
+            ? File.GetLastWriteTimeUtc(_settingsPath)
+            : DateTime.UtcNow;
+    }
+
+    private static DesktopLayoutSettingsSnapshot NormalizeSnapshot(DesktopLayoutSettingsSnapshot? snapshot)
+    {
+        var normalized = snapshot?.Clone() ?? new DesktopLayoutSettingsSnapshot();
+        normalized.DesktopPageCount = Math.Max(1, normalized.DesktopPageCount);
+        normalized.CurrentDesktopSurfaceIndex = Math.Max(0, normalized.CurrentDesktopSurfaceIndex);
+
+        var placements = new List<DesktopComponentPlacementSnapshot>(normalized.DesktopComponentPlacements?.Count ?? 0);
+        if (normalized.DesktopComponentPlacements is not null)
+        {
+            foreach (var placement in normalized.DesktopComponentPlacements)
+            {
+                if (placement is null)
+                {
+                    continue;
+                }
+
+                placements.Add(new DesktopComponentPlacementSnapshot
+                {
+                    PlacementId = placement.PlacementId?.Trim() ?? string.Empty,
+                    PageIndex = Math.Max(0, placement.PageIndex),
+                    ComponentId = placement.ComponentId?.Trim() ?? string.Empty,
+                    Row = Math.Max(0, placement.Row),
+                    Column = Math.Max(0, placement.Column),
+                    WidthCells = Math.Max(1, placement.WidthCells),
+                    HeightCells = Math.Max(1, placement.HeightCells)
+                });
+            }
+        }
+
+        normalized.DesktopComponentPlacements = placements;
+        return normalized;
+    }
+
+    private void UpdateCache(DesktopLayoutSettingsSnapshot snapshot, DateTime writeTimeUtc, DateTime probeTimeUtc)
+    {
+        _cachedPath = _settingsPath;
+        _cachedSnapshot = snapshot.Clone();
+        _cachedWriteTimeUtc = writeTimeUtc;
+        _lastProbeUtc = probeTimeUtc;
+    }
+
+    private sealed class LegacyDesktopLayoutSettingsSnapshot
+    {
+        public int DesktopPageCount { get; set; } = 1;
+
+        public int CurrentDesktopSurfaceIndex { get; set; }
+
+        public List<DesktopComponentPlacementSnapshot>? DesktopComponentPlacements { get; set; }
+    }
+}

LanMountainDesktop/Services/IComponentInstanceSettingsStore.cs

@@ -0,0 +1,22 @@
+using LanMountainDesktop.Models;
+
+namespace LanMountainDesktop.Services;
+
+public interface IComponentInstanceSettingsStore
+{
+    ComponentSettingsSnapshot Load();
+
+    void Save(ComponentSettingsSnapshot snapshot);
+
+    ComponentSettingsSnapshot LoadForComponent(string componentId, string? placementId);
+
+    void SaveForComponent(string componentId, string? placementId, ComponentSettingsSnapshot snapshot);
+
+    void DeleteForComponent(string componentId, string? placementId);
+
+    T LoadPluginSettings<T>(string componentId, string? placementId) where T : new();
+
+    void SavePluginSettings<T>(string componentId, string? placementId, T settings);
+
+    void DeletePluginSettings(string componentId, string? placementId);
+}

LanMountainDesktop/Services/LauncherSettingsService.cs

@@ -0,0 +1,242 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text.Json;
+using LanMountainDesktop.Models;
+
+namespace LanMountainDesktop.Services;
+
+public sealed class LauncherSettingsService
+{
+    public static event Action<string>? SettingsSaved;
+
+    private static readonly JsonSerializerOptions SerializerOptions = new()
+    {
+        WriteIndented = true
+    };
+    private static readonly object CacheGate = new();
+    private static readonly TimeSpan CacheProbeInterval = TimeSpan.FromMilliseconds(400);
+
+    private static string? _cachedPath;
+    private static LauncherSettingsSnapshot? _cachedSnapshot;
+    private static DateTime _cachedWriteTimeUtc = DateTime.MinValue;
+    private static DateTime _lastProbeUtc = DateTime.MinValue;
+
+    private readonly string _settingsPath;
+    private readonly string _legacyAppSettingsPath;
+
+    public string InstanceId { get; } = Guid.NewGuid().ToString("N");
+
+    public LauncherSettingsService()
+    {
+        var appData = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
+        var settingsDirectory = Path.Combine(appData, "LanMountainDesktop");
+        _settingsPath = Path.Combine(settingsDirectory, "launcher-settings.json");
+        _legacyAppSettingsPath = Path.Combine(settingsDirectory, "settings.json");
+    }
+
+    public LauncherSettingsSnapshot Load()
+    {
+        try
+        {
+            lock (CacheGate)
+            {
+                var nowUtc = DateTime.UtcNow;
+                if (TryGetCachedWithoutProbe(nowUtc, out var cached))
+                {
+                    return cached;
+                }
+
+                var hasFile = File.Exists(_settingsPath);
+                var writeTimeUtc = hasFile
+                    ? File.GetLastWriteTimeUtc(_settingsPath)
+                    : DateTime.MinValue;
+
+                _lastProbeUtc = nowUtc;
+                if (TryGetCachedAfterProbe(writeTimeUtc, out cached))
+                {
+                    return cached;
+                }
+
+                LauncherSettingsSnapshot loadedSnapshot;
+                var loadedFromLegacy = false;
+                if (hasFile)
+                {
+                    loadedSnapshot = LoadSnapshotFromDisk();
+                }
+                else if (TryLoadLegacySnapshot(out var migratedSnapshot))
+                {
+                    loadedSnapshot = migratedSnapshot;
+                    loadedFromLegacy = true;
+                }
+                else
+                {
+                    loadedSnapshot = new LauncherSettingsSnapshot();
+                }
+
+                var normalizedSnapshot = NormalizeSnapshot(loadedSnapshot);
+                if (loadedFromLegacy)
+                {
+                    writeTimeUtc = PersistSnapshotToDisk(normalizedSnapshot);
+                }
+
+                UpdateCache(normalizedSnapshot, writeTimeUtc, nowUtc);
+                return normalizedSnapshot.Clone();
+            }
+        }
+        catch
+        {
+            return new LauncherSettingsSnapshot();
+        }
+    }
+
+    public void Save(LauncherSettingsSnapshot snapshot)
+    {
+        var snapshotToPersist = NormalizeSnapshot(snapshot);
+
+        try
+        {
+            var writeTimeUtc = PersistSnapshotToDisk(snapshotToPersist);
+
+            lock (CacheGate)
+            {
+                UpdateCache(snapshotToPersist, writeTimeUtc, DateTime.UtcNow);
+            }
+
+            SettingsSaved?.Invoke(InstanceId);
+        }
+        catch
+        {
+            // Swallow persistence errors to keep UI interactions uninterrupted.
+        }
+    }
+
+    private bool TryGetCachedWithoutProbe(DateTime nowUtc, out LauncherSettingsSnapshot snapshot)
+    {
+        if (string.Equals(_cachedPath, _settingsPath, StringComparison.Ordinal) &&
+            _cachedSnapshot is not null &&
+            nowUtc - _lastProbeUtc < CacheProbeInterval)
+        {
+            snapshot = _cachedSnapshot.Clone();
+            return true;
+        }
+
+        snapshot = null!;
+        return false;
+    }
+
+    private bool TryGetCachedAfterProbe(DateTime writeTimeUtc, out LauncherSettingsSnapshot snapshot)
+    {
+        if (string.Equals(_cachedPath, _settingsPath, StringComparison.Ordinal) &&
+            _cachedSnapshot is not null &&
+            writeTimeUtc == _cachedWriteTimeUtc)
+        {
+            snapshot = _cachedSnapshot.Clone();
+            return true;
+        }
+
+        snapshot = null!;
+        return false;
+    }
+
+    private LauncherSettingsSnapshot LoadSnapshotFromDisk()
+    {
+        try
+        {
+            var json = File.ReadAllText(_settingsPath);
+            var snapshot = JsonSerializer.Deserialize<LauncherSettingsSnapshot>(json, SerializerOptions);
+            return NormalizeSnapshot(snapshot);
+        }
+        catch
+        {
+            return new LauncherSettingsSnapshot();
+        }
+    }
+
+    private bool TryLoadLegacySnapshot(out LauncherSettingsSnapshot snapshot)
+    {
+        snapshot = new LauncherSettingsSnapshot();
+
+        try
+        {
+            if (!File.Exists(_legacyAppSettingsPath))
+            {
+                return false;
+            }
+
+            var legacyJson = File.ReadAllText(_legacyAppSettingsPath);
+            var legacy = JsonSerializer.Deserialize<LegacyLauncherSettingsSnapshot>(legacyJson, SerializerOptions);
+            if (legacy is null)
+            {
+                return false;
+            }
+
+            snapshot = new LauncherSettingsSnapshot
+            {
+                HiddenLauncherFolderPaths = legacy.HiddenLauncherFolderPaths ?? [],
+                HiddenLauncherAppPaths = legacy.HiddenLauncherAppPaths ?? []
+            };
+
+            return true;
+        }
+        catch
+        {
+            return false;
+        }
+    }
+
+    private DateTime PersistSnapshotToDisk(LauncherSettingsSnapshot snapshot)
+    {
+        var directory = Path.GetDirectoryName(_settingsPath);
+        if (!string.IsNullOrWhiteSpace(directory))
+        {
+            Directory.CreateDirectory(directory);
+        }
+
+        var json = JsonSerializer.Serialize(snapshot, SerializerOptions);
+        File.WriteAllText(_settingsPath, json);
+
+        return File.Exists(_settingsPath)
+            ? File.GetLastWriteTimeUtc(_settingsPath)
+            : DateTime.UtcNow;
+    }
+
+    private static LauncherSettingsSnapshot NormalizeSnapshot(LauncherSettingsSnapshot? snapshot)
+    {
+        var normalized = snapshot?.Clone() ?? new LauncherSettingsSnapshot();
+        normalized.HiddenLauncherFolderPaths = NormalizeKeys(normalized.HiddenLauncherFolderPaths);
+        normalized.HiddenLauncherAppPaths = NormalizeKeys(normalized.HiddenLauncherAppPaths);
+        return normalized;
+    }
+
+    private static List<string> NormalizeKeys(IReadOnlyList<string>? values)
+    {
+        if (values is null || values.Count == 0)
+        {
+            return [];
+        }
+
+        return values
+            .Where(value => !string.IsNullOrWhiteSpace(value))
+            .Select(value => value.Trim())
+            .Distinct(StringComparer.OrdinalIgnoreCase)
+            .OrderBy(value => value, StringComparer.OrdinalIgnoreCase)
+            .ToList();
+    }
+
+    private void UpdateCache(LauncherSettingsSnapshot snapshot, DateTime writeTimeUtc, DateTime probeTimeUtc)
+    {
+        _cachedPath = _settingsPath;
+        _cachedSnapshot = snapshot.Clone();
+        _cachedWriteTimeUtc = writeTimeUtc;
+        _lastProbeUtc = probeTimeUtc;
+    }
+
+    private sealed class LegacyLauncherSettingsSnapshot
+    {
+        public List<string>? HiddenLauncherFolderPaths { get; set; }
+
+        public List<string>? HiddenLauncherAppPaths { get; set; }
+    }
+}

LanMountainDesktop/Services/PluginCatalogEntry.cs

@@ -0,0 +1,19 @@
+using LanMountainDesktop.PluginSdk;
+
+namespace LanMountainDesktop.Services;
+
+public enum PluginCatalogSourceKind
+{
+    Package = 0,
+    Manifest = 1
+}
+
+public sealed record PluginCatalogEntry(
+    PluginManifest Manifest,
+    string SourcePath,
+    bool IsPackage,
+    bool IsEnabled,
+    bool IsLoaded,
+    string? ErrorMessage,
+    int SettingsPageCount,
+    int WidgetCount);

LanMountainDesktop/Services/PluginContributions.cs

@@ -0,0 +1,11 @@
+using LanMountainDesktop.PluginSdk;
+
+namespace LanMountainDesktop.Services;
+
+public sealed record PluginSettingsPageContribution(
+    LoadedPlugin Plugin,
+    PluginSettingsPageRegistration Registration);
+
+public sealed record PluginDesktopComponentContribution(
+    LoadedPlugin Plugin,
+    PluginDesktopComponentRegistration Registration);

LanMountainDesktop/Services/PluginRuntimeService.cs

@@ -0,0 +1,328 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using System.IO.Compression;
+using System.Linq;
+using System.Reflection;
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Markup.Xaml;
+using LanMountainDesktop.Models;
+using LanMountainDesktop.PluginSdk;
+
+namespace LanMountainDesktop.Services;
+
+public sealed class PluginRuntimeService : IDisposable
+{
+    private readonly PluginLoader _loader;
+    private readonly AppSettingsService _appSettingsService = new();
+    private readonly List<LoadedPlugin> _loadedPlugins = [];
+    private readonly List<PluginLoadResult> _loadResults = [];
+    private readonly List<PluginCatalogEntry> _catalog = [];
+    private readonly List<PluginSettingsPageContribution> _settingsPages = [];
+    private readonly List<PluginDesktopComponentContribution> _desktopComponents = [];
+
+    public PluginRuntimeService()
+    {
+        PluginsDirectory = Path.Combine(AppContext.BaseDirectory, "Extensions", "Plugins");
+        _loader = new PluginLoader(CreateOptions());
+    }
+
+    public string PluginsDirectory { get; }
+
+    public IReadOnlyList<LoadedPlugin> LoadedPlugins => _loadedPlugins;
+
+    public IReadOnlyList<PluginLoadResult> LoadResults => _loadResults;
+
+    public IReadOnlyList<PluginCatalogEntry> Catalog => _catalog;
+
+    public IReadOnlyList<PluginSettingsPageContribution> SettingsPages => _settingsPages;
+
+    public IReadOnlyList<PluginDesktopComponentContribution> DesktopComponents => _desktopComponents;
+
+    public void LoadInstalledPlugins()
+    {
+        Directory.CreateDirectory(PluginsDirectory);
+        UnloadInstalledPlugins();
+
+        var disabledPluginIds = GetDisabledPluginIds();
+        var hostProperties = new Dictionary<string, object?>(StringComparer.OrdinalIgnoreCase)
+        {
+            ["HostApplicationName"] = "LanMountainDesktop",
+            ["HostVersion"] = typeof(App).Assembly.GetName().Version?.ToString(),
+            ["PluginSdkApiVersion"] = PluginSdkInfo.ApiVersion
+        };
+
+        var discoveryFailures = new List<PluginLoadResult>();
+        var candidates = DiscoverCandidates(discoveryFailures);
+        _loadResults.AddRange(discoveryFailures);
+
+        var selectedPluginIds = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+        foreach (var candidate in candidates)
+        {
+            if (!selectedPluginIds.Add(candidate.Manifest.Id))
+            {
+                var duplicateFailure = PluginLoadResult.Failure(
+                    candidate.SourcePath,
+                    candidate.Manifest,
+                    new InvalidOperationException(
+                        $"Duplicate plugin id '{candidate.Manifest.Id}' was found. Source '{candidate.SourcePath}' was ignored because a higher-priority source was already selected."));
+                _loadResults.Add(duplicateFailure);
+                continue;
+            }
+
+            var isEnabled = !disabledPluginIds.Contains(candidate.Manifest.Id);
+            if (!isEnabled)
+            {
+                _catalog.Add(new PluginCatalogEntry(
+                    candidate.Manifest,
+                    candidate.SourcePath,
+                    candidate.SourceKind == PluginCatalogSourceKind.Package,
+                    false,
+                    false,
+                    null,
+                    0,
+                    0));
+                continue;
+            }
+
+            var loadResult = candidate.SourceKind switch
+            {
+                PluginCatalogSourceKind.Package => _loader.LoadFromPackage(
+                    candidate.SourcePath,
+                    PluginsDirectory,
+                    services: null,
+                    hostProperties),
+                _ => _loader.LoadFromManifest(
+                    candidate.SourcePath,
+                    services: null,
+                    hostProperties)
+            };
+
+            _loadResults.Add(loadResult);
+
+            if (loadResult.IsSuccess && loadResult.LoadedPlugin is not null)
+            {
+                _loadedPlugins.Add(loadResult.LoadedPlugin);
+                CollectContributions(loadResult.LoadedPlugin);
+                _catalog.Add(new PluginCatalogEntry(
+                    loadResult.LoadedPlugin.Manifest,
+                    loadResult.SourcePath,
+                    candidate.SourceKind == PluginCatalogSourceKind.Package,
+                    true,
+                    true,
+                    null,
+                    loadResult.LoadedPlugin.SettingsPages.Count,
+                    loadResult.LoadedPlugin.DesktopComponents.Count));
+                Debug.WriteLine($"[PluginRuntime] Loaded '{loadResult.Manifest?.Id}' from '{loadResult.SourcePath}'.");
+                continue;
+            }
+
+            _catalog.Add(new PluginCatalogEntry(
+                candidate.Manifest,
+                candidate.SourcePath,
+                candidate.SourceKind == PluginCatalogSourceKind.Package,
+                true,
+                false,
+                loadResult.Error?.Message,
+                0,
+                0));
+            Debug.WriteLine($"[PluginRuntime] Failed to load plugin from '{loadResult.SourcePath}': {loadResult.Error}");
+        }
+
+        if (_catalog.Count == 0 && discoveryFailures.Count == 0)
+        {
+            Debug.WriteLine($"[PluginRuntime] No .laapp packages or loose plugin manifests found under '{PluginsDirectory}'.");
+        }
+    }
+
+    public bool SetPluginEnabled(string pluginId, bool isEnabled)
+    {
+        if (string.IsNullOrWhiteSpace(pluginId))
+        {
+            return false;
+        }
+
+        var snapshot = _appSettingsService.Load();
+        var disabledPluginIds = snapshot.DisabledPluginIds is { Count: > 0 }
+            ? new HashSet<string>(snapshot.DisabledPluginIds, StringComparer.OrdinalIgnoreCase)
+            : new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+
+        var changed = isEnabled
+            ? disabledPluginIds.Remove(pluginId)
+            : disabledPluginIds.Add(pluginId);
+
+        if (!changed)
+        {
+            return false;
+        }
+
+        snapshot.DisabledPluginIds = disabledPluginIds
+            .OrderBy(id => id, StringComparer.OrdinalIgnoreCase)
+            .ToList();
+        _appSettingsService.Save(snapshot);
+
+        for (var i = 0; i < _catalog.Count; i++)
+        {
+            if (string.Equals(_catalog[i].Manifest.Id, pluginId, StringComparison.OrdinalIgnoreCase))
+            {
+                _catalog[i] = _catalog[i] with { IsEnabled = isEnabled };
+            }
+        }
+
+        return true;
+    }
+
+    public void Dispose()
+    {
+        UnloadInstalledPlugins();
+    }
+
+    private void UnloadInstalledPlugins()
+    {
+        for (var i = _loadedPlugins.Count - 1; i >= 0; i--)
+        {
+            _loadedPlugins[i].Dispose();
+        }
+
+        _loadedPlugins.Clear();
+        _loadResults.Clear();
+        _catalog.Clear();
+        _settingsPages.Clear();
+        _desktopComponents.Clear();
+    }
+
+    private HashSet<string> GetDisabledPluginIds()
+    {
+        var snapshot = _appSettingsService.Load();
+        return snapshot.DisabledPluginIds is { Count: > 0 }
+            ? new HashSet<string>(snapshot.DisabledPluginIds, StringComparer.OrdinalIgnoreCase)
+            : new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+    }
+
+    private IReadOnlyList<PluginCandidate> DiscoverCandidates(List<PluginLoadResult> failures)
+    {
+        var candidates = new List<PluginCandidate>();
+
+        foreach (var packagePath in EnumerateCandidatePaths($"*{PluginSdkInfo.PackageFileExtension}"))
+        {
+            try
+            {
+                var manifest = ReadManifestFromPackage(packagePath);
+                candidates.Add(new PluginCandidate(packagePath, manifest, PluginCatalogSourceKind.Package));
+            }
+            catch (Exception ex)
+            {
+                failures.Add(PluginLoadResult.Failure(packagePath, null, ex));
+            }
+        }
+
+        foreach (var manifestPath in EnumerateCandidatePaths("plugin.json"))
+        {
+            try
+            {
+                var manifest = PluginManifest.Load(manifestPath);
+                candidates.Add(new PluginCandidate(manifestPath, manifest, PluginCatalogSourceKind.Manifest));
+            }
+            catch (Exception ex)
+            {
+                failures.Add(PluginLoadResult.Failure(manifestPath, null, ex));
+            }
+        }
+
+        return candidates
+            .OrderBy(candidate => candidate.SourceKind)
+            .ThenBy(candidate => candidate.SourcePath, StringComparer.OrdinalIgnoreCase)
+            .ToArray();
+    }
+
+    private IEnumerable<string> EnumerateCandidatePaths(string searchPattern)
+    {
+        var runtimeRootDirectory = EnsureTrailingSeparator(Path.Combine(Path.GetFullPath(PluginsDirectory), ".runtime"));
+
+        return Directory
+            .EnumerateFiles(PluginsDirectory, searchPattern, SearchOption.AllDirectories)
+            .Select(Path.GetFullPath)
+            .Where(path => !path.StartsWith(runtimeRootDirectory, StringComparison.OrdinalIgnoreCase))
+            .OrderBy(path => path, StringComparer.OrdinalIgnoreCase);
+    }
+
+    private static PluginManifest ReadManifestFromPackage(string packagePath)
+    {
+        using var archive = ZipFile.OpenRead(packagePath);
+        var entries = archive.Entries
+            .Where(entry => string.Equals(entry.Name, "plugin.json", StringComparison.OrdinalIgnoreCase))
+            .ToArray();
+
+        if (entries.Length == 0)
+        {
+            throw new InvalidOperationException($"Plugin package '{packagePath}' does not contain 'plugin.json'.");
+        }
+
+        if (entries.Length > 1)
+        {
+            throw new InvalidOperationException($"Plugin package '{packagePath}' contains multiple 'plugin.json' files.");
+        }
+
+        using var stream = entries[0].Open();
+        return PluginManifest.Load(stream, $"{packagePath}!/{entries[0].FullName}");
+    }
+
+    private static string EnsureTrailingSeparator(string path)
+    {
+        return path.EndsWith(Path.DirectorySeparatorChar.ToString(), StringComparison.Ordinal)
+            ? path
+            : path + Path.DirectorySeparatorChar;
+    }
+
+    private static PluginLoaderOptions CreateOptions()
+    {
+        var options = new PluginLoaderOptions();
+        AddSharedAssembly(options, typeof(App).Assembly);
+
+        foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
+        {
+            var assemblyName = assembly.GetName().Name;
+            if (string.IsNullOrWhiteSpace(assemblyName))
+            {
+                continue;
+            }
+
+            if (assemblyName.StartsWith("Avalonia", StringComparison.OrdinalIgnoreCase) ||
+                string.Equals(assemblyName, "MicroCom.Runtime", StringComparison.OrdinalIgnoreCase))
+            {
+                AddSharedAssembly(options, assembly);
+            }
+        }
+
+        return options;
+    }
+
+    private static void AddSharedAssembly(PluginLoaderOptions options, Assembly assembly)
+    {
+        var assemblyName = assembly.GetName().Name;
+        if (!string.IsNullOrWhiteSpace(assemblyName))
+        {
+            options.SharedAssemblyNames.Add(assemblyName);
+        }
+    }
+
+    private void CollectContributions(LoadedPlugin loadedPlugin)
+    {
+        foreach (var settingsPage in loadedPlugin.SettingsPages)
+        {
+            _settingsPages.Add(new PluginSettingsPageContribution(loadedPlugin, settingsPage));
+        }
+
+        foreach (var desktopComponent in loadedPlugin.DesktopComponents)
+        {
+            _desktopComponents.Add(new PluginDesktopComponentContribution(loadedPlugin, desktopComponent));
+        }
+    }
+
+    private sealed record PluginCandidate(
+        string SourcePath,
+        PluginManifest Manifest,
+        PluginCatalogSourceKind SourceKind);
+}

LanMountainDesktop/Views/Components/AnalogClockWidget.axaml.cs

@@ -7,11 +7,12 @@ using Avalonia.Controls.Shapes;
 using Avalonia.Media;
 using Avalonia.Styling;
 using Avalonia.Threading;
+using LanMountainDesktop.ComponentSystem;
 using LanMountainDesktop.Services;
 
 namespace LanMountainDesktop.Views.Components;
 
-public partial class AnalogClockWidget : UserControl, IDesktopComponentWidget, ITimeZoneAwareComponentWidget
+public partial class AnalogClockWidget : UserControl, IDesktopComponentWidget, ITimeZoneAwareComponentWidget, IComponentPlacementContextAware, IComponentSettingsStoreAware
 {
     private static readonly IReadOnlyDictionary<string, string> ZhCityNames =
         new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
@@ -54,9 +55,11 @@ public partial class AnalogClockWidget : UserControl, IDesktopComponentWidget, I
 
     private const double DialSize = 258;
     private const double Center = DialSize / 2;
+    private string _componentId = BuiltInComponentIds.DesktopClock;
+    private string _placementId = string.Empty;
 
     private readonly AppSettingsService _appSettingsService = new();
-    private readonly ComponentSettingsService _componentSettingsService = new();
+    private IComponentInstanceSettingsStore _componentSettingsStore = new ComponentSettingsService();
     private readonly LocalizationService _localizationService = new();
     private TimeZoneService? _timeZoneService;
     private double _currentCellSize = 48;
@@ -112,6 +115,21 @@ public partial class AnalogClockWidget : UserControl, IDesktopComponentWidget, I
         UpdateClock();
     }
 
+    public void SetComponentPlacementContext(string componentId, string? placementId)
+    {
+        _componentId = string.IsNullOrWhiteSpace(componentId)
+            ? BuiltInComponentIds.DesktopClock
+            : componentId.Trim();
+        _placementId = placementId?.Trim() ?? string.Empty;
+        RefreshFromSettings();
+    }
+
+    public void SetComponentSettingsStore(IComponentInstanceSettingsStore settingsStore)
+    {
+        _componentSettingsStore = settingsStore ?? new ComponentSettingsService();
+        RefreshFromSettings();
+    }
+
     private void OnAttachedToVisualTree(object? sender, VisualTreeAttachmentEventArgs e)
     {
         InitializeDialIfNeeded();
@@ -359,7 +377,7 @@ public partial class AnalogClockWidget : UserControl, IDesktopComponentWidget, I
     private void LoadClockSettings()
     {
         var appSnapshot = _appSettingsService.Load();
-        var componentSnapshot = _componentSettingsService.Load();
+        var componentSnapshot = _componentSettingsStore.LoadForComponent(_componentId, _placementId);
         _languageCode = _localizationService.NormalizeLanguageCode(appSnapshot.LanguageCode);
 
         var configuredTimeZoneId = string.IsNullOrWhiteSpace(componentSnapshot.DesktopClockTimeZoneId)

LanMountainDesktop/Views/Components/AnalogClockWidgetSettingsWindow.axaml.cs

@@ -4,11 +4,12 @@ using System.Linq;
 using Avalonia.Controls;
 using Avalonia.Controls.Primitives;
 using Avalonia.Interactivity;
+using LanMountainDesktop.ComponentSystem;
 using LanMountainDesktop.Services;
 
 namespace LanMountainDesktop.Views.Components;
 
-public partial class AnalogClockWidgetSettingsWindow : UserControl
+public partial class AnalogClockWidgetSettingsWindow : UserControl, IComponentPlacementContextAware, IComponentSettingsStoreAware
 {
     private static readonly IReadOnlyDictionary<string, string> ZhTimeZoneNames =
         new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
@@ -28,11 +29,13 @@ public partial class AnalogClockWidgetSettingsWindow : UserControl
         };
 
     private readonly AppSettingsService _appSettingsService = new();
-    private readonly ComponentSettingsService _componentSettingsService = new();
+    private IComponentInstanceSettingsStore _componentSettingsStore = new ComponentSettingsService();
     private readonly LocalizationService _localizationService = new();
     private readonly TimeZoneService _timeZoneService = new();
     private bool _suppressEvents;
     private string _languageCode = "zh-CN";
+    private string _componentId = BuiltInComponentIds.DesktopClock;
+    private string _placementId = string.Empty;
     private IReadOnlyList<TimeZoneInfo> _allTimeZones = Array.Empty<TimeZoneInfo>();
     private string _selectedTimeZoneId = string.Empty;
     private string _secondHandMode = ClockSecondHandMode.Tick;
@@ -47,10 +50,29 @@ public partial class AnalogClockWidgetSettingsWindow : UserControl
         PopulateTimeZoneComboBox();
     }
 
+    public void SetComponentPlacementContext(string componentId, string? placementId)
+    {
+        _componentId = string.IsNullOrWhiteSpace(componentId)
+            ? BuiltInComponentIds.DesktopClock
+            : componentId.Trim();
+        _placementId = placementId?.Trim() ?? string.Empty;
+        LoadState();
+        ApplyLocalization();
+        PopulateTimeZoneComboBox();
+    }
+
+    public void SetComponentSettingsStore(IComponentInstanceSettingsStore settingsStore)
+    {
+        _componentSettingsStore = settingsStore ?? new ComponentSettingsService();
+        LoadState();
+        ApplyLocalization();
+        PopulateTimeZoneComboBox();
+    }
+
     private void LoadState()
     {
         var appSnapshot = _appSettingsService.Load();
-        var componentSnapshot = _componentSettingsService.Load();
+        var componentSnapshot = _componentSettingsStore.LoadForComponent(_componentId, _placementId);
         _languageCode = _localizationService.NormalizeLanguageCode(appSnapshot.LanguageCode);
         _selectedTimeZoneId = string.IsNullOrWhiteSpace(componentSnapshot.DesktopClockTimeZoneId)
             ? "China Standard Time"
@@ -149,10 +171,10 @@ public partial class AnalogClockWidgetSettingsWindow : UserControl
         _selectedTimeZoneId = normalizedId;
         _secondHandMode = GetSelectedSecondHandMode();
 
-        var snapshot = _componentSettingsService.Load();
+        var snapshot = _componentSettingsStore.LoadForComponent(_componentId, _placementId);
         snapshot.DesktopClockTimeZoneId = normalizedId;
         snapshot.DesktopClockSecondHandMode = _secondHandMode;
-        _componentSettingsService.Save(snapshot);
+        _componentSettingsStore.SaveForComponent(_componentId, _placementId, snapshot);
 
         SettingsChanged?.Invoke(this, EventArgs.Empty);
     }

LanMountainDesktop/Views/Components/ClassScheduleSettingsWindow.axaml.cs

@@ -10,19 +10,22 @@ using Avalonia.Interactivity;
 using Avalonia.Layout;
 using Avalonia.Media;
 using Avalonia.Platform.Storage;
+using LanMountainDesktop.ComponentSystem;
 using LanMountainDesktop.Models;
 using LanMountainDesktop.Services;
 
 namespace LanMountainDesktop.Views.Components;
 
-public partial class ClassScheduleSettingsWindow : UserControl
+public partial class ClassScheduleSettingsWindow : UserControl, IComponentPlacementContextAware, IComponentSettingsStoreAware
 {
     private readonly AppSettingsService _appSettingsService = new();
-    private readonly ComponentSettingsService _componentSettingsService = new();
+    private IComponentInstanceSettingsStore _componentSettingsStore = new ComponentSettingsService();
     private readonly LocalizationService _localizationService = new();
     private readonly List<ImportedClassScheduleSnapshot> _importedSchedules = [];
     private string _activeScheduleId = string.Empty;
     private string _languageCode = "zh-CN";
+    private string _componentId = BuiltInComponentIds.DesktopClassSchedule;
+    private string _placementId = string.Empty;
 
     public event EventHandler? SettingsChanged;
 
@@ -34,10 +37,29 @@ public partial class ClassScheduleSettingsWindow : UserControl
         RenderImportedSchedules();
     }
 
+    public void SetComponentPlacementContext(string componentId, string? placementId)
+    {
+        _componentId = string.IsNullOrWhiteSpace(componentId)
+            ? BuiltInComponentIds.DesktopClassSchedule
+            : componentId.Trim();
+        _placementId = placementId?.Trim() ?? string.Empty;
+        LoadState();
+        ApplyLocalization();
+        RenderImportedSchedules();
+    }
+
+    public void SetComponentSettingsStore(IComponentInstanceSettingsStore settingsStore)
+    {
+        _componentSettingsStore = settingsStore ?? new ComponentSettingsService();
+        LoadState();
+        ApplyLocalization();
+        RenderImportedSchedules();
+    }
+
     private void LoadState()
     {
         var appSnapshot = _appSettingsService.Load();
-        var componentSnapshot = _componentSettingsService.Load();
+        var componentSnapshot = _componentSettingsStore.LoadForComponent(_componentId, _placementId);
         _languageCode = _localizationService.NormalizeLanguageCode(appSnapshot.LanguageCode);
 
         _importedSchedules.Clear();
@@ -299,7 +321,7 @@ public partial class ClassScheduleSettingsWindow : UserControl
 
     private void SaveState()
     {
-        var snapshot = _componentSettingsService.Load();
+        var snapshot = _componentSettingsStore.LoadForComponent(_componentId, _placementId);
         snapshot.ImportedClassSchedules = _importedSchedules
             .Select(item => new ImportedClassScheduleSnapshot
             {
@@ -309,7 +331,7 @@ public partial class ClassScheduleSettingsWindow : UserControl
             })
             .ToList();
         snapshot.ActiveImportedClassScheduleId = _activeScheduleId ?? string.Empty;
-        _componentSettingsService.Save(snapshot);
+        _componentSettingsStore.SaveForComponent(_componentId, _placementId, snapshot);
         SettingsChanged?.Invoke(this, EventArgs.Empty);
     }
 

LanMountainDesktop/Views/Components/ClassScheduleWidget.axaml.cs

@@ -7,12 +7,13 @@ using Avalonia.Controls;
 using Avalonia.Media;
 using Avalonia.Styling;
 using Avalonia.Threading;
+using LanMountainDesktop.ComponentSystem;
 using LanMountainDesktop.Models;
 using LanMountainDesktop.Services;
 
 namespace LanMountainDesktop.Views.Components;
 
-public partial class ClassScheduleWidget : UserControl, IDesktopComponentWidget, ITimeZoneAwareComponentWidget
+public partial class ClassScheduleWidget : UserControl, IDesktopComponentWidget, ITimeZoneAwareComponentWidget, IComponentPlacementContextAware, IComponentSettingsStoreAware
 {
     private sealed record CourseItemViewModel(
         string Name,
@@ -26,7 +27,7 @@ public partial class ClassScheduleWidget : UserControl, IDesktopComponentWidget,
     };
 
     private readonly AppSettingsService _appSettingsService = new();
-    private readonly ComponentSettingsService _componentSettingsService = new();
+    private IComponentInstanceSettingsStore _componentSettingsStore = new ComponentSettingsService();
     private readonly LocalizationService _localizationService = new();
     private readonly IClassIslandScheduleDataService _scheduleService = new ClassIslandScheduleDataService();
 
@@ -35,6 +36,8 @@ public partial class ClassScheduleWidget : UserControl, IDesktopComponentWidget,
     private IReadOnlyList<CourseItemViewModel> _courseItems = Array.Empty<CourseItemViewModel>();
     private bool _isNightVisual = true;
     private string _languageCode = "zh-CN";
+    private string _componentId = BuiltInComponentIds.DesktopClassSchedule;
+    private string _placementId = string.Empty;
 
     public ClassScheduleWidget()
     {
@@ -113,10 +116,25 @@ public partial class ClassScheduleWidget : UserControl, IDesktopComponentWidget,
         RefreshSchedule();
     }
 
+    public void SetComponentPlacementContext(string componentId, string? placementId)
+    {
+        _componentId = string.IsNullOrWhiteSpace(componentId)
+            ? BuiltInComponentIds.DesktopClassSchedule
+            : componentId.Trim();
+        _placementId = placementId?.Trim() ?? string.Empty;
+        RefreshSchedule();
+    }
+
+    public void SetComponentSettingsStore(IComponentInstanceSettingsStore settingsStore)
+    {
+        _componentSettingsStore = settingsStore ?? new ComponentSettingsService();
+        RefreshSchedule();
+    }
+
     private void RefreshSchedule()
     {
         var appSettings = _appSettingsService.Load();
-        var componentSettings = _componentSettingsService.Load();
+        var componentSettings = _componentSettingsStore.LoadForComponent(_componentId, _placementId);
         _languageCode = _localizationService.NormalizeLanguageCode(appSettings.LanguageCode);
         var now = _timeZoneService?.GetCurrentTime() ?? DateTime.Now;
         UpdateHeader(now);

LanMountainDesktop/Views/Components/DailyArtworkSettingsWindow.axaml.cs

@@ -2,18 +2,21 @@ using System;
 using Avalonia.Controls;
 using Avalonia.Controls.Primitives;
 using Avalonia.Interactivity;
+using LanMountainDesktop.ComponentSystem;
 using LanMountainDesktop.Models;
 using LanMountainDesktop.Services;
 
 namespace LanMountainDesktop.Views.Components;
 
-public partial class DailyArtworkSettingsWindow : UserControl
+public partial class DailyArtworkSettingsWindow : UserControl, IComponentPlacementContextAware, IComponentSettingsStoreAware
 {
     private readonly AppSettingsService _appSettingsService = new();
-    private readonly ComponentSettingsService _componentSettingsService = new();
+    private IComponentInstanceSettingsStore _componentSettingsStore = new ComponentSettingsService();
     private readonly LocalizationService _localizationService = new();
     private string _languageCode = "zh-CN";
     private bool _suppressEvents;
+    private string _componentId = BuiltInComponentIds.DesktopDailyArtwork;
+    private string _placementId = string.Empty;
 
     public event EventHandler? SettingsChanged;
 
@@ -24,10 +27,27 @@ public partial class DailyArtworkSettingsWindow : UserControl
         ApplyLocalization();
     }
 
+    public void SetComponentPlacementContext(string componentId, string? placementId)
+    {
+        _componentId = string.IsNullOrWhiteSpace(componentId)
+            ? BuiltInComponentIds.DesktopDailyArtwork
+            : componentId.Trim();
+        _placementId = placementId?.Trim() ?? string.Empty;
+        LoadState();
+        ApplyLocalization();
+    }
+
+    public void SetComponentSettingsStore(IComponentInstanceSettingsStore settingsStore)
+    {
+        _componentSettingsStore = settingsStore ?? new ComponentSettingsService();
+        LoadState();
+        ApplyLocalization();
+    }
+
     private void LoadState()
     {
         var appSnapshot = _appSettingsService.Load();
-        var componentSnapshot = _componentSettingsService.Load();
+        var componentSnapshot = _componentSettingsStore.LoadForComponent(_componentId, _placementId);
         _languageCode = _localizationService.NormalizeLanguageCode(appSnapshot.LanguageCode);
 
         var source = DailyArtworkMirrorSources.Normalize(componentSnapshot.DailyArtworkMirrorSource);
@@ -59,9 +79,9 @@ public partial class DailyArtworkSettingsWindow : UserControl
         }
 
         var source = GetSelectedSource();
-        var snapshot = _componentSettingsService.Load();
+        var snapshot = _componentSettingsStore.LoadForComponent(_componentId, _placementId);
         snapshot.DailyArtworkMirrorSource = source;
-        _componentSettingsService.Save(snapshot);
+        _componentSettingsStore.SaveForComponent(_componentId, _placementId, snapshot);
 
         UpdateSourceStatus(source);
         SettingsChanged?.Invoke(this, EventArgs.Empty);

LanMountainDesktop/Views/Components/DailyArtworkWidget.axaml.cs

@@ -13,12 +13,13 @@ using Avalonia.Input;
 using Avalonia.Media;
 using Avalonia.Media.Imaging;
 using Avalonia.Threading;
+using LanMountainDesktop.ComponentSystem;
 using LanMountainDesktop.Models;
 using LanMountainDesktop.Services;
 
 namespace LanMountainDesktop.Views.Components;
 
-public partial class DailyArtworkWidget : UserControl, IDesktopComponentWidget, IRecommendationInfoAwareComponentWidget
+public partial class DailyArtworkWidget : UserControl, IDesktopComponentWidget, IRecommendationInfoAwareComponentWidget, IComponentPlacementContextAware, IComponentSettingsStoreAware
 {
     private static readonly IReadOnlyDictionary<DayOfWeek, string> ZhWeekdays =
         new Dictionary<DayOfWeek, string>
@@ -58,6 +59,7 @@ public partial class DailyArtworkWidget : UserControl, IDesktopComponentWidget,
     };
 
     private readonly AppSettingsService _settingsService = new();
+    private IComponentInstanceSettingsStore _componentSettingsStore = new ComponentSettingsService();
     private readonly LocalizationService _localizationService = new();
 
     private IRecommendationInfoService _recommendationService = DefaultRecommendationService;
@@ -67,6 +69,8 @@ public partial class DailyArtworkWidget : UserControl, IDesktopComponentWidget,
     private double _currentCellSize = BaseCellSize;
     private bool _isAttached;
     private bool _isRefreshing;
+    private string _componentId = BuiltInComponentIds.DesktopDailyArtwork;
+    private string _placementId = string.Empty;
     private string? _currentArtworkSourceUrl;
     private string? _currentArtworkImageUrl;
 
@@ -136,6 +140,21 @@ public partial class DailyArtworkWidget : UserControl, IDesktopComponentWidget,
         }
     }
 
+    public void SetComponentPlacementContext(string componentId, string? placementId)
+    {
+        _componentId = string.IsNullOrWhiteSpace(componentId)
+            ? BuiltInComponentIds.DesktopDailyArtwork
+            : componentId.Trim();
+        _placementId = placementId?.Trim() ?? string.Empty;
+        RefreshFromSettings();
+    }
+
+    public void SetComponentSettingsStore(IComponentInstanceSettingsStore settingsStore)
+    {
+        _componentSettingsStore = settingsStore ?? new ComponentSettingsService();
+        RefreshFromSettings();
+    }
+
     private void OnAttachedToVisualTree(object? sender, VisualTreeAttachmentEventArgs e)
     {
         _isAttached = true;
@@ -203,6 +222,7 @@ public partial class DailyArtworkWidget : UserControl, IDesktopComponentWidget,
         {
             var query = new DailyArtworkQuery(
                 Locale: _languageCode,
+                MirrorSource: ResolveMirrorSource(),
                 ForceRefresh: forceRefresh);
             var result = await _recommendationService.GetDailyArtworkAsync(query, cts.Token);
             if (!_isAttached || cts.IsCancellationRequested)
@@ -640,6 +660,19 @@ public partial class DailyArtworkWidget : UserControl, IDesktopComponentWidget,
         }
     }
 
+    private string ResolveMirrorSource()
+    {
+        try
+        {
+            var snapshot = _componentSettingsStore.LoadForComponent(_componentId, _placementId);
+            return DailyArtworkMirrorSources.Normalize(snapshot.DailyArtworkMirrorSource);
+        }
+        catch
+        {
+            return DailyArtworkMirrorSources.Overseas;
+        }
+    }
+
     private void UpdateDateLabels()
     {
         var now = DateTime.Now;

LanMountainDesktop/Views/Components/DesktopComponentRuntimeRegistry.cs

@@ -7,24 +7,65 @@ using LanMountainDesktop.Services;
 
 namespace LanMountainDesktop.Views.Components;
 
-public sealed record DesktopComponentRuntimeRegistration(
-    string ComponentId,
-    string DisplayNameLocalizationKey,
-    Func<Control> ControlFactory,
-    Func<double, double>? CornerRadiusResolver = null);
+public sealed record DesktopComponentControlFactoryContext(
+    DesktopComponentDefinition Definition,
+    double CellSize,
+    TimeZoneService TimeZoneService,
+    IWeatherInfoService WeatherInfoService,
+    IRecommendationInfoService RecommendationInfoService,
+    ICalculatorDataService CalculatorDataService,
+    IComponentInstanceSettingsStore ComponentSettingsStore,
+    string? PlacementId = null);
+
+public sealed class DesktopComponentRuntimeRegistration
+{
+    public DesktopComponentRuntimeRegistration(
+        string componentId,
+        string? displayNameLocalizationKey,
+        Func<Control> controlFactory,
+        Func<double, double>? cornerRadiusResolver = null)
+        : this(componentId, displayNameLocalizationKey, _ => controlFactory(), cornerRadiusResolver)
+    {
+    }
+
+    public DesktopComponentRuntimeRegistration(
+        string componentId,
+        string? displayNameLocalizationKey,
+        Func<DesktopComponentControlFactoryContext, Control> controlFactory,
+        Func<double, double>? cornerRadiusResolver = null)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(componentId);
+        ArgumentNullException.ThrowIfNull(controlFactory);
+
+        ComponentId = componentId.Trim();
+        DisplayNameLocalizationKey = string.IsNullOrWhiteSpace(displayNameLocalizationKey)
+            ? null
+            : displayNameLocalizationKey.Trim();
+        ControlFactory = controlFactory;
+        CornerRadiusResolver = cornerRadiusResolver;
+    }
+
+    public string ComponentId { get; }
+
+    public string? DisplayNameLocalizationKey { get; }
+
+    public Func<DesktopComponentControlFactoryContext, Control> ControlFactory { get; }
+
+    public Func<double, double>? CornerRadiusResolver { get; }
+}
 
 public sealed class DesktopComponentRuntimeDescriptor
 {
     private static readonly Func<double, double> DefaultCornerRadiusResolver =
         cellSize => Math.Clamp(cellSize * 0.22, 8, 18);
 
-    private readonly Func<Control> _controlFactory;
+    private readonly Func<DesktopComponentControlFactoryContext, Control> _controlFactory;
     private readonly Func<double, double> _cornerRadiusResolver;
 
     internal DesktopComponentRuntimeDescriptor(
         DesktopComponentDefinition definition,
-        string displayNameLocalizationKey,
-        Func<Control> controlFactory,
+        string? displayNameLocalizationKey,
+        Func<DesktopComponentControlFactoryContext, Control> controlFactory,
         Func<double, double>? cornerRadiusResolver)
     {
         Definition = definition;
@@ -35,16 +76,48 @@ public sealed class DesktopComponentRuntimeDescriptor
 
     public DesktopComponentDefinition Definition { get; }
 
-    public string DisplayNameLocalizationKey { get; }
+    public string? DisplayNameLocalizationKey { get; }
 
     public Control CreateControl(
         double cellSize,
         TimeZoneService timeZoneService,
         IWeatherInfoService weatherInfoService,
         IRecommendationInfoService recommendationInfoService,
-        ICalculatorDataService calculatorDataService)
+        ICalculatorDataService calculatorDataService,
+        IComponentInstanceSettingsStore componentSettingsStore,
+        string? placementId = null)
     {
-        var control = _controlFactory();
+        var control = _controlFactory(new DesktopComponentControlFactoryContext(
+            Definition,
+            cellSize,
+            timeZoneService,
+            weatherInfoService,
+            recommendationInfoService,
+            calculatorDataService,
+            componentSettingsStore,
+            placementId));
+        var runtimeContext = new DesktopComponentRuntimeContext(
+            Definition.Id,
+            placementId,
+            componentSettingsStore);
+
+        if (control is IComponentRuntimeContextAware runtimeContextAwareComponent)
+        {
+            runtimeContextAwareComponent.SetComponentRuntimeContext(runtimeContext);
+        }
+
+        if (control is IComponentPlacementContextAware placementAwareComponent)
+        {
+            placementAwareComponent.SetComponentPlacementContext(Definition.Id, placementId);
+        }
+
+        if (control is IComponentSettingsStoreAware settingsStoreAwareComponent)
+        {
+            settingsStoreAwareComponent.SetComponentSettingsStore(componentSettingsStore);
+        }
+
+        ComponentSettingsService.ApplyScopedContextToTarget(control, Definition.Id, placementId);
+
         if (control is IDesktopComponentWidget sizedComponent)
         {
             sizedComponent.ApplyCellSize(cellSize);
@@ -109,12 +182,10 @@ public sealed class DesktopComponentRuntimeRegistry
                 StringComparer.OrdinalIgnoreCase);
     }
 
-    public static DesktopComponentRuntimeRegistry CreateDefault(ComponentRegistry componentRegistry)
+    public static IReadOnlyList<DesktopComponentRuntimeRegistration> GetDefaultRegistrations()
     {
-        return new DesktopComponentRuntimeRegistry(
-            componentRegistry,
-            new[]
-            {
+        return
+        [
                 new DesktopComponentRuntimeRegistration(
                     BuiltInComponentIds.Date,
                     "component.date",
@@ -295,7 +366,12 @@ public sealed class DesktopComponentRuntimeRegistry
                     "component.holiday_calendar",
                     () => new HolidayCalendarWidget(),
                     cellSize => Math.Clamp(cellSize * 0.32, 12, 28))
-            });
+        ];
+    }
+
+    public static DesktopComponentRuntimeRegistry CreateDefault(ComponentRegistry componentRegistry)
+    {
+        return new DesktopComponentRuntimeRegistry(componentRegistry, GetDefaultRegistrations());
     }
 
     public bool TryGetDescriptor(string componentId, out DesktopComponentRuntimeDescriptor descriptor)

LanMountainDesktop/Views/Components/ExtendedWeatherWidget.axaml.cs

@@ -9,13 +9,14 @@ using Avalonia;
 using Avalonia.Controls;
 using Avalonia.Media;
 using Avalonia.Threading;
+using LanMountainDesktop.ComponentSystem;
 using LanMountainDesktop.Models;
 using LanMountainDesktop.Services;
 using LanMountainDesktop.Theme;
 
 namespace LanMountainDesktop.Views.Components;
 
-public partial class ExtendedWeatherWidget : UserControl, IDesktopComponentWidget, IDesktopPageVisibilityAwareComponentWidget, ITimeZoneAwareComponentWidget, IWeatherInfoAwareComponentWidget
+public partial class ExtendedWeatherWidget : UserControl, IDesktopComponentWidget, IDesktopPageVisibilityAwareComponentWidget, ITimeZoneAwareComponentWidget, IWeatherInfoAwareComponentWidget, IComponentPlacementContextAware, IComponentSettingsStoreAware
 {
     private static readonly IWeatherInfoService DefaultWeatherInfoService = new XiaomiWeatherService();
     private static readonly IReadOnlyList<int> SupportedAutoRefreshIntervalsMinutes = RefreshIntervalCatalog.SupportedIntervalsMinutes;
@@ -25,7 +26,7 @@ public partial class ExtendedWeatherWidget : UserControl, IDesktopComponentWidge
     private readonly ScaleTransform _backgroundMotionScaleTransform = new(1, 1);
     private readonly TranslateTransform _backgroundMotionTranslateTransform = new();
     private readonly AppSettingsService _settingsService = new();
-    private readonly ComponentSettingsService _componentSettingsService = new();
+    private IComponentInstanceSettingsStore _componentSettingsStore = new ComponentSettingsService();
     private readonly LocalizationService _localizationService = new();
 
     private IWeatherInfoService _weatherInfoService = DefaultWeatherInfoService;
@@ -39,6 +40,8 @@ public partial class ExtendedWeatherWidget : UserControl, IDesktopComponentWidge
     private bool _autoRefreshEnabled = true;
     private string _languageCode = "zh-CN";
     private HyperOS3WeatherVisualKind _activeVisualKind = HyperOS3WeatherVisualKind.ClearDay;
+    private string _componentId = BuiltInComponentIds.DesktopExtendedWeather;
+    private string _placementId = string.Empty;
     private readonly TextBlock[] _hourlyTempBlocks;
     private readonly TextBlock[] _hourlyTimeBlocks;
     private readonly Image[] _hourlyIconBlocks;
@@ -173,6 +176,21 @@ public partial class ExtendedWeatherWidget : UserControl, IDesktopComponentWidge
         }
     }
 
+    public void SetComponentPlacementContext(string componentId, string? placementId)
+    {
+        _componentId = string.IsNullOrWhiteSpace(componentId)
+            ? BuiltInComponentIds.DesktopExtendedWeather
+            : componentId.Trim();
+        _placementId = placementId?.Trim() ?? string.Empty;
+        RefreshFromSettings();
+    }
+
+    public void SetComponentSettingsStore(IComponentInstanceSettingsStore settingsStore)
+    {
+        _componentSettingsStore = settingsStore ?? new ComponentSettingsService();
+        RefreshFromSettings();
+    }
+
     public void SetDesktopPageContext(bool isOnActivePage, bool isEditMode)
     {
         _ = isEditMode;
@@ -935,7 +953,7 @@ public partial class ExtendedWeatherWidget : UserControl, IDesktopComponentWidge
 
         try
         {
-            var snapshot = _componentSettingsService.Load();
+            var snapshot = _componentSettingsStore.LoadForComponent(_componentId, _placementId);
             enabled = snapshot.WeatherAutoRefreshEnabled;
             intervalMinutes = NormalizeAutoRefreshIntervalMinutes(snapshot.WeatherAutoRefreshIntervalMinutes);
         }

LanMountainDesktop/Views/Components/HourlyWeatherWidget.axaml.cs

@@ -11,13 +11,14 @@ using Avalonia.Media;
 using Avalonia.Media.Imaging;
 using Avalonia.Platform;
 using Avalonia.Threading;
+using LanMountainDesktop.ComponentSystem;
 using LanMountainDesktop.Models;
 using LanMountainDesktop.Services;
 using LanMountainDesktop.Theme;
 
 namespace LanMountainDesktop.Views.Components;
 
-public partial class HourlyWeatherWidget : UserControl, IDesktopComponentWidget, IDesktopPageVisibilityAwareComponentWidget, ITimeZoneAwareComponentWidget, IWeatherInfoAwareComponentWidget
+public partial class HourlyWeatherWidget : UserControl, IDesktopComponentWidget, IDesktopPageVisibilityAwareComponentWidget, ITimeZoneAwareComponentWidget, IWeatherInfoAwareComponentWidget, IComponentPlacementContextAware, IComponentSettingsStoreAware
 {
     private enum WeatherVisualKind
     {
@@ -95,7 +96,7 @@ public partial class HourlyWeatherWidget : UserControl, IDesktopComponentWidget,
     };
 
     private readonly AppSettingsService _settingsService = new();
-    private readonly ComponentSettingsService _componentSettingsService = new();
+    private IComponentInstanceSettingsStore _componentSettingsStore = new ComponentSettingsService();
     private readonly LocalizationService _localizationService = new();
     private readonly Dictionary<WeatherVisualKind, IBrush> _backgroundBrushCache = new();
     private readonly Dictionary<HyperOS3WeatherVisualKind, IBrush> _particleBrushCache = new();
@@ -118,6 +119,8 @@ public partial class HourlyWeatherWidget : UserControl, IDesktopComponentWidget,
     private bool _isOnActivePage = true;
     private bool _isRefreshing;
     private bool _autoRefreshEnabled = true;
+    private string _componentId = BuiltInComponentIds.DesktopHourlyWeather;
+    private string _placementId = string.Empty;
     private readonly TextBlock[] _hourlyTimeBlocks;
     private readonly Image[] _hourlyIconBlocks;
     private readonly TextBlock[] _hourlyTempBlocks;
@@ -224,6 +227,21 @@ public partial class HourlyWeatherWidget : UserControl, IDesktopComponentWidget,
         }
     }
 
+    public void SetComponentPlacementContext(string componentId, string? placementId)
+    {
+        _componentId = string.IsNullOrWhiteSpace(componentId)
+            ? BuiltInComponentIds.DesktopHourlyWeather
+            : componentId.Trim();
+        _placementId = placementId?.Trim() ?? string.Empty;
+        RefreshFromSettings();
+    }
+
+    public void SetComponentSettingsStore(IComponentInstanceSettingsStore settingsStore)
+    {
+        _componentSettingsStore = settingsStore ?? new ComponentSettingsService();
+        RefreshFromSettings();
+    }
+
     public void SetDesktopPageContext(bool isOnActivePage, bool isEditMode)
     {
         _ = isEditMode;
@@ -1424,7 +1442,7 @@ public partial class HourlyWeatherWidget : UserControl, IDesktopComponentWidget,
 
         try
         {
-            var snapshot = _componentSettingsService.Load();
+            var snapshot = _componentSettingsStore.LoadForComponent(_componentId, _placementId);
             enabled = snapshot.WeatherAutoRefreshEnabled;
             intervalMinutes = NormalizeAutoRefreshIntervalMinutes(snapshot.WeatherAutoRefreshIntervalMinutes);
         }

LanMountainDesktop/Views/Components/MultiDayWeatherWidget.axaml.cs

@@ -9,13 +9,14 @@ using Avalonia;
 using Avalonia.Controls;
 using Avalonia.Media;
 using Avalonia.Threading;
+using LanMountainDesktop.ComponentSystem;
 using LanMountainDesktop.Models;
 using LanMountainDesktop.Services;
 using LanMountainDesktop.Theme;
 
 namespace LanMountainDesktop.Views.Components;
 
-public partial class MultiDayWeatherWidget : UserControl, IDesktopComponentWidget, IDesktopPageVisibilityAwareComponentWidget, ITimeZoneAwareComponentWidget, IWeatherInfoAwareComponentWidget
+public partial class MultiDayWeatherWidget : UserControl, IDesktopComponentWidget, IDesktopPageVisibilityAwareComponentWidget, ITimeZoneAwareComponentWidget, IWeatherInfoAwareComponentWidget, IComponentPlacementContextAware, IComponentSettingsStoreAware
 {
     private enum WeatherVisualKind
     {
@@ -93,7 +94,7 @@ public partial class MultiDayWeatherWidget : UserControl, IDesktopComponentWidge
     };
 
     private readonly AppSettingsService _settingsService = new();
-    private readonly ComponentSettingsService _componentSettingsService = new();
+    private IComponentInstanceSettingsStore _componentSettingsStore = new ComponentSettingsService();
     private readonly LocalizationService _localizationService = new();
     private readonly Dictionary<WeatherVisualKind, IBrush> _backgroundBrushCache = new();
     private readonly Dictionary<HyperOS3WeatherVisualKind, IBrush> _particleBrushCache = new();
@@ -116,6 +117,8 @@ public partial class MultiDayWeatherWidget : UserControl, IDesktopComponentWidge
     private bool _isOnActivePage = true;
     private bool _isRefreshing;
     private bool _autoRefreshEnabled = true;
+    private string _componentId = BuiltInComponentIds.DesktopMultiDayWeather;
+    private string _placementId = string.Empty;
     private readonly TextBlock[] _hourlyTimeBlocks;
     private readonly Image[] _hourlyIconBlocks;
     private readonly TextBlock[] _hourlyTempBlocks;
@@ -222,6 +225,21 @@ public partial class MultiDayWeatherWidget : UserControl, IDesktopComponentWidge
         }
     }
 
+    public void SetComponentPlacementContext(string componentId, string? placementId)
+    {
+        _componentId = string.IsNullOrWhiteSpace(componentId)
+            ? BuiltInComponentIds.DesktopMultiDayWeather
+            : componentId.Trim();
+        _placementId = placementId?.Trim() ?? string.Empty;
+        RefreshFromSettings();
+    }
+
+    public void SetComponentSettingsStore(IComponentInstanceSettingsStore settingsStore)
+    {
+        _componentSettingsStore = settingsStore ?? new ComponentSettingsService();
+        RefreshFromSettings();
+    }
+
     public void SetDesktopPageContext(bool isOnActivePage, bool isEditMode)
     {
         _ = isEditMode;
@@ -1274,7 +1292,7 @@ public partial class MultiDayWeatherWidget : UserControl, IDesktopComponentWidge
 
         try
         {
-            var snapshot = _componentSettingsService.Load();
+            var snapshot = _componentSettingsStore.LoadForComponent(_componentId, _placementId);
             enabled = snapshot.WeatherAutoRefreshEnabled;
             intervalMinutes = NormalizeAutoRefreshIntervalMinutes(snapshot.WeatherAutoRefreshIntervalMinutes);
         }

LanMountainDesktop/Views/Components/StudyEnvironmentWidget.axaml.cs

@@ -64,8 +64,16 @@ public partial class StudyEnvironmentWidget : UserControl, IDesktopComponentWidg
     public void SetDesktopPageContext(bool isOnActivePage, bool isEditMode)
     {
         _ = isEditMode;
+        var wasOnActivePage = _isOnActivePage;
         _isOnActivePage = isOnActivePage;
+        
         UpdateMonitoringLeaseState();
+        
+        if (isOnActivePage && !wasOnActivePage)
+        {
+            RefreshVisual();
+        }
+        
         UpdateTimerState();
     }
 
@@ -116,8 +124,7 @@ public partial class StudyEnvironmentWidget : UserControl, IDesktopComponentWidg
 
     private void UpdateMonitoringLeaseState()
     {
-        var shouldMonitor = _isAttached && _isOnActivePage;
-        if (shouldMonitor)
+        if (_isAttached)
         {
             _monitoringLease ??= _monitoringLeaseCoordinator.AcquireLease();
             return;

LanMountainDesktop/Views/Components/StudyNoiseCurveWidget.axaml.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Globalization;
 using Avalonia;
@@ -11,7 +11,7 @@ using LanMountainDesktop.Theme;
 
 namespace LanMountainDesktop.Views.Components;
 
-public partial class StudyNoiseCurveWidget : UserControl, IDesktopComponentWidget, IDesktopPageVisibilityAwareComponentWidget
+public partial class StudyNoiseCurveWidget : UserControl, IDesktopComponentWidget, IDesktopPageVisibilityAwareComponentWidget, IDisposable
 {
     private const double NormalTextMinContrast = 4.5;
     private const double LargeTextMinContrast = 4.5;
@@ -69,6 +69,7 @@ public partial class StudyNoiseCurveWidget : UserControl, IDesktopComponentWidge
     private bool _isAttached;
     private bool _isOnActivePage = true;
     private bool _isSubscribed;
+    private bool _isDisposed;
     private int _framesSinceCompaction;
     private IDisposable? _monitoringLease;
 
@@ -131,8 +132,20 @@ public partial class StudyNoiseCurveWidget : UserControl, IDesktopComponentWidge
     public void SetDesktopPageContext(bool isOnActivePage, bool isEditMode)
     {
         _ = isEditMode;
+        var wasOnActivePage = _isOnActivePage;
         _isOnActivePage = isOnActivePage;
+        
         UpdateMonitoringLeaseState();
+        
+        if (isOnActivePage && !wasOnActivePage)
+        {
+            lock (_snapshotSync)
+            {
+                _pendingSnapshot = _studyAnalyticsService.GetSnapshot();
+                _hasPendingSnapshot = true;
+            }
+        }
+        
         UpdateRenderLoopState();
     }
 
@@ -231,8 +244,7 @@ public partial class StudyNoiseCurveWidget : UserControl, IDesktopComponentWidge
 
     private void UpdateMonitoringLeaseState()
     {
-        var shouldMonitor = _isAttached && _isOnActivePage;
-        if (shouldMonitor)
+        if (_isAttached)
         {
             _monitoringLease ??= _monitoringLeaseCoordinator.AcquireLease();
             return;
@@ -553,4 +565,29 @@ public partial class StudyNoiseCurveWidget : UserControl, IDesktopComponentWidge
     {
         return _localizationService.GetString(_languageCode, key, fallback);
     }
+
+    public void Dispose()
+    {
+        if (_isDisposed)
+        {
+            return;
+        }
+
+        _isDisposed = true;
+
+        _renderTimer.Stop();
+        _renderTimer.Tick -= OnRenderTimerTick;
+        AttachedToVisualTree -= OnAttachedToVisualTree;
+        DetachedFromVisualTree -= OnDetachedFromVisualTree;
+        SizeChanged -= OnSizeChanged;
+
+        if (_isSubscribed)
+        {
+            _studyAnalyticsService.SnapshotUpdated -= OnStudySnapshotUpdated;
+            _isSubscribed = false;
+        }
+
+        _monitoringLease?.Dispose();
+        _monitoringLease = null;
+    }
 }

LanMountainDesktop/Views/Components/StudyNoiseDistributionWidget.axaml.cs

@@ -93,8 +93,16 @@ public partial class StudyNoiseDistributionWidget : UserControl, IDesktopCompone
     public void SetDesktopPageContext(bool isOnActivePage, bool isEditMode)
     {
         _ = isEditMode;
+        var wasOnActivePage = _isOnActivePage;
         _isOnActivePage = isOnActivePage;
+        
         UpdateMonitoringLeaseState();
+        
+        if (isOnActivePage && !wasOnActivePage)
+        {
+            RefreshVisual();
+        }
+        
         UpdateTimerState();
     }
 
@@ -143,8 +151,7 @@ public partial class StudyNoiseDistributionWidget : UserControl, IDesktopCompone
 
     private void UpdateMonitoringLeaseState()
     {
-        var shouldMonitor = _isAttached && _isOnActivePage;
-        if (shouldMonitor)
+        if (_isAttached)
         {
             _monitoringLease ??= _monitoringLeaseCoordinator.AcquireLease();
             return;

LanMountainDesktop/Views/Components/StudySessionHistoryWidget.axaml.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Globalization;
 using Avalonia;
@@ -15,7 +15,7 @@ using LanMountainDesktop.Theme;
 
 namespace LanMountainDesktop.Views.Components;
 
-public partial class StudySessionHistoryWidget : UserControl, IDesktopComponentWidget, IDesktopPageVisibilityAwareComponentWidget
+public partial class StudySessionHistoryWidget : UserControl, IDesktopComponentWidget, IDesktopPageVisibilityAwareComponentWidget, IDisposable
 {
     private const double MinTextContrast = 4.5;
     private enum HistoryDialogMode
@@ -55,6 +55,7 @@ public partial class StudySessionHistoryWidget : UserControl, IDesktopComponentW
     private bool _isAttached;
     private bool _isOnActivePage = true;
     private bool _isSubscribed;
+    private bool _isDisposed;
     private bool _isCompactMode;
     private bool _isUltraCompactMode;
     private string? _loadingSessionId;
@@ -733,6 +734,29 @@ public partial class StudySessionHistoryWidget : UserControl, IDesktopComponentW
 
         return min;
     }
+
+    public void Dispose()
+    {
+        if (_isDisposed)
+        {
+            return;
+        }
+
+        _isDisposed = true;
+
+        AttachedToVisualTree -= OnAttachedToVisualTree;
+        DetachedFromVisualTree -= OnDetachedFromVisualTree;
+        SizeChanged -= OnSizeChanged;
+        DialogCancelButton.Click -= (_, _) => CloseDialog();
+        DialogConfirmButton.Click -= (_, _) => ConfirmDialog();
+        DialogRenameTextBox.KeyDown -= OnDialogRenameTextBoxKeyDown;
+
+        if (_isSubscribed)
+        {
+            _studyAnalyticsService.SnapshotUpdated -= OnStudySnapshotUpdated;
+            _isSubscribed = false;
+        }
+    }
 }
 
 

LanMountainDesktop/Views/Components/WeatherClockWidget.axaml.cs

@@ -10,12 +10,13 @@ using Avalonia.Controls.Shapes;
 using Avalonia.Media;
 using Avalonia.Styling;
 using Avalonia.Threading;
+using LanMountainDesktop.ComponentSystem;
 using LanMountainDesktop.Models;
 using LanMountainDesktop.Services;
 
 namespace LanMountainDesktop.Views.Components;
 
-public partial class WeatherClockWidget : UserControl, IDesktopComponentWidget, ITimeZoneAwareComponentWidget, IWeatherInfoAwareComponentWidget
+public partial class WeatherClockWidget : UserControl, IDesktopComponentWidget, ITimeZoneAwareComponentWidget, IWeatherInfoAwareComponentWidget, IComponentPlacementContextAware, IComponentSettingsStoreAware
 {
     private sealed record WeatherClockConfig(
         string LanguageCode,
@@ -41,7 +42,7 @@ public partial class WeatherClockWidget : UserControl, IDesktopComponentWidget,
     };
 
     private readonly AppSettingsService _settingsService = new();
-    private readonly ComponentSettingsService _componentSettingsService = new();
+    private IComponentInstanceSettingsStore _componentSettingsStore = new ComponentSettingsService();
     private readonly LocalizationService _localizationService = new();
     private readonly Line _hourHandLine = CreateHandLine("#232938", 4.0);
     private readonly Line _minuteHandLine = CreateHandLine("#2F3749", 2.8);
@@ -59,6 +60,8 @@ public partial class WeatherClockWidget : UserControl, IDesktopComponentWidget,
     private bool? _isNightModeApplied;
     private string _languageCode = "zh-CN";
     private HyperOS3WeatherVisualKind _activeVisualKind = HyperOS3WeatherVisualKind.CloudyDay;
+    private string _componentId = BuiltInComponentIds.DesktopWeatherClock;
+    private string _placementId = string.Empty;
 
     public WeatherClockWidget()
     {
@@ -116,6 +119,21 @@ public partial class WeatherClockWidget : UserControl, IDesktopComponentWidget,
         }
     }
 
+    public void SetComponentPlacementContext(string componentId, string? placementId)
+    {
+        _componentId = string.IsNullOrWhiteSpace(componentId)
+            ? BuiltInComponentIds.DesktopWeatherClock
+            : componentId.Trim();
+        _placementId = placementId?.Trim() ?? string.Empty;
+        RefreshFromSettings();
+    }
+
+    public void SetComponentSettingsStore(IComponentInstanceSettingsStore settingsStore)
+    {
+        _componentSettingsStore = settingsStore ?? new ComponentSettingsService();
+        RefreshFromSettings();
+    }
+
     public void ApplyCellSize(double cellSize)
     {
         _currentCellSize = Math.Max(1, cellSize);
@@ -659,7 +677,7 @@ public partial class WeatherClockWidget : UserControl, IDesktopComponentWidget,
 
         try
         {
-            var snapshot = _componentSettingsService.Load();
+            var snapshot = _componentSettingsStore.LoadForComponent(_componentId, _placementId);
             enabled = snapshot.WeatherAutoRefreshEnabled;
             intervalMinutes = NormalizeAutoRefreshIntervalMinutes(snapshot.WeatherAutoRefreshIntervalMinutes);
         }

LanMountainDesktop/Views/Components/WeatherWidget.axaml.cs

@@ -11,13 +11,14 @@ using Avalonia.Media;
 using Avalonia.Media.Imaging;
 using Avalonia.Platform;
 using Avalonia.Threading;
+using LanMountainDesktop.ComponentSystem;
 using LanMountainDesktop.Models;
 using LanMountainDesktop.Services;
 using LanMountainDesktop.Theme;
 
 namespace LanMountainDesktop.Views.Components;
 
-public partial class WeatherWidget : UserControl, IDesktopComponentWidget, IDesktopPageVisibilityAwareComponentWidget, ITimeZoneAwareComponentWidget, IWeatherInfoAwareComponentWidget
+public partial class WeatherWidget : UserControl, IDesktopComponentWidget, IDesktopPageVisibilityAwareComponentWidget, ITimeZoneAwareComponentWidget, IWeatherInfoAwareComponentWidget, IComponentPlacementContextAware, IComponentSettingsStoreAware
 {
     private enum WeatherVisualKind
     {
@@ -89,7 +90,7 @@ public partial class WeatherWidget : UserControl, IDesktopComponentWidget, IDesk
     };
 
     private readonly AppSettingsService _settingsService = new();
-    private readonly ComponentSettingsService _componentSettingsService = new();
+    private IComponentInstanceSettingsStore _componentSettingsStore = new ComponentSettingsService();
     private readonly LocalizationService _localizationService = new();
     private readonly Dictionary<WeatherVisualKind, IBrush> _backgroundBrushCache = new();
     private readonly Dictionary<HyperOS3WeatherVisualKind, IBrush> _particleBrushCache = new();
@@ -112,6 +113,8 @@ public partial class WeatherWidget : UserControl, IDesktopComponentWidget, IDesk
     private bool _isOnActivePage = true;
     private bool _isRefreshing;
     private bool _autoRefreshEnabled = true;
+    private string _componentId = BuiltInComponentIds.DesktopWeather;
+    private string _placementId = string.Empty;
 
     public WeatherWidget()
     {
@@ -167,6 +170,21 @@ public partial class WeatherWidget : UserControl, IDesktopComponentWidget, IDesk
         }
     }
 
+    public void SetComponentPlacementContext(string componentId, string? placementId)
+    {
+        _componentId = string.IsNullOrWhiteSpace(componentId)
+            ? BuiltInComponentIds.DesktopWeather
+            : componentId.Trim();
+        _placementId = placementId?.Trim() ?? string.Empty;
+        RefreshFromSettings();
+    }
+
+    public void SetComponentSettingsStore(IComponentInstanceSettingsStore settingsStore)
+    {
+        _componentSettingsStore = settingsStore ?? new ComponentSettingsService();
+        RefreshFromSettings();
+    }
+
     public void SetDesktopPageContext(bool isOnActivePage, bool isEditMode)
     {
         _ = isEditMode;
@@ -1063,7 +1081,7 @@ public partial class WeatherWidget : UserControl, IDesktopComponentWidget, IDesk
 
         try
         {
-            var snapshot = _componentSettingsService.Load();
+            var snapshot = _componentSettingsStore.LoadForComponent(_componentId, _placementId);
             enabled = snapshot.WeatherAutoRefreshEnabled;
             intervalMinutes = NormalizeAutoRefreshIntervalMinutes(snapshot.WeatherAutoRefreshIntervalMinutes);
         }

LanMountainDesktop/Views/Components/WeatherWidgetSettingsWindow.axaml.cs

@@ -4,20 +4,23 @@ using System.Linq;
 using Avalonia.Controls;
 using Avalonia.Controls.Primitives;
 using Avalonia.Interactivity;
+using LanMountainDesktop.ComponentSystem;
 using LanMountainDesktop.Models;
 using LanMountainDesktop.Services;
 
 namespace LanMountainDesktop.Views.Components;
 
-public partial class WeatherWidgetSettingsWindow : UserControl
+public partial class WeatherWidgetSettingsWindow : UserControl, IComponentPlacementContextAware, IComponentSettingsStoreAware
 {
     private static readonly IReadOnlyList<int> SupportedIntervals = RefreshIntervalCatalog.SupportedIntervalsMinutes;
 
     private readonly AppSettingsService _appSettingsService = new();
-    private readonly ComponentSettingsService _componentSettingsService = new();
+    private IComponentInstanceSettingsStore _componentSettingsStore = new ComponentSettingsService();
     private readonly LocalizationService _localizationService = new();
     private bool _suppressEvents;
     private string _languageCode = "zh-CN";
+    private string _componentId = BuiltInComponentIds.DesktopWeather;
+    private string _placementId = string.Empty;
 
     public event EventHandler? SettingsChanged;
 
@@ -29,10 +32,27 @@ public partial class WeatherWidgetSettingsWindow : UserControl
         ApplyLocalization();
     }
 
+    public void SetComponentPlacementContext(string componentId, string? placementId)
+    {
+        _componentId = string.IsNullOrWhiteSpace(componentId)
+            ? BuiltInComponentIds.DesktopWeather
+            : componentId.Trim();
+        _placementId = placementId?.Trim() ?? string.Empty;
+        LoadState();
+        ApplyLocalization();
+    }
+
+    public void SetComponentSettingsStore(IComponentInstanceSettingsStore settingsStore)
+    {
+        _componentSettingsStore = settingsStore ?? new ComponentSettingsService();
+        LoadState();
+        ApplyLocalization();
+    }
+
     private void LoadState()
     {
         var appSnapshot = _appSettingsService.Load();
-        var componentSnapshot = _componentSettingsService.Load();
+        var componentSnapshot = _componentSettingsStore.LoadForComponent(_componentId, _placementId);
         _languageCode = _localizationService.NormalizeLanguageCode(appSnapshot.LanguageCode);
 
         var enabled = componentSnapshot.WeatherAutoRefreshEnabled;
@@ -83,10 +103,10 @@ public partial class WeatherWidgetSettingsWindow : UserControl
 
     private void SaveState()
     {
-        var snapshot = _componentSettingsService.Load();
+        var snapshot = _componentSettingsStore.LoadForComponent(_componentId, _placementId);
         snapshot.WeatherAutoRefreshEnabled = AutoRefreshCheckBox.IsChecked == true;
         snapshot.WeatherAutoRefreshIntervalMinutes = GetSelectedInterval();
-        _componentSettingsService.Save(snapshot);
+        _componentSettingsStore.SaveForComponent(_componentId, _placementId, snapshot);
         SettingsChanged?.Invoke(this, EventArgs.Empty);
     }
 

LanMountainDesktop/Views/Components/WorldClockWidget.axaml.cs

@@ -8,11 +8,12 @@ using Avalonia.Layout;
 using Avalonia.Media;
 using Avalonia.Styling;
 using Avalonia.Threading;
+using LanMountainDesktop.ComponentSystem;
 using LanMountainDesktop.Services;
 
 namespace LanMountainDesktop.Views.Components;
 
-public partial class WorldClockWidget : UserControl, IDesktopComponentWidget, ITimeZoneAwareComponentWidget
+public partial class WorldClockWidget : UserControl, IDesktopComponentWidget, ITimeZoneAwareComponentWidget, IComponentPlacementContextAware, IComponentSettingsStoreAware
 {
     private const int BaseWidthCells = 4;
     private const int BaseHeightCells = 2;
@@ -92,7 +93,7 @@ public partial class WorldClockWidget : UserControl, IDesktopComponentWidget, IT
     };
 
     private readonly AppSettingsService _appSettingsService = new();
-    private readonly ComponentSettingsService _componentSettingsService = new();
+    private IComponentInstanceSettingsStore _componentSettingsStore = new ComponentSettingsService();
     private readonly LocalizationService _localizationService = new();
     private readonly ClockEntryVisual[] _entryVisuals = new ClockEntryVisual[WorldClockTimeZoneCatalog.ClockCount];
     private readonly TimeZoneInfo[] _entryTimeZones = new TimeZoneInfo[WorldClockTimeZoneCatalog.ClockCount];
@@ -103,6 +104,8 @@ public partial class WorldClockWidget : UserControl, IDesktopComponentWidget, IT
     private DateTime _nextLanguageProbeUtc = DateTime.MinValue;
     private string _secondHandMode = ClockSecondHandMode.Tick;
     private bool _isNightVisual = true;
+    private string _componentId = BuiltInComponentIds.DesktopWorldClock;
+    private string _placementId = string.Empty;
 
     public WorldClockWidget()
     {
@@ -147,6 +150,21 @@ public partial class WorldClockWidget : UserControl, IDesktopComponentWidget, IT
         UpdateClockVisuals();
     }
 
+    public void SetComponentPlacementContext(string componentId, string? placementId)
+    {
+        _componentId = string.IsNullOrWhiteSpace(componentId)
+            ? BuiltInComponentIds.DesktopWorldClock
+            : componentId.Trim();
+        _placementId = placementId?.Trim() ?? string.Empty;
+        RefreshFromSettings();
+    }
+
+    public void SetComponentSettingsStore(IComponentInstanceSettingsStore settingsStore)
+    {
+        _componentSettingsStore = settingsStore ?? new ComponentSettingsService();
+        RefreshFromSettings();
+    }
+
     public void ApplyCellSize(double cellSize)
     {
         _currentCellSize = Math.Max(1, cellSize);
@@ -525,7 +543,7 @@ public partial class WorldClockWidget : UserControl, IDesktopComponentWidget, IT
     private void LoadFromSettings()
     {
         var appSnapshot = _appSettingsService.Load();
-        var componentSnapshot = _componentSettingsService.Load();
+        var componentSnapshot = _componentSettingsStore.LoadForComponent(_componentId, _placementId);
         _languageCode = _localizationService.NormalizeLanguageCode(appSnapshot.LanguageCode);
 
         var ids = WorldClockTimeZoneCatalog.NormalizeTimeZoneIds(componentSnapshot.WorldClockTimeZoneIds);

LanMountainDesktop/Views/Components/WorldClockWidgetSettingsWindow.axaml.cs

@@ -4,11 +4,12 @@ using System.Linq;
 using Avalonia.Controls;
 using Avalonia.Controls.Primitives;
 using Avalonia.Interactivity;
+using LanMountainDesktop.ComponentSystem;
 using LanMountainDesktop.Services;
 
 namespace LanMountainDesktop.Views.Components;
 
-public partial class WorldClockWidgetSettingsWindow : UserControl
+public partial class WorldClockWidgetSettingsWindow : UserControl, IComponentPlacementContextAware, IComponentSettingsStoreAware
 {
     private static readonly IReadOnlyDictionary<string, string> ZhTimeZoneNames =
         new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
@@ -28,12 +29,14 @@ public partial class WorldClockWidgetSettingsWindow : UserControl
         };
 
     private readonly AppSettingsService _appSettingsService = new();
-    private readonly ComponentSettingsService _componentSettingsService = new();
+    private IComponentInstanceSettingsStore _componentSettingsStore = new ComponentSettingsService();
     private readonly LocalizationService _localizationService = new();
     private readonly TimeZoneService _timeZoneService = new();
     private readonly ComboBox[] _timeZoneComboBoxes;
     private bool _suppressEvents;
     private string _languageCode = "zh-CN";
+    private string _componentId = BuiltInComponentIds.DesktopWorldClock;
+    private string _placementId = string.Empty;
     private IReadOnlyList<TimeZoneInfo> _allTimeZones = Array.Empty<TimeZoneInfo>();
     private IReadOnlyList<string> _selectedTimeZoneIds = Array.Empty<string>();
     private string _secondHandMode = ClockSecondHandMode.Tick;
@@ -57,10 +60,29 @@ public partial class WorldClockWidgetSettingsWindow : UserControl
         PopulateTimeZoneComboBoxes();
     }
 
+    public void SetComponentPlacementContext(string componentId, string? placementId)
+    {
+        _componentId = string.IsNullOrWhiteSpace(componentId)
+            ? BuiltInComponentIds.DesktopWorldClock
+            : componentId.Trim();
+        _placementId = placementId?.Trim() ?? string.Empty;
+        LoadState();
+        ApplyLocalization();
+        PopulateTimeZoneComboBoxes();
+    }
+
+    public void SetComponentSettingsStore(IComponentInstanceSettingsStore settingsStore)
+    {
+        _componentSettingsStore = settingsStore ?? new ComponentSettingsService();
+        LoadState();
+        ApplyLocalization();
+        PopulateTimeZoneComboBoxes();
+    }
+
     private void LoadState()
     {
         var appSnapshot = _appSettingsService.Load();
-        var componentSnapshot = _componentSettingsService.Load();
+        var componentSnapshot = _componentSettingsStore.LoadForComponent(_componentId, _placementId);
         _languageCode = _localizationService.NormalizeLanguageCode(appSnapshot.LanguageCode);
 
         _allTimeZones = _timeZoneService
@@ -167,10 +189,10 @@ public partial class WorldClockWidgetSettingsWindow : UserControl
         var normalizedIds = WorldClockTimeZoneCatalog.NormalizeTimeZoneIds(selectedIds, _allTimeZones);
         _secondHandMode = GetSelectedSecondHandMode();
 
-        var snapshot = _componentSettingsService.Load();
+        var snapshot = _componentSettingsStore.LoadForComponent(_componentId, _placementId);
         snapshot.WorldClockTimeZoneIds = normalizedIds.ToList();
         snapshot.WorldClockSecondHandMode = _secondHandMode;
-        _componentSettingsService.Save(snapshot);
+        _componentSettingsStore.SaveForComponent(_componentId, _placementId, snapshot);
 
         _selectedTimeZoneIds = normalizedIds;
         SettingsChanged?.Invoke(this, EventArgs.Empty);

LanMountainDesktop/Views/MainWindow.ComponentSystem.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using Avalonia;
@@ -14,6 +14,7 @@ using FluentIcons.Avalonia;
 using FluentIcons.Common;
 using LanMountainDesktop.ComponentSystem;
 using LanMountainDesktop.Models;
+using LanMountainDesktop.Services;
 using LanMountainDesktop.Theme;
 using LanMountainDesktop.Views.Components;
 
@@ -255,14 +256,15 @@ public partial class MainWindow
             return TaskbarContext.Desktop;
         }
 
-        return SettingsNavListBox?.SelectedIndex switch
+        var selectedItem = SettingsNavView?.SelectedItem as FluentAvalonia.UI.Controls.NavigationViewItem;
+        return selectedItem?.Tag?.ToString() switch
         {
-            0 => TaskbarContext.SettingsWallpaper,
-            1 => TaskbarContext.SettingsGrid,
-            2 => TaskbarContext.SettingsColor,
-            3 => TaskbarContext.SettingsStatusBar,
-            4 => TaskbarContext.SettingsWeather,
-            5 => TaskbarContext.SettingsRegion,
+            "Wallpaper" => TaskbarContext.SettingsWallpaper,
+            "Grid" => TaskbarContext.SettingsGrid,
+            "Color" => TaskbarContext.SettingsColor,
+            "StatusBar" => TaskbarContext.SettingsStatusBar,
+            "Weather" => TaskbarContext.SettingsWeather,
+            "Region" => TaskbarContext.SettingsRegion,
             _ => TaskbarContext.Desktop
         };
     }
@@ -681,23 +683,34 @@ public partial class MainWindow
         }
 
         ClearTimeZoneServiceBindings(_selectedDesktopComponentHost);
+        DisposeComponentIfNeeded(_selectedDesktopComponentHost);
 
         if (_desktopPageComponentGrids.TryGetValue(placement.PageIndex, out var pageGrid))
         {
             pageGrid.Children.Remove(_selectedDesktopComponentHost);
         }
 
-        // Remove from persisted placement list as well.
         _desktopComponentPlacements.Remove(placement);
+        _componentSettingsService.DeleteForComponent(placement.ComponentId, placement.PlacementId);
 
         ClearDesktopComponentSelection();
 
         ApplyTaskbarActionVisibility(GetCurrentTaskbarContext());
 
-        // 娣囨繂鐡ㄧ拋鍓х枂
         PersistSettings();
     }
 
+    private static void DisposeComponentIfNeeded(Border host)
+    {
+        if (TryGetContentHost(host) is Border contentHost && contentHost.Child is Control componentControl)
+        {
+            if (componentControl is IDisposable disposableComponent)
+            {
+                disposableComponent.Dispose();
+            }
+        }
+    }
+
     private void OpenComponentSettings()
     {
         if (_selectedDesktopComponentHost is null || _selectedDesktopComponentHost.Tag is not string placementId)
@@ -714,80 +727,80 @@ public partial class MainWindow
 
         if (placement.ComponentId == BuiltInComponentIds.Date)
         {
-            OpenDateComponentSettings();
+            OpenDateComponentSettings(placement);
             return;
         }
 
         if (placement.ComponentId == BuiltInComponentIds.DesktopClock)
         {
-            OpenDesktopClockComponentSettings();
+            OpenDesktopClockComponentSettings(placement);
             return;
         }
 
         if (placement.ComponentId == BuiltInComponentIds.DesktopClassSchedule)
         {
-            OpenClassScheduleComponentSettings();
+            OpenClassScheduleComponentSettings(placement);
             return;
         }
 
         if (placement.ComponentId == BuiltInComponentIds.DesktopWorldClock)
         {
-            OpenWorldClockComponentSettings();
+            OpenWorldClockComponentSettings(placement);
             return;
         }
 
         if (IsWeatherComponentId(placement.ComponentId))
         {
-            OpenWeatherComponentSettings();
+            OpenWeatherComponentSettings(placement);
             return;
         }
 
         if (placement.ComponentId == BuiltInComponentIds.DesktopDailyArtwork)
         {
-            OpenDailyArtworkComponentSettings();
+            OpenDailyArtworkComponentSettings(placement);
             return;
         }
 
         if (placement.ComponentId == BuiltInComponentIds.DesktopCnrDailyNews)
         {
-            OpenCnrDailyNewsComponentSettings();
+            OpenCnrDailyNewsComponentSettings(placement);
             return;
         }
 
         if (placement.ComponentId == BuiltInComponentIds.DesktopIfengNews)
         {
-            OpenIfengNewsComponentSettings();
+            OpenIfengNewsComponentSettings(placement);
             return;
         }
 
         if (placement.ComponentId == BuiltInComponentIds.DesktopDailyWord ||
             placement.ComponentId == BuiltInComponentIds.DesktopDailyWord2x2)
         {
-            OpenDailyWordComponentSettings();
+            OpenDailyWordComponentSettings(placement);
             return;
         }
 
         if (placement.ComponentId == BuiltInComponentIds.DesktopBilibiliHotSearch)
         {
-            OpenBilibiliHotSearchComponentSettings();
+            OpenBilibiliHotSearchComponentSettings(placement);
             return;
         }
 
         if (placement.ComponentId == BuiltInComponentIds.DesktopBaiduHotSearch)
         {
-            OpenBaiduHotSearchComponentSettings();
+            OpenBaiduHotSearchComponentSettings(placement);
             return;
         }
 
         if (placement.ComponentId == BuiltInComponentIds.DesktopStcn24Forum)
         {
-            OpenStcn24ForumComponentSettings();
+            OpenStcn24ForumComponentSettings(placement);
             return;
         }
 
         if (placement.ComponentId == BuiltInComponentIds.DesktopStudyEnvironment)
         {
-            OpenStudyEnvironmentComponentSettings();
+            OpenStudyEnvironmentComponentSettings(placement);
             return;
         }
     }
@@ -801,212 +814,129 @@ public partial class MainWindow
                string.Equals(componentId, BuiltInComponentIds.DesktopExtendedWeather, StringComparison.OrdinalIgnoreCase);
     }
 
-    private void OpenDateComponentSettings()
+    private void ShowComponentSettings(Control settingsContent, DesktopComponentPlacementSnapshot placement)
     {
         if (ComponentSettingsWindow is null || ComponentSettingsContentHost is null)
         {
             return;
         }
 
-        var settingsContent = new DateWidgetSettingsWindow();
+        var runtimeContext = new DesktopComponentRuntimeContext(
+            placement.ComponentId,
+            placement.PlacementId,
+            _componentSettingsService);
+
+        if (settingsContent is IComponentRuntimeContextAware runtimeContextAwareComponent)
+        {
+            runtimeContextAwareComponent.SetComponentRuntimeContext(runtimeContext);
+        }
+
+        if (settingsContent is IComponentPlacementContextAware placementAwareComponent)
+        {
+            placementAwareComponent.SetComponentPlacementContext(placement.ComponentId, placement.PlacementId);
+        }
+
+        if (settingsContent is IComponentSettingsStoreAware settingsStoreAwareComponent)
+        {
+            settingsStoreAwareComponent.SetComponentSettingsStore(_componentSettingsService);
+        }
+
+        ComponentSettingsService.ApplyScopedContextToTarget(settingsContent, placement.ComponentId, placement.PlacementId);
+
         ComponentSettingsContentHost.Content = settingsContent;
-        
         ComponentSettingsWindow.IsVisible = true;
         ComponentSettingsWindow.Opacity = 0;
-        
         ComponentSettingsWindow.Opacity = 1;
     }
 
-    private void OpenClassScheduleComponentSettings()
+    private void OpenDateComponentSettings(DesktopComponentPlacementSnapshot placement)
     {
-        if (ComponentSettingsWindow is null || ComponentSettingsContentHost is null)
-        {
-            return;
-        }
+        var settingsContent = new DateWidgetSettingsWindow();
+        ShowComponentSettings(settingsContent, placement);
+    }
 
+    private void OpenClassScheduleComponentSettings(DesktopComponentPlacementSnapshot placement)
+    {
         var settingsContent = new ClassScheduleSettingsWindow();
         settingsContent.SettingsChanged += OnClassScheduleSettingsChanged;
-        ComponentSettingsContentHost.Content = settingsContent;
-
-        ComponentSettingsWindow.IsVisible = true;
-        ComponentSettingsWindow.Opacity = 0;
-        ComponentSettingsWindow.Opacity = 1;
+        ShowComponentSettings(settingsContent, placement);
     }
 
-    private void OpenDesktopClockComponentSettings()
+    private void OpenDesktopClockComponentSettings(DesktopComponentPlacementSnapshot placement)
     {
-        if (ComponentSettingsWindow is null || ComponentSettingsContentHost is null)
-        {
-            return;
-        }
-
         var settingsContent = new AnalogClockWidgetSettingsWindow();
         settingsContent.SettingsChanged += OnDesktopClockSettingsChanged;
-        ComponentSettingsContentHost.Content = settingsContent;
-
-        ComponentSettingsWindow.IsVisible = true;
-        ComponentSettingsWindow.Opacity = 0;
-        ComponentSettingsWindow.Opacity = 1;
+        ShowComponentSettings(settingsContent, placement);
     }
 
-    private void OpenWorldClockComponentSettings()
+    private void OpenWorldClockComponentSettings(DesktopComponentPlacementSnapshot placement)
     {
-        if (ComponentSettingsWindow is null || ComponentSettingsContentHost is null)
-        {
-            return;
-        }
-
         var settingsContent = new WorldClockWidgetSettingsWindow();
         settingsContent.SettingsChanged += OnWorldClockSettingsChanged;
-        ComponentSettingsContentHost.Content = settingsContent;
-
-        ComponentSettingsWindow.IsVisible = true;
-        ComponentSettingsWindow.Opacity = 0;
-        ComponentSettingsWindow.Opacity = 1;
+        ShowComponentSettings(settingsContent, placement);
     }
 
-    private void OpenWeatherComponentSettings()
+    private void OpenWeatherComponentSettings(DesktopComponentPlacementSnapshot placement)
     {
-        if (ComponentSettingsWindow is null || ComponentSettingsContentHost is null)
-        {
-            return;
-        }
-
         var settingsContent = new WeatherWidgetSettingsWindow();
         settingsContent.SettingsChanged += OnWeatherSettingsChanged;
-        ComponentSettingsContentHost.Content = settingsContent;
-
-        ComponentSettingsWindow.IsVisible = true;
-        ComponentSettingsWindow.Opacity = 0;
-        ComponentSettingsWindow.Opacity = 1;
+        ShowComponentSettings(settingsContent, placement);
     }
 
-    private void OpenStudyEnvironmentComponentSettings()
+    private void OpenStudyEnvironmentComponentSettings(DesktopComponentPlacementSnapshot placement)
     {
-        if (ComponentSettingsWindow is null || ComponentSettingsContentHost is null)
-        {
-            return;
-        }
-
         var settingsContent = new StudyEnvironmentWidgetSettingsWindow();
         settingsContent.SettingsChanged += OnStudyEnvironmentSettingsChanged;
-        ComponentSettingsContentHost.Content = settingsContent;
-
-        ComponentSettingsWindow.IsVisible = true;
-        ComponentSettingsWindow.Opacity = 0;
-        ComponentSettingsWindow.Opacity = 1;
+        ShowComponentSettings(settingsContent, placement);
     }
 
-    private void OpenDailyArtworkComponentSettings()
+    private void OpenDailyArtworkComponentSettings(DesktopComponentPlacementSnapshot placement)
     {
-        if (ComponentSettingsWindow is null || ComponentSettingsContentHost is null)
-        {
-            return;
-        }
-
         var settingsContent = new DailyArtworkSettingsWindow();
         settingsContent.SettingsChanged += OnDailyArtworkSettingsChanged;
-        ComponentSettingsContentHost.Content = settingsContent;
-
-        ComponentSettingsWindow.IsVisible = true;
-        ComponentSettingsWindow.Opacity = 0;
-        ComponentSettingsWindow.Opacity = 1;
+        ShowComponentSettings(settingsContent, placement);
     }
 
-    private void OpenCnrDailyNewsComponentSettings()
+    private void OpenCnrDailyNewsComponentSettings(DesktopComponentPlacementSnapshot placement)
     {
-        if (ComponentSettingsWindow is null || ComponentSettingsContentHost is null)
-        {
-            return;
-        }
-
         var settingsContent = new CnrDailyNewsSettingsWindow();
         settingsContent.SettingsChanged += OnCnrDailyNewsSettingsChanged;
-        ComponentSettingsContentHost.Content = settingsContent;
-
-        ComponentSettingsWindow.IsVisible = true;
-        ComponentSettingsWindow.Opacity = 0;
-        ComponentSettingsWindow.Opacity = 1;
+        ShowComponentSettings(settingsContent, placement);
     }
 
-    private void OpenIfengNewsComponentSettings()
+    private void OpenIfengNewsComponentSettings(DesktopComponentPlacementSnapshot placement)
     {
-        if (ComponentSettingsWindow is null || ComponentSettingsContentHost is null)
-        {
-            return;
-        }
-
         var settingsContent = new IfengNewsSettingsWindow();
         settingsContent.SettingsChanged += OnIfengNewsSettingsChanged;
-        ComponentSettingsContentHost.Content = settingsContent;
-
-        ComponentSettingsWindow.IsVisible = true;
-        ComponentSettingsWindow.Opacity = 0;
-        ComponentSettingsWindow.Opacity = 1;
+        ShowComponentSettings(settingsContent, placement);
     }
 
-    private void OpenDailyWordComponentSettings()
+    private void OpenDailyWordComponentSettings(DesktopComponentPlacementSnapshot placement)
     {
-        if (ComponentSettingsWindow is null || ComponentSettingsContentHost is null)
-        {
-            return;
-        }
-
         var settingsContent = new DailyWordSettingsWindow();
         settingsContent.SettingsChanged += OnDailyWordSettingsChanged;
-        ComponentSettingsContentHost.Content = settingsContent;
-
-        ComponentSettingsWindow.IsVisible = true;
-        ComponentSettingsWindow.Opacity = 0;
-        ComponentSettingsWindow.Opacity = 1;
+        ShowComponentSettings(settingsContent, placement);
     }
 
-    private void OpenBilibiliHotSearchComponentSettings()
+    private void OpenBilibiliHotSearchComponentSettings(DesktopComponentPlacementSnapshot placement)
     {
-        if (ComponentSettingsWindow is null || ComponentSettingsContentHost is null)
-        {
-            return;
-        }
-
         var settingsContent = new BilibiliHotSearchSettingsWindow();
         settingsContent.SettingsChanged += OnBilibiliHotSearchSettingsChanged;
-        ComponentSettingsContentHost.Content = settingsContent;
-
-        ComponentSettingsWindow.IsVisible = true;
-        ComponentSettingsWindow.Opacity = 0;
-        ComponentSettingsWindow.Opacity = 1;
+        ShowComponentSettings(settingsContent, placement);
     }
 
-    private void OpenBaiduHotSearchComponentSettings()
+    private void OpenBaiduHotSearchComponentSettings(DesktopComponentPlacementSnapshot placement)
     {
-        if (ComponentSettingsWindow is null || ComponentSettingsContentHost is null)
-        {
-            return;
-        }
-
         var settingsContent = new BaiduHotSearchSettingsWindow();
         settingsContent.SettingsChanged += OnBaiduHotSearchSettingsChanged;
-        ComponentSettingsContentHost.Content = settingsContent;
-
-        ComponentSettingsWindow.IsVisible = true;
-        ComponentSettingsWindow.Opacity = 0;
-        ComponentSettingsWindow.Opacity = 1;
+        ShowComponentSettings(settingsContent, placement);
     }
 
-    private void OpenStcn24ForumComponentSettings()
+    private void OpenStcn24ForumComponentSettings(DesktopComponentPlacementSnapshot placement)
     {
-        if (ComponentSettingsWindow is null || ComponentSettingsContentHost is null)
-        {
-            return;
-        }
-
         var settingsContent = new Stcn24ForumSettingsWindow();
         settingsContent.SettingsChanged += OnStcn24ForumSettingsChanged;
-        ComponentSettingsContentHost.Content = settingsContent;
-
-        ComponentSettingsWindow.IsVisible = true;
-        ComponentSettingsWindow.Opacity = 0;
-        ComponentSettingsWindow.Opacity = 1;
+        ShowComponentSettings(settingsContent, placement);
     }
 
     private void OnClassScheduleSettingsChanged(object? sender, EventArgs e)
@@ -1389,11 +1319,16 @@ public partial class MainWindow
         if (_desktopPageComponentGrids.TryGetValue(_currentDesktopSurfaceIndex, out var pageGrid))
         {
             ClearTimeZoneServiceBindings(pageGrid.Children.OfType<Control>().ToList());
+            foreach (var child in pageGrid.Children.OfType<Border>())
+            {
+                DisposeComponentIfNeeded(child);
+            }
         }
         
         foreach (var placement in placementsToRemove)
         {
             _desktopComponentPlacements.Remove(placement);
+            _componentSettingsService.DeleteForComponent(placement.ComponentId, placement.PlacementId);
         }
 
         _desktopPageCount = Math.Clamp(_desktopPageCount - 1, MinDesktopPageCount, MaxDesktopPageCount);
@@ -1417,7 +1352,7 @@ public partial class MainWindow
         ApplyTaskbarActionVisibility(GetCurrentTaskbarContext());
     }
 
-    private void InitializeDesktopComponentPlacements(AppSettingsSnapshot snapshot)
+    private void InitializeDesktopComponentPlacements(DesktopLayoutSettingsSnapshot snapshot)
     {
         _desktopComponentPlacements.Clear();
 
@@ -1587,7 +1522,7 @@ public partial class MainWindow
             placement.PlacementId = Guid.NewGuid().ToString("N");
         }
 
-        var component = CreateDesktopComponentControl(placement.ComponentId);
+        var component = CreateDesktopComponentControl(placement.ComponentId, placement.PlacementId);
         if (component is null)
         {
             return null;
@@ -2021,7 +1956,7 @@ public partial class MainWindow
         return onLeft || onRight || onTop || onBottom;
     }
 
-    private Control? CreateDesktopComponentControl(string componentId)
+    private Control? CreateDesktopComponentControl(string componentId, string? placementId = null)
     {
         if (!_componentRuntimeRegistry.TryGetDescriptor(componentId, out var runtimeDescriptor))
         {
@@ -2033,7 +1968,9 @@ public partial class MainWindow
             _timeZoneService,
             _weatherDataService,
             _recommendationInfoService,
-            _calculatorDataService);
+            _calculatorDataService,
+            _componentSettingsService,
+            placementId);
         component.Classes.Add(DesktopComponentClass);
         return component;
     }
@@ -3181,7 +3118,8 @@ public partial class MainWindow
                 _timeZoneService,
                 _weatherDataService,
                 _recommendationInfoService,
-                _calculatorDataService);
+                _calculatorDataService,
+                _componentSettingsService);
             // Component library previews must stay non-interactive so drag gesture is reliable.
             previewControl.IsHitTestVisible = false;
             previewControl.Focusable = false;
@@ -3278,7 +3216,9 @@ public partial class MainWindow
 
     private string GetLocalizedComponentDisplayName(DesktopComponentRuntimeDescriptor descriptor)
     {
-        return L(descriptor.DisplayNameLocalizationKey, descriptor.Definition.DisplayName);
+        return string.IsNullOrWhiteSpace(descriptor.DisplayNameLocalizationKey)
+            ? descriptor.Definition.DisplayName
+            : L(descriptor.DisplayNameLocalizationKey, descriptor.Definition.DisplayName);
     }
 
     private void OnComponentLibraryComponentPreviewPointerPressed(object? sender, PointerPressedEventArgs e)
@@ -3584,4 +3524,3 @@ public partial class MainWindow
         ApplyComponentLibraryComponentOffset();
     }
 }
-

LanMountainDesktop/Views/MainWindow.DesktopPaging.cs

@@ -66,14 +66,14 @@ public partial class MainWindow
 
     private int TotalSurfaceCount => LauncherSurfaceIndex + 1;
 
-    private void InitializeDesktopSurfaceState(AppSettingsSnapshot snapshot)
+    private void InitializeDesktopSurfaceState(DesktopLayoutSettingsSnapshot snapshot)
     {
         var loadedPageCount = snapshot.DesktopPageCount <= 0 ? MinDesktopPageCount : snapshot.DesktopPageCount;
         _desktopPageCount = Math.Clamp(loadedPageCount, MinDesktopPageCount, MaxDesktopPageCount);
         _currentDesktopSurfaceIndex = Math.Clamp(snapshot.CurrentDesktopSurfaceIndex, 0, LauncherSurfaceIndex);
     }
 
-    private void InitializeLauncherVisibilitySettings(AppSettingsSnapshot snapshot)
+    private void InitializeLauncherVisibilitySettings(LauncherSettingsSnapshot snapshot)
     {
         _hiddenLauncherFolderPaths.Clear();
         if (snapshot.HiddenLauncherFolderPaths is not null)

LanMountainDesktop/Views/MainWindow.Localization.cs

@@ -1,10 +1,12 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using Avalonia.Controls;
 using Avalonia.Interactivity;
 using Avalonia.Layout;
 using FluentIcons.Avalonia;
 using FluentIcons.Common;
+using LanMountainDesktop.Services;
 
 namespace LanMountainDesktop.Views;
 
@@ -107,16 +109,16 @@ public partial class MainWindow
         ToolTip.SetTip(LauncherFolderBackButton, L("common.back", "Back"));
         ToolTip.SetTip(LauncherFolderCloseButton, L("common.close", "Close"));
 
-        SettingsNavHeaderTextBlock.Text = L("settings.nav_header", "Settings");
-        SettingsNavWallpaperTextBlock.Text = L("settings.nav.wallpaper", "Wallpaper");
-        SettingsNavGridTextBlock.Text = L("settings.nav.grid", "Grid");
-        SettingsNavColorTextBlock.Text = L("settings.nav.color", "Color");
-        SettingsNavStatusBarTextBlock.Text = L("settings.nav.status_bar", "Status Bar");
-        SettingsNavWeatherTextBlock.Text = L("settings.nav.weather", "Weather");
-        SettingsNavRegionTextBlock.Text = L("settings.nav.region", "Region");
-        SettingsNavUpdateTextBlock.Text = L("settings.nav.update", "Update");
-        SettingsNavLauncherTextBlock.Text = L("settings.nav.launcher", "App Launcher");
-        SettingsNavPluginsTextBlock.Text = L("settings.nav.plugins", "Plugins");
+        // SettingsNavHeaderTextBlock no longer exists
+        SettingsNavWallpaperItem.Content = L("settings.nav.wallpaper", "Wallpaper");
+        SettingsNavGridItem.Content = L("settings.nav.grid", "Grid");
+        SettingsNavColorItem.Content = L("settings.nav.color", "Color");
+        SettingsNavStatusBarItem.Content = L("settings.nav.status_bar", "Status Bar");
+        SettingsNavWeatherItem.Content = L("settings.nav.weather", "Weather");
+        SettingsNavRegionItem.Content = L("settings.nav.region", "Region");
+        SettingsNavUpdateItem.Content = L("settings.nav.update", "Update");
+        SettingsNavLauncherItem.Content = L("settings.nav.launcher", "App Launcher");
+        SettingsNavPluginsItem.Content = L("settings.nav.plugins", "Plugins");
 
         WallpaperPanelTitleTextBlock.Text = L("settings.wallpaper.title", "Personalize your wallpaper");
         WallpaperPlacementSettingsExpander.Header = L("settings.wallpaper.placement_label", "Placement");
@@ -127,10 +129,10 @@ public partial class MainWindow
         ClearWallpaperButton.Content = L("settings.wallpaper.clear_button", "Reset");
 
         GridPanelTitleTextBlock.Text = L("settings.grid.title", "Grid Layout");
-        GridSpacingPresetLabelTextBlock.Text = L("settings.grid.spacing_label", "Grid Spacing");
+        GridSpacingSettingsExpander.Header = L("settings.grid.spacing_label", "Grid Spacing");
         GridSpacingRelaxedComboBoxItem.Content = L("settings.grid.spacing_relaxed", "Relaxed");
         GridSpacingCompactComboBoxItem.Content = L("settings.grid.spacing_compact", "Compact");
-        GridEdgeInsetLabelTextBlock.Text = L("settings.grid.edge_inset_label", "Screen Inset");
+        GridEdgeInsetSettingsExpander.Header = L("settings.grid.edge_inset_label", "Screen Inset");
         ApplyGridButton.Content = L("settings.grid.apply_button", "Apply");
         UpdateGridEdgeInsetComputedPxText(_currentDesktopCellSize);
 
@@ -175,7 +177,7 @@ public partial class MainWindow
         StatusBarSpacingModeCompactItem.Content = L("settings.status_bar.spacing_mode_compact", "Compact");
         StatusBarSpacingModeRelaxedItem.Content = L("settings.status_bar.spacing_mode_relaxed", "Relaxed");
         StatusBarSpacingModeCustomItem.Content = L("settings.status_bar.spacing_mode_custom", "Custom");
-        StatusBarSpacingCustomLabelTextBlock.Text = L("settings.status_bar.spacing_custom_label", "Custom spacing (%)");
+        StatusBarSpacingCustomPanel.Content = L("settings.status_bar.spacing_custom_label", "Custom spacing (%)");
 
         WeatherPanelTitleTextBlock.Text = L("settings.weather.title", "Weather");
         WeatherLocationSettingsExpander.Header = L("settings.weather.location_source_header", "Location Source");
@@ -212,6 +214,14 @@ public partial class MainWindow
             "Refresh and verify current weather service status.");
         WeatherPreviewButton.Content = L("settings.weather.refresh_button", "Refresh");
 
+        WeatherLocationSettingsExpander.Header = L("settings.weather.location_msg_header", "Location Source");
+        WeatherLocationSettingsExpander.Description = L(
+            "settings.weather.location_msg_desc",
+            "Choose how weather widgets resolve location.");
+        WeatherLocationModeCityChipItem.Content = L("settings.weather.mode_city", "City Search");
+        WeatherLocationModeCoordinatesChipItem.Content = L("settings.weather.mode_coordinates", "Coordinates");
+        WeatherAutoRefreshToggleSwitch.Content = L("settings.weather.auto_location_toggle", "Auto refresh location on startup");
+
         WeatherAlertFilterSettingsExpander.Header = L("settings.weather.alert_filter_header", "Excluded Alerts");
         WeatherAlertFilterSettingsExpander.Description = L(
             "settings.weather.alert_filter_desc",
@@ -248,6 +258,7 @@ public partial class MainWindow
 
         RegionPanelTitleTextBlock.Text = L("settings.region.title", "Region");
         LanguageSettingsExpander.Header = L("settings.region.language_header", "Language");
+        LanguageSettingsExpander.Description = L("settings.region.language_desc", "Select application language. Changes apply immediately.");
         LanguageChineseItem.Content = L("settings.region.language_zh", "Chinese");
         LanguageEnglishItem.Content = L("settings.region.language_en", "English");
         TimeZoneSettingsExpander.Header = L("settings.region.timezone_header", "Time Zone");
@@ -271,15 +282,24 @@ public partial class MainWindow
         PluginSystemSettingsExpander.Header = L("settings.plugins.runtime_header", "Plugin Runtime");
         PluginSystemSettingsExpander.Description = L(
             "settings.plugins.runtime_desc",
-            "Manage plugin loading and backend isolation.");
+            "Review plugin runtime state and load results.");
         PluginSystemDescriptionTextBlock.Text = L(
             "settings.plugins.runtime_hint",
-            "This page will host installed plugin management, permission review, and sandboxed backend runtime controls.");
+            "This page shows discovery status, load results, and runtime diagnostics for installed plugins.");
         PluginSystemStatusTextBlock.Text = L(
             "settings.plugins.runtime_status",
-            "Plugin management UI is not connected yet. Next step is wiring the loader, permissions, and worker isolation state into this panel.");
+            "Plugin runtime status will appear here after plugin discovery completes.");
+        InstalledPluginsSettingsExpander.Header = L("settings.plugins.installed_header", "Installed Plugins");
+        InstalledPluginsSettingsExpander.Description = L(
+            "settings.plugins.installed_desc",
+            "Enable or disable plugins here. Detailed plugin settings appear as separate settings pages.");
+        PluginRestartHintTextBlock.Text = L(
+            "settings.plugins.restart_hint",
+            "Plugin enable state changes take effect after restarting the app.");
+        PluginCatalogEmptyTextBlock.Text = L("settings.plugins.empty", "No plugins found.");
+        PluginSettingsPanel.RefreshFromRuntime();
 
-        SettingsNavAboutTextBlock.Text = L("settings.nav.about", "About");
+        SettingsNavAboutItem.Content = L("settings.nav.about", "About");
         AboutPanelTitleTextBlock.Text = L("settings.about.title", "About");
         VersionTextBlock.Text = Lf(
             "settings.about.version_format",
@@ -297,6 +317,15 @@ public partial class MainWindow
         AboutStartupSettingsExpander.Description = L(
             "settings.about.startup_desc",
             "Launch the app automatically when signing in to Windows.");
+        AboutRenderModeSettingsExpander.Header = L("settings.about.render_mode_header", "Rendering Mode");
+        AboutRenderModeSettingsExpander.Description = L(
+            "settings.about.render_mode_desc",
+            "Choose the rendering backend. Restart the app after changing this option. Unsupported modes fall back to software.");
+        SetAppRenderModeComboItemContent(AppRenderingModeHelper.Default, L("settings.about.render_mode.default", "Default"));
+        SetAppRenderModeComboItemContent(AppRenderingModeHelper.Software, L("settings.about.render_mode.software", "Software"));
+        SetAppRenderModeComboItemContent(AppRenderingModeHelper.AngleEgl, L("settings.about.render_mode.angle_egl", "angleEgl"));
+        SetAppRenderModeComboItemContent(AppRenderingModeHelper.Wgl, L("settings.about.render_mode.wgl", "WGL"));
+        SetAppRenderModeComboItemContent(AppRenderingModeHelper.Vulkan, L("settings.about.render_mode.vulkan", "Vulkan"));
 
         if (WallpaperPlacementComboBox?.ItemCount >= 5)
         {
@@ -323,6 +352,19 @@ public partial class MainWindow
         UpdateWallpaperDisplay();
     }
 
+    private void SetAppRenderModeComboItemContent(string tag, string content)
+    {
+        var item = AppRenderModeComboBox.Items
+            .OfType<ComboBoxItem>()
+            .FirstOrDefault(candidate =>
+                string.Equals(candidate.Tag?.ToString(), tag, StringComparison.OrdinalIgnoreCase));
+
+        if (item is not null)
+        {
+            item.Content = content;
+        }
+    }
+
     private string GetLocalizedTimeZoneDisplayName(TimeZoneInfo timeZone)
     {
         var offset = timeZone.GetUtcOffset(DateTime.UtcNow);
@@ -419,3 +461,4 @@ public partial class MainWindow
                 : _weatherLocationKey);
     }
 }
+

LanMountainDesktop/Views/MainWindow.PluginSettings.cs

@@ -0,0 +1,193 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Media;
+using FluentAvalonia.UI.Controls;
+using FluentIcons.Avalonia.Fluent;
+using FluentIcons.Common;
+using LanMountainDesktop.Models;
+using LanMountainDesktop.Services;
+
+namespace LanMountainDesktop.Views;
+
+public partial class MainWindow
+{
+    private readonly Dictionary<string, Control> _pluginSettingsPageHosts = new(StringComparer.OrdinalIgnoreCase);
+
+    private void InitializePluginSettingsNavigation()
+    {
+        if (_pluginSettingsPageHosts.Count > 0 || SettingsNavView?.MenuItems is null)
+        {
+            return;
+        }
+
+        var runtime = (Application.Current as App)?.PluginRuntimeService;
+        var contributions = runtime?.SettingsPages
+            .OrderBy(contribution => contribution.Registration.SortOrder)
+            .ThenBy(contribution => contribution.Plugin.Manifest.Name, StringComparer.OrdinalIgnoreCase)
+            .ThenBy(contribution => contribution.Registration.Title, StringComparer.OrdinalIgnoreCase)
+            .ToArray();
+
+        if (contributions is not { Length: > 0 })
+        {
+            return;
+        }
+
+        var pageCountsByPluginId = contributions
+            .GroupBy(contribution => contribution.Plugin.Manifest.Id, StringComparer.OrdinalIgnoreCase)
+            .ToDictionary(group => group.Key, group => group.Count(), StringComparer.OrdinalIgnoreCase);
+
+        var insertIndex = SettingsNavView.MenuItems.IndexOf(SettingsNavPluginsItem) + 1;
+        foreach (var contribution in contributions)
+        {
+            var tag = BuildPluginSettingsTag(contribution);
+            var navigationTitle = BuildPluginSettingsNavigationTitle(contribution, pageCountsByPluginId);
+            var navItem = new NavigationViewItem
+            {
+                Content = navigationTitle,
+                Tag = tag,
+                IconSource = new FluentIcons.Avalonia.Fluent.SymbolIconSource
+                {
+                    Symbol = FluentIcons.Common.Symbol.PuzzlePiece,
+                    IconVariant = FluentIcons.Common.IconVariant.Regular
+                }
+            };
+
+            ToolTip.SetTip(navItem, $"{contribution.Plugin.Manifest.Name} - {contribution.Registration.Title}");
+
+            SettingsNavView.MenuItems.Insert(insertIndex++, navItem);
+
+            var pageHost = CreatePluginSettingsPageHost(contribution);
+            pageHost.IsVisible = false;
+            SettingsContentPagesHost.Children.Add(pageHost);
+            _pluginSettingsPageHosts[tag] = pageHost;
+        }
+    }
+
+    private static string BuildPluginSettingsTag(PluginSettingsPageContribution contribution)
+    {
+        return $"PluginPage:{contribution.Plugin.Manifest.Id}:{contribution.Registration.Id}";
+    }
+
+    private static string BuildPluginSettingsNavigationTitle(
+        PluginSettingsPageContribution contribution,
+        IReadOnlyDictionary<string, int> pageCountsByPluginId)
+    {
+        return pageCountsByPluginId.TryGetValue(contribution.Plugin.Manifest.Id, out var pageCount) && pageCount > 1
+            ? $"{contribution.Plugin.Manifest.Name} - {contribution.Registration.Title}"
+            : contribution.Plugin.Manifest.Name;
+    }
+
+    private Control CreatePluginSettingsPageHost(PluginSettingsPageContribution contribution)
+    {
+        Control content;
+        try
+        {
+            content = contribution.Registration.ContentFactory();
+        }
+        catch (Exception ex)
+        {
+            content = CreatePluginPageErrorContent(ex);
+        }
+
+        return new StackPanel
+        {
+            Spacing = 16,
+            Children =
+            {
+                new TextBlock
+                {
+                    Text = contribution.Registration.Title,
+                    FontSize = 24,
+                    FontWeight = FontWeight.SemiBold,
+                    Foreground = GetThemeBrush("AdaptiveTextPrimaryBrush")
+                },
+                new TextBlock
+                {
+                    Text = contribution.Plugin.Manifest.Name,
+                    Foreground = GetThemeBrush("AdaptiveTextSecondaryBrush")
+                },
+                content
+            }
+        };
+    }
+
+    private Control CreatePluginPageErrorContent(Exception exception)
+    {
+        return new Border
+        {
+            Background = new SolidColorBrush(Color.Parse("#332B0F16")),
+            BorderBrush = new SolidColorBrush(Color.Parse("#66F97316")),
+            BorderThickness = new Thickness(1),
+            CornerRadius = new CornerRadius(16),
+            Padding = new Thickness(16),
+            Child = new TextBlock
+            {
+                Text = exception.Message,
+                TextWrapping = TextWrapping.Wrap
+            }
+        };
+    }
+
+    private void UpdatePluginSettingsPageVisibility(string? selectedTag)
+    {
+        foreach (var pair in _pluginSettingsPageHosts)
+        {
+            pair.Value.IsVisible = string.Equals(pair.Key, selectedTag, StringComparison.OrdinalIgnoreCase);
+        }
+    }
+
+    private string? GetSelectedSettingsTabTag()
+    {
+        return (SettingsNavView?.SelectedItem as NavigationViewItem)?.Tag?.ToString();
+    }
+
+    private int ResolveSelectedSettingsTabIndex()
+    {
+        if (SettingsNavView?.SelectedItem is null || SettingsNavView.MenuItems is null)
+        {
+            return 0;
+        }
+
+        for (var i = 0; i < SettingsNavView.MenuItems.Count; i++)
+        {
+            if (ReferenceEquals(SettingsNavView.MenuItems[i], SettingsNavView.SelectedItem))
+            {
+                return i;
+            }
+        }
+
+        return 0;
+    }
+
+    private void RestoreSettingsTabSelection(AppSettingsSnapshot snapshot)
+    {
+        if (SettingsNavView?.MenuItems is null || SettingsNavView.MenuItems.Count == 0)
+        {
+            return;
+        }
+
+        if (!string.IsNullOrWhiteSpace(snapshot.SettingsTabTag))
+        {
+            var taggedItem = SettingsNavView.MenuItems
+                .OfType<NavigationViewItem>()
+                .FirstOrDefault(item => string.Equals(item.Tag?.ToString(), snapshot.SettingsTabTag, StringComparison.OrdinalIgnoreCase));
+            if (taggedItem is not null)
+            {
+                SettingsNavView.SelectedItem = taggedItem;
+                return;
+            }
+        }
+
+        var safeIndex = Math.Clamp(snapshot.SettingsTabIndex, 0, Math.Max(0, SettingsNavView.MenuItems.Count - 1));
+        if (SettingsNavView.MenuItems[safeIndex] is NavigationViewItem navItem)
+        {
+            SettingsNavView.SelectedItem = navItem;
+        }
+    }
+}
+
+
+

LanMountainDesktop/Views/MainWindow.Settings.cs

@@ -1,5 +1,6 @@
 using System;
 using FluentIcons.Avalonia;
+using FluentIcons.Avalonia.Fluent;
 using FluentIcons.Common;
 using LanMountainDesktop.Views.Components;
 
@@ -19,6 +20,7 @@ using Avalonia.Platform;
 using Avalonia.Platform.Storage;
 using Avalonia.Styling;
 using Avalonia.Threading;
+using LanMountainDesktop.ComponentSystem;
 using LanMountainDesktop.Models;
 using LanMountainDesktop.Services;
 using LanMountainDesktop.Theme;
@@ -28,6 +30,47 @@ namespace LanMountainDesktop.Views;
 
 public partial class MainWindow
 {
+    private void OnExternalAppSettingsSaved(string sourceInstanceId)
+    {
+        if (string.Equals(sourceInstanceId, _appSettingsService.InstanceId, StringComparison.Ordinal))
+        {
+            return;
+        }
+
+        ScheduleReloadFromExternalSettings();
+    }
+
+    private void OnExternalLauncherSettingsSaved(string sourceInstanceId)
+    {
+        if (string.Equals(sourceInstanceId, _launcherSettingsService.InstanceId, StringComparison.Ordinal))
+        {
+            return;
+        }
+
+        ScheduleReloadFromExternalSettings();
+    }
+
+    private void ScheduleReloadFromExternalSettings()
+    {
+        if (_externalSettingsReloadPending)
+        {
+            return;
+        }
+
+        _externalSettingsReloadPending = true;
+        Dispatcher.UIThread.Post(() =>
+        {
+            _externalSettingsReloadPending = false;
+
+            if (!IsVisible)
+            {
+                return;
+            }
+
+            ReloadFromPersistedSettings();
+        }, DispatcherPriority.Background);
+    }
+
     private void OnOpenSettingsClick(object? sender, RoutedEventArgs e)
     {
         if (_isComponentLibraryOpen)
@@ -49,16 +92,20 @@ public partial class MainWindow
         CloseSettingsPage();
     }
 
-    private void OnSettingsNavSelectionChanged(object? sender, SelectionChangedEventArgs e)
+    private void OnSettingsNavSelectionChanged(object? sender, FluentAvalonia.UI.Controls.NavigationViewSelectionChangedEventArgs e)
     {
         UpdateSettingsTabContent();
         PersistSettings();
     }
 
+    private int GetSettingsTabIndex()
+    {
+        return ResolveSelectedSettingsTabIndex();
+    }
+
     private void UpdateSettingsTabContent()
     {
-        // SelectionChanged can fire during XAML initialization before all named controls are assigned.
-        if (SettingsNavListBox is null ||
+        if (SettingsNavView is null ||
             GridSettingsPanel is null ||
             WallpaperSettingsPanel is null ||
             ColorSettingsPanel is null ||
@@ -73,24 +120,27 @@ public partial class MainWindow
             return;
         }
 
-        var selectedIndex = SettingsNavListBox.SelectedIndex;
-        WallpaperSettingsPanel.IsVisible = selectedIndex == 0;
-        GridSettingsPanel.IsVisible = selectedIndex == 1;
-        ColorSettingsPanel.IsVisible = selectedIndex == 2;
-        StatusBarSettingsPanel.IsVisible = selectedIndex == 3;
-        WeatherSettingsPanel.IsVisible = selectedIndex == 4;
-        RegionSettingsPanel.IsVisible = selectedIndex == 5;
-        UpdateSettingsPanel.IsVisible = selectedIndex == 6;
-        AboutSettingsPanel.IsVisible = selectedIndex == 7;
-        LauncherSettingsPanel.IsVisible = selectedIndex == 8;
-        PluginSettingsPanel.IsVisible = selectedIndex == 9;
+        var selectedItem = SettingsNavView.SelectedItem as FluentAvalonia.UI.Controls.NavigationViewItem;
+        var tag = selectedItem?.Tag?.ToString();
 
-        if (selectedIndex == 8)
+        WallpaperSettingsPanel.IsVisible = tag == "Wallpaper";
+        GridSettingsPanel.IsVisible = tag == "Grid";
+        ColorSettingsPanel.IsVisible = tag == "Color";
+        StatusBarSettingsPanel.IsVisible = tag == "StatusBar";
+        WeatherSettingsPanel.IsVisible = tag == "Weather";
+        RegionSettingsPanel.IsVisible = tag == "Region";
+        UpdateSettingsPanel.IsVisible = tag == "Update";
+        AboutSettingsPanel.IsVisible = tag == "About";
+        LauncherSettingsPanel.IsVisible = tag == "Launcher";
+        PluginSettingsPanel.IsVisible = tag == "Plugins";
+        UpdatePluginSettingsPageVisibility(tag);
+
+        if (tag == "Launcher")
         {
             RenderLauncherHiddenItemsList();
         }
 
-        if (selectedIndex == 1)
+        if (tag == "Grid")
         {
             UpdateGridPreviewLayout();
         }
@@ -864,47 +914,162 @@ public partial class MainWindow
             return;
         }
 
-        var snapshot = new AppSettingsSnapshot
+        _appSettingsService.Save(BuildAppSettingsSnapshot());
+        _desktopLayoutSettingsService.Save(BuildDesktopLayoutSettingsSnapshot());
+        _launcherSettingsService.Save(BuildLauncherSettingsSnapshot());
+
+    }
+
+    internal void ReloadFromPersistedSettings()
+    {
+        _suppressSettingsPersistence = true;
+        try
+        {
+            var snapshot = _appSettingsService.Load();
+            var desktopLayoutSnapshot = _desktopLayoutSettingsService.Load();
+            var launcherSnapshot = _launcherSettingsService.Load();
+
+            if (!string.IsNullOrWhiteSpace(snapshot.TimeZoneId))
+            {
+                _timeZoneService.SetTimeZoneById(snapshot.TimeZoneId);
+            }
+
+            _targetShortSideCells = Math.Clamp(
+                snapshot.GridShortSideCells > 0 ? snapshot.GridShortSideCells : CalculateDefaultShortSideCellCountFromDpi(),
+                MinShortSideCells,
+                MaxShortSideCells);
+
+            _gridSpacingPreset = NormalizeGridSpacingPreset(snapshot.GridSpacingPreset);
+            _suppressGridSpacingEvents = true;
+            GridSpacingPresetComboBox.SelectedIndex =
+                string.Equals(_gridSpacingPreset, "Compact", StringComparison.OrdinalIgnoreCase) ? 1 : 0;
+            _suppressGridSpacingEvents = false;
+
+            _desktopEdgeInsetPercent = Math.Clamp(snapshot.DesktopEdgeInsetPercent, MinEdgeInsetPercent, MaxEdgeInsetPercent);
+            _suppressGridInsetEvents = true;
+            GridEdgeInsetSlider.Value = _desktopEdgeInsetPercent;
+            GridEdgeInsetNumberBox.Value = _desktopEdgeInsetPercent;
+            _suppressGridInsetEvents = false;
+
+            _statusBarSpacingMode = NormalizeStatusBarSpacingMode(snapshot.StatusBarSpacingMode);
+            _statusBarCustomSpacingPercent = Math.Clamp(snapshot.StatusBarCustomSpacingPercent, 0, 30);
+            _suppressStatusBarSpacingEvents = true;
+            StatusBarSpacingModeComboBox.SelectedIndex = _statusBarSpacingMode switch
+            {
+                "Compact" => 0,
+                "Custom" => 2,
+                _ => 1
+            };
+            StatusBarSpacingSlider.Value = _statusBarCustomSpacingPercent;
+            StatusBarSpacingNumberBox.Value = _statusBarCustomSpacingPercent;
+            StatusBarSpacingCustomPanel.IsVisible = string.Equals(_statusBarSpacingMode, "Custom", StringComparison.OrdinalIgnoreCase);
+            _suppressStatusBarSpacingEvents = false;
+
+            GridSizeNumberBox.Value = _targetShortSideCells;
+            GridSizeSlider.Value = _targetShortSideCells;
+
+            RestoreSettingsTabSelection(snapshot);
+
+            UpdateSettingsTabContent();
+            WallpaperPlacementComboBox.SelectedIndex = GetPlacementIndexFromSetting(snapshot.WallpaperPlacement);
+            _defaultDesktopBackground = DesktopWallpaperLayer.Background;
+            ApplyTaskbarSettings(snapshot);
+            InitializeLocalization(snapshot.LanguageCode);
+            InitializeWeatherSettings(snapshot);
+            _ = _componentSettingsService.Load();
+            InitializeAutoStartWithWindowsSetting(snapshot);
+            InitializeAppRenderModeSetting(snapshot);
+            InitializeUpdateSettings(snapshot);
+            InitializeDesktopSurfaceState(desktopLayoutSnapshot);
+            InitializeLauncherVisibilitySettings(launcherSnapshot);
+            InitializeDesktopComponentPlacements(desktopLayoutSnapshot);
+            InitializeSettingsIcons();
+
+            TryRestoreWallpaper(snapshot.WallpaperPath);
+            ApplyWallpaperBrush();
+            UpdateWallpaperDisplay();
+
+            if (TryParseColor(snapshot.ThemeColor, out var savedThemeColor))
+            {
+                _selectedThemeColor = savedThemeColor;
+            }
+
+            _isNightMode = snapshot.IsNightMode ?? (CalculateCurrentBackgroundLuminance() < LightBackgroundLuminanceThreshold);
+            ApplyNightModeState(_isNightMode, refreshPalettes: true);
+            _suppressStatusBarToggleEvents = true;
+            StatusBarClockToggleSwitch.IsChecked = _topStatusComponentIds.Contains(BuiltInComponentIds.Clock);
+            _suppressStatusBarToggleEvents = false;
+            ApplyLocalization();
+            ThemeColorStatusTextBlock.Text = Lf("settings.color.theme_ready_format", "Theme color ready: {0}.", _selectedThemeColor);
+            RebuildDesktopGrid();
+            LoadLauncherEntriesAsync();
+            InitializeTimeZoneSettings();
+            ClockWidget.SetTimeZoneService(_timeZoneService);
+            UpdateWallpaperPreviewLayout();
+            UpdateGridPreviewLayout();
+            UpdateAdaptiveTextSystem();
+            ApplyTaskbarActionVisibility(GetCurrentTaskbarContext());
+        }
+        finally
+        {
+            _suppressSettingsPersistence = false;
+        }
+    }
+
+    private AppSettingsSnapshot BuildAppSettingsSnapshot()
+    {
+        var snapshot = _appSettingsService.Load();
+        snapshot.GridShortSideCells = _targetShortSideCells;
+        snapshot.GridSpacingPreset = _gridSpacingPreset;
+        snapshot.DesktopEdgeInsetPercent = _desktopEdgeInsetPercent;
+        snapshot.IsNightMode = _isNightMode;
+        snapshot.ThemeColor = _selectedThemeColor.ToString();
+        snapshot.WallpaperPath = _wallpaperPath;
+        snapshot.WallpaperPlacement = GetPlacementDisplayName(GetSelectedWallpaperPlacement());
+        snapshot.SettingsTabIndex = Math.Max(0, GetSettingsTabIndex());
+        snapshot.SettingsTabTag = GetSelectedSettingsTabTag();
+        snapshot.LanguageCode = _languageCode;
+        snapshot.TimeZoneId = _timeZoneService.CurrentTimeZone.Id;
+        snapshot.WeatherLocationMode = ToWeatherLocationModeTag(_weatherLocationMode);
+        snapshot.WeatherLocationKey = _weatherLocationKey;
+        snapshot.WeatherLocationName = _weatherLocationName;
+        snapshot.WeatherLatitude = _weatherLatitude;
+        snapshot.WeatherLongitude = _weatherLongitude;
+        snapshot.WeatherAutoRefreshLocation = _weatherAutoRefreshLocation;
+        snapshot.WeatherLocationQuery = BuildLegacyWeatherLocationQuery();
+        snapshot.WeatherExcludedAlerts = _weatherExcludedAlertsRaw;
+        snapshot.WeatherIconPackId = _weatherIconPackId;
+        snapshot.WeatherNoTlsRequests = _weatherNoTlsRequests;
+        snapshot.AutoStartWithWindows = _autoStartWithWindows;
+        snapshot.AppRenderMode = _selectedAppRenderMode;
+        snapshot.AutoCheckUpdates = _autoCheckUpdates;
+        snapshot.IncludePrereleaseUpdates = IncludePrereleaseUpdates;
+        snapshot.UpdateChannel = IncludePrereleaseUpdates ? UpdateChannelPreview : UpdateChannelStable;
+        snapshot.TopStatusComponentIds = _topStatusComponentIds.ToList();
+        snapshot.PinnedTaskbarActions = _pinnedTaskbarActions.Select(action => action.ToString()).ToList();
+        snapshot.EnableDynamicTaskbarActions = _enableDynamicTaskbarActions;
+        snapshot.TaskbarLayoutMode = _taskbarLayoutMode;
+        snapshot.ClockDisplayFormat = _clockDisplayFormat == ClockDisplayFormat.HourMinute ? "HourMinute" : "HourMinuteSecond";
+        snapshot.StatusBarSpacingMode = _statusBarSpacingMode;
+        snapshot.StatusBarCustomSpacingPercent = _statusBarCustomSpacingPercent;
+        return snapshot;
+    }
+    private DesktopLayoutSettingsSnapshot BuildDesktopLayoutSettingsSnapshot()
+    {
+        return new DesktopLayoutSettingsSnapshot
         {
-            GridShortSideCells = _targetShortSideCells,
-            GridSpacingPreset = _gridSpacingPreset,
-            DesktopEdgeInsetPercent = _desktopEdgeInsetPercent,
-            IsNightMode = _isNightMode,
-            ThemeColor = _selectedThemeColor.ToString(),
-            WallpaperPath = _wallpaperPath,
-            WallpaperPlacement = GetPlacementDisplayName(GetSelectedWallpaperPlacement()),
-            SettingsTabIndex = Math.Max(0, SettingsNavListBox?.SelectedIndex ?? 0),
-            LanguageCode = _languageCode,
-            TimeZoneId = _timeZoneService.CurrentTimeZone.Id,
-            WeatherLocationMode = ToWeatherLocationModeTag(_weatherLocationMode),
-            WeatherLocationKey = _weatherLocationKey,
-            WeatherLocationName = _weatherLocationName,
-            WeatherLatitude = _weatherLatitude,
-            WeatherLongitude = _weatherLongitude,
-            WeatherAutoRefreshLocation = _weatherAutoRefreshLocation,
-            WeatherLocationQuery = BuildLegacyWeatherLocationQuery(),
-            WeatherExcludedAlerts = _weatherExcludedAlertsRaw,
-            WeatherIconPackId = _weatherIconPackId,
-            WeatherNoTlsRequests = _weatherNoTlsRequests,
-            AutoStartWithWindows = _autoStartWithWindows,
-            AutoCheckUpdates = _autoCheckUpdates,
-            IncludePrereleaseUpdates = IncludePrereleaseUpdates,
-            UpdateChannel = IncludePrereleaseUpdates ? "Preview" : "Stable",
-            TopStatusComponentIds = _topStatusComponentIds.ToList(),
-            PinnedTaskbarActions = _pinnedTaskbarActions.Select(action => action.ToString()).ToList(),
-            EnableDynamicTaskbarActions = _enableDynamicTaskbarActions,
-            TaskbarLayoutMode = _taskbarLayoutMode,
-            ClockDisplayFormat = _clockDisplayFormat == ClockDisplayFormat.HourMinute ? "HourMinute" : "HourMinuteSecond",
-            StatusBarSpacingMode = _statusBarSpacingMode,
-            StatusBarCustomSpacingPercent = _statusBarCustomSpacingPercent,
             DesktopPageCount = _desktopPageCount,
             CurrentDesktopSurfaceIndex = _currentDesktopSurfaceIndex,
-            DesktopComponentPlacements = _desktopComponentPlacements.ToList(),
+            DesktopComponentPlacements = _desktopComponentPlacements.ToList()
+        };
+    }
+    private LauncherSettingsSnapshot BuildLauncherSettingsSnapshot()
+    {
+        return new LauncherSettingsSnapshot
+        {
             HiddenLauncherFolderPaths = _hiddenLauncherFolderPaths.OrderBy(path => path, StringComparer.OrdinalIgnoreCase).ToList(),
             HiddenLauncherAppPaths = _hiddenLauncherAppPaths.OrderBy(path => path, StringComparer.OrdinalIgnoreCase).ToList()
         };
-
-        _appSettingsService.Save(snapshot);
     }
 
     private IDisposable? _persistSettingsDebounceTimer;
@@ -1057,6 +1222,43 @@ public partial class MainWindow
         }
     }
 
+    private void InitializeAppRenderModeSetting(AppSettingsSnapshot snapshot)
+    {
+        _selectedAppRenderMode = AppRenderingModeHelper.Normalize(snapshot.AppRenderMode);
+
+        if (AppRenderModeComboBox is null)
+        {
+            return;
+        }
+
+        _suppressAppRenderModeSelectionEvents = true;
+        try
+        {
+            AppRenderModeComboBox.IsEnabled = OperatingSystem.IsWindows();
+            SelectAppRenderModeInUi(_selectedAppRenderMode);
+        }
+        finally
+        {
+            _suppressAppRenderModeSelectionEvents = false;
+        }
+    }
+
+    private void SelectAppRenderModeInUi(string renderMode)
+    {
+        if (AppRenderModeComboBox is null)
+        {
+            return;
+        }
+
+        var selectedItem = AppRenderModeComboBox.Items
+            .OfType<ComboBoxItem>()
+            .FirstOrDefault(item =>
+                string.Equals(item.Tag?.ToString(), renderMode, StringComparison.OrdinalIgnoreCase));
+
+        AppRenderModeComboBox.SelectedItem = selectedItem
+            ?? AppRenderModeComboBox.Items.OfType<ComboBoxItem>().FirstOrDefault();
+    }
+
     private static WeatherLocationMode ParseWeatherLocationMode(string? value)
     {
         return string.Equals(value, "Coordinates", StringComparison.OrdinalIgnoreCase)
@@ -1324,6 +1526,25 @@ public partial class MainWindow
         PersistSettings();
     }
 
+    private void OnAppRenderModeSelectionChanged(object? sender, SelectionChangedEventArgs e)
+    {
+        if (_suppressAppRenderModeSelectionEvents || AppRenderModeComboBox is null)
+        {
+            return;
+        }
+
+        var selectedMode = AppRenderingModeHelper.Normalize(
+            (AppRenderModeComboBox.SelectedItem as ComboBoxItem)?.Tag?.ToString());
+
+        if (string.Equals(_selectedAppRenderMode, selectedMode, StringComparison.Ordinal))
+        {
+            return;
+        }
+
+        _selectedAppRenderMode = selectedMode;
+        PersistSettings();
+    }
+
     private async void OnSearchWeatherCityClick(object? sender, RoutedEventArgs e)
     {
         if (_isWeatherSearchInProgress || WeatherCitySearchTextBox is null || WeatherCityResultsComboBox is null)
@@ -1753,7 +1974,7 @@ public partial class MainWindow
             : CalculateCurrentBackgroundLuminance() >= LightBackgroundLuminanceThreshold;
         var isLightNavBackground = _isSettingsOpen
             ? !_isNightMode
-            : CalculateBrushLuminance(SettingsNavPanelBorder?.Background) >= LightBackgroundLuminanceThreshold;
+            : CalculateBrushLuminance(SettingsNavView?.Background) >= LightBackgroundLuminanceThreshold;
         var context = new ThemeColorContext(
             _selectedThemeColor,
             isLightBackground,
@@ -2287,5 +2508,219 @@ public partial class MainWindow
             IconVariant = IconVariant.Regular
         };
     }
+
+    // ========================================================================
+    // --- UserControl Forwarding Properties (Definitive Catch-All List) ---
+    // These properties allow legacy code in MainWindow.axaml.cs and other partials
+    // to access controls that have been moved into independent UserControls.
+    // ========================================================================
+
+    // --- WallpaperSettingsPage ---
+    internal TextBlock WallpaperPanelTitleTextBlock => WallpaperSettingsPanel.FindControl<TextBlock>("WallpaperPanelTitleTextBlock")!;
+    internal TextBlock WallpaperPathTextBlock => WallpaperSettingsPanel.FindControl<TextBlock>("WallpaperPathTextBlock")!;
+    internal TextBlock WallpaperStatusTextBlock => WallpaperSettingsPanel.FindControl<TextBlock>("WallpaperStatusTextBlock")!;
+    internal ComboBox WallpaperPlacementComboBox => WallpaperSettingsPanel.FindControl<ComboBox>("WallpaperPlacementComboBox")!;
+    internal Border WallpaperPreviewHost => WallpaperSettingsPanel.FindControl<Border>("WallpaperPreviewHost")!;
+    internal Border WallpaperPreviewFrame => WallpaperSettingsPanel.FindControl<Border>("WallpaperPreviewFrame")!;
+    internal Border WallpaperPreviewViewport => WallpaperSettingsPanel.FindControl<Border>("WallpaperPreviewViewport")!;
+    internal LibVLCSharp.Avalonia.VideoView? WallpaperPreviewVideoView => WallpaperSettingsPanel.FindControl<LibVLCSharp.Avalonia.VideoView>("WallpaperPreviewVideoView");
+    internal Grid WallpaperPreviewGrid => WallpaperSettingsPanel.FindControl<Grid>("WallpaperPreviewGrid")!;
+    internal Border WallpaperPreviewTopStatusBarHost => WallpaperSettingsPanel.FindControl<Border>("WallpaperPreviewTopStatusBarHost")!;
+    internal StackPanel WallpaperPreviewTopStatusComponentsPanel => WallpaperSettingsPanel.FindControl<StackPanel>("WallpaperPreviewTopStatusComponentsPanel")!;
+    internal LanMountainDesktop.Views.Components.ClockWidget WallpaperPreviewClockWidget => WallpaperSettingsPanel.FindControl<LanMountainDesktop.Views.Components.ClockWidget>("WallpaperPreviewClockWidget")!;
+    internal Border WallpaperPreviewBottomTaskbarContainer => WallpaperSettingsPanel.FindControl<Border>("WallpaperPreviewBottomTaskbarContainer")!;
+    internal Border WallpaperPreviewTaskbarFixedActionsHost => WallpaperSettingsPanel.FindControl<Border>("WallpaperPreviewTaskbarFixedActionsHost")!;
+    internal StackPanel WallpaperPreviewBackButtonVisual => WallpaperSettingsPanel.FindControl<StackPanel>("WallpaperPreviewBackButtonVisual")!;
+    internal TextBlock WallpaperPreviewBackButtonTextBlock => WallpaperSettingsPanel.FindControl<TextBlock>("WallpaperPreviewBackButtonTextBlock")!;
+    internal StackPanel WallpaperPreviewTaskbarDynamicActionsHost => WallpaperSettingsPanel.FindControl<StackPanel>("WallpaperPreviewTaskbarDynamicActionsHost")!;
+    internal Border WallpaperPreviewTaskbarSettingsActionHost => WallpaperSettingsPanel.FindControl<Border>("WallpaperPreviewTaskbarSettingsActionHost")!;
+    internal StackPanel WallpaperPreviewComponentLibraryVisual => WallpaperSettingsPanel.FindControl<StackPanel>("WallpaperPreviewComponentLibraryVisual")!;
+    internal TextBlock WallpaperPreviewComponentLibraryTextBlock => WallpaperSettingsPanel.FindControl<TextBlock>("WallpaperPreviewComponentLibraryTextBlock")!;
+    internal FluentIcons.Avalonia.SymbolIcon WallpaperPreviewSettingsButtonIcon => WallpaperSettingsPanel.FindControl<FluentIcons.Avalonia.SymbolIcon>("WallpaperPreviewSettingsButtonIcon")!;
+    internal Button PickWallpaperButton => WallpaperSettingsPanel.FindControl<Button>("PickWallpaperButton")!;
+    internal Button ClearWallpaperButton => WallpaperSettingsPanel.FindControl<Button>("ClearWallpaperButton")!;
+    internal FluentAvalonia.UI.Controls.SettingsExpander WallpaperPlacementSettingsExpander => WallpaperSettingsPanel.FindControl<FluentAvalonia.UI.Controls.SettingsExpander>("WallpaperPlacementSettingsExpander")!;
+
+    // --- GridSettingsPage ---
+    internal TextBlock GridPanelTitleTextBlock => GridSettingsPanel.FindControl<TextBlock>("GridPanelTitleTextBlock")!;
+    internal Border GridPreviewHost => GridSettingsPanel.FindControl<Border>("GridPreviewHost")!;
+    internal Border GridPreviewFrame => GridSettingsPanel.FindControl<Border>("GridPreviewFrame")!;
+    internal Border GridPreviewViewport => GridSettingsPanel.FindControl<Border>("GridPreviewViewport")!;
+    internal Canvas GridPreviewLinesCanvas => GridSettingsPanel.FindControl<Canvas>("GridPreviewLinesCanvas")!;
+    internal Grid GridPreviewGrid => GridSettingsPanel.FindControl<Grid>("GridPreviewGrid")!;
+    internal Border GridPreviewTopStatusBarHost => GridSettingsPanel.FindControl<Border>("GridPreviewTopStatusBarHost")!;
+    internal StackPanel GridPreviewTopStatusComponentsPanel => GridSettingsPanel.FindControl<StackPanel>("GridPreviewTopStatusComponentsPanel")!;
+    internal Border GridPreviewBottomTaskbarContainer => GridSettingsPanel.FindControl<Border>("GridPreviewBottomTaskbarContainer")!;
+    internal Border GridPreviewTaskbarFixedActionsHost => GridSettingsPanel.FindControl<Border>("GridPreviewTaskbarFixedActionsHost")!;
+    internal StackPanel GridPreviewBackButtonVisual => GridSettingsPanel.FindControl<StackPanel>("GridPreviewBackButtonVisual")!;
+    internal TextBlock GridPreviewBackButtonTextBlock => GridSettingsPanel.FindControl<TextBlock>("GridPreviewBackButtonTextBlock")!;
+    internal StackPanel GridPreviewTaskbarDynamicActionsHost => GridSettingsPanel.FindControl<StackPanel>("GridPreviewTaskbarDynamicActionsHost")!;
+    internal Border GridPreviewTaskbarSettingsActionHost => GridSettingsPanel.FindControl<Border>("GridPreviewTaskbarSettingsActionHost")!;
+    internal StackPanel GridPreviewComponentLibraryVisual => GridSettingsPanel.FindControl<StackPanel>("GridPreviewComponentLibraryVisual")!;
+    internal FluentIcons.Avalonia.FluentIcon GridPreviewComponentLibraryIcon => GridSettingsPanel.FindControl<FluentIcons.Avalonia.FluentIcon>("GridPreviewComponentLibraryIcon")!;
+    internal TextBlock GridPreviewComponentLibraryTextBlock => GridSettingsPanel.FindControl<TextBlock>("GridPreviewComponentLibraryTextBlock")!;
+    internal FluentIcons.Avalonia.SymbolIcon GridPreviewSettingsButtonIcon => GridSettingsPanel.FindControl<FluentIcons.Avalonia.SymbolIcon>("GridPreviewSettingsButtonIcon")!;
+    internal FluentAvalonia.UI.Controls.SettingsExpander GridRowsSettingsExpander => GridSettingsPanel.FindControl<FluentAvalonia.UI.Controls.SettingsExpander>("GridRowsSettingsExpander")!;
+    internal FluentAvalonia.UI.Controls.SettingsExpander GridSpacingSettingsExpander => GridSettingsPanel.FindControl<FluentAvalonia.UI.Controls.SettingsExpander>("GridSpacingSettingsExpander")!;
+    internal FluentAvalonia.UI.Controls.SettingsExpander GridEdgeInsetSettingsExpander => GridSettingsPanel.FindControl<FluentAvalonia.UI.Controls.SettingsExpander>("GridEdgeInsetSettingsExpander")!;
+    internal Slider GridSizeSlider => GridSettingsPanel.FindControl<Slider>("GridSizeSlider")!;
+    internal FluentAvalonia.UI.Controls.NumberBox GridSizeNumberBox => GridSettingsPanel.FindControl<FluentAvalonia.UI.Controls.NumberBox>("GridSizeNumberBox")!;
+    internal ComboBox GridSpacingPresetComboBox => GridSettingsPanel.FindControl<ComboBox>("GridSpacingPresetComboBox")!;
+    internal ComboBoxItem GridSpacingRelaxedComboBoxItem => GridSettingsPanel.FindControl<ComboBoxItem>("GridSpacingRelaxedComboBoxItem")!;
+    internal ComboBoxItem GridSpacingCompactComboBoxItem => GridSettingsPanel.FindControl<ComboBoxItem>("GridSpacingCompactComboBoxItem")!;
+    internal Slider GridEdgeInsetSlider => GridSettingsPanel.FindControl<Slider>("GridEdgeInsetSlider")!;
+    internal FluentAvalonia.UI.Controls.NumberBox GridEdgeInsetNumberBox => GridSettingsPanel.FindControl<FluentAvalonia.UI.Controls.NumberBox>("GridEdgeInsetNumberBox")!;
+    internal TextBlock GridEdgeInsetComputedPxTextBlock => GridSettingsPanel.FindControl<TextBlock>("GridEdgeInsetComputedPxTextBlock")!;
+    internal Button ApplyGridButton => GridSettingsPanel.FindControl<Button>("ApplyGridButton")!;
+    internal TextBlock GridInfoTextBlock => GridSettingsPanel.FindControl<TextBlock>("GridInfoTextBlock")!;
+
+    // --- ColorSettingsPage ---
+    internal TextBlock ColorPanelTitleTextBlock => ColorSettingsPanel.FindControl<TextBlock>("ColorPanelTitleTextBlock")!;
+    internal FluentAvalonia.UI.Controls.SettingsExpander ThemeModeSettingsExpander => ColorSettingsPanel.FindControl<FluentAvalonia.UI.Controls.SettingsExpander>("ThemeModeSettingsExpander")!;
+    internal FluentAvalonia.UI.Controls.SettingsExpander ThemeColorSettingsExpander => ColorSettingsPanel.FindControl<FluentAvalonia.UI.Controls.SettingsExpander>("ThemeColorSettingsExpander")!;
+    internal ToggleSwitch NightModeToggleSwitch => ColorSettingsPanel.FindControl<ToggleSwitch>("NightModeToggleSwitch")!;
+    internal TextBlock ThemeColorStatusTextBlock => ColorSettingsPanel.FindControl<TextBlock>("ThemeColorStatusTextBlock")!;
+    internal TextBlock RecommendedColorsLabelTextBlock => ColorSettingsPanel.FindControl<TextBlock>("RecommendedColorsLabelTextBlock")!;
+    internal TextBlock SystemMonetColorsLabelTextBlock => ColorSettingsPanel.FindControl<TextBlock>("SystemMonetColorsLabelTextBlock")!;
+    internal Button RecommendedColorButton1 => ColorSettingsPanel.FindControl<Button>("RecommendedColorButton1")!;
+    internal Button RecommendedColorButton2 => ColorSettingsPanel.FindControl<Button>("RecommendedColorButton2")!;
+    internal Button RecommendedColorButton3 => ColorSettingsPanel.FindControl<Button>("RecommendedColorButton3")!;
+    internal Button RecommendedColorButton4 => ColorSettingsPanel.FindControl<Button>("RecommendedColorButton4")!;
+    internal Button RecommendedColorButton5 => ColorSettingsPanel.FindControl<Button>("RecommendedColorButton5")!;
+    internal Button RecommendedColorButton6 => ColorSettingsPanel.FindControl<Button>("RecommendedColorButton6")!;
+    internal Border RecommendedColorSwatch1 => ColorSettingsPanel.FindControl<Border>("RecommendedColorSwatch1")!;
+    internal Border RecommendedColorSwatch2 => ColorSettingsPanel.FindControl<Border>("RecommendedColorSwatch2")!;
+    internal Border RecommendedColorSwatch3 => ColorSettingsPanel.FindControl<Border>("RecommendedColorSwatch3")!;
+    internal Border RecommendedColorSwatch4 => ColorSettingsPanel.FindControl<Border>("RecommendedColorSwatch4")!;
+    internal Border RecommendedColorSwatch5 => ColorSettingsPanel.FindControl<Border>("RecommendedColorSwatch5")!;
+    internal Border RecommendedColorSwatch6 => ColorSettingsPanel.FindControl<Border>("RecommendedColorSwatch6")!;
+    internal Button RefreshMonetColorsButton => ColorSettingsPanel.FindControl<Button>("RefreshMonetColorsButton")!;
+    internal Button MonetColorButton1 => ColorSettingsPanel.FindControl<Button>("MonetColorButton1")!;
+    internal Button MonetColorButton2 => ColorSettingsPanel.FindControl<Button>("MonetColorButton2")!;
+    internal Button MonetColorButton3 => ColorSettingsPanel.FindControl<Button>("MonetColorButton3")!;
+    internal Button MonetColorButton4 => ColorSettingsPanel.FindControl<Button>("MonetColorButton4")!;
+    internal Button MonetColorButton5 => ColorSettingsPanel.FindControl<Button>("MonetColorButton5")!;
+    internal Button MonetColorButton6 => ColorSettingsPanel.FindControl<Button>("MonetColorButton6")!;
+    internal Border MonetColorSwatch1 => ColorSettingsPanel.FindControl<Border>("MonetColorSwatch1")!;
+    internal Border MonetColorSwatch2 => ColorSettingsPanel.FindControl<Border>("MonetColorSwatch2")!;
+    internal Border MonetColorSwatch3 => ColorSettingsPanel.FindControl<Border>("MonetColorSwatch3")!;
+    internal Border MonetColorSwatch4 => ColorSettingsPanel.FindControl<Border>("MonetColorSwatch4")!;
+    internal Border MonetColorSwatch5 => ColorSettingsPanel.FindControl<Border>("MonetColorSwatch5")!;
+    internal Border MonetColorSwatch6 => ColorSettingsPanel.FindControl<Border>("MonetColorSwatch6")!;
+
+    // --- StatusBarSettingsPage ---
+    internal TextBlock StatusBarPanelTitleTextBlock => StatusBarSettingsPanel.FindControl<TextBlock>("StatusBarPanelTitleTextBlock")!;
+    internal FluentAvalonia.UI.Controls.SettingsExpander StatusBarClockSettingsExpander => StatusBarSettingsPanel.FindControl<FluentAvalonia.UI.Controls.SettingsExpander>("StatusBarClockSettingsExpander")!;
+    internal FluentAvalonia.UI.Controls.SettingsExpander StatusBarSpacingSettingsExpander => StatusBarSettingsPanel.FindControl<FluentAvalonia.UI.Controls.SettingsExpander>("StatusBarSpacingSettingsExpander")!;
+    internal ToggleSwitch StatusBarClockToggleSwitch => StatusBarSettingsPanel.FindControl<ToggleSwitch>("StatusBarClockToggleSwitch")!;
+    internal RadioButton ClockFormatHMSSRadio => StatusBarSettingsPanel.FindControl<RadioButton>("ClockFormatHMSSRadio")!;
+    internal RadioButton ClockFormatHMRadio => StatusBarSettingsPanel.FindControl<RadioButton>("ClockFormatHMRadio")!;
+    internal ComboBox StatusBarSpacingModeComboBox => StatusBarSettingsPanel.FindControl<ComboBox>("StatusBarSpacingModeComboBox")!;
+    internal ComboBoxItem StatusBarSpacingModeCompactItem => StatusBarSettingsPanel.FindControl<ComboBoxItem>("StatusBarSpacingModeCompactItem")!;
+    internal ComboBoxItem StatusBarSpacingModeRelaxedItem => StatusBarSettingsPanel.FindControl<ComboBoxItem>("StatusBarSpacingModeRelaxedItem")!;
+    internal ComboBoxItem StatusBarSpacingModeCustomItem => StatusBarSettingsPanel.FindControl<ComboBoxItem>("StatusBarSpacingModeCustomItem")!;
+    internal FluentAvalonia.UI.Controls.SettingsExpanderItem StatusBarSpacingCustomPanel => StatusBarSettingsPanel.FindControl<FluentAvalonia.UI.Controls.SettingsExpanderItem>("StatusBarSpacingCustomPanel")!;
+    internal Slider StatusBarSpacingSlider => StatusBarSettingsPanel.FindControl<Slider>("StatusBarSpacingSlider")!;
+    internal FluentAvalonia.UI.Controls.NumberBox StatusBarSpacingNumberBox => StatusBarSettingsPanel.FindControl<FluentAvalonia.UI.Controls.NumberBox>("StatusBarSpacingNumberBox")!;
+    internal TextBlock StatusBarSpacingComputedPxTextBlock => StatusBarSettingsPanel.FindControl<TextBlock>("StatusBarSpacingComputedPxTextBlock")!;
+
+    // --- RegionSettingsPage ---
+    internal TextBlock RegionPanelTitleTextBlock => RegionSettingsPanel.FindControl<TextBlock>("RegionPanelTitleTextBlock")!;
+    internal FluentAvalonia.UI.Controls.SettingsExpander LanguageSettingsExpander => RegionSettingsPanel.FindControl<FluentAvalonia.UI.Controls.SettingsExpander>("LanguageSettingsExpander")!;
+    internal FluentAvalonia.UI.Controls.SettingsExpander TimeZoneSettingsExpander => RegionSettingsPanel.FindControl<FluentAvalonia.UI.Controls.SettingsExpander>("TimeZoneSettingsExpander")!;
+    internal ComboBox LanguageComboBox => RegionSettingsPanel.FindControl<ComboBox>("LanguageComboBox")!;
+    internal ComboBoxItem LanguageChineseItem => RegionSettingsPanel.FindControl<ComboBoxItem>("LanguageChineseItem")!;
+    internal ComboBoxItem LanguageEnglishItem => RegionSettingsPanel.FindControl<ComboBoxItem>("LanguageEnglishItem")!;
+    internal ComboBox TimeZoneComboBox => RegionSettingsPanel.FindControl<ComboBox>("TimeZoneComboBox")!;
+
+    // --- WeatherSettingsPage ---
+    internal TextBlock WeatherPanelTitleTextBlock => WeatherSettingsPanel.FindControl<TextBlock>("WeatherPanelTitleTextBlock")!;
+    internal FluentAvalonia.UI.Controls.SettingsExpander WeatherPreviewSettingsExpander => WeatherSettingsPanel.FindControl<FluentAvalonia.UI.Controls.SettingsExpander>("WeatherPreviewSettingsExpander")!;
+    internal FluentAvalonia.UI.Controls.SettingsExpander WeatherLocationSettingsExpander => WeatherSettingsPanel.FindControl<FluentAvalonia.UI.Controls.SettingsExpander>("WeatherLocationSettingsExpander")!;
+    internal FluentAvalonia.UI.Controls.SettingsExpander WeatherCitySearchSettingsExpander => WeatherSettingsPanel.FindControl<FluentAvalonia.UI.Controls.SettingsExpander>("WeatherCitySearchSettingsExpander")!;
+    internal FluentAvalonia.UI.Controls.SettingsExpander WeatherCoordinateSettingsExpander => WeatherSettingsPanel.FindControl<FluentAvalonia.UI.Controls.SettingsExpander>("WeatherCoordinateSettingsExpander")!;
+    internal FluentAvalonia.UI.Controls.SettingsExpander WeatherAlertFilterSettingsExpander => WeatherSettingsPanel.FindControl<FluentAvalonia.UI.Controls.SettingsExpander>("WeatherAlertFilterSettingsExpander")!;
+    internal FluentAvalonia.UI.Controls.SettingsExpander WeatherIconPackSettingsExpander => WeatherSettingsPanel.FindControl<FluentAvalonia.UI.Controls.SettingsExpander>("WeatherIconPackSettingsExpander")!;
+    internal FluentAvalonia.UI.Controls.SettingsExpander WeatherNoTlsSettingsExpander => WeatherSettingsPanel.FindControl<FluentAvalonia.UI.Controls.SettingsExpander>("WeatherNoTlsSettingsExpander")!;
+    internal Button WeatherPreviewButton => WeatherSettingsPanel.FindControl<Button>("WeatherPreviewButton")!;
+    internal ComboBox WeatherLocationModeComboBox => WeatherSettingsPanel.FindControl<ComboBox>("WeatherLocationModeComboBox")!;
+    internal ComboBoxItem WeatherLocationModeCityItem => WeatherSettingsPanel.FindControl<ComboBoxItem>("WeatherLocationModeCityItem")!;
+    internal ComboBoxItem WeatherLocationModeCoordinatesItem => WeatherSettingsPanel.FindControl<ComboBoxItem>("WeatherLocationModeCoordinatesItem")!;
+    internal ListBoxItem WeatherLocationModeCityChipItem => WeatherSettingsPanel.FindControl<ListBoxItem>("WeatherLocationModeCityChipItem")!;
+    internal ListBoxItem WeatherLocationModeCoordinatesChipItem => WeatherSettingsPanel.FindControl<ListBoxItem>("WeatherLocationModeCoordinatesChipItem")!;
+    internal ListBox WeatherLocationModeChipListBox => WeatherSettingsPanel.FindControl<ListBox>("WeatherLocationModeChipListBox")!;
+    internal ToggleSwitch WeatherAutoRefreshToggleSwitch => WeatherSettingsPanel.FindControl<ToggleSwitch>("WeatherAutoRefreshToggleSwitch")!;
+    internal Button WeatherSearchButton => WeatherSettingsPanel.FindControl<Button>("WeatherSearchButton")!;
+    internal Button WeatherApplyCityButton => WeatherSettingsPanel.FindControl<Button>("WeatherApplyCityButton")!;
+    internal Button WeatherApplyCoordinatesButton => WeatherSettingsPanel.FindControl<Button>("WeatherApplyCoordinatesButton")!;
+    internal TextBox WeatherExcludedAlertsTextBox => WeatherSettingsPanel.FindControl<TextBox>("WeatherExcludedAlertsTextBox")!;
+    internal ComboBox WeatherIconPackComboBox => WeatherSettingsPanel.FindControl<ComboBox>("WeatherIconPackComboBox")!;
+    internal ToggleSwitch WeatherNoTlsToggleSwitch => WeatherSettingsPanel.FindControl<ToggleSwitch>("WeatherNoTlsToggleSwitch")!;
+    internal TextBox WeatherCitySearchTextBox => WeatherSettingsPanel.FindControl<TextBox>("WeatherCitySearchTextBox")!;
+    internal ComboBox WeatherCityResultsComboBox => WeatherSettingsPanel.FindControl<ComboBox>("WeatherCityResultsComboBox")!;
+    internal TextBlock WeatherSearchStatusTextBlock => WeatherSettingsPanel.FindControl<TextBlock>("WeatherSearchStatusTextBlock")!;
+    internal TextBox WeatherLocationKeyTextBox => WeatherSettingsPanel.FindControl<TextBox>("WeatherLocationKeyTextBox")!;
+    internal TextBox WeatherLocationNameTextBox => WeatherSettingsPanel.FindControl<TextBox>("WeatherLocationNameTextBox")!;
+    internal FluentAvalonia.UI.Controls.NumberBox WeatherLatitudeNumberBox => WeatherSettingsPanel.FindControl<FluentAvalonia.UI.Controls.NumberBox>("WeatherLatitudeNumberBox")!;
+    internal FluentAvalonia.UI.Controls.NumberBox WeatherLongitudeNumberBox => WeatherSettingsPanel.FindControl<FluentAvalonia.UI.Controls.NumberBox>("WeatherLongitudeNumberBox")!;
+    internal TextBlock WeatherCoordinateStatusTextBlock => WeatherSettingsPanel.FindControl<TextBlock>("WeatherCoordinateStatusTextBlock")!;
+    internal TextBlock WeatherPreviewResultTextBlock => WeatherSettingsPanel.FindControl<TextBlock>("WeatherPreviewResultTextBlock")!;
+    internal FluentIcons.Avalonia.Fluent.SymbolIcon WeatherPreviewIconSymbol => WeatherSettingsPanel.FindControl<FluentIcons.Avalonia.Fluent.SymbolIcon>("WeatherPreviewIconSymbol")!;
+    internal TextBlock WeatherPreviewTemperatureTextBlock => WeatherSettingsPanel.FindControl<TextBlock>("WeatherPreviewTemperatureTextBlock")!;
+    internal TextBlock WeatherPreviewUpdatedTextBlock => WeatherSettingsPanel.FindControl<TextBlock>("WeatherPreviewUpdatedTextBlock")!;
+    internal FluentAvalonia.UI.Controls.ProgressRing WeatherSearchProgressRing => WeatherSettingsPanel.FindControl<FluentAvalonia.UI.Controls.ProgressRing>("WeatherSearchProgressRing")!;
+    internal FluentAvalonia.UI.Controls.ProgressRing WeatherPreviewProgressRing => WeatherSettingsPanel.FindControl<FluentAvalonia.UI.Controls.ProgressRing>("WeatherPreviewProgressRing")!;
+    internal ComboBoxItem WeatherIconPackFluentRegularItem => WeatherSettingsPanel.FindControl<ComboBoxItem>("WeatherIconPackFluentRegularItem")!;
+    internal ComboBoxItem WeatherIconPackFluentFilledItem => WeatherSettingsPanel.FindControl<ComboBoxItem>("WeatherIconPackFluentFilledItem")!;
+    internal TextBlock WeatherLocationStatusTextBlock => WeatherSettingsPanel.FindControl<TextBlock>("WeatherLocationStatusTextBlock")!;
+
+    // --- UpdateSettingsPage ---
+    internal TextBlock UpdatePanelTitleTextBlock => UpdateSettingsPanel.FindControl<TextBlock>("UpdatePanelTitleTextBlock")!;
+    internal FluentAvalonia.UI.Controls.SettingsExpander UpdateOptionsSettingsExpander => UpdateSettingsPanel.FindControl<FluentAvalonia.UI.Controls.SettingsExpander>("UpdateOptionsSettingsExpander")!;
+    internal FluentAvalonia.UI.Controls.SettingsExpander UpdateActionsSettingsExpander => UpdateSettingsPanel.FindControl<FluentAvalonia.UI.Controls.SettingsExpander>("UpdateActionsSettingsExpander")!;
+    internal TextBlock UpdateCurrentVersionLabelTextBlock => UpdateSettingsPanel.FindControl<TextBlock>("UpdateCurrentVersionLabelTextBlock")!;
+    internal TextBlock UpdateCurrentVersionValueTextBlock => UpdateSettingsPanel.FindControl<TextBlock>("UpdateCurrentVersionValueTextBlock")!;
+    internal TextBlock UpdateLatestVersionLabelTextBlock => UpdateSettingsPanel.FindControl<TextBlock>("UpdateLatestVersionLabelTextBlock")!;
+    internal TextBlock UpdateLatestVersionValueTextBlock => UpdateSettingsPanel.FindControl<TextBlock>("UpdateLatestVersionValueTextBlock")!;
+    internal TextBlock UpdatePublishedAtLabelTextBlock => UpdateSettingsPanel.FindControl<TextBlock>("UpdatePublishedAtLabelTextBlock")!;
+    internal TextBlock UpdatePublishedAtValueTextBlock => UpdateSettingsPanel.FindControl<TextBlock>("UpdatePublishedAtValueTextBlock")!;
+    internal TextBlock UpdateChannelLabelTextBlock => UpdateSettingsPanel.FindControl<TextBlock>("UpdateChannelLabelTextBlock")!;
+    internal ListBoxItem UpdateChannelStableChipItem => UpdateSettingsPanel.FindControl<ListBoxItem>("UpdateChannelStableChipItem")!;
+    internal ListBoxItem UpdateChannelPreviewChipItem => UpdateSettingsPanel.FindControl<ListBoxItem>("UpdateChannelPreviewChipItem")!;
+    internal ToggleSwitch AutoCheckUpdatesToggleSwitch => UpdateSettingsPanel.FindControl<ToggleSwitch>("AutoCheckUpdatesToggleSwitch")! ;
+    internal ListBox UpdateChannelChipListBox => UpdateSettingsPanel.FindControl<ListBox>("UpdateChannelChipListBox")!;
+    internal Button CheckForUpdatesButton => UpdateSettingsPanel.FindControl<Button>("CheckForUpdatesButton")!;
+    internal Button DownloadAndInstallUpdateButton => UpdateSettingsPanel.FindControl<Button>("DownloadAndInstallUpdateButton")!;
+    internal ProgressBar UpdateDownloadProgressBar => UpdateSettingsPanel.FindControl<ProgressBar>("UpdateDownloadProgressBar")!;
+    internal TextBlock UpdateDownloadProgressTextBlock => UpdateSettingsPanel.FindControl<TextBlock>("UpdateDownloadProgressTextBlock")!;
+    internal TextBlock UpdateStatusTextBlock => UpdateSettingsPanel.FindControl<TextBlock>("UpdateStatusTextBlock")!;
+
+    // --- AboutSettingsPage ---
+    internal TextBlock AboutPanelTitleTextBlock => AboutSettingsPanel.FindControl<TextBlock>("AboutPanelTitleTextBlock")!;
+    internal FluentAvalonia.UI.Controls.SettingsExpander AboutStartupSettingsExpander => AboutSettingsPanel.FindControl<FluentAvalonia.UI.Controls.SettingsExpander>("AboutStartupSettingsExpander")!;
+    internal FluentAvalonia.UI.Controls.SettingsExpander AboutRenderModeSettingsExpander => AboutSettingsPanel.FindControl<FluentAvalonia.UI.Controls.SettingsExpander>("AboutRenderModeSettingsExpander")!;
+    internal ToggleSwitch AutoStartWithWindowsToggleSwitch => AboutSettingsPanel.FindControl<ToggleSwitch>("AutoStartWithWindowsToggleSwitch")!;
+    internal ComboBox AppRenderModeComboBox => AboutSettingsPanel.FindControl<ComboBox>("AppRenderModeComboBox")!;
+    internal TextBlock VersionTextBlock => AboutSettingsPanel.FindControl<TextBlock>("VersionTextBlock")!;
+    internal TextBlock CodeNameTextBlock => AboutSettingsPanel.FindControl<TextBlock>("CodeNameTextBlock")!;
+    internal TextBlock FontInfoTextBlock => AboutSettingsPanel.FindControl<TextBlock>("FontInfoTextBlock")!;
+
+    // --- LauncherSettingsPage ---
+    internal TextBlock LauncherSettingsPanelTitleTextBlock => LauncherSettingsPanel.FindControl<TextBlock>("LauncherSettingsPanelTitleTextBlock")!;
+    internal FluentAvalonia.UI.Controls.SettingsExpander LauncherHiddenItemsSettingsExpander => LauncherSettingsPanel.FindControl<FluentAvalonia.UI.Controls.SettingsExpander>("LauncherHiddenItemsSettingsExpander")!;
+    internal StackPanel LauncherHiddenItemsListPanel => LauncherSettingsPanel.FindControl<StackPanel>("LauncherHiddenItemsListPanel")!;
+    internal TextBlock LauncherHiddenItemsEmptyTextBlock => LauncherSettingsPanel.FindControl<TextBlock>("LauncherHiddenItemsEmptyTextBlock")!;
+    internal TextBlock LauncherHiddenItemsDescriptionTextBlock => LauncherSettingsPanel.FindControl<TextBlock>("LauncherHiddenItemsDescriptionTextBlock")!;
+
+    // --- PluginSettingsPage (Added for completeness) ---
+    internal TextBlock PluginSettingsPanelTitleTextBlock => PluginSettingsPanel.FindControl<TextBlock>("PluginSettingsPanelTitleTextBlock")!;
+    internal FluentAvalonia.UI.Controls.SettingsExpander PluginSystemSettingsExpander => PluginSettingsPanel.FindControl<FluentAvalonia.UI.Controls.SettingsExpander>("PluginSystemSettingsExpander")!;
+    internal TextBlock PluginSystemDescriptionTextBlock => PluginSettingsPanel.FindControl<TextBlock>("PluginSystemDescriptionTextBlock")!;
+    internal TextBlock PluginSystemStatusTextBlock => PluginSettingsPanel.FindControl<TextBlock>("PluginSystemStatusTextBlock")!;
+    internal FluentAvalonia.UI.Controls.SettingsExpander InstalledPluginsSettingsExpander => PluginSettingsPanel.FindControl<FluentAvalonia.UI.Controls.SettingsExpander>("InstalledPluginsSettingsExpander")!;
+    internal TextBlock PluginRestartHintTextBlock => PluginSettingsPanel.FindControl<TextBlock>("PluginRestartHintTextBlock")!;
+    internal TextBlock PluginCatalogEmptyTextBlock => PluginSettingsPanel.FindControl<TextBlock>("PluginCatalogEmptyTextBlock")!;
 }
 
+
+

LanMountainDesktop/Views/MainWindow.Update.cs

@@ -78,7 +78,7 @@ public partial class MainWindow
 
     private void ApplyUpdateLocalization()
     {
-        SettingsNavUpdateTextBlock.Text = L("settings.nav.update", "Update");
+        SettingsNavUpdateItem.Content = L("settings.nav.update", "Update");
         UpdatePanelTitleTextBlock.Text = L("settings.update.title", "Update");
 
         UpdateCurrentVersionLabelTextBlock.Text = L("settings.update.current_version_label", "Current Version");

LanMountainDesktop/Views/MainWindow.axaml.cs

@@ -19,7 +19,6 @@ using Avalonia.Styling;
 using Avalonia.Threading;
 using FluentAvalonia.Styling;
 using LanMountainDesktop.ComponentSystem;
-using LanMountainDesktop.ComponentSystem.Extensions;
 using LanMountainDesktop.Models;
 using LanMountainDesktop.Services;
 using LanMountainDesktop.Theme;
@@ -88,6 +87,8 @@ public partial class MainWindow : Window
     }
     private readonly MonetColorService _monetColorService = new();
     private readonly AppSettingsService _appSettingsService = new();
+    private readonly DesktopLayoutSettingsService _desktopLayoutSettingsService = new();
+    private readonly LauncherSettingsService _launcherSettingsService = new();
     private readonly ComponentSettingsService _componentSettingsService = new();
     private readonly LocalizationService _localizationService = new();
     private readonly TimeZoneService _timeZoneService = new();
@@ -96,11 +97,7 @@ public partial class MainWindow : Window
     private readonly IWeatherDataService _weatherDataService = new XiaomiWeatherService();
     private readonly IRecommendationInfoService _recommendationInfoService = new RecommendationDataService();
     private readonly ICalculatorDataService _calculatorDataService = new CalculatorDataService();
-    private readonly ComponentRegistry _componentRegistry = ComponentRegistry
-        .CreateDefault()
-        .RegisterExtensions(
-            JsonComponentExtensionProvider.LoadProvidersFromDirectory(
-                Path.Combine(AppContext.BaseDirectory, "Extensions", "Components")));
+    private readonly ComponentRegistry _componentRegistry;
     private readonly DesktopComponentRuntimeRegistry _componentRuntimeRegistry;
     private readonly FluentAvaloniaTheme? _fluentAvaloniaTheme;
     private readonly HashSet<string> _topStatusComponentIds = new(StringComparer.OrdinalIgnoreCase);
@@ -170,21 +167,90 @@ public partial class MainWindow : Window
     private bool _weatherNoTlsRequests;
     private bool _autoStartWithWindows;
     private bool _suppressAutoStartToggleEvents;
+    private bool _suppressAppRenderModeSelectionEvents;
+    private string _selectedAppRenderMode = AppRenderingModeHelper.Default;
     private string _weatherSearchKeyword = string.Empty;
     private bool _isWeatherSearchInProgress;
     private bool _isWeatherPreviewInProgress;
     private ClockDisplayFormat _clockDisplayFormat = ClockDisplayFormat.HourMinuteSecond;
+    private bool _externalSettingsReloadPending;
 
     private double CurrentDesktopPitch => _currentDesktopCellSize + _currentDesktopCellGap;
 
     public MainWindow()
     {
+        var pluginRuntimeService = (Application.Current as App)?.PluginRuntimeService;
+        _componentRegistry = DesktopComponentRegistryFactory.Create(pluginRuntimeService);
+
         InitializeComponent();
-        _componentRuntimeRegistry = DesktopComponentRuntimeRegistry.CreateDefault(_componentRegistry);
+        InitializePluginSettingsNavigation();
+        _componentRuntimeRegistry = DesktopComponentRegistryFactory.CreateRuntimeRegistry(
+            _componentRegistry,
+            pluginRuntimeService);
         _fluentAvaloniaTheme = Application.Current?.Styles.OfType<FluentAvaloniaTheme>().FirstOrDefault();
+        AppSettingsService.SettingsSaved += OnExternalAppSettingsSaved;
+        LauncherSettingsService.SettingsSaved += OnExternalLauncherSettingsSaved;
         PropertyChanged += OnWindowPropertyChanged;
         InitializeDesktopSurfaceSwipeHandlers();
         InitializeDesktopComponentDragHandlers();
+
+        PickWallpaperButton.Click += OnPickWallpaperClick;
+        ClearWallpaperButton.Click += OnClearWallpaperClick;
+        WallpaperPlacementComboBox.SelectionChanged += OnWallpaperPlacementSelectionChanged;
+
+        GridSizeSlider.ValueChanged += OnGridSizeSliderChanged;
+        GridSpacingPresetComboBox.SelectionChanged += OnGridSpacingPresetSelectionChanged;
+        GridEdgeInsetSlider.ValueChanged += OnGridEdgeInsetSliderChanged;
+        ApplyGridButton.Click += OnApplyGridSizeClick;
+
+        NightModeToggleSwitch.Checked += OnNightModeChecked;
+        NightModeToggleSwitch.Unchecked += OnNightModeUnchecked;
+        RecommendedColorButton1.Click += OnRecommendedColorClick;
+        RecommendedColorButton2.Click += OnRecommendedColorClick;
+        RecommendedColorButton3.Click += OnRecommendedColorClick;
+        RecommendedColorButton4.Click += OnRecommendedColorClick;
+        RecommendedColorButton5.Click += OnRecommendedColorClick;
+        RecommendedColorButton6.Click += OnRecommendedColorClick;
+        RefreshMonetColorsButton.Click += OnRefreshMonetColorsClick;
+        MonetColorButton1.Click += OnMonetColorClick;
+        MonetColorButton2.Click += OnMonetColorClick;
+        MonetColorButton3.Click += OnMonetColorClick;
+        MonetColorButton4.Click += OnMonetColorClick;
+        MonetColorButton5.Click += OnMonetColorClick;
+        MonetColorButton6.Click += OnMonetColorClick;
+
+        StatusBarClockToggleSwitch.Checked += OnStatusBarClockChecked;
+        StatusBarClockToggleSwitch.Unchecked += OnStatusBarClockUnchecked;
+        ClockFormatHMSSRadio.Checked += OnClockFormatChanged;
+        ClockFormatHMRadio.Checked += OnClockFormatChanged;
+        StatusBarSpacingModeComboBox.SelectionChanged += OnStatusBarSpacingModeChanged;
+        StatusBarSpacingSlider.ValueChanged += OnStatusBarSpacingSliderChanged;
+
+        WeatherPreviewButton.Click += OnTestWeatherRequestClick;
+        WeatherLocationModeComboBox.SelectionChanged += OnWeatherLocationModeSelectionChanged;
+        WeatherLocationModeChipListBox.SelectionChanged += OnWeatherLocationModeChipSelectionChanged;
+        WeatherAutoRefreshToggleSwitch.Checked += OnWeatherAutoRefreshToggled;
+        WeatherAutoRefreshToggleSwitch.Unchecked += OnWeatherAutoRefreshToggled;
+        WeatherSearchButton.Click += OnSearchWeatherCityClick;
+        WeatherApplyCityButton.Click += OnApplyWeatherCitySelectionClick;
+        WeatherApplyCoordinatesButton.Click += OnApplyWeatherCoordinatesClick;
+        WeatherExcludedAlertsTextBox.LostFocus += OnWeatherExcludedAlertsLostFocus;
+        WeatherIconPackComboBox.SelectionChanged += OnWeatherIconPackSelectionChanged;
+        WeatherNoTlsToggleSwitch.Checked += OnWeatherNoTlsToggled;
+        WeatherNoTlsToggleSwitch.Unchecked += OnWeatherNoTlsToggled;
+
+        LanguageComboBox.SelectionChanged += OnLanguageSelectionChanged;
+        TimeZoneComboBox.SelectionChanged += OnTimeZoneSelectionChanged;
+
+        AutoCheckUpdatesToggleSwitch.Checked += OnAutoCheckUpdatesToggled;
+        AutoCheckUpdatesToggleSwitch.Unchecked += OnAutoCheckUpdatesToggled;
+        UpdateChannelChipListBox.SelectionChanged += OnUpdateChannelSelectionChanged;
+        CheckForUpdatesButton.Click += OnCheckForUpdatesClick;
+        DownloadAndInstallUpdateButton.Click += OnDownloadAndInstallUpdateClick;
+
+        AutoStartWithWindowsToggleSwitch.Checked += OnAutoStartWithWindowsToggled;
+        AutoStartWithWindowsToggleSwitch.Unchecked += OnAutoStartWithWindowsToggled;
+        AppRenderModeComboBox.SelectionChanged += OnAppRenderModeSelectionChanged;
     }
 
     protected override void OnOpened(EventArgs e)
@@ -193,6 +259,8 @@ public partial class MainWindow : Window
 
         _suppressSettingsPersistence = true;
         var snapshot = _appSettingsService.Load();
+        var desktopLayoutSnapshot = _desktopLayoutSettingsService.Load();
+        var launcherSnapshot = _launcherSettingsService.Load();
 
         if (!string.IsNullOrWhiteSpace(snapshot.TimeZoneId))
         {
@@ -236,7 +304,7 @@ public partial class MainWindow : Window
         GridSizeSlider.ValueChanged += OnGridSizeSliderChanged;
         GridSizeNumberBox.ValueChanged += OnGridSizeNumberBoxChanged;
 
-        SettingsNavListBox.SelectedIndex = Math.Clamp(snapshot.SettingsTabIndex, 0, 9);
+        RestoreSettingsTabSelection(snapshot);
         UpdateSettingsTabContent();
 
         WallpaperPlacementComboBox.SelectedIndex = GetPlacementIndexFromSetting(snapshot.WallpaperPlacement);
@@ -247,9 +315,9 @@ public partial class MainWindow : Window
         _ = _componentSettingsService.Load();
         InitializeAutoStartWithWindowsSetting(snapshot);
         InitializeUpdateSettings(snapshot);
-        InitializeDesktopSurfaceState(snapshot);
-        InitializeLauncherVisibilitySettings(snapshot);
-        InitializeDesktopComponentPlacements(snapshot);
+        InitializeDesktopSurfaceState(desktopLayoutSnapshot);
+        InitializeLauncherVisibilitySettings(launcherSnapshot);
+        InitializeDesktopComponentPlacements(desktopLayoutSnapshot);
         InitializeSettingsIcons();
 
         TryRestoreWallpaper(snapshot.WallpaperPath);
@@ -309,6 +377,8 @@ public partial class MainWindow : Window
         _releaseUpdateService.Dispose();
         _wallpaperBitmap?.Dispose();
         _wallpaperBitmap = null;
+        AppSettingsService.SettingsSaved -= OnExternalAppSettingsSaved;
+        LauncherSettingsService.SettingsSaved -= OnExternalLauncherSettingsSaved;
         PropertyChanged -= OnWindowPropertyChanged;
         DesktopHost.SizeChanged -= OnDesktopHostSizeChanged;
         WallpaperPreviewHost.SizeChanged -= OnWallpaperPreviewHostSizeChanged;
@@ -1324,6 +1394,7 @@ public partial class MainWindow : Window
         _suppressTimeZoneSelectionEvents = false;
     }
 
+
     private void OnTimeZoneSelectionChanged(object? sender, SelectionChangedEventArgs e)
     {
         if (_suppressTimeZoneSelectionEvents || TimeZoneComboBox.SelectedItem is not ComboBoxItem item)
@@ -1341,4 +1412,3 @@ public partial class MainWindow : Window
         PersistSettings();
     }
 }
-

LanMountainDesktop/Views/SettingsPages/AboutSettingsPage.axaml

@@ -0,0 +1,60 @@
+<UserControl xmlns="https://github.com/avaloniaui"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+             xmlns:ui="using:FluentAvalonia.UI.Controls"
+             xmlns:fi="using:FluentIcons.Avalonia.Fluent"
+             mc:Ignorable="d" d:DesignWidth="800" d:DesignHeight="1000"
+             x:Class="LanMountainDesktop.Views.SettingsPages.AboutSettingsPage">
+
+    <StackPanel x:Name="AboutSettingsPanel" Spacing="20">
+        <TextBlock x:Name="AboutPanelTitleTextBlock" FontSize="24" FontWeight="SemiBold" Foreground="{DynamicResource AdaptiveTextPrimaryBrush}" Text="About" />
+        
+        <Border Background="{DynamicResource AdaptiveSurfaceRaisedBrush}" CornerRadius="{DynamicResource DesignCornerRadiusMd}" Padding="20">
+            <StackPanel Spacing="12">
+                <TextBlock Text="LanMountainDesktop" FontSize="20" FontWeight="SemiBold" Foreground="{DynamicResource AdaptiveTextPrimaryBrush}" />
+                <TextBlock Text="Modern desktop shell experience." FontSize="13" Foreground="{DynamicResource AdaptiveTextSecondaryBrush}" />
+                <Separator Background="{DynamicResource AdaptiveButtonBorderBrush}" Margin="0,8" />
+                <TextBlock x:Name="VersionTextBlock" Text="Version: 1.0.0" FontSize="13" Foreground="{DynamicResource AdaptiveTextPrimaryBrush}" />
+                <TextBlock x:Name="CodeNameTextBlock" Text="Code Name: Administrate" FontSize="13" FontWeight="SemiBold" Foreground="{DynamicResource AdaptiveAccentBrush}" />
+                <TextBlock x:Name="FontInfoTextBlock" Text="Font: MiSans" FontSize="12" Foreground="{DynamicResource AdaptiveTextSecondaryBrush}" />
+            </StackPanel>
+        </Border>
+
+        <Border Classes="settings-expander-shell">
+            <ui:SettingsExpander x:Name="AboutStartupSettingsExpander"
+                                 Header="Windows Startup"
+                                 Description="Launch the app automatically when signing in to Windows."
+                                 IsExpanded="True">
+                <ui:SettingsExpander.IconSource>
+                    <fi:SymbolIconSource Symbol="Window" />
+                </ui:SettingsExpander.IconSource>
+                <ui:SettingsExpander.Footer>
+                    <ToggleSwitch x:Name="AutoStartWithWindowsToggleSwitch" />
+                </ui:SettingsExpander.Footer>
+            </ui:SettingsExpander>
+        </Border>
+
+        <Border Classes="settings-expander-shell">
+            <ui:SettingsExpander x:Name="AboutRenderModeSettingsExpander"
+                                 Header="Rendering Mode"
+                                 Description="Choose the rendering backend. Restart the app after changing this option. Unsupported modes fall back to software."
+                                 IsExpanded="True">
+                <ui:SettingsExpander.IconSource>
+                    <fi:SymbolIconSource Symbol="Window" />
+                </ui:SettingsExpander.IconSource>
+                <ui:SettingsExpander.Footer>
+                    <ComboBox x:Name="AppRenderModeComboBox"
+                              MinWidth="180"
+                              HorizontalAlignment="Right">
+                        <ComboBoxItem Content="Default" Tag="Default" />
+                        <ComboBoxItem Content="Software" Tag="Software" />
+                        <ComboBoxItem Content="angleEgl" Tag="AngleEgl" />
+                        <ComboBoxItem Content="WGL" Tag="Wgl" />
+                        <ComboBoxItem Content="Vulkan" Tag="Vulkan" />
+                    </ComboBox>
+                </ui:SettingsExpander.Footer>
+            </ui:SettingsExpander>
+        </Border>
+    </StackPanel>
+</UserControl>

LanMountainDesktop/Views/SettingsPages/AboutSettingsPage.axaml.cs

@@ -0,0 +1,12 @@
+using Avalonia.Controls;
+using Avalonia.Markup.Xaml;
+
+namespace LanMountainDesktop.Views.SettingsPages;
+
+public partial class AboutSettingsPage : UserControl
+{
+    public AboutSettingsPage()
+    {
+        InitializeComponent();
+    }
+}

LanMountainDesktop/Views/SettingsPages/ColorSettingsPage.axaml

@@ -0,0 +1,204 @@
+<UserControl xmlns="https://github.com/avaloniaui"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+             xmlns:ui="using:FluentAvalonia.UI.Controls"
+             xmlns:fi="using:FluentIcons.Avalonia"
+             xmlns:ic="using:FluentIcons.Avalonia.Fluent"
+             mc:Ignorable="d" d:DesignWidth="800" d:DesignHeight="600"
+             x:Class="LanMountainDesktop.Views.SettingsPages.ColorSettingsPage">
+    <StackPanel x:Name="ColorSettingsPanel"
+                Spacing="16">
+        <TextBlock x:Name="ColorPanelTitleTextBlock"
+                   FontSize="24"
+                   FontWeight="SemiBold"
+                   Foreground="{DynamicResource AdaptiveTextPrimaryBrush}"
+                   Text="Color" />
+
+        <Border Classes="settings-expander-shell">
+            <ui:SettingsExpander x:Name="ThemeModeSettingsExpander"
+                                 Header="&#26085;&#22812;&#27169;&#24335;"
+                                 Description="&#20999;&#25442;&#24212;&#29992;&#30340;&#27973;&#33394;&#25110;&#28145;&#33394;&#20027;&#39064;&#12290;">
+                <ui:SettingsExpander.IconSource>
+
+                </ui:SettingsExpander.IconSource>
+                <ui:SettingsExpander.Footer>
+                    <ToggleSwitch x:Name="NightModeToggleSwitch"
+                                  OffContent="Day"
+                                  OnContent="Night" />
+                </ui:SettingsExpander.Footer>
+            </ui:SettingsExpander>
+        </Border>
+
+        <Border Classes="settings-expander-shell">
+            <ui:SettingsExpander x:Name="ThemeColorSettingsExpander"
+                                 Header="&#20027;&#39064;&#33394;"
+                                 Description="&#36873;&#25321;&#24212;&#29992;&#30340;&#20027;&#39064;&#28857;&#32512;&#33394;&#12290;">
+                <ui:SettingsExpander.IconSource>
+
+                </ui:SettingsExpander.IconSource>
+                
+                <ui:SettingsExpanderItem>
+                    <ui:SettingsExpanderItem.Footer>
+                        <StackPanel Spacing="12">
+                            <TextBlock x:Name="RecommendedColorsLabelTextBlock"
+                                       Foreground="{DynamicResource AdaptiveTextSecondaryBrush}"
+                                       Text="Recommended Colors" />
+                            <WrapPanel ItemWidth="72"
+                                       ItemHeight="56"
+                                       Orientation="Horizontal">
+                                <Button x:Name="RecommendedColorButton1"
+                                        Width="68"
+                                        Height="50"
+                                        Padding="8">
+                                    <Border x:Name="RecommendedColorSwatch1"
+                                            Width="26"
+                                            Height="26"
+                                            CornerRadius="12"
+                                            BorderThickness="0" />
+                                </Button>
+                                <Button x:Name="RecommendedColorButton2"
+                                        Width="68"
+                                        Height="50"
+                                        Padding="8">
+                                    <Border x:Name="RecommendedColorSwatch2"
+                                            Width="26"
+                                            Height="26"
+                                            CornerRadius="12"
+                                            BorderThickness="0" />
+                                </Button>
+                                <Button x:Name="RecommendedColorButton3"
+                                        Width="68"
+                                        Height="50"
+                                        Padding="8">
+                                    <Border x:Name="RecommendedColorSwatch3"
+                                            Width="26"
+                                            Height="26"
+                                            CornerRadius="12"
+                                            BorderThickness="0" />
+                                </Button>
+                                <Button x:Name="RecommendedColorButton4"
+                                        Width="68"
+                                        Height="50"
+                                        Padding="8">
+                                    <Border x:Name="RecommendedColorSwatch4"
+                                            Width="26"
+                                            Height="26"
+                                            CornerRadius="12"
+                                            BorderThickness="0" />
+                                </Button>
+                                <Button x:Name="RecommendedColorButton5"
+                                        Width="68"
+                                        Height="50"
+                                        Padding="8">
+                                    <Border x:Name="RecommendedColorSwatch5"
+                                            Width="26"
+                                            Height="26"
+                                            CornerRadius="12"
+                                            BorderThickness="0" />
+                                </Button>
+                                <Button x:Name="RecommendedColorButton6"
+                                        Width="68"
+                                        Height="50"
+                                        Padding="8">
+                                    <Border x:Name="RecommendedColorSwatch6"
+                                            Width="26"
+                                            Height="26"
+                                            CornerRadius="12"
+                                            BorderThickness="0" />
+                                </Button>
+                            </WrapPanel>
+                        </StackPanel>
+                    </ui:SettingsExpanderItem.Footer>
+                </ui:SettingsExpanderItem>
+
+                <ui:SettingsExpanderItem>
+                    <ui:SettingsExpanderItem.Footer>
+                        <StackPanel Spacing="12">
+                            <Grid ColumnDefinitions="*,Auto"
+                                  ColumnSpacing="10">
+                                <TextBlock x:Name="SystemMonetColorsLabelTextBlock"
+                                           VerticalAlignment="Center"
+                                           Foreground="{DynamicResource AdaptiveTextSecondaryBrush}"
+                                           Text="System Monet Colors" />
+                                <Button x:Name="RefreshMonetColorsButton"
+                                        Grid.Column="1"
+                                        Padding="10,6"
+                                        Content="Refresh" />
+                            </Grid>
+
+                            <WrapPanel ItemWidth="72"
+                                       ItemHeight="56"
+                                       Orientation="Horizontal">
+                                <Button x:Name="MonetColorButton1"
+                                        Width="68"
+                                        Height="50"
+                                        Padding="8">
+                                    <Border x:Name="MonetColorSwatch1"
+                                            Width="26"
+                                            Height="26"
+                                            CornerRadius="12"
+                                            BorderThickness="0" />
+                                </Button>
+                                <Button x:Name="MonetColorButton2"
+                                        Width="68"
+                                        Height="50"
+                                        Padding="8">
+                                    <Border x:Name="MonetColorSwatch2"
+                                            Width="26"
+                                            Height="26"
+                                            CornerRadius="12"
+                                            BorderThickness="0" />
+                                </Button>
+                                <Button x:Name="MonetColorButton3"
+                                        Width="68"
+                                        Height="50"
+                                        Padding="8">
+                                    <Border x:Name="MonetColorSwatch3"
+                                            Width="26"
+                                            Height="26"
+                                            CornerRadius="12"
+                                            BorderThickness="0" />
+                                </Button>
+                                <Button x:Name="MonetColorButton4"
+                                        Width="68"
+                                        Height="50"
+                                        Padding="8">
+                                    <Border x:Name="MonetColorSwatch4"
+                                            Width="26"
+                                            Height="26"
+                                            CornerRadius="12"
+                                            BorderThickness="0" />
+                                </Button>
+                                <Button x:Name="MonetColorButton5"
+                                        Width="68"
+                                        Height="50"
+                                        Padding="8">
+                                    <Border x:Name="MonetColorSwatch5"
+                                            Width="26"
+                                            Height="26"
+                                            CornerRadius="12"
+                                            BorderThickness="0" />
+                                </Button>
+                                <Button x:Name="MonetColorButton6"
+                                        Width="68"
+                                        Height="50"
+                                        Padding="8">
+                                    <Border x:Name="MonetColorSwatch6"
+                                            Width="26"
+                                            Height="26"
+                                            CornerRadius="12"
+                                            BorderThickness="0" />
+                                </Button>
+                            </WrapPanel>
+                        </StackPanel>
+                    </ui:SettingsExpanderItem.Footer>
+                </ui:SettingsExpanderItem>
+            </ui:SettingsExpander>
+        </Border>
+
+        <TextBlock x:Name="ThemeColorStatusTextBlock"
+                   Foreground="{DynamicResource AdaptiveTextMutedBrush}"
+                   Text="Theme color is ready." />
+    </StackPanel>
+</UserControl>

LanMountainDesktop/Views/SettingsPages/ColorSettingsPage.axaml.cs

@@ -0,0 +1,12 @@
+using Avalonia.Controls;
+using Avalonia.Markup.Xaml;
+
+namespace LanMountainDesktop.Views.SettingsPages;
+
+public partial class ColorSettingsPage : UserControl
+{
+    public ColorSettingsPage()
+    {
+        InitializeComponent();
+    }
+}

LanMountainDesktop/Views/SettingsPages/GridSettingsPage.axaml

@@ -0,0 +1,172 @@
+<UserControl xmlns="https://github.com/avaloniaui"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+             xmlns:ui="using:FluentAvalonia.UI.Controls"
+             xmlns:fi="using:FluentIcons.Avalonia"
+             xmlns:ic="using:FluentIcons.Avalonia.Fluent"
+             xmlns:comp="using:LanMountainDesktop.Views.Components"
+             mc:Ignorable="d" d:DesignWidth="800" d:DesignHeight="600"
+             x:Class="LanMountainDesktop.Views.SettingsPages.GridSettingsPage">
+    <Grid x:Name="GridSettingsPanel"
+          ColumnDefinitions="*, *"
+          RowDefinitions="Auto, *">
+        <TextBlock x:Name="GridPanelTitleTextBlock"
+                   Grid.Row="0" Grid.Column="0" Grid.ColumnSpan="2"
+                   FontSize="28"
+                   FontWeight="SemiBold"
+                   Foreground="{DynamicResource AdaptiveTextPrimaryBrush}"
+                   Margin="0,0,0,24"
+                   Text="调整网格布局" />
+
+        <!-- Left Column: Grid Preview -->
+        <Border x:Name="GridPreviewHost"
+                Grid.Row="1" Grid.Column="0"
+                Margin="0,0,16,0"
+                VerticalAlignment="Top"
+                HorizontalAlignment="Stretch">
+            <Border x:Name="GridPreviewFrame"
+                    HorizontalAlignment="Stretch"
+                    CornerRadius="28"
+                    Background="#FF1A1A1A"
+                    Padding="12">
+                <Border x:Name="GridPreviewViewport"
+                        ClipToBounds="True"
+                        CornerRadius="16"
+                        Background="#30111827">
+                    <Panel>
+                        <Canvas x:Name="GridPreviewLinesCanvas"
+                                HorizontalAlignment="Center"
+                                VerticalAlignment="Center"
+                                IsHitTestVisible="False" />
+                        <Grid x:Name="GridPreviewGrid"
+                              HorizontalAlignment="Center"
+                              VerticalAlignment="Center">
+                            <Border x:Name="GridPreviewTopStatusBarHost"
+                                Grid.Row="0"
+                                Background="Transparent"
+                                Padding="2">
+                            <StackPanel x:Name="GridPreviewTopStatusComponentsPanel"
+                                        Orientation="Horizontal"
+                                        Spacing="3">
+                            </StackPanel>
+                        </Border>
+
+                        <Border x:Name="GridPreviewBottomTaskbarContainer"
+                                Classes="glass-strong"
+                                Grid.Row="1"
+                                Margin="3"
+                                CornerRadius="16"
+                                Padding="2">
+                            <Grid ColumnDefinitions="Auto,*,Auto"
+                                  ColumnSpacing="3">
+                                <Border x:Name="GridPreviewTaskbarFixedActionsHost" Grid.Column="0">
+                                    <StackPanel x:Name="GridPreviewBackButtonVisual" Orientation="Horizontal" Spacing="3">
+                                        <fi:SymbolIcon Classes="icon-s" Symbol="Window" />
+                                        <TextBlock x:Name="GridPreviewBackButtonTextBlock" Text="回到Windows" VerticalAlignment="Center" />
+                                    </StackPanel>
+                                </Border>
+                                <StackPanel x:Name="GridPreviewTaskbarDynamicActionsHost"
+                                            Grid.Column="1"
+                                            Orientation="Horizontal"
+                                            HorizontalAlignment="Center"
+                                            Spacing="3" />
+                                <Border x:Name="GridPreviewTaskbarSettingsActionHost" Grid.Column="2">
+                                    <StackPanel Orientation="Horizontal" Spacing="3">
+                                        <StackPanel x:Name="GridPreviewComponentLibraryVisual" IsVisible="False" Orientation="Horizontal" Spacing="3">
+                                            <fi:FluentIcon x:Name="GridPreviewComponentLibraryIcon" Classes="icon-s" Icon="Apps" />
+                                            <TextBlock x:Name="GridPreviewComponentLibraryTextBlock" Text="Widget library" VerticalAlignment="Center" />
+                                        </StackPanel>
+                                        <fi:SymbolIcon x:Name="GridPreviewSettingsButtonIcon" Classes="icon-s" Symbol="Settings" />
+                                    </StackPanel>
+                                </Border>
+                            </Grid>
+                        </Border>
+                    </Grid>
+                    </Panel>
+                </Border>
+            </Border>
+        </Border>
+
+        <!-- Right Column: Settings Content -->
+        <StackPanel Grid.Row="1" Grid.Column="1"
+                    Margin="16,0,0,0"
+                    Spacing="16">
+            
+            <Border Classes="settings-expander-shell">
+                <ui:SettingsExpander x:Name="GridRowsSettingsExpander" Header="Rows" Description="Adjust the density of the grid">
+                    <ui:SettingsExpander.Footer>
+                        <Grid ColumnDefinitions="*,Auto" ColumnSpacing="12" Width="220">
+                            <Slider x:Name="GridSizeSlider"
+                                    Grid.Column="0"
+                                    Minimum="6"
+                                    Maximum="96"
+                                    TickFrequency="1"
+                                    TickPlacement="None"
+                                    Value="12" />
+                            <ui:NumberBox x:Name="GridSizeNumberBox"
+                                          Grid.Column="1"
+                                          Width="80"
+                                          Minimum="6"
+                                          Maximum="96"
+                                          Foreground="{DynamicResource AdaptiveTextPrimaryBrush}"
+                                          Value="12" />
+                        </Grid>
+                    </ui:SettingsExpander.Footer>
+                </ui:SettingsExpander>
+            </Border>
+
+            <Border Classes="settings-expander-shell">
+                <ui:SettingsExpander x:Name="GridSpacingSettingsExpander" Header="Spacing" Description="Adjust the gap between cells">
+                    <ui:SettingsExpander.Footer>
+                        <ComboBox x:Name="GridSpacingPresetComboBox"
+                                  Width="120">
+                            <ComboBoxItem x:Name="GridSpacingRelaxedComboBoxItem" Tag="Relaxed" Content="Relaxed" />
+                            <ComboBoxItem x:Name="GridSpacingCompactComboBoxItem" Tag="Compact" Content="Compact" />
+                        </ComboBox>
+                    </ui:SettingsExpander.Footer>
+                </ui:SettingsExpander>
+            </Border>
+
+            <Border Classes="settings-expander-shell">
+                <ui:SettingsExpander x:Name="GridEdgeInsetSettingsExpander" Header="Screen Inset" Description="Adjust margins around the desktop">
+                    <ui:SettingsExpander.Footer>
+                        <Grid ColumnDefinitions="*,Auto" ColumnSpacing="12" Width="220">
+                            <Slider x:Name="GridEdgeInsetSlider"
+                                    Grid.Column="0"
+                                    Minimum="0"
+                                    Maximum="30"
+                                    TickFrequency="1"
+                                    TickPlacement="None"
+                                    Value="18" />
+                            <ui:NumberBox x:Name="GridEdgeInsetNumberBox"
+                                          Grid.Column="1"
+                                          Width="80"
+                                          Minimum="0"
+                                          Maximum="30"
+                                          Foreground="{DynamicResource AdaptiveTextPrimaryBrush}"
+                                          Value="18" />
+                        </Grid>
+                    </ui:SettingsExpander.Footer>
+                    <ui:SettingsExpanderItem>
+                        <ui:SettingsExpanderItem.Footer>
+                            <TextBlock x:Name="GridEdgeInsetComputedPxTextBlock"
+                                       Foreground="{DynamicResource AdaptiveTextSecondaryBrush}"
+                                       Text=">= 0 px" />
+                        </ui:SettingsExpanderItem.Footer>
+                    </ui:SettingsExpanderItem>
+                </ui:SettingsExpander>
+            </Border>
+
+            <Button x:Name="ApplyGridButton"
+                    HorizontalAlignment="Stretch"
+                    Padding="0,10"
+                    Foreground="{DynamicResource AdaptiveTextPrimaryBrush}"
+                    Content="应用" />
+
+            <TextBlock x:Name="GridInfoTextBlock"
+                       Foreground="{DynamicResource AdaptiveTextSecondaryBrush}"
+                       Text="Grid: - cols x - rows (1:1)" />
+        </StackPanel>
+    </Grid>
+</UserControl>

LanMountainDesktop/Views/SettingsPages/GridSettingsPage.axaml.cs

@@ -0,0 +1,12 @@
+using Avalonia.Controls;
+using Avalonia.Markup.Xaml;
+
+namespace LanMountainDesktop.Views.SettingsPages;
+
+public partial class GridSettingsPage : UserControl
+{
+    public GridSettingsPage()
+    {
+        InitializeComponent();
+    }
+}

LanMountainDesktop/Views/SettingsPages/LauncherSettingsPage.axaml

@@ -0,0 +1,45 @@
+<UserControl xmlns="https://github.com/avaloniaui"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+             xmlns:ui="using:FluentAvalonia.UI.Controls"
+             xmlns:fi="using:FluentIcons.Avalonia.Fluent"
+             mc:Ignorable="d" d:DesignWidth="800" d:DesignHeight="1000"
+             x:Class="LanMountainDesktop.Views.SettingsPages.LauncherSettingsPage">
+
+    <StackPanel x:Name="LauncherSettingsPanel" Spacing="16">
+        <TextBlock x:Name="LauncherSettingsPanelTitleTextBlock"
+                   FontSize="24"
+                   FontWeight="SemiBold"
+                   Foreground="{DynamicResource AdaptiveTextPrimaryBrush}"
+                   Text="App Launcher" />
+
+        <Border Classes="settings-expander-shell">
+            <ui:SettingsExpander x:Name="LauncherHiddenItemsSettingsExpander"
+                                 Header="Hidden Items"
+                                 Description="Review hidden launcher entries and show them again."
+                                 IsExpanded="True">
+                <ui:SettingsExpander.IconSource>
+                    <ui:FontIconSource Glyph="&#xe71e;" FontFamily="{StaticResource SymbolThemeFontFamily}" />
+                </ui:SettingsExpander.IconSource>
+                <ui:SettingsExpander.Footer>
+                    <StackPanel Spacing="10">
+                        <TextBlock x:Name="LauncherHiddenItemsDescriptionTextBlock"
+                                   Foreground="{DynamicResource AdaptiveTextSecondaryBrush}"
+                                   Text="Right-click an icon in launcher to hide it. Hidden entries appear here." />
+                        <TextBlock x:Name="LauncherHiddenItemsEmptyTextBlock"
+                                   IsVisible="False"
+                                   Foreground="{DynamicResource AdaptiveTextSecondaryBrush}"
+                                   Text="No hidden items." />
+                        <ScrollViewer MaxHeight="420"
+                                      VerticalScrollBarVisibility="Auto"
+                                      HorizontalScrollBarVisibility="Disabled">
+                            <StackPanel x:Name="LauncherHiddenItemsListPanel"
+                                        Spacing="8" />
+                        </ScrollViewer>
+                    </StackPanel>
+                </ui:SettingsExpander.Footer>
+            </ui:SettingsExpander>
+        </Border>
+    </StackPanel>
+</UserControl>

LanMountainDesktop/Views/SettingsPages/LauncherSettingsPage.axaml.cs

@@ -0,0 +1,12 @@
+using Avalonia.Controls;
+using Avalonia.Markup.Xaml;
+
+namespace LanMountainDesktop.Views.SettingsPages;
+
+public partial class LauncherSettingsPage : UserControl
+{
+    public LauncherSettingsPage()
+    {
+        InitializeComponent();
+    }
+}

LanMountainDesktop/Views/SettingsPages/PluginSettingsPage.axaml

@@ -0,0 +1,68 @@
+<UserControl xmlns="https://github.com/avaloniaui"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+             xmlns:ui="using:FluentAvalonia.UI.Controls"
+             xmlns:fi="using:FluentIcons.Avalonia.Fluent"
+             mc:Ignorable="d" d:DesignWidth="800" d:DesignHeight="1000"
+             x:Class="LanMountainDesktop.Views.SettingsPages.PluginSettingsPage">
+
+    <StackPanel x:Name="PluginSettingsPanel" Spacing="16">
+        <TextBlock x:Name="PluginSettingsPanelTitleTextBlock"
+                   FontSize="24"
+                   FontWeight="SemiBold"
+                   Foreground="{DynamicResource AdaptiveTextPrimaryBrush}"
+                   Text="Plugins" />
+
+        <Border Classes="settings-expander-shell">
+            <ui:SettingsExpander x:Name="PluginSystemSettingsExpander"
+                                 Header="Plugin Runtime"
+                                 Description="Manage plugin loading and backend isolation."
+                                 IsExpanded="True">
+                <ui:SettingsExpander.IconSource>
+                    <ui:FontIconSource Glyph="&#xe734;" FontFamily="{StaticResource SymbolThemeFontFamily}" />
+                </ui:SettingsExpander.IconSource>
+                <ui:SettingsExpander.Footer>
+                    <StackPanel Spacing="10">
+                        <TextBlock x:Name="PluginSystemDescriptionTextBlock"
+                                   Foreground="{DynamicResource AdaptiveTextSecondaryBrush}"
+                                   Text="This page will host installed plugin management, permission review, and sandboxed backend runtime controls." />
+                        <Border Background="{DynamicResource AdaptiveSurfaceRaisedBrush}"
+                                CornerRadius="{DynamicResource DesignCornerRadiusSm}"
+                                Padding="14">
+                            <TextBlock x:Name="PluginSystemStatusTextBlock"
+                                       Foreground="{DynamicResource AdaptiveTextSecondaryBrush}"
+                                       TextWrapping="Wrap"
+                                       Text="Plugin management UI is not connected yet. Next step is wiring the loader, permissions, and worker isolation state into this panel." />
+                        </Border>
+                        <StackPanel x:Name="PluginRuntimeSummaryPanel" Spacing="6" />
+                    </StackPanel>
+                </ui:SettingsExpander.Footer>
+            </ui:SettingsExpander>
+        </Border>
+
+        <Border Classes="settings-expander-shell">
+            <ui:SettingsExpander x:Name="InstalledPluginsSettingsExpander"
+                                 Header="Installed Plugins"
+                                 Description="Enable plugins here. Detailed settings appear as separate settings pages."
+                                 IsExpanded="True">
+                <ui:SettingsExpander.IconSource>
+                    <ui:FontIconSource Glyph="&#xe8fd;" FontFamily="{StaticResource SymbolThemeFontFamily}" />
+                </ui:SettingsExpander.IconSource>
+                <ui:SettingsExpander.Footer>
+                    <StackPanel Spacing="10">
+                        <TextBlock x:Name="PluginRestartHintTextBlock"
+                                   Foreground="{DynamicResource AdaptiveTextSecondaryBrush}"
+                                   TextWrapping="Wrap"
+                                   Text="Plugin enable state changes take effect after restarting the app." />
+                        <TextBlock x:Name="PluginCatalogEmptyTextBlock"
+                                   Foreground="{DynamicResource AdaptiveTextSecondaryBrush}"
+                                   Text="No plugins found."
+                                   IsVisible="False" />
+                        <StackPanel x:Name="PluginCatalogItemsHost" Spacing="12" />
+                    </StackPanel>
+                </ui:SettingsExpander.Footer>
+            </ui:SettingsExpander>
+        </Border>
+    </StackPanel>
+</UserControl>

LanMountainDesktop/Views/SettingsPages/PluginSettingsPage.axaml.cs

@@ -0,0 +1,222 @@
+using System;
+using System.Globalization;
+using System.Linq;
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Layout;
+using Avalonia.Media;
+using FluentAvalonia.UI.Controls;
+using LanMountainDesktop.Services;
+
+namespace LanMountainDesktop.Views.SettingsPages;
+
+public partial class PluginSettingsPage : UserControl
+{
+    private readonly AppSettingsService _appSettingsService = new();
+    private readonly LocalizationService _localizationService = new();
+
+    public PluginSettingsPage()
+    {
+        InitializeComponent();
+        AttachedToVisualTree += (_, _) => RefreshFromRuntime();
+    }
+
+    public void RefreshFromRuntime()
+    {
+        var runtime = (Application.Current as App)?.PluginRuntimeService;
+        if (runtime is null)
+        {
+            PluginSystemStatusTextBlock.Text = L("settings.plugins.runtime_unavailable", "Plugin runtime is not available.");
+            PluginRuntimeSummaryPanel.Children.Clear();
+            PluginCatalogItemsHost.Children.Clear();
+            PluginRestartHintTextBlock.IsVisible = false;
+            return;
+        }
+
+        BuildRuntimeSummary(runtime);
+        BuildPluginCatalog(runtime);
+    }
+
+    private void BuildRuntimeSummary(PluginRuntimeService runtime)
+    {
+        var failures = runtime.LoadResults.Where(result => !result.IsSuccess).ToArray();
+        var enabledCount = runtime.Catalog.Count(entry => entry.IsEnabled);
+        PluginSystemStatusTextBlock.Text = F(
+            "settings.plugins.summary_format",
+            "Detected {0} plugin(s); enabled {1}; loaded {2}; settings pages {3}; widgets {4}; failures {5}.",
+            runtime.Catalog.Count,
+            enabledCount,
+            runtime.LoadedPlugins.Count,
+            runtime.SettingsPages.Count,
+            runtime.DesktopComponents.Count,
+            failures.Length);
+
+        PluginRuntimeSummaryPanel.Children.Clear();
+        foreach (var plugin in runtime.Catalog.OrderBy(entry => entry.Manifest.Name, StringComparer.OrdinalIgnoreCase))
+        {
+            var status = plugin.IsEnabled
+                ? plugin.IsLoaded
+                    ? L("settings.plugins.state.enabled", "Enabled")
+                    : L("settings.plugins.state.enabled_failed", "Enabled / failed to load")
+                : L("settings.plugins.state.disabled", "Disabled");
+            PluginRuntimeSummaryPanel.Children.Add(CreateSummaryLine(
+                F(
+                    "settings.plugins.summary_item_format",
+                    "{0}  v{1}  |  {2}",
+                    plugin.Manifest.Name,
+                    plugin.Manifest.Version ?? "dev",
+                    status)));
+        }
+    }
+
+    private void BuildPluginCatalog(PluginRuntimeService runtime)
+    {
+        PluginCatalogItemsHost.Children.Clear();
+
+        var plugins = runtime.Catalog
+            .OrderBy(entry => entry.Manifest.Name, StringComparer.OrdinalIgnoreCase)
+            .ToList();
+
+        PluginCatalogEmptyTextBlock.IsVisible = plugins.Count == 0;
+        PluginRestartHintTextBlock.IsVisible = plugins.Count > 0;
+
+        foreach (var plugin in plugins)
+        {
+            PluginCatalogItemsHost.Children.Add(CreatePluginCatalogItem(runtime, plugin));
+        }
+    }
+
+    private Control CreatePluginCatalogItem(PluginRuntimeService runtime, PluginCatalogEntry entry)
+    {
+        var title = new TextBlock
+        {
+            Text = entry.Manifest.Name,
+            FontSize = 16,
+            FontWeight = FontWeight.SemiBold,
+            TextWrapping = TextWrapping.Wrap
+        };
+
+        var subtitle = new TextBlock
+        {
+            Text = BuildPluginSubtitle(entry),
+            Foreground = PluginSystemDescriptionTextBlock.Foreground,
+            TextWrapping = TextWrapping.Wrap
+        };
+
+        var enabledToggle = new ToggleSwitch
+        {
+            IsChecked = entry.IsEnabled,
+            OnContent = L("settings.plugins.toggle_on", "Enabled"),
+            OffContent = L("settings.plugins.toggle_off", "Disabled"),
+            HorizontalAlignment = HorizontalAlignment.Right,
+            VerticalAlignment = VerticalAlignment.Center
+        };
+
+        enabledToggle.Checked += (_, _) => OnPluginEnableChanged(runtime, entry, true);
+        enabledToggle.Unchecked += (_, _) => OnPluginEnableChanged(runtime, entry, false);
+
+        var header = new Grid
+        {
+            ColumnDefinitions = new ColumnDefinitions("*,Auto"),
+            ColumnSpacing = 12,
+            Children =
+            {
+                new StackPanel
+                {
+                    Spacing = 4,
+                    Children = { title, subtitle }
+                },
+                enabledToggle
+            }
+        };
+        Grid.SetColumn(enabledToggle, 1);
+
+        var details = new TextBlock
+        {
+            Text = BuildPluginDetails(entry),
+            Foreground = PluginSystemDescriptionTextBlock.Foreground,
+            TextWrapping = TextWrapping.Wrap
+        };
+
+        return new Border
+        {
+            Background = new SolidColorBrush(Color.Parse("#14000000")),
+            CornerRadius = new CornerRadius(16),
+            Padding = new Thickness(14),
+            Child = new StackPanel
+            {
+                Spacing = 10,
+                Children = { header, details }
+            }
+        };
+    }
+
+    private void OnPluginEnableChanged(PluginRuntimeService runtime, PluginCatalogEntry entry, bool isEnabled)
+    {
+        runtime.SetPluginEnabled(entry.Manifest.Id, isEnabled);
+        BuildRuntimeSummary(runtime);
+        BuildPluginCatalog(runtime);
+        PluginSystemStatusTextBlock.Text = F(
+            "settings.plugins.toggle_result_format",
+            "Plugin '{0}' was {1} for the next launch. Restart the app to apply page and widget changes.",
+            entry.Manifest.Name,
+            isEnabled
+                ? L("settings.plugins.toggle_state_enabled", "enabled")
+                : L("settings.plugins.toggle_state_disabled", "disabled"));
+    }
+
+    private string BuildPluginSubtitle(PluginCatalogEntry entry)
+    {
+        var source = entry.IsPackage
+            ? L("settings.plugins.source_package", ".laapp package")
+            : L("settings.plugins.source_manifest", "Loose manifest");
+        var state = entry.IsEnabled
+            ? entry.IsLoaded
+                ? L("settings.plugins.state.loaded", "Loaded")
+                : L("settings.plugins.state.load_failed", "Load failed")
+            : L("settings.plugins.state.disabled", "Disabled");
+        return F(
+            "settings.plugins.subtitle_format",
+            "{0} | {1} | {2}",
+            state,
+            source,
+            entry.Manifest.Id);
+    }
+
+    private string BuildPluginDetails(PluginCatalogEntry entry)
+    {
+        var detail = F(
+            "settings.plugins.detail_format",
+            "Settings pages: {0} | Widgets: {1}",
+            entry.SettingsPageCount,
+            entry.WidgetCount);
+        return string.IsNullOrWhiteSpace(entry.ErrorMessage)
+            ? detail
+            : detail + Environment.NewLine + entry.ErrorMessage;
+    }
+
+    private TextBlock CreateSummaryLine(string text)
+    {
+        return new TextBlock
+        {
+            Text = text,
+            TextWrapping = TextWrapping.Wrap,
+            Foreground = PluginSystemDescriptionTextBlock.Foreground
+        };
+    }
+
+    private string L(string key, string fallback)
+    {
+        var snapshot = _appSettingsService.Load();
+        return _localizationService.GetString(snapshot.LanguageCode, key, fallback);
+    }
+
+    private string F(string key, string fallback, params object[] args)
+    {
+        return string.Format(CultureInfo.CurrentCulture, L(key, fallback), args);
+    }
+}
+
+
+
+

LanMountainDesktop/Views/SettingsPages/RegionSettingsPage.axaml

@@ -0,0 +1,49 @@
+<UserControl xmlns="https://github.com/avaloniaui"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+             xmlns:ui="using:FluentAvalonia.UI.Controls"
+             xmlns:fi="using:FluentIcons.Avalonia.Fluent"
+             mc:Ignorable="d" d:DesignWidth="800" d:DesignHeight="600"
+             x:Class="LanMountainDesktop.Views.SettingsPages.RegionSettingsPage">
+
+    <StackPanel x:Name="RegionSettingsPanel"
+                Spacing="16">
+        <TextBlock x:Name="RegionPanelTitleTextBlock"
+                   FontSize="24"
+                   FontWeight="SemiBold"
+                   Foreground="{DynamicResource AdaptiveTextPrimaryBrush}"
+                   Text="Region" />
+
+        <Border Classes="settings-expander-shell">
+            <ui:SettingsExpander x:Name="LanguageSettingsExpander"
+                                 Header="Language"
+                                 Description="Select application language. Changes apply immediately.">
+                <ui:SettingsExpander.IconSource>
+                    <fi:SymbolIconSource Symbol="Translate" />
+                </ui:SettingsExpander.IconSource>
+                <ui:SettingsExpander.Footer>
+                    <ComboBox x:Name="LanguageComboBox"
+                              Width="220">
+                        <ComboBoxItem x:Name="LanguageChineseItem" Tag="zh-CN" Content="中文" />
+                        <ComboBoxItem x:Name="LanguageEnglishItem" Tag="en-US" Content="English" />
+                    </ComboBox>
+                </ui:SettingsExpander.Footer>
+            </ui:SettingsExpander>
+        </Border>
+
+        <Border Classes="settings-expander-shell">
+            <ui:SettingsExpander x:Name="TimeZoneSettingsExpander"
+                                 Header="Time Zone"
+                                 Description="Select a time zone. Clock and calendar widgets will follow this zone.">
+                <ui:SettingsExpander.IconSource>
+                    <fi:SymbolIconSource Symbol="Clock" />
+                </ui:SettingsExpander.IconSource>
+                <ui:SettingsExpander.Footer>
+                    <ComboBox x:Name="TimeZoneComboBox"
+                              Width="280" />
+                </ui:SettingsExpander.Footer>
+            </ui:SettingsExpander>
+        </Border>
+    </StackPanel>
+</UserControl>

LanMountainDesktop/Views/SettingsPages/RegionSettingsPage.axaml.cs

@@ -0,0 +1,12 @@
+using Avalonia.Controls;
+using Avalonia.Markup.Xaml;
+
+namespace LanMountainDesktop.Views.SettingsPages;
+
+public partial class RegionSettingsPage : UserControl
+{
+    public RegionSettingsPage()
+    {
+        InitializeComponent();
+    }
+}

LanMountainDesktop/Views/SettingsPages/StatusBarSettingsPage.axaml

@@ -0,0 +1,90 @@
+<UserControl xmlns="https://github.com/avaloniaui"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+             xmlns:ui="using:FluentAvalonia.UI.Controls"
+             xmlns:fi="using:FluentIcons.Avalonia"
+             mc:Ignorable="d" d:DesignWidth="800" d:DesignHeight="600"
+             x:Class="LanMountainDesktop.Views.SettingsPages.StatusBarSettingsPage">
+    <StackPanel x:Name="StatusBarSettingsPanel"
+                Spacing="16">
+        <TextBlock x:Name="StatusBarPanelTitleTextBlock"
+                   FontSize="24"
+                   FontWeight="SemiBold"
+                   Foreground="{DynamicResource AdaptiveTextPrimaryBrush}"
+                   Text="Status Bar" />
+
+        <Border Classes="settings-expander-shell">
+            <ui:SettingsExpander x:Name="StatusBarClockSettingsExpander"
+                                 Header="&#31995;&#32479;&#26102;&#38047;"
+                                 Description="&#22312;&#29366;&#24577;&#26639;&#19978;&#26174;&#31034;&#26102;&#38388;&#12290;"
+                                 IsExpanded="False">
+                <ui:SettingsExpander.Footer>
+                    <ToggleSwitch x:Name="StatusBarClockToggleSwitch"
+                                  OnContent="On"
+                                  OffContent="Off" />
+                </ui:SettingsExpander.Footer>
+                
+                <ui:SettingsExpanderItem Content="Display Format">
+                    <ui:SettingsExpanderItem.Footer>
+                        <StackPanel Orientation="Horizontal" Spacing="16">
+                            <RadioButton x:Name="ClockFormatHMSSRadio"
+                                         Content="HH:mm:ss"
+                                         GroupName="ClockFormat"
+                                         Tag="Hms" />
+                            <RadioButton x:Name="ClockFormatHMRadio"
+                                         Content="HH:mm"
+                                         GroupName="ClockFormat"
+                                         Tag="Hm" />
+                        </StackPanel>
+                    </ui:SettingsExpanderItem.Footer>
+                </ui:SettingsExpanderItem>
+            </ui:SettingsExpander>
+        </Border>
+
+        <Border Classes="settings-expander-shell">
+            <ui:SettingsExpander x:Name="StatusBarSpacingSettingsExpander"
+                                 Header="Component spacing"
+                                 Description="Adjust spacing between status bar components."
+                                 IsExpanded="False">
+                <ui:SettingsExpander.Footer>
+                    <ComboBox x:Name="StatusBarSpacingModeComboBox"
+                              Width="150">
+                        <ComboBoxItem x:Name="StatusBarSpacingModeCompactItem" Tag="Compact" Content="Compact" />
+                        <ComboBoxItem x:Name="StatusBarSpacingModeRelaxedItem" Tag="Relaxed" Content="Relaxed" />
+                        <ComboBoxItem x:Name="StatusBarSpacingModeCustomItem" Tag="Custom" Content="Custom" />
+                    </ComboBox>
+                </ui:SettingsExpander.Footer>
+
+                <ui:SettingsExpanderItem x:Name="StatusBarSpacingCustomPanel"
+                                         Content="Custom spacing"
+                                        IsVisible="False">
+                     <ui:SettingsExpanderItem.Footer>
+                        <StackPanel Orientation="Horizontal" Spacing="12">
+                            <Slider x:Name="StatusBarSpacingSlider"
+                                    Width="150"
+                                    Minimum="0"
+                                    Maximum="30"
+                                    TickFrequency="1"
+                                    Value="12" />
+                             <ui:NumberBox x:Name="StatusBarSpacingNumberBox"
+                                           Width="80"
+                                           Minimum="0"
+                                           Maximum="30"
+                                           Value="12" />
+                        </StackPanel>
+                     </ui:SettingsExpanderItem.Footer>
+                </ui:SettingsExpanderItem>
+                
+                <ui:SettingsExpanderItem>
+                    <ui:SettingsExpanderItem.Footer>
+                        <TextBlock x:Name="StatusBarSpacingComputedPxTextBlock"
+                                   HorizontalAlignment="Right"
+                                   Foreground="{DynamicResource AdaptiveTextSecondaryBrush}"
+                                   Text=">= 0 px" />
+                    </ui:SettingsExpanderItem.Footer>
+                </ui:SettingsExpanderItem>
+            </ui:SettingsExpander>
+        </Border>
+    </StackPanel>
+</UserControl>

LanMountainDesktop/Views/SettingsPages/StatusBarSettingsPage.axaml.cs

@@ -0,0 +1,12 @@
+using Avalonia.Controls;
+using Avalonia.Markup.Xaml;
+
+namespace LanMountainDesktop.Views.SettingsPages;
+
+public partial class StatusBarSettingsPage : UserControl
+{
+    public StatusBarSettingsPage()
+    {
+        InitializeComponent();
+    }
+}

LanMountainDesktop/Views/SettingsPages/UpdateSettingsPage.axaml

@@ -0,0 +1,122 @@
+<UserControl xmlns="https://github.com/avaloniaui"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+             xmlns:ui="using:FluentAvalonia.UI.Controls"
+             xmlns:fi="using:FluentIcons.Avalonia.Fluent"
+             mc:Ignorable="d" d:DesignWidth="800" d:DesignHeight="1000"
+             x:Class="LanMountainDesktop.Views.SettingsPages.UpdateSettingsPage">
+
+    <StackPanel x:Name="UpdateSettingsPanel"
+                Spacing="16">
+        <TextBlock x:Name="UpdatePanelTitleTextBlock"
+                   FontSize="24"
+                   FontWeight="SemiBold"
+                   Foreground="{DynamicResource AdaptiveTextPrimaryBrush}"
+                   Text="Update" />
+
+        <Border Background="{DynamicResource AdaptiveSurfaceRaisedBrush}"
+                CornerRadius="{DynamicResource DesignCornerRadiusMd}"
+                Padding="20">
+            <Grid ColumnDefinitions="Auto,*" RowDefinitions="Auto,Auto,Auto" ColumnSpacing="12" RowSpacing="8">
+                <TextBlock x:Name="UpdateCurrentVersionLabelTextBlock"
+                           Text="Current Version"
+                           FontWeight="SemiBold"
+                           Foreground="{DynamicResource AdaptiveTextSecondaryBrush}" />
+                <TextBlock x:Name="UpdateCurrentVersionValueTextBlock"
+                           Grid.Column="1"
+                           Text="-"
+                           Foreground="{DynamicResource AdaptiveTextPrimaryBrush}" />
+
+                <TextBlock x:Name="UpdateLatestVersionLabelTextBlock"
+                           Grid.Row="1"
+                           Text="Latest Release"
+                           FontWeight="SemiBold"
+                           Foreground="{DynamicResource AdaptiveTextSecondaryBrush}" />
+                <TextBlock x:Name="UpdateLatestVersionValueTextBlock"
+                           Grid.Row="1" Grid.Column="1"
+                           Text="-"
+                           Foreground="{DynamicResource AdaptiveTextPrimaryBrush}" />
+
+                <TextBlock x:Name="UpdatePublishedAtLabelTextBlock"
+                           Grid.Row="2"
+                           Text="Published At"
+                           FontWeight="SemiBold"
+                           Foreground="{DynamicResource AdaptiveTextSecondaryBrush}" />
+                <TextBlock x:Name="UpdatePublishedAtValueTextBlock"
+                           Grid.Row="2" Grid.Column="1"
+                           Text="-"
+                           Foreground="{DynamicResource AdaptiveTextPrimaryBrush}" />
+            </Grid>
+        </Border>
+
+        <Border Classes="settings-expander-shell">
+            <ui:SettingsExpander x:Name="UpdateOptionsSettingsExpander"
+                                 Header="Update Options"
+                                 Description="Configure update checks and release channel."
+                                 IsExpanded="True">
+                <ui:SettingsExpander.IconSource>
+                    <fi:SymbolIconSource Symbol="Settings" />
+                </ui:SettingsExpander.IconSource>
+                <ui:SettingsExpander.Footer>
+                    <StackPanel Spacing="10">
+                        <ToggleSwitch x:Name="AutoCheckUpdatesToggleSwitch"
+                                      Content="Automatically check for updates on startup" />
+                        <TextBlock x:Name="UpdateChannelLabelTextBlock"
+                                   Text="Update Channel"
+                                   FontWeight="SemiBold"
+                                   Foreground="{DynamicResource AdaptiveTextSecondaryBrush}" />
+                        <ListBox x:Name="UpdateChannelChipListBox"
+                                 Classes="settings-chip-list">
+                            <ListBox.ItemsPanel>
+                                <ItemsPanelTemplate>
+                                    <StackPanel Orientation="Horizontal" Spacing="8" />
+                                </ItemsPanelTemplate>
+                            </ListBox.ItemsPanel>
+                            <ListBoxItem x:Name="UpdateChannelStableChipItem"
+                                         Tag="Stable"
+                                         Content="Stable" />
+                            <ListBoxItem x:Name="UpdateChannelPreviewChipItem"
+                                         Tag="Preview"
+                                         Content="Preview" />
+                        </ListBox>
+                    </StackPanel>
+                </ui:SettingsExpander.Footer>
+            </ui:SettingsExpander>
+        </Border>
+
+        <Border Classes="settings-expander-shell">
+            <ui:SettingsExpander x:Name="UpdateActionsSettingsExpander"
+                                 Header="Update Actions"
+                                 Description="Check releases, download installer, and start update."
+                                 IsExpanded="True">
+                <ui:SettingsExpander.IconSource>
+                    <fi:SymbolIconSource Symbol="ArrowSync" />
+                </ui:SettingsExpander.IconSource>
+                <ui:SettingsExpander.Footer>
+                    <StackPanel Spacing="10">
+                        <StackPanel Orientation="Horizontal" Spacing="10">
+                            <Button x:Name="CheckForUpdatesButton"
+                                    MinWidth="140"
+                                    Content="Check for Updates" />
+                            <Button x:Name="DownloadAndInstallUpdateButton"
+                                    MinWidth="180"
+                                    Content="Download &amp; Install" />
+                        </StackPanel>
+                        <ProgressBar x:Name="UpdateDownloadProgressBar"
+                                     Minimum="0"
+                                     Maximum="100"
+                                     Height="6"
+                                     IsVisible="False" />
+                        <TextBlock x:Name="UpdateDownloadProgressTextBlock"
+                                   Text="Download progress: -"
+                                   Foreground="{DynamicResource AdaptiveTextSecondaryBrush}" />
+                        <TextBlock x:Name="UpdateStatusTextBlock"
+                                   Text="Ready to check for updates."
+                                   Foreground="{DynamicResource AdaptiveTextPrimaryBrush}" />
+                    </StackPanel>
+                </ui:SettingsExpander.Footer>
+            </ui:SettingsExpander>
+        </Border>
+    </StackPanel>
+</UserControl>

LanMountainDesktop/Views/SettingsPages/UpdateSettingsPage.axaml.cs

@@ -0,0 +1,12 @@
+using Avalonia.Controls;
+using Avalonia.Markup.Xaml;
+
+namespace LanMountainDesktop.Views.SettingsPages;
+
+public partial class UpdateSettingsPage : UserControl
+{
+    public UpdateSettingsPage()
+    {
+        InitializeComponent();
+    }
+}

LanMountainDesktop/Views/SettingsPages/WallpaperSettingsPage.axaml

@@ -0,0 +1,151 @@
+<UserControl xmlns="https://github.com/avaloniaui"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+             xmlns:ui="using:FluentAvalonia.UI.Controls"
+             xmlns:fi="using:FluentIcons.Avalonia"
+             xmlns:ic="using:FluentIcons.Avalonia.Fluent"
+             xmlns:comp="using:LanMountainDesktop.Views.Components"
+             xmlns:vlc="clr-namespace:LibVLCSharp.Avalonia;assembly=LibVLCSharp.Avalonia"
+             mc:Ignorable="d" d:DesignWidth="800" d:DesignHeight="600"
+             x:Class="LanMountainDesktop.Views.SettingsPages.WallpaperSettingsPage">
+    <Grid x:Name="WallpaperSettingsPanel"
+          ColumnDefinitions="*, *"
+          RowDefinitions="Auto, *">
+        <TextBlock x:Name="WallpaperPanelTitleTextBlock"
+                   Grid.Row="0" Grid.Column="0" Grid.ColumnSpan="2"
+                   FontSize="28"
+                   FontWeight="SemiBold"
+                   Foreground="{DynamicResource AdaptiveTextPrimaryBrush}"
+                   Margin="0,0,0,24"
+                   Text="Personalize Wallpaper" />
+
+        <!-- Left Column: Monitor Preview -->
+        <Border x:Name="WallpaperPreviewHost"
+                Grid.Row="1" Grid.Column="0"
+                Margin="0,0,16,0"
+                VerticalAlignment="Stretch"
+                HorizontalAlignment="Stretch">
+            <!-- Monitor Frame (Bezel) -->
+            <Border x:Name="WallpaperPreviewFrame"
+                    HorizontalAlignment="Stretch"
+                    CornerRadius="28"
+                    Background="#FF1A1A1A"
+                    Padding="12">
+                <Border x:Name="WallpaperPreviewViewport"
+                        ClipToBounds="True"
+                        CornerRadius="12"
+                        Background="#30111827">
+                    <Grid>
+                        <vlc:VideoView x:Name="WallpaperPreviewVideoView"
+                                       IsVisible="False"
+                                       IsHitTestVisible="False"
+                                       HorizontalAlignment="Stretch"
+                                       VerticalAlignment="Stretch" />
+
+                        <Grid x:Name="WallpaperPreviewGrid"
+                              HorizontalAlignment="Center"
+                              VerticalAlignment="Center">
+                            <Border x:Name="WallpaperPreviewTopStatusBarHost"
+                                    Grid.Row="0"
+                                    Background="Transparent"
+                                    Padding="2">
+                                <StackPanel x:Name="WallpaperPreviewTopStatusComponentsPanel"
+                                            Orientation="Horizontal"
+                                            Spacing="3">
+                                    <comp:ClockWidget x:Name="WallpaperPreviewClockWidget"
+                                                      IsVisible="False" />
+                                </StackPanel>
+                            </Border>
+
+                            <Border x:Name="WallpaperPreviewBottomTaskbarContainer"
+                                    Classes="glass-strong"
+                                    Grid.Row="1"
+                                    Margin="3"
+                                    CornerRadius="16"
+                                    Padding="2">
+                                <Grid ColumnDefinitions="Auto,*,Auto"
+                                      ColumnSpacing="3">
+                                    <Border x:Name="WallpaperPreviewTaskbarFixedActionsHost" Grid.Column="0">
+                                        <StackPanel x:Name="WallpaperPreviewBackButtonVisual" Orientation="Horizontal" Spacing="3">
+                                            <fi:SymbolIcon Classes="icon-s" Symbol="Window" />
+                                            <TextBlock x:Name="WallpaperPreviewBackButtonTextBlock" Text="Back to Windows" VerticalAlignment="Center" />
+                                        </StackPanel>
+                                    </Border>
+                                     <StackPanel x:Name="WallpaperPreviewTaskbarDynamicActionsHost"
+                                                 Grid.Column="1"
+                                                 Orientation="Horizontal"
+                                                 HorizontalAlignment="Center"
+                                                 Spacing="3" />
+                                    <Border x:Name="WallpaperPreviewTaskbarSettingsActionHost" Grid.Column="2">
+                                        <StackPanel Orientation="Horizontal" Spacing="3">
+                                            <StackPanel x:Name="WallpaperPreviewComponentLibraryVisual" IsVisible="False" Orientation="Horizontal" Spacing="3">
+                                                <fi:FluentIcon Classes="icon-s" Icon="Apps" />
+                                                <TextBlock x:Name="WallpaperPreviewComponentLibraryTextBlock" Text="Widget library" VerticalAlignment="Center" />
+                                            </StackPanel>
+                                            <fi:SymbolIcon x:Name="WallpaperPreviewSettingsButtonIcon" Classes="icon-s" Symbol="Settings" />
+                                        </StackPanel>
+                                    </Border>
+                                </Grid>
+                            </Border>
+                        </Grid>
+                    </Grid>
+                </Border>
+            </Border>
+        </Border>
+
+        <!-- Right Column: Settings Content -->
+        <StackPanel Grid.Row="1" Grid.Column="1"
+                    Margin="16,0,0,0"
+                    Spacing="16">
+            <StackPanel Spacing="8">
+                <TextBlock Text="Preview status" FontSize="12" Foreground="{DynamicResource AdaptiveTextSecondaryBrush}" />
+                <TextBlock x:Name="WallpaperPathTextBlock"
+                           FontSize="14"
+                           FontWeight="Medium"
+                           Foreground="{DynamicResource AdaptiveTextPrimaryBrush}"
+                           TextTrimming="CharacterEllipsis"
+                           Text="No file selected" />
+                <TextBlock x:Name="WallpaperStatusTextBlock"
+                           FontSize="12"
+                           Foreground="{DynamicResource AdaptiveTextMutedBrush}"
+                           Text="Ready" />
+            </StackPanel>
+
+            <Separator Background="{DynamicResource SurfaceStrokeColorDefaultBrush}" Height="1" Margin="0,8" />
+
+            <TextBlock Text="Choose image or video" FontSize="16" FontWeight="SemiBold" Foreground="{DynamicResource AdaptiveTextPrimaryBrush}" />
+            
+            <Grid ColumnDefinitions="*, *" ColumnSpacing="12">
+                <Button x:Name="PickWallpaperButton"
+                        Grid.Column="0"
+                        Classes="accent"
+                        HorizontalAlignment="Stretch"
+                        Padding="0,10"
+                        Content="Browse" />
+                <Button x:Name="ClearWallpaperButton"
+                        Grid.Column="1"
+                        HorizontalAlignment="Stretch"
+                        Padding="0,10"
+                        Content="Reset" />
+            </Grid>
+
+            <Border Classes="settings-expander-shell">
+<ui:SettingsExpander x:Name="WallpaperPlacementSettingsExpander"
+                                                 Header="Placement"
+                                                 Padding="12,8">
+                <ui:SettingsExpander.Footer>
+                    <ComboBox x:Name="WallpaperPlacementComboBox"
+                              Width="120">
+                        <ComboBoxItem Content="Fill" />
+                        <ComboBoxItem Content="Fit" />
+                        <ComboBoxItem Content="Stretch" />
+                        <ComboBoxItem Content="Center" />
+                        <ComboBoxItem Content="Tile" />
+                    </ComboBox>
+                </ui:SettingsExpander.Footer>
+            </ui:SettingsExpander>
+            </Border>
+        </StackPanel>
+    </Grid>
+</UserControl>

LanMountainDesktop/Views/SettingsPages/WallpaperSettingsPage.axaml.cs

@@ -0,0 +1,12 @@
+using Avalonia.Controls;
+using Avalonia.Markup.Xaml;
+
+namespace LanMountainDesktop.Views.SettingsPages;
+
+public partial class WallpaperSettingsPage : UserControl
+{
+    public WallpaperSettingsPage()
+    {
+        InitializeComponent();
+    }
+}

LanMountainDesktop/Views/SettingsPages/WeatherSettingsPage.axaml

@@ -0,0 +1,258 @@
+<UserControl xmlns="https://github.com/avaloniaui"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+             xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+             xmlns:ui="using:FluentAvalonia.UI.Controls"
+             xmlns:fi="using:FluentIcons.Avalonia.Fluent"
+             mc:Ignorable="d" d:DesignWidth="800" d:DesignHeight="1200"
+             x:Class="LanMountainDesktop.Views.SettingsPages.WeatherSettingsPage">
+
+    <StackPanel x:Name="WeatherSettingsContentPanel"
+                Margin="0,0,8,0"
+                Spacing="16">
+        <TextBlock x:Name="WeatherPanelTitleTextBlock"
+                   FontSize="24"
+                   FontWeight="SemiBold"
+                   Foreground="{DynamicResource AdaptiveTextPrimaryBrush}"
+                   Text="Weather" />
+
+        <!-- Weather Preview Card -->
+        <Border Classes="settings-expander-shell">
+            <ui:SettingsExpander x:Name="WeatherPreviewSettingsExpander"
+                                 Header="Weather Preview"
+                                 Description="Refresh and verify current weather service status."
+                                 IsExpanded="True">
+                <ui:SettingsExpander.IconSource>
+                    <fi:SymbolIconSource Symbol="WeatherSunny" />
+                </ui:SettingsExpander.IconSource>
+                <ui:SettingsExpander.Footer>
+                    <StackPanel Orientation="Horizontal" Spacing="8">
+                        <Button x:Name="WeatherPreviewButton"
+                                Padding="12,8"
+                                Content="Refresh" />
+                        <ui:ProgressRing x:Name="WeatherPreviewProgressRing"
+                                         Width="20"
+                                         Height="20"
+                                         IsActive="True"
+                                         IsVisible="False" />
+                    </StackPanel>
+                </ui:SettingsExpander.Footer>
+                
+                <ui:SettingsExpanderItem>
+                    <Grid ColumnDefinitions="Auto,*" ColumnSpacing="12">
+                        <Border Width="44"
+                                Height="44"
+                                CornerRadius="{DynamicResource DesignCornerRadiusXs}"
+                                BorderThickness="1"
+                                BorderBrush="{DynamicResource AdaptiveButtonBorderBrush}"
+                                Background="{DynamicResource AdaptiveButtonBackgroundBrush}">
+                            <fi:SymbolIcon x:Name="WeatherPreviewIconSymbol"
+                                           Symbol="WeatherSunny"
+                                           IconVariant="Regular"
+                                           FontSize="22"
+                                           HorizontalAlignment="Center"
+                                           VerticalAlignment="Center" />
+                        </Border>
+                        <StackPanel Grid.Column="1"
+                                    VerticalAlignment="Center"
+                                    Spacing="2">
+                            <TextBlock x:Name="WeatherPreviewTemperatureTextBlock"
+                                       FontSize="22"
+                                       FontWeight="SemiBold"
+                                       Text="--°" />
+                            <TextBlock x:Name="WeatherPreviewUpdatedTextBlock"
+                                       FontSize="12"
+                                       Foreground="{DynamicResource AdaptiveTextSecondaryBrush}"
+                                       Text="-" />
+                        </StackPanel>
+                    </Grid>
+                </ui:SettingsExpanderItem>
+
+                <ui:SettingsExpanderItem>
+                    <TextBlock x:Name="WeatherPreviewResultTextBlock"
+                               Foreground="{DynamicResource AdaptiveTextSecondaryBrush}"
+                               TextWrapping="Wrap"
+                               Text="Use refresh to verify your weather configuration." />
+                </ui:SettingsExpanderItem>
+            </ui:SettingsExpander>
+        </Border>
+
+        <!-- Location Source Card -->
+        <Border Classes="settings-expander-shell">
+            <ui:SettingsExpander x:Name="WeatherLocationSettingsExpander"
+                                 Header="Location Source"
+                                 Description="Choose how weather widgets resolve location."
+                                 IsExpanded="True">
+                <ui:SettingsExpander.IconSource>
+                    <fi:SymbolIconSource Symbol="Location" />
+                </ui:SettingsExpander.IconSource>
+                <ui:SettingsExpander.Footer>
+                    <ListBox x:Name="WeatherLocationModeChipListBox"
+                             Classes="settings-chip-list"
+                             SelectionMode="Single">
+                        <ListBox.ItemsPanel>
+                            <ItemsPanelTemplate>
+                                <WrapPanel Orientation="Horizontal" />
+                            </ItemsPanelTemplate>
+                        </ListBox.ItemsPanel>
+                        <ListBoxItem x:Name="WeatherLocationModeCityChipItem"
+                                     Tag="CitySearch"
+                                     Content="City Search" />
+                        <ListBoxItem x:Name="WeatherLocationModeCoordinatesChipItem"
+                                     Tag="Coordinates"
+                                     Content="Coordinates" />
+                    </ListBox>
+                </ui:SettingsExpander.Footer>
+
+                <ui:SettingsExpanderItem>
+                    <ui:SettingsExpanderItem.Footer>
+                        <ToggleSwitch x:Name="WeatherAutoRefreshToggleSwitch"
+                                      Content="Auto refresh location on startup" />
+                    </ui:SettingsExpanderItem.Footer>
+                </ui:SettingsExpanderItem>
+
+                <!-- ComboBox hidden as in original -->
+                <ComboBox x:Name="WeatherLocationModeComboBox"
+                          IsVisible="False">
+                    <ComboBoxItem x:Name="WeatherLocationModeCityItem" Tag="CitySearch" Content="City Search" />
+                    <ComboBoxItem x:Name="WeatherLocationModeCoordinatesItem" Tag="Coordinates" Content="Coordinates" />
+                </ComboBox>
+            </ui:SettingsExpander>
+        </Border>
+
+        <!-- City Search Card -->
+        <Border Classes="settings-expander-shell">
+            <ui:SettingsExpander x:Name="WeatherCitySearchSettingsExpander"
+                                 Header="City Search"
+                                 Description="Search cities and apply one weather location."
+                                 IsExpanded="True">
+                <ui:SettingsExpander.Footer>
+                    <Button x:Name="WeatherApplyCityButton"
+                            Padding="12,8"
+                            Content="Apply City" />
+                </ui:SettingsExpander.Footer>
+
+                <ui:SettingsExpanderItem Content="Advanced Filters">
+                    <StackPanel Spacing="10">
+                        <Grid ColumnDefinitions="*,Auto,Auto" ColumnSpacing="8">
+                            <TextBox x:Name="WeatherCitySearchTextBox"
+                                     Watermark="e.g. Beijing" />
+                            <ui:ProgressRing x:Name="WeatherSearchProgressRing"
+                                             Grid.Column="1"
+                                             Width="24"
+                                             Height="24"
+                                             IsActive="True"
+                                             IsVisible="False" />
+                            <Button x:Name="WeatherSearchButton"
+                                    Grid.Column="2"
+                                    Padding="12,8"
+                                    Content="Search" />
+                        </Grid>
+                        <ComboBox x:Name="WeatherCityResultsComboBox"
+                                  Width="320" />
+                        <TextBlock x:Name="WeatherSearchStatusTextBlock"
+                                   FontSize="12"
+                                   Foreground="{DynamicResource AdaptiveTextSecondaryBrush}"
+                                   Text="Search by city name and apply one location." />
+                    </StackPanel>
+                </ui:SettingsExpanderItem>
+            </ui:SettingsExpander>
+        </Border>
+
+        <!-- Coordinates Card -->
+        <Border Classes="settings-expander-shell">
+            <ui:SettingsExpander x:Name="WeatherCoordinateSettingsExpander"
+                                 Header="Coordinates"
+                                 Description="Set latitude/longitude and optional key/name."
+                                 IsVisible="False"
+                                 IsExpanded="True">
+                <ui:SettingsExpander.Footer>
+                    <Button x:Name="WeatherApplyCoordinatesButton"
+                            Padding="12,8"
+                            Content="Apply Coordinates" />
+                </ui:SettingsExpander.Footer>
+
+                <ui:SettingsExpanderItem>
+                    <StackPanel Spacing="12">
+                        <Grid ColumnDefinitions="*,*" ColumnSpacing="10">
+                            <ui:NumberBox x:Name="WeatherLatitudeNumberBox"
+                                          Grid.Column="0"
+                                          Header="Latitude"
+                                          Minimum="-90"
+                                          Maximum="90"
+                                          SpinButtonPlacementMode="Inline"
+                                          SmallChange="0.1"
+                                          LargeChange="1"
+                                          Value="39.9042" />
+                            <ui:NumberBox x:Name="WeatherLongitudeNumberBox"
+                                          Grid.Column="1"
+                                          Header="Longitude"
+                                          Minimum="-180"
+                                          Maximum="180"
+                                          SpinButtonPlacementMode="Inline"
+                                          SmallChange="0.1"
+                                          LargeChange="1"
+                                          Value="116.4074" />
+                        </Grid>
+                        <TextBox x:Name="WeatherLocationKeyTextBox"
+                                 Watermark="Location key (optional)" />
+                        <TextBox x:Name="WeatherLocationNameTextBox"
+                                 Watermark="Display name (optional)" />
+                        <TextBlock x:Name="WeatherCoordinateStatusTextBlock"
+                                   FontSize="12"
+                                   Foreground="{DynamicResource AdaptiveTextSecondaryBrush}" />
+                    </StackPanel>
+                </ui:SettingsExpanderItem>
+            </ui:SettingsExpander>
+        </Border>
+
+        <!-- Excluded Alerts Card -->
+        <Border Classes="settings-expander-shell">
+            <ui:SettingsExpander x:Name="WeatherAlertFilterSettingsExpander"
+                                 Header="Excluded Alerts"
+                                 Description="Alerts containing these words will not be shown. One rule per line."
+                                 IsExpanded="True">
+                <ui:SettingsExpanderItem>
+                    <TextBox x:Name="WeatherExcludedAlertsTextBox"
+                             MinHeight="96"
+                             MaxHeight="220"
+                             Width="360"
+                             TextWrapping="Wrap"
+                             AcceptsReturn="True" />
+                </ui:SettingsExpanderItem>
+            </ui:SettingsExpander>
+        </Border>
+
+        <!-- Weather Style Card -->
+        <Border Classes="settings-expander-shell">
+            <ui:SettingsExpander x:Name="WeatherIconPackSettingsExpander"
+                                 Header="Weather Icon Style"
+                                 Description="Choose Fluent Icon style for weather symbols."
+                                 IsExpanded="True">
+                <ui:SettingsExpander.Footer>
+                    <ComboBox x:Name="WeatherIconPackComboBox"
+                              Width="240">
+                        <ComboBoxItem x:Name="WeatherIconPackFluentRegularItem" Tag="FluentRegular" Content="Fluent Regular" />
+                        <ComboBoxItem x:Name="WeatherIconPackFluentFilledItem" Tag="FluentFilled" Content="Fluent Filled" />
+                    </ComboBox>
+                </ui:SettingsExpander.Footer>
+            </ui:SettingsExpander>
+        </Border>
+
+        <!-- No TLS Card -->
+        <Border Classes="settings-expander-shell">
+            <ui:SettingsExpander x:Name="WeatherNoTlsSettingsExpander"
+                                 Header="No TLS Weather Request"
+                                 Description="Not recommended. Enable only for incompatible network environments."
+                                 IsExpanded="True">
+                <ui:SettingsExpander.Footer>
+                    <ToggleSwitch x:Name="WeatherNoTlsToggleSwitch" />
+                </ui:SettingsExpander.Footer>
+            </ui:SettingsExpander>
+        </Border>
+
+        <TextBlock x:Name="WeatherLocationStatusTextBlock"
+                   Foreground="{DynamicResource AdaptiveTextSecondaryBrush}"
+                   Text="No city location is configured." />
+    </StackPanel>
+</UserControl>

LanMountainDesktop/Views/SettingsPages/WeatherSettingsPage.axaml.cs

@@ -0,0 +1,12 @@
+using Avalonia.Controls;
+using Avalonia.Markup.Xaml;
+
+namespace LanMountainDesktop.Views.SettingsPages;
+
+public partial class WeatherSettingsPage : UserControl
+{
+    public WeatherSettingsPage()
+    {
+        InitializeComponent();
+    }
+}

LanMountainDesktop/Views/SettingsWindow.Controls.cs

@@ -0,0 +1,215 @@
+using Avalonia.Controls;
+using Avalonia.Media;
+using Avalonia.Media.Imaging;
+using LibVLCSharp.Avalonia;
+namespace LanMountainDesktop.Views;
+
+public partial class SettingsWindow
+{
+    // --- WallpaperSettingsPage ---
+    internal TextBlock WallpaperPanelTitleTextBlock => WallpaperSettingsPanel.FindControl<TextBlock>("WallpaperPanelTitleTextBlock")!;
+    internal TextBlock WallpaperPathTextBlock => WallpaperSettingsPanel.FindControl<TextBlock>("WallpaperPathTextBlock")!;
+    internal TextBlock WallpaperStatusTextBlock => WallpaperSettingsPanel.FindControl<TextBlock>("WallpaperStatusTextBlock")!;
+    internal ComboBox WallpaperPlacementComboBox => WallpaperSettingsPanel.FindControl<ComboBox>("WallpaperPlacementComboBox")!;
+    internal Border WallpaperPreviewHost => WallpaperSettingsPanel.FindControl<Border>("WallpaperPreviewHost")!;
+    internal Border WallpaperPreviewFrame => WallpaperSettingsPanel.FindControl<Border>("WallpaperPreviewFrame")!;
+    internal Border WallpaperPreviewViewport => WallpaperSettingsPanel.FindControl<Border>("WallpaperPreviewViewport")!;
+    internal LibVLCSharp.Avalonia.VideoView? WallpaperPreviewVideoView => WallpaperSettingsPanel.FindControl<LibVLCSharp.Avalonia.VideoView>("WallpaperPreviewVideoView");
+    internal Grid WallpaperPreviewGrid => WallpaperSettingsPanel.FindControl<Grid>("WallpaperPreviewGrid")!;
+    internal Border WallpaperPreviewTopStatusBarHost => WallpaperSettingsPanel.FindControl<Border>("WallpaperPreviewTopStatusBarHost")!;
+    internal StackPanel WallpaperPreviewTopStatusComponentsPanel => WallpaperSettingsPanel.FindControl<StackPanel>("WallpaperPreviewTopStatusComponentsPanel")!;
+    internal LanMountainDesktop.Views.Components.ClockWidget WallpaperPreviewClockWidget => WallpaperSettingsPanel.FindControl<LanMountainDesktop.Views.Components.ClockWidget>("WallpaperPreviewClockWidget")!;
+    internal Border WallpaperPreviewBottomTaskbarContainer => WallpaperSettingsPanel.FindControl<Border>("WallpaperPreviewBottomTaskbarContainer")!;
+    internal Border WallpaperPreviewTaskbarFixedActionsHost => WallpaperSettingsPanel.FindControl<Border>("WallpaperPreviewTaskbarFixedActionsHost")!;
+    internal StackPanel WallpaperPreviewBackButtonVisual => WallpaperSettingsPanel.FindControl<StackPanel>("WallpaperPreviewBackButtonVisual")!;
+    internal TextBlock WallpaperPreviewBackButtonTextBlock => WallpaperSettingsPanel.FindControl<TextBlock>("WallpaperPreviewBackButtonTextBlock")!;
+    internal StackPanel WallpaperPreviewTaskbarDynamicActionsHost => WallpaperSettingsPanel.FindControl<StackPanel>("WallpaperPreviewTaskbarDynamicActionsHost")!;
+    internal Border WallpaperPreviewTaskbarSettingsActionHost => WallpaperSettingsPanel.FindControl<Border>("WallpaperPreviewTaskbarSettingsActionHost")!;
+    internal StackPanel WallpaperPreviewComponentLibraryVisual => WallpaperSettingsPanel.FindControl<StackPanel>("WallpaperPreviewComponentLibraryVisual")!;
+    internal TextBlock WallpaperPreviewComponentLibraryTextBlock => WallpaperSettingsPanel.FindControl<TextBlock>("WallpaperPreviewComponentLibraryTextBlock")!;
+    internal FluentIcons.Avalonia.SymbolIcon WallpaperPreviewSettingsButtonIcon => WallpaperSettingsPanel.FindControl<FluentIcons.Avalonia.SymbolIcon>("WallpaperPreviewSettingsButtonIcon")!;
+    internal Button PickWallpaperButton => WallpaperSettingsPanel.FindControl<Button>("PickWallpaperButton")!;
+    internal Button ClearWallpaperButton => WallpaperSettingsPanel.FindControl<Button>("ClearWallpaperButton")!;
+    internal FluentAvalonia.UI.Controls.SettingsExpander WallpaperPlacementSettingsExpander => WallpaperSettingsPanel.FindControl<FluentAvalonia.UI.Controls.SettingsExpander>("WallpaperPlacementSettingsExpander")!;
+
+    // --- GridSettingsPage ---
+    internal TextBlock GridPanelTitleTextBlock => GridSettingsPanel.FindControl<TextBlock>("GridPanelTitleTextBlock")!;
+    internal Border GridPreviewHost => GridSettingsPanel.FindControl<Border>("GridPreviewHost")!;
+    internal Border GridPreviewFrame => GridSettingsPanel.FindControl<Border>("GridPreviewFrame")!;
+    internal Border GridPreviewViewport => GridSettingsPanel.FindControl<Border>("GridPreviewViewport")!;
+    internal Canvas GridPreviewLinesCanvas => GridSettingsPanel.FindControl<Canvas>("GridPreviewLinesCanvas")!;
+    internal Grid GridPreviewGrid => GridSettingsPanel.FindControl<Grid>("GridPreviewGrid")!;
+    internal Border GridPreviewTopStatusBarHost => GridSettingsPanel.FindControl<Border>("GridPreviewTopStatusBarHost")!;
+    internal StackPanel GridPreviewTopStatusComponentsPanel => GridSettingsPanel.FindControl<StackPanel>("GridPreviewTopStatusComponentsPanel")!;
+    internal Border GridPreviewBottomTaskbarContainer => GridSettingsPanel.FindControl<Border>("GridPreviewBottomTaskbarContainer")!;
+    internal Border GridPreviewTaskbarFixedActionsHost => GridSettingsPanel.FindControl<Border>("GridPreviewTaskbarFixedActionsHost")!;
+    internal StackPanel GridPreviewBackButtonVisual => GridSettingsPanel.FindControl<StackPanel>("GridPreviewBackButtonVisual")!;
+    internal TextBlock GridPreviewBackButtonTextBlock => GridSettingsPanel.FindControl<TextBlock>("GridPreviewBackButtonTextBlock")!;
+    internal StackPanel GridPreviewTaskbarDynamicActionsHost => GridSettingsPanel.FindControl<StackPanel>("GridPreviewTaskbarDynamicActionsHost")!;
+    internal Border GridPreviewTaskbarSettingsActionHost => GridSettingsPanel.FindControl<Border>("GridPreviewTaskbarSettingsActionHost")!;
+    internal StackPanel GridPreviewComponentLibraryVisual => GridSettingsPanel.FindControl<StackPanel>("GridPreviewComponentLibraryVisual")!;
+    internal FluentIcons.Avalonia.FluentIcon GridPreviewComponentLibraryIcon => GridSettingsPanel.FindControl<FluentIcons.Avalonia.FluentIcon>("GridPreviewComponentLibraryIcon")!;
+    internal TextBlock GridPreviewComponentLibraryTextBlock => GridSettingsPanel.FindControl<TextBlock>("GridPreviewComponentLibraryTextBlock")!;
+    internal FluentIcons.Avalonia.SymbolIcon GridPreviewSettingsButtonIcon => GridSettingsPanel.FindControl<FluentIcons.Avalonia.SymbolIcon>("GridPreviewSettingsButtonIcon")!;
+    internal FluentAvalonia.UI.Controls.SettingsExpander GridRowsSettingsExpander => GridSettingsPanel.FindControl<FluentAvalonia.UI.Controls.SettingsExpander>("GridRowsSettingsExpander")!;
+    internal FluentAvalonia.UI.Controls.SettingsExpander GridSpacingSettingsExpander => GridSettingsPanel.FindControl<FluentAvalonia.UI.Controls.SettingsExpander>("GridSpacingSettingsExpander")!;
+    internal FluentAvalonia.UI.Controls.SettingsExpander GridEdgeInsetSettingsExpander => GridSettingsPanel.FindControl<FluentAvalonia.UI.Controls.SettingsExpander>("GridEdgeInsetSettingsExpander")!;
+    internal Slider GridSizeSlider => GridSettingsPanel.FindControl<Slider>("GridSizeSlider")!;
+    internal FluentAvalonia.UI.Controls.NumberBox GridSizeNumberBox => GridSettingsPanel.FindControl<FluentAvalonia.UI.Controls.NumberBox>("GridSizeNumberBox")!;
+    internal ComboBox GridSpacingPresetComboBox => GridSettingsPanel.FindControl<ComboBox>("GridSpacingPresetComboBox")!;
+    internal ComboBoxItem GridSpacingRelaxedComboBoxItem => GridSettingsPanel.FindControl<ComboBoxItem>("GridSpacingRelaxedComboBoxItem")!;
+    internal ComboBoxItem GridSpacingCompactComboBoxItem => GridSettingsPanel.FindControl<ComboBoxItem>("GridSpacingCompactComboBoxItem")!;
+    internal Slider GridEdgeInsetSlider => GridSettingsPanel.FindControl<Slider>("GridEdgeInsetSlider")!;
+    internal FluentAvalonia.UI.Controls.NumberBox GridEdgeInsetNumberBox => GridSettingsPanel.FindControl<FluentAvalonia.UI.Controls.NumberBox>("GridEdgeInsetNumberBox")!;
+    internal TextBlock GridEdgeInsetComputedPxTextBlock => GridSettingsPanel.FindControl<TextBlock>("GridEdgeInsetComputedPxTextBlock")!;
+    internal Button ApplyGridButton => GridSettingsPanel.FindControl<Button>("ApplyGridButton")!;
+    internal TextBlock GridInfoTextBlock => GridSettingsPanel.FindControl<TextBlock>("GridInfoTextBlock")!;
+
+    // --- ColorSettingsPage ---
+    internal TextBlock ColorPanelTitleTextBlock => ColorSettingsPanel.FindControl<TextBlock>("ColorPanelTitleTextBlock")!;
+    internal FluentAvalonia.UI.Controls.SettingsExpander ThemeModeSettingsExpander => ColorSettingsPanel.FindControl<FluentAvalonia.UI.Controls.SettingsExpander>("ThemeModeSettingsExpander")!;
+    internal FluentAvalonia.UI.Controls.SettingsExpander ThemeColorSettingsExpander => ColorSettingsPanel.FindControl<FluentAvalonia.UI.Controls.SettingsExpander>("ThemeColorSettingsExpander")!;
+    internal ToggleSwitch NightModeToggleSwitch => ColorSettingsPanel.FindControl<ToggleSwitch>("NightModeToggleSwitch")!;
+    internal TextBlock ThemeColorStatusTextBlock => ColorSettingsPanel.FindControl<TextBlock>("ThemeColorStatusTextBlock")!;
+    internal TextBlock RecommendedColorsLabelTextBlock => ColorSettingsPanel.FindControl<TextBlock>("RecommendedColorsLabelTextBlock")!;
+    internal TextBlock SystemMonetColorsLabelTextBlock => ColorSettingsPanel.FindControl<TextBlock>("SystemMonetColorsLabelTextBlock")!;
+    internal Button RecommendedColorButton1 => ColorSettingsPanel.FindControl<Button>("RecommendedColorButton1")!;
+    internal Button RecommendedColorButton2 => ColorSettingsPanel.FindControl<Button>("RecommendedColorButton2")!;
+    internal Button RecommendedColorButton3 => ColorSettingsPanel.FindControl<Button>("RecommendedColorButton3")!;
+    internal Button RecommendedColorButton4 => ColorSettingsPanel.FindControl<Button>("RecommendedColorButton4")!;
+    internal Button RecommendedColorButton5 => ColorSettingsPanel.FindControl<Button>("RecommendedColorButton5")!;
+    internal Button RecommendedColorButton6 => ColorSettingsPanel.FindControl<Button>("RecommendedColorButton6")!;
+    internal Border RecommendedColorSwatch1 => ColorSettingsPanel.FindControl<Border>("RecommendedColorSwatch1")!;
+    internal Border RecommendedColorSwatch2 => ColorSettingsPanel.FindControl<Border>("RecommendedColorSwatch2")!;
+    internal Border RecommendedColorSwatch3 => ColorSettingsPanel.FindControl<Border>("RecommendedColorSwatch3")!;
+    internal Border RecommendedColorSwatch4 => ColorSettingsPanel.FindControl<Border>("RecommendedColorSwatch4")!;
+    internal Border RecommendedColorSwatch5 => ColorSettingsPanel.FindControl<Border>("RecommendedColorSwatch5")!;
+    internal Border RecommendedColorSwatch6 => ColorSettingsPanel.FindControl<Border>("RecommendedColorSwatch6")!;
+    internal Button RefreshMonetColorsButton => ColorSettingsPanel.FindControl<Button>("RefreshMonetColorsButton")!;
+    internal Button MonetColorButton1 => ColorSettingsPanel.FindControl<Button>("MonetColorButton1")!;
+    internal Button MonetColorButton2 => ColorSettingsPanel.FindControl<Button>("MonetColorButton2")!;
+    internal Button MonetColorButton3 => ColorSettingsPanel.FindControl<Button>("MonetColorButton3")!;
+    internal Button MonetColorButton4 => ColorSettingsPanel.FindControl<Button>("MonetColorButton4")!;
+    internal Button MonetColorButton5 => ColorSettingsPanel.FindControl<Button>("MonetColorButton5")!;
+    internal Button MonetColorButton6 => ColorSettingsPanel.FindControl<Button>("MonetColorButton6")!;
+    internal Border MonetColorSwatch1 => ColorSettingsPanel.FindControl<Border>("MonetColorSwatch1")!;
+    internal Border MonetColorSwatch2 => ColorSettingsPanel.FindControl<Border>("MonetColorSwatch2")!;
+    internal Border MonetColorSwatch3 => ColorSettingsPanel.FindControl<Border>("MonetColorSwatch3")!;
+    internal Border MonetColorSwatch4 => ColorSettingsPanel.FindControl<Border>("MonetColorSwatch4")!;
+    internal Border MonetColorSwatch5 => ColorSettingsPanel.FindControl<Border>("MonetColorSwatch5")!;
+    internal Border MonetColorSwatch6 => ColorSettingsPanel.FindControl<Border>("MonetColorSwatch6")!;
+
+    // --- StatusBarSettingsPage ---
+    internal TextBlock StatusBarPanelTitleTextBlock => StatusBarSettingsPanel.FindControl<TextBlock>("StatusBarPanelTitleTextBlock")!;
+    internal FluentAvalonia.UI.Controls.SettingsExpander StatusBarClockSettingsExpander => StatusBarSettingsPanel.FindControl<FluentAvalonia.UI.Controls.SettingsExpander>("StatusBarClockSettingsExpander")!;
+    internal FluentAvalonia.UI.Controls.SettingsExpander StatusBarSpacingSettingsExpander => StatusBarSettingsPanel.FindControl<FluentAvalonia.UI.Controls.SettingsExpander>("StatusBarSpacingSettingsExpander")!;
+    internal ToggleSwitch StatusBarClockToggleSwitch => StatusBarSettingsPanel.FindControl<ToggleSwitch>("StatusBarClockToggleSwitch")!;
+    internal RadioButton ClockFormatHMSSRadio => StatusBarSettingsPanel.FindControl<RadioButton>("ClockFormatHMSSRadio")!;
+    internal RadioButton ClockFormatHMRadio => StatusBarSettingsPanel.FindControl<RadioButton>("ClockFormatHMRadio")!;
+    internal ComboBox StatusBarSpacingModeComboBox => StatusBarSettingsPanel.FindControl<ComboBox>("StatusBarSpacingModeComboBox")!;
+    internal ComboBoxItem StatusBarSpacingModeCompactItem => StatusBarSettingsPanel.FindControl<ComboBoxItem>("StatusBarSpacingModeCompactItem")!;
+    internal ComboBoxItem StatusBarSpacingModeRelaxedItem => StatusBarSettingsPanel.FindControl<ComboBoxItem>("StatusBarSpacingModeRelaxedItem")!;
+    internal ComboBoxItem StatusBarSpacingModeCustomItem => StatusBarSettingsPanel.FindControl<ComboBoxItem>("StatusBarSpacingModeCustomItem")!;
+    internal FluentAvalonia.UI.Controls.SettingsExpanderItem StatusBarSpacingCustomPanel => StatusBarSettingsPanel.FindControl<FluentAvalonia.UI.Controls.SettingsExpanderItem>("StatusBarSpacingCustomPanel")!;
+    internal Slider StatusBarSpacingSlider => StatusBarSettingsPanel.FindControl<Slider>("StatusBarSpacingSlider")!;
+    internal FluentAvalonia.UI.Controls.NumberBox StatusBarSpacingNumberBox => StatusBarSettingsPanel.FindControl<FluentAvalonia.UI.Controls.NumberBox>("StatusBarSpacingNumberBox")!;
+    internal TextBlock StatusBarSpacingComputedPxTextBlock => StatusBarSettingsPanel.FindControl<TextBlock>("StatusBarSpacingComputedPxTextBlock")!;
+
+    // --- RegionSettingsPage ---
+    internal TextBlock RegionPanelTitleTextBlock => RegionSettingsPanel.FindControl<TextBlock>("RegionPanelTitleTextBlock")!;
+    internal FluentAvalonia.UI.Controls.SettingsExpander LanguageSettingsExpander => RegionSettingsPanel.FindControl<FluentAvalonia.UI.Controls.SettingsExpander>("LanguageSettingsExpander")!;
+    internal FluentAvalonia.UI.Controls.SettingsExpander TimeZoneSettingsExpander => RegionSettingsPanel.FindControl<FluentAvalonia.UI.Controls.SettingsExpander>("TimeZoneSettingsExpander")!;
+    internal ComboBox LanguageComboBox => RegionSettingsPanel.FindControl<ComboBox>("LanguageComboBox")!;
+    internal ComboBoxItem LanguageChineseItem => RegionSettingsPanel.FindControl<ComboBoxItem>("LanguageChineseItem")!;
+    internal ComboBoxItem LanguageEnglishItem => RegionSettingsPanel.FindControl<ComboBoxItem>("LanguageEnglishItem")!;
+    internal ComboBox TimeZoneComboBox => RegionSettingsPanel.FindControl<ComboBox>("TimeZoneComboBox")!;
+
+    // --- WeatherSettingsPage ---
+    internal TextBlock WeatherPanelTitleTextBlock => WeatherSettingsPanel.FindControl<TextBlock>("WeatherPanelTitleTextBlock")!;
+    internal FluentAvalonia.UI.Controls.SettingsExpander WeatherPreviewSettingsExpander => WeatherSettingsPanel.FindControl<FluentAvalonia.UI.Controls.SettingsExpander>("WeatherPreviewSettingsExpander")!;
+    internal FluentAvalonia.UI.Controls.SettingsExpander WeatherLocationSettingsExpander => WeatherSettingsPanel.FindControl<FluentAvalonia.UI.Controls.SettingsExpander>("WeatherLocationSettingsExpander")!;
+    internal FluentAvalonia.UI.Controls.SettingsExpander WeatherCitySearchSettingsExpander => WeatherSettingsPanel.FindControl<FluentAvalonia.UI.Controls.SettingsExpander>("WeatherCitySearchSettingsExpander")!;
+    internal FluentAvalonia.UI.Controls.SettingsExpander WeatherCoordinateSettingsExpander => WeatherSettingsPanel.FindControl<FluentAvalonia.UI.Controls.SettingsExpander>("WeatherCoordinateSettingsExpander")!;
+    internal FluentAvalonia.UI.Controls.SettingsExpander WeatherAlertFilterSettingsExpander => WeatherSettingsPanel.FindControl<FluentAvalonia.UI.Controls.SettingsExpander>("WeatherAlertFilterSettingsExpander")!;
+    internal FluentAvalonia.UI.Controls.SettingsExpander WeatherIconPackSettingsExpander => WeatherSettingsPanel.FindControl<FluentAvalonia.UI.Controls.SettingsExpander>("WeatherIconPackSettingsExpander")!;
+    internal FluentAvalonia.UI.Controls.SettingsExpander WeatherNoTlsSettingsExpander => WeatherSettingsPanel.FindControl<FluentAvalonia.UI.Controls.SettingsExpander>("WeatherNoTlsSettingsExpander")!;
+    internal Button WeatherPreviewButton => WeatherSettingsPanel.FindControl<Button>("WeatherPreviewButton")!;
+    internal ComboBox WeatherLocationModeComboBox => WeatherSettingsPanel.FindControl<ComboBox>("WeatherLocationModeComboBox")!;
+    internal ComboBoxItem WeatherLocationModeCityItem => WeatherSettingsPanel.FindControl<ComboBoxItem>("WeatherLocationModeCityItem")!;
+    internal ComboBoxItem WeatherLocationModeCoordinatesItem => WeatherSettingsPanel.FindControl<ComboBoxItem>("WeatherLocationModeCoordinatesItem")!;
+    internal ListBoxItem WeatherLocationModeCityChipItem => WeatherSettingsPanel.FindControl<ListBoxItem>("WeatherLocationModeCityChipItem")!;
+    internal ListBoxItem WeatherLocationModeCoordinatesChipItem => WeatherSettingsPanel.FindControl<ListBoxItem>("WeatherLocationModeCoordinatesChipItem")!;
+    internal ListBox WeatherLocationModeChipListBox => WeatherSettingsPanel.FindControl<ListBox>("WeatherLocationModeChipListBox")!;
+    internal ToggleSwitch WeatherAutoRefreshToggleSwitch => WeatherSettingsPanel.FindControl<ToggleSwitch>("WeatherAutoRefreshToggleSwitch")!;
+    internal Button WeatherSearchButton => WeatherSettingsPanel.FindControl<Button>("WeatherSearchButton")!;
+    internal Button WeatherApplyCityButton => WeatherSettingsPanel.FindControl<Button>("WeatherApplyCityButton")!;
+    internal Button WeatherApplyCoordinatesButton => WeatherSettingsPanel.FindControl<Button>("WeatherApplyCoordinatesButton")!;
+    internal TextBox WeatherExcludedAlertsTextBox => WeatherSettingsPanel.FindControl<TextBox>("WeatherExcludedAlertsTextBox")!;
+    internal ComboBox WeatherIconPackComboBox => WeatherSettingsPanel.FindControl<ComboBox>("WeatherIconPackComboBox")!;
+    internal ToggleSwitch WeatherNoTlsToggleSwitch => WeatherSettingsPanel.FindControl<ToggleSwitch>("WeatherNoTlsToggleSwitch")!;
+    internal TextBox WeatherCitySearchTextBox => WeatherSettingsPanel.FindControl<TextBox>("WeatherCitySearchTextBox")!;
+    internal ComboBox WeatherCityResultsComboBox => WeatherSettingsPanel.FindControl<ComboBox>("WeatherCityResultsComboBox")!;
+    internal TextBlock WeatherSearchStatusTextBlock => WeatherSettingsPanel.FindControl<TextBlock>("WeatherSearchStatusTextBlock")!;
+    internal TextBox WeatherLocationKeyTextBox => WeatherSettingsPanel.FindControl<TextBox>("WeatherLocationKeyTextBox")!;
+    internal TextBox WeatherLocationNameTextBox => WeatherSettingsPanel.FindControl<TextBox>("WeatherLocationNameTextBox")!;
+    internal FluentAvalonia.UI.Controls.NumberBox WeatherLatitudeNumberBox => WeatherSettingsPanel.FindControl<FluentAvalonia.UI.Controls.NumberBox>("WeatherLatitudeNumberBox")!;
+    internal FluentAvalonia.UI.Controls.NumberBox WeatherLongitudeNumberBox => WeatherSettingsPanel.FindControl<FluentAvalonia.UI.Controls.NumberBox>("WeatherLongitudeNumberBox")!;
+    internal TextBlock WeatherCoordinateStatusTextBlock => WeatherSettingsPanel.FindControl<TextBlock>("WeatherCoordinateStatusTextBlock")!;
+    internal TextBlock WeatherPreviewResultTextBlock => WeatherSettingsPanel.FindControl<TextBlock>("WeatherPreviewResultTextBlock")!;
+    internal FluentIcons.Avalonia.Fluent.SymbolIcon WeatherPreviewIconSymbol => WeatherSettingsPanel.FindControl<FluentIcons.Avalonia.Fluent.SymbolIcon>("WeatherPreviewIconSymbol")!;
+    internal TextBlock WeatherPreviewTemperatureTextBlock => WeatherSettingsPanel.FindControl<TextBlock>("WeatherPreviewTemperatureTextBlock")!;
+    internal TextBlock WeatherPreviewUpdatedTextBlock => WeatherSettingsPanel.FindControl<TextBlock>("WeatherPreviewUpdatedTextBlock")!;
+    internal FluentAvalonia.UI.Controls.ProgressRing WeatherSearchProgressRing => WeatherSettingsPanel.FindControl<FluentAvalonia.UI.Controls.ProgressRing>("WeatherSearchProgressRing")!;
+    internal FluentAvalonia.UI.Controls.ProgressRing WeatherPreviewProgressRing => WeatherSettingsPanel.FindControl<FluentAvalonia.UI.Controls.ProgressRing>("WeatherPreviewProgressRing")!;
+    internal ComboBoxItem WeatherIconPackFluentRegularItem => WeatherSettingsPanel.FindControl<ComboBoxItem>("WeatherIconPackFluentRegularItem")!;
+    internal ComboBoxItem WeatherIconPackFluentFilledItem => WeatherSettingsPanel.FindControl<ComboBoxItem>("WeatherIconPackFluentFilledItem")!;
+    internal TextBlock WeatherLocationStatusTextBlock => WeatherSettingsPanel.FindControl<TextBlock>("WeatherLocationStatusTextBlock")!;
+
+    // --- UpdateSettingsPage ---
+    internal TextBlock UpdatePanelTitleTextBlock => UpdateSettingsPanel.FindControl<TextBlock>("UpdatePanelTitleTextBlock")!;
+    internal FluentAvalonia.UI.Controls.SettingsExpander UpdateOptionsSettingsExpander => UpdateSettingsPanel.FindControl<FluentAvalonia.UI.Controls.SettingsExpander>("UpdateOptionsSettingsExpander")!;
+    internal FluentAvalonia.UI.Controls.SettingsExpander UpdateActionsSettingsExpander => UpdateSettingsPanel.FindControl<FluentAvalonia.UI.Controls.SettingsExpander>("UpdateActionsSettingsExpander")!;
+    internal TextBlock UpdateCurrentVersionLabelTextBlock => UpdateSettingsPanel.FindControl<TextBlock>("UpdateCurrentVersionLabelTextBlock")!;
+    internal TextBlock UpdateCurrentVersionValueTextBlock => UpdateSettingsPanel.FindControl<TextBlock>("UpdateCurrentVersionValueTextBlock")!;
+    internal TextBlock UpdateLatestVersionLabelTextBlock => UpdateSettingsPanel.FindControl<TextBlock>("UpdateLatestVersionLabelTextBlock")!;
+    internal TextBlock UpdateLatestVersionValueTextBlock => UpdateSettingsPanel.FindControl<TextBlock>("UpdateLatestVersionValueTextBlock")!;
+    internal TextBlock UpdatePublishedAtLabelTextBlock => UpdateSettingsPanel.FindControl<TextBlock>("UpdatePublishedAtLabelTextBlock")!;
+    internal TextBlock UpdatePublishedAtValueTextBlock => UpdateSettingsPanel.FindControl<TextBlock>("UpdatePublishedAtValueTextBlock")!;
+    internal TextBlock UpdateChannelLabelTextBlock => UpdateSettingsPanel.FindControl<TextBlock>("UpdateChannelLabelTextBlock")!;
+    internal ListBoxItem UpdateChannelStableChipItem => UpdateSettingsPanel.FindControl<ListBoxItem>("UpdateChannelStableChipItem")!;
+    internal ListBoxItem UpdateChannelPreviewChipItem => UpdateSettingsPanel.FindControl<ListBoxItem>("UpdateChannelPreviewChipItem")!;
+    internal ToggleSwitch AutoCheckUpdatesToggleSwitch => UpdateSettingsPanel.FindControl<ToggleSwitch>("AutoCheckUpdatesToggleSwitch")! ;
+    internal ListBox UpdateChannelChipListBox => UpdateSettingsPanel.FindControl<ListBox>("UpdateChannelChipListBox")!;
+    internal Button CheckForUpdatesButton => UpdateSettingsPanel.FindControl<Button>("CheckForUpdatesButton")!;
+    internal Button DownloadAndInstallUpdateButton => UpdateSettingsPanel.FindControl<Button>("DownloadAndInstallUpdateButton")!;
+    internal ProgressBar UpdateDownloadProgressBar => UpdateSettingsPanel.FindControl<ProgressBar>("UpdateDownloadProgressBar")!;
+    internal TextBlock UpdateDownloadProgressTextBlock => UpdateSettingsPanel.FindControl<TextBlock>("UpdateDownloadProgressTextBlock")!;
+    internal TextBlock UpdateStatusTextBlock => UpdateSettingsPanel.FindControl<TextBlock>("UpdateStatusTextBlock")!;
+
+    // --- AboutSettingsPage ---
+    internal TextBlock AboutPanelTitleTextBlock => AboutSettingsPanel.FindControl<TextBlock>("AboutPanelTitleTextBlock")!;
+    internal FluentAvalonia.UI.Controls.SettingsExpander AboutStartupSettingsExpander => AboutSettingsPanel.FindControl<FluentAvalonia.UI.Controls.SettingsExpander>("AboutStartupSettingsExpander")!;
+    internal FluentAvalonia.UI.Controls.SettingsExpander AboutRenderModeSettingsExpander => AboutSettingsPanel.FindControl<FluentAvalonia.UI.Controls.SettingsExpander>("AboutRenderModeSettingsExpander")!;
+    internal ToggleSwitch AutoStartWithWindowsToggleSwitch => AboutSettingsPanel.FindControl<ToggleSwitch>("AutoStartWithWindowsToggleSwitch")!;
+    internal ComboBox AppRenderModeComboBox => AboutSettingsPanel.FindControl<ComboBox>("AppRenderModeComboBox")!;
+    internal TextBlock VersionTextBlock => AboutSettingsPanel.FindControl<TextBlock>("VersionTextBlock")!;
+    internal TextBlock CodeNameTextBlock => AboutSettingsPanel.FindControl<TextBlock>("CodeNameTextBlock")!;
+    internal TextBlock FontInfoTextBlock => AboutSettingsPanel.FindControl<TextBlock>("FontInfoTextBlock")!;
+
+    // --- LauncherSettingsPage ---
+    internal TextBlock LauncherSettingsPanelTitleTextBlock => LauncherSettingsPanel.FindControl<TextBlock>("LauncherSettingsPanelTitleTextBlock")!;
+    internal FluentAvalonia.UI.Controls.SettingsExpander LauncherHiddenItemsSettingsExpander => LauncherSettingsPanel.FindControl<FluentAvalonia.UI.Controls.SettingsExpander>("LauncherHiddenItemsSettingsExpander")!;
+    internal StackPanel LauncherHiddenItemsListPanel => LauncherSettingsPanel.FindControl<StackPanel>("LauncherHiddenItemsListPanel")!;
+    internal TextBlock LauncherHiddenItemsEmptyTextBlock => LauncherSettingsPanel.FindControl<TextBlock>("LauncherHiddenItemsEmptyTextBlock")!;
+    internal TextBlock LauncherHiddenItemsDescriptionTextBlock => LauncherSettingsPanel.FindControl<TextBlock>("LauncherHiddenItemsDescriptionTextBlock")!;
+
+    // --- PluginSettingsPage (Added for completeness) ---
+    internal TextBlock PluginSettingsPanelTitleTextBlock => PluginSettingsPanel.FindControl<TextBlock>("PluginSettingsPanelTitleTextBlock")!;
+    internal FluentAvalonia.UI.Controls.SettingsExpander PluginSystemSettingsExpander => PluginSettingsPanel.FindControl<FluentAvalonia.UI.Controls.SettingsExpander>("PluginSystemSettingsExpander")!;
+    internal TextBlock PluginSystemDescriptionTextBlock => PluginSettingsPanel.FindControl<TextBlock>("PluginSystemDescriptionTextBlock")!;
+    internal TextBlock PluginSystemStatusTextBlock => PluginSettingsPanel.FindControl<TextBlock>("PluginSystemStatusTextBlock")!;
+    internal FluentAvalonia.UI.Controls.SettingsExpander InstalledPluginsSettingsExpander => PluginSettingsPanel.FindControl<FluentAvalonia.UI.Controls.SettingsExpander>("InstalledPluginsSettingsExpander")!;
+    internal TextBlock PluginRestartHintTextBlock => PluginSettingsPanel.FindControl<TextBlock>("PluginRestartHintTextBlock")!;
+    internal TextBlock PluginCatalogEmptyTextBlock => PluginSettingsPanel.FindControl<TextBlock>("PluginCatalogEmptyTextBlock")!;
+}
+

LanMountainDesktop/Views/SettingsWindow.Core.cs

@@ -0,0 +1,501 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Interactivity;
+using Avalonia.Layout;
+using Avalonia.Media;
+using Avalonia.Threading;
+using FluentIcons.Avalonia.Fluent;
+using FluentIcons.Common;
+using LanMountainDesktop.ComponentSystem;
+using LanMountainDesktop.Models;
+using LanMountainDesktop.Views.Components;
+
+namespace LanMountainDesktop.Views;
+
+public partial class SettingsWindow
+{
+    protected override void OnClosed(EventArgs e)
+    {
+        _persistSettingsDebounceTimer?.Dispose();
+        _persistSettingsDebounceTimer = null;
+
+        StopVideoWallpaper();
+        _previewVideoWallpaperPlayer?.Dispose();
+        _previewVideoWallpaperPlayer = null;
+        _previewVideoWallpaperMedia?.Dispose();
+        _previewVideoWallpaperMedia = null;
+        _libVlc?.Dispose();
+        _libVlc = null;
+
+        _releaseUpdateService.Dispose();
+        _wallpaperBitmap?.Dispose();
+        _wallpaperBitmap = null;
+        _launcherFolderIconBitmap?.Dispose();
+        _launcherFolderIconBitmap = null;
+
+        foreach (var icon in _launcherIconCache.Values)
+        {
+            icon.Dispose();
+        }
+
+        _launcherIconCache.Clear();
+        base.OnClosed(e);
+    }
+
+    private void OnSettingsNavSelectionChanged(object? sender, FluentAvalonia.UI.Controls.NavigationViewSelectionChangedEventArgs e)
+    {
+        UpdateSettingsTabContent();
+        PersistSettings();
+    }
+
+    private int GetSettingsTabIndex()
+    {
+        return ResolveSelectedSettingsTabIndex();
+    }
+
+    private void UpdateSettingsTabContent()
+    {
+        if (SettingsNavView is null)
+        {
+            return;
+        }
+
+        var selectedItem = SettingsNavView.SelectedItem as FluentAvalonia.UI.Controls.NavigationViewItem;
+        var tag = selectedItem?.Tag?.ToString();
+
+        WallpaperSettingsPanel.IsVisible = tag == "Wallpaper";
+        GridSettingsPanel.IsVisible = tag == "Grid";
+        ColorSettingsPanel.IsVisible = tag == "Color";
+        StatusBarSettingsPanel.IsVisible = tag == "StatusBar";
+        WeatherSettingsPanel.IsVisible = tag == "Weather";
+        RegionSettingsPanel.IsVisible = tag == "Region";
+        UpdateSettingsPanel.IsVisible = tag == "Update";
+        AboutSettingsPanel.IsVisible = tag == "About";
+        LauncherSettingsPanel.IsVisible = tag == "Launcher";
+        PluginSettingsPanel.IsVisible = tag == "Plugins";
+        UpdatePluginSettingsPageVisibility(tag);
+
+        if (tag == "Launcher")
+        {
+            RenderLauncherHiddenItemsList();
+        }
+
+        if (tag == "Grid")
+        {
+            UpdateGridPreviewLayout();
+        }
+
+        ApplyTaskbarActionVisibility(GetCurrentTaskbarContext());
+    }
+
+    private void PersistSettings()
+    {
+        if (_suppressSettingsPersistence)
+        {
+            return;
+        }
+
+        _appSettingsService.Save(BuildAppSettingsSnapshot());
+        _launcherSettingsService.Save(BuildLauncherSettingsSnapshot());
+    }
+
+    private AppSettingsSnapshot BuildAppSettingsSnapshot()
+    {
+        var snapshot = _appSettingsService.Load();
+        snapshot.GridShortSideCells = _targetShortSideCells;
+        snapshot.GridSpacingPreset = _gridSpacingPreset;
+        snapshot.DesktopEdgeInsetPercent = _desktopEdgeInsetPercent;
+        snapshot.IsNightMode = _isNightMode;
+        snapshot.ThemeColor = _selectedThemeColor.ToString();
+        snapshot.WallpaperPath = _wallpaperPath;
+        snapshot.WallpaperPlacement = GetPlacementDisplayName(GetSelectedWallpaperPlacement());
+        snapshot.SettingsTabIndex = Math.Max(0, GetSettingsTabIndex());
+        snapshot.SettingsTabTag = GetSelectedSettingsTabTag();
+        snapshot.LanguageCode = _languageCode;
+        snapshot.TimeZoneId = _timeZoneService.CurrentTimeZone.Id;
+        snapshot.WeatherLocationMode = ToWeatherLocationModeTag(_weatherLocationMode);
+        snapshot.WeatherLocationKey = _weatherLocationKey;
+        snapshot.WeatherLocationName = _weatherLocationName;
+        snapshot.WeatherLatitude = _weatherLatitude;
+        snapshot.WeatherLongitude = _weatherLongitude;
+        snapshot.WeatherAutoRefreshLocation = _weatherAutoRefreshLocation;
+        snapshot.WeatherLocationQuery = BuildLegacyWeatherLocationQuery();
+        snapshot.WeatherExcludedAlerts = _weatherExcludedAlertsRaw;
+        snapshot.WeatherIconPackId = _weatherIconPackId;
+        snapshot.WeatherNoTlsRequests = _weatherNoTlsRequests;
+        snapshot.AutoStartWithWindows = _autoStartWithWindows;
+        snapshot.AppRenderMode = _selectedAppRenderMode;
+        snapshot.AutoCheckUpdates = _autoCheckUpdates;
+        snapshot.IncludePrereleaseUpdates = IncludePrereleaseUpdates;
+        snapshot.UpdateChannel = IncludePrereleaseUpdates ? UpdateChannelPreview : UpdateChannelStable;
+        snapshot.TopStatusComponentIds = _topStatusComponentIds.ToList();
+        snapshot.PinnedTaskbarActions = _pinnedTaskbarActions.Select(action => action.ToString()).ToList();
+        snapshot.EnableDynamicTaskbarActions = _enableDynamicTaskbarActions;
+        snapshot.TaskbarLayoutMode = _taskbarLayoutMode;
+        snapshot.ClockDisplayFormat = _clockDisplayFormat == ClockDisplayFormat.HourMinute ? "HourMinute" : "HourMinuteSecond";
+        snapshot.StatusBarSpacingMode = _statusBarSpacingMode;
+        snapshot.StatusBarCustomSpacingPercent = _statusBarCustomSpacingPercent;
+        return snapshot;
+    }
+
+    private LauncherSettingsSnapshot BuildLauncherSettingsSnapshot()
+    {
+        return new LauncherSettingsSnapshot
+        {
+            HiddenLauncherFolderPaths = _hiddenLauncherFolderPaths.OrderBy(path => path, StringComparer.OrdinalIgnoreCase).ToList(),
+            HiddenLauncherAppPaths = _hiddenLauncherAppPaths.OrderBy(path => path, StringComparer.OrdinalIgnoreCase).ToList()
+        };
+    }
+
+    private void SchedulePersistSettings(int delayMs = 200)
+    {
+        if (_suppressSettingsPersistence)
+        {
+            return;
+        }
+
+        _persistSettingsDebounceTimer?.Dispose();
+        _persistSettingsDebounceTimer = DispatcherTimer.RunOnce(() =>
+        {
+            _persistSettingsDebounceTimer = null;
+            PersistSettings();
+        }, TimeSpan.FromMilliseconds(Math.Max(0, delayMs)));
+    }
+
+    private int CalculateDefaultShortSideCellCountFromDpi()
+    {
+        var dpi = 96d * RenderScaling;
+        var count = (int)Math.Round(dpi / 8d);
+        return Math.Clamp(count, MinShortSideCells, MaxShortSideCells);
+    }
+
+    private static string NormalizeGridSpacingPreset(string? value)
+    {
+        return string.Equals(value, "Compact", StringComparison.OrdinalIgnoreCase)
+            ? "Compact"
+            : "Relaxed";
+    }
+
+    private static string NormalizeStatusBarSpacingMode(string? value)
+    {
+        return value switch
+        {
+            _ when string.Equals(value, "Compact", StringComparison.OrdinalIgnoreCase) => "Compact",
+            _ when string.Equals(value, "Custom", StringComparison.OrdinalIgnoreCase) => "Custom",
+            _ => "Relaxed"
+        };
+    }
+
+    private static string? TryGetSelectedComboBoxTag(ComboBox? comboBox)
+    {
+        if (comboBox?.SelectedItem is ComboBoxItem item)
+        {
+            return item.Tag?.ToString();
+        }
+
+        return comboBox?.SelectedItem?.ToString();
+    }
+
+    private int ResolveStatusBarSpacingPercent()
+    {
+        return _statusBarSpacingMode switch
+        {
+            "Compact" => 6,
+            "Custom" => Math.Clamp(_statusBarCustomSpacingPercent, 0, 30),
+            _ => 12
+        };
+    }
+
+    private void ApplyStatusBarComponentSpacingForPanel(StackPanel? panel, double cellSize)
+    {
+        if (panel is null)
+        {
+            return;
+        }
+
+        var percent = ResolveStatusBarSpacingPercent();
+        panel.Spacing = Math.Max(0, cellSize) * (percent / 100d);
+    }
+
+    private void UpdateStatusBarSpacingComputedPxText(double cellSize)
+    {
+        var percent = ResolveStatusBarSpacingPercent();
+        var spacingPx = Math.Max(0, cellSize) * (percent / 100d);
+        StatusBarSpacingComputedPxTextBlock.Text = Lf(
+            "settings.status_bar.spacing_custom_px_format",
+            ">= {0:F1}px",
+            spacingPx);
+    }
+
+    private int ResolvePendingGridEdgeInsetPercent()
+    {
+        var pending = (int)Math.Round(GridEdgeInsetNumberBox.Value);
+        return Math.Clamp(pending, MinEdgeInsetPercent, MaxEdgeInsetPercent);
+    }
+
+    private void UpdateGridEdgeInsetComputedPxText(double cellSize)
+    {
+        var percent = ResolvePendingGridEdgeInsetPercent();
+        var insetPx = Math.Clamp(Math.Max(0, cellSize) * (percent / 100d), 0, 80);
+        GridEdgeInsetComputedPxTextBlock.Text = Lf("settings.grid.edge_inset_px_format", "{0:F1}px", insetPx);
+    }
+
+    private void OnStatusBarClockChecked(object? sender, RoutedEventArgs e)
+    {
+        if (_suppressStatusBarToggleEvents)
+        {
+            return;
+        }
+
+        _topStatusComponentIds.Add(BuiltInComponentIds.Clock);
+        ApplyTopStatusComponentVisibility();
+        UpdateWallpaperPreviewLayout();
+        PersistSettings();
+    }
+
+    private void OnStatusBarClockUnchecked(object? sender, RoutedEventArgs e)
+    {
+        if (_suppressStatusBarToggleEvents)
+        {
+            return;
+        }
+
+        _topStatusComponentIds.Remove(BuiltInComponentIds.Clock);
+        ApplyTopStatusComponentVisibility();
+        UpdateWallpaperPreviewLayout();
+        PersistSettings();
+    }
+
+    private void OnClockFormatChanged(object? sender, RoutedEventArgs e)
+    {
+        if (sender is not RadioButton radioButton || radioButton.Tag is not string formatTag)
+        {
+            return;
+        }
+
+        _clockDisplayFormat = formatTag == "Hm"
+            ? ClockDisplayFormat.HourMinute
+            : ClockDisplayFormat.HourMinuteSecond;
+        ClockWidget.SetDisplayFormat(_clockDisplayFormat);
+        WallpaperPreviewClockWidget.SetDisplayFormat(_clockDisplayFormat);
+        ApplyTopStatusComponentVisibility();
+        UpdateWallpaperPreviewLayout();
+        PersistSettings();
+    }
+
+    private void ApplyTaskbarSettings(AppSettingsSnapshot snapshot)
+    {
+        _topStatusComponentIds.Clear();
+        if (snapshot.TopStatusComponentIds is not null)
+        {
+            foreach (var componentId in snapshot.TopStatusComponentIds)
+            {
+                if (string.IsNullOrWhiteSpace(componentId))
+                {
+                    continue;
+                }
+
+                var normalizedId = componentId.Trim();
+                if (_componentRegistry.IsKnownComponent(normalizedId) &&
+                    _componentRegistry.AllowsStatusBarPlacement(normalizedId))
+                {
+                    _topStatusComponentIds.Add(normalizedId);
+                }
+            }
+        }
+
+        _pinnedTaskbarActions.Clear();
+        if (snapshot.PinnedTaskbarActions is not null)
+        {
+            foreach (var actionText in snapshot.PinnedTaskbarActions)
+            {
+                if (Enum.TryParse<TaskbarActionId>(actionText, ignoreCase: true, out var action))
+                {
+                    _pinnedTaskbarActions.Add(action);
+                }
+            }
+        }
+
+        if (_pinnedTaskbarActions.Count == 0)
+        {
+            foreach (var action in DefaultPinnedTaskbarActions)
+            {
+                _pinnedTaskbarActions.Add(action);
+            }
+        }
+
+        _enableDynamicTaskbarActions = snapshot.EnableDynamicTaskbarActions;
+        _taskbarLayoutMode = string.IsNullOrWhiteSpace(snapshot.TaskbarLayoutMode)
+            ? TaskbarLayoutBottomFullRowMacStyle
+            : snapshot.TaskbarLayoutMode;
+        _clockDisplayFormat = snapshot.ClockDisplayFormat == "HourMinute"
+            ? ClockDisplayFormat.HourMinute
+            : ClockDisplayFormat.HourMinuteSecond;
+
+        ClockWidget.SetDisplayFormat(_clockDisplayFormat);
+        WallpaperPreviewClockWidget.SetDisplayFormat(_clockDisplayFormat);
+
+        if (_clockDisplayFormat == ClockDisplayFormat.HourMinute)
+        {
+            ClockFormatHMRadio.IsChecked = true;
+        }
+        else
+        {
+            ClockFormatHMSSRadio.IsChecked = true;
+        }
+
+        _suppressStatusBarToggleEvents = true;
+        StatusBarClockToggleSwitch.IsChecked = _topStatusComponentIds.Contains(BuiltInComponentIds.Clock);
+        _suppressStatusBarToggleEvents = false;
+    }
+
+    private void ApplyTopStatusComponentVisibility()
+    {
+        var showClock = _topStatusComponentIds.Contains(BuiltInComponentIds.Clock);
+
+        ClockWidget.IsVisible = showClock;
+        if (showClock)
+        {
+            ClockWidget.SetDisplayFormat(_clockDisplayFormat);
+            Grid.SetColumnSpan(ClockWidget, _clockDisplayFormat == ClockDisplayFormat.HourMinute ? 2 : 3);
+        }
+
+        WallpaperPreviewClockWidget.IsVisible = showClock;
+        if (showClock)
+        {
+            WallpaperPreviewClockWidget.SetDisplayFormat(_clockDisplayFormat);
+        }
+    }
+
+    private TaskbarContext GetCurrentTaskbarContext()
+    {
+        var selectedItem = SettingsNavView?.SelectedItem as FluentAvalonia.UI.Controls.NavigationViewItem;
+        return selectedItem?.Tag?.ToString() switch
+        {
+            "Wallpaper" => TaskbarContext.SettingsWallpaper,
+            "Grid" => TaskbarContext.SettingsGrid,
+            "Color" => TaskbarContext.SettingsColor,
+            "StatusBar" => TaskbarContext.SettingsStatusBar,
+            "Weather" => TaskbarContext.SettingsWeather,
+            "Region" => TaskbarContext.SettingsRegion,
+            _ => TaskbarContext.Desktop
+        };
+    }
+
+    private void ApplyTaskbarActionVisibility(TaskbarContext context)
+    {
+        _ = context;
+
+        var showMinimize = _pinnedTaskbarActions.Contains(TaskbarActionId.MinimizeToWindows);
+        var showSettings = _pinnedTaskbarActions.Contains(TaskbarActionId.OpenSettings);
+
+        BackToWindowsButton.IsVisible = showMinimize;
+        OpenComponentLibraryButton.IsVisible = false;
+        OpenSettingsButton.IsVisible = showSettings;
+
+        WallpaperPreviewBackButtonVisual.IsVisible = showMinimize;
+        WallpaperPreviewComponentLibraryVisual.IsVisible = false;
+        WallpaperPreviewSettingsButtonIcon.IsVisible = showSettings;
+
+        TaskbarFixedActionsHost.IsVisible = showMinimize;
+        TaskbarSettingsActionHost.IsVisible = showSettings;
+        TaskbarDynamicActionsHost.IsVisible = false;
+        WallpaperPreviewTaskbarFixedActionsHost.IsVisible = showMinimize;
+        WallpaperPreviewTaskbarSettingsActionHost.IsVisible = showSettings;
+        WallpaperPreviewTaskbarDynamicActionsHost.IsVisible = false;
+
+        UpdateOpenSettingsActionVisualState();
+    }
+
+    private void UpdateOpenSettingsActionVisualState()
+    {
+        OpenSettingsButtonTextBlock.IsVisible = false;
+        OpenSettingsButtonTextBlock.Text = L("tooltip.open_settings", "Settings");
+    }
+
+    private void InitializeSettingsIcons()
+    {
+        const IconVariant variant = IconVariant.Regular;
+
+        WallpaperPlacementSettingsExpander.IconSource = new SymbolIconSource { Symbol = Symbol.Wallpaper, IconVariant = variant };
+        ThemeColorSettingsExpander.IconSource = new SymbolIconSource { Symbol = Symbol.Color, IconVariant = variant };
+        StatusBarClockSettingsExpander.IconSource = new SymbolIconSource { Symbol = Symbol.Clock, IconVariant = variant };
+        StatusBarSpacingSettingsExpander.IconSource = new SymbolIconSource { Symbol = Symbol.TextLineSpacing, IconVariant = variant };
+        WeatherLocationSettingsExpander.IconSource = new SymbolIconSource { Symbol = Symbol.WeatherSunny, IconVariant = variant };
+        WeatherPreviewSettingsExpander.IconSource = new SymbolIconSource { Symbol = Symbol.WeatherSunny, IconVariant = variant };
+        WeatherAlertFilterSettingsExpander.IconSource = new SymbolIconSource { Symbol = Symbol.Info, IconVariant = variant };
+        WeatherIconPackSettingsExpander.IconSource = new SymbolIconSource { Symbol = Symbol.Color, IconVariant = variant };
+        WeatherNoTlsSettingsExpander.IconSource = new SymbolIconSource { Symbol = Symbol.Globe, IconVariant = variant };
+        LanguageSettingsExpander.IconSource = new SymbolIconSource { Symbol = Symbol.Translate, IconVariant = variant };
+        TimeZoneSettingsExpander.IconSource = new SymbolIconSource { Symbol = Symbol.GlobeClock, IconVariant = variant };
+        UpdateOptionsSettingsExpander.IconSource = new SymbolIconSource { Symbol = Symbol.ArrowClockwiseDashesSettings, IconVariant = variant };
+        UpdateActionsSettingsExpander.IconSource = new SymbolIconSource { Symbol = Symbol.ArrowDownload, IconVariant = variant };
+        AboutStartupSettingsExpander.IconSource = new SymbolIconSource { Symbol = Symbol.Play, IconVariant = variant };
+        PluginSystemSettingsExpander.IconSource = new SymbolIconSource { Symbol = Symbol.PuzzlePiece, IconVariant = variant };
+        UpdateThemeModeIcon();
+    }
+
+    private void UpdateThemeModeIcon()
+    {
+        ThemeModeSettingsExpander.IconSource = new SymbolIconSource
+        {
+            Symbol = _isNightMode ? Symbol.WeatherMoon : Symbol.WeatherSunny,
+            IconVariant = IconVariant.Regular
+        };
+    }
+
+    private void InitializeTimeZoneSettings()
+    {
+        _suppressTimeZoneSelectionEvents = true;
+        TimeZoneComboBox.Items.Clear();
+        foreach (var tz in _timeZoneService.GetAllTimeZones())
+        {
+            var item = new ComboBoxItem
+            {
+                Content = GetLocalizedTimeZoneDisplayName(tz),
+                Tag = tz.Id
+            };
+            TimeZoneComboBox.Items.Add(item);
+            if (tz.Id == _timeZoneService.CurrentTimeZone.Id)
+            {
+                TimeZoneComboBox.SelectedItem = item;
+            }
+        }
+
+        ClockWidget.SetTimeZoneService(_timeZoneService);
+        WallpaperPreviewClockWidget.SetTimeZoneService(_timeZoneService);
+        _suppressTimeZoneSelectionEvents = false;
+    }
+
+    private void OnTimeZoneSelectionChanged(object? sender, SelectionChangedEventArgs e)
+    {
+        if (_suppressTimeZoneSelectionEvents || TimeZoneComboBox.SelectedItem is not ComboBoxItem item)
+        {
+            return;
+        }
+
+        var timeZoneId = item.Tag?.ToString();
+        if (string.IsNullOrWhiteSpace(timeZoneId))
+        {
+            return;
+        }
+
+        _timeZoneService.SetTimeZoneById(timeZoneId);
+        PersistSettings();
+    }
+
+    private IBrush GetThemeBrush(string key)
+    {
+        if (Resources.TryGetResource(key, ActualThemeVariant, out var resource) && resource is IBrush brush)
+        {
+            return brush;
+        }
+
+        return Brushes.Transparent;
+    }
+}
+

LanMountainDesktop/Views/SettingsWindow.Layout.cs

@@ -0,0 +1,529 @@
+using System;
+using Avalonia;
+using Avalonia.Controls;
+using Avalonia.Controls.Primitives;
+using Avalonia.Interactivity;
+using Avalonia.Layout;
+using Avalonia.Media;
+using FluentAvalonia.UI.Controls;
+using Line = Avalonia.Controls.Shapes.Line;
+
+namespace LanMountainDesktop.Views;
+
+public partial class SettingsWindow
+{
+    private void OnGridSizeSliderChanged(object? sender, RoutedEventArgs e)
+    {
+        var sliderValue = (int)Math.Round(GridSizeSlider.Value);
+        if (Math.Abs(GridSizeNumberBox.Value - sliderValue) > double.Epsilon)
+        {
+            GridSizeNumberBox.Value = sliderValue;
+        }
+
+        UpdateGridPreviewLayout();
+    }
+
+    private void OnGridSizeNumberBoxChanged(object? sender, NumberBoxValueChangedEventArgs e)
+    {
+        var numberBoxValue = (int)Math.Round(GridSizeNumberBox.Value);
+        if (Math.Abs(GridSizeSlider.Value - numberBoxValue) > double.Epsilon)
+        {
+            GridSizeSlider.Value = numberBoxValue;
+        }
+
+        UpdateGridPreviewLayout();
+    }
+
+    private void OnGridEdgeInsetSliderChanged(object? sender, RoutedEventArgs e)
+    {
+        if (_suppressGridInsetEvents)
+        {
+            return;
+        }
+
+        var value = (int)Math.Round(GridEdgeInsetSlider.Value);
+        SetPendingGridEdgeInsetPercent(value, updateSlider: false, updateNumberBox: true);
+        UpdateGridPreviewLayout();
+    }
+
+    private void OnGridEdgeInsetNumberBoxChanged(object? sender, NumberBoxValueChangedEventArgs e)
+    {
+        if (_suppressGridInsetEvents)
+        {
+            return;
+        }
+
+        var value = (int)Math.Round(GridEdgeInsetNumberBox.Value);
+        SetPendingGridEdgeInsetPercent(value, updateSlider: true, updateNumberBox: false);
+        UpdateGridPreviewLayout();
+    }
+
+    private void SetPendingGridEdgeInsetPercent(int percent, bool updateSlider, bool updateNumberBox)
+    {
+        var clamped = Math.Clamp(percent, MinEdgeInsetPercent, MaxEdgeInsetPercent);
+
+        _suppressGridInsetEvents = true;
+        try
+        {
+            if (updateSlider && Math.Abs(GridEdgeInsetSlider.Value - clamped) > double.Epsilon)
+            {
+                GridEdgeInsetSlider.Value = clamped;
+            }
+
+            if (updateNumberBox && Math.Abs(GridEdgeInsetNumberBox.Value - clamped) > double.Epsilon)
+            {
+                GridEdgeInsetNumberBox.Value = clamped;
+            }
+        }
+        finally
+        {
+            _suppressGridInsetEvents = false;
+        }
+    }
+
+    private void OnGridSpacingPresetSelectionChanged(object? sender, SelectionChangedEventArgs e)
+    {
+        if (_suppressGridSpacingEvents)
+        {
+            return;
+        }
+
+        UpdateGridPreviewLayout();
+    }
+
+    private void OnStatusBarSpacingModeChanged(object? sender, SelectionChangedEventArgs e)
+    {
+        if (_suppressStatusBarSpacingEvents)
+        {
+            return;
+        }
+
+        _statusBarSpacingMode = NormalizeStatusBarSpacingMode(
+            TryGetSelectedComboBoxTag(StatusBarSpacingModeComboBox) ?? _statusBarSpacingMode);
+        StatusBarSpacingCustomPanel.IsVisible = string.Equals(_statusBarSpacingMode, "Custom", StringComparison.OrdinalIgnoreCase);
+        UpdateWallpaperPreviewLayout();
+        UpdateGridPreviewLayout();
+        SchedulePersistSettings();
+    }
+
+    private void OnStatusBarSpacingSliderChanged(object? sender, RangeBaseValueChangedEventArgs e)
+    {
+        if (_suppressStatusBarSpacingEvents)
+        {
+            return;
+        }
+
+        var percent = (int)Math.Round(StatusBarSpacingSlider.Value);
+        SetStatusBarCustomSpacingPercent(percent, updateSlider: false, updateNumberBox: true);
+
+        if (string.Equals(_statusBarSpacingMode, "Custom", StringComparison.OrdinalIgnoreCase))
+        {
+            UpdateWallpaperPreviewLayout();
+            UpdateGridPreviewLayout();
+        }
+
+        SchedulePersistSettings();
+    }
+
+    private void OnStatusBarSpacingNumberBoxChanged(object? sender, NumberBoxValueChangedEventArgs e)
+    {
+        if (_suppressStatusBarSpacingEvents)
+        {
+            return;
+        }
+
+        var percent = (int)Math.Round(StatusBarSpacingNumberBox.Value);
+        SetStatusBarCustomSpacingPercent(percent, updateSlider: true, updateNumberBox: false);
+
+        if (string.Equals(_statusBarSpacingMode, "Custom", StringComparison.OrdinalIgnoreCase))
+        {
+            UpdateWallpaperPreviewLayout();
+            UpdateGridPreviewLayout();
+        }
+
+        SchedulePersistSettings();
+    }
+
+    private void SetStatusBarCustomSpacingPercent(int percent, bool updateSlider, bool updateNumberBox)
+    {
+        percent = Math.Clamp(percent, 0, 30);
+        _statusBarCustomSpacingPercent = percent;
+
+        _suppressStatusBarSpacingEvents = true;
+        try
+        {
+            if (updateSlider && Math.Abs(StatusBarSpacingSlider.Value - percent) > double.Epsilon)
+            {
+                StatusBarSpacingSlider.Value = percent;
+            }
+
+            if (updateNumberBox && Math.Abs(StatusBarSpacingNumberBox.Value - percent) > double.Epsilon)
+            {
+                StatusBarSpacingNumberBox.Value = percent;
+            }
+        }
+        finally
+        {
+            _suppressStatusBarSpacingEvents = false;
+        }
+    }
+
+    private void OnApplyGridSizeClick(object? sender, RoutedEventArgs e)
+    {
+        _gridSpacingPreset = NormalizeGridSpacingPreset(TryGetSelectedComboBoxTag(GridSpacingPresetComboBox) ?? _gridSpacingPreset);
+        _desktopEdgeInsetPercent = ResolvePendingGridEdgeInsetPercent();
+
+        var requested = (int)Math.Round(GridSizeNumberBox.Value);
+        if (requested <= 0)
+        {
+            requested = _targetShortSideCells;
+        }
+
+        _targetShortSideCells = Math.Clamp(requested, MinShortSideCells, MaxShortSideCells);
+
+        if (Math.Abs(GridSizeNumberBox.Value - _targetShortSideCells) > double.Epsilon)
+        {
+            GridSizeNumberBox.Value = _targetShortSideCells;
+        }
+
+        if (Math.Abs(GridSizeSlider.Value - _targetShortSideCells) > double.Epsilon)
+        {
+            GridSizeSlider.Value = _targetShortSideCells;
+        }
+
+        SetPendingGridEdgeInsetPercent(_desktopEdgeInsetPercent, updateSlider: true, updateNumberBox: true);
+        UpdateWallpaperPreviewLayout();
+        UpdateGridPreviewLayout();
+        PersistSettings();
+    }
+
+    private static double ResolveGridGapRatio(string preset)
+    {
+        return string.Equals(preset, "Compact", StringComparison.OrdinalIgnoreCase) ? 0.06 : 0.12;
+    }
+
+    private static double CalculateEdgeInset(double hostWidth, double hostHeight, int shortSideCells, int insetPercent)
+    {
+        if (hostWidth <= 1 || hostHeight <= 1)
+        {
+            return 0;
+        }
+
+        var cells = Math.Max(1, shortSideCells);
+        var shortSidePx = Math.Max(1, Math.Min(hostWidth, hostHeight));
+        var baseCell = shortSidePx / cells;
+        return Math.Clamp(baseCell * (Math.Clamp(insetPercent, MinEdgeInsetPercent, MaxEdgeInsetPercent) / 100d), 0, 80);
+    }
+
+    private static GridMetrics CalculateGridMetrics(double hostWidth, double hostHeight, int shortSideCells, double gapRatio, double edgeInsetPx)
+    {
+        if (hostWidth <= 1 || hostHeight <= 1)
+        {
+            return default;
+        }
+
+        var shortSide = Math.Max(1, shortSideCells);
+        var clampedGapRatio = Math.Max(0, gapRatio);
+        var inset = Math.Max(0, edgeInsetPx);
+        var availableWidth = Math.Max(1, hostWidth - inset * 2);
+        var availableHeight = Math.Max(1, hostHeight - inset * 2);
+
+        if (hostWidth >= hostHeight)
+        {
+            var rowCount = shortSide;
+            var denominator = rowCount + Math.Max(0, rowCount - 1) * clampedGapRatio;
+            if (denominator <= 0)
+            {
+                return default;
+            }
+
+            var cellSize = availableHeight / denominator;
+            var gapPx = cellSize * clampedGapRatio;
+            var pitch = cellSize + gapPx;
+            if (pitch <= 0)
+            {
+                return default;
+            }
+
+            var columnCount = Math.Max(1, (int)Math.Floor((availableWidth + gapPx) / pitch));
+            var gridWidth = columnCount * cellSize + Math.Max(0, columnCount - 1) * gapPx;
+            var gridHeight = rowCount * cellSize + Math.Max(0, rowCount - 1) * gapPx;
+            return new GridMetrics(columnCount, rowCount, cellSize, gapPx, inset, gridWidth, gridHeight);
+        }
+
+        var columnCountPortrait = shortSide;
+        var denominatorPortrait = columnCountPortrait + Math.Max(0, columnCountPortrait - 1) * clampedGapRatio;
+        if (denominatorPortrait <= 0)
+        {
+            return default;
+        }
+
+        var cellSizePortrait = availableWidth / denominatorPortrait;
+        var gapPxPortrait = cellSizePortrait * clampedGapRatio;
+        var pitchPortrait = cellSizePortrait + gapPxPortrait;
+        if (pitchPortrait <= 0)
+        {
+            return default;
+        }
+
+        var rowCountPortrait = Math.Max(1, (int)Math.Floor((availableHeight + gapPxPortrait) / pitchPortrait));
+        var gridWidthPortrait = columnCountPortrait * cellSizePortrait + Math.Max(0, columnCountPortrait - 1) * gapPxPortrait;
+        var gridHeightPortrait = rowCountPortrait * cellSizePortrait + Math.Max(0, rowCountPortrait - 1) * gapPxPortrait;
+        return new GridMetrics(columnCountPortrait, rowCountPortrait, cellSizePortrait, gapPxPortrait, inset, gridWidthPortrait, gridHeightPortrait);
+    }
+
+    private static int ClampComponentSpan(int requestedSpan, int axisCellCount)
+    {
+        return Math.Clamp(requestedSpan, 1, Math.Max(1, axisCellCount));
+    }
+
+    private static int ClampGridIndex(int requestedIndex, int axisCellCount)
+    {
+        return Math.Clamp(requestedIndex, 0, Math.Max(0, axisCellCount - 1));
+    }
+
+    private static void PlaceStatusBarComponent(Control component, int column, int requestedColumnSpan, int totalColumns)
+    {
+        var clampedColumn = ClampGridIndex(column, totalColumns);
+        var availableColumns = Math.Max(1, totalColumns - clampedColumn);
+        Grid.SetRow(component, StatusBarRowIndex);
+        Grid.SetColumn(component, clampedColumn);
+        Grid.SetColumnSpan(component, ClampComponentSpan(requestedColumnSpan, availableColumns));
+    }
+
+    private void UpdateGridPreviewLayout()
+    {
+        var previewShortSideCells = (int)Math.Round(GridSizeSlider.Value);
+        if (previewShortSideCells < MinShortSideCells || previewShortSideCells > MaxShortSideCells)
+        {
+            previewShortSideCells = _targetShortSideCells;
+        }
+
+        var desktopWidth = Math.Max(1, DesktopHost.Bounds.Width > 1 ? DesktopHost.Bounds.Width : Bounds.Width);
+        var desktopHeight = Math.Max(1, DesktopHost.Bounds.Height > 1 ? DesktopHost.Bounds.Height : Bounds.Height);
+        var aspectRatio = desktopWidth / desktopHeight;
+        var availableWidth = Math.Max(100, GridPreviewHost.Bounds.Width);
+        var framePadding = GridPreviewFrame.Padding;
+        var horizontalPadding = framePadding.Left + framePadding.Right;
+        var verticalPadding = framePadding.Top + framePadding.Bottom;
+
+        var gridPreviewWidth = availableWidth;
+        var gridPreviewHeight = gridPreviewWidth / aspectRatio;
+        GridPreviewFrame.Width = gridPreviewWidth;
+        GridPreviewFrame.Height = gridPreviewHeight;
+
+        var innerWidth = Math.Max(1, gridPreviewWidth - horizontalPadding);
+        var innerHeight = Math.Max(1, gridPreviewHeight - verticalPadding);
+        var preset = NormalizeGridSpacingPreset(TryGetSelectedComboBoxTag(GridSpacingPresetComboBox) ?? _gridSpacingPreset);
+        var gapRatio = ResolveGridGapRatio(preset);
+        var edgeInset = CalculateEdgeInset(innerWidth, innerHeight, previewShortSideCells, ResolvePendingGridEdgeInsetPercent());
+        var gridMetrics = CalculateGridMetrics(innerWidth, innerHeight, previewShortSideCells, gapRatio, edgeInset);
+        if (gridMetrics.CellSize <= 0)
+        {
+            return;
+        }
+
+        _currentDesktopCellSize = gridMetrics.CellSize;
+        GridPreviewGrid.Margin = new Thickness(gridMetrics.EdgeInsetPx);
+        GridPreviewGrid.RowSpacing = gridMetrics.GapPx;
+        GridPreviewGrid.ColumnSpacing = gridMetrics.GapPx;
+        GridPreviewGrid.Width = gridMetrics.GridWidthPx;
+        GridPreviewGrid.Height = gridMetrics.GridHeightPx;
+        GridPreviewLinesCanvas.Margin = new Thickness(gridMetrics.EdgeInsetPx);
+        GridPreviewGrid.RowDefinitions.Clear();
+        GridPreviewGrid.ColumnDefinitions.Clear();
+
+        for (var row = 0; row < gridMetrics.RowCount; row++)
+        {
+            GridPreviewGrid.RowDefinitions.Add(new RowDefinition(new GridLength(gridMetrics.CellSize, GridUnitType.Pixel)));
+        }
+
+        for (var col = 0; col < gridMetrics.ColumnCount; col++)
+        {
+            GridPreviewGrid.ColumnDefinitions.Add(new ColumnDefinition(new GridLength(gridMetrics.CellSize, GridUnitType.Pixel)));
+        }
+
+        PlaceStatusBarComponent(GridPreviewTopStatusBarHost, 0, gridMetrics.ColumnCount, gridMetrics.ColumnCount);
+
+        var taskbarRow = gridMetrics.RowCount - 1;
+        Grid.SetRow(GridPreviewBottomTaskbarContainer, taskbarRow);
+        Grid.SetColumn(GridPreviewBottomTaskbarContainer, 0);
+        Grid.SetColumnSpan(GridPreviewBottomTaskbarContainer, gridMetrics.ColumnCount);
+
+        ApplyGridPreviewWidgetSizing(gridMetrics.CellSize);
+        ApplyStatusBarComponentSpacingForPanel(GridPreviewTopStatusComponentsPanel, gridMetrics.CellSize);
+        UpdateGridEdgeInsetComputedPxText(gridMetrics.CellSize);
+        GridInfoTextBlock.Text = Lf("settings.grid.info_format", "Grid: {0} cols x {1} rows | cell {2:F1}px (1:1)", gridMetrics.ColumnCount, gridMetrics.RowCount, gridMetrics.CellSize);
+
+        DrawGridPreviewLines(gridMetrics);
+    }
+
+    private void DrawGridPreviewLines(GridMetrics gridMetrics)
+    {
+        var viewportBackground = GridPreviewViewport.Background as SolidColorBrush;
+        var backgroundColor = viewportBackground?.Color ?? Color.Parse("#30111827");
+        var luminance = CalculateRelativeLuminance(backgroundColor);
+        var lineColor = luminance >= LightBackgroundLuminanceThreshold ? Color.Parse("#80000000") : Color.Parse("#80FFFFFF");
+
+        GridPreviewLinesCanvas.Children.Clear();
+        GridPreviewLinesCanvas.Width = gridMetrics.GridWidthPx;
+        GridPreviewLinesCanvas.Height = gridMetrics.GridHeightPx;
+
+        var dashLength = gridMetrics.CellSize * 0.3;
+        var gapLength = gridMetrics.CellSize * 0.2;
+
+        for (var row = 0; row <= gridMetrics.RowCount; row++)
+        {
+            var y = row == gridMetrics.RowCount ? gridMetrics.GridHeightPx : row * gridMetrics.Pitch;
+            GridPreviewLinesCanvas.Children.Add(new Line
+            {
+                StartPoint = new Point(0, y),
+                EndPoint = new Point(gridMetrics.GridWidthPx, y),
+                Stroke = new SolidColorBrush(lineColor),
+                StrokeThickness = 1,
+                StrokeDashArray = new Avalonia.Collections.AvaloniaList<double> { dashLength, gapLength },
+                IsHitTestVisible = false
+            });
+        }
+
+        for (var col = 0; col <= gridMetrics.ColumnCount; col++)
+        {
+            var x = col == gridMetrics.ColumnCount ? gridMetrics.GridWidthPx : col * gridMetrics.Pitch;
+            GridPreviewLinesCanvas.Children.Add(new Line
+            {
+                StartPoint = new Point(x, 0),
+                EndPoint = new Point(x, gridMetrics.GridHeightPx),
+                Stroke = new SolidColorBrush(lineColor),
+                StrokeThickness = 1,
+                StrokeDashArray = new Avalonia.Collections.AvaloniaList<double> { dashLength, gapLength },
+                IsHitTestVisible = false
+            });
+        }
+    }
+
+    private void ApplyGridPreviewWidgetSizing(double cellSize)
+    {
+        var previewTaskbarCell = Math.Clamp(cellSize * 0.74, 10, 30);
+        var iconSize = Math.Clamp(cellSize * 0.35, 8, 16);
+
+        GridPreviewTopStatusBarHost.Padding = new Thickness(0);
+        GridPreviewBottomTaskbarContainer.Margin = new Thickness(0);
+        GridPreviewBottomTaskbarContainer.CornerRadius = new CornerRadius(Math.Clamp(cellSize * 0.45, 16, 32));
+        GridPreviewBottomTaskbarContainer.Padding = new Thickness(Math.Clamp(cellSize * 0.06, 1, 4));
+
+        GridPreviewBackButtonTextBlock.FontSize = Math.Clamp(cellSize * 0.19, 5, 13);
+        GridPreviewComponentLibraryTextBlock.FontSize = Math.Clamp(cellSize * 0.18, 5, 12);
+        GridPreviewComponentLibraryIcon.FontSize = iconSize;
+        GridPreviewBackButtonVisual.MinHeight = previewTaskbarCell;
+        GridPreviewBackButtonVisual.MinWidth = Math.Clamp(cellSize * 2.1, 30, 120);
+        GridPreviewComponentLibraryVisual.MinHeight = previewTaskbarCell;
+        GridPreviewComponentLibraryVisual.MinWidth = Math.Clamp(cellSize * 2.0, 28, 110);
+        GridPreviewSettingsButtonIcon.Width = Math.Clamp(previewTaskbarCell * 0.42, 6, 14);
+        GridPreviewSettingsButtonIcon.Height = Math.Clamp(previewTaskbarCell * 0.42, 6, 14);
+    }
+
+    private void UpdateWallpaperPreviewLayout()
+    {
+        if (_isUpdatingWallpaperPreviewLayout)
+        {
+            return;
+        }
+
+        _isUpdatingWallpaperPreviewLayout = true;
+        try
+        {
+            var desktopWidth = Math.Max(1, DesktopHost.Bounds.Width > 1 ? DesktopHost.Bounds.Width : Bounds.Width);
+            var desktopHeight = Math.Max(1, DesktopHost.Bounds.Height > 1 ? DesktopHost.Bounds.Height : Bounds.Height);
+            var aspectRatio = desktopWidth / desktopHeight;
+
+            var availableWidth = Math.Max(100, WallpaperPreviewHost.Bounds.Width);
+            var availableHeight = WallpaperPreviewHost.Bounds.Height < 120 ? double.PositiveInfinity : WallpaperPreviewHost.Bounds.Height;
+
+            var framePadding = WallpaperPreviewFrame.Padding;
+            var horizontalPadding = framePadding.Left + framePadding.Right;
+            var verticalPadding = framePadding.Top + framePadding.Bottom;
+
+            var previewWidth = Math.Min(availableWidth, WallpaperPreviewMaxWidth);
+            var previewHeight = previewWidth / aspectRatio;
+            if (double.IsFinite(availableHeight) && previewHeight > availableHeight)
+            {
+                previewHeight = availableHeight;
+                previewWidth = previewHeight * aspectRatio;
+            }
+
+            WallpaperPreviewFrame.Width = previewWidth;
+            WallpaperPreviewFrame.Height = previewHeight;
+
+            var innerWidth = Math.Max(1, previewWidth - horizontalPadding);
+            var innerHeight = Math.Max(1, previewHeight - verticalPadding);
+            var gapRatio = ResolveGridGapRatio(_gridSpacingPreset);
+            var edgeInset = CalculateEdgeInset(innerWidth, innerHeight, _targetShortSideCells, _desktopEdgeInsetPercent);
+            var gridMetrics = CalculateGridMetrics(innerWidth, innerHeight, _targetShortSideCells, gapRatio, edgeInset);
+            if (gridMetrics.CellSize <= 0)
+            {
+                return;
+            }
+
+            WallpaperPreviewGrid.Margin = new Thickness(gridMetrics.EdgeInsetPx);
+            WallpaperPreviewGrid.RowSpacing = gridMetrics.GapPx;
+            WallpaperPreviewGrid.ColumnSpacing = gridMetrics.GapPx;
+            WallpaperPreviewGrid.Width = gridMetrics.GridWidthPx;
+            WallpaperPreviewGrid.Height = gridMetrics.GridHeightPx;
+            WallpaperPreviewGrid.RowDefinitions.Clear();
+            WallpaperPreviewGrid.ColumnDefinitions.Clear();
+
+            for (var row = 0; row < gridMetrics.RowCount; row++)
+            {
+                WallpaperPreviewGrid.RowDefinitions.Add(new RowDefinition(new GridLength(gridMetrics.CellSize, GridUnitType.Pixel)));
+            }
+
+            for (var col = 0; col < gridMetrics.ColumnCount; col++)
+            {
+                WallpaperPreviewGrid.ColumnDefinitions.Add(new ColumnDefinition(new GridLength(gridMetrics.CellSize, GridUnitType.Pixel)));
+            }
+
+            PlaceStatusBarComponent(WallpaperPreviewTopStatusBarHost, 0, gridMetrics.ColumnCount, gridMetrics.ColumnCount);
+
+            var taskbarRow = gridMetrics.RowCount - 1;
+            Grid.SetRow(WallpaperPreviewBottomTaskbarContainer, taskbarRow);
+            Grid.SetColumn(WallpaperPreviewBottomTaskbarContainer, 0);
+            Grid.SetColumnSpan(WallpaperPreviewBottomTaskbarContainer, gridMetrics.ColumnCount);
+
+            ApplyTopStatusComponentVisibility();
+            ApplyTaskbarActionVisibility(GetCurrentTaskbarContext());
+            ApplyPreviewWidgetSizing(gridMetrics.CellSize);
+            ApplyStatusBarComponentSpacingForPanel(WallpaperPreviewTopStatusComponentsPanel, gridMetrics.CellSize);
+        }
+        finally
+        {
+            _isUpdatingWallpaperPreviewLayout = false;
+        }
+    }
+
+    private void ApplyPreviewWidgetSizing(double cellSize)
+    {
+        var previewTaskbarCell = Math.Clamp(cellSize * 0.74, 10, 28);
+        var previewTextSize = Math.Clamp(previewTaskbarCell * 0.38, 7, 14);
+        var previewIconSize = Math.Clamp(previewTaskbarCell * 0.46, 8, 16);
+        var previewInset = Math.Clamp(previewTaskbarCell * 0.20, 2, 6);
+        var previewContentSpacing = Math.Clamp(previewTaskbarCell * 0.20, 2, 6);
+
+        WallpaperPreviewTopStatusBarHost.Margin = new Thickness(0);
+        WallpaperPreviewTopStatusBarHost.Padding = new Thickness(0);
+        WallpaperPreviewBottomTaskbarContainer.Margin = new Thickness(0);
+        WallpaperPreviewBottomTaskbarContainer.CornerRadius = new CornerRadius(Math.Clamp(cellSize * 0.45, 6, 14));
+        WallpaperPreviewBottomTaskbarContainer.Padding = new Thickness(previewInset);
+
+        WallpaperPreviewClockWidget.ApplyCellSize(cellSize);
+        WallpaperPreviewBackButtonTextBlock.FontSize = previewTextSize;
+        WallpaperPreviewComponentLibraryTextBlock.FontSize = previewTextSize;
+        WallpaperPreviewBackButtonVisual.Spacing = previewContentSpacing;
+        WallpaperPreviewComponentLibraryVisual.Spacing = previewContentSpacing;
+        WallpaperPreviewBackButtonVisual.MinHeight = previewTaskbarCell;
+        WallpaperPreviewBackButtonVisual.MinWidth = Math.Clamp(cellSize * 2.1, 30, 120);
+        WallpaperPreviewComponentLibraryVisual.MinHeight = previewTaskbarCell;
+        WallpaperPreviewComponentLibraryVisual.MinWidth = Math.Clamp(cellSize * 2.0, 28, 110);
+        WallpaperPreviewSettingsButtonIcon.Width = previewIconSize;
+        WallpaperPreviewSettingsButtonIcon.Height = previewIconSize;
+    }
+}

LanMountainDesktop/Views/SettingsWindow.Localization.cs

@@ -0,0 +1,214 @@
+using System;
+using System.Linq;
+using Avalonia.Controls;
+using LanMountainDesktop.Services;
+
+namespace LanMountainDesktop.Views;
+
+public partial class SettingsWindow
+{
+    private void InitializeLocalization(string? languageCode)
+    {
+        _languageCode = _localizationService.NormalizeLanguageCode(languageCode);
+        _suppressLanguageSelectionEvents = true;
+        LanguageComboBox.SelectedIndex = string.Equals(_languageCode, "en-US", StringComparison.OrdinalIgnoreCase) ? 1 : 0;
+        _suppressLanguageSelectionEvents = false;
+    }
+
+    private string L(string key, string fallback)
+    {
+        return _localizationService.GetString(_languageCode, key, fallback);
+    }
+
+    private string Lf(string key, string fallback, params object[] args)
+    {
+        var template = L(key, fallback);
+        return string.Format(template, args);
+    }
+
+    private string GetLanguageDisplayName(string languageCode)
+    {
+        return string.Equals(languageCode, "en-US", StringComparison.OrdinalIgnoreCase)
+            ? L("settings.region.language_en", "English")
+            : L("settings.region.language_zh", "Chinese");
+    }
+
+    private string GetLocalizedPlacementDisplayName(WallpaperPlacement placement)
+    {
+        return placement switch
+        {
+            WallpaperPlacement.Fill => L("placement.fill", "Fill"),
+            WallpaperPlacement.Fit => L("placement.fit", "Fit"),
+            WallpaperPlacement.Stretch => L("placement.stretch", "Stretch"),
+            WallpaperPlacement.Center => L("placement.center", "Center"),
+            WallpaperPlacement.Tile => L("placement.tile", "Tile"),
+            _ => L("placement.fill", "Fill")
+        };
+    }
+
+    private void ApplyLocalization()
+    {
+        Title = L("settings.title", "Settings");
+        WindowTitleTextBlock.Text = L("settings.title", "Settings");
+        WindowSubtitleTextBlock.Text = L("settings.footer", "LanMountainDesktop Settings");
+
+        SettingsNavWallpaperItem.Content = L("settings.nav.wallpaper", "Wallpaper");
+        SettingsNavGridItem.Content = L("settings.nav.grid", "Grid");
+        SettingsNavColorItem.Content = L("settings.nav.color", "Color");
+        SettingsNavStatusBarItem.Content = L("settings.nav.status_bar", "Status Bar");
+        SettingsNavWeatherItem.Content = L("settings.nav.weather", "Weather");
+        SettingsNavRegionItem.Content = L("settings.nav.region", "Region");
+        SettingsNavUpdateItem.Content = L("settings.nav.update", "Update");
+        SettingsNavAboutItem.Content = L("settings.nav.about", "About");
+        SettingsNavLauncherItem.Content = L("settings.nav.launcher", "App Launcher");
+        SettingsNavPluginsItem.Content = L("settings.nav.plugins", "Plugins");
+
+        WallpaperPanelTitleTextBlock.Text = L("settings.wallpaper.title", "Personalize your wallpaper");
+        WallpaperPlacementSettingsExpander.Header = L("settings.wallpaper.placement_label", "Placement");
+        WallpaperPlacementSettingsExpander.Description = L("settings.wallpaper.placement_desc", "Adjust how the image fits on the desktop.");
+        PickWallpaperButton.Content = L("settings.wallpaper.pick_button", "Browse");
+        ClearWallpaperButton.Content = L("settings.wallpaper.clear_button", "Reset");
+        WallpaperPreviewBackButtonTextBlock.Text = L("button.back_to_windows", "Back to Windows");
+        WallpaperPreviewComponentLibraryTextBlock.Text = L("button.component_library", "Edit Desktop");
+        GridPreviewBackButtonTextBlock.Text = L("button.back_to_windows", "Back to Windows");
+        GridPreviewComponentLibraryTextBlock.Text = L("button.component_library", "Edit Desktop");
+
+        GridPanelTitleTextBlock.Text = L("settings.grid.title", "Grid Layout");
+        GridSpacingSettingsExpander.Header = L("settings.grid.spacing_label", "Grid Spacing");
+        GridSpacingRelaxedComboBoxItem.Content = L("settings.grid.spacing_relaxed", "Relaxed");
+        GridSpacingCompactComboBoxItem.Content = L("settings.grid.spacing_compact", "Compact");
+        GridEdgeInsetSettingsExpander.Header = L("settings.grid.edge_inset_label", "Screen Inset");
+        ApplyGridButton.Content = L("settings.grid.apply_button", "Apply");
+        UpdateGridEdgeInsetComputedPxText(_currentDesktopCellSize);
+
+        ColorPanelTitleTextBlock.Text = L("settings.color.title", "Color");
+        ThemeModeSettingsExpander.Header = L("settings.color.day_night_label", "Day/Night");
+        RecommendedColorsLabelTextBlock.Text = L("settings.color.recommended_label", "Recommended Colors");
+        SystemMonetColorsLabelTextBlock.Text = L("settings.color.system_monet_label", "System Monet Colors");
+        RefreshMonetColorsButton.Content = L("settings.color.refresh_button", "Refresh");
+
+        StatusBarPanelTitleTextBlock.Text = L("settings.status_bar.title", "Status Bar");
+        StatusBarClockSettingsExpander.Header = L("settings.status_bar.clock_header", "Clock");
+        StatusBarSpacingSettingsExpander.Header = L("settings.status_bar.spacing_header", "Component Spacing");
+        StatusBarSpacingSettingsExpander.Description = L("settings.status_bar.spacing_desc", "Adjust spacing between status bar components.");
+        StatusBarSpacingModeCompactItem.Content = L("settings.status_bar.spacing_mode_compact", "Compact");
+        StatusBarSpacingModeRelaxedItem.Content = L("settings.status_bar.spacing_mode_relaxed", "Relaxed");
+        StatusBarSpacingModeCustomItem.Content = L("settings.status_bar.spacing_mode_custom", "Custom");
+        StatusBarSpacingCustomPanel.Content = L("settings.status_bar.spacing_custom_label", "Custom spacing (%)");
+
+        RegionPanelTitleTextBlock.Text = L("settings.region.title", "Region");
+        LanguageSettingsExpander.Header = L("settings.region.language_header", "Language");
+        LanguageSettingsExpander.Description = L("settings.region.language_desc", "Select application language. Changes apply immediately.");
+        LanguageChineseItem.Content = L("settings.region.language_zh", "Chinese");
+        LanguageEnglishItem.Content = L("settings.region.language_en", "English");
+        TimeZoneSettingsExpander.Header = L("settings.region.timezone_header", "Time Zone");
+        TimeZoneSettingsExpander.Description = L("settings.region.timezone_desc", "Select a time zone. Clock and calendar widgets will follow this zone.");
+
+        LauncherSettingsPanelTitleTextBlock.Text = L("settings.launcher.title", "App Launcher");
+        LauncherHiddenItemsSettingsExpander.Header = L("settings.launcher.hidden_header", "Hidden Items");
+        LauncherHiddenItemsSettingsExpander.Description = L("settings.launcher.hidden_desc", "Review hidden launcher entries and show them again.");
+        LauncherHiddenItemsDescriptionTextBlock.Text = L("settings.launcher.hidden_hint", "Right-click an icon in launcher to hide it. Hidden entries appear here.");
+        LauncherHiddenItemsEmptyTextBlock.Text = L("settings.launcher.hidden_empty", "No hidden items.");
+
+        PluginSettingsPanelTitleTextBlock.Text = L("settings.plugins.title", "Plugins");
+        PluginSystemSettingsExpander.Header = L("settings.plugins.runtime_header", "Plugin Runtime");
+        PluginSystemSettingsExpander.Description = L("settings.plugins.runtime_desc", "Review plugin runtime state and load results.");
+        PluginSystemDescriptionTextBlock.Text = L("settings.plugins.runtime_hint", "This page shows discovery status, load results, and runtime diagnostics for installed plugins.");
+        PluginSystemStatusTextBlock.Text = L("settings.plugins.runtime_status", "Plugin runtime status will appear here after plugin discovery completes.");
+        InstalledPluginsSettingsExpander.Header = L("settings.plugins.installed_header", "Installed Plugins");
+        InstalledPluginsSettingsExpander.Description = L("settings.plugins.installed_desc", "Enable or disable plugins here. Detailed plugin settings appear as separate settings pages.");
+        PluginRestartHintTextBlock.Text = L("settings.plugins.restart_hint", "Plugin enable state changes take effect after restarting the app.");
+        PluginCatalogEmptyTextBlock.Text = L("settings.plugins.empty", "No plugins found.");
+        PluginSettingsPanel.RefreshFromRuntime();
+
+        AboutPanelTitleTextBlock.Text = L("settings.about.title", "About");
+        VersionTextBlock.Text = Lf("settings.about.version_format", "Version: {0}", GetAppVersionText());
+        CodeNameTextBlock.Text = Lf("settings.about.codename_format", "Code Name: {0}", AppCodeName);
+        FontInfoTextBlock.Text = Lf("settings.about.font_format", "Font: {0}", AppFontName);
+        AboutStartupSettingsExpander.Header = L("settings.about.startup_header", "Windows Startup");
+        AboutStartupSettingsExpander.Description = L("settings.about.startup_desc", "Launch the app automatically when signing in to Windows.");
+        AboutRenderModeSettingsExpander.Header = L("settings.about.render_mode_header", "Rendering Mode");
+        AboutRenderModeSettingsExpander.Description = L(
+            "settings.about.render_mode_desc",
+            "Choose the rendering backend. Restart the app after changing this option. Unsupported modes fall back to software.");
+        SetAppRenderModeComboItemContent(AppRenderingModeHelper.Default, L("settings.about.render_mode.default", "Default"));
+        SetAppRenderModeComboItemContent(AppRenderingModeHelper.Software, L("settings.about.render_mode.software", "Software"));
+        SetAppRenderModeComboItemContent(AppRenderingModeHelper.AngleEgl, L("settings.about.render_mode.angle_egl", "angleEgl"));
+        SetAppRenderModeComboItemContent(AppRenderingModeHelper.Wgl, L("settings.about.render_mode.wgl", "WGL"));
+        SetAppRenderModeComboItemContent(AppRenderingModeHelper.Vulkan, L("settings.about.render_mode.vulkan", "Vulkan"));
+
+        var placementItems = WallpaperPlacementComboBox.Items.OfType<ComboBoxItem>().ToList();
+        if (placementItems.Count >= 5)
+        {
+            placementItems[0].Content = L("placement.fill", "Fill");
+            placementItems[1].Content = L("placement.fit", "Fit");
+            placementItems[2].Content = L("placement.stretch", "Stretch");
+            placementItems[3].Content = L("placement.center", "Center");
+            placementItems[4].Content = L("placement.tile", "Tile");
+        }
+
+        ApplyUpdateLocalization();
+        UpdateWallpaperDisplay();
+        RenderLauncherHiddenItemsList();
+    }
+
+    private void SetAppRenderModeComboItemContent(string tag, string content)
+    {
+        var item = AppRenderModeComboBox.Items
+            .OfType<ComboBoxItem>()
+            .FirstOrDefault(candidate =>
+                string.Equals(candidate.Tag?.ToString(), tag, StringComparison.OrdinalIgnoreCase));
+
+        if (item is not null)
+        {
+            item.Content = content;
+        }
+    }
+
+    private string GetLocalizedTimeZoneDisplayName(TimeZoneInfo timeZone)
+    {
+        var offset = timeZone.GetUtcOffset(DateTime.UtcNow);
+        var sign = offset >= TimeSpan.Zero ? "+" : "-";
+        var hours = Math.Abs(offset.Hours);
+        var minutes = Math.Abs(offset.Minutes);
+        var name = string.IsNullOrWhiteSpace(timeZone.StandardName) ? timeZone.DisplayName : timeZone.StandardName;
+
+        if (string.Equals(_languageCode, "zh-CN", StringComparison.OrdinalIgnoreCase) &&
+            ZhTimeZoneNames.TryGetValue(timeZone.Id, out var localizedName))
+        {
+            name = localizedName;
+        }
+
+        if (string.IsNullOrWhiteSpace(name))
+        {
+            name = timeZone.Id;
+        }
+
+        return $"(UTC{sign}{hours:D2}:{minutes:D2}) {name}";
+    }
+
+    private static string GetAppVersionText()
+    {
+        var version = typeof(MainWindow).Assembly.GetName().Version;
+        if (version is null || version.Major < 0 || version.Minor < 0 || version.Build < 0)
+        {
+            return FallbackAppVersion;
+        }
+
+        return $"{version.Major}.{version.Minor}.{version.Build}";
+    }
+
+    private void OnLanguageSelectionChanged(object? sender, SelectionChangedEventArgs e)
+    {
+        if (_suppressLanguageSelectionEvents || LanguageComboBox.SelectedItem is not ComboBoxItem item)
+        {
+            return;
+        }
+
+        _languageCode = _localizationService.NormalizeLanguageCode(item.Tag as string);
+        ApplyLocalization();
+        ThemeColorStatusTextBlock.Text = Lf("settings.region.applied_format", "Language switched to: {0}", GetLanguageDisplayName(_languageCode));
+        PersistSettings();
+    }
+}
+