diff --git a/src/DiffEngineTray.Tests/DiffRunnerViewerFocusRaceTest.cs b/src/DiffEngineTray.Tests/DiffRunnerViewerFocusRaceTest.cs
index 60301f36..03fa76b0 100644
--- a/src/DiffEngineTray.Tests/DiffRunnerViewerFocusRaceTest.cs
+++ b/src/DiffEngineTray.Tests/DiffRunnerViewerFocusRaceTest.cs
@@ -71,7 +71,7 @@ public async Task A_move_the_tray_has_tracked_is_a_focus_and_nothing_more()
         await Assert.That(fixture.Launches).IsEqualTo(1);
         // Focus raised the window over the entry that was already there, so nothing re-tracked it:
         // a Diff would have replaced the move, losing the exe and arguments the piper send carries.
-        await Assert.That(fixture.TrackedExe()).IsEqualTo(Exe);
+        await Assert.That(fixture.TrackedExe()).IsEqualTo(exe);
     }
 
     sealed class Fixture :
@@ -124,7 +124,7 @@ public Fixture()
         /// that always worked.
         /// </summary>
         public void Track() =>
-            tracker.AddMove(Temp, Target, Exe, "--diff", false, null);
+            tracker.AddMove(Temp, Target, exe, "--diff", false, null);
 
         public bool Tracks(string key) =>
             ((ITrackedFiles) tracker).Has(key);
@@ -169,13 +169,13 @@ public async ValueTask DisposeAsync()
     /// Guarded as existing and never started: the pair is the viewer's, so nothing here reaches a
     /// process launch.
     /// </summary>
-    static readonly string Exe = Environment.ProcessPath!;
+    static readonly string exe = Environment.ProcessPath!;
 
     static ResolvedTool Viewer() =>
         new(
-            name: DiffTool.DiffEngineViewer.ToString(),
+            name: nameof(DiffTool.DiffEngineViewer),
             tool: DiffTool.DiffEngineViewer,
-            exePath: Exe,
+            exePath: exe,
             launchArguments: new(
                 Left: (temp, target) => $"\"{target}\" \"{temp}\"",
                 Right: (temp, target) => $"\"{temp}\" \"{target}\""),
diff --git a/src/DiffEngineTray.Tests/DiffRunnerViewerMoveTest.cs b/src/DiffEngineTray.Tests/DiffRunnerViewerMoveTest.cs
index eb71de3c..ffb4795d 100644
--- a/src/DiffEngineTray.Tests/DiffRunnerViewerMoveTest.cs
+++ b/src/DiffEngineTray.Tests/DiffRunnerViewerMoveTest.cs
@@ -80,7 +80,7 @@ static async Task<MovePayload> CaptureMove(Func<Task<LaunchResult>> launch)
 
     static ResolvedTool Viewer() =>
         new(
-            name: DiffTool.DiffEngineViewer.ToString(),
+            name: nameof(DiffTool.DiffEngineViewer),
             tool: DiffTool.DiffEngineViewer,
             // Guarded as existing, and never started: the tray takes the move, so nothing here
             // reaches a launch.
diff --git a/src/DiffEngineViewer.Documents/DocumentRenderer.cs b/src/DiffEngineViewer.Documents/DocumentRenderer.cs
index 53b881fb..3866490f 100644
--- a/src/DiffEngineViewer.Documents/DocumentRenderer.cs
+++ b/src/DiffEngineViewer.Documents/DocumentRenderer.cs
@@ -1,4 +1,3 @@
-using System.Text;
 using GeoConvert;
 using Morph;
 using Morph.PDFium;
diff --git a/src/DiffEngineViewer.Tests/DiffEngineViewer.Tests.csproj b/src/DiffEngineViewer.Tests/DiffEngineViewer.Tests.csproj
index 00308d84..61ebf0bb 100644
--- a/src/DiffEngineViewer.Tests/DiffEngineViewer.Tests.csproj
+++ b/src/DiffEngineViewer.Tests/DiffEngineViewer.Tests.csproj
@@ -20,6 +20,10 @@
     -->
     <ProjectReference Include="..\DiffEngine\DiffEngine.csproj" Aliases="engine" />
     <PackageReference Include="TUnit" />
+    <!-- For FileTypeLaunchTests: maps in every format, and JPEG and WebP images. -->
+    <PackageReference Include="GeoConvert" />
+    <PackageReference Include="SkiaSharp" />
+    <PackageReference Include="SkiaSharp.NativeAssets.Linux.NoDependencies" />
     <PackageReference Include="Microsoft.Testing.Extensions.CodeCoverage" />
 
   <!--
diff --git a/src/DiffEngineViewer.Tests/DocumentFileSideTests.cs b/src/DiffEngineViewer.Tests/DocumentFileSideTests.cs
index 5b9390ad..b5b4e008 100644
--- a/src/DiffEngineViewer.Tests/DocumentFileSideTests.cs
+++ b/src/DiffEngineViewer.Tests/DocumentFileSideTests.cs
@@ -41,7 +41,7 @@ await Assert.That(side.Document).IsEqualTo(new DocumentFile(
             path,
             19,
             DocumentFormat.Pdf,
-            Convert.ToHexString(SHA256.HashData(Encoding.UTF8.GetBytes("%PDF-1.4 not really"))),
+            Convert.ToHexString(SHA256.HashData("%PDF-1.4 not really"u8.ToArray())),
             Reading: true));
     }
 
diff --git a/src/DiffEngineViewer.Tests/DocumentRendererTests.cs b/src/DiffEngineViewer.Tests/DocumentRendererTests.cs
index 8cd16317..28ba19c7 100644
--- a/src/DiffEngineViewer.Tests/DocumentRendererTests.cs
+++ b/src/DiffEngineViewer.Tests/DocumentRendererTests.cs
@@ -38,7 +38,7 @@ public async Task APdfDrawsAPageAPng()
         {
             await Assert.That(ImageHeader.TryRead(page, out var header)).IsTrue();
             // 300 x 200 points at 150 dpi
-            await Assert.That(header).IsEqualTo(new ImageHeader(ImageFormat.Png, 625, 417));
+            await Assert.That(header).IsEqualTo(new(ImageFormat.Png, 625, 417));
         }
     }
 
