0.8.35 - say what looted gear is typically worth

The Loot page listed what was picked up and where, and said nothing about
value. The join needed already existed - the stash prices items by taking the
item class to a community entry and its uuid to UEX - so this is that same hop
at the loot endpoint.

The number is the median across every terminal stocking the item, not
UexData.ItemPrice, which is documented as the cheapest. The two answer
different questions and on this install they differ tenfold: the MaxLift
Tractor Beam is stocked near 19,175 by about a hundred terminals and at 1,975
by one, so the cheapest reads as a tenth of what the thing is worth. A mean
would still be dragged by that row, which is why this is a median.

UEX stocks 64 of this install's 109 looted item classes, so 41% of the table
has no price. Those show a dash and a reason rather than a blank that reads as
worthless or a zero that reads as free, and a summary tile says how many rows
carry a price so a sparse table is explained rather than looking broken.

Nothing stored changes shape, so PayloadVersion stays where it is.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01C5xdyEeEFuvh5nPTGFSjnF

Author: peans99

Directory.Build.props

@@ -10,9 +10,9 @@
     <Copyright>Copyright © nekron</Copyright>
     <Description>A pilot's logbook for Star Citizen: second-screen dashboard, in-game overlay, and flight-log analysis for Star Citizen, driven by Game.log.</Description>
 
-    <Version>0.8.34</Version>
-    <AssemblyVersion>0.8.34.0</AssemblyVersion>
-    <FileVersion>0.8.34.0</FileVersion>
+    <Version>0.8.35</Version>
+    <AssemblyVersion>0.8.35.0</AssemblyVersion>
+    <FileVersion>0.8.35.0</FileVersion>
 
     <RepositoryUrl>https://github.com/peans99/QuantumWake</RepositoryUrl>
     <PackageProjectUrl>https://github.com/peans99/QuantumWake</PackageProjectUrl>

README.md

@@ -384,7 +384,7 @@ affiliated with or endorsed by Cloud Imperium Games.
 Newest first. Each version's section is what the GitHub release says too — the
 release workflow lifts it from here, so it is written once.
 
-### 0.8.34
+### 0.8.35
 
 - Ship retrievals are recorded again. Game build 12519617 stopped writing the
   log line that confirmed a retrieved ship had reached the pad, so retrievals
@@ -401,6 +401,14 @@ release workflow lifts it from here, so it is written once.
   than showing a zero it cannot stand behind. It can be switched on in the
   overlay widget too.
 
+- Loot says what things are worth. Each item carries the median price across
+  every terminal UEX reports stocking it — what it usually goes for, rather
+  than the cheapest run to make. The two are not the same: one item here is
+  stocked near 19,175 by a hundred terminals and at 1,975 by one, so the
+  cheapest understates it tenfold. Items UEX does not stock show a dash and
+  the reason instead of a zero, and the summary says how many of the rows
+  carry a price at all.
+
 ### 0.8.32
 
 - **Settings can save a report to send with a bug.** If a page is empty for

src/Quantumwake.Data/UexData.cs

@@ -266,6 +266,37 @@ public UexData(string? directory = null)
     public decimal? ItemPrice(string? uuid) =>
         uuid is not null && _itemPrices.TryGetValue(uuid, out var price) ? price : null;
 
+    /// <summary>
+    /// What an item usually costs: the median buy price across every terminal
+    /// stocking it. Null when nothing stocks it.
+    /// </summary>
+    /// <remarks>
+    /// Median rather than mean, and deliberately not <see cref="ItemPrice"/>.
+    /// The cheapest is what you would pay having flown to the right terminal,
+    /// which is a different question from what a thing is worth, and one odd
+    /// row makes it wildly unrepresentative: this install's MaxLift Tractor
+    /// Beam is stocked by 103 terminals at about 19,175 and by one at 1,975,
+    /// so the cheapest understates it tenfold. A mean would still be dragged
+    /// by that row; a median ignores it.
+    ///
+    /// Falls back to the cheapest when the per-terminal rows are missing but a
+    /// price is known, so an item is never left unpriced over a gap in the
+    /// market table alone.
+    /// </remarks>
+    public decimal? TypicalItemPrice(string? uuid)
+    {
+        var rows = ItemMarket(uuid);
+        if (rows.Count == 0)
+            return ItemPrice(uuid);
+
+        var sorted = rows.Select(row => row.Buy).Order().ToArray();
+        var middle = sorted.Length / 2;
+
+        return sorted.Length % 2 == 1
+            ? sorted[middle]
+            : (sorted[middle - 1] + sorted[middle]) / 2;
+    }
+
     /// <summary>Every terminal stocking an item, by uuid. Empty when unknown.</summary>
     public IReadOnlyList<UexItemRow> ItemMarket(string? uuid) =>
         uuid is not null && _itemMarket.TryGetValue(uuid, out var rows) ? rows : [];

src/Quantumwake.Server/ServerHost.cs

@@ -838,7 +838,20 @@ static void MustRevalidate(StaticFileResponseContext context) =>
         });
 
         // Items observed entering the player's inventories - the Loot page.
