Die Startseite führt die Neuankömmlinge ein

Seit der Inbetriebnahme setzte die Startseite voraus, was gerade nicht hat, wer
sie zum ersten Mal aufruft: geeignete Dateien. Über dem Formular stand die
Tätigkeitsbeschreibung, darunter zwei leere Dateifelder, und wer nie mit
gii-Norm-XML oder einem BGBl-Regelungstext zu tun hatte, konnte das Werkzeug
nicht einmal ausprobieren. Ein zugeklappter Block tritt hinzu, der zwei
durchgerechnete Fälle mit Verweisen auf die amtlichen Fundstellen anbietet.
Zugeklappt kostet er eine Zeile; das Formular bleibt, wo es war.

Angeboten werden ein verkündetes Änderungsgesetz — das UWG nebst dem Dritten
Gesetz zu seiner Änderung (BGBl. 2026 I Nr. 43), neunzehn Befehle an sechs
Normen ohne Rest — und ein Gesetzentwurf — das AGG nebst BT-Drs. 21/6178,
dreiundzwanzig Befehle an vierzehn Normen, einer zur Prüfung markiert. Der
zweite Fall war zunächst als ProdHaftG nebst BT-Drs. 21/4297 gedacht und ist
verworfen: Die Modernisierung löst das Gesetz ab, statt es zu ändern, und ergibt
einen einzigen Befehl an einer einzigen Norm. Ein Beispiel, das nichts zeigt,
ist keines.

Mitausgeliefert wird nichts, und die Seite ruft von sich aus nichts ab; sie
verweist. Die Verweise öffnen ein eigenes Fenster, weil ein im selben Fenster
geöffnetes PDF die bereits gewählten Dateien aus dem Formular nähme. Das
Stilblatt bekommt .einfuehrung im Zuschnitt der übrigen Kästen und keine einzige
neue Farbe, sodass Hell- und Dunkelfassung ohne Zutun stimmen.

Dabei stellte sich heraus, dass gesetze-im-internet.de das Norm-XML gar nicht
als solches ausgibt: Es gibt allein …/<kurz>/xml.zip, der unmittelbare
BJNR….xml-Pfad ist 404. Eine Einführung, die auf die Fundstelle verweist, wäre
ohne Weiteres eine Anleitung zum Entpacken von Hand gewesen. Der Ladepfad nimmt
das Archiv deshalb nun unmittelbar an (ZipAuspacker, vorgeschaltet in
Pipeline.ladeStammgesetz; DateiTyp kennt die Art ZIP). Die Änderungsdokumente
bleiben unberührt — Gesetzblätter und Drucksachen kommen nirgends als Archiv.

Das Format wird von Hand gelesen, und zwar aus einem Grund, der außerhalb der
Browserfassung sinnlos wäre: Von den Archivklassen des JDK trägt dort allein der
Inflater, den InflaterErsatz auf jzlib zurückführt; ZipInputStream, ZipFile und
CRC32 beruhen auf nativen Bindungen, die Web Image nicht kennt. Auch die
Prüfsumme rechnet die Klasse deshalb selbst. Gelesen wird über das
Zentralverzeichnis am Dateiende, nicht über die örtlichen Vorspanne, deren
Größenangaben bei nachgestellten Beschreibern erst hinter den Daten stehen.
Gewählt wird der einzige auf .xml endende Eintrag: Den Gesetzen mit Anlagen legt
die Fundstelle deren Bilddateien mit ins Archiv, es ist also nicht einerlei,
welchen man nimmt. Die ZIP-Signatur wird vor der PDF-Signatur geprüft, weil sie
am ersten Byte verankert ist, während jene ein Vorschaufenster durchsucht — ein
Archiv mit der Zeichenfolge „%PDF-“ in seinen gepackten Daten wäre sonst als PDF
angesprochen worden.

Die Quellenzeile der Synopse nennt weiterhin die angegebene Datei (uwg.zip),
nicht den Eintrag; sie soll den Weg zur Fundstelle zurück beschreiben. Den
Eintragsnamen trägt die ausgepackte Quelle gleichwohl, damit Protokoll und
Ladefehler das Gesetz benennen und nicht seine Verpackung.

