more

lib/html5_checker/datatype/dt_autocomplete.ml

···
     is_contact_details := true
   | _ -> ());
 
+  (* Check if any token in the list is shipping/billing *)
+  let find_shipping_billing tokens =
+    List.find_opt (fun t -> t = "shipping" || t = "billing") tokens
+  in
+
+  (* Check if any token in the list is a contact type *)
+  let find_contact_type tokens =
+    List.find_opt (fun t -> List.mem t contact_types) tokens
+  in
+
+  (* Check if any token in the list is a section-* indicator *)
+  let find_section tokens =
+    List.find_opt (fun t -> starts_with t "section-") tokens
+  in
+
   (* Process remaining tokens *)
-  let process_field_tokens = function
-    | [] -> Error "A list of autofill details tokens must contain an autofill field name"
+  let process_field_tokens tokens =
+    match tokens with
+    | [] -> Error "A list of autofill details tokens must contain an autofill field name."
     | [ "webauthn" ] ->
       Error
         "The token \"webauthn\" must not be the only token in a list of \
-         autofill detail tokens"
+         autofill detail tokens."
     | [ field_name ] ->
       if not (List.mem field_name all_field_names) then
         Error
           (Printf.sprintf
-             "The string \"%s\" is not a valid autofill field name"
+             "The string \"%s\" is not a valid autofill field name."
              field_name)
       else if !is_contact_details && not (List.mem field_name contact_field_names)
       then
         Error
           (Printf.sprintf
              "The autofill field name \"%s\" is not allowed in contact \
-              context"
+              context."
              field_name)
       else Ok ()
     | [ field_name; "webauthn" ] ->
       if not (List.mem field_name all_field_names) then
         Error
           (Printf.sprintf
-             "The string \"%s\" is not a valid autofill field name"
+             "The string \"%s\" is not a valid autofill field name."
              field_name)
       else if !is_contact_details && not (List.mem field_name contact_field_names)
       then
         Error
           (Printf.sprintf
              "The autofill field name \"%s\" is not allowed in contact \
-              context"
+              context."
              field_name)
       else Ok ()
     | token :: _ when List.mem token contact_types ->
       Error
         (Printf.sprintf
-           "The token \"%s\" must only appear before any autofill field names"
+           "The token \"%s\" must only appear before any autofill field names."
            token)
     | token :: _ when starts_with token "section-" ->
       Error
         "A \"section-*\" indicator must only appear as the first token in a \
-         list of autofill detail tokens"
+         list of autofill detail tokens."
     | "shipping" :: _ | "billing" :: _ as toks ->
       Error
         (Printf.sprintf
            "The token \"%s\" must only appear as either the first token in a \
             list of autofill detail tokens, or, if the first token is a \
-            \"section-*\" indicator, as the second token"
+            \"section-*\" indicator, as the second token."
            (List.hd toks))
     | _ :: "webauthn" :: _ :: _ ->
       Error
         "The token \"webauthn\" must only appear as the very last token in a \
-         list of autofill detail tokens"
-    | _ :: _ :: _ ->
-      Error
-        "A list of autofill details tokens must not contain more than one \
-         autofill field name"
+         list of autofill detail tokens."
+    | _ :: rest ->
+      (* Check if any remaining token is a section-* indicator - position error takes precedence *)
+      (match find_section rest with
+       | Some _ ->
+         Error
+           "A \"section-*\" indicator must only appear as the first token in a \
+            list of autofill detail tokens."
+       | None ->
+         (* Check if any remaining token is a contact type - position error takes precedence *)
+         match find_contact_type rest with
+         | Some ct_token ->
+           Error
+             (Printf.sprintf
+                "The token \"%s\" must only appear before any autofill field names."
+                ct_token)
+         | None ->
+           (* Check if any remaining token is shipping/billing - position error takes precedence *)
+           match find_shipping_billing rest with
+           | Some sb_token ->
+             Error
+               (Printf.sprintf
+                  "The token \"%s\" must only appear as either the first token in a \
+                   list of autofill detail tokens, or, if the first token is a \
+                   \"section-*\" indicator, as the second token."
+                  sb_token)
+           | None ->
+             Error
+               "A list of autofill details tokens must not contain more than one \
+                autofill field name.")
   in
   process_field_tokens !tokens
 
 (** Validate autocomplete value *)
 let validate_autocomplete s =
   let trimmed = trim_whitespace s in
-  if String.length trimmed = 0 then Error "Must not be empty"
+  if String.length trimmed = 0 then Error "Must not be empty."
   else if trimmed = "on" || trimmed = "off" then Ok ()
   else
     let tokens = split_on_whitespace trimmed in

lib/html5_checker/parse_error_bridge.ml

···
     Message.make_location ~line ~column ?system_id ()
   in
   let code_str = Html5rw.Parse_error_code.to_string code in
