feat(regex): close every D-447 gap — named groups, \A \z \Z, class algebra

The regex-equivalence audit's remaining gaps, all landed or settled:

  - Named groups `(?<name>e)`: a capturing group sharing Java's numbering,
    duplicate names rejected, name→index bindings on the Program, and
    `(.group m "name")` on Matcher.
  - `\A \z \Z` anchors; `\Z` honours a final `\n` / `\r` / `\r\n` (Java
    parity), all three MULTILINE-independent.
  - Character-class ALGEBRA: nested unions `[a[b]]` and `&&` intersection
    (`[a-z&&[^m-p]]`), via a recursive class parser over the existing
    bitmap+RangeSet representation. This is also what `[[:alpha:]]` IS in
    Java — the D-447 row called it "POSIX classes", but Java has no POSIX
    bracket classes; it parses them as a nested union (oracle-verified:
    clj matches "a" in "ab1"). The row's framing was a mis-diagnosis.
  - Empty alternatives and groups: `()` and `a|` are legal Java (match
    empty) and were misrouted to the unsupported signal.
  - Lookbehind had already landed; the row was stale on it.

Backreferences are PERMANENTLY DECLINED as AD-060, not deferred: ADR-0031's
Pike-NFA linear-time guarantee is the property that lets untrusted patterns
run without a ReDoS budget, a backreference forces a backtracking engine,
and RE2 rejects them for exactly this reason.

The signal split deferred from the data-vs-feature sweep lands with it:
a MALFORMED pattern raises the CATCHABLE `regex_pattern_invalid` (Java
PatternSyntaxException parity), routed through one shared
`regex_value.raiseCompileError` used by every compile surface — re-pattern,
regex literals, Pattern/compile+matches, String .matches/.split/replace,
clojure.string/split — while a valid-in-Java feature cljw declines stays
the uncatchable unsupported signal.

