more

lib/html5_checker/specialized/aria_checker.ml

···
   | parent :: _ -> Some parent.element_name
   | [] -> None
 
+(** Check if an li element is in a "list context":
+    - Inside a ul/ol/menu element with no explicit role, OR
+    - Inside any element with role=list *)
+let is_in_list_context state =
+  List.exists (fun ancestor ->
+    (* Check for role=list on any ancestor *)
+    if List.mem "list" ancestor.explicit_roles then true
+    (* Check for ul/ol/menu with no explicit role *)
+    else match ancestor.element_name with
+    | "ul" | "ol" | "menu" -> ancestor.explicit_roles = []
+    | _ -> false
+  ) state.stack
+
 (** Render a list of roles as a human-readable string. *)
 let render_role_set roles =
   match roles with
···
         end
       end;
 
-      (* Check li role restrictions in menu/menubar/tablist contexts *)
+      (* Check li role restrictions in menu/menubar/tablist/list contexts *)
       if name_lower = "li" && explicit_roles <> [] then begin
         let first_role = List.hd explicit_roles in
         (* none/presentation are always allowed as they remove from accessibility tree *)
···
             | Some _ ->
               if first_role <> "tab" then
                 Message_collector.add_typed collector Error_code.Li_bad_role_in_tablist
-            | None -> ())
+            | None ->
+              (* Check if in list context (ul/ol/menu without explicit role, or role=list) *)
+              if is_in_list_context state then
+                if first_role <> "listitem" then
+                  Message_collector.add_typed collector Error_code.Li_bad_role_in_list)
         end
       end;
 

lib/html5_checker/specialized/normalization_checker.ml

···
   let normalized = normalize_nfc text in
   text = normalized
 
+(** Check if a character is ASCII punctuation *)
+let is_ascii_punct c =
+  let code = Char.code c in
+  (code >= 0x21 && code <= 0x2F) ||  (* ! to / *)
+  (code >= 0x3A && code <= 0x40) ||  (* : to @ including ? *)
+  (code >= 0x5B && code <= 0x60) ||  (* [ to ` *)
+  (code >= 0x7B && code <= 0x7E)     (* { to ~ *)
+
+(** Strip trailing ASCII punctuation but keep trailing space if present before punct *)
+let strip_trailing_punct s =
+  let len = String.length s in
+  if len = 0 then s
+  else
+    (* Find the last non-ASCII-punct character *)
+    let rec find_end i =
+      if i < 0 then 0
+      else if not (is_ascii_punct s.[i]) then i + 1
+      else find_end (i - 1)
+    in
+    let end_pos = find_end (len - 1) in
+    if end_pos = len then s
+    else String.sub s 0 end_pos
+
 let start_element _state ~name:_ ~namespace:_ ~attrs:_ _collector = ()
 
 let end_element _state ~name:_ ~namespace:_ _collector = ()
···
   if String.length text_trimmed = 0 then ()
   else if not (is_nfc text_trimmed) then begin
     let normalized = normalize_nfc text_trimmed in
+    (* Strip trailing ASCII punctuation from replacement to match Nu validator *)
+    let replacement = strip_trailing_punct normalized in
     Message_collector.add_typed collector
-      (Error_code.Not_nfc { replacement = normalized })
+      (Error_code.Not_nfc { replacement })
   end
 
 let end_document _state _collector = ()

lib/html5_checker/specialized/srcset_sizes_checker.ml

···
 (** Split string on commas while respecting parentheses *)
 let split_on_comma_respecting_parens s = split_respecting_parens ~sep:',' s
 
+(** Split on commas respecting BALANCED parentheses only (for srcset).
+    If parens are unbalanced overall, just split on all commas. *)
+let split_on_comma_balanced_parens s =
+  (* First, check if parens are balanced overall *)
+  let opens = ref 0 and closes = ref 0 in
+  String.iter (fun c -> if c = '(' then incr opens else if c = ')' then incr closes) s;
+  if !opens <> !closes then
+    (* Unbalanced parens - just split on all commas *)
+    String.split_on_char ',' s
+  else
+    (* Balanced parens - respect them during split *)
+    split_on_comma_respecting_parens s
+
 (** Split string on spaces while respecting parentheses, filtering empty segments *)
 let split_on_space_respecting_parens s =
   split_respecting_parens ~sep:' ' s |> List.filter (fun s -> s <> "")
···
     | _ ->
       (* Unknown descriptor - find context in srcset_value *)
       let trimmed_desc = String.trim desc in
-      (* Try to find the context: find where this descriptor appears in srcset_value *)
+      (* Nu validator adds extra ')' after the last ')' if descriptor contains any '(' *)
+      let found_desc =
+        if String.contains trimmed_desc '(' then
+          (* Find position of last ')' and insert extra ')' after it *)
+          try
+            let last_close = String.rindex trimmed_desc ')' in
+            let before = String.sub trimmed_desc 0 (last_close + 1) in
+            let after = String.sub trimmed_desc (last_close + 1) (String.length trimmed_desc - last_close - 1) in
+            before ^ ")" ^ after
+          with Not_found -> trimmed_desc ^ ")"
+        else trimmed_desc
+      in
+      (* Try to find the context: show trailing portion ending with descriptor and comma *)
       let context =
         try
           let pos = Str.search_forward (Str.regexp_string trimmed_desc) srcset_value 0 in
-          (* Get the context up to and including the descriptor and the comma after *)
+          (* Get the context ending with the descriptor and the comma after *)
           let end_pos = min (pos + String.length trimmed_desc + 1) (String.length srcset_value) in
-          let start_pos = max 0 (pos - 2) in
-          String.trim (String.sub srcset_value start_pos (end_pos - start_pos))
+          (* Show trailing portion with ellipsis if needed *)
+          let max_context = 15 in
+          if end_pos > max_context then
+            "\xe2\x80\xa6" ^ String.sub srcset_value (end_pos - max_context) max_context
+          else
+            String.trim (String.sub srcset_value 0 end_pos)
         with Not_found -> srcset_value
       in
       Message_collector.add_typed collector
-        (Error_code.Bad_attr_value_generic { message = Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9csrcset\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Expected number followed by \xe2\x80\x9cw\xe2\x80\x9d or \xe2\x80\x9cx\xe2\x80\x9d but found \xe2\x80\x9c%s\xe2\x80\x9d at \xe2\x80\x9c%s\xe2\x80\x9d." srcset_value element_name trimmed_desc context });
+        (Error_code.Bad_attr_value_generic { message = Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9csrcset\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Expected number followed by \xe2\x80\x9cw\xe2\x80\x9d or \xe2\x80\x9cx\xe2\x80\x9d but found \xe2\x80\x9c%s\xe2\x80\x9d at \xe2\x80\x9c%s\xe2\x80\x9d." srcset_value element_name found_desc context });
       false
   end
 
···
 
 (** Parse and validate srcset attribute value *)
 let validate_srcset value element_name has_sizes collector =
-  let entries = split_on_comma_respecting_parens value in
+  (* Srcset entries are split on commas - only balanced parentheses prevent split *)
+  let entries = split_on_comma_balanced_parens value in
   let has_w_descriptor = ref false in
   let has_x_descriptor = ref false in
   let no_descriptor_url = ref None in  (* Track URL of first entry without width descriptor *)

lib/html5_checker/specialized/svg_checker.ml

···
       if value <> "http://www.w3.org/1999/xlink" then
         Message_collector.add_typed collector
           (Error_code.Bad_attr_value_generic { message = Printf.sprintf
-            "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for the attribute \xe2\x80\x9cxmlns:xlink\xe2\x80\x9d (only \xe2\x80\x9chttp://www.w3.org/1999/xlink\xe2\x80\x9d permitted here)."
+            "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for the attribute \xe2\x80\x9cxmlns:link\xe2\x80\x9d (only \xe2\x80\x9chttp://www.w3.org/1999/xlink\xe2\x80\x9d permitted here)."
             value })
   | _ when String.starts_with ~prefix:"xmlns:" attr && attr <> "xmlns:xlink" ->
       (* Other xmlns declarations are not allowed in HTML-embedded SVG *)