Update README.md with project details, features, requirements, architecture, and data management for PLib video library manager.

.editorconfig

@@ -0,0 +1,52 @@
+root = true
+
+[*]
+charset = utf-8
+end_of_line = crlf
+indent_style = space
+indent_size = 4
+insert_final_newline = true
+trim_trailing_whitespace = true
+
+[*.{xml,axaml,xaml,csproj,props,targets,json,yml,yaml}]
+indent_size = 2
+
+[*.md]
+trim_trailing_whitespace = false
+
+[*.cs]
+# Namespaces
+csharp_style_namespace_declarations = file_scoped:warning
+
+# var
+csharp_style_var_when_type_is_apparent = true:suggestion
+csharp_style_var_elsewhere = true:suggestion
+
+# Modern language features
+csharp_style_expression_bodied_methods = when_on_single_line:suggestion
+csharp_style_expression_bodied_properties = true:suggestion
+csharp_style_prefer_primary_constructors = true:suggestion
+csharp_style_prefer_pattern_matching = true:suggestion
+csharp_style_prefer_switch_expression = true:suggestion
+csharp_prefer_braces = true:warning
+csharp_prefer_simple_using_statement = true:suggestion
+dotnet_style_collection_initializer = true:suggestion
+dotnet_style_prefer_collection_expression = true:suggestion
+dotnet_style_readonly_field = true:warning
+dotnet_style_require_accessibility_modifiers = for_non_interface_members:warning
+
+# Usings
+dotnet_sort_system_directives_first = true
+csharp_using_directive_placement = outside_namespace:warning
+
+# Naming: private fields are _camelCase
+dotnet_naming_rule.private_fields_underscore.symbols = private_fields
+dotnet_naming_rule.private_fields_underscore.style = underscore_prefix
+dotnet_naming_rule.private_fields_underscore.severity = warning
+
+dotnet_naming_symbols.private_fields.applicable_kinds = field
+dotnet_naming_symbols.private_fields.applicable_accessibilities = private
+dotnet_naming_symbols.private_fields.required_modifiers =
+
+dotnet_naming_style.underscore_prefix.capitalization = camel_case
+dotnet_naming_style.underscore_prefix.required_prefix = _

Directory.Build.props

@@ -0,0 +1,20 @@
+<Project>
+
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <LangVersion>latest</LangVersion>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+    <EnforceCodeStyleInBuild>true</EnforceCodeStyleInBuild>
+    <GenerateDocumentationFile>false</GenerateDocumentationFile>
+    <AccelerateBuildsInVisualStudio>true</AccelerateBuildsInVisualStudio>
+  </PropertyGroup>
+
+  <PropertyGroup>
+    <Product>PLib</Product>
+    <Company>PLib</Company>
+    <Version>0.1.0</Version>
+  </PropertyGroup>
+
+</Project>

Directory.Packages.props

@@ -0,0 +1,51 @@
+<Project>
+
+  <PropertyGroup>
+    <ManagePackageVersionsCentrally>true</ManagePackageVersionsCentrally>
+    <CentralPackageTransitivePinningEnabled>true</CentralPackageTransitivePinningEnabled>
+  </PropertyGroup>
+
+  <ItemGroup Label="UI">
+    <PackageVersion Include="Avalonia" Version="12.1.1" />
+    <PackageVersion Include="Avalonia.Desktop" Version="12.1.1" />
+    <PackageVersion Include="Avalonia.Controls.ItemsRepeater" Version="12.0.0" />
+    <PackageVersion Include="Avalonia.Fonts.Inter" Version="12.1.1" />
+    <PackageVersion Include="Semi.Avalonia" Version="12.1.0.1" />
+    <PackageVersion Include="Material.Icons.Avalonia" Version="3.0.2" />
+  </ItemGroup>
+
+  <ItemGroup Label="MVVM / Composition">
+    <PackageVersion Include="CommunityToolkit.Mvvm" Version="8.4.2" />
+    <PackageVersion Include="Microsoft.Extensions.Hosting" Version="10.0.10" />
+    <PackageVersion Include="Microsoft.Extensions.Options" Version="10.0.10" />
+    <PackageVersion Include="Microsoft.Extensions.Options.DataAnnotations" Version="10.0.10" />
+    <PackageVersion Include="Microsoft.Extensions.Logging.Abstractions" Version="10.0.10" />
+  </ItemGroup>
+
+  <ItemGroup Label="Persistence">
+    <PackageVersion Include="Microsoft.EntityFrameworkCore.Sqlite" Version="10.0.10" />
+    <!-- Pinned above the version EF Core resolves: 2.1.11 carries GHSA-2m69-gcr7-jv3q. -->
+    <PackageVersion Include="SQLitePCLRaw.bundle_e_sqlite3" Version="3.0.5" />
+    <PackageVersion Include="SQLitePCLRaw.core" Version="3.0.5" />
+    <PackageVersion Include="SQLitePCLRaw.lib.e_sqlite3" Version="3.53.3" />
+    <PackageVersion Include="SQLitePCLRaw.provider.e_sqlite3" Version="3.0.5" />
+  </ItemGroup>
+
+  <ItemGroup Label="Media">
+    <PackageVersion Include="FFMpegCore" Version="5.4.0" />
+  </ItemGroup>
+
+  <ItemGroup Label="Logging">
+    <PackageVersion Include="Serilog" Version="4.4.0" />
+    <PackageVersion Include="Serilog.Extensions.Logging" Version="10.0.0" />
+    <PackageVersion Include="Serilog.Sinks.Console" Version="6.1.1" />
+    <PackageVersion Include="Serilog.Sinks.File" Version="7.0.0" />
+  </ItemGroup>
+
+  <ItemGroup Label="Testing">
+    <PackageVersion Include="xunit.v3" Version="3.2.2" />
+    <PackageVersion Include="Shouldly" Version="4.3.0" />
+    <PackageVersion Include="NSubstitute" Version="6.0.0" />
+  </ItemGroup>
+
+</Project>

PLib.slnx

@@ -0,0 +1,11 @@
+<Solution>
+  <Folder Name="/src/">
+    <Project Path="src/PLib.Application/PLib.Application.csproj" />
+    <Project Path="src/PLib.Desktop/PLib.Desktop.csproj" />
+    <Project Path="src/PLib.Domain/PLib.Domain.csproj" />
+    <Project Path="src/PLib.Infrastructure/PLib.Infrastructure.csproj" />
+  </Folder>
+  <Folder Name="/tests/">
+    <Project Path="tests/PLib.Tests/PLib.Tests.csproj" />
+  </Folder>
+</Solution>

README.md

@@ -1,2 +1,66 @@
 # PLib
 
+Менеджер видеотеки на Avalonia: сканирует папки, вытаскивает превью через ffmpeg и
+показывает всё сеткой карточек.
+
+## Что уже работает
+
+- Сканирование указанных папок, инкрементальное — файл, который не изменился, не переиндексируется.
+- Метаданные (длительность, разрешение, кодек) через ffprobe.
+- Постеры кадром из видео через ffmpeg, с кэшем на диске.
+- Виртуализированная сетка карточек, ленивая загрузка превью, поиск и сортировка.
+- Светлая и тёмная темы.
+- Клик или Enter по карточке — открыть в системном плеере, правая кнопка — контекстное меню.
+
+## Требования
+
+- .NET 10 SDK
+- `ffmpeg` и `ffprobe` в `PATH`
+
+## Запуск
+
+```bash
+dotnet run --project src/PLib.Desktop
+```
+
+```bash
+dotnet test
+```
+
+## Архитектура
+
+Четыре слоя, зависимости направлены только внутрь:
+
+| Проект | Отвечает за | Знает о |
+| --- | --- | --- |
+| `PLib.Domain` | Сущность `VideoItem` и её инварианты | ни о чём |
+| `PLib.Application` | Сценарии (`LibraryService`) и абстракции портов | Domain |
+| `PLib.Infrastructure` | EF Core + SQLite, ffmpeg, файловая система | Application |
+| `PLib.Desktop` | Avalonia, ViewModel'и, composition root | Infrastructure |
+
+Ключевые решения:
+
+- **Сканирование — поток событий.** `ILibraryService.ScanAsync` возвращает
+  `IAsyncEnumerable<LibraryScanEvent>`: карточки появляются по мере находок, а не после
+  завершения всего прохода. Тяжёлая часть (ffprobe + ffmpeg) идёт параллельно через
+  `Parallel.ForEachAsync`, результаты собираются в `Channel` и применяются к сущностям
+  по одному — трекер изменений EF не потокобезопасен.
+- **Вся работа вне UI-потока.** ViewModel оборачивает конвейер в `Task.Run` и возвращает
+  каждое событие в UI явно через `Dispatcher.UIThread`.
+- **Превью живут только пока видны.** `AsyncImage` запрашивает битмап при попадании в
+  визуальное дерево и отпускает при выходе; `ThumbnailCache` — LRU на 256 записей с
+  декодированием в нужную ширину. Память зависит от размера окна, а не от размера библиотеки.
+- **Scope на операцию.** `DbContext` живёт ровно одну операцию — ViewModel берёт
+  `IServiceScopeFactory` и создаёт scope на каждый вызов.
+
+## Данные
+
+Всё пользовательское лежит в `%LOCALAPPDATA%\PLib`:
+
+- `library.db` — SQLite с метаданными;
+- `thumbnails/` — кэш постеров (ключ = путь + размер + время изменения файла);
+- `settings.json` — список папок, перечитывается на лету;
+- `logs/` — Serilog, ротация по дням.
+
+Схема создаётся через `EnsureCreated`. Когда форма таблицы устоится — заменить на
+миграции EF Core (`DatabaseInitializer` — единственное место, которое надо будет тронуть).

global.json

@@ -0,0 +1,6 @@
+{
+  "sdk": {
+    "version": "10.0.100",
+    "rollForward": "latestFeature"
+  }
+}

src/PLib.Application/Abstractions/IMediaProbe.cs

@@ -0,0 +1,14 @@
+using PLib.Domain.Videos;
+
+namespace PLib.Application.Abstractions;
+
+/// <summary>Reads duration, resolution and codec out of a media container.</summary>
+public interface IMediaProbe
+{
+    /// <summary>
+    /// Probes <paramref name="fullPath"/>. Returns <see cref="VideoTechnicalInfo.Unknown"/>
+    /// when the file cannot be read or is not a media file — probing must never throw for
+    /// a single bad file, otherwise one corrupt video would abort a whole library scan.
+    /// </summary>
+    Task<VideoTechnicalInfo> ProbeAsync(string fullPath, CancellationToken cancellationToken = default);
+}

src/PLib.Application/Abstractions/IThumbnailGenerator.cs

@@ -0,0 +1,15 @@
+namespace PLib.Application.Abstractions;
+
+/// <summary>Produces (and caches on disk) a poster frame for a video file.</summary>
+public interface IThumbnailGenerator
+{
+    /// <summary>
+    /// Returns the absolute path of the poster frame for <paramref name="videoPath"/>,
+    /// generating it if it is not cached yet. Returns <c>null</c> when no frame could be
+    /// extracted; a missing thumbnail is a normal outcome, not an error.
+    /// </summary>
+    Task<string?> GetOrCreateAsync(
+        string videoPath,
+        TimeSpan? duration,
+        CancellationToken cancellationToken = default);
+}

src/PLib.Application/Abstractions/IVideoFileScanner.cs

@@ -0,0 +1,13 @@
+namespace PLib.Application.Abstractions;
+
+/// <summary>A video file discovered on disk, before it is known to the library.</summary>
+/// <param name="FullPath">Absolute path of the file.</param>
+/// <param name="SizeInBytes">Size of the file on disk.</param>
+/// <param name="ModifiedAt">Last write time of the file.</param>
+public readonly record struct DiscoveredVideoFile(string FullPath, long SizeInBytes, DateTimeOffset ModifiedAt);
+
+/// <summary>Walks a folder tree and yields every file that looks like a video.</summary>
+public interface IVideoFileScanner
+{
+    IAsyncEnumerable<DiscoveredVideoFile> ScanAsync(string rootFolder, CancellationToken cancellationToken = default);
+}

src/PLib.Application/Abstractions/IVideoRepository.cs

@@ -0,0 +1,21 @@
+using PLib.Domain.Videos;
+
+namespace PLib.Application.Abstractions;
+
+/// <summary>
+/// Persistence boundary for the library. The application layer only ever talks to this
+/// interface, which keeps EF Core (and SQLite) an implementation detail of the outer ring.
+/// </summary>
+public interface IVideoRepository
+{
+    Task<IReadOnlyList<VideoItem>> GetAllAsync(CancellationToken cancellationToken = default);
+
+    Task<VideoItem?> FindByPathAsync(string fullPath, CancellationToken cancellationToken = default);
+
+    Task AddAsync(VideoItem item, CancellationToken cancellationToken = default);
+
+    Task RemoveAsync(VideoItem item, CancellationToken cancellationToken = default);
+
+    /// <summary>Flushes every pending change made to tracked entities.</summary>
+    Task SaveChangesAsync(CancellationToken cancellationToken = default);
+}

src/PLib.Application/Library/ILibraryService.cs

@@ -0,0 +1,18 @@
+using PLib.Domain.Videos;
+
+namespace PLib.Application.Library;
+
+/// <summary>Use cases the UI needs in order to show and refresh the video library.</summary>
+public interface ILibraryService
+{
+    /// <summary>Everything currently stored in the library, newest first.</summary>
+    Task<IReadOnlyList<VideoItem>> GetLibraryAsync(CancellationToken cancellationToken = default);
+
+    /// <summary>
+    /// Reconciles the library with the configured folders and then fills in metadata and
+    /// poster frames for anything that is missing them, streaming progress as it goes.
+    /// </summary>
+    IAsyncEnumerable<LibraryScanEvent> ScanAsync(
+        IReadOnlyList<string> folders,
+        CancellationToken cancellationToken = default);
+}

src/PLib.Application/Library/LibraryOptions.cs

