Add L2 positional UA markers on date components

Extends the parser chain to recognise UA markers (?, ~, %) attached
to individual year, month, or day components rather than to the
whole date. Uses the Bitmask.UA[] positional table to OR the right
bits into the uncertain / approximate masks.

L2Parser
  New tryParsePositionalUa method scans through an input that
  contains at least one UA character and checks for markers at
  each of the six positions defined in the grammar:

      [UA]YYYY[UA]-[UA]MM[UA]-[UA]DD[UA]
         0    1    2    3    4    5

  Each present marker OR's Bitmask.UA[position] into the
  uncertain (for ? or %) or approximate (for ~ or %) mask.
  Returns null if no marker is present (lets other L2 branches
  handle the input) or if the input shape is unrecognised.

L1Parser
  parseUaDate now picks the mask based on the date's precision
  (YEAR / YM / YMD) instead of always using YMD, matching
  edtf.js's Date.bits behaviour. This keeps 2020? at L1 while
  letting 2020?-05~ (mixed year + month qualifiers) promote to
  L2 through the level-detection rule in EdtfDate.level().

  parseEndpoint for intervals now delegates to the top-level
  Edtf.parse so L2 season / mask / positional-UA endpoints parse
  correctly inside interval shapes.

EdtfDate
  level() now returns L2 when the uncertain and approximate masks
  are non-zero AND unequal (the combination isn't expressible as
  a single L1 whole-date marker). toEdtfString uses
  Bitmask.marks to position the UA characters per the qualified()
  positions from edtf.js/src/bitmask.js, replacing combined ?~
  or ~? with %.

L2PositionalUaTest
  Six tests covering leading ?, positional ?/~/% on month and day,
  mixed uncertain+approximate that elevates to L2, and the L1
  whole-date case that stays L1 for regression coverage.

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

Author: jeffreyameyer

src/main/java/io/github/openhistoricalmap/edtf/parser/L1Parser.java

@@ -120,9 +120,17 @@ private static EdtfDate parseUaDate(Cursor c) {
         }
         c.accept(ch);
 
-        Bitmask ymdMask = new Bitmask(Bitmask.YMD);
-        Bitmask u = (ch == '?' || ch == '%') ? ymdMask : Bitmask.EMPTY;
-        Bitmask a = (ch == '~' || ch == '%') ? ymdMask : Bitmask.EMPTY;
+        // L1 trailing UA covers all components up to the date's
+        // precision. Per edtf.js Date.bits(): year-precision -> YEAR,
+        // month-precision -> YM, day-precision or beyond -> YMD.
+        int maskValue = switch (date.precision()) {
+            case YEAR -> Bitmask.YEAR;
+            case MONTH -> Bitmask.YM;
+            case DAY, MINUTE, SECOND, MILLISECOND -> Bitmask.YMD;
+        };
+        Bitmask mask = new Bitmask(maskValue);
+        Bitmask u = (ch == '?' || ch == '%') ? mask : Bitmask.EMPTY;
+        Bitmask a = (ch == '~' || ch == '%') ? mask : Bitmask.EMPTY;
         return date.withQualifiers(u, a, Bitmask.EMPTY);
     }
 
@@ -251,13 +259,13 @@ private static Endpoint parseEndpoint(String s) {
         if (s.isEmpty()) return Endpoint.Unknown.INSTANCE;
         if (s.equals("..")) return Endpoint.Open.INSTANCE;
         try {
-            return new Endpoint.Bounded(L0Parser.parse(s));
-        } catch (EdtfParseException ignored) {}
-        try {
-            Cursor c = new Cursor(s);
-            EdtfTemporal t = parseNonInterval(c);
-            if (c.atEnd()) return new Endpoint.Bounded(t);
-        } catch (EdtfParseException ignored) {}
-        throw new EdtfParseException("invalid interval endpoint: " + s, s);
+            // Delegate to the top-level facade so L2 endpoints
+            // (extended seasons, decades, masked / positional-UA
+            // dates, etc.) are accepted alongside L0 and L1.
+            return new Endpoint.Bounded(
+                io.github.openhistoricalmap.edtf.Edtf.parse(s));
+        } catch (EdtfParseException e) {
+            throw new EdtfParseException("invalid interval endpoint: " + s, s);
+        }
     }
 }