-        app.MapGet("/api/loot", (LogLibrary lib, int? days) => lib.Pickups(days ?? 0));
+        // Priced at the endpoint rather than in the library, the same join the
+        // stash uses: the item class names a community entry, which carries the
+        // uuid UEX prices against. Null price is normal and the page says so -
+        // UEX stocks 64 of this install's 109 looted classes.
+        app.MapGet("/api/loot", (LogLibrary lib, UexData uex, int? days) =>
+            lib.Pickups(days ?? 0).Select(p => new
+            {
+                p.At,
+                p.Item,
+                p.ItemClass,
+                p.Place,
+                p.Category,
+                price = uex.TypicalItemPrice(lib.Community.Item(p.ItemClass)?.Uuid)
+            }));
         app.MapGet("/api/contracts", (LogLibrary lib, int? days) => lib.Contracts(days ?? 0));
 
         // Work done per faction, and the little reputation anyone has written

tests/Quantumwake.Tests/UexTypicalPriceTests.cs

@@ -0,0 +1,96 @@
+using Quantumwake.Data;
+
+namespace Quantumwake.Tests;
+
+/// <summary>
+/// What an item is worth, as opposed to what it costs at the one terminal
+/// selling it cheapest. The two answer different questions and this install
+/// has an item where they differ tenfold.
+/// </summary>
+public class UexTypicalPriceTests : IDisposable
+{
+    private readonly string _directory =
+        Path.Combine(Path.GetTempPath(), $"qw-typical-{Guid.NewGuid():N}");
+
+    public UexTypicalPriceTests() => Directory.CreateDirectory(_directory);
+
+    public void Dispose()
+    {
+        if (Directory.Exists(_directory))
+            Directory.Delete(_directory, recursive: true);
+
+        GC.SuppressFinalize(this);
+    }
+
+    /// <summary>
+    /// The cache only loads as a set: prices.json is the gate, and the ids and
+    /// terminals beside it are read unguarded, so a directory holding item
+    /// prices alone loads nothing at all.
+    /// </summary>
+    private void SeedTheCacheItLoadsAsASet()
+    {
+        File.WriteAllText(Path.Combine(_directory, "prices.json"), "{}");
+        File.WriteAllText(Path.Combine(_directory, "commodity-ids.json"), "{}");
+        File.WriteAllText(Path.Combine(_directory, "terminals.json"), "[]");
+    }
+
+    private UexData Seeded(string uuid, decimal cheapest, params decimal[] terminals)
+    {
+        SeedTheCacheItLoadsAsASet();
+
+        File.WriteAllText(
+            Path.Combine(_directory, "item-prices.json"),
+            $$"""{"{{uuid}}":{{cheapest}}}""");
+
+        var rows = string.Join(",", terminals.Select((b, i) =>
+            $$"""{"Terminal":"T{{i}}","Buy":{{b}}}"""));
+
+        File.WriteAllText(
+            Path.Combine(_directory, "item-market.json"),
+            $$"""{"{{uuid}}":[{{rows}}]}""");
+
+        return new UexData(_directory);
+    }
+
+    /// <summary>
+    /// The MaxLift Tractor Beam as this install sees it: stocked near 19,175
+    /// almost everywhere and at 1,975 in one place. The cheapest understates it
+    /// tenfold, and a mean would still be pulled down by the odd row.
+    /// </summary>
+    [Fact]
+    public void One_odd_terminal_does_not_move_the_typical_price()
+    {
+        var uex = Seeded("beam", 1975, 1975, 19175, 19175, 19175, 19175);
+
+        Assert.Equal(1975, uex.ItemPrice("beam"));
+        Assert.Equal(19175, uex.TypicalItemPrice("beam"));
+    }
+
+    [Fact]
+    public void An_even_number_of_terminals_takes_the_middle_pair()
+    {
+        var uex = Seeded("part", 100, 100, 200, 300, 400);
+
+        Assert.Equal(250, uex.TypicalItemPrice("part"));
+    }
+
+    /// <summary>
+    /// A price with no per-terminal rows behind it is still a price. Falling
+    /// through to null would drop items over a gap in the market table alone.
+    /// </summary>
+    [Fact]
+    public void A_price_with_no_terminal_rows_falls_back_to_the_cheapest()
+    {
+        SeedTheCacheItLoadsAsASet();
+        File.WriteAllText(Path.Combine(_directory, "item-prices.json"), """{"lonely":4200}""");
+
+        Assert.Equal(4200, new UexData(_directory).TypicalItemPrice("lonely"));
+    }
+
+    [Fact]
+    public void An_item_nothing_stocks_has_no_typical_price()
+    {
+        Assert.Null(Seeded("beam", 1975, 1975).TypicalItemPrice("unstocked"));
+        Assert.Null(Seeded("beam", 1975, 1975).TypicalItemPrice(null));
+    }
+}

tests/Quantumwake.WebTests/LootPriceTests.cs

