fix(historian): #671 review — raw-row cap, reverse Interpolative, SDK status rule, Partial bit

M1: the time-weighted family (incl. Total, formerly a pushed-down SUM) streams
raw window rows into the C# evaluator. New shared knob
ServerHistorian:MaxTimeWeightedRawRows (default 1,000,000; <=0 unbounded with a
Validate warning) flows through HistorianBackendRegistry into both providers.
The window query is capped at cap+1 (SQL Server TOP (@maxRows), QuestDB LIMIT $4);
one row past the cap throws the new Core.Abstractions
HistoryReadLimitExceededException, which the node manager maps to
BadTooManyOperations for that node. Not counted as a backend health failure;
bound rows are not counted; per-sample aggregates are not capped.

M2: reverse Interpolative is anchored at the later time (Part 13): points at
End - i*interval, emitted latest first. 10:00->09:00 @1h yields 10:00.

L1: Partial bit (0x4, = Opc.Ua.AggregateBits.Partial) on non-Bad results of a
truncated last interval (time-weighted family; per-sample family is a follow-up).

L2/L3: aligned with the SDK AggregateCalculator.GetTimeBasedStatusCode
(decompiled from Opc.Ua.Server 1.5.378.106): TreatUncertainAsBad=false counts
Uncertain time (Uncertain samples, held-into-outage, extrapolation) as Good
time; data but no non-Bad time => generic Bad (0x80000000); BadNoData only
when there is no data at all. Consequence: a live tag's latest interval reads
Good (documented).

L5: release note no longer claims Total matches the Gateway Integral exactly
(AVEVA's divisor is unverified); it notes Total is now evaluated in C# and
subject to the cap.

Tests: unit (reverse Interpolative x3, Partial, Bad vs BadNoData incl. an
open-ended outage, cap helpers, SDK bit oracles); conformance (reverse
Interpolative, raw-row cap at/over/0, bounds not counted, health unaffected);
node manager BadTooManyOperations; options default + warning. Each new
behaviour falsified by mutation (aggregator x9, data-source cap checks on
both backends against the real DBs, node-manager catch).

tests/Server/ZB.MOM.WW.OtOpcUa.OpcUaServer.Tests/NodeManagerHistoryReadTests.cs

@@ -342,6 +342,28 @@ public sealed class NodeManagerHistoryReadTests : IDisposable
         await host.DisposeAsync();
     }
 
+    /// <summary>#671: a read past a backend size limit (the time-weighted raw-row cap) answers BadTooManyOperations
+    /// for that node (not the generic BadHistoryOperationUnsupported, nor a deadline BadTimeout).</summary>
+    [Fact]
+    public async Task Processed_limit_exceeded_yields_BadTooManyOperations()
+    {
+        var (host, server) = await BootAsync();
+        var nm = server.NodeManager!;
+        nm.HistorianDataSource = new RecordingHistorianDataSource { LimitExceeded = true };
+        nm.EnsureVariable("eq-1/cap", parentFolderNodeId: null, displayName: "C", dataType: "Float",
+            writable: false, historianTagname: "WW.Cap", realm: AddressSpaceRealm.Uns);
+        var nodeId = nm.TryGetVariable("eq-1/cap")!.NodeId;
+
+        var (_, errors) = InvokeHistoryRead(server, nm, new ReadProcessedDetails
+        {
+            StartTime = DateTime.UtcNow.AddHours(-1), EndTime = DateTime.UtcNow, ProcessingInterval = 10_000.0,
+            AggregateType = new NodeIdCollection { ObjectIds.AggregateFunction_Total },
+        }, nodeId);
+
+        errors[0].StatusCode.Code.ShouldBe(StatusCodes.BadTooManyOperations);
+        await host.DisposeAsync();
+    }
+
     /// <summary>AtTime read: the requested timestamps reach ReadAtTimeAsync in order.</summary>
     [Fact]
     public async Task AtTime_dispatches_requested_timestamps()
@@ -505,6 +527,7 @@ public sealed class NodeManagerHistoryReadTests : IDisposable
     {
         public bool ThrowOnRead { get; init; }
         public bool AggregateNotSupported { get; init; }
+        public bool LimitExceeded { get; init; }
         public HistorianRead RawResult { get; set; } = new(Array.Empty<DataValueSnapshot>(), null);
         public HistorianRead ProcessedResult { get; set; } = new(Array.Empty<DataValueSnapshot>(), null);
         public HistorianRead AtTimeResult { get; set; } = new(Array.Empty<DataValueSnapshot>(), null);
@@ -537,6 +560,7 @@ public sealed class NodeManagerHistoryReadTests : IDisposable
         {
             if (ThrowOnRead) throw new InvalidOperationException("backend boom");
             if (AggregateNotSupported) throw new HistoryAggregateNotSupportedException(aggregate);
+            if (LimitExceeded) throw new HistoryReadLimitExceededException(4, "too many raw rows");
             LastCall = "Processed";
             LastTagname = fullReference;
             LastStart = startUtc;

tests/Server/ZB.MOM.WW.OtOpcUa.Runtime.Tests/Historian/ServerHistorianOptionsTests.cs

@@ -89,6 +89,16 @@ public sealed class ServerHistorianOptionsTests
         Assert.Contains(w, m => m.Contains("HistoryReadDeadline"));
     }
 
+    [Fact]
+    public void MaxTimeWeightedRawRows_defaults_to_one_million_and_warns_when_nonpositive()
+    {
+        Assert.Equal(1_000_000, new ServerHistorianOptions().MaxTimeWeightedRawRows);
+        var w = new ServerHistorianOptions
+        { Enabled = true, Endpoint = "https://h:5222", ApiKey = "histgw_x_y", MaxTimeWeightedRawRows = 0 }
+            .Validate();
+        Assert.Contains(w, m => m.Contains("MaxTimeWeightedRawRows"));
+    }
+
     [Fact]
     public void Disabled_with_nonpositive_HistoryRead_knobs_is_silent()
     {