@@ -0,0 +1,37 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace PLib.Application.Library;
+
+/// <summary>User-tunable settings for how the library is discovered and indexed.</summary>
+public sealed class LibraryOptions
+{
+    public const string SectionName = "Library";
+
+    /// <summary>Root folders that make up the library.</summary>
+    public IList<string> Folders { get; init; } = [];
+
+    /// <summary>File extensions treated as video, lower case and including the leading dot.</summary>
+    public IList<string> VideoExtensions { get; init; } =
+    [
+        ".mp4", ".mkv", ".avi", ".mov", ".wmv", ".webm", ".m4v", ".mpg", ".mpeg", ".flv", ".ts", ".m2ts",
+    ];
+
+    /// <summary>Width of generated poster frames in pixels; height follows the source aspect ratio.</summary>
+    [Range(160, 1920)]
+    public int ThumbnailWidth { get; init; } = 480;
+
+    /// <summary>
+    /// Fraction of the duration at which the poster frame is captured. Grabbing the very
+    /// first frame usually yields a black or logo frame, so we sample a bit into the file.
+    /// </summary>
+    [Range(0.0, 0.9)]
+    public double ThumbnailPositionRatio { get; init; } = 0.15;
+
+    /// <summary>How many files may be probed / rendered concurrently.</summary>
+    [Range(1, 32)]
+    public int MaxIndexingConcurrency { get; init; } = 4;
+
+    /// <summary>Files smaller than this are skipped as they are almost certainly not real videos.</summary>
+    [Range(0, long.MaxValue)]
+    public long MinimumFileSizeInBytes { get; init; } = 64 * 1024;
+}

src/PLib.Application/Library/LibraryPathComparer.cs

@@ -0,0 +1,12 @@
+namespace PLib.Application.Library;
+
+/// <summary>
+/// Compares file system paths the way the host platform does: case-insensitively on
+/// Windows, byte-for-byte everywhere else.
+/// </summary>
+public static class LibraryPathComparer
+{
+    public static StringComparer Instance { get; } = OperatingSystem.IsWindows()
+        ? StringComparer.OrdinalIgnoreCase
+        : StringComparer.Ordinal;
+}

src/PLib.Application/Library/LibraryScanEvent.cs

@@ -0,0 +1,32 @@
+using PLib.Domain.Videos;
+
+namespace PLib.Application.Library;
+
+/// <summary>
+/// Something that happened during a scan. The scan is exposed as a stream of these so the
+/// UI can render cards as soon as they are known instead of waiting for the whole pass.
+/// </summary>
+public abstract record LibraryScanEvent
+{
+    private LibraryScanEvent()
+    {
+    }
+
+    /// <summary>The file system walk finished and we know how much work there is.</summary>
+    public sealed record DiscoveryCompleted(int FilesFound) : LibraryScanEvent;
+
+    /// <summary>A video is now part of the library (possibly still without a poster frame).</summary>
+    public sealed record ItemAdded(VideoItem Item) : LibraryScanEvent;
+
+    /// <summary>A video that is already displayed gained metadata or a poster frame.</summary>
+    public sealed record ItemUpdated(VideoItem Item) : LibraryScanEvent;
+
+    /// <summary>A video disappeared from disk and was dropped from the library.</summary>
+    public sealed record ItemRemoved(Guid Id) : LibraryScanEvent;
+
+    /// <summary>Indexing progress, reported after every processed file.</summary>
+    public sealed record IndexingProgress(int Processed, int Total) : LibraryScanEvent;
+
+    /// <summary>The scan finished successfully.</summary>
+    public sealed record Completed(int LibrarySize) : LibraryScanEvent;
+}

src/PLib.Application/Library/LibraryService.cs

@@ -0,0 +1,184 @@
+using System.Runtime.CompilerServices;
+using System.Threading.Channels;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
+using PLib.Application.Abstractions;
+using PLib.Domain.Videos;
+
+namespace PLib.Application.Library;
+
+/// <inheritdoc cref="ILibraryService"/>
+public sealed class LibraryService(
+    IVideoRepository repository,
+    IVideoFileScanner scanner,
+    IMediaProbe mediaProbe,
+    IThumbnailGenerator thumbnailGenerator,
+    IOptions<LibraryOptions> options,
+    ILogger<LibraryService> logger) : ILibraryService
+{
+    /// <summary>How many indexed items to accumulate before flushing them to storage.</summary>
+    private const int SaveBatchSize = 25;
+
+    private readonly LibraryOptions _options = options.Value;
+
+    public async Task<IReadOnlyList<VideoItem>> GetLibraryAsync(CancellationToken cancellationToken = default)
+    {
+        var items = await repository.GetAllAsync(cancellationToken);
+        return [.. items.OrderByDescending(x => x.AddedAt)];
+    }
+
+    public async IAsyncEnumerable<LibraryScanEvent> ScanAsync(
+        IReadOnlyList<string> folders,
+        [EnumeratorCancellation] CancellationToken cancellationToken = default)
+    {
+        var known = (await repository.GetAllAsync(cancellationToken))
+            .ToDictionary(x => x.FullPath, LibraryPathComparer.Instance);
+
+        var discovered = await DiscoverAsync(folders, cancellationToken);
+        yield return new LibraryScanEvent.DiscoveryCompleted(discovered.Count);
+
+        var pending = new List<VideoItem>();
+
+        foreach (var file in discovered.Values)
+        {
+            if (known.TryGetValue(file.FullPath, out var existing))
+            {
+                existing.RefreshFileFacts(file.SizeInBytes, file.ModifiedAt);
+            }
+            else
+            {
+                existing = new VideoItem(
+                    file.FullPath,
+                    Path.GetFileNameWithoutExtension(file.FullPath),
+                    file.SizeInBytes,
+                    file.ModifiedAt);
+
+                await repository.AddAsync(existing, cancellationToken);
+                known.Add(existing.FullPath, existing);
+                yield return new LibraryScanEvent.ItemAdded(existing);
+            }
+
+            if (!existing.IsIndexed)
+            {
+                pending.Add(existing);
+            }
+        }
+
+        foreach (var orphan in known.Values.Where(x => !discovered.ContainsKey(x.FullPath)).ToList())
+        {
+            await repository.RemoveAsync(orphan, cancellationToken);
+            known.Remove(orphan.FullPath);
+            yield return new LibraryScanEvent.ItemRemoved(orphan.Id);
+        }
+
+        await repository.SaveChangesAsync(cancellationToken);
+
+        await foreach (var indexed in IndexAsync(pending, cancellationToken))
+        {
+            yield return indexed;
+        }
+
+        await repository.SaveChangesAsync(cancellationToken);
+        yield return new LibraryScanEvent.Completed(known.Count);
+    }
+
+    private async Task<Dictionary<string, DiscoveredVideoFile>> DiscoverAsync(
+        IReadOnlyList<string> folders,
+        CancellationToken cancellationToken)
+    {
+        var discovered = new Dictionary<string, DiscoveredVideoFile>(LibraryPathComparer.Instance);
+
+        foreach (var folder in folders)
+        {
+            await foreach (var file in scanner.ScanAsync(folder, cancellationToken))
+            {
+                if (file.SizeInBytes < _options.MinimumFileSizeInBytes)
+                {
+                    continue;
+                }
+
+                // Overlapping roots are legal, so the first sighting of a path wins.
+                discovered.TryAdd(file.FullPath, file);
+            }
+        }
+
+        return discovered;
+    }
+
+    /// <summary>
+    /// Probes and renders poster frames with bounded concurrency. The expensive work runs in
+    /// parallel, but the results are applied to the entities one at a time by the consumer
+    /// because change tracking is not thread safe.
+    /// </summary>
+    private async IAsyncEnumerable<LibraryScanEvent> IndexAsync(
+        IReadOnlyList<VideoItem> pending,
+        [EnumeratorCancellation] CancellationToken cancellationToken)
+    {
+        if (pending.Count == 0)
+        {
+            yield break;
+        }
+
+        var channel = Channel.CreateBounded<IndexResult>(new BoundedChannelOptions(_options.MaxIndexingConcurrency * 4)
+        {
+            SingleReader = true,
+        });
+
+        var producer = Task.Run(
+            async () =>
+            {
+                try
+                {
+                    var parallelOptions = new ParallelOptions
+                    {
+                        MaxDegreeOfParallelism = _options.MaxIndexingConcurrency,
+                        CancellationToken = cancellationToken,
+                    };
+
+                    await Parallel.ForEachAsync(
+                        pending,
+                        parallelOptions,
+                        async (item, token) =>
+                        {
+                            var info = await mediaProbe.ProbeAsync(item.FullPath, token);
+                            var thumbnail = await thumbnailGenerator.GetOrCreateAsync(item.FullPath, info.Duration, token);
+                            await channel.Writer.WriteAsync(new IndexResult(item, info, thumbnail), token);
+                        });
+
+                    channel.Writer.Complete();
+                }
+                catch (Exception ex)
+                {
+                    channel.Writer.Complete(ex);
+                }
+            },
+            cancellationToken);
+
+        var processed = 0;
+
+        await foreach (var result in channel.Reader.ReadAllAsync(cancellationToken))
+        {
+            result.Item.ApplyTechnicalInfo(result.Info);
+
+            if (result.ThumbnailPath is not null)
+            {
+                result.Item.AttachThumbnail(result.ThumbnailPath);
+            }
+
+            processed++;
+
+            yield return new LibraryScanEvent.ItemUpdated(result.Item);
+            yield return new LibraryScanEvent.IndexingProgress(processed, pending.Count);
+
+            if (processed % SaveBatchSize == 0)
+            {
+                await repository.SaveChangesAsync(cancellationToken);
+            }
+        }
+
+        await producer;
+        logger.LogInformation("Indexed {Processed} of {Total} video files", processed, pending.Count);
+    }
+
+    private readonly record struct IndexResult(VideoItem Item, VideoTechnicalInfo Info, string? ThumbnailPath);
+}

src/PLib.Application/PLib.Application.csproj

@@ -0,0 +1,16 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <RootNamespace>PLib.Application</RootNamespace>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Extensions.Logging.Abstractions" />
+    <PackageReference Include="Microsoft.Extensions.Options" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\PLib.Domain\PLib.Domain.csproj" />
+  </ItemGroup>
+
+</Project>

src/PLib.Desktop/App.axaml

@@ -0,0 +1,20 @@
+<Application xmlns="https://github.com/avaloniaui"
+             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+             x:Class="PLib.Desktop.App"
+             RequestedThemeVariant="Dark">
+
+  <Application.Resources>
+    <ResourceDictionary>
+      <ResourceDictionary.MergedDictionaries>
+        <ResourceInclude Source="avares://PLib/Themes/Palette.axaml" />
+      </ResourceDictionary.MergedDictionaries>
+    </ResourceDictionary>
+  </Application.Resources>
+
+  <Application.Styles>
+    <StyleInclude Source="avares://Semi.Avalonia/Index.axaml" />
+    <StyleInclude Source="avares://Material.Icons.Avalonia/MaterialIconStyles.axaml" />
+    <StyleInclude Source="avares://PLib/Themes/LibraryStyles.axaml" />
+  </Application.Styles>
+
+</Application>

src/PLib.Desktop/App.axaml.cs

@@ -0,0 +1,55 @@
+using Avalonia;
+using Avalonia.Controls.ApplicationLifetimes;
+using Avalonia.Markup.Xaml;
+using Avalonia.Threading;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using PLib.Desktop.Controls;
+using PLib.Desktop.Imaging;
+using PLib.Desktop.ViewModels;
+using PLib.Desktop.Views;
+
+namespace PLib.Desktop;
+
+// Fully qualified: the PLib.Application namespace shadows the Application type in this assembly.
+public sealed class App : Avalonia.Application
+{
+    private IHost? _host;
+
+    public override void Initialize() => AvaloniaXamlLoader.Load(this);
+
+    public override void OnFrameworkInitializationCompleted()
+    {
+        if (ApplicationLifetime is IClassicDesktopStyleApplicationLifetime desktop)
+        {
+            _host = AppHost.Create(desktop.Args ?? []);
+            _host.Start();
+
+            AsyncImage.Loader = _host.Services.GetRequiredService<ThumbnailCache>();
+
+            var viewModel = _host.Services.GetRequiredService<MainWindowViewModel>();
+            desktop.MainWindow = new MainWindow { DataContext = viewModel };
+            desktop.Exit += OnExit;
+
+            // Kick the first load off once the dispatcher is running, so a failure surfaces
+            // through the view model instead of disappearing into an unobserved task.
+            Dispatcher.UIThread.Post(
+                () => viewModel.InitializeCommand.Execute(null),
+                DispatcherPriority.Background);
+        }
+
+        base.OnFrameworkInitializationCompleted();
+    }
+
+    private void OnExit(object? sender, ControlledApplicationLifetimeExitEventArgs e)
+    {
+        if (_host is null)
+        {
+            return;
+        }
+
+        _host.StopAsync(TimeSpan.FromSeconds(3)).GetAwaiter().GetResult();
+        _host.Dispose();
+        _host = null;
+    }
+}

src/PLib.Desktop/AppHost.cs

@@ -0,0 +1,69 @@
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
+using PLib.Desktop.Imaging;
+using PLib.Desktop.Services;
+using PLib.Desktop.ViewModels;
+using PLib.Infrastructure;
+using PLib.Infrastructure.Storage;
+using Serilog;
+
+namespace PLib.Desktop;
+
+/// <summary>
+/// Composition root. Everything the application is made of is wired up here and nowhere else.
+/// </summary>
+internal static class AppHost
+{
+    public static IHost Create(string[] args)
+    {
+        // The paths are needed to locate the user settings file, which is itself a
+        // configuration source — so they are built before the container exists and then
+        // handed to it as an instance.
+        var paths = new AppPaths();
+
+        // A desktop app is launched from arbitrary working directories, so the content root
+        // has to be the folder the executable lives in rather than Environment.CurrentDirectory.
+        var builder = Host.CreateApplicationBuilder(new HostApplicationBuilderSettings
+        {
+            Args = args,
+            ContentRootPath = AppContext.BaseDirectory,
+        });
+
+        builder.Configuration.AddJsonFile(
+            Path.Combine(paths.DataDirectory, "settings.json"),
+            optional: true,
+            reloadOnChange: true);
+
+        ConfigureLogging(builder, paths);
+
+        builder.Services.AddSingleton<IAppPaths>(paths);
+        builder.Services.AddPLibInfrastructure(builder.Configuration);
+
+        builder.Services.AddSingleton<ThumbnailCache>();
+        builder.Services.AddSingleton<IThumbnailLoader>(sp => sp.GetRequiredService<ThumbnailCache>());
+        builder.Services.AddSingleton<ILibrarySettingsStore, JsonLibrarySettingsStore>();
+        builder.Services.AddSingleton<IFolderPicker, StorageProviderFolderPicker>();
+        builder.Services.AddSingleton<ISystemShell, SystemShell>();
+        builder.Services.AddSingleton<IThemeService, ThemeService>();
+        builder.Services.AddSingleton<MainWindowViewModel>();
+
+        return builder.Build();
+    }
+
+    private static void ConfigureLogging(HostApplicationBuilder builder, IAppPaths paths)
+    {
+        Log.Logger = new LoggerConfiguration()
+            .MinimumLevel.Information()
+            .WriteTo.Console()
+            .WriteTo.File(
+                Path.Combine(paths.DataDirectory, "logs", "plib-.log"),
+                rollingInterval: RollingInterval.Day,
+                retainedFileCountLimit: 7)
+            .CreateLogger();
+
+        builder.Logging.ClearProviders();
+        builder.Logging.AddSerilog(Log.Logger, dispose: true);
+    }
+}

