Merge branch 'feat/decomp-only-followups'

SVSim.Database/Migrations/20260613134356_ConfigPreferenceFlags.cs

@@ -0,0 +1,40 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace SVSim.Database.Migrations
+{
+    /// <inheritdoc />
+    public partial class ConfigPreferenceFlags : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<bool>(
+                name: "Info_IsFoilPreferred",
+                table: "Viewers",
+                type: "boolean",
+                nullable: false,
+                defaultValue: false);
+
+            migrationBuilder.AddColumn<bool>(
+                name: "Info_IsPrizePreferred",
+                table: "Viewers",
+                type: "boolean",
+                nullable: false,
+                defaultValue: false);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "Info_IsFoilPreferred",
+                table: "Viewers");
+
+            migrationBuilder.DropColumn(
+                name: "Info_IsPrizePreferred",
+                table: "Viewers");
+        }
+    }
+}

SVSim.Database/Migrations/SVSimDbContextModelSnapshot.cs

@@ -4340,12 +4340,18 @@ namespace SVSim.Database.Migrations
                                 .IsRequired()
                                 .HasColumnType("text");
 
+                            b1.Property<bool>("IsFoilPreferred")
+                                .HasColumnType("boolean");
+
                             b1.Property<bool>("IsOfficial")
                                 .HasColumnType("boolean");
 
                             b1.Property<bool>("IsOfficialMarkDisplayed")
                                 .HasColumnType("boolean");
 
+                            b1.Property<bool>("IsPrizePreferred")
+                                .HasColumnType("boolean");
+
                             b1.Property<int>("MaxFriends")
                                 .HasColumnType("integer");
 

SVSim.Database/Models/ViewerInfo.cs

@@ -10,6 +10,8 @@ public class ViewerInfo
     public int MaxFriends { get; set; }
     public bool IsOfficial { get; set; }
     public bool IsOfficialMarkDisplayed { get; set; }
+    public bool IsFoilPreferred { get; set; }
+    public bool IsPrizePreferred { get; set; }
 
     #region Navigation Properties
 

SVSim.EmulatedEntrypoint/Controllers/CardController.cs

@@ -1,7 +1,11 @@
 using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
+using SVSim.Database;
 using SVSim.Database.Enums;
+using SVSim.Database.Models;
 using SVSim.Database.Repositories.Card;
 using SVSim.Database.Services;
+using SVSim.Database.Services.Inventory;
 using SVSim.EmulatedEntrypoint.Models.Dtos;
 using SVSim.EmulatedEntrypoint.Models.Dtos.Requests.Card;
 using SVSim.EmulatedEntrypoint.Models.Dtos.Responses.Card;
@@ -10,18 +14,28 @@ using System.Text.Json;
 namespace SVSim.EmulatedEntrypoint.Controllers;
 
 /// <summary>
-/// /card/* — viewer card-inventory mutations. Ships /card/destruct, /card/create, /card/protect.
-/// /card/create_foil_card is reserved for a follow-up slice.
+/// /card/* — viewer card-inventory mutations. Ships /card/destruct, /card/create, /card/protect,
+/// /card/create_foil_card.
 /// </summary>
 [Route("card")]
 public class CardController : SVSimController
 {
+    /// <summary>Item catalog id for Orb (Seer's Globe currency). Source: PremiumCardConversionTask</summary>
+    private const int OrbItemId = 1000;
+
+    /// <summary>Per-card ownership cap mirrored from the client gate (CardDetailUI.cs:2261).</summary>
+    private const int MaxCardCopies = 3;
+
     private readonly ICardInventoryRepository _inventory;
+    private readonly IInventoryService _inv;
+    private readonly SVSimDbContext _db;
     private readonly ILogger<CardController> _log;
 
-    public CardController(ICardInventoryRepository inventory, ILogger<CardController> log)
+    public CardController(ICardInventoryRepository inventory, IInventoryService inv, SVSimDbContext db, ILogger<CardController> log)
     {
         _inventory = inventory;
+        _inv = inv;
+        _db = db;
         _log = log;
     }
 
@@ -132,6 +146,82 @@ public class CardController : SVSimController
         _ => "malformed_request",
     };
 
