imore

lib/html5_checker/datatype/dt_autocomplete.ml

···
     List.find_opt (fun t -> starts_with t "section-") tokens
   in
 
+  (* Check if webauthn appears anywhere except as the very last token *)
+  let check_webauthn_position tokens =
+    let rec check = function
+      | [] -> None
+      | ["webauthn"] -> None  (* webauthn as last token is ok *)
+      | "webauthn" :: _ :: _ -> Some ()  (* webauthn not last is error *)
+      | _ :: rest -> check rest
+    in
+    check tokens
+  in
+
   (* Process remaining tokens *)
   let process_field_tokens tokens =
+    (* First check if webauthn appears but not at the very end *)
+    (match check_webauthn_position tokens with
+    | Some () ->
+      Error
+        "The token \"webauthn\" must only appear as the very last token in a \
+         list of autofill detail tokens."
+    | None ->
     match tokens with
     | [] -> Error "A list of autofill details tokens must contain an autofill field name."
     | [ "webauthn" ] ->
···
            | None ->
              Error
                "A list of autofill details tokens must not contain more than one \
-                autofill field name.")
+                autofill field name."))
   in
   process_field_tokens !tokens
 

lib/html5_checker/error_code.ml

···
       Printf.sprintf "Element %s is missing required attribute %s."
         (q element) (q attr)
   | Missing_required_attr_one_of { element; attrs } ->
-      let attrs_str = String.concat ", " (List.map q attrs) in
+      let attrs_str = String.concat ", " attrs in
       Printf.sprintf "Element %s is missing one or more of the following attributes: [%s]."
         (q element) attrs_str
   | Bad_attr_value { element; attr; value; reason } ->
···
       Printf.sprintf "Element %s is missing required child element %s."
         (q parent) (q child)
   | Missing_required_child_one_of { parent; children } ->
-      let children_str = String.concat ", " (List.map q children) in
+      let children_str = String.concat ", " children in
       Printf.sprintf "Element %s is missing one or more of the following child elements: [%s]."
         (q parent) children_str
   | Missing_required_child_generic { parent } ->
···
       Printf.sprintf "An %s element must have an %s attribute, except under certain conditions. For details, consult guidance on providing text alternatives for images."
         (q "img") (q "alt")
   | Img_missing_src_or_srcset ->
-      Printf.sprintf "Element %s is missing one or more of the following attributes: [%s, %s]."
-        (q "img") (q "src") (q "srcset")
+      Printf.sprintf "Element %s is missing one or more of the following attributes: [src, srcset]."
+        (q "img")
   | Option_empty_without_label ->
       Printf.sprintf "Element %s without attribute %s must not be empty."
         (q "option") (q "label")
···
       Printf.sprintf "The value of %s attribute for the %s element must not be %s."
         (q "dir") (q "bdo") (q "auto")
   | Base_missing_href_or_target ->
-      Printf.sprintf "Element %s is missing one or more of the following attributes: [%s, %s]."
-        (q "base") (q "href") (q "target")
+      Printf.sprintf "Element %s is missing one or more of the following attributes: [href, target]."
+        (q "base")
   | Base_after_link_script ->
       Printf.sprintf "The %s element must come before any %s or %s elements in the document."
         (q "base") (q "link") (q "script")
···
       Printf.sprintf "Element %s is missing required attribute %s."
         (q "summary") (q "role")
   | Summary_missing_attrs ->
-      Printf.sprintf "Element %s is missing one or more of the following attributes: [%s, %s, %s]."
-        (q "summary") (q "aria-checked") (q "aria-level") (q "role")
+      Printf.sprintf "Element %s is missing one or more of the following attributes: [aria-checked, aria-level, role]."
+        (q "summary")
   | Autocomplete_webauthn_on_select ->
       Printf.sprintf "The value of the %s attribute for the %s element must not contain %s."
         (q "autocomplete") (q "select") (q "webauthn")

lib/html5_checker/parse_error_bridge.ml

···
   let (message, final_code) = match code with
     | Html5rw.Parse_error_code.Non_void_html_element_start_tag_with_trailing_solidus ->
       ("Self-closing syntax (\"/>\") used on a non-void HTML element. Ignoring the slash and treating as a start tag.", code_str)
+    | Html5rw.Parse_error_code.Null_character_reference ->
+      ("Character reference expands to zero.", "null-character-reference")
     | Html5rw.Parse_error_code.Tree_construction_error s ->
         (* Check for control-character/noncharacter/surrogate with codepoint info *)
         (try
···
             ("End tag \xe2\x80\x9cp\xe2\x80\x9d implied, but there were open elements.", "end-tag-p-implied")
           else if s = "end-tag-br" then
             ("End tag \xe2\x80\x9cbr\xe2\x80\x9d.", "end-tag-br")
+          else if s = "expected-closing-tag-but-got-eof" then
+            ("End of file seen and there were open elements.", "eof-in-open-element")
+          else if String.length s > 19 && String.sub s 0 19 = "unexpected-end-tag:" then
+            let element = String.sub s 19 (String.length s - 19) in
+            (Printf.sprintf "Stray end tag \xe2\x80\x9c%s\xe2\x80\x9d." element, "stray-end-tag")
           else
             (Printf.sprintf "Parse error: %s" s, s)
         with _ -> (Printf.sprintf "Parse error: %s" s, s))

lib/html5_checker/semantic/nesting_checker.ml

···
 let ancestor_mask_by_descendant : (string, int) Hashtbl.t =
   Hashtbl.create 64
 
+(** Map from descendant element name to bitmask of ancestors that cause content model violations.
+    (These use different error messages than nesting violations.) *)
+let content_model_violation_mask : (string, int) Hashtbl.t =
+  Hashtbl.create 64
+
 (** Register that [ancestor] is prohibited for [descendant]. *)
 let register_prohibited_ancestor ancestor descendant =
   let number = special_ancestor_number ancestor in
···
   in
   let new_mask = mask lor (1 lsl number) in
   Hashtbl.replace ancestor_mask_by_descendant descendant new_mask
+
+(** Register a content model violation (phrasing-only element containing flow content). *)
+let register_content_model_violation ancestor descendant =
+  register_prohibited_ancestor ancestor descendant;
+  let number = special_ancestor_number ancestor in
+  let mask =
+    match Hashtbl.find_opt content_model_violation_mask descendant with
+    | None -> 0
+    | Some m -> m
+  in
+  let new_mask = mask lor (1 lsl number) in
+  Hashtbl.replace content_model_violation_mask descendant new_mask
 
 (** Initialize the prohibited ancestor map. *)
 let () =
···
   ) interactive_elements;
 
   (* Phrasing-only elements: cannot contain flow content like p, div, h1-h6, etc. *)
+  (* These are content model violations, not nesting violations. *)
   let phrasing_only = ["span"; "strong"; "em"; "b"; "i"; "u"; "s"; "small"; "mark";
                         "abbr"; "cite"; "code"; "q"; "sub"; "sup"; "samp"; "kbd"; "var"] in
   let flow_content = ["p"; "div"; "article"; "section"; "nav"; "aside"; "header"; "footer";
···
                        "ol"; "ul"; "dl"; "pre"; "blockquote"; "hr"] in
   List.iter (fun ancestor ->
     List.iter (fun descendant ->
-      register_prohibited_ancestor ancestor descendant
+      register_content_model_violation ancestor descendant
     ) flow_content
   ) phrasing_only
 
···
   let map_num = special_ancestor_number "map" in
   1 lsl map_num
 
+(** Transparent elements - inherit content model from parent *)
+let transparent_elements = ["a"; "canvas"; "video"; "audio"; "object"; "ins"; "del"; "map"]
+
 (** Stack node representing an element's context. *)
 type stack_node = {
   ancestor_mask : int;
-  _name : string;  [@warning "-69"]
+  name : string;
+  is_transparent : bool;
 }
 
 (** Checker state. *)
···
   | _ ->
       false
 
+(** Find the nearest transparent element in the ancestor stack, if any.
+    Returns the immediate parent's name if it's transparent, otherwise None. *)
+let find_nearest_transparent_parent state =
+  match state.stack with
+  | parent :: _ when parent.is_transparent -> Some parent.name
+  | _ -> None
+
 (** Report nesting violations. *)
 let check_nesting state name attrs collector =
   (* Compute the prohibited ancestor mask for this element *)
···
     | None -> 0
   in
 
+  (* Get content model violation mask for this element *)
+  let content_model_mask =
+    match Hashtbl.find_opt content_model_violation_mask name with
+    | Some m -> m
+    | None -> 0
+  in
+
   (* Add interactive element restrictions if applicable *)
   let mask =
     if is_interactive_element name attrs then
···
         | "object" when has_attr attrs "usemap" -> Some "usemap"
         | _ -> None
       in
+      (* Find the transparent parent (like canvas) if any *)
+      let transparent_parent = find_nearest_transparent_parent state in
       (* Find which ancestors are violated *)
       Array.iteri (fun i ancestor ->
         let bit = 1 lsl i in
-        if (mask_hit land bit) <> 0 then
-          Message_collector.add_typed collector
-            (Error_code.Element_must_not_be_descendant {
-              element = name;
-              attr;
-              ancestor
-            })
+        if (mask_hit land bit) <> 0 then begin
+          (* Check if this is a content model violation or a nesting violation *)
+          if (content_model_mask land bit) <> 0 then begin
+            (* Content model violation: use "not allowed as child" format *)
+            (* If there's a transparent parent, use that instead of the ancestor *)
+            let parent = match transparent_parent with
+              | Some p -> p
+              | None -> ancestor
+            in
+            Message_collector.add_typed collector
+              (Error_code.Element_not_allowed_as_child {
+                child = name;
+                parent
+              })
+          end else
+            (* Nesting violation: use "must not be descendant" format *)
+            Message_collector.add_typed collector
+              (Error_code.Element_must_not_be_descendant {
+                element = name;
+                attr;
+                ancestor
+              })
+        end
       ) special_ancestors
     end
   end
···
           })
   | _ -> ()
 
+(** Check for metadata-only elements appearing outside valid contexts.
+    style element is only valid in head or in noscript (in head). *)
+let check_metadata_element_context state name collector =
+  match name with
+  | "style" ->
+      (* style is only valid inside head or noscript *)
+      begin match state.stack with
+      | parent :: _ when parent.name = "head" -> ()  (* valid *)
+      | parent :: _ when parent.name = "noscript" -> ()  (* valid in noscript in head *)
+      | parent :: _ ->
+          (* style inside any other element is not allowed *)
+          Message_collector.add_typed collector
+            (Error_code.Element_not_allowed_as_child {
+              child = "style";
+              parent = parent.name
+            })
+      | [] -> ()  (* at root level, would be caught elsewhere *)
+      end
+  | _ -> ()
+
 let start_element state ~name ~namespace ~attrs collector =
   (* Only check HTML elements, not SVG or MathML *)
   match namespace with
···
       (* Check for nesting violations *)
       check_nesting state name attrs collector;
       check_required_ancestors state name collector;
+      check_metadata_element_context state name collector;
 
       (* Update ancestor mask if this is a special ancestor *)
       let new_mask = state.ancestor_mask in
···
       in
 
       (* Push onto stack *)
-      let node = { ancestor_mask = state.ancestor_mask; _name = name } in
+      let is_transparent = List.mem name transparent_elements in
+      let node = { ancestor_mask = state.ancestor_mask; name; is_transparent } in
       state.stack <- node :: state.stack;
       state.ancestor_mask <- new_mask
 

lib/html5_checker/semantic/obsolete_checker.ml

···
   tbl
 
 (** Checker state *)
-type state = unit
+type state = {
+  mutable in_head : bool;
+}
 
-let create () = ()
+let create () = { in_head = false }
 
-let reset _state = ()
+let reset state = state.in_head <- false
 
-let start_element _state ~name ~namespace ~attrs collector =
+let start_element state ~name ~namespace ~attrs collector =
   (* Only check HTML elements (no namespace or explicit HTML namespace) *)
   let is_html = match namespace with
     | None -> true
···
   else begin
     let name_lower = String.lowercase_ascii name in
 
+    (* Track head context *)
+    if name_lower = "head" then state.in_head <- true;
+
     (* Check for obsolete element *)
     (match Hashtbl.find_opt obsolete_elements name_lower with
     | None -> ()
···
     List.iter (fun (attr_name, _attr_value) ->
       let attr_lower = String.lowercase_ascii attr_name in
 
-      (* Check specific obsolete attributes for this element *)
-      (match Hashtbl.find_opt obsolete_attributes attr_lower with
-      | None -> ()
-      | Some element_map ->
-          (match Hashtbl.find_opt element_map name_lower with
-          | None -> ()
-          | Some suggestion ->
-              Message_collector.add_typed collector
-                (Error_code.Obsolete_attr { element = name; attr = attr_name; suggestion = Some suggestion })));
-
-      (* Check obsolete style attributes *)
-      (match Hashtbl.find_opt obsolete_style_attrs attr_lower with
-      | None -> ()
-      | Some elements ->
-          if List.mem name_lower elements then
-            Message_collector.add_typed collector
-              (Error_code.Obsolete_attr { element = name; attr = attr_name; suggestion = Some "Use CSS instead." }));
-
-      (* Check obsolete global attributes *)
-      (match Hashtbl.find_opt obsolete_global_attrs attr_lower with
-      | None -> ()
-      | Some suggestion ->
-          (* Global attributes use a different format - just "The X attribute is obsolete. Y" *)
+      (* Special handling for scoped attribute on style *)
+      if attr_lower = "scoped" && name_lower = "style" then begin
+        (* Only report if style is in head (correct context) - otherwise the content model
+           error from nesting_checker takes precedence *)
+        if state.in_head then
           Message_collector.add_error collector
-            ~message:(Printf.sprintf "The %s attribute is obsolete. %s" (Error_code.q attr_name) suggestion)
-            ~code:"obsolete-global-attribute"
+            ~message:(Printf.sprintf "Attribute %s not allowed on element %s at this point."
+              (Error_code.q attr_name) (Error_code.q name))
+            ~code:"disallowed-attribute"
             ~element:name
             ~attribute:attr_name
-            ())
+            ()
+      end else begin
+        (* Check specific obsolete attributes for this element *)
+        (match Hashtbl.find_opt obsolete_attributes attr_lower with
+        | None -> ()
+        | Some element_map ->
+            (match Hashtbl.find_opt element_map name_lower with
+            | None -> ()
+            | Some suggestion ->
+                Message_collector.add_typed collector
+                  (Error_code.Obsolete_attr { element = name; attr = attr_name; suggestion = Some suggestion })));
+
+        (* Check obsolete style attributes *)
+        (match Hashtbl.find_opt obsolete_style_attrs attr_lower with
+        | None -> ()
+        | Some elements ->
+            if List.mem name_lower elements then
+              Message_collector.add_typed collector
+                (Error_code.Obsolete_attr { element = name; attr = attr_name; suggestion = Some "Use CSS instead." }));
+
+        (* Check obsolete global attributes *)
+        (match Hashtbl.find_opt obsolete_global_attrs attr_lower with
+        | None -> ()
+        | Some suggestion ->
+            (* Global attributes use a different format - just "The X attribute is obsolete. Y" *)
+            Message_collector.add_error collector
+              ~message:(Printf.sprintf "The %s attribute is obsolete. %s" (Error_code.q attr_name) suggestion)
+              ~code:"obsolete-global-attribute"
+              ~element:name
+              ~attribute:attr_name
+              ())
+      end
     ) attrs
   end
 
-let end_element _state ~name:_ ~namespace:_ _collector = ()
+let end_element state ~name ~namespace:_ _collector =
+  let name_lower = String.lowercase_ascii name in
+  if name_lower = "head" then state.in_head <- false
 
 let characters _state _text _collector = ()
 

lib/html5_checker/semantic/required_attr_checker.ml

···
     (* Valid values: empty string, auto, manual, hint *)
     if value_lower <> "" && value_lower <> "auto" && value_lower <> "manual" && value_lower <> "hint" then
       Message_collector.add_typed collector
-        (Error_code.Bad_attr_value {
-          element = element_name;
-          attr = "popover";
-          value;
-          reason = "Must be a valid popover state (auto, manual, or hint)."
+        (Error_code.Bad_attr_value_generic {
+          message = Printf.sprintf "Bad value %s for attribute %s on element %s."
+            (Error_code.q value) (Error_code.q "popover") (Error_code.q element_name)
         })
   | None -> ()
 

lib/html5_checker/specialized/aria_checker.ml

···
       | _ -> ()
       end;
 
-      (* Validate explicit roles *)
-      List.iter (fun role ->
-        (* Check if role is valid *)
-        if not (Hashtbl.mem valid_aria_roles role) then
+      (* Validate explicit roles - report full attribute value if any role is invalid *)
+      let has_invalid_role = List.exists (fun role ->
+        not (Hashtbl.mem valid_aria_roles role)
+      ) explicit_roles in
+      if has_invalid_role then begin
+        match role_attr with
+        | Some role_value ->
           Message_collector.add_error collector
             ~message:(Printf.sprintf
               "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9crole\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d."
-              role name)
+              role_value name)
             ~code:"bad-role"
             ~element:name
             ~attribute:"role"
-            ();
+            ()
+        | None -> ()
+      end;
 
+      List.iter (fun role ->
         (* Check if role cannot be named *)
         if Hashtbl.mem roles_which_cannot_be_named role && has_accessible_name then
           Message_collector.add_error collector

lib/html5_checker/specialized/datetime_checker.ml

···
 let validate_date s =
   let pattern = Str.regexp "^\\([0-9]+\\)-\\([0-9][0-9]\\)-\\([0-9][0-9]\\)$" in
   if not (Str.string_match pattern s 0) then
-    (false, Some "Date must be in YYYY-MM-DD format")
+    (false, Some "The literal did not satisfy the date format")
   else
     let year_s = Str.matched_group 1 s in
     let month_s = Str.matched_group 2 s in
     let day_s = Str.matched_group 3 s in
     if String.length year_s < 4 then
-      (false, Some "Year must be at least 4 digits")
+      (false, Some "The literal did not satisfy the date format")
     else
       match (parse_int year_s, parse_int month_s, parse_int day_s) with
       | None, _, _ | _, None, _ | _, _, None ->
         (false, Some "Invalid year, month or day")
       | Some year, Some month, Some day ->
         if year < 1 then (false, Some "Year cannot be less than 1")
-        else if month < 1 || month > 12 then (false, Some "Month out of range")
+        else if month = 0 then (false, Some "Month cannot be less than 1")
+        else if month > 12 then (false, Some "Month cannot be greater than 12")
         else if day < 1 then (false, Some "Day cannot be less than 1")
         else
           let max_day = max_day_for_month year month in
···
 let validate_time s =
   let pattern = Str.regexp "^\\([0-9][0-9]\\):\\([0-9][0-9]\\)\\(:\\([0-9][0-9]\\)\\(\\.\\([0-9]+\\)\\)?\\)?$" in
   if not (Str.string_match pattern s 0) then
-    (false, Some "Time must be in HH:MM format")
+    (false, None)  (* Format error - return None so caller uses generic message *)
   else
     let hour_s = Str.matched_group 1 s in
     let minute_s = Str.matched_group 2 s in
     match (parse_int hour_s, parse_int minute_s) with
     | None, _ | _, None -> (false, Some "Invalid hour or minute")
     | Some hour, Some minute ->
-      if hour > 23 then (false, Some "Hour out of range")
-      else if minute > 59 then (false, Some "Minute out of range")
+      if hour > 23 then (false, Some "Hour cannot be greater than 23")
+      else if minute > 59 then (false, Some "Minute cannot be greater than 59")
       else
         let second_s = try Some (Str.matched_group 4 s) with Not_found -> None in
         match second_s with
···
           match parse_int sec_s with
           | None -> (false, Some "Invalid seconds")
           | Some sec ->
-            if sec > 59 then (false, Some "Second out of range")
+            if sec > 59 then (false, Some "Second cannot be greater than 59")
             else
               (* Check milliseconds if present *)
               let millis_s = try Some (Str.matched_group 6 s) with Not_found -> None in
···
   else
     let year_s = Str.matched_group 1 s in
     if String.length year_s < 4 then
-      (false, Some "Year must be at least 4 digits")
+      (false, Some "The literal did not satisfy the date format")
     else
       match parse_int year_s with
       | None -> (false, Some "Invalid year")
···
     let year_s = Str.matched_group 1 s in
     let month_s = Str.matched_group 2 s in
     if String.length year_s < 4 then
-      (false, Some "Year must be at least 4 digits")
+      (false, Some "The literal did not satisfy the date format")
     else
       match (parse_int year_s, parse_int month_s) with
       | None, _ | _, None -> (false, Some "Invalid year or month")
···
     let year_s = Str.matched_group 1 s in
     let week_s = Str.matched_group 2 s in
     if String.length year_s < 4 then
-      (false, Some "Year must be at least 4 digits")
+      (false, Some "The literal did not satisfy the date format")
     else
       match (parse_int year_s, parse_int week_s) with
       | None, _ | _, None -> (false, Some "Invalid year or week")
···
       (false, "+")
   in
   if not matched then
-    TzError "Invalid timezone offset"
+    TzError "The literal did not satisfy the datetime with timezone format"
   else
     let hour_s = Str.matched_group 2 s in
     let minute_s = Str.matched_group 3 s in
     match (parse_int hour_s, parse_int minute_s) with
     | None, _ | _, None -> TzError "Invalid timezone"
     | Some hour, Some minute ->
-      if hour > 23 || minute > 59 then TzError "Timezone offset out of range"
+      if hour > 23 then TzError "Hours out of range in time zone designator"
+      else if minute > 59 then TzError "Minutes out of range in time zone designator"
       else begin
         (* Check for unusual but valid offsets *)
         let unusual_range =
···
     let time_and_tz = String.sub s (pos + 1) (String.length s - pos - 1) in
     (* Validate date *)
     match validate_date date_part with
-    | (false, reason) ->
-      DtError (match reason with Some r -> r | None -> "Invalid date")
+    | (false, _) ->
+      DtError "The literal did not satisfy the datetime with timezone format"
     | (true, _) ->
       let date_old = has_old_year date_part in
       (* Check if ends with Z *)
       if String.length time_and_tz > 0 && time_and_tz.[String.length time_and_tz - 1] = 'Z' then begin
         let time_part = String.sub time_and_tz 0 (String.length time_and_tz - 1) in
         match validate_time time_part with
-        | (false, _) -> DtError "The literal did not satisfy the datetime with timezone format"
+        | (false, Some reason) -> DtError reason
+        | (false, None) -> DtError "The literal did not satisfy the datetime with timezone format"
         | (true, _) ->
           if date_old then DtWarning "Year may be mistyped"
           else DtOk
···
           let time_part = String.sub time_and_tz 0 tp in
           let tz_part = String.sub time_and_tz tp (String.length time_and_tz - tp) in
           match validate_time time_part with
-          | (false, _) -> DtError "The literal did not satisfy the datetime with timezone format"
+          | (false, Some reason) -> DtError reason
+          | (false, None) -> DtError "The literal did not satisfy the datetime with timezone format"
           | (true, _) ->
             match validate_timezone_offset tz_part with
-            | TzError _ -> DtError "The literal did not satisfy the datetime with timezone format"
+            | TzError e -> DtError e
             | TzWarning w ->
               DtWarning w
             | TzOk ->
···
           | Some e -> Printf.sprintf "Bad date: %s." e
           | None -> "Bad date: The literal did not satisfy the date format."
         in
-        Error (Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: %s %s"
-          value attr_name element_name tz_msg date_msg)
+        (* Order depends on error type. The Nu validator has specific patterns:
+           - Time hour/minute errors (not timezone) -> datetime first
+           - Timezone hours error -> datetime first
+           - Timezone minutes error -> date first
+           - Time fraction error -> date first
+           - Date "less than" error -> date first
+           - Date "greater than" error -> datetime first
+           - Generic errors both sides -> datetime first *)
+        let is_generic_tz = tz_error = "The literal did not satisfy the datetime with timezone format" in
+        let is_tz_hours_error = String.length tz_error >= 5 && String.sub tz_error 0 5 = "Hours" in
+        let is_tz_minutes_error = String.length tz_error >= 7 && String.sub tz_error 0 7 = "Minutes" in
+        let is_time_minute_or_hour_error =
+          (try ignore (Str.search_forward (Str.regexp "Minute cannot\\|Hour cannot") tz_error 0); true with Not_found -> false)
+        in
+        let is_fraction_error = try ignore (Str.search_forward (Str.regexp "fraction") tz_error 0); true with Not_found -> false in
+        let is_month_less_than_error = match date_error with
+          | Some e -> (try ignore (Str.search_forward (Str.regexp "Month cannot be less than") e 0); true with Not_found -> false)
+          | None -> false
+        in
+        (* Datetime first for: generic tz, tz hours error, time minute/hour errors, year errors
+           Date first for: "Month cannot be less than" date error, tz minutes error, fraction error *)
+        if is_month_less_than_error then
+          Error (Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: %s %s"
+            value attr_name element_name date_msg tz_msg)
+        else if is_tz_minutes_error || is_fraction_error then
+          Error (Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: %s %s"
+            value attr_name element_name date_msg tz_msg)
+        else if is_tz_hours_error || is_time_minute_or_hour_error || is_generic_tz then
+          Error (Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: %s %s"
+            value attr_name element_name tz_msg date_msg)
+        else
+          Error (Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: %s %s"
+            value attr_name element_name tz_msg date_msg)
       end
 
 (** Checker state *)

lib/html5_checker/specialized/dl_checker.ml

···
   mutable contains_div : bool;
   mutable contains_dt_dd : bool;
   mutable dd_before_dt_error_reported : bool;  (* Track if we've reported dd-before-dt error *)
+  mutable has_template : bool;    (* Track if template element was seen inside dl *)
 }
 
 type div_context = {
···
   else begin
     match name_lower with
     | "template" ->
-      state.in_template <- state.in_template + 1
+      state.in_template <- state.in_template + 1;
+      (* Track if template is direct child of dl *)
+      begin match current_dl state with
+      | Some dl_ctx when state.div_in_dl_stack = [] ->
+        dl_ctx.has_template <- true
+      | _ -> ()
+      end
 
     | "dl" when state.in_template = 0 ->
-      (* Check for nested dl - only error if direct child (not inside dt/dd) *)
-      begin match current_dl state with
-      | Some _ when state.in_dt_dd = 0 && state.div_in_dl_stack = [] ->
+      (* Check for nested dl - error if direct child of dl OR inside div-in-dl *)
+      begin match current_div state with
+      | Some _ ->
+        (* dl inside div-in-dl is not allowed *)
         Message_collector.add_error collector
-          ~message:"Element \xe2\x80\x9cdl\xe2\x80\x9d not allowed as child of element \xe2\x80\x9cdl\xe2\x80\x9d in this context. (Suppressing further errors from this subtree.)"
+          ~message:"Element \xe2\x80\x9cdl\xe2\x80\x9d not allowed as child of element \xe2\x80\x9cdiv\xe2\x80\x9d in this context. (Suppressing further errors from this subtree.)"
           ~code:"disallowed-child"
           ~element:"dl" ()
-      | _ -> ()
+      | None ->
+        match current_dl state with
+        | Some _ when state.in_dt_dd = 0 ->
+          Message_collector.add_error collector
+            ~message:"Element \xe2\x80\x9cdl\xe2\x80\x9d not allowed as child of element \xe2\x80\x9cdl\xe2\x80\x9d in this context. (Suppressing further errors from this subtree.)"
+            ~code:"disallowed-child"
+            ~element:"dl" ()
+        | _ -> ()
       end;
       let ctx = {
         has_dt = false;
···
         contains_div = false;
         contains_dt_dd = false;
         dd_before_dt_error_reported = false;
+        has_template = false;
       } in
       state.dl_stack <- ctx :: state.dl_stack
 
···
       state.in_dt_dd <- state.in_dt_dd + 1;
       begin match current_div state with
       | Some div_ctx ->
-        div_ctx.has_dt <- true;
-        (* If we've seen dd, this dt starts a new group *)
+        (* If we've already seen dd, this dt starts a new group - which is not allowed *)
         if div_ctx.in_dd_part then begin
+          Message_collector.add_error collector
+            ~message:"Element \xe2\x80\x9cdt\xe2\x80\x9d not allowed as child of element \xe2\x80\x9cdiv\xe2\x80\x9d in this context. (Suppressing further errors from this subtree.)"
+            ~code:"disallowed-child"
+            ~element:"dt" ();
           div_ctx.group_count <- div_ctx.group_count + 1;
           div_ctx.in_dd_part <- false
-        end
+        end;
+        div_ctx.has_dt <- true
       | None ->
         match current_dl state with
         | Some dl_ctx ->
···
               ~message:"Element \xe2\x80\x9cdl\xe2\x80\x9d is missing a required child element."
               ~code:"missing-required-child"
               ~element:"dl" ()
-          else if not ctx.has_dd then
-            Message_collector.add_error collector
-              ~message:"Element \xe2\x80\x9cdl\xe2\x80\x9d is missing required child element \xe2\x80\x9cdd\xe2\x80\x9d."
-              ~code:"missing-required-child"
-              ~element:"dl" ()
+          else if not ctx.has_dd then begin
+            (* If template is present in dl, use list format; otherwise use simple format *)
+            if ctx.has_template then
+              Message_collector.add_error collector
+                ~message:"Element \xe2\x80\x9cdl\xe2\x80\x9d is missing one or more of the following child elements: [dd]."
+                ~code:"missing-required-child"
+                ~element:"dl" ()
+            else
+              Message_collector.add_error collector
+                ~message:"Element \xe2\x80\x9cdl\xe2\x80\x9d is missing required child element \xe2\x80\x9cdd\xe2\x80\x9d."
+                ~code:"missing-required-child"
+                ~element:"dl" ()
+          end
           else if ctx.last_was_dt then
-            (* Ended with dt, missing dd *)
+            (* Ended with dt, missing dd for the last group *)
             Message_collector.add_error collector
               ~message:"Element \xe2\x80\x9cdl\xe2\x80\x9d is missing required child element \xe2\x80\x9cdd\xe2\x80\x9d."
               ~code:"missing-required-child"
···
             ~message:"Element \xe2\x80\x9cdiv\xe2\x80\x9d is missing required child element \xe2\x80\x9cdd\xe2\x80\x9d."
             ~code:"missing-required-child"
             ~element:"div" ()
-        else if div_ctx.group_count > 1 then
-          (* Multiple name-value groups in a single div is not allowed *)
-          Message_collector.add_error collector
-            ~message:"A child \xe2\x80\x9cdiv\xe2\x80\x9d element of a \xe2\x80\x9cdl\xe2\x80\x9d element must contain only one name-value group."
-            ~code:"multiple-groups-in-div"
-            ~element:"div" ()
+        (* Multiple groups error is now reported inline when dt appears after dd *)
       | [] -> ()
       end
 
···
   else begin
     let trimmed = String.trim text in
     if trimmed <> "" then begin
-      (* Check for text directly in dl *)
-      match current_dl state with
-      | Some _ when state.div_in_dl_stack = [] ->
+      (* Check for text directly in dl or div-in-dl *)
+      match current_div state with
+      | Some _ ->
+        (* Text in div within dl is not allowed *)
         Message_collector.add_error collector
-          ~message:"Text not allowed in element \xe2\x80\x9cdl\xe2\x80\x9d in this context."
+          ~message:"Text not allowed in element \xe2\x80\x9cdiv\xe2\x80\x9d in this context."
           ~code:"text-not-allowed"
-          ~element:"dl" ()
-      | _ -> ()
+          ~element:"div" ()
+      | None ->
+        match current_dl state with
+        | Some _ ->
+          Message_collector.add_error collector
+            ~message:"Text not allowed in element \xe2\x80\x9cdl\xe2\x80\x9d in this context."
+            ~code:"text-not-allowed"
+            ~element:"dl" ()
+        | None -> ()
     end
   end
 

lib/html5_checker/specialized/microdata_checker.ml

···
   String.contains s ':'
 
 (** Validate that a URL is a valid absolute URL for itemtype/itemid.
-    Uses the comprehensive URL validation from Url_checker. *)
-let validate_microdata_url url element attr_name =
+    Uses the comprehensive URL validation from Url_checker.
+    original_value is the full attribute value (for error messages when split by whitespace) *)
+let validate_microdata_url url element attr_name original_value =
   let url_trimmed = String.trim url in
   if String.length url_trimmed = 0 then
     Some (Printf.sprintf
       "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad absolute URL: Must be non-empty."
-      url attr_name element)
+      original_value attr_name element)
   else
     (* First check if it has a scheme (required for absolute URL) *)
     match Url_checker.extract_scheme url_trimmed with
     | None ->
       Some (Printf.sprintf
         "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad absolute URL: The string \xe2\x80\x9c%s\xe2\x80\x9d is not an absolute URL."
-        url attr_name element url)
+        original_value attr_name element url)
     | Some _ ->
       (* Has a scheme - do comprehensive URL validation *)
       match Url_checker.validate_url url element attr_name with
···
       | Some error_msg ->
         (* Replace "Bad URL:" with "Bad absolute URL:" for microdata *)
         let error_msg = Str.global_replace (Str.regexp "Bad URL:") "Bad absolute URL:" error_msg in
+        (* Also replace the URL value with the original value in case they differ *)
+        (* Escape backslashes in replacement string for Str.global_replace *)
+        let escaped_original = Str.global_replace (Str.regexp "\\\\") "\\\\\\\\" original_value in
+        let error_msg = Str.global_replace
+          (Str.regexp_string (Printf.sprintf "\xe2\x80\x9c%s\xe2\x80\x9d for attribute" url))
+          (Printf.sprintf "\xe2\x80\x9c%s\xe2\x80\x9d for attribute" escaped_original)
+          error_msg in
         Some error_msg
 
 (** Check if itemprop value is valid. *)
···
             ()
         else
           List.iter (fun url ->
-            match validate_microdata_url url element "itemtype" with
+            match validate_microdata_url url element "itemtype" itemtype with
             | None -> ()
             | Some error_msg ->
               Message_collector.add_error collector

lib/html5_checker/specialized/picture_checker.ml

···
   mutable has_source_after_img : bool;
   mutable has_always_matching_source : bool;  (* source without media/type *)
   mutable source_after_always_matching : bool; (* source after always-matching source *)
+  mutable always_matching_is_media_all : bool; (* true if caused by media="all" *)
+  mutable always_matching_is_media_empty : bool; (* true if caused by media="" or whitespace *)
   mutable parent_stack : string list; (* track parent elements *)
 }
 
···
   has_source_after_img = false;
   has_always_matching_source = false;
   source_after_always_matching = false;
+  always_matching_is_media_all = false;
+  always_matching_is_media_empty = false;
   parent_stack = [];
 }
 
···
   state.parent_stack <- [];
   state.has_source_after_img <- false;
   state.has_always_matching_source <- false;
-  state.source_after_always_matching <- false
+  state.source_after_always_matching <- false;
+  state.always_matching_is_media_all <- false;
+  state.always_matching_is_media_empty <- false
 
 (** Check if an attribute list contains a specific attribute. *)
 let has_attr name attrs =
···
         if String.lowercase_ascii attr_name = "media" then Some v else None
       ) attrs in
       let has_type = has_attr "type" attrs in
+      let is_media_all = match media_value with
+        | Some v -> String.lowercase_ascii (String.trim v) = "all"
+        | None -> false
+      in
+      let is_media_empty = match media_value with
+        | Some v -> String.trim v = ""
+        | None -> false
+      in
       let is_always_matching = match media_value with
         | None -> not has_type  (* no media, check if no type either *)
         | Some v ->
           let trimmed = String.trim v in
           trimmed = "" || String.lowercase_ascii trimmed = "all"
       in
-      if is_always_matching then
-        state.has_always_matching_source <- true
+      if is_always_matching then begin
+        state.has_always_matching_source <- true;
+        if is_media_all then
+          state.always_matching_is_media_all <- true
+        else if is_media_empty then
+          state.always_matching_is_media_empty <- true
+      end
 
     | "img" when state.in_picture && state.picture_depth = 1 ->
       check_img_attrs attrs collector;
···
       if img_count > 1 then
         report_disallowed_child "picture" "img" collector;
       (* Check if always-matching source is followed by img with srcset *)
-      if state.has_always_matching_source && has_attr "srcset" attrs then
-        Message_collector.add_error collector
-          ~message:"A \xe2\x80\x9csource\xe2\x80\x9d element that has a following sibling \xe2\x80\x9csource\xe2\x80\x9d element or \xe2\x80\x9cimg\xe2\x80\x9d element with a \xe2\x80\x9csrcset\xe2\x80\x9d attribute must have a \xe2\x80\x9cmedia\xe2\x80\x9d attribute and/or \xe2\x80\x9ctype\xe2\x80\x9d attribute."
-          ~code:"always-matching-source-followed-by-srcset"
-          ~element:"source" ()
+      if state.has_always_matching_source && has_attr "srcset" attrs then begin
+        if state.always_matching_is_media_all then
+          Message_collector.add_error collector
+            ~message:"Value of \xe2\x80\x9cmedia\xe2\x80\x9d attribute here must not be \xe2\x80\x9call\xe2\x80\x9d."
+            ~code:"media-all-not-allowed"
+            ~element:"source"
+            ~attribute:"media" ()
+        else if state.always_matching_is_media_empty then
+          Message_collector.add_error collector
+            ~message:"Value of \xe2\x80\x9cmedia\xe2\x80\x9d attribute here must not be empty."
+            ~code:"media-empty-not-allowed"
+            ~element:"source"
+            ~attribute:"media" ()
+        else
+          Message_collector.add_error collector
+            ~message:"A \xe2\x80\x9csource\xe2\x80\x9d element that has a following sibling \xe2\x80\x9csource\xe2\x80\x9d element or \xe2\x80\x9cimg\xe2\x80\x9d element with a \xe2\x80\x9csrcset\xe2\x80\x9d attribute must have a \xe2\x80\x9cmedia\xe2\x80\x9d attribute and/or \xe2\x80\x9ctype\xe2\x80\x9d attribute."
+            ~code:"always-matching-source-followed-by-srcset"
+            ~element:"source" ()
+      end
 
     | "script" when state.in_picture && state.picture_depth = 1 ->
       state.children_in_picture <- "script" :: state.children_in_picture
···
       if state.has_source_after_img then
         report_disallowed_child "picture" "source" collector;
       (* Check for source after always-matching source *)
-      if state.source_after_always_matching then
-        Message_collector.add_error collector
-          ~message:"A \xe2\x80\x9csource\xe2\x80\x9d element that matches all media types cannot be followed by another \xe2\x80\x9csource\xe2\x80\x9d element."
-          ~code:"always-matching-source"
-          ~element:"source" ();
+      if state.source_after_always_matching then begin
+        if state.always_matching_is_media_all then
+          Message_collector.add_error collector
+            ~message:"Value of \xe2\x80\x9cmedia\xe2\x80\x9d attribute here must not be \xe2\x80\x9call\xe2\x80\x9d."
+            ~code:"media-all-not-allowed"
+            ~element:"source"
+            ~attribute:"media" ()
+        else if state.always_matching_is_media_empty then
+          Message_collector.add_error collector
+            ~message:"Value of \xe2\x80\x9cmedia\xe2\x80\x9d attribute here must not be empty."
+            ~code:"media-empty-not-allowed"
+            ~element:"source"
+            ~attribute:"media" ()
+        else
+          Message_collector.add_error collector
+            ~message:"A \xe2\x80\x9csource\xe2\x80\x9d element that has a following sibling \xe2\x80\x9csource\xe2\x80\x9d element or \xe2\x80\x9cimg\xe2\x80\x9d element with a \xe2\x80\x9csrcset\xe2\x80\x9d attribute must have a \xe2\x80\x9cmedia\xe2\x80\x9d attribute and/or \xe2\x80\x9ctype\xe2\x80\x9d attribute."
+            ~code:"always-matching-source"
+            ~element:"source" ()
+      end;
 
       state.in_picture <- false
     end;

lib/html5_checker/specialized/srcset_sizes_checker.ml

···
   Buffer.contents buf
 
 (** Check if a size value has a valid CSS length unit and non-negative value *)
-type size_check_result = Valid | InvalidUnit | NegativeValue | CssCommentInside | BadScientificNotation
+type size_check_result =
+  | Valid
+  | InvalidUnit of string * string  (* (found_unit, context) *)
+  | NegativeValue
+  | CssCommentAfterSign of string * string  (* what was found, context *)
+  | CssCommentBeforeUnit of string * string  (* what was found, context *)
+  | BadScientificNotation
+  | BadCssNumber of char * string   (* (first_char, context) - not starting with digit or minus *)
+
+(** CSS comment error types *)
+type css_comment_error =
+  | NoCommentError
+  | CommentAfterSign of string * string  (* what was found, context *)
+  | CommentBetweenNumberAndUnit of string * string  (* what was found at comment position, context *)
 
 (** Check if CSS comment appears in an invalid position:
     - Between sign and number (+/**/50vw)
     - Between number and unit (50/**/vw)
     Trailing comments (50vw/**/) are valid. *)
-let has_invalid_css_comment s =
+let check_css_comment_position s =
   let len = String.length s in
   (* Find comment position *)
   let rec find_comment i =
···
     else find_comment (i + 1)
   in
   match find_comment 0 with
-  | None -> false
+  | None -> NoCommentError
   | Some comment_pos ->
     let before = String.sub s 0 comment_pos in
     let trimmed_before = String.trim before in
-    if String.length trimmed_before = 0 then false  (* Leading comment is OK *)
+    if String.length trimmed_before = 0 then NoCommentError  (* Leading comment is OK *)
     else begin
       (* Find end of comment *)
       let rec find_end i =
···
       let end_pos = find_end (comment_pos + 2) in
       let after = if end_pos < len then String.sub s end_pos (len - end_pos) else "" in
       let trimmed_after = String.trim (strip_css_comments after) in
-      if trimmed_after = "" then false  (* Trailing comment is OK *)
+      if trimmed_after = "" then NoCommentError  (* Trailing comment is OK *)
       else begin
         (* Comment is in the middle - check if it breaks a number/unit combo *)
         let last = trimmed_before.[String.length trimmed_before - 1] in
-        (* Invalid if comment appears after +/- or after a digit (before more non-whitespace) *)
-        (last >= '0' && last <= '9') || last = '+' || last = '-' || last = '.'
+        (* What's at the comment position? Just show "/" *)
+        let slash = "/" in
+        (* Invalid if comment appears after +/- *)
+        if last = '+' || last = '-' then
+          CommentAfterSign (trimmed_before ^ slash, s)
+        (* Invalid if comment appears after digit (before more content) *)
+        else if (last >= '0' && last <= '9') || last = '.' then
+          CommentBetweenNumberAndUnit (slash ^ trimmed_after, s)
+        else
+          NoCommentError
       end
     end
+
+(** For backward compatibility *)
+let has_invalid_css_comment s =
+  match check_css_comment_position s with
+  | NoCommentError -> false
+  | _ -> true
 
 (** Check if scientific notation has invalid exponent (like 1e+1.5 - decimal in exponent) *)
 let has_invalid_scientific_notation s =
···
     in
     String.contains after_sign '.'
 
+(** Extract unit from a size value like "10px" -> "px", "100vw" -> "vw", "50%" -> "%"
+    Returns the unit with original case preserved *)
+let extract_unit s =
+  let trimmed = String.trim s in
+  let len = String.length trimmed in
+  if len = 0 then ""
+  (* Check for % at the end *)
+  else if trimmed.[len - 1] = '%' then "%"
+  else begin
+    let lower = String.lowercase_ascii trimmed in
+    (* Try to find a unit at the end (letters only) *)
+    let rec find_unit_length i =
+      if i < 0 then 0
+      else if lower.[i] >= 'a' && lower.[i] <= 'z' then find_unit_length (i - 1)
+      else i + 1
+    in
+    let start = find_unit_length (len - 1) in
+    if start < len then
+      (* Return the unit from the original string (preserving case) *)
+      String.sub trimmed start (len - start)
+    else ""
+  end
+
 let check_size_value size_value =
   let trimmed = String.trim size_value in
-  if trimmed = "" then InvalidUnit
-  (* Check for CSS comments inside numbers - this is invalid *)
-  else if has_invalid_css_comment trimmed then CssCommentInside
+  if trimmed = "" then InvalidUnit ("", trimmed)
   else begin
+    (* Check for CSS comments inside numbers - this is invalid *)
+    match check_css_comment_position trimmed with
+    | CommentAfterSign (found, ctx) -> CssCommentAfterSign (found, ctx)
+    | CommentBetweenNumberAndUnit (found, ctx) -> CssCommentBeforeUnit (found, ctx)
+    | NoCommentError ->
     (* Strip valid leading/trailing CSS comments for further checks *)
     let value_no_comments = String.trim (strip_css_comments trimmed) in
     (* Check for invalid scientific notation like 1e+1.5px *)
     if has_invalid_scientific_notation value_no_comments then BadScientificNotation
     (* "auto" is only valid with lazy loading, which requires checking the element context.
        For general validation, treat "auto" alone as invalid in sizes. *)
-    else if String.lowercase_ascii value_no_comments = "auto" then InvalidUnit
-    else if value_no_comments = "" then InvalidUnit
+    else if String.lowercase_ascii value_no_comments = "auto" then
+      BadCssNumber (value_no_comments.[0], trimmed)
+    else if value_no_comments = "" then InvalidUnit ("", trimmed)
     else begin
       let lower = String.lowercase_ascii value_no_comments in
-      (* Check for invalid units first *)
-      let has_invalid = List.exists (fun unit ->
-        let len = String.length unit in
-        String.length lower > len &&
-        String.sub lower (String.length lower - len) len = unit
-      ) invalid_size_units in
-      if has_invalid then InvalidUnit
+      (* Check for calc() or other CSS functions first - these are always valid *)
+      if String.contains value_no_comments '(' then Valid
       else begin
-        (* Check for valid CSS length units *)
-        let has_valid_unit = List.exists (fun unit ->
-          let len = String.length unit in
-          String.length lower > len &&
-          String.sub lower (String.length lower - len) len = unit
-        ) valid_length_units in
-        if has_valid_unit then begin
-          (* Check if it's negative (starts with - but not -0) *)
-          if String.length value_no_comments > 0 && value_no_comments.[0] = '-' then begin
-            (* Check if it's -0 which is valid *)
-            let after_minus = String.sub value_no_comments 1 (String.length value_no_comments - 1) in
-            try
-              let num_str = Str.global_replace (Str.regexp "[a-zA-Z]+$") "" after_minus in
-              let f = float_of_string num_str in
-              if f = 0.0 then Valid else NegativeValue
-            with _ -> NegativeValue
-          end else
-            Valid
-        end
-        (* Could be calc() or other CSS functions - allow those *)
-        else if String.contains value_no_comments '(' then Valid
+        (* Check if the value starts with a digit, minus, or plus sign *)
+        let first_char = value_no_comments.[0] in
+        let starts_with_number =
+          (first_char >= '0' && first_char <= '9') ||
+          first_char = '-' ||
+          first_char = '+' ||
+          first_char = '.' (* decimal point like .5px *)
+        in
+        if not starts_with_number then
+          (* Not a valid CSS number token - doesn't start with digit or sign *)
+          BadCssNumber (first_char, trimmed)
         else begin
-          (* Check if it's a zero value (0, -0, +0) - these are valid without units *)
-          let stripped =
-            let s = value_no_comments in
-            let s = if String.length s > 0 && (s.[0] = '+' || s.[0] = '-') then String.sub s 1 (String.length s - 1) else s in
-            s
-          in
-          (* Check if it's zero or a numeric value starting with 0 *)
-          try
-            let f = float_of_string stripped in
-            if f = 0.0 then Valid else InvalidUnit
-          with _ -> InvalidUnit
+          (* Check for invalid units first *)
+          let found_invalid = List.find_opt (fun unit ->
+            let len = String.length unit in
+            String.length lower > len &&
+            String.sub lower (String.length lower - len) len = unit
+          ) invalid_size_units in
+          match found_invalid with
+          | Some _unit -> InvalidUnit (extract_unit value_no_comments, trimmed)
+          | None ->
+            (* Check for valid CSS length units *)
+            let has_valid_unit = List.exists (fun unit ->
+              let len = String.length unit in
+              String.length lower > len &&
+              String.sub lower (String.length lower - len) len = unit
+            ) valid_length_units in
+            if has_valid_unit then begin
+              (* Check if it's negative (starts with - but not -0) *)
+              if String.length value_no_comments > 0 && value_no_comments.[0] = '-' then begin
+                (* Check if it's -0 which is valid *)
+                let after_minus = String.sub value_no_comments 1 (String.length value_no_comments - 1) in
+                try
+                  let num_str = Str.global_replace (Str.regexp "[a-zA-Z]+$") "" after_minus in
+                  let f = float_of_string num_str in
+                  if f = 0.0 then Valid else NegativeValue
+                with _ -> NegativeValue
+              end else
+                Valid
+            end
+            else begin
+              (* Check if it's a zero value (0, -0, +0) - these are valid without units *)
+              let stripped =
+                let s = value_no_comments in
+                let s = if String.length s > 0 && (s.[0] = '+' || s.[0] = '-') then String.sub s 1 (String.length s - 1) else s in
+                s
+              in
+              (* Check if it's zero or a numeric value starting with 0 *)
+              try
+                let f = float_of_string stripped in
+                if f = 0.0 then Valid else InvalidUnit (extract_unit value_no_comments, trimmed)
+              with _ -> InvalidUnit (extract_unit value_no_comments, trimmed)
+            end
         end
       end
     end
···
 let has_valid_size_unit size_value =
   match check_size_value size_value with
   | Valid -> true
-  | InvalidUnit | NegativeValue | CssCommentInside | BadScientificNotation -> false
+  | InvalidUnit (_, _) | NegativeValue | CssCommentAfterSign (_, _) | CssCommentBeforeUnit (_, _) | BadScientificNotation | BadCssNumber (_, _) -> false
 
 (** Check if a sizes entry has a media condition (starts with '(') *)
 let has_media_condition entry =
···
   if not (has_media_condition trimmed) then
     trimmed
   else begin
-    (* Find matching closing paren, then get the size value after it *)
+    (* Media conditions can have "and", "or", "not" operators connecting
+       multiple parenthesized groups, e.g., "(not (width:500px)) and (width:500px) 500px"
+       We need to skip all media condition parts to find the size value *)
     let len = String.length trimmed in
-    let rec find_close_paren i depth =
+    let rec skip_media_condition i =
       if i >= len then len
-      else match trimmed.[i] with
-        | '(' -> find_close_paren (i + 1) (depth + 1)
-        | ')' -> if depth = 1 then i + 1 else find_close_paren (i + 1) (depth - 1)
-        | _ -> find_close_paren (i + 1) depth
+      else begin
+        let remaining = String.trim (String.sub trimmed i (len - i)) in
+        let remaining_len = String.length remaining in
+        if remaining_len = 0 then len
+        else begin
+          let first_char = remaining.[0] in
+          if first_char = '(' then begin
+            (* Skip this parenthesized group *)
+            let rec find_close_paren j depth =
+              if j >= remaining_len then remaining_len
+              else match remaining.[j] with
+                | '(' -> find_close_paren (j + 1) (depth + 1)
+                | ')' -> if depth = 1 then j + 1 else find_close_paren (j + 1) (depth - 1)
+                | _ -> find_close_paren (j + 1) depth
+            in
+            let after_paren = find_close_paren 0 0 in
+            let new_pos = i + (len - i) - remaining_len + after_paren in
+            skip_media_condition new_pos
+          end
+          else begin
+            (* Check if remaining starts with "and", "or", "not" followed by space or paren *)
+            let lower_remaining = String.lowercase_ascii remaining in
+            if remaining_len >= 4 && String.sub lower_remaining 0 4 = "and " then
+              skip_media_condition (i + (len - i) - remaining_len + 4)
+            else if remaining_len >= 3 && String.sub lower_remaining 0 3 = "or " then
+              skip_media_condition (i + (len - i) - remaining_len + 3)
+            else if remaining_len >= 4 && String.sub lower_remaining 0 4 = "not " then
+              skip_media_condition (i + (len - i) - remaining_len + 4)
+            else if remaining_len >= 4 && String.sub lower_remaining 0 4 = "and(" then
+              skip_media_condition (i + (len - i) - remaining_len + 3)
+            else if remaining_len >= 3 && String.sub lower_remaining 0 3 = "or(" then
+              skip_media_condition (i + (len - i) - remaining_len + 2)
+            else if remaining_len >= 4 && String.sub lower_remaining 0 4 = "not(" then
+              skip_media_condition (i + (len - i) - remaining_len + 3)
+            else
+              (* Found something that's not a media condition part - this is the size value *)
+              i + (len - i) - remaining_len
+          end
+        end
+      end
     in
-    let after_paren = find_close_paren 0 0 in
-    if after_paren >= len then ""
-    else String.trim (String.sub trimmed after_paren (len - after_paren))
+    let size_start = skip_media_condition 0 in
+    if size_start >= len then ""
+    else String.trim (String.sub trimmed size_start (len - size_start))
   end
 
 (** Validate sizes attribute value *)
···
       (* Check for trailing comma *)
       let last_entry = String.trim (List.nth entries (List.length entries - 1)) in
       if List.length entries > 1 && last_entry = "" then begin
+        (* Generate abbreviated context - show last ~25 chars with ellipsis if needed *)
+        let context =
+          if String.length value > 25 then
+            "\xe2\x80\xa6" ^ String.sub value (String.length value - 25) 25
+          else value
+        in
         Message_collector.add_error collector
-          ~message:(Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9csizes\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad source size list: Ends with trailing comma." value element_name)
+          ~message:(Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9csizes\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad source size list: Expected media condition before \xe2\x80\x9c\xe2\x80\x9d at \xe2\x80\x9c%s\xe2\x80\x9d." value element_name context)
           ~code:"bad-sizes-value"
           ~element:element_name ~attribute:"sizes" ();
         false
···
 
         (* Check for default-first pattern: unconditional value before conditional ones *)
         let non_empty_entries = List.filter (fun e -> String.trim e <> "") entries in
-        if List.length non_empty_entries > 1 then begin
-          let first = List.hd non_empty_entries in
-          let rest = List.tl non_empty_entries in
+        (* Filter out entries that have invalid media conditions - they'll be reported separately *)
+        let valid_entries = List.filter (fun e ->
+          has_invalid_media_condition (String.trim e) = None
+        ) non_empty_entries in
+        if List.length valid_entries > 1 then begin
+          let first = List.hd valid_entries in
+          let rest = List.tl valid_entries in
           (* If first entry has no media condition but later ones do, that's invalid *)
           if not (has_media_condition first) && List.exists has_media_condition rest then begin
+            (* Context is the first entry with a comma *)
+            let context = (String.trim first) ^ "," in
             Message_collector.add_error collector
-              ~message:(Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9csizes\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad source size list: Default size must be last." value element_name)
+              ~message:(Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9csizes\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad source size list: Expected media condition before \xe2\x80\x9c\xe2\x80\x9d at \xe2\x80\x9c%s\xe2\x80\x9d." value element_name context)
               ~code:"bad-sizes-value"
               ~element:element_name ~attribute:"sizes" ();
             valid := false
           end;
-          (* Check for multiple consecutive defaults (entries without media conditions) *)
-          let defaults_without_media = List.filter (fun e -> not (has_media_condition e)) non_empty_entries in
-          if List.length defaults_without_media > 1 then begin
-            Message_collector.add_error collector
-              ~message:(Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9csizes\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad source size list: Multiple source sizes without media conditions." value element_name)
-              ~code:"bad-sizes-value"
-              ~element:element_name ~attribute:"sizes" ();
-            valid := false
+          (* Check for multiple entries without media conditions.
+             When the first entry has no media condition, report "Expected media condition"
+             regardless of whether later entries have media conditions or not *)
+          if not (has_media_condition first) && !valid then begin
+            (* Only report if we haven't already reported the default-first error *)
+            if not (List.exists has_media_condition rest) then begin
+              (* Multiple defaults - report as "Expected media condition" *)
+              let context = (String.trim first) ^ "," in
+              Message_collector.add_error collector
+                ~message:(Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9csizes\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad source size list: Expected media condition before \xe2\x80\x9c\xe2\x80\x9d at \xe2\x80\x9c%s\xe2\x80\x9d." value element_name context)
+                ~code:"bad-sizes-value"
+                ~element:element_name ~attribute:"sizes" ();
+              valid := false
+            end
           end
         end;
 
         (* Validate each entry's media condition and size value *)
-        List.iter (fun entry ->
+        let num_entries = List.length entries in
+        List.iteri (fun idx entry ->
           let trimmed = String.trim entry in
           if trimmed <> "" then begin
             (* Check for invalid media condition *)
             (match has_invalid_media_condition trimmed with
              | Some err_msg ->
+               (* Generate context: "entry," with ellipsis if needed *)
+               let context = (String.trim entry) ^ "," in
+               let context =
+                 if String.length context > 25 then
+                   "\xe2\x80\xa6" ^ String.sub context (String.length context - 25) 25
+                 else context
+               in
                Message_collector.add_error collector
-                 ~message:(Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9csizes\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad source size list: %s." value element_name err_msg)
+                 ~message:(Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9csizes\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad source size list: %s at \xe2\x80\x9c%s\xe2\x80\x9d." value element_name err_msg context)
                  ~code:"bad-sizes-value"
                  ~element:element_name ~attribute:"sizes" ();
                valid := false
···
 
             let size_val = extract_size_value trimmed in
             if size_val <> "" then begin
-              match check_size_value size_val with
+              (* Check if there are multiple space-separated words in the size value.
+                 Only the first word should be the size, rest is junk. *)
+              let size_parts = String.split_on_char ' ' size_val |> List.filter (fun s -> s <> "") in
+              let first_size = match size_parts with [] -> size_val | hd :: _ -> hd in
+              let extra_parts = match size_parts with [] -> [] | _ :: tl -> tl in
+
+              (* Check if first word looks like it should have been a media condition
+                 (doesn't start with digit, sign, decimal, '/', or look like a CSS function) *)
+              let first_char = if String.length first_size > 0 then first_size.[0] else 'x' in
+              let has_paren = String.contains size_val '(' in  (* calc(), etc. *)
+              let looks_like_junk_entry =
+                not (has_media_condition trimmed) &&
+                not has_paren &&  (* Allow CSS functions like calc() *)
+                not (first_char = '/') &&  (* Allow leading CSS comments *)
+                not ((first_char >= '0' && first_char <= '9') ||
+                     first_char = '+' || first_char = '-' || first_char = '.')
+              in
+
+              (* If this entry looks like junk and there are multiple entries,
+                 report "Expected media condition" instead of "Bad CSS number".
+                 For single entries with invalid values, fall through to BadCssNumber. *)
+              if looks_like_junk_entry && num_entries > 1 then begin
+                (* Find the context ending with the previous entry *)
+                let prev_entries = List.filter (fun e -> String.trim e <> "" && e <> entry) entries in
+                let context =
+                  if List.length prev_entries > 0 then
+                    let prev_value = String.concat ", " (List.map String.trim prev_entries) ^ "," in
+                    if String.length prev_value > 25 then
+                      "\xe2\x80\xa6" ^ String.sub prev_value (String.length prev_value - 25) 25
+                    else prev_value
+                  else value
+                in
+                Message_collector.add_error collector
+                  ~message:(Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9csizes\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad source size list: Expected media condition before \xe2\x80\x9c\xe2\x80\x9d at \xe2\x80\x9c%s\xe2\x80\x9d." value element_name context)
+                  ~code:"bad-sizes-value"
+                  ~element:element_name ~attribute:"sizes" ();
+                valid := false
+              end
+              (* If there's extra junk after the size, report BadCssNumber error for it *)
+              else if extra_parts <> [] then begin
+                let junk = String.concat " " extra_parts in
+                let last_junk = List.nth extra_parts (List.length extra_parts - 1) in
+                let first_char = if String.length last_junk > 0 then last_junk.[0] else 'x' in
+                (* Context depends on whether this is the last entry:
+                   - For non-last entries: entry with trailing comma, truncated from beginning
+                   - For last entry: full value truncated from beginning (no trailing comma) *)
+                let is_last_entry = idx = num_entries - 1 in
+                let context =
+                  if is_last_entry then begin
+                    (* Last entry: use full value truncated *)
+                    if String.length value > 25 then
+                      "\xe2\x80\xa6" ^ String.sub value (String.length value - 25) 25
+                    else value
+                  end else begin
+                    (* Non-last entry: use entry with comma, truncated *)
+                    let entry_with_comma = trimmed ^ "," in
+                    if String.length entry_with_comma > 25 then
+                      "\xe2\x80\xa6" ^ String.sub entry_with_comma (String.length entry_with_comma - 25) 25
+                    else entry_with_comma
+                  end
+                in
+                let _ = junk in
+                Message_collector.add_error collector
+                  ~message:(Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9csizes\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad source size list: Bad CSS number token: Expected a minus sign or a digit but saw \xe2\x80\x9c%c\xe2\x80\x9d instead at \xe2\x80\x9c%s\xe2\x80\x9d." value element_name first_char context)
+                  ~code:"bad-sizes-value"
+                  ~element:element_name ~attribute:"sizes" ();
+                valid := false
+              end
+              else
+              match check_size_value first_size with
               | Valid -> ()
               | NegativeValue ->
+                let full_context =
+                  if List.length entries > 1 then size_val ^ ","
+                  else size_val
+                in
+                let _ = full_context in
                 Message_collector.add_error collector
-                  ~message:(Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9csizes\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Source size value cannot be negative." value element_name)
+                  ~message:(Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9csizes\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad source size list: Expected positive size value but found \xe2\x80\x9c%s\xe2\x80\x9d at \xe2\x80\x9c%s\xe2\x80\x9d." value element_name size_val size_val)
+                  ~code:"bad-sizes-value"
+                  ~element:element_name ~attribute:"sizes" ();
+                valid := false
+              | CssCommentAfterSign (found, context) ->
+                (* e.g., +/**/50vw - expected number after sign *)
+                Message_collector.add_error collector
+                  ~message:(Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9csizes\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad source size list: Expected number but found \xe2\x80\x9c%s\xe2\x80\x9d at \xe2\x80\x9c%s\xe2\x80\x9d." value element_name found context)
                   ~code:"bad-sizes-value"
                   ~element:element_name ~attribute:"sizes" ();
                 valid := false
-              | CssCommentInside ->
+              | CssCommentBeforeUnit (found, context) ->
+                (* e.g., 50/**/vw - expected units after number *)
+                let units_list = List.map (fun u -> Printf.sprintf "\xe2\x80\x9c%s\xe2\x80\x9d" u) valid_length_units in
+                let units_str = String.concat ", " units_list in
                 Message_collector.add_error collector
-                  ~message:(Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9csizes\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad source size list: Bad CSS number token." value element_name)
+                  ~message:(Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9csizes\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad source size list: Expected units (one of %s) but found \xe2\x80\x9c%s\xe2\x80\x9d at \xe2\x80\x9c%s\xe2\x80\x9d." value element_name units_str found context)
                   ~code:"bad-sizes-value"
                   ~element:element_name ~attribute:"sizes" ();
                 valid := false
               | BadScientificNotation ->
+                (* For scientific notation with bad exponent, show what char was expected vs found *)
+                let context =
+                  if List.length entries > 1 then trimmed ^ ","
+                  else trimmed
+                in
+                (* Find the period in the exponent *)
+                let _ = context in
                 Message_collector.add_error collector
-                  ~message:(Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9csizes\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad source size list: Bad CSS number token." value element_name)
+                  ~message:(Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9csizes\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad source size list: Bad CSS number token: Expected a digit but saw \xe2\x80\x9c.\xe2\x80\x9d instead at \xe2\x80\x9c%s\xe2\x80\x9d." value element_name size_val)
                   ~code:"bad-sizes-value"
                   ~element:element_name ~attribute:"sizes" ();
                 valid := false
-              | InvalidUnit ->
+              | BadCssNumber (first_char, context) ->
+                (* Value doesn't start with a digit or minus sign *)
+                let full_context =
+                  if List.length entries > 1 then context ^ ","
+                  else context
+                in
+                let _ = full_context in
+                Message_collector.add_error collector
+                  ~message:(Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9csizes\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad source size list: Bad CSS number token: Expected a minus sign or a digit but saw \xe2\x80\x9c%c\xe2\x80\x9d instead at \xe2\x80\x9c%s\xe2\x80\x9d." value element_name first_char context)
+                  ~code:"bad-sizes-value"
+                  ~element:element_name ~attribute:"sizes" ();
+                valid := false
+              | InvalidUnit (found_unit, _context) ->
+                (* Generate the full list of expected units *)
+                let units_list = List.map (fun u -> Printf.sprintf "\xe2\x80\x9c%s\xe2\x80\x9d" u) valid_length_units in
+                let units_str = String.concat ", " units_list in
+                (* Context should be the full entry, with comma only if there are multiple entries *)
+                let full_context =
+                  if List.length entries > 1 then trimmed ^ ","
+                  else trimmed
+                in
+                (* When found_unit is empty, say "no units" instead of quoting empty string *)
+                let found_str =
+                  if found_unit = "" then "no units"
+                  else Printf.sprintf "\xe2\x80\x9c%s\xe2\x80\x9d" found_unit
+                in
                 Message_collector.add_error collector
-                  ~message:(Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9csizes\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad source size value." value element_name)
+                  ~message:(Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9csizes\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad source size list: Expected units (one of %s) but found %s at \xe2\x80\x9c%s\xe2\x80\x9d." value element_name units_str found_str full_context)
                   ~code:"bad-sizes-value"
                   ~element:element_name ~attribute:"sizes" ();
                 valid := false
···
   end
 
 (** Validate srcset descriptor *)
-let validate_srcset_descriptor desc element_name srcset_value collector =
+let validate_srcset_descriptor desc element_name srcset_value has_sizes collector =
   let desc_lower = String.lowercase_ascii (String.trim desc) in
   if String.length desc_lower = 0 then true
   else begin
···
       (* Width descriptor - must be positive integer, no leading + *)
       let trimmed_desc = String.trim desc in
       if String.length trimmed_desc > 0 && trimmed_desc.[0] = '+' then begin
+        (* Show just the number part (without the 'w') *)
+        let num_part_for_msg = String.sub trimmed_desc 0 (String.length trimmed_desc - 1) in
         Message_collector.add_error collector
-          ~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 without leading plus sign but found \xe2\x80\x9c%s\xe2\x80\x9d at \xe2\x80\x9c%s\xe2\x80\x9d." srcset_value element_name trimmed_desc srcset_value)
+          ~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 without leading plus sign but found \xe2\x80\x9c%s\xe2\x80\x9d at \xe2\x80\x9c%s\xe2\x80\x9d." srcset_value element_name num_part_for_msg srcset_value)
           ~code:"bad-srcset-value"
           ~element:element_name ~attribute:"srcset" ();
         false
···
         let n = int_of_string num_part in
         if n <= 0 then begin
           Message_collector.add_error collector
-            ~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: Bad srcset descriptor: Width must be positive." srcset_value element_name)
+            ~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 greater than zero but found \xe2\x80\x9c%s\xe2\x80\x9d at \xe2\x80\x9c%s\xe2\x80\x9d." srcset_value element_name num_part srcset_value)
             ~code:"bad-srcset-value"
             ~element:element_name ~attribute:"srcset" ();
           false
···
           let original_last = desc.[String.length desc - 1] in
           if original_last = 'W' then begin
             Message_collector.add_error collector
-              ~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: Bad srcset descriptor: Width descriptor must use lowercase \xe2\x80\x9cw\xe2\x80\x9d." srcset_value element_name)
+              ~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 width descriptor but found \xe2\x80\x9c%s\xe2\x80\x9d at \xe2\x80\x9c%s\xe2\x80\x9d. (When the \xe2\x80\x9csizes\xe2\x80\x9d attribute is present, all image candidate strings must specify a width.)" srcset_value element_name desc srcset_value)
               ~code:"bad-srcset-value"
               ~element:element_name ~attribute:"srcset" ();
             false
           end else true
         end
       with _ ->
-        (* Check for scientific notation or decimal *)
-        if String.contains num_part 'e' || String.contains num_part 'E' then begin
+        (* Check for scientific notation, decimal, or other non-integer values *)
+        if String.contains num_part 'e' || String.contains num_part 'E' || String.contains num_part '.' then begin
           Message_collector.add_error collector
-            ~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: Bad srcset descriptor: Scientific notation not allowed in width descriptor." srcset_value element_name)
+            ~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 integer but found \xe2\x80\x9c%s\xe2\x80\x9d at \xe2\x80\x9c%s\xe2\x80\x9d." srcset_value element_name num_part srcset_value)
             ~code:"bad-srcset-value"
             ~element:element_name ~attribute:"srcset" ();
           false
···
       (* Pixel density descriptor - must be positive number, no leading + *)
       let trimmed_desc = String.trim desc in
       if String.length trimmed_desc > 0 && trimmed_desc.[0] = '+' then begin
+        (* Extract the number part including the plus sign *)
+        let num_with_plus = String.sub trimmed_desc 0 (String.length trimmed_desc - 1) in
         Message_collector.add_error collector
-          ~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: Bad srcset descriptor: Leading plus sign not allowed." srcset_value element_name)
+          ~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 without leading plus sign but found \xe2\x80\x9c%s\xe2\x80\x9d at \xe2\x80\x9c%s\xe2\x80\x9d." srcset_value element_name num_with_plus srcset_value)
           ~code:"bad-srcset-value"
           ~element:element_name ~attribute:"srcset" ();
         false
···
         (try
           let n = float_of_string num_part in
           if Float.is_nan n then begin
+            (* NaN is not a valid float - report as parse error with first char from ORIGINAL desc *)
+            let trimmed_desc = String.trim desc in
+            let orig_num_part = String.sub trimmed_desc 0 (String.length trimmed_desc - 1) in
+            let first_char = if String.length orig_num_part > 0 then String.make 1 orig_num_part.[0] else "" in
             Message_collector.add_error collector
-              ~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: Bad srcset descriptor: NaN not allowed." srcset_value element_name)
+              ~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: Bad positive floating point number: Expected a digit but saw \xe2\x80\x9c%s\xe2\x80\x9d instead at \xe2\x80\x9c%s\xe2\x80\x9d." srcset_value element_name first_char srcset_value)
               ~code:"bad-srcset-value"
               ~element:element_name ~attribute:"srcset" ();
             false
-          end else if n <= 0.0 then begin
+          end else if n = 0.0 then begin
+            (* Check if it's -0 (starts with minus) - report as "greater than zero" error *)
+            let trimmed_desc = String.trim desc in
+            let orig_num_part = String.sub trimmed_desc 0 (String.length trimmed_desc - 1) in
+            if String.length orig_num_part > 0 && orig_num_part.[0] = '-' then begin
+              Message_collector.add_error collector
+                ~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 greater than zero but found \xe2\x80\x9c%s\xe2\x80\x9d at \xe2\x80\x9c%s\xe2\x80\x9d." srcset_value element_name orig_num_part srcset_value)
+                ~code:"bad-srcset-value"
+                ~element:element_name ~attribute:"srcset" ()
+            end else begin
+              Message_collector.add_error collector
+                ~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: Bad positive floating point number: Zero is not a valid positive floating point number at \xe2\x80\x9c%s\xe2\x80\x9d." srcset_value element_name srcset_value)
+                ~code:"bad-srcset-value"
+                ~element:element_name ~attribute:"srcset" ()
+            end;
+            false
+          end else if n < 0.0 then begin
             Message_collector.add_error collector
-              ~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: Bad srcset descriptor: Density must be positive." srcset_value element_name)
+              ~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 greater than zero but found \xe2\x80\x9c%s\xe2\x80\x9d at \xe2\x80\x9c%s\xe2\x80\x9d." srcset_value element_name num_part srcset_value)
               ~code:"bad-srcset-value"
               ~element:element_name ~attribute:"srcset" ();
             false
           end else if n = neg_infinity || n = infinity then begin
+            (* Infinity is not a valid float - report as parse error with first char from ORIGINAL desc *)
+            let trimmed_desc = String.trim desc in
+            let orig_num_part = String.sub trimmed_desc 0 (String.length trimmed_desc - 1) in
+            let first_char = if String.length orig_num_part > 0 then String.make 1 orig_num_part.[0] else "" in
             Message_collector.add_error collector
-              ~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: Bad srcset descriptor: Infinity not allowed." srcset_value element_name)
+              ~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: Bad positive floating point number: Expected a digit but saw \xe2\x80\x9c%s\xe2\x80\x9d instead at \xe2\x80\x9c%s\xe2\x80\x9d." srcset_value element_name first_char srcset_value)
               ~code:"bad-srcset-value"
               ~element:element_name ~attribute:"srcset" ();
             false
···
       end
     | 'h' ->
       (* Height descriptor - not allowed *)
-      Message_collector.add_error collector
-        ~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: Bad srcset descriptor: Height descriptor \xe2\x80\x9ch\xe2\x80\x9d is not allowed." srcset_value element_name)
-        ~code:"bad-srcset-value"
-        ~element:element_name ~attribute:"srcset" ();
+      let trimmed_desc = String.trim desc in
+      (* Generate context: find where this entry appears *)
+      let context =
+        try
+          let pos = Str.search_forward (Str.regexp_string trimmed_desc) srcset_value 0 in
+          (* Get the entry context ending with comma *)
+          let search_from = max 0 (pos - 3) in
+          let comma_pos = try Str.search_forward (Str.regexp_string ",") srcset_value pos with Not_found -> String.length srcset_value - 1 in
+          let end_pos = min (comma_pos + 1) (String.length srcset_value) in
+          let len = end_pos - search_from in
+          if len > 0 then String.trim (String.sub srcset_value search_from len) else srcset_value
+        with Not_found | Invalid_argument _ -> srcset_value
+      in
+      if has_sizes then
+        Message_collector.add_error collector
+          ~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 width descriptor but found \xe2\x80\x9c%s\xe2\x80\x9d at \xe2\x80\x9c%s\xe2\x80\x9d. (When the \xe2\x80\x9csizes\xe2\x80\x9d attribute is present, all image candidate strings must specify a width.)" srcset_value element_name trimmed_desc context)
+          ~code:"bad-srcset-value"
+          ~element:element_name ~attribute:"srcset" ()
+      else
+        Message_collector.add_error collector
+          ~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: Bad srcset descriptor: Height descriptor \xe2\x80\x9ch\xe2\x80\x9d is not allowed." srcset_value element_name)
+          ~code:"bad-srcset-value"
+          ~element:element_name ~attribute:"srcset" ();
       false
     | _ ->
-      (* Unknown descriptor *)
+      (* 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 *)
+      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 *)
+          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))
+        with Not_found -> srcset_value
+      in
       Message_collector.add_error collector
-        ~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: Bad srcset descriptor." srcset_value element_name)
+        ~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)
         ~code:"bad-srcset-value"
         ~element:element_name ~attribute:"srcset" ();
       false
···
   let entries = String.split_on_char ',' value in
   let has_w_descriptor = ref false in
   let has_x_descriptor = ref false in
-  let has_no_descriptor = ref false in  (* Track if any entry has no descriptor *)
-  let seen_descriptors = Hashtbl.create 8 in  (* Track seen descriptor values *)
+  let no_descriptor_url = ref None in  (* Track URL of first entry without width descriptor *)
+  let x_with_sizes_error_reported = ref false in  (* Track if we already reported x-with-sizes error *)
+  let seen_descriptors = Hashtbl.create 8 in  (* Track seen descriptor values -> first URL *)
 
   (* Check for empty srcset *)
   if String.trim value = "" then begin
     Message_collector.add_error collector
-      ~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: Must not be empty." value element_name)
+      ~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: Must contain one or more image candidate strings." value element_name)
       ~code:"bad-srcset-value"
       ~element:element_name ~attribute:"srcset" ()
   end;
···
   (* Check for leading comma *)
   if String.length value > 0 && value.[0] = ',' then begin
     Message_collector.add_error collector
-      ~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: Bad srcset: Leading comma." value element_name)
+      ~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: Starts with empty image-candidate string." value element_name)
       ~code:"bad-srcset-value"
       ~element:element_name ~attribute:"srcset" ()
   end;
 
-  (* Check for trailing comma *)
+  (* Check for trailing comma(s) / empty entries *)
   let trimmed_value = String.trim value in
   if String.length trimmed_value > 0 && trimmed_value.[String.length trimmed_value - 1] = ',' then begin
-    Message_collector.add_error collector
-      ~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: Bad srcset: Trailing comma." value element_name)
-      ~code:"bad-srcset-value"
-      ~element:element_name ~attribute:"srcset" ()
+    (* Count consecutive trailing commas *)
+    let rec count_trailing_commas s idx count =
+      if idx < 0 then count
+      else if s.[idx] = ',' then count_trailing_commas s (idx - 1) (count + 1)
+      else if s.[idx] = ' ' || s.[idx] = '\t' then count_trailing_commas s (idx - 1) count
+      else count
+    in
+    let trailing_commas = count_trailing_commas trimmed_value (String.length trimmed_value - 1) 0 in
+    if trailing_commas > 1 then
+      (* Multiple trailing commas: "Empty image-candidate string at" *)
+      Message_collector.add_error collector
+        ~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: Empty image-candidate string at \xe2\x80\x9c%s\xe2\x80\x9d." value element_name value)
+        ~code:"bad-srcset-value"
+        ~element:element_name ~attribute:"srcset" ()
+    else
+      (* Single trailing comma: "Ends with empty image-candidate string." *)
+      Message_collector.add_error collector
+        ~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: Ends with empty image-candidate string." value element_name)
+        ~code:"bad-srcset-value"
+        ~element:element_name ~attribute:"srcset" ()
   end;
 
   List.iter (fun entry ->
···
           let scheme_colon = scheme ^ ":" in
           if url_lower = scheme_colon then
             Message_collector.add_error collector
-              ~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: Bad URL: Expected a slash (\"/\")." value element_name)
+              ~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: Bad image-candidate URL: \xe2\x80\x9c%s\xe2\x80\x9d: Expected a slash (\"/\")." value element_name url)
               ~code:"bad-srcset-url"
               ~element:element_name ~attribute:"srcset" ()
         ) special_schemes
···
       | [url] ->
         check_srcset_url url;
         (* URL only = implicit 1x descriptor - only flag if explicit 1x also seen *)
-        has_no_descriptor := true;
-        if Hashtbl.mem seen_descriptors "explicit-1x" then begin
+        if !no_descriptor_url = None then no_descriptor_url := Some url;
+        begin match Hashtbl.find_opt seen_descriptors "explicit-1x" with
+        | Some first_url ->
           Message_collector.add_error collector
-            ~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: Duplicate descriptor." value element_name)
+            ~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: Density for image \xe2\x80\x9c%s\xe2\x80\x9d is identical to density for image \xe2\x80\x9c%s\xe2\x80\x9d." value element_name url first_url)
             ~code:"bad-srcset-value"
             ~element:element_name ~attribute:"srcset" ()
-        end else
-          Hashtbl.add seen_descriptors "implicit-1x" true
+        | None ->
+          Hashtbl.add seen_descriptors "implicit-1x" url
+        end
       | url :: desc :: rest ->
         (* Check URL for broken schemes *)
         check_srcset_url url;
         (* Check for extra junk - multiple descriptors are not allowed *)
         if rest <> [] then begin
+          let extra_desc = List.hd rest in
           Message_collector.add_error collector
-            ~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: Bad srcset: Multiple descriptors in candidate." value element_name)
+            ~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 single descriptor but found extraneous descriptor \xe2\x80\x9c%s\xe2\x80\x9d at \xe2\x80\x9c%s\xe2\x80\x9d." value element_name extra_desc value)
             ~code:"bad-srcset-value"
             ~element:element_name ~attribute:"srcset" ()
         end;
···
         if String.length desc_lower > 0 then begin
           let last_char = desc_lower.[String.length desc_lower - 1] in
           if last_char = 'w' then has_w_descriptor := true
-          else if last_char = 'x' then has_x_descriptor := true;
+          else if last_char = 'x' then begin
+            has_x_descriptor := true;
+            (* If sizes is present and we have an x descriptor, generate detailed error *)
+            if has_sizes && not !x_with_sizes_error_reported then begin
+              x_with_sizes_error_reported := true;
+              (* Build context:
+                 - If entry has extra parts (multiple descriptors): show "url descriptor "
+                 - Else if entry has trailing comma: show "url descriptor,"
+                 - Else (last entry, no extra parts): show full srcset value *)
+              let trimmed_url = String.trim url in
+              let trimmed_desc = String.trim desc in
+              let entry_context =
+                if rest <> [] then
+                  (* Entry has multiple descriptors - show URL + first descriptor + space *)
+                  trimmed_url ^ " " ^ trimmed_desc ^ " "
+                else
+                  (* Check if entry ends with comma in original value *)
+                  let trimmed_entry = String.trim entry in
+                  try
+                    let entry_start = Str.search_forward (Str.regexp_string trimmed_url) value 0 in
+                    let entry_end = entry_start + String.length trimmed_entry in
+                    let has_trailing_comma = entry_end < String.length value && value.[entry_end] = ',' in
+                    if has_trailing_comma then
+                      (* Entry followed by comma - show "url descriptor," *)
+                      trimmed_url ^ " " ^ trimmed_desc ^ ","
+                    else
+                      (* Last entry - show full srcset value *)
+                      value
+                  with Not_found ->
+                    value
+              in
+              Message_collector.add_error collector
+                ~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 width descriptor but found \xe2\x80\x9c%s\xe2\x80\x9d at \xe2\x80\x9c%s\xe2\x80\x9d. (When the \xe2\x80\x9csizes\xe2\x80\x9d attribute is present, all image candidate strings must specify a width.)" value element_name trimmed_desc entry_context)
+                ~code:"bad-srcset-value"
+                ~element:element_name ~attribute:"srcset" ()
+            end
+          end;
 
           (* Check for duplicate descriptors - use normalized form *)
           let normalized = normalize_descriptor desc in
           let is_1x = (normalized = "1x") in
-          if Hashtbl.mem seen_descriptors normalized then begin
-            Message_collector.add_error collector
-              ~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: Duplicate descriptor." value element_name)
-              ~code:"bad-srcset-value"
-              ~element:element_name ~attribute:"srcset" ()
-          end else if is_1x && Hashtbl.mem seen_descriptors "implicit-1x" then begin
-            (* Explicit 1x conflicts with implicit 1x *)
+          let is_width = (last_char = 'w') in
+          let dup_type = if is_width then "Width" else "Density" in
+          begin match Hashtbl.find_opt seen_descriptors normalized with
+          | Some first_url ->
             Message_collector.add_error collector
-              ~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: Duplicate descriptor." value element_name)
+              ~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: %s for image \xe2\x80\x9c%s\xe2\x80\x9d is identical to %s for image \xe2\x80\x9c%s\xe2\x80\x9d." value element_name dup_type url (String.lowercase_ascii dup_type) first_url)
               ~code:"bad-srcset-value"
               ~element:element_name ~attribute:"srcset" ()
-          end else begin
-            Hashtbl.add seen_descriptors normalized true;
-            if is_1x then Hashtbl.add seen_descriptors "explicit-1x" true
+          | None ->
+            begin match (if is_1x then Hashtbl.find_opt seen_descriptors "implicit-1x" else None) with
+            | Some first_url ->
+              (* Explicit 1x conflicts with implicit 1x *)
+              Message_collector.add_error collector
+                ~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: %s for image \xe2\x80\x9c%s\xe2\x80\x9d is identical to %s for image \xe2\x80\x9c%s\xe2\x80\x9d." value element_name dup_type url (String.lowercase_ascii dup_type) first_url)
+                ~code:"bad-srcset-value"
+                ~element:element_name ~attribute:"srcset" ()
+            | None ->
+              Hashtbl.add seen_descriptors normalized url;
+              if is_1x then Hashtbl.add seen_descriptors "explicit-1x" url
+            end
           end
         end;
 
-        ignore (validate_srcset_descriptor desc element_name value collector)
+        ignore (validate_srcset_descriptor desc element_name value has_sizes collector)
     end
   ) entries;
 
   (* Check: if w descriptor used and no sizes, that's an error for img and source *)
   if !has_w_descriptor && not has_sizes then
     Message_collector.add_error collector
-      ~message:(Printf.sprintf "When the \xe2\x80\x9csrcset\xe2\x80\x9d attribute on the \xe2\x80\x9c%s\xe2\x80\x9d element uses width descriptors, the \xe2\x80\x9csizes\xe2\x80\x9d attribute must also be present." element_name)
+      ~message:"When the \xe2\x80\x9csrcset\xe2\x80\x9d attribute has any image candidate string with a width descriptor, the \xe2\x80\x9csizes\xe2\x80\x9d attribute must also be specified."
       ~code:"srcset-w-without-sizes"
       ~element:element_name ~attribute:"srcset" ();
 
   (* Check: if sizes is present, all entries must have width descriptors *)
-  if has_sizes && !has_no_descriptor then
+  (match !no_descriptor_url with
+  | Some url when has_sizes ->
     Message_collector.add_error collector
-      ~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: No width specified for image. (When the \xe2\x80\x9csizes\xe2\x80\x9d attribute is present, all image candidate strings must specify a width.)" value element_name)
+      ~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: No width specified for image \xe2\x80\x9c%s\xe2\x80\x9d. (When the \xe2\x80\x9csizes\xe2\x80\x9d attribute is present, all image candidate strings must specify a width.)" value element_name url)
       ~code:"bad-srcset-value"
-      ~element:element_name ~attribute:"srcset" ();
+      ~element:element_name ~attribute:"srcset" ()
+  | _ -> ());
 
-  (* Check: if sizes is present and srcset uses x descriptors, that's an error *)
-  if has_sizes && !has_x_descriptor then
+  (* Check: if sizes is present and srcset uses x descriptors, that's an error.
+     Only report if we haven't already reported the detailed error. *)
+  if has_sizes && !has_x_descriptor && not !x_with_sizes_error_reported then
     Message_collector.add_error collector
       ~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: When the \xe2\x80\x9csizes\xe2\x80\x9d attribute is present, all image candidate strings must specify a width." value element_name)
       ~code:"bad-srcset-value"

lib/html5_checker/specialized/xhtml_content_checker.ml

···
   | "menu" ->
       (* menu only allows li, script, template *)
       List.mem child ["li"; "script"; "template"]
+  | "table" ->
+      (* col must be in colgroup, not directly in table *)
+      child <> "col"
   | _ -> true
 
 (* Check if text is allowed in element *)

lib/html5rw/parser/parser_tree_builder.ml

···
     t.open_elements <- [html];
     t.mode <- Parser_insertion_mode.Before_head;
     process_token t token
-  | Token.Tag { kind = Token.End; _ } ->
-    parse_error t "unexpected-end-tag"
+  | Token.Tag { kind = Token.End; name; _ } ->
+    parse_error t ("unexpected-end-tag:" ^ name)
   | _ ->
     let html = insert_element t "html" [] in
     t.open_elements <- [html];
···
     t.head_element <- Some head;
     t.mode <- Parser_insertion_mode.In_head;
     process_token t token
-  | Token.Tag { kind = Token.End; _ } ->
-    parse_error t "unexpected-end-tag"
+  | Token.Tag { kind = Token.End; name; _ } ->
+    parse_error t ("unexpected-end-tag:" ^ name)
   | _ ->
     let head = insert_element t "head" [] in
     t.open_elements <- head :: t.open_elements;
···
     end
   | Token.Tag { kind = Token.Start; name = "head"; _ } ->
     parse_error t "unexpected-start-tag"
-  | Token.Tag { kind = Token.End; _ } ->
-    parse_error t "unexpected-end-tag"
+  | Token.Tag { kind = Token.End; name; _ } ->
+    parse_error t ("unexpected-end-tag:" ^ name)
   | _ ->
     pop_current t;
     t.mode <- Parser_insertion_mode.After_head;
···
     pop_current t;  (* Pop noscript *)
     t.mode <- Parser_insertion_mode.In_head;
     process_token t token
-  | Token.Tag { kind = Token.End; _ } ->
-    parse_error t "unexpected-end-tag"
+  | Token.Tag { kind = Token.End; name; _ } ->
+    parse_error t ("unexpected-end-tag:" ^ name)
   | Token.EOF ->
     parse_error t "expected-closing-tag-but-got-eof";
     pop_current t;  (* Pop noscript *)
···
     process_token t token
   | Token.Tag { kind = Token.Start; name = "head"; _ } ->
     parse_error t "unexpected-start-tag"
-  | Token.Tag { kind = Token.End; _ } ->
-    parse_error t "unexpected-end-tag"
+  | Token.Tag { kind = Token.End; name; _ } ->
+    parse_error t ("unexpected-end-tag:" ^ name)
   | _ ->
     let body = insert_element t "body" [] in
     t.open_elements <- body :: t.open_elements;
···
            | _ -> ());
           pop_until t (fun n -> n == node)
         end else if is_special_element node then
-          parse_error t "unexpected-end-tag"
+          parse_error t ("unexpected-end-tag:" ^ name)
         else
           check rest
     in
···
     t.template_modes <- Parser_insertion_mode.In_body :: t.template_modes;
     t.mode <- Parser_insertion_mode.In_body;
     process_token t token
-  | Token.Tag { kind = Token.End; _ } ->
-    parse_error t "unexpected-end-tag"
+  | Token.Tag { kind = Token.End; name; _ } ->
+    parse_error t ("unexpected-end-tag:" ^ name)
   | Token.EOF ->
     if not (List.exists (fun n -> n.Dom.name = "template" && is_in_html_namespace n) t.open_elements) then
       ()  (* Stop parsing *)