feat(demo): laat zien dat het paneel je opnieuw heeft ingelogd

Het herstel navigeert weg, dus de melding die erbij hoort flitst voorbij en is
na terugkomst nergens meer te zien. Wie even niet naar het scherm keek, kan een
geslaagd herstel dan niet onderscheiden van een demo waarin niets gebeurde —
en daarmee is de afhandeling zelf ook niet te beproeven.

Het herstel laat nu een spoor achter in sessionStorage, dat de navigatie naar
de proxy en terug overleeft. Het paneel leest het bij het opstarten, meldt één
keer dat je opnieuw bent ingelogd, en wist het spoor meteen — anders komt die
melding bij elke volgende verversing terug.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Author: ericwout-overheid

demo/demo-console/src/main/resources/META-INF/resources/bediening.js

@@ -2093,6 +2093,13 @@ richtIn(false);
 
 verversToestand();
 
+// Ná `verversToestand()`: die zet bij een geslaagde ronde zelf niets in de balk, dus deze melding
+// blijft staan. Zonder dit is een geslaagd herstel niet te onderscheiden van een demo waarin niets
+// gebeurde — het herstel navigeert immers weg, en de melding van vóór die navigatie is dan weg.
+const herstelmelding = muurHerstelMelding();
+
+if (herstelmelding) toonMelding(herstelmelding, 'let-op', null);
+
 // Alleen pollen terwijl er iemand kijkt: een demo-console blijft dagen in een tab openstaan.
 setInterval(() => {
     if (!document.hidden) verversToestand();

demo/demo-console/src/main/resources/META-INF/resources/inlogmuur.js

@@ -30,6 +30,12 @@ const MUUR_DEMPING_MS = 30000;
  * in het geheugen is bij terugkomst juist weg, precies wanneer de lus zou beginnen. */
 const MUUR_SLEUTEL = 'fbs-demo-inlogmuur:laatste-poging';
 
+/* Dat er hersteld ís. Het herstel navigeert weg, dus de melding die daarbij hoort flitst voorbij en
+ * is na terugkomst nergens meer te zien: wie even niet keek, kan een geslaagd herstel niet van een
+ * rustige ochtend onderscheiden — en bij het beproeven van deze afhandeling is dat juist wat je
+ * wilt weten. Ook in sessionStorage, om dezelfde reden als de demping. */
+const MUUR_SPOOR = 'fbs-demo-inlogmuur:hersteld';
+
 /* Of de navigatie naar het inlogpad al is ingezet. De poll en een druk op een knop kunnen elkaar
  * overlappen, en twee navigaties tegelijk laten de browser de eerste afbreken. */
 let muurHerstelLoopt = false;
@@ -65,6 +71,7 @@ function herstelInlogsessie() {
 
     muurHerstelLoopt = true;
     onthoudHerstelpoging();
+    laatSpoorAchter();
 
     window.location.assign(MUUR_START_PAD + '?rd=' + encodeURIComponent(location.pathname + location.search));
 
@@ -79,6 +86,39 @@ function muurMelding() {
         : 'Je bent uitgelogd bij de omgeving. Ververs de pagina om opnieuw in te loggen.';
 }
 
+/* De melding voor wie terugkomt uit een herstel, of `null` wanneer er niets aan voorafging. Net als
+ * `muurMelding()` één ingang: de tekst en de toets erop horen niet uit elkaar te lopen. */
+function muurHerstelMelding() {
+    return netHersteld() ? 'Je was uitgelogd bij de omgeving en bent opnieuw ingelogd.' : null;
+}
+
+/* Of er op deze pagina zojuist een herstel aan voorafging. Wist het spoor meteen: de melding hoort
+ * bij die ene terugkomst, en zou anders bij elke volgende verversing opnieuw verschijnen en de
+ * bediener laten denken dat hij er steeds uit vliegt. */
+function netHersteld() {
+    try {
+        const spoor = window.sessionStorage.getItem(MUUR_SPOOR);
+
+        if (!spoor) return false;
+
+        window.sessionStorage.removeItem(MUUR_SPOOR);
+
+        return true;
+    } catch (fout) {
+        console.error('[inlogmuur] spoor niet te lezen', fout);
+
+        return false;
+    }
+}
+
+function laatSpoorAchter() {
+    try {
+        window.sessionStorage.setItem(MUUR_SPOOR, String(Date.now()));
+    } catch (fout) {
+        console.error('[inlogmuur] spoor niet te bewaren', fout);
+    }
+}
+
 /* Storage kan gooien wanneer site-data geblokkeerd is. Dan liever herstellen zonder demping dan
  * helemaal niet: de bediener heeft meer aan een poging dan aan een dood paneel. */
 function dempingVerstreken() {

demo/demo-console/src/test/kotlin/nl/rijksoverheid/moz/fbs/democonsole/PaneelInlogmuurTest.kt

@@ -116,6 +116,38 @@ class PaneelInlogmuurTest {
         assertTrue(controle in 0 until onleesbaar, "de muur-controle staat ná de terugval op een onleesbaar antwoord")
     }
 
+    @Test
+    fun `het herstel laat een spoor achter dat de navigatie overleeft`() {
+        // Zonder spoor is een geslaagd herstel niet waarneembaar: de melding van vóór de navigatie
+        // is na terugkomst weg, en wie even niet keek kan het niet van een rustige ochtend
+        // onderscheiden. Dat maakt ook het beproeven van deze afhandeling onmogelijk.
+        val code = zonderCommentaar(inlogmuur)
+
+        assertTrue(code.contains("MUUR_SPOOR"), "er is geen spoor van een herstel")
+        assertTrue(functieBody(inlogmuur, "herstelInlogsessie").contains("laatSpoorAchter()"), "het herstel laat geen spoor achter")
+        assertTrue(code.contains("sessionStorage.setItem(MUUR_SPOOR"), "het spoor overleeft de navigatie naar de proxy niet")
+    }
+
+    @Test
+    fun `het spoor verdwijnt zodra het gelezen is`() {
+        // Anders verschijnt de melding bij elke volgende verversing opnieuw, en denkt de bediener
+        // dat hij er steeds uit vliegt.
+        assertTrue(
+            functieBody(inlogmuur, "netHersteld").contains("sessionStorage.removeItem(MUUR_SPOOR)"),
+            "het spoor blijft staan na het lezen",
+        )
+    }
+
+    @Test
+    fun `het paneel meldt bij het opstarten dat het hersteld is`() {
+        // Buiten elke functie, tussen de bedrading onderaan: hier hoort het één keer per laadbeurt
+        // te gebeuren en niet in een pad dat de bediener zelf moet aanraken.
+        assertTrue(
+            zonderCommentaar(script).contains("const herstelmelding = muurHerstelMelding()"),
+            "het paneel leest het spoor niet bij het opstarten",
+        )
+    }
+
     @Test
     fun `de melding over uitloggen staat alleen bij de herstelpoging`() {
         // Eén ingang voor melden en herstellen: een aanroeper die de tekst zelf opschrijft, meldt