+    /// <summary>
+    /// Seer's Globe conversion (decomp: Wizard/PremiumCardConversionTask.cs). Spends N Orbs
+    /// (Item 1000) + N copies of the base card, grants N copies of the foil twin (base.Id + 1).
+    /// Foil convention is the documented one on <see cref="ShadowverseCardEntry.IsFoil"/> —
+    /// the foil twin shares the base's CardSet at card_id = base + 1. The 3-copy cap is mirrored
+    /// from the client gate (CardDetailUI.cs:2261); reject server-side too so direct API hits
+    /// can't bypass.
+    /// </summary>
+    [HttpPost("create_foil_card")]
+    public async Task<ActionResult<CardCreateFoilCardResponse>> CreateFoilCard(
+        CardCreateFoilCardRequest request, CancellationToken ct)
+    {
+        if (!TryGetViewerId(out long viewerId)) return Unauthorized();
+        if (request.CreateNumber < 1) return BadRequest(new { error = "invalid_create_number" });
+
+        var baseCard = await _db.Set<ShadowverseCardEntry>()
+            .FirstOrDefaultAsync(c => c.Id == request.BaseCardId, ct);
+        if (baseCard is null || baseCard.IsFoil)
+            return BadRequest(new { error = "invalid_base_card" });
+
+        var foilCard = await _db.Set<ShadowverseCardEntry>()
+            .FirstOrDefaultAsync(c => c.Id == baseCard.Id + 1 && c.IsFoil, ct);
+        if (foilCard is null)
+            return BadRequest(new { error = "no_foil_variant" });
+
+        await using var tx = await _inv.BeginAsync(viewerId, ct);
+        var viewer = tx.Viewer;
+
+        var baseOwned = viewer.Cards.FirstOrDefault(c => c.Card.Id == baseCard.Id);
+        if (baseOwned is null || baseOwned.Count < request.CreateNumber)
+            return BadRequest(new { error = "insufficient_base_card" });
+
+        var foilOwned = viewer.Cards.FirstOrDefault(c => c.Card.Id == foilCard.Id);
+        int existingFoilCount = foilOwned?.Count ?? 0;
+        if (existingFoilCount + request.CreateNumber > MaxCardCopies)
+            return BadRequest(new { error = "would_exceed_max_copies" });
+
+        // Snapshot mismatch is warn-log only — matches the /card/create + /card/destruct pattern.
+        if (request.BaseCardNumber != baseOwned.Count)
+        {
+            _log.LogWarning(
+                "CreateFoilCard possession-snapshot mismatch: card={BaseCardId} client_snapshot={Snapshot} server={Server}",
+                request.BaseCardId, request.BaseCardNumber, baseOwned.Count);
+        }
+
+        // Spend Orbs first so an Orb-poor viewer keeps their base copy on failure. The inventory
+        // facade throws InventoryCatalogException when the item has never been owned at all (no
+        // OwnedItemEntry row), so pre-check rather than relying on TryDebitAsync alone.
+        var orbOwned = viewer.Items.FirstOrDefault(i => i.Item.Id == OrbItemId);
+        if (orbOwned is null || orbOwned.Count < request.CreateNumber)
+            return BadRequest(new { error = "insufficient_orb" });
+        var orbSpend = await tx.TryDebitAsync(UserGoodsType.Item, OrbItemId, request.CreateNumber, ct);
+        if (!orbSpend.Success)
+            return BadRequest(new { error = "insufficient_orb" });
+
+        // Debit base copies directly (InventoryTransaction.TryDebitAsync doesn't route Card).
+        baseOwned.Count -= request.CreateNumber;
+
+        // Grant foil copies via the canonical primitive so CardCosmeticReward cascades fire.
+        await tx.GrantAsync(UserGoodsType.Card, foilCard.Id, request.CreateNumber, ct);
+
+        var result = await tx.CommitAsync(ct);
+
+        // Append the base card's post-state total so the client can update its on-screen count
+        // (UpdateHaveUserGoodsNumByJsonData does direct assignment, not delta).
+        var rewardList = result.RewardList.ToRewardList();
+        rewardList.Add(new RewardListEntry
+        {
+            RewardType = (int)UserGoodsType.Card,
+            RewardId = baseCard.Id,
+            RewardNum = baseOwned.Count,
+        });
+
+        return new CardCreateFoilCardResponse { RewardList = rewardList };
+    }
+
     [HttpPost("protect")]
     public async Task<ActionResult<CardProtectResponse>> Protect(CardProtectRequest request)
     {

SVSim.EmulatedEntrypoint/Controllers/ConfigController.cs

@@ -1,31 +1,42 @@
 using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
+using SVSim.Database;
 using SVSim.EmulatedEntrypoint.Models.Dtos.Common;
 using SVSim.EmulatedEntrypoint.Models.Dtos.Requests;
 
 namespace SVSim.EmulatedEntrypoint.Controllers;
 
 /// <summary>
-/// /config/* — viewer-scoped preference toggles. Fired by the client as fire-and-forget
-/// after the deck-builder save flow (and from settings screens). Currently acknowledge-only:
-/// UserConfig is stubbed in load/index + mypage/index until a viewer-config persistence
-/// layer lands. Mirrors the set_deck_redis precedent (no-op accept).
+/// /config/* — viewer-scoped preference toggles. Persists to ViewerInfo; reads back through
+/// /load/index + /mypage/index user_config.
 /// </summary>
 public class ConfigController : SVSimController
 {
+    private readonly SVSimDbContext _db;
+
+    public ConfigController(SVSimDbContext db) => _db = db;
+
     [HttpPost("update_foil_preferred")]
-    public ActionResult<EmptyResponse> UpdateFoilPreferred(ConfigUpdateFoilPreferredRequest request)
+    public async Task<ActionResult<EmptyResponse>> UpdateFoilPreferred(
+        ConfigUpdateFoilPreferredRequest request, CancellationToken ct)
     {
-        if (!TryGetViewerId(out long _)) return Unauthorized();
-        // TODO(viewer-config-persist): write request.IsFoilPreferred onto the viewer's config row
-        // and read it back in load/index + mypage/index instead of `new UserConfig()`.
+        if (!TryGetViewerId(out long viewerId)) return Unauthorized();
+        var viewer = await _db.Viewers.FirstOrDefaultAsync(v => v.Id == viewerId, ct);
+        if (viewer is null) return Unauthorized();
+        viewer.Info.IsFoilPreferred = request.IsFoilPreferred != 0;
+        await _db.SaveChangesAsync(ct);
         return new EmptyResponse();
     }
 
     [HttpPost("update_prize_preferred")]
-    public ActionResult<EmptyResponse> UpdatePrizePreferred(ConfigUpdatePrizePreferredRequest request)
+    public async Task<ActionResult<EmptyResponse>> UpdatePrizePreferred(
+        ConfigUpdatePrizePreferredRequest request, CancellationToken ct)
     {
-        if (!TryGetViewerId(out long _)) return Unauthorized();
-        // TODO(viewer-config-persist): see UpdateFoilPreferred.
+        if (!TryGetViewerId(out long viewerId)) return Unauthorized();
+        var viewer = await _db.Viewers.FirstOrDefaultAsync(v => v.Id == viewerId, ct);
+        if (viewer is null) return Unauthorized();
+        viewer.Info.IsPrizePreferred = request.IsPrizePreferred != 0;
+        await _db.SaveChangesAsync(ct);
         return new EmptyResponse();
     }
 }

SVSim.EmulatedEntrypoint/Controllers/DegreeController.cs

@@ -0,0 +1,70 @@
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
+using SVSim.Database;
+using SVSim.EmulatedEntrypoint.Models.Dtos.Common;
+using SVSim.EmulatedEntrypoint.Models.Dtos.Requests;
+using SVSim.EmulatedEntrypoint.Models.Dtos.Requests.Degree;
+using SVSim.EmulatedEntrypoint.Models.Dtos.Responses.Degree;
+
+namespace SVSim.EmulatedEntrypoint.Controllers;
+
+/// <summary>
+/// /degree/* — viewer-scoped degree (title) management. Read, mark-favorite, set-currently-displayed.
+/// Mirrors /sleeve/* and /emblem/*; favorite handler is no-op like the others until a viewer-favorites
+/// schema lands (would also serve /sleeve/favorite + /emblem/favorite via the shared Wizard/FavoriteTask.cs Kind enum).
+/// </summary>
+[Route("degree")]
+public class DegreeController : SVSimController
+{
+    private readonly SVSimDbContext _db;
+
+    public DegreeController(SVSimDbContext db) => _db = db;
+
+    [HttpPost("degree_list")]
+    public async Task<ActionResult<DegreeListResponse>> DegreeList(DegreeListRequest _, CancellationToken ct)
+    {
+        if (!TryGetViewerId(out long viewerId)) return Unauthorized();
+
+        var viewer = await _db.Viewers
+            .Include(v => v.Degrees)
+            .FirstOrDefaultAsync(v => v.Id == viewerId, ct);
+        if (viewer is null) return Unauthorized();
+
+        return new DegreeListResponse
+        {
+            UserDegreeList = viewer.Degrees
+                .Select(d => new DegreeListEntry { DegreeId = d.Id })
+                .OrderBy(e => e.DegreeId)
+                .ToList(),
+        };
+    }
+
+    [HttpPost("favorite")]
+    public ActionResult<EmptyResponse> Favorite([FromBody] DegreeFavoriteRequest _)
+    {
+        if (!TryGetViewerId(out long __)) return Unauthorized();
+        // Accept-and-ack. Persisting per-viewer cosmetic favorites is deferred until
+        // a viewer-favorites schema lands (would also serve /sleeve/favorite + /emblem/favorite
+        // via the shared Wizard/FavoriteTask.cs Kind enum).
+        return new EmptyResponse();
+    }
+
+    [HttpPost("update_degree")]
+    public async Task<ActionResult<EmptyResponse>> Update(DegreeUpdateRequest request, CancellationToken ct)
+    {
+        if (!TryGetViewerId(out long viewerId)) return Unauthorized();
+
+        var viewer = await _db.Viewers
+            .Include(v => v.Degrees)
+            .FirstOrDefaultAsync(v => v.Id == viewerId, ct);
+        if (viewer is null) return Unauthorized();
+
+        var owned = viewer.Degrees.FirstOrDefault(d => d.Id == request.DegreeId);
+        if (owned is null)
+            return BadRequest(new { error = "degree_not_owned" });
+
+        viewer.Info.SelectedDegree = owned;
+        await _db.SaveChangesAsync(ct);
+        return new EmptyResponse();
+    }
+}

SVSim.EmulatedEntrypoint/Controllers/EmblemController.cs

@@ -0,0 +1,70 @@
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.EntityFrameworkCore;
+using SVSim.Database;
+using SVSim.EmulatedEntrypoint.Models.Dtos.Common;
+using SVSim.EmulatedEntrypoint.Models.Dtos.Requests;
+using SVSim.EmulatedEntrypoint.Models.Dtos.Requests.Emblem;
+using SVSim.EmulatedEntrypoint.Models.Dtos.Responses.Emblem;
+
+namespace SVSim.EmulatedEntrypoint.Controllers;
+
+/// <summary>
+/// /emblem/* — viewer-scoped emblem (lobby/profile badge) management. Read, mark-favorite,
+/// set-currently-displayed. Mirrors /sleeve/* and /degree/*.
+/// </summary>
+[Route("emblem")]
+public class EmblemController : SVSimController
+{
+    private readonly SVSimDbContext _db;
+
+    public EmblemController(SVSimDbContext db) => _db = db;
+
+    [HttpPost("emblem_list")]
+    public async Task<ActionResult<EmblemListResponse>> EmblemList(BaseRequest _, CancellationToken ct)
+    {
+        if (!TryGetViewerId(out long viewerId)) return Unauthorized();
+
+        var viewer = await _db.Viewers
+            .Include(v => v.Emblems)
+            .FirstOrDefaultAsync(v => v.Id == viewerId, ct);
+        if (viewer is null) return Unauthorized();
+
+        return new EmblemListResponse
+        {
+            UserEmblemList = viewer.Emblems
+                .Select(e => new EmblemListEntry { EmblemId = e.Id })
+                .OrderBy(x => x.EmblemId)
+                .ToList(),
+        };
+    }
+
+    [HttpPost("favorite")]
+    public ActionResult<EmptyResponse> Favorite([FromBody] EmblemFavoriteRequest _)
+    {
+        if (!TryGetViewerId(out long __)) return Unauthorized();
+        // Accept-and-ack. Persisting per-viewer cosmetic favorites is deferred until
+        // a viewer-favorites schema lands (would also serve /sleeve/favorite + /degree/favorite
+        // via the shared Wizard/FavoriteTask.cs Kind enum).
+        return new EmptyResponse();
+    }
+
+    [HttpPost("update_emblem")]
+    public async Task<ActionResult<EmptyResponse>> Update(EmblemUpdateRequest request, CancellationToken ct)
+    {
+        if (!TryGetViewerId(out long viewerId)) return Unauthorized();
+
+        var viewer = await _db.Viewers
+            .Include(v => v.Emblems)
+            .FirstOrDefaultAsync(v => v.Id == viewerId, ct);
+        if (viewer is null) return Unauthorized();
+
+        // EmblemEntry.Id is int; cast the wire long once at the boundary.
+        var owned = viewer.Emblems.FirstOrDefault(e => e.Id == (int)request.EmblemId);
+        if (owned is null)
+            return BadRequest(new { error = "emblem_not_owned" });
+
+        viewer.Info.SelectedEmblem = owned;
+        await _db.SaveChangesAsync(ct);
+        return new EmptyResponse();
+    }
+}

SVSim.EmulatedEntrypoint/Controllers/LoadController.cs

@@ -253,7 +253,11 @@ public class LoadController : SVSimController
             },
             ArenaInfos = await BuildArenaInfosAsync(viewer.Id),
             RotationSets = rotationSets,
