From 27796851f36f4c72c8f624d289d8c1a4ce596a4e Mon Sep 17 00:00:00 2001
From: AJ Isaacs <ajisaacs27@gmail.com>
Date: Sat, 24 Oct 2026 18:08:46 -0400
Subject: [PATCH] feat(desktop): build releases in a panel beside the Drawing
 Sets lists

The modal release dialog is replaced by ReleasePanel, docked beside the
Library and Sets tabs and shared by both. A double-click or Enter adds a
set at one kit or a library drawing on its own at the entered quantity;
adding one already listed adds to its quantity. Lines are edited in
place with a remove button, and the nests it will make preview live.

Each group now merges into a matching Draft nest by default: the only
one, or the most recently saved of several (chosen in the row); a draft
open in a tab blocks Make Nests instead of making a parallel nest.
Nest after release is remembered per user. Edit Set and Edit Drawing
move to their buttons and right-click menus.

The Drawing Sets window is now an unowned top-level window with its own
taskbar entry and remembered bounds, closed with the main window; a
release not yet made survives closing it, and Make Nests brings the
main window forward. ReleaseSetForm remains as a thin dialog host for
releasing from Nest > Add from Drawing Library.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../Forms/SetReleaseFormsTests.cs             | 1177 +++++++++--------
 OpenNest/Controls/DrawingLibraryView.cs       |   84 +-
 .../Controls/DrawingSetBrowser.Designer.cs    |   33 +-
 OpenNest/Controls/DrawingSetBrowser.cs        |  109 +-
 OpenNest/Controls/GridStyle.cs                |    6 +-
 OpenNest/Controls/ReleasePanel.Designer.cs    |  468 +++++++
 OpenNest/Controls/ReleasePanel.cs             | 1128 ++++++++++++++++
 OpenNest/Controls/SetReleasesView.Designer.cs |    2 +-
 OpenNest/Controls/SetReleasesView.cs          |   45 +-
 OpenNest/Forms/DrawingSetsForm.Designer.cs    |   38 +-
 OpenNest/Forms/DrawingSetsForm.cs             |   97 +-
 OpenNest/Forms/MainForm.File.cs               |   36 +-
 OpenNest/Forms/MainForm.cs                    |   10 +-
 OpenNest/Forms/MainWindowSettings.cs          |   35 +
 OpenNest/Forms/ReleaseSetForm.Designer.cs     |  582 +-------
 OpenNest/Forms/ReleaseSetForm.cs              | 1122 +---------------
 OpenNest/Properties/Settings.Designer.cs      |   53 +
 OpenNest/Properties/Settings.settings         |   12 +
 docs/nest-storage.md                          |  192 +--
 19 files changed, 2843 insertions(+), 2386 deletions(-)
 create mode 100644 OpenNest/Controls/ReleasePanel.Designer.cs
 create mode 100644 OpenNest/Controls/ReleasePanel.cs

diff --git a/OpenNest.WinForms.Tests/Forms/SetReleaseFormsTests.cs b/OpenNest.WinForms.Tests/Forms/SetReleaseFormsTests.cs
index fdd66aa5..500d87e6 100644
--- a/OpenNest.WinForms.Tests/Forms/SetReleaseFormsTests.cs
+++ b/OpenNest.WinForms.Tests/Forms/SetReleaseFormsTests.cs
@@ -6,7 +6,7 @@ using OpenNest.Forms;
 using OpenNest.IO;
 using OpenNest.Shapes;
 using OpenNest.Tests.Data;
-using DrawingSetBrowser = OpenNest.Controls.DrawingSetBrowser;
+using ReleasePanel = OpenNest.Controls.ReleasePanel;
 
 namespace OpenNest.WinForms.Tests.Forms;
 
@@ -16,7 +16,7 @@ public class SetReleaseFormsTests
     private static readonly TimeSpan TestTimeout = TimeSpan.FromSeconds(60);
 
     [Fact]
-    public void Release_CreatesOneDraftNestPerTickedGroup_OpensEach_AndRecordsTheRelease()
+    public void MakeNests_CreatesOneDraftNestPerTickedGroup_OpensEach_AndRecordsTheRelease()
     {
         StaTestThread.Run(
             () =>
@@ -30,42 +30,53 @@ public class SetReleaseFormsTests
                 var set = CreateSet(sets, (a, 2), (b, 1), (c, 4), (old, 1));
                 var nests = new MemoryNests();
                 var opened = new List<(Nest Nest, NestRecord Record)>();
-                var questions = new List<string>();
+                var nestsOpened = 0;
 
-                using var form = new ReleaseSetForm(sets, library, nests, Server, set, (nest, record) => opened.Add((nest, record)));
-                form.ShowMessage = (text, _, _) => { questions.Add(text); return DialogResult.OK; };
-                var created = 0;
-                form.CreateNest = (group, _) => Task.FromResult(new Nest($"N26-{++created:D4}") { Units = group.Units });
-                form.Show();
-                var grid = Field<DataGridView>(form, "groupGrid");
-                var skipped = Field<Label>(form, "skippedLabel");
+                var (host, panel) = ShowPanel(sets, library, nests, (nest, record) => opened.Add((nest, record)));
+                using var _ = host;
+                panel.NestsOpened += (_, _) => nestsOpened++;
+                var grid = Field<DataGridView>(panel, "groupGrid");
+                var release = Field<Button>(panel, "releaseButton");
+                Assert.Equal(("Make Nests", false), (release.Text, release.Enabled));
 
+                Assert.True(panel.AddSet(set));
                 Assert.Equal(2, grid.Rows.Count);
-                Assert.True(skipped.Visible);
-                Assert.Contains("'SYN-OLD'", skipped.Text);
-                Field<DataGridView>(form, "setGrid").Rows[0].Cells["kitsColumn"].Value = "3";
+                Assert.Contains("'SYN-OLD'", Field<Label>(panel, "previewLabel").Text);
+                Assert.True(Field<CheckBox>(panel, "includeArchivedCheckBox").Visible);
+                Assert.Equal("Synthetic customer", Field<Label>(panel, "customerValue").Text);
+                var lines = Field<DataGridView>(panel, "lineGrid");
+                Assert.Equal(new object[] { "Synthetic kit", "1", "kit" }, lines.Rows[0].Cells.Cast<DataGridViewCell>().Take(3).Select(c => c.Value));
+                lines.Rows[0].Cells["lineQuantityColumn"].Value = "3";
+                Assert.Equal("kits", lines.Rows[0].Cells["lineUnitColumn"].Value);
                 Assert.Equal(new object[] { 12, 9 }, grid.Rows.Cast<DataGridViewRow>().Select(r => r.Cells["partsColumn"].Value));
-                Field<TextBox>(form, "notesBox").Text = "Synthetic run";
+                Assert.Equal("Synthetic Aluminum Grade A 0.25 in, Laser", grid.Rows[0].Cells["groupColumn"].Value);
+                Assert.Equal(("Make Nests (2)", true), (release.Text, release.Enabled));
+                Assert.All(grid.Rows.Cast<DataGridViewRow>(), r => Assert.Equal("→ new Draft nest, nested with Auto Nest.", Note(r)));
+                Field<TextBox>(panel, "notesBox").Text = "Synthetic run";
 
-                Run(form.ReleaseAsync());
+                Run(panel.ReleaseAsync());
 
-                Assert.Contains("Make 2 Draft nests from set 'Synthetic kit' ×3?", Assert.Single(questions));
                 Assert.Equal(2, nests.Uploaded.Count);
                 Assert.Equal(2, opened.Count);
+                Assert.Equal(1, nestsOpened);
                 Assert.All(opened, o => Assert.Equal(NestStatus.Draft, o.Nest.Status));
                 var steel = opened.Single(o => o.Nest.Material.Name == "Synthetic Steel");
                 Assert.Equal(new[] { ("SYN-A", 6), ("SYN-B", 3) },
                     steel.Nest.Drawings.OrderBy(d => d.Name).Select(d => (d.Name, d.Quantity.Required)));
-                Assert.Equal(steel.Record.Id, nests.Uploaded.Single(u => u.Name == steel.Nest.Name).Id);
 
-                var release = Assert.Single(sets.Releases);
-                Assert.Equal((3, "Synthetic run", 2), (release.Sets.Single().Quantity, release.Notes, release.Nests.Count));
-                Assert.Same(release, form.Result!.Release);
-                Assert.StartsWith("Done: 2 nests", Field<Label>(form, "statusLabel").Text);
-                Assert.All(grid.Rows.Cast<DataGridViewRow>(), r => Assert.StartsWith("Created N26-", (string)r.Cells["statusColumn"].Value));
-                Assert.False(Field<Button>(form, "releaseButton").Enabled);
-                Assert.True(Field<DataGridView>(form, "setGrid").ReadOnly);
-                Assert.False(Field<ComboBox>(form, "addSetCombo").Enabled);
+                var recorded = Assert.Single(sets.Releases);
+                Assert.Equal((3, "Synthetic run", 2), (recorded.Sets.Single().Quantity, recorded.Notes, recorded.Nests.Count));
+                Assert.Same(recorded, panel.Result!.Release);
+                Assert.StartsWith("Done: 2 nests", Field<Label>(panel, "statusLabel").Text);
+                Assert.All(grid.Rows.Cast<DataGridViewRow>(), r => Assert.StartsWith("Created N26-", Note(r)));
+                Assert.False(release.Enabled);
+                Assert.True(lines.Columns["lineQuantityColumn"]!.ReadOnly);
+                Assert.Null(panel.TakeDraft());
+
+                // The next set starts the next release.
+                Assert.True(panel.AddSet(set));
+                Assert.Null(panel.Result);
+                Assert.Equal(("Synthetic kit", 1), panel.Lines().Select(l => (l.Set.Name, l.Quantity)).Single());
             },
             TestTimeout,
             "The release test did not complete.");
@@ -86,26 +97,22 @@ public class SetReleaseFormsTests
                 var set = CreateSet(sets, (a, 1), (twin, 1), (c, 1), (d, 1));
                 var nests = new MemoryNests();
 
-                using var form = new ReleaseSetForm(sets, library, nests, Server, set, (_, _) => { });
-                form.ShowMessage = (_, _, _) => DialogResult.OK;
-                form.CreateNest = (group, _) => Task.FromResult(new Nest("N") { Units = group.Units });
-                form.Show();
-                var grid = Field<DataGridView>(form, "groupGrid");
-                var rows = grid.Rows.Cast<DataGridViewRow>().ToList();
-                var refused = rows.Single(r => ((SetReleaseGroup)r.Tag!).MaterialName == "Synthetic Steel");
-                var copper = rows.Single(r => ((SetReleaseGroup)r.Tag!).MaterialName == "Synthetic Copper");
+                var (host, panel) = ShowPanel(sets, library, nests);
+                using var _ = host;
+                panel.AddSet(set);
+                var refused = GroupRow(panel, "Synthetic Steel");
 
                 Assert.Equal(false, refused.Cells["includeColumn"].Value);
                 Assert.True(refused.Cells["includeColumn"].ReadOnly);
-                Assert.Contains("named 'SYN-A'", (string)refused.Cells["statusColumn"].Value);
-                copper.Cells["includeColumn"].Value = false;
-                Assert.Contains("1 of 3 materials chosen", Field<Label>(form, "summaryLabel").Text);
+                Assert.Contains("named 'SYN-A'", Note(refused));
+                GroupRow(panel, "Synthetic Copper").Cells["includeColumn"].Value = false;
+                Assert.Equal("Left out of this release.", Note(GroupRow(panel, "Synthetic Copper")));
+                Assert.Equal("Make Nests (1)", Field<Button>(panel, "releaseButton").Text);
                 // Rebuilding the plan keeps the operator's choice.
-                Field<CheckBox>(form, "includeArchivedCheckBox").Checked = true;
-                Assert.Equal(false, grid.Rows.Cast<DataGridViewRow>()
-                    .Single(r => ((SetReleaseGroup)r.Tag!).MaterialName == "Synthetic Copper").Cells["includeColumn"].Value);
+                Field<DataGridView>(panel, "lineGrid").Rows[0].Cells["lineQuantityColumn"].Value = "2";
+                Assert.Equal(false, GroupRow(panel, "Synthetic Copper").Cells["includeColumn"].Value);
 
-                Run(form.ReleaseAsync());
+                Run(panel.ReleaseAsync());
 
                 Assert.Equal("Synthetic Aluminum", Assert.Single(Assert.Single(sets.Releases).Nests).MaterialName);
                 Assert.Single(nests.Uploaded);
@@ -114,72 +121,6 @@ public class SetReleaseFormsTests
             "The release choice test did not complete.");
     }
 
-    [Fact]
-    public void Release_PreviewsTheNestsWithOptionsCollapsed_AndKeepsChangedOptionsShown()
-    {
-        StaTestThread.Run(
-            () =>
-            {
-                var library = new PackageLibrary();
-                var a = library.Add("SYN-A", "Synthetic Steel");
-                var c = library.Add("SYN-C", "Synthetic Aluminum");
-                var old = library.Add("SYN-OLD", "Synthetic Steel", archived: true);
-                var sets = new InMemoryDrawingSets();
-                var set = CreateSet(sets, (a, 2), (c, 1), (old, 1));
-                var nests = new MemoryNests();
-
-                using var form = new ReleaseSetForm(sets, library, nests, Server, set, (_, _) => { });
-                form.ShowMessage = (_, _, _) => DialogResult.OK;
-                form.CreateNest = (group, _) => Task.FromResult(new Nest("N") { Units = group.Units });
-                form.Show();
-                var grid = Field<DataGridView>(form, "groupGrid");
-                var archived = Field<CheckBox>(form, "includeArchivedCheckBox");
-                var options = Field<Button>(form, "optionsButton");
-                var preview = Field<Label>(form, "previewLabel");
-                Run(form.LoadDraftsAsync());
-
-                // Collapsed: the defaults, read-only, with no draft to merge into.
-                Assert.False(form.OptionsExpanded);
-                Assert.Equal("Release set 'Synthetic kit' ×1", Field<Label>(form, "setLabel").Text);
-                Assert.Equal("Creates 2 nests: Synthetic Aluminum Grade A 0.25 in, Synthetic Steel Grade A 0.25 in.", preview.Text);
-                Assert.Equal((false, false, false), (grid.Columns["includeColumn"]!.Visible, grid.Columns["targetColumn"]!.Visible, archived.Visible));
-                Assert.Contains("under Options", Field<Label>(form, "skippedLabel").Text);
-                Assert.True(grid.Rows.Cast<DataGridViewRow>().All(r => (bool)r.Cells["includeColumn"].Value));
-                Assert.Equal(new object[] { "New Draft nest", "New Draft nest" }, grid.Rows.Cast<DataGridViewRow>().Select(r => r.Cells["targetColumn"].Value));
-                Assert.True(Field<CheckBox>(form, "nestAfterReleaseCheckBox").Checked);
-
-                Field<DataGridView>(form, "setGrid").Rows[0].Cells["kitsColumn"].Value = "3";
-                Assert.Equal("Release set 'Synthetic kit' ×3", Field<Label>(form, "setLabel").Text);
-
-                options.PerformClick();
-                Assert.True(form.OptionsExpanded);
-                Assert.Equal("Options ▾", options.Text);
-                Assert.Equal((true, true, true), (grid.Columns["includeColumn"]!.Visible, grid.Columns["targetColumn"]!.Visible, archived.Visible));
-
-                // Options left changed stay shown when collapsed; the defaults hide again.
-                grid.Rows[0].Cells["includeColumn"].Value = false;
-                archived.Checked = true;
-                options.PerformClick();
-                Assert.Equal("Options ▸", options.Text);
-                Assert.Equal((true, false, true), (grid.Columns["includeColumn"]!.Visible, grid.Columns["targetColumn"]!.Visible, archived.Visible));
-                Assert.Equal("Creates 1 nest: Synthetic Steel Grade A 0.25 in. 1 material is left out (unticked under Release).", preview.Text);
-
-                grid.Rows[0].Cells["includeColumn"].Value = true;
-                archived.Checked = false;
-                // Nothing vanishes while collapsed until Options is toggled.
-                Assert.True(grid.Columns["includeColumn"]!.Visible);
-                options.PerformClick();
-                options.PerformClick();
-                Assert.Equal((false, false, false), (grid.Columns["includeColumn"]!.Visible, grid.Columns["targetColumn"]!.Visible, archived.Visible));
-
-                Run(form.ReleaseAsync());
-
-                Assert.Equal(2, Assert.Single(sets.Releases).Nests.Count);
-            },
-            TestTimeout,
-            "The collapsed options test did not complete.");
-    }
-
     [Fact]
     public void FixDrawings_EditsEachDrawingTheGroupIsRefusedFor_ThenTheGroupCanBeReleased()
     {
@@ -195,35 +136,35 @@ public class SetReleaseFormsTests
                 var nests = new MemoryNests();
                 var edits = new List<string>();
 
-                using var form = new ReleaseSetForm(sets, library, nests, Server, set, (_, _) => { });
-                form.ShowMessage = (_, _, _) => DialogResult.OK;
-                form.CreateNest = (group, _) => Task.FromResult(new Nest("N") { Units = group.Units });
-                form.EditDrawing = edit =>
+                var (host, panel) = ShowPanel(sets, library, nests);
+                using var _ = host;
+                panel.EditDrawing = edit =>
                 {
                     edits.Add(edit.Listed.Name);
                     return Run(edit.SaveAsync(edit.Details with { MaterialName = "Synthetic Steel", Thickness = 0.25 }, edit.Listed.Notes, edit.Listed.Settings ?? new DrawingNestingSettings()));
                 };
-                Field<CheckBox>(form, "nestAfterReleaseCheckBox").Checked = false;
-                form.Show();
-                var grid = Field<DataGridView>(form, "groupGrid");
-                var fix = Field<Button>(form, "fixDrawingsButton");
+                Field<CheckBox>(panel, "nestAfterReleaseCheckBox").Checked = false;
+                panel.AddSet(set);
+                var grid = Field<DataGridView>(panel, "groupGrid");
+                var fix = Field<Button>(panel, "fixDrawingsButton");
                 var refused = grid.Rows.Cast<DataGridViewRow>().Single(r => ((SetReleaseGroup)r.Tag!).IsUnassigned);
-                Assert.Contains("Edit Drawing", (string)refused.Cells["statusColumn"].Value);
-                Assert.Contains("1 material can't be released yet: choose Fix Drawings.", Field<Label>(form, "previewLabel").Text);
+                Assert.Contains("Edit Drawing", Note(refused));
+                Assert.Equal("(no material or thickness)", refused.Cells["groupColumn"].Value);
+                Assert.Contains("1 material can't be released yet: choose Fix Drawings.", Field<Label>(panel, "previewLabel").Text);
                 // With a releasable group selected, Fix Drawings takes the refused one.
-                grid.CurrentCell = grid.Rows[0].Cells["materialColumn"];
+                grid.CurrentCell = grid.Rows[0].Cells["groupColumn"];
                 Assert.NotSame(refused, grid.CurrentRow);
-                Assert.True(fix.Enabled);
+                Assert.True(fix.Visible && fix.Enabled);
 
-                Run(form.FixSelectedGroupAsync());
+                Run(panel.FixSelectedGroupAsync());
 
                 Assert.Equal(new[] { "SYN-B", "SYN-C" }, edits);
-                Assert.False(fix.Enabled);
+                Assert.False(fix.Visible);
                 var group = Assert.IsType<SetReleaseGroup>(Assert.Single(grid.Rows.Cast<DataGridViewRow>()).Tag);
                 Assert.True(group.CanRelease);
                 Assert.Equal(new[] { ("SYN-A", 1), ("SYN-B", 2), ("SYN-C", 2) }, group.Items.Select(i => (i.Drawing.Name, i.Drawing.Revision)));
 
-                Run(form.ReleaseAsync());
+                Run(panel.ReleaseAsync());
 
                 Assert.Single(nests.Uploaded);
                 Assert.Equal("Synthetic Steel", Assert.Single(Assert.Single(sets.Releases).Nests).MaterialName);
@@ -233,7 +174,7 @@ public class SetReleaseFormsTests
     }
 
     [Fact]
-    public void ReleaseNotRecorded_CanBeRecordedAgain()
+    public void ReleaseNotRecorded_CanBeRecordedAgain_AndIsNotClearedByANewLine()
     {
         StaTestThread.Run(
             () =>
@@ -245,30 +186,563 @@ public class SetReleaseFormsTests
                 sets.FailNextPost = true;
                 var opened = 0;
 
-                using var form = new ReleaseSetForm(sets, library, new MemoryNests(), Server, set, (_, _) => opened++);
-                form.ShowMessage = (_, _, _) => DialogResult.OK;
-                form.CreateNest = (group, _) => Task.FromResult(new Nest("N") { Units = group.Units });
-                form.Show();
-                var release = Field<Button>(form, "releaseButton");
+                var (host, panel) = ShowPanel(sets, library, new MemoryNests(), (_, _) => opened++);
+                using var _ = host;
+                panel.AddSet(set);
+                var release = Field<Button>(panel, "releaseButton");
 
-                Run(form.ReleaseAsync());
+                Run(panel.ReleaseAsync());
 
                 Assert.Equal(1, opened);
                 Assert.Empty(sets.Releases);
                 Assert.Equal(("Try Again", true), (release.Text, release.Enabled));
                 Assert.EndsWith("Synthetic release post failure. Try Again records it; the nests are not made again.",
-                    Field<Label>(form, "statusLabel").Text);
+                    Field<Label>(panel, "statusLabel").Text);
+                Assert.False(panel.AddSet(set));
+                Assert.NotNull(panel.Result);
 
-                Run(form.RetryRecordAsync());
+                Run(panel.RetryRecordAsync());
 
                 Assert.Equal(2, sets.PostAttempts);
-                Assert.Same(Assert.Single(sets.Releases), form.Result!.Release);
-                Assert.Equal(("Make Nests...", false), (release.Text, release.Enabled));
+                Assert.Same(Assert.Single(sets.Releases), panel.Result!.Release);
+                Assert.Equal(("Make Nests (1)", false), (release.Text, release.Enabled));
             },
             TestTimeout,
             "The release retry test did not complete.");
     }
 
+    [Fact]
+    public void OneMatchingDraft_IsMergedIntoByDefault()
+    {
+        StaTestThread.Run(
+            () =>
+            {
+                var library = new PackageLibrary();
+                var a = library.Add("SYN-A", "Synthetic Steel");
+                var c = library.Add("SYN-C", "Synthetic Aluminum");
+                var sets = new InMemoryDrawingSets();
+                var set = CreateSet(sets, (a, 1), (c, 1));
+                var nests = new MemoryNests();
+                var draft = nests.AddDraft("N26-0007", "Synthetic Steel", "Grade A", 0.25);
+
+                var (host, panel) = ShowPanel(sets, library, nests);
+                using var _ = host;
+                panel.AddSet(set);
+                var steel = GroupRow(panel, "Synthetic Steel");
+                var aluminum = GroupRow(panel, "Synthetic Aluminum");
+
+                Assert.Equal("N26-0007", steel.Cells["targetColumn"].Value);
+                Assert.Equal("→ merges into N26-0007; the whole draft (1 sheet) is nested again.", Note(steel));
+                Assert.Equal(ReleasePanel.NewNestChoice, aluminum.Cells["targetColumn"].Value);
+                Assert.True(aluminum.Cells["targetColumn"].ReadOnly);
+                Assert.Same(draft, panel.ChosenMerges().Values.Single());
+                Assert.StartsWith("1 new, 1 merged, 2 parts.", Field<Label>(panel, "previewLabel").Text);
+
+                Run(panel.ReleaseAsync());
+
+                var release = Assert.Single(sets.Releases);
+                var merged = release.Nests.Single(n => n.Kind == SetReleaseNestKind.Merged);
+                Assert.Equal((draft.Id, (int?)draft.Revision, draft.Revision + 1), (merged.NestId, merged.RevisionBefore, merged.RevisionAfter));
+                Assert.StartsWith("Merged into N26-0007", Note(steel));
+            },
+            TestTimeout,
+            "The one-draft merge test did not complete.");
+    }
+
+    [Fact]
+    public void SeveralMatchingDrafts_DefaultToTheNewest_AndTheChoiceIsInTheRow()
+    {
+        StaTestThread.Run(
+            () =>
+            {
+                var library = new PackageLibrary();
+                var a = library.Add("SYN-A", "Synthetic Steel");
+                var sets = new InMemoryDrawingSets();
+                var set = CreateSet(sets, (a, 1));
+                var nests = new MemoryNests();
+                var older = nests.AddDraft("N26-0005", "Synthetic Steel", "Grade A", 0.25, new DateTime(2026, 10, 1, 9, 0, 0, DateTimeKind.Utc));
+                var newer = nests.AddDraft("N26-0009", "Synthetic Steel", "Grade A", 0.25, new DateTime(2026, 10, 22, 9, 0, 0, DateTimeKind.Utc));
+
+                var (host, panel) = ShowPanel(sets, library, nests);
+                using var _ = host;
+                panel.AddSet(set);
+                var row = Field<DataGridView>(panel, "groupGrid").Rows[0];
+                var cell = (DataGridViewComboBoxCell)row.Cells["targetColumn"];
+                var group = (SetReleaseGroup)row.Tag!;
+
+                Assert.Equal(new object[] { "N26-0009", "N26-0005", ReleasePanel.NewNestChoice }, cell.Items.Cast<object>());
+                Assert.False(cell.ReadOnly);
+                Assert.Equal("N26-0009", cell.Value);
+                Assert.Same(newer, panel.TargetOf(group));
+                Assert.Contains("2 Draft nests match; the newest is chosen.", Note(row));
+
+                panel.ChooseTarget(row, group, "N26-0005");
+                Assert.Same(older, panel.TargetOf(group));
+                Assert.DoesNotContain("the newest is chosen", Note(row));
+                // The choice survives a rebuilt plan.
+                Field<DataGridView>(panel, "lineGrid").Rows[0].Cells["lineQuantityColumn"].Value = "2";
+                row = Field<DataGridView>(panel, "groupGrid").Rows[0];
+                Assert.Equal("N26-0005", row.Cells["targetColumn"].Value);
+
+                panel.ChooseTarget(row, (SetReleaseGroup)row.Tag!, ReleasePanel.NewNestChoice);
+                Assert.Empty(panel.ChosenMerges());
+                Assert.StartsWith("→ new Draft nest", Note(row));
+                Assert.Contains("2 Draft nests match; choose one to merge.", Note(row));
+            },
+            TestTimeout,
+            "The several-drafts merge test did not complete.");
+    }
+
+    [Fact]
+    public void NoMatchingDraft_MakesANewDraftNest()
+    {
+        StaTestThread.Run(
+            () =>
+            {
+                var library = new PackageLibrary();
+                var a = library.Add("SYN-A", "Synthetic Steel");
+                var sets = new InMemoryDrawingSets();
+                var set = CreateSet(sets, (a, 1));
+                var nests = new MemoryNests();
+                // Another material's draft does not match.
+                nests.AddDraft("N26-0007", "Synthetic Aluminum", "Grade A", 0.25);
+
+                var (host, panel) = ShowPanel(sets, library, nests);
+                using var _ = host;
+                panel.AddSet(set);
+                var row = Field<DataGridView>(panel, "groupGrid").Rows[0];
+
+                Assert.Equal(ReleasePanel.NewNestChoice, row.Cells["targetColumn"].Value);
+                Assert.Equal("→ new Draft nest, nested with Auto Nest.", Note(row));
+
+                Run(panel.ReleaseAsync());
+
+                Assert.Equal(SetReleaseNestKind.Created, Assert.Single(Assert.Single(sets.Releases).Nests).Kind);
+            },
+            TestTimeout,
+            "The no-draft release test did not complete.");
+    }
+
+    [Fact]
+    public void DraftOpenInATab_IsNeverMergedInto_AndMakeNestsWaitsUntilItIsClosed()
+    {
+        StaTestThread.Run(
+            () =>
+            {
+                var library = new PackageLibrary();
+                var a = library.Add("SYN-A", "Synthetic Steel");
+                var sets = new InMemoryDrawingSets();
+                var set = CreateSet(sets, (a, 1));
+                var nests = new MemoryNests();
+                var draft = nests.AddDraft("N26-0007", "Synthetic Steel", "Grade A", 0.25);
+                var openTabs = new HashSet<Guid> { draft.Id };
+                var messages = new List<string>();
+
+                var (host, panel) = ShowPanel(sets, library, nests, messages: messages);
+                using var _ = host;
+                panel.IsNestOpen = openTabs.Contains;
+                panel.AddSet(set);
+                var row = Field<DataGridView>(panel, "groupGrid").Rows[0];
+                var release = Field<Button>(panel, "releaseButton");
+
+                Assert.Equal("N26-0007", row.Cells["targetColumn"].Value);
+                Assert.Equal("N26-0007 is open — save and close it to merge into it.", Note(row));
+                Assert.False(release.Enabled);
+                Assert.Contains("Make Nests waits: N26-0007 is open in a tab.", Field<Label>(panel, "previewLabel").Text);
+
+                Run(panel.ReleaseAsync());
+                Assert.Empty(nests.Uploaded);
+                Assert.Empty(sets.Releases);
+                Assert.Contains("is open in a tab", Assert.Single(messages));
+
+                // Closed in its tab, as the window learns when it is activated again.
+                openTabs.Clear();
+                panel.RefreshOpenNests();
+                Assert.True(release.Enabled);
+                Assert.StartsWith("→ merges into N26-0007", Note(row));
+
+                Run(panel.ReleaseAsync());
+                Assert.Equal(SetReleaseNestKind.Merged, Assert.Single(Assert.Single(sets.Releases).Nests).Kind);
+            },
+            TestTimeout,
+            "The open-draft release test did not complete.");
+    }
+
+    [Fact]
+    public void NestAfterRelease_NestsEachGroupWithAutoNest_AndListsItsSheets()
+    {
+        StaTestThread.Run(
+            () =>
+            {
+                var library = new PackageLibrary();
+                var a = library.Add("SYN-A", "Synthetic Steel");
+                var sets = new InMemoryDrawingSets();
+                var set = CreateSet(sets, (a, 3));
+                var opened = new List<Nest>();
+
+                var (host, panel) = ShowPanel(sets, library, new MemoryNests(), (nest, _) => opened.Add(nest));
+                using var _ = host;
+                panel.CreateNest = (group, _) =>
+                {
+                    var nest = new Nest("N26-0200") { Units = group.Units };
+                    nest.PlateDefaults.Size = new OpenNest.Geometry.Size(48, 96);
+                    return Task.FromResult(nest);
+                };
+                Field<CheckBox>(panel, "nestAfterReleaseCheckBox").Checked = true;
+                panel.AddSet(set);
+
+                Run(panel.ReleaseAsync());
+
+                var nest = Assert.Single(opened);
+                Assert.Equal(3, nest.Plates.Sum(p => p.Parts.Count * p.Quantity));
+                Assert.Equal(0, Assert.Single(nest.Drawings).Quantity.Remaining);
+                Assert.StartsWith("Created N26-0200 — Nested on 1 sheet, ", Note(Field<DataGridView>(panel, "groupGrid").Rows[0]));
+            },
+            TestTimeout,
+            "The nest after release test did not complete.");
+    }
+
+    [Fact]
+    public void NestAfterRelease_Unticked_SaysAMergedDraftIsLeftWithoutSheets()
+    {
+        StaTestThread.Run(
+            () =>
+            {
+                var library = new PackageLibrary();
+                var a = library.Add("SYN-A", "Synthetic Steel");
+                var sets = new InMemoryDrawingSets();
+                var set = CreateSet(sets, (a, 2));
+                var nests = new MemoryNests();
+                var draft = nests.AddDraft("N26-0007", "Synthetic Steel", "Grade A", 0.25);
+                var renested = 0;
+
+                var (host, panel) = ShowPanel(sets, library, nests);
+                using var _ = host;
+                panel.Renest = (_, _) => { renested++; return Task.FromResult(new SetReleaseRenest(true, "")); };
+                var nestAfter = Field<CheckBox>(panel, "nestAfterReleaseCheckBox");
+                nestAfter.Checked = true;
+                panel.AddSet(set);
+                var row = Field<DataGridView>(panel, "groupGrid").Rows[0];
+                Assert.Contains("the whole draft (1 sheet) is nested again", Note(row));
+
+                nestAfter.Checked = false;
+                Assert.Equal("→ merges into N26-0007; its 1 sheet is cleared, leaving the draft without sheets until it is nested.", Note(row));
+
+                Run(panel.ReleaseAsync());
+
+                Assert.Equal(0, renested);
+                var merged = Assert.Single(panel.Result!.Created);
+                Assert.Same(draft, merged.MergedInto);
+                Assert.Empty(merged.Nest!.Plates);
+                Assert.Null(merged.Renest);
+                Assert.False(nestAfter.Enabled);
+            },
+            TestTimeout,
+            "The release without nesting test did not complete.");
+    }
+
+    [Fact]
+    public void NestAfterRelease_RemembersTheOperatorsLastChoice()
+    {
+        StaTestThread.Run(
+            () =>
+            {
+                var settings = OpenNest.Properties.Settings.Default;
+                var saved = settings.ReleaseNestAfter;
+                try
+                {
+                    settings.ReleaseNestAfter = true;
+                    using (var first = new ReleasePanel())
+                    {
+                        var box = Field<CheckBox>(first, "nestAfterReleaseCheckBox");
+                        Assert.True(box.Checked);
+                        // Set by code, it is not remembered; clicked by the operator, it is.
+                        box.Checked = false;
+                        Assert.True(settings.ReleaseNestAfter);
+                        box.Checked = true;
+                        typeof(CheckBox).GetMethod("OnClick", BindingFlags.Instance | BindingFlags.NonPublic)!
+                            .Invoke(box, new object[] { EventArgs.Empty });
+                        Assert.False(box.Checked);
+                        Assert.False(settings.ReleaseNestAfter);
+                    }
+
+                    using var second = new ReleasePanel();
+                    Assert.False(Field<CheckBox>(second, "nestAfterReleaseCheckBox").Checked);
+                }
+                finally
+                {
+                    settings.ReleaseNestAfter = saved;
+                    settings.Save();
+                }
+            },
+            TestTimeout,
+            "The remembered nest-after test did not complete.");
+    }
+
+    [Fact]
+    public void SetsTab_DoubleClickAddsASetAtOneKit_AgainAddsAKit_AndAddToReleaseTakesEverySelectedSet()
+    {
+        StaTestThread.Run(
+            () =>
+            {
+                var library = new PackageLibrary();
+                var a = library.Add("SYN-A", "Synthetic Steel");
+                var sets = new InMemoryDrawingSets();
+                CreateSet(sets, "Synthetic kit", (a, 1));
+                CreateSet(sets, "Synthetic frame", (a, 2));
+                var edits = 0;
+
+                using var form = new DrawingSetsForm(sets, library, Server);
+                form.EnableRelease(new MemoryNests(), (_, _) => { });
+                var browser = form.Browser;
+                browser.EditSet = _ => { edits++; return null; };
+                form.Show();
+                var setGrid = Field<DataGridView>(browser, "setGrid");
+                PumpUntil(() => setGrid.Rows.Count == 2, "the set list");
+                var panel = form.ReleasePanel;
+                Assert.True(panel.Visible);
+                Assert.Equal("&Add to Release", Field<Button>(browser, "releaseButton").Text);
+
+                // Listed by name: frame, then kit.
+                setGrid.CurrentCell = setGrid.Rows[1].Cells[0];
+                DoubleClick(setGrid, 1);
+                PumpUntil(() => panel.Lines().Count == 1, "the set to be added");
+                Assert.Equal(("Synthetic kit", 1), (panel.Lines()[0].Set.Name, panel.Lines()[0].Quantity));
+                Assert.Equal("Synthetic Steel", Assert.Single(panel.Lines()[0].Set.Members).Drawing!.MaterialName);
+
+                DoubleClick(setGrid, 1);
+                PumpUntil(() => panel.Lines()[0].Quantity == 2, "the kit to be added");
+                Assert.Single(panel.Lines());
+                Assert.Equal(0, edits);
+
+                setGrid.Rows[0].Selected = true;
+                setGrid.Rows[1].Selected = true;
+                Run(browser.AddSelectedToReleaseAsync());
+                Assert.Equal(new[] { ("Synthetic kit", 3), ("Synthetic frame", 1) }, panel.Lines().Select(l => (l.Set.Name, l.Quantity)));
+
+                // Edit moved to its button and the right-click menu.
+                Assert.True(Field<ToolStripMenuItem>(browser, "editMenuItem").Available);
+                Run(browser.EditSelectedAsync());
+                Assert.Equal(1, edits);
+
+                // The panel shows beside the lists, never over the releases.
+                Field<TabControl>(form, "tabs").SelectedIndex = 2;
+                Assert.True(Field<SplitContainer>(form, "splitContainer").Panel2Collapsed);
+                form.ShowLibrary();
+                Assert.False(Field<SplitContainer>(form, "splitContainer").Panel2Collapsed);
+            },
+            TestTimeout,
+            "The sets tab add test did not complete.");
+    }
+
+    [Fact]
+    public void LibraryTab_DoubleClickAddsADrawingOnItsOwnAtTheQuantity_AgainAddsThatMore_IntoTheSameRelease()
+    {
+        StaTestThread.Run(
+            () =>
+            {
+                var library = new PackageLibrary();
+                var a = library.Add("SYN-A", "Synthetic Steel");
+                var sets = new InMemoryDrawingSets();
+                var set = CreateSet(sets, "Synthetic kit", (a, 1));
+                var edits = 0;
+
+                using var form = new DrawingSetsForm(sets, library, Server);
+                form.EnableRelease(new MemoryNests(), (_, _) => { });
+                var view = form.LibraryView;
+                view.EditDrawing = _ => { edits++; return null; };
+                view.LoadPreview = (_, _) => Task.FromResult<Drawing>(null!);
+                form.ShowLibrary();
+                form.Show();
+                var grid = Field<DataGridView>(view, "drawingGrid");
+                PumpUntil(() => grid.Rows.Count == 1, "the library page");
+                grid.CurrentCell = grid.Rows[0].Cells[0];
+                var panel = form.ReleasePanel;
+                Assert.True(panel.AddSet(set));
+
+                Field<NumericUpDown>(view, "quantityBox").Value = 4;
+                DoubleClick(grid, 0);
+                PumpUntil(() => panel.DrawingLines().Count == 1, "the drawing to be added");
+                Assert.Equal(("SYN-A", 4), (panel.DrawingLines()[0].Drawing.Name, panel.DrawingLines()[0].Quantity));
+
+                DoubleClick(grid, 0);
+                PumpUntil(() => panel.DrawingLines()[0].Quantity == 8, "the quantity to be added");
+                Assert.Equal(0, edits);
+                var lines = Field<DataGridView>(panel, "lineGrid");
+                Assert.Equal(new object[] { "Synthetic kit", "SYN-A" }, lines.Rows.Cast<DataGridViewRow>().Select(r => r.Cells["lineNameColumn"].Value));
+                Assert.Equal("pcs", lines.Rows[1].Cells["lineUnitColumn"].Value);
+                // The set and the drawing on its own share one group.
+                Assert.Equal(9, Field<DataGridView>(panel, "groupGrid").Rows[0].Cells["partsColumn"].Value);
+
+                var addButton = Field<Button>(view, "addButton");
+                Assert.Equal(("Add to Release", true, true), (addButton.Text, addButton.Visible, addButton.Enabled));
+                Assert.Equal("Edit Drawing...", Field<Button>(view, "editButton").Text);
+                Run(view.EditSelectedAsync());
+                Assert.Equal(1, edits);
+
+                // ✕ removes a line.
+                typeof(DataGridView).GetMethod("OnCellContentClick", BindingFlags.Instance | BindingFlags.NonPublic)!
+                    .Invoke(lines, new object[] { new DataGridViewCellEventArgs(lines.Columns["lineRemoveColumn"]!.Index, 0) });
+                Assert.Empty(panel.Lines());
+                Assert.Single(panel.DrawingLines());
+
+                // Closing keeps the release for the next time the window opens.
+                var draft = form.TakeRelease();
+                Assert.NotNull(draft);
+                using var again = new DrawingSetsForm(sets, library, Server);
+                again.EnableRelease(new MemoryNests(), (_, _) => { });
+                again.RestoreRelease(draft);
+                Assert.Equal(("SYN-A", 8), again.ReleasePanel.DrawingLines().Select(l => (l.Drawing.Name, l.Quantity)).Single());
+            },
+            TestTimeout,
+            "The library tab add test did not complete.");
+    }
+
+    [Fact]
+    public void ReleaseDialog_OfASetAndDrawingsAddedFromTheLibrary_GroupsThemTogether_AndRecordsBoth()
+    {
+        StaTestThread.Run(
+            () =>
+            {
+                var library = new PackageLibrary();
+                var a = library.Add("SYN-A", "Synthetic Steel");
+                library.Add("SYN-B", "Synthetic Steel");
+                library.Add("SYN-C", "Synthetic Aluminum");
+                var sets = new InMemoryDrawingSets();
+                var set = CreateSet(sets, (a, 2));
+                var nests = new MemoryNests();
+
+                using var form = new ReleaseSetForm(sets, library, nests, Server, new[] { set }, Array.Empty<SetReleaseDrawingLine>(), (_, _) => { });
+                var panel = form.Panel;
+                panel.ShowMessage = (_, _, _) => DialogResult.OK;
+                var created = 0;
+                panel.CreateNest = (group, _) => Task.FromResult(new Nest($"N26-{++created:D4}") { Units = group.Units });
+                form.Show();
+                using var picker = new AddReleaseDrawingsForm(library, Server, panel.AddDrawings,
+                    id => panel.DrawingLines().Any(l => l.Drawing.Id == id));
+                picker.Show(form);
+                Run(picker.RefreshAsync());
+
+                picker.Select("SYN-A", "SYN-C");
+                picker.Quantity = 5;
+                picker.AddSelectedDrawings();
+                Assert.Equal("Added 2 drawings.", picker.Status);
+                picker.Select("SYN-C", "SYN-B");
+                picker.Quantity = 1;
+                picker.AddSelectedDrawings();
+                Assert.Equal("Added 1 drawing and 1 more of 1 listed.", picker.Status);
+
+                var lines = Field<DataGridView>(panel, "lineGrid");
+                Assert.Equal(new object[] { "kit", "pcs", "pcs", "pc" },
+                    lines.Rows.Cast<DataGridViewRow>().Select(r => r.Cells["lineUnitColumn"].Value));
+                lines.Rows[2].Cells["lineQuantityColumn"].Value = "40";
+                Assert.Equal(new[] { ("SYN-A", 5), ("SYN-C", 40), ("SYN-B", 1) }, panel.DrawingLines().Select(l => (l.Drawing.Name, l.Quantity)));
+                var grid = Field<DataGridView>(panel, "groupGrid");
+                Assert.Equal(new object[] { 40, 8 }, grid.Rows.Cast<DataGridViewRow>().Select(r => r.Cells["partsColumn"].Value));
+
+                Run(panel.ReleaseAsync());
+
+                var release = Assert.Single(sets.Releases);
+                Assert.Equal(new[] { 5, 40, 1 }, release.Drawings.Select(d => d.Quantity));
+                var steel = release.Nests.Single(n => n.MaterialName == "Synthetic Steel");
+                Assert.Equal(new[] { ((Guid?)set.Id, 2), (null, 5), (null, 1) }, steel.Items.Select(i => (i.SetId, i.Quantity)));
+                Assert.Equal(2, nests.Uploaded.Count);
+            },
+            TestTimeout,
+            "The drawing release test did not complete.");
+    }
+
+    [Fact]
+    public void Release_OfADrawingAlone_OnAServerWithoutDrawingsOnTheirOwn_SavesNothing()
+    {
+        StaTestThread.Run(
+            () =>
+            {
+                var library = new PackageLibrary();
+                var a = library.Add("SYN-A", "Synthetic Steel");
+                var sets = new InMemoryDrawingSets { WithoutDrawingReleases = true };
+                var nests = new MemoryNests();
+
+                var (host, panel) = ShowPanel(sets, library, nests);
+                using var _ = host;
+                Assert.Equal("Added 'SYN-A' ×4.", panel.AddDrawings(new[] { a }, 4));
+                Assert.Equal("Release drawing 'SYN-A' ×4", Field<Label>(panel, "headingLabel").Text);
+                Assert.Contains("4 parts", Field<Label>(panel, "previewLabel").Text);
+
+                Run(panel.ReleaseAsync());
+
+                Assert.Empty(nests.Uploaded);
+                Assert.Empty(sets.Releases);
+                Assert.Equal("Nothing saved. See What happens.", Field<Label>(panel, "statusLabel").Text);
+                Assert.Contains("does not support releasing library drawings on their own",
+                    Note(Field<DataGridView>(panel, "groupGrid").Rows[0]));
+            },
+            TestTimeout,
+            "The old-server drawing release test did not complete.");
+    }
+
+    [Fact]
+    public void NewRelease_SwitchesToTheSetsTab_AndTheReleasesTabRereadsWhenShownAgain()
+    {
+        StaTestThread.Run(
+            () =>
+            {
+                var library = new PackageLibrary();
+                var a = library.Add("SYN-A", "Synthetic Steel");
+                var sets = new InMemoryDrawingSets();
+                var set = CreateSet(sets, (a, 1));
+                var other = CreateSet(sets, "Synthetic frame", (a, 2));
+                SetReleaseRecord Release(DateTime at, SetReleaseLine[] lines, SetReleaseDrawing[] drawings) => new()
+                {
+                    Id = Guid.NewGuid(),
+                    Sets = lines,
+                    Drawings = drawings,
+                    ReleasedBy = "Synthetic operator",
+                    ReleasedAt = at,
+                    Nests = new[] { new SetReleaseNest { NestId = Guid.NewGuid(), Nest = new NestRecord { Name = "N1", Status = NestStatus.Draft } } },
+                };
+                sets.Releases.Add(Release(new DateTime(2026, 10, 20, 12, 0, 0, DateTimeKind.Utc),
+                    new[]
+                    {
+                        new SetReleaseLine { SetId = set.Id, SetRevision = 1, SetName = set.Name, Quantity = 2 },
+                        new SetReleaseLine { SetId = other.Id, SetRevision = 1, SetName = other.Name, Quantity = 1 },
+                    },
+                    new[] { new SetReleaseDrawing { DrawingId = a.Id, DrawingName = a.Name, Quantity = 4 } }));
+                sets.Releases.Add(Release(new DateTime(2026, 10, 21, 12, 0, 0, DateTimeKind.Utc),
+                    Array.Empty<SetReleaseLine>(),
+                    new[] { new SetReleaseDrawing { DrawingId = a.Id, DrawingName = a.Name, Quantity = 1 } }));
+
+                using var form = new DrawingSetsForm(sets, library, Server);
+                var view = form.Releases;
+                Run(form.ShowReleasesAsync());
+                form.Show();
+                var releases = Field<DataGridView>(view, "releaseGrid");
+                PumpUntil(() => releases.Rows.Count == 2, "the releases");
+
+                Assert.False(Field<TableLayoutPanel>(view, "filterTable").Visible);
+                Assert.Equal("Released", releases.Columns["multiplierColumn"]!.HeaderText);
+                Assert.Equal(new object[] { "SYN-A ×1", "Synthetic kit ×2, Synthetic frame; SYN-A ×4" },
+                    releases.Rows.Cast<DataGridViewRow>().Select(r => r.Cells["multiplierColumn"].Value));
+                var newRelease = Field<Button>(view, "newReleaseButton");
+                Assert.False(newRelease.Visible);
+
+                form.EnableRelease(new MemoryNests(), (_, _) => { });
+                Assert.True(newRelease.Visible);
+                newRelease.PerformClick();
+                Assert.False(form.ShowsReleases);
+                Assert.True(form.ReleasePanel.Visible);
+
+                // A release made meanwhile shows once the tab is shown again.
+                sets.Releases.Add(Release(DateTime.UtcNow, new[] { new SetReleaseLine { SetId = set.Id, SetRevision = 1, SetName = set.Name } },
+                    Array.Empty<SetReleaseDrawing>()));
+                Run(form.ShowReleasesAsync());
+                PumpUntil(() => releases.Rows.Count == 3, "the re-read releases");
+                Assert.Equal("Synthetic kit", releases.Rows[0].Cells["multiplierColumn"].Value);
+            },
+            TestTimeout,
+            "The new release test did not complete.");
+    }
+
     [Fact]
     public void Releases_ListsEachReleaseWithProgress_AndItsNestsStates()
     {
@@ -314,157 +788,6 @@ public class SetReleaseFormsTests
             "The releases view test did not complete.");
     }
 
