feat: Phase 1 — basemap fix & baseline comparison charts

- Bundle 50m Natural Earth shapefiles in Docker for offline basemaps
- Update map renderer to use 50m scale features (sharper coastlines)
- Add dual baseline overlay to charts: monthly band+line for rainfall,
horizontal reference band for 2-point indicators
- Add baseline range data to all 7 applicable indicators

109 tests passing.

Generated with [Claude Code](https://claude.ai/code)
via [Happy](https://happy.engineering)

Co-Authored-By: Claude <noreply@anthropic.com>
Co-Authored-By: Happy <yesreply@happy.engineering>

Dockerfile

@@ -16,6 +16,12 @@ RUN pip install --no-cache-dir --only-binary :all: \
     numpy scipy matplotlib geopandas shapely pyproj rioxarray xarray \
     && pip install --no-cache-dir --prefer-binary cartopy
 
+# Pre-download 50m Natural Earth data so Cartopy works offline in containers
+RUN python -c "\
+import cartopy.io.shapereader as shpreader; \
+[shpreader.natural_earth(resolution='50m', category=cat, name=name) \
+ for cat, name in [('physical','land'),('physical','ocean'),('physical','coastline'),('cultural','admin_0_boundary_lines_lake')]]"
+
 # Install remaining deps (lightweight, pure-python or small wheels)
 RUN pip install --no-cache-dir --prefer-binary \
     "fastapi>=0.110.0" \
@@ -43,6 +49,7 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
 # Copy installed packages from builder
 COPY --from=builder /usr/local/lib/python3.11/site-packages /usr/local/lib/python3.11/site-packages
 COPY --from=builder /usr/local/bin /usr/local/bin
+COPY --from=builder /root/.local/share/cartopy /root/.local/share/cartopy
 
 WORKDIR /app
 

app/indicators/cropland.py

@@ -45,7 +45,7 @@ class CroplandIndicator(BaseIndicator):
             else ConfidenceLevel.LOW
         )
 
-        chart_data = self._build_chart_data(baseline_mean, current_mean, time_range)
+        chart_data = self._build_chart_data(baseline_mean, current_mean, time_range, getattr(self, '_baseline_yearly_means', None))
 
         if abs_change <= 5:
             headline = f"Cropland vegetation stable ({current_mean:.0f}% cover, ±{abs_change:.0f}pp vs baseline)"
@@ -219,10 +219,16 @@ class CroplandIndicator(BaseIndicator):
 
         # Baseline: pool all years by month, then median per month
         baseline_pool: dict[int, list[float]] = defaultdict(list)
+        baseline_yearly_means: list[float] = []
         for yr in range(baseline_start_year, current_year):
             yr_monthly = await loop.run_in_executor(None, _query_growing_season, yr)
+            yr_medians = []
             for month, vals in yr_monthly.items():
                 baseline_pool[month].extend(vals)
+                if vals:
+                    yr_medians.append(float(np.median(vals)))
+            if yr_medians:
+                baseline_yearly_means.append(float(np.mean(yr_medians)))
 
         # Month-matched comparison: only growing-season months with data in BOTH periods
         baseline_medians = []
@@ -239,6 +245,7 @@ class CroplandIndicator(BaseIndicator):
             self._is_placeholder = True
             return self._synthetic()
 
+        self._baseline_yearly_means = baseline_yearly_means
         return (
             float(np.mean(baseline_medians)),
             float(np.mean(current_medians)),
@@ -271,10 +278,16 @@ class CroplandIndicator(BaseIndicator):
 
     @staticmethod
     def _build_chart_data(
-        baseline: float, current: float, time_range: TimeRange
+        baseline: float, current: float, time_range: TimeRange,
+        baseline_yearly_means: list[float] | None = None,
     ) -> dict[str, Any]:
-        return {
+        data: dict[str, Any] = {
             "dates": [str(time_range.start.year - 1), str(time_range.end.year)],
             "values": [round(baseline, 1), round(current, 1)],
             "label": "Vegetation cover (%)",
         }
+        if baseline_yearly_means and len(baseline_yearly_means) >= 2:
+            data["baseline_range_mean"] = round(float(np.mean(baseline_yearly_means)), 1)
+            data["baseline_range_min"] = round(float(min(baseline_yearly_means)), 1)
+            data["baseline_range_max"] = round(float(max(baseline_yearly_means)), 1)
+        return data

app/indicators/lst.py

@@ -45,7 +45,7 @@ class LSTIndicator(BaseIndicator):
         status = self._classify(abs(z_score))
         trend = self._compute_trend(z_score)
         confidence = ConfidenceLevel.MODERATE
-        chart_data = self._build_chart_data(current_temp, baseline_mean, baseline_std, time_range)
+        chart_data = self._build_chart_data(current_temp, baseline_mean, baseline_std, time_range, getattr(self, '_baseline_yearly_means', None))
 
         direction = "above" if z_score >= 0 else "below"
         abs_z = abs(z_score)
@@ -160,6 +160,7 @@ class LSTIndicator(BaseIndicator):
             self._is_placeholder = True
             return self._synthetic_lst()
 
+        self._baseline_yearly_means = baseline_yearly_means
         return (
             float(np.mean(current_vals)),
             float(np.mean(baseline_yearly_means)),
@@ -232,10 +233,16 @@ class LSTIndicator(BaseIndicator):
         baseline_mean: float,
         baseline_std: float,
         time_range: TimeRange,
+        baseline_yearly_means: list[float] | None = None,
     ) -> dict[str, Any]:
-        return {
+        result: dict[str, Any] = {
             "dates": ["baseline", str(time_range.end.year)],
             "values": [round(baseline_mean, 1), round(current, 1)],
             "baseline_std": round(baseline_std, 1),
             "label": "Daily max temperature (°C)",
         }
+        if baseline_yearly_means and len(baseline_yearly_means) >= 2:
+            result["baseline_range_mean"] = round(float(np.mean(baseline_yearly_means)), 1)
+            result["baseline_range_min"] = round(float(min(baseline_yearly_means)), 1)
+            result["baseline_range_max"] = round(float(max(baseline_yearly_means)), 1)
+        return result

app/indicators/nightlights.py

@@ -52,7 +52,7 @@ class NightlightsIndicator(BaseIndicator):
         status = self._classify(ratio)
         trend = self._compute_trend(ratio)
         confidence = self._compute_confidence(spatial)
-        chart_data = self._build_chart_data(current_radiance, baseline_radiance, time_range)
+        chart_data = self._build_chart_data(current_radiance, baseline_radiance, time_range, getattr(self, '_baseline_yearly_vals', None))
 
         if ratio >= 0.9:
             headline = f"Nighttime light intensity at {pct:.0f}% of baseline — normal activity"
@@ -213,6 +213,7 @@ class NightlightsIndicator(BaseIndicator):
             return None
 
         baseline_mean = float(np.mean(baseline_vals))
+        self._baseline_yearly_vals = baseline_vals
 
         # Build spatial data from whichever year we read
         spatial = None
@@ -338,6 +339,7 @@ class NightlightsIndicator(BaseIndicator):
             return None
 
         baseline_mean = float(np.mean(baseline_vals))
+        self._baseline_yearly_vals = baseline_vals
         # NASA source provides scalar means only (no 2D spatial data due to sinusoidal tiling)
         return current_mean, baseline_mean, None
 
@@ -379,10 +381,18 @@ class NightlightsIndicator(BaseIndicator):
 
     @staticmethod
     def _build_chart_data(
-        current: float, baseline: float, time_range: TimeRange
+        current: float,
+        baseline: float,
+        time_range: TimeRange,
+        baseline_yearly_vals: list[float] | None = None,
     ) -> dict[str, Any]:
-        return {
+        result: dict[str, Any] = {
             "dates": [str(time_range.start.year - 1), str(time_range.end.year)],
             "values": [round(baseline, 4), round(current, 4)],
             "label": "Mean VIIRS DNB radiance (nW·cm⁻²·sr⁻¹)",
         }
+        if baseline_yearly_vals and len(baseline_yearly_vals) >= 2:
+            result["baseline_range_mean"] = round(float(np.mean(baseline_yearly_vals)), 4)
+            result["baseline_range_min"] = round(float(min(baseline_yearly_vals)), 4)
+            result["baseline_range_max"] = round(float(max(baseline_yearly_vals)), 4)
+        return result

app/indicators/no2.py

@@ -39,7 +39,7 @@ class NO2Indicator(BaseIndicator):
         status = self._classify(abs(z_score))
         trend = self._compute_trend(z_score)
         confidence = ConfidenceLevel.MODERATE
-        chart_data = self._build_chart_data(current_no2, baseline_mean, baseline_std, time_range)
+        chart_data = self._build_chart_data(current_no2, baseline_mean, baseline_std, time_range, getattr(self, '_baseline_yearly_means', None))
 
         direction = "above" if z_score >= 0 else "below"
         abs_z = abs(z_score)
@@ -142,6 +142,7 @@ class NO2Indicator(BaseIndicator):
             self._is_placeholder = True
             return self._synthetic_no2()
 
+        self._baseline_yearly_means = baseline_yearly_means
         return (
             float(np.mean(current_vals)),
             float(np.mean(baseline_yearly_means)),
@@ -178,10 +179,16 @@ class NO2Indicator(BaseIndicator):
         baseline_mean: float,
         baseline_std: float,
         time_range: TimeRange,
+        baseline_yearly_means: list[float] | None = None,
     ) -> dict[str, Any]:
-        return {
+        result: dict[str, Any] = {
             "dates": ["baseline", str(time_range.end.year)],
             "values": [round(baseline_mean, 1), round(current, 1)],
             "baseline_std": round(baseline_std, 1),
             "label": "NO2 concentration (µg/m³)",
         }
+        if baseline_yearly_means and len(baseline_yearly_means) >= 2:
+            result["baseline_range_mean"] = round(float(np.mean(baseline_yearly_means)), 1)
+            result["baseline_range_min"] = round(float(min(baseline_yearly_means)), 1)
+            result["baseline_range_max"] = round(float(max(baseline_yearly_means)), 1)
+        return result

app/indicators/rainfall.py

@@ -52,7 +52,10 @@ class RainfallIndicator(BaseIndicator):
         status = self._classify(deviation_pct)
         trend = self._compute_trend(deviation_pct)
         confidence = ConfidenceLevel.HIGH if current_monthly else ConfidenceLevel.LOW
-        chart_data = self._build_chart_data(current_monthly, baseline_monthly)
+        chart_data = self._build_chart_data(
+            current_monthly, baseline_monthly,
+            getattr(self, '_baseline_per_year', None),
+        )
 
         if deviation_pct <= 10:
             headline = f"Rainfall within normal range — {deviation_pct:.1f}% below baseline"
@@ -147,6 +150,9 @@ class RainfallIndicator(BaseIndicator):
                     month_num = month_key.split("-")[1]
                     baseline_pool[month_num].append(mm)
 
+            # Store per-year monthly breakdown for baseline range computation
+            self._baseline_per_year = dict(baseline_pool)
+
             # Average each month across baseline years, keyed as current_year-MM
             baseline_monthly: dict[str, float] = {}
             for month_num, vals in baseline_pool.items():
@@ -255,12 +261,32 @@ class RainfallIndicator(BaseIndicator):
 
     @staticmethod
     def _build_chart_data(
-        current: dict[str, float], baseline: dict[str, float]
+        current: dict[str, float],
+        baseline: dict[str, float],
+        baseline_per_year: dict[str, list[float]] | None = None,
     ) -> dict[str, Any]:
         all_keys = sorted(set(list(current.keys()) + list(baseline.keys())))
-        return {
+        result: dict[str, Any] = {
             "dates": all_keys,
             "values": [current.get(k, baseline.get(k, 0.0)) for k in all_keys],
             "baseline_values": [baseline.get(k, 0.0) for k in all_keys],
             "label": "Monthly rainfall (mm)",
         }
+        if baseline_per_year:
+            b_mean, b_min, b_max = [], [], []
+            for k in all_keys:
+                month_num = k.split("-")[1]
+                year_vals = baseline_per_year.get(month_num, [])
+                if year_vals:
+                    b_mean.append(float(np.mean(year_vals)))
+                    b_min.append(float(min(year_vals)))
+                    b_max.append(float(max(year_vals)))
+                else:
+                    fallback = baseline.get(k, 0.0)
+                    b_mean.append(fallback)
+                    b_min.append(fallback)
+                    b_max.append(fallback)
+            result["baseline_mean"] = b_mean
+            result["baseline_min"] = b_min
+            result["baseline_max"] = b_max
+        return result

app/indicators/vegetation.py

@@ -40,7 +40,7 @@ class VegetationIndicator(BaseIndicator):
             else ConfidenceLevel.MODERATE if n_months >= 3
             else ConfidenceLevel.LOW
         )
-        chart_data = self._build_chart_data(baseline_mean, current_mean, time_range)
+        chart_data = self._build_chart_data(baseline_mean, current_mean, time_range, getattr(self, '_baseline_yearly_means', None))
 
         if abs_change <= 5:
             headline = f"Vegetation cover stable ({current_mean:.0f}% cover, ±{abs_change:.0f}pp vs baseline)"
@@ -200,10 +200,16 @@ class VegetationIndicator(BaseIndicator):
         current_monthly = await loop.run_in_executor(None, _query_monthly, current_year)
 
         baseline_pool: dict[int, list[float]] = defaultdict(list)
+        baseline_yearly_means: list[float] = []
         for yr in range(baseline_start_year, current_year):
             yr_monthly = await loop.run_in_executor(None, _query_monthly, yr)
+            yr_medians = []
             for month, vals in yr_monthly.items():
                 baseline_pool[month].extend(vals)
+                if vals:
+                    yr_medians.append(float(np.median(vals)))
+            if yr_medians:
+                baseline_yearly_means.append(float(np.mean(yr_medians)))
 
         baseline_medians = []
         current_medians = []
@@ -219,6 +225,7 @@ class VegetationIndicator(BaseIndicator):
             self._is_placeholder = True
             return self._synthetic()
 
+        self._baseline_yearly_means = baseline_yearly_means
         return (
             float(np.mean(baseline_medians)),
             float(np.mean(current_medians)),
@@ -250,10 +257,16 @@ class VegetationIndicator(BaseIndicator):
 
     @staticmethod
     def _build_chart_data(
-        baseline: float, current: float, time_range: TimeRange
+        baseline: float, current: float, time_range: TimeRange,
+        baseline_yearly_means: list[float] | None = None,
     ) -> dict[str, Any]:
-        return {
+        data: dict[str, Any] = {
             "dates": [str(time_range.start.year - 1), str(time_range.end.year)],
             "values": [round(baseline, 1), round(current, 1)],
             "label": "Vegetation cover (%)",
         }
+        if baseline_yearly_means and len(baseline_yearly_means) >= 2:
+            data["baseline_range_mean"] = round(float(np.mean(baseline_yearly_means)), 1)
+            data["baseline_range_min"] = round(float(min(baseline_yearly_means)), 1)
+            data["baseline_range_max"] = round(float(max(baseline_yearly_means)), 1)
+        return data

app/indicators/water.py

@@ -43,7 +43,7 @@ class WaterIndicator(BaseIndicator):
             else ConfidenceLevel.MODERATE if n_months >= 3
             else ConfidenceLevel.LOW
         )
-        chart_data = self._build_chart_data(baseline_mean, current_mean, time_range)
+        chart_data = self._build_chart_data(baseline_mean, current_mean, time_range, getattr(self, '_baseline_yearly_means', None))
 
         abs_ctx = f"({baseline_mean:.2f}% → {current_mean:.2f}% cover)"
         if change_pct < 10:
@@ -203,10 +203,16 @@ class WaterIndicator(BaseIndicator):
         current_monthly = await loop.run_in_executor(None, _query_monthly, current_year)
 
         baseline_pool: dict[int, list[float]] = defaultdict(list)
+        baseline_yearly_means: list[float] = []
         for yr in range(baseline_start_year, current_year):
             yr_monthly = await loop.run_in_executor(None, _query_monthly, yr)
+            yr_medians = []
             for month, vals in yr_monthly.items():
                 baseline_pool[month].extend(vals)
+                if vals:
+                    yr_medians.append(float(np.median(vals)))
+            if yr_medians:
+                baseline_yearly_means.append(float(np.mean(yr_medians)))
 
         baseline_medians = []
         current_medians = []
@@ -222,6 +228,7 @@ class WaterIndicator(BaseIndicator):
             self._is_placeholder = True
             return self._synthetic()
 
+        self._baseline_yearly_means = baseline_yearly_means
         return (
             float(np.mean(baseline_medians)),
             float(np.mean(current_medians)),
@@ -255,10 +262,18 @@ class WaterIndicator(BaseIndicator):
 
     @staticmethod
     def _build_chart_data(
-        baseline: float, current: float, time_range: TimeRange
+        baseline: float,
+        current: float,
+        time_range: TimeRange,
+        baseline_yearly_means: list[float] | None = None,
     ) -> dict[str, Any]:
-        return {
+        result: dict[str, Any] = {
             "dates": [str(time_range.start.year - 1), str(time_range.end.year)],
             "values": [round(baseline, 2), round(current, 2)],
             "label": "Water body coverage (%)",
         }
+        if baseline_yearly_means and len(baseline_yearly_means) >= 2:
+            result["baseline_range_mean"] = round(float(np.mean(baseline_yearly_means)), 2)
+            result["baseline_range_min"] = round(float(min(baseline_yearly_means)), 2)
+            result["baseline_range_max"] = round(float(max(baseline_yearly_means)), 2)
+        return result

app/outputs/charts.py

@@ -96,11 +96,42 @@ def render_timeseries_chart(
         if use_categorical:
             parsed_dates = list(range(len(dates)))
 
+        # Baseline overlay (rendered behind current data)
+        b_mean = chart_data.get("baseline_mean")
+        b_min = chart_data.get("baseline_min")
+        b_max = chart_data.get("baseline_max")
+
+        br_mean = chart_data.get("baseline_range_mean")
+        br_min = chart_data.get("baseline_range_min")
+        br_max = chart_data.get("baseline_range_max")
+
+        has_monthly_baseline = (
+            isinstance(b_mean, list)
+            and len(b_mean) == len(parsed_dates)
+            and len(b_mean) > 0
+        )
+        has_summary_baseline = br_mean is not None
+
+        if has_monthly_baseline:
+            ax.fill_between(
+                parsed_dates, b_min, b_max,
+                color="#D5D3CE", alpha=0.3, label="Baseline range", zorder=1,
+            )
+            ax.plot(
+                parsed_dates, b_mean,
+                color="#9B9B9B", linewidth=1.5, linestyle="--",
+                label="Baseline mean", zorder=2,
+            )
+        elif has_summary_baseline:
+            ax.axhspan(br_min, br_max, color="#D5D3CE", alpha=0.3, label="Baseline range", zorder=1)
+            ax.axhline(br_mean, color="#9B9B9B", linewidth=1.5, linestyle="--", label="Baseline mean", zorder=2)
+
         ax.plot(
             parsed_dates, values,
             color=status_color, linewidth=2, marker="o",
             markersize=5, markerfacecolor="white",
             markeredgecolor=status_color, markeredgewidth=1.5,
+            label="Current",
             zorder=3,
         )
         ax.fill_between(
@@ -108,6 +139,9 @@ def render_timeseries_chart(
             alpha=0.15, color=status_color,
         )
 
+        if has_monthly_baseline or has_summary_baseline:
+            ax.legend(fontsize=7, loc="upper left", framealpha=0.8)
+
         # X-axis formatting
         if use_categorical:
             ax.set_xticks(parsed_dates)

app/outputs/maps.py

@@ -54,9 +54,9 @@ def _base_ax(aoi: AOI):
              min_lat - pad_lat, max_lat + pad_lat],
             crs=ccrs.PlateCarree(),
         )
-        ax.add_feature(cfeature.LAND, facecolor="#E8E6E0", edgecolor="none")
-        ax.add_feature(cfeature.OCEAN, facecolor="#D4E6F1", edgecolor="none")
-        ax.add_feature(cfeature.BORDERS, linewidth=0.5, edgecolor=INK_MUTED)
+        ax.add_feature(cfeature.LAND.with_scale("50m"), facecolor="#E8E6E0", edgecolor="none")
+        ax.add_feature(cfeature.OCEAN.with_scale("50m"), facecolor="#D4E6F1", edgecolor="none")
+        ax.add_feature(cfeature.BORDERS.with_scale("50m"), linewidth=0.5, edgecolor=INK_MUTED)
         gl = ax.gridlines(draw_labels=True, linewidth=0.3, color=INK_MUTED, alpha=0.4, linestyle="--")
         gl.top_labels = False
         gl.right_labels = False

tests/test_charts.py

@@ -37,3 +37,66 @@ def test_render_timeseries_chart_handles_empty_data():
             y_label="Fire events",
         )
         assert os.path.exists(out_path)
+
+
+def test_render_timeseries_chart_with_monthly_baseline():
+    chart_data = {
+        "dates": ["2025-01", "2025-02", "2025-03", "2025-04", "2025-05", "2025-06"],
+        "values": [2, 3, 1, 5, 4, 7],
+        "baseline_mean": [3.0, 3.5, 2.5, 4.0, 4.5, 5.0],
+        "baseline_min": [1.0, 1.5, 0.5, 2.0, 2.5, 3.0],
+        "baseline_max": [5.0, 5.5, 4.5, 6.0, 6.5, 7.0],
+    }
+    with tempfile.TemporaryDirectory() as tmpdir:
+        out_path = os.path.join(tmpdir, "monthly_baseline_chart.png")
+        render_timeseries_chart(
+            chart_data=chart_data,
+            indicator_name="NDVI",
+            status=StatusLevel.GREEN,
+            trend=TrendDirection.IMPROVING,
+            output_path=out_path,
+            y_label="NDVI value",
+        )
+        assert os.path.exists(out_path)
+        assert os.path.getsize(out_path) > 1000
+
+
+def test_render_timeseries_chart_with_summary_baseline():
+    chart_data = {
+        "dates": ["2025-01", "2025-02", "2025-03", "2025-04", "2025-05", "2025-06"],
+        "values": [2, 3, 1, 5, 4, 7],
+        "baseline_range_mean": 4.0,
+        "baseline_range_min": 2.0,
+        "baseline_range_max": 6.0,
+    }
+    with tempfile.TemporaryDirectory() as tmpdir:
+        out_path = os.path.join(tmpdir, "summary_baseline_chart.png")
+        render_timeseries_chart(
+            chart_data=chart_data,
+            indicator_name="NDVI",
+            status=StatusLevel.AMBER,
+            trend=TrendDirection.STABLE,
+            output_path=out_path,
+            y_label="NDVI value",
+        )
+        assert os.path.exists(out_path)
+        assert os.path.getsize(out_path) > 1000
+
+
+def test_render_timeseries_chart_no_baseline_still_works():
+    chart_data = {
+        "dates": ["2025-01", "2025-02", "2025-03", "2025-04", "2025-05", "2025-06"],
+        "values": [2, 3, 1, 5, 4, 7],
+    }
+    with tempfile.TemporaryDirectory() as tmpdir:
+        out_path = os.path.join(tmpdir, "no_baseline_chart.png")
+        render_timeseries_chart(
+            chart_data=chart_data,
+            indicator_name="NDVI",
+            status=StatusLevel.RED,
+            trend=TrendDirection.DETERIORATING,
+            output_path=out_path,
+            y_label="NDVI value",
+        )
+        assert os.path.exists(out_path)
+        assert os.path.getsize(out_path) > 1000

tests/test_indicator_cropland.py

@@ -169,3 +169,48 @@ def test_classify_boundary():
     assert ind._classify(-5.1) == StatusLevel.AMBER
     assert ind._classify(-15) == StatusLevel.AMBER     # boundary
     assert ind._classify(-15.1) == StatusLevel.RED
+
+
+# ---------------------------------------------------------------------------
+# Baseline range in chart data
+# ---------------------------------------------------------------------------
+
+def test_build_chart_data_includes_baseline_range():
+    from app.indicators.cropland import CroplandIndicator
+    from datetime import date
+    from app.models import TimeRange
+    tr = TimeRange(start=date(2025, 1, 1), end=date(2025, 12, 31))
+    result = CroplandIndicator._build_chart_data(
+        baseline=40.0, current=42.0, time_range=tr,
+        baseline_yearly_means=[38.0, 40.0, 42.0],
+    )
+    assert "baseline_range_mean" in result
+    assert "baseline_range_min" in result
+    assert "baseline_range_max" in result
+    assert result["baseline_range_min"] == 38.0
+    assert result["baseline_range_max"] == 42.0
+
+
+def test_build_chart_data_no_baseline_range_when_absent():
+    from app.indicators.cropland import CroplandIndicator
+    from datetime import date
+    from app.models import TimeRange
+    tr = TimeRange(start=date(2025, 1, 1), end=date(2025, 12, 31))
+    result = CroplandIndicator._build_chart_data(
+        baseline=40.0, current=42.0, time_range=tr,
+    )
+    assert "baseline_range_mean" not in result
+    assert "baseline_range_min" not in result
+    assert "baseline_range_max" not in result
+
+
+def test_build_chart_data_no_baseline_range_when_single_year():
+    from app.indicators.cropland import CroplandIndicator
+    from datetime import date
+    from app.models import TimeRange
+    tr = TimeRange(start=date(2025, 1, 1), end=date(2025, 12, 31))
+    result = CroplandIndicator._build_chart_data(
+        baseline=40.0, current=42.0, time_range=tr,
+        baseline_yearly_means=[40.0],
+    )
+    assert "baseline_range_mean" not in result

tests/test_indicator_lst.py

@@ -0,0 +1,37 @@
+def test_build_chart_data_includes_baseline_range():
+    from app.indicators.lst import LSTIndicator
+    from datetime import date
+    from app.models import TimeRange
+    tr = TimeRange(start=date(2025, 1, 1), end=date(2025, 12, 31))
+    result = LSTIndicator._build_chart_data(
+        current=34.0, baseline_mean=32.0, baseline_std=2.5, time_range=tr,
+        baseline_yearly_means=[30.0, 31.5, 32.0, 33.0, 33.5],
+    )
+    assert "baseline_range_mean" in result
+    assert result["baseline_range_min"] == 30.0
+    assert result["baseline_range_max"] == 33.5
+
+
+def test_build_chart_data_no_baseline_range_when_omitted():
+    from app.indicators.lst import LSTIndicator
+    from datetime import date
+    from app.models import TimeRange
+    tr = TimeRange(start=date(2025, 1, 1), end=date(2025, 12, 31))
+    result = LSTIndicator._build_chart_data(
+        current=34.0, baseline_mean=32.0, baseline_std=2.5, time_range=tr,
+    )
+    assert "baseline_range_mean" not in result
+    assert "baseline_range_min" not in result
+    assert "baseline_range_max" not in result
+
+
+def test_build_chart_data_no_baseline_range_when_single_value():
+    from app.indicators.lst import LSTIndicator
+    from datetime import date
+    from app.models import TimeRange
+    tr = TimeRange(start=date(2025, 1, 1), end=date(2025, 12, 31))
+    result = LSTIndicator._build_chart_data(
+        current=34.0, baseline_mean=32.0, baseline_std=2.5, time_range=tr,
+        baseline_yearly_means=[32.0],
+    )
+    assert "baseline_range_mean" not in result

tests/test_indicator_nightlights.py

@@ -0,0 +1,51 @@
+def test_build_chart_data_includes_baseline_range():
+    from app.indicators.nightlights import NightlightsIndicator
+    from datetime import date
+    from app.models import TimeRange
+    tr = TimeRange(start=date(2025, 1, 1), end=date(2025, 12, 31))
+    result = NightlightsIndicator._build_chart_data(
+        current=2.8, baseline=3.2, time_range=tr,
+        baseline_yearly_vals=[3.0, 3.2, 3.4],
+    )
+    assert "baseline_range_mean" in result
+    assert result["baseline_range_min"] == 3.0
+    assert result["baseline_range_max"] == 3.4
+
+
+def test_build_chart_data_no_range_when_single_year():
+    from app.indicators.nightlights import NightlightsIndicator
+    from datetime import date
+    from app.models import TimeRange
+    tr = TimeRange(start=date(2025, 1, 1), end=date(2025, 12, 31))
+    result = NightlightsIndicator._build_chart_data(
+        current=2.8, baseline=3.2, time_range=tr,
+        baseline_yearly_vals=[3.2],
+    )
+    assert "baseline_range_mean" not in result
+
+
+def test_build_chart_data_no_range_when_none():
+    from app.indicators.nightlights import NightlightsIndicator
+    from datetime import date
+    from app.models import TimeRange
+    tr = TimeRange(start=date(2025, 1, 1), end=date(2025, 12, 31))
+    result = NightlightsIndicator._build_chart_data(
+        current=2.8, baseline=3.2, time_range=tr,
+    )
+    assert "baseline_range_mean" not in result
+    assert result["values"] == [3.2, 2.8]
+
+
+def test_build_chart_data_uses_four_decimal_places():
+    from app.indicators.nightlights import NightlightsIndicator
+    from datetime import date
+    from app.models import TimeRange
+    tr = TimeRange(start=date(2025, 1, 1), end=date(2025, 12, 31))
+    result = NightlightsIndicator._build_chart_data(
+        current=2.8, baseline=3.2, time_range=tr,
+        baseline_yearly_vals=[3.0, 3.2, 3.4],
+    )
+    # mean of [3.0, 3.2, 3.4] = 3.2, check rounding to 4 dp
+    assert result["baseline_range_mean"] == 3.2
+    assert result["baseline_range_min"] == 3.0
+    assert result["baseline_range_max"] == 3.4

tests/test_indicator_no2.py

@@ -0,0 +1,36 @@
+def test_build_chart_data_includes_baseline_range():
+    from app.indicators.no2 import NO2Indicator
+    from datetime import date
+    from app.models import TimeRange
+    tr = TimeRange(start=date(2025, 1, 1), end=date(2025, 12, 31))
+    result = NO2Indicator._build_chart_data(
+        current=16.5, baseline_mean=15.0, baseline_std=4.0, time_range=tr,
+        baseline_yearly_means=[12.0, 15.0, 18.0],
+    )
+    assert "baseline_range_mean" in result
+    assert result["baseline_range_min"] == 12.0
+    assert result["baseline_range_max"] == 18.0
+
+
+def test_build_chart_data_no_range_when_single_year():
+    from app.indicators.no2 import NO2Indicator
+    from datetime import date
+    from app.models import TimeRange
+    tr = TimeRange(start=date(2025, 1, 1), end=date(2025, 12, 31))
+    result = NO2Indicator._build_chart_data(
+        current=16.5, baseline_mean=15.0, baseline_std=4.0, time_range=tr,
+        baseline_yearly_means=[15.0],
+    )
+    assert "baseline_range_mean" not in result
+
+
+def test_build_chart_data_no_range_when_none():
+    from app.indicators.no2 import NO2Indicator
+    from datetime import date
+    from app.models import TimeRange
+    tr = TimeRange(start=date(2025, 1, 1), end=date(2025, 12, 31))
+    result = NO2Indicator._build_chart_data(
+        current=16.5, baseline_mean=15.0, baseline_std=4.0, time_range=tr,
+    )
+    assert "baseline_range_mean" not in result
+    assert result["baseline_std"] == 4.0

tests/test_indicator_rainfall.py

@@ -188,3 +188,25 @@ def test_classify_boundary():
     assert ind._classify(25.0) == StatusLevel.AMBER
     assert ind._classify(25.1) == StatusLevel.RED
     assert ind._classify(50.0) == StatusLevel.RED
+
+
+# ---------------------------------------------------------------------------
+# Baseline range arrays in chart data
+# ---------------------------------------------------------------------------
+
+def test_build_chart_data_includes_baseline_range():
+    from app.indicators.rainfall import RainfallIndicator
+    current = {"2025-01": 50.0, "2025-02": 60.0, "2025-03": 45.0}
+    baseline = {"2025-01": 55.0, "2025-02": 58.0, "2025-03": 50.0}
+    baseline_per_year = {
+        "01": [50.0, 55.0, 60.0],
+        "02": [52.0, 58.0, 64.0],
+        "03": [45.0, 50.0, 55.0],
+    }
+    result = RainfallIndicator._build_chart_data(current, baseline, baseline_per_year)
+    assert "baseline_mean" in result
+    assert "baseline_min" in result
+    assert "baseline_max" in result
+    assert len(result["baseline_mean"]) == len(result["dates"])
+    for i in range(len(result["dates"])):
+        assert result["baseline_min"][i] <= result["baseline_mean"][i] <= result["baseline_max"][i]

tests/test_indicator_vegetation.py

@@ -0,0 +1,68 @@
+"""Tests for the D2 Vegetation & Forest Cover indicator."""
+from __future__ import annotations
+
+from datetime import date
+
+import pytest
+
+from app.indicators.vegetation import VegetationIndicator
+from app.models import TimeRange
+
+
+# ---------------------------------------------------------------------------
+# Baseline range in chart data
+# ---------------------------------------------------------------------------
+
+def test_build_chart_data_includes_baseline_range():
+    tr = TimeRange(start=date(2025, 1, 1), end=date(2025, 12, 31))
+    result = VegetationIndicator._build_chart_data(
+        baseline=35.0, current=38.0, time_range=tr,
+        baseline_yearly_means=[32.0, 35.0, 38.0, 34.0, 36.0],
+    )
+    assert "baseline_range_mean" in result
+    assert "baseline_range_min" in result
+    assert "baseline_range_max" in result
+    assert result["baseline_range_min"] == 32.0
+    assert result["baseline_range_max"] == 38.0
+    assert result["baseline_range_min"] <= result["baseline_range_mean"] <= result["baseline_range_max"]
+
+
+def test_build_chart_data_no_baseline_range_when_absent():
+    tr = TimeRange(start=date(2025, 1, 1), end=date(2025, 12, 31))
+    result = VegetationIndicator._build_chart_data(
+        baseline=35.0, current=38.0, time_range=tr,
+    )
+    assert "baseline_range_mean" not in result
+    assert "baseline_range_min" not in result
+    assert "baseline_range_max" not in result
+
+
+def test_build_chart_data_no_baseline_range_when_single_year():
+    tr = TimeRange(start=date(2025, 1, 1), end=date(2025, 12, 31))
+    result = VegetationIndicator._build_chart_data(
+        baseline=35.0, current=38.0, time_range=tr,
+        baseline_yearly_means=[35.0],
+    )
+    assert "baseline_range_mean" not in result
+
+
+def test_build_chart_data_baseline_range_mean_is_rounded():
+    tr = TimeRange(start=date(2025, 1, 1), end=date(2025, 12, 31))
+    result = VegetationIndicator._build_chart_data(
+        baseline=35.0, current=38.0, time_range=tr,
+        baseline_yearly_means=[33.33, 36.67],
+    )
+    assert isinstance(result["baseline_range_mean"], float)
+    # Should be rounded to 1 decimal place
+    assert result["baseline_range_mean"] == round(result["baseline_range_mean"], 1)
+
+
+def test_build_chart_data_base_fields_always_present():
+    tr = TimeRange(start=date(2025, 1, 1), end=date(2025, 12, 31))
+    result = VegetationIndicator._build_chart_data(
+        baseline=35.0, current=38.0, time_range=tr,
+    )
+    assert "dates" in result
+    assert "values" in result
+    assert "label" in result
+    assert result["values"] == [35.0, 38.0]

tests/test_indicator_water.py

@@ -0,0 +1,37 @@
+def test_build_chart_data_includes_baseline_range():
+    from app.indicators.water import WaterIndicator
+    from datetime import date
+    from app.models import TimeRange
+    tr = TimeRange(start=date(2025, 1, 1), end=date(2025, 12, 31))
+    result = WaterIndicator._build_chart_data(
+        baseline=5.0, current=4.5, time_range=tr,
+        baseline_yearly_means=[4.5, 5.0, 5.5],
+    )
+    assert "baseline_range_mean" in result
+    assert result["baseline_range_min"] == 4.5
+    assert result["baseline_range_max"] == 5.5
+
+
+def test_build_chart_data_no_baseline_range_when_omitted():
+    from app.indicators.water import WaterIndicator
+    from datetime import date
+    from app.models import TimeRange
+    tr = TimeRange(start=date(2025, 1, 1), end=date(2025, 12, 31))
+    result = WaterIndicator._build_chart_data(
+        baseline=5.0, current=4.5, time_range=tr,
+    )
+    assert "baseline_range_mean" not in result
+    assert "baseline_range_min" not in result
+    assert "baseline_range_max" not in result
+
+
+def test_build_chart_data_no_baseline_range_when_single_value():
+    from app.indicators.water import WaterIndicator
+    from datetime import date
+    from app.models import TimeRange
+    tr = TimeRange(start=date(2025, 1, 1), end=date(2025, 12, 31))
+    result = WaterIndicator._build_chart_data(
+        baseline=5.0, current=4.5, time_range=tr,
+        baseline_yearly_means=[5.0],
+    )
+    assert "baseline_range_mean" not in result