gui: the window says where things begin and end (#116)

* gui: the window says where things begin and end - the owner's list from the running window

The owner's report from the running window: the whole thing runs together,
nothing says where a section ends, where a box begins or what is a button.
Measured on the shot, every structural surface sat within 1.0 to 1.8:1 of
its neighbour, and the palette's role table had classed the boundary
between a panel and the page as decoration with no threshold. Two whole
looks were built and shown and turned down. What ships is the list the
owner gave, each point shown in the running window before it was kept:

- a section draws a line round its edge again, in the separator's colour
  (the guard that forbade the line now requires it, and the fill under
  it still has to clear the page);
- a field's name stands over its box rather than beside it, in an ink a
  step under the value's, and the byte count goes under the box - so the
  column of names, the widest-name arithmetic, the hand kept list of every
  name and the guard holding that list complete all go, because a width
  nothing draws is a number waiting to be wrong;
- Preview, Choose, Duplicate and Add a batch stand on the button's own
  surface, brighter than a box to type in, asked for by name and by
  distance;
- a fold inside a section is titled at the rank of a subheading, and the
  pointer lights only its words rather than the whole row;
- a field's explanation opens with an edge and a shade below it.

Turned down and written up rather than left half in: a menu raised like a
button, a brighter edge round a box to type in, both looks built from
guidelines or from other applications measured on this machine.

Guards: nine went red in one run of the package and each was rewritten to
what the window does now, two assertions were added for the new behaviour
(the fold's fill narrower than its row, the name's ink readable and a
step under the value), 26 stored screen pictures were regenerated, the
type ceiling followed the widest type down to 26 methods. Mutation entries:
six re-aimed, two removed with the column of names, three added, every
pattern found once.

Not run locally by the owner's decision: the full suite and the full
mutation run. Run: the cheap whole-tree gates plus every guard of every
touched file (121, green), gofmt, vet, lint, staticcheck.

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

* gui: after the outside review of #116 - two guards bounded from both sides, the tip's shade in the palette

Three findings, all three true on the code as it stood:

- the fold head's fill was asked to be narrower than its row and wider
  than nothing, which a one pixel fill satisfies. It is now asked to be at
  least as wide as the title it lights and narrower than the row;
- the pairing of a name with the box under it was measured once, between
  the first two fields, and applied to every field - a later pair could
  drift while the first still held. Each name is now measured against the
  next name down the screen;
- the shade under an explanation was a colour written at the call site.
  It is a name of the palette now, in both variants - its own name rather
  than the toolkit's Shadow, which this palette answers with nothing on
  purpose since 2026-08-24.

Run: the guards of the touched files and the cheap whole-tree gates (41),
gofmt, vet, lint, staticcheck.

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

---------

Co-authored-by: Claude Opus 5 <noreply@anthropic.com>

Author: donislawdev

CHANGELOG.md

@@ -16,6 +16,16 @@ because it turns other people's test suites red.
 
 ### Changed
 
+- **The window says where things begin and end.** Every field's name now
+  stands above its box rather than beside it, in a lighter ink than the
+  value under it, so a form reads as a column of named boxes. A section
+  draws a line round its edge again. Preview, Choose, Duplicate and Add a
+  batch stand on a surface of their own, brighter than a box to type in, so
+  a button no longer looks like a field. A folded block of settings inside
+  a section is titled at the rank of a subheading rather than a section, and
+  the pointer lights only its words rather than the whole row. A field's
+  explanation opens with an edge and a shadow, so it reads as something laid
+  over the form rather than a patch of it.
 - **Nine things the owner saw in the running window.** A field's
   explanation opens on the same raised surface as an open list, so it no
   longer lies flat on the section it covers. A list of formats keeps its

internal/guard/controlstates_test.go

@@ -271,8 +271,17 @@ func TestASecondaryButtonWearsAFaceAtRest(t *testing.T) {
 		return nil
 	}
 	rest := faceOf()
-	if want := parts.PaletteColour(theme.ColorNameInputBackground, theme.VariantDark); rest != want {
-		t.Errorf("at rest the face is %v and should be the surface of a box to type in, %v - an outline round nothing reads as a bordered word", rest, want)
+	// The button's own surface since 2026-09-21, and a step brighter than a
+	// box to type in: the owner's report from the running window was that a
+	// button wearing the field's surface read as a field. Asked as a
+	// relationship, not only as a name, so a palette edit that lowers the
+	// button under the field goes red here rather than on the screen.
+	if want := parts.PaletteColour(theme.ColorNameButton, theme.VariantDark); rest != want {
+		t.Errorf("at rest the face is %v and should be the button's own surface, %v - a button in the field's colour reads as a field", rest, want)
+	}
+	field := parts.PaletteColour(theme.ColorNameInputBackground, theme.VariantDark)
+	if gap := lightnessGap(rest, field); gap < 5 {
+		t.Errorf("the button's face is %.1f L* off a box to type in, and 5 is the least that tells a thing to press from a thing to type in", gap)
 	}
 	b.MouseIn(&desktop.MouseEvent{})
 	hovered := faceOf()

internal/guard/detailpopup_test.go

@@ -252,21 +252,37 @@ func TestTheExplanationFloatsOnTheSurfaceAnOpenListDoes(t *testing.T) {
 		t.Fatal("hovering the button put nothing on the sheet, so there is no box to measure")
 	}
 
-	var surface *canvas.Rectangle
+	// Two rectangles since 2026-09-21: the shade the box casts, then the
+	// surface it stands on. The owner's report from the running window was
+	// that a flat box with no edge read as a random rectangle, so the
+	// surface wears a line and a shade shows below it. Each is asked for by
+	// what it is rather than by its place in the tree.
+	var surface, shade *canvas.Rectangle
+	want := parts.PaletteColour(theme.ColorNameMenuBackground, theme.VariantDark)
 	walk(box, func(o fyne.CanvasObject) {
-		if rect, is := o.(*canvas.Rectangle); is && surface == nil {
+		rect, is := o.(*canvas.Rectangle)
+		if !is {
+			return
+		}
+		if rect.FillColor == want && surface == nil {
 			surface = rect
+		} else if _, _, _, a := rect.FillColor.RGBA(); a > 0 && a < 0xFFFF && shade == nil {
+			shade = rect
 		}
 	})
 	if surface == nil {
-		t.Fatal("the explanation's box draws no rectangle, so it stands on nothing this guard can measure")
-	}
-	want := parts.PaletteColour(theme.ColorNameMenuBackground, theme.VariantDark)
-	if surface.FillColor != want {
-		t.Errorf("the explanation stands on %v and an open list on %v - a box the colour of the panel it opens over has no edge anywhere",
-			surface.FillColor, want)
+		t.Fatal("the explanation's box draws no rectangle in the colour of an open list, so it stands on nothing that floats")
 	}
 	if surface.CornerRadius != parts.RadiusField {
 		t.Errorf("the explanation's corner is %.0f and a floating control's is %d", surface.CornerRadius, parts.RadiusField)
 	}
+	if surface.StrokeWidth == 0 {
+		t.Error("the explanation's surface has no line round it, which is the random rectangle the owner saw")
+	}
+	if shade == nil {
+		t.Error("the explanation casts no shade, so nothing says it lies over the form rather than in it")
+	} else if shade.Position().Y <= surface.Position().Y {
+		t.Errorf("the shade sits at y=%.0f and the surface at y=%.0f - a shade that is not below the box it belongs to reads as a smudge",
+			shade.Position().Y, surface.Position().Y)
+	}
 }

internal/guard/foldhead_test.go

@@ -197,6 +197,23 @@ func TestTheHeadRowDrawsItsStatesAndTheArrowFollows(t *testing.T) {
 	if want := parts.PaletteColour(theme.ColorNameHover, theme.VariantDark); back.FillColor != want {
 		t.Errorf("under the pointer the row's fill is %v, not the hover colour %v", back.FillColor, want)
 	}
+	// The fill is as wide as the words and no wider, since 2026-09-21: the
+	// owner's report from the running window was a hover the width of the
+	// form, which is enormous. The row is still the target - the head is as
+	// wide as the row - so the two widths are asked for apart: the head wide,
+	// its fill narrow.
+	// Bounded from both sides, after the outside review of #116: "narrower
+	// than the row" alone would have let a one pixel fill through. The fill
+	// has to be at least as wide as the title it lights, and narrower than
+	// the row it stands in.
+	title, ok := labelBox(fold.Object(), "Notes for the manifest")
+	if !ok {
+		t.Fatal("the fold's title is not on the screen, so there is nothing to measure the fill against")
+	}
+	if row, fill := head.Size().Width, back.Size().Width; fill >= row || fill < title.Width {
+		t.Errorf("under the pointer the fill is %.0f px wide, the title %.0f and the head %.0f - the fill has to cover the words and stop short of the row",
+			fill, title.Width, row)
+	}
 	if arrow.Resource.Name() == restingArrow {
 		t.Error("the arrow is inked the same under the pointer as at rest, so it does not follow the row")
 	}

internal/guard/guitext_test.go

@@ -108,6 +108,8 @@ var notWords = map[string]string{
 	`"%s: %w"`:        "how one error is wrapped around another, both already worded",
 	`"•"`:             "the marker in front of a list item, a shape rather than a word",
 	`"panel"`:         "our name for a colour, in the palette the toolkit asks by name",
+	`"label"`:         "our name for the ink of a field's name, a colour the palette holds",
+	`"tipshade"`:      "our name for the shade under an explanation, a colour the palette holds",
 	`"lift"`:          "our name for what the pointer does to the filled button, a colour the palette holds",
 	`"shade"`:         "our name for what a press does to the filled button, a colour the palette holds",
 	`"fyneDo"`:        "a migration flag the toolkit reads, never shown",

internal/guard/namescolumn_test.go

@@ -50,6 +50,21 @@ func TestThePaletteMeetsTheContrastItWasComputedFor(t *testing.T) {
 			}
 		}
 
+		// A field's name, since 2026-09-21 in an ink of its own a step under
+		// the value's, is still read - on the panel it stands on, which is
+		// lighter than the page and so the harder of the two.
+		panel := parts.PaletteColour(parts.ColorNamePanel, variant.v)
+		if got := contrast(parts.PaletteColour(parts.ColorNameLabel, variant.v), panel); got < 4.5 {
+			t.Errorf("%s: a field's name is %.2f:1 against the panel, under the 4.5 a reader needs", variant.name, got)
+		}
+		// And it is a step under the value, or the two inks are one ink with
+		// two names - the owner accepted the quieter name on 2026-09-21 and
+		// then asked for it brighter, so the step is small and it is asked
+		// for as a step rather than as a number.
+		if label, value := parts.PaletteColour(parts.ColorNameLabel, variant.v), parts.PaletteColour(theme.ColorNameForeground, variant.v); lightnessGap(label, value) < 3 {
+			t.Errorf("%s: a field's name is %.1f L* off the value under it, so nothing tells the name from the value", variant.name, lightnessGap(label, value))
+		}
+
 		// Recognised as a state: 3.0, from WCAG 1.4.11. What carries it is the
 		// LINE round a control - parts.Ring - and not the focus colour, which
 		// is a wash the toolkit lays over whatever the control already is.

internal/guard/palette_test.go

@@ -72,6 +72,24 @@ func TestNoSectionIsNamedAfterAFieldInsideIt(t *testing.T) {
 	}
 }
 
+// fieldNamesOn is every field name a screen draws, read off the fields
+// themselves - a field is the one container laid out as a field, and its
+// first thing is its name. Asked by the layout rather than by the weight of
+// the words, for the reason the guard above gives.
+func fieldNamesOn(screen fyne.CanvasObject) []string {
+	var out []string
+	walk(screen, func(obj fyne.CanvasObject) {
+		box, ok := obj.(*fyne.Container)
+		if !ok || !parts.IsField(box) || len(box.Objects) < 2 {
+			return
+		}
+		if name, named := headingOf(box.Objects[0]); named && name != "" {
+			out = append(out, name)
+		}
+	})
+	return out
+}
+
 // And the preset card still says what it is for.
 //
 // The half that stops the guard above being satisfied by deleting the title.

internal/guard/samename_test.go

@@ -65,28 +65,30 @@ func TestASectionDrawsItsOwnSurface(t *testing.T) {
 				subject.what, surface.FillColor, want)
 		}
 
-		// No line round it, and the protection that line used to give has moved
-		// rather than gone. Both halves matter and they are checked together.
+		// A line round it, since 2026-09-21, and the fill under it - both, and
+		// both are checked.
 		//
-		// It used to be drawn with one, because the fill on its own was 4.0 L*
-		// off the page - a surface you sense rather than see - and a panel with
-		// no boundary is where this started. What changed on 2026-08-23 is that
-		// the same one pixel line was also what every box to type in used to
-		// say "your value goes here". One mark meaning two things means
-		// neither, and the field is the one that needs it.
-		//
-		// So the fill has to do the work alone now, and that is asserted here
-		// rather than assumed: a border removed without lifting the surface
-		// would leave exactly the panel this file was written about.
-		if surface.StrokeWidth != 0 {
-			t.Errorf("%s draws a line round itself %.1f px wide.\n"+
-				"Reason: a border is what a box to type in uses, so a container wearing one makes the mark mean nothing.\n"+
-				"What to do: let the surface group by being a surface.", subject.what, surface.StrokeWidth)
+		// The line was taken away on 2026-08-23 on the argument that the same
+		// one pixel line was what a box to type in used to say "your value
+		// goes here", and a mark meaning two things means neither. The owner's
+		// report from the running window a month later was the other half of
+		// that trade: with the fill 5.9 L* off the page and nothing round it,
+		// the whole window ran together and nobody could tell where a section
+		// ended. The line is back on the owner's decision, in the separator's
+		// colour, and the field keeps its own edge in its own colour - two
+		// marks, two colours, and the surface still does its share.
+		if surface.StrokeWidth == 0 {
+			t.Errorf("%s draws no line round itself.\n"+
+				"Reason: the fill alone was measured at 5.9 L* off the page and read as nothing, 2026-09-21.\n"+
+				"What to do: stroke the surface in the separator's colour, one edge wide.", subject.what)
+		}
+		if want := parts.PaletteColour(theme.ColorNameSeparator, theme.VariantDark); surface.StrokeColor != want {
+			t.Errorf("%s draws its edge in %v and the palette says a separator is %v", subject.what, surface.StrokeColor, want)
 		}
 		page := parts.PaletteColour(theme.ColorNameBackground, theme.VariantDark)
 		if gap := lightnessGap(surface.FillColor, page); gap < 5 {
-			t.Errorf("%s is %.1f L* off the page with no line round it, and 5 is the least that reads as a surface.\n"+
-				"Reason: the edge used to carry this and no longer does, so the fill is all there is.", subject.what, gap)
+			t.Errorf("%s is %.1f L* off the page, and 5 is the least that reads as a surface even with a line round it.\n"+
+				"Reason: the line says where the edge is, the fill says there is a thing inside it.", subject.what, gap)
 		}
 	}
 }