-    [Fact]
-    public void Release_OfATypedInSecondSet_MergesOneGroupIntoADraft_UnlessItIsOpen()
-    {
-        StaTestThread.Run(
-            () =>
-            {
-                var library = new PackageLibrary();
-                var a = library.Add("SYN-A", "Synthetic Steel");
-                var b = library.Add("SYN-B", "Synthetic Steel");
-                var c = library.Add("SYN-C", "Synthetic Aluminum");
-                var sets = new InMemoryDrawingSets();
-                var first = CreateSet(sets, "First kit", (a, 1), (c, 1));
-                CreateSet(sets, "Second kit", (b, 2));
-                var nests = new MemoryNests();
-                var draft = nests.AddDraft("N26-0007", "Synthetic Steel", "Grade A", 0.25);
-                var opened = new List<NestRecord>();
-                var messages = new List<string>();
-
-                using var form = new ReleaseSetForm(sets, library, nests, Server, first, (_, record) => opened.Add(record));
-                form.ShowMessage = (text, _, _) => { messages.Add(text); return DialogResult.OK; };
-                form.CreateNest = (group, _) => Task.FromResult(new Nest("N26-0100") { Units = group.Units });
-                var openTabs = new HashSet<Guid> { draft.Id };
-                form.IsNestOpen = openTabs.Contains;
-                form.Show();
-
-                Field<ComboBox>(form, "addSetCombo").Text = "second KIT";
-                Run(form.AddTypedSetAsync());
-                Assert.Equal(new[] { ("First kit", 1), ("Second kit", 1) }, form.Lines().Select(l => (l.Set.Name, l.Quantity)));
-                Assert.False(form.AddLine(first, 2));
-                Field<DataGridView>(form, "setGrid").Rows[1].Cells["kitsColumn"].Value = "2";
-
-                var grid = Field<DataGridView>(form, "groupGrid");
-                DataGridViewRow Steel() => grid.Rows.Cast<DataGridViewRow>().Single(r => ((SetReleaseGroup)r.Tag!).MaterialName == "Synthetic Steel");
-                PumpUntil(() => ((DataGridViewComboBoxCell)Steel().Cells["targetColumn"]).Items.Count == 2, "the drafts to merge into");
-                // A draft to merge into shows the Nest column while Options is collapsed.
-                Assert.False(form.OptionsExpanded);
-                Assert.True(grid.Columns["targetColumn"]!.Visible);
-                Assert.Contains("A Draft nest of the same material exists", Field<Label>(form, "previewLabel").Text);
-                Assert.Equal(new object[] { 1, 4 }, new[] { a, b }.Select(d => (object)((SetReleaseGroup)Steel().Tag!).Items.Single(i => i.Drawing.Id == d.Id).Quantity));
-                var mergeChoice = (string)((DataGridViewComboBoxCell)Steel().Cells["targetColumn"]).Items[1]!;
-                Assert.StartsWith("Merge into N26-0007 (1 sheet", mergeChoice);
-
-                // An open draft is refused and the group stays a new nest.
-                Steel().Cells["targetColumn"].Value = mergeChoice;
-                Assert.Contains("is open in a tab here", Assert.Single(messages));
-                Assert.Equal("New Draft nest", Steel().Cells["targetColumn"].Value);
-                Assert.Empty(form.ChosenMerges());
-
-                openTabs.Clear();
-                Steel().Cells["targetColumn"].Value = mergeChoice;
-                Assert.Same(draft, form.ChosenMerges().Values.Single());
-                Assert.Contains("Replaces the layout of 'N26-0007'", (string)Steel().Cells["statusColumn"].Value);
-                Assert.Contains("1 new Draft nest, 1 merge, 6 parts", Field<Label>(form, "summaryLabel").Text);
-                Assert.Contains("Creates 1 nest and merges into 1 Draft nest: ", Field<Label>(form, "previewLabel").Text);
-                Assert.Contains("Synthetic Steel Grade A 0.25 in into 'N26-0007'", Field<Label>(form, "previewLabel").Text);
-
-                Run(form.ReleaseAsync());
-
-                Assert.Contains("1 new, 1 merged into existing drafts", messages[^1]);
-                var release = Assert.Single(sets.Releases);
-                Assert.Equal(new[] { ("First kit", 1), ("Second kit", 2) }, release.Sets.Select(l => (l.SetName, l.Quantity)));
-                var merged = release.Nests.Single(n => n.Kind == SetReleaseNestKind.Merged);
-                Assert.Equal((draft.Id, (int?)draft.Revision, draft.Revision + 1), (merged.NestId, merged.RevisionBefore, merged.RevisionAfter));
-                Assert.Equal(SetReleaseNestKind.Created, release.Nests.Single(n => n.NestId != draft.Id).Kind);
-                Assert.Equal(2, opened.Count);
-                Assert.StartsWith("Merged into N26-0007", (string)Steel().Cells["statusColumn"].Value);
-            },
-            TestTimeout,
-            "The multi-set merge release test did not complete.");
-    }
-
-    [Fact]
-    public void NestAfterRelease_NestsEachGroupWithAutoNest_AndListsItsSheets()
-    {
-        StaTestThread.Run(
-            () =>
-            {
-                var library = new PackageLibrary();
-                var a = library.Add("SYN-A", "Synthetic Steel");
-                var sets = new InMemoryDrawingSets();
-                var set = CreateSet(sets, (a, 3));
-                var opened = new List<Nest>();
-                var questions = new List<string>();
-
-                using var form = new ReleaseSetForm(sets, library, new MemoryNests(), Server, set, (nest, _) => opened.Add(nest));
-                form.ShowMessage = (text, _, _) => { questions.Add(text); return DialogResult.OK; };
-                form.CreateNest = (group, _) =>
-                {
-                    var nest = new Nest("N26-0200") { Units = group.Units };
-                    nest.PlateDefaults.Size = new OpenNest.Geometry.Size(48, 96);
-                    return Task.FromResult(nest);
-                };
-                form.Show();
-                Assert.True(Field<CheckBox>(form, "nestAfterReleaseCheckBox").Checked);
-
-                Run(form.ReleaseAsync());
-
-                Assert.Contains("Each is nested with Auto Nest", Assert.Single(questions));
-                var nest = Assert.Single(opened);
-                Assert.Equal(3, nest.Plates.Sum(p => p.Parts.Count * p.Quantity));
-                Assert.Equal(0, Assert.Single(nest.Drawings).Quantity.Remaining);
-                var status = (string)Field<DataGridView>(form, "groupGrid").Rows[0].Cells["statusColumn"].Value;
-                Assert.StartsWith("Created N26-0200 — Nested on 1 sheet, ", status);
-            },
-            TestTimeout,
-            "The nest after release test did not complete.");
-    }
-
-    [Fact]
-    public void NestAfterRelease_Unticked_LeavesNestsAndMergedDraftsForAutoNest()
-    {
-        StaTestThread.Run(
-            () =>
-            {
-                var library = new PackageLibrary();
-                var a = library.Add("SYN-A", "Synthetic Steel");
-                var sets = new InMemoryDrawingSets();
-                var set = CreateSet(sets, (a, 2));
-                var nests = new MemoryNests();
-                var draft = nests.AddDraft("N26-0007", "Synthetic Steel", "Grade A", 0.25);
-                var questions = new List<string>();
-                var renested = 0;
-
-                using var form = new ReleaseSetForm(sets, library, nests, Server, set, (_, _) => { });
-                form.ShowMessage = (text, _, _) => { questions.Add(text); return DialogResult.OK; };
-                form.CreateNest = (group, _) => Task.FromResult(new Nest("N") { Units = group.Units });
-                form.Renest = (_, _) => { renested++; return Task.FromResult(new SetReleaseRenest(true, "")); };
-                form.Show();
-                var row = Field<DataGridView>(form, "groupGrid").Rows[0];
-                PumpUntil(() => ((DataGridViewComboBoxCell)row.Cells["targetColumn"]).Items.Count == 2, "the drafts to merge into");
-                row.Cells["targetColumn"].Value = ((DataGridViewComboBoxCell)row.Cells["targetColumn"]).Items[1];
-                Assert.Contains("and nests again", (string)row.Cells["statusColumn"].Value);
-
-                Field<CheckBox>(form, "nestAfterReleaseCheckBox").Checked = false;
-                Assert.Contains("and leaves it for Auto Nest", (string)row.Cells["statusColumn"].Value);
-
-                Run(form.ReleaseAsync());
-
-                Assert.Equal(0, renested);
-                Assert.Contains("layout is cleared for Auto Nest", Assert.Single(questions));
-                Assert.DoesNotContain("nested with Auto Nest", questions[0]);
-                var merged = Assert.Single(form.Result!.Created);
-                Assert.Same(draft, merged.MergedInto);
-                Assert.Empty(merged.Nest!.Plates);
-                Assert.Null(merged.Renest);
-                Assert.False(Field<CheckBox>(form, "nestAfterReleaseCheckBox").Enabled);
-            },
-            TestTimeout,
-            "The release without nesting test did not complete.");
-    }
-
     [Fact]
     public void Releases_UndoOffersToLeaveChangedNests_AndShowsWhatTheReleaseDid()
     {
@@ -544,131 +867,6 @@ public class SetReleaseFormsTests
             "The release undo test did not complete.");
     }
 
-    [Fact]
-    public void Browser_Release_ReadsTheSetWithItsMembers_OnlyWhenEnabled()
-    {
-        StaTestThread.Run(
-            () =>
-            {
-                var library = new PackageLibrary();
-                var a = library.Add("SYN-A", "Synthetic Steel");
-                var sets = new InMemoryDrawingSets();
-                CreateSet(sets, (a, 2));
-                var released = new List<DrawingSetRecord>();
-
-                using var host = new Form();
-                var browser = new DrawingSetBrowser { Dock = DockStyle.Fill };
-                host.Controls.Add(browser);
-                browser.Initialize(sets, library, Server);
-                browser.ShowRelease = released.Add;
-                host.Show();
-                Run(browser.RefreshAsync());
-                var releaseButton = Field<Button>(browser, "releaseButton");
-                Assert.False(releaseButton.Visible);
-
-                browser.EnableRelease(new MemoryNests(), (_, _) => { });
-                Assert.True(releaseButton.Visible);
-                Assert.True(releaseButton.Enabled);
-                // Make Nests is the Sets tab's primary command.
-                Assert.True(releaseButton.Font.Bold);
-                Run(browser.ReleaseSelectedAsync());
-
-                var set = Assert.Single(released);
-                Assert.Equal("SYN-A", Assert.Single(set.Members).Drawing!.Name);
-            },
-            TestTimeout,
-            "The browser release test did not complete.");
-    }
-
-    [Fact]
-    public void Release_OfASetAndDrawingsAddedFromTheLibrary_GroupsThemTogether_AndRecordsBoth()
-    {
-        StaTestThread.Run(
-            () =>
-            {
-                var library = new PackageLibrary();
-                var a = library.Add("SYN-A", "Synthetic Steel");
-                library.Add("SYN-B", "Synthetic Steel");
-                library.Add("SYN-C", "Synthetic Aluminum");
-                var sets = new InMemoryDrawingSets();
-                var set = CreateSet(sets, (a, 2));
-                var nests = new MemoryNests();
-                var questions = new List<string>();
-
-                using var form = new ReleaseSetForm(sets, library, nests, Server, set, (_, _) => { });
-                form.ShowMessage = (text, _, _) => { questions.Add(text); return DialogResult.OK; };
-                var created = 0;
-                form.CreateNest = (group, _) => Task.FromResult(new Nest($"N26-{++created:D4}") { Units = group.Units });
-                form.Show();
-                using var picker = new AddReleaseDrawingsForm(library, Server, form.AddDrawingLines,
-                    id => form.DrawingLines().Any(l => l.Drawing.Id == id));
-                picker.Show(form);
-                Run(picker.RefreshAsync());
-
-                picker.Select("SYN-A", "SYN-C");
-                picker.Quantity = 5;
-                picker.AddSelectedDrawings();
-                Assert.Equal("Added 2 drawings.", picker.Status);
-                picker.Select("SYN-C", "SYN-B");
-                picker.Quantity = 1;
-                picker.AddSelectedDrawings();
-                Assert.Equal("Added 'SYN-B'. Already listed (change the quantity there): 'SYN-C'.", picker.Status);
-
-                var lines = Field<DataGridView>(form, "setGrid");
-                Assert.Equal(new object[] { "Set", "Drawing", "Drawing", "Drawing" },
-                    lines.Rows.Cast<DataGridViewRow>().Select(r => r.Cells["lineTypeColumn"].Value));
-                lines.Rows[2].Cells["kitsColumn"].Value = "40";
-                Assert.Equal(new[] { ("SYN-A", 5), ("SYN-C", 40), ("SYN-B", 1) }, form.DrawingLines().Select(l => (l.Drawing.Name, l.Quantity)));
-                var grid = Field<DataGridView>(form, "groupGrid");
-                Assert.Equal(new object[] { 40, 8 }, grid.Rows.Cast<DataGridViewRow>().Select(r => r.Cells["partsColumn"].Value));
-
-                Run(form.ReleaseAsync());
-
-                Assert.Contains("Make 2 Draft nests from set 'Synthetic kit' and 3 drawings?", Assert.Single(questions));
-                var release = Assert.Single(sets.Releases);
-                Assert.Equal(new[] { 5, 40, 1 }, release.Drawings.Select(d => d.Quantity));
-                var steel = release.Nests.Single(n => n.MaterialName == "Synthetic Steel");
-                Assert.Equal(new[] { ((Guid?)set.Id, 2), (null, 5), (null, 1) }, steel.Items.Select(i => (i.SetId, i.Quantity)));
-                Assert.Equal(2, nests.Uploaded.Count);
-                Assert.False(Field<Button>(form, "addDrawingsButton").Enabled);
-            },
-            TestTimeout,
-            "The drawing release test did not complete.");
-    }
-
-    [Fact]
-    public void Release_OfADrawingAlone_OnAServerWithoutDrawingsOnTheirOwn_SavesNothing()
-    {
-        StaTestThread.Run(
-            () =>
-            {
-                var library = new PackageLibrary();
-                var a = library.Add("SYN-A", "Synthetic Steel");
-                var sets = new InMemoryDrawingSets { WithoutDrawingReleases = true };
-                var nests = new MemoryNests();
-
-                using var form = new ReleaseSetForm(sets, library, nests, Server, Array.Empty<DrawingSetRecord>(),
-                    new[] { new SetReleaseDrawingLine(a, 4) }, (_, _) => { });
-                form.ShowMessage = (_, _, _) => DialogResult.OK;
-                form.CreateNest = (group, _) => Task.FromResult(new Nest("N") { Units = group.Units });
-                form.Show();
-
-                Assert.Equal("Release 'SYN-A'", form.Text);
-                Assert.False(Field<Button>(form, "removeSetButton").Enabled);
-                Assert.Contains("4 parts", Field<Label>(form, "summaryLabel").Text);
-
-                Run(form.ReleaseAsync());
-
-                Assert.Empty(nests.Uploaded);
-                Assert.Empty(sets.Releases);
-                Assert.Equal("Nothing saved. See Status.", Field<Label>(form, "statusLabel").Text);
-                Assert.Contains("does not support releasing library drawings on their own",
-                    (string)Field<DataGridView>(form, "groupGrid").Rows[0].Cells["statusColumn"].Value);
-            },
-            TestTimeout,
-            "The old-server drawing release test did not complete.");
-    }
-
     [Fact]
     public void Releases_OfADrawing_ListsReleasesThatHadItOnItsOwn_AndUndoesOne()
     {
@@ -712,138 +910,6 @@ public class SetReleaseFormsTests
             "The drawing releases view test did not complete.");
     }
 
-    [Fact]
-    public void AllReleases_NamesWhatEachReleased_AndNewReleaseRereadsOnceOneIsRecorded()
-    {
-        StaTestThread.Run(
-            () =>
-            {
-                var library = new PackageLibrary();
-                var a = library.Add("SYN-A", "Synthetic Steel");
-                var sets = new InMemoryDrawingSets();
-                var set = CreateSet(sets, (a, 1));
-                var other = CreateSet(sets, "Synthetic frame", (a, 2));
-                SetReleaseRecord Release(DateTime at, SetReleaseLine[] lines, SetReleaseDrawing[] drawings) => new()
-                {
-                    Id = Guid.NewGuid(),
-                    Sets = lines,
-                    Drawings = drawings,
-                    ReleasedBy = "Synthetic operator",
-                    ReleasedAt = at,
-                    Nests = new[] { new SetReleaseNest { NestId = Guid.NewGuid(), Nest = new NestRecord { Name = "N1", Status = NestStatus.Draft } } },
-                };
-                sets.Releases.Add(Release(new DateTime(2026, 10, 20, 12, 0, 0, DateTimeKind.Utc),
-                    new[]
-                    {
-                        new SetReleaseLine { SetId = set.Id, SetRevision = 1, SetName = set.Name, Quantity = 2 },
-                        new SetReleaseLine { SetId = other.Id, SetRevision = 1, SetName = other.Name, Quantity = 1 },
-                    },
-                    new[] { new SetReleaseDrawing { DrawingId = a.Id, DrawingName = a.Name, Quantity = 4 } }));
-                sets.Releases.Add(Release(new DateTime(2026, 10, 21, 12, 0, 0, DateTimeKind.Utc),
-                    Array.Empty<SetReleaseLine>(),
-                    new[] { new SetReleaseDrawing { DrawingId = a.Id, DrawingName = a.Name, Quantity = 1 } }));
-
-                using var form = new DrawingSetsForm(sets, library, Server);
-                var view = form.Releases;
-                var opened = 0;
-                view.ShowNewRelease = () =>
-                {
-                    opened++;
-                    // The dialog records a release before it closes; a cancelled dialog records none.
-                    if (opened == 2)
-                        sets.Releases.Add(Release(DateTime.UtcNow, new[] { new SetReleaseLine { SetId = set.Id, SetRevision = 1, SetName = set.Name } },
-                            Array.Empty<SetReleaseDrawing>()));
-                    return opened == 2;
-                };
-                Run(form.ShowReleasesAsync());
-                form.Show();
-                var releases = Field<DataGridView>(view, "releaseGrid");
-                PumpUntil(() => releases.Rows.Count == 2, "the releases");
-
-                Assert.False(Field<TableLayoutPanel>(view, "filterTable").Visible);
-                Assert.False(releases.Columns["revisionColumn"]!.Visible);
-                Assert.Equal("Released", releases.Columns["multiplierColumn"]!.HeaderText);
-                Assert.Equal(new object[] { "SYN-A ×1", "Synthetic kit ×2, Synthetic frame; SYN-A ×4" },
-                    releases.Rows.Cast<DataGridViewRow>().Select(r => r.Cells["multiplierColumn"].Value));
-                Assert.Equal("Releases 1-2 of 2", Field<Label>(view, "summaryLabel").Text);
-                Assert.False(Field<Button>(view, "newReleaseButton").Visible);
-
-                Run(view.NewReleaseAsync());
-                Assert.Equal(2, releases.Rows.Count);
-
-                Run(view.NewReleaseAsync());
-                PumpUntil(() => releases.Rows.Count == 3, "the re-read releases");
-                Assert.Equal("Synthetic kit", releases.Rows[0].Cells["multiplierColumn"].Value);
-                Assert.Equal("Releases 1-3 of 3", Field<Label>(view, "summaryLabel").Text);
-            },
-            TestTimeout,
-            "The all-releases view test did not complete.");
-    }
-
-    [Fact]
-    public void Release_ListsTheFirstSetsInTheAddSetBox_BeforeAnythingIsTyped()
-    {
-        StaTestThread.Run(
-            () =>
-            {
-                var library = new PackageLibrary();
-                var a = library.Add("SYN-A", "Synthetic Steel");
-                var sets = new InMemoryDrawingSets();
-                CreateSet(sets, "Synthetic kit", (a, 1));
-                CreateSet(sets, "Synthetic frame", (a, 2));
-                var nests = new MemoryNests();
-
-                using var form = new ReleaseSetForm(sets, library, nests, Server, Array.Empty<DrawingSetRecord>(),
-                    Array.Empty<SetReleaseDrawingLine>(), (_, _) => { });
-                form.Show();
-                var combo = Field<ComboBox>(form, "addSetCombo");
-                PumpUntil(() => combo.Items.Count == 2, "the set list");
-
-                Assert.Equal(new[] { "Synthetic frame", "Synthetic kit" }, combo.Items.Cast<object>().Select(i => i.ToString()!.Split(" (")[0]));
-                Assert.Equal("", combo.Text);
-                Assert.False(combo.DroppedDown);
-            },
-            TestTimeout,
-            "The set list test did not complete.");
-    }
-
-    [Fact]
-    public void Release_StartedEmpty_AddsASetAndReleasesIt()
-    {
-        StaTestThread.Run(
-            () =>
-            {
-                var library = new PackageLibrary();
-                var a = library.Add("SYN-A", "Synthetic Steel");
-                var sets = new InMemoryDrawingSets();
-                var set = CreateSet(sets, (a, 2));
-                var nests = new MemoryNests();
-                var opened = new List<(Nest Nest, NestRecord Record)>();
-
-                using var form = new ReleaseSetForm(sets, library, nests, Server, Array.Empty<DrawingSetRecord>(),
-                    Array.Empty<SetReleaseDrawingLine>(), (nest, record) => opened.Add((nest, record)));
-                form.ShowMessage = (_, _, _) => DialogResult.OK;
-                form.CreateNest = (group, _) => Task.FromResult(new Nest("N26-0001") { Units = group.Units });
-                form.Show();
-
-                Assert.Equal("New Release", form.Text);
-                Assert.Empty(Field<DataGridView>(form, "groupGrid").Rows);
-                Assert.False(Field<Button>(form, "releaseButton").Enabled);
-
-                Assert.True(form.AddLine(set, 3));
-                Assert.Equal("Release 'Synthetic kit'", form.Text);
-                Assert.True(Field<Button>(form, "releaseButton").Enabled);
-
-                Run(form.ReleaseAsync());
-
-                Assert.Single(opened);
-                Assert.Equal(6, opened[0].Nest.Drawings.Single().Quantity.Required);
-                Assert.Equal(3, Assert.Single(sets.Releases).Sets.Single().Quantity);
-            },
-            TestTimeout,
-            "The empty release test did not complete.");
-    }
-
     [Fact]
     public void DrawingSetsWindow_ReadsEachTabWhenShown_AndASetsReleasesFilterTheReleasesTab_UntilCleared()
     {
@@ -924,6 +990,33 @@ public class SetReleaseFormsTests
         return task.GetAwaiter().GetResult();
     }
 
+    /// <summary>A release panel in a shown window, initialized, with test hooks for messages and new nests.</summary>
+    private static (Form Host, ReleasePanel Panel) ShowPanel(InMemoryDrawingSets sets, PackageLibrary library, MemoryNests nests,
+        Action<Nest, NestRecord>? openNest = null, List<string>? messages = null)
+    {
+        var host = new Form { Width = 900, Height = 700 };
+        var panel = new ReleasePanel { Dock = DockStyle.Fill };
+        host.Controls.Add(panel);
+        panel.Initialize(sets, library, nests, Server, openNest ?? ((_, _) => { }));
+        panel.ShowMessage = (text, _, _) => { messages?.Add(text); return DialogResult.OK; };
+        var created = 0;
+        panel.CreateNest = (group, _) => Task.FromResult(new Nest($"N26-{++created:D4}") { Units = group.Units });
+        // As by default, whatever this PC last chose.
+        Field<CheckBox>(panel, "nestAfterReleaseCheckBox").Checked = true;
+        host.Show();
+        return (host, panel);
+    }
+
+    private static DataGridViewRow GroupRow(ReleasePanel panel, string material) =>
+        Field<DataGridView>(panel, "groupGrid").Rows.Cast<DataGridViewRow>()
+            .Single(r => ((SetReleaseGroup)r.Tag!).MaterialName == material);
+
+    private static string Note(DataGridViewRow row) => (string)row.Cells["statusColumn"].Value;
+
+    private static void DoubleClick(DataGridView grid, int row) =>
+        typeof(DataGridView).GetMethod("OnCellDoubleClick", BindingFlags.Instance | BindingFlags.NonPublic)!
+            .Invoke(grid, new object[] { new DataGridViewCellEventArgs(0, row) });
+
     private static void Run(Task task) => PumpUntil(() => task.IsCompleted, "the operation to finish");
 
     private static T Run<T>(Task<T> task)
@@ -1031,7 +1124,7 @@ public class SetReleaseFormsTests
         public List<NestRecord> Drafts { get; } = new();
 
         /// <summary>A Draft nest on one empty sheet, stored as a real archive at revision 3.</summary>
-        public NestRecord AddDraft(string name, string material, string grade, double thickness)
+        public NestRecord AddDraft(string name, string material, string grade, double thickness, DateTime? savedAt = null)
         {
             var nest = new Nest(name) { Units = Units.Inches, Material = new Material(material, grade), Thickness = thickness, Status = NestStatus.Draft };
             nest.CreatePlate();
@@ -1047,7 +1140,7 @@ public class SetReleaseFormsTests
                 Thickness = thickness,
                 Status = NestStatus.Draft,
                 PlateCount = 1,
-                SavedAt = new DateTime(2026, 10, 21, 9, 0, 0, DateTimeKind.Utc),
+                SavedAt = savedAt ?? new DateTime(2026, 10, 21, 9, 0, 0, DateTimeKind.Utc),
             };
             _revisions[(record.Id, record.Revision)] = stream.ToArray();
             Drafts.Add(record);
diff --git a/OpenNest/Controls/DrawingLibraryView.cs b/OpenNest/Controls/DrawingLibraryView.cs
index 032e7186..20797a92 100644
--- a/OpenNest/Controls/DrawingLibraryView.cs
+++ b/OpenNest/Controls/DrawingLibraryView.cs
@@ -19,14 +19,17 @@ namespace OpenNest.Controls
     /// <see cref="DrawingLibraryBrowseSession"/>, filtered to the nest's material and thickness
     /// unless Show all is ticked. Add downloads the listed revision's exact package, plans it
     /// with <see cref="LibraryDrawingInsert"/>, shows any warning or refusal first and only then
-    /// changes the nest. Opened without a nest, it lists every active drawing and has no Add or
-    /// In This Nest tab; a double-click edits the drawing instead. Edit Drawing changes the
+    /// changes the nest. Opened without a nest, it lists every active drawing and has no In This
+    /// Nest tab; as the Library tab of <see cref="DrawingSetsForm"/> a double-click, Enter or Add
+    /// to Release adds the drawing on its own, at the entered quantity, to the window's
+    /// <see cref="ReleasePanel"/>, and elsewhere a double-click edits it. Edit Drawing changes the
     /// selected drawing's details, notes and nesting settings (Cut first, priority, rotation,
     /// color) on the server as a new revision with the same package. With a set
     /// store, the drawing grid's menu lists the sets a drawing is in, adds it to a set, lists
     /// the releases that had it on its own (the Releases tab of <see cref="DrawingSetsForm"/>,
-    /// filtered to it) and, once release is enabled, releases it; sets themselves are browsed
-    /// and released in <see cref="DrawingSetsForm"/>.
+    /// filtered to it) and, once release is enabled, adds it to the release (with a nest, Make
+    /// Nests opens the release dialog on it); sets themselves are browsed and released in
+    /// <see cref="DrawingSetsForm"/>.
     /// The details pane previews the selected revision's geometry, downloaded shortly after
     /// the selection settles and cached per revision for the dialog's lifetime. The In This
     /// Nest tab lists the nest's drawings and edits their required quantities in place.
@@ -73,10 +76,11 @@ namespace OpenNest.Controls
         internal Func<DrawingSetEditSession, DrawingSetRecord> EditSet { get; set; }
 
         /// <summary>
-        /// Shows the release dialog for a drawing read from the library, at a quantity; set by
-        /// <see cref="EnableRelease"/> and replaced by tests.
+        /// Adds a drawing read from the library, at a quantity, to the release: the host's
+        /// release panel, or with a nest the release dialog; set by <see cref="EnableRelease(Action{DrawingLibraryRecord, int})"/>
+        /// or <see cref="EnableRelease(INestRepository, Action{Nest, NestRecord}, Func{Guid, bool})"/>.
         /// </summary>