src/PLib.Desktop/Controls/AsyncImage.cs

@@ -0,0 +1,201 @@
+using Avalonia;
+using Avalonia.Animation;
+using Avalonia.Animation.Easings;
+using Avalonia.Controls;
+using Avalonia.Media;
+using Avalonia.Media.Imaging;
+using Avalonia.Threading;
+using PLib.Desktop.Imaging;
+
+namespace PLib.Desktop.Controls;
+
+/// <summary>
+/// Draws a poster frame that is loaded only while the control is actually on screen.
+/// </summary>
+/// <remarks>
+/// A virtualised grid recycles containers as the user scrolls, so binding a decoded
+/// <see cref="Bitmap"/> straight into the view model would keep every frame the user has ever
+/// passed alive. Instead the control asks the shared loader when it is attached to the visual
+/// tree and drops its reference when it is detached, which keeps memory proportional to what
+/// is visible rather than to the size of the library.
+/// </remarks>
+public sealed class AsyncImage : Control
+{
+    public static readonly StyledProperty<string?> SourceProperty =
+        AvaloniaProperty.Register<AsyncImage, string?>(nameof(Source));
+
+    public static readonly StyledProperty<int> DecodeWidthProperty =
+        AvaloniaProperty.Register<AsyncImage, int>(nameof(DecodeWidth), defaultValue: 400);
+
+    public static readonly StyledProperty<IBrush?> PlaceholderBrushProperty =
+        AvaloniaProperty.Register<AsyncImage, IBrush?>(nameof(PlaceholderBrush));
+
+    /// <summary>
+    /// Shared loader, assigned once by the composition root. A control is created by the XAML
+    /// runtime and therefore cannot take constructor dependencies.
+    /// </summary>
+    public static IThumbnailLoader? Loader { get; set; }
+
+    private CancellationTokenSource? _pending;
+    private Bitmap? _bitmap;
+    private bool _isAttached;
+
+    static AsyncImage()
+    {
+        AffectsRender<AsyncImage>(SourceProperty, PlaceholderBrushProperty);
+    }
+
+    public AsyncImage()
+    {
+        Opacity = 0;
+        Transitions =
+        [
+            new DoubleTransition
+            {
+                Property = OpacityProperty,
+                Duration = TimeSpan.FromMilliseconds(220),
+                Easing = new CubicEaseOut(),
+            },
+        ];
+    }
+
+    public string? Source
+    {
+        get => GetValue(SourceProperty);
+        set => SetValue(SourceProperty, value);
+    }
+
+    /// <summary>Target width in pixels for decoding; smaller means less memory per card.</summary>
+    public int DecodeWidth
+    {
+        get => GetValue(DecodeWidthProperty);
+        set => SetValue(DecodeWidthProperty, value);
+    }
+
+    public IBrush? PlaceholderBrush
+    {
+        get => GetValue(PlaceholderBrushProperty);
+        set => SetValue(PlaceholderBrushProperty, value);
+    }
+
+    protected override void OnAttachedToVisualTree(VisualTreeAttachmentEventArgs e)
+    {
+        base.OnAttachedToVisualTree(e);
+        _isAttached = true;
+        BeginLoad();
+    }
+
+    protected override void OnDetachedFromVisualTree(VisualTreeAttachmentEventArgs e)
+    {
+        base.OnDetachedFromVisualTree(e);
+        _isAttached = false;
+        Release();
+    }
+
+    protected override void OnPropertyChanged(AvaloniaPropertyChangedEventArgs change)
+    {
+        base.OnPropertyChanged(change);
+
+        if (change.Property == SourceProperty || change.Property == DecodeWidthProperty)
+        {
+            Release();
+            BeginLoad();
+        }
+    }
+
+    public override void Render(DrawingContext context)
+    {
+        var bounds = new Rect(Bounds.Size);
+
+        if (bounds.Width <= 0 || bounds.Height <= 0)
+        {
+            return;
+        }
+
+        if (_bitmap is null)
+        {
+            if (PlaceholderBrush is { } placeholder)
+            {
+                context.FillRectangle(placeholder, bounds);
+            }
+
+            return;
+        }
+
+        context.DrawImage(_bitmap, CoverSourceRect(_bitmap.PixelSize, bounds), bounds);
+    }
+
+    /// <summary>
+    /// Picks the largest centred crop of the source that has the same aspect ratio as the
+    /// destination, i.e. CSS <c>object-fit: cover</c>: fill the card, never letterbox.
+    /// </summary>
+    private static Rect CoverSourceRect(PixelSize source, Rect destination)
+    {
+        var scale = Math.Max(destination.Width / source.Width, destination.Height / source.Height);
+        var width = destination.Width / scale;
+        var height = destination.Height / scale;
+
+        return new Rect((source.Width - width) / 2, (source.Height - height) / 2, width, height);
+    }
+
+    private void BeginLoad()
+    {
+        if (!_isAttached || Loader is not { } loader || string.IsNullOrEmpty(Source))
+        {
+            return;
+        }
+
+        var cts = new CancellationTokenSource();
+        _pending = cts;
+
+        _ = LoadAsync(loader, Source, DecodeWidth, cts);
+    }
+
+    private async Task LoadAsync(IThumbnailLoader loader, string path, int decodeWidth, CancellationTokenSource cts)
+    {
+        try
+        {
+            var bitmap = await loader.GetAsync(path, decodeWidth, cts.Token);
+
+            if (bitmap is null || cts.IsCancellationRequested)
+            {
+                return;
+            }
+
+            await Dispatcher.UIThread.InvokeAsync(() =>
+            {
+                // The container may have been recycled onto a different item while we decoded.
+                if (cts.IsCancellationRequested || !ReferenceEquals(_pending, cts))
+                {
+                    return;
+                }
+
+                _bitmap = bitmap;
+                Opacity = 1;
+                InvalidateVisual();
+            });
+        }
+        catch (OperationCanceledException)
+        {
+            // Scrolled away before the frame was ready; nothing to show and nothing to report.
+        }
+    }
+
+    /// <summary>
+    /// Cancels any in-flight decode and drops the reference to the bitmap. The bitmap itself
+    /// belongs to the cache and is never disposed here.
+    /// </summary>
+    private void Release()
+    {
+        if (_pending is { } cts)
+        {
+            _pending = null;
+            cts.Cancel();
+            cts.Dispose();
+        }
+
+        _bitmap = null;
+        Opacity = 0;
+        InvalidateVisual();
+    }
+}

src/PLib.Desktop/Imaging/IThumbnailLoader.cs

@@ -0,0 +1,9 @@
+using Avalonia.Media.Imaging;
+
+namespace PLib.Desktop.Imaging;
+
+/// <summary>The view-side contract for turning a poster frame path into a drawable bitmap.</summary>
+public interface IThumbnailLoader
+{
+    Task<Bitmap?> GetAsync(string path, int decodeWidth, CancellationToken cancellationToken);
+}

src/PLib.Desktop/Imaging/ThumbnailCache.cs

@@ -0,0 +1,114 @@
+using Avalonia.Media.Imaging;
+using Microsoft.Extensions.Logging;
+
+namespace PLib.Desktop.Imaging;
+
+/// <summary>
+/// Decodes poster frames off the UI thread and keeps the most recently used ones in memory.
+/// </summary>
+/// <remarks>
+/// A library can hold thousands of files, so decoded bitmaps cannot all stay alive. Entries
+/// are evicted by least-recent use but never disposed: a card that is still on screen may be
+/// rendering the very bitmap we drop, and the garbage collector is the only party that knows
+/// when the last reference is gone.
+/// </remarks>
+public sealed class ThumbnailCache(ILogger<ThumbnailCache> logger) : IThumbnailLoader
+{
+    private const int Capacity = 256;
+
+    /// <summary>Decoding is CPU bound; a couple of workers keeps scrolling smooth without thrashing.</summary>
+    private readonly SemaphoreSlim _decodeSlots = new(Math.Max(2, Environment.ProcessorCount / 2));
+
+    private readonly Lock _gate = new();
+    private readonly Dictionary<CacheKey, LinkedListNode<CacheEntry>> _entries = [];
+    private readonly LinkedList<CacheEntry> _recency = [];
+
+    public async Task<Bitmap?> GetAsync(string path, int decodeWidth, CancellationToken cancellationToken)
+    {
+        var key = new CacheKey(path, decodeWidth);
+
+        if (TryTouch(key, out var cached))
+        {
+            return cached;
+        }
+
+        await _decodeSlots.WaitAsync(cancellationToken);
+
+        try
+        {
+            // Another card may have decoded the same frame while we waited for a slot.
+            if (TryTouch(key, out cached))
+            {
+                return cached;
+            }
+
+            var bitmap = await Task.Run(() => Decode(path, decodeWidth), cancellationToken);
+
+            if (bitmap is not null)
+            {
+                Store(key, bitmap);
+            }
+
+            return bitmap;
+        }
+        finally
+        {
+            _decodeSlots.Release();
+        }
+    }
+
+    private Bitmap? Decode(string path, int decodeWidth)
+    {
+        try
+        {
+            using var stream = File.OpenRead(path);
+            return Bitmap.DecodeToWidth(stream, decodeWidth, BitmapInterpolationMode.HighQuality);
+        }
+        catch (Exception ex)
+        {
+            logger.LogDebug(ex, "Could not decode thumbnail {Path}", path);
+            return null;
+        }
+    }
+
+    private bool TryTouch(CacheKey key, out Bitmap? bitmap)
+    {
+        lock (_gate)
+        {
+            if (_entries.TryGetValue(key, out var node))
+            {
+                _recency.Remove(node);
+                _recency.AddFirst(node);
+                bitmap = node.Value.Bitmap;
+                return true;
+            }
+        }
+
+        bitmap = null;
+        return false;
+    }
+
+    private void Store(CacheKey key, Bitmap bitmap)
+    {
+        lock (_gate)
+        {
+            if (_entries.ContainsKey(key))
+            {
+                return;
+            }
+
+            _entries[key] = _recency.AddFirst(new CacheEntry(key, bitmap));
+
+            while (_recency.Count > Capacity)
+            {
+                var evicted = _recency.Last!;
+                _recency.RemoveLast();
+                _entries.Remove(evicted.Value.Key);
+            }
+        }
+    }
+
+    private readonly record struct CacheKey(string Path, int DecodeWidth);
+
+    private readonly record struct CacheEntry(CacheKey Key, Bitmap Bitmap);
+}

src/PLib.Desktop/PLib.Desktop.csproj

@@ -0,0 +1,38 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>WinExe</OutputType>
+    <RootNamespace>PLib.Desktop</RootNamespace>
+    <AssemblyName>PLib</AssemblyName>
+    <BuiltInComInteropSupport>true</BuiltInComInteropSupport>
+    <ApplicationManifest>app.manifest</ApplicationManifest>
+    <AvaloniaUseCompiledBindingsByDefault>true</AvaloniaUseCompiledBindingsByDefault>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <AvaloniaResource Include="Assets\**" />
+    <None Update="appsettings.json">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Avalonia" />
+    <PackageReference Include="Avalonia.Desktop" />
+    <PackageReference Include="Avalonia.Controls.ItemsRepeater" />
+    <PackageReference Include="Avalonia.Fonts.Inter" />
+    <PackageReference Include="Semi.Avalonia" />
+    <PackageReference Include="Material.Icons.Avalonia" />
+    <PackageReference Include="CommunityToolkit.Mvvm" />
+    <PackageReference Include="Microsoft.Extensions.Hosting" />
+    <PackageReference Include="Serilog" />
+    <PackageReference Include="Serilog.Extensions.Logging" />
+    <PackageReference Include="Serilog.Sinks.Console" />
+    <PackageReference Include="Serilog.Sinks.File" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\PLib.Infrastructure\PLib.Infrastructure.csproj" />
+  </ItemGroup>
+
+</Project>

src/PLib.Desktop/Program.cs

@@ -0,0 +1,18 @@
+using Avalonia;
+
+namespace PLib.Desktop;
+
+internal static class Program
+{
+    // Avalonia must be initialised before anything touches its types, so keep Main free of
+    // any other work and let App own the application host.
+    [STAThread]
+    public static void Main(string[] args) => BuildAvaloniaApp()
+        .StartWithClassicDesktopLifetime(args);
+
+    /// <summary>Also used by the XAML previewer, which requires this exact signature.</summary>
+    public static AppBuilder BuildAvaloniaApp() => AppBuilder.Configure<App>()
+        .UsePlatformDetect()
+        .WithInterFont()
+        .LogToTrace();
+}

src/PLib.Desktop/Services/IFolderPicker.cs

@@ -0,0 +1,7 @@
+namespace PLib.Desktop.Services;
+
+/// <summary>Asks the user for a folder. Returns <c>null</c> when the dialog is dismissed.</summary>
+public interface IFolderPicker
+{
+    Task<string?> PickFolderAsync(string title, CancellationToken cancellationToken = default);
+}

src/PLib.Desktop/Services/ILibrarySettingsStore.cs

@@ -0,0 +1,11 @@
+namespace PLib.Desktop.Services;
+
+/// <summary>
+/// Persists the parts of <see cref="Application.Library.LibraryOptions"/> the user can change
+/// at runtime. Writes land in a JSON file that is also a configuration source, so
+/// <c>IOptionsMonitor</c> picks the change up without a restart.
+/// </summary>
+public interface ILibrarySettingsStore
+{
+    Task SaveFoldersAsync(IReadOnlyList<string> folders, CancellationToken cancellationToken = default);
+}

src/PLib.Desktop/Services/JsonLibrarySettingsStore.cs

