feat(anchor): manual chain length feeds the Auto radius

Sailors had no way to tell the plotter how much rode they let out, so
Auto could only react to swing the boat had already done - on a calm
set the boat sits over its anchor and Auto under-reads the radius it
will need once the wind fills in.

Add a Chain field to the Set Radius panel (persisted as a setting).
Auto now floors the swing term with the chain's horizontal projection
at the current depth - AnchorRadiusHeuristic.ChainHorizontalProjection
= sqrt(rode^2 - depth^2), with conservative fallbacks (full rode when
depth is unknown, zero when the rode is shorter than the depth). The
breakdown labels the term "rode" when the chain projection dominates,
"swing"/"current" otherwise, so the helm can see which input drove the
number.

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

Author: msallin

OnaPlotter.Tests/AnchorRadiusHeuristicTests.cs

@@ -291,4 +291,73 @@ public async Task Suggest_AcrossDepthRange_AlwaysInClampBounds()
             await Assert.That(got).IsLessThanOrEqualTo(AnchorRadiusHeuristic.MaxSuggestedMeters);
         }
     }
+
+    // --- ChainHorizontalProjection -----------------------------------
+    // Taut-rode horizontal reach: sqrt(rode^2 - depth^2), with
+    // conservative fallbacks. Feeds the Auto-radius chain floor.
+
+    [Test]
+    public async Task ChainProjection_RodeAndDepth_ReturnsPythagoreanLeg()
+    {
+        // 3-4-5: 5 m rode, 3 m depth -> 4 m horizontal. Exact integer
+        // triangle so the assert needs no tolerance.
+        await Assert.That(AnchorRadiusHeuristic.ChainHorizontalProjection(5, 3)).IsEqualTo(4.0);
+        // Realistic anchorage: 40 m rode, 8 m depth.
+        await Assert.That(AnchorRadiusHeuristic.ChainHorizontalProjection(40, 8))
+            .IsEqualTo(Math.Sqrt(40 * 40 - 8 * 8));
+    }
+
+    [Test]
+    public async Task ChainProjection_NullDepth_ReturnsFullRode_Conservative()
+    {
+        // No depth -> assume rode lying flat (max horizontal reach).
+        // Over-estimating the radius is the safe direction.
+        await Assert.That(AnchorRadiusHeuristic.ChainHorizontalProjection(40, null)).IsEqualTo(40.0);
+    }
+
+    [Test]
+    public async Task ChainProjection_UnusableDepth_ReturnsFullRode()
+    {
+        // Non-positive / non-finite depth routes to the same
+        // conservative full-rode fallback as null.
+        await Assert.That(AnchorRadiusHeuristic.ChainHorizontalProjection(40, 0)).IsEqualTo(40.0);
+        await Assert.That(AnchorRadiusHeuristic.ChainHorizontalProjection(40, -5)).IsEqualTo(40.0);
+        await Assert.That(AnchorRadiusHeuristic.ChainHorizontalProjection(40, double.NaN)).IsEqualTo(40.0);
+        await Assert.That(AnchorRadiusHeuristic.ChainHorizontalProjection(40, double.PositiveInfinity)).IsEqualTo(40.0);
+    }
+
+    [Test]
+    public async Task ChainProjection_RodeShorterThanDepth_ReturnsZero()
+    {
+        // Sub-1:1 scope: the rode is effectively vertical, no
+        // meaningful horizontal reach. Boundary rode == depth also
+        // collapses to 0.
+        await Assert.That(AnchorRadiusHeuristic.ChainHorizontalProjection(5, 8)).IsEqualTo(0.0);
+        await Assert.That(AnchorRadiusHeuristic.ChainHorizontalProjection(8, 8)).IsEqualTo(0.0);
+    }
+
+    [Test]
+    public async Task ChainProjection_NoRode_ReturnsZero()
+    {
+        // Rode <= 0 / NaN / Infinity -> the chain term simply doesn't
+        // contribute (and never feeds NaN into the caller's max()).
+        await Assert.That(AnchorRadiusHeuristic.ChainHorizontalProjection(0, 8)).IsEqualTo(0.0);
+        await Assert.That(AnchorRadiusHeuristic.ChainHorizontalProjection(-10, 8)).IsEqualTo(0.0);
+        await Assert.That(AnchorRadiusHeuristic.ChainHorizontalProjection(double.NaN, 8)).IsEqualTo(0.0);
+        await Assert.That(AnchorRadiusHeuristic.ChainHorizontalProjection(double.PositiveInfinity, 8)).IsEqualTo(0.0);
+    }
+
+    [Test]
+    public async Task ChainProjection_AlwaysLessThanOrEqualRode()
+    {
+        // Invariant: the horizontal leg never exceeds the hypotenuse
+        // (the rode). Sweep depths for a fixed rode.
+        const double rode = 50;
+        for (double d = 0.5; d < rode + 10; d += 0.5)
+        {
+            double proj = AnchorRadiusHeuristic.ChainHorizontalProjection(rode, d);
+            await Assert.That(proj).IsGreaterThanOrEqualTo(0.0);
+            await Assert.That(proj).IsLessThanOrEqualTo(rode);
+        }
+    }
 }