-        internal Action<DrawingLibraryRecord, int> ShowRelease { get; set; }
+        internal Action<DrawingLibraryRecord, int> AddToRelease { get; private set; }
 
         /// <summary>
         /// Shows the releases that had a drawing on its own: opens a Drawing Sets window on its
@@ -387,18 +391,43 @@ namespace OpenNest.Controls
         {
             if (e.RowIndex < 0)
                 return;
-            if (nest == null)
-                await EditSelectedAsync();
-            else
-                await AddSelectedAsync();
+            await ActivateSelectedAsync();
         }
 
-        private async void AddButton_Click(object sender, EventArgs e) => await AddSelectedAsync();
+        // Without a nest a drawing is added to the release where there is one, else edited.
+        private Task ActivateSelectedAsync() =>
+            nest != null ? AddSelectedAsync()
+                : AddToRelease != null ? AddSelectedToReleaseAsync()
+                : EditSelectedAsync();
+
+        private async void AddButton_Click(object sender, EventArgs e) =>
+            await (nest == null ? AddSelectedToReleaseAsync() : AddSelectedAsync());
 
         /// <summary>
-        /// Lets the drawing menu release a drawing on its own: nests are saved through
-        /// <paramref name="nests"/> and each is opened with <paramref name="openNest"/>; a nest
-        /// <paramref name="isNestOpen"/> reports as open in a tab is never merged into.
+        /// Without a nest: a double-click, Enter, Add to Release or the drawing menu adds the
+        /// drawing on its own, at the entered quantity, through <paramref name="addToRelease"/>
+        /// (the Drawing Sets window's release panel).
+        /// </summary>
+        public void EnableRelease(Action<DrawingLibraryRecord, int> addToRelease)
+        {
+            if (sets == null || nest != null)
+                return;
+            AddToRelease = addToRelease ?? throw new ArgumentNullException(nameof(addToRelease));
+            addButton.Text = "Add to Release";
+            addButton.Visible = true;
+            releaseMenuItem.Text = "Add to Release";
+            releaseMenuItem.ToolTipText = "Add this drawing on its own, at the entered quantity, to the release";
+            releaseSeparator.Visible = true;
+            releaseMenuItem.Visible = true;
+            UpdateFilterLabel();
+            UpdateCommands();
+        }
+
+        /// <summary>
+        /// With a nest: lets the drawing menu release a drawing on its own in the release dialog:
+        /// nests are saved through <paramref name="nests"/> and each is opened with
+        /// <paramref name="openNest"/>; a nest <paramref name="isNestOpen"/> reports as open in a
+        /// tab is never merged into.
         /// </summary>
         public void EnableRelease(INestRepository nests, Action<Nest, NestRecord> openNest, Func<Guid, bool> isNestOpen = null)
         {
@@ -406,7 +435,7 @@ namespace OpenNest.Controls
                 return;
             ArgumentNullException.ThrowIfNull(nests);
             ArgumentNullException.ThrowIfNull(openNest);
-            ShowRelease = (record, quantity) =>
+            AddToRelease = (record, quantity) =>
             {
                 using var form = new ReleaseSetForm(sets, library, nests, serverUrl, Array.Empty<DrawingSetRecord>(),
                     new[] { new SetReleaseDrawingLine(record, quantity) }, openNest)
@@ -431,11 +460,11 @@ namespace OpenNest.Controls
             editMenuItem.Enabled = record is { Archived: false } && !adding;
             usedInSetsMenuItem.Enabled = record != null && !adding;
             addToSetMenuItem.Enabled = record != null && !adding;
-            releaseMenuItem.Enabled = record is { Archived: false } && !adding && ShowRelease != null;
+            releaseMenuItem.Enabled = record is { Archived: false } && !adding && AddToRelease != null;
             releasesMenuItem.Enabled = record != null && !adding;
         }
 
-        private async void ReleaseMenuItem_Click(object sender, EventArgs e) => await ReleaseSelectedAsync();
+        private async void ReleaseMenuItem_Click(object sender, EventArgs e) => await AddSelectedToReleaseAsync();
 
         private void ReleasesMenuItem_Click(object sender, EventArgs e)
         {
@@ -444,13 +473,13 @@ namespace OpenNest.Controls
         }
 
         /// <summary>
-        /// Reads the selected drawing's current record and opens the release dialog with it at
-        /// the entered quantity; more drawings and sets can be added there.
+        /// Reads the selected drawing's current record and adds it to the release at the entered
+        /// quantity.
         /// </summary>
-        internal async Task ReleaseSelectedAsync()
+        internal async Task AddSelectedToReleaseAsync()
         {
             var listed = SelectedRecord();
-            if (listed == null || ShowRelease == null || adding)
+            if (listed == null || AddToRelease == null || adding)
                 return;
 
             DrawingLibraryRecord current;
@@ -484,7 +513,7 @@ namespace OpenNest.Controls
                 return;
             }
 
-            ShowRelease(current, (int)quantityBox.Value);
+            AddToRelease(current, (int)quantityBox.Value);
         }
 
         private async void UsedInSetsMenuItem_Click(object sender, EventArgs e) => await ShowUsedInSetsAsync();
@@ -623,7 +652,7 @@ namespace OpenNest.Controls
         {
             if (keyData == Keys.Enter && drawingGrid.ContainsFocus && SelectedRecord() != null)
             {
-                _ = nest == null ? EditSelectedAsync() : AddSelectedAsync();
+                _ = ActivateSelectedAsync();
                 return true;
             }
 
@@ -743,7 +772,8 @@ namespace OpenNest.Controls
 
         private void UpdateCommands()
         {
-            addButton.Enabled = !adding && nest != null && SelectedRecord() != null;
+            addButton.Enabled = !adding && (nest != null ? SelectedRecord() != null
+                : AddToRelease != null && SelectedRecord() is { Archived: false });
             editButton.Enabled = !adding && SelectedRecord() is { Archived: false };
         }
 
@@ -751,7 +781,9 @@ namespace OpenNest.Controls
         {
             if (nest == null)
             {
-                filterLabel.Text = "Showing every active drawing. Double-click one to edit it.";
+                filterLabel.Text = AddToRelease != null
+                    ? "Showing every active drawing. Double-click one to add it to the release."
+                    : "Showing every active drawing. Double-click one to edit it.";
                 return;
             }
 
diff --git a/OpenNest/Controls/DrawingSetBrowser.Designer.cs b/OpenNest/Controls/DrawingSetBrowser.Designer.cs
index 55677f7c..b46d60a3 100644
--- a/OpenNest/Controls/DrawingSetBrowser.Designer.cs
+++ b/OpenNest/Controls/DrawingSetBrowser.Designer.cs
@@ -48,6 +48,9 @@ namespace OpenNest.Controls
             statusLabel = new System.Windows.Forms.Label();
             searchTimer = new System.Windows.Forms.Timer(components);
             moreMenu = new System.Windows.Forms.ContextMenuStrip(components);
+            addToReleaseMenuItem = new System.Windows.Forms.ToolStripMenuItem();
+            editMenuItem = new System.Windows.Forms.ToolStripMenuItem();
+            editSeparator = new System.Windows.Forms.ToolStripSeparator();
             archiveMenuItem = new System.Windows.Forms.ToolStripMenuItem();
             historyMenuItem = new System.Windows.Forms.ToolStripMenuItem();
             previewMenuItem = new System.Windows.Forms.ToolStripMenuItem();
@@ -135,7 +138,7 @@ namespace OpenNest.Controls
             setGrid.AllowUserToDeleteRows = false;
             setGrid.Columns.AddRange(new System.Windows.Forms.DataGridViewColumn[] { nameColumn, customerColumn, membersColumn, revisionColumn, savedColumn, savedByColumn, stateColumn });
             setGrid.Dock = System.Windows.Forms.DockStyle.Fill;
-            setGrid.MultiSelect = false;
+            setGrid.MultiSelect = true;
             setGrid.Name = "setGrid";
             setGrid.ReadOnly = true;
             setGrid.RowHeadersVisible = false;
@@ -319,7 +322,7 @@ namespace OpenNest.Controls
             releaseButton.Margin = new System.Windows.Forms.Padding(12, 3, 3, 3);
             releaseButton.Name = "releaseButton";
             releaseButton.TabIndex = 7;
-            releaseButton.Text = "&Make Nests...";
+            releaseButton.Text = "&Add to Release";
             releaseButton.UseVisualStyleBackColor = true;
             releaseButton.Visible = false;
             releaseButton.Click += ReleaseButton_Click;
@@ -340,10 +343,29 @@ namespace OpenNest.Controls
             //
             // moreMenu
             //
-            moreMenu.Items.AddRange(new System.Windows.Forms.ToolStripItem[] { previewMenuItem, archiveMenuItem, historyMenuItem, releasesMenuItem, importSeparator, importBomMenuItem });
+            moreMenu.Items.AddRange(new System.Windows.Forms.ToolStripItem[] { addToReleaseMenuItem, editMenuItem, previewMenuItem, editSeparator, archiveMenuItem, historyMenuItem, releasesMenuItem, importSeparator, importBomMenuItem });
             moreMenu.Name = "moreMenu";
             moreMenu.Opening += MoreMenu_Opening;
             //
+            // addToReleaseMenuItem
+            //
+            addToReleaseMenuItem.Enabled = false;
+            addToReleaseMenuItem.Name = "addToReleaseMenuItem";
+            addToReleaseMenuItem.Text = "Add to Re&lease";
+            addToReleaseMenuItem.Visible = false;
+            addToReleaseMenuItem.Click += ReleaseButton_Click;
+            //
+            // editMenuItem
+            //
+            editMenuItem.Enabled = false;
+            editMenuItem.Name = "editMenuItem";
+            editMenuItem.Text = "&Edit Set...";
+            editMenuItem.Click += EditButton_Click;
+            //
+            // editSeparator
+            //
+            editSeparator.Name = "editSeparator";
+            //
             // previewMenuItem
             //
             previewMenuItem.Enabled = false;
@@ -369,7 +391,7 @@ namespace OpenNest.Controls
             //
             releasesMenuItem.Enabled = false;
             releasesMenuItem.Name = "releasesMenuItem";
-            releasesMenuItem.Text = "Re&leases...";
+            releasesMenuItem.Text = "Relea&ses...";
             releasesMenuItem.Click += ReleasesMenuItem_Click;
             //
             // importSeparator
@@ -432,6 +454,9 @@ namespace OpenNest.Controls
         private System.Windows.Forms.Label statusLabel;
         private System.Windows.Forms.Timer searchTimer;
         private System.Windows.Forms.ContextMenuStrip moreMenu;
+        private System.Windows.Forms.ToolStripMenuItem addToReleaseMenuItem;
+        private System.Windows.Forms.ToolStripMenuItem editMenuItem;
+        private System.Windows.Forms.ToolStripSeparator editSeparator;
         private System.Windows.Forms.ToolStripMenuItem archiveMenuItem;
         private System.Windows.Forms.ToolStripMenuItem historyMenuItem;
         private System.Windows.Forms.ToolStripMenuItem previewMenuItem;
diff --git a/OpenNest/Controls/DrawingSetBrowser.cs b/OpenNest/Controls/DrawingSetBrowser.cs
index 4e52677a..07558d31 100644
--- a/OpenNest/Controls/DrawingSetBrowser.cs
+++ b/OpenNest/Controls/DrawingSetBrowser.cs
@@ -1,8 +1,10 @@
 using System;
+using System.Collections.Generic;
 using System.ComponentModel;
 using System.Drawing;
 using System.Globalization;
 using System.IO;
+using System.Linq;
 using System.Net.Http;
 using System.Threading.Tasks;
 using System.Windows.Forms;
@@ -15,11 +17,13 @@ namespace OpenNest.Controls
     /// <summary>
     /// Browses the server's drawing sets one bounded page at a time through
     /// <see cref="DrawingSetBrowseSession"/>, and creates, edits, archives or restores them and
-    /// shows their history. <see cref="DrawingSetsForm"/> hosts it on its Sets tab to manage and
-    /// release sets, and shows a set's Releases on its Releases tab. New Set, Edit, Preview and
-    /// Make Nests are buttons; Preview, Archive/Restore, History and Releases, then Import BOM,
-    /// are in the More menu, which is also the list's right-click menu. Preview shows all of a
-    /// set's drawings in one window at the same scale (<see cref="DrawingSetPreviewForm"/>). In pick mode
+    /// shows their history. <see cref="DrawingSetsForm"/> hosts it on its Sets tab beside its
+    /// <see cref="ReleasePanel"/>, and shows a set's Releases on its Releases tab. Once release is
+    /// enabled, a double-click or Enter adds the set to the release (Add to Release does so for
+    /// every selected set); Edit opens the set editor. New Set, Edit, Preview and Add to Release
+    /// are buttons; Add to Release, Edit Set, Preview, Archive/Restore, History and Releases, then
+    /// Import BOM, are in the More menu, which is also the list's right-click menu. Preview shows
+    /// all of a set's drawings in one window at the same scale (<see cref="DrawingSetPreviewForm"/>). In pick mode
     /// (<see cref="ChooseDrawingSetForm"/>) only active sets are listed, and choosing a set or
     /// New Set raises <see cref="SetActivated"/> or <see cref="NewSetChosen"/> instead.
     /// </summary>
@@ -28,9 +32,6 @@ namespace OpenNest.Controls
         private IDrawingSetStore sets;
         private IDrawingLibraryStore library;
         private string serverUrl;
-        private INestRepository nests;
-        private Action<Nest, NestRecord> openNest;
-        private Func<Guid, bool> isNestOpen = _ => false;
         private DrawingSetBrowseSession session;
         private BrowsePager<DrawingSetPage, DrawingSetSortField> pager;
         private bool pick;
@@ -57,8 +58,8 @@ namespace OpenNest.Controls
         /// <summary>Shows the same-scale preview of a set read with its members; replaced by tests.</summary>
         internal Action<DrawingSetRecord> ShowPreview { get; set; }
 
-        /// <summary>Shows the release dialog for a set read with its members; replaced by tests.</summary>
-        internal Action<DrawingSetRecord> ShowRelease { get; set; }
+        /// <summary>Adds a set read with its members to the release; set by <see cref="EnableRelease"/>.</summary>
+        internal Action<DrawingSetRecord> AddToRelease { get; private set; }
 
         /// <summary>Pick mode: an active set was double-clicked (or chosen with Enter).</summary>
         public event EventHandler SetActivated;
@@ -88,6 +89,14 @@ namespace OpenNest.Controls
         /// <summary>The highlighted set as listed (without members).</summary>
         public DrawingSetRecord SelectedSet => setGrid.CurrentRow?.Tag as DrawingSetRecord;
 
+        /// <summary>The selected sets as listed, in list order; the highlighted one when none is selected.</summary>
+        internal IReadOnlyList<DrawingSetRecord> SelectedSets()
+        {
+            var selected = setGrid.SelectedRows.Cast<DataGridViewRow>().OrderBy(r => r.Index)
+                .Select(r => r.Tag).OfType<DrawingSetRecord>().ToList();
+            return selected.Count > 0 || SelectedSet == null ? selected : new[] { SelectedSet };
+        }
+
         /// <param name="library">Used by the set editor to pick drawings.</param>
         /// <param name="pick">Choose an active set instead of managing them.</param>
         public void Initialize(IDrawingSetStore sets, IDrawingLibraryStore library, string serverUrl, bool pick = false)
@@ -135,11 +144,9 @@ namespace OpenNest.Controls
                 });
                 form.ShowDialog(FindForm());
             };
-            ShowRelease = set =>
-            {
-                using var form = new ReleaseSetForm(sets, library, nests, this.serverUrl, set, openNest) { IsNestOpen = isNestOpen };
-                form.ShowDialog(FindForm());
-            };
+            setGrid.MultiSelect = !pick;
+            // Add to Release acts on every selected set.
+            setGrid.SelectionChanged += (_, _) => UpdateCommands();
 
             if (pick)
             {
@@ -155,19 +162,16 @@ namespace OpenNest.Controls
         }
 
         /// <summary>
-        /// Shows Release, which makes nests from the selected set and any others the operator
-        /// adds: saves them through <paramref name="nests"/> and opens each with
-        /// <paramref name="openNest"/>. <paramref name="isNestOpen"/> says whether a server nest
-        /// is open in a tab, which keeps a release from merging into it.
+        /// Shows Add to Release and makes a double-click or Enter add the set, read with its
+        /// members' current drawings, through <paramref name="addToRelease"/>.
         /// </summary>
-        public void EnableRelease(INestRepository nests, Action<Nest, NestRecord> openNest, Func<Guid, bool> isNestOpen = null)
+        public void EnableRelease(Action<DrawingSetRecord> addToRelease)
         {
-            this.isNestOpen = isNestOpen ?? (_ => false);
             if (session == null || pick)
                 throw new InvalidOperationException("Release needs an initialized set browser that is not picking.");
-            this.nests = nests ?? throw new ArgumentNullException(nameof(nests));
-            this.openNest = openNest ?? throw new ArgumentNullException(nameof(openNest));
+            AddToRelease = addToRelease ?? throw new ArgumentNullException(nameof(addToRelease));
             releaseButton.Visible = true;
+            addToReleaseMenuItem.Visible = true;
             UpdateCommands();
         }
 
@@ -223,6 +227,8 @@ namespace OpenNest.Controls
                 return;
             if (pick)
                 ActivateSelected();
+            else if (AddToRelease != null)
+                await AddSelectedToReleaseAsync(highlightedOnly: true);
             else
                 await EditSelectedAsync();
         }
@@ -249,6 +255,8 @@ namespace OpenNest.Controls
             {
                 if (pick)
                     ActivateSelected();
+                else if (AddToRelease != null)
+                    _ = AddSelectedToReleaseAsync();
                 else
                     _ = EditSelectedAsync();
                 return true;
@@ -277,7 +285,7 @@ namespace OpenNest.Controls
                 ShowReleases?.Invoke(set);
         }
 
-        private async void ReleaseButton_Click(object sender, EventArgs e) => await ReleaseSelectedAsync();
+        private async void ReleaseButton_Click(object sender, EventArgs e) => await AddSelectedToReleaseAsync();
 
         private async void ImportBomMenuItem_Click(object sender, EventArgs e) => await ImportBomAsync();
 
@@ -307,24 +315,41 @@ namespace OpenNest.Controls
                 statusLabel.Text = $"Saved set '{saved.Name}' revision {saved.Revision}.";
         }
 
-        /// <summary>Reads the selected active set with its members' current drawings and opens the release dialog.</summary>
-        internal async Task ReleaseSelectedAsync()
+        /// <summary>
+        /// Reads each selected active set with its members' current drawings and adds it to the
+        /// release at one kit; <paramref name="highlightedOnly"/> takes just the highlighted one,
+        /// as a double-click does.
+        /// </summary>
+        internal async Task AddSelectedToReleaseAsync(bool highlightedOnly = false)
         {
-            var listed = SelectedSet;
-            if (session == null || nests == null || listed == null || listed.Archived || busy)
+            if (session == null || AddToRelease == null || busy)
+                return;
+            var chosen = (highlightedOnly && SelectedSet != null ? new[] { SelectedSet } : SelectedSets())
+                .Where(s => !s.Archived).ToList();
+            if (chosen.Count == 0)
                 return;
 
-            DrawingSetRecord current;
+            var read = new List<DrawingSetRecord>();
+            var gone = new List<string>();
             busy = true;
             UpdateCommands();
-            statusLabel.Text = $"Reading set '{listed.Name}'...";
             try
             {
-                current = await sets.GetAsync(listed.Id);
+                foreach (var listed in chosen)
+                {
+                    statusLabel.Text = $"Reading set '{listed.Name}'...";
+                    var current = await sets.GetAsync(listed.Id);
+                    if (IsDisposed)
+                        return;
+                    if (current == null || current.Archived)
+                        gone.Add(listed.Name);
+                    else
+                        read.Add(current);
+                }
             }
             catch (Exception ex) when (ex is IOException || ex is HttpRequestException || ex is TaskCanceledException)
             {
-                Fail($"Could not read set '{listed.Name}': {ex.Message}");
+                Fail($"Could not read the set: {ex.Message}");
                 return;
             }
             finally
@@ -334,19 +359,15 @@ namespace OpenNest.Controls
                     UpdateCommands();
             }
 
-            if (IsDisposed)
-                return;
             statusLabel.Text = "";
-            if (current == null || current.Archived)
+            foreach (var set in read)
+                AddToRelease(set);
+            if (gone.Count > 0)
             {
-                ShowMessage(current == null
-                    ? $"Set '{listed.Name}' no longer exists on the server."
-                    : $"Set '{listed.Name}' was archived. Restore it to release it.", MessageBoxButtons.OK, MessageBoxIcon.Warning);
+                ShowMessage($"No longer releasable (deleted or archived since listed): {string.Join(", ", gone.Select(n => $"'{n}'"))}.",
+                    MessageBoxButtons.OK, MessageBoxIcon.Warning);
                 await RunAsync(session.RefreshAsync);
-                return;
             }
-
-            ShowRelease(current);
         }
 
         /// <summary>
@@ -554,6 +575,8 @@ namespace OpenNest.Controls
             var ready = session != null && !busy;
             newButton.Enabled = ready;
             editButton.Enabled = ready && selected is { Archived: false };
+            editMenuItem.Enabled = editButton.Enabled;
+            editMenuItem.Visible = editSeparator.Visible = !pick;
             previewButton.Enabled = previewMenuItem.Enabled = ready && !pick && selected is { MemberCount: > 0 };
             archiveMenuItem.Enabled = ready && selected != null;
             archiveMenuItem.Text = selected is { Archived: true } ? "&Restore" : "&Archive";
@@ -562,7 +585,9 @@ namespace OpenNest.Controls
             importBomMenuItem.Enabled = ready && !pick;
             moreButton.Enabled = previewMenuItem.Enabled || archiveMenuItem.Enabled || historyMenuItem.Enabled || releasesMenuItem.Enabled
                 || importBomMenuItem.Enabled;
-            releaseButton.Enabled = ready && nests != null && selected is { Archived: false, MemberCount: > 0 };
+            releaseButton.Enabled = ready && AddToRelease != null
+                && SelectedSets().Any(s => !s.Archived && s.MemberCount > 0);
+            addToReleaseMenuItem.Enabled = releaseButton.Enabled;
         }
     }
 }
diff --git a/OpenNest/Controls/GridStyle.cs b/OpenNest/Controls/GridStyle.cs
index 38f6c611..d13f1506 100644
--- a/OpenNest/Controls/GridStyle.cs
+++ b/OpenNest/Controls/GridStyle.cs
@@ -19,7 +19,8 @@ public static class GridStyle
     private static readonly Color SelectionBackColor = Color.FromArgb(204, 228, 247);
     private static readonly Color LineColor = Color.FromArgb(230, 230, 230);
 
-    public static T Apply<T>(T grid) where T : DataGridView
+    /// <param name="sizeColumns">False leaves column widths to the grid, as for columns that fill it.</param>
+    public static T Apply<T>(T grid, bool sizeColumns = true) where T : DataGridView
     {
         grid.AllowUserToResizeRows = false;
         grid.BackgroundColor = SystemColors.Window;
@@ -44,7 +45,8 @@ public static class GridStyle
         grid.RowHeadersDefaultCellStyle.SelectionBackColor = SelectionBackColor;
         grid.RowHeadersDefaultCellStyle.SelectionForeColor = Color.Black;
         grid.RowHeadersDefaultCellStyle.Alignment = DataGridViewContentAlignment.MiddleRight;
-        SizeColumnsOnceToContent(grid);
+        if (sizeColumns)
+            SizeColumnsOnceToContent(grid);
         return grid;
     }
 