@@ -0,0 +1,64 @@
+using System.Text.Json;
+using System.Text.Json.Nodes;
+using PLib.Application.Library;
+using PLib.Infrastructure.Storage;
+
+namespace PLib.Desktop.Services;
+
+/// <inheritdoc cref="ILibrarySettingsStore"/>
+public sealed class JsonLibrarySettingsStore(IAppPaths paths) : ILibrarySettingsStore
+{
+    private static readonly JsonSerializerOptions WriteOptions = new() { WriteIndented = true };
+
+    private readonly SemaphoreSlim _writeLock = new(1, 1);
+
+    private string SettingsFile => Path.Combine(paths.DataDirectory, "settings.json");
+
+    public async Task SaveFoldersAsync(
+        IReadOnlyList<string> folders,
+        CancellationToken cancellationToken = default)
+    {
+        await _writeLock.WaitAsync(cancellationToken);
+
+        try
+        {
+            var root = await ReadRootAsync(cancellationToken);
+
+            if (root[LibraryOptions.SectionName] is not JsonObject section)
+            {
+                section = [];
+                root[LibraryOptions.SectionName] = section;
+            }
+
+            section["Folders"] = new JsonArray([.. folders.Select(f => (JsonNode)JsonValue.Create(f))]);
+
+            // Write through a temp file so an interrupted save cannot corrupt the settings.
+            var staging = SettingsFile + ".tmp";
+            await File.WriteAllTextAsync(staging, root.ToJsonString(WriteOptions), cancellationToken);
+            File.Move(staging, SettingsFile, overwrite: true);
+        }
+        finally
+        {
+            _writeLock.Release();
+        }
+    }
+
+    private async Task<JsonObject> ReadRootAsync(CancellationToken cancellationToken)
+    {
+        if (!File.Exists(SettingsFile))
+        {
+            return [];
+        }
+
+        try
+        {
+            var json = await File.ReadAllTextAsync(SettingsFile, cancellationToken);
+            return JsonNode.Parse(json) as JsonObject ?? [];
+        }
+        catch (JsonException)
+        {
+            // A hand-edited, broken settings file should not stop the app from saving.
+            return [];
+        }
+    }
+}

src/PLib.Desktop/Services/StorageProviderFolderPicker.cs

@@ -0,0 +1,28 @@
+using Avalonia;
+using Avalonia.Controls.ApplicationLifetimes;
+using Avalonia.Platform.Storage;
+
+namespace PLib.Desktop.Services;
+
+/// <inheritdoc cref="IFolderPicker"/>
+public sealed class StorageProviderFolderPicker : IFolderPicker
+{
+    public async Task<string?> PickFolderAsync(string title, CancellationToken cancellationToken = default)
+    {
+        if (Avalonia.Application.Current?.ApplicationLifetime is not IClassicDesktopStyleApplicationLifetime
+            {
+                MainWindow.StorageProvider: { } storageProvider,
+            })
+        {
+            return null;
+        }
+
+        var folders = await storageProvider.OpenFolderPickerAsync(new FolderPickerOpenOptions
+        {
+            Title = title,
+            AllowMultiple = false,
+        });
+
+        return folders.Count > 0 ? folders[0].TryGetLocalPath() : null;
+    }
+}

src/PLib.Desktop/Services/SystemShell.cs

@@ -0,0 +1,58 @@
+using System.Diagnostics;
+using Microsoft.Extensions.Logging;
+
+namespace PLib.Desktop.Services;
+
+/// <summary>Hands a file over to whatever the operating system uses to open or show it.</summary>
+public interface ISystemShell
+{
+    void OpenFile(string path);
+
+    void RevealInFileManager(string path);
+}
+
+/// <inheritdoc cref="ISystemShell"/>
+public sealed class SystemShell(ILogger<SystemShell> logger) : ISystemShell
+{
+    public void OpenFile(string path) => Start(new ProcessStartInfo(path) { UseShellExecute = true }, path);
+
+    public void RevealInFileManager(string path)
+    {
+        ProcessStartInfo startInfo;
+
+        if (OperatingSystem.IsWindows())
+        {
+            startInfo = new ProcessStartInfo("explorer.exe", $"/select,\"{path}\"");
+        }
+        else if (OperatingSystem.IsMacOS())
+        {
+            startInfo = new ProcessStartInfo("open", ["-R", path]);
+        }
+        else
+        {
+            var folder = Path.GetDirectoryName(path);
+
+            if (folder is null)
+            {
+                return;
+            }
+
+            startInfo = new ProcessStartInfo("xdg-open", [folder]);
+        }
+
+        Start(startInfo, path);
+    }
+
+    private void Start(ProcessStartInfo startInfo, string path)
+    {
+        try
+        {
+            using var process = Process.Start(startInfo);
+        }
+        catch (Exception ex)
+        {
+            // Nothing actionable for the user here; a missing handler is not a crash.
+            logger.LogWarning(ex, "Could not hand {Path} to the shell", path);
+        }
+    }
+}

src/PLib.Desktop/Services/ThemeService.cs

@@ -0,0 +1,28 @@
+using Avalonia;
+using Avalonia.Styling;
+
+namespace PLib.Desktop.Services;
+
+/// <summary>Switches the application between the light and dark variants.</summary>
+public interface IThemeService
+{
+    void Toggle();
+}
+
+/// <inheritdoc cref="IThemeService"/>
+public sealed class ThemeService : IThemeService
+{
+    public void Toggle()
+    {
+        if (Avalonia.Application.Current is not { } application)
+        {
+            return;
+        }
+
+        // ActualThemeVariant resolves "follow the system" to whatever is on screen right now,
+        // which is what the user is actually toggling away from.
+        application.RequestedThemeVariant = application.ActualThemeVariant == ThemeVariant.Dark
+            ? ThemeVariant.Light
+            : ThemeVariant.Dark;
+    }
+}

src/PLib.Desktop/Themes/LibraryStyles.axaml

@@ -0,0 +1,121 @@
+<Styles xmlns="https://github.com/avaloniaui"
+        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
+
+  <!-- ============================ Card ============================ -->
+
+  <!--
+    The card is a Button so that keyboard focus, Enter/Space and the pointer all activate it
+    for free. Its template is reduced to a single surface Border because the Semi button
+    chrome would fight the artwork.
+  -->
+  <Style Selector="Button.card">
+    <Setter Property="Padding" Value="0" />
+    <Setter Property="Background" Value="Transparent" />
+    <!-- Without these the card keeps its desired size inside the grid cell the layout
+         hands it, which leaves the cards small and the grid full of gaps. -->
+    <Setter Property="HorizontalAlignment" Value="Stretch" />
+    <Setter Property="VerticalAlignment" Value="Stretch" />
+    <Setter Property="HorizontalContentAlignment" Value="Stretch" />
+    <Setter Property="VerticalContentAlignment" Value="Stretch" />
+    <Setter Property="Cursor" Value="Hand" />
+    <Setter Property="RenderTransform" Value="none" />
+    <Setter Property="Transitions">
+      <Transitions>
+        <TransformOperationsTransition Property="RenderTransform" Duration="0:0:0.16" Easing="CubicEaseOut" />
+      </Transitions>
+    </Setter>
+    <Setter Property="Template">
+      <ControlTemplate>
+        <Border Name="PART_Surface"
+                Background="{DynamicResource CardBackgroundBrush}"
+                BorderBrush="{DynamicResource CardBorderBrush}"
+                BorderThickness="1"
+                CornerRadius="14"
+                Padding="8,8,8,10">
+          <Border.Transitions>
+            <Transitions>
+              <BrushTransition Property="BorderBrush" Duration="0:0:0.16" />
+            </Transitions>
+          </Border.Transitions>
+          <ContentPresenter Content="{TemplateBinding Content}"
+                            ContentTemplate="{TemplateBinding ContentTemplate}"
+                            HorizontalContentAlignment="Stretch"
+                            VerticalContentAlignment="Stretch" />
+        </Border>
+      </ControlTemplate>
+    </Setter>
+  </Style>
+
+  <Style Selector="Button.card:pointerover">
+    <Setter Property="RenderTransform" Value="scale(1.025)" />
+  </Style>
+
+  <Style Selector="Button.card:pointerover /template/ Border#PART_Surface">
+    <Setter Property="BorderBrush" Value="{DynamicResource CardHoverBorderBrush}" />
+  </Style>
+
+  <Style Selector="Button.card:pressed">
+    <Setter Property="RenderTransform" Value="scale(0.99)" />
+  </Style>
+
+  <Style Selector="Button.card:focus-visible /template/ Border#PART_Surface">
+    <Setter Property="BorderBrush" Value="{DynamicResource AccentBrush}" />
+  </Style>
+
+  <!-- Play affordance: invisible until the pointer is over the card. -->
+  <Style Selector="Border.playOverlay">
+    <Setter Property="Opacity" Value="0" />
+    <Setter Property="Transitions">
+      <Transitions>
+        <DoubleTransition Property="Opacity" Duration="0:0:0.16" Easing="CubicEaseOut" />
+      </Transitions>
+    </Setter>
+  </Style>
+
+  <Style Selector="Button.card:pointerover Border.playOverlay">
+    <Setter Property="Opacity" Value="1" />
+  </Style>
+
+  <!-- ============================ Text ============================ -->
+
+  <Style Selector="TextBlock.cardTitle">
+    <Setter Property="Foreground" Value="{DynamicResource TextPrimaryBrush}" />
+    <Setter Property="FontSize" Value="13" />
+    <Setter Property="FontWeight" Value="SemiBold" />
+    <Setter Property="LineHeight" Value="18" />
+    <Setter Property="MaxLines" Value="2" />
+    <Setter Property="TextWrapping" Value="Wrap" />
+    <Setter Property="TextTrimming" Value="CharacterEllipsis" />
+  </Style>
+
+  <Style Selector="TextBlock.cardMeta">
+    <Setter Property="Foreground" Value="{DynamicResource TextTertiaryBrush}" />
+    <Setter Property="FontSize" Value="11.5" />
+  </Style>
+
+  <Style Selector="TextBlock.sectionTitle">
+    <Setter Property="Foreground" Value="{DynamicResource TextPrimaryBrush}" />
+    <Setter Property="FontSize" Value="17" />
+    <Setter Property="FontWeight" Value="Bold" />
+  </Style>
+
+  <Style Selector="TextBlock.subtle">
+    <Setter Property="Foreground" Value="{DynamicResource TextSecondaryBrush}" />
+    <Setter Property="FontSize" Value="12.5" />
+  </Style>
+
+  <!-- ============================ Badge ============================ -->
+
+  <Style Selector="Border.badge">
+    <Setter Property="Background" Value="{DynamicResource BadgeBackgroundBrush}" />
+    <Setter Property="CornerRadius" Value="6" />
+    <Setter Property="Padding" Value="6,2" />
+  </Style>
+
+  <Style Selector="Border.badge > TextBlock">
+    <Setter Property="Foreground" Value="{DynamicResource BadgeForegroundBrush}" />
+    <Setter Property="FontSize" Value="11" />
+    <Setter Property="FontWeight" Value="SemiBold" />
+  </Style>
+
+</Styles>

src/PLib.Desktop/Themes/Palette.axaml

@@ -0,0 +1,49 @@
+<ResourceDictionary xmlns="https://github.com/avaloniaui"
+                    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
+
+  <!--
+    Semantic brushes owned by this application. Semi.Avalonia styles the controls; the
+    surfaces the library grid is built from are defined here so the card design does not
+    depend on the internal resource keys of a third-party theme.
+  -->
+  <ResourceDictionary.ThemeDictionaries>
+
+    <ResourceDictionary x:Key="Dark">
+      <SolidColorBrush x:Key="PageBackgroundBrush" Color="#0E1014" />
+      <SolidColorBrush x:Key="SurfaceBrush" Color="#14171D" />
+      <SolidColorBrush x:Key="SurfaceBorderBrush" Color="#20252E" />
+      <SolidColorBrush x:Key="CardBackgroundBrush" Color="#171B22" />
+      <SolidColorBrush x:Key="CardBorderBrush" Color="#242A34" />
+      <SolidColorBrush x:Key="CardHoverBorderBrush" Color="#3F4B5E" />
+      <SolidColorBrush x:Key="ThumbnailPlaceholderBrush" Color="#1C222B" />
+      <SolidColorBrush x:Key="TextPrimaryBrush" Color="#E8EDF4" />
+      <SolidColorBrush x:Key="TextSecondaryBrush" Color="#97A2B2" />
+      <SolidColorBrush x:Key="TextTertiaryBrush" Color="#69737F" />
+      <SolidColorBrush x:Key="AccentBrush" Color="#5B8CFF" />
+      <SolidColorBrush x:Key="AccentSoftBrush" Color="#1E2A44" />
+      <SolidColorBrush x:Key="BadgeBackgroundBrush" Color="#B3000000" />
+      <SolidColorBrush x:Key="BadgeForegroundBrush" Color="#F2F5FA" />
+      <SolidColorBrush x:Key="OverlayBrush" Color="#59000000" />
+    </ResourceDictionary>
+
+    <ResourceDictionary x:Key="Light">
+      <SolidColorBrush x:Key="PageBackgroundBrush" Color="#F4F6F9" />
+      <SolidColorBrush x:Key="SurfaceBrush" Color="#FFFFFF" />
+      <SolidColorBrush x:Key="SurfaceBorderBrush" Color="#E6E9EF" />
+      <SolidColorBrush x:Key="CardBackgroundBrush" Color="#FFFFFF" />
+      <SolidColorBrush x:Key="CardBorderBrush" Color="#E4E7EC" />
+      <SolidColorBrush x:Key="CardHoverBorderBrush" Color="#B9C3D3" />
+      <SolidColorBrush x:Key="ThumbnailPlaceholderBrush" Color="#E9EDF2" />
+      <SolidColorBrush x:Key="TextPrimaryBrush" Color="#111621" />
+      <SolidColorBrush x:Key="TextSecondaryBrush" Color="#586274" />
+      <SolidColorBrush x:Key="TextTertiaryBrush" Color="#8A93A2" />
+      <SolidColorBrush x:Key="AccentBrush" Color="#2F6BFF" />
+      <SolidColorBrush x:Key="AccentSoftBrush" Color="#E5EDFF" />
+      <SolidColorBrush x:Key="BadgeBackgroundBrush" Color="#B3101418" />
+      <SolidColorBrush x:Key="BadgeForegroundBrush" Color="#FFFFFF" />
+      <SolidColorBrush x:Key="OverlayBrush" Color="#4D000000" />
+    </ResourceDictionary>
+
+  </ResourceDictionary.ThemeDictionaries>
+
+</ResourceDictionary>

src/PLib.Desktop/ViewModels/DisplayText.cs

@@ -0,0 +1,47 @@
+using System.Globalization;
+
+namespace PLib.Desktop.ViewModels;
+
+/// <summary>Turns raw numbers into the short strings the cards show.</summary>
+internal static class DisplayText
+{
+    private static readonly string[] SizeUnits = ["Б", "КБ", "МБ", "ГБ", "ТБ"];
+
+    public static string Duration(TimeSpan? duration) => duration switch
+    {
+        null or { TotalSeconds: < 1 } => "—",
+        { TotalHours: >= 1 } value => value.ToString(@"h\:mm\:ss", CultureInfo.InvariantCulture),
+        var value => value.Value.ToString(@"m\:ss", CultureInfo.InvariantCulture),
+    };
+
+    public static string FileSize(long bytes)
+    {
+        double value = bytes;
+        var unit = 0;
+
+        while (value >= 1024 && unit < SizeUnits.Length - 1)
+        {
+            value /= 1024;
+            unit++;
+        }
+
+        var precision = value < 10 && unit > 0 ? 1 : 0;
+        return string.Create(CultureInfo.CurrentCulture, $"{Math.Round(value, precision)} {SizeUnits[unit]}");
+    }
+
+    /// <summary>
+    /// Names the vertical resolution the way people talk about it, falling back to the raw
+    /// dimensions for anything that does not match a familiar tier.
+    /// </summary>
+    public static string? Quality(int? width, int? height) => (width, height) switch
+    {
+        (null, _) or (_, null) => null,
+        ( >= 7000, _) => "8K",
+        ( >= 3500, _) => "4K",
+        (_, >= 2000) => "1440p",
+        (_, >= 1000) => "1080p",
+        (_, >= 700) => "720p",
+        (_, >= 460) => "480p",
+        var (w, h) => $"{w}×{h}",
+    };
+}

