• Rust 50.8%
  • TypeScript 14.4%
  • Vue 12.9%
  • JavaScript 10.4%
  • Gherkin 6.7%
  • Other 4.7%
Find a file
Tim de Jager c949350905
feat(engine): projection in REDUCTIE: welke records meetellen volgt uit de effecten in de wet, stappen nemen uitvoer van een wet (#1903)
* 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 2839f6bda, 834b3b7e3, b447d4288 en 54ba2ec4d terug. Die haalden
state en steps uit de projectie; dat was niet gevraagd. De boom is weer
gelijk aan 542a47d9e.

Werkpakket: aansluiten-op-bronnen-chronolexografie

* refactor(engine): projectie zonder initial, stap-sleutel, fact, type en replaces

Wat geen scenario nodig had gaat uit de taal (schema v0.8.14, in plaats,
nog niet uitgebracht):

- state[].initial: een eigenschap begint bij de waarde van haar type
  (boolean false, number/amount 0, string/date null).
- steps[].key: de engine zoekt de sleutel onder de naam uit
  projection.key, als veld of uitvoer. De aanvraag speelt daardoor mee.
- steps[].fact: een stap op een artikel dat een feit vereist geldt voor
  dat feit; twee feiten weigert de engine.
- steps[].type: een derde segment in record (#BESCHIKKING), alleen nodig
  als het artikel meer dan een soort record geeft.
- $record.id, .basis en .type zijn niet meer zichtbaar voor stappen.
- replaces gaat op in revokes: een besluit in de plaats herroept het oude
  en telt zelf mee.

Alle scenario's houden hun uitkomst; de traces tonen nu de aanvraag en
"revokes" waar eerst "replaces" stond.

* test(engine): een stap met soort EXECUTOGRAM kiest ook geen feit uit twee

* test(engine): een datum in de staat moet als datum lezen

* refactor(engine): een stap past een wetsartikel toe in plaats van set

Wat een record met de staat doet, staat nu in een artikel van de wet. Een
stap noemt dat artikel (apply), verbindt zijn parameters met kale
verwijzingen naar $record.<veld> of $state.<eigenschap>, en zegt welke
uitvoer welke eigenschap zet (output). steps[].set is weg.

- Het artikel draait in de versie die gold op de dag van het record, met
  de pure ArticleEngine. Een artikel met een input (ook source.regulation),
  open termen of zonder uitvoer wordt geweigerd.
- Bij het afspelen controleert de engine of de verbindingen passen:
  bestaand artikel, elke parameter verbonden, bestaande velden, passende
  typen, bekende uitvoer. De loader controleert de vorm.
- De trace noemt per toegepast record het artikel.
- Fictieve artikelen 7 en 8 in test_chronicle_effects en 4 in
  test_parkeervergunning; de reducties verbinden alleen. Alle scenario's
  houden hun uitkomst.

* test(engine): een toegepast artikel met open termen wordt geweigerd

* refactor(engine): een stap bindt parameters en uitvoer op naam

parameters en output op een stap zijn alleen nog nodig waar namen
verschillen. Een parameter van het toegepaste artikel die de stap niet
noemt, krijgt het veld van het record of de eigenschap van de staat met
die naam; hebben beide die naam, of geen van beide, dan weigert de engine
de stap. Een uitvoer met de naam van een eigenschap zet die; een
vermelding in output gaat voor. Een stap die niets zet wordt geweigerd.

De fictieve artikelen en de reducties gebruiken dat waar de namen al
klopten. Alle scenario's houden hun uitkomst en hun trace.

* feat(engine): een antwoord leest alleen eigenschappen die de staat declareert

Een reductie met projectie die $state.<x> leest waar x geen eigenschap van
de staat is, laadde en faalde pas bij het afspelen (VariableNotFound). De
loader weigert dat nu, met de gedeclareerde eigenschappen in de melding,
in acties en in de parameters van een input. $state als geheel wordt ook
geweigerd, en $state in een artikel zonder projectie, tenzij het artikel
zelf iets met de naam state declareert.

* test(engine): een artikel zonder projectie mag een eigen input of uitvoer state lezen

* feat(engine): een cel geeft een antwoord uit een projectie via source.reduction

Bindt beleid een open begrip aan het antwoord van een cel, en heeft de
reductie van dat antwoord een projection, dan speelt de cel zijn kroniek
door die projectie met de parameters van de binding, in plaats van te
weigeren. De weigering blijft voor elk pad dat de kroniek omzeilt.

- Reader::run kiest evaluate_projection_with als de reductie een projectie
  heeft, met de Call van de cel.
- evaluate_projection_with en ProjectionOptions (call, trace);
  evaluate_projection roept het aan met een lege Call.
- chronicle_records zet de kroniek om in records; de BDD-runner gebruikt
  dezelfde functie.
- Scenario: fictief artikel 9 en fictief beleid binden het open begrip aan
  het antwoord van de cel; de uitkomst draait om na een gegrond bezwaar.

Overgenomen uit #1913 in kleinere vorm (zonder known_on en afschriften).

* test(cel): de kroniek als records houdt elk gram in volgorde

* refactor(engine): een stap neemt uitvoer van een wet met input en set

Een stap van een projectie is nu geschreven als een artikel: input met
source.regulation (uitvoer, parameters uit $record en $state) en set, dat
elke eigenschap aan een kale verwijzing koppelt ($<input>, $record.<veld>
of $state.<eigenschap>). apply, parameters, output en het binden op naam
zijn weg.

- De wet draait via de gewone weg, in de versie op de dag van het record,
  en haar trace hangt onder de APPLY-knoop van het record.
- Het aangeroepen artikel moet zuiver zijn: geen input, geen open termen.
- De loader weigert een andere bron dan source.regulation, en in set een
  operatie of een letterlijke waarde.
- Reducties, unit-tests, conformance en docs omgezet; alle scenario's
  houden hun uitkomst en hun trace.

* refactor(engine): een stap geeft zijn eigenschappen waarden met actions

set op een stap is vervangen door actions, dezelfde vorm als bij een
artikel: output noemt een eigenschap van de staat, value is een kale
verwijzing ($<input>, $record.<veld> of $state.<eigenschap>). Schema,
model, loader, fixtures, conformance en docs omgezet. De loader weigert
een actie met een operatie, een eigenschap die twee keer een waarde
krijgt, en een waarde die geen kale verwijzing is. Alle scenario's houden
hun uitkomst en hun trace.

* test(engine): een input van een stap zonder regulation of zonder output wordt geweigerd

* refactor(engine): eerst bepalen welke records meetellen, dan de stappen

De projectie speelt niet meer terug. Fase 1 bepaalt declaratief welke
records meetellen: een record telt mee tenzij een later record dat zelf
meetelt het herroept (met herleving). Dat hangt niet van de staat af,
want when leest alleen uitvoer van hetzelfde besluit, en volgt uit één
pass van achter naar voren. Fase 2 vouwt de stappen van de records die
meetellen in volgorde.

- Een stap mag een parameter van de vraag doorgeven ($peildatum) aan de
  wet die hij aanroept; scenario met fictieve test_bedrijfsvergunning.
- Trace: COUNTS (per record telt mee / herroepen door / alleen effecten)
  en FOLD (de toegepaste stappen met de aanroepen eronder).
- De differentiële test vergelijkt met een brute-force orakel dat elke
  toewijzing aan de definitie toetst.
- Schema, docs en BDD-traces beschrijven herroepen declaratief.

* test(engine): een parameter van de vraag van het verkeerde type wordt geweigerd

* docs: herroepen declaratief beschreven en vier open punten bij de projectie
2026-11-07 12:30:36 +00:00
.claude feat(engine): projection in REDUCTIE: welke records meetellen volgt uit de effecten in de wet, stappen nemen uitvoer van een wet (#1903) 2026-11-07 12:30:36 +00:00
.github feat(engine): projection in REDUCTIE: welke records meetellen volgt uit de effecten in de wet, stappen nemen uitvoer van een wet (#1903) 2026-11-07 12:30:36 +00:00
bdd feat(engine): projection in REDUCTIE: welke records meetellen volgt uit de effecten in de wet, stappen nemen uitvoer van een wet (#1903) 2026-11-07 12:30:36 +00:00
conformance feat(engine): projection in REDUCTIE: welke records meetellen volgt uit de effecten in de wet, stappen nemen uitvoer van een wet (#1903) 2026-11-07 12:30:36 +00:00
corpus docs: open punt over gevraagde beschikking uit requests (#1883) 2026-11-02 15:53:05 +00:00
corpus-poc fix(corpus): Awb 4:13 in de Napp-poc lezen als buitengrens, niet als termijn 2026-10-01 10:39:05 +02:00
deploy/nginx fix: security-headers en een csp die er echt is, op elk domein (#1177) 2026-08-07 19:09:11 +02:00
dev refactor(dev): fold dev-frontend into just dev, drop the backend-only stack (#1667) 2026-10-02 11:19:09 +00:00
docs feat(engine): projection in REDUCTIE: welke records meetellen volgt uit de effecten in de wet, stappen nemen uitvoer van een wet (#1903) 2026-11-07 12:30:36 +00:00
frontend feat(engine): projection in REDUCTIE: welke records meetellen volgt uit de effecten in de wet, stappen nemen uitvoer van een wet (#1903) 2026-11-07 12:30:36 +00:00
frontend-demo build(deps): ontwerpsysteem @nldd/design-system van 0.9 naar 0.16 (#1906) 2026-11-05 19:04:50 +00:00
frontend-lawmaking build(deps): ontwerpsysteem @nldd/design-system van 0.9 naar 0.16 (#1906) 2026-11-05 19:04:50 +00:00
frontend-poc-napp build(deps): ontwerpsysteem @nldd/design-system van 0.9 naar 0.16 (#1906) 2026-11-05 19:04:50 +00:00
frontend-poc-nieuwkomersbekostiging build(deps): ontwerpsysteem @nldd/design-system van 0.9 naar 0.16 (#1906) 2026-11-05 19:04:50 +00:00
frontend-poc-portal build(deps): ontwerpsysteem @nldd/design-system van 0.9 naar 0.16 (#1906) 2026-11-05 19:04:50 +00:00
frontend-poc-terugbetaalregimes build(deps): ontwerpsysteem @nldd/design-system van 0.9 naar 0.16 (#1906) 2026-11-05 19:04:50 +00:00
LICENSES feat(docs): jurix-paper over uitleg aan burgers als research-paper (#1736) 2026-10-16 15:18:27 +00:00
packages feat(engine): projection in REDUCTIE: welke records meetellen volgt uit de effecten in de wet, stappen nemen uitvoer van een wet (#1903) 2026-11-07 12:30:36 +00:00
pocs chore(engine): geen versiegedrag in de engine; verwijzingen naar opgegane RFC's omgezet (#1798) 2026-11-02 08:09:16 +00:00
schema feat(engine): projection in REDUCTIE: welke records meetellen volgt uit de effecten in de wet, stappen nemen uitvoer van een wet (#1903) 2026-11-07 12:30:36 +00:00
script feat(engine): projection in REDUCTIE: welke records meetellen volgt uit de effecten in de wet, stappen nemen uitvoer van een wet (#1903) 2026-11-07 12:30:36 +00:00
tests/fixtures/federation feat(schema): v0.5.0 operation set with engine, corpus migration, and WOO (#312) 2026-03-30 21:59:09 +02:00
.dockerignore refactor(lawmaking): de app in TypeScript, opgezet zoals create-vue (#1757) 2026-10-21 08:04:10 +00:00
.env.example feat: verrijken kan ook met VLAM, via de ZAD-dienst vlam (#1879) 2026-11-03 08:30:50 +00:00
.env.poc.example refactor: de poc-app heet chronolexografie (#1742) 2026-10-19 09:39:34 +00:00
.env.sso-local.example fix(editor): allow Safari for local SSO dev (#782) 2026-06-10 14:26:11 +02:00
.gitignore feat: chronolexografie-poc laadt de NAPP-bron live via het portaal (#1775) 2026-10-21 13:44:21 +00:00
.npmrc refactor(frontend): extract shared auth/color-scheme/fetch package (#860) 2026-06-26 14:04:30 +02:00
.pre-commit-config.yaml docs: skill om een slapende preview te wekken (#1904) 2026-11-05 09:58:55 +00:00
.yamllint feat(frontend): portaal met proof-of-concepts achter een wachtwoord (#1432) 2026-09-15 15:43:56 +02:00
AGENTS.md docs: skill om een slapende preview te wekken (#1904) 2026-11-05 09:58:55 +00:00
CLAUDE.md chore(dev): instructies voor agents staan in AGENTS.md (#1541) 2026-09-23 12:03:48 +00:00
CONTRIBUTING.md feat(docs): werkpakketten krijgen een slug, en elke pull request noemt er een (#1485) 2026-09-17 15:07:43 +02:00
corpus-registry.yaml feat(editor): opt-in local test corpus trajecten (#832) 2026-06-18 18:12:12 +02:00
deny.toml feat(editor): notities inchecken via PR (federated schrijfpad) (#652) 2026-05-19 21:27:24 +02:00
docker-compose.dev.yml feat: verrijken kan ook met VLAM, via de ZAD-dienst vlam (#1879) 2026-11-03 08:30:50 +00:00
Justfile feat(engine): projection in REDUCTIE: welke records meetellen volgt uit de effecten in de wet, stappen nemen uitvoer van een wet (#1903) 2026-11-07 12:30:36 +00:00
LICENSE Add license 2025-11-10 14:14:42 +01:00
package-lock.json build(deps): ontwerpsysteem @nldd/design-system van 0.9 naar 0.16 (#1906) 2026-11-05 19:04:50 +00:00
package.json feat: de chronolexografie-poc draait helemaal in de browser (#1774) 2026-10-21 11:26:52 +00:00
publiccode.yml feat(demo): de demo en de rondleiding in het Frans (#1842) 2026-10-28 17:45:34 +00:00
README.md chore: repo-verwijzingen naar NederlandseDigitaleDienst (#1708) 2026-10-14 15:59:32 +00:00
REUSE.toml test(pipeline): opgenomen agent-uitvoer vastgelegd per provider (#1896) 2026-11-04 16:33:31 +00:00
REVIEW.md test: guard tegen tests die nergens in CI draaien (#1884) 2026-11-03 15:40:34 +00:00
rust-toolchain.toml chore(ci): consolidate pipeline Dockerfiles, align Rust base images, matrix twin CI jobs (#793) 2026-06-15 10:59:32 +02:00

regelrecht

CI License: EUPL-1.2 Rust 2021 Mutation Testing Docs

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.yaml and 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.

Run just dev-setup once. It does three things:

  1. Points every worktree at one shared target dir — a new worktree reuses the already-built dependency graph instead of cold-building ~600 crates.
  2. 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-setup detects this and relocates the target to ~/.cache/regelrecht/ (local disk). This is usually the single biggest win.
  3. Installs mold + sccache. mold (wired into packages/.cargo/config.toml) speeds up linking and is a hard requirement for the dev recipes; sccache is 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.

License

EUPL-1.2