Geprüft ist beides gegen die Fundstelle selbst, nicht nur gegen den
Beispielkorpus: 312 Prüfungen laufen durch, darunter acht neue zum Auspacken.
Das unmittelbar bezogene uwg.zip ergibt auf der Befehlszeile mit dem
BGBl-Regelungstext dieselbe Ausfertigung wie die entpackte Fassung — die beiden
unterscheiden sich allein in der Quellenzeile —, und dieselben 19/0/6 ergeben
sich im neu gebauten Wasm-Modul im Browser, ohne eine Beanstandung in der
Konsole. Der Block hält bei 320 Pixeln Breite ohne Überlauf.

Unberührt bleiben pom.xml, deploy/webpaket.sh und die nginx-Vorlage: Da nichts
mitausgeliefert wird, braucht es weder einen zweiten Ressourcen-Block noch neue
MIME-Typen — deren types-Block ersetzt die Zuordnung vollständig und wäre sonst
die Falle gewesen.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Change-Id: I5f6566ca89aa5198452b0b29ac5b38da9eb26137

5 files changed, 297 insertions, 11 deletions

diff --git a/src/main/java/eu/mulk/aendggner/DateiTyp.java b/src/main/java/eu/mulk/aendggner/DateiTyp.java
index 2157fc4..6e31dc1 100644
--- a/src/main/java/eu/mulk/aendggner/DateiTyp.java
+++ b/src/main/java/eu/mulk/aendggner/DateiTyp.java
@@ -3,22 +3,33 @@ package eu.mulk.aendggner;
 import java.nio.charset.StandardCharsets;
 
 /**
- * Die drei Eingabeformate, die ÄndGgner unterscheidet, erkannt an den ersten Bytes.
+ * Die Eingabeformate, die ÄndGgner unterscheidet, erkannt an den ersten Bytes.
  *
- * <p>Ersetzt die frühere Tika-Erkennung: Unterschieden werden muss nur zwischen PDF, gii-XML und
- * Klartext, und dafür genügen die Signaturbytes. Das spart eine schwergewichtige Abhängigkeit samt
- * ServiceLoader- und XML-Konfiguration — was der Wasm-Übersetzung zugutekommt, für die jede
+ * <p>Ersetzt die frühere Tika-Erkennung: Unterschieden werden muss nur zwischen ZIP, PDF, gii-XML
+ * und Klartext, und dafür genügen die Signaturbytes. Das spart eine schwergewichtige Abhängigkeit
+ * samt ServiceLoader- und XML-Konfiguration — was der Wasm-Übersetzung zugutekommt, für die jede
  * dynamisch aufgelöste Abhängigkeit Handarbeit bedeutet.
  */
 public enum DateiTyp {
   PDF,
   XML,
+  ZIP,
   KLARTEXT;
 
   /** Wie weit hinein nach der Signatur gesucht wird (PDFs tragen gelegentlich Vorspann). */
   private static final int VORSCHAU_BYTES = 1024;
 
   public static DateiTyp erkenne(byte[] inhalt) {
+    // Die ZIP-Signatur steht an Byte 0 und wird deshalb zuerst und ohne Vorschaufenster geprüft:
+    // Ein Archiv, das zufällig „%PDF-“ in seinen komprimierten Daten führt, wäre sonst ein PDF.
+    if (inhalt.length >= 4
+        && inhalt[0] == 'P'
+        && inhalt[1] == 'K'
+        && inhalt[2] == 3
+        && inhalt[3] == 4) {
+      return ZIP;
+    }
+
     // ISO-8859-1 bildet jedes Byte auf genau ein Zeichen ab — hier geht es um Signaturen, nicht
     // um lesbaren Text, und die Zeichenzählung soll der Byteposition entsprechen.
     var vorschau =
@@ -41,7 +52,7 @@ public enum DateiTyp {
     return KLARTEXT;
   }
 
-  /** Für Fehlermeldungen: „PDF“, „XML“, „Klartext“. */
+  /** Für Fehlermeldungen: „PDF“, „XML“, „ZIP“, „Klartext“. */
   public String anzeigeName() {
     return this == KLARTEXT ? "Klartext" : name();
   }
diff --git a/src/main/java/eu/mulk/aendggner/Pipeline.java b/src/main/java/eu/mulk/aendggner/Pipeline.java
index 4b2b7d9..16df275 100644
--- a/src/main/java/eu/mulk/aendggner/Pipeline.java
+++ b/src/main/java/eu/mulk/aendggner/Pipeline.java
@@ -278,11 +278,18 @@ public final class Pipeline {
     return ladeStammgesetz(Quelle.lies(baseFile));
   }
 
-  /** Gii-XML → {@link GiiXmlLoader}; PDF/Klartext (Landesrecht) → {@link LandesRechtLoader}. */
+  /**
+   * Gii-XML → {@link GiiXmlLoader}; PDF/Klartext (Landesrecht) → {@link LandesRechtLoader}.
+   *
+   * <p>Vorweg wird ausgepackt: gesetze-im-internet.de gibt das Norm-XML nur als {@code xml.zip}
+   * aus, und das soll unentpackt taugen (siehe {@link ZipAuspacker}). Die Änderungsdokumente
+   * bleiben davon unberührt — Gesetzblätter und Drucksachen kommen nirgends als Archiv.
+   */
   static Gesetz ladeStammgesetz(Quelle baseFile) throws Exception {
-    return DateiTyp.erkenne(baseFile.inhalt()) == DateiTyp.XML
-        ? new GiiXmlLoader().load(baseFile)
-        : new LandesRechtLoader().load(baseFile);
+    var quelle = ZipAuspacker.auspacken(baseFile);
+    return DateiTyp.erkenne(quelle.inhalt()) == DateiTyp.XML
+        ? new GiiXmlLoader().load(quelle)
+        : new LandesRechtLoader().load(quelle);
   }
 
   /**
diff --git a/src/main/java/eu/mulk/aendggner/ZipAuspacker.java b/src/main/java/eu/mulk/aendggner/ZipAuspacker.java
new file mode 100644
index 0000000..0baeac2
--- /dev/null
+++ b/src/main/java/eu/mulk/aendggner/ZipAuspacker.java
@@ -0,0 +1,268 @@
+package eu.mulk.aendggner;
+
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.zip.DataFormatException;
+import java.util.zip.Inflater;
+
+/**
+ * Holt das gii-Norm-XML aus einem Archiv heraus, wie gesetze-im-internet.de es ausliefert.
+ *
+ * <p>Das Portal gibt kein rohes XML aus, sondern je Gesetz nur {@code …/<kurz>/xml.zip}. Ohne
+ * diesen Schritt müsste jede:r die heruntergeladene Datei erst von Hand entpacken, bevor sie ins
+ * Formular passt — die Einführung der Browserfassung verweist deshalb unmittelbar auf das Archiv.
+ *
+ * <p>Das ZIP-Format wird hier von Hand gelesen statt mit {@link java.util.zip.ZipInputStream}: Von
+ * allen zip-Klassen des JDK trägt in der Wasm-Fassung allein {@link Inflater}, den {@code
+ * eu.mulk.aendggner.wasm.InflaterErsatz} durch die reine Java-Umsetzung von jzlib ersetzt. {@code
+ * ZipInputStream}, {@code ZipFile} und {@code CRC32} greifen auf native Bindungen zurück, die Web
+ * Image nicht kennt; die Prüfsumme rechnet deshalb {@link #crc32} selbst.
+ *
+ * <p>Gelesen wird über das Zentralverzeichnis am Dateiende, nicht über die Local Header: Bei
+ * Einträgen mit Data Descriptor stehen Größe und Prüfsumme im Local Header auf null und erst hinter
+ * den komprimierten Daten — das Zentralverzeichnis trägt sie immer.
+ */
+public final class ZipAuspacker {
+
+  /** „PK\05\06“ — Kennung des End-of-Central-Directory-Records. */
+  private static final int EOCD_SIGNATUR = 0x06054b50;
+
+  /** „PK\01\02“ — Kennung eines Eintrags im Zentralverzeichnis. */
+  private static final int ZENTRAL_SIGNATUR = 0x02014b50;
+
+  /** „PK\03\04“ — Kennung eines Local Headers. */
+  private static final int LOKAL_SIGNATUR = 0x04034b50;
+
+  /** Fester Teil des EOCD-Records; dahinter steht nur noch der Archivkommentar. */
+  private static final int EOCD_MINDESTLAENGE = 22;
+
+  /** Der Kommentar ist auf 64 KiB begrenzt; weiter zurück muss die Suche nach dem EOCD nicht. */
+  private static final int KOMMENTAR_MAX = 0xFFFF;
+
+  private static final int VERFAHREN_GESPEICHERT = 0;
+  private static final int VERFAHREN_DEFLATE = 8;
+
+  /** Bit 0 des Allgemeinen Kennzeichens: Der Eintrag ist verschlüsselt. */
+  private static final int KENNZEICHEN_VERSCHLUESSELT = 1;
+
+  private ZipAuspacker() {}
+
+  /**
+   * Liefert bei einem Archiv den enthaltenen XML-Eintrag, sonst die Quelle unverändert.
+   *
+   * <p>Die gelieferte Quelle trägt den Eintragsnamen, damit Protokoll und Ladefehler das Gesetz
+   * benennen statt seine Verpackung. Die Quellenzeile der Synopse bleibt davon unberührt: Sie nennt
+   * weiterhin die Datei, die angegeben wurde ({@code uwg.zip}), denn sie soll den Weg zur
+   * Fundstelle zurück beschreiben.
+   */
+  public static Quelle auspacken(Quelle quelle) throws IOException {
+    if (DateiTyp.erkenne(quelle.inhalt()) != DateiTyp.ZIP) {
+      return quelle;
+    }
+
+    var eintraege = zentralverzeichnis(quelle);
+    var xml = einzigesXml(eintraege, quelle.name());
+    return new Quelle(xml.name(), entpacke(quelle.inhalt(), xml, quelle.name()));
+  }
+
+  /** Ein Eintrag des Zentralverzeichnisses, soweit hier gebraucht. */
+  private record Eintrag(
+      String name,
+      int verfahren,
+      int kennzeichen,
+      long crc,
+      int gepackt,
+      int entpackt,
+      int offset) {
+
+    String dateiname() {
+      int schraeg = name.lastIndexOf('/');
+      return schraeg < 0 ? name : name.substring(schraeg + 1);
+    }
+  }
+
+  private static List<Eintrag> zentralverzeichnis(Quelle quelle) throws IOException {
+    var bytes = quelle.inhalt();
+    int eocd = sucheEocd(bytes, quelle.name());
+
+    int anzahl = u16(bytes, eocd + 10);
+    int anfang = (int) u32(bytes, eocd + 16);
+
+    var eintraege = new ArrayList<Eintrag>(anzahl);
+    int p = anfang;
+    for (int i = 0; i < anzahl; i++) {
+      if (p < 0 || p + 46 > bytes.length || (int) u32(bytes, p) != ZENTRAL_SIGNATUR) {
+        throw beschaedigt(quelle.name(), "das Zentralverzeichnis bricht ab");
+      }
+      int namensLaenge = u16(bytes, p + 28);
+      int zusatzLaenge = u16(bytes, p + 30);
+      int kommentarLaenge = u16(bytes, p + 32);
+      if (p + 46 + namensLaenge > bytes.length) {
+        throw beschaedigt(quelle.name(), "ein Eintragsname reicht über das Dateiende hinaus");
+      }
+      eintraege.add(
+          new Eintrag(
+              // Ohne gesetztes Bit 11 des Allgemeinen Kennzeichens schreibt das Format CP437;
+              // die hier vorkommenden Namen sind reines ASCII, für das beides zusammenfällt.
+              new String(bytes, p + 46, namensLaenge, StandardCharsets.UTF_8),
+              u16(bytes, p + 10),
+              u16(bytes, p + 8),
+              u32(bytes, p + 16),
+              (int) u32(bytes, p + 20),
+              (int) u32(bytes, p + 24),
+              (int) u32(bytes, p + 42)));
+      p += 46 + namensLaenge + zusatzLaenge + kommentarLaenge;
+    }
+    return eintraege;
+  }
+
+  /** Sucht den EOCD-Record von hinten: Vor ihm steht nur noch der Archivkommentar. */
+  private static int sucheEocd(byte[] bytes, String name) throws IOException {
+    int frueheste = Math.max(0, bytes.length - EOCD_MINDESTLAENGE - KOMMENTAR_MAX);
+    for (int p = bytes.length - EOCD_MINDESTLAENGE; p >= frueheste; p--) {
+      if ((int) u32(bytes, p) == EOCD_SIGNATUR) {
+        return p;
+      }
+    }
+    throw beschaedigt(name, "das Ende des Zentralverzeichnisses fehlt");
+  }
+
+  private static Eintrag einzigesXml(List<Eintrag> eintraege, String archiv) throws IOException {
+    var xml = new ArrayList<Eintrag>();
+    for (var eintrag : eintraege) {
+      // Verzeichniseinträge tragen keinen Inhalt; „__MACOSX/“ ist Beiwerk, das macOS beim Packen
+      // hinzufügt und dessen Namen die der echten Einträge spiegeln.
+      if (eintrag.name().endsWith("/") || eintrag.name().startsWith("__MACOSX/")) {
+        continue;
+      }
+      // gii legt Gesetzen mit Anlagen deren Bilddateien mit ins Archiv — es ist deshalb nicht
+      // einerlei, welcher Eintrag genommen wird.
+      if (eintrag.dateiname().toLowerCase().endsWith(".xml")) {
+        xml.add(eintrag);
+      }
+    }
+
+    if (xml.isEmpty()) {
+      throw new IOException(
+          "Das Archiv %s enthält keine XML-Datei; erwartet wird das gii-Norm-XML von"
+                  .formatted(archiv)
+              + " gesetze-im-internet.de (xml.zip)");
+    }
+    if (xml.size() > 1) {
+      throw new IOException(
+          "Das Archiv %s enthält mehrere XML-Dateien (%s); bitte die gewünschte entpackt angeben"
+              .formatted(archiv, String.join(", ", xml.stream().map(Eintrag::name).toList())));
+    }
+    return xml.getFirst();
+  }
+
+  private static byte[] entpacke(byte[] bytes, Eintrag eintrag, String archiv) throws IOException {
+    if ((eintrag.kennzeichen() & KENNZEICHEN_VERSCHLUESSELT) != 0) {
+      throw new IOException(
+          "Der Eintrag %s im Archiv %s ist verschlüsselt".formatted(eintrag.name(), archiv));
+    }
+
+    // Der Local Header wiederholt Name und Zusatzfeld, und zwar mit eigenen Längen — die Daten
+    // beginnen erst dahinter.
+    int lokal = eintrag.offset();
+    if (lokal < 0 || lokal + 30 > bytes.length || (int) u32(bytes, lokal) != LOKAL_SIGNATUR) {
+      throw beschaedigt(
+          archiv,
+          "der Eintrag %s steht nicht dort, wo das Zentralverzeichnis ihn führt"
+              .formatted(eintrag.name()));
+    }
+    int daten = lokal + 30 + u16(bytes, lokal + 26) + u16(bytes, lokal + 28);
+    if (daten < 0 || eintrag.gepackt() < 0 || daten + eintrag.gepackt() > bytes.length) {
+      throw beschaedigt(
+          archiv, "der Eintrag %s reicht über das Dateiende hinaus".formatted(eintrag.name()));
+    }
+
+    var inhalt =
+        switch (eintrag.verfahren()) {
+          case VERFAHREN_GESPEICHERT -> {
+            var kopie = new byte[eintrag.gepackt()];
+            System.arraycopy(bytes, daten, kopie, 0, eintrag.gepackt());
+            yield kopie;
+          }
+          case VERFAHREN_DEFLATE ->
+              inflate(bytes, daten, eintrag.gepackt(), eintrag.entpackt(), eintrag.name(), archiv);
+          default ->
+              throw new IOException(
+                  "Der Eintrag %s im Archiv %s ist mit dem unbekannten Verfahren %d gepackt"
+                      .formatted(eintrag.name(), archiv, eintrag.verfahren()));
+        };
+
+    if (crc32(inhalt) != eintrag.crc()) {
+      throw beschaedigt(
+          archiv, "die Prüfsumme des Eintrags %s stimmt nicht".formatted(eintrag.name()));
+    }
+    return inhalt;
+  }
+
+  /**
+   * Rohes Deflate ohne zlib-Rahmen — daher {@code new Inflater(true)}. Die Ausgabegröße steht im
+   * Zentralverzeichnis, es wird also genau einmal ausgelesen und nicht nachgewachsen.
+   */
+  private static byte[] inflate(
+      byte[] bytes, int von, int gepackt, int entpackt, String eintrag, String archiv)
+      throws IOException {
+    if (entpackt < 0) {
+      throw beschaedigt(
+          archiv, "der Eintrag %s gibt eine unbrauchbare Größe an".formatted(eintrag));
+    }
+    var inflater = new Inflater(true);
+    try {
+      inflater.setInput(bytes, von, gepackt);
+      var aus = new byte[entpackt];
+      int gefuellt = 0;
+      while (gefuellt < entpackt) {
+        int geschrieben = inflater.inflate(aus, gefuellt, entpackt - gefuellt);
+        if (geschrieben == 0 && (inflater.finished() || inflater.needsInput())) {
+          throw beschaedigt(
+              archiv, "der Eintrag %s endet vor der angegebenen Größe".formatted(eintrag));
+        }
+        gefuellt += geschrieben;
+      }
+      return aus;
+    } catch (DataFormatException e) {
+      throw new IOException(
+          "Der Eintrag %s im Archiv %s lässt sich nicht entpacken: %s"
+              .formatted(eintrag, archiv, e.getMessage()),
+          e);
+    } finally {
+      inflater.end();
+    }
+  }
+
+  /**
+   * CRC-32 (IEEE 802.3) in reinem Java. {@code java.util.zip.CRC32} ruft eine native Routine des
+   * JDK auf, die Web Image nicht kennt; die Tabelle wird deshalb hier aufgebaut.
+   */
+  private static long crc32(byte[] daten) {
+    long crc = 0xFFFFFFFFL;
+    for (var b : daten) {
+      crc ^= b & 0xFF;
+      for (int i = 0; i < 8; i++) {
+        crc = (crc >>> 1) ^ (0xEDB88320L & -(crc & 1));
+      }
+    }
+    return crc ^ 0xFFFFFFFFL;
+  }
+
+  private static IOException beschaedigt(String archiv, String grund) {
+    return new IOException("Das Archiv %s ist beschädigt: %s".formatted(archiv, grund));
+  }
+
+  private static int u16(byte[] bytes, int p) {
+    return (bytes[p] & 0xFF) | ((bytes[p + 1] & 0xFF) << 8);
+  }
+
+  private static long u32(byte[] bytes, int p) {
+    return (bytes[p] & 0xFFL)
+        | ((bytes[p + 1] & 0xFFL) << 8)
+        | ((bytes[p + 2] & 0xFFL) << 16)
+        | ((bytes[p + 3] & 0xFFL) << 24);
+  }
+}
diff --git a/src/main/java/eu/mulk/aendggner/aenderung/parse/PatchTextExtraktor.java b/src/main/java/eu/mulk/aendggner/aenderung/parse/PatchTextExtraktor.java
index daa72c5..876f0b5 100644
--- a/src/main/java/eu/mulk/aendggner/aenderung/parse/PatchTextExtraktor.java
+++ b/src/main/java/eu/mulk/aendggner/aenderung/parse/PatchTextExtraktor.java
@@ -44,7 +44,7 @@ public final class PatchTextExtraktor {
     return switch (typ) {
       case PDF -> extrahierePdf(quelle.inhalt());
       case KLARTEXT -> new String(quelle.inhalt(), StandardCharsets.UTF_8);
-      case XML ->
+      case XML, ZIP ->
           throw new IOException(
               "Nicht unterstützter Dateityp %s für %s (unterstützt: PDF, Klartext)"
                   .formatted(typ.anzeigeName(), quelle.name()));
diff --git a/src/main/java/eu/mulk/aendggner/gesetz/land/LandesRechtLoader.java b/src/main/java/eu/mulk/aendggner/gesetz/land/LandesRechtLoader.java
index 22c1e41..f5e777a 100644
--- a/src/main/java/eu/mulk/aendggner/gesetz/land/LandesRechtLoader.java
+++ b/src/main/java/eu/mulk/aendggner/gesetz/land/LandesRechtLoader.java
@@ -49,7 +49,7 @@ public final class LandesRechtLoader {
           case KLARTEXT ->
               Normalizer.normalize(
                   new String(quelle.inhalt(), StandardCharsets.UTF_8), Normalizer.Form.NFC);
-          case XML ->
+          case XML, ZIP ->
               throw new IOException(
                   "Nicht unterstützter Dateityp %s für Stammgesetz %s (unterstützt: PDF, Klartext)"
                       .formatted(typ.anzeigeName(), quelle.name()));