Six enhancements: recompute, markers, vendoring, tests, nerd stats, DS18B20

1. POST /api/recompute re-derives every compensated column from the untouched raw values, removing the step a calibration otherwise leaves through the history. Possible because temp_raw, cpu_temp and hum are never overwritten. Idempotent by construction and tested per row: 0 of 6051 rows change on a second run. 6069 rows in 0.25 s here, so a few seconds on the Pi. 2. Calibration now emits a 'discontinuity' event alongside the calibration log, so downstream views can find the boundary without parsing prose. 3. Vendored Tailwind, Chart.js, hammer, the zoom plugin, KaTeX with its 20 woff2 faces, and both Google fonts into ashvale/static, served by the station. 1.4 MB. Verified with every non-localhost request aborted in the browser: zero external requests, equations still render, fonts still load. The dashboard no longer needs internet. 4. 54 pytest cases over the pure numerics: physics closed forms and round trips, both compensator inverse properties, the Kalman covariance invariants and NIS consistency, the RLS trace cap under a deliberately unexcited regressor, conformal coverage, and the Zambretti ordering. Wired into CI after the seed step so the recompute cases have history. Writing them caught my own sign error on the conformal update: a hit raises alpha and narrows the band, which reads backwards until you follow it through. 5. Stats for Nerds gains the condition number of each head's covariance, a standardised innovation histogram per Kalman filter from a bounded 600 sample ring buffer, and a reliability strip of realised against nominal coverage. All arithmetic on data already in memory. 6. OutdoorProbe reads a DS18B20 over the kernel 1-Wire driver, no new dependency. Polled on its own slower cadence because the sensor blocks for up to 750 ms during conversion, which would eat a third of the 2 s sample budget. Rejects the 85000 power-on sentinel and out-of-range values, and reports age so a dead probe cannot masquerade as fresh.
2026-09-12 12:47:49 +00:00 · 2026-08-15 22:39:37 +01:00
parent 9d2e884b74
commit 98210bff8f
49 changed files with 1437 additions and 12 deletions
@@ -25,11 +25,13 @@ import asyncio
 import json
 import time
 from contextlib import asynccontextmanager
+from pathlib import Path
 from typing import Any, Dict, List, Optional

 import numpy as np
 from fastapi import FastAPI, HTTPException, Query, Request
 from fastapi.responses import HTMLResponse, StreamingResponse
+from fastapi.staticfiles import StaticFiles
 from pydantic import BaseModel, Field

 from .config import CONFIG
@@ -78,6 +80,14 @@ app = FastAPI(
    lifespan=lifespan,
 )

+# Vendored browser libraries. The dashboard used to pull Tailwind, Chart.js,
+# hammer, the zoom plugin, KaTeX and two Google fonts from CDNs at runtime,
+# which meant the Pi needed internet to render its own UI. Serving them from
+# disk costs about 1.4 MB and removes that dependency entirely.
+_STATIC = Path(__file__).resolve().parent / "static"
+if _STATIC.is_dir():
+    app.mount("/static", StaticFiles(directory=str(_STATIC)), name="static")
+

 def _st() -> Station:
    if station is None:
@@ -158,6 +168,7 @@ def telemetry() -> Dict:
        "cpu_offset": live.get("cpu_offset"),
        "compensator_k": live.get("compensator_k"),
        "hum_offset": live.get("hum_offset"),
+        "outdoor_c": live.get("outdoor_c"),
        "hum_psychrometric": live.get("hum_psychrometric"),
        "rates": {
            "temperature_c_per_h": live.get("temp_rate"),
@@ -361,6 +372,54 @@ def models() -> Dict:
    })


+def _innovation_histogram(st, bins: int = 21) -> Dict:
+    """Distribution of recent standardised Kalman innovations, per signal.
+
+    y/sqrt(S) should be standard normal when a filter is consistent. The single
+    NIS number says whether the spread is right on average; this says whether
+    the *shape* is right. Skew means systematic bias, excess kurtosis means the
+    filter is surprised more often than it admits.
+    """
+    out = {}
+    for name, buf in st.tracker.innovations.items():
+        z = np.array(buf, dtype=float)
+        z = z[np.isfinite(z)]
+        if z.size < 20:
+            out[name] = {"counts": [], "n": int(z.size)}
+            continue
+        clipped = np.clip(z, -4.0, 4.0)
+        counts, edges = np.histogram(clipped, bins=bins, range=(-4.0, 4.0))
+        out[name] = {
+            "counts": [int(c) for c in counts],
+            "edges": [round(float(e), 2) for e in edges],
+            "n": int(z.size),
+            "mean": round(float(np.mean(z)), 4),
+            "std": round(float(np.std(z)), 4),
+            "skew": round(float(np.mean(((z - z.mean()) / (z.std() or 1.0)) ** 3)), 3),
+            "kurtosis": round(float(np.mean(((z - z.mean()) / (z.std() or 1.0)) ** 4)), 3),
+        }
+    return out
+
+
+def _reliability_curve(st) -> Dict:
+    """Realised coverage against nominal, per horizon.
+
+    The scorecard reports one coverage number per head. This asks the sharper
+    question: is the *shape* right. Points below the diagonal mean the intervals
+    are lying, and by how much.
+    """
+    out = []
+    for (target, h), head in sorted(st.nowcast.heads.items()):
+        cov = head.conformal.empirical_coverage
+        if not np.isfinite(cov):
+            continue
+        out.append({"target": target, "horizon_s": h,
+                    "nominal": round(1.0 - head.conformal.alpha_target, 4),
+                    "realised": round(float(cov), 4),
+                    "n": int(head.n_scored)})
+    return {"points": out}
+
+
@app.get("/api/nerd")
 def nerd() -> Dict:
    """Every internal number the estimator and the learners are carrying.
@@ -393,10 +452,22 @@ def nerd() -> Dict:
        m = head.model
        P = np.asarray(m.P, dtype=float)
        theta = np.asarray(m.theta, dtype=float)
+        # Condition number of P says whether the 33 directions are being excited
+        # evenly. A huge value means some directions carry almost no information
+        # and the fit there is effectively arbitrary, which is the quiet failure
+        # the trace cap only partly protects against. eigvalsh because P is
+        # symmetric by construction.
+        try:
+            ev = np.linalg.eigvalsh(P)
+            lo, hi = float(np.min(ev)), float(np.max(ev))
+            cond = float(hi / lo) if lo > 1e-12 else float("inf")
+        except np.linalg.LinAlgError:
+            cond = float("nan")
        heads.append({
            "target": target, "horizon_s": h,
            "n_updates": int(m.n_updates),
            "trace_p": float(np.trace(P)),
+            "cond_p": cond,
            "theta_norm": float(np.linalg.norm(theta)),
            "rmse_ewma": float(np.sqrt(max(m.ewma_sq_error, 0.0))),
            "lam": float(m.lam), "p_max": float(m.p_max),
@@ -459,6 +530,8 @@ def nerd() -> Dict:
            "logloss_ewma": st.precip.ewma_logloss,
        },
        "monitoring": monitoring,
+        "innovation": _innovation_histogram(st),
+        "reliability": _reliability_curve(st),
    })


@@ -515,12 +588,25 @@ def calibrate_humidity(body: HumidityCalibrationIn) -> Dict:
    return _clean(result)


+@app.post("/api/recompute")
+def recompute() -> Dict:
+    """Re-derive every compensated column in the history from the raw values.
+
+    Run after a calibration to remove the step it leaves behind. Safe to repeat:
+    it always starts from the untouched raw columns, never from a previous
+    result, so it cannot compound.
+    """
+    result = _st().recompute_history()
+    return _clean(result)
+
+
@app.get("/api/status")
 def status() -> Dict:
    st = _st()
    return _clean({
        **st.status(),
        "display_frame": display.frame_name if display else None,
+        "outdoor_probe": (st.probe.status() if st.probe is not None else None),
        "events": st.store.recent_events(15),
    })

@@ -66,6 +66,11 @@ class SensorConfig:
    # HIGH and this correction would push it higher still. The error is an
    # additive element bias, not a thermal gradient. Leave off unless your own
    # reference says otherwise.
+    # Optional DS18B20 on the 1-Wire bus, outside the window. When present its
+    # reading is logged as outdoor_c and surfaced in the API. It does not feed
+    # the forecasting features yet: that needs history to train against.
+    outdoor_probe: bool = True
+    outdoor_probe_period_s: float = 20.0
    hum_psychrometric: bool = False
    hum_offset: float = 0.0
    hum_offset_min: float = -35.0
@@ -48,14 +48,15 @@ DASHBOARD_HTML = r"""
 <meta charset="UTF-8">
 <meta name="viewport" content="width=device-width, initial-scale=1.0">
 <title>Ashvale Station</title>