src/PLib.Desktop/ViewModels/MainWindowViewModel.cs

@@ -0,0 +1,302 @@
+using System.Collections.ObjectModel;
+using Avalonia.Threading;
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
+using PLib.Application.Library;
+using PLib.Desktop.Services;
+
+namespace PLib.Desktop.ViewModels;
+
+public sealed partial class MainWindowViewModel : ObservableObject
+{
+    private readonly IServiceScopeFactory _scopeFactory;
+    private readonly IOptionsMonitor<LibraryOptions> _options;
+    private readonly ILibrarySettingsStore _settingsStore;
+    private readonly IFolderPicker _folderPicker;
+    private readonly ISystemShell _shell;
+    private readonly IThemeService _theme;
+    private readonly ILogger<MainWindowViewModel> _logger;
+
+    /// <summary>Every card we know about; <see cref="Videos"/> is the filtered, sorted view of it.</summary>
+    private readonly List<VideoCardViewModel> _all = [];
+    private readonly Dictionary<Guid, VideoCardViewModel> _byId = [];
+
+    public MainWindowViewModel(
+        IServiceScopeFactory scopeFactory,
+        IOptionsMonitor<LibraryOptions> options,
+        ILibrarySettingsStore settingsStore,
+        IFolderPicker folderPicker,
+        ISystemShell shell,
+        IThemeService theme,
+        ILogger<MainWindowViewModel> logger)
+    {
+        _scopeFactory = scopeFactory;
+        _options = options;
+        _settingsStore = settingsStore;
+        _folderPicker = folderPicker;
+        _shell = shell;
+        _theme = theme;
+        _logger = logger;
+
+        SelectedSort = SortOption.All[0];
+    }
+
+    public ObservableCollection<VideoCardViewModel> Videos { get; } = [];
+
+    public IReadOnlyList<SortOption> SortOptions => SortOption.All;
+
+    public IReadOnlyList<string> Folders => [.. _options.CurrentValue.Folders];
+
+    [ObservableProperty]
+    public partial string SearchText { get; set; } = string.Empty;
+
+    [ObservableProperty]
+    public partial SortOption SelectedSort { get; set; }
+
+    [ObservableProperty]
+    public partial bool IsScanning { get; set; }
+
+    [ObservableProperty]
+    public partial string StatusText { get; set; } = string.Empty;
+
+    [ObservableProperty]
+    public partial double ScanProgress { get; set; }
+
+    [ObservableProperty]
+    public partial bool IsProgressIndeterminate { get; set; }
+
+    /// <summary>True when the library is empty and there is nothing to show but the call to action.</summary>
+    public bool IsEmpty => Videos.Count == 0 && !IsScanning;
+
+    public bool HasFolders => _options.CurrentValue.Folders.Count > 0;
+
+    partial void OnSearchTextChanged(string value) => RebuildView();
+
+    partial void OnSelectedSortChanged(SortOption value) => RebuildView();
+
+    partial void OnIsScanningChanged(bool value) => OnPropertyChanged(nameof(IsEmpty));
+
+    /// <summary>Loads whatever is already in the database, then refreshes it against disk.</summary>
+    [RelayCommand]
+    private async Task InitializeAsync()
+    {
+        try
+        {
+            await using var scope = _scopeFactory.CreateAsyncScope();
+            var library = scope.ServiceProvider.GetRequiredService<ILibraryService>();
+
+            foreach (var item in await library.GetLibraryAsync())
+            {
+                var card = new VideoCardViewModel(item, _shell);
+                _all.Add(card);
+                _byId[card.Id] = card;
+            }
+        }
+        catch (Exception ex)
+        {
+            // An unobserved failure here would tear the process down through the command's
+            // task; the user gets a message instead and can still pick a folder.
+            _logger.LogError(ex, "Could not load the stored library");
+            StatusText = "Не удалось открыть базу библиотеки — подробности в журнале";
+            return;
+        }
+
+        RebuildView();
+
+        if (HasFolders)
+        {
+            await ScanCommand.ExecuteAsync(null);
+        }
+        else
+        {
+            StatusText = "Библиотека пуста — добавьте папку с видео";
+        }
+    }
+
+    [RelayCommand(IncludeCancelCommand = true)]
+    private async Task ScanAsync(CancellationToken cancellationToken)
+    {
+        var folders = _options.CurrentValue.Folders.ToArray();
+
+        if (folders.Length == 0)
+        {
+            StatusText = "Не выбрано ни одной папки";
+            return;
+        }
+
+        IsScanning = true;
+        IsProgressIndeterminate = true;
+        ScanProgress = 0;
+        StatusText = "Поиск файлов…";
+
+        try
+        {
+            // Task.Run detaches the whole pipeline from the UI synchronisation context, so
+            // scanning, probing and database work never touch the render thread. Every event
+            // is marshalled back explicitly.
+            await Task.Run(
+                async () =>
+                {
+                    await using var scope = _scopeFactory.CreateAsyncScope();
+                    var library = scope.ServiceProvider.GetRequiredService<ILibraryService>();
+
+                    await foreach (var scanEvent in library.ScanAsync(folders, cancellationToken))
+                    {
+                        await Dispatcher.UIThread.InvokeAsync(() => Handle(scanEvent));
+                    }
+                },
+                cancellationToken);
+        }
+        catch (OperationCanceledException)
+        {
+            StatusText = "Сканирование отменено";
+        }
+        catch (Exception ex)
+        {
+            _logger.LogError(ex, "Library scan failed");
+            StatusText = "Не удалось просканировать библиотеку — подробности в журнале";
+        }
+        finally
+        {
+            IsScanning = false;
+            IsProgressIndeterminate = false;
+            RebuildView();
+        }
+    }
+
+    [RelayCommand]
+    private async Task AddFolderAsync()
+    {
+        var folder = await _folderPicker.PickFolderAsync("Выберите папку с видео");
+
+        if (folder is null)
+        {
+            return;
+        }
+
+        var folders = _options.CurrentValue.Folders.ToList();
+
+        if (folders.Contains(folder, LibraryPathComparer.Instance))
+        {
+            return;
+        }
+
+        folders.Add(folder);
+        await _settingsStore.SaveFoldersAsync(folders);
+
+        // IOptionsMonitor reloads from the file asynchronously; wait for it so the scan below
+        // sees the folder we just added instead of racing the file watcher.
+        await WaitForFolderAsync(folder);
+
+        OnPropertyChanged(nameof(Folders));
+        OnPropertyChanged(nameof(HasFolders));
+
+        await ScanCommand.ExecuteAsync(null);
+    }
+
+    [RelayCommand]
+    private void ToggleTheme() => _theme.Toggle();
+
+    private async Task WaitForFolderAsync(string folder)
+    {
+        for (var attempt = 0; attempt < 20; attempt++)
+        {
+            if (_options.CurrentValue.Folders.Contains(folder, LibraryPathComparer.Instance))
+            {
+                return;
+            }
+
+            await Task.Delay(50);
+        }
+
+        _logger.LogWarning("Configuration did not pick up the new folder {Folder} in time", folder);
+    }
+
+    private void Handle(LibraryScanEvent scanEvent)
+    {
+        switch (scanEvent)
+        {
+            case LibraryScanEvent.DiscoveryCompleted discovery:
+                StatusText = $"Найдено файлов: {discovery.FilesFound}";
+                break;
+
+            case LibraryScanEvent.ItemAdded added:
+            {
+                var card = new VideoCardViewModel(added.Item, _shell);
+                _all.Add(card);
+                _byId[card.Id] = card;
+                InsertIntoView(card);
+                break;
+            }
+
+            case LibraryScanEvent.ItemUpdated updated
+                when _byId.TryGetValue(updated.Item.Id, out var existing):
+                existing.Apply(updated.Item);
+                break;
+
+            case LibraryScanEvent.ItemRemoved removed
+                when _byId.Remove(removed.Id, out var dropped):
+                _all.Remove(dropped);
+                Videos.Remove(dropped);
+                OnPropertyChanged(nameof(IsEmpty));
+                break;
+
+            case LibraryScanEvent.IndexingProgress progress:
+                IsProgressIndeterminate = false;
+                ScanProgress = progress.Total == 0 ? 100 : progress.Processed * 100.0 / progress.Total;
+                StatusText = $"Обработка превью: {progress.Processed} из {progress.Total}";
+                break;
+
+            case LibraryScanEvent.Completed completed:
+                ScanProgress = 100;
+                StatusText = completed.LibrarySize == 0
+                    ? "В выбранных папках не нашлось видео"
+                    : $"В библиотеке {completed.LibrarySize} видео";
+                break;
+
+            default:
+                break;
+        }
+    }
+
+    private void InsertIntoView(VideoCardViewModel card)
+    {
+        if (!PassesFilter(card))
+        {
+            return;
+        }
+
+        // Appending keeps the grid stable while a scan streams in; the final RebuildView
+        // puts everything in the requested order once the scan settles.
+        Videos.Add(card);
+        OnPropertyChanged(nameof(IsEmpty));
+    }
+
+    private bool PassesFilter(VideoCardViewModel card) =>
+        string.IsNullOrWhiteSpace(SearchText) || card.Matches(SearchText.Trim());
+
+    private void RebuildView()
+    {
+        var visible = _all.Where(PassesFilter);
+
+        visible = SelectedSort.Sort switch
+        {
+            LibrarySort.TitleAscending => visible.OrderBy(x => x.Title, StringComparer.CurrentCultureIgnoreCase),
+            LibrarySort.LongestFirst => visible.OrderByDescending(x => x.RawDuration ?? TimeSpan.Zero),
+            LibrarySort.LargestFirst => visible.OrderByDescending(x => x.RawSizeInBytes),
+            _ => visible.OrderByDescending(x => x.AddedAt),
+        };
+
+        Videos.Clear();
+
+        foreach (var card in visible)
+        {
+            Videos.Add(card);
+        }
+
+        OnPropertyChanged(nameof(IsEmpty));
+    }
+}

src/PLib.Desktop/ViewModels/SortOption.cs

@@ -0,0 +1,21 @@
+namespace PLib.Desktop.ViewModels;
+
+public enum LibrarySort
+{
+    RecentlyAdded,
+    TitleAscending,
+    LongestFirst,
+    LargestFirst,
+}
+
+/// <summary>A sort order together with the label the combo box shows for it.</summary>
+public sealed record SortOption(LibrarySort Sort, string Label)
+{
+    public static IReadOnlyList<SortOption> All { get; } =
+    [
+        new(LibrarySort.RecentlyAdded, "Недавно добавленные"),
+        new(LibrarySort.TitleAscending, "По названию"),
+        new(LibrarySort.LongestFirst, "Сначала длинные"),
+        new(LibrarySort.LargestFirst, "Сначала большие"),
+    ];
+}

src/PLib.Desktop/ViewModels/VideoCardViewModel.cs

@@ -0,0 +1,74 @@
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+using PLib.Desktop.Services;
+using PLib.Domain.Videos;
+
+namespace PLib.Desktop.ViewModels;
+
+/// <summary>One card in the library grid.</summary>
+public sealed partial class VideoCardViewModel : ObservableObject
+{
+    private readonly ISystemShell _shell;
+
+    public VideoCardViewModel(VideoItem item, ISystemShell shell)
+    {
+        _shell = shell;
+        Id = item.Id;
+        FullPath = item.FullPath;
+        Title = item.Title;
+        Apply(item);
+    }
+
+    public Guid Id { get; }
+
+    public string FullPath { get; }
+
+    public DateTimeOffset AddedAt { get; private set; }
+
+    public TimeSpan? RawDuration { get; private set; }
+
+    public long RawSizeInBytes { get; private set; }
+
+    [ObservableProperty]
+    public partial string Title { get; set; }
+
+    [ObservableProperty]
+    public partial string? ThumbnailPath { get; set; }
+
+    [ObservableProperty]
+    public partial string DurationText { get; set; } = "—";
+
+    [ObservableProperty]
+    public partial string SizeText { get; set; } = string.Empty;
+
+    [ObservableProperty]
+    public partial string? QualityText { get; set; }
+
+    /// <summary>True while the poster frame has not been produced yet.</summary>
+    [ObservableProperty]
+    public partial bool IsPending { get; set; } = true;
+
+    /// <summary>Copies the current state of the entity into the card.</summary>
+    public void Apply(VideoItem item)
+    {
+        Title = item.Title;
+        ThumbnailPath = item.ThumbnailPath;
+        DurationText = DisplayText.Duration(item.Duration);
+        SizeText = DisplayText.FileSize(item.SizeInBytes);
+        QualityText = DisplayText.Quality(item.Width, item.Height);
+        AddedAt = item.AddedAt;
+        RawDuration = item.Duration;
+        RawSizeInBytes = item.SizeInBytes;
+        IsPending = item.ThumbnailPath is null;
+    }
+
+    [RelayCommand]
+    private void Play() => _shell.OpenFile(FullPath);
+
+    [RelayCommand]
+    private void Reveal() => _shell.RevealInFileManager(FullPath);
+
+    public bool Matches(string term) =>
+        Title.Contains(term, StringComparison.CurrentCultureIgnoreCase) ||
+        FullPath.Contains(term, StringComparison.CurrentCultureIgnoreCase);
+}

src/PLib.Desktop/Views/MainWindow.axaml

