Switch map to sub-national regions (v0.12.0)

Part of #16

src/App.tsx

@@ -589,6 +589,17 @@ function GameScreen({
 }: GameScreenProps) {
   // Which nation's dossier to show. Defaults to the player; remounts per game.
   const [viewingId, setViewingId] = useState(game.playerNationId);
+  // When the dossier target was set by a map click, remember which sub-region
+  // (its own name + parent country) was clicked, for a small label in the
+  // dossier. Cleared when the user picks a nation via the manual Inspect select.
+  const [selectedRegion, setSelectedRegion] = useState<{ parent?: string; name?: string } | null>(null);
+  const focusNation = useCallback(
+    (id: string, info?: { parent?: string; name?: string }) => {
+      setViewingId(id);
+      setSelectedRegion(info ?? null);
+    },
+    [],
+  );
   const player = game.nations[game.playerNationId];
   const viewed = game.nations[viewingId] ?? player;
   const nations = Object.values(game.nations).sort((a, b) => a.name.localeCompare(b.name));
@@ -641,7 +652,7 @@ function GameScreen({
         playerNationId={game.playerNationId}
         nations={game.nations}
         presetId={game.presetId}
-        onFocusNation={setViewingId}
+        onFocusNation={focusNation}
       />
 
       {/* Pinned top bar: brand, turn + date, player nation, live status, Focus map.
@@ -747,7 +758,14 @@ function GameScreen({
           <div className="mb-1.5 text-xs font-medium uppercase tracking-wide text-muted-foreground">
             Inspect
           </div>
-          <Select value={viewingId} onValueChange={setViewingId}>
+          <Select
+            value={viewingId}
+            onValueChange={(id) => {
+              // A manual pick supersedes a map-click selection: clear the label.
+              setViewingId(id);
+              setSelectedRegion(null);
+            }}
+          >
             <SelectTrigger className="w-full" data-testid="inspect-select">
               <SelectValue />
             </SelectTrigger>
@@ -759,6 +777,12 @@ function GameScreen({
               ))}
             </SelectContent>
           </Select>
+          {selectedRegion && (
+            <div className="mt-1.5 truncate text-[11px] text-muted-foreground" data-testid="selected-region">
+              Selected: {selectedRegion.name ?? selectedRegion.parent ?? 'region'}
+              {selectedRegion.parent ? ` (${selectedRegion.parent})` : ''}
+            </div>
+          )}
         </div>
         <NationPanel nation={viewed} nations={game.nations} isPlayer={viewingId === game.playerNationId} inWindow />
       </FloatingWindow>

src/components/WorldMap.tsx

@@ -8,11 +8,14 @@ import 'maplibre-gl/dist/maplibre-gl.css';
 // Point it at a Vite-emitted copy of the worker module so it loads in prod.
 import workerUrl from 'maplibre-gl/dist/maplibre-gl-worker.mjs?url';
 maplibregl.setWorkerUrl(workerUrl);
-import { regionOwner, type RegionMap, type RegionOwner } from '@shared/protocol';
+import { mapFeatureOwner, type RegionMap, type RegionOwner } from '@shared/protocol';
 import type { Nation } from '@shared/types';
 import { cn } from '@/lib/utils';
 
-// Minimal GeoJSON types (avoids a hard @types/geojson dependency).
+// Minimal GeoJSON types (avoids a hard @types/geojson dependency). The choropleth
+// source is the sub-national `regions.geo.json`: each feature is a sub-region with
+// a top-level `id` of the form `<ISO_A3>-<nn>` (e.g. `FRA-03`) and
+// `properties = { name, parent }` where `parent` is the parent country's ISO_A3.
 interface GeoFeature {
   type: 'Feature';
   id?: string | number;
@@ -27,7 +30,7 @@ type GeoSource = maplibregl.GeoJSONSource;
 
 // Inline basemap style — a visible dark-navy background plus a subtle
 // OpenFreeMap shaded-relief raster so the ocean is never pure black and terrain
-// is faintly visible. The country choropleth (added in `ensureLayers`) is drawn
+// is faintly visible. The regional choropleth (added in `ensureLayers`) is drawn
 // on top and is the real star.
 //
 // Why inline instead of a remote style URL: the OFM "dark" style's vector tiles
@@ -69,11 +72,11 @@ const INLINE_STYLE: maplibregl.StyleSpecification = {
   ],
 };
 
-const COUNTRIES_SOURCE = 'countries';
+const REGIONS_SOURCE = 'regions';
 const HOVER_SOURCE = 'hover';
 const FLASH_SOURCE = 'flash';
-const FILL_LAYER = 'countries-fill';
-const LINE_LAYER = 'countries-line';
+const FILL_LAYER = 'regions-fill';
+const LINE_LAYER = 'regions-line';
 const PLAYER_LINE = 'player-line';
 const FLASH_LINE = 'flash-line';
 const HOVER_FILL = 'hover-fill';
@@ -97,29 +100,39 @@ function cameraForPreset(presetId: string): { center: [number, number]; zoom: nu
 }
 
 /**
- * Stamp the current ownership + colors onto a clone of the base geo. Each region
- * carries its owner's stable fill color, a subtle stroke, and a flag for the
- * player's own regions (rendered as a brighter, thicker border by a dedicated
- * layer). Unknown owners fall back to a faint neutral fill — never an error.
+ * Stamp the current ownership + colors onto a clone of the sub-national base geo.
+ * Ownership and the LLM stay at **country** granularity (#16, PR 2): a nation
+ * owns whole countries, so every sub-region of a country shares that country's
+ * owning nation's color — the map looks like the old country choropleth, but
+ * subdivided into finer cells. Each sub-region therefore carries:
  *
- * Crucially, the base GeoJSON feature's top-level `id` (the ISO_A3 code) is
- * stamped into `properties.regionId`, and the owner's id into `properties.ownerId`.
- * MapLibre repacks a GeoJSON source's top-level `id` into a numeric index when it
- * stores it, so a later click/hover event exposes that number on
- * `e.features[i].id` — the top-level `id` is *not* a reliable lookup key at
- * interaction time (the root cause of #6). `properties`, however, survive into the
- * rendered features, so the interaction handlers resolve the owning nation from
- * `properties.regionId` via the RegionMap (see `regionOwner`).
+ *  - `regionId`  – its own sub-region id (e.g. `FRA-03`), kept in a property that
+ *                  survives into the features MapLibre hands back on click/hover
+ *                  (the top-level `id` is repacked into a numeric index, #6);
+ *  - `parent`    – the parent country's ISO_A3 (e.g. `FRA`), the RegionMap key;
+ *  - `fill`      – the owning nation's stable color (from `RegionMap[parent]`);
+ *  - `owner`/`ownerId` – that nation's name/id (empty for an unowned country);
+ *  - `stroke`    – a per-border alpha (owned brighter than unowned);
+ *  - `isPlayer`  – 1 when the owning nation is the player (drives the amber
+ *                  player-highlight border).
+ *
+ * Crucially, the owner lookup keys the RegionMap by `properties.parent` (the
+ * country ISO_A3), **never** by the sub-region id — the RegionMap has no
+ * `FRA-03` entries, only `FRA`.
  */
 function applyRegions(geo: FeatureCollection, regions: RegionMap, playerNationId: string): FeatureCollection {
   const out: FeatureCollection = JSON.parse(JSON.stringify(geo));
   for (const f of out.features) {
     f.properties = f.properties ?? {};
-    // The base GeoJSON `id` is the ISO_A3 code; keep it in a property that
-    // survives into the features MapLibre hands back on click/hover.
-    const code = f.id == null ? '' : String(f.id);
-    f.properties.regionId = code;
-    const r = code ? regions[code] : undefined;
+    // The sub-region's own id (e.g. `FRA-03`) — stamped into a property that
+    // survives into the rendered features (the top-level `id` gets repacked).
+    const subId = f.id == null ? '' : String(f.id);
+    f.properties.regionId = subId;
+    // Ownership lives at the parent country: resolve `properties.parent`
+    // (the ISO_A3) against the RegionMap. Never the sub-region id.
+    const parent = typeof f.properties.parent === 'string' ? f.properties.parent : '';
+    f.properties.parent = parent;
+    const r = parent ? regions[parent] : undefined;
     if (r) {
       f.properties.fill = r.color;
       f.properties.owner = r.owner;
@@ -137,10 +150,18 @@ function applyRegions(geo: FeatureCollection, regions: RegionMap, playerNationId
   return out;
 }
 
-/** Build a FeatureCollection of just the features whose id is in `codes` (cloned). */
-function featuresByCodes(geo: FeatureCollection, codes: Iterable<string>): FeatureCollection {
-  const set = new Set(codes);
-  const features = geo.features.filter((f) => f.id != null && set.has(String(f.id)));
+/**
+ * Build a FeatureCollection of just the sub-regions whose **parent** country is
+ * in `parents` (cloned). Used by the territory-change flash: a turn changes a
+ * whole *country* (the RegionMap is ISO_A3-keyed), so a changed country's code
+ * must light up **all** of its sub-regions, not a single feature.
+ */
+function featuresByParents(geo: FeatureCollection, parents: Iterable<string>): FeatureCollection {
+  const set = new Set(parents);
+  const features = geo.features.filter((f) => {
+    const parent = f.properties?.parent;
+    return typeof parent === 'string' && set.has(parent);
+  });
   return { type: 'FeatureCollection', features: JSON.parse(JSON.stringify(features)) };
 }
 
@@ -152,14 +173,20 @@ function statRow(label: string, value?: number): string {
   return `<div class="hm-stat"><span class="hm-stat-k">${label}</span><span class="hm-stat-v">${Math.round(value)}</span></div>`;
 }
 
-/** Compact hover tooltip: country, its owner (color-chipped), and 1–2 key stats. */
-function hoverHtml(countryName: string, region?: RegionOwner, nation?: Nation): string {
+/**
+ * Compact hover tooltip: the sub-region's name, its parent country (ISO_A3), its
+ * owner (color-chipped), and 1–2 key stats. When the parent country has no
+ * owning nation, a minimal "No owner" card is shown instead.
+ */
+function hoverHtml(subRegionName: string, parentCode: string, region?: RegionOwner, nation?: Nation): string {
   if (!region || !nation) {
-    return `<div class="hm-popup"><div class="hm-popup-title">${esc(countryName || 'Unclaimed')}</div><div class="hm-popup-sub">No owner</div></div>`;
+    return `<div class="hm-popup"><div class="hm-popup-title">${esc(subRegionName || parentCode || 'Unclaimed')}</div><div class="hm-popup-sub">No owner</div></div>`;
   }
   const stats = [statRow('Mil', nation.stats.military), statRow('Eco', nation.stats.economy)].join('');
+  const sub = parentCode ? `<div class="hm-popup-sub">${esc(parentCode)}</div>` : '';
   return `<div class="hm-popup">
-    <div class="hm-popup-title">${esc(countryName || region.owner)}</div>
+    <div class="hm-popup-title">${esc(subRegionName || region.owner)}</div>
+    ${sub}
     <div class="hm-popup-owner"><span class="hm-chip" style="background:${region.color}"></span>${esc(region.owner)}</div>
     <div class="hm-stats">${stats}</div>
   </div>`;
@@ -174,27 +201,38 @@ interface Props {
   presetId: string;
   className?: string;
   /**
-   * Called with a region's owning-nation id when that region is clicked, so the
-   * dossier switches to that nation. Not called for unowned regions (the dossier
-   * keeps its current target). See the component doc for the full behavior.
+   * Called with a region's owning-nation id when a sub-region is clicked, so the
+   * dossier switches to that nation. For a sub-region, the owner is the parent
+   * country's owning nation. The optional `info` carries the clicked sub-region's
+   * own id/name and its parent country's ISO_A3, for a small "which region" label
+   * in the dossier. Not called for unowned regions (the dossier keeps its
+   * current target). See the component doc for the full behavior.
    */
-  onFocusNation?: (id: string) => void;
+  onFocusNation?: (id: string, info?: { parent?: string; name?: string }) => void;
 }
 
 /**
- * World basemap (MapLibre GL) + a country choropleth colored by the owning
- * nation. Rendered as a fixed, full-viewport background layer (z-0) behind the
- * floating HUD windows: a dark-navy basemap with subtle terrain, per-nation
- * stable fills (the choropleth is the star), thin borders, a brighter/thicker
- * border for the player, a hover tooltip (owner + key stats), a **click that
- * switches the dossier to the region's owning nation** (no popup — see #7), a
- * transient flash on territory changes, and a per-scenario initial camera.
+ * World basemap (MapLibre GL) + a **sub-national** choropleth. The map renders
+ * the finer `regions.geo.json` dataset: each country is subdivided into
+ * ~100–200 km sub-regions, drawn as a finer choropleth with thin internal border
+ * lines. Ownership and the LLM stay at **country** granularity (#16, PR 2): a
+ * nation owns whole countries, so all of a country's sub-regions share that
+ * country's owning-nation color. Rendered as a fixed, full-viewport background
+ * layer (z-0) behind the floating HUD windows: a dark-navy basemap with subtle
+ * terrain, per-nation stable fills (uniform per country, the choropleth is the
+ * star), thin sub-region borders, a brighter/thicker amber border for the
+ * player's countries, a hover tooltip (sub-region name + parent country + owner
+ * + key stats), a **click that switches the dossier to the sub-region's parent
+ * country's owning nation** (no popup — see #7), a transient flash when a
+ * country's owner changes (lighting up all its sub-regions), and a per-scenario
+ * initial camera.
  *
- * Ownership for a hovered/clicked region is resolved from the authoritative
- * RegionMap by the feature's stable ISO_A3 code in `properties.regionId`
- * (see `regionOwner` in @shared/protocol) — never from the feature's top-level
- * `id`, which MapLibre repacks into a numeric index at interaction time (#6).
- * Unowned regions (no RegionMap entry) simply do not change the dossier.
+ * Ownership for a hovered/clicked sub-region is resolved from the authoritative
+ * RegionMap by its **parent country's** ISO_A3 code (`properties.parent`, via
+ * `mapFeatureOwner` in @shared/protocol) — never from the feature's top-level
+ * `id` (MapLibre repacks it into a numeric index at interaction time, #6) and
+ * never from the sub-region id (not a RegionMap key). Unowned countries (no
+ * RegionMap entry for the parent) simply do not change the dossier.
  *
  * Zoom and pan are driven directly by the user (MapLibre wheel/trackpad + drag)
  * — no floating control and no external API.
@@ -255,9 +293,9 @@ export default function WorldMap({
     const loadGeo = (): Promise<FeatureCollection> =>
       baseGeoRef.current
         ? Promise.resolve(baseGeoRef.current)
-        : fetch('/countries.geo.json')
+        : fetch('/regions.geo.json')
             .then((r) => {
-              if (!r.ok) throw new Error(`countries.geo.json → HTTP ${r.status}`);
+              if (!r.ok) throw new Error(`regions.geo.json → HTTP ${r.status}`);
               return r.json();
             })
             .then((g: FeatureCollection) => {
@@ -268,12 +306,14 @@ export default function WorldMap({
     const emptyFC = (): FeatureCollection => ({ type: 'FeatureCollection', features: [] });
 
     // Transient flash: pulse a bright outline over the changed regions, then fade
-    // to zero over a few seconds and self-clean. Idempotent per call.
+    // to zero over a few seconds and self-clean. Idempotent per call. `codes` are
+    // parent-country ISO_A3 codes (a turn changes whole countries); each lights
+    // up all of that country's sub-regions.
     function animateFlash(codes: string[]) {
       const geo = baseGeoRef.current;
       const src = map.getSource(FLASH_SOURCE) as GeoSource | undefined;
       if (!geo || !src || cancelled) return;
-      src.setData(featuresByCodes(geo, codes));
+      src.setData(featuresByParents(geo, codes));
       if (!map.getLayer(FLASH_LINE)) {
         // Defensive re-add (normally created by ensureLayers). Keep it beneath the
         // hover highlight when that layer exists; otherwise just append.
@@ -306,33 +346,34 @@ export default function WorldMap({
     }
     flashApiRef.current = animateFlash;
 
-    // The region a hovered/clicked feature belongs to is identified by its stable
-    // ISO_A3 code, read from `properties.regionId` (stamped by `applyRegions`).
-    // We must NOT use the feature's top-level `id`: MapLibre repacks a GeoJSON
-    // source's `id` into a numeric index when it stores the source, so the value
-    // exposed on `e.features[i].id` at interaction time is a number, never the
-    // ISO_A3 — resolving the owner from it is the "no owner" bug (#6).
+    // The sub-region a hovered/clicked feature belongs to is identified by its
+    // stable sub-region id in `properties.regionId` (stamped by `applyRegions`),
+    // and its **owner** is resolved from the authoritative RegionMap via the
+    // feature's `properties.parent` (the parent country's ISO_A3) through
+    // `mapFeatureOwner` — never from the repacked top-level `id` (a numeric
+    // index, #6) and never from the sub-region id (not a RegionMap key).
     const onHover = (e: maplibregl.MapLayerMouseEvent) => {
       const f = e.features?.[0];
       if (!f) return;
-      const p = f.properties as { name?: string; regionId?: string };
-      const code = typeof p?.regionId === 'string' ? p.regionId : '';
-      if (code && code !== lastHoverId) {
-        lastHoverId = code;
+      const p = f.properties as { name?: string; regionId?: string; parent?: string };
+      const subId = typeof p?.regionId === 'string' ? p.regionId : '';
+      const parent = typeof p?.parent === 'string' ? p.parent : '';
+      if (subId && subId !== lastHoverId) {
+        lastHoverId = subId;
         const geo = baseGeoRef.current;
-        // The base GeoJSON feature's top-level `id` IS the ISO_A3, so match on
-        // that to recover the feature for the hover-highlight outline (the
-        // feature MapLibre hands us has a repacked numeric `id` we can't use).
-        const feat = geo?.features.find((x) => x.id != null && String(x.id) === code);
+        // The base GeoJSON feature's top-level `id` IS the sub-region id, so
+        // match on it to recover the exact feature for the hover-highlight
+        // outline (the feature MapLibre hands us has a repacked numeric `id`).
+        const feat = geo?.features.find((x) => x.id != null && String(x.id) === subId);
         (map.getSource(HOVER_SOURCE) as GeoSource | undefined)?.setData(
           feat ? { type: 'FeatureCollection', features: [JSON.parse(JSON.stringify(feat))] } : emptyFC(),
         );
       }
-      const region = regionOwner(regionsRef.current, code);
+      const region = mapFeatureOwner(regionsRef.current, f);
       const nation = region ? nationsRef.current[region.ownerId] : undefined;
       hoverPopup
         .setLngLat(e.lngLat)
-        .setHTML(hoverHtml(p?.name ?? code, region, nation))
+        .setHTML(hoverHtml(p?.name ?? parent ?? subId, parent, region, nation))
         .addTo(map);
       map.getCanvas().style.cursor = 'pointer';
     };
@@ -345,17 +386,24 @@ export default function WorldMap({
     };
 
     // #7: a click does NOT open a popup — it switches the dossier to the region's
-    // owning nation. The owner is resolved from the stable ISO_A3 in
-    // `properties.regionId` via the RegionMap (never the repacked top-level
-    // `f.id`, #6). A region with no owner in the RegionMap (unowned territory)
-    // leaves the current dossier target unchanged — never a broken dossier.
+    // owning nation. For a sub-region, the owner is the **parent country's**
+    // owning nation, resolved from `properties.parent` (the ISO_A3) via the
+    // RegionMap (never the repacked top-level `f.id`, #6, and never the
+    // sub-region id). A sub-region whose parent country has no owner leaves the
+    // current dossier target unchanged — never a broken dossier.
     const onClick = (e: maplibregl.MapLayerMouseEvent) => {
       const f = e.features?.[0];
       if (!f) return;
-      const p = f.properties as { regionId?: string };
-      const code = typeof p?.regionId === 'string' ? p.regionId : '';
-      const region = regionOwner(regionsRef.current, code);
-      if (region?.ownerId) onFocusNationRef.current?.(region.ownerId);
+      const region = mapFeatureOwner(regionsRef.current, f);
+      if (!region?.ownerId) return;
+      // Carry the clicked sub-region's identity (own id/name + parent ISO_A3) so
+      // the dossier can show which region was selected.
+      const p = f.properties as { regionId?: string; parent?: string; name?: string };
+      const info = {
+        parent: typeof p?.parent === 'string' ? p.parent : undefined,
+        name: typeof p?.name === 'string' ? p.name : undefined,
+      };
+      onFocusNationRef.current?.(region.ownerId, info);
     };
 
     // Idempotent: (re)creates the sources + layers after any style (re)load and
@@ -363,16 +411,16 @@ export default function WorldMap({
     // automatically, so no setWorkerUrl is needed.)
     //
     // The three choropleth sources are created up front (empty until the base
-    // geo arrives) so the layer structure always exists; `paintCountries` then
-    // stamps ownership + colors onto the countries source. This makes it immune
+    // geo arrives) so the layer structure always exists; `paintRegions` then
+    // stamps ownership + colors onto the regions source. This makes it immune
     // to load-order races: if `ensureLayers` runs before the geo fetch
     // resolves, the data is applied the moment the fetch lands; if the geo
     // resolves first, `ensureLayers` uses it. No source is ever left stuck on
     // `emptyFC()` — `ensureLayers` is retried on every `styledata`, and the
     // regions effect re-paints whenever ownership changes.
     const ensureSources = () => {
-      if (!map.getSource(COUNTRIES_SOURCE)) {
-        map.addSource(COUNTRIES_SOURCE, { type: 'geojson', data: emptyFC() });
+      if (!map.getSource(REGIONS_SOURCE)) {
+        map.addSource(REGIONS_SOURCE, { type: 'geojson', data: emptyFC() });
       }
       if (!map.getSource(HOVER_SOURCE)) {
         map.addSource(HOVER_SOURCE, { type: 'geojson', data: emptyFC() });
@@ -382,10 +430,10 @@ export default function WorldMap({
       }
     };
 
-    // Stamp ownership + colors onto the countries source (no-op until geo loads).
-    const paintCountries = () => {
+    // Stamp ownership + colors onto the regions source (no-op until geo loads).
+    const paintRegions = () => {
       const geo = baseGeoRef.current;
-      const src = map.getSource(COUNTRIES_SOURCE) as GeoSource | undefined;
+      const src = map.getSource(REGIONS_SOURCE) as GeoSource | undefined;
       if (!geo || !src) return;
       src.setData(applyRegions(geo, regionsRef.current, playerRef.current));
     };
@@ -394,32 +442,39 @@ export default function WorldMap({
       if (cancelled) return;
       ensureSources();
       if (baseGeoRef.current) {
-        paintCountries();
+        paintRegions();
       } else {
         try {
           await loadGeo();
         } catch (err) {
-          console.error('failed to load countries geojson', err);
+          console.error('failed to load regions geojson', err);
         }
         if (cancelled) return;
-        paintCountries();
+        paintRegions();
       }
       if (!map.getLayer(FILL_LAYER)) {
         // The choropleth is the star: a high opacity so the vivid per-nation
         // colors read clearly even on the dark background / over the terrain.
+        // Every sub-region carries its parent country's owner color, so a whole
+        // country reads as one uniform fill — same as the old country map, but
+        // subdivided.
         map.addLayer({
           id: FILL_LAYER,
           type: 'fill',
-          source: COUNTRIES_SOURCE,
+          source: REGIONS_SOURCE,
           paint: { 'fill-color': ['get', 'fill'], 'fill-opacity': 1.0 },
         });
       }
       if (!map.getLayer(LINE_LAYER)) {
+        // Thin internal borders: every sub-region outline at a light weight so
+        // the subdivision reads within each country's uniform fill. The per-
+        // feature `stroke` alpha keeps owned borders a touch brighter than
+        // unowned ones (the v0.10 treatment, thinned for the finer grid).
         map.addLayer({
           id: LINE_LAYER,
           type: 'line',
-          source: COUNTRIES_SOURCE,
-          paint: { 'line-color': ['get', 'stroke'], 'line-width': 1.25, 'line-opacity': 0.95 },
+          source: REGIONS_SOURCE,
+          paint: { 'line-color': ['get', 'stroke'], 'line-width': 0.75, 'line-opacity': 0.95 },
         });
       }
       // NOTE: layers are added in bottom→top order (each appends on top). The
@@ -430,7 +485,7 @@ export default function WorldMap({
         map.addLayer({
           id: PLAYER_LINE,
           type: 'line',
-          source: COUNTRIES_SOURCE,
+          source: REGIONS_SOURCE,
           filter: ['==', ['get', 'isPlayer'], 1],
           paint: { 'line-color': '#f59e0b', 'line-width': 2.2, 'line-opacity': 0.95 },
         });
@@ -482,8 +537,10 @@ export default function WorldMap({
     };
   }, []);
 
-  // Re-color the choropleth whenever ownership changes, and flash any regions
-  // whose owner changed since the last update (transient, self-cleaning).
+  // Re-color the choropleth whenever ownership changes, and flash any country
+  // (all of its sub-regions) whose owner changed since the last update (a
+  // transient, self-cleaning pulse). The diff is over the ISO_A3-keyed RegionMap;
+  // `animateFlash` expands each changed country to every one of its sub-regions.
   useEffect(() => {
     const map = mapRef.current;
     const geo = baseGeoRef.current;
@@ -494,7 +551,7 @@ export default function WorldMap({
     if (Object.keys(cur).length > 0) primedRef.current = true;
 
     if (map && geo) {
-      const src = map.getSource(COUNTRIES_SOURCE) as GeoSource | undefined;
+      const src = map.getSource(REGIONS_SOURCE) as GeoSource | undefined;
       if (src) void src.setData(applyRegions(geo, cur, playerNationId));
     }