bugfix

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

.env.example

@@ -17,6 +17,9 @@ CORS_ORIGIN=http://localhost:3400
 
 # Update-notificaties (leeg = melding uit)
 UPDATE_CHECK_URL=https://vibehoogie.duckdns.org/api/v1/repos/vibe/VibeFinance/releases/latest
-# Nodig zolang de Gitea-repo niet publiek leesbaar is; scope read:repository.
-# Zonder token geeft releases/latest 404 en blijft de update-melding leeg.
+# De Gitea-organisatie is publiek, dus de check werkt anoniem — laat dit staan.
+# Alleen nodig als de organisatie weer privé wordt; scope read:repository.
+# Dan geeft releases/latest zonder token 404 en blijft de melding leeg.
+# Let op: een ongeldig token geeft 401, ook op een publieke repo. Bij twijfel
+# de regel uitgecommentarieerd laten in plaats van een token te gokken.
 # UPDATE_CHECK_TOKEN=

BEHEER.md

@@ -32,6 +32,25 @@ Vite proxyt `/api` naar `localhost:3001` binnen dezelfde container.
 > ⚠️ Alleen `.\dev.ps1 down` wist de development-database (`docker compose down -v`).
 > `.\dev.ps1 up` doet een gewone `down` en laat het volume staan.
 