src/main/java/io/github/openhistoricalmap/edtf/types/EdtfDate.java

@@ -133,22 +133,28 @@ public EdtfDate withQualifiers(Bitmask uncertain, Bitmask approximate, Bitmask u
             uncertain.value() != 0 || approximate.value() != 0 || unspecified.value() != 0;
         if (!hasFlags) return EdtfLevel.L0;
 
-        // L1 masks are the "whole-field" values only: YEAR, MONTH, DAY,
-        // YM, MD, YMD, YYXX, YYYX, XXXX (= YEAR), plus 0. Any other
-        // value is an L2 partial mask.
-        if (!isL1Mask(unspecified.value())) return EdtfLevel.L2;
-
-        // L1 qualifiers are whole-date only: uncertain / approximate
-        // either 0 or YMD.
+        // L1 unspecified masks are "whole-field" values only: YEAR,
+        // MONTH, DAY, YM, MD, YMD, YYXX, YYYX, XXXX (= YEAR), plus 0.
+        // Any other value is an L2 partial mask.
+        if (!isL1UnspecifiedMask(unspecified.value())) return EdtfLevel.L2;
+
+        // L1 UA qualifiers cover everything up to the date's precision:
+        // 0 (no qualifier), YEAR, YM, or YMD.
+        if (!isL1UaMask(uncertain.value())) return EdtfLevel.L2;
+        if (!isL1UaMask(approximate.value())) return EdtfLevel.L2;
+
+        // If BOTH uncertain and approximate are set, they must match
+        // to be expressible as a single % marker at a whole-date L1
+        // level. Mismatched masks (e.g., year uncertain + month
+        // approximate) are L2.
         int u = uncertain.value();
         int a = approximate.value();
-        if (u != 0 && u != Bitmask.YMD) return EdtfLevel.L2;
-        if (a != 0 && a != Bitmask.YMD) return EdtfLevel.L2;
+        if (u != 0 && a != 0 && u != a) return EdtfLevel.L2;
 
         return EdtfLevel.L1;
     }
 
