gui, guard: nine things reported from the running window

A setting chosen from a list opens on its own default instead of on an
extra entry reading "not stated - pdf". That entry existed so a default
nobody picked could be told from a value somebody chose, and its written
reason was untouchable rule 5. Measured at both ends and neither end read
it: an ICO run with embed left alone and one with embed=bmp produce the
same bytes and the same manifest, both writing embed: bmp with the word
defaulted in neither, and a preset's defaulted is built from the
parameters a preset declares, which the global format flag is not one of.

One correction to that measurement, found by the guard comparing the two
surfaces: defaulted does not carry it, but the parameters block does once
a value is given. Settled on the screen's side, since the menu shows the
word pdf to whoever is looking at it. The files are unchanged.

Boxes somebody types into keep the old promise. Leaving a preset's limit
empty still records it as ours rather than theirs.

Every list of formats draws the file kind pictures, decided in
parts.NewChooser rather than at each call site - two of the three lists
had gone twenty days without them because the assignment was a line
somebody had to remember. Gated on the whole set of registered formats,
since a subset is the case that must not get them: ICO's embed offers two
pictures and would draw one icon twice.

"Add files inside" appears only under a format that holds files. The
reason written beside that code said asking would put a rule about
formats in the window - false, since Container is a declared field on a
descriptor. Rows already typed stay on screen when the format changes, so
nothing is thrown away and a refusal still has a field to point at.

Four fields explain themselves better, including the seed, which now says
that 0 is the seed a run uses when nobody asks for another one rather
than a request for random files.

parts.RowWidthFor is the one home of a list row's arithmetic, and
menuWidth takes the wider of the closed box and the row. Two changes met
on the preset screen: pictures widen a row, and dropping "not stated -
pdf" removed the longest string that had been holding the box wide enough
to hide it. Every one of the twenty formats came out cut off, and the
guard said so before anything here changed.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Author: donislawdev

CHANGELOG.md

@@ -282,6 +282,38 @@ because it turns other people's test suites red.
 
 ### Changed
 
+- The window no longer offers to put files inside a format that holds none.
+  "Add files inside" now appears under ZIP and TAR.GZ, and nowhere else. It used
+  to appear under every batch, so a PNG batch carried a button whose only
+  destination was a refusal. Rows you already filled in stay on screen if you
+  change the format afterwards, so nothing you typed disappears and the refusal
+  still has a field to point at.
+
+- Every list of file formats in the window now draws the same small picture
+  beside each value. One of the three lists had them and two did not, so the
+  same twenty formats looked like different kinds of list depending on which tab
+  you were on.
+
+- A setting chosen from a list now opens on its own default instead of on an
+  extra entry reading "not stated - pdf". The extra entry existed so that a
+  default nobody picked could be told from a value somebody chose. Measured on
+  both surfaces, nothing downstream ever read that difference for a setting
+  drawn as a list: a run leaving an ICO's embed alone and a run asking for
+  embed=bmp produce the same bytes and the same manifest, and the preset block's
+  defaulted list is built from a preset's own parameters, which the format is
+  not one of. Boxes you type into are unchanged - leaving a preset's limit empty
+  still records it as ours rather than yours.
+
+  One visible consequence: a run started from the Presets tab now records the
+  format in the manifest's preset parameters, because the screen states it. The
+  files are the same.
+
+- Four fields explain themselves better. The format list dropped its second
+  sentence, which described the list you were already looking at. "File names"
+  and "Batch name" say what they are for and what they change. The seed says
+  what 0 means - it is the seed a run uses when nobody asks for another one, and
+  it is not a request for random files, which this tool never produces.
+
 - Two refusals are worded differently. Nothing about what is accepted has
   changed - only the sentences.
 

internal/guard/archivecontents_test.go

