diff --git a/CLAUDE.md b/CLAUDE.md
index 4aef8f1a..d700b116 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -70,11 +70,12 @@ MijnOverheid Zakelijk (MOZa) is een HTML/CSS/JS prototype gebouwd met Eleventy e
 - Accountwisselaar staat achter feature flag `data-feature-default="off"`
 - Pagina-layout: `body` is een flex column met `min-block-size: 100dvh`, `<main>` heeft `flex: 1` zodat `<footer>` altijd onderaan staat
 - Lege dynamische containers: geef ze `class="dynamic-list"` zodat ze via `.dynamic-list:empty { display: none }` uit de layout vallen tot er items zijn
-- 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`
+- 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), haalUitMap?(berichtId) }`. `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, mappen voor de scenario's M1–M3), `proeftuin-vier` (90000015, veel berichten in mappen), `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.
 
+- Berichtenbox, mappen uit het Federatief Berichtenstelsel (MinBZK/MijnOverheidZakelijk#941): daar is een map geen ding op zich maar een eigenschap van een bericht, opgeslagen bij de organisatie die het stuurde. Er is dus geen mappenlijst en geen mappenopslag in de browser; het overzicht is afgeleid. Tijdens de ophaalronde komt het uit de `mappen` op elke `magazijn-bevraging-voltooid` met status `OK` (de lijst is dan niet op te vragen, 409): `berichtenbox-keten.js` telt ze per naam op over de organisaties heen en geeft ze mee als `voortgang.mappen`. Na de ronde is de lijst de bron: `mappenVan()` in `keten-bron.js` leidt ze af uit `bericht.map`. Namen gaan woordelijk en zijn ook de sleutel (`slug` = naam, in de URL als `?map=` ge-encodeerd): hoofdletters onderscheiden, een slug afleiden zou mappen samenvoegen. `werkMappenBij()` in de render-laag zet de mappen in de tabbalk gelijk aan wat de bron levert; het sjabloon zet ze verborgen neer, want bij het bouwen is de persona onbekend. De mappen van de dataset blijven in de stijl tijdelijk verborgen (`.berichtenbox-folder-user`); een map met een aantal krijgt `data-map-uit-berichten` en is wél zichtbaar. Een map zonder berichten bestaat niet en verdwijnt dus vanzelf. Uit een map halen: de knop “Haal uit map” op `bericht-demo.html`, via `bron.haalUitMap()` naar `PATCH /api/v1/berichten/{berichtId}?magazijnId=` met `{"map": ""}` en `Content-Type: application/merge-patch+json` — niet `null`, dat betekent in een merge-patch “niet wijzigen”. Verplaatsen naar een andere map of een map hernoemen is er bewust niet (hernoemen zou elk bericht in die map patchen). Een mapwijziging telt als wijziging van de lijst: het pollen vergelijkt id én map, en `aanwasVan` in `keten-bron.js` maakt van een bericht in een andere map, of een binnenkomer mét map, een hele lijst in plaats van een binnenkomer. Wie er niet leverde staat op elke pagina van de berichtenlijst (`aantalNietGeleverd`, `nietGeleverd`), ook na verversen; volledig is `aantalNietGeleverd == 0`, niet een lege `nietGeleverd` (een sessie over een uitrol heen kent het aantal zonder namen). De melding daarover gaat voor op die uit de ronde (`toonUitval`), wordt bij elke polltik bijgewerkt en alleen ingetrokken als het die melding zelf was. De `status` wordt niet gelezen: elke organisatie in die lijst leverde niet, ook bij een onbekende waarde.
 - 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.
 - Berichtenbox-state hoort bij één persona. `maakState(opslag, persona)` schrijft de actieve persona in de bewaarde staat en gooit een staat van iemand anders weg — tussen persona's bestaat geen verband, het zijn andere bedrijven met andere post. Dat geldt ook voor `eersteBezoekGehad`, dus elke persona krijgt de ophaalanimatie één keer. Een staat zonder persona komt uit een oudere versie en verdwijnt zodra er wél een persona is; draait er geen `personas.js`, dan blijft hij staan. Onleesbare opslag wordt nooit overschreven, ook niet om er een persona in te zetten. Het markeren vanaf de homepage (`leesGedeeldeState` in `berichtenbox.js`) hanteert dezelfde regel.
diff --git a/_data/personas.json b/_data/personas.json
index 715eda5b..f01585f2 100644
--- a/_data/personas.json
+++ b/_data/personas.json
@@ -1662,6 +1662,61 @@
 		"homepageSubsidies": ["duurzaam-advies-voucher"],
 		"homepageRegelgeving": ["milieubeheer"]
 	},
+	{
+		"id": "proeftuin-vier",
+		"stelsel": true,
+		"actief": false,
+		"archief": false,
+		"label": "Aangesloten onderneming 4",
+		"persoon": {
+			"voornaam": "Sam",
+			"achternaam": "de Wit"
+		},
+		"bedrijf": {
+			"handelsnaam": "Demo-onderneming 4",
+			"functies": "Eigenaar",
+			"website": "",
+			"kvkNummer": "90000015",
+			"rsinNummer": "90000015",
+			"btwNummer": "NL00090000015",
+			"omzetbelastingnummer": "090000015B01",
+			"startdatum": "1 maart 2024",
+			"rechtsvorm": "Besloten vennootschap",
+			"branche": "Groothandel",
+			"vestigingsadres": "Blaak 16, Rotterdam",
+			"gemeente": "Rotterdam",
+			"rol": "Eigenaar",
+			"vestigingsnummer": "000090000015",
+			"iban": "",
+			"loonheffingennummer": "",
+			"werkzamePersonenFulltime": 1,
+			"werkzamePersonenParttime": 0,
+			"sbi": [
+				{
+					"code": "46900",
+					"omschrijving": "Niet-gespecialiseerde groothandel"
+				}
+			],
+			"vestigingsadresVolledig": "Blaak 16, 3011 TA Rotterdam",
+			"postadres": "Blaak 16, 3011 TA Rotterdam",
+			"vestigingen": [
+				{
+					"nummer": "000090000015",
+					"type": "Hoofdvestiging",
+					"adres": "Blaak 16, 3011 TA Rotterdam"
+				}
+			],
+			"ubo": [],
+			"jaarrekeningen": []
+		},
+		"andereBedrijven": [],
+		"belangen": [],
+		"subsidies": ["mkb-digitaliseringssubsidie", "duurzaam-advies-voucher", "kia"],
+		"regelgeving": ["handelsregisterwet", "loonbelasting", "dienstenwet", "milieubeheer"],
+		"buurt": "rotterdam",
+		"homepageSubsidies": ["duurzaam-advies-voucher"],
+		"homepageRegelgeving": ["milieubeheer"]
+	},
 	{
 		"id": "proeftuin-veel",
 		"stelsel": true,
diff --git a/_includes/berichtenbox-tabs.njk b/_includes/berichtenbox-tabs.njk
index c9dc6ce2..6b9f3a5b 100644
--- a/_includes/berichtenbox-tabs.njk
+++ b/_includes/berichtenbox-tabs.njk
@@ -32,9 +32,12 @@
 				<!-- <span class="badge" data-berichtenbox-count="prullenbak">0</span> -->
 			</a>
 		</li>
-		<li class="list-separation"><span class="visually-hidden">Mappen:</span></li>
+		{# Verborgen tot berichtenbox.js weet welke mappen er zijn. Bij het bouwen is niet te weten welke
+		   persona er kijkt, en wie zijn berichten uit het stelsel haalt heeft andere mappen dan de dataset:
+		   daar is een map een eigenschap van een bericht, en het overzicht komt uit die berichten. #}
+		<li class="list-separation" hidden><span class="visually-hidden">Mappen:</span></li>
 		{% for map in box.mappen %}
-			<li data-map-slug="{{ map.slug }}" class="berichtenbox-folder-user">
+			<li data-map-slug="{{ map.slug }}" class="berichtenbox-folder-user" hidden>
 				<a href="{{ tabsBasis | url }}?map={{ map.slug }}#hoofd-inhoud">
 					<svg xmlns="http://www.w3.org/2000/svg" class="icon-sm" viewBox="0 0 64 64">
 						<path fill="currentColor" d="M58 15H29v-2c0-1.1-.9-2-2-2H12c-1.1 0-2 .9-2 2v4.69c7.13.47 40.09 2.62 40.59 2.75.28.07.38.21.4.34 0 .04.02.23-.01.23H4.53c-1.29 0-2.24 1.2-1.95 2.46l7.06 30c.27 1.16 1.18 1.54 2.36 1.54h46a2 2 0 0 0 2-2V17c0-1.1-.9-2-2-2" />
diff --git a/assets/javascript/berichtenbox-keten.js b/assets/javascript/berichtenbox-keten.js
index 97c40b74..d42d2117 100644
--- a/assets/javascript/berichtenbox-keten.js
+++ b/assets/javascript/berichtenbox-keten.js
@@ -5,7 +5,10 @@
  * plaats van uit de gegenereerde dataset. Welke persona aangesloten is zegt de demo-omgeving
  * (/api/demo/personas); staat de actieve persona daar niet bij, dan blijft de dataset staan.
  *
- * Alleen lezen: markeren, verplaatsen en verwijderen blijven op de bestaande localStorage-state.
+ * Vrijwel alleen lezen: markeren, archiveren en verwijderen blijven op de bestaande
+ * localStorage-state. De uitzondering is een bericht uit zijn map halen. Een map hoort bij het
+ * bericht en staat bij de organisatie die het stuurde, dus die wijziging gaat naar het stelsel en
+ * niet naar de browser.
  *
  * Dit is de transportlaag, en verder niets: hij haalt op, en meldt wat hij ziet. Wat daarvan op het
  * scherm komt en waar, bepaalt `berichtenbox/keten-bron.js` — die maakt hier een bron van, zoals de
@@ -134,6 +137,10 @@
 		traag: "Het ophalen van dit bericht duurde te lang. Ververs de pagina om het opnieuw te proberen.",
 	};
 
+	// Het bericht blijft waar het was, dus opnieuw proberen kan: de knop staat er nog.
+	const UIT_MAP_TRAAG = "Het uit de map halen duurde te lang, dus wij weten niet of het gelukt is. Ververs de pagina om te zien waar het bericht staat.";
+	const UIT_MAP_FOUT = "Wij konden dit bericht niet uit de map halen. Het staat nog in de map. Probeer het opnieuw.";
+
 	// Het pollen geeft het op. Geen storing maar een mededeling: de lijst die er staat klopt nog, en
 	// wat er misgaat is dat zij zich niet meer bijwerkt. Zeggen wat er aan de hand is en wat de
 	// bezoeker eraan kan doen — verversen begint met een nieuwe ophaalronde en zet alles terug.
@@ -164,6 +171,10 @@
 	// 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.
 	let organisatiesVanRonde = {};
+	// Wie er volgens de laatst gelezen lijst niet leverde, of null als het stelsel dat niet zegt. Het
+	// pollen vergelijkt ermee: verandert het, dan hoort de melding mee te veranderen, ook als de
+	// berichten zelf hetzelfde bleven.
+	let laatstNietGeleverd = null;
 
 	// --- Wat de buitenwereld te horen krijgt ---------------------------------------------------
 
@@ -173,7 +184,10 @@
 	// bronuitval, en is voor de bezoeker niet meer te zien wat echt is en wat nagebootst.
 
 	let melding = null; // { soort: "storing" | "mededeling", tekst }
-	let voortgang = null; // { bevraagd, klaar, gevonden }
+	let voortgang = null; // { bevraagd, klaar, gevonden, mappen? }
+	// Staat de melding van hierboven er omdat niet elke organisatie leverde? Dan mag een lijst die
+	// weer volledig is hem intrekken; een andere melding laat die lijst staan.
+	let meldingOverNietGeleverd = false;
 	let laatsteUitkomst = null;
 	// De laatste berichtenlijst die als wijziging naar de bron ging. Apart van `laatsteUitkomst`, want
 	// alleen deze mag op null: kon de bron de lijst niet tonen, dan telt zij weer als wijziging (zie
@@ -197,6 +211,7 @@
 
 	function meld(soort, tekst) {
 		melding = tekst ? { soort: soort, tekst: tekst } : null;
+		meldingOverNietGeleverd = false;
 		laatWeten();
 	}
 
@@ -229,10 +244,42 @@
 		meld(null, null);
 	}
 