@@ -0,0 +1,53 @@
+namespace Quantumwake.WebTests;
+
+/// <summary>
+/// What looted gear is worth. The number shown is the median across every
+/// terminal stocking it, not the cheapest, because the two differ tenfold on
+/// at least one item this install has picked up.
+/// </summary>
+public class LootPriceTests
+{
+    private const string Pickups = """
+        [{"at":"2026-08-20T09:00:00+00:00","item":"MaxLift Tractor Beam","itemClass":"maxlift_01",
+          "place":"Orison","category":"Attachments","price":19175},
+         {"at":"2026-08-19T09:00:00+00:00","item":"Bantam Hat Orange","itemClass":"987_hat_01",
+          "place":"Orison","category":"Clothing","price":null}]
+        """;
+
+    private static Page Loaded()
+    {
+        var page = new Page();
+        page.Serve("/api/loot?days=0", Pickups);
+        page.Do("__dom.node('#loot-period').value = '0'; await loadLoot();");
+        return page;
+    }
+
+    [Fact]
+    public void It_shows_what_an_item_typically_costs()
+    {
+        Assert.Contains("19,175 aUEC", Loaded().NodeText("#loot-table tbody"));
+    }
+
+    /// <summary>
+    /// An unstocked item is not a worthless one. A blank cell reads as nothing
+    /// and a zero as free, so the gap gets a dash and a reason instead.
+    /// </summary>
+    [Fact]
+    public void An_item_nothing_stocks_shows_a_dash_rather_than_a_zero()
+    {
+        var page = Loaded();
+
+        Assert.Contains("—", page.NodeText("#loot-table tbody"));
+        Assert.DoesNotContain("0 aUEC", page.NodeText("#loot-table tbody"));
+    }
+
+    /// <summary>
+    /// The summary says how much of the table carries a price, so a page that
+    /// is mostly dashes is explained rather than looking broken.
+    /// </summary>
+    [Fact]
+    public void The_summary_says_how_many_carry_a_price()
+    {
+        Assert.Contains("1 of 2", Loaded().NodeText("#loot-summary"));
+    }
+}

web/app.js

@@ -2405,6 +2405,24 @@ function fillLootFilter(select, all, label) {
   return select.value;
 }
 
+/**
+ * What an item usually costs, or an explanation of why it does not say.
+ *
+ * A blank cell would read as "worthless" and a zero as "free", and neither is
+ * what an unpriced row means: UEX reports 64 of this install's 109 looted item
+ * classes, and the rest are simply not sold anywhere it can see. So the gap
+ * gets a dash and a reason rather than a number nobody should act on.
+ */
+function lootPriceCell(pickup) {
+  if (!(pickup.price > 0)) {
+    const td = el('td', 'num muted', '—');
+    td.title = 'No terminal UEX knows about stocks this, so it has no price to report.';
+    return td;
+  }
+
+  return el('td', 'num', money(pickup.price));
+}
+
 function renderLoot(pickups) {
   const term = ($('#loot-search').value || '').trim().toLowerCase();
 
@@ -2422,6 +2440,10 @@ function renderLoot(pickups) {
     ['New items', rows.length],
     ['Last 7 days', rows.filter((p) => Date.now() - new Date(p.at).getTime() < 7 * 86400000).length],
     ['Places', new Set(rows.map((p) => p.place)).size],
+
+    // What share carries a price, rather than a total: these are first
+    // sightings, so summing them would value a wardrobe nobody owns twice over.
+    ['Priced', `${rows.filter((p) => p.price > 0).length} of ${rows.length}`],
   ]);
 
   const body = $('#loot-table tbody');
@@ -2436,7 +2458,7 @@ function renderLoot(pickups) {
       ? `Nothing matching ${[kind, place].filter(Boolean).join(' at ')} in that range.`
       : 'Nothing in that range.');
 
-    td.colSpan = 4;
+    td.colSpan = 5;
     tr.append(td);
     body.append(tr);
     lastLootRows = pickups;
@@ -2448,6 +2470,7 @@ function renderLoot(pickups) {
     tr.append(el('td', null, dateOf(pickup.at)));
     tr.append(el('td', null, prettyItem(pickup.item)));
     tr.append(el('td', 'muted', pickup.category));
+    tr.append(lootPriceCell(pickup));
     tr.append(tdPlace(pickup.place, 'muted'));
     body.append(tr);
   }

web/index.html

@@ -1321,13 +1321,21 @@ <h2>New items</h2>
       than pickups. An item counts once, at its first ever appearance.
     </p>
 
+    <p class="muted caption">
+      Typical price is the median across every terminal UEX reports stocking the
+      item &mdash; what it usually goes for, not the cheapest run to make. Items
+      UEX does not stock show no price rather than a zero.
+    </p>
+
     <div class="summary-strip" id="loot-summary"></div>
 
     <div class="table-wrap">
       <table id="loot-table">
         <thead>
           <tr>
-            <th>First seen</th><th>Item</th><th>Kind</th><th>Where you were</th>
+            <th>First seen</th><th>Item</th><th>Kind</th>
+            <th title="Median buy price across every terminal stocking it">Typical price</th>
+            <th>Where you were</th>
           </tr>
         </thead>
         <tbody></tbody>