@@ -0,0 +1,234 @@
+<Window xmlns="https://github.com/avaloniaui"
+        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+        xmlns:controls="clr-namespace:PLib.Desktop.Controls"
+        xmlns:icons="clr-namespace:Material.Icons.Avalonia;assembly=Material.Icons.Avalonia"
+        xmlns:vm="clr-namespace:PLib.Desktop.ViewModels"
+        x:Class="PLib.Desktop.Views.MainWindow"
+        x:DataType="vm:MainWindowViewModel"
+        Title="PLib — видеотека"
+        Width="1180"
+        Height="760"
+        MinWidth="640"
+        MinHeight="420"
+        Background="{DynamicResource PageBackgroundBrush}"
+        WindowStartupLocation="CenterScreen">
+
+  <Window.Resources>
+
+    <!-- ======================= Video card ======================= -->
+    <DataTemplate x:Key="VideoCardTemplate" DataType="vm:VideoCardViewModel">
+      <Button Classes="card" Command="{Binding PlayCommand}" ToolTip.Tip="{Binding FullPath}">
+
+        <Button.ContextMenu>
+          <ContextMenu>
+            <MenuItem Header="Воспроизвести" Command="{Binding PlayCommand}" />
+            <MenuItem Header="Показать в папке" Command="{Binding RevealCommand}" />
+          </ContextMenu>
+        </Button.ContextMenu>
+
+        <Grid RowDefinitions="*,Auto">
+
+          <!-- Poster frame -->
+          <Border Grid.Row="0"
+                  CornerRadius="9"
+                  ClipToBounds="True"
+                  Background="{DynamicResource ThumbnailPlaceholderBrush}">
+            <Panel>
+              <controls:AsyncImage Source="{Binding ThumbnailPath}"
+                                   DecodeWidth="480"
+                                   PlaceholderBrush="{DynamicResource ThumbnailPlaceholderBrush}" />
+
+              <!-- Shown until ffmpeg has produced a frame for this file. -->
+              <icons:MaterialIcon Kind="FilmstripBoxMultiple"
+                                  Width="30"
+                                  Height="30"
+                                  Opacity="0.35"
+                                  Foreground="{DynamicResource TextTertiaryBrush}"
+                                  HorizontalAlignment="Center"
+                                  VerticalAlignment="Center"
+                                  IsVisible="{Binding IsPending}" />
+
+              <Border Classes="badge"
+                      Margin="8"
+                      HorizontalAlignment="Left"
+                      VerticalAlignment="Top"
+                      IsVisible="{Binding QualityText, Converter={x:Static ObjectConverters.IsNotNull}}">
+                <TextBlock Text="{Binding QualityText}" />
+              </Border>
+
+              <Border Classes="badge"
+                      Margin="8"
+                      HorizontalAlignment="Right"
+                      VerticalAlignment="Bottom">
+                <TextBlock Text="{Binding DurationText}" />
+              </Border>
+
+              <Border Classes="playOverlay" Background="{DynamicResource OverlayBrush}">
+                <Border Width="46"
+                        Height="46"
+                        CornerRadius="23"
+                        Background="{DynamicResource AccentBrush}"
+                        HorizontalAlignment="Center"
+                        VerticalAlignment="Center">
+                  <icons:MaterialIcon Kind="Play" Width="24" Height="24" Foreground="White" />
+                </Border>
+              </Border>
+            </Panel>
+          </Border>
+
+          <!-- Caption -->
+          <StackPanel Grid.Row="1" Margin="4,10,4,2" Spacing="3">
+            <TextBlock Classes="cardTitle" Text="{Binding Title}" />
+            <StackPanel Orientation="Horizontal" Spacing="6">
+              <TextBlock Classes="cardMeta" Text="{Binding SizeText}" />
+            </StackPanel>
+          </StackPanel>
+
+        </Grid>
+      </Button>
+    </DataTemplate>
+
+  </Window.Resources>
+
+  <Grid RowDefinitions="Auto,*,Auto">
+
+    <!-- ======================= Header ======================= -->
+    <Border Grid.Row="0"
+            Background="{DynamicResource SurfaceBrush}"
+            BorderBrush="{DynamicResource SurfaceBorderBrush}"
+            BorderThickness="0,0,0,1"
+            Padding="20,14">
+      <Grid ColumnDefinitions="Auto,*,Auto" ColumnSpacing="20">
+
+        <StackPanel Grid.Column="0" Orientation="Horizontal" Spacing="10" VerticalAlignment="Center">
+          <Border Width="34"
+                  Height="34"
+                  CornerRadius="9"
+                  Background="{DynamicResource AccentSoftBrush}">
+            <icons:MaterialIcon Kind="VideoVintage"
+                                Width="19"
+                                Height="19"
+                                Foreground="{DynamicResource AccentBrush}" />
+          </Border>
+          <StackPanel VerticalAlignment="Center">
+            <TextBlock Classes="sectionTitle" Text="Видеотека" />
+            <TextBlock Classes="cardMeta" Text="{Binding Videos.Count, StringFormat='{}{0} видео'}" />
+          </StackPanel>
+        </StackPanel>
+
+        <TextBox Grid.Column="1"
+                 MaxWidth="420"
+                 HorizontalAlignment="Stretch"
+                 VerticalAlignment="Center"
+                 PlaceholderText="Поиск по названию…"
+                 Text="{Binding SearchText}" />
+
+        <StackPanel Grid.Column="2" Orientation="Horizontal" Spacing="8" VerticalAlignment="Center">
+
+          <ComboBox MinWidth="180"
+                    ItemsSource="{Binding SortOptions}"
+                    SelectedItem="{Binding SelectedSort}">
+            <ComboBox.ItemTemplate>
+              <DataTemplate x:DataType="vm:SortOption">
+                <TextBlock Text="{Binding Label}" />
+              </DataTemplate>
+            </ComboBox.ItemTemplate>
+          </ComboBox>
+
+          <Button Command="{Binding ScanCommand}"
+                  IsEnabled="{Binding !IsScanning}"
+                  ToolTip.Tip="Пересканировать библиотеку">
+            <icons:MaterialIcon Kind="Refresh" Width="17" Height="17" />
+          </Button>
+
+          <Button Command="{Binding ToggleThemeCommand}" ToolTip.Tip="Сменить тему">
+            <icons:MaterialIcon Kind="ThemeLightDark" Width="17" Height="17" />
+          </Button>
+
+          <Button Classes="Primary" Command="{Binding AddFolderCommand}">
+            <StackPanel Orientation="Horizontal" Spacing="7">
+              <icons:MaterialIcon Kind="FolderPlusOutline" Width="17" Height="17" />
+              <TextBlock Text="Добавить папку" />
+            </StackPanel>
+          </Button>
+
+        </StackPanel>
+      </Grid>
+    </Border>
+
+    <!-- ======================= Grid ======================= -->
+    <Panel Grid.Row="1">
+
+      <ScrollViewer Padding="20,18" HorizontalScrollBarVisibility="Disabled">
+        <ItemsRepeater ItemsSource="{Binding Videos}" ItemTemplate="{StaticResource VideoCardTemplate}">
+          <ItemsRepeater.Layout>
+            <UniformGridLayout ItemsStretch="Fill"
+                               MinItemWidth="230"
+                               MinItemHeight="212"
+                               MinColumnSpacing="16"
+                               MinRowSpacing="16" />
+          </ItemsRepeater.Layout>
+        </ItemsRepeater>
+      </ScrollViewer>
+
+      <!-- Empty state -->
+      <StackPanel HorizontalAlignment="Center"
+                  VerticalAlignment="Center"
+                  Spacing="14"
+                  MaxWidth="420"
+                  IsVisible="{Binding IsEmpty}">
+        <icons:MaterialIcon Kind="VideoBoxOff"
+                            Width="52"
+                            Height="52"
+                            Opacity="0.35"
+                            Foreground="{DynamicResource TextTertiaryBrush}"
+                            HorizontalAlignment="Center" />
+        <TextBlock Classes="sectionTitle"
+                   HorizontalAlignment="Center"
+                   Text="Здесь пока пусто" />
+        <TextBlock Classes="subtle"
+                   HorizontalAlignment="Center"
+                   TextAlignment="Center"
+                   TextWrapping="Wrap"
+                   Text="Укажите папку с видеофайлами — PLib пройдётся по ней, соберёт превью и покажет всё карточками." />
+        <Button Classes="Primary"
+                HorizontalAlignment="Center"
+                Command="{Binding AddFolderCommand}"
+                Content="Выбрать папку" />
+      </StackPanel>
+
+    </Panel>
+
+    <!-- ======================= Status bar ======================= -->
+    <Border Grid.Row="2"
+            Background="{DynamicResource SurfaceBrush}"
+            BorderBrush="{DynamicResource SurfaceBorderBrush}"
+            BorderThickness="0,1,0,0"
+            Padding="20,9">
+      <Grid ColumnDefinitions="Auto,*,Auto" ColumnSpacing="14">
+
+        <ProgressBar Grid.Column="0"
+                     Width="160"
+                     VerticalAlignment="Center"
+                     Minimum="0"
+                     Maximum="100"
+                     Value="{Binding ScanProgress}"
+                     IsIndeterminate="{Binding IsProgressIndeterminate}"
+                     IsVisible="{Binding IsScanning}" />
+
+        <TextBlock Grid.Column="1"
+                   Classes="subtle"
+                   VerticalAlignment="Center"
+                   TextTrimming="CharacterEllipsis"
+                   Text="{Binding StatusText}" />
+
+        <Button Grid.Column="2"
+                Content="Отмена"
+                Command="{Binding ScanCancelCommand}"
+                IsVisible="{Binding IsScanning}" />
+
+      </Grid>
+    </Border>
+
+  </Grid>
+</Window>

src/PLib.Desktop/Views/MainWindow.axaml.cs

@@ -0,0 +1,8 @@
+using Avalonia.Controls;
+
+namespace PLib.Desktop.Views;
+
+public sealed partial class MainWindow : Window
+{
+    public MainWindow() => InitializeComponent();
+}

src/PLib.Desktop/app.manifest

@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="utf-8"?>
+<assembly manifestVersion="1.0" xmlns="urn:schemas-microsoft-com:asm.v1">
+  <assemblyIdentity version="0.1.0.0" name="PLib.Desktop" />
+
+  <application xmlns="urn:schemas-microsoft-com:asm.v3">
+    <windowsSettings>
+      <dpiAware xmlns="http://schemas.microsoft.com/SMI/2005/WindowsSettings">true/pm</dpiAware>
+      <dpiAwareness xmlns="http://schemas.microsoft.com/SMI/2016/WindowsSettings">permonitorv2</dpiAwareness>
+    </windowsSettings>
+  </application>
+
+  <compatibility xmlns="urn:schemas-microsoft-com:compatibility.v1">
+    <application>
+      <!-- Windows 10 / 11 -->
+      <supportedOS Id="{8e0f7a12-bfb3-4fe8-b9a5-48fd50a15a9a}" />
+    </application>
+  </compatibility>
+</assembly>

src/PLib.Desktop/appsettings.json

@@ -0,0 +1,9 @@
+{
+  "Library": {
+    "Folders": [],
+    "ThumbnailWidth": 480,
+    "ThumbnailPositionRatio": 0.15,
+    "MaxIndexingConcurrency": 4,
+    "MinimumFileSizeInBytes": 65536
+  }
+}

src/PLib.Domain/PLib.Domain.csproj

@@ -0,0 +1,7 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <RootNamespace>PLib.Domain</RootNamespace>
+  </PropertyGroup>
+
+</Project>

src/PLib.Domain/Videos/VideoItem.cs

@@ -0,0 +1,103 @@
+namespace PLib.Domain.Videos;
+
+/// <summary>
+/// A single video file that belongs to the library.
+/// </summary>
+/// <remarks>
+/// The absolute path is the natural identity of a video: the library is a view over the
+/// file system, so two entries pointing at the same path are the same video. Mutation goes
+/// through explicit methods so that the entity can never end up half-updated.
+/// </remarks>
+public sealed class VideoItem
+{
+    /// <summary>Required by EF Core materialization; do not use from application code.</summary>
+    private VideoItem()
+    {
+        FullPath = null!;
+        Title = null!;
+    }
+
+    public VideoItem(string fullPath, string title, long sizeInBytes, DateTimeOffset fileModifiedAt)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(fullPath);
+        ArgumentException.ThrowIfNullOrWhiteSpace(title);
+        ArgumentOutOfRangeException.ThrowIfNegative(sizeInBytes);
+
+        Id = Guid.CreateVersion7();
+        FullPath = fullPath;
+        Title = title;
+        SizeInBytes = sizeInBytes;
+        FileModifiedAt = fileModifiedAt;
+        AddedAt = DateTimeOffset.UtcNow;
+    }
+
+    public Guid Id { get; private set; }
+
+    /// <summary>Absolute path of the file on disk. Unique within the library.</summary>
+    public string FullPath { get; private set; }
+
+    /// <summary>Human readable name; defaults to the file name without extension.</summary>
+    public string Title { get; private set; }
+
+    public long SizeInBytes { get; private set; }
+
+    public TimeSpan? Duration { get; private set; }
+
+    public int? Width { get; private set; }
+
+    public int? Height { get; private set; }
+
+    public string? VideoCodec { get; private set; }
+
+    /// <summary>Absolute path of the generated poster frame, or <c>null</c> if none exists yet.</summary>
+    public string? ThumbnailPath { get; private set; }
+
+    /// <summary>Last write time of the file when it was last indexed.</summary>
+    public DateTimeOffset FileModifiedAt { get; private set; }
+
+    public DateTimeOffset AddedAt { get; private set; }
+
+    /// <summary>True once the file has been probed and a poster frame produced.</summary>
+    public bool IsIndexed => Duration is not null && ThumbnailPath is not null;
+
+    public void Rename(string title)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(title);
+        Title = title;
+    }
+
+    public void ApplyTechnicalInfo(VideoTechnicalInfo info)
+    {
+        Duration = info.Duration;
+        Width = info.Width;
+        Height = info.Height;
+        VideoCodec = info.VideoCodec;
+    }
+
+    public void AttachThumbnail(string thumbnailPath)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(thumbnailPath);
+        ThumbnailPath = thumbnailPath;
+    }
+
+    public void DetachThumbnail() => ThumbnailPath = null;
+
+    /// <summary>
+    /// Refreshes the file system facts after the file changed on disk, and invalidates
+    /// everything that was derived from the previous revision of the file.
+    /// </summary>
+    public void RefreshFileFacts(long sizeInBytes, DateTimeOffset fileModifiedAt)
+    {
+        ArgumentOutOfRangeException.ThrowIfNegative(sizeInBytes);
+
+        if (SizeInBytes == sizeInBytes && FileModifiedAt == fileModifiedAt)
+        {
+            return;
+        }
+
+        SizeInBytes = sizeInBytes;
+        FileModifiedAt = fileModifiedAt;
+        ApplyTechnicalInfo(VideoTechnicalInfo.Unknown);
+        DetachThumbnail();
+    }
+}

src/PLib.Domain/Videos/VideoTechnicalInfo.cs

