Minor: Add Asian Pokemon Card Support (#18 )

minor: New Game Digimon Digi-Battle (#17 )
* digimon digi battle added to supported games * sonarqube update * readme update --------- Co-authored-by: sdine <sdine@sdine.com>
2026-09-02 13:00:33 +00:00 · 2026-07-22 11:13:42 +02:00 · 2026-07-19 12:06:57 +02:00
112 changed files with 80203 additions and 176 deletions
@@ -58,7 +58,7 @@ jobs:
          --exclude "^tests/"

      - name: SonarQube Cloud scan
-        uses: SonarSource/sonarqube-scan-action@v5
+        uses: SonarSource/sonarqube-scan-action@v6
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
          SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
@@ -58,7 +58,7 @@ jobs:
          --exclude "^tests/"

      - name: SonarQube Cloud scan
-        uses: SonarSource/sonarqube-scan-action@v5
+        uses: SonarSource/sonarqube-scan-action@v6
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
          SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
@@ -40,3 +40,6 @@ config.json
 configure.log
 build.log
 test.log
+
+# Offline ETL caches (large third-party extracts)
+tools/pokemon_jp/_tcgdex_cards_database/
@@ -5,7 +5,7 @@ C++ desktop implementation (originally based on a Tauri Rust+TS version) — sin
 ## Project structure

 - `core/` — `ccm_core` static library. UI-agnostic domain, ports, services, infra adapters. **Never** depends on wxWidgets. See `core/AGENTS.md`.
- `ui_wx/` — `ccm_ui_wx` static library. The only place that touches wxWidgets. See `ui_wx/AGENTS.md`. Ships `ui_wx/assets/ygo_card_back.png` (Yu-Gi-Oh! offline preview fallback); `app/CMakeLists.txt` copies it to `<exeDir>/assets/` when linking `ccm`.
+- `ui_wx/` — `ccm_ui_wx` static library. The only place that touches wxWidgets. See `ui_wx/AGENTS.md`. Ships `ui_wx/assets/ygo_card_back.png` and `ui_wx/assets/digibattle99_card_back.png` (offline preview fallbacks); `app/CMakeLists.txt` copies them to `<exeDir>/assets/` when linking `ccm`.
 - `app/` — `ccm` executable (composition root). Wires concrete adapters into services. See `app/AGENTS.md`.
 - `tests/` — `ccm_core_tests` doctest binary. Pure-logic tests against in-memory fakes. See `tests/AGENTS.md`.
 - `docs/` — long-form developer documentation. Start with `docs/adding-a-new-game.md` for the canonical end-to-end procedure for extending the app with a new TCG. See `docs/AGENTS.md`.
@@ -84,7 +84,7 @@ Run from the **workspace root**.
 - Card preview round-trips are slow (HTTPS handshake + image GET, often two hosts). The three amortizations in place — all game-agnostic — must stay. The full update mechanic (key-driven invalidation, positive↔negative same-key replacement, eviction, manual cache clearing) is documented in `docs/caching.md` → "Updating cached entries"; do **not** add a side-channel `clearCache(...)` API to `CardPreviewService` — keep updates flowing through cache keys so the in-memory and disk tiers stay aligned automatically.
  - `CardPreviewService` keeps a bounded in-memory LRU (`kCacheCapacity`) of preview bytes keyed by `(game, name, setId, setNo)` plus a by-URL cache for the per-game card-back fallback. Re-selecting a row already viewed in this session is decode-only, no HTTP. Source failures are split by `PreviewLookupError::Kind`: `NotFound` (the upstream answered cleanly that the record has no image) is **negative-cached** so subsequent clicks short-circuit to the card-back placeholder without HTTP, while `Transient` (HTTP/network/parse) is **never** cached so a brief outage can recover on the next selection. Editing a lookup-relevant field changes the cache key and invalidates the negative entry automatically.
  - `LocalPreviewByteCache` (port `IPreviewByteCache`) extends the LRU with an on-disk byte cache rooted at `<exeDir>/.cache/preview-cache/` — **next to the executable, in the same scope as `config.json`, NOT inside the user-configurable `dataStorage` path** so previews don't follow the user's collection when the data-storage path is reconfigured (the umbrella `.cache/` directory is reserved for any future computed-from-network caches). Both positive previews and `NotFound` verdicts **survive app restarts**. Lookup order is memory → disk → source/HTTP; a disk hit (positive or negative) is promoted into the in-memory tier so the follow-up call stays decode-only. Total `.bin` payload size is capped (default 64 MiB) and oldest-by-mtime entries are evicted when a new write would exceed the cap; tiny `.neg` markers are not counted against the cap. The persistent tier is fire-and-forget: any I/O error is swallowed by the adapter so disk problems can never break the preview path.
-  - `CprHttpClient` owns a single long-lived `cpr::Session` (and therefore a single libcurl easy handle) with keep-alive enabled, so repeat HTTPS calls to the same host (`api.scryfall.com`, `api.pokemontcg.io`, `db.ygoprodeck.com`, `yugipedia.com`, `ms.yugipedia.com`) reuse the existing TLS connection. Concurrent callers are serialized through a mutex — easy handles are not thread-safe and the preview path is single-flight already. Session default **`Accept: */*`** keeps JSON info APIs and binary image GETs on one client; **`CardPreviewService::fetchAndCache`** rejects empty HTTP bodies so a bogus 200 cannot masquerade as a cached preview.
+  - `CprHttpClient` owns a single long-lived `cpr::Session` (and therefore a single libcurl easy handle) with keep-alive enabled, so repeat HTTPS calls to the same host (`api.scryfall.com`, `api.pokemontcg.io`, `api.tcgdex.net`, `assets.tcgdex.net`, `db.ygoprodeck.com`, `yugipedia.com`, `ms.yugipedia.com`, `digimoncard.io`, `images.digimoncard.io`) reuse the existing TLS connection. Concurrent callers are serialized through a mutex — easy handles are not thread-safe and the preview path is single-flight already. Session default **`Accept: */*`** keeps JSON info APIs and binary image GETs on one client; **`CardPreviewService::fetchAndCache`** rejects empty HTTP bodies so a bogus 200 cannot masquerade as a cached preview.

 ## Windows UI theming guardrails

@@ -9,21 +9,38 @@ Currently, the application supports the following TCGs:
 - Magic the Gathering
 - Pokemon TCG
 - Yu-Gi-Oh!
+- Digimon (Digi-Battle)

 ## Screenshots

-### Magic The Gathering
+<details open>
+<summary>Magic The Gathering</summary>

 ![CCM3 Demo - Magic: The Gathering](docs/assets/images/demo-mtg.png)

-### Pokemon TCG
+</details>
+
+<details>
+<summary>Pokemon TCG</summary>

 ![CCM3 Demo - Pokemon](docs/assets/images/demo-pkm.png)

-### Yu-Gi-Oh!
+</details>
+
+<details>
+<summary>Yu-Gi-Oh!</summary>

 ![CCM3 Demo - YuGiOh](docs/assets/images/demo-ygo.png)

+</details>
+
+<details>
+<summary>Digimon (Digi-Battle)</summary>
+
+![CCM3 Demo - Digimon Digi-Battle](docs/assets/images/demo-digibattle99.png)
+
+</details>
+

 ## Migrating From CCM1 And CCM2

@@ -5,14 +5,14 @@ The `ccm` executable — composition root only. The single place where concrete
 ## File pointers

 - `main.cpp` — the entire app. Defines `CcmApp : public wxApp`, builds the dependency graph in `OnInit()`, then hands an `AppContext` to `MainFrame`.
- `CMakeLists.txt` — declares the `ccm` target. Sets `WIN32_EXECUTABLE TRUE` on Windows so no console window appears. Links `ccm_core`, `ccm_ui_wx`, `ccm_warnings`. **`POST_BUILD`**: creates `$<TARGET_FILE_DIR:ccm>/assets/` and copies `ui_wx/assets/ygo_card_back.png` there so Yu-Gi-Oh! preview fallbacks work offline (see `BaseSelectedCardPanel` / `docs/assets-and-info-apis.md`).
+- `CMakeLists.txt` — declares the `ccm` target. Sets `WIN32_EXECUTABLE TRUE` on Windows so no console window appears. Links `ccm_core`, `ccm_ui_wx`, `ccm_warnings`. **`POST_BUILD`**: creates `$<TARGET_FILE_DIR:ccm>/assets/` and copies `ui_wx/assets/ygo_card_back.png`, `ui_wx/assets/digibattle99_card_back.png`, and `ui_wx/assets/pokemon_jp_en_catalog.json` there so Yu-Gi-Oh! / Digi-Battle preview fallbacks and Japanese Pokémon EN names work offline (see `BaseSelectedCardPanel` / `docs/assets-and-info-apis.md`).

 ## Conventions

-1. **Composition root is the only place** that names concrete adapters: `StdFileSystem`, `CprHttpClient`, `JsonCollectionRepository<MagicCard>`, `JsonCollectionRepository<PokemonCard>`, `JsonCollectionRepository<YuGiOhCard>`, `JsonSetRepository`, `LocalImageStore`, `LocalPreviewByteCache`, `MagicGameModule`, `PokemonGameModule`, `YuGiOhGameModule`, `MagicGameView`, `PokemonGameView`, `YuGiOhGameView`, etc. If a concrete adapter type appears anywhere else in the codebase, move the wiring here.
+1. **Composition root is the only place** that names concrete adapters: `StdFileSystem`, `CprHttpClient`, `JsonCollectionRepository<MagicCard>`, `JsonCollectionRepository<PokemonCard>`, `JsonCollectionRepository<YuGiOhCard>`, `JsonCollectionRepository<DigiBattle99Card>`, `JsonSetRepository`, `LocalImageStore`, `LocalPreviewByteCache`, `MagicGameModule`, `PokemonGameModule`, `JapanesePokemonGameModule` (Asia sets/preview backend for unified Pokemon), `YuGiOhGameModule`, `DigiBattle99GameModule`, `MagicGameView`, `PokemonGameView`, `YuGiOhGameView`, `DigiBattle99GameView`, etc. If a concrete adapter type appears anywhere else in the codebase, move the wiring here.
 2. **Member declaration order in `CcmApp` matters** — destruction is reverse, so a member that depends on another (e.g. `magicCollSvc_` depends on `magicRepo_` and `imgStore_`; `previewSvc_` depends on `http_` and is consumed by `ctx_`; `magicView_` depends on the typed `magicCollSvc_` and the shared services) must be declared **after** its deps. Do not reorder casually.
 3. **Use `std::unique_ptr` for everything owned** by `CcmApp`. The `AppContext` then holds plain references into those owned objects, plus a vector of `IGameView*` raw pointers (the `unique_ptr<>`s for the views are the actual owners; the vector just describes the active set).
-4. **Game-to-directory mapping** lives in `dirNameForGame(Game)` (anonymous namespace). When adding a new game, extend this function — it is wired into all three repositories (`JsonCollectionRepository`, `JsonSetRepository`, `LocalImageStore`).
+4. **Game-to-directory mapping** lives in `dirNameForGame(Game)` (anonymous namespace). When adding a new game, extend this function — it is wired into all three repositories (`JsonCollectionRepository`, `JsonSetRepository`, `LocalImageStore`). Pokemon West (`Game::Pokemon`) and Asia (`Game::JapanesePokemon`) both map to `"pokemon"`; `JsonSetRepository` stores their set caches as `sets-west.json` / `sets-asia.json` in that directory (other games keep `sets.json`).
 5. **`config.json` location** is the executable's parent directory, resolved via `wxStandardPaths::Get().GetExecutablePath()`. Do not change this — existing installations rely on that location.
 6. **Image format handlers** must be registered via `wxImage::AddHandler(new wxPNGHandler)` and `new wxJPEGHandler` before any image is loaded. They are added in `OnInit()` first thing — keep it that way.
 7. **Card preview source ownership** lives inside the `IGameModule`. The composition root never constructs an `<Name>CardPreviewSource` directly; it calls `previewSvc_->registerModule(*<name>Mod_)` and the service pulls the module's preview source via `IGameModule::cardPreviewSource()` (returning `nullptr` is silently skipped).
@@ -21,7 +21,8 @@ The `ccm` executable — composition root only. The single place where concrete

 ## Required follow-ups

- The **`POST_BUILD` copy of `ygo_card_back.png`** must stay in sync with `ui_wx/assets/`; if you relocate install layout or add more bundled assets, mirror the pattern (`make_directory` + `copy_if_different`) and document under `docs/assets-and-info-apis.md` / `ui_wx/AGENTS.md`.
+- The **`POST_BUILD` copy of `ygo_card_back.png` / `digibattle99_card_back.png` / `pokemon_jp_en_catalog.json`** must stay in sync with `ui_wx/assets/`; if you relocate install layout or add more bundled assets, mirror the pattern (`make_directory` + `copy_if_different`) and document under `docs/assets-and-info-apis.md` / `ui_wx/AGENTS.md`.
+- On MinGW-w64 Windows, POST_BUILD also copies `libstdc++-6.dll` / `libgcc_s_seh-1.dll` / `libwinpthread-1.dll` from the compiler directory into `$<TARGET_FILE_DIR:ccm>` so the exe does not load a mismatched runtime from `PATH`.
 - After adding a new game module you **must**: (1) add a `unique_ptr<<Name>GameModule>` member in declaration-order-correct position, (2) construct it in `OnInit()`, (3) call `setSvc_->registerModule(<name>Mod_.get())`, (4) call `previewSvc_->registerModule(*<name>Mod_)` (no-op when the module has no preview source), (5) extend `dirNameForGame`, (6) add a typed `JsonCollectionRepository<<Name>Card>` + `CollectionService<<Name>Card>` if the game has a custom card type, (7) construct a `<Name>GameView` and append its raw pointer to the `AppContext::gameViews` vector, (8) make sure the view's `unique_ptr<>` member sits **after** all its deps (typed services + `IGameModule`).
 - After adding a new core service you **must** add a `unique_ptr<...>` member, construct it in `OnInit()` after its deps, and add a reference field to `AppContext`.
 - After adding a new dependency edge you **must** verify destruction order is still correct: deps **before** dependents in the member list.
@@ -19,9 +19,37 @@ target_link_libraries(ccm
        ccm_warnings
 )

-# Yu-Gi-Oh! preview fallback image (used when network card-back URLs fail).
+# Yu-Gi-Oh! / Digi-Battle preview fallback images and the Japanese Pokémon
+# EN name catalog (used when network card-back URLs fail or no public URL
+# exists / for JP English display names).
 add_custom_command(TARGET ccm POST_BUILD
    COMMAND ${CMAKE_COMMAND} -E make_directory "$<TARGET_FILE_DIR:ccm>/assets"
+    COMMAND ${CMAKE_COMMAND} -E make_directory "$<TARGET_FILE_DIR:ccm>/assets/pokemon_jp_classic"
    COMMAND ${CMAKE_COMMAND} -E copy_if_different
            "${CMAKE_SOURCE_DIR}/ui_wx/assets/ygo_card_back.png"
-            "$<TARGET_FILE_DIR:ccm>/assets/ygo_card_back.png")
+            "$<TARGET_FILE_DIR:ccm>/assets/ygo_card_back.png"
+    COMMAND ${CMAKE_COMMAND} -E copy_if_different
+            "${CMAKE_SOURCE_DIR}/ui_wx/assets/digibattle99_card_back.png"
+            "$<TARGET_FILE_DIR:ccm>/assets/digibattle99_card_back.png"
+    COMMAND ${CMAKE_COMMAND} -E copy_if_different
+            "${CMAKE_SOURCE_DIR}/ui_wx/assets/pokemon_jp_en_catalog.json"
+            "$<TARGET_FILE_DIR:ccm>/assets/pokemon_jp_en_catalog.json"
+    COMMAND ${CMAKE_COMMAND} -E copy_directory
+            "${CMAKE_SOURCE_DIR}/ui_wx/assets/pokemon_jp_classic"
+            "$<TARGET_FILE_DIR:ccm>/assets/pokemon_jp_classic")
+
+# MinGW-w64: ship the toolchain runtime next to ccm3.exe so Explorer / IDE
+# launches do not pick a mismatched libstdc++ off PATH (symptoms: Entry Point
+# Not Found for __emutls_v._ZSt11__once_call in libcpr.dll).
+if(WIN32 AND CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
+    get_filename_component(_ccm_mingw_bin "${CMAKE_CXX_COMPILER}" DIRECTORY)
+    foreach(_ccm_rt_dll IN ITEMS libstdc++-6.dll libgcc_s_seh-1.dll libwinpthread-1.dll)
+        if(EXISTS "${_ccm_mingw_bin}/${_ccm_rt_dll}")
+            add_custom_command(TARGET ccm POST_BUILD
+                COMMAND ${CMAKE_COMMAND} -E copy_if_different
+                        "${_ccm_mingw_bin}/${_ccm_rt_dll}"
+                        "$<TARGET_FILE_DIR:ccm>/${_ccm_rt_dll}"
+                VERBATIM)
+        endif()
+    endforeach()
+endif()
@@ -2,11 +2,15 @@
 // it to the wxWidgets UI layer. This is the only place where concrete adapter
 // types are mentioned - everything downstream depends on interfaces.

+#include "ccm/domain/DigiBattle99Card.hpp"
 #include "ccm/domain/MagicCard.hpp"
 #include "ccm/domain/PokemonCard.hpp"
 #include "ccm/domain/YuGiOhCard.hpp"
+#include "ccm/games/digibattle99/DigiBattle99GameModule.hpp"
 #include "ccm/games/magic/MagicGameModule.hpp"
 #include "ccm/games/pokemon/PokemonGameModule.hpp"
+#include "ccm/games/pokemonjp/JapanesePokemonEnCatalog.hpp"
+#include "ccm/games/pokemonjp/JapanesePokemonGameModule.hpp"
 #include "ccm/games/yugioh/YuGiOhGameModule.hpp"
 #include "ccm/infra/CprHttpClient.hpp"
 #include "ccm/infra/JsonCollectionRepository.hpp"
@@ -20,6 +24,7 @@
 #include "ccm/services/ImageService.hpp"
 #include "ccm/services/SetService.hpp"
 #include "ccm/ui/AppContext.hpp"
+#include "ccm/ui/DigiBattle99GameView.hpp"
 #include "ccm/ui/MagicGameView.hpp"
 #include "ccm/ui/MainFrame.hpp"
 #include "ccm/ui/PokemonGameView.hpp"
@@ -42,9 +47,11 @@ namespace {
 // need for the repositories to know about concrete game module classes.
 std::string dirNameForGame(ccm::Game g) {
    switch (g) {
-        case ccm::Game::Magic:   return "magic";
-        case ccm::Game::Pokemon: return "pokemon";
-        case ccm::Game::YuGiOh:  return "yugioh";
+        case ccm::Game::Magic:           return "magic";
+        case ccm::Game::Pokemon:         return "pokemon";
+        case ccm::Game::YuGiOh:          return "yugioh";
+        case ccm::Game::DigiBattle99:    return "digibattle99";
+        case ccm::Game::JapanesePokemon: return "pokemon";
    }
    return "magic";
 }
@@ -80,6 +87,18 @@ public:
        magicMod_ = std::make_unique<ccm::MagicGameModule>(*http_);
        pokeMod_  = std::make_unique<ccm::PokemonGameModule>(*http_);
        ygoMod_   = std::make_unique<ccm::YuGiOhGameModule>(*http_);
+        digiBattle99Mod_ = std::make_unique<ccm::DigiBattle99GameModule>(*http_);
+
+        ccm::JapanesePokemonEnCatalog jpCatalog;
+        {
+            const auto catalogPath = exeDir / "assets" / "pokemon_jp_en_catalog.json";
+            if (auto text = fs_->readText(catalogPath); text) {
+                if (auto parsed = ccm::JapanesePokemonEnCatalog::parse(text.value()); parsed) {
+                    jpCatalog = std::move(parsed).value();
+                }
+            }
+        }
+        jpPokeMod_ = std::make_unique<ccm::JapanesePokemonGameModule>(*http_, std::move(jpCatalog));

        magicRepo_ = std::make_unique<ccm::JsonCollectionRepository<ccm::MagicCard>>(
            *fs_, *config_, &dirNameForGame);
@@ -87,6 +106,9 @@ public:
            *fs_, *config_, &dirNameForGame);
        ygoRepo_   = std::make_unique<ccm::JsonCollectionRepository<ccm::YuGiOhCard>>(
            *fs_, *config_, &dirNameForGame);
+        digiBattle99Repo_ =
+            std::make_unique<ccm::JsonCollectionRepository<ccm::DigiBattle99Card>>(
+                *fs_, *config_, &dirNameForGame);
        setRepo_   = std::make_unique<ccm::JsonSetRepository>(*fs_, *config_, &dirNameForGame);
        imgStore_  = std::make_unique<ccm::LocalImageStore>(*fs_, *config_, &dirNameForGame);

@@ -97,10 +119,15 @@ public:
            *pokeRepo_, *imgStore_);
        ygoCollSvc_   = std::make_unique<ccm::CollectionService<ccm::YuGiOhCard>>(
            *ygoRepo_, *imgStore_);
+        digiBattle99CollSvc_ =
+            std::make_unique<ccm::CollectionService<ccm::DigiBattle99Card>>(
+                *digiBattle99Repo_, *imgStore_);
        setSvc_       = std::make_unique<ccm::SetService>(*setRepo_);
        setSvc_->registerModule(magicMod_.get());
        setSvc_->registerModule(pokeMod_.get());
        setSvc_->registerModule(ygoMod_.get());
+        setSvc_->registerModule(digiBattle99Mod_.get());
+        setSvc_->registerModule(jpPokeMod_.get());

        // Disk-backed preview cache lives next to the executable, in the same
        // location scope as config.json - NOT inside the user's data-storage
@@ -116,10 +143,16 @@ public:
        previewCache_ = std::make_unique<ccm::LocalPreviewByteCache>(
            *fs_,
            exeDir / ".cache" / "preview-cache");
-        previewSvc_   = std::make_unique<ccm::CardPreviewService>(*http_, previewCache_.get());
+        previewSvc_   = std::make_unique<ccm::CardPreviewService>(
+            *http_,
+            previewCache_.get(),
+            fs_.get(),
+            exeDir / "assets");
        previewSvc_->registerModule(*magicMod_);
        previewSvc_->registerModule(*pokeMod_);
        previewSvc_->registerModule(*ygoMod_);
+        previewSvc_->registerModule(*digiBattle99Mod_);
+        previewSvc_->registerModule(*jpPokeMod_);

        // Per-game UI bundles. Order here is the order shown in the Game menu.
        magicView_ = std::make_unique<ccm::ui::MagicGameView>(
@@ -128,6 +161,9 @@ public:
            *config_, *pokeCollSvc_, *setSvc_, *imgSvc_, *previewSvc_, *pokeMod_);
        ygoView_   = std::make_unique<ccm::ui::YuGiOhGameView>(
            *config_, *ygoCollSvc_, *setSvc_, *imgSvc_, *previewSvc_, *ygoMod_);
+        digiBattle99View_ = std::make_unique<ccm::ui::DigiBattle99GameView>(
+            *config_, *digiBattle99CollSvc_, *setSvc_, *imgSvc_, *previewSvc_,
+            *digiBattle99Mod_);

        ctx_ = std::make_unique<ccm::ui::AppContext>(ccm::ui::AppContext{
            *config_,
@@ -137,7 +173,9 @@ public:
            *magicMod_,
            *pokeMod_,
            *ygoMod_,
-            { magicView_.get(), pokeView_.get(), ygoView_.get() },
+            *digiBattle99Mod_,
+            *jpPokeMod_,
+            { magicView_.get(), pokeView_.get(), ygoView_.get(), digiBattle99View_.get() },
        });

        auto* frame = new ccm::ui::MainFrame(*ctx_);
@@ -158,21 +196,26 @@ private:
    std::unique_ptr<ccm::MagicGameModule>                            magicMod_;
    std::unique_ptr<ccm::PokemonGameModule>                          pokeMod_;
    std::unique_ptr<ccm::YuGiOhGameModule>                           ygoMod_;
+    std::unique_ptr<ccm::DigiBattle99GameModule>                     digiBattle99Mod_;
+    std::unique_ptr<ccm::JapanesePokemonGameModule>                  jpPokeMod_;
    std::unique_ptr<ccm::JsonCollectionRepository<ccm::MagicCard>>   magicRepo_;
    std::unique_ptr<ccm::JsonCollectionRepository<ccm::PokemonCard>> pokeRepo_;
    std::unique_ptr<ccm::JsonCollectionRepository<ccm::YuGiOhCard>>  ygoRepo_;
+    std::unique_ptr<ccm::JsonCollectionRepository<ccm::DigiBattle99Card>> digiBattle99Repo_;
    std::unique_ptr<ccm::JsonSetRepository>                          setRepo_;
    std::unique_ptr<ccm::LocalImageStore>                            imgStore_;
    std::unique_ptr<ccm::ImageService>                               imgSvc_;
    std::unique_ptr<ccm::CollectionService<ccm::MagicCard>>          magicCollSvc_;
    std::unique_ptr<ccm::CollectionService<ccm::PokemonCard>>        pokeCollSvc_;
    std::unique_ptr<ccm::CollectionService<ccm::YuGiOhCard>>         ygoCollSvc_;
+    std::unique_ptr<ccm::CollectionService<ccm::DigiBattle99Card>>   digiBattle99CollSvc_;
    std::unique_ptr<ccm::SetService>                                 setSvc_;
    std::unique_ptr<ccm::LocalPreviewByteCache>                      previewCache_;
    std::unique_ptr<ccm::CardPreviewService>                         previewSvc_;
    std::unique_ptr<ccm::ui::MagicGameView>                          magicView_;
    std::unique_ptr<ccm::ui::PokemonGameView>                        pokeView_;
    std::unique_ptr<ccm::ui::YuGiOhGameView>                         ygoView_;
+    std::unique_ptr<ccm::ui::DigiBattle99GameView>                   digiBattle99View_;
    std::unique_ptr<ccm::ui::AppContext>                             ctx_;
 };

@@ -4,11 +4,11 @@

 ## Layer pointers

- `include/ccm/domain/` — POD value types: `Enums`, `Set`, `MagicCard`, `PokemonCard`, `YuGiOhCard`, `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`, `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/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/`, and `yugioh/` are the reference implementations — all three expose a fully working set source + card preview source.
+- `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/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.

@@ -27,7 +27,7 @@
 8. **HTTP query strings must be percent-encoded** before they reach `IHttpClient::get`. `cpr::Url` does **not** encode the URL string we hand it. See `MagicCardPreviewSource::buildSearchUrl` for the canonical pattern (RFC 3986 unreserved-set encoder). `IHttpClient::get` accepts arbitrary bytes back — `Result<std::string>` is a binary buffer, not text, so callers can use it for image payloads directly.
 9. **Yu-Gi-Oh! preview uses Yugipedia, not YGOPRODeck.** `YuGiOhCardPreviewSource::fetchImageUrl` queries Yugipedia's MediaWiki API with a batched list of deterministic file names (`<Slug>-<SET>-<REGION>-<RARITY>-<EDITION>.<png|jpg>`) so per-printing reprints with shared passcodes (LOB Blue-Eyes vs SDK Blue-Eyes, …) resolve to genuinely different scans. Region candidates are **always English** (`EN`/`NA`/`EU`/`AU`) regardless of `card.language`; localized scans are not queried. YGOPRODeck remains as a last-resort fallback (see `parseFallbackImageUrl`) for cards Yugipedia hasn't scanned yet, and as the source for `detectFirstPrint` / `detectPrintVariants` (`parsePrintVariants` enumerates distinct printings for the edit dialog). **Do not** restore a YGOPRODeck-only image path: that endpoint's `card_images` array is keyed by art-treatment passcode, not by physical printing, and adding `cardset=` only reorders the same passcode list (alt-art often gets promoted) without ever surfacing the per-printing scan. The YGO source therefore needs the printed edition flag to be plumbed through; `YuGiOhSelectedCardPanel::previewKey()` packs it into the third tuple slot as `<setNo>||<rarity>||<1E|UE>` so the candidate list can prioritize the correct edition without changing the generic `ICardPreviewSource` interface.
 10. **Preview byte cache (`CardPreviewService`) is by `(game, name, setId, setNo)` across two tiers, with classified failure caching and a single update mechanic.** Successful `fetchPreviewBytes` results and successful `fetchImageBytesByUrl` results are stored first in a bounded in-memory LRU (`kCacheCapacity` entries, mutex-protected — the panel calls into the service from a worker thread) and then in an optional persistent byte cache (`IPreviewByteCache`, normally `LocalPreviewByteCache` rooted at `<exeDir>/.cache/preview-cache/` — next to the executable, **not** under `dataStorage`, so previews don't follow the user's collection when the data-storage path is reconfigured). **`fetchAndCache` rejects empty response bodies** (returns error, no tier write) so a degenerate HTTP 200 cannot fill the LRU with unusable entries. Lookup order is **memory → disk → source/HTTP**, and a disk hit (positive *or* negative) is promoted into the in-memory tier on its way to the caller so the next selection of the same row stays decode-only. **Failures are split by `PreviewLookupError::Kind`**: `NotFound` is negative-cached in both tiers (memory `CacheEntry::negative=true`, disk `<hash>.neg` marker) so the user gets an instant card-back on every subsequent click for cards whose printing genuinely has no upstream image; `Transient` (HTTP/network/parse failures) is **never** cached so a brief outage cannot permanently disable previews. Per-game `ICardPreviewSource::fetchImageUrl` implementations must classify their errors honestly — `NotFound` only when the upstream answered cleanly with no match / no image variants; anything that could be the network or a schema deviation is `Transient`. **The cache update mechanic is entirely key-driven and has no side-channel API:** (a) the user editing any lookup-relevant field of a card record changes the cache key, so the next selection misses both tiers and re-runs the source — this is how a stale negative entry gets dislodged after the user fixes the record, with no manual invalidation call needed; (b) a same-key resolution that flips between positive and negative outcomes overwrites the existing entry in both tiers (`store` removes any `.neg` for that hash; `storeNegative` removes any `.bin`) so `.bin` and `.neg` for the same hash are never co-resident; (c) eviction handles passive aging (LRU on the in-memory tier; oldest-by-mtime `.bin` files on the disk tier; `.neg` markers don't count against the size cap and are not actively evicted). **Do not add a `clearCache(...)` / `invalidate(...)` method** to `CardPreviewService`: the cache invariants depend on memory and disk staying aligned through the same write paths, and any side-channel API would just be a new way for future code to forget the disk tier. If you add a new lookup disambiguator (for example a future `editionTag` slot), pack it into one of the existing key fields (see `YuGiOhSelectedCardPanel::previewKey()`'s `||`-separated trailing fields) so editing the field continues to invalidate cached entries automatically. The persistent tier is **fire-and-forget**: the adapter swallows I/O errors so a flaky or full disk degrades the experience to a fresh-install warm-up, never to a broken preview path.
-11. **`CprHttpClient` keeps one persistent `cpr::Session` for the app's lifetime.** All callers (set sources, preview sources, fallback URL fetch, auto-detect) share the same libcurl easy handle so connections to repeat hosts (`api.scryfall.com`, `api.pokemontcg.io`, `db.ygoprodeck.com`, `yugipedia.com`, `ms.yugipedia.com`) are reused with TLS keep-alive. Default request headers use **`Accept: */*`** so JSON endpoints and binary image downloads share one session without pinning every GET to `application/json`. The session is not thread-safe — every `get(...)` is serialized through an internal mutex. **Do not** construct a new `cpr::Session` (or `cpr::Get(...)`) per call: that throws away the connection cache and re-pays the TLS handshake every time. If you need richer behavior on the port (POST, headers per call, …) extend `IHttpClient` and the adapter while keeping the single-session ownership intact.
+11. **`CprHttpClient` keeps one persistent `cpr::Session` for the app's lifetime.** All callers (set sources, preview sources, fallback URL fetch, auto-detect) share the same libcurl easy handle so connections to repeat hosts (`api.scryfall.com`, `api.pokemontcg.io`, `api.tcgdex.net`, `assets.tcgdex.net`, `product-images.tcgplayer.com`, `db.ygoprodeck.com`, `yugipedia.com`, `ms.yugipedia.com`, `digimoncard.io`, `images.digimoncard.io`) are reused with TLS keep-alive. Default request headers use **`Accept: */*`** so JSON endpoints and binary image downloads share one session without pinning every GET to `application/json`. The session is not thread-safe — every `get(...)` is serialized through an internal mutex. **Do not** construct a new `cpr::Session` (or `cpr::Get(...)`) per call: that throws away the connection cache and re-pays the TLS handshake every time. If you need richer behavior on the port (POST, headers per call, …) extend `IHttpClient` and the adapter while keeping the single-session ownership intact.

 ## Adding a new game

@@ -7,6 +7,8 @@ add_library(ccm_core STATIC
    src/domain/MagicCard.cpp
    src/domain/PokemonCard.cpp
    src/domain/YuGiOhCard.cpp
+    src/domain/DigiBattle99Card.cpp
+    src/domain/JapanesePokemonCard.cpp
    src/domain/Configuration.cpp

    src/services/ConfigService.cpp
@@ -31,6 +33,13 @@ add_library(ccm_core STATIC
    src/games/yugioh/YuGiOhSetSource.cpp
    src/games/yugioh/YuGiOhCardPreviewSource.cpp
    src/games/yugioh/YuGiOhGameModule.cpp
+    src/games/digibattle99/DigiBattle99SetSource.cpp
+    src/games/digibattle99/DigiBattle99CardPreviewSource.cpp
+    src/games/digibattle99/DigiBattle99GameModule.cpp
+    src/games/pokemonjp/JapanesePokemonEnCatalog.cpp
+    src/games/pokemonjp/JapanesePokemonSetSource.cpp
+    src/games/pokemonjp/JapanesePokemonCardPreviewSource.cpp
+    src/games/pokemonjp/JapanesePokemonGameModule.cpp

    src/util/FsNames.cpp
 )
@@ -0,0 +1,38 @@
+#pragma once
+
+// DigiBattle99Card - Digimon Digi-Battle (1999 English) card model.
+// Pokémon-shaped field set (setNo / holo / firstEdition / signed / altered).
+
+#include "ccm/domain/Enums.hpp"
+#include "ccm/domain/Set.hpp"
+
+#include <nlohmann/json.hpp>
+
+#include <cstdint>
+#include <string>
+#include <vector>
+
+namespace ccm {
+
+struct DigiBattle99Card {
+    std::uint32_t id{0};
+    std::uint8_t  amount{1};
+    std::string   name;
+    Set           set;
+    std::string   setNo;
+    std::string   note;
+    std::vector<std::string> images;
+    Language      language{Language::English};
+    Condition     condition{Condition::NearMint};
+    bool          firstEdition{false};
+    bool          holo{false};
+    bool          signed_{false};
+    bool          altered{false};
+
+    friend bool operator==(const DigiBattle99Card&, const DigiBattle99Card&) = default;
+};
+
+void to_json(nlohmann::json& j, const DigiBattle99Card& c);
+void from_json(const nlohmann::json& j, DigiBattle99Card& c);
+
+}  // namespace ccm
@@ -10,6 +10,7 @@

 #include <array>
 #include <optional>
+#include <span>
 #include <string>
 #include <string_view>

@@ -19,6 +20,13 @@ enum class Game {
    Magic,
    Pokemon,
    YuGiOh,
+    DigiBattle99,
+    JapanesePokemon,  // internal Asia sets/preview routing; not in allGames()
+};
+
+enum class PokemonRegion {
+    West,
+    Asia,
 };

 enum class Language {
@@ -27,8 +35,10 @@ enum class Language {
    French,
    Spanish,
    Italian,
-    Chinese,
+    SimplifiedChinese,   // JSON / display: "S-Chinese" (legacy "Chinese" accepted)
+    TraditionalChinese,  // JSON / display: "T-Chinese"
    Japanese,
+    Korean,
    Russian,
 };

@@ -48,24 +58,34 @@ enum class Theme {
 };

 std::string_view to_string(Game g) noexcept;
+std::string_view to_string(PokemonRegion r) noexcept;
 std::string_view to_string(Language l) noexcept;
 std::string_view to_string(Condition c) noexcept;
 std::string_view to_string(Theme t) noexcept;

-std::optional<Game>      gameFromString(std::string_view s) noexcept;
-std::optional<Language>  languageFromString(std::string_view s) noexcept;
-std::optional<Condition> conditionFromString(std::string_view s) noexcept;
-std::optional<Theme>     themeFromString(std::string_view s) noexcept;
+std::optional<Game>          gameFromString(std::string_view s) noexcept;
+std::optional<PokemonRegion> pokemonRegionFromString(std::string_view s) noexcept;
+std::optional<Language>      languageFromString(std::string_view s) noexcept;
+std::optional<Condition>     conditionFromString(std::string_view s) noexcept;
+std::optional<Theme>         themeFromString(std::string_view s) noexcept;

-const std::array<Game, 3>&       allGames() noexcept;
-const std::array<Language, 8>&   allLanguages() noexcept;
+// User-facing games (Game menu / Settings). JapanesePokemon is internal-only.
+const std::array<Game, 4>&       allGames() noexcept;
+const std::array<Language, 10>&  allLanguages() noexcept;
 const std::array<Condition, 7>&  allConditions() noexcept;
 const std::array<Theme, 2>&      allThemes() noexcept;

+[[nodiscard]] std::span<const Language> languagesForPokemonRegion(PokemonRegion r) noexcept;
+[[nodiscard]] Game pokemonBackendGame(PokemonRegion r) noexcept;
+[[nodiscard]] Language defaultLanguageForPokemonRegion(PokemonRegion r) noexcept;
+
 // nlohmann/json hooks - serialize as plain strings, matching Rust serde.
 void to_json(nlohmann::json& j, Game v);
 void from_json(const nlohmann::json& j, Game& v);

+void to_json(nlohmann::json& j, PokemonRegion v);
+void from_json(const nlohmann::json& j, PokemonRegion& v);
+
 void to_json(nlohmann::json& j, Language v);
 void from_json(const nlohmann::json& j, Language& v);

@@ -0,0 +1,38 @@
+#pragma once
+
+// JapanesePokemonCard - Japanese Pokémon TCG collection model.
+// Pokémon-shaped field set (setNo / holo / firstEdition / signed / altered).
+
+#include "ccm/domain/Enums.hpp"
+#include "ccm/domain/Set.hpp"
+
+#include <nlohmann/json.hpp>
+
+#include <cstdint>
+#include <string>
+#include <vector>
+
+namespace ccm {
+
+struct JapanesePokemonCard {
+    std::uint32_t id{0};
+    std::uint8_t  amount{1};
+    std::string   name;
+    Set           set;
+    std::string   setNo;
+    std::string   note;
+    std::vector<std::string> images;
+    Language      language{Language::Japanese};
+    Condition     condition{Condition::NearMint};
+    bool          firstEdition{false};
+    bool          holo{false};
+    bool          signed_{false};
+    bool          altered{false};
+
+    friend bool operator==(const JapanesePokemonCard&, const JapanesePokemonCard&) = default;
+};
+
+void to_json(nlohmann::json& j, const JapanesePokemonCard& c);
+void from_json(const nlohmann::json& j, JapanesePokemonCard& c);
+
+}  // namespace ccm
@@ -1,7 +1,8 @@
 #pragma once

 // PokemonCard - faithful port of pokemon/card_services.rs::Card.
-// Same established JSON shape (with `setNo` and `firstEdition` aliases).
+// Same established JSON shape (with `setNo` and `firstEdition` aliases),
+// plus `region` (West/Asia) for unified West+Asia collections.

 #include "ccm/domain/Enums.hpp"
 #include "ccm/domain/Set.hpp"
@@ -28,6 +29,7 @@ struct PokemonCard {
    bool          holo{false};
    bool          signed_{false};
    bool          altered{false};
+    PokemonRegion region{PokemonRegion::West};

    friend bool operator==(const PokemonCard&, const PokemonCard&) = default;
 };
@@ -23,6 +23,10 @@ public:
    // Implementations return a vector that has already been filtered
    // (e.g. no digital-only sets) and sorted by release date ascending.
    virtual Result<std::vector<Set>> fetchAll() = 0;
+
+    // Optional post-process for locally cached set lists (e.g. inject products
+    // the upstream API omits). Default is a no-op. Called by SetService::getSets.
+    virtual void augmentCachedSets(std::vector<Set>& /*sets*/) const {}
 };

 class IGameModule {
@@ -0,0 +1,67 @@
+#pragma once
+
+// DigiBattle99CardPreviewSource: digimoncard.io search + CDN card images for
+// Digimon Digi-Battle (1999 English).
+//
+// Preview key middle slot is Set.name (pack display name) so search.php?pack=
+// works without a reverse slug map. When setNo is present, the CDN URL is
+// built directly — no search round-trip.
+
+#include "ccm/ports/ICardPreviewSource.hpp"
+#include "ccm/ports/IHttpClient.hpp"
+
+#include <string>
+#include <string_view>
+#include <vector>
+
+namespace ccm {
+
+class DigiBattle99CardPreviewSource final : public ICardPreviewSource {
+public:
+    static constexpr const char* kSeries = "Digimon Digi-Battle Card Game";
+    static constexpr const char* kImageBase =
+        "https://images.digimoncard.io/images/cards/";
+
+    explicit DigiBattle99CardPreviewSource(IHttpClient& http);
+
+    [[nodiscard]] bool supportsAutoDetectPrint() const noexcept override { return true; }
+
+    Result<std::string, PreviewLookupError>
+        fetchImageUrl(std::string_view name,
+                      std::string_view setName,
+                      std::string_view setNo) override;
+    Result<AutoDetectedPrint> detectFirstPrint(std::string_view name,
+                                               std::string_view setName) override;
+    Result<std::vector<AutoDetectedPrint>> detectPrintVariants(std::string_view name,
+                                                               std::string_view setName) override;
+
+    // Uppercase the alphabetic prefix of a Digi-Battle card number (bo-88 -> BO-88).
+    // Does not invent zero-padding — CDN keys match API ids literally.
+    static std::string normalizeCardNumber(std::string_view setNo);
+
+    // CDN preview URL for a normalized card id (.jpg — wxImage registers
+    // JPEG/PNG only; digimoncard.io also serves .webp but we cannot decode it).
+    static std::string buildImageUrl(std::string_view setNo);
+
+    // digimoncard.io search URL: n= / pack= / series= / optional card=.
+    // setName is the pack display name (Set.name), not the slug id.
+    static std::string buildSearchUrl(std::string_view name,
+                                      std::string_view setName,
+                                      std::string_view setNo);
+
+    // Parse a digimoncard.io search.php body into a CDN image URL for the
+    // first exact name match (optional pack filter applied by the request).
+    static Result<std::string, PreviewLookupError>
+        parseImageUrlFromSearch(const std::string& body,
+                                std::string_view wantedCardName);
+
+    static Result<std::vector<AutoDetectedPrint>>
+        parsePrintVariants(const std::string& body,
+                           std::string_view setName,
+                           std::string_view wantedCardName);
+
+private:
+    IHttpClient& http_;
+};
+
+}  // namespace ccm
@@ -0,0 +1,27 @@
+#pragma once
+
+// DigiBattle99GameModule: Digimon Digi-Battle (1999 English) via digimoncard.io.
+
+#include "ccm/games/IGameModule.hpp"
+#include "ccm/games/digibattle99/DigiBattle99CardPreviewSource.hpp"
+#include "ccm/games/digibattle99/DigiBattle99SetSource.hpp"
+
+namespace ccm {
+
+class DigiBattle99GameModule final : public IGameModule {
+public:
+    explicit DigiBattle99GameModule(IHttpClient& http);
+
+    [[nodiscard]] Game        id() const noexcept override { return Game::DigiBattle99; }
+    [[nodiscard]] std::string dirName()     const override { return "digibattle99"; }
+    [[nodiscard]] std::string displayName() const override { return "Digimon (Digi-Battle)"; }
+
+    ISetSource&         setSource()          override { return setSource_; }
+    ICardPreviewSource* cardPreviewSource() noexcept override { return &previewSource_; }
+
+private:
+    DigiBattle99SetSource         setSource_;
+    DigiBattle99CardPreviewSource previewSource_;
+};
+
+}  // namespace ccm
@@ -0,0 +1,37 @@
+#pragma once
+
+// 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.
+
+#include "ccm/games/IGameModule.hpp"
+#include "ccm/ports/IHttpClient.hpp"
+
+#include <string>
+#include <string_view>
+
+namespace ccm {
+
+class DigiBattle99SetSource final : public ISetSource {
+public:
+    static constexpr const char* kEndpoint =
+        "https://digimoncard.io/api-public/search.php?"
+        "series=Digimon%20Digi-Battle%20Card%20Game&limit=1000&sort=name&sortdirection=asc";
+
+    static constexpr const char* kSeries = "Digimon Digi-Battle Card Game";
+
+    explicit DigiBattle99SetSource(IHttpClient& http);
+
+    Result<std::vector<Set>> fetchAll() override;
+
+    // Pure parser exposed for unit testing without a network round-trip.
+    static Result<std::vector<Set>> parseResponse(const std::string& body);
+
+    // Stable Set.id from a pack display name (ASCII lower, non-alnum -> '-').
+    static std::string slugifyPackName(std::string_view packName);
+
+private:
+    IHttpClient& http_;
+};
+
+}  // namespace ccm
@@ -0,0 +1,68 @@
+#pragma once
+
+// JapanesePokemonCardPreviewSource: TCGdex ja localId-based preview + variants.
+// Image URLs use /high.png (wxImage decodes PNG/JPEG, not webp).
+
+#include "ccm/games/pokemonjp/JapanesePokemonEnCatalog.hpp"
+#include "ccm/ports/ICardPreviewSource.hpp"
+#include "ccm/ports/IHttpClient.hpp"
+
+#include <string>
+#include <string_view>
+#include <vector>
+
+namespace ccm {
+
+class JapanesePokemonCardPreviewSource final : public ICardPreviewSource {
+public:
+    JapanesePokemonCardPreviewSource(IHttpClient& http,
+                                     const JapanesePokemonEnCatalog& catalog);
+
+    [[nodiscard]] bool supportsAutoDetectPrint() const noexcept override { return true; }
+
+    Result<std::string, PreviewLookupError>
+        fetchImageUrl(std::string_view name,
+                      std::string_view setId,
+                      std::string_view setNo) override;
+    Result<AutoDetectedPrint> detectFirstPrint(std::string_view name,
+                                               std::string_view setId) override;
+    Result<std::vector<AutoDetectedPrint>> detectPrintVariants(std::string_view name,
+                                                               std::string_view setId) override;
+
+    static std::string normalizeLocalId(std::string_view setNo);
+    static std::string buildSetDetailUrl(std::string_view setId);
+    static std::string buildCardUrl(std::string_view setId, std::string_view localId);
+    static std::string imageUrlFromBase(std::string_view imageBase);
+
+    // Parse set-detail body; optionally filter by name (EN catalog / JA) and/or localId.
+    struct SetCardRow {
+        std::string localId;
+        std::string nameJa;
+        std::string imageBase;  // empty when TCGdex has no scan
+        std::string rarity;
+    };
+
+    static Result<std::vector<SetCardRow>, PreviewLookupError>
+        parseSetCards(const std::string& body);
+
+    static Result<std::string, PreviewLookupError>
+        parseCardImageUrl(const std::string& body);
+
+    static Result<std::vector<AutoDetectedPrint>>
+        parsePrintVariants(const std::string& body,
+                           std::string_view setId,
+                           std::string_view wantedCardName,
+                           const JapanesePokemonEnCatalog& catalog);
+
+    // Catalog-only Auto-detect when TCGdex has no set detail (theme decks, etc.).
+    static Result<std::vector<AutoDetectedPrint>>
+        detectPrintVariantsFromCatalog(std::string_view setId,
+                                       std::string_view wantedCardName,
+                                       const JapanesePokemonEnCatalog& catalog);
+
+private:
+    IHttpClient& http_;
+    const JapanesePokemonEnCatalog& catalog_;
+};
+
+}  // namespace ccm
@@ -0,0 +1,71 @@
+#pragma once
+
+// JapanesePokemonEnCatalog - bundled English name layer for Japanese Pokémon.
+// Loaded from assets/pokemon_jp_en_catalog.json (generated offline). Missing
+// entries fall through to TCGdex Japanese names at runtime.
+
+#include "ccm/util/Result.hpp"
+
+#include <optional>
+#include <string>
+#include <string_view>
+#include <unordered_map>
+#include <vector>
+
+namespace ccm {
+
+struct JapanesePokemonSetEnInfo {
+    std::string nameEn;
+    std::string nameJa;
+    std::string releaseDate;  // YYYY/MM/DD when known; may be empty
+};
+
+struct JapanesePokemonPrintEnInfo {
+    std::string setId;
+    std::string localId;
+    std::string nameEn;
+    std::string nameJa;
+    std::string nameEnSource;  // bulbapedia | species-table | manual
+    // Classic JA gap-fill when TCGdex has no CDN scan (optional).
+    std::string imageUrl;      // explicit HTTPS URL, preferred when set
+    std::string tcgplayerId;   // TCGPlayer product id → product-images CDN
+};
+
+class JapanesePokemonEnCatalog {
+public:
+    [[nodiscard]] static Result<JapanesePokemonEnCatalog>
+        parse(const std::string& jsonBody);
+
+    [[nodiscard]] bool empty() const noexcept {
+        return sets_.empty() && printsByKey_.empty();
+    }
+
+    [[nodiscard]] std::optional<JapanesePokemonSetEnInfo>
+        findSet(std::string_view setId) const;
+
+    [[nodiscard]] std::optional<JapanesePokemonPrintEnInfo>
+        findPrint(std::string_view setId, std::string_view localId) const;
+
+    // Case-insensitive match of nameEn or nameJa within a set.
+    // Also matches qualified English titles: wanted "Mewtwo" hits
+    // "Mewtwo (CoroCoro promo)" (prefix + " (").
+    [[nodiscard]] std::vector<JapanesePokemonPrintEnInfo>
+        findPrintsByName(std::string_view setId, std::string_view cardName) const;
+
+    [[nodiscard]] bool hasPrintsForSet(std::string_view setId) const noexcept;
+
+    // TCGPlayer product-image CDN URL for classic JA gap-fill.
+    [[nodiscard]] static std::string tcgplayerImageUrl(std::string_view productId);
+
+    // Prefer imageUrl; else build from tcgplayerId; else empty.
+    [[nodiscard]] static std::string previewImageUrlFromPrint(
+        const JapanesePokemonPrintEnInfo& print);
+
+private:
+    std::unordered_map<std::string, JapanesePokemonSetEnInfo> sets_;
+    std::unordered_map<std::string, JapanesePokemonPrintEnInfo> printsByKey_;
+    // setId -> print keys for name scans
+    std::unordered_map<std::string, std::vector<std::string>> printKeysBySet_;
+};
+
+}  // namespace ccm
@@ -0,0 +1,34 @@
+#pragma once
+
+// JapanesePokemonGameModule: Japanese Pokémon TCG via TCGdex ja + EN catalog.
+
+#include "ccm/games/IGameModule.hpp"
+#include "ccm/games/pokemonjp/JapanesePokemonCardPreviewSource.hpp"
+#include "ccm/games/pokemonjp/JapanesePokemonEnCatalog.hpp"
+#include "ccm/games/pokemonjp/JapanesePokemonSetSource.hpp"
+
+namespace ccm {
+
+class JapanesePokemonGameModule final : public IGameModule {
+public:
+    explicit JapanesePokemonGameModule(IHttpClient& http,
+                                       JapanesePokemonEnCatalog catalog = {});
+
+    [[nodiscard]] Game        id() const noexcept override { return Game::JapanesePokemon; }
+    [[nodiscard]] std::string dirName()     const override { return "pokemon"; }
+    [[nodiscard]] std::string displayName() const override { return "Pokemon (Japan)"; }
+
+    ISetSource&         setSource()          override { return setSource_; }
+    ICardPreviewSource* cardPreviewSource() noexcept override { return &previewSource_; }
+
+    [[nodiscard]] const JapanesePokemonEnCatalog& catalog() const noexcept {
+        return catalog_;
+    }
+
+private:
+    JapanesePokemonEnCatalog          catalog_;
+    JapanesePokemonSetSource          setSource_;
+    JapanesePokemonCardPreviewSource  previewSource_;
+};
+
+}  // namespace ccm
@@ -0,0 +1,39 @@
+#pragma once
+
+// JapanesePokemonSetSource: TCGdex ja set list + per-set detail for release
+// dates. English display names come from JapanesePokemonEnCatalog when present.
+
+#include "ccm/games/IGameModule.hpp"
+#include "ccm/games/pokemonjp/JapanesePokemonEnCatalog.hpp"
+#include "ccm/ports/IHttpClient.hpp"
+
+namespace ccm {
+
+class JapanesePokemonSetSource final : public ISetSource {
+public:
+    static constexpr const char* kListEndpoint = "https://api.tcgdex.net/v2/ja/sets";
+
+    JapanesePokemonSetSource(IHttpClient& http, const JapanesePokemonEnCatalog& catalog);
+
+    Result<std::vector<Set>> fetchAll() override;
+
+    void augmentCachedSets(std::vector<Set>& sets) const override;
+
+    // Pure parsers for hermetic tests.
+    static Result<std::vector<Set>> parseListResponse(const std::string& body);
+    static Result<std::string> parseReleaseDate(const std::string& detailBody);
+    static bool shouldExcludeSetId(std::string_view setId) noexcept;
+    static std::string applySetNameOverride(std::string_view setId,
+                                            std::string nameJa);
+    static std::string rewriteReleaseDate(std::string_view isoDate);
+    static std::string buildSetDetailUrl(std::string_view setId);
+
+    // Original-era theme decks / sheets omitted by TCGdex JA. Idempotent by id.
+    static void appendMissingClassicProducts(std::vector<Set>& sets);
+
+private:
+    IHttpClient& http_;
+    const JapanesePokemonEnCatalog& catalog_;
+};
+
+}  // namespace ccm
@@ -1,6 +1,8 @@
 #pragma once

-// JsonSetRepository: persists vector<Set> to `<dataStorage>/<game>/sets.json`.
+// JsonSetRepository: persists vector<Set> under `<dataStorage>/<dirName>/`.
+// Most games use `sets.json`. Pokemon West/Asia share dir `pokemon` with
+// `sets-west.json` / `sets-asia.json` (migrate-on-load from legacy paths).

 #include "ccm/games/IGameModule.hpp"
 #include "ccm/ports/IFileSystem.hpp"
@@ -27,6 +29,8 @@ private:
    DirNameFn       dirName_;

    [[nodiscard]] std::filesystem::path setsPath(Game game) const;
+    [[nodiscard]] std::filesystem::path legacySetsPath(Game game) const;
+    [[nodiscard]] Result<std::vector<Set>> parseSetsText(const std::string& text) const;
 };

 }  // namespace ccm
@@ -1,6 +1,8 @@
 #pragma once

-// ISetRepository - persistence port for the cached `sets.json` of a game.
+// ISetRepository - persistence port for the cached set list of a game.
+// Typical layout: `<dataStorage>/<dirName>/sets.json`. Pokemon West/Asia use
+// `sets-west.json` / `sets-asia.json` under the shared `pokemon/` directory.
 // Stored as a flat list to mirror the original Rust file layout.

 #include "ccm/domain/Enums.hpp"
@@ -19,6 +19,8 @@
 //   * An empty filter matches every row, exactly as in JS where every string
 //     `.includes("")` returns true.

+#include "ccm/domain/DigiBattle99Card.hpp"
+#include "ccm/domain/JapanesePokemonCard.hpp"
 #include "ccm/domain/MagicCard.hpp"
 #include "ccm/domain/PokemonCard.hpp"
 #include "ccm/domain/YuGiOhCard.hpp"
@@ -34,11 +36,19 @@ namespace ccm {
                                      std::string_view filter);

 // Pokemon value-key columns from PokemonTable.tsx tableFields list:
-//   name, set.name, setNo, language, condition, amount, note.
+//   name, set.name, setNo, language, condition, amount, note, region.
 // Holo/FirstEdition/Signed/Altered are bool-typed and excluded.
 [[nodiscard]] bool matchesPokemonFilter(const PokemonCard& card,
                                        std::string_view filter);
 [[nodiscard]] bool matchesYuGiOhFilter(const YuGiOhCard& card,
                                       std::string_view filter);

+// Digi-Battle mirrors Pokemon searchable columns (includes setNo).
+[[nodiscard]] bool matchesDigiBattle99Filter(const DigiBattle99Card& card,
+                                             std::string_view filter);
+
+// Japanese Pokemon mirrors Pokemon searchable columns (includes setNo).
+[[nodiscard]] bool matchesJapanesePokemonFilter(const JapanesePokemonCard& card,
+                                                std::string_view filter);
+
 }  // namespace ccm
@@ -15,11 +15,13 @@
 #include "ccm/domain/Enums.hpp"
 #include "ccm/games/IGameModule.hpp"
 #include "ccm/ports/ICardPreviewSource.hpp"
+#include "ccm/ports/IFileSystem.hpp"
 #include "ccm/ports/IHttpClient.hpp"
 #include "ccm/ports/IPreviewByteCache.hpp"
 #include "ccm/util/Result.hpp"

 #include <cstddef>
+#include <filesystem>
 #include <list>
 #include <mutex>
 #include <string>
@@ -32,7 +34,9 @@ namespace ccm {
 class CardPreviewService {
 public:
    explicit CardPreviewService(IHttpClient& http,
-                                IPreviewByteCache* persistentCache = nullptr);
+                                IPreviewByteCache* persistentCache = nullptr,
+                                IFileSystem* fs = nullptr,
+                                std::filesystem::path assetRoot = {});

    // Register a game module's preview source. Calling this with a module
    // whose `cardPreviewSource()` returns nullptr is a no-op (the game has
@@ -96,6 +100,9 @@ private:

    Result<std::string> fetchAndCache(const std::string& cacheKey,
                                      std::string_view url);
+    Result<std::string, PreviewLookupError> fetchAssetAndCache(
+        const std::string& cacheKey,
+        std::string_view assetUrl);

    // Returns the kind of in-memory cache entry for `key`. On Hit the
    // payload is copied into `outPayload`; on NegativeHit `outPayload` is
@@ -107,6 +114,8 @@ private:

    IHttpClient&        http_;
    IPreviewByteCache*  persistentCache_{nullptr};
+    IFileSystem*        fs_{nullptr};
+    std::filesystem::path assetRoot_;
    std::unordered_map<Game, ICardPreviewSource*> sources_;

    // LRU: list holds entries in MRU-first order; map points at list nodes
@@ -16,6 +16,8 @@
 // UI relies on it so successive clicks on different columns compose predictably
 // (e.g. sort by name, then by set => grouped by set, name-sorted within each).

+#include "ccm/domain/DigiBattle99Card.hpp"
+#include "ccm/domain/JapanesePokemonCard.hpp"
 #include "ccm/domain/MagicCard.hpp"
 #include "ccm/domain/PokemonCard.hpp"
 #include "ccm/domain/YuGiOhCard.hpp"
@@ -66,6 +68,34 @@ enum class YuGiOhSortColumn {
    Note,
 };

+// Digi-Battle mirrors Pokemon columns (setNo is filter-only, not a sort column).
+enum class DigiBattle99SortColumn {
+    Name,
+    SetReleaseDate,
+    Language,
+    Condition,
+    Amount,
+    Holo,
+    FirstEdition,
+    Signed,
+    Altered,
+    Note,
+};
+
+// Japanese Pokemon mirrors Pokemon columns.
+enum class JapanesePokemonSortColumn {
+    Name,
+    SetReleaseDate,
+    Language,
+    Condition,
+    Amount,
+    Holo,
+    FirstEdition,
+    Signed,
+    Altered,
+    Note,
+};
+
 // Stable in-place sort. `ascending=false` runs the same comparator with
 // inverted sign, matching `byField(field, asc)` semantics.
 void sortMagicCards(std::vector<MagicCard>& cards, MagicSortColumn column,
@@ -74,5 +104,11 @@ void sortPokemonCards(std::vector<PokemonCard>& cards, PokemonSortColumn column,
                      bool ascending);
 void sortYuGiOhCards(std::vector<YuGiOhCard>& cards, YuGiOhSortColumn column,
                     bool ascending);
+void sortDigiBattle99Cards(std::vector<DigiBattle99Card>& cards,
+                           DigiBattle99SortColumn column,
+                           bool ascending);
+void sortJapanesePokemonCards(std::vector<JapanesePokemonCard>& cards,
+                              JapanesePokemonSortColumn column,
+                              bool ascending);

 }  // namespace ccm
@@ -13,6 +13,11 @@ void to_json(nlohmann::json& j, const Configuration& c) {
 void from_json(const nlohmann::json& j, Configuration& c) {
    j.at("dataStorage").get_to(c.dataStorage);
    j.at("defaultGame").get_to(c.defaultGame);
+    // JapanesePokemon was folded into Pokemon (West/Asia region). Coerce so
+    // older config.json files keep a valid user-facing default game.
+    if (c.defaultGame == Game::JapanesePokemon) {
+        c.defaultGame = Game::Pokemon;
+    }
    c.theme = j.value("theme", Theme::Light);
 }

@@ -0,0 +1,39 @@
+#include "ccm/domain/DigiBattle99Card.hpp"
+
+namespace ccm {
+
+void to_json(nlohmann::json& j, const DigiBattle99Card& c) {
+    j = nlohmann::json{
+        {"id",           c.id},
+        {"amount",       c.amount},
+        {"name",         c.name},
+        {"set",          c.set},
+        {"setNo",        c.setNo},
+        {"note",         c.note},
+        {"images",       c.images},
+        {"language",     c.language},
+        {"condition",    c.condition},
+        {"firstEdition", c.firstEdition},
+        {"holo",         c.holo},
+        {"signed",       c.signed_},
+        {"altered",      c.altered},
+    };
+}
+
+void from_json(const nlohmann::json& j, DigiBattle99Card& c) {
+    j.at("id").get_to(c.id);
+    j.at("amount").get_to(c.amount);
+    j.at("name").get_to(c.name);
+    j.at("set").get_to(c.set);
+    j.at("setNo").get_to(c.setNo);
+    j.at("note").get_to(c.note);
+    j.at("images").get_to(c.images);
+    j.at("language").get_to(c.language);
+    j.at("condition").get_to(c.condition);
+    j.at("firstEdition").get_to(c.firstEdition);
+    j.at("holo").get_to(c.holo);
+    j.at("signed").get_to(c.signed_);
+    j.at("altered").get_to(c.altered);
+}
+
+}  // namespace ccm
@@ -13,23 +13,35 @@ namespace ccm {

 std::string_view to_string(Game g) noexcept {
    switch (g) {
-        case Game::Magic:   return "Magic";
-        case Game::Pokemon: return "Pokemon";
-        case Game::YuGiOh:  return "YuGiOh";
+        case Game::Magic:            return "Magic";
+        case Game::Pokemon:          return "Pokemon";
+        case Game::YuGiOh:           return "YuGiOh";
+        case Game::DigiBattle99:     return "DigiBattle99";
+        case Game::JapanesePokemon:  return "JapanesePokemon";
+    }
+    CCM_UNREACHABLE();
+}
+
+std::string_view to_string(PokemonRegion r) noexcept {
+    switch (r) {
+        case PokemonRegion::West: return "West";
+        case PokemonRegion::Asia: return "Asia";
    }
    CCM_UNREACHABLE();
 }

 std::string_view to_string(Language l) noexcept {
    switch (l) {
-        case Language::English:  return "English";
-        case Language::German:   return "German";
-        case Language::French:   return "French";
-        case Language::Spanish:  return "Spanish";
-        case Language::Italian:  return "Italian";
-        case Language::Chinese:  return "Chinese";
-        case Language::Japanese: return "Japanese";
-        case Language::Russian:  return "Russian";
+        case Language::English:            return "English";
+        case Language::German:             return "German";
+        case Language::French:             return "French";
+        case Language::Spanish:            return "Spanish";
+        case Language::Italian:            return "Italian";
+        case Language::SimplifiedChinese:  return "S-Chinese";
+        case Language::TraditionalChinese: return "T-Chinese";
+        case Language::Japanese:           return "Japanese";
+        case Language::Korean:             return "Korean";
+        case Language::Russian:            return "Russian";
    }
    CCM_UNREACHABLE();
 }
@@ -56,21 +68,33 @@ std::string_view to_string(Theme t) noexcept {
 }

 std::optional<Game> gameFromString(std::string_view s) noexcept {
-    if (s == "Magic")   return Game::Magic;
-    if (s == "Pokemon") return Game::Pokemon;
-    if (s == "YuGiOh")  return Game::YuGiOh;
+    if (s == "Magic")           return Game::Magic;
+    if (s == "Pokemon")         return Game::Pokemon;
+    if (s == "YuGiOh")          return Game::YuGiOh;
+    if (s == "DigiBattle99")    return Game::DigiBattle99;
+    if (s == "JapanesePokemon") return Game::JapanesePokemon;
+    return std::nullopt;
+}
+
+std::optional<PokemonRegion> pokemonRegionFromString(std::string_view s) noexcept {
+    if (s == "West") return PokemonRegion::West;
+    if (s == "Asia") return PokemonRegion::Asia;
    return std::nullopt;
 }

 std::optional<Language> languageFromString(std::string_view s) noexcept {
-    if (s == "English")  return Language::English;
-    if (s == "German")   return Language::German;
-    if (s == "French")   return Language::French;
-    if (s == "Spanish")  return Language::Spanish;
-    if (s == "Italian")  return Language::Italian;
-    if (s == "Chinese")  return Language::Chinese;
-    if (s == "Japanese") return Language::Japanese;
-    if (s == "Russian")  return Language::Russian;
+    if (s == "English")            return Language::English;
+    if (s == "German")             return Language::German;
+    if (s == "French")             return Language::French;
+    if (s == "Spanish")            return Language::Spanish;
+    if (s == "Italian")            return Language::Italian;
+    if (s == "S-Chinese")          return Language::SimplifiedChinese;
+    if (s == "T-Chinese")          return Language::TraditionalChinese;
+    // Legacy single Chinese spelling → Simplified.
+    if (s == "Chinese")            return Language::SimplifiedChinese;
+    if (s == "Japanese")           return Language::Japanese;
+    if (s == "Korean")             return Language::Korean;
+    if (s == "Russian")            return Language::Russian;
    return std::nullopt;
 }

@@ -91,15 +115,17 @@ std::optional<Theme> themeFromString(std::string_view s) noexcept {
    return std::nullopt;
 }

-const std::array<Game, 3>& allGames() noexcept {
-    static constexpr std::array<Game, 3> v{Game::Magic, Game::Pokemon, Game::YuGiOh};
+const std::array<Game, 4>& allGames() noexcept {
+    static constexpr std::array<Game, 4> v{
+        Game::Magic, Game::Pokemon, Game::YuGiOh, Game::DigiBattle99};
    return v;
 }

-const std::array<Language, 8>& allLanguages() noexcept {
-    static constexpr std::array<Language, 8> v{
+const std::array<Language, 10>& allLanguages() noexcept {
+    static constexpr std::array<Language, 10> v{
        Language::English, Language::German, Language::French, Language::Spanish,
-        Language::Italian, Language::Chinese, Language::Japanese, Language::Russian
+        Language::Italian, Language::SimplifiedChinese, Language::TraditionalChinese,
+        Language::Japanese, Language::Korean, Language::Russian
    };
    return v;
 }
@@ -117,16 +143,45 @@ const std::array<Theme, 2>& allThemes() noexcept {
    return v;
 }

-void to_json(nlohmann::json& j, Game v)      { j = std::string(to_string(v)); }
-void to_json(nlohmann::json& j, Language v)  { j = std::string(to_string(v)); }
-void to_json(nlohmann::json& j, Condition v) { j = std::string(to_string(v)); }
-void to_json(nlohmann::json& j, Theme v)     { j = std::string(to_string(v)); }
+std::span<const Language> languagesForPokemonRegion(PokemonRegion r) noexcept {
+    static constexpr std::array<Language, 6> kWest{
+        Language::English, Language::German, Language::French,
+        Language::Spanish, Language::Italian, Language::Russian};
+    static constexpr std::array<Language, 4> kAsia{
+        Language::Japanese, Language::SimplifiedChinese,
+        Language::TraditionalChinese, Language::Korean};
+    switch (r) {
+        case PokemonRegion::West: return kWest;
+        case PokemonRegion::Asia: return kAsia;
+    }
+    CCM_UNREACHABLE();
+    return kWest;
+}
+
+Game pokemonBackendGame(PokemonRegion r) noexcept {
+    return r == PokemonRegion::Asia ? Game::JapanesePokemon : Game::Pokemon;
+}
+
+Language defaultLanguageForPokemonRegion(PokemonRegion r) noexcept {
+    return r == PokemonRegion::Asia ? Language::Japanese : Language::English;
+}
+
+void to_json(nlohmann::json& j, Game v)           { j = std::string(to_string(v)); }
+void to_json(nlohmann::json& j, PokemonRegion v)  { j = std::string(to_string(v)); }
+void to_json(nlohmann::json& j, Language v)       { j = std::string(to_string(v)); }
+void to_json(nlohmann::json& j, Condition v)      { j = std::string(to_string(v)); }
+void to_json(nlohmann::json& j, Theme v)          { j = std::string(to_string(v)); }

 void from_json(const nlohmann::json& j, Game& v) {
    auto parsed = gameFromString(j.get<std::string>());
    if (!parsed) throw std::invalid_argument("Unknown Game value: " + j.get<std::string>());
    v = *parsed;
 }
+void from_json(const nlohmann::json& j, PokemonRegion& v) {
+    auto parsed = pokemonRegionFromString(j.get<std::string>());
+    if (!parsed) throw std::invalid_argument("Unknown PokemonRegion value: " + j.get<std::string>());
+    v = *parsed;
+}
 void from_json(const nlohmann::json& j, Language& v) {
    auto parsed = languageFromString(j.get<std::string>());
    if (!parsed) throw std::invalid_argument("Unknown Language value: " + j.get<std::string>());
@@ -0,0 +1,39 @@
+#include "ccm/domain/JapanesePokemonCard.hpp"
+
+namespace ccm {
+
+void to_json(nlohmann::json& j, const JapanesePokemonCard& c) {
+    j = nlohmann::json{
+        {"id",           c.id},
+        {"amount",       c.amount},
+        {"name",         c.name},
+        {"set",          c.set},
+        {"setNo",        c.setNo},
+        {"note",         c.note},
+        {"images",       c.images},
+        {"language",     c.language},
+        {"condition",    c.condition},
+        {"firstEdition", c.firstEdition},
+        {"holo",         c.holo},
+        {"signed",       c.signed_},
+        {"altered",      c.altered},
+    };
+}
+
+void from_json(const nlohmann::json& j, JapanesePokemonCard& c) {
+    j.at("id").get_to(c.id);
+    j.at("amount").get_to(c.amount);
+    j.at("name").get_to(c.name);
+    j.at("set").get_to(c.set);
+    j.at("setNo").get_to(c.setNo);
+    j.at("note").get_to(c.note);
+    j.at("images").get_to(c.images);
+    j.at("language").get_to(c.language);
+    j.at("condition").get_to(c.condition);
+    j.at("firstEdition").get_to(c.firstEdition);
+    j.at("holo").get_to(c.holo);
+    j.at("signed").get_to(c.signed_);
+    j.at("altered").get_to(c.altered);
+}
+
+}  // namespace ccm
@@ -17,6 +17,7 @@ void to_json(nlohmann::json& j, const PokemonCard& c) {
        {"holo",         c.holo},
        {"signed",       c.signed_},
        {"altered",      c.altered},
+        {"region",       c.region},
    };
 }

@@ -34,6 +35,8 @@ void from_json(const nlohmann::json& j, PokemonCard& c) {
    j.at("holo").get_to(c.holo);
    j.at("signed").get_to(c.signed_);
    j.at("altered").get_to(c.altered);
+    // Missing `region` defaults to West so pre-merge West-only files still load.
+    c.region = j.value("region", PokemonRegion::West);
 }

 }  // namespace ccm
@@ -0,0 +1,222 @@
+#include "ccm/games/digibattle99/DigiBattle99CardPreviewSource.hpp"
+
+#include "ccm/util/Rfc3986.hpp"
+
+#include <nlohmann/json.hpp>
+
+#include <cctype>
+#include <string>
+#include <unordered_set>
+#include <vector>
+
+namespace ccm {
+
+namespace {
+
+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();
+    return s;
+}
+
+std::string toLower(std::string s) {
+    for (char& ch : s) {
+        ch = static_cast<char>(std::tolower(static_cast<unsigned char>(ch)));
+    }
+    return s;
+}
+
+bool cardInPack(const nlohmann::json& card, std::string_view packName) {
+    if (packName.empty()) return true;
+    if (!card.contains("set_name") || !card.at("set_name").is_array()) return false;
+    for (const auto& pack : card.at("set_name")) {
+        if (pack.is_string() && pack.get<std::string>() == packName) return true;
+    }
+    return false;
+}
+
+}  // namespace
+
+DigiBattle99CardPreviewSource::DigiBattle99CardPreviewSource(IHttpClient& http)
+    : http_(http) {}
+
+std::string DigiBattle99CardPreviewSource::normalizeCardNumber(std::string_view setNo) {
+    std::string s = trim(std::string(setNo));
+    if (s.empty()) return s;
+    // Uppercase leading alphabetic prefix (ST / BO / MO / Fx-style).
+    std::size_t i = 0;
+    while (i < s.size() && std::isalpha(static_cast<unsigned char>(s[i]))) {
+        s[i] = static_cast<char>(std::toupper(static_cast<unsigned char>(s[i])));
+        ++i;
+    }
+    return s;
+}
+
+std::string DigiBattle99CardPreviewSource::buildImageUrl(std::string_view setNo) {
+    const std::string id = normalizeCardNumber(setNo);
+    return std::string(kImageBase) + id + ".jpg";
+}
+
+std::string DigiBattle99CardPreviewSource::buildSearchUrl(std::string_view name,
+                                                          std::string_view setName,
+                                                          std::string_view setNo) {
+    std::string url = "https://digimoncard.io/api-public/search.php?series=";
+    url += rfc3986PercentEncode(kSeries);
+    if (!name.empty()) {
+        url += "&n=";
+        url += rfc3986PercentEncode(name);
+    }
+    if (!setName.empty()) {
+        url += "&pack=";
+        url += rfc3986PercentEncode(setName);
+    }
+    const std::string num = normalizeCardNumber(setNo);
+    if (!num.empty()) {
+        url += "&card=";
+        url += rfc3986PercentEncode(num);
+    }
+    url += "&sort=name&sortdirection=asc";
+    return url;
+}
+
+Result<std::string, PreviewLookupError>
+DigiBattle99CardPreviewSource::parseImageUrlFromSearch(const std::string& body,
+                                                       std::string_view wantedCardName) {
+    using R = Result<std::string, PreviewLookupError>;
+    using K = PreviewLookupError::Kind;
+    try {
+        const auto j = nlohmann::json::parse(body);
+        if (j.is_object() && j.contains("error")) {
+            return R::err({K::NotFound, j.value("error", std::string{"No cards found."})});
+        }
+        if (!j.is_array()) {
+            return R::err({K::Transient, "digimoncard.io Digi-Battle response is not a JSON array."});
+        }
+        if (j.empty()) {
+            return R::err({K::NotFound, "digimoncard.io returned no matching Digi-Battle cards."});
+        }
+
+        const std::string wantedLower = toLower(trim(std::string(wantedCardName)));
+        const nlohmann::json* chosen = nullptr;
+        for (const auto& card : j) {
+            if (!wantedLower.empty()) {
+                const std::string cardName = trim(card.value("name", ""));
+                if (toLower(cardName) != wantedLower) continue;
+            }
+            chosen = &card;
+            break;
+        }
+        if (chosen == nullptr) {
+            return R::err({K::NotFound, "digimoncard.io returned no matching Digi-Battle cards."});
+        }
+        const std::string id = normalizeCardNumber(chosen->value("id", ""));
+        if (id.empty()) {
+            return R::err({K::NotFound, "Digi-Battle card has no id / card number."});
+        }
+        return R::ok(buildImageUrl(id));
+    } catch (const std::exception& e) {
+        return R::err({K::Transient,
+            std::string("digimoncard.io Digi-Battle JSON parse error: ") + e.what()});
+    }
+}
+
+Result<std::string, PreviewLookupError>
+DigiBattle99CardPreviewSource::fetchImageUrl(std::string_view name,
+                                             std::string_view setName,
+                                             std::string_view setNo) {
+    using R = Result<std::string, PreviewLookupError>;
+    using K = PreviewLookupError::Kind;
+
+    const std::string num = normalizeCardNumber(setNo);
+    if (!num.empty()) {
+        return R::ok(buildImageUrl(num));
+    }
+    if (name.empty()) {
+        return R::err({K::NotFound, "Digi-Battle preview requires a card name or set number."});
+    }
+
+    const std::string url = buildSearchUrl(name, setName, "");
+    auto resp = http_.get(url);
+    if (!resp) return R::err({K::Transient, resp.error()});
+    return parseImageUrlFromSearch(resp.value(), name);
+}
+
+Result<std::vector<AutoDetectedPrint>> DigiBattle99CardPreviewSource::parsePrintVariants(
+    const std::string& body,
+    std::string_view setName,
+    std::string_view wantedCardName) {
+    using R = Result<std::vector<AutoDetectedPrint>>;
+    try {
+        const auto j = nlohmann::json::parse(body);
+        if (j.is_object() && j.contains("error")) {
+            return R::err(j.value("error", std::string{"No cards found."}));
+        }
+        if (!j.is_array() || j.empty()) {
+            return R::err("digimoncard.io returned no matching Digi-Battle cards.");
+        }
+
+        const std::string wantedPack = trim(std::string(setName));
+        const std::string wantedNameLower = toLower(trim(std::string(wantedCardName)));
+
+        std::vector<AutoDetectedPrint> collected;
+        for (const auto& card : j) {
+            if (!wantedNameLower.empty()) {
+                const std::string cardName = trim(card.value("name", ""));
+                if (toLower(cardName) != wantedNameLower) continue;
+            }
+            if (!cardInPack(card, wantedPack)) continue;
+            AutoDetectedPrint out;
+            out.setNo = normalizeCardNumber(card.value("id", ""));
+            out.rarity = "";  // Digi-Battle UI is Pokémon-like; rarity not persisted.
+            if (out.setNo.empty()) continue;
+            collected.push_back(std::move(out));
+        }
+
+        if (collected.empty()) {
+            if (!wantedNameLower.empty() && !wantedPack.empty()) {
+                return R::err("Could not auto-detect Digi-Battle set print metadata.");
+            }
+            return R::err("digimoncard.io returned no matching Digi-Battle cards.");
+        }
+
+        std::vector<AutoDetectedPrint> deduped;
+        deduped.reserve(collected.size());
+        std::unordered_set<std::string> seen;
+        seen.reserve(collected.size() * 2);
+        for (auto& p : collected) {
+            if (seen.insert(p.setNo).second) deduped.push_back(std::move(p));
+        }
+        return R::ok(std::move(deduped));
+    } catch (const std::exception& e) {
+        return R::err(std::string("digimoncard.io Digi-Battle JSON parse error: ") + e.what());
+    }
+}
+
+Result<AutoDetectedPrint> DigiBattle99CardPreviewSource::detectFirstPrint(
+    std::string_view name,
+    std::string_view setName) {
+    auto list = detectPrintVariants(name, setName);
+    if (!list || list.value().empty()) {
+        if (!list) return Result<AutoDetectedPrint>::err(list.error());
+        return Result<AutoDetectedPrint>::err("Could not auto-detect Digi-Battle set print metadata.");
+    }
+    return Result<AutoDetectedPrint>::ok(list.value().front());
+}
+
+Result<std::vector<AutoDetectedPrint>> DigiBattle99CardPreviewSource::detectPrintVariants(
+    std::string_view name,
+    std::string_view setName) {
+    using R = Result<std::vector<AutoDetectedPrint>>;
+    const std::string url = buildSearchUrl(name, setName, "");
+    auto resp = http_.get(url);
+    if (resp) {
+        return parsePrintVariants(resp.value(), setName, name);
+    }
+    // Retry name-only; still filter by pack in parsePrintVariants.
+    const std::string fallbackUrl = buildSearchUrl(name, "", "");
+    auto fallback = http_.get(fallbackUrl);
+    if (!fallback) return R::err(fallback.error());
+    return parsePrintVariants(fallback.value(), setName, name);
+}
+
+}  // namespace ccm
@@ -0,0 +1,8 @@
+#include "ccm/games/digibattle99/DigiBattle99GameModule.hpp"
+
+namespace ccm {
+
+DigiBattle99GameModule::DigiBattle99GameModule(IHttpClient& http)
+    : setSource_(http), previewSource_(http) {}
+
+}  // namespace ccm
@@ -0,0 +1,119 @@
+#include "ccm/games/digibattle99/DigiBattle99SetSource.hpp"
+
+#include <nlohmann/json.hpp>
+
+#include <algorithm>
+#include <cctype>
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
+
+namespace ccm {
+
+namespace {
+
+// Curated EN release dates for the vintage Digi-Battle product line.
+// Series 1 Starter is verified 1999-06-01; other entries use digimoncard.io /
+// checklist years (day unknown -> YYYY/01/01 or mid-year anchors for ordering).
+const std::unordered_map<std::string, std::string>& curatedReleaseDates() {
+    static const std::unordered_map<std::string, std::string> kDates{
+        {"Series 1 Starter Set", "1999/06/01"},
+        {"Series 1 Booster Pack", "1999/06/01"},
+        {"Series 2 Booster Pack", "1999/09/01"},
+        {"Series 3 Booster Pack", "2000/01/01"},
+        {"Series 4 Booster Pack", "2000/06/01"},
+        {"Series 5 Booster Pack", "2000/10/01"},
+        {"Series 6 Booster Pack", "2001/01/01"},
+        {"Street Starter Set 1", "2001/01/01"},
+        {"Street Starter Set 2", "2001/02/01"},
+        {"Street Starter Set 3", "2001/03/01"},
+        {"Street Starter Set 4", "2001/04/01"},
+        {"Digimon The Movie Promo Cards", "2000/10/01"},
+    };
+    return kDates;
+}
+
+std::string releaseDateForPack(const std::string& packName) {
+    const auto& dates = curatedReleaseDates();
+    const auto it = dates.find(packName);
+    if (it != dates.end()) return it->second;
+    return {};
+}
+
+}  // namespace
+
+DigiBattle99SetSource::DigiBattle99SetSource(IHttpClient& http) : http_(http) {}
+
+std::string DigiBattle99SetSource::slugifyPackName(std::string_view packName) {
+    std::string out;
+    out.reserve(packName.size());
+    bool pendingHyphen = false;
+    for (unsigned char ch : packName) {
+        if (std::isalnum(ch)) {
+            if (pendingHyphen && !out.empty()) out.push_back('-');
+            pendingHyphen = false;
+            out.push_back(static_cast<char>(std::tolower(ch)));
+        } else {
+            pendingHyphen = !out.empty();
+        }
+    }
+    return out;
+}
+
+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.");
+        }
+
+        // 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);
+            }
+        }
+
+        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());
+    }
+}
+
+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());
+}
+
+}  // namespace ccm
@@ -0,0 +1,442 @@
+#include "ccm/games/pokemonjp/JapanesePokemonCardPreviewSource.hpp"
+
+#include "ccm/util/Rfc3986.hpp"
+
+#include <nlohmann/json.hpp>
+
+#include <cctype>
+#include <string>
+#include <unordered_set>
+
+namespace ccm {
+
+namespace {
+
+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();
+    }
+    return s;
+}
+
+std::string asciiLower(std::string s) {
+    for (char& ch : s) {
+        ch = static_cast<char>(std::tolower(static_cast<unsigned char>(ch)));
+    }
+    return s;
+}
+
+std::string stripLeadingZeros(std::string_view s) {
+    std::size_t i = 0;
+    while (i + 1 < s.size() && s[i] == '0') ++i;
+    return std::string(s.substr(i));
+}
+
+bool localIdsMatch(std::string_view a, std::string_view b) {
+    if (a == b) return true;
+    return stripLeadingZeros(a) == stripLeadingZeros(b);
+}
+
+bool catalogPrintMatchesRow(const JapanesePokemonPrintEnInfo& print,
+                            const JapanesePokemonCardPreviewSource::SetCardRow& row) {
+    // Reject stale catalog rows whose Japanese name disagrees with TCGdex.
+    // Seed data historically mapped Charmander→001 / Charizard→004; those
+    // localIds are Bulbasaur / Weedle on PMCG1.
+    if (print.nameJa.empty()) return true;
+    return asciiLower(print.nameJa) == asciiLower(row.nameJa);
+}
+
+bool nameMatchesRow(std::string_view wantedLower,
+                    const JapanesePokemonCardPreviewSource::SetCardRow& row,
+                    std::string_view setId,
+                    const JapanesePokemonEnCatalog& catalog) {
+    if (wantedLower.empty()) return true;
+    if (asciiLower(row.nameJa) == wantedLower) return true;
+    if (auto print = catalog.findPrint(setId, row.localId)) {
+        if (!catalogPrintMatchesRow(*print, row)) return false;
+        if (asciiLower(print->nameEn) == wantedLower) return true;
+        if (asciiLower(print->nameJa) == wantedLower) return true;
+    }
+    return false;
+}
+
+}  // namespace
+
+JapanesePokemonCardPreviewSource::JapanesePokemonCardPreviewSource(
+    IHttpClient& http, const JapanesePokemonEnCatalog& catalog)
+    : http_(http), catalog_(catalog) {}
+
+std::string JapanesePokemonCardPreviewSource::normalizeLocalId(std::string_view setNo) {
+    std::string s = trim(std::string(setNo));
+    const auto slash = s.find('/');
+    if (slash != std::string::npos) s.erase(slash);
+    return s;
+}
+
+std::string JapanesePokemonCardPreviewSource::buildSetDetailUrl(std::string_view setId) {
+    return std::string("https://api.tcgdex.net/v2/ja/sets/") +
+           rfc3986PercentEncode(setId);
+}
+
+std::string JapanesePokemonCardPreviewSource::buildCardUrl(std::string_view setId,
+                                                           std::string_view localId) {
+    std::string id = std::string(setId) + "-" + std::string(localId);
+    return std::string("https://api.tcgdex.net/v2/ja/cards/") +
+           rfc3986PercentEncode(id);
+}
+
+std::string JapanesePokemonCardPreviewSource::imageUrlFromBase(std::string_view imageBase) {
+    if (imageBase.empty()) return {};
+    std::string url(imageBase);
+    while (!url.empty() && (url.back() == '/' || url.back() == ' ')) url.pop_back();
+    return url + "/high.png";
+}
+
+Result<std::vector<JapanesePokemonCardPreviewSource::SetCardRow>, PreviewLookupError>
+JapanesePokemonCardPreviewSource::parseSetCards(const std::string& body) {
+    using R = Result<std::vector<SetCardRow>, PreviewLookupError>;
+    using K = PreviewLookupError::Kind;
+    try {
+        const auto j = nlohmann::json::parse(body);
+        if (!j.is_object() || !j.contains("cards") || !j.at("cards").is_array()) {
+            return R::err({K::Transient,
+                           "TCGdex JA set detail missing 'cards' array."});
+        }
+        std::vector<SetCardRow> out;
+        out.reserve(j.at("cards").size());
+        for (const auto& card : j.at("cards")) {
+            SetCardRow row;
+            row.localId = card.value("localId", "");
+            if (row.localId.empty() && card.contains("id") && card.at("id").is_string()) {
+                // Fallback: take suffix after last '-' from card id.
+                const std::string id = card.at("id").get<std::string>();
+                const auto dash = id.rfind('-');
+                if (dash != std::string::npos) row.localId = id.substr(dash + 1);
+            }
+            row.nameJa = card.value("name", "");
+            row.rarity = card.value("rarity", "");
+            if (card.contains("image") && card.at("image").is_string()) {
+                row.imageBase = card.at("image").get<std::string>();
+            }
+            if (row.localId.empty()) continue;
+            out.push_back(std::move(row));
+        }
+        return R::ok(std::move(out));
+    } catch (const std::exception& e) {
+        return R::err({K::Transient,
+                       std::string("TCGdex JA set detail JSON parse error: ") + e.what()});
+    }
+}
+
+Result<std::string, PreviewLookupError>
+JapanesePokemonCardPreviewSource::parseCardImageUrl(const std::string& body) {
+    using R = Result<std::string, PreviewLookupError>;
+    using K = PreviewLookupError::Kind;
+    try {
+        const auto j = nlohmann::json::parse(body);
+        if (!j.is_object()) {
+            return R::err({K::Transient, "TCGdex JA card response is not a JSON object."});
+        }
+        if (!j.contains("image") || j.at("image").is_null()) {
+            return R::err({K::NotFound, "TCGdex JA card has no image."});
+        }
+        if (!j.at("image").is_string()) {
+            return R::err({K::Transient, "TCGdex JA card image field is not a string."});
+        }
+        const std::string base = j.at("image").get<std::string>();
+        if (base.empty()) {
+            return R::err({K::NotFound, "TCGdex JA card has no image."});
+        }
+        return R::ok(imageUrlFromBase(base));
+    } catch (const std::exception& e) {
+        return R::err({K::Transient,
+                       std::string("TCGdex JA card JSON parse error: ") + e.what()});
+    }
+}
+
+Result<std::vector<AutoDetectedPrint>>
+JapanesePokemonCardPreviewSource::parsePrintVariants(
+    const std::string& body,
+    std::string_view setId,
+    std::string_view wantedCardName,
+    const JapanesePokemonEnCatalog& catalog) {
+    using R = Result<std::vector<AutoDetectedPrint>>;
+    auto rows = parseSetCards(body);
+    if (!rows) {
+        return R::err(rows.error().message);
+    }
+
+    const std::string wantedLower = asciiLower(trim(std::string(wantedCardName)));
+    std::vector<AutoDetectedPrint> out;
+    std::unordered_set<std::string> seen;
+    std::unordered_set<std::string> seenCatalogUrls;
+
+    // Prefer catalog EN matches first so typed English names resolve — but
+    // only when the catalog localId exists in the set and name_ja agrees
+    // with TCGdex (guards against stale seed mappings).
+    std::vector<AutoDetectedPrint> withPreview;
+    std::vector<AutoDetectedPrint> withoutPreview;
+    if (!wantedLower.empty()) {
+        for (const auto& p : catalog.findPrintsByName(setId, wantedCardName)) {
+            const SetCardRow* row = nullptr;
+            for (const auto& r : rows.value()) {
+                if (localIdsMatch(r.localId, p.localId)) {
+                    row = &r;
+                    break;
+                }
+            }
+            const std::string previewUrl =
+                JapanesePokemonEnCatalog::previewImageUrlFromPrint(p);
+            if (row == nullptr) {
+                // Set detail sometimes omits cards[]; keep catalog-only hits
+                // (UnnumberedPromo). Dedupe only among non-empty preview URLs
+                // so empty-image prints still appear in the Next ring.
+                if (!rows.value().empty()) continue;
+                if (!previewUrl.empty() &&
+                    !seenCatalogUrls.insert(previewUrl).second) {
+                    continue;
+                }
+            } else if (!catalogPrintMatchesRow(p, *row)) {
+                continue;
+            }
+            if (!seen.insert(p.localId).second) continue;
+            AutoDetectedPrint print;
+            print.setNo = p.localId;
+            if (row != nullptr) print.rarity = row->rarity;
+            if (previewUrl.empty()) {
+                withoutPreview.push_back(std::move(print));
+            } else {
+                withPreview.push_back(std::move(print));
+            }
+        }
+    }
+
+    for (auto& print : withPreview) out.push_back(std::move(print));
+    for (auto& print : withoutPreview) out.push_back(std::move(print));
+
+    for (const auto& row : rows.value()) {
+        if (!nameMatchesRow(wantedLower, row, setId, catalog)) continue;
+        if (!seen.insert(row.localId).second) continue;
+        AutoDetectedPrint print;
+        print.setNo = row.localId;
+        print.rarity = row.rarity;
+        out.push_back(std::move(print));
+    }
+
+    if (out.empty() && !wantedLower.empty()) {
+        return R::err("No matching Japanese Pokemon prints for that name in the set.");
+    }
+    return R::ok(std::move(out));
+}
+
+Result<std::vector<AutoDetectedPrint>>
+JapanesePokemonCardPreviewSource::detectPrintVariantsFromCatalog(
+    std::string_view setId,
+    std::string_view wantedCardName,
+    const JapanesePokemonEnCatalog& catalog) {
+    using R = Result<std::vector<AutoDetectedPrint>>;
+    if (!catalog.hasPrintsForSet(setId)) {
+        return R::err("No matching Japanese Pokemon prints for that name in the set.");
+    }
+    const std::string wantedLower = asciiLower(trim(std::string(wantedCardName)));
+    std::vector<AutoDetectedPrint> out;
+    std::unordered_set<std::string> seen;
+    std::unordered_set<std::string> seenUrls;
+    if (wantedLower.empty()) {
+        return R::ok(std::move(out));
+    }
+    std::vector<AutoDetectedPrint> withPreview;
+    std::vector<AutoDetectedPrint> withoutPreview;
+    for (const auto& p : catalog.findPrintsByName(setId, wantedCardName)) {
+        if (!seen.insert(p.localId).second) continue;
+        // Dedupe only among non-empty preview URLs so identical art is not
+        // cycled; empty-image prints still join the Next ring (card-back).
+        // Emit imaged prints first so Auto-detect lands on real art.
+        const std::string previewUrl =
+            JapanesePokemonEnCatalog::previewImageUrlFromPrint(p);
+        if (!previewUrl.empty() && !seenUrls.insert(previewUrl).second) {
+            continue;
+        }
+        AutoDetectedPrint print;
+        print.setNo = p.localId;
+        if (previewUrl.empty()) {
+            withoutPreview.push_back(std::move(print));
+        } else {
+            withPreview.push_back(std::move(print));
+        }
+    }
+    for (auto& print : withPreview) out.push_back(std::move(print));
+    for (auto& print : withoutPreview) out.push_back(std::move(print));
+    if (out.empty()) {
+        return R::err("No matching Japanese Pokemon prints for that name in the set.");
+    }
+    return R::ok(std::move(out));
+}
+
+Result<std::string, PreviewLookupError>
+JapanesePokemonCardPreviewSource::fetchImageUrl(std::string_view name,
+                                                std::string_view setId,
+                                                std::string_view setNo) {
+    using R = Result<std::string, PreviewLookupError>;
+    using K = PreviewLookupError::Kind;
+
+    const std::string localId = normalizeLocalId(setNo);
+    if (setId.empty()) {
+        return R::err({K::NotFound, "Japanese Pokemon preview requires a set id."});
+    }
+
+    auto catalogPreviewFor = [&](std::string_view lid) -> Result<std::string, PreviewLookupError> {
+        if (lid.empty()) return R::err({K::NotFound, "No catalog preview for print."});
+        if (auto print = catalog_.findPrint(setId, lid)) {
+            const std::string catalogUrl =
+                JapanesePokemonEnCatalog::previewImageUrlFromPrint(*print);
+            if (!catalogUrl.empty()) return R::ok(catalogUrl);
+        }
+        return R::err({K::NotFound, "TCGdex JA card has no image."});
+    };
+
+    // Prefer direct card fetch when we have a localId.
+    if (!localId.empty()) {
+        auto cardResp = http_.get(buildCardUrl(setId, localId));
+        if (cardResp) {
+            auto img = parseCardImageUrl(cardResp.value());
+            if (img) return img;
+            // NotFound from card object: fall through to set list / catalog.
+            if (img.error().kind == K::Transient) return img;
+        } else {
+            // Synthetic / classic products: try catalog gap-fill before set detail.
+            auto catalogImg = catalogPreviewFor(localId);
+            if (catalogImg) return catalogImg;
+            // Known catalog print with no preview URL: honest miss (do not
+            // borrow a sibling print's art via name match).
+            if (catalog_.findPrint(setId, localId)) {
+                return R::err({K::NotFound, "TCGdex JA card has no image."});
+            }
+        }
+    }
+
+    auto setResp = http_.get(buildSetDetailUrl(setId));
+    if (!setResp) {
+        // Catalog-only products (City Gym theme decks, etc.) are not on TCGdex.
+        if (!localId.empty()) {
+            auto catalogImg = catalogPreviewFor(localId);
+            if (catalogImg) return catalogImg;
+            if (catalog_.findPrint(setId, localId)) {
+                return R::err({K::NotFound, "TCGdex JA card has no image."});
+            }
+            // Network failure and no catalog entry: Transient so a brief outage
+            // is not negative-cached as a permanent miss.
+            return R::err({K::Transient, setResp.error()});
+        }
+        if (catalog_.hasPrintsForSet(setId)) {
+            const std::string wantedLower = asciiLower(trim(std::string(name)));
+            if (!wantedLower.empty()) {
+                for (const auto& p : catalog_.findPrintsByName(setId, name)) {
+                    auto catalogImg = catalogPreviewFor(p.localId);
+                    if (catalogImg) return catalogImg;
+                }
+            }
+            return R::err({K::NotFound, "No matching Japanese Pokemon card for preview."});
+        }
+        return R::err({K::Transient, setResp.error()});
+    }
+    auto rows = parseSetCards(setResp.value());
+    if (!rows) return R::err(rows.error());
+
+    const std::string wantedLower = asciiLower(trim(std::string(name)));
+    const SetCardRow* chosen = nullptr;
+    for (const auto& row : rows.value()) {
+        if (!localId.empty() && localIdsMatch(row.localId, localId)) {
+            chosen = &row;
+            break;
+        }
+    }
+    // Name match only when setNo was not provided — never borrow a sibling
+    // print's art for a concrete localId.
+    if (chosen == nullptr && localId.empty() && !wantedLower.empty()) {
+        for (const auto& row : rows.value()) {
+            if (nameMatchesRow(wantedLower, row, setId, catalog_)) {
+                chosen = &row;
+                break;
+            }
+        }
+    }
+    if (chosen == nullptr) {
+        // Empty cards[] with catalog prints: resolve from catalog.
+        if (rows.value().empty() && catalog_.hasPrintsForSet(setId)) {
+            if (!localId.empty()) {
+                auto catalogImg = catalogPreviewFor(localId);
+                if (catalogImg) return catalogImg;
+                if (catalog_.findPrint(setId, localId)) {
+                    return R::err({K::NotFound, "TCGdex JA card has no image."});
+                }
+                return R::err({K::NotFound, "No matching Japanese Pokemon card for preview."});
+            }
+            if (!wantedLower.empty()) {
+                for (const auto& p : catalog_.findPrintsByName(setId, name)) {
+                    auto catalogImg = catalogPreviewFor(p.localId);
+                    if (catalogImg) return catalogImg;
+                }
+            }
+        }
+        return R::err({K::NotFound, "No matching Japanese Pokemon card for preview."});
+    }
+    if (!chosen->imageBase.empty()) {
+        return R::ok(imageUrlFromBase(chosen->imageBase));
+    }
+
+    // Try full card object — set résumé sometimes omits image.
+    auto cardResp = http_.get(buildCardUrl(setId, chosen->localId));
+    if (cardResp) {
+        auto img = parseCardImageUrl(cardResp.value());
+        if (img) return img;
+        if (img.error().kind == K::Transient) return img;
+    } else {
+        // Odd localId padding can 404; still try catalog gap-fill below.
+    }
+
+    // Classic JA sets often have image:null on TCGdex. Prefer a catalog
+    // printing-accurate TCGPlayer product image for this exact setId+localId
+    // (never search other printings by Pokémon name).
+    return catalogPreviewFor(chosen->localId);
+}
+
+Result<AutoDetectedPrint>
+JapanesePokemonCardPreviewSource::detectFirstPrint(std::string_view name,
+                                                   std::string_view setId) {
+    auto variants = detectPrintVariants(name, setId);
+    if (!variants) return Result<AutoDetectedPrint>::err(variants.error());
+    if (variants.value().empty()) {
+        return Result<AutoDetectedPrint>::err(
+            "No matching Japanese Pokemon prints for that name in the set.");
+    }
+    return Result<AutoDetectedPrint>::ok(variants.value().front());
+}
+
+Result<std::vector<AutoDetectedPrint>>
+JapanesePokemonCardPreviewSource::detectPrintVariants(std::string_view name,
+                                                      std::string_view setId) {
+    if (setId.empty()) {
+        return Result<std::vector<AutoDetectedPrint>>::err(
+            "Select a set before auto-detecting Japanese Pokemon prints.");
+    }
+    auto setResp = http_.get(buildSetDetailUrl(setId));
+    if (!setResp) {
+        if (catalog_.hasPrintsForSet(setId)) {
+            return detectPrintVariantsFromCatalog(setId, name, catalog_);
+        }
+        return Result<std::vector<AutoDetectedPrint>>::err(setResp.error());
+    }
+    auto parsed = parsePrintVariants(setResp.value(), setId, name, catalog_);
+    if (parsed) return parsed;
+    // Empty/unusable TCGdex detail: fall back to catalog prints when present.
+    if (catalog_.hasPrintsForSet(setId)) {
+        return detectPrintVariantsFromCatalog(setId, name, catalog_);
+    }
+    return parsed;
+}
+
+}  // namespace ccm
@@ -0,0 +1,159 @@
+#include "ccm/games/pokemonjp/JapanesePokemonEnCatalog.hpp"
+
+#include <nlohmann/json.hpp>
+
+#include <cctype>
+#include <cstdint>
+#include <string>
+#include <string_view>
+
+namespace ccm {
+
+namespace {
+
+std::string asciiLower(std::string s) {
+    for (char& ch : s) {
+        ch = static_cast<char>(std::tolower(static_cast<unsigned char>(ch)));
+    }
+    return s;
+}
+
+std::string printKey(std::string_view setId, std::string_view localId) {
+    return std::string(setId) + '\0' + std::string(localId);
+}
+
+bool isAsciiAlnumToken(std::string_view s) {
+    if (s.empty()) return false;
+    for (unsigned char ch : s) {
+        if (!std::isalnum(ch)) return false;
+    }
+    return true;
+}
+
+/// True when `needle` appears in `hay` as a whole alphanumeric token
+/// (e.g. "mewtwo" in "team gr's mewtwo" / "mewtwo strikes back", but not
+/// "mew" inside "mewtwo"). ASCII needles only.
+bool containsWholeAsciiToken(std::string_view hay, std::string_view needle) {
+    if (!isAsciiAlnumToken(needle)) return false;
+    const std::size_t n = needle.size();
+    for (std::size_t i = 0; i + n <= hay.size(); ++i) {
+        if (hay.compare(i, n, needle) != 0) continue;
+        const bool leftOk = i == 0 || !std::isalnum(static_cast<unsigned char>(hay[i - 1]));
+        const bool rightOk =
+            i + n == hay.size() ||
+            !std::isalnum(static_cast<unsigned char>(hay[i + n]));
+        if (leftOk && rightOk) return true;
+    }
+    return false;
+}
+
+}  // namespace
+
+Result<JapanesePokemonEnCatalog>
+JapanesePokemonEnCatalog::parse(const std::string& jsonBody) {
+    try {
+        const auto j = nlohmann::json::parse(jsonBody);
+        JapanesePokemonEnCatalog out;
+
+        if (j.contains("sets") && j.at("sets").is_object()) {
+            for (auto it = j.at("sets").begin(); it != j.at("sets").end(); ++it) {
+                JapanesePokemonSetEnInfo info;
+                info.nameEn = it.value().value("name_en", "");
+                info.nameJa = it.value().value("name_ja", "");
+                info.releaseDate = it.value().value("releaseDate", "");
+                out.sets_[it.key()] = std::move(info);
+            }
+        }
+
+        if (j.contains("prints") && j.at("prints").is_array()) {
+            for (const auto& entry : j.at("prints")) {
+                JapanesePokemonPrintEnInfo info;
+                info.setId = entry.value("set_id", "");
+                info.localId = entry.value("local_id", "");
+                info.nameEn = entry.value("name_en", "");
+                info.nameJa = entry.value("name_ja", "");
+                info.nameEnSource = entry.value("name_en_source", "");
+                info.imageUrl = entry.value("image_url", "");
+                if (entry.contains("tcgplayer_id")) {
+                    const auto& tp = entry.at("tcgplayer_id");
+                    if (tp.is_string()) {
+                        info.tcgplayerId = tp.get<std::string>();
+                    } else if (tp.is_number_integer()) {
+                        info.tcgplayerId = std::to_string(tp.get<std::int64_t>());
+                    } else if (tp.is_number_unsigned()) {
+                        info.tcgplayerId = std::to_string(tp.get<std::uint64_t>());
+                    }
+                }
+                if (info.setId.empty() || info.localId.empty()) continue;
+                const std::string key = printKey(info.setId, info.localId);
+                out.printKeysBySet_[info.setId].push_back(key);
+                out.printsByKey_[key] = std::move(info);
+            }
+        }
+
+        return Result<JapanesePokemonEnCatalog>::ok(std::move(out));
+    } catch (const std::exception& e) {
+        return Result<JapanesePokemonEnCatalog>::err(
+            std::string("Japanese Pokemon EN catalog JSON parse error: ") + e.what());
+    }
+}
+
+std::optional<JapanesePokemonSetEnInfo>
+JapanesePokemonEnCatalog::findSet(std::string_view setId) const {
+    const auto it = sets_.find(std::string(setId));
+    if (it == sets_.end()) return std::nullopt;
+    return it->second;
+}
+
+std::optional<JapanesePokemonPrintEnInfo>
+JapanesePokemonEnCatalog::findPrint(std::string_view setId,
+                                    std::string_view localId) const {
+    const auto it = printsByKey_.find(printKey(setId, localId));
+    if (it == printsByKey_.end()) return std::nullopt;
+    return it->second;
+}
+
+std::vector<JapanesePokemonPrintEnInfo>
+JapanesePokemonEnCatalog::findPrintsByName(std::string_view setId,
+                                           std::string_view cardName) const {
+    std::vector<JapanesePokemonPrintEnInfo> out;
+    if (cardName.empty()) return out;
+    const std::string wanted = asciiLower(std::string(cardName));
+    const auto keysIt = printKeysBySet_.find(std::string(setId));
+    if (keysIt == printKeysBySet_.end()) return out;
+    for (const auto& key : keysIt->second) {
+        const auto pit = printsByKey_.find(key);
+        if (pit == printsByKey_.end()) continue;
+        const auto& p = pit->second;
+        const std::string enLower = asciiLower(p.nameEn);
+        const std::string jaLower = asciiLower(p.nameJa);
+        // Exact, qualified "Mewtwo (...)", or whole-token in a longer title
+        // ("Team GR's Mewtwo", "Mewtwo Strikes Back (...)").
+        if (enLower == wanted || jaLower == wanted ||
+            enLower.starts_with(wanted + " (") ||
+            containsWholeAsciiToken(enLower, wanted) ||
+            containsWholeAsciiToken(jaLower, wanted)) {
+            out.push_back(p);
+        }
+    }
+    return out;
+}
+
+bool JapanesePokemonEnCatalog::hasPrintsForSet(std::string_view setId) const noexcept {
+    const auto it = printKeysBySet_.find(std::string(setId));
+    return it != printKeysBySet_.end() && !it->second.empty();
+}
+
+std::string JapanesePokemonEnCatalog::tcgplayerImageUrl(std::string_view productId) {
+    if (productId.empty()) return {};
+    return std::string("https://product-images.tcgplayer.com/fit-in/437x437/") +
+           std::string(productId) + ".jpg";
+}
+
+std::string JapanesePokemonEnCatalog::previewImageUrlFromPrint(
+    const JapanesePokemonPrintEnInfo& print) {
+    if (!print.imageUrl.empty()) return print.imageUrl;
+    return tcgplayerImageUrl(print.tcgplayerId);
+}
+
+}  // namespace ccm
@@ -0,0 +1,11 @@
+#include "ccm/games/pokemonjp/JapanesePokemonGameModule.hpp"
+
+namespace ccm {
+
+JapanesePokemonGameModule::JapanesePokemonGameModule(IHttpClient& http,
+                                                     JapanesePokemonEnCatalog catalog)
+    : catalog_(std::move(catalog)),
+      setSource_(http, catalog_),
+      previewSource_(http, catalog_) {}
+
+}  // namespace ccm
@@ -0,0 +1,207 @@
+#include "ccm/games/pokemonjp/JapanesePokemonSetSource.hpp"
+
+#include "ccm/util/Rfc3986.hpp"
+
+#include <nlohmann/json.hpp>
+
+#include <algorithm>
+#include <array>
+#include <string>
+#include <unordered_map>
+
+namespace ccm {
+
+namespace {
+
+struct ClassicMissingProduct {
+    const char* id;
+    const char* nameEn;
+    const char* releaseDate;  // YYYY/MM/DD
+};
+
+// Keep in sync with tools/pokemon_jp/classic_missing_sets.json and
+// docs/assets-and-info-apis.md (Japanese Pokémon Info API).
+constexpr std::array<ClassicMissingProduct, 11> kMissingClassicProducts{{
+    // Day after Pokémon Jungle (PMCG2, 1997/03/05) so the set list places
+    // Unnumbered Promo immediately after Jungle when sorted by releaseDate.
+    {"UnnumberedPromo", "Unnumbered Promotional cards", "1997/03/06"},
+    {"ExpSheet1", "Expansion Sheet Series 1", "1998/03/23"},
+    {"NiviCG", "Nivi City Gym", "1998/04/26"},
+    {"HanadaCG", "Hanada City Gym", "1998/04/26"},
+    {"ExpSheet2", "Expansion Sheet Series 2", "1998/06/17"},
+    {"KuchibaCG", "Kuchiba City Gym", "1998/07/25"},
+    {"TamamushiCG", "Tamamushi City Gym", "1998/07/25"},
+    {"ExpSheet3", "Expansion Sheet Series 3", "1998/11/24"},
+    {"YamabukiCG", "Yamabuki City Gym", "1999/02/26"},
+    {"GurenTG", "Guren Town Gym", "1999/02/26"},
+    {"SouthernIslands", "Southern Islands", "1999/07/17"},
+}};
+
+const std::unordered_map<std::string, std::string>& setNameJaOverrides() {
+    // Field-level corrections for known TCGdex JA mislabels (never edit cache).
+    static const std::unordered_map<std::string, std::string> kOverrides{
+        {"SV4a", "シャイニートレジャーex"},
+    };
+    return kOverrides;
+}
+
+[[nodiscard]] bool containsCjk(std::string_view s) noexcept {
+    // Detect hiragana / katakana / CJK unified (UTF-8 lead bytes 0xE3–0xE9).
+    // Do NOT treat Latin-1 accents (e.g. é in "Pokémon", lead 0xC3) as CJK —
+    // that used to wipe catalog English names back to the set id.
+    for (unsigned char ch : s) {
+        if (ch >= 0xE3 && ch <= 0xE9) return true;
+    }
+    return false;
+}
+
+}  // namespace
+
+JapanesePokemonSetSource::JapanesePokemonSetSource(
+    IHttpClient& http, const JapanesePokemonEnCatalog& catalog)
+    : http_(http), catalog_(catalog) {}
+
+bool JapanesePokemonSetSource::shouldExcludeSetId(std::string_view setId) noexcept {
+    // Chinese-region CS* entries are mislabeled on the JA endpoint.
+    return setId.size() >= 2 && setId[0] == 'C' && setId[1] == 'S';
+}
+
+std::string JapanesePokemonSetSource::applySetNameOverride(std::string_view setId,
+                                                           std::string nameJa) {
+    const auto& overrides = setNameJaOverrides();
+    const auto it = overrides.find(std::string(setId));
+    if (it != overrides.end()) return it->second;
+    return nameJa;
+}
+
+std::string JapanesePokemonSetSource::rewriteReleaseDate(std::string_view isoDate) {
+    std::string out(isoDate);
+    for (char& ch : out) {
+        if (ch == '-') ch = '/';
+    }
+    return out;
+}
+
+std::string JapanesePokemonSetSource::buildSetDetailUrl(std::string_view setId) {
+    return std::string("https://api.tcgdex.net/v2/ja/sets/") +
+           rfc3986PercentEncode(setId);
+}
+
+Result<std::vector<Set>>
+JapanesePokemonSetSource::parseListResponse(const std::string& body) {
+    try {
+        const auto j = nlohmann::json::parse(body);
+        if (!j.is_array()) {
+            return Result<std::vector<Set>>::err(
+                "TCGdex JA sets response is not a JSON array.");
+        }
+        std::vector<Set> out;
+        out.reserve(j.size());
+        for (const auto& entry : j) {
+            Set s;
+            s.id = entry.value("id", "");
+            if (s.id.empty() || shouldExcludeSetId(s.id)) continue;
+            s.name = applySetNameOverride(s.id, entry.value("name", ""));
+            s.releaseDate = {};  // filled from catalog or set detail
+            out.push_back(std::move(s));
+        }
+        appendMissingClassicProducts(out);
+        return Result<std::vector<Set>>::ok(std::move(out));
+    } catch (const std::exception& e) {
+        return Result<std::vector<Set>>::err(
+            std::string("TCGdex JA sets JSON parse error: ") + e.what());
+    }
+}
+
+void JapanesePokemonSetSource::appendMissingClassicProducts(std::vector<Set>& sets) {
+    for (const auto& product : kMissingClassicProducts) {
+        auto it = std::find_if(sets.begin(), sets.end(), [&](const Set& s) {
+            return s.id == product.id;
+        });
+        if (it != sets.end()) {
+            // Keep curated display name / sort date in sync (e.g. UnnumberedPromo
+            // placement after Pokémon Jungle) even when the id was already cached.
+            it->name = product.nameEn;
+            it->releaseDate = product.releaseDate;
+            continue;
+        }
+        Set s;
+        s.id = product.id;
+        s.name = product.nameEn;
+        s.releaseDate = product.releaseDate;
+        sets.push_back(std::move(s));
+    }
+}
+
+Result<std::string>
+JapanesePokemonSetSource::parseReleaseDate(const std::string& detailBody) {
+    try {
+        const auto j = nlohmann::json::parse(detailBody);
+        if (!j.is_object()) {
+            return Result<std::string>::err(
+                "TCGdex JA set detail response is not a JSON object.");
+        }
+        const std::string raw = j.value("releaseDate", "");
+        if (raw.empty()) {
+            return Result<std::string>::ok(std::string{});
+        }
+        return Result<std::string>::ok(rewriteReleaseDate(raw));
+    } catch (const std::exception& e) {
+        return Result<std::string>::err(
+            std::string("TCGdex JA set detail JSON parse error: ") + e.what());
+    }
+}
+
+Result<std::vector<Set>> JapanesePokemonSetSource::fetchAll() {
+    auto listResp = http_.get(kListEndpoint);
+    if (!listResp) return Result<std::vector<Set>>::err(listResp.error());
+
+    auto parsed = parseListResponse(listResp.value());
+    if (!parsed) return parsed;
+
+    std::vector<Set> out = std::move(parsed).value();
+    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;
+        }
+        if (!s.releaseDate.empty()) continue;
+
+        auto detail = http_.get(buildSetDetailUrl(s.id));
+        if (!detail) continue;  // keep set with empty date rather than fail all
+        auto date = parseReleaseDate(detail.value());
+        if (date && !date.value().empty()) {
+            s.releaseDate = std::move(date).value();
+        }
+    }
+
+    std::sort(out.begin(), out.end(),
+              [](const Set& a, const Set& b) { return a.releaseDate < b.releaseDate; });
+    return Result<std::vector<Set>>::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;
+        }
+    }
+    appendMissingClassicProducts(sets);
+    std::sort(sets.begin(), sets.end(),
+              [](const Set& a, const Set& b) { return a.releaseDate < b.releaseDate; });
+}
+
+}  // namespace ccm
@@ -12,24 +12,59 @@ JsonSetRepository::JsonSetRepository(IFileSystem& fs, ConfigService& config, Dir
    : fs_(fs), config_(config), dirName_(std::move(dirName)) {}

 fs::path JsonSetRepository::setsPath(Game game) const {
-    return fs::path(config_.current().dataStorage) / dirName_(game) / "sets.json";
+    const fs::path root = fs::path(config_.current().dataStorage) / dirName_(game);
+    switch (game) {
+        case Game::Pokemon:         return root / "sets-west.json";
+        case Game::JapanesePokemon: return root / "sets-asia.json";
+        default:                    return root / "sets.json";
+    }
 }

-Result<std::vector<Set>> JsonSetRepository::load(Game game) {
-    const auto p = setsPath(game);
-    if (!fs_.exists(p)) {
-        return Result<std::vector<Set>>::err("Set list not yet downloaded for this game.");
+fs::path JsonSetRepository::legacySetsPath(Game game) const {
+    const fs::path dataRoot(config_.current().dataStorage);
+    switch (game) {
+        case Game::Pokemon:
+            // Pre-flatten: pokemon/sets.json
+            return dataRoot / "pokemon" / "sets.json";
+        case Game::JapanesePokemon:
+            // Pre-flatten: pokemonjp/sets.json
+            return dataRoot / "pokemonjp" / "sets.json";
+        default:
+            return {};
    }
-    auto text = fs_.readText(p);
-    if (!text) return Result<std::vector<Set>>::err(text.error());
+}
+
+Result<std::vector<Set>> JsonSetRepository::parseSetsText(const std::string& text) const {
    try {
-        auto j = nlohmann::json::parse(text.value());
+        auto j = nlohmann::json::parse(text);
        return Result<std::vector<Set>>::ok(j.get<std::vector<Set>>());
    } catch (const std::exception& e) {
        return Result<std::vector<Set>>::err(std::string("sets.json parse error: ") + e.what());
    }
 }

+Result<std::vector<Set>> JsonSetRepository::load(Game game) {
+    const auto p = setsPath(game);
+    if (fs_.exists(p)) {
+        auto text = fs_.readText(p);
+        if (!text) return Result<std::vector<Set>>::err(text.error());
+        return parseSetsText(text.value());
+    }
+
+    const auto legacy = legacySetsPath(game);
+    if (!legacy.empty() && fs_.exists(legacy)) {
+        auto text = fs_.readText(legacy);
+        if (!text) return Result<std::vector<Set>>::err(text.error());
+        auto parsed = parseSetsText(text.value());
+        if (!parsed) return parsed;
+        // Best-effort promote to the new path; UI still gets the sets if write fails.
+        (void)save(game, parsed.value());
+        return parsed;
+    }
+
+    return Result<std::vector<Set>>::err("Set list not yet downloaded for this game.");
+}
+
 Result<void> JsonSetRepository::save(Game game, const std::vector<Set>& sets) {
    const auto p = setsPath(game);
    auto dir = fs_.ensureDirectory(p.parent_path());
@@ -47,6 +47,7 @@ bool matchesPokemonFilter(const PokemonCard& card, std::string_view filter) {
    if (containsLower(to_string(card.condition), needle))     return true;
    if (containsLower(std::to_string(card.amount), needle))   return true;
    if (containsLower(card.note, needle))                     return true;
+    if (containsLower(to_string(card.region), needle))        return true;
    return false;
 }

@@ -67,4 +68,35 @@ bool matchesYuGiOhFilter(const YuGiOhCard& card, std::string_view filter) {
    return false;
 }

+bool matchesDigiBattle99Filter(const DigiBattle99Card& card, std::string_view filter) {
+    if (filter.empty()) return true;
+
+    const std::string needle = asciiLower(filter);
+
+    if (containsLower(card.name, needle))                     return true;
+    if (containsLower(card.set.name, needle))                 return true;
+    if (containsLower(card.setNo, needle))                    return true;
+    if (containsLower(to_string(card.language), needle))      return true;
+    if (containsLower(to_string(card.condition), needle))     return true;
+    if (containsLower(std::to_string(card.amount), needle))   return true;
+    if (containsLower(card.note, needle))                     return true;
+    return false;
+}
+
+bool matchesJapanesePokemonFilter(const JapanesePokemonCard& card,
+                                  std::string_view filter) {
+    if (filter.empty()) return true;
+
+    const std::string needle = asciiLower(filter);
+
+    if (containsLower(card.name, needle))                     return true;
+    if (containsLower(card.set.name, needle))                 return true;
+    if (containsLower(card.setNo, needle))                    return true;
+    if (containsLower(to_string(card.language), needle))      return true;
+    if (containsLower(to_string(card.condition), needle))     return true;
+    if (containsLower(std::to_string(card.amount), needle))   return true;
+    if (containsLower(card.note, needle))                     return true;
+    return false;
+}
+
 }  // namespace ccm
@@ -1,5 +1,6 @@
 #include "ccm/services/CardPreviewService.hpp"

+#include <filesystem>
 #include <string>
 #include <utility>
 #include <vector>
@@ -36,11 +37,18 @@ std::string makeUrlKey(std::string_view url) {
    return k;
 }

+constexpr std::string_view kAssetScheme = "asset:";
+
 }  // namespace

 CardPreviewService::CardPreviewService(IHttpClient& http,
-                                       IPreviewByteCache* persistentCache)
-    : http_(http), persistentCache_(persistentCache) {}
+                                       IPreviewByteCache* persistentCache,
+                                       IFileSystem* fs,
+                                       std::filesystem::path assetRoot)
+    : http_(http),
+      persistentCache_(persistentCache),
+      fs_(fs),
+      assetRoot_(std::move(assetRoot)) {}

 void CardPreviewService::registerModule(IGameModule& module) {
    if (auto* src = module.cardPreviewSource(); src != nullptr) {
@@ -122,6 +130,37 @@ Result<std::string> CardPreviewService::fetchAndCache(const std::string& cacheKe
    return Result<std::string>::ok(std::move(payload));
 }

+Result<std::string, PreviewLookupError> CardPreviewService::fetchAssetAndCache(
+    const std::string& cacheKey,
+    std::string_view assetUrl) {
+    using R = Result<std::string, PreviewLookupError>;
+    using K = PreviewLookupError::Kind;
+
+    if (fs_ == nullptr || assetRoot_.empty()) {
+        return R::err({K::Transient, "Asset preview path is not configured."});
+    }
+    if (!assetUrl.starts_with(kAssetScheme)) {
+        return R::err({K::Transient, "Asset preview URL is missing the asset: prefix."});
+    }
+    std::filesystem::path rel(std::string(assetUrl.substr(kAssetScheme.size())));
+    const auto fullPath = assetRoot_ / rel;
+    auto bytes = fs_->readText(fullPath);
+    if (!bytes) {
+        return R::err({K::NotFound,
+                       "Bundled preview asset not found: " + fullPath.generic_string()});
+    }
+    std::string payload = std::move(bytes).value();
+    if (payload.empty()) {
+        return R::err({K::NotFound,
+                       "Bundled preview asset is empty: " + fullPath.generic_string()});
+    }
+    cacheStore(cacheKey, payload);
+    if (persistentCache_ != nullptr) {
+        persistentCache_->store(cacheKey, payload);
+    }
+    return R::ok(std::move(payload));
+}
+
 Result<std::string> CardPreviewService::fetchPreviewBytes(Game game,
                                                          std::string_view name,
                                                          std::string_view setId,
@@ -179,6 +218,18 @@ Result<std::string> CardPreviewService::fetchPreviewBytes(Game game,
        }
        return Result<std::string>::err(err.message);
    }
+    if (url.value().starts_with(kAssetScheme)) {
+        auto asset = fetchAssetAndCache(key, url.value());
+        if (!asset) {
+            const auto err = std::move(asset).error();
+            if (err.kind == PreviewLookupError::Kind::NotFound) {
+                cacheStoreNegative(key);
+                if (persistentCache_ != nullptr) persistentCache_->storeNegative(key);
+            }
+            return Result<std::string>::err(err.message);
+        }
+        return Result<std::string>::ok(std::move(asset).value());
+    }
    return fetchAndCache(key, url.value());
 }

@@ -231,6 +282,11 @@ Result<std::string> CardPreviewService::fetchImageBytesByUrl(std::string_view ur
            return Result<std::string>::ok(disk.payload);
        }
    }
+    if (url.starts_with(kAssetScheme)) {
+        auto asset = fetchAssetAndCache(key, url);
+        if (!asset) return Result<std::string>::err(asset.error().message);
+        return Result<std::string>::ok(std::move(asset).value());
+    }
    return fetchAndCache(key, url);
 }

@@ -223,4 +223,144 @@ void sortYuGiOhCards(std::vector<YuGiOhCard>& cards, YuGiOhSortColumn column,
    }
 }

+void sortDigiBattle99Cards(std::vector<DigiBattle99Card>& cards,
+                           DigiBattle99SortColumn column,
+                           bool ascending) {
+    switch (column) {
+    case DigiBattle99SortColumn::Name:
+        std::stable_sort(cards.begin(), cards.end(), directional(
+            [](const DigiBattle99Card& a, const DigiBattle99Card& b) {
+                return asciiLower(a.name) < asciiLower(b.name);
+            }, ascending));
+        break;
+    case DigiBattle99SortColumn::SetReleaseDate:
+        std::stable_sort(cards.begin(), cards.end(), directional(
+            [](const DigiBattle99Card& a, const DigiBattle99Card& b) {
+                return asciiLower(a.set.releaseDate) <
+                       asciiLower(b.set.releaseDate);
+            }, ascending));
+        break;
+    case DigiBattle99SortColumn::Language:
+        std::stable_sort(cards.begin(), cards.end(), directional(
+            [](const DigiBattle99Card& a, const DigiBattle99Card& b) {
+                return asciiLower(to_string(a.language)) <
+                       asciiLower(to_string(b.language));
+            }, ascending));
+        break;
+    case DigiBattle99SortColumn::Condition:
+        std::stable_sort(cards.begin(), cards.end(), directional(
+            [](const DigiBattle99Card& a, const DigiBattle99Card& b) {
+                return asciiLower(to_string(a.condition)) <
+                       asciiLower(to_string(b.condition));
+            }, ascending));
+        break;
+    case DigiBattle99SortColumn::Amount:
+        std::stable_sort(cards.begin(), cards.end(), directional(
+            [](const DigiBattle99Card& a, const DigiBattle99Card& b) {
+                return a.amount < b.amount;
+            }, ascending));
+        break;
+    case DigiBattle99SortColumn::Holo:
+        std::stable_sort(cards.begin(), cards.end(), directional(
+            [](const DigiBattle99Card& a, const DigiBattle99Card& b) {
+                return a.holo < b.holo;
+            }, ascending));
+        break;
+    case DigiBattle99SortColumn::FirstEdition:
+        std::stable_sort(cards.begin(), cards.end(), directional(
+            [](const DigiBattle99Card& a, const DigiBattle99Card& b) {
+                return a.firstEdition < b.firstEdition;
+            }, ascending));
+        break;
+    case DigiBattle99SortColumn::Signed:
+        std::stable_sort(cards.begin(), cards.end(), directional(
+            [](const DigiBattle99Card& a, const DigiBattle99Card& b) {
+                return a.signed_ < b.signed_;
+            }, ascending));
+        break;
+    case DigiBattle99SortColumn::Altered:
+        std::stable_sort(cards.begin(), cards.end(), directional(
+            [](const DigiBattle99Card& a, const DigiBattle99Card& b) {
+                return a.altered < b.altered;
+            }, ascending));
+        break;
+    case DigiBattle99SortColumn::Note:
+        std::stable_sort(cards.begin(), cards.end(), directional(
+            [](const DigiBattle99Card& a, const DigiBattle99Card& b) {
+                return asciiLower(a.note) < asciiLower(b.note);
+            }, ascending));
+        break;
+    }
+}
+
+void sortJapanesePokemonCards(std::vector<JapanesePokemonCard>& cards,
+                              JapanesePokemonSortColumn column,
+                              bool ascending) {
+    switch (column) {
+    case JapanesePokemonSortColumn::Name:
+        std::stable_sort(cards.begin(), cards.end(), directional(
+            [](const JapanesePokemonCard& a, const JapanesePokemonCard& b) {
+                return asciiLower(a.name) < asciiLower(b.name);
+            }, ascending));
+        break;
+    case JapanesePokemonSortColumn::SetReleaseDate:
+        std::stable_sort(cards.begin(), cards.end(), directional(
+            [](const JapanesePokemonCard& a, const JapanesePokemonCard& b) {
+                return asciiLower(a.set.releaseDate) <
+                       asciiLower(b.set.releaseDate);
+            }, ascending));
+        break;
+    case JapanesePokemonSortColumn::Language:
+        std::stable_sort(cards.begin(), cards.end(), directional(
+            [](const JapanesePokemonCard& a, const JapanesePokemonCard& b) {
+                return asciiLower(to_string(a.language)) <
+                       asciiLower(to_string(b.language));
+            }, ascending));
+        break;
+    case JapanesePokemonSortColumn::Condition:
+        std::stable_sort(cards.begin(), cards.end(), directional(
+            [](const JapanesePokemonCard& a, const JapanesePokemonCard& b) {
+                return asciiLower(to_string(a.condition)) <
+                       asciiLower(to_string(b.condition));
+            }, ascending));
+        break;
+    case JapanesePokemonSortColumn::Amount:
+        std::stable_sort(cards.begin(), cards.end(), directional(
+            [](const JapanesePokemonCard& a, const JapanesePokemonCard& b) {
+                return a.amount < b.amount;
+            }, ascending));
+        break;
+    case JapanesePokemonSortColumn::Holo:
+        std::stable_sort(cards.begin(), cards.end(), directional(
+            [](const JapanesePokemonCard& a, const JapanesePokemonCard& b) {
+                return a.holo < b.holo;
+            }, ascending));
+        break;
+    case JapanesePokemonSortColumn::FirstEdition:
+        std::stable_sort(cards.begin(), cards.end(), directional(
+            [](const JapanesePokemonCard& a, const JapanesePokemonCard& b) {
+                return a.firstEdition < b.firstEdition;
+            }, ascending));
+        break;
+    case JapanesePokemonSortColumn::Signed:
+        std::stable_sort(cards.begin(), cards.end(), directional(
+            [](const JapanesePokemonCard& a, const JapanesePokemonCard& b) {
+                return a.signed_ < b.signed_;
+            }, ascending));
+        break;
+    case JapanesePokemonSortColumn::Altered:
+        std::stable_sort(cards.begin(), cards.end(), directional(
+            [](const JapanesePokemonCard& a, const JapanesePokemonCard& b) {
+                return a.altered < b.altered;
+            }, ascending));
+        break;
+    case JapanesePokemonSortColumn::Note:
+        std::stable_sort(cards.begin(), cards.end(), directional(
+            [](const JapanesePokemonCard& a, const JapanesePokemonCard& b) {
+                return asciiLower(a.note) < asciiLower(b.note);
+            }, ascending));
+        break;
+    }
+}
+
 }  // namespace ccm
@@ -21,7 +21,13 @@ Result<std::vector<Set>> SetService::updateSets(Game game) {
 }

 Result<std::vector<Set>> SetService::getSets(Game game) {
-    return repo_.load(game);
+    auto loaded = repo_.load(game);
+    if (!loaded) return loaded;
+    auto it = modules_.find(game);
+    if (it != modules_.end() && it->second != nullptr) {
+        it->second->setSource().augmentCachedSets(loaded.value());
+    }
+    return loaded;
 }

 }  // namespace ccm
@@ -11,13 +11,13 @@ Long-form contributor documentation that lives outside the source tree.
 - `dow-doc-build-locally.md` — complete local build/setup reference for Windows and Linux, including dependency management and troubleshooting.
 - `intro-to-new-developers.md` — onboarding map for new contributors: architecture, folder responsibilities, guardrails, anti-patterns, and links to deeper docs.
 - `testing-and-test-code-of-conduct.md` — testing workflow plus expected standards for writing and maintaining deterministic, hermetic, behavior-focused tests.
- `assets-and-info-apis.md` — reference for the external info APIs (set metadata) and asset APIs (card preview images) used by the Magic, Pokémon, and Yu-Gi-Oh! modules, plus the runtime flow through `SetService` / `CardPreviewService`, shared HTTP defaults (`CprHttpClient`, `Accept: */*`), per-game card-back fallbacks (URLs + bundled `ygo_card_back.png`), and error-surface conventions. The Yu-Gi-Oh! **Info API** section also documents the local **set code** lookup used by the edit dialog (`YuGiOhSetLookup`, no extra HTTP).
+- `assets-and-info-apis.md` — reference for the external info APIs (set metadata) and asset APIs (card preview images) used by the Magic, Pokémon (West + Asia backends), Yu-Gi-Oh!, and Digimon Digi-Battle modules, plus the runtime flow through `SetService` / `CardPreviewService`, shared HTTP defaults (`CprHttpClient`, `Accept: */*`), per-game card-back fallbacks (URLs + bundled `ygo_card_back.png` / `digibattle99_card_back.png`), the Japanese Pokémon EN catalog asset (Asia region), and error-surface conventions. The Yu-Gi-Oh! **Info API** section also documents the local **set code** lookup used by the edit dialog (`YuGiOhSetLookup`, no extra HTTP).
 - `caching.md` — dedicated reference for preview-byte caching tiers (`CardPreviewService` LRU + `LocalPreviewByteCache`), cache keys and eviction, HTTP session reuse via `CprHttpClient`, and explicit non-goals (no error caching).
 - `README.md` — index page that clusters docs by area and links to all documents in this directory.

 ## Subdirectories

- `assets/images/` — static screenshots and other binary assets referenced from the documentation (currently `demo-mtg.png`, `demo-pkm.png`). Keep filenames stable so cross-doc links don't break, and prefer compressed PNG/JPEG over uncompressed formats.
+- `assets/images/` — static screenshots and other binary assets referenced from the documentation (currently `demo-mtg.png`, `demo-pkm.png`, `demo-ygo.png`, `demo-digibattle99.png`). Keep filenames stable so cross-doc links don't break, and prefer compressed PNG/JPEG over uncompressed formats.

 ## Conventions

@@ -28,7 +28,7 @@ Long-form contributor documentation that lives outside the source tree.
 ## Required follow-ups

 - After changing per-game seams in `core/` (e.g. `IGameModule`, `ISetSource`, `ICardPreviewSource`, `CollectionService`, `SetService`, `CardPreviewService`, `ImageService`) you **must** update `adding-a-new-game.md` to keep the canonical procedure in sync. The same applies to the UI seams (`IGameView`, `BaseCardListPanel`, `BaseCardEditDialog`, `BaseSelectedCardPanel`) and the composition-root wiring in `app/main.cpp`.
- After changing any game's set/preview adapters (`MagicSetSource`, `MagicCardPreviewSource`, `PokemonSetSource`, `PokemonCardPreviewSource`, `YuGiOhSetSource`, `YuGiOhCardPreviewSource`) — endpoints, response parsing, name/number normalization, or the info-vs-asset split — you **must** update `assets-and-info-apis.md` so the API reference matches the live behavior.
+- After changing any game's set/preview adapters (`MagicSetSource`, `MagicCardPreviewSource`, `PokemonSetSource`, `PokemonCardPreviewSource`, `YuGiOhSetSource`, `YuGiOhCardPreviewSource`, `DigiBattle99SetSource`, `DigiBattle99CardPreviewSource`) — endpoints, response parsing, name/number normalization, or the info-vs-asset split — you **must** update `assets-and-info-apis.md` so the API reference matches the live behavior.
 - After bumping a key dependency (`nlohmann/json`, `cpr`, `wxWidgets`, `doctest`) in a way that changes a public API used in the guide's examples, update those examples.
 - After adding a new file under `docs/` (or a new entry under `docs/assets/images/`) you **must** add it to the file list above **and** to `README.md` so the index stays complete.
 - Do **not** rename, move, or split this file without first updating every other `AGENTS.md` that points at it (root, `core/`, `ui_wx/`, `app/`, `tests/`).
@@ -22,7 +22,7 @@ This folder contains contributor documentation for Card Collection Manager 3. St

 - [adding-a-new-game.md](adding-a-new-game.md): canonical end-to-end procedure for adding a new game module across `core/`, `ui_wx/`, and `app/`.

- [assets-and-info-apis.md](assets-and-info-apis.md): external info and asset APIs used by Magic, Pokémon, and Yu-Gi-Oh! modules, preview fallback URLs / bundled YGO card-back asset, and shared HTTP behavior (`CprHttpClient`).
+- [assets-and-info-apis.md](assets-and-info-apis.md): external info and asset APIs used by Magic, Pokémon, Yu-Gi-Oh!, and Digimon Digi-Battle modules, preview fallback URLs / bundled card-back assets, and shared HTTP behavior (`CprHttpClient`).

 ## Performance & Caching

@@ -195,7 +195,7 @@ private:

 Two subtle requirements:

- `dirName()` returns the **on-disk directory name**. Once you ship, this is forever — changing it later orphans every existing user's data. Pick something lowercase, ASCII, and short.
+- `dirName()` returns the **on-disk directory name**. Once you ship, this is forever — changing it later orphans every existing user's data. Pick something lowercase, ASCII, and short. **Pokemon exception:** a unified Game menu entry may keep one `dirName` (`pokemon`) for collection/images and disambiguate region set caches by filename (`sets-west.json` / `sets-asia.json`) instead of a second data subdirectory.
 - `cardPreviewSource()` defaults to `nullptr` in `IGameModule`. Only override it if you actually have a preview source. Returning `nullptr` makes `CardPreviewService::registerModule(*module)` a silent no-op for that game; the UI gracefully falls back to "no preview available".

 The `.cpp` is one line of constructor body — see `core/src/games/pokemon/PokemonGameModule.cpp`.
@@ -18,6 +18,10 @@ Used by `MagicCardPreviewSource` to find a card printing from `name` + `setId`,

 ## Pokemon APIs

+Unified **Pokemon** Game menu entry. Per-card `region` (`West` / `Asia`) selects the backend below. Collection: `pokemon/collection.json`. West sets: `pokemon/sets-west.json`. Asia sets: `pokemon/sets-asia.json`. Language choices: West → English/German/French/Spanish/Italian/Russian; Asia → Japanese/S-Chinese/T-Chinese/Korean.
+
+### West (`Game::Pokemon`, pokemontcg.io)
+
 **Info API:** `https://api.pokemontcg.io/v2/sets`  
 Used by `PokemonSetSource` to fetch all sets. The parser maps `id`, `name`, and `releaseDate` directly into `Set`, then sorts ascending by release date.

@@ -78,6 +82,153 @@ Used in two situations:

 YGOPRODeck publishes rate limits and asks clients to cache responses and avoid abusive hotlinking; treat failures after burst traffic as an upstream policy signal, not an app bug. Yugipedia’s MediaWiki API is similarly polite — one batched call per preview lookup keeps us well under any normal threshold.

+## Digimon Digi-Battle (1999) APIs (digimoncard.io)
+
+English Digi-Battle is wired as `Game::DigiBattle99` (`dirName` `digibattle99`, UI label **Digimon (Digi-Battle)**). Upstream docs: [digimoncard.io Public API](https://digimoncard.io/api-documentation). Always scope requests with `series=Digimon Digi-Battle Card Game` so modern Digimon Card Game rows are never mixed in. Rate limit: **15 requests / 10 seconds / IP** (429 then temporary block on abuse).
+
+### Info API: derived set list from `search.php`
+
+There is **no** dedicated sets endpoint. `DigiBattle99SetSource` calls:
+
+`https://digimoncard.io/api-public/search.php?series=Digimon%20Digi-Battle%20Card%20Game&limit=1000&sort=name&sortdirection=asc`
+
+and collects unique `set_name[]` pack strings. Each pack becomes a `Set` with:
+
+- `Set.name` — exact pack display name (used as `pack=` on search / auto-detect)
+- `Set.id` — stable slug (`Series 1 Starter Set` → `series-1-starter-set`); never rename after ship
+- `Set.releaseDate` — curated table in the set source (Series 1 Starter = `1999/06/01` verified; other packs use documented year/month anchors)
+
+Unknown future packs get an empty release date and sort last.
+
+### Asset API: CDN images + `search.php` lookup
+
+Card scans live at:
+
+`https://images.digimoncard.io/images/cards/{id}.jpg`
+
+where `{id}` is the API card number (`ST-01`, `BO-115`, `MO-06`). The CDN also serves `.webp`, but CCM3 uses `.jpg` because `OnInit` only registers `wxPNGHandler` / `wxJPEGHandler` (WebP bytes would surface as “image decode failed”).
+
+`DigiBattle99CardPreviewSource::fetchImageUrl`:
+
+1. If `setNo` is non-empty → normalize alphabetic prefix to uppercase (**no** invented zero-padding) and return the CDN URL with **no** search round-trip.
+2. Otherwise search with `n=` + optional `pack=` (display set name) + `series=`, take the first exact name match’s `id`, then build the CDN URL.
+
+**Preview key:** `(name, set.name, setNo)` — middle slot is the pack **display name** (same idea as Yu-Gi-Oh! passing `set.name` for YGOPRODeck `cardset=`), not the slug id.
+
+**Auto-detect** (`detectPrintVariants`): same search; distinct `id` values become `AutoDetectedPrint::setNo`. Digi-Battle UI is Pokémon-like (no persisted rarity).
+
+Empty search array / `{"error":"..."}` → `NotFound`; bad JSON / HTTP → `Transient`.
+
+## Japanese Pokémon TCG APIs (TCGdex `ja`) — Asia region backend
+
+Asia Pokémon is routed internally as `Game::JapanesePokemon` (`dirName` `pokemon`, same data directory as West). It is **not** a separate Game menu entry: the unified **Pokemon** UI stores both West and Asia cards in `pokemon/collection.json` with a per-card `region` (`West` / `Asia`). Set caches are split by filename under that directory (`pokemon/sets-west.json` vs `pokemon/sets-asia.json`). `JsonSetRepository` migrate-on-load promotes legacy `pokemon/sets.json` → `sets-west.json` and `pokemonjp/sets.json` → `sets-asia.json` when the new files are missing. **Sets > Update Pokemon** refreshes both lists. Upstream: [TCGdex REST API](https://tcgdex.dev/). No API key. Japanese set IDs (e.g. `PMCG1`, `SV1a`) are never merged into Western pokemontcg.io ids.
+
+### Info API: TCGdex `GET /v2/ja/sets` (+ per-set detail)
+
+`https://api.tcgdex.net/v2/ja/sets` returns a slim array (`id`, `name`, `cardCount`). Release dates require `GET /v2/ja/sets/{id}` (`releaseDate` as `YYYY-MM-DD`, rewritten to `YYYY/MM/DD`). `JapanesePokemonSetSource`:
+
+- Excludes Chinese-region `CS*` junk rows mislabeled on the JA endpoint.
+- Applies field overrides (e.g. `SV4a` Japanese name → `シャイニートレジャーex`).
+- Prefers English display names and release dates from the bundled EN catalog when present; otherwise keeps the TCGdex Japanese name and fetches detail for the date.
+- After parsing the TCGdex list, **injects Original-era / catalog-only products TCGdex omits** (idempotent by set id — skipped if upstream later adds them). The same injection runs when loading a cached Asia set list (`sets-asia.json`) via `ISetSource::augmentCachedSets`, so these products appear without requiring **Update Sets** first. Stable ids and English names:
+
+| Id | English name |
+|---|---|
+| `UnnumberedPromo` | Unnumbered Promotional cards (Bulbapedia catch-all; synthetic `001`… localIds; preview via catalog `image_url` preferring Japanese / Unnumbered Bulbagarden scans) |
+| `ExpSheet1` / `ExpSheet2` / `ExpSheet3` | Expansion Sheet Series 1–3 |
+| `NiviCG` | Nivi City Gym |
+| `HanadaCG` | Hanada City Gym |
+| `KuchibaCG` | Kuchiba City Gym |
+| `TamamushiCG` | Tamamushi City Gym |
+| `YamabukiCG` | Yamabuki City Gym |
+| `GurenTG` | Guren Town Gym |
+| `SouthernIslands` | Southern Islands |
+
+Seed data lives in `tools/pokemon_jp/classic_missing_sets.json` + `classic_missing_prints.json` (merged into the EN catalog via `merge_classic_missing.py`). LocalIds for these products are sequential `001`… within each product (cards were unnumbered in print). Refresh `UnnumberedPromo` prints from Bulbapedia with `python tools/pokemon_jp/harvest_unnumbered_promos.py`, then fill preview images with `python tools/pokemon_jp/enrich_unnumbered_promo_images.py` (prefers Unnumbered / Japanese reprint-gallery scans over English Wizards `|image=` primaries; EN-only Bulbapedia pages leave `image_url` empty), then re-run `merge_classic_missing.py`. Numbered Japanese promo eras (`SV-P`, `S-P`, …) remain out of scope — TCGdex does not expose them, and they are not part of this curated set.
+
+### Sets without printed collector numbers (`UnnumberedPromo`)
+
+Physically unnumbered Japanese promos (and the other classic catalog-only products above) have **no printed set number**. The app still stores a synthetic `setNo` / catalog `local_id` (`001`, `002`, …) so preview and collection JSON stay keyed by `(setId, localId)` — but that value must not be treated as something the user can read off the card.
+
+**Edit dialog (`PokemonCardEditDialog`, Asia region) for set id `UnnumberedPromo`:**
+
+- The **Set #** text field is hidden (row label becomes **Print**). **Auto detect** and **Next** remain.
+- Auto-detect / silent Edit prefetch lists catalog prints matching the typed name (exact EN/JA, plus qualified titles such as `Mewtwo` → `Mewtwo (CoroCoro promo)`). Distinct synthetic localIds form the Next ring.
+- **Next** on the edit form shows a position counter (`Next (2/5)`), not the synthetic id. For ordinary numbered JP sets, Next still shows the current collector number (`Next (42)`).
+- A modeless **Print preview** popup (`VariantImagePreviewDialog`) opens ~20px to the right of the Add/Edit dialog. It loads the current print via `CardPreviewService::fetchPreviewBytes` and refreshes on each ring step. The popup has its own **`<< Prev` / `Next >>`** controls that drive the same ring as the edit dialog (buttons disabled when fewer than two variants).
+- On save, the dialog writes the ring’s synthetic `setNo` into `PokemonCard::setNo` even though the text field was hidden.
+
+Other classic unnumbered products (City Gyms, Expansion Sheets, Southern Islands) currently keep the normal Set # field; only `UnnumberedPromo` uses the print-preview UX above.
+
+### Asset API: TCGdex card / set-detail images
+
+Preview is **local-id based**. `JapanesePokemonCardPreviewSource`:
+
+1. With `setId` + `setNo` (`localId`), tries `GET /v2/ja/cards/{setId}-{localId}` and reads `image`.
+2. Falls back to set-detail `cards[]` (which often already carries `image` on modern sets).
+3. Appends `/high.png` to the TCGdex image base URL (PNG — wxImage does not decode webp).
+4. If the set-specific card still has no scan (classic sets like `PMCG1`), looks up the bundled EN catalog print for that exact `setId`+`localId` and uses optional `image_url` or a TCGPlayer product image built from `tcgplayer_id` (`https://product-images.tcgplayer.com/fit-in/437x437/{id}.jpg`). Gap-fill sources differ by era:
+   - **PMCG and other data-asia sets with `thirdParty.tcgplayer`**: printing-accurate `tcgplayer_id` harvested offline from [tcgdex/cards-database](https://github.com/tcgdex/cards-database) `data-asia` (the live TCGdex API does not expose them).
+   - **neo1–neo4**: data-asia has no `tcgplayer_id` and TCGdex JA `image` is null; the catalog may carry an ETL-written `image_url` from a **Japanese** [CardIndex](https://www.cardindex.co/) set scan (`enrich_neo_image_urls.py` scrapes the JA neo set pages and matches by English card name). **No English pokemontcg.io fallback** — if CardIndex has no JP image, `image_url` is left empty and the UI shows the card-back. Use `--overwrite` to re-resolve / clear stale EN URLs. Runtime still resolves only by exact JA `setId`+`localId` — no C++ name search across printings.
+   This is **printing-accurate** gap-fill — not a name search across other Charizard printings at runtime.
+5. For **catalog-only products** (Unnumbered Promotional cards, City Gym theme decks, Expansion Sheets, Southern Islands), when TCGdex set/card GETs fail, Auto-detect and preview fall back to the bundled catalog prints for that `setId` (EN/JA name → `localId`; optional `tcgplayer_id` / `image_url` for preview). `UnnumberedPromo` rows typically carry Bulbagarden Archives `image_url` values written by `enrich_unnumbered_promo_images.py`, which prefers Japanese / Unnumbered Promotional reprint scans and omits English-only Wizards Black Star primaries when no JP file is available. Without a catalog image field, preview returns `NotFound` and the UI shows the card-back. Auto-detect matches exact EN/JA names and also qualified English titles (`Mewtwo` → `Mewtwo (CoroCoro promo)`).
+6. City Gym deck exclusives must stay **printing-accurate**. Do **not** reuse Leaders' Stadium / PMCG donor `tcgplayer_id`s for those prints; that shows the wrong set art. Instead, bundle local scans under `assets/pokemon_jp_classic/<setId>/<localId>.jpg` and point the catalog row at `image_url: "asset:pokemon_jp_classic/<setId>/<localId>.jpg"`. `CardPreviewService` loads `asset:` URLs from disk next to the executable, bypassing HTTP entirely.
+
+It does **not** substitute another printing of the same Pokémon when both TCGdex and the catalog lack an image. Then preview returns `NotFound` and the UI shows the Japanese TCG card-back.
+
+Auto-detect / Next uses the same set-detail `cards[]`, matching the typed name against catalog English names or TCGdex Japanese names. Catalog EN aliases are applied only when the catalog `name_ja` agrees with the TCGdex row (stale seed mappings like Charmander→`001` are ignored).
+
+Pokémon English aliases in the catalog come from National Dex → species table (`dexId`) for ordinary Pokémon. When `name_ja` carries a known owner / Rocket's / Dark / Light / Shining prefix, `enrich_preview_images.py` composes the **full English product title** (e.g. `エリカのナゾノクサ` → `Erika's Oddish`, `わるいリザードン` → `Dark Charizard`, `R団のサンダー` → `Rocket's Zapdos`, neo garbled `輝くセレビ` → `Shining Celebi`). Those rows use `name_en_source: "species-table-variant"`. Trainer/Energy English aliases come from the offline JA→EN map `tools/pokemon_jp/non_pokemon_en_by_ja.json` (e.g. Switch ← `ポケモンいれかえ`).
+
+That trainer/energy map is maintained to cover **at least the first 15 chronological main Japanese expansions** present in TCGdex (PMCG1–PMCG6, neo1–neo4, VS1, web1, E1–E3). The same JA→EN entry also applies to later reprints that reuse the Japanese name.
+
+### Variant Pokémon English titles
+
+Auto-detect for English owner / Rocket's / Dark / Light / Shining Pokémon names requires the bundled catalog's **full** `name_en` for that print (same rule as City Gym manuals that already store `Erika's Oddish`). Typing the Japanese TCGdex name still works when `name_ja` is correct.
+
+To extend variant coverage:
+
+1. Add new JA prefix → English title prefix pairs to `VARIANT_JA_PREFIXES` in [`tools/pokemon_jp/enrich_preview_images.py`](../tools/pokemon_jp/enrich_preview_images.py) (longest prefixes first).
+2. Re-run:
+
+```bash
+python tools/pokemon_jp/enrich_preview_images.py
+```
+
+3. For neo1–neo4 Japanese preview images (CardIndex JP scans only; clears EN
+   pokemontcg.io URLs on miss), run:
+
+```bash
+python tools/pokemon_jp/enrich_neo_image_urls.py
+python tools/pokemon_jp/enrich_neo_image_urls.py --overwrite
+```
+
+4. Rebuild so `assets/pokemon_jp_en_catalog.json` next to the exe is updated.
+
+Rows with `name_en_source: "manual"` (City Gym theme decks in `classic_missing_prints.json`) are never overwritten. Prefer stable English TCG product names (Bulbapedia / Limitless English titles).
+
+### Extending Trainer/Energy English aliases
+
+Auto-detect for English Trainer/Energy names only works when the bundled catalog has a `name_en` for that print. Pokémon get `name_en` automatically from `dexId` (bare species) or from variant prefix composition (full titles); Trainers and Energy do not. To add more sets or staples:
+
+1. Collect unique Japanese Trainer/Energy names for the sets you care about (from TCGdex set detail `cards[].name`, or from `tools/pokemon_jp/_tcgdex_cards_database/data-asia/<serie>/<setId>/*.ts` after running enrich once).
+2. Add each missing `name_ja` → English display name to [`tools/pokemon_jp/non_pokemon_en_by_ja.json`](../tools/pokemon_jp/non_pokemon_en_by_ja.json). One entry covers **every set** that reprints that Japanese title.
+3. Re-run:
+
+```bash
+python tools/pokemon_jp/enrich_preview_images.py
+```
+
+4. Confirm `enrich_preview_images.py` prints `FIRST15 trainer/energy coverage OK` (or extend `FIRST15_SETS` in that script if you raise the coverage baseline). Copy/rebuild so `assets/pokemon_jp_en_catalog.json` next to the exe is updated.
+5. Prefer stable English TCG product names (Bulbapedia / Limitless English titles). Do not invent per-set aliases that differ for the same `name_ja`.
+
+### Bundled English catalog
+
+`ui_wx/assets/pokemon_jp_en_catalog.json` is copied next to the exe on build (`assets/pokemon_jp_en_catalog.json`). It supplies English set/card names TCGdex JA cannot provide, plus optional classic-image gap-fill fields (`tcgplayer_id` / `image_url`). Generated offline via `tools/pokemon_jp/` (set EN merge + `enrich_preview_images.py` using species, variant, and trainer/energy tables + optional `enrich_neo_image_urls.py` for neo `image_url`). Missing catalog → Japanese-only labels still work; missing image fields → card-back for unscanned printings. Missing EN aliases for a Trainer still allow Auto-detect when the Japanese name is typed.
+
+Card-back fallback uses the Japanese TCG Bulbagarden scan
+(`TCG_Card_Back_Japanese.jpg`), not the Western `Cardback.jpg`.
+
 ## Runtime Flow In CCM3

 The app uses the same flow for every game that registers a module:
@@ -85,21 +236,21 @@ The app uses the same flow for every game that registers a module:
 - `SetService` asks the game's `ISetSource` (info API) for the latest set list.
 - `CardPreviewService` asks the game's `ICardPreviewSource` (asset API) for a preview image URL.
 - `CardPreviewService` performs a second HTTP GET to that URL and returns raw bytes to the UI layer.
- If preview lookup fails (or returns empty bytes), the UI loads a **per-game card-back fallback** in `BaseSelectedCardPanel`: Magic / Pokémon call `CardPreviewService::fetchImageBytesByUrl(...)` against fixed HTTPS URLs. Yu-Gi-Oh! tries two Yugipedia URLs (thumbnail then full `Back-EN.png`), then reads **`assets/ygo_card_back.png`** next to the executable if both downloads fail (bundled asset; see `app/CMakeLists.txt`).
+- If preview lookup fails (or returns empty bytes), the UI loads a **per-game card-back fallback** in `BaseSelectedCardPanel`: Magic / Pokémon / Japanese Pokémon call `CardPreviewService::fetchImageBytesByUrl(...)` against fixed HTTPS URLs. Yu-Gi-Oh! tries two Yugipedia URLs (thumbnail then full `Back-EN.png`), then reads **`assets/ygo_card_back.png`** next to the executable if both downloads fail (bundled asset; see `app/CMakeLists.txt`).

 ### Caching And Connection Reuse

 See [caching.md](caching.md) for a dedicated reference on preview cache tiers, internal keys, eviction, clearing, and HTTP session reuse.

-Three mechanisms reduce preview latency for **all** games (Magic, Pokemon, Yu-Gi-Oh!). In addition, the shared HTTP session speeds **every** `IHttpClient::get` call (including set-list fetches), not only previews:
+Three mechanisms reduce preview latency for **all** games (Magic, Pokemon West/Asia backends, Yu-Gi-Oh!, DigiBattle99). In addition, the shared HTTP session speeds **every** `IHttpClient::get` call (including set-list fetches), not only previews:

 - **In-memory preview LRU** (`CardPreviewService`). Successful `fetchPreviewBytes` results are cached keyed by `(game, name, setId, setNo)`; successful `fetchImageBytesByUrl` results are cached keyed by URL (used for the per-game card-back fallback). Re-selecting a previously viewed row is decode-only — no HTTP at all. The cache is bounded by `CardPreviewService::kCacheCapacity` (currently 128 entries) and uses a list+map LRU under a mutex (the preview pipeline is invoked from a worker thread in `BaseSelectedCardPanel`). **Source errors are split** by `PreviewLookupError::Kind`: `NotFound` (the upstream answered cleanly that the record has no image) is *negative-cached* in this tier so subsequent selections short-circuit without HTTP, while `Transient` (HTTP/network/parse failures) is **never** cached so a brief outage cannot permanently disable a card's preview.
 - **Persistent disk byte cache** (`LocalPreviewByteCache`, port `IPreviewByteCache`). Wraps the in-memory tier with an on-disk store under `<exeDir>/.cache/preview-cache/` — pinned **next to the executable**, in the same scope as `config.json`, **not** under the user-configurable `Configuration.dataStorage` path. The cache stays put when the user reconfigures or relocates their collection data, and it is not part of the user's data directory backups; it is install-scoped, not collection-scoped. Both positive previews and `NotFound` verdicts survive an app restart. Each entry is a mutually-exclusive `<hash>.bin` (positive payload) or `<hash>.neg` (negative marker) plus a `<hash>.idx` sidecar containing the original key — load-time mismatch on the sidecar treats the entry as a miss, so a hash collision degrades to a one-time HTTP refetch instead of serving the wrong card's bytes (or the wrong card's "no image" verdict). Hashing is FNV-1a 64-bit (no crypto dependency). The cache is bounded by total `.bin` payload bytes (default `kDefaultMaxBytes = 64 MiB`) and evicts oldest entries by mtime when a new write would exceed the cap; reading an entry touches its mtime so frequently-viewed cards survive eviction. Negative `.neg` markers are tiny and not counted against the cap — their count is naturally bounded by the user's actively-viewed records. Filesystem mutations route through `IFileSystem`; size and mtime queries (which the port does not expose) use `std::filesystem` directly inside the adapter. The persistent tier is **fire-and-forget on the way down** — every adapter operation swallows I/O errors so a flaky or full disk never breaks the preview path.
- **Persistent HTTP session** (`CprHttpClient`). The adapter owns one long-lived `cpr::Session` (libcurl easy handle) for the lifetime of the app. Per-request configuration is limited to `SetUrl(...)`; headers, timeout, and redirect policy are configured once in the constructor. Default **`Accept: */*`** keeps JSON responses and raw image bodies working on the same session (avoid tying every GET to `application/json`). libcurl's connection pool keeps the TLS connection to each host warm, so repeat calls to `api.scryfall.com`, `api.pokemontcg.io`, `db.ygoprodeck.com`, `yugipedia.com`, and `ms.yugipedia.com` skip the TLS handshake. A `std::mutex` serializes callers — libcurl easy handles are not thread-safe, and the preview pipeline is single-flight per panel anyway.
+- **Persistent HTTP session** (`CprHttpClient`). The adapter owns one long-lived `cpr::Session` (libcurl easy handle) for the lifetime of the app. Per-request configuration is limited to `SetUrl(...)`; headers, timeout, and redirect policy are configured once in the constructor. Default **`Accept: */*`** keeps JSON responses and raw image bodies working on the same session (avoid tying every GET to `application/json`). libcurl's connection pool keeps the TLS connection to each host warm, so repeat calls to `api.scryfall.com`, `api.pokemontcg.io`, `db.ygoprodeck.com`, `yugipedia.com`, `ms.yugipedia.com`, `digimoncard.io`, and `images.digimoncard.io` skip the TLS handshake. A `std::mutex` serializes callers — libcurl easy handles are not thread-safe, and the preview pipeline is single-flight per panel anyway.

 `CardPreviewService` consults the tiers in order **memory → disk → source/HTTP**. On a disk hit (positive *or* negative) the entry is promoted into the in-memory LRU so the next click on the same row never re-touches the disk cache. On HTTP success the bytes are written through to both tiers in one shot. On a `NotFound` source error the **negative** marker is written through to both tiers; on `Transient` source errors nothing is written, so the next selection retries cleanly.

-The combined effect on the preview path: first selection of a previously-unseen card pays one TLS handshake per *new* host this session (typically two hops for Yu-Gi-Oh!: `yugipedia.com` for the API, `ms.yugipedia.com` for the image), each subsequent fresh card on the same host skips the handshake, any re-selection of an already-viewed card is instant, after the first run with the disk cache populated **even a fresh app launch is decode-only for previously-seen cards** until eviction or a manual cache clear, and **records the upstream cleanly has no image for** stay "instant card-back" across restarts instead of re-paying the lookup every launch. Editing a lookup-relevant field of a record (name, set, setNo, or for Yu-Gi-Oh! the rarity / edition packed into setNo) changes the cache key automatically, so a fresh resolution attempt happens on the next click.
+The combined effect on the preview path: first selection of a previously-unseen card pays one TLS handshake per *new* host this session (typically two hops for Yu-Gi-Oh!: `yugipedia.com` for the API, `ms.yugipedia.com` for the image; Digi-Battle often hits `images.digimoncard.io` only when `setNo` is already known), each subsequent fresh card on the same host skips the handshake, any re-selection of an already-viewed card is instant, after the first run with the disk cache populated **even a fresh app launch is decode-only for previously-seen cards** until eviction or a manual cache clear, and **records the upstream cleanly has no image for** stay "instant card-back" across restarts instead of re-paying the lookup every launch. Editing a lookup-relevant field of a record (name, set, setNo, or for Yu-Gi-Oh! the rarity / edition packed into setNo) changes the cache key automatically, so a fresh resolution attempt happens on the next click.

 To clear the persistent cache (for example to recover from a bad upstream image), delete the `<exeDir>/.cache/preview-cache/` subdirectory or the umbrella `<exeDir>/.cache/` folder. Note: the in-app "Reset" / data-storage-relocation flow does **not** touch this directory — the cache is install-scoped, not collection-scoped, so it is preserved across data-dir moves and only cleared by deleting the directory above explicitly (or by reinstalling / relocating the executable).

@@ -109,7 +260,9 @@ Fallback card-back sources (`BaseSelectedCardPanel`; Magic/Pokémon URLs match C

 - Magic: `https://gamepedia.cursecdn.com/mtgsalvation_gamepedia/f/f8/Magic_card_back.jpg`
 - Pokémon: `https://archives.bulbagarden.net/media/upload/1/17/Cardback.jpg`
+- Japanese Pokémon: `https://archives.bulbagarden.net/media/upload/2/2a/TCG_Card_Back_Japanese.jpg`
 - Yu-Gi-Oh!: Yugipedia English TCG back — try `https://ms.yugipedia.com/thumb/e/e5/Back-EN.png/250px-Back-EN.png`, then `https://ms.yugipedia.com/e/e5/Back-EN.png`; if both fail, load `<exeDir>/assets/ygo_card_back.png` (shipped from `ui_wx/assets/ygo_card_back.png` at link time). `fallbackImageUrlForGame(Game::YuGiOh)` returns the thumbnail URL for helpers that only consult a single string.
+- Digimon (Digi-Battle): no stable public back URL; load `<exeDir>/assets/digibattle99_card_back.png` (shipped from `ui_wx/assets/digibattle99_card_back.png` at link time).

 If a game module does not provide a preview source (`cardPreviewSource() == nullptr`), preview registration is skipped and the UI behaves as "no remote preview API available."

@@ -120,6 +273,6 @@ All source types return `Result<T, std::string>` errors so failures cross bounda
 - info API failures (bad set payload, schema mismatch, endpoint/network failure), and
 - asset API failures (query mismatch, no matching card, missing image fields, image download failure).

-When previews fail, verify request construction first (name sanitization, number normalization, percent encoding), then verify response shape assumptions: Scryfall (`data`, `image_uris`), Pokemon (`data`, `images.large`/`images.small`; auto-detect also needs `name`, `number`, `rarity`, and `set.id` on each matching row), Yu-Gi-Oh! Yugipedia (`query.pages.<id>.imageinfo[0].url` per filename, missing files tagged `"missing": ""`), Yu-Gi-Oh! YGOPRODeck fallback (`data`, `name`, `card_images`). If the UI fallback path succeeds (network card-back and/or bundled PNG), the panel shows the card-back image and the inline label `(image preview unavailable)`; only if every fallback fails does the preview stay empty with status text.
+When previews fail, verify request construction first (name sanitization, number normalization, percent encoding), then verify response shape assumptions: Scryfall (`data`, `image_uris`), Pokemon (`data`, `images.large`/`images.small`; auto-detect also needs `name`, `number`, `rarity`, and `set.id` on each matching row), Yu-Gi-Oh! Yugipedia (`query.pages.<id>.imageinfo[0].url` per filename, missing files tagged `"missing": ""`), Yu-Gi-Oh! YGOPRODeck fallback (`data`, `name`, `card_images`), Digi-Battle digimoncard.io (top-level array with `name`/`id`/`set_name`; CDN `images.digimoncard.io/images/cards/{id}.jpg`), Japanese Pokémon TCGdex (`image` base + `/high.png`; set-detail `cards[]` with `localId`). If the UI fallback path succeeds (network card-back and/or bundled PNG), the panel shows the card-back image and the inline label `(image preview unavailable)`; only if every fallback fails does the preview stay empty with status text.

 For Yu-Gi-Oh! specifically, when a printing shows the wrong art compared with Yugipedia’s gallery, debug in this order: (1) verify the candidate list via `YuGiOhCardPreviewSource::buildCandidateFilenames(...)` against the actual file names on Yugipedia’s `Card_Gallery:<Card>` page; (2) confirm the dialog rarity name maps to the expected short code in `ygoRarityShortCode(...)` / `rarityCodeFor(...)` (extend the mapping when a new rarity surfaces); (3) confirm the `firstEdition` flag matches the printed edition stamp — the candidate ordering puts the printed edition first.
@@ -68,7 +68,7 @@ There is no explicit "refresh" or "invalidate" API on `CardPreviewService` — b

 ### 1. Edit-driven invalidation (record changed → fresh lookup, automatic)

-The cache key for the preview path is `(game, name, setId, setNo)`. For Yu-Gi-Oh! the third slot also encodes rarity and edition, packed by `YuGiOhSelectedCardPanel::previewKey()` as `<setNo>||<rarity>||<1E|UE>`. The user editing **any** lookup-relevant field of a card record produces a **different cache key** for the resulting selection, which means:
+The cache key for the preview path is `(game, name, setId, setNo)`. For Yu-Gi-Oh! the third slot also encodes rarity and edition, packed by `YuGiOhSelectedCardPanel::previewKey()` as `<setNo>||<rarity>||<1E|UE>`. For Digimon Digi-Battle the middle slot is the pack **display name** (`Set.name`), not the slug id, so `pack=` search and the CDN path stay aligned. The user editing **any** lookup-relevant field of a card record produces a **different cache key** for the resulting selection, which means:

 - Memory and disk lookups for the new key **miss** the old entry (positive or negative).
 - A fresh `ICardPreviewSource::fetchImageUrl` call runs.
@@ -113,7 +113,7 @@ Automated tests primarily cover `core/` and infrastructure adapters. UI testing

 `cpr` builds as shared, so `build/bin` contains runtime DLLs (for example `libcpr.dll`, `libcurl.dll`, `libzlib.dll`) next to `ccm3.exe`.

-For MinGW/MSYS2 builds, UCRT runtime DLLs must be available (typically via MSYS2 UCRT64 `bin` on `PATH`).
+For MinGW/MSYS2 builds, the `ccm` POST_BUILD step also copies `libstdc++-6.dll`, `libgcc_s_seh-1.dll`, and `libwinpthread-1.dll` from the compiler’s `bin/` next to `ccm3.exe`. That keeps Explorer / IDE launches on the same UCRT runtime used to build (avoids “Entry Point Not Found” / `__emutls_v._ZSt11__once_call` against `libcpr.dll` when a different `libstdc++` is on `PATH`).

 ## Troubleshooting

@@ -11,7 +11,7 @@
 - `image_service_tests.cpp` — `ImageService` (uses inline `RecordingImageStore` fake).
 - `collection_service_tests.cpp` — `CollectionService<MagicCard>` (uses inline `InMemoryRepo` + `StubImageStore`).
 - `config_service_tests.cpp` — `ConfigService` against `InMemoryFileSystem`.
- `json_collection_repository_tests.cpp`, `json_set_repository_tests.cpp` — repository round-trips against `InMemoryFileSystem`.
+- `json_collection_repository_tests.cpp`, `json_set_repository_tests.cpp` — repository round-trips against `InMemoryFileSystem`. Set-repo cases also pin Pokemon `sets-west.json` / `sets-asia.json` paths and migrate-on-load from legacy `pokemon/sets.json` / `pokemonjp/sets.json`.
 - `local_image_store_tests.cpp` — `LocalImageStore` against `InMemoryFileSystem` + `ConfigService`: `copyIn` (extension preserved, missing source errors), `remove` (existing file deleted; absent path is a no-op), `resolvePath` layout under `dataStorage/<game>/images/`.
 - `set_service_tests.cpp` — `SetService` with `FakeSetSource` + `InMemSetRepo`.
 - `magic_set_source_tests.cpp` — `MagicSetSource::parseResponse` (Scryfall mapping). Drives `fetchAll` via `FixedHttpClient` fake.
@@ -21,9 +21,11 @@
 - `std_file_system_tests.cpp` — `StdFileSystem` directly (`exists`, `isDirectory`, `ensureDirectory`, `readText`, `writeText`, `copyFile`, `remove`, `listDirectory`) under a unique `temp_directory_path()/ccm_std_fs_test_*` directory per case; scope matches the real-disk exception documented for preview-cache tests.
 - `pokemon_set_source_tests.cpp` — `PokemonSetSource::parseResponse` (api.pokemontcg.io/v2/sets shape — `data[].id`, `name`, `releaseDate` already in `YYYY/MM/DD`) + sort-by-release-date stability. Drives `fetchAll` via `FixedHttpClient` and asserts the public endpoint URL.
 - `pokemon_card_preview_source_tests.cpp` — `PokemonCardPreviewSource::buildSearchUrl` (percent-encoded `name:` / `set.id:` / `number:` triple, with collector-number `4/102` -> `4` normalization) + `parseResponse` (`data[0].images.large` with `images.small` fallback). Drives `fetchImageUrl` via `FixedHttpClient`.
+- `digibattle99_set_source_tests.cpp` — `DigiBattle99SetSource::parseResponse` derives unique packs from digimoncard.io search arrays, slugifies `Set.id`, applies curated release dates, and sorts chronologically. Drives `fetchAll` via `FixedHttpClient`.
+- `digibattle99_card_preview_source_tests.cpp` — CDN image URL from `setNo`, search URL encoding (`series`/`n`/`pack`/`card`), `parseImageUrlFromSearch` NotFound vs Transient, and auto-detect print variants. Drives `fetchImageUrl` / `detectPrintVariants` via `FixedHttpClient`.
 - `yugioh_set_source_tests.cpp` — `YuGiOhSetSource::parseResponse` for YGOPRODeck `cardsets.php` (`set_code`, `set_name`, `tcg_date`) including `YYYY-MM-DD` -> `YYYY/MM/DD` rewrite and chronological sort checks.
 - `yugioh_set_lookup_tests.cpp` — `lookupYuGiOhSetByShorthand` / helpers in `ccm/util/YuGiOhSetLookup.hpp` (trim, ASCII case-fold, exact `Set.id` match, not-found vs ambiguous).
- `game_module_tests.cpp` — smoke tests that each concrete `IGameModule` (Magic / Pokemon / Yu-Gi-Oh) reports stable `id()`, `dirName()`, `displayName()`, and a non-null `cardPreviewSource()` when constructed with a noop `IHttpClient`.
+- `game_module_tests.cpp` — smoke tests that each concrete `IGameModule` (Magic / Pokemon / Yu-Gi-Oh / DigiBattle99) reports stable `id()`, `dirName()`, `displayName()`, and a non-null `cardPreviewSource()` when constructed with a noop `IHttpClient`.
 - `yugioh_card_preview_source_tests.cpp` — `YuGiOhCardPreviewSource` Yugipedia + YGOPRODeck unit coverage. Helper-level tests pin down `normalizeName` (whitespace + Yugipedia-policy punctuation stripping), `ygoRarityShortCode` + `rarityCodeFor` (CCM3 dialog rarity names → canonical short codes used by both the YGO overview table and Yugipedia filename generation; unknown rarity falls through), `extractSetCode` (`LOB-005` / `LOB-DE005` → `LOB`), `buildCandidateFilenames` (printed-edition first, EN/NA/EU/AU + png/jpg, rarity-less fallback round, empty list when slug or set code is missing), `buildYugipediaQueryUrl` (single `titles=File:A|File:B` batch, percent-encoded), and `parseYugipediaResponse` (returns the URL of the highest-priority filename that resolved, errors when every candidate is `missing`). End-to-end `fetchImageUrl` cases use a `RoutingHttpClient` to verify Yugipedia is queried first and the per-printing scan is returned when found, that empty/error Yugipedia responses fall through to the YGOPRODeck `card_images[0]` fallback, that the YGOPRODeck error is propagated when both upstreams fail, and that an empty `setNo` skips Yugipedia entirely. `parseFirstPrint` preferred-`set_name` lookup is also covered for the auto-detect path. `parsePrintVariants` includes synthetic scenarios aligned with the `yugioh_same_card_set_variant_tests` fixture (dual-rarity vs multi-code within one display set, duplicate suppression, and no merge across unrelated `set_name` rows when the picker label matches nothing).
 - `card_sorter_tests.cpp` — `sortMagicCards` / `sortPokemonCards` per-column behavior. Pin-down tests for `byField`-equivalent semantics: case-insensitive strings, chronological set sort via `set.releaseDate`, numeric `amount`, `false < true` boolean order, stable composition (sort by name then by set keeps inner-name order). Update this file whenever you add a new column / sort key.
 - `card_filter_tests.cpp` — `matchesMagicFilter` / `matchesPokemonFilter` / `matchesYuGiOhFilter` row-matcher behavior. Pin-down tests for `applyFilter`-equivalent semantics: case-insensitive substring match across `tableFields` valueKeys (name, set.name, language, condition, amount-as-string, note; Pokemon adds `setNo`; Yu-Gi-Oh adds `setNo` + `rarity`), boolean flag columns intentionally excluded, empty filter matches everything. Update this file whenever you add a new searchable column.
@@ -21,6 +21,11 @@ add_executable(ccm_core_tests
    std_file_system_tests.cpp
    pokemon_set_source_tests.cpp
    pokemon_card_preview_source_tests.cpp
+    digibattle99_set_source_tests.cpp
+    digibattle99_card_preview_source_tests.cpp
+    japanese_pokemon_en_catalog_tests.cpp
+    japanese_pokemon_set_source_tests.cpp
+    japanese_pokemon_card_preview_source_tests.cpp
    icard_preview_source_tests.cpp
    yugioh_set_source_tests.cpp
    yugioh_set_lookup_tests.cpp
@@ -6,6 +6,8 @@
 #include <doctest/doctest.h>

 #include "ccm/domain/Enums.hpp"
+#include "ccm/domain/DigiBattle99Card.hpp"
+#include "ccm/domain/JapanesePokemonCard.hpp"
 #include "ccm/domain/MagicCard.hpp"
 #include "ccm/domain/PokemonCard.hpp"
 #include "ccm/domain/YuGiOhCard.hpp"
@@ -185,6 +187,15 @@ TEST_SUITE("CardFilter::matchesPokemonFilter") {
    TEST_CASE("empty filter matches everything") {
        CHECK(matchesPokemonFilter(pc("Charizard", "Base Set"), ""));
    }
+
+    TEST_CASE("region is searchable") {
+        PokemonCard c = pc("Charizard", "Base Set");
+        c.region = PokemonRegion::Asia;
+        CHECK(matchesPokemonFilter(c, "asia"));
+        CHECK_FALSE(matchesPokemonFilter(c, "west"));
+        c.region = PokemonRegion::West;
+        CHECK(matchesPokemonFilter(c, "west"));
+    }
 }

 TEST_SUITE("CardFilter::matchesYuGiOhFilter") {
@@ -238,3 +249,77 @@ TEST_SUITE("CardFilter::matchesYuGiOhFilter") {
        CHECK_FALSE(matchesYuGiOhFilter(c, "zzznomatch"));
    }
 }
+
+TEST_SUITE("CardFilter::matchesDigiBattle99Filter") {
+    TEST_CASE("matches by name and set.name") {
+        DigiBattle99Card c;
+        c.name = "Agumon";
+        c.set.name = "Series 1 Starter Set";
+        CHECK(matchesDigiBattle99Filter(c, "agu"));
+        CHECK(matchesDigiBattle99Filter(c, "STARTER"));
+        CHECK_FALSE(matchesDigiBattle99Filter(c, "greymon"));
+    }
+
+    TEST_CASE("includes setNo in searchable columns") {
+        DigiBattle99Card c;
+        c.name = "Agumon";
+        c.set.name = "Series 1 Starter Set";
+        c.setNo = "ST-01";
+        CHECK(matchesDigiBattle99Filter(c, "st-01"));
+        CHECK(matchesDigiBattle99Filter(c, "ST-"));
+    }
+
+    TEST_CASE("empty filter matches everything") {
+        DigiBattle99Card c;
+        c.name = "Agumon";
+        CHECK(matchesDigiBattle99Filter(c, ""));
+    }
+
+    TEST_CASE("boolean flag columns are not matched") {
+        DigiBattle99Card c;
+        c.name = "Agumon";
+        c.holo = true;
+        c.firstEdition = true;
+        c.signed_ = true;
+        c.altered = true;
+        CHECK_FALSE(matchesDigiBattle99Filter(c, "true"));
+        CHECK(matchesDigiBattle99Filter(c, "agu"));
+    }
+}
+
+TEST_SUITE("CardFilter::matchesJapanesePokemonFilter") {
+    TEST_CASE("matches by name and set.name") {
+        JapanesePokemonCard c;
+        c.name = "Charmander";
+        c.set.name = "Expansion Pack";
+        CHECK(matchesJapanesePokemonFilter(c, "char"));
+        CHECK(matchesJapanesePokemonFilter(c, "EXPANSION"));
+        CHECK_FALSE(matchesJapanesePokemonFilter(c, "pikachu"));
+    }
+
+    TEST_CASE("includes setNo in searchable columns") {
+        JapanesePokemonCard c;
+        c.name = "Charmander";
+        c.set.name = "Expansion Pack";
+        c.setNo = "001";
+        CHECK(matchesJapanesePokemonFilter(c, "001"));
+        CHECK(matchesJapanesePokemonFilter(c, "00"));
+    }
+
+    TEST_CASE("empty filter matches everything") {
+        JapanesePokemonCard c;
+        c.name = "Charmander";
+        CHECK(matchesJapanesePokemonFilter(c, ""));
+    }
+
+    TEST_CASE("boolean flag columns are not matched") {
+        JapanesePokemonCard c;
+        c.name = "Charmander";
+        c.holo = true;
+        c.firstEdition = true;
+        c.signed_ = true;
+        c.altered = true;
+        CHECK_FALSE(matchesJapanesePokemonFilter(c, "true"));
+        CHECK(matchesJapanesePokemonFilter(c, "char"));
+    }
+}
@@ -2,10 +2,12 @@

 #include "ccm/games/IGameModule.hpp"
 #include "ccm/ports/ICardPreviewSource.hpp"
+#include "ccm/ports/IFileSystem.hpp"
 #include "ccm/ports/IHttpClient.hpp"
 #include "ccm/ports/IPreviewByteCache.hpp"
 #include "ccm/services/CardPreviewService.hpp"

+#include <filesystem>
 #include <optional>
 #include <string>
 #include <unordered_map>
@@ -130,6 +132,50 @@ public:
    void storeNegative(std::string_view) override {}
 };

+class MemoryFileSystem final : public IFileSystem {
+public:
+    std::unordered_map<std::string, std::string> files;
+
+    [[nodiscard]] bool exists(const std::filesystem::path& p) const override {
+        return files.contains(p.generic_string());
+    }
+    [[nodiscard]] bool isDirectory(const std::filesystem::path&) const override {
+        return false;
+    }
+    Result<void> ensureDirectory(const std::filesystem::path&) override {
+        return Result<void>::ok();
+    }
+    Result<std::string> readText(const std::filesystem::path& p) override {
+        auto it = files.find(p.generic_string());
+        if (it == files.end()) {
+            return Result<std::string>::err("Unable to open " + p.generic_string());
+        }
+        return Result<std::string>::ok(it->second);
+    }
+    Result<void> writeText(const std::filesystem::path& p, std::string_view contents) override {
+        files[p.generic_string()] = std::string(contents);
+        return Result<void>::ok();
+    }
+    Result<void> copyFile(const std::filesystem::path& from,
+                          const std::filesystem::path& to,
+                          bool) override {
+        auto it = files.find(from.generic_string());
+        if (it == files.end()) {
+            return Result<void>::err("missing source");
+        }
+        files[to.generic_string()] = it->second;
+        return Result<void>::ok();
+    }
+    Result<void> remove(const std::filesystem::path& p) override {
+        files.erase(p.generic_string());
+        return Result<void>::ok();
+    }
+    Result<std::vector<std::filesystem::path>> listDirectory(
+        const std::filesystem::path&) override {
+        return Result<std::vector<std::filesystem::path>>::ok({});
+    }
+};
+
 // Minimal IGameModule fake that exposes a configurable preview source.
 class FakeGameModule final : public IGameModule {
 public:
@@ -232,6 +278,26 @@ TEST_SUITE("CardPreviewService::fetchPreviewBytes") {
        CHECK(out.isErr());
        CHECK(out.error() == "net down");
    }
+
+    TEST_CASE("asset: preview loads bytes from configured asset root") {
+        FakeSource source;
+        source.url = "asset:pokemon_jp_classic/TamamushiCG/016.jpg";
+        FakeGameModule module;
+        module.gameId = Game::JapanesePokemon;
+        module.preview = &source;
+
+        FixedHttpClient http;
+        MemoryFileSystem fs;
+        fs.files["assets/pokemon_jp_classic/TamamushiCG/016.jpg"] = "JPEG-bytes";
+
+        CardPreviewService svc{http, nullptr, &fs, "assets"};
+        svc.registerModule(module);
+
+        const auto out = svc.fetchPreviewBytes(Game::JapanesePokemon, "Erika", "TamamushiCG", "016");
+        REQUIRE(out.isOk());
+        CHECK(out.value() == "JPEG-bytes");
+        CHECK(http.calls == 0);
+    }
 }

 TEST_SUITE("CardPreviewService caching") {
@@ -6,6 +6,8 @@
 #include <doctest/doctest.h>

 #include "ccm/domain/Enums.hpp"
+#include "ccm/domain/DigiBattle99Card.hpp"
+#include "ccm/domain/JapanesePokemonCard.hpp"
 #include "ccm/domain/MagicCard.hpp"
 #include "ccm/domain/PokemonCard.hpp"
 #include "ccm/domain/YuGiOhCard.hpp"
@@ -94,6 +96,54 @@ YuGiOhCard yc(std::uint32_t id, std::string name,
    return c;
 }

+DigiBattle99Card db(std::uint32_t id, std::string name,
+                    std::string setName, std::string releaseDate,
+                    std::uint8_t amount = 1,
+                    bool holo = false, bool firstEdition = false,
+                    bool sgnd = false, bool altered = false,
+                    Language lang = Language::English,
+                    Condition cond = Condition::NearMint,
+                    std::string note = "") {
+    DigiBattle99Card c;
+    c.id = id;
+    c.name = std::move(name);
+    c.set.name = std::move(setName);
+    c.set.releaseDate = std::move(releaseDate);
+    c.amount = amount;
+    c.holo = holo;
+    c.firstEdition = firstEdition;
+    c.signed_ = sgnd;
+    c.altered = altered;
+    c.language = lang;
+    c.condition = cond;
+    c.note = std::move(note);
+    return c;
+}
+
+JapanesePokemonCard jp(std::uint32_t id, std::string name,
+                       std::string setName, std::string releaseDate,
+                       std::uint8_t amount = 1,
+                       bool holo = false, bool firstEdition = false,
+                       bool sgnd = false, bool altered = false,
+                       Language lang = Language::Japanese,
+                       Condition cond = Condition::NearMint,
+                       std::string note = "") {
+    JapanesePokemonCard c;
+    c.id = id;
+    c.name = std::move(name);
+    c.set.name = std::move(setName);
+    c.set.releaseDate = std::move(releaseDate);
+    c.amount = amount;
+    c.holo = holo;
+    c.firstEdition = firstEdition;
+    c.signed_ = sgnd;
+    c.altered = altered;
+    c.language = lang;
+    c.condition = cond;
+    c.note = std::move(note);
+    return c;
+}
+
 std::vector<std::uint32_t> ids(const std::vector<MagicCard>& v) {
    std::vector<std::uint32_t> out;
    out.reserve(v.size());
@@ -115,6 +165,20 @@ std::vector<std::uint32_t> ids(const std::vector<YuGiOhCard>& v) {
    return out;
 }

+std::vector<std::uint32_t> ids(const std::vector<DigiBattle99Card>& v) {
+    std::vector<std::uint32_t> out;
+    out.reserve(v.size());
+    for (const auto& c : v) out.push_back(c.id);
+    return out;
+}
+
+std::vector<std::uint32_t> ids(const std::vector<JapanesePokemonCard>& v) {
+    std::vector<std::uint32_t> out;
+    out.reserve(v.size());
+    for (const auto& c : v) out.push_back(c.id);
+    return out;
+}
+
 }  // namespace

 TEST_SUITE("CardSorter - Magic columns") {
@@ -451,3 +515,67 @@ TEST_SUITE("CardSorter - YuGiOh columns") {
        CHECK(ids(v) == std::vector<std::uint32_t>{3, 1, 2});
    }
 }
+
+TEST_SUITE("CardSorter - DigiBattle99 columns") {
+    TEST_CASE("Holo and FirstEdition sort false before true") {
+        std::vector<DigiBattle99Card> v = {
+            db(1, "a", "X", "2000/01/01", 1, /*holo=*/true, /*first=*/false),
+            db(2, "b", "X", "2000/01/01", 1, /*holo=*/false, /*first=*/true),
+            db(3, "c", "X", "2000/01/01", 1, /*holo=*/false, /*first=*/false),
+        };
+        sortDigiBattle99Cards(v, DigiBattle99SortColumn::Holo, /*ascending=*/true);
+        CHECK(ids(v) == std::vector<std::uint32_t>{2, 3, 1});
+        sortDigiBattle99Cards(v, DigiBattle99SortColumn::FirstEdition, /*ascending=*/true);
+        CHECK(ids(v) == std::vector<std::uint32_t>{3, 1, 2});
+    }
+
+    TEST_CASE("Set column sorts by release date") {
+        std::vector<DigiBattle99Card> v = {
+            db(1, "x", "Late", "2001/01/01"),
+            db(2, "y", "Early", "1999/06/01"),
+        };
+        sortDigiBattle99Cards(v, DigiBattle99SortColumn::SetReleaseDate, /*ascending=*/true);
+        CHECK(ids(v) == std::vector<std::uint32_t>{2, 1});
+    }
+
+    TEST_CASE("Name sorts case-insensitively") {
+        std::vector<DigiBattle99Card> v = {
+            db(1, "greymon", "X", "2000/01/01"),
+            db(2, "Agumon", "X", "2000/01/01"),
+        };
+        sortDigiBattle99Cards(v, DigiBattle99SortColumn::Name, /*ascending=*/true);
+        CHECK(ids(v) == std::vector<std::uint32_t>{2, 1});
+    }
+}
+
+TEST_SUITE("CardSorter - JapanesePokemon columns") {
+    TEST_CASE("Holo and FirstEdition sort false before true") {
+        std::vector<JapanesePokemonCard> v = {
+            jp(1, "a", "X", "2000/01/01", 1, /*holo=*/true, /*first=*/false),
+            jp(2, "b", "X", "2000/01/01", 1, /*holo=*/false, /*first=*/true),
+            jp(3, "c", "X", "2000/01/01", 1, /*holo=*/false, /*first=*/false),
+        };
+        sortJapanesePokemonCards(v, JapanesePokemonSortColumn::Holo, /*ascending=*/true);
+        CHECK(ids(v) == std::vector<std::uint32_t>{2, 3, 1});
+        sortJapanesePokemonCards(v, JapanesePokemonSortColumn::FirstEdition, /*ascending=*/true);
+        CHECK(ids(v) == std::vector<std::uint32_t>{3, 1, 2});
+    }
+
+    TEST_CASE("Set column sorts by release date") {
+        std::vector<JapanesePokemonCard> v = {
+            jp(1, "x", "Late", "2023/03/10"),
+            jp(2, "y", "Early", "1996/10/20"),
+        };
+        sortJapanesePokemonCards(v, JapanesePokemonSortColumn::SetReleaseDate, /*ascending=*/true);
+        CHECK(ids(v) == std::vector<std::uint32_t>{2, 1});
+    }
+
+    TEST_CASE("Name sorts case-insensitively") {
+        std::vector<JapanesePokemonCard> v = {
+            jp(1, "charmander", "X", "1996/10/20"),
+            jp(2, "Bulbasaur", "X", "1996/10/20"),
+        };
+        sortJapanesePokemonCards(v, JapanesePokemonSortColumn::Name, /*ascending=*/true);
+        CHECK(ids(v) == std::vector<std::uint32_t>{2, 1});
+    }
+}
@@ -0,0 +1,179 @@
+#include <doctest/doctest.h>
+
+#include "ccm/games/digibattle99/DigiBattle99CardPreviewSource.hpp"
+#include "ccm/ports/IHttpClient.hpp"
+
+#include <string>
+
+using namespace ccm;
+
+namespace {
+
+class FixedHttpClient final : public IHttpClient {
+public:
+    std::string lastUrl;
+    std::string body;
+    bool ok = true;
+    Result<std::string> get(std::string_view url) override {
+        lastUrl = std::string(url);
+        return ok ? Result<std::string>::ok(body)
+                  : Result<std::string>::err("offline");
+    }
+};
+
+}  // namespace
+
+TEST_SUITE("DigiBattle99CardPreviewSource::normalizeCardNumber") {
+    TEST_CASE("uppercases alphabetic prefix without zero-padding") {
+        CHECK(DigiBattle99CardPreviewSource::normalizeCardNumber("bo-88") == "BO-88");
+        CHECK(DigiBattle99CardPreviewSource::normalizeCardNumber("st-01") == "ST-01");
+        CHECK(DigiBattle99CardPreviewSource::normalizeCardNumber("  MO-06 ") == "MO-06");
+    }
+}
+
+TEST_SUITE("DigiBattle99CardPreviewSource::buildImageUrl") {
+    TEST_CASE("builds CDN jpeg URL from card id") {
+        CHECK(DigiBattle99CardPreviewSource::buildImageUrl("ST-01") ==
+              "https://images.digimoncard.io/images/cards/ST-01.jpg");
+        CHECK(DigiBattle99CardPreviewSource::buildImageUrl("bo-115") ==
+              "https://images.digimoncard.io/images/cards/BO-115.jpg");
+    }
+}
+
+TEST_SUITE("DigiBattle99CardPreviewSource::buildSearchUrl") {
+    TEST_CASE("percent-encodes name pack and series") {
+        const auto url = DigiBattle99CardPreviewSource::buildSearchUrl(
+            "Agumon", "Series 1 Starter Set", "");
+        CHECK(url.find("https://digimoncard.io/api-public/search.php?series=") == 0);
+        CHECK(url.find("Digimon%20Digi-Battle%20Card%20Game") != std::string::npos);
+        CHECK(url.find("&n=Agumon") != std::string::npos);
+        CHECK(url.find("&pack=Series%201%20Starter%20Set") != std::string::npos);
+        CHECK(url.find("&card=") == std::string::npos);
+    }
+
+    TEST_CASE("includes card= when setNo is present") {
+        const auto url = DigiBattle99CardPreviewSource::buildSearchUrl(
+            "Agumon", "Series 1 Starter Set", "st-01");
+        CHECK(url.find("&card=ST-01") != std::string::npos);
+    }
+
+    TEST_CASE("empty pack omits pack clause") {
+        const auto url =
+            DigiBattle99CardPreviewSource::buildSearchUrl("Agumon", "", "ST-01");
+        CHECK(url.find("&pack=") == std::string::npos);
+        CHECK(url.find("&card=ST-01") != std::string::npos);
+    }
+}
+
+TEST_SUITE("DigiBattle99CardPreviewSource::parseImageUrlFromSearch") {
+    TEST_CASE("returns CDN URL for first exact name match") {
+        const std::string json = R"([
+            {"name":"Agumon","id":"ST-01","set_name":["Series 1 Starter Set"]},
+            {"name":"Agumon","id":"BO-115","set_name":["Series 1 Booster Pack"]}
+        ])";
+        const auto out =
+            DigiBattle99CardPreviewSource::parseImageUrlFromSearch(json, "Agumon");
+        REQUIRE(out.isOk());
+        CHECK(out.value() == "https://images.digimoncard.io/images/cards/ST-01.jpg");
+    }
+
+    TEST_CASE("empty array is NotFound") {
+        const auto out =
+            DigiBattle99CardPreviewSource::parseImageUrlFromSearch("[]", "Agumon");
+        REQUIRE(out.isErr());
+        CHECK(out.error().kind == PreviewLookupError::Kind::NotFound);
+    }
+
+    TEST_CASE("API error object is NotFound") {
+        const auto out = DigiBattle99CardPreviewSource::parseImageUrlFromSearch(
+            R"({"error":"No cards found for this search."})", "Agumon");
+        REQUIRE(out.isErr());
+        CHECK(out.error().kind == PreviewLookupError::Kind::NotFound);
+    }
+
+    TEST_CASE("non-array is Transient") {
+        const auto out =
+            DigiBattle99CardPreviewSource::parseImageUrlFromSearch(R"({"meta":{}})", "Agumon");
+        REQUIRE(out.isErr());
+        CHECK(out.error().kind == PreviewLookupError::Kind::Transient);
+    }
+
+    TEST_CASE("malformed JSON is Transient") {
+        const auto out =
+            DigiBattle99CardPreviewSource::parseImageUrlFromSearch("{not json", "Agumon");
+        REQUIRE(out.isErr());
+        CHECK(out.error().kind == PreviewLookupError::Kind::Transient);
+    }
+}
+
+TEST_SUITE("DigiBattle99CardPreviewSource::fetchImageUrl") {
+    TEST_CASE("setNo present skips HTTP and returns CDN URL") {
+        FixedHttpClient http;
+        DigiBattle99CardPreviewSource src{http};
+        const auto out = src.fetchImageUrl("Agumon", "Series 1 Starter Set", "st-01");
+        REQUIRE(out.isOk());
+        CHECK(out.value() == "https://images.digimoncard.io/images/cards/ST-01.jpg");
+        CHECK(http.lastUrl.empty());
+    }
+
+    TEST_CASE("empty setNo searches and parses") {
+        FixedHttpClient http;
+        http.body = R"([{"name":"Agumon","id":"ST-01","set_name":["Series 1 Starter Set"]}])";
+        DigiBattle99CardPreviewSource src{http};
+        const auto out = src.fetchImageUrl("Agumon", "Series 1 Starter Set", "");
+        REQUIRE(out.isOk());
+        CHECK(out.value() == "https://images.digimoncard.io/images/cards/ST-01.jpg");
+        CHECK(http.lastUrl.find("search.php") != std::string::npos);
+        CHECK(http.lastUrl.find("n=Agumon") != std::string::npos);
+    }
+
+    TEST_CASE("HTTP failure is Transient") {
+        FixedHttpClient http;
+        http.ok = false;
+        DigiBattle99CardPreviewSource src{http};
+        const auto out = src.fetchImageUrl("Agumon", "Series 1 Starter Set", "");
+        REQUIRE(out.isErr());
+        CHECK(out.error().kind == PreviewLookupError::Kind::Transient);
+    }
+}
+
+TEST_SUITE("DigiBattle99CardPreviewSource::parsePrintVariants") {
+    TEST_CASE("collects distinct card ids for name+pack") {
+        const std::string json = R"([
+            {"name":"Agumon","id":"ST-01","set_name":["Series 1 Starter Set"]},
+            {"name":"Agumon","id":"ST-01","set_name":["Series 1 Starter Set"]},
+            {"name":"Agumon","id":"BO-115","set_name":["Series 1 Booster Pack"]},
+            {"name":"Greymon","id":"ST-02","set_name":["Series 1 Starter Set"]}
+        ])";
+        const auto out = DigiBattle99CardPreviewSource::parsePrintVariants(
+            json, "Series 1 Starter Set", "Agumon");
+        REQUIRE(out.isOk());
+        REQUIRE(out.value().size() == 1);
+        CHECK(out.value()[0].setNo == "ST-01");
+    }
+
+    TEST_CASE("pack miss with exact name returns error") {
+        const std::string json = R"([
+            {"name":"Agumon","id":"BO-115","set_name":["Series 1 Booster Pack"]}
+        ])";
+        const auto out = DigiBattle99CardPreviewSource::parsePrintVariants(
+            json, "Series 1 Starter Set", "Agumon");
+        CHECK(out.isErr());
+    }
+}
+
+TEST_SUITE("DigiBattle99CardPreviewSource::detectPrintVariants") {
+    TEST_CASE("round-trips through FixedHttpClient") {
+        FixedHttpClient http;
+        http.body = R"([
+            {"name":"Agumon","id":"ST-01","set_name":["Series 1 Starter Set"]},
+            {"name":"Agumon","id":"ST-126","set_name":["Series 1 Starter Set"]}
+        ])";
+        DigiBattle99CardPreviewSource src{http};
+        const auto out = src.detectPrintVariants("Agumon", "Series 1 Starter Set");
+        REQUIRE(out.isOk());
+        REQUIRE(out.value().size() == 2);
+        CHECK(out.value()[0].setNo == "ST-01");
+        CHECK(out.value()[1].setNo == "ST-126");
+    }
+}
@@ -0,0 +1,112 @@
+#include <doctest/doctest.h>
+
+#include "ccm/games/digibattle99/DigiBattle99SetSource.hpp"
+#include "ccm/ports/IHttpClient.hpp"
+
+using namespace ccm;
+
+namespace {
+
+class FixedHttpClient final : public IHttpClient {
+public:
+    std::string lastUrl;
+    std::string body;
+    bool ok = true;
+    Result<std::string> get(std::string_view url) override {
+        lastUrl = std::string(url);
+        return ok ? Result<std::string>::ok(body)
+                  : Result<std::string>::err("offline");
+    }
+};
+
+}  // namespace
+
+TEST_SUITE("DigiBattle99SetSource::slugifyPackName") {
+    TEST_CASE("slugifies pack display names") {
+        CHECK(DigiBattle99SetSource::slugifyPackName("Series 1 Starter Set") ==
+              "series-1-starter-set");
+        CHECK(DigiBattle99SetSource::slugifyPackName("Digimon The Movie Promo Cards") ==
+              "digimon-the-movie-promo-cards");
+    }
+}
+
+TEST_SUITE("DigiBattle99SetSource::parseResponse") {
+    TEST_CASE("derives unique packs with curated release dates") {
+        const std::string json = R"([
+            {"name":"Agumon","id":"ST-01","set_name":["Series 1 Starter Set"]},
+            {"name":"MetalGreymon","id":"BO-01","set_name":["Series 1 Booster Pack"]},
+            {"name":"Agumon","id":"ST-126","set_name":["Series 1 Starter Set"]},
+            {"name":"Promo","id":"MO-06","set_name":["Digimon The Movie Promo Cards"]}
+        ])";
+
+        const auto out = DigiBattle99SetSource::parseResponse(json);
+        REQUIRE(out.isOk());
+        REQUIRE(out.value().size() == 3);
+        // Same curated date for Series 1 products → secondary sort by name:
+        // "Booster" before "Starter".
+        CHECK(out.value()[0].id == "series-1-booster-pack");
+        CHECK(out.value()[0].name == "Series 1 Booster Pack");
+        CHECK(out.value()[0].releaseDate == "1999/06/01");
+        CHECK(out.value()[1].id == "series-1-starter-set");
+        CHECK(out.value()[1].name == "Series 1 Starter Set");
+        CHECK(out.value()[1].releaseDate == "1999/06/01");
+        CHECK(out.value()[2].id == "digimon-the-movie-promo-cards");
+        CHECK(out.value()[2].releaseDate == "2000/10/01");
+    }
+
+    TEST_CASE("sorts by release date then name") {
+        const std::string json = R"([
+            {"name":"A","id":"ST-1","set_name":["Street Starter Set 2"]},
+            {"name":"B","id":"ST-2","set_name":["Series 1 Starter Set"]},
+            {"name":"C","id":"ST-3","set_name":["Street Starter Set 1"]}
+        ])";
+        const auto out = DigiBattle99SetSource::parseResponse(json);
+        REQUIRE(out.isOk());
+        REQUIRE(out.value().size() == 3);
+        CHECK(out.value()[0].name == "Series 1 Starter Set");
+        CHECK(out.value()[1].name == "Street Starter Set 1");
+        CHECK(out.value()[2].name == "Street Starter Set 2");
+    }
+
+    TEST_CASE("empty array returns an empty list") {
+        const auto out = DigiBattle99SetSource::parseResponse("[]");
+        REQUIRE(out.isOk());
+        CHECK(out.value().empty());
+    }
+
+    TEST_CASE("non-array object with error is an error") {
+        const auto out = DigiBattle99SetSource::parseResponse(
+            R"({"error":"No cards found for this search."})");
+        CHECK(out.isErr());
+    }
+
+    TEST_CASE("missing top-level array returns an error") {
+        const auto out = DigiBattle99SetSource::parseResponse(R"({"meta":{}})");
+        CHECK(out.isErr());
+    }
+
+    TEST_CASE("invalid JSON returns an error") {
+        const auto out = DigiBattle99SetSource::parseResponse("{not json");
+        CHECK(out.isErr());
+    }
+}
+
+TEST_SUITE("DigiBattle99SetSource::fetchAll") {
+    TEST_CASE("network error is surfaced as a Result error") {
+        FixedHttpClient http;
+        http.ok = false;
+        DigiBattle99SetSource src{http};
+        CHECK(src.fetchAll().isErr());
+    }
+
+    TEST_CASE("network success hits the Digi-Battle search endpoint") {
+        FixedHttpClient http;
+        http.ok = true;
+        http.body = R"([{"name":"Agumon","id":"ST-01","set_name":["Series 1 Starter Set"]}])";
+        DigiBattle99SetSource src{http};
+        const auto out = src.fetchAll();
+        REQUIRE(out.isOk());
+        CHECK(out.value().front().id == "series-1-starter-set");
+        CHECK(http.lastUrl == DigiBattle99SetSource::kEndpoint);
+    }
+}
@@ -1,7 +1,9 @@
 #include <doctest/doctest.h>

 #include "ccm/domain/Configuration.hpp"
+#include "ccm/domain/DigiBattle99Card.hpp"
 #include "ccm/domain/Enums.hpp"
+#include "ccm/domain/JapanesePokemonCard.hpp"
 #include "ccm/domain/MagicCard.hpp"
 #include "ccm/domain/PokemonCard.hpp"
 #include "ccm/domain/YuGiOhCard.hpp"
@@ -23,6 +25,12 @@ TEST_SUITE("domain enums round-trip JSON as strings") {
        nlohmann::json jYgo = "YuGiOh";
        CHECK(jYgo.get<Game>() == Game::YuGiOh);

+        nlohmann::json jDigi = "DigiBattle99";
+        CHECK(jDigi.get<Game>() == Game::DigiBattle99);
+
+        nlohmann::json jJp = "JapanesePokemon";
+        CHECK(jJp.get<Game>() == Game::JapanesePokemon);
+
        nlohmann::json j3 = Theme::Dark;
        CHECK(j3.get<std::string>() == "Dark");
        CHECK(j3.get<Theme>() == Theme::Dark);
@@ -33,11 +41,45 @@ TEST_SUITE("domain enums round-trip JSON as strings") {
        CHECK(l.get<std::string>() == "Japanese");
        CHECK(l.get<Language>() == Language::Japanese);

+        nlohmann::json k = Language::Korean;
+        CHECK(k.get<std::string>() == "Korean");
+        CHECK(k.get<Language>() == Language::Korean);
+
+        nlohmann::json sc = Language::SimplifiedChinese;
+        CHECK(sc.get<std::string>() == "S-Chinese");
+        CHECK(sc.get<Language>() == Language::SimplifiedChinese);
+
+        nlohmann::json tc = Language::TraditionalChinese;
+        CHECK(tc.get<std::string>() == "T-Chinese");
+        CHECK(tc.get<Language>() == Language::TraditionalChinese);
+
+        nlohmann::json legacyChinese = "Chinese";
+        CHECK(legacyChinese.get<Language>() == Language::SimplifiedChinese);
+
        nlohmann::json c = Condition::LightPlayed;
        CHECK(c.get<std::string>() == "LightPlayed");
        CHECK(c.get<Condition>() == Condition::LightPlayed);
    }

+    TEST_CASE("PokemonRegion") {
+        nlohmann::json j = PokemonRegion::Asia;
+        CHECK(j.get<std::string>() == "Asia");
+        CHECK(j.get<PokemonRegion>() == PokemonRegion::Asia);
+
+        nlohmann::json w = "West";
+        CHECK(w.get<PokemonRegion>() == PokemonRegion::West);
+    }
+
+    TEST_CASE("allGames excludes JapanesePokemon but string mapping remains") {
+        for (const auto game : allGames()) {
+            CHECK(game != Game::JapanesePokemon);
+        }
+        CHECK(allGames().size() == 4);
+        CHECK(gameFromString("JapanesePokemon") == Game::JapanesePokemon);
+        CHECK(pokemonBackendGame(PokemonRegion::West) == Game::Pokemon);
+        CHECK(pokemonBackendGame(PokemonRegion::Asia) == Game::JapanesePokemon);
+    }
+
    TEST_CASE("invalid enum string throws") {
        nlohmann::json bad = "Spanglish";
        CHECK_THROWS(bad.get<Language>());
@@ -142,15 +184,93 @@ TEST_SUITE("PokemonCard JSON") {
        c.holo = true;
        c.signed_ = false;
        c.altered = false;
+        c.region = PokemonRegion::West;

        nlohmann::json j = c;
        CHECK(j.at("setNo") == "4/102");
        CHECK(j.at("firstEdition") == true);
        CHECK(j.at("signed") == false);
+        CHECK(j.at("region") == "West");

        const PokemonCard back = j.get<PokemonCard>();
        CHECK(back == c);
    }
+
+    TEST_CASE("region Asia round-trips and missing region defaults to West") {
+        PokemonCard c;
+        c.id = 1;
+        c.amount = 1;
+        c.name = "Charmander";
+        c.set = Set{"PMCG1", "Expansion Pack", "1996/10/20"};
+        c.setNo = "001";
+        c.language = Language::Japanese;
+        c.condition = Condition::NearMint;
+        c.region = PokemonRegion::Asia;
+
+        nlohmann::json j = c;
+        CHECK(j.at("region") == "Asia");
+        CHECK(j.get<PokemonCard>().region == PokemonRegion::Asia);
+
+        j.erase("region");
+        const PokemonCard legacy = j.get<PokemonCard>();
+        CHECK(legacy.region == PokemonRegion::West);
+    }
+}
+
+TEST_SUITE("DigiBattle99Card JSON") {
+    TEST_CASE("uses 'setNo' and 'firstEdition' aliases") {
+        DigiBattle99Card c;
+        c.id = 3;
+        c.amount = 2;
+        c.name = "Agumon";
+        c.set = Set{"series-1-starter-set", "Series 1 Starter Set", "1999/06/01"};
+        c.setNo = "ST-01";
+        c.note = "starter";
+        c.images = {"a.png"};
+        c.language = Language::English;
+        c.condition = Condition::NearMint;
+        c.firstEdition = false;
+        c.holo = true;
+        c.signed_ = true;
+        c.altered = false;
+
+        nlohmann::json j = c;
+        CHECK(j.at("setNo") == "ST-01");
+        CHECK(j.at("firstEdition") == false);
+        CHECK(j.at("holo") == true);
+        CHECK(j.at("signed") == true);
+
+        const DigiBattle99Card back = j.get<DigiBattle99Card>();
+        CHECK(back == c);
+    }
+}
+
+TEST_SUITE("JapanesePokemonCard JSON") {
+    TEST_CASE("uses 'setNo' and 'firstEdition' aliases") {
+        JapanesePokemonCard c;
+        c.id = 9;
+        c.amount = 1;
+        c.name = "Charmander";
+        c.set = Set{"PMCG1", "Expansion Pack", "1996/10/20"};
+        c.setNo = "001";
+        c.note = "";
+        c.images = {};
+        c.language = Language::Japanese;
+        c.condition = Condition::NearMint;
+        c.firstEdition = true;
+        c.holo = false;
+        c.signed_ = false;
+        c.altered = false;
+
+        nlohmann::json j = c;
+        CHECK(j.at("setNo") == "001");
+        CHECK(j.at("firstEdition") == true);
+        CHECK(j.at("signed") == false);
+        CHECK(j.at("language") == "Japanese");
+
+        const JapanesePokemonCard back = j.get<JapanesePokemonCard>();
+        CHECK(back == c);
+    }
 }

 TEST_SUITE("Configuration JSON matches Rust serde aliases") {
@@ -169,6 +289,16 @@ TEST_SUITE("Configuration JSON matches Rust serde aliases") {
        CHECK(back == cfg);
    }

+    TEST_CASE("legacy defaultGame JapanesePokemon coerces to Pokemon") {
+        nlohmann::json j = {
+            {"dataStorage", "/data"},
+            {"defaultGame", "JapanesePokemon"},
+            {"theme", "Light"},
+        };
+        const auto cfg = j.get<Configuration>();
+        CHECK(cfg.defaultGame == Game::Pokemon);
+    }
+
    TEST_CASE("missing theme key defaults to Light") {
        const nlohmann::json j = {
            {"dataStorage", "/portable/data"},
@@ -497,6 +627,66 @@ TEST_SUITE("Domain JSON required fields") {
        }
    }

+    TEST_CASE("DigiBattle99Card missing each required key throws") {
+        const nlohmann::json full = {
+            {"id", 3},
+            {"amount", 1},
+            {"name", "Agumon"},
+            {"set", nlohmann::json{
+                {"id", "series-1-starter-set"},
+                {"name", "Series 1 Starter Set"},
+                {"releaseDate", "1999/06/01"},
+            }},
+            {"setNo", "ST-01"},
+            {"note", ""},
+            {"images", nlohmann::json::array()},
+            {"language", "English"},
+            {"condition", "NearMint"},
+            {"firstEdition", false},
+            {"holo", true},
+            {"signed", false},
+            {"altered", false},
+        };
+
+        for (const char* key :
+             {"id", "amount", "name", "set", "setNo", "note", "images", "language", "condition",
+              "firstEdition", "holo", "signed", "altered"}) {
+            nlohmann::json partial = full;
+            partial.erase(key);
+            CHECK_THROWS(partial.get<DigiBattle99Card>());
+        }
+    }
+
+    TEST_CASE("JapanesePokemonCard missing each required key throws") {
+        const nlohmann::json full = {
+            {"id", 9},
+            {"amount", 1},
+            {"name", "Charmander"},
+            {"set", nlohmann::json{
+                {"id", "PMCG1"},
+                {"name", "Expansion Pack"},
+                {"releaseDate", "1996/10/20"},
+            }},
+            {"setNo", "001"},
+            {"note", ""},
+            {"images", nlohmann::json::array()},
+            {"language", "Japanese"},
+            {"condition", "NearMint"},
+            {"firstEdition", true},
+            {"holo", false},
+            {"signed", false},
+            {"altered", false},
+        };
+
+        for (const char* key :
+             {"id", "amount", "name", "set", "setNo", "note", "images", "language", "condition",
+              "firstEdition", "holo", "signed", "altered"}) {
+            nlohmann::json partial = full;
+            partial.erase(key);
+            CHECK_THROWS(partial.get<JapanesePokemonCard>());
+        }
+    }
+
    TEST_CASE("Configuration missing required key throws") {
        const nlohmann::json j = {
            {"defaultGame", "Magic"},
@@ -1,7 +1,9 @@
 #include <doctest/doctest.h>

+#include "ccm/games/digibattle99/DigiBattle99GameModule.hpp"
 #include "ccm/games/magic/MagicGameModule.hpp"
 #include "ccm/games/pokemon/PokemonGameModule.hpp"
+#include "ccm/games/pokemonjp/JapanesePokemonGameModule.hpp"
 #include "ccm/games/yugioh/YuGiOhGameModule.hpp"
 #include "ccm/ports/IHttpClient.hpp"

@@ -51,4 +53,26 @@ TEST_SUITE("game modules expose stable identity and wiring") {
        CHECK(module.cardPreviewSource() != nullptr);
        CHECK(static_cast<void*>(&module.setSource()) != static_cast<void*>(module.cardPreviewSource()));
    }
+
+    TEST_CASE("DigiBattle99 module reports canonical metadata") {
+        NoopHttpClient http;
+        DigiBattle99GameModule module(http);
+
+        CHECK(module.id() == Game::DigiBattle99);
+        CHECK(module.dirName() == "digibattle99");
+        CHECK(module.displayName() == "Digimon (Digi-Battle)");
+        CHECK(module.cardPreviewSource() != nullptr);
+        CHECK(static_cast<void*>(&module.setSource()) != static_cast<void*>(module.cardPreviewSource()));
+    }
+
+    TEST_CASE("JapanesePokemon module reports canonical metadata") {
+        NoopHttpClient http;
+        JapanesePokemonGameModule module(http);
+
+        CHECK(module.id() == Game::JapanesePokemon);
+        CHECK(module.dirName() == "pokemon");
+        CHECK(module.displayName() == "Pokemon (Japan)");
+        CHECK(module.cardPreviewSource() != nullptr);
+        CHECK(static_cast<void*>(&module.setSource()) != static_cast<void*>(module.cardPreviewSource()));
+    }
 }
@@ -0,0 +1,593 @@
+#include <doctest/doctest.h>
+
+#include "ccm/games/pokemonjp/JapanesePokemonCardPreviewSource.hpp"
+#include "ccm/games/pokemonjp/JapanesePokemonEnCatalog.hpp"
+#include "ccm/ports/IHttpClient.hpp"
+
+#include <string>
+#include <unordered_map>
+
+using namespace ccm;
+
+namespace {
+
+class RoutingHttpClient final : public IHttpClient {
+public:
+    std::unordered_map<std::string, std::string> bodies;
+    std::string lastUrl;
+    bool ok = true;
+    Result<std::string> get(std::string_view url) override {
+        lastUrl = std::string(url);
+        if (!ok) return Result<std::string>::err("offline");
+        const auto it = bodies.find(lastUrl);
+        if (it == bodies.end()) return Result<std::string>::err("unknown url: " + lastUrl);
+        return Result<std::string>::ok(it->second);
+    }
+};
+
+JapanesePokemonEnCatalog sampleCatalog() {
+    auto c = JapanesePokemonEnCatalog::parse(R"({
+        "sets": {
+            "SV1a": {"name_en":"Triplet Beat","name_ja":"トリプレットビート"}
+        },
+        "prints": [
+            {"set_id":"SV1a","local_id":"001","name_en":"Tropius","name_ja":"トロピウス","name_en_source":"bulbapedia"}
+        ]
+    })");
+    REQUIRE(c.isOk());
+    return std::move(c).value();
+}
+
+}  // namespace
+
+TEST_SUITE("JapanesePokemonCardPreviewSource helpers") {
+    TEST_CASE("normalizeLocalId strips slash and whitespace") {
+        CHECK(JapanesePokemonCardPreviewSource::normalizeLocalId(" 001/102 ") == "001");
+        CHECK(JapanesePokemonCardPreviewSource::normalizeLocalId("4/102") == "4");
+    }
+
+    TEST_CASE("imageUrlFromBase appends high.png") {
+        CHECK(JapanesePokemonCardPreviewSource::imageUrlFromBase(
+                  "https://assets.tcgdex.net/ja/SV/SV1a/001") ==
+              "https://assets.tcgdex.net/ja/SV/SV1a/001/high.png");
+    }
+
+    TEST_CASE("buildCardUrl encodes set-local id") {
+        CHECK(JapanesePokemonCardPreviewSource::buildCardUrl("SV1a", "001") ==
+              "https://api.tcgdex.net/v2/ja/cards/SV1a-001");
+    }
+}
+
+TEST_SUITE("JapanesePokemonCardPreviewSource::parseSetCards") {
+    TEST_CASE("parses localId name and image") {
+        const std::string json = R"({
+            "id":"SV1a",
+            "cards":[
+                {"id":"SV1a-001","localId":"001","name":"トロピウス",
+                 "image":"https://assets.tcgdex.net/ja/SV/SV1a/001","rarity":"Common"}
+            ]
+        })";
+        const auto out = JapanesePokemonCardPreviewSource::parseSetCards(json);
+        REQUIRE(out.isOk());
+        REQUIRE(out.value().size() == 1);
+        CHECK(out.value()[0].localId == "001");
+        CHECK(out.value()[0].nameJa == "トロピウス");
+        CHECK(out.value()[0].imageBase == "https://assets.tcgdex.net/ja/SV/SV1a/001");
+    }
+
+    TEST_CASE("missing cards array is Transient") {
+        const auto out = JapanesePokemonCardPreviewSource::parseSetCards(R"({"id":"X"})");
+        REQUIRE(out.isErr());
+        CHECK(out.error().kind == PreviewLookupError::Kind::Transient);
+    }
+}
+
+TEST_SUITE("JapanesePokemonCardPreviewSource::parseCardImageUrl") {
+    TEST_CASE("returns high.png URL") {
+        const auto out = JapanesePokemonCardPreviewSource::parseCardImageUrl(
+            R"({"id":"SV1a-001","image":"https://assets.tcgdex.net/ja/SV/SV1a/001"})");
+        REQUIRE(out.isOk());
+        CHECK(out.value() == "https://assets.tcgdex.net/ja/SV/SV1a/001/high.png");
+    }
+
+    TEST_CASE("null image is NotFound") {
+        const auto out = JapanesePokemonCardPreviewSource::parseCardImageUrl(
+            R"({"id":"PMCG1-001","image":null})");
+        REQUIRE(out.isErr());
+        CHECK(out.error().kind == PreviewLookupError::Kind::NotFound);
+    }
+
+    TEST_CASE("malformed JSON is Transient") {
+        const auto out = JapanesePokemonCardPreviewSource::parseCardImageUrl("{bad");
+        REQUIRE(out.isErr());
+        CHECK(out.error().kind == PreviewLookupError::Kind::Transient);
+    }
+}
+
+TEST_SUITE("JapanesePokemonCardPreviewSource::parsePrintVariants") {
+    TEST_CASE("matches English catalog name") {
+        const std::string body = R"({
+            "id":"SV1a",
+            "cards":[
+                {"localId":"001","name":"トロピウス","rarity":"Common"},
+                {"localId":"002","name":"other","rarity":"Common"}
+            ]
+        })";
+        const auto catalog = sampleCatalog();
+        const auto out = JapanesePokemonCardPreviewSource::parsePrintVariants(
+            body, "SV1a", "Tropius", catalog);
+        REQUIRE(out.isOk());
+        REQUIRE(out.value().size() == 1);
+        CHECK(out.value()[0].setNo == "001");
+    }
+
+    TEST_CASE("matches Japanese name without catalog") {
+        const std::string body = R"({
+            "id":"SV1a",
+            "cards":[{"localId":"001","name":"トロピウス"}]
+        })";
+        JapanesePokemonEnCatalog empty;
+        const auto out = JapanesePokemonCardPreviewSource::parsePrintVariants(
+            body, "SV1a", "トロピウス", empty);
+        REQUIRE(out.isOk());
+        CHECK(out.value().front().setNo == "001");
+    }
+
+    TEST_CASE("rejects stale catalog localId when name_ja disagrees with TCGdex") {
+        // Historical seed bug: Charmander mapped to 001 (actually Bulbasaur).
+        const auto catalog = JapanesePokemonEnCatalog::parse(R"({
+            "sets": {},
+            "prints": [
+                {"set_id":"PMCG1","local_id":"001","name_en":"Charmander","name_ja":"ヒトカゲ"}
+            ]
+        })");
+        REQUIRE(catalog.isOk());
+        const std::string body = R"({
+            "id":"PMCG1",
+            "cards":[
+                {"localId":"001","name":"フシギダネ","rarity":"Common"},
+                {"localId":"014","name":"ヒトカゲ","rarity":"Common"}
+            ]
+        })";
+        const auto out = JapanesePokemonCardPreviewSource::parsePrintVariants(
+            body, "PMCG1", "Charmander", catalog.value());
+        REQUIRE(out.isErr());
+    }
+
+    TEST_CASE("accepts corrected catalog localId for Charmander") {
+        const auto catalog = JapanesePokemonEnCatalog::parse(R"({
+            "sets": {},
+            "prints": [
+                {"set_id":"PMCG1","local_id":"014","name_en":"Charmander","name_ja":"ヒトカゲ"}
+            ]
+        })");
+        REQUIRE(catalog.isOk());
+        const std::string body = R"({
+            "id":"PMCG1",
+            "cards":[
+                {"localId":"001","name":"フシギダネ"},
+                {"localId":"014","name":"ヒトカゲ","rarity":"Common"}
+            ]
+        })";
+        const auto out = JapanesePokemonCardPreviewSource::parsePrintVariants(
+            body, "PMCG1", "Charmander", catalog.value());
+        REQUIRE(out.isOk());
+        REQUIRE(out.value().size() == 1);
+        CHECK(out.value()[0].setNo == "014");
+    }
+
+    TEST_CASE("English Blastoise and Mewtwo resolve Expansion Pack localIds") {
+        const auto catalog = JapanesePokemonEnCatalog::parse(R"({
+            "sets": {},
+            "prints": [
+                {"set_id":"PMCG1","local_id":"032","name_en":"Blastoise","name_ja":"カメックス"},
+                {"set_id":"PMCG1","local_id":"050","name_en":"Mewtwo","name_ja":"ミュウツー"}
+            ]
+        })");
+        REQUIRE(catalog.isOk());
+        const std::string body = R"({
+            "id":"PMCG1",
+            "cards":[
+                {"localId":"032","name":"カメックス","rarity":"Holo Rare"},
+                {"localId":"050","name":"ミュウツー","rarity":"Holo Rare"}
+            ]
+        })";
+        auto blast = JapanesePokemonCardPreviewSource::parsePrintVariants(
+            body, "PMCG1", "Blastoise", catalog.value());
+        REQUIRE(blast.isOk());
+        REQUIRE(blast.value().size() == 1);
+        CHECK(blast.value()[0].setNo == "032");
+
+        auto mew = JapanesePokemonCardPreviewSource::parsePrintVariants(
+            body, "PMCG1", "Mewtwo", catalog.value());
+        REQUIRE(mew.isOk());
+        REQUIRE(mew.value().size() == 1);
+        CHECK(mew.value()[0].setNo == "050");
+    }
+
+    TEST_CASE("English Switch resolves Expansion Pack localId 073") {
+        const auto catalog = JapanesePokemonEnCatalog::parse(R"({
+            "sets": {},
+            "prints": [
+                {"set_id":"PMCG1","local_id":"073","name_en":"Switch","name_ja":"ポケモンいれかえ"}
+            ]
+        })");
+        REQUIRE(catalog.isOk());
+        const std::string body = R"({
+            "id":"PMCG1",
+            "cards":[
+                {"localId":"071","name":"きずぐすり","rarity":"Common"},
+                {"localId":"073","name":"ポケモンいれかえ","rarity":"Common"}
+            ]
+        })";
+        const auto out = JapanesePokemonCardPreviewSource::parsePrintVariants(
+            body, "PMCG1", "Switch", catalog.value());
+        REQUIRE(out.isOk());
+        REQUIRE(out.value().size() == 1);
+        CHECK(out.value()[0].setNo == "073");
+    }
+}
+
+TEST_SUITE("JapanesePokemonCardPreviewSource::fetchImageUrl") {
+    TEST_CASE("resolves via card endpoint when localId present") {
+        RoutingHttpClient http;
+        http.bodies[JapanesePokemonCardPreviewSource::buildCardUrl("SV1a", "001")] =
+            R"({"id":"SV1a-001","image":"https://assets.tcgdex.net/ja/SV/SV1a/001"})";
+        auto catalog = sampleCatalog();
+        JapanesePokemonCardPreviewSource src{http, catalog};
+        const auto out = src.fetchImageUrl("Tropius", "SV1a", "001");
+        REQUIRE(out.isOk());
+        CHECK(out.value() == "https://assets.tcgdex.net/ja/SV/SV1a/001/high.png");
+    }
+
+    TEST_CASE("resolves via set detail when card has no image but set row does") {
+        RoutingHttpClient http;
+        http.bodies[JapanesePokemonCardPreviewSource::buildCardUrl("SV1a", "001")] =
+            R"({"id":"SV1a-001","image":null})";
+        http.bodies[JapanesePokemonCardPreviewSource::buildSetDetailUrl("SV1a")] = R"({
+            "id":"SV1a",
+            "cards":[{"localId":"001","name":"トロピウス",
+                      "image":"https://assets.tcgdex.net/ja/SV/SV1a/001"}]
+        })";
+        auto catalog = sampleCatalog();
+        JapanesePokemonCardPreviewSource src{http, catalog};
+        const auto out = src.fetchImageUrl("Tropius", "SV1a", "001");
+        REQUIRE(out.isOk());
+        CHECK(out.value().find("/high.png") != std::string::npos);
+    }
+
+    TEST_CASE("stale catalog does not bind English name to wrong localId image") {
+        RoutingHttpClient http;
+        http.bodies[JapanesePokemonCardPreviewSource::buildSetDetailUrl("PMCG1")] = R"({
+            "id":"PMCG1",
+            "cards":[
+                {"localId":"001","name":"フシギダネ",
+                 "image":"https://assets.tcgdex.net/ja/PMCG/PMCG1/001"},
+                {"localId":"014","name":"ヒトカゲ",
+                 "image":"https://assets.tcgdex.net/ja/PMCG/PMCG1/014"}
+            ]
+        })";
+        const auto catalog = JapanesePokemonEnCatalog::parse(R"({
+            "sets": {},
+            "prints": [
+                {"set_id":"PMCG1","local_id":"001","name_en":"Charmander","name_ja":"ヒトカゲ"}
+            ]
+        })");
+        REQUIRE(catalog.isOk());
+        JapanesePokemonCardPreviewSource src{http, catalog.value()};
+        // Empty setNo forces name match; stale catalog must not pick Bulbasaur's art.
+        const auto out = src.fetchImageUrl("Charmander", "PMCG1", "");
+        REQUIRE(out.isErr());
+        CHECK(out.error().kind == PreviewLookupError::Kind::NotFound);
+    }
+
+    TEST_CASE("English name resolves correct localId image via catalog") {
+        RoutingHttpClient http;
+        http.bodies[JapanesePokemonCardPreviewSource::buildSetDetailUrl("PMCG1")] = R"({
+            "id":"PMCG1",
+            "cards":[
+                {"localId":"001","name":"フシギダネ",
+                 "image":"https://assets.tcgdex.net/ja/PMCG/PMCG1/001"},
+                {"localId":"014","name":"ヒトカゲ",
+                 "image":"https://assets.tcgdex.net/ja/PMCG/PMCG1/014"}
+            ]
+        })";
+        const auto catalog = JapanesePokemonEnCatalog::parse(R"({
+            "sets": {},
+            "prints": [
+                {"set_id":"PMCG1","local_id":"014","name_en":"Charmander","name_ja":"ヒトカゲ"}
+            ]
+        })");
+        REQUIRE(catalog.isOk());
+        JapanesePokemonCardPreviewSource src{http, catalog.value()};
+        const auto out = src.fetchImageUrl("Charmander", "PMCG1", "");
+        REQUIRE(out.isOk());
+        CHECK(out.value() == "https://assets.tcgdex.net/ja/PMCG/PMCG1/014/high.png");
+    }
+
+    TEST_CASE("null image on set-specific card is NotFound without other-printing fallback") {
+        RoutingHttpClient http;
+        http.bodies[JapanesePokemonCardPreviewSource::buildCardUrl("PMCG1", "021")] =
+            R"({"id":"PMCG1-021","name":"リザードン","image":null})";
+        http.bodies[JapanesePokemonCardPreviewSource::buildSetDetailUrl("PMCG1")] = R"({
+            "id":"PMCG1",
+            "cards":[{"localId":"021","name":"リザードン"}]
+        })";
+        JapanesePokemonEnCatalog empty;
+        JapanesePokemonCardPreviewSource src{http, empty};
+        const auto out = src.fetchImageUrl("Charizard", "PMCG1", "021");
+        REQUIRE(out.isErr());
+        CHECK(out.error().kind == PreviewLookupError::Kind::NotFound);
+    }
+
+    TEST_CASE("catalog tcgplayer_id gap-fills when TCGdex image is null") {
+        RoutingHttpClient http;
+        http.bodies[JapanesePokemonCardPreviewSource::buildCardUrl("PMCG1", "021")] =
+            R"({"id":"PMCG1-021","name":"リザードン","image":null})";
+        http.bodies[JapanesePokemonCardPreviewSource::buildSetDetailUrl("PMCG1")] = R"({
+            "id":"PMCG1",
+            "cards":[{"localId":"021","name":"リザードン"}]
+        })";
+        const auto catalog = JapanesePokemonEnCatalog::parse(R"({
+            "sets": {},
+            "prints": [
+                {"set_id":"PMCG1","local_id":"021","name_en":"Charizard",
+                 "name_ja":"リザードン","tcgplayer_id":"575604"}
+            ]
+        })");
+        REQUIRE(catalog.isOk());
+        JapanesePokemonCardPreviewSource src{http, catalog.value()};
+        const auto out = src.fetchImageUrl("Charizard", "PMCG1", "021");
+        REQUIRE(out.isOk());
+        CHECK(out.value() ==
+              "https://product-images.tcgplayer.com/fit-in/437x437/575604.jpg");
+    }
+
+    TEST_CASE("HTTP failure is Transient") {
+        RoutingHttpClient http;
+        http.ok = false;
+        JapanesePokemonEnCatalog empty;
+        JapanesePokemonCardPreviewSource src{http, empty};
+        const auto out = src.fetchImageUrl("Tropius", "SV1a", "001");
+        REQUIRE(out.isErr());
+        CHECK(out.error().kind == PreviewLookupError::Kind::Transient);
+    }
+
+    TEST_CASE("catalog-only theme deck resolves preview from tcgplayer_id") {
+        RoutingHttpClient http;
+        // No TCGdex bodies: card + set detail both miss.
+        const auto catalog = JapanesePokemonEnCatalog::parse(R"({
+            "sets": {"TamamushiCG":{"name_en":"Tamamushi City Gym"}},
+            "prints": [
+                {"set_id":"TamamushiCG","local_id":"021","name_en":"Celadon City Gym",
+                 "name_ja":"タマムシシティジム","tcgplayer_id":"12345"}
+            ]
+        })");
+        REQUIRE(catalog.isOk());
+        JapanesePokemonCardPreviewSource src{http, catalog.value()};
+        const auto out = src.fetchImageUrl("Celadon City Gym", "TamamushiCG", "021");
+        REQUIRE(out.isOk());
+        CHECK(out.value() ==
+              "https://product-images.tcgplayer.com/fit-in/437x437/12345.jpg");
+    }
+
+    TEST_CASE("Tamamushi City Gym Erika uses catalog tcgplayer gap-fill") {
+        RoutingHttpClient http;
+        const auto catalog = JapanesePokemonEnCatalog::parse(R"({
+            "sets": {"TamamushiCG":{"name_en":"Tamamushi City Gym"}},
+            "prints": [
+                {"set_id":"TamamushiCG","local_id":"016","name_en":"Erika",
+                 "name_ja":"エリカ","name_en_source":"trainer-table",
+                 "tcgplayer_id":"576776"}
+            ]
+        })");
+        REQUIRE(catalog.isOk());
+        JapanesePokemonCardPreviewSource src{http, catalog.value()};
+        const auto out = src.fetchImageUrl("Erika", "TamamushiCG", "016");
+        REQUIRE(out.isOk());
+        CHECK(out.value() ==
+              "https://product-images.tcgplayer.com/fit-in/437x437/576776.jpg");
+    }
+
+    TEST_CASE("neo catalog image_url gap-fills when TCGdex image is null") {
+        RoutingHttpClient http;
+        http.bodies[JapanesePokemonCardPreviewSource::buildCardUrl("neo4", "106")] =
+            R"({"id":"neo4-106","name":"ラッキースタジアム","image":null})";
+        http.bodies[JapanesePokemonCardPreviewSource::buildSetDetailUrl("neo4")] = R"({
+            "id":"neo4",
+            "cards":[{"localId":"106","name":"ラッキースタジアム"}]
+        })";
+        const auto catalog = JapanesePokemonEnCatalog::parse(R"({
+            "sets": {},
+            "prints": [
+                {"set_id":"neo4","local_id":"106","name_en":"Shining Celebi",
+                 "name_ja":"輝くセレビ","name_en_source":"species-table-variant",
+                 "image_url":"https://images.pokemontcg.io/neo4/106_hires.png"}
+            ]
+        })");
+        REQUIRE(catalog.isOk());
+        JapanesePokemonCardPreviewSource src{http, catalog.value()};
+        const auto out = src.fetchImageUrl("Shining Celebi", "neo4", "106");
+        REQUIRE(out.isOk());
+        CHECK(out.value() == "https://images.pokemontcg.io/neo4/106_hires.png");
+    }
+}
+
+TEST_SUITE("JapanesePokemonCardPreviewSource::detectPrintVariants catalog-only") {
+    TEST_CASE("English trainer name resolves when TCGdex set detail is unavailable") {
+        RoutingHttpClient http;
+        const auto catalog = JapanesePokemonEnCatalog::parse(R"json({
+            "sets": {"TamamushiCG":{"name_en":"Tamamushi City Gym"}},
+            "prints": [
+                {"set_id":"TamamushiCG","local_id":"021","name_en":"Celadon City Gym",
+                 "name_ja":"タマムシシティジム","name_en_source":"trainer-table",
+                 "image_url":"https://example.com/celadon.jpg"},
+                {"set_id":"TamamushiCG","local_id":"001","name_en":"Erika's Oddish",
+                 "name_ja":"エリカのナゾノクサ","name_en_source":"manual",
+                 "image_url":"https://example.com/oddish.jpg"}
+            ]
+        })json");
+        REQUIRE(catalog.isOk());
+        JapanesePokemonCardPreviewSource src{http, catalog.value()};
+        const auto out = src.detectPrintVariants("Celadon City Gym", "TamamushiCG");
+        REQUIRE(out.isOk());
+        REQUIRE(out.value().size() == 1);
+        CHECK(out.value()[0].setNo == "021");
+    }
+
+    TEST_CASE("detectPrintVariantsFromCatalog includes UnnumberedPromo prints without image_url") {
+        const auto catalog = JapanesePokemonEnCatalog::parse(R"json({
+            "sets": {},
+            "prints": [
+                {"set_id":"UnnumberedPromo","local_id":"007","name_en":"Mewtwo (CoroCoro promo)",
+                 "name_ja":"ミュウツー","name_en_source":"manual"},
+                {"set_id":"UnnumberedPromo","local_id":"008","name_en":"Mewtwo (Fan Book promo)",
+                 "name_ja":"ミュウツー","name_en_source":"manual"},
+                {"set_id":"UnnumberedPromo","local_id":"030","name_en":"Mewtwo (WHF Special Sheet promo)",
+                 "name_ja":"ミュウツー","name_en_source":"manual",
+                 "image_url":"https://archives.bulbagarden.net/media/upload/w/w/MewtwoWHF.jpg"},
+                {"set_id":"UnnumberedPromo","local_id":"045","name_en":"Mewtwo Strikes Back (Jumbo)",
+                 "name_ja":"","name_en_source":"manual"}
+            ]
+        })json");
+        REQUIRE(catalog.isOk());
+        const auto mew = JapanesePokemonCardPreviewSource::detectPrintVariantsFromCatalog(
+            "UnnumberedPromo", "Mewtwo", catalog.value());
+        REQUIRE(mew.isOk());
+        REQUIRE(mew.value().size() == 4);
+        // Imaged prints first, then empty-URL identity rows.
+        CHECK(mew.value()[0].setNo == "030");
+        CHECK(mew.value()[1].setNo == "007");
+        CHECK(mew.value()[2].setNo == "008");
+        CHECK(mew.value()[3].setNo == "045");
+
+        RoutingHttpClient http;
+        JapanesePokemonCardPreviewSource src{http, catalog.value()};
+        const auto img = src.fetchImageUrl("Mewtwo", "UnnumberedPromo", "030");
+        REQUIRE(img.isOk());
+        CHECK(img.value() ==
+              "https://archives.bulbagarden.net/media/upload/w/w/MewtwoWHF.jpg");
+    }
+
+    TEST_CASE("fetchImageUrl does not borrow sibling UnnumberedPromo image") {
+        RoutingHttpClient http;
+        const auto catalog = JapanesePokemonEnCatalog::parse(R"json({
+            "sets": {},
+            "prints": [
+                {"set_id":"UnnumberedPromo","local_id":"007","name_en":"Mewtwo (CoroCoro promo)",
+                 "name_ja":"ミュウツー","name_en_source":"manual"},
+                {"set_id":"UnnumberedPromo","local_id":"030","name_en":"Mewtwo (WHF Special Sheet promo)",
+                 "name_ja":"ミュウツー","name_en_source":"manual",
+                 "image_url":"https://archives.bulbagarden.net/media/upload/w/w/MewtwoWHF.jpg"}
+            ]
+        })json");
+        REQUIRE(catalog.isOk());
+        JapanesePokemonCardPreviewSource src{http, catalog.value()};
+        const auto empty = src.fetchImageUrl("Mewtwo", "UnnumberedPromo", "007");
+        REQUIRE(empty.isErr());
+        CHECK(empty.error().kind == PreviewLookupError::Kind::NotFound);
+
+        const auto whf = src.fetchImageUrl("Mewtwo", "UnnumberedPromo", "030");
+        REQUIRE(whf.isOk());
+        CHECK(whf.value() ==
+              "https://archives.bulbagarden.net/media/upload/w/w/MewtwoWHF.jpg");
+    }
+
+    TEST_CASE("detectPrintVariantsFromCatalog dedupes shared preview URLs") {
+        const auto catalog = JapanesePokemonEnCatalog::parse(R"json({
+            "sets": {},
+            "prints": [
+                {"set_id":"UnnumberedPromo","local_id":"030","name_en":"Mewtwo (WHF Special Sheet promo)",
+                 "image_url":"https://archives.bulbagarden.net/media/upload/w/w/same.jpg"},
+                {"set_id":"UnnumberedPromo","local_id":"073","name_en":"Mewtwo (Song Best Collection promo)",
+                 "image_url":"https://archives.bulbagarden.net/media/upload/w/w/same.jpg"},
+                {"set_id":"UnnumberedPromo","local_id":"197","name_en":"Mewtwo (Wizards Promo 12)",
+                 "image_url":"https://archives.bulbagarden.net/media/upload/w/w/same.jpg"}
+            ]
+        })json");
+        REQUIRE(catalog.isOk());
+        const auto mew = JapanesePokemonCardPreviewSource::detectPrintVariantsFromCatalog(
+            "UnnumberedPromo", "Mewtwo", catalog.value());
+        REQUIRE(mew.isOk());
+        REQUIRE(mew.value().size() == 1);
+        CHECK(mew.value()[0].setNo == "030");
+    }
+
+    TEST_CASE("detectPrintVariantsFromCatalog matches owner Pokemon English title") {
+        const auto catalog = JapanesePokemonEnCatalog::parse(R"json({
+            "sets": {},
+            "prints": [
+                {"set_id":"TamamushiCG","local_id":"001","name_en":"Erika's Oddish",
+                 "name_ja":"エリカのナゾノクサ",
+                 "image_url":"https://example.com/oddish.jpg"}
+            ]
+        })json");
+        REQUIRE(catalog.isOk());
+        const auto out = JapanesePokemonCardPreviewSource::detectPrintVariantsFromCatalog(
+            "TamamushiCG", "Erika's Oddish", catalog.value());
+        REQUIRE(out.isOk());
+        REQUIRE(out.value().size() == 1);
+        CHECK(out.value()[0].setNo == "001");
+    }
+
+    TEST_CASE("detectPrintVariantsFromCatalog matches Dark Rocket and Owner PMCG titles") {
+        const auto catalog = JapanesePokemonEnCatalog::parse(R"json({
+            "sets": {},
+            "prints": [
+                {"set_id":"PMCG4","local_id":"017","name_en":"Dark Charizard",
+                 "name_ja":"わるいリザードン","name_en_source":"species-table-variant",
+                 "tcgplayer_id":"575744"},
+                {"set_id":"PMCG6","local_id":"042","name_en":"Rocket's Zapdos",
+                 "name_ja":"R団のサンダー","name_en_source":"species-table-variant",
+                 "tcgplayer_id":"1"},
+                {"set_id":"PMCG5","local_id":"002","name_en":"Erika's Oddish",
+                 "name_ja":"エリカのナゾノクサ","name_en_source":"species-table-variant",
+                 "tcgplayer_id":"2"}
+            ]
+        })json");
+        REQUIRE(catalog.isOk());
+        const auto dark = JapanesePokemonCardPreviewSource::detectPrintVariantsFromCatalog(
+            "PMCG4", "Dark Charizard", catalog.value());
+        REQUIRE(dark.isOk());
+        REQUIRE(dark.value().size() == 1);
+        CHECK(dark.value()[0].setNo == "017");
+
+        const auto rocket = JapanesePokemonCardPreviewSource::detectPrintVariantsFromCatalog(
+            "PMCG6", "Rocket's Zapdos", catalog.value());
+        REQUIRE(rocket.isOk());
+        REQUIRE(rocket.value().size() == 1);
+        CHECK(rocket.value()[0].setNo == "042");
+
+        const auto owner = JapanesePokemonCardPreviewSource::detectPrintVariantsFromCatalog(
+            "PMCG5", "Erika's Oddish", catalog.value());
+        REQUIRE(owner.isOk());
+        REQUIRE(owner.value().size() == 1);
+        CHECK(owner.value()[0].setNo == "002");
+    }
+
+    TEST_CASE("detectPrintVariantsFromCatalog matches Light and Shining neo titles") {
+        const auto catalog = JapanesePokemonEnCatalog::parse(R"json({
+            "sets": {},
+            "prints": [
+                {"set_id":"neo4","local_id":"004","name_en":"Light Sunflora",
+                 "name_ja":"軽いサンフロラ","name_en_source":"species-table-variant",
+                 "image_url":"https://example.com/sunflora.png"},
+                {"set_id":"neo4","local_id":"013","name_en":"Shining Celebi",
+                 "name_ja":"輝くセレビ","name_en_source":"species-table-variant",
+                 "image_url":"https://example.com/celebi.png"}
+            ]
+        })json");
+        REQUIRE(catalog.isOk());
+        const auto light = JapanesePokemonCardPreviewSource::detectPrintVariantsFromCatalog(
+            "neo4", "Light Sunflora", catalog.value());
+        REQUIRE(light.isOk());
+        REQUIRE(light.value().size() == 1);
+        CHECK(light.value()[0].setNo == "004");
+
+        const auto shining = JapanesePokemonCardPreviewSource::detectPrintVariantsFromCatalog(
+            "neo4", "Shining Celebi", catalog.value());
+        REQUIRE(shining.isOk());
+        REQUIRE(shining.value().size() == 1);
+        CHECK(shining.value()[0].setNo == "013");
+    }
+}
@@ -0,0 +1,152 @@
+#include <doctest/doctest.h>
+
+#include "ccm/games/pokemonjp/JapanesePokemonEnCatalog.hpp"
+
+using namespace ccm;
+
+TEST_SUITE("JapanesePokemonEnCatalog") {
+    TEST_CASE("parses sets and prints") {
+        const auto catalog = JapanesePokemonEnCatalog::parse(R"({
+            "sets": {
+                "PMCG1": {
+                    "name_en": "Expansion Pack",
+                    "name_ja": "拡張パック",
+                    "releaseDate": "1996/10/20"
+                }
+            },
+            "prints": [
+                {
+                    "set_id": "PMCG1",
+                    "local_id": "001",
+                    "name_en": "Charmander",
+                    "name_ja": "ヒトカゲ",
+                    "name_en_source": "bulbapedia"
+                }
+            ]
+        })");
+        REQUIRE(catalog.isOk());
+        CHECK_FALSE(catalog.value().empty());
+
+        auto set = catalog.value().findSet("PMCG1");
+        REQUIRE(set.has_value());
+        CHECK(set->nameEn == "Expansion Pack");
+        CHECK(set->releaseDate == "1996/10/20");
+
+        auto print = catalog.value().findPrint("PMCG1", "001");
+        REQUIRE(print.has_value());
+        CHECK(print->nameEn == "Charmander");
+        CHECK(print->nameEnSource == "bulbapedia");
+    }
+
+    TEST_CASE("parses optional tcgplayer_id and image_url") {
+        const auto catalog = JapanesePokemonEnCatalog::parse(R"({
+            "sets": {},
+            "prints": [
+                {
+                    "set_id": "PMCG1",
+                    "local_id": "021",
+                    "name_en": "Charizard",
+                    "name_ja": "リザードン",
+                    "tcgplayer_id": 575604
+                },
+                {
+                    "set_id": "SV1a",
+                    "local_id": "001",
+                    "name_en": "Tropius",
+                    "image_url": "https://example.com/tropius.png"
+                }
+            ]
+        })");
+        REQUIRE(catalog.isOk());
+        auto charizard = catalog.value().findPrint("PMCG1", "021");
+        REQUIRE(charizard.has_value());
+        CHECK(charizard->tcgplayerId == "575604");
+        CHECK(JapanesePokemonEnCatalog::previewImageUrlFromPrint(*charizard) ==
+              "https://product-images.tcgplayer.com/fit-in/437x437/575604.jpg");
+
+        auto tropius = catalog.value().findPrint("SV1a", "001");
+        REQUIRE(tropius.has_value());
+        CHECK(JapanesePokemonEnCatalog::previewImageUrlFromPrint(*tropius) ==
+              "https://example.com/tropius.png");
+    }
+
+    TEST_CASE("findPrintsByName is case-insensitive on English") {
+        const auto catalog = JapanesePokemonEnCatalog::parse(R"({
+            "sets": {},
+            "prints": [
+                {"set_id":"PMCG1","local_id":"001","name_en":"Charmander","name_ja":"ヒトカゲ"}
+            ]
+        })");
+        REQUIRE(catalog.isOk());
+        const auto hits = catalog.value().findPrintsByName("PMCG1", "charmander");
+        REQUIRE(hits.size() == 1);
+        CHECK(hits[0].localId == "001");
+    }
+
+    TEST_CASE("findPrintsByName matches qualified English titles by bare prefix") {
+        const auto catalog = JapanesePokemonEnCatalog::parse(R"json({
+            "sets": {},
+            "prints": [
+                {"set_id":"UnnumberedPromo","local_id":"007","name_en":"Mewtwo (CoroCoro promo)"},
+                {"set_id":"UnnumberedPromo","local_id":"008","name_en":"Mewtwo (Fan Book promo)"},
+                {"set_id":"UnnumberedPromo","local_id":"045","name_en":"Mewtwo Strikes Back (Jumbo)"},
+                {"set_id":"UnnumberedPromo","local_id":"001","name_en":"Pikachu (CoroCoro promo)"}
+            ]
+        })json");
+        REQUIRE(catalog.isOk());
+        const auto hits = catalog.value().findPrintsByName("UnnumberedPromo", "Mewtwo");
+        REQUIRE(hits.size() == 3);
+        CHECK(hits[0].localId == "007");
+        CHECK(hits[1].localId == "008");
+        CHECK(hits[2].localId == "045");
+        // Exact full title still works.
+        const auto exact = catalog.value().findPrintsByName(
+            "UnnumberedPromo", "Mewtwo Strikes Back (Jumbo)");
+        REQUIRE(exact.size() == 1);
+        CHECK(exact[0].localId == "045");
+    }
+
+    TEST_CASE("findPrintsByName whole-token matches owner and GR titles") {
+        const auto catalog = JapanesePokemonEnCatalog::parse(R"json({
+            "sets": {},
+            "prints": [
+                {"set_id":"UnnumberedPromo","local_id":"227","name_en":"Team GR's Mewtwo (Pokémon Card GB2 promo)"},
+                {"set_id":"UnnumberedPromo","local_id":"045","name_en":"Mewtwo Strikes Back (CoroCoro promo) (Jumbo)"},
+                {"set_id":"UnnumberedPromo","local_id":"016","name_en":"Mew (CoroCoro promo)"}
+            ]
+        })json");
+        REQUIRE(catalog.isOk());
+        const auto mewtwo = catalog.value().findPrintsByName("UnnumberedPromo", "Mewtwo");
+        REQUIRE(mewtwo.size() == 2);
+        CHECK(mewtwo[0].localId == "227");
+        CHECK(mewtwo[1].localId == "045");
+
+        // "Mew" must not match "Mewtwo …" rows.
+        const auto mew = catalog.value().findPrintsByName("UnnumberedPromo", "Mew");
+        REQUIRE(mew.size() == 1);
+        CHECK(mew[0].localId == "016");
+    }
+
+    TEST_CASE("hasPrintsForSet reports curated classic products") {
+        const auto catalog = JapanesePokemonEnCatalog::parse(R"({
+            "sets": {},
+            "prints": [
+                {"set_id":"TamamushiCG","local_id":"021","name_en":"Celadon City Gym"}
+            ]
+        })");
+        REQUIRE(catalog.isOk());
+        CHECK(catalog.value().hasPrintsForSet("TamamushiCG"));
+        CHECK_FALSE(catalog.value().hasPrintsForSet("PMCG1"));
+    }
+
+    TEST_CASE("missing set/print returns nullopt") {
+        JapanesePokemonEnCatalog empty;
+        CHECK_FALSE(empty.findSet("X").has_value());
+        CHECK_FALSE(empty.findPrint("X", "1").has_value());
+        CHECK(empty.empty());
+    }
+
+    TEST_CASE("malformed JSON is an error") {
+        CHECK(JapanesePokemonEnCatalog::parse("{not json").isErr());
+    }
+}
@@ -0,0 +1,317 @@
+#include <doctest/doctest.h>
+
+#include "ccm/games/pokemonjp/JapanesePokemonSetSource.hpp"
+#include "ccm/ports/IHttpClient.hpp"
+
+#include <algorithm>
+#include <string>
+#include <unordered_map>
+
+using namespace ccm;
+
+namespace {
+
+class RoutingHttpClient final : public IHttpClient {
+public:
+    std::unordered_map<std::string, std::string> bodies;
+    std::string lastUrl;
+    bool ok = true;
+    Result<std::string> get(std::string_view url) override {
+        lastUrl = std::string(url);
+        if (!ok) return Result<std::string>::err("offline");
+        const auto it = bodies.find(lastUrl);
+        if (it == bodies.end()) return Result<std::string>::err("unknown url");
+        return Result<std::string>::ok(it->second);
+    }
+};
+
+}  // namespace
+
+TEST_SUITE("JapanesePokemonSetSource helpers") {
+    TEST_CASE("excludes CS* set ids") {
+        CHECK(JapanesePokemonSetSource::shouldExcludeSetId("CS1a"));
+        CHECK(JapanesePokemonSetSource::shouldExcludeSetId("CS4a"));
+        CHECK_FALSE(JapanesePokemonSetSource::shouldExcludeSetId("PMCG1"));
+        CHECK_FALSE(JapanesePokemonSetSource::shouldExcludeSetId("SV1a"));
+    }
+
+    TEST_CASE("applies SV4a name override") {
+        CHECK(JapanesePokemonSetSource::applySetNameOverride("SV4a", "wrong") ==
+              "シャイニートレジャーex");
+        CHECK(JapanesePokemonSetSource::applySetNameOverride("PMCG1", "拡張パック") ==
+              "拡張パック");
+    }
+
+    TEST_CASE("rewrites release date separators") {
+        CHECK(JapanesePokemonSetSource::rewriteReleaseDate("1996-10-20") == "1996/10/20");
+    }
+
+    TEST_CASE("buildSetDetailUrl percent-encodes id") {
+        CHECK(JapanesePokemonSetSource::buildSetDetailUrl("SV1a") ==
+              "https://api.tcgdex.net/v2/ja/sets/SV1a");
+    }
+}
+
+TEST_SUITE("JapanesePokemonSetSource::parseListResponse") {
+    TEST_CASE("maps id/name and drops CS* entries") {
+        const std::string json = R"([
+            {"id":"PMCG1","name":"拡張パック","cardCount":{"total":102,"official":102}},
+            {"id":"CS1a","name":"トリプレットビート","cardCount":{"total":1,"official":1}},
+            {"id":"SV4a","name":"レイジングサーフ","cardCount":{"total":320,"official":190}}
+        ])";
+        const auto out = JapanesePokemonSetSource::parseListResponse(json);
+        REQUIRE(out.isOk());
+        // 2 from TCGdex + 11 curated products omitted by TCGdex.
+        REQUIRE(out.value().size() == 13);
+        CHECK(out.value()[0].id == "PMCG1");
+        CHECK(out.value()[0].name == "拡張パック");
+        CHECK(out.value()[1].id == "SV4a");
+        CHECK(out.value()[1].name == "シャイニートレジャーex");
+    }
+
+    TEST_CASE("injects classic City Gym and Expansion Sheet products") {
+        const auto out = JapanesePokemonSetSource::parseListResponse("[]");
+        REQUIRE(out.isOk());
+        REQUIRE(out.value().size() == 11);
+        const auto hasId = [&](const char* id) {
+            return std::any_of(out.value().begin(), out.value().end(),
+                               [&](const Set& s) { return s.id == id; });
+        };
+        CHECK(hasId("UnnumberedPromo"));
+        CHECK(hasId("TamamushiCG"));
+        CHECK(hasId("NiviCG"));
+        CHECK(hasId("HanadaCG"));
+        CHECK(hasId("KuchibaCG"));
+        CHECK(hasId("YamabukiCG"));
+        CHECK(hasId("GurenTG"));
+        CHECK(hasId("ExpSheet1"));
+        CHECK(hasId("ExpSheet2"));
+        CHECK(hasId("ExpSheet3"));
+        CHECK(hasId("SouthernIslands"));
+        const Set* unnumbered = nullptr;
+        const Set* tama = nullptr;
+        for (const auto& s : out.value()) {
+            if (s.id == "UnnumberedPromo") unnumbered = &s;
+            if (s.id == "TamamushiCG") tama = &s;
+        }
+        REQUIRE(unnumbered != nullptr);
+        CHECK(unnumbered->name == "Unnumbered Promotional cards");
+        CHECK(unnumbered->releaseDate == "1997/03/06");
+        REQUIRE(tama != nullptr);
+        CHECK(tama->name == "Tamamushi City Gym");
+        CHECK(tama->releaseDate == "1998/07/25");
+    }
+
+    TEST_CASE("does not duplicate classic products already in the list") {
+        const std::string json = R"([
+            {"id":"TamamushiCG","name":"already-present"}
+        ])";
+        const auto out = JapanesePokemonSetSource::parseListResponse(json);
+        REQUIRE(out.isOk());
+        int tamaCount = 0;
+        for (const auto& s : out.value()) {
+            if (s.id == "TamamushiCG") ++tamaCount;
+        }
+        CHECK(tamaCount == 1);
+        // Curated EN name / release date overwrite a stale upstream label.
+        CHECK(out.value().front().name == "Tamamushi City Gym");
+        CHECK(out.value().front().releaseDate == "1998/07/25");
+    }
+
+    TEST_CASE("empty array still injects classic products") {
+        const auto out = JapanesePokemonSetSource::parseListResponse("[]");
+        REQUIRE(out.isOk());
+        CHECK_FALSE(out.value().empty());
+    }
+
+    TEST_CASE("non-array is an error") {
+        CHECK(JapanesePokemonSetSource::parseListResponse(R"({"data":[]})").isErr());
+    }
+
+    TEST_CASE("invalid JSON is an error") {
+        CHECK(JapanesePokemonSetSource::parseListResponse("{not json").isErr());
+    }
+}
+
+TEST_SUITE("JapanesePokemonSetSource::parseReleaseDate") {
+    TEST_CASE("extracts and rewrites releaseDate") {
+        const auto out = JapanesePokemonSetSource::parseReleaseDate(
+            R"({"id":"PMCG1","releaseDate":"1996-10-20"})");
+        REQUIRE(out.isOk());
+        CHECK(out.value() == "1996/10/20");
+    }
+
+    TEST_CASE("missing releaseDate yields empty string") {
+        const auto out = JapanesePokemonSetSource::parseReleaseDate(R"({"id":"X"})");
+        REQUIRE(out.isOk());
+        CHECK(out.value().empty());
+    }
+}
+
+TEST_SUITE("JapanesePokemonSetSource::fetchAll") {
+    TEST_CASE("enriches from catalog and sorts by release date") {
+        RoutingHttpClient http;
+        http.bodies[JapanesePokemonSetSource::kListEndpoint] = R"([
+            {"id":"SV1a","name":"トリプレットビート"},
+            {"id":"PMCG1","name":"拡張パック"},
+            {"id":"PMCG2","name":"ポケモンジャングル"},
+            {"id":"CS1a","name":"junk"}
+        ])";
+        // Catalog supplies dates so detail GETs are skipped.
+        const auto catalog = JapanesePokemonEnCatalog::parse(R"({
+            "sets": {
+                "PMCG1": {"name_en":"Expansion Pack","name_ja":"拡張パック","releaseDate":"1996/10/20"},
+                "PMCG2": {"name_en":"Pokémon Jungle","name_ja":"ポケモンジャングル","releaseDate":"1997/03/05"},
+                "SV1a": {"name_en":"Triplet Beat","name_ja":"トリプレットビート","releaseDate":"2023/03/10"}
+            },
+            "prints": []
+        })");
+        REQUIRE(catalog.isOk());
+        JapanesePokemonSetSource src{http, catalog.value()};
+        const auto out = src.fetchAll();
+        REQUIRE(out.isOk());
+        // CS* dropped; 3 TCGdex + 11 curated injections.
+        REQUIRE(out.value().size() == 14);
+        // Expansion Pack → Jungle → UnnumberedPromo (day after Jungle).
+        CHECK(out.value()[0].id == "PMCG1");
+        CHECK(out.value()[1].id == "PMCG2");
+        CHECK(out.value()[1].name == "Pokémon Jungle");
+        CHECK(out.value()[2].id == "UnnumberedPromo");
+        CHECK(out.value()[2].name == "Unnumbered Promotional cards");
+        CHECK(out.value()[2].releaseDate == "1997/03/06");
+        const Set* pmcg1 = nullptr;
+        bool foundSv = false;
+        bool foundTama = false;
+        for (const auto& s : out.value()) {
+            if (s.id == "PMCG1") {
+                pmcg1 = &s;
+                CHECK(s.name == "Expansion Pack");
+                CHECK(s.releaseDate == "1996/10/20");
+            }
+            if (s.id == "SV1a") {
+                foundSv = true;
+                CHECK(s.name == "Triplet Beat");
+            }
+            if (s.id == "TamamushiCG") {
+                foundTama = true;
+                CHECK(s.name == "Tamamushi City Gym");
+            }
+        }
+        REQUIRE(pmcg1 != nullptr);
+        CHECK(foundSv);
+        CHECK(foundTama);
+    }
+
+    TEST_CASE("fetches set detail when catalog lacks release date") {
+        RoutingHttpClient http;
+        http.bodies[JapanesePokemonSetSource::kListEndpoint] =
+            R"([{"id":"PMCG1","name":"拡張パック"}])";
+        http.bodies[JapanesePokemonSetSource::buildSetDetailUrl("PMCG1")] =
+            R"({"id":"PMCG1","releaseDate":"1996-10-20","cards":[]})";
+        JapanesePokemonEnCatalog empty;
+        JapanesePokemonSetSource src{http, empty};
+        const auto out = src.fetchAll();
+        REQUIRE(out.isOk());
+        REQUIRE(out.value().size() == 12);  // PMCG1 + 11 curated
+        const Set* pmcg1 = nullptr;
+        for (const auto& s : out.value()) {
+            if (s.id == "PMCG1") {
+                pmcg1 = &s;
+                break;
+            }
+        }
+        REQUIRE(pmcg1 != nullptr);
+        CHECK(pmcg1->releaseDate == "1996/10/20");
+        // Without catalog EN, never keep Japanese TCGdex names in Set.name.
+        CHECK(pmcg1->name == "PMCG1");
+    }
+
+    TEST_CASE("CJK set names fall back to set id even without catalog") {
+        RoutingHttpClient http;
+        http.bodies[JapanesePokemonSetSource::kListEndpoint] =
+            R"([{"id":"PMCG3","name":"化石の秘密"}])";
+        http.bodies[JapanesePokemonSetSource::buildSetDetailUrl("PMCG3")] =
+            R"({"id":"PMCG3","releaseDate":"1997-06-21"})";
+        JapanesePokemonEnCatalog empty;
+        JapanesePokemonSetSource src{http, empty};
+        const auto out = src.fetchAll();
+        REQUIRE(out.isOk());
+        const Set* pmcg3 = nullptr;
+        for (const auto& s : out.value()) {
+            if (s.id == "PMCG3") {
+                pmcg3 = &s;
+                break;
+            }
+        }
+        REQUIRE(pmcg3 != nullptr);
+        CHECK(pmcg3->name == "PMCG3");
+    }
+
+    TEST_CASE("network error on list is surfaced") {
+        RoutingHttpClient http;
+        http.ok = false;
+        JapanesePokemonEnCatalog empty;
+        JapanesePokemonSetSource src{http, empty};
+        CHECK(src.fetchAll().isErr());
+    }
+
+    TEST_CASE("augmentCachedSets injects classic products into a cached list") {
+        RoutingHttpClient http;
+        JapanesePokemonEnCatalog empty;
+        JapanesePokemonSetSource src{http, empty};
+        std::vector<Set> cached;
+        Set pmcg2;
+        pmcg2.id = "PMCG2";
+        pmcg2.name = "Pokémon Jungle";
+        pmcg2.releaseDate = "1997/03/05";
+        cached.push_back(std::move(pmcg2));
+        src.augmentCachedSets(cached);
+        REQUIRE(cached.size() == 12);
+        // Jungle stays first; UnnumberedPromo (1997/03/06) is immediately after.
+        CHECK(cached[0].id == "PMCG2");
+        CHECK(cached[1].id == "UnnumberedPromo");
+        CHECK(cached[1].releaseDate == "1997/03/06");
+        bool foundTama = false;
+        bool foundUnnumbered = false;
+        for (const auto& s : cached) {
+            if (s.id == "TamamushiCG") {
+                foundTama = true;
+                CHECK(s.name == "Tamamushi City Gym");
+            }
+            if (s.id == "UnnumberedPromo") {
+                foundUnnumbered = true;
+                CHECK(s.name == "Unnumbered Promotional cards");
+            }
+        }
+        CHECK(foundTama);
+        CHECK(foundUnnumbered);
+    }
+
+    TEST_CASE("augmentCachedSets restores English names from catalog") {
+        RoutingHttpClient http;
+        const auto catalog = JapanesePokemonEnCatalog::parse(R"({
+            "sets": {
+                "PMCG2": {"name_en":"Pokémon Jungle","name_ja":"ポケモンジャングル","releaseDate":"1997/03/05"}
+            },
+            "prints": []
+        })");
+        REQUIRE(catalog.isOk());
+        JapanesePokemonSetSource src{http, catalog.value()};
+        std::vector<Set> cached;
+        Set pmcg2;
+        pmcg2.id = "PMCG2";
+        pmcg2.name = "PMCG2";  // stale cache stored the id as the display name
+        pmcg2.releaseDate = "1997/03/05";
+        cached.push_back(std::move(pmcg2));
+        src.augmentCachedSets(cached);
+        const Set* jungle = nullptr;
+        for (const auto& s : cached) {
+            if (s.id == "PMCG2") {
+                jungle = &s;
+                break;
+            }
+        }
+        REQUIRE(jungle != nullptr);
+        CHECK(jungle->name == "Pokémon Jungle");
+    }
+}
@@ -143,13 +143,57 @@ TEST_SUITE("JsonSetRepository") {
        CHECK(writeFail.error() == "write failed");
    }

-    TEST_CASE("paths are composed from dataStorage and game dir") {
+    TEST_CASE("paths use region-specific filenames for Pokemon West and Asia") {
        InMemoryFileSystem fs;
        auto cfg = makeConfig(fs, "/data");
        JsonSetRepository repo{fs, cfg, dirNameFn};
-        const std::vector<Set> sets = {{"base1", "Base Set", "1999/01/09"}};
+        const std::vector<Set> west = {{"base1", "Base Set", "1999/01/09"}};
+        const std::vector<Set> asia = {{"SV1a", "Triplet Beat", "2023/01/20"}};

-        REQUIRE(repo.save(Game::Pokemon, sets).isOk());
-        CHECK(fs.files().count("/data/pokemon/sets.json") == 1);
+        REQUIRE(repo.save(Game::Pokemon, west).isOk());
+        REQUIRE(repo.save(Game::JapanesePokemon, asia).isOk());
+        CHECK(fs.files().count("/data/pokemon/sets-west.json") == 1);
+        CHECK(fs.files().count("/data/pokemon/sets-asia.json") == 1);
+        CHECK(fs.files().count("/data/pokemon/sets.json") == 0);
+    }
+
+    TEST_CASE("load migrates legacy pokemon/sets.json to sets-west.json") {
+        InMemoryFileSystem fs;
+        auto cfg = makeConfig(fs, "/data");
+        const std::vector<Set> sets = {{"base1", "Base Set", "1999/01/09"}};
+        REQUIRE(fs.writeText("/data/pokemon/sets.json", nlohmann::json(sets).dump(2)).isOk());
+
+        JsonSetRepository repo{fs, cfg, dirNameFn};
+        const auto loaded = repo.load(Game::Pokemon);
+        REQUIRE(loaded.isOk());
+        CHECK(loaded.value() == sets);
+        CHECK(fs.files().count("/data/pokemon/sets-west.json") == 1);
+    }
+
+    TEST_CASE("load migrates legacy pokemonjp/sets.json to sets-asia.json") {
+        InMemoryFileSystem fs;
+        auto cfg = makeConfig(fs, "/data");
+        const std::vector<Set> sets = {{"SV1a", "Triplet Beat", "2023/01/20"}};
+        REQUIRE(fs.writeText("/data/pokemonjp/sets.json", nlohmann::json(sets).dump(2)).isOk());
+
+        JsonSetRepository repo{fs, cfg, dirNameFn};
+        const auto loaded = repo.load(Game::JapanesePokemon);
+        REQUIRE(loaded.isOk());
+        CHECK(loaded.value() == sets);
+        CHECK(fs.files().count("/data/pokemon/sets-asia.json") == 1);
+    }
+
+    TEST_CASE("load prefers new path over legacy when both exist") {
+        InMemoryFileSystem fs;
+        auto cfg = makeConfig(fs, "/data");
+        const std::vector<Set> legacy = {{"old", "Old", "1999/01/01"}};
+        const std::vector<Set> neu = {{"new", "New", "2024/01/01"}};
+        REQUIRE(fs.writeText("/data/pokemon/sets.json", nlohmann::json(legacy).dump(2)).isOk());
+        REQUIRE(fs.writeText("/data/pokemon/sets-west.json", nlohmann::json(neu).dump(2)).isOk());
+
+        JsonSetRepository repo{fs, cfg, dirNameFn};
+        const auto loaded = repo.load(Game::Pokemon);
+        REQUIRE(loaded.isOk());
+        CHECK(loaded.value() == neu);
    }
 }
@@ -17,6 +17,8 @@ std::string dirNameForGame(Game g) {
        case Game::Magic: return "magic";
        case Game::Pokemon: return "pokemon";
        case Game::YuGiOh: return "yugioh";
+        case Game::DigiBattle99: return "digibattle99";
+        case Game::JapanesePokemon: return "pokemon";
    }
    return "magic";
 }
@@ -29,6 +29,9 @@ public:
    std::string dirName()     const override {
        if (gameId == Game::Magic) return "magic";
        if (gameId == Game::Pokemon) return "pokemon";
+        if (gameId == Game::YuGiOh) return "yugioh";
+        if (gameId == Game::DigiBattle99) return "digibattle99";
+        if (gameId == Game::JapanesePokemon) return "pokemon";
        return "yugioh";
    }
    std::string displayName() const override { return dirName(); }
@@ -148,6 +151,72 @@ TEST_SUITE("SetService") {
        CHECK(yugioh.source.calls == 1);
    }

+    TEST_CASE("DigiBattle99 module routes independently when all games are registered") {
+        InMemSetRepo repo;
+        SetService svc{repo};
+
+        FakeGameModule magic{Game::Magic};
+        magic.source.result = Result<std::vector<Set>>::ok({{"lea", "Alpha", "1993/08/05"}});
+        FakeGameModule pokemon{Game::Pokemon};
+        pokemon.source.result = Result<std::vector<Set>>::ok({{"base1", "Base", "1999/01/09"}});
+        FakeGameModule yugioh{Game::YuGiOh};
+        yugioh.source.result = Result<std::vector<Set>>::ok({{"LOB", "Legend of Blue Eyes", "2002/03/08"}});
+        FakeGameModule digi{Game::DigiBattle99};
+        digi.source.result = Result<std::vector<Set>>::ok(
+            {{"series-1-starter-set", "Series 1 Starter Set", "1999/06/01"}});
+
+        svc.registerModule(&magic);
+        svc.registerModule(&pokemon);
+        svc.registerModule(&yugioh);
+        svc.registerModule(&digi);
+
+        REQUIRE(svc.updateSets(Game::Magic).isOk());
+        REQUIRE(svc.updateSets(Game::Pokemon).isOk());
+        REQUIRE(svc.updateSets(Game::YuGiOh).isOk());
+        const auto out = svc.updateSets(Game::DigiBattle99);
+        REQUIRE(out.isOk());
+        CHECK(out.value().front().id == "series-1-starter-set");
+        CHECK(magic.source.calls == 1);
+        CHECK(pokemon.source.calls == 1);
+        CHECK(yugioh.source.calls == 1);
+        CHECK(digi.source.calls == 1);
+    }
+
+    TEST_CASE("JapanesePokemon module routes independently when all games are registered") {
+        InMemSetRepo repo;
+        SetService svc{repo};
+
+        FakeGameModule magic{Game::Magic};
+        magic.source.result = Result<std::vector<Set>>::ok({{"lea", "Alpha", "1993/08/05"}});
+        FakeGameModule pokemon{Game::Pokemon};
+        pokemon.source.result = Result<std::vector<Set>>::ok({{"base1", "Base", "1999/01/09"}});
+        FakeGameModule yugioh{Game::YuGiOh};
+        yugioh.source.result = Result<std::vector<Set>>::ok({{"LOB", "Legend of Blue Eyes", "2002/03/08"}});
+        FakeGameModule digi{Game::DigiBattle99};
+        digi.source.result = Result<std::vector<Set>>::ok(
+            {{"series-1-starter-set", "Series 1 Starter Set", "1999/06/01"}});
+        FakeGameModule jp{Game::JapanesePokemon};
+        jp.source.result = Result<std::vector<Set>>::ok(
+            {{"PMCG1", "Expansion Pack", "1996/10/20"}});
+
+        svc.registerModule(&magic);
+        svc.registerModule(&pokemon);
+        svc.registerModule(&yugioh);
+        svc.registerModule(&digi);
+        svc.registerModule(&jp);
+
+        REQUIRE(svc.updateSets(Game::Magic).isOk());
+        REQUIRE(svc.updateSets(Game::Pokemon).isOk());
+        REQUIRE(svc.updateSets(Game::YuGiOh).isOk());
+        REQUIRE(svc.updateSets(Game::DigiBattle99).isOk());
+        const auto out = svc.updateSets(Game::JapanesePokemon);
+        REQUIRE(out.isOk());
+        CHECK(out.value().front().id == "PMCG1");
+        CHECK(jp.source.calls == 1);
+        CHECK(magic.source.calls == 1);
+        CHECK(pokemon.source.calls == 1);
+    }
+
    TEST_CASE("updateSets propagates repository save failures") {
        InMemSetRepo repo;
        repo.failSave = true;
@@ -0,0 +1,147 @@
+# Japanese Pokémon EN catalog ETL
+
+Offline pipeline that builds `ui_wx/assets/pokemon_jp_en_catalog.json` for the
+CCM3 Japanese Pokémon module. The C++ app loads this file at startup; it does
+**not** scrape Bulbapedia or PokéAPI at runtime.
+
+## Output schema
+
+```json
+{
+  "sets": {
+    "PMCG1": {
+      "name_en": "Expansion Pack",
+      "name_ja": "拡張パック",
+      "releaseDate": "1996/10/20"
+    }
+  },
+  "prints": [
+    {
+      "set_id": "PMCG1",
+      "local_id": "073",
+      "name_en": "Switch",
+      "name_ja": "ポケモンいれかえ",
+      "name_en_source": "trainer-table",
+      "tcgplayer_id": "575596"
+    },
+    {
+      "set_id": "PMCG4",
+      "local_id": "017",
+      "name_en": "Dark Charizard",
+      "name_ja": "わるいリザードン",
+      "name_en_source": "species-table-variant",
+      "tcgplayer_id": "575744"
+    }
+  ]
+}
+```
+
+`name_en_source` is one of `bulbapedia` | `species-table` | `species-table-variant` |
+`trainer-table` | `energy-table` | `manual` | `tcgdex-thirdparty`.
+
+Optional gap-fill fields (classic JA when TCGdex has no CDN scan):
+
+- `tcgplayer_id` — TCGPlayer product id from data-asia `thirdParty.tcgplayer`
+  (PMCG and other classic sets). Runtime builds
+  `https://product-images.tcgplayer.com/fit-in/437x437/{id}.jpg`
+- `image_url` — explicit HTTPS URL (wins over `tcgplayer_id` when both set).
+  Sources: City Gym bundled `asset:pokemon_jp_classic/...` paths, or neo1–neo4
+  Japanese CardIndex scans written by `enrich_neo_image_urls.py` (JP only;
+  empty `image_url` → card-back when no JP scan exists).
+
+## Suggested steps
+
+1. Snapshot TCGdex `GET /v2/ja/sets` into `_tcgdex_sets.json`.
+2. Maintain curated English display names in `set_en_names.json` (set id → EN).
+3. Run `merge_set_en_catalog.py` to emit set EN names into the catalog (also
+   refreshes classic TCGdex-missing products from `classic_missing_sets.json`).
+4. For Original-era products TCGdex omits (City Gym theme decks, Expansion
+   Sheets, Southern Islands), maintain `classic_missing_sets.json` +
+   `classic_missing_prints.json` and run `merge_classic_missing.py`. Print
+   `local_id`s are sequential `001`… within each product. Owner Pokémon use
+   full English titles (e.g. `Erika's Oddish`), not bare species names.
+   For Bulbapedia **Unnumbered Promotional cards**, run
+   `harvest_unnumbered_promos.py` to refresh the `UnnumberedPromo` set + prints,
+   then `enrich_unnumbered_promo_images.py` to write Bulbagarden Archives
+   `image_url` values that prefer Japanese / Unnumbered Promotional scans
+   (reprint/gallery) over English Wizards primary `|image=` files. Binding is
+   print-identity-aware (set/page tokens, no bare-species page fallback) so
+   unrelated Mewtwo promos do not share one WHF scan. EN-only Bulbapedia pages
+   leave `image_url` empty (card-back) — never store Wizards/Base Set EN
+   scans for Pokemon (Japan). Also fills `name_ja` when present. Then run
+   `merge_classic_missing.py`.
+   Cardmarket labels some Expansion Sheet / Vending Pokémon as EXP/EXS; those
+   may still be filed under `UnnumberedPromo` here (e.g. `Mewtwo (Vending S1)` /
+   `Mewtwo (Vending S3)`). Auto-detect matches bare species names as whole
+   tokens (`Mewtwo` → `Team GR's Mewtwo`, `Mewtwo Strikes Back (…)`, not `Mew`).
+   Runtime UX for this set (no Set # field; Next cycles synthetic localIds;
+   modeless print-preview popup) is documented under
+   `docs/assets-and-info-apis.md` → **Sets without printed collector numbers**.
+   For printing-accurate City Gym deck scans, run
+   `fetch_classic_gym_images.py` and store deck-specific `image_url` values as
+   `asset:pokemon_jp_classic/<setId>/<localId>.jpg`. Do **not** reuse PMCG
+   donor `tcgplayer_id`s for City Gym deck exclusives; that shows the wrong
+   Leaders' Stadium art.
+5. Extend `non_pokemon_en_by_ja.json` when new Trainer/Energy English aliases
+   are needed (JA name → EN display name; covers reprints of the same JA name).
+   Baseline coverage: **first 15 chronological TCGdex JA main sets**
+   (`PMCG1`–`PMCG6`, `neo1`–`neo4`, `VS1`, `web1`, `E1`–`E3`). See
+   `docs/assets-and-info-apis.md` → **Extending Trainer/Energy English aliases**.
+6. Run `enrich_preview_images.py` to merge from TCGdex cards-database
+   `data-asia`:
+   - `tcgplayer_id` for classic-image gap-fill (where data-asia exposes it)
+   - `name_ja` from card sources
+   - `name_en` via National Dex → English species table (`species_en.json`)
+     for ordinary Pokémon with `dexId` (e.g. Blastoise → `032`, Mewtwo → `050`)
+   - **Variant full titles** when `name_ja` matches a known prefix + `dexId`
+     (owner gym leaders, Rocket's, Dark, Light, Shining — e.g. `Erika's Oddish`,
+     `Dark Charizard`, `Shining Celebi`). Upgrades existing bare `species-table`
+     rows on re-enrich. Tagged `species-table-variant`.
+   - `name_en` via `non_pokemon_en_by_ja.json` for Trainer/Energy
+     (e.g. Switch ← `ポケモンいれかえ` → localId `073`)
+7. Run `enrich_neo_image_urls.py` after enrich when neo1–neo4 previews need
+   gap-fill. Writes `image_url` from **Japanese** CardIndex set scans (never
+   English pokemontcg.io). Matching is by English card name within the JA neo
+   set. Misses clear `image_url` (card-back). Use `--overwrite` to replace
+   stale EN URLs. See `docs/assets-and-info-apis.md`.
+8. Optionally refine `prints[]` name fields via Bulbapedia joins.
+
+At runtime, `JapanesePokemonSetSource` prefers catalog `name_en` and **never**
+leaves Japanese TCGdex names in `Set.name` (falls back to the set id). It also
+injects the classic missing products listed above. `JapanesePokemonCardPreviewSource`
+uses catalog `tcgplayer_id` / `image_url` only for the exact `setId`+`localId`
+when TCGdex has no scan, and falls back to catalog-only Auto-detect/preview
+when TCGdex has no set detail for a curated classic product.
+
+## Commands
+
+```bash
+# After refreshing tools/pokemon_jp/_tcgdex_sets.json and set_en_names.json:
+python tools/pokemon_jp/merge_set_en_catalog.py
+
+# After editing classic_missing_sets.json / classic_missing_prints.json:
+python tools/pokemon_jp/merge_classic_missing.py
+
+# Refresh UnnumberedPromo prints from Bulbapedia, enrich JP images, then merge:
+python tools/pokemon_jp/harvest_unnumbered_promos.py
+python tools/pokemon_jp/enrich_unnumbered_promo_images.py --force
+python tools/pokemon_jp/merge_classic_missing.py
+
+# After updating bundled City Gym deck scans:
+python tools/pokemon_jp/fetch_classic_gym_images.py
+
+# Harvest TCGPlayer ids + species/trainer/variant English aliases:
+python tools/pokemon_jp/enrich_preview_images.py
+
+# Fill neo1–neo4 image_url from Japanese CardIndex scans (run after enrich):
+python tools/pokemon_jp/enrich_neo_image_urls.py
+# Replace / clear previously written EN pokemontcg.io neo URLs:
+python tools/pokemon_jp/enrich_neo_image_urls.py --overwrite
+```
+
+Seed-only catalog writer (minimal rows):
+
+```bash
+python tools/pokemon_jp/build_catalog.py \
+  --out ui_wx/assets/pokemon_jp_en_catalog.json
+```
@@ -0,0 +1 @@
+#REDIRECT [[Fossil (TCG)]]
@@ -0,0 +1,81 @@
+#!/usr/bin/env python3
+"""Scaffold ETL for Japanese Pokémon EN catalog JSON.
+
+Seed mode (default) writes a small valid catalog matching the committed asset
+schema. Extend this script to pull TCGdex + Bulbapedia joins for full coverage.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+SEED = {
+    "sets": {
+        "PMCG1": {
+            "name_en": "Expansion Pack",
+            "name_ja": "拡張パック",
+            "releaseDate": "1996/10/20",
+        },
+        "PMCG2": {
+            "name_en": "Pokémon Jungle",
+            "name_ja": "ポケモンジャングル",
+            "releaseDate": "1997/03/14",
+        },
+        "SV1a": {
+            "name_en": "Triplet Beat",
+            "name_ja": "トリプレットビート",
+            "releaseDate": "2023/03/10",
+        },
+        "SV4a": {
+            "name_en": "Shiny Treasure ex",
+            "name_ja": "シャイニートレジャーex",
+            "releaseDate": "2023/11/10",
+        },
+    },
+    "prints": [
+        {
+            "set_id": "PMCG1",
+            "local_id": "014",
+            "name_en": "Charmander",
+            "name_ja": "ヒトカゲ",
+            "name_en_source": "bulbapedia",
+        },
+        {
+            "set_id": "PMCG1",
+            "local_id": "021",
+            "name_en": "Charizard",
+            "name_ja": "リザードン",
+            "name_en_source": "bulbapedia",
+        },
+        {
+            "set_id": "SV1a",
+            "local_id": "001",
+            "name_en": "Tropius",
+            "name_ja": "トロピウス",
+            "name_en_source": "bulbapedia",
+        },
+    ],
+}
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--out",
+        type=Path,
+        default=Path("ui_wx/assets/pokemon_jp_en_catalog.json"),
+        help="Output catalog path",
+    )
+    args = parser.parse_args()
+    args.out.parent.mkdir(parents=True, exist_ok=True)
+    args.out.write_text(
+        json.dumps(SEED, ensure_ascii=False, indent=2) + "\n",
+        encoding="utf-8",
+    )
+    print(f"Wrote seed catalog to {args.out}")
+
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,160 @@
+#!/usr/bin/env python3
+"""Build a full Japanese Pokémon EN set catalog from TCGdex + Wikipedia.
+
+Strategy:
+1. Pull JA set list from TCGdex (exclude CS*).
+2. Pull Wikipedia 'List of Pokémon Trading Card Game sets' wikitext and
+   extract English / Japanese name pairs from {{lang|ja|...}} near bold titles.
+3. Match by Japanese name (after TCGdex overrides). Unmatched sets get a
+   Latin fallback of the set id (never leave Japanese in Set.name).
+4. Fetch release dates from TCGdex set detail for catalog completeness.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import time
+import urllib.request
+from pathlib import Path
+
+UA = "CardCollectionManager3-ETL/0.1 (local; set-catalog)"
+JA_OVERRIDES = {
+    "SV4a": "シャイニートレジャーex",
+}
+
+
+def http_json(url: str):
+    req = urllib.request.Request(url, headers={"User-Agent": UA})
+    with urllib.request.urlopen(req, timeout=60) as resp:
+        return json.load(resp)
+
+
+def http_text_params(base: str, params: dict) -> dict:
+    from urllib.parse import urlencode
+
+    return http_json(base + "?" + urlencode(params))
+
+
+def contains_cjk(s: str) -> bool:
+    return any(
+        "\u3040" <= ch <= "\u30ff"
+        or "\u3400" <= ch <= "\u4dbf"
+        or "\u4e00" <= ch <= "\u9fff"
+        or "\uf900" <= ch <= "\ufaff"
+        for ch in s
+    )
+
+
+def wiki_en_ja_pairs() -> dict[str, str]:
+    """Map Japanese set name -> English display name from Wikipedia."""
+    data = http_text_params(
+        "https://en.wikipedia.org/w/api.php",
+        {
+            "action": "parse",
+            "page": "List of Pokémon Trading Card Game sets",
+            "prop": "wikitext",
+            "format": "json",
+            "formatversion": "2",
+        },
+    )
+    wt = data["parse"]["wikitext"]
+    # '''English Name''' ... lang|ja|Japanese Name
+    pairs: dict[str, str] = {}
+    for m in re.finditer(
+        r"'''([^']+)'''(?P<body>.{0,260}?)\{\{lang\|ja\|(?P<ja>[^}]+)\}\}",
+        wt,
+        flags=re.DOTALL,
+    ):
+        en = m.group(1).strip()
+        ja = m.group("ja").strip()
+        # Drop template noise / multi-ja (take first segment before &)
+        ja = re.split(r"\s*&\s*", ja)[0].strip()
+        ja = re.sub(r"<[^>]+>", "", ja).strip()
+        if not ja or not en or not contains_cjk(ja):
+            continue
+        # Prefer first English seen for a JA name
+        pairs.setdefault(ja, en)
+    return pairs
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--out",
+        type=Path,
+        default=Path("ui_wx/assets/pokemon_jp_en_catalog.json"),
+    )
+    parser.add_argument(
+        "--fetch-dates",
+        action="store_true",
+        help="Hit TCGdex set detail for each set (slow, ~1 req/s).",
+    )
+    args = parser.parse_args()
+
+    raw_sets = http_json("https://api.tcgdex.net/v2/ja/sets")
+    sets = [s for s in raw_sets if not str(s.get("id", "")).startswith("CS")]
+    print(f"TCGdex JA sets (excl CS*): {len(sets)}")
+
+    ja_to_en = wiki_en_ja_pairs()
+    print(f"Wikipedia JA->EN pairs: {len(ja_to_en)}")
+
+    # Keep existing print rows if present
+    existing_prints = []
+    if args.out.exists():
+        try:
+            prev = json.loads(args.out.read_text(encoding="utf-8"))
+            existing_prints = prev.get("prints", [])
+        except Exception:
+            pass
+
+    catalog_sets: dict[str, dict] = {}
+    matched = 0
+    for entry in sets:
+        sid = entry["id"]
+        name_ja = JA_OVERRIDES.get(sid, entry.get("name", ""))
+        name_en = ja_to_en.get(name_ja, "")
+        if not name_en:
+            # Fuzzy: Wikipedia sometimes includes extra spaces / fullwidth
+            for ja, en in ja_to_en.items():
+                if ja in name_ja or name_ja in ja:
+                    name_en = en
+                    break
+        if name_en:
+            matched += 1
+        else:
+            # Never leave CJK in the UI set picker — fall back to set id.
+            name_en = sid
+        catalog_sets[sid] = {
+            "name_en": name_en,
+            "name_ja": name_ja,
+            "releaseDate": "",
+        }
+
+    print(f"Matched Wikipedia EN names: {matched}/{len(sets)}")
+    print(f"Fallback to set id: {len(sets) - matched}")
+
+    if args.fetch_dates:
+        for i, sid in enumerate(catalog_sets):
+            try:
+                detail = http_json(f"https://api.tcgdex.net/v2/ja/sets/{sid}")
+                rd = detail.get("releaseDate") or ""
+                if rd:
+                    catalog_sets[sid]["releaseDate"] = rd.replace("-", "/")
+            except Exception as exc:
+                print(f"  date fail {sid}: {exc}")
+            time.sleep(0.35)
+            if (i + 1) % 20 == 0:
+                print(f"  dates {i+1}/{len(catalog_sets)}")
+
+    out = {"sets": catalog_sets, "prints": existing_prints}
+    args.out.parent.mkdir(parents=True, exist_ok=True)
+    args.out.write_text(
+        json.dumps(out, ensure_ascii=False, indent=2) + "\n", encoding="utf-8"
+    )
+    print(f"Wrote {args.out}")
+
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,57 @@
+{
+  "ExpSheet1": {
+    "name_en": "Expansion Sheet Series 1",
+    "name_ja": "拡張シート 第1弾",
+    "releaseDate": "1998/03/23"
+  },
+  "NiviCG": {
+    "name_en": "Nivi City Gym",
+    "name_ja": "ニビシティジム タケシ",
+    "releaseDate": "1998/04/26"
+  },
+  "HanadaCG": {
+    "name_en": "Hanada City Gym",
+    "name_ja": "ハナダシティジム カスミ",
+    "releaseDate": "1998/04/26"
+  },
+  "ExpSheet2": {
+    "name_en": "Expansion Sheet Series 2",
+    "name_ja": "拡張シート 第2弾",
+    "releaseDate": "1998/06/17"
+  },
+  "KuchibaCG": {
+    "name_en": "Kuchiba City Gym",
+    "name_ja": "クチバシティジム マチス",
+    "releaseDate": "1998/07/25"
+  },
+  "TamamushiCG": {
+    "name_en": "Tamamushi City Gym",
+    "name_ja": "タマムシシティジム エリカ",
+    "releaseDate": "1998/07/25"
+  },
+  "ExpSheet3": {
+    "name_en": "Expansion Sheet Series 3",
+    "name_ja": "拡張シート 第3弾",
+    "releaseDate": "1998/11/24"
+  },
+  "YamabukiCG": {
+    "name_en": "Yamabuki City Gym",
+    "name_ja": "ヤマブキシティジム ナツメ",
+    "releaseDate": "1999/02/26"
+  },
+  "GurenTG": {
+    "name_en": "Guren Town Gym",
+    "name_ja": "グレンタウンジム カツラ",
+    "releaseDate": "1999/02/26"
+  },
+  "SouthernIslands": {
+    "name_en": "Southern Islands",
+    "name_ja": "サザンアイランド",
+    "releaseDate": "1999/07/17"
+  },
+  "UnnumberedPromo": {
+    "name_en": "Unnumbered Promotional cards",
+    "name_ja": "番号なしプロモーションカード",
+    "releaseDate": "1997/03/06"
+  }
+}
@@ -0,0 +1,289 @@
+#!/usr/bin/env python3
+"""Fill neo1–neo4 catalog image_url from Japanese CardIndex scans only.
+
+TCGdex JA neo sets have image:null. This ETL scrapes CardIndex Japanese set
+pages (Awakening Legends, etc.) and writes HTTPS image_url values for exact
+JA setId+localId catalog rows.
+
+Policy (UnnumberedPromo parity): Japanese scans only. If CardIndex has no JP
+image for a print, image_url is cleared — never store English pokemontcg.io
+art as a fallback.
+
+Usage:
+  python tools/pokemon_jp/enrich_neo_image_urls.py
+  python tools/pokemon_jp/enrich_neo_image_urls.py --dry-run
+  python tools/pokemon_jp/enrich_neo_image_urls.py --overwrite
+  python tools/pokemon_jp/enrich_neo_image_urls.py --overwrite --limit 20
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import time
+import urllib.error
+import urllib.request
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[2]
+OUT = ROOT / "ui_wx" / "assets" / "pokemon_jp_en_catalog.json"
+
+NEO_SETS = frozenset({"neo1", "neo2", "neo3", "neo4"})
+UA = {
+    "User-Agent": (
+        "CCM3-pokemon-jp-etl/1.0 "
+        "(local; +https://github.com/sebastiandine/Card-Collection-Manager-3)"
+    )
+}
+
+# JA neo set id -> (CardIndex set page slug, image CDN folder)
+SET_META: dict[str, tuple[str, str]] = {
+    "neo1": ("gold-silver-to-a-new-world", "neo-jp-gold-silver"),
+    "neo2": ("crossing-the-ruins", "neo-jp-crossing-ruins"),
+    "neo3": ("awakening-legends", "neo-jp-awakening-legends"),
+    "neo4": ("darkness-and-to-light", "neo-jp-darkness-light"),
+}
+
+IMG_RE = re.compile(
+    r"https://images\.cardindex\.co/cardindex-images/cards/"
+    r"(?P<folder>[^/\"']+)/(?P<file>[^\"'\s>]+)\.(?P<ext>jpe?g|png|webp)",
+    re.IGNORECASE,
+)
+
+
+def log(msg: str) -> None:
+    try:
+        print(msg, flush=True)
+    except UnicodeEncodeError:
+        print(msg.encode("ascii", errors="replace").decode("ascii"), flush=True)
+
+
+def http_get(url: str, timeout: float = 60.0) -> str:
+    req = urllib.request.Request(url, headers=UA)
+    with urllib.request.urlopen(req, timeout=timeout) as resp:
+        return resp.read().decode("utf-8", "replace")
+
+
+def normalize_name(s: str) -> str:
+    """Lowercase alnum tokens for matching catalog names to CardIndex slugs."""
+    s = s.lower().replace("\u2019", "'").replace("'", "")
+    s = re.sub(r"[^a-z0-9]+", " ", s)
+    return " ".join(s.split())
+
+
+def slug_base_name(slug: str) -> str:
+    """shining-magikarp-129 / balloon-berry-promo -> shining magikarp / balloon berry."""
+    s = slug.strip().lower()
+    s = re.sub(r"-promo$", "", s)
+    s = re.sub(r"-\d+$", "", s)
+    return normalize_name(s.replace("-", " "))
+
+
+def pick_set_image(html: str, image_folder: str, card_slug: str) -> str | None:
+    """Prefer full-size JP scan in this set's CDN folder for this card slug."""
+    folder_l = image_folder.lower()
+    slug_l = card_slug.lower()
+    full: list[str] = []
+    small: list[str] = []
+    for m in IMG_RE.finditer(html):
+        if m.group("folder").lower() != folder_l:
+            continue
+        file_stem = m.group("file").lower()
+        # Require the card's own slug (with optional -small).
+        if not (file_stem == slug_l or file_stem == f"{slug_l}-small"):
+            # Also accept promo variant files named "{base}-promo".
+            base = re.sub(r"-\d+$", "", slug_l)
+            if not (
+                file_stem == f"{base}-promo"
+                or file_stem == f"{base}-promo-small"
+                or file_stem.startswith(f"{slug_l}")
+            ):
+                continue
+        url = m.group(0)
+        if file_stem.endswith("-small"):
+            small.append(url)
+        else:
+            full.append(url)
+    if full:
+        # Prefer exact slug match over promo/other.
+        for u in full:
+            if f"/{slug_l}." in u.lower():
+                return u
+        for u in full:
+            if f"/{slug_l}-" not in u.lower() or "-promo." in u.lower():
+                return u
+        return full[0]
+    if small:
+        # Upgrade -small to full-size URL when possible.
+        u = small[0]
+        return re.sub(r"-small\.(jpe?g|png|webp)$", r".\1", u, flags=re.I)
+    return None
+
+
+def scrape_set_index(
+    set_id: str, *, sleep_s: float
+) -> dict[str, list[tuple[str, str]]]:
+    """Return normalize_name -> [(card_slug, image_url), ...] for one neo set."""
+    page_slug, image_folder = SET_META[set_id]
+    set_url = f"https://www.cardindex.co/pokemon-cards/{page_slug}"
+    log(f"scraping set index {set_id}: {set_url}")
+    html = http_get(set_url)
+    card_slugs = sorted(
+        set(
+            re.findall(
+                rf"/pokemon-cards/{re.escape(page_slug)}/([a-z0-9\-]+)",
+                html,
+            )
+        )
+    )
+    log(f"  {len(card_slugs)} card pages")
+
+    by_name: dict[str, list[tuple[str, str]]] = {}
+    for i, slug in enumerate(card_slugs, start=1):
+        card_url = f"https://www.cardindex.co/pokemon-cards/{page_slug}/{slug}"
+        try:
+            time.sleep(sleep_s)
+            card_html = http_get(card_url)
+        except (urllib.error.URLError, TimeoutError) as exc:
+            log(f"  [{i}/{len(card_slugs)}] FAIL {slug}: {exc}")
+            continue
+        img = pick_set_image(card_html, image_folder, slug)
+        if not img:
+            log(f"  [{i}/{len(card_slugs)}] no JP image {slug}")
+            continue
+        name = slug_base_name(slug)
+        by_name.setdefault(name, []).append((slug, img))
+        log(f"  [{i}/{len(card_slugs)}] {name!r} <- {img}")
+    return by_name
+
+
+def resolve_url_for_print(
+    name_en: str, index: dict[str, list[tuple[str, str]]]
+) -> str | None:
+    key = normalize_name(name_en)
+    if not key:
+        return None
+    hits = index.get(key) or []
+    if not hits:
+        return None
+    # Unique image only — ambiguous Unown / multi-print names stay empty.
+    urls = sorted({u for _slug, u in hits})
+    if len(urls) == 1:
+        return urls[0]
+    return None
+
+
+def enrich_neo_images(
+    catalog: dict,
+    *,
+    dry_run: bool,
+    overwrite: bool,
+    sleep_s: float,
+    limit: int,
+    out_path: Path,
+) -> tuple[int, int, int, int]:
+    prints = catalog.get("prints", [])
+    candidates = [
+        p
+        for p in prints
+        if p.get("set_id") in NEO_SETS and (p.get("name_en") or "").strip()
+    ]
+    if not overwrite:
+        candidates = [
+            p for p in candidates if not (p.get("image_url") or "").strip()
+        ]
+    if limit > 0:
+        candidates = candidates[:limit]
+
+    # Scrape only the sets we need.
+    needed_sets = sorted({str(p["set_id"]) for p in candidates})
+    indexes: dict[str, dict[str, list[tuple[str, str]]]] = {}
+    for sid in needed_sets:
+        indexes[sid] = scrape_set_index(sid, sleep_s=sleep_s)
+
+    filled = 0
+    changed = 0
+    missed = 0
+    updates = 0
+
+    def persist() -> None:
+        if dry_run:
+            return
+        out_path.write_text(
+            json.dumps(catalog, ensure_ascii=False, indent=2) + "\n",
+            encoding="utf-8",
+        )
+
+    for i, p in enumerate(candidates, start=1):
+        sid = str(p["set_id"])
+        lid = str(p["local_id"])
+        name_en = str(p["name_en"]).strip()
+        prev = (p.get("image_url") or "").strip()
+        log(f"[{i}/{len(candidates)}] {sid}-{lid} {name_en!r} …")
+        url = resolve_url_for_print(name_en, indexes.get(sid, {}))
+        if url:
+            if not dry_run:
+                p["image_url"] = url
+            filled += 1
+            if url != prev:
+                changed += 1
+                updates += 1
+                log(f"  -> {url}" + (f" (was {prev})" if prev else ""))
+            else:
+                log(f"  -> {url} (unchanged)")
+        else:
+            missed += 1
+            if prev:
+                if not dry_run:
+                    p.pop("image_url", None)
+                changed += 1
+                updates += 1
+                log(f"  -> (miss, cleared {prev})")
+            else:
+                log("  -> (miss)")
+        if updates >= 25:
+            persist()
+            updates = 0
+            log(f"  checkpoint wrote {out_path}")
+
+    persist()
+    return len(candidates), filled, changed, missed
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(description=__doc__)
+    ap.add_argument("--out", type=Path, default=OUT)
+    ap.add_argument("--dry-run", action="store_true")
+    ap.add_argument(
+        "--overwrite",
+        action="store_true",
+        help="Re-resolve neo prints that already have image_url (clears EN URLs)",
+    )
+    ap.add_argument("--limit", type=int, default=0, help="Max neo prints to process")
+    ap.add_argument("--sleep", type=float, default=0.35, help="Seconds between HTTP calls")
+    args = ap.parse_args()
+
+    if not args.out.is_file():
+        raise SystemExit(f"catalog not found: {args.out}")
+
+    catalog = json.loads(args.out.read_text(encoding="utf-8"))
+    total, filled, changed, missed = enrich_neo_images(
+        catalog,
+        dry_run=args.dry_run,
+        overwrite=args.overwrite,
+        sleep_s=args.sleep,
+        limit=args.limit,
+        out_path=args.out,
+    )
+
+    print(
+        f"neo image_url: candidates={total} filled={filled} changed={changed} "
+        f"missed={missed}"
+        + (" (dry-run)" if args.dry_run else f" wrote {args.out}"),
+        flush=True,
+    )
+
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,471 @@
+#!/usr/bin/env python3
+"""Enrich pokemon_jp_en_catalog.json prints from TCGdex data-asia.
+
+Harvests per-card:
+  - tcgplayer_id (thirdParty.tcgplayer) for classic-image gap-fill
+  - name_ja from the card source
+  - name_en via National Dex id → English species name (when dexId present)
+  - name_en for owner / Rocket's / Dark / Light / Shining variants (full titles)
+  - name_en for Trainer/Energy via tools/pokemon_jp/non_pokemon_en_by_ja.json
+
+English names are required for Auto-detect when the user types "Mewtwo" /
+"Switch" / "Erika's Oddish" / "Dark Charizard" etc. — TCGdex set résumés only
+expose Japanese names.
+
+Usage:
+  python tools/pokemon_jp/enrich_preview_images.py
+  python tools/pokemon_jp/enrich_preview_images.py --data-asia path/to/data-asia
+"""
+
+from __future__ import annotations
+
+import argparse
+import io
+import json
+import re
+import shutil
+import urllib.request
+import zipfile
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[2]
+OUT = ROOT / "ui_wx" / "assets" / "pokemon_jp_en_catalog.json"
+CACHE_DIR = Path(__file__).resolve().parent / "_tcgdex_cards_database"
+SPECIES_CACHE = Path(__file__).resolve().parent / "species_en.json"
+NON_POKEMON_EN = Path(__file__).resolve().parent / "non_pokemon_en_by_ja.json"
+ZIP_URL = "https://github.com/tcgdex/cards-database/archive/refs/heads/master.zip"
+# National-dex-ordered English names (index 0 = Bulbasaur / dex 1).
+SPECIES_URL = (
+    "https://raw.githubusercontent.com/sindresorhus/pokemon/main/data/en.json"
+)
+
+TCGPLAYER_RE = re.compile(r"tcgplayer\s*:\s*(\d+)")
+NAME_JA_RE = re.compile(r"name\s*:\s*\{\s*ja\s*:\s*\"([^\"]+)\"", re.DOTALL)
+DEX_RE = re.compile(r"dexId\s*:\s*\[\s*(\d+)")
+CATEGORY_RE = re.compile(r'category\s*:\s*"([^"]+)"')
+LOCAL_ID_RE = re.compile(r"^[0-9A-Za-z]+$")
+
+# Chronological first 15 main Japanese expansions in TCGdex (for coverage checks).
+# Longest JA prefixes first. Maps to English product-title prefix + National Dex species.
+VARIANT_JA_PREFIXES: list[tuple[str, str]] = [
+    ("R団の", "Rocket's "),
+    ("エリカの", "Erika's "),
+    ("タケシの", "Brock's "),
+    ("カスミの", "Misty's "),
+    ("マチスの", "Lt. Surge's "),
+    ("ナツメの", "Sabrina's "),
+    ("カツラの", "Blaine's "),
+    ("キョウの", "Koga's "),
+    ("サカキの", "Giovanni's "),
+    ("ヤナギの", "Pryce's "),
+    ("カンナの", "Lorelei's "),
+    ("シバの", "Bruno's "),
+    ("キクコの", "Agatha's "),
+    ("やさしい", "Light "),
+    ("ひかる", "Shining "),
+    ("輝く", "Shining "),  # neo Destiny upstream garble
+    ("軽い", "Light "),  # neo Destiny upstream garble
+    ("わるい", "Dark "),
+    ("暗い", "Dark "),  # neo Destiny upstream garble
+    ("ダーク", "Dark "),  # neo Destiny upstream garble (e.g. ダークアリアドス)
+]
+
+PROTECTED_NAME_EN_SOURCES = frozenset(
+    {"manual", "trainer-table", "energy-table", "bulbapedia", "tcgdex-thirdparty"}
+)
+
+FIRST15_SETS = [
+    "PMCG1",
+    "PMCG2",
+    "PMCG3",
+    "PMCG4",
+    "PMCG5",
+    "PMCG6",
+    "neo1",
+    "neo2",
+    "neo3",
+    "neo4",
+    "VS1",
+    "web1",
+    "E1",
+    "E2",
+    "E3",
+]
+
+
+def download_data_asia(dest: Path) -> Path:
+    dest.mkdir(parents=True, exist_ok=True)
+    marker = dest / "data-asia"
+    if marker.is_dir() and any(marker.rglob("*.ts")):
+        return marker
+
+    print(f"Downloading {ZIP_URL} …")
+    req = urllib.request.Request(ZIP_URL, headers={"User-Agent": "ccm-pokemonjp-etl"})
+    with urllib.request.urlopen(req, timeout=180) as resp:
+        blob = resp.read()
+
+    with zipfile.ZipFile(io.BytesIO(blob)) as zf:
+        members = [n for n in zf.namelist() if "/data-asia/" in n.replace("\\", "/")]
+        for name in members:
+            parts = Path(name).parts
+            if "data-asia" not in parts:
+                continue
+            idx = parts.index("data-asia")
+            rel = Path(*parts[idx:])
+            target = dest / rel
+            if name.endswith("/"):
+                target.mkdir(parents=True, exist_ok=True)
+                continue
+            target.parent.mkdir(parents=True, exist_ok=True)
+            with zf.open(name) as src, open(target, "wb") as out:
+                shutil.copyfileobj(src, out)
+
+    if not marker.is_dir():
+        raise SystemExit("data-asia missing after zip extract")
+    return marker
+
+
+def load_species_en() -> dict[int, str]:
+    """Map National Dex id -> English species name."""
+    if SPECIES_CACHE.is_file():
+        raw = json.loads(SPECIES_CACHE.read_text(encoding="utf-8"))
+    else:
+        print(f"Downloading {SPECIES_URL} …")
+        req = urllib.request.Request(
+            SPECIES_URL, headers={"User-Agent": "ccm-pokemonjp-etl"}
+        )
+        with urllib.request.urlopen(req, timeout=60) as resp:
+            raw = json.loads(resp.read().decode("utf-8"))
+        SPECIES_CACHE.write_text(
+            json.dumps(raw, ensure_ascii=False, indent=2) + "\n", encoding="utf-8"
+        )
+    # File is a list: ["Bulbasaur", "Ivysaur", ...]
+    if isinstance(raw, list):
+        return {i + 1: name for i, name in enumerate(raw) if isinstance(name, str)}
+    if isinstance(raw, dict):
+        return {int(k): str(v) for k, v in raw.items()}
+    raise SystemExit("unexpected species_en.json shape")
+
+
+def load_non_pokemon_en() -> dict[str, str]:
+    """Map Japanese Trainer/Energy (etc.) names → English display names."""
+    if not NON_POKEMON_EN.is_file():
+        return {}
+    raw = json.loads(NON_POKEMON_EN.read_text(encoding="utf-8"))
+    if not isinstance(raw, dict):
+        raise SystemExit("non_pokemon_en_by_ja.json must be a JSON object")
+    return {str(k): str(v) for k, v in raw.items() if str(k).strip() and str(v).strip()}
+
+
+def extract_cards(data_asia: Path) -> dict[tuple[str, str], dict]:
+    """Map (setId, localId) -> {tcgplayer_id, name_ja, dex_id}."""
+    out: dict[tuple[str, str], dict] = {}
+    for path in data_asia.rglob("*.ts"):
+        try:
+            rel = path.relative_to(data_asia)
+        except ValueError:
+            continue
+        parts = rel.parts
+        if len(parts) != 3:
+            continue
+        set_id = parts[1]
+        local_id = path.stem
+        if not LOCAL_ID_RE.match(local_id):
+            continue
+        text = path.read_text(encoding="utf-8", errors="replace")
+        entry: dict = {}
+        m = TCGPLAYER_RE.search(text)
+        if m:
+            entry["tcgplayer_id"] = m.group(1)
+        m = NAME_JA_RE.search(text)
+        if m:
+            entry["name_ja"] = m.group(1)
+        m = DEX_RE.search(text)
+        if m:
+            entry["dex_id"] = int(m.group(1))
+        m = CATEGORY_RE.search(text)
+        category = m.group(1) if m else ""
+        # TCGdex PMCG1-102 Fighting Energy has an empty Japanese name in source.
+        if (
+            set_id == "PMCG1"
+            and local_id == "102"
+            and category == "Energy"
+            and not entry.get("name_ja")
+        ):
+            entry["name_ja"] = "基本闘エネルギー"
+        if not entry:
+            continue
+        out[(set_id, local_id)] = entry
+    return out
+
+
+def variant_en_prefix(name_ja: str) -> str | None:
+    """Return English title prefix for a known JA variant pattern, or None."""
+    for ja_prefix, en_prefix in VARIANT_JA_PREFIXES:
+        if name_ja.startswith(ja_prefix):
+            return en_prefix
+    return None
+
+
+def compose_species_name_en(
+    name_ja: str, dex_id: int | None, species_en: dict[int, str]
+) -> tuple[str, str] | None:
+    """Return (name_en, name_en_source) from dex + optional variant prefix."""
+    if dex_id is None or dex_id not in species_en:
+        return None
+    species = species_en[dex_id]
+    prefix = variant_en_prefix(name_ja)
+    if prefix:
+        return prefix + species, "species-table-variant"
+    return species, "species-table"
+
+
+def upgrade_variant_titles(
+    prints: list[dict],
+    cards: dict[tuple[str, str], dict],
+    species_en: dict[int, str],
+) -> int:
+    """Upgrade bare species-table rows to full variant English titles."""
+    upgraded = 0
+    for p in prints:
+        if (p.get("name_en_source") or "") in PROTECTED_NAME_EN_SOURCES:
+            continue
+        ja = (p.get("name_ja") or "").strip()
+        if not ja or variant_en_prefix(ja) is None:
+            continue
+        sid = str(p.get("set_id", ""))
+        lid = str(p.get("local_id", ""))
+        dex = cards.get((sid, lid), {}).get("dex_id")
+        composed = compose_species_name_en(ja, dex, species_en)
+        if composed is None:
+            continue
+        full_en, src = composed
+        if p.get("name_en") == full_en and p.get("name_en_source") == src:
+            continue
+        p["name_en"] = full_en
+        p["name_en_source"] = src
+        upgraded += 1
+    return upgraded
+
+
+def verify_first15_trainer_coverage(
+    data_asia: Path, non_pokemon_en: dict[str, str]
+) -> list[str]:
+    """Return unique Trainer/Energy JA names in FIRST15 still missing from the map."""
+    missing: set[str] = set()
+    for path in data_asia.rglob("*.ts"):
+        try:
+            rel = path.relative_to(data_asia)
+        except ValueError:
+            continue
+        parts = rel.parts
+        if len(parts) != 3 or parts[1] not in FIRST15_SETS:
+            continue
+        text = path.read_text(encoding="utf-8", errors="replace")
+        catm = CATEGORY_RE.search(text)
+        if not catm or catm.group(1) == "Pokemon":
+            continue
+        jam = NAME_JA_RE.search(text)
+        ja = jam.group(1) if jam else ""
+        if path.stem == "102" and parts[1] == "PMCG1" and not ja:
+            ja = "基本闘エネルギー"
+        if not ja:
+            missing.add(f"{parts[1]}/{path.stem} <empty name_ja>")
+            continue
+        if ja not in non_pokemon_en:
+            missing.add(ja)
+    return sorted(missing)
+
+
+def merge_catalog(
+    catalog: dict,
+    cards: dict[tuple[str, str], dict],
+    species_en: dict[int, str],
+    non_pokemon_en: dict[str, str],
+) -> tuple[int, int, int, int]:
+    prints = catalog.setdefault("prints", [])
+    by_key: dict[tuple[str, str], dict] = {}
+    for p in prints:
+        sid = str(p.get("set_id", ""))
+        lid = str(p.get("local_id", ""))
+        if sid and lid:
+            by_key[(sid, lid)] = p
+
+    updated = 0
+    added = 0
+    species_named = 0
+    table_named = 0
+    for (sid, lid), meta in sorted(cards.items()):
+        existing = by_key.get((sid, lid))
+        if existing is None:
+            existing = {
+                "set_id": sid,
+                "local_id": lid,
+                "name_en": "",
+                "name_ja": "",
+                "name_en_source": "",
+            }
+            prints.append(existing)
+            by_key[(sid, lid)] = existing
+            added += 1
+
+        changed = False
+        pid = meta.get("tcgplayer_id")
+        if pid and existing.get("tcgplayer_id") != pid:
+            existing["tcgplayer_id"] = pid
+            changed = True
+
+        name_ja = meta.get("name_ja", "")
+        if name_ja and not (existing.get("name_ja") or "").strip():
+            existing["name_ja"] = name_ja
+            changed = True
+
+        if not (existing.get("name_en") or "").strip():
+            dex = meta.get("dex_id")
+            ja_key = (existing.get("name_ja") or name_ja or "").strip()
+            composed = compose_species_name_en(ja_key, dex, species_en)
+            if composed is not None:
+                existing["name_en"], existing["name_en_source"] = composed
+                species_named += 1
+                changed = True
+            else:
+                ja_key = (existing.get("name_ja") or name_ja or "").strip()
+                if ja_key and ja_key in non_pokemon_en:
+                    existing["name_en"] = non_pokemon_en[ja_key]
+                    # Energies vs trainers: basic energy names share a pattern.
+                    if "エネルギー" in ja_key and ja_key.startswith("基本"):
+                        existing["name_en_source"] = "energy-table"
+                    elif "エネルギー" in ja_key:
+                        existing["name_en_source"] = "energy-table"
+                    else:
+                        existing["name_en_source"] = "trainer-table"
+                    table_named += 1
+                    changed = True
+
+        if changed:
+            updated += 1
+
+    # Also apply the JA→EN table to existing prints that were never in data-asia
+    # walk (or already present with name_ja but empty name_en).
+    for p in prints:
+        if (p.get("name_en") or "").strip():
+            continue
+        ja_key = (p.get("name_ja") or "").strip()
+        if not ja_key or ja_key not in non_pokemon_en:
+            continue
+        p["name_en"] = non_pokemon_en[ja_key]
+        if "エネルギー" in ja_key:
+            p["name_en_source"] = "energy-table"
+        else:
+            p["name_en_source"] = "trainer-table"
+        table_named += 1
+        updated += 1
+
+    catalog["prints"] = prints
+    return updated, added, species_named, table_named
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(description=__doc__)
+    ap.add_argument("--data-asia", type=Path, default=None)
+    ap.add_argument("--out", type=Path, default=OUT)
+    args = ap.parse_args()
+
+    if args.data_asia:
+        data_asia = args.data_asia
+        if not data_asia.is_dir():
+            raise SystemExit(f"data-asia not found: {data_asia}")
+    else:
+        data_asia = download_data_asia(CACHE_DIR)
+
+    species_en = load_species_en()
+    non_pokemon_en = load_non_pokemon_en()
+    cards = extract_cards(data_asia)
+    print(f"found {len(cards)} card files under {data_asia}")
+    print(f"non-pokemon EN map entries: {len(non_pokemon_en)}")
+
+    if args.out.exists():
+        catalog = json.loads(args.out.read_text(encoding="utf-8"))
+    else:
+        catalog = {"sets": {}, "prints": []}
+
+    updated, added, species_named, table_named = merge_catalog(
+        catalog, cards, species_en, non_pokemon_en
+    )
+    variant_upgraded = upgrade_variant_titles(
+        catalog["prints"], cards, species_en
+    )
+
+    for lid, expect_en in (
+        ("021", "Charizard"),
+        ("032", "Blastoise"),
+        ("050", "Mewtwo"),
+        ("073", "Switch"),
+    ):
+        hit = next(
+            (
+                p
+                for p in catalog["prints"]
+                if p.get("set_id") == "PMCG1" and p.get("local_id") == lid
+            ),
+            None,
+        )
+        if hit:
+            print(
+                f"PMCG1/{lid}: name_en={hit.get('name_en')!r} "
+                f"name_ja={hit.get('name_ja')!r} tp={hit.get('tcgplayer_id')}"
+            )
+            if hit.get("name_en") != expect_en:
+                print(f"  WARNING: expected name_en {expect_en!r}")
+        else:
+            print(f"WARNING: missing PMCG1/{lid}")
+
+    gaps = verify_first15_trainer_coverage(data_asia, non_pokemon_en)
+    if gaps:
+        print(f"WARNING: {len(gaps)} FIRST15 trainer/energy JA names still unmapped:")
+        for ja in gaps[:30]:
+            print(f"  - {ja}")
+        if len(gaps) > 30:
+            print(f"  ... and {len(gaps) - 30} more")
+    else:
+        print(f"FIRST15 trainer/energy coverage OK ({len(FIRST15_SETS)} sets)")
+
+    args.out.parent.mkdir(parents=True, exist_ok=True)
+    args.out.write_text(
+        json.dumps(catalog, ensure_ascii=False, indent=2) + "\n",
+        encoding="utf-8",
+    )
+    # Spot-check variant titles on classic sets.
+    for sid, lid, expect_en in (
+        ("PMCG5", "002", "Erika's Oddish"),
+        ("PMCG4", "017", "Dark Charizard"),
+        ("PMCG6", "042", "Rocket's Zapdos"),
+    ):
+        hit = next(
+            (
+                p
+                for p in catalog["prints"]
+                if p.get("set_id") == sid and p.get("local_id") == lid
+            ),
+            None,
+        )
+        if hit:
+            print(
+                f"{sid}/{lid}: name_en={hit.get('name_en')!r} "
+                f"source={hit.get('name_en_source')!r}"
+            )
+            if hit.get("name_en") != expect_en:
+                print(f"  WARNING: expected name_en {expect_en!r}")
+        else:
+            print(f"WARNING: missing {sid}/{lid}")
+
+    print(
+        f"wrote {args.out}: touched={updated} added={added} "
+        f"species_named={species_named} table_named={table_named} "
+        f"variant_upgraded={variant_upgraded} "
+        f"prints={len(catalog['prints'])}"
+    )
+
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,567 @@
+#!/usr/bin/env python3
+"""Fill UnnumberedPromo image_url / name_ja from Bulbapedia card pages.
+
+Reads tools/pokemon_jp/classic_missing_prints.json rows with set_id=UnnumberedPromo,
+resolves each `bulbapedia_page` (with redirects), and prefers Japanese /
+Unnumbered Promotional scans from reprint/gallery fields over the English
+primary `|image=` (often a Wizards Black Star print).
+
+If Bulbapedia only hosts an English scan, image_url is left empty (card-back)
+rather than storing a misleading EN preview.
+
+Usage:
+  python tools/pokemon_jp/enrich_unnumbered_promo_images.py
+  python tools/pokemon_jp/enrich_unnumbered_promo_images.py --force
+  python tools/pokemon_jp/enrich_unnumbered_promo_images.py --dry-run
+  python tools/pokemon_jp/enrich_unnumbered_promo_images.py --limit 20
+
+Then:
+  python tools/pokemon_jp/merge_classic_missing.py
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
+from pathlib import Path
+
+HERE = Path(__file__).resolve().parent
+PRINTS = HERE / "classic_missing_prints.json"
+SET_ID = "UnnumberedPromo"
+UA = "CCM3-pokemon-jp-etl/1.0 (local; +https://github.com/sebastiandine/Card-Collection-Manager-3)"
+API = "https://bulbapedia.bulbagarden.net/w/api.php"
+
+JNAME_RE = re.compile(r"\|\s*jname\s*=\s*([^\n|]+)", re.IGNORECASE)
+# |image= / |image1= / |reprint1= / |caption= / |caption2= / |recaption1=
+FIELD_RE = re.compile(
+    r"\|\s*(image|reprint|caption|recaption)(\d*)\s*=\s*([^\n]+)",
+    re.IGNORECASE,
+)
+
+SKIP_IMAGE_SUBSTR = (
+    "attack.png",
+    "card_back",
+    "cardback",
+    "project_tcg",
+    "setsymbol",
+    "rare_",
+    "energy.png",
+    "tcg1_",
+    "tcg2_",
+    "misprint",
+)
+
+# Filename / caption hints that the scan is the Japanese unnumbered print.
+JP_FILENAME_MARKERS = (
+    "corocoro",
+    "whf",
+    "fanbook",
+    "unnumbered",
+    "japanese",
+    "gb2",
+    "illustrator",
+    "battleroad",
+    "movie",
+    "parentchild",
+    "vending",
+    "asobikata",
+    "jogress",
+    "pokedude",
+    "daisuki",
+    "specialsheet",
+    "informationpack",
+    "howibecame",
+    "newgarura",
+    "touchgeneration",
+    "championleague",
+    "worldofillusions",
+    "clashatthesummit",
+    "blackwhitetour",
+    "warnerbros",
+    "nintendo64",
+    "teamgr",
+    "imakuni",
+    "tradeplease",
+    "hungrysnorlax",
+    "coolporygon",  # often still EN — scored only with caption
+)
+
+# Captions that mark the Unnumbered / JP print on shared EN+JP articles.
+JP_CAPTION_MARKERS = (
+    "unnumbered promotional",
+    "unnumbered promo",
+    "japanese",
+    "jpexpansion",
+)
+
+# English primary prints we must not prefer when a JP candidate exists.
+EN_FILENAME_MARKERS = (
+    "wizardspromo",
+    "baseset",
+    "neogenesis",
+    "fossil",
+    "teamrocket",
+    "jungle",
+    "legendarycollection",
+    "dppromo",
+    "mysterious treasures",
+    "mysterioustreasures",
+    "diamondpearl",
+    "exdragon",
+    "exholon",
+    "exdelta",
+    "neodiscovery",
+    "neorevelations",
+    "neodestiny",
+    "gymheroes",
+    "gymchallenge",
+    "nintendopromo",  # often EN Black Star; allow if also JP-captioned
+)
+
+
+def api(**params: object) -> dict:
+    qs = urllib.parse.urlencode({k: v for k, v in params.items() if v is not None})
+    req = urllib.request.Request(f"{API}?{qs}", headers={"User-Agent": UA})
+    with urllib.request.urlopen(req, timeout=90) as resp:
+        return json.load(resp)
+
+
+def fetch_wikitext(page: str) -> tuple[str, str] | None:
+    """Return (resolved_title, wikitext) or None if missing."""
+    try:
+        data = api(
+            action="parse",
+            page=page,
+            prop="wikitext",
+            format="json",
+            redirects=1,
+        )
+    except urllib.error.HTTPError:
+        return None
+    except urllib.error.URLError:
+        return None
+    if "error" in data:
+        return None
+    parsed = data.get("parse") or {}
+    wt = (parsed.get("wikitext") or {}).get("*")
+    title = parsed.get("title") or page
+    if not wt:
+        return None
+    return title, wt
+
+
+def file_url(filename: str) -> str | None:
+    fname = filename.strip().replace(" ", "_")
+    if not fname:
+        return None
+    data = api(
+        action="query",
+        titles=f"File:{fname}",
+        prop="imageinfo",
+        iiprop="url",
+        format="json",
+    )
+    pages = (data.get("query") or {}).get("pages") or {}
+    for page in pages.values():
+        infos = page.get("imageinfo") or []
+        if infos and infos[0].get("url"):
+            return str(infos[0]["url"])
+    return None
+
+
+def normalize_filename(raw: str) -> str | None:
+    s = raw.strip().split("|", 1)[0].strip()
+    s = re.sub(r"\[\[(?:File:)?([^\]|]+).*", r"\1", s, flags=re.IGNORECASE)
+    s = s.strip()
+    if not s:
+        return None
+    low = s.lower().replace(" ", "_")
+    if any(tok in low for tok in SKIP_IMAGE_SUBSTR):
+        return None
+    if not re.search(r"\.(jpe?g|png|gif|webp)$", low):
+        return None
+    return s
+
+
+def score_candidate(filename: str, caption: str) -> int:
+    """Higher is better. Score <= 0 means EN-only / reject for UnnumberedPromo."""
+    fl = filename.lower().replace(" ", "").replace("_", "")
+    cl = caption.lower()
+    score = 0
+
+    if any(m in cl for m in JP_CAPTION_MARKERS):
+        score += 100
+    if any(m.replace(" ", "") in fl for m in JP_FILENAME_MARKERS):
+        score += 50
+    if "promo" in fl and not any(m in fl for m in ("wizardspromo", "nintendopromo", "dppromo")):
+        score += 10
+
+    en_hit = any(m.replace(" ", "") in fl for m in EN_FILENAME_MARKERS)
+    if en_hit:
+        # EN primary unless caption explicitly marks Unnumbered/JP.
+        if score < 100:
+            return -100
+        score -= 20
+
+    return score
+
+
+def collect_image_candidates(wikitext: str) -> list[tuple[int, str]]:
+    """Return (score, filename) for JP-eligible images, best first."""
+    # Map field key -> value for pairing imageN with captionN / reprintN with recaptionN.
+    fields: dict[str, str] = {}
+    for m in FIELD_RE.finditer(wikitext):
+        kind = m.group(1).lower()
+        num = m.group(2) or ""
+        val = m.group(3).strip()
+        fields[f"{kind}{num}"] = val
+
+    candidates: list[tuple[int, str]] = []
+    seen: set[str] = set()
+
+    def add(fname_raw: str, caption: str) -> None:
+        fname = normalize_filename(fname_raw)
+        if not fname:
+            return
+        key = fname.lower().replace(" ", "_")
+        if key in seen:
+            return
+        score = score_candidate(fname, caption)
+        if score <= 0:
+            return
+        seen.add(key)
+        candidates.append((score, fname))
+
+    # Primary image + caption (usually EN — only kept if JP-scored).
+    if "image" in fields:
+        add(fields["image"], fields.get("caption", ""))
+
+    # reprintN + recaptionN (common home of Unnumbered JP scans).
+    for key, val in list(fields.items()):
+        m = re.fullmatch(r"reprint(\d+)", key)
+        if not m:
+            continue
+        n = m.group(1)
+        add(val, fields.get(f"recaption{n}", "") or fields.get(f"caption{n}", ""))
+
+    # Gallery imageN + captionN.
+    for key, val in list(fields.items()):
+        m = re.fullmatch(r"image(\d+)", key)
+        if not m:
+            continue
+        n = m.group(1)
+        add(val, fields.get(f"caption{n}", "") or fields.get(f"recaption{n}", ""))
+
+    candidates.sort(key=lambda t: (-t[0], t[1].lower()))
+    return candidates
+
+
+def normalize_token_blob(s: str) -> str:
+    """Lowercase alnum-only blob for substring affinity checks."""
+    return re.sub(r"[^a-z0-9]+", "", s.lower())
+
+
+def identity_tokens(print_row: dict) -> list[str]:
+    """Significant tokens from this print's promo identity (set / page)."""
+    raw_bits: list[str] = []
+    for key in ("tcg_set", "bulbapedia_page", "name_en"):
+        val = str(print_row.get(key) or "").strip()
+        if val:
+            raw_bits.append(val)
+    # Prefer longer set-like phrases first.
+    tokens: list[str] = []
+    for bit in raw_bits:
+        # Drop trailing extras like "(Jumbo)".
+        bit = re.sub(r"\s*\([^)]*(?:Jumbo|Mini|Silver|Gold)[^)]*\)\s*", " ", bit)
+        # Pull parenthetical set qualifier: "Mewtwo (WHF Special Sheet promo)".
+        m = re.search(r"\(([^)]+)\)", bit)
+        if m:
+            inner = m.group(1)
+            inner = re.sub(r"\bpromo\b", "", inner, flags=re.I).strip()
+            if inner:
+                tokens.append(inner)
+        tokens.append(bit)
+    # Significant wordy tokens (>=3 chars after normalize), longest first.
+    out: list[str] = []
+    seen: set[str] = set()
+    for t in tokens:
+        norm = normalize_token_blob(t)
+        if len(norm) < 4:
+            continue
+        if norm in seen:
+            continue
+        # Skip generic card-name-only blobs when we have set context.
+        seen.add(norm)
+        out.append(norm)
+    out.sort(key=len, reverse=True)
+    return out
+
+
+def has_print_affinity(
+    print_row: dict,
+    requested_page: str,
+    resolved_title: str,
+    filename: str,
+    caption: str = "",
+) -> bool:
+    """True if this JP candidate belongs to this print, not a borrowed promo."""
+    tokens = identity_tokens(print_row)
+    token_set = set(tokens)
+    hay = normalize_token_blob(filename + " " + caption + " " + resolved_title)
+    fl = normalize_token_blob(filename)
+    req = normalize_token_blob(requested_page)
+    resolved = normalize_token_blob(resolved_title)
+
+    # Filename names a specific JP promo family this print is not part of → reject.
+    foreign_markers = (
+        "whf",
+        "corocoro",
+        "fanbook",
+        "gb2",
+        "specialsheet",
+        "songbest",
+        "battleroad",
+        "teamgr",
+        "illustrator",
+        "asobikata",
+        "vending",
+        "movie",
+    )
+    for marker in foreign_markers:
+        if marker in fl and not any(marker in tok for tok in token_set):
+            # e.g. WHF file on a Wizards Promo / Song Best Collection row.
+            return False
+
+    # Resolved title still matches what we asked for (allow mild redirect rename).
+    if req and (req in resolved or resolved in req):
+        # Still require filename not foreign (handled above); OK.
+        if any(m in fl for m in foreign_markers) or "unnumbered" in hay or any(
+            len(tok) >= 5 and tok in fl for tok in token_set
+        ):
+            return True
+        # Requested page matched but image is generic EN — leave to score_candidate.
+        if any(len(tok) >= 5 and tok in hay for tok in token_set):
+            return True
+
+    tcg_set = str(print_row.get("tcg_set") or "").strip()
+    tcg_set_norm = normalize_token_blob(tcg_set)
+    # Wizards Promo rows may use the Wizards article, but only with a
+    # non-foreign JP file (foreign_markers already rejected WHF/etc.).
+    if tcg_set_norm.startswith("wizardspromo") and "wizardspromo" in resolved:
+        if "wizardspromo" in fl or (
+            any(m in caption.lower() for m in JP_CAPTION_MARKERS)
+            and not any(m in fl for m in foreign_markers)
+        ):
+            return True
+        return False
+
+    # Reject borrowing from a generic Wizards Promo dump unless this print is that set.
+    if "wizardspromo" in resolved and not tcg_set_norm.startswith("wizardspromo"):
+        for tok in tokens:
+            if len(tok) >= 5 and tok in hay and "wizardspromo" not in tok:
+                species = normalize_token_blob(str(print_row.get("tcg_name") or ""))
+                if species and tok == species:
+                    continue
+                return True
+        return False
+
+    for tok in tokens:
+        if len(tok) >= 5 and tok in hay:
+            species = normalize_token_blob(str(print_row.get("tcg_name") or ""))
+            if species and tok == species:
+                continue
+            return True
+        if len(tok) >= 3 and tok in ("whf", "gb2") and tok in hay:
+            return True
+
+    for tok in tokens:
+        if len(tok) >= 5 and tok in fl:
+            species = normalize_token_blob(str(print_row.get("tcg_name") or ""))
+            if species and tok == species:
+                continue
+            return True
+
+    return False
+
+
+def pick_image_filename_for_print(
+    print_row: dict,
+    requested_page: str,
+    resolved_title: str,
+    wikitext: str,
+) -> str | None:
+    """Best JP scan that also has affinity with this print's promo identity."""
+    fields: dict[str, str] = {}
+    for m in FIELD_RE.finditer(wikitext):
+        fields[f"{m.group(1).lower()}{m.group(2) or ''}"] = m.group(3).strip()
+
+    def caption_for(fname: str) -> str:
+        target = fname.lower().replace(" ", "_")
+        for key, val in fields.items():
+            nf = normalize_filename(val)
+            if not nf or nf.lower().replace(" ", "_") != target:
+                continue
+            if key == "image":
+                return fields.get("caption", "")
+            m = re.fullmatch(r"(reprint|image)(\d+)", key)
+            if not m:
+                continue
+            n = m.group(2)
+            if m.group(1) == "reprint":
+                return fields.get(f"recaption{n}", "") or fields.get(f"caption{n}", "")
+            return fields.get(f"caption{n}", "") or fields.get(f"recaption{n}", "")
+        return ""
+
+    for _score, fname in collect_image_candidates(wikitext):
+        if has_print_affinity(
+            print_row, requested_page, resolved_title, fname, caption_for(fname)
+        ):
+            return fname
+    return None
+
+
+def pick_jname(wikitext: str) -> str:
+    m = JNAME_RE.search(wikitext)
+    if not m:
+        return ""
+    return m.group(1).strip()
+
+
+def candidate_pages(print_row: dict) -> list[str]:
+    """Qualified Bulbapedia titles only — never bare species (avoids shared dumps)."""
+    out: list[str] = []
+    page = str(print_row.get("bulbapedia_page") or "").strip()
+    if page:
+        out.append(page)
+    tcg_set = str(print_row.get("tcg_set") or "").strip()
+    tcg_name = str(print_row.get("tcg_name") or "").strip()
+    tcg_num = str(print_row.get("tcg_num") or "").strip()
+    if tcg_name and tcg_set:
+        if not tcg_num or tcg_num.lower() == "promo":
+            out.append(f"{tcg_name} ({tcg_set} promo)")
+        else:
+            out.append(f"{tcg_name} ({tcg_set} {tcg_num})")
+            out.append(f"{tcg_name} ({tcg_set} promo)")
+    # Full qualified English title from harvest (may include Jumbo markers).
+    name_en = str(print_row.get("name_en") or "").strip()
+    if name_en and "(" in name_en:
+        # Strip only trailing variant markers, keep set qualifier.
+        cleaned = re.sub(
+            r"\s*\((?:Jumbo|Mini|Silver|Gold|Silver w/Stamp)[^)]*\)\s*$",
+            "",
+            name_en,
+            flags=re.I,
+        ).strip()
+        if cleaned:
+            out.append(cleaned)
+        out.append(name_en)
+    seen: set[str] = set()
+    uniq: list[str] = []
+    for p in out:
+        if p and p not in seen:
+            seen.add(p)
+            uniq.append(p)
+    return uniq
+
+
+def enrich_print(print_row: dict, sleep_s: float) -> bool:
+    """Mutate print_row with JP image_url / name_ja. Return True if image filled."""
+    already = str(print_row.get("image_url") or "").strip()
+    if already:
+        return False
+
+    for page in candidate_pages(print_row):
+        time.sleep(sleep_s)
+        resolved = fetch_wikitext(page)
+        if not resolved:
+            continue
+        title, wt = resolved
+        if not str(print_row.get("name_ja") or "").strip():
+            jname = pick_jname(wt)
+            if jname:
+                print_row["name_ja"] = jname
+        fname = pick_image_filename_for_print(print_row, page, title, wt)
+        if not fname:
+            continue
+        time.sleep(sleep_s)
+        url = file_url(fname)
+        if url:
+            print_row["image_url"] = url
+            return True
+    return False
+
+
+def log(msg: str) -> None:
+    try:
+        print(msg)
+    except UnicodeEncodeError:
+        print(msg.encode("ascii", errors="replace").decode("ascii"))
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--dry-run", action="store_true")
+    ap.add_argument("--limit", type=int, default=0, help="Max UnnumberedPromo rows")
+    ap.add_argument("--sleep", type=float, default=0.35, help="Seconds between API calls")
+    ap.add_argument("--force", action="store_true", help="Overwrite existing image_url")
+    ap.add_argument(
+        "--save-every",
+        type=int,
+        default=25,
+        help="Persist classic_missing_prints.json every N updates",
+    )
+    args = ap.parse_args()
+
+    all_prints: list[dict] = json.loads(PRINTS.read_text(encoding="utf-8"))
+    targets = [p for p in all_prints if str(p.get("set_id")) == SET_ID]
+    if args.limit > 0:
+        targets = targets[: args.limit]
+
+    def persist() -> None:
+        if args.dry_run:
+            return
+        PRINTS.write_text(
+            json.dumps(all_prints, ensure_ascii=False, indent=2) + "\n", encoding="utf-8"
+        )
+
+    filled = 0
+    missed = 0
+    updates_since_save = 0
+    for i, p in enumerate(targets, start=1):
+        lid = p.get("local_id")
+        name = p.get("name_en")
+        if args.force:
+            p.pop("image_url", None)
+        if str(p.get("image_url") or "").strip():
+            log(f"[{i}/{len(targets)}] skip {lid} {name} (already has image)")
+            continue
+        ok = enrich_print(p, sleep_s=args.sleep)
+        if ok:
+            filled += 1
+            updates_since_save += 1
+            log(f"[{i}/{len(targets)}] OK {lid} {name} -> {p.get('image_url')}")
+        else:
+            missed += 1
+            # Ensure stale EN URLs do not linger after --force.
+            p.pop("image_url", None)
+            log(f"[{i}/{len(targets)}] MISS {lid} {name}")
+        if updates_since_save >= args.save_every:
+            persist()
+            updates_since_save = 0
+            log(f"  checkpoint wrote {PRINTS}")
+
+    log(f"filled={filled} missed={missed} total={len(targets)}")
+    if args.dry_run:
+        log(f"dry-run: not writing {PRINTS}")
+        return
+    persist()
+    log(f"wrote {PRINTS}")
+
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,76 @@
+#!/usr/bin/env python3
+"""Download and convert bundled classic Japanese gym-deck scans.
+
+Writes JPEGs under ui_wx/assets/pokemon_jp_classic/<setId>/<localId>.jpg.
+Uses dwebp + cjpeg from the local MSYS2 toolchain so we do not need Pillow.
+"""
+
+from __future__ import annotations
+
+import shutil
+import subprocess
+import tempfile
+import urllib.request
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[2]
+OUT_DIR = ROOT / "ui_wx" / "assets" / "pokemon_jp_classic"
+
+# Curated direct CDN/file URLs for printing-accurate deck scans.
+SOURCES: dict[tuple[str, str], str] = {
+    # TCGCollector static CDN URL for Erika (City Gym Decks No. 061).
+    ("TamamushiCG", "016"): (
+        "https://static.tcgcollector.com/content/images/9d/33/c6/"
+        "9d33c6ffe701da03266dd5a65c6ee9537c7043b63b880cf3889f644e1c66aa6f.webp"
+    ),
+}
+
+
+def tool(name: str) -> str:
+    path = shutil.which(name)
+    if path is None:
+        raise SystemExit(f"required tool not found on PATH: {name}")
+    return path
+
+
+def download(url: str, dest: Path) -> None:
+    req = urllib.request.Request(url, headers={"User-Agent": "Mozilla/5.0"})
+    with urllib.request.urlopen(req, timeout=60) as resp:
+        dest.write_bytes(resp.read())
+
+
+def convert_to_jpeg(src: Path, dest: Path) -> None:
+    suffix = src.suffix.lower()
+    if suffix in {".jpg", ".jpeg"}:
+        shutil.copyfile(src, dest)
+        return
+    if suffix == ".webp":
+        dwebp = tool("dwebp")
+        cjpeg = tool("cjpeg")
+        with tempfile.NamedTemporaryFile(suffix=".ppm", delete=False) as tmp:
+            ppm = Path(tmp.name)
+        try:
+            subprocess.run([dwebp, str(src), "-ppm", "-o", str(ppm)], check=True)
+            with open(dest, "wb") as out:
+                subprocess.run([cjpeg, "-quality", "92", str(ppm)], check=True, stdout=out)
+        finally:
+            ppm.unlink(missing_ok=True)
+        return
+    raise SystemExit(f"unsupported source format: {src}")
+
+
+def main() -> None:
+    for (set_id, local_id), url in SOURCES.items():
+        out_dir = OUT_DIR / set_id
+        out_dir.mkdir(parents=True, exist_ok=True)
+        target = out_dir / f"{local_id}.jpg"
+        with tempfile.TemporaryDirectory() as td:
+            src = Path(td) / Path(url).name
+            print(f"download {set_id}/{local_id} <- {url}")
+            download(url, src)
+            convert_to_jpeg(src, target)
+        print(f"wrote {target}")
+
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,115 @@
+#!/usr/bin/env python3
+"""Build English set names for Japanese Pokémon catalog from Serebii + TCGdex."""
+
+from __future__ import annotations
+
+import json
+import re
+import urllib.request
+from html import unescape
+from pathlib import Path
+
+UA = "CardCollectionManager3-ETL/0.1"
+OUT = Path("ui_wx/assets/pokemon_jp_en_catalog.json")
+SEREBII = "https://www.serebii.net/card/japanese.shtml"
+JA_OVERRIDES = {"SV4a": "シャイニートレジャーex"}
+
+
+def get_bytes(url: str) -> bytes:
+    req = urllib.request.Request(url, headers={"User-Agent": UA})
+    with urllib.request.urlopen(req, timeout=60) as resp:
+        return resp.read()
+
+
+def contains_cjk(s: str) -> bool:
+    return any(ord(c) >= 0x80 for c in s)
+
+
+def parse_serebii_ja_en(html: str) -> dict[str, str]:
+    """Extract Japanese -> English set name pairs from Serebii japanese.shtml."""
+    ja_en: dict[str, str] = {}
+
+    # Common patterns on the page:
+    #  English Name<br>Japanese
+    #  English Name (Japanese)
+    #  <a ...>English</a> ... Japanese in nearby cell
+    for m in re.finditer(
+        r">([A-Za-z0-9][^<]{1,70}?)</(?:a|b|font|td|span)>\s*<br\s*/?>\s*"
+        r"([^<]{2,50}?)<",
+        html,
+        flags=re.IGNORECASE,
+    ):
+        en = unescape(re.sub(r"\s+", " ", m.group(1))).strip()
+        ja = unescape(re.sub(r"\s+", " ", m.group(2))).strip()
+        if contains_cjk(ja) and not contains_cjk(en) and len(en) > 1:
+            ja_en.setdefault(ja, en)
+
+    for m in re.finditer(
+        r">([A-Za-z0-9][^<]{1,70}?)\s*\(([^)]{2,50})\)<",
+        html,
+    ):
+        en = unescape(re.sub(r"\s+", " ", m.group(1))).strip()
+        ja = unescape(re.sub(r"\s+", " ", m.group(2))).strip()
+        if contains_cjk(ja) and not contains_cjk(en) and len(en) > 1:
+            ja_en.setdefault(ja, en)
+
+    return ja_en
+
+
+def main() -> None:
+    sets = [
+        s
+        for s in json.loads(get_bytes("https://api.tcgdex.net/v2/ja/sets"))
+        if not str(s.get("id", "")).startswith("CS")
+    ]
+    print("tcgdex sets", len(sets))
+
+    html = get_bytes(SEREBII).decode("utf-8", "replace")
+    Path("tools/pokemon_jp/_serebii_japanese.html").write_text(html, encoding="utf-8")
+    print("serebii bytes", len(html))
+
+    ja_en = parse_serebii_ja_en(html)
+    print("ja->en pairs", len(ja_en))
+    for ja, en in list(ja_en.items())[:12]:
+        print(f"  {en!r} <- {ja!r}")
+
+    prints = []
+    if OUT.exists():
+        try:
+            prints = json.loads(OUT.read_text(encoding="utf-8")).get("prints", [])
+        except Exception:
+            pass
+
+    catalog: dict[str, dict] = {}
+    matched = 0
+    for entry in sets:
+        sid = entry["id"]
+        name_ja = JA_OVERRIDES.get(sid, entry.get("name", ""))
+        name_en = ja_en.get(name_ja, "")
+        if not name_en:
+            for ja, en in ja_en.items():
+                if ja == name_ja or ja in name_ja or name_ja in ja:
+                    name_en = en
+                    break
+        if name_en:
+            matched += 1
+        else:
+            name_en = sid
+        catalog[sid] = {
+            "name_en": name_en,
+            "name_ja": name_ja,
+            "releaseDate": "",
+        }
+
+    print(f"matched {matched}/{len(sets)}; id fallback {len(sets) - matched}")
+    OUT.parent.mkdir(parents=True, exist_ok=True)
+    OUT.write_text(
+        json.dumps({"sets": catalog, "prints": prints}, ensure_ascii=False, indent=2)
+        + "\n",
+        encoding="utf-8",
+    )
+    print("wrote", OUT)
+
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,239 @@
+#!/usr/bin/env python3
+"""Harvest Bulbapedia Unnumbered Promotional cards into classic_missing seed JSON.
+
+Fetches:
+  - Unnumbered_Promotional_cards_(TCG)/1996-2005
+  - Yearly sections on Unnumbered_Promotional_cards_(TCG) (2006+)
+
+Writes/updates:
+  - tools/pokemon_jp/classic_missing_sets.json  (adds UnnumberedPromo)
+  - tools/pokemon_jp/classic_missing_prints.json (replaces UnnumberedPromo prints)
+
+Synthetic local_ids are sequential 001… (cards are unnumbered in print).
+Each print carries a qualified English title when the setlist row has a
+{{TCG ID|Set|Name|num}} (e.g. "Mewtwo (CoroCoro promo)") plus a
+`bulbapedia_page` hint for enrich_unnumbered_promo_images.py.
+
+Run after harvest:
+  python tools/pokemon_jp/enrich_unnumbered_promo_images.py
+  python tools/pokemon_jp/merge_classic_missing.py
+"""
+
+from __future__ import annotations
+
+import json
+import re
+import urllib.parse
+import urllib.request
+from pathlib import Path
+
+HERE = Path(__file__).resolve().parent
+SETS = HERE / "classic_missing_sets.json"
+PRINTS = HERE / "classic_missing_prints.json"
+
+SET_ID = "UnnumberedPromo"
+SET_META = {
+    "name_en": "Unnumbered Promotional cards",
+    "name_ja": "番号なしプロモーションカード",
+    "releaseDate": "1997/03/06",
+}
+
+UA = "CCM3-pokemon-jp-etl/1.0 (local; +https://github.com/sebastiandine/Card-Collection-Manager-3)"
+
+# {{TCG ID|Set|Name|num}} — name may contain δ / &amp; etc.
+TCG_ID_FULL_RE = re.compile(
+    r"\{\{TCG ID\|([^}|]+)\|([^}|]+)(?:\|([^}|]*))?\}\}", re.IGNORECASE
+)
+TCG_RE = re.compile(r"\{\{TCG\|([^}|]+)(?:\|[^}]*)?\}\}", re.IGNORECASE)
+OBP_RE = re.compile(r"\{\{OBP\|([^}|]+)(?:\|[^}]*)?\}\}", re.IGNORECASE)
+SMALL_TAG_RE = re.compile(
+    r"<small>\s*'''?\s*\[([^\]]+)\]\s*'''?\s*</small>", re.IGNORECASE
+)
+ITALIC_NOTE_RE = re.compile(r"\(''([^']+)''\)")
+HTML_TAG_RE = re.compile(r"<[^>]+>")
+TEMPLATE_RE = re.compile(r"\{\{[^{}]*\}\}")
+
+
+def fetch_wikitext(page: str) -> str:
+    qs = urllib.parse.urlencode(
+        {
+            "action": "parse",
+            "page": page,
+            "prop": "wikitext",
+            "format": "json",
+        }
+    )
+    url = f"https://bulbapedia.bulbagarden.net/w/api.php?{qs}"
+    req = urllib.request.Request(url, headers={"User-Agent": UA})
+    with urllib.request.urlopen(req, timeout=90) as resp:
+        data = json.load(resp)
+    return data["parse"]["wikitext"]["*"]
+
+
+def decode_wiki_text(s: str) -> str:
+    return (
+        s.replace("&amp;", "&")
+        .replace("&lt;", "<")
+        .replace("&gt;", ">")
+        .replace("&#39;", "'")
+        .strip()
+    )
+
+
+def bulbapedia_page_from_tcg_id(set_name: str, card_name: str, num: str) -> str:
+    """Best-effort Bulbapedia article title for a TCG ID triple."""
+    set_name = decode_wiki_text(set_name)
+    card_name = decode_wiki_text(card_name)
+    num = decode_wiki_text(num or "").strip()
+    if not num or num.lower() == "promo":
+        return f"{card_name} ({set_name} promo)"
+    return f"{card_name} ({set_name} {num})"
+
+
+def qualified_name_en(card_name: str, set_name: str, num: str, extras: list[str]) -> str:
+    """Distinct English title: Name (Set promo) plus optional [Jumbo]/ markers."""
+    card_name = decode_wiki_text(card_name)
+    set_name = decode_wiki_text(set_name)
+    num = decode_wiki_text(num or "").strip()
+    if set_name:
+        if not num or num.lower() == "promo":
+            base = f"{card_name} ({set_name} promo)"
+        else:
+            base = f"{card_name} ({set_name} {num})"
+    else:
+        base = card_name
+    # Avoid duplicating qualifier already present in extras.
+    remaining = [
+        e
+        for e in extras
+        if e.lower() not in base.lower() and e.lower() not in {"promo"}
+    ]
+    if remaining:
+        return f"{base} ({'; '.join(remaining)})"
+    return base
+
+
+def collect_extras(raw: str) -> list[str]:
+    extras: list[str] = []
+    for m in SMALL_TAG_RE.finditer(raw):
+        extras.append(m.group(1).strip())
+    for m in ITALIC_NOTE_RE.finditer(raw):
+        extras.append(m.group(1).strip())
+    if "Jumbo" in raw and not any("jumbo" in e.lower() for e in extras):
+        extras.append("Jumbo")
+    if "Mini" in raw and not any("mini" in e.lower() for e in extras):
+        extras.append("Mini")
+    return extras
+
+
+def extract_entry(field: str) -> dict | None:
+    """Parse one Setlist/nmentry name field into print metadata."""
+    raw = field.strip()
+    extras = collect_extras(raw)
+
+    tcg = TCG_ID_FULL_RE.search(raw)
+    if tcg:
+        set_name = tcg.group(1).strip()
+        card_name = tcg.group(2).strip()
+        num = (tcg.group(3) or "").strip()
+        name_en = qualified_name_en(card_name, set_name, num, extras)
+        page = bulbapedia_page_from_tcg_id(set_name, card_name, num)
+        return {
+            "name_en": name_en,
+            "bulbapedia_page": page,
+            "tcg_set": decode_wiki_text(set_name),
+            "tcg_name": decode_wiki_text(card_name),
+            "tcg_num": decode_wiki_text(num) if num else "promo",
+        }
+
+    name = None
+    for rx in (TCG_RE, OBP_RE):
+        m = rx.search(raw)
+        if m:
+            name = decode_wiki_text(m.group(1))
+            break
+    if not name:
+        cleaned = TEMPLATE_RE.sub("", raw)
+        cleaned = HTML_TAG_RE.sub("", cleaned)
+        cleaned = cleaned.split("|", 1)[0].strip()
+        cleaned = re.sub(r"\[\[([^|\]]+)(?:\|[^\]]+)?\]\]", r"\1", cleaned)
+        name = decode_wiki_text(cleaned.strip(" '\""))
+    if not name:
+        return None
+
+    if extras:
+        name = f"{name} ({'; '.join(extras)})"
+    return {"name_en": name, "bulbapedia_page": name}
+
+
+def harvest_entries(wikitext: str) -> list[dict]:
+    entries: list[dict] = []
+    for m in re.finditer(r"\{\{Setlist/nmentry\|None\|", wikitext):
+        start = m.end()
+        depth = 0
+        i = start
+        while i < len(wikitext):
+            if wikitext.startswith("{{", i):
+                depth += 1
+                i += 2
+                continue
+            if wikitext.startswith("}}", i):
+                depth = max(0, depth - 1)
+                i += 2
+                continue
+            if wikitext[i] == "|" and depth == 0:
+                break
+            i += 1
+        parsed = extract_entry(wikitext[start:i])
+        if parsed:
+            entries.append(parsed)
+    return entries
+
+
+def main() -> None:
+    pages = [
+        "Unnumbered_Promotional_cards_(TCG)/1996-2005",
+        "Unnumbered_Promotional_cards_(TCG)",
+    ]
+    all_entries: list[dict] = []
+    for page in pages:
+        wt = fetch_wikitext(page)
+        got = harvest_entries(wt)
+        print(f"{page}: {len(got)} setlist rows")
+        all_entries.extend(got)
+
+    prints: list[dict] = []
+    for i, entry in enumerate(all_entries, start=1):
+        row = {
+            "set_id": SET_ID,
+            "local_id": f"{i:03d}",
+            "name_en": entry["name_en"],
+            "name_ja": "",
+            "name_en_source": "manual",
+            "bulbapedia_page": entry.get("bulbapedia_page") or entry["name_en"],
+        }
+        for key in ("tcg_set", "tcg_name", "tcg_num"):
+            if entry.get(key):
+                row[key] = entry[key]
+        prints.append(row)
+
+    sets_obj: dict = json.loads(SETS.read_text(encoding="utf-8"))
+    sets_obj[SET_ID] = SET_META
+    SETS.write_text(
+        json.dumps(sets_obj, ensure_ascii=False, indent=2) + "\n", encoding="utf-8"
+    )
+
+    existing: list[dict] = json.loads(PRINTS.read_text(encoding="utf-8"))
+    kept = [p for p in existing if str(p.get("set_id")) != SET_ID]
+    kept.extend(prints)
+    PRINTS.write_text(
+        json.dumps(kept, ensure_ascii=False, indent=2) + "\n", encoding="utf-8"
+    )
+    print(
+        f"wrote {SET_ID}: {len(prints)} prints "
+        f"(classic_missing_prints total={len(kept)})"
+    )
+
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,114 @@
+#!/usr/bin/env python3
+"""Merge classic TCGdex-missing JA products into pokemon_jp_en_catalog.json.
+
+Reads:
+  tools/pokemon_jp/classic_missing_sets.json
+  tools/pokemon_jp/classic_missing_prints.json
+  tools/pokemon_jp/set_en_names.json (updated with EN display names)
+
+Writes set metadata + prints into ui_wx/assets/pokemon_jp_en_catalog.json
+without dropping existing TCGdex-backed entries. Replaces prior prints for
+the same (set_id, local_id) keys from classic_missing_prints.json.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[2]
+HERE = Path(__file__).resolve().parent
+SETS = HERE / "classic_missing_sets.json"
+PRINTS = HERE / "classic_missing_prints.json"
+EN_MAP = HERE / "set_en_names.json"
+OUT = ROOT / "ui_wx" / "assets" / "pokemon_jp_en_catalog.json"
+
+# Classic gym-deck / sheet products use synthetic set ids (not on TCGdex).
+CLASSIC_SET_IDS = frozenset(
+    {
+        "UnnumberedPromo",
+        "ExpSheet1",
+        "ExpSheet2",
+        "ExpSheet3",
+        "NiviCG",
+        "HanadaCG",
+        "KuchibaCG",
+        "TamamushiCG",
+        "YamabukiCG",
+        "GurenTG",
+        "SouthernIslands",
+    }
+)
+
+GYM_DECK_SET_IDS = frozenset(
+    {"NiviCG", "HanadaCG", "KuchibaCG", "TamamushiCG", "YamabukiCG", "GurenTG"}
+)
+
+
+def strip_gym_deck_donor_ids(classic_prints: list[dict]) -> int:
+    """Remove PMCG donor ids; gym-deck exclusives need printing-accurate art."""
+    stripped = 0
+    for p in classic_prints:
+        sid = str(p.get("set_id") or "")
+        if sid not in GYM_DECK_SET_IDS:
+            continue
+        if p.get("image_url"):
+            p.pop("tcgplayer_id", None)
+            continue
+        if p.pop("tcgplayer_id", None) is not None:
+            stripped += 1
+    return stripped
+
+
+def main() -> None:
+    missing_sets: dict[str, dict] = json.loads(SETS.read_text(encoding="utf-8"))
+    missing_prints: list[dict] = json.loads(PRINTS.read_text(encoding="utf-8"))
+    en_map: dict[str, str] = json.loads(EN_MAP.read_text(encoding="utf-8"))
+
+    catalog: dict = {"sets": {}, "prints": []}
+    if OUT.exists():
+        catalog = json.loads(OUT.read_text(encoding="utf-8"))
+
+    sets_obj: dict = catalog.setdefault("sets", {})
+    for sid, meta in missing_sets.items():
+        name_en = str(meta.get("name_en") or "").strip() or sid
+        en_map[sid] = name_en
+        sets_obj[sid] = {
+            "name_en": name_en,
+            "name_ja": str(meta.get("name_ja") or ""),
+            "releaseDate": str(meta.get("releaseDate") or ""),
+        }
+
+    EN_MAP.write_text(
+        json.dumps(dict(sorted(en_map.items())), ensure_ascii=False, indent=2) + "\n",
+        encoding="utf-8",
+    )
+
+    classic_ids = {s for s in missing_sets}
+    classic_keys = {
+        (str(p.get("set_id")), str(p.get("local_id"))) for p in missing_prints
+    }
+    existing: list[dict] = catalog.get("prints") or []
+    kept = [
+        p
+        for p in existing
+        if (str(p.get("set_id")), str(p.get("local_id"))) not in classic_keys
+        or str(p.get("set_id")) not in classic_ids
+    ]
+    # Drop all prints for classic set ids, then append the curated list.
+    kept = [p for p in kept if str(p.get("set_id")) not in classic_ids]
+    stripped = strip_gym_deck_donor_ids(missing_prints)
+    kept.extend(missing_prints)
+    catalog["prints"] = kept
+
+    OUT.write_text(
+        json.dumps(catalog, ensure_ascii=False, indent=2) + "\n", encoding="utf-8"
+    )
+    print(
+        f"merged {len(missing_sets)} classic sets and {len(missing_prints)} prints "
+        f"into {OUT} (total prints={len(kept)}, gym donor ids stripped={stripped})"
+    )
+
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,77 @@
+#!/usr/bin/env python3
+"""Merge curated English set names into pokemon_jp_en_catalog.json.
+
+Reads tools/pokemon_jp/_tcgdex_sets.json (TCGdex JA list snapshot) and
+tools/pokemon_jp/set_en_names.json (curated id -> English display name).
+Also preserves / refreshes classic TCGdex-missing products from
+classic_missing_sets.json (UnnumberedPromo, City Gym decks, Expansion Sheets,
+Southern Islands).
+Never writes Japanese into name_en.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[2]
+HERE = Path(__file__).resolve().parent
+SETS_SNAP = HERE / "_tcgdex_sets.json"
+EN_MAP = HERE / "set_en_names.json"
+CLASSIC = HERE / "classic_missing_sets.json"
+OUT = ROOT / "ui_wx" / "assets" / "pokemon_jp_en_catalog.json"
+JA_OVERRIDES = {"SV4a": "シャイニートレジャーex"}
+
+
+def main() -> None:
+    sets = json.loads(SETS_SNAP.read_text(encoding="utf-8"))
+    en_map: dict[str, str] = json.loads(EN_MAP.read_text(encoding="utf-8"))
+    classic: dict[str, dict] = {}
+    if CLASSIC.exists():
+        classic = json.loads(CLASSIC.read_text(encoding="utf-8"))
+
+    prints = []
+    if OUT.exists():
+        try:
+            prints = json.loads(OUT.read_text(encoding="utf-8")).get("prints", [])
+        except Exception:
+            pass
+
+    catalog: dict[str, dict] = {}
+    matched = 0
+    for entry in sets:
+        sid = entry["id"]
+        if sid.startswith("CS"):
+            continue
+        name_ja = JA_OVERRIDES.get(sid, entry.get("name", ""))
+        name_en = en_map.get(sid, "").strip()
+        if name_en:
+            matched += 1
+        else:
+            name_en = sid
+        catalog[sid] = {
+            "name_en": name_en,
+            "name_ja": name_ja,
+            "releaseDate": "",
+        }
+
+    for sid, meta in classic.items():
+        name_en = str(meta.get("name_en") or en_map.get(sid) or sid).strip()
+        catalog[sid] = {
+            "name_en": name_en,
+            "name_ja": str(meta.get("name_ja") or ""),
+            "releaseDate": str(meta.get("releaseDate") or ""),
+        }
+        if name_en and name_en != sid:
+            matched += 1
+
+    OUT.write_text(
+        json.dumps({"sets": catalog, "prints": prints}, ensure_ascii=False, indent=2)
+        + "\n",
+        encoding="utf-8",
+    )
+    print(f"wrote {OUT}: {matched}/{len(catalog)} curated EN names")
+
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,263 @@
+{
+  "Bugsyのテクニカルマシン01": "Bugsy's Technical Machine 01",
+  "Bugsyのテクニカルマシン02": "Bugsy's Technical Machine 02",
+  "Clair's Technical Machine 01": "Clair's Technical Machine 01",
+  "Clair's Technical Machine 02": "Clair's Technical Machine 02",
+  "Max Revive": "Max Revive",
+  "Moomooミルク": "Moomoo Milk",
+  "Morty's Technical Machine 01": "Morty's Technical Machine 01",
+  "Morty's Technical Machine 02": "Morty's Technical Machine 02",
+  "ecogym": "Eco Gym",
+  "exp。共有": "EXP. Share",
+  "いいきずぐすり": "Super Potion",
+  "お上品攻撃": "Refined Attack",
+  "きずぐすり": "Potion",
+  "きずぐすり配合エネルギー": "Potion Energy",
+  "くすぐりマシーン": "Tickling Machine",
+  "げんきのかけら": "Revive",
+  "せまいジム": "Narrow Gym",
+  "たたきつけろ!挑戦状": "Challenge!",
+  "なかよしポフィン": "Buddy-Buddy Poffin",
+  "なにかの化石": "Mysterious Fossil",
+  "なんでもなおし": "Full Heal",
+  "なんでもなおし配合エネルギー": "Full Heal Energy",
+  "にせオーキドの逆襲": "Impostor Professor Oak's Revenge",
+  "ねむれ!ねむれ!": "Sleep! Sleep!",
+  "ふうせん": "Air Balloon",
+  "ふしぎなアメ": "Rare Candy",
+  "まきちらせ!ベトベトガス": "Goop Gas Attack",
+  "アカマツ": "Carmine",
+  "アプリコーンの森": "Apricorn Forest",
+  "アーケードゲーム": "Arcade Game",
+  "ウィルのテクニカルマシン01": "Will's Technical Machine 01",
+  "ウィルのテクニカルマシン02": "Will's Technical Machine 02",
+  "ウォーターキューブ01": "Water Cube 01",
+  "エネルギーの流れ": "Energy Flow",
+  "エネルギーをリサイクルします": "Recycle Energy",
+  "エネルギーを高めます": "Boost Energy",
+  "エネルギーアーク": "Energy Ark",
+  "エネルギーサーキュレート": "Energy Circulate",
+  "エネルギースイッチ": "Energy Switch",
+  "エネルギースタジアム": "Energy Stadium",
+  "エネルギー・リムーブ": "Energy Removal",
+  "エネルギー回収": "Energy Retrieval",
+  "エネルギー回復": "Energy Restore",
+  "エネルギー増幅器": "Energy Amplifier",
+  "エネルギー検索": "Energy Search",
+  "エネルギー転送": "Energy Transfer",
+  "エネルギー除去2": "Energy Removal 2",
+  "エネルギー電荷": "Energy Charge",
+  "エリカ": "Erika",
+  "エリカのお付き": "Erika's Maids",
+  "エリカの親切": "Erika's Kindness",
+  "エリカの香水": "Erika's Perfume",
+  "エルム教授": "Professor Elm",
+  "エルム教授のトレーニング方法": "Professor Elm's Training Method",
+  "オーキドはかせ": "Professor Oak",
+  "オーク教授の研究": "Professor Oak's Research",
+  "カウンターゲイン": "Counter Gain",
+  "カスミ": "Misty",
+  "カスミのいかり": "Misty's Wrath",
+  "カスミのなみだ": "Misty's Tears",
+  "カスミのわがまま": "Misty's Wish",
+  "カスミの勝負": "Misty's Duel",
+  "カツラ": "Blaine",
+  "カツラのギャンブル": "Blaine's Gamble",
+  "カツラのクイズ その3": "Blaine's Quiz #3",
+  "カツラの奥の手": "Blaine's Last Resort",
+  "カレンのテクニカルマシン01": "Karen's Technical Machine 01",
+  "カレンのテクニカルマシン02": "Karen's Technical Machine 02",
+  "カードフリップゲーム": "Card Flip Game",
+  "キョウ": "Koga",
+  "キョウ秘伝, 変わり身の術": "Koga's Ninja Trick",
+  "ギャンブラー": "Gambler",
+  "クイックボール": "Quick Ball",
+  "クチバシティジム": "Vermilion City Gym",
+  "クリスタルエネルギー": "Crystal Energy",
+  "グッドマナー": "Good Manners",
+  "グラスキューブ01": "Grass Cube 01",
+  "グレンタウンジム": "Cinnabar Island Gym",
+  "ゴールドベリー": "Gold Berry",
+  "サイキックキューブ01": "Psychic Cube 01",
+  "サカキ": "Giovanni",
+  "サカキの切り札": "Giovanni's Last Resort",
+  "ジャグラー": "Juggler",
+  "ジャスミンのテクニカルマシン01": "Jasmine's Technical Machine 01",
+  "ジャスミンのテクニカルマシン02": "Jasmine's Technical Machine 02",
+  "ジャニーンのテクニカルマシン01": "Janine's Technical Machine 01",
+  "ジャニーンのテクニカルマシン02": "Janine's Technical Machine 02",
+  "スイッチ": "Switch",
+  "スイレンのお世話": "Lana's Aid",
+  "スパイ作戦": "Spy Work",
+  "スプラウトタワー": "Sprout Tower",
+  "スーパーエネルギー検索": "Super Energy Retrieval",
+  "スーパーエネルギー除去2": "Super Energy Removal 2",
+  "スーパースクープアップ": "Super Scoop Up",
+  "スーパーボール": "Great Ball",
+  "スーパーロッド": "Super Rod",
+  "セキチクシティジム": "Fuchsia City Gym",
+  "タイムカプセル": "Time Capsule",
+  "タイムシャード": "Time Shard",
+  "タケシ": "Brock",
+  "タケシの保護": "Brock's Protection",
+  "タケシの育て方": "Brock's Training Method",
+  "タマムシシティジム": "Celadon City Gym",
+  "ダウジングマシーン": "Item Finder",
+  "ダブル無色エネルギー": "Double Colorless Energy",
+  "チャックのテクニカルマシン01": "Chuck's Technical Machine 01",
+  "チャックのテクニカルマシン02": "Chuck's Technical Machine 02",
+  "チャリティ": "Charity",
+  "チームロケットの邪悪な行為": "Team Rocket's Evil Deeds",
+  "テクノレーダー": "Technical Machine: Evolution",
+  "ディフェンダー": "Defender",
+  "デュアルボール": "Dual Ball",
+  "トウコ": "Hilda",
+  "トキワシティジム": "Viridian City Gym",
+  "トラッシュ交換": "Trash Exchange",
+  "ナツメ": "Sabrina",
+  "ナツメのESP": "Sabrina's ESP",
+  "ナツメのサイキックコントロール": "Sabrina's Psychic Control",
+  "ナツメの眼": "Sabrina's Gaze",
+  "ナンジャモ": "Iono",
+  "ニビシティジム": "Pewter City Gym",
+  "ネストボール": "Nest Ball",
+  "ハイパーデボルブスプレー": "Hyper Devolution Spray",
+  "ハイパーボール": "Ultra Ball",
+  "ハナダシティジム": "Cerulean City Gym",
+  "バトルVIPパス": "Battle VIP Pass",
+  "バトル場は穴だらけ!": "The Field is Full of Holes!",
+  "バルーンベリー": "Balloon Berry",
+  "パソコン通信": "Computer Search",
+  "パワープロテイン": "Power Protein",
+  "ヒーリングフィールド": "Healing Field",
+  "ビルからのメール": "Mail from Bill",
+  "ビルのテレポーター": "Bill's Teleporter",
+  "ビルのメンテナンス": "Bill's Maintenance",
+  "ピッピ人形": "Clefairy Doll",
+  "ファイアキューブ01": "Fire Cube 01",
+  "フォーカスバンド": "Focus Band",
+  "フォークナーのテクニカルマシン01": "Falkner's Technical Machine 01",
+  "フォークナーのテクニカルマシン02": "Falkner's Technical Machine 02",
+  "フジろうじん": "Mr. Fuji",
+  "フルヒール": "Full Heal",
+  "ブルーノのテクニカルマシン01": "Bruno's Technical Machine 01",
+  "ブルーノのテクニカルマシン02": "Bruno's Technical Machine 02",
+  "ブレイブバングル": "Brave Bangle",
+  "プライスのテクニカルマシン01": "Pryce's Technical Machine 01",
+  "プライスのテクニカルマシン02": "Pryce's Technical Machine 02",
+  "プライムキャッチャー": "Prime Catcher",
+  "プラスパワー": "PlusPower",
+  "ベリー": "Berry",
+  "ペパー": "Arven",
+  "ホイットニーのテクニカルマシン01": "Whitney's Technical Machine 01",
+  "ホイットニーのテクニカルマシン02": "Whitney's Technical Machine 02",
+  "ボスのやりかた": "The Boss's Way",
+  "ボスの指令": "Boss's Orders",
+  "ポクギア": "Pokégear",
+  "ポケギア3.0": "Pokégear 3.0",
+  "ポケモンいれかえ": "Switch",
+  "ポケモンの笛": "Pokémon Flute",
+  "ポケモンキャッチャー": "Pokémon Catcher",
+  "ポケモンセンター": "Pokémon Center",
+  "ポケモンナース": "Pokémon Nurse",
+  "ポケモンパーク": "Pokémon Park",
+  "ポケモンパーソナリティテスト": "Pokémon Personality Test",
+  "ポケモンファンクラブ": "Pokémon Fan Club",
+  "ポケモンブリーダーフィールド": "Pokémon Breeder Fields",
+  "ポケモンマーチ": "Pokémon March",
+  "ポケモン交換おじさん": "Pokémon Trader",
+  "ポケモン再送信": "Pokémon Retransmit",
+  "ポケモン反転": "Pokémon Reversal",
+  "ポケモン回収": "Pokémon Retrieval",
+  "ポケモン図鑑": "Pokédex",
+  "ポケモン育て屋さん": "Pokémon Breeder",
+  "ポケモン通信": "Pokémon Communication",
+  "ポーション": "Potion",
+  "マサキ": "Bill",
+  "マスターボール": "Master Ball",
+  "マチス": "Lt. Surge",
+  "マチスの交渉": "Lt. Surge's Treaty",
+  "マチスの秘策": "Lt. Surge's Secret Plan",
+  "マルチテクニカルマシン01": "Multi Technical Machine 01",
+  "ミニスカート": "Lass",
+  "ミラクルベリー": "Miracle Berry",
+  "メアリー": "Mary",
+  "メアリーの衝動": "Mary's Impulse",
+  "メモリベリー": "Memory Berry",
+  "メンテナンス": "Maintenance",
+  "モンスターボール": "Poké Ball",
+  "ヤマブキシティジム": "Saffron City Gym",
+  "ライトニングキューブ01": "Lightning Cube 01",
+  "ラジオタワー": "Radio Tower",
+  "ラッキースタジアム": "Lucky Stadium",
+  "ランスのテクニカルマシン01": "Lance's Technical Machine 01",
+  "ランスのテクニカルマシン02": "Lance's Technical Machine 02",
+  "リコール": "Recall",
+  "リサイクル": "Recycle",
+  "リムーブ禁止ジム": "No Removal Gym",
+  "リーリエの決心": "Lillie's Determination",
+  "レインボーエネルギー": "Rainbow Energy",
+  "ロケットのスニーク攻撃": "Rocket's Sneak Attack",
+  "ロケットのテクニカルマシン01": "Rocket's Technical Machine 01",
+  "ロケットの隠れ家": "Rocket Hideout",
+  "ロケット団のおねーさん": "Rocket's Admin.",
+  "ロケット団のワナ": "Team Rocket's Trap",
+  "ロケット団の実験": "Team Rocket's Experiment",
+  "ロケット団の爆発ジム": "Explosion Gym",
+  "ロケット団の特訓ジム": "Training Center",
+  "ロケット団参上!": "Here Comes Team Rocket!",
+  "ロケット団員": "Team Rocket Grunt",
+  "ワープエネルギー": "Warp Energy",
+  "ワープポイント": "Warp Point",
+  "二重突風": "Double Gust",
+  "先見者": "Oracle",
+  "化石卵": "Fossil Egg",
+  "博士の研究": "Professor's Research",
+  "反撃の爪": "Counterattack Claws",
+  "古い棒": "Old Rod",
+  "基本ドラゴンエネルギー": "Dragon Energy",
+  "基本フェアリーエネルギー": "Fairy Energy",
+  "基本悪エネルギー": "Darkness Energy",
+  "基本水エネルギー": "Water Energy",
+  "基本炎エネルギー": "Fire Energy",
+  "基本草エネルギー": "Grass Energy",
+  "基本超エネルギー": "Psychic Energy",
+  "基本鋼エネルギー": "Metal Energy",
+  "基本闘エネルギー": "Fighting Energy",
+  "基本雷エネルギー": "Lightning Energy",
+  "壁を台無しにする[aerodactyl]": "Ruin Wall",
+  "壁を台無しにする[カブト]": "Ruin Wall",
+  "壊れた地上ジム": "Broken Ground Gym",
+  "夜のタンカ": "Night Stretcher",
+  "夜の廃品回収": "Nightly Garbage Run",
+  "大地の器": "Earthen Vessel",
+  "奇跡のエネルギー": "Miracle Energy",
+  "強さの魅力": "Power Charge",
+  "思い出させる": "Reminder",
+  "思考ウェーブマシン": "Thought Wave Machine",
+  "戦いキューブ01": "Fighting Cube 01",
+  "抵抗力低下ジム": "Resistance Gym",
+  "拡大鏡": "Magnifier",
+  "新しいpokedex": "New Pokédex",
+  "旅行セールスマン": "Traveling Salesman",
+  "森林保護者": "Forest Guardian",
+  "模倣": "Copycat",
+  "海底遺跡": "Undersea Ruins",
+  "町のボランティア": "Town Volunteers",
+  "癒しベリー": "Heal Berry",
+  "発電所": "Power Plant",
+  "礼儀作法": "Etiquette",
+  "突風": "Gust of Wind",
+  "粉末を癒します": "Heal Powder",
+  "脱力感ガード": "Weakness Guard",
+  "見えない壁": "Invisible Wall",
+  "詐欺師オーク教授": "Impostor Professor Oak",
+  "詐欺師オーク教授の発明": "Impostor Professor Oak's Invention",
+  "超エネルギーリムーブ": "Super Energy Removal",
+  "退化スプレー": "Devolution Spray",
+  "金属エネルギー": "Metal Energy",
+  "金属キューブ01": "Metal Cube 01",
+  "錯乱ジム": "Chaos Gym",
+  "闇のエネルギー": "Darkness Energy",
+  "闇キューブ01": "Darkness Cube 01"
+}
@@ -0,0 +1,175 @@
+{
+  "ADV1": "Expansion Pack ADV",
+  "ADV2": "Miracle of the Desert",
+  "ADV3": "Rulers of the Heavens",
+  "ADV4": "Flight of the Skies",
+  "ADV5": "Undone Seal",
+  "CP1": "Magma Gang VS Aqua Gang: Double Crisis",
+  "CP2": "Legendary Shine Collection",
+  "CP3": "PokéKyun Collection",
+  "CP4": "Premium Champion Pack",
+  "CP5": "Mythical & Legendary Dream Shine Collection",
+  "CP6": "Expansion Pack 20th Anniversary",
+  "E1": "Base Expansion Pack",
+  "E2": "The Town on No Map",
+  "E3": "Wind from the Sea",
+  "E4": "Split Earth",
+  "E5": "Mysterious Mountains",
+  "ExpSheet1": "Expansion Sheet Series 1",
+  "ExpSheet2": "Expansion Sheet Series 2",
+  "ExpSheet3": "Expansion Sheet Series 3",
+  "GurenTG": "Guren Town Gym",
+  "HanadaCG": "Hanada City Gym",
+  "KuchibaCG": "Kuchiba City Gym",
+  "L1a": "HeartGold Collection",
+  "L1b": "SoulSilver Collection",
+  "L2": "Reviving Legends",
+  "L3": "Clash at the Summit",
+  "LL": "Lost Link",
+  "M-P": "MEGA Promo",
+  "M1L": "Mega Symphonia",
+  "M1S": "Mega Symphonia",
+  "M2": "Inferno X",
+  "M2a": "MEGA Dream ex",
+  "M3": "Munikeith Zero",
+  "M4": "Ninja Spinner",
+  "M5": "MEGA Expansion",
+  "MC": "McDonald's Collection",
+  "NiviCG": "Nivi City Gym",
+  "PCG1": "Venusaur/Charizard/Blastoise Half Deck",
+  "PCG10": "Offense and Defense of the Furthest Ends",
+  "PCG2": "Flight of Fire",
+  "PCG3": "Clash of the Blue Sky",
+  "PCG4": "Rocket Gang Strikes Back",
+  "PCG5": "Golden Sky, Silvery Ocean",
+  "PCG6": "Mirage Forest",
+  "PCG7": "Holon Research Tower",
+  "PCG8": "Holon Phantom",
+  "PCG9": "Miracle Crystal",
+  "PMCG1": "Expansion Pack",
+  "PMCG2": "Pokémon Jungle",
+  "PMCG3": "Mystery of the Fossils",
+  "PMCG4": "Rocket Gang",
+  "PMCG5": "Leaders' Stadium",
+  "PMCG6": "Challenge from the Darkness",
+  "S10D": "Time Gazer",
+  "S10P": "Space Juggler",
+  "S10a": "Dark Abyss",
+  "S10b": "Pokémon GO",
+  "S11": "Lost Abyss",
+  "S11a": "Incandescent Arcana",
+  "S12": "Paradigm Trigger",
+  "S12a": "VSTAR Universe",
+  "S1H": "Shield",
+  "S1W": "Sword",
+  "S1a": "VMAX Rising",
+  "S2": "Rebellion Crash",
+  "S2a": "Explosive Walker",
+  "S3": "Infinity Zone",
+  "S3a": "Legendary Pulse",
+  "S4": "Amazing Volt Tackle",
+  "S4a": "Shiny Star V",
+  "S5I": "Single Strike Master",
+  "S5R": "Rapid Strike Master",
+  "S5a": "Matchless Fighters",
+  "S6H": "Silver Lance",
+  "S6K": "Jet-Black Spirit",
+  "S6a": "Eevee Heroes",
+  "S7D": "Skyscraping Perfection",
+  "S7R": "Blue Sky Stream",
+  "S8": "Fusion Arts",
+  "S8a": "Dark Phantasma",
+  "S8b": "VMAX Climax",
+  "S9": "Star Birth",
+  "S9a": "Battle Region",
+  "SM0": "Generation",
+  "SM1+": "Strength Expansion Pack Sun & Moon",
+  "SM10": "Double Blaze",
+  "SM10b": "Sky Legend",
+  "SM11a": "Remix Bout",
+  "SM11b": "Dream League",
+  "SM12": "Alter Genesis",
+  "SM12a": "Tag All Stars",
+  "SM1M": "Collection Moon",
+  "SM1S": "Collection Sun",
+  "SM2K": "Islands Await You",
+  "SM2L": "Alolan Moonlight",
+  "SM3+": "Shining Legends",
+  "SM3H": "Fighting Rainbow",
+  "SM3N": "Darkness that Consumes Light",
+  "SM4+": "GX Battle Boost",
+  "SM4A": "Ultradimensional Beasts",
+  "SM4S": "Awakened Heroes",
+  "SM5+": "Ultra Force Ultra Sun Ultra Moon",
+  "SM5M": "Ultra Force",
+  "SM5S": "Ultra Moon",
+  "SM6": "Forbidden Light",
+  "SM6a": "Dragon Storm",
+  "SM6b": "Champion Road",
+  "SM7": "Fairy Rise",
+  "SM7a": "Thunderclap Spark",
+  "SM7b": "Fairy Rise",
+  "SM8": "Explosive Impact",
+  "SM8a": "Dark Order",
+  "SM8b": "GX Ultra Shiny",
+  "SM9": "Tag Bolt",
+  "SM9a": "Night Unison",
+  "SM9b": "Full Metal Wall",
+  "SMP2": "Detective Pikachu",
+  "SV10": "Glory of Team Rocket",
+  "SV11B": "Black Bolt",
+  "SV11W": "White Flare",
+  "SV1S": "Scarlet ex",
+  "SV1V": "Violet ex",
+  "SV1a": "Triplet Beat",
+  "SV2D": "Clay Burst",
+  "SV2P": "Snow Hazard",
+  "SV2a": "Pokémon Card 151",
+  "SV3": "Ruler of the Black Flame",
+  "SV3a": "Raging Surf",
+  "SV4K": "Ancient Roar",
+  "SV4M": "Future Flash",
+  "SV4a": "Shiny Treasure ex",
+  "SV5K": "Wild Force",
+  "SV5M": "Cyber Judge",
+  "SV5a": "Crimson Haze",
+  "SV6": "Mask of Change",
+  "SV6a": "Night Wanderer",
+  "SV7": "Stellar Miracle",
+  "SV7a": "Paradise Dragona",
+  "SV8": "Super Electric Breaker",
+  "SV8a": "Terastal Festival ex",
+  "SV9": "Battle Partners",
+  "SV9a": "Heat Wave Arena",
+  "SVK": "Starter Set / Construction Dec",
+  "SVLN": "Starter Set Terastal Charizard ex",
+  "SVLS": "Starter Set Lucario & Roaring Moon",
+  "SouthernIslands": "Southern Islands",
+  "TamamushiCG": "Tamamushi City Gym",
+  "UnnumberedPromo": "Unnumbered Promotional cards",
+  "VS1": "Pokémon VS",
+  "XY10": "Awakening Psychic King",
+  "XY11a": "Cruel Traitor",
+  "XY11b": "Fever-Burst Fight",
+  "XY1a": "Collection X",
+  "XY1b": "Collection Y",
+  "XY2": "Wild Blaze",
+  "XY3": "Rising Fist",
+  "XY4": "Phantom Gate",
+  "XY5a": "Gaia Volcano",
+  "XY5b": "Tidal Storm",
+  "XY6": "Emerald Break",
+  "XY7": "Bandit Ring",
+  "XY8a": "Blue Shock",
+  "XY8b": "Red Flash",
+  "XY9": "Rage of the Broken Heavens",
+  "YamabukiCG": "Yamabuki City Gym",
+  "neo1": "Gold, Silver, to a New World...",
+  "neo2": "Crossing the Ruins...",
+  "neo3": "Awakening Legends",
+  "neo4": "Darkness, and to Light...",
+  "sm2+": "Facing a New Trial",
+  "sn10a": "GG End",
+  "sn11": "Miracle Twin",
+  "web1": "Pokémon Web"
+}
@@ -9,8 +9,8 @@
 - `include/ccm/ui/MainFrame.hpp` + `src/MainFrame.cpp` — top-level window (default size `1210×770`), menu strip (`File` / `Game` / `Sets` / `Help`), toolbar (Add / Edit / Delete + filter input), and the splitter that swaps the active `IGameView`'s panels. The `Game` and `Sets` menus are built dynamically from `AppContext::gameViews` so adding a new game lights up its menu entries automatically. Filter and toolbar actions forward to `activeView()`. `EVT_PREVIEW_STATUS` (preview fetch outcome → status label; empty string resets to `"Ready"`) is the only event the frame binds; `EVT_CARD_SELECTED` is bound *per view* (each `IGameView` connects its typed list panel to its typed selected panel internally). About is a custom themed dialog (not `wxAboutBox`) so dark mode behavior stays consistent.
 - `include/ccm/ui/BaseCardListPanel.hpp` — header-only template `BaseCardListPanel<TCard, TSortColumn>` that owns ALL the non-game-specific `wxListCtrl` machinery: hidden zero-width spacer column (legacy of the MSW comctl32 image-list gutter workaround, kept to preserve column-index math), themed header row (clickable to sort, edge-drag to resize, divider double-click to autosize), per-icon-column cached `wxBitmap` pairs (normal + selected color) consumed by `IconListCtrl::MSWOnNotify` so row icons are pixel-perfect centered under the themed-header icons, rebuild guard so DESELECTED/SELECTED storms collapse into a single bubbled `EVT_CARD_SELECTED`, case-insensitive substring filter via `setFilter(...)`, per-column toggle-direction sort. Subclasses fill in column descriptors + per-row text + per-icon-column flag predicates + dispatch hooks (`sortBy`, `matchesFilter`).
 - `include/ccm/ui/IconListCtrl.hpp` + `src/IconListCtrl.cpp` — small `wxListCtrl` subclass that intercepts `NM_CUSTOMDRAW` on Windows and paints flag-icon sub-items at the exact center of each cell. It owns a `HIMAGELIST` (built from the cached `wxBitmap` pairs via straight-RGBA 32 bpp DIB sections) and draws each cell's icon with `ImageList_Draw(ILD_TRANSPARENT)` onto the native `HDC` from `NMLVCUSTOMDRAW`. This is the same low-level pixel path `wxImageList` uses internally, which is the only rendering path that has reliably preserved SVG transparency + correct fill color across light/dark themes on MSW. Two earlier attempts — `wxGraphicsContext::DrawBitmap` and a manually-premultiplied-DIB `AlphaBlend` — both rendered runtime-fill SVG icons as solid white in light mode and were abandoned (see convention 11). The custom-draw is purely about positioning; pixel format handling is delegated to comctl32.
- `include/ccm/ui/BaseSelectedCardPanel.hpp` — header-only template `BaseSelectedCardPanel<TCard>` that owns the right-hand-side detail panel: preview image fetched via `CardPreviewService` (with the `shared_ptr<State>` + `std::atomic alive`/`currentGen` cancellation pattern), 2-column detail grid, flag-icon strip that collapses when no flags are set, image list with double-click viewer. If preview lookup fails or returns empty bytes, the panel loads a per-game **card-back fallback**: Magic and Pokémon use fixed HTTPS URLs (`fallbackImageUrlForGame`, CCM2-aligned); **Yu-Gi-Oh!** tries Yugipedia thumbnail URL, then full `Back-EN.png` on `ms.yugipedia.com`, then reads `<exeDir>/assets/ygo_card_back.png` (copied next to the executable by `app/CMakeLists.txt` on link — source file `ui_wx/assets/ygo_card_back.png`). The constructor caches `<exeDir>/` for that disk path. Subclasses describe the detail rows / flag icons / preview lookup `(name, setId, setNo)` and own a `Game` constant.
- `include/ccm/ui/BaseCardEditDialog.hpp` — header-only template `BaseCardEditDialog<TCard>` that owns the standard Add/Edit form: Name, Set picker (read-only `wxComboBox` with prefix-match typeahead and case-insensitive id matching for legacy data), Amount spin, Language and Condition choices, Note, image management (Add multiple via `wxFD_MULTIPLE`, Remove, double-click to view), OK/Cancel + validation. The **Set** row is built on a host `wxPanel` with a horizontal `wxBoxSizer`; games may override `customizeSetPickerRow(row, combo)` to wrap the combo (default: combo only). After a programmatic selection, `applySetSelectionByIndex` updates `card_.set` and calls `onSetSelectionApplied()` (default no-op). After `buildAndPopulate()`, the template snapshots the loaded card into `openingSnapshot_`; in **`EditMode::Edit`**, OK asks **Yes/No** (“Save changes to this card?”) only when the card differs from that snapshot (dirty-only confirm). **Create** mode never prompts. Subclasses build the flags row (`buildFlagsRow`), append game-specific extra rows (e.g. Pokemon's `Set #`) via `appendExtraRows`, and copy values in/out of the typed card (`readExtraFromCard` / `writeExtraToCard`). The template binds `EVT_TEXT` on **Name** and invokes `onCardLookupContextChanged()` so games can drop stale keyed metadata when the user edits the lookup identity (Yu-Gi-Oh! clears its YGOPRODeck print-variant cache here). `YuGiOhCardEditDialog` overrides `customizeSetPickerRow` to add a **`SwitchCtrl`** pill switch plus a **hint** label (`Set name` / `Set code`), a text field, and **Auto detect** (resolves `Set.id` via `ccm/util/YuGiOhSetLookup.hpp` against `availableSets()`, then returns to the dropdown on success); it overrides `onSetSelectionApplied` to match manual set-change behavior. It additionally `CallAfter`s a silent `detectPrintVariants` when opening **Edit** (and after changing **Set**) so multi-print **Next** buttons can appear without pressing Auto detect first, as long as name + display set are populated. The base also exposes helpers to sync current control values and inspect the currently-selected set when a subclass needs derived-field UI.
+- `include/ccm/ui/BaseSelectedCardPanel.hpp` — header-only template `BaseSelectedCardPanel<TCard>` that owns the right-hand-side detail panel: preview image fetched via `CardPreviewService` (with the `shared_ptr<State>` + `std::atomic alive`/`currentGen` cancellation pattern), 2-column detail grid, flag-icon strip that collapses when no flags are set, image list with double-click viewer. If preview lookup fails or returns empty bytes, the panel loads a per-game **card-back fallback**: Magic and Pokémon West use fixed HTTPS URLs (`fallbackImageUrlForGame`, CCM2-aligned); **Pokémon Asia** uses the Japanese TCG back via `previewGameFor(card)` → `Game::JapanesePokemon`; **Yu-Gi-Oh!** tries Yugipedia thumbnail URL, then full `Back-EN.png` on `ms.yugipedia.com`, then reads `<exeDir>/assets/ygo_card_back.png`; **Digimon Digi-Battle** reads `<exeDir>/assets/digibattle99_card_back.png` (both bundled assets copied by `app/CMakeLists.txt` on link). The constructor caches `<exeDir>/` for that disk path. Subclasses describe the detail rows / flag icons / preview lookup `(name, setId, setNo)` and own a `Game` constant; override `previewGameFor` when preview routing differs from collection `gameId()` (Pokemon West/Asia).
+- `include/ccm/ui/BaseCardEditDialog.hpp` — header-only template `BaseCardEditDialog<TCard>` that owns the standard Add/Edit form: Name, optional `appendPreSetRows` (Pokemon West/Asia region), Set picker (read-only `wxComboBox` with typeahead — prefix first, then substring, ASCII-fold so `Pokemon`/`Jungle` match `Pokémon Jungle` — and case-insensitive id matching for legacy data), Amount spin, Language and Condition choices (`languagesForChoice()` hook; Pokemon filters by region), Note, image management (Add multiple via `wxFD_MULTIPLE`, Remove, double-click to view), OK/Cancel + validation. The **Set** row is built on a host `wxPanel` with a horizontal `wxBoxSizer`; games may override `customizeSetPickerRow(row, combo)` to wrap the combo (default: combo only). After a programmatic selection, `applySetSelectionByIndex` updates `card_.set` and calls `onSetSelectionApplied()` (default no-op). After `buildAndPopulate()`, the template snapshots the loaded card into `openingSnapshot_`; in **`EditMode::Edit`**, OK asks **Yes/No** (“Save changes to this card?”) only when the card differs from that snapshot (dirty-only confirm). **Create** mode never prompts. Subclasses build the flags row (`buildFlagsRow`), append game-specific extra rows (e.g. Pokemon's `Set #`) via `appendExtraRows`, and copy values in/out of the typed card (`readExtraFromCard` / `writeExtraToCard`). The template binds `EVT_TEXT` on **Name** and invokes `onCardLookupContextChanged()` so games can drop stale keyed metadata when the user edits the lookup identity (Yu-Gi-Oh! clears its YGOPRODeck print-variant cache here). `YuGiOhCardEditDialog` overrides `customizeSetPickerRow` to add a **`SwitchCtrl`** pill switch plus a **hint** label (`Set name` / `Set code`), a text field, and **Auto detect** (resolves `Set.id` via `ccm/util/YuGiOhSetLookup.hpp` against `availableSets()`, then returns to the dropdown on success); it overrides `onSetSelectionApplied` to match manual set-change behavior. It additionally `CallAfter`s a silent `detectPrintVariants` when opening **Edit** (and after changing **Set**) so multi-print **Next** buttons can appear without pressing Auto detect first, as long as name + display set are populated. The base also exposes helpers to sync current control values and inspect the currently-selected set when a subclass needs derived-field UI.
 - `include/ccm/ui/SwitchCtrl.hpp` + `src/SwitchCtrl.cpp` — custom pill-track + thumb switch for small modal rows (Yu-Gi-Oh! set picker); fires `EVT_CCM_SWITCH` on user toggle and reads colors from `inferThemeFromWindow` / `paletteForTheme`.
 - `include/ccm/ui/Magic*.hpp` + `src/Magic*.cpp` — Magic implementations: `MagicCardListPanel`, `MagicSelectedCardPanel`, `MagicCardEditDialog`, `MagicGameView`. Each is ~50–100 lines of hook overrides on top of the matching base template.
 - `include/ccm/ui/Pokemon*.hpp` + `src/Pokemon*.cpp` — Pokemon implementations: `PokemonCardListPanel`, `PokemonSelectedCardPanel`, `PokemonCardEditDialog`, `PokemonGameView`. Same shape as the Magic ones; differences are limited to the Set # field, the Holo / 1. Edition flags, and the Pokemon TCG preview lookup key (which includes `setNo`).
@@ -67,7 +67,7 @@
    - When validating UI theming changes, rebuild and run `ccm` (the executable), not just `ccm_ui_wx`.
 15. **Preview fallback behavior (CCM2 parity where applicable):**
    - Keep unresolved external previews user-visible by showing a per-game card-back image in `BaseSelectedCardPanel` instead of a blank/transparent bitmap.
-    - Magic / Pokémon use single fixed HTTPS URLs (`Magic_card_back.jpg`, Bulbagarden `Cardback.jpg`). Yu-Gi-Oh! uses Yugipedia-hosted backs plus a **bundled** PNG beside the exe (`assets/ygo_card_back.png`) when the network path fails — keep that chain working when touching preview code.
+    - Magic / Pokémon use single fixed HTTPS URLs (`Magic_card_back.jpg`, Bulbagarden `Cardback.jpg`). Japanese Pokémon uses the Japanese TCG Bulbagarden back (`TCG_Card_Back_Japanese.jpg`). Yu-Gi-Oh! uses Yugipedia-hosted backs plus a **bundled** PNG beside the exe (`assets/ygo_card_back.png`) when the network path fails. Digimon Digi-Battle uses a **bundled** PNG (`assets/digibattle99_card_back.png`) — keep those chains working when touching preview code.
    - If you change fallback sourcing (URLs or bundled asset), keep the "always show a reasonable card-back fallback" behavior intact for **every** game with remote previews.
 16. **Per-game auto-detect controls:**
    - Auto-detect actions in edit dialogs (e.g. detect set print number / rarity from API) are opt-in per game.
@@ -76,7 +76,7 @@

 ## Required follow-ups

- If you replace **`ui_wx/assets/ygo_card_back.png`**, rebuild the **`ccm`** target so `app/CMakeLists.txt`'s `POST_BUILD` copy refreshes `<exeDir>/assets/`; do not remove the asset without updating `BaseSelectedCardPanel` / `docs/assets-and-info-apis.md`.
+- If you replace **`ui_wx/assets/ygo_card_back.png`** or **`ui_wx/assets/digibattle99_card_back.png`**, rebuild the **`ccm`** target so `app/CMakeLists.txt`'s `POST_BUILD` copy refreshes `<exeDir>/assets/`; do not remove an asset without updating `BaseSelectedCardPanel` / `docs/assets-and-info-apis.md`.
 - After adding a new dialog/panel `.cpp` you **must** add it to `ui_wx/CMakeLists.txt`.
 - After adding a new menu action you **must** allocate an `Ids::*` value in `MainFrame.hpp` (don't reuse `wxID_HIGHEST` math inline) and `Bind` it in `buildMenuBar`. The dynamic Game / Sets menus consume the `IdGameMenuBase` / `IdSetsMenuBase` ranges; do not stomp on those id ranges.
 - After changing `AppContext` you **must** update `app/main.cpp` so the composition root populates the new field.
@@ -19,10 +19,15 @@ add_library(ccm_ui_wx STATIC
    src/YuGiOhSelectedCardPanel.cpp
    src/YuGiOhCardEditDialog.cpp
    src/YuGiOhGameView.cpp
+    src/DigiBattle99CardListPanel.cpp
+    src/DigiBattle99SelectedCardPanel.cpp
+    src/DigiBattle99CardEditDialog.cpp
+    src/DigiBattle99GameView.cpp

    src/SettingsDialog.cpp
    src/SwitchCtrl.cpp
    src/ImageViewerDialog.cpp
+    src/VariantImagePreviewDialog.cpp
    src/IconListCtrl.cpp
    src/SvgIcons.cpp
    src/Theme.cpp
@@ -26,6 +26,9 @@ struct AppContext {
    IGameModule&                         magicModule;
    IGameModule&                         pokemonModule;
    IGameModule&                         yuGiOhModule;
+    IGameModule&                         digiBattle99Module;
+    // Asia Pokemon sets/preview backend (not a separate Game menu entry).
+    IGameModule&                         japanesePokemonModule;
    // Active per-game UI bundles. The order is the order shown in the
    // Game menu; the composition root constructs them and hands raw
    // pointers in. `MainFrame` does not own these — `app/main.cpp` does.
@@ -3,7 +3,8 @@
 // BaseCardEditDialog<TCard>
 //
 // Header-only template for the modal create/edit form. Owns the parts every
-// game shares — Name, Set picker (read-only combo with prefix typeahead),
+// game shares — Name, Set picker (read-only combo with typeahead: prefix first,
+// then substring, with ASCII-fold so "Pokemon"/"Jungle" match "Pokémon Jungle"),
 // Amount spin, Language and Condition choices, Note, Image list with
 // Add/Remove/double-click-to-view, OK/Cancel — and exposes hooks the
 // subclass uses to:
@@ -48,6 +49,7 @@
 #include <chrono>
 #include <cstdint>
 #include <filesystem>
+#include <span>
 #include <string>
 #include <utility>
 #include <vector>
@@ -102,6 +104,9 @@ protected:
    // wants; the base only owns the surrounding label.
    virtual void buildFlagsRow(wxBoxSizer* flagsBox) = 0;

+    // Subclass adds any labelled rows between Name and Set. Default does nothing.
+    virtual void appendPreSetRows(wxFlexGridSizer* /*grid*/) {}
+
    // Subclass adds any extra game-specific labelled rows just below the
    // standard rows but above the Note row, by calling `appendRow(label, ctrl)`
    // (provided as a parameter). Default does nothing.
@@ -114,6 +119,11 @@ protected:
    // Subclass copies the extra fields it owns from its widgets back into `card_`.
    virtual void writeExtraToCard() {}

+    // Languages offered in the Language choice. Default: allLanguages().
+    [[nodiscard]] virtual std::span<const Language> languagesForChoice() const {
+        return allLanguages();
+    }
+
    [[nodiscard]] virtual std::string updateMenuName() const { return "Update Sets"; }

    // Display name passed into errors and the dialog title hints.
@@ -151,6 +161,12 @@ protected:
        return preloadedSets_ != nullptr ? *preloadedSets_ : sets_;
    }

+    void setPreloadedSetsPointer(const std::vector<Set>* sets) noexcept {
+        preloadedSets_ = sets;
+    }
+
+    void refreshSetAndLanguageChoices() { populateChoices(); }
+
    // Default: combo only. Yu-Gi-Oh! overrides to add set-code entry + toggle.
    virtual void customizeSetPickerRow(wxBoxSizer& row, wxComboBox* combo) {
        row.Add(combo, 1, wxEXPAND);
@@ -193,6 +209,9 @@ private:
        });
        appendRow(grid, "Name", nameCtrl_);

+        // Optional rows between Name and Set (e.g. Pokemon West/Asia region).
+        appendPreSetRows(grid);
+
        // `setCombo_` must be parented to `setHost` so every control in the Set row
        // shares the same `wxPanel`; otherwise the combo stays a direct child of the
        // dialog while the sizer lives on `setHost`, which corrupts layout on MSW.
@@ -311,9 +330,10 @@ private:
        languageChoice_->Clear();
        int langIdx = 0;
        int i = 0;
+        const auto langsForChoice = languagesForChoice();
        wxArrayString langs;
-        langs.Alloc(allLanguages().size());
-        for (auto l : allLanguages()) {
+        langs.Alloc(langsForChoice.size());
+        for (auto l : langsForChoice) {
            const std::string lang = std::string(to_string(l));
            langs.Add(wxString::FromUTF8(lang.c_str()));
            if (l == card_.language) langIdx = i;
@@ -486,20 +506,43 @@ private:
 #endif
    }

+    // Fold a few Latin-1 diacritics so typing ASCII "Pokemon" matches "Pokémon".
+    [[nodiscard]] static wxString foldAsciiForTypeahead(wxString s) {
+        s.MakeLower();
+        s.Replace(wxString::FromUTF8("\xc3\xa9"), wxT("e"));  // é
+        s.Replace(wxString::FromUTF8("\xc3\x89"), wxT("e"));  // É (after lower: é)
+        s.Replace(wxString::FromUTF8("\xc3\xa8"), wxT("e"));  // è
+        s.Replace(wxString::FromUTF8("\xc3\xaa"), wxT("e"));  // ê
+        s.Replace(wxString::FromUTF8("\xc3\xa0"), wxT("a"));  // à
+        s.Replace(wxString::FromUTF8("\xc3\xa1"), wxT("a"));  // á
+        s.Replace(wxString::FromUTF8("\xc3\xb1"), wxT("n"));  // ñ
+        s.Replace(wxString::FromUTF8("\xc3\xbc"), wxT("u"));  // ü
+        s.Replace(wxString::FromUTF8("\xc3\xb6"), wxT("o"));  // ö
+        return s;
+    }
+
    void applySetTypeaheadSelection() {
        const auto& available = availableSets();
        if (!setCombo_ || available.empty()) return;
-        wxString pref = setTypeaheadPrefix_;
-        pref.MakeLower();
+        const wxString pref = foldAsciiForTypeahead(setTypeaheadPrefix_);
        if (pref.empty()) return;
+        // Prefer prefix matches, then substring (so "Jungle" finds "Pokémon Jungle").
        for (std::size_t i = 0; i < available.size(); ++i) {
-            wxString name(wxString::FromUTF8(available[i].name));
-            name.MakeLower();
+            const wxString name =
+                foldAsciiForTypeahead(wxString::FromUTF8(available[i].name));
            if (name.StartsWith(pref)) {
                setCombo_->SetSelection(static_cast<int>(i));
                return;
            }
        }
+        for (std::size_t i = 0; i < available.size(); ++i) {
+            const wxString name =
+                foldAsciiForTypeahead(wxString::FromUTF8(available[i].name));
+            if (name.Contains(pref)) {
+                setCombo_->SetSelection(static_cast<int>(i));
+                return;
+            }
+        }
    }

    void onSetComboChar(wxKeyEvent& ev) {
@@ -217,6 +217,12 @@ protected:

    [[nodiscard]] virtual Game gameId() const noexcept = 0;

+    // Preview / card-back routing. Defaults to `gameId()`; Pokemon overrides
+    // so Asia cards use the JapanesePokemon preview source + card back.
+    [[nodiscard]] virtual Game previewGameFor(const TCard& /*card*/) const noexcept {
+        return gameId();
+    }
+
    // Construction ------------------------------------------------------------

    BaseSelectedCardPanel(wxWindow* parent,
@@ -292,12 +298,17 @@ private:
            case Game::Pokemon:
                // Mirrors CCM2's unresolved-preview fallback image.
                return "https://archives.bulbagarden.net/media/upload/1/17/Cardback.jpg";
+            case Game::JapanesePokemon:
+                // Japanese TCG back (distinct from the Western Cardback.jpg).
+                return "https://archives.bulbagarden.net/media/upload/2/2a/TCG_Card_Back_Japanese.jpg";
            case Game::YuGiOh:
                // Yugipedia English TCG backing (thumbnail — smaller than full scan).
                return "https://ms.yugipedia.com/thumb/e/e5/Back-EN.png/250px-Back-EN.png";
-            default:
+            case Game::DigiBattle99:
+                // No stable public Digi-Battle back URL; UI uses bundled PNG.
                return {};
        }
+        return {};
    }

    void buildInfoGrid(wxBoxSizer* root) {
@@ -377,7 +388,7 @@ private:
        auto state = state_;
        CardPreviewService* svcPtr = &cardPreview_;
        auto [name, setId, setNo] = previewKey(card);
-        const Game game = gameId();
+        const Game game = previewGameFor(card);
        const std::string exeDirCopy = exeDirForBundledAssets_;

        std::thread([state, gen, svcPtr, name = std::move(name),
@@ -424,6 +435,16 @@ private:
                            applyFallbackPayload(ss.str());
                        }
                    }
+                } else if (game == Game::DigiBattle99) {
+                    namespace fs = std::filesystem;
+                    const fs::path asset =
+                        fs::path(exeDirCopy) / "assets" / "digibattle99_card_back.png";
+                    std::ifstream in(asset, std::ios::binary);
+                    if (in) {
+                        std::ostringstream ss;
+                        ss << in.rdbuf();
+                        applyFallbackPayload(ss.str());
+                    }
                } else {
                    const std::string fallbackUrl = fallbackImageUrlForGame(game);
                    if (!fallbackUrl.empty()) {
@@ -0,0 +1,81 @@
+#pragma once
+
+#include "ccm/domain/DigiBattle99Card.hpp"
+#include "ccm/ports/ICardPreviewSource.hpp"
+#include "ccm/services/CardPreviewService.hpp"
+#include "ccm/ui/BaseCardEditDialog.hpp"
+#include <wx/button.h>
+
+#include <atomic>
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace ccm::ui {
+
+class DigiBattle99CardEditDialog final : public BaseCardEditDialog<DigiBattle99Card> {
+public:
+    DigiBattle99CardEditDialog(wxWindow* parent,
+                               ImageService& imageService,
+                               SetService& setService,
+                               CardPreviewService& cardPreview,
+                               EditMode mode,
+                               DigiBattle99Card initial,
+                               const std::vector<Set>* preloadedSets = nullptr);
+    ~DigiBattle99CardEditDialog() override;
+
+protected:
+    void buildFlagsRow(wxBoxSizer* flagsBox) override;
+    void appendExtraRows(wxFlexGridSizer* grid) override;
+    void readExtraFromCard() override;
+    void writeExtraToCard() override;
+    [[nodiscard]] std::string updateMenuName() const override {
+        return "Update Digimon (Digi-Battle)";
+    }
+    void onCardLookupContextChanged() override;
+
+private:
+    struct VariantFetchState {
+        std::atomic<bool> alive{true};
+    };
+
+    void onAutoDetectSetNo(wxCommandEvent&);
+    void onNextSetNo(wxCommandEvent&);
+    void onSetSelectionChanged(wxCommandEvent&);
+    void autoDetectFromApi();
+    void clearCachedPrintVariants();
+    void requestVariantsAsync(unsigned capturedEpoch,
+                              std::string name,
+                              std::string setName,
+                              bool fillSetNoOnSuccess,
+                              bool showFailureDialog);
+    void applyDetectedVariants(unsigned capturedEpoch,
+                               Result<std::vector<AutoDetectedPrint>> detected,
+                               bool fillSetNoOnSuccess,
+                               bool showFailureDialog);
+    void rebuildVariantRingFromCache();
+    void syncRingPositionToControls();
+    void refreshVariantNextControls();
+    void scheduleDeferredVariantPrefetch();
+    void prefetchVariantsForCurrentCardSilent(unsigned capturedEpoch);
+    [[nodiscard]] static std::string storedSetNoFromControls(const wxTextCtrl* ctrl);
+    [[nodiscard]] static std::string normalizedStoredSetNo(std::string_view setNo);
+
+    EditMode                      dialogMode_;
+    unsigned                      variantFetchEpoch_{0};
+    CardPreviewService&           cardPreview_;
+    std::shared_ptr<VariantFetchState> variantFetchState_;
+    wxTextCtrl*                   setNoCtrl_{nullptr};
+    wxButton*                     autoSetNoBtn_{nullptr};
+    wxButton*                     nextSetNoBtn_{nullptr};
+    wxCheckBox*                   holoCheck_{nullptr};
+    wxCheckBox*                   firstEditionCheck_{nullptr};
+    wxCheckBox*                   signedCheck_{nullptr};
+    wxCheckBox*                   alteredCheck_{nullptr};
+
+    std::vector<AutoDetectedPrint> cachedVariants_;
+    std::vector<std::string>       uniqueSetNos_;
+    std::size_t                    setNoRingPos_{0};
+};
+
+}  // namespace ccm::ui
@@ -0,0 +1,26 @@
+#pragma once
+
+#include "ccm/domain/DigiBattle99Card.hpp"
+#include "ccm/services/CardSorter.hpp"
+#include "ccm/ui/BaseCardListPanel.hpp"
+
+namespace ccm::ui {
+
+class DigiBattle99CardListPanel final
+    : public BaseCardListPanel<DigiBattle99Card, DigiBattle99SortColumn> {
+public:
+    explicit DigiBattle99CardListPanel(wxWindow* parent);
+
+protected:
+    [[nodiscard]] std::vector<TextColumnSpec> declareTextColumns() const override;
+    [[nodiscard]] std::vector<IconColumnSpec> declareIconColumns() const override;
+    [[nodiscard]] std::string renderTextCell(const DigiBattle99Card& card,
+                                             std::size_t idx) const override;
+    [[nodiscard]] bool isIconColumnSet(const DigiBattle99Card& card,
+                                       std::size_t idx) const override;
+    void sortBy(DigiBattle99SortColumn column, bool ascending) override;
+    [[nodiscard]] bool matchesFilter(const DigiBattle99Card& card,
+                                     std::string_view filter) const override;
+};
+
+}  // namespace ccm::ui
@@ -0,0 +1,64 @@
+#pragma once
+
+#include "ccm/domain/DigiBattle99Card.hpp"
+#include "ccm/games/IGameModule.hpp"
+#include "ccm/services/CardPreviewService.hpp"
+#include "ccm/services/CollectionService.hpp"
+#include "ccm/services/ConfigService.hpp"
+#include "ccm/services/ImageService.hpp"
+#include "ccm/services/SetService.hpp"
+#include "ccm/ui/IGameView.hpp"
+
+#include <string>
+#include <string_view>
+#include <vector>
+
+namespace ccm::ui {
+
+class DigiBattle99CardListPanel;
+class DigiBattle99SelectedCardPanel;
+
+class DigiBattle99GameView final : public IGameView {
+public:
+    DigiBattle99GameView(ConfigService&                         config,
+                         CollectionService<DigiBattle99Card>&   collection,
+                         SetService&                            sets,
+                         ImageService&                          images,
+                         CardPreviewService&                    cardPreview,
+                         IGameModule&                           module);
+
+    [[nodiscard]] Game        gameId() const noexcept override { return Game::DigiBattle99; }
+    [[nodiscard]] std::string displayName() const override { return "Digimon (Digi-Battle)"; }
+
+    wxPanel* listPanel(wxWindow* parent) override;
+    wxPanel* selectedPanel(wxWindow* parent) override;
+
+    void refreshCollection() override;
+    void onAddCard(wxWindow* parentWindow) override;
+    void onEditCard(wxWindow* parentWindow) override;
+    void onDeleteCard(wxWindow* parentWindow) override;
+    std::string onUpdateSets(wxWindow* parentWindow) override;
+    void setFilter(std::string_view filter) override;
+    void applyTheme(const ThemePalette& palette) override;
+    [[nodiscard]] std::string updateSetsMenuLabel() const override {
+        return "Update Digimon (Digi-Battle)";
+    }
+
+private:
+    void ensureSetsLoaded();
+    const std::vector<Set>& setsForDialog();
+
+    ConfigService&                        config_;
+    CollectionService<DigiBattle99Card>&  collection_;
+    SetService&                           sets_;
+    ImageService&                         images_;
+    CardPreviewService&                   cardPreview_;
+    IGameModule&                          module_;
+
+    DigiBattle99CardListPanel*     listPanel_{nullptr};
+    DigiBattle99SelectedCardPanel* selectedPanel_{nullptr};
+    std::vector<Set>               setsCache_;
+    bool                           attemptedInitialSetLoad_{false};
+};
+
+}  // namespace ccm::ui
@@ -0,0 +1,25 @@
+#pragma once
+
+#include "ccm/domain/DigiBattle99Card.hpp"
+#include "ccm/ui/BaseSelectedCardPanel.hpp"
+
+namespace ccm::ui {
+
+class DigiBattle99SelectedCardPanel final : public BaseSelectedCardPanel<DigiBattle99Card> {
+public:
+    DigiBattle99SelectedCardPanel(wxWindow* parent,
+                                  ImageService& imageService,
+                                  CardPreviewService& cardPreview);
+
+protected:
+    [[nodiscard]] std::vector<DetailRowSpec> declareDetailRows() const override;
+    [[nodiscard]] std::vector<FlagIconSpec>  declareFlagIcons()  const override;
+    [[nodiscard]] std::string detailValueFor(const DigiBattle99Card& card,
+                                             DetailKey key) const override;
+    [[nodiscard]] bool isFlagSet(const DigiBattle99Card& card, DetailKey key) const override;
+    [[nodiscard]] std::tuple<std::string, std::string, std::string>
+        previewKey(const DigiBattle99Card& card) const override;
+    [[nodiscard]] Game gameId() const noexcept override { return Game::DigiBattle99; }
+};
+
+}  // namespace ccm::ui
@@ -1,24 +1,28 @@
 #pragma once

-// PokemonCardEditDialog: typed Add/Edit form for a `PokemonCard`. Inherits
-// the shared layout, set picker, and image management from
-// `BaseCardEditDialog<PokemonCard>` and adds:
-//   - a `Set #` text input (between the Set picker and the Amount spin)
-//   - `Holo`, `1. Edition`, `Signed`, `Altered` check boxes in the flags row
+// PokemonCardEditDialog: Add/Edit form for a unified West/Asia PokemonCard.
+// West/Asia switch drives set lists, language choices, preview APIs, and the
+// Asia-only UnnumberedPromo print UX (from the former Japanese dialog).

 #include "ccm/domain/PokemonCard.hpp"
 #include "ccm/ports/ICardPreviewSource.hpp"
 #include "ccm/services/CardPreviewService.hpp"
 #include "ccm/ui/BaseCardEditDialog.hpp"
+#include "ccm/ui/SwitchCtrl.hpp"
+
 #include <wx/button.h>
+#include <wx/stattext.h>

 #include <atomic>
 #include <memory>
+#include <span>
 #include <string>
 #include <vector>

 namespace ccm::ui {

+class VariantImagePreviewDialog;
+
 class PokemonCardEditDialog final : public BaseCardEditDialog<PokemonCard> {
 public:
    PokemonCardEditDialog(wxWindow* parent,
@@ -27,22 +31,27 @@ public:
                          CardPreviewService& cardPreview,
                          EditMode mode,
                          PokemonCard initial,
-                          const std::vector<Set>* preloadedSets = nullptr);
+                          const std::vector<Set>* westSets = nullptr,
+                          const std::vector<Set>* asiaSets = nullptr);
    ~PokemonCardEditDialog() override;

 protected:
+    void appendPreSetRows(wxFlexGridSizer* grid) override;
    void buildFlagsRow(wxBoxSizer* flagsBox) override;
    void appendExtraRows(wxFlexGridSizer* grid) override;
    void readExtraFromCard() override;
    void writeExtraToCard() override;
    [[nodiscard]] std::string updateMenuName() const override { return "Update Pokemon"; }
    void onCardLookupContextChanged() override;
+    [[nodiscard]] std::span<const Language> languagesForChoice() const override;

 private:
    struct VariantFetchState {
        std::atomic<bool> alive{true};
    };

+    void onRegionSwitch(wxCommandEvent&);
+    void applyRegion(PokemonRegion region, bool clearSetIfMissing);
    void onAutoDetectSetNo(wxCommandEvent&);
    void onNextSetNo(wxCommandEvent&);
    void onSetSelectionChanged(wxCommandEvent&);
@@ -60,15 +69,37 @@ private:
    void rebuildVariantRingFromCache();
    void syncRingPositionToControls();
    void refreshVariantNextControls();
+    void refreshSetNoRowMode();
+    void applySelectedSetNo(std::string setNo);
+    void stepVariantRing(int delta);
    void scheduleDeferredVariantPrefetch();
    void prefetchVariantsForCurrentCardSilent(unsigned capturedEpoch);
+    void closeUnnumberedPreview();
+    void ensureUnnumberedPreviewOpen();
+    void refreshUnnumberedPreview();
+    void requestUnnumberedPreviewAsync(unsigned capturedEpoch,
+                                       std::string name,
+                                       std::string setId,
+                                       std::string setNo,
+                                       std::size_t ringIndex,
+                                       std::size_t ringCount);
+    [[nodiscard]] bool isUnnumberedPromoSelected() const;
+    [[nodiscard]] std::string currentRingSetNo() const;
+    [[nodiscard]] Game backendGame() const noexcept;
+    [[nodiscard]] PokemonRegion currentRegion() const noexcept;
    [[nodiscard]] static std::string storedSetNoFromControls(const wxTextCtrl* ctrl);
    [[nodiscard]] static std::string normalizedStoredSetNo(std::string_view setNo);

    EditMode                      dialogMode_;
    unsigned                      variantFetchEpoch_{0};
+    unsigned                      previewFetchEpoch_{0};
    CardPreviewService&           cardPreview_;
+    const std::vector<Set>*       westSets_{nullptr};
+    const std::vector<Set>*       asiaSets_{nullptr};
    std::shared_ptr<VariantFetchState> variantFetchState_;
+
+    SwitchCtrl*                   regionSwitch_{nullptr};
+    wxStaticText*                 setNoLabel_{nullptr};
    wxTextCtrl*                   setNoCtrl_{nullptr};
    wxButton*                     autoSetNoBtn_{nullptr};
    wxButton*                     nextSetNoBtn_{nullptr};
@@ -76,7 +107,9 @@ private:
    wxCheckBox*                   firstEditionCheck_{nullptr};
    wxCheckBox*                   signedCheck_{nullptr};
    wxCheckBox*                   alteredCheck_{nullptr};
+    VariantImagePreviewDialog*    unnumberedPreview_{nullptr};

+    std::string                    selectedSetNo_;
    std::vector<AutoDetectedPrint> cachedVariants_;
    std::vector<std::string>       uniqueSetNos_;
    std::size_t                    setNoRingPos_{0};
@@ -1,9 +1,7 @@
 #pragma once

-// PokemonGameView: IGameView for the Pokemon TCG. Mirrors `MagicGameView` —
-// owns the Pokemon-typed list, selected, and edit-dialog widgets and
-// delegates persistence to a `CollectionService<PokemonCard>` reference
-// supplied by the composition root.
+// PokemonGameView: unified West + Asia Pokemon UI. One collection file;
+// separate West/Asia set caches; Sets > Update Pokemon refreshes both.

 #include "ccm/domain/PokemonCard.hpp"
 #include "ccm/games/IGameModule.hpp"
@@ -49,7 +47,7 @@ public:

 private:
    void ensureSetsLoaded();
-    const std::vector<Set>& setsForDialog();
+    const std::vector<Set>& setsForDialog(PokemonRegion region);

    ConfigService&                  config_;
    CollectionService<PokemonCard>& collection_;
@@ -60,7 +58,8 @@ private:

    PokemonCardListPanel*     listPanel_{nullptr};
    PokemonSelectedCardPanel* selectedPanel_{nullptr};
-    std::vector<Set>          setsCache_;
+    std::vector<Set>          setsCacheWest_;
+    std::vector<Set>          setsCacheAsia_;
    bool                      attemptedInitialSetLoad_{false};
 };

--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Sebastian Dine	c9e6bc2b6b	Minor: Add Asian Pokemon Card Support (#18 )	2026-07-22 11:13:42 +02:00
Sebastian Dine	e5c830e945	minor: New Game Digimon Digi-Battle (#17 ) * digimon digi battle added to supported games * sonarqube update * readme update --------- Co-authored-by: sdine <sdine@sdine.com>	2026-07-19 12:06:57 +02:00