-  let message = match code with
+  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."
-    | _ -> Printf.sprintf "Parse error: %s" code_str
+      ("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.Tree_construction_error s ->
+        (* Check for control-character/noncharacter/surrogate with codepoint info *)
+        (try
+          if String.length s > 28 && String.sub s 0 28 = "control-character-in-input-s" then
+            let colon_pos = String.index s ':' in
+            let cp_str = String.sub s (colon_pos + 1) (String.length s - colon_pos - 1) in
+            let cp = int_of_string ("0x" ^ cp_str) in
+            (Printf.sprintf "Forbidden code point U+%04x." cp, "forbidden-codepoint")
+          else if String.length s > 25 && String.sub s 0 25 = "noncharacter-in-input-str" then
+            let colon_pos = String.index s ':' in
+            let cp_str = String.sub s (colon_pos + 1) (String.length s - colon_pos - 1) in
+            let cp = int_of_string ("0x" ^ cp_str) in
+            (Printf.sprintf "Forbidden code point U+%04x." cp, "forbidden-codepoint")
+          else if String.length s > 22 && String.sub s 0 22 = "surrogate-in-input-str" then
+            let colon_pos = String.index s ':' in
+            let cp_str = String.sub s (colon_pos + 1) (String.length s - colon_pos - 1) in
+            let cp = int_of_string ("0x" ^ cp_str) in
+            (Printf.sprintf "Forbidden code point U+%04x." cp, "forbidden-codepoint")
+          (* Character reference errors *)
+          else if String.length s > 28 && String.sub s 0 28 = "control-character-reference:" then
+            let cp_str = String.sub s 28 (String.length s - 28) in
+            let cp = int_of_string ("0x" ^ cp_str) in
+            if cp = 0x0D then
+              ("A numeric character reference expanded to carriage return.", "control-character-reference")
+            else
+              (Printf.sprintf "Character reference expands to a control character (U+%04x)." cp, "control-character-reference")
+          else if String.length s > 31 && String.sub s 0 31 = "noncharacter-character-referenc" then
+            let colon_pos = String.index s ':' in
+            let cp_str = String.sub s (colon_pos + 1) (String.length s - colon_pos - 1) in
+            let cp = int_of_string ("0x" ^ cp_str) in
+            (* U+FDD0-U+FDEF are "permanently unassigned" *)
+            if cp >= 0xFDD0 && cp <= 0xFDEF then
+              ("Character reference expands to a permanently unassigned code point.", "noncharacter-character-reference")
+            (* Astral noncharacters (planes 1-16) *)
+            else if cp >= 0x10000 then
+              (Printf.sprintf "Character reference expands to an astral non-character (U+%05x)." cp, "noncharacter-character-reference")
+            else
+              (Printf.sprintf "Character reference expands to a non-character (U+%04x)." cp, "noncharacter-character-reference")
+          else if String.length s > 36 && String.sub s 0 36 = "character-reference-outside-unicode-" then
+            let colon_pos = String.index s ':' in
+            let _ = String.sub s (colon_pos + 1) (String.length s - colon_pos - 1) in
+            ("Character reference outside the permissible Unicode range.", "character-reference-outside-unicode-range")
+          else if String.length s > 27 && String.sub s 0 27 = "surrogate-character-referen" then
+            let colon_pos = String.index s ':' in
+            let cp_str = String.sub s (colon_pos + 1) (String.length s - colon_pos - 1) in
+            let cp = int_of_string ("0x" ^ cp_str) in
+            (Printf.sprintf "Character reference expands to a surrogate (U+%04x)." cp, "surrogate-character-reference")
+          else if s = "no-p-element-in-scope" then
+            ("No \xe2\x80\x9cp\xe2\x80\x9d element in scope but a \xe2\x80\x9cp\xe2\x80\x9d end tag seen.", "no-p-element-in-scope")
+          else if s = "end-tag-p-implied-but-open-elements" then
+            ("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
+            (Printf.sprintf "Parse error: %s" s, s)
+        with _ -> (Printf.sprintf "Parse error: %s" s, s))
+    | _ -> (Printf.sprintf "Parse error: %s" code_str, code_str)
   in
   Message.error
     ~message
-    ~code:code_str
+    ~code:final_code
     ~location
     ()
 

lib/html5_checker/semantic/form_checker.ml

···
     match Dt_autocomplete.validate_autocomplete value with
     | Ok () -> ()
     | Error msg ->
+        (* Nu validator prefixes autocomplete errors with "Bad autocomplete detail tokens (any): " for select/textarea, but not for input *)
+        let reason = if element_name = "input" then msg else "Bad autocomplete detail tokens (any): " ^ msg in
         Message_collector.add_typed collector
           (Error_code.Bad_attr_value {
             element = element_name;
             attr = "autocomplete";
             value;
-            reason = msg
+            reason
           })
   end
 

lib/html5_checker/semantic/id_checker.ml

···
      so we pass None. In a full implementation, this would be passed
      from the parser. *)
   let location = None in
-  process_attrs state ~element:name ~attrs ~location collector
+  process_attrs state ~element:name ~attrs ~location collector;
+
+  (* Special check: map element must have matching id and name if both present *)
+  if name = "map" then begin
+    let id_opt = List.find_map (fun (n, v) -> if n = "id" then Some v else None) attrs in
+    let name_opt = List.find_map (fun (n, v) -> if n = "name" then Some v else None) attrs in
+    match id_opt, name_opt with
+    | Some id_val, Some name_val when id_val <> name_val ->
+        Message_collector.add_typed collector Error_code.Map_id_name_mismatch
+    | _ -> ()
+  end
 
 let end_element _state ~name:_ ~namespace:_ _collector =
   ()
···
 let end_document state collector =
   (* Check all ID references point to existing IDs *)
   List.iter (fun ref ->
-    if not (Hashtbl.mem state.ids ref.referenced_id) then
-      (* Use generic for dangling references - format may vary *)
-      Message_collector.add_typed collector
-        (Error_code.Generic {
-          message = Printf.sprintf "The %s attribute on the %s element refers to ID %s which does not exist in the document."
-            (Error_code.q ref.attribute) (Error_code.q ref.referring_element) (Error_code.q ref.referenced_id)
-        })
+    if not (Hashtbl.mem state.ids ref.referenced_id) then begin
+      (* Use specific error for list attribute on input *)
+      if ref.attribute = "list" && ref.referring_element = "input" then
+        Message_collector.add_typed collector Error_code.List_attr_requires_datalist
+      else
+        (* Use generic for dangling references - format may vary *)
+        Message_collector.add_typed collector
+          (Error_code.Generic {
+            message = Printf.sprintf "The %s attribute on the %s element refers to ID %s which does not exist in the document."
+              (Error_code.q ref.attribute) (Error_code.q ref.referring_element) (Error_code.q ref.referenced_id)
+          })
+    end
   ) state.references;
 
   (* Check all usemap references point to existing map names *)

lib/html5_checker/semantic/lang_detecting_checker.ml

···
   | "zh-tw" -> "zh-hant"
   | _ -> code
 
+(* Traditional Chinese-only characters (simplified versions don't exist) *)
+(* These are characters that were simplified in Simplified Chinese *)
+let traditional_chars = [|
+  0x570B; (* 國 -> 国 *)
+  0x5B78; (* 學 -> 学 *)
+  0x8AAA; (* 說 -> 说 *)
+  0x66F8; (* 書 -> 书 *)
+  0x8A9E; (* 語 -> 语 *)
+  0x6642; (* 時 -> 时 *)
+  0x6703; (* 會 -> 会 *)
+  0x7D93; (* 經 -> 经 *)
+  0x6A5F; (* 機 -> 机 *)
+  0x767C; (* 發 -> 发 *)
+  0x554F; (* 問 -> 问 *)
+  0x6578; (* 數 -> 数 *)
+  0x5BE6; (* 實 -> 实 *)
+  0x958B; (* 開 -> 开 *)
+  0x95DC; (* 關 -> 关 *)
+  0x9577; (* 長 -> 长 *)
+  0x9AD4; (* 體 -> 体 *)
+  0x9EDE; (* 點 -> 点 *)
+  0x96FB; (* 電 -> 电 *)
+  0x8CC7; (* 資 -> 资 *)
+  0x7FA9; (* 義 -> 义 *)
+  0x8B93; (* 讓 -> 让 *)
+  0x9054; (* 達 -> 达 *)
+  0x71DF; (* 營 -> 营 *)
+  0x8655; (* 處 -> 处 *)
+  0x6771; (* 東 -> 东 *)
+  0x8209; (* 舉 -> 举 *)
+  0x8A18; (* 記 -> 记 *)
+  0x5099; (* 備 -> 备 *)
+  0x5354; (* 協 -> 协 *)
+  0x8FA6; (* 辦 -> 办 *)
+  0x8457; (* 著 -> 着 *)
+  0x8F09; (* 載 -> 载 *)
+  0x52D9; (* 務 -> 务 *)
+  0x7121; (* 無 -> 无 *)
+  0x5F9E; (* 從 -> 从 *)
+  0x8B58; (* 識 -> 识 *)
+  0x8207; (* 與 -> 与 *)
+  0x78BA; (* 確 -> 确 *)
+  0x904E; (* 過 -> 过 *)
+  0x8A72; (* 該 -> 该 *)
+  0x9810; (* 預 -> 预 *)
+  0x7576; (* 當 -> 当 *)
+  0x5831; (* 報 -> 报 *)
+  0x9054; (* 達 -> 达 *)
+  0x91AB; (* 醫 -> 医 *)
+  0x5718; (* 團 -> 团 *)
+  0x8B70; (* 議 -> 议 *)
+  0x7D71; (* 統 -> 统 *)
+  0x898F; (* 規 -> 规 *)
+|]
+
+(* Check if text contains enough Traditional Chinese characters *)
+let is_traditional_chinese text =
+  let count = ref 0 in
+  let total = ref 0 in
+  let decoder = Uutf.decoder ~encoding:`UTF_8 (`String text) in
+  let rec process () =
+    if !total >= 1000 then ()  (* Sample first 1000 chars *)
+    else match Uutf.decode decoder with
+    | `Await | `End -> ()
+    | `Malformed _ -> process ()
+    | `Uchar uchar ->
+        let code = Uchar.to_int uchar in
+        (* Count CJK characters *)
+        if code >= 0x4E00 && code <= 0x9FFF then begin
+          incr total;
+          (* Check if it's a Traditional-only character *)
+          if Array.exists (fun c -> c = code) traditional_chars then
+            incr count
+        end;
+        process ()
+  in
+  process ();
+  (* If > 2% are Traditional-only characters, it's Traditional Chinese *)
+  !total > 100 && (float_of_int !count /. float_of_int !total) > 0.02
+
 let start_element state ~name ~namespace ~attrs _collector =
   let name_lower = String.lowercase_ascii name in
   let ns = Option.value namespace ~default:"" in
···
         let original_declared = match state.html_lang with
           | Some l -> l
           | None -> ""
+        in
+        (* Correct for Traditional vs Simplified Chinese misdetection *)
+        let detected_lang =
+          if detected_lang = "zh-cn" && is_traditional_chinese text then "zh-tw"
+          else detected_lang
         in
         let detected_code = detected_lang in  (* Keep full code like zh-tw *)
         let detected_name = get_language_name detected_lang in

lib/html5_checker/specialized/aria_checker.ml

···
   mutable stack : stack_node list;
   mutable has_active_tab : bool;  (* Whether document has role=tab with aria-selected=true *)
   mutable has_tabpanel : bool;    (* Whether document has role=tabpanel elements *)
+  mutable visible_main_count : int;  (* Count of visible elements with role=main *)
 }
 
-let create () = { stack = []; has_active_tab = false; has_tabpanel = false }
+let create () = { stack = []; has_active_tab = false; has_tabpanel = false; visible_main_count = 0 }
 
 let reset state =
   state.stack <- [];
   state.has_active_tab <- false;
-  state.has_tabpanel <- false
+  state.has_tabpanel <- false;
+  state.visible_main_count <- 0
 
 (** Check if any ancestor has one of the required roles. *)
 let has_required_ancestor_role state required_roles =
···
         if aria_selected = Some "true" then state.has_active_tab <- true
       end;
       if List.mem "tabpanel" explicit_roles then state.has_tabpanel <- true;
+
+      (* Track visible main elements (explicit role=main or implicit main role) *)
+      let is_hidden =
+        let aria_hidden = List.assoc_opt "aria-hidden" attrs in
+        aria_hidden = Some "true"
+      in
+      if not is_hidden then begin
+        (* Check explicit role *)
+        if List.mem "main" explicit_roles then
+          state.visible_main_count <- state.visible_main_count + 1
+        (* Check implicit role from <main> element *)
+        else if name_lower = "main" then
+          state.visible_main_count <- state.visible_main_count + 1
+      end;
 
       (* Check br/wbr role restrictions - only none/presentation allowed *)
       if (name_lower = "br" || name_lower = "wbr") && explicit_roles <> [] then begin
···
     Message_collector.add_error collector
       ~message:"Every active \xe2\x80\x9crole=tab\xe2\x80\x9d element must have a corresponding \xe2\x80\x9crole=tabpanel\xe2\x80\x9d element."
       ~code:"tab-without-tabpanel"
-      ()
+      ();
+
+  (* Check for multiple visible main elements *)
+  if state.visible_main_count > 1 then
+    Message_collector.add_typed collector Error_code.Multiple_main_visible
 
 let checker = (module struct
   type nonrec state = state

lib/html5_checker/specialized/attr_restrictions_checker.ml

···
               Printf.sprintf "Bad value \xe2\x80\x9c\xe2\x80\x9d for attribute \xe2\x80\x9c%s\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: The empty string is not a valid non-negative integer."
                 attr_name name
             else if String.contains attr_value '%' then
-              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: Expected a digit but saw \xe2\x80\x9c%%\xe2\x80\x9d instead."
+              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 non-negative integer: Expected a digit but saw \xe2\x80\x9c%%\xe2\x80\x9d instead."
                 attr_value attr_name name
             else if String.length attr_value > 0 && attr_value.[0] = '-' then
-              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: The value must be non-negative."
+              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 non-negative integer: Expected a digit but saw \xe2\x80\x9c-\xe2\x80\x9d instead."
                 attr_value attr_name name
             else
               (* Find first non-digit character *)
···
               in
               match bad_char with
               | Some c ->
-                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: Expected a digit but saw \xe2\x80\x9c%c\xe2\x80\x9d instead."
+                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 non-negative integer: Expected a digit but saw \xe2\x80\x9c%c\xe2\x80\x9d instead."
                   attr_value attr_name name c
               | None ->
-                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: Expected a digit."
+                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 non-negative integer: Expected a digit."
                   attr_value attr_name name
           in
           Message_collector.add_error collector
···
         List.iter (fun key ->
           if count_codepoints key > 1 then
             Message_collector.add_error collector
-              ~message:(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: The space-separated list of key labels contains a value \xe2\x80\x9c%s\xe2\x80\x9d that consists of more than a single code point."
-                attr_value attr_name name key)
+              ~message:(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 key label list: Key label has multiple characters. Each key label must be a single character."
+                attr_value attr_name name)
               ~code:"bad-attribute-value"
               ~element:name ~attribute:attr_name ()
         ) keys;
···
           | k :: rest ->
             if List.mem k seen then
               Message_collector.add_error collector
-                ~message:(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: Duplicate key label."
+                ~message:(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 key label list: Duplicate key label. Each key label must be unique."
                   attr_value attr_name name)
                 ~code:"bad-attribute-value"
                 ~element:name ~attribute:attr_name ()

lib/html5_checker/specialized/datetime_checker.ml

···
           minute <> 0 && minute <> 30 && minute <> 45
         in
         if unusual_range then
-          TzWarning "unusual timezone offset"
+          TzWarning "Hours in time zone designator should be from \"-12:00\" to \"+14:00\""
         else if unusual_minutes then
-          TzWarning "unusual timezone offset minutes"
+          TzWarning "Minutes in time zone designator should be either \"00\", \"30\", or \"45\"."
         else
           TzOk
       end
···
   match validate_datetime_with_timezone value with
   | DtOk -> Ok  (* Valid datetime with timezone *)
   | DtWarning w ->
-    (* Valid but with warning *)
-    Warning (Printf.sprintf "Possibly mistyped 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."
+    (* Valid but with warning - format matches Nu validator *)
+    Warning (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 datetime with timezone: %s Bad date: The literal did not satisfy the date format."
       value attr_name element_name w)
   | DtError tz_error ->
     (* Try just date - valid for all elements *)
···
     | (true, _) ->
       (* Date is valid, but check for suspicious year (5+ digits or old year) *)
       if has_suspicious_year value || has_old_year value then begin
-        let date_msg = "Year may be mistyped." in
+        let date_msg = "Bad date: Year may be mistyped." in
         let tz_msg = Printf.sprintf "Bad datetime with timezone: %s." tz_error in
-        Warning (Printf.sprintf "Possibly mistyped 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"
+        Warning (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)
       end else
         Ok  (* Valid date with normal year *)
···
                     match validate_duration value with
                     | (true, _) -> Ok  (* Valid duration P... *)
                     | (false, _) ->
-                      let tz_msg = Printf.sprintf "Bad datetime with timezone: %s." tz_error in
-                      let date_msg = match date_error with
-                        | 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)
+                      (* Use simplified message for time element matching Nu validator format *)
+                      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: Bad time-datetime: The literal did not satisfy the time-datetime format."
+                        value attr_name element_name)
       end
       else begin
         (* del/ins only allow date or datetime-with-timezone *)

lib/html5_checker/specialized/importmap_checker.ml

···
   | SlashKeyWithoutSlashValue of string (* property name where slash key doesn't have slash value *)
   | InvalidScopeKey (* scope key is not a valid URL *)
   | InvalidScopeValue of string (* scope value is not a valid URL *)
+  | ScopeValueNotObject (* a value inside scopes is not a JSON object *)
 
 (** Check if a string looks like a valid URL-like specifier for importmaps *)
 let is_valid_url_like s =
···
                   | JNull -> ()
                   | _ -> add_error (NotString ("scopes[" ^ skey ^ "][" ^ sikey ^ "]"))
                 ) scope_imports
-              | _ -> add_error (NotObject ("scopes[" ^ skey ^ "]"))
+              | _ -> add_error ScopeValueNotObject
             ) scope_members
           | _ -> add_error (NotObject "scopes")
         end
···
     Printf.sprintf "The value of the \xe2\x80\x9c%s\xe2\x80\x9d property within the content of a \xe2\x80\x9cscript\xe2\x80\x9d element with a \xe2\x80\x9ctype\xe2\x80\x9d attribute whose value is \xe2\x80\x9cimportmap\xe2\x80\x9d must be a JSON object." prop
   | NotString _ ->
     "A specifier map defined in a \xe2\x80\x9cimports\xe2\x80\x9d property within the content of a \xe2\x80\x9cscript\xe2\x80\x9d element with a \xe2\x80\x9ctype\xe2\x80\x9d attribute whose value is \xe2\x80\x9cimportmap\xe2\x80\x9d must only contain string values."
-  | ForbiddenProperty prop ->
-    Printf.sprintf "The \xe2\x80\x9c%s\xe2\x80\x9d property within the content of a \xe2\x80\x9cscript\xe2\x80\x9d element with a \xe2\x80\x9ctype\xe2\x80\x9d attribute whose value is \xe2\x80\x9cimportmap\xe2\x80\x9d is not an allowed property." prop
+  | ForbiddenProperty _ ->
+    "A \xe2\x80\x9cscript\xe2\x80\x9d element with a \xe2\x80\x9ctype\xe2\x80\x9d attribute whose value is \xe2\x80\x9cimportmap\xe2\x80\x9d must contain a JSON object with no properties other than \xe2\x80\x9cimports\xe2\x80\x9d, \xe2\x80\x9cscopes\xe2\x80\x9d, and \xe2\x80\x9cintegrity\xe2\x80\x9d."
   | SlashKeyWithoutSlashValue prop ->
     Printf.sprintf "A specifier map defined in a \xe2\x80\x9c%s\xe2\x80\x9d property within the content of a \xe2\x80\x9cscript\xe2\x80\x9d element with a \xe2\x80\x9ctype\xe2\x80\x9d attribute whose value is \xe2\x80\x9cimportmap\xe2\x80\x9d must have values that end with \xe2\x80\x9c/\xe2\x80\x9d when its corresponding key ends with \xe2\x80\x9c/\xe2\x80\x9d." prop
   | InvalidScopeKey ->
     "The value of the \xe2\x80\x9cscopes\xe2\x80\x9d property within the content of a \xe2\x80\x9cscript\xe2\x80\x9d element with a \xe2\x80\x9ctype\xe2\x80\x9d attribute whose value is \xe2\x80\x9cimportmap\xe2\x80\x9d must be a JSON object whose keys are valid URL strings."
   | InvalidScopeValue _ ->
     "A specifier map defined in a \xe2\x80\x9cscopes\xe2\x80\x9d property within the content of a \xe2\x80\x9cscript\xe2\x80\x9d element with a \xe2\x80\x9ctype\xe2\x80\x9d attribute whose value is \xe2\x80\x9cimportmap\xe2\x80\x9d must only contain valid URL values."
+  | ScopeValueNotObject ->
+    "The value of the \xe2\x80\x9cscopes\xe2\x80\x9d property within the content of a \xe2\x80\x9cscript\xe2\x80\x9d element with a \xe2\x80\x9ctype\xe2\x80\x9d attribute whose value is \xe2\x80\x9cimportmap\xe2\x80\x9d must be a JSON object whose values are also JSON objects."
 
 let end_element state ~name ~namespace collector =
   if namespace <> None then ()

lib/html5_checker/specialized/language_checker.ml

···
       | Some (deprecated, replacement) ->
           Message_collector.add_warning collector
             ~message:(Printf.sprintf
-              "The language tag \xe2\x80\x9c%s\xe2\x80\x9d is deprecated. Use \xe2\x80\x9c%s\xe2\x80\x9d instead."
-              deprecated replacement)
+              "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 language tag: The language subtag \xe2\x80\x9c%s\xe2\x80\x9d is deprecated. Use \xe2\x80\x9c%s\xe2\x80\x9d instead."
+              value attribute element deprecated replacement)
             ~code:"deprecated-lang"
             ?location
             ~element
-            ~attribute:"lang"
+            ~attribute
             ()
       | None -> ()
 

lib/html5_checker/specialized/url_checker.ml

···
     let _ = contains_invalid_unicode decoded in
     None
   with Exit ->
-    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 URL: Invalid host."
+    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 URL: Invalid host: A label or domain name contains disallowed characters.."
       url attr_name element_name)
 
 (** Check if string contains a character (checking both ASCII and UTF-8 fullwidth variants). *)
···
     end else
       None
 
-(** Check for data: URI with fragment - this is a warning (RFC 2397 forbids fragments). *)
-let check_data_uri_fragment url attr_name element_name =
+(** Check for data: URI with fragment - this is a warning (RFC 2397 forbids fragments).
+    The is_absolute_url parameter controls whether to use "Bad URL:" or "Bad absolute URL:" in the message. *)
+let check_data_uri_fragment ?(is_absolute_url=false) url attr_name element_name =
   match extract_scheme url with
   | None -> None
   | Some scheme ->
     if scheme = "data" && String.contains url '#' 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 URL: Fragment is not allowed for data: URIs according to RFC 2397."
-        url attr_name element_name)
+      let url_type = if is_absolute_url then "Bad absolute URL:" else "Bad URL:" in
+      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: %s Fragment is not allowed for data: URIs according to RFC 2397."
+        url attr_name element_name url_type)
     else
       None
 