-    private static boolean isL1Mask(int mask) {
+    private static boolean isL1UnspecifiedMask(int mask) {
         return mask == 0
             || mask == Bitmask.YEAR
             || mask == Bitmask.MONTH
@@ -160,6 +166,13 @@ private static boolean isL1Mask(int mask) {
             || mask == Bitmask.YYYX;
     }
 
+    private static boolean isL1UaMask(int mask) {
+        return mask == 0
+            || mask == Bitmask.YEAR
+            || mask == Bitmask.YM
+            || mask == Bitmask.YMD;
+    }
+
     @Override public long min() {
         if (unspecified.value() != 0) {
             return computeMaskedMin();
@@ -294,10 +307,37 @@ private long toInstantMillis(boolean exclusiveEnd) {
         if (unspecified.value() != 0) {
             return renderMasked();
         }
-        // Qualified dates (L1 whole-date UA): emit with trailing marker.
-        String body = renderPlainDate();
-        String marker = resolveUaMarker();
-        return body + marker;
+        // Date-only value with UA markers: use positional rendering.
+        if (!precision.isAtomic()
+            && (uncertain.value() != 0 || approximate.value() != 0)) {
+            return renderPositionalUa();
+        }
+        // No UA or datetime: fall through.
+        return renderPlainDate();
+    }
+
+    /**
+     * Render the date with UA markers placed per
+     * {@link Bitmask#qualified(int)}. Uses the {@code %} combined
+     * form where a position carries both {@code ?} and {@code ~}.
+     */
+    private String renderPositionalUa() {
+        String[] values = switch (precision) {
+            case YEAR -> new String[]{padYear(year)};
+            case MONTH -> new String[]{padYear(year), pad2(month)};
+            case DAY -> new String[]{padYear(year), pad2(month), pad2(day)};
+            default -> throw new IllegalStateException("UA not supported for " + precision);
+        };
+        if (uncertain.value() != 0) {
+            values = uncertain.marks(values, '?');
+        }
+        if (approximate.value() != 0) {
+            values = approximate.marks(values, '~');
+            for (int i = 0; i < values.length; i++) {
+                values[i] = values[i].replace("?~", "%").replace("~?", "%");
+            }
+        }
+        return String.join("-", values);
     }
 
     private String renderMasked() {
@@ -310,15 +350,6 @@ private String renderMasked() {
         return sb.toString();
     }
 
-    private String resolveUaMarker() {
-        int u = uncertain.value();
-        int a = approximate.value();
-        if (u != 0 && a != 0) return "%";
-        if (u != 0) return "?";
-        if (a != 0) return "~";
-        return "";
-    }
-
     private String renderPlainDate() {
         StringBuilder sb = new StringBuilder();
         sb.append(padYear(year));

src/test/java/io/github/openhistoricalmap/edtf/parser/L2PositionalUaTest.java

@@ -0,0 +1,66 @@
+package io.github.openhistoricalmap.edtf.parser;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import io.github.openhistoricalmap.edtf.Edtf;
+import io.github.openhistoricalmap.edtf.EdtfLevel;
+import io.github.openhistoricalmap.edtf.types.EdtfDate;
+import org.junit.jupiter.api.Test;
+
+/**
+ * L2 positional UA (uncertain / approximate / mixed markers attached
+ * to individual year, month, or day components, rather than to the
+ * whole date).
+ */
+class L2PositionalUaTest {
+
+    @Test
+    void leadingUaOnYearOnly() {
+        EdtfDate d = (EdtfDate) Edtf.parse("?2020");
+        assertThat(d.level()).isEqualTo(EdtfLevel.L1);
+        // Position 0 alone sets YEAR bits -> same as L1 trailing form
+        assertThat(d.toEdtfString()).isEqualTo("2020?");
+    }
+
+    @Test
+    void uaBeforeMonthOnly() {
+        // 2020-?05: month-only uncertain -> bitmask = MONTH (0x30), L2
+        EdtfDate d = (EdtfDate) Edtf.parse("2020-?05");
+        assertThat(d.level()).isEqualTo(EdtfLevel.L2);
+        // Qualified(2) = MONTH-only -> leading marker on month
+        assertThat(d.toEdtfString()).isEqualTo("2020-?05");
+    }
+
+    @Test
+    void uaBeforeDayOnly() {
+        EdtfDate d = (EdtfDate) Edtf.parse("2020-05-?15");
+        assertThat(d.level()).isEqualTo(EdtfLevel.L2);
+        assertThat(d.toEdtfString()).isEqualTo("2020-05-?15");
+    }
+
+    @Test
+    void mixedUaYearUncertainMonthApproximate() {
+        EdtfDate d = (EdtfDate) Edtf.parse("2020?-05~");
+        assertThat(d.level()).isEqualTo(EdtfLevel.L2);
+        // year is uncertain, month is approximate -> not a plain L1 whole-date marker
+        assertThat(d.uncertain().value()).isNotZero();
+        assertThat(d.approximate().value()).isNotZero();
+    }
+
+    @Test
+    void trailingApproximateOnMonthPrecision() {
+        // L1 shape (whole-date ~): YM mask applied, still L1
+        EdtfDate d = (EdtfDate) Edtf.parse("2020-05~");
+        assertThat(d.level()).isEqualTo(EdtfLevel.L1);
+        assertThat(d.toEdtfString()).isEqualTo("2020-05~");
+    }
+
+    @Test
+    void percentOnMonthPositional() {
+        EdtfDate d = (EdtfDate) Edtf.parse("2020-%05");
+        assertThat(d.level()).isEqualTo(EdtfLevel.L2);
+        // % = both uncertain and approximate at position 2 (before month)
+        assertThat(d.uncertain().value()).isNotZero();
+        assertThat(d.approximate().value()).isNotZero();
+    }
+}