feat(ui): D.2b — toolbar collapse-to-one-row (bottom-edge snap resize hides/shows row 2)

UiElement.MaxHeight + ResizableEdges mask; UiCollapsibleFrame snaps height to the nearer
of {collapsed,expanded} and toggles row-2 visibility; GameWindow computes the two heights
from the layout + top-anchors the content. Amends IA-17. UiNineSlicePanel unsealed to
allow subclassing.

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

src/AcDream.App/UI/UiCollapsibleFrame.cs

@@ -0,0 +1,36 @@
+using System;
+using System.Collections.Generic;
+
+namespace AcDream.App.UI;
+
+/// <summary>
+/// A toolbar-frame variant that snaps its height between two stops — collapsed (row 2 hidden) and
+/// expanded (row 2 shown) — and toggles a set of "second-row" elements to match. Resized via the
+/// bottom edge (the mount sets <see cref="UiElement.ResizableEdges"/> = Bottom); each tick it resolves
+/// the dragged height to the nearer stop so the frame always rests collapsed or expanded — never a
+/// half-row. Toolkit UX (keystone.dll has no decomp; the dat stacks both rows always) — see IA-17.
+/// </summary>
+public sealed class UiCollapsibleFrame : UiNineSlicePanel
+{
+    public UiCollapsibleFrame(Func<uint, (uint, int, int)> resolve) : base(resolve) { }
+
+    public float CollapsedHeight { get; set; }
+    public float ExpandedHeight  { get; set; }
+    /// <summary>Elements shown only when expanded (the row-2 slot lists). Hidden when collapsed.</summary>
+    public IReadOnlyList<UiElement> SecondRow { get; set; } = Array.Empty<UiElement>();
+
+    /// <summary>True when the frame is at (or nearer) the expanded stop.</summary>
+    public bool IsExpanded => Height >= (CollapsedHeight + ExpandedHeight) * 0.5f;
+
+    protected override void OnTick(double deltaSeconds)
+    {
+        base.OnTick(deltaSeconds);
+        if (ExpandedHeight <= CollapsedHeight) return;   // not configured yet — no snap
+        bool expanded = IsExpanded;
+        Height = expanded ? ExpandedHeight : CollapsedHeight;   // snap the dragged height to a stop
+        for (int i = 0; i < SecondRow.Count; i++) SecondRow[i].Visible = expanded;
+    }
+
+    /// <summary>Test hook — OnTick is protected. Drives one snap+visibility reconcile.</summary>
+    internal void TickForTest(double dt) => OnTick(dt);
+}

src/AcDream.App/UI/UiElement.cs

@@ -125,11 +125,19 @@ public abstract class UiElement
     public float MinWidth { get; set; } = 40f;
     public float MinHeight { get; set; } = 40f;
 
+    /// <summary>Maximum height enforced while resizing (default unbounded). Pairs with MinHeight.</summary>
+    public float MaxHeight { get; set; } = float.MaxValue;
+
     /// <summary>Allow horizontal (width) resize. Ignored unless <see cref="Resizable"/>.</summary>
     public bool ResizeX { get; set; } = true;
     /// <summary>Allow vertical (height) resize. Ignored unless <see cref="Resizable"/>.</summary>
     public bool ResizeY { get; set; } = true;
 
+    /// <summary>Which edges may start a resize, beyond the ResizeX/ResizeY axis gates. Default: all.
+    /// Set to e.g. <see cref="ResizeEdges.Bottom"/> to allow only a bottom-edge drag (the collapse toolbar).</summary>
+    public ResizeEdges ResizableEdges { get; set; } =
+        ResizeEdges.Left | ResizeEdges.Right | ResizeEdges.Top | ResizeEdges.Bottom;
+
     /// <summary>Edges this element anchors to in its parent. Default Left|Top
     /// (pinned top-left, fixed size — no reflow). Left|Right stretches width.</summary>
     public AnchorEdges Anchors { get; set; } = AnchorEdges.Left | AnchorEdges.Top;