diff --git a/OpenNest/Controls/ReleasePanel.Designer.cs b/OpenNest/Controls/ReleasePanel.Designer.cs
new file mode 100644
index 00000000..9d5cbcb1
--- /dev/null
+++ b/OpenNest/Controls/ReleasePanel.Designer.cs
@@ -0,0 +1,468 @@
+namespace OpenNest.Controls
+{
+    partial class ReleasePanel
+    {
+        private System.ComponentModel.IContainer components = null;
+
+        protected override void Dispose(bool disposing)
+        {
+            if (disposing)
+            {
+                cancellation?.Dispose();
+                if (components != null)
+                    components.Dispose();
+            }
+            base.Dispose(disposing);
+        }
+
+        #region Component Designer generated code
+
+        private void InitializeComponent()
+        {
+            components = new System.ComponentModel.Container();
+            System.Windows.Forms.DataGridViewCellStyle rightAligned = new System.Windows.Forms.DataGridViewCellStyle();
+            System.Windows.Forms.DataGridViewCellStyle wrapped = new System.Windows.Forms.DataGridViewCellStyle();
+            layoutTable = new System.Windows.Forms.TableLayoutPanel();
+            headingLabel = new System.Windows.Forms.Label();
+            hintLabel = new System.Windows.Forms.Label();
+            lineGrid = new System.Windows.Forms.DataGridView();
+            lineNameColumn = new System.Windows.Forms.DataGridViewTextBoxColumn();
+            lineQuantityColumn = new System.Windows.Forms.DataGridViewTextBoxColumn();
+            lineUnitColumn = new System.Windows.Forms.DataGridViewTextBoxColumn();
+            lineRemoveColumn = new System.Windows.Forms.DataGridViewButtonColumn();
+            detailsTable = new System.Windows.Forms.TableLayoutPanel();
+            customerLabel = new System.Windows.Forms.Label();
+            customerValue = new System.Windows.Forms.Label();
+            notesLabel = new System.Windows.Forms.Label();
+            notesBox = new System.Windows.Forms.TextBox();
+            nestsTable = new System.Windows.Forms.TableLayoutPanel();
+            nestsLabel = new System.Windows.Forms.Label();
+            includeArchivedCheckBox = new System.Windows.Forms.CheckBox();
+            groupGrid = new System.Windows.Forms.DataGridView();
+            includeColumn = new System.Windows.Forms.DataGridViewCheckBoxColumn();
+            groupColumn = new System.Windows.Forms.DataGridViewTextBoxColumn();
+            partsColumn = new System.Windows.Forms.DataGridViewTextBoxColumn();
+            targetColumn = new System.Windows.Forms.DataGridViewComboBoxColumn();
+            statusColumn = new System.Windows.Forms.DataGridViewTextBoxColumn();
+            previewLabel = new System.Windows.Forms.Label();
+            bottomTable = new System.Windows.Forms.TableLayoutPanel();
+            fixDrawingsButton = new System.Windows.Forms.Button();
+            nestAfterReleaseCheckBox = new System.Windows.Forms.CheckBox();
+            clearButton = new System.Windows.Forms.Button();
+            releaseButton = new System.Windows.Forms.Button();
+            statusLabel = new System.Windows.Forms.Label();
+            groupMenu = new System.Windows.Forms.ContextMenuStrip(components);
+            layoutTable.SuspendLayout();
+            ((System.ComponentModel.ISupportInitialize)lineGrid).BeginInit();
+            detailsTable.SuspendLayout();
+            nestsTable.SuspendLayout();
+            ((System.ComponentModel.ISupportInitialize)groupGrid).BeginInit();
+            bottomTable.SuspendLayout();
+            SuspendLayout();
+            //
+            // layoutTable
+            //
+            layoutTable.ColumnCount = 1;
+            layoutTable.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle(System.Windows.Forms.SizeType.Percent, 100F));
+            layoutTable.Controls.Add(headingLabel, 0, 0);
+            layoutTable.Controls.Add(hintLabel, 0, 1);
+            layoutTable.Controls.Add(lineGrid, 0, 2);
+            layoutTable.Controls.Add(detailsTable, 0, 3);
+            layoutTable.Controls.Add(nestsTable, 0, 4);
+            layoutTable.Controls.Add(groupGrid, 0, 5);
+            layoutTable.Controls.Add(previewLabel, 0, 6);
+            layoutTable.Controls.Add(bottomTable, 0, 7);
+            layoutTable.Controls.Add(statusLabel, 0, 8);
+            layoutTable.Dock = System.Windows.Forms.DockStyle.Fill;
+            layoutTable.Location = new System.Drawing.Point(0, 0);
+            layoutTable.Name = "layoutTable";
+            layoutTable.RowCount = 9;
+            layoutTable.RowStyles.Add(new System.Windows.Forms.RowStyle());
+            layoutTable.RowStyles.Add(new System.Windows.Forms.RowStyle());
+            layoutTable.RowStyles.Add(new System.Windows.Forms.RowStyle(System.Windows.Forms.SizeType.Percent, 40F));
+            layoutTable.RowStyles.Add(new System.Windows.Forms.RowStyle());
+            layoutTable.RowStyles.Add(new System.Windows.Forms.RowStyle());
+            layoutTable.RowStyles.Add(new System.Windows.Forms.RowStyle(System.Windows.Forms.SizeType.Percent, 60F));
+            layoutTable.RowStyles.Add(new System.Windows.Forms.RowStyle());
+            layoutTable.RowStyles.Add(new System.Windows.Forms.RowStyle());
+            layoutTable.RowStyles.Add(new System.Windows.Forms.RowStyle());
+            layoutTable.Size = new System.Drawing.Size(560, 600);
+            layoutTable.TabIndex = 0;
+            //
+            // headingLabel
+            //
+            headingLabel.AutoEllipsis = true;
+            headingLabel.Dock = System.Windows.Forms.DockStyle.Fill;
+            headingLabel.Font = new System.Drawing.Font("Segoe UI", 11.25F, System.Drawing.FontStyle.Bold);
+            headingLabel.Margin = new System.Windows.Forms.Padding(3, 0, 3, 3);
+            headingLabel.Name = "headingLabel";
+            headingLabel.Size = new System.Drawing.Size(100, 24);
+            headingLabel.TabIndex = 0;
+            headingLabel.Text = "Release";
+            //
+            // hintLabel
+            //
+            hintLabel.AutoSize = true;
+            hintLabel.ForeColor = System.Drawing.SystemColors.GrayText;
+            hintLabel.Margin = new System.Windows.Forms.Padding(3, 0, 3, 6);
+            hintLabel.Name = "hintLabel";
+            hintLabel.TabIndex = 1;
+            hintLabel.Text = "Double-click a set or a drawing to add it.";
+            //
+            // lineGrid
+            //
+            lineGrid.AllowUserToAddRows = false;
+            lineGrid.AllowUserToDeleteRows = false;
+            lineGrid.AutoSizeColumnsMode = System.Windows.Forms.DataGridViewAutoSizeColumnsMode.Fill;
+            lineGrid.Columns.AddRange(new System.Windows.Forms.DataGridViewColumn[] { lineNameColumn, lineQuantityColumn, lineUnitColumn, lineRemoveColumn });
+            lineGrid.Dock = System.Windows.Forms.DockStyle.Fill;
+            lineGrid.EditMode = System.Windows.Forms.DataGridViewEditMode.EditOnEnter;
+            lineGrid.Margin = new System.Windows.Forms.Padding(3, 0, 3, 6);
+            lineGrid.MultiSelect = false;
+            lineGrid.Name = "lineGrid";
+            lineGrid.RowHeadersVisible = false;
+            lineGrid.SelectionMode = System.Windows.Forms.DataGridViewSelectionMode.FullRowSelect;
+            lineGrid.StandardTab = true;
+            lineGrid.TabIndex = 2;
+            lineGrid.CellContentClick += LineGrid_CellContentClick;
+            lineGrid.CellValidating += LineGrid_CellValidating;
+            lineGrid.CellValueChanged += LineGrid_CellValueChanged;
+            lineGrid.KeyDown += LineGrid_KeyDown;
+            //
+            // lineNameColumn
+            //
+            lineNameColumn.AutoSizeMode = System.Windows.Forms.DataGridViewAutoSizeColumnMode.Fill;
+            lineNameColumn.HeaderText = "Set or drawing";
+            lineNameColumn.Name = "lineNameColumn";
+            lineNameColumn.ReadOnly = true;
+            lineNameColumn.SortMode = System.Windows.Forms.DataGridViewColumnSortMode.NotSortable;
+            //
+            // lineQuantityColumn
+            //
+            rightAligned.Alignment = System.Windows.Forms.DataGridViewContentAlignment.MiddleRight;
+            lineQuantityColumn.AutoSizeMode = System.Windows.Forms.DataGridViewAutoSizeColumnMode.None;
+            lineQuantityColumn.DefaultCellStyle = rightAligned;
+            lineQuantityColumn.HeaderText = "Qty";
+            lineQuantityColumn.Name = "lineQuantityColumn";
+            lineQuantityColumn.SortMode = System.Windows.Forms.DataGridViewColumnSortMode.NotSortable;
+            lineQuantityColumn.ToolTipText = "Kits of a set (every quantity in it is multiplied) or pieces of a drawing.";
+            lineQuantityColumn.Width = 55;
+            //
+            // lineUnitColumn
+            //
+            lineUnitColumn.AutoSizeMode = System.Windows.Forms.DataGridViewAutoSizeColumnMode.None;
+            lineUnitColumn.HeaderText = "";
+            lineUnitColumn.Name = "lineUnitColumn";
+            lineUnitColumn.ReadOnly = true;
+            lineUnitColumn.SortMode = System.Windows.Forms.DataGridViewColumnSortMode.NotSortable;
+            lineUnitColumn.Width = 42;
+            //
+            // lineRemoveColumn
+            //
+            lineRemoveColumn.AutoSizeMode = System.Windows.Forms.DataGridViewAutoSizeColumnMode.None;
+            lineRemoveColumn.FlatStyle = System.Windows.Forms.FlatStyle.Flat;
+            lineRemoveColumn.HeaderText = "";
+            lineRemoveColumn.Name = "lineRemoveColumn";
+            lineRemoveColumn.Text = "✕";
+            lineRemoveColumn.ToolTipText = "Remove from the release";
+            lineRemoveColumn.UseColumnTextForButtonValue = true;
+            lineRemoveColumn.Width = 30;
+            //
+            // detailsTable
+            //
+            detailsTable.AutoSize = true;
+            detailsTable.ColumnCount = 2;
+            detailsTable.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle());
+            detailsTable.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle(System.Windows.Forms.SizeType.Percent, 100F));
+            detailsTable.Controls.Add(customerLabel, 0, 0);
+            detailsTable.Controls.Add(customerValue, 1, 0);
+            detailsTable.Controls.Add(notesLabel, 0, 1);
+            detailsTable.Controls.Add(notesBox, 1, 1);
+            detailsTable.Dock = System.Windows.Forms.DockStyle.Fill;
+            detailsTable.Margin = new System.Windows.Forms.Padding(0, 0, 0, 6);
+            detailsTable.Name = "detailsTable";
+            detailsTable.RowCount = 2;
+            detailsTable.RowStyles.Add(new System.Windows.Forms.RowStyle());
+            detailsTable.RowStyles.Add(new System.Windows.Forms.RowStyle());
+            detailsTable.TabIndex = 3;
+            //
+            // customerLabel
+            //
+            customerLabel.Anchor = System.Windows.Forms.AnchorStyles.Left;
+            customerLabel.AutoSize = true;
+            customerLabel.Name = "customerLabel";
+            customerLabel.TabIndex = 0;
+            customerLabel.Text = "Customer:";
+            //
+            // customerValue
+            //
+            customerValue.AutoEllipsis = true;
+            customerValue.Dock = System.Windows.Forms.DockStyle.Fill;
+            customerValue.Name = "customerValue";
+            customerValue.Size = new System.Drawing.Size(100, 22);
+            customerValue.TabIndex = 1;
+            customerValue.TextAlign = System.Drawing.ContentAlignment.MiddleLeft;
+            //
+            // notesLabel
+            //
+            notesLabel.Anchor = System.Windows.Forms.AnchorStyles.Left;
+            notesLabel.AutoSize = true;
+            notesLabel.Name = "notesLabel";
+            notesLabel.TabIndex = 2;
+            notesLabel.Text = "Notes:";
+            //
+            // notesBox
+            //
+            notesBox.Dock = System.Windows.Forms.DockStyle.Fill;
+            notesBox.MaxLength = 4000;
+            notesBox.Name = "notesBox";
+            notesBox.TabIndex = 3;
+            //
+            // nestsTable
+            //
+            nestsTable.AutoSize = true;
+            nestsTable.ColumnCount = 2;
+            nestsTable.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle(System.Windows.Forms.SizeType.Percent, 100F));
+            nestsTable.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle());
+            nestsTable.Controls.Add(nestsLabel, 0, 0);
+            nestsTable.Controls.Add(includeArchivedCheckBox, 1, 0);
+            nestsTable.Dock = System.Windows.Forms.DockStyle.Fill;
+            nestsTable.Margin = new System.Windows.Forms.Padding(0);
+            nestsTable.Name = "nestsTable";
+            nestsTable.RowCount = 1;
+            nestsTable.RowStyles.Add(new System.Windows.Forms.RowStyle());
+            nestsTable.TabIndex = 4;
+            //
+            // nestsLabel
+            //
+            nestsLabel.Anchor = System.Windows.Forms.AnchorStyles.Left;
+            nestsLabel.AutoSize = true;
+            nestsLabel.Font = new System.Drawing.Font("Segoe UI", 9.75F, System.Drawing.FontStyle.Bold);
+            nestsLabel.Name = "nestsLabel";
+            nestsLabel.TabIndex = 0;
+            nestsLabel.Text = "Nests it will make";
+            //
+            // includeArchivedCheckBox
+            //
+            includeArchivedCheckBox.Anchor = System.Windows.Forms.AnchorStyles.Right;
+            includeArchivedCheckBox.AutoSize = true;
+            includeArchivedCheckBox.Name = "includeArchivedCheckBox";
+            includeArchivedCheckBox.TabIndex = 1;
+            includeArchivedCheckBox.Text = "Include archived drawings";
+            includeArchivedCheckBox.UseVisualStyleBackColor = true;
+            includeArchivedCheckBox.Visible = false;
+            includeArchivedCheckBox.CheckedChanged += IncludeArchivedCheckBox_CheckedChanged;
+            //
+            // groupGrid
+            //
+            groupGrid.AllowUserToAddRows = false;
+            groupGrid.AllowUserToDeleteRows = false;
+            groupGrid.AutoSizeColumnsMode = System.Windows.Forms.DataGridViewAutoSizeColumnsMode.Fill;
+            groupGrid.AutoSizeRowsMode = System.Windows.Forms.DataGridViewAutoSizeRowsMode.AllCells;
+            groupGrid.ContextMenuStrip = groupMenu;
+            groupGrid.Columns.AddRange(new System.Windows.Forms.DataGridViewColumn[] { includeColumn, groupColumn, partsColumn, targetColumn, statusColumn });
+            groupGrid.Dock = System.Windows.Forms.DockStyle.Fill;
+            groupGrid.EditMode = System.Windows.Forms.DataGridViewEditMode.EditOnEnter;
+            groupGrid.Margin = new System.Windows.Forms.Padding(3, 3, 3, 3);
+            groupGrid.MultiSelect = false;
+            groupGrid.Name = "groupGrid";
+            groupGrid.RowHeadersVisible = false;
+            groupGrid.SelectionMode = System.Windows.Forms.DataGridViewSelectionMode.FullRowSelect;
+            groupGrid.StandardTab = true;
+            groupGrid.TabIndex = 5;
+            groupGrid.CellValueChanged += GroupGrid_CellValueChanged;
+            groupGrid.CurrentCellDirtyStateChanged += GroupGrid_CurrentCellDirtyStateChanged;
+            groupGrid.DataError += GroupGrid_DataError;
+            groupGrid.CellDoubleClick += GroupGrid_CellDoubleClick;
+            groupGrid.CellMouseDown += GroupGrid_CellMouseDown;
+            groupGrid.CurrentCellChanged += GroupGrid_CurrentCellChanged;
+            //
+            // includeColumn
+            //
+            includeColumn.AutoSizeMode = System.Windows.Forms.DataGridViewAutoSizeColumnMode.None;
+            includeColumn.HeaderText = "";
+            includeColumn.Name = "includeColumn";
+            includeColumn.ToolTipText = "Untick to leave this material out of the release.";
+            includeColumn.Width = 28;
+            //
+            // groupColumn
+            //
+            wrapped.WrapMode = System.Windows.Forms.DataGridViewTriState.True;
+            groupColumn.DefaultCellStyle = wrapped;
+            groupColumn.FillWeight = 40F;
+            groupColumn.HeaderText = "Material";
+            groupColumn.Name = "groupColumn";
+            groupColumn.ReadOnly = true;
+            groupColumn.SortMode = System.Windows.Forms.DataGridViewColumnSortMode.NotSortable;
+            //
+            // partsColumn
+            //
+            partsColumn.AutoSizeMode = System.Windows.Forms.DataGridViewAutoSizeColumnMode.None;
+            partsColumn.DefaultCellStyle = rightAligned;
+            partsColumn.HeaderText = "Parts";
+            partsColumn.Name = "partsColumn";
+            partsColumn.ReadOnly = true;
+            partsColumn.SortMode = System.Windows.Forms.DataGridViewColumnSortMode.NotSortable;
+            partsColumn.Width = 50;
+            //
+            // targetColumn
+            //
+            targetColumn.AutoSizeMode = System.Windows.Forms.DataGridViewAutoSizeColumnMode.None;
+            targetColumn.DisplayStyle = System.Windows.Forms.DataGridViewComboBoxDisplayStyle.DropDownButton;
+            targetColumn.FlatStyle = System.Windows.Forms.FlatStyle.Flat;
+            targetColumn.HeaderText = "Nest";
+            targetColumn.Name = "targetColumn";
+            targetColumn.SortMode = System.Windows.Forms.DataGridViewColumnSortMode.NotSortable;
+            targetColumn.ToolTipText = "Merge into a Draft nest of the same material (it is renested), or make a new one.";
+            targetColumn.Width = 150;
+            //
+            // statusColumn
+            //
+            statusColumn.DefaultCellStyle = wrapped;
+            statusColumn.FillWeight = 60F;
+            statusColumn.HeaderText = "What happens";
+            statusColumn.Name = "statusColumn";
+            statusColumn.ReadOnly = true;
+            statusColumn.SortMode = System.Windows.Forms.DataGridViewColumnSortMode.NotSortable;
+            //
+            // previewLabel
+            //
+            previewLabel.AutoSize = true;
+            previewLabel.Margin = new System.Windows.Forms.Padding(3, 3, 3, 3);
+            previewLabel.Name = "previewLabel";
+            previewLabel.TabIndex = 6;
+            //
+            // bottomTable
+            //
+            bottomTable.AutoSize = true;
+            bottomTable.ColumnCount = 5;
+            bottomTable.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle());
+            bottomTable.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle(System.Windows.Forms.SizeType.Percent, 100F));
+            bottomTable.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle());
+            bottomTable.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle());
+            bottomTable.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle());
+            bottomTable.Controls.Add(fixDrawingsButton, 0, 0);
+            bottomTable.Controls.Add(nestAfterReleaseCheckBox, 2, 0);
+            bottomTable.Controls.Add(clearButton, 3, 0);
+            bottomTable.Controls.Add(releaseButton, 4, 0);
+            bottomTable.Dock = System.Windows.Forms.DockStyle.Fill;
+            bottomTable.Margin = new System.Windows.Forms.Padding(0, 3, 0, 0);
+            bottomTable.Name = "bottomTable";
+            bottomTable.RowCount = 1;
+            bottomTable.RowStyles.Add(new System.Windows.Forms.RowStyle());
+            bottomTable.TabIndex = 7;
+            //
+            // fixDrawingsButton
+            //
+            fixDrawingsButton.AutoSize = true;
+            fixDrawingsButton.Enabled = false;
+            fixDrawingsButton.Name = "fixDrawingsButton";
+            fixDrawingsButton.TabIndex = 0;
+            fixDrawingsButton.Text = "Fix Drawings...";
+            fixDrawingsButton.UseVisualStyleBackColor = true;
+            fixDrawingsButton.Visible = false;
+            fixDrawingsButton.Click += FixDrawingsButton_Click;
+            //
+            // nestAfterReleaseCheckBox
+            //
+            nestAfterReleaseCheckBox.Anchor = System.Windows.Forms.AnchorStyles.Right;
+            nestAfterReleaseCheckBox.AutoSize = true;
+            nestAfterReleaseCheckBox.Checked = true;
+            nestAfterReleaseCheckBox.CheckState = System.Windows.Forms.CheckState.Checked;
+            nestAfterReleaseCheckBox.Margin = new System.Windows.Forms.Padding(3, 3, 9, 3);
+            nestAfterReleaseCheckBox.Name = "nestAfterReleaseCheckBox";
+            nestAfterReleaseCheckBox.TabIndex = 1;
+            nestAfterReleaseCheckBox.Text = "Nest after release";
+            nestAfterReleaseCheckBox.UseVisualStyleBackColor = true;
+            nestAfterReleaseCheckBox.CheckedChanged += NestAfterReleaseCheckBox_CheckedChanged;
+            //
+            // clearButton
+            //
+            clearButton.AutoSize = true;
+            clearButton.Enabled = false;
+            clearButton.Name = "clearButton";
+            clearButton.TabIndex = 2;
+            clearButton.Text = "Clear";
+            clearButton.UseVisualStyleBackColor = true;
+            clearButton.Click += ClearButton_Click;
+            //
+            // releaseButton
+            //
+            releaseButton.AutoSize = true;
+            releaseButton.Enabled = false;
+            releaseButton.Font = new System.Drawing.Font("Segoe UI", 9.75F, System.Drawing.FontStyle.Bold);
+            releaseButton.MinimumSize = new System.Drawing.Size(0, 32);
+            releaseButton.Name = "releaseButton";
+            releaseButton.TabIndex = 3;
+            releaseButton.Text = "Make Nests";
+            releaseButton.UseVisualStyleBackColor = true;
+            releaseButton.Click += ReleaseButton_Click;
+            //
+            // statusLabel
+            //
+            statusLabel.AutoSize = true;
+            statusLabel.Margin = new System.Windows.Forms.Padding(3, 6, 3, 0);
+            statusLabel.Name = "statusLabel";
+            statusLabel.TabIndex = 8;
+            //
+            // groupMenu
+            //
+            groupMenu.Name = "groupMenu";
+            groupMenu.Opening += GroupMenu_Opening;
+            //
+            // ReleasePanel
+            //
+            AutoScaleMode = System.Windows.Forms.AutoScaleMode.None;
+            Controls.Add(layoutTable);
+            Font = new System.Drawing.Font("Segoe UI", 9.75F);
+            MinimumSize = new System.Drawing.Size(420, 360);
+            Name = "ReleasePanel";
+            Size = new System.Drawing.Size(560, 600);
+            Resize += ReleasePanel_Resize;
+            layoutTable.ResumeLayout(false);
+            layoutTable.PerformLayout();
+            ((System.ComponentModel.ISupportInitialize)lineGrid).EndInit();
+            detailsTable.ResumeLayout(false);
+            detailsTable.PerformLayout();
+            nestsTable.ResumeLayout(false);
+            nestsTable.PerformLayout();
+            ((System.ComponentModel.ISupportInitialize)groupGrid).EndInit();
+            bottomTable.ResumeLayout(false);
+            bottomTable.PerformLayout();
+            ResumeLayout(false);
+        }
+
+        #endregion
+
+        private System.Windows.Forms.TableLayoutPanel layoutTable;
+        private System.Windows.Forms.Label headingLabel;
+        private System.Windows.Forms.Label hintLabel;
+        private System.Windows.Forms.DataGridView lineGrid;
+        private System.Windows.Forms.DataGridViewTextBoxColumn lineNameColumn;
+        private System.Windows.Forms.DataGridViewTextBoxColumn lineQuantityColumn;
+        private System.Windows.Forms.DataGridViewTextBoxColumn lineUnitColumn;
+        private System.Windows.Forms.DataGridViewButtonColumn lineRemoveColumn;
+        private System.Windows.Forms.TableLayoutPanel detailsTable;
+        private System.Windows.Forms.Label customerLabel;
+        private System.Windows.Forms.Label customerValue;
+        private System.Windows.Forms.Label notesLabel;
+        private System.Windows.Forms.TextBox notesBox;
+        private System.Windows.Forms.TableLayoutPanel nestsTable;
+        private System.Windows.Forms.Label nestsLabel;
+        private System.Windows.Forms.CheckBox includeArchivedCheckBox;
+        private System.Windows.Forms.DataGridView groupGrid;
+        private System.Windows.Forms.DataGridViewCheckBoxColumn includeColumn;
+        private System.Windows.Forms.DataGridViewTextBoxColumn groupColumn;
+        private System.Windows.Forms.DataGridViewTextBoxColumn partsColumn;
+        private System.Windows.Forms.DataGridViewComboBoxColumn targetColumn;
+        private System.Windows.Forms.DataGridViewTextBoxColumn statusColumn;
+        private System.Windows.Forms.Label previewLabel;
+        private System.Windows.Forms.TableLayoutPanel bottomTable;
+        private System.Windows.Forms.Button fixDrawingsButton;
+        private System.Windows.Forms.CheckBox nestAfterReleaseCheckBox;
+        private System.Windows.Forms.Button clearButton;
+        private System.Windows.Forms.Button releaseButton;
+        private System.Windows.Forms.Label statusLabel;
+        private System.Windows.Forms.ContextMenuStrip groupMenu;
+    }
+}
diff --git a/OpenNest/Controls/ReleasePanel.cs b/OpenNest/Controls/ReleasePanel.cs
new file mode 100644
index 00000000..3b0e42de
--- /dev/null
+++ b/OpenNest/Controls/ReleasePanel.cs
@@ -0,0 +1,1128 @@
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Windows.Forms;
+using OpenNest.Data;
+using OpenNest.Engine.BestFit;
+using OpenNest.Engine.Jobs;
+using OpenNest.Forms;
+using OpenNest.IO;
+
+namespace OpenNest.Controls
+{
+    /// <summary>
+    /// The release being built, beside the Library and Sets lists of
+    /// <see cref="DrawingSetsForm"/>: a double-click there adds a set at one kit or a library
+    /// drawing on its own at the entered quantity, and adding one already listed adds to its
+    /// quantity. The lines are edited in place (quantity, ✕ to remove) with the release's
+    /// customer and notes, and "Nests it will make" previews live how they split into one nest
+    /// per material group (<see cref="SetReleasePlan"/>), with a tick per group and its target.
+    /// A group merges into a Draft nest of the same material by default: the only one, or the
+    /// most recently saved of several (the row names it and offers the others or a new nest);
+    /// with none it makes a new Draft nest. A draft open in a tab of this desktop is never
+    /// merged into: its row says so and Make Nests waits until it is closed or another target
+    /// is chosen. A group refused for its drawings (no material or thickness, or two with one
+    /// name) shows why at once; Fix Drawings, a double-click or the group's right-click menu
+    /// opens Edit Drawing and the plan is rebuilt with what was saved. Make Nests is the only
+    /// step that writes: <see cref="SetReleaseSession"/> builds the nests, nests each with Auto
+    /// Nest when Nest after release is ticked (remembered per user), saves them, opens each in
+    /// its own tab and records the release; each group's outcome is then shown.
+    /// </summary>
+    public partial class ReleasePanel : UserControl
+    {
+        internal const string NewNestChoice = "New Draft nest";
+
+        private IDrawingSetStore sets;
+        private IDrawingLibrary library;
+        // Edit Drawing needs a writable library; null hides Fix Drawings.
+        private IDrawingLibraryStore libraryStore;
+        private INestRepository nests;
+        private string serverUrl = "";
+        private Action<Nest, NestRecord> openNest = (_, _) => { };
+        private readonly HashSet<string> excluded = new(StringComparer.Ordinal);
+        // The draft the operator picked for a group, by group key; without one the group takes the default.
+        private readonly Dictionary<string, NestRecord> targets = new(StringComparer.Ordinal);
+        // Groups the operator chose to make a new nest for although a draft matches.
+        private readonly HashSet<string> newNests = new(StringComparer.Ordinal);
+        // The drafts each group could merge into, by group key; absent while still loading.
+        private readonly Dictionary<string, IReadOnlyList<NestRecord>> drafts = new(StringComparer.Ordinal);
+        // Group keys whose draft lookup failed, with the reason.
+        private readonly Dictionary<string, string> lookupErrors = new(StringComparer.Ordinal);
+        private SetReleasePlan plan;
+        private SetReleaseSession session;
+        private CancellationTokenSource cancellation;
+        private bool populating;
+        private bool running;
+        private bool loadingDrafts;
+        private bool editing;
+
+        /// <summary>Shows a message and returns the operator's answer; replaced by tests.</summary>
+        internal Func<string, MessageBoxButtons, MessageBoxIcon, DialogResult> ShowMessage { get; set; }
+
+        /// <summary>Makes the empty nest for a group, as File &gt; New would in its units; replaced by tests.</summary>
+        internal Func<SetReleaseGroup, CancellationToken, Task<Nest>> CreateNest { get; set; }
+
+        /// <summary>
+        /// Nests a group's built nest when Nest after release is ticked: Auto Nest headless with
+        /// the selected engine (<see cref="NestRenest"/>); replaced by tests.
+        /// </summary>
+        internal Func<Nest, CancellationToken, Task<SetReleaseRenest>> Renest { get; set; } = RenestAsync;
+
+        /// <summary>Shows Edit Drawing and returns the saved record, or null; replaced by tests.</summary>
+        internal Func<DrawingLibraryEditSession, DrawingLibraryRecord> EditDrawing { get; set; }
+
+        /// <summary>
+        /// True when a server nest is open in a tab of this desktop. Such a draft is not merged
+        /// into: the tab could hold edits the merge would leave behind.
+        /// </summary>
+        public Func<Guid, bool> IsNestOpen { get; set; } = _ => false;
+
+        /// <summary>Raised once Make Nests has opened the nests it made, so the host can show them.</summary>
+        public event EventHandler NestsOpened;
+
+        /// <summary>The finished release, once Make Nests has run; otherwise null.</summary>
+        public SetReleaseResult Result { get; private set; }
+
+        /// <summary>True while Make Nests is making nests or recording the release.</summary>
+        public bool IsRunning => running;
+
+        public ReleasePanel()
+        {
+            InitializeComponent();
+            GridStyle.Apply(lineGrid, sizeColumns: false);
+            GridStyle.Apply(groupGrid, sizeColumns: false);
+            // A refusal or outcome wraps rather than being cut off.
+            groupGrid.RowTemplate.MinimumHeight = groupGrid.RowTemplate.Height;
+            groupGrid.AutoSizeRowsMode = DataGridViewAutoSizeRowsMode.AllCells;
+            // Only the operator's own click is remembered, so a test or a host setting it is not.
+            nestAfterReleaseCheckBox.Checked = Properties.Settings.Default.ReleaseNestAfter;
+            nestAfterReleaseCheckBox.Click += NestAfterReleaseCheckBox_Click;
+            ShowMessage = (text, buttons, icon) => MessageBox.Show(FindForm(), text, "Release", buttons, icon);
+            CreateNest = (group, _) => NewNestFactory.CreateAsync(FindForm(), group.Units);
+            EditDrawing = edit =>
+            {
+                using var form = new EditLibraryDrawingForm(edit);
+                return form.ShowDialog(FindForm()) == DialogResult.OK ? form.Saved : null;
+            };
+            BuildPlan();
+        }
+
+        /// <param name="openNest">Opens a created or merged nest in its own tab, bound to its server record.</param>
+        public void Initialize(IDrawingSetStore sets, IDrawingLibrary library, INestRepository nests, string serverUrl,
+            Action<Nest, NestRecord> openNest)
+        {
+            this.sets = sets ?? throw new ArgumentNullException(nameof(sets));
+            this.library = library ?? throw new ArgumentNullException(nameof(library));
+            libraryStore = library as IDrawingLibraryStore;
+            this.nests = nests ?? throw new ArgumentNullException(nameof(nests));
+            this.serverUrl = serverUrl ?? "";
+            this.openNest = openNest ?? throw new ArgumentNullException(nameof(openNest));
+            UpdateCommands();
+        }
+
+        /// <summary>True once <see cref="Initialize"/> has run.</summary>
+        public bool IsInitialized => nests != null;
+
+        /// <summary>The sets listed, in order, with their kits.</summary>
+        internal IReadOnlyList<SetReleasePlanLine> Lines() =>
+            lineGrid.Rows.Cast<DataGridViewRow>()
+                .Where(r => r.Tag is DrawingSetRecord)
+                .Select(r => new SetReleasePlanLine((DrawingSetRecord)r.Tag, Quantity(r)))
+                .ToList();
+
+        /// <summary>The drawings listed on their own, in order, with their quantities.</summary>
+        internal IReadOnlyList<SetReleaseDrawingLine> DrawingLines() =>
+            lineGrid.Rows.Cast<DataGridViewRow>()
+                .Where(r => r.Tag is DrawingLibraryRecord)
+                .Select(r => new SetReleaseDrawingLine((DrawingLibraryRecord)r.Tag, Quantity(r)))
+                .ToList();
+
+        /// <summary>True when nothing is listed.</summary>
+        public bool IsEmpty => lineGrid.Rows.Count == 0;
+
+        /// <summary>
+        /// Adds a set read from the server (members joined) at <paramref name="kits"/>, or that
+        /// many more kits when it is already listed. False, with the reason shown, when it is
+        /// archived or nothing can be added now. A finished release is cleared first, so the
+        /// set starts the next one.
+        /// </summary>
+        public bool AddSet(DrawingSetRecord set, int kits = 1)
+        {
+            ArgumentNullException.ThrowIfNull(set);
+            if (!PrepareToAdd())
+                return false;
+            if (set.Archived)
+            {
+                statusLabel.Text = $"'{set.Name}' is archived. Restore it before releasing it.";
+                return false;
+            }
+
+            var listed = lineGrid.Rows.Cast<DataGridViewRow>().FirstOrDefault(r => r.Tag is DrawingSetRecord s && s.Id == set.Id);
+            if (listed != null)
+            {
+                var now = System.Math.Min(Quantity(listed) + kits, SetReleaseRules.MaxQuantity);
+                SetQuantity(listed, now);
+                listed.Selected = true;
+                statusLabel.Text = $"'{set.Name}' is now ×{now} {Unit(set, now)}.";
+            }
+            else
+            {
+                AddRow(set, set.Name, System.Math.Clamp(kits, 1, SetReleaseRules.MaxQuantity));
+                statusLabel.Text = $"Added set '{set.Name}'.";
+            }
+            BuildPlan();
+            return true;
+        }
+
+        /// <summary>
+        /// Adds library drawings on their own at <paramref name="quantity"/> each, adding that
+        /// many more to those already listed and skipping (and naming) archived ones, and
+        /// returns what happened for the operator.
+        /// </summary>
+        public string AddDrawings(IReadOnlyList<DrawingLibraryRecord> drawings, int quantity)
+        {
+            ArgumentNullException.ThrowIfNull(drawings);
+            if (!PrepareToAdd())
+                return statusLabel.Text;
+            var added = new List<DrawingLibraryRecord>();
+            var more = new List<DrawingLibraryRecord>();
+            var archived = new List<DrawingLibraryRecord>();
+            var full = false;
+            foreach (var drawing in drawings)
+            {
+                if (drawing.Archived)
+                {
+                    archived.Add(drawing);
+                    continue;
+                }
+                var listed = lineGrid.Rows.Cast<DataGridViewRow>()
+                    .FirstOrDefault(r => r.Tag is DrawingLibraryRecord d && d.Id == drawing.Id);
+                if (listed != null)
+                {
+                    SetQuantity(listed, System.Math.Min(Quantity(listed) + quantity, SetReleaseRules.MaxDrawingQuantity));
+                    more.Add(drawing);
+                }
+                else if (DrawingLines().Count >= SetReleaseRules.MaxDrawingLines)
+                {
+                    full = true;
+                }
+                else
+                {
+                    AddRow(drawing, drawing.Name, System.Math.Clamp(quantity, 1, SetReleaseRules.MaxDrawingQuantity));
+                    added.Add(drawing);
+                }
+            }
+            if (added.Count + more.Count > 0)
+                BuildPlan();
+
+            var text = (added.Count, more.Count) switch
+            {
+                (0, 0) => "Nothing added.",
+                (1, 0) => $"Added '{added[0].Name}' ×{quantity}.",
+                (_, 0) => $"Added {added.Count} drawings.",
+                (0, 1) => $"'{more[0].Name}' is now ×{DrawingLines().Single(l => l.Drawing.Id == more[0].Id).Quantity} pcs.",
+                _ => $"Added {added.Count} drawing{(added.Count == 1 ? "" : "s")} and {quantity} more of {more.Count} listed.",
+            };
+            if (archived.Count > 0)
+                text += $" Archived, restore before releasing: {Names(archived)}.";
+            if (full)
+                text += $" A release may list at most {SetReleaseRules.MaxDrawingLines} drawings on their own.";
+            statusLabel.Text = text;
+            return text;
+        }
+
+        private static string Names(IEnumerable<DrawingLibraryRecord> drawings) =>
+            string.Join(", ", drawings.Select(d => $"'{d.Name}'"));
+
+        // A finished release makes way for the next; one waiting to be recorded, or running, does not.
+        private bool PrepareToAdd()
+        {
+            if (running)
+            {
+                statusLabel.Text = "Wait for Make Nests to finish before adding more.";
+                return false;
+            }
+            if (Result == null)
+                return true;
+            if (session?.HasPendingRelease == true)
+            {
+                statusLabel.Text = "The nests are saved but the release is not recorded. Try Again records it; Clear leaves it unrecorded.";
+                return false;
+            }
+            Clear();
+            return true;
+        }
+
+        private void AddRow(object tag, string name, int quantity)
+        {
+            var row = new DataGridViewRow { Tag = tag };
+            row.CreateCells(lineGrid, name, quantity.ToString(CultureInfo.CurrentCulture), Unit(tag, quantity));
+            row.Cells[lineNameColumn.Index].ToolTipText = tag switch
+            {
+                DrawingSetRecord set => $"Set '{set.Name}', revision {set.Revision}"
+                    + (string.IsNullOrWhiteSpace(set.Customer) ? "" : $", {set.Customer}"),
+                DrawingLibraryRecord drawing => $"Drawing '{drawing.Name}' on its own, revision {drawing.Revision}"
+                    + (string.IsNullOrWhiteSpace(drawing.Customer) ? "" : $", {drawing.Customer}"),
+                _ => "",
+            };
+            lineGrid.Rows.Add(row);
+        }
+
+        private void SetQuantity(DataGridViewRow row, int quantity)
+        {
+            populating = true;
+            row.Cells[lineQuantityColumn.Index].Value = quantity.ToString(CultureInfo.CurrentCulture);
+            row.Cells[lineUnitColumn.Index].Value = Unit(row.Tag, quantity);
+            populating = false;
+        }
+
+        // "kits" for a set, "pcs" for a drawing on its own.
+        private static string Unit(object tag, int quantity) =>
+            tag is DrawingSetRecord ? (quantity == 1 ? "kit" : "kits") : (quantity == 1 ? "pc" : "pcs");
+
+        private static int Quantity(DataGridViewRow row) =>
+            int.TryParse(Convert.ToString(row.Cells["lineQuantityColumn"].Value, CultureInfo.CurrentCulture), NumberStyles.Integer,
+                CultureInfo.CurrentCulture, out var quantity) ? quantity : 1;
+
+        private void LineGrid_CellValidating(object sender, DataGridViewCellValidatingEventArgs e)
+        {
+            if (e.ColumnIndex != lineQuantityColumn.Index || e.RowIndex < 0)
+                return;
+            var drawing = lineGrid.Rows[e.RowIndex].Tag is DrawingLibraryRecord;
+            var maximum = drawing ? SetReleaseRules.MaxDrawingQuantity : SetReleaseRules.MaxQuantity;
+            var valid = int.TryParse(Convert.ToString(e.FormattedValue, CultureInfo.CurrentCulture), NumberStyles.Integer,
+                CultureInfo.CurrentCulture, out var quantity) && quantity >= 1 && quantity <= maximum;
+            lineGrid.Rows[e.RowIndex].ErrorText = valid ? "" : $"Enter a whole number from 1 to {maximum:N0}.";
+            e.Cancel = !valid;
+        }
+
+        private void LineGrid_CellValueChanged(object sender, DataGridViewCellEventArgs e)
+        {
+            if (populating || e.RowIndex < 0 || e.ColumnIndex != lineQuantityColumn.Index || running || Result != null)
+                return;
+            var row = lineGrid.Rows[e.RowIndex];
+            populating = true;
+            row.Cells[lineUnitColumn.Index].Value = Unit(row.Tag, Quantity(row));
+            populating = false;
+            BuildPlan();
+        }
+
+        private void LineGrid_CellContentClick(object sender, DataGridViewCellEventArgs e)
+        {
+            if (e.RowIndex >= 0 && e.ColumnIndex == lineRemoveColumn.Index)
+                RemoveLine(lineGrid.Rows[e.RowIndex]);
+        }
+
+        private void LineGrid_KeyDown(object sender, KeyEventArgs e)
+        {
+            if (e.KeyCode == Keys.Delete && !lineGrid.IsCurrentCellInEditMode && lineGrid.CurrentRow != null)
+            {
+                RemoveLine(lineGrid.CurrentRow);
+                e.Handled = true;
+            }
+        }
+
+        /// <summary>Takes a line out of the release in progress.</summary>
+        internal void RemoveLine(DataGridViewRow row)
+        {
+            if (running || Result != null || row == null)
+                return;
+            lineGrid.CancelEdit();
+            lineGrid.Rows.Remove(row);
+            statusLabel.Text = "";
+            BuildPlan();
+        }
+
+        private void ClearButton_Click(object sender, EventArgs e)
+        {
+            if (running)
+            {
+                cancellation?.Cancel();
+                statusLabel.Text = "Stopping after the nest being saved...";
+                clearButton.Enabled = false;
+                return;
+            }
+            if (ConfirmDiscard())
+                Clear();
+        }
+
+        /// <summary>
+        /// True when nothing would be lost by dropping this release, or the operator agreed to
+        /// leave saved nests whose release is not recorded.
+        /// </summary>
+        public bool ConfirmDiscard() =>
+            !running && (session?.HasPendingRelease != true
+                || ShowMessage("The nests are saved but the release is not recorded, so it can't be undone as one. Leave it unrecorded?",
+                    MessageBoxButtons.OKCancel, MessageBoxIcon.Warning) == DialogResult.OK);
+
+        /// <summary>Empties the panel for a new release.</summary>
+        public void Clear()
+        {
+            if (running)
+                return;
+            lineGrid.Rows.Clear();
+            notesBox.Text = "";
+            includeArchivedCheckBox.Checked = false;
+            excluded.Clear();
+            targets.Clear();
+            newNests.Clear();
+            // A release may have made new drafts, so the next one looks again.
+            drafts.Clear();
+            lookupErrors.Clear();
+            Result = null;
+            session = null;
+            statusLabel.Text = "";
+            BuildPlan();
+        }
+
+        /// <summary>The release in progress, to keep while the window is closed; null when there is none.</summary>
+        public ReleaseDraft TakeDraft() =>
+            running || Result != null || IsEmpty ? null
+                : new ReleaseDraft(Lines(), DrawingLines(), notesBox.Text, includeArchivedCheckBox.Checked);
+
+        /// <summary>Lists a release kept by <see cref="TakeDraft"/> again; its drafts to merge into are looked up afresh.</summary>
+        public void Restore(ReleaseDraft draft)
+        {
+            if (draft == null || running)
+                return;
+            Clear();
+            foreach (var line in draft.Sets)
+                AddRow(line.Set, line.Set.Name, line.Quantity);
+            foreach (var line in draft.Drawings)
+                AddRow(line.Drawing, line.Drawing.Name, line.Quantity);
+            notesBox.Text = draft.Notes ?? "";
+            includeArchivedCheckBox.Checked = draft.IncludeArchived;
+            BuildPlan();
+        }
+
+        /// <summary>
+        /// Re-reads which nests are open in tabs, as the operator may have closed a draft there
+        /// since; called when the window is activated.
+        /// </summary>
+        public void RefreshOpenNests()
+        {
+            if (running || Result != null || plan == null)
+                return;
+            UpdateNotes();
+            UpdateCommands();
+        }
+
+        private void IncludeArchivedCheckBox_CheckedChanged(object sender, EventArgs e)
+        {
+            if (!running && Result == null && !populating)
+                BuildPlan();
+        }
+
+        // The notes say what a merge does to the draft's layout, which this choice changes.
+        private void NestAfterReleaseCheckBox_CheckedChanged(object sender, EventArgs e)
+        {
+            if (running || Result != null)
+                return;
+            UpdateNotes();
+        }
+
+        private void NestAfterReleaseCheckBox_Click(object sender, EventArgs e)
+        {
+            Properties.Settings.Default.ReleaseNestAfter = nestAfterReleaseCheckBox.Checked;
+            Properties.Settings.Default.Save();
+        }
+
+        private void ReleasePanel_Resize(object sender, EventArgs e)
+        {
+            // Long notes wrap to the panel's width rather than widening it.
+            var width = System.Math.Max(100, layoutTable.ClientSize.Width - 8);
+            foreach (var label in new[] { hintLabel, previewLabel, statusLabel })
+                label.MaximumSize = new System.Drawing.Size(width, 0);
+        }
+
+        // Commit a checkbox click or a target choice at once so the summary follows it.
+        private void GroupGrid_CurrentCellDirtyStateChanged(object sender, EventArgs e)
+        {
+            if (groupGrid.IsCurrentCellDirty
+                && (groupGrid.CurrentCell?.OwningColumn == includeColumn || groupGrid.CurrentCell?.OwningColumn == targetColumn))
+                groupGrid.CommitEdit(DataGridViewDataErrorContexts.Commit);
+        }
+
+        private void GroupGrid_CellValueChanged(object sender, DataGridViewCellEventArgs e)
+        {
+            if (populating || e.RowIndex < 0)
+                return;
+            var row = groupGrid.Rows[e.RowIndex];
+            if (row.Tag is not SetReleaseGroup group)
+                return;
+            if (e.ColumnIndex == includeColumn.Index)
+            {
+                if (row.Cells[includeColumn.Index].Value is true)
+                    excluded.Remove(group.Key);
+                else
+                    excluded.Add(group.Key);
+                UpdateNotes();
+            }
+            else if (e.ColumnIndex == targetColumn.Index)
+            {
+                ChooseTarget(row, group, row.Cells[targetColumn.Index].Value as string);
+            }
+            UpdateCommands();
+        }
+
+        // A combo value that is not in a rebuilt list is reset rather than reported.
+        private void GroupGrid_DataError(object sender, DataGridViewDataErrorEventArgs e) => e.ThrowException = false;
+
+        /// <summary>Makes <paramref name="group"/> merge into the draft named by <paramref name="choice"/>, or a new nest.</summary>
+        internal void ChooseTarget(DataGridViewRow row, SetReleaseGroup group, string choice)
+        {
+            var draft = drafts.TryGetValue(group.Key, out var candidates)
+                ? candidates.FirstOrDefault(d => DraftChoice(d, candidates) == choice)
+                : null;
+            if (draft == null)
+            {
+                targets.Remove(group.Key);
+                newNests.Add(group.Key);
+            }
+            else
+            {
+                targets[group.Key] = draft;
+                newNests.Remove(group.Key);
+            }
+            populating = true;
+            row.Cells[targetColumn.Index].Value = TargetChoice(group);
+            row.Cells[statusColumn.Index].Value = GroupNote(group);
+            populating = false;
+            UpdateCommands();
+        }
+
+        /// <summary>
+        /// The draft <paramref name="group"/> merges into: the one the operator picked, else the
+        /// most recently saved Draft nest of its material; null for a new nest or while its
+        /// drafts are still being looked up.
+        /// </summary>
+        internal NestRecord TargetOf(SetReleaseGroup group)
+        {
+            if (!group.CanRelease || newNests.Contains(group.Key)
+                || !drafts.TryGetValue(group.Key, out var candidates) || candidates.Count == 0)
+                return null;
+            if (targets.TryGetValue(group.Key, out var picked) && candidates.Any(d => d.Id == picked.Id))
+                return picked;
+            return candidates.OrderByDescending(d => d.SavedAt).First();
+        }
+
+        private void GroupGrid_CurrentCellChanged(object sender, EventArgs e) => UpdateCommands();
+
+        // A right-click selects the row under the pointer, so the menu acts on what was clicked.
+        private void GroupGrid_CellMouseDown(object sender, DataGridViewCellMouseEventArgs e)
+        {
+            if (e.Button == MouseButtons.Right && e.RowIndex >= 0 && groupGrid.CurrentRow?.Index != e.RowIndex)
+                groupGrid.CurrentCell = groupGrid.Rows[e.RowIndex].Cells[groupColumn.Index];
+        }
+
+        private async void GroupGrid_CellDoubleClick(object sender, DataGridViewCellEventArgs e)
+        {
+            if (e.RowIndex >= 0 && groupGrid.Rows[e.RowIndex].Tag is SetReleaseGroup { CanRelease: false })
+                await FixSelectedGroupAsync();
+        }
+
+        private async void FixDrawingsButton_Click(object sender, EventArgs e) => await FixSelectedGroupAsync();
+
+        // One Edit Drawing item per drawing of the group, the ones it is refused for first.
+        private void GroupMenu_Opening(object sender, System.ComponentModel.CancelEventArgs e)
+        {
+            groupMenu.Items.Clear();
+            if (libraryStore == null || groupGrid.CurrentRow?.Tag is not SetReleaseGroup group)
+            {
+                e.Cancel = true;
+                return;
+            }
+
+            const int listed = 15;
+            var items = group.RefusedItems.Concat(group.Items.Where(i => !group.RefusedItems.Contains(i))).ToList();
+            var enabled = CanEditDrawings();
+            foreach (var item in items.Take(listed))
+            {
+                var menuItem = new ToolStripMenuItem($"Edit Drawing '{item.Drawing.Name}'...") { Enabled = enabled };
+                menuItem.Click += async (_, _) => await EditItemDrawingAsync(item);
+                groupMenu.Items.Add(menuItem);
+            }
+            if (items.Count > listed)
+            {
+                groupMenu.Items.Add(new ToolStripMenuItem(
+                    $"...and {items.Count - listed} more: edit them in the set or the Drawing Library")
+                { Enabled = false });
+            }
+        }
+
+        // The selected refused group, else the first one.
+        private DataGridViewRow RefusedRow() =>
+            groupGrid.CurrentRow?.Tag is SetReleaseGroup { CanRelease: false } ? groupGrid.CurrentRow
+                : groupGrid.Rows.Cast<DataGridViewRow>().FirstOrDefault(r => r.Tag is SetReleaseGroup { CanRelease: false });
+
+        private bool CanEditDrawings() => libraryStore != null && !running && !editing && Result == null;
+
+        /// <summary>
+        /// Opens Edit Drawing, one after another, on each drawing the selected group is refused
+        /// for, or the first refused group's when a releasable one is selected; cancelling one
+        /// stops. The plan is rebuilt after each save.
+        /// </summary>
+        internal async Task FixSelectedGroupAsync()
+        {
+            if (!CanEditDrawings() || RefusedRow() is not { Tag: SetReleaseGroup group } row)
+                return;
+            if (groupGrid.CurrentRow != row)
+                groupGrid.CurrentCell = row.Cells[groupColumn.Index];
+            foreach (var item in group.RefusedItems.ToList())
+            {
+                if (!await EditItemDrawingAsync(item) || IsDisposed)
+                    return;
+            }
+        }
+
+        /// <summary>
+        /// Reads the item's current library record and opens Edit Drawing on it; true when it
+        /// was saved. What was read or saved replaces the drawing in the plan.
+        /// </summary>
+        internal async Task<bool> EditItemDrawingAsync(SetReleaseItem item)
+        {
+            ArgumentNullException.ThrowIfNull(item);
+            if (!CanEditDrawings())
+                return false;
+
+            var name = item.Drawing.Name;
+            DrawingLibraryRecord current;
+            editing = true;
+            UpdateCommands();
+            statusLabel.Text = $"Reading '{name}'...";
+            try
+            {
+                current = await libraryStore.GetAsync(item.Drawing.Id);
+            }
+            catch (Exception ex) when (ex is IOException || ex is HttpRequestException || ex is TaskCanceledException)
+            {
+                if (!IsDisposed)
+                {
+                    statusLabel.Text = "";
+                    ShowMessage($"Could not read '{name}': {ex.Message}", MessageBoxButtons.OK, MessageBoxIcon.Warning);
+                }
+                return false;
+            }
+            finally
+            {
+                editing = false;
+                if (!IsDisposed)
+                    UpdateCommands();
+            }
+
+            if (IsDisposed)
+                return false;
+            statusLabel.Text = "";
+            if (current == null)
+            {
+                ShowMessage($"'{name}' is no longer in the library.", MessageBoxButtons.OK, MessageBoxIcon.Warning);
+                return false;
+            }
+            if (current.Archived)
+            {
+                ShowMessage($"'{current.Name}' is archived in the library. Restore it there before editing it.",
+                    MessageBoxButtons.OK, MessageBoxIcon.Information);
+                return false;
+            }
+
+            var saved = EditDrawing(new DrawingLibraryEditSession(libraryStore, current, Environment.UserName));
+            if (IsDisposed)
+                return false;
+            ApplyDrawing(saved ?? current);
+            if (saved == null)
+                return false;
+            statusLabel.Text = $"Saved '{saved.Name}' revision {saved.Revision} to the library.";
+            return true;
+        }
+
+        /// <summary>
+        /// Shows a newer library record of a listed drawing, in the sets that list it (their
+        /// joined members) and on its own line, and rebuilds the plan. Sets list drawings by id,
+        /// so the release takes the drawing as it now is.
+        /// </summary>
+        internal void ApplyDrawing(DrawingLibraryRecord drawing)
+        {
+            ArgumentNullException.ThrowIfNull(drawing);
+            var changed = false;
+            foreach (DataGridViewRow row in lineGrid.Rows)
+            {
+                if (row.Tag is DrawingSetRecord set)
+                {
+                    foreach (var member in set.Members ?? new List<DrawingSetMember>())
+                    {
+                        if (member.DrawingId == drawing.Id && (member.Drawing == null || member.Drawing.Revision < drawing.Revision))
+                        {
+                            member.Drawing = drawing;
+                            changed = true;
+                        }
+                    }
+                }
+                else if (row.Tag is DrawingLibraryRecord listed && listed.Id == drawing.Id && listed.Revision < drawing.Revision)
+                {
+                    row.Tag = drawing;
+                    row.Cells[lineNameColumn.Index].Value = drawing.Name;
+                    changed = true;
+                }
+            }
+
+            if (changed)
+                BuildPlan();
+        }
+
+        private async void ReleaseButton_Click(object sender, EventArgs e)
+        {
+            if (Result is { Release: null, ReleaseError.Length: > 0 })
+                await RetryRecordAsync();
+            else
+                await ReleaseAsync();
+        }
+
+        /// <summary>The groups ticked for release, in plan order.</summary>
+        internal IReadOnlyList<SetReleaseGroup> ChosenGroups() =>
+            plan.Groups.Where(g => g.CanRelease && !excluded.Contains(g.Key)).ToList();
+
+        /// <summary>The chosen groups that merge into a draft, with that draft.</summary>
+        internal IReadOnlyDictionary<SetReleaseGroup, NestRecord> ChosenMerges() =>
+            ChosenGroups().Select(g => (Group: g, Draft: TargetOf(g))).Where(m => m.Draft != null)
+                .ToDictionary(m => m.Group, m => m.Draft);
+
+        // A chosen group whose draft is open in a tab; Make Nests waits for it.
+        private NestRecord OpenTarget() => ChosenMerges().Values.FirstOrDefault(d => IsNestOpen(d.Id));
+
+        // Every chosen group knows whether a draft matches it, so none becomes a new nest by accident.
+        private bool DraftsKnown(IReadOnlyList<SetReleaseGroup> chosen) => chosen.All(g => drafts.ContainsKey(g.Key));
+
+        /// <summary>
+        /// Makes or merges one Draft nest per ticked group, opens each in its own tab and records
+        /// the release. Every group's outcome is shown in the grid.
+        /// </summary>
+        internal async Task ReleaseAsync()
+        {
+            if (!IsInitialized || running || Result != null || !lineGrid.EndEdit() || !groupGrid.EndEdit())
+                return;
+            var chosen = ChosenGroups();
+            if (chosen.Count == 0 || !DraftsKnown(chosen))
+                return;
+            if (OpenTarget() is { } open)
+            {
+                UpdateNotes();
+                UpdateCommands();
+                ShowMessage($"'{open.Name}' is open in a tab. Save and close it to merge into it, or choose {NewNestChoice} for its material.",
+                    MessageBoxButtons.OK, MessageBoxIcon.Information);
+                return;
+            }
+
+            var merges = ChosenMerges();
+            var nestAfter = nestAfterReleaseCheckBox.Checked;
+            running = true;
+            cancellation = new CancellationTokenSource();
+            UpdateCommands();
+            session = new SetReleaseSession(sets, library, nests, serverUrl, ReadPackage, WriteNest, CreateNest, ReadNest,
+                nestAfter ? Renest : null);
+            var progress = new Progress<SetReleaseProgress>(ShowProgress);
+            try
+            {
+                Result = await session.RunAsync(plan, chosen, Environment.UserName, notesBox.Text, progress, cancellation.Token, merges);
+            }
+            finally
+            {
+                running = false;
+            }
+
+            foreach (var done in Result.Created)
+                openNest(done.Nest, done.Record);
+            if (IsDisposed)
+                return;
+            ShowOutcome();
+            if (Result.Created.Count > 0)
+                NestsOpened?.Invoke(this, EventArgs.Empty);
+        }
+
+        /// <summary>Posts the release again after every nest was saved but recording it failed.</summary>
+        internal async Task RetryRecordAsync()
+        {
+            if (running || session == null || !session.HasPendingRelease)
+                return;
+            running = true;
+            UpdateCommands();
+            statusLabel.Text = "Recording the release...";
+            try
+            {
+                var release = await session.RetryReleaseAsync();
+                Result = Result.WithRelease(release);
+            }
+            catch (Exception ex) when (ex is IOException || ex is HttpRequestException
+                || ex is TaskCanceledException || ex is System.Text.Json.JsonException)
+            {
+                if (!IsDisposed)
+                    ShowMessage($"The release is still not recorded: {ex.Message}", MessageBoxButtons.OK, MessageBoxIcon.Warning);
+            }
+            finally
+            {
+                running = false;
+            }
+
+            if (!IsDisposed)
+                ShowOutcome();
+        }
+
+        private void BuildPlan()
+        {
+            plan = SetReleasePlan.Build(Lines(), DrawingLines(), includeArchivedCheckBox.Checked);
+            headingLabel.Text = Heading();
+            customerValue.Text = CustomerText();
+            populating = true;
+            groupGrid.Rows.Clear();
+            foreach (var group in plan.Groups)
+            {
+                var row = new DataGridViewRow { Tag = group };
+                row.CreateCells(groupGrid,
+                    group.CanRelease && !excluded.Contains(group.Key),
+                    GroupText(group),
+                    group.TotalQuantity,
+                    null,
+                    "");
+                row.Cells[groupColumn.Index].ToolTipText = string.Join(Environment.NewLine,
+                    group.Items.Take(20).Select(i => $"{i.Drawing.Name} ×{i.Quantity}"))
+                    + (group.Items.Count > 20 ? $"{Environment.NewLine}...and {group.Items.Count - 20} more" : "");
+                groupGrid.Rows.Add(row);
+                FillTargets(row, group);
+                row.Cells[statusColumn.Index].Value = GroupNote(group);
+            }
+            populating = false;
+            UpdateCommands();
+            _ = LoadDraftsAsync();
+        }
+
+        // "Release set 'Kit A' ×2", "Release 'Kit A' ×2, 'Kit B' ×1 and 'SYN-A' ×4".
+        private string Heading()
+        {
+            if (plan.Lines.Count + plan.Drawings.Count == 1)
+                return plan.Lines.Count == 1
+                    ? $"Release set '{plan.Lines[0].Set.Name}' ×{plan.Lines[0].Quantity}"
+                    : $"Release drawing '{plan.Drawings[0].Drawing.Name}' ×{plan.Drawings[0].Quantity}";
+            const int named = 3;
+            var lines = plan.Lines.Select(l => $"'{l.Set.Name}' ×{l.Quantity}")
+                .Concat(plan.Drawings.Select(d => $"'{d.Drawing.Name}' ×{d.Quantity}"))
+                .ToList();
+            if (lines.Count == 0)
+                return "Release";
+            if (lines.Count <= named + 1)
+                return $"Release {string.Join(", ", lines.Take(lines.Count - 1))} and {lines[^1]}";
+            return $"Release {string.Join(", ", lines.Take(named))} and {lines.Count - named} more";
+        }
+
+        // The release takes the one customer every line names; several leave it blank.
+        private string CustomerText()
+        {
+            if (plan.Lines.Count + plan.Drawings.Count == 0)
+                return "—";
+            if (plan.Customer.Length > 0)
+                return plan.Customer;
+            var named = plan.Lines.Select(l => l.Set.Customer).Concat(plan.Drawings.Select(d => d.Drawing.Customer))
+                .Select(c => (c ?? "").Trim()).Distinct(StringComparer.Ordinal).Count();
+            return named > 1 ? "Several (left blank on the release)" : "—";
+        }
+
+        // The target list of one group: each draft it could merge into, newest first, then a new nest.
+        private void FillTargets(DataGridViewRow row, SetReleaseGroup group)
+        {
+            var cell = (DataGridViewComboBoxCell)row.Cells[targetColumn.Index];
+            cell.Items.Clear();
+            var choice = TargetChoice(group);
+            if (group.CanRelease && drafts.TryGetValue(group.Key, out var candidates))
+            {
+                foreach (var draft in candidates.OrderByDescending(d => d.SavedAt))
+                    cell.Items.Add(DraftChoice(draft, candidates));
+                cell.Items.Add(NewNestChoice);
+            }
+            else if (choice.Length > 0)
+            {
+                cell.Items.Add(choice);
+            }
+            cell.Value = choice;
+            // Nothing to choose until the drafts are known, or with only a new nest to make.
+            cell.ReadOnly = !group.CanRelease || cell.Items.Count < 2;
+            cell.DisplayStyle = cell.ReadOnly ? DataGridViewComboBoxDisplayStyle.Nothing : DataGridViewComboBoxDisplayStyle.DropDownButton;
+        }
+
+        // The target cell's text: the draft, a new nest, or blank while looking or refused.
+        private string TargetChoice(SetReleaseGroup group)
+        {
+            if (!group.CanRelease)
+                return "";
+            if (!drafts.TryGetValue(group.Key, out var candidates))
+                return "Looking...";
+            var draft = TargetOf(group);
+            return draft == null ? NewNestChoice : DraftChoice(draft, candidates);
+        }
+
+        /// <summary>Looks up, once per group, the Draft nests it could merge into, then fills the lists.</summary>
+        internal async Task LoadDraftsAsync()
+        {
+            if (loadingDrafts || plan == null || nests == null)
+                return;
+            loadingDrafts = true;
+            try
+            {
+                while (plan.Groups.FirstOrDefault(g => g.CanRelease && !drafts.ContainsKey(g.Key)) is { } group)
+                {
+                    try
+                    {
+                        drafts[group.Key] = await SetReleasePlan.FindDraftsAsync(nests, group);
+                        lookupErrors.Remove(group.Key);
+                    }
+                    catch (Exception ex) when (ex is IOException or HttpRequestException or TaskCanceledException
+                        or System.Text.Json.JsonException or NotSupportedException)
+                    {
+                        drafts[group.Key] = Array.Empty<NestRecord>();
+                        lookupErrors[group.Key] = ex.Message;
+                    }
+                    if (IsDisposed)
+                        return;
+                }
+            }
+            finally
+            {
+                loadingDrafts = false;
+            }
+
+            if (IsDisposed || running || Result != null)
+                return;
+            populating = true;
+            foreach (DataGridViewRow row in groupGrid.Rows)
+            {
+                if (row.Tag is SetReleaseGroup group)
+                {
+                    FillTargets(row, group);
+                    row.Cells[statusColumn.Index].Value = GroupNote(group);
+                }
+            }
+            populating = false;
+            UpdateCommands();
+        }
+
+        private void UpdateNotes()
+        {
+            populating = true;
+            foreach (DataGridViewRow row in groupGrid.Rows)
+            {
+                if (row.Tag is SetReleaseGroup group)
+                    row.Cells[statusColumn.Index].Value = GroupNote(group);
+            }
+            populating = false;
+        }
+
+        /// <summary>What Make Nests will do with <paramref name="group"/>, or why it can't.</summary>
+        internal string GroupNote(SetReleaseGroup group)
+        {
+            if (!group.CanRelease)
+                return group.Refusal;
+            var notes = new List<string>();
+            if (excluded.Contains(group.Key))
+                notes.Add("Left out of this release.");
+            else if (!drafts.TryGetValue(group.Key, out var candidates))
+                notes.Add("Looking for a Draft nest to merge into...");
+            else if (TargetOf(group) is { } draft)
+            {
+                var sheets = $"{draft.PlateCount} sheet{(draft.PlateCount == 1 ? "" : "s")}";
+                if (IsNestOpen(draft.Id))
+                    notes.Add($"{draft.Name} is open — save and close it to merge into it.");
+                else if (nestAfterReleaseCheckBox.Checked)
+                    notes.Add($"→ merges into {draft.Name}; the whole draft ({sheets}) is nested again.");
+                else
+                    notes.Add($"→ merges into {draft.Name}; its {sheets} {(draft.PlateCount == 1 ? "is" : "are")} cleared, "
+                        + "leaving the draft without sheets until it is nested.");
+                if (candidates.Count > 1 && !targets.ContainsKey(group.Key))
+                    notes.Add($"{candidates.Count} Draft nests match; the newest is chosen.");
+            }
+            else
+            {
+                notes.Add(nestAfterReleaseCheckBox.Checked ? "→ new Draft nest, nested with Auto Nest." : "→ new Draft nest.");
+                if (lookupErrors.TryGetValue(group.Key, out var error))
+                    notes.Add($"Could not look for a Draft nest to merge into: {error}");
+                else if (candidates.Count > 0)
+                    notes.Add($"{candidates.Count} Draft nest{(candidates.Count == 1 ? " matches" : "s match")}; choose one to merge.");
+            }
+            notes.AddRange(group.Warnings);
+            return string.Join(" ", notes);
+        }
+
+        // A draft by its name; when several share it, the saved time tells them apart.
+        private static string DraftChoice(NestRecord draft, IReadOnlyList<NestRecord> candidates) =>
+            candidates.Count(d => d.Name == draft.Name) > 1
+                ? $"{draft.Name} (saved {draft.SavedAt.ToLocalTime().ToString("g", CultureInfo.CurrentCulture)})"
+                : draft.Name;
+
+        private void ShowProgress(SetReleaseProgress progress)
+        {
+            // Progress is posted, so a report can arrive after the run ended; the outcome wins.
+            if (IsDisposed || !running)
+                return;
+            statusLabel.Text = progress.Stage switch
+            {
+                SetReleaseStage.Preparing => $"Preparing nest {progress.Index + 1} of {progress.Count}: {Describe(progress.Group)}...",
+                SetReleaseStage.Nesting => $"Nesting nest {progress.Index + 1} of {progress.Count}: {Describe(progress.Group)}...",
+                SetReleaseStage.Uploading => $"Saving nest {progress.Index + 1} of {progress.Count}: {Describe(progress.Group)}...",
+                _ => "Recording the release...",
+            };
+        }
+
+        private void ShowOutcome()
+        {
+            populating = true;
+            foreach (DataGridViewRow row in groupGrid.Rows)
+            {
+                var outcome = Result.Groups.FirstOrDefault(g => ReferenceEquals(g.Group, row.Tag));
+                if (outcome == null)
+                    continue;
+                var notes = outcome.Warnings.Count == 0 ? "" : " — " + string.Join(" ", outcome.Warnings);
+                row.Cells[statusColumn.Index].Value = outcome.Outcome switch
+                {
+                    SetReleaseGroupOutcome.Created when outcome.MergedInto != null => $"Merged into {outcome.Record!.Name}" + notes,
+                    SetReleaseGroupOutcome.Created => $"Created {outcome.Record!.Name}" + notes,
+                    SetReleaseGroupOutcome.Refused => "Refused: " + outcome.Error,
+                    SetReleaseGroupOutcome.Failed => "Failed: " + outcome.Error,
+                    _ => "Not started",
+                };
+            }
+            populating = false;
+
+            var done = Result.Created.Count;
+            var nestsText = $"{done} nest{(done == 1 ? "" : "s")}";
+            if (Result.Release != null)
+                statusLabel.Text = $"Done: {nestsText} saved and opened.";
+            else if (Result.ReleaseError.Length > 0)
+                statusLabel.Text = Result.ReleaseError.TrimEnd('.', ' ')
+                    + ". Try Again records it; the nests are not made again.";
+            else if (Result.Canceled)
+                statusLabel.Text = $"Canceled: {nestsText} saved, release not recorded.";
+            else
+                statusLabel.Text = done == 0
+                    ? "Nothing saved. See What happens."
+                    : $"Stopped: {nestsText} saved, release not recorded. See What happens.";
+            UpdateCommands();
+        }
+
+        private void UpdateCommands()
+        {
+            var chosen = plan == null ? Array.Empty<SetReleaseGroup>() : ChosenGroups();
+            var editable = !running && Result == null;
+            lineQuantityColumn.ReadOnly = !editable;
+            notesBox.ReadOnly = !editable;
+            includeArchivedCheckBox.Enabled = editable;
+            includeArchivedCheckBox.Visible = includeArchivedCheckBox.Checked || plan?.SkippedArchived.Count > 0;
+            nestAfterReleaseCheckBox.Enabled = editable;
+            includeColumn.ReadOnly = !editable;
+            targetColumn.ReadOnly = !editable;
+            if (editable)
+            {
+                foreach (DataGridViewRow row in groupGrid.Rows)
+                {
+                    var refused = row.Tag is SetReleaseGroup { CanRelease: false };
+                    row.Cells[includeColumn.Index].ReadOnly = refused;
+                    row.Cells[targetColumn.Index].ReadOnly = refused
+                        || ((DataGridViewComboBoxCell)row.Cells[targetColumn.Index]).Items.Count < 2;
+                }
+            }
+
+            var refusedAny = plan != null && plan.Groups.Any(g => !g.CanRelease);
+            fixDrawingsButton.Visible = libraryStore != null && refusedAny;
+            fixDrawingsButton.Enabled = CanEditDrawings() && RefusedRow() != null;
+
+            hintLabel.Visible = IsEmpty || Result != null;
+            hintLabel.Text = Result != null
+                ? "Double-click a set or a drawing to start the next release, or Clear."
+                : "Double-click a set or a drawing to add it. Adding one again adds to its quantity.";
+            clearButton.Text = running ? "Stop" : "Clear";
+            clearButton.Enabled = running ? cancellation?.IsCancellationRequested != true : !IsEmpty || Result != null;
+
+            var retry = Result is { Release: null, ReleaseError.Length: > 0 };
+            var open = editable ? OpenTarget() : null;
+            releaseButton.Text = retry ? "Try Again" : chosen.Count == 0 ? "Make Nests" : $"Make Nests ({chosen.Count})";
+            releaseButton.Enabled = IsInitialized && !running
+                && (retry || (editable && chosen.Count > 0 && open == null && DraftsKnown(chosen)));
+            previewLabel.Text = editable ? Preview(chosen, open) : "";
+            previewLabel.Visible = previewLabel.Text.Length > 0;
+        }
+
+        // What needs the operator's attention before Make Nests.
+        private string Preview(IReadOnlyList<SetReleaseGroup> chosen, NestRecord open)
+        {
+            if (plan == null || plan.Groups.Count == 0)
+                return "";
+            var notes = new List<string>();
+            if (open != null)
+                notes.Add($"Make Nests waits: {open.Name} is open in a tab. Save and close it, or choose {NewNestChoice} for its material.");
+            var refused = plan.Groups.Count(g => !g.CanRelease);
+            if (refused > 0)
+                notes.Add($"{refused} material{(refused == 1 ? " can't" : "s can't")} be released yet: "
+                    + (libraryStore == null ? "see What happens." : "choose Fix Drawings."));
+            var skipped = plan.SkippedArchived;
+            if (skipped.Count > 0)
+                notes.Add($"{skipped.Count} archived drawing{(skipped.Count == 1 ? " is" : "s are")} left out: "
+                    + string.Join(", ", skipped.Take(5).Select(m => $"'{m.Drawing!.Name}'"))
+                    + (skipped.Count > 5 ? $" and {skipped.Count - 5} more" : "") + ".");
+            if (chosen.Count > 0 && !DraftsKnown(chosen))
+                notes.Add("Looking for Draft nests to merge into...");
+            var merges = chosen.Count(g => TargetOf(g) != null);
+            if (chosen.Count > 0 && DraftsKnown(chosen))
+            {
+                var parts = chosen.Sum(g => (long)g.TotalQuantity);
+                notes.Insert(0, $"{chosen.Count - merges} new, {merges} merged, {parts:N0} part{(parts == 1 ? "" : "s")}.");
+            }
+            return string.Join(" ", notes);
+        }
+
+        // "Synthetic Steel Grade A 0.25 in, Laser".
+        private static string GroupText(SetReleaseGroup group) =>
+            group.IsUnassigned ? "(no material or thickness)" : $"{Describe(group)}, {group.CutType}";
+
+        private static string Describe(SetReleaseGroup group) =>
+            group == null ? "" : string.Join(" ", new[]
+            {
+                group.MaterialName,
+                group.MaterialGrade,
+                $"{group.Thickness.ToString("0.####", CultureInfo.CurrentCulture)} {UnitsHelper.GetShortString(group.Units)}",
+            }.Where(s => !string.IsNullOrWhiteSpace(s)));
+
+        // The nest is not shown anywhere yet, so Auto Nest runs off the UI thread on it alone.
+        private static Task<SetReleaseRenest> RenestAsync(Nest nest, CancellationToken token)
+        {
+            var engineName = EngineSelection.EngineName;
+            return Task.Run(() =>
+            {
+                var renested = NestRenest.Run(nest, engineName, AutoNestForm.DefaultMinRemnantSize, token: token);
+                return new SetReleaseRenest(renested.Nested, renested.Note);
+            }, token);
+        }
+
+        private static LibraryPackage ReadPackage(byte[] bytes)
+        {
+            var contents = DrawingPackage.Read(bytes);
+            return new LibraryPackage(bytes, contents.Drawing, contents.Units, contents.Warnings);
+        }
+
+        private static Nest ReadNest(byte[] bytes)
+        {
+            using var stream = new MemoryStream(bytes, writable: false);
+            return new NestReader(stream) { BestFitStore = BestFitCacheStore.Shared }.Read();
+        }
+
+        private static byte[] WriteNest(Nest nest)
+        {
+            using var stream = new MemoryStream();
+            new NestWriter(nest) { BestFitStore = BestFitCacheStore.Shared }.Write(stream);
+            return stream.ToArray();
+        }
+    }
+
+    /// <summary>A release being built, kept while the Drawing Sets window is closed.</summary>
+    public sealed record ReleaseDraft(IReadOnlyList<SetReleasePlanLine> Sets, IReadOnlyList<SetReleaseDrawingLine> Drawings,
+        string Notes, bool IncludeArchived);
+}
diff --git a/OpenNest/Controls/SetReleasesView.Designer.cs b/OpenNest/Controls/SetReleasesView.Designer.cs
index 0b249f98..11a1a9e3 100644
--- a/OpenNest/Controls/SetReleasesView.Designer.cs
+++ b/OpenNest/Controls/SetReleasesView.Designer.cs
@@ -298,7 +298,7 @@ namespace OpenNest.Controls
             newReleaseButton.AutoSize = true;
             newReleaseButton.Name = "newReleaseButton";
             newReleaseButton.TabIndex = 3;
