feat(collectibles): a real shop, and the two fields that decided which furniture the client drew

The shop tab was answering an empty list with a confident comment about needing a
blockchain. That was wrong -- an offer is a furniture classname, a price in
emeralds and two flags, none of which needs a chain, exactly like collections.
It was unbuilt, not impossible, and there was no way for an admin to fill it.

Built end to end: an nft_store_offers table, an NftStoreGrain that both serves
the offers and performs the sale, the purchase message (3196) with its result
(448), and a Shop tab in the dashboard with the offer list and its editor. The
sale runs inside the single-threaded grain so the last copy of a limited edition
cannot be sold twice, refunds the emeralds if handing the furniture over fails,
and refuses outright if the offer names furniture that does not exist.

The picture bug, which was the same bug in two places. The client draws a
collectible by reading itemTypeId with parseInt and looking that number up in one
of its own furniture tables, chosen by productTypeId (0 wall, 1 floor). Both were
being stored or defaulted rather than derived: itemTypeId fell back to the
classname, so parseInt("02_dragonlamp_skream") gave 2, and sprite 2 is the
post-it -- a dragon lamp came out as a post-it. Collections were worse:
ToPrizeItem hardcoded productTypeId 0 and the classname, so every bonus and
reward in every collection was looked up in the wrong table with a nonsense id.
Both now derive from the furniture definition through one shared
CollectibleProductIdentity, and two tests pin sprite-id-not-classname.

Silver and emeralds are pushed at login beside the credits. The client asks for
them once, while its inventory component starts up, and keeps the answer for the
whole session -- so opening the Collectors Guild first left both at zero over a
wallet holding thousands, and the shop's own affordability check then refused
every purchase before sending anything.

A collection's status now means something. The client parses the field and never
reads it, so an admin picking a value was picking noise; the server withholds
anything that is not Visible, which makes Draft a collection you can build over
several sittings without a half-finished set reaching anyone.

Dashboard: the collections editor asked for a bare status number, free-text
rarity and hand-typed prize classnames. Status and rarity are lists now -- rarity
from the client's own colour table -- both prizes are picked from the catalogue
with their image, and the page is split into Collections / Shop / Collectors
tabs instead of stacking three jobs vertically.

Also: the purchase handler now names all six of its outcomes in the log. Only two
were logged, so the three most likely refusals left no trace anywhere and looked
exactly like a packet that never arrived.

Committed with --no-verify at the user's explicit request: the hook cannot run
while Vortex.Main holds the build outputs. The gate's contents were run by hand
instead -- csharpier clean, every touched project builds with no warnings, and
Players 297 / Revisions 209 / Dashboard 20 / Database 124 all pass, plus web lint
and build.

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

Author: codex

Vortex.Dashboard.API/Api/DashboardApiService.Collectibles.cs

@@ -112,6 +112,66 @@ await db
                     })
                     .ToList();
 
+                // The shop is checked the same way a collection item is: an offer naming furniture
+                // that does not exist would take the buyer's emeralds and hand over nothing, so the
+                // grain refuses the sale — and this is the only place that would say so beforehand.
+                var offerRows = await db
+                    .NftStoreOffers.AsNoTracking()
+                    .OrderBy(o => o.SortOrder)
+                    .ThenBy(o => o.Id)
+                    .Select(o => new
+                    {
+                        o.Id,
+                        o.ProductCode,
+                        o.EmeraldPrice,
+                        o.IsFeatured,
+                        o.IsLimited,
+                        o.MintLimit,
+                        o.SoldCount,
+                        o.ItemTypeId,
+                        o.ProductTypeId,
+                        o.Score,
+                        o.Rarity,
+                        o.Enabled,
+                        o.SortOrder,
+                    })
+                    .ToListAsync(ct)
+                    .ConfigureAwait(false);
+
+                List<string> offerCodes = offerRows.Select(o => o.ProductCode).Distinct().ToList();
+
+                HashSet<string> knownOfferFurniture = new(
+                    await db
+                        .FurnitureDefinitions.AsNoTracking()
+                        .Where(f => offerCodes.Contains(f.Name))
+                        .Select(f => f.Name)
+                        .ToListAsync(ct)
+                        .ConfigureAwait(false),
+                    StringComparer.Ordinal
+                );
+
+                var storeOffers = offerRows
+                    .Select(o => new
+                    {
+                        o.Id,
+                        o.ProductCode,
+                        o.EmeraldPrice,
+                        o.IsFeatured,
+                        o.IsLimited,
+                        o.MintLimit,
+                        o.SoldCount,
+                        o.ItemTypeId,
+                        o.ProductTypeId,
+                        o.Score,
+                        o.Rarity,
+                        o.Enabled,
+                        o.SortOrder,
+                        resolved = knownOfferFurniture.Contains(o.ProductCode),
+                        soldOut = o.MintLimit > 0 && o.SoldCount >= o.MintLimit,
+                        iconUrl = BuildFurniIconUrl(o.ProductCode),
+                    })
+                    .ToList();
+
                 var collectorRows = await db
                     .PlayerCollectorStats.AsNoTracking()
                     .OrderByDescending(s => s.HighestScore)
@@ -141,8 +201,13 @@ await db
                         unresolvedItems = collectionItems.Sum(c => c.unresolvedItems),
                         completableCollections = collectionItems.Count(c => c.completable),
                         trackedPlayers,
+                        storeOffers = storeOffers.Count,
+                        storeOffersOnSale = storeOffers.Count(o =>
+                            o.Enabled && !o.soldOut && o.resolved
+                        ),
                     },
                     collections = collectionItems,
+                    storeOffers,
                     topCollectors = collectorRows
                         .Select(c => new
                         {