···
       let after_colon = String.sub url (colon_pos + 1) (String.length url - colon_pos - 1) in
       (* data: URLs should NOT start with / - format is data:[mediatype][;base64],data *)
       if String.length after_colon > 0 && after_colon.[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 URL: Invalid %s: URL."
-          url attr_name element_name scheme)
+        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 URL: Expected a token character or a semicolon but saw \xe2\x80\x9c/\xe2\x80\x9d instead."
+          url attr_name element_name)
       else
         None
     end else
···
       (* Get scheme data (after the colon) *)
       let colon_pos = String.index url ':' in
       let scheme_data = String.sub url (colon_pos + 1) (String.length url - colon_pos - 1) in
+      (* Check for tab in scheme data *)
+      if String.contains scheme_data '\t' 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 URL: Illegal character in scheme data: tab is not allowed."
+          url attr_name element_name)
+      (* Check for newline in scheme data *)
+      else if String.contains scheme_data '\n' 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 URL: Illegal character in scheme data: line break is not allowed."
+          url attr_name element_name)
+      (* Check for carriage return in scheme data *)
+      else if String.contains scheme_data '\r' 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 URL: Illegal character in scheme data: line break is not allowed."
+          url attr_name element_name)
       (* Check for space in scheme data *)
-      if String.contains scheme_data ' ' then
+      else if String.contains scheme_data ' ' 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 URL: Illegal character in scheme data: space is not allowed."
           url attr_name element_name)
       else