-            newReleaseButton.Text = "New Release...";
+            newReleaseButton.Text = "New Release";
             newReleaseButton.UseVisualStyleBackColor = true;
             newReleaseButton.Visible = false;
             newReleaseButton.Click += NewReleaseButton_Click;
diff --git a/OpenNest/Controls/SetReleasesView.cs b/OpenNest/Controls/SetReleasesView.cs
index 925a0a8f..95c11d64 100644
--- a/OpenNest/Controls/SetReleasesView.cs
+++ b/OpenNest/Controls/SetReleasesView.cs
@@ -17,8 +17,9 @@ namespace OpenNest.Controls
     /// the release did to each and their current status, or Deleted. A filter narrows the list
     /// to the releases that include one set, or one library drawing on its own; the filter
     /// shows above the list until Clear Filter. The server joins every nest's current metadata
-    /// on each read. New Release opens the release dialog empty; the list re-reads once a
-    /// release is recorded. Undo Release deletes the nests a release created and restores the
+    /// on each read. New Release switches to the Sets tab, where the window's
+    /// <see cref="ReleasePanel"/> builds the release; the list re-reads when the tab is shown
+    /// again. Undo Release deletes the nests a release created and restores the
     /// drafts it merged into, all or nothing; nests changed since can be left as they are.
     /// </summary>
     public partial class SetReleasesView : UserControl
@@ -38,11 +39,8 @@ namespace OpenNest.Controls
         /// <summary>Shows a message and returns the operator's answer; replaced by tests.</summary>
         internal Func<string, MessageBoxButtons, MessageBoxIcon, DialogResult> ShowMessage { get; set; }
 
-        /// <summary>
-        /// Shows the release dialog empty and returns true when it recorded a release; set by
-        /// <see cref="EnableRelease"/> and replaced by tests.
-        /// </summary>
-        internal Func<bool> ShowNewRelease { get; set; }
+        /// <summary>Starts a release in the host's release panel; set by <see cref="EnableRelease"/>.</summary>
+        internal Action StartRelease { get; private set; }
 
         public SetReleasesView()
         {
@@ -71,27 +69,12 @@ namespace OpenNest.Controls
             ShowMessage = (text, buttons, icon) => MessageBox.Show(FindForm(), text, FindForm()?.Text ?? "Releases", buttons, icon);
         }
 
-        /// <summary>
-        /// Shows New Release: the release dialog starts empty, saves nests through
-        /// <paramref name="nests"/> and opens each with <paramref name="openNest"/>; a nest
-        /// <paramref name="isNestOpen"/> reports as open in a tab is never merged into.
-        /// </summary>
-        public void EnableRelease(IDrawingLibrary library, INestRepository nests, string serverUrl,
-            Action<Nest, NestRecord> openNest, Func<Guid, bool> isNestOpen = null)
+        /// <summary>Shows New Release, which calls <paramref name="startRelease"/>.</summary>
+        public void EnableRelease(Action startRelease)
         {
-            ArgumentNullException.ThrowIfNull(library);
-            ArgumentNullException.ThrowIfNull(nests);
-            ArgumentNullException.ThrowIfNull(openNest);
             if (sets == null)
                 throw new InvalidOperationException("New Release needs an initialized releases view.");
-            ShowNewRelease = () =>
-            {
-                using var form = new ReleaseSetForm(sets, library, nests, serverUrl, Array.Empty<DrawingSetRecord>(),
-                    Array.Empty<SetReleaseDrawingLine>(), openNest)
-                { IsNestOpen = isNestOpen ?? (_ => false) };
-                form.ShowDialog(FindForm());
-                return form.Result?.Release != null;
-            };
+            StartRelease = startRelease ?? throw new ArgumentNullException(nameof(startRelease));
             newReleaseButton.Visible = true;
         }
 
@@ -137,16 +120,10 @@ namespace OpenNest.Controls
                 : "";
         }
 
-        private async void NewReleaseButton_Click(object sender, EventArgs e) => await NewReleaseAsync();
-
-        /// <summary>Opens the empty release dialog and, once it recorded a release, shows the newest page.</summary>
-        internal async Task NewReleaseAsync()
+        private void NewReleaseButton_Click(object sender, EventArgs e)
         {
-            if (ShowNewRelease == null || undoing)
-                return;
-            var recorded = ShowNewRelease();
-            if (recorded && !IsDisposed)
-                await LoadPageAsync(0);
+            if (!undoing)
+                StartRelease?.Invoke();
         }
 
         private async void PreviousButton_Click(object sender, EventArgs e) =>
diff --git a/OpenNest/Forms/DrawingSetsForm.Designer.cs b/OpenNest/Forms/DrawingSetsForm.Designer.cs
index e3b44397..59ca0a4e 100644
--- a/OpenNest/Forms/DrawingSetsForm.Designer.cs
+++ b/OpenNest/Forms/DrawingSetsForm.Designer.cs
@@ -18,6 +18,8 @@ namespace OpenNest.Forms
         private void InitializeComponent()
         {
             layoutTable = new System.Windows.Forms.TableLayoutPanel();
+            splitContainer = new System.Windows.Forms.SplitContainer();
+            releasePanel = new OpenNest.Controls.ReleasePanel();
             tabs = new System.Windows.Forms.TabControl();
             libraryTab = new System.Windows.Forms.TabPage();
             libraryView = new OpenNest.Controls.DrawingLibraryView();
@@ -28,6 +30,10 @@ namespace OpenNest.Forms
             buttonPanel = new System.Windows.Forms.FlowLayoutPanel();
             closeButton = new System.Windows.Forms.Button();
             layoutTable.SuspendLayout();
+            ((System.ComponentModel.ISupportInitialize)splitContainer).BeginInit();
+            splitContainer.Panel1.SuspendLayout();
+            splitContainer.Panel2.SuspendLayout();
+            splitContainer.SuspendLayout();
             tabs.SuspendLayout();
             libraryTab.SuspendLayout();
             setsTab.SuspendLayout();
@@ -39,7 +45,7 @@ namespace OpenNest.Forms
             //
             layoutTable.ColumnCount = 1;
             layoutTable.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle(System.Windows.Forms.SizeType.Percent, 100F));
-            layoutTable.Controls.Add(tabs, 0, 0);
+            layoutTable.Controls.Add(splitContainer, 0, 0);
             layoutTable.Controls.Add(buttonPanel, 0, 1);
             layoutTable.Dock = System.Windows.Forms.DockStyle.Fill;
             layoutTable.Location = new System.Drawing.Point(0, 0);
@@ -51,6 +57,27 @@ namespace OpenNest.Forms
             layoutTable.Size = new System.Drawing.Size(984, 601);
             layoutTable.TabIndex = 0;
             //
+            // splitContainer
+            //
+            splitContainer.Dock = System.Windows.Forms.DockStyle.Fill;
+            splitContainer.FixedPanel = System.Windows.Forms.FixedPanel.Panel2;
+            splitContainer.Margin = new System.Windows.Forms.Padding(0);
+            splitContainer.Name = "splitContainer";
+            splitContainer.Panel1.Controls.Add(tabs);
+            splitContainer.Panel2.Controls.Add(releasePanel);
+            splitContainer.Panel2.Padding = new System.Windows.Forms.Padding(6, 0, 0, 0);
+            splitContainer.Panel2Collapsed = true;
+            splitContainer.Size = new System.Drawing.Size(1008, 580);
+            splitContainer.SplitterDistance = 560;
+            splitContainer.TabIndex = 0;
+            //
+            // releasePanel
+            //
+            releasePanel.Dock = System.Windows.Forms.DockStyle.Fill;
+            releasePanel.Margin = new System.Windows.Forms.Padding(0);
+            releasePanel.Name = "releasePanel";
+            releasePanel.TabIndex = 0;
+            //
             // tabs
             //
             tabs.Controls.Add(libraryTab);
@@ -137,16 +164,21 @@ namespace OpenNest.Forms
             ClientSize = new System.Drawing.Size(1024, 641);
             Controls.Add(layoutTable);
             Font = new System.Drawing.Font("Segoe UI", 9.75F);
-            MinimizeBox = false;
             MinimumSize = new System.Drawing.Size(720, 440);
             Name = "DrawingSetsForm";
             ShowIcon = false;
             ShowInTaskbar = false;
             StartPosition = System.Windows.Forms.FormStartPosition.CenterParent;
+            Activated += DrawingSetsForm_Activated;
+            FormClosing += DrawingSetsForm_FormClosing;
             Text = "Drawing Sets";
             Shown += DrawingSetsForm_Shown;
             layoutTable.ResumeLayout(false);
             layoutTable.PerformLayout();
+            splitContainer.Panel1.ResumeLayout(false);
+            splitContainer.Panel2.ResumeLayout(false);
+            ((System.ComponentModel.ISupportInitialize)splitContainer).EndInit();
+            splitContainer.ResumeLayout(false);
             tabs.ResumeLayout(false);
             libraryTab.ResumeLayout(false);
             setsTab.ResumeLayout(false);
@@ -159,6 +191,8 @@ namespace OpenNest.Forms
         #endregion
 
         private System.Windows.Forms.TableLayoutPanel layoutTable;
+        private System.Windows.Forms.SplitContainer splitContainer;
+        private OpenNest.Controls.ReleasePanel releasePanel;
         private System.Windows.Forms.TabControl tabs;
         private System.Windows.Forms.TabPage libraryTab;
         private OpenNest.Controls.DrawingLibraryView libraryView;
diff --git a/OpenNest/Forms/DrawingSetsForm.cs b/OpenNest/Forms/DrawingSetsForm.cs
index 1686a8aa..6d6ed8a6 100644
--- a/OpenNest/Forms/DrawingSetsForm.cs
+++ b/OpenNest/Forms/DrawingSetsForm.cs
@@ -12,12 +12,17 @@ namespace OpenNest.Forms
     /// <see cref="DrawingLibraryView"/>; Sets browses, edits and releases the server's drawing sets with
     /// <see cref="DrawingSetBrowser"/>; Releases lists the releases with
     /// <see cref="SetReleasesView"/>, and a set's Releases (or a library drawing's) opens that
