Minor: Set completion tracking (#19)

core/AGENTS.md

@@ -4,11 +4,11 @@
 
 ## Layer pointers
 
-- `include/ccm/domain/` — POD value types: `Enums` (includes `PokemonRegion`), `Set`, `MagicCard`, `PokemonCard` (unified West/Asia via `region`), `YuGiOhCard`, `DigiBattle99Card`, `JapanesePokemonCard` (legacy type retained for tests/serde; app collection uses `PokemonCard`), `Configuration`. Each has `to_json` / `from_json` defined in the matching `src/domain/*.cpp`.
+- `include/ccm/domain/` — POD value types: `Enums` (includes `PokemonRegion`), `Set`, `MagicCard`, `PokemonCard` (unified West/Asia via `region`), `YuGiOhCard`, `YuGiOhSetCatalog` (Yu-Gi-Oh! pack checklists for set completion), `DigiBattle99Card`, `DigiBattle99SetCatalog` (Digi-Battle pack checklists for set completion), `PokemonSetCatalog` (Pokemon West/Asia pack checklists for set completion), `JapanesePokemonCard` (legacy type retained for tests/serde; app collection uses `PokemonCard`), `Configuration`. Each has `to_json` / `from_json` defined in the matching `src/domain/*.cpp`.
 - `include/ccm/ports/` — interfaces (`IHttpClient`, `IFileSystem`, `ICollectionRepository<T>`, `ISetRepository`, `IImageStore`, `ICardPreviewSource`, `IPreviewByteCache`). All seams the services depend on. Add new ports here when adding new external concerns.
-- `include/ccm/services/` — high-level operations: `ConfigService`, `CollectionService<TCard>` (header-only template), `SetService`, `ImageService`, `CardPreviewService`, `CardSorter` (free functions; per-column sort comparators that mirror established table sorting behavior — UI-agnostic so they can be unit-tested directly), `CardFilter` (free functions; case-insensitive substring row matcher restricted to each game's `tableFields` valueKey list). They depend only on ports.
 - `include/ccm/infra/` — concrete adapters: `CprHttpClient`, `StdFileSystem`, `JsonCollectionRepository<T>` (header-only template), `JsonSetRepository`, `LocalImageStore`, `LocalPreviewByteCache`.
-- `include/ccm/games/` — `IGameModule` + per-game modules. `IGameModule` consolidates the per-game seams: every module owns an `ISetSource` (required) and may own an `ICardPreviewSource` (optional, default `nullptr`). `magic/`, `pokemon/`, `yugioh/`, `digibattle99/`, and `pokemonjp/` are the reference implementations — all five expose a fully working set source + card preview source. `pokemonjp/` is the **Asia region backend** for the unified Pokemon UI (set cache at `pokemon/sets-asia.json`, same data dir as West; TCGdex JA previews); it is registered for sets/previews but is not a separate Game menu entry. Japanese Pokémon also loads an optional EN name catalog (`JapanesePokemonEnCatalog`) for display/auto-detect.
+- `include/ccm/services/` — high-level operations: `ConfigService`, `CollectionService<TCard>` (header-only template), `SetService`, `ImageService`, `CardPreviewService`, `CardSorter` (free functions; per-column sort comparators that mirror established table sorting behavior — UI-agnostic so they can be unit-tested directly), `CardFilter` (free functions; case-insensitive substring row matcher restricted to each game's `tableFields` valueKey list), `YuGiOhSetCompletion` / `DigiBattle99SetCompletion` / `PokemonSetCompletion` (pure set-completion / checklist helpers), `YuGiOhSetCatalogService` (`yugioh/set-catalog.json`), `DigiBattle99SetCatalogService` (`digibattle99/set-catalog.json`), `PokemonSetCatalogService` (`pokemon/set-catalog-west.json` / `set-catalog-asia.json`). They depend only on ports / domain.
+- `include/ccm/games/` — `IGameModule` + per-game modules. `IGameModule` consolidates the per-game seams: every module owns an `ISetSource` (required) and may own an `ICardPreviewSource` (optional, default `nullptr`). `magic/`, `pokemon/`, `yugioh/`, `digibattle99/`, and `pokemonjp/` are the reference implementations — all five expose a fully working set source + card preview source. `YuGiOhSetSource`, `DigiBattle99SetSource`, `PokemonSetSource`, and `JapanesePokemonSetSource` also expose `parseCatalog` / `fetchAllWithCatalog` (or Asia equivalents) for set-completion checklists. `pokemonjp/` is the **Asia region backend** for the unified Pokemon UI (set cache at `pokemon/sets-asia.json`, same data dir as West; TCGdex JA previews); it is registered for sets/previews but is not a separate Game menu entry. Japanese Pokémon also loads an optional EN name catalog (`JapanesePokemonEnCatalog`) for display/auto-detect / Asia set-completion gap-fill.
 - `include/ccm/util/` — `Result.hpp` (the sum type), `FsNames.hpp` (filename munging ported from `util/fs.rs`), `YuGiOhPrintingSlot.hpp` / `YuGiOhSetLookup.hpp` (Yu-Gi-Oh! print-slot helpers and cached-set **set code** lookup for the edit dialog; both header-only, unit-tested).
 - `src/` mirrors `include/ccm/` for non-template implementations.
 

core/CMakeLists.txt

@@ -8,6 +8,9 @@ add_library(ccm_core STATIC
     src/domain/PokemonCard.cpp
     src/domain/YuGiOhCard.cpp
     src/domain/DigiBattle99Card.cpp
+    src/domain/DigiBattle99SetCatalog.cpp
+    src/domain/YuGiOhSetCatalog.cpp
+    src/domain/PokemonSetCatalog.cpp
     src/domain/JapanesePokemonCard.cpp
     src/domain/Configuration.cpp
 
@@ -17,6 +20,12 @@ add_library(ccm_core STATIC
     src/services/CardPreviewService.cpp
     src/services/CardSorter.cpp
     src/services/CardFilter.cpp
+    src/services/DigiBattle99SetCompletion.cpp
+    src/services/DigiBattle99SetCatalogService.cpp
+    src/services/YuGiOhSetCompletion.cpp
+    src/services/YuGiOhSetCatalogService.cpp
+    src/services/PokemonSetCompletion.cpp
+    src/services/PokemonSetCatalogService.cpp
 
     src/infra/CprHttpClient.cpp
     src/infra/StdFileSystem.cpp

core/include/ccm/domain/DigiBattle99SetCatalog.hpp

@@ -0,0 +1,52 @@
+#pragma once
+
+// DigiBattle99SetCatalog: offline pack → card checklist for Digi-Battle set
+// completion. Filled from digimoncard.io bulk search.php (same payload as the
+// set list) and persisted at `<dataStorage>/digibattle99/set-catalog.json`.
+
+#include <nlohmann/json.hpp>
+
+#include <cstddef>
+#include <string>
+#include <string_view>
+#include <vector>
+
+namespace ccm {
+
+struct DigiBattle99CatalogCard {
+    std::string setNo;
+    std::string name;
+
+    friend bool operator==(const DigiBattle99CatalogCard&,
+                           const DigiBattle99CatalogCard&) = default;
+};
+
+struct DigiBattle99SetCatalogPack {
+    std::string setId;
+    std::string setName;
+    std::vector<DigiBattle99CatalogCard> cards;
+
+    friend bool operator==(const DigiBattle99SetCatalogPack&,
+                           const DigiBattle99SetCatalogPack&) = default;
+};
+
+struct DigiBattle99SetCatalog {
+    std::vector<DigiBattle99SetCatalogPack> packs;
+
+    [[nodiscard]] const DigiBattle99SetCatalogPack* findPack(
+        std::string_view setId) const;
+
+    [[nodiscard]] bool empty() const noexcept { return packs.empty(); }
+
+    friend bool operator==(const DigiBattle99SetCatalog&,
+                           const DigiBattle99SetCatalog&) = default;
+};
+
+void to_json(nlohmann::json& j, const DigiBattle99CatalogCard& c);
+void from_json(const nlohmann::json& j, DigiBattle99CatalogCard& c);
+void to_json(nlohmann::json& j, const DigiBattle99SetCatalogPack& p);
+void from_json(const nlohmann::json& j, DigiBattle99SetCatalogPack& p);
+void to_json(nlohmann::json& j, const DigiBattle99SetCatalog& c);
+void from_json(const nlohmann::json& j, DigiBattle99SetCatalog& c);
+
+}  // namespace ccm

core/include/ccm/domain/PokemonSetCatalog.hpp

@@ -0,0 +1,52 @@
+#pragma once
+
+// PokemonSetCatalog: offline pack → card checklist for Pokemon set
+// completion. West and Asia each persist their own file under
+// `<dataStorage>/pokemon/` (`set-catalog-west.json` / `set-catalog-asia.json`).
+
+#include <nlohmann/json.hpp>
+
+#include <cstddef>
+#include <string>
+#include <string_view>
+#include <vector>
+
+namespace ccm {
+
+struct PokemonCatalogCard {
+    std::string setNo;
+    std::string name;
+
+    friend bool operator==(const PokemonCatalogCard&,
+                           const PokemonCatalogCard&) = default;
+};
+
+struct PokemonSetCatalogPack {
+    std::string setId;
+    std::string setName;
+    std::vector<PokemonCatalogCard> cards;
+
+    friend bool operator==(const PokemonSetCatalogPack&,
+                           const PokemonSetCatalogPack&) = default;
+};
+
+struct PokemonSetCatalog {
+    std::vector<PokemonSetCatalogPack> packs;
+
+    [[nodiscard]] const PokemonSetCatalogPack* findPack(
+        std::string_view setId) const;
+
+    [[nodiscard]] bool empty() const noexcept { return packs.empty(); }
+
+    friend bool operator==(const PokemonSetCatalog&,
+                           const PokemonSetCatalog&) = default;
+};
+
+void to_json(nlohmann::json& j, const PokemonCatalogCard& c);
+void from_json(const nlohmann::json& j, PokemonCatalogCard& c);
+void to_json(nlohmann::json& j, const PokemonSetCatalogPack& p);
+void from_json(const nlohmann::json& j, PokemonSetCatalogPack& p);
+void to_json(nlohmann::json& j, const PokemonSetCatalog& c);
+void from_json(const nlohmann::json& j, PokemonSetCatalog& c);
+
+}  // namespace ccm

core/include/ccm/domain/YuGiOhSetCatalog.hpp

@@ -0,0 +1,52 @@
+#pragma once
+
+// YuGiOhSetCatalog: offline pack → card checklist for Yu-Gi-Oh! set
+// completion. Filled from YGOPRODeck cardinfo.php (all-cards dump) and
+// persisted at `<dataStorage>/yugioh/set-catalog.json`.
+
+#include <nlohmann/json.hpp>
+
+#include <cstddef>
+#include <string>
+#include <string_view>
+#include <vector>
+
+namespace ccm {
+
+struct YuGiOhCatalogCard {
+    std::string setNo;
+    std::string name;
+
+    friend bool operator==(const YuGiOhCatalogCard&,
+                           const YuGiOhCatalogCard&) = default;
+};
+
+struct YuGiOhSetCatalogPack {
+    std::string setId;
+    std::string setName;
+    std::vector<YuGiOhCatalogCard> cards;
+
+    friend bool operator==(const YuGiOhSetCatalogPack&,
+                           const YuGiOhSetCatalogPack&) = default;
+};
+
+struct YuGiOhSetCatalog {
+    std::vector<YuGiOhSetCatalogPack> packs;
+
+    [[nodiscard]] const YuGiOhSetCatalogPack* findPack(
+        std::string_view setId) const;
+
+    [[nodiscard]] bool empty() const noexcept { return packs.empty(); }
+
+    friend bool operator==(const YuGiOhSetCatalog&,
+                           const YuGiOhSetCatalog&) = default;
+};
+
+void to_json(nlohmann::json& j, const YuGiOhCatalogCard& c);
+void from_json(const nlohmann::json& j, YuGiOhCatalogCard& c);
+void to_json(nlohmann::json& j, const YuGiOhSetCatalogPack& p);
+void from_json(const nlohmann::json& j, YuGiOhSetCatalogPack& p);
+void to_json(nlohmann::json& j, const YuGiOhSetCatalog& c);
+void from_json(const nlohmann::json& j, YuGiOhSetCatalog& c);
+
+}  // namespace ccm

core/include/ccm/games/digibattle99/DigiBattle99SetSource.hpp

@@ -3,12 +3,15 @@
 // DigiBattle99SetSource: ISetSource for Digimon Digi-Battle (1999 English).
 // digimoncard.io has no dedicated sets endpoint; we derive unique pack names
 // from a bulk search.php call scoped to series=Digimon Digi-Battle Card Game.
+// The same payload also builds the set-completion catalog (parseCatalog).
 
+#include "ccm/domain/DigiBattle99SetCatalog.hpp"
 #include "ccm/games/IGameModule.hpp"
 #include "ccm/ports/IHttpClient.hpp"
 
 #include <string>
 #include <string_view>
+#include <vector>
 
 namespace ccm {
 
@@ -20,12 +23,21 @@ public:
 
     static constexpr const char* kSeries = "Digimon Digi-Battle Card Game";
 
+    struct FetchWithCatalog {
+        std::vector<Set>         sets;
+        DigiBattle99SetCatalog   catalog;
+    };
+
     explicit DigiBattle99SetSource(IHttpClient& http);
 
     Result<std::vector<Set>> fetchAll() override;
 
-    // Pure parser exposed for unit testing without a network round-trip.
+    // One HTTP round-trip producing both the set list and the pack catalog.
+    Result<FetchWithCatalog> fetchAllWithCatalog();
+
+    // Pure parsers exposed for unit testing without a network round-trip.
     static Result<std::vector<Set>> parseResponse(const std::string& body);
+    static Result<DigiBattle99SetCatalog> parseCatalog(const std::string& body);
 
     // Stable Set.id from a pack display name (ASCII lower, non-alnum -> '-').
     static std::string slugifyPackName(std::string_view packName);

core/include/ccm/games/pokemon/PokemonCardPreviewSource.hpp

@@ -1,11 +1,11 @@
 #pragma once
 
 // PokemonCardPreviewSource: ICardPreviewSource implementation for the Pokemon
-// TCG. Calls the Pokemon TCG search endpoint at
-//   https://api.pokemontcg.io/v2/cards?q=name:"<name>" set.id:<setId> number:<setNo>
-// and returns `data[0].images.large` (with `images.small` as a graceful
-// fallback). Mirrors the established `getImage` flow in
-// `src/components/pokemon/SelectedPokemonPanel.tsx`.
+// TCG. When set id + collector number are both known, prefers
+//   GET https://api.pokemontcg.io/v2/cards/{setId}-{number}
+// then falls back to a name-less search `set.id:… number:…`. Name-based
+// search is kept for lookups that lack a set number (or set id). Returns
+// `images.large` (with `images.small` as a graceful fallback).
 
 #include "ccm/ports/ICardPreviewSource.hpp"
 #include "ccm/ports/IHttpClient.hpp"
@@ -32,24 +32,37 @@ public:
                                                                std::string_view setId) override;
 
     // Build the fully URL-encoded Pokemon TCG search URL for the given card.
+    // When both setId and setNo are non-empty, omits the name: clause so the
+    // Lucene query cannot miss on name∩number intersections.
     // Exposed for unit testing and to keep encoding rules in one place.
     static std::string buildSearchUrl(std::string_view name,
                                       std::string_view setId,
                                       std::string_view setNo);
 
+    // Direct card endpoint: /v2/cards/{setId}-{normalizedNumber}.
+    static std::string buildCardByIdUrl(std::string_view setId, std::string_view setNo);
+
+    // Strip everything after the first '/' (e.g. "4/102" -> "4"). Used by
+    // preview lookups, auto-detect, and set-completion ownership matching.
+    static std::string normalizeCollectorNumber(std::string_view setNo);
+
     // Slimmer search URL for auto-detect: omits the number clause and asks the
     // API for only the fields the print-variant parser needs.
     static std::string buildDetectSearchUrl(std::string_view name,
                                             std::string_view setId);
 
-    // Parse a Pokemon TCG /v2/cards response body and pull out the image URL
-    // for the first matching card. Prefers `images.large`, falls back to
-    // `images.small`. Errors are classified:
+    // Parse a Pokemon TCG /v2/cards *search* response body (`data` array) and
+    // pull out the image URL for the first matching card. Prefers
+    // `images.large`, falls back to `images.small`. Errors are classified:
     //   - JSON parse failure or missing/non-array `data` => Transient.
     //   - Empty `data` array or missing image variants => NotFound.
     static Result<std::string, PreviewLookupError>
         parseResponse(const std::string& body);
 
+    // Parse a Pokemon TCG /v2/cards/{id} response (`data` object).
+    static Result<std::string, PreviewLookupError>
+        parseCardByIdResponse(const std::string& body);
+
     // Enumerate distinct collector numbers (and rarities) for an exact card
     // name inside the chosen set. Exposed for unit testing without HTTP.
     static Result<std::vector<AutoDetectedPrint>>

core/include/ccm/games/pokemon/PokemonSetSource.hpp

@@ -6,23 +6,56 @@
 // The Pokemon TCG API already returns `releaseDate` in `YYYY/MM/DD` format,
 // so no rewriting is needed (unlike Scryfall's `released_at`).
 // Behavior matches `pokemon/set_services.rs::update_sets`.
+// Set-completion catalog is built from a paginated /v2/cards dump.
 
+#include "ccm/domain/PokemonSetCatalog.hpp"
+#include "ccm/domain/Set.hpp"
 #include "ccm/games/IGameModule.hpp"
 #include "ccm/ports/IHttpClient.hpp"
 
+#include <string>
+#include <vector>
+
 namespace ccm {
 
 class PokemonSetSource final : public ISetSource {
 public:
     static constexpr const char* kEndpoint = "https://api.pokemontcg.io/v2/sets";
+    static constexpr const char* kCardsEndpoint = "https://api.pokemontcg.io/v2/cards";
+    static constexpr int         kCardsPageSize = 250;
+
+    struct FetchWithCatalog {
+        std::vector<Set>   sets;
+        PokemonSetCatalog  catalog;
+    };
 
     explicit PokemonSetSource(IHttpClient& http);
 
     Result<std::vector<Set>> fetchAll() override;
 
+    // Sets endpoint + paginated cards dump for the offline checklist.
+    Result<FetchWithCatalog> fetchAllWithCatalog();
+
     // Pure parser exposed for unit testing without a network round-trip.
     static Result<std::vector<Set>> parseResponse(const std::string& body);
 
+    // Build / merge checklist packs from one /v2/cards page body. Pass an
+    // accumulating catalog; returns page count metadata for pagination.
+    struct CardsPageMeta {
+        int page{1};
+        int pageSize{kCardsPageSize};
+        int count{0};
+        int totalCount{0};
+    };
+    static Result<CardsPageMeta> mergeCardsPage(const std::string& body,
+                                                PokemonSetCatalog& catalog,
+                                                const std::vector<Set>& sets);
+
+    static Result<PokemonSetCatalog> parseCatalog(const std::string& body,
+                                                  const std::vector<Set>& sets);
+
+    static std::string buildCardsPageUrl(int page, int pageSize = kCardsPageSize);
+
 private:
     IHttpClient& http_;
 };

core/include/ccm/games/pokemonjp/JapanesePokemonEnCatalog.hpp

@@ -54,6 +54,10 @@ public:
 
     [[nodiscard]] bool hasPrintsForSet(std::string_view setId) const noexcept;
 
+    // All prints for a set (catalog gap-fill / set-completion checklists).
+    [[nodiscard]] std::vector<JapanesePokemonPrintEnInfo>
+        printsForSet(std::string_view setId) const;
+
     // TCGPlayer product-image CDN URL for classic JA gap-fill.
     [[nodiscard]] static std::string tcgplayerImageUrl(std::string_view productId);
 

core/include/ccm/games/pokemonjp/JapanesePokemonSetSource.hpp

@@ -1,22 +1,37 @@
 #pragma once
 
 // JapanesePokemonSetSource: TCGdex ja set list + per-set detail for release
-// dates. English display names come from JapanesePokemonEnCatalog when present.
+// dates and set-completion checklists. English display names come from
+// JapanesePokemonEnCatalog when present.
 
+#include "ccm/domain/PokemonSetCatalog.hpp"
+#include "ccm/domain/Set.hpp"
 #include "ccm/games/IGameModule.hpp"
 #include "ccm/games/pokemonjp/JapanesePokemonEnCatalog.hpp"
 #include "ccm/ports/IHttpClient.hpp"
 
+#include <string>
+#include <string_view>
+#include <vector>
+
 namespace ccm {
 
 class JapanesePokemonSetSource final : public ISetSource {
 public:
     static constexpr const char* kListEndpoint = "https://api.tcgdex.net/v2/ja/sets";
 
+    struct FetchWithCatalog {
+        std::vector<Set>   sets;
+        PokemonSetCatalog  catalog;
+    };
+
     JapanesePokemonSetSource(IHttpClient& http, const JapanesePokemonEnCatalog& catalog);
 
     Result<std::vector<Set>> fetchAll() override;
 
+    // List + per-set detail (cards + release date) + EN catalog gap-fill.
+    Result<FetchWithCatalog> fetchAllWithCatalog();
+
     void augmentCachedSets(std::vector<Set>& sets) const override;
 
     // Pure parsers for hermetic tests.
@@ -28,6 +43,16 @@ public:
     static std::string rewriteReleaseDate(std::string_view isoDate);
     static std::string buildSetDetailUrl(std::string_view setId);
 
+    // Build one pack checklist from a set-detail body, then gap-fill from catalog.
+    static Result<PokemonSetCatalogPack> parseCatalogPackFromSetDetail(
+        const std::string& detailBody,
+        const Set&         set,
+        const JapanesePokemonEnCatalog& enCatalog);
+
+    // Catalog-only pack (classic products with no TCGdex detail).
+    static PokemonSetCatalogPack catalogPackFromEnCatalog(
+        const Set& set, const JapanesePokemonEnCatalog& enCatalog);
+
     // Original-era theme decks / sheets omitted by TCGdex JA. Idempotent by id.
     static void appendMissingClassicProducts(std::vector<Set>& sets);
 

core/include/ccm/games/yugioh/YuGiOhSetSource.hpp

@@ -1,21 +1,45 @@
 #pragma once
 
 // YuGiOhSetSource: ISetSource implementation for Yu-Gi-Oh via YGOPRODeck.
+// Sets come from cardsets.php; the set-completion catalog is built from the
+// unfiltered cardinfo.php dump (card_sets[] per card).
 
+#include "ccm/domain/Set.hpp"
+#include "ccm/domain/YuGiOhSetCatalog.hpp"
 #include "ccm/games/IGameModule.hpp"
 #include "ccm/ports/IHttpClient.hpp"
 
+#include <string>
+#include <vector>
+
 namespace ccm {
 
 class YuGiOhSetSource final : public ISetSource {
 public:
     static constexpr const char* kEndpoint = "https://db.ygoprodeck.com/api/v7/cardsets.php";
+    static constexpr const char* kCardInfoEndpoint =
+        "https://db.ygoprodeck.com/api/v7/cardinfo.php";
+
+    struct FetchWithCatalog {
+        std::vector<Set>   sets;
+        YuGiOhSetCatalog   catalog;
+    };
 
     explicit YuGiOhSetSource(IHttpClient& http);
 
     Result<std::vector<Set>> fetchAll() override;
+
+    // Two HTTP round-trips: cardsets.php for the set list, cardinfo.php for
+    // the pack checklist catalog.
+    Result<FetchWithCatalog> fetchAllWithCatalog();
+
     static Result<std::vector<Set>> parseResponse(const std::string& body);
 
+    // Build the offline checklist from a cardinfo.php body, resolving pack
+    // ids against the already-parsed sets list (by set_name → Set.id).
+    static Result<YuGiOhSetCatalog> parseCatalog(const std::string&          body,
+                                                 const std::vector<Set>&     sets);
+
 private:
     IHttpClient& http_;
 };

core/include/ccm/services/DigiBattle99SetCatalogService.hpp

@@ -0,0 +1,36 @@
+#pragma once
+
+// DigiBattle99SetCatalogService: load/save digibattle99/set-catalog.json under
+// the configured dataStorage path.
+
+#include "ccm/domain/DigiBattle99SetCatalog.hpp"
+#include "ccm/domain/Enums.hpp"
+#include "ccm/ports/IFileSystem.hpp"
+#include "ccm/services/ConfigService.hpp"
+#include "ccm/util/Result.hpp"
+
+#include <functional>
+#include <string>
+
+namespace ccm {
+
+class DigiBattle99SetCatalogService {
+public:
+    using DirNameFn = std::function<std::string(Game)>;
+
+    DigiBattle99SetCatalogService(IFileSystem& fs, ConfigService& config, DirNameFn dirName);
+
+    Result<DigiBattle99SetCatalog> load() const;
+    Result<void>                   save(const DigiBattle99SetCatalog& catalog);
+
+    [[nodiscard]] bool exists() const;
+
+private:
+    IFileSystem&   fs_;
+    ConfigService& config_;
+    DirNameFn      dirName_;
+
+    [[nodiscard]] std::filesystem::path catalogPath() const;
+};
+
+}  // namespace ccm

core/include/ccm/services/DigiBattle99SetCompletion.hpp

@@ -0,0 +1,59 @@
+#pragma once
+
+// Pure helpers: Digi-Battle set-completion progress and per-set checklists.
+// Ownership counts only when collection card.set.id matches the pack and the
+// normalized setNo appears in that pack's catalog. Duplicates / amount do not
+// inflate the numerator. An optional languageFilter restricts ownership to
+// cards of that language (packs with zero matches are omitted).
+
+#include "ccm/domain/DigiBattle99Card.hpp"
+#include "ccm/domain/DigiBattle99SetCatalog.hpp"
+#include "ccm/domain/Enums.hpp"
+
+#include <cstddef>
+#include <optional>
+#include <string>
+#include <string_view>
+#include <vector>
+
+namespace ccm {
+
+struct DigiBattle99SetCompletionProgress {
+    std::string setId;
+    std::string setName;
+    std::size_t ownedUnique{0};
+    std::size_t total{0};
+
+    [[nodiscard]] int percent() const noexcept {
+        if (total == 0) return 0;
+        return static_cast<int>((ownedUnique * 100) / total);
+    }
+};
+
+struct DigiBattle99ChecklistEntry {
+    std::string setNo;
+    std::string name;
+    bool        owned{false};
+};
+
+// Distinct languages present in the collection, in allLanguages() order.
+[[nodiscard]] std::vector<Language>
+digiBattle99LanguagesInCollection(const std::vector<DigiBattle99Card>& collection);
+
+// Packs where the collection owns ≥1 card with matching set.id, ordered by
+// setName. Packs absent from the catalog are skipped. When languageFilter is
+// set, only cards of that language count toward ownership.
+[[nodiscard]] std::vector<DigiBattle99SetCompletionProgress>
+computeDigiBattle99SetCompletion(const std::vector<DigiBattle99Card>& collection,
+                                 const DigiBattle99SetCatalog&        catalog,
+                                 std::optional<Language> languageFilter = std::nullopt);
+
+// Full catalog checklist for one pack; owned flags from the collection.
+// When languageFilter is set, only cards of that language count as owned.
+[[nodiscard]] std::vector<DigiBattle99ChecklistEntry>
+digiBattle99ChecklistForSet(const std::vector<DigiBattle99Card>& collection,
+                            const DigiBattle99SetCatalog&        catalog,
+                            std::string_view                     setId,
+                            std::optional<Language> languageFilter = std::nullopt);
+
+}  // namespace ccm

core/include/ccm/services/PokemonSetCatalogService.hpp

@@ -0,0 +1,36 @@
+#pragma once
+
+// PokemonSetCatalogService: load/save pokemon/set-catalog-west.json and
+// pokemon/set-catalog-asia.json under the configured dataStorage path.
+
+#include "ccm/domain/Enums.hpp"
+#include "ccm/domain/PokemonSetCatalog.hpp"
+#include "ccm/ports/IFileSystem.hpp"
+#include "ccm/services/ConfigService.hpp"
+#include "ccm/util/Result.hpp"
+
+#include <functional>
+#include <string>
+
+namespace ccm {
+
+class PokemonSetCatalogService {
+public:
+    using DirNameFn = std::function<std::string(Game)>;
+
+    PokemonSetCatalogService(IFileSystem& fs, ConfigService& config, DirNameFn dirName);
+
+    Result<PokemonSetCatalog> load(PokemonRegion region) const;
+    Result<void>              save(PokemonRegion region, const PokemonSetCatalog& catalog);
+
+    [[nodiscard]] bool exists(PokemonRegion region) const;
+
+private:
+    IFileSystem&   fs_;
+    ConfigService& config_;
+    DirNameFn      dirName_;
+
+    [[nodiscard]] std::filesystem::path catalogPath(PokemonRegion region) const;
+};
+
+}  // namespace ccm

core/include/ccm/services/PokemonSetCompletion.hpp

@@ -0,0 +1,71 @@
+#pragma once
+
+// Pure helpers: Pokemon set-completion progress and per-set checklists.
+// Ownership requires matching PokemonRegion for the pack (West vs Asia),
+// matching set.id, and a normalized collector number / localId. Duplicates /
+// amount / holo / firstEdition do not inflate the numerator. Optional
+// regionFilter and languageFilter restrict which cards count (packs with
+// zero matches are omitted).
+
+#include "ccm/domain/Enums.hpp"
+#include "ccm/domain/PokemonCard.hpp"
+#include "ccm/domain/PokemonSetCatalog.hpp"
+
+#include <cstddef>
+#include <optional>
+#include <string>
+#include <string_view>
+#include <vector>
+
+namespace ccm {
+
+struct PokemonSetCompletionProgress {
+    PokemonRegion region{PokemonRegion::West};
+    std::string   setId;
+    std::string   setName;
+    std::size_t   ownedUnique{0};
+    std::size_t   total{0};
+
+    [[nodiscard]] int percent() const noexcept {
+        if (total == 0) return 0;
+        return static_cast<int>((ownedUnique * 100) / total);
+    }
+};
+
+struct PokemonChecklistEntry {
+    std::string setNo;
+    std::string name;
+    bool        owned{false};
+};
+
+// Distinct languages present in the collection (optionally region-scoped),
+// in allLanguages() order.
+[[nodiscard]] std::vector<Language>
+pokemonLanguagesInCollection(const std::vector<PokemonCard>& collection,
+                             std::optional<PokemonRegion> regionFilter = std::nullopt);
+
+// Distinct regions that have ≥1 owned card matching a catalog pack.
+[[nodiscard]] std::vector<PokemonRegion>
+pokemonRegionsInCollection(const std::vector<PokemonCard>& collection,
+                           const PokemonSetCatalog&        westCatalog,
+                           const PokemonSetCatalog&        asiaCatalog);
+
+// Packs where the collection owns ≥1 matching card, ordered by setName then
+// region. When regionFilter is set, only that region's catalog/cards count.
+[[nodiscard]] std::vector<PokemonSetCompletionProgress>
+computePokemonSetCompletion(const std::vector<PokemonCard>& collection,
+                            const PokemonSetCatalog&        westCatalog,
+                            const PokemonSetCatalog&        asiaCatalog,
+                            std::optional<PokemonRegion> regionFilter = std::nullopt,
+                            std::optional<Language>      languageFilter = std::nullopt);
+
+// Full catalog checklist for one pack; owned flags from the collection.
+[[nodiscard]] std::vector<PokemonChecklistEntry>
+pokemonChecklistForSet(const std::vector<PokemonCard>& collection,
+                       const PokemonSetCatalog&        westCatalog,
+                       const PokemonSetCatalog&        asiaCatalog,
+                       PokemonRegion                   region,
+                       std::string_view                setId,
+                       std::optional<Language> languageFilter = std::nullopt);
+
+}  // namespace ccm

core/include/ccm/services/SetService.hpp

@@ -27,6 +27,10 @@ public:
     // repository, and return the new list.
     Result<std::vector<Set>> updateSets(Game game);
 
+    // Persist an already-fetched set list (no HTTP). Used when a game-specific
+    // Update Sets path fetches sets + side payloads in one round-trip.
+    Result<void> saveSets(Game game, const std::vector<Set>& sets);
+
     // Cached read; returns an error if no local data exists yet.
     Result<std::vector<Set>> getSets(Game game);
 

core/include/ccm/services/YuGiOhSetCatalogService.hpp

@@ -0,0 +1,36 @@
+#pragma once
+
+// YuGiOhSetCatalogService: load/save yugioh/set-catalog.json under the
+// configured dataStorage path.
+
+#include "ccm/domain/Enums.hpp"
+#include "ccm/domain/YuGiOhSetCatalog.hpp"
+#include "ccm/ports/IFileSystem.hpp"
+#include "ccm/services/ConfigService.hpp"
+#include "ccm/util/Result.hpp"
+
+#include <functional>
+#include <string>
+
+namespace ccm {
+
+class YuGiOhSetCatalogService {
+public:
+    using DirNameFn = std::function<std::string(Game)>;
+
+    YuGiOhSetCatalogService(IFileSystem& fs, ConfigService& config, DirNameFn dirName);
+
+    Result<YuGiOhSetCatalog> load() const;
+    Result<void>             save(const YuGiOhSetCatalog& catalog);
+
+    [[nodiscard]] bool exists() const;
+
+private:
+    IFileSystem&   fs_;
+    ConfigService& config_;
+    DirNameFn      dirName_;
+
+    [[nodiscard]] std::filesystem::path catalogPath() const;
+};
+
+}  // namespace ccm

core/include/ccm/services/YuGiOhSetCompletion.hpp

@@ -0,0 +1,60 @@
+#pragma once
+
+// Pure helpers: Yu-Gi-Oh! set-completion progress and per-set checklists.
+// Ownership counts only when collection card.set.id matches the pack and the
+// printing slot matches a catalog setNo (ygoPrintingSlotsMatch). Duplicates /
+// amount / rarity / firstEdition do not inflate the numerator. An optional
+// languageFilter restricts ownership to cards of that language (packs with
+// zero matches are omitted).
+
+#include "ccm/domain/Enums.hpp"
+#include "ccm/domain/YuGiOhCard.hpp"
+#include "ccm/domain/YuGiOhSetCatalog.hpp"
+
+#include <cstddef>
+#include <optional>
+#include <string>
+#include <string_view>
+#include <vector>
+
+namespace ccm {
+
+struct YuGiOhSetCompletionProgress {
+    std::string setId;
+    std::string setName;
+    std::size_t ownedUnique{0};
+    std::size_t total{0};
+
+    [[nodiscard]] int percent() const noexcept {
+        if (total == 0) return 0;
+        return static_cast<int>((ownedUnique * 100) / total);
+    }
+};
+
+struct YuGiOhChecklistEntry {
+    std::string setNo;
+    std::string name;
+    bool        owned{false};
+};
+
+// Distinct languages present in the collection, in allLanguages() order.
+[[nodiscard]] std::vector<Language>
+yuGiOhLanguagesInCollection(const std::vector<YuGiOhCard>& collection);
+
+// Packs where the collection owns ≥1 card with matching set.id, ordered by
+// setName. Packs absent from the catalog are skipped. When languageFilter is
+// set, only cards of that language count toward ownership.
+[[nodiscard]] std::vector<YuGiOhSetCompletionProgress>
+computeYuGiOhSetCompletion(const std::vector<YuGiOhCard>& collection,
+                           const YuGiOhSetCatalog&         catalog,
+                           std::optional<Language> languageFilter = std::nullopt);
+
+// Full catalog checklist for one pack; owned flags from the collection.
+// When languageFilter is set, only cards of that language count as owned.
+[[nodiscard]] std::vector<YuGiOhChecklistEntry>
+yuGiOhChecklistForSet(const std::vector<YuGiOhCard>& collection,
+                      const YuGiOhSetCatalog&         catalog,
+                      std::string_view                setId,
+                      std::optional<Language> languageFilter = std::nullopt);
+
+}  // namespace ccm

core/src/domain/DigiBattle99SetCatalog.cpp

@@ -0,0 +1,40 @@
+#include "ccm/domain/DigiBattle99SetCatalog.hpp"
+
+namespace ccm {
+
+const DigiBattle99SetCatalogPack* DigiBattle99SetCatalog::findPack(
+    std::string_view setId) const {
+    for (const auto& pack : packs) {
+        if (pack.setId == setId) return &pack;
+    }
+    return nullptr;
+}
+
+void to_json(nlohmann::json& j, const DigiBattle99CatalogCard& c) {
+    j = nlohmann::json{{"setNo", c.setNo}, {"name", c.name}};
+}
+
+void from_json(const nlohmann::json& j, DigiBattle99CatalogCard& c) {
+    j.at("setNo").get_to(c.setNo);
+    j.at("name").get_to(c.name);
+}
+
+void to_json(nlohmann::json& j, const DigiBattle99SetCatalogPack& p) {
+    j = nlohmann::json{{"id", p.setId}, {"name", p.setName}, {"cards", p.cards}};
+}
+
+void from_json(const nlohmann::json& j, DigiBattle99SetCatalogPack& p) {
+    j.at("id").get_to(p.setId);
+    j.at("name").get_to(p.setName);
+    j.at("cards").get_to(p.cards);
+}
+
+void to_json(nlohmann::json& j, const DigiBattle99SetCatalog& c) {
+    j = nlohmann::json{{"packs", c.packs}};
+}
+
+void from_json(const nlohmann::json& j, DigiBattle99SetCatalog& c) {
+    j.at("packs").get_to(c.packs);
+}
+
+}  // namespace ccm

core/src/domain/PokemonSetCatalog.cpp

@@ -0,0 +1,39 @@
+#include "ccm/domain/PokemonSetCatalog.hpp"
+
+namespace ccm {
+
+const PokemonSetCatalogPack* PokemonSetCatalog::findPack(std::string_view setId) const {
+    for (const auto& pack : packs) {
+        if (pack.setId == setId) return &pack;
+    }
+    return nullptr;
+}
+
+void to_json(nlohmann::json& j, const PokemonCatalogCard& c) {
+    j = nlohmann::json{{"setNo", c.setNo}, {"name", c.name}};
+}
+
+void from_json(const nlohmann::json& j, PokemonCatalogCard& c) {
+    j.at("setNo").get_to(c.setNo);
+    j.at("name").get_to(c.name);
+}
+
+void to_json(nlohmann::json& j, const PokemonSetCatalogPack& p) {
+    j = nlohmann::json{{"id", p.setId}, {"name", p.setName}, {"cards", p.cards}};
+}
+
+void from_json(const nlohmann::json& j, PokemonSetCatalogPack& p) {
+    j.at("id").get_to(p.setId);
+    j.at("name").get_to(p.setName);
+    j.at("cards").get_to(p.cards);
+}
+
+void to_json(nlohmann::json& j, const PokemonSetCatalog& c) {
+    j = nlohmann::json{{"packs", c.packs}};
+}
+
+void from_json(const nlohmann::json& j, PokemonSetCatalog& c) {
+    j.at("packs").get_to(c.packs);
+}
+
+}  // namespace ccm

core/src/domain/YuGiOhSetCatalog.cpp

@@ -0,0 +1,39 @@
+#include "ccm/domain/YuGiOhSetCatalog.hpp"
+
+namespace ccm {
+
+const YuGiOhSetCatalogPack* YuGiOhSetCatalog::findPack(std::string_view setId) const {
+    for (const auto& pack : packs) {
+        if (pack.setId == setId) return &pack;
+    }
+    return nullptr;
+}
+
+void to_json(nlohmann::json& j, const YuGiOhCatalogCard& c) {
+    j = nlohmann::json{{"setNo", c.setNo}, {"name", c.name}};
+}
+
+void from_json(const nlohmann::json& j, YuGiOhCatalogCard& c) {
+    j.at("setNo").get_to(c.setNo);
+    j.at("name").get_to(c.name);
+}
+
+void to_json(nlohmann::json& j, const YuGiOhSetCatalogPack& p) {
+    j = nlohmann::json{{"id", p.setId}, {"name", p.setName}, {"cards", p.cards}};
+}
+
+void from_json(const nlohmann::json& j, YuGiOhSetCatalogPack& p) {
+    j.at("id").get_to(p.setId);
+    j.at("name").get_to(p.setName);
+    j.at("cards").get_to(p.cards);
+}
+
+void to_json(nlohmann::json& j, const YuGiOhSetCatalog& c) {
+    j = nlohmann::json{{"packs", c.packs}};
+}
+
+void from_json(const nlohmann::json& j, YuGiOhSetCatalog& c) {
+    j.at("packs").get_to(c.packs);
+}
+
+}  // namespace ccm

core/src/games/digibattle99/DigiBattle99SetSource.cpp

@@ -1,5 +1,7 @@
 #include "ccm/games/digibattle99/DigiBattle99SetSource.hpp"
 
+#include "ccm/games/digibattle99/DigiBattle99CardPreviewSource.hpp"
+
 #include <nlohmann/json.hpp>
 
 #include <algorithm>
@@ -40,6 +42,24 @@ std::string releaseDateForPack(const std::string& packName) {
     return {};
 }
 
+Result<nlohmann::json> parseSearchArray(const std::string& body) {
+    try {
+        const auto j = nlohmann::json::parse(body);
+        if (j.is_object() && j.contains("error")) {
+            return Result<nlohmann::json>::err(
+                j.value("error", std::string{"digimoncard.io set search error"}));
+        }
+        if (!j.is_array()) {
+            return Result<nlohmann::json>::err(
+                "digimoncard.io Digi-Battle response is not a JSON array.");
+        }
+        return Result<nlohmann::json>::ok(j);
+    } catch (const std::exception& e) {
+        return Result<nlohmann::json>::err(
+            std::string("digimoncard.io Digi-Battle JSON parse error: ") + e.what());
+    }
+}
+
 }  // namespace
 
 DigiBattle99SetSource::DigiBattle99SetSource(IHttpClient& http) : http_(http) {}
@@ -61,59 +81,126 @@ std::string DigiBattle99SetSource::slugifyPackName(std::string_view packName) {
 }
 
 Result<std::vector<Set>> DigiBattle99SetSource::parseResponse(const std::string& body) {
-    try {
-        const auto j = nlohmann::json::parse(body);
-        if (j.is_object() && j.contains("error")) {
-            return Result<std::vector<Set>>::err(
-                j.value("error", std::string{"digimoncard.io set search error"}));
-        }
-        if (!j.is_array()) {
-            return Result<std::vector<Set>>::err(
-                "digimoncard.io Digi-Battle response is not a JSON array.");
-        }
+    auto arr = parseSearchArray(body);
+    if (!arr) return Result<std::vector<Set>>::err(arr.error());
 
-        // Preserve first-seen order of pack names, then sort by release date.
-        std::unordered_set<std::string> seen;
-        std::vector<std::string> packNames;
-        packNames.reserve(16);
-        for (const auto& entry : j) {
-            if (!entry.contains("set_name") || !entry.at("set_name").is_array()) continue;
-            for (const auto& pack : entry.at("set_name")) {
-                if (!pack.is_string()) continue;
-                const std::string name = pack.get<std::string>();
-                if (name.empty()) continue;
-                if (seen.insert(name).second) packNames.push_back(name);
-            }
+    // Preserve first-seen order of pack names, then sort by release date.
+    std::unordered_set<std::string> seen;
+    std::vector<std::string> packNames;
+    packNames.reserve(16);
+    for (const auto& entry : arr.value()) {
+        if (!entry.contains("set_name") || !entry.at("set_name").is_array()) continue;
+        for (const auto& pack : entry.at("set_name")) {
+            if (!pack.is_string()) continue;
+            const std::string name = pack.get<std::string>();
+            if (name.empty()) continue;
+            if (seen.insert(name).second) packNames.push_back(name);
         }
-
-        std::vector<Set> out;
-        out.reserve(packNames.size());
-        for (const auto& name : packNames) {
-            Set s;
-            s.id = slugifyPackName(name);
-            s.name = name;
-            s.releaseDate = releaseDateForPack(name);
-            if (s.id.empty()) continue;
-            out.push_back(std::move(s));
-        }
-
-        std::sort(out.begin(), out.end(), [](const Set& a, const Set& b) {
-            if (a.releaseDate.empty() && !b.releaseDate.empty()) return false;
-            if (!a.releaseDate.empty() && b.releaseDate.empty()) return true;
-            if (a.releaseDate != b.releaseDate) return a.releaseDate < b.releaseDate;
-            return a.name < b.name;
-        });
-        return Result<std::vector<Set>>::ok(std::move(out));
-    } catch (const std::exception& e) {
-        return Result<std::vector<Set>>::err(
-            std::string("digimoncard.io Digi-Battle JSON parse error: ") + e.what());
     }
+
+    std::vector<Set> out;
+    out.reserve(packNames.size());
+    for (const auto& name : packNames) {
+        Set s;
+        s.id = slugifyPackName(name);
+        s.name = name;
+        s.releaseDate = releaseDateForPack(name);
+        if (s.id.empty()) continue;
+        out.push_back(std::move(s));
+    }
+
+    std::sort(out.begin(), out.end(), [](const Set& a, const Set& b) {
+        if (a.releaseDate.empty() && !b.releaseDate.empty()) return false;
+        if (!a.releaseDate.empty() && b.releaseDate.empty()) return true;
+        if (a.releaseDate != b.releaseDate) return a.releaseDate < b.releaseDate;
+        return a.name < b.name;
+    });
+    return Result<std::vector<Set>>::ok(std::move(out));
+}
+
+Result<DigiBattle99SetCatalog> DigiBattle99SetSource::parseCatalog(const std::string& body) {
+    auto arr = parseSearchArray(body);
+    if (!arr) return Result<DigiBattle99SetCatalog>::err(arr.error());
+
+    // pack display name -> (setId, ordered unique cards by first-seen setNo)
+    struct PackBuild {
+        std::string setId;
+        std::string setName;
+        std::unordered_set<std::string> seenNos;
+        std::vector<DigiBattle99CatalogCard> cards;
+    };
+    std::unordered_map<std::string, PackBuild> byName;
+
+    for (const auto& entry : arr.value()) {
+        if (!entry.contains("name") || !entry.at("name").is_string()) continue;
+        if (!entry.contains("id") || !entry.at("id").is_string()) continue;
+        if (!entry.contains("set_name") || !entry.at("set_name").is_array()) continue;
+
+        DigiBattle99CatalogCard card;
+        card.name = entry.at("name").get<std::string>();
+        card.setNo = DigiBattle99CardPreviewSource::normalizeCardNumber(
+            entry.at("id").get<std::string>());
+        if (card.setNo.empty()) continue;
+
+        for (const auto& pack : entry.at("set_name")) {
+            if (!pack.is_string()) continue;
+            const std::string packName = pack.get<std::string>();
+            if (packName.empty()) continue;
+
+            auto& build = byName[packName];
+            if (build.setName.empty()) {
+                build.setName = packName;
+                build.setId = slugifyPackName(packName);
+            }
+            if (build.setId.empty()) continue;
+            if (!build.seenNos.insert(card.setNo).second) continue;
+            build.cards.push_back(card);
+        }
+    }
+
+    DigiBattle99SetCatalog catalog;
+    catalog.packs.reserve(byName.size());
+    for (auto& [_, build] : byName) {
+        if (build.setId.empty()) continue;
+        std::sort(build.cards.begin(), build.cards.end(),
+                  [](const DigiBattle99CatalogCard& a, const DigiBattle99CatalogCard& b) {
+                      if (a.setNo != b.setNo) return a.setNo < b.setNo;
+                      return a.name < b.name;
+                  });
+        DigiBattle99SetCatalogPack pack;
+        pack.setId = std::move(build.setId);
+        pack.setName = std::move(build.setName);
+        pack.cards = std::move(build.cards);
+        catalog.packs.push_back(std::move(pack));
+    }
+
+    std::sort(catalog.packs.begin(), catalog.packs.end(),
+              [](const DigiBattle99SetCatalogPack& a, const DigiBattle99SetCatalogPack& b) {
+                  return a.setName < b.setName;
+              });
+    return Result<DigiBattle99SetCatalog>::ok(std::move(catalog));
+}
+
+Result<DigiBattle99SetSource::FetchWithCatalog>
+DigiBattle99SetSource::fetchAllWithCatalog() {
+    auto resp = http_.get(kEndpoint);
+    if (!resp) return Result<FetchWithCatalog>::err(resp.error());
+
+    auto sets = parseResponse(resp.value());
+    if (!sets) return Result<FetchWithCatalog>::err(sets.error());
+    auto catalog = parseCatalog(resp.value());
+    if (!catalog) return Result<FetchWithCatalog>::err(catalog.error());
+
+    FetchWithCatalog out;
+    out.sets = std::move(sets).value();
+    out.catalog = std::move(catalog).value();
+    return Result<FetchWithCatalog>::ok(std::move(out));
 }
 
 Result<std::vector<Set>> DigiBattle99SetSource::fetchAll() {
-    auto resp = http_.get(kEndpoint);
-    if (!resp) return Result<std::vector<Set>>::err(resp.error());
-    return parseResponse(resp.value());
+    auto both = fetchAllWithCatalog();
+    if (!both) return Result<std::vector<Set>>::err(both.error());
+    return Result<std::vector<Set>>::ok(std::move(both).value().sets);
 }
 
 }  // namespace ccm

core/src/games/pokemon/PokemonCardPreviewSource.cpp

@@ -13,18 +13,6 @@ namespace ccm {
 
 namespace {
 
-// Strip everything after the first '/' in a Pokemon collector number.
-// The Pokemon TCG API expects `number:"4"`, but cards are commonly stored as
-// `4/102`. Without this, no API match is found.
-std::string normalizeNumber(std::string_view setNo) {
-    std::string s(setNo);
-    const auto slash = s.find('/');
-    if (slash != std::string::npos) {
-        s = s.substr(0, slash);
-    }
-    return s;
-}
-
 std::string trim(std::string s) {
     while (!s.empty() && std::isspace(static_cast<unsigned char>(s.front()))) s.erase(s.begin());
     while (!s.empty() && std::isspace(static_cast<unsigned char>(s.back()))) s.pop_back();
@@ -38,31 +26,74 @@ std::string toLower(std::string s) {
     return s;
 }
 
+Result<std::string, PreviewLookupError> imageUrlFromCardObject(const nlohmann::json& card) {
+    using R = Result<std::string, PreviewLookupError>;
+    using K = PreviewLookupError::Kind;
+    if (!card.contains("images") || !card.at("images").is_object()) {
+        return R::err({K::NotFound, "Card has no 'images' object."});
+    }
+    const auto& images = card.at("images");
+    if (images.contains("large") && images.at("large").is_string()) {
+        return R::ok(images.at("large").get<std::string>());
+    }
+    if (images.contains("small") && images.at("small").is_string()) {
+        return R::ok(images.at("small").get<std::string>());
+    }
+    return R::err({K::NotFound, "Card has no 'large' or 'small' image variant."});
+}
+
 }  // namespace
 
 PokemonCardPreviewSource::PokemonCardPreviewSource(IHttpClient& http) : http_(http) {}
 
+std::string PokemonCardPreviewSource::normalizeCollectorNumber(std::string_view setNo) {
+    // Pokemon TCG search uses an unquoted `number:` clause (e.g. number:4 or
+    // number:TG14). Cards are commonly stored as `4/102`; strip the suffix.
+    std::string s(setNo);
+    const auto slash = s.find('/');
+    if (slash != std::string::npos) {
+        s = s.substr(0, slash);
+    }
+    return s;
+}
+
 std::string PokemonCardPreviewSource::buildSearchUrl(std::string_view name,
                                                      std::string_view setId,
                                                      std::string_view setNo) {
-    // Build the unencoded query first so the output matches what the Pokemon
-    // TCG search syntax expects: name:"<name>" set.id:<setId> number:<num>.
-    std::string query = "name:\"";
-    query += std::string(name);
-    query += "\"";
-    if (!setId.empty()) {
-        query += " set.id:";
+    // When both set id and collector number are known, omit name: — Lucene
+    // name∩number intersections can miss even when the print is real, and
+    // collector numbers are unique within a set.
+    const std::string num = PokemonCardPreviewSource::normalizeCollectorNumber(setNo);
+    std::string query;
+    if (!setId.empty() && !num.empty()) {
+        query = "set.id:";
         query += std::string(setId);
-    }
-    const std::string num = normalizeNumber(setNo);
-    if (!num.empty()) {
         query += " number:";
         query += num;
+    } else {
+        query = "name:\"";
+        query += std::string(name);
+        query += "\"";
+        if (!setId.empty()) {
+            query += " set.id:";
+            query += std::string(setId);
+        }
+        if (!num.empty()) {
+            query += " number:";
+            query += num;
+        }
     }
     return std::string("https://api.pokemontcg.io/v2/cards?q=") +
            rfc3986PercentEncode(query);
 }
 
+std::string PokemonCardPreviewSource::buildCardByIdUrl(std::string_view setId,
+                                                       std::string_view setNo) {
+    const std::string num = PokemonCardPreviewSource::normalizeCollectorNumber(setNo);
+    std::string id = std::string(setId) + "-" + num;
+    return std::string("https://api.pokemontcg.io/v2/cards/") + rfc3986PercentEncode(id);
+}
+
 std::string PokemonCardPreviewSource::buildDetectSearchUrl(std::string_view name,
                                                            std::string_view setId) {
     std::string url = buildSearchUrl(name, setId, "");
@@ -84,18 +115,23 @@ PokemonCardPreviewSource::parseResponse(const std::string& body) {
         if (data.empty()) {
             return R::err({K::NotFound, "Pokemon TCG returned no matching cards."});
         }
-        const auto& first = data.at(0);
-        if (!first.contains("images") || !first.at("images").is_object()) {
-            return R::err({K::NotFound, "Card has no 'images' object."});
+        return imageUrlFromCardObject(data.at(0));
+    } catch (const std::exception& e) {
+        return R::err({K::Transient,
+            std::string("Pokemon TCG JSON parse error: ") + e.what()});
+    }
+}
+
+Result<std::string, PreviewLookupError>
+PokemonCardPreviewSource::parseCardByIdResponse(const std::string& body) {
+    using R = Result<std::string, PreviewLookupError>;
+    using K = PreviewLookupError::Kind;
+    try {
+        const auto j = nlohmann::json::parse(body);
+        if (!j.contains("data") || !j.at("data").is_object()) {
+            return R::err({K::Transient, "Pokemon TCG card response missing 'data' object."});
         }
-        const auto& images = first.at("images");
-        if (images.contains("large") && images.at("large").is_string()) {
-            return R::ok(images.at("large").get<std::string>());
-        }
-        if (images.contains("small") && images.at("small").is_string()) {
-            return R::ok(images.at("small").get<std::string>());
-        }
-        return R::err({K::NotFound, "Card has no 'large' or 'small' image variant."});
+        return imageUrlFromCardObject(j.at("data"));
     } catch (const std::exception& e) {
         return R::err({K::Transient,
             std::string("Pokemon TCG JSON parse error: ") + e.what()});
@@ -108,6 +144,18 @@ PokemonCardPreviewSource::fetchImageUrl(std::string_view name,
                                         std::string_view setNo) {
     using R = Result<std::string, PreviewLookupError>;
     using K = PreviewLookupError::Kind;
+
+    const std::string num = normalizeCollectorNumber(setNo);
+    if (!setId.empty() && !num.empty()) {
+        auto byId = http_.get(buildCardByIdUrl(setId, num));
+        if (byId) {
+            auto img = parseCardByIdResponse(byId.value());
+            if (img) return img;
+            // NotFound (no images) or Transient (schema): fall through to search.
+        }
+        // HTTP failure (404/5xx/offline): fall through to search.
+    }
+
     const std::string url = buildSearchUrl(name, setId, setNo);
     auto resp = http_.get(url);
     if (!resp) return R::err({K::Transient, resp.error()});

core/src/games/pokemon/PokemonSetSource.cpp

@@ -1,12 +1,35 @@
 #include "ccm/games/pokemon/PokemonSetSource.hpp"
 
+#include "ccm/games/pokemon/PokemonCardPreviewSource.hpp"
+
 #include <nlohmann/json.hpp>
 
 #include <algorithm>
 #include <string>
+#include <unordered_map>
+#include <unordered_set>
+#include <utility>
 
 namespace ccm {
 
+namespace {
+
+void finalizeCatalog(PokemonSetCatalog& catalog) {
+    for (auto& pack : catalog.packs) {
+        std::sort(pack.cards.begin(), pack.cards.end(),
+                  [](const PokemonCatalogCard& a, const PokemonCatalogCard& b) {
+                      if (a.setNo != b.setNo) return a.setNo < b.setNo;
+                      return a.name < b.name;
+                  });
+    }
+    std::sort(catalog.packs.begin(), catalog.packs.end(),
+              [](const PokemonSetCatalogPack& a, const PokemonSetCatalogPack& b) {
+                  return a.setName < b.setName;
+              });
+}
+
+}  // namespace
+
 PokemonSetSource::PokemonSetSource(IHttpClient& http) : http_(http) {}
 
 Result<std::vector<Set>> PokemonSetSource::parseResponse(const std::string& body) {
@@ -36,10 +59,137 @@ Result<std::vector<Set>> PokemonSetSource::parseResponse(const std::string& body
     }
 }
 
+std::string PokemonSetSource::buildCardsPageUrl(int page, int pageSize) {
+    return std::string(kCardsEndpoint) + "?select=name,number,set&pageSize=" +
+           std::to_string(pageSize) + "&page=" + std::to_string(page);
+}
+
+Result<PokemonSetSource::CardsPageMeta>
+PokemonSetSource::mergeCardsPage(const std::string&    body,
+                                 PokemonSetCatalog&    catalog,
+                                 const std::vector<Set>& sets) {
+    try {
+        const auto j = nlohmann::json::parse(body);
+        if (!j.contains("data") || !j.at("data").is_array()) {
+            return Result<CardsPageMeta>::err(
+                "Pokemon TCG cards response missing 'data' array.");
+        }
+
+        std::unordered_map<std::string, std::string> idToName;
+        idToName.reserve(sets.size());
+        for (const auto& set : sets) {
+            if (!set.id.empty()) idToName.emplace(set.id, set.name);
+        }
+
+        // Index existing packs for multi-page merges.
+        std::unordered_map<std::string, std::size_t> packIndex;
+        for (std::size_t i = 0; i < catalog.packs.size(); ++i) {
+            packIndex.emplace(catalog.packs[i].setId, i);
+        }
+        std::vector<std::unordered_set<std::string>> seenByPack(catalog.packs.size());
+        for (std::size_t i = 0; i < catalog.packs.size(); ++i) {
+            for (const auto& card : catalog.packs[i].cards) {
+                seenByPack[i].insert(card.setNo);
+            }
+        }
+
+        for (const auto& entry : j.at("data")) {
+            const std::string name = entry.value("name", "");
+            const std::string number =
+                PokemonCardPreviewSource::normalizeCollectorNumber(entry.value("number", ""));
+            if (name.empty() || number.empty()) continue;
+
+            std::string setId;
+            std::string setName;
+            if (entry.contains("set") && entry.at("set").is_object()) {
+                setId = entry.at("set").value("id", "");
+                setName = entry.at("set").value("name", "");
+            }
+            if (setId.empty()) continue;
+            if (const auto it = idToName.find(setId); it != idToName.end() && !it->second.empty()) {
+                setName = it->second;
+            }
+            if (setName.empty()) setName = setId;
+
+            auto pit = packIndex.find(setId);
+            if (pit == packIndex.end()) {
+                PokemonSetCatalogPack pack;
+                pack.setId = setId;
+                pack.setName = setName;
+                pack.cards.push_back(PokemonCatalogCard{number, name});
+                packIndex.emplace(setId, catalog.packs.size());
+                seenByPack.emplace_back(std::unordered_set<std::string>{number});
+                catalog.packs.push_back(std::move(pack));
+                continue;
+            }
+
+            const std::size_t idx = pit->second;
+            if (!seenByPack[idx].insert(number).second) continue;
+            if (catalog.packs[idx].setName.empty() && !setName.empty()) {
+                catalog.packs[idx].setName = setName;
+            }
+            catalog.packs[idx].cards.push_back(PokemonCatalogCard{number, name});
+        }
+
+        CardsPageMeta meta;
+        meta.page = j.value("page", 1);
+        meta.pageSize = j.value("pageSize", kCardsPageSize);
+        meta.count = j.value("count", static_cast<int>(j.at("data").size()));
+        meta.totalCount = j.value("totalCount", meta.count);
+        return Result<CardsPageMeta>::ok(meta);
+    } catch (const std::exception& e) {
+        return Result<CardsPageMeta>::err(
+            std::string("Pokemon TCG cards JSON parse error: ") + e.what());
+    }
+}
+
+Result<PokemonSetCatalog> PokemonSetSource::parseCatalog(const std::string&    body,
+                                                         const std::vector<Set>& sets) {
+    PokemonSetCatalog catalog;
+    auto meta = mergeCardsPage(body, catalog, sets);
+    if (!meta) return Result<PokemonSetCatalog>::err(meta.error());
+    finalizeCatalog(catalog);
+    return Result<PokemonSetCatalog>::ok(std::move(catalog));
+}
+
 Result<std::vector<Set>> PokemonSetSource::fetchAll() {
     auto resp = http_.get(kEndpoint);
     if (!resp) return Result<std::vector<Set>>::err(resp.error());
     return parseResponse(resp.value());
 }
 
+Result<PokemonSetSource::FetchWithCatalog> PokemonSetSource::fetchAllWithCatalog() {
+    auto setsResp = http_.get(kEndpoint);
+    if (!setsResp) return Result<FetchWithCatalog>::err(setsResp.error());
+    auto sets = parseResponse(setsResp.value());
+    if (!sets) return Result<FetchWithCatalog>::err(sets.error());
+
+    PokemonSetCatalog catalog;
+    int page = 1;
+    int totalCount = 0;
+    int fetched = 0;
+    for (;;) {
+        auto cardsResp = http_.get(buildCardsPageUrl(page));
+        if (!cardsResp) return Result<FetchWithCatalog>::err(cardsResp.error());
+        auto meta = mergeCardsPage(cardsResp.value(), catalog, sets.value());
+        if (!meta) return Result<FetchWithCatalog>::err(meta.error());
+
+        fetched += meta.value().count;
+        totalCount = meta.value().totalCount;
+        if (meta.value().count <= 0 || fetched >= totalCount) break;
+        ++page;
+        // Safety: avoid unbounded loops if the API lies about totals.
+        if (page > 10000) {
+            return Result<FetchWithCatalog>::err(
+                "Pokemon TCG cards pagination exceeded safety limit.");
+        }
+    }
+
+    finalizeCatalog(catalog);
+    FetchWithCatalog out;
+    out.sets = std::move(sets).value();
+    out.catalog = std::move(catalog);
+    return Result<FetchWithCatalog>::ok(std::move(out));
+}
+
 }  // namespace ccm

core/src/games/pokemonjp/JapanesePokemonEnCatalog.cpp

@@ -144,6 +144,20 @@ bool JapanesePokemonEnCatalog::hasPrintsForSet(std::string_view setId) const noe
     return it != printKeysBySet_.end() && !it->second.empty();
 }
 
+std::vector<JapanesePokemonPrintEnInfo>
+JapanesePokemonEnCatalog::printsForSet(std::string_view setId) const {
+    std::vector<JapanesePokemonPrintEnInfo> out;
+    const auto keysIt = printKeysBySet_.find(std::string(setId));
+    if (keysIt == printKeysBySet_.end()) return out;
+    out.reserve(keysIt->second.size());
+    for (const auto& key : keysIt->second) {
+        const auto pit = printsByKey_.find(key);
+        if (pit == printsByKey_.end()) continue;
+        out.push_back(pit->second);
+    }
+    return out;
+}
+
 std::string JapanesePokemonEnCatalog::tcgplayerImageUrl(std::string_view productId) {
     if (productId.empty()) return {};
     return std::string("https://product-images.tcgplayer.com/fit-in/437x437/") +

core/src/games/pokemonjp/JapanesePokemonSetSource.cpp

@@ -1,5 +1,6 @@
 #include "ccm/games/pokemonjp/JapanesePokemonSetSource.hpp"
 
+#include "ccm/games/pokemonjp/JapanesePokemonCardPreviewSource.hpp"
 #include "ccm/util/Rfc3986.hpp"
 
 #include <nlohmann/json.hpp>
@@ -8,6 +9,8 @@
 #include <array>
 #include <string>
 #include <unordered_map>
+#include <unordered_set>
+#include <utility>
 
 namespace ccm {
 
@@ -55,6 +58,41 @@ const std::unordered_map<std::string, std::string>& setNameJaOverrides() {
     return false;
 }
 
+void gapFillFromEnCatalog(PokemonSetCatalogPack& pack,
+                          const JapanesePokemonEnCatalog& enCatalog) {
+    std::unordered_set<std::string> seen;
+    for (const auto& card : pack.cards) {
+        seen.insert(JapanesePokemonCardPreviewSource::normalizeLocalId(card.setNo));
+    }
+    for (const auto& print : enCatalog.printsForSet(pack.setId)) {
+        const std::string localId =
+            JapanesePokemonCardPreviewSource::normalizeLocalId(print.localId);
+        if (localId.empty() || !seen.insert(localId).second) continue;
+        std::string name = print.nameEn;
+        if (name.empty()) name = print.nameJa;
+        if (name.empty()) name = localId;
+        pack.cards.push_back(PokemonCatalogCard{localId, std::move(name)});
+    }
+}
+
+void sortPackCards(PokemonSetCatalogPack& pack) {
+    std::sort(pack.cards.begin(), pack.cards.end(),
+              [](const PokemonCatalogCard& a, const PokemonCatalogCard& b) {
+                  if (a.setNo != b.setNo) return a.setNo < b.setNo;
+                  return a.name < b.name;
+              });
+}
+
+void applyEnglishSetName(Set& s, const JapanesePokemonEnCatalog& catalog) {
+    if (auto en = catalog.findSet(s.id)) {
+        if (!en->nameEn.empty()) s.name = en->nameEn;
+        if (!en->releaseDate.empty()) s.releaseDate = en->releaseDate;
+    }
+    if (s.name.empty() || containsCjk(s.name)) {
+        s.name = s.id;
+    }
+}
+
 }  // namespace
 
 JapanesePokemonSetSource::JapanesePokemonSetSource(
@@ -152,6 +190,70 @@ JapanesePokemonSetSource::parseReleaseDate(const std::string& detailBody) {
     }
 }
 
+PokemonSetCatalogPack JapanesePokemonSetSource::catalogPackFromEnCatalog(
+    const Set& set, const JapanesePokemonEnCatalog& enCatalog) {
+    PokemonSetCatalogPack pack;
+    pack.setId = set.id;
+    pack.setName = set.name.empty() ? set.id : set.name;
+    for (const auto& print : enCatalog.printsForSet(set.id)) {
+        const std::string localId =
+            JapanesePokemonCardPreviewSource::normalizeLocalId(print.localId);
+        if (localId.empty()) continue;
+        std::string name = print.nameEn;
+        if (name.empty()) name = print.nameJa;
+        if (name.empty()) name = localId;
+        pack.cards.push_back(PokemonCatalogCard{localId, std::move(name)});
+    }
+    sortPackCards(pack);
+    return pack;
+}
+
+Result<PokemonSetCatalogPack> JapanesePokemonSetSource::parseCatalogPackFromSetDetail(
+    const std::string& detailBody,
+    const Set&         set,
+    const JapanesePokemonEnCatalog& enCatalog) {
+    auto rows = JapanesePokemonCardPreviewSource::parseSetCards(detailBody);
+    if (!rows) {
+        // Transient/NotFound from parse — treat empty cards as catalog-only.
+        if (rows.error().kind == PreviewLookupError::Kind::NotFound) {
+            auto pack = catalogPackFromEnCatalog(set, enCatalog);
+            if (pack.cards.empty()) {
+                return Result<PokemonSetCatalogPack>::err(
+                    "No cards for set " + set.id);
+            }
+            return Result<PokemonSetCatalogPack>::ok(std::move(pack));
+        }
+        return Result<PokemonSetCatalogPack>::err(rows.error().message);
+    }
+
+    PokemonSetCatalogPack pack;
+    pack.setId = set.id;
+    pack.setName = set.name.empty() ? set.id : set.name;
+
+    std::unordered_set<std::string> seen;
+    for (const auto& row : rows.value()) {
+        const std::string localId =
+            JapanesePokemonCardPreviewSource::normalizeLocalId(row.localId);
+        if (localId.empty() || !seen.insert(localId).second) continue;
+
+        std::string name;
+        if (auto print = enCatalog.findPrint(set.id, localId)) {
+            name = print->nameEn;
+            if (name.empty()) name = print->nameJa;
+        }
+        if (name.empty()) name = row.nameJa;
+        if (name.empty()) name = localId;
+        pack.cards.push_back(PokemonCatalogCard{localId, std::move(name)});
+    }
+
+    gapFillFromEnCatalog(pack, enCatalog);
+    sortPackCards(pack);
+    if (pack.cards.empty()) {
+        return Result<PokemonSetCatalogPack>::err("No cards for set " + set.id);
+    }
+    return Result<PokemonSetCatalogPack>::ok(std::move(pack));
+}
+
 Result<std::vector<Set>> JapanesePokemonSetSource::fetchAll() {
     auto listResp = http_.get(kListEndpoint);
     if (!listResp) return Result<std::vector<Set>>::err(listResp.error());
@@ -163,13 +265,7 @@ Result<std::vector<Set>> JapanesePokemonSetSource::fetchAll() {
     for (auto& s : out) {
         // Prefer catalog English; never leave Japanese TCGdex names in Set.name
         // (the set picker must stay English-only).
-        if (auto en = catalog_.findSet(s.id)) {
-            if (!en->nameEn.empty()) s.name = en->nameEn;
-            if (!en->releaseDate.empty()) s.releaseDate = en->releaseDate;
-        }
-        if (s.name.empty() || containsCjk(s.name)) {
-            s.name = s.id;
-        }
+        applyEnglishSetName(s, catalog_);
         if (!s.releaseDate.empty()) continue;
 
         auto detail = http_.get(buildSetDetailUrl(s.id));
@@ -185,19 +281,67 @@ Result<std::vector<Set>> JapanesePokemonSetSource::fetchAll() {
     return Result<std::vector<Set>>::ok(std::move(out));
 }
 
+Result<JapanesePokemonSetSource::FetchWithCatalog>
+JapanesePokemonSetSource::fetchAllWithCatalog() {
+    auto listResp = http_.get(kListEndpoint);
+    if (!listResp) return Result<FetchWithCatalog>::err(listResp.error());
+
+    auto parsed = parseListResponse(listResp.value());
+    if (!parsed) return Result<FetchWithCatalog>::err(parsed.error());
+
+    std::vector<Set> sets = std::move(parsed).value();
+    PokemonSetCatalog catalog;
+    catalog.packs.reserve(sets.size());
+
+    for (auto& s : sets) {
+        applyEnglishSetName(s, catalog_);
+
+        auto detail = http_.get(buildSetDetailUrl(s.id));
+        if (!detail) {
+            // Classic / catalog-only products often have no TCGdex detail.
+            auto pack = catalogPackFromEnCatalog(s, catalog_);
+            if (!pack.cards.empty()) {
+                catalog.packs.push_back(std::move(pack));
+            }
+            continue;
+        }
+
+        if (s.releaseDate.empty()) {
+            auto date = parseReleaseDate(detail.value());
+            if (date && !date.value().empty()) {
+                s.releaseDate = std::move(date).value();
+            }
+        }
+
+        auto pack = parseCatalogPackFromSetDetail(detail.value(), s, catalog_);
+        if (pack) {
+            catalog.packs.push_back(std::move(pack).value());
+        } else {
+            auto fallback = catalogPackFromEnCatalog(s, catalog_);
+            if (!fallback.cards.empty()) {
+                catalog.packs.push_back(std::move(fallback));
+            }
+        }
+    }
+
+    std::sort(sets.begin(), sets.end(),
+              [](const Set& a, const Set& b) { return a.releaseDate < b.releaseDate; });
+    std::sort(catalog.packs.begin(), catalog.packs.end(),
+              [](const PokemonSetCatalogPack& a, const PokemonSetCatalogPack& b) {
+                  return a.setName < b.setName;
+              });
+
+    FetchWithCatalog out;
+    out.sets = std::move(sets);
+    out.catalog = std::move(catalog);
+    return Result<FetchWithCatalog>::ok(std::move(out));
+}
+
 void JapanesePokemonSetSource::augmentCachedSets(std::vector<Set>& sets) const {
     // Stale caches may store set ids (or Japanese) as Set.name — re-apply the
     // bundled EN catalog so names like "Pokémon Jungle" are searchable again.
     for (auto& s : sets) {
-        if (auto en = catalog_.findSet(s.id)) {
-            if (!en->nameEn.empty()) s.name = en->nameEn;
-            if (!en->releaseDate.empty() && s.releaseDate.empty()) {
-                s.releaseDate = en->releaseDate;
-            }
-        }
-        if (s.name.empty() || containsCjk(s.name)) {
-            s.name = s.id;
-        }
+        applyEnglishSetName(s, catalog_);
     }
     appendMissingClassicProducts(sets);
     std::sort(sets.begin(), sets.end(),

core/src/games/yugioh/YuGiOhSetSource.cpp

@@ -1,10 +1,15 @@
 #include "ccm/games/yugioh/YuGiOhSetSource.hpp"
 
+#include "ccm/util/YuGiOhPrintingSlot.hpp"
+
 #include <nlohmann/json.hpp>
 
 #include <algorithm>
 #include <array>
+#include <cctype>
 #include <string>
+#include <unordered_map>
+#include <utility>
 
 namespace ccm {
 namespace {
@@ -39,6 +44,47 @@ void appendMissingSetAliases(std::vector<Set>& sets) {
     }
 }
 
+[[nodiscard]] std::string ygoSlotKey(std::string_view setNo) {
+    const std::string abbrev = ygoAbbrevBeforeDash(setNo);
+    const std::string digits = ygoCollectorDigitsOnly(setNo);
+    if (abbrev.empty() || digits.empty()) return {};
+    return abbrev + "|" + digits;
+}
+
+[[nodiscard]] bool ygoHasEnRegionInfix(std::string_view setCode) {
+    const std::string_view s = trimAsciiSpaces(setCode);
+    const auto dash = s.find('-');
+    if (dash == std::string_view::npos || dash + 3 > s.size()) return false;
+    const std::string_view tail = s.substr(dash + 1);
+    if (tail.size() < 3) return false;
+    return (tail[0] == 'E' || tail[0] == 'e') && (tail[1] == 'N' || tail[1] == 'n')
+        && std::isdigit(static_cast<unsigned char>(tail[2])) != 0;
+}
+
+[[nodiscard]] std::string uppercaseAscii(std::string s) {
+    std::transform(s.begin(), s.end(), s.begin(), [](unsigned char c) {
+        return static_cast<char>(std::toupper(c));
+    });
+    return s;
+}
+
+[[nodiscard]] std::string resolvePackId(const std::unordered_map<std::string, std::string>& nameToId,
+                                        const std::string& setName,
+                                        const std::string& setCode) {
+    const auto it = nameToId.find(setName);
+    if (it != nameToId.end() && !it->second.empty()) return it->second;
+    const std::string abbrev = uppercaseAscii(ygoAbbrevBeforeDash(setCode));
+    return abbrev;
+}
+
+struct PackBuild {
+    std::string setId;
+    std::string setName;
+    // slotKey → index into cards (for EN preference upgrades).
+    std::unordered_map<std::string, std::size_t> slotIndex;
+    std::vector<YuGiOhCatalogCard>               cards;
+};
+
 }  // namespace
 
 YuGiOhSetSource::YuGiOhSetSource(IHttpClient& http) : http_(http) {}
@@ -73,10 +119,116 @@ Result<std::vector<Set>> YuGiOhSetSource::parseResponse(const std::string& body)
     }
 }
 
+Result<YuGiOhSetCatalog> YuGiOhSetSource::parseCatalog(const std::string&      body,
+                                                       const std::vector<Set>& sets) {
+    try {
+        const auto j = nlohmann::json::parse(body);
+        if (!j.is_object() || !j.contains("data") || !j.at("data").is_array()) {
+            return Result<YuGiOhSetCatalog>::err(
+                "YGOPRODeck cardinfo response missing data array.");
+        }
+
+        std::unordered_map<std::string, std::string> nameToId;
+        nameToId.reserve(sets.size());
+        for (const auto& set : sets) {
+            if (set.name.empty() || set.id.empty()) continue;
+            // First wins — aliases and upstream rows rarely collide by name.
+            nameToId.emplace(set.name, set.id);
+        }
+
+        // Keyed by pack setId.
+        std::unordered_map<std::string, PackBuild> byId;
+
+        for (const auto& cardJson : j.at("data")) {
+            const std::string cardName = cardJson.value("name", "");
+            if (cardName.empty()) continue;
+            if (!cardJson.contains("card_sets") || !cardJson.at("card_sets").is_array()) {
+                continue;
+            }
+            for (const auto& printing : cardJson.at("card_sets")) {
+                const std::string setName = printing.value("set_name", "");
+                const std::string setCode = printing.value("set_code", "");
+                if (setName.empty() || setCode.empty()) continue;
+                if (ygoLikelyEuropeanRegionalSetCode(setCode)) continue;
+
+                const std::string slot = ygoSlotKey(setCode);
+                if (slot.empty()) continue;
+
+                const std::string packId = resolvePackId(nameToId, setName, setCode);
+                if (packId.empty()) continue;
+
+                auto& build = byId[packId];
+                if (build.setId.empty()) {
+                    build.setId = packId;
+                    build.setName = setName;
+                }
+
+                const auto existing = build.slotIndex.find(slot);
+                if (existing == build.slotIndex.end()) {
+                    build.slotIndex.emplace(slot, build.cards.size());
+                    build.cards.push_back(YuGiOhCatalogCard{setCode, cardName});
+                    continue;
+                }
+
+                // Prefer an EN-embedded code over a bare / other-region equivalent.
+                auto& prev = build.cards[existing->second];
+                if (!ygoHasEnRegionInfix(prev.setNo) && ygoHasEnRegionInfix(setCode)) {
+                    prev.setNo = setCode;
+                    if (!cardName.empty()) prev.name = cardName;
+                }
+            }
+        }
+
+        YuGiOhSetCatalog catalog;
+        catalog.packs.reserve(byId.size());
+        for (auto& [_, build] : byId) {
+            if (build.setId.empty() || build.cards.empty()) continue;
+            std::sort(build.cards.begin(), build.cards.end(),
+                      [](const YuGiOhCatalogCard& a, const YuGiOhCatalogCard& b) {
+                          if (a.setNo != b.setNo) return a.setNo < b.setNo;
+                          return a.name < b.name;
+                      });
+            YuGiOhSetCatalogPack pack;
+            pack.setId = std::move(build.setId);
+            pack.setName = std::move(build.setName);
+            pack.cards = std::move(build.cards);
+            catalog.packs.push_back(std::move(pack));
+        }
+
+        std::sort(catalog.packs.begin(), catalog.packs.end(),
+                  [](const YuGiOhSetCatalogPack& a, const YuGiOhSetCatalogPack& b) {
+                      return a.setName < b.setName;
+                  });
+        return Result<YuGiOhSetCatalog>::ok(std::move(catalog));
+    } catch (const std::exception& e) {
+        return Result<YuGiOhSetCatalog>::err(
+            std::string("YGOPRODeck catalog parse error: ") + e.what());
+    }
+}
+
 Result<std::vector<Set>> YuGiOhSetSource::fetchAll() {
     auto resp = http_.get(kEndpoint);
     if (!resp) return Result<std::vector<Set>>::err(resp.error());
     return parseResponse(resp.value());
 }
 
+Result<YuGiOhSetSource::FetchWithCatalog> YuGiOhSetSource::fetchAllWithCatalog() {
+    auto setsResp = http_.get(kEndpoint);
+    if (!setsResp) return Result<FetchWithCatalog>::err(setsResp.error());
+
+    auto sets = parseResponse(setsResp.value());
+    if (!sets) return Result<FetchWithCatalog>::err(sets.error());
+
+    auto infoResp = http_.get(kCardInfoEndpoint);
+    if (!infoResp) return Result<FetchWithCatalog>::err(infoResp.error());
+
+    auto catalog = parseCatalog(infoResp.value(), sets.value());
+    if (!catalog) return Result<FetchWithCatalog>::err(catalog.error());
+
+    FetchWithCatalog out;
+    out.sets = std::move(sets).value();
+    out.catalog = std::move(catalog).value();
+    return Result<FetchWithCatalog>::ok(std::move(out));
+}
+
 }  // namespace ccm

core/src/services/DigiBattle99SetCatalogService.cpp

@@ -0,0 +1,50 @@
+#include "ccm/services/DigiBattle99SetCatalogService.hpp"
+
+#include <nlohmann/json.hpp>
+
+#include <utility>
+
+namespace ccm {
+
+namespace fs = std::filesystem;
+
+DigiBattle99SetCatalogService::DigiBattle99SetCatalogService(IFileSystem&   fs,
+                                                             ConfigService& config,
+                                                             DirNameFn      dirName)
+    : fs_(fs), config_(config), dirName_(std::move(dirName)) {}
+
+fs::path DigiBattle99SetCatalogService::catalogPath() const {
+    return fs::path(config_.current().dataStorage) / dirName_(Game::DigiBattle99) /
+           "set-catalog.json";
+}
+
+bool DigiBattle99SetCatalogService::exists() const {
+    return fs_.exists(catalogPath());
+}
+
+Result<DigiBattle99SetCatalog> DigiBattle99SetCatalogService::load() const {
+    const auto p = catalogPath();
+    if (!fs_.exists(p)) {
+        return Result<DigiBattle99SetCatalog>::err(
+            "Digimon Digi-Battle set catalog not yet downloaded.");
+    }
+    auto text = fs_.readText(p);
+    if (!text) return Result<DigiBattle99SetCatalog>::err(text.error());
+    try {
+        const auto j = nlohmann::json::parse(text.value());
+        return Result<DigiBattle99SetCatalog>::ok(j.get<DigiBattle99SetCatalog>());
+    } catch (const std::exception& e) {
+        return Result<DigiBattle99SetCatalog>::err(
+            std::string("set-catalog.json parse error: ") + e.what());
+    }
+}
+
+Result<void> DigiBattle99SetCatalogService::save(const DigiBattle99SetCatalog& catalog) {
+    const auto p = catalogPath();
+    auto dir = fs_.ensureDirectory(p.parent_path());
+    if (!dir) return dir;
+    const nlohmann::json j = catalog;
+    return fs_.writeText(p, j.dump(2));
+}
+
+}  // namespace ccm

core/src/services/DigiBattle99SetCompletion.cpp

@@ -0,0 +1,129 @@
+#include "ccm/services/DigiBattle99SetCompletion.hpp"
+
+#include "ccm/games/digibattle99/DigiBattle99CardPreviewSource.hpp"
+
+#include <algorithm>
+#include <array>
+#include <unordered_map>
+#include <unordered_set>
+
+namespace ccm {
+
+namespace {
+
+using OwnedBySet = std::unordered_map<std::string, std::unordered_set<std::string>>;
+
+bool passesLanguageFilter(const DigiBattle99Card& card,
+                          std::optional<Language> languageFilter) {
+    return !languageFilter.has_value() || card.language == *languageFilter;
+}
+
+OwnedBySet ownedSetNosBySetId(const std::vector<DigiBattle99Card>& collection,
+                              std::optional<Language>              languageFilter) {
+    OwnedBySet out;
+    for (const auto& card : collection) {
+        if (!passesLanguageFilter(card, languageFilter)) continue;
+        if (card.set.id.empty()) continue;
+        const std::string setNo =
+            DigiBattle99CardPreviewSource::normalizeCardNumber(card.setNo);
+        if (setNo.empty()) continue;
+        out[card.set.id].insert(setNo);
+    }
+    return out;
+}
+
+}  // namespace
+
+std::vector<Language>
+digiBattle99LanguagesInCollection(const std::vector<DigiBattle99Card>& collection) {
+    const auto& langs = allLanguages();
+    std::array<bool, 10> present{};
+    for (const auto& card : collection) {
+        for (std::size_t i = 0; i < langs.size(); ++i) {
+            if (langs[i] == card.language) {
+                present[i] = true;
+                break;
+            }
+        }
+    }
+
+    std::vector<Language> out;
+    for (std::size_t i = 0; i < langs.size(); ++i) {
+        if (present[i]) out.push_back(langs[i]);
+    }
+    return out;
+}
+
+std::vector<DigiBattle99SetCompletionProgress>
+computeDigiBattle99SetCompletion(const std::vector<DigiBattle99Card>& collection,
+                                 const DigiBattle99SetCatalog&        catalog,
+                                 std::optional<Language>              languageFilter) {
+    const OwnedBySet owned = ownedSetNosBySetId(collection, languageFilter);
+
+    std::vector<DigiBattle99SetCompletionProgress> out;
+    out.reserve(owned.size());
+
+    for (const auto& [setId, ownedNos] : owned) {
+        const auto* pack = catalog.findPack(setId);
+        if (pack == nullptr || pack->cards.empty()) continue;
+
+        std::size_t matched = 0;
+        for (const auto& card : pack->cards) {
+            const std::string catalogNo =
+                DigiBattle99CardPreviewSource::normalizeCardNumber(card.setNo);
+            if (!catalogNo.empty() && ownedNos.count(catalogNo) != 0) ++matched;
+        }
+
+        DigiBattle99SetCompletionProgress row;
+        row.setId = pack->setId;
+        row.setName = pack->setName;
+        row.ownedUnique = matched;
+        row.total = pack->cards.size();
+        out.push_back(std::move(row));
+    }
+
+    std::sort(out.begin(), out.end(),
+              [](const DigiBattle99SetCompletionProgress& a,
+                 const DigiBattle99SetCompletionProgress& b) {
+                  return a.setName < b.setName;
+              });
+    return out;
+}
+
+std::vector<DigiBattle99ChecklistEntry>
+digiBattle99ChecklistForSet(const std::vector<DigiBattle99Card>& collection,
+                            const DigiBattle99SetCatalog&        catalog,
+                            std::string_view                     setId,
+                            std::optional<Language>              languageFilter) {
+    const auto* pack = catalog.findPack(setId);
+    if (pack == nullptr) return {};
+
+    std::unordered_set<std::string> ownedNos;
+    for (const auto& card : collection) {
+        if (!passesLanguageFilter(card, languageFilter)) continue;
+        if (card.set.id != setId) continue;
+        const std::string setNo =
+            DigiBattle99CardPreviewSource::normalizeCardNumber(card.setNo);
+        if (!setNo.empty()) ownedNos.insert(setNo);
+    }
+
+    std::vector<DigiBattle99ChecklistEntry> out;
+    out.reserve(pack->cards.size());
+    for (const auto& card : pack->cards) {
+        DigiBattle99ChecklistEntry entry;
+        entry.setNo = DigiBattle99CardPreviewSource::normalizeCardNumber(card.setNo);
+        entry.name = card.name;
+        entry.owned = !entry.setNo.empty() && ownedNos.count(entry.setNo) != 0;
+        out.push_back(std::move(entry));
+    }
+
+    std::sort(out.begin(), out.end(),
+              [](const DigiBattle99ChecklistEntry& a,
+                 const DigiBattle99ChecklistEntry& b) {
+                  if (a.setNo != b.setNo) return a.setNo < b.setNo;
+                  return a.name < b.name;
+              });
+    return out;
+}
+
+}  // namespace ccm

core/src/services/PokemonSetCatalogService.cpp

@@ -0,0 +1,54 @@
+#include "ccm/services/PokemonSetCatalogService.hpp"
+
+#include <nlohmann/json.hpp>
+
+#include <utility>
+
+namespace ccm {
+
+namespace fs = std::filesystem;
+
+PokemonSetCatalogService::PokemonSetCatalogService(IFileSystem&   fs,
+                                                   ConfigService& config,
+                                                   DirNameFn      dirName)
+    : fs_(fs), config_(config), dirName_(std::move(dirName)) {}
+
+fs::path PokemonSetCatalogService::catalogPath(PokemonRegion region) const {
+    const char* file = region == PokemonRegion::Asia ? "set-catalog-asia.json"
+                                                     : "set-catalog-west.json";
+    return fs::path(config_.current().dataStorage) / dirName_(Game::Pokemon) / file;
+}
+
+bool PokemonSetCatalogService::exists(PokemonRegion region) const {
+    return fs_.exists(catalogPath(region));
+}
+
+Result<PokemonSetCatalog> PokemonSetCatalogService::load(PokemonRegion region) const {
+    const auto p = catalogPath(region);
+    if (!fs_.exists(p)) {
+        return Result<PokemonSetCatalog>::err(
+            region == PokemonRegion::Asia
+                ? "Asia Pokemon set catalog not yet downloaded."
+                : "West Pokemon set catalog not yet downloaded.");
+    }
+    auto text = fs_.readText(p);
+    if (!text) return Result<PokemonSetCatalog>::err(text.error());
+    try {
+        const auto j = nlohmann::json::parse(text.value());
+        return Result<PokemonSetCatalog>::ok(j.get<PokemonSetCatalog>());
+    } catch (const std::exception& e) {
+        return Result<PokemonSetCatalog>::err(
+            std::string("set-catalog.json parse error: ") + e.what());
+    }
+}
+
+Result<void> PokemonSetCatalogService::save(PokemonRegion             region,
+                                            const PokemonSetCatalog&  catalog) {
+    const auto p = catalogPath(region);
+    auto dir = fs_.ensureDirectory(p.parent_path());
+    if (!dir) return dir;
+    const nlohmann::json j = catalog;
+    return fs_.writeText(p, j.dump(2));
+}
+
+}  // namespace ccm

core/src/services/PokemonSetCompletion.cpp

@@ -0,0 +1,190 @@
+#include "ccm/services/PokemonSetCompletion.hpp"
+
+#include "ccm/games/pokemon/PokemonCardPreviewSource.hpp"
+#include "ccm/games/pokemonjp/JapanesePokemonCardPreviewSource.hpp"
+
+#include <algorithm>
+#include <array>
+#include <unordered_map>
+#include <unordered_set>
+
+namespace ccm {
+
+namespace {
+
+using OwnedBySet = std::unordered_map<std::string, std::unordered_set<std::string>>;
+
+bool passesLanguageFilter(const PokemonCard& card, std::optional<Language> languageFilter) {
+    return !languageFilter.has_value() || card.language == *languageFilter;
+}
+
+bool passesRegionFilter(const PokemonCard& card, std::optional<PokemonRegion> regionFilter) {
+    return !regionFilter.has_value() || card.region == *regionFilter;
+}
+
+std::string normalizeForRegion(PokemonRegion region, std::string_view setNo) {
+    if (region == PokemonRegion::Asia) {
+        return JapanesePokemonCardPreviewSource::normalizeLocalId(setNo);
+    }
+    return PokemonCardPreviewSource::normalizeCollectorNumber(setNo);
+}
+
+OwnedBySet ownedSetNosBySetId(const std::vector<PokemonCard>& collection,
+                              PokemonRegion                   region,
+                              std::optional<Language>         languageFilter) {
+    OwnedBySet out;
+    for (const auto& card : collection) {
+        if (card.region != region) continue;
+        if (!passesLanguageFilter(card, languageFilter)) continue;
+        if (card.set.id.empty()) continue;
+        const std::string setNo = normalizeForRegion(region, card.setNo);
+        if (setNo.empty()) continue;
+        out[card.set.id].insert(setNo);
+    }
+    return out;
+}
+
+std::vector<PokemonSetCompletionProgress>
+computeForCatalog(const std::vector<PokemonCard>& collection,
+                  const PokemonSetCatalog&        catalog,
+                  PokemonRegion                   region,
+                  std::optional<Language>         languageFilter) {
+    const OwnedBySet owned = ownedSetNosBySetId(collection, region, languageFilter);
+
+    std::vector<PokemonSetCompletionProgress> out;
+    out.reserve(owned.size());
+
+    for (const auto& [setId, ownedNos] : owned) {
+        const auto* pack = catalog.findPack(setId);
+        if (pack == nullptr || pack->cards.empty()) continue;
+
+        std::size_t matched = 0;
+        for (const auto& card : pack->cards) {
+            const std::string catalogNo = normalizeForRegion(region, card.setNo);
+            if (!catalogNo.empty() && ownedNos.count(catalogNo) != 0) ++matched;
+        }
+
+        PokemonSetCompletionProgress row;
+        row.region = region;
+        row.setId = pack->setId;
+        row.setName = pack->setName;
+        row.ownedUnique = matched;
+        row.total = pack->cards.size();
+        out.push_back(std::move(row));
+    }
+    return out;
+}
+
+}  // namespace
+
+std::vector<Language>
+pokemonLanguagesInCollection(const std::vector<PokemonCard>& collection,
+                             std::optional<PokemonRegion>    regionFilter) {
+    const auto& langs = allLanguages();
+    std::array<bool, 10> present{};
+    for (const auto& card : collection) {
+        if (!passesRegionFilter(card, regionFilter)) continue;
+        for (std::size_t i = 0; i < langs.size(); ++i) {
+            if (langs[i] == card.language) {
+                present[i] = true;
+                break;
+            }
+        }
+    }
+
+    std::vector<Language> out;
+    for (std::size_t i = 0; i < langs.size(); ++i) {
+        if (present[i]) out.push_back(langs[i]);
+    }
+    return out;
+}
+
+std::vector<PokemonRegion>
+pokemonRegionsInCollection(const std::vector<PokemonCard>& collection,
+                           const PokemonSetCatalog&        westCatalog,
+                           const PokemonSetCatalog&        asiaCatalog) {
+    std::vector<PokemonRegion> out;
+    const auto westRows =
+        computeForCatalog(collection, westCatalog, PokemonRegion::West, std::nullopt);
+    if (!westRows.empty()) out.push_back(PokemonRegion::West);
+    const auto asiaRows =
+        computeForCatalog(collection, asiaCatalog, PokemonRegion::Asia, std::nullopt);
+    if (!asiaRows.empty()) out.push_back(PokemonRegion::Asia);
+    return out;
+}
+
+std::vector<PokemonSetCompletionProgress>
+computePokemonSetCompletion(const std::vector<PokemonCard>& collection,
+                            const PokemonSetCatalog&        westCatalog,
+                            const PokemonSetCatalog&        asiaCatalog,
+                            std::optional<PokemonRegion>    regionFilter,
+                            std::optional<Language>         languageFilter) {
+    std::vector<PokemonSetCompletionProgress> out;
+
+    const bool includeWest =
+        !regionFilter.has_value() || *regionFilter == PokemonRegion::West;
+    const bool includeAsia =
+        !regionFilter.has_value() || *regionFilter == PokemonRegion::Asia;
+
+    if (includeWest) {
+        auto west = computeForCatalog(collection, westCatalog, PokemonRegion::West,
+                                      languageFilter);
+        out.insert(out.end(), std::make_move_iterator(west.begin()),
+                   std::make_move_iterator(west.end()));
+    }
+    if (includeAsia) {
+        auto asia = computeForCatalog(collection, asiaCatalog, PokemonRegion::Asia,
+                                      languageFilter);
+        out.insert(out.end(), std::make_move_iterator(asia.begin()),
+                   std::make_move_iterator(asia.end()));
+    }
+
+    std::sort(out.begin(), out.end(),
+              [](const PokemonSetCompletionProgress& a,
+                 const PokemonSetCompletionProgress& b) {
+                  if (a.setName != b.setName) return a.setName < b.setName;
+                  return static_cast<int>(a.region) < static_cast<int>(b.region);
+              });
+    return out;
+}
+
+std::vector<PokemonChecklistEntry>
+pokemonChecklistForSet(const std::vector<PokemonCard>& collection,
+                       const PokemonSetCatalog&        westCatalog,
+                       const PokemonSetCatalog&        asiaCatalog,
+                       PokemonRegion                   region,
+                       std::string_view                setId,
+                       std::optional<Language>         languageFilter) {
+    const PokemonSetCatalog& catalog =
+        region == PokemonRegion::Asia ? asiaCatalog : westCatalog;
+    const auto* pack = catalog.findPack(setId);
+    if (pack == nullptr) return {};
+
+    std::unordered_set<std::string> ownedNos;
+    for (const auto& card : collection) {
+        if (card.region != region) continue;
+        if (!passesLanguageFilter(card, languageFilter)) continue;
+        if (card.set.id != setId) continue;
+        const std::string setNo = normalizeForRegion(region, card.setNo);
+        if (!setNo.empty()) ownedNos.insert(setNo);
+    }
+
+    std::vector<PokemonChecklistEntry> out;
+    out.reserve(pack->cards.size());
+    for (const auto& card : pack->cards) {
+        PokemonChecklistEntry entry;
+        entry.setNo = normalizeForRegion(region, card.setNo);
+        entry.name = card.name;
+        entry.owned = !entry.setNo.empty() && ownedNos.count(entry.setNo) != 0;
+        out.push_back(std::move(entry));
+    }
+
+    std::sort(out.begin(), out.end(),
+              [](const PokemonChecklistEntry& a, const PokemonChecklistEntry& b) {
+                  if (a.setNo != b.setNo) return a.setNo < b.setNo;
+                  return a.name < b.name;
+              });
+    return out;
+}
+
+}  // namespace ccm

core/src/services/SetService.cpp

@@ -20,6 +20,10 @@ Result<std::vector<Set>> SetService::updateSets(Game game) {
     return fetched;
 }
 
+Result<void> SetService::saveSets(Game game, const std::vector<Set>& sets) {
+    return repo_.save(game, sets);
+}
+
 Result<std::vector<Set>> SetService::getSets(Game game) {
     auto loaded = repo_.load(game);
     if (!loaded) return loaded;

core/src/services/YuGiOhSetCatalogService.cpp

@@ -0,0 +1,49 @@
+#include "ccm/services/YuGiOhSetCatalogService.hpp"
+
+#include <nlohmann/json.hpp>
+
+#include <utility>
+
+namespace ccm {
+
+namespace fs = std::filesystem;
+
+YuGiOhSetCatalogService::YuGiOhSetCatalogService(IFileSystem&   fs,
+                                                 ConfigService& config,
+                                                 DirNameFn      dirName)
+    : fs_(fs), config_(config), dirName_(std::move(dirName)) {}
+
+fs::path YuGiOhSetCatalogService::catalogPath() const {
+    return fs::path(config_.current().dataStorage) / dirName_(Game::YuGiOh) /
+           "set-catalog.json";
+}
+
+bool YuGiOhSetCatalogService::exists() const {
+    return fs_.exists(catalogPath());
+}
+
+Result<YuGiOhSetCatalog> YuGiOhSetCatalogService::load() const {
+    const auto p = catalogPath();
+    if (!fs_.exists(p)) {
+        return Result<YuGiOhSetCatalog>::err("Yu-Gi-Oh! set catalog not yet downloaded.");
+    }
+    auto text = fs_.readText(p);
+    if (!text) return Result<YuGiOhSetCatalog>::err(text.error());
+    try {
+        const auto j = nlohmann::json::parse(text.value());
+        return Result<YuGiOhSetCatalog>::ok(j.get<YuGiOhSetCatalog>());
+    } catch (const std::exception& e) {
+        return Result<YuGiOhSetCatalog>::err(
+            std::string("set-catalog.json parse error: ") + e.what());
+    }
+}
+
+Result<void> YuGiOhSetCatalogService::save(const YuGiOhSetCatalog& catalog) {
+    const auto p = catalogPath();
+    auto dir = fs_.ensureDirectory(p.parent_path());
+    if (!dir) return dir;
+    const nlohmann::json j = catalog;
+    return fs_.writeText(p, j.dump(2));
+}
+
+}  // namespace ccm

core/src/services/YuGiOhSetCompletion.cpp

@@ -0,0 +1,132 @@
+#include "ccm/services/YuGiOhSetCompletion.hpp"
+
+#include "ccm/util/YuGiOhPrintingSlot.hpp"
+
+#include <algorithm>
+#include <array>
+#include <unordered_map>
+#include <unordered_set>
+
+namespace ccm {
+
+namespace {
+
+using OwnedBySet = std::unordered_map<std::string, std::unordered_set<std::string>>;
+
+[[nodiscard]] std::string ygoSlotKey(std::string_view setNo) {
+    const std::string abbrev = ygoAbbrevBeforeDash(setNo);
+    const std::string digits = ygoCollectorDigitsOnly(setNo);
+    if (abbrev.empty() || digits.empty()) return {};
+    return abbrev + "|" + digits;
+}
+
+bool passesLanguageFilter(const YuGiOhCard& card, std::optional<Language> languageFilter) {
+    return !languageFilter.has_value() || card.language == *languageFilter;
+}
+
+OwnedBySet ownedSlotsBySetId(const std::vector<YuGiOhCard>& collection,
+                             std::optional<Language>        languageFilter) {
+    OwnedBySet out;
+    for (const auto& card : collection) {
+        if (!passesLanguageFilter(card, languageFilter)) continue;
+        if (card.set.id.empty()) continue;
+        const std::string key = ygoSlotKey(card.setNo);
+        if (key.empty()) continue;
+        out[card.set.id].insert(key);
+    }
+    return out;
+}
+
+}  // namespace
+
+std::vector<Language>
+yuGiOhLanguagesInCollection(const std::vector<YuGiOhCard>& collection) {
+    const auto& langs = allLanguages();
+    std::array<bool, 10> present{};
+    for (const auto& card : collection) {
+        for (std::size_t i = 0; i < langs.size(); ++i) {
+            if (langs[i] == card.language) {
+                present[i] = true;
+                break;
+            }
+        }
+    }
+
+    std::vector<Language> out;
+    for (std::size_t i = 0; i < langs.size(); ++i) {
+        if (present[i]) out.push_back(langs[i]);
+    }
+    return out;
+}
+
+std::vector<YuGiOhSetCompletionProgress>
+computeYuGiOhSetCompletion(const std::vector<YuGiOhCard>& collection,
+                           const YuGiOhSetCatalog&         catalog,
+                           std::optional<Language>        languageFilter) {
+    const OwnedBySet owned = ownedSlotsBySetId(collection, languageFilter);
+
+    std::vector<YuGiOhSetCompletionProgress> out;
+    out.reserve(owned.size());
+
+    for (const auto& [setId, ownedSlots] : owned) {
+        const auto* pack = catalog.findPack(setId);
+        if (pack == nullptr || pack->cards.empty()) continue;
+
+        std::size_t matched = 0;
+        for (const auto& card : pack->cards) {
+            const std::string key = ygoSlotKey(card.setNo);
+            if (!key.empty() && ownedSlots.count(key) != 0) ++matched;
+        }
+
+        YuGiOhSetCompletionProgress row;
+        row.setId = pack->setId;
+        row.setName = pack->setName;
+        row.ownedUnique = matched;
+        row.total = pack->cards.size();
+        out.push_back(std::move(row));
+    }
+
+    std::sort(out.begin(), out.end(),
+              [](const YuGiOhSetCompletionProgress& a,
+                 const YuGiOhSetCompletionProgress& b) {
+                  return a.setName < b.setName;
+              });
+    return out;
+}
+
+std::vector<YuGiOhChecklistEntry>
+yuGiOhChecklistForSet(const std::vector<YuGiOhCard>& collection,
+                      const YuGiOhSetCatalog&         catalog,
+                      std::string_view                setId,
+                      std::optional<Language>         languageFilter) {
+    const auto* pack = catalog.findPack(setId);
+    if (pack == nullptr) return {};
+
+    std::unordered_set<std::string> ownedSlots;
+    for (const auto& card : collection) {
+        if (!passesLanguageFilter(card, languageFilter)) continue;
+        if (card.set.id != setId) continue;
+        const std::string key = ygoSlotKey(card.setNo);
+        if (!key.empty()) ownedSlots.insert(key);
+    }
+
+    std::vector<YuGiOhChecklistEntry> out;
+    out.reserve(pack->cards.size());
+    for (const auto& card : pack->cards) {
+        YuGiOhChecklistEntry entry;
+        entry.setNo = card.setNo;
+        entry.name = card.name;
+        const std::string key = ygoSlotKey(card.setNo);
+        entry.owned = !key.empty() && ownedSlots.count(key) != 0;
+        out.push_back(std::move(entry));
+    }
+
+    std::sort(out.begin(), out.end(),
+              [](const YuGiOhChecklistEntry& a, const YuGiOhChecklistEntry& b) {
+                  if (a.setNo != b.setNo) return a.setNo < b.setNo;
+                  return a.name < b.name;
+              });
+    return out;
+}
+
+}  // namespace ccm