From 099580fa13d927c80efc0275a93998345747f55e Mon Sep 17 00:00:00 2001
From: Philippe Matray <phmatray@gmail.com>
Date: Mon, 24 Aug 2026 17:46:53 +0200
Subject: [PATCH 1/5] chore(#263): scaffold draft PR for ARIA-only required
 announcement


From 101c34d145202e033c69f6ceb960a7cf5c1db123 Mon Sep 17 00:00:00 2001
From: Philippe Matray <phmatray@gmail.com>
Date: Mon, 24 Aug 2026 17:51:29 +0200
Subject: [PATCH 2/5] build(deps): raise MudBlazor to 9.9.0 for
 caller-overridable ARIA

---
 Directory.Packages.props | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Directory.Packages.props b/Directory.Packages.props
index 40c84a5..cf41018 100644
--- a/Directory.Packages.props
+++ b/Directory.Packages.props
@@ -15,7 +15,7 @@
     -->
     <PackageVersion Include="System.Security.Cryptography.Xml" Version="10.0.11" />
     <!-- UI Framework packages -->
-    <PackageVersion Include="MudBlazor" Version="9.8.0" />
+    <PackageVersion Include="MudBlazor" Version="9.9.0" />
     <!--
       Fluent UI Blazor v5 is still an RC (#260). v4 loses support in November 2026 and v5 renamed
       most of the input surface, so the adapter targets v5 directly rather than being born

From 9d4643c2d9da70c142bf6b6b05eb452bd88f2f56 Mon Sep 17 00:00:00 2001
From: Philippe Matray <phmatray@gmail.com>
Date: Wed, 26 Aug 2026 11:02:58 +0200
Subject: [PATCH 3/5] feat(mudblazor): announce required fields without the
 HTML5 required attribute

---
 .../Components/RenderPipelineParityTests.cs   |  27 +++--
 .../Fields/AriaRequiredTests.cs               | 108 ++++++++++++------
 .../Fields/CollectionRequiredTests.cs         |  99 +++++++++-------
 .../MudBlazorAutocompleteFieldComponent.razor |   1 +
 .../MudBlazorBooleanFieldComponent.razor.cs   |  25 ++--
 .../MudBlazorDateOnlyFieldComponent.razor     |   1 +
 .../MudBlazorDateTimeFieldComponent.razor     |   1 +
 .../MudBlazorTimeOnlyFieldComponent.razor     |   1 +
 .../MudBlazorLookupFieldComponent.razor       |   1 +
 .../LovField/MudBlazorLovFieldComponent.razor |   1 +
 .../Fields/MudBlazorFieldComponentBase.cs     |  62 +++++++---
 ...dBlazorNullableNumericFieldComponent.razor |   1 +
 .../MudBlazorNumericFieldComponent.razor      |   1 +
 .../MudBlazorMultiSelectFieldComponent.razor  |   3 +-
 .../MudBlazorSelectFieldComponent.razor       |   3 +-
 .../MudBlazorTextFieldComponent.razor         |   1 +
 16 files changed, 221 insertions(+), 115 deletions(-)

diff --git a/FormCraft.ForMudBlazor.UnitTests/Components/RenderPipelineParityTests.cs b/FormCraft.ForMudBlazor.UnitTests/Components/RenderPipelineParityTests.cs
index 3a55482..480ec98 100644
--- a/FormCraft.ForMudBlazor.UnitTests/Components/RenderPipelineParityTests.cs
+++ b/FormCraft.ForMudBlazor.UnitTests/Components/RenderPipelineParityTests.cs
@@ -475,14 +475,19 @@ static void Configure<TOwner>(FieldBuilder<TOwner, string> field)
         standaloneRender.Find("input").GetAttribute("type").ShouldBe("password");
         itemRender.Find("input").GetAttribute("type").ShouldBe("password");
 
-        // Required is compared here for a .Required(...) field, which since #199 renders TRUE on both
-        // paths so the field is announced to assistive technology. This assertion used to read
-        // ShouldBeFalse (#190); the value flipped, the guard did not. Its bite is unchanged and
-        // symmetric — Presentation() above compares the two paths, and this line pins WHICH of the
-        // two agreed values they settled on, so levelling both back down to silence fails here
-        // rather than passing as a vacuous agreement. The explicit .WithNativeRequired() opt-in is
-        // guarded by the test below (#204), and the opt-OUT by AriaRequiredTests.
-        standalone.Required.ShouldBeTrue();
+        // Required is compared here for a .Required(...) field, which since #263 renders FALSE on
+        // both paths: the announcement moved to aria-required via UserAttributes, and MudBlazor's
+        // Required parameter — which drags the HTML5 attribute and the asterisk along with it — is
+        // now reserved for the explicit .WithNativeRequired() opt-in.
+        //
+        // The value has now flipped twice (#190 false, #199 true, #263 false) while the guard stayed
+        // put, so it is worth being explicit about what it still guards. On its own this line no
+        // longer distinguishes "correctly announced" from "levelled back down to silence" — both
+        // read false here. The pair below does: aria-required must be "true" on the standalone path
+        // AND equal on the item path. So read the two together — this line pins that the native
+        // decoration is off, the next pins that the field is still announced anyway. Silence fails
+        // the second even though it passes the first.
+        standalone.Required.ShouldBeFalse();
 
         // And the accessibility attribute itself, on both paths (#199). The parameter comparison
         // above cannot see this: Required is what FormCraft sets, aria-required is what MudBlazor
@@ -867,9 +872,11 @@ static void Configure<TOwner>(FieldBuilder<TOwner, int> field)
         standalone.Adornment.ShouldBe(Adornment.End);
         standalone.AdornmentIcon.ShouldBe(Icons.Material.Filled.Numbers);
         standalone.Variant.ShouldBe(Variant.Filled);
-        standalone.Required.ShouldBeTrue();
+        standalone.Required.ShouldBeFalse();
 
-        // The accessibility attribute a screen reader reads, on both paths (#199)
+        // The accessibility attribute a screen reader reads, on both paths (#199, #263). Since #263
+        // this is the assertion carrying the weight — see the longer note on the text-field parity
+        // test above — because the Required parameter reads false for silence and success alike.
         standaloneRender.Find("input").GetAttribute("aria-required").ShouldBe("true");
         itemRender.Find("input").GetAttribute("aria-required")
             .ShouldBe(standaloneRender.Find("input").GetAttribute("aria-required"));
diff --git a/FormCraft.ForMudBlazor.UnitTests/Fields/AriaRequiredTests.cs b/FormCraft.ForMudBlazor.UnitTests/Fields/AriaRequiredTests.cs
index ec4b5c6..a89de6f 100644
--- a/FormCraft.ForMudBlazor.UnitTests/Fields/AriaRequiredTests.cs
+++ b/FormCraft.ForMudBlazor.UnitTests/Fields/AriaRequiredTests.cs
@@ -3,33 +3,42 @@
 namespace FormCraft.ForMudBlazor.UnitTests.Fields;
 
 /// <summary>
-/// Tests that a <c>.Required(...)</c> field is announced as required to assistive technology, on
-/// both render paths (#199). WCAG 2.1 <b>3.3.2 Labels or Instructions</b> (Level A) expects required
-/// fields to be identified; before this they were not, on either path.
+/// Tests that a <c>.Required(...)</c> field is announced as required to assistive technology (#199),
+/// and — since #263 — that it is announced <i>without</i> acquiring the HTML5 <c>required</c>
+/// attribute. WCAG 2.1 <b>3.3.2 Labels or Instructions</b> (Level A) expects required fields to be
+/// identified; before #199 they were not.
 /// </summary>
 /// <remarks>
 /// <para>
-/// <b>Why the HTML5 attribute comes back.</b> The issue asked for <c>aria-required="true"</c>
-/// <i>without</i> HTML5 <c>required</c>. Measured against MudBlazor 9.8.0, that is unreachable:
-/// <c>MudInput</c> splats <c>UserAttributes</c> into the element and then writes its own
-/// <c>required</c> and <c>aria-required</c> afterwards, both off the single <c>Required</c> bool.
-/// Blazor resolves duplicate attributes last-write-wins, so a caller-supplied <c>aria-required</c>
-/// is always overwritten and the two attributes cannot be separated. The owner's decision was to
-/// drive <c>Required</c> from <c>IsRequired</c> and accept the HTML5 attribute, which is inert here:
-/// FormCraft forms render <c>novalidate</c>, a guarantee #206 pins with tests.
+/// <b>How the two attributes came apart.</b> #199 asked for <c>aria-required="true"</c> without
+/// HTML5 <c>required</c> and could not have it: measured against MudBlazor 9.8.0, <c>MudInput</c>
+/// splatted <c>UserAttributes</c> and then wrote its own <c>required</c> and <c>aria-required</c>
+/// afterwards, both off the single <c>Required</c> bool, and Blazor resolves duplicate attributes
+/// last-write-wins — so a caller-supplied <c>aria-required</c> was always overwritten. #199 shipped
+/// the compromise: drive <c>Required</c> from <c>IsRequired</c> and accept the HTML5 attribute,
+/// inert here because FormCraft forms render <c>novalidate</c> (#206).
 /// </para>
 /// <para>
-/// This deliberately reverses the collection-path half of #190. What #190 actually fixed was the
-/// <i>divergence</i> — the same <c>.Required("…")</c> call decorating an item field and not an
-/// ordinary one — and that stays fixed, because both paths now resolve the flag the same way. What
-/// it also did, and what this undoes, is level the two paths down to silence.
+/// <see href="https://github.com/MudBlazor/MudBlazor/pull/13613">MudBlazor#13613</see>, released in
+/// <b>9.9.0</b>, moved those ARIA writes above the splat so callers win, while leaving
+/// <c>required</c> below it and deliberately not overridable. #263 is FormCraft taking that up:
+/// the announcement travels through <c>UserAttributes</c>, and MudBlazor's <c>Required</c> parameter
+/// is reserved for the explicit <c>.WithNativeRequired()</c> opt-in. These tests will go red on any
+/// MudBlazor older than 9.9.0 — that version floor is the point, not an accident.
+/// </para>
+/// <para>
+/// ⚠️ <b>The asterisk is the cost.</b> MudBlazor's visible marker is driven by the same
+/// <c>Required</c> parameter as the HTML5 attribute, so it goes too. That trade is the spec's
+/// explicit decision and is pinned by
+/// <c>Required_Field_Should_No_Longer_Carry_MudBlazors_Visible_Marker</c> together with
+/// <c>Explicit_Native_Required_Should_Restore_The_Marker_And_The_Html5_Attribute</c> — read as a
+/// pair, they are the decision, not an accident anyone has to reverse-engineer later.
 /// </para>
 /// <para>
 /// ⚠️ <c>aria-required="false"</c> is asserted for optional fields rather than the attribute's
-/// absence. MudBlazor emits it unconditionally, and <c>false</c> is the correct ARIA value for an
-/// optional field, so its presence is not the defect — the defect was a <i>required</i> field
-/// saying <c>"false"</c>, which is an affirmatively wrong statement to a screen reader rather than
-/// merely a missing one.
+/// absence. <c>false</c> is the correct ARIA value for an optional field, so its presence was never
+/// the defect — the defect was a <i>required</i> field saying <c>"false"</c>, which is an
+/// affirmatively wrong statement to a screen reader rather than merely a missing one.
 /// </para>
 /// </remarks>
 public class AriaRequiredTests : MudBlazorTestBase
@@ -40,8 +49,11 @@ public void Required_Field_Should_Announce_Itself_To_Assistive_Technology()
         // Arrange & Act - the plain .Required(...) call, on an ordinary (non-collection) field
         var component = RenderField(f => f.WithLabel("Name").Required("Name is required"));
 
-        // Assert - the attribute a screen reader actually reads, on the element it reads it from
+        // Assert - the attribute a screen reader actually reads, on the element it reads it from,
+        // and NOT the HTML5 one. Both halves matter: #199 could only deliver the first because
+        // MudBlazor fused them, and #263 exists to separate them.
         component.Find("input").GetAttribute("aria-required").ShouldBe("true");
+        component.Find("input").HasAttribute("required").ShouldBeFalse();
     }
 
     [Fact]
@@ -55,15 +67,41 @@ public void Optional_Field_Should_Not_Be_Announced_As_Required()
     }
 
     [Fact]
