diff --git a/CLAUDE.md b/CLAUDE.md
index 4aef8f1a..aed9ddc7 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -73,7 +73,7 @@ MijnOverheid Zakelijk (MOZa) is een HTML/CSS/JS prototype gebouwd met Eleventy e
 - Berichtenbox, datalaag en rendering gescheiden: `assets/javascript/berichtenbox/` bevat zes modules zonder DOM-kennis — `datum.js` (datumnotatie), `state.js` (localStorage-state en de vragen daarover), `lijst.js` (filteren, sorteren, pagineren als pure functies), `bron.js` (bronregister) `keten-bron.js` (het Federatief Berichtenstelsel als bron) en `dataset-bron.js` (de gegenereerde dataset als bron, inclusief het nagebootste federatieve gedrag: de ophaalanimatie bij het eerste bezoek, de binnendruppelende berichten en de gesimuleerde bronuitval). `berichtenbox.js` is de render-laag: die leest uit de datalaag en muteert de bron nooit. Een bron is `{ naam, geldtVoor(persona), laad(), start?(meld), inhoudVan?(berichtId), volgVoortgang?(kijker), herhaalOphalen?(klaar) }`. `inhoudVan` levert `{ inhoud, bijlagen }` of `{ fout }` en werpt niet: de detailpagina moet altijd iets kunnen tonen, en een lege pagina zou de bezoeker laten denken dat het bericht zelf leeg is. De berichtenuitvraag van het stelsel geeft alleen kopgegevens — afzender, onderwerp, datum; de inhoud staat achter een eigen adres per bericht (`GET /api/v1/berichten/{berichtId}`) en wordt pas opgehaald als de bezoeker het bericht opent. Dat is geen besparing maar het gedrag van een federatief stelsel: de inhoud blijft bij de organisatie tot iemand erom vraagt. Een bijlage is een gewone link naar `/api/v1/berichten/{berichtId}/bijlagen/{bijlageId}`, geen fetch: een `<a href>` en een `<object data>` kunnen geen eigen header meesturen, en het stelsel eist `X-Ontvanger`. De keten-bron zet die ontvanger daarom in een cookie (`ontvanger`, rauw en `SameSite=Strict`) en de proxy maakt er in `container/default.conf.template` weer een header van — zelfde patroon als `X-Test-User` bij de Digitale Assistent. In het cookie en niet in de URL: de ontvanger hoort bij de zitting, niet bij het adres van het document. Dat maakt niets veiliger; een cookie is net zo goed aan te passen als een header. `personas.js` wist het cookie bij een persona-wissel, anders haalt een klik de bijlage van de vorige persona op. Berichten uit de keten hebben geen server-gerenderde detailpagina — die worden bij de build uit de dataset gegenereerd — en landen daarom op `bericht-demo.html`. `volgVoortgang` meldt `{ bevraagd, klaar, gevonden }` zolang er opgehaald wordt en `null` als er niets meer te melden valt; de render-laag abonneert zich daarop vóór de bronkeuze, want `geldtVoor` wacht een ronde af. `herhaalOphalen` draait een nieuwe ronde op verzoek van de bezoeker. Beide zijn generiek: de dataset-bron vult ze met een nabootsing, het stelsel met gemeten getallen, en de render-laag hoort het verschil niet te kunnen zien; de volgorde van registreren is de voorrang en de dataset-bron staat achteraan als vangnet. Één weg naar het scherm: `toonBerichten()` filtert de berichten, neemt het paginavenster en bouwt die rijen. De inbox rendert geen rijen vooraf: de tbody begint leeg en wordt gevuld uit de datalaag, net als het archief en de prullenbak. Dat is een bewuste afwijking van principe 5 (HTML waar het kan): dit prototype simuleert een federatief stelsel dat berichten bij verschillende organisaties ophaalt, en die zijn er per definitie niet synchroon. Vooraf een volledige lijst renderen zou beweren dat ze dat wél waren — precies wat de voortgangsanimatie tegenspreekt. Wie geen JavaScript heeft krijgt een `<noscript>`-blok dat dat uitlegt; de detailpagina's uit de dataset zijn statisch en werken wel. Voor een bericht uit de keten geldt dat níet: dat heeft geen gegenereerde detailpagina en landt op `bericht-demo.html`, dat zonder JavaScript leeg is. Open vraag voor het FBS-team: er is nog geen afgesproken kenmerk waarmee een ingetrokken bericht (404 omdat het weg is) te scheiden is van een 404 die uit een tussenliggende laag komt. Zolang dat er niet is, zegt de melding wat we wél weten en beweert ze niet dat het bericht zeker verdwenen is. `_includes/berichtenbox-row.njk` blijft in gebruik voor het voorproefje van vijf berichten op de homepage. De scripts zijn ES-modules (`type="module"` in `_includes/base.njk`), als enige in dit project. Let op: modulescripts draaien ná álle klassieke `defer`-scripts, niet op hun plek in de documentvolgorde. Berichten die binnenkomen terwijl de bezoeker kijkt lopen langs `keten-bron.js`: die vergelijkt de lijst van het transport met de vorige en meldt alleen de aanwas, als losse `{ nieuwBericht }` en oudste eerst — dezelfde weg die de dataset-bron voor zijn nagebootste federatie gebruikt. Elke andere wijziging blijft een hele lijst. Druppelen gebeurt alleen waar een binnenkomer te zien is (inbox, pagina 1, `toontBinnenkomers` in de render-laag); elders is de melding in het live-gebied een uitspraak over een rij die er niet staat. Lukt het tonen niet, dan schuift de bron zijn ijkpunt niet op, zodat het transport dezelfde lijst opnieuw aanbiedt in plaats van de berichten stil te laten verdwijnen; wat wél getoond werd telt als bekend, dus een geslaagde binnenkomer verschijnt geen tweede keer. Na drie vergeefse pogingen op dezelfde berichten houdt de bron ermee op en zegt dat één keer: anders herhaalt zich dat elke tik, zonder dat een van de tellers aanslaat. Meldingen aan de bezoeker lopen via één blok per pagina, `[data-berichtenbox-storing]`, dat op elke berichtenbox-pagina staat — ook op de detailpagina's. Het blok van de gesimuleerde bronuitval (`[data-geen-bronnen]`, `[data-bron-onbereikbaar]`) is daar níet voor: dat hoort bij de unhappy-flow-vlag en staat alleen op de inbox.
 - Berichtenbox, Federatief Berichtenstelsel: `assets/javascript/berichtenbox-keten.js` is de transportlaag — het vraagt de demo-omgeving of de actieve persona aangesloten is (`/api/demo/personas`), draait de ophaalronde (`/api/v1/berichten/_ophalen`, SSE) en haalt de lijst op (`/api/v1/berichten`). `_ophalen` draait niet op elke pagina: die bouwt bij het stelsel de sessie op, en daarna levert `GET /api/v1/berichten` dezelfde gegevens. Die lijst komt per pagina van honderd — een grotere `paginaGrootte` vragen kapt het stelsel daarop af — dus bladert de client door zolang het antwoord een `_links.next` noemt. Twee dingen beëindigen dat bladeren zonder dat er iets mis is: geen `next` meer, of een lege pagina (ook als daar nog een `next` naast staat). Alles daarbuiten is een fout en werpt, want een halve lijst is aan het scherm niet van een hele te onderscheiden: een pagina zonder `berichten`-array is `lijstOnleesbaar`, een pagina die niet binnenkomt is `lijstAfgebroken` — dat laatste met een eigen tekst, want de bronnen hebben dan al geleverd en “de bronnen reageren niet meer” zou onwaar zijn. Alleen een 409 blijft `geenSessie`, want daar hangt het herstel aan vast. Naast de tijdslimiet per pagina staat er een budget over de hele reeks (`LIJST_TOTAAL_LIMIET_MS`), anders zouden honderd trage pagina's de berichtenbox drie kwartier leeg laten. De pagina's worden ontdubbeld op `berichtId`: de sessie kan groeien terwijl de client bladert, en dan schuift een bericht over de paginagrens. Bij hoogstens honderd pagina's houdt het op; dan zegt een mededeling hoeveel berichten er getoond worden en dat het er meer kunnen zijn — het aantal dat er staat, niet de bovengrens van de client. Het adres uit `next` volgt de client niet: hij telt het paginanummer zelf op, zodat een antwoord hem niet ergens anders heen stuurt. Dat veronderstelt wel dat `pagina=N` blijft betekenen wat `next` bedoelt; wordt dat ooit een cursor, dan moet dit mee. De lijst draagt per bericht de naam van de afzendende organisatie (`afzenderNaam`, in de uitvraag-API verplicht en nooit leeg), dus een pagina heeft de ophaalronde niet nodig om iets leesbaars te tonen; het organisatiefilter komt uit diezelfde lijst, aangevuld met de organisaties die in een eigen ronde antwoordden maar niets te leveren hadden. Elke pagina vraagt daarom eerst de lijst op en draait alleen een ronde als het stelsel met 409 antwoordt: dan is er nog geen sessie. Die vraag gaat naar het stelsel en niet naar een aantekening in `sessionStorage` — die hoort bij één tabblad, terwijl de sessie bij de ontvanger hoort, en een tweede tabblad zou dan alsnog een hele ronde draaien terwijl de berichten klaarstaan. Draait een andere pagina net een ronde, dan antwoordt het stelsel ook met 409 — één ontvanger, één ronde tegelijk — en wacht de client die af via de lijst in plaats van een storing te melden. Geen DOM, op één plek na: `paginaGebruiktKeten()` leest het pad van de pagina, want binnen het Belastingdienst-portaal wordt er niet opgehaald. `assets/javascript/berichtenbox/keten-bron.js` maakt daar een bron van en staat vóór de dataset-bron in het register; de render-laag weet niet welke bron levert. `geldtVoor` wacht de ronde af — eerder antwoorden zou de dataset-bron de aangesloten persona laten opeisen. Mislukt de ronde voor iemand die aantoonbaar aangesloten is, dan blijft de keten de bron en werpt `laad`: geen stille terugval, want verzonnen berichten tussen echte zijn niet te onderscheiden. Meldingen van de keten lopen langs `meldStoring` naar hetzelfde `[data-berichtenbox-storing]` als alle andere; een onvolledige lijst is `info`, een mislukte ronde is `storing`. De dataset-bron implementeert allebei met de nagebootste ophaalronde; die verzint aankomsttijden per bron en eindigt op de aantallen die de bezoeker daarna écht ziet, dus krijgt hij `zichtbaarheid` (`statusVan`, `magazijnDoorOrgFilter`, `magazijnToegestaan`, `persoonRelevant`) en `magAnimeren` mee. In `.finally` start het brongedrag vóór `naEersteLading()`: andersom onthult die de lijst een tel voordat de ronde hem weer wegneemt. De voortgang van de ronde komt uit `volgVoortgang` op de bron; de render-laag abonneert zich vóór de bronkeuze, want `geldtVoor` wacht de ronde af en daarna valt er niets meer te tonen. De balk verschijnt pas als de ronde langer dan 300 ms duurt (`VOORTGANG_DREMPEL_MS`): lokaal duurt een ronde ongeveer een tiende seconde, en die even laten oplichten leest als een storing. Zolang de keten levert staat de nabootsing uit: geen gesimuleerde bronuitval, geen ophaalanimatie, geen binnendruppelende berichten (`simulatieMag()` in `berichtenbox.js`). Berichten uit de keten dragen `uitKeten: true` en linken naar `bericht-demo/?id=`, want gegenereerde detailpagina's bestaan alleen voor de dataset. Het script draait klassiek en `defer`, vóór de module, zodat de ronde zo vroeg mogelijk start. Berichten uit de keten komen **niet** in `localStorage`: wat eerder opgehaald is staat op de server, in een sessiecache per ontvanger (schuivende TTL van 12 uur). Elke berichtenbox-pagina vraagt daarom zijn eigen lijst op — ook het archief, de prullenbak en een detailpagina — en draait alleen een ronde als die lijst er nog niet is. Runtime-vars: `BACKEND_KETEN` (default naar de publieke FBS-omgeving in het Containerfile, géén terugval — expliciet leeggemaakt antwoordt nginx zelf met een 502; onder `/api/v1/` met de variabelenaam erin, bij een bijlage-adres bewust zonder, want dat antwoord komt bij de bezoeker in beeld), `BACKEND_PERSONAS` voor `/api/demo/personas` (een eigen publieke dienst, valt terug op `BACKEND_DEMO`), `BACKEND_DEMO` voor de rest van de console (valt terug op `BACKEND_KETEN`; die console zit achter SSO en is server-side niet te proxyen, wat geen gemis is omdat dit prototype er niets van aanroept), `BACKEND_API` (de standaard-upstream voor al het overige onder `/api/`, valt terug op `BACKEND_ORIGIN`, dat verder alleen de chat-backend is) en, achter een gedeelde ingress, `BACKEND_KETEN_HOST` / `BACKEND_DEMO_HOST`. De ontvanger gaat mee als header `X-Ontvanger` (`KVK:<nummer>`); voor een bijlage kan dat niet — een `<a href>` stuurt geen header mee — dus zet `berichtenbox-keten.js` de ontvanger in een sessiecookie op `path=/api/v1/berichten` (`SameSite=Strict`, `Secure` op https) en maakt de proxy er weer een header van. `personas.js` wist dat cookie bij een persona-wissel op dat pad én op `/`, want alleen op het pad waarop het gezet is valt het te wissen. Testpersona's: `proeftuin-een` (90000011), `proeftuin-twee` (90000012), `proeftuin-drie` (90000013), `proeftuin-veel` (90000001). Let op: dit is **geen authenticatie** — de header is in de browser aan te passen, dus het stelsel moet zijn eigen allowlist hanteren; zelfde afweging als bij `X-Test-User`
 