-<script src="https://cdn.tailwindcss.com"></script>
-<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/[email protected]/dist/katex.min.css">
-<script defer src="https://cdn.jsdelivr.net/npm/[email protected]/dist/katex.min.js"></script>
-<script src="https://cdn.jsdelivr.net/npm/[email protected]/dist/chart.umd.min.js"></script>
-<script src="https://cdn.jsdelivr.net/npm/[email protected]/hammer.min.js"></script>
-<script src="https://cdn.jsdelivr.net/npm/[email protected]/dist/chartjs-plugin-zoom.min.js"></script>
-<link rel="preconnect" href="https://fonts.googleapis.com">
-<link rel="stylesheet" href="https://fonts.googleapis.com/css2?family=Plus+Jakarta+Sans:wght@400;500;600;700;800&family=JetBrains+Mono:wght@400;500;600;700&display=swap">
+<!-- Served from the station, not a CDN, so the dashboard renders on a LAN with
+     no internet at all. See ashvale/static/. -->
+<script src="/static/tailwind.js"></script>
+<link rel="stylesheet" href="/static/katex.min.css">
+<script defer src="/static/katex.min.js"></script>
+<script src="/static/chart.umd.min.js"></script>
+<script src="/static/hammer.min.js"></script>
+<script src="/static/chartjs-plugin-zoom.min.js"></script>
+<link rel="stylesheet" href="/static/gfonts.css">
 <style>
  body { font-family:'Plus Jakarta Sans',sans-serif; }
  .font-mono { font-family:'JetBrains Mono',monospace; }
@@ -404,7 +405,7 @@ DASHBOARD_HTML = r"""
  <!-- Everything the estimator and the 18 learners are actually carrying, read
       straight off the live objects. No internal scrollers: the head bank is a
       fixed 18 rows and the attribution list is capped at what fits. -->
-  <section id="pane-nerd" class="pane h-full min-h-0 gap-3 grid-cols-1 lg:grid-cols-4 lg:grid-rows-[auto_1fr]">
+  <section id="pane-nerd" class="pane h-full min-h-0 gap-3 grid-cols-1 lg:grid-cols-4 lg:grid-rows-[auto_1fr_auto]">

    <div class="glass rounded-2xl p-3 lg:col-span-3">
      <div class="flex items-baseline justify-between mb-1.5">
@@ -450,6 +451,14 @@ DASHBOARD_HTML = r"""
        <div id="n-precip" class="font-mono text-[10px] space-y-0.5"></div>
      </div>
    </div>
+
+    <div class="glass rounded-2xl p-3 lg:col-span-4 shrink-0">
+      <div class="flex items-baseline justify-between mb-1.5">
+        <h2 class="text-sm font-bold">Reliability</h2>
+        <span class="text-[9px] font-mono text-slate-600 uppercase">realised coverage against the 90% nominal</span>
+      </div>
+      <div id="n-rel" class="grid grid-cols-3 sm:grid-cols-6 gap-x-3 gap-y-0.5 font-mono text-[9px]"></div>
+    </div>
  </section>

  <!-- ---------------- METHODS ---------------- -->