OnaPlotter.Tests/AppSettingsServiceTests.cs

@@ -428,6 +428,27 @@ public async Task TcpaAlarmMin_RoundTrip()
         await Assert.That(svc2.TcpaAlarmMin).IsEqualTo(15);
     }
 
+    [Test]
+    public async Task AnchorChainLength_RoundTrip_AndClampsNegativeToZero()
+    {
+        var kv = new InMemoryKv();
+        var svc = new AppSettingsService(kv);
+        await svc.InitializeAsync();
+
+        // Default is 0 ("not entered").
+        await Assert.That(svc.AnchorChainLengthMeters).IsEqualTo(0.0);
+
+        await svc.SetAnchorChainLengthMetersAsync(45);
+        var svc2 = new AppSettingsService(kv);
+        await svc2.InitializeAsync();
+        await Assert.That(svc2.AnchorChainLengthMeters).IsEqualTo(45.0);
+
+        // Negative input clamps to 0 (a length can't be negative, and
+        // it must not feed a NaN into the chain-projection sqrt).
+        await svc2.SetAnchorChainLengthMetersAsync(-10);
+        await Assert.That(svc2.AnchorChainLengthMeters).IsEqualTo(0.0);
+    }
+
     [Test]
     public async Task EnabledRoutes_Overwrite()
     {

OnaPlotter.Tests/Components/AnchorEditPanelTests.cs

@@ -62,7 +62,9 @@ private static IRenderedComponent<AnchorEditPanel> RenderSetRadius(
         bool initialPickIsAuto = false,
         bool canMove = false,
         bool moveActive = false,
-        Action<bool>? onToggleMove = null)
+        Action<bool>? onToggleMove = null,
+        int chainLengthMeters = 0,
+        Action<int>? onChainLengthChanged = null)
     {
         return ctx.RenderComponent<AnchorEditPanel>(p => p
             .Add(x => x.Mode, AnchorEditPanel.AnchorPanelMode.SetRadius)
@@ -74,8 +76,11 @@ private static IRenderedComponent<AnchorEditPanel> RenderSetRadius(
             .Add(x => x.AutoBreakdown, autoBreakdown)
             .Add(x => x.CanMove, canMove)
             .Add(x => x.MoveActive, moveActive)
+            .Add(x => x.ChainLengthMeters, chainLengthMeters)
             .Add(x => x.OnToggleMove, Microsoft.AspNetCore.Components.EventCallback.Factory
                 .Create<bool>(p, v => onToggleMove?.Invoke(v)))
+            .Add(x => x.OnChainLengthChanged, Microsoft.AspNetCore.Components.EventCallback.Factory
+                .Create<int>(p, v => onChainLengthChanged?.Invoke(v)))
             .Add(x => x.OnPreviewRadius, Microsoft.AspNetCore.Components.EventCallback.Factory
                 .Create<int>(p, r => onPreviewRadius?.Invoke(r)))
             // Most existing tests only care about the radius value; surface
@@ -854,6 +859,77 @@ public async Task SetRadiusMode_MoveButton_Busy_DoesNotToggle()
         await Assert.That(toggles).IsEmpty();
     }
 
+    // ---- Chain / rode length input ----
+
+    [Test]
+    public async Task SetRadiusMode_ChainInput_Renders()
+    {
+        using var ctx = new Bunit.TestContext();
+        var cut = RenderSetRadius(ctx, initial: 30);
+
+        await Assert.That(cut.FindAll(".anchor-edit-chain-input").Count).IsEqualTo(1);
+    }
+
+    [Test]
+    public async Task SetRadiusMode_ChainInput_ShowsValueWhenSet_BlankWhenZero()
+    {
+        using var ctx = new Bunit.TestContext();
+
+        var withChain = RenderSetRadius(ctx, initial: 30, chainLengthMeters: 40);
+        await Assert.That(withChain.Find(".anchor-edit-chain-input").GetAttribute("value"))
+            .IsEqualTo("40");
+
+        var noChain = RenderSetRadius(ctx, initial: 30, chainLengthMeters: 0);
+        await Assert.That(noChain.Find(".anchor-edit-chain-input").GetAttribute("value"))
+            .IsEqualTo("");
+    }
+
+    [Test]
+    public async Task SetRadiusMode_ChainInput_Change_FiresParsedValue()
+    {
+        using var ctx = new Bunit.TestContext();
+        var changes = new List<int>();
+        var cut = RenderSetRadius(ctx, initial: 30, onChainLengthChanged: v => changes.Add(v));
+
+        cut.Find(".anchor-edit-chain-input").Change("45");
+
+        await Assert.That(changes).IsEquivalentTo([45]);
+    }
+
+    [Test]
+    public async Task SetRadiusMode_ChainInput_EmptyOrInvalid_FiresZero()
+    {
+        // Cleared field / non-numeric collapses to 0 ("not entered")
+        // rather than throwing or leaving a stale value.
+        using var ctx = new Bunit.TestContext();
+        var changes = new List<int>();
+        var cut = RenderSetRadius(ctx, initial: 30, chainLengthMeters: 40,
+            onChainLengthChanged: v => changes.Add(v));
+
+        cut.Find(".anchor-edit-chain-input").Change("");
+        await Assert.That(changes).IsEquivalentTo([0]);
+    }
+
+    [Test]
+    public async Task SetRadiusMode_ChainInput_Busy_Disabled()
+    {
+        using var ctx = new Bunit.TestContext();
+        var cut = RenderSetRadius(ctx, initial: 30, busy: true);
+
+        await Assert.That(cut.Find(".anchor-edit-chain-input").HasAttribute("disabled")).IsTrue();
+    }
+
+    [Test]
+    public async Task DropMode_NoChainInput()
+    {
+        // Chain entry only makes sense once the radius decision is in
+        // play; Drop mode stays minimal.
+        using var ctx = new Bunit.TestContext();
+        var cut = RenderDrop(ctx);
+
+        await Assert.That(cut.FindAll(".anchor-edit-chain-input").Count).IsEqualTo(0);
+    }
+
     // ---- External InitialRadiusMeters changes (server delta echo) ----
 
     [Test]

OnaPlotter.Tests/FakeSettings.cs

@@ -58,6 +58,7 @@ internal sealed class FakeSettings : IAppSettings
     public double AnchorTideSafetyMargin { get; set; } = 1.0;
     public double AnchorAutoRadiusSafetyMargin { get; set; } = 5.0;
     public double ManualAnchorRadiusMeters { get; set; } = 30.0;
+    public double AnchorChainLengthMeters { get; set; } = 0.0;
     public double DeadmanTimeoutMinutes { get; set; } = 0.0;
     public double DeadmanNightMinutes { get; set; } = 15.0;
     public int SnoozeDurationMinutes { get; set; } = 10;
@@ -189,6 +190,7 @@ public Task ApplyMobileFirstRunDefaultsAsync(bool isMobile)
     public Task SetAnchorTideSafetyMarginAsync(double v) => Task.CompletedTask;
     public Task SetAnchorAutoRadiusSafetyMarginAsync(double v) { AnchorAutoRadiusSafetyMargin = v; return Task.CompletedTask; }
     public Task SetManualAnchorRadiusMetersAsync(double v) => Task.CompletedTask;
+    public Task SetAnchorChainLengthMetersAsync(double v) { AnchorChainLengthMeters = Math.Max(0, v); return Task.CompletedTask; }
     public Task SetDeadmanTimeoutMinutesAsync(double v) { DeadmanTimeoutMinutes = v; return Task.CompletedTask; }
     public Task SetDeadmanNightMinutesAsync(double v) { DeadmanNightMinutes = v; return Task.CompletedTask; }
     public Task SetSnoozeDurationMinutesAsync(int v) { SnoozeDurationMinutes = v; return Task.CompletedTask; }

OnaPlotter/Components/Map/AnchorEditPanel.razor

@@ -93,6 +93,24 @@
             }
         </div>
 
+        @* Chain / rode length. Feeds the Auto radius (the chain's
+           horizontal projection at the current depth floors the swing
+           term), so the helm entering "we let out 40 m" makes Auto
+           account for how far the boat CAN swing before it actually
+           has. Persisted parent-side; blank = not entered. Plain
+           on-change (blur / Enter) avoids a PUT-storm per keystroke. *@
+        <label class="anchor-edit-chain"
+               title="Deployed chain / rode length - feeds the Auto radius">
+            <span class="anchor-edit-chain-label">Chain</span>
+            <input type="number" inputmode="numeric" min="0" max="300" step="5"
+                   class="anchor-edit-chain-input"
+                   value="@(ChainLengthMeters > 0 ? ChainLengthMeters.ToString() : "")"
+                   placeholder="&ndash;"
+                   @onchange="OnChainInputChanged"
+                   disabled="@Busy" />
+            <span class="hud-unit">m</span>
+        </label>
+
         @* Move toggles the on-map drag handle so the helm can nudge
            the pin onto the actual lie of the chain (the plugin
            captures GPS at drop time, which can be a boat-length off).
@@ -284,6 +302,19 @@
     /// PUT itself rides along with the radius on Set.</summary>
     [Parameter] public EventCallback<bool> OnToggleMove { get; set; }
 
+    /// <summary>Helm-entered deployed chain / rode length (metres),
+    /// parent-owned (persisted in settings). 0 renders the input blank
+    /// ("not entered"). Feeds the parent's Auto radius computation -
+    /// the panel just surfaces the field + relays edits.</summary>
+    [Parameter] public int ChainLengthMeters { get; set; }
+
+    /// <summary>Helm edited the chain field. Carries the parsed whole-
+    /// metre value (0 when cleared / invalid). Parent persists it and
+    /// recomputes the Auto radius; the new <see cref="AutoPreviewRadius"/>
+    /// flows back and, when Auto is the active pick, re-previews the
+    /// on-map ring.</summary>
+    [Parameter] public EventCallback<int> OnChainLengthChanged { get; set; }
+
     /// <summary>Helm-tunable anchor-radius presets (metres). 150 m
     /// dropped from the v1 set on field-study feedback - 5:1 scope
     /// at 30 m of water is already 150 m and that's deeper than the
@@ -459,6 +490,24 @@
         await OnToggleMove.InvokeAsync(!MoveActive);
     }
 
+    /// <summary>Parse the chain field and relay the whole-metre value
+    /// to the parent. Empty / non-numeric / negative all collapse to
+    /// 0 ("not entered"), which the heuristic treats as "no chain
+    /// term". Invariant parse so a comma-decimal locale on the number
+    /// input doesn't mis-read the digits.</summary>
+    private async Task OnChainInputChanged(ChangeEventArgs e)
+    {
+        if (Busy) return;
+        var raw = e.Value?.ToString();
+        if (!int.TryParse(raw, System.Globalization.NumberStyles.Integer,
+                System.Globalization.CultureInfo.InvariantCulture, out int meters)
+            || meters < 0)
+        {
+            meters = 0;
+        }
+        await OnChainLengthChanged.InvokeAsync(meters);
+    }
+
     private async Task OnCancelClicked()
     {
         if (Busy) return;