From 7a392a5367365ef1f11f6421d7739de13d2b1e2f Mon Sep 17 00:00:00 2001
From: glenn schrooyen <glenn@dsgpartners.be>
Date: Thu, 22 Oct 2026 03:21:41 +0200
Subject: [PATCH 1/3] UX-46: Dutch status rows, banners, notes and wizard lines
 on the NL pages

Rows and banners are built once with their Dutch beside them (messages.Bi)
and status_payload() picks one by the page's language. Settings notes and the
wizard's checks carry a Dutch twin (Note.nl) that /config/validate picks by
the posted language. The peak forecast label drops "(W)" in EN and NL.

Co-Authored-By: Claude <noreply@anthropic.com>
---
 goodwe_controller/DOCS.md              |   2 +-
 goodwe_controller/app/main.py          |  18 +-
 goodwe_controller/app/messages.py      | 648 +++++++++++++++++++------
 goodwe_controller/app/setuponly.py     |   6 +-
 goodwe_controller/app/uipage.py        |   4 +-
 goodwe_controller/app/validate.py      | 168 +++++--
 goodwe_controller/app/web.py           |  20 +-
 goodwe_controller/test_ux46.py         | 578 ++++++++++++++++++++++
 goodwe_controller/translations/en.yaml |   2 +-
 goodwe_controller/translations/nl.yaml |   2 +-
 10 files changed, 1244 insertions(+), 204 deletions(-)
 create mode 100644 goodwe_controller/test_ux46.py

diff --git a/goodwe_controller/DOCS.md b/goodwe_controller/DOCS.md
index fb1be9c..27b7b20 100644
--- a/goodwe_controller/DOCS.md
+++ b/goodwe_controller/DOCS.md
@@ -211,7 +211,7 @@ The label and description each setting shows on the Configuration tab, in tab or
 | Limits | Battery cut-out level (%) | `bms_soc_floor` | The level where the battery's own management system stops giving power. Read it off your battery rather than copying a figure. |
 | Limits | Peak limit (W) | `peak_cap_w` | Your own number: the 15-minute average power the add-on keeps the grid under. Take it from your grid contract. |
 | Limits | Margin below the peak limit (W) | `peak_margin_w` | The add-on aims this much below the peak limit, so a 15-minute period that ends a little high still stays under it. |
-| Limits | 15-minute demand forecast entity (W) | `peak_forecast_entity` | Optional. A forecast of this 15-minute period's average power, in W or kW. With no power unit it is not used. Leave it empty and there is no peak limit. |
+| Limits | 15-minute demand forecast entity | `peak_forecast_entity` | Optional. A forecast of this 15-minute period's average power, in W or kW. With no power unit it is not used. Leave it empty and there is no peak limit. |
 | Limits | Peak reserve (%) | `peak_soc_floor` | Peak limiting will not draw the battery below this level, but ordinary use can. Derived value, leave it unchanged. |
 | Tariff | Dynamic price source | `price_provider` | Where prices come from. Choosing a source starts the price fetch, even with trading off. |
 | Tariff | Supplier markup (EUR/kWh) | `price_markup_eur_kwh` | Your supplier's margin. It is added only when the price source does not already include it. |
diff --git a/goodwe_controller/app/main.py b/goodwe_controller/app/main.py
index 1a301a0..290068d 100644
--- a/goodwe_controller/app/main.py
+++ b/goodwe_controller/app/main.py
@@ -7464,7 +7464,8 @@ class Controller:
             level, banner = "warn", messages.banner_stopped()
         elif runs:
             level, running_alarm = "bad", True
-            banner = runs[0].get("banner") or messages.headline(runs[0]["text"])
+            banner = runs[0].get("banner") or messages.headline_bi(
+                runs[0]["text"])
         elif any(i.delivery_wd.tripped for i in self.inverters):
             # ⚠️ SAFETY-42, AND IT IS A `warn` BANNER RATHER THAN A `bad` ONE,
             # WHICH IS THE WHOLE "reports, does not act" DECISION IN ONE LINE.
@@ -7487,11 +7488,11 @@ class Controller:
             # character; at two, "Maintenance: drain" without a name is a
             # banner an operator cannot act on, because the remedy is at one
             # device and the site has two.
-            level, banner = "warn", f"Maintenance: {self.maint.phase}"
-            if len(self.inverters) > 1:
-                banner += f" ({self.maint_unit.name})"
+            level, banner = "warn", messages.banner_maintenance(
+                self.maint.phase,
+                self.maint_unit.name if len(self.inverters) > 1 else "")
         else:
-            level, banner = "ok", "Running — holding grid at zero"
+            level, banner = "ok", messages.banner_running()
 
         def w(v):
             return "—" if v is None else f"{v:,.0f} W".replace(",", " ")
@@ -7595,6 +7596,13 @@ class Controller:
                 now=datetime.now(timezone.utc), why=self.why_words)),
         ]
         held = level == "bad" and not running_alarm