-    /// tab filtered to it. It needs no open nest, since a release creates new nests or merges
-    /// into draft ones and opens each in its own tab. Each tab reads its list when first shown;
-    /// Releases re-reads its page whenever it is shown again, so a release made on Sets appears.
+    /// tab filtered to it. Once release is enabled, a <see cref="ReleasePanel"/> beside the
+    /// Library and Sets tabs builds one release from both: a double-click adds a set or a
+    /// drawing to it. It needs no open nest, since a release creates new nests or merges into
+    /// draft ones and opens each in its own tab. Each tab reads its list when first shown;
+    /// Releases re-reads its page whenever it is shown again, so a release made meanwhile appears.
     /// </summary>
     public partial class DrawingSetsForm : Form
     {
+        private const int ReleasePanelWidth = 620;
+
+        private readonly IDrawingSetStore sets;
         private readonly IDrawingLibraryStore library;
         private readonly string serverUrl;
         private bool shown;
@@ -28,6 +33,9 @@ namespace OpenNest.Forms
 
         internal SetReleasesView Releases => releasesView;
 
+        /// <summary>The release being built; shown beside the Library and Sets tabs once release is enabled.</summary>
+        internal ReleasePanel ReleasePanel => releasePanel;
+
         /// <summary>True while the Releases tab is showing.</summary>
         public bool ShowsReleases => tabs.SelectedTab == releasesTab;
 
@@ -35,6 +43,7 @@ namespace OpenNest.Forms
         public DrawingSetsForm(IDrawingSetStore sets, IDrawingLibraryStore library, string serverUrl)
         {
             InitializeComponent();
+            this.sets = sets ?? throw new ArgumentNullException(nameof(sets));
             this.library = library ?? throw new ArgumentNullException(nameof(library));
             this.serverUrl = serverUrl ?? "";
             browser.Initialize(sets, library, serverUrl);
@@ -43,20 +52,87 @@ namespace OpenNest.Forms
             libraryView.ShowReleases = drawing => _ = ShowReleasesAsync(drawing: drawing);
             releasesView.Initialize(sets);
             Text = $"Drawing Library — {serverUrl}";
-            // Shown as an MDI child, where a DialogResult button no longer closes the window.
+            // Shown modeless, where a DialogResult button does not close the window.
             closeButton.Click += (_, _) => Close();
+            Load += (_, _) => FitReleasePanel();
         }
 
         /// <summary>
-        /// Shows Release, and New Release on the Releases tab: nests are saved through
-        /// <paramref name="nests"/> and each is opened with <paramref name="openNest"/>; a nest
-        /// <paramref name="isNestOpen"/> reports as open in a tab is never merged into.
+        /// Shows the release panel beside the Library and Sets tabs, and New Release on the
+        /// Releases tab: nests are saved through <paramref name="nests"/> and each is opened with
+        /// <paramref name="openNest"/>; a nest <paramref name="isNestOpen"/> reports as open in a
+        /// tab is never merged into.
         /// </summary>
         public void EnableRelease(INestRepository nests, Action<Nest, NestRecord> openNest, Func<Guid, bool> isNestOpen = null)
         {
-            libraryView.EnableRelease(nests, openNest, isNestOpen);
-            browser.EnableRelease(nests, openNest, isNestOpen);
-            releasesView.EnableRelease(library, nests, serverUrl, openNest, isNestOpen);
+            releasePanel.Initialize(sets, library, nests, serverUrl, openNest);
+            releasePanel.IsNestOpen = isNestOpen ?? (_ => false);
+            browser.EnableRelease(set => releasePanel.AddSet(set));
+            libraryView.EnableRelease((drawing, quantity) => releasePanel.AddDrawings(new[] { drawing }, quantity));
+            releasesView.EnableRelease(StartRelease);
+            UpdateReleasePanel();
+        }
+
+        /// <summary>Raised once Make Nests has opened the nests it made.</summary>
+        public event EventHandler NestsOpened
+        {
+            add => releasePanel.NestsOpened += value;
+            remove => releasePanel.NestsOpened -= value;
+        }
+
+        /// <summary>The release being built, to keep while the window is closed; null when there is none.</summary>
+        public ReleaseDraft TakeRelease() => releasePanel.TakeDraft();
+
+        /// <summary>Lists a release kept by <see cref="TakeRelease"/> again.</summary>
+        public void RestoreRelease(ReleaseDraft draft) => releasePanel.Restore(draft);
+
+        // New Release: the release is built on the Sets tab, starting afresh once one has run.
+        private void StartRelease()
+        {
+            ShowSets();
+            if (releasePanel.Result != null && releasePanel.ConfirmDiscard())
+                releasePanel.Clear();
+            releasePanel.Focus();
+        }
+
+        // The panel shows beside the lists it adds from, never over the releases.
+        private void UpdateReleasePanel()
+        {
+            var show = releasePanel.IsInitialized && !ShowsReleases;
+            if (splitContainer.Panel2Collapsed == !show)
+                return;
+            splitContainer.Panel2Collapsed = !show;
+            if (show)
+                FitReleasePanel();
+        }
+
+        private void FitReleasePanel()
+        {
+            if (splitContainer.Panel2Collapsed)
+                return;
+            splitContainer.Panel1MinSize = 300;
+            splitContainer.Panel2MinSize = releasePanel.MinimumSize.Width;
+            var available = splitContainer.Width - splitContainer.SplitterWidth;
+            if (available >= splitContainer.Panel1MinSize + splitContainer.Panel2MinSize)
+                splitContainer.SplitterDistance = System.Math.Clamp(available - ReleasePanelWidth,
+                    splitContainer.Panel1MinSize, available - splitContainer.Panel2MinSize);
+        }
+
+        // A draft closed in a tab meanwhile can be merged into now.
+        private void DrawingSetsForm_Activated(object sender, EventArgs e) => releasePanel.RefreshOpenNests();
+
+        private void DrawingSetsForm_FormClosing(object sender, FormClosingEventArgs e)
+        {
+            // Nests may be on their way to the server; Make Nests stops between uploads, never mid-way.
+            if (releasePanel.IsRunning)
+            {
+                e.Cancel = true;
+                MessageBox.Show(this, "Make Nests is still running. Stop it, or wait for it to finish, before closing.",
+                    Text, MessageBoxButtons.OK, MessageBoxIcon.Information);
+                return;
+            }
+            if (e.CloseReason == CloseReason.UserClosing && !releasePanel.ConfirmDiscard())
+                e.Cancel = true;
         }
 
         /// <summary>
@@ -106,6 +182,7 @@ namespace OpenNest.Forms
 
         private async void Tabs_SelectedIndexChanged(object sender, EventArgs e)
         {
+            UpdateReleasePanel();
             if (shown)
                 await RefreshSelectedTabAsync();
         }
diff --git a/OpenNest/Forms/MainForm.File.cs b/OpenNest/Forms/MainForm.File.cs
index 174ae0ba..06e43663 100644
--- a/OpenNest/Forms/MainForm.File.cs
+++ b/OpenNest/Forms/MainForm.File.cs
@@ -11,6 +11,10 @@ namespace OpenNest.Forms
 {
     public partial class MainForm
     {
+        // The Drawing Sets window while it is open, and the release it was building when it last closed.
+        private DrawingSetsForm drawingSetsForm;
+        private Controls.ReleaseDraft releaseDraft;
+
         private void LoadNest(Nest nest, FormWindowState windowState = FormWindowState.Maximized,
             Guid remoteId = default, string serverUrl = null, int remoteRevision = 0)
         {
@@ -144,9 +148,10 @@ namespace OpenNest.Forms
                 return;
 
             // One Drawing Sets window at a time: a second menu click brings it forward on the tab asked for.
-            var open = MdiChildren.OfType<DrawingSetsForm>().FirstOrDefault();
-            if (open != null)
+            if (drawingSetsForm is { IsDisposed: false } open)
             {
+                if (open.WindowState == FormWindowState.Minimized)
+                    open.WindowState = FormWindowState.Normal;
                 open.Activate();
                 if (releases)
                     _ = open.ShowReleasesAsync();
@@ -174,16 +179,35 @@ namespace OpenNest.Forms
                 return;
             }
 
-            // An MDI child beside the nest tabs, maximized when it opens; disposed when closed.
-            var form = new DrawingSetsForm(sets, library, NestStorage.Settings.ServerUrl);
+            // A window of its own, beside the main window rather than in it: the main window's
+            // menus and toolbar edit nests. It is not owned, so either can be in front.
+            var form = new DrawingSetsForm(sets, library, NestStorage.Settings.ServerUrl)
+            {
+                Icon = Icon,
+                ShowIcon = true,
+                ShowInTaskbar = true,
+                MinimizeBox = true,
+            };
             form.EnableRelease(nests, OpenServerNest, IsServerNestOpen);
+            form.RestoreRelease(releaseDraft);
+            releaseDraft = null;
+            // The nests a release made open here, so this window comes forward to show them.
+            form.NestsOpened += (_, _) => Activate();
             if (releases)
                 _ = form.ShowReleasesAsync();
             else if (libraryTab)
                 form.ShowLibrary();
             form.ImportBomWhenShown = importBom;
-            form.MdiParent = this;
-            form.WindowState = FormWindowState.Maximized;
+            MainWindowSettings.LoadDrawingSets(form);
+            form.FormClosed += (_, _) =>
+            {
+                // A release not yet made is kept for the next time the window opens in this run.
+                releaseDraft = form.TakeRelease();
+                MainWindowSettings.SaveDrawingSets(form);
+                if (drawingSetsForm == form)
+                    drawingSetsForm = null;
+            };
+            drawingSetsForm = form;
             form.Show();
         }
 
diff --git a/OpenNest/Forms/MainForm.cs b/OpenNest/Forms/MainForm.cs
index 4892a727..a9afe7e6 100644
--- a/OpenNest/Forms/MainForm.cs
+++ b/OpenNest/Forms/MainForm.cs
@@ -307,7 +307,15 @@ namespace OpenNest.Forms
         protected override void OnClosing(System.ComponentModel.CancelEventArgs e)
         {
             base.OnClosing(e);
-            MainWindowSettings.Save(this);
+            // The Drawing Sets window closes with this one; while Make Nests runs, neither does.
+            if (!e.Cancel && drawingSetsForm is { IsDisposed: false } sets)
+            {
+                sets.Close();
+                if (!sets.IsDisposed)
+                    e.Cancel = true;
+            }
+            if (!e.Cancel)
+                MainWindowSettings.Save(this);
         }
 
         #endregion
diff --git a/OpenNest/Forms/MainWindowSettings.cs b/OpenNest/Forms/MainWindowSettings.cs
index 10efcd1f..530a2d48 100644
--- a/OpenNest/Forms/MainWindowSettings.cs
+++ b/OpenNest/Forms/MainWindowSettings.cs
@@ -38,6 +38,41 @@ namespace OpenNest.Forms
             Settings.Default.Save();
         }
 
+        /// <summary>
+        /// Places the Drawing Sets window where it last closed when that still shows on a
+        /// screen; the first time, maximized on the main window's screen.
+        /// </summary>
+        public static void LoadDrawingSets(Form form)
+        {
+            var bounds = new System.Drawing.Rectangle(Settings.Default.DrawingSetsWindowLocation, Settings.Default.DrawingSetsWindowSize);
+            form.StartPosition = FormStartPosition.Manual;
+            if (bounds.Width > 0 && bounds.Height > 0
+                && Array.Exists(Screen.AllScreens, s => s.WorkingArea.IntersectsWith(bounds)))
+            {
+                form.Bounds = bounds;
+                form.WindowState = Settings.Default.DrawingSetsWindowState == FormWindowState.Maximized
+                    ? FormWindowState.Maximized : FormWindowState.Normal;
+                return;
+            }
+
+            var owner = Application.OpenForms.Count > 0 ? Screen.FromControl(Application.OpenForms[0]) : Screen.PrimaryScreen;
+            var area = owner.WorkingArea;
+            form.Bounds = new System.Drawing.Rectangle(area.X + area.Width / 10, area.Y + area.Height / 10,
+                area.Width * 8 / 10, area.Height * 8 / 10);
+            form.WindowState = FormWindowState.Maximized;
+        }
+
+        /// <summary>Remembers the Drawing Sets window's restored bounds and whether it was maximized.</summary>
+        public static void SaveDrawingSets(Form form)
+        {
+            var bounds = form.WindowState == FormWindowState.Normal ? form.Bounds : form.RestoreBounds;
+            Settings.Default.DrawingSetsWindowLocation = bounds.Location;
+            Settings.Default.DrawingSetsWindowSize = bounds.Size;
+            Settings.Default.DrawingSetsWindowState = form.WindowState == FormWindowState.Maximized
+                ? FormWindowState.Maximized : FormWindowState.Normal;
+            Settings.Default.Save();
+        }
+
         /// <summary>
         /// One-time upgrade: converts a legacy .nstdot nest template
         /// (NestTemplatePath setting) into defaults.json, then clears the
diff --git a/OpenNest/Forms/ReleaseSetForm.Designer.cs b/OpenNest/Forms/ReleaseSetForm.Designer.cs
index 7c61ec6e..cddbdf8a 100644
--- a/OpenNest/Forms/ReleaseSetForm.Designer.cs
+++ b/OpenNest/Forms/ReleaseSetForm.Designer.cs
@@ -6,12 +6,9 @@ namespace OpenNest.Forms
 
         protected override void Dispose(bool disposing)
         {
-            if (disposing)
+            if (disposing && (components != null))
             {
-                cancellation?.Dispose();
-                searchCancellation?.Dispose();
-                if (components != null)
-                    components.Dispose();
+                components.Dispose();
             }
             base.Dispose(disposing);
         }
@@ -20,583 +17,96 @@ namespace OpenNest.Forms
 
         private void InitializeComponent()
         {
-            components = new System.ComponentModel.Container();
-            System.Windows.Forms.DataGridViewCellStyle rightAligned = new System.Windows.Forms.DataGridViewCellStyle();
             layoutTable = new System.Windows.Forms.TableLayoutPanel();
-            setLabel = new System.Windows.Forms.Label();
-            addSetTable = new System.Windows.Forms.TableLayoutPanel();
-            addSetLabel = new System.Windows.Forms.Label();
-            addSetCombo = new System.Windows.Forms.ComboBox();
-            addSetButton = new System.Windows.Forms.Button();
-            addDrawingsButton = new System.Windows.Forms.Button();
-            removeSetButton = new System.Windows.Forms.Button();
-            setGrid = new System.Windows.Forms.DataGridView();
-            lineTypeColumn = new System.Windows.Forms.DataGridViewTextBoxColumn();
-            setNameColumn = new System.Windows.Forms.DataGridViewTextBoxColumn();
-            setCustomerColumn = new System.Windows.Forms.DataGridViewTextBoxColumn();
-            setRevisionColumn = new System.Windows.Forms.DataGridViewTextBoxColumn();
-            kitsColumn = new System.Windows.Forms.DataGridViewTextBoxColumn();
-            optionsTable = new System.Windows.Forms.TableLayoutPanel();
-            includeArchivedCheckBox = new System.Windows.Forms.CheckBox();
-            nestAfterReleaseCheckBox = new System.Windows.Forms.CheckBox();
-            notesLabel = new System.Windows.Forms.Label();
-            notesBox = new System.Windows.Forms.TextBox();
-            previewTable = new System.Windows.Forms.TableLayoutPanel();
-            previewLabel = new System.Windows.Forms.Label();
-            optionsButton = new System.Windows.Forms.Button();
-            groupGrid = new System.Windows.Forms.DataGridView();
-            includeColumn = new System.Windows.Forms.DataGridViewCheckBoxColumn();
-            materialColumn = new System.Windows.Forms.DataGridViewTextBoxColumn();
-            gradeColumn = new System.Windows.Forms.DataGridViewTextBoxColumn();
-            thicknessColumn = new System.Windows.Forms.DataGridViewTextBoxColumn();
-            unitsColumn = new System.Windows.Forms.DataGridViewTextBoxColumn();
-            cutTypeColumn = new System.Windows.Forms.DataGridViewTextBoxColumn();
-            drawingsColumn = new System.Windows.Forms.DataGridViewTextBoxColumn();
-            partsColumn = new System.Windows.Forms.DataGridViewTextBoxColumn();
-            targetColumn = new System.Windows.Forms.DataGridViewComboBoxColumn();
-            statusColumn = new System.Windows.Forms.DataGridViewTextBoxColumn();
-            skippedLabel = new System.Windows.Forms.Label();
-            bottomTable = new System.Windows.Forms.TableLayoutPanel();
-            summaryLabel = new System.Windows.Forms.Label();
-            releaseButton = new System.Windows.Forms.Button();
+            releasePanel = new OpenNest.Controls.ReleasePanel();
+            buttonPanel = new System.Windows.Forms.FlowLayoutPanel();
             closeButton = new System.Windows.Forms.Button();
-            statusLabel = new System.Windows.Forms.Label();
-            searchTimer = new System.Windows.Forms.Timer(components);
-            fixDrawingsButton = new System.Windows.Forms.Button();
-            groupMenu = new System.Windows.Forms.ContextMenuStrip(components);
+            addDrawingsButton = new System.Windows.Forms.Button();
             layoutTable.SuspendLayout();
-            addSetTable.SuspendLayout();
-            ((System.ComponentModel.ISupportInitialize)setGrid).BeginInit();
-            optionsTable.SuspendLayout();
-            previewTable.SuspendLayout();
-            ((System.ComponentModel.ISupportInitialize)groupGrid).BeginInit();
-            bottomTable.SuspendLayout();
+            buttonPanel.SuspendLayout();
             SuspendLayout();
             //
             // layoutTable
             //
             layoutTable.ColumnCount = 1;
             layoutTable.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle(System.Windows.Forms.SizeType.Percent, 100F));
-            layoutTable.Controls.Add(setLabel, 0, 0);
-            layoutTable.Controls.Add(addSetTable, 0, 1);
-            layoutTable.Controls.Add(setGrid, 0, 2);
-            layoutTable.Controls.Add(optionsTable, 0, 3);
-            layoutTable.Controls.Add(previewTable, 0, 4);
-            layoutTable.Controls.Add(groupGrid, 0, 5);
-            layoutTable.Controls.Add(skippedLabel, 0, 6);
-            layoutTable.Controls.Add(bottomTable, 0, 7);
-            layoutTable.Controls.Add(statusLabel, 0, 8);
+            layoutTable.Controls.Add(releasePanel, 0, 0);
+            layoutTable.Controls.Add(buttonPanel, 0, 1);
             layoutTable.Dock = System.Windows.Forms.DockStyle.Fill;
             layoutTable.Location = new System.Drawing.Point(0, 0);
             layoutTable.Name = "layoutTable";
             layoutTable.Padding = new System.Windows.Forms.Padding(8);
-            layoutTable.RowCount = 9;
-            layoutTable.RowStyles.Add(new System.Windows.Forms.RowStyle());
-            layoutTable.RowStyles.Add(new System.Windows.Forms.RowStyle());
-            layoutTable.RowStyles.Add(new System.Windows.Forms.RowStyle(System.Windows.Forms.SizeType.Absolute, 130F));
-            layoutTable.RowStyles.Add(new System.Windows.Forms.RowStyle());
-            layoutTable.RowStyles.Add(new System.Windows.Forms.RowStyle());
+            layoutTable.RowCount = 2;
             layoutTable.RowStyles.Add(new System.Windows.Forms.RowStyle(System.Windows.Forms.SizeType.Percent, 100F));
             layoutTable.RowStyles.Add(new System.Windows.Forms.RowStyle());
-            layoutTable.RowStyles.Add(new System.Windows.Forms.RowStyle());
-            layoutTable.RowStyles.Add(new System.Windows.Forms.RowStyle());
-            layoutTable.Size = new System.Drawing.Size(1104, 661);
+            layoutTable.Size = new System.Drawing.Size(760, 640);
             layoutTable.TabIndex = 0;
             //
-            // setLabel
-            //
-            setLabel.AutoEllipsis = true;
-            setLabel.Dock = System.Windows.Forms.DockStyle.Fill;
-            setLabel.Font = new System.Drawing.Font("Segoe UI", 9.75F, System.Drawing.FontStyle.Bold);
-            setLabel.Margin = new System.Windows.Forms.Padding(3, 0, 3, 6);
-            setLabel.Name = "setLabel";
-            setLabel.Size = new System.Drawing.Size(100, 20);
-            setLabel.TabIndex = 0;
-            setLabel.Text = "Sets and drawings to release";
-            //
-            // addSetTable
-            //
-            addSetTable.AutoSize = true;
-            addSetTable.ColumnCount = 5;
-            addSetTable.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle());
-            addSetTable.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle(System.Windows.Forms.SizeType.Absolute, 360F));
-            addSetTable.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle());
-            addSetTable.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle());
-            addSetTable.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle(System.Windows.Forms.SizeType.Percent, 100F));
-            addSetTable.Controls.Add(addSetLabel, 0, 0);
-            addSetTable.Controls.Add(addSetCombo, 1, 0);
-            addSetTable.Controls.Add(addSetButton, 2, 0);
-            addSetTable.Controls.Add(addDrawingsButton, 3, 0);
-            addSetTable.Controls.Add(removeSetButton, 4, 0);
-            addSetTable.Dock = System.Windows.Forms.DockStyle.Fill;
-            addSetTable.Margin = new System.Windows.Forms.Padding(0, 0, 0, 3);
-            addSetTable.Name = "addSetTable";
-            addSetTable.RowCount = 1;
-            addSetTable.RowStyles.Add(new System.Windows.Forms.RowStyle());
-            addSetTable.TabIndex = 1;
-            //
-            // addSetLabel
-            //
-            addSetLabel.Anchor = System.Windows.Forms.AnchorStyles.Left;
-            addSetLabel.AutoSize = true;
-            addSetLabel.Name = "addSetLabel";
-            addSetLabel.TabIndex = 0;
-            addSetLabel.Text = "Add a set:";
-            //
-            // addSetCombo
-            //
-            addSetCombo.Dock = System.Windows.Forms.DockStyle.Fill;
-            addSetCombo.Name = "addSetCombo";
-            addSetCombo.TabIndex = 1;
-            addSetCombo.TextUpdate += AddSetCombo_TextUpdate;
-            addSetCombo.DropDown += AddSetCombo_DropDown;
-            addSetCombo.KeyDown += AddSetCombo_KeyDown;
-            //
-            // addSetButton
-            //
-            addSetButton.AutoSize = true;
-            addSetButton.Name = "addSetButton";
-            addSetButton.TabIndex = 2;
-            addSetButton.Text = "Add";
-            addSetButton.UseVisualStyleBackColor = true;
-            addSetButton.Click += AddSetButton_Click;
-            //
-            // addDrawingsButton
-            //
-            addDrawingsButton.Anchor = System.Windows.Forms.AnchorStyles.Left;
-            addDrawingsButton.AutoSize = true;
-            addDrawingsButton.Margin = new System.Windows.Forms.Padding(12, 3, 3, 3);
-            addDrawingsButton.Name = "addDrawingsButton";
-            addDrawingsButton.TabIndex = 3;
-            addDrawingsButton.Text = "Add Drawings...";
-            addDrawingsButton.UseVisualStyleBackColor = true;
-            addDrawingsButton.Click += AddDrawingsButton_Click;
-            //
-            // removeSetButton
-            //
-            removeSetButton.Anchor = System.Windows.Forms.AnchorStyles.Left;
-            removeSetButton.AutoSize = true;
-            removeSetButton.Name = "removeSetButton";
-            removeSetButton.TabIndex = 4;
-            removeSetButton.Text = "Remove";
-            removeSetButton.UseVisualStyleBackColor = true;
-            removeSetButton.Click += RemoveSetButton_Click;
-            //
-            // setGrid
-            //
-            setGrid.AllowUserToAddRows = false;
-            setGrid.AllowUserToDeleteRows = false;
-            setGrid.Columns.AddRange(new System.Windows.Forms.DataGridViewColumn[] { lineTypeColumn, setNameColumn, setCustomerColumn, setRevisionColumn, kitsColumn });
-            setGrid.Dock = System.Windows.Forms.DockStyle.Fill;
-            setGrid.Margin = new System.Windows.Forms.Padding(3, 3, 3, 6);
-            setGrid.MultiSelect = false;
-            setGrid.Name = "setGrid";
-            setGrid.RowHeadersVisible = false;
-            setGrid.SelectionMode = System.Windows.Forms.DataGridViewSelectionMode.FullRowSelect;
-            setGrid.StandardTab = true;
-            setGrid.TabIndex = 2;
-            setGrid.CellValidating += SetGrid_CellValidating;
-            setGrid.CellValueChanged += SetGrid_CellValueChanged;
-            setGrid.SelectionChanged += SetGrid_SelectionChanged;
-            //
-            // lineTypeColumn
-            //
-            lineTypeColumn.HeaderText = "Type";
-            lineTypeColumn.Name = "lineTypeColumn";
-            lineTypeColumn.ReadOnly = true;
-            lineTypeColumn.SortMode = System.Windows.Forms.DataGridViewColumnSortMode.NotSortable;
-            lineTypeColumn.Width = 70;
-            //
-            // setNameColumn
-            //
-            setNameColumn.Width = 260;
-            setNameColumn.HeaderText = "Set or drawing";
-            setNameColumn.Name = "setNameColumn";
-            setNameColumn.ReadOnly = true;
-            setNameColumn.SortMode = System.Windows.Forms.DataGridViewColumnSortMode.NotSortable;
-            //
-            // setCustomerColumn
-            //
-            setCustomerColumn.HeaderText = "Customer";
-            setCustomerColumn.Name = "setCustomerColumn";
-            setCustomerColumn.ReadOnly = true;
-            setCustomerColumn.SortMode = System.Windows.Forms.DataGridViewColumnSortMode.NotSortable;
-            setCustomerColumn.Width = 200;
-            //
-            // setRevisionColumn
-            //
-            setRevisionColumn.DefaultCellStyle = rightAligned;
-            setRevisionColumn.HeaderText = "Revision";
-            setRevisionColumn.Name = "setRevisionColumn";
-            setRevisionColumn.ReadOnly = true;
-            setRevisionColumn.SortMode = System.Windows.Forms.DataGridViewColumnSortMode.NotSortable;
-            setRevisionColumn.Width = 75;
-            //
-            // kitsColumn
-            //
-            kitsColumn.DefaultCellStyle = rightAligned;
-            kitsColumn.HeaderText = "Quantity";
-            kitsColumn.Name = "kitsColumn";
-            kitsColumn.SortMode = System.Windows.Forms.DataGridViewColumnSortMode.NotSortable;
-            kitsColumn.ToolTipText = "How many to make. For a set, every quantity in the set is multiplied by it.";
-            kitsColumn.Width = 80;
-            //
-            // optionsTable
-            //
-            optionsTable.AutoSize = true;
-            optionsTable.ColumnCount = 3;
-            optionsTable.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle());
-            optionsTable.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle());
-            optionsTable.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle(System.Windows.Forms.SizeType.Percent, 100F));
-            optionsTable.Controls.Add(nestAfterReleaseCheckBox, 0, 0);
-            optionsTable.Controls.Add(notesLabel, 1, 0);
-            optionsTable.Controls.Add(notesBox, 2, 0);
-            optionsTable.Dock = System.Windows.Forms.DockStyle.Fill;
-            optionsTable.Margin = new System.Windows.Forms.Padding(0, 0, 0, 6);
-            optionsTable.Name = "optionsTable";
-            optionsTable.RowCount = 1;
-            optionsTable.RowStyles.Add(new System.Windows.Forms.RowStyle());
-            optionsTable.TabIndex = 3;
-            //
-            // includeArchivedCheckBox
-            //
-            includeArchivedCheckBox.Anchor = System.Windows.Forms.AnchorStyles.Left;
-            includeArchivedCheckBox.AutoSize = true;
-            includeArchivedCheckBox.Margin = new System.Windows.Forms.Padding(12, 3, 3, 3);
-            includeArchivedCheckBox.Name = "includeArchivedCheckBox";
-            includeArchivedCheckBox.TabIndex = 1;
-            includeArchivedCheckBox.Visible = false;
-            includeArchivedCheckBox.Text = "Include archived drawings";
-            includeArchivedCheckBox.UseVisualStyleBackColor = true;
-            includeArchivedCheckBox.CheckedChanged += Options_Changed;
-            //
-            // nestAfterReleaseCheckBox
-            //
-            nestAfterReleaseCheckBox.Anchor = System.Windows.Forms.AnchorStyles.Left;
-            nestAfterReleaseCheckBox.AutoSize = true;
-            nestAfterReleaseCheckBox.Checked = true;
-            nestAfterReleaseCheckBox.CheckState = System.Windows.Forms.CheckState.Checked;
-            nestAfterReleaseCheckBox.Name = "nestAfterReleaseCheckBox";
-            nestAfterReleaseCheckBox.TabIndex = 0;
-            nestAfterReleaseCheckBox.Text = "Nest after release";
-            nestAfterReleaseCheckBox.UseVisualStyleBackColor = true;
-            nestAfterReleaseCheckBox.CheckedChanged += NestAfterReleaseCheckBox_CheckedChanged;
-            //
-            // notesLabel
-            //
-            notesLabel.Anchor = System.Windows.Forms.AnchorStyles.Left;
-            notesLabel.AutoSize = true;
-            notesLabel.Margin = new System.Windows.Forms.Padding(12, 0, 3, 0);
-            notesLabel.Name = "notesLabel";
-            notesLabel.TabIndex = 1;
-            notesLabel.Text = "Release notes:";
-            //
-            // notesBox
-            //
-            notesBox.Dock = System.Windows.Forms.DockStyle.Fill;
-            notesBox.MaxLength = 4000;
-            notesBox.Name = "notesBox";
-            notesBox.TabIndex = 2;
-            //
-            // previewTable
-            //
-            previewTable.AutoSize = true;
-            previewTable.ColumnCount = 3;
-            previewTable.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle(System.Windows.Forms.SizeType.Percent, 100F));
-            previewTable.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle());
-            previewTable.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle());
-            previewTable.Controls.Add(previewLabel, 0, 0);
-            previewTable.Controls.Add(includeArchivedCheckBox, 1, 0);
-            previewTable.Controls.Add(optionsButton, 2, 0);
-            previewTable.Dock = System.Windows.Forms.DockStyle.Fill;
-            previewTable.Margin = new System.Windows.Forms.Padding(0, 0, 0, 3);
-            previewTable.Name = "previewTable";
-            previewTable.RowCount = 1;
-            previewTable.RowStyles.Add(new System.Windows.Forms.RowStyle());
-            previewTable.TabIndex = 4;
-            //
-            // previewLabel
-            //
-            previewLabel.AutoSize = true;
-            previewLabel.Dock = System.Windows.Forms.DockStyle.Fill;
-            previewLabel.Margin = new System.Windows.Forms.Padding(3, 6, 3, 6);
-            previewLabel.Name = "previewLabel";
-            previewLabel.TabIndex = 0;
-            //
-            // optionsButton
-            //
-            optionsButton.Anchor = System.Windows.Forms.AnchorStyles.Right;
-            optionsButton.AutoSize = true;
-            optionsButton.Name = "optionsButton";
-            optionsButton.TabIndex = 2;
-            optionsButton.Text = "Options ▸";
-            optionsButton.UseVisualStyleBackColor = true;
-            optionsButton.Click += OptionsButton_Click;
-            //
-            // groupGrid
-            //
-            groupGrid.AllowUserToAddRows = false;
-            groupGrid.AllowUserToDeleteRows = false;
-            groupGrid.ContextMenuStrip = groupMenu;
-            groupGrid.Columns.AddRange(new System.Windows.Forms.DataGridViewColumn[] { includeColumn, materialColumn, gradeColumn, thicknessColumn, unitsColumn, cutTypeColumn, drawingsColumn, partsColumn, targetColumn, statusColumn });
-            groupGrid.Dock = System.Windows.Forms.DockStyle.Fill;
-            groupGrid.EditMode = System.Windows.Forms.DataGridViewEditMode.EditOnEnter;
-            groupGrid.MultiSelect = false;
-            groupGrid.Name = "groupGrid";
-            groupGrid.RowHeadersVisible = false;
-            groupGrid.SelectionMode = System.Windows.Forms.DataGridViewSelectionMode.FullRowSelect;
-            groupGrid.StandardTab = true;
-            groupGrid.TabIndex = 5;
-            groupGrid.CellValueChanged += GroupGrid_CellValueChanged;
-            groupGrid.CurrentCellDirtyStateChanged += GroupGrid_CurrentCellDirtyStateChanged;
-            groupGrid.DataError += GroupGrid_DataError;
-            groupGrid.CellDoubleClick += GroupGrid_CellDoubleClick;
-            groupGrid.CellMouseDown += GroupGrid_CellMouseDown;
-            groupGrid.CurrentCellChanged += GroupGrid_CurrentCellChanged;
-            //
-            // includeColumn
-            //
-            includeColumn.HeaderText = "Release";
-            includeColumn.Name = "includeColumn";
-            includeColumn.Visible = false;
-            includeColumn.Width = 65;
-            //
-            // materialColumn
-            //
-            materialColumn.HeaderText = "Material";
-            materialColumn.Name = "materialColumn";
-            materialColumn.ReadOnly = true;
-            materialColumn.SortMode = System.Windows.Forms.DataGridViewColumnSortMode.NotSortable;
-            materialColumn.Width = 140;
-            //
-            // gradeColumn
-            //
-            gradeColumn.HeaderText = "Grade";
-            gradeColumn.Name = "gradeColumn";
-            gradeColumn.ReadOnly = true;
-            gradeColumn.SortMode = System.Windows.Forms.DataGridViewColumnSortMode.NotSortable;
-            gradeColumn.Width = 90;
-            //
-            // thicknessColumn
-            //
-            rightAligned.Alignment = System.Windows.Forms.DataGridViewContentAlignment.MiddleRight;
-            thicknessColumn.DefaultCellStyle = rightAligned;
-            thicknessColumn.HeaderText = "Thickness";
-            thicknessColumn.Name = "thicknessColumn";
-            thicknessColumn.ReadOnly = true;
-            thicknessColumn.SortMode = System.Windows.Forms.DataGridViewColumnSortMode.NotSortable;
-            thicknessColumn.Width = 80;
-            //
-            // unitsColumn
-            //
-            unitsColumn.HeaderText = "Units";
-            unitsColumn.Name = "unitsColumn";
-            unitsColumn.ReadOnly = true;
-            unitsColumn.SortMode = System.Windows.Forms.DataGridViewColumnSortMode.NotSortable;
-            unitsColumn.Width = 55;
-            //
-            // cutTypeColumn
-            //
-            cutTypeColumn.HeaderText = "Cut type";
-            cutTypeColumn.Name = "cutTypeColumn";
-            cutTypeColumn.ReadOnly = true;
-            cutTypeColumn.SortMode = System.Windows.Forms.DataGridViewColumnSortMode.NotSortable;
-            cutTypeColumn.Width = 75;
-            //
-            // drawingsColumn
-            //
-            drawingsColumn.DefaultCellStyle = rightAligned;
-            drawingsColumn.HeaderText = "Drawings";
-            drawingsColumn.Name = "drawingsColumn";
-            drawingsColumn.ReadOnly = true;
-            drawingsColumn.SortMode = System.Windows.Forms.DataGridViewColumnSortMode.NotSortable;
-            drawingsColumn.Width = 70;
-            //
-            // partsColumn
-            //
-            partsColumn.DefaultCellStyle = rightAligned;
-            partsColumn.HeaderText = "Parts";
-            partsColumn.Name = "partsColumn";
-            partsColumn.ReadOnly = true;
-            partsColumn.SortMode = System.Windows.Forms.DataGridViewColumnSortMode.NotSortable;
-            partsColumn.Width = 65;
-            //
-            // targetColumn
-            //
-            targetColumn.DisplayStyle = System.Windows.Forms.DataGridViewComboBoxDisplayStyle.DropDownButton;
-            targetColumn.FlatStyle = System.Windows.Forms.FlatStyle.Flat;
-            targetColumn.HeaderText = "Nest";
-            targetColumn.Name = "targetColumn";
-            targetColumn.Visible = false;
-            targetColumn.SortMode = System.Windows.Forms.DataGridViewColumnSortMode.NotSortable;
-            targetColumn.ToolTipText = "Make a new Draft nest, or merge into a Draft nest of the same material and renest it.";
-            targetColumn.Width = 260;
-            //
-            // statusColumn
-            //
-            statusColumn.Width = 200;
-            statusColumn.HeaderText = "Status";
-            statusColumn.Name = "statusColumn";
-            statusColumn.ReadOnly = true;
-            statusColumn.SortMode = System.Windows.Forms.DataGridViewColumnSortMode.NotSortable;
-            //
-            // skippedLabel
-            //
-            skippedLabel.AutoSize = true;
-            skippedLabel.ForeColor = System.Drawing.SystemColors.GrayText;
-            skippedLabel.Margin = new System.Windows.Forms.Padding(3, 6, 3, 0);
-            skippedLabel.MaximumSize = new System.Drawing.Size(1080, 0);
-            skippedLabel.Name = "skippedLabel";
-            skippedLabel.TabIndex = 6;
-            skippedLabel.Visible = false;
-            //
-            // bottomTable
-            //
-            bottomTable.AutoSize = true;
-            bottomTable.ColumnCount = 4;
-            bottomTable.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle(System.Windows.Forms.SizeType.Percent, 100F));
-            bottomTable.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle());
-            bottomTable.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle());
-            bottomTable.ColumnStyles.Add(new System.Windows.Forms.ColumnStyle());
-            bottomTable.Controls.Add(summaryLabel, 0, 0);
-            bottomTable.Controls.Add(fixDrawingsButton, 1, 0);
-            bottomTable.Controls.Add(releaseButton, 2, 0);
-            bottomTable.Controls.Add(closeButton, 3, 0);
-            bottomTable.Dock = System.Windows.Forms.DockStyle.Fill;
-            bottomTable.Margin = new System.Windows.Forms.Padding(0, 6, 0, 0);
-            bottomTable.Name = "bottomTable";
-            bottomTable.RowCount = 1;
-            bottomTable.RowStyles.Add(new System.Windows.Forms.RowStyle());
-            bottomTable.TabIndex = 7;
-            //
-            // summaryLabel
-            //
-            summaryLabel.Anchor = System.Windows.Forms.AnchorStyles.Left | System.Windows.Forms.AnchorStyles.Right;
-            summaryLabel.AutoEllipsis = true;
-            summaryLabel.Name = "summaryLabel";
-            summaryLabel.TabIndex = 0;
-            //
-            // fixDrawingsButton
-            //
-            fixDrawingsButton.AutoSize = true;
-            fixDrawingsButton.Enabled = false;
-            fixDrawingsButton.Margin = new System.Windows.Forms.Padding(3, 3, 12, 3);
-            fixDrawingsButton.Name = "fixDrawingsButton";
-            fixDrawingsButton.TabIndex = 1;
-            fixDrawingsButton.Text = "Fix Drawings...";
-            fixDrawingsButton.UseVisualStyleBackColor = true;
-            fixDrawingsButton.Click += FixDrawingsButton_Click;
-            //
-            // releaseButton
-            //
-            releaseButton.AutoSize = true;
-            releaseButton.Enabled = false;
-            releaseButton.Name = "releaseButton";
-            releaseButton.TabIndex = 2;
-            releaseButton.Text = "Make Nests...";
-            releaseButton.UseVisualStyleBackColor = true;
-            releaseButton.Click += ReleaseButton_Click;
+            // releasePanel
+            //
+            releasePanel.Dock = System.Windows.Forms.DockStyle.Fill;
+            releasePanel.Margin = new System.Windows.Forms.Padding(0);
+            releasePanel.Name = "releasePanel";
+            releasePanel.TabIndex = 0;
+            //
+            // buttonPanel
+            //
+            buttonPanel.AutoSize = true;
+            buttonPanel.Controls.Add(closeButton);
+            buttonPanel.Controls.Add(addDrawingsButton);
+            buttonPanel.Dock = System.Windows.Forms.DockStyle.Fill;
+            buttonPanel.FlowDirection = System.Windows.Forms.FlowDirection.RightToLeft;
+            buttonPanel.Margin = new System.Windows.Forms.Padding(0, 6, 0, 0);
+            buttonPanel.Name = "buttonPanel";
+            buttonPanel.TabIndex = 1;
             //
             // closeButton
             //
             closeButton.AutoSize = true;
+            closeButton.DialogResult = System.Windows.Forms.DialogResult.Cancel;
             closeButton.Name = "closeButton";
-            closeButton.TabIndex = 3;
+            closeButton.TabIndex = 1;
             closeButton.Text = "Close";
             closeButton.UseVisualStyleBackColor = true;
-            closeButton.Click += CloseButton_Click;
             //
-            // statusLabel
+            // addDrawingsButton
             //
-            statusLabel.AutoEllipsis = true;
-            statusLabel.Dock = System.Windows.Forms.DockStyle.Fill;
-            statusLabel.Margin = new System.Windows.Forms.Padding(3, 6, 3, 0);
-            statusLabel.Name = "statusLabel";
-            statusLabel.Size = new System.Drawing.Size(100, 20);
-            statusLabel.TabIndex = 8;
-            //
-            // searchTimer
-            //
-            searchTimer.Interval = 250;
-            searchTimer.Tick += SearchTimer_Tick;
-            //
-            // groupMenu
-            //
-            groupMenu.Name = "groupMenu";
-            groupMenu.Opening += GroupMenu_Opening;
+            addDrawingsButton.AutoSize = true;
+            addDrawingsButton.Margin = new System.Windows.Forms.Padding(3, 3, 12, 3);
+            addDrawingsButton.Name = "addDrawingsButton";
+            addDrawingsButton.TabIndex = 0;
+            addDrawingsButton.Text = "Add Drawings...";
+            addDrawingsButton.UseVisualStyleBackColor = true;
+            addDrawingsButton.Click += AddDrawingsButton_Click;
             //
             // ReleaseSetForm
             //
             AutoScaleMode = System.Windows.Forms.AutoScaleMode.None;
-            ClientSize = new System.Drawing.Size(1104, 661);
+            CancelButton = closeButton;
+            ClientSize = new System.Drawing.Size(760, 640);
             Controls.Add(layoutTable);
             Font = new System.Drawing.Font("Segoe UI", 9.75F);
             MinimizeBox = false;
-            MinimumSize = new System.Drawing.Size(860, 520);
+            MinimumSize = new System.Drawing.Size(560, 480);
             Name = "ReleaseSetForm";
             ShowIcon = false;
             ShowInTaskbar = false;
             StartPosition = System.Windows.Forms.FormStartPosition.CenterParent;
-            Text = "Release Drawing Sets and Drawings";
+            Text = "Make Nests";
             FormClosing += ReleaseSetForm_FormClosing;
             layoutTable.ResumeLayout(false);
             layoutTable.PerformLayout();