···
   try
     let fragment_start = String.index url '#' in
     let fragment = String.sub url (fragment_start + 1) (String.length url - fragment_start - 1) in
+    (* Check for backslash in fragment *)
+    if String.contains fragment '\\' 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 URL: Illegal character in fragment: \xe2\x80\x9c\\\xe2\x80\x9d is not allowed."
+        url attr_name element_name)
     (* Check for second hash in fragment *)
-    if String.contains fragment '#' then
+    else if String.contains fragment '#' 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 URL: Illegal character in fragment: \xe2\x80\x9c#\xe2\x80\x9d is not allowed."
         url attr_name element_name)
     (* Check for space in fragment *)
···
       else if String.contains userinfo ' ' 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 URL: Illegal character in user or password: space is not allowed."
           url attr_name element_name)
-      else
-        (* Check for non-ASCII characters (like emoji) *)
-        let has_non_ascii = String.exists (fun c -> Char.code c > 127) userinfo in
-        if has_non_ascii 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 URL: Illegal character in user or password."
-            url attr_name element_name)
-        else
+      else begin
+        (* Check for non-ASCII characters (like emoji) using UTF-8 decoding *)
+        let find_non_ascii_char userinfo =
+          let decoder = Uutf.decoder ~encoding:`UTF_8 (`String userinfo) in
+          let rec find () =
+            match Uutf.decode decoder with
+            | `End | `Await -> None
+            | `Malformed _ -> find ()
+            | `Uchar uchar ->
+                let code = Uchar.to_int uchar in
+                (* Check if character is not allowed in userinfo *)
+                (* Per URL Standard: only ASCII letters, digits, and certain symbols allowed *)
+                if code > 127 then begin
+                  let buf = Buffer.create 8 in
+                  Buffer.add_utf_8_uchar buf uchar;
+                  Some (Buffer.contents buf)
+                end else find ()
+          in
+          find ()
+        in
+        match find_non_ascii_char userinfo with
+        | Some bad_char ->
+          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 URL: Illegal character in user or password: \xe2\x80\x9c%s\xe2\x80\x9d is not allowed."
+            url attr_name element_name bad_char)
+        | None ->
           (* Check for other invalid chars *)
           let invalid = List.find_opt (fun c -> String.contains userinfo c) invalid_userinfo_chars in
           match invalid with
