= Beispieldaten: Landesrecht weiterer Länder
Matthias Andreas Benkard
// SPDX-FileCopyrightText: 2020 Matthias Andreas Benkard <code@mail.matthias.benkard.de>
// SPDX-License-Identifier: AGPL-3.0-or-later

Ergänzend zum bayerischen Belegfall (`BayJG/`) sind hier Änderungsgesetze und
Änderungsverordnungen aus dem Landesrecht weiterer Länder gesammelt. Sie dienen als
Kandidaten für künftige Ertüchtigungswellen und decken Konventionen ab, die im Bundes- und
im bayerischen Recht so nicht vorkommen.

WICHTIG: Anders als Bayern (Art./§-Inversion) gliedern alle übrigen Länder ihre Stammgesetze
in *§* (wie der Bund) mit `Artikel N` als Änderungsgesetz-Container. Die neuen Testdimensionen
liegen daher im *PDF-Layout* und in *Befehlsidiom-Varianten*, nicht in der Gliederung.

Zu jedem Beispiel gehört ein *Änderungsgesetz*; wo auch die *konsolidierte Stammfassung* vorliegt
(nötig für einen Akzeptanztest wie bei BayJG), ist der Fall bis zur Anwendung belegt. Die
Stammfassung kommt je Land aus dem Portal des Landes oder als handgepflegter Klartext analog zu
`BayJG/BayJG-alt.txt`; welcher Weg trägt, steht unter „Beschaffung der Stammfassungen“.

== Übersicht

[cols="1,3,3",options="header"]
|===
|Land |Datei / Fundstelle |Besonderheit für das Werkzeug