-  Zolang een berichtenbox-pagina openstaat vraagt deze laag periodiek `GET /api/v1/berichten` op: dat leest alleen de sessiecache van de ontvanger — geen ophaalronde, dus de organisaties worden er niet voor bevraagd — en houdt tegelijk de schuivende vervaltijd van die sessie warm. Elke 15 seconden zolang het tabblad zichtbaar is, elke 60 seconden als het dat niet is: niet stoppen bij een verborgen tabblad, want dan verloopt de sessie en kost terugkomen een volle ronde. Beide zijn in te stellen via `?poll=` en `?pollVerborgen=` in de URL of `setting:berichtenbox-poll(-verborgen)` in localStorage (het Flags-paneel heeft er geen veld voor), met een ondergrens van 5 seconden; `poll=0` zet het pollen uit, `pollVerborgen=0` pauzeert het tot het tabblad terug is. Alleen een lijst die veranderd is gaat door naar de bron — en een lijst die de bron niet kon tonen telt daarna weer als wijziging. Eén tik tegelijk, en een tik die door een nieuwere ophaalronde is ingehaald vervalt: anders legt een traag antwoord een verouderde lijst over een nieuwere heen. Dezelfde `?poll=` stelt bij de dataset-bron de nagebootste binnenkomers in, met een eigen standaard van 60 seconden en zonder die nul-betekenis: daar zet `poll=0` niets uit. Let op de twee 409's: die van `_ophalen` zegt dat er al een ronde loopt, die van de berichtenlijst dat de sessie weg is. Op de tweede draait er wél een nieuwe ophaalronde, hoogstens twee keer op rij zonder geslaagde tik ertussen — anders bevraagt een sessie die korter leeft dan het pollinterval bij elke tik alle organisaties. Het pollen houdt op na drie mislukte pogingen op rij of na die twee vergeefse herstelrondes; beide zeggen dat als mededeling, want de berichten die er staan kloppen nog. `pagehide` parkeert het pollen altijd — nooit blijvend stoppen, want die gebeurtenis weet niet betrouwbaar of de pagina bewaard wordt — en `pageshow` haalt het terug: gaat de pagina de bfcache in — inbox, bericht openen, terugknop — dan draait het script niet opnieuw en zou een berichtenbox die er levend uitziet zich nooit meer bijwerken. Slaat de render-laag het brongedrag over — na een mislukte eerste lading — dan zet zij het pollen stil met `stopPollen()`: zonder luisteraar is het verkeer voor een scherm dat er niets mee doet.
+  Zolang een berichtenbox-pagina openstaat volgt deze laag wat er binnenkomt, standaard over een SSE-stroom: `GET /api/v1/berichten/_volgen` met `X-Ontvanger`, gelezen met `fetch` en een reader (`EventSource` kan die header niet meesturen) en met dezelfde parser als `_ophalen` (`leesSse`). Eén stroom tegelijk, achter een `AbortController`. Hij begint met `volgen-gestart`, en dan haalt de laag één keer de lijst op, langs hetzelfde pad als een polltik. Een tik die al liep krijgt er nog één achteraan, want die begon vóór het volgen. Mislukt die lijst, dan blijft de stroom open en probeert de laag het na 15 seconden opnieuw; na drie mislukkingen op rij houdt het bijwerken op met dezelfde mededeling als bij het navragen. Behalve bij een 409 op de lijst: dan is de sessie weg, sluit de stroom en draait `herstelSessie`. Daarna komt elk nieuw bericht als `bericht-bijgekomen`, in dezelfde vorm als een element van de lijst en met `afzenderNaam`. Het gaat als gewijzigde lijst naar de bron, die er een `{ nieuwBericht }` van maakt. Ontdubbeld wordt op `berichtId`, want een bericht op het grensvlak kan in de lijst én in de stroom zitten. Een bericht dat binnenkomt terwijl de lijst van die tik onderweg is, blijft staan (`bijgekomenTijdensTik`): anders legt die lijst zich eroverheen en haalt de bron het weer weg. Een melding die geen JSON is of niet te verwerken valt, wordt met een `console.error` overgeslagen; de verbinding blijft staan, want één kapot bericht is geen weggevallen verbinding. Wel haalt de laag na 5 seconden de lijst op, zodat dat bericht alsnog verschijnt (of, zonder id, gemeld wordt). Een onbekende `event` wordt genegeerd, met één `console.warn` per soort. `hartslag` komt elke 20 seconden. Blijft er 45 seconden geen leesbare gebeurtenis komen, ook tijdens het openen, dan breekt een waakhond de verbinding af: na een slaapstand of een wissel van wifi merkt de browser het niet, en losse bytes of onleesbare frames tellen niet als teken van leven. Een verbinding telt pas als gezond na haar eerste `hartslag`, niet al bij `volgen-gestart`. Pas dan gaan de tellers terug naar nul: de reeks tussenpozen (1, 2, 5, 10 en daarna 30 seconden, met ±20% spreiding), de mislukte verbindingen, de 409's en de herstelrem. Zette `volgen-gestart` of de lijst-tik daarna ze terug, dan verbindt een stroom die telkens net na de start wegvalt elke seconde opnieuw, en draait een sessie die korter leeft dan één cyclus eindeloos rondes langs alle organisaties. Ook een stroom die na een uur netjes eindigt, verbindt gewoon opnieuw. `sessie-verlopen` loopt via hetzelfde herstel als bij het pollen (`herstelSessie`, met dezelfde rem van twee rondes), en daarna verbindt de laag opnieuw. Een 409 bij het openen doet dat één keer; komt er vóór een gezonde verbinding wéér een 409, dan ligt het niet aan de sessie en valt de laag blijvend terug op navragen. Een 503 of 429 wacht `Retry-After` af, hoogstens een minuut, en telt mee als mislukte verbinding; een 200 zonder `text/event-stream` ook, en van zo'n antwoord wordt de body gesloten, want elke open verbinding telt mee voor de vijf per ontvanger. Bij een 404, 405 of 406 (een keten zonder `_volgen`, die het pad als `GET /berichten/{berichtId}` leest en dan op `Accept: text/event-stream` met 406 antwoordt) valt de laag blijvend terug op het periodiek navragen hieronder, tot een herlading. Na drie verbindingen op rij die niet gezond werden, valt hij tijdelijk terug: na vijf minuten, of bij `pageshow`, probeert hij de stroom opnieuw, en de reeks tussenpozen loopt dan door waar ze was. Bij een terugval komt er geen melding, alleen een `console.warn`: de berichtenbox werkt gewoon, alleen verschijnen nieuwe berichten wat later. Een verborgen tabblad blijft verbonden. `pagehide` sluit de stroom en `pageshow` verbindt opnieuw, behalve als er intussen een andere persona gekozen is: dan houdt de pagina op met volgen. `stopPollen()` sluit de stroom ook. `?volgen=0` of `setting:berichtenbox-volgen` op `0` zet de stroom uit, zodat een demonstratie ook het navragen kan tonen. De proxy in de container staat al ongebufferd met een `proxy_read_timeout` van 3600 s. Lokaal loopt `/api/v1/` via `server/keten-proxy.js`, dat ook al een timeout van 3600 s heeft; `server/proxy.js` hoort bij de react-islands en staat niet in dit pad. Is er geen stroom, dan vraagt deze laag periodiek `GET /api/v1/berichten` op: dat leest alleen de sessiecache van de ontvanger — geen ophaalronde, dus de organisaties worden er niet voor bevraagd — en houdt tegelijk de schuivende vervaltijd van die sessie warm. Elke 15 seconden zolang het tabblad zichtbaar is, elke 60 seconden als het dat niet is: niet stoppen bij een verborgen tabblad, want dan verloopt de sessie en kost terugkomen een volle ronde. Beide zijn in te stellen via `?poll=` en `?pollVerborgen=` in de URL of `setting:berichtenbox-poll(-verborgen)` in localStorage (het Flags-paneel heeft er geen veld voor), met een ondergrens van 5 seconden; `poll=0` zet het pollen uit, `pollVerborgen=0` pauzeert het tot het tabblad terug is. Alleen een lijst die veranderd is gaat door naar de bron — en een lijst die de bron niet kon tonen telt daarna weer als wijziging. Eén tik tegelijk, en een tik die door een nieuwere ophaalronde is ingehaald vervalt: anders legt een traag antwoord een verouderde lijst over een nieuwere heen. Dezelfde `?poll=` stelt bij de dataset-bron de nagebootste binnenkomers in, met een eigen standaard van 60 seconden en zonder die nul-betekenis: daar zet `poll=0` niets uit. Let op de twee 409's: die van `_ophalen` zegt dat er al een ronde loopt, die van de berichtenlijst dat de sessie weg is. Op de tweede draait er wél een nieuwe ophaalronde, hoogstens twee keer op rij zonder geslaagde tik ertussen — anders bevraagt een sessie die korter leeft dan het pollinterval bij elke tik alle organisaties. Het pollen houdt op na drie mislukte pogingen op rij of na die twee vergeefse herstelrondes; beide zeggen dat als mededeling, want de berichten die er staan kloppen nog. `pagehide` parkeert het pollen altijd — nooit blijvend stoppen, want die gebeurtenis weet niet betrouwbaar of de pagina bewaard wordt — en `pageshow` haalt het terug, tenzij er intussen een andere persona gekozen is: gaat de pagina de bfcache in — inbox, bericht openen, terugknop — dan draait het script niet opnieuw en zou een berichtenbox die er levend uitziet zich nooit meer bijwerken. Slaat de render-laag het brongedrag over — na een mislukte eerste lading — dan zet zij het pollen stil met `stopPollen()`: zonder luisteraar is het verkeer voor een scherm dat er niets mee doet.
 
 - De gesimuleerde bronuitval (feature-flag "Berichtenbox unhappy flow", cookie) hoort bij de dataset-bron. Een bron die niet antwoordt levert geen berichten, dus laat `laad()` ze weg in plaats van dat de render-laag ze wegfiltert — zo is een nagebootste storing hetzelfde als een echte. Drie scenario's, één per weergave gekozen: `een` (één magazijn stil), `geen` (geen enkel) en `later` (alles laadt, daarna valt er één weg — dat laatste is `start`-gedrag en meldt zich als gewone bronwijziging). Wat er wegviel staat in het veld `uitval` van het laad-antwoord en van elke bronwijziging — bewust alleen als veld en niet als functie: een functie zou ná de lading een verse toestand kunnen dobbelen, en dan staat er een melding over een bron boven een lijst waar die bron gewoon in staat, of weten de inbox en de detailpagina iets anders. Een pagina speelt alleen een scenario dat zij ook kan uitleggen (`kanUitleggen(scenario)`): de inbox alle drie, want zij heeft de waarschuwingsblokken; een detailpagina alleen `later`, want haar "bericht onbeschikbaar" gaat over de bron van dít bericht. Bij `een` of `geen` zou zij het bericht tonen terwijl de bron niets leverde, en onderweg de ongelezen-teller over een lege lijst herberekenen — een badge die daarna op elke andere pagina verkeerd staat. De Belastingdienst-inbox heeft de lijst wél maar geen van beide soorten blokken, en valt daarom nooit uit. En de nabootsing laat alleen weg wat de bezoeker ook écht zou zien (`zouTonen`): status, org-filter, magazijn-toestemming en persona-relevantie tellen alle vier mee. Anders verschijnt "deze bron is onbereikbaar" boven een lijst waar niets uit weg is, want die berichten stonden er toch al niet. De bron legt bij het maken één kopie van de dataset vast: `data.berichten` is hetzelfde object dat de render-laag terugschrijft, dus zonder die kopie kan "Opnieuw proberen" de weggelaten berichten niet teruggeven. De zitting bewaart één ding in sessionStorage: `berichtenbox-bron-uitval` — welke bron wegviel bij het scenario "later". Die bewaarde uitval is zelfstandig: hij ís dat scenario in uitvoering, dus hij wordt niet nog eens getoetst aan een nieuwe worp. Het scenario zelf wordt per paginalading geloot en nergens bewaard, net als op `main`. Dat is ook de bedoeling: de persona's zonder stelsel zijn er om snel vormgeving te bekijken, en dan hoort verversen een ander scenario te geven. Wél de bewaarde uitval aan de worp koppelen was een eerdere fout hier — dan hing het van de dobbelsteen af of een bericht van de weggevallen bron nog opende, en moest het scenario mee bewaard worden om dat recht te trekken. Eén functie bouwt wat de bron levert (`bouwLevering`), zodat `laad()` en de uitval-ná-het-laden niet uiteenlopen — die tweede gooide anders de binnengedruppelde berichten weg, ook die van een andere organisatie dan de bron die uitviel. `bron.herstelBronnen()` hoort onder de knop "Opnieuw proberen", `bron.vergeetUitval()` onder het uitzetten van de vlag; allebei leveren ze de lijst opnieuw, want de bron liet die berichten weg en alleen de bron kan ze teruggeven. De drie meldingsblokken in de template blijven waar ze zijn; de render-laag leest alleen nog de stand.
 - Tests: `npm test` (Vitest) draait de tests in `tests/`. Bewust niet naast de bron, omdat `.eleventy.js` de hele `assets`-map ongefilterd naar `_site` kopieert. `tests/berichtenbox/dom.js` bouwt een minimale berichtenbox-pagina voor de jsdom-tests van de render-laag.
diff --git a/assets/javascript/berichtenbox-keten.js b/assets/javascript/berichtenbox-keten.js
index 97c40b74..888f366d 100644
--- a/assets/javascript/berichtenbox-keten.js
+++ b/assets/javascript/berichtenbox-keten.js
@@ -15,9 +15,12 @@
  * Het draait vóór berichtenbox.js, zodat de ophaalronde zo vroeg mogelijk begint; de bron wacht die
  * af voordat hij zegt dat hij van toepassing is.
  *