-            addSetTable.ResumeLayout(false);
-            addSetTable.PerformLayout();
-            ((System.ComponentModel.ISupportInitialize)setGrid).EndInit();
-            optionsTable.ResumeLayout(false);
-            optionsTable.PerformLayout();
-            previewTable.ResumeLayout(false);
-            previewTable.PerformLayout();
-            ((System.ComponentModel.ISupportInitialize)groupGrid).EndInit();
-            bottomTable.ResumeLayout(false);
-            bottomTable.PerformLayout();
+            buttonPanel.ResumeLayout(false);
+            buttonPanel.PerformLayout();
             ResumeLayout(false);
         }
 
         #endregion
 
         private System.Windows.Forms.TableLayoutPanel layoutTable;
-        private System.Windows.Forms.Label setLabel;
-        private System.Windows.Forms.TableLayoutPanel addSetTable;
-        private System.Windows.Forms.Label addSetLabel;
-        private System.Windows.Forms.ComboBox addSetCombo;
-        private System.Windows.Forms.Button addSetButton;
-        private System.Windows.Forms.Button addDrawingsButton;
-        private System.Windows.Forms.Button removeSetButton;
-        private System.Windows.Forms.DataGridView setGrid;
-        private System.Windows.Forms.DataGridViewTextBoxColumn lineTypeColumn;
-        private System.Windows.Forms.DataGridViewTextBoxColumn setNameColumn;
-        private System.Windows.Forms.DataGridViewTextBoxColumn setCustomerColumn;
-        private System.Windows.Forms.DataGridViewTextBoxColumn setRevisionColumn;
-        private System.Windows.Forms.DataGridViewTextBoxColumn kitsColumn;
-        private System.Windows.Forms.TableLayoutPanel optionsTable;
-        private System.Windows.Forms.CheckBox includeArchivedCheckBox;
-        private System.Windows.Forms.CheckBox nestAfterReleaseCheckBox;
-        private System.Windows.Forms.Label notesLabel;
-        private System.Windows.Forms.TextBox notesBox;
-        private System.Windows.Forms.TableLayoutPanel previewTable;
-        private System.Windows.Forms.Label previewLabel;
-        private System.Windows.Forms.Button optionsButton;
-        private System.Windows.Forms.DataGridView groupGrid;
-        private System.Windows.Forms.DataGridViewCheckBoxColumn includeColumn;
-        private System.Windows.Forms.DataGridViewTextBoxColumn materialColumn;
-        private System.Windows.Forms.DataGridViewTextBoxColumn gradeColumn;
-        private System.Windows.Forms.DataGridViewTextBoxColumn thicknessColumn;
-        private System.Windows.Forms.DataGridViewTextBoxColumn unitsColumn;
-        private System.Windows.Forms.DataGridViewTextBoxColumn cutTypeColumn;
-        private System.Windows.Forms.DataGridViewTextBoxColumn drawingsColumn;
-        private System.Windows.Forms.DataGridViewTextBoxColumn partsColumn;
-        private System.Windows.Forms.DataGridViewComboBoxColumn targetColumn;
-        private System.Windows.Forms.DataGridViewTextBoxColumn statusColumn;
-        private System.Windows.Forms.Label skippedLabel;
-        private System.Windows.Forms.Button fixDrawingsButton;
-        private System.Windows.Forms.ContextMenuStrip groupMenu;
-        private System.Windows.Forms.TableLayoutPanel bottomTable;
-        private System.Windows.Forms.Label summaryLabel;
-        private System.Windows.Forms.Button releaseButton;
+        private OpenNest.Controls.ReleasePanel releasePanel;
+        private System.Windows.Forms.FlowLayoutPanel buttonPanel;
         private System.Windows.Forms.Button closeButton;
-        private System.Windows.Forms.Label statusLabel;
-        private System.Windows.Forms.Timer searchTimer;
+        private System.Windows.Forms.Button addDrawingsButton;
     }
 }
diff --git a/OpenNest/Forms/ReleaseSetForm.cs b/OpenNest/Forms/ReleaseSetForm.cs
index 514afb4e..7c1980f5 100644
--- a/OpenNest/Forms/ReleaseSetForm.cs
+++ b/OpenNest/Forms/ReleaseSetForm.cs
@@ -1,124 +1,37 @@
 using System;
 using System.Collections.Generic;
-using System.Globalization;
-using System.IO;
 using System.Linq;
-using System.Net.Http;
-using System.Threading;
-using System.Threading.Tasks;
 using System.Windows.Forms;
 using OpenNest.Controls;
 using OpenNest.Data;
-using OpenNest.Engine.BestFit;
-using OpenNest.Engine.Jobs;
-using OpenNest.IO;
 
 namespace OpenNest.Forms
 {
     /// <summary>
-    /// Drawing Sets &gt; Release: the operator lists the sets to release, typed in or added from
-    /// the browser, each with a number of kits, and library drawings on their own (Add
-    /// Drawings), each with a quantity, and the dialog previews, in a sentence and a grid, how
-    /// they split into one nest per material group (<see cref="SetReleasePlan"/>). Options
-    /// shows an archived-drawing toggle and a tick per group; an option left changed stays
-    /// shown while Options is collapsed. Each group makes a new Draft nest or merges into a
-    /// Draft nest of the same material, whose layout is discarded; the Nest column shows
-    /// whenever such a draft exists. <see cref="SetReleaseSession"/> then builds
-    /// those nests, nests each one with Auto Nest when Nest after release is ticked, saves them,
-    /// opens each in its own tab, and records the release once every chosen nest exists. The
-    /// dialog shows every group's outcome; a release runs once per dialog. A group refused for
-    /// its drawings (no material or thickness, or two with one name) is not a dead end: Fix
-    /// Drawings, a double-click or the group's right-click menu opens Edit Drawing on the
-    /// current library record, and the plan is rebuilt with what was saved.
+    /// <see cref="ReleasePanel"/> in a dialog, for a release started where the Drawing Sets
+    /// window's panel is not at hand: Make Nests in Nest &gt; Add from Drawing Library. Add
+    /// Drawings lists more library drawings on their own (<see cref="AddReleaseDrawingsForm"/>);
+    /// sets are released from the Drawing Sets window. Closing waits for a running release to
+    /// stop between uploads.
     /// </summary>
     public partial class ReleaseSetForm : Form
     {
-        private const string NewNestChoice = "New Draft nest";
-
-        private readonly IDrawingSetStore sets;
-        private readonly IDrawingLibrary library;
-        // Edit Drawing needs a writable library; null hides it.
-        private readonly IDrawingLibraryStore libraryStore;
-        private readonly INestRepository nests;
-        private readonly string serverUrl;
-        private readonly Action<Nest, NestRecord> openNest;
-        private readonly HashSet<string> excluded = new(StringComparer.Ordinal);
-        // The draft each group merges into, by group key, so the choice survives plan rebuilds.
-        private readonly Dictionary<string, NestRecord> targets = new(StringComparer.Ordinal);
-        // The drafts each group could merge into, by group key; absent while still loading.
-        private readonly Dictionary<string, IReadOnlyList<NestRecord>> drafts = new(StringComparer.Ordinal);
-        private SetReleasePlan plan;
-        private SetReleaseSession session;
-        private CancellationTokenSource cancellation;
-        private CancellationTokenSource searchCancellation;
-        private bool populating;
-        private bool running;
-        private bool loadingDrafts;
-        private bool editing;
-        private bool optionsExpanded;
-        private bool archivedShown;
-
-        /// <summary>Shows a message and returns the operator's answer; replaced by tests.</summary>
-        internal Func<string, MessageBoxButtons, MessageBoxIcon, DialogResult> ShowMessage { get; set; }
-
-        /// <summary>Makes the empty nest for a group, as File &gt; New would in its units; replaced by tests.</summary>
-        internal Func<SetReleaseGroup, CancellationToken, Task<Nest>> CreateNest { get; set; }
-
-        /// <summary>
-        /// Nests a group's built nest when Nest after release is ticked: Auto Nest headless with
-        /// the selected engine (<see cref="NestRenest"/>); replaced by tests.
-        /// </summary>
-        internal Func<Nest, CancellationToken, Task<SetReleaseRenest>> Renest { get; set; } = RenestAsync;
-
-        /// <summary>
-        /// True when a server nest is open in a tab of this desktop. Such a draft is not merged
-        /// into: the tab could hold edits the merge would leave behind.
-        /// </summary>
-        public Func<Guid, bool> IsNestOpen { get; set; } = _ => false;
-
-        /// <summary>
-        /// Shows the library browser that adds drawings on their own (<see cref="AddReleaseDrawingsForm"/>);
-        /// replaced by tests.
-        /// </summary>
-        internal Action ShowAddDrawings { get; set; }
-
-        /// <summary>Shows Edit Drawing and returns the saved record, or null; replaced by tests.</summary>
-        internal Func<DrawingLibraryEditSession, DrawingLibraryRecord> EditDrawing { get; set; }
-
-        /// <summary>
-        /// Shows the Release ticks, the Nest column and Include archived drawings; collapsed,
-        /// they show only when they differ from the defaults or a draft could be merged into.
-        /// </summary>
-        internal bool OptionsExpanded
-        {
-            get => optionsExpanded;
-            set
-            {
-                // Hiding a column mid-edit would drop the edit, so it is committed first.
-                if (optionsExpanded == value || !groupGrid.EndEdit())
-                    return;
-                optionsExpanded = value;
-                UpdateOptions(plan == null ? Array.Empty<SetReleaseGroup>() : ChosenGroups(), collapsing: !value);
-            }
-        }
+        internal ReleasePanel Panel => releasePanel;
 
         /// <summary>The finished release, once one has run; otherwise null.</summary>
-        public SetReleaseResult Result { get; private set; }
+        public SetReleaseResult Result => releasePanel.Result;
 
-        /// <param name="set">The first set to release, read with <see cref="IDrawingSetStore.GetAsync"/>, members joined.</param>
-        /// <param name="openNest">Opens a created or merged nest in its own tab, bound to its server record.</param>
-        public ReleaseSetForm(IDrawingSetStore sets, IDrawingLibrary library, INestRepository nests, string serverUrl,
-            DrawingSetRecord set, Action<Nest, NestRecord> openNest)
-            : this(sets, library, nests, serverUrl, new[] { set ?? throw new ArgumentNullException(nameof(set)) },
-                Array.Empty<SetReleaseDrawingLine>(), openNest)
+        /// <summary>True when a server nest is open in a tab of this desktop; such a draft is not merged into.</summary>
+        public Func<Guid, bool> IsNestOpen
         {
+            get => releasePanel.IsNestOpen;
+            set => releasePanel.IsNestOpen = value ?? (_ => false);
         }
 
-        /// <param name="setsToRelease">
-        /// Sets read with <see cref="IDrawingSetStore.GetAsync"/>, members joined, each at one kit.
-        /// With <paramref name="drawings"/> empty too, the dialog starts empty (File &gt; Releases
-        /// &gt; New Release) and the operator adds sets and drawings before releasing.
-        /// </param>
+        /// <summary>Shows the library browser that adds drawings on their own; replaced by tests.</summary>
+        internal Action ShowAddDrawings { get; set; }
+
+        /// <param name="setsToRelease">Sets read with <see cref="IDrawingSetStore.GetAsync"/>, members joined, each at one kit.</param>
         /// <param name="drawings">Library drawings to release on their own, each with its quantity.</param>
         /// <param name="openNest">Opens a created or merged nest in its own tab, bound to its server record.</param>
         public ReleaseSetForm(IDrawingSetStore sets, IDrawingLibrary library, INestRepository nests, string serverUrl,
@@ -126,1016 +39,33 @@ namespace OpenNest.Forms
             Action<Nest, NestRecord> openNest)
         {
             InitializeComponent();
-            this.sets = sets ?? throw new ArgumentNullException(nameof(sets));
-            this.library = library ?? throw new ArgumentNullException(nameof(library));
-            libraryStore = library as IDrawingLibraryStore;
-            this.nests = nests ?? throw new ArgumentNullException(nameof(nests));
-            this.serverUrl = serverUrl ?? "";
-            this.openNest = openNest ?? throw new ArgumentNullException(nameof(openNest));
             ArgumentNullException.ThrowIfNull(setsToRelease);
             ArgumentNullException.ThrowIfNull(drawings);
-            ShowMessage = (text, buttons, icon) => MessageBox.Show(this, text, Text, buttons, icon);
-            CreateNest = (group, _) => NewNestFactory.CreateAsync(this, group.Units);
+            releasePanel.Initialize(sets, library, nests, serverUrl, openNest);
+            foreach (var set in setsToRelease)
+                releasePanel.AddSet(set);
+            foreach (var line in drawings)
+                releasePanel.AddDrawings(new[] { line.Drawing }, line.Quantity);
             ShowAddDrawings = () =>
             {
-                using var form = new AddReleaseDrawingsForm(library, this.serverUrl, AddDrawingLines,
-                    id => DrawingLines().Any(l => l.Drawing.Id == id));
+                using var form = new AddReleaseDrawingsForm(library, serverUrl ?? "", releasePanel.AddDrawings,
+                    id => releasePanel.DrawingLines().Any(l => l.Drawing.Id == id));
                 form.ShowDialog(this);
             };
-            EditDrawing = edit =>
-            {
-                using var form = new EditLibraryDrawingForm(edit);
-                return form.ShowDialog(this) == DialogResult.OK ? form.Saved : null;
-            };
-            fixDrawingsButton.Visible = libraryStore != null;
-
-            GridStyle.Apply(setGrid);
-            GridStyle.Apply(groupGrid);
-            // A refusal or outcome wraps rather than being cut off.
-            groupGrid.RowTemplate.MinimumHeight = groupGrid.RowTemplate.Height;
-            groupGrid.AutoSizeRowsMode = DataGridViewAutoSizeRowsMode.AllCells;
-            statusColumn.DefaultCellStyle.WrapMode = DataGridViewTriState.True;
-            populating = true;
-            foreach (var set in setsToRelease)
-                AddRow(set, set.Name, set.Customer, set.Revision, 1);
-            foreach (var line in drawings)
-                AddRow(line.Drawing, line.Drawing.Name, line.Drawing.Customer, line.Drawing.Revision, line.Quantity);
-            populating = false;
-            BuildPlan();
-            // The first sets by name are listed before anything is typed, so the arrow shows them.
-            Shown += async (_, _) => await SearchSetsAsync("", dropDown: false);
-        }
-
-        /// <summary>The sets listed, in order, with their kits.</summary>
-        internal IReadOnlyList<SetReleasePlanLine> Lines() =>
-            setGrid.Rows.Cast<DataGridViewRow>()
-                .Where(r => r.Tag is DrawingSetRecord)
-                .Select(r => new SetReleasePlanLine((DrawingSetRecord)r.Tag, Kits(r)))
-                .ToList();
-
-        /// <summary>The drawings listed on their own, in order, with their quantities.</summary>
-        internal IReadOnlyList<SetReleaseDrawingLine> DrawingLines() =>
-            setGrid.Rows.Cast<DataGridViewRow>()
-                .Where(r => r.Tag is DrawingLibraryRecord)
-                .Select(r => new SetReleaseDrawingLine((DrawingLibraryRecord)r.Tag, Kits(r)))
-                .ToList();
-
-        /// <summary>
-        /// Adds a set read from the server (members joined) with <paramref name="kits"/>; false,
-        /// with the reason shown, when it is archived or already listed.
-        /// </summary>
-        internal bool AddLine(DrawingSetRecord set, int kits)
-        {
-            ArgumentNullException.ThrowIfNull(set);
-            var listed = setGrid.Rows.Cast<DataGridViewRow>().FirstOrDefault(r => r.Tag is DrawingSetRecord s && s.Id == set.Id);
-            if (listed != null)
-            {
-                listed.Selected = true;
-                statusLabel.Text = $"'{set.Name}' is already listed. Change its quantity instead.";
-                return false;
-            }
-            if (set.Archived)
-            {
-                statusLabel.Text = $"'{set.Name}' is archived. Restore it before releasing it.";
-                return false;
-            }
-
-            AddRow(set, set.Name, set.Customer, set.Revision, kits);
-            statusLabel.Text = "";
-            BuildPlan();
-            return true;
-        }
-
-        /// <summary>
-        /// Adds library drawings on their own at <paramref name="quantity"/> each, skipping (and
-        /// naming) those already listed or archived, and returns what happened for the operator.
-        /// </summary>
-        internal string AddDrawingLines(IReadOnlyList<DrawingLibraryRecord> drawings, int quantity)
-        {
-            ArgumentNullException.ThrowIfNull(drawings);
-            if (running || Result != null)
-                return "The release has run; nothing can be added.";
-            var listed = DrawingLines().Select(l => l.Drawing.Id).ToHashSet();
-            var added = new List<DrawingLibraryRecord>();
-            var already = new List<DrawingLibraryRecord>();
-            var archived = new List<DrawingLibraryRecord>();
-            foreach (var drawing in drawings)
-            {
-                if (drawing.Archived)
-                    archived.Add(drawing);
-                else if (!listed.Add(drawing.Id))
-                    already.Add(drawing);
-                else if (listed.Count > SetReleaseRules.MaxDrawingLines)
-                {
-                    listed.Remove(drawing.Id);
-                    break;
-                }
-                else
-                    added.Add(drawing);
-            }
-
-            foreach (var drawing in added)
-                AddRow(drawing, drawing.Name, drawing.Customer, drawing.Revision, quantity);
-            if (added.Count > 0)
-                BuildPlan();
-
-            var text = added.Count switch
-            {
-                0 => "Nothing added.",
-                1 => $"Added '{added[0].Name}'.",
-                _ => $"Added {added.Count} drawings.",
-            };
-            if (already.Count > 0)
-                text += $" Already listed (change the quantity there): {Names(already)}.";
-            if (archived.Count > 0)
-                text += $" Archived, restore before releasing: {Names(archived)}.";
-            if (added.Count + already.Count + archived.Count < drawings.Count)
-                text += $" A release may list at most {SetReleaseRules.MaxDrawingLines} drawings on their own.";
-            statusLabel.Text = text;
-            return text;
-        }
-
-        private static string Names(IEnumerable<DrawingLibraryRecord> drawings) =>
-            string.Join(", ", drawings.Select(d => $"'{d.Name}'"));
-
-        private void AddRow(object tag, string name, string customer, int revision, int quantity)
-        {
-            var row = new DataGridViewRow { Tag = tag };
-            row.CreateCells(setGrid, tag is DrawingSetRecord ? "Set" : "Drawing", name, customer, revision,
-                quantity.ToString(CultureInfo.CurrentCulture));
-            setGrid.Rows.Add(row);
+            Load += (_, _) => DialogBounds.FitToOwnerScreen(this);
         }
 
         private void AddDrawingsButton_Click(object sender, EventArgs e)
         {
-            if (!running && Result == null && setGrid.EndEdit())
+            if (!releasePanel.IsRunning)
                 ShowAddDrawings();
         }
 
-        private static int Kits(DataGridViewRow row) =>
-            int.TryParse(Convert.ToString(row.Cells["kitsColumn"].Value, CultureInfo.CurrentCulture), NumberStyles.Integer,
-                CultureInfo.CurrentCulture, out var kits) ? kits : 1;
-
-        private void OptionsButton_Click(object sender, EventArgs e) => OptionsExpanded = !OptionsExpanded;
-
-        private void Options_Changed(object sender, EventArgs e)
-        {
-            if (!running && Result == null)
-                BuildPlan();
-        }
-
-        // The merge notes say what happens to a draft's layout, which this choice changes.
-        private void NestAfterReleaseCheckBox_CheckedChanged(object sender, EventArgs e)
-        {
-            if (running || Result != null)
-                return;
-            populating = true;
-            foreach (DataGridViewRow row in groupGrid.Rows)
-            {
-                if (row.Tag is SetReleaseGroup group)
-                    row.Cells[statusColumn.Index].Value = GroupNote(group);
-            }
-            populating = false;
-        }
-
-        private void SetGrid_CellValidating(object sender, DataGridViewCellValidatingEventArgs e)
-        {
-            if (e.ColumnIndex != kitsColumn.Index)
-                return;
-            var drawing = setGrid.Rows[e.RowIndex].Tag is DrawingLibraryRecord;
-            var maximum = drawing ? SetReleaseRules.MaxDrawingQuantity : SetReleaseRules.MaxQuantity;
-            var valid = int.TryParse(Convert.ToString(e.FormattedValue, CultureInfo.CurrentCulture), NumberStyles.Integer,
-                CultureInfo.CurrentCulture, out var kits) && kits >= 1 && kits <= maximum;
-            setGrid.Rows[e.RowIndex].ErrorText = valid ? ""
-                : $"Enter a whole number from 1 to {maximum:N0}.";
-            e.Cancel = !valid;
-        }
-
-        private void SetGrid_CellValueChanged(object sender, DataGridViewCellEventArgs e)
-        {
-            if (e.RowIndex >= 0 && e.ColumnIndex == kitsColumn.Index && !running && Result == null && !populating)
-                BuildPlan();
-        }
-
-        private void SetGrid_SelectionChanged(object sender, EventArgs e) => UpdateCommands();
-
-        private void RemoveSetButton_Click(object sender, EventArgs e)
-        {
-            if (setGrid.Rows.Count < 2 || setGrid.CurrentRow == null)
-                return;
-            setGrid.Rows.Remove(setGrid.CurrentRow);
-            BuildPlan();
-        }
-
-        // Opening the empty list reads the first sets when the initial read failed or found none yet.
-        private async void AddSetCombo_DropDown(object sender, EventArgs e)
-        {
-            if (addSetCombo.Items.Count == 0 && string.IsNullOrEmpty(addSetCombo.Text) && addSetCombo.Enabled)
-                await SearchSetsAsync("", dropDown: false);
-        }
-
-        // Type-ahead: the set list is queried once typing pauses.
-        private void AddSetCombo_TextUpdate(object sender, EventArgs e)
-        {
-            searchTimer.Stop();
-            searchTimer.Start();
-        }
-
-        private async void SearchTimer_Tick(object sender, EventArgs e)
-        {
-            searchTimer.Stop();
-            await SearchSetsAsync(addSetCombo.Text);
-        }
-
-        private async void AddSetCombo_KeyDown(object sender, KeyEventArgs e)
-        {
-            if (e.KeyCode != Keys.Enter)
-                return;
-            e.Handled = e.SuppressKeyPress = true;
-            await AddTypedSetAsync();
-        }
-
-        private async void AddSetButton_Click(object sender, EventArgs e) => await AddTypedSetAsync();
-
-        /// <summary>
-        /// Lists the first active sets by name whose name, customer or notes contain
-        /// <paramref name="text"/> (all of them for an empty text); <paramref name="dropDown"/>
-        /// opens the list when the box has focus, as typing does.
-        /// </summary>
-        internal async Task SearchSetsAsync(string text, bool dropDown = true)
-        {
-            searchCancellation?.Cancel();
-            searchCancellation?.Dispose();
-            searchCancellation = new CancellationTokenSource();
-            var token = searchCancellation.Token;
-            DrawingSetPage page;
-            try
-            {
-                page = await sets.QueryAsync(new DrawingSetQuery { Search = text ?? "", Limit = 20, Sort = DrawingSetSortField.Name, Descending = false }, token);
-            }
-            catch (OperationCanceledException) when (token.IsCancellationRequested)
-            {
-                return;
-            }
-            catch (Exception ex) when (ex is IOException or HttpRequestException or TaskCanceledException or System.Text.Json.JsonException)
-            {
-                if (!IsDisposed)
-                    statusLabel.Text = $"Could not search the sets: {ex.Message}";
-                return;
-            }
-
-            if (IsDisposed || token.IsCancellationRequested)
-                return;
-            // Refilling the list resets the text, so the operator's typing is put back.
-            var typed = addSetCombo.Text;
-            var caret = addSetCombo.SelectionStart;
-            addSetCombo.BeginUpdate();
-            addSetCombo.Items.Clear();
-            foreach (var found in page.Items)
-                addSetCombo.Items.Add(new SetChoice(found));
-            addSetCombo.EndUpdate();
-            addSetCombo.Text = typed;
-            addSetCombo.SelectionStart = System.Math.Min(caret, typed.Length);
-            if (dropDown && addSetCombo.Focused && page.Items.Count > 0)
-                addSetCombo.DroppedDown = true;
-        }
-
-        /// <summary>
-        /// Adds the set picked in the list, or the one active set whose name is exactly what was
-        /// typed, read with its members.
-        /// </summary>
-        internal async Task AddTypedSetAsync()
-        {
-            if (running || Result != null)
-                return;
-            var typed = (addSetCombo.Text ?? "").Trim();
-            try
-            {
-                Guid id;
-                if (addSetCombo.SelectedItem is SetChoice choice && choice.ToString() == addSetCombo.Text)
-                {
-                    id = choice.Set.Id;
-                }
-                else
-                {
-                    if (typed.Length == 0)
-                        return;
-                    var page = await sets.QueryAsync(new DrawingSetQuery { Search = typed, Limit = 50 });
-                    var exact = page.Items.Where(s => string.Equals(s.Name.Trim(), typed, StringComparison.OrdinalIgnoreCase)).ToList();
-                    if (exact.Count != 1)
-                    {
-                        statusLabel.Text = exact.Count == 0
-                            ? $"No active set is named '{typed}'. Pick one from the list."
-                            : $"{exact.Count} sets are named '{typed}'. Pick one from the list.";
-                        return;
-                    }
-                    id = exact[0].Id;
-                }
-
-                var read = await sets.GetAsync(id);
-                if (IsDisposed)
-                    return;
-                if (read == null)
-                {
-                    statusLabel.Text = "That set no longer exists on the server.";
-                    return;
-                }
-                if (AddLine(read, 1))
-                    addSetCombo.Text = "";
-            }
-            catch (Exception ex) when (ex is IOException or HttpRequestException or TaskCanceledException or System.Text.Json.JsonException)
-            {
-                if (!IsDisposed)
-                    statusLabel.Text = $"Could not read the set: {ex.Message}";
-            }
-        }
-
-        // Commit a checkbox click or a target choice at once so the summary follows it.
-        private void GroupGrid_CurrentCellDirtyStateChanged(object sender, EventArgs e)
-        {
-            if (groupGrid.IsCurrentCellDirty
-                && (groupGrid.CurrentCell?.OwningColumn == includeColumn || groupGrid.CurrentCell?.OwningColumn == targetColumn))
-                groupGrid.CommitEdit(DataGridViewDataErrorContexts.Commit);
-        }
-
-        private void GroupGrid_CellValueChanged(object sender, DataGridViewCellEventArgs e)
-        {
-            if (populating || e.RowIndex < 0)
-                return;
-            var row = groupGrid.Rows[e.RowIndex];
-            if (row.Tag is not SetReleaseGroup group)
-                return;
-            if (e.ColumnIndex == includeColumn.Index)
-            {
-                if (row.Cells[includeColumn.Index].Value is true)
-                    excluded.Remove(group.Key);
-                else
-                    excluded.Add(group.Key);
-            }
-            else if (e.ColumnIndex == targetColumn.Index)
-            {
-                ChooseTarget(row, group, row.Cells[targetColumn.Index].Value as string);
-            }
-            UpdateCommands();
-        }
-
-        // A combo value that is not in a rebuilt list is reset rather than reported.
-        private void GroupGrid_DataError(object sender, DataGridViewDataErrorEventArgs e) => e.ThrowException = false;
-
-        /// <summary>Makes <paramref name="group"/> merge into the draft named by <paramref name="choice"/>, or a new nest.</summary>
-        internal void ChooseTarget(DataGridViewRow row, SetReleaseGroup group, string choice)
-        {
-            var draft = drafts.TryGetValue(group.Key, out var candidates)
-                ? candidates.FirstOrDefault(d => DraftChoice(d) == choice)
-                : null;
-            if (draft != null && IsNestOpen(draft.Id))
-            {
-                ShowMessage($"'{draft.Name}' is open in a tab here. Close it first, so no edits there are left behind by the merge.",
-                    MessageBoxButtons.OK, MessageBoxIcon.Information);
-                draft = null;
-            }
-
-            if (draft == null)
-                targets.Remove(group.Key);
-            else
-                targets[group.Key] = draft;
-            populating = true;
-            row.Cells[targetColumn.Index].Value = draft == null ? NewNestChoice : DraftChoice(draft);
-            row.Cells[statusColumn.Index].Value = GroupNote(group);
-            populating = false;
-        }
-
-        private void GroupGrid_CurrentCellChanged(object sender, EventArgs e) => UpdateCommands();
-
-        // A right-click selects the row under the pointer, so the menu acts on what was clicked.
-        private void GroupGrid_CellMouseDown(object sender, DataGridViewCellMouseEventArgs e)
-        {
-            if (e.Button == MouseButtons.Right && e.RowIndex >= 0 && groupGrid.CurrentRow?.Index != e.RowIndex)
-                groupGrid.CurrentCell = groupGrid.Rows[e.RowIndex].Cells[materialColumn.Index];
-        }
-
-        private async void GroupGrid_CellDoubleClick(object sender, DataGridViewCellEventArgs e)
-        {
-            if (e.RowIndex >= 0 && groupGrid.Rows[e.RowIndex].Tag is SetReleaseGroup { CanRelease: false })
-                await FixSelectedGroupAsync();
-        }
-
-        private async void FixDrawingsButton_Click(object sender, EventArgs e) => await FixSelectedGroupAsync();
-
-        // One Edit Drawing item per drawing of the group, the ones it is refused for first.
-        private void GroupMenu_Opening(object sender, System.ComponentModel.CancelEventArgs e)
-        {
-            groupMenu.Items.Clear();
-            if (libraryStore == null || groupGrid.CurrentRow?.Tag is not SetReleaseGroup group)
-            {
-                e.Cancel = true;
-                return;
-            }
-
-            const int listed = 15;
-            var items = group.RefusedItems.Concat(group.Items.Where(i => !group.RefusedItems.Contains(i))).ToList();
-            var enabled = CanEditDrawings();
-            foreach (var item in items.Take(listed))
-            {
-                var menuItem = new ToolStripMenuItem($"Edit Drawing '{item.Drawing.Name}'...") { Enabled = enabled };
-                menuItem.Click += async (_, _) => await EditItemDrawingAsync(item);
-                groupMenu.Items.Add(menuItem);
-            }
-            if (items.Count > listed)
-            {
-                groupMenu.Items.Add(new ToolStripMenuItem(
-                    $"...and {items.Count - listed} more: edit them in the set or the Drawing Library")
-                { Enabled = false });
-            }
-        }
-
-        // The selected refused group, else the first one.
-        private DataGridViewRow RefusedRow() =>
-            groupGrid.CurrentRow?.Tag is SetReleaseGroup { CanRelease: false } ? groupGrid.CurrentRow
-                : groupGrid.Rows.Cast<DataGridViewRow>().FirstOrDefault(r => r.Tag is SetReleaseGroup { CanRelease: false });
-
-        private bool CanEditDrawings() => libraryStore != null && !running && !editing && Result == null;
-
-        /// <summary>
-        /// Opens Edit Drawing, one after another, on each drawing the selected group is refused
-        /// for, or the first refused group's when a releasable one is selected; cancelling one
-        /// stops. The plan is rebuilt after each save.
-        /// </summary>
-        internal async Task FixSelectedGroupAsync()
-        {
-            if (!CanEditDrawings() || RefusedRow() is not { Tag: SetReleaseGroup group } row)
-                return;
-            if (groupGrid.CurrentRow != row)
-                groupGrid.CurrentCell = row.Cells[materialColumn.Index];
-            foreach (var item in group.RefusedItems.ToList())
-            {
-                if (!await EditItemDrawingAsync(item) || IsDisposed)
-                    return;
-            }
-        }
-
-        /// <summary>
-        /// Reads the item's current library record and opens Edit Drawing on it; true when it
-        /// was saved. What was read or saved replaces the drawing in the plan.
-        /// </summary>
-        internal async Task<bool> EditItemDrawingAsync(SetReleaseItem item)
-        {
-            ArgumentNullException.ThrowIfNull(item);
-            if (!CanEditDrawings())
-                return false;
-
-            var name = item.Drawing.Name;
-            DrawingLibraryRecord current;
-            editing = true;
-            UpdateCommands();
-            statusLabel.Text = $"Reading '{name}'...";
-            try
-            {
-                current = await libraryStore.GetAsync(item.Drawing.Id);
-            }
-            catch (Exception ex) when (ex is IOException || ex is HttpRequestException || ex is TaskCanceledException)
-            {
-                if (!IsDisposed)
-                {
-                    statusLabel.Text = "";
-                    ShowMessage($"Could not read '{name}': {ex.Message}", MessageBoxButtons.OK, MessageBoxIcon.Warning);
-                }
-                return false;
-            }
-            finally
-            {
-                editing = false;
-                if (!IsDisposed)
-                    UpdateCommands();
-            }
-
-            if (IsDisposed)
-                return false;
-            statusLabel.Text = "";
-            if (current == null)
-            {
-                ShowMessage($"'{name}' is no longer in the library.", MessageBoxButtons.OK, MessageBoxIcon.Warning);
-                return false;
-            }
-            if (current.Archived)
-            {
-                ShowMessage($"'{current.Name}' is archived in the library. Restore it there before editing it.",
-                    MessageBoxButtons.OK, MessageBoxIcon.Information);
-                return false;
-            }
-
-            var saved = EditDrawing(new DrawingLibraryEditSession(libraryStore, current, Environment.UserName));
-            if (IsDisposed)
-                return false;
-            ApplyDrawing(saved ?? current);
-            if (saved == null)
-                return false;
-            statusLabel.Text = $"Saved '{saved.Name}' revision {saved.Revision} to the library.";
-            return true;
-        }
-
-        /// <summary>
-        /// Shows a newer library record of a listed drawing, in the sets that list it (their
-        /// joined members) and on its own line, and rebuilds the plan. Sets list drawings by id,
-        /// so the release takes the drawing as it now is.
-        /// </summary>
-        internal void ApplyDrawing(DrawingLibraryRecord drawing)
-        {
-            ArgumentNullException.ThrowIfNull(drawing);
-            var changed = false;
-            foreach (DataGridViewRow row in setGrid.Rows)
-            {
-                if (row.Tag is DrawingSetRecord set)
-                {
-                    foreach (var member in set.Members ?? new List<DrawingSetMember>())
-                    {
-                        if (member.DrawingId == drawing.Id && (member.Drawing == null || member.Drawing.Revision < drawing.Revision))
-                        {
-                            member.Drawing = drawing;
-                            changed = true;
-                        }
-                    }
-                }
-                else if (row.Tag is DrawingLibraryRecord listed && listed.Id == drawing.Id && listed.Revision < drawing.Revision)
-                {
-                    row.Tag = drawing;
-                    row.Cells[setNameColumn.Index].Value = drawing.Name;
-                    row.Cells[setCustomerColumn.Index].Value = drawing.Customer;
-                    row.Cells[setRevisionColumn.Index].Value = drawing.Revision;
-                    changed = true;
-                }
-            }
-
-            if (changed)
-                BuildPlan();
-        }
-
-        private async void ReleaseButton_Click(object sender, EventArgs e)
-        {
-            if (Result is { Release: null, ReleaseError.Length: > 0 })
-                await RetryRecordAsync();
-            else
-                await ReleaseAsync();
-        }
-
-        private void CloseButton_Click(object sender, EventArgs e)
-        {
-            if (running)
-            {
-                cancellation?.Cancel();
-                statusLabel.Text = "Stopping after the nest being saved...";
-                closeButton.Enabled = false;
-                return;
-            }
-
-            Close();
-        }
-
         private void ReleaseSetForm_FormClosing(object sender, FormClosingEventArgs e)
         {
             // Nests may be on their way to the server; stop between uploads, never mid-way.
-            if (!running)
-                return;
-            e.Cancel = true;
-            CloseButton_Click(sender, e);
-        }
-
-        /// <summary>The groups ticked for release, in plan order.</summary>
-        internal IReadOnlyList<SetReleaseGroup> ChosenGroups() =>
-            plan.Groups.Where(g => g.CanRelease && !excluded.Contains(g.Key)).ToList();
-
-        /// <summary>The chosen groups that merge into a draft, with that draft.</summary>
-        internal IReadOnlyDictionary<SetReleaseGroup, NestRecord> ChosenMerges() =>
-            ChosenGroups().Where(g => targets.ContainsKey(g.Key)).ToDictionary(g => g, g => targets[g.Key]);
-
-        /// <summary>
-        /// Confirms, then makes or merges one Draft nest per ticked group, opens each in its own
-        /// tab and records the release. Every group's outcome is shown in the grid.
-        /// </summary>
-        internal async Task ReleaseAsync()
-        {
-            if (running || Result != null || !setGrid.EndEdit() || !groupGrid.EndEdit())
-                return;
-            var chosen = ChosenGroups();
-            if (chosen.Count == 0)
-                return;
-            var merges = ChosenMerges();
-            if (merges.Values.FirstOrDefault(d => IsNestOpen(d.Id)) is { } open)
-            {
-                ShowMessage($"'{open.Name}' is open in a tab here. Close it, or choose a new nest for its group.",
-                    MessageBoxButtons.OK, MessageBoxIcon.Information);
-                return;
-            }
-
-            var created = chosen.Count - merges.Count;
-            var text = $"Make {chosen.Count} Draft nest{(chosen.Count == 1 ? "" : "s")} from {DescribeLines()}?";
-            var nestAfter = nestAfterReleaseCheckBox.Checked;
-            if (merges.Count > 0)
-                text += $" {created} new, {merges.Count} merged into existing drafts. A merged draft's layout is "
-                    + (nestAfter ? "replaced" : "cleared for Auto Nest")
-                    + "; Undo Release restores it.";
-            text += nestAfter ? " Each is nested with Auto Nest and opens in a tab." : " Each opens in a tab.";
-            if (ShowMessage(text, MessageBoxButtons.OKCancel, MessageBoxIcon.Question) != DialogResult.OK)
-                return;
-
-            running = true;
-            cancellation = new CancellationTokenSource();
-            closeButton.Text = "Cancel";
-            UpdateCommands();
-            session = new SetReleaseSession(sets, library, nests, serverUrl, ReadPackage, WriteNest, CreateNest, ReadNest,
-                nestAfter ? Renest : null);
-            var progress = new Progress<SetReleaseProgress>(ShowProgress);
-            try
-            {
-                Result = await session.RunAsync(plan, chosen, Environment.UserName, notesBox.Text, progress, cancellation.Token, merges);
-            }
-            finally
-            {
-                running = false;
-                if (!IsDisposed)
-                {
-                    closeButton.Text = "Close";
-                    closeButton.Enabled = true;
-                }
-            }
-
-            foreach (var done in Result.Created)
-                openNest(done.Nest, done.Record);
-            if (IsDisposed)
-                return;
-            ShowOutcome();
-        }
-
-        /// <summary>Posts the release again after every nest was saved but recording it failed.</summary>
-        internal async Task RetryRecordAsync()
-        {
-            if (running || session == null || !session.HasPendingRelease)
-                return;
-            running = true;
-            UpdateCommands();
-            statusLabel.Text = "Recording the release...";
-            try
-            {
-                var release = await session.RetryReleaseAsync();
-                Result = Result.WithRelease(release);
-            }
-            catch (Exception ex) when (ex is IOException || ex is HttpRequestException
-                || ex is TaskCanceledException || ex is System.Text.Json.JsonException)
-            {
-                if (!IsDisposed)
-                    ShowMessage($"The release is still not recorded: {ex.Message}", MessageBoxButtons.OK, MessageBoxIcon.Warning);
-            }
-            finally
-            {
-                running = false;
-            }
-
-            if (!IsDisposed)
-                ShowOutcome();
-        }
-
-        private void BuildPlan()
-        {
-            plan = SetReleasePlan.Build(Lines(), DrawingLines(), includeArchivedCheckBox.Checked);
-            Text = (plan.Lines.Count + plan.Drawings.Count) switch
-            {
-                0 => "New Release",
-                1 => $"Release '{(plan.Lines.Count == 1 ? plan.Lines[0].Set.Name : plan.Drawings[0].Drawing.Name)}'",
-                _ => $"Release {DescribeLines()}",
-            };
-            setLabel.Text = Heading();
-            populating = true;
-            groupGrid.Rows.Clear();
-            foreach (var group in plan.Groups)
-            {
-                var row = new DataGridViewRow { Tag = group };
-                row.CreateCells(groupGrid,
-                    group.CanRelease && !excluded.Contains(group.Key),
-                    group.IsUnassigned ? "(none)" : group.MaterialName,
-                    group.MaterialGrade,
-                    group.IsUnassigned ? "" : group.Thickness.ToString("0.####", CultureInfo.CurrentCulture),
-                    group.IsUnassigned ? "" : UnitsHelper.GetShortString(group.Units),
-                    group.IsUnassigned ? "" : group.CutType.ToString(),
-                    group.Items.Count,
-                    group.TotalQuantity,
-                    null,
-                    GroupNote(group));
-                // A refused group cannot be ticked.
-                row.Cells[includeColumn.Index].ReadOnly = !group.CanRelease;
-                groupGrid.Rows.Add(row);
-                FillTargets(row, group);
-            }
-            populating = false;
-
-            var skipped = plan.SkippedArchived;
-            skippedLabel.Visible = skipped.Count > 0;
-            skippedLabel.Text = skipped.Count == 0 ? "" :
-                $"{skipped.Count} archived drawing{(skipped.Count == 1 ? " is" : "s are")} left out: "
-                + string.Join(", ", skipped.Take(5).Select(m => $"'{m.Drawing!.Name}'"))
-                + (skipped.Count > 5 ? $" and {skipped.Count - 5} more" : "")
-                + ". Tick Include archived drawings (under Options) to add them.";
-            UpdateCommands();
-            _ = LoadDraftsAsync();
-        }
-
-        // "Release set 'Kit A' ×2", "Release 'Kit A' ×2, 'Kit B' ×1 and 'SYN-A' ×4".
-        private string Heading()
-        {
-            if (plan.Lines.Count + plan.Drawings.Count == 1)
-                return plan.Lines.Count == 1
-                    ? $"Release set '{plan.Lines[0].Set.Name}' ×{plan.Lines[0].Quantity}"
-                    : $"Release drawing '{plan.Drawings[0].Drawing.Name}' ×{plan.Drawings[0].Quantity}";
-            const int named = 3;
-            var lines = plan.Lines.Select(l => $"'{l.Set.Name}' ×{l.Quantity}")
-                .Concat(plan.Drawings.Select(d => $"'{d.Drawing.Name}' ×{d.Quantity}"))
-                .ToList();
-            if (lines.Count == 0)
-                return "Add a set or drawings to release";
-            if (lines.Count <= named + 1)
-                return $"Release {string.Join(", ", lines.Take(lines.Count - 1))} and {lines[^1]}";
-            return $"Release {string.Join(", ", lines.Take(named))} and {lines.Count - named} more";
-        }
-
-        // "set 'Kit A' ×2", "3 sets and 2 drawings", "drawing 'SYN-A' ×4".
-        private string DescribeLines()
-        {
-            var parts = new List<string>();
-            if (plan.Lines.Count == 1)
-                parts.Add($"set '{plan.Lines[0].Set.Name}'" + (plan.Lines[0].Quantity == 1 ? "" : $" ×{plan.Lines[0].Quantity}"));
-            else if (plan.Lines.Count > 1)
-                parts.Add($"{plan.Lines.Count} sets");
-            if (plan.Drawings.Count == 1)
-                parts.Add($"drawing '{plan.Drawings[0].Drawing.Name}' ×{plan.Drawings[0].Quantity}");
-            else if (plan.Drawings.Count > 1)
-                parts.Add($"{plan.Drawings.Count} drawings");
-            return string.Join(" and ", parts);
-        }
-
-        // The target list of one group: a new nest, then each draft it could merge into.
-        private void FillTargets(DataGridViewRow row, SetReleaseGroup group)
-        {
-            var cell = (DataGridViewComboBoxCell)row.Cells[targetColumn.Index];
-            cell.Items.Clear();
-            cell.Items.Add(NewNestChoice);
-            if (group.CanRelease && drafts.TryGetValue(group.Key, out var candidates))
-            {
-                foreach (var draft in candidates)
-                    cell.Items.Add(DraftChoice(draft));
-            }
-            if (targets.TryGetValue(group.Key, out var target) && !cell.Items.Contains(DraftChoice(target)))
-                targets.Remove(group.Key);
-            cell.Value = targets.TryGetValue(group.Key, out target) ? DraftChoice(target) : NewNestChoice;
-            cell.ReadOnly = !group.CanRelease;
-        }
-
-        /// <summary>Looks up, once per group, the Draft nests it could merge into, then fills the lists.</summary>
-        internal async Task LoadDraftsAsync()
-        {
-            if (loadingDrafts || plan == null)
-                return;
-            loadingDrafts = true;
-            try
-            {
-                while (plan.Groups.FirstOrDefault(g => g.CanRelease && !drafts.ContainsKey(g.Key)) is { } group)
-                {
-                    try
-                    {
-                        drafts[group.Key] = await SetReleasePlan.FindDraftsAsync(nests, group);
-                    }
-                    catch (Exception ex) when (ex is IOException or HttpRequestException or TaskCanceledException
-                        or System.Text.Json.JsonException or NotSupportedException)
-                    {
-                        drafts[group.Key] = Array.Empty<NestRecord>();
-                        if (!IsDisposed)
-                            statusLabel.Text = $"Could not list the draft nests to merge into: {ex.Message}";
-                    }
-                    if (IsDisposed)
-                        return;
-                }
-            }
-            finally
-            {
-                loadingDrafts = false;
-            }
-
-            if (IsDisposed || running || Result != null)
-                return;
-            populating = true;
-            foreach (DataGridViewRow row in groupGrid.Rows)
-            {
-                if (row.Tag is SetReleaseGroup group)
-                    FillTargets(row, group);
-            }
-            populating = false;
-            UpdateCommands();
-        }
-
-        // A releasable group has a draft it could merge into.
-        private bool CanMerge() =>
-            plan.Groups.Any(g => g.CanRelease && drafts.TryGetValue(g.Key, out var candidates) && candidates.Count > 0);
-
-        private string GroupNote(SetReleaseGroup group)
-        {
-            if (!group.CanRelease)
-                return group.Refusal;
-            var notes = group.Warnings.ToList();
-            if (targets.TryGetValue(group.Key, out var draft))
-                notes.Insert(0, $"Replaces the layout of '{draft.Name}' ({draft.PlateCount} sheet"
-                    + $"{(draft.PlateCount == 1 ? "" : "s")}) "
-                    + (nestAfterReleaseCheckBox.Checked ? "and nests again" : "and leaves it for Auto Nest")
-                    + "; Undo Release restores it.");
-            return string.Join(" ", notes);
-        }
-
-        private static string DraftChoice(NestRecord draft) =>
-            $"Merge into {draft.Name} ({draft.PlateCount} sheet{(draft.PlateCount == 1 ? "" : "s")}, saved "
-            + $"{draft.SavedAt.ToLocalTime().ToString("g", CultureInfo.CurrentCulture)})";
-
-        private void ShowProgress(SetReleaseProgress progress)
-        {
-            // Progress is posted, so a report can arrive after the run ended; the outcome wins.
-            if (IsDisposed || !running)
-                return;
-            statusLabel.Text = progress.Stage switch
-            {
-                SetReleaseStage.Preparing => $"Preparing nest {progress.Index + 1} of {progress.Count}: {Describe(progress.Group)}...",
-                SetReleaseStage.Nesting => $"Nesting nest {progress.Index + 1} of {progress.Count}: {Describe(progress.Group)}...",
-                SetReleaseStage.Uploading => $"Saving nest {progress.Index + 1} of {progress.Count}: {Describe(progress.Group)}...",
-                _ => "Recording the release...",
-            };
-        }
-
-        private void ShowOutcome()
-        {
-            foreach (DataGridViewRow row in groupGrid.Rows)
-            {
-                var outcome = Result.Groups.FirstOrDefault(g => ReferenceEquals(g.Group, row.Tag));
-                if (outcome == null)
-                    continue;
-                var notes = outcome.Warnings.Count == 0 ? "" : " — " + string.Join(" ", outcome.Warnings);
-                row.Cells[statusColumn.Index].Value = outcome.Outcome switch
-                {
-                    SetReleaseGroupOutcome.Created when outcome.MergedInto != null => $"Merged into {outcome.Record!.Name}" + notes,
-                    SetReleaseGroupOutcome.Created => $"Created {outcome.Record!.Name}" + notes,
-                    SetReleaseGroupOutcome.Refused => "Refused: " + outcome.Error,
-                    SetReleaseGroupOutcome.Failed => "Failed: " + outcome.Error,
-                    _ => "Not started",
-                };
-            }
-
-            var done = Result.Created.Count;
-            var nestsText = $"{done} nest{(done == 1 ? "" : "s")}";
-            if (Result.Release != null)
-                statusLabel.Text = $"Done: {nestsText} saved and opened.";
-            else if (Result.ReleaseError.Length > 0)
-                statusLabel.Text = Result.ReleaseError.TrimEnd('.', ' ')
-                    + ". Try Again records it; the nests are not made again.";
-            else if (Result.Canceled)
-                statusLabel.Text = $"Canceled: {nestsText} saved, release not recorded.";
-            else
-                statusLabel.Text = done == 0
-                    ? "Nothing saved. See Status."
-                    : $"Stopped: {nestsText} saved, release not recorded. See Status.";
-            UpdateCommands();
-        }
-
-        private void UpdateCommands()
-        {
-            var chosen = plan == null ? Array.Empty<SetReleaseGroup>() : ChosenGroups();
-            var editable = !running && Result == null;
-            setGrid.ReadOnly = !editable;
-            addSetCombo.Enabled = editable;
-            addSetButton.Enabled = editable;
-            addDrawingsButton.Enabled = editable;
-            removeSetButton.Enabled = editable && setGrid.Rows.Count > 1 && setGrid.CurrentRow != null;
-            includeArchivedCheckBox.Enabled = editable;
-            nestAfterReleaseCheckBox.Enabled = editable;
-            notesBox.ReadOnly = !editable;
-            includeColumn.ReadOnly = !editable;
-            targetColumn.ReadOnly = !editable;
-            if (editable)
-            {
-                foreach (DataGridViewRow row in groupGrid.Rows)
-                {
-                    var refused = row.Tag is SetReleaseGroup { CanRelease: false };
-                    row.Cells[includeColumn.Index].ReadOnly = refused;
-                    row.Cells[targetColumn.Index].ReadOnly = refused;
-                }
-            }
-
-            fixDrawingsButton.Enabled = CanEditDrawings() && RefusedRow() != null;
-            UpdateOptions(chosen);
-
-            var retry = Result is { Release: null, ReleaseError.Length: > 0 };
-            releaseButton.Text = retry ? "Try Again" : "Make Nests...";
-            releaseButton.Enabled = !running && (retry || (editable && chosen.Count > 0));
-            var parts = chosen.Sum(g => (long)g.TotalQuantity);
-            var merged = chosen.Count(g => targets.ContainsKey(g.Key));
-            summaryLabel.Text = plan == null || plan.Groups.Count == 0
-                ? "No nests to make."
-                : $"{chosen.Count} of {plan.Groups.Count} material{(plan.Groups.Count == 1 ? "" : "s")} chosen: "
-                    + $"{chosen.Count - merged} new Draft nest{(chosen.Count - merged == 1 ? "" : "s")}"
-                    + (merged == 0 ? "" : $", {merged} merge{(merged == 1 ? "" : "s")}")
-                    + $", {parts:N0} part{(parts == 1 ? "" : "s")}";
-        }
-
-        // Collapsed, an option shows while it differs from its default or, for the Nest column,
-        // while a draft could be merged into. Only collapsing hides one: hiding a column from its
-        // own cell's events would move the current cell mid-event, and a control should not
-        // vanish under the pointer.
-        private void UpdateOptions(IReadOnlyList<SetReleaseGroup> chosen, bool collapsing = false)
-        {
-            var anyExcluded = plan != null && plan.Groups.Any(g => g.CanRelease && excluded.Contains(g.Key));
-            var canMerge = plan != null && CanMerge();
-            optionsButton.Text = optionsExpanded ? "Options ▾" : "Options ▸";
-            // A control reads as hidden until the form is shown, so the checkbox's state is kept here.
-            archivedShown = Reveal(includeArchivedCheckBox.Checked, archivedShown);
-            includeArchivedCheckBox.Visible = archivedShown;
-            includeColumn.Visible = Reveal(anyExcluded, includeColumn.Visible);
-            targetColumn.Visible = Reveal(canMerge || targets.Count > 0, targetColumn.Visible);
-            previewLabel.Text = Preview(chosen, canMerge);
-
-            bool Reveal(bool changed, bool shown) => optionsExpanded || changed || (shown && !collapsing);
-        }
-
-        // "Creates 2 nests: A36 0.25 in, 304 0.1875 in." and what needs the operator's attention.
-        private string Preview(IReadOnlyList<SetReleaseGroup> chosen, bool canMerge)
-        {
-            if (plan == null || plan.Groups.Count == 0)
-                return "Add a set or drawings to see the nests they make.";
-            const int named = 4;
-            var merges = chosen.Count(g => targets.ContainsKey(g.Key));
-            var created = chosen.Count - merges;
-            var text = (created, merges) switch
-            {
-                (0, 0) => "No nests chosen.",
-                (_, 0) => $"Creates {created} nest{(created == 1 ? "" : "s")}: ",
-                (0, _) => $"Merges into {merges} Draft nest{(merges == 1 ? "" : "s")}: ",
-                _ => $"Creates {created} nest{(created == 1 ? "" : "s")} and merges into "
-                    + $"{merges} Draft nest{(merges == 1 ? "" : "s")}: ",
-            };
-            if (chosen.Count > 0)
-                text += string.Join(", ", chosen.Take(named).Select(g =>
-                        targets.TryGetValue(g.Key, out var draft) ? $"{Describe(g)} into '{draft.Name}'" : Describe(g)))
-                    + (chosen.Count > named ? $" and {chosen.Count - named} more." : ".");
-
-            var refused = plan.Groups.Count(g => !g.CanRelease);
-            if (refused == 1)
-                text += " 1 material can't be released yet: " + (libraryStore == null ? "see its Status." : "choose Fix Drawings.");
-            else if (refused > 1)
-                text += $" {refused} materials can't be released yet: "
-                    + (libraryStore == null ? "see their Status." : "select one and choose Fix Drawings.");
-            var left = plan.Groups.Count(g => g.CanRelease && excluded.Contains(g.Key));
-            if (left > 0)
-                text += $" {left} material{(left == 1 ? " is" : "s are")} left out (unticked under Release).";
-            if (merges == 0 && canMerge)
-                text += " A Draft nest of the same material exists: choose it under Nest to merge into it.";
-            return text;
-        }
-
-        private static string Describe(SetReleaseGroup group) =>
-            group == null ? "" : string.Join(" ", new[]
-            {
-                group.MaterialName,
-                group.MaterialGrade,
-                $"{group.Thickness.ToString("0.####", CultureInfo.CurrentCulture)} {UnitsHelper.GetShortString(group.Units)}",
-            }.Where(s => !string.IsNullOrWhiteSpace(s)));
-
-        // The nest is not shown anywhere yet, so Auto Nest runs off the UI thread on it alone.
-        private static Task<SetReleaseRenest> RenestAsync(Nest nest, CancellationToken token)
-        {
-            var engineName = EngineSelection.EngineName;
-            return Task.Run(() =>
-            {
-                var renested = NestRenest.Run(nest, engineName, AutoNestForm.DefaultMinRemnantSize, token: token);
-                return new SetReleaseRenest(renested.Nested, renested.Note);
-            }, token);
-        }
-
-        private static LibraryPackage ReadPackage(byte[] bytes)
-        {
-            var contents = DrawingPackage.Read(bytes);
-            return new LibraryPackage(bytes, contents.Drawing, contents.Units, contents.Warnings);
-        }
-
-        private static Nest ReadNest(byte[] bytes)
-        {
-            using var stream = new MemoryStream(bytes, writable: false);
-            return new NestReader(stream) { BestFitStore = BestFitCacheStore.Shared }.Read();
-        }
-
-        private static byte[] WriteNest(Nest nest)
-        {
-            using var stream = new MemoryStream();
-            new NestWriter(nest) { BestFitStore = BestFitCacheStore.Shared }.Write(stream);
-            return stream.ToArray();
-        }
-
-        /// <summary>A set in the type-ahead list, shown by name and customer.</summary>
-        private sealed record SetChoice(DrawingSetRecord Set)
-        {
-            public override string ToString() =>
-                string.IsNullOrWhiteSpace(Set.Customer) ? Set.Name : $"{Set.Name} ({Set.Customer})";
+            if (releasePanel.IsRunning || !releasePanel.ConfirmDiscard())
+                e.Cancel = true;
         }
     }
 }