+        # UX-46. The rows were built in English with their Dutch beside them
+        # (`messages.Bi`); the page's language is chosen once, here, for the
+        # Home sentences, the checks list and the rows that carry one. The
+        # banner above stays English: it is the plain fallback.
+        checks = [dict(c, text=messages.pick(c["text"], lang)) for c in checks]
+        rows = [(k, messages.pick(v, lang)) for k, v in rows]
+        banner = messages.pick(banner, lang)
         out = {
             "banner": banner, "level": level, "rows": rows, "checks": checks,
             "hint": self.hint,
diff --git a/goodwe_controller/app/messages.py b/goodwe_controller/app/messages.py
index 0c1344f..f8c350a 100644
--- a/goodwe_controller/app/messages.py
+++ b/goodwe_controller/app/messages.py
@@ -31,6 +31,54 @@ def duration(seconds) -> str:
     return f"{s / 60:.0f} minutes"
 
 
+class Bi(str):
+    """UX-46. A status row in both languages. It is its English text, so every
+    caller and every log line sees English, and `.nl` is the Dutch. The Home
+    page picks one with `pick()` where it knows the page's language."""
+
+    def __new__(cls, en, nl=None):
+        out = super().__new__(cls, en)
+        out.nl = nl
+        return out
+
+    def __getnewargs__(self):
+        return (str(self), self.nl)
+
+
+def pick(text, lang="en"):
+    """`text` in `lang`. A `Bi` gives its Dutch for "nl"; any other text, and
+    any language but "nl", gives the text as it is."""
+    if lang == "nl" and isinstance(text, Bi) and text.nl:
+        return str(text.nl)
+    return str(text) if isinstance(text, Bi) else text
+
+
+def seconden(value) -> str:
+    n = f"{float(value):.0f}"
+    return f"{n} seconde" if n == "1" else f"{n} seconden"
+
+
+def duur(value) -> str:
+    s = float(value)
+    return f"{s:.0f} seconden" if s < 120 else f"{s / 60:.0f} minuten"
+
+
+def keer(n) -> str:
+    return f"{int(n)} keer"
+
+
+def voor(unit) -> str:
+    """` voor inverter-b` on a site with several inverters, else nothing."""
+    return f" voor {unit}" if unit else ""
+
+
+def namen(items) -> str:
+    items = list(items)
+    if len(items) <= 1:
+        return "".join(items)
+    return ", ".join(items[:-1]) + " en " + items[-1]
+
+
 def names(items) -> str:
     items = list(items)
     if len(items) <= 1:
@@ -129,6 +177,13 @@ S_NOT_DELIVERING = "An inverter is not delivering"
 T_METER_FROZEN = "Meter reading may be stuck"
 T_MAINT_FAILED = "Battery cycle did not finish"
 T_MAINT_FAILED_NL = "Batterijcyclus niet afgerond"
+# UX-46: the Dutch of the titles the rows repeat. The Home page's own titles
+# (ui_text/nl.json, "attn") are the same words.
+T_LOOP_BOUND_NL = "Batterij kan niet volgen"
+T_OUTPUT_CLAMP_NL = "Vermogensvraag te hoog"
+T_PEAK_SATURATED_NL = "Belasting te hoog voor de batterij"
+T_METER_FROZEN_NL = "Meter staat mogelijk vast"
+TITLE_NL = {T_LOOP_BOUND: T_LOOP_BOUND_NL, T_OUTPUT_CLAMP: T_OUTPUT_CLAMP_NL}
 T_NO_PRICES = "No prices"
 T_NO_PRICES_NL = "Prijzen ontbreken"
 
@@ -387,13 +442,18 @@ def fixed_tariff_card_gone() -> Dismiss:
 def row_no_prices(since=None, now=None) -> str:
     """PRICE-01: the status row while no price covers now."""
     if since is not None:
-        return f"No prices since {since_text(since, now)}, maintenance waits."
-    return "No prices yet, maintenance waits."
+        return Bi(f"No prices since {since_text(since, now)}, maintenance "
+                  "waits.",
+                  f"Geen prijzen sinds {since_text(since, now, 'nl')}, "
+                  "onderhoud wacht.")
+    return Bi("No prices yet, maintenance waits.",
+              "Nog geen prijzen, onderhoud wacht.")
 
 
 def row_maint_waits(until_text: str) -> str:
     """MAINT-13: the status row while a failed cycle waits."""
-    return f"Waits until {until_text} after a cycle that did not finish."
+    return Bi(f"Waits until {until_text} after a cycle that did not finish.",
+              f"Wacht tot {until_text} na een cyclus die niet af was.")
 
 
 # --- the status page (UX-08 phase 2b) ----------------------------------------
@@ -405,6 +465,8 @@ def row_maint_waits(until_text: str) -> str:
 # DOCS.md, "Status page", explains every row.
 
 NOT_READY = "Not ready"
+BANNER_RUNNING = ("Running — holding grid at zero",
+                  "Actief — het net blijft op nul")
 DOCS_STATUS = "Status page"
 
 
@@ -462,42 +524,72 @@ def headline(text: str) -> str:
 
 
 # Banners (the headline at the top of the page).
+def headline_bi(text):
+    """`headline()` of a row, in both languages."""
+    return Bi(headline(text), headline(getattr(text, "nl", None) or text))
+
+
 def banner_not_ready(row: dict) -> str:
-    return f"{NOT_READY} — {row.get('banner') or headline(row['text'])}"
+    part = row.get("banner") or headline_bi(row["text"])
+    return Bi(f"{NOT_READY} — {part}",
+              f"Niet klaar — {getattr(part, 'nl', None) or part}")
 
 
 def banner_circulating() -> str:
-    return "Inverters worked against each other. Every inverter is set to 0 W."
+    return Bi("Inverters worked against each other. Every inverter is set to "
+              "0 W.",
+              "Omvormers werkten elkaar tegen. Elke omvormer staat op 0 W.")
 
 
 def banner_site_direction() -> str:
-    return "Total power went the wrong way. All inverters at 0 W."
+    return Bi("Total power went the wrong way. All inverters at 0 W.",
+              "Totaal vermogen ging de verkeerde kant op. Alle omvormers op "
+              "0 W.")
 
 
 def banner_direction(several: bool) -> str:
     if several:
-        return "An inverter's own power went the wrong way. Set to 0 W."
-    return "The meter saw power go the wrong way. Inverter at 0 W."
+        return Bi("An inverter's own power went the wrong way. Set to 0 W.",
+                  "Eigen vermogen van een omvormer ging verkeerd. Op 0 W "
+                  "gezet.")
+    return Bi("The meter saw power go the wrong way. Inverter at 0 W.",
+              "De meter zag het vermogen verkeerd gaan. Omvormer op 0 W.")
 
 
 def banner_not_delivering(units) -> str:
     units = list(units)
     verb = "are" if len(units) > 1 else "is"
-    return f"{names(units)} {verb} not delivering. Control keeps running."
+    werkwoord = "leveren" if len(units) > 1 else "levert"
+    return Bi(f"{names(units)} {verb} not delivering. Control keeps running.",
+              f"{namen(units)} {werkwoord} niet. De regeling blijft draaien.")
+
+
+def banner_maintenance(phase: str, unit: str = "") -> str:
+    where = f" ({unit})" if unit else ""
+    return Bi(f"Maintenance: {phase}{where}", f"Onderhoud: {phase}{where}")
+
+
+def banner_running() -> str:
+    return Bi(*BANNER_RUNNING)
 
 
 def banner_stopped() -> str:
-    return "Stopped — the inverters are set to 0 W"
+    return Bi("Stopped — the inverters are set to 0 W",
+              "Gestopt — de omvormers staan op 0 W")
 
 
 def banner_setup_only() -> str:
     """UX-15: setup-only mode, where the add-on serves the page and commands
     nothing (app/setuponly.py)."""
-    return "Setup: nothing is controlled yet"
+    return Bi("Setup: nothing is controlled yet",
+              "Installatie: nog niets wordt geregeld")
 
 
 def row_setup_only() -> str:
-    return "No inverter is named yet, so finish Setup and restart the add-on."
+    return Bi("No inverter is named yet, so finish Setup and restart the "
+              "add-on.",
+              "Er is nog geen omvormer benoemd, dus rond de installatie af "
+              "en herstart de add-on.")
 
 
 def banner_shadow(latched: bool) -> str:
@@ -508,84 +600,117 @@ def banner_shadow(latched: bool) -> str:
     clears.
     """
     if latched:
-        return ("Shadow mode: battery not controlled. A safety stop stays on, "
-                "see below.")
-    return "Shadow mode: the battery is not controlled. Inverters stay at 0 W."
+        return Bi("Shadow mode: battery not controlled. A safety stop stays "
+                  "on, see below.",
+                  "Schaduwmodus: batterij niet geregeld. Een veiligheidsstop "
+                  "blijft aan, zie hieronder.")
+    return Bi("Shadow mode: the battery is not controlled. Inverters stay at "
+              "0 W.",
+              "Schaduwmodus: de batterij wordt niet geregeld. Omvormers "
+              "blijven op 0 W.")
 
 
 def banner_ha_waiting() -> str:
     """SAFETY-112: the Supervisor passes nothing on until Home Assistant has
     finished starting, so the add-on can neither read nor write."""
-    return "Waiting for Home Assistant to finish starting"
+    return Bi("Waiting for Home Assistant to finish starting",
+              "Wachten tot Home Assistant is opgestart")
 
 
 def row_ha_waiting() -> str:
-    return ("Home Assistant is not answering, perhaps it is still starting. "
-            "Control resumes by itself when it answers.")
+    return Bi("Home Assistant is not answering, perhaps it is still "
+              "starting. Control resumes by itself when it answers.",
+              "Home Assistant antwoordt niet, misschien start het nog op. "
+              "De regeling gaat vanzelf verder zodra het antwoordt.")
 
 
 # Rows: control and the meter. "Control" is what the add-on does, as in
 # "start control" (STYLE.md section 4).
 def row_controller_starting() -> str:
-    return "Control: starting"
+    return Bi("Control: starting", "Regeling: start op")
 
 
 def row_controller_ran(age_s) -> str:
-    return f"Control: last ran {seconds(age_s)} ago"
+    return Bi(f"Control: last ran {seconds(age_s)} ago",
+              f"Regeling: laatst uitgevoerd {seconden(age_s)} geleden")
 
 
 def row_controller_stalled(age_s, veto_s) -> str:
-    return (f"Control has not run for {seconds(age_s)}. The control board "
-            f"sets the inverter to 0 W after {seconds(veto_s)}.")
+    return Bi(f"Control has not run for {seconds(age_s)}. The control board "
+              f"sets the inverter to 0 W after {seconds(veto_s)}.",
+              f"De regeling is al {seconden(age_s)} niet uitgevoerd. De "
+              f"stuurmodule zet de omvormer na {seconden(veto_s)} op 0 W.")
 
 
 def row_meter_waiting(limit_s) -> str:
     """UX-10: no reading yet since the start, and still inside the limit."""
-    return f"Meter: waiting for the first reading, limit {seconds(limit_s)}"
+    return Bi(f"Meter: waiting for the first reading, limit "
+              f"{seconds(limit_s)}",
+              f"Meter: wacht op de eerste meting, limiet {seconden(limit_s)}")
 
 
 def row_meter_stale(age_s, limit_s) -> str:
-    return (f"Meter: no reading for {seconds(age_s)}, limit "
-            f"{seconds(limit_s)}. The add-on log shows why.")
+    return Bi(f"Meter: no reading for {seconds(age_s)}, limit "
+              f"{seconds(limit_s)}. The add-on log shows why.",
+              f"Meter: al {seconden(age_s)} geen meting, limiet "
+              f"{seconden(limit_s)}. De log van de add-on toont waarom.")
 
 
 def row_meter(net_w, age_s, rejected=0, unchanged_s=None) -> str:
-    return (f"Meter: {signed_watts(net_w)}, {seconds(age_s)} old"
-            + (f", {rejected} readings refused" if rejected else "")
-            + ("" if unchanged_s is None
-               else f", unchanged for {duration(unchanged_s)}"))
+    return Bi(f"Meter: {signed_watts(net_w)}, {seconds(age_s)} old"
+              + (f", {rejected} readings refused" if rejected else "")
+              + ("" if unchanged_s is None
+                 else f", unchanged for {duration(unchanged_s)}"),
+              f"Meter: {signed_watts(net_w)}, {seconden(age_s)} oud"
+              + (f", {rejected} metingen geweigerd" if rejected else "")
+              + ("" if unchanged_s is None
+                 else f", ongewijzigd gedurende {duur(unchanged_s)}"))
 
 
 def row_meter_frozen() -> str:
-    return (f"{T_METER_FROZEN}. Control still follows it. Check the meter, "
-            f"and stop control if it is stuck.")
+    return Bi(f"{T_METER_FROZEN}. Control still follows it. Check the meter, "
+              f"and stop control if it is stuck.",
+              f"{T_METER_FROZEN_NL}. De regeling volgt hem nog. Controleer "
+              f"de meter en stop de regeling als hij vastzit.")
 
 
 # Settings are named by their labels in translations/en.yaml.
 METER_SOURCE = "“Where the meter reading comes from”"
+METER_SOURCE_NL = "“Waar de meterstand vandaan komt”"
 
 FREEZE_OFF = {
     "source": f"it needs {METER_SOURCE} set to HomeWizard local",
     "rating": "“Inverter rating” is not set",
     "range": "the inverter reports no usable power range",
 }
+FREEZE_OFF_NL = {
+    "source": f"vereist {METER_SOURCE_NL} op HomeWizard local",
+    "rating": "“Vermogen van de omvormer” is niet ingesteld",
+    "range": "de omvormer meldt geen bruikbaar vermogensbereik",
+}
 
 
 def row_freeze_off(why: str) -> str:
     """`why` is a key of FREEZE_OFF: why the stuck-meter check cannot run."""
-    return f"Stuck-meter check: off, {FREEZE_OFF[why]}"
+    return Bi(f"Stuck-meter check: off, {FREEZE_OFF[why]}",
+              f"Controle op vastgelopen meter: uit, {FREEZE_OFF_NL[why]}")
 
 
 def row_freeze_on(hold_s, rail_w, own_limit: bool) -> str:
-    return (f"Stuck-meter check: alerts after {duration(hold_s)} unchanged "
-            f"above {watts(rail_w)}"
-            + (", the inverter's own limit" if own_limit else ""))
+    return Bi(f"Stuck-meter check: alerts after {duration(hold_s)} unchanged "
+              f"above {watts(rail_w)}"
+              + (", the inverter's own limit" if own_limit else ""),
+              f"Vastgelopen meter: alarm na {duur(hold_s)} gelijk boven "
+              f"{watts(rail_w)}"
+              + (", limiet van de omvormer" if own_limit else ""))
 
 
 # Rows: the peak guard.
 def row_peak_saturated(ceiling_w) -> str:
-    return (f"{T_PEAK_SATURATED}. Switch off large loads to stay under the "
-            f"{watts(ceiling_w)} peak limit.")
+    return Bi(f"{T_PEAK_SATURATED}. Switch off large loads to stay under the "
+              f"{watts(ceiling_w)} peak limit.",
+              f"{T_PEAK_SATURATED_NL}. Schakel grote verbruikers uit om onder "
+              f"de piekgrens van {watts(ceiling_w)} te blijven.")
 
 
 def row_peak_reserve(ceiling_w, *, soc_unread: bool, floor_unknown: bool,
@@ -593,95 +718,142 @@ def row_peak_reserve(ceiling_w, *, soc_unread: bool, floor_unknown: bool,
     """SAFETY-24/25/32. The last sentence is SAFETY-25 and must stay.
     `others`: as in `peak_reserve()` (SAFETY-87)."""
     if soc_unread:
-        why = "Battery level cannot be read"
+        why, why_nl = ("Battery level cannot be read",
+                       "Het laadniveau is niet leesbaar")
     elif floor_unknown:
-        why = "A battery cut-out level is not set"
+        why, why_nl = ("A battery cut-out level is not set",
+                       "Een uitschakelniveau van de batterij is niet ingesteld")
     else:
-        why = (f"{names(packs)} battery at its peak reserve" if packs
-               else "Battery at its peak reserve")
+        why, why_nl = ((f"{names(packs)} battery at its peak reserve",
+                        f"Batterij van {namen(packs)} op de piekreserve")
+                       if packs else
+                       ("Battery at its peak reserve",
+                        "Batterij op de piekreserve"))
     if others:
-        return (f"{why}. The others cannot hold the {watts(ceiling_w)} peak "
-                f"limit alone. Home use still draws it lower, to the cut-out "
-                f"level.")
-    return (f"{why}, so the {watts(ceiling_w)} peak limit will be passed. Home "
-            f"use still draws the battery below it, down to the cut-out level.")
+        return Bi(f"{why}. The others cannot hold the {watts(ceiling_w)} peak "
+                  f"limit alone. Home use still draws it lower, to the "
+                  f"cut-out level.",
+                  f"{why_nl}. De andere kunnen de piekgrens van "
+                  f"{watts(ceiling_w)} niet alleen houden. Het huis trekt de "
+                  f"batterij nog leger, tot het uitschakelniveau.")
+    return Bi(f"{why}, so the {watts(ceiling_w)} peak limit will be passed. "
+              f"Home use still draws the battery below it, down to the "
+              f"cut-out level.",
+              f"{why_nl}, dus de piekgrens van {watts(ceiling_w)} wordt "
+              f"overschreden. Het huis trekt de batterij nog leger, tot het "
+              f"uitschakelniveau.")
 
 
 def row_peak_guard_off() -> str:
     """`meter_source` is off: the 15-minute average cannot be measured."""
-    return f"Peak guard: off, set {METER_SOURCE} to anything but off"
+    return Bi(f"Peak guard: off, set {METER_SOURCE} to anything but off",
+              f"Piekbewaking: uit, zet {METER_SOURCE_NL} op iets anders dan "
+              f"uit")
 
 
 def banner_peak_reserve() -> str:
-    return T_PEAK_RESERVE
+    return Bi(T_PEAK_RESERVE, "Batterij beperkt de piek niet meer")
 
 
 # Rows: the sensors and the inverter control.
 LABEL_SOC = "Battery level"
 LABEL_BATTERY = "Battery power"
 LABEL_GRID = "Grid power"
+# UX-46: the same three in Dutch, and the settings that name them.
+LABEL_NL = {LABEL_SOC: "Laadniveau", LABEL_BATTERY: "Batterijvermogen",
+            LABEL_GRID: "Netvermogen"}
+LABEL_ENTITY_NL = {LABEL_SOC: "Entiteit laadniveau",
+                   LABEL_BATTERY: "Entiteit batterijvermogen",
+                   LABEL_GRID: "Entiteit netvermogen"}
 
 
 def row_sensor(label, value, unit=None) -> str:
     shown = f"{float(value):g} %" if label.startswith(LABEL_SOC) \
         else signed_watts(value)
-    return f"{label}{for_unit(unit)}: {shown}"
+    return Bi(f"{label}{for_unit(unit)}: {shown}",
+              f"{LABEL_NL.get(label, label)}{voor(unit)}: {shown}")
 
 
 def row_sensor_unset(label, unit=None) -> str:
     """The setting is "<label> entity" (e.g. "Grid power entity (W)")."""
-    return f"{label}{for_unit(unit)}: “{label} entity” is not set"
+    return Bi(f"{label}{for_unit(unit)}: “{label} entity” is not set",
+              f"{LABEL_NL.get(label, label)}{voor(unit)}: “"
+              f"{LABEL_ENTITY_NL.get(label, label)}” is niet ingesteld")
 
 
 def row_sensor_unusable(label, unit=None) -> str:
     """SAFETY-56: it may be missing OR held back as stale; say both."""
-    return (f"{label}{for_unit(unit)}: no usable reading. The entity may be "
-            f"missing, or its reading is held back as too old. Check it in "
-            f"Developer Tools before replacing it.")
+    return Bi(f"{label}{for_unit(unit)}: no usable reading. The entity may be "
+              f"missing, or its reading is held back as too old. Check it in "
+              f"Developer Tools before replacing it.",
+              f"{LABEL_NL.get(label, label)}{voor(unit)}: geen bruikbare "
+              f"meting. De entiteit ontbreekt misschien, of de meting is te "
+              f"oud. Controleer ze in Ontwikkelaarstools voor u ze vervangt.")
 
 
-def setpoint_label(unit=None) -> str:
+def setpoint_label(unit=None, lang="en") -> str:
     """The label: "Setpoint entity" in the inverter list, else its long form."""
+    if lang == "nl":
+        return "“Setpoint-entiteit”" if unit \
+            else "“Setpoint-entiteit van de omvormer”"
     return "“Setpoint entity”" if unit else "“Inverter setpoint entity”"
 
 
 def row_control_unset(unit=None) -> str:
-    return f"Inverter control{for_unit(unit)}: {setpoint_label(unit)} is not set"
+    return Bi(f"Inverter control{for_unit(unit)}: {setpoint_label(unit)} is "
+              f"not set",
+              f"Regeling van de omvormer{voor(unit)}: "
+              f"{setpoint_label(unit, 'nl')} is niet ingesteld")
 
 
 def row_control_missing(unit=None) -> str:
-    return f"Inverter control{for_unit(unit)}: not found in Home Assistant"
+    return Bi(f"Inverter control{for_unit(unit)}: not found in Home "
+              f"Assistant",
+              f"Regeling van de omvormer{voor(unit)}: niet gevonden in Home "
+              f"Assistant")
 
 
 # Rows: whether each inverter can still be controlled (DEV-02). `name` is
 # always given: these rows came with the inverter list.
 def row_no_setpoint(name) -> str:
     """Amber. The site refuses to run at part strength, so all stay at 0 W."""
-    return f"{name}: “Setpoint entity” is not set, so every inverter stays at 0 W"
+    return Bi(f"{name}: “Setpoint entity” is not set, so every inverter "
+              f"stays at 0 W",
+              f"{name}: “Setpoint-entiteit” is niet ingesteld, dus elke "
+              f"omvormer blijft op 0 W")
 
 
 def row_not_controllable(name, held_s, limit_s) -> str:
     """Red. The inverter is dropped and the others carry its share."""
-    return (f"{name} cannot be controlled. It refused every command for "
-            f"{seconds(held_s)}, so control leaves it out.")
+    return Bi(f"{name} cannot be controlled. It refused every command for "
+              f"{seconds(held_s)}, so control leaves it out.",
+              f"{name} kan niet worden geregeld. Hij weigerde elke opdracht "
+              f"gedurende {seconden(held_s)}, dus de regeling laat hem "
+              f"buiten beschouwing.")
 
 
 def row_commands_refused(name, held_s, limit_s) -> str:
     """Amber. Refused, but not for long enough to be dropped yet."""
-    return (f"{name}: commands refused for {seconds(held_s)}, left out of "
-            f"control after {seconds(limit_s)}")
+    return Bi(f"{name}: commands refused for {seconds(held_s)}, left out of "
+              f"control after {seconds(limit_s)}",
+              f"{name}: opdrachten geweigerd gedurende {seconden(held_s)}, "
+              f"na {seconden(limit_s)} buiten de regeling gelaten")
 
 
 def row_control(lo_w, hi_w, unit=None) -> str:
     """The inverter's own range: charging below 0 W, giving power above it."""
     head = f"Inverter control{for_unit(unit)}: ready"
+    kop = f"Regeling van de omvormer{voor(unit)}: klaar"
     if lo_w is None or hi_w is None or lo_w > 0 or hi_w < 0:
         def w(v):
             return "?" if v is None else signed_watts(v)
-        return f"{head}, from {w(lo_w)} to {w(hi_w)}"
+        return Bi(f"{head}, from {w(lo_w)} to {w(hi_w)}",
+                  f"{kop}, van {w(lo_w)} tot {w(hi_w)}")
     if abs(float(lo_w)) == float(hi_w):
-        return f"{head}, up to {watts(hi_w)} each way"
-    return f"{head}, {watts(lo_w)} charging, {watts(hi_w)} giving"
+        return Bi(f"{head}, up to {watts(hi_w)} each way",
+                  f"{kop}, tot {watts(hi_w)} in beide richtingen")
+    return Bi(f"{head}, {watts(lo_w)} charging, {watts(hi_w)} giving",
+              f"{kop}, {watts(lo_w)} laden, {watts(hi_w)} leveren")
 
 
 # Rows: the two loop alarms. The names are the notification titles, so the
@@ -693,26 +865,38 @@ def row_power_too_high(clamps, count, *, shadow: bool = False) -> str:
     what = (f"asked {watts(c.asked_w)}{for_unit(c.unit)}, "
             f"{'would send' if shadow else 'sent'} {watts(c.sent_w)}. Cut back"
             if c else "cut back")
-    return (f"{head}: {what} {times(count)} since start. Software fault, "
-            f"please report it.")
+    kop = f"{T_OUTPUT_CLAMP_NL}{' in schaduwmodus' if shadow else ''}"
+    wat = (f"gevraagd {watts(c.asked_w)}{voor(c.unit)}, "
+           f"{'zou ' + watts(c.sent_w) + ' sturen' if shadow else watts(c.sent_w) + ' gestuurd'}"
+           f". {keer(count)} teruggebracht" if c
+           else f"{keer(count)} teruggebracht")
+    return Bi(f"{head}: {what} {times(count)} since start. Software fault, "
+              f"please report it.",
+              f"{kop}: {wat} sinds de start. Softwarefout, meld dit "
+              f"alstublieft.")
 
 
 def banner_power_too_high() -> str:
-    return T_OUTPUT_CLAMP
+    return Bi(T_OUTPUT_CLAMP, T_OUTPUT_CLAMP_NL)
 
 
 def row_not_keeping_up(count) -> str:
-    return f"{T_LOOP_BOUND}: {times(count)} since start"
+    return Bi(f"{T_LOOP_BOUND}: {times(count)} since start",
+              f"{T_LOOP_BOUND_NL}: {keer(count)} sinds de start")
 
 
 def row_before(title, count) -> str:
     """After an episode clears: how often it happened, so the evidence stays."""
-    return f"{title}: {times(count)} since start, fine now"
+    return Bi(f"{title}: {times(count)} since start, fine now",
+              f"{TITLE_NL.get(title, title)}: {keer(count)} sinds de start, "
+              f"nu weer in orde")
 
 
 def row_write_refused(unit=None) -> str:
-    return (f"{unit or 'The inverter'} refused the last command. Check the "
-            f"add-on log.")
+    return Bi(f"{unit or 'The inverter'} refused the last command. Check the "
+              f"add-on log.",
+              f"{unit or 'De omvormer'} weigerde de laatste opdracht. Kijk in "
+              f"de log van de add-on.")
 
 
 # Rows: the direction checks (SAFETY-02/30).
@@ -721,71 +905,107 @@ def row_direction_trip(unit=None) -> str:
     what = (f"{unit}'s own power went against what the add-on asked, so it is"
             if unit else
             "Grid power went against what the add-on asked, so the inverter is")
-    return (f"{what} set to 0 W. Find out why, then start control. A restart "
-            f"does not clear this.")
+    wat = (f"Het eigen vermogen van {unit} ging tegen de vraag in, dus hij staat"
+           if unit else
+           "Het netvermogen ging tegen de vraag in, dus de omvormer staat")
+    return Bi(f"{what} set to 0 W. Find out why, then start control. A restart "
+              f"does not clear this.",
+              f"{wat} op 0 W. Zoek uit waarom, start dan de regeling. Een "
+              f"herstart heft dit niet op.")
 
 
 def row_direction_check(held_s, hold_s, unit=None) -> str:
     who = (f"Direction check for {unit}, against its own power" if unit
            else "Direction check")
+    wie = (f"Richtingcontrole voor {unit}, op het eigen vermogen" if unit
+           else "Richtingcontrole")
     if held_s:
-        return f"{who}: opposite for {held_s:.0f} of {seconds(hold_s)}"
-    return f"{who}: on"
+        return Bi(f"{who}: opposite for {held_s:.0f} of {seconds(hold_s)}",
+                  f"{wie}: tegengesteld gedurende {held_s:.0f} van "
+                  f"{seconden(hold_s)}")
+    return Bi(f"{who}: on", f"{wie}: aan")
 
 
 def row_site_direction_trip() -> str:
-    return ("Grid power went against the add-on's total request, so every "
-            "inverter is set to 0 W. The cause is the total, not one inverter. "
-            "Only starting control clears this.")
+    return Bi("Grid power went against the add-on's total request, so every "
+              "inverter is set to 0 W. The cause is the total, not one "
+              "inverter. Only starting control clears this.",
+              "Het netvermogen ging tegen de totale vraag in, dus elke omvormer "
+              "staat op 0 W. De oorzaak is het totaal, niet één omvormer. "
+              "Alleen de regeling starten heft dit op.")
 
 
 def row_site_direction_check(held_s, hold_s) -> str:
     if held_s:
-        return (f"Site direction check: opposite for {held_s:.0f} of "
-                f"{seconds(hold_s)}")
-    return "Site direction check: on, against the meter"
+        return Bi(f"Site direction check: opposite for {held_s:.0f} of "
+                  f"{seconds(hold_s)}",
+                  f"Richtingcontrole voor de installatie: tegengesteld "
+                  f"gedurende {held_s:.0f} van {seconden(hold_s)}")
+    return Bi("Site direction check: on, against the meter",
+              "Richtingcontrole voor de installatie: aan, op de meter")
 
 
 # Rows: circulating power (SAFETY-31) and delivery (SAFETY-42).
 def row_circulating_trip() -> str:
-    return ("Inverters worked against each other, so every inverter is set to "
-            "0 W. The meter cannot see this. Only starting control clears this.")
+    return Bi("Inverters worked against each other, so every inverter is set "
+              "to 0 W. The meter cannot see this. Only starting control "
+              "clears this.",
+              "Omvormers werkten elkaar tegen, dus elke omvormer staat op 0 W. "
+              "De meter ziet dit niet. Alleen de regeling starten heft dit "
+              "op.")
 
 
 CHECK_CIRCULATING = "Check for inverters working against each other"
+CHECK_CIRCULATING_NL = "Controle op omvormers die elkaar tegenwerken"
+CHECK_DELIVERY = "Delivery check"
+CHECK_DELIVERY_NL = "Controle op levering"
+CHECK_NL = {CHECK_CIRCULATING: CHECK_CIRCULATING_NL,
+            CHECK_DELIVERY: CHECK_DELIVERY_NL}
 
 
 def row_circulating_check(now_w, held_s, hold_s) -> str:
     if held_s:
-        return (f"{CHECK_CIRCULATING}: {watts(now_w or 0)} for {held_s:.0f} of "
-                f"{seconds(hold_s)}")
-    return (f"{CHECK_CIRCULATING}: on"
-            + (f", now {watts(now_w)}" if now_w else ""))
+        return Bi(f"{CHECK_CIRCULATING}: {watts(now_w or 0)} for {held_s:.0f} "
+                  f"of {seconds(hold_s)}",
+                  f"{CHECK_CIRCULATING_NL}: {watts(now_w or 0)} gedurende "
+                  f"{held_s:.0f} van {seconden(hold_s)}")
+    return Bi(f"{CHECK_CIRCULATING}: on"
+              + (f", now {watts(now_w)}" if now_w else ""),
+              f"{CHECK_CIRCULATING_NL}: aan"
+              + (f", nu {watts(now_w)}" if now_w else ""))
 
 
 def row_one_inverter(check: str) -> str:
-    return f"{check}: not needed with one inverter"
+    return Bi(f"{check}: not needed with one inverter",
+              f"{CHECK_NL.get(check, check)}: niet nodig met één omvormer")
 
 
 def row_not_delivering(unit) -> str:
-    return (f"{unit} is not delivering, and only stopping and starting control "
-            f"clears this")
+    return Bi(f"{unit} is not delivering, and only stopping and starting "
+              f"control clears this",
+              f"{unit} levert niet, en alleen de regeling stoppen en starten "
+              f"heft dit op")
 
 
 def row_delivery_check(unit, short_s, hold_s) -> str:
     if short_s:
-        return (f"Delivery check for {unit}: short for {short_s:.0f} of "
-                f"{seconds(hold_s)}")
-    return f"Delivery check for {unit}: on"
+        return Bi(f"Delivery check for {unit}: short for {short_s:.0f} of "
+                  f"{seconds(hold_s)}",
+                  f"{CHECK_DELIVERY_NL} voor {unit}: te weinig gedurende "
+                  f"{short_s:.0f} van {seconden(hold_s)}")
+    return Bi(f"Delivery check for {unit}: on",
+              f"{CHECK_DELIVERY_NL} voor {unit}: aan")
 
 
 def row_estop_fitted() -> str:
-    return "Emergency stop: fitted"
+    return Bi("Emergency stop: fitted", "Noodstop: geplaatst")
 
 
 def row_no_peak_forecast() -> str:
-    return ("No peak forecast set, so maintenance charging is not kept under "
-            "the peak limit")
+    return Bi("No peak forecast set, so maintenance charging is not kept "
+              "under the peak limit",
+              "Geen prognose voor de piekgrens ingesteld, dus onderhoudsladen "
+              "blijft niet onder de piekgrens")
 
 
 def peak_forecast_unit(unit, lang="en") -> str:
@@ -804,16 +1024,19 @@ def peak_forecast_unit(unit, lang="en") -> str:
 
 
 def row_peak_forecast_unit(unit) -> str:
-    return peak_forecast_unit(unit)
+    return Bi(peak_forecast_unit(unit), peak_forecast_unit(unit, "nl"))
 
 
 def row_peak_guard_waiting() -> str:
-    return "Peak guard: no decision yet, control has not run"
+    return Bi("Peak guard: no decision yet, control has not run",
+              "Piekbewaking: nog geen besluit, de regeling is niet uitgevoerd")
 
 
 def row_no_estop() -> str:
-    return ("No emergency stop fitted: if this computer fails, the battery "
-            "keeps its last command")
+    return Bi("No emergency stop fitted: if this computer fails, the battery "
+              "keeps its last command",
+              "Geen noodstop geplaatst: als deze computer uitvalt, houdt de "
+              "batterij haar laatste opdracht")
 
 
 # Rows: solar production (TEL-11/12/14). Sources are numbered in the order of
@@ -821,103 +1044,143 @@ def row_no_estop() -> str:
 # labels in translations/en.yaml.
 PV_ONE = "“Solar production entity”"
 PV_REVERSED = "“Reversed-sign solar entities”"
+PV_ONE_NL = "“Entiteit zonneproductie”"
+PV_REVERSED_NL = "“Zonne-entiteiten met omgekeerd teken”"
 
 
-def source(n, of) -> str:
+def source(n, of, lang="en") -> str:
+    if lang == "nl":
+        return "de entiteit" if of == 1 else f"bron {n}"
     return "the entity" if of == 1 else f"source {n}"
 
 
-def pv_problem(why: str) -> str:
+def pv_problem(why: str, lang="en") -> str:
     """`pv.watts()`'s reason, in plain words."""
     w = str(why)
+    en, nl = ("the reading is not usable", "de meting is niet bruikbaar")
     if w.startswith("no state"):
-        return "the entity is missing"
-    if w.startswith("entity is"):
-        return "the entity is unavailable"
-    if w.endswith("is not numeric"):
-        return "the reading is not a number"
-    if w.startswith("no unit"):
-        return "the entity has no unit"
-    if w.startswith("unit "):
-        return "the entity's unit is not a power unit"
-    return "the reading is not usable"
+        en, nl = "the entity is missing", "de entiteit ontbreekt"
+    elif w.startswith("entity is"):
+        en, nl = "the entity is unavailable", "de entiteit is niet beschikbaar"
+    elif w.endswith("is not numeric"):
+        en, nl = "the reading is not a number", "de meting is geen getal"
+    elif w.startswith("no unit"):
+        en, nl = "the entity has no unit", "de entiteit heeft geen eenheid"
+    elif w.startswith("unit "):
+        en, nl = ("the entity's unit is not a power unit",
+                  "de eenheid van de entiteit is geen vermogenseenheid")
+    return nl if lang == "nl" else en
 
 
 def row_pv(total_w, count, reversed_=False) -> str:
-    return (f"Solar production: {signed_watts(total_w)}"
-            + (f" from {count} sources" if count > 1 else "")
-            + (", sign reversed" if reversed_ else ""))
+    return Bi(f"Solar production: {signed_watts(total_w)}"
+              + (f" from {count} sources" if count > 1 else "")
+              + (", sign reversed" if reversed_ else ""),
+              f"Zonneproductie: {signed_watts(total_w)}"
+              + (f" van {count} bronnen" if count > 1 else "")
+              + (", teken omgekeerd" if reversed_ else ""))
 
 
 def row_pv_none(why) -> str:
-    return f"Solar production: no reading, {pv_problem(why)}"
+    return Bi(f"Solar production: no reading, {pv_problem(why)}",
+              f"Zonneproductie: geen meting, {pv_problem(why, 'nl')}")
 
 
 def row_pv_partial(missing, count) -> str:
     """`missing` are the 1-based positions of the sources that did not report."""
     which = names([str(n) for n in missing])
-    return (f"Solar production: no total, source{'s' if len(missing) > 1 else ''} "
-            f"{which} of {count} {'have' if len(missing) > 1 else 'has'} no "
-            f"reading")
+    welke = namen([str(n) for n in missing])
+    many = len(missing) > 1
+    return Bi(f"Solar production: no total, source{'s' if many else ''} "
+              f"{which} of {count} {'have' if many else 'has'} no "
+              f"reading",
+              f"Zonneproductie: geen totaal, {'bronnen' if many else 'bron'} "
+              f"{welke} van {count} {'hebben' if many else 'heeft'} geen "
+              f"meting")
 
 
 def row_forecast_gap(day, missing, count) -> str:
     """OPT-17. `day` is "today" or "tomorrow"; `missing` are the 1-based
     positions of the forecast entities with no usable reading."""
     which = names([str(n) for n in missing])
+    welke = namen([str(n) for n in missing])
     many = len(missing) > 1
-    return (f"Solar forecast for {day}: not used, source{'s' if many else ''} "
-            f"{which} of {count} {'have' if many else 'has'} no reading")
+    dag = {"today": "vandaag", "tomorrow": "morgen"}.get(day, day)
+    return Bi(f"Solar forecast for {day}: not used, source{'s' if many else ''} "
+              f"{which} of {count} {'have' if many else 'has'} no reading",
+              f"Zonneprognose voor {dag}: niet gebruikt, "
+              f"{'bronnen' if many else 'bron'} {welke} van {count} "
+              f"{'hebben' if many else 'heeft'} geen meting")
 
 
 def row_pv_single_ignored() -> str:
-    return f"Solar production: clear {PV_ONE}, the per-inverter list replaces it"
+    return Bi(f"Solar production: clear {PV_ONE}, the per-inverter list "
+              f"replaces it",
+              f"Zonneproductie: wis {PV_ONE_NL}, de lijst per omvormer "
+              f"vervangt hem")
 
 
 def row_pv_negative(n, count, value_w, flipped: bool) -> str:
     fix = ("remove it from" if flipped else "add it to")
     who = source(n, count)
-    return (f"Solar production: {who} reads {signed_watts(value_w)}, "
-            f"{fix} {PV_REVERSED}")
+    herstel = "haal hem uit" if flipped else "voeg hem toe aan"
+    return Bi(f"Solar production: {who} reads {signed_watts(value_w)}, "
+              f"{fix} {PV_REVERSED}",
+              f"Zonneproductie: {source(n, count, 'nl')} meet "
+              f"{signed_watts(value_w)}, {herstel} {PV_REVERSED_NL}")
 
 
 def row_pv_stray(n) -> str:
-    return (f"Solar production: entry {n} of {PV_REVERSED} is not a solar "
-            f"entity in use")
+    return Bi(f"Solar production: entry {n} of {PV_REVERSED} is not a solar "
+              f"entity in use",
+              f"Zonneproductie: item {n} van {PV_REVERSED_NL} is geen "
+              f"zonne-entiteit die in gebruik is")
 
 
 # Rows: this month's peak and the peak guard (UX-08 phase 2d). The detail
 # (the projection's reason, the store's state at start) is in the add-on log.
 def row_month_peak(peak_w, at, frac) -> str:
     """`at` is the local start of the 15-minute period that set the peak."""
-    return (f"Month peak: {watts(peak_w)} on {at.day} {at:%b} at {at:%H:%M}, "
-            f"{frac * 100:.0f} % of the peak limit")
+    return Bi(f"Month peak: {watts(peak_w)} on {at.day} {at:%b} at {at:%H:%M}, "
+              f"{frac * 100:.0f} % of the peak limit",
+              f"Maandpiek: {watts(peak_w)} op {at.day} "
+              f"{NL_MONTHS[at.month - 1]} om {at:%H:%M}, {frac * 100:.0f} % "
+              f"van de piekgrens")
 
 
 def row_month_peak_none() -> str:
-    return "Month peak: none recorded yet this month"
+    return Bi("Month peak: none recorded yet this month",
+              "Maandpiek: deze maand nog niets gemeten")
 
 
 def row_month_peak_unreadable() -> str:
     """The store did not answer. This is not a zero peak (TARIFF-01)."""
-    return "Month peak: cannot be read, so only the peak limit is used"
+    return Bi("Month peak: cannot be read, so only the peak limit is used",
+              "Maandpiek: niet leesbaar, dus alleen de piekgrens telt")
 
 
 def row_periods_measured(n) -> str:
     """TARIFF-13's coverage figure. `n` is an int, or a text when unreadable."""
     shown = n if isinstance(n, int) else "cannot be read"
-    return f"15-minute periods measured this month: {shown}"
+    getoond = n if isinstance(n, int) else "niet leesbaar"
+    return Bi(f"15-minute periods measured this month: {shown}",
+              f"Gemeten kwartieren deze maand: {getoond}")
 
 
 def row_peak_guard_idle(projected_w, limit_w, month_peak: bool) -> str:
     """The projection first and the limit second (SAFETY-38's ordered pair)."""
     limit = (f"this month's {watts(limit_w)} peak" if month_peak
              else f"the {watts(limit_w)} peak limit")
-    return f"Peak guard: idle, heading for {watts(projected_w)}, under {limit}"
+    grens = (f"de maandpiek van {watts(limit_w)}" if month_peak
+             else f"de piekgrens van {watts(limit_w)}")
+    return Bi(f"Peak guard: idle, heading for {watts(projected_w)}, under "
+              f"{limit}",
+              f"Piekbewaking: rust, op weg naar {watts(projected_w)}, onder "
+              f"{grens}")
 
 
 def row_peak_guard_quiet() -> str:
-    return "Peak guard: idle"
+    return Bi("Peak guard: idle", "Piekbewaking: rust")
 
 
 BLIND_WORDS = {
@@ -925,41 +1188,61 @@ BLIND_WORDS = {
     "gap": "meter readings have a gap",
     "frozen": "meter reading is stuck",
 }
+BLIND_WORDS_NL = {
+    "no_block": "wacht op metingen van de meter",
+    "gap": "de metingen van de meter hebben een gat",
+    "frozen": "de meterstand zit vast",
+}
 
 
 def row_peak_guard_blind(why: str) -> str:
     """`why` is a key of BLIND_WORDS. The battery may give power, not charge."""
-    return (f"Peak guard: {BLIND_WORDS[why]}, so the battery does not charge "
-            f"meanwhile")
+    return Bi(f"Peak guard: {BLIND_WORDS[why]}, so the battery does not "
+              f"charge meanwhile",
+              f"Piekbewaking: {BLIND_WORDS_NL[why]}, dus de batterij laadt "
+              f"intussen niet")
 
 
 def row_peak_guard_unmeasured() -> str:
     """SAFETY-90. Before the first reading; that part counts as high use."""
-    return ("Peak guard: part of this 15-minute period was not measured, "
-            "counted as high use")
+    return Bi("Peak guard: part of this 15-minute period was not measured, "
+              "counted as high use",
+              "Piekbewaking: een deel van dit kwartier is niet gemeten, "
+              "geteld als hoog verbruik")
 
 
 def row_peak_guard_on(floor_w, limit_w, *, shadow: bool = False) -> str:
     if shadow:
-        return (f"Peak guard: would ask for {watts(floor_w)} to stay under "
-                f"{watts(limit_w)}")
-    return (f"Peak guard: asks the battery for {watts(floor_w)} to stay under "
-            f"{watts(limit_w)}")
+        return Bi(f"Peak guard: would ask for {watts(floor_w)} to stay under "
+                  f"{watts(limit_w)}",
+                  f"Piekbewaking: zou {watts(floor_w)} vragen om onder "
+                  f"{watts(limit_w)} te blijven")
+    return Bi(f"Peak guard: asks the battery for {watts(floor_w)} to stay "
+              f"under {watts(limit_w)}",
+              f"Piekbewaking: vraagt {watts(floor_w)} van de batterij om "
+              f"onder {watts(limit_w)} te blijven")
 
 
 def row_battery_stuck(unit) -> str:
     """SAFETY-37/56. A fact, not a verdict: the reading may be stuck, or the
     battery may be refusing, and the add-on cannot tell which."""
-    return (f"{unit}: battery power reading stopped changing, so it is not used "
-            f"for now")
+    return Bi(f"{unit}: battery power reading stopped changing, so it is not "
+              f"used for now",
+              f"{unit}: het batterijvermogen verandert niet meer, dus het "
+              f"wordt nu niet gebruikt")
 
 
 def row_battery_refuses(unit, sign, probing) -> str:
     """SAFETY-73. One inverter's battery refuses, the others take its share."""
     way = "give" if sign > 0 else "take"
+    weg = "leveren" if sign > 0 else "opnemen"
     if probing:
-        return f"{unit}: testing if the battery will {way} power again"
-    return f"{unit}: the battery refuses to {way} power, the others take over"
+        return Bi(f"{unit}: testing if the battery will {way} power again",
+                  f"{unit}: test of de batterij weer stroom wil {weg}")
+    return Bi(f"{unit}: the battery refuses to {way} power, the others take "
+              f"over",
+              f"{unit}: de batterij weigert stroom te {weg}, de andere "
+              f"nemen over")
 
 
 # The top of the page: why the battery does what it does (the "Why" line).
@@ -1264,6 +1547,9 @@ def status_samples() -> list:
         ("row_pv_negative", AMBER, row_pv_negative(1, 1, -1500, True)),
         ("row_pv_stray", AMBER, row_pv_stray(2)),
         ("banner_stopped", None, banner_stopped()),
+        ("banner_running", None, banner_running()),
+        ("banner_maintenance", None, banner_maintenance("drain")),
+        ("banner_maintenance", None, banner_maintenance("drain", "inverter-b")),
         ("row_control", GREEN, row_control(-4000, 5000, "inverter-b")),
         ("row_month_peak", GREEN, row_month_peak(
             4998, datetime(2026, 8, 12, 19, 15), 0.83)),
@@ -1413,10 +1699,78 @@ def not_valid(option: str, err) -> str:
 UNIT_WORDS = {"c_eur_per_kwh": "c/kWh", "eur_per_kwh": "EUR/kWh"}
 
 
-def setting(key: str, unit: str = "") -> str:
+# UX-46: the same labels in Dutch, as translations/nl.yaml names them
+# (test_messages.py checks each one).
+LABELS_NL = {
+    "setpoint_entity": "Setpoint-entiteit van de omvormer",
+    "max_w": "Vermogen van de omvormer",
+    "bms_soc_floor": "Uitschakelniveau van de batterij",
+    "capacity_kwh": "Bruikbare capaciteit",
+    "inverters": "Lijst met omvormers",
+    "name": "Naam",
+    "meter_source": "Waar de meterstand vandaan komt",
+    "meter_phases": "Aantal fasen",
+    "p1_host": "Adres van de HomeWizard P1",
+    "meter_poll_s": "Tijd tussen twee uitlezingen",
+    "meter_max_age_s": "Meting te oud na",
+    "meter_mqtt_topic": "MQTT-topic",
+    "p1_import_entity": "Entiteit afname",
+    "p1_export_entity": "Entiteit injectie",
+    "p1_net_entity": "Entiteit nettovermogen met teken",
+    "p1_phase_net_entities": "Netto-entiteiten per fase",
+    "peak_soc_floor": "Piekreserve",
+    "price_provider": "Bron van dynamische prijzen",
+    "price_taxes_eur_kwh": "Distributie, heffingen en btw",
+    "static_profile": "Vast of dag/nacht-tarief",
+    "price_taxes_profile": "Heffingen en btw dag/nacht",
+    "price_formula": "Uw eigen tariefformule",
+    "price_export_formula": "Uw eigen injectieformule",
+    "price_csv_path": "CSV-bestand met prijzen",
+    "price_service_token": "Token van de prijsdienst",
+    "price_now_entity": "Entiteit huidige prijs",
+    "price_avg_entity": "Entiteit gemiddelde prijs",
+    "arbitrage_enabled": "Handelen op het prijsverschil",
+    "cycle_cost_threshold_eur": "Kosten van een batterijcyclus",
+    "arbitrage_soc_floor": "Handel houdt minstens",
+    "arbitrage_soc_ceiling": "Handel laadt hoogstens",
+    "maintenance_charge_w": "Laadvermogen",
+    "sign_disagree_w": "Drempel verkeerde richting",
+    "unit_sign_disagree_w": "Drempel verkeerde richting per omvormer",
+    "slew_w": "Grootste stap per cyclus",
+    "shadow_mode": "Schaduwmodus",
+    "integrator_max_w": "Inhaalgrens",
+    "maintenance_discharge_w": "Ontlaadvermogen",
+    "peak_cap_w": "Piekgrens",
+    "peak_margin_w": "Marge onder de piekgrens",
+    "peak_forecast_entity": "Entiteit kwartierprognose",
+    "meter_entity": "Entiteit netvermogen",
+    "soc_entity": "Entiteit laadniveau",
+    "batt_entity": "Entiteit batterijvermogen",
+    "pv_entity": "Entiteit zonneproductie",
+    "pv_entities": "Entiteiten zonneproductie, per omvormer",
+    "pv_forecast_entity": "Zonneprognose, vandaag",
+    "pv_forecast_tomorrow_entity": "Zonneprognose, morgen",
+    "pv_forecast_entities": "Meerdere zonneprognoses, vandaag",
+    "pv_forecast_tomorrow_entities": "Meerdere zonneprognoses, morgen",
+    "solar_trust_pct": "Vertrouwen in de prognose",
+    "p1_phase_import_entities": "Afname-entiteiten per fase",
+    "p1_phase_export_entities": "Injectie-entiteiten per fase",
+}
+# The inverter list shows two of them under a shorter name.
+UNIT_LABELS_NL = {"setpoint_entity": "Setpoint-entiteit",
+                  "max_w": "Vermogen van deze omvormer"}
+
+
+def setting(key: str, unit: str = "", lang: str = "en") -> str:
     """`max_w` -> `“Inverter rating” (max_w)`. For one inverter in a list it is
     `“Inverter rating” for inverter-b (inverters.max_w)`, so the config panel
-    also shows the reason beside `inverters`, where that value is changed."""
+    also shows the reason beside `inverters`, where that value is changed.
+    In Dutch: `“Vermogen van de omvormer” (max_w)`, and `voor inverter-b`."""
+    if lang == "nl":
+        if unit:
+            return (f"“{UNIT_LABELS_NL.get(key, LABELS_NL[key])}” voor {unit} "
+                    f"(inverters.{key})")
+        return f"“{LABELS_NL[key]}” ({key})"
     if unit:
         return f"“{LABELS[key]}” for {unit} (inverters.{key})"
     return f"“{LABELS[key]}” ({key})"
diff --git a/goodwe_controller/app/setuponly.py b/goodwe_controller/app/setuponly.py
index bb4ce3e..026cb36 100644
--- a/goodwe_controller/app/setuponly.py
+++ b/goodwe_controller/app/setuponly.py
@@ -54,10 +54,12 @@ class SetupOnly:
 
     def status_payload(self, lang: str = "en") -> dict:
         return {"setup_only": True, "mode": "setup_only",
-                "banner": messages.banner_setup_only(), "level": "warn",
+                "banner": messages.pick(messages.banner_setup_only(),
+                                       lang), "level": "warn",
                 "rows": [["Control", "not started, in setup"]],
                 "checks": [{"ok": False, "warn": True,
-                            "text": messages.row_setup_only()}],
+                            "text": messages.pick(messages.row_setup_only(),
+                                                  lang)}],
                 "hint": self.hint, "events": list(self.events)}
 
     async def handle_action(self, what):
diff --git a/goodwe_controller/app/uipage.py b/goodwe_controller/app/uipage.py
index 2e2b832..ba33213 100644
--- a/goodwe_controller/app/uipage.py
+++ b/goodwe_controller/app/uipage.py
@@ -17,7 +17,7 @@ from . import uilayout as L
 from . import uitext
 from . import uimodel as U
 from .configui import help_of, label_of, problems_by_field, split_group
-from .validate import power_request_entities
+from .validate import note_text, power_request_entities
 
 # A choice the page cannot make, only keep. `price_service` needs a token, and
 # the token is a secret this page never draws (uilayout.HIDDEN), so it is set on
@@ -314,7 +314,7 @@ def anchors(problems, notes, model, keys, lang="en") -> list:
         add(None, None, "bad", text)
     for note in notes:
         tier = note.tier if note.tier in _TIERS else "info"
-        text = messages.NOTE_NL.get(note.text, note.text) if lang == "nl" else note.text
+        text = note_text(note, lang)
         for key in note.keys or (None,):
             for field, card in (targets(key, note.text, model) if key
                                 else [(None, None)]):
diff --git a/goodwe_controller/app/validate.py b/goodwe_controller/app/validate.py
index 3314706..c9dfb19 100644
--- a/goodwe_controller/app/validate.py
+++ b/goodwe_controller/app/validate.py
@@ -386,12 +386,23 @@ class Note(NamedTuple):
                                 # also "ok" and "bad" (setup_checks)
     keys: tuple
     text: str
+    nl: str = ""                # UX-46: the same sentence in Dutch
 
 
-def _advise(notes, tier: str, keys, text: str) -> None:
-    """Add a Note when the caller collects them (the settings page)."""
+def _advise(notes, tier: str, keys, text: str, nl: str = "") -> None:
+    """Add a Note when the caller collects them (the settings page). `nl` is
+    the Dutch twin of `text`; the page picks one (`note_text()`)."""
     if notes is not None:
-        notes.append(Note(tier, tuple(keys), text))
+        notes.append(Note(tier, tuple(keys), text, nl))
+
+
+def note_text(note, lang: str = "en") -> str:
+    """The note's sentence in the page's language, English when it has no
+    Dutch twin."""
+    if lang == "nl":
+        return getattr(note, "nl", "") or messages.NOTE_NL.get(
+            note.text, note.text)
+    return note.text
 
 
 # ⚠️ A MIRROR OF A FIRMWARE CONSTANT, AND IT CANNOT BE IMPORTED. The firmware
@@ -628,6 +639,11 @@ def S(key: str, where: str = "") -> str:
     return messages.setting(key, where.strip().strip("()"))
 
 
+def SN(key: str, where: str = "") -> str:
+    """`S()` with the Dutch label, for the Dutch twin of a note."""
+    return messages.setting(key, where.strip().strip("()"), "nl")
+
+
 def _labels(keys, joiner: str = "and") -> str:
     """Several settings, each with its key: the config panel files a refusal
     under every key it names (`configui.problems_by_field()`)."""
@@ -1216,7 +1232,9 @@ def validate_startup_config(opts: dict, dev_min=None, dev_max=None,
             integ_w, max_w)
         _advise(notes, "warn", ("integrator_max_w",),
                 f"{S('integrator_max_w')} is above {S('max_w')}, which only "
-                "adds overshoot, so set it to 0.")
+                "adds overshoot, so set it to 0.",
+                nl=f"{SN('integrator_max_w')} is hoger dan {SN('max_w')}, wat "
+                "alleen doorschieten geeft, dus zet het op 0.")
 
     # ⚠️ THE SIBLING OF RULE 6, AND NOT THE SAME CASE - see the docstring. The
     # drain phase OWNS the actuator (`Claim.set` at P_MAINTENANCE), and a SET is
@@ -1244,7 +1262,10 @@ def validate_startup_config(opts: dict, dev_min=None, dev_max=None,
         _advise(notes, "warn", ("maintenance_discharge_w",),
                 f"{S('maintenance_discharge_w')} is above "
                 f"{S('max_w', maint_where)}, so the battery empties at "
-                f"{messages.watts(maint_cap)} and the cycle takes longer.")
+                f"{messages.watts(maint_cap)} and the cycle takes longer.",
+                nl=f"{SN('maintenance_discharge_w')} is hoger dan "
+                f"{SN('max_w', maint_where)}, dus de batterij loopt leeg met "
+                f"{messages.watts(maint_cap)} en de cyclus duurt langer.")
         _LOG.debug(
             "Not refused: the drain phase sets the setpoint, the arbiter "
             "clamps it to %.0f W and names the clamp, and the drain phase has "
@@ -1473,7 +1494,9 @@ def _price_problems(opts: dict, notes: list | None = None) -> list[str]:
                 TAXES_PROFILE_OPTION, negative)
             _advise(notes, "warn", (TAXES_PROFILE_OPTION,),
                     f"{S(TAXES_PROFILE_OPTION)} has negative figures, which "
-                    "lower the price, and that is usually a sign error.")
+                    "lower the price, and that is usually a sign error.",
+                    nl=f"{SN(TAXES_PROFILE_OPTION)} heeft negatieve bedragen, "
+                    "die de prijs verlagen, en dat is meestal een tekenfout.")
 
     # ⚠️ TARIFF-15: THE FORMULA, GRADED AGAINST THE OPERATOR'S OWN CARD, AT
     # STARTUP RATHER THAN AT 03:00.
@@ -1532,7 +1555,10 @@ def _price_problems(opts: dict, notes: list | None = None) -> list[str]:
             _advise(notes, "warn", ("price_formula", "price_provider"),
                     f"{S('price_formula')} is not used, because "
                     f"{S('price_provider')} is not 'custom_formula', so clear "
-                    "it or choose that source.")
+                    "it or choose that source.",
+                    nl=f"{SN('price_formula')} wordt niet gebruikt, omdat "
+                    f"{SN('price_provider')} niet 'custom_formula' is, dus wis "
+                    "ze of kies die bron.")
         if spec is not None and pid == "custom_formula":
             taxes = _number(opts, "price_taxes_eur_kwh",
                             PRICE_OPTION_DEFAULTS["price_taxes_eur_kwh"])
@@ -1547,7 +1573,8 @@ def _price_problems(opts: dict, notes: list | None = None) -> list[str]:
                 # cannot start.
                 _LOG.warning("%s", aged)
                 _advise(notes, "warn", ("price_formula",),
-                        _card_note("price_formula", spec))
+                        _card_note("price_formula", spec),
+                        nl=_card_note("price_formula", spec, "nl"))
 
     # ⚠️ TARIFF-16: THE INJECTION LEG, REFUSED AT STARTUP ON THE SAME RULE.
     #
@@ -1630,7 +1657,10 @@ def _price_problems(opts: dict, notes: list | None = None) -> list[str]:
                     xspec.offset_eur_kwh)
                 _advise(notes, "info", (EXPORT_FORMULA_OPTION,),
                         f"{S(EXPORT_FORMULA_OPTION)} has no card block, so "
-                        "only the shape of its numbers is checked.")
+                        "only the shape of its numbers is checked.",
+                        nl=f"{SN(EXPORT_FORMULA_OPTION)} heeft geen kaartblok, "
+                        "dus alleen de vorm van de getallen wordt "
+                        "gecontroleerd.")
                 _LOG.debug(
                     "Accepted because some suppliers (Eneco) print the "
                     "injection formula with no price beside it. If your card "
@@ -1643,7 +1673,8 @@ def _price_problems(opts: dict, notes: list | None = None) -> list[str]:
                 if xaged:
                     _LOG.warning("%s", xaged)
                     _advise(notes, "warn", (EXPORT_FORMULA_OPTION,),
-                            _card_note(EXPORT_FORMULA_OPTION, xspec))
+                            _card_note(EXPORT_FORMULA_OPTION, xspec),
+                            nl=_card_note(EXPORT_FORMULA_OPTION, xspec, "nl"))
 
     # ⚠️ A WARNING, NOT A REFUSAL, AND THE ASYMMETRY IS DELIBERATE. §11.4 says a
     # site with no price data falls back to the static profile; a dynamic site
@@ -1657,13 +1688,16 @@ def _price_problems(opts: dict, notes: list | None = None) -> list[str]:
             "fallback.", pid)
         _advise(notes, "warn", ("static_profile",),
                 f"{S('static_profile')} is empty, so the site has no tariff "
-                "at all while the price feed is down.")
+                "at all while the price feed is down.",
+                nl=f"{SN('static_profile')} is leeg, dus de installatie heeft "
+                "helemaal geen tarief zolang de prijsfeed uitvalt.")
 
     # PRICE-01: not a fault, so an info note and no log line here (the add-on
     # logs it once at start). With `price_service` the fixed tariff is only the
     # plan's last fallback; the cheap window and the gate do not read it.
     if pid == "price_service" and str(opts.get("static_profile", "") or "").strip():
-        _advise(notes, "info", ("static_profile",), messages.FIXED_TARIFF_NOTE)
+        _advise(notes, "info", ("static_profile",), messages.FIXED_TARIFF_NOTE,
+                nl=messages.FIXED_TARIFF_NOTE_NL)
 
     # ⚠️ OPT-04. THE THREE WAYS `arbitrage_enabled: true` CAN BE A LIE, refused
     # rather than logged, because a strategy that is armed in the UI and cannot
@@ -1735,7 +1769,11 @@ def _price_problems(opts: dict, notes: list | None = None) -> list[str]:
     return problems
 
 
-def _card_note(option: str, spec) -> str:
+def _card_note(option: str, spec, lang: str = "en") -> str:
+    if lang == "nl":
+        return (f"{SN(option)} gebruikt een tariefkaart van "
+                f"{spec.card_month}, dus neem de nieuwe cijfers over als uw "
+                "contract veranderde.")
     return (f"{S(option)} uses a tariff card dated {spec.card_month}, so copy "
             "the new figures if your contract changed.")
 
@@ -1810,7 +1848,10 @@ def config_notes(opts: dict, *, entities: dict | None = None,
     if month_peak_w is not None and cap is not None and cap < month_peak_w:
         _advise(notes, "warn", ("peak_cap_w",),
                 f"This month's peak is already {messages.watts(month_peak_w)}, "
-                f"so a lower {S('peak_cap_w')} saves nothing until next month.")
+                f"so a lower {S('peak_cap_w')} saves nothing until next month.",
+                nl=f"De piek van deze maand is al "
+                f"{messages.watts(month_peak_w)}, dus een lagere "
+                f"{SN('peak_cap_w')} bespaart niets tot volgende maand.")
     return notes
 
 
@@ -1823,31 +1864,43 @@ def _entity_notes(notes, opts: dict, entities: dict, bad=()) -> None:
         if row is None:
             _advise(notes, "bad" if key in bad else "warn", (key,),
                     f"Home Assistant has no entity {entity}, which "
-                    f"{S(key, where)} names.")
+                    f"{S(key, where)} names.",
+                    nl=f"Home Assistant heeft geen entiteit {entity}, terwijl "
+                    f"{SN(key, where)} die noemt.")
             continue
         unit = str(row.get("unit") or "")
         if key in WATT_ENTITY_KEYS and unit in pv.WATTS_PER and unit != "W":
             _advise(notes, "warn", (key,),
                     f"{entity} reads in {unit}, but {S(key, where)} is "
-                    "taken as watts, so pick a sensor in W.")
+                    "taken as watts, so pick a sensor in W.",
+                    nl=f"{entity} meldt in {unit}, maar {SN(key, where)} wordt "
+                    "als watt gelezen, dus kies een sensor in W.")
         if key == "peak_forecast_entity" and unit not in pv.WATTS_PER:
             _advise(notes, "warn", (key,),
                     messages.peak_forecast_unit(unit) + " Pick a sensor in "
-                    "W or kW.")
+                    "W or kW.",
+                    nl=messages.peak_forecast_unit(unit, "nl")
+                    + " Kies een sensor in W of kW.")
         if key in FORECAST_KEYS and unit not in solarfc.KWH_PER:
             _advise(notes, "warn", (key,),
                     f"{entity} does not read in kWh, so pick a solar "
-                    "forecast sensor in kWh.")
+                    "forecast sensor in kWh.",
+                    nl=f"{entity} meldt niet in kWh, dus kies een sensor voor "
+                    "de zonneprognose in kWh.")
     today = solarfc.entities(opts)
     tomorrow = solarfc.entities(opts, tomorrow=True)
     if (today or tomorrow) and \
             opts.get("battery_modes_enabled") is not True:
         _advise(notes, "info", ("pv_forecast_entity",),
-                "The solar forecast is used only with battery modes on.")
+                "The solar forecast is used only with battery modes on.",
+                nl="De zonneprognose wordt alleen gebruikt met batterijmodi "
+                "aan.")
     if tomorrow and not today:
         _advise(notes, "warn", ("pv_forecast_tomorrow_entity",),
                 "Tomorrow's forecast is used only with today's, so set "
-                f"{S('pv_forecast_entity')} too.")
+                f"{S('pv_forecast_entity')} too.",
+                nl="De prognose voor morgen wordt alleen met die van vandaag "
+                f"gebruikt, dus stel ook {SN('pv_forecast_entity')} in.")
 
 
 # --------------------------------------------------------------------------- #
@@ -1926,7 +1979,9 @@ def setup_checks(opts: dict, *, entities: dict | None, running=None,
     if entities is None:
         # Red: only the list can tell a missing power request entity (SAFETY-77).
         _advise(notes, "bad", ("setpoint_entity",), "Home Assistant is not "
-                "answering, so press Check again once it is back.")
+                "answering, so press Check again once it is back.",
+                nl="Home Assistant antwoordt niet, dus druk op Opnieuw "
+                "nakijken zodra het terug is.")
     else:
         # A missing meter entity is red too (UX-15): with the kettle test
         # skipped, nothing else on the way to the save would catch it.
@@ -1948,13 +2003,16 @@ def setup_checks(opts: dict, *, entities: dict | None, running=None,
                 solar.append(None)
                 _advise(notes, "warn", ("pv_invert_entities",),
                         f"{entity} reads below zero now, so turn on its "
-                        "“Reads negative” switch in the Solar step.")
+                        "“Reads negative” switch in the Solar step.",
+                        nl=f"{entity} meet nu onder nul, dus zet de schakelaar "
+                        "“Meet negatief” aan bij de stap Zonnepanelen.")
             else:
                 w = -w if entity in flipped else w
                 solar.append(w)
                 _advise(notes, "ok", ("pv_entity",),
                         f"{entity} reads {_signed(w)} of solar production "
-                        "now.")
+                        "now.",
+                        nl=f"{entity} meet nu {_signed(w)} zonneproductie.")
     # A battery sensor that reads the wrong way while giving power makes the
     # house use less than nothing. Only with every term known: a missing
     # solar reading could be the difference.
@@ -1964,7 +2022,10 @@ def setup_checks(opts: dict, *, entities: dict | None, running=None,
         _advise(notes, "warn", ("batt_invert",),
                 f"The readings add up to {_signed(sum(known))} of house "
                 "use, so check each "
-                "battery's “Battery power sign is reversed” switch in step 2.")
+                "battery's “Battery power sign is reversed” switch in step 2.",
+                nl=f"De metingen tellen op tot {_signed(sum(known))} "
+                "huisverbruik, dus controleer bij elke batterij de schakelaar "
+                "“Teken batterijvermogen omkeren” in stap 2.")
     _price_check(notes, opts, running, prices_known)
     return notes
 
@@ -1988,7 +2049,9 @@ def _meter_check(notes, opts, entities, running, meter_now_w):
             return float(meter_now_w)
         _advise(notes, "info", ("meter_source",), "The add-on reads "
                 "this meter itself, so Home shows its reading after "
-                "the restart.")
+                "the restart.",
+                nl="De add-on leest deze meter zelf, dus Start toont de "
+                "meting na de herstart.")
         return None
     if entities is None:
         return None
@@ -2001,7 +2064,9 @@ def _meter_check(notes, opts, entities, running, meter_now_w):
         if w is None:
             _advise(notes, "warn", ("meter_source",),
                     f"{entity} reads {text} now, so check it in Home "
-                    "Assistant before you start.")
+                    "Assistant before you start.",
+                    nl=f"{entity} meldt nu {text}, dus controleer ze in Home "
+                    "Assistant voor u start.")
             return None
         total += sign * w
     if source == "off" and opts.get("meter_invert"):
@@ -2012,12 +2077,14 @@ def _meter_check(notes, opts, entities, running, meter_now_w):
 
 def _meter_line(notes, w) -> None:
     if abs(w) < 1.0:
-        text = "The meter reads 0 W now."
+        text, nl = "The meter reads 0 W now.", "De meter meldt nu 0 W."
     elif w > 0:
         text = f"The meter reads {messages.watts(w)} taken from the grid now."
+        nl = f"De meter meldt nu {messages.watts(w)} afname van het net."
     else:
         text = f"The meter reads {messages.watts(w)} fed into the grid now."
-    _advise(notes, "ok", ("meter_source",), text)
+        nl = f"De meter meldt nu {messages.watts(w)} injectie op het net."
+    _advise(notes, "ok", ("meter_source",), text, nl=nl)
 
 
 def _card_checks(notes, who, entry, entities):
@@ -2025,40 +2092,55 @@ def _card_checks(notes, who, entry, entities):
     positive while giving power, or None when it is not known."""
     if entities is None:
         return None
+    wie = who.replace(" for ", " voor ", 1)
     setpoint = str(entry.get("setpoint_entity") or "").strip()
     if setpoint and setpoint in entities:
         _advise(notes, "ok", ("setpoint_entity",),
                 f"Home Assistant has {setpoint}, the power request "
-                f"entity{who}.")
+                f"entity{who}.",
+                nl=f"Home Assistant heeft {setpoint}, de entiteit voor de "
+                f"vermogensvraag{wie}.")
     soc = str(entry.get("soc_entity") or "").strip()
     if not soc:
         _advise(notes, "warn", ("soc_entity",), f"There is no battery "
                 f"level entity{who}, so pick one in step 2 or the add-on "
-                "holds 0 W.")
+                "holds 0 W.",
+                nl=f"Er is geen entiteit voor het laadniveau{wie}, dus kies er "
+                "een in stap 2 of de add-on houdt 0 W aan.")
     elif soc in entities:
         level, _unit = _reading(entities, soc)
         if level is None or not 0.0 <= level <= 100.0:
             _advise(notes, "warn", ("soc_entity",), f"The battery "
-                    f"level{who} reads nothing now, so check {soc}.")
+                    f"level{who} reads nothing now, so check {soc}.",
+                    nl=f"Het laadniveau{wie} meldt niets, dus controleer "
+                    f"{soc}.")
         else:
             _advise(notes, "ok", ("soc_entity",),
-                    f"The battery level{who} reads {level:.0f} %.")
+                    f"The battery level{who} reads {level:.0f} %.",
+                    nl=f"Het laadniveau{wie} meldt {level:.0f} %.")
     batt = str(entry.get("batt_entity") or "").strip()
     if batt and batt in entities:
         w, _unit = _reading(entities, batt)
         if w is None:
             _advise(notes, "warn", ("batt_entity",), f"The battery "
-                    f"power{who} reads nothing now, so check {batt}.")
+                    f"power{who} reads nothing now, so check {batt}.",
+                    nl=f"Het batterijvermogen{wie} meldt niets, dus controleer "
+                    f"{batt}.")
             return None
         w = -w if entry.get("batt_invert") else w
         if abs(w) < IDLE_W:
             _advise(notes, "info", ("batt_entity",), f"The battery{who} is "
-                    "idle now, so check its direction on Home later.")
+                    "idle now, so check its direction on Home later.",
+                    nl=f"De batterij{wie} staat nu stil, dus controleer later "
+                    "op Start de richting.")
         else:
             doing = "giving power" if w > 0 else "charging"