-            UserConfig = new UserConfig(),
+            UserConfig = new UserConfig
+            {
+                IsFoilPreferred = viewer.Info.IsFoilPreferred ? 1 : 0,
+                IsPrizePreferred = viewer.Info.IsPrizePreferred ? 1 : 0,
+            },
             OpenBattlefieldIds = (await _globalsRepository.GetBattlefields(true))
                 .Select(bf => bf.Id.ToString()).ToList(),
             DefaultSettings = new DefaultSettings(defaultLoadout),

SVSim.EmulatedEntrypoint/Controllers/MyPageController.cs

@@ -111,7 +111,11 @@ public class MyPageController : SVSimController
                 IsJoinTournament = false,
                 IsAdminWatchUser = false,
             },
-            UserConfig = new UserConfig(),                          // TODO(mypage-stub): persist viewer UserConfig
+            UserConfig = new UserConfig
+            {
+                IsFoilPreferred = viewer.Info.IsFoilPreferred ? 1 : 0,
+                IsPrizePreferred = viewer.Info.IsPrizePreferred ? 1 : 0,
+            },
             Quest = new Quest(),                                    // TODO(mypage-stub): active Quest event + viewer flags
             MasterPointRankingPeriod = BuildMasterPointRankingPeriod(masterPointPeriod),
             PreReleaseStatus = 0,                                   // TODO(mypage-stub): derive from PreReleaseInfo

