fix

lib/htmlrw_check/element/tag.ml

···
 let tag_of_string ?namespace name =
   let name_lower = String.lowercase_ascii name in
   match namespace with
-  | Some ns when is_svg_namespace ns -> Svg name_lower
-  | Some ns when is_mathml_namespace ns -> MathML name_lower
+  | Some ns when is_svg_namespace ns -> Svg name  (* Preserve original case for SVG *)
+  | Some ns when is_mathml_namespace ns -> MathML name  (* Preserve original case for MathML *)
   | Some _ -> Unknown name_lower  (* Unknown namespace *)
   | None ->
     match html_tag_of_string_opt name_lower with

lib/htmlrw_check/error_code.ml

···
   | `Unrecognized_role of [`Token of string]
   | `Tab_without_tabpanel
   | `Multiple_main
+  | `Accessible_name_prohibited of [`Attr of string] * [`Elem of string]
 ]
 
 type li_role_error = [
···
   | `Aria (`Unrecognized_role _) -> "unrecognized-role"
   | `Aria `Tab_without_tabpanel -> "tab-without-tabpanel"
   | `Aria `Multiple_main -> "multiple-main"
+  | `Aria (`Accessible_name_prohibited _) -> "aria-not-allowed"
 
   (* List item role errors *)
   | `Li_role `Div_in_dl_bad_role -> "invalid-role"
···
   | `Aria `Multiple_main ->
       Printf.sprintf "A document should not include more than one visible element with %s."
         (q "role=main")
+  | `Aria (`Accessible_name_prohibited (`Attr attr, `Elem element)) ->
+      (* Roles that prohibit accessible names - defined by ARIA spec *)
+      let prohibited_roles = [
+        "caption"; "code"; "deletion"; "emphasis"; "generic"; "insertion";
+        "paragraph"; "presentation"; "strong"; "subscript"; "superscript"
+      ] in
+      let roles_str = String.concat ", " (List.map q (List.rev (List.tl (List.rev prohibited_roles)))) ^
+        ", or " ^ q (List.hd (List.rev prohibited_roles)) in
+      Printf.sprintf "The %s attribute must not be specified on any %s element unless the element has a %s value other than %s."
+        (q attr) (q element) (q "role") roles_str
 
   (* List item role errors *)
   | `Li_role `Div_in_dl_bad_role ->

lib/htmlrw_check/error_code.mli

···
     (** Document has multiple visible main landmarks.
         Only one visible [role="main"] or [<main>] should exist
         per document for proper landmark navigation. *)
+
+  | `Accessible_name_prohibited of [`Attr of string] * [`Elem of string]
+    (** Accessible name attribute not allowed on element with generic role.
+        Elements with implicit [role="generic"] (or no role) cannot have
+        [aria-label], [aria-labelledby], or [aria-braillelabel] unless
+        they have an explicit role that supports accessible names. *)
 ]
 
 (** List item role constraint errors.

lib/htmlrw_check/specialized/aria_checker.ml

···
 (** ARIA validation checker implementation. *)
 
+(** Quote helper for consistent message formatting. *)
+let q = Error_code.q
+
 (** Valid WAI-ARIA 1.2 roles.
 
     These are all the valid role values according to the WAI-ARIA 1.2
···
 let render_role_set roles =
   match roles with
   | [] -> ""
-  | [role] -> "\"" ^ role ^ "\""
+  | [role] -> q role
   | _ ->
-      let quoted = List.map (fun r -> "\"" ^ r ^ "\"") roles in
+      let quoted = List.map q roles in
       String.concat " or " quoted
 
 let start_element state ~element collector =
···
       (* Generate error if element cannot have accessible name but has one *)
       if has_aria_label && not can_have_name then
         Message_collector.add_typed collector
-          (`Aria (`Must_not_specify (`Attr "aria-label", `Elem name,
-            `Condition "the element has a \xe2\x80\x9crole\xe2\x80\x9d value other than \xe2\x80\x9ccaption\xe2\x80\x9d, \xe2\x80\x9ccode\xe2\x80\x9d, \xe2\x80\x9cdeletion\xe2\x80\x9d, \xe2\x80\x9cemphasis\xe2\x80\x9d, \xe2\x80\x9cgeneric\xe2\x80\x9d, \xe2\x80\x9cinsertion\xe2\x80\x9d, \xe2\x80\x9cparagraph\xe2\x80\x9d, \xe2\x80\x9cpresentation\xe2\x80\x9d, \xe2\x80\x9cstrong\xe2\x80\x9d, \xe2\x80\x9csubscript\xe2\x80\x9d, or \xe2\x80\x9csuperscript\xe2\x80\x9d")));
+          (`Aria (`Accessible_name_prohibited (`Attr "aria-label", `Elem name)));
 
       if has_aria_labelledby && not can_have_name then
         Message_collector.add_typed collector
-          (`Aria (`Must_not_specify (`Attr "aria-labelledby", `Elem name,
-            `Condition "the element has a \xe2\x80\x9crole\xe2\x80\x9d value other than \xe2\x80\x9ccaption\xe2\x80\x9d, \xe2\x80\x9ccode\xe2\x80\x9d, \xe2\x80\x9cdeletion\xe2\x80\x9d, \xe2\x80\x9cemphasis\xe2\x80\x9d, \xe2\x80\x9cgeneric\xe2\x80\x9d, \xe2\x80\x9cinsertion\xe2\x80\x9d, \xe2\x80\x9cparagraph\xe2\x80\x9d, \xe2\x80\x9cpresentation\xe2\x80\x9d, \xe2\x80\x9cstrong\xe2\x80\x9d, \xe2\x80\x9csubscript\xe2\x80\x9d, or \xe2\x80\x9csuperscript\xe2\x80\x9d")));
+          (`Aria (`Accessible_name_prohibited (`Attr "aria-labelledby", `Elem name)));
 
       if has_aria_braillelabel && not can_have_name then
         Message_collector.add_typed collector
-          (`Aria (`Must_not_specify (`Attr "aria-braillelabel", `Elem name,
-            `Condition "the element has a \xe2\x80\x9crole\xe2\x80\x9d value other than \xe2\x80\x9ccaption\xe2\x80\x9d, \xe2\x80\x9ccode\xe2\x80\x9d, \xe2\x80\x9cdeletion\xe2\x80\x9d, \xe2\x80\x9cemphasis\xe2\x80\x9d, \xe2\x80\x9cgeneric\xe2\x80\x9d, \xe2\x80\x9cinsertion\xe2\x80\x9d, \xe2\x80\x9cparagraph\xe2\x80\x9d, \xe2\x80\x9cpresentation\xe2\x80\x9d, \xe2\x80\x9cstrong\xe2\x80\x9d, \xe2\x80\x9csubscript\xe2\x80\x9d, or \xe2\x80\x9csuperscript\xe2\x80\x9d")));
+          (`Aria (`Accessible_name_prohibited (`Attr "aria-braillelabel", `Elem name)));
 
       (* Check for img with empty alt having role attribute *)
       if name_lower = "img" then begin
···
               | None -> "text"
             in
             if not has_list && input_type = "text" then
-              "for an \xe2\x80\x9cinput\xe2\x80\x9d element that has no \xe2\x80\x9clist\xe2\x80\x9d attribute and whose type is \xe2\x80\x9ctext\xe2\x80\x9d"
+              Printf.sprintf "for an %s element that has no %s attribute and whose type is %s"
+                (q "input") (q "list") (q "text")
             else
-              Printf.sprintf "for element \xe2\x80\x9c%s\xe2\x80\x9d" name
+              Printf.sprintf "for element %s" (q name)
           end else
-            Printf.sprintf "for element \xe2\x80\x9c%s\xe2\x80\x9d" name
+            Printf.sprintf "for element %s" (q name)
         in
         Message_collector.add_typed collector
           (`Aria (`Unnecessary_role (`Role first_role, `Elem name, `Reason reason)))
···
         if Hashtbl.mem roles_which_cannot_be_named role && has_accessible_name then
           Message_collector.add_typed collector
             (`Generic (Printf.sprintf
-              "Elements with role=\"%s\" must not have accessible names (via aria-label or aria-labelledby)."
-              role));
+              "Elements with %s must not have accessible names (via aria-label or aria-labelledby)."
+              (q ("role=" ^ role))));
 
         (* Check for required ancestor roles *)
         begin match Hashtbl.find_opt required_role_ancestor_by_descendant role with
···
             if not (has_required_ancestor_role state required_ancestors) then
               Message_collector.add_typed collector
                 (`Generic (Printf.sprintf
-                  "An element with \"role=%s\" must be contained in, or owned by, an element with the \"role\" value %s."
-                  role
+                  "An element with %s must be contained in, or owned by, an element with the %s value %s."
+                  (q ("role=" ^ role))
+                  (q "role")
                   (render_role_set required_ancestors)))
         | None -> ()
         end;
···
               if value_lower = default_value then
                 Message_collector.add_typed collector
                   (`Generic (Printf.sprintf
-                    "The \xe2\x80\x9c%s\xe2\x80\x9d attribute is unnecessary for the value \xe2\x80\x9c%s\xe2\x80\x9d."
-                    attr_name attr_value))
+                    "The %s attribute is unnecessary for the value %s."
+                    (q attr_name) (q attr_value)))
           | None -> ()
       ) attrs;
 
···
         implicit_role;
       } in
       state.stack <- node :: state.stack
-  | _ -> () (* Skip non-HTML elements *)
+
+  | Tag.Custom name ->
+      (* Custom elements (autonomous custom elements) have generic role by default
+         and cannot have accessible names unless they have an explicit role *)
+      let attrs = element.raw_attrs in
+      let role_attr = List.assoc_opt "role" attrs in
+      let aria_label = List.assoc_opt "aria-label" attrs in
+      let aria_labelledby = List.assoc_opt "aria-labelledby" attrs in
+      let aria_braillelabel = List.assoc_opt "aria-braillelabel" attrs in
+      let has_aria_label = match aria_label with Some v -> String.trim v <> "" | None -> false in
+      let has_aria_labelledby = match aria_labelledby with Some v -> String.trim v <> "" | None -> false in
+      let has_aria_braillelabel = match aria_braillelabel with Some v -> String.trim v <> "" | None -> false in
+
+      (* Parse explicit roles from role attribute *)
+      let explicit_roles = match role_attr with
+        | Some role_value -> split_roles role_value
+        | None -> []
+      in
+
+      (* Custom elements have no implicit role (generic) *)
+      let implicit_role = None in
+
+      (* Check if element can have accessible names *)
+      let can_have_name = element_can_have_accessible_name name explicit_roles implicit_role in
+
+      (* Generate error if element cannot have accessible name but has one *)
+      if has_aria_label && not can_have_name then
+        Message_collector.add_typed collector
+          (`Aria (`Accessible_name_prohibited (`Attr "aria-label", `Elem name)));
+
+      if has_aria_labelledby && not can_have_name then
+        Message_collector.add_typed collector
+          (`Aria (`Accessible_name_prohibited (`Attr "aria-labelledby", `Elem name)));
+
+      if has_aria_braillelabel && not can_have_name then
+        Message_collector.add_typed collector
+          (`Aria (`Accessible_name_prohibited (`Attr "aria-braillelabel", `Elem name)))
+
+  | _ -> () (* Skip SVG, MathML, Unknown elements *)
 
 let end_element state ~tag _collector =
   (* Only process HTML elements *)

lib/htmlrw_check/specialized/svg_checker.ml

···
 
 type fecomponenttransfer_state = {
   mutable seen_funcs : string list;  (* track feFuncR, feFuncG, etc. *)
+  mutable duplicate_error_reported : bool;  (* suppress further duplicate errors *)
 }
 
 type state = {
···
     | parent :: _ when String.lowercase_ascii parent = "a" ->
         if List.mem name_lower a_disallowed_children then
           Message_collector.add_typed collector
-            (`Element (`Not_allowed_as_child (`Child name_lower, `Parent "a")))
+            (`Element (`Not_allowed_as_child (`Child name, `Parent "a")))
     | _ -> ());
 
     (* 2. Track missing-glyph in font *)
···
         if List.mem name_lower ["fefuncr"; "fefuncg"; "fefuncb"; "fefunca"] then begin
           match state.fecomponenttransfer_stack with
           | fect :: _ ->
-              if List.mem name_lower fect.seen_funcs then
-                Message_collector.add_typed collector
-                  (`Element (`Not_allowed_as_child (`Child name, `Parent "feComponentTransfer")))
-              else
+              if List.mem name_lower fect.seen_funcs then begin
+                (* Only report first duplicate error, suppress further *)
+                if not fect.duplicate_error_reported then begin
+                  Message_collector.add_typed collector
+                    (`Element (`Not_allowed_as_child (`Child name, `Parent "feComponentTransfer")));
+                  fect.duplicate_error_reported <- true
+                end
+              end else
                 fect.seen_funcs <- name_lower :: fect.seen_funcs
           | [] -> ()
         end
···
     if name_lower = "font" then
       state.font_stack <- { has_missing_glyph = false } :: state.font_stack;
     if name_lower = "fecomponenttransfer" then
-      state.fecomponenttransfer_stack <- { seen_funcs = [] } :: state.fecomponenttransfer_stack;
+      state.fecomponenttransfer_stack <- { seen_funcs = []; duplicate_error_reported = false } :: state.fecomponenttransfer_stack;
+
+    (* Check feConvolveMatrix requires order attribute *)
+    if name_lower = "feconvolvematrix" then begin
+      if not (Attr_utils.has_attr "order" attrs) then
+        Message_collector.add_typed collector
+          (`Svg (`Missing_attr (`Elem "feConvolveMatrix", `Attr "order")))
+    end;
 
     state.element_stack <- name :: state.element_stack;