feat(fifa17): project owned kits with active home/away designation

Closes the server side of the FUT kit selector. Ownership stays generic in
Core (submodule bump: club_kit_assignments + GET/PUT /club/kits); this
commit adds the FIFA17 representation, the host projection and importer
support.

adapter:
* ContentKind::Kit ("kit") so kits are classified alongside player/staff/
  consumable instead of being mistaken for 0-rated players.
* Fifa17CardIdentity carries card_asset_id and team_id; RawCard keeps both
  optional because the emitted catalog writes null for non-kit definitions.
* shape_kit_item emits only the fields the client's kit path reads
  (id/resourceId/assetId/cardassetid/cardsubtypeid/itemState/owners/
  untradeable/teamid) — no attributeList, no itemType.
* itemState on the wire is the STRING token activeHomeKit/activeAwayKit;
  the 101/102 integers are the client's post-deserialisation runtime enum
  (item+0x5c) and are never emitted.
* club_stats S_KITS (0x28) now counts owned kits instead of a hard zero.

host:
* CoreKitAssignments + CoreAccess::get_active_kits (GET /club/kits),
  defaulting to no active kits so a Core without the endpoint degrades
  instead of fabricating a designation.
* handle_club classifies type=player|kit, rejects any other type with an
  empty page and outcome=unsupported_type, and now always fetches
  unpaginated from Core: kind and transfer-pile membership are host-side
  concepts Core cannot express, so filtering and pagination must both
  happen after shaping or pages come back short.

importer:
* ItemClass::Kit (cardsubtypeid == 9 and resourceId in 6_300_000..=6_400_654),
  kit counts/balances, and card_asset_id/team_id carried into the emitted
  catalog and manifest.
* a kit group missing cardassetid == 35 or teamid is DEFERRED
  (missing_kit_render_metadata) rather than defaulted; conflicting render
  metadata across instances defers as render_metadata_conflict.

staging: sold-staging-up.py seeds two owned kits (6300006 home / 6400003
away, team 21) plus both active designations so the projection can be
verified over HTTP before involving the client.

openfut-adapter-fifa17/src/fut/club_response.rs

@@ -11,33 +11,65 @@ use serde_json::{json, Value};
 
 use crate::fut::content_taxonomy::ContentKind;
 use crate::fut::entities::ReverseEntityResolver;
-use crate::fut::item::shape_item;
+use crate::fut::item::{shape_item, shape_kit_item};
 // Re-exported so existing `club_response::{…}` callers keep working; the types
 // are now defined once in `fut::item`.
-pub use crate::fut::item::{CoreOwnedItem, Fifa17Identity, ItemIdentityResolver, ShapeStats};
+pub use crate::fut::item::{
+    CoreOwnedItem, Fifa17Identity, Fifa17KitIdentity, ItemIdentityResolver, ShapeStats,
+};
 