SVSim.EmulatedEntrypoint/Models/Dtos/Requests/Card/CardCreateFoilCardRequest.cs

@@ -0,0 +1,30 @@
+using MessagePack;
+using System.Text.Json.Serialization;
+
+namespace SVSim.EmulatedEntrypoint.Models.Dtos.Requests.Card;
+
+/// <summary>
+/// POST /card/create_foil_card — Seer's Globe conversion (Wizard/PremiumCardConversionTask.cs).
+/// Consumes <see cref="CreateNumber"/> Orbs (Item id 1000) + <see cref="CreateNumber"/> copies of
+/// <see cref="BaseCardId"/> to grant <see cref="CreateNumber"/> copies of the foil twin (base+1).
+/// </summary>
+[MessagePackObject]
+public class CardCreateFoilCardRequest : BaseRequest
+{
+    [JsonPropertyName("base_card_id")]
+    [Key("base_card_id")]
+    public int BaseCardId { get; set; }
+
+    /// <summary>
+    /// Client's snapshot of how many normal copies it has at request time. Sanity-check only —
+    /// the actual spend is <c>create_number</c> copies, not this value.
+    /// </summary>
+    [JsonPropertyName("base_card_number")]
+    [Key("base_card_number")]
+    public int BaseCardNumber { get; set; }
+
+    /// <summary>Hardcoded to 1 by <c>PremiumCardConversionTask.SetParameter</c>.</summary>
+    [JsonPropertyName("create_number")]
+    [Key("create_number")]
+    public int CreateNumber { get; set; }
+}

SVSim.EmulatedEntrypoint/Models/Dtos/Requests/Degree/DegreeFavoriteRequest.cs

@@ -0,0 +1,17 @@
+using MessagePack;
+using System.Text.Json.Serialization;
+
+namespace SVSim.EmulatedEntrypoint.Models.Dtos.Requests.Degree;
+
+[MessagePackObject]
+public class DegreeFavoriteRequest : BaseRequest
+{
+    // Spec note: ids are STRINGS on the wire, not ints. Same gotcha as /sleeve/favorite and /emblem/favorite.
+    [JsonPropertyName("favorite_add")]
+    [Key("favorite_add")]
+    public List<string> FavoriteAdd { get; set; } = new();
+
+    [JsonPropertyName("favorite_remove")]
+    [Key("favorite_remove")]
+    public List<string> FavoriteRemove { get; set; } = new();
+}

SVSim.EmulatedEntrypoint/Models/Dtos/Requests/Degree/DegreeListRequest.cs

@@ -0,0 +1,12 @@
+using MessagePack;
+using System.Text.Json.Serialization;
+
+namespace SVSim.EmulatedEntrypoint.Models.Dtos.Requests.Degree;
+
+[MessagePackObject]
+public class DegreeListRequest : BaseRequest
+{
+    [JsonPropertyName("degree_id")]
+    [Key("degree_id")]
+    public int DegreeId { get; set; }
+}

SVSim.EmulatedEntrypoint/Models/Dtos/Requests/Degree/DegreeUpdateRequest.cs

@@ -0,0 +1,12 @@
+using MessagePack;
+using System.Text.Json.Serialization;
+
+namespace SVSim.EmulatedEntrypoint.Models.Dtos.Requests.Degree;
+
+[MessagePackObject]
+public class DegreeUpdateRequest : BaseRequest
+{
+    [JsonPropertyName("degree_id")]
+    [Key("degree_id")]
+    public int DegreeId { get; set; }
+}

SVSim.EmulatedEntrypoint/Models/Dtos/Requests/Emblem/EmblemFavoriteRequest.cs

@@ -0,0 +1,17 @@
+using MessagePack;
+using System.Text.Json.Serialization;
+
+namespace SVSim.EmulatedEntrypoint.Models.Dtos.Requests.Emblem;
+
+[MessagePackObject]
+public class EmblemFavoriteRequest : BaseRequest
+{
+    // Spec note: ids are STRINGS on the wire, not ints. Same gotcha as /sleeve/favorite and /degree/favorite.
+    [JsonPropertyName("favorite_add")]
+    [Key("favorite_add")]
+    public List<string> FavoriteAdd { get; set; } = new();
+
+    [JsonPropertyName("favorite_remove")]
+    [Key("favorite_remove")]
+    public List<string> FavoriteRemove { get; set; } = new();
+}

SVSim.EmulatedEntrypoint/Models/Dtos/Requests/Emblem/EmblemUpdateRequest.cs

@@ -0,0 +1,13 @@
+using MessagePack;
+using System.Text.Json.Serialization;
+
+namespace SVSim.EmulatedEntrypoint.Models.Dtos.Requests.Emblem;
+
+[MessagePackObject]
+public class EmblemUpdateRequest : BaseRequest
+{
+    // Spec note: emblem_id is a long on the wire (UserInfo.SelectedEmblemId is also long).
+    [JsonPropertyName("emblem_id")]
+    [Key("emblem_id")]
+    public long EmblemId { get; set; }
+}

SVSim.EmulatedEntrypoint/Models/Dtos/Responses/Card/CardCreateFoilCardResponse.cs

@@ -0,0 +1,19 @@
+using MessagePack;
+using SVSim.EmulatedEntrypoint.Models.Dtos;
+using System.Text.Json.Serialization;
+
+namespace SVSim.EmulatedEntrypoint.Models.Dtos.Responses.Card;
+
+/// <summary>
+/// /card/create_foil_card response. reward_list entries are POST-STATE TOTALS — client's
+/// <c>PlayerStaticData.UpdateHaveUserGoodsNumByJsonData</c> does direct assignment. Contains
+/// the Item (Orb) post-balance, base-card post-count, and foil-card post-count.
+/// </summary>
+[MessagePackObject]
+public class CardCreateFoilCardResponse
+{
+    [JsonPropertyName("reward_list")]
+    [JsonIgnore(Condition = JsonIgnoreCondition.Never)]
+    [Key("reward_list")]
+    public List<RewardListEntry> RewardList { get; set; } = new();
+}

