diff --git a/src/FluentCMS.Admin/Components/Forms/FieldWidget.razor b/src/FluentCMS.Admin/Components/Forms/FieldWidget.razor
new file mode 100644
index 000000000..3456566a9
--- /dev/null
+++ b/src/FluentCMS.Admin/Components/Forms/FieldWidget.razor
@@ -0,0 +1,78 @@
+@using FluentCMS.Admin.Forms
+@using FluentCMS.Core.Schema
+@inject IStringLocalizer<FieldWidget> L
+
+@* One field of a generated form (FRM-01): the widget its type takes, inside a FormField with the field's description and error. *@
+<FormField Label="@Label" Description="@Description" Error="@Error" Class="@(Wide ? "sm:col-span-2" : null)">
+    @switch (Field.Type)
+    {
+        case "boolean":
+            <div class="flex items-center gap-2">
+                <Checkbox name="@Name" value="true" checked="@(Value == "true")" data-field="@Field.Name" />
+            </div>
+            break;
+        case "richText":
+            <Textarea name="@Name" rows="6" value="@Value" required="@Field.Required" maxlength="@MaxLength" data-field="@Field.Name" />
+            break;
+        case "list":
+        case "json":
+            <Textarea name="@Name" rows="5" value="@Value" required="@Field.Required" dir="ltr" Class="font-mono text-xs" data-field="@Field.Name" />
+            break;
+        case "number":
+            <Input Type="number" step="any" name="@Name" value="@Value" required="@Field.Required" dir="ltr" data-field="@Field.Name" />
+            break;
+        case "dateTime":
+            <Input Type="@(FieldValues.IsDateOnly(Field) ? "date" : "datetime-local")" name="@Name" value="@Value" required="@Field.Required" dir="ltr" data-field="@Field.Name" />
+            break;
+        case "enum":
+            <Select name="@Name" required="@Field.Required" data-field="@Field.Name">
+                <option value="">@L["Choose…"]</option>
+                @foreach (var choice in FieldValues.Strings(Field, "values"))
+                {
+                    <option value="@choice" selected="@(choice == Value)">@choice</option>
+                }
+            </Select>
+            break;
+        case "reference":
+        case "media":
+            <Select name="@Name" required="@Field.Required" data-field="@Field.Name">
+                <option value="">@L["Choose…"]</option>
+                @foreach (var option in Options)
+                {
+                    <option value="@option.Value" selected="@(option.Value == Value)">@option.Label</option>
+                }
+            </Select>
+            break;
+        default:
+            <Input name="@Name" value="@Value" required="@Field.Required" maxlength="@MaxLength" data-field="@Field.Name" />
+            break;
+    }
+</FormField>
+
+@code {
+    [Parameter, EditorRequired] public FieldDefinition Field { get; set; } = null!;
+    [Parameter] public string? Value { get; set; }
+    [Parameter] public string? Error { get; set; }
+    [Parameter] public IReadOnlyList<FieldOption> Options { get; set; } = [];
+
+    private string Name => $"Form.Values[{Field.Name}]";
+
+    private string Label => Field.Required ? L["{0} (required)", Field.Name] : Field.Name;
+
+    private string? Description => Field.Type switch
+    {
+        "dateTime" when !FieldValues.IsDateOnly(Field) => Join(Field.Description, L["In UTC."]),
+        "list" or "json" => Join(Field.Description, L["As JSON."]),
+        _ => Field.Description,
+    };
+
+    private bool Wide => Field.Type is "richText" or "list" or "json";
+
+    private int? MaxLength => Field.Settings.ValueKind == System.Text.Json.JsonValueKind.Object
+        && Field.Settings.TryGetProperty("maxLength", out var max)
+        && max.TryGetInt32(out var length)
+            ? length
+            : null;
+
+    private static string? Join(string? description, string hint) => description is null ? hint : $"{description} {hint}";
+}
diff --git a/src/FluentCMS.Admin/Components/Layout/MainLayout.razor b/src/FluentCMS.Admin/Components/Layout/MainLayout.razor
index 8bb002efb..fe86a4a3e 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="content" class="text-sm text-muted-foreground hover:text-foreground">@L["Content"]</a>
                 <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>
diff --git a/src/FluentCMS.Admin/Components/Pages/ChangeSetView.razor b/src/FluentCMS.Admin/Components/Pages/ChangeSetView.razor
index 7d95ac1b6..31f4a3b20 100644
--- a/src/FluentCMS.Admin/Components/Pages/ChangeSetView.razor
+++ b/src/FluentCMS.Admin/Components/Pages/ChangeSetView.razor
@@ -367,6 +367,7 @@
     {
         "approved" => L["The previous set was approved."].Value,
         "rejected" => L["The previous set was rejected."].Value,
+        "saved" => L["Saved to this new change set. Submit it when it holds every change you want reviewed together."].Value,
         _ => null,
     };
 