+	/**
+	 * Organisaties die in de laatste ronde niet leverden, zoals de berichtenlijst dat vastlegt.
+	 *
+	 * Anders dan `toonUitval` hierboven komt dit niet uit de ronde maar uit de lijst, en die draagt
+	 * het op elke pagina en ook na verversen. Daarom mag deze melding pas weg als het aantal nul is,
+	 * en niet als er alleen geen namen meer bij staan: een sessie die over een uitrol heen loopt kent
+	 * het aantal wél en de namen niet. Dan noemen we er geen, maar zeggen we nog steeds dat er iets
+	 * kan ontbreken.
+	 *
+	 * Mappen staan erbij omdat die bij het bericht horen, bij de organisatie die het stuurde. Levert
+	 * zij niet, dan ontbreken haar mappen ook — of tellen ze minder dan ze zouden moeten.
+	 */
+	function toonNietGeleverd(nietGeleverd) {
+		const namen = nietGeleverd.namen;
+		const rest = nietGeleverd.aantal - namen.length;
+		let wie;
+		if (!namen.length) {
+			wie = nietGeleverd.aantal === 1 ? "Eén organisatie heeft" : nietGeleverd.aantal + " organisaties hebben";
+		} else if (rest > 0) {
+			wie = namen.join(", ") + " en nog " + (rest === 1 ? "één organisatie" : rest + " organisaties") + " hebben";
+		} else {
+			wie = namen.length > 1 ? namen.slice(0, -1).join(", ") + " en " + namen[namen.length - 1] + " hebben" : namen[0] + " heeft";
+		}
+		const van = nietGeleverd.aantal === 1 ? "van die organisatie" : "van die organisaties";
+		meld("mededeling", wie + " uw berichten niet geleverd. Berichten en mappen " + van + " kunnen daardoor ontbreken.");
+		meldingOverNietGeleverd = true;
+	}
+
 	// Hoeveel organisaties bevraagd zijn, hoeveel er antwoordden en hoeveel berichten dat opleverde.
 	// Dit is échte voortgang: het komt uit de stroom van het stelsel zelf, niet uit een nabootsing.
-	function toonVoortgang(bevraagd, klaar, gevonden) {
+	//
+	// `mappen` alleen als het stelsel ze meestuurt: een keten van vóór dat veld zegt niets over
+	// mappen, en een lege lijst zou dan beweren dat er geen zijn.
+	function toonVoortgang(bevraagd, klaar, gevonden, mappen) {
 		voortgang = { bevraagd: bevraagd, klaar: klaar, gevonden: gevonden };
+		if (mappen) voortgang.mappen = mappen;
 		laatWeten();
 	}
 
@@ -378,11 +425,39 @@
 		}
 	}
 
+	/**
+	 * Het mappenoverzicht tot nu toe, uit wat de organisaties tijdens de ronde meldden.
+	 *
+	 * Een map is geen ding bij het stelsel maar een eigenschap van een bericht, en die ligt bij de
+	 * organisatie die het stuurde. Dezelfde naam kan dus bij twee organisaties voorkomen; voor de
+	 * bezoeker is dat één map, en de aantallen tellen op. Namen gaan woordelijk: "Belasting" en
+	 * "belasting" zijn twee mappen, want zo staan ze bij de organisatie.
+	 *
+	 * Tijdens de ronde is de berichtenlijst niet op te vragen — het stelsel antwoordt dan met 409 —
+	 * dus dit is het enige wat er over mappen te zeggen valt tot de ronde klaar is. Daarna is de lijst
+	 * zelf de bron.
+	 */
+	function telMappenOp(mappenPerOrganisatie) {
+		const aantallen = new Map();
+		for (const mappen of Object.values(mappenPerOrganisatie)) {
+			for (const map of mappen) {
+				if (!map || typeof map.naam !== "string" || map.naam.trim() === "") continue;
+				aantallen.set(map.naam, (aantallen.get(map.naam) || 0) + (Number(map.aantalBerichten) || 0));
+			}
+		}
+		return Array.from(aantallen, ([naam, aantal]) => ({ naam: naam, aantalBerichten: aantal })).sort((a, b) => a.naam.localeCompare(b.naam, "nl"));
+	}
+
 	// 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.
 	async function haalOp(ontvanger) {
 		const organisaties = {};
 		const stil = [];
+		// Per organisatie de mappen die zij meldde. Per organisatie en niet meteen opgeteld: een
+		// organisatie kan zich — bij een herhaalde gebeurtenis — twee keer melden, en dan hoort haar
+		// telling vervangen te worden, niet verdubbeld.
+		const mappenPerOrganisatie = {};
+		let mappenGemeld = false;
 		let klaar = 0;
 		let gevonden = 0;
 		let gereed = false;
@@ -437,6 +512,13 @@
 				klaar++;
 				gevonden += gebeurtenis.aantalBerichten || 0;
 				if (gebeurtenis.status !== "OK") stil.push(gebeurtenis.naam || gebeurtenis.magazijnId);
+				// Alleen bij "OK" draagt de gebeurtenis mappen. Wie niet leverde, heeft er ook geen
+				// gemeld; die mappen ontbreken tot een volgende ronde, en de melding over wie niet
+				// leverde zegt dat.
+				if (gebeurtenis.status === "OK" && Array.isArray(gebeurtenis.mappen)) {
+					mappenPerOrganisatie[gebeurtenis.magazijnId || gebeurtenis.naam || "zonder-id-" + klaar] = gebeurtenis.mappen;
+					mappenGemeld = true;
+				}
 			}
 			if (gebeurtenis.event === "ophalen-fout") {
 				const fout = ketenFout("onbereikbaar", "het stelsel meldde een fout tijdens het ophalen");
@@ -444,7 +526,7 @@
 				throw fout;
 			}
 
-			toonVoortgang(Object.keys(organisaties).length, klaar, gevonden);
+			toonVoortgang(Object.keys(organisaties).length, klaar, gevonden, mappenGemeld ? telMappenOp(mappenPerOrganisatie) : null);
 			if (gebeurtenis.event === "ophalen-gereed") gereed = true;
 		}
 
@@ -525,15 +607,18 @@
 	 * demonstratie hoort de hele berichtenbox te tonen en niet de eerste honderd, dus blijven we
 	 * bladeren zolang het stelsel een volgende pagina noemt.
 	 *
-	 * Geeft `{ berichten, afgekapt }`. `afgekapt` staat aan als we bij de bovengrens stopten terwijl
-	 * er nog een volgende pagina was — dan zegt de berichtenbox erbij dat er meer kan zijn. Elke
-	 * andere reden om te stoppen is een fout en werpt: een halve lijst die zich voordoet als een hele
-	 * is het ergste wat hier kan gebeuren, want daar is aan het scherm niets van te zien.
+	 * Geeft `{ berichten, afgekapt, nietGeleverd }`. `afgekapt` staat aan als we bij de bovengrens
+	 * stopten terwijl er nog een volgende pagina was — dan zegt de berichtenbox erbij dat er meer kan
+	 * zijn. `nietGeleverd` zegt welke organisaties in de laatste ronde niet leverden; zie
+	 * `nietGeleverdVan`. Elke andere reden om te stoppen is een fout en werpt: een halve lijst die zich
+	 * voordoet als een hele is het ergste wat hier kan gebeuren, want daar is aan het scherm niets van
+	 * te zien.
 	 */
 	async function haalLijst(ontvanger) {
 		const berichten = [];
 		const gezien = new Set();
 		const einde = Date.now() + LIJST_TOTAAL_LIMIET_MS;
+		let nietGeleverd = null;
 
 		for (let pagina = 0; pagina < MAX_PAGINAS; pagina++) {
 			const resterend = einde - Date.now();
@@ -569,11 +654,48 @@
 				console.warn("[Berichtenbox] " + dubbel + " bericht(en) kwamen op twee pagina's voor; de lijst groeide tijdens het ophalen.");
 			}
 
+			// Elke pagina draagt het; de laatste telt, want de ronde kan intussen opnieuw gedraaid zijn.
+			nietGeleverd = nietGeleverdVan(deel) || nietGeleverd;
+
 			// Een lege pagina is het einde, ook als er nog een `next` naast staat: nog een ronde langs
 			// hetzelfde antwoord levert niets nieuws op.
-			if (deel.berichten.length === 0 || !heeftVolgende(deel)) return { berichten: berichten, afgekapt: false };
+			if (deel.berichten.length === 0 || !heeftVolgende(deel)) return { berichten: berichten, afgekapt: false, nietGeleverd: nietGeleverd };
+		}
+		return { berichten: berichten, afgekapt: true, nietGeleverd: nietGeleverd };
+	}
+
+	/**
+	 * Welke organisaties in de laatste ronde niet leverden, uit één pagina van de berichtenlijst.
+	 *
+	 * Volledig is `aantalNietGeleverd` nul — niet een lege `nietGeleverd`. Een sessie die over een
+	 * uitrol van het stelsel heen loopt, kent het aantal wél en de namen niet; die lijst is dan korter
+	 * dan het aantal, en de melding zegt "mogelijk onvolledig" zonder namen in plaats van niets.
+	 *
+	 * De `status` (`FOUT`, `TIMEOUT`, `NIET_OPGEHAALD`) lezen we niet: elke organisatie in deze lijst
+	 * leverde niet, wat de reden ook is. Een status die we niet kennen verandert daar niets aan — hem
+	 * als geslaagd lezen zou een onvolledige lijst als volledig tonen.
+	 *
+	 * Geeft null als het veld ontbreekt: een stelsel van vóór dit veld zegt er niets over, en dan
+	 * blijft de melding uit de ronde (`toonUitval`) het enige wat we weten.
+	 */
+	function nietGeleverdVan(deel) {
+		const aantal = deel && deel.aantalNietGeleverd;
+		if (typeof aantal !== "number" || !Number.isFinite(aantal)) return null;
+
+		const lijst = Array.isArray(deel.nietGeleverd) ? deel.nietGeleverd : [];
+		const namen = [];
+		for (const organisatie of lijst) {
+			const naam = organisatie && (organisatie.naam || organisatie.magazijnId);
+			if (typeof naam === "string" && naam !== "" && namen.indexOf(naam) === -1) namen.push(naam);
 		}
-		return { berichten: berichten, afgekapt: true };
+		// Meer namen dan het aantal is een tegenstrijdig antwoord. Het aantal is de afspraak, maar een
+		// organisatie die met naam genoemd wordt, leverde aantoonbaar niet — dus die telt mee.
+		return { aantal: Math.max(aantal, namen.length), namen: namen };
+	}
+
+	function zelfdeNietGeleverd(vorige, nieuwe) {
+		if (!vorige || !nieuwe) return vorige === nieuwe;
+		return vorige.aantal === nieuwe.aantal && vorige.namen.join("|") === nieuwe.namen.join("|");
 	}
 
 	/**
@@ -660,6 +782,30 @@
 		};
 	}
 
+	/**
+	 * Haalt een bericht uit zijn map, terug naar de inbox.
+	 *
+	 * De map is een eigenschap van het bericht en staat bij de organisatie die het stuurde; daar
+	 * gaat deze wijziging dus ook heen, via de uitvraag. `{"map": ""}` en niet `null`: in een
+	 * merge-patch betekent `null` "niet wijzigen", en dan gebeurt er niets terwijl het stelsel met
+	 * een 200 antwoordt.
+	 *
+	 * Werpt bij alles behalve een 2xx.
+	 */
+	async function patchUitMap(ontvanger, berichtId, magazijnId) {
+		const adres = "/api/v1/berichten/" + encodeURIComponent(berichtId) + "?magazijnId=" + encodeURIComponent(magazijnId);
+		const respons = await metTijdslimiet(
+			adres,
+			{
+				method: "PATCH",
+				headers: { "X-Ontvanger": ontvanger, "Content-Type": "application/merge-patch+json" },
+				body: JSON.stringify({ map: "" }),
+			},
+			INHOUD_LIMIET_MS
+		);
+		if (!respons.ok) throw ketenFout(redenVanRespons(respons, "een bericht uit zijn map halen"), "uit map halen mislukt (" + respons.status + ")");
+	}
+
 	// --- Vertaling ----------------------------------------------------------------------------
 
 	// Zonder berichtId is er geen sleutel voor de state en geen detailpagina; zo'n bericht laten we
@@ -933,9 +1079,14 @@
 				// onwaar: die vergelijking mag niet stilzwijgend voor "alles is er" doorgaan.
 			} else if (typeof uitvraag.gevonden === "number" && berichten.length < uitvraag.gevonden) {
 				toonOnvolledig(berichten.length, uitvraag.gevonden);
+			} else if (lijst.nietGeleverd) {
+				// Wat de lijst zegt gaat vóór wat de ronde zag: de lijst draagt het ook na verversen, en
+				// een pagina die de sessie van een andere pagina leest heeft geen eigen ronde gezien.
+				if (lijst.nietGeleverd.aantal > 0) toonNietGeleverd(lijst.nietGeleverd);
 			} else if (uitvraag.stil.length > 0) {
 				toonUitval(uitvraag.stil);
 			}
+			laatstNietGeleverd = lijst.nietGeleverd;
 
 			return { berichten: berichten, magazijnen: magazijnen };
 		} catch (fout) {
@@ -962,6 +1113,9 @@
 	let pollBezig = false;
 	let pollHerstelBezig = false;
 	let laatsteTikOp = 0;
+	// Telt op bij elke map-wijziging die hier gedaan is. Een tik die de lijst vóór die wijziging
+	// opvroeg en erna terugkomt, zou het bericht anders terugzetten in zijn map.
+	let mapVersie = 0;
 
 	/**
 	 * Een instelling in seconden: eerst de URL, dan localStorage, anders de standaardwaarde.
@@ -1108,6 +1262,7 @@
 		// Waar deze tik bij hoort. Draait er onderweg een nieuwe ophaalronde, dan is wat hier
 		// terugkomt ouder dan wat die ronde opleverde.
 		const rondeVanTik = ronde;
+		const mapVersieVanTik = mapVersie;
 
 		try {
 			const lijst = await haalLijst(ontvangerVanRonde);
@@ -1115,7 +1270,7 @@
 			// De pagina is intussen weg geweest, of een nieuwere ronde heeft ons ingehaald. Dit antwoord
 			// stilzwijgend laten vallen is hier het juiste: het zou een verouderde lijst over een
 			// nieuwere heen leggen, en de bron zou een zojuist getoond bericht weer weghalen.
-			if (achterhaald(rondeVanTik)) return;
+			if (achterhaald(rondeVanTik, mapVersieVanTik)) return;
 
 			// Pas nullen als het verwerken ook lukte: een antwoord dat aankomt maar niet te lezen is,
 			// hoort mee te tellen in de foutenreeks en niet die van zijn voorgangers te wissen.
@@ -1123,7 +1278,7 @@
 			pollFouten = 0;
 			pollHerstelPogingen = 0;
 		} catch (fout) {
-			if (achterhaald(rondeVanTik)) return;
+			if (achterhaald(rondeVanTik, mapVersieVanTik)) return;
 
 			// De sessie is weg. Doorpollen levert niets meer op: alleen een nieuwe ronde vult hem.
 			if (redenVan(fout) === "geenSessie") {
@@ -1154,9 +1309,9 @@
 	 * 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.
 	 */
-	function achterhaald(rondeVanTik) {
+	function achterhaald(rondeVanTik, mapVersieVanTik) {
 		if (pollGestopt || pollGeparkeerd) return true;
-		if (ronde !== rondeVanTik) {
+		if (ronde !== rondeVanTik || mapVersie !== mapVersieVanTik) {
 			planPoll();
 			return true;
 		}
@@ -1183,6 +1338,8 @@
 		const ruw = lijst.berichten;
 		const berichten = ruw.filter(bruikbaar).map((bericht) => naarBerichtenboxVorm(bericht));
 
+		werkNietGeleverdBij(lijst.nietGeleverd);
+
 		// 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;
@@ -1222,10 +1379,36 @@
 		laatstGemeld = uitkomst.berichten;
 	}
 
+	/**
+	 * Dezelfde berichten, in dezelfde mappen. De map telt mee: een bericht dat uit zijn map gehaald
+	 * is — in een ander tabblad, of door de organisatie zelf — is voor het mappenoverzicht een
+	 * wijziging, ook al staat er geen bericht bij of af.
+	 */
 	function zelfdeBerichten(vorige, nieuwe) {
 		if (vorige.length !== nieuwe.length) return false;
-		const oud = new Set(vorige.map((bericht) => bericht.id));
-		return nieuwe.every((bericht) => oud.has(bericht.id));
+		const oud = new Map(vorige.map((bericht) => [bericht.id, bericht.map || null]));
+		return nieuwe.every((bericht) => oud.has(bericht.id) && oud.get(bericht.id) === (bericht.map || null));
+	}
+
+	/**
+	 * Houdt de melding over wie niet leverde gelijk met de lijst.
+	 *
+	 * Alleen als het veranderde: het meldingsblok is een live-regio, en elke tik dezelfde tekst erin
+	 * schrijven laat een schermlezer hem elke vijftien seconden voorlezen. En alleen onze eigen
+	 * melding intrekken — staat er iets anders, dan is dat nog steeds waar.
+	 */
+	function werkNietGeleverdBij(nietGeleverd) {
+		// Een stelsel dat het veld niet (meer) meestuurt, zegt er niets over. Dat is geen "alles
+		// geleverd", dus de melding die er staat blijft.
+		if (!nietGeleverd || zelfdeNietGeleverd(laatstNietGeleverd, nietGeleverd)) return;
+		laatstNietGeleverd = nietGeleverd;
+
+		if (nietGeleverd.aantal > 0) {
+			// Geen andere melding overschrijven: die gaat over iets anders en is nog steeds waar.
+			if (!melding || meldingOverNietGeleverd) toonNietGeleverd(nietGeleverd);
+		} else if (meldingOverNietGeleverd) {
+			verbergMeldingen();
+		}
 	}
 
 	/**
@@ -1447,6 +1630,40 @@
 			}
 		},
 
+		/**
+		 * Haalt een bericht uit zijn map. Geeft `{}` als het lukte, of `{ fout }` met een tekst voor de
+		 * bezoeker. Werpt niet: de aanroeper is een knop, en die hoort te zeggen wat er misging.
+		 *
+		 * Lukt het, dan staat het bericht meteen zonder map in de lijst, zonder op de volgende tik te
+		 * wachten. Het stelsel heeft het dan al; de lijst hier bijwerken is niets vooruitlopen. Was het
+		 * het laatste bericht in die map, dan is de map daarmee weg: een lege map bestaat niet.
+		 */
+		haalUitMap: async function (berichtId) {
+			const bericht = laatsteUitkomst && laatsteUitkomst.berichten.find((b) => b.id === berichtId);
+			if (!ontvangerVanRonde || !bericht || !bericht.magazijnId) {
+				console.warn("[Berichtenbox] Dit bericht is niet uit zijn map te halen: geen ontvanger of geen organisatie bekend.", berichtId);
+				return { fout: UIT_MAP_FOUT };
+			}
+			if (!bericht.map) return {};
+
+			try {
+				await patchUitMap(ontvangerVanRonde, berichtId, bericht.magazijnId);
+			} catch (fout) {
+				console.error("[Berichtenbox] bericht uit zijn map halen mislukt", fout);
+				// Bij een tijdslimiet weten we niet of het stelsel het al gedaan heeft; "het staat nog in
+				// de map" zou dan misschien onwaar zijn.
+				if (redenVan(fout) === "stil") return { fout: UIT_MAP_TRAAG };
+				return { fout: redenVan(fout) === "configuratie" ? FOUT_TEKSTEN.configuratie : UIT_MAP_FOUT };
+			}
+
+			mapVersie += 1;
+			const berichten = laatsteUitkomst.berichten.map((b) => (b.id === berichtId ? Object.assign({}, b, { map: null }) : b));
+			laatsteUitkomst = { berichten: berichten, magazijnen: laatsteUitkomst.magazijnen };
+			laatstGemeld = berichten;
+			laatWeten();
+			return {};
+		},
+
 		/**
 		 * 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
diff --git a/assets/javascript/berichtenbox.js b/assets/javascript/berichtenbox.js
index 9ac0e0d1..7c43e951 100644
--- a/assets/javascript/berichtenbox.js
+++ b/assets/javascript/berichtenbox.js
@@ -499,7 +499,7 @@ import { ketenBron } from "./berichtenbox/keten-bron.js";
 
 		const alleMappen = [...data.mappen, ...state.eigenMappen];
 		alleMappen.forEach((m) => {
-			const el = document.querySelector(`[data-berichtenbox-count="map:${m.slug}"]`);
+			const el = document.querySelector(`[data-berichtenbox-count="map:${CSS.escape(m.slug)}"]`);
 			if (!el) return;
 			const n = data.berichten.filter((b) => {
 				if (statusVan(b.id) !== "inbox") return false;
@@ -1023,6 +1023,93 @@ import { ketenBron } from "./berichtenbox/keten-bron.js";
 		lijst.appendChild(li);
 	}
 
+	// Heeft de bron al mappen geleverd? Tot dan komt het overzicht uit de voortgang van de ronde.
+	let mappenVanBron = false;
+
+	const MAP_ICOON = '<svg xmlns="http://www.w3.org/2000/svg" class="icon-sm" viewBox="0 0 64 64" aria-hidden="true"><path fill="currentColor" d="M58 15H29v-2c0-1.1-.9-2-2-2H12c-1.1 0-2 .9-2 2v4.69c7.13.47 40.09 2.62 40.59 2.75.28.07.38.21.4.34 0 .04.02.23-.01.23H4.53c-1.29 0-2.24 1.2-1.95 2.46l7.06 30c.27 1.16 1.18 1.54 2.36 1.54h46a2 2 0 0 0 2-2V17c0-1.1-.9-2-2-2" /></svg>';
+
+	/**
+	 * Zet de mappen in de tabbalk gelijk aan wat de bron levert.
+	 *
+	 * Het sjabloon zet de mappen van de dataset neer, verborgen: bij het bouwen is niet te weten welke
+	 * persona er kijkt, en een persona die zijn berichten uit het stelsel haalt heeft andere mappen —
+	 * of geen. Pas als de bron zegt welke mappen er zijn, komen ze in beeld. Een map die de bron niet
+	 * meer noemt, verdwijnt; dat is ook hoe een map zonder berichten verdwijnt.
+	 *
+	 * Draagt een map een aantal (`aantalBerichten`), dan staat dat erbij. Tijdens een ophaalronde
+	 * groeit het overzicht zo mee met wat de organisaties melden.
+	 *
+	 * Bestaande items blijven staan en schuiven alleen op hun plek: een item vervangen zou de focus
+	 * weghalen bij wie er met het toetsenbord op staat.
+	 */
+	function werkMappenBij(mappen) {
+		const scheiding = document.querySelector(".tablist .list-separation");
+		if (!scheiding) return;
+		const lijst = scheiding.parentNode;
+
+		const bestaand = new Map();
+		lijst.querySelectorAll(".berichtenbox-folder-user").forEach((li) => bestaand.set(li.dataset.mapSlug, li));
+
+		const actief = huidigeView() === "inbox" ? new URLSearchParams(location.search).get("map") : null;
+		const gezien = new Set();
+
+		mappen.forEach((map) => {
+			if (!map || typeof map.slug !== "string" || gezien.has(map.slug)) return;
+			gezien.add(map.slug);
+
+			let li = bestaand.get(map.slug);
+			if (!li) {
+				li = document.createElement("li");
+				li.className = "berichtenbox-folder-user";
+				li.dataset.mapSlug = map.slug;
+				const a = document.createElement("a");
+				a.href = url(berichtenboxBasis() + "?map=" + encodeURIComponent(map.slug) + "#hoofd-inhoud");
+				a.innerHTML = MAP_ICOON;
+				a.appendChild(document.createTextNode(" " + map.naam + " "));
+				li.appendChild(a);
+			}
+
+			const a = li.querySelector("a");
+			let aantal = li.querySelector("[data-berichtenbox-map-aantal]");
+			// Een map met een aantal komt uit de berichten zelf. Die zijn zichtbaar, ook nu de mappen
+			// van de dataset in de stijl tijdelijk verborgen staan.
+			li.toggleAttribute("data-map-uit-berichten", typeof map.aantalBerichten === "number");
+			if (typeof map.aantalBerichten === "number") {
+				// Geen bolletje: dat staat bij de inbox voor "ongelezen", en dit is het totaal in de map.
+				if (!aantal && a) {
+					aantal = document.createElement("span");
+					aantal.dataset.berichtenboxMapAantal = "";
+					a.appendChild(aantal);
+				}
+				if (aantal) {
+					aantal.textContent = "\u00a0(" + map.aantalBerichten;
+					const eenheid = document.createElement("span");
+					eenheid.className = "visually-hidden";
+					eenheid.textContent = map.aantalBerichten === 1 ? " bericht" : " berichten";
+					aantal.appendChild(eenheid);
+					aantal.appendChild(document.createTextNode(")"));
+				}
+			} else if (aantal) {
+				aantal.remove();
+			}
+
+			if (a && actief === map.slug) a.setAttribute("aria-current", "page");
+
+			li.hidden = false;
+			lijst.appendChild(li);
+		});
+
+		bestaand.forEach((li, slug) => {
+			if (!gezien.has(slug)) li.remove();
+		});
+
+		scheiding.hidden = gezien.size === 0;
+
+		// Binnen het Belastingdienst-portaal horen de mappen bij de andere organisaties en staan ze
+		// alleen als die zichtbaar zijn. Dat geldt ook voor wat hier net in beeld kwam.
+		werkMappenZichtbaarheidBij();
+	}
+
 	// Vlag-knop voor de Gemarkeerd-kolom; spiegelt de markup uit berichtenbox-row.njk.
 	function maakMarkKnop(gemarkeerd) {
 		const knop = document.createElement("button");
@@ -1431,7 +1518,9 @@ import { ketenBron } from "./berichtenbox/keten-bron.js";
 
 		const mapFilter = mapUitUrl();
 		if (mapFilter) {
-			const mapTab = document.querySelector('[data-map-slug="' + mapFilter + '"] a');
+			// Een mapnaam uit het stelsel komt woordelijk mee, met spaties en al wat een organisatie erin
+			// zette. Ongeëscaped breekt een aanhalingsteken de selector en daarmee dit hele blok.
+			const mapTab = document.querySelector('[data-map-slug="' + CSS.escape(mapFilter) + '"] a');
 			if (mapTab) {
 				mapTab.setAttribute("aria-current", "page");
 				mapTab.setAttribute("aria-selected", "true");
@@ -1444,8 +1533,11 @@ import { ketenBron } from "./berichtenbox/keten-bron.js";
 					inboxLink.removeAttribute("aria-selected");
 				}
 			}
+			// Een map die uit de berichten is afgeleid — die draagt een aantal — heeft geen aanmaakdatum:
+			// hij bestaat zolang er een bericht in zit. Daar een datum noemen zou iets verzinnen.
+			const map = data.mappen.find((m) => m.slug === mapFilter);
 			const counterP = document.querySelector("[data-berichtenbox-toolbar] > p");
-			if (counterP) counterP.textContent = "Deze map heeft u aangemaakt op 7 april 2026.";
+			if (counterP && !(map && typeof map.aantalBerichten === "number")) counterP.textContent = "Deze map heeft u aangemaakt op 7 april 2026.";
 		}
 		pasFilterToe();
 	}
@@ -1504,8 +1596,7 @@ import { ketenBron } from "./berichtenbox/keten-bron.js";
 		// Hier inline, want dit icoon komt pas in beeld nadat JavaScript weet waar het bericht staat,
 		// en de icoon-shortcode van Eleventy draait alleen bij de build. `aria-hidden` omdat de knop
 		// zijn naam uit zijn tekst haalt.
-		const ICOON_BERICHTENBOX =
-			'<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" aria-hidden="true"><path fill="currentColor" d="M1 4v2.1l9.4 5.7c1 .6 2.2.6 3.1 0L23 6.1V4H1z" /><path fill="currentColor" d="M10.4 14 1 8.3V19h22V8.3L13.6 14c-1 .6-2.2.6-3.2 0z" /></svg>';
+		const ICOON_BERICHTENBOX = '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" aria-hidden="true"><path fill="currentColor" d="M1 4v2.1l9.4 5.7c1 .6 2.2.6 3.1 0L23 6.1V4H1z" /><path fill="currentColor" d="M10.4 14 1 8.3V19h22V8.3L13.6 14c-1 .6-2.2.6-3.2 0z" /></svg>';
 
 		// Alleen het icoon vervangen, de tekst en de visually-hidden span laten staan.
 		function zetKnopIcoon(btn, svg) {
@@ -2189,18 +2280,7 @@ import { ketenBron } from "./berichtenbox/keten-bron.js";
 
 		document.title = "MijnOverheid Zakelijk: " + bericht.onderwerp;
 
-		const effMap = mapVan(bericht.id, bericht.map);
-		const metaEl = detail.querySelector("[data-demo-meta]");
-		if (metaEl) {
-			metaEl.textContent = bericht.afzender + " \u00b7 " + datumNL(bericht.datum);
-			if (effMap) {
-				const span = document.createElement("span");
-				span.dataset.maplabel = "";
-				span.textContent = effMap;
-				metaEl.appendChild(document.createTextNode(" \u00b7 "));
-				metaEl.appendChild(span);
-			}
-		}
+		schrijfDemoMeta(detail, bericht, mapVan(bericht.id, bericht.map));
 
 		const bodyEl = detail.querySelector("[data-demo-body]");
 		if (bodyEl) {
@@ -2233,6 +2313,72 @@ import { ketenBron } from "./berichtenbox/keten-bron.js";
 		}
 	}
 
+	function schrijfDemoMeta(detail, bericht, map) {
+		const metaEl = detail.querySelector("[data-demo-meta]");
+		if (!metaEl) return;
+		metaEl.textContent = bericht.afzender + " \u00b7 " + datumNL(bericht.datum);
+		if (map) {
+			const span = document.createElement("span");
+			span.dataset.maplabel = "";
+			span.textContent = map;
+			metaEl.appendChild(document.createTextNode(" \u00b7 "));
+			metaEl.appendChild(span);
+		}
+	}
+
+	/**
+	 * De knop "Haal uit map" op de detailpagina.
+	 *
+	 * Alleen als het bericht in een map staat en de bron het kan. Bij het stelsel is een map een
+	 * eigenschap van het bericht, opgeslagen bij de organisatie die het stuurde; de bron stuurt de
+	 * wijziging daarheen. Er is geen map om leeg achter te laten: was dit het laatste bericht erin,
+	 * dan is de map daarna weg uit het overzicht.
+	 *
+	 * `aria-disabled` en niet `disabled` zolang het verzoek loopt, zodat de knop voor een
+	 * schermlezer te vinden blijft.
+	 */
+	function bindUitMap() {
+		const knop = document.querySelector('[data-actie="uit-map"]');
+		const detail = document.querySelector("[data-demo-detail]");
+		if (!knop || !detail) return;
+
+		const bron = register.actief();
+		if (!bron || typeof bron.haalUitMap !== "function") return;
+
+		const berichtId = detail.dataset.berichtId;
+		const bericht = data.berichten.find((b) => b.id === berichtId);
+		if (!bericht || !bericht.map) return;
+
+		knop.hidden = false;
+		knop.addEventListener("click", async () => {
+			if (knop.getAttribute("aria-disabled") === "true") return;
+			knop.setAttribute("aria-disabled", "true");
+
+			const mapNaam = bericht.map;
+			const uitkomst = await bron.haalUitMap(berichtId);
+			knop.removeAttribute("aria-disabled");
+
+			if (uitkomst && uitkomst.fout) {
+				toonPaginaMelding(uitkomst.fout, "storing", "uit-map");
+				return;
+			}
+			verbergPaginaMelding("uit-map");
+
+			// De bron heeft de lijst al bijgewerkt; wat hier staat volgt.
+			const nu = data.berichten.find((b) => b.id === berichtId) || bericht;
+			schrijfDemoMeta(detail, nu, null);
+			werkMapKruimelBij();
+
+			// De knop gaat weg, dus de focus moet ergens heen waar de bezoeker verder kan.
+			knop.hidden = true;
+			const volgende = detail.querySelector(".action-group [data-actie]:not([hidden])");
+			if (volgende) volgende.focus();
+
+			const status = detail.querySelector("[data-demo-inhoud-status]");
+			if (status) status.textContent = "Dit bericht staat niet meer in de map " + mapNaam + ". U vindt het in uw inbox.";
+		});
+	}
+
 	function toonMappenZijbalk() {
 		const kop = document.querySelector("[data-berichtenbox-folders-heading]");
 		const lijst = document.querySelector("[data-berichtenbox-folders]");
@@ -2363,6 +2509,16 @@ import { ketenBron } from "./berichtenbox/keten-bron.js";
 			bron.volgVoortgang((voortgang) => {
 				laatste = voortgang;
 
+				// Het mappenoverzicht groeit mee met wat de organisaties tijdens de ronde melden, los van
+				// de drempel voor de balk: een map die er al is hoort er te staan, ook bij een korte ronde.
+				//
+				// Alleen tot de bron voor het eerst geleverd heeft. Daarna is de lijst de bron: een latere
+				// ronde — een herstel na een verlopen sessie — zou mappen die nog niet gemeld zijn even
+				// weghalen, met de focus en de actieve map erbij, en eindigen op de tellingen van de ronde.
+				if (voortgang && Array.isArray(voortgang.mappen) && !mappenVanBron) {
+					veilig({ log: "Het mappenoverzicht tijdens het ophalen", bezoeker: "De mappen zijn op dit moment niet volledig te zien." }, () => werkMappenBij(voortgang.mappen));
+				}
+
 				// Geen voortgang meer: de ronde is klaar of afgebroken. Wat er voor haar verborgen is,
 				// hoort dan weer op het scherm — ook als deze bron nooit aan tonen toekwam, want de
 				// lijst kan al vóór de bronkeuze zijn weggehaald. Alleen als niemand anders nog bezig is.
@@ -2711,6 +2867,7 @@ import { ketenBron } from "./berichtenbox/keten-bron.js";
 		// Eigen afscherming: gaat dit mis, dan staat er "Inbox" in het kruimelpad terwijl het bericht
 		// elders staat. Vervelend, maar geen reden om de knoppen hierboven mee te nemen.
 		veilig({ log: "De map in het kruimelpad", bezoeker: "Het kruimelpad laat niet zien waar dit bericht staat." }, werkMapKruimelBij);
+		veilig({ log: "De knop Haal uit map", bezoeker: "U kunt dit bericht nu niet uit zijn map halen." }, bindUitMap);
 
 		// Ná het register: dit hangt aan de bron. De wéérgave hoeft hier niet bijgewerkt te worden —
 		// de lading meldt zich als bronwijziging, en die luisteraar doet het.
@@ -2830,6 +2987,10 @@ import { ketenBron } from "./berichtenbox/keten-bron.js";
 		}
 
 		try {
+			if (!inhoud.nieuwBericht) {
+				werkMappenBij(data.mappen);
+				mappenVanBron = true;
+			}
 			werkMappenZichtbaarheidBij();
 			toonBerichten();
 			render(huidigeView());
@@ -2843,6 +3004,7 @@ import { ketenBron } from "./berichtenbox/keten-bron.js";
 			// De rijen zijn mogelijk al vervangen voordat het misging. Alleen `data` terugzetten laat
 			// het scherm iets tonen wat nergens meer bestaat.
 			try {
+				werkMappenBij(data.mappen);
 				toonBerichten();
 				render(huidigeView());
 			} catch (herstelFout) {
diff --git a/assets/javascript/berichtenbox/keten-bron.js b/assets/javascript/berichtenbox/keten-bron.js
index 37c231db..0642df1e 100644
--- a/assets/javascript/berichtenbox/keten-bron.js
+++ b/assets/javascript/berichtenbox/keten-bron.js
@@ -19,6 +19,36 @@
  * render-laag niet te weten of een bericht verzonnen is of echt.
  */
 
+/**
+ * Het mappenoverzicht, afgeleid uit de berichten.
+ *
+ * In het stelsel is een map geen ding op zich maar een eigenschap van een bericht, opgeslagen bij de
+ * organisatie die het stuurde. Er is dus geen lijst met mappen om op te vragen: wat hier staat is wat
+ * de berichten zeggen. Een map zonder berichten bestaat daarmee niet, en een map aanmaken vóór er
+ * een bericht in zit kan ook niet.
+ *
+ * De naam is ook de sleutel (`slug`), woordelijk: "Belasting" en "belasting" zijn twee mappen, zoals
+ * ze bij de organisatie staan. Een slug afleiden zou ze samenvoegen.
+ *
+ * `aantalBerichten` telt alles wat de bron in die map levert. Wat de bezoeker in deze browser
+ * archiveerde of weggooide telt mee: dat is een weergave hier, het bericht staat bij de organisatie
+ * nog in die map.
+ */
+export function mappenVan(berichten) {
+	const aantallen = new Map();
+	for (const bericht of berichten || []) {
+		const naam = bericht && bericht.map;
+		if (typeof naam !== "string" || naam.trim() === "") continue;
+		aantallen.set(naam, (aantallen.get(naam) || 0) + 1);
+	}
+	return mappenInVorm(Array.from(aantallen, ([naam, aantal]) => ({ naam: naam, aantalBerichten: aantal })));
+}
+
+/** Mappen in de vorm van de render-laag, gesorteerd op naam. */
+function mappenInVorm(mappen) {
+	return mappen.map((map) => ({ slug: map.naam, naam: map.naam, aantalBerichten: map.aantalBerichten })).sort((a, b) => a.naam.localeCompare(b.naam, "nl"));
+}
+
 /** Twee lijsten magazijnen zijn hetzelfde als ze dezelfde ids bevatten. */
 function gelijkeMagazijnen(vorige, nieuwe) {
 	const oud = (vorige || []).map((magazijn) => magazijn.id).sort();
@@ -33,22 +63,31 @@ function gelijkeMagazijnen(vorige, nieuwe) {
  * aangenomen heeft: `getoond`. Die twee lopen uiteen zodra het tonen van een bericht mislukt, en dan
  * hoort dat bericht opnieuw aangeboden te worden — niet als bekend te gelden.
  *
- * Geeft `null` als dit geen aanwas is: er is een bericht verdwenen, of er zijn andere organisaties
- * in beeld. Dan is het een andere lijst en die hoort in één keer op het scherm, niet als een reeks
- * binnenkomers. Een organisatie die erbij komt telt mee: haar naam bereikt de render-laag alleen via
- * een hele lijst, want bij een binnenkomer gaan er geen magazijnen mee.
+ * Geeft `null` als dit geen aanwas is: er is een bericht verdwenen, er zijn andere organisaties in
+ * beeld, of een bericht staat in een andere map. Dan is het een andere lijst en die hoort in één keer
+ * op het scherm, niet als een reeks binnenkomers. Een organisatie die erbij komt telt mee: haar naam
+ * bereikt de render-laag alleen via een hele lijst, want bij een binnenkomer gaan er geen magazijnen
+ * mee. Om dezelfde reden telt een binnenkomer in een map als een andere lijst: het mappenoverzicht
+ * gaat alleen met een hele lijst mee.
  *
  * Een lege uitkomst betekent: precies wat er staat, er valt niets te melden.
  */
 function aanwasVan(getoond, nieuwe) {
 	if (!gelijkeMagazijnen(getoond.magazijnen, nieuwe.magazijnen)) return null;
 
-	const nu = new Set((nieuwe.berichten || []).map((bericht) => bericht.id));
-	for (const id of getoond.ids) {
-		if (!nu.has(id)) return null;
+	const nu = new Map((nieuwe.berichten || []).map((bericht) => [bericht.id, bericht.map || null]));
+	for (const [id, map] of getoond.ids) {
+		if (!nu.has(id) || nu.get(id) !== map) return null;
 	}
 
-	return (nieuwe.berichten || []).filter((bericht) => !getoond.ids.has(bericht.id));
+	const aanwas = (nieuwe.berichten || []).filter((bericht) => !getoond.ids.has(bericht.id));
+	if (aanwas.some((bericht) => bericht.map)) return null;
+	return aanwas;
+}
+
+/** Wat er op het scherm staat, per bericht met zijn map. */
+function getoondeIds(berichten) {
+	return new Map((berichten || []).map((bericht) => [bericht.id, bericht.map || null]));
 }
 
 /** Zoveel keer bieden we dezelfde onbruikbare aanwas opnieuw aan; daarna zeggen we het en houden op. */
@@ -138,10 +177,18 @@ export function ketenBron(keten, { meldStoring = () => {}, verbergMelding = () =
 				}
 			}
 
+			// De mappen die de organisaties tijdens de ronde melden gaan mee in de vorm die de
+			// render-laag van `laad()` kent. Zo groeit het mappenoverzicht terwijl er geleverd wordt,
+			// en hoeft de render-laag niet te weten waar een map vandaan komt.
+			function inVorm(voortgang) {
+				if (!voortgang || !Array.isArray(voortgang.mappen)) return voortgang;
+				return Object.assign({}, voortgang, { mappen: mappenInVorm(voortgang.mappen) });
+			}
+
 			// De eerste melding kan al geweest zijn voordat deze module bestond; het script draait
 			// vóór de module en begint dan meteen op te halen.
-			if (keten.voortgang) meld(keten.voortgang);
-			keten.opWijziging((toestand) => meld(toestand.voortgang));
+			if (keten.voortgang) meld(inVorm(keten.voortgang));
+			keten.opWijziging((toestand) => meld(inVorm(toestand.voortgang)));
 		},
 
 		async laad() {
@@ -158,14 +205,28 @@ export function ketenBron(keten, { meldStoring = () => {}, verbergMelding = () =
 				}
 				throw new Error("het ophalen bij het Federatief Berichtenstelsel is mislukt");
 			}
-			// De keten kent geen mappen; die zijn van de bezoeker en staan in de bewaarde staat.
+			// Geen mappenlijst van het stelsel: een map is een eigenschap van een bericht.
 			return {
 				berichten: uitkomst.berichten,
 				magazijnen: uitkomst.magazijnen,
-				mappen: [],
+				mappen: mappenVan(uitkomst.berichten),
 			};
 		},
 
+		/**
+		 * Haalt een bericht uit zijn map, bij de organisatie die het stuurde. Werpt niet: geeft `{}`
+		 * of `{ fout }`, zoals `inhoudVan`. Lukt het, dan meldt de keten de gewijzigde lijst langs
+		 * dezelfde weg als elke andere wijziging, en verdwijnt een map zonder berichten vanzelf uit het
+		 * overzicht.
+		 */
+		async haalUitMap(berichtId) {
+			if (!keten || typeof keten.haalUitMap !== "function") {
+				console.error("[Berichtenbox] Het keten-script kent geen haalUitMap; het bericht blijft in zijn map.");
+				return { fout: "Wij konden dit bericht niet uit de map halen. Ververs de pagina om het opnieuw te proberen." };
+			}
+			return keten.haalUitMap(berichtId);
+		},
+
 		/**
 		 * De inhoud van één bericht, pas opgehaald als de bezoeker het opent.
 		 *
@@ -200,7 +261,7 @@ export function ketenBron(keten, { meldStoring = () => {}, verbergMelding = () =
 			// Wat er op het scherm staat, en niet wat het transport laatst leverde. Bij het begin is
 			// dat de lijst waarmee de render-laag zojuist geladen heeft.
 			const getoond = {
-				ids: new Set(((uitkomst && uitkomst.berichten) || []).map((bericht) => bericht.id)),
+				ids: getoondeIds(uitkomst && uitkomst.berichten),
 				magazijnen: (uitkomst && uitkomst.magazijnen) || [],
 			};
 
@@ -271,13 +332,13 @@ export function ketenBron(keten, { meldStoring = () => {}, verbergMelding = () =
 				const mislukt = meld({
 					berichten: nieuwe.berichten,
 					magazijnen: nieuwe.magazijnen,
-					mappen: [],
+					mappen: mappenVan(nieuwe.berichten),
 				});
 
 				// Alleen bijhouden wat er ook echt staat: bij een mislukte lijst heeft de render-laag
 				// teruggedraaid naar de vorige weergave.
 				if (!mislukt || !mislukt.length) {
-					getoond.ids = new Set((nieuwe.berichten || []).map((bericht) => bericht.id));
+					getoond.ids = getoondeIds(nieuwe.berichten);
 					getoond.magazijnen = nieuwe.magazijnen || [];
 				}
 				return mislukt;
@@ -297,7 +358,7 @@ export function ketenBron(keten, { meldStoring = () => {}, verbergMelding = () =
 					// Doorgaan zou een lijst opleveren waar er middenin één ontbreekt, en dat is van een
 					// volledige lijst niet te onderscheiden. De rest wacht op de volgende wijziging.
 					if (fouten && fouten.length) return fouten;
-					getoond.ids.add(bericht.id);
+					getoond.ids.set(bericht.id, bericht.map || null);
 				}
 				return [];
 			}
diff --git a/moza/berichtenbox/bericht-demo.html b/moza/berichtenbox/bericht-demo.html
index fd07c123..abb2e4b5 100644
--- a/moza/berichtenbox/bericht-demo.html
+++ b/moza/berichtenbox/bericht-demo.html
@@ -74,6 +74,11 @@ <h2>Bijlage(n)</h2>
 				<!-- <button class="icon-button" data-actie="verplaatsen">
 					{% icon "/assets/icons/icon-gegevens.svg" %}Verplaatsen naar map
 				</button> -->
+				<!-- Alleen voor een bericht in een map, en alleen als de bron het kan: een map hoort bij
+				     het bericht en staat bij de organisatie die het stuurde. berichtenbox.js zet hem aan. -->
+				<button class="icon-button" data-actie="uit-map" hidden>
+					{% icon "/assets/icons/icon-gegevens.svg" %}Haal uit map
+				</button>
 				<button class="icon-button" data-actie="doorsturen">
 					{% icon "/assets/icons/icon-doorsturen.svg" %}Delen
 				</button>
diff --git a/style/style.css b/style/style.css
index cb400826..b789d582 100644
--- a/style/style.css
+++ b/style/style.css
@@ -1618,7 +1618,12 @@ button.is-marked {
 }
 
 .berichtenbox-folder-user {
-	display: none; /* Tijdelijk verbergen */
+	display: none; /* Tijdelijk verbergen: de mappen van de gegenereerde dataset */
+	/* Mappen uit het Federatief Berichtenstelsel wel: die volgen uit de berichten zelf, en wat er
+	   ontbreekt of verdwijnt is daar precies wat er te zien moet zijn. */
+	&[data-map-uit-berichten] {
+		display: revert;
+	}
 	a {
 		color: var(--toepassing-color-text-subtle-2);
 	}
diff --git a/tests/berichtenbox/dom.js b/tests/berichtenbox/dom.js
index f200fe1c..4a06f336 100644
--- a/tests/berichtenbox/dom.js
+++ b/tests/berichtenbox/dom.js
@@ -64,7 +64,18 @@ const STORING = `
 		<div><p data-berichtenbox-storing-tekst></p></div>
 	</div>`;
 
-function paginaHtml(berichten, view, { orgSchakelaar = false } = {}) {
+// De mappen in de tabbalk, zoals `berichtenbox-tabs.njk` ze neerzet: die van de dataset, verborgen
+// tot de render-laag weet welke mappen de bron heeft.
+const MAPPENBALK = `
+	<nav aria-label="Berichtenbox">
+		<ul class="tablist">
+			<li><a href="/moza/berichtenbox/berichtenbox-archief/">Archief</a></li>
+			<li class="list-separation" hidden><span class="visually-hidden">Mappen:</span></li>
+			<li data-map-slug="belastingen-2025" class="berichtenbox-folder-user" hidden><a href="/moza/berichtenbox/?map=belastingen-2025#hoofd-inhoud">Belastingen 2025</a></li>
+		</ul>
+	</nav>`;
+
+function paginaHtml(berichten, view, { orgSchakelaar = false, mappenbalk = false } = {}) {
 	const inbox = view === "inbox";
 	// Leeg en verborgen, net als in de templates: bij het bouwen is niet te weten welke persona er
 	// kijkt, dus staat er geen getal in de HTML. De render-laag vult ze en maakt de regel zichtbaar.
@@ -87,6 +98,7 @@ function paginaHtml(berichten, view, { orgSchakelaar = false } = {}) {
 	{/* Het bolletje uit het menu, dat op élke pagina staat. Zonder dit hier bleef ongetoetst of
 	   het een onthouden getal toont op een pagina die het echte zo berekent. */}
 	<nav class="side-nav"><a href="#">Berichtenbox<span class="badge" data-berichtenbox-count="ongelezen"></span></a></nav>
+${mappenbalk ? MAPPENBALK : ""}
 ${inbox ? MELDINGEN_INBOX : ""}
 ${STORING}
 
@@ -244,9 +256,9 @@ export function dataset(berichten) {
  * voortgangsanimatie van het eerste bezoek de lijst niet vier seconden verborgen houdt; een test
  * die juist dát gedrag wil, zet hem expliciet op false.
  */
-export function bouwPagina(berichten, { pad = "/moza/berichtenbox/", view = "inbox", state = {}, orgSchakelaar = false } = {}) {
+export function bouwPagina(berichten, { pad = "/moza/berichtenbox/", view = "inbox", state = {}, orgSchakelaar = false, mappenbalk = false } = {}) {
 	ruimDocumentListenersOp();
-	document.body.innerHTML = paginaHtml(berichten, view, { orgSchakelaar });
+	document.body.innerHTML = paginaHtml(berichten, view, { orgSchakelaar, mappenbalk });
 	window.history.replaceState(null, "", pad);
 	window.berichtenboxData = dataset(berichten);
 	window.localStorage.clear();
@@ -324,6 +336,10 @@ export function bouwDemoDetailPagina(bericht, { berichten = [bericht] } = {}) {
 				<p class="berichtenbox-attachments-loading" data-berichtenbox-attachments-loading></p>
 				<ul class="list-indent" data-berichtenbox-attachments-list hidden></ul>
 			</section>
+			<div class="action-group action-options">
+				<button class="icon-button" data-actie="markeren" aria-pressed="false"><span data-markeer-label>Markeren</span></button>
+				<button class="icon-button" data-actie="uit-map" hidden>Haal uit map</button>
+			</div>
 		</section>
 		<div class="berichtenbox-empty" data-demo-niet-gevonden hidden>
 			<p>Dit bericht kon niet worden gevonden. Mogelijk is het verwijderd.</p>
diff --git a/tests/berichtenbox/keten-bron.test.js b/tests/berichtenbox/keten-bron.test.js
index 625c5c61..0d56a15d 100644
--- a/tests/berichtenbox/keten-bron.test.js
+++ b/tests/berichtenbox/keten-bron.test.js
@@ -1,5 +1,5 @@
 import { describe, it, expect, vi, afterEach } from "vitest";
-import { ketenBron } from "../../assets/javascript/berichtenbox/keten-bron.js";
+import { ketenBron, mappenVan } from "../../assets/javascript/berichtenbox/keten-bron.js";
 import { maakRegister } from "../../assets/javascript/berichtenbox/bron.js";
 
 /** Een dubbel voor berichtenbox-keten.js: dezelfde vorm, zonder netwerk. */
@@ -456,3 +456,71 @@ describe("ketenBron — dezelfde melding niet twee keer", () => {
 		expect(meldStoring).toHaveBeenCalledTimes(1);
 	});
 });
+
+describe("ketenBron — mappen horen bij het bericht", () => {
+	const IN_MAPPEN = {
+		berichten: [
+			{ id: "a", magazijnId: "kvk", map: "Subsidies" },
+			{ id: "b", magazijnId: "kvk", map: "Boekhouding 2026" },
+			{ id: "c", magazijnId: "kvk", map: "Boekhouding 2026" },
+			{ id: "d", magazijnId: "kvk", map: null },
+		],
+		magazijnen: UITKOMST.magazijnen,
+	};
+
+	it("leidt het overzicht af uit de berichten, met de naam als sleutel", () => {
+		expect(mappenVan(IN_MAPPEN.berichten)).toEqual([
+			{ slug: "Boekhouding 2026", naam: "Boekhouding 2026", aantalBerichten: 2 },
+			{ slug: "Subsidies", naam: "Subsidies", aantalBerichten: 1 },
+		]);
+	});
+
+	it("houdt namen die alleen in hoofdletters verschillen uit elkaar", () => {
+		expect(mappenVan([{ id: "a", map: "Belasting" }, { id: "b", map: "belasting" }]).map((m) => m.naam).sort()).toEqual(["Belasting", "belasting"]);
+	});
+
+	it("levert bij het laden de mappen uit de lijst", async () => {
+		const bron = ketenBron(nepKeten({ bezig: true, uitkomst: IN_MAPPEN }));
+		await bron.geldtVoor();
+
+		expect((await bron.laad()).mappen.map((m) => m.naam)).toEqual(["Boekhouding 2026", "Subsidies"]);
+	});
+
+	it("meldt een bericht dat uit zijn map gehaald is als een andere lijst, niet als niets", async () => {
+		const keten = nepKeten({ bezig: true, uitkomst: IN_MAPPEN });
+		const bron = ketenBron(keten);
+		await bron.geldtVoor();
+		const meld = vi.fn(() => []);
+		bron.start(meld);
+
+		const zonder = { ...IN_MAPPEN, berichten: IN_MAPPEN.berichten.map((b) => (b.id === "a" ? { ...b, map: null } : b)) };
+		keten._meld({ melding: null, uitkomst: zonder });
+
+		expect(meld).toHaveBeenCalledTimes(1);
+		expect(meld.mock.calls[0][0].mappen.map((m) => m.naam)).toEqual(["Boekhouding 2026"]);
+	});
+
+	it("meldt een binnenkomer in een map als een hele lijst, zodat het overzicht meegaat", async () => {
+		const keten = nepKeten({ bezig: true, uitkomst: IN_MAPPEN });
+		const bron = ketenBron(keten, { magDruppelen: () => true });
+		await bron.geldtVoor();
+		const meld = vi.fn(() => []);
+		bron.start(meld);
+
+		keten._meld({ melding: null, uitkomst: { ...IN_MAPPEN, berichten: [{ id: "e", magazijnId: "kvk", map: "Nieuw" }, ...IN_MAPPEN.berichten] } });
+
+		expect(meld.mock.calls[0][0].nieuwBericht).toBeUndefined();
+		expect(meld.mock.calls[0][0].mappen.map((m) => m.naam)).toContain("Nieuw");
+	});
+
+	it("geeft de mappen uit de voortgang door in de vorm van de lijst", () => {
+		const keten = nepKeten({ bezig: true });
+		const bron = ketenBron(keten);
+		const gezien = [];
+		bron.volgVoortgang((v) => gezien.push(v));
+
+		keten._meld({ voortgang: { bevraagd: 2, klaar: 1, gevonden: 3, mappen: [{ naam: "Subsidies", aantalBerichten: 3 }] } });
+
+		expect(gezien[0].mappen).toEqual([{ slug: "Subsidies", naam: "Subsidies", aantalBerichten: 3 }]);
+	});
+});
diff --git a/tests/berichtenbox/keten-harnas.js b/tests/berichtenbox/keten-harnas.js
index 9ea6168f..9e436b9f 100644
--- a/tests/berichtenbox/keten-harnas.js
+++ b/tests/berichtenbox/keten-harnas.js
@@ -122,7 +122,7 @@ export async function startKeten(perAdres, pad = "/moza/berichtenbox/", kvkNumme
 	const aanroepen = [];
 
 	vi.stubGlobal("fetch", async (pad, opties) => {
-		aanroepen.push({ pad, headers: (opties && opties.headers) || {} });
+		aanroepen.push({ pad, headers: (opties && opties.headers) || {}, methode: (opties && opties.method) || "GET", body: opties && opties.body });
 		for (const [patroon, geef] of perAdres) {
 			if (pad.indexOf(patroon) !== -1) return typeof geef === "function" ? geef(pad) : geef;
 		}
diff --git a/tests/berichtenbox/keten-mappen-weergave.test.js b/tests/berichtenbox/keten-mappen-weergave.test.js
new file mode 100644
index 00000000..aba50e88
--- /dev/null
+++ b/tests/berichtenbox/keten-mappen-weergave.test.js
@@ -0,0 +1,266 @@
+// @vitest-environment jsdom
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { bouwPagina, bouwDemoDetailPagina, laadBerichtenbox, laatLaden, rijen } from "./dom.js";
+
+/**
+ * Mappen uit het Federatief Berichtenstelsel op het scherm.
+ *
+ * Een map is daar een eigenschap van een bericht, dus het overzicht in de tabbalk volgt de berichten:
+ * het groeit mee terwijl organisaties leveren, en een map zonder berichten verdwijnt. De mappen van
+ * de gegenereerde dataset, die het sjabloon neerzet, horen daar niet tussen.
+ */
+
+function ketenBericht(id, map, extra = {}) {
+	return { id, magazijnId: "00000001823288444000", afzender: "Belastingdienst", onderwerp: "Onderwerp " + id, datum: "2026-09-21", isOngelezen: false, map, inhoud: "", uitKeten: true, ...extra };
+}
+
+const UITKOMST = {
+	berichten: [ketenBericht("r1", "Subsidies", { magazijnId: "rvo", afzender: "RVO" }), ketenBericht("b1", "Boekhouding 2026"), ketenBericht("r2", "Boekhouding 2026", { magazijnId: "rvo", afzender: "RVO" }), ketenBericht("b2", "Te bespreken met adviseur"), ketenBericht("b3", null)],
+	magazijnen: [
+		{ id: "rvo", naam: "RVO", type: "instantie" },
+		{ id: "00000001823288444000", naam: "Belastingdienst", type: "instantie" },
+	],
+};
+
+/** Een dubbel voor berichtenbox-keten.js. */
+function zetKeten({ uitkomst, haalUitMap = vi.fn(async () => ({})) } = {}) {
+	const kijkers = [];
+	let losmaken;
+	const wachten = new Promise((klaar) => {
+		losmaken = klaar;
+	});
+	const keten = {
+		bezig: true,
+		aangesloten: true,
+		melding: null,
+		voortgang: null,
+		huidigeUitkomst: null,
+		berichten: () => (uitkomst === undefined ? wachten : Promise.resolve(uitkomst)),
+		opWijziging: (kijker) => kijkers.push(kijker),
+		meldVerwerkingsfout: vi.fn(),
+		stopPollen: vi.fn(),
+		haalUitMap,
+	};
+	window.BerichtenboxKeten = keten;
+	return {
+		keten,
+		meld(toestand) {
+			if ("voortgang" in toestand) keten.voortgang = toestand.voortgang;
+			kijkers.forEach((k) => k({ melding: null, voortgang: null, uitkomst: null, ...toestand }));
+		},
+		klaar(u) {
+			losmaken(u);
+		},
+	};
+}
+
+// Zoals een schermlezer het hoort: "Subsidies (3 berichten)".
+const mappenInBalk = () => [...document.querySelectorAll(".tablist .berichtenbox-folder-user")].filter((li) => !li.hidden).map((li) => li.textContent.replace(/\s+/g, " ").trim());
+const scheiding = () => document.querySelector(".tablist .list-separation");
+
+beforeEach(() => {
+	vi.spyOn(console, "error").mockImplementation(() => {});
+	vi.spyOn(console, "warn").mockImplementation(() => {});
+});
+
+afterEach(() => {
+	delete window.BerichtenboxKeten;
+	vi.restoreAllMocks();
+});
+
+describe("het mappenoverzicht in de tabbalk", () => {
+	it("toont geen mappen van de dataset zolang niet bekend is welke mappen de bron heeft", async () => {
+		bouwPagina([], { mappenbalk: true });
+		zetKeten({}); // de ronde loopt nog
+
+		await laadBerichtenbox();
+		await laatLaden();
+
+		expect(mappenInBalk()).toEqual([]);
+		expect(scheiding().hidden).toBe(true);
+	});
+
+	it("groeit mee met wat de organisaties tijdens de ronde melden", async () => {
+		bouwPagina([], { mappenbalk: true });
+		const keten = zetKeten({});
+		await laadBerichtenbox();
+		await laatLaden();
+
+		keten.meld({
+			voortgang: {
+				bevraagd: 2,
+				klaar: 1,
+				gevonden: 5,
+				mappen: [
+					{ naam: "Boekhouding 2026", aantalBerichten: 1 },
+					{ naam: "Subsidies", aantalBerichten: 3 },
+				],
+			},
+		});
+		expect(mappenInBalk()).toEqual(["Boekhouding 2026 (1 bericht)", "Subsidies (3 berichten)"]);
+		expect(scheiding().hidden).toBe(false);
+
+		keten.meld({
+			voortgang: {
+				bevraagd: 2,
+				klaar: 2,
+				gevonden: 10,
+				mappen: [
+					{ naam: "Belasting", aantalBerichten: 3 },
+					{ naam: "Boekhouding 2026", aantalBerichten: 2 },
+					{ naam: "Subsidies", aantalBerichten: 3 },
+					{ naam: "Te bespreken met adviseur", aantalBerichten: 1 },
+				],
+			},
+		});
+		expect(mappenInBalk()).toEqual(["Belasting (3 berichten)", "Boekhouding 2026 (2 berichten)", "Subsidies (3 berichten)", "Te bespreken met adviseur (1 bericht)"]);
+	});
+
+	it("neemt na afloop de mappen uit de lijst, en laat die van de dataset weg", async () => {
+		bouwPagina([], { mappenbalk: true });
+		zetKeten({ uitkomst: UITKOMST });
+
+		await laadBerichtenbox();
+		await laatLaden();
+
+		expect(mappenInBalk()).toEqual(["Boekhouding 2026 (2 berichten)", "Subsidies (1 bericht)", "Te bespreken met adviseur (1 bericht)"]);
+		expect(document.querySelector('[data-map-slug="belastingen-2025"]')).toBeNull();
+	});
+
+	it("laat een map verdwijnen met zijn laatste bericht", async () => {
+		bouwPagina([], { mappenbalk: true });
+		const keten = zetKeten({ uitkomst: UITKOMST });
+		await laadBerichtenbox();
+		await laatLaden();
+
+		const zonder = { ...UITKOMST, berichten: UITKOMST.berichten.map((b) => (b.id === "b2" ? { ...b, map: null } : b)) };
+		keten.meld({ uitkomst: zonder });
+
+		expect(mappenInBalk()).toEqual(["Boekhouding 2026 (2 berichten)", "Subsidies (1 bericht)"]);
+	});
+
+	it("verbergt het kopje Mappen als er geen enkele map is", async () => {
+		bouwPagina([], { mappenbalk: true });
+		zetKeten({ uitkomst: { ...UITKOMST, berichten: [ketenBericht("b3", null)] } });
+
+		await laadBerichtenbox();
+		await laatLaden();
+
+		expect(mappenInBalk()).toEqual([]);
+		expect(scheiding().hidden).toBe(true);
+	});
+
+	it("filtert de inbox op een map met een naam zoals de organisatie die schreef", async () => {
+		bouwPagina([], { mappenbalk: true, pad: "/moza/berichtenbox/?map=" + encodeURIComponent("Boekhouding 2026") });
+		zetKeten({ uitkomst: UITKOMST });
+
+		await laadBerichtenbox();
+		await laatLaden();
+
+		expect(
+			rijen()
+				.map((r) => r.dataset.berichtId)
+				.sort()
+		).toEqual(["b1", "r2"]);
+		const actief = document.querySelector('.tablist [aria-current="page"]');
+		expect(actief && actief.textContent).toContain("Boekhouding 2026");
+	});
+
+	it("struikelt niet over een aanhalingsteken in de naam van een map", async () => {
+		// Namen komen woordelijk van de organisatie. Ongeëscaped in een selector breekt de hele weergave.
+		const naam = 'Project "Noord" \\ 2026';
+		bouwPagina([], { mappenbalk: true, pad: "/moza/berichtenbox/?map=" + encodeURIComponent(naam) });
+		zetKeten({ uitkomst: { ...UITKOMST, berichten: [ketenBericht("q1", naam), ketenBericht("b3", null)] } });
+
+		await laadBerichtenbox();
+		await laatLaden();
+
+		expect(mappenInBalk()).toEqual([naam + " (1 bericht)"]);
+		expect(rijen().map((r) => r.dataset.berichtId)).toEqual(["q1"]);
+		expect(document.querySelector("[data-berichtenbox-storing]").hidden).toBe(true);
+	});
+
+	it("laat het overzicht met rust tijdens een latere ronde, want dan is de lijst de bron", async () => {
+		// Een herstelronde na een verlopen sessie meldt opnieuw voortgang. Die tussenstand zou mappen
+		// die nog niet gemeld zijn even weghalen, met de focus en de actieve map erbij.
+		bouwPagina([], { mappenbalk: true });
+		const keten = zetKeten({ uitkomst: UITKOMST });
+		await laadBerichtenbox();
+		await laatLaden();
+
+		keten.meld({ voortgang: { bevraagd: 2, klaar: 1, gevonden: 1, mappen: [{ naam: "Subsidies", aantalBerichten: 1 }] } });
+
+		expect(mappenInBalk()).toEqual(["Boekhouding 2026 (2 berichten)", "Subsidies (1 bericht)", "Te bespreken met adviseur (1 bericht)"]);
+	});
+
+	it("toont de mappen van de dataset gewoon voor een persona zonder stelsel", async () => {
+		bouwPagina([{ id: "d1", magazijnId: "rvo", afzender: "RVO", onderwerp: "x", datum: "2026-01-01", isOngelezen: false, map: "belastingen-2025", inhoud: "x" }], { mappenbalk: true });
+
+		await laadBerichtenbox();
+		await laatLaden();
+
+		expect(mappenInBalk()).toEqual(["Belastingen 2025"]);
+		expect(scheiding().hidden).toBe(false);
+	});
+});
+
+describe("een bericht uit zijn map halen op de detailpagina", () => {
+	const knop = () => document.querySelector('[data-actie="uit-map"]');
+
+	it("biedt de knop alleen aan voor een bericht in een map", async () => {
+		bouwDemoDetailPagina(ketenBericht("b3", null));
+		zetKeten({ uitkomst: { ...UITKOMST, berichten: [ketenBericht("b3", null)] } });
+
+		await laadBerichtenbox();
+		await laatLaden();
+
+		expect(knop().hidden).toBe(true);
+	});
+
+	it("haalt het bericht uit zijn map en laat zien dat het weer in de inbox staat", async () => {
+		const bericht = ketenBericht("b2", "Te bespreken met adviseur");
+		bouwDemoDetailPagina(bericht);
+		document.querySelector("[data-demo-detail]").insertAdjacentHTML("beforebegin", '<nav><ol><li data-berichtenbox-map-kruimel><a href="/moza/berichtenbox/">Inbox</a></li></ol></nav>');
+		const uitkomst = { ...UITKOMST, berichten: [bericht] };
+		const keten = zetKeten({ uitkomst });
+		keten.keten.haalUitMap = vi.fn(async () => {
+			// Zoals het transport: de lijst is meteen bijgewerkt, vóór het antwoord terugkomt.
+			keten.meld({ uitkomst: { ...uitkomst, berichten: [{ ...bericht, map: null }] } });
+			return {};
+		});
+
+		await laadBerichtenbox();
+		await laatLaden();
+
+		expect(knop().hidden).toBe(false);
+		expect(document.querySelector("[data-demo-meta]").textContent).toContain("Te bespreken met adviseur");
+		expect(document.querySelector("[data-berichtenbox-map-kruimel] a").textContent).toBe("Te bespreken met adviseur");
+
+		knop().click();
+		await laatLaden();
+
+		expect(keten.keten.haalUitMap).toHaveBeenCalledWith("b2");
+		expect(knop().hidden).toBe(true);
+		expect(document.querySelector("[data-demo-meta]").textContent).not.toContain("Te bespreken met adviseur");
+		expect(document.querySelector("[data-berichtenbox-map-kruimel] a").textContent).toBe("Inbox");
+		expect(document.querySelector("[data-demo-inhoud-status]").textContent).toContain("inbox");
+		expect(document.activeElement).toBe(document.querySelector('[data-actie="markeren"]'));
+	});
+
+	it("laat de knop staan en zegt wat er misging als het stelsel weigert", async () => {
+		const bericht = ketenBericht("b2", "Te bespreken met adviseur");
+		bouwDemoDetailPagina(bericht);
+		const keten = zetKeten({ uitkomst: { ...UITKOMST, berichten: [bericht] } });
+		keten.keten.haalUitMap = vi.fn(async () => ({ fout: "Wij konden dit bericht niet uit de map halen. Het staat nog in de map. Probeer het opnieuw." }));
+
+		await laadBerichtenbox();
+		await laatLaden();
+		knop().click();
+		await laatLaden();
+
+		expect(knop().hidden).toBe(false);
+		expect(knop().getAttribute("aria-disabled")).toBeNull();
+		expect(document.querySelector("[data-berichtenbox-storing-tekst]").textContent).toContain("niet uit de map halen");
+		expect(document.querySelector("[data-demo-meta]").textContent).toContain("Te bespreken met adviseur");
+	});
+});
diff --git a/tests/berichtenbox/keten-mappen.test.js b/tests/berichtenbox/keten-mappen.test.js
new file mode 100644
index 00000000..d3c06a35
--- /dev/null
+++ b/tests/berichtenbox/keten-mappen.test.js
@@ -0,0 +1,338 @@
+// @vitest-environment jsdom
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { antwoord, personasVoor, rondeMetLijst, sseVan, startKeten, ruimKetenOp } from "./keten-harnas.js";
+
+/**
+ * Mappen in het Federatief Berichtenstelsel, aan de kant van het transport.
+ *
+ * Een map is daar geen ding op zich maar een eigenschap van een bericht, opgeslagen bij de
+ * organisatie die het stuurde. Drie dingen volgen daaruit, en die toetst dit bestand:
+ *
+ * - Tijdens de ophaalronde is de lijst niet op te vragen, dus het mappenoverzicht komt dan uit de
+ *   gebeurtenissen per organisatie, opgeteld terwijl ze binnenkomen.
+ * - Levert een organisatie niet, dan kunnen haar mappen en berichten ontbreken. De lijst zegt dat
+ *   (`aantalNietGeleverd`, `nietGeleverd`) op elke pagina en ook na verversen, en de melding volgt.
+ * - Een bericht uit zijn map halen gaat naar het stelsel, met `{"map": ""}`.
+ */
+
+const RVO = "00000001003214345000";
+const BD = "00000001823288444000";
+
+let bezoeker = 90000200;
+
+/** Een eigen kvk-nummer per test: elk vorig exemplaar van het script blijft in het document bestaan. */
+async function start(perAdres, pad) {
+	bezoeker += 1;
+	const kvkNummer = String(bezoeker);
+	const gestart = await startKeten([["/api/demo/personas", personasVoor(kvkNummer)], ...perAdres], pad, kvkNummer);
+	return { ...gestart, ontvanger: "KVK:" + kvkNummer };
+}
+
+function bericht(id, magazijnId, map) {
+	return { berichtId: id, onderwerp: "Onderwerp " + id, publicatietijdstip: "2026-09-21T10:00:00Z", magazijnId: magazijnId, afzenderNaam: magazijnId === RVO ? "RVO" : "Belastingdienst", map: map };
+}
+
+const BERICHTEN = [bericht("r1", RVO, "Subsidies"), bericht("r2", RVO, "Boekhouding 2026"), bericht("b1", BD, "Boekhouding 2026"), bericht("b2", BD, "Te bespreken met adviseur"), bericht("b3", BD, null)];
+
+function lijstMet(extra, berichten = BERICHTEN) {
+	return antwoord(200, { berichten: berichten, _links: {}, ...extra });
+}
+
+function voltooid(magazijnId, naam, status, mappen) {
+	const gebeurtenis = { event: "magazijn-bevraging-voltooid", magazijnId: magazijnId, naam: naam, status: status, aantalBerichten: 0, afgekapt: false };
+	if (mappen) gebeurtenis.mappen = mappen;
+	return gebeurtenis;
+}
+
+/**
+ * Hangt een kijker aan het script zodra het zich op `window` zet. Het script begint bij het laden
+ * meteen aan de ronde; wie pas daarna kijkt, heeft de voortgang gemist.
+ */
+function kijkVanafStart(kijker) {
+	Object.defineProperty(window, "BerichtenboxKeten", {
+		configurable: true,
+		get: () => undefined,
+		set: (keten) => {
+			keten.opWijziging(kijker);
+			Object.defineProperty(window, "BerichtenboxKeten", { configurable: true, writable: true, value: keten });
+		},
+	});
+}
+
+beforeEach(() => {
+	vi.spyOn(console, "error").mockImplementation(() => {});
+	vi.spyOn(console, "warn").mockImplementation(() => {});
+	vi.spyOn(console, "info").mockImplementation(() => {});
+});
+
+afterEach(() => {
+	window.dispatchEvent(new Event("pagehide"));
+	ruimKetenOp();
+	vi.useRealTimers();
+	vi.restoreAllMocks();
+	vi.unstubAllGlobals();
+});
+
+describe("het mappenoverzicht tijdens de ophaalronde", () => {
+	it("telt de mappen per organisatie op terwijl ze leveren", async () => {
+		const gezien = [];
+		const stroom = () =>
+			sseVan([
+				voltooid(RVO, "RVO", "OK", [
+					{ naam: "Boekhouding 2026", aantalBerichten: 1 },
+					{ naam: "Subsidies", aantalBerichten: 3 },
+				]),
+				voltooid(BD, "Belastingdienst", "OK", [
+					{ naam: "Belasting", aantalBerichten: 3 },
+					{ naam: "Boekhouding 2026", aantalBerichten: 1 },
+					{ naam: "Te bespreken met adviseur", aantalBerichten: 1 },
+				]),
+				{ event: "ophalen-gereed" },
+			]);
+
+		kijkVanafStart((toestand) => toestand.voortgang && gezien.push(toestand.voortgang.mappen));
+
+		await start(rondeMetLijst(lijstMet({ aantalNietGeleverd: 0, nietGeleverd: [] }), stroom));
+
+		expect(gezien[0]).toEqual([
+			{ naam: "Boekhouding 2026", aantalBerichten: 1 },
+			{ naam: "Subsidies", aantalBerichten: 3 },
+		]);
+		expect(gezien[1]).toEqual([
+			{ naam: "Belasting", aantalBerichten: 3 },
+			{ naam: "Boekhouding 2026", aantalBerichten: 2 },
+			{ naam: "Subsidies", aantalBerichten: 3 },
+			{ naam: "Te bespreken met adviseur", aantalBerichten: 1 },
+		]);
+	});
+
+	it("zegt niets over mappen als het stelsel ze niet meestuurt", async () => {
+		// Een keten van vóór dit veld. Een lege lijst zou beweren dat er geen mappen zijn.
+		const gezien = [];
+		kijkVanafStart((toestand) => toestand.voortgang && gezien.push(toestand.voortgang));
+
+		await start(rondeMetLijst(lijstMet({}), () => sseVan([voltooid(RVO, "RVO", "OK"), { event: "ophalen-gereed" }])));
+
+		expect(gezien.length).toBeGreaterThan(0);
+		gezien.forEach((voortgang) => expect("mappen" in voortgang).toBe(false));
+	});
+
+	it("neemt geen mappen mee van een organisatie die niet leverde", async () => {
+		const gezien = [];
+		kijkVanafStart((toestand) => toestand.voortgang && gezien.push(toestand.voortgang.mappen));
+
+		await start(rondeMetLijst(lijstMet({}), () => sseVan([voltooid(RVO, "RVO", "OK", [{ naam: "Subsidies", aantalBerichten: 3 }]), voltooid(BD, "Belastingdienst", "FOUT", [{ naam: "Belasting", aantalBerichten: 3 }]), { event: "ophalen-gereed" }])));
+
+		expect(gezien[gezien.length - 1]).toEqual([{ naam: "Subsidies", aantalBerichten: 3 }]);
+	});
+});
+
+describe("een organisatie die niet leverde", () => {
+	it("staat in de melding, met haar naam", async () => {
+		await start(rondeMetLijst(lijstMet({ aantalNietGeleverd: 1, nietGeleverd: [{ magazijnId: BD, naam: "Belastingdienst", status: "FOUT" }] })));
+
+		const melding = window.BerichtenboxKeten.melding;
+		expect(melding.soort).toBe("mededeling");
+		expect(melding.tekst).toContain("Belastingdienst");
+		expect(melding.tekst).toContain("mappen");
+	});
+
+	it("blijft gemeld na verversen, als de lijst uit de sessie komt en er geen ronde draait", async () => {
+		// Verversen draait geen ronde: de sessie staat er nog, en de lijst antwoordt meteen. Wie er
+		// niet leverde, weet dan alleen de lijst.
+		const { aanroepen } = await start([["/api/v1/berichten?", lijstMet({ aantalNietGeleverd: 1, nietGeleverd: [{ magazijnId: BD, naam: "Belastingdienst", status: "TIMEOUT" }] })]]);
+
+		expect(aanroepen.some((a) => a.pad.indexOf("_ophalen") !== -1)).toBe(false);
+		expect(window.BerichtenboxKeten.melding.tekst).toContain("Belastingdienst");
+	});
+
+	it("blijft gemeld bij doorbladeren naar een volgende pagina van de berichtenbox", async () => {
+		// Een andere pagina van de berichtenbox is een nieuwe paginalading met dezelfde sessie.
+		await start([["/api/v1/berichten?", lijstMet({ aantalNietGeleverd: 1, nietGeleverd: [{ magazijnId: BD, naam: "Belastingdienst", status: "FOUT" }] })]], "/moza/berichtenbox/?pagina=2");
+
+		expect(window.BerichtenboxKeten.melding.tekst).toContain("Belastingdienst");
+	});
+
+	it("leest het ook als het stelsel de lijst over meer pagina's verdeelt", async () => {
+		const paginas = [BERICHTEN.slice(0, 3), BERICHTEN.slice(3)];
+		const lijst = (pad) => {
+			const nummer = Number(new URLSearchParams(pad.slice(pad.indexOf("?"))).get("pagina"));
+			const laatste = nummer >= paginas.length - 1;
+			return antwoord(200, {
+				berichten: paginas[nummer] || [],
+				aantalNietGeleverd: 1,
+				nietGeleverd: [{ magazijnId: BD, naam: "Belastingdienst", status: "FOUT" }],
+				_links: laatste ? {} : { next: { href: "/api/v1/berichten?pagina=" + (nummer + 1) } },
+			});
+		};
+		await start([["/api/v1/berichten?", lijst]]);
+
+		expect((await window.BerichtenboxKeten.berichten()).berichten).toHaveLength(5);
+		expect(window.BerichtenboxKeten.melding.tekst).toContain("Belastingdienst");
+	});
+
+	it("meldt het zonder namen als het stelsel alleen het aantal kent", async () => {
+		// Een sessie die over een uitrol heen loopt. Volledig is aantalNietGeleverd == 0, niet een lege lijst.
+		await start([["/api/v1/berichten?", lijstMet({ aantalNietGeleverd: 1, nietGeleverd: [] })]]);
+
+		const melding = window.BerichtenboxKeten.melding;
+		expect(melding).not.toBeNull();
+		expect(melding.tekst).toMatch(/^Eén organisatie heeft uw berichten niet geleverd/);
+	});
+
+	it("noemt wie het kent en telt de rest", async () => {
+		await start([["/api/v1/berichten?", lijstMet({ aantalNietGeleverd: 3, nietGeleverd: [{ magazijnId: BD, naam: "Belastingdienst", status: "FOUT" }] })]]);
+
+		expect(window.BerichtenboxKeten.melding.tekst).toMatch(/^Belastingdienst en nog 2 organisaties hebben/);
+	});
+
+	it("breekt niet op een status die het niet kent, en leest die als niet geleverd", async () => {
+		await start([["/api/v1/berichten?", lijstMet({ aantalNietGeleverd: 1, nietGeleverd: [{ magazijnId: BD, naam: "Belastingdienst", status: "ONBEKEND_NIEUW" }] })]]);
+
+		const uitkomst = await window.BerichtenboxKeten.berichten();
+		expect(uitkomst.berichten).toHaveLength(5);
+		expect(window.BerichtenboxKeten.melding.tekst).toContain("Belastingdienst");
+	});
+
+	it("meldt niets als iedereen leverde", async () => {
+		await start([["/api/v1/berichten?", lijstMet({ aantalNietGeleverd: 0, nietGeleverd: [] })]]);
+
+		expect(window.BerichtenboxKeten.melding).toBeNull();
+	});
+
+	it("gaat voor op wat de ronde zag, want de lijst is wat blijft", async () => {
+		const stroom = () => sseVan([voltooid(RVO, "RVO", "OK", []), voltooid(BD, "Belastingdienst", "FOUT"), { event: "ophalen-gereed" }]);
+		await start(rondeMetLijst(lijstMet({ aantalNietGeleverd: 1, nietGeleverd: [{ magazijnId: BD, naam: "Belastingdienst", status: "FOUT" }] }), stroom));
+
+		expect(window.BerichtenboxKeten.melding.tekst).toMatch(/^Belastingdienst heeft uw berichten niet geleverd/);
+	});
+
+	it("verdwijnt zodra het aantal nul is, en komt terug als het weer oploopt", async () => {
+		vi.useFakeTimers();
+		const antwoorden = [
+			{ aantalNietGeleverd: 1, nietGeleverd: [{ magazijnId: BD, naam: "Belastingdienst", status: "FOUT" }] },
+			{ aantalNietGeleverd: 0, nietGeleverd: [] },
+			{ aantalNietGeleverd: 1, nietGeleverd: [] },
+		];
+		let tik = 0;
+		await start([["/api/v1/berichten?", () => lijstMet(antwoorden[Math.min(tik++, antwoorden.length - 1)])]]);
+		expect(window.BerichtenboxKeten.melding).not.toBeNull();
+
+		await vi.advanceTimersByTimeAsync(15000);
+		expect(window.BerichtenboxKeten.melding).toBeNull();
+
+		await vi.advanceTimersByTimeAsync(15000);
+		expect(window.BerichtenboxKeten.melding.tekst).toMatch(/^Eén organisatie/);
+	});
+});
+
+describe("een bericht uit zijn map halen", () => {
+	it("stuurt een merge-patch met een lege map naar de organisatie van het bericht", async () => {
+		const { aanroepen, ontvanger } = await start([
+			["/api/v1/berichten?", lijstMet({ aantalNietGeleverd: 0, nietGeleverd: [] })],
+			["?magazijnId=", antwoord(200, {})],
+		]);
+
+		const uitkomst = await window.BerichtenboxKeten.haalUitMap("b2");
+
+		expect(uitkomst).toEqual({});
+		const patch = aanroepen.find((a) => a.methode === "PATCH");
+		expect(patch.pad).toBe("/api/v1/berichten/b2?magazijnId=" + BD);
+		expect(patch.headers["X-Ontvanger"]).toBe(ontvanger);
+		expect(patch.headers["Content-Type"]).toBe("application/merge-patch+json");
+		// Niet `null`: in een merge-patch is dat "niet wijzigen".
+		expect(JSON.parse(patch.body)).toEqual({ map: "" });
+	});
+
+	it("zet het bericht meteen zonder map in de lijst, zodat de map met zijn laatste bericht verdwijnt", async () => {
+		await start([
+			["/api/v1/berichten?", lijstMet({})],
+			["?magazijnId=", antwoord(200, {})],
+		]);
+		const gemeld = [];
+		window.BerichtenboxKeten.opWijziging((toestand) => gemeld.push(toestand.uitkomst));
+
+		await window.BerichtenboxKeten.haalUitMap("b2");
+
+		const laatste = gemeld[gemeld.length - 1];
+		expect(laatste.berichten.find((b) => b.id === "b2").map).toBeNull();
+		expect(laatste.berichten.some((b) => b.map === "Te bespreken met adviseur")).toBe(false);
+	});
+
+	it("laat het bericht in zijn map en zegt dat, als het stelsel weigert", async () => {
+		await start([
+			["/api/v1/berichten?", lijstMet({})],
+			["?magazijnId=", antwoord(400, { title: "Bad Request" }, "application/problem+json")],
+		]);
+
+		const uitkomst = await window.BerichtenboxKeten.haalUitMap("b2");
+
+		expect(uitkomst.fout).toMatch(/niet uit de map halen/);
+		expect(window.BerichtenboxKeten.huidigeUitkomst.berichten.find((b) => b.id === "b2").map).toBe("Te bespreken met adviseur");
+	});
+
+	it("vraagt niets als het bericht niet in een map staat", async () => {
+		const { aanroepen } = await start([["/api/v1/berichten?", lijstMet({})]]);
+
+		expect(await window.BerichtenboxKeten.haalUitMap("b3")).toEqual({});
+		expect(aanroepen.some((a) => a.methode === "PATCH")).toBe(false);
+	});
+
+	it("laat een tik die de lijst van vóór de wijziging ophaalde het bericht niet terugzetten", async () => {
+		vi.useFakeTimers();
+		let losmaken;
+		let tik = 0;
+		await start([
+			[
+				"/api/v1/berichten?",
+				() => {
+					if (tik++ === 0) return lijstMet({});
+					// De tik vraagt de lijst op vóór de PATCH, en het antwoord komt erna binnen.
+					return new Promise((klaar) => {
+						losmaken = () => klaar(lijstMet({}));
+					});
+				},
+			],
+			["?magazijnId=", antwoord(200, {})],
+		]);
+
+		await vi.advanceTimersByTimeAsync(15000);
+		expect(losmaken).toBeTypeOf("function");
+		await window.BerichtenboxKeten.haalUitMap("b2");
+		losmaken();
+		await vi.advanceTimersByTimeAsync(0);
+
+		expect(window.BerichtenboxKeten.huidigeUitkomst.berichten.find((b) => b.id === "b2").map).toBeNull();
+	});
+
+	it("zegt niet dat het bericht nog in de map staat als het antwoord te lang uitbleef", async () => {
+		await start([
+			["/api/v1/berichten?", lijstMet({})],
+			[
+				"?magazijnId=",
+				() => {
+					throw new DOMException("te laat", "TimeoutError");
+				},
+			],
+		]);
+
+		const uitkomst = await window.BerichtenboxKeten.haalUitMap("b2");
+
+		expect(uitkomst.fout).toMatch(/weten niet of het gelukt is/);
+	});
+
+	it("ziet een map die elders verdween bij de volgende tik", async () => {
+		// Een ander tabblad, of de organisatie zelf. Dezelfde berichten in een andere map zijn een wijziging.
+		vi.useFakeTimers();
+		const zonderMap = BERICHTEN.map((b) => (b.berichtId === "b2" ? { ...b, map: "" } : b));
+		let tik = 0;
+		await start([["/api/v1/berichten?", () => lijstMet({}, tik++ === 0 ? BERICHTEN : zonderMap)]]);
+		const gemeld = [];
+		window.BerichtenboxKeten.opWijziging((toestand) => gemeld.push(toestand.uitkomst));
+
+		await vi.advanceTimersByTimeAsync(15000);
+
+		expect(gemeld.length).toBeGreaterThan(0);
+		expect(gemeld[gemeld.length - 1].berichten.find((b) => b.id === "b2").map).toBeNull();
+	});
+});