+### Welke versie de dev-app toont
+
+De versie in "Over VibeFinance" komt uit `VITE_APP_VERSION`. `dev.ps1` leest die
+uit de **root** `package.json`, zet hem in de omgeving en synct hem naar
+`frontend/package.json`. In de dev-container is het een *runtime*-variabele
+(`docker-compose.dev.yml`, sectie `environment`) en geen build-arg: Vite bakt
+`__APP_VERSION__` in bij het **starten** van de dev-server, niet bij het bouwen
+van het image. Is hij leeg, dan valt `vite.config.js` terug op
+`frontend/package.json`.
+
+Ziet de app een oude versie, dan draait de dev-server nog van vóór de bump —
+`.\dev.ps1 up` hercreëert de container en start Vite opnieuw. Start je de stack
+handmatig met `docker compose -f docker-compose.dev.yml up`, dan staat
+`VITE_APP_VERSION` niet in je shell en zie je de versie uit
+`frontend/package.json`.
+
+> Een versie met een suffix (`1.0.1-dev`) onderdrukt de update-melding
+> permanent — zie [Update-notificaties](#update-notificaties).
+
 ---
 
 ## Testen
@@ -77,66 +96,121 @@ docker compose -f docker-compose.dev.yml exec -w /app/frontend app npm run lint
 
 ## Tokens
 
-Twee tokens, gesplitst op machine en op read/write. De grens die iets betekent
-ligt tussen werkstation en server, niet tussen push en release: op één machine
-kan wie het ene token kan lezen, het andere ook.
+**Eén token, op het werkstation.** Dat is genoeg omdat de `Vibe`-organisatie op
+public staat: alles wat alleen *leest* heeft geen token meer nodig — `git clone`,
+`docker compose pull` en de update-check van de app werken anoniem. Wat overblijft
+is schrijven, en dat gebeurt allemaal vanaf deze ene machine.
 
 | Token | Machine | Scopes | Gebruikt voor |
 |---|---|---|---|
-| `vibefinance-workstation` | dit werkstation | `write:package`, `write:repository` | `docker push` (`release.ps1`, `dev.ps1 push`) en het aanmaken van de Gitea-release |
-| `vibefinance-host` | de Docker-host | `read:package`, `read:repository` | `docker compose pull` en de update-check van de app |
+| `vibefinance-workstation` | dit werkstation | `write:package`, `write:repository` | `docker push` (`release.ps1`, `dev.ps1 push`) én het aanmaken van de Gitea-release |
 
-Aanmaken: Gitea → Settings → Applications → Generate New Token. Doe dat onder een
-account dat lid is van de `Vibe`-organisatie — die is privé, dus een token van
-een buitenstaander ziet de repo niet.
+Er is geen apart host-token en geen apart registry-token:
 
-**Waar ze terechtkomen**
+- **`git push`** gaat over SSH (`gitea@…:Vibe/VibeFinance.git`), dus die gebruikt
+  je SSH-sleutel en niet dit token. Werkt SSH even niet — bijvoorbeeld omdat de
+  ssh-agent niet meedoet in een niet-interactieve shell, wat `Permission denied
+  (publickey,password)` geeft — dan kun je *lezen* nu anoniem over https, omdat
+  de organisatie public is:
 
-| | Werkstation | Docker-host |
-|---|---|---|
-| Registry | `docker login` (credential store), of `REGISTRY_USER` + `REGISTRY_TOKEN` in `.env.release` | `docker login` als de gebruiker die deployt |
-| Gitea-API | `GITEA_TOKEN` in `.env.release` | `UPDATE_CHECK_TOKEN` in `.env` |
+  ```powershell
+  git fetch https://vibehoogie.duckdns.org/Vibe/VibeFinance.git --prune --tags "+refs/heads/*:refs/remotes/origin/*"
+  ```
 
-**Waarom het host-token read-only blijft.** Dat staat in platte tekst in `.env` op
-een server die de app op poort 3400 publiceert. Met schrijfrechten kan wie bij dat
-bestand komt — via de container, een shell op die host, of een backup — een eigen
-image als `latest` naar de registry pushen, en die host pullt `latest` zelf.
-Read-only houdt je eigen deploy-pad uit de aanvalsketen.
+  Die refspec werkt ook `origin/*` bij, dus daarna doen `git merge --ff-only
+  origin/main` en `git log origin/main` het weer. Pushen blijft SSH; `release.ps1`
+  leest daarvoor `core.sshCommand` uit, omdat op Windows alleen de OpenSSH van het
+  systeem met de ssh-agent praat en Git's eigen `ssh` niet.
+- **De registry** heeft geen eigen variabele nodig: `release.ps1` en `dev.ps1`
+  vallen bij een ontbrekende `REGISTRY_TOKEN` terug op `GITEA_TOKEN`. Zet alleen
+  `REGISTRY_USER` erbij, zodat het script zelf kan inloggen als de credential
+  store leeg is.
+- **De Docker-host** hoeft niets meer te hebben: pull en update-check zijn anoniem.
+
+Aanmaken: Gitea → Settings → Applications → Generate New Token, met **beide**
+scopes aangevinkt. Doe dat onder een account dat push-rechten op de repo heeft —
+lid zijn van de organisatie is daarvoor niet automatisch genoeg. Scopes van een
+bestaand token zijn later niet aan te passen, dus vink ze in één keer goed aan.
+
+**Waar hij terechtkomt** — `.env.release` naast de scripts, niet in git
+(`.gitignore` pakt `.env.*`):
+
+```ini
+GITEA_TOKEN=<token met write:package + write:repository>
+REGISTRY_USER=<je Gitea-account>
+```
+
+Een variabele die al in je shell staat wint, zodat je per run kunt afwijken. Een
+lege waarde in het bestand wordt overgeslagen.
+
+**Als de organisatie weer privé gaat** heb je er wél een tweede bij nodig: een
+read-only token op de Docker-host, voor `docker compose pull` en
+`UPDATE_CHECK_TOKEN`. Houd dat token dan read-only. Het staat in platte tekst in
+`.env` op een server die de app op poort 3400 publiceert; met schrijfrechten kan
+wie bij dat bestand komt — via de container, een shell op die host, of een
+backup — een eigen image als `latest` naar de registry pushen, en die host pullt
+`latest` zelf. Read-only houdt je eigen deploy-pad uit de aanvalsketen.
 
 ### Wat een foutcode betekent
 
 | Status | Betekenis |
 |---|---|
-| 401 | Token ongeldig of verlopen. Op de registry: helemaal niet ingelogd. |
-| 403 | Het token mag de repo wél zien, maar mist de **scope** voor dit endpoint. Gitea noemt de vereiste scope in de response-body. |
-| 404 | Het token mag de repo niet zien. Gitea geeft geen 403, om niet te verklappen dat iets bestaat: verkeerd account, of geen toegang tot de organisatie. |
+| 401 | Token ongeldig, verlopen of ingetrokken — Gitea herkent hem niet. Op de registry: helemaal niet ingelogd. |
+| 403 | Het token **bestaat en werkt**, maar mist de **scope** voor dit endpoint. Gitea noemt de vereiste scope in de response-body. |
+| 404 | Het token mag de repo niet zien. Gitea geeft geen 403, om niet te verklappen dat iets bestaat: verkeerd account, of geen toegang tot de organisatie. Nu de organisatie public is, wijst een 404 op een leesactie eerder op een verkeerde URL dan op rechten. |
 
 Scopes van een bestaand token zijn in Gitea niet aan te passen. Bij een 403 maak
 je dus een nieuw token aan; bijwerken kan niet.
 
-Nakijken wie een token is en wat hij ziet:
+**Leeft mijn token nog?** Juist dat onderscheid tussen 401 en 403 is de test.
+Vraag *niet* `/api/v1/user` op om te kijken "wie het token is": het
+werkstation-token heeft geen `read:user`, dus dat endpoint geeft altijd 403 en
+zegt niets over geldigheid. Kijk naar de statuscode, niet naar de inhoud:
 
 ```powershell
-$h = @{ Authorization = "token $env:GITEA_TOKEN" }
-(Invoke-RestMethod https://vibehoogie.duckdns.org/api/v1/user -Headers $h).login
-(Invoke-RestMethod https://vibehoogie.duckdns.org/api/v1/user/repos -Headers $h).full_name
+$u = "https://vibehoogie.duckdns.org/api/v1/user/repos"
+try   { (Invoke-WebRequest $u -Headers @{ Authorization = "token $env:GITEA_TOKEN" } -UseBasicParsing).StatusCode }
+catch { $_.Exception.Response.StatusCode.value__ }
 ```
 
+`403` = het token leeft (alleen deze scope ontbreekt). `401` = ingetrokken of
+fout gekopieerd. Nagemeten op 2026-09-10: geen header `401`, een nep-token van 40
+nullen `401`, het werkstation-token `403`.
+
 Vanuit de app-container op de host valt de body van een fout anders weg —
 busybox-`wget` gooit die bij een foutstatus weg, en Node zit in het image:
 
 ```bash
-docker exec vibefinance_app node -e 'fetch(process.env.UPDATE_CHECK_URL,{headers:{Accept:"application/json",Authorization:`token ${process.env.UPDATE_CHECK_TOKEN}`}}).then(async r=>console.log(r.status, (await r.text()).slice(0,300)))'
+# Anoniem, zoals de app het doet zonder UPDATE_CHECK_TOKEN
+docker exec vibefinance_app node -e 'fetch(process.env.UPDATE_CHECK_URL,{headers:{Accept:"application/json"}}).then(async r=>console.log(r.status, (await r.text()).slice(0,300)))'
+
+# Mét token, precies zoals routes/update.js de header opbouwt
+docker exec vibefinance_app node -e 'const t=process.env.UPDATE_CHECK_TOKEN; fetch(process.env.UPDATE_CHECK_URL,{headers:{Accept:"application/json",...(t&&{Authorization:`token ${t}`})}}).then(async r=>console.log(r.status, (await r.text()).slice(0,300)))'
 ```
 
-### Tokens opruimen
+> Let op: een **ongeldig** token geeft `401`, ook op deze publieke repo — Gitea
+> valt bij een verkeerd token niet terug op anonieme toegang. Krijg je 401
+> terwijl anoniem `200` geeft, haal `UPDATE_CHECK_TOKEN` dan uit `.env` in plaats
+> van hem te vervangen. Een *leeg* token is onschuldig: `Authorization: token `
+> negeert Gitea (`200`), en `config/index.js` zet met `|| null` bij een lege
+> waarde helemaal geen header. Nagemeten op 2026-09-10:
+> geen header `200`, `token ongeldig123` `401`, leeg `200`.
 
-De lijst onder Settings → Applications heeft een kolom **Last used**. Zet eerst
-beide machines om, draai daarna een release en een pull, en kijk een dag later
-welke tokens niet meer meebewegen — die kun je intrekken. Betrouwbaarder dan uit
-de naam afleiden wat waar in gebruik is. Trek niets in vóór die controle: het
-token achter je `docker login` op dit werkstation laat een release op de push
-falen.
+### Oude tokens opruimen
+
+Nu er één token overblijft, kunnen de rest weg — maar niet op de gok. De lijst
+onder Settings → Applications heeft een kolom **Last used**. Werkwijze:
+
+1. Zet het nieuwe token in `.env.release` en draai een release die helemaal
+   doorloopt (inclusief `docker push` en stap 5).
+2. Kijk in de lijst welk token net **Last used** heeft gekregen.
+3. Wacht een dag en trek de tokens in die niet meer meebewegen.
+
+Betrouwbaarder dan uit de naam afleiden wat waar in gebruik is. Trek vooral niets
+in vóór die controle: het token achter je `docker login` zit in de credential
+store en niet in een bestand, dus je ziet aan niets welke het is — trek je die
+in, dan valt de push in stap 3 om. Loopt dat toch mis, dan is
+`docker login vibehoogie.duckdns.org` met het nieuwe token genoeg.
 
 ---
 
@@ -144,7 +218,8 @@ falen.
 
 ```powershell
 # 1. Versienummer in package.json van "x.x.x-dev" naar "x.x.x"
-# 2. Changelog.md: kop van "Niet vrijgegeven" naar "[x.x.x] - datum"
+# 2. Wijzigingen in Changelog.md onder de kop "## [Niet vrijgegeven]"
+#    (de kop zelf omzetten hoeft niet — dat doet het script)
 # 3. Token staat in .env.release (zie Tokens) — of eenmalig in de shell:
 $env:GITEA_TOKEN = "<vibefinance-workstation>"
 
@@ -152,8 +227,9 @@ $env:GITEA_TOKEN = "<vibefinance-workstation>"
 .\release.ps1 -DryRun      # droogloop — toont alle stappen zonder uit te voeren
 .\release.ps1 -NoBuild     # sla docker build over, alleen tag + release
 .\release.ps1 -SkipTests   # sla de testsuite over (niet aanbevolen)
+.\release.ps1 -NoChangelog # publiceer bewust zonder release-notes
 
-# 4. Versienummer in package.json naar "x.x.(x+1)-dev" voor volgende cyclus
+# Klaar. Het versienummer voor de volgende cyclus zet het script zelf.
 ```
 
 Het script bouwt één image voor `linux/amd64` en `linux/arm64`, zodat dezelfde
@@ -161,38 +237,50 @@ tag op een Raspberry Pi en op een x86-server werkt.
 
 **Wat het script zelf bijwerkt** — met de hand aanpassen is dus dubbel werk:
 
-| Bestand | Wat |
-|---|---|
-| `frontend/package.json` | versie gelijkgetrokken met de root `package.json` |
-| `README.md` | de `versie-x.x.x`-badge bovenaan |
+| Bestand | Wat | Wanneer |
+|---|---|---|
+| `Changelog.md` | kop `## [Niet vrijgegeven]` → `## [x.x.x] - datum` | vóór de build |
+| `frontend/package.json` | versie gelijkgetrokken met de root `package.json` | vóór de build |
+| `README.md` | de `versie-x.x.x`-badge bovenaan | vóór de build |
+| `package.json` (root) | versie → `x.x.(x+1)-dev` voor de volgende cyclus | **ná** het publiceren |
 
-Beide gebeuren vóór de build, en een `-DryRun` meldt ze zonder te schrijven. Ze
-blijven na een echte release als wijziging in je working tree staan; neem ze mee
-in de volgende commit.
+Een `-DryRun` meldt alle vier zonder te schrijven. Ze blijven na een echte
+release als wijziging in je working tree staan; neem ze mee in de volgende
+commit.
 
-> **De changelog-kop moet exact `## [x.x.x]` zijn.** `release.ps1` zoekt die kop
-> om de release-notes te vullen. Staat je werk nog onder `## [Niet vrijgegeven]`,
-> dan vindt het script niets en valt het terug op de tekst `"Release x.x.x"` —
-> dan staat er geen inhoudelijke release-notes in Gitea en ziet een gebruiker in
-> het belletje een placeholder. Dat overkwam 0.1.9. Achteraf repareren kan met
-> een `PATCH` op `/repos/<org>/<repo>/releases/<id>`, maar vóór de release
-> omzetten is een stuk minder werk.
+De laatste staat bewust ná het publiceren: breekt de release eerder af, dan
+schuift het versienummer niet vooruit. Bijeffect dat je moet kennen — na een
+geslaagde release staat er een `-dev` nummer in `package.json`, en de controle
+bovenin het script weigert een `-dev` versie. Dat sluit een dubbele publicatie
+uit, maar wil je dezelfde versie bewust opnieuw releasen (bijvoorbeeld omdat een
+tag is verdwenen), zet het nummer dan eerst zelf terug naar `x.x.x`.
+
+> **Zonder changelog-sectie breekt het script af.** De release-notes komen uit de
+> sectie `## [x.x.x]` in `Changelog.md`. Vond het script daar niets, dan
+> publiceerde het stil de tekst `"Release x.x.x"` — dat gebeurde bij 0.1.9 en
+> 1.0.2. Nu zet het de kop `## [Niet vrijgegeven]` zelf om, en als er ook dán
+> niets over deze versie in staat, stopt het vóór de build met de melding wat je
+> moet toevoegen. Wil je bewust zonder notes publiceren, gebruik `-NoChangelog`.
+>
+> De controle staat vóór de drie auto-updates hierboven, zodat een afgebroken
+> release geen gewijzigde bestanden achterlaat. Is een release toch al gepubliceerd
+> met de placeholder, dan repareer je dat met een `PATCH` op
+> `/repos/<org>/<repo>/releases/<id>` met de juiste `body`.
 
 ### `.env.release` — token niet elke sessie opnieuw zetten
 
 Staat er een `.env.release` naast `release.ps1`, dan leest het script die in
 voordat er iets gebeurt, en hoeft stap 3 niet meer met de hand:
 
-```
+```ini
 # .env.release — staat in .gitignore, hoort alleen op de release-machine
 GITEA_TOKEN=<vibefinance-workstation>
 REGISTRY_USER=<gitea-gebruiker>
-REGISTRY_TOKEN=<vibefinance-workstation>
 ```
 
-Beide tokenvariabelen krijgen hetzelfde token; zie [Tokens](#tokens) voor waarom
-dat op deze machine één token mag zijn, en voor wat een 401, 403 of 404 van Gitea
-betekent.
+`REGISTRY_TOKEN` hoeft er niet in: beide scripts vallen bij een ontbrekende
+`REGISTRY_TOKEN` terug op `GITEA_TOKEN`. Zie [Tokens](#tokens) voor de scopes en
+voor wat een 401, 403 of 404 van Gitea betekent.
 
 Een variabele die al in je shell staat wint, zodat je per run kunt afwijken zonder
 het bestand aan te passen. Het script logt alleen welke namen het heeft geladen,
@@ -210,7 +298,12 @@ docker compose pull && docker compose up -d
 docker compose down -v && docker compose up -d
 ```
 
-Pullen vereist een registry-login op die host — zie
+Draai dit in de map met `docker-compose.yml` en `.env`. `docker compose` zoekt
+dat bestand namelijk in de huidige map en kijkt niet omhoog; staat het er niet,
+dan is het antwoord `no configuration file provided: not found`. Met
+`docker compose -f /pad/naar/docker-compose.yml` kun je het expliciet meegeven.
+
+Pullen zelf werkt anoniem zolang de organisatie public is — zie
 [Pullen op een deploy-machine](#pullen-op-een-deploy-machine).
 
 ### PostgreSQL versie-upgrade
@@ -391,8 +484,9 @@ machine — `vibefinance-workstation`, zie [Tokens](#tokens). Zonder login faalt
 een push met `401 Unauthorized`; `release.ps1` en `dev.ps1 push` controleren dit
 vóór de build en stoppen dan meteen.
 
-Liever niet handmatig inloggen? Zet `REGISTRY_USER` en `REGISTRY_TOKEN` in
-`.env.release`, dan logt het script zelf in.
+Liever niet handmatig inloggen? Zet `REGISTRY_USER` in `.env.release`, dan logt
+het script zelf in met `GITEA_TOKEN` — een aparte `REGISTRY_TOKEN` is alleen
+nodig als je daar bewust een ánder token voor wilt gebruiken.
 
 Twee valkuilen: log in op `vibehoogie.duckdns.org` **zonder** `:3000` (dat is een
 aparte sleutel in de credential store), en doe het als dezelfde Windows-gebruiker
@@ -406,20 +500,8 @@ docker-credential-desktop list
 
 ### Pullen op een deploy-machine
 
-Het package is privé, dus ook een **pull** vereist een login — anoniem geeft
-`401 Unauthorized` (`docker compose pull` meldt dan "no basic auth credentials"
-of "pull access denied"). Eenmalig op de Docker-host:
-
-```bash
-docker login vibehoogie.duckdns.org
-# gebruikersnaam: je Gitea-account
-# wachtwoord:     het token van deze host (vibefinance-host, read:package)
-```
-
-Daarna werkt `docker compose pull && docker compose up -d`. De login komt in
-`~/.docker/config.json` van de gebruiker die het commando uitvoert — doe het dus
-als dezelfde gebruiker (bij `sudo docker` is dat root). Log in op
-`vibehoogie.duckdns.org` **zonder** `:3000`.
+De organisatie is public, dus een **pull** werkt anoniem — `docker compose pull &&
+docker compose up -d` en klaar, zonder `docker login`.
 
 Controleren zonder te pullen:
 
@@ -427,8 +509,23 @@ Controleren zonder te pullen:
 docker manifest inspect vibehoogie.duckdns.org/vibe/vibefinance-app:latest
 ```
 
-Ditzelfde token gaat als `UPDATE_CHECK_TOKEN` in de `.env` op deze host, voor de
-update-check van de app — één token voor beide, zie [Tokens](#tokens).
+Krijg je `401 Unauthorized`, "no basic auth credentials" of "pull access denied",
+dan is het package niet publiek leesbaar (organisatie weer op privé, of de
+package-eigenaar wijkt af van de organisatie). Dan alsnog eenmalig op de host:
+
+```bash
+docker login vibehoogie.duckdns.org
+# gebruikersnaam: je Gitea-account
+# wachtwoord:     een token met read:package
+```
+
+De login komt in `~/.docker/config.json` van de gebruiker die het commando
+uitvoert — doe het dus als dezelfde gebruiker (bij `sudo docker` is dat root).
+Log in op `vibehoogie.duckdns.org` **zonder** `:3000`.
+
+Moet je terug naar een token, dan kan datzelfde token ook als
+`UPDATE_CHECK_TOKEN` in de `.env` op deze host — één token voor beide, zie
+[Tokens](#tokens).
 
 ---
 
@@ -447,7 +544,43 @@ dat op het belletje in de topbalk en onder "Over VibeFinance".
 
 Builds met een `-dev` suffix melden nooit (die lopen voor op de laatste release).
 Wil je de melding tijdens ontwikkeling toch testen: open de app met `?updatecheck`
-in de URL.
+in de URL. Let op dat `isNieuwer` alleen bij een écht hoger nummer aanslaat — bij
+`1.0.2-dev` naast release `1.0.1` blijft de kaart dus ook met `?updatecheck` leeg.
+Zet dan tijdelijk een lagere versie in de root `package.json`.
+
+**Wat de melding toont**
+
+Alleen de kop, de versieregel en een link:
+
+```
+🔔  Nieuwe versie beschikbaar
+    v1.0.1 is uitgebracht. Je gebruikt momenteel v1.0.0.
+    Release bekijken →
+```
+
+De release-notes staan er bewust **niet** in. `/api/update-check` stuurt ze wel
+mee als `notes`, maar dat is de ruwe Markdown uit de changelog; in een kaart van
+280px leverde dat zichtbare `### `-koppen en afgekapte regels op. Wie de details
+wil, volgt de link. Het veld blijft in de API zitten voor het geval je ze ooit
+ergens met meer ruimte wilt tonen — dan is Markdown renderen de volgende stap.
+
+**De release-link hangt aan Gitea's `ROOT_URL`**
+
+De `url` in het antwoord is de `html_url` van de release, en die stelt Gitea bij
+elk verzoek samen uit `ROOT_URL` in `app.ini` — hij wordt *niet* per release
+opgeslagen. Staat `ROOT_URL` op een intern adres, dan wijst "Release bekijken"
+naar iets dat buiten je netwerk niet bestaat, terwijl de melding zelf gewoon
+werkt (die leest alleen het versienummer).
+
+Nakijken welke waarde Gitea daadwerkelijk gebruikt — de `issuer` is `ROOT_URL`:
+
+```bash
+curl -s https://vibehoogie.duckdns.org/.well-known/openid-configuration | grep issuer
+```
+
+`app.ini` wordt alleen bij het opstarten gelezen, dus na een wijziging moet Gitea
+herstarten. Omdat de URL wordt samengesteld en niet bewaard, zijn daarna álle
+releases in één keer goed — ook de oude. Een `PATCH` per release is niet nodig.
 
 **Configuratie**
 
@@ -464,7 +597,7 @@ uit `.env` (of de default in `docker-compose.yml`). Beschikbare backend-variabel
 | Variabele | Betekenis |
 |---|---|
 | `UPDATE_CHECK_URL` | Release-API die gepolld wordt. Leeg = melding uit. |
-| `UPDATE_CHECK_TOKEN` | Nodig zolang de `Vibe`-organisatie in Gitea privé is: het token van de host (`read:repository`, zie [Tokens](#tokens)). Zonder token geeft `releases/latest` 404, met een verkeerde scope 403 — in beide gevallen blijft de melding leeg, met alleen een `WARN` in het containerlog. |
+| `UPDATE_CHECK_TOKEN` | Optioneel. De `Vibe`-organisatie is public, dus `releases/latest` antwoordt anoniem met `200` en de check heeft geen token nodig. Gaat de organisatie weer privé, dan is het host-token nodig (`read:repository`, zie [Tokens](#tokens)): zonder geeft `releases/latest` dan 404, met een verkeerde scope 403 — in beide gevallen blijft de melding leeg, met alleen een `WARN` in het containerlog. |
 
 **Een release publiceren**
 

Changelog.md

@@ -2,6 +2,105 @@
 
 ## [Niet vrijgegeven]
 
+### Toegevoegd
+- `release.ps1` zet de changelog-kop `## [Niet vrijgegeven]` nu zelf om naar
+  `## [x.x.x] - datum`, net zoals het al deed met `frontend/package.json` en de
+  README-badge. Handmatig omzetten hoeft dus niet meer
+- Staat er ook na die omzetting niets over deze versie in `Changelog.md`, dan
+  breekt het script af **vóór** de build met de melding wat je moet toevoegen.
+  Eerder viel het stil terug op de tekst `"Release x.x.x"` en meldde het
+  "Gepubliceerd" — dat overkwam 0.1.9 en 1.0.2, en is achteraf alleen met een
+  `PATCH` op de release te herstellen. Nieuwe switch `-NoChangelog` om bewust
+  zonder release-notes te publiceren
+- `release.ps1` zet na een geslaagde release de versie in de root
+  `package.json` op `x.x.(x+1)-dev`. Dat was voorheen de laatste handmatige stap
+  van de release-workflow. Het staat bewust ná het publiceren, zodat een
+  afgebroken release het nummer niet vooruit schuift
+
+### Opgelost
+- **`-DryRun` in combinatie met `-Force` verwijderde écht de Git-tag.** De twee
+  commando's in stap 4 (`git tag -d` en `git push origin :refs/tags/x.x.x`)
+  liepen niet via `Invoke-Cmd` en hadden dus geen droogloop-controle. Gitea
+  ruimt de release op zodra de tag verdwijnt, dus een droogloop kon een
+  gepubliceerde release wissen — zo is de release van 1.0.2 verloren gegaan en
+  opnieuw aangemaakt. Onder `-DryRun` worden beide nu alleen gemeld
+
+### Gewijzigd
+- De changelog-controle staat vóór de drie auto-updates, zodat een afgebroken
+  release geen gewijzigde bestanden achterlaat terwijl hij "er is niets
+  gepubliceerd" meldt
+- Stap 5 leest de release-notes uit het geheugen in plaats van opnieuw van
+  schijf. Een droogloop schrijft de kop niet, en toonde daardoor de placeholder
+  in de payload — precies wat je met een droogloop wilt uitsluiten
+- De Quick Start in `README.md` begint nu met het ophalen van
+  `docker-compose.yml` (clone, of alleen die twee bestanden via `raw`). Zonder
+  dat bestand antwoordt `docker compose pull` met `no configuration file
+  provided: not found`, en die stap ontbrak. Beide foutmeldingen staan er nu bij
+  met hun oorzaak
+
+## [1.0.2] - 2026-09-10
+
+### Gewijzigd
+- De update-melding op het belletje toont alleen nog de kop, de versieregel en de
+  link naar de release. De release-notes stonden er als ruwe Markdown in — in een
+  kaart van 280px leverde dat zichtbare `### `-koppen en afgekapte regels op.
+  `/api/update-check` stuurt `notes` nog wel mee, zodat ze later ergens met meer
+  ruimte gebruikt kunnen worden
+- `BEHEER.md` legt vast dat de release-link uit Gitea's `ROOT_URL` wordt
+  samengesteld en niet per release wordt opgeslagen: na een `ROOT_URL`-wijziging
+  plus herstart zijn álle releases in één keer goed, ook de oude. Verder staat er
+  nu hoe je aan het verschil tussen `401` en `403` ziet of een token nog leeft, en
+  hoe je anoniem over https fetcht als SSH niet meedoet
+
+## [1.0.1] - 2026-09-10
+
+### Toegevoegd
+- Kolommen in de tabellen op Eigen Vermogen ("Geïnvesteerde Fiat") en Voortgang
+  zijn versleepbaar: pak de rechterrand van een kolomkop. De breedtes gaan per
+  tabel naar localStorage, dus ze overleven een tabwissel en een herlaad;
+  dubbelklik op de greep zet één kolom terug op zijn standaardbreedte. De logica
+  staat in de nieuwe hook `frontend/src/hooks/useKolomBreedtes.js`, de greep zelf
+  is `.kolom-grip` in `App.css`
+
+### Gewijzigd
+- De `Vibe`-organisatie in Gitea staat op **public**, dus lezen vereist geen
+  token meer: `git clone`, `docker compose pull` en de update-check werken
+  anoniem. `UPDATE_CHECK_TOKEN` in `.env` is daarmee optioneel — de code
+  ondersteunt hem nog als vangnet voor het geval de organisatie weer privé
+  wordt. Schrijven verandert niet: `docker push` en het aanmaken van een release
+  hebben nog steeds het werkstation-token nodig
+- Het tweetoken-model in `BEHEER.md` is teruggebracht tot **één** Gitea-token op
+  het werkstation, met `write:package` en `write:repository`. Het host-token is
+  niet meer nodig (pull en update-check zijn anoniem), `git push` gaat over SSH,
+  en `REGISTRY_TOKEN` hoeft niet apart: `release.ps1` en `dev.ps1` vielen daar al
+  terug op `GITEA_TOKEN`. Geen code-wijziging, alleen minder te beheren
+- De tabellen op Eigen Vermogen en Voortgang staan op `table-layout: fixed`,
+  nodig om ingestelde kolombreedtes te respecteren. Gevolg: lange tekst rekt een
+  kolom niet meer op maar wordt afgekapt met een ellips. De Opmerkingen-cellen
+  hebben een `title`, dus hover geeft de volledige tekst
+- Het label bij een beschikbare update in "Over VibeFinance" is "Nieuwe versie"
+  (was "Nieuwste versie" in 1.0.0)
+
+### Opgelost
+- De sticky kolomkop van die tabellen was in dark mode maar 30% dekkend: hij
+  gebruikte `T.card` (`rgba(22,23,27,0.30)`), waardoor de rijen tijdens het
+  scrollen zichtbaar door de koptekst heen liepen. Nu `T.popupBg`, de
+  ondoorzichtige variant die al in het thema stond
+- In dev bakte Vite de versie uit `frontend/package.json` in in plaats van de
+  versie uit de root `package.json`. `VITE_APP_VERSION` kwam alleen als
+  build-arg mee, maar de `development`-stage in de `Dockerfile` declareert die
+  `ARG` niet — en Vite bakt de constante in bij het *starten* van de dev-server,
+  niet bij het bouwen van het image. De variabele staat nu in de
+  runtime-omgeving van de dev-container; `vite.config.js` valt met `||` (was
+  `??`) terug op `package.json` als hij leeg is
+- API-antwoorden sturen nu `Cache-Control: no-store`. Ze hadden alleen een
+  `ETag` en geen cache-beleid, waardoor de browser zelf mocht bepalen hoe lang
+  hij ze hergebruikte — per browser en profiel verschillend. Gevolg: de
+  update-melding bleef in Brave op een oud antwoord hangen (nog van vóór het
+  werkende token) terwijl een verse Edge het goede kreeg
+
+## [1.0.0] - 2026-09-09
+
 ### Gewijzigd
 - `BEHEER.md` heeft één centrale `## Tokens`-sectie met het tweetoken-model
   (werkstation `write:*`, Docker-host `read:*`) plus de betekenis van een 401,

README.md

@@ -10,7 +10,7 @@ Eigen vermogen · Schulden · Voortgang · Gebruikersbeheer
 ![Node.js](https://img.shields.io/badge/Node.js_22-339933?style=flat&logo=node.js&logoColor=white)
 ![PostgreSQL](https://img.shields.io/badge/PostgreSQL_18-4169E1?style=flat&logo=postgresql&logoColor=white)
 ![Docker](https://img.shields.io/badge/Docker_Compose-2496ED?style=flat&logo=docker&logoColor=white)
-![Version](https://img.shields.io/badge/versie-0.1.9-8b5cf6?style=flat)
+![Version](https://img.shields.io/badge/versie-1.0.2-8b5cf6?style=flat)
 ![Built with Claude](https://img.shields.io/badge/Gebouwd_met-Claude.ai-8b5cf6?style=flat&logo=anthropic&logoColor=white)
 
 <img src="docs/screenshot-dashboard.png" alt="VibeFinance dashboard" width="820">
@@ -32,7 +32,25 @@ Deze applicatie is volledig ontworpen en ontwikkeld met behulp van [Claude.ai](h
 De app draait in **2 containers**: `app` (Express API + gebouwde frontend) en
 `postgres` (database).
 
-**`.env`** — kopieer `.env.example` en vul in:
+**1. De bestanden op de server zetten.** `docker compose` leest
+`docker-compose.yml` uit de map waarin je het commando draait, dus dat bestand
+moet er eerst staan. De organisatie in Gitea is publiek, dus dit kan anoniem:
+
+```bash
+git clone https://vibehoogie.duckdns.org/Vibe/VibeFinance.git
+cd VibeFinance
+```
+
+Wil je de repo niet op je server, dan zijn deze twee bestanden genoeg:
+
+```bash
+mkdir -p vibefinance && cd vibefinance
+base=https://vibehoogie.duckdns.org/Vibe/VibeFinance/raw/branch/main
+curl -fsSLO $base/docker-compose.yml
+curl -fsSL  $base/.env.example -o .env.example
+```
+
+**2. `.env` aanmaken** — kopieer `.env.example` en vul in:
 
 ```env
 POSTGRES_USER=vibefinance
@@ -46,15 +64,26 @@ APP_PORT=3400
 openssl rand -hex 64
 ```
 
+**3. Starten:**
+
 ```bash
 cp .env.example .env    # en vul de waarden in
 
-# Het app-image staat in een privé-registry, dus eerst inloggen:
-docker login vibehoogie.duckdns.org   # wachtwoord = Gitea-token met read:package
-
 docker compose pull && docker compose up -d
 ```
 
+Twee foutmeldingen en wat ze betekenen:
+
+- **`no configuration file provided: not found`** — je staat in een map zonder
+  `docker-compose.yml`. Controleer met `ls docker-compose.yml`, of geef het
+  bestand expliciet mee: `docker compose -f /pad/naar/docker-compose.yml up -d`.
+- **`401 Unauthorized`** of **"pull access denied"** — de organisatie staat niet
+  meer op publiek. Dan alsnog inloggen:
+
+  ```bash
+  docker login vibehoogie.duckdns.org   # wachtwoord = Gitea-token met read:package
+  ```
+
 Navigeer naar `http://<server-ip>:3400` en registreer je account. De **eerste** geregistreerde gebruiker krijgt automatisch de Admin-rol.
 
 De container luistert intern op poort 3001 en serveert daar zowel de frontend
@@ -116,13 +145,21 @@ backend/package.json (15 dependencies)
 
 ```powershell
 # token: staat in .env.release, of eenmalig in de shell
-$env:GITEA_TOKEN = "<token met write:repository>"
+# één Gitea-token met write:package (push) én write:repository (release)
+$env:GITEA_TOKEN = "<token met write:package + write:repository>"
 .\release.ps1
 ```
 
 Draait de tests, bouwt het app-image voor `amd64` + `arm64` (Raspberry Pi),
 pusht naar de registry, zet de Git-tag en publiceert de Gitea-release.
 
+Het script regelt ook het bijwerken eromheen: de changelog-kop
+`## [Niet vrijgegeven]` wordt `## [x.x.x] - datum`, de versie in
+`frontend/package.json` en de badge hierboven gaan mee, en ná het publiceren
+zet het de root `package.json` op `x.x.(x+1)-dev` voor de volgende cyclus.
+Beschrijft de changelog niets over deze versie, dan stopt het script vóór de
+build — anders zou de release met een placeholder als notes online komen.
+
 ---
 
 ## 🗂️ Functionaliteit
@@ -135,6 +172,10 @@ pusht naar de registry, zet de Git-tag en publiceert de Gitea-release.
 | 📈 **Voortgang** | Grafieken en trends van EV en schuld over tijd (apart bij te houden) |
 | 👥 **Gebruikers** | Accounts aanmaken, bewerken en beheren (Admin-rol vereist) |
 
+De kolommen in de tabellen op Eigen vermogen en Voortgang zijn versleepbaar: pak
+de rechterrand van een kolomkop. De breedtes worden per tabel in de browser
+bewaard; dubbelklik op de greep voor de standaardbreedte.
+
 ---
 
 ## 🏗️ Architectuur
@@ -161,11 +202,12 @@ vibefinance/
 │   ├── vite.config.js          # /api proxy naar de API in dezelfde container
 │   └── src/
 │       ├── App.jsx             # Root – wiring + idle-logout
+│       ├── App.css             # Reset + losse klassen (o.a. .kolom-grip)
 │       ├── main.jsx
 │       ├── version.js          # Draaiende versie (__APP_VERSION__ uit de build)
 │       ├── constants/          # Kleuren, tabs, begindata
 │       ├── utils/              # Formatters, helpers
-│       ├── hooks/              # useTheme, useUpdateCheck
+│       ├── hooks/              # useTheme, useUpdateCheck, useKolomBreedtes
 │       ├── context/            # AppContext (global state + API sync)
 │       ├── components/
 │       │   ├── ui/             # Primitieve UI (VCard, DonutChart…)
@@ -259,7 +301,7 @@ Het schema wordt bij het starten van de app aangemaakt/bijgewerkt via
 | `PORT` | `3001` | Poort binnen de container |
 | `STATIC_DIR` | `/app/public` | Map met de frontend-build |
 | `UPDATE_CHECK_URL` | Gitea releases-API | Bron update-melding (leeg = uit) |
-| `UPDATE_CHECK_TOKEN` | — | Nodig zolang de Gitea-repo privé is; scope `read:repository` |
+| `UPDATE_CHECK_TOKEN` | — | Optioneel: de Gitea-repo is publiek, dus de check werkt anoniem. Alleen nodig als de organisatie weer privé wordt; scope `read:repository` |
 
 ---
 
@@ -289,8 +331,9 @@ Het schema wordt bij het starten van de app aangemaakt/bijgewerkt via
 ## 🛠️ Beheer
 
 Zie `BEHEER.md` voor commando's voor lokale ontwikkeling, releases, logs en
-database-toegang — en voor de sectie **Tokens**: welk Gitea-token op welke
-machine hoort, met welke scopes, en wat een 401, 403 of 404 van Gitea betekent.
+database-toegang — en voor de sectie **Tokens**: waarom één Gitea-token op het
+werkstation genoeg is, welke scopes het nodig heeft, en wat een 401, 403 of 404
+van Gitea betekent.
 
 ---
 

backend/src/server.js

@@ -56,6 +56,17 @@ if (config.NODE_ENV !== "test") {
   app.use(pinoHttp({ logger }));
 }
 
+// ── Geen browsercache op de API ───────────────────────────────────────────────
+// Zonder Cache-Control mag de browser zelf bepalen hoe lang hij een antwoord
+// hergebruikt (heuristische caching). Dat verschilt per browser en profiel: de
+// update-melding bleef in de ene browser op een oud antwoord hangen terwijl een
+// verse browser het goede kreeg. API-antwoorden zijn per gebruiker en per moment,
+// dus die horen nooit uit de cache te komen.
+app.use("/api", (_req, res, next) => {
+  res.setHeader("Cache-Control", "no-store");
+  next();
+});
+
 // ── API-routes ────────────────────────────────────────────────────────────────
 app.use("/api/health",       healthRouter);
 app.use("/api/update-check", updateRouter);

backend/test/app.test.js

@@ -68,6 +68,15 @@ describe("API", () => {
     assert.equal(body.latest, null);
     assert.equal(body.disabled, true);
   });
+
+  // Zonder expliciete header bepaalt de browser zelf hoe lang hij een
+  // API-antwoord hergebruikt, en dat verschilt per browser.
+  it("API-antwoorden komen nooit uit de browsercache", async () => {
+    for (const pad of ["/api/health", "/api/update-check", "/api/bestaat-niet"]) {
+      const res = await fetch(`${basis}${pad}`);
+      assert.match(res.headers.get("cache-control") ?? "", /no-store/, pad);
+    }
+  });
 });
 
 describe("Frontend serveren", () => {

docker-compose.dev.yml

@@ -49,6 +49,11 @@ services:
     environment:
       NODE_ENV:     development
       PORT:         3001
+      # Vite bakt de versie in bij het STARTEN van de dev-server, dus die moet
+      # in de runtime-omgeving staan; de build-arg hierboven bereikt alleen de
+      # frontend-build-stage en doet niets voor target: development.
+      # Leeg = vite.config.js valt terug op frontend/package.json.
+      VITE_APP_VERSION: ${VITE_APP_VERSION:-}
       JWT_SECRET:   dev-secret-change-in-production
       JWT_EXPIRES:  7d
       CORS_ORIGIN:  http://localhost

frontend/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vibefinance-frontend",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "private": true,
   "type": "module",
   "scripts": {

frontend/src/App.css

@@ -26,3 +26,37 @@ input[type="number"]::-webkit-inner-spin-button {
 @keyframes spin {
   to { transform: rotate(360deg); }
 }
+
+/* Sleepvlak op de rechterrand van een tabelkop — zie hooks/useKolomBreedtes.js.
+   Blijft binnen de cel (geen negatieve offset), anders duwt de laatste kolom
+   een horizontale scrollbar tevoorschijn. */
+.kolom-grip {
+  position: absolute;
+  top: 0;
+  right: 0;
+  width: 6px;
+  height: 100%;
+  cursor: col-resize;
+  user-select: none;
+  touch-action: none;
+}
+
+/* Het streepje erft de kleur van de kop, dus per categorie de accentkleur. */
+.kolom-grip::after {
+  content: "";
+  position: absolute;
+  top: 25%;
+  right: 2px;
+  width: 1px;
+  height: 50%;
+  background: currentColor;
+  opacity: 0.3;
+}
+
+.kolom-grip:hover::after,
+.kolom-grip:active::after {
+  top: 0;
+  height: 100%;
+  width: 2px;
+  opacity: 1;
+}

frontend/src/App.jsx

@@ -209,14 +209,10 @@ function AppInner() {
                       <div style={{ fontSize: 12, color: T.muted, lineHeight: 1.5 }}>
                         v{nieuweVersie.latest} is uitgebracht. Je gebruikt momenteel v{version}.
                       </div>
-                      {nieuweVersie.notes && (
-                        <div style={{
-                          fontSize: 11, color: T.subtext, marginTop: 6, lineHeight: 1.5,
-                          maxHeight: 130, overflowY: "auto", whiteSpace: "pre-wrap",
-                        }}>
-                          {nieuweVersie.notes}
-                        </div>
-                      )}
+                      {/* De release-notes zelf staan hier niet: dat is Markdown
+                          uit de changelog, en die kwam als ruwe `### `-koppen in
+                          een smalle kolom te staan. Wie de details wil, volgt de
+                          link naar de release. */}
                       {nieuweVersie.url && (
                         <a href={nieuweVersie.url} target="_blank" rel="noreferrer" style={{
                           display: "inline-block", marginTop: 8,

frontend/src/components/NavBar.jsx

@@ -165,7 +165,7 @@ function OverPopup({ onClose, nieuweVersie, T }) {
 
           {nieuweVersie && (
             <div style={{ display: "flex", justifyContent: "space-between", alignItems: "center", marginBottom: 10 }}>
-              <span style={{ fontSize: 13, color: T.muted }}>Nieuwste versie</span>
+              <span style={{ fontSize: 13, color: T.muted }}>Nieuwe versie</span>
               <span style={{ fontSize: 12, fontWeight: 700, color: "#f97316", background: "rgba(249,115,22,0.12)", borderRadius: 6, padding: "3px 10px" }}>
                 v{nieuweVersie.latest}
               </span>

frontend/src/hooks/useKolomBreedtes.js

@@ -0,0 +1,78 @@
+import { useRef, useState } from "react";
+import { loadFromStorage, saveToStorage } from "../utils/storage.js";
+
+// Smaller dan dit wordt een kolom onleesbaar; de greep blijft wel pakbaar.
+const MIN_BREEDTE = 60;
+
+/**
+ * Versleepbare kolombreedtes voor een tabel.
+ *
+ * `kolommen` is een array van { id, breedte } in weergave-volgorde, waarbij
+ * `breedte` de standaard in pixels is. De aanpassingen van de gebruiker gaan
+ * per tabel naar localStorage, zodat ze een tabwissel of herlaad overleven.
+ * Kolommen die later verschijnen (een categorie die de gebruiker toevoegt)
+ * krijgen hun standaardbreedte; opgeslagen breedtes van verdwenen kolommen
+ * blijven ongebruikt staan en storen niets.
+ *
+ * De tabel moet `tableLayout: "fixed"` krijgen met een <colgroup>, en als
+ * `width` de teruggegeven `totaal`. Met `width: "100%"` verdeelt de browser de
+ * ruimte namelijk proportioneel en levert slepen niet exact de gesleepte
+ * pixels op.
+ *
+ * Geeft terug:
+ *   breedtes  px per kolom-id, standaard plus aanpassing
+ *   totaal    som van de breedtes, voor de `width` van de tabel
+ *   grip      props voor het sleepvlak in de <th> van die kolom
+ *   herstel   alle kolommen terug naar hun standaardbreedte
+ */
+export function useKolomBreedtes(opslagKey, kolommen) {
+  const [aangepast, setAangepast] = useState(() => loadFromStorage(opslagKey) ?? {});
+  // Spiegelt `aangepast` zodat het slepen en het opslaan bij het loslaten niet
+  // van de state-updater afhangen (die mag geen bijwerkingen hebben).
+  const laatste = useRef(aangepast);
+  const sleep   = useRef(null);
+
+  const breedtes = {};
+  for (const k of kolommen) breedtes[k.id] = aangepast[k.id] ?? k.breedte;
+  const totaal = kolommen.reduce((som, k) => som + breedtes[k.id], 0);
+
+  const zet = (volgende) => { laatste.current = volgende; setAangepast(volgende); };
+
+  const grip = (id) => ({
+    className: "kolom-grip",
+    role: "separator",
+    title: "Sleep om de kolom breder of smaller te maken — dubbelklik voor de standaardbreedte",
+    onPointerDown: (e) => {
+      // Pointer capture: het slepen loopt door buiten de greep, ook boven de
+      // rijen of naast de tabel, zonder losse listeners op window.
+      e.preventDefault();
+      e.currentTarget.setPointerCapture(e.pointerId);
+      sleep.current = { id, startX: e.clientX, startBreedte: breedtes[id] };
+    },
+    onPointerMove: (e) => {
+      if (!sleep.current) return;
+      const { id: kolomId, startX, startBreedte } = sleep.current;
+      const nieuw = Math.max(MIN_BREEDTE, Math.round(startBreedte + e.clientX - startX));
+      if (laatste.current[kolomId] === nieuw) return;
+      zet({ ...laatste.current, [kolomId]: nieuw });
+    },
+    onPointerUp: () => {
+      if (!sleep.current) return;
+      sleep.current = null;
+      // Pas bij het loslaten opslaan; tijdens het slepen zou elke pixel een
+      // localStorage-write kosten.
+      saveToStorage(opslagKey, laatste.current);
+    },
+    onDoubleClick: () => {
+      // Zonder destructuring-omit: die laat een ongebruikte variabele achter.
+      const rest = { ...laatste.current };
+      delete rest[id];
+      zet(rest);
+      saveToStorage(opslagKey, rest);
+    },
+  });
+
+  const herstel = () => { zet({}); saveToStorage(opslagKey, {}); };
+
+  return { breedtes, totaal, grip, herstel };
+}

frontend/src/pages/EigenVermogenTab.jsx

@@ -1,6 +1,7 @@
 import { useState } from "react";
 import { useApp } from "../context/AppContext.jsx";
 import { fmt, fmtDatum } from "../utils/format.js";
+import { useKolomBreedtes } from "../hooks/useKolomBreedtes.js";
 import { PURPLE, PURPLE_LIGHT, GREEN, RED, CAT_COLORS } from "../constants/index.js";
 import {
   VCard, DonutChart, Overlay, ModalBox, ModalHeader, ModalFooter,
@@ -250,8 +251,22 @@ function EVVoortgangTabel() {
 
   const removeRow = (datum) => setEvRows(evRows.filter((r) => r.datum !== datum));
 
-  const th = { padding: "8px 10px", fontSize: 11, color: T.muted, fontWeight: 600, textAlign: "left", whiteSpace: "nowrap", background: T.card, position: "sticky", top: 0, zIndex: 1, borderBottom: `1px solid ${T.border}` };
-  const td = { padding: "7px 10px", fontSize: 12, color: T.text, borderBottom: `1px solid ${T.border}` };
+  // Kolommen in weergave-volgorde, met hun standaardbreedte. De categorieën
+  // zijn dynamisch, dus de lijst wordt per render opgebouwd.
+  const kolommen = [
+    { id: "datum",       breedte: 100 },
+    ...cats.map((c) => ({ id: c.id, breedte: 100 })),
+    { id: "nettoWaarde", breedte: 115 },
+    { id: "verschil",    breedte: 105 },
+    { id: "opmerkingen", breedte: 150 },
+    ...(!locked ? [{ id: "acties", breedte: 75 }] : []),
+  ];
+  const { breedtes, totaal, grip } = useKolomBreedtes("ev_kolom_breedtes", kolommen);
+
+  // overflow/ellipsis horen bij tableLayout "fixed": de inhoud rekt de kolom
+  // niet meer op, dus zonder afkappen loopt lange tekst de buurcel binnen.
+  const th = { padding: "8px 10px", fontSize: 11, color: T.muted, fontWeight: 600, textAlign: "left", whiteSpace: "nowrap", overflow: "hidden", textOverflow: "ellipsis", background: T.popupBg, position: "sticky", top: 0, zIndex: 1, borderBottom: `1px solid ${T.border}` };
+  const td = { padding: "7px 10px", fontSize: 12, color: T.text, whiteSpace: "nowrap", overflow: "hidden", textOverflow: "ellipsis", borderBottom: `1px solid ${T.border}` };
 
   return (
     <div>
@@ -326,15 +341,22 @@ function EVVoortgangTabel() {
       {evRows.length > 0 ? (
         <div style={{ overflowX: "auto" }}>
           <div style={{ maxHeight: 340, overflowY: "auto" }}>
-            <table style={{ width: "100%", borderCollapse: "collapse", minWidth: 600 }}>
+            <table style={{ width: totaal, borderCollapse: "collapse", tableLayout: "fixed" }}>
+              <colgroup>
+                {kolommen.map((k) => <col key={k.id} style={{ width: breedtes[k.id] }} />)}
+              </colgroup>
               <thead>
                 <tr>
-                  <th style={th}>Datum</th>
-                  {cats.map((c) => <th key={c.id} style={{ ...th, color: c.color }}>{c.naam}</th>)}
-                  <th style={th}>Netto Waarde</th>
-                  <th style={th}>Verschil</th>
-                  <th style={th}>Opmerkingen</th>
-                  {!locked && <th style={th}></th>}
+                  <th style={th}>Datum<span {...grip("datum")} /></th>
+                  {cats.map((c) => (
+                    <th key={c.id} style={{ ...th, color: c.color }}>
+                      {c.naam}<span {...grip(c.id)} />
+                    </th>
+                  ))}
+                  <th style={th}>Netto Waarde<span {...grip("nettoWaarde")} /></th>
+                  <th style={th}>Verschil<span {...grip("verschil")} /></th>
+                  <th style={th}>Opmerkingen<span {...grip("opmerkingen")} /></th>
+                  {!locked && <th style={th}><span {...grip("acties")} /></th>}
                 </tr>
               </thead>
               <tbody>
@@ -349,7 +371,8 @@ function EVVoortgangTabel() {
                       {cats.map((c) => <td key={c.id} style={{ ...td, color: c.color }}>{fmt(row[c.id] || 0)}</td>)}
                       <td style={{ ...td, fontWeight: 700, color: PURPLE_LIGHT }}>{fmt(row.nettoWaarde || 0)}</td>
                       <td style={{ ...td, fontWeight: 700, color: vColor }}>{vLabel}</td>
-                      <td style={{ ...td, color: T.muted }}>{row.opmerkingen || "—"}</td>
+                      {/* title: bij een smalle kolom is de tekst afgekapt */}
+                      <td style={{ ...td, color: T.muted }} title={row.opmerkingen || ""}>{row.opmerkingen || "—"}</td>
                       {!locked && (
                         <td style={td}>
                           <div style={{ display: "flex", gap: 6 }}>

frontend/src/pages/VoortgangTab.jsx

@@ -1,6 +1,7 @@
 import { useState } from "react";
 import { useApp } from "../context/AppContext.jsx";
 import { fmt, fmtDatum } from "../utils/format.js";
+import { useKolomBreedtes } from "../hooks/useKolomBreedtes.js";
 import { PURPLE, PURPLE_LIGHT, RED, GREEN } from "../constants/index.js";
 import { VCard, DonutChart, Overlay, ModalBox, ModalHeader, ModalFooter } from "../components/ui/index.jsx";
 
@@ -261,8 +262,21 @@ export default function VoortgangTab() {
     setData({ ...data, schuld: { ...schuld, schuldHistory: schuldHistory.filter((s) => s.datum !== datum) } });
   };
 
-  const th = { padding: "8px 10px", fontSize: 11, color: T.muted, fontWeight: 600, textAlign: "left", whiteSpace: "nowrap", background: T.card, position: "sticky", top: 0, zIndex: 1, borderBottom: `1px solid ${T.border}` };
-  const td = { padding: "7px 10px", fontSize: 12, color: T.text, borderBottom: `1px solid ${T.border}` };
+  // Kolommen in weergave-volgorde, met hun standaardbreedte.
+  const kolommen = [
+    { id: "datum",       breedte: 120 },
+    { id: "ev",          breedte: 175 },
+    { id: "schuld",      breedte: 160 },
+    { id: "netto",       breedte: 175 },
+    { id: "opmerkingen", breedte: 340 },
+    ...(!locked ? [{ id: "acties", breedte: 90 }] : []),
+  ];
+  const { breedtes, totaal, grip } = useKolomBreedtes("voortgang_kolom_breedtes", kolommen);
+
+  // overflow/ellipsis horen bij tableLayout "fixed": de inhoud rekt de kolom
+  // niet meer op, dus zonder afkappen loopt lange tekst de buurcel binnen.
+  const th = { padding: "8px 10px", fontSize: 11, color: T.muted, fontWeight: 600, textAlign: "left", whiteSpace: "nowrap", overflow: "hidden", textOverflow: "ellipsis", background: T.popupBg, position: "sticky", top: 0, zIndex: 1, borderBottom: `1px solid ${T.border}` };
+  const td = { padding: "7px 10px", fontSize: 12, color: T.text, whiteSpace: "nowrap", overflow: "hidden", textOverflow: "ellipsis", borderBottom: `1px solid ${T.border}` };
 
   return (
     <div>
@@ -396,15 +410,18 @@ export default function VoortgangTab() {
         )}
         {voortgangRows.length > 0 ? (
           <div style={{ overflowX: "auto" }}>
-            <table style={{ width: "100%", borderCollapse: "collapse", minWidth: 560 }}>
+            <table style={{ width: totaal, borderCollapse: "collapse", tableLayout: "fixed" }}>
+              <colgroup>
+                {kolommen.map((k) => <col key={k.id} style={{ width: breedtes[k.id] }} />)}
+              </colgroup>
               <thead>
                 <tr>
-                  <th style={th}>Datum</th>
-                  <th style={{ ...th, color: GREEN }}>Eigen Vermogen</th>
-                  <th style={{ ...th, color: RED }}>Schuld</th>
-                  <th style={{ ...th, color: PURPLE_LIGHT }}>Nettowaarde</th>
-                  <th style={th}>Opmerkingen</th>
-                  {!locked && <th style={th}></th>}
+                  <th style={th}>Datum<span {...grip("datum")} /></th>
+                  <th style={{ ...th, color: GREEN }}>Eigen Vermogen<span {...grip("ev")} /></th>
+                  <th style={{ ...th, color: RED }}>Schuld<span {...grip("schuld")} /></th>
+                  <th style={{ ...th, color: PURPLE_LIGHT }}>Nettowaarde<span {...grip("netto")} /></th>
+                  <th style={th}>Opmerkingen<span {...grip("opmerkingen")} /></th>
+                  {!locked && <th style={th}><span {...grip("acties")} /></th>}
                 </tr>
               </thead>
               <tbody>
@@ -414,7 +431,8 @@ export default function VoortgangTab() {
                     <td style={{ ...td, color: GREEN, fontWeight: 600 }}>{row.ev !== null ? fmt(row.ev) : "—"}</td>
                     <td style={{ ...td, color: RED, fontWeight: 600 }}>{row.schuld !== null ? fmt(row.schuld) : "—"}</td>
                     <td style={{ ...td, fontWeight: 700, color: row.netto !== null ? (row.netto >= 0 ? GREEN : RED) : T.muted }}>{row.netto !== null ? fmt(row.netto) : "—"}</td>
-                    <td style={{ ...td, color: T.muted }}>{row.opmerkingen || "—"}</td>
+                    {/* title: bij een smalle kolom is de tekst afgekapt */}
+                    <td style={{ ...td, color: T.muted }} title={row.opmerkingen || ""}>{row.opmerkingen || "—"}</td>
                     {!locked && (
                       <td style={{ ...td, whiteSpace: "nowrap" }}>
                         <button onClick={() => setEditRow(row)} style={{ padding: "2px 8px", background: `${PURPLE}22`, border: `1px solid ${PURPLE}44`, borderRadius: 6, color: PURPLE_LIGHT, cursor: "pointer", fontSize: 12, marginRight: 4 }}>✏️</button>

frontend/vite.config.js

@@ -41,6 +41,6 @@ export default defineConfig({
   define: {
     // VITE_API_URL wordt ingebakken tijdens build
     __API_URL__: JSON.stringify(process.env.VITE_API_URL ?? "/api"),
-    __APP_VERSION__: JSON.stringify(process.env.VITE_APP_VERSION ?? pkg.version),
+    __APP_VERSION__: JSON.stringify(process.env.VITE_APP_VERSION || pkg.version),
   },
 });

package.json

@@ -1,6 +1,6 @@
 {
   "name": "vibefinance",
-  "version": "0.1.9",
+  "version": "1.0.3",
   "description": "VibeFinance — persoonlijk vermogensbeheer",
   "private": true,
   "repository": "https://vibehoogie.duckdns.org/vibe/VibeFinance",

release.ps1

@@ -9,6 +9,16 @@
 #   .\release.ps1 -SkipTests   # sla de testsuite over (niet aanbevolen)
 #   .\release.ps1 -DryRun      # toon alle commando's zonder iets uit te voeren
 #   .\release.ps1 -Force       # sla conflictcontrole over, overschrijf tags
+#   .\release.ps1 -NoChangelog # publiceer bewust zonder release-notes
+#
+# Het script werkt zelf vier dingen bij, dus die hoef je niet met de hand te
+# doen: de changelog-kop `## [Niet vrijgegeven]` -> `## [x.x.x] - datum`, de
+# versie in frontend/package.json, de versiebadge in README.md, en ná het
+# publiceren de versie in de root package.json -> `x.x.(x+1)-dev`.
+#
+# LET OP bij -Force: dat verwijdert de bestaande tag lokaal en op origin, en
+# Gitea gooit de bijbehorende release daarmee weg. Onder -DryRun wordt dat
+# alleen gemeld (dat was eerder niet zo — zie stap 4).
 #
 # Vereisten:
 #   - Docker Desktop actief
@@ -16,6 +26,9 @@
 #   - docker buildx builder actief: docker buildx create --use
 #   - Git geinstalleerd en working directory is de repo root
 #   - root package.json bevat een schoon versienummer ZONDER -dev suffix
+#   - Changelog.md beschrijft deze versie, onder `## [Niet vrijgegeven]` of
+#     onder een kop `## [x.x.x]`; anders breekt het script af (-NoChangelog
+#     omzeilt dat)
 #   - GITEA_TOKEN in de omgeving (token met release-rechten) voor stap 5,
 #     de Gitea-release waar de update-melding in de app op afgaat
 
@@ -23,7 +36,10 @@ param(
     [switch]$NoBuild,
     [switch]$SkipTests,
     [switch]$DryRun,
-    [switch]$Force
+    [switch]$Force,
+    # Releasen zonder inhoudelijke release-notes. Zonder deze switch breekt het
+    # script af wanneer de changelog niets over deze versie zegt.
+    [switch]$NoChangelog
 )
 
 $ErrorActionPreference = "Stop"
@@ -75,41 +91,6 @@ if ($appVersion -match "-dev$") {
     exit 1
 }
 
-# ── Versie synchroniseren naar frontend/package.json ──────────────────────
-# Een droogloop schrijft hier niet: anders laat -DryRun een gewijzigd bestand
-# achter, en tagt de echte release daarna een vervuilde working tree.
-$frontendPkgPath = Join-Path $PSScriptRoot "frontend/package.json"
-$frontendPkg = Get-Content $frontendPkgPath -Raw | ConvertFrom-Json
-if ($frontendPkg.version -ne $appVersion) {
-    if ($DryRun) {
-        Write-Host "[DRY-RUN] Versie naar frontend synchroniseren: $($frontendPkg.version) -> $appVersion" -ForegroundColor Yellow
-    } else {
-        $frontendPkg.version = $appVersion
-        [System.IO.File]::WriteAllText($frontendPkgPath, ($frontendPkg | ConvertTo-Json -Depth 10))
-        Write-Host "Versie gesynchroniseerd naar frontend: $appVersion" -ForegroundColor Green
-    }
-}
-
-# ── Versiebadge in README.md ──────────────────────────────────────────────
-# Anders loopt die badge stil achter: hij stond drie releases achter voordat
-# dit erin zat, en het script kent het nummer toch al. Zelfde regel als
-# hierboven: een droogloop meldt het, maar schrijft niet.
-$readmePath = Join-Path $PSScriptRoot "README.md"
-if (Test-Path $readmePath) {
-    $readme  = [System.IO.File]::ReadAllText($readmePath)
-    $patroon = "badge/versie-[^-]+-"
-    $nieuw   = "badge/versie-$appVersion-"
-    $huidig  = [regex]::Match($readme, $patroon)
-    if ($huidig.Success -and $huidig.Value -ne $nieuw) {
-        if ($DryRun) {
-            Write-Host "[DRY-RUN] Versiebadge in README.md: $($huidig.Value) -> $nieuw" -ForegroundColor Yellow
-        } else {
-            [System.IO.File]::WriteAllText($readmePath, ($readme -replace $patroon, $nieuw))
-            Write-Host "Versiebadge in README.md bijgewerkt: $appVersion" -ForegroundColor Green
-        }
-    }
-}
-
 $gitTag = "$appVersion"
 
 # ── Registry tags (één image voor frontend + backend) ─────────────────────
@@ -151,12 +132,13 @@ function Write-Step {
     Write-Host "── $Label" -ForegroundColor Cyan
 }
 
-# Haalt de sectie van deze versie uit Changelog.md als release-notes.
-function Get-ChangelogSection {
-    param([string]$Version)
-    $path = Join-Path $PSScriptRoot "Changelog.md"
-    if (-not (Test-Path $path)) { return "" }
-    $lines  = Get-Content $path
+# Haalt de sectie van deze versie uit changelog-tekst. Werkt op een string en
+# niet op het bestand, zodat een droogloop kan valideren tegen de kop die hij
+# zou schrijven zonder die daadwerkelijk te schrijven.
+function Get-ChangelogSectionFromText {
+    param([string]$Text, [string]$Version)
+    if (-not $Text) { return "" }
+    $lines  = $Text -split "\r?\n"
     $start  = -1
     $needle = "^##\s*\[" + [regex]::Escape($Version) + "\]"
     for ($i = 0; $i -lt $lines.Count; $i++) {
@@ -172,6 +154,94 @@ function Get-ChangelogSection {
     return (($out -join "`n").Trim())
 }
 
+# ── Changelog-kop vrijgeven ───────────────────────────────────────────────
+# De release-notes komen uit de sectie `## [x.x.x]` in Changelog.md. Stond het
+# werk nog onder `## [Niet vrijgegeven]`, dan vond het script niets en werd stil
+# de placeholder "Release x.x.x" gepubliceerd — dat gebeurde bij 0.1.9 en 1.0.2,
+# en is achteraf alleen met een PATCH op de release te herstellen. Daarom zet het
+# script de kop nu zelf om, en breekt het af als er niets te melden valt.
+# Zelfde regel als bij de andere auto-updates: een droogloop meldt, maar schrijft
+# niet.
+$changelogPath = Join-Path $PSScriptRoot "Changelog.md"
+$nieuweKop     = "## [$appVersion] - $(Get-Date -Format 'yyyy-MM-dd')"
+$changelogTxt  = if (Test-Path $changelogPath) { [System.IO.File]::ReadAllText($changelogPath) } else { "" }
+
+$kopPatroon      = "(?m)^##\s*\[" + [regex]::Escape($appVersion) + "\]"
+$onderwegPatroon = "(?m)^##\s*\[\s*Niet vrijgegeven\s*\]\s*$"
+
+# Eerst alleen in het geheugen omzetten. Schrijven gebeurt na de controle
+# hieronder: bij een lege `[Niet vrijgegeven]`-sectie zou de kop anders al
+# vervangen zijn terwijl het script daarna afbreekt, en dan blijft er een
+# aangepaste changelog achter bij een release die niet doorging.
+$kopOmzetten = ($changelogTxt -notmatch $kopPatroon -and $changelogTxt -match $onderwegPatroon)
+if ($kopOmzetten) {
+    # $nieuweKop bevat geen '$', dus veilig als vervangingstekst.
+    $changelogTxt = [regex]::Replace($changelogTxt, $onderwegPatroon, $nieuweKop)
+}
+
+if (-not (Get-ChangelogSectionFromText $changelogTxt $appVersion) -and -not $NoChangelog) {
+    Write-Host ""
+    Write-Host "Changelog.md zegt niets over $appVersion." -ForegroundColor Red
+    Write-Host ""
+    Write-Host "Zonder notes komt er alleen de tekst 'Release $appVersion' in de Gitea-release," -ForegroundColor Yellow
+    Write-Host "en dat is achteraf alleen met een PATCH op de release te herstellen." -ForegroundColor Yellow
+    Write-Host ""
+    Write-Host "Zet je wijzigingen in Changelog.md onder een kop:" -ForegroundColor White
+    Write-Host "  ## [Niet vrijgegeven]" -ForegroundColor White
+    Write-Host "Die zet dit script bij de volgende run zelf om naar '$nieuweKop'." -ForegroundColor White
+    Write-Host ""
+    Write-Host "Bewust zonder release-notes publiceren? Draai met -NoChangelog." -ForegroundColor DarkGray
+    Write-Host ""
+    Write-Host "Er is niets gepubliceerd." -ForegroundColor DarkGray
+    exit 1
+}
+
+# De controle is doorstaan, dus nu pas schrijven.
+if ($kopOmzetten) {
+    if ($DryRun) {
+        Write-Host "[DRY-RUN] Changelog-kop vrijgeven: '## [Niet vrijgegeven]' -> '$nieuweKop'" -ForegroundColor Yellow
+    } else {
+        [System.IO.File]::WriteAllText($changelogPath, $changelogTxt)
+        Write-Host "Changelog-kop vrijgegeven: $nieuweKop" -ForegroundColor Green
+    }
+}
+
+# ── Versie synchroniseren naar frontend/package.json ──────────────────────
+# Staat na de changelog-controle: anders laat een afgebroken release wél een
+# gewijzigde working tree achter terwijl hij "niets gepubliceerd" meldt.
+# Een droogloop schrijft hier niet, om dezelfde reden.
+$frontendPkgPath = Join-Path $PSScriptRoot "frontend/package.json"
+$frontendPkg = Get-Content $frontendPkgPath -Raw | ConvertFrom-Json
+if ($frontendPkg.version -ne $appVersion) {
+    if ($DryRun) {
+        Write-Host "[DRY-RUN] Versie naar frontend synchroniseren: $($frontendPkg.version) -> $appVersion" -ForegroundColor Yellow
+    } else {
+        $frontendPkg.version = $appVersion
+        [System.IO.File]::WriteAllText($frontendPkgPath, ($frontendPkg | ConvertTo-Json -Depth 10))
+        Write-Host "Versie gesynchroniseerd naar frontend: $appVersion" -ForegroundColor Green
+    }
+}
+
+# ── Versiebadge in README.md ──────────────────────────────────────────────
+# Anders loopt die badge stil achter: hij stond drie releases achter voordat
+# dit erin zat, en het script kent het nummer toch al. Zelfde regel als
+# hierboven: een droogloop meldt het, maar schrijft niet.
+$readmePath = Join-Path $PSScriptRoot "README.md"
+if (Test-Path $readmePath) {
+    $readme  = [System.IO.File]::ReadAllText($readmePath)
+    $patroon = "badge/versie-[^-]+-"
+    $nieuw   = "badge/versie-$appVersion-"
+    $huidig  = [regex]::Match($readme, $patroon)
+    if ($huidig.Success -and $huidig.Value -ne $nieuw) {
+        if ($DryRun) {
+            Write-Host "[DRY-RUN] Versiebadge in README.md: $($huidig.Value) -> $nieuw" -ForegroundColor Yellow
+        } else {
+            [System.IO.File]::WriteAllText($readmePath, ($readme -replace $patroon, $nieuw))
+            Write-Host "Versiebadge in README.md bijgewerkt: $appVersion" -ForegroundColor Green
+        }
+    }
+}
+
 # ── Samenvatting ───────────────────────────────────────────────────────────
 Write-Host ""
 Write-Host "════════════════════════════════════════" -ForegroundColor Cyan
@@ -365,14 +435,24 @@ if (-not $NoBuild) {
 Write-Step "[4/5] Git-tag aanmaken en pushen"
 
 if ($Force) {
+    # LET OP: deze twee commando's gingen niet via Invoke-Cmd en hadden dus geen
+    # -DryRun-controle. Een `-DryRun -Force` verwijderde daardoor écht de tag,
+    # lokaal en op origin — en Gitea ruimt de release op zodra de tag verdwijnt.
+    # Zo is de release van 1.0.2 verloren gegaan.
+    if ($DryRun) {
+        Write-Host "[DRY-RUN] git tag -d $gitTag" -ForegroundColor Yellow
+        Write-Host "[DRY-RUN] git push origin :refs/tags/$gitTag" -ForegroundColor Yellow
+    } else {
         Write-Host "Bestaande lokale tag verwijderen (indien aanwezig)..." -ForegroundColor Yellow
         $ErrorActionPreference = "SilentlyContinue"
         git tag -d $gitTag 2>$null | Out-Null
         $ErrorActionPreference = "Stop"
         Write-Host "Bestaande remote tag verwijderen (indien aanwezig)..." -ForegroundColor Yellow
+        Write-Host "  Gitea verwijdert de bijbehorende release mee." -ForegroundColor DarkGray
         $ErrorActionPreference = "SilentlyContinue"
         git push origin ":refs/tags/$gitTag" 2>$null | Out-Null
         $ErrorActionPreference = "Stop"
+    }
 }
 
 Write-Host "Git-tag aanmaken: $gitTag" -ForegroundColor White
@@ -405,7 +485,10 @@ if (-not $releaseApi) {
     Write-Host "Geen GITEA_TOKEN in de omgeving — release overgeslagen." -ForegroundColor Yellow
     Write-Host "  Zonder release ziet de app geen update-melding voor $appVersion." -ForegroundColor DarkGray
 } else {
-    $notes = Get-ChangelogSection $appVersion
+    # Uit $changelogTxt en niet opnieuw van schijf: in een droogloop is de kop
+    # nog niet geschreven, en dan zou de payload hier de placeholder tonen —
+    # precies wat je met een droogloop wilt uitsluiten.
+    $notes = Get-ChangelogSectionFromText $changelogTxt $appVersion
     if (-not $notes) { $notes = "Release $appVersion" }
     $payload = @{
         tag_name   = $gitTag
@@ -451,6 +534,38 @@ Write-Host "  Git-tag: $gitTag -> origin" -ForegroundColor Green
 Write-Host "════════════════════════════════════════" -ForegroundColor Cyan
 Write-Host ""
 
+# ── Versie naar de volgende dev-cyclus ────────────────────────────────────
+# Was voorheen stap 4 met de hand. Gebeurt hier, ná het publiceren, zodat een
+# afgebroken release het versienummer niet vooruit zet. Bijkomend voordeel: de
+# `-dev` suffix laat dezelfde release niet nog eens draaien (de controle boven
+# in dit script weigert een `-dev` versie), dus een dubbele publicatie is
+# meteen uitgesloten. Wil je bewust opnieuw releasen, zet het nummer dan zelf
+# terug.
+if ($appVersion -match '^(\d+)\.(\d+)\.(\d+)$') {
+    $volgende = "{0}.{1}.{2}-dev" -f $Matches[1], $Matches[2], ([int]$Matches[3] + 1)
+    $rootPkgPath = Join-Path $PSScriptRoot "package.json"
+
+    if ($DryRun) {
+        Write-Host "[DRY-RUN] Versie in package.json: $appVersion -> $volgende" -ForegroundColor Yellow
+    } else {
+        # Gerichte tekstvervanging in plaats van ConvertTo-Json: dat zou het hele
+        # bestand herschrijven en de opmaak van de andere velden aantasten.
+        $rootTxt = [System.IO.File]::ReadAllText($rootPkgPath)
+        $treffer = [regex]::Match($rootTxt, '"version"\s*:\s*"' + [regex]::Escape($appVersion) + '"')
+        if ($treffer.Success) {
+            $rootTxt = $rootTxt.Remove($treffer.Index, $treffer.Length).Insert($treffer.Index, '"version": "' + $volgende + '"')
+            [System.IO.File]::WriteAllText($rootPkgPath, $rootTxt)
+            Write-Host "Versie in package.json naar de volgende cyclus: $volgende" -ForegroundColor Green
+            Write-Host "  Commit dit mee, samen met de changelog-kop en de README-badge." -ForegroundColor DarkGray
+            Write-Host ""
+        } else {
+            Write-Host "Kon '$appVersion' niet terugvinden in package.json — versie niet bijgewerkt." -ForegroundColor Yellow
+        }
+    }
+} else {
+    Write-Host "Versie '$appVersion' is geen x.y.z — volgende dev-versie niet automatisch gezet." -ForegroundColor Yellow
+}
+
 # Expliciete 0: anders erft de caller de exitcode van het laatste
 # docker-commando (bijv. de registry-check).
 exit 0

release.sh

@@ -9,6 +9,7 @@
 #   ./release.sh -SkipTests   # sla de testsuite over (niet aanbevolen)
 #   ./release.sh -DryRun      # toon alle commando's zonder iets uit te voeren
 #   ./release.sh -Force       # sla conflictcontrole over, overschrijf tags
+#   ./release.sh -NoChangelog # publiceer bewust zonder release-notes
 #
 # Combinaties:
 #   ./release.sh -Force -NoBuild