+            doet = "levert" if w > 0 else "laadt"
             _advise(notes, "info", ("batt_invert",),
                     f"The battery{who} reads {messages.watts(w)} {doing} "
-                    "now, so check the inverter shows the same.")
+                    "now, so check the inverter shows the same.",
+                    nl=f"De batterij{wie} {doet} nu {messages.watts(w)}, dus "
+                    "controleer of de omvormer hetzelfde toont.")
         return w
     return None
 
@@ -2070,20 +2152,28 @@ def _price_check(notes, opts, running, prices_known) -> None:
         if profile:
             _advise(notes, "ok", ("static_profile",),
                     "Your prices come from your contract, so they are "
-                    "always known.")
+                    "always known.",
+                    nl="Uw prijzen komen uit uw contract, dus ze zijn altijd "
+                    "bekend.")
         else:
             _advise(notes, "info", ("price_provider",),
                     "No prices are set, so the batteries do not charge "
-                    "on price.")
+                    "on price.",
+                    nl="Er zijn geen prijzen ingesteld, dus de batterijen "
+                    "laden niet op prijs.")
         return
     same = (isinstance(running, dict)
             and str(running.get("price_provider") or "") == provider)
     if same and prices_known:
         _advise(notes, "ok", ("price_provider",),
-                f"Prices for today are in, for {prices_known} of 24 hours.")
+                f"Prices for today are in, for {prices_known} of 24 hours.",
+                nl=f"De prijzen van vandaag zijn binnen, voor {prices_known} "
+                "van 24 uur.")
     else:
         _advise(notes, "info", ("price_provider",),
-                "Prices are fetched after the restart, and Home shows them.")
+                "Prices are fetched after the restart, and Home shows them.",
+                nl="De prijzen worden na de herstart opgehaald, en Start toont "
+                "ze.")
 
 
 def _margin_problems(opts: dict) -> list[str]:
diff --git a/goodwe_controller/app/web.py b/goodwe_controller/app/web.py
index 77093dd..4d578d6 100644
--- a/goodwe_controller/app/web.py
+++ b/goodwe_controller/app/web.py
@@ -51,7 +51,7 @@ from aiohttp import web
 from . import messages, price, selfconfig, uipage, uitext
 from .haentities import EntityCache
 from .homeview import priced_hours, region_of
-from .validate import config_notes, setup_checks
+from .validate import config_notes, note_text, setup_checks
 from .config_page import CONFIG_PAGE
 from .configui import (changed_keys, field_model, hide_secrets, keep_secrets,
                        problems_by_field, secret_keys)
@@ -105,6 +105,9 @@ def page() -> str:
 DEVICE_NOTE = (
     "%s did not report its power range, so two checks were skipped, here and "
     "at start. If they fail later, the add-on will not start then.")
+DEVICE_NOTE_NL = (
+    "%s meldde geen vermogensbereik, dus twee controles zijn overgeslagen, "
+    "hier en bij het starten. Falen ze later, dan start de add-on dan niet.")
 
 
 def build_app(controller, selfcfg=None) -> web.Application:
@@ -301,22 +304,27 @@ def build_app(controller, selfcfg=None) -> web.Application:
         # UX-13: warnings and info beside the refusals. Never block a save.
         # The entity checks use the picker's cached list and never wait on HA.
         notes += config_notes(options, entities=entities.peek())