SVSim.EmulatedEntrypoint/Models/Dtos/Responses/Degree/DegreeListEntry.cs

@@ -0,0 +1,12 @@
+using MessagePack;
+using System.Text.Json.Serialization;
+
+namespace SVSim.EmulatedEntrypoint.Models.Dtos.Responses.Degree;
+
+[MessagePackObject]
+public class DegreeListEntry
+{
+    [JsonPropertyName("degree_id")]
+    [Key("degree_id")]
+    public int DegreeId { get; set; }
+}

SVSim.EmulatedEntrypoint/Models/Dtos/Responses/Degree/DegreeListResponse.cs

@@ -0,0 +1,12 @@
+using MessagePack;
+using System.Text.Json.Serialization;
+
+namespace SVSim.EmulatedEntrypoint.Models.Dtos.Responses.Degree;
+
+[MessagePackObject]
+public class DegreeListResponse
+{
+    [JsonPropertyName("user_degree_list")]
+    [Key("user_degree_list")]
+    public List<DegreeListEntry> UserDegreeList { get; set; } = new();
+}

SVSim.EmulatedEntrypoint/Models/Dtos/Responses/Emblem/EmblemListEntry.cs

@@ -0,0 +1,12 @@
+using MessagePack;
+using System.Text.Json.Serialization;
+
+namespace SVSim.EmulatedEntrypoint.Models.Dtos.Responses.Emblem;
+
+[MessagePackObject]
+public class EmblemListEntry
+{
+    [JsonPropertyName("emblem_id")]
+    [Key("emblem_id")]
+    public int EmblemId { get; set; }
+}

SVSim.EmulatedEntrypoint/Models/Dtos/Responses/Emblem/EmblemListResponse.cs

@@ -0,0 +1,12 @@
+using MessagePack;
+using System.Text.Json.Serialization;
+
+namespace SVSim.EmulatedEntrypoint.Models.Dtos.Responses.Emblem;
+
+[MessagePackObject]
+public class EmblemListResponse
+{
+    [JsonPropertyName("user_emblem_list")]
+    [Key("user_emblem_list")]
+    public List<EmblemListEntry> UserEmblemList { get; set; } = new();
+}

SVSim.UnitTests/Controllers/CardControllerCreateFoilCardTests.cs

@@ -0,0 +1,128 @@
+using System.Net;
+using System.Text;
+using System.Text.Json;
+using NUnit.Framework;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.DependencyInjection;
+using SVSim.Database;
+using SVSim.Database.Enums;
+using SVSim.Database.Models;
+using SVSim.UnitTests.Infrastructure;
+
+namespace SVSim.UnitTests.Controllers;
+
+public class CardControllerCreateFoilCardTests
+{
+    private const int OrbItemId = 1000;
+
+    private static async Task<(long baseCardId, long foilCardId)> SeedFoilPairAsync(SVSimTestFactory factory)
+    {
+        long baseId = await factory.SeedCardAsync(isFoil: false);
+        // SeedCardAsync increments by 2 to keep base/foil at consecutive ids; the foil twin
+        // for our baseId is at baseId + 1.
+        using var scope = factory.Services.CreateScope();
+        var db = scope.ServiceProvider.GetRequiredService<SVSimDbContext>();
+        long foilId = baseId + 1;
+        if (!await db.Cards.AnyAsync(c => c.Id == foilId))
+        {
+            db.Cards.Add(new ShadowverseCardEntry { Id = foilId, IsFoil = true, Name = $"SeedCard{foilId}" });
+            await db.SaveChangesAsync();
+        }
+        return (baseId, foilId);
+    }
+
+    private static async Task GiveBaseCopyAsync(SVSimTestFactory factory, long viewerId, long baseCardId, int count)
+    {
+        using var scope = factory.Services.CreateScope();
+        var db = scope.ServiceProvider.GetRequiredService<SVSimDbContext>();
+        var card = await db.Cards.FirstAsync(c => c.Id == baseCardId);
+        var viewer = await db.Viewers.Include(v => v.Cards).ThenInclude(c => c.Card).FirstAsync(v => v.Id == viewerId);
+        viewer.Cards.Add(new OwnedCardEntry { Card = card, Count = count, IsProtected = false });
+        await db.SaveChangesAsync();
+    }
+
+    private static async Task GiveOrbsAsync(SVSimTestFactory factory, long viewerId, int count)
+        => await factory.SeedOwnedItemAsync(viewerId, OrbItemId, count, itemName: "Orb", itemType: 1);
+
+    [Test]
+    public async Task CreateFoilCard_consumes_one_orb_and_one_normal_copy_and_grants_one_foil()
+    {
+        using var factory = new SVSimTestFactory();
+        long viewerId = await factory.SeedViewerAsync(tutorialState: 0);
+        var (baseCardId, foilCardId) = await SeedFoilPairAsync(factory);
+        await GiveBaseCopyAsync(factory, viewerId, baseCardId, count: 1);
+        await GiveOrbsAsync(factory, viewerId, count: 1);
+
+        using var client = factory.CreateAuthenticatedClient(viewerId);
+        var requestJson = $$"""{"base_card_id":{{baseCardId}},"base_card_number":1,"create_number":1,"viewer_id":"0","steam_id":0,"steam_session_ticket":""}""";
+        var response = await client.PostAsync("/card/create_foil_card",
+            new StringContent(requestJson, Encoding.UTF8, "application/json"));
+
+        var body = await response.Content.ReadAsStringAsync();
+        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK), body);
+
+        using var scope2 = factory.Services.CreateScope();
+        var db2 = scope2.ServiceProvider.GetRequiredService<SVSimDbContext>();
+        var viewer2 = await db2.Viewers
+            .Include(v => v.Cards).ThenInclude(c => c.Card)
+            .Include(v => v.Items).ThenInclude(i => i.Item)
+            .FirstAsync(v => v.Id == viewerId);
+
+        var foilOwn = viewer2.Cards.SingleOrDefault(c => c.Card.Id == foilCardId);
+        var baseOwn = viewer2.Cards.SingleOrDefault(c => c.Card.Id == baseCardId);
+        Assert.That(foilOwn?.Count ?? 0, Is.EqualTo(1), "foil count");
+        Assert.That(baseOwn?.Count ?? 0, Is.EqualTo(0), "base count after consume");
+
+        var orbBalance = viewer2.Items.SingleOrDefault(i => i.Item.Id == OrbItemId)?.Count ?? 0;
+        Assert.That(orbBalance, Is.EqualTo(0), "orb balance after spend");
+
+        using var doc = JsonDocument.Parse(body);
+        var rewards = doc.RootElement.GetProperty("reward_list").EnumerateArray().ToList();
+        Assert.That(rewards, Is.Not.Empty);
+    }
+
+    [Test]
+    public async Task CreateFoilCard_rejects_without_orb()
+    {
+        using var factory = new SVSimTestFactory();
+        long viewerId = await factory.SeedViewerAsync(tutorialState: 0);
+        var (baseCardId, foilCardId) = await SeedFoilPairAsync(factory);
+        await GiveBaseCopyAsync(factory, viewerId, baseCardId, count: 1);
+        // No orbs granted.
+
+        using var client = factory.CreateAuthenticatedClient(viewerId);
+        var requestJson = $$"""{"base_card_id":{{baseCardId}},"base_card_number":1,"create_number":1,"viewer_id":"0","steam_id":0,"steam_session_ticket":""}""";
+        var response = await client.PostAsync("/card/create_foil_card",
+            new StringContent(requestJson, Encoding.UTF8, "application/json"));
+
+        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
+
+        using var scope = factory.Services.CreateScope();
+        var db = scope.ServiceProvider.GetRequiredService<SVSimDbContext>();
+        var viewer = await db.Viewers.Include(v => v.Cards).ThenInclude(c => c.Card).FirstAsync(v => v.Id == viewerId);
+        Assert.That(viewer.Cards.Single(c => c.Card.Id == baseCardId).Count, Is.EqualTo(1), "base count untouched");
+        Assert.That(viewer.Cards.Any(c => c.Card.Id == foilCardId && c.Count > 0), Is.False, "no foil granted");
+    }
+
+    [Test]
+    public async Task CreateFoilCard_rejects_without_base_copy()
+    {
+        using var factory = new SVSimTestFactory();
+        long viewerId = await factory.SeedViewerAsync(tutorialState: 0);
+        var (baseCardId, _) = await SeedFoilPairAsync(factory);
+        await GiveOrbsAsync(factory, viewerId, count: 1);
+        // No base copy granted.
+
+        using var client = factory.CreateAuthenticatedClient(viewerId);
+        var requestJson = $$"""{"base_card_id":{{baseCardId}},"base_card_number":1,"create_number":1,"viewer_id":"0","steam_id":0,"steam_session_ticket":""}""";
+        var response = await client.PostAsync("/card/create_foil_card",
+            new StringContent(requestJson, Encoding.UTF8, "application/json"));
+
+        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
+
+        using var scope = factory.Services.CreateScope();
+        var db = scope.ServiceProvider.GetRequiredService<SVSimDbContext>();
+        var viewer = await db.Viewers.Include(v => v.Items).ThenInclude(i => i.Item).FirstAsync(v => v.Id == viewerId);
+        Assert.That(viewer.Items.Single(i => i.Item.Id == OrbItemId).Count, Is.EqualTo(1), "orb balance untouched");
+    }
+}