@@ -0,0 +1,101 @@
+package guard
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/donislawdev/TestingFilesGenerator/internal/format"
+	"github.com/donislawdev/TestingFilesGenerator/internal/gui/text"
+	"github.com/donislawdev/TestingFilesGenerator/internal/gui/window"
+	"github.com/donislawdev/TestingFilesGenerator/internal/recipe"
+)
+
+// Only a format that holds other files offers to put files in it.
+//
+// Every batch used to carry an "Add files inside" button, whatever it was going
+// to produce, and a PNG batch is where the owner saw it on 2026-08-27. The
+// reason written beside the code was that asking a format whether it holds
+// files would put a rule about formats into the window. That premise is false:
+// Container is a DECLARED field on a descriptor, sitting beside the properties
+// this same screen already draws straight from the declaration, so asking it is
+// the opposite of inventing a rule.
+//
+// Asked of the registry rather than of a list written here, so a format
+// registered tomorrow is covered on the day it is registered - which is the
+// same reason the menu itself is built from format.IDs().
+func TestOnlyAFormatThatHoldsFilesOffersToPutFilesInIt(t *testing.T) {
+	screen := window.NewRecipe(newFakeHost(t))
+	body := screen.Object()
+
+	holders, plain := 0, 0
+	for _, d := range format.All() {
+		chooserIn(t, screen.Fields(), recipe.TargetAddress(1, recipe.KeyFormat)).SetSelected(d.ID)
+
+		offered := buttonNamed(body, text.ButtonAddContents()) != nil
+		switch {
+		case d.Container && !offered:
+			t.Errorf("%s holds other files and its batch offers no way to say what they are", d.ID)
+		case !d.Container && offered:
+			t.Errorf("%s holds no other files and its batch offers to put files in it, "+
+				"which leads nowhere but a refusal", d.ID)
+		}
+		if d.Container {
+			holders++
+		} else {
+			plain++
+		}
+	}
+
+	// Both sides have to have happened. A build registering only containers -
+	// or only plain formats - would satisfy every branch above without either
+	// half of the rule being exercised.
+	if holders == 0 || plain == 0 {
+		t.Fatalf("this guard saw %d format(s) that hold files and %d that do not, "+
+			"so one half of the rule went unchecked", holders, plain)
+	}
+	t.Logf("%d format(s) offer to hold files, %d do not", holders, plain)
+}
+
+// What somebody already typed into an archive stays on screen when the format
+// changes under it.
+//
+// This is the half of the decision worth being careful about, and it is the
+// owner's, taken on 2026-08-27 with both of the alternatives named. Dropping
+// the rows would throw away typed work on the strength of one menu press, which
+// is the silence untouchable rule 6 forbids. Hiding them while still sending
+// them would put the run in the state folding the batches away was allowed to
+// close on condition of avoiding: the engine refuses over a value, the screen
+// has no box to mark, and the button reads as having done nothing.
+//
+// So the rows outlive the format and the refusal has somewhere to land. The way
+// out of it stays visible too - remove them, or put the format back.
+func TestContentsAlreadyTypedStayOnScreenWhenTheFormatChanges(t *testing.T) {
+	screen := window.NewRecipe(newFakeHost(t))
+	body := screen.Object()
+
+	at := recipe.ContentAddress(1, 1, recipe.KeySize)
+	chooserIn(t, screen.Fields(), recipe.TargetAddress(1, recipe.KeyFormat)).SetSelected("zip")
+	pressNamed(t, body, text.ButtonAddContents())
+	setBox(t, screen.Fields(), at, "3kb")
+
+	// A format that holds nothing. The offer to add more goes, since another
+	// one would not be legal.
+	chooserIn(t, screen.Fields(), recipe.TargetAddress(1, recipe.KeyFormat)).SetSelected("txt")
+
+	if buttonNamed(body, text.ButtonAddContents()) != nil {
+		t.Error("a txt batch offers to add files inside it")
+	}
+
+	if findField(screen.Fields(), at) == nil {
+		t.Fatalf("the row typed into an archive is gone from the screen after the format changed, "+
+			"so a refusal about %s would have nothing to mark", at)
+	}
+	if got := boxText(t, screen.Fields(), at); got != "3kb" {
+		t.Errorf("the row typed into an archive says %q after the format changed and it was typed as %q",
+			got, "3kb")
+	}
+	if !strings.Contains(everythingSaid(body), text.ContentsHeading()) {
+		t.Errorf("the rows are still registered and %q is not on the screen, "+
+			"so what is left is a value nobody can see", text.ContentsHeading())
+	}
+}

internal/guard/detailpopup_test.go

