feat(core): recursive DNS server after Java, measured with Java FILIUS

The resolver runs on the events now (a query, its dnsQueryTimeout, its
answer at the socket); the blocking resolveDns waits for it, and a
recursive server uses it: its own records, else the zone's name server
from its records, else its own DNS server, else a referral
(DNSServer.answerWithRemoteData).

DnsRun plays five stories on the new dns-recursive network. Measured and
not taken: a server that is its zone's name server asks itself, which asks
itself again, without end (the client times out, then every level floods
its own DNS server); Java guards only the step through its own DNS server.
The core asks itself in neither step. That story is compared up to the
client's query (JAVA_UNTIL).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

tools/java-oracle/README.md

@@ -267,6 +267,26 @@ Nameservers im Antwortteil. Der Resolver folgt dem Verweis selbst
 (iterativ) und wartet je Anfrage 5 RTT (13750 ms bei 90 %); ohne Server
 fragt ARP zweimal im Abstand einer RTT, dann scheitert der Aufruf.
 
+Auf dem Netz von `dns-recursive` (sonst wie `dns-lan`) löst 192.168.0.10
+rekursiv auf, sein eigener DNS-Server ist .11, und er führt die Zone
+`filius.de` mit sich selbst als Nameserver. Abläufe
+(`dns-recursive-java-<ablauf>.java.json`): `address` (eigener Eintrag),
+`referral` (`www.schule.de` über den NS von `schule.de`), `unknown`
+(`x.unbekannt.org`), `unknownInZone` (`nix.schule.de`, das .11 nicht kennt),
+`unknownInOwnZone` (`nix.filius.de`).
+
+Gemessen (30.09.2026): Findet der Server nichts in seinen Einträgen, fragt
+er selbst, mit seinem eigenen Resolver (iterativ, 5 RTT je Anfrage): zuerst
+den Nameserver der längsten passenden Zone aus seinen Einträgen, bringt das
+nichts, seinen eigenen DNS-Server (nur wenn das nicht er selbst ist). Die
+Antwort an den Client enthält, was er gelernt hat, sonst den Verweis (NS und
+A). Bei `unknownInZone` fragt er .11 also zweimal. Bei `unknownInOwnZone`
+fragt er als Nameserver der Zone sich selbst, ohne Ende: Jede Ebene erzeugt
+die nächste (ohne Frames, die Anfragen bleiben im Rechner), der Client gibt
+nach 5 RTT auf, dann laufen die inneren Ebenen nacheinander ab und fragen
+ersatzweise .11, eine Anfrage alle 55 ms. Ein Java-Fehler; der Kern fragt
+sich weder als Nameserver noch als DNS-Server selbst.
+
 ## ARP zur Laufzeit
 
 `ArpRun` sendet auf dem Netz von `arp-routed` (10.0.0.2 über einen Switch am

tools/java-oracle/run.sh

@@ -141,6 +141,16 @@ for run in address:5000 mail:5000 referral:5000 unknown:5000 noServer:22000; do
         "$root/packages/core/test/scenarios/dns-lan.scenario.json" "$story" "${run##*:}" "$output" 2>&1 | grep -v 'logback\|^$' || true
     test -s "$output"
 done
+# The same with a recursive server (dns-recursive). unknownInOwnZone asks
+# itself without end: a short run, and a bounded heap.
+for run in address:5000 referral:5000 unknown:5000 unknownInZone:5000 unknownInOwnZone:15500; do
+    story="${run%%:*}"
+    output="$root/packages/core/test/scenarios/dns-recursive-java-$story.java.json"
+    rm -f "$output"
+    HOME="$here/.build/home" xvfb-run -a java -Xmx1g -cp "$classpath:$here/.build" DnsRun \
+        "$root/packages/core/test/scenarios/dns-recursive.scenario.json" "$story" "${run##*:}" "$output" 2>&1 | grep -v 'logback\|^$' || true
+    test -s "$output"
+done
 
 # ARP as Java FILIUS runs it: sends to addresses no card has on arp-routed's
 # network (ArpRun); frames and the calls, for the core's ARP comparison.

tools/java-oracle/src/DnsRun.java

@@ -12,6 +12,11 @@
 //   referral   192.168.0.20 asks for www.schule.de (A), referred to .11
 //   unknown    192.168.0.20 asks for x.unbekannt.org, which no one knows
 //   noServer   192.168.0.21 asks its DNS server 192.168.0.99, which is not there
+//
+// On dns-recursive's network .10 resolves recursively, its own DNS server is
+// .11, and it holds filius.de's NS record, which names itself. There also:
+//   unknownInZone     192.168.0.20 asks for nix.schule.de, which .11 does not know
+//   unknownInOwnZone  192.168.0.20 asks for nix.filius.de, in .10's own zone
 
 import filius.software.dns.Resolver;
 
@@ -62,6 +67,12 @@ public class DnsRun {
             case "unknown":
                 call("holeIPAdresse x.unbekannt.org", () -> client.holeIPAdresse("x.unbekannt.org"));
                 break;
+            case "unknownInZone":
+                call("holeIPAdresse nix.schule.de", () -> client.holeIPAdresse("nix.schule.de"));
+                break;
+            case "unknownInOwnZone":
+                call("holeIPAdresse nix.filius.de", () -> client.holeIPAdresse("nix.filius.de"));
+                break;
             case "noServer":
                 Resolver lost = network.system(LOST_CLIENT).holeDNSClient();
                 call("holeIPAdresse web.filius.de", () -> lost.holeIPAdresse("web.filius.de"));