SVSim.UnitTests/Controllers/ConfigControllerPreferencesTests.cs

@@ -0,0 +1,56 @@
+using System.Net;
+using System.Text;
+using System.Text.Json;
+using NUnit.Framework;
+using SVSim.UnitTests.Infrastructure;
+
+namespace SVSim.UnitTests.Controllers;
+
+public class ConfigControllerPreferencesTests
+{
+    [Test]
+    public async Task UpdateFoilPreferred_persists_and_appears_in_load_index()
+    {
+        using var factory = new SVSimTestFactory();
+        long viewerId = await factory.SeedViewerAsync(tutorialState: 0);
+        using var client = factory.CreateAuthenticatedClient(viewerId);
+
+        var setJson = """{"is_foil_preferred":1,"viewer_id":"0","steam_id":0,"steam_session_ticket":""}""";
+        var setResp = await client.PostAsync("/config/update_foil_preferred",
+            new StringContent(setJson, Encoding.UTF8, "application/json"));
+        var setBody = await setResp.Content.ReadAsStringAsync();
+        Assert.That(setResp.StatusCode, Is.EqualTo(HttpStatusCode.OK), setBody);
+
+        var loadJson = """{"viewer_id":"0","steam_id":0,"steam_session_ticket":"","carrier":"none","card_master_hash":""}""";
+        var loadResp = await client.PostAsync("/load/index",
+            new StringContent(loadJson, Encoding.UTF8, "application/json"));
+        var body = await loadResp.Content.ReadAsStringAsync();
+        Assert.That(loadResp.StatusCode, Is.EqualTo(HttpStatusCode.OK), body);
+
+        using var doc = JsonDocument.Parse(body);
+        var cfg = doc.RootElement.GetProperty("user_config");
+        Assert.That(cfg.GetProperty("is_foil_preferred").GetInt32(), Is.EqualTo(1), body);
+    }
+
+    [Test]
+    public async Task UpdatePrizePreferred_persists_and_appears_in_load_index()
+    {
+        using var factory = new SVSimTestFactory();
+        long viewerId = await factory.SeedViewerAsync(tutorialState: 0);
+        using var client = factory.CreateAuthenticatedClient(viewerId);
+
+        var setJson = """{"is_prize_preferred":1,"viewer_id":"0","steam_id":0,"steam_session_ticket":""}""";
+        var setResp = await client.PostAsync("/config/update_prize_preferred",
+            new StringContent(setJson, Encoding.UTF8, "application/json"));
+        Assert.That(setResp.StatusCode, Is.EqualTo(HttpStatusCode.OK));
+
+        var loadJson = """{"viewer_id":"0","steam_id":0,"steam_session_ticket":"","carrier":"none","card_master_hash":""}""";
+        var loadResp = await client.PostAsync("/load/index",
+            new StringContent(loadJson, Encoding.UTF8, "application/json"));
+
+        var body = await loadResp.Content.ReadAsStringAsync();
+        using var doc = JsonDocument.Parse(body);
+        var cfg = doc.RootElement.GetProperty("user_config");
+        Assert.That(cfg.GetProperty("is_prize_preferred").GetInt32(), Is.EqualTo(1));
+    }
+}

SVSim.UnitTests/Controllers/DegreeControllerFavoriteTests.cs