@@ -53,7 +53,12 @@ func TestTheLongerExplanationOpensWhenAsked(t *testing.T) {
 	// nobody can see until they press something, so an unwired button is
 	// invisible in exactly the way the permanent text was not.
 	for _, field := range []struct{ label, detail string }{
-		{text.FieldFormat(), text.DetailFormat()},
+		// The format field's sentence is the line under its label, which lives
+		// behind this button like every longer explanation since 2026-08-24.
+		// It had a second sentence until 2026-08-27 and the button outlived it,
+		// which is the point: an empty explanation would leave the line with
+		// nowhere to be read.
+		{text.FieldFormat(), text.HintFormat()},
 		{text.FieldSize(), text.DetailSize()},
 		{text.FieldTargetID(), text.DetailTargetID()},
 		{text.FieldNameTemplate(), text.DetailNameTemplate()},

internal/guard/menudefault_test.go

@@ -0,0 +1,179 @@
+package guard
+
+import (
+	"strings"
+	"testing"
+
+	"fyne.io/fyne/v2"
+
+	"github.com/donislawdev/TestingFilesGenerator/internal/format"
+	"github.com/donislawdev/TestingFilesGenerator/internal/gui/parts"
+	"github.com/donislawdev/TestingFilesGenerator/internal/gui/text"
+	"github.com/donislawdev/TestingFilesGenerator/internal/gui/window"
+	"github.com/donislawdev/TestingFilesGenerator/internal/preset"
+	"github.com/donislawdev/TestingFilesGenerator/internal/recipe"
+)
+
+// A menu offers what the declaration lists, and opens on the declared default.
+//
+// This replaces TestAMenuLeftAloneSaysNothingWasChosen, which held the opposite
+// promise: that a menu carries an extra first entry reading "not stated - a4",
+// so a default nobody picked could be told from a value somebody chose. The
+// reason written on that guard was untouchable rule 5 - the manifest records
+// WHICH values were ours - and the reason was never checked against a manifest.
+//
+// Measured on 2026-08-27, at both ends, and neither end wanted it:
+//
+//   - A format setting. An ICO run leaving embed alone and one asking for
+//     embed=bmp give the same bytes and the same manifest, which writes
+//     embed: bmp in both of them. The word defaulted is in neither.
+//   - A preset setting. Defaulted is built from the parameters a preset
+//     declares, and the format a preset is built in is a global flag rather
+//     than one of those, so a run that never states it records
+//     defaulted: [spread] and never mentions format at all.
+//
+// So the entry was a third value between two that already did the same thing.
+// Removed by the owner's decision. What is guarded instead is the promise that
+// replaced it, and it has two halves that fail differently: a menu offering
+// something the declaration does not list would let somebody ask for a value
+// the engine refuses, and a menu opening on anything but the default would
+// silently change what a fresh screen produces.
+//
+// Boxes somebody types in are a different case and keep the old promise -
+// TestABoxYouMayLeaveAloneSaysSo is the guard for those.
+func TestAMenuOpensOnItsDeclaredDefault(t *testing.T) {
+	checked := 0
+	for _, p := range everyDeclaredMenu() {
+		p := p
+		t.Run(p.Name, func(t *testing.T) {
+			field := parts.FromProperty(p)
+			menu, ok := field.Control.(*parts.Chooser)
+			if !ok {
+				t.Fatalf("%q is a closed set and the window draws %T for it", p.Name, field.Control)
+			}
+			checked++
+
+			if got, want := strings.Join(menu.Options, ","), strings.Join(p.Choices, ","); got != want {
+				t.Errorf("the menu for %q offers %s and the declaration lists %s", p.Name, got, want)
+			}
+
+			if p.Default == "" {
+				// Nothing declared, so nothing chosen. The format works its own
+				// answer out and the placeholder says so.
+				if menu.Selected != "" {
+					t.Errorf("%q declares no default and its menu opens on %q, which is a choice nobody made",
+						p.Name, menu.Selected)
+				}
+				return
+			}
+
+			if menu.Selected != p.Default {
+				t.Errorf("%q declares the default %q and its menu opens on %q",
+					p.Name, p.Default, menu.Selected)
+			}
+			// Asked of the FIELD rather than read off the control, because the
+			// value is the half that reaches the engine. A menu showing the
+			// right word while sending something else onward would be a defect
+			// wearing a label.
+			if got := field.Value(); got != p.Default {
+				t.Errorf("the menu for %q shows %q and sends %q", p.Name, menu.Selected, got)
+			}
+		})
+	}
+	if checked == 0 {
+		t.Fatal("no menu was examined - this guard would pass without checking anything")
+	}
+	t.Logf("%d menu(s) open on their declared default", checked)
+}
+
+// everyDeclaredMenu is every closed set either surface draws, with and without
+// a declared default.
+//
+// Both kinds, deliberately. The old guard looked only at settings that declare
+// a default, because the entry it was about only existed for those - which left
+// the menus that declare none unwatched by anything asking what they offer.
+func everyDeclaredMenu() []format.Property {
+	var out []format.Property
+	seen := map[string]bool{}
+	add := func(p format.Property) {
+		if p.Kind != format.PropertyChoice || seen[p.Name] {
+			return
+		}
+		seen[p.Name] = true
+		out = append(out, p)
+	}
+
+	for _, d := range format.All() {
+		for _, p := range d.Properties {
+			add(p)
+		}
+	}
+	for _, p := range preset.All() {
+		for _, param := range append(append([]format.Property{}, p.Parameters...), p.Globals()...) {
+			add(param)
+		}
+	}
+	return out
+}
+
+// Every menu offering the whole list of formats draws the file kind pictures.
+//
+// There were three such menus on 2026-08-27 and one of them had the pictures:
+// the format of a batch. The list inside "Add files inside" and the format a
+// preset is built in were drawn plain, so the same twenty values looked like
+// different kinds of list depending on which tab somebody was standing on.
+// Reported by the owner from the running window.
+//
+// Asked of the SCREENS rather than of the constructor, and that is the whole
+// value of it. The rule now lives in parts.NewChooser, and a guard calling that
+// directly would prove the rule and say nothing about whether a screen went
+// through it - which is exactly the state this defect was in, since the batch
+// screen assigned the pictures by hand and the other two forgot.
+func TestEveryMenuOfferingEveryFormatDrawsTheKindPictures(t *testing.T) {
+	host := newFakeHost(t)
+	window.Open(host)
+
+	look := func(where string, root fyne.CanvasObject) int {
+		found := 0
+		walk(root, func(o fyne.CanvasObject) {
+			menu, ok := o.(*parts.Chooser)
+			if !ok || !parts.IsEveryFormat(menu.Options) {
+				return
+			}
+			found++
+			if menu.KindOf == nil {
+				t.Errorf("a menu of formats on %s draws no pictures, and the one on %s does",
+					where, text.TabRecipe())
+				return
+			}
+			for _, id := range menu.Options {
+				if menu.KindOf(id) == nil {
+					t.Errorf("the menu of formats on %s draws nothing for %q", where, id)
+				}
+			}
+		})
+		return found
+	}
+
+	// One per screen, counted per screen. A total would let a screen with none
+	// hide behind a screen with two, which is the shape of the defect itself -
+	// two menus were missed for twenty days while a third had the pictures.
+	for _, tab := range []string{text.TabOneTarget(), text.TabRecipe(), text.TabPresets()} {
+		if n := look(tab, tabNamed(t, host.content, tab)); n != 1 {
+			t.Errorf("the %s screen has %d menu(s) offering every format and this guard expects 1", tab, n)
+		}
+	}
+
+	// The fourth is not on any screen until somebody asks for it: the list of
+	// what an archive holds is drawn by pressing a button, and since 2026-08-27
+	// that button is only under a format that holds files. Two are expected
+	// here, since this batch screen still has the batch's own format menu on it.
+	screen := window.NewRecipe(newFakeHost(t))
+	body := screen.Object()
+	chooserIn(t, screen.Fields(), recipe.TargetAddress(1, recipe.KeyFormat)).SetSelected("zip")
+	pressNamed(t, body, text.ButtonAddContents())
+	if n := look(text.ContentsHeading(), body); n != 2 {
+		t.Errorf("a batch holding files has %d menu(s) offering every format and this guard expects 2 - "+
+			"the batch's own and the one row inside it", n)
+	}
+}