@@ -0,0 +1,18 @@
+namespace PLib.Domain.Videos;
+
+/// <summary>
+/// Technical facts about a media file that are discovered by probing it,
+/// as opposed to facts we already know from the file system entry itself.
+/// </summary>
+/// <param name="Duration">Playback duration, or <c>null</c> if the container did not report one.</param>
+/// <param name="Width">Width of the primary video stream in pixels.</param>
+/// <param name="Height">Height of the primary video stream in pixels.</param>
+/// <param name="VideoCodec">Short codec name of the primary video stream, e.g. <c>h264</c>.</param>
+public readonly record struct VideoTechnicalInfo(
+    TimeSpan? Duration,
+    int? Width,
+    int? Height,
+    string? VideoCodec)
+{
+    public static VideoTechnicalInfo Unknown => default;
+}

src/PLib.Infrastructure/DependencyInjection.cs

@@ -0,0 +1,48 @@
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.DependencyInjection.Extensions;
+using PLib.Application.Abstractions;
+using PLib.Application.Library;
+using PLib.Infrastructure.Media;
+using PLib.Infrastructure.Persistence;
+using PLib.Infrastructure.Storage;
+
+namespace PLib.Infrastructure;
+
+public static class DependencyInjection
+{
+    /// <summary>
+    /// Registers everything the application layer declares as an abstraction. The composition
+    /// root (the UI project) never sees EF Core or ffmpeg types directly.
+    /// </summary>
+    public static IServiceCollection AddPLibInfrastructure(
+        this IServiceCollection services,
+        IConfiguration configuration)
+    {
+        services.AddOptions<LibraryOptions>()
+            .Bind(configuration.GetSection(LibraryOptions.SectionName))
+            .ValidateDataAnnotations()
+            .ValidateOnStart();
+
+        // TryAdd so a composition root that already needed the paths (to locate the user
+        // settings file before the container exists) can share its own instance.
+        services.TryAddSingleton<IAppPaths, AppPaths>();
+
+        services.AddDbContext<LibraryDbContext>((provider, builder) =>
+        {
+            var paths = provider.GetRequiredService<IAppPaths>();
+            builder.UseSqlite($"Data Source={paths.DatabaseFile}");
+        });
+
+        services.AddScoped<IVideoRepository, EfVideoRepository>();
+        services.AddSingleton<IVideoFileScanner, FileSystemVideoScanner>();
+        services.AddSingleton<IMediaProbe, FfmpegMediaProbe>();
+        services.AddSingleton<IThumbnailGenerator, FfmpegThumbnailGenerator>();
+        services.AddScoped<ILibraryService, LibraryService>();
+
+        services.AddHostedService<DatabaseInitializer>();
+
+        return services;
+    }
+}

src/PLib.Infrastructure/Media/FfmpegMediaProbe.cs

@@ -0,0 +1,35 @@
+using FFMpegCore;
+using Microsoft.Extensions.Logging;
+using PLib.Application.Abstractions;
+using PLib.Domain.Videos;
+
+namespace PLib.Infrastructure.Media;
+
+/// <inheritdoc cref="IMediaProbe"/>
+public sealed class FfmpegMediaProbe(ILogger<FfmpegMediaProbe> logger) : IMediaProbe
+{
+    public async Task<VideoTechnicalInfo> ProbeAsync(string fullPath, CancellationToken cancellationToken = default)
+    {
+        try
+        {
+            var analysis = await FFProbe.AnalyseAsync(fullPath, cancellationToken: cancellationToken);
+            var video = analysis.PrimaryVideoStream;
+
+            return new VideoTechnicalInfo(
+                analysis.Duration > TimeSpan.Zero ? analysis.Duration : null,
+                video?.Width,
+                video?.Height,
+                video?.CodecName);
+        }
+        catch (OperationCanceledException)
+        {
+            throw;
+        }
+        catch (Exception ex)
+        {
+            // A single unreadable file must not abort the scan.
+            logger.LogWarning(ex, "Could not probe {Path}", fullPath);
+            return VideoTechnicalInfo.Unknown;
+        }
+    }
+}

src/PLib.Infrastructure/Media/FfmpegThumbnailGenerator.cs

@@ -0,0 +1,111 @@
+using System.Security.Cryptography;
+using System.Text;
+using FFMpegCore;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
+using PLib.Application.Abstractions;
+using PLib.Application.Library;
+using PLib.Infrastructure.Storage;
+
+namespace PLib.Infrastructure.Media;
+
+/// <inheritdoc cref="IThumbnailGenerator"/>
+public sealed class FfmpegThumbnailGenerator(
+    IAppPaths paths,
+    IOptions<LibraryOptions> options,
+    ILogger<FfmpegThumbnailGenerator> logger) : IThumbnailGenerator
+{
+    /// <summary>Fallback capture position for files whose duration we could not read.</summary>
+    private static readonly TimeSpan BlindCapturePosition = TimeSpan.FromSeconds(5);
+
+    private readonly LibraryOptions _options = options.Value;
+
+    public async Task<string?> GetOrCreateAsync(
+        string videoPath,
+        TimeSpan? duration,
+        CancellationToken cancellationToken = default)
+    {
+        var file = new FileInfo(videoPath);
+
+        if (!file.Exists)
+        {
+            return null;
+        }
+
+        var target = Path.Combine(paths.ThumbnailDirectory, $"{BuildCacheKey(file)}.jpg");
+
+        if (File.Exists(target))
+        {
+            return target;
+        }
+
+        // Render to a private temp file first so a crash or cancellation can never leave a
+        // truncated JPEG behind that later runs would happily treat as a valid cache hit.
+        var staging = Path.Combine(paths.ThumbnailDirectory, $"{Guid.CreateVersion7()}.tmp");
+
+        try
+        {
+            var succeeded = await RenderAsync(videoPath, staging, CapturePositionFor(duration), cancellationToken);
+
+            if (!succeeded)
+            {
+                return null;
+            }
+
+            File.Move(staging, target, overwrite: true);
+            return target;
+        }
+        catch (OperationCanceledException)
+        {
+            throw;
+        }
+        catch (Exception ex)
+        {
+            logger.LogWarning(ex, "Could not create a thumbnail for {Path}", videoPath);
+            return null;
+        }
+        finally
+        {
+            if (File.Exists(staging))
+            {
+                File.Delete(staging);
+            }
+        }
+    }
+
+    private async Task<bool> RenderAsync(
+        string videoPath,
+        string outputPath,
+        TimeSpan capturePosition,
+        CancellationToken cancellationToken)
+    {
+        // Seeking on the input (rather than the output) makes ffmpeg jump straight to the
+        // keyframe instead of decoding everything before it — orders of magnitude faster.
+        // Height -2 lets ffmpeg keep the aspect ratio while staying encoder friendly.
+        return await FFMpegArguments
+            .FromFileInput(videoPath, verifyExists: true, input => input.Seek(capturePosition))
+            .OutputToFile(outputPath, overwrite: true, output => output
+                .WithVideoFilters(filter => filter.Scale(_options.ThumbnailWidth, -2))
+                .WithFrameOutputCount(1)
+                .WithCustomArgument("-q:v 3")
+                .ForceFormat("image2"))
+            .CancellableThrough(cancellationToken)
+            .ProcessAsynchronously(throwOnError: false);
+    }
+
+    private TimeSpan CapturePositionFor(TimeSpan? duration) =>
+        duration is { } value && value > TimeSpan.Zero
+            ? value * _options.ThumbnailPositionRatio
+            : BlindCapturePosition;
+
+    /// <summary>
+    /// Keys the cache by path plus size plus timestamp, so replacing a file on disk
+    /// naturally produces a different key rather than a stale poster frame.
+    /// </summary>
+    private static string BuildCacheKey(FileInfo file)
+    {
+        var seed = $"{file.FullName}|{file.Length}|{file.LastWriteTimeUtc.Ticks}";
+        var hash = SHA256.HashData(Encoding.UTF8.GetBytes(seed));
+        return Convert.ToHexStringLower(hash)[..32];
+    }
+}

src/PLib.Infrastructure/Media/FileSystemVideoScanner.cs

@@ -0,0 +1,52 @@
+using System.Runtime.CompilerServices;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
+using PLib.Application.Abstractions;
+using PLib.Application.Library;
+
+namespace PLib.Infrastructure.Media;
+
+/// <inheritdoc cref="IVideoFileScanner"/>
+public sealed class FileSystemVideoScanner(
+    IOptions<LibraryOptions> options,
+    ILogger<FileSystemVideoScanner> logger) : IVideoFileScanner
+{
+    private readonly HashSet<string> _extensions =
+        new(options.Value.VideoExtensions, StringComparer.OrdinalIgnoreCase);
+
+    public async IAsyncEnumerable<DiscoveredVideoFile> ScanAsync(
+        string rootFolder,
+        [EnumeratorCancellation] CancellationToken cancellationToken = default)
+    {
+        // Walking a large tree blocks; hand the caller back its thread before we start.
+        await Task.Yield();
+
+        if (!Directory.Exists(rootFolder))
+        {
+            logger.LogWarning("Library folder {Folder} does not exist and was skipped", rootFolder);
+            yield break;
+        }
+
+        // IgnoreInaccessible keeps a single protected subfolder from aborting the whole walk.
+        var enumerationOptions = new EnumerationOptions
+        {
+            RecurseSubdirectories = true,
+            IgnoreInaccessible = true,
+            AttributesToSkip = FileAttributes.Hidden | FileAttributes.System,
+        };
+
+        // Enumerating FileInfo (rather than paths) reuses the metadata the OS already
+        // returned for each directory entry, so size and timestamp cost no extra syscall.
+        foreach (var file in new DirectoryInfo(rootFolder).EnumerateFiles("*", enumerationOptions))
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+
+            if (!_extensions.Contains(file.Extension))
+            {
+                continue;
+            }
+
+            yield return new DiscoveredVideoFile(file.FullName, file.Length, file.LastWriteTimeUtc);
+        }
+    }
+}

src/PLib.Infrastructure/PLib.Infrastructure.csproj

@@ -0,0 +1,18 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <RootNamespace>PLib.Infrastructure</RootNamespace>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="FFMpegCore" />
+    <PackageReference Include="Microsoft.EntityFrameworkCore.Sqlite" />
+    <PackageReference Include="Microsoft.Extensions.Options.DataAnnotations" />
+    <PackageReference Include="Microsoft.Extensions.Hosting" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\PLib.Application\PLib.Application.csproj" />
+  </ItemGroup>
+
+</Project>

src/PLib.Infrastructure/Persistence/DatabaseInitializer.cs

@@ -0,0 +1,29 @@
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
+
+namespace PLib.Infrastructure.Persistence;
+
+/// <summary>
+/// Brings the local database up to date before the first window is shown.
+/// </summary>
+/// <remarks>
+/// While the schema is still moving we create it from the model. Once the shape settles this
+/// becomes <c>MigrateAsync</c> plus a checked-in migration history.
+/// </remarks>
+public sealed class DatabaseInitializer(
+    IServiceScopeFactory scopeFactory,
+    ILogger<DatabaseInitializer> logger) : IHostedService
+{
+    public async Task StartAsync(CancellationToken cancellationToken)
+    {
+        await using var scope = scopeFactory.CreateAsyncScope();
+        var dbContext = scope.ServiceProvider.GetRequiredService<LibraryDbContext>();
+
+        var created = await dbContext.Database.EnsureCreatedAsync(cancellationToken);
+        logger.LogInformation("Library database ready (created: {Created})", created);
+    }
+
+    public Task StopAsync(CancellationToken cancellationToken) => Task.CompletedTask;
+}

src/PLib.Infrastructure/Persistence/EfVideoRepository.cs

@@ -0,0 +1,29 @@
+using Microsoft.EntityFrameworkCore;
+using PLib.Application.Abstractions;
+using PLib.Domain.Videos;
+
+namespace PLib.Infrastructure.Persistence;
+
+/// <inheritdoc cref="IVideoRepository"/>
+public sealed class EfVideoRepository(LibraryDbContext dbContext) : IVideoRepository
+{
+    public async Task<IReadOnlyList<VideoItem>> GetAllAsync(CancellationToken cancellationToken = default) =>
+        await dbContext.Videos
+            .OrderByDescending(x => x.AddedAt)
+            .ToListAsync(cancellationToken);
+
+    public Task<VideoItem?> FindByPathAsync(string fullPath, CancellationToken cancellationToken = default) =>
+        dbContext.Videos.FirstOrDefaultAsync(x => x.FullPath == fullPath, cancellationToken);
+
+    public async Task AddAsync(VideoItem item, CancellationToken cancellationToken = default) =>
+        await dbContext.Videos.AddAsync(item, cancellationToken);
+
+    public Task RemoveAsync(VideoItem item, CancellationToken cancellationToken = default)
+    {
+        dbContext.Videos.Remove(item);
+        return Task.CompletedTask;
+    }
+
+    public Task SaveChangesAsync(CancellationToken cancellationToken = default) =>
+        dbContext.SaveChangesAsync(cancellationToken);
+}

src/PLib.Infrastructure/Persistence/LibraryDbContext.cs

@@ -0,0 +1,15 @@
+using Microsoft.EntityFrameworkCore;
+using PLib.Domain.Videos;
+
+namespace PLib.Infrastructure.Persistence;
+
+public sealed class LibraryDbContext(DbContextOptions<LibraryDbContext> options) : DbContext(options)
+{
+    public DbSet<VideoItem> Videos => Set<VideoItem>();
+
+    protected override void OnModelCreating(ModelBuilder modelBuilder)
+    {
+        modelBuilder.ApplyConfigurationsFromAssembly(typeof(LibraryDbContext).Assembly);
+        base.OnModelCreating(modelBuilder);
+    }
+}

src/PLib.Infrastructure/Persistence/VideoItemConfiguration.cs

@@ -0,0 +1,51 @@
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using PLib.Domain.Videos;
+
+namespace PLib.Infrastructure.Persistence;
+
+internal sealed class VideoItemConfiguration : IEntityTypeConfiguration<VideoItem>
+{
+    /// <summary>
+    /// SQLite refuses to ORDER BY a DateTimeOffset because its default TEXT representation
+    /// carries an offset and therefore does not sort chronologically. Storing UTC ticks keeps
+    /// the column both sortable and indexable.
+    /// </summary>
+    private static readonly ValueConverter<DateTimeOffset, long> UtcTicksConverter = new(
+        value => value.UtcTicks,
+        ticks => new DateTimeOffset(ticks, TimeSpan.Zero));
+
+    public void Configure(EntityTypeBuilder<VideoItem> builder)
+    {
+        builder.ToTable("Videos");
+
+        builder.HasKey(x => x.Id);
+
+        builder.Property(x => x.AddedAt).HasConversion(UtcTicksConverter);
+        builder.Property(x => x.FileModifiedAt).HasConversion(UtcTicksConverter);
+
+        builder.Property(x => x.FullPath)
+            .IsRequired()
+            .HasMaxLength(1024);
+
+        builder.HasIndex(x => x.FullPath)
+            .IsUnique();
+
+        builder.Property(x => x.Title)
+            .IsRequired()
+            .HasMaxLength(512);
+
+        builder.Property(x => x.VideoCodec)
+            .HasMaxLength(64);
+
+        builder.Property(x => x.ThumbnailPath)
+            .HasMaxLength(1024);
+
+        // Sorting the grid by "recently added" is the default view, so it gets an index.
+        builder.HasIndex(x => x.AddedAt);
+
+        // IsIndexed is derived from other columns and must not become a table column.
+        builder.Ignore(x => x.IsIndexed);
+    }
+}