@@ -0,0 +1,37 @@
+using System.Net;
+using System.Text;
+using NUnit.Framework;
+using SVSim.UnitTests.Infrastructure;
+
+namespace SVSim.UnitTests.Controllers;
+
+public class DegreeControllerFavoriteTests
+{
+    [Test]
+    public async Task Favorite_accepts_add_and_remove_lists()
+    {
+        using var factory = new SVSimTestFactory();
+        long viewerId = await factory.SeedViewerAsync(tutorialState: 0);
+        using var client = factory.CreateAuthenticatedClient(viewerId);
+
+        var requestJson = """{"favorite_add":["100","101"],"favorite_remove":["200"],"viewer_id":"0","steam_id":0,"steam_session_ticket":""}""";
+        var response = await client.PostAsync("/degree/favorite",
+            new StringContent(requestJson, Encoding.UTF8, "application/json"));
+
+        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));
+    }
+
+    [Test]
+    public async Task Favorite_accepts_empty_lists()
+    {
+        using var factory = new SVSimTestFactory();
+        long viewerId = await factory.SeedViewerAsync(tutorialState: 0);
+        using var client = factory.CreateAuthenticatedClient(viewerId);
+
+        var requestJson = """{"favorite_add":[],"favorite_remove":[],"viewer_id":"0","steam_id":0,"steam_session_ticket":""}""";
+        var response = await client.PostAsync("/degree/favorite",
+            new StringContent(requestJson, Encoding.UTF8, "application/json"));
+
+        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));
+    }
+}

SVSim.UnitTests/Controllers/DegreeControllerListTests.cs

@@ -0,0 +1,49 @@
+using System.Net;
+using System.Text;
+using System.Text.Json;
+using NUnit.Framework;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.DependencyInjection;
+using SVSim.Database;
+using SVSim.Database.Models;
+using SVSim.UnitTests.Infrastructure;
+
+namespace SVSim.UnitTests.Controllers;
+
+public class DegreeControllerListTests
+{
+    [Test]
+    public async Task DegreeList_returns_owned_ids_wrapped()
+    {
+        using var factory = new SVSimTestFactory();
+        long viewerId = await factory.SeedViewerAsync(tutorialState: 0);
+
+        using (var scope = factory.Services.CreateScope())
+        {
+            var db = scope.ServiceProvider.GetRequiredService<SVSimDbContext>();
+            var viewer = await db.Viewers.Include(v => v.Degrees).FirstAsync(v => v.Id == viewerId);
+            var d100 = await db.Set<DegreeEntry>().FirstOrDefaultAsync(d => d.Id == 100)
+                       ?? db.Set<DegreeEntry>().Add(new DegreeEntry { Id = 100 }).Entity;
+            var d101 = await db.Set<DegreeEntry>().FirstOrDefaultAsync(d => d.Id == 101)
+                       ?? db.Set<DegreeEntry>().Add(new DegreeEntry { Id = 101 }).Entity;
+            viewer.Degrees.Add(d100);
+            viewer.Degrees.Add(d101);
+            await db.SaveChangesAsync();
+        }
+
+        using var client = factory.CreateAuthenticatedClient(viewerId);
+        var requestJson = """{"degree_id":0,"viewer_id":"0","steam_id":0,"steam_session_ticket":""}""";
+        var response = await client.PostAsync("/degree/degree_list",
+            new StringContent(requestJson, Encoding.UTF8, "application/json"));
+
+        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));
+
+        var body = await response.Content.ReadAsStringAsync();
+        using var doc = JsonDocument.Parse(body);
+        var ids = doc.RootElement.GetProperty("user_degree_list").EnumerateArray()
+            .Select(e => e.GetProperty("degree_id").GetInt32())
+            .ToList();
+        Assert.That(ids, Does.Contain(100));
+        Assert.That(ids, Does.Contain(101));
+    }
+}

SVSim.UnitTests/Controllers/DegreeControllerUpdateTests.cs

@@ -0,0 +1,58 @@
+using System.Net;
+using System.Text;
+using NUnit.Framework;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.DependencyInjection;
+using SVSim.Database;
+using SVSim.Database.Models;
+using SVSim.UnitTests.Infrastructure;
+
+namespace SVSim.UnitTests.Controllers;
+
+public class DegreeControllerUpdateTests
+{
+    [Test]
+    public async Task Update_persists_selected_degree_when_owned()
+    {
+        using var factory = new SVSimTestFactory();
+        long viewerId = await factory.SeedViewerAsync(tutorialState: 0);
+
+        using (var scope = factory.Services.CreateScope())
+        {
+            var db = scope.ServiceProvider.GetRequiredService<SVSimDbContext>();
+            var viewer = await db.Viewers.Include(v => v.Degrees).FirstAsync(v => v.Id == viewerId);
+            var d500 = await db.Set<DegreeEntry>().FirstOrDefaultAsync(d => d.Id == 500)
+                       ?? db.Set<DegreeEntry>().Add(new DegreeEntry { Id = 500 }).Entity;
+            viewer.Degrees.Add(d500);
+            await db.SaveChangesAsync();
+        }
+
+        using var client = factory.CreateAuthenticatedClient(viewerId);
+        var requestJson = """{"degree_id":500,"viewer_id":"0","steam_id":0,"steam_session_ticket":""}""";
+        var response = await client.PostAsync("/degree/update_degree",
+            new StringContent(requestJson, Encoding.UTF8, "application/json"));
+
+        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));
+
+        using var scope2 = factory.Services.CreateScope();
+        var db2 = scope2.ServiceProvider.GetRequiredService<SVSimDbContext>();
+        var viewer2 = await db2.Viewers
+            .Include(v => v.Info.SelectedDegree)
+            .FirstAsync(v => v.Id == viewerId);
+        Assert.That(viewer2.Info.SelectedDegree.Id, Is.EqualTo(500));
+    }
+
+    [Test]
+    public async Task Update_rejects_unowned_degree()
+    {
+        using var factory = new SVSimTestFactory();
+        long viewerId = await factory.SeedViewerAsync(tutorialState: 0);
+        using var client = factory.CreateAuthenticatedClient(viewerId);
+
+        var requestJson = """{"degree_id":99999,"viewer_id":"0","steam_id":0,"steam_session_ticket":""}""";
+        var response = await client.PostAsync("/degree/update_degree",
+            new StringContent(requestJson, Encoding.UTF8, "application/json"));
+
+        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
+    }
+}

SVSim.UnitTests/Controllers/EmblemControllerFavoriteTests.cs