diff --git a/src/FluentCMS.Admin/Components/Pages/ContentTypesView.razor b/src/FluentCMS.Admin/Components/Pages/ContentTypesView.razor
new file mode 100644
index 000000000..01f81ddc4
--- /dev/null
+++ b/src/FluentCMS.Admin/Components/Pages/ContentTypesView.razor
@@ -0,0 +1,49 @@
+@page "/content"
+@using FluentCMS.Core.Schema
+@inject IContentTypeDirectory ContentTypes
+@inject IStringLocalizer<ContentTypesView> L
+
+<PageTitle>@L["Content"]</PageTitle>
+
+<h1 id="content-heading" class="text-2xl font-semibold tracking-tight">@L["Content"]</h1>
+<p class="mt-1 text-sm text-muted-foreground">@L["Create and edit entries by hand. Each save opens a change set that is checked and reviewed like an agent's."]</p>
+
+@if (_types.Count == 0)
+{
+    <p class="mt-6 rounded-md border px-3 py-6 text-center text-sm text-muted-foreground" data-testid="content-empty">@L["No content type is defined yet."]</p>
+}
+else
+{
+    <div class="mt-6 rounded-md border">
+        <Table aria-labelledby="content-heading">
+            <TableHeader>
+                <TableRow>
+                    <TableHead>@L["Content type"]</TableHead>
+                    <TableHead>@L["Slug"]</TableHead>
+                    <TableHead>@L["Version"]</TableHead>
+                </TableRow>
+            </TableHeader>
+            <TableBody data-ui="rove">
+                @foreach (var (type, index) in _types.Select((type, index) => (type, index)))
+                {
+                    <TableRow data-type="@type.Slug">
+                        <TableCell>
+                            <a href="@($"content/{type.Slug}")" data-ui="rove-item" tabindex="@(index == 0 ? null : "-1")" class="font-medium underline-offset-4 hover:underline"><bdi>@type.Name</bdi></a>
+                        </TableCell>
+                        <TableCell><bdi dir="ltr" class="font-mono text-xs">@type.Slug</bdi></TableCell>
+                        <TableCell>@type.Version</TableCell>
+                    </TableRow>
+                }
+            </TableBody>
+        </Table>
+    </div>
+}
+
+@code {
+    private IReadOnlyList<ContentTypeSummary> _types = [];
+
+    protected override async Task OnInitializedAsync()
+    {
+        _types = [.. (await ContentTypes.ListAsync()).OrderBy(type => type.Name, StringComparer.CurrentCulture)];
+    }
+}
diff --git a/src/FluentCMS.Admin/Components/Pages/EntriesView.razor b/src/FluentCMS.Admin/Components/Pages/EntriesView.razor
new file mode 100644
index 000000000..7eb4a9864
--- /dev/null
+++ b/src/FluentCMS.Admin/Components/Pages/EntriesView.razor
@@ -0,0 +1,102 @@
+@page "/content/{Slug}"
+@using FluentCMS.Core.Content
+@using FluentCMS.Core.Schema
+@inject IContentTypeDirectory ContentTypes
+@inject IEntryDirectory Entries
+@inject NavigationManager Navigation
+@inject IStringLocalizer<EntriesView> L
+
+<PageTitle>@L["Content"]</PageTitle>
+
+@if (_type is { } type)
+{
+    <nav class="mb-4" aria-label="@L["Content navigation"]">
+        <a href="content" aria-keyshortcuts="B" class="@ButtonVariants.Classes("outline", "sm")">@L["Back to content types"]</a>
+    </nav>
+    <div class="flex flex-wrap items-center justify-between gap-4">
+        <div>
+            <h1 id="entries-heading" class="text-2xl font-semibold tracking-tight"><bdi>@type.Name</bdi></h1>
+            <p class="mt-1 text-sm text-muted-foreground">
+                @(type.Definition.IsEntity ? L["An entity type: each field is a fact with its source, owner and validity."] : L["Entries of this content type."])
+            </p>
+        </div>
+        @if (!type.Definition.IsEntity)
+        {
+            <a href="@($"content/{type.Slug}/new")" aria-keyshortcuts="N" class="@ButtonVariants.Classes()" data-testid="new-entry">@L["New entry"]</a>
+        }
+    </div>
+    @if (type.Definition.IsEntity)
+    {
+        <p class="mt-4 rounded-md border px-3 py-2 text-sm text-muted-foreground" data-testid="entity-form-note">@L["Entity forms, with a source, owner and validity on every fact, come with the next forms slice. Agents write entities with set_entity_fact until then."]</p>
+    }
+
+    @if (_entries.Count == 0)
+    {
+        <p class="mt-6 rounded-md border px-3 py-6 text-center text-sm text-muted-foreground" data-testid="entries-empty">@L["No entry yet."]</p>
+    }
+    else
+    {
+        <div class="mt-6 rounded-md border">
+            <Table aria-labelledby="entries-heading">
+                <TableHeader>
+                    <TableRow>
+                        <TableHead>@L["Entry"]</TableHead>
+                        <TableHead>@L["State"]</TableHead>
+                        <TableHead>@L["Latest version"]</TableHead>
+                        <TableHead>@L["Published version"]</TableHead>
+                    </TableRow>
+                </TableHeader>
+                <TableBody data-ui="rove">
+                    @foreach (var (entry, index) in _entries.Select((entry, index) => (entry, index)))
+                    {
+                        <TableRow data-entry="@entry.Id.ToString("N")">
+                            <TableCell>
+                                @if (type.Definition.IsEntity)
+                                {
+                                    <bdi dir="ltr" class="font-mono text-xs">@entry.Id</bdi>
+                                }
+                                else
+                                {
+                                    <a href="@($"content/{type.Slug}/{entry.Id}")" data-ui="rove-item" tabindex="@(index == 0 ? null : "-1")" class="font-mono text-xs underline-offset-4 hover:underline" dir="ltr">@entry.Id</a>
+                                }
+                            </TableCell>
+                            <TableCell><Badge Variant="outline">@StateLabel(entry.State)</Badge></TableCell>
+                            <TableCell>@entry.LatestVersion</TableCell>
+                            <TableCell>@(entry.PublishedVersion?.ToString(System.Globalization.CultureInfo.CurrentCulture) ?? "–")</TableCell>
+                        </TableRow>
+                    }
+                </TableBody>
+            </Table>
+        </div>
+    }
+}
+
+@code {
+    private ContentType? _type;
+    private IReadOnlyList<EntrySummary> _entries = [];
+
+    [Parameter] public string Slug { get; set; } = string.Empty;
+
+    protected override async Task OnInitializedAsync()
+    {
+        var type = await ContentTypes.GetAsync(Slug);
+        if (!type.IsSuccess)
+        {
+            Navigation.NotFound();
+            return;
+        }
+
+        _type = type.Value;
+        var entries = await Entries.ListAsync(Slug);
+        _entries = entries.IsSuccess ? [.. entries.Value.Reverse()] : [];
+    }
+
+    private string StateLabel(EntryState state) => state switch
+    {
+        EntryState.Draft => L["Draft"],
+        EntryState.InReview => L["In review"],
+        EntryState.Published => L["Published"],
+        EntryState.Reverted => L["Reverted"],
+        _ => L["Archived"],
+    };
+}
diff --git a/src/FluentCMS.Admin/Components/Pages/EntryEditor.razor b/src/FluentCMS.Admin/Components/Pages/EntryEditor.razor
new file mode 100644
index 000000000..bd3934527
--- /dev/null
+++ b/src/FluentCMS.Admin/Components/Pages/EntryEditor.razor
@@ -0,0 +1,258 @@
+@page "/content/{Slug}/new"
+@page "/content/{Slug}/{Id:guid}"
+@using System.Text.Json
+@using System.Text.Json.Nodes
+@using System.Text.RegularExpressions
+@using FluentCMS.Admin.Components.Forms
+@using FluentCMS.Admin.Forms
+@using FluentCMS.Core.ChangeSets
+@using FluentCMS.Core.Content
+@using FluentCMS.Core.Media
+@using FluentCMS.Core.Schema
+@inject IContentTypeDirectory ContentTypes
+@inject IEntryDirectory Entries
+@inject IEntryEdits Edits
+@inject IMediaLibrary Media
+@inject FieldTypeRegistry FieldTypes
+@inject NavigationManager Navigation
+@inject IStringLocalizer<EntryEditor> L
+
+<PageTitle>@L["Content"]</PageTitle>
+
+@if (_type is { } type)
+{
+    <nav class="mb-4" aria-label="@L["Content navigation"]">
+        <a href="@($"content/{type.Slug}")" aria-keyshortcuts="B" class="@ButtonVariants.Classes("outline", "sm")">@L["Back to {0}", type.Name]</a>
+    </nav>
+    <h1 class="text-2xl font-semibold tracking-tight" data-testid="entry-editor" data-version="@(_entry?.LatestVersion)">
+        @(_entry is null ? L["New {0}", type.Name] : L["Edit {0}", type.Name])
+    </h1>
+    <p class="mt-1 text-sm text-muted-foreground">@L["Saving opens a change set with this change. Submit the set when it is ready; checks run and a person reviews it before anything is published."]</p>
+
+    @if (type.Definition.IsEntity)
+    {
+        <p class="mt-6 rounded-md border px-3 py-2 text-sm text-muted-foreground" data-testid="entity-form-note">@L["Entity forms, with a source, owner and validity on every fact, come with the next forms slice."]</p>
+    }
+    else
+    {
+        <form method="post" @onsubmit="SaveAsync" @formname="entry" class="mt-6 grid gap-6" data-testid="entry-form">
+            <AntiforgeryToken />
+            <input type="hidden" name="Form.BaseVersion" value="@(_entry?.LatestVersion ?? 0)" />
+            @if (_formError is not null)
+            {
+                <p role="alert" class="rounded-md border border-destructive/50 px-3 py-2 text-sm text-destructive" data-testid="entry-form-error">@_formError</p>
+            }
+            <Card>
+                <CardHeader>
+                    <CardTitle><h2>@L["Fields"]</h2></CardTitle>
+                </CardHeader>
+                <CardContent Class="grid gap-6 sm:grid-cols-2">
+                    @foreach (var field in type.Definition.Fields)
+                    {
+                        <FieldWidget Field="field" Value="@Shown.Values.GetValueOrDefault(field.Name)" Error="@_fieldErrors.GetValueOrDefault(field.Name)" Options="@_options.GetValueOrDefault(field.Name, [])" />
+                    }
+                </CardContent>
+            </Card>
+            <Card>
+                <CardHeader>
+                    <CardTitle><h2>@L["Change set"]</h2></CardTitle>
+                    <CardDescription>@L["The reviewer reads why you made the change and where it comes from."]</CardDescription>
+                </CardHeader>
+                <CardContent Class="grid gap-6">
+                    <FormField Label="@L["Why (required)"]" Error="@_rationaleError">
+                        <Textarea name="Form.Rationale" rows="2" value="@Shown.Rationale" required />
+                    </FormField>
+                    <FormField Label="@L["Sources"]" Description="@L["Optional, one per line, such as a URL or a file name."]">
+                        <Textarea name="Form.Sources" rows="2" value="@Shown.Sources" dir="ltr" />
+                    </FormField>
+                </CardContent>
+            </Card>
+            <div>
+                <Button Type="submit" data-action="save">@L["Save to a change set"]</Button>
+            </div>
+        </form>
+    }
+}
+
+@code {
+    private ContentType? _type;
+    private Entry? _entry;
+    private Dictionary<string, IReadOnlyList<FieldOption>> _options = new(StringComparer.Ordinal);
+    private Dictionary<string, string> _fieldErrors = new(StringComparer.Ordinal);
+    private string? _rationaleError;
+    private string? _formError;
+
+    [Parameter] public string Slug { get; set; } = string.Empty;
+
+    [Parameter] public Guid? Id { get; set; }
+
+    [SupplyParameterFromForm(FormName = "entry")]
+    private EntryFormModel? Form { get; set; }
+
+    // What the form shows: what was posted after a refused save, the stored values otherwise.
+    private EntryFormModel Shown { get; set; } = new();
+
+    protected override async Task OnInitializedAsync()
+    {
+        if (!await LoadAsync())
+        {
+            Navigation.NotFound();
+            return;
+        }
+
+        await LoadOptionsAsync();
+    }
+
+    private async Task<bool> LoadAsync()
+    {
+        var type = await ContentTypes.GetAsync(Slug);
+        if (!type.IsSuccess)
+        {
+            return false;
+        }
+
+        _type = type.Value;
+        _entry = null;
+        if (Id is { } id)
+        {
+            var entry = await Entries.GetAsync(id);
+            if (!entry.IsSuccess || entry.Value.ContentType != _type.Slug)
+            {
+                // Nothing renders for a page that is not found, the form included.
+                _type = null;
+                return false;
+            }
+
+            _entry = entry.Value;
+        }
+
+        Shown = new EntryFormModel { BaseVersion = _entry?.LatestVersion ?? 0 };
+        foreach (var field in _type.Definition.Fields)
+        {
+            JsonElement? stored = _entry is not null && _entry.Latest.Fields.TryGetProperty(field.Name, out var value) ? value : null;
+            Shown.Values[field.Name] = FieldValues.Show(field, stored);
+        }
+
+        return true;
+    }
+
+    // Until the pickers search (F-SRC), a reference offers every entry of its target type and a media field every asset.
+    private async Task LoadOptionsAsync()
+    {
+        foreach (var field in _type!.Definition.Fields)
+        {
+            if (field.Type == "reference" && FieldValues.Setting(field, "target") is { } target)
+            {
+                var entries = await Entries.ListAsync(target);
+                _options[field.Name] = entries.IsSuccess
+                    ? [.. entries.Value.Select(entry => new FieldOption(entry.Id.ToString(), L["{0} (version {1})", entry.Id.ToString()[..8], entry.LatestVersion]))]
+                    : [];
+            }
+            else if (field.Type == "media")
+            {
+                _options[field.Name] = [.. (await Media.ListAsync(new MediaQuery())).Select(asset => new FieldOption(asset.Id.ToString(), asset.FileName))];
+            }
+        }
+    }
+
+    private async Task SaveAsync()
+    {
+        if (_type is null || Form is null || _type.Definition.IsEntity)
+        {
+            return;
+        }
+
+        var fields = new JsonObject();
+        foreach (var field in _type.Definition.Fields)
+        {
+            var value = FieldValues.Read(field, Form.Values.GetValueOrDefault(field.Name), out var problem);
+            if (problem is not null)
+            {
+                _fieldErrors[field.Name] = Problem(problem);
+                continue;
+            }
+
+            if (value is null)
+            {
+                if (field.Required)
+                {
+                    _fieldErrors[field.Name] = L["Fill in {0}.", field.Name];
+                }
+
+                continue;
+            }
+
+            var element = JsonSerializer.SerializeToElement(value);
+            var errors = FieldTypes.ValidateValue(field.Type, field.Settings, element);
+            if (errors.Count > 0)
+            {
+                _fieldErrors[field.Name] = string.Join(" ", errors.Select(error => error.Message));
+                continue;
+            }
+
+            fields[field.Name] = value;
+        }
+
+        if (string.IsNullOrWhiteSpace(Form.Rationale))
+        {
+            _rationaleError = L["Say why you are making this change."];
+        }
+
+        if (_fieldErrors.Count > 0 || _rationaleError is not null)
+        {
+            Shown = Form;
+            return;
+        }
+
+        var saved = await Edits.SaveAsync(new EntryEdit(
+            _type.Slug,
+            _entry?.Id,
+            _entry is null ? null : Form.BaseVersion,
+            JsonSerializer.SerializeToElement(fields),
+            new NewChangeSet(Form.Rationale!, Form.SourceList())));
+
+        if (saved.IsSuccess)
+        {
+            Navigation.NavigateTo($"sets/{saved.Value.ChangeSet.Id}?done=saved");
+            return;
+        }
+
+        if (saved.Errors.Any(error => error.Code == ContentErrorCodes.VersionConflict))
+        {
+            // The values someone else saved meanwhile are shown, and nothing typed here is applied over them.
+            await LoadAsync();
+            _formError = L["Someone saved this entry since the form was shown. Here it is as it is now; make your change again."];
+            return;
+        }
+
+        Shown = Form;
+        foreach (var error in saved.Errors)
+        {
+            if (FieldOf(error.Message) is { } field && _type.Definition.HasField(field))
+            {
+                _fieldErrors[field] = error.Message[(error.Message.IndexOf(':') + 1)..].Trim();
+            }
+            else
+            {
+                // The error code is the resource key; the service's own message is the text until a resource exists.
+                var localized = L[error.Code];
+                _formError = $"{_formError} {(localized.ResourceNotFound ? error.Message : localized.Value)}".Trim();
+            }
+        }
+    }
+
+    private string Problem(string kind) => kind switch
+    {
+        "number" => L["Enter a number, such as 12 or 4.5."],
+        "date" => L["Enter a date."],
+        "dateTime" => L["Enter a date and a time."],
+        _ => L["Enter valid JSON, such as [\"a\", \"b\"] or {\"key\": 1}."],
+    };
+
+    // The directory names the field a problem is about, as "Field 'price': ...".
+    private static string? FieldOf(string message)
+    {
+        var match = Regex.Match(message, "^Field '([^']+)'");
+        return match.Success ? match.Groups[1].Value : null;
+    }
+}
diff --git a/src/FluentCMS.Admin/Forms/EntryFormModel.cs b/src/FluentCMS.Admin/Forms/EntryFormModel.cs
new file mode 100644
index 000000000..f61dc6568
--- /dev/null
+++ b/src/FluentCMS.Admin/Forms/EntryFormModel.cs
@@ -0,0 +1,22 @@
+namespace FluentCMS.Admin.Forms;
+
+// What a generated form posts: one text per field by name, the reason for the change and its sources, and the version an edit read.
+public sealed class EntryFormModel
+{
+    public Dictionary<string, string?> Values { get; set; } = new(StringComparer.Ordinal);
+
+    public string? Rationale { get; set; }
+
+    // One per line, such as a URL or a file name.
+    public string? Sources { get; set; }
+
+    public int BaseVersion { get; set; }
+
+    public IReadOnlyList<string> SourceList()
+    {
+        return (Sources ?? string.Empty).Split('\n', StringSplitOptions.TrimEntries | StringSplitOptions.RemoveEmptyEntries);
+    }
+}
+
+// A choice a reference or media widget offers: the id it posts and what the person reads.
+public sealed record FieldOption(string Value, string Label);
diff --git a/src/FluentCMS.Admin/Forms/FieldValues.cs b/src/FluentCMS.Admin/Forms/FieldValues.cs
new file mode 100644
index 000000000..2855ffb85
--- /dev/null
+++ b/src/FluentCMS.Admin/Forms/FieldValues.cs
@@ -0,0 +1,123 @@
+using System.Globalization;
+using System.Text.Json;
+using System.Text.Json.Nodes;
+using FluentCMS.Core.Schema;
+
+namespace FluentCMS.Admin.Forms;
+
+// Turns what a generated form posts for a field into the field's JSON value, and a stored value back into what its widget shows
+// (FRM-01). Every widget posts text; the field type then checks the value as it checks an agent's.
+public static class FieldValues
+{
+    public const string DateTimeFormat = "yyyy-MM-ddTHH:mm";
+
+    public static bool IsDateOnly(FieldDefinition field)
+    {
+        return field.Settings.ValueKind == JsonValueKind.Object
+            && field.Settings.TryGetProperty("dateOnly", out var flag)
+            && flag.ValueKind == JsonValueKind.True;
+    }
+
+    public static string? Setting(FieldDefinition field, string name)
+    {
+        return field.Settings.ValueKind == JsonValueKind.Object
+            && field.Settings.TryGetProperty(name, out var value)
+            && value.ValueKind == JsonValueKind.String
+                ? value.GetString()
+                : null;
+    }
+
+    public static IReadOnlyList<string> Strings(FieldDefinition field, string name)
+    {
+        return field.Settings.ValueKind == JsonValueKind.Object
+            && field.Settings.TryGetProperty(name, out var value)
+            && value.ValueKind == JsonValueKind.Array
+                ? [.. value.EnumerateArray().Where(item => item.ValueKind == JsonValueKind.String).Select(item => item.GetString()!)]
+                : [];
+    }
+
+    // Null when the field was left empty. A problem is set when the text cannot be the field's value at all.
+    public static JsonNode? Read(FieldDefinition field, string? posted, out string? problem)
+    {
+        problem = null;
+        var text = posted?.Trim() ?? string.Empty;
+
+        if (field.Type == "boolean")
+        {
+            return JsonValue.Create(text == "true");
+        }
+
+        if (text.Length == 0)
+        {
+            return null;
+        }
+
+        switch (field.Type)
+        {
+            case "number":
+                if (decimal.TryParse(text, NumberStyles.Float, CultureInfo.InvariantCulture, out var number))
+                {
+                    return JsonValue.Create(number);
+                }
+
+                problem = "number";
+                return null;
+
+            case "dateTime" when IsDateOnly(field):
+                if (DateOnly.TryParseExact(text, "yyyy-MM-dd", CultureInfo.InvariantCulture, DateTimeStyles.None, out var date))
+                {
+                    return JsonValue.Create(date.ToString("yyyy-MM-dd", CultureInfo.InvariantCulture));
+                }
+
+                problem = "date";
+                return null;
+
+            case "dateTime":
+                // The browser's date-time input has no offset; the form says the time is UTC.
+                if (DateTime.TryParseExact(text, [DateTimeFormat, DateTimeFormat + ":ss"], CultureInfo.InvariantCulture, DateTimeStyles.AssumeUniversal | DateTimeStyles.AdjustToUniversal, out var time))
+                {
+                    return JsonValue.Create(time.ToString("yyyy-MM-ddTHH:mm:ssZ", CultureInfo.InvariantCulture));
+                }
+
+                problem = "dateTime";
+                return null;
+
+            case "list":
+            case "json":
+                try
+                {
+                    return JsonNode.Parse(text);
+                }
+                catch (JsonException)
+                {
+                    problem = "json";
+                    return null;
+                }
+
+            default:
+                // Text, rich text, an enum value, or the id a reference or media field holds.
+                return JsonValue.Create(posted);
+        }
+    }
+
+    // What the widget shows for a stored value.
+    public static string? Show(FieldDefinition field, JsonElement? value)
+    {
+        if (value is not { } stored || stored.ValueKind == JsonValueKind.Null)
+        {
+            return null;
+        }
+
+        return field.Type switch
+        {
+            "boolean" => stored.ValueKind == JsonValueKind.True ? "true" : null,
+            "number" => stored.GetRawText(),
+            "dateTime" when !IsDateOnly(field) && DateTimeOffset.TryParse(stored.GetString(), CultureInfo.InvariantCulture, DateTimeStyles.None, out var time)
+                => time.UtcDateTime.ToString(DateTimeFormat, CultureInfo.InvariantCulture),
+            "list" or "json" => JsonSerializer.Serialize(stored, Indented),
+            _ => stored.ValueKind == JsonValueKind.String ? stored.GetString() : stored.GetRawText(),
+        };
+    }
+
+    private static readonly JsonSerializerOptions Indented = new() { WriteIndented = true, Encoder = System.Text.Encodings.Web.JavaScriptEncoder.UnsafeRelaxedJsonEscaping };
+}
diff --git a/src/FluentCMS.Core/Content/EntryEdits.cs b/src/FluentCMS.Core/Content/EntryEdits.cs
new file mode 100644
index 000000000..e241e2a90
--- /dev/null
+++ b/src/FluentCMS.Core/Content/EntryEdits.cs
@@ -0,0 +1,66 @@
+using FluentCMS.Core.ChangeSets;
+using FluentCMS.Core.Persistence;
+using FluentCMS.Core.Results;
+using FluentCMS.Core.Schema;
+
+namespace FluentCMS.Core.Content;
+
+// The directories find their expected failures before their own units of work, so leaving this one uncommitted undoes them all:
+// no version a form writes exists outside the change set that proposes it (AUD-N1, CHG-01).
+internal sealed class EntryEdits(
+    IUnitOfWork unitOfWork,
+    IEntryDirectory entries,
+    IContentTypeDirectory contentTypes,
+    IChangeSetDirectory changeSets) : IEntryEdits
+{
+    public async Task<Result<SavedEntryEdit>> SaveAsync(EntryEdit edit, CancellationToken cancellationToken = default)
+    {
+        ArgumentNullException.ThrowIfNull(edit);
+
+        if (edit.EntryId is not null && edit.BaseVersion is null)
+        {
+            return Result<SavedEntryEdit>.Failure(ContentErrorCodes.VersionConflict, "An update names the version it was made from.");
+        }
+
+        await using var scope = await unitOfWork.BeginAsync(cancellationToken);
+
+        var entry = edit.EntryId is { } id
+            ? await entries.UpdateAsync(id, edit.BaseVersion!.Value, edit.Fields, cancellationToken)
+            : await entries.CreateAsync(new NewEntry(edit.ContentType, edit.Fields), cancellationToken);
+        if (!entry.IsSuccess)
+        {
+            return Result<SavedEntryEdit>.Failure(entry.Errors);
+        }
+
+        var type = await contentTypes.GetAsync(entry.Value.ContentType, cancellationToken);
+        if (!type.IsSuccess)
+        {
+            return Result<SavedEntryEdit>.Failure(type.Errors);
+        }
+
+        // An update is based on what is published, which publishing it replaces; a draft never published is still a create.
+        var kind = type.Value.Definition.IsEntity ? ItemKind.Entity : ItemKind.Entry;
+        var operation = entry.Value.PublishedVersion is { } published
+            ? ChangeOperation.Create(OperationKind.Update, kind, entry.Value.Id, published, entry.Value.LatestVersion)
+            : ChangeOperation.Create(OperationKind.Create, kind, entry.Value.Id, null, entry.Value.LatestVersion);
+        if (!operation.IsSuccess)
+        {
+            return Result<SavedEntryEdit>.Failure(operation.Errors);
+        }
+
+        var opened = await changeSets.OpenAsync(edit.ChangeSet, cancellationToken);
+        if (!opened.IsSuccess)
+        {
+            return Result<SavedEntryEdit>.Failure(opened.Errors);
+        }
+
+        var set = await changeSets.AddOperationAsync(opened.Value.Id, operation.Value, cancellationToken);
+        if (!set.IsSuccess)
+        {
+            return Result<SavedEntryEdit>.Failure(set.Errors);
+        }
+
+        await scope.CommitAsync(cancellationToken);
+        return Result<SavedEntryEdit>.Success(new SavedEntryEdit(entry.Value, set.Value));
+    }
+}
diff --git a/src/FluentCMS.Core/Content/IEntryEdits.cs b/src/FluentCMS.Core/Content/IEntryEdits.cs
new file mode 100644
index 000000000..24f105d17
--- /dev/null
+++ b/src/FluentCMS.Core/Content/IEntryEdits.cs
@@ -0,0 +1,17 @@
+using System.Text.Json;
+using FluentCMS.Core.ChangeSets;
+using FluentCMS.Core.Results;
+
+namespace FluentCMS.Core.Content;
+
+// A person's create or update of an entry from a generated form (FRM-01, FRM-02). The version and its operation go into a change set
+// that the save opens, in one unit of work, so a person's edit is reviewed like an agent's: the set stays open until it is submitted.
+public interface IEntryEdits
+{
+    Task<Result<SavedEntryEdit>> SaveAsync(EntryEdit edit, CancellationToken cancellationToken = default);
+}
+
+// EntryId and BaseVersion name the entry and the version the form read for an update, and are null for a create.
+public sealed record EntryEdit(string ContentType, Guid? EntryId, int? BaseVersion, JsonElement Fields, NewChangeSet ChangeSet);
+
+public sealed record SavedEntryEdit(Entry Entry, ChangeSet ChangeSet);
diff --git a/src/FluentCMS.Core/CoreServiceCollectionExtensions.cs b/src/FluentCMS.Core/CoreServiceCollectionExtensions.cs
index df0475845..5a5ac3061 100644
--- a/src/FluentCMS.Core/CoreServiceCollectionExtensions.cs
+++ b/src/FluentCMS.Core/CoreServiceCollectionExtensions.cs
@@ -1,6 +1,7 @@
 using FluentCMS.Core.Agents;
 using FluentCMS.Core.Audit;
 using FluentCMS.Core.Checks;