src/AcDream.App/UI/UiNineSlicePanel.cs

@@ -10,7 +10,7 @@ namespace AcDream.App.UI;
 /// the widget is testable without GL. In production:
 /// <c>id => { var t = cache.GetOrUploadRenderSurface(id, out var w, out var h); return (t, w, h); }</c>.
 /// </summary>
-public sealed class UiNineSlicePanel : UiPanel
+public class UiNineSlicePanel : UiPanel
 {
     /// <summary>A placed chrome piece: destination rect in local pixel space.</summary>
     public readonly record struct Rect(float X, float Y, float W, float H);

src/AcDream.App/UI/UiRoot.cs

@@ -176,7 +176,8 @@ public sealed class UiRoot : UiElement
             var (nx, ny, nw, nh) = ResizeRect(
                 _resizeStartX, _resizeStartY, _resizeStartW, _resizeStartH,
                 _resizeEdges, x - _resizeMouseX, y - _resizeMouseY,
-                _resizeTarget.MinWidth, _resizeTarget.MinHeight);
+                _resizeTarget.MinWidth, _resizeTarget.MinHeight,
+                float.MaxValue, _resizeTarget.MaxHeight);
             _resizeTarget.Left = nx; _resizeTarget.Top = ny;
             _resizeTarget.Width = nw; _resizeTarget.Height = nh;
             return;
@@ -626,21 +627,23 @@ public sealed class UiRoot : UiElement
         if (System.Math.Abs(y - b) <= grip) e |= ResizeEdges.Bottom;
         if (!w.ResizeX) e &= ~(ResizeEdges.Left | ResizeEdges.Right);
         if (!w.ResizeY) e &= ~(ResizeEdges.Top | ResizeEdges.Bottom);
+        e &= w.ResizableEdges;
         return e;
     }
 
     /// <summary>Compute a resized rect from a start rect + drag delta + which edges,
-    /// clamping to (<paramref name="minW"/>,<paramref name="minH"/>). Left/Top edges
-    /// move the origin so the opposite edge stays put.</summary>
+    /// clamping to (<paramref name="minW"/>,<paramref name="minH"/>) and
+    /// (<paramref name="maxW"/>,<paramref name="maxH"/>). Left/Top edges move the
+    /// origin so the opposite edge stays put.</summary>
     public static (float x, float y, float w, float h) ResizeRect(
         float startX, float startY, float startW, float startH,
-        ResizeEdges edges, float dx, float dy, float minW, float minH)
+        ResizeEdges edges, float dx, float dy, float minW, float minH, float maxW, float maxH)
     {
         float x = startX, y = startY, w = startW, h = startH;
-        if ((edges & ResizeEdges.Right) != 0) w = System.Math.Max(minW, startW + dx);
-        if ((edges & ResizeEdges.Bottom) != 0) h = System.Math.Max(minH, startH + dy);
-        if ((edges & ResizeEdges.Left) != 0) { float nw = System.Math.Max(minW, startW - dx); x = startX + (startW - nw); w = nw; }
-        if ((edges & ResizeEdges.Top) != 0) { float nh = System.Math.Max(minH, startH - dy); y = startY + (startH - nh); h = nh; }
+        if ((edges & ResizeEdges.Right) != 0) w = System.Math.Clamp(startW + dx, minW, maxW);
+        if ((edges & ResizeEdges.Bottom) != 0) h = System.Math.Clamp(startH + dy, minH, maxH);
+        if ((edges & ResizeEdges.Left) != 0) { float nw = System.Math.Clamp(startW - dx, minW, maxW); x = startX + (startW - nw); w = nw; }
+        if ((edges & ResizeEdges.Top) != 0) { float nh = System.Math.Clamp(startH - dy, minH, maxH); y = startY + (startH - nh); h = nh; }
         return (x, y, w, h);
     }