diff --git a/src/FluentCMS.Admin/AdminRoutes.cs b/src/FluentCMS.Admin/AdminRoutes.cs
index 11522e772..18166eb05 100644
--- a/src/FluentCMS.Admin/AdminRoutes.cs
+++ b/src/FluentCMS.Admin/AdminRoutes.cs
@@ -1,6 +1,7 @@
 namespace FluentCMS.Admin;
 
-// The routes the host needs: the account pages for the cookie's redirects, and the audit page with the download it posts to.
+// The routes the host needs: the account pages for the cookie's redirects, the audit page with the download it posts to, and the
+// media library with its upload and file endpoints.
 // Each page route matches the @page directive of its page.
 public static class AdminRoutes
 {
@@ -15,6 +16,15 @@ public static class AdminRoutes
     public const string Audit = "/audit";
     public const string AuditExport = "/audit/export";
 
+    // The media library page, and the endpoints a page cannot be: the upload its form posts to and the bytes its previews show.
+    public const string Media = "/media";
+    public const string MediaUpload = "/media/upload";
+
+    public static string MediaFile(Guid id, int? version = null)
+    {
+        return version is { } number ? $"media/{id}/file?version={number}" : $"media/{id}/file";
+    }
+
     // Only a path on this site is followed after sign-in, so a crafted link cannot send someone elsewhere.
     public static bool IsLocal(string? url)
     {
diff --git a/src/FluentCMS.Admin/Components/Layout/MainLayout.razor b/src/FluentCMS.Admin/Components/Layout/MainLayout.razor
index f3918410b..8bb002efb 100644
--- a/src/FluentCMS.Admin/Components/Layout/MainLayout.razor
+++ b/src/FluentCMS.Admin/Components/Layout/MainLayout.razor
@@ -9,6 +9,7 @@
             @if (Initiator.Current is UserInitiator user)
             {
                 <NotificationLinks />
+                <a href="media" class="text-sm text-muted-foreground hover:text-foreground">@L["Media"]</a>
                 <a href="audit" class="text-sm text-muted-foreground hover:text-foreground">@L["Audit log"]</a>
                 <a href="users" class="text-sm text-muted-foreground hover:text-foreground">@L["Users"]</a>
                 <a href="agents" class="text-sm text-muted-foreground hover:text-foreground">@L["Agents"]</a>
diff --git a/src/FluentCMS.Admin/Components/Pages/MediaAssetView.razor b/src/FluentCMS.Admin/Components/Pages/MediaAssetView.razor
new file mode 100644
index 000000000..857265d58
--- /dev/null
+++ b/src/FluentCMS.Admin/Components/Pages/MediaAssetView.razor
@@ -0,0 +1,246 @@
+@page "/media/{Id:guid}"
+@using System.Globalization
+@using FluentCMS.Admin.Media
+@using FluentCMS.Core.Content
+@using FluentCMS.Core.Media
+@inject IMediaLibrary Library
+@inject IWhereUsed WhereUsed
+@inject NavigationManager Navigation
+@inject IStringLocalizer<MediaAssetView> L
+
+<PageTitle>@L["Media"]</PageTitle>
+
+@if (_asset is { } asset)
+{
+    var latest = asset.Latest;
+    <nav class="mb-4" aria-label="@L["Media navigation"]">
+        <a href="media" aria-keyshortcuts="B" class="@ButtonVariants.Classes("outline", "sm")">@L["Back to the library"]</a>
+    </nav>
+
+    <h1 class="text-2xl font-semibold tracking-tight break-all" data-testid="media-asset" data-version="@asset.LatestVersion"><bdi>@latest.Metadata.FileName</bdi></h1>
+    <div class="mt-2 flex flex-wrap items-center gap-2 text-sm text-muted-foreground">
+        <span dir="ltr">@latest.Blob.ContentType</span>
+        <span>@L["Version {0}", asset.LatestVersion]</span>
+        @if (asset.PublishedVersion is { } published)
+        {
+            <Badge Variant="secondary">@L["Version {0} is published", published]</Badge>
+        }
+        else
+        {
+            <Badge Variant="outline">@L["Not published"]</Badge>
+        }
+        <a href="@AdminRoutes.MediaFile(asset.Id, asset.LatestVersion)" class="underline underline-offset-4">@L["Download"]</a>
+    </div>
+
+    @if (Uploaded)
+    {
+        <p role="status" class="mt-4 rounded-md border bg-muted/50 px-3 py-2 text-sm" data-testid="media-uploaded">@L["Uploaded. The file is stored as version 1."]</p>
+    }
+
+    <div class="mt-6 grid gap-6 lg:grid-cols-2">
+        <Card>
+            <CardHeader>
+                <CardTitle><h2>@L["Preview"]</h2></CardTitle>
+            </CardHeader>
+            <CardContent>
+                @if (latest.Blob.ContentType.StartsWith("image/", StringComparison.Ordinal))
+                {
+                    <img src="@AdminRoutes.MediaFile(asset.Id, asset.LatestVersion)" alt="@(latest.Metadata.AltText ?? string.Empty)" class="max-h-96 w-full rounded-md border object-contain" data-testid="media-preview" />
+                    @if (latest.Metadata.AltText is null)
+                    {
+                        <p class="mt-2 text-sm text-destructive" data-testid="media-no-alt-text">@L["This image has no alt text, so people who cannot see it do not know what it shows. Add it below."]</p>
+                    }
+                }
+                else
+                {
+                    <p class="text-sm text-muted-foreground">@L["No preview for this type. Download the file to see it."]</p>
+                }
+            </CardContent>
+        </Card>
+
+        <Card data-testid="media-metadata">
+            <CardHeader>
+                <CardTitle><h2>@L["Details"]</h2></CardTitle>
+                <CardDescription>@L["Saving stores a new version with these details; the file stays the same."]</CardDescription>
+            </CardHeader>
+            <CardContent>
+                <form method="post" @onsubmit="SaveAsync" @formname="metadata" class="grid gap-4">
+                    <AntiforgeryToken />
+                    <input type="hidden" name="Form.BaseVersion" value="@asset.LatestVersion" />
+                    @if (_message is not null)
+                    {
+                        <p role="status" class="rounded-md border bg-muted/50 px-3 py-2 text-sm" data-testid="media-saved">@_message</p>
+                    }
+                    @if (_formError is not null)
+                    {
+                        <p role="alert" class="text-sm text-destructive" data-testid="media-save-error">@_formError</p>
+                    }
+                    <FormField Label="@L["File name"]" Error="@Error(MediaErrorCodes.FileNameInvalid)">
+                        <Input name="Form.FileName" value="@Shown.FileName" required />
+                    </FormField>
+                    <FormField Label="@L["Folder"]" Description="@L["Leave empty for the root, or such as products/drills."]" Error="@Error(MediaErrorCodes.FolderInvalid)">
+                        <Input name="Form.Folder" value="@Shown.Folder" dir="ltr" />
+                    </FormField>
+                    <FormField Label="@L["Tags"]" Description="@L["Separated by commas, such as product-shot, hero."]" Error="@Error(MediaErrorCodes.TagInvalid)">
+                        <Input name="Form.Tags" value="@Shown.Tags" dir="ltr" />
+                    </FormField>
+                    <FormField Label="@L["Alt text"]" Description="@L["What the image shows, for people who cannot see it."]" Error="@Error(MediaErrorCodes.AltTextInvalid)">
+                        <Textarea name="Form.AltText" rows="3" value="@Shown.AltText" />
+                    </FormField>
+                    <FormField Label="@L["Caption"]" Error="@Error(MediaErrorCodes.CaptionInvalid)">
+                        <Textarea name="Form.Caption" rows="2" value="@Shown.Caption" />
+                    </FormField>
+                    <div>
+                        <Button Type="submit">@L["Save"]</Button>
+                    </div>
+                </form>
+            </CardContent>
+        </Card>
+    </div>
+
+    <section class="mt-8" aria-labelledby="usage-heading" data-testid="media-usage">
+        <h2 id="usage-heading" class="text-lg font-semibold">@L["Where used"]</h2>
+        @if (_usage.Count == 0)
+        {
+            <p class="mt-2 text-sm text-muted-foreground" data-testid="media-unused">@L["No entry uses this file."]</p>
+        }
+        else
+        {
+            <div class="mt-4 rounded-md border">
+                <Table aria-labelledby="usage-heading">
+                    <TableHeader>
+                        <TableRow>
+                            <TableHead>@L["Entry"]</TableHead>
+                            <TableHead>@L["Version"]</TableHead>
+                            <TableHead>@L["Fields"]</TableHead>
+                        </TableRow>
+                    </TableHeader>
+                    <TableBody>
+                        @foreach (var usage in _usage)
+                        {
+                            <TableRow data-entry="@usage.EntryId.ToString("N")">
+                                <TableCell>
+                                    <bdi>@usage.ContentType</bdi> <bdi class="font-mono text-xs text-muted-foreground" dir="ltr">@usage.EntryId.ToString("N")[..8]</bdi>
+                                </TableCell>
+                                <TableCell>
+                                    <span class="flex flex-wrap items-center gap-1">
+                                        @usage.Version.ToString(CultureInfo.CurrentCulture)
+                                        @if (usage.IsPublished)
+                                        {
+                                            <Badge Variant="secondary">@L["Published"]</Badge>
+                                        }
+                                        @if (usage.IsLatest)
+                                        {
+                                            <Badge Variant="outline">@L["Latest draft"]</Badge>
+                                        }
+                                    </span>
+                                </TableCell>
+                                <TableCell Class="whitespace-normal font-mono text-xs" dir="ltr">@string.Join(", ", usage.Paths)</TableCell>
+                            </TableRow>
+                        }
+                    </TableBody>
+                </Table>
+            </div>
+        }
+    </section>
+}
+
+@code {
+    private MediaAsset? _asset;
+    private IReadOnlyList<EntryUsage> _usage = [];
+    private IReadOnlyList<string> _errors = [];
+    private string? _formError;
+    private string? _message;
+
+    [Parameter] public Guid Id { get; set; }
+
+    [SupplyParameterFromQuery(Name = "uploaded")]
+    private bool Uploaded { get; set; }
+
+    [SupplyParameterFromForm(FormName = "metadata")]
+    private MediaMetadataForm? Form { get; set; }
+
+    // What the form shows: what was posted after a refused save, the stored details otherwise.
+    private MediaMetadataForm Shown { get; set; } = new();
+
+    protected override async Task OnInitializedAsync()
+    {
+        if (!await LoadAsync())
+        {
+            Navigation.NotFound();
+        }
+    }
+
+    private async Task<bool> LoadAsync()
+    {
+        var read = await Library.GetAsync(Id);
+        if (!read.IsSuccess)
+        {
+            _asset = null;
+            return false;
+        }
+
+        _asset = read.Value;
+        var metadata = _asset.Latest.Metadata;
+        Shown = new MediaMetadataForm
+        {
+            FileName = metadata.FileName,
+            Folder = metadata.Folder,
+            Tags = string.Join(", ", metadata.Tags),
+            AltText = metadata.AltText,
+            Caption = metadata.Caption,
+            BaseVersion = _asset.LatestVersion,
+        };
+        _usage = await WhereUsed.ForMediaAsync(Id);
+        return true;
+    }
+
+    private async Task SaveAsync()
+    {
+        if (_asset is null || Form is null)
+        {
+            return;
+        }
+
+        var metadata = Form.ToMetadata(Form.FileName ?? string.Empty);
+        var saved = metadata.IsSuccess
+            ? await Library.UpdateAsync(Id, Form.BaseVersion, metadata.Value)
+            : FluentCMS.Core.Results.Result<MediaAsset>.Failure(metadata.Errors);
+
+        if (saved.IsSuccess)
+        {
+            _message = L["Saved as version {0}.", saved.Value.LatestVersion];
+            await LoadAsync();
+            return;
+        }
+
+        await LoadAsync();
+        _errors = [.. saved.Errors.Select(error => error.Code)];
+        _formError = saved.Errors.Any(error => error.Code == MediaErrorCodes.VersionConflict)
+            ? L["Someone changed this file's details since the page was shown. Here are the details as they are now; make the change again."]
+            : saved.Errors.Any(error => Error(error.Code) is null) ? L["The details could not be saved."].Value : null;
+
+        if (!saved.Errors.Any(error => error.Code == MediaErrorCodes.VersionConflict))
+        {
+            Shown = Form;
+        }
+    }
+
+    private string? Error(string code)
+    {
+        if (!_errors.Contains(code))
+        {
+            return null;
+        }
+
+        return code switch
+        {
+            MediaErrorCodes.FileNameInvalid => L["Enter a file name without slashes, at most 255 characters."].Value,
+            MediaErrorCodes.FolderInvalid => L["A folder is lowercase words joined by hyphens, with slashes between levels, such as products/drills."].Value,
+            MediaErrorCodes.TagInvalid => L["Each tag is lowercase words joined by hyphens, such as product-shot, and there are at most 32."].Value,
+            MediaErrorCodes.AltTextInvalid => L["Alt text is at most 1000 characters."].Value,
+            MediaErrorCodes.CaptionInvalid => L["A caption is at most 2000 characters."].Value,
+            _ => null,
+        };
+    }
+}
diff --git a/src/FluentCMS.Admin/Components/Pages/MediaLibraryView.razor b/src/FluentCMS.Admin/Components/Pages/MediaLibraryView.razor
new file mode 100644
index 000000000..d60347fca
--- /dev/null
+++ b/src/FluentCMS.Admin/Components/Pages/MediaLibraryView.razor
@@ -0,0 +1,247 @@
+@page "/media"
+@using System.Globalization
+@using FluentCMS.Admin.Media
+@using FluentCMS.Core.Media
+@inject IMediaLibrary Library
+@inject IStringLocalizer<MediaLibraryView> L
+
+<PageTitle>@L["Media"]</PageTitle>
+
+<h1 id="media-heading" class="text-2xl font-semibold tracking-tight">@L["Media"]</h1>
+<p class="mt-1 text-sm text-muted-foreground">@L["Images, documents and videos the site's pages use, with their alt text and where each is used."]</p>
+
+<div class="mt-6 grid gap-6 lg:grid-cols-[14rem_1fr]">
+    <nav aria-label="@L["Folders and tags"]" class="grid content-start gap-4 text-sm" data-testid="media-filters">
+        <div>
+            <h2 class="mb-2 font-medium">@L["Folders"]</h2>
+            <ul class="grid gap-1">
+                <li>
+                    <a href="media" aria-current="@(Folder is null && Tag is null ? "page" : null)" class="@Filter(Folder is null && Tag is null)" data-folder="">@L["All media"]</a>
+                </li>
+                @foreach (var folder in _folders.Where(folder => folder.Length > 0))
+                {
+                    <li>
+                        <a href="@($"media?folder={Uri.EscapeDataString(folder)}&sub=true")" aria-current="@(folder == Folder ? "page" : null)" class="@Filter(folder == Folder)" data-folder="@folder">
+                            <bdi dir="ltr">@folder</bdi>
+                        </a>
+                    </li>
+                }
+            </ul>
+        </div>
+        @if (_tags.Count > 0)
+        {
+            <div>
+                <h2 class="mb-2 font-medium">@L["Tags"]</h2>
+                <ul class="flex flex-wrap gap-1">
+                    @foreach (var tag in _tags)
+                    {
+                        <li>
+                            <a href="@($"media?tag={Uri.EscapeDataString(tag)}")" aria-current="@(tag == Tag ? "page" : null)" data-tag="@tag">
+                                <Badge Variant="@(tag == Tag ? "default" : "outline")">@tag</Badge>
+                            </a>
+                        </li>
+                    }
+                </ul>
+            </div>
+        }
+    </nav>
+
+    <div class="grid content-start gap-6">
+        <Card data-testid="media-upload">
+            <CardHeader>
+                <CardTitle><h2>@L["Upload"]</h2></CardTitle>
+                <CardDescription>@L["JPEG, PNG, GIF, WebP, PDF, MP4 or WebM. Describe an image in its alt text for people who cannot see it."]</CardDescription>
+            </CardHeader>
+            <CardContent>
+                @* Posts to the host's upload endpoint, which goes to the new asset or sends a refused upload back here. *@
+                <form method="post" action="media/upload" enctype="multipart/form-data" class="grid gap-4">
+                    <AntiforgeryToken />
+                    <FormField Label="@L["File"]" Error="@UploadError(MediaUploadForm.FileMissing, MediaErrorCodes.FileNameInvalid, MediaErrorCodes.ContentTypeInvalid, MediaErrorCodes.MediaEmpty, MediaErrorCodes.MediaTooLarge, MediaErrorCodes.ContentMismatch)">
+                        <Input Type="file" name="file" accept="@string.Join(",", MediaTypes.Allowed)" required />
+                    </FormField>
+                    <div class="grid gap-4 sm:grid-cols-2">
+                        <FormField Label="@L["Folder"]" Description="@L["Optional, such as products/drills."]" Error="@UploadError(MediaErrorCodes.FolderInvalid)">
+                            <Input name="Folder" value="@(UploadFolder ?? Folder)" dir="ltr" />
+                        </FormField>
+                        <FormField Label="@L["Tags"]" Description="@L["Optional, separated by commas, such as product-shot, hero."]" Error="@UploadError(MediaErrorCodes.TagInvalid)">
+                            <Input name="Tags" value="@UploadTags" dir="ltr" />
+                        </FormField>
+                    </div>
+                    <FormField Label="@L["Alt text"]" Error="@UploadError(MediaErrorCodes.AltTextInvalid)">
+                        <Textarea name="AltText" rows="2" value="@UploadAltText" />
+                    </FormField>
+                    <FormField Label="@L["Caption"]" Error="@UploadError(MediaErrorCodes.CaptionInvalid)">
+                        <Textarea name="Caption" rows="2" value="@UploadCaption" />
+                    </FormField>
+                    @if (UploadFormError is { } formError)
+                    {
+                        <p role="alert" class="text-sm text-destructive" data-testid="media-upload-error">@formError</p>
+                    }
+                    <div>
+                        <Button Type="submit">@L["Upload"]</Button>
+                    </div>
+                </form>
+            </CardContent>
+        </Card>
+
+        <section aria-labelledby="media-list-heading">
+            <h2 id="media-list-heading" class="text-lg font-semibold">
+                @(Tag is not null ? L["Tagged {0}", Tag] : Folder is not null ? L["In {0}", Folder] : L["All media"])
+                <span class="text-muted-foreground">(@_assets.Count.ToString(CultureInfo.CurrentCulture))</span>
+            </h2>
+            @if (_assets.Count == 0)
+            {
+                <p class="mt-4 rounded-md border px-3 py-6 text-center text-sm text-muted-foreground" data-testid="media-empty">@L["No media here yet."]</p>
+            }
+            else
+            {
+                <div class="mt-4 rounded-md border">
+                    <Table aria-labelledby="media-list-heading">
+                        <TableHeader>
+                            <TableRow>
+                                <TableHead><span class="sr-only">@L["Preview"]</span></TableHead>
+                                <TableHead>@L["File"]</TableHead>
+                                <TableHead>@L["Folder"]</TableHead>
+                                <TableHead>@L["Tags"]</TableHead>
+                                <TableHead Class="text-end">@L["Size"]</TableHead>
+                                <TableHead>@L["Status"]</TableHead>
+                            </TableRow>
+                        </TableHeader>
+                        <TableBody data-ui="rove">
+                            @foreach (var (asset, index) in _assets.Select((asset, index) => (asset, index)))
+                            {
+                                <TableRow data-asset="@asset.Id.ToString("N")">
+                                    <TableCell Class="w-16">
+                                        @if (IsImage(asset.ContentType))
+                                        {
+                                            @* The file name beside it names the image, so the preview is decorative. *@
+                                            <img src="@AdminRoutes.MediaFile(asset.Id)" alt="" loading="lazy" class="size-12 rounded-md border object-cover" />
+                                        }
+                                    </TableCell>
+                                    <TableCell Class="whitespace-normal">
+                                        <a href="@($"media/{asset.Id}")" data-ui="rove-item" tabindex="@(index == 0 ? null : "-1")" class="font-medium underline-offset-4 hover:underline"><bdi>@asset.FileName</bdi></a>
+                                        <span class="block text-xs text-muted-foreground" dir="ltr">@asset.ContentType</span>
+                                    </TableCell>
+                                    <TableCell><bdi dir="ltr">@asset.Folder</bdi></TableCell>
+                                    <TableCell Class="whitespace-normal">
+                                        <span class="flex flex-wrap gap-1">
+                                            @foreach (var tag in asset.Tags)
+                                            {
+                                                <Badge Variant="outline">@tag</Badge>
+                                            }
+                                        </span>
+                                    </TableCell>
+                                    <TableCell Class="text-end tabular-nums">@Size(asset.Length)</TableCell>
+                                    <TableCell>
+                                        <span class="flex flex-wrap gap-1">
+                                            @if (asset.PublishedVersion is not null)
+                                            {
+                                                <Badge Variant="secondary" data-status="published">@L["Published"]</Badge>
+                                            }
+                                            @if (IsImage(asset.ContentType) && !asset.HasAltText)
+                                            {
+                                                <Badge Variant="destructive" data-status="no-alt-text">@L["No alt text"]</Badge>
+                                            }
+                                        </span>
+                                    </TableCell>
+                                </TableRow>
+                            }
+                        </TableBody>
+                    </Table>
+                </div>
+            }
+        </section>
+    </div>
+</div>
+
+@code {
+    private IReadOnlyList<string> _folders = [];
+    private IReadOnlyList<string> _tags = [];
+    private IReadOnlyList<MediaAssetSummary> _assets = [];
+
+    [SupplyParameterFromQuery(Name = "folder")]
+    private string? Folder { get; set; }
+
+    [SupplyParameterFromQuery(Name = "sub")]
+    private bool Subfolders { get; set; }
+
+    [SupplyParameterFromQuery(Name = "tag")]
+    private string? Tag { get; set; }
+
+    // What a refused upload sends back, so each problem shows next to its field and nothing typed is lost.
+    [SupplyParameterFromQuery(Name = MediaUploadForm.ErrorName)]
+    private string? UploadErrors { get; set; }
+
+    [SupplyParameterFromQuery(Name = MediaUploadForm.FolderName)]
+    private string? UploadFolder { get; set; }
+
+    [SupplyParameterFromQuery(Name = MediaUploadForm.TagsName)]
+    private string? UploadTags { get; set; }
+
+    [SupplyParameterFromQuery(Name = MediaUploadForm.AltTextName)]
+    private string? UploadAltText { get; set; }
+
+    [SupplyParameterFromQuery(Name = MediaUploadForm.CaptionName)]
+    private string? UploadCaption { get; set; }
+
+    private static readonly HashSet<string> FieldCodes =
+    [
+        MediaUploadForm.FileMissing,
+        MediaErrorCodes.FileNameInvalid,
+        MediaErrorCodes.ContentTypeInvalid,
+        MediaErrorCodes.MediaEmpty,
+        MediaErrorCodes.MediaTooLarge,
+        MediaErrorCodes.ContentMismatch,
+        MediaErrorCodes.FolderInvalid,
+        MediaErrorCodes.TagInvalid,
+        MediaErrorCodes.AltTextInvalid,
+        MediaErrorCodes.CaptionInvalid,
+    ];
+
+    private IReadOnlyList<string> ErrorCodes => (UploadErrors ?? string.Empty).Split(',', StringSplitOptions.RemoveEmptyEntries);
+
+    private string? UploadFormError => ErrorCodes.Any(code => !FieldCodes.Contains(code))
+        ? L["The upload could not be stored. Try again."].Value
+        : null;
+
+    protected override async Task OnInitializedAsync()
+    {
+        // The library lists the oldest asset first; the newest is what someone looks for after an upload.
+        _folders = await Library.FoldersAsync();
+        var all = await Library.ListAsync(new MediaQuery());
+        _tags = [.. all.SelectMany(asset => asset.Tags).Distinct(StringComparer.Ordinal).Order(StringComparer.Ordinal)];
+        var listed = Folder is null && Tag is null ? all : await Library.ListAsync(new MediaQuery(Folder, Subfolders, Tag));
+        _assets = [.. listed.Reverse()];
+    }
+
+    private string? UploadError(params string[] codes)
+    {
+        return codes.FirstOrDefault(ErrorCodes.Contains) switch
+        {
+            null => null,
+            MediaUploadForm.FileMissing => L["Choose a file to upload."].Value,
+            MediaErrorCodes.FileNameInvalid => L["The file name must not contain slashes and must be at most 255 characters."].Value,
+            MediaErrorCodes.ContentTypeInvalid => L["This type of file cannot be uploaded. Choose a JPEG, PNG, GIF, WebP, PDF, MP4 or WebM file."].Value,
+            MediaErrorCodes.MediaEmpty => L["The file is empty."].Value,
+            MediaErrorCodes.MediaTooLarge => L["The file is larger than the library accepts."].Value,
+            MediaErrorCodes.ContentMismatch => L["The file's content does not match its type. Check that it is the file you meant."].Value,
+            MediaErrorCodes.FolderInvalid => L["A folder is lowercase words joined by hyphens, with slashes between levels, such as products/drills."].Value,
+            MediaErrorCodes.TagInvalid => L["Each tag is lowercase words joined by hyphens, such as product-shot, and there are at most 32."].Value,
+            MediaErrorCodes.AltTextInvalid => L["Alt text is at most 1000 characters."].Value,
+            _ => L["A caption is at most 2000 characters."].Value,
+        };
+    }
+
+    private static string Filter(bool current) => ClassNames.Cn(
+        "block rounded-md px-2 py-1 hover:bg-accent hover:text-accent-foreground",
+        current ? "bg-secondary font-medium text-secondary-foreground" : "text-muted-foreground");
+
+    private static bool IsImage(string contentType) => contentType.StartsWith("image/", StringComparison.Ordinal);
+
+    private static string Size(long bytes) => bytes switch
+    {
+        < 1024 => $"{bytes.ToString(CultureInfo.CurrentCulture)} B",
+        < 1024 * 1024 => $"{(bytes / 1024.0).ToString("0.#", CultureInfo.CurrentCulture)} KB",
+        _ => $"{(bytes / (1024.0 * 1024)).ToString("0.#", CultureInfo.CurrentCulture)} MB",
+    };
+}
diff --git a/src/FluentCMS.Admin/Media/MediaForms.cs b/src/FluentCMS.Admin/Media/MediaForms.cs
new file mode 100644
index 000000000..ae079e411
--- /dev/null
+++ b/src/FluentCMS.Admin/Media/MediaForms.cs
@@ -0,0 +1,64 @@
+using FluentCMS.Core.Media;
+using FluentCMS.Core.Results;
+
+namespace FluentCMS.Admin.Media;
+
+// The metadata fields both media forms post. Tags are typed comma-separated; a blank alt text or caption means none.
+public class MediaMetadataFields
+{
+    public string? Folder { get; set; }
+
+    public string? Tags { get; set; }
+
+    public string? AltText { get; set; }
+
+    public string? Caption { get; set; }
+
+    public Result<AssetMetadata> ToMetadata(string fileName)
+    {
+        return AssetMetadata.Create(fileName, Folder, SplitTags(Tags), Blank(AltText), Blank(Caption));
+    }
+
+    public static IReadOnlyList<string> SplitTags(string? tags)
+    {
+        return (tags ?? string.Empty).Split(',', StringSplitOptions.TrimEntries | StringSplitOptions.RemoveEmptyEntries);
+    }
+
+    private static string? Blank(string? text)
+    {
+        return string.IsNullOrWhiteSpace(text) ? null : text;
+    }
+}
+
+// The library's upload form as it posts to the host's upload endpoint; the file arrives beside it. A refused upload comes back to the
+// library with ReturnQuery, so the page can show each problem next to its field and keep what was typed.
+public sealed class MediaUploadForm : MediaMetadataFields
+{
+    public const string FileMissing = "media_file_missing";
+
+    public const string ErrorName = "error";
+    public const string FolderName = "folder";
+    public const string TagsName = "tags";
+    public const string AltTextName = "alt";
+    public const string CaptionName = "caption";
+
+    public Dictionary<string, string?> ReturnQuery(IEnumerable<Error> errors)
+    {
+        return new Dictionary<string, string?>
+        {
+            [ErrorName] = string.Join(",", errors.Select(error => error.Code).Distinct()),
+            [FolderName] = Folder,
+            [TagsName] = Tags,
+            [AltTextName] = AltText,
+            [CaptionName] = Caption,
+        };
+    }
+}
+
+// The asset page's metadata form. BaseVersion is the version the page showed, so a change made meanwhile is refused, not overwritten.
+public sealed class MediaMetadataForm : MediaMetadataFields
+{
+    public string? FileName { get; set; }
+
+    public int BaseVersion { get; set; }
+}
diff --git a/src/FluentCMS.Host/FluentCmsHost.cs b/src/FluentCMS.Host/FluentCmsHost.cs
index f3d39ee5c..fc7b5177b 100644
--- a/src/FluentCMS.Host/FluentCmsHost.cs
+++ b/src/FluentCMS.Host/FluentCmsHost.cs
@@ -6,6 +6,7 @@
 using FluentCMS.Host.Audit;
 using FluentCMS.Host.Identity;
 using FluentCMS.Host.Jobs;
+using FluentCMS.Host.Media;
 using FluentCMS.Host.Security;
 using FluentCMS.Infrastructure;
 using FluentCMS.Infrastructure.Media;
@@ -70,6 +71,7 @@ public static WebApplication BuildWebApplication(string[] args, Action<WebApplic
         app.MapFluentCmsApi();
         app.MapExternalSignIn();
         app.MapAuditExport();
+        app.MapMediaLibrary();
 
         // Every admin page needs a signed-in user unless it allows anonymous access itself (setup, sign-in, not found).
         app.MapRazorComponents<App>()
diff --git a/src/FluentCMS.Host/Media/MediaEndpoints.cs b/src/FluentCMS.Host/Media/MediaEndpoints.cs
new file mode 100644
index 000000000..afd0c61a5
--- /dev/null
+++ b/src/FluentCMS.Host/Media/MediaEndpoints.cs
@@ -0,0 +1,83 @@
+using FluentCMS.Admin;
+using FluentCMS.Admin.Media;
+using FluentCMS.Core.Media;
+using FluentCMS.Core.Results;
+using FluentCMS.Infrastructure.Media;
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Options;
+using Microsoft.Net.Http.Headers;
+
+namespace FluentCMS.Host.Media;
+
+// What the media library's pages cannot do themselves: take a file from a form and send bytes back. Each maps the request and calls
+// the library, nothing more. Form binding makes the anti-forgery check apply to the upload (SEC-07).
+internal static class MediaEndpoints
+{
+    // Room for the form's other fields and the multipart framing around a file of the largest size the library accepts.
+    private const long FormOverhead = 1024 * 1024;
+
+    public static void MapMediaLibrary(this IEndpointRouteBuilder endpoints)
+    {
+        var limit = endpoints.ServiceProvider.GetRequiredService<IOptions<MediaOptions>>().Value.MaxBytes + FormOverhead;
+
+        endpoints.MapPost(AdminRoutes.MediaUpload, UploadAsync)
+            .RequireAuthorization()
+            .WithMetadata(new RequestSizeLimitAttribute(limit))
+            .WithFormOptions(multipartBodyLengthLimit: limit);
+
+        // Someone whose session ran out signs in again and is sent back here with a GET; the form is on the library page.
+        endpoints.MapGet(AdminRoutes.MediaUpload, () => Results.LocalRedirect(AdminRoutes.Media)).RequireAuthorization();
+        endpoints.MapGet("/media/{id:guid}/file", FileAsync).RequireAuthorization();
+    }
+
+    private static async Task<IResult> UploadAsync([FromForm] MediaUploadForm? fields, IFormFile? file, IMediaLibrary library, CancellationToken cancellationToken)
+    {
+        // A form with only a file binds no fields at all.
+        var form = fields ?? new MediaUploadForm();
+        if (file is null || file.Length == 0)
+        {
+            return BackToLibrary(form, [new Error(MediaUploadForm.FileMissing, "Choose a file to upload.")]);
+        }
+
+        // Some browsers send the path the file came from; only its name is the asset's.
+        var metadata = form.ToMetadata(Path.GetFileName(file.FileName));
+        if (!metadata.IsSuccess)
+        {
+            return BackToLibrary(form, metadata.Errors);
+        }
+
+        await using var content = file.OpenReadStream();
+        var uploaded = await library.UploadAsync(new NewAsset(content, file.ContentType, metadata.Value), cancellationToken);
+
+        return uploaded.IsSuccess
+            ? Results.LocalRedirect($"{AdminRoutes.Media}/{uploaded.Value.Id}?uploaded=true")
+            : BackToLibrary(form, uploaded.Errors);
+    }
+
+    // Images show inline for the library's previews; anything else downloads. The library only stores types a browser does not run
+    // as a document (MediaTypes), and nosniff keeps the browser to the stored type.
+    private static async Task<IResult> FileAsync(Guid id, int? version, IMediaLibrary library, HttpContext context, CancellationToken cancellationToken)
+    {
+        var opened = await library.OpenAsync(id, version, cancellationToken);
+        if (!opened.IsSuccess)
+        {
+            return Results.NotFound();
+        }
+
+        var content = opened.Value;
+        var headers = context.Response.Headers;
+        headers.XContentTypeOptions = "nosniff";
+        headers.CacheControl = "private, no-store";
+        headers.ContentDisposition = new ContentDispositionHeaderValue(content.ContentType.StartsWith("image/", StringComparison.Ordinal) ? "inline" : "attachment")
+        {
+            FileNameStar = content.FileName,
+        }.ToString();
+
+        return Results.Stream(content.Content, content.ContentType);
+    }
+
+    private static IResult BackToLibrary(MediaUploadForm form, IEnumerable<Error> errors)
+    {
+        return Results.LocalRedirect(AdminRoutes.Media + QueryString.Create(form.ReturnQuery(errors)));
+    }
+}
diff --git a/tests/FluentCMS.IntegrationTests/Browser/AccessibilityTests.cs b/tests/FluentCMS.IntegrationTests/Browser/AccessibilityTests.cs
index f0d5828ff..d3080837f 100644
--- a/tests/FluentCMS.IntegrationTests/Browser/AccessibilityTests.cs
+++ b/tests/FluentCMS.IntegrationTests/Browser/AccessibilityTests.cs
@@ -1,7 +1,9 @@
 using Deque.AxeCore.Commons;
 using Deque.AxeCore.Playwright;
 using FluentCMS.Core.ChangeSets;
+using FluentCMS.Core.Media;
 using FluentCMS.Core.Schema;
+using FluentCMS.IntegrationTests.Media;
 using Microsoft.Playwright;
 
 namespace FluentCMS.IntegrationTests.Browser;
@@ -19,9 +21,13 @@ public async Task The_showcase_desk_and_set_view_have_no_wcag_21_aa_violations()
     {
         await using var session = await BrowserSession.StartAsync();
         var set = await AwaitingReviewAsync(session);
+        var asset = await session.Host.AsUserAsync<IMediaLibrary, Guid>(session.OwnerId, async library => (await library.UploadAsync(new NewAsset(
+            new MemoryStream(MediaFiles.Jpeg()),
+            "image/jpeg",
+            AssetMetadata.Create("drill.jpg", "products", ["hero"], null, null).Value))).Value.Id);
         await session.SignInWithKeyboardAsync();
 
-        string[] paths = ["/ui", "/", "/?queue=stale-facts", $"/sets/{set.Id}?queue=awaiting-me", "/security"];
+        string[] paths = ["/ui", "/", "/?queue=stale-facts", $"/sets/{set.Id}?queue=awaiting-me", "/security", "/media", $"/media/{asset}"];
         var violations = new List<string>();
         foreach (var theme in new[] { "light", "dark" })
         {
diff --git a/tests/FluentCMS.IntegrationTests/Media/MediaScreenTests.cs b/tests/FluentCMS.IntegrationTests/Media/MediaScreenTests.cs
new file mode 100644
index 000000000..c4a44b6ad
--- /dev/null
+++ b/tests/FluentCMS.IntegrationTests/Media/MediaScreenTests.cs
@@ -0,0 +1,241 @@
+using System.Net;
+using System.Net.Http.Headers;
+using System.Text.Json;
+using System.Text.RegularExpressions;
+using FluentCMS.Core.Content;
+using FluentCMS.Core.Media;
+using FluentCMS.Core.Schema;
+using FluentCMS.Infrastructure.Persistence;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace FluentCMS.IntegrationTests.Media;
+
+public sealed partial class MediaScreenTests
+{
+    private static readonly byte[] Png = [0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A, 0x00, 0x00, 0x00, 0x0D, 0x49, 0x48, 0x44, 0x52];
+
+    [Fact]
+    public async Task An_administrator_uploads_an_image_lands_on_it_and_its_bytes_come_back()
+    {
+        using var install = new TemporaryInstall();
+        await using var host = await AdminHost.StartAsync(install);
+        await host.CreateFirstAdministratorAsync();
+        await host.SignInAsync(AdminHost.Owner);
+
+        var uploaded = await UploadAsync(host, "drill.png", "image/png", Png, ("Folder", "products/drills"), ("Tags", "Product-Shot, hero"), ("AltText", "A cordless drill."));
+
+        Assert.Equal(HttpStatusCode.Redirect, uploaded.StatusCode);
+        var location = host.LocationOf(uploaded)!;
+        Assert.Matches("^/media/[0-9a-f-]{36}\\?uploaded=true$", location);
+        var id = Guid.Parse(location["/media/".Length..location.IndexOf('?')]);
+        var page = await host.Client.GetStringAsync(location);
+        Assert.Contains("data-testid=\"media-uploaded\"", page);
+        Assert.Contains($"src=\"media/{id}/file?version=1\" alt=\"A cordless drill.\"", page);
+        Assert.Contains("value=\"product-shot, hero\"", page);
+
+        var file = await host.Client.GetAsync($"/media/{id}/file");
+        Assert.Equal(HttpStatusCode.OK, file.StatusCode);
+        Assert.Equal("image/png", file.Content.Headers.ContentType!.MediaType);
+        Assert.Equal(Png, await file.Content.ReadAsByteArrayAsync());
+        Assert.Equal("inline", file.Content.Headers.ContentDisposition!.DispositionType);
+        Assert.Equal("nosniff", file.Headers.GetValues("X-Content-Type-Options").Single());
+        Assert.Equal(HttpStatusCode.NotFound, (await host.Client.GetAsync($"/media/{Guid.NewGuid()}/file")).StatusCode);
+    }
+
+    [Fact]
+    public async Task A_refused_upload_comes_back_with_its_problems_next_to_the_fields_and_stores_nothing()
+    {
+        using var install = new TemporaryInstall();
+        await using var host = await AdminHost.StartAsync(install);
+        await host.CreateFirstAdministratorAsync();
+        await host.SignInAsync(AdminHost.Owner);
+
+        var mismatch = await UploadAsync(host, "notes.png", "image/png", "plain text, not a PNG"u8.ToArray(), ("Folder", "Bad Folder"), ("AltText", "Notes."));
+        var noFile = await UploadAsync(host, null, null, null);
+
+        Assert.StartsWith("/media?error=folder_invalid", host.LocationOf(mismatch));
+        var form = await host.Client.GetStringAsync(host.LocationOf(mismatch)!);
+        Assert.Contains("A folder is lowercase words joined by hyphens", form);
+        Assert.Contains("value=\"Bad Folder\"", form);
+        Assert.Contains("Notes.", form);
+
+        var fixedFolder = await UploadAsync(host, "notes.png", "image/png", "plain text, not a PNG"u8.ToArray());
+        Assert.True(fixedFolder.StatusCode == HttpStatusCode.Redirect, $"{fixedFolder.StatusCode}: {await fixedFolder.Content.ReadAsStringAsync()}");
+        Assert.Equal("/media?error=media_content_mismatch", host.LocationOf(fixedFolder)!.Split('&')[0]);
+        Assert.Contains("does not match its type", await host.Client.GetStringAsync(host.LocationOf(fixedFolder)!));
+        Assert.True(noFile.StatusCode == HttpStatusCode.Redirect, $"{noFile.StatusCode}: {await noFile.Content.ReadAsStringAsync()}");
+        Assert.Equal("/media?error=media_file_missing", host.LocationOf(noFile)!.Split('&')[0]);
+        Assert.Equal(0, await QueryAsync(host, context => context.Set<FluentCMS.Infrastructure.Media.MediaAssetRow>().CountAsync()));
+    }
+
+    [Fact]
+    public async Task The_library_filters_by_folder_subfolders_and_tag_and_marks_images_without_alt_text()
+    {
+        using var install = new TemporaryInstall();
+        await using var host = await AdminHost.StartAsync(install);
+        var ownerId = await host.CreateFirstAdministratorAsync();
+        var drill = await StoreAsync(host, ownerId, "drill.jpg", "products/drills", ["hero"], "A drill.");
+        var saw = await StoreAsync(host, ownerId, "saw.jpg", "products", [], null);
+        var logo = await StoreAsync(host, ownerId, "logo.jpg", "", ["hero"], "The logo.");
+        await host.SignInAsync(AdminHost.Owner);
+
+        var all = await host.Client.GetStringAsync("/media");
+        var products = await host.Client.GetStringAsync("/media?folder=products&sub=true");
+        var productsOnly = await host.Client.GetStringAsync("/media?folder=products");
+        var hero = await host.Client.GetStringAsync("/media?tag=hero");
+
+        Assert.Equal([logo, saw, drill], Assets(all));
+        Assert.Equal([saw, drill], Assets(products));
+        Assert.Equal([saw], Assets(productsOnly));
+        Assert.Equal([logo, drill], Assets(hero));
+        Assert.Contains("data-folder=\"products/drills\"", all);
+        Assert.Contains("data-tag=\"hero\"", all);
+        var sawRow = all[all.IndexOf($"data-asset=\"{saw:N}\"", StringComparison.Ordinal)..];
+        Assert.Contains("data-status=\"no-alt-text\"", sawRow[..sawRow.IndexOf("</tr>", StringComparison.Ordinal)]);
+        Assert.Equal(1, Regex.Count(all, "data-status=\"no-alt-text\""));
+    }
+
+    [Fact]
+    public async Task Saving_details_stores_the_next_version_and_a_form_from_an_older_version_is_refused()
+    {
+        using var install = new TemporaryInstall();
+        await using var host = await AdminHost.StartAsync(install);
+        var ownerId = await host.CreateFirstAdministratorAsync();
+        var id = await StoreAsync(host, ownerId, "saw.jpg", "", [], null);
+        await host.SignInAsync(AdminHost.Owner);
+
+        var saved = await host.SubmitAsync($"/media/{id}", "metadata", Details(1, "A circular saw."));
+        var stale = await host.SubmitAsync($"/media/{id}", "metadata", Details(1, "A table saw."));
+        var invalid = await host.SubmitAsync($"/media/{id}", "metadata", Details(2, "A saw.", tags: "Not A Tag!"));
+
+        var page = await saved.Content.ReadAsStringAsync();
+        Assert.Contains("data-testid=\"media-saved\"", page);
+        Assert.Contains("data-version=\"2\"", page);
+        Assert.Contains("A circular saw.", page);
+        var conflict = await stale.Content.ReadAsStringAsync();
+        Assert.Contains("data-testid=\"media-save-error\"", conflict);
+        Assert.Contains("A circular saw.", conflict);
+        Assert.Contains("Each tag is lowercase words", await invalid.Content.ReadAsStringAsync());
+        var stored = await host.AsUserAsync<IMediaLibrary, MediaAsset>(ownerId, async library => (await library.GetAsync(id)).Value);
+        Assert.Equal((2, "A circular saw."), (stored.LatestVersion, stored.Latest.Metadata.AltText));
+    }
+
+    [Fact]
+    public async Task The_asset_page_lists_where_it_is_used()
+    {
+        using var install = new TemporaryInstall();
+        await using var host = await AdminHost.StartAsync(install);
+        var ownerId = await host.CreateFirstAdministratorAsync();
+        var hero = await StoreAsync(host, ownerId, "hero.jpg", "", [], "A drill on a bench.");
+        var unused = await StoreAsync(host, ownerId, "spare.jpg", "", [], "A spare.");
+        await host.AsUserAsync<IContentTypeDirectory, ContentType>(ownerId, async types => (await types.CreateAsync(new NewContentType(
+            "Product page",
+            "product-page",
+            new ContentTypeDefinition([new FieldDefinition("title", "text"), new FieldDefinition("hero", "media")])))).Value);
+        var page = await host.AsUserAsync<IEntryDirectory, Entry>(ownerId, async entries => (await entries.CreateAsync(new NewEntry(
+            "product-page",
+            JsonSerializer.Deserialize<JsonElement>($$"""{"title": "Drills", "hero": "{{hero}}"}""")))).Value);
+        await host.SignInAsync(AdminHost.Owner);
+
+        var used = await host.Client.GetStringAsync($"/media/{hero}");
+        var notUsed = await host.Client.GetStringAsync($"/media/{unused}");
+
+        Assert.Contains($"data-entry=\"{page.Id:N}\"", used);
+        Assert.Contains("/hero", used);
+        Assert.Contains("data-testid=\"media-unused\"", notUsed);
+    }
+
+    [Fact]
+    public async Task Anonymous_requests_go_to_sign_in_and_an_upload_without_the_token_stores_nothing()
+    {
+        using var install = new TemporaryInstall();
+        await using var host = await AdminHost.StartAsync(install);
+        var ownerId = await host.CreateFirstAdministratorAsync();
+        var id = await StoreAsync(host, ownerId, "saw.jpg", "", [], null);
+
+        foreach (var path in new[] { "/media", $"/media/{id}", $"/media/{id}/file" })
+        {
+            var response = await host.Client.GetAsync(path);
+            Assert.Equal(HttpStatusCode.Redirect, response.StatusCode);
+            Assert.StartsWith("/sign-in?ReturnUrl=", host.LocationOf(response));
+        }
+
+        await host.SignInAsync(AdminHost.Owner);
+        using var form = new MultipartFormDataContent { { File("drill.png", "image/png", Png), "file" } };
+        var forged = await host.Client.PostAsync("/media/upload", form);
+
+        Assert.Equal(HttpStatusCode.BadRequest, forged.StatusCode);
+        Assert.Equal(1, await QueryAsync(host, context => context.Set<FluentCMS.Infrastructure.Media.MediaAssetRow>().CountAsync()));
+    }
+
+    private static Dictionary<string, string> Details(int baseVersion, string altText, string tags = "")
+    {
+        return new Dictionary<string, string>
+        {
+            ["Form.BaseVersion"] = baseVersion.ToString(System.Globalization.CultureInfo.InvariantCulture),
+            ["Form.FileName"] = "saw.jpg",
+            ["Form.Folder"] = "",
+            ["Form.Tags"] = tags,
+            ["Form.AltText"] = altText,
+            ["Form.Caption"] = "",
+        };
+    }
+
+    // Posts the library's upload form as a browser would, with the token from the library page.
+    private static async Task<HttpResponseMessage> UploadAsync(AdminHost host, string? fileName, string? contentType, byte[]? bytes, params (string Name, string Value)[] fields)
+    {
+        var page = await host.Client.GetStringAsync("/media");
+        var token = AntiforgeryToken().Match(page);
+        Assert.True(token.Success, "The library has no anti-forgery token.");
+
+        using var form = new MultipartFormDataContent
+        {
+            { new StringContent(WebUtility.HtmlDecode(token.Groups[1].Value)), "__RequestVerificationToken" },
+        };
+        foreach (var (name, value) in fields)
+        {
+            form.Add(new StringContent(value), name);
+        }
+
+        if (bytes is not null)
+        {
+            form.Add(File(fileName!, contentType!, bytes), "file");
+        }
+
+        return await host.Client.PostAsync("/media/upload", form);
+    }
+
+    private static ByteArrayContent File(string fileName, string contentType, byte[] bytes)
+    {
+        var file = new ByteArrayContent(bytes);
+        file.Headers.ContentType = new MediaTypeHeaderValue(contentType);
+        file.Headers.ContentDisposition = new ContentDispositionHeaderValue("form-data") { Name = "file", FileName = fileName };
+        return file;
+    }
+
+    private static Task<Guid> StoreAsync(AdminHost host, Guid ownerId, string fileName, string folder, string[] tags, string? altText)
+    {
+        return host.AsUserAsync<IMediaLibrary, Guid>(ownerId, async library => (await library.UploadAsync(new NewAsset(
+            new MemoryStream(MediaFiles.Jpeg()),
+            "image/jpeg",
+            AssetMetadata.Create(fileName, folder, tags, altText, null).Value))).Value.Id);
+    }
+
+    private static List<Guid> Assets(string page)
+    {
+        return [.. AssetRow().Matches(page).Select(match => Guid.ParseExact(match.Groups[1].Value, "N"))];
+    }
+
+    private static async Task<T> QueryAsync<T>(AdminHost host, Func<FluentCmsDbContext, Task<T>> query)
+    {
+        await using var scope = host.App.Services.CreateAsyncScope();
+        return await query(scope.ServiceProvider.GetRequiredService<FluentCmsDbContext>());
+    }
+
+    [GeneratedRegex("data-asset=\"([0-9a-f]{32})\"")]
+    private static partial Regex AssetRow();
+
+    [GeneratedRegex("name=\"__RequestVerificationToken\" value=\"([^\"]+)\"")]
+    private static partial Regex AntiforgeryToken();
+}
diff --git a/tests/FluentCMS.Tests/Admin/MediaViewsTests.cs b/tests/FluentCMS.Tests/Admin/MediaViewsTests.cs
new file mode 100644
index 000000000..36ba19673
--- /dev/null
+++ b/tests/FluentCMS.Tests/Admin/MediaViewsTests.cs
@@ -0,0 +1,200 @@
+using Bunit;
+using FluentCMS.Admin.Components.Pages;
+using FluentCMS.Admin.Media;
+using FluentCMS.Core.Content;
+using FluentCMS.Core.Media;
+using FluentCMS.Core.Results;
+using Microsoft.AspNetCore.Components;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace FluentCMS.Tests.Admin;
+
+public sealed class MediaViewsTests
+{
+    [Fact]
+    public void The_library_lists_the_newest_first_with_previews_status_and_filters()
+    {
+        var library = new FakeLibrary();
+        using var context = Context(library);
+
+        var cut = context.Render<MediaLibraryView>();
+
+        var rows = cut.FindAll("[data-asset]");
+        Assert.Equal([library.Pdf.Id, library.NoAlt.Id, library.Drill.Id], rows.Select(row => Guid.ParseExact(row.GetAttribute("data-asset")!, "N")));
+        Assert.Null(rows[0].QuerySelector("img"));
+        Assert.Equal($"media/{library.NoAlt.Id}/file", rows[1].QuerySelector("img")!.GetAttribute("src"));
+        Assert.Equal("", rows[1].QuerySelector("img")!.GetAttribute("alt"));
+        Assert.NotNull(rows[1].QuerySelector("[data-status=no-alt-text]"));
+        Assert.Null(rows[2].QuerySelector("[data-status=no-alt-text]"));
+        Assert.NotNull(rows[2].QuerySelector("[data-status=published]"));
+        Assert.Null(rows[0].QuerySelector("[data-status=no-alt-text]"));
+        Assert.Equal(["", "products", "products/drills"], cut.FindAll("[data-folder]").Select(link => link.GetAttribute("data-folder")));
+        Assert.Equal(["hero", "product-shot"], cut.FindAll("[data-tag]").Select(link => link.GetAttribute("data-tag")));
+        Assert.Equal("page", cut.Find("[data-folder='']").GetAttribute("aria-current"));
+        Assert.Equal("rove", cut.Find("tbody").GetAttribute("data-ui"));
+    }
+
+    [Fact]
+    public void A_folder_or_tag_in_the_address_filters_the_list()
+    {
+        var library = new FakeLibrary();
+        using var context = Context(library);
+        context.Services.GetRequiredService<NavigationManager>().NavigateTo("/media?folder=products&sub=true");
+
+        var cut = context.Render<MediaLibraryView>();
+
+        Assert.Equal(new MediaQuery("products", true, null), library.Queries[^1]);
+        Assert.Equal("page", cut.Find("[data-folder=products]").GetAttribute("aria-current"));
+    }
+
+    [Fact]
+    public void The_upload_form_posts_to_the_endpoint_and_shows_a_refused_upload_next_to_its_fields()
+    {
+        using var context = Context(new FakeLibrary());
+        context.Services.GetRequiredService<NavigationManager>().NavigateTo("/media?error=media_content_mismatch,folder_invalid&folder=Bad&alt=A%20drill.");
+
+        var cut = context.Render<MediaLibraryView>();
+
+        var form = cut.Find("[data-testid=media-upload] form");
+        Assert.Equal("media/upload", form.GetAttribute("action"));
+        Assert.Equal("multipart/form-data", form.GetAttribute("enctype"));
+        Assert.Contains("image/png", cut.Find("input[type=file]").GetAttribute("accept"));
+        Assert.Contains("does not match its type", form.TextContent);
+        Assert.Contains("A folder is lowercase words", form.TextContent);
+        Assert.Equal("Bad", cut.Find("input[name=Folder]").GetAttribute("value"));
+        Assert.Equal("A drill.", cut.Find("textarea[name=AltText]").GetAttribute("value"));
+        Assert.Empty(cut.FindAll("[data-testid=media-upload-error]"));
+    }
+
+    [Fact]
+    public void The_asset_page_shows_the_preview_the_details_form_and_where_it_is_used()
+    {
+        var library = new FakeLibrary();
+        using var context = Context(library);
+
+        var cut = context.Render<MediaAssetView>(page => page.Add(p => p.Id, library.Drill.Id));
+
+        Assert.Equal("drill.jpg", cut.Find("h1").TextContent);
+        Assert.Equal($"media/{library.Drill.Id}/file?version=2", cut.Find("[data-testid=media-preview]").GetAttribute("src"));
+        Assert.Equal("A cordless drill.", cut.Find("[data-testid=media-preview]").GetAttribute("alt"));
+        Assert.Equal("2", cut.Find("input[name='Form.BaseVersion']").GetAttribute("value"));
+        Assert.Equal("hero, product-shot", cut.Find("input[name='Form.Tags']").GetAttribute("value"));
+        Assert.Equal("products/drills", cut.Find("input[name='Form.Folder']").GetAttribute("value"));
+        var usage = cut.Find("[data-entry]");
+        Assert.Contains("/hero", usage.TextContent);
+        Assert.Contains("product-page", usage.TextContent);
+        Assert.Empty(cut.FindAll("[data-testid=media-no-alt-text]"));
+    }
+
+    [Fact]
+    public void An_image_without_alt_text_says_so_on_its_page()
+    {
+        var library = new FakeLibrary();
+        using var context = Context(library);
+
+        var cut = context.Render<MediaAssetView>(page => page.Add(p => p.Id, library.NoAlt.Id));
+
+        Assert.NotNull(cut.Find("[data-testid=media-no-alt-text]"));
+        Assert.Equal("", cut.Find("[data-testid=media-preview]").GetAttribute("alt"));
+        Assert.NotNull(cut.Find("[data-testid=media-unused]"));
+    }
+
+    [Fact]
+    public void Uses_logical_utilities_only()
+    {
+        var library = new FakeLibrary();
+        using var context = Context(library);
+
+        var list = context.Render<MediaLibraryView>();
+        var asset = context.Render<MediaAssetView>(page => page.Add(p => p.Id, library.Drill.Id));
+
+        Assert.DoesNotContain(list.FindAll("[class]").Concat(asset.FindAll("[class]")).SelectMany(element => element.ClassList), Utilities.IsPhysical);
+    }
+
+    [Theory]
+    [InlineData("hero, Product-Shot ,, ", new[] { "hero", "Product-Shot" })]
+    [InlineData("", new string[0])]
+    [InlineData(null, new string[0])]
+    public void Tags_are_split_on_commas(string? typed, string[] tags)
+    {
+        Assert.Equal(tags, MediaMetadataFields.SplitTags(typed));
+    }
+
+    [Fact]
+    public void A_refused_upload_returns_its_codes_and_fields_and_blank_texts_mean_none()
+    {
+        var form = new MediaUploadForm { Folder = "Bad", Tags = "a, b", AltText = " ", Caption = "Shown." };
+
+        var query = form.ReturnQuery([new Error("folder_invalid", "x"), new Error("folder_invalid", "y"), new Error("tag_invalid", "z")]);
+        var metadata = new MediaUploadForm { Folder = "products", Tags = "Hero", AltText = " " }.ToMetadata("drill.jpg").Value;
+
+        Assert.Equal("folder_invalid,tag_invalid", query["error"]);
+        Assert.Equal(("Bad", "a, b", " ", "Shown."), (query["folder"], query["tags"], query["alt"], query["caption"]));
+        Assert.Equal(("products", "hero", null), (metadata.Folder, Assert.Single(metadata.Tags), metadata.AltText));
+    }
+
+    private static AdminTestContext Context(FakeLibrary library)
+    {
+        var context = new AdminTestContext();
+        context.Services.AddSingleton<IMediaLibrary>(library);
+        context.Services.AddSingleton<IWhereUsed>(new FakeUsage(library));
+        return context;
+    }
+
+    private sealed class FakeLibrary : IMediaLibrary
+    {
+        public MediaAssetSummary Drill { get; } = new(Guid.CreateVersion7(), 2, 1, "drill.jpg", "image/jpeg", 2048, "products/drills", ["hero", "product-shot"], true);
+
+        public MediaAssetSummary NoAlt { get; } = new(Guid.CreateVersion7(), 1, null, "saw.png", "image/png", 512, "products", [], false);
+
+        public MediaAssetSummary Pdf { get; } = new(Guid.CreateVersion7(), 1, null, "manual.pdf", "application/pdf", 3 * 1024 * 1024, "", ["hero"], false);
+
+        public List<MediaQuery> Queries { get; } = [];
+
+        public Task<IReadOnlyList<MediaAssetSummary>> ListAsync(MediaQuery query, CancellationToken cancellationToken = default)
+        {
+            Queries.Add(query);
+            IReadOnlyList<MediaAssetSummary> all = [Drill, NoAlt, Pdf];
+            return Task.FromResult(all);
+        }
+
+        public Task<IReadOnlyList<string>> FoldersAsync(CancellationToken cancellationToken = default)
+        {
+            return Task.FromResult<IReadOnlyList<string>>(["", "products", "products/drills"]);
+        }
+
+        public Task<Result<MediaAsset>> GetAsync(Guid id, CancellationToken cancellationToken = default)
+        {
+            var summary = new[] { Drill, NoAlt, Pdf }.SingleOrDefault(asset => asset.Id == id);
+            if (summary is null)
+            {
+                return Task.FromResult(Result<MediaAsset>.Failure(MediaErrorCodes.AssetNotFound, "No such asset."));
+            }
+
+            var metadata = new AssetMetadata(summary.FileName, summary.Folder, summary.Tags, summary.HasAltText ? "A cordless drill." : null, null);
+            var version = new MediaAssetVersion(id, summary.LatestVersion, new MediaBlob(summary.ContentType, summary.Length, "00", "local", "key"), metadata, DateTimeOffset.UnixEpoch);
+            return Task.FromResult(Result<MediaAsset>.Success(new MediaAsset(id, Guid.NewGuid(), summary.LatestVersion, summary.PublishedVersion, version)));
+        }
+
+        public Task<Result<MediaAsset>> UploadAsync(NewAsset asset, CancellationToken cancellationToken = default) => throw new NotSupportedException();
+
+        public Task<Result<MediaAsset>> UpdateAsync(Guid id, int baseVersion, AssetMetadata metadata, CancellationToken cancellationToken = default) => throw new NotSupportedException();
+
+        public Task<Result<MediaAssetVersion>> GetVersionAsync(Guid id, int version, CancellationToken cancellationToken = default) => throw new NotSupportedException();
+
+        public Task<Result<MediaContent>> OpenAsync(Guid id, int? version = null, CancellationToken cancellationToken = default) => throw new NotSupportedException();
+    }
+
+    private sealed class FakeUsage(FakeLibrary library) : IWhereUsed
+    {
+        public Task<IReadOnlyList<EntryUsage>> ForMediaAsync(Guid assetId, CancellationToken cancellationToken = default)
+        {
+            IReadOnlyList<EntryUsage> usage = assetId == library.Drill.Id ? [new EntryUsage(Guid.NewGuid(), "product-page", 3, true, true, ["/hero"])] : [];
+            return Task.FromResult(usage);
+        }
+
+        public Task<Result<IReadOnlyList<EntryUsage>>> ForEntryAsync(Guid entryId, CancellationToken cancellationToken = default) => throw new NotSupportedException();
+
+        public Task<Result<IReadOnlyList<EntryUsage>>> ForEntityFieldAsync(Guid entityId, string field, CancellationToken cancellationToken = default) => throw new NotSupportedException();
+    }
+}