fix(resilience): score all countries on first ranking request

[koala73]

Summary

• RESILIENCE_WARM_LIMIT = 24 capped warmMissingResilienceScores so only 24 countries were scored per ranking request
• On a cold cache (layer just enabled), the ranking API returned 100+ countries but only the first 24 had overallScore >= 0
• buildResilienceChoroplethMap filters overallScore < 0, so ~170 countries were invisible on the Resilience choropleth layer
• Fix: remove the cap; introduce a single shared createMemoizedSeedReader() passed to all country scorers so global Redis keys (conflict:ucdp-events:v1, sanctions:pressure:v1, etc.) are fetched once per ranking request instead of once per country

Test plan

• TypeScript typechecks pass (typecheck + typecheck:api)
• Biome lint passes
• All 3047 unit/data tests pass (includes resilience-handlers, resilience-ranking, resilience-scorers)
• Edge function bundle check passes
• Edge function isolation tests pass (153 tests)
• Markdown lint passes
• Version sync check passes
• Verify resilience choropleth layer shows all ~150+ indexed countries instead of ~20-25

[vercel]

The latest updates on your projects. Learn more about Vercel for GitHub.

1 Skipped Deployment

Project	Deployment	Actions	Updated (UTC)
worldmonitor	Ignored	Preview	Apr 5, 2026 3:38pm

[greptile-apps]

Greptile Summary

Fixes the Resilience choropleth showing only ~20–25 countries on a cold cache by removing the RESILIENCE_WARM_LIMIT = 24 cap from warmMissingResilienceScores. A shared createMemoizedSeedReader() is introduced and threaded through all country scorers so global Redis keys (conflict events, sanctions, unrest, etc.) are fetched once per ranking request regardless of how many countries need warming.

Confidence Score: 5/5

Safe to merge — the fix is targeted and correct with no P0/P1 issues found

The bug (.slice(0, 24)) is unambiguous, the fix directly addresses the root cause, RESILIENCE_WARM_LIMIT has zero other usages in the repo (confirmed by full-repo grep), and the shared memoized reader is race-free given JS's single-threaded event loop. The only finding is a harmless P2 double-memoization pattern that does not affect correctness.

No files require special attention

Important Files Changed

Filename	Overview
server/worldmonitor/resilience/v1/_shared.ts	Removes the 24-country cap in warmMissingResilienceScores and adds a shared memoized seed reader to deduplicate global Redis key fetches across all country scorers

Sequence Diagram

sequenceDiagram
    participant Handler as getResilienceRanking
    participant Warm as warmMissingResilienceScores
    participant Cache as ensureResilienceScoreCached
    participant Score as scoreAllDimensions
    participant Redis as Redis

    Handler->>Warm: warmMissingResilienceScores(missingCodes)
    Warm->>Warm: sharedReader = createMemoizedSeedReader()
    par For each missing country (all ~194)
        Warm->>Cache: ensureResilienceScoreCached(code, sharedReader)
        Cache->>Score: scoreAllDimensions(code, sharedReader)
        Score->>Redis: sharedReader("conflict:ucdp-events:v1") [1st country — FETCHES]
        Redis-->>Score: event data (cached in sharedReader)
        Score->>Redis: sharedReader("sanctions:pressure:v1") [1st country — FETCHES]
        Redis-->>Score: sanctions data (cached in sharedReader)
        Note over Score,Redis: 2nd..Nth country calls return cached promise — no extra Redis round-trips
        Score-->>Cache: dimension scores
        Cache->>Redis: SET resilience:score:XX (TTL 6h)
    end
    Warm-->>Handler: all settled (Promise.allSettled)

Loading

_{Reviews (1): Last reviewed commit: "fix(resilience): score all countries on ..." | Re-trigger Greptile}

[greptile-apps]

Double-memoization in scoreAllDimensions

sharedReader is already memoized (created by createMemoizedSeedReader()), but scoreAllDimensions in _dimension-scorers.ts unconditionally wraps it in another createMemoizedSeedReader(reader) call, producing a redundant per-country layer. The cross-country deduplication still works correctly — the outer sharedReader is what prevents repeated Redis fetches — but a new Map and closure are allocated for every country on each cold-cache ranking request. Worth cleaning up in a follow-up.