EW 2 fix: the enemy schematic's rows, claimed class and range label are derived in ServerShared

Entity.SchematicRows(subject) owns which weapon rows a schematic shows, each row's item and
claimed design, and its range (own ship: live; any other: the claimed design's rated range).
SchematicDisplay renders SchematicRow and decides nothing. Headless tests cover default-to-truth,
a weapon claimed as another weapon, a weapon claimed as a non-weapon, own rows, and the rebuild key.

Builds on the Shared side not yet verified at this commit.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Assets/Scripts/ServerShared/Entity.cs

@@ -985,6 +985,15 @@ public abstract class Entity
         RevealsOf(subject).Where(r => r.Claimed != null && r.Claimed.Behaviors.Any(b => b is WeaponData))
             .OrderBy(r => subject.Equipment.IndexOf(r.Item));
 
+    // The weapon rows of `subject`'s schematic as this ship reads it: its own equipment when `subject` is this ship (each
+    // row its own data and live range, nothing to doubt about your own ship), otherwise RevealedWeapons (each row the
+    // claimed class and that design's rated range). The one owner of which rows, which class and which range an
+    // enemy schematic shows; the Unity SchematicDisplay renders it.
+    public IEnumerable<SchematicRow> SchematicRows(Entity subject) =>
+        subject == this
+            ? subject.Equipment.Where(i => i.Behaviors.Any(b => b.Data is WeaponData)).Select(i => new SchematicRow(i, i.Data, true))
+            : RevealedWeapons(subject).Select(r => new SchematicRow(r.Item, r.Claimed, false));
+
     // Whether this observer's book for `subject` holds `item`: the book's membership, no live gear read.
     internal bool HasReveal(Entity subject, EquippedItem item) =>
         _reveals.TryGetValue(subject, out var book) && book.ContainsKey(item);

Assets/Scripts/ServerShared/Sensing.cs

@@ -2,6 +2,7 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
+using System.Linq;
 using CultMath;
 
 // Light signatures split by channel (ruling visibility-per-capability-reveal): an observer learns what a ship
@@ -118,6 +119,32 @@ public readonly struct Reveal
     }
 }
 
+// One weapon row of a ship's schematic as its viewer is entitled to read it (aetheria-ew, classify-from-belief; ruling
+// ew-claim-weapon-measure-ruled). Made only by Entity.SchematicRows. `Item` is the true item: the selection mark's key and,
+// on the viewer's own ship, the live gear. `Claimed` is the class the row shows. The range label is the live range on
+// the viewer's own ship and the claimed design's rated range on any other; the viewer never sees a target weapon's
+// quality, wear or power. A renderer shows these and decides nothing.
+public readonly struct SchematicRow
+{
+    public readonly EquippedItem Item;
+    public readonly EquippableItemData Claimed;
+    private readonly bool _own;
+
+    internal SchematicRow(EquippedItem item, EquippableItemData claimed, bool own)
+    {
+        Item = item;
+        Claimed = claimed;
+        _own = own;
+    }
+
+    // What a renderer compares to know the rows changed. Range is a reading, not part of the key.
+    public (EquippedItem, EquippableItemData) Key => (Item, Claimed);
+
+    public float Range => _own
+        ? Item.Behaviors.OfType<Weapon>().First().Range
+        : Claimed.Behaviors.OfType<WeaponData>().First().RatedRange;
+}
+
 // A subject's removal from a zone as the zone recorded it (death, dock, warp, any removal): where it was and how
 // bright its light was (its Visibility at removal). Judged by each observer's Sense under the
 // light-act gate; notification only, one tick long, it decides nothing.