@@ -965,6 +974,15 @@ el('m-hcalrst').addEventListener('click', async () => {
 /* ---------------- STATS FOR NERDS ---------------- */
 let nerdDoc = null, nerdHead = null;
 const HL = (h) => h<3600 ? (h/60)+'m' : h<86400 ? (h/3600)+'h' : (h/86400)+'d';
+// A 21-bin histogram drawn as inline divs. No canvas: Chart.js instances cost
+// memory and this is three tiny plots that never need interaction.
+function histo(counts, colour, h) {
+  if (!counts || !counts.length) return '<div class="text-slate-700 text-[9px]">warming up</div>';
+  const mx = Math.max.apply(null, counts) || 1;
+  return '<div class="flex items-end gap-px" style="height:'+h+'px">'+
+    counts.map(c=>'<div style="flex:1;height:'+Math.max(1,(c/mx)*h)+'px;background:'+colour+
+      ';opacity:'+(0.35+0.65*(c/mx))+'"></div>').join('')+'</div>';
+}
 function bar(frac, colour) {
  const w = Math.max(0, Math.min(1, frac||0))*100;
  return '<div class="h-1 bg-slate-950 rounded-full overflow-hidden border border-slate-800/70">'+
@@ -975,6 +993,7 @@ async function loadNerd() {
  nerdDoc = d;

  const COL = {temperature:'#f59e0b', humidity:'#06b6d4', pressure:'#a78bfa'};
+  const iv = d.innovation||{};
  el('n-filters').innerHTML = Object.keys(d.filters||{}).map(k=>{
    const f = d.filters[k];
    // NIS is chi-square(1) distributed when consistent, so 1 is the target and
@@ -987,6 +1006,12 @@ async function loadNerd() {
      '<div class="flex justify-between text-slate-500 mt-1">&sigma; level<span class="text-slate-300">'+fmt(f.sigma_level,4)+'</span></div>'+
      '<div class="flex justify-between text-slate-500">P rate<span class="text-slate-300">'+f.p_rate.toExponential(2)+'</span></div>'+
      '<div class="flex justify-between text-slate-600">q / r<span>'+f.q.toExponential(1)+' / '+fmt(f.r,3)+'</span></div>'+
+      // innovation shape: should look standard normal if the filter is honest
+      '<div class="mt-1 pt-1 border-t border-slate-800/70">'+
+      histo((iv[k]||{}).counts, COL[k], 16)+
+      '<div class="flex justify-between text-slate-600 mt-0.5 text-[9px]">'+
+      '<span>innov &mu;='+fmt((iv[k]||{}).mean,2)+' &sigma;='+fmt((iv[k]||{}).std,2)+'</span>'+
+      '<span>skew '+fmt((iv[k]||{}).skew,2)+'</span></div></div>'+
      '</div>';
  }).join('');

@@ -1004,6 +1029,7 @@ async function loadNerd() {
  el('n-heads').innerHTML = heads.length ? '<table class="w-full font-mono text-[10px]">'+
    '<thead class="text-slate-600 uppercase text-[9px]"><tr class="border-b border-slate-800">'+
    '<th class="text-left py-0.5">head</th><th class="text-right">n</th><th class="text-right">tr P</th>'+
+    '<th class="text-right">cond</th>'+
    '<th class="text-right">|&theta;|</th><th class="text-right">rmse</th><th class="text-right">&alpha;</th>'+
    '<th class="text-right">cov</th><th class="text-right">&plusmn;</th><th class="text-right pl-2">p/c/l</th></tr></thead><tbody>'+
    heads.map(h=>{
@@ -1015,6 +1041,10 @@ async function loadNerd() {
        '<td class="py-0.5 text-slate-400">'+h.target.slice(0,4)+' <span class="text-slate-600">'+HL(h.horizon_s)+'</span></td>'+
        '<td class="text-right text-slate-600">'+h.n_updates+'</td>'+
        '<td class="text-right '+(sat>0.95?'text-rose-300':'text-slate-400')+'">'+h.trace_p.toExponential(1)+'</td>'+
+        // a huge condition number means some of the 33 directions are barely
+        // excited, so their weights are close to arbitrary
+        '<td class="text-right '+(h.cond_p>1e8?'text-amber-300':'text-slate-500')+'">'+
+        (isFinite(h.cond_p)?h.cond_p.toExponential(0):'inf')+'</td>'+
        '<td class="text-right text-slate-300">'+fmt(h.theta_norm,1)+'</td>'+
        '<td class="text-right text-slate-300">'+fmt(h.rmse_ewma,3)+'</td>'+
        '<td class="text-right text-indigo-300">'+fmt(h.alpha,3)+'</td>'+
@@ -1025,6 +1055,16 @@ async function loadNerd() {
    }).join('')+'</tbody></table>'
    : '<p class="text-[10px] text-slate-600 font-mono">No heads trained yet.</p>';

+  const rel = ((d.reliability||{}).points)||[];
+  el('n-rel').innerHTML = rel.length ? rel.map(pt=>{
+    const gap = pt.realised - pt.nominal;
+    const cls = Math.abs(gap)<0.03 ? '#34d399' : Math.abs(gap)<0.06 ? '#fbbf24' : '#fb7185';
+    return '<div class="flex items-center gap-1.5">'+
+      '<span class="text-slate-600" style="width:42%">'+pt.target.slice(0,4)+' '+HL(pt.horizon_s)+'</span>'+
+      '<span class="flex-1">'+bar(pt.realised, cls)+'</span>'+
+      '<span style="width:26%;text-align:right;color:'+cls+'">'+(pt.realised*100).toFixed(0)+'%</span></div>';
+  }).join('') : '<p class="text-slate-600">Nothing scored yet.</p>';
+
  const sel = el('n-head-sel');
  if (sel.options.length !== heads.length) {
    sel.innerHTML = heads.map((h,i)=>'<option value="'+i+'">'+h.target.slice(0,4)+' '+HL(h.horizon_s)+'</option>').join('');
@@ -30,6 +30,7 @@ Two jobs here, both familiar from soft-sensor work:

 from __future__ import annotations

+from collections import deque
 from dataclasses import dataclass, field
 from typing import Dict, Optional

@@ -54,6 +55,7 @@ class KalmanCV:
    P: np.ndarray = field(default_factory=lambda: np.eye(2) * 1e3)
    initialised: bool = False
    nis: float = 0.0  # normalised innovation squared, for health monitoring
+    innovation_z: float = 0.0

    def update(self, z: float, dt: float) -> tuple[float, float]:
        if not np.isfinite(z):
@@ -83,6 +85,11 @@ class KalmanCV:
        self.P = I_KH @ self.P @ I_KH.T + K @ K.T * self.r   # Joseph form, stays PSD

        self.nis = (y * y) / S
+        # y/sqrt(S) is the innovation in units of its own predicted spread, so it
+        # is comparable across signals and should look standard normal when the
+        # filter is consistent. Cheap to keep, and the only honest way to see
+        # skew or fat tails rather than inferring them from a single NIS value.
+        self.innovation_z = float(y / np.sqrt(S)) if S > 0 else 0.0
        return float(self.x[0]), float(self.x[1])

    @property
@@ -265,6 +272,12 @@ class SignalTracker:
            "pressure": KalmanCV(cfg.sensor.kalman_q_press, cfg.sensor.kalman_r_press),
        }
        self.last_ts: Optional[float] = None
+        # 600 samples per signal is 20 minutes at the live 2 s cadence, about
+        # 14 kB total. Bounded on purpose: this board has 512 MB and an
+        # unbounded diagnostic buffer is a slow memory leak with a nice name.
+        self.innovations: Dict[str, deque] = {
+            k: deque(maxlen=600) for k in self.filters
+        }

    def step(self, ts: float, temp_raw: float, hum: float, press: float,
             cpu_temp: float) -> Dict[str, float]:
@@ -278,6 +291,9 @@ class SignalTracker:
        t_lvl, t_rate = self.filters["temperature"].update(temp_c, dt)
        h_lvl, h_rate = self.filters["humidity"].update(hum_c, dt)
        p_lvl, p_rate = self.filters["pressure"].update(press, dt)
+        for name, kf in self.filters.items():
+            if kf.initialised:
+                self.innovations[name].append(kf.innovation_z)

        return {
            "temp_c": temp_c,
@@ -24,14 +24,18 @@ same code to the Pi unchanged.

 from __future__ import annotations

+import logging
 import math
 import time
+from pathlib import Path
 from typing import Any, Dict, Optional

 import numpy as np

 from .physics import dew_point, sea_level_pressure, solar_position

+log = logging.getLogger(__name__)
+
 TCS3400_ENABLE = 0x80
 TCS3400_ATIME = 0x81
 TCS3400_CONTROL = 0x8F
@@ -105,6 +109,95 @@ class SimulatedBoard:
        pass


+class OutdoorProbe:
+    """Optional DS18B20 on the 1-Wire bus, read through the kernel's w1 driver.
+
+    Why this matters more than any model change: indoors the station forecasts
+    a room. Pressure passes through walls, temperature and humidity do not. One
+    three-pound sensor on a metre of cable outside the window removes the single
+    largest caveat in the project.
+
+    No new dependency. The kernel exposes each probe as a text file under
+    /sys/bus/w1/devices/28-*/w1_slave, so this is a file read and two string
+    splits. Enable with `dtoverlay=w1-gpio` in /boot/firmware/config.txt.
+
+    How it fails: the DS18B20 takes up to 750 ms to convert, and the driver
+    blocks for that whole time. Reading it on the 2 s sample loop would eat a
+    third of the budget on a single-issue core, so it is polled on its own
+    slower cadence and the last good value is reused in between. A probe that
+    goes missing (cable pulled, bad CRC) returns None rather than a stale value
+    forever: `age_s` lets the caller decide when to stop trusting it.
+    """
+
+    ROOT = "/sys/bus/w1/devices"
+
+    def __init__(self, min_period_s: float = 20.0) -> None:
+        self.min_period_s = float(min_period_s)
+        self.device: Optional[str] = None
+        self.available = False
+        self.last_value: Optional[float] = None
+        self.last_ts: Optional[float] = None
+        self.errors = 0
+        self._discover()
+
+    def _discover(self) -> None:
+        try:
+            root = Path(self.ROOT)
+            if not root.is_dir():
+                return
+            probes = sorted(p for p in root.glob("28-*") if (p / "w1_slave").exists())
+            if probes:
+                self.device = str(probes[0] / "w1_slave")
+                self.available = True
+                log.info("outdoor probe found at %s", self.device)
+        except OSError as exc:
+            log.warning("1-wire scan failed: %r", exc)
+
+    def read(self) -> Optional[float]:
+        """Celsius, or None. Cached between polls so the sample loop never blocks."""
+        if not self.available or self.device is None:
+            return None
+        now = time.time()
+        if self.last_ts is not None and (now - self.last_ts) < self.min_period_s:
+            return self.last_value
+        try:
+            with open(self.device, "r") as fh:
+                text = fh.read()
+        except OSError as exc:
+            self.errors += 1
+            log.warning("outdoor probe read failed: %r", exc)
+            return self.last_value
+        # Two lines: the first ends in YES only when the CRC checked out.
+        if "YES" not in text.split("\n")[0]:
+            self.errors += 1
+            return self.last_value
+        marker = text.find("t=")
+        if marker < 0:
+            self.errors += 1
+            return self.last_value
+        try:
+            milli = int(text[marker + 2:].strip())
+        except ValueError:
+            self.errors += 1
+            return self.last_value
+        # 85000 is the DS18B20 power-on default and means "never converted".
+        if milli == 85000:
+            self.errors += 1
+            return self.last_value
+        value = milli / 1000.0
+        if not (-55.0 <= value <= 125.0):
+            self.errors += 1
+            return self.last_value
+        self.last_value = value
+        self.last_ts = now
+        return value
+
+    def status(self) -> Dict[str, Any]:
+        age = None if self.last_ts is None else round(time.time() - self.last_ts, 1)
+        return {"available": self.available, "device": self.device,
+                "value_c": self.last_value, "age_s": age, "errors": self.errors}
+
+
 class SenseBoard:
    """Real hardware wrapper. Attribute `available` tells you which world
    you are in without try/except at every call site."""
@@ -0,0 +1,396 @@
+/* cyrillic-ext */
+@font-face {
+  font-family: 'JetBrains Mono';
+  font-style: normal;
+  font-weight: 400;
+  font-display: swap;
+  src: url(fonts/gf-tDbv2o-flEEny0FZhsfKu5WU4zr3E_BX0PnT8RD8yKwBNntkaToggR7BYRbKPx3cwgknk-6nFg.woff2) format('woff2');
+  unicode-range: U+0460-052F, U+1C80-1C8A, U+20B4, U+2DE0-2DFF, U+A640-A69F, U+FE2E-FE2F;
+}
+/* cyrillic */
+@font-face {
+  font-family: 'JetBrains Mono';
+  font-style: normal;
+  font-weight: 400;
+  font-display: swap;
+  src: url(fonts/gf-tDbv2o-flEEny0FZhsfKu5WU4zr3E_BX0PnT8RD8yKwBNntkaToggR7BYRbKPxTcwgknk-6nFg.woff2) format('woff2');
+  unicode-range: U+0301, U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
+}
+/* greek */
+@font-face {
+  font-family: 'JetBrains Mono';
+  font-style: normal;
+  font-weight: 400;
+  font-display: swap;
+  src: url(fonts/gf-tDbv2o-flEEny0FZhsfKu5WU4zr3E_BX0PnT8RD8yKwBNntkaToggR7BYRbKPxPcwgknk-6nFg.woff2) format('woff2');
+  unicode-range: U+0370-0377, U+037A-037F, U+0384-038A, U+038C, U+038E-03A1, U+03A3-03FF;
+}
+/* vietnamese */
+@font-face {
+  font-family: 'JetBrains Mono';
+  font-style: normal;
+  font-weight: 400;
+  font-display: swap;
+  src: url(fonts/gf-tDbv2o-flEEny0FZhsfKu5WU4zr3E_BX0PnT8RD8yKwBNntkaToggR7BYRbKPx_cwgknk-6nFg.woff2) format('woff2');
+  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;
+}
+/* latin-ext */
+@font-face {
+  font-family: 'JetBrains Mono';
+  font-style: normal;
+  font-weight: 400;
+  font-display: swap;
+  src: url(fonts/gf-tDbv2o-flEEny0FZhsfKu5WU4zr3E_BX0PnT8RD8yKwBNntkaToggR7BYRbKPx7cwgknk-6nFg.woff2) format('woff2');
+  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;
+}
+/* latin */
+@font-face {
+  font-family: 'JetBrains Mono';
+  font-style: normal;
+  font-weight: 400;
+  font-display: swap;
+  src: url(fonts/gf-tDbv2o-flEEny0FZhsfKu5WU4zr3E_BX0PnT8RD8yKwBNntkaToggR7BYRbKPxDcwgknk-4.woff2) format('woff2');
+  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
+}
+/* cyrillic-ext */
+@font-face {
+  font-family: 'JetBrains Mono';
+  font-style: normal;
+  font-weight: 500;
+  font-display: swap;
+  src: url(fonts/gf-tDbv2o-flEEny0FZhsfKu5WU4zr3E_BX0PnT8RD8yKwBNntkaToggR7BYRbKPx3cwgknk-6nFg.woff2) format('woff2');
+  unicode-range: U+0460-052F, U+1C80-1C8A, U+20B4, U+2DE0-2DFF, U+A640-A69F, U+FE2E-FE2F;
+}
+/* cyrillic */
+@font-face {
+  font-family: 'JetBrains Mono';
+  font-style: normal;
+  font-weight: 500;
+  font-display: swap;
+  src: url(fonts/gf-tDbv2o-flEEny0FZhsfKu5WU4zr3E_BX0PnT8RD8yKwBNntkaToggR7BYRbKPxTcwgknk-6nFg.woff2) format('woff2');
+  unicode-range: U+0301, U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
+}
+/* greek */
+@font-face {
+  font-family: 'JetBrains Mono';
+  font-style: normal;
+  font-weight: 500;
+  font-display: swap;
+  src: url(fonts/gf-tDbv2o-flEEny0FZhsfKu5WU4zr3E_BX0PnT8RD8yKwBNntkaToggR7BYRbKPxPcwgknk-6nFg.woff2) format('woff2');
+  unicode-range: U+0370-0377, U+037A-037F, U+0384-038A, U+038C, U+038E-03A1, U+03A3-03FF;
+}
+/* vietnamese */
+@font-face {
+  font-family: 'JetBrains Mono';
+  font-style: normal;
+  font-weight: 500;
+  font-display: swap;
+  src: url(fonts/gf-tDbv2o-flEEny0FZhsfKu5WU4zr3E_BX0PnT8RD8yKwBNntkaToggR7BYRbKPx_cwgknk-6nFg.woff2) format('woff2');
+  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;
+}
+/* latin-ext */
+@font-face {
+  font-family: 'JetBrains Mono';
+  font-style: normal;
+  font-weight: 500;
+  font-display: swap;
+  src: url(fonts/gf-tDbv2o-flEEny0FZhsfKu5WU4zr3E_BX0PnT8RD8yKwBNntkaToggR7BYRbKPx7cwgknk-6nFg.woff2) format('woff2');
+  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;
+}
+/* latin */
+@font-face {
+  font-family: 'JetBrains Mono';
+  font-style: normal;
+  font-weight: 500;
+  font-display: swap;
+  src: url(fonts/gf-tDbv2o-flEEny0FZhsfKu5WU4zr3E_BX0PnT8RD8yKwBNntkaToggR7BYRbKPxDcwgknk-4.woff2) format('woff2');
+  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
+}
+/* cyrillic-ext */
+@font-face {
+  font-family: 'JetBrains Mono';
+  font-style: normal;
+  font-weight: 600;
+  font-display: swap;
+  src: url(fonts/gf-tDbv2o-flEEny0FZhsfKu5WU4zr3E_BX0PnT8RD8yKwBNntkaToggR7BYRbKPx3cwgknk-6nFg.woff2) format('woff2');
+  unicode-range: U+0460-052F, U+1C80-1C8A, U+20B4, U+2DE0-2DFF, U+A640-A69F, U+FE2E-FE2F;
+}
+/* cyrillic */
+@font-face {
+  font-family: 'JetBrains Mono';
+  font-style: normal;
+  font-weight: 600;
+  font-display: swap;
+  src: url(fonts/gf-tDbv2o-flEEny0FZhsfKu5WU4zr3E_BX0PnT8RD8yKwBNntkaToggR7BYRbKPxTcwgknk-6nFg.woff2) format('woff2');
+  unicode-range: U+0301, U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
+}
+/* greek */
+@font-face {
+  font-family: 'JetBrains Mono';
+  font-style: normal;
+  font-weight: 600;
+  font-display: swap;
+  src: url(fonts/gf-tDbv2o-flEEny0FZhsfKu5WU4zr3E_BX0PnT8RD8yKwBNntkaToggR7BYRbKPxPcwgknk-6nFg.woff2) format('woff2');
+  unicode-range: U+0370-0377, U+037A-037F, U+0384-038A, U+038C, U+038E-03A1, U+03A3-03FF;
+}
+/* vietnamese */
+@font-face {
+  font-family: 'JetBrains Mono';
+  font-style: normal;
+  font-weight: 600;
+  font-display: swap;
+  src: url(fonts/gf-tDbv2o-flEEny0FZhsfKu5WU4zr3E_BX0PnT8RD8yKwBNntkaToggR7BYRbKPx_cwgknk-6nFg.woff2) format('woff2');
+  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;
+}
+/* latin-ext */
+@font-face {
+  font-family: 'JetBrains Mono';
+  font-style: normal;
+  font-weight: 600;
+  font-display: swap;
+  src: url(fonts/gf-tDbv2o-flEEny0FZhsfKu5WU4zr3E_BX0PnT8RD8yKwBNntkaToggR7BYRbKPx7cwgknk-6nFg.woff2) format('woff2');
+  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;
+}
+/* latin */
+@font-face {
+  font-family: 'JetBrains Mono';
+  font-style: normal;
+  font-weight: 600;
+  font-display: swap;
+  src: url(fonts/gf-tDbv2o-flEEny0FZhsfKu5WU4zr3E_BX0PnT8RD8yKwBNntkaToggR7BYRbKPxDcwgknk-4.woff2) format('woff2');
+  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
+}
+/* cyrillic-ext */
+@font-face {
+  font-family: 'JetBrains Mono';
+  font-style: normal;
+  font-weight: 700;
+  font-display: swap;
+  src: url(fonts/gf-tDbv2o-flEEny0FZhsfKu5WU4zr3E_BX0PnT8RD8yKwBNntkaToggR7BYRbKPx3cwgknk-6nFg.woff2) format('woff2');
+  unicode-range: U+0460-052F, U+1C80-1C8A, U+20B4, U+2DE0-2DFF, U+A640-A69F, U+FE2E-FE2F;
+}
+/* cyrillic */
+@font-face {
+  font-family: 'JetBrains Mono';
+  font-style: normal;
+  font-weight: 700;
+  font-display: swap;
+  src: url(fonts/gf-tDbv2o-flEEny0FZhsfKu5WU4zr3E_BX0PnT8RD8yKwBNntkaToggR7BYRbKPxTcwgknk-6nFg.woff2) format('woff2');
+  unicode-range: U+0301, U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
+}
+/* greek */
+@font-face {
+  font-family: 'JetBrains Mono';
+  font-style: normal;
+  font-weight: 700;
+  font-display: swap;
+  src: url(fonts/gf-tDbv2o-flEEny0FZhsfKu5WU4zr3E_BX0PnT8RD8yKwBNntkaToggR7BYRbKPxPcwgknk-6nFg.woff2) format('woff2');
+  unicode-range: U+0370-0377, U+037A-037F, U+0384-038A, U+038C, U+038E-03A1, U+03A3-03FF;
+}
+/* vietnamese */
+@font-face {
+  font-family: 'JetBrains Mono';
+  font-style: normal;
+  font-weight: 700;
+  font-display: swap;
+  src: url(fonts/gf-tDbv2o-flEEny0FZhsfKu5WU4zr3E_BX0PnT8RD8yKwBNntkaToggR7BYRbKPx_cwgknk-6nFg.woff2) format('woff2');
+  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;
+}
+/* latin-ext */
+@font-face {
+  font-family: 'JetBrains Mono';
+  font-style: normal;
+  font-weight: 700;
+  font-display: swap;
+  src: url(fonts/gf-tDbv2o-flEEny0FZhsfKu5WU4zr3E_BX0PnT8RD8yKwBNntkaToggR7BYRbKPx7cwgknk-6nFg.woff2) format('woff2');
+  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;
+}
+/* latin */
+@font-face {
+  font-family: 'JetBrains Mono';
+  font-style: normal;
+  font-weight: 700;
+  font-display: swap;
+  src: url(fonts/gf-tDbv2o-flEEny0FZhsfKu5WU4zr3E_BX0PnT8RD8yKwBNntkaToggR7BYRbKPxDcwgknk-4.woff2) format('woff2');
+  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
+}
+/* cyrillic-ext */
+@font-face {
+  font-family: 'Plus Jakarta Sans';
+  font-style: normal;
+  font-weight: 400;
+  font-display: swap;
+  src: url(fonts/gf-LDIoaomQNQcsA88c7O9yZ4KMCoOg4Ko70yygg_vbd-E.woff2) format('woff2');
+  unicode-range: U+0460-052F, U+1C80-1C8A, U+20B4, U+2DE0-2DFF, U+A640-A69F, U+FE2E-FE2F;
+}
+/* vietnamese */
+@font-face {
+  font-family: 'Plus Jakarta Sans';
+  font-style: normal;
+  font-weight: 400;
+  font-display: swap;
+  src: url(fonts/gf-LDIoaomQNQcsA88c7O9yZ4KMCoOg4Ko50yygg_vbd-E.woff2) format('woff2');
+  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;
+}
+/* latin-ext */
+@font-face {
+  font-family: 'Plus Jakarta Sans';
+  font-style: normal;
+  font-weight: 400;
+  font-display: swap;
+  src: url(fonts/gf-LDIoaomQNQcsA88c7O9yZ4KMCoOg4Ko40yygg_vbd-E.woff2) format('woff2');
+  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;
+}
+/* latin */
+@font-face {
+  font-family: 'Plus Jakarta Sans';
+  font-style: normal;
+  font-weight: 400;
+  font-display: swap;
+  src: url(fonts/gf-LDIoaomQNQcsA88c7O9yZ4KMCoOg4Ko20yygg_vb.woff2) format('woff2');
+  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
+}
+/* cyrillic-ext */
+@font-face {
+  font-family: 'Plus Jakarta Sans';
+  font-style: normal;
+  font-weight: 500;
+  font-display: swap;
+  src: url(fonts/gf-LDIoaomQNQcsA88c7O9yZ4KMCoOg4Ko70yygg_vbd-E.woff2) format('woff2');
+  unicode-range: U+0460-052F, U+1C80-1C8A, U+20B4, U+2DE0-2DFF, U+A640-A69F, U+FE2E-FE2F;
+}
+/* vietnamese */
+@font-face {
+  font-family: 'Plus Jakarta Sans';
+  font-style: normal;
+  font-weight: 500;
+  font-display: swap;
+  src: url(fonts/gf-LDIoaomQNQcsA88c7O9yZ4KMCoOg4Ko50yygg_vbd-E.woff2) format('woff2');
+  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;
+}
+/* latin-ext */
+@font-face {
+  font-family: 'Plus Jakarta Sans';
+  font-style: normal;
+  font-weight: 500;
+  font-display: swap;
+  src: url(fonts/gf-LDIoaomQNQcsA88c7O9yZ4KMCoOg4Ko40yygg_vbd-E.woff2) format('woff2');
+  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;
+}
+/* latin */
+@font-face {
+  font-family: 'Plus Jakarta Sans';
+  font-style: normal;
+  font-weight: 500;
+  font-display: swap;
+  src: url(fonts/gf-LDIoaomQNQcsA88c7O9yZ4KMCoOg4Ko20yygg_vb.woff2) format('woff2');
+  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
+}
+/* cyrillic-ext */
+@font-face {
+  font-family: 'Plus Jakarta Sans';
+  font-style: normal;
+  font-weight: 600;
+  font-display: swap;
+  src: url(fonts/gf-LDIoaomQNQcsA88c7O9yZ4KMCoOg4Ko70yygg_vbd-E.woff2) format('woff2');
+  unicode-range: U+0460-052F, U+1C80-1C8A, U+20B4, U+2DE0-2DFF, U+A640-A69F, U+FE2E-FE2F;
+}
+/* vietnamese */
+@font-face {
+  font-family: 'Plus Jakarta Sans';
+  font-style: normal;
+  font-weight: 600;
+  font-display: swap;
+  src: url(fonts/gf-LDIoaomQNQcsA88c7O9yZ4KMCoOg4Ko50yygg_vbd-E.woff2) format('woff2');
+  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;
+}
+/* latin-ext */
+@font-face {
+  font-family: 'Plus Jakarta Sans';
+  font-style: normal;
+  font-weight: 600;
+  font-display: swap;
+  src: url(fonts/gf-LDIoaomQNQcsA88c7O9yZ4KMCoOg4Ko40yygg_vbd-E.woff2) format('woff2');
+  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;
+}
+/* latin */
+@font-face {
+  font-family: 'Plus Jakarta Sans';
+  font-style: normal;
+  font-weight: 600;
+  font-display: swap;
+  src: url(fonts/gf-LDIoaomQNQcsA88c7O9yZ4KMCoOg4Ko20yygg_vb.woff2) format('woff2');
+  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
+}
+/* cyrillic-ext */
+@font-face {
+  font-family: 'Plus Jakarta Sans';
+  font-style: normal;
+  font-weight: 700;
+  font-display: swap;
+  src: url(fonts/gf-LDIoaomQNQcsA88c7O9yZ4KMCoOg4Ko70yygg_vbd-E.woff2) format('woff2');
+  unicode-range: U+0460-052F, U+1C80-1C8A, U+20B4, U+2DE0-2DFF, U+A640-A69F, U+FE2E-FE2F;
+}
+/* vietnamese */
+@font-face {
+  font-family: 'Plus Jakarta Sans';
+  font-style: normal;
+  font-weight: 700;
+  font-display: swap;
+  src: url(fonts/gf-LDIoaomQNQcsA88c7O9yZ4KMCoOg4Ko50yygg_vbd-E.woff2) format('woff2');
+  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;
+}
+/* latin-ext */
+@font-face {
+  font-family: 'Plus Jakarta Sans';
+  font-style: normal;
+  font-weight: 700;
+  font-display: swap;
+  src: url(fonts/gf-LDIoaomQNQcsA88c7O9yZ4KMCoOg4Ko40yygg_vbd-E.woff2) format('woff2');
+  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;
+}
+/* latin */
+@font-face {
+  font-family: 'Plus Jakarta Sans';
+  font-style: normal;
+  font-weight: 700;
+  font-display: swap;
+  src: url(fonts/gf-LDIoaomQNQcsA88c7O9yZ4KMCoOg4Ko20yygg_vb.woff2) format('woff2');
+  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
+}
+/* cyrillic-ext */
+@font-face {
+  font-family: 'Plus Jakarta Sans';
+  font-style: normal;
+  font-weight: 800;
+  font-display: swap;
+  src: url(fonts/gf-LDIoaomQNQcsA88c7O9yZ4KMCoOg4Ko70yygg_vbd-E.woff2) format('woff2');
+  unicode-range: U+0460-052F, U+1C80-1C8A, U+20B4, U+2DE0-2DFF, U+A640-A69F, U+FE2E-FE2F;
+}
+/* vietnamese */
+@font-face {
+  font-family: 'Plus Jakarta Sans';
+  font-style: normal;
+  font-weight: 800;
+  font-display: swap;
+  src: url(fonts/gf-LDIoaomQNQcsA88c7O9yZ4KMCoOg4Ko50yygg_vbd-E.woff2) format('woff2');
+  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;
+}
+/* latin-ext */
+@font-face {
+  font-family: 'Plus Jakarta Sans';
+  font-style: normal;
+  font-weight: 800;
+  font-display: swap;
+  src: url(fonts/gf-LDIoaomQNQcsA88c7O9yZ4KMCoOg4Ko40yygg_vbd-E.woff2) format('woff2');
+  unicode-range: U+0100-02BA, U+02BD-02C5, U+02C7-02CC, U+02CE-02D7, U+02DD-02FF, U+0304, U+0308, U+0329, U+1D00-1DBF, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;
+}
+/* latin */
+@font-face {
+  font-family: 'Plus Jakarta Sans';
+  font-style: normal;
+  font-weight: 800;
+  font-display: swap;
+  src: url(fonts/gf-LDIoaomQNQcsA88c7O9yZ4KMCoOg4Ko20yygg_vb.woff2) format('woff2');
+  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
+}
@@ -42,13 +42,13 @@ import numpy as np

 from . import physics
 from .config import Config
-from .estimation import SignalTracker
+from .estimation import KalmanCV, SignalTracker
 from .features import build_features
 from .models.anomaly import AnomalyMonitor
 from .models.climatology import HarmonicClimatology
 from .models.nowcast import NowcastEnsemble
 from .models.precip import PrecipitationModel, proxy_wet_label, zambretti
-from .sensors import SenseBoard, enrich
+from .sensors import OutdoorProbe, SenseBoard, enrich
 from .storage import Store, resample

 STATE_VERSION = 1
@@ -65,6 +65,9 @@ class Station:
            latitude=cfg.site.latitude,
            longitude=cfg.site.longitude,
        )
+        # Optional and entirely absent on a board without one wired up.
+        self.probe = (OutdoorProbe(cfg.sensor.outdoor_probe_period_s)
+                      if cfg.sensor.outdoor_probe else None)
        self.tracker = SignalTracker(cfg)
        self.nowcast = NowcastEnsemble(cfg.model.targets, cfg.model.horizons_s, cfg.model)
        self.climatology = HarmonicClimatology(
@@ -191,6 +194,7 @@ class Station:
            "cpu_offset": (raw.get("cpu_temp") or float("nan")) - (raw.get("temp_raw") or float("nan")),
            "compensator_k": self.tracker.compensator.k,
            "hum_offset": self.tracker.hum_compensator.offset,
+            "outdoor_c": (self.probe.read() if self.probe is not None else None),
            "hum_psychrometric": float(est["hum_c"]) - float(raw.get("hum") or float("nan")),
            "health": anomaly["health_overall"],
            "novelty_d2": anomaly["novelty"].get("d2", 0.0),
@@ -265,6 +269,11 @@ class Station:
        result = self.tracker.compensator.calibrate(float(raw), float(cpu), float(reference_c))
        self.store.log_event("calibration", "info",
                             f"k -> {result['k']:.3f} (residual {result['residual']:+.2f} C)")
+        # Discontinuity marker: everything logged before this instant used a
+        # different coefficient. Kept as its own event kind so the scorecard and
+        # the records view can find it without parsing prose.
+        self.store.log_event("discontinuity", "warn",
+                             f"temperature k {result['k']:.4f}")
        return result

    def calibrate_humidity(self, reference_pct: float) -> Dict:
@@ -279,6 +288,8 @@ class Station:
        self.store.log_event("calibration", "info",
                             f"rh offset -> {result['offset']:+.2f}% "
                             f"(residual {result['residual']:+.2f}%)")
+        self.store.log_event("discontinuity", "warn",
+                             f"humidity offset {result['offset']:+.4f}")
        return result

    def reset_humidity_calibration(self) -> Dict:
@@ -293,6 +304,72 @@ class Station:
                             f"rh offset reset to prior {self.cfg.sensor.hum_offset}")
        return {"offset": self.tracker.hum_compensator.offset, "reset": True, "n": 0}

+    def recompute_history(self) -> Dict:
+        """Re-derive every compensated column from the stored raw values.
+
+        Why this exists: calibration only changes readings from that moment on,
+        so a correction of any size leaves a step in the record. Measured on this
+        station, one humidity calibration put a 25-point discontinuity through
+        the middle of the day. That contaminates the all-time records with values
+        that were never real weather, and makes the learners train across a jump.
+
+        It is possible at all because the raw columns are never overwritten:
+        `temp_raw`, `cpu_temp` and `hum` are exactly what the sensor reported, so
+        the current coefficients can be applied to the whole history.
+
+        The Kalman levels are re-run rather than shifted, because the filter is
+        not a constant offset. That means the smoothing is *re-derived*, not bit
+        identical to what was logged live: the replay sees the stored cadence,
+        which for tiered rows is coarser than the 2 s the filter runs at. The
+        levels are right, the fine texture of old raw rows is not recoverable.
+        """
+        data = self.store.all_for_recompute()
+        ts = data["ts"]
+        if ts.size == 0:
+            return {"rows": 0, "reason": "no history"}
+
+        t0 = time.time()
+        comp, hcomp = self.tracker.compensator, self.tracker.hum_compensator
+        n = ts.size
+        temp_c = np.empty(n)
+        hum_c = np.empty(n)
+        for i in range(n):
+            tr, cp, hu = data["temp_raw"][i], data["cpu_temp"][i], data["hum"][i]
+            temp_c[i] = comp.compensate(tr, cp) if np.isfinite(tr) and np.isfinite(cp) else tr
+            hum_c[i] = (hcomp.compensate(hu, tr, temp_c[i])
+                        if np.isfinite(hu) and np.isfinite(tr) else hu)
+
+        # Replay the filters over the corrected series. Fresh instances, so an
+        # old contaminated state cannot leak into the re-derivation.
+        kt = KalmanCV(self.cfg.sensor.kalman_q_temp, self.cfg.sensor.kalman_r_temp)
+        kh = KalmanCV(self.cfg.sensor.kalman_q_hum, self.cfg.sensor.kalman_r_hum)
+        temp_s = np.empty(n)
+        temp_r = np.empty(n)
+        hum_s = np.empty(n)
+        prev = None
+        for i in range(n):
+            dt = 1.0 if prev is None else max(ts[i] - prev, 1e-3)
+            prev = ts[i]
+            lvl, rate = kt.update(temp_c[i], dt)
+            temp_s[i], temp_r[i] = lvl, rate * 3600.0
+            hum_s[i], _ = kh.update(hum_c[i], dt)
+
+        dew = np.asarray(physics.dew_point(temp_s, hum_s), dtype=float)
+        slp = np.asarray(physics.sea_level_pressure(
+            data["press"], temp_s, self.cfg.site.altitude_m), dtype=float)
+
+        written = self.store.apply_recompute(ts, {
+            "temp_c": temp_c, "temp_smooth": temp_s, "temp_rate": temp_r,
+            "hum_smooth": hum_s, "dew_c": dew, "press_slp": slp,
+        })
+        secs = time.time() - t0
+        self.store.log_event(
+            "recompute", "info",
+            f"re-derived {written} rows from raw with k={comp.k:.4f}, "
+            f"rh offset={hcomp.offset:+.2f}% in {secs:.1f}s")
+        return {"rows": written, "seconds": round(secs, 2),
+                "k": comp.k, "hum_offset": hcomp.offset}
+
    def reset_calibration(self) -> Dict:
        """Return the self-heating coefficient to its configured prior.

@@ -154,6 +154,52 @@ class Store:

    # ------------------------------------------------------------- reads

+    def all_for_recompute(self) -> Dict[str, np.ndarray]:
+        """Every stored row's *raw* inputs, oldest first.
+
+        Only the columns a re-derivation actually needs. The raw sensor values
+        are never overwritten, which is precisely what makes recomputation
+        possible after a calibration changes k or the humidity offset.
+        """
+        cols = ["ts", "temp_raw", "cpu_temp", "hum", "press"]
+        with self._conn() as conn:
+            rows = conn.execute(
+                f"SELECT {', '.join(cols)} FROM telemetry ORDER BY ts ASC").fetchall()
+        if not rows:
+            return {c: np.empty(0) for c in cols}
+        arr = np.array(rows, dtype=object)
+        out = {}
+        for i, c in enumerate(cols):
+            out[c] = np.array([np.nan if v is None else float(v) for v in arr[:, i]],
+                              dtype=float)
+        return out
+
+    def apply_recompute(self, ts: np.ndarray, updates: Dict[str, np.ndarray],
+                        chunk: int = 2000) -> int:
+        """Write recomputed derived columns back, in chunks.
+
+        Chunked because a year of tiered history is a six-figure row count and a
+        single statement would hold the whole parameter list in memory on a
+        512 MB board.
+        """
+        names = list(updates.keys())
+        sql = (f"UPDATE telemetry SET {', '.join(n + ' = ?' for n in names)} "
+               f"WHERE ts = ?")
+        n_written = 0
+        with self._conn() as conn:
+            for start in range(0, ts.size, chunk):
+                stop = min(start + chunk, ts.size)
+                batch = [
+                    tuple(
+                        [None if not np.isfinite(updates[n][i]) else float(updates[n][i])
+                         for n in names] + [float(ts[i])]
+                    )
+                    for i in range(start, stop)
+                ]
+                conn.executemany(sql, batch)
+                n_written += len(batch)
+        return n_written
+
    def window(self, hours: float, columns: Optional[Iterable[str]] = None) -> Dict[str, np.ndarray]:
        """Return the last `hours` of telemetry as column arrays, oldest first."""
        cols = list(columns) if columns else COLUMNS