Nine things a domain kept having to invent

Every change here started life as a workaround in a game and is really
the same finding: a fact about an entity had nowhere to live, so the
domain built machinery around the gap.

  Character.Label / Character.Voice — a tape is a character that speaks
  into the log, not a second spelling of Say. VoiceOf and CharacterLabel
  read them; Say obeys them.

  Game.Do — a real action queue, in order, so a widget can start an
  action. queueAction no longer drops what arrives while the runner is
  busy; it queues it.

  Widget.When + Gated + WidgetVisible — a widget declares when it is on
  screen. Nothing ticks, draws or blocks a click while its condition is
  false, so a HUD is hidden for a cutscene without a wrapper per widget.

  TopBar.NoteVar — the title was already discovered; the note beside it
  no longer needs a domain widget to push it in.

  Game.UseWithFail — the pair nobody authored is content, and belongs to
  the domain, exactly like ExitLook and ExitTake.

  Game.Player / Game.Walkboxes — a scene that names no cast and no floor
  means "the usual", instead of a defaults pass rewriting every scene.

  Game.WindowScale — Run's 4× is now a default, not a decision.

  SceneNav — the dev widget every game was writing.

  Colour text: DrawText paints in the colour it is handed, and GlyphW/H,
  TextWidth, WrapText and ClipText are the library's, not each game's.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

ui.widget.go

@@ -54,6 +54,25 @@ type Layered interface {
 	Layer() Layer
 }
 
+// Gated is implemented by a widget that can be switched off by game
+// state — every built-in is, through its When field. A widget that does
+// not implement it, or whose condition is nil, is always live.
+type Gated interface {
+	VisibleWhen() Condition
+}
+
+// WidgetVisible reports whether a widget takes part in this frame at all.
+// A widget switched off neither ticks nor draws, and does not block a
+// click, so a HUD can be hidden for a cutscene without unregistering it.
+func WidgetVisible(ctx *Ctx, w Widget) bool {
+	g, ok := w.(Gated)
+	if !ok {
+		return true
+	}
+	c := g.VisibleWhen()
+	return c == nil || c.Eval(ctx)
+}
+
 // LayerOf reports the layer a widget paints on. A wrapper widget that
 // forwards to an inner one — a visibility gate, say — should return
 // LayerOf(inner) so that wrapping does not move the widget.