Corpus-backed per the row's own mandate: 15 clj-byte-matched goldens in
regex_equivalence.txt covering every landed feature plus the catchable
invalid cases; pin e2e regex_parity_gaps.sh asserts the catchable/
uncatchable split the corpus cannot express. compile.zig's header now
states the true surface (the row's depth-1 doc-fix item). D-447 discharged.

Smell-audited: 2: the row said "POSIX classes" and the first instinct was to
implement POSIX classes — the oracle said Java doesn't have them, so what
landed is what Java actually does. Also caught my own stale unit test
asserting the pre-split error for "(" and updated it to the new contract
rather than weakening the contract to fit the test.

Author: chaploud

.dev/accepted_divergences.yaml

@@ -945,3 +945,25 @@ accepted:
       be wrong.
     derives_from: "ADR-0181 (doc coverage is a ledger of decisions) + .claude/rules/clj_attribution.md (the two header variants) + EPL-1.0 §7 redistribution."
     pin: "scripts/check_clj_attribution.sh --gate (the variant-1 file set must equal legal/NOTICE's list, both directions) + test/diff/clj_corpus/set_arity.txt (17 golden pairs incl. every arity and the :doc/:arglists reads)."
+  - id: "AD-060"
+    area: "regex"
+    summary: |-
+      Backreferences (`\1` … `\9`, `\k<name>`) raise the UNCATCHABLE
+      unsupported-feature error at pattern-compile time; Java compiles and
+      matches them. This is the RE2 posture, permanent by design, not a
+      pending gap: cljw's matcher is a Pike-NFA (ADR-0031) whose worst case is
+      linear in the input, which is the property that lets the playground run
+      untrusted patterns without a ReDoS budget. A backreference makes
+      matching NP-hard in general and forces a backtracking engine — RE2
+      rejects backreferences for exactly this reason. The raise is the
+      unsupported-feature signal (not the catchable invalid-pattern error),
+      because the pattern is VALID Java that cljw deliberately declines,
+      distinct from a malformed pattern the user should catch and handle
+      (regex_pattern_invalid, which IS catchable, matching Java's
+      PatternSyntaxException). Every other D-447 gap closed 2026-08-05:
+      lookbehind, named groups `(?<name>…)` (+ `.group m "name"`), `\A \z \Z`,
+      nested class unions `[a[b]]` / `&&` intersection, empty
+      alternatives/groups.
+    example: '(re-pattern "(a)\\1") => cljw UNCATCHABLE "this regex feature … is not supported" / clj #"(a)\1" compiles and (re-matches #"(a)\1" "aa") => ["aa" "a"]'
+    derives_from: "ADR-0031 (Pike-NFA, non-backtracking invariant — linear-time matching is the security property, F-002 finished form)."
+    pin: "test/e2e/regex_parity_gaps.sh — backref compile raises the uncatchable unsupported signal and a (catch Throwable …) does NOT swallow it."

.dev/debt.yaml

@@ -1354,11 +1354,6 @@ active:
     category: "perf"
     barrier: "none hard — O-023 already ships the effective form. The 正しい姿 unification is a deliberate refactor that touches the gate-green O-023 path; a transducer stack (map's fn) ≠ a pred vector, so the unified representation needs design. Take up alongside a reduce-heavy bench that the current `[xform coll]` descriptor under-serves, or when the lazy-walk collapse is revisited with a real workload. Not blocking; the existing fused-reduce is correct + fast."
     last_reviewed: "2026-06-15"
-  - id: "D-447"
-    status: "open (2026-06-15, regex equivalence audit / ADR-0147). Regex parity gaps cljw's Pike-NFA matcher does NOT support — all currently RAISE NotImplemented (never silently wrong; the 48-golden `test/diff/clj_corpus/regex_equivalence.txt` deliberately excludes them; reluctant quantifiers `*? +? ?? {n,m}?` LANDED 2026-06-16 — split-priority swap pairing with the cut-on-match leftmost-first fix + a dedicated matchFull loop for the re-matches full-span case, corpus regex_equivalence): lookbehind `(?<=)`/`(?<!)`, named groups `(?<name>)`, backreferences `\\1`, `\\A \\z \\Z`, POSIX `[[:class:]]`. (Lookahead `(?=)`/`(?!)` and all four flags `(?imsx)` DO work.) NOT campaign-blocking — addressed only when a real workload needs them OR opportunistically alongside the ADR-0147 regex-perf engine work (reluctant quantifiers are a cheap split-priority swap that pairs naturally with the matcher changes; backrefs would need a backtracking fallback cljw rejects per ADR-0031, so likely stay a documented gap / RE2 posture). When a gap closes, MOVE its goldens into the equivalence corpus in the same cycle (corpus-backed discharge, anti-D-177). Also a depth-1 doc fix: `compile.zig:22-23` claims 'lookaround' unsupported but lookahead works."
-    category: "clj-parity"
-    barrier: "none — each gap is a bounded matcher/compiler feature. Reluctant quantifiers DONE 2026-06-16 (the cheap split-priority swap). Remaining: take up opportunistically when a lib/workload needs one. Backrefs conflict with the non-backtracking invariant (ADR-0031) — likely an accepted gap, not a fix. lookbehind/named-groups/`\\A\\z\\Z`/POSIX-classes are bounded compiler features."
-    last_reviewed: "2026-06-15"
   - id: "D-462"
     status: "PARTIAL (2026-06-18 — java.time LOCAL FAMILY WIRED; only ZonedDateTime + arithmetic methods residual). Instant, Duration, LocalDateTime, LocalDate, LocalTime are all wired as `.typed_instance` values (per-Runtime descriptors; timestamp.zig/date.zig model — NO new NaN-box tag): statics (of/now/parse/ofEpoch*) + readers + (str) ISO-grounded vs clj + value `=` + cross-refs (LocalDateTime.toLocalDate/toLocalTime). Shared civil + ISO date/time format/parse helpers live in runtime/time/instant.zig; the typed_instance print form is a `temporal_print` enum on TypeDescriptor; value-wrap files in the compat_tiers `wrap:` slot (G3-clean). e2e: phase15_java_time_{instant,duration,local_date_time,local_date}.sh (clj-grounded, incl. negative/pre-1970/1900-non-leap/ns-precision edges). pr-str divergence (bare toString vs clj `#object[…]`) = AD-042. RESIDUAL: (1) ZonedDateTime DEFERRED — needs a bundled IANA tz database for named zones (scope decision, user/ADR-owned; see compat_tiers status); (3) LocalDateTime.now is UTC-based (no zone DB). RESIDUAL (2) RESOLVED (2026-06-20): a verify-sweep (anti-D-177, 24 methods × clj oracle) found the 2026-06-18 'arithmetic NOT implemented' claim was STALE — plus*/minus*/plusWeeks/plusMonths/plusYears/isBefore/isAfter/isEqual (LocalDate), plus*/minus*/isBefore/isEqual (LocalDateTime/LocalTime), plusSeconds/plusMillis/plusNanos/minus*/isBefore (Instant), multipliedBy/negated/toMinutes/between (Duration) ALL already worked + matched clj. The ONLY genuinely-missing methods were LocalDate.atStartOfDay (→ LocalDateTime at midnight) + LocalDate.atTime (h m / h m s / h m s ns → LocalDateTime), now IMPLEMENTED in local_date_value.zig (atStartOfDayFn/atTimeFn → local_date_time_value.make(rt, epoch_day, nano_of_day); out-of-range time fields raise like JVM DateTimeException, message differs per AD-007). clj-verified incl. ns-precision + toLocalDate round-trip; e2e phase15_java_time_local_date_arith.sh (at-time case). The original UNWIRED finding (static-method class resolution + empty method_tables + compat_tiers over-claim) is fully resolved for the local family. ROW NOW OPEN ONLY FOR ZonedDateTime (residual 1, user/ADR-owned tz-DB) + the LDT.now-UTC note (residual 3)."
     category: "clj-parity"
@@ -2696,6 +2691,33 @@ standing:
     barrier: "open after the D-440 arc completes (R4 + R5 must first rewrite the bulk of 'Phase N' citations to gap-area terms). Premature adoption = ~70 dangling citations with no 1:1 redirect. Trigger: D-440 R4/R5 done + a user nod to re-architect the planning axis (it is depth-4, the project's organizing metaphor)."
     last_reviewed: "2026-06-15"
 discharged:
+  - id: "D-447"
+    status: |-
+      DISCHARGED 2026-08-05 — every named gap closed or settled, corpus-backed.
+      IMPLEMENTED: named groups `(?<name>e)` (shared Java numbering, duplicate
+      names rejected, `.group m "name"` on Matcher); `\A \z \Z` anchors (\Z
+      honours a final \n / \r / \r\n); nested class unions `[a[b]]` and `&&`
+      intersection (which is what `[[:alpha:]]` actually IS in Java — the row's
+      "POSIX classes" framing was a mis-diagnosis: Java has no POSIX bracket
+      classes, it parses them as a nested union, verified on the oracle);
+      empty alternatives/groups `()` `a|` (were misrouted to NotImplemented).
+      Lookbehind had already landed (the row was stale). SETTLED: backreferences
+      are PERMANENTLY DECLINED as AD-060 — the RE2 posture; ADR-0031's Pike-NFA
+      linear-time guarantee is the security property, and a backref forces
+      backtracking. SIGNAL SPLIT landed with it (the task-3 deferral): a
+      MALFORMED pattern now raises the CATCHABLE `regex_pattern_invalid`
+      (Java PatternSyntaxException parity) via the shared
+      `regex_value.raiseCompileError` used by every compile surface (re-pattern,
+      literals, Pattern/compile, String .matches/.split/replace,
+      clojure.string/split); a valid-in-Java feature cljw declines stays the
+      uncatchable unsupported signal. Corpus: 15 clj-byte-matched goldens
+      appended to regex_equivalence.txt; pin e2e regex_parity_gaps.sh (3 cases
+      incl. the catchable/uncatchable split). The compile.zig header doc now
+      states the true surface (the row's depth-1 doc-fix item).
+    category: clj-parity
+    barrier: none — discharged
+    last_reviewed: "2026-08-05"
+
   - id: "D-446"
     status: "PARTIAL (2026-06-18 — MID/UNDER/over-arity sweep COMPLETE; only multidim residual open). An empirical both-sides arity probe (193 common clojure.core fns × arities 0-7, BOTH runtimes catch clojure.lang.ArityException; harness + data in private/arity_sweep/) found 22 over-strict fns (cljw REJECTS an arity clj accepts; ZERO over-lenient — the 0-arg class from the 2026-06-16 pass below stays clean). 14 fixed bug→fix (F-011): n-ary map/mapv/mapcat/list* (declare-d top-level -map-n-step + -spread, D-147 no-named-local-fn), bit-and-not variadic fold, resolve 2-arg env form (a local named in env → nil) [commit 982890aa]; the 8 typed array ctors gained the 2-arg (X-array size init-or-seq) form (uniform -array-from2 — value init fills, sequential init copies; the byte/short/char NUMBER-init divergence vs clj IS recorded as AD-036 deriving from AD-019, Devil-advocate-forked) [array commit]. Mechanised: test/diff/clj_corpus/arity_envelopes.txt (22 cases, all clj-byte-matched) + e2e phase14_arity_parity.sh (35/0). REMAINING OPEN SCOPE OF THIS ROW = multidim array indexing: (aget a i j …) and (aset a i j … v) + the typed aset-* multidim forms diverge at arity 3+/4+ (8 aset-* fns; aget is a builtin the ns-publics fn? sweep did not enumerate) — see barrier. EARLIER 0-ARG PASS (2026-06-16, kept for history): a fresh-context subagent probed the 0-ARG boundary (the not= precedent) + 22 over-arity + 20 extra-0-arg; found 10 divergences all aligned to clj — cljw-LENIENT = < > <= >= distinct? every-pred some-fn now throw; cljw-STRICT into + conj! now return clj values. ORIGINAL (2026-06-15, user-directed): arity-divergence audit — enumerate cljw fn arities, diff vs clj, classify each bug→fix or accepted→AD-NNN; big-bang-then-closed (clj_diff_sweep Discipline 2)."
     category: "clj-parity"

src/eval/analyzer/analyzer.zig

@@ -563,9 +563,7 @@ pub fn parseRatioLiteral(rt: *Runtime, digits: []const u8, loc: error_mod.Source
 pub fn parseRegexLiteral(rt: *Runtime, body: []const u8, loc: error_mod.SourceLocation) AnalyzeError!Value {
     return regex_value.alloc(rt, body, .{}) catch |err| switch (err) {
         error.OutOfMemory => return error.OutOfMemory,
-        else => return error_catalog.raise(.feature_not_supported, loc, .{
-            .name = "regex literal (unsupported syntax in cycle 1)",
-        }),
+        else => return regex_value.raiseCompileError(err, loc),
     };
 }
 

src/lang/primitive/regex.zig

@@ -56,15 +56,8 @@ pub fn rePattern(rt: *Runtime, env: *Env, args: []const Value, loc: SourceLocati
         });
     }
     const src = string_collection.asString(args[0]);
-    return regex_value.alloc(rt, src, .{}) catch |err| switch (err) {
-        error.OutOfMemory => err,
-        // INV-1: a nested-counted-repetition compile-bomb is a catchable error,
-        // not an OOM / process kill.
-        error.PatternTooLarge => error_catalog.raise(.regex_pattern_too_large, loc, .{}),
-        else => error_catalog.raise(.feature_not_supported, loc, .{
-            .name = "re-pattern (unsupported syntax in cycle 1)",
-        }),
-    };
+    return regex_value.alloc(rt, src, .{}) catch |err|
+        regex_value.raiseCompileError(err, loc);
 }
 
 /// `(re-find re s)` — search for the first match of `re` anywhere