diff --git a/OpenNest/Properties/Settings.Designer.cs b/OpenNest/Properties/Settings.Designer.cs
index 5225012b..56a0d0ef 100644
--- a/OpenNest/Properties/Settings.Designer.cs
+++ b/OpenNest/Properties/Settings.Designer.cs
@@ -384,5 +384,58 @@ namespace OpenNest.Properties {
                 this["CutOffHeadLockOvercutInches"] = value;
             }
         }
+    
+
+        [global::System.Configuration.UserScopedSettingAttribute()]
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+        [global::System.Configuration.DefaultSettingValueAttribute("True")]
+        // Make Nests nests each group with Auto Nest; the release panel remembers the last choice.
+        public bool ReleaseNestAfter {
+            get {
+                return ((bool)(this["ReleaseNestAfter"]));
+            }
+            set {
+                this["ReleaseNestAfter"] = value;
+            }
+        }
+
+        [global::System.Configuration.UserScopedSettingAttribute()]
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+        [global::System.Configuration.DefaultSettingValueAttribute("0, 0")]
+        // The Drawing Sets window's restored location.
+        public global::System.Drawing.Point DrawingSetsWindowLocation {
+            get {
+                return ((global::System.Drawing.Point)(this["DrawingSetsWindowLocation"]));
+            }
+            set {
+                this["DrawingSetsWindowLocation"] = value;
+            }
+        }
+
+        [global::System.Configuration.UserScopedSettingAttribute()]
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+        [global::System.Configuration.DefaultSettingValueAttribute("0, 0")]
+        // The Drawing Sets window's restored size; empty until it first closes.
+        public global::System.Drawing.Size DrawingSetsWindowSize {
+            get {
+                return ((global::System.Drawing.Size)(this["DrawingSetsWindowSize"]));
+            }
+            set {
+                this["DrawingSetsWindowSize"] = value;
+            }
+        }
+
+        [global::System.Configuration.UserScopedSettingAttribute()]
+        [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+        [global::System.Configuration.DefaultSettingValueAttribute("Maximized")]
+        // Whether the Drawing Sets window opens maximized.
+        public global::System.Windows.Forms.FormWindowState DrawingSetsWindowState {
+            get {
+                return ((global::System.Windows.Forms.FormWindowState)(this["DrawingSetsWindowState"]));
+            }
+            set {
+                this["DrawingSetsWindowState"] = value;
+            }
+        }
     }
 }
diff --git a/OpenNest/Properties/Settings.settings b/OpenNest/Properties/Settings.settings
index 06be8104..836515bb 100644
--- a/OpenNest/Properties/Settings.settings
+++ b/OpenNest/Properties/Settings.settings
@@ -92,5 +92,17 @@
     <Setting Name="CutOffHeadLockOvercutInches" Type="System.Double" Scope="User">
       <Value Profile="(Default)">1.5</Value>
     </Setting>
+    <Setting Name="ReleaseNestAfter" Type="System.Boolean" Scope="User">
+      <Value Profile="(Default)">True</Value>
+    </Setting>
+    <Setting Name="DrawingSetsWindowLocation" Type="System.Drawing.Point" Scope="User">
+      <Value Profile="(Default)">0, 0</Value>
+    </Setting>
+    <Setting Name="DrawingSetsWindowSize" Type="System.Drawing.Size" Scope="User">
+      <Value Profile="(Default)">0, 0</Value>
+    </Setting>
+    <Setting Name="DrawingSetsWindowState" Type="System.Windows.Forms.FormWindowState" Scope="User">
+      <Value Profile="(Default)">Maximized</Value>
+    </Setting>
   </Settings>
 </SettingsFile>
diff --git a/docs/nest-storage.md b/docs/nest-storage.md
index 046eec49..d833c1a5 100644
--- a/docs/nest-storage.md
+++ b/docs/nest-storage.md
@@ -325,9 +325,12 @@ The browser's **Cut first** column shows the setting.
 
 **File > Drawing Library...** (Database mode only, like Drawing Sets) opens the
 drawing sets window on its **Library** tab ([below](#drawing-sets-desktop)),
-the same browser without a nest: it lists every active drawing, has no Add to
-Nest or In This Nest tab, and a double-click or Enter edits the selected drawing. Its
-right-click menu has Edit Drawing and the set and release items below.
+the same browser without a nest: it lists every active drawing and has no Add to
+Nest or In This Nest tab. There a double-click, Enter or **Add to Release** adds
+the selected drawing on its own, at the entered **Quantity**, to the window's
+release panel ([below](#make-nests-the-release-panel)); **Edit Drawing...** (the
+button or the right-click menu) edits it. Its right-click menu also has the set
+and release items below.
 
 ### Edit Drawing (desktop)
 
@@ -360,7 +363,7 @@ Edit Drawing opens from:
   right-click it, or **Edit Drawing...** beside the grid. It first reads the
   member's current record, so a set read earlier does not cause a conflict; the
   row then shows what was saved. The set itself is unchanged and needs no save;
-- the release dialog: a group refused for its drawings (no material or
+- the release panel: a group refused for its drawings (no material or
   thickness, or two drawings with one name) has **Fix Drawings...**, which opens
   Edit Drawing on each drawing it is refused for in turn (Cancel stops), as does
   a double-click on the group; with a releasable group selected, it takes the
@@ -405,19 +408,28 @@ revision; save the nest to keep it.
 
 **File > Drawing Sets...** (Database mode only) opens the drawing sets window;
 it needs no open nest, since releasing a set makes new nests or merges into
-draft ones and opens each in its own tab. The window has three tabs, **Library**
+draft ones and opens each in its own tab. It is a window of its own beside the
+main window (in the taskbar, with its own minimize button), not a tab inside it,
+since the main window's menus and toolbar are for editing nests. There is one
+at a time: the menu items bring it forward on the tab asked for. It opens
+maximized the first time, then where and as it was last closed, and closes with
+the main window. The window has three tabs, **Library**
 (**File > Drawing Library...** opens on it), **Sets** and **Releases**
 ([below](#releases-tab)); **File > Releases...** is a shortcut that opens the
-same window on the Releases tab. Each tab reads its list when first
+same window on the Releases tab. Beside the Library and Sets tabs is the
+release panel ([below](#make-nests-the-release-panel)), which builds one release
+from both. Each tab reads its list when first
 shown, and Releases re-reads its page each time it is shown again. Sets lists sets a page at a time
 (`OpenNest.Data.DrawingSetBrowseSession`): search by name, customer or notes,
 sort by name, customer, revision or saved time, and **Show archived**. Selecting
-a set shows its notes. Below the list are **New Set...**, **Edit...** (also a
-double-click or Enter on a set), **More ▾** and **Make Nests...** in bold, the
-main action (below). **More ▾**, also the list's right-click
-menu (the menu key or Shift+F10 opens it from the keyboard), holds **Archive**
-or **Restore**, **History...** and **Releases...** for the selected set, then
-**Import BOM...** ([below](#import-bom-to-a-set-desktop)), which needs no selection.
+a set shows its notes. A double-click or Enter adds the set to the release at
+one kit (again adds another kit). Below the list are **New Set...**, **Edit...**,
+**More ▾** and **Add to Release** in bold, which adds every selected set
+(Ctrl- or Shift-click selects several). **More ▾**, also the list's right-click
+menu (the menu key or Shift+F10 opens it from the keyboard), holds **Add to
+Release** and **Edit Set...**, then **Archive** or **Restore**, **History...**
+and **Releases...** for the selected set, then **Import BOM...**
+([below](#import-bom-to-a-set-desktop)), which needs no selection.
 
 - **New Set...** and **Edit...** open the set editor
   (`OpenNest.Data.DrawingSetEditSession`): name, customer, notes and the member
@@ -456,7 +468,7 @@ or **Restore**, **History...** and **Releases...** for the selected set, then
 Database mode opens the drawing sets window straight into it) turns a BOM into a
 new drawing set. It sits in More rather than beside New Set because it is another
 way to start a set, used once per job, and the Sets tab keeps New Set, Edit and
-Make Nests as its only buttons; File > Import BOM stays the familiar way in.
+Add to Release as its only buttons; File > Import BOM stays the familiar way in.
 
 1. Choose the BOM (`.xlsx`, read by `BomReader`) and the folder of its drawings,
    the **Set name** (prefilled from the BOM file name without a trailing " BOM")
@@ -497,7 +509,7 @@ Make Nests as its only buttons; File > Import BOM stays the familiar way in.
    leaves the set unchanged; Read BOM again then reuses those drawings, so
    importing twice never stores a drawing twice.
 
-Releasing the set (**Make Nests...**) then makes the nests, replacing File-mode
+Releasing the set (**Make Nests** in the release panel) then makes the nests, replacing File-mode
 BOM import's Create Nests for Database mode. In File mode, **File > Import BOM...**
 still makes nests directly, unchanged.
 
@@ -506,10 +518,12 @@ whose current revision contains it) or **Add to Set...**: choose an active set
 or **New Set**, and the set editor opens with the drawing added at the entered
 quantity for review and Save. **Releases...** opens the drawing sets window on
 its Releases tab, filtered to the releases that had the drawing on its own (see
-below), with Undo Release. When the dialog was opened
-from a nest, **Make Nests...** reads the drawing's current record and opens the
-release dialog with it on its own at the entered quantity; more drawings and
-sets are added there.
+below), with Undo Release. In the drawing sets window, **Add to Release** adds
+the drawing to the release panel. When the dialog was opened from a nest,
+**Make Nests...** reads the drawing's current record and opens the release panel
+in a dialog of its own with the drawing on its own at the entered quantity;
+**Add Drawings...** there adds more library drawings (sets are released from the
+drawing sets window).
 
 The nest's drawing list has **Add Library Drawings to Set...** (right-click any
 drawing; it acts on the whole nest, `OpenNest.Data.NestSetMerge`). It takes each
@@ -525,80 +539,89 @@ library's latest revision. Anything kept, skipped, archived in the library or
 newer there than in the nest is listed first, then the set editor opens for
 review and Save; nothing is stored before then.
 
-**Make Nests...** (on the drawing sets window's Sets tab) reads the
-selected active set with its members and opens the release dialog with it listed.
-More sets are added from **Add a set**: the list opens with the first active sets
-by name and narrows as you type; Enter or **Add** takes the picked set, or the one
-set whose name is exactly what was typed. **Add Drawings...** adds library drawings on
-their own, outside any set: it browses every active drawing as the set editor's
-library pane does (search, server-side sort, pages, several selected at once),
-and **Add to Release**, a double-click or Enter adds the selection at the
-entered quantity. It stays open for more; a drawing already listed is greyed
-and skipped, and an archived one is refused. **Remove** takes a set or drawing
-out while another remains. The list shows each line's type; **Quantity** is how
-many of a set (1 to 1000, multiplying its quantities) or of a drawing (1 to
-100,000), and a set or drawing is listed once. A drawing that a set also lists
-becomes one item with both quantities. The heading reads as a sentence of what
-is listed, such as "Release set 'Frame kit' ×2", or the first few lines by name
-and quantity when there are several.
+<a id="make-nests-the-release-panel"></a>
+### Make Nests: the release panel (desktop)
 
-Below, a sentence previews what **Make Nests...** will do, such as "Creates 3
-nests: A36 Grade A 0.25 in, 304 0.1875 in, ...", and the grid has one row per
-material (name, grade, thickness, units and cut type) across all the sets and
-drawings (`OpenNest.Data.SetReleasePlan`): material, grade, thickness, units,
-cut type, drawings, parts and status. Refused groups (two drawings with one name,
-or drawings without material or thickness) show why in the status column and
-the preview counts them. **Fix Drawings...** opens
-[Edit Drawing](#edit-drawing-desktop) on the selected refused group's drawings,
-or the first refused group's when another row is selected, and rebuilds the plan
-with what was saved. Archived members are left out and named below the grid.
+The release panel (`OpenNest.Controls.ReleasePanel`) sits beside the Library and
+Sets tabs and holds one release in progress for both. Adding is a double-click
+(or Enter) in either list: a set is read with its members' current drawings and
+listed at one kit; a library drawing is read afresh and listed on its own at the
+Library tab's **Quantity**. Adding a set or drawing already listed adds to its
+quantity instead, so double-clicking a set twice makes it ×2 kits. An archived
+set or drawing is refused. Each line shows its name, its quantity (edited in
+place: 1 to 1000 kits of a set, multiplying its quantities, or 1 to 100,000
+pieces of a drawing) and **kits** or **pcs**; **✕** (or Delete) removes it. A
+drawing that a set also lists becomes one item with both quantities. Above the
+lines, the heading reads as a sentence of what is listed, such as "Release set
+'Frame kit' ×2", or the first few lines when there are several. Below them are
+the release's **Customer** (the one every line names, or left blank when they
+differ) and **Notes**. Closing the window keeps a release not yet made for the
+next time it opens in this run of OpenNest; it is not saved to disk.
 
-The common case needs nothing more: every releasable material makes a new Draft
-nest and **Nest after release** is ticked. **Options ▸** expands the choices that
-change that: a **Release** tick per group (refused groups cannot be ticked), the
-**Nest** column, and **Include archived drawings**, which puts archived members
-back in. A tick survives changing the sets, quantities or the archived toggle.
-Collapsing Options hides only what is at its default: an unticked group keeps the
-Release column shown, and a ticked Include archived drawings stays shown. The
-**Nest** column also shows, with a hint in the preview, whenever a Draft nest
-exists that a material could merge into.
+**Nests it will make** previews, live as lines change, one row per material
+(name, grade, thickness, units and cut type) across all the sets and drawings
+(`OpenNest.Data.SetReleasePlan`): a tick, the material, its parts, its **Nest**
+and **What happens**. Untick a group to leave it out; the choice survives
+changing the lines. Refused groups (two drawings with one name, or drawings
+without material or thickness) cannot be ticked and say why at once.
+**Fix Drawings...** opens [Edit Drawing](#edit-drawing-desktop) on the selected
+refused group's drawings, or the first refused group's when another row is
+selected, and rebuilds the plan with what was saved. Archived members are left
+out and named below the grid, where **Include archived drawings** appears to put
+them back in.
 
-**Nest** is **New Draft nest** or **Merge into** one of the Draft nests of the
-group's material, grade and thickness, listed with their sheet count and when
-they were saved. A merge adds the demand to that draft's drawings and discards
-every sheet (placements, cutoffs, cut plans), keeping drawing-level setup such as
-cut pins (the status column says so); **Undo Release** restores it. A draft open
-in a tab of this desktop is refused, since that tab could hold edits the merge
-would leave behind: close it first.
+A group **merges into a Draft nest by default**, which is what Draft status is
+for: the plan looks up the Draft nests of the group's material, grade and
+thickness (`SetReleasePlan.FindDraftsAsync`) and
 
-**Nest after release** (ticked by default) runs Auto Nest on every released
+- with exactly one, merges into it: the row says "→ merges into N26-0007";
+- with several, merges into the most recently saved; the **Nest** list in the
+  row offers the others (newest first) and **New Draft nest**, and the row says
+  how many match;
+- with none, makes a new Draft nest ("→ new Draft nest");
+- when the draft it would merge into is open in a tab of this desktop, the row
+  says "N26-0007 is open — save and close it to merge into it" and **Make Nests**
+  waits: the tab could hold edits the merge would leave behind, and a parallel
+  nest is never made silently. Close the tab (the panel checks again when the
+  window is activated), choose New Draft nest for the group, or untick it.
+
+Make Nests also waits until every chosen group's drafts have been looked up. A
+merge adds the demand to that draft's drawings and renests the whole draft: every
+sheet (placements, cutoffs, cut plans) is discarded and rebuilt, keeping
+drawing-level setup such as cut pins; **Undo Release** restores it. With **Nest
+after release** unticked, the row says the merged draft is left without sheets
+until it is nested.
+
+**Nest after release** (beside the button, ticked by default; the panel
+remembers the operator's last choice) runs Auto Nest on every released
 group, new or merged, before anything is saved (`OpenNest.Engine.Jobs.NestRenest`):
 every drawing's required quantity, the selected engine, sheets from the nest's
 plate defaults and plate-size options, as the Auto Nest dialog would offer them.
 A layout is kept only when it is valid; otherwise the nest is saved without
 sheets and its status says "Auto Nest could not keep a layout: open it and run
-Auto Nest". The status column lists each group's sheets and utilization, and any
+Auto Nest". The row lists each group's sheets and utilization, and any
 copies left unplaced, which stay as remaining quantity. Unticked, new nests are
 saved without sheets and merged drafts are left cleared for Auto Nest.
 
-**Make Nests...** confirms, then runs `OpenNest.Data.SetReleaseSession`: every ticked
-group's new nest is made as File > New would (the server's next nest name, the
-saved plate defaults and clamps), in the group's units, with the saved plate size
-and spacings converted (25.4 mm per inch) when those differ; the nest takes the
-group's material, grade and thickness, the sets' customer when they share one,
-and the **Draft** status (with drawings on their own, their library customers
-count too). A merged draft is saved only while nobody else has
-saved it since it was listed. Each created or merged nest opens in its own tab,
-bound to its server record, and the release (with the release notes) is
-recorded. A release with drawings on their own first checks that the server can
-record them (see below) and, on an older server, saves nothing and says so. The
-grid then shows every group's outcome: Created or Merged into with
-the nest name, Refused or Failed with the reason, or Not started. Cancel during
-preparing or nesting saves nothing; once saving starts it stops between saves,
-never during one. When every nest was saved but recording failed,
-the button becomes **Try Again** and posts the same release again without making
-the nests again. A dialog
-runs one release.
+**Make Nests (n)**, in bold, with n the groups ticked, is the only step that
+writes; **Clear** empties the panel. It runs `OpenNest.Data.SetReleaseSession`:
+every ticked group's new nest is made as File > New would (the server's next nest
+name, the saved plate defaults and clamps), in the group's units, with the saved
+plate size and spacings converted (25.4 mm per inch) when those differ; the nest
+takes the group's material, grade and thickness, the release's customer when
+there is one, and the **Draft** status. A merged draft is saved only while nobody
+else has saved it since it was listed. Each created or merged nest opens in its
+own tab of the main window, bound to its server record, the main window comes
+forward, and the release (with its notes) is recorded. A release with drawings
+on their own first checks that the server can record them (see below) and, on an
+older server, saves nothing and says so. Each row then shows its group's outcome:
+Created or Merged into with the nest name, Refused or Failed with the reason, or
+Not started. **Stop** (Clear while running) during preparing or nesting saves
+nothing; once saving starts it stops between saves, never during one, and the
+window does not close while it runs. When every nest was saved but recording
+failed, the button becomes **Try Again** and posts the same release again
+without making the nests again; until then nothing more can be added. After a
+release, the next double-click starts the next one.
 
 <a id="releases-tab"></a>
 The **Releases** tab lists every release on the server, newest first, 100 at a
@@ -611,9 +634,9 @@ notes. The selected release's nests show their **Material**, the **Action**
 Deleted. **Undo Release...** deletes the nests the release created (they can be
 recovered) and restores the drafts it merged into. When some nests were changed
 after the release, it lists them and offers to undo the others, leaving those as
-they are. **New Release...** opens the release dialog empty; sets are added by
-name and drawings with Add Drawings, and once the dialog records a release the
-list re-reads from the newest.
+they are. **New Release** switches to the Sets tab, where the release panel
+builds the next release; the list re-reads from the newest when the tab is
+shown again.
 
 A filter narrows the tab to one set or one drawing, shown above the list
 ("Releases of set 'Frame A'") until **Clear Filter** lists every release again:
@@ -783,7 +806,8 @@ material or a positive thickness goes to one refused "unassigned" group, listed
 `SetReleasePlan.FindDraftsAsync(nests, group)` lists the Draft nests a group
 could merge into, using the nest query's status, material, grade and thickness
 filters. Units and cut type are not in nest metadata, so they are checked on the
-downloaded nest.
+downloaded nest. The desktop merges into the most recently saved of them by
+default and never into one open in a tab ([release panel](#make-nests-the-release-panel)).
 
 `SetReleaseSession.RunAsync` releases the chosen releasable groups in plan order.
 A group named in its `mergeInto` map merges into that draft instead of making a