@@ -115,7 +115,7 @@ public async Task AnSvgDrawsAtAReviewableSize()
         var pages = Render(path);
         await Assert.That(pages.Count).IsEqualTo(1);
         await Assert.That(ImageHeader.TryRead(pages[0], out var header)).IsTrue();
-        await Assert.That(header).IsEqualTo(new ImageHeader(ImageFormat.Png, 1024, 512));
+        await Assert.That(header).IsEqualTo(new(ImageFormat.Png, 1024, 512));
     }
 
     /// <summary>
diff --git a/src/DiffEngineViewer.Tests/DocumentWatchTests.cs b/src/DiffEngineViewer.Tests/DocumentWatchTests.cs
index afaae2d0..390f9a49 100644
--- a/src/DiffEngineViewer.Tests/DocumentWatchTests.cs
+++ b/src/DiffEngineViewer.Tests/DocumentWatchTests.cs
@@ -197,7 +197,7 @@ public async Task ACallThatNeverReturnsIsLeftBehind()
                 Timeout = TimeSpan.FromMilliseconds(200)
             };
             watch.Pump();
-            documents.Landing = () => release.Wait();
+            documents.Landing = release.Wait;
 
             watch.Pump();
 
diff --git a/src/DiffEngineViewer.Tests/EngineDiffTests.cs b/src/DiffEngineViewer.Tests/EngineDiffTests.cs
index 23370be1..4c723f1f 100644
--- a/src/DiffEngineViewer.Tests/EngineDiffTests.cs
+++ b/src/DiffEngineViewer.Tests/EngineDiffTests.cs
@@ -99,7 +99,7 @@ await Assert.That(scope.Fixture.Host.State.Queue.Single().Key)
 
     static EngineResolvedTool Viewer() =>
         new(
-            EngineTool.DiffEngineViewer.ToString(),
+            nameof(EngineTool.DiffEngineViewer),
             EngineTool.DiffEngineViewer,
             // Guarded as existing, and never started: an owner answers on the port every time.
             Environment.ProcessPath!,
diff --git a/src/DiffEngineViewer.Tests/FileTypeLaunchTests.cs b/src/DiffEngineViewer.Tests/FileTypeLaunchTests.cs
new file mode 100644
index 00000000..eeee8bc6
--- /dev/null
+++ b/src/DiffEngineViewer.Tests/FileTypeLaunchTests.cs
@@ -0,0 +1,244 @@
+extern alias engine;
+using EngineLaunch = engine::DiffEngine.LaunchResult;
+using EngineRunner = engine::DiffEngine.DiffRunner;
+using EngineTool = engine::DiffEngine.DiffTool;
+using EngineTools = engine::DiffEngine.DiffTools;
+
+/// <summary>
+/// Launches the viewer built from this working tree on a pair of every file type it compares
+/// other than text, through the entry point a test run takes, for a person to look at.
+/// <para>
+/// What each head draws is the point. Pictures are drawn with each toolkit's own decoder, so which
+/// image formats show is per platform, and documents and maps need the documents folder, which a
+/// head's bin has and DiffEngine's bundled copy does not. None of that is in a screen snapshot,
+/// which stops at the rows every renderer draws.
+/// </para>
+/// <para>
+/// Explicit, as <see cref="ViewerLaunchTests"/> are, and for the same reasons. Run one case, or
+/// the class, which opens each in turn as the last is closed:
+/// <code>
+/// Get-Process DiffEngineViewer -ErrorAction SilentlyContinue | Stop-Process -Force
+/// dotnet build src
+/// dotnet test --project src/DiffEngineViewer.Tests -- --treenode-filter "/*/*/FileTypeLaunchTests/*"
+/// </code>
+/// </para>
+/// <para>
+/// On its own port, and with the tray left out, for the reason <see cref="ViewerLaunchTests.GroupedQueue"/>
+/// gives: a running DiffEngineTray would otherwise take the pair into its own queue and show it in
+/// its installed viewer rather than this one.
+/// </para>
+/// </summary>
+[NotInParallel]
+public class FileTypeLaunchTests
+{
+    const string port = "3499";
+
+    [Before(Class)]
+    public static void Enable()
+    {
+        ManualViewer.Enable();
+        Environment.SetEnvironmentVariable(ViewerClient.PortVariable, port);
+        EngineRunner.TrayDisabled = true;
+        // Five by default, and the class launches one window per extension. Left raised afterwards:
+        // the setter pins a value rather than restoring the ambient one, and nothing else in this
+        // assembly launches more than a handful.
+        EngineRunner.MaxInstancesToLaunch(100);
+    }
+
+    [After(Class)]
+    public static void Cleanup()
+    {
+        ManualViewer.Close();
+        Environment.SetEnvironmentVariable(ViewerClient.PortVariable, null);
+        EngineRunner.TrayDisabled = false;
+    }
+
+    [Test]
+    [Explicit]
+    [Arguments(".png")]
+    [Arguments(".bmp")]
+    [Arguments(".gif")]
+    [Arguments(".ico")]
+    [Arguments(".jpg")]
+    [Arguments(".jpeg")]
+    [Arguments(".webp")]
+    public Task Image(string extension) =>
+        Launch(
+            extension,
+            SampleImages.Build(extension, 220, 40, 40),
+            SampleImages.Build(extension, 40, 80, 220),
+            $"Image {extension}",
+            "Rows for the format, the size and the bytes, coloured where the two differ",
+            "Each picture drawn under the rows: red on the left, blue on the right",
+            "A format this platform's decoder cannot read shows its rows and no picture, which is expected",
+            "The status line says the two are different files");
+
+    [Test]
+    [Explicit]
+    public Task Pdf() =>
+        Launch(
+            ".pdf",
+            SamplePdf.Build("alpha", "BRAVO", "charlie"),
+            SamplePdf.Build("alpha", "bravo", "charlie"),
+            "PDF",
+            "Text and picture: each page's text above, the page drawn under it",
+            "Opens at page 2, the one that differs, and the headers say (page 2 of 3)",
+            "The status line says page 2 differs",
+            "[ and ] or Prev page and Next page turn both sides together",
+            "r, or the view button, cycles to Picture only, then Text only, then back",
+            "In Picture only, Prev change and Next change move between the pages that differ");
+
+    [Test]
+    [Explicit]
+    [Arguments(".docx", "Hello World!")]
+    [Arguments(".xlsx", "Dulce")]
+    [Arguments(".pptx", "Hello, PowerPoint!")]
+    public Task Office(string extension, string text) =>
+        Launch(
+            extension,
+            Edited(extension, text, $"{text} CHANGED"),
+            File.ReadAllBytes(Sample(extension)),
+            $"Office {extension}",
+            "The status line says reading text, then the line range",
+            $"The document as Markdown above, one line differing: {text} CHANGED on the left",
+            "The page drawn under the text",
+            "r cycles the three views, and the page buttons turn pages where there is more than one");
+
+    [Test]
+    [Explicit]
+    public Task Svg() =>
+        Launch(
+            ".svg",
+            Encoding.UTF8.GetBytes(SvgOf("red")),
+            Encoding.UTF8.GetBytes(SvgOf("blue")),
+            "SVG",
+            "The SVG's source above, the fill line differing",
+            "A red circle drawn on the left and a blue one on the right, larger than the 48 pixels the file says",
+            "No page buttons, and the status line says the drawings differ",
+            "r cycles the three views");
+
+    [Test]
+    [Explicit]
+    [Arguments(".geojson")]
+    [Arguments(".topojson")]
+    [Arguments(".kml")]
+    [Arguments(".gpx")]
+    [Arguments(".wkt")]
+    public Task TextMap(string extension) =>
+        Launch(
+            extension,
+            MapOf(extension, moved: true),
+            MapOf(extension, moved: false),
+            $"Map {extension}",
+            "The file itself as the text, the point's coordinates differing",
+            "A map drawn under the text: a shaded block, a line across it and a point, the point further east on the left",
+            "No page buttons, and the status line says the drawings differ",
+            "r cycles the three views");
+
+    [Test]
+    [Explicit]
+    [Arguments(".kmz")]
+    [Arguments(".wkb")]
+    [Arguments(".fgb")]
+    [Arguments(".geoparquet")]
+    public Task BinaryMap(string extension) =>
+        Launch(
+            extension,
+            MapOf(extension, moved: true),
+            MapOf(extension, moved: false),
+            $"Map {extension}",
+            "The status line says reading text, then the line range",
+            "The text is GeoJSON, indented, the point's coordinates differing",
+            "A map drawn under the text, the point further east on the left",
+            "No page buttons, and the status line says the drawings differ");
+
+    /// <summary>
+    /// Through <see cref="EngineRunner"/>, which is what a test run calls, after asking DiffEngine
+    /// whether it would choose the viewer for this extension at all: a type it would not route
+    /// there is never seen in it by anyone but this test.
+    /// </summary>
+    static async Task Launch(string extension, byte[] received, byte[] verified, string scenario, params string[] checks)
+    {
+        await Assert.That(EngineTools.IsDetectedForExtension(EngineTool.DiffEngineViewer, extension)).IsTrue();
+
+        var directory = ManualViewer.TempDirectory();
+        var temp = Path.Combine(directory.FullName, $"Sample.received{extension}");
+        var target = Path.Combine(directory.FullName, $"Sample.verified{extension}");
+        await File.WriteAllBytesAsync(temp, received);
+        await File.WriteAllBytesAsync(target, verified);
+
+        ManualViewer.Expect(
+            scenario,
+            [$"Headers Sample.received{extension} and Sample.verified{extension}", .. checks]);
+
+        var result = await EngineRunner.LaunchAsync(EngineTool.DiffEngineViewer, temp, target);
+
+        await Assert.That(result).IsEqualTo(EngineLaunch.StartedNewInstance);
+        await ManualViewer.WaitForClose();
+    }
+
+    static string Sample(string extension) =>
+        Path.Combine(AppContext.BaseDirectory, "DocumentSamples", $"sample{extension}");
+
+    /// <summary>
+    /// The committed sample with one string in it changed, wherever in the package that string is
+    /// kept: the document body, the shared strings or a slide.
+    /// </summary>
+    internal static byte[] Edited(string extension, string from, string to)
+    {
+        using var stream = new MemoryStream();
+        stream.Write(File.ReadAllBytes(Sample(extension)));
+        using (var archive = new ZipArchive(stream, ZipArchiveMode.Update, leaveOpen: true))
+        {
+            foreach (var entry in archive.Entries.Where(_ => _.FullName.EndsWith(".xml")).ToList())
+            {
+                string xml;
+                using (var reader = new StreamReader(entry.Open()))
+                {
+                    xml = reader.ReadToEnd();
+                }
+
+                if (!xml.Contains(from))
+                {
+                    continue;
+                }
+
+                var name = entry.FullName;
+                entry.Delete();
+                using var writer = new StreamWriter(archive.CreateEntry(name).Open());
+                writer.Write(xml.Replace(from, to));
+            }
+        }
+
+        return stream.ToArray();
+    }
+
+    internal static string SvgOf(string fill) =>
+        $"""
+         <svg xmlns="http://www.w3.org/2000/svg" width="48" height="48">
+           <circle cx="24" cy="24" r="20" fill="{fill}" />
+         </svg>
+         """;
+
+    /// <summary>
+    /// Sydney Harbour as a block, a bridge and a point, converted by GeoConvert to whichever format
+    /// is asked for, so every format holds the same features.
+    /// </summary>
+    internal static byte[] MapOf(string extension, bool moved)
+    {
+        var longitude = moved ? "151.235" : "151.215";
+        var geoJson =
+            $$$"""
+               {"type":"FeatureCollection","features":[
+                 {"type":"Feature","properties":{"name":"Harbour"},"geometry":{"type":"Polygon","coordinates":[[[151.2,-33.86],[151.24,-33.86],[151.24,-33.84],[151.2,-33.84],[151.2,-33.86]]]}},
+                 {"type":"Feature","properties":{"name":"Bridge"},"geometry":{"type":"LineString","coordinates":[[151.21,-33.85],[151.23,-33.85]]}},
+                 {"type":"Feature","properties":{"name":"Opera House"},"geometry":{"type":"Point","coordinates":[{{{longitude}}},-33.857]}}
+               ]}
+               """;
+        var features = GeoConvert.GeoJson.ReadString(geoJson);
+        var format = GeoConvert.GeoConverter.DetectFormat($"map{extension}");
+        using var stream = new MemoryStream();
+        GeoConvert.GeoConverter.Write(features, stream, format);
+        return stream.ToArray();
+    }
+}
diff --git a/src/DiffEngineViewer.Tests/FileTypeSampleTests.cs b/src/DiffEngineViewer.Tests/FileTypeSampleTests.cs
new file mode 100644
index 00000000..c72957d5
--- /dev/null
+++ b/src/DiffEngineViewer.Tests/FileTypeSampleTests.cs
@@ -0,0 +1,73 @@
+/// <summary>
+/// The pairs <see cref="FileTypeLaunchTests"/> puts in front of a person, checked on every run:
+/// those tests are explicit, so a sample that stopped being what its extension says would otherwise
+/// only be found by someone looking at a window that shows nothing.
+/// </summary>
+public class FileTypeSampleTests :
+    IDisposable
+{
+    [Test]
+    [Arguments(".png", "Png", 240, 160)]
+    [Arguments(".bmp", "Bmp", 240, 160)]
+    [Arguments(".gif", "Gif", 240, 160)]
+    [Arguments(".ico", "Ico", 64, 64)]
+    [Arguments(".jpg", "Jpeg", 240, 160)]
+    [Arguments(".webp", "Webp", 240, 160)]
+    public async Task AnImageIsWhatItsExtensionSays(string extension, string format, int width, int height)
+    {
+        var red = SampleImages.Build(extension, 220, 40, 40);
+        var blue = SampleImages.Build(extension, 40, 80, 220);
+        await Assert.That(ImageHeader.TryRead(red, out var header)).IsTrue();
+        await Assert.That(header).IsEqualTo(new(Enum.Parse<ImageFormat>(format), width, height));
+        await Assert.That(red).IsNotEquivalentTo(blue);
+    }
+
+    [Test]
+    [Arguments(".docx", "Hello World!")]
+    [Arguments(".xlsx", "Dulce")]
+    [Arguments(".pptx", "Hello, PowerPoint!")]
+    public async Task AnOfficeSampleReadsWithItsChange(string extension, string text)
+    {
+        var path = Write($"edited{extension}", FileTypeLaunchTests.Edited(extension, text, $"{text} CHANGED"));
+        await Assert.That(Plugin.Text(path)).Contains($"{text} CHANGED");
+    }
+
+    [Test]
+    [Arguments(".geojson")]
+    [Arguments(".topojson")]
+    [Arguments(".kml")]
+    [Arguments(".gpx")]
+    [Arguments(".wkt")]
+    [Arguments(".kmz")]
+    [Arguments(".wkb")]
+    [Arguments(".fgb")]
+    [Arguments(".geoparquet")]
+    public async Task AMapDrawsDifferentlyOnceMoved(string extension)
+    {
+        var moved = Render(Write($"moved{extension}", FileTypeLaunchTests.MapOf(extension, moved: true)));
+        var still = Render(Write($"still{extension}", FileTypeLaunchTests.MapOf(extension, moved: false)));
+        await Assert.That(moved).IsNotEquivalentTo(still);
+    }
+
+    static DocumentPlugin Plugin { get; } = DocumentPlugin.Find(Path.Combine(AppContext.BaseDirectory, "documents"))!;
+
+    byte[] Render(string path)
+    {
+        var pages = Directory.CreateDirectory(Path.Combine(directory, $"{Path.GetFileName(path)}-pages")).FullName;
+        var landed = new List<string>();
+        Plugin.Render(path, pages, landed.Add);
+        return File.ReadAllBytes(landed.Single());
+    }
+
+    string Write(string name, byte[] content)
+    {
+        var path = Path.Combine(directory, name);
+        File.WriteAllBytes(path, content);
+        return path;
+    }
+
+    readonly string directory = Directory.CreateTempSubdirectory("deview-file-types-").FullName;
+
+    public void Dispose() =>
+        Directory.Delete(directory, true);
+}
diff --git a/src/DiffEngineViewer.Tests/SampleImages.cs b/src/DiffEngineViewer.Tests/SampleImages.cs
new file mode 100644
index 00000000..0cc7da5f
--- /dev/null
+++ b/src/DiffEngineViewer.Tests/SampleImages.cs
@@ -0,0 +1,153 @@
+using SkiaSharp;
+
+/// <summary>
+/// A solid colour in every image format the viewer compares, for <see cref="FileTypeLaunchTests"/>
+/// to put in front of a person: whether each head draws a format is exactly what it is there to
+/// show.
+/// <para>
+/// BMP, ICO and GIF are written by hand, as <see cref="SamplePng"/> is. JPEG and WebP go through
+/// Skia, since a hand written encoder for either is a project of its own, and nothing here is a
+/// baseline whose bytes have to hold still.
+/// </para>
+/// </summary>
+static class SampleImages
+{
+    const int width = 240;
+    const int height = 160;
+
+    public static byte[] Build(string extension, byte red, byte green, byte blue) =>
+        extension switch
+        {
+            ".png" => SamplePng.Build(width, height, red, green, blue),
+            ".bmp" => Bmp(red, green, blue),
+            ".ico" => Ico(red, green, blue),
+            ".gif" => Gif(red, green, blue),
+            ".jpg" or ".jpeg" => Skia(SKEncodedImageFormat.Jpeg, red, green, blue),
+            ".webp" => Skia(SKEncodedImageFormat.Webp, red, green, blue),
+            _ => throw new ArgumentException($"No sample image for {extension}.", nameof(extension))
+        };
+
+    /// <summary>
+    /// 24 bits a pixel, uncompressed, rows bottom up and each padded to four bytes.
+    /// </summary>
+    static byte[] Bmp(byte red, byte green, byte blue)
+    {
+        var stride = (width * 3 + 3) / 4 * 4;
+        var pixels = stride * height;
+        var bytes = new byte[54 + pixels];
+        bytes[0] = (byte) 'B';
+        bytes[1] = (byte) 'M';
+        BinaryPrimitives.WriteInt32LittleEndian(bytes.AsSpan(2), bytes.Length);
+        BinaryPrimitives.WriteInt32LittleEndian(bytes.AsSpan(10), 54);
+        BinaryPrimitives.WriteInt32LittleEndian(bytes.AsSpan(14), 40);
+        BinaryPrimitives.WriteInt32LittleEndian(bytes.AsSpan(18), width);
+        BinaryPrimitives.WriteInt32LittleEndian(bytes.AsSpan(22), height);
+        BinaryPrimitives.WriteInt16LittleEndian(bytes.AsSpan(26), 1);
+        BinaryPrimitives.WriteInt16LittleEndian(bytes.AsSpan(28), 24);
+        BinaryPrimitives.WriteInt32LittleEndian(bytes.AsSpan(34), pixels);
+        for (var y = 0; y < height; y++)
+        {
+            for (var x = 0; x < width; x++)
+            {
+                var index = 54 + y * stride + x * 3;
+                bytes[index] = blue;
+                bytes[index + 1] = green;
+                bytes[index + 2] = red;
+            }
+        }
+
+        return bytes;
+    }
+
+    /// <summary>
+    /// One 64 pixel PNG in an icon directory, which every reader since Vista accepts.
+    /// </summary>
+    static byte[] Ico(byte red, byte green, byte blue)
+    {
+        const int size = 64;
+        var png = SamplePng.Build(size, size, red, green, blue);
+        var bytes = new byte[22 + png.Length];
+        // Reserved, then type 1 (icon), then one image.
+        BinaryPrimitives.WriteInt16LittleEndian(bytes.AsSpan(2), 1);
+        BinaryPrimitives.WriteInt16LittleEndian(bytes.AsSpan(4), 1);
+        bytes[6] = size;
+        bytes[7] = size;
+        BinaryPrimitives.WriteInt16LittleEndian(bytes.AsSpan(10), 1);
+        BinaryPrimitives.WriteInt16LittleEndian(bytes.AsSpan(12), 32);
+        BinaryPrimitives.WriteInt32LittleEndian(bytes.AsSpan(14), png.Length);
+        BinaryPrimitives.WriteInt32LittleEndian(bytes.AsSpan(18), 22);
+        png.CopyTo(bytes, 22);
+        return bytes;
+    }
+
+    /// <summary>
+    /// A GIF whose LZW stream compresses nothing. With a minimum code size of 7, every code is 8
+    /// bits wide until the table reaches 256 entries, so a clear code every 100 pixels keeps each
+    /// code exactly one byte: the pixel's palette index, which is always 0.
+    /// </summary>
+    static byte[] Gif(byte red, byte green, byte blue)
+    {
+        const byte clear = 128;
+        const byte end = 129;
+        var bytes = new List<byte>();
+        bytes.AddRange("GIF89a"u8);
+        AddInt16(bytes, width);
+        AddInt16(bytes, height);
+        // A global table of 128 colours, at 7 bits of resolution.
+        bytes.Add(0xE6);
+        bytes.Add(0);
+        bytes.Add(0);
+        var palette = new byte[128 * 3];
+        palette[0] = red;
+        palette[1] = green;
+        palette[2] = blue;
+        bytes.AddRange(palette);
+
+        bytes.Add(0x2C);
+        AddInt16(bytes, 0);
+        AddInt16(bytes, 0);
+        AddInt16(bytes, width);
+        AddInt16(bytes, height);
+        bytes.Add(0);
+
+        var codes = new List<byte>();
+        for (var pixel = 0; pixel < width * height; pixel++)
+        {
+            if (pixel % 100 == 0)
+            {
+                codes.Add(clear);
+            }
+
+            codes.Add(0);
+        }
+
+        codes.Add(end);
+
+        bytes.Add(7);
+        for (var start = 0; start < codes.Count; start += 255)
+        {
+            var count = Math.Min(255, codes.Count - start);
+            bytes.Add((byte) count);
+            bytes.AddRange(codes.GetRange(start, count));
+        }
+
+        bytes.Add(0);
+        bytes.Add(0x3B);
+        return [.. bytes];
+    }
+
+    static void AddInt16(List<byte> bytes, int value)
+    {
+        bytes.Add((byte) value);
+        bytes.Add((byte) (value >> 8));
+    }
+
+    static byte[] Skia(SKEncodedImageFormat format, byte red, byte green, byte blue)
+    {
+        using var bitmap = new SKBitmap(width, height);
+        bitmap.Erase(new(red, green, blue));
+        using var image = SKImage.FromBitmap(bitmap);
+        using var data = image.Encode(format, 90);
+        return data.ToArray();
+    }
+}
diff --git a/src/DiffEngineViewer/ScreenBuilder.cs b/src/DiffEngineViewer/ScreenBuilder.cs
index 2da129d6..a7b572a3 100644
--- a/src/DiffEngineViewer/ScreenBuilder.cs
+++ b/src/DiffEngineViewer/ScreenBuilder.cs
@@ -23,9 +23,7 @@ public static int BodyRows(SessionState state) =>
     public static int PaneRows(SessionState state)
     {
         var body = BodyRows(state);
-        if (state.Drawing == DrawingView.Both &&
-            state.Current is { IsDocument: true } &&
-            !state.ShowsProperties)
+        if (state is {Drawing: DrawingView.Both, Current.IsDocument: true, ShowsProperties: false})
         {
             return Math.Max(1, body / 2);
         }
@@ -333,7 +331,7 @@ static IEnumerable<Button> ViewButtons(SessionState state, int body)
 
         yield return new(
             state.Minimal ? "All lines" : "Changes only",
-            state.Current is { IsImage: false } && !state.ShowsProperties,
+            state is {Current.IsImage: false, ShowsProperties: false},
             CommandKind.ToggleMinimal);
     }