+        # UX-46: one language choice for everything below that has words.
+        lang = uitext.lang_of(_body.get("lang"))
         payload = {"problems": problems, "by_key": by_key,
                    "unanchored": unanchored,
                    "notes": [n._asdict() for n in notes]}
         if unread:
-            payload["device_note"] = DEVICE_NOTE % ", ".join(sorted(set(unread)))
+            payload["device_note"] = (DEVICE_NOTE_NL if lang == "nl"
+                                      else DEVICE_NOTE) % ", ".join(
+                                          sorted(set(unread)))
         if model is not None:
             payload["messages"] = (
                 uipage.derive_messages(errors, problems, notes, model,
-                                       _keys_of(options),
-                                       uitext.lang_of(_body.get("lang")))
+                                       _keys_of(options), lang)
                 if errors
                 else uipage.anchors(problems, notes, model, _keys_of(options),
-                                    uitext.lang_of(_body.get("lang"))))
+                                    lang))
             payload["steps"] = uipage.step_problems(payload["messages"], model)
         if _body.get("setup"):
-            payload["setup"] = [n._asdict() for n in await _setup_checks(options)]
+            payload["setup"] = [
+                dict(n._asdict(), text=note_text(n, lang))
+                for n in await _setup_checks(options)]
         return web.json_response(payload)
 
     async def _setup_checks(options):