-/// Shape the whole `/club` response. Items without a resolvable real asset id
-/// are dropped (counted in `ShapeStats`), never emitted with a fabricated id.
+/// Active club-level kit roles, keyed by Core owned-instance id.
+#[derive(Debug, Clone, Copy, Default)]
+pub struct ActiveKitAssignments<'a> {
+    pub home: Option<&'a str>,
+    pub away: Option<&'a str>,
+}
+
+/// Shape the player portion of `/club` (the historical/default query).
 pub fn shape_club_response<I: ItemIdentityResolver + ?Sized>(
     items: &[CoreOwnedItem],
     ent: &impl ReverseEntityResolver,
     ident: &I,
+) -> (Value, ShapeStats) {
+    shape_club_response_with_kits(items, ent, ident, ActiveKitAssignments::default())
+}
+
+/// Shape `/club` items, including ownership-backed active kit designations.
+/// Consumables/staff remain excluded because they use separate wire envelopes.
+pub fn shape_club_response_with_kits<I: ItemIdentityResolver + ?Sized>(
+    items: &[CoreOwnedItem],
+    ent: &impl ReverseEntityResolver,
+    ident: &I,
+    active_kits: ActiveKitAssignments<'_>,
 ) -> (Value, ShapeStats) {
     let mut out = Vec::with_capacity(items.len());
     let mut stats = ShapeStats::default();
     for item in items {
-        // Exclude non-player content (consumables/staff): a `/club` player list
-        // must never render them as 0-rated players. Counted, never emitted.
-        if ident.kind_of(item) != ContentKind::Player {
-            stats.excluded_non_player += 1;
-            continue;
-        }
-        match ident.resolve(item) {
-            Some(id) => {
-                out.push(shape_item(item, id, ent));
-                stats.emitted += 1;
+        match ident.kind_of(item) {
+            ContentKind::Player => match ident.resolve(item) {
+                Some(id) => {
+                    out.push(shape_item(item, id, ent));
+                    stats.emitted += 1;
+                }
+                None => stats.dropped_no_asset += 1,
+            },
+            ContentKind::Kit => match ident.resolve_kit(item) {
+                Some(id) => {
+                    let item_state = if active_kits.home == Some(item.owned_card_id.as_str()) {
+                        "activeHomeKit"
+                    } else if active_kits.away == Some(item.owned_card_id.as_str()) {
+                        "activeAwayKit"
+                    } else {
+                        "free"
+                    };
+                    out.push(shape_kit_item(id, item_state));
+                    stats.emitted += 1;
+                }
+                None => stats.dropped_no_asset += 1,
+            },
+            ContentKind::Consumable | ContentKind::Staff => {
+                stats.excluded_non_player += 1;
             }
-            None => stats.dropped_no_asset += 1,
         }
     }
     (json!({ "itemData": out }), stats)
@@ -207,11 +239,15 @@ mod tests {
     struct KindMapIdentity {
         ids: HashMap<String, Fifa17Identity>,
         kinds: HashMap<String, ContentKind>,
+        kits: HashMap<String, Fifa17KitIdentity>,
     }
     impl ItemIdentityResolver for KindMapIdentity {
         fn resolve(&self, it: &CoreOwnedItem) -> Option<Fifa17Identity> {
             self.ids.get(&it.card_id).copied()
         }
+        fn resolve_kit(&self, it: &CoreOwnedItem) -> Option<Fifa17KitIdentity> {
+            self.kits.get(&it.card_id).copied()
+        }
         fn kind_of(&self, it: &CoreOwnedItem) -> ContentKind {
             self.kinds
                 .get(&it.card_id)
@@ -235,6 +271,7 @@ mod tests {
                 ("card_consumable".to_string(), id(100000002, 5003012)),
                 ("card_staff".to_string(), id(100000003, 3000083)),
             ]),
+            kits: HashMap::new(),
             kinds: HashMap::from([
                 ("card_consumable".to_string(), ContentKind::Consumable),
                 ("card_staff".to_string(), ContentKind::Staff),
@@ -262,4 +299,50 @@ mod tests {
         assert_eq!(arr[0]["id"], 100000001, "the player survives");
         assert_eq!(arr[0]["itemType"], "player");
     }
+
+    #[test]
+    fn kits_project_with_owned_active_home_and_away_states() {
+        let ent = entities();
+        let kit = |item_id, resource_id, team_id| Fifa17KitIdentity {
+            item_id,
+            asset_id: resource_id,
+            resource_id,
+            card_asset_id: 35,
+            subtype: 9,
+            team_id,
+        };
+        let ident = KindMapIdentity {
+            ids: HashMap::new(),
+            kits: HashMap::from([
+                ("kit-home".into(), kit(100000010, 6300006, 21)),
+                ("kit-away".into(), kit(100000011, 6400003, 21)),
+            ]),
+            kinds: HashMap::from([
+                ("kit-home".into(), ContentKind::Kit),
+                ("kit-away".into(), ContentKind::Kit),
+            ]),
+        };
+        let items = vec![
+            item("owned-home", "kit-home", 0, "", "", "", ""),
+            item("owned-away", "kit-away", 0, "", "", "", ""),
+        ];
+        let (body, stats) = shape_club_response_with_kits(
+            &items,
+            &ent,
+            &ident,
+            ActiveKitAssignments {
+                home: Some("owned-home"),
+                away: Some("owned-away"),
+            },
+        );
+        assert_eq!(stats.emitted, 2);
+        assert_eq!(body["itemData"][0]["resourceId"], 6300006);
+        assert_eq!(body["itemData"][0]["cardassetid"], 35);
+        assert_eq!(body["itemData"][0]["cardsubtypeid"], 9);
+        assert_eq!(body["itemData"][0]["teamid"], 21);
+        assert_eq!(body["itemData"][0]["itemState"], "activeHomeKit");
+        assert_eq!(body["itemData"][1]["itemState"], "activeAwayKit");
+        assert!(body["itemData"][0].get("attributeList").is_none());
+        assert!(body["itemData"][0].get("itemType").is_none());
+    }
 }