src/PLib.Infrastructure/Storage/AppPaths.cs

@@ -0,0 +1,25 @@
+namespace PLib.Infrastructure.Storage;
+
+/// <inheritdoc cref="IAppPaths"/>
+public sealed class AppPaths : IAppPaths
+{
+    public AppPaths()
+    {
+        var localAppData = Environment.GetFolderPath(
+            Environment.SpecialFolder.LocalApplicationData,
+            Environment.SpecialFolderOption.Create);
+
+        DataDirectory = Path.Combine(localAppData, "PLib");
+        ThumbnailDirectory = Path.Combine(DataDirectory, "thumbnails");
+        DatabaseFile = Path.Combine(DataDirectory, "library.db");
+
+        Directory.CreateDirectory(DataDirectory);
+        Directory.CreateDirectory(ThumbnailDirectory);
+    }
+
+    public string DataDirectory { get; }
+
+    public string ThumbnailDirectory { get; }
+
+    public string DatabaseFile { get; }
+}

src/PLib.Infrastructure/Storage/IAppPaths.cs

@@ -0,0 +1,14 @@
+namespace PLib.Infrastructure.Storage;
+
+/// <summary>Where the application keeps the data it owns on the local machine.</summary>
+public interface IAppPaths
+{
+    /// <summary>Root of the per-user data directory; created on first access.</summary>
+    string DataDirectory { get; }
+
+    /// <summary>Directory holding cached poster frames.</summary>
+    string ThumbnailDirectory { get; }
+
+    /// <summary>Full path of the SQLite database file.</summary>
+    string DatabaseFile { get; }
+}

tests/PLib.Tests/Domain/VideoItemTests.cs

@@ -0,0 +1,64 @@
+using PLib.Domain.Videos;
+using Shouldly;
+
+namespace PLib.Tests.Domain;
+
+public sealed class VideoItemTests
+{
+    private static VideoItem CreateIndexedItem()
+    {
+        var item = new VideoItem(@"C:\videos\clip.mp4", "clip", 1_000, DateTimeOffset.UnixEpoch);
+        item.ApplyTechnicalInfo(new VideoTechnicalInfo(TimeSpan.FromMinutes(3), 1920, 1080, "h264"));
+        item.AttachThumbnail(@"C:\cache\clip.jpg");
+        return item;
+    }
+
+    [Fact]
+    public void An_item_is_indexed_only_once_it_has_both_a_duration_and_a_thumbnail()
+    {
+        var item = new VideoItem(@"C:\videos\clip.mp4", "clip", 1_000, DateTimeOffset.UnixEpoch);
+        item.IsIndexed.ShouldBeFalse();
+
+        item.ApplyTechnicalInfo(new VideoTechnicalInfo(TimeSpan.FromMinutes(1), 1280, 720, "h264"));
+        item.IsIndexed.ShouldBeFalse();
+
+        item.AttachThumbnail(@"C:\cache\clip.jpg");
+        item.IsIndexed.ShouldBeTrue();
+    }
+
+    [Fact]
+    public void Refreshing_an_unchanged_file_keeps_everything_that_was_derived_from_it()
+    {
+        var item = CreateIndexedItem();
+
+        item.RefreshFileFacts(1_000, DateTimeOffset.UnixEpoch);
+
+        item.IsIndexed.ShouldBeTrue();
+        item.ThumbnailPath.ShouldNotBeNull();
+    }
+
+    [Fact]
+    public void Refreshing_a_changed_file_invalidates_the_metadata_and_the_thumbnail()
+    {
+        var item = CreateIndexedItem();
+
+        item.RefreshFileFacts(2_000, DateTimeOffset.UnixEpoch.AddDays(1));
+
+        item.SizeInBytes.ShouldBe(2_000);
+        item.Duration.ShouldBeNull();
+        item.ThumbnailPath.ShouldBeNull();
+        item.IsIndexed.ShouldBeFalse();
+    }
+
+    [Theory]
+    [InlineData("", "title")]
+    [InlineData("   ", "title")]
+    [InlineData(@"C:\videos\clip.mp4", "")]
+    public void An_item_cannot_be_created_without_a_path_and_a_title(string path, string title) =>
+        Should.Throw<ArgumentException>(() => new VideoItem(path, title, 1, DateTimeOffset.UnixEpoch));
+
+    [Fact]
+    public void An_item_cannot_have_a_negative_size() =>
+        Should.Throw<ArgumentOutOfRangeException>(
+            () => new VideoItem(@"C:\videos\clip.mp4", "clip", -1, DateTimeOffset.UnixEpoch));
+}

tests/PLib.Tests/GlobalUsings.cs

@@ -0,0 +1 @@
+global using Xunit;

tests/PLib.Tests/Library/InMemoryVideoRepository.cs

@@ -0,0 +1,50 @@
+using PLib.Application.Abstractions;
+using PLib.Application.Library;
+using PLib.Domain.Videos;
+
+namespace PLib.Tests.Library;
+
+/// <summary>
+/// A hand-written double rather than a mock: the scan logic is all about what ends up in the
+/// repository, so the tests read better when they can just look at the resulting list.
+/// </summary>
+internal sealed class InMemoryVideoRepository : IVideoRepository
+{
+    private readonly Dictionary<string, VideoItem> _items = new(LibraryPathComparer.Instance);
+
+    public int SaveCount { get; private set; }
+
+    public IReadOnlyCollection<VideoItem> Items => _items.Values;
+
+    public void Seed(params VideoItem[] items)
+    {
+        foreach (var item in items)
+        {
+            _items[item.FullPath] = item;
+        }
+    }
+
+    public Task<IReadOnlyList<VideoItem>> GetAllAsync(CancellationToken cancellationToken = default) =>
+        Task.FromResult<IReadOnlyList<VideoItem>>([.. _items.Values]);
+
+    public Task<VideoItem?> FindByPathAsync(string fullPath, CancellationToken cancellationToken = default) =>
+        Task.FromResult(_items.GetValueOrDefault(fullPath));
+
+    public Task AddAsync(VideoItem item, CancellationToken cancellationToken = default)
+    {
+        _items[item.FullPath] = item;
+        return Task.CompletedTask;
+    }
+
+    public Task RemoveAsync(VideoItem item, CancellationToken cancellationToken = default)
+    {
+        _items.Remove(item.FullPath);
+        return Task.CompletedTask;
+    }
+
+    public Task SaveChangesAsync(CancellationToken cancellationToken = default)
+    {
+        SaveCount++;
+        return Task.CompletedTask;
+    }
+}

tests/PLib.Tests/Library/LibraryServiceTests.cs

@@ -0,0 +1,149 @@
+using Microsoft.Extensions.Logging.Abstractions;
+using Microsoft.Extensions.Options;
+using NSubstitute;
+using PLib.Application.Abstractions;
+using PLib.Application.Library;
+using PLib.Domain.Videos;
+using Shouldly;
+
+namespace PLib.Tests.Library;
+
+public sealed class LibraryServiceTests
+{
+    private const string Root = @"C:\videos";
+
+    private readonly InMemoryVideoRepository _repository = new();
+    private readonly IVideoFileScanner _scanner = Substitute.For<IVideoFileScanner>();
+    private readonly IMediaProbe _probe = Substitute.For<IMediaProbe>();
+    private readonly IThumbnailGenerator _thumbnails = Substitute.For<IThumbnailGenerator>();
+
+    public LibraryServiceTests()
+    {
+        _probe.ProbeAsync(Arg.Any<string>(), Arg.Any<CancellationToken>())
+            .Returns(new VideoTechnicalInfo(TimeSpan.FromMinutes(2), 1920, 1080, "h264"));
+
+        _thumbnails.GetOrCreateAsync(Arg.Any<string>(), Arg.Any<TimeSpan?>(), Arg.Any<CancellationToken>())
+            .Returns(callInfo => $@"C:\cache\{Path.GetFileNameWithoutExtension(callInfo.Arg<string>())}.jpg");
+    }
+
+    [Fact]
+    public async Task Files_that_are_new_on_disk_are_added_probed_and_given_a_thumbnail()
+    {
+        GivenFilesOnDisk(File(@"C:\videos\a.mp4"), File(@"C:\videos\b.mkv"));
+
+        var events = await CollectAsync(CreateService());
+
+        _repository.Items.Count.ShouldBe(2);
+        _repository.Items.ShouldAllBe(x => x.IsIndexed);
+
+        events.OfType<LibraryScanEvent.ItemAdded>().Count().ShouldBe(2);
+        events.OfType<LibraryScanEvent.ItemUpdated>().Count().ShouldBe(2);
+        events.OfType<LibraryScanEvent.Completed>().Single().LibrarySize.ShouldBe(2);
+    }
+
+    [Fact]
+    public async Task Entries_whose_file_is_gone_are_dropped_from_the_library()
+    {
+        _repository.Seed(new VideoItem(@"C:\videos\stale.mp4", "stale", 5_000, DateTimeOffset.UnixEpoch));
+        GivenFilesOnDisk(File(@"C:\videos\a.mp4"));
+
+        var events = await CollectAsync(CreateService());
+
+        _repository.Items.Select(x => x.FullPath).ShouldBe([@"C:\videos\a.mp4"]);
+        events.OfType<LibraryScanEvent.ItemRemoved>().Count().ShouldBe(1);
+    }
+
+    [Fact]
+    public async Task Files_below_the_minimum_size_are_not_part_of_the_library()
+    {
+        GivenFilesOnDisk(File(@"C:\videos\tiny.mp4", sizeInBytes: 128), File(@"C:\videos\real.mp4"));
+
+        await CollectAsync(CreateService(new LibraryOptions { MinimumFileSizeInBytes = 1_024 }));
+
+        _repository.Items.Select(x => x.FullPath).ShouldBe([@"C:\videos\real.mp4"]);
+    }
+
+    [Fact]
+    public async Task An_item_that_is_already_indexed_is_not_probed_again()
+    {
+        var indexed = new VideoItem(@"C:\videos\a.mp4", "a", 5_000, DateTimeOffset.UnixEpoch);
+        indexed.ApplyTechnicalInfo(new VideoTechnicalInfo(TimeSpan.FromMinutes(1), 1280, 720, "h264"));
+        indexed.AttachThumbnail(@"C:\cache\a.jpg");
+        _repository.Seed(indexed);
+
+        GivenFilesOnDisk(File(@"C:\videos\a.mp4", sizeInBytes: 5_000));
+
+        await CollectAsync(CreateService());
+
+        await _probe.DidNotReceive().ProbeAsync(Arg.Any<string>(), Arg.Any<CancellationToken>());
+    }
+
+    [Fact]
+    public async Task An_item_whose_file_changed_on_disk_is_indexed_again()
+    {
+        var indexed = new VideoItem(@"C:\videos\a.mp4", "a", 5_000, DateTimeOffset.UnixEpoch);
+        indexed.ApplyTechnicalInfo(new VideoTechnicalInfo(TimeSpan.FromMinutes(1), 1280, 720, "h264"));
+        indexed.AttachThumbnail(@"C:\cache\old.jpg");
+        _repository.Seed(indexed);
+
+        GivenFilesOnDisk(File(@"C:\videos\a.mp4", sizeInBytes: 9_999));
+
+        await CollectAsync(CreateService());
+
+        await _probe.Received(1).ProbeAsync(@"C:\videos\a.mp4", Arg.Any<CancellationToken>());
+        _repository.Items.Single().ThumbnailPath.ShouldBe(@"C:\cache\a.jpg");
+    }
+
+    [Fact]
+    public async Task The_same_file_reached_through_two_overlapping_roots_is_only_added_once()
+    {
+        GivenFilesOnDisk(File(@"C:\videos\a.mp4"));
+
+        var events = await CollectAsync(CreateService(), Root, Root);
+
+        _repository.Items.Count.ShouldBe(1);
+        events.OfType<LibraryScanEvent.DiscoveryCompleted>().Single().FilesFound.ShouldBe(1);
+    }
+
+    private static DiscoveredVideoFile File(string path, long sizeInBytes = 10_000) =>
+        new(path, sizeInBytes, DateTimeOffset.UnixEpoch);
+
+    private void GivenFilesOnDisk(params DiscoveredVideoFile[] files) =>
+        _scanner.ScanAsync(Arg.Any<string>(), Arg.Any<CancellationToken>())
+            .Returns(_ => files.ToAsyncEnumerable());
+
+    private LibraryService CreateService(LibraryOptions? options = null) => new(
+        _repository,
+        _scanner,
+        _probe,
+        _thumbnails,
+        Options.Create(options ?? new LibraryOptions { MinimumFileSizeInBytes = 0 }),
+        NullLogger<LibraryService>.Instance);
+
+    private static async Task<List<LibraryScanEvent>> CollectAsync(
+        LibraryService service,
+        params string[] folders)
+    {
+        var events = new List<LibraryScanEvent>();
+
+        await foreach (var scanEvent in service.ScanAsync(folders.Length == 0 ? [Root] : folders))
+        {
+            events.Add(scanEvent);
+        }
+
+        return events;
+    }
+}
+
+internal static class AsyncEnumerableExtensions
+{
+    public static async IAsyncEnumerable<T> ToAsyncEnumerable<T>(this IEnumerable<T> source)
+    {
+        foreach (var item in source)
+        {
+            yield return item;
+        }
+
+        await Task.CompletedTask;
+    }
+}

tests/PLib.Tests/PLib.Tests.csproj

@@ -0,0 +1,22 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <RootNamespace>PLib.Tests</RootNamespace>
+    <IsPackable>false</IsPackable>
+    <OutputType>Exe</OutputType>
+    <!-- xunit.v3 runs on Microsoft.Testing.Platform; no VSTest adapter needed. -->
+    <TestingPlatformDotnetTestSupport>true</TestingPlatformDotnetTestSupport>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="xunit.v3" />
+    <PackageReference Include="Shouldly" />
+    <PackageReference Include="NSubstitute" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\src\PLib.Application\PLib.Application.csproj" />
+    <ProjectReference Include="..\..\src\PLib.Domain\PLib.Domain.csproj" />
+  </ItemGroup>
+
+</Project>