-    public void Required_Field_Should_Also_Carry_The_Visible_Required_Marker()
+    public void Required_Field_Should_No_Longer_Carry_MudBlazors_Visible_Marker()
     {
-        // Arrange & Act - MudBlazor's asterisk is a CSS ::after on .mud-input-required, so the CLASS
-        // is the measurable proxy. The spec listed the asterisk as a non-goal; under this mechanism
-        // it is not separable from the ARIA flag, so it ships - and it is itself a WCAG 3.3.2
-        // *visible* identification. Pinned so the pairing is a decision on record, not an accident.
+        // Arrange & Act - THE ASTERISK DECISION (#263 Task 3 Step 4), recorded as a test rather than
+        // left to be discovered. MudBlazor's asterisk is a CSS ::after on .mud-input-required, and
+        // that class comes from the same Required parameter as the HTML5 attribute - one flag, both
+        // effects, still fused after MudBlazor#13613 (which separated only the ARIA write). So
+        // dropping the attribute drops the asterisk with it; they cannot be had separately.
+        //
+        // The spec chose to accept that rather than invent a FormCraft-owned marker: its behaviour
+        // diagram ends "no asterisk unless .WithNativeRequired()", and its non-goals keep the
+        // decoration available through that opt-in. #199 had shipped the asterisk as a *visible*
+        // WCAG 3.3.2 identification, so this is a real trade, not a free win - which is exactly why
+        // it is pinned here and in the test below rather than merely inverted in silence.
         var component = RenderField(f => f.WithLabel("Name").Required("Name is required"));
 
+        // Assert - announced to assistive technology, but no longer marked for sighted users
+        component.Find("input").GetAttribute("aria-required").ShouldBe("true");
+        component.FindAll(".mud-input-required").ShouldBeEmpty();
+    }
+
+    [Fact]
+    public void Explicit_Native_Required_Should_Restore_The_Marker_And_The_Html5_Attribute()
+    {
+        // Arrange & Act - the other half of that decision: .WithNativeRequired() is the documented
+        // way back to MudBlazor's native semantics, and "native" means the whole package. A caller
+        // who wants the asterisk has to accept the HTML5 attribute that comes with it, and this
+        // test is what makes that promise checkable.
+        var component = RenderField(f => f
+            .WithLabel("Name")
+            .Required("Name is required")
+            .WithNativeRequired());
+
         // Assert
+        component.Find("input").GetAttribute("aria-required").ShouldBe("true");
+        component.Find("input").HasAttribute("required").ShouldBeTrue();
         component.FindAll(".mud-input-required").ShouldNotBeEmpty();
     }
 
@@ -108,7 +146,7 @@ public void Required_Numeric_Field_Should_Announce_Itself()
         var component = RenderConfig(config);
 
         // Assert
-        component.FindComponent<MudNumericField<int>>().Instance.Required.ShouldBeTrue();
+        component.FindComponent<MudNumericField<int>>().Instance.Required.ShouldBeFalse();
         component.Find("input").GetAttribute("aria-required").ShouldBe("true");
     }
 
@@ -126,7 +164,7 @@ public void Required_Date_Field_Should_Announce_Itself()
         var component = RenderConfig(config);
 
         // Assert
-        component.FindComponent<MudDatePicker>().Instance.Required.ShouldBeTrue();
+        component.FindComponent<MudDatePicker>().Instance.Required.ShouldBeFalse();
         component.Find("input").GetAttribute("aria-required").ShouldBe("true");
     }
 
@@ -139,7 +177,7 @@ public void Required_Text_Item_Field_Should_Announce_Itself()
         var component = this.RenderItemForm(NewOrder(), TextItemForm(f => f.Required("Product is required")));
 
         // Assert
-        component.FindComponent<MudTextField<string>>().Instance.Required.ShouldBeTrue();
+        component.FindComponent<MudTextField<string>>().Instance.Required.ShouldBeFalse();
         component.Find("input").GetAttribute("aria-required").ShouldBe("true");
     }
 
@@ -150,7 +188,7 @@ public void Required_Numeric_Item_Field_Should_Announce_Itself()
         var component = this.RenderItemForm(NewBasket(), NumericItemForm(f => f.Required("Quantity is required")));
 
         // Assert
-        component.FindComponent<MudNumericField<int>>().Instance.Required.ShouldBeTrue();
+        component.FindComponent<MudNumericField<int>>().Instance.Required.ShouldBeFalse();
         component.Find("input").GetAttribute("aria-required").ShouldBe("true");
     }
 