@@ -0,0 +1,37 @@
+using System.Net;
+using System.Text;
+using NUnit.Framework;
+using SVSim.UnitTests.Infrastructure;
+
+namespace SVSim.UnitTests.Controllers;
+
+public class EmblemControllerFavoriteTests
+{
+    [Test]
+    public async Task Favorite_accepts_add_and_remove_lists()
+    {
+        using var factory = new SVSimTestFactory();
+        long viewerId = await factory.SeedViewerAsync(tutorialState: 0);
+        using var client = factory.CreateAuthenticatedClient(viewerId);
+
+        var requestJson = """{"favorite_add":["100","101"],"favorite_remove":["200"],"viewer_id":"0","steam_id":0,"steam_session_ticket":""}""";
+        var response = await client.PostAsync("/emblem/favorite",
+            new StringContent(requestJson, Encoding.UTF8, "application/json"));
+
+        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));
+    }
+
+    [Test]
+    public async Task Favorite_accepts_empty_lists()
+    {
+        using var factory = new SVSimTestFactory();
+        long viewerId = await factory.SeedViewerAsync(tutorialState: 0);
+        using var client = factory.CreateAuthenticatedClient(viewerId);
+
+        var requestJson = """{"favorite_add":[],"favorite_remove":[],"viewer_id":"0","steam_id":0,"steam_session_ticket":""}""";
+        var response = await client.PostAsync("/emblem/favorite",
+            new StringContent(requestJson, Encoding.UTF8, "application/json"));
+
+        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));
+    }
+}

SVSim.UnitTests/Controllers/EmblemControllerListTests.cs

@@ -0,0 +1,49 @@
+using System.Net;
+using System.Text;
+using System.Text.Json;
+using NUnit.Framework;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.DependencyInjection;
+using SVSim.Database;
+using SVSim.Database.Models;
+using SVSim.UnitTests.Infrastructure;
+
+namespace SVSim.UnitTests.Controllers;
+
+public class EmblemControllerListTests
+{
+    [Test]
+    public async Task EmblemList_returns_owned_ids_wrapped()
+    {
+        using var factory = new SVSimTestFactory();
+        long viewerId = await factory.SeedViewerAsync(tutorialState: 0);
+
+        using (var scope = factory.Services.CreateScope())
+        {
+            var db = scope.ServiceProvider.GetRequiredService<SVSimDbContext>();
+            var viewer = await db.Viewers.Include(v => v.Emblems).FirstAsync(v => v.Id == viewerId);
+            var e100 = await db.Set<EmblemEntry>().FirstOrDefaultAsync(e => e.Id == 100)
+                       ?? db.Set<EmblemEntry>().Add(new EmblemEntry { Id = 100 }).Entity;
+            var e101 = await db.Set<EmblemEntry>().FirstOrDefaultAsync(e => e.Id == 101)
+                       ?? db.Set<EmblemEntry>().Add(new EmblemEntry { Id = 101 }).Entity;
+            viewer.Emblems.Add(e100);
+            viewer.Emblems.Add(e101);
+            await db.SaveChangesAsync();
+        }
+
+        using var client = factory.CreateAuthenticatedClient(viewerId);
+        var requestJson = """{"viewer_id":"0","steam_id":0,"steam_session_ticket":""}""";
+        var response = await client.PostAsync("/emblem/emblem_list",
+            new StringContent(requestJson, Encoding.UTF8, "application/json"));
+
+        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));
+
+        var body = await response.Content.ReadAsStringAsync();
+        using var doc = JsonDocument.Parse(body);
+        var ids = doc.RootElement.GetProperty("user_emblem_list").EnumerateArray()
+            .Select(e => e.GetProperty("emblem_id").GetInt32())
+            .ToList();
+        Assert.That(ids, Does.Contain(100));
+        Assert.That(ids, Does.Contain(101));
+    }
+}

SVSim.UnitTests/Controllers/EmblemControllerUpdateTests.cs

@@ -0,0 +1,58 @@
+using System.Net;
+using System.Text;
+using NUnit.Framework;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.DependencyInjection;
+using SVSim.Database;
+using SVSim.Database.Models;
+using SVSim.UnitTests.Infrastructure;
+
+namespace SVSim.UnitTests.Controllers;
+
+public class EmblemControllerUpdateTests
+{
+    [Test]
+    public async Task Update_persists_selected_emblem_when_owned()
+    {
+        using var factory = new SVSimTestFactory();
+        long viewerId = await factory.SeedViewerAsync(tutorialState: 0);
+
+        using (var scope = factory.Services.CreateScope())
+        {
+            var db = scope.ServiceProvider.GetRequiredService<SVSimDbContext>();
+            var viewer = await db.Viewers.Include(v => v.Emblems).FirstAsync(v => v.Id == viewerId);
+            var e500 = await db.Set<EmblemEntry>().FirstOrDefaultAsync(e => e.Id == 500)
+                       ?? db.Set<EmblemEntry>().Add(new EmblemEntry { Id = 500 }).Entity;
+            viewer.Emblems.Add(e500);
+            await db.SaveChangesAsync();
+        }
+
+        using var client = factory.CreateAuthenticatedClient(viewerId);
+        var requestJson = """{"emblem_id":500,"viewer_id":"0","steam_id":0,"steam_session_ticket":""}""";
+        var response = await client.PostAsync("/emblem/update_emblem",
+            new StringContent(requestJson, Encoding.UTF8, "application/json"));
+
+        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.OK));
+
+        using var scope2 = factory.Services.CreateScope();
+        var db2 = scope2.ServiceProvider.GetRequiredService<SVSimDbContext>();
+        var viewer2 = await db2.Viewers
+            .Include(v => v.Info.SelectedEmblem)
+            .FirstAsync(v => v.Id == viewerId);
+        Assert.That(viewer2.Info.SelectedEmblem.Id, Is.EqualTo(500));
+    }
+
+    [Test]
+    public async Task Update_rejects_unowned_emblem()
+    {
+        using var factory = new SVSimTestFactory();
+        long viewerId = await factory.SeedViewerAsync(tutorialState: 0);
+        using var client = factory.CreateAuthenticatedClient(viewerId);
+
+        var requestJson = """{"emblem_id":99999,"viewer_id":"0","steam_id":0,"steam_session_ticket":""}""";
+        var response = await client.PostAsync("/emblem/update_emblem",
+            new StringContent(requestJson, Encoding.UTF8, "application/json"));
+
+        Assert.That(response.StatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
+    }
+}