- * En zolang de pagina openstaat kijkt hij periodiek of er berichten bij gekomen zijn: alleen de
- * lijst opnieuw opvragen, geen ophaalronde, dus de organisaties merken er niets van. Dat houdt
- * tegelijk de sessie bij het stelsel warm zolang de bezoeker kijkt.
+ * En zolang de pagina openstaat volgt hij wat er binnenkomt. Standaard over een verbinding waarop
+ * het stelsel zelf meldt dat er een bericht bij is (`_volgen`); lukt die niet, dan kijkt hij
+ * periodiek of de lijst veranderd is. Allebei zonder ophaalronde, dus de organisaties merken er
+ * niets van, en allebei houden ze de sessie bij het stelsel warm zolang de bezoeker kijkt: de lijst
+ * verlengt haar bij elke aanroep, de stroom bij de hartslag (zo ontworpen in
+ * MinBZK/moza-poc-fbs-berichtenbox#336).
  *
  * Berichten uit de keten komen niet in localStorage. Wat eerder opgehaald is staat op de server, in
  * een sessiecache per ontvanger. Elke berichtenbox-pagina vraagt daarom zelf de lijst op — ook het
@@ -87,19 +90,45 @@
 	// Ondergrens, ook als iemand om een korter interval vraagt: sneller levert geen zichtbaar
 	// verschil op en wel verkeer.
 	const POLL_MIN_SEC = 5;
-	// Zoveel mislukte pogingen op rij voordat de bezoeker het te horen krijgt en het pollen ermee
-	// ophoudt tot een herlading. Eén hik gaat vanzelf over; er meteen een melding van maken zou een
-	// probleem tonen dat er niet meer is.
+	// Zoveel mislukte pogingen op rij om de lijst op te halen voordat de bezoeker het te horen krijgt
+	// en het bijwerken ermee ophoudt tot een herlading — ook over de stroom, want ook daar hangt de
+	// lijst aan. Eén hik gaat vanzelf over; er meteen een melding van maken zou een probleem tonen
+	// dat er niet meer is.
 	const POLL_FOUT_LIMIET = 3;
 	// Zoveel keer proberen we een verlopen sessie met een nieuwe ophaalronde terug te halen. Zonder
-	// deze rem bevraagt een sessie die korter leeft dan het pollinterval bij elke tik alle
-	// organisaties opnieuw.
+	// deze rem bevraagt een sessie die korter leeft dan het pollinterval bij elke tik of
+	// herverbinding alle organisaties opnieuw.
 	const POLL_HERSTEL_LIMIET = 2;
 
+	// Het volgen: een verbinding waarop het stelsel zelf meldt dat er een bericht bij is, in plaats
+	// van dat wij elke vijftien seconden gaan kijken. Het periodiek navragen hierboven is daarvan de
+	// terugval.
+	//
+	// Het stelsel stuurt elke twintig seconden een hartslag. Blijft er vijfenveertig seconden alles
+	// stil — twee gemiste hartslagen en wat marge — dan is de verbinding weg zonder dat de browser
+	// het merkt: na een slaapstand of een wissel van wifi blijft een fetch gewoon wachten.
+	const VOLG_WAAKHOND_MS = 45000;
+	// Hoe lang we wachten voordat we opnieuw verbinden, oplopend per poging. Met wat spreiding, zodat
+	// tabbladen die tegelijk hun verbinding verloren niet ook tegelijk terugkomen.
+	const VOLG_TUSSENPOZEN_SEC = [1, 2, 5, 10, 30];
+	const VOLG_SPREIDING = 0.2;
+	// Zoveel verbindingen op rij die niet gezond worden — geen hartslag, en ook een 503, 429 of 200
+	// zonder stroom — en we vallen terug op het periodiek navragen. Stil: de berichtenbox werkt dan
+	// gewoon, nieuwe berichten verschijnen alleen wat later.
+	const VOLG_FOUT_LIMIET = 3;
+	// Na zo'n terugval proberen we de stroom na vijf minuten opnieuw. Drie mislukkingen binnen een
+	// paar seconden zijn vaker een wifi-wissel dan een keten die niet kan volgen. Alleen een keten die
+	// `_volgen` aantoonbaar niet kent, of die ook na een nieuwe ronde met 409 blijft antwoorden, laat
+	// de stroom tot een herlading met rust.
+	const VOLG_HERKANSING_MS = 5 * 60 * 1000;
+	// Hoogstens zo lang wachten we op een `Retry-After`. Zolang we wachten, verschijnt er niets
+	// nieuws, en een uur lang niets is erger dan een stelsel dat het na een minuut nog eens hoort.
+	const VOLG_MAX_WACHT_MS = 60 * 1000;
+
 	// Constructief en handelingsgericht: benoem wat er misging en wat de bezoeker kan doen.
 	// Handelingsgericht, en de handeling moet ook kúnnen. "Probeer het opnieuw" stond hier terwijl er
 	// geen knop is die dat doet: `opnieuw()` hieronder heeft nog steeds geen aanroeper in de interface.
-	// `herhaal()` wél — het pollen haalt daarmee een verlopen sessie terug — maar dat gebeurt buiten
+	// `herhaal()` wél — het pollen en het volgen halen daarmee een verlopen sessie terug — maar dat gebeurt buiten
 	// het zicht van de bezoeker. Zolang die knop er niet is, is verversen wat hem rest, en dat is ook
 	// wat de render-laag overal zegt.
 	const FOUT_TEKSTEN = {
@@ -113,7 +142,7 @@
 		// "Zijn nog niet opgehaald": er is geen sessie meer. Anders dan bij de andere meldingen helpt
 		// verversen hier echt, want dan draait de ophaalronde opnieuw en zet die de sessie terug. Deze
 		// tekst hoort bij het eerste laden; verloopt de sessie terwijl de bezoeker kijkt, dan vangt
-		// `pollTik` deze reden af en draait `herstelSessie` de ronde zelf opnieuw.
+		// `pollTik` of `verbindStroom` dat af en draait `herstelSessie` de ronde zelf opnieuw.
 		geenSessie: "Uw berichten zijn niet meer klaargezet bij het stelsel. Ververs de pagina; dan halen wij ze opnieuw op.",
 		afgebroken: "Het ophalen bij de bronnen is halverwege afgebroken. Uw berichten zijn daardoor niet volledig opgehaald. Ververs de pagina om het opnieuw te proberen.",
 		// De berichtenlijst komt per pagina. Breekt dat halverwege af, dan is er niets mis bij de
@@ -162,7 +191,7 @@
 	let ronde = null;
 	// De organisaties die de laatste eigen ronde meldde. Niet voor hun namen — die draagt elk bericht
 	// zelf — maar voor wie er niets te leveren had: zonder hen valt een organisatie uit het filter
-	// zodra het pollen de lijst vervangt, terwijl ze er bij het laden wél in stond.
+	// zodra het pollen of de stroom de lijst vervangt, terwijl ze er bij het laden wél in stond.
 	let organisatiesVanRonde = {};
 
 	// --- Wat de buitenwereld te horen krijgt ---------------------------------------------------
@@ -179,6 +208,8 @@
 	// alleen deze mag op null: kon de bron de lijst niet tonen, dan telt zij weer als wijziging (zie
 	// `vergeetGemeldeLijst`), terwijl `laatsteUitkomst` de laatst bekende lijst blijft.
 	let laatstGemeld = null;
+	// Hoeveel berichten zonder id het navragen het laatst meldde. Alleen een ander aantal is nieuws.
+	let gemeldOvergeslagen = 0;
 	const kijkers = [];
 
 	function laatWeten() {
@@ -378,8 +409,63 @@
 		}
 	}
 
-	// De ophaalronde is een Server-Sent-Events-stroom met voortgang per organisatie. EventSource kan
-	// geen eigen header meesturen, dus lezen we de stroom zelf uit.
+	/**
+	 * Leest een Server-Sent-Events-stroom uit, gebeurtenis voor gebeurtenis.
+	 *
+	 * EventSource kan geen eigen header meesturen, en het stelsel eist `X-Ontvanger`; daarom lezen we
+	 * de stroom zelf. Gedeeld door de ophaalronde (`_ophalen`) en het volgen (`_volgen`).
+	 *
+	 * `opLeven` hoort élk binnenkomend blok, ook een keep-alive zonder gebeurtenis: dat is wat een
+	 * stiltebewaking nodig heeft. `opGebeurtenis` krijgt het geparste JSON-object en geeft `true` terug
+	 * om te stoppen. Een frame dat geen JSON is, werpt, tenzij er een `opOnleesbaar` is: de ophaalronde
+	 * vertrouwt een stroom waarvan ze de helft niet kan lezen niet, het volgen slaat zo'n melding over. De stroom wordt altijd afgesloten, anders blijft de
+	 * backend doorwerken voor een lezer die er niet meer is.
+	 */
+	async function leesSse(body, opLeven, opGebeurtenis, opOnleesbaar) {
+		const lezer = body.getReader();
+		const decoder = new TextDecoder();
+		let buffer = "";
+
+		try {
+			for (;;) {
+				const blok = await lezer.read();
+				if (blok.done) return;
+				opLeven();
+
+				// Frames zijn gescheiden door een lege regel. Een server mag CRLF gebruiken; een
+				// chunkgrens mag midden in zo'n paar vallen, dus normaliseren we de hele buffer.
+				buffer = (buffer + decoder.decode(blok.value, { stream: true })).replace(/\r\n/g, "\n");
+
+				let scheiding;
+				while ((scheiding = buffer.indexOf("\n\n")) >= 0) {
+					const frame = buffer.slice(0, scheiding);
+					buffer = buffer.slice(scheiding + 2);
+					// Meerdere data-regels in één frame horen aaneengeplakt te worden met \n.
+					const payload = frame
+						.split("\n")
+						.filter((regel) => regel.indexOf("data:") === 0)
+						.map((regel) => regel.slice(5).replace(/^ /, ""))
+						.join("\n");
+					if (payload.trim() === "") continue;
+					let gebeurtenis;
+					try {
+						gebeurtenis = JSON.parse(payload);
+					} catch (fout) {
+						if (!opOnleesbaar) throw fout;
+						opOnleesbaar(payload, fout);
+						continue;
+					}
+					if (opGebeurtenis(gebeurtenis) === true) return;
+				}
+			}
+		} finally {
+			lezer.cancel().catch(() => {
+				/* stroom al dicht */
+			});
+		}
+	}
+
+	// De ophaalronde is een Server-Sent-Events-stroom met voortgang per organisatie.
 	async function haalOp(ontvanger) {
 		const organisaties = {};
 		const stil = [];
@@ -425,10 +511,6 @@
 			throw ketenFout("onbereikbaar", "ophalen leverde geen stroom op");
 		}
 
-		const lezer = respons.body.getReader();
-		const decoder = new TextDecoder();
-		let buffer = "";
-
 		function verwerk(gebeurtenis) {
 			if (gebeurtenis.magazijnId) {
 				organisaties[gebeurtenis.magazijnId] = gebeurtenis.naam || gebeurtenis.magazijnId;
@@ -446,42 +528,17 @@
 
 			toonVoortgang(Object.keys(organisaties).length, klaar, gevonden);
 			if (gebeurtenis.event === "ophalen-gereed") gereed = true;
+			// Na "ophalen-gereed" stoppen: de stroom afsluiten, anders loopt de backend elke
+			// resterende organisatie nog af.
+			return gereed;
 		}
 
 		try {
-			for (;;) {
-				const blok = await lezer.read();
-				if (blok.done) break;
-
-				// Elk teken uit de stroom telt als teken van leven, ook een SSE-keep-alive (":ping").
-				// Alleen op geparste gebeurtenissen resetten zou een trage organisatie afkappen.
-				herstartStilteKlok();
-
-				// Frames zijn gescheiden door een lege regel. Een server mag CRLF gebruiken; een
-				// chunkgrens mag midden in zo'n paar vallen, dus normaliseren we de hele buffer.
-				buffer = (buffer + decoder.decode(blok.value, { stream: true })).replace(/\r\n/g, "\n");
-
-				let scheiding;
-				while ((scheiding = buffer.indexOf("\n\n")) >= 0) {
-					const frame = buffer.slice(0, scheiding);
-					buffer = buffer.slice(scheiding + 2);
-					// Meerdere data-regels in één frame horen aaneengeplakt te worden met \n.
-					const payload = frame
-						.split("\n")
-						.filter((regel) => regel.indexOf("data:") === 0)
-						.map((regel) => regel.slice(5).replace(/^ /, ""))
-						.join("\n");
-					if (payload.trim() !== "") verwerk(JSON.parse(payload));
-				}
-
-				if (gereed) break;
-			}
+			// Elk teken uit de stroom telt als teken van leven, ook een SSE-keep-alive (":ping").
+			// Alleen op geparste gebeurtenissen resetten zou een trage organisatie afkappen.
+			await leesSse(respons.body, herstartStilteKlok, verwerk);
 		} finally {
 			clearTimeout(stilteKlok);
-			// De stroom afsluiten, anders loopt de backend elke resterende organisatie nog af.
-			lezer.cancel().catch(() => {
-				/* stroom al dicht */
-			});
 		}
 
 		// Een stroom die eindigt zonder "ophalen-gereed" is afgebroken. Die zou een halve lijst als
@@ -751,6 +808,14 @@
 		return !!(persona && persona.stelsel);
 	}
 
+	// Zelfde vraag als hieronder, zonder console-regel: voor een pagina die uit de bfcache terugkomt
+	// en alleen wil weten of de persona nog dezelfde is.
+	function actiefKvkNummerStil() {
+		const persona = window.Personas && typeof window.Personas.actief === "function" ? window.Personas.actief() : null;
+		const nummer = persona && persona.bedrijf && persona.bedrijf.kvkNummer;
+		return nummer ? String(nummer) : null;
+	}
+
 	function actiefKvkNummer() {
 		if (!window.Personas || typeof window.Personas.actief !== "function") {
 			console.error("[Berichtenbox] keten overgeslagen: window.Personas ontbreekt.");
@@ -910,8 +975,8 @@
 
 			const magazijnen = magazijnenVan(berichten, uitvraag.organisaties);
 
-			// Het pollen bouwt het filter op dezelfde manier op, dus het krijgt dezelfde organisaties
-			// mee.
+			// Het pollen en de stroom bouwen het filter op dezelfde manier op, dus ze krijgen dezelfde
+			// organisaties mee.
 			organisatiesVanRonde = uitvraag.organisaties;
 
 			// De tellers boven de lijst tonen zelf hoeveel bronnen antwoordden; alleen een
@@ -962,16 +1027,43 @@
 	let pollBezig = false;
 	let pollHerstelBezig = false;
 	let laatsteTikOp = 0;
+	// Kwam er tijdens een tik een `volgen-gestart` binnen, dan hoort er daarna nog een: de lopende
+	// tik begon vóór het volgen, en wat er tussen die twee binnenkwam, staat in geen van beide.
+	let tikNogEens = false;
+
+	// De stroom. `volgAfbreker` is er zolang er een verbinding openstaat of opgezet wordt; wie hem
+	// weghaalt en afbreekt, sluit de stroom bewust en wil geen vervolg.
+	let volgAfbreker = null;
+	let volgKlok = null;
+	// Waar we zijn in de reeks tussenpozen, en hoeveel verbindingen op rij niet gezond werden. Allebei
+	// terug naar nul bij de eerste hartslag van een verbinding, en bij `pageshow`.
+	let volgPoging = 0;
+	let volgMislukt = 0;
+	// Hoe vaak `_volgen` met 409 antwoordde sinds de laatste gezonde verbinding. Eén keer is een
+	// verlopen sessie; twee keer, met een ronde ertussen, is iets anders.
+	let volgConflicten = 0;
+	// Waarom we navragen in plaats van volgen: `null` (we volgen), "tijdelijk" (de verbinding kwam niet
+	// op gang; over vijf minuten weer proberen) of "blijvend" (deze keten kan het niet; tot een
+	// herlading navragen).
+	let volgTeruggevallen = null;
+	// Soorten gebeurtenissen die we niet kennen en al in de console noemden. Eén keer per soort: de
+	// hartslag komt elke twintig seconden, en een onbekende soort mogelijk net zo vaak.
+	const onbekendeSoorten = new Set();
+	// Wat de stroom meldde terwijl er een tik liep. Die tik kan een lijst opleveren die van vóór zo'n
+	// bericht is; zonder dit haalt hij het weer van het scherm.
+	let bijgekomenTijdensTik = null;
 
 	/**
-	 * Een instelling in seconden: eerst de URL, dan localStorage, anders de standaardwaarde.
+	 * Een getal uit de instellingen: eerst de URL, dan localStorage, anders de standaardwaarde. Meestal
+	 * seconden; voor `volgen` is het een aan/uit, waarbij nul uit is.
 	 *
 	 * De URL wint, zodat een gedeelde demo-link zijn eigen ritme meebrengt zonder dat iemand eerst
 	 * iets hoeft om te zetten. Wat nul of minder betekent, beslist de aanroeper: zie `pollTussenpoos`
 	 * hieronder, waar de zichtbare nul uitzet en de verborgen pauzeert. Een negatief getal is een
 	 * typefout en krijgt hetzelfde antwoord als nul, want een ritme is het niet. Het Flags-paneel
-	 * heeft voor geen van beide een veld: wie ze zonder de URL wil bijstellen, zet
-	 * `setting:berichtenbox-poll` of `setting:berichtenbox-poll-verborgen` zelf.
+	 * heeft voor geen van drieën een veld: wie ze zonder de URL wil bijstellen, zet
+	 * `setting:berichtenbox-poll`, `setting:berichtenbox-poll-verborgen` of
+	 * `setting:berichtenbox-volgen` zelf.
 	 */
 	function ingesteldeSeconden(urlSleutel, instelling, standaard) {
 		const uitUrl = parseInt(new URLSearchParams(location.search).get(urlSleutel), 10);
@@ -1007,6 +1099,25 @@
 		return Math.max(zichtbaar, POLL_MIN_SEC) * 1000;
 	}
 
+	/**
+	 * Volgen we over de stroom, of vragen we periodiek na?
+	 *
+	 * `?volgen=0` of `setting:berichtenbox-volgen` op `0` zet de stroom uit, zodat een demonstratie
+	 * beide kan laten zien. Dan geldt het periodiek navragen, met zijn eigen instellingen.
+	 */
+	function volgtStroom() {
+		return !volgTeruggevallen && ingesteldeSeconden("volgen", "setting:berichtenbox-volgen", 1) > 0;
+	}
+
+	/** Volgen wat er binnenkomt, op de manier die nu geldt. */
+	function hervat() {
+		if (volgtStroom()) {
+			verbindStroom();
+		} else {
+			planPoll();
+		}
+	}
+
 	function startPoll() {
 		if (pollGestopt) return;
 		// Niet ontparkeren: een ronde die afrondt ná `pagehide` zou anders het pollen weer aanzetten op
@@ -1020,13 +1131,14 @@
 			window.addEventListener("pageshow", opTerugkomen);
 			pollLuistert = true;
 		}
-		planPoll();
+		hervat();
 	}
 
 	function planPoll() {
 		clearTimeout(pollKlok);
 		pollKlok = null;
-		if (!pollMag()) return;
+		// Over de stroom komt het vanzelf; navragen is dan alleen verkeer.
+		if (!pollMag() || volgtStroom()) return;
 
 		const tussenpoos = pollTussenpoos();
 		if (!tussenpoos) return;
@@ -1041,7 +1153,8 @@
 	}
 
 	/**
-	 * De pagina gaat weg: het pollen pauzeert. Altijd pauzeren en nooit blijvend stoppen, want
+	 * De pagina gaat weg: het volgen pauzeert. De stroom gaat dicht en een geplande tik vervalt.
+	 * Altijd pauzeren en nooit blijvend stoppen, want
 	 * `pagehide` weet niet betrouwbaar of de browser deze pagina bewaart — Safari en iOS melden dat
 	 * niet — en `pageshow` weet het wél. Een document dat écht vernietigd wordt draait toch niets
 	 * meer, dus pauzeren kost daar niets; een document dat terugkomt zou anders dood zijn, en van de
@@ -1050,26 +1163,48 @@
 	function opWeggaan() {
 		clearTimeout(pollKlok);
 		pollKlok = null;
+		sluitStroom();
 		pollGeparkeerd = true;
 	}
 
 	/**
 	 * De pagina is terug uit de bfcache: het script draaide niet opnieuw, dus alleen wij kunnen het
-	 * pollen weer aanzetten. Meteen kijken en niet een interval wachten — er kan intussen van alles
-	 * binnengekomen zijn, en de sessie bij het stelsel kan verlopen zijn.
+	 * volgen weer aanzetten. Meteen, en niet een interval wachten — er kan intussen van alles
+	 * binnengekomen zijn, en de sessie bij het stelsel kan verlopen zijn. Over de stroom haalt
+	 * `volgen-gestart` de lijst bij; anders kijken we zelf. Is er intussen een andere persona
+	 * gekozen, dan houdt deze pagina op met volgen.
 	 */
 	function opTerugkomen() {
 		if (pollGestopt || !pollGeparkeerd) return;
+		// Intussen een andere persona gekozen, en met de terugknop hier weer beland: deze pagina hoort
+		// bij iemand anders, en met zijn ontvanger verder volgen zou diens post binnenhalen.
+		if (actiefKvkNummerStil() !== kvkNummer) {
+			console.info("[Berichtenbox] Er is intussen een andere persona gekozen; deze pagina volgt niet meer.");
+			stopPoll();
+			return;
+		}
 		pollGeparkeerd = false;
 		// De reeks begint opnieuw: wat er misging hoorde bij een pagina die weg was.
 		pollFouten = 0;
-		pollTik();
+		volgPoging = 0;
+		volgMislukt = 0;
+		volgConflicten = 0;
+		// Een tijdelijke terugval hoorde bij de verbinding van toen; de klok voor de herkansing is bij
+		// het weggaan gestopt.
+		if (volgTeruggevallen === "tijdelijk") volgTeruggevallen = null;
+		// Over de stroom haalt `volgen-gestart` de lijst bij; anders kijken we meteen.
+		if (volgtStroom()) {
+			verbindStroom();
+		} else {
+			pollTik();
+		}
 	}
 
 	function stopPoll() {
 		pollGestopt = true;
 		clearTimeout(pollKlok);
 		pollKlok = null;
+		sluitStroom();
 		if (pollLuistert) {
 			document.removeEventListener("visibilitychange", opZichtbaarheid);
 			window.removeEventListener("pagehide", opWeggaan);
@@ -1084,7 +1219,9 @@
 	 * tussenpoos voor een tabblad dat niemand voor zich heeft.
 	 */
 	function opZichtbaarheid() {
-		if (!pollMag()) return;
+		// Een verborgen tabblad blijft verbonden: het stelsel verlengt de sessie bij elke hartslag, en
+		// een stille verbinding kost niets.
+		if (!pollMag() || volgtStroom()) return;
 
 		// Wel meteen kijken, niet bij élke tabwissel: heen en weer schakelen zou anders een reeks
 		// verzoeken opleveren, en de ondergrens staat er juist om dat te voorkomen.
@@ -1104,6 +1241,7 @@
 		clearTimeout(pollKlok);
 		pollKlok = null;
 		pollBezig = true;
+		bijgekomenTijdensTik = new Map();
 		laatsteTikOp = Date.now();
 		// Waar deze tik bij hoort. Draait er onderweg een nieuwe ophaalronde, dan is wat hier
 		// terugkomt ouder dan wat die ronde opleverde.
@@ -1121,7 +1259,11 @@
 			// hoort mee te tellen in de foutenreeks en niet die van zijn voorgangers te wissen.
 			verwerkPolllijst(lijst);
 			pollFouten = 0;
-			pollHerstelPogingen = 0;
+			// Over de stroom zegt een geslaagde tik niets over de sessie: die komt meteen na een
+			// herstelronde, als de sessie net gevuld is. Daar zet de eerste hartslag de rem terug;
+			// deed deze tik dat, dan draaide een sessie die korter leeft dan één cyclus eindeloos
+			// rondes langs alle organisaties.
+			if (!volgtStroom()) pollHerstelPogingen = 0;
 		} catch (fout) {
 			if (achterhaald(rondeVanTik)) return;
 
@@ -1140,8 +1282,23 @@
 				meld("mededeling", POLL_GESTOPT_TEKSTEN.fouten);
 				return;
 			}
+			// Over de stroom komt er geen volgende tik vanzelf, en deze lijst was de aansluiting op
+			// wat er vóór het volgen binnenkwam. Dus zelf opnieuw proberen, na de standaard zichtbare
+			// tussenpoos van het navragen (15 s): dan overleeft de berichtenbox een hapering van de lijst net zo lang als bij
+			// het navragen. De stroom zelf werkt en blijft open; die afbreken en opnieuw verbinden zou
+			// elke seconde een tik opleveren, en na drie daarvan houdt het bijwerken op.
+			if (volgtStroom()) {
+				clearTimeout(pollKlok);
+				pollKlok = setTimeout(lijstTik, POLL_ZICHTBAAR_SEC * 1000);
+				return;
+			}
 		} finally {
 			pollBezig = false;
+			bijgekomenTijdensTik = null;
+			if (tikNogEens) {
+				tikNogEens = false;
+				setTimeout(pollTik, 0);
+			}
 		}
 
 		planPoll();
@@ -1150,9 +1307,10 @@
 	/**
 	 * Hoort dit antwoord nog bij de pagina zoals die er nu voor staat?
 	 *
-	 * Zo niet, dan vervalt het — maar het pollen zelf hoeft daar niet aan te stoppen. Draait er een
-	 * nieuwere ronde, dan plannen we gewoon de volgende tik; is de pagina weg of hebben we het
-	 * opgegeven, dan zorgt `opTerugkomen` of niemand voor het vervolg.
+	 * Zo niet, dan vervalt het — maar het volgen zelf hoeft daar niet aan te stoppen. Draait er een
+	 * nieuwere ronde, dan plannen we bij het navragen gewoon de volgende tik; over de stroom neemt
+	 * die ronde het over, via `herhaal` en `hervat`. Is de pagina weg of hebben we het opgegeven,
+	 * dan zorgt `opTerugkomen` of niemand voor het vervolg.
 	 */
 	function achterhaald(rondeVanTik) {
 		if (pollGestopt || pollGeparkeerd) return true;
@@ -1181,19 +1339,35 @@
 		}
 
 		const ruw = lijst.berichten;
-		const berichten = ruw.filter(bruikbaar).map((bericht) => naarBerichtenboxVorm(bericht));
+		const bruikbare = ruw.filter(bruikbaar);
+		// Vóór het samenvoegen hieronder tellen: een binnenkomer uit de stroom maakt de lijst weer even
+		// lang en verstopt zo een bericht zonder id.
+		const overgeslagen = ruw.length - bruikbare.length;
+		const berichten = bruikbare.map((bericht) => naarBerichtenboxVorm(bericht));
+
+		// Wat de stroom meldde terwijl deze lijst onderweg was, kan er nog niet in staan. Het staat al
+		// op het scherm; zonder dit ziet de bron het verdwijnen en haalt hij het weer weg.
+		if (bijgekomenTijdensTik) {
+			const inLijst = new Set(berichten.map((bericht) => bericht.id));
+			for (const bericht of bijgekomenTijdensTik.values()) {
+				if (!inLijst.has(bericht.id)) berichten.unshift(bericht);
+			}
+		}
 
 		// Zelfde telling als in de ophaalronde: een bericht zonder id kan nergens heen, maar het
 		// verdwijnt hier wél uit de berichtenbox van iemand die het bij het stelsel wel heeft staan.
-		if (laatstGemeld && zelfdeBerichten(laatstGemeld, berichten)) return;
-
-		// Pas melden als de lijst werkelijk veranderd is. Het meldingsblok is een live-regio: elke
-		// keer dezelfde tekst erin schrijven laat een schermlezer hem elke keer voorlezen.
-		const overgeslagen = ruw.length - berichten.length;
-		if (overgeslagen > 0) {
+		// Vóór de vergelijking hieronder: is zo'n bericht de enige wijziging, dan is de lijst verder
+		// dezelfde en kwam het nooit ter sprake. Alleen als het aantal verandert, want het meldingsblok
+		// is een live-regio: dezelfde tekst er elke tik opnieuw in schrijven laat een schermlezer hem
+		// elke keer voorlezen.
+		if (overgeslagen > 0 && overgeslagen !== gemeldOvergeslagen) {
 			console.error("[Berichtenbox] " + overgeslagen + " bericht(en) zonder berichtId overgeslagen tijdens het pollen.");
 			toonOnbruikbaar(overgeslagen);
 		}
+		gemeldOvergeslagen = overgeslagen;
+
+		// Pas een lijst melden als die werkelijk veranderd is; om dezelfde reden.
+		if (laatstGemeld && zelfdeBerichten(laatstGemeld, berichten)) return;
 
 		laatsteUitkomst = { berichten: berichten, magazijnen: magazijnenVan(berichten, organisatiesVanRonde) };
 		laatstGemeld = berichten;
@@ -1229,15 +1403,18 @@
 	}
 
 	/**
-	 * Haalt een verlopen sessie terug met een nieuwe ophaalronde, en pakt het pollen daarna weer op.
+	 * Haalt een verlopen sessie terug met een nieuwe ophaalronde, en pakt het volgen daarna weer op:
+	 * de stroom, of het navragen.
 	 *
-	 * Dit is de enige plek waar het pollen de organisaties laat bevragen. Dat mag hier: zonder
+	 * Dit is de enige plek waar het volgen de organisaties laat bevragen. Dat mag hier: zonder
 	 * sessie is er niets te lezen, en de bezoeker die zijn berichtenbox openhoudt hoort niet stil
 	 * achter te blijven bij een lijst die niet meer bijgewerkt wordt.
 	 */
 	function herstelSessie() {
 		clearTimeout(pollKlok);
 		pollKlok = null;
+		// Zonder sessie heeft de stroom niets meer te melden. Na het herstel verbindt `hervat` opnieuw.
+		sluitStroom();
 
 		if (pollHerstelPogingen >= POLL_HERSTEL_LIMIET) {
 			stopPoll();
@@ -1268,10 +1445,10 @@
 					return;
 				}
 				// De reeks mislukte tikken hoort bij de sessie die weg was, niet bij de nieuwe. En het
-				// plannen gebeurt hier: `herhaal` probeerde dat al, maar toen zat dit slot nog dicht en
-				// ketste `planPoll` af op `pollMag()`.
+				// hervatten gebeurt hier: `herhaal` probeerde dat al, maar toen zat dit slot nog dicht en
+				// ketste het af op `pollMag()`.
 				pollFouten = 0;
-				planPoll();
+				hervat();
 			},
 			(fout) => {
 				pollHerstelBezig = false;
@@ -1314,6 +1491,292 @@
 		return ronde;
 	}
 
+	// --- Volgen over de stroom ----------------------------------------------------------------
+
+	/**
+	 * Opent de verbinding waarop het stelsel meldt wat er binnenkomt (`GET /api/v1/berichten/_volgen`).
+	 *
+	 * De stroom begint met `volgen-gestart`: vanaf dan komt elk nieuw bericht als `bericht-bijgekomen`
+	 * voorbij, en wat daarvóór binnenkwam staat in de lijst. Daarom haalt die gebeurtenis de lijst
+	 * één keer op. Een bericht op het grensvlak kan in allebei zitten; dubbel tonen we het niet, want
+	 * `voegBijgekomenToe` en de bron kijken allebei naar het `berichtId`. Opnieuw verbinden na een
+	 * haperende verbinding gaat precies zo, en daarna is de lijst dus weer compleet.
+	 *
+	 * Een verbinding die niet tot stand komt of wegvalt, blijft stil voor de bezoeker: de lijst die er
+	 * staat klopt, en wie niet verbonden raakt, krijgt het periodiek navragen. Nieuwe berichten
+	 * verschijnen dan wat later, maar ze verschijnen wel; alleen de console zegt wat er aan de hand
+	 * is. Een mededeling komt er alleen als het bijwerken helemaal ophoudt: een sessie die niet terug
+	 * te halen is, of een lijst die drie keer op rij niet binnenkomt — dezelfde als bij het navragen.
+	 *
+	 * Een verbinding telt pas als gezond na haar eerste hartslag, en niet al bij `volgen-gestart`. Een
+	 * stroom die telkens net na de start wegvalt — een tussenlaag die hem sluit, een time-out korter
+	 * dan de hartslag — zou anders elke seconde opnieuw verbinden en de lijst ophalen, zonder ooit op
+	 * te geven.
+	 */
+	async function verbindStroom() {
+		clearTimeout(volgKlok);
+		volgKlok = null;
+		if (!pollMag() || volgAfbreker || !volgtStroom()) return;
+
+		const afbreker = new AbortController();
+		volgAfbreker = afbreker;
+		let waakhond = null;
+		const herstartWaakhond = () => {
+			clearTimeout(waakhond);
+			waakhond = setTimeout(() => afbreker.abort(), VOLG_WAAKHOND_MS);
+		};
+
+		// Hoe de stroom eindigde: "afgebroken" (ook netjes geëindigd of niet geopend: opnieuw
+		// verbinden), "verlopen" (het stelsel meldde dat
+		// de sessie weg is), "conflict" (een 409 bij het openen) of "ontbreekt" (deze keten kent
+		// `_volgen` niet).
+		let einde = "afgebroken";
+		let status = null;
+		let gezond = false;
+		let wachtMinstens = 0;
+		const geopend = Date.now();
+
+		// Vóór de fetch, niet erna: na een slaapstand blijft juist het openen hangen.
+		herstartWaakhond();
+		try {
+			const respons = await fetch("/api/v1/berichten/_volgen", {
+				headers: { "X-Ontvanger": ontvangerVanRonde, Accept: "text/event-stream" },
+				signal: afbreker.signal,
+			});
+			status = respons.status;
+
+			// Een keten zonder `_volgen` leest dit pad als `GET /berichten/{berichtId}`: 404 zonder
+			// `Accept`, en 406 mét — dat adres levert alleen JSON. Gemeten tegen de publieke omgeving.
+			if (status === 404 || status === 405 || status === 406) {
+				einde = "ontbreekt";
+			} else if (status === 409) {
+				// Zelfde betekenis als een 409 op de lijst: er is (nog) geen sessie, dus een herstelronde.
+				einde = "conflict";
+			} else if (!respons.ok || !respons.body || !isStroom(respons)) {
+				// Een 503 of 429 zegt hoe lang we moeten wachten: het stelsel is druk, of er staan voor
+				// deze ontvanger al te veel berichtenboxen open. Een 200 zonder stroom is een tussenlaag
+				// die iets anders teruggeeft, een foutpagina bijvoorbeeld; daar valt niets uit te lezen.
+				if (status === 503 || status === 429) wachtMinstens = Math.min(wachttijdVan(respons), VOLG_MAX_WACHT_MS);
+				// Een open body van een antwoord dat we niet lezen, houdt bij het stelsel een plek
+				// bezet; per ontvanger zijn er vijf.
+				if (respons.body) {
+					respons.body.cancel().catch(() => {
+						/* al dicht */
+					});
+				}
+				console.warn("[Berichtenbox] Het volgen van nieuwe berichten kwam niet tot stand (" + status + (respons.ok ? ", geen text/event-stream" : "") + ").");
+			} else {
+				// De waakhond herstart op een gebeurtenis die we konden lezen, niet op elk binnenkomend
+				// blok: een stroom die alleen onleesbare frames levert, bleef anders een uur open.
+				await leesSse(
+					respons.body,
+					() => {},
+					(gebeurtenis) => {
+						herstartWaakhond();
+						// Eén gebeurtenis die we niet kunnen verwerken, is geen weggevallen verbinding. Zou
+						// die fout de stroom meenemen, dan verbindt de berichtenbox opnieuw, struikelt de
+						// lijst over hetzelfde bericht, en houdt het bijwerken na drie rondes op — onder de
+						// noemer "verbinding weggevallen", die de oorzaak juist verbergt.
+						try {
+							return verwerkVolgGebeurtenis(gebeurtenis);
+						} catch (fout) {
+							// Overgeslagen, maar niet vergeten: de lijst brengt het bericht alsnog. Gaat het
+							// mis in de vertaling die de lijst ook gebruikt, dan faalt die tik net zo, en
+							// houdt het bijwerken na drie keer op met de bestaande mededeling.
+							console.error("[Berichtenbox] Een melding uit de stroom kon niet verwerkt worden; overgeslagen.", gebeurtenis, fout);
+							planLijstTik();
+							return false;
+						}
+					},
+					(frame, fout) => {
+						console.error("[Berichtenbox] Een melding uit de stroom was geen JSON; overgeslagen.", frame, fout);
+					}
+				);
+				console.info("[Berichtenbox] De stroom met nieuwe berichten eindigde na " + Math.round((Date.now() - geopend) / 1000) + " s.");
+			}
+		} catch (fout) {
+			// De waakhond of het netwerk: opnieuw verbinden.
+			if (volgAfbreker === afbreker) console.warn("[Berichtenbox] De verbinding voor nieuwe berichten viel weg na " + Math.round((Date.now() - geopend) / 1000) + " s.", fout);
+		} finally {
+			clearTimeout(waakhond);
+		}
+
+		function verwerkVolgGebeurtenis(gebeurtenis) {
+			const soort = gebeurtenis && gebeurtenis.event;
+			if (soort === "volgen-gestart") {
+				lijstTik();
+			} else if (soort === "hartslag") {
+				if (!gezond) {
+					gezond = true;
+					volgPoging = 0;
+					volgMislukt = 0;
+					volgConflicten = 0;
+					pollHerstelPogingen = 0;
+				}
+			} else if (soort === "bericht-bijgekomen") {
+				voegBijgekomenToe(gebeurtenis.bericht);
+			} else if (soort === "sessie-verlopen") {
+				einde = "verlopen";
+				return true;
+			} else if (!onbekendeSoorten.has(soort)) {
+				// Niets te doen, maar wel één keer zeggen: een hernoemde `bericht-bijgekomen` zou er
+				// anders net zo uitzien als een stroom waarop niets gebeurt.
+				onbekendeSoorten.add(soort);
+				console.warn("[Berichtenbox] Onbekende melding uit de stroom genegeerd: " + soort);
+			}
+			return false;
+		}
+
+		// Weggehaald door `sluitStroom`: de pagina gaat weg, we houden ermee op, of een herstelronde
+		// verbindt straks zelf opnieuw. Hier dan geen vervolg.
+		if (volgAfbreker !== afbreker) return;
+		volgAfbreker = null;
+		if (!pollMag()) return;
+
+		if (einde === "ontbreekt") {
+			valTerug("blijvend", "deze keten kent _volgen niet, status " + status);
+			return;
+		}
+		if (einde === "verlopen") {
+			console.info("[Berichtenbox] Het stelsel meldt dat de sessie verlopen is; er volgt een nieuwe ophaalronde.");
+			herstelSessie();
+			return;
+		}
+		if (einde === "conflict") {
+			// Eén keer is een verlopen sessie, en dan hoort er een ronde bij. Blijft `_volgen` met 409
+			// antwoorden terwijl er net een ronde gedraaid heeft, dan ligt het niet aan de sessie:
+			// verder herstellen bevraagt telkens alle organisaties, en houdt na twee keer op met een
+			// mededeling, terwijl het navragen gewoon werkt.
+			volgConflicten += 1;
+			if (volgConflicten >= 2) {
+				valTerug("blijvend", "_volgen antwoordt ook na een nieuwe ophaalronde met 409");
+				return;
+			}
+			console.info("[Berichtenbox] _volgen antwoordde met 409; er volgt een nieuwe ophaalronde.");
+			herstelSessie();
+			return;
+		}
+		if (!gezond) {
+			volgMislukt += 1;
+			if (volgMislukt >= VOLG_FOUT_LIMIET) {
+				valTerug("tijdelijk", volgMislukt + " verbindingen op rij kwamen niet tot een hartslag" + (status && status !== 200 ? ", laatste status " + status : ""));
+				return;
+			}
+		}
+		// Ook een stroom die netjes eindigt: die duurt bij het stelsel hoogstens een uur.
+		planHerverbinding(wachtMinstens);
+	}
+
+	function isStroom(respons) {
+		const soort = respons.headers && typeof respons.headers.get === "function" ? respons.headers.get("Content-Type") : null;
+		return !!soort && soort.indexOf("text/event-stream") === 0;
+	}
+
+	/** Sluit de stroom, zonder vervolg. */
+	function sluitStroom() {
+		clearTimeout(volgKlok);
+		volgKlok = null;
+		if (!volgAfbreker) return;
+		const afbreker = volgAfbreker;
+		volgAfbreker = null;
+		afbreker.abort();
+	}
+
+	function planHerverbinding(wachtMinstens) {
+		clearTimeout(volgKlok);
+		const stap = VOLG_TUSSENPOZEN_SEC[Math.min(volgPoging, VOLG_TUSSENPOZEN_SEC.length - 1)];
+		volgPoging += 1;
+		const spreiding = 1 + (Math.random() * 2 - 1) * VOLG_SPREIDING;
+		volgKlok = setTimeout(verbindStroom, Math.max(stap * 1000 * spreiding, wachtMinstens));
+	}
+
+	/**
+	 * Periodiek navragen in plaats van volgen. Geen melding: de berichtenbox werkt gewoon, en dat nieuwe
+	 * berichten wat later verschijnen, hoeft de bezoeker niet te weten.
+	 *
+	 * `soort` is "blijvend" (tot een herlading) of "tijdelijk": dan proberen we de stroom over vijf
+	 * minuten opnieuw, en ook als de pagina uit de bfcache terugkomt.
+	 */
+	function valTerug(soort, reden) {
+		console.warn("[Berichtenbox] Nieuwe berichten volgen lukt nu niet (" + reden + "); de berichtenbox kijkt " + (soort === "blijvend" ? "voortaan" : "voorlopig") + " periodiek.");
+		volgTeruggevallen = soort;
+		sluitStroom();
+		planPoll();
+		if (soort === "tijdelijk") volgKlok = setTimeout(herkansStroom, VOLG_HERKANSING_MS);
+	}
+
+	/**
+	 * Na een tijdelijke terugval: de stroom opnieuw proberen. De reeks tussenpozen loopt door waar ze
+	 * was, dus lukt het weer niet, dan wachten de volgende pogingen 10 en 30 seconden.
+	 */
+	function herkansStroom() {
+		if (volgTeruggevallen !== "tijdelijk") return;
+		volgTeruggevallen = null;
+		volgMislukt = 0;
+		clearTimeout(pollKlok);
+		pollKlok = null;
+		verbindStroom();
+	}
+
+	/**
+	 * De lijst over een paar seconden ophalen, één keer, ook als er meer aanleidingen komen. Voor een
+	 * bericht dat de stroom meldde maar dat we niet konden verwerken, en voor een lijst die de bron
+	 * niet kon tonen: over de stroom komt er geen volgende tik vanzelf.
+	 */
+	function planLijstTik() {
+		if (pollKlok) return;
+		pollKlok = setTimeout(() => {
+			pollKlok = null;
+			lijstTik();
+		}, POLL_MIN_SEC * 1000);
+	}
+
+	/** `Retry-After` in milliseconden: seconden of een datum, en nul als hij ontbreekt. */
+	function wachttijdVan(respons) {
+		const waarde = respons.headers && typeof respons.headers.get === "function" ? respons.headers.get("Retry-After") : null;
+		if (!waarde) return 0;
+		const seconden = Number(waarde);
+		if (Number.isFinite(seconden)) return Math.max(0, seconden * 1000);
+		const tijdstip = Date.parse(waarde);
+		return Number.isFinite(tijdstip) ? Math.max(0, tijdstip - Date.now()) : 0;
+	}
+
+	/** De lijst één keer ophalen; loopt er al een tik, dan nog één zodra die klaar is. */
+	function lijstTik() {
+		if (pollBezig) {
+			tikNogEens = true;
+			return;
+		}
+		pollTik();
+	}
+
+	/**
+	 * Een bericht dat de stroom meldt, erbij zetten, tenzij het er al staat.
+	 *
+	 * Het draagt zijn afzendernaam zelf, dus er hoeft niets nagevraagd te worden. Het gaat als een
+	 * gewijzigde lijst naar de bron, en die ziet er één binnenkomer in: dezelfde weg als een bericht
+	 * dat het periodiek navragen vindt.
+	 */
+	function voegBijgekomenToe(ruw) {
+		if (!bruikbaar(ruw)) {
+			console.error("[Berichtenbox] De stroom meldde een bericht zonder berichtId; overgeslagen.", ruw);
+			// De lijst telt het mee en zegt de bezoeker dat er een bericht niet te tonen is.
+			planLijstTik();
+			return;
+		}
+		const bericht = naarBerichtenboxVorm(ruw);
+		if (bijgekomenTijdensTik) bijgekomenTijdensTik.set(bericht.id, bericht);
+
+		// Zonder eerdere lijst valt er niets aan toe te voegen; de tik na `volgen-gestart` brengt het.
+		if (!laatsteUitkomst) return;
+		if (laatsteUitkomst.berichten.some((bestaand) => bestaand.id === bericht.id)) return;
+
+		const berichten = [bericht].concat(laatsteUitkomst.berichten);
+		laatsteUitkomst = { berichten: berichten, magazijnen: magazijnenVan(berichten, organisatiesVanRonde) };
+		laatstGemeld = berichten;
+		laatWeten();
+	}
+
 	// --- Start --------------------------------------------------------------------------------
 
 	// Alleen op pagina's die een berichtenbox tonen: elders is er niets te vervangen, en zou een
@@ -1340,7 +1803,7 @@
 		ronde = draaiRonde(kvkNummer);
 		// Pas kijken of er berichten bij komen als er iets is om mee te vergelijken. De uitkomst
 		// hier vastleggen en niet aan `berichten()` overlaten: die wordt alleen aangeroepen door een
-		// pagina met een bronregister, en het pollen houdt ook op een detailpagina de sessie warm.
+		// pagina met een bronregister, en het volgen houdt ook op een detailpagina de sessie warm.
 		ronde.then(
 			(uitkomst) => {
 				if (!uitkomst) return;
@@ -1449,8 +1912,8 @@
 
 		/**
 		 * De lijst zoals die er nu is. Voor een bron die zich later aanmeldt: tussen het kiezen van de
-		 * bron en het aanhaken van zijn luisteraar kan er een polltik geland zijn, en die is hier al
-		 * als gemeld afgeboekt.
+		 * bron en het aanhaken van zijn luisteraar kan er een polltik of een bericht uit de stroom
+		 * geland zijn, en dat is hier al als gemeld afgeboekt.
 		 */
 		get huidigeUitkomst() {
 			return laatsteUitkomst;
@@ -1470,12 +1933,15 @@
 			// dat de volgende tik zwijgt en die berichten nooit meer aangeboden worden.
 			vergeetGemeldeLijst();
 			meldStoring("verwerking");
+			// Periodiek navragen biedt de lijst bij de volgende tik vanzelf opnieuw aan. Over de stroom
+			// komt er geen volgende tik, dus vragen we er zelf een, na de ondergrens van het navragen.
+			if (volgtStroom()) planLijstTik();
 		},
 
 		/**
-		 * Stopt het kijken naar nieuwe berichten. Voor de render-laag: slaat die het gedrag van de bron
-		 * over — na een mislukte eerste lading — dan leest niemand meer wat hier gemeld wordt, en is
-		 * doorpollen verkeer voor een scherm dat er niets mee doet.
+		 * Stopt het kijken naar nieuwe berichten, en sluit de stroom. Voor de render-laag: slaat die
+		 * het gedrag van de bron over — na een mislukte eerste lading — dan leest niemand meer wat hier
+		 * gemeld wordt, en is doorvolgen verkeer voor een scherm dat er niets mee doet.
 		 */
 		stopPollen: function () {
 			stopPoll();
diff --git a/assets/javascript/berichtenbox/keten-bron.js b/assets/javascript/berichtenbox/keten-bron.js
index 37c231db..9cee966d 100644
--- a/assets/javascript/berichtenbox/keten-bron.js
+++ b/assets/javascript/berichtenbox/keten-bron.js
@@ -13,10 +13,10 @@
  * De voortgang komt hier ook vandaan: het stelsel meldt per organisatie hoeveel er bevraagd, klaar
  * en gevonden zijn. Dat zijn echte getallen, waar de dataset-bron een nabootsing tegenover zet.
  *
- * En de berichten die binnenkomen terwijl de bezoeker kijkt: het transport haalt de lijst
- * periodiek opnieuw op, deze module ziet wat erbij gekomen is en meldt dat als losse binnenkomers —
- * dezelfde weg die de dataset-bron voor zijn nagebootste federatie gebruikt. Zo hoeft de
- * render-laag niet te weten of een bericht verzonnen is of echt.
+ * En de berichten die binnenkomen terwijl de bezoeker kijkt: het transport hoort ze van het stelsel,
+ * of vraagt de lijst periodiek na als dat niet lukt. Deze module ziet wat erbij gekomen is en meldt
+ * dat als losse binnenkomers — dezelfde weg die de dataset-bron voor zijn nagebootste federatie
+ * gebruikt. Zo hoeft de render-laag niet te weten of een bericht verzonnen is of echt.
  */
 
 /** Twee lijsten magazijnen zijn hetzelfde als ze dezelfde ids bevatten. */
@@ -218,7 +218,7 @@ export function ketenBron(keten, { meldStoring = () => {}, verbergMelding = () =
 			});
 
 			// Tussen `geldtVoor()` en dit punt rendert de render-laag, en in dat venster kan er al een
-			// polltik geland zijn. Die wijziging heeft geen luisteraar gehad en is bij het transport al
+			// polltik of een bericht uit de stroom geland zijn. Die wijziging heeft geen luisteraar gehad en is bij het transport al
 			// als gemeld afgeboekt, dus alleen hier valt hij nog in te halen.
 			if (keten.huidigeUitkomst) verwerkWijziging(keten.huidigeUitkomst);
 
@@ -231,7 +231,7 @@ export function ketenBron(keten, { meldStoring = () => {}, verbergMelding = () =
 				uitkomst = nieuwe;
 
 				// Een herhaalde ophaalronde levert een nieuw object met — meestal — dezelfde berichten;
-				// het pollen filtert dat zelf al weg. Alleen wat er bij komt is nieuws; de rest zou de
+				// het transport filtert dat zelf al weg. Alleen wat er bij komt is nieuws; de rest zou de
 				// lijst laten knipperen om niets.
 				const aanwas = aanwasVan(getoond, nieuwe);
 				if (aanwas && !aanwas.length) return;
diff --git a/tests/berichtenbox/keten-harnas.js b/tests/berichtenbox/keten-harnas.js
index 9ea6168f..270b18dc 100644
--- a/tests/berichtenbox/keten-harnas.js
+++ b/tests/berichtenbox/keten-harnas.js
@@ -124,8 +124,11 @@ export async function startKeten(perAdres, pad = "/moza/berichtenbox/", kvkNumme
 	vi.stubGlobal("fetch", async (pad, opties) => {
 		aanroepen.push({ pad, headers: (opties && opties.headers) || {} });
 		for (const [patroon, geef] of perAdres) {
-			if (pad.indexOf(patroon) !== -1) return typeof geef === "function" ? geef(pad) : geef;
+			if (pad.indexOf(patroon) !== -1) return typeof geef === "function" ? geef(pad, opties) : geef;
 		}
+		// Een keten zonder `_volgen`, zoals een stelsel van vóór dat endpoint: de client valt dan stil
+		// terug op het periodiek navragen. Een test over de stroom geeft zelf een antwoord voor dit adres.
+		if (pad.indexOf("_volgen") !== -1) return antwoord(404, {});
 		throw new Error("onverwacht adres in de test: " + pad);
 	});
 
diff --git a/tests/berichtenbox/keten-volgen.test.js b/tests/berichtenbox/keten-volgen.test.js
new file mode 100644
index 00000000..b5160000
--- /dev/null
+++ b/tests/berichtenbox/keten-volgen.test.js
@@ -0,0 +1,872 @@
+// @vitest-environment jsdom
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { antwoord, personasVoor, ruimKetenOp, sseAntwoord, startKeten } from "./keten-harnas.js";
+import { ketenBron } from "../../assets/javascript/berichtenbox/keten-bron.js";
+
+/**
+ * Het volgen van `berichtenbox-keten.js`: een verbinding waarop het stelsel zelf meldt dat er een
+ * bericht bij is (`GET /api/v1/berichten/_volgen`), in plaats van dat de berichtenbox blijft
+ * navragen.
+ *
+ * Wat hier op het spel staat: na elke (her)verbinding is de lijst compleet, zonder dubbele
+ * berichten; en komt de verbinding niet tot stand, dan werkt de berichtenbox gewoon verder op het
+ * periodiek navragen, zonder dat de bezoeker een melding krijgt die hem tegenhoudt.
+ */
+
+function apiBericht(id, extra = {}) {
+	return {
+		berichtId: id,
+		magazijnId: "00000001000000000000",
+		afzenderNaam: "Belastingdienst",
+		onderwerp: "Bericht " + id,
+		publicatietijdstip: "2026-09-21T09:00:00Z",
+		aantalBijlagen: 0,
+		status: "ongelezen",
+		...extra,
+	};
+}
+
+const lijstMet = (...ids) => antwoord(200, { berichten: ids.map((id) => apiBericht(id)) });
+const GEEN_SESSIE = () => antwoord(409, {});
+
+/** Antwoorden op de berichtenlijst, één per aanroep; het laatste blijft gelden. */
+function lijstReeks(...antwoorden) {
+	let beurt = 0;
+	return () => {
+		const volgende = antwoorden[Math.min(beurt++, antwoorden.length - 1)];
+		return typeof volgende === "function" ? volgende() : volgende;
+	};
+}
+
+/**
+ * Een SSE-stroom die de test zelf voedt.
+ *
+ * Breekt de client de verbinding af — de waakhond, `pagehide`, een persona-wissel — dan faalt het
+ * lezen, zoals een echte fetch dat doet. `afgebroken` laat zien of dat gebeurd is.
+ */
+function maakStroom(signaal) {
+	let regelaar;
+	const stroom = {
+		afgebroken: false,
+		stuur(gebeurtenis) {
+			regelaar.enqueue(new TextEncoder().encode("data:" + JSON.stringify(gebeurtenis) + "\n\n"));
+		},
+		stuurRauw(tekst) {
+			regelaar.enqueue(new TextEncoder().encode(tekst));
+		},
+		sluit() {
+			regelaar.close();
+		},
+		breek() {
+			regelaar.error(new TypeError("network error"));
+		},
+	};
+	const body = new ReadableStream({
+		start(r) {
+			regelaar = r;
+		},
+	});
+	if (signaal) {
+		signaal.addEventListener("abort", () => {
+			stroom.afgebroken = true;
+			try {
+				regelaar.error(new DOMException("afgebroken", "AbortError"));
+			} catch {
+				/* al dicht */
+			}
+		});
+	}
+	stroom.respons = { ok: true, status: 200, body: body, headers: { get: () => "text/event-stream" } };
+	return stroom;
+}
+
+/**
+ * Het adres `_volgen`: elke verbinding krijgt een eigen stroom, of het antwoord dat de test voor die
+ * poging opgeeft. `stromen` houdt ze in volgorde bij.
+ */
+function volgAdres(...antwoorden) {
+	const stromen = [];
+	let beurt = 0;
+	const geef = (pad, opties) => {
+		const vast = antwoorden[beurt++];
+		if (vast) return typeof vast === "function" ? vast(opties) : vast;
+		const stroom = maakStroom(opties && opties.signal);
+		stromen.push(stroom);
+		return stroom.respons;
+	};
+	return { stromen, adres: ["_volgen", geef] };
+}
+
+let bezoeker = 90000500;
+
+async function startVolgKeten(perAdres, pad) {
+	bezoeker += 1;
+	const kvkNummer = String(bezoeker);
+	const gestart = await startKeten([["/api/demo/personas", personasVoor(kvkNummer)], ...perAdres, ["_ophalen", () => sseAntwoord()]], pad, kvkNummer);
+	// De stroom opent na de ronde, in een volgende microtaak.
+	await vi.advanceTimersByTimeAsync(0);
+	return { ...gestart, ontvanger: "KVK:" + kvkNummer };
+}
+
+function tellingen(aanroepen, ontvanger) {
+	const vanDeze = aanroepen.filter((aanroep) => aanroep.headers["X-Ontvanger"] === ontvanger);
+	const telling = (stuk) => vanDeze.filter((aanroep) => aanroep.pad.indexOf(stuk) !== -1).length;
+	return { lijst: telling("/api/v1/berichten?"), volgen: telling("_volgen"), rondes: telling("_ophalen") };
+}
+
+/** Wat de keten als laatste lijst aan zijn kijkers meldde. */
+function volgGemeld() {
+	const gemeld = [];
+	window.BerichtenboxKeten.opWijziging((toestand) => {
+		if (toestand.uitkomst) gemeld.push(toestand.uitkomst);
+	});
+	return () => gemeld[gemeld.length - 1];
+}
+
+const ids = (uitkomst) => uitkomst.berichten.map((bericht) => bericht.id);
+
+function zetZichtbaarheid(staat) {
+	Object.defineProperty(document, "visibilityState", { configurable: true, get: () => staat });
+	document.dispatchEvent(new Event("visibilitychange"));
+}
+
+beforeEach(() => {
+	vi.useFakeTimers();
+	sessionStorage.clear();
+	localStorage.clear();
+	vi.spyOn(console, "error").mockImplementation(() => {});
+	vi.spyOn(console, "warn").mockImplementation(() => {});
+	vi.spyOn(console, "info").mockImplementation(() => {});
+	// Geen spreiding op de tussenpozen, zodat de tijden hieronder vastliggen.
+	vi.spyOn(Math, "random").mockReturnValue(0.5);
+});
+
+afterEach(() => {
+	window.dispatchEvent(new Event("pagehide"));
+	ruimKetenOp();
+	zetZichtbaarheid("visible");
+	vi.useRealTimers();
+	vi.restoreAllMocks();
+	vi.unstubAllGlobals();
+});
+
+describe("de stroom opent na de ronde", () => {
+	it("stuurt de ontvanger mee en vraagt om een SSE-stroom", async () => {
+		const volg = volgAdres();
+		const { aanroepen, ontvanger } = await startVolgKeten([volg.adres, ["/api/v1/berichten?", lijstMet()]]);
+
+		const verbinding = aanroepen.find((aanroep) => aanroep.pad.indexOf("_volgen") !== -1 && aanroep.headers["X-Ontvanger"] === ontvanger);
+		expect(verbinding).toBeTruthy();
+		expect(verbinding.headers.Accept).toBe("text/event-stream");
+	});
+
+	it("haalt bij `volgen-gestart` één keer de lijst, en daarna niet meer periodiek", async () => {
+		const volg = volgAdres();
+		const { aanroepen, ontvanger } = await startVolgKeten([volg.adres, ["/api/v1/berichten?", lijstMet()]]);
+		const voor = tellingen(aanroepen, ontvanger);
+
+		volg.stromen[0].stuur({ event: "volgen-gestart" });
+		await vi.advanceTimersByTimeAsync(0);
+		expect(tellingen(aanroepen, ontvanger).lijst).toBe(voor.lijst + 1);
+
+		for (let seconde = 20; seconde <= 120; seconde += 20) {
+			volg.stromen[0].stuur({ event: "hartslag" });
+			await vi.advanceTimersByTimeAsync(20000);
+		}
+		expect(tellingen(aanroepen, ontvanger).lijst).toBe(voor.lijst + 1);
+		expect(tellingen(aanroepen, ontvanger).volgen).toBe(1);
+	});
+
+	it("zet een `bericht-bijgekomen` bovenaan de lijst, met de naam van de afzender", async () => {
+		const volg = volgAdres();
+		await startVolgKeten([volg.adres, ["/api/v1/berichten?", lijstMet("b-1")]]);
+		const laatste = volgGemeld();
+
+		volg.stromen[0].stuur({ event: "volgen-gestart" });
+		await vi.advanceTimersByTimeAsync(0);
+		volg.stromen[0].stuur({ event: "bericht-bijgekomen", bericht: apiBericht("b-2", { magazijnId: "00000002000000000000", afzenderNaam: "RVO" }) });
+		await vi.advanceTimersByTimeAsync(0);
+
+		expect(ids(laatste())).toEqual(["b-2", "b-1"]);
+		expect(laatste().berichten[0].afzender).toBe("RVO");
+		expect(laatste().magazijnen.map((magazijn) => magazijn.naam)).toContain("RVO");
+	});
+
+	it("negeert een gebeurtenis die het niet kent", async () => {
+		const volg = volgAdres();
+		await startVolgKeten([volg.adres, ["/api/v1/berichten?", lijstMet("b-1")]]);
+
+		volg.stromen[0].stuur({ event: "volgen-gestart" });
+		volg.stromen[0].stuur({ event: "iets-nieuws", wat: 1 });
+		await vi.advanceTimersByTimeAsync(5000);
+
+		// Ook niet stil geëindigd en opnieuw verbonden: dan was er een tweede stroom.
+		expect(volg.stromen.length).toBe(1);
+		expect(volg.stromen[0].afgebroken).toBe(false);
+		expect(window.BerichtenboxKeten.melding).toBe(null);
+	});
+
+	it("slaat een melding over die het niet kan verwerken, en blijft verbonden", async () => {
+		// Een fout in één bericht is geen weggevallen verbinding. Nam die fout de stroom mee, dan
+		// verbond de berichtenbox opnieuw en hield het bijwerken na drie rondes op.
+		const volg = volgAdres();
+		// De lijst na het overgeslagen bericht bevat b-2 al: het stelsel zet elk bericht eerst in de
+		// sessie en meldt het dan pas.
+		await startVolgKeten([volg.adres, ["/api/v1/berichten?", lijstReeks(lijstMet("b-1"), lijstMet("b-1"), lijstMet("b-2", "b-1"))]]);
+		const laatste = volgGemeld();
+
+		volg.stromen[0].stuur({ event: "volgen-gestart" });
+		await vi.advanceTimersByTimeAsync(0);
+		volg.stromen[0].stuur(null);
+		volg.stromen[0].stuur({ event: "bericht-bijgekomen", bericht: apiBericht("b-kapot", { publicatietijdstip: 20260921 }) });
+		volg.stromen[0].stuur({ event: "bericht-bijgekomen", bericht: apiBericht("b-2") });
+		await vi.advanceTimersByTimeAsync(5000);
+
+		expect(volg.stromen.length).toBe(1);
+		expect(volg.stromen[0].afgebroken).toBe(false);
+		expect(ids(laatste())).toEqual(["b-2", "b-1"]);
+		expect(console.error).toHaveBeenCalled();
+	});
+
+	it("slaat een melding over die geen JSON is, en blijft verbonden", async () => {
+		const volg = volgAdres();
+		await startVolgKeten([volg.adres, ["/api/v1/berichten?", lijstMet("b-1")]]);
+		const laatste = volgGemeld();
+
+		volg.stromen[0].stuur({ event: "volgen-gestart" });
+		await vi.advanceTimersByTimeAsync(0);
+		volg.stromen[0].stuurRauw("data:{kapot\n\n");
+		volg.stromen[0].stuur({ event: "bericht-bijgekomen", bericht: apiBericht("b-2") });
+		await vi.advanceTimersByTimeAsync(5000);
+
+		expect(volg.stromen.length).toBe(1);
+		expect(ids(laatste())).toEqual(["b-2", "b-1"]);
+	});
+});
+
+describe("ontdubbelen", () => {
+	it("toont een bericht één keer als het via de lijst én via de stroom komt", async () => {
+		const volg = volgAdres();
+		await startVolgKeten([volg.adres, ["/api/v1/berichten?", lijstReeks(lijstMet(), lijstMet("b-1"))]]);
+		const laatste = volgGemeld();
+
+		volg.stromen[0].stuur({ event: "volgen-gestart" });
+		await vi.advanceTimersByTimeAsync(0);
+		volg.stromen[0].stuur({ event: "bericht-bijgekomen", bericht: apiBericht("b-1") });
+		await vi.advanceTimersByTimeAsync(0);
+
+		expect(ids(laatste())).toEqual(["b-1"]);
+	});
+
+	it("houdt een bericht vast dat binnenkwam terwijl de lijst onderweg was", async () => {
+		// De lijst is van vóór het bericht. Zonder dit legt hij zich over het bericht heen, ziet de bron
+		// het "verdwijnen" en haalt hij het weer van het scherm.
+		let geefLijst;
+		const volg = volgAdres();
+		await startVolgKeten([volg.adres, ["/api/v1/berichten?", lijstReeks(lijstMet("b-1"), () => new Promise((klaar) => (geefLijst = () => klaar(lijstMet("b-1")))))]]);
+		const laatste = volgGemeld();
+
+		volg.stromen[0].stuur({ event: "volgen-gestart" });
+		await vi.advanceTimersByTimeAsync(0);
+		volg.stromen[0].stuur({ event: "bericht-bijgekomen", bericht: apiBericht("b-2") });
+		await vi.advanceTimersByTimeAsync(0);
+		geefLijst();
+		await vi.advanceTimersByTimeAsync(0);
+
+		expect(ids(laatste())).toEqual(["b-2", "b-1"]);
+	});
+});
+
+describe("de waakhond", () => {
+	it("verbindt opnieuw als het 45 seconden stil blijft", async () => {
+		const volg = volgAdres();
+		const { aanroepen, ontvanger } = await startVolgKeten([volg.adres, ["/api/v1/berichten?", lijstMet()]]);
+		volg.stromen[0].stuur({ event: "volgen-gestart" });
+
+		await vi.advanceTimersByTimeAsync(44000);
+		expect(volg.stromen[0].afgebroken).toBe(false);
+		await vi.advanceTimersByTimeAsync(1000);
+		expect(volg.stromen[0].afgebroken).toBe(true);
+
+		// Eerste tussenpoos: een seconde; de spreiding staat in deze tests op nul, 1500 ms is marge.
+		await vi.advanceTimersByTimeAsync(1500);
+		expect(tellingen(aanroepen, ontvanger).volgen).toBe(2);
+	});
+
+	it("laat een verbinding met een hartslag staan", async () => {
+		const volg = volgAdres();
+		const { aanroepen, ontvanger } = await startVolgKeten([volg.adres, ["/api/v1/berichten?", lijstMet()]]);
+		volg.stromen[0].stuur({ event: "volgen-gestart" });
+
+		for (let keer = 0; keer < 6; keer++) {
+			await vi.advanceTimersByTimeAsync(20000);
+			volg.stromen[0].stuur({ event: "hartslag" });
+		}
+
+		expect(volg.stromen[0].afgebroken).toBe(false);
+		expect(tellingen(aanroepen, ontvanger).volgen).toBe(1);
+	});
+});
+
+describe("opnieuw verbinden", () => {
+	it("maakt de lijst na een afgebroken stroom weer compleet", async () => {
+		// Tijdens de onderbreking kwam b-2 binnen. De stroom meldde het niet, maar de lijst na de
+		// nieuwe `volgen-gestart` heeft het wél.
+		const volg = volgAdres();
+		await startVolgKeten([volg.adres, ["/api/v1/berichten?", lijstReeks(lijstMet("b-1"), lijstMet("b-1"), lijstMet("b-2", "b-1"))]]);
+		const laatste = volgGemeld();
+		volg.stromen[0].stuur({ event: "volgen-gestart" });
+		await vi.advanceTimersByTimeAsync(0);
+
+		volg.stromen[0].breek();
+		await vi.advanceTimersByTimeAsync(1500);
+		expect(volg.stromen.length).toBe(2);
+
+		volg.stromen[1].stuur({ event: "volgen-gestart" });
+		await vi.advanceTimersByTimeAsync(0);
+
+		expect(ids(laatste())).toEqual(["b-2", "b-1"]);
+	});
+
+	it("verbindt opnieuw als de stroom na een uur netjes eindigt", async () => {
+		const volg = volgAdres();
+		const { aanroepen, ontvanger } = await startVolgKeten([volg.adres, ["/api/v1/berichten?", lijstMet()]]);
+		volg.stromen[0].stuur({ event: "volgen-gestart" });
+		volg.stromen[0].stuur({ event: "hartslag" });
+		await vi.advanceTimersByTimeAsync(0);
+
+		volg.stromen[0].sluit();
+		await vi.advanceTimersByTimeAsync(1500);
+
+		expect(tellingen(aanroepen, ontvanger).volgen).toBe(2);
+	});
+
+	it("wacht steeds langer, en begint na de eerste hartslag weer van voren", async () => {
+		// Een gezonde stroom breekt, dan twee pogingen die mislukken: 1, 2 en 5 seconden. Na een
+		// nieuwe hartslag wacht de volgende breuk weer één seconde, geen tien.
+		const volg = volgAdres(null, antwoord(500, {}), antwoord(500, {}));
+		const { aanroepen, ontvanger } = await startVolgKeten([volg.adres, ["/api/v1/berichten?", lijstMet()]]);
+		volg.stromen[0].stuur({ event: "volgen-gestart" });
+		volg.stromen[0].stuur({ event: "hartslag" });
+		await vi.advanceTimersByTimeAsync(0);
+		volg.stromen[0].breek();
+
+		await vi.advanceTimersByTimeAsync(1100);
+		expect(tellingen(aanroepen, ontvanger).volgen).toBe(2);
+		await vi.advanceTimersByTimeAsync(1800);
+		expect(tellingen(aanroepen, ontvanger).volgen).toBe(2);
+		await vi.advanceTimersByTimeAsync(200);
+		expect(tellingen(aanroepen, ontvanger).volgen).toBe(3);
+		await vi.advanceTimersByTimeAsync(4800);
+		expect(tellingen(aanroepen, ontvanger).volgen).toBe(3);
+		await vi.advanceTimersByTimeAsync(200);
+		expect(tellingen(aanroepen, ontvanger).volgen).toBe(4);
+
+		volg.stromen[1].stuur({ event: "volgen-gestart" });
+		volg.stromen[1].stuur({ event: "hartslag" });
+		await vi.advanceTimersByTimeAsync(0);
+		volg.stromen[1].breek();
+		await vi.advanceTimersByTimeAsync(1100);
+		expect(tellingen(aanroepen, ontvanger).volgen).toBe(5);
+	});
+
+	it("geeft een stroom die telkens na de start wegvalt op, in plaats van eindeloos opnieuw te verbinden", async () => {
+		// Een tussenlaag die de stroom na `volgen-gestart` sluit, vóór de eerste hartslag. Telde
+		// `volgen-gestart` als gezond, dan verbond de berichtenbox elke seconde opnieuw en haalde
+		// hij elke keer de lijst op, zonder ooit op te geven.
+		const volg = volgAdres();
+		const { aanroepen, ontvanger } = await startVolgKeten([volg.adres, ["/api/v1/berichten?", lijstMet()]]);
+
+		for (let keer = 0; keer < 3; keer++) {
+			volg.stromen[keer].stuur({ event: "volgen-gestart" });
+			await vi.advanceTimersByTimeAsync(0);
+			volg.stromen[keer].sluit();
+			await vi.advanceTimersByTimeAsync(6000);
+		}
+		const na = tellingen(aanroepen, ontvanger);
+		await vi.advanceTimersByTimeAsync(60000);
+
+		expect(na.volgen).toBe(3);
+		expect(tellingen(aanroepen, ontvanger).volgen).toBe(3);
+		expect(window.BerichtenboxKeten.melding).toBe(null);
+	});
+});
+
+describe("een verlopen sessie", () => {
+	it("draait na `sessie-verlopen` een nieuwe ronde en verbindt daarna opnieuw", async () => {
+		const volg = volgAdres();
+		const { aanroepen, ontvanger } = await startVolgKeten([volg.adres, ["/api/v1/berichten?", lijstReeks(lijstMet(), lijstMet(), GEEN_SESSIE(), lijstMet())]]);
+		volg.stromen[0].stuur({ event: "volgen-gestart" });
+		await vi.advanceTimersByTimeAsync(0);
+		const voor = tellingen(aanroepen, ontvanger);
+
+		volg.stromen[0].stuur({ event: "sessie-verlopen" });
+		await vi.advanceTimersByTimeAsync(0);
+
+		expect(tellingen(aanroepen, ontvanger).rondes).toBe(voor.rondes + 1);
+		expect(tellingen(aanroepen, ontvanger).volgen).toBe(voor.volgen + 1);
+	});
+
+	it("draait bij een 409 op het openen een nieuwe ronde", async () => {
+		const volg = volgAdres(GEEN_SESSIE());
+		const { aanroepen, ontvanger } = await startVolgKeten([volg.adres, ["/api/v1/berichten?", lijstReeks(lijstMet(), GEEN_SESSIE(), lijstMet())]]);
+
+		expect(tellingen(aanroepen, ontvanger).rondes).toBe(1);
+		expect(tellingen(aanroepen, ontvanger).volgen).toBe(2);
+	});
+
+	it("valt stil terug als `_volgen` ook na een nieuwe ronde met 409 antwoordt", async () => {
+		// Dan ligt het niet aan de sessie: de lijst werkt. Verder herstellen bevraagt telkens alle
+		// organisaties en houdt na twee keer op met een mededeling, terwijl navragen gewoon werkt.
+		const volg = volgAdres(GEEN_SESSIE(), GEEN_SESSIE(), GEEN_SESSIE());
+		const { aanroepen, ontvanger } = await startVolgKeten([volg.adres, ["/api/v1/berichten?", lijstReeks(lijstMet(), GEEN_SESSIE(), lijstMet())]]);
+		const voor = tellingen(aanroepen, ontvanger);
+
+		await vi.advanceTimersByTimeAsync(15000);
+
+		expect(voor.rondes).toBe(1);
+		expect(voor.volgen).toBe(2);
+		expect(tellingen(aanroepen, ontvanger).lijst).toBe(voor.lijst + 1);
+		expect(tellingen(aanroepen, ontvanger).rondes).toBe(1);
+		expect(window.BerichtenboxKeten.melding).toBe(null);
+	});
+
+	it("sluit de stroom en draait een ronde als de lijst meldt dat de sessie weg is", async () => {
+		const volg = volgAdres();
+		const { aanroepen, ontvanger } = await startVolgKeten([volg.adres, ["/api/v1/berichten?", lijstReeks(lijstMet(), GEEN_SESSIE(), GEEN_SESSIE(), lijstMet())]]);
+		const voor = tellingen(aanroepen, ontvanger);
+
+		volg.stromen[0].stuur({ event: "volgen-gestart" });
+		await vi.advanceTimersByTimeAsync(0);
+
+		expect(volg.stromen[0].afgebroken).toBe(true);
+		expect(tellingen(aanroepen, ontvanger).rondes).toBe(voor.rondes + 1);
+		expect(tellingen(aanroepen, ontvanger).volgen).toBe(voor.volgen + 1);
+	});
+});
+
+describe("terugvallen op periodiek navragen", () => {
+	it.each([404, 405, 406])("valt stil terug bij een keten zonder `_volgen` (%i)", async (status) => {
+		// 406 is wat de publieke omgeving zonder `_volgen` geeft: het pad valt daar onder
+		// `GET /berichten/{berichtId}`, en dat levert geen `text/event-stream`.
+		const volg = volgAdres(antwoord(status, {}));
+		const { aanroepen, ontvanger } = await startVolgKeten([volg.adres, ["/api/v1/berichten?", lijstMet()]]);
+		const voor = tellingen(aanroepen, ontvanger);
+
+		await vi.advanceTimersByTimeAsync(15000);
+
+		expect(tellingen(aanroepen, ontvanger).lijst).toBe(voor.lijst + 1);
+		expect(tellingen(aanroepen, ontvanger).volgen).toBe(1);
+		expect(window.BerichtenboxKeten.melding).toBe(null);
+	});
+
+	it("valt stil terug na drie verbindingen op rij die niet tot stand kwamen", async () => {
+		const volg = volgAdres(antwoord(500, {}), antwoord(502, {}), antwoord(500, {}));
+		const { aanroepen, ontvanger } = await startVolgKeten([volg.adres, ["/api/v1/berichten?", lijstMet()]]);
+
+		await vi.advanceTimersByTimeAsync(4000);
+		expect(tellingen(aanroepen, ontvanger).volgen).toBe(3);
+		const voor = tellingen(aanroepen, ontvanger);
+
+		await vi.advanceTimersByTimeAsync(60000);
+		expect(tellingen(aanroepen, ontvanger).volgen).toBe(3);
+		expect(tellingen(aanroepen, ontvanger).lijst).toBeGreaterThan(voor.lijst);
+		expect(window.BerichtenboxKeten.melding).toBe(null);
+	});
+
+	it.each([503, 429])("wacht na een %i de opgegeven `Retry-After` af", async (code) => {
+		const druk = { ok: false, status: code, headers: { get: (naam) => (naam === "Retry-After" ? "30" : null) } };
+		const volg = volgAdres(druk);
+		const { aanroepen, ontvanger } = await startVolgKeten([volg.adres, ["/api/v1/berichten?", lijstMet()]]);
+
+		await vi.advanceTimersByTimeAsync(29000);
+		expect(tellingen(aanroepen, ontvanger).volgen).toBe(1);
+		await vi.advanceTimersByTimeAsync(1500);
+		expect(tellingen(aanroepen, ontvanger).volgen).toBe(2);
+	});
+});
+
+describe("een lijst die hapert terwijl de stroom openstaat", () => {
+	it("laat de stroom staan en probeert de lijst na vijftien seconden opnieuw", async () => {
+		const volg = volgAdres();
+		const { aanroepen, ontvanger } = await startVolgKeten([volg.adres, ["/api/v1/berichten?", lijstReeks(lijstMet(), antwoord(502, {}), lijstMet("b-1"))]]);
+		const laatste = volgGemeld();
+		volg.stromen[0].stuur({ event: "volgen-gestart" });
+		await vi.advanceTimersByTimeAsync(0);
+		const na = tellingen(aanroepen, ontvanger);
+
+		await vi.advanceTimersByTimeAsync(14000);
+		expect(tellingen(aanroepen, ontvanger).lijst).toBe(na.lijst);
+		await vi.advanceTimersByTimeAsync(1500);
+
+		expect(tellingen(aanroepen, ontvanger).lijst).toBe(na.lijst + 1);
+		expect(volg.stromen[0].afgebroken).toBe(false);
+		expect(tellingen(aanroepen, ontvanger).volgen).toBe(1);
+		expect(ids(laatste())).toEqual(["b-1"]);
+	});
+
+	it("houdt een storing van een halve minuut vol, net als het navragen", async () => {
+		// Drie mislukkingen op rij zetten het bijwerken stil. Kwamen die elke seconde, dan was dat
+		// na drie seconden al zo; nu zitten er vijftien tussen.
+		const volg = volgAdres();
+		await startVolgKeten([volg.adres, ["/api/v1/berichten?", lijstReeks(lijstMet(), antwoord(502, {}), antwoord(502, {}), antwoord(502, {}))]]);
+		volg.stromen[0].stuur({ event: "volgen-gestart" });
+		await vi.advanceTimersByTimeAsync(0);
+
+		await vi.advanceTimersByTimeAsync(29000);
+		expect(window.BerichtenboxKeten.melding).toBe(null);
+
+		await vi.advanceTimersByTimeAsync(2000);
+		expect(window.BerichtenboxKeten.melding.soort).toBe("mededeling");
+		expect(volg.stromen[0].afgebroken).toBe(true);
+	});
+
+	it("haalt de lijst nog een keer op als `volgen-gestart` komt terwijl er een tik loopt", async () => {
+		// De lopende tik begon vóór het volgen; wat er tussendoor binnenkwam, staat in geen van beide.
+		let geefTraag;
+		const volg = volgAdres();
+		const { aanroepen, ontvanger } = await startVolgKeten([volg.adres, ["/api/v1/berichten?", lijstReeks(lijstMet(), () => new Promise((klaar) => (geefTraag = () => klaar(lijstMet("b-1")))), lijstMet("b-2", "b-1"))]]);
+		const laatste = volgGemeld();
+		volg.stromen[0].stuur({ event: "volgen-gestart" });
+		await vi.advanceTimersByTimeAsync(0);
+		const tijdensTik = tellingen(aanroepen, ontvanger);
+
+		// De verbinding valt weg en komt terug terwijl de eerste tik nog onderweg is.
+		volg.stromen[0].breek();
+		await vi.advanceTimersByTimeAsync(1500);
+		volg.stromen[1].stuur({ event: "volgen-gestart" });
+		await vi.advanceTimersByTimeAsync(0);
+		expect(tellingen(aanroepen, ontvanger).lijst).toBe(tijdensTik.lijst);
+
+		geefTraag();
+		await vi.advanceTimersByTimeAsync(0);
+
+		expect(tellingen(aanroepen, ontvanger).lijst).toBe(tijdensTik.lijst + 1);
+		expect(ids(laatste())).toEqual(["b-2", "b-1"]);
+	});
+
+	it("biedt de lijst opnieuw aan als de bron hem niet kon tonen", async () => {
+		// Over de stroom komt er geen volgende tik vanzelf; zonder deze tik blijft de melding staan
+		// en verschijnen die berichten niet meer.
+		const volg = volgAdres();
+		const { aanroepen, ontvanger } = await startVolgKeten([volg.adres, ["/api/v1/berichten?", lijstMet("b-1")]]);
+		volg.stromen[0].stuur({ event: "volgen-gestart" });
+		await vi.advanceTimersByTimeAsync(0);
+		const voor = tellingen(aanroepen, ontvanger);
+
+		const gemeld = [];
+		window.BerichtenboxKeten.opWijziging((toestand) => {
+			if (toestand.uitkomst) gemeld.push(toestand.uitkomst);
+		});
+		window.BerichtenboxKeten.meldVerwerkingsfout();
+		const naMelding = gemeld.length;
+		await vi.advanceTimersByTimeAsync(5000);
+
+		expect(tellingen(aanroepen, ontvanger).lijst).toBe(voor.lijst + 1);
+		// Dezelfde lijst, maar opnieuw aangeboden: zonder `vergeetGemeldeLijst` zou de tik zwijgen.
+		expect(gemeld.length).toBeGreaterThan(naMelding);
+		expect(ids(gemeld[gemeld.length - 1])).toEqual(["b-1"]);
+	});
+});
+
+describe("een verbinding die niet op gang komt", () => {
+	it("breekt ook een openen dat blijft hangen af", async () => {
+		// Na een slaapstand blijft juist de fetch hangen, nog vóór er een antwoord is.
+		// Zoals een echte fetch: hij antwoordt nooit, maar geeft op zodra hij afgebroken wordt.
+		const hangt = (opties) => new Promise((_, weiger) => opties.signal.addEventListener("abort", () => weiger(new DOMException("afgebroken", "AbortError"))));
+		const volg = volgAdres(hangt);
+		const { aanroepen, ontvanger } = await startVolgKeten([volg.adres, ["/api/v1/berichten?", lijstMet()]]);
+
+		await vi.advanceTimersByTimeAsync(45000 + 1500);
+
+		expect(tellingen(aanroepen, ontvanger).volgen).toBe(2);
+	});
+
+	it("telt een 200 zonder `text/event-stream` als mislukte verbinding", async () => {
+		// Een tussenlaag die een foutpagina teruggeeft. Daar valt niets uit te lezen.
+		const html = { ok: true, status: 200, body: new ReadableStream(), headers: { get: () => "text/html" } };
+		const volg = volgAdres(html, html, html);
+		const { aanroepen, ontvanger } = await startVolgKeten([volg.adres, ["/api/v1/berichten?", lijstMet()]]);
+
+		await vi.advanceTimersByTimeAsync(60000);
+
+		expect(tellingen(aanroepen, ontvanger).volgen).toBe(3);
+		expect(window.BerichtenboxKeten.melding).toBe(null);
+	});
+});
+
+describe("tweede reviewronde", () => {
+	it("houdt de herstelrem vast als de stroom telkens na de start `sessie-verlopen` meldt", async () => {
+		// Een sessie die korter leeft dan één cyclus. De lijst-tik na `volgen-gestart` slaagt altijd,
+		// want de ronde heeft de sessie net gevuld; zette die tik de rem terug, dan draaide de
+		// berichtenbox om de paar seconden een ronde langs alle organisaties, zonder einde.
+		let sessie = true;
+		const volg = volgAdres();
+		const { aanroepen, ontvanger } = await startVolgKeten([
+			volg.adres,
+			[
+				"_ophalen",
+				() => {
+					sessie = true;
+					return sseAntwoord();
+				},
+			],
+			["/api/v1/berichten?", () => (sessie ? lijstMet() : GEEN_SESSIE())],
+		]);
+
+		for (let stroom = 0; stroom < 6 && volg.stromen[stroom]; stroom++) {
+			volg.stromen[stroom].stuur({ event: "volgen-gestart" });
+			await vi.advanceTimersByTimeAsync(100);
+			sessie = false;
+			volg.stromen[stroom].stuur({ event: "sessie-verlopen" });
+			await vi.advanceTimersByTimeAsync(100);
+		}
+
+		expect(tellingen(aanroepen, ontvanger).rondes).toBeLessThanOrEqual(2);
+		expect(window.BerichtenboxKeten.melding.soort).toBe("mededeling");
+	});
+
+	it("meldt een bericht zonder id, ook als er tijdens de tik een bericht uit de stroom bijkwam", async () => {
+		let geefLijst;
+		const volg = volgAdres();
+		await startVolgKeten([volg.adres, ["/api/v1/berichten?", lijstReeks(lijstMet("b-1"), () => new Promise((klaar) => (geefLijst = () => klaar(antwoord(200, { berichten: [apiBericht("b-1"), { onderwerp: "Zonder id" }] })))))]]);
+		volg.stromen[0].stuur({ event: "volgen-gestart" });
+		await vi.advanceTimersByTimeAsync(0);
+		volg.stromen[0].stuur({ event: "bericht-bijgekomen", bericht: apiBericht("b-2") });
+		await vi.advanceTimersByTimeAsync(0);
+		geefLijst();
+		await vi.advanceTimersByTimeAsync(0);
+
+		expect(window.BerichtenboxKeten.melding && window.BerichtenboxKeten.melding.tekst).toContain("ontbreken gegevens");
+	});
+
+	it.each([
+		["zonder id", { onderwerp: "Zonder id" }],
+		["met een onleesbaar veld", apiBericht("b-kapot", { publicatietijdstip: 20260921 })],
+	])("haalt de lijst op als een bericht uit de stroom %s overgeslagen werd", async (_, bericht) => {
+		// Anders blijft dat bericht weg tot de volgende `volgen-gestart`, en die kan een uur op zich
+		// laten wachten.
+		const volg = volgAdres();
+		const { aanroepen, ontvanger } = await startVolgKeten([volg.adres, ["/api/v1/berichten?", lijstMet()]]);
+		volg.stromen[0].stuur({ event: "volgen-gestart" });
+		await vi.advanceTimersByTimeAsync(0);
+		const voor = tellingen(aanroepen, ontvanger);
+
+		volg.stromen[0].stuur({ event: "bericht-bijgekomen", bericht: bericht });
+		await vi.advanceTimersByTimeAsync(5500);
+
+		expect(tellingen(aanroepen, ontvanger).lijst).toBe(voor.lijst + 1);
+	});
+
+	it("laat de waakhond niet voeden door meldingen die niets zeggen", async () => {
+		// Een stroom die alleen onleesbare frames levert, zou anders een uur openblijven en nooit als
+		// mislukt tellen.
+		const volg = volgAdres();
+		await startVolgKeten([volg.adres, ["/api/v1/berichten?", lijstMet()]]);
+		volg.stromen[0].stuur({ event: "volgen-gestart" });
+		volg.stromen[0].stuur({ event: "hartslag" });
+
+		for (let keer = 0; keer < 5; keer++) {
+			await vi.advanceTimersByTimeAsync(10000);
+			if (!volg.stromen[0].afgebroken) volg.stromen[0].stuurRauw("data:{kapot\n\n");
+		}
+
+		expect(volg.stromen[0].afgebroken).toBe(true);
+	});
+
+	it("wacht een `Retry-After` van een uur niet helemaal af", async () => {
+		const druk = { ok: false, status: 503, headers: { get: (naam) => (naam === "Retry-After" ? "3600" : null) } };
+		const volg = volgAdres(druk);
+		const { aanroepen, ontvanger } = await startVolgKeten([volg.adres, ["/api/v1/berichten?", lijstMet()]]);
+
+		await vi.advanceTimersByTimeAsync(61000);
+
+		expect(tellingen(aanroepen, ontvanger).volgen).toBe(2);
+	});
+
+	it("probeert de stroom na een netwerkstoring later opnieuw", async () => {
+		// Drie mislukte pogingen binnen een paar seconden zijn een wifi-wissel, geen keten zonder
+		// `_volgen`. Tijdelijk navragen, daarna de stroom weer proberen.
+		const volg = volgAdres(antwoord(500, {}), antwoord(500, {}), antwoord(500, {}));
+		const { aanroepen, ontvanger } = await startVolgKeten([volg.adres, ["/api/v1/berichten?", lijstMet()]]);
+		await vi.advanceTimersByTimeAsync(4000);
+		expect(tellingen(aanroepen, ontvanger).volgen).toBe(3);
+
+		await vi.advanceTimersByTimeAsync(5 * 60 * 1000);
+
+		expect(tellingen(aanroepen, ontvanger).volgen).toBe(4);
+		expect(volg.stromen.length).toBe(1);
+	});
+
+	it("probeert de stroom niet opnieuw bij een keten zonder `_volgen`", async () => {
+		const volg = volgAdres(antwoord(404, {}));
+		const { aanroepen, ontvanger } = await startVolgKeten([volg.adres, ["/api/v1/berichten?", lijstMet()]]);
+
+		await vi.advanceTimersByTimeAsync(10 * 60 * 1000);
+
+		expect(tellingen(aanroepen, ontvanger).volgen).toBe(1);
+	});
+});
+
+describe("wat de eerste hartslag terugzet", () => {
+	it("telt mislukkingen van vóór een gezonde verbinding niet meer mee", async () => {
+		// Twee mislukkingen, een gezonde verbinding, en dan weer één: dat is geen reeks van drie.
+		const volg = volgAdres(antwoord(500, {}), antwoord(500, {}), null, antwoord(500, {}));
+		const { aanroepen, ontvanger } = await startVolgKeten([volg.adres, ["/api/v1/berichten?", lijstMet()]]);
+		await vi.advanceTimersByTimeAsync(3100);
+		volg.stromen[0].stuur({ event: "volgen-gestart" });
+		volg.stromen[0].stuur({ event: "hartslag" });
+		await vi.advanceTimersByTimeAsync(0);
+		volg.stromen[0].breek();
+
+		await vi.advanceTimersByTimeAsync(4000);
+
+		expect(tellingen(aanroepen, ontvanger).volgen).toBe(5);
+		expect(volg.stromen.length).toBe(2);
+	});
+
+	it("vergeet een 409 van vóór een gezonde verbinding", async () => {
+		// Twee 409's met uren gezonde verbinding ertussen zijn twee verlopen sessies, geen keten die
+		// het niet kan.
+		const volg = volgAdres(GEEN_SESSIE(), null, GEEN_SESSIE());
+		const { aanroepen, ontvanger } = await startVolgKeten([volg.adres, ["/api/v1/berichten?", lijstReeks(lijstMet(), GEEN_SESSIE(), lijstMet(), lijstMet(), GEEN_SESSIE(), lijstMet())]]);
+		expect(tellingen(aanroepen, ontvanger).rondes).toBe(1);
+		volg.stromen[0].stuur({ event: "volgen-gestart" });
+		volg.stromen[0].stuur({ event: "hartslag" });
+		await vi.advanceTimersByTimeAsync(0);
+
+		volg.stromen[0].breek();
+		await vi.advanceTimersByTimeAsync(1500);
+
+		expect(tellingen(aanroepen, ontvanger).rondes).toBe(2);
+		expect(volg.stromen.length).toBe(2);
+	});
+});
+
+describe("een antwoord dat we niet lezen", () => {
+	it("sluit de body van een 200 zonder stroom", async () => {
+		// Anders blijft zo'n verbinding bij het stelsel open, en per ontvanger zijn er vijf.
+		let gesloten = false;
+		const html = { ok: true, status: 200, body: new ReadableStream({ cancel: () => (gesloten = true) }), headers: { get: () => "text/html" } };
+		const volg = volgAdres(html);
+		await startVolgKeten([volg.adres, ["/api/v1/berichten?", lijstMet()]]);
+
+		expect(gesloten).toBe(true);
+	});
+});
+
+describe("van stroom tot bron", () => {
+	it("maakt van een bericht uit de stroom één binnenkomer, ook als de lijst het ook heeft", async () => {
+		const volg = volgAdres();
+		await startVolgKeten([volg.adres, ["/api/v1/berichten?", lijstReeks(lijstMet("b-1"), lijstMet("b-2", "b-1"))]]);
+		const bron = ketenBron(window.BerichtenboxKeten);
+		expect(await bron.geldtVoor()).toBe(true);
+		await bron.laad();
+		const gemeld = [];
+		bron.start((wijziging) => {
+			gemeld.push(wijziging);
+			return [];
+		});
+
+		// Grensvlak: b-2 staat in de lijst van de tik én komt over de stroom.
+		volg.stromen[0].stuur({ event: "volgen-gestart" });
+		await vi.advanceTimersByTimeAsync(0);
+		volg.stromen[0].stuur({ event: "bericht-bijgekomen", bericht: apiBericht("b-2") });
+		await vi.advanceTimersByTimeAsync(0);
+
+		const binnenkomers = gemeld.filter((wijziging) => wijziging.nieuwBericht).map((wijziging) => wijziging.nieuwBericht.id);
+		expect(binnenkomers).toEqual(["b-2"]);
+		expect(gemeld.filter((wijziging) => wijziging.berichten)).toEqual([]);
+	});
+});
+
+describe("de levenscyclus van de pagina", () => {
+	it("sluit de stroom bij `pagehide` en verbindt opnieuw bij `pageshow`", async () => {
+		const volg = volgAdres();
+		const { aanroepen, ontvanger } = await startVolgKeten([volg.adres, ["/api/v1/berichten?", lijstMet()]]);
+		volg.stromen[0].stuur({ event: "volgen-gestart" });
+		await vi.advanceTimersByTimeAsync(0);
+
+		window.dispatchEvent(new Event("pagehide"));
+		// Meteen, en niet pas na een minuut: dan had de waakhond hem ook al afgebroken.
+		await vi.advanceTimersByTimeAsync(0);
+		expect(volg.stromen[0].afgebroken).toBe(true);
+		await vi.advanceTimersByTimeAsync(60000);
+		expect(tellingen(aanroepen, ontvanger).volgen).toBe(1);
+
+		const voor = tellingen(aanroepen, ontvanger);
+		window.dispatchEvent(new Event("pageshow"));
+		await vi.advanceTimersByTimeAsync(0);
+		volg.stromen[1].stuur({ event: "volgen-gestart" });
+		await vi.advanceTimersByTimeAsync(0);
+
+		expect(tellingen(aanroepen, ontvanger).volgen).toBe(2);
+		expect(tellingen(aanroepen, ontvanger).lijst).toBe(voor.lijst + 1);
+	});
+
+	it("blijft verbonden in een verborgen tabblad", async () => {
+		const volg = volgAdres();
+		const { aanroepen, ontvanger } = await startVolgKeten([volg.adres, ["/api/v1/berichten?", lijstMet()]]);
+		volg.stromen[0].stuur({ event: "volgen-gestart" });
+		await vi.advanceTimersByTimeAsync(0);
+		const voor = tellingen(aanroepen, ontvanger);
+
+		zetZichtbaarheid("hidden");
+		for (let keer = 0; keer < 4; keer++) {
+			await vi.advanceTimersByTimeAsync(20000);
+			volg.stromen[0].stuur({ event: "hartslag" });
+		}
+		// Terug naar zichtbaar: over de stroom komt het vanzelf, dus geen extra tik.
+		zetZichtbaarheid("visible");
+		await vi.advanceTimersByTimeAsync(0);
+
+		expect(volg.stromen[0].afgebroken).toBe(false);
+		expect(tellingen(aanroepen, ontvanger)).toEqual(voor);
+	});
+
+	it("verbindt niet opnieuw als er intussen een andere persona gekozen is", async () => {
+		const volg = volgAdres();
+		const { aanroepen, ontvanger } = await startVolgKeten([volg.adres, ["/api/v1/berichten?", lijstMet()]]);
+		window.dispatchEvent(new Event("pagehide"));
+
+		window.Personas.actief = () => ({ id: "proeftuin-twee", stelsel: true, bedrijf: { kvkNummer: "90000012" } });
+		window.dispatchEvent(new Event("pageshow"));
+		await vi.advanceTimersByTimeAsync(60000);
+
+		expect(tellingen(aanroepen, ontvanger).volgen).toBe(1);
+		expect(tellingen(aanroepen, "KVK:90000012").volgen).toBe(0);
+	});
+
+	it("sluit de stroom bij `stopPollen()`", async () => {
+		const volg = volgAdres();
+		const { aanroepen, ontvanger } = await startVolgKeten([volg.adres, ["/api/v1/berichten?", lijstMet()]]);
+
+		window.BerichtenboxKeten.stopPollen();
+		await vi.advanceTimersByTimeAsync(0);
+		expect(volg.stromen[0].afgebroken).toBe(true);
+
+		await vi.advanceTimersByTimeAsync(60000);
+		expect(tellingen(aanroepen, ontvanger).volgen).toBe(1);
+	});
+});
+
+describe("de stroom is uit te zetten", () => {
+	it("vraagt met `?volgen=0` periodiek na, zonder stroom", async () => {
+		const volg = volgAdres();
+		const { aanroepen, ontvanger } = await startVolgKeten([volg.adres, ["/api/v1/berichten?", lijstMet()]], "/moza/berichtenbox/?volgen=0");
+		const voor = tellingen(aanroepen, ontvanger);
+
+		await vi.advanceTimersByTimeAsync(15000);
+
+		expect(tellingen(aanroepen, ontvanger).volgen).toBe(0);
+		expect(tellingen(aanroepen, ontvanger).lijst).toBe(voor.lijst + 1);
+	});
+
+	it("volgt ook `setting:berichtenbox-volgen`", async () => {
+		localStorage.setItem("setting:berichtenbox-volgen", "0");
+		const volg = volgAdres();
+		const { aanroepen, ontvanger } = await startVolgKeten([volg.adres, ["/api/v1/berichten?", lijstMet()]]);
+
+		expect(tellingen(aanroepen, ontvanger).volgen).toBe(0);
+	});
+});