+using FluentCMS.Core.Content;
 using FluentCMS.Core.Desk;
 using FluentCMS.Core.Extensions;
 using FluentCMS.Core.Media;
@@ -44,6 +45,9 @@ public static IServiceCollection AddFluentCmsCore(this IServiceCollection servic
         // Reads through IChangeSetLists and IEntityFacts, which Infrastructure provides.
         services.AddScoped<IDeskQueues, DeskQueues>();
 
+        // Writes through IEntryDirectory, IContentTypeDirectory and IChangeSetDirectory in one unit of work, which Infrastructure provides.
+        services.AddScoped<IEntryEdits, EntryEdits>();
+
         return services;
     }
 }
diff --git a/tests/FluentCMS.IntegrationTests/Browser/AccessibilityTests.cs b/tests/FluentCMS.IntegrationTests/Browser/AccessibilityTests.cs
index d3080837f..ce53a53b7 100644
--- a/tests/FluentCMS.IntegrationTests/Browser/AccessibilityTests.cs
+++ b/tests/FluentCMS.IntegrationTests/Browser/AccessibilityTests.cs
@@ -27,7 +27,7 @@ public async Task The_showcase_desk_and_set_view_have_no_wcag_21_aa_violations()
             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", "/media", $"/media/{asset}"];