|Berlin
|`Berlin/GVBl-2026-17_ASOG-LAF-AendG.pdf` — GVBl. für Berlin Nr. 17 vom 11.06.2026, S. 234
(Gesetz zur Änderung des ASOG und des LAF-Errichtungsgesetzes vom 03.06.2026)
|*Zweispaltiges Layout* (Herausgabe über Wolters Kluwer). Der Spaltenspike ist erledigt: Die
Reihenfolge des Inhaltsstroms *ist* bereits die Lesereihenfolge, eine koordinatenbasierte
Spaltenerkennung ist nicht nötig. Verbleibende Layout-Eigenheit sind ganzseitenbreite Rahmen
(Titelblock, laufender Seitenkopf), die an falscher Stelle im Strom stehen — der Seitenkopf wird
herausgeschnitten, der Titelblock landet weiterhin mitten im Text. Tiefe Verschachtelung
a)/aa)/bb)/cc); Artikel 1 ändert eine *Anlage*, deren Einheiten als *Überschriften* („Nummer 6")
statt als Aufzählungsmarken gesetzt sind. Artikel 2 (LAF-Errichtungsgesetz) ist ein voller
Akzeptanzfall; das Portal setzt die amtlichen *Satznummern als angeklebte Ziffern* („(2) 1Gegen …").

|Schleswig-Holstein
|`SchleswigHolstein/GVOBl-2026-27_Kommunalrecht-AendG.pdf` — GVOBl. Schl.-H. 2026/27 vom
30.03.2026 (Gesetz zur Änderung des Gesetzes zur Änderung kommunalrechtlicher Vorschriften)
|Neues Neufassungsidiom „§ 34a Absatz 1 *erhält folgende Fassung*:" (statt „wird wie folgt
gefasst"); *hochgestellte Fußnotenmarker an Artikel-Überschriften* („Artikel 1 ¹)"); Meta-
Änderung an einem anderen Änderungsgesetz („Artikel 5 wird gestrichen"). Voller Akzeptanzfall für
*zwei* Stammgesetze zugleich (Gemeindeordnung, Kreisordnung); der Portalsatz trennt die
*Sachnummer* ab („§ 57 c") und setzt im Klammerzusatz einen *Bindestrich* statt des
Gedankenstrichs.

|Hessen
|`Hessen/GVBl-2026-05_11-AendVO-verkehrsrechtl-Zustaendigkeiten.pdf` — GVBl. Hessen Nr. 5 vom
03.02.2026 (Elfte Verordnung zur Änderung der Verordnung zur Bestimmung verkehrsrechtlicher
Zuständigkeiten)
|*Sperrsatz* in Datums- und Signaturzeilen („3 . F e bru a r 2 02 6", „Der Mi n is t er pr
äs i d e nt") — er trifft, anders als erwartet, nur den Unterschriftenblock und keinen Befehl;
*abgekürztes „Abs."/„Nr." im §-Kontext*; die *FFN-Fußnote der Überschrift* („* Ändert FFN 61-60")
steht am Seitenfuß mitten zwischen zwei Gliederungspunkten. Die Stammverordnung führt *keine
Paragraphenüberschriften* und gliedert sich in *ausgeschriebene Ordinalzahlen* („Erster Teil").
Voller Akzeptanzfall, Stammfassung `Hessen/StVRZustV-alt.txt`, Prüfmaßstab
`Hessen/StVRZustV-neu.txt`.

|Niedersachsen
|`Niedersachsen/Nds-GVBl-2026-10_ELER-Foerdergesetz-AendG.pdf` — Nds. GVBl. 2026 Nr. 10 vom
04.02.2026 (Gesetz zur Änderung des Niedersächsischen ELER-Fördergesetzes) +
`Nds-GVBl-2026-23_BeurtVO-Steuer_amtliche-Satznummern.pdf` — Nr. 23 vom 18.03.2026
|*Hochgestellte amtliche Satznummern ¹²³* wie Bayern, aber im *§-Modus* (nicht invertiert) →
das bayerische Superskriptmodul wäre wiederverwendbar. Nr. 23 (Verordnung) zeigt die
Satznummern deutlich; Nr. 10 ist das eigentliche Änderungsgesetz (Idiom „Absatz 1 erhält
folgende Fassung"). Saubere einspaltige PDFs über die stabile API `verkuendung-niedersachsen.de`.

|Baden-Württemberg
|`BadenWuerttemberg/GBl-2026-26_KommunalwahlO-AendVO.pdf` — GBl. BW 2026 Nr. 26 vom 27.02.2026
(Verordnung des Innenministeriums zur Änderung der Kommunalwahlordnung)
|Standard-HdR-Befehle im GBl-Layout; „werden nach dem Wort … die Wörter … eingefügt",
„werden die Wörter … gestrichen".

|Nordrhein-Westfalen
|`NRW/GV-NRW-2026-S202_22-Rundfunkaenderungsgesetz.pdf` — GV. NRW. 2026 Nr. 7 vom 31.03.2026,
S. 202 (22. Rundfunkänderungsgesetz)
|Umfangreiches Mehrgesetz-Artikelgesetz (17 S.); „Die Inhaltsübersicht wird wie folgt
geändert", „§ … (weggefallen)". Bereitgestellt aus dem amtlichen recht.nrw.de-PDF. *Unbalancierte
Anführungszeichen* im amtlichen Satz (Artikel 2 Nr. 7 b und Nr. 11). Konsolidierte Fassungen sind
über `recht.nrw.de/lrgv/gesetz/<TTMMJJJJ>-<Kurztitel-Slug>` frei und serverseitig gerendert
abrufbar; der Datumspräfix ist der Gültigkeitsbeginn der jeweiligen Fassung.

|Sachsen
|`Sachsen/SaechsGVBl-2026-S134_AendG-SaechsBeamtVG_revosax.pdf` — SächsGVBl. S. 134
(Gesetz zur Änderung des Sächsischen Beamtenversorgungsgesetzes vom 13.04.2026)
|Kompaktes Änderungsgesetz, Verschachtelung a)/aa)/bb)/cc), „wird durch den folgenden Satz
ersetzt". Quelle: revosax-Gesamtansicht (nicht der Original-GVBl-Satz — recht-sachsen.de ist ein
cookie-/kostenpflichtiger Shop).

|Thüringen
|`Thueringen/GVBl-TH-2026-02_KiGaFinanzVO-AendVO-ua.pdf` — GVBl. Freistaat Thüringen Nr. 2 vom
13.02.2026 (u. a. Vierte Verordnung zur Änderung der Thüringer Kindergartenfinanzierungs-
verordnung)
|Sammelheft (28 S.) mit vier Verkündungen, davon eine Änderungsverordnung. Unterscheidend: Das
Blatt führt *kein einziges* `„`, sondern setzt gerade Anführungszeichen beidseitig; dazu das
Idiom „die Verweisung „X" durch die Verweisung „Y" ersetzt", ein Rahmen, der sich auf eine
Untereinheit der umnummerierten Norm verengt, und eine Bereichs-Umnummerierung über einen
aufgehobenen Platzhalter hinweg. Voller Akzeptanzfall, Stammfassung
`Thueringen/ThuerKigaFinVO-alt.txt`.
|===

== Stand der Umsetzung

* *Sachsen* ist als erster nichtbayerischer Belegfall vollständig umgesetzt: konsolidierte
  Vorfassung `Sachsen/SaechsBeamtVG-alt.txt` (kanonischer Klartext, Fassung vom 01.02.2025, aus
  der archivierten revosax-Volltextfassung abgeleitet) und End-to-End-Akzeptanztest
  (`EndToEndTest.saechsBeamtVgAcceptance`; fünf Befehle, kein Rest).
* *Niedersachsen* ist umgesetzt: `Niedersachsen/NEFG-alt.txt` (seit 2022 unveränderter NEFG, aus
  dem zweispaltigen Nds. GVBl 2022 Nr. 33) und `EndToEndTest.nefgAcceptance` (alle sieben Befehle
  angewandt, kein Rest — einschließlich der beiden niedersächsischen Einfügeformen: Sachnummer mit
  Leerzeichen „§ 2 a“ und gliederungsbezogene Einfügung „In Kapitel 4 wird nach § 12 …“).
* *Schleswig-Holstein* ist *vollständig* umgesetzt
  (`EndToEndTest.kommunalrechtAendGSchleswigHolstein`): Artikel 1 trifft die Gemeindeordnung,
  Artikel 2 die Kreisordnung, je ein Neufassungsbefehl, kein unbekannter Befehl — und beide
  Gesetze gleichen nach der Anwendung Norm für Norm der amtlichen Nachfassung vom 31. März 2026
  (167 bzw. 86 Normen). Artikel 3 ändert ein anderes Änderungsgesetz und wird zu Recht nicht
  gewählt. Beide Stammfassungen sind über die Browsersteuerung beschafft.

* *Nordrhein-Westfalen* ist der Massentest-Fall: aus demselben Heft sind alle vier ändernden
  Artikel als Akzeptanzfälle hinterlegt.
+
--
`EndToEndTest.tmzGesetzAcceptance`:: Artikel 3 (Telemedienzuständigkeitsgesetz), vier Befehle,
kein Rest. Stamm `NRW/TMZ-Gesetz-alt.txt`.
`EndToEndTest.wdrGesetzAcceptance`:: Artikel 1 (WDR-Gesetz), 101 Befehle an 31 Normen, davon 100
angewandt. Stamm `NRW/WDR-Gesetz-alt.txt` (Fassung vom 01.01.2025). Der Fall trägt die
Umnummerierungs-Kaskaden (§ 3: Absatz 2 → zwei Absätze, die Absätze 3 bis 11 rücken auf, ein neuer
Absatz 13 kommt hinzu; § 15 Absatz 3: Nummer 22 entfällt, 23 bis 37 rücken auf), den Sammelrahmen
„Es werden ersetzt:“ und die Angabe-Befehle auf die Inhaltsübersicht. Einziges Residuum ist
Nr. 13 e) aa): „der Punkt am Ende des Satzes“ ist in einer zweisätzigen Nummer nicht eindeutig.
`EndToEndTest.lmgNrwAcceptance`:: Artikel 2 (Landesmediengesetz), 18 Befehle, kein Rest. Stamm
`NRW/LMG-NRW-alt.txt` (Fassung vom 01.01.2025).
`EndToEndTest.rundfunkAusfuehrungsgesetzAcceptance`:: Artikel 4 (17. RÄStV-AusfG), ein Befehl,
kein Rest. Stamm `NRW/17-RAEStV-AusfG-alt.txt` (Erstfassung vom 17.12.2015, bis 2026 unverändert).
Der Artikel führt seinen Befehl *ohne* Gliederungspunkt — der Text nach der Änderungsformel ist
der Befehl —, und das Zitat der neuen Fassung trägt verschachtelte Anführungszeichen (ein
vollständiges „durch Artikel 3 …“ innerhalb einer eckigen Klammer). Beides trägt die vorhandene
Maschinerie.
--
+
Alle vier Ergebnisse sind normweise gegen die amtliche Fassung vom 01.04.2026 abgeglichen. Es
bleiben nur Abweichungen, in denen die amtliche Nachfassung selbst vom Befehlswortlaut abweicht
(§ 15 WDR-Gesetz: „des“ vor „Bundesreisekostengesetzes“ entfallen; § 7 und § 21 WDR-Gesetz: ein
überzähliges Anführungszeichen aus dem Änderungsgesetz; § 93 LMG NRW: zusätzlich die Wörter
„Film (“ gestrichen) — ÄndGgner wendet dort den Wortlaut an. Damit ist das Heft GV. NRW. 7/2026
vollständig belegt.
* *Berlin* ist zur Hälfte umgesetzt (`EndToEndTest.asogLafAendGBerlin`). Artikel 2
  (LAF-Errichtungsgesetz) ist ein *voller* Akzeptanzfall: beide Befehle angewandt, alle fünf
  Normen gleich der amtlichen Nachfassung vom 12. Juni 2026; die Stammfassung ist über die
  Browsersteuerung beschafft. Artikel 1 (ASOG) wird *vollständig erkannt* — alle sechs Befehle,
  einschließlich der Änderungen an der unnummerierten Anlage —, aber nicht angewandt: Fünf der
  sechs zielen auf Einheiten der Anlage, die dort als Überschriften stehen („Nummer 6“,
  „Nummer 23“, „Nummer 31“) und nicht als Aufzählungsmarken. Sie brauchen einen eigenen Rang
  zwischen Norm und Absatz; Begründung und Bezugsweg in `Berlin/SOURCES`.
* *Hessen* ist *vollständig* umgesetzt (`EndToEndTest.verkehrsZustVAendVOHessen`): alle
  21 Befehle des Artikels 1 werden erkannt und angewandt, und alle 52 Normen gleichen danach
  zeichengenau der amtlichen Nachfassung vom 4. Februar 2026. Die Stammfassung ist über eine
  *Browsersteuerung* aus dem Landesrechtsportal beschafft; damit ist die juris-Sackgasse
  aufgebrochen (siehe „Beschaffung der Stammfassungen“).

* Baden-Württemberg (GBl 2026 Nr. 26): großes Anlage-lastiges Änderungsgesetz (§§ 4–57a + Anlagen
  1/3b/4b); Stammfassung/Akzeptanztest noch offen.

== Beschaffung der Stammfassungen

Für einen vollen Akzeptanztest wird die Fassung *vor* dem Änderungsgesetz gebraucht. Welcher Weg
dafür trägt, hängt allein vom Portal ab; die drei erprobten Wege:

`recht.nrw.de` (Nordrhein-Westfalen):: Der bequemste Fall. Serverseitig gerendertes HTML, keine
Single-Page-Anwendung, `robots.txt` erlaubt alles. Das URL-Schema
`recht.nrw.de/lrgv/gesetz/<TTMMJJJJ>-<Kurztitel-Slug>` trägt den *Gültigkeitsbeginn der jeweiligen
Fassung* im Datumspräfix — Vor- und Nachfassung sind damit unmittelbar adressierbar, und das
Ergebnis lässt sich gegen die amtliche Nachfassung prüfen. Die Slugs findet die Suchmaske nicht
(Formular); sie stehen im Sitemap-Index (`robots.txt` listet `sitemap/page/1..47/sitemap.xml`, je
1000 Einträge). Alte `lmi/owa/br_*`-URLs leiten auf die neuen Slugs um.

`revosax.sachsen.de` (Sachsen):: Liefert Volltext-PDFs je Fassung, aber nur die aktuelle live. Die
Vorfassung kommt über die Wayback-CDX-API: Fassungs-IDs abfragen, die zum Zeitraum passende wählen,
per `…id_/…`-Rohform laden. Achtung, `WebFetch` erreicht `web.archive.org` nicht — nur `curl`.

juris-Landesportale, Browsersteuerung:: Der Weg, der die Sackgasse aufbricht — *erprobt an Hessen*.
Diese Portale sind Einseitenanwendungen: Jede Skriptabfrage erhält nur die rund 5,4 kB große
Anwendungshülle, gleich unter welcher Adresse. Ein *Browser* dagegen bekommt den Text. Er ist
deshalb Dokument für Dokument über eine Browsersteuerung auszulesen, nicht im Massenabzug.
Maßgeblich ist die Schaltfläche „Gesamtausgaben-Liste“ der Dokumentansicht: Sie führt jede Fassung
mit ihrem Geltungszeitraum und macht sie unter einer *datierbaren* Adresse abrufbar —
`/<Kennung>/document/aiz-jlr-<Dokumentkennung>@<JJJJMMTT>`; Vor- und Nachfassung sind damit
unmittelbar adressierbar und das Ergebnis gegen die amtliche Nachfassung prüfbar. Zwei
Fallstricke: Die Seite rendert nachlädig, sodass ein Auszug des sichtbaren Bereichs mitten im
Gesetz abbricht — maßgeblich ist der Textinhalt des Dokumentbehälters (`div.docLayoutText`); und
die Portale führen im Seitenkopf eine Vorbehaltsangabe zum Text- und Data-Mining
(„tdm-reservation“), die für gemeinfreie amtliche Werke nach § 5 UrhG keine Wirkung entfalten
kann. Rezept im einzelnen: `Hessen/SOURCES`.

juris-Landesportale, Skript:: Sackgasse — *geprüft* für `gesetze-rechtsprechung.sh.juris.de`
(Schleswig-Holstein), `gesetze.berlin.de` (Berlin, trotz Eigennamen dieselbe Anwendung),
`landesrecht-bw.de` (Baden-Württemberg) und `rv.hessenrecht.hessen.de` (Hessen, Kennung `bshe`).
und `landesrecht.thueringen.de` (Thüringen).
Alle fünf sind seit etwa Ende 2022 reine Single-Page-Anwendungen; sämtliche Dokument-URLs liefern
nur die leere Anwendungshülle (rund 5,4 kB), die Inhalte hängen an einer tokenpflichtigen
Schnittstelle. Auch archivierte
Einzelnorm-Seiten sind bereits Hüllen. Brauchbar sind allenfalls Wayback-Snapshots aus der Zeit
*vor* der Umstellung — die sind aber meist zu alt für die gesuchte Fassung. Für
`voris.niedersachsen.de` ist dasselbe zu erwarten, aber *nicht* nachgeprüft: Ein Versuch lohnt,
bevor man aufgibt.

Parlamentsdokumentationen:: Der Ausweg, wo das Landesrechtportal versperrt ist. Gibt der Landtag
das Gesetzblatt heraus — in Thüringen ist das so —, so liegen dessen Hefte oft frei in der
Parlamentsdatenbank, auch die alten:
`parldok.thueringer-landtag.de/ParlDok/dokument/<WP>/art/GVBl/num/<Heft>/jahr/<Jahr>[/seite/<S>]`.
Damit lässt sich eine konsolidierte Fassung aus dem Stammheft und den Änderungsheften
zusammensetzen, wenn kein Portal sie fertig liefert (Rezept in `Thueringen/SOURCES`). Das Archiv
der Staatskanzlei (`thueringen.de/th1/tsk/gvbl/`) hilft dagegen nicht: Es antwortet Skripten mit
einer Bot-Schutz-Fehlerseite.

Fällt das Portal aus, bleibt der Weg über das Gesetzblatt selbst: Trägt der Einleitungssatz des
Änderungsgesetzes kein „zuletzt geändert durch“, so ist die Originalfassung zugleich die
Stammfassung (so bei Niedersachsen). Die Extraktion zweispaltiger Hefte übernimmt `--extract-only`
des Werkzeugs selbst; `pdftotext -layout` verschränkt dort die Spalten.

Ein Fallstrick beim Prüfen extrahierter Hefte: Das GV.-NRW.-Heft 7/2026 kodiert einen Teil seiner
Umlaute *zerlegt* (`u` + U+0308 statt `ü`, 79 Stellen, darunter dutzende „eingefügt:“/„angefügt:“).
Im Text ist das unsichtbar, für jedes Befehlsmuster aber ein anderes Wort. `TextBereiniger.bereinige`
normalisiert deshalb ganz früh nach NFC — nicht NFKC, das plättete die amtlichen Satznummern ¹²³ zu
gewöhnlichen Ziffern. Wer Klartext von Hand aufbereitet, sollte ihn ebenfalls in NFC ablegen; der
Klartext-Zweig des Loaders normalisiert zur Sicherheit mit.

== Noch offen


* *Berlin, ASOG — Stammfassung bewusst nicht beigelegt*, weil sie ohne den Rang der
  Anlagen-Einheiten keinen Prüfgewinn brächte; der Bezugsweg steht in `Berlin/SOURCES` und führt
  in zwei Abrufen wieder dorthin. Zur Geschichte: `gesetze.berlin.de` ist trotz des Eigennamens dieselbe
  juris-Anwendung wie das schleswig-holsteinische Portal (Kennung `bsbe`) und ebenso
  anmeldepflichtig. In der Wayback Machine gibt es keine serverseitig gerenderten Volltexte des
  ASOG oder des LAF-Errichtungsgesetzes.
* *Anlagen im kanonischen Klartext* — der Normkopf ist erledigt, der Rang der Nummern nicht:
  Der `LandesRechtTextParser` kennt seit dieser Welle Anlagen-Normköpfe („Anlage“, „Anlage 2“,
  „Anhang“), und alles hinter ihnen gehört zur Anlage — ihre inneren Überschriften gliedern nicht
  das Gesetz, und ein Paragraph, den sie zitieren, eröffnet keine Norm. Offen bleibt die
  *Adressierung ihrer Einheiten*: Berlins Anlage überschreibt sie mit „Nummer 6“, während der
  Stellenauflöser eine Marke „6.“ im Text sucht, die dort vielfach vorkommt. Nötig ist ein eigener
  Rang zwischen Norm und Absatz. Die ältere Fassung dieses Punktes, zur Einordnung: Anlagen sind als Änderungsziel unterstützt — im gii-XML sind
  sie eigene Normen („Anlage 8“, „Anhang“), und `Stelle.anlagenEnbez()` löst sie auf; im GEG werden
  anlagenbezogene Befehle angewandt. Der `LandesRechtTextParser` kennt jedoch nur „§“- und
  „Art.“-Normköpfe: Eine handgepflegte Stammfassung kann *keine* Anlage tragen. Das ist die
  konkrete Lücke für Berlin (Artikel 1) und Baden-Württemberg (Anlagen 1/3b/4b). Beide Portale sind
  inzwischen als juris-Anwendung *nachgeprüft* — die Lücke geht deshalb erst mit einem
  Anlage-tragenden Stammgesetz aus einem anderen Portal auf, praktisch `recht.nrw.de`.
* *Berlin, ganzseitenbreite Rahmen*: Titelblock und Impressum stehen im Inhaltsstrom an anderer
  Stelle als im Satzbild (der Titelblock mitten im Fließtext der ersten Seite). Das zu beheben
  verlangt eine geometrische Lesereihenfolge (XY-Cut), nicht bloß eine Spaltenerkennung.
* *Rheinland-Pfalz*: Die Verkündungsplattform `verkuendung.rlp.de` verkündet erst seit dem
  01.07.2026 elektronisch; ältere GVBl-Hefte liegen nicht als freie Direkt-PDF vor.
* Bremen, Hamburg, Mecklenburg-Vorpommern, Saarland, Brandenburg, Sachsen-Anhalt: noch nicht
  erfasst.

== Wo weitermachen

Kein Land scheitert noch an reiner Extraktionsschwäche; offen sind Modell- und Beschaffungsfragen.
Nach absteigendem Nutzen:

. *Den Rang der Anlagen-Einheiten einführen* — die Nummern einer Anlage stehen zwischen Norm und
  Absatz. Daran hängen Berlins Artikel 1 (fünf von sechs Befehlen) und Baden-Württembergs
  Anlagen 1, 3b und 4b. Der Belegfall ist unmittelbar zur Hand: Berlins ASOG ist in zwei Abrufen
  wiederbeschafft (`Berlin/SOURCES`). Mitzuerledigen ist die Umschrift der Berliner Satznummern
  (angeklebte Ziffern statt Superskripte).
. *Baden-Württembergs Kommunalwahlordnung über die Browsersteuerung holen* — der Weg ist unter
  „Beschaffung der Stammfassungen“ beschrieben; Hessen, Schleswig-Holstein und Berlin sind ihn
  gegangen.
. *Berlin, ganzseitenbreite Rahmen* (XY-Cut) — die letzte offene Layout-Frage, siehe „Noch offen“.

*Erledigt:* _Berlins Artikel 2_ ist ein voller Akzeptanzfall, und der Klartext-Parser trägt
nunmehr *Anlagen als eigene Normen*. Zwei Berliner Befunde stehen für die nächste Arbeit fest: Die
Einheiten einer Anlage können als Überschriften gesetzt sein statt als Marken, und das Portal
schreibt die amtlichen Satznummern als angeklebte Ziffern statt als Superskripte.

*Erledigt:* _Schleswig-Holstein_ ist vollständig umgesetzt — der erste Fall mit *zwei*
Stammgesetzen in einem Änderungsgesetz. Zwei Eigenheiten des Portalsatzes waren zu beheben: Er
trennt die Sachnummer ab („§ 57 c“ statt „§ 57c“, zehn Normen der Gemeindeordnung wären sonst
dem Gesetz entgangen), und er setzt im Klammerzusatz einen Bindestrich statt des amtlichen
Gedankenstrichs, weshalb Kurztitel und Abkürzung ungetrennt blieben und kein Artikel gewählt
wurde. Der Parser nimmt den Strich nunmehr in beiden Gestalten an, sofern Leerraum ihn umgibt.

*Erledigt:* _Hessen_ ist vollständig umgesetzt (`EndToEndTest.verkehrsZustVAendVOHessen`,
einundzwanzig Befehle, kein Rest; alle zweiundfünfzig Normen gleichen der amtlichen Nachfassung).
Der Fall hat den Beschaffungsweg über die Browsersteuerung eröffnet und fünf allgemeine Befunde
gebracht: Ein Normkopf darf ohne Überschrift stehen; eine Gliederung darf ihr Ordinale
ausschreiben („Erster Teil“); die Streichung einer Absatzbezeichnung nimmt dem Wortlaut seine
Nummer, statt ihn zu beseitigen; ein Platzhalter „(weggefallen)“ steht nur dort, wo ihm eine
weitere Einheit folgt, deren Bezeichnung er schonen soll; und ein Wort, das an die Stelle eines
Satzzeichens tritt, bekommt seinen Zwischenraum. Zwei vorbestehende stille Mängel kamen dabei ans
Licht: `List.remove` erhielt einen geboxten Index und entfernte deshalb nichts (das traf auch die
Neufassung eines Absatzes durch mehrere), und ein Aufzählungsglied, das auf „und“ endet, galt als
Unter-Überschrift.

*Erledigt:* _Thüringen_ ist vollständig umgesetzt (`EndToEndTest.thuerKiGaFinVOAendVO`, zehn
Befehle, kein Rest). Es war das letzte beschaffte, nie angefasste Heft und hat drei allgemeine
Befunde gebracht: gerade Anführungszeichen werden paarweise gelesen, wenn ein Text kein deutsches
öffnendes Zeichen führt; eine Bereichs-Umnummerierung nennt Bezeichnungen, meint aber Einheiten und
bleibt deshalb bis zur Anwendung ungeteilt; und der Wortbestand eines Dokuments entscheidet, ob ein
Trennstrich vor einem Großbuchstaben eine Silbentrennung war. Die Stammfassung ist aus vier
Gesetzblättern zusammengesetzt — siehe `Thueringen/SOURCES`.

*Erledigt:* Die _Stellung eines eingefügten Blocks_ war der letzte sichtbare Rest an Art. 56 des
BayJG. Ursache war nicht die Einfügung selbst, sondern die Neufassung der Nr. 4 einen Punkt zuvor:
Sie setzte ihren Wortlaut ohne Einrückung, worauf der Zeilenblock dieser Marke bis ans Absatzende
reichte — er reicht so weit, wie tiefer eingerückt wird. Art. 56 Abs. 1 gleicht seither in Aufbau
und Wortlaut der amtlichen Nachfassung; der Akzeptanztest prüft das.

Regressionsschutz: `./mvnw verify` prüft die bestehenden Belegfälle mit. Gepinnt ist dabei nicht
überall dieselbe Art von Zahl — für UWG, AGG und ProdHaftG, dass *kein* Befehl manuell bleibt; für
das BayJG die 154 erkannten Befehle, die vollständige Anwendung und den Wortlaut des
Bußgeldkatalogs — dort auch Aufbau und Einrückung, weil an ihnen die Stellung eingefügter Blöcke
hängt; für Sachsen,
Niedersachsen und die vier NRW-Artikel die vollständige Anwendung bis auf das eine benannte
Residuum im WDR-Gesetz; für Hessen die vollständige Anwendung und den Gleichlauf
aller 52 Normen mit der amtlichen Nachfassung; für Schleswig-Holstein die vollständige Anwendung auf beide
Stammgesetze; für Berlin die vollständige Anwendung des Artikels 2 und die
vollständige *Erkennung* des Artikels 1. Wer eine dieser Zahlen
ändern muss, sollte den Grund im Test vermerken.