···
             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 URL: Illegal character in user or password: \xe2\x80\x9c%c\xe2\x80\x9d is not allowed."
               url attr_name element_name c)
           | None -> None
+      end
   with _ -> None
 
 (** Attributes where empty URL is an error.
···
         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 URL: Illegal character: leading/trailing ASCII whitespace."
           original_url attr_name element_name)
       else None
-    (* Check for newlines/tabs *)
-    else if String.contains url '\n' || String.contains url '\r' || String.contains url '\t' 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 URL: Tab, new line or carriage return found."
-        url attr_name element_name)
+    (* Check scheme data for non-special schemes FIRST - handles tab/newline/CR in scheme data *)
     else begin
+      match check_scheme_data url attr_name element_name with
+      | Some err -> Some err
+      | None ->
+      (* Check for newlines/tabs in special scheme URLs *)
+      if String.contains url '\n' || String.contains url '\r' || String.contains url '\t' 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 URL: Tab, new line or carriage return found."
+          url attr_name element_name)
+      else begin
       (* Check for relative URL issues first *)
       match check_relative_url url attr_name element_name with
       | Some err -> Some err
···
           url attr_name element_name)
       else
 
-      (* Check scheme data for non-special schemes *)
-      match check_scheme_data url attr_name element_name with
-      | Some err -> Some err
-      | None ->
-
       (* Check path segment for illegal characters *)
       match check_path_segment url attr_name element_name with
       | Some err -> Some err