@@ -214,14 +207,8 @@ fn coerceRegex(rt: *Runtime, v: Value, loc: SourceLocation, fn_name: []const u8)
     if (v.tag() == .regex) return regex_value.asRegex(v);
     if (v.tag() == .string) {
         const src = string_collection.asString(v);
-        const compiled = regex_value.alloc(rt, src, .{}) catch |err| switch (err) {
-            error.OutOfMemory => return err,
-            // INV-1: compile-bomb pattern is a catchable error, not an OOM.
-            error.PatternTooLarge => return error_catalog.raise(.regex_pattern_too_large, loc, .{}),
-            else => return error_catalog.raise(.feature_not_supported, loc, .{
-                .name = "re-find / re-matches with invalid pattern (cycle 1)",
-            }),
-        };
+        const compiled = regex_value.alloc(rt, src, .{}) catch |err|
+            return regex_value.raiseCompileError(err, loc);
         return regex_value.asRegex(compiled);
     }
     return error_catalog.raise(.type_arg_not_string, loc, .{

src/lang/primitive/string.zig

@@ -491,7 +491,7 @@ fn coerceRegex(rt: *Runtime, v: Value, loc: SourceLocation, fn_name: []const u8)
     if (v.tag() == .string) {
         const compiled = regex_value.alloc(rt, string_collection.asString(v), .{}) catch |err| switch (err) {
             error.OutOfMemory => return err,
-            else => return error_catalog.raise(.feature_not_supported, loc, .{ .name = "clojure.string/split with invalid regex source" }),
+            else => |e| return regex_value.raiseCompileError(e, loc),
         };
         return regex_value.asRegex(compiled);
     }

src/runtime/error/catalog.zig

@@ -57,6 +57,13 @@ pub const Code = enum {
     inst_string_invalid,
     json_string_invalid,
     edn_string_invalid,
+    /// A malformed regex PATTERN (unclosed group/class, dangling quantifier,
+    /// bad escape) — Java throws the catchable PatternSyntaxException
+    /// (⊂ IllegalArgumentException), so this is bad DATA, kind value_error.
+    /// Distinct from a VALID-in-Java pattern using a feature cljw does not
+    /// implement (backreferences), which stays the uncatchable
+    /// `feature_not_supported`.
+    regex_pattern_invalid,
     /// A user-written FORM SHAPE the runtime rejects — a malformed libspec,
     /// destructuring directive, import spec, `.` member form, reader
     /// conditional. Bad DATA (the user's code is the data), so CATCHABLE:
@@ -578,6 +585,11 @@ pub fn entry(comptime code: Code) Entry {
             .phase = .parse,
             .template = "EDN error ({[reason]s})",
         },
+        .regex_pattern_invalid => .{
+            .kind = .value_error,
+            .phase = .eval,
+            .template = "invalid regex pattern ({[reason]s})",
+        },
         .form_malformed => .{
             .kind = .syntax_error,
             .phase = .analysis,

src/runtime/java/lang/String.zig

@@ -23,6 +23,7 @@ const SourceLocation = @import("../../error/info.zig").SourceLocation;
 const error_catalog = @import("../../error/catalog.zig");
 const charset = @import("../../charset.zig");
 const string_collection = @import("../../collection/string.zig");
+const regex_value = @import("../../regex/value.zig");
 const regex_compile = @import("../../regex/compile.zig");
 const regex_match = @import("../../regex/match.zig");
 const regex_replace = @import("../../regex/replace.zig");
@@ -446,8 +447,8 @@ fn matches(rt: *Runtime, env: *Env, args: []const Value, loc: SourceLocation) an
     try error_catalog.checkArity(".matches", args, 2, loc);
     if (args[1].tag() != .string)
         return error_catalog.raise(.type_arg_not_string, loc, .{ .fn_name = ".matches", .actual = @tagName(args[1].tag()) });
-    var program = regex_compile.compile(rt.gpa, string_collection.asString(args[1]), .{}) catch
-        return error_catalog.raise(.feature_not_supported, loc, .{ .name = ".matches (invalid regex pattern)" });
+    var program = regex_compile.compile(rt.gpa, string_collection.asString(args[1]), .{}) catch |err|
+        return regex_value.raiseCompileError(err, loc);
     defer program.deinit(rt.gpa);
     const m = regex_match.matchFull(rt.gpa, &program, string_collection.asString(args[0])) catch
         return error_catalog.raise(.feature_not_supported, loc, .{ .name = ".matches" });
@@ -465,8 +466,8 @@ fn replaceRegex(rt: *Runtime, fn_name: []const u8, kind: regex_replace.ReplaceKi
         return error_catalog.raise(.type_arg_not_string, loc, .{ .fn_name = fn_name, .actual = @tagName(args[1].tag()) });
     if (args[2].tag() != .string)
         return error_catalog.raise(.type_arg_not_string, loc, .{ .fn_name = fn_name, .actual = @tagName(args[2].tag()) });
-    var program = regex_compile.compile(rt.gpa, string_collection.asString(args[1]), .{}) catch
-        return error_catalog.raise(.feature_not_supported, loc, .{ .name = "regex-replace (invalid regex pattern)" });
+    var program = regex_compile.compile(rt.gpa, string_collection.asString(args[1]), .{}) catch |err|
+        return regex_value.raiseCompileError(err, loc);
     defer program.deinit(rt.gpa);
     return regex_replace.replaceString(rt, &program, string_collection.asString(args[0]), string_collection.asString(args[2]), kind);
 }
@@ -494,8 +495,8 @@ fn split(rt: *Runtime, env: *Env, args: []const Value, loc: SourceLocation) anye
     if (args[1].tag() != .string)
         return error_catalog.raise(.type_arg_not_string, loc, .{ .fn_name = ".split", .actual = @tagName(args[1].tag()) });
     const limit: i64 = if (args.len == 3) try error_catalog.expectInteger(args[2], ".split", loc) else 0;
-    var program = regex_compile.compile(rt.gpa, string_collection.asString(args[1]), .{}) catch
-        return error_catalog.raise(.feature_not_supported, loc, .{ .name = ".split (invalid regex pattern)" });
+    var program = regex_compile.compile(rt.gpa, string_collection.asString(args[1]), .{}) catch |err|
+        return regex_value.raiseCompileError(err, loc);
     defer program.deinit(rt.gpa);
     return regex_replace.splitToVector(rt, &program, string_collection.asString(args[0]), limit);
 }

src/runtime/java/util/regex/Matcher.zig

@@ -159,6 +159,20 @@ fn group(rt: *Runtime, env: *Env, args: []const Value, loc: SourceLocation) anye
     const input = inputOf(args[0]);
     if (args.len == 1)
         return string_collection.alloc(rt, input[ms.start..ms.end]);
+    // `(.group m "name")` — a `(?<name>…)` group by name (Java group(String)).
+    if (args[1].tag() == .string) {
+        const want = string_collection.asString(args[1]);
+        for (programOf(args[0]).group_names) |g| {
+            if (std.mem.eql(u8, g.name, want)) {
+                const gs = ms.slots[@intCast(2 * @as(u32, g.index))];
+                const ge = ms.slots[@intCast(2 * @as(u32, g.index) + 1)];
+                if (gs < 0 or ge < 0) return Value.nil_val;
+                return string_collection.alloc(rt, input[@intCast(gs)..@intCast(ge)]);
+            }
+        }
+        // Java: IllegalArgumentException "No group with name <x>" — catchable.
+        return error_catalog.raise(.arg_value_invalid, loc, .{ .fn_name = ".group", .expected = "a declared (?<name>…) group", .actual = "an unknown group name" });
+    }
     if (args[1].tag() != .integer)
         return error_catalog.raise(.type_arg_not_integer, loc, .{ .fn_name = ".group", .actual = @tagName(args[1].tag()) });
     const n = args[1].asInteger();