+        string[] paths = ["/ui", "/", "/?queue=stale-facts", $"/sets/{set.Id}?queue=awaiting-me", "/security", "/media", $"/media/{asset}", "/content", "/content/product", "/content/product/new"];
         var violations = new List<string>();
         foreach (var theme in new[] { "light", "dark" })
         {
diff --git a/tests/FluentCMS.IntegrationTests/Forms/EntryEditsTests.cs b/tests/FluentCMS.IntegrationTests/Forms/EntryEditsTests.cs
new file mode 100644
index 000000000..a40238c7e
--- /dev/null
+++ b/tests/FluentCMS.IntegrationTests/Forms/EntryEditsTests.cs
@@ -0,0 +1,81 @@
+using System.Text.Json;
+using FluentCMS.Core.ChangeSets;
+using FluentCMS.Core.Content;
+using FluentCMS.Core.Identity;
+using FluentCMS.Infrastructure.Persistence;
+using FluentCMS.IntegrationTests.Content;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace FluentCMS.IntegrationTests.Forms;
+
+public sealed class EntryEditsTests
+{
+    [Theory]
+    [InlineData(DatabaseProviders.Sqlite)]
+    [PostgresData]
+    public async Task A_person_saves_an_entry_into_a_new_open_set_that_holds_its_create_operation(string provider)
+    {
+        await using var scenario = await CreateAsync(provider);
+
+        var saved = (await SaveAsync(scenario, new EntryEdit("blog-post", null, null, Json("""{"title": "Hello"}"""), new NewChangeSet("Write the welcome post.", ["notes/welcome.md"])))).Value;
+
+        Assert.Equal(ChangeSetState.Open, saved.ChangeSet.State);
+        Assert.Equal(("Write the welcome post.", "notes/welcome.md"), (saved.ChangeSet.Rationale, Assert.Single(saved.ChangeSet.Sources)));
+        Assert.IsType<UserInitiator>(saved.ChangeSet.Initiator);
+        var operation = Assert.Single(saved.ChangeSet.Operations);
+        Assert.Equal((OperationKind.Create, ItemKind.Entry, saved.Entry.Id, (int?)null, (int?)1), (operation.Kind, operation.ItemKind, operation.ItemId, operation.BaseVersion, operation.ProposedVersion));
+    }
+
+    [Theory]
+    [InlineData(DatabaseProviders.Sqlite)]
+    [PostgresData]
+    public async Task An_edit_of_a_draft_never_published_is_a_create_of_its_next_version(string provider)
+    {
+        await using var scenario = await CreateAsync(provider);
+        var first = (await SaveAsync(scenario, new EntryEdit("blog-post", null, null, Json("""{"title": "Hello"}"""), new NewChangeSet("Draft.", [])))).Value;
+
+        var second = (await SaveAsync(scenario, new EntryEdit("blog-post", first.Entry.Id, 1, Json("""{"title": "Hello again"}"""), new NewChangeSet("Retitle.", [])))).Value;
+        var stale = await SaveAsync(scenario, new EntryEdit("blog-post", first.Entry.Id, 1, Json("""{"title": "Lost"}"""), new NewChangeSet("Retitle.", [])));
+
+        var operation = Assert.Single(second.ChangeSet.Operations);
+        Assert.Equal((OperationKind.Create, (int?)2), (operation.Kind, operation.ProposedVersion));
+        Assert.NotEqual(first.ChangeSet.Id, second.ChangeSet.Id);
+        Assert.Equal(ContentErrorCodes.VersionConflict, Assert.Single(stale.Errors).Code);
+    }
+
+    // The version is written first; a set that cannot be opened rolls it back, so no version exists outside a set (AUD-N1).
+    [Theory]
+    [InlineData(DatabaseProviders.Sqlite)]
+    [PostgresData]
+    public async Task A_refused_save_stores_neither_the_version_nor_a_set(string provider)
+    {
+        await using var scenario = await CreateAsync(provider);
+
+        var noReason = await SaveAsync(scenario, new EntryEdit("blog-post", null, null, Json("""{"title": "Hello"}"""), new NewChangeSet(" ", [])));
+        var invalid = await SaveAsync(scenario, new EntryEdit("blog-post", null, null, Json("""{"title": 5}"""), new NewChangeSet("Why.", [])));
+
+        Assert.Equal(ChangeSetErrorCodes.RationaleMissing, Assert.Single(noReason.Errors).Code);
+        Assert.NotEmpty(invalid.Errors);
+        Assert.Empty(await scenario.EntryRowsAsync());
+        Assert.Equal(0, await scenario.Schema.QueryAsync(context => context.ChangeSets.CountAsync(row => row.Rationale != "content-model")));
+    }
+
+    private static async Task<EntryScenario> CreateAsync(string provider)
+    {
+        var scenario = await EntryScenario.CreateAsync(provider);
+        await scenario.Schema.CreateReferenceModelAsync();
+        return scenario;
+    }
+
+    private static async Task<FluentCMS.Core.Results.Result<SavedEntryEdit>> SaveAsync(EntryScenario scenario, EntryEdit edit)
+    {
+        await using var scope = scenario.Services.CreateAsyncScope();
+        return await scope.ServiceProvider.GetRequiredService<IEntryEdits>().SaveAsync(edit);
+    }
+
+    private static JsonElement Json(string json)
+    {
+        return JsonSerializer.Deserialize<JsonElement>(json);
+    }
+}
diff --git a/tests/FluentCMS.IntegrationTests/Forms/EntryFormScreenTests.cs b/tests/FluentCMS.IntegrationTests/Forms/EntryFormScreenTests.cs
new file mode 100644
index 000000000..1768adb8a
--- /dev/null
+++ b/tests/FluentCMS.IntegrationTests/Forms/EntryFormScreenTests.cs
@@ -0,0 +1,189 @@
+using System.Net;
+using System.Text.Json;
+using FluentCMS.Core.ChangeSets;
+using FluentCMS.Core.Content;
+using FluentCMS.Core.Media;
+using FluentCMS.Core.Schema;
+using FluentCMS.IntegrationTests.Media;
+
+namespace FluentCMS.IntegrationTests.Forms;
+
+public sealed class EntryFormScreenTests
+{
+    [Fact]
+    public async Task A_person_creates_an_entry_with_every_field_type_and_lands_on_its_open_set()
+    {
+        using var install = new TemporaryInstall();
+        await using var host = await AdminHost.StartAsync(install);
+        var ownerId = await host.CreateFirstAdministratorAsync();
+        var (category, asset) = await KitchenSinkAsync(host, ownerId);
+        await host.SignInAsync(AdminHost.Owner);
+
+        var form = await host.Client.GetStringAsync("/content/kitchen-sink/new");
+        Assert.Contains("name=\"Form.Values[title]\"", form);
+        Assert.Contains("type=\"datetime-local\"", form);
+        Assert.Contains("type=\"date\"", form);
+        Assert.Contains($"<option value=\"{category}\"", form);
+        Assert.Contains($"<option value=\"{asset}\">hero.jpg</option>", form);
+
+        var saved = await host.SubmitAsync("/content/kitchen-sink/new", "entry", new Dictionary<string, string>
+        {
+            ["Form.Values[title]"] = "Cordless drill",
+            ["Form.Values[body]"] = "A **light** drill.",
+            ["Form.Values[price]"] = "129.5",
+            ["Form.Values[active]"] = "true",
+            ["Form.Values[launch]"] = "2026-11-01T09:30",
+            ["Form.Values[day]"] = "2026-11-02",
+            ["Form.Values[colour]"] = "red",
+            ["Form.Values[category]"] = category.ToString(),
+            ["Form.Values[hero]"] = asset.ToString(),
+            ["Form.Values[tags]"] = """["power", "tools"]""",
+            ["Form.Values[extra]"] = """{"warranty": 2}""",
+            ["Form.Rationale"] = "Add the drill for the launch.",
+            ["Form.Sources"] = "https://example.com/catalog\nexports/drills.csv",
+            ["Form.BaseVersion"] = "0",
+        });
+
+        Assert.Equal(HttpStatusCode.Redirect, saved.StatusCode);
+        var location = host.LocationOf(saved)!;
+        Assert.Matches("^/sets/[0-9a-f-]{36}\\?done=saved$", location);
+        var set = await host.AsUserAsync<IChangeSetDirectory, ChangeSet>(ownerId, async sets => (await sets.GetAsync(Guid.Parse(location[6..42]))).Value);
+        Assert.Equal((ChangeSetState.Open, "Add the drill for the launch."), (set.State, set.Rationale));
+        Assert.Equal(["https://example.com/catalog", "exports/drills.csv"], set.Sources);
+        var operation = Assert.Single(set.Operations);
+        Assert.Equal((OperationKind.Create, ItemKind.Entry), (operation.Kind, operation.ItemKind));
+        var entry = await host.AsUserAsync<IEntryDirectory, Entry>(ownerId, async entries => (await entries.GetAsync(operation.ItemId)).Value);
+        var fields = entry.Latest.Fields;
+        Assert.Equal(129.5m, fields.GetProperty("price").GetDecimal());
+        Assert.True(fields.GetProperty("active").GetBoolean());
+        Assert.Equal("2026-11-01T09:30:00Z", fields.GetProperty("launch").GetString());
+        Assert.Equal("2026-11-02", fields.GetProperty("day").GetString());
+        Assert.Equal(["power", "tools"], fields.GetProperty("tags").EnumerateArray().Select(tag => tag.GetString()));
+        Assert.Equal(2, fields.GetProperty("extra").GetProperty("warranty").GetInt32());
+        Assert.Contains("data-testid=\"review-done\"", await host.Client.GetStringAsync(location));
+
+        // Editing shows the stored values, and the save opens a second set with the next version.
+        var edit = await host.Client.GetStringAsync($"/content/kitchen-sink/{entry.Id}");
+        Assert.Contains("value=\"2026-11-01T09:30\"", edit);
+        Assert.Contains("value=\"129.5\"", edit);
+        Assert.Contains("<option value=\"red\" selected", edit);
+        var edited = await host.SubmitAsync($"/content/kitchen-sink/{entry.Id}", "entry", new Dictionary<string, string>
+        {
+            ["Form.Values[title]"] = "Cordless drill, 18 V",
+            ["Form.Rationale"] = "Name the voltage.",
+            ["Form.BaseVersion"] = "1",
+        });
+        var second = await host.AsUserAsync<IChangeSetDirectory, ChangeSet>(ownerId, async sets => (await sets.GetAsync(Guid.Parse(host.LocationOf(edited)![6..42]))).Value);
+        Assert.Equal((OperationKind.Create, (int?)2), (Assert.Single(second.Operations).Kind, second.Operations[0].ProposedVersion));
+    }
+
+    [Fact]
+    public async Task Problems_show_next_to_their_fields_and_nothing_is_stored()
+    {
+        using var install = new TemporaryInstall();
+        await using var host = await AdminHost.StartAsync(install);
+        var ownerId = await host.CreateFirstAdministratorAsync();
+        await KitchenSinkAsync(host, ownerId);
+        await host.SignInAsync(AdminHost.Owner);
+
+        var refused = await host.SubmitAsync("/content/kitchen-sink/new", "entry", new Dictionary<string, string>
+        {
+            ["Form.Values[title]"] = "",
+            ["Form.Values[price]"] = "cheap",
+            ["Form.Values[launch]"] = "soon",
+            ["Form.Values[colour]"] = "purple",
+            ["Form.Values[extra]"] = "{",
+            ["Form.Rationale"] = "",
+            ["Form.BaseVersion"] = "0",
+        });
+        var page = await refused.Content.ReadAsStringAsync();
+
+        Assert.Equal(HttpStatusCode.OK, refused.StatusCode);
+        Assert.Contains("Fill in title.", page);
+        Assert.Contains("Enter a number", page);
+        Assert.Contains("Enter a date and a time.", page);
+        Assert.Contains("Enter valid JSON", page);
+        Assert.Contains("Say why you are making this change.", page);
+        Assert.Contains("value=\"cheap\"", page);
+        Assert.True(System.Text.RegularExpressions.Regex.Count(page, "aria-invalid=\"true\"") >= 5);
+        Assert.Empty((await host.AsUserAsync<IEntryDirectory, IReadOnlyList<EntrySummary>>(ownerId, async entries => (await entries.ListAsync("kitchen-sink")).Value)));
+    }
+
+    [Fact]
+    public async Task A_form_from_an_older_version_is_refused_and_shows_the_entry_as_it_is_now()
+    {
+        using var install = new TemporaryInstall();
+        await using var host = await AdminHost.StartAsync(install);
+        var ownerId = await host.CreateFirstAdministratorAsync();
+        await KitchenSinkAsync(host, ownerId);
+        var entry = await host.AsUserAsync<IEntryDirectory, Entry>(ownerId, async entries =>
+            (await entries.CreateAsync(new NewEntry("kitchen-sink", Json("""{"title": "First"}""")))).Value);
+        await host.AsUserAsync<IEntryDirectory, Entry>(ownerId, async entries =>
+            (await entries.UpdateAsync(entry.Id, 1, Json("""{"title": "Second"}"""))).Value);
+        await host.SignInAsync(AdminHost.Owner);
+
+        var stale = await host.SubmitAsync($"/content/kitchen-sink/{entry.Id}", "entry", new Dictionary<string, string>
+        {
+            ["Form.Values[title]"] = "Mine",
+            ["Form.Rationale"] = "Retitle.",
+            ["Form.BaseVersion"] = "1",
+        });
+        var page = await stale.Content.ReadAsStringAsync();
+
+        Assert.Contains("data-testid=\"entry-form-error\"", page);
+        Assert.Contains("value=\"Second\"", page);
+        Assert.Contains("data-version=\"2\"", page);
+    }
+
+    [Fact]
+    public async Task The_content_pages_list_types_and_entries_and_need_a_signed_in_person()
+    {
+        using var install = new TemporaryInstall();
+        await using var host = await AdminHost.StartAsync(install);
+        var ownerId = await host.CreateFirstAdministratorAsync();
+        await KitchenSinkAsync(host, ownerId);
+
+        Assert.StartsWith("/sign-in?ReturnUrl=", host.LocationOf(await host.Client.GetAsync("/content/kitchen-sink/new")));
+        await host.SignInAsync(AdminHost.Owner);
+
+        Assert.Contains("data-type=\"kitchen-sink\"", await host.Client.GetStringAsync("/content"));
+        var entries = await host.Client.GetStringAsync("/content/category");
+        Assert.Contains("data-entry=", entries);
+        Assert.Equal(HttpStatusCode.NotFound, (await host.Client.GetAsync("/content/nothing")).StatusCode);
+        Assert.Equal(HttpStatusCode.NotFound, (await host.Client.GetAsync($"/content/kitchen-sink/{Guid.NewGuid()}")).StatusCode);
+    }
+
+    // A type with one field of every built-in type, a category entry to reference and an asset to show.
+    private static async Task<(Guid Category, Guid Asset)> KitchenSinkAsync(AdminHost host, Guid ownerId)
+    {
+        await host.AsUserAsync<IContentTypeDirectory, ContentType>(ownerId, async types => (await types.CreateAsync(new NewContentType(
+            "Category", "category", new ContentTypeDefinition([new FieldDefinition("name", "text", required: true)])))).Value);
+        await host.AsUserAsync<IContentTypeDirectory, ContentType>(ownerId, async types => (await types.CreateAsync(new NewContentType(
+            "Kitchen sink",
+            "kitchen-sink",
+            new ContentTypeDefinition(
+            [
+                new FieldDefinition("title", "text", required: true, settings: Json("""{"maxLength": 80}""")),
+                new FieldDefinition("body", "richText"),
+                new FieldDefinition("price", "number"),
+                new FieldDefinition("active", "boolean"),
+                new FieldDefinition("launch", "dateTime"),
+                new FieldDefinition("day", "dateTime", settings: Json("""{"dateOnly": true}""")),
+                new FieldDefinition("colour", "enum", settings: Json("""{"values": ["red", "blue"]}""")),
+                new FieldDefinition("category", "reference", settings: Json("""{"target": "category"}""")),
+                new FieldDefinition("hero", "media"),
+                new FieldDefinition("tags", "list", settings: Json("""{"itemType": "text"}""")),
+                new FieldDefinition("extra", "json"),
+            ])))).Value);
+        var category = await host.AsUserAsync<IEntryDirectory, Entry>(ownerId, async entries =>
+            (await entries.CreateAsync(new NewEntry("category", Json("""{"name": "Tools"}""")))).Value);
+        var asset = await host.AsUserAsync<IMediaLibrary, MediaAsset>(ownerId, async library => (await library.UploadAsync(new NewAsset(
+            new MemoryStream(MediaFiles.Jpeg()), "image/jpeg", AssetMetadata.Create("hero.jpg", null, null, "A drill.", null).Value))).Value);
+        return (category.Id, asset.Id);
+    }
+
+    private static JsonElement Json(string json)
+    {
+        return JsonSerializer.Deserialize<JsonElement>(json);
+    }
+}
diff --git a/tests/FluentCMS.Tests/Admin/GeneratedFormTests.cs b/tests/FluentCMS.Tests/Admin/GeneratedFormTests.cs
new file mode 100644
index 000000000..d31cf4362
--- /dev/null
+++ b/tests/FluentCMS.Tests/Admin/GeneratedFormTests.cs
@@ -0,0 +1,109 @@
+using System.Text.Json;
+using Bunit;
+using FluentCMS.Admin.Components.Forms;
+using FluentCMS.Admin.Forms;
+using FluentCMS.Core.Schema;
+
+namespace FluentCMS.Tests.Admin;
+
+public sealed class GeneratedFormTests
+{
+    [Theory]
+    [InlineData("text", "{}", " Hello ", "\" Hello \"")]
+    [InlineData("richText", "{}", "A **b**", "\"A **b**\"")]
+    [InlineData("number", "{}", "129.5", "129.5")]
+    [InlineData("number", "{}", "-3", "-3")]
+    [InlineData("boolean", "{}", "true", "true")]
+    [InlineData("boolean", "{}", null, "false")]
+    [InlineData("dateTime", "{}", "2026-11-01T09:30", "\"2026-11-01T09:30:00Z\"")]
+    [InlineData("dateTime", """{"dateOnly": true}""", "2026-11-02", "\"2026-11-02\"")]
+    [InlineData("enum", """{"values": ["red"]}""", "red", "\"red\"")]
+    [InlineData("list", """{"itemType": "text"}""", """["a", "b"]""", """["a","b"]""")]
+    [InlineData("json", "{}", """{"k": 1}""", """{"k":1}""")]
+    public void A_posted_text_becomes_the_fields_json_value(string type, string settings, string? posted, string json)
+    {
+        var value = FieldValues.Read(Field(type, settings), posted, out var problem);
+
+        Assert.Null(problem);
+        Assert.Equal(json, value!.ToJsonString());
+    }
+
+    [Theory]
+    [InlineData("number", "{}", "cheap", "number")]
+    [InlineData("dateTime", "{}", "soon", "dateTime")]
+    [InlineData("dateTime", """{"dateOnly": true}""", "31/12/2026", "date")]
+    [InlineData("json", "{}", "{", "json")]
+    [InlineData("list", """{"itemType": "text"}""", "[1,", "json")]
+    public void A_text_that_cannot_be_the_value_is_a_problem(string type, string settings, string posted, string expected)
+    {
+        Assert.Null(FieldValues.Read(Field(type, settings), posted, out var problem));
+        Assert.Equal(expected, problem);
+    }
+
+    [Theory]
+    [InlineData("text")]
+    [InlineData("number")]
+    [InlineData("reference")]
+    public void An_empty_field_has_no_value(string type)
+    {
+        Assert.Null(FieldValues.Read(Field(type, "{}"), "  ", out var problem));
+        Assert.Null(problem);
+    }
+
+    [Theory]
+    [InlineData("dateTime", "{}", "\"2026-11-01T11:30:00+02:00\"", "2026-11-01T09:30")]
+    [InlineData("boolean", "{}", "true", "true")]
+    [InlineData("boolean", "{}", "false", null)]
+    [InlineData("number", "{}", "4.50", "4.50")]
+    [InlineData("text", "{}", "\"Hello\"", "Hello")]
+    [InlineData("json", "{}", """{"k":"ä"}""", "{\n  \"k\": \"ä\"\n}")]
+    public void A_stored_value_shows_as_its_widget_takes_it(string type, string settings, string stored, string? shown)
+    {
+        Assert.Equal(shown, FieldValues.Show(Field(type, settings), JsonDocument.Parse(stored).RootElement)?.ReplaceLineEndings("\n"));
+    }
+
+    [Theory]
+    [InlineData("text", "input[type=text]")]
+    [InlineData("richText", "textarea")]
+    [InlineData("number", "input[type=number]")]
+    [InlineData("boolean", "input[type=checkbox]")]
+    [InlineData("dateTime", "input[type=datetime-local]")]
+    [InlineData("enum", "select")]
+    [InlineData("reference", "select")]
+    [InlineData("media", "select")]
+    [InlineData("list", "textarea")]
+    [InlineData("json", "textarea")]
+    public void Each_field_type_renders_its_widget_inside_a_form_field(string type, string selector)
+    {
+        using var context = new AdminTestContext();
+
+        var cut = context.Render<FieldWidget>(widget => widget
+            .Add(w => w.Field, Field(type, type == "enum" ? """{"values": ["red", "blue"]}""" : "{}", required: true))
+            .Add(w => w.Options, [new FieldOption("0192f3a1-7c2e-7a4b-9d3e-1f2a3b4c5d6e", "Tools")])
+            .Add(w => w.Error, "Wrong."));
+
+        var control = cut.Find(selector);
+        Assert.Equal("Form.Values[field]", control.GetAttribute("name"));
+        Assert.Equal(cut.Find("label").GetAttribute("for"), control.GetAttribute("id"));
+        Assert.Contains("(required)", cut.Find("label").TextContent);
+        Assert.Contains("Wrong.", cut.Find("[data-slot=form-message]").TextContent);
+    }
+
+    [Fact]
+    public void An_enum_offers_its_values_and_marks_the_stored_one()
+    {
+        using var context = new AdminTestContext();
+
+        var cut = context.Render<FieldWidget>(widget => widget
+            .Add(w => w.Field, Field("enum", """{"values": ["red", "blue"]}"""))
+            .Add(w => w.Value, "blue"));
+
+        Assert.Equal(["", "red", "blue"], cut.FindAll("option").Select(option => option.GetAttribute("value")));
+        Assert.True(cut.Find("option[value=blue]").HasAttribute("selected"));
+    }
+
+    private static FieldDefinition Field(string type, string settings, bool required = false)
+    {
+        return new FieldDefinition("field", type, required, JsonDocument.Parse(settings).RootElement);
+    }
+}