diff --git a/goodwe_controller/test_ux46.py b/goodwe_controller/test_ux46.py
new file mode 100644
index 0000000..24c2f31
--- /dev/null
+++ b/goodwe_controller/test_ux46.py
@@ -0,0 +1,578 @@
+"""UX-46: the Dutch pages show Dutch status rows, notes and wizard lines.
+`python3 -B test_ux46.py`
+
+Before this, Home's status rows, the settings page's notes and the setup
+wizard's checks were built in English and sent as they were, so the NL pages
+showed English under Dutch titles (SAFETY-118 I-1, UX-44 I-2, UX-45 I-3).
+
+1. Rows: every row in `messages.status_samples()` carries a Dutch twin
+   (`messages.Bi`), the Dutch follows STYLE.md, and the Home page's status
+   payload gives it for lang=nl and the English text for everything else.
+2. Notes: every `_advise()` call in app/validate.py gives a Dutch twin, the
+   notes the validator really builds carry it, and /config/validate sends the
+   page's language, for the settings notes and for the wizard's check list.
+3. The setting labels the Dutch notes quote are the labels in nl.yaml, and the
+   peak forecast label has no "(W)", since any power unit is read.
+4. The rules above catch spoiled input.
+"""
+
+import ast
+import asyncio
+import copy
+import json
+import logging
+import os
+import re
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+
+from aiohttp import ClientSession, web as aioweb
+
+HERE = Path(__file__).resolve().parent
+sys.path.insert(0, str(HERE / "tools"))
+logging.disable(logging.WARNING)
+
+import translations_lint as TL                                  # noqa: E402
+import ux13_demo as D                                           # noqa: E402
+from style_rules import sentences, text_problems, words        # noqa: E402
+from app import messages, uimodel as U, uitext, web             # noqa: E402
+from app.main import Controller                                 # noqa: E402
+from app.validate import (Note, note_text, setup_checks,        # noqa: E402
+                          config_notes)
+
+fails = []
+
+
+def check(name, cond):
+    print(f"  {'ok  ' if cond else 'FAIL'} {name}")
+    if not cond:
+        fails.append(name)
+
+
+# STYLE.md for a Dutch row or note: the same length and shape rules, plus the
+# Dutch words that test_ui_text.py bans for the same things. A quoted setting
+# label may keep its own words ("Setpoint-entiteit" is the label in nl.yaml).
+JARGON_NL = re.compile(
+    r"\b(?:setpoints?|setpunt\w*|SoC|laadtoestand|BMS|PV|failsafe|regelaar|"
+    r"regellus|controller|latch|ontlad\w*|payload|endpoint|JSON|API|"
+    r"time-?out|boolean|config|kwartuur\w*|commando\w*|geparkeerd|ESP32|"
+    r"master)\b", re.I)
+# English function words that never belong in a Dutch sentence.
+ENGLISH = re.compile(r"\b(?:the|not|and|for|with|from|reads|check|so|no|set|"
+                     r"keeps|stays|has|have|ran|ago|seconds?|minutes?)\b", re.I)
+QUOTED = re.compile(r"“[^”]*”")
+
+
+def dutch_problems(text):
+    bare = re.sub(r"\b[a-z_]+\.[a-z0-9_]+\b", "X", QUOTED.sub("X", text))
+    out = []
+    if JARGON_NL.search(bare):
+        out.append("jargon: " + JARGON_NL.search(bare).group(0))
+    names = re.sub(r"\binverter-[a-z0-9]+\b|\b[a-z_]+\.[a-z0-9_]+\b", "X",
+                   bare)
+    eng = ENGLISH.search(names)
+    if eng:
+        out.append("English word: " + eng.group(0))
+    return out
+
+
+def row_problems_nl(colour, text):
+    n_s, n_w = sentences(text), len(words(text))
+    out = []
+    if colour == messages.RED:
+        if n_s > 3 or n_w > 30:
+            out.append(f"red row over 3 sentences / 30 words ({n_s}/{n_w})")
+    elif n_s > 1 or n_w > 15:
+        out.append(f"row over 1 sentence / 15 words ({n_s}/{n_w})")
+    if ";" in text:
+        out.append("semicolon")
+    return out + text_problems(text, keys=False, entities=False) \
+        + dutch_problems(text)
+
+
+# --------------------------------------------------------------------------- #
+print("1. every status row has a Dutch twin, and the page picks one")
+# --------------------------------------------------------------------------- #
+ROWS = [(fn, c, t) for fn, c, t in messages.status_samples() if c is not None]
+check(f"there are rows to grade ({len(ROWS)})", len(ROWS) > 80)
+_none = [(fn, str(t)) for fn, c, t in ROWS
+         if not (isinstance(t, messages.Bi) and t.nl)]
+check(f"every row has a Dutch text ({_none})", not _none)
+_same = [(fn, str(t)) for fn, c, t in ROWS
+         if isinstance(t, messages.Bi) and t.nl == str(t)]
+check(f"no Dutch row is the English one ({_same})", not _same)
+_bad = [(fn, p) for fn, c, t in ROWS if isinstance(t, messages.Bi) and t.nl
+        for p in row_problems_nl(c, t.nl)]
+for x in _bad:
+    print(f"       STYLE  {x}")
+check(f"every Dutch row follows STYLE.md ({len(_bad)} problems)", not _bad)
+BANNERS = [(fn, t) for fn, c, t in messages.status_samples() if c is None]
+_nob = [(fn, str(t)) for fn, t in BANNERS
+        if not (isinstance(t, messages.Bi) and t.nl and t.nl != str(t))]
+check(f"every banner has a Dutch text ({_nob})", BANNERS and not _nob)
+_bb = [(fn, t.nl) for fn, t in BANNERS if isinstance(t, messages.Bi) and t.nl
+       and (len(words(t.nl)) > 12 or ";" in t.nl or dutch_problems(t.nl)
+            or text_problems(t.nl, keys=False, entities=False))]
+check(f"every Dutch banner is at most 12 words and follows STYLE.md ({_bb})",
+      not _bb)
+_cat = {k for k, v in vars(messages).items()
+        if callable(v) and k.startswith("row_")}
+check("the samples cover every row_ function, so none can skip the check",
+      _cat <= {fn for fn, _c, _t in ROWS})
+_lat = {"row_direction_trip": "herstart heft dit niet op",
+        "row_site_direction_trip": "regeling starten heft dit op",
+        "row_circulating_trip": "regeling starten heft dit op",
+        "row_not_delivering": "stoppen en starten heft dit op"}
+_unclear = [fn for fn, _c, t in ROWS if fn in _lat and _lat[fn] not in t.nl]
+check(f"a Dutch latch row says how it clears too ({_unclear})", not _unclear)
+check("pick() gives the English for en, the Dutch for nl, and leaves other "
+      "text alone",
+      messages.pick(messages.row_estop_fitted(), "en") == "Emergency stop: fitted"
+      and type(messages.pick(messages.row_estop_fitted(), "en")) is str
+      and messages.pick(messages.row_estop_fitted(), "nl") == "Noodstop: geplaatst"
+      and messages.pick("Plain", "nl") == "Plain"
+      and messages.pick(messages.Bi("A"), "nl") == "A")
+check("a Bi survives copy and pickle, and JSON",
+      copy.deepcopy(messages.row_estop_fitted()).nl == "Noodstop: geplaatst"
+      and json.dumps(messages.row_estop_fitted()) == '"Emergency stop: fitted"')
+
+
+# --- the page: a real Controller -------------------------------------------- #
+class _Store:
+    def __init__(self):
+        self.data = {}
+
+    def set(self, k, v):
+        self.data[k] = v
+
+    def get(self, k, d=None):
+        return self.data.get(k, d)
+
+    def set_time(self, k, v):
+        self.data[k] = v.isoformat()
+
+    def get_time(self, k):
+        v = self.data.get(k)
+        return None if v is None else datetime.fromisoformat(v)
+
+
+class _Pub:
+    enabled = False
+
+    def publish(self, _v):
+        pass
+
+    def close(self):
+        pass
+
+
+class _Hass:
+    session = None
+    token = ""
+
+    async def limits(self, _e):
+        return (-5000.0, 5000.0, 1.0)
+
+    async def number(self, _e, invert=False):
+        return None
+
+    async def state(self, _e):
+        return None
+
+    async def set_number(self, _e, _v):
+        return True
+
+    async def call(self, *_a):
+        return True
+
+    async def states(self):
+        return []
+
+
+ONE = {"setpoint_entity": "number.sp", "meter_entity": "sensor.grid",
+       "soc_entity": "sensor.soc", "batt_entity": "sensor.batt",
+       "meter_source": "off", "max_w": 5000, "shadow_mode": "off",
+       "maintenance_enabled": False, "peak_forecast_entity": "sensor.fc"}
+TWO = dict(ONE, inverters=[
+    {"name": "Battery A", "setpoint_entity": "number.a", "soc_entity":
+     "sensor.soc_a", "batt_entity": "sensor.batt_a", "max_w": 2500},
+    {"name": "Battery B", "setpoint_entity": "", "soc_entity":
+     "sensor.soc_b", "batt_entity": "sensor.batt_b", "max_w": 2500}])
+
+
+def make(opts, soc=(62.0, 35.0), batt=(-2500.0, -300.0)):
+    c = Controller(dict(opts), _Hass(), _Store(), _Pub(), stop=asyncio.Event())
+    c.auto = True
+    for i, inv in enumerate(c.inverters):
+        inv.soc, inv.batt = soc[i], batt[i]
+        inv.dev_min, inv.dev_max = -5000.0, 5000.0
+    c.grid = 10.0
+    return c
+
+
+def attention(payload, rid):
+    return next((a for a in payload["attention"] if a["id"] == rid), None)
+
+
+c = make(ONE, soc=(62.0,), batt=(960.0,))
+c._peak_fc_fault = "kWh"
+s_en, s_nl = c.status_payload(), c.status_payload(lang="nl")
+_en = next(r for r in s_en["checks"] if r.get("id") == "peak_forecast")
+_nl = next(r for r in s_nl["checks"] if r.get("id") == "peak_forecast")
+check("Home, English: the peak forecast row is the English sentence",
+      _en["text"] == messages.peak_forecast_unit("kWh")
+      and attention(s_en, "peak_forecast")["body"]
+      == messages.peak_forecast_unit("kWh"))
+check("Home, Dutch: the row, the Needs-attention entry and the title are "
+      "Dutch",
+      _nl["text"] == messages.peak_forecast_unit("kWh", "nl")
+      and attention(s_nl, "peak_forecast")["body"]
+      == messages.peak_forecast_unit("kWh", "nl")
+      and attention(s_nl, "peak_forecast")["title"]
+      == uitext.words("nl")["home_words"]["attn"]["peak_forecast"])
+c._peak_fc_fault = ""
+_nl0 = next(r for r in c.status_payload(lang="nl")["checks"]
+            if r.get("id") == "peak_forecast")
+check("...and with no unit at all, the Dutch is the 'no unit' sentence",
+      _nl0["text"] == messages.peak_forecast_unit("", "nl")
+      and messages.peak_forecast_unit("", "nl")
+      != messages.peak_forecast_unit("kWh", "nl"))
+check("a language that is not Dutch gets the English, and the default call "
+      "is unchanged",
+      c.status_payload(lang="fr")["checks"] == c.status_payload()["checks"]
+      and all(type(r["text"]) is str for r in c.status_payload()["checks"]))
+
+# A site with faults of many kinds: every row it shows is Dutch on the NL page.
+SCEN = {}
+SCEN["two, one without a setpoint, meter stale"] = make(TWO)
+SCEN["one, nothing read"] = make(ONE, soc=(None,), batt=(None,))
+SCEN["one, no forecast set"] = make(dict(ONE, peak_forecast_entity=""))
+SCEN["one, shadow, estop fitted"] = make(dict(ONE, shadow_mode="on",
+                                              estop_fitted=True))
+SCEN["one, solar sources"] = make(dict(ONE, pv_entity="sensor.pv"))
+SCEN["two, solar list"] = make(dict(TWO, pv_entities=["sensor.a", "sensor.b"]))
+SCEN["one, peak forecast unit fault"] = c
+SCEN["one, control stopped"] = make(ONE)
+SCEN["one, control stopped"].auto = False
+_English, _rows_seen = [], 0
+for name, ctl in SCEN.items():
+    raw = ctl.checks()
+    en = ctl.status_payload()["checks"]
+    nl = ctl.status_payload(lang="nl")["checks"]
+    check(f"[{name}] {len(raw)} rows: same rows in both languages",
+          len(raw) == len(en) == len(nl))
+    for r, e, n in zip(raw, en, nl):
+        _rows_seen += 1
+        if not (isinstance(r["text"], messages.Bi) and r["text"].nl):
+            _English.append((name, r.get("id"), str(r["text"])))
+        elif e["text"] != str(r["text"]) or n["text"] != r["text"].nl:
+            _English.append((name, r.get("id"), "page did not pick"))
+_banners = {n: (ctl.status_payload()["banner"],
+                ctl.status_payload(lang="nl")["banner"])
+            for n, ctl in SCEN.items()}
+print(f"    banners: {_banners}")
+check("the banner at the top of Home is Dutch on the Dutch page, English on "
+      "the English one", all(e != n and not dutch_problems(n)
+                             for e, n in _banners.values()))
+check(f"{_rows_seen} rows over {len(SCEN)} sites: none shows English on the "
+      f"Dutch page when it has no Dutch text ({_English})", not _English)
+check("the row's details list in /status is picked the same way",
+      all(isinstance(v, str) and not isinstance(v, messages.Bi)
+          for ctl in SCEN.values()
+          for _k, v in ctl.status_payload(lang="nl")["rows"]))
+
+# --------------------------------------------------------------------------- #
+print("\n2. every settings note and wizard line has a Dutch twin")
+# --------------------------------------------------------------------------- #
+tree = ast.parse((HERE / "app" / "validate.py").read_text(encoding="utf-8"))
+_calls = [n for n in ast.walk(tree) if isinstance(n, ast.Call)
+          and ast.unparse(n.func) == "_advise"]
+_bare = [n.lineno for n in _calls if not any(k.arg == "nl" for k in n.keywords)]
+check(f"every _advise() call in validate.py gives `nl` ({len(_calls)} calls, "
+      f"without: {_bare})", len(_calls) >= 30 and not _bare)
+
+OPTS = dict(D.defaults(D.CONFIG), setpoint_entity="number.sp",
+            meter_entity="sensor.grid", soc_entity="sensor.soc",
+            batt_entity="sensor.batt", pv_entity="sensor.pv",
+            peak_forecast_entity="sensor.fc")
+
+
+def ent(state, unit=None):
+    return {"state": state, "unit": unit}
+
+
+GOOD = {"number.sp": ent("0"), "sensor.grid": ent("402", "W"),
+        "sensor.soc": ent("62", "%"), "sensor.batt": ent("-800", "W"),
+        "sensor.pv": ent("-1200", "W"), "sensor.fc": ent("820", "kWh")}
+NOTES = []
+NOTES += setup_checks(OPTS, entities=GOOD, running=None)
+NOTES += setup_checks(OPTS, entities=None)
+NOTES += setup_checks(dict(OPTS, meter_invert=True, pv_invert_entities=["sensor.pv"]),
+                      entities=dict(GOOD, **{"sensor.batt": ent("0", "W")}))
+NOTES += setup_checks(dict(OPTS, soc_entity="sensor.x", batt_entity="sensor.y",
+                           setpoint_entity="number.typo"),
+                      entities=GOOD)
+NOTES += setup_checks(dict(OPTS, meter_source="homewizard_local"),
+                      entities=GOOD, running=None)
+NOTES += setup_checks(dict(OPTS, meter_source="homewizard_local",
+                           price_provider="generic_dayahead"),
+                      entities=GOOD, running=dict(OPTS, meter_source="homewizard_local",
+                                                  price_provider="generic_dayahead"),
+                      meter_now_w=-350.0, prices_known=18)
+NOTES += setup_checks(dict(OPTS, price_provider="generic_dayahead"), entities=GOOD,
+                      running=None)
+NOTES += setup_checks(dict(OPTS, price_provider="off", static_profile=""),
+                      entities=GOOD)
+NOTES += setup_checks(dict(OPTS, price_provider="off",
+                           static_profile='{"periods":[]}'), entities=GOOD)
+NOTES += setup_checks(dict(OPTS, batt_entity="sensor.batt2"),
+                      entities=dict(GOOD, **{"sensor.batt2": ent("unavailable")}))
+NOTES += setup_checks(dict(OPTS, soc_entity="sensor.soc2"),
+                      entities=dict(GOOD, **{"sensor.soc2": ent("unavailable")}))
+NOTES += setup_checks(dict(OPTS, meter_entity="sensor.m2"),
+                      entities=dict(GOOD, **{"sensor.m2": ent("unavailable")}))
+_TWO = dict(OPTS, inverters=[
+    {"name": "a", "setpoint_entity": "number.sp", "soc_entity": "sensor.soc",
+     "batt_entity": "sensor.batt", "max_w": 2000, "bms_soc_floor": 10},
+    {"name": "b", "setpoint_entity": "number.b", "max_w": 2000,
+     "bms_soc_floor": 10}])
+NOTES += setup_checks(_TWO, entities=dict(GOOD, **{"sensor.batt": ent("-0.5", "kW")}))
+NOTES += setup_checks(dict(OPTS, meter_source="ha_signed",
+                           p1_net_entity="sensor.net"),
+                      entities=dict(GOOD, **{"sensor.net": ent("-3.1", "kW")}))
+NOTES += config_notes(dict(OPTS, integrator_max_w=9000, max_w=2000,
+                           peak_cap_w=2000), entities=GOOD, month_peak_w=3000)
+NOTES += config_notes(dict(OPTS, pv_forecast_entity="sensor.f1",
+                           pv_forecast_tomorrow_entity="sensor.f2",
+                           peak_forecast_entity="sensor.fc2"),
+                      entities=dict(GOOD, **{"sensor.f1": ent("5", "W"),
+                                             "sensor.f2": ent("6", "kWh"),
+                                             "sensor.fc2": ent("5")}))
+NOTES += config_notes(dict(OPTS, meter_entity="sensor.gone"), entities=GOOD)
+NOTES += config_notes(dict(OPTS, pv_forecast_tomorrow_entity="sensor.f2"),
+                      entities=dict(GOOD, **{"sensor.f2": ent("6", "kWh")}))
+NOTES += config_notes(dict(OPTS, batt_entity="sensor.kw"),
+                      entities=dict(GOOD, **{"sensor.kw": ent("1", "kW")}))
+print(f"    {len(NOTES)} notes built")
+_nonl = [n.text for n in NOTES if not n.nl]
+check(f"every note the validator builds has a Dutch twin ({_nonl})",
+      NOTES and not _nonl)
+_same = [n.text for n in NOTES if n.nl == n.text]
+check(f"...which is not the English ({_same})", not _same)
+_bad = []
+for n in NOTES:
+    nw, ns = len(words(n.nl)), sentences(n.nl)
+    p = text_problems(n.nl, keys=True, entities=True) + dutch_problems(n.nl)
+    if nw > 25 and not n.text.startswith(("The 15-minute", "Home Assistant")):
+        p.append(f"over 25 words ({nw})")
+    if ns > 2:
+        p.append(f"over 2 sentences ({ns})")
+    if ";" in n.nl:
+        p.append("semicolon")
+    if len(words(n.nl)) > len(words(n.text)) + 6:
+        p.append("much longer than the English")
+    _bad += [(n.nl, x) for x in p]
+for x in _bad:
+    print(f"       STYLE  {x}")
+check(f"every Dutch note follows STYLE.md ({len(_bad)} problems)", not _bad)
+_l = {t: [n for n in NOTES if n.text.startswith(t)] for t in (
+    "Prices for today are in", "The 15-minute demand forecast")}
+check("the wizard's price line, and the peak forecast unit note, are among "
+      "them", all(_l.values()))
+check("note_text() picks: Dutch for nl, English for en, the old twin table "
+      "for a note with no `nl`",
+      note_text(_l["Prices for today are in"][0], "nl")
+      == "De prijzen van vandaag zijn binnen, voor 18 van 24 uur."
+      and note_text(_l["Prices for today are in"][0], "en")
+      == "Prices for today are in, for 18 of 24 hours."
+      and note_text(Note("info", (), messages.FIXED_TARIFF_NOTE), "nl")
+      == messages.FIXED_TARIFF_NOTE_NL
+      and note_text(Note("info", (), "Other"), "nl") == "Other")
+
+# --- over HTTP: the settings page and the wizard, in both languages --------- #
+SCHEMA = D.schema_ui(D.CONFIG)
+TRANSLATIONS = {l: TL.parse_translation_file(HERE / "translations" / f"{l}.yaml")
+                for l in ("en", "nl")}
+STATES = [{"entity_id": e, "state": v["state"],
+           "attributes": ({"unit_of_measurement": v["unit"]} if v["unit"]
+                          else {})} for e, v in GOOD.items()]
+
+
+class Hass:
+    session = None
+    token = ""
+
+    async def limits(self, _e):
+        return (-5000.0, 5000.0, 1.0)
+
+    async def states(self):
+        return copy.deepcopy(STATES)
+
+    async def state(self, entity):
+        return next((copy.deepcopy(s) for s in STATES
+                     if s["entity_id"] == entity), None)
+
+
+class Supervisor:
+    def __init__(self, options):
+        self.options = copy.deepcopy(options)
+
+    async def info(self):
+        return {"options": copy.deepcopy(self.options), "schema": SCHEMA,
+                "translations": TRANSLATIONS}
+
+    async def write_options(self, options):
+        pass
+
+    async def restart(self, confirm):
+        pass
+
+
+class Ctl:
+    def __init__(self, opts):
+        self.o, self.hass, self.inverters = dict(opts), Hass(), []
+        self.store, self.auto, self.grid = None, True, 402.0
+
+    def log_event(self, text, hint=None):
+        pass
+
+    def status_payload(self, lang="en"):
+        return {"banner": "", "level": "ok", "rows": [], "checks": [],
+                "plan": {"prices": [{"label": f"{h:02d}:00", "eur_kwh": 0.2}
+                            for h in range(20)]
+                         + [{"label": f"{h:02d}:00", "eur_kwh": None}
+                            for h in range(20, 24)]}}
+
+
+async def serve(opts, steps):
+    runner = aioweb.AppRunner(web.build_app(Ctl(opts), Supervisor(opts)))
+    await runner.setup()
+    site = aioweb.TCPSite(runner, "127.0.0.1", 0)
+    await site.start()
+    root = f"http://127.0.0.1:{site._server.sockets[0].getsockname()[1]}/"
+    try:
+        async with ClientSession() as s:
+            return await steps(s, root)
+    finally:
+        await runner.cleanup()
+
+
+async def post(s, url, body):
+    async with s.post(url, json=body) as r:
+        return await r.json()
+
+
+RUN = dict(OPTS, meter_source="homewizard_local", p1_host="192.0.2.50",
+           price_provider="generic_dayahead")
+
+
+async def pages(s, root):
+    out = {}
+    # The settings notes read the entity list the picker has cached, so the
+    # first call only warms it.
+    await post(s, root + "config/validate",
+               {"model": U.options_to_ui(RUN), "setup": True})
+    for lang in ("en", "nl"):
+        async with s.get(root + f"config/model?lang={lang}") as r:
+            m = await r.json()
+        model = U.options_to_ui(RUN)
+        out[lang] = await post(s, root + "config/validate",
+                               {"model": model, "setup": True, "lang": lang})
+    out["none"] = await post(s, root + "config/validate", {
+        "model": U.options_to_ui(RUN), "setup": True})
+    return out
+
+
+R = asyncio.run(serve(RUN, pages))
+_texts = {l: [m["text"] for m in R[l].get("messages", [])] for l in ("en", "nl")}
+_setup = {l: [m["text"] for m in R[l].get("setup", [])] for l in ("en", "nl")}
+FC_EN = messages.peak_forecast_unit("kWh") + " Pick a sensor in W or kW."
+FC_NL = messages.peak_forecast_unit("kWh", "nl") + " Kies een sensor in W of kW."
+print(f"    settings notes en: {_texts['en']}")
+print(f"    settings notes nl: {_texts['nl']}")
+print(f"    wizard lines nl:   {_setup['nl']}")
+check("settings page, English: the peak forecast unit note is English",
+      FC_EN in _texts["en"])
+check("settings page, Dutch: it is the Dutch sentence, and no English "
+      "sentence of it is left", FC_NL in _texts["nl"]
+      and FC_EN not in _texts["nl"])
+check("wizard, English: the price line and the checks are English",
+      "Prices for today are in, for 20 of 24 hours." in _setup["en"])
+check("wizard, Dutch: the price line is Dutch",
+      "De prijzen van vandaag zijn binnen, voor 20 van 24 uur."
+      in _setup["nl"] and "Prices for today are in, for 20 of 24 hours."
+      not in _setup["nl"])
+_left = [t for t in _setup["nl"] + _texts["nl"]
+         if ENGLISH.search(QUOTED.sub("X", t))
+         and not t.startswith("Home Assistant has no entity")]
+check(f"no wizard line or settings note on the Dutch page has English words "
+      f"left ({_left})", not _left)
+check("a request with no language gets English (an old page keeps working)",
+      [m["text"] for m in R["none"].get("setup", [])]
+      == [m["text"] for m in R["en"].get("setup", [])])
+check("the raw `notes` list keeps the English `text` and adds `nl`",
+      R["nl"]["notes"] and all(n["text"] != n["nl"] for n in R["nl"]["notes"]))
+
+# --------------------------------------------------------------------------- #
+print("\n3. labels")
+# --------------------------------------------------------------------------- #
+for lang in ("en", "nl"):
+    name = TRANSLATIONS[lang]["configuration"]["peak_forecast_entity"]["name"]
+    check(f"[{lang}] the peak forecast label has no unit: {name!r}",
+          "(W)" not in name and "(kW)" not in name
+          and name.split("·")[-1].strip() == (
+              "15-minute demand forecast entity" if lang == "en"
+              else "Entiteit kwartierprognose"))
+check("DOCS.md shows the same label, so the table cannot drift",
+      "| Limits | 15-minute demand forecast entity | `peak_forecast_entity` |"
+      in (HERE / "DOCS.md").read_text(encoding="utf-8"))
+
+
+def stems(key):
+    tr = TRANSLATIONS["nl"]["configuration"]
+    out = []
+    for c in (tr, tr["inverters"]["fields"]):
+        if isinstance(c.get(key), dict):
+            n = c[key]["name"].split("·")[-1].strip()
+            while re.search(r"\s*\([^()]*\)$", n):
+                n = re.sub(r"\s*\([^()]*\)$", "", n)
+            out.append(n)
+    return out
+
+
+_drift = sorted(k for k, v in messages.LABELS_NL.items() if v not in stems(k))
+check(f"every Dutch label a note quotes is the setting's name in nl.yaml "
+      f"(drifted: {_drift})", not _drift
+      and set(messages.LABELS_NL) == set(messages.LABELS))
+_unit = sorted(k for k, v in messages.UNIT_LABELS_NL.items() if v not in stems(k))
+check(f"...and so are the two the inverter list names differently ({_unit})",
+      not _unit)
+check("setting() in Dutch keeps the key, so the config panel can find it",
+      messages.setting("max_w", "", "nl") == "“Vermogen van de omvormer” (max_w)"
+      and messages.setting("max_w", "inverter-b", "nl")
+      == "“Vermogen van deze omvormer” voor inverter-b (inverters.max_w)"
+      and messages.setting("max_w") == "“Inverter rating” (max_w)")
+
+# --------------------------------------------------------------------------- #
+print("\n4. the rules catch spoiled input")
+# --------------------------------------------------------------------------- #
+check("a Dutch row left in English is caught",
+      row_problems_nl(messages.AMBER, "Control: last ran 2 seconds ago"))
+check("an over-long Dutch row is caught",
+      row_problems_nl(messages.AMBER, " ".join(["woord"] * 16) + "."))
+check("Dutch jargon is caught", dutch_problems("Het commando is geweigerd"))
+check("a row with no Dutch is caught",
+      not isinstance(messages.pick("x", "nl"), messages.Bi)
+      and not getattr(messages.Bi("x"), "nl"))
+check("the untranslated-call scan sees a bare _advise",
+      any(isinstance(n, ast.Call) and not any(k.arg == "nl" for k in n.keywords)
+          for n in ast.walk(ast.parse('_advise(notes, "warn", (), "x")'))))
+
+print()
+if fails:
+    print(f"{len(fails)} FAILED:")
+    for f in fails:
+        print("  -", f)
+    sys.exit(1)
+print("all passed")
diff --git a/goodwe_controller/translations/en.yaml b/goodwe_controller/translations/en.yaml
index cdaced8..d390d74 100644
--- a/goodwe_controller/translations/en.yaml
+++ b/goodwe_controller/translations/en.yaml
@@ -164,7 +164,7 @@ configuration:
     name: "Limits · Margin below the peak limit (W)"
     description: "The add-on aims this much below the peak limit, so a 15-minute period that ends a little high still stays under it."
   peak_forecast_entity:
-    name: "Limits · 15-minute demand forecast entity (W)"
+    name: "Limits · 15-minute demand forecast entity"
     description: "Optional. A forecast of this 15-minute period's average power, in W or kW. With no power unit it is not used. Leave it empty and there is no peak limit."
   peak_soc_floor:
     name: "Limits · Peak reserve (%)"
diff --git a/goodwe_controller/translations/nl.yaml b/goodwe_controller/translations/nl.yaml
index 0e939d5..3db9bd5 100644
--- a/goodwe_controller/translations/nl.yaml
+++ b/goodwe_controller/translations/nl.yaml
@@ -145,7 +145,7 @@ configuration:
     name: "Grenzen · Marge onder de piekgrens (W)"
     description: "De add-on mikt zoveel onder de piekgrens, zodat een kwartier dat iets hoger uitvalt er toch onder blijft."
   peak_forecast_entity:
-    name: "Grenzen · Entiteit kwartierprognose (W)"
+    name: "Grenzen · Entiteit kwartierprognose"
     description: "Optioneel. Een prognose van het gemiddelde vermogen in het lopende kwartier, in W of kW. Zonder vermogenseenheid wordt ze niet gebruikt. Laat u dit leeg, dan is er geen piekgrens."
   peak_soc_floor:
     name: "Grenzen · Piekreserve (%)"