@@ -161,7 +199,7 @@ public void Required_Date_Item_Field_Should_Announce_Itself()
         var component = this.RenderItemForm(NewAppointment(), DateItemForm(f => f.Required("When is required")));
 
         // Assert
-        component.FindComponent<MudDatePicker>().Instance.Required.ShouldBeTrue();
+        component.FindComponent<MudDatePicker>().Instance.Required.ShouldBeFalse();
         component.Find("input").GetAttribute("aria-required").ShouldBe("true");
     }
 
@@ -206,8 +244,8 @@ public void Required_Boolean_Item_Field_Should_Announce_Itself()
 
         // Assert - the parameter, the asterisk class, and the attribute on the real <input>
         component.FindComponent<MudCheckBox<bool>>().Instance.Label.ShouldBe("Gift");
-        component.FindComponent<MudCheckBox<bool>>().Instance.Required.ShouldBeTrue();
-        component.FindAll(".mud-input-required").ShouldNotBeEmpty();
+        component.FindComponent<MudCheckBox<bool>>().Instance.Required.ShouldBeFalse();
+        component.FindAll(".mud-input-required").ShouldBeEmpty();
         component.Find("input[type=checkbox]").GetAttribute("aria-required").ShouldBe("true");
     }
 
@@ -227,7 +265,7 @@ public void Required_Boolean_Field_Should_Announce_Itself_On_The_Component_Path_
         var component = RenderConfig(config);
 
         // Assert
-        component.FindComponent<MudCheckBox<bool>>().Instance.Required.ShouldBeTrue();
+        component.FindComponent<MudCheckBox<bool>>().Instance.Required.ShouldBeFalse();
         component.Find("input[type=checkbox]").GetAttribute("aria-required").ShouldBe("true");
     }
 
@@ -266,7 +304,7 @@ public void Required_Select_Field_Should_Announce_Itself()
         var component = RenderConfig(config);
 
         // Assert - MudSelect forwards Required to its inner MudInput, which is what emits the ARIA
-        component.FindComponent<MudSelect<string>>().Instance.Required.ShouldBeTrue();
+        component.FindComponent<MudSelect<string>>().Instance.Required.ShouldBeFalse();
         component.Find("input").GetAttribute("aria-required").ShouldBe("true");
     }
 
@@ -306,7 +344,7 @@ public void Required_Autocomplete_Field_Should_Announce_Itself()
         var component = RenderConfig(config);
 
         // Assert
-        component.FindComponent<MudAutocomplete<string>>().Instance.Required.ShouldBeTrue();
+        component.FindComponent<MudAutocomplete<string>>().Instance.Required.ShouldBeFalse();
         component.Find("input").GetAttribute("aria-required").ShouldBe("true");
     }
 
diff --git a/FormCraft.ForMudBlazor.UnitTests/Fields/CollectionRequiredTests.cs b/FormCraft.ForMudBlazor.UnitTests/Fields/CollectionRequiredTests.cs
index f717b14..0da5d3f 100644
--- a/FormCraft.ForMudBlazor.UnitTests/Fields/CollectionRequiredTests.cs
+++ b/FormCraft.ForMudBlazor.UnitTests/Fields/CollectionRequiredTests.cs
@@ -4,25 +4,30 @@ namespace FormCraft.ForMudBlazor.UnitTests.Fields;
 
 /// <summary>
 /// Tests how collection item fields resolve MudBlazor's <c>Required</c> — the flag that carries the
-/// HTML5 attribute, <c>aria-required</c> and the asterisk together (#190, then #199).
+/// HTML5 attribute and the asterisk together (#190, #199, then #263).
 /// <para>
 /// <b>The arc this suite records.</b> The collection path originally drove the flag from
 /// <c>field.IsRequired</c> while the component path did not, so the same <c>.Required("…")</c> call
 /// decorated an item field and not an ordinary one. #190 closed that divergence by dropping the
 /// forward — correctly, since divergence was the defect — but closed it by levelling both paths
-/// down to silence. #199 restores the forward on <b>both</b> paths at once: a required field that
-/// never says it is required fails WCAG 2.1 <b>3.3.2</b> (Level A), and on MudBlazor 9.8.0 this
-/// single flag is the only way to say it (see
-/// <c>MudBlazorFieldComponentBase.EffectiveNativeRequired</c> for the measurement). The tests below
-/// that used to assert the attribute's ABSENCE for a <c>.Required(...)</c> field now assert its
-/// presence; the divergence #190 fixed stays fixed, because
-/// <c>RenderPipelineParityTests</c> compares the two paths.
+/// down to silence, and a required field that never says it is required fails WCAG 2.1 <b>3.3.2</b>
+/// (Level A). #199 restored the forward on both paths, which announced the field but dragged in the
+/// HTML5 attribute, because MudBlazor 9.8.0 drove both from this one flag and offered no way to
+/// separate them.
 /// </para>
 /// <para>
-/// The HTML5 attribute is inert for validation here: FormCraft forms render <c>novalidate</c>, which
-/// since #206 is an actual guarantee rather than a best effort — the attribute is rendered on the
-/// form itself, so it applies during prerender and targets this component's own form, rather than
-/// being applied by script to the *first* form in the document after the first render.
+/// #263 separates them. <see href="https://github.com/MudBlazor/MudBlazor/pull/13613">MudBlazor
+/// #13613</see>, released in 9.9.0, made <c>aria-required</c> caller-overridable while leaving
+/// <c>required</c> bound to the parameter — so FormCraft now contributes the announcement through
+/// <c>UserAttributes</c> and leaves <c>Required</c> to the explicit <c>.WithNativeRequired()</c>
+/// opt-in. The assertions below therefore read <b>false</b> for a plain <c>.Required(...)</c> field
+/// again, as they did under #190 — but for the opposite reason, and the <c>aria-required</c>
+/// assertions beside them are what makes the difference visible. Read each pair together.
+/// </para>
+/// <para>
+/// The divergence #190 fixed stays fixed: since #203 item fields render through the very same
+/// components as ordinary ones, and <c>RenderPipelineParityTests</c> still compares the two
+/// placements.
 /// </para>
 /// <para>
 /// Measured while fixing #190 and still true: the attribute arms no second validator — item fields
@@ -47,16 +52,19 @@ namespace FormCraft.ForMudBlazor.UnitTests.Fields;
 public class CollectionRequiredTests : MudBlazorTestBase
 {
     [Fact]
-    public void Required_ItemField_Should_Render_The_Html5_Required_Attribute()
+    public void Required_ItemField_Should_Not_Render_The_Html5_Required_Attribute()
     {
-        // Arrange & Act - the same .Required(...) call a standalone field would use, which since
-        // #199 resolves the flag identically on both paths. Was ShouldBeFalse under #190.
+        // Arrange & Act - the same .Required(...) call a standalone field would use, resolved
+        // identically on both placements. This assertion has now flipped twice: ShouldBeFalse under
+        // #190, ShouldBeTrue under #199, and false again under #263 - but for the opposite reason to
+        // #190's. #190 dropped the flag and lost the announcement with it; #263 drops the flag and
+        // KEEPS the announcement, because aria-required now travels separately through
+        // UserAttributes. The test below asserts that half, and the two must be read together.
         var component = this.RenderItemForm(NewOrder(), TextItemForm(field => field
             .Required("Product name is required")));
 
-        // Assert - the flag is set, so the field is announced; validation is unchanged either way
-        // (see the EditContext tests below, which still pass a single message)
-        component.FindComponent<MudTextField<string>>().Instance.Required.ShouldBeTrue();
+        // Assert - no native decoration, hence no HTML5 attribute
+        component.FindComponent<MudTextField<string>>().Instance.Required.ShouldBeFalse();
     }
 
     [Fact]
@@ -87,20 +95,22 @@ public void ItemField_Without_Any_Required_Configuration_Should_Not_Render_It()
     }
 
     [Fact]
-    public void Required_NumericItemField_Should_Render_The_Html5_Required_Attribute()
+    public void Required_NumericItemField_Should_Not_Render_The_Html5_Required_Attribute()
     {
-        // Arrange & Act - AddCommonFieldAttributes feeds three renderers (text, numeric and date), so
-        // the numeric one must follow the forward too rather than being fixed only where it was
-        // measured. Inverted from #190's ShouldBeFalse by #199.
+        // Arrange & Act - the numeric field type must follow the text one rather than be fixed
+        // separately; since #203 both reach the same component, so this is a regression guard on
+        // that convergence rather than on a second implementation.
         var component = this.RenderItemForm(NewBasket(), NumericItemForm(field => field
             .Required("Quantity is required")));
 
-        // Assert
-        component.FindComponent<MudNumericField<int>>().Instance.Required.ShouldBeTrue();
+        // Assert - decoration off, announcement on
+        var numeric = component.FindComponent<MudNumericField<int>>();
+        numeric.Instance.Required.ShouldBeFalse();
+        numeric.Find("input").GetAttribute("aria-required").ShouldBe("true");
     }
 
     [Fact]
-    public void Required_ItemField_Should_Put_The_Required_Attribute_On_The_Input_Element()
+    public void Required_ItemField_Should_Put_Only_The_Aria_Attribute_On_The_Input_Element()
     {
         // Arrange & Act - the component property is the cause; this is the effect that reaches the
         // browser and the screen reader. Asserting the property alone would stay green if the value
@@ -109,42 +119,49 @@ public void Required_ItemField_Should_Put_The_Required_Attribute_On_The_Input_El
             .Required("Product name is required")));
 
         // Assert - anchored to the field under test, not to whichever input happens to be first.
-        // aria-required="true" is the accessibility goal; the HTML5 attribute rides along with it
-        // because MudBlazor drives both from one flag, and is inert under the form's novalidate.
+        // This is the pair that matters: the accessibility goal is present, the HTML5 attribute the
+        // project's validation convention forbids is not. Before #263 the second line read
+        // ShouldBeTrue, because MudBlazor drove both from one flag and offered no way to separate
+        // them; MudBlazor#13613 is what made this assertion expressible.
         var input = component.FindComponent<MudTextField<string>>().Find("input");
         input.GetAttribute("aria-required").ShouldBe("true");
-        input.HasAttribute("required").ShouldBeTrue();
+        input.HasAttribute("required").ShouldBeFalse();
     }
 
     [Fact]
-    public void Required_ItemField_Should_Render_MudBlazors_Required_Asterisk()
+    public void Required_ItemField_Should_No_Longer_Render_MudBlazors_Required_Asterisk()
     {
         // Arrange & Act - the asterisk is a CSS ::after on .mud-input-required, which MudBlazor adds
         // only when Required is true. A markup search for "*" cannot see it, so the CLASS is the
-        // measurable proxy. This is the user-visible half of #199: a required item field carries the
-        // marker, and so does a required ordinary field — which under #190 neither did.
+        // measurable proxy.
         //
-        // The spec listed the asterisk as a non-goal. It is not separable from the ARIA flag under
-        // this mechanism, so it ships, and it is itself a WCAG 3.3.2 *visible* identification.
+        // #263's deliberate trade, and the one part of it that is not a pure win: MudBlazor#13613
+        // separated aria-required from the Required parameter but left the asterisk and the HTML5
+        // attribute fused to it, so dropping one drops the other. The spec chose that over inventing
+        // a FormCraft-owned marker, and kept .WithNativeRequired() as the way back - the four
+        // WithNativeRequired tests at the bottom of this file are that promise, on all four field
+        // types. See AriaRequiredTests for the standalone half of the same decision.
         var component = this.RenderItemForm(NewOrder(), TextItemForm(field => field
             .Required("Product name is required")));
 
         // Assert
-        component.FindAll(".mud-input-required").ShouldNotBeEmpty();
+        component.FindAll(".mud-input-required").ShouldBeEmpty();
     }
 
     [Fact]
-    public void DateItemField_Should_Render_The_Html5_Required_Attribute()
+    public void DateItemField_Should_Not_Render_The_Html5_Required_Attribute()
     {
-        // Arrange & Act - MudDatePicker is the THIRD renderer fed by AddCommonFieldAttributes, and it
-        // derives from MudFormComponent too, so it takes the same forward. Its sibling suite covers
-        // the date path for adornments (#184); this keeps that parity for Required. Inverted by #199.
+        // Arrange & Act - MudDatePicker is the third field family to check, and the one #190 missed
+        // first time round. Its sibling suite covers the date path for adornments (#184); this keeps
+        // that parity for Required.
         var component = this.RenderItemForm(NewAppointment(), DateItemForm(field => field
             .Required("When is required")));
 
-        // Assert
-        component.FindComponent<MudDatePicker>().Instance.Required.ShouldBeTrue();
-        component.FindAll(".mud-input-required").ShouldNotBeEmpty();
+        // Assert - decoration and asterisk both gone, announcement intact
+        var picker = component.FindComponent<MudDatePicker>();
+        picker.Instance.Required.ShouldBeFalse();
+        component.FindAll(".mud-input-required").ShouldBeEmpty();
+        component.Find("input").GetAttribute("aria-required").ShouldBe("true");
     }
 
     [Fact]
diff --git a/FormCraft.ForMudBlazor/Fields/AutocompleteField/MudBlazorAutocompleteFieldComponent.razor b/FormCraft.ForMudBlazor/Fields/AutocompleteField/MudBlazorAutocompleteFieldComponent.razor
index 6788925..9a73f6d 100644
--- a/FormCraft.ForMudBlazor/Fields/AutocompleteField/MudBlazorAutocompleteFieldComponent.razor
+++ b/FormCraft.ForMudBlazor/Fields/AutocompleteField/MudBlazorAutocompleteFieldComponent.razor
@@ -17,6 +17,7 @@
     Margin="Margin.Dense"
     ShrinkLabel="@EffectiveShrinkLabel"
     Required="@EffectiveNativeRequired"
+    aria-required="@AriaRequired"
     DebounceInterval="@_debounceMs"
     MinCharacters="@_minCharacters"
     ResetValueOnEmptyText="true"
diff --git a/FormCraft.ForMudBlazor/Fields/BooleanField/MudBlazorBooleanFieldComponent.razor.cs b/FormCraft.ForMudBlazor/Fields/BooleanField/MudBlazorBooleanFieldComponent.razor.cs
index 6f4211a..e71358f 100644
--- a/FormCraft.ForMudBlazor/Fields/BooleanField/MudBlazorBooleanFieldComponent.razor.cs
+++ b/FormCraft.ForMudBlazor/Fields/BooleanField/MudBlazorBooleanFieldComponent.razor.cs
@@ -15,20 +15,29 @@ public partial class MudBlazorBooleanFieldComponent<TModel>
     /// ShrinkLabel diagnostic, neither of which a checkbox has any use for.
     /// </remarks>
     private bool NativeRequiredValue =>
-        NativeRequired.Resolve(Context.Field.AdditionalAttributes, IsRequired);
+        NativeRequired.Resolve(Context.Field.AdditionalAttributes, isRequired: false);
 
     /// <summary>
     /// <c>aria-required</c> as MudBlazor would spell it, for the <c>UserAttributes</c> splat below.
     /// </summary>
     /// <remarks>
-    /// ⚠️ Passed explicitly because <c>MudCheckBox</c> and <c>MudSwitch</c> emit <b>no</b>
-    /// <c>aria-required</c> of their own — unlike <c>MudInput</c>, whose own write overrides the
-    /// caller's. Their <c>GetInputAttributes()</c> copies <c>UserAttributes</c> onto the rendered
-    /// <c>&lt;input&gt;</c> and nothing downstream re-emits this key, so here the splat really does
-    /// land. That asymmetry is the whole reason a checkbox can be announced correctly while a text
-    /// field cannot (measured on MudBlazor 9.8.0).
+    /// <para>
+    /// ⚠️ Passed explicitly, and never <c>null</c>, because <c>MudCheckBox</c> and <c>MudSwitch</c>
+    /// emit <b>no</b> <c>aria-required</c> of their own. Their <c>GetInputAttributes()</c> copies
+    /// <c>UserAttributes</c> onto the rendered <c>&lt;input&gt;</c> and nothing downstream re-emits
+    /// this key, so there is no fallback to leave in place — omitting it for an optional field would
+    /// drop the attribute entirely rather than leave it <c>"false"</c>. The MudInput-backed field
+    /// types can return <c>null</c> there; this one cannot.
+    /// </para>
+    /// <para>
+    /// Resolved from <c>IsRequired</c> rather than from <see cref="NativeRequiredValue"/> since
+    /// #263, which split the announcement from the native decoration. Reading the sibling property
+    /// would silently re-couple them and leave a required checkbox unannounced the moment it stopped
+    /// setting <c>Required</c>.
+    /// </para>
     /// </remarks>
-    private string AriaRequiredValue => NativeRequiredValue ? "true" : "false";
+    private string AriaRequiredValue =>
+        NativeRequired.Resolve(Context.Field.AdditionalAttributes, IsRequired) ? "true" : "false";
 
     public BooleanDisplayStyle DisplayStyle { get; set; } = BooleanDisplayStyle.Checkbox;
     public string? TrueText { get; set; }
diff --git a/FormCraft.ForMudBlazor/Fields/DateTimeField/MudBlazorDateOnlyFieldComponent.razor b/FormCraft.ForMudBlazor/Fields/DateTimeField/MudBlazorDateOnlyFieldComponent.razor
index c9d82f8..4807959 100644
--- a/FormCraft.ForMudBlazor/Fields/DateTimeField/MudBlazorDateOnlyFieldComponent.razor
+++ b/FormCraft.ForMudBlazor/Fields/DateTimeField/MudBlazorDateOnlyFieldComponent.razor
@@ -14,6 +14,7 @@
     Margin="Margin.Dense"
     ShrinkLabel="@EffectiveShrinkLabel"
     Required="@EffectiveNativeRequired"
+    aria-required="@AriaRequired"
     DateFormat="@Format"
     Editable="true"
     MinDate="@MinDate"
diff --git a/FormCraft.ForMudBlazor/Fields/DateTimeField/MudBlazorDateTimeFieldComponent.razor b/FormCraft.ForMudBlazor/Fields/DateTimeField/MudBlazorDateTimeFieldComponent.razor
index 6f93014..13d2d34 100644
--- a/FormCraft.ForMudBlazor/Fields/DateTimeField/MudBlazorDateTimeFieldComponent.razor
+++ b/FormCraft.ForMudBlazor/Fields/DateTimeField/MudBlazorDateTimeFieldComponent.razor
@@ -18,6 +18,7 @@
     Margin="Margin.Dense"
     ShrinkLabel="@EffectiveShrinkLabel"
     Required="@EffectiveNativeRequired"
+    aria-required="@AriaRequired"
     DateFormat="@Format"
     Editable="true"
     MinDate="@MinDate"
diff --git a/FormCraft.ForMudBlazor/Fields/DateTimeField/MudBlazorTimeOnlyFieldComponent.razor b/FormCraft.ForMudBlazor/Fields/DateTimeField/MudBlazorTimeOnlyFieldComponent.razor
index aa73a13..4980d4b 100644
--- a/FormCraft.ForMudBlazor/Fields/DateTimeField/MudBlazorTimeOnlyFieldComponent.razor
+++ b/FormCraft.ForMudBlazor/Fields/DateTimeField/MudBlazorTimeOnlyFieldComponent.razor
@@ -14,5 +14,6 @@
     Margin="Margin.Dense"
     ShrinkLabel="@EffectiveShrinkLabel"
     Required="@EffectiveNativeRequired"
+    aria-required="@AriaRequired"
     Editable="true"
     Clearable="@ShowClearButton" />
diff --git a/FormCraft.ForMudBlazor/Fields/LookupField/MudBlazorLookupFieldComponent.razor b/FormCraft.ForMudBlazor/Fields/LookupField/MudBlazorLookupFieldComponent.razor
index e3e958e..71e42fe 100644
--- a/FormCraft.ForMudBlazor/Fields/LookupField/MudBlazorLookupFieldComponent.razor
+++ b/FormCraft.ForMudBlazor/Fields/LookupField/MudBlazorLookupFieldComponent.razor
@@ -15,6 +15,7 @@
     Margin="Margin.Dense"
     ShrinkLabel="@EffectiveShrinkLabel"
     Required="@EffectiveNativeRequired"
+    aria-required="@AriaRequired"
     Adornment="Adornment.End"
     AdornmentIcon="@Icons.Material.Filled.Search"
     OnAdornmentClick="@OpenLookupDialog"
diff --git a/FormCraft.ForMudBlazor/Fields/LovField/MudBlazorLovFieldComponent.razor b/FormCraft.ForMudBlazor/Fields/LovField/MudBlazorLovFieldComponent.razor
index 6d76953..dd296dc 100644
--- a/FormCraft.ForMudBlazor/Fields/LovField/MudBlazorLovFieldComponent.razor
+++ b/FormCraft.ForMudBlazor/Fields/LovField/MudBlazorLovFieldComponent.razor
@@ -22,6 +22,7 @@
     Margin="Margin.Dense"
     ShrinkLabel="@EffectiveShrinkLabel"
     Required="@EffectiveNativeRequired"
+    aria-required="@AriaRequired"
     Adornment="Adornment.End"
     AdornmentIcon="@AdornmentIcon"
     AdornmentColor="Color.Primary"
diff --git a/FormCraft.ForMudBlazor/Fields/MudBlazorFieldComponentBase.cs b/FormCraft.ForMudBlazor/Fields/MudBlazorFieldComponentBase.cs
index 2f848fb..8d12540 100644
--- a/FormCraft.ForMudBlazor/Fields/MudBlazorFieldComponentBase.cs
+++ b/FormCraft.ForMudBlazor/Fields/MudBlazorFieldComponentBase.cs
@@ -324,35 +324,59 @@ public abstract class MudBlazorFieldComponentBase<TModel, TValue> : FieldCompone
     protected virtual Adornment? RenderedAdornment => null;
 
     /// <summary>
-    /// Whether MudBlazor's native required decoration is rendered: the explicit
-    /// <c>.WithNativeRequired(...)</c> opt-in (or the equivalent raw <c>"Required"</c> attribute)
-    /// when the field sets one, otherwise <c>Context.Field.IsRequired</c> (#199, #204).
+    /// Whether MudBlazor's native required decoration is rendered — its asterisk and the HTML5
+    /// <c>required</c> attribute, which one parameter drives together. Set only by the explicit
+    /// <c>.WithNativeRequired(...)</c> opt-in (or the equivalent raw <c>"Required"</c> attribute);
+    /// <c>Context.Field.IsRequired</c> alone no longer implies it (#263).
     /// </summary>
     /// <remarks>
     /// <para>
-    /// The explicit attribute wins in <b>both</b> directions — a field that asked for the decoration
-    /// without <c>.Required(...)</c> gets it, and one that suppressed it with
-    /// <c>.WithNativeRequired(false)</c> keeps it suppressed even when <c>.Required(...)</c> is
-    /// configured. Only an unconfigured field falls through to the validator's own answer.
+    /// <c>.Required(...)</c> is announced through <see cref="AriaRequired"/> instead, so a required
+    /// field is identified to assistive technology without acquiring the HTML5 attribute the
+    /// project's validation convention forbids. Between #199 and #263 this property carried both
+    /// jobs, because MudBlazor 9.8.0 fused them: <c>MudInput</c> splatted <c>UserAttributes</c> and
+    /// then wrote its own <c>required</c> and <c>aria-required</c> afterwards, both off this single
+    /// bool, and last-write-wins meant a caller-supplied <c>aria-required</c> was always discarded.
     /// </para>
     /// <para>
-    /// ⚠️ This property used to read the attribute and <b>never</b> <c>IsRequired</c>, because #190
-    /// had removed that forward. #199 restores it deliberately: a required field that is not
-    /// announced as required fails WCAG 2.1 <b>3.3.2</b> (Level A), and on MudBlazor 9.8.0 there is
-    /// no way to say so without this flag. <c>MudInput</c> splats <c>UserAttributes</c> and then
-    /// writes its own <c>required</c> and <c>aria-required</c> afterwards, both off this single
-    /// bool; Blazor resolves duplicate attributes last-write-wins, so a caller-supplied
-    /// <c>aria-required</c> is always overwritten and the two attributes cannot be separated.
+    /// MudBlazor 9.9.0 moved those ARIA writes <i>above</i> the splat
+    /// (<see href="https://github.com/MudBlazor/MudBlazor/pull/13613">MudBlazor#13613</see>), making
+    /// them caller-overridable while <c>required</c> stayed below it and deliberately not. That is
+    /// what separates the pair, and it is why <c>Directory.Packages.props</c> must not drop below
+    /// 9.9.0 — on an older MudBlazor every ARIA assertion in <c>AriaRequiredTests</c> goes red.
     /// </para>
     /// <para>
-    /// What #190 actually fixed — the same <c>.Required("…")</c> call decorating an item field but
-    /// not an ordinary one — stays fixed: <c>CollectionFieldComponent</c> resolves the flag by the
-    /// same rule, so the two render paths agree. The HTML5 attribute that returns with it is inert
-    /// for validation here, since FormCraft forms render <c>novalidate</c> (#206).
+    /// ⚠️ The visible asterisk goes with the decoration, so a plain <c>.Required(...)</c> field no
+    /// longer shows one. That is the spec's decision, not an oversight:
+    /// <c>.WithNativeRequired()</c> is the documented way back to native semantics, asterisk
+    /// included. <c>AriaRequiredTests</c> pins both halves.
     /// </para>
     /// </remarks>
     protected bool EffectiveNativeRequired =>
-        NativeRequired.Resolve(Context.Field.AdditionalAttributes, IsRequired);
+        NativeRequired.Resolve(Context.Field.AdditionalAttributes, isRequired: false);
+
+    /// <summary>
+    /// The value of <c>aria-required</c> to contribute through <c>UserAttributes</c> (#263).
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// This carries the <i>announcement</i>, which <see cref="EffectiveNativeRequired"/> no longer
+    /// does. It resolves by the full rule — an explicit <c>.WithNativeRequired(...)</c> winning over
+    /// <c>Context.Field.IsRequired</c> in both directions — so <c>.WithNativeRequired(false)</c> on a
+    /// <c>.Required(...)</c> field still suppresses the annotation, as it always has.
+    /// </para>
+    /// <para>
+    /// ⚠️ Always a string, never <c>null</c>. Returning <c>null</c> to "leave MudBlazor's own
+    /// fallback in place" does the opposite: a null component parameter is still captured into
+    /// <c>UserAttributes</c> as a present key with a null value, and Blazor deletes an attribute
+    /// whose last write is null — so the optional case lost <c>aria-required</c> altogether instead
+    /// of keeping <c>"false"</c>. Measured, not reasoned: it turned five DOM assertions red.
+    /// Spelling both values out also stops the negative case depending on a MudBlazor fallback that
+    /// some components (<c>MudSelect</c> among them) do not emit at all.
+    /// </para>
+    /// </remarks>
+    protected string AriaRequired =>
+        NativeRequired.Resolve(Context.Field.AdditionalAttributes, IsRequired) ? "true" : "false";
 
     /// <summary>
     /// Service provider used to resolve an optional <see cref="ILoggerFactory"/> for the
diff --git a/FormCraft.ForMudBlazor/Fields/NumericField/MudBlazorNullableNumericFieldComponent.razor b/FormCraft.ForMudBlazor/Fields/NumericField/MudBlazorNullableNumericFieldComponent.razor
index 106aa6e..c6a83af 100644
--- a/FormCraft.ForMudBlazor/Fields/NumericField/MudBlazorNullableNumericFieldComponent.razor
+++ b/FormCraft.ForMudBlazor/Fields/NumericField/MudBlazorNullableNumericFieldComponent.razor
@@ -30,4 +30,5 @@
     Margin="Margin.Dense"
     ShrinkLabel="@EffectiveShrinkLabel"
     Required="@EffectiveNativeRequired"
+    aria-required="@AriaRequired"
     Immediate="true" />
diff --git a/FormCraft.ForMudBlazor/Fields/NumericField/MudBlazorNumericFieldComponent.razor b/FormCraft.ForMudBlazor/Fields/NumericField/MudBlazorNumericFieldComponent.razor
index 9de9576..2f5ab15 100644
--- a/FormCraft.ForMudBlazor/Fields/NumericField/MudBlazorNumericFieldComponent.razor
+++ b/FormCraft.ForMudBlazor/Fields/NumericField/MudBlazorNumericFieldComponent.razor
@@ -36,4 +36,5 @@
     Margin="Margin.Dense"
     ShrinkLabel="@EffectiveShrinkLabel"
     Required="@EffectiveNativeRequired"
+    aria-required="@AriaRequired"
     Immediate="true" />
\ No newline at end of file
diff --git a/FormCraft.ForMudBlazor/Fields/SelectField/MudBlazorMultiSelectFieldComponent.razor b/FormCraft.ForMudBlazor/Fields/SelectField/MudBlazorMultiSelectFieldComponent.razor
index 9b82bbe..633cd49 100644
--- a/FormCraft.ForMudBlazor/Fields/SelectField/MudBlazorMultiSelectFieldComponent.razor
+++ b/FormCraft.ForMudBlazor/Fields/SelectField/MudBlazorMultiSelectFieldComponent.razor
@@ -16,7 +16,8 @@
     Variant="@EffectiveVariant"
     Margin="Margin.Dense"
     ShrinkLabel="@EffectiveShrinkLabel"
-    Required="@EffectiveNativeRequired">
+    Required="@EffectiveNativeRequired"
+    aria-required="@AriaRequired">
     @foreach (SelectOption<TItem> option in Options)
     {
         <MudSelectItem T="TItem" Value="@option.Value">
diff --git a/FormCraft.ForMudBlazor/Fields/SelectField/MudBlazorSelectFieldComponent.razor b/FormCraft.ForMudBlazor/Fields/SelectField/MudBlazorSelectFieldComponent.razor
index 4493a07..c83f8d5 100644
--- a/FormCraft.ForMudBlazor/Fields/SelectField/MudBlazorSelectFieldComponent.razor
+++ b/FormCraft.ForMudBlazor/Fields/SelectField/MudBlazorSelectFieldComponent.razor
@@ -16,7 +16,8 @@
     Variant="@EffectiveVariant"
     Margin="Margin.Dense"
     ShrinkLabel="@EffectiveShrinkLabel"
-    Required="@EffectiveNativeRequired">
+    Required="@EffectiveNativeRequired"
+    aria-required="@AriaRequired">
     @foreach (SelectOption<TValue> option in Options)
     {
         <MudSelectItem T="TValue" Value="@option.Value">
diff --git a/FormCraft.ForMudBlazor/Fields/TextField/MudBlazorTextFieldComponent.razor b/FormCraft.ForMudBlazor/Fields/TextField/MudBlazorTextFieldComponent.razor
index c5d2d00..a1154e1 100644
--- a/FormCraft.ForMudBlazor/Fields/TextField/MudBlazorTextFieldComponent.razor
+++ b/FormCraft.ForMudBlazor/Fields/TextField/MudBlazorTextFieldComponent.razor
@@ -25,4 +25,5 @@
     Margin="Margin.Dense"
     ShrinkLabel="@EffectiveShrinkLabel"
     Required="@EffectiveNativeRequired"
+    aria-required="@AriaRequired"
     Immediate="true" />
\ No newline at end of file

From dd4615aec0743ee0fc132b34f726e254a39378c4 Mon Sep 17 00:00:00 2001
From: Philippe Matray <phmatray@gmail.com>
Date: Wed, 26 Aug 2026 11:05:04 +0200
Subject: [PATCH 4/5] docs: restore the validation convention now ARIA is
 independent

---
 CLAUDE.md                                     | 48 ++++++++++++-------
 .../Extensions/FieldBuilderExtensions.cs      | 39 +++++++++------
 README.md                                     |  6 +++
 3 files changed, 60 insertions(+), 33 deletions(-)

diff --git a/CLAUDE.md b/CLAUDE.md
index 8ef049d..4228d04 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -335,15 +335,24 @@ because it lives in core rather than in one of the two packages that need it.
 #### Validation Behavior
 - **The convention governs browser *constraint validation*, not accessibility annotations** (#199).
   Those are different things, and conflating them is what left required fields silent to screen
-  readers. `Required()` still routes validation server-side and the browser still runs none — but a
-  required field must be *identified*, which is WCAG 2.1 3.3.2 (Level A)
-- `Required()` therefore DOES set MudBlazor's `Required` on both render paths, which emits
-  `aria-required="true"`, the `*` asterisk, and the HTML5 `required` attribute. MudBlazor derives all
-  three from one flag and they cannot be separated: `MudInput` splats `UserAttributes` and then writes
-  its own `required`/`aria-required` afterwards, so a caller-supplied value is always overwritten
-  (measured on 9.8.0). The HTML5 attribute is inert here because the form renders `novalidate`.
-  ⛔ Do not "restore the convention" by dropping this — that is #190, which #199 reversed, and it
-  reintroduces a Level A accessibility failure. `.WithNativeRequired(false)` is the per-field opt-out
+  readers. `Required()` routes validation server-side and the browser runs none — but a required
+  field must still be *identified*, which is WCAG 2.1 3.3.2 (Level A)
+- **`Required()` adds validation but NOT the HTML5 `required` attribute** — the convention in its
+  literal form, restored by #263. It was amended between #199 and #263 only because MudBlazor 9.8.0
+  fused the two: `MudInput` splatted `UserAttributes` and then wrote its own `required` **and**
+  `aria-required` afterwards, both off one `Required` flag, so last-write-wins meant a caller could
+  never supply the annotation on its own. [MudBlazor#13613](https://github.com/MudBlazor/MudBlazor/pull/13613)
+  moved the ARIA writes *above* the splat and left `required` below it; shipped in **9.9.0**
+- `Required()` therefore now contributes **`aria-required="true"` through `UserAttributes`** and
+  leaves MudBlazor's `Required` parameter alone. ⛔ Do not "simplify" this back to setting `Required`
+  — that reintroduces the HTML5 attribute this convention forbids. And do not drop the annotation
+  either: that is #190, and it is a Level A failure. Both halves are pinned by `AriaRequiredTests`
+- ⚠️ **The visible asterisk is gone for a plain `.Required(...)` field**, and that is a decision, not
+  a regression to fix. MudBlazor draws it from the same `Required` parameter as the HTML5 attribute,
+  and #13613 did not separate *those* two. `.WithNativeRequired()` is the documented way back to
+  native semantics — asterisk and HTML5 attribute together
+- 🔒 **Version floor: MudBlazor ≥ 9.9.0.** On anything older, 9 of the 35 `AriaRequiredTests` fail
+  (measured by reverting the pin). Do not lower `Directory.Packages.props` below it
 - Browser validation disabled via a `novalidate` attribute **rendered on the form** by
   `FormCraftComponent` (#206). It is a real attribute in the markup, so it applies during
   prerender/SSR, targets this component's own form rather than the first one on the page, and needs
@@ -352,15 +361,18 @@ because it lives in core rather than in one of the two packages that need it.
   ran on the server pass, failed silently, and was blocked outright by a strict CSP
 - All validation through FluentValidation
 - Validation messages from server, not browser
-- MudBlazor components DO set `Required` for a `.Required(...)` field since #199 (see above), on
-  **every** field type that can carry it: text, numeric, date, select, multi-select, autocomplete,
-  lookup, LOV and boolean, on both render paths. ⛔ Keep it uniform when adding a field type. Once
-  required fields carry an asterisk, absence stops meaning "not annotated" and starts meaning
-  "optional", so a new renderer that skips this actively mis-signals rather than merely omitting
-- **Checkboxes take a different route.** `MudCheckBox`/`MudSwitch` emit no `aria-required`, so
-  FormCraft passes it via `UserAttributes` — which lands there because nothing downstream re-emits
-  it. Do **not** copy that trick to `MudInput`-based fields: there MudBlazor's own later write always
-  wins, which is the whole reason `Required` had to be the mechanism (see `EffectiveNativeRequired`)
+- MudBlazor components announce `aria-required` for a `.Required(...)` field on **every** field type
+  that can carry it: text, numeric, date, select, multi-select, autocomplete, lookup, LOV and
+  boolean. ⛔ Keep it uniform when adding a field type — a required field that says nothing is a
+  Level A failure, and one that says `aria-required="false"` states the opposite of the truth. The
+  value comes from `MudBlazorFieldComponentBase.AriaRequired`; bind it alongside `Required` in the
+  new component's `.razor`
+- **Every field type now takes the `UserAttributes` route** that checkboxes always did. Since 9.9.0
+  a caller-supplied `aria-required` wins on `MudInput`-based fields too, so there is one mechanism
+  rather than two. ⚠️ `AriaRequired` returns `"true"`/`"false"` and **never `null`**: a null
+  component parameter is still captured into `UserAttributes` as a present key, and Blazor deletes
+  an attribute whose last write is null — returning `null` for optional fields drops
+  `aria-required` entirely instead of leaving it `"false"` (measured; it turned five assertions red)
 - **File upload is covered too, but NOT via `Required` on `MudFileUpload`** (#262). Its
   `<input type="file">` carries `tabindex="-1"` at `opacity-0` behind a custom drop zone, so
   annotating that input satisfies a DOM assertion while reaching no user who navigates by focus.
diff --git a/FormCraft/Forms/Extensions/FieldBuilderExtensions.cs b/FormCraft/Forms/Extensions/FieldBuilderExtensions.cs
index d7e2179..88e2810 100644
--- a/FormCraft/Forms/Extensions/FieldBuilderExtensions.cs
+++ b/FormCraft/Forms/Extensions/FieldBuilderExtensions.cs
@@ -203,14 +203,16 @@ public FieldBuilder<TModel, TValue> WithEmailValidation(string? errorMessage = n
 
         /// <summary>
         /// Overrides whether this field renders the UI framework's native required decoration — the
-        /// HTML5 <c>required</c> attribute, <c>aria-required</c>, and the framework's required
-        /// styling (the asterisk) on the rendered input. Pass <c>false</c> to suppress a decoration
-        /// that <c>.Required(...)</c> would otherwise produce.
+        /// HTML5 <c>required</c> attribute and the framework's required styling (the asterisk) on
+        /// the rendered input. Pass <c>true</c> to add a decoration that <c>.Required(...)</c> alone
+        /// no longer produces; pass <c>false</c> to suppress the field's required annotation
+        /// entirely.
         /// </summary>
         /// <param name="enabled">
-        /// <c>true</c> (default) to force the decoration on a field that never called
-        /// <c>.Required(...)</c>; <c>false</c> to suppress it on one that did. Either way the
-        /// explicit value wins over the inference — this method is an override, not merely an opt-in.
+        /// <c>true</c> (default) to render the native decoration, whether or not
+        /// <c>.Required(...)</c> was called; <c>false</c> to suppress the requirement annotation on a
+        /// field that did call it. Either way the explicit value wins over the inference — this
+        /// method is an override, not merely an opt-in.
         /// </param>
         /// <returns>The FieldBuilder instance for method chaining.</returns>
         /// <remarks>
@@ -221,13 +223,20 @@ public FieldBuilder<TModel, TValue> WithEmailValidation(string? errorMessage = n
         /// <c>false</c> here suppresses the decoration and leaves that validation entirely intact.
         /// </para>
         /// <para>
-        /// ⛔ <b>Think twice before passing <c>false</c> on a <c>.Required(...)</c> field.</b> Since
-        /// #199 a required field renders <c>aria-required="true"</c> so assistive technology
-        /// announces it; suppressing that puts <c>aria-required="false"</c> back on a genuinely
-        /// required input, which states the opposite of the truth to a screen reader and is a
-        /// WCAG 2.1 3.3.2 (Level A) failure. If the visible asterisk is what you want gone, restyle
-        /// the framework's required class instead. Legitimate uses of <c>false</c> are fields whose
-        /// requirement is conditional or communicated elsewhere.
+        /// ⛔ <b>Think twice before passing <c>false</c> on a <c>.Required(...)</c> field.</b> A
+        /// required field renders <c>aria-required="true"</c> so assistive technology announces it;
+        /// suppressing that puts <c>aria-required="false"</c> back on a genuinely required input,
+        /// which states the opposite of the truth to a screen reader and is a WCAG 2.1 3.3.2
+        /// (Level A) failure. Legitimate uses of <c>false</c> are fields whose requirement is
+        /// conditional or communicated elsewhere.
+        /// </para>
+        /// <para>
+        /// <b>What <c>true</c> buys you since #263.</b> A plain <c>.Required(...)</c> field is now
+        /// announced through <c>aria-required</c> alone and carries neither the HTML5 attribute nor
+        /// the framework's asterisk — MudBlazor drives both from its own <c>Required</c> parameter
+        /// and they cannot be separated from each other. This method is what sets that parameter, so
+        /// it is the supported way to get the visible marker back, and the HTML5 attribute comes with
+        /// it. Between #199 and #263 the pairing was unavoidable rather than chosen; it is now opt-in.
         /// </para>
         /// <para>
         /// Lives in core rather than in an adapter because the value it writes is read by every
@@ -251,8 +260,8 @@ public FieldBuilder<TModel, TValue> WithEmailValidation(string? errorMessage = n
         /// <example>
         /// <code>
         /// .AddField(x => x.Email, field => field
-        ///     .Required("Email is required")   // the validation
-        ///     .WithNativeRequired())           // the decoration
+        ///     .Required("Email is required")   // the validation, and aria-required="true"
+        ///     .WithNativeRequired())           // the visible asterisk + HTML5 required
         /// </code>
         /// </example>
         public FieldBuilder<TModel, TValue> WithNativeRequired(bool enabled = true)
diff --git a/README.md b/README.md
index 8e6ca07..155d19b 100644
--- a/README.md
+++ b/README.md
@@ -58,6 +58,12 @@ Experience FormCraft in action! Visit our [interactive demo](https://phmatray.gi
 
 ## 🎉 Unreleased
 
+- **Required fields are announced to screen readers again — and no longer carry the HTML5 `required` attribute (#263).** FormCraft's convention has always been that `Required()` adds validation, not browser constraint validation; forms render `novalidate` and messages come from your validators. #199 had to bend that: MudBlazor derived the HTML5 `required` attribute **and** `aria-required` from a single `Required` flag and wrote both *after* splatting caller attributes, so the accessibility annotation could not be had without the attribute. Announcing the field won, and the HTML5 attribute came along.
+
+  [MudBlazor#13613](https://github.com/MudBlazor/MudBlazor/pull/13613) — contributed from this repo and released in **MudBlazor 9.9.0** — moved those ARIA writes above the splat so a caller can override them, while leaving `required` bound to the parameter. FormCraft now passes `aria-required="true"` through `UserAttributes` and leaves `Required` alone. A required field is still announced, on every field type that can carry it, and the `required` attribute is gone. **The MudBlazor pin is therefore raised to 9.9.0 and must not go below it.**
+
+  ⚠️ **The visible asterisk goes with it.** MudBlazor draws its `*` from the same `Required` parameter as the HTML5 attribute, and those two are still fused, so a plain `.Required("…")` field no longer shows one. This was a deliberate trade rather than an oversight: **`.WithNativeRequired()` restores MudBlazor's native decoration — asterisk and HTML5 attribute together** — on any field you want marked visibly. If you relied on the asterisk appearing automatically for required fields, add that call, or style the requirement yourself from your own label markup.
+
 - **`.editorconfig` is now actually enforced, and the tree matches it (#301).** The file declared its code-style rules at `warning` severity and `Directory.Build.props` sets `TreatWarningsAsErrors=true` — which together *look* like enforcement and were not: `IDE*` analyzers only run at build time when `EnforceCodeStyleInBuild` is set, and it wasn't, while no CI job ran `dotnet format` either. Nothing anywhere read those severities, so 574 violations had accumulated across 201 files. There is now a Nuke `Format` target (`./build.sh Format`) wrapping `dotnet format --verify-no-changes`, wired into `ci.yml` ahead of the test run, and a one-off pass has cleared the backlog — split into a whitespace commit and a code-style commit so the shape-changing fixes stayed reviewable. Enforcement lives in CI rather than the build on purpose: with warnings-as-errors, build-time style analysis would break `dotnet build` mid-edit over a missing brace.
 
   ⚠️ **`dotnet format` can corrupt multi-targeted files when it applies fixes** — `FormCraft` is `net8.0;net10.0`, and a fix applied once per target framework can land as a literal `<<<<<<< TODO: Unmerged change` conflict block written into the `.cs` file, which then doesn't compile. Verify mode never writes, so the CI gate is unaffected. After running the formatter to apply fixes, `grep -rl '<<<<<<< TODO' --include='*.cs' .` before committing.

From 67f26f4aa5044b97a48f55949415cbba674c13f7 Mon Sep 17 00:00:00 2001
From: Philippe Matray <phmatray@gmail.com>
Date: Wed, 26 Aug 2026 11:08:19 +0200
Subject: [PATCH 5/5] fix: address code-review findings

---
 .../MudBlazorBooleanFieldComponent.razor      |  8 +++---
 .../MudBlazorBooleanFieldComponent.razor.cs   | 27 +++++++++++++------
 2 files changed, 23 insertions(+), 12 deletions(-)

diff --git a/FormCraft.ForMudBlazor/Fields/BooleanField/MudBlazorBooleanFieldComponent.razor b/FormCraft.ForMudBlazor/Fields/BooleanField/MudBlazorBooleanFieldComponent.razor
index 98d7537..0bad1a2 100644
--- a/FormCraft.ForMudBlazor/Fields/BooleanField/MudBlazorBooleanFieldComponent.razor
+++ b/FormCraft.ForMudBlazor/Fields/BooleanField/MudBlazorBooleanFieldComponent.razor
@@ -12,8 +12,8 @@
         @bind-Value:after="OnLocalValueChanged"
         ReadOnly="@IsReadOnly"
         Disabled="@IsDisabled"
-        Required="@NativeRequiredValue"
-        aria-required="@AriaRequiredValue"
+        Required="@EffectiveNativeRequired"
+        aria-required="@AriaRequired"
         Color="Color.Primary" />
 }
 else
@@ -25,6 +25,6 @@ else
         @bind-Value:after="OnLocalValueChanged"
         ReadOnly="@IsReadOnly"
         Disabled="@IsDisabled"
-        Required="@NativeRequiredValue"
-        aria-required="@AriaRequiredValue" />
+        Required="@EffectiveNativeRequired"
+        aria-required="@AriaRequired" />
 }
diff --git a/FormCraft.ForMudBlazor/Fields/BooleanField/MudBlazorBooleanFieldComponent.razor.cs b/FormCraft.ForMudBlazor/Fields/BooleanField/MudBlazorBooleanFieldComponent.razor.cs
index e71358f..d5795f8 100644
--- a/FormCraft.ForMudBlazor/Fields/BooleanField/MudBlazorBooleanFieldComponent.razor.cs
+++ b/FormCraft.ForMudBlazor/Fields/BooleanField/MudBlazorBooleanFieldComponent.razor.cs
@@ -5,16 +5,27 @@ public partial class MudBlazorBooleanFieldComponent<TModel>
     private bool _localValue;
 
     /// <summary>
-    /// Whether this field renders MudBlazor's native required decoration (#199), resolved by the
-    /// same rule as every other field type — see <see cref="NativeRequired.Resolve"/>.
+    /// Whether this field renders MudBlazor's native required decoration — the asterisk and the
+    /// HTML5 <c>required</c> attribute. Set only by the explicit <c>.WithNativeRequired(...)</c>
+    /// opt-in since #263; the announcement lives in <see cref="AriaRequired"/>.
     /// </summary>
     /// <remarks>
+    /// <para>
     /// Declared here rather than inherited because this component derives from
-    /// <c>FieldComponentBase</c> directly, not from <c>MudBlazorFieldComponentBase</c>, so it has no
-    /// <c>EffectiveNativeRequired</c>. Rebasing it would drag in the variant cascade and the
-    /// ShrinkLabel diagnostic, neither of which a checkbox has any use for.
+    /// <c>FieldComponentBase</c> directly, not from <c>MudBlazorFieldComponentBase</c>. Rebasing it
+    /// would drag in the variant cascade and the ShrinkLabel diagnostic, neither of which a checkbox
+    /// has any use for.
+    /// </para>
+    /// <para>
+    /// ⚠️ It carries the <b>same name and the same meaning</b> as the base's property on purpose.
+    /// This pair was called <c>NativeRequiredValue</c>/<c>AriaRequiredValue</c> until #263 split the
+    /// decoration from the announcement — at which point the old name would have meant "explicit
+    /// opt-in only" here while <c>MudBlazorFileUploadComponentBase.NativeRequiredValue</c> went on
+    /// meaning "is this field required", the full resolve. Two sibling components, one identifier,
+    /// opposite answers, and nothing to catch a copy-paste between them.
+    /// </para>
     /// </remarks>
-    private bool NativeRequiredValue =>
+    private bool EffectiveNativeRequired =>
         NativeRequired.Resolve(Context.Field.AdditionalAttributes, isRequired: false);
 
     /// <summary>
@@ -30,13 +41,13 @@ public partial class MudBlazorBooleanFieldComponent<TModel>
     /// types can return <c>null</c> there; this one cannot.
     /// </para>
     /// <para>
-    /// Resolved from <c>IsRequired</c> rather than from <see cref="NativeRequiredValue"/> since
+    /// Resolved from <c>IsRequired</c> rather than from <see cref="EffectiveNativeRequired"/> since
     /// #263, which split the announcement from the native decoration. Reading the sibling property
     /// would silently re-couple them and leave a required checkbox unannounced the moment it stopped
     /// setting <c>Required</c>.
     /// </para>
     /// </remarks>
-    private string AriaRequiredValue =>
+    private string AriaRequired =>
         NativeRequired.Resolve(Context.Field.AdditionalAttributes, IsRequired) ? "true" : "false";
 
     public BooleanDisplayStyle DisplayStyle { get; set; } = BooleanDisplayStyle.Checkbox;