···
         match host_opt with
         | Some host -> validate_host host url attr_name element_name scheme_str
         | None -> None
+    end
     end
   end
 
···
                 ()
             | Some _ ->
               (* Check for data: URI with fragment - emit warning *)
-              (match check_data_uri_fragment url "value" name with
+              (* input[type=url] uses "Bad absolute URL:" format *)
+              (match check_data_uri_fragment ~is_absolute_url:true url "value" name with
               | Some warn_msg ->
                 Message_collector.add_warning collector
                   ~message:warn_msg
···
       end
     end;
     (* Check microdata itemtype and itemid attributes for data: URI fragments *)
+    (* Microdata uses "Bad absolute URL:" format *)
     let itemtype_opt = get_attr_value "itemtype" attrs in
     (match itemtype_opt with
     | Some url when String.trim url <> "" ->
-      (match check_data_uri_fragment url "itemtype" name with
+      (match check_data_uri_fragment ~is_absolute_url:true url "itemtype" name with
       | Some warn_msg ->
         Message_collector.add_warning collector
           ~message:warn_msg
···
           ()
       | None -> ())
     | _ -> ());
+    (* itemid uses "Bad URL:" format (not "Bad absolute URL:") *)
     let itemid_opt = get_attr_value "itemid" attrs in
     (match itemid_opt with
     | Some url when String.trim url <> "" ->

lib/html5rw/parser/parser_tree_builder.ml

···
 let close_p_element t =
   generate_implied_end_tags t ~except:"p" ();
   (match current_node t with
-   | Some n when n.Dom.name <> "p" -> parse_error t "expected-p"
+   | Some n when n.Dom.name <> "p" -> parse_error t "end-tag-p-implied-but-open-elements"
    | _ -> ());
   pop_until_tag t "p"
 
···
     end
   | Token.Tag { kind = Token.End; name = "p"; _ } ->
     if not (has_element_in_button_scope t "p") then begin
-      parse_error t "unexpected-end-tag";
+      parse_error t "no-p-element-in-scope";
       ignore (insert_element t "p" ~push:true [])
     end;
     close_p_element t
···
     t.frameset_ok <- false;
     t.mode <- Parser_insertion_mode.In_table
   | Token.Tag { kind = Token.End; name = "br"; _ } ->
-    parse_error t "unexpected-end-tag";
+    parse_error t "end-tag-br";
     reconstruct_active_formatting t;
     ignore (insert_element t "br" ~push:true []);
     pop_current t;

lib/html5rw/tokenizer/tokenizer_impl.ml

···
        code = 0x0B ||
        (code >= 0x0E && code <= 0x1F) ||
        code = 0x7F then
-      error t "control-character-in-input-stream"
+      error t (Printf.sprintf "control-character-in-input-stream:%04x" code)
   in
 
 
···
         error t "null-character-reference";
         replacement_char
       end else if code > 0x10FFFF then begin
-        error t "character-reference-outside-unicode-range";
+        error t (Printf.sprintf "character-reference-outside-unicode-range:%x" code);
         replacement_char
       end else if code >= 0xD800 && code <= 0xDFFF then begin
-        error t "surrogate-character-reference";
+        error t (Printf.sprintf "surrogate-character-reference:%04x" code);
         replacement_char
       end else if (code >= 0xFDD0 && code <= 0xFDEF) ||
                   List.mem code [0xFFFE; 0xFFFF; 0x1FFFE; 0x1FFFF; 0x2FFFE; 0x2FFFF;
···
                                  0x9FFFE; 0x9FFFF; 0xAFFFE; 0xAFFFF; 0xBFFFE; 0xBFFFF;
                                  0xCFFFE; 0xCFFFF; 0xDFFFE; 0xDFFFF; 0xEFFFE; 0xEFFFF;
                                  0xFFFFE; 0xFFFFF; 0x10FFFE; 0x10FFFF] then begin
-        error t "noncharacter-character-reference";
+        error t (Printf.sprintf "noncharacter-character-reference:%05x" code);
         Entities.Numeric_ref.codepoint_to_utf8 code
       end else if (code >= 0x01 && code <= 0x08) || code = 0x0B ||
                   (code >= 0x0D && code <= 0x1F) ||
                   (code >= 0x7F && code <= 0x9F) then begin
-        error t "control-character-reference";
+        error t (Printf.sprintf "control-character-reference:%04x" code);
         (* Apply Windows-1252 replacement table for 0x80-0x9F *)
         match Entities.Numeric_ref.find_replacement code with
         | Some replacement -> Entities.Numeric_ref.codepoint_to_utf8 replacement

lib/html5rw/tokenizer/tokenizer_stream.ml

···
 let check_utf8_codepoint t lead_byte =
   let b0 = Char.code lead_byte in
   if b0 < 0x80 then
-    (* ASCII - no surrogates or noncharacters possible in this range except control chars *)
+    (* ASCII - control characters are handled in tokenizer_impl.ml *)
     ()
   else if b0 >= 0xC2 && b0 <= 0xDF then begin
     (* 2-byte sequence: 110xxxxx 10xxxxxx -> U+0080 to U+07FF *)
···
       (* C1 controls: U+0080 to U+009F *)
       if cp >= 0x80 && cp <= 0x9F then
         (match t.error_callback with
-        | Some cb -> cb "control-character-in-input-stream"
+        | Some cb -> cb (Printf.sprintf "control-character-in-input-stream:%04x" cp)
         | None -> ())
     | Some c1 ->
       push_back_char t c1
···
         (* Check for surrogates and noncharacters *)
         (match t.error_callback with
         | Some cb ->
-          if is_surrogate cp then cb "surrogate-in-input-stream"
-          else if is_noncharacter cp then cb "noncharacter-in-input-stream"
+          if is_surrogate cp then cb (Printf.sprintf "surrogate-in-input-stream:%04x" cp)
+          else if is_noncharacter cp then cb (Printf.sprintf "noncharacter-in-input-stream:%04x" cp)
         | None -> ())
       | Some c2 ->
         push_back_char t c2;
···
           (* Check for noncharacters (no surrogates in 4-byte range) *)
           (match t.error_callback with
           | Some cb ->
-            if is_noncharacter cp then cb "noncharacter-in-input-stream"
+            if is_noncharacter cp then cb (Printf.sprintf "noncharacter-in-input-stream:%05x" cp)
           | None -> ())
         | Some c3 ->
           push_back_char t c3;