From c1809b4ca90862691a2bf2bdb8d9032477cb4c9c Mon Sep 17 00:00:00 2001
From: glenn schrooyen <glenn@dsgpartners.be>
Date: Thu, 22 Oct 2026 03:41:18 +0200
Subject: [PATCH 2/3] UX-46: test_ux46 points at MUTATION.md and reads rows
 without raising

Co-Authored-By: Claude <noreply@anthropic.com>
---
 goodwe_controller/test_ux46.py | 19 ++++++++++++-------
 1 file changed, 12 insertions(+), 7 deletions(-)

diff --git a/goodwe_controller/test_ux46.py b/goodwe_controller/test_ux46.py
index 24c2f31..1658f08 100644
--- a/goodwe_controller/test_ux46.py
+++ b/goodwe_controller/test_ux46.py
@@ -14,6 +14,8 @@ showed English under Dutch titles (SAFETY-118 I-1, UX-44 I-2, UX-45 I-3).
 3. The setting labels the Dutch notes quote are the labels in nl.yaml, and the
    peak forecast label has no "(W)", since any power unit is read.
 4. The rules above catch spoiled input.
+
+Mutating a module this file grades? Read MUTATION.md first (purge __pycache__).
 """
 
 import ast
@@ -38,6 +40,7 @@ import ux13_demo as D                                           # noqa: E402
 from style_rules import sentences, text_problems, words        # noqa: E402
 from app import messages, uimodel as U, uitext, web             # noqa: E402
 from app.main import Controller                                 # noqa: E402
+from named_absence import field, nth, present                   # noqa: E402
 from app.validate import (Note, note_text, setup_checks,        # noqa: E402
                           config_notes)
 
@@ -218,24 +221,26 @@ def attention(payload, rid):
 c = make(ONE, soc=(62.0,), batt=(960.0,))
 c._peak_fc_fault = "kWh"
 s_en, s_nl = c.status_payload(), c.status_payload(lang="nl")
-_en = next(r for r in s_en["checks"] if r.get("id") == "peak_forecast")
-_nl = next(r for r in s_nl["checks"] if r.get("id") == "peak_forecast")
+def fc_row(payload):
+    return nth([r for r in payload["checks"] if r.get("id") == "peak_forecast"])
+
+
+_en, _nl = fc_row(s_en), fc_row(s_nl)
 check("Home, English: the peak forecast row is the English sentence",
-      _en["text"] == messages.peak_forecast_unit("kWh")
+      present(_en) and field(_en, "text") == messages.peak_forecast_unit("kWh")
       and attention(s_en, "peak_forecast")["body"]
       == messages.peak_forecast_unit("kWh"))
 check("Home, Dutch: the row, the Needs-attention entry and the title are "
       "Dutch",
-      _nl["text"] == messages.peak_forecast_unit("kWh", "nl")
+      present(_nl) and field(_nl, "text") == messages.peak_forecast_unit("kWh", "nl")
       and attention(s_nl, "peak_forecast")["body"]
       == messages.peak_forecast_unit("kWh", "nl")
       and attention(s_nl, "peak_forecast")["title"]
       == uitext.words("nl")["home_words"]["attn"]["peak_forecast"])
 c._peak_fc_fault = ""
-_nl0 = next(r for r in c.status_payload(lang="nl")["checks"]
-            if r.get("id") == "peak_forecast")
+_nl0 = fc_row(c.status_payload(lang="nl"))
 check("...and with no unit at all, the Dutch is the 'no unit' sentence",
-      _nl0["text"] == messages.peak_forecast_unit("", "nl")
+      present(_nl0) and field(_nl0, "text") == messages.peak_forecast_unit("", "nl")
       and messages.peak_forecast_unit("", "nl")
       != messages.peak_forecast_unit("kWh", "nl"))
 check("a language that is not Dutch gets the English, and the default call "

From ae0ef4296b8787c7343839416af9b801b52e7cbc Mon Sep 17 00:00:00 2001
From: glenn schrooyen <glenn@dsgpartners.be>
Date: Thu, 22 Oct 2026 04:53:55 +0200
Subject: [PATCH 3/3] UX-46 review: Dutch wording fixes on the NL rows and
 notes

Text only. "stroom te opnemen" -> "stroom op te nemen"; Developer Tools is
"Ontwikkelhulpmiddelen" in HA and ui_text; the green stuck-meter row no longer
starts "Vastgelopen meter:"; maintenance banner names the phase in Dutch;
double "dan" in the device note; plainer peak reserve, peak guard, refused
commands and missing-entity wording. Two stale comments now say the banner
and Home bodies follow the page's language.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 goodwe_controller/app/homeview.py |  6 ++---
 goodwe_controller/app/main.py     |  4 ++--
 goodwe_controller/app/messages.py | 40 +++++++++++++++++--------------
 goodwe_controller/app/validate.py |  6 ++---
 goodwe_controller/app/web.py      |  2 +-
 5 files changed, 31 insertions(+), 27 deletions(-)

diff --git a/goodwe_controller/app/homeview.py b/goodwe_controller/app/homeview.py
index 9501c7a..00bd30f 100644
--- a/goodwe_controller/app/homeview.py
+++ b/goodwe_controller/app/homeview.py
@@ -1075,9 +1075,9 @@ def _kwh(v) -> str:
     return _dec(f"{float(v):.1f}") + " kWh"
 
 
-# Row id -> the title on Home. The row's own sentence is the body, and it stays
-# in English (app/messages.py). Five titles are the notification's own title,
-# which test_ui_text.py checks.
+# Row id -> the title on Home. The row's own sentence is the body, in the
+# page's language (UX-46, `messages.pick`). Five titles are the notification's
+# own title, which test_ui_text.py checks.
 _EN = uitext.words("en")["home_words"]
 ATTN_TITLES = {(None if k == "none" else k): v for k, v in _EN["attn"].items()}
 ATTN_FROM_MESSAGES = {
diff --git a/goodwe_controller/app/main.py b/goodwe_controller/app/main.py
index 290068d..c98b91d 100644
--- a/goodwe_controller/app/main.py
+++ b/goodwe_controller/app/main.py
@@ -7598,8 +7598,8 @@ class Controller:
         held = level == "bad" and not running_alarm
         # UX-46. The rows were built in English with their Dutch beside them
         # (`messages.Bi`); the page's language is chosen once, here, for the
-        # Home sentences, the checks list and the rows that carry one. The
-        # banner above stays English: it is the plain fallback.
+        # Home sentences, the checks list, the rows that carry one and the
+        # banner. A plain str (no Dutch twin) stays as it is.
         checks = [dict(c, text=messages.pick(c["text"], lang)) for c in checks]
         rows = [(k, messages.pick(v, lang)) for k, v in rows]
         banner = messages.pick(banner, lang)
diff --git a/goodwe_controller/app/messages.py b/goodwe_controller/app/messages.py
index f8c350a..298c9e0 100644
--- a/goodwe_controller/app/messages.py
+++ b/goodwe_controller/app/messages.py
@@ -466,7 +466,7 @@ def row_maint_waits(until_text: str) -> str:
 
 NOT_READY = "Not ready"
 BANNER_RUNNING = ("Running — holding grid at zero",
-                  "Actief — het net blijft op nul")
+                  "Actief — houdt het net op nul")
 DOCS_STATUS = "Status page"
 
 
@@ -566,7 +566,9 @@ def banner_not_delivering(units) -> str:
 
 def banner_maintenance(phase: str, unit: str = "") -> str:
     where = f" ({unit})" if unit else ""
-    return Bi(f"Maintenance: {phase}{where}", f"Onderhoud: {phase}{where}")
+    fase = {"drain": "leegmaken", "charge": "opladen", "hold": "vol houden"}
+    return Bi(f"Maintenance: {phase}{where}",
+              f"Onderhoud: {fase.get(phase, phase)}{where}")
 
 
 def banner_running() -> str:
@@ -588,7 +590,7 @@ def banner_setup_only() -> str:
 def row_setup_only() -> str:
     return Bi("No inverter is named yet, so finish Setup and restart the "
               "add-on.",
-              "Er is nog geen omvormer benoemd, dus rond de installatie af "
+              "Er is nog geen omvormer opgegeven, dus rond de installatie af "
               "en herstart de add-on.")
 
 
@@ -700,9 +702,9 @@ def row_freeze_on(hold_s, rail_w, own_limit: bool) -> str:
     return Bi(f"Stuck-meter check: alerts after {duration(hold_s)} unchanged "
               f"above {watts(rail_w)}"
               + (", the inverter's own limit" if own_limit else ""),
-              f"Vastgelopen meter: alarm na {duur(hold_s)} gelijk boven "
-              f"{watts(rail_w)}"
-              + (", limiet van de omvormer" if own_limit else ""))
+              f"Controle op vastgelopen meter: alarm na {duur(hold_s)} "
+              f"ongewijzigd boven {watts(rail_w)}"
+              + (", omvormerlimiet" if own_limit else ""))
 
 
 # Rows: the peak guard.
@@ -734,14 +736,15 @@ def row_peak_reserve(ceiling_w, *, soc_unread: bool, floor_unknown: bool,
                   f"limit alone. Home use still draws it lower, to the "
                   f"cut-out level.",
                   f"{why_nl}. De andere kunnen de piekgrens van "
-                  f"{watts(ceiling_w)} niet alleen houden. Het huis trekt de "
-                  f"batterij nog leger, tot het uitschakelniveau.")
+                  f"{watts(ceiling_w)} niet alleen houden. Het verbruik in "
+                  f"huis trekt de batterij verder leeg, tot het "
+                  f"uitschakelniveau.")
     return Bi(f"{why}, so the {watts(ceiling_w)} peak limit will be passed. "
               f"Home use still draws the battery below it, down to the "
               f"cut-out level.",
               f"{why_nl}, dus de piekgrens van {watts(ceiling_w)} wordt "
-              f"overschreden. Het huis trekt de batterij nog leger, tot het "
-              f"uitschakelniveau.")
+              f"overschreden. Het verbruik in huis trekt de batterij verder "
+              f"leeg, tot het uitschakelniveau.")
 
 
 def row_peak_guard_off() -> str:
@@ -788,7 +791,7 @@ def row_sensor_unusable(label, unit=None) -> str:
               f"Developer Tools before replacing it.",
               f"{LABEL_NL.get(label, label)}{voor(unit)}: geen bruikbare "
               f"meting. De entiteit ontbreekt misschien, of de meting is te "
-              f"oud. Controleer ze in Ontwikkelaarstools voor u ze vervangt.")
+              f"oud. Controleer ze in Ontwikkelhulpmiddelen voor u ze vervangt.")
 
 
 def setpoint_label(unit=None, lang="en") -> str:
@@ -829,7 +832,7 @@ def row_not_controllable(name, held_s, limit_s) -> str:
               f"{seconds(held_s)}, so control leaves it out.",
               f"{name} kan niet worden geregeld. Hij weigerde elke opdracht "
               f"gedurende {seconden(held_s)}, dus de regeling laat hem "
-              f"buiten beschouwing.")
+              f"weg.")
 
 
 def row_commands_refused(name, held_s, limit_s) -> str:
@@ -837,7 +840,7 @@ def row_commands_refused(name, held_s, limit_s) -> str:
     return Bi(f"{name}: commands refused for {seconds(held_s)}, left out of "
               f"control after {seconds(limit_s)}",
               f"{name}: opdrachten geweigerd gedurende {seconden(held_s)}, "
-              f"na {seconden(limit_s)} buiten de regeling gelaten")
+              f"de regeling laat hem weg na {seconden(limit_s)}")
 
 
 def row_control(lo_w, hi_w, unit=None) -> str:
@@ -1029,7 +1032,7 @@ def row_peak_forecast_unit(unit) -> str:
 
 def row_peak_guard_waiting() -> str:
     return Bi("Peak guard: no decision yet, control has not run",
-              "Piekbewaking: nog geen besluit, de regeling is niet uitgevoerd")
+              "Piekbewaking: nog geen besluit, de regeling liep nog niet")
 
 
 def row_no_estop() -> str:
@@ -1175,12 +1178,12 @@ def row_peak_guard_idle(projected_w, limit_w, month_peak: bool) -> str:
              else f"de piekgrens van {watts(limit_w)}")
     return Bi(f"Peak guard: idle, heading for {watts(projected_w)}, under "
               f"{limit}",
-              f"Piekbewaking: rust, op weg naar {watts(projected_w)}, onder "
+              f"Piekbewaking: in rust, richting {watts(projected_w)}, onder "
               f"{grens}")
 
 
 def row_peak_guard_quiet() -> str:
-    return Bi("Peak guard: idle", "Piekbewaking: rust")
+    return Bi("Peak guard: idle", "Piekbewaking: in rust")
 
 
 BLIND_WORDS = {
@@ -1219,7 +1222,7 @@ def row_peak_guard_on(floor_w, limit_w, *, shadow: bool = False) -> str:
                   f"{watts(limit_w)} te blijven")
     return Bi(f"Peak guard: asks the battery for {watts(floor_w)} to stay "
               f"under {watts(limit_w)}",
-              f"Piekbewaking: vraagt {watts(floor_w)} van de batterij om "
+              f"Piekbewaking: vraagt de batterij {watts(floor_w)} om "
               f"onder {watts(limit_w)} te blijven")
 
 
@@ -1236,12 +1239,13 @@ def row_battery_refuses(unit, sign, probing) -> str:
     """SAFETY-73. One inverter's battery refuses, the others take its share."""
     way = "give" if sign > 0 else "take"
     weg = "leveren" if sign > 0 else "opnemen"
+    weigert = "te leveren" if sign > 0 else "op te nemen"
     if probing:
         return Bi(f"{unit}: testing if the battery will {way} power again",
                   f"{unit}: test of de batterij weer stroom wil {weg}")
     return Bi(f"{unit}: the battery refuses to {way} power, the others take "
               f"over",
-              f"{unit}: de batterij weigert stroom te {weg}, de andere "
+              f"{unit}: de batterij weigert stroom {weigert}, de andere "
               f"nemen over")
 
 
diff --git a/goodwe_controller/app/validate.py b/goodwe_controller/app/validate.py
index c9dfb19..659bc05 100644
--- a/goodwe_controller/app/validate.py
+++ b/goodwe_controller/app/validate.py
@@ -1865,8 +1865,8 @@ def _entity_notes(notes, opts: dict, entities: dict, bad=()) -> None:
             _advise(notes, "bad" if key in bad else "warn", (key,),
                     f"Home Assistant has no entity {entity}, which "
                     f"{S(key, where)} names.",
-                    nl=f"Home Assistant heeft geen entiteit {entity}, terwijl "
-                    f"{SN(key, where)} die noemt.")
+                    nl=f"Home Assistant kent {entity} niet, maar "
+                    f"{SN(key, where)} verwijst ernaar.")
             continue
         unit = str(row.get("unit") or "")
         if key in WATT_ENTITY_KEYS and unit in pv.WATTS_PER and unit != "W":
@@ -1885,7 +1885,7 @@ def _entity_notes(notes, opts: dict, entities: dict, bad=()) -> None:
             _advise(notes, "warn", (key,),
                     f"{entity} does not read in kWh, so pick a solar "
                     "forecast sensor in kWh.",
-                    nl=f"{entity} meldt niet in kWh, dus kies een sensor voor "
+                    nl=f"{entity} meet niet in kWh, dus kies een sensor voor "
                     "de zonneprognose in kWh.")
     today = solarfc.entities(opts)
     tomorrow = solarfc.entities(opts, tomorrow=True)
diff --git a/goodwe_controller/app/web.py b/goodwe_controller/app/web.py
index 4d578d6..e520ea6 100644
--- a/goodwe_controller/app/web.py
+++ b/goodwe_controller/app/web.py
@@ -107,7 +107,7 @@ DEVICE_NOTE = (
     "at start. If they fail later, the add-on will not start then.")
 DEVICE_NOTE_NL = (
     "%s meldde geen vermogensbereik, dus twee controles zijn overgeslagen, "
-    "hier en bij het starten. Falen ze later, dan start de add-on dan niet.")
+    "hier en bij het starten. Falen ze later, dan start de add-on niet.")
 
 
 def build_app(controller, selfcfg=None) -> web.Application: