fixes

lib/htmlrw_check/specialized/srcset_sizes_checker.ml

···
 (** Srcset and sizes attribute validation checker. *)
 
+(** Quote helper for consistent message formatting. *)
+let q = Error_code.q
+
 (** Valid CSS length units for sizes attribute *)
 let valid_length_units = [
   "em"; "ex"; "ch"; "rem"; "cap"; "ic";
···
   (* Empty sizes is invalid *)
   if String.trim value = "" then begin
     Message_collector.add_typed collector
-      (`Attr (`Bad_value_generic (`Message (Printf.sprintf "Bad value \xe2\x80\x9c\xe2\x80\x9d for attribute \xe2\x80\x9csizes\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad source size list: Must not be empty." element_name))));
+      (`Attr (`Bad_value_generic (`Message (Printf.sprintf "Bad value %s for attribute %s on element %s: Bad source size list: Must not be empty." (q "") (q "sizes") (q element_name)))));
     false
   end else begin
     (* Split on comma and check each entry *)
···
     (* Check if starts with comma (empty first entry) *)
     if first_entry = "" then begin
       Message_collector.add_typed collector
-        (`Attr (`Bad_value_generic (`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: Starts with empty source size." value element_name))));
+        (`Attr (`Bad_value_generic (`Message (Printf.sprintf "Bad value %s for attribute %s on element %s: Bad source size list: Starts with empty source size." (q value) (q "sizes") (q element_name)))));
       false
     end else begin
       (* 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_typed collector
-          (`Attr (`Bad_value_generic (`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))));
+          (`Attr (`Bad_value_generic (`Message (Printf.sprintf "Bad value %s for attribute %s on element %s: Bad source size list: Expected media condition before %s at %s." (q value) (q "sizes") (q element_name) (q "") (q value)))));
         false
       end else begin
         let valid = ref true in
···
             (* Context is the first entry with a comma *)
             let context = (String.trim first) ^ "," in
             Message_collector.add_typed collector
-              (`Attr (`Bad_value_generic (`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))));
+              (`Attr (`Bad_value_generic (`Message (Printf.sprintf "Bad value %s for attribute %s on element %s: Bad source size list: Expected media condition before %s at %s." (q value) (q "sizes") (q element_name) (q "") (q context)))));
             valid := false
           end;
           (* Check for multiple entries without media conditions.
···
               (* Multiple defaults - report as "Expected media condition" *)
               let context = (String.trim first) ^ "," in
               Message_collector.add_typed collector
-                (`Attr (`Bad_value_generic (`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))));
+                (`Attr (`Bad_value_generic (`Message (Printf.sprintf "Bad value %s for attribute %s on element %s: Bad source size list: Expected media condition before %s at %s." (q value) (q "sizes") (q element_name) (q "") (q context)))));
               valid := false
             end
           end
···
             (* 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
+               let context = trimmed ^ "," in
                Message_collector.add_typed collector
-                 (`Attr (`Bad_value_generic (`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))));
+                 (`Attr (`Bad_value_generic (`Message (Printf.sprintf "Bad value %s for attribute %s on element %s: Bad source size list: %s at %s." (q value) (q "sizes") (q element_name) err_msg (q context)))));
                valid := false
              | None -> ());
 
···
                 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
+                    String.concat ", " (List.map String.trim prev_entries) ^ ","
                   else value
                 in
                 Message_collector.add_typed collector
-                  (`Attr (`Bad_value_generic (`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))));
+                  (`Attr (`Bad_value_generic (`Message (Printf.sprintf "Bad value %s for attribute %s on element %s: Bad source size list: Expected media condition before %s at %s." (q value) (q "sizes") (q element_name) (q "") (q context)))));
                 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
+                  if is_last_entry then value
+                  else trimmed ^ ","
                 in
-                let _ = junk in
                 Message_collector.add_typed collector
-                  (`Attr (`Bad_value_generic (`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))));
+                  (`Attr (`Bad_value_generic (`Message (Printf.sprintf "Bad value %s for attribute %s on element %s: Bad source size list: Bad CSS number token: Expected a minus sign or a digit but saw %s instead at %s." (q value) (q "sizes") (q element_name) (q (String.make 1 first_char)) (q context)))));
                 valid := false
               end
               else
···
                 in
                 let _ = full_context in
                 Message_collector.add_typed collector
-                  (`Attr (`Bad_value_generic (`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))));
+                  (`Attr (`Bad_value_generic (`Message (Printf.sprintf "Bad value %s for attribute %s on element %s: Bad source size list: Expected positive size value but found %s at %s." (q value) (q "sizes") (q element_name) (q size_val) (q size_val)))));
                 valid := false
               | CssCommentAfterSign (found, context) ->
                 (* e.g., +/**/50vw - expected number after sign *)
                 Message_collector.add_typed collector
-                  (`Attr (`Bad_value_generic (`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))));
+                  (`Attr (`Bad_value_generic (`Message (Printf.sprintf "Bad value %s for attribute %s on element %s: Bad source size list: Expected number but found %s at %s." (q value) (q "sizes") (q element_name) (q found) (q context)))));
                 valid := false
               | 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_list = List.map q valid_length_units in
                 let units_str = String.concat ", " units_list in
                 Message_collector.add_typed collector
-                  (`Attr (`Bad_value_generic (`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))));
+                  (`Attr (`Bad_value_generic (`Message (Printf.sprintf "Bad value %s for attribute %s on element %s: Bad source size list: Expected units (one of %s) but found %s at %s." (q value) (q "sizes") (q element_name) units_str (q found) (q context)))));
                 valid := false
               | BadScientificNotation ->
                 (* For scientific notation with bad exponent, show what char was expected vs found *)
···
                 (* Find the period in the exponent *)
                 let _ = context in
                 Message_collector.add_typed collector
-                  (`Attr (`Bad_value_generic (`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))));
+                  (`Attr (`Bad_value_generic (`Message (Printf.sprintf "Bad value %s for attribute %s on element %s: Bad source size list: Bad CSS number token: Expected a digit but saw %s instead at %s." (q value) (q "sizes") (q element_name) (q ".") (q size_val)))));
                 valid := false
               | BadCssNumber (first_char, context) ->
                 (* Value doesn't start with a digit or minus sign *)
···
                 in
                 let _ = full_context in
                 Message_collector.add_typed collector
-                  (`Attr (`Bad_value_generic (`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))));
+                  (`Attr (`Bad_value_generic (`Message (Printf.sprintf "Bad value %s for attribute %s on element %s: Bad source size list: Bad CSS number token: Expected a minus sign or a digit but saw %s instead at %s." (q value) (q "sizes") (q element_name) (q (String.make 1 first_char)) (q context)))));
                 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_list = List.map q 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 =
···
                 (* 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
+                  else q found_unit
                 in
                 Message_collector.add_typed collector
-                  (`Attr (`Bad_value_generic (`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))));
+                  (`Attr (`Bad_value_generic (`Message (Printf.sprintf "Bad value %s for attribute %s on element %s: Bad source size list: Expected units (one of %s) but found %s at %s." (q value) (q "sizes") (q element_name) units_str found_str (q full_context)))));
                 valid := false
             end
           end
···
         (* 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_typed collector
-          (`Attr (`Bad_value_generic (`Message (Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9csrcset\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Expected number 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))));
+          (`Attr (`Bad_value_generic (`Message (Printf.sprintf "Bad value %s for attribute %s on element %s: Expected number without leading plus sign but found %s at %s." (q srcset_value) (q "srcset") (q element_name) (q num_part_for_msg) (q srcset_value)))));
         false
       end else
       (try
         let n = int_of_string num_part in
         if n <= 0 then begin
           Message_collector.add_typed collector
-            (`Attr (`Bad_value_generic (`Message (Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9csrcset\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Expected number 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))));
+            (`Attr (`Bad_value_generic (`Message (Printf.sprintf "Bad value %s for attribute %s on element %s: Expected number greater than zero but found %s at %s." (q srcset_value) (q "srcset") (q element_name) (q num_part) (q srcset_value)))));
           false
         end else begin
           (* Check for uppercase W - compare original desc with lowercase version *)
           let original_last = desc.[String.length desc - 1] in
           if original_last = 'W' then begin
             Message_collector.add_typed collector
-              (`Attr (`Bad_value_generic (`Message (Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9csrcset\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Expected 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))));
+              (`Attr (`Bad_value_generic (`Message (Printf.sprintf "Bad value %s for attribute %s on element %s: Expected width descriptor but found %s at %s. (When the %s attribute is present, all image candidate strings must specify a width.)" (q srcset_value) (q "srcset") (q element_name) (q desc) (q srcset_value) (q "sizes")))));
             false
           end else true
         end
···
         (* 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_typed collector
-            (`Attr (`Bad_value_generic (`Message (Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9csrcset\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Expected 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))));
+            (`Attr (`Bad_value_generic (`Message (Printf.sprintf "Bad value %s for attribute %s on element %s: Expected integer but found %s at %s." (q srcset_value) (q "srcset") (q element_name) (q num_part) (q srcset_value)))));
           false
         end else begin
           Message_collector.add_typed collector
-            (`Attr (`Bad_value_generic (`Message (Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9csrcset\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad srcset descriptor: Invalid width descriptor." srcset_value element_name))));
+            (`Attr (`Bad_value_generic (`Message (Printf.sprintf "Bad value %s for attribute %s on element %s: Bad srcset descriptor: Invalid width descriptor." (q srcset_value) (q "srcset") (q element_name)))));
           false
         end)
     | 'x' ->
···
         (* 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_typed collector
-          (`Attr (`Bad_value_generic (`Message (Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9csrcset\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Expected number 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))));
+          (`Attr (`Bad_value_generic (`Message (Printf.sprintf "Bad value %s for attribute %s on element %s: Expected number without leading plus sign but found %s at %s." (q srcset_value) (q "srcset") (q element_name) (q num_with_plus) (q srcset_value)))));
         false
       end else begin
         (try
···
             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_typed collector
-              (`Attr (`Bad_value_generic (`Message (Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9csrcset\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: 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))));
+              (`Attr (`Bad_value_generic (`Message (Printf.sprintf "Bad value %s for attribute %s on element %s: Bad positive floating point number: Expected a digit but saw %s instead at %s." (q srcset_value) (q "srcset") (q element_name) (q first_char) (q srcset_value)))));
             false
           end else if n = 0.0 then begin
             (* Check if it's -0 (starts with minus) - report as "greater than zero" error *)
···
             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_typed collector
-                (`Attr (`Bad_value_generic (`Message (Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9csrcset\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Expected number 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))))
+                (`Attr (`Bad_value_generic (`Message (Printf.sprintf "Bad value %s for attribute %s on element %s: Expected number greater than zero but found %s at %s." (q srcset_value) (q "srcset") (q element_name) (q orig_num_part) (q srcset_value)))))
             end else begin
               Message_collector.add_typed collector
-                (`Attr (`Bad_value_generic (`Message (Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9csrcset\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: 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))))
+                (`Attr (`Bad_value_generic (`Message (Printf.sprintf "Bad value %s for attribute %s on element %s: Bad positive floating point number: Zero is not a valid positive floating point number at %s." (q srcset_value) (q "srcset") (q element_name) (q srcset_value)))))
             end;
             false
           end else if n < 0.0 then begin
             Message_collector.add_typed collector
-              (`Attr (`Bad_value_generic (`Message (Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9csrcset\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Expected number 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))));
+              (`Attr (`Bad_value_generic (`Message (Printf.sprintf "Bad value %s for attribute %s on element %s: Expected number greater than zero but found %s at %s." (q srcset_value) (q "srcset") (q element_name) (q num_part) (q srcset_value)))));
             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 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_typed collector
-              (`Attr (`Bad_value_generic (`Message (Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9csrcset\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: 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))));
+              (`Attr (`Bad_value_generic (`Message (Printf.sprintf "Bad value %s for attribute %s on element %s: Bad positive floating point number: Expected a digit but saw %s instead at %s." (q srcset_value) (q "srcset") (q element_name) (q first_char) (q srcset_value)))));
             false
           end else true
         with _ ->
           Message_collector.add_typed collector
-            (`Attr (`Bad_value_generic (`Message (Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9csrcset\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad srcset descriptor: Invalid density descriptor." srcset_value element_name))));
+            (`Attr (`Bad_value_generic (`Message (Printf.sprintf "Bad value %s for attribute %s on element %s: Bad srcset descriptor: Invalid density descriptor." (q srcset_value) (q "srcset") (q element_name)))));
           false)
       end
     | 'h' ->
···
       in
       if has_sizes then
         Message_collector.add_typed collector
-          (`Attr (`Bad_value_generic (`Message (Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9csrcset\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Expected 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))))
+          (`Attr (`Bad_value_generic (`Message (Printf.sprintf "Bad value %s for attribute %s on element %s: Expected width descriptor but found %s at %s. (When the %s attribute is present, all image candidate strings must specify a width.)" (q srcset_value) (q "srcset") (q element_name) (q trimmed_desc) (q context) (q "sizes")))))
       else
         Message_collector.add_typed collector
-          (`Attr (`Bad_value_generic (`Message (Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9csrcset\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad srcset descriptor: Height descriptor \xe2\x80\x9ch\xe2\x80\x9d is not allowed." srcset_value element_name))));
+          (`Attr (`Bad_value_generic (`Message (Printf.sprintf "Bad value %s for attribute %s on element %s: Bad srcset descriptor: Height descriptor %s is not allowed." (q srcset_value) (q "srcset") (q element_name) (q "h")))));
       false
     | _ ->
       (* Unknown descriptor - find context in srcset_value *)
···
           with Not_found -> trimmed_desc ^ ")"
         else trimmed_desc
       in
-      (* Try to find the context: show trailing portion ending with descriptor and comma *)
+      (* Find context: the entry containing the error with trailing comma *)
       let context =
         try
           let pos = Str.search_forward (Str.regexp_string trimmed_desc) srcset_value 0 in
           (* Get the context ending with the descriptor and the comma after *)
           let end_pos = min (pos + String.length trimmed_desc + 1) (String.length srcset_value) in
-          (* Show trailing portion with ellipsis if needed *)
-          let max_context = 15 in
-          if end_pos > max_context then
-            "\xe2\x80\xa6" ^ String.sub srcset_value (end_pos - max_context) max_context
-          else
-            String.trim (String.sub srcset_value 0 end_pos)
+          String.trim (String.sub srcset_value 0 end_pos)
         with Not_found -> srcset_value
       in
       Message_collector.add_typed collector
-        (`Attr (`Bad_value_generic (`Message (Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9csrcset\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Expected number followed by \xe2\x80\x9cw\xe2\x80\x9d or \xe2\x80\x9cx\xe2\x80\x9d but found \xe2\x80\x9c%s\xe2\x80\x9d at \xe2\x80\x9c%s\xe2\x80\x9d." srcset_value element_name found_desc context))));
+        (`Attr (`Bad_value_generic (`Message (Printf.sprintf "Bad value %s for attribute %s on element %s: Expected number followed by %s or %s but found %s at %s." (q srcset_value) (q "srcset") (q element_name) (q "w") (q "x") (q found_desc) (q context)))));
       false
   end
 
···
   (* Check for empty srcset *)
   if String.trim value = "" then begin
     Message_collector.add_typed collector
-      (`Attr (`Bad_value_generic (`Message (Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9csrcset\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Must contain one or more image candidate strings." value element_name))))
+      (`Attr (`Bad_value_generic (`Message (Printf.sprintf "Bad value %s for attribute %s on element %s: Must contain one or more image candidate strings." (q value) (q "srcset") (q element_name)))))
   end;
 
   (* Check for leading comma *)
   if String.length value > 0 && value.[0] = ',' then begin
     Message_collector.add_typed collector
-      (`Attr (`Bad_value_generic (`Message (Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9csrcset\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Starts with empty image-candidate string." value element_name))))
+      (`Attr (`Bad_value_generic (`Message (Printf.sprintf "Bad value %s for attribute %s on element %s: Starts with empty image-candidate string." (q value) (q "srcset") (q element_name)))))
   end;
 
   (* Check for trailing comma(s) / empty entries *)
···
     if trailing_commas > 1 then
       (* Multiple trailing commas: "Empty image-candidate string at" *)
       Message_collector.add_typed collector
-        (`Attr (`Bad_value_generic (`Message (Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9csrcset\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Empty image-candidate string at \xe2\x80\x9c%s\xe2\x80\x9d." value element_name value))))
+        (`Attr (`Bad_value_generic (`Message (Printf.sprintf "Bad value %s for attribute %s on element %s: Empty image-candidate string at %s." (q value) (q "srcset") (q element_name) (q value)))))
     else
       (* Single trailing comma: "Ends with empty image-candidate string." *)
       Message_collector.add_typed collector
-        (`Attr (`Bad_value_generic (`Message (Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9csrcset\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Ends with empty image-candidate string." value element_name))))
+        (`Attr (`Bad_value_generic (`Message (Printf.sprintf "Bad value %s for attribute %s on element %s: Ends with empty image-candidate string." (q value) (q "srcset") (q element_name)))))
   end;
 
   List.iter (fun entry ->
···
           let scheme_colon = scheme ^ ":" in
           if url_lower = scheme_colon then
             Message_collector.add_typed collector
-              (`Attr (`Bad_value_generic (`Message (Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9csrcset\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad image-candidate URL: \xe2\x80\x9c%s\xe2\x80\x9d: Expected a slash (\"/\")." value element_name url))))
+              (`Attr (`Bad_value_generic (`Message (Printf.sprintf "Bad value %s for attribute %s on element %s: Bad image-candidate URL: %s: Expected a slash (\"/\")." (q value) (q "srcset") (q element_name) (q url)))))
         ) special_schemes
       in
       match parts with
···
         begin match Hashtbl.find_opt seen_descriptors "explicit-1x" with
         | Some first_url ->
           Message_collector.add_typed collector
-            (`Attr (`Bad_value_generic (`Message (Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9csrcset\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: 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))))
+            (`Attr (`Bad_value_generic (`Message (Printf.sprintf "Bad value %s for attribute %s on element %s: Density for image %s is identical to density for image %s." (q value) (q "srcset") (q element_name) (q url) (q first_url)))))
         | None ->
           Hashtbl.add seen_descriptors "implicit-1x" url
         end
···
         if rest <> [] then begin
           let extra_desc = List.hd rest in
           Message_collector.add_typed collector
-            (`Attr (`Bad_value_generic (`Message (Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9csrcset\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Expected 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))))
+            (`Attr (`Bad_value_generic (`Message (Printf.sprintf "Bad value %s for attribute %s on element %s: Expected single descriptor but found extraneous descriptor %s at %s." (q value) (q "srcset") (q element_name) (q extra_desc) (q value)))))
         end;
 
         let desc_lower = String.lowercase_ascii (String.trim desc) in
···
                     value
               in
               Message_collector.add_typed collector
-                (`Attr (`Bad_value_generic (`Message (Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9csrcset\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Expected 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))))
+                (`Attr (`Bad_value_generic (`Message (Printf.sprintf "Bad value %s for attribute %s on element %s: Expected width descriptor but found %s at %s. (When the %s attribute is present, all image candidate strings must specify a width.)" (q value) (q "srcset") (q element_name) (q trimmed_desc) (q entry_context) (q "sizes")))))
             end
           end;
 
···
           begin match Hashtbl.find_opt seen_descriptors normalized with
           | Some first_url ->
             Message_collector.add_typed collector
-              (`Attr (`Bad_value_generic (`Message (Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9csrcset\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: %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))))
+              (`Attr (`Bad_value_generic (`Message (Printf.sprintf "Bad value %s for attribute %s on element %s: %s for image %s is identical to %s for image %s." (q value) (q "srcset") (q element_name) dup_type (q url) (String.lowercase_ascii dup_type) (q first_url)))))
           | 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_typed collector
-                (`Attr (`Bad_value_generic (`Message (Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9csrcset\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: %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))))
+                (`Attr (`Bad_value_generic (`Message (Printf.sprintf "Bad value %s for attribute %s on element %s: %s for image %s is identical to %s for image %s." (q value) (q "srcset") (q element_name) dup_type (q url) (String.lowercase_ascii dup_type) (q first_url)))))
             | None ->
               Hashtbl.add seen_descriptors normalized url;
               if is_1x then Hashtbl.add seen_descriptors "explicit-1x" url
···
   (match !no_descriptor_url with
   | Some url when has_sizes ->
     Message_collector.add_typed collector
-      (`Attr (`Bad_value_generic (`Message (Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9csrcset\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: 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))))
+      (`Attr (`Bad_value_generic (`Message (Printf.sprintf "Bad value %s for attribute %s on element %s: No width specified for image %s. (When the %s attribute is present, all image candidate strings must specify a width.)" (q value) (q "srcset") (q element_name) (q url) (q "sizes")))))
   | _ -> ());
 
   (* 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_typed collector
-      (`Attr (`Bad_value_generic (`Message (Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9csrcset\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: When the \xe2\x80\x9csizes\xe2\x80\x9d attribute is present, all image candidate strings must specify a width." value element_name))));
+      (`Attr (`Bad_value_generic (`Message (Printf.sprintf "Bad value %s for attribute %s on element %s: When the %s attribute is present, all image candidate strings must specify a width." (q value) (q "srcset") (q element_name) (q "sizes")))));
 
   (* Check for mixing w and x descriptors *)
   if !has_w_descriptor && !has_x_descriptor then
     Message_collector.add_typed collector
-      (`Attr (`Bad_value_generic (`Message (Printf.sprintf "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9csrcset\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Mixing width and density descriptors is not allowed." value element_name))))
+      (`Attr (`Bad_value_generic (`Message (Printf.sprintf "Bad value %s for attribute %s on element %s: Mixing width and density descriptors is not allowed." (q value) (q "srcset") (q element_name)))))
 
 let start_element _state ~element collector =
   match element.Element.tag with

test/expected_message.ml

···
   require_severity = true;
 }
 
+(** Unicode ellipsis character *)
+let ellipsis = "\xe2\x80\xa6"
+
 (** Normalize Unicode curly quotes to ASCII for comparison *)
 let normalize_quotes s =
   let buf = Buffer.create (String.length s) in
···
     end
   done;
   Buffer.contents buf
+
+(** Unicode curly quotes *)
+let left_curly_quote = "\xe2\x80\x9c"
+let right_curly_quote = "\xe2\x80\x9d"
+
+(** Check if expected message (with potential ellipsis truncation) matches actual.
+    When expected has ellipsis followed by text in curly quotes, we check if actual
+    has a value that ends with that text.
+    This handles Nu validator's message truncation for long attribute values. *)
+let truncation_aware_match expected actual =
+  (* Look for pattern: left_curly_quote + ellipsis in expected *)
+  let quote_ellipsis = left_curly_quote ^ ellipsis in
+  try
+    let pos = Str.search_forward (Str.regexp_string quote_ellipsis) expected 0 in
+    (* Found quote+ellipsis pattern - extract what comes after ellipsis until closing curly quote *)
+    let start_after_ellipsis = pos + String.length quote_ellipsis in
+    let end_quote_pos =
+      try Str.search_forward (Str.regexp_string right_curly_quote) expected start_after_ellipsis
+      with Not_found -> String.length expected
+    in
+    let truncated_suffix = String.sub expected start_after_ellipsis (end_quote_pos - start_after_ellipsis) in
+
+    (* Build expected prefix (everything before the truncated quote) and suffix (everything after) *)
+    let prefix = String.sub expected 0 pos in
+    let suffix_start = end_quote_pos + String.length right_curly_quote in
+    let suffix =
+      if suffix_start < String.length expected then
+        String.sub expected suffix_start (String.length expected - suffix_start)
+      else ""
+    in
+
+    (* Check if actual starts with prefix and ends with suffix *)
+    let actual_starts_with_prefix =
+      String.length actual >= String.length prefix &&
+      String.sub actual 0 (String.length prefix) = prefix
+    in
+    let actual_ends_with_suffix =
+      String.length actual >= String.length suffix &&
+      String.sub actual (String.length actual - String.length suffix) (String.length suffix) = suffix
+    in
+
+    (* If prefix and suffix match, extract the middle (the quoted value in actual) *)
+    if actual_starts_with_prefix && actual_ends_with_suffix then begin
+      (* Find the quoted value in actual at the same position *)
+      let actual_quote_start = String.length prefix in
+      try
+        (* Check actual has left curly quote at expected position *)
+        if String.sub actual actual_quote_start (String.length left_curly_quote) = left_curly_quote then begin
+          let actual_value_start = actual_quote_start + String.length left_curly_quote in
+          let actual_value_end =
+            Str.search_forward (Str.regexp_string right_curly_quote) actual actual_value_start
+          in
+          let actual_value = String.sub actual actual_value_start (actual_value_end - actual_value_start) in
+          (* Check if actual value ends with the truncated suffix from expected *)
+          String.length actual_value >= String.length truncated_suffix &&
+          String.sub actual_value (String.length actual_value - String.length truncated_suffix) (String.length truncated_suffix) = truncated_suffix
+        end else false
+      with _ -> false
+    end else false
+  with Not_found ->
+    (* No ellipsis truncation pattern found *)
+    false
 
 (** Pattern matchers for Nu validator messages.
     Each returns (error_code option, element option, attribute option) *)
···
 
   (* Check message text *)
   let exact_text_match = actual_norm = expected_norm in
+  (* Truncation-aware match: expected may have ellipsis where actual has full value *)
+  let truncation_match = truncation_aware_match expected.message actual.Htmlrw_check.text in
   let substring_match =
     try let _ = Str.search_forward (Str.regexp_string expected_norm) actual_norm 0 in true
     with Not_found -> false
···
     Code_match
   else if exact_text_match then
     Message_match
+  else if truncation_match then
+    Message_match  (* Treat truncation match same as message match *)
   else if substring_match && not strictness.require_exact_message then
     Substring_match
   else