Add Equipment tab with profile creation, device discovery, and assignment

Full Equipment/Profile tab for tianwen-gui:
- No profile → E tab forced active, sidebar locks P/V/S tabs (dimmed)
- "Create Profile" button → text input for name → creates profile
- SDL3 text input lifecycle (StartTextInput/StopTextInput/TextInput events)
- Profile summary panel (360px left): mount, site, guider, OTA details
- Clickable slots → assignment mode → click device in list to assign
- Device list (fill right): type badge, display name, assigned checkmark
- [Discover] button triggers background device discovery
- [+ Add OTA] adds a new telescope to the profile
- All assignments auto-save via EquipmentActions (shared with CLI)

Also adds EquipmentActions to Abstractions for shared profile manipulation.

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

Author: sebgod

src/TianWen.UI.Abstractions/EquipmentActions.cs

@@ -0,0 +1,152 @@
+using System;
+using System.Collections.Immutable;
+using System.Globalization;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Web;
+using TianWen.Lib.Devices;
+using TianWen.Lib.Sequencing;
+
+namespace TianWen.UI.Abstractions;
+
+/// <summary>
+/// Pure functions for profile/equipment manipulation. Shared between CLI and GUI.
+/// All methods return new ProfileData (immutable record with-expressions).
+/// </summary>
+public static class EquipmentActions
+{
+    public static async Task<Profile> CreateProfileAsync(string name, IExternal external, CancellationToken ct)
+    {
+        var profile = new Profile(Guid.NewGuid(), name, ProfileData.Empty);
+        await profile.SaveAsync(external, ct);
+        return profile;
+    }
+
+    public static ProfileData AssignMount(ProfileData data, Uri mountUri)
+        => data with { Mount = mountUri };
+
+    public static ProfileData AssignGuider(ProfileData data, Uri guiderUri)
+        => data with { Guider = guiderUri };
+
+    public static ProfileData AssignGuiderCamera(ProfileData data, Uri cameraUri)
+        => data with { GuiderCamera = cameraUri };
+
+    public static ProfileData AssignGuiderFocuser(ProfileData data, Uri focuserUri)
+        => data with { GuiderFocuser = focuserUri };
+
+    public static ProfileData SetOagOtaIndex(ProfileData data, int otaIndex)
+        => data with { OAG_OTA_Index = otaIndex };
+
+    public static ProfileData SetSite(ProfileData data, double lat, double lon, double? elevation = null)
+    {
+        var query = HttpUtility.ParseQueryString(data.Mount.Query);
+        query[DeviceQueryKey.Latitude.Key] = lat.ToString(CultureInfo.InvariantCulture);
+        query[DeviceQueryKey.Longitude.Key] = lon.ToString(CultureInfo.InvariantCulture);
+        if (elevation.HasValue)
+        {
+            query[DeviceQueryKey.Elevation.Key] = elevation.Value.ToString(CultureInfo.InvariantCulture);
+        }
+        var builder = new UriBuilder(data.Mount) { Query = query.ToString() };
+        return data with { Mount = builder.Uri };
+    }
+
+    public static ProfileData AddOTA(ProfileData data, OTAData ota)
+        => data with { OTAs = data.OTAs.Add(ota) };
+
+    public static ProfileData RemoveOTA(ProfileData data, int index)
+        => index >= 0 && index < data.OTAs.Length
+            ? data with { OTAs = data.OTAs.RemoveAt(index) }
+            : data;
+
+    public static ProfileData AssignDeviceToOTA(ProfileData data, int otaIndex, DeviceType deviceType, Uri deviceUri)
+    {
+        if (otaIndex < 0 || otaIndex >= data.OTAs.Length)
+        {
+            return data;
+        }
+
+        var ota = data.OTAs[otaIndex];
+        var updated = deviceType switch
+        {
+            DeviceType.Camera => ota with { Camera = deviceUri },
+            DeviceType.Focuser => ota with { Focuser = deviceUri },
+            DeviceType.FilterWheel => ota with { FilterWheel = deviceUri },
+            DeviceType.CoverCalibrator => ota with { Cover = deviceUri },
+            _ => ota
+        };
+
+        return data with { OTAs = data.OTAs.SetItem(otaIndex, updated) };
+    }
+
+    /// <summary>
+    /// Checks if a device URI is assigned anywhere in the profile.
+    /// </summary>
+    public static bool IsDeviceAssigned(ProfileData data, Uri deviceUri)
+    {
+        if (data.Mount == deviceUri || data.Guider == deviceUri)
+        {
+            return true;
+        }
+        if (data.GuiderCamera == deviceUri || data.GuiderFocuser == deviceUri)
+        {
+            return true;
+        }
+
+        foreach (var ota in data.OTAs)
+        {
+            if (ota.Camera == deviceUri || ota.Focuser == deviceUri ||
+                ota.FilterWheel == deviceUri || ota.Cover == deviceUri)
+            {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /// <summary>
+    /// Returns a human-readable label for a device URI, using the registry if available.
+    /// </summary>
+    public static string DeviceLabel(Uri? uri, IDeviceUriRegistry? registry)
+    {
+        if (uri is null || uri == NoneDevice.Instance.DeviceUri)
+        {
+            return "(none)";
+        }
+
+        if (registry is not null && registry.TryGetDeviceFromUri(uri, out var device))
+        {
+            return device.DisplayName;
+        }
+
+        // Fallback: extract from URI path
+        var path = uri.AbsolutePath.TrimStart('/');
+        return path.Length > 0 ? path : uri.ToString();
+    }
+
+    /// <summary>
+    /// Extracts site coordinates from a mount URI, if present.
+    /// </summary>
+    public static (double Lat, double Lon, double? Elev)? GetSiteFromMount(Uri mountUri)
+    {
+        if (mountUri == NoneDevice.Instance.DeviceUri)
+        {
+            return null;
+        }
+
+        var query = HttpUtility.ParseQueryString(mountUri.Query);
+        var latStr = query[DeviceQueryKey.Latitude.Key];
+        var lonStr = query[DeviceQueryKey.Longitude.Key];
+        var elevStr = query[DeviceQueryKey.Elevation.Key];
+
+        if (latStr is not null && lonStr is not null &&
+            double.TryParse(latStr, CultureInfo.InvariantCulture, out var lat) &&
+            double.TryParse(lonStr, CultureInfo.InvariantCulture, out var lon))
+        {
+            double? elev = elevStr is not null && double.TryParse(elevStr, CultureInfo.InvariantCulture, out var e) ? e : null;
+            return (lat, lon, elev);
+        }
+
+        return null;
+    }
+}

src/TianWen.UI.Gui/EquipmentTabState.cs

@@ -0,0 +1,55 @@
+using System.Collections.Generic;
+using TianWen.Lib.Devices;
+using TianWen.UI.Abstractions;
+
+namespace TianWen.UI.Gui;
+
+/// <summary>
+/// State for the Equipment/Profile tab.
+/// </summary>
+public class EquipmentTabState
+{
+    // Profile creation
+    public bool IsCreatingProfile { get; set; }
+    public TextInputState ProfileNameInput { get; } = new() { Placeholder = "Enter profile name..." };
+
+    // Device discovery
+    public IReadOnlyList<DeviceBase> DiscoveredDevices { get; set; } = [];
+    public bool IsDiscovering { get; set; }
+
+    // Assignment mode: when non-null, clicking a device in the list assigns it to this slot
+    public AssignTarget? ActiveAssignment { get; set; }
+
+    // Scrolling
+    public int DeviceScrollOffset { get; set; }
+    public int ProfileScrollOffset { get; set; }
+
+    // Profile list (for multi-profile picker)
+    public IReadOnlyList<Profile> AllProfiles { get; set; } = [];
+}
+
+/// <summary>
+/// Identifies a slot in a profile that a device can be assigned to.
+/// </summary>
+public abstract record AssignTarget
+{
+    /// <summary>A profile-level slot (Mount, Guider, GuiderCamera, GuiderFocuser).</summary>
+    public sealed record ProfileLevel(string Field) : AssignTarget;
+
+    /// <summary>A per-OTA slot (Camera, Focuser, FilterWheel, Cover).</summary>
+    public sealed record OTALevel(int OtaIndex, string Field) : AssignTarget;
+
+    /// <summary>Returns the DeviceType expected for this slot.</summary>
+    public DeviceType ExpectedDeviceType => this switch
+    {
+        ProfileLevel { Field: "Mount" } => DeviceType.Mount,
+        ProfileLevel { Field: "Guider" } => DeviceType.Guider,
+        ProfileLevel { Field: "GuiderCamera" } => DeviceType.Camera,
+        ProfileLevel { Field: "GuiderFocuser" } => DeviceType.Focuser,
+        OTALevel { Field: "Camera" } => DeviceType.Camera,
+        OTALevel { Field: "Focuser" } => DeviceType.Focuser,
+        OTALevel { Field: "FilterWheel" } => DeviceType.FilterWheel,
+        OTALevel { Field: "Cover" } => DeviceType.CoverCalibrator,
+        _ => DeviceType.Unknown
+    };
+}