- Rust 50.8%
- TypeScript 14.4%
- Vue 12.9%
- JavaScript 10.4%
- Gherkin 6.7%
- Other 4.7%
* feat(schema): een besluit zegt wat het met een ander besluit doet, de cel speelt het af
Een besluit zegt in de wet wat het met een ander besluit doet, en de cel
speelt dat af. Schema v0.8.14 geeft een besluit in de lijstvorm van
`produces` het veld `effects`: `revokes` of `replaces`, met de parameter
die het andere besluit noemt (Awb 7:11 lid 2). De engine weigert een
effect op een indiening of op een parameter die het artikel niet kent.
regelrecht_cel::effects::counting speelt de effecten in de volgorde van
vastleggen: een besluit telt mee tenzij een later besluit dat zelf
meetelt het herroept of vervangt. Wordt een intrekking herroepen, dan
telt het ingetrokken besluit weer.
De cel krijgt een eigen BDD-afdeling (packages/cel/bdd), met kroniekstappen
bovenop de canonieke grammatica maar buiten bdd/grammar.yaml. De generator
van de engine leest nu een basis plus een uitbreiding; de runner in
packages/cel deelt world, dispatch en helpers met die van de engine.
Vijf scenario's over een fictieve parkeerkaart: verlening, herroeping,
een besluit in de plaats (twee richtingen) en een herroepen intrekking.
Werkpakket: aansluiten-op-bronnen-chronolexografie
* fix(schema): het effect van een besluit staat inline, zonder eigen definitie
De schemapagina gaf geen sectie voor een losse definitie decisionEffect,
zodat de link naar #decision-effect doodliep (Docs accessibility gate).
* feat(schema): een effect geldt alleen bij de uitkomst die het noemt
Met `when` hangt een effect af van een boolean-output van hetzelfde
besluit: een beslissing op bezwaar herroept het bestreden besluit alleen
als het bezwaar gegrond is. De loader weigert een `when` op een output die
het besluit niet heeft of die geen boolean is; de cel leest bij het
afspelen de vastgelegde uitkomst. Artikel 2 van de fixture-wet leidt
`herroepen` af uit de bevinding `bezwaar_gegrond`, en een nieuwe stap
geeft die bevinding mee bij het beslissen op een indiening.
* feat(engine): een reductie speelt de kroniek vooruit af en spoelt terug bij herroeping
Een REDUCTIE krijgt `projection` (schema v0.8.14): een staat van benoemde
eigenschappen met beginwaarden, en per artikel waarop een record rust een
stap die eigenschappen zet uit `$state` en `$record`. De execution
antwoordt uit de eindstaat. LawExecutionService::evaluate_projection
speelt de records in volgorde van vastleggen af. Maakt een effect uit
`produces[].effects` van een record dat meetelt een eerder, al toegepast
record ongedaan, dan speelt de engine opnieuw af vanaf het begin zonder
dat record. Een record blijft overgeslagen zolang een record dat het
ongedaan maakt meetelt; valt het laatste weg, dan telt het weer. De
engine houdt per eigenschap het laatst zettende record bij en elke stap
(toegepast, overgeslagen, teruggespoeld), in de uitkomst en als
PROJECTION-knoop in de trace.
cel/src/effects.rs vervalt; de cel geeft zijn kroniek door. De BDD-suite
van de cel legt ook feiten vast (executogram, fictief artikel 5) en toetst
de afspeling als tabel, met Tims reeks, herleving en een besluit dat twee
keer herroepen wordt.
Wordt een record vervangen, dan gaat wat het ongedaan maakte over op de
vervanger; wordt het herroepen, dan vervalt dat. Een twee keer vervangen
besluit blijft zo vervangen.
* fix(engine): review op de projectie verwerkt
- Een vervangen record maakt niets meer ongedaan, zoals een herroepen
record; geen overdracht naar de vervanger meer (Awb-semantiek hoort in
de wet, en de uitkomst hing af van de verwerkingsvolgorde).
- Een differentiële test vergelijkt terugspoelen over 500 gegenereerde
kronieken met één achterwaartse pass.
- Records van na de rekendatum spelen niet mee.
- Eén versie van de reductie, die op de rekendatum, voor de hele
afspeling; effecten blijven uit de wet op de dag van vastleggen.
- Een record van een soort die zijn artikel niet produceert wordt
geweigerd in plaats van stil overgeslagen.
- De loader weigert twee stappen voor dezelfde records en een letterlijke
waarde van het verkeerde type.
- Herroepen is ex tunc; ex nunc gaat via een stap met een datum.
* fix: bevindingen van de ralph-review verwerkt
Vijftien bevindingen uit vijf reviewrondes. De engine weigert een
reductie met een projectie op elk pad behalve evaluate_projection (ook via
een ander artikel, een andere reductie of een eigen state), en geeft de
gespeelde staat door aan artikelen van dezelfde reductie. Een berekende
waarde van een stap moet het type van de eigenschap hebben. Docs, schema en
de open vragen van de chronolexografie volgen.
* test(engine): mutanten in de projectie gevangen
Tests voor een lege kroniek, de oorzaak van elke terugspoeling in de
trace, stappen voor verschillende soorten records onder een artikel, en
een datum als eigenschap. Twee voorwaarden die altijd gelijk waren,
vereenvoudigd: een toegepast doel had nog geen ongedaanmaker, en binnen
de afspeling is de gespeelde staat de enige.
* feat(engine): een projectie speelt alleen de records van één sleutel af
`projection.key` noemt een parameter van de reductie (bijvoorbeeld de
aanvrager), `steps[].key` het veld van een record dat de sleutel draagt.
Een record hoort bij de sleutel als dat veld de gevraagde waarde heeft,
of als het verwijst naar een record dat erbij hoort (refers_to, of een
veld dat een effect van zijn artikel noemt), transitief. Een verwijzend
record met een eigen, afwijkende sleutel wordt uitgesloten en is in de
trace zichtbaar als `excluded`; een record zonder sleutelveld komt via
de verwijzing mee. Records komen nooit mee via waar zij zelf naar
verwijzen. Het terugspoelen draait op de partitie; een effect op een
record van een andere partitie geldt daar niet.
De BDD-suite van de cel gebruikt `aanvrager` als sleutel, met scenario's
voor twee aanvragers in één kroniek en een uitgesloten record.
* fix(engine): een record van een ander telt mee voor zijn effecten
Een record dat naar de partitie verwijst maar een eigen sleutel met een
andere waarde draagt, werd uitgesloten, en daarmee ook wat het ongedaan
maakte of verving. Dat hangt dan af van de vraag: een besluit dat een
parkeervergunning naar een nieuw kenteken omzet, vervangt de vergunning
per bewoner wel en per oud kenteken niet. De wet zegt één keer wat een
besluit met een ander doet.
Zo'n record telt nu mee voor zijn effecten (ook terugspoelen), maar zijn
stap wordt niet op de staat toegepast; de trace toont het als 'effects
only' met de reden. Een record zonder sleutel dat alleen naar zulke
records verwijst, zoals de herroeping van de omzetting, telt op dezelfde
manier mee, zodat wat die omzetting verving weer meetelt. De partitie
blijft de records die vanaf de sleutel bereikbaar zijn.
Fictieve testwet test_parkeervergunning met een reductie per kenteken en
een per bewoner; drie scenario's en drie unittests. De beschrijving van
projection.key in schema v0.8.14 en de docs volgen.
Werkpakket: aansluiten-op-bronnen-chronolexografie
* feat(engine): een reductie met projectie leest de records die gelden, zonder eigen staat
De projectie houdt alleen nog een sleutel (projection.key, of
projection: {}). state, steps, set en initial zijn weg. De engine speelt
de kroniek af en spoelt terug zoals eerst, en geeft de invoer van de
reductie die besluiten of feiten leest (source.decisions, source.facts)
alleen de records die gelden, als rijen met hun velden en uitvoer en id,
basis, type, recorded_on en refers_to. De execution rekent het antwoord
uit met de gewone bewerkingen.
Een record hoort bij de sleutel als het die waarde onder dezelfde naam
draagt; een record van een ander telt mee voor zijn effecten maar is geen
rij. De trace toont toegepast, overgeslagen, alleen effecten en
terugspoelen, en de records die gelden.
De testreducties lezen nu rijen. De volgorde van inleveren en opnieuw
verlenen leest de reductie uit recorded_on; Tims reeks legt daarom elk
record op een eigen dag vast. Een nieuw scenario: een bewoner met twee
vergunningen voor twee auto's.
Werkpakket: aansluiten-op-bronnen-chronolexografie
* test(engine): mutanten in de rijen van de projectie gevangen
Een test dat een invoer van feiten alleen de executogrammen van zijn
artikel en feit leest, en de naam van de bron in de trace. Het
commentaar bij MachineReadable.projection volgt het nieuwe model.
Werkpakket: aansluiten-op-bronnen-chronolexografie
* test(engine): een sleutel van type datum in de projectie
Vangt de mutant die de datumarm uit fits_type haalt.
Werkpakket: aansluiten-op-bronnen-chronolexografie
* docs(engine): commentaar bij de projectiecontrole volgt het nieuwe model
Reviewbevinding: de controle zegt niet meer dat een projectie een eigen
staat zet.
Werkpakket: aansluiten-op-bronnen-chronolexografie
* fix(engine): terug naar de projectie met staat en stappen
Draait
|
||
|---|---|---|
| .claude | ||
| .github | ||
| bdd | ||
| conformance | ||
| corpus | ||
| corpus-poc | ||
| deploy/nginx | ||
| dev | ||
| docs | ||
| frontend | ||
| frontend-demo | ||
| frontend-lawmaking | ||
| frontend-poc-napp | ||
| frontend-poc-nieuwkomersbekostiging | ||
| frontend-poc-portal | ||
| frontend-poc-terugbetaalregimes | ||
| LICENSES | ||
| packages | ||
| pocs | ||
| schema | ||
| script | ||
| tests/fixtures/federation | ||
| .dockerignore | ||
| .env.example | ||
| .env.poc.example | ||
| .env.sso-local.example | ||
| .gitignore | ||
| .npmrc | ||
| .pre-commit-config.yaml | ||
| .yamllint | ||
| AGENTS.md | ||
| CLAUDE.md | ||
| CONTRIBUTING.md | ||
| corpus-registry.yaml | ||
| deny.toml | ||
| docker-compose.dev.yml | ||
| Justfile | ||
| LICENSE | ||
| package-lock.json | ||
| package.json | ||
| publiccode.yml | ||
| README.md | ||
| REUSE.toml | ||
| REVIEW.md | ||
| rust-toolchain.toml | ||
regelrecht
Machine-readable Dutch law execution. regelrecht takes legal texts, encodes them as structured YAML, and runs them as deterministic decision logic.
What does it do
- The engine takes a regulation and a set of inputs, evaluates the decision logic, and returns a result with a full explanation trail
- Laws are tested against real-world scenarios using BDD (Gherkin) tests, many derived from legislative explanatory memoranda. The vocabulary those scenarios speak lives in
bdd/grammar.yamland every engine's step bindings are generated from it - A harvester downloads and tracks Dutch legislation from the official BWB repository
- Regulations can be edited through a web UI with live execution preview
Components
Rust packages
| Package | Description |
|---|---|
| packages/engine/ | Law execution engine (also compiles to WASM) |
| packages/law-model/ | The Rust representation of the law format, conforming to schema/ |
| packages/harvester/ | Downloads Dutch legislation from BWB |
| packages/pipeline/ | PostgreSQL job queue for law processing |
| packages/admin/ | Harvester-admin API; its dashboard UI lives in the editor |
| packages/editor-api/ | Backend API for the law editor |
| packages/corpus/ | Git integration for the regulation corpus |
| packages/auth/ | Shared OIDC/SSO authentication |
| packages/github/ | Shared GitHub REST client |
| packages/shared/ | Shared domain types across crates |
| packages/arch-extract/ | Derives the architecture model from the code (just arch-explore) |
| packages/tui/ | Terminal dashboard (Ratatui) |
Frontends and sites
| Directory | Description |
|---|---|
| frontend/ | Law editor UI (Vue 3 + Vite) |
| frontend-lawmaking/ | Law-making process visualization (Vue 3 + Vite) |
| packages/frontend-shared/ | Shared frontend primitives (auth, colour scheme, API fetch) |
| docs/ | Astro site: landing page + documentation |
Data and testing
| Directory | Description |
|---|---|
| corpus/regulation/ | A working set of ruleworks, some of them synthetic (test_*) |
| schema/ | Versioned JSON schema for the law format (schema/latest points at the current version) |
| bdd/ | The Gherkin vocabulary (grammar.yaml) and the engine-conformance suite |
corpus/regulation/**/scenarios/ |
Law-validation scenarios, next to the law they test |
| packages/grafana/ | Grafana monitoring dashboards (provisioning, not a crate) |
The full corpus lives elsewhere
corpus/regulation/ in this repo holds a couple of dozen laws: the ones the
tests and BDD scenarios run against, plus synthetic test_* laws for the
conformance suite. The harvested body of Dutch legislation is far too large to
carry here and lives in its own repository:
MinBZK/regelrecht-corpus — currently some 22,000 YAML files under regulation/nl.
Which branch you want depends on what you are after:
| Branch | What is on it |
|---|---|
development |
The working branch, and what corpus-registry.yaml points this repo at. Harvested laws land here first |
main |
Only moves when development is merged into it, so it lags |
enrich/* |
Output of the enrichment runs, one branch per enricher (enrich/claude, enrich/opencode) |
Short-lived prN and editor/* branches belong to preview deployments and
editor sessions; they are not meant to be read directly.
Deployed services
| Service | URL |
|---|---|
| Editor | https://editor.regelrecht.rijks.app |
| Landing page | https://regelrecht.rijks.app |
| Documentation | https://docs.regelrecht.rijks.app |
| Law-making | https://lawmaking.regelrecht.rijks.app |
| Harvester admin | https://harvester-admin.regelrecht.rijks.app |
| Grafana | https://grafana.regelrecht.rijks.app |
The pipeline API and the harvester and enrich workers deploy alongside these but have no web UI of their own.
A PR gets a preview environment once it carries the deploy:preview label; taking the label off, or closing the PR, cleans it up again.
Getting started
Prerequisites: Rust (rustup installs the version pinned in
rust-toolchain.toml) and just. The dev stacks
below also need Docker and Node.js, and on x86_64 Linux mold.
just check # everything CI runs (format, lint, build, validate, tests)
just test # every Rust test in the workspace
just test-no-docker # the same, minus the container-backed suites
just bdd # the BDD suites: law scenarios and engine conformance
just test and just check start PostgreSQL containers for the crates that
need one, so they want a Docker daemon. Without one, just test-no-docker
covers everything else. just bdd runs separately: it executes against the real
corpus and is deliberately not part of just test.
Faster builds (recommended)
Run just dev-setup once. It does three things:
- Points every worktree at one shared target dir — a new worktree reuses the already-built dependency graph instead of cold-building ~600 crates.
- Puts that target on fast local storage when the repo lives on a slow mount.
A Rust build writes tens of thousands of small files; on a 9p/NFS/SMB mount
(e.g. a WSL2 or Docker-Desktop dev container where the repo is a Windows
drive) that I/O dominates build time — often more than everything else
combined.
dev-setupdetects this and relocates the target to~/.cache/regelrecht/(local disk). This is usually the single biggest win. - Installs mold +
sccache. mold (wired intopackages/.cargo/config.toml) speeds up linking and is a hard requirement for the dev recipes;sccacheis installed but left off locally.
sccache is disabled locally because it requires CARGO_INCREMENTAL=0 and so
disables incremental compilation, which slows every rebuild after an edit.
Enable it only for cold or flag-varying builds:
export RUSTC_WRAPPER=sccache CARGO_INCREMENTAL=0
CI uses both mold and sccache (see .github/workflows/ci.yml).
Running a dev stack
just dev # editor (7300) + lawmaking (7500), editor-api on 8000, admin API on 8001
just dev editor # just the editor (editor-api + editor UI + DB)
just dev admin # just the admin API + DB
just dev lawmaking # just the lawmaking UI (no backend)
just dev-down # stop it
just dev starts only what the chosen app needs: no Grafana, Prometheus or
workers. The editor runs with real SSO against the central Keycloak, so it
needs .env.sso-local (copy .env.sso-local.example).
Vite ports default to 7300/7500 (overridable via EDITOR_PORT /
LAWMAKING_PORT). When a native backend can't reach Postgres
on localhost (e.g. a WSL2/Docker-Desktop dev container, where Postgres is
published on the Docker host), point it at host.docker.internal: for the
admin API set DB_HOST=host.docker.internal in .env; for the
editor that host comes from DATABASE_URL in .env.sso-local (the
.env.sso-local.example already uses host.docker.internal).
See the docs site for full development instructions.