more

lib/html5_checker/checker_registry.ml

···
   Hashtbl.replace reg "autofocus" Autofocus_checker.checker;
   Hashtbl.replace reg "option" Option_checker.checker;
   Hashtbl.replace reg "language" Language_checker.checker;
+  Hashtbl.replace reg "microdata" Microdata_checker.checker;
   (* Hashtbl.replace reg "table" Table_checker.checker; *)
   (* Hashtbl.replace reg "heading" Heading_checker.checker; *)
-  (* Hashtbl.replace reg "microdata" Microdata_checker.checker; *)
   (* Hashtbl.replace reg "content" Content_checker.checker; *)
   reg
 

lib/html5_checker/datatype/dt_media_query.ml

···
-(** Media query validation - simplified implementation *)
+(** Media query validation - strict implementation for HTML5 conformance *)
 
-(** Media types *)
-let media_types =
+(** Valid media types per Media Queries Level 4 spec *)
+let valid_media_types =
   [
     "all";
     "screen";
     "print";
     "speech";
+  ]
+
+(** Deprecated media types that should trigger an error *)
+let deprecated_media_types =
+  [
     "aural";
     "braille";
     "handheld";
···
     "embossed";
   ]
 
-(** Media query keywords *)
-let media_keywords = [ "and"; "or"; "not"; "only" ]
+(** Deprecated media features that should trigger an error *)
+let deprecated_media_features =
+  [
+    "device-width";
+    "device-height";
+    "device-aspect-ratio";
+  ]
+
+(** Valid media features *)
+let valid_media_features =
+  [
+    (* Dimensions *)
+    "width"; "min-width"; "max-width";
+    "height"; "min-height"; "max-height";
+    "aspect-ratio"; "min-aspect-ratio"; "max-aspect-ratio";
+    (* Display quality *)
+    "resolution"; "min-resolution"; "max-resolution";
+    "scan"; "grid"; "update"; "overflow-block"; "overflow-inline";
+    (* Color *)
+    "color"; "min-color"; "max-color";
+    "color-index"; "min-color-index"; "max-color-index";
+    "monochrome"; "min-monochrome"; "max-monochrome";
+    "color-gamut";
+    (* Interaction *)
+    "pointer"; "any-pointer"; "hover"; "any-hover";
+    (* Scripting *)
+    "scripting";
+    (* Light/dark *)
+    "prefers-color-scheme"; "prefers-contrast"; "prefers-reduced-motion";
+    "prefers-reduced-transparency";
+    (* Display mode *)
+    "display-mode";
+    (* Inverted colors *)
+    "inverted-colors";
+    (* Forced colors *)
+    "forced-colors";
+    (* Orientation *)
+    "orientation";
+  ]
+
+(** Valid length units *)
+let valid_length_units = ["px"; "em"; "rem"; "vh"; "vw"; "vmin"; "vmax"; "cm"; "mm"; "in"; "pt"; "pc"; "ch"; "ex"]
+
+(** Valid resolution units *)
+let valid_resolution_units = ["dpi"; "dpcm"; "dppx"; "x"]
+
+(** Media query keywords (unused but kept for documentation) *)
+let _media_keywords = [ "and"; "not"; "only" ]
 
 (** Check if character is whitespace *)
 let is_whitespace c = c = ' ' || c = '\t' || c = '\n' || c = '\r'
···
 let is_ident_char c =
   is_ident_start c || (c >= '0' && c <= '9')
 
+(** Unicode case-fold for Turkish dotted-I etc *)
+let lowercase_unicode s =
+  (* Handle special case: U+0130 LATIN CAPITAL LETTER I WITH DOT ABOVE -> i *)
+  let buf = Buffer.create (String.length s) in
+  let i = ref 0 in
+  while !i < String.length s do
+    let c = s.[!i] in
+    if c = '\xc4' && !i + 1 < String.length s && s.[!i + 1] = '\xb0' then begin
+      (* U+0130 -> 'i' + U+0307 (combining dot above), but for simplicity just 'i' followed by U+0307 *)
+      Buffer.add_string buf "i\xcc\x87";
+      i := !i + 2
+    end else begin
+      Buffer.add_char buf (Char.lowercase_ascii c);
+      incr i
+    end
+  done;
+  Buffer.contents buf
+
 (** Check balanced parentheses *)
 let check_balanced_parens s =
   let rec check depth i =
     if i >= String.length s then
       if depth = 0 then Ok ()
-      else Error "Unbalanced parentheses: unclosed '('"
+      else Error "Parse Error."
     else
       let c = s.[i] in
       match c with
       | '(' -> check (depth + 1) (i + 1)
       | ')' ->
-        if depth = 0 then Error "Unbalanced parentheses: unexpected ')'"
+        if depth = 0 then Error "Parse Error."
         else check (depth - 1) (i + 1)
       | _ -> check depth (i + 1)
   in
   check 0 0
 
-(** Extract words (identifiers and keywords) from media query *)
-let extract_words s =
-  let words = ref [] in
-  let buf = Buffer.create 16 in
-  let in_parens = ref 0 in
+(** Strict media query validation *)
+let rec validate_media_query_strict s =
+  let s = String.trim s in
+  if String.length s = 0 then Error "Parse Error."
+  else begin
+    (* Check for empty commas *)
+    if s = "," then Error "Parse Error."
+    else if String.length s > 0 && s.[0] = ',' then Error "Parse Error."
+    else if String.length s > 0 && s.[String.length s - 1] = ',' then Error "Parse Error."
+    else if String.contains s ',' then begin
+      (* Check for empty queries between commas *)
+      let parts = String.split_on_char ',' s in
+      if List.exists (fun p -> String.trim p = "") parts then Error "Parse Error."
+      else begin
+        (* Validate each media query in the list *)
+        let rec validate_all = function
+          | [] -> Ok ()
+          | part :: rest ->
+            match validate_media_query_strict (String.trim part) with
+            | Ok () -> validate_all rest
+            | Error e -> Error e
+        in
+        validate_all parts
+      end
+    end else begin
+      (* Single media query *)
+      match check_balanced_parens s with
+      | Error e -> Error e
+      | Ok () ->
+        (* Check for "and" or "and(" at end *)
+        let trimmed = String.trim s in
+        if String.length trimmed >= 3 then begin
+          let suffix = String.sub trimmed (String.length trimmed - 3) 3 in
+          if String.lowercase_ascii suffix = "and" then
+            Error "Parse Error."
+          else if String.length trimmed >= 4 then begin
+            let suffix4 = String.sub trimmed (String.length trimmed - 4) 4 in
+            if String.lowercase_ascii suffix4 = "and(" then
+              Error "Parse Error."
+            else
+              validate_media_query_content trimmed
+          end else
+            validate_media_query_content trimmed
+        end else
+          validate_media_query_content trimmed
+    end
+  end
 
-  for i = 0 to String.length s - 1 do
-    let c = s.[i] in
-    match c with
-    | '(' ->
-      if Buffer.length buf > 0 then (
-        words := Buffer.contents buf :: !words;
-        Buffer.clear buf);
-      incr in_parens
-    | ')' ->
-      if Buffer.length buf > 0 then (
-        words := Buffer.contents buf :: !words;
-        Buffer.clear buf);
-      decr in_parens
-    | _ ->
-      if !in_parens = 0 then
-        if is_ident_char c then Buffer.add_char buf c
-        else if is_whitespace c then
-          if Buffer.length buf > 0 then (
-            words := Buffer.contents buf :: !words;
-            Buffer.clear buf)
-        else ()
-      else if Buffer.length buf > 0 then (
-        words := Buffer.contents buf :: !words;
-        Buffer.clear buf)
-  done;
+and validate_media_query_content s =
+  (* Parse into tokens *)
+  let len = String.length s in
+  let i = ref 0 in
+  let skip_ws () = while !i < len && is_whitespace s.[!i] do incr i done in
+
+  let read_ident () =
+    let start = !i in
+    while !i < len && is_ident_char s.[!i] do incr i done;
+    if !i > start then Some (String.sub s start (!i - start))
+    else None
+  in
+
+  let read_paren_content () =
+    (* Read until matching ) *)
+    let start = !i in
+    let depth = ref 1 in
+    incr i; (* skip opening ( *)
+    while !i < len && !depth > 0 do
+      if s.[!i] = '(' then incr depth
+      else if s.[!i] = ')' then decr depth;
+      incr i
+    done;
+    String.sub s (start + 1) (!i - start - 2)
+  in
 
-  if Buffer.length buf > 0 then words := Buffer.contents buf :: !words;
-  List.rev !words
+  (* Parse the query *)
+  skip_ws ();
+  if !i >= len then Error "Parse Error."
+  else begin
+    (* Check for only/not prefix *)
+    let has_only = ref false in
+    let has_not = ref false in
+    (match read_ident () with
+    | Some w ->
+      let w_lower = String.lowercase_ascii w in
+      if w_lower = "only" then (has_only := true; skip_ws ())
+      else if w_lower = "not" then (has_not := true; skip_ws ())
+      else i := !i - String.length w (* put back *)
+    | None -> ());
 
-(** Validate media query structure *)
+    skip_ws ();
+    if !i >= len then begin
+      if !has_only || !has_not then Error "Parse Error."
+      else Error "Parse Error."
+    end else begin
+      (* Check for media type or ( *)
+      if s.[!i] = '(' then begin
+        (* Media feature only *)
+        let content = read_paren_content () in
+        validate_media_feature content
+      end else begin
+        (* Expect media type *)
+        match read_ident () with
+        | None -> Error "Parse Error."
+        | Some media_type ->
+          let mt_lower = lowercase_unicode media_type in
+          (* Check for deprecated media type *)
+          if List.mem mt_lower deprecated_media_types then
+            Error (Printf.sprintf "The media \"%s\" has been deprecated" mt_lower)
+          (* Check if valid media type *)
+          else if not (List.mem mt_lower valid_media_types) then
+            Error (Printf.sprintf "unrecognized media \"%s\"." mt_lower)
+          else begin
+            skip_ws ();
+            if !i >= len then Ok ()
+            else begin
+              (* Check for "and" - must be followed by whitespace *)
+              let and_start = !i in
+              match read_ident () with
+              | None -> Error "Parse Error."
+              | Some kw ->
+                let kw_lower = String.lowercase_ascii kw in
+                if kw_lower <> "and" then Error "Parse Error."
+                else begin
+                  (* Check that there was whitespace before 'and' *)
+                  if and_start > 0 && not (is_whitespace s.[and_start - 1]) then
+                    Error "Parse Error."
+                  (* Check that there is whitespace after 'and' *)
+                  else if !i < len && s.[!i] = '(' then
+                    Error "Parse Error."
+                  else begin
+                    skip_ws ();
+                    if !i >= len then Error "Parse Error."
+                    else if s.[!i] <> '(' then Error "Parse Error."
+                    else begin
+                    (* Validate remaining features *)
+                    let rec validate_features () =
+                      skip_ws ();
+                      if !i >= len then Ok ()
+                      else if s.[!i] = '(' then begin
+                        let content = read_paren_content () in
+                        match validate_media_feature content with
+                        | Error e -> Error e
+                        | Ok () ->
+                          skip_ws ();
+                          if !i >= len then Ok ()
+                          else begin
+                            match read_ident () with
+                            | None -> Error "Parse Error."
+                            | Some kw2 ->
+                              let kw2_lower = String.lowercase_ascii kw2 in
+                              if kw2_lower <> "and" then Error "Parse Error."
+                              else begin
+                                skip_ws ();
+                                if !i >= len then Error "Parse Error."
+                                else validate_features ()
+                              end
+                          end
+                      end else Error "Parse Error."
+                    in
+                    validate_features ()
+                    end
+                  end
+                end
+            end
+          end
+      end
+    end
+  end
+
+and validate_media_feature content =
+  let content = String.trim content in
+  if content = "" then Error "Parse Error."
+  else begin
+    (* Check for colon - feature: value *)
+    match String.index_opt content ':' with
+    | None ->
+      (* Just feature name - boolean feature or range syntax *)
+      let feature_lower = String.lowercase_ascii content in
+      if List.mem feature_lower deprecated_media_features then
+        Error (Printf.sprintf "Deprecated media feature \"%s\". For guidance, see the Deprecated Media Features section in the current Media Queries specification." feature_lower)
+      else if List.mem feature_lower valid_media_features then
+        Ok ()
+      else
+        Ok () (* Allow unknown features for forward compatibility *)
+    | Some colon_pos ->
+      let feature = String.trim (String.sub content 0 colon_pos) in
+      let value = String.trim (String.sub content (colon_pos + 1) (String.length content - colon_pos - 1)) in
+      let feature_lower = String.lowercase_ascii feature in
+
+      (* Check for deprecated features *)
+      if List.mem feature_lower deprecated_media_features then
+        Error (Printf.sprintf "Deprecated media feature \"%s\". For guidance, see the Deprecated Media Features section in the current Media Queries specification." feature_lower)
+      (* Check for incomplete value *)
+      else if value = "" then
+        Error "Parse Error."
+      (* Check for invalid value syntax *)
+      else if String.length value > 0 && value.[String.length value - 1] = ';' then
+        Error "Parse Error."
+      else begin
+        (* Validate value based on feature type *)
+        validate_feature_value feature_lower value
+      end
+  end
+
+and validate_feature_value feature value =
+  (* Width/height features require length values *)
+  let length_features = ["width"; "min-width"; "max-width"; "height"; "min-height"; "max-height"] in
+  let color_features = ["color"; "min-color"; "max-color"; "color-index"; "min-color-index"; "max-color-index";
+                        "monochrome"; "min-monochrome"; "max-monochrome"] in
+
+  if List.mem feature length_features then begin
+    (* Must be a valid length: number followed by unit *)
+    let value = String.trim value in
+    let is_digit c = c >= '0' && c <= '9' in
+
+    (* Parse number - includes sign, digits, and decimal point *)
+    let i = ref 0 in
+    let len = String.length value in
+    while !i < len && (is_digit value.[!i] || value.[!i] = '.' || value.[!i] = '-' || value.[!i] = '+') do
+      incr i
+    done;
+    let num_part = String.sub value 0 !i in
+    let unit_part = String.sub value !i (len - !i) in
+
+    (* Check if the number is zero (including 0.0, 0.00, etc.) *)
+    let is_zero num =
+      let rec check i =
+        if i >= String.length num then true
+        else match num.[i] with
+          | '0' | '.' | '-' -> check (i + 1)
+          | _ -> false
+      in
+      check 0
+    in
+    if num_part = "" then Error "Parse Error."
+    else if is_zero num_part && unit_part = "" then Ok () (* 0 (or 0.0) can be unitless *)
+    else if unit_part = "" then
+      Error "only \"0\" can be a \"unit\". You must put a unit after your number"
+    else begin
+      let unit_lower = String.lowercase_ascii unit_part in
+      if List.mem unit_lower valid_length_units then Ok ()
+      else if List.mem unit_lower valid_resolution_units then
+        Error (Printf.sprintf "\"%s\" is not a \"%s\" value" value feature)
+      else
+        Error "Unknown dimension."
+    end
+  end else if List.mem feature color_features then begin
+    (* Must be an integer *)
+    let value = String.trim value in
+    let is_digit c = c >= '0' && c <= '9' in
+    if String.length value > 0 && String.for_all is_digit value then Ok ()
+    else
+      Error (Printf.sprintf "\"%s\" is not a \"%s\" value" value feature)
+  end else
+    Ok () (* Allow other features with any value for now *)
+
+(** Legacy permissive validation *)
 let validate_media_query s =
   let s = String.trim s in
   if String.length s = 0 then Error "Media query must not be empty"
   else
-    (* Check balanced parentheses *)
     match check_balanced_parens s with
     | Error _ as e -> e
-    | Ok () ->
-      (* Extract and validate words *)
-      let words = extract_words s in
-      let words_lower = List.map String.lowercase_ascii words in
-
-      (* Basic validation: check for invalid keyword combinations *)
-      let rec validate_words prev = function
-        | [] -> Ok ()
-        | word :: rest -> (
-          let word_lower = String.lowercase_ascii word in
-          match (prev, word_lower) with
-          | None, "and" | None, "or" ->
-            Error
-              (Printf.sprintf
-                 "Media query cannot start with keyword '%s'" word)
-          | Some "and", "and" | Some "or", "or" | Some "not", "not" ->
-            Error
-              (Printf.sprintf "Consecutive '%s' keywords are not allowed"
-                 word)
-          | Some "only", "only" ->
-            Error "Consecutive 'only' keywords are not allowed"
-          | _, _ -> validate_words (Some word_lower) rest)
-      in
-
-      (* Check if query contains valid media types or features *)
-      let has_media_type =
-        List.exists
-          (fun w -> List.mem (String.lowercase_ascii w) media_types)
-          words
-      in
-      let has_features = String.contains s '(' in
-
-      if not (has_media_type || has_features) then
-        (* Only keywords, no actual media type or features *)
-        if List.for_all (fun w -> List.mem w media_keywords) words_lower then
-          Error "Media query contains only keywords without media type or features"
-        else Ok () (* Assume other identifiers are valid *)
-      else validate_words None words
+    | Ok () -> Ok ()
 
 module Media_query = struct
   let name = "media query"

lib/html5_checker/datatype/dt_media_query.mli

···
 
     This module provides a validator for CSS media queries as used in HTML5. *)
 
+(** Strict media query validation for HTML5 conformance checking.
+    Returns Ok () if valid, Error message if invalid. *)
+val validate_media_query_strict : string -> (unit, string) result
+
 (** Media query validator.
 
     Validates CSS media queries used in media attributes and CSS @media rules.

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
+    | 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
+  in
   Message.error
-    ~message:(Printf.sprintf "Parse error: %s" code_str)
+    ~message
     ~code:code_str
     ~location
     ()
···
   in
   let filtered_errors =
     if is_xhtml then
-      (* XHTML doesn't require DOCTYPE - filter that error *)
+      (* XHTML has different requirements than HTML:
+         - No DOCTYPE required
+         - Self-closing syntax is valid for all elements *)
       List.filter (fun err ->
         match Html5rw.error_code err with
         | Html5rw.Parse_error_code.Tree_construction_error "expected-doctype-but-got-other" -> false
+        | Html5rw.Parse_error_code.Non_void_html_element_start_tag_with_trailing_solidus -> false
         | _ -> true
       ) errors
     else errors

lib/html5_checker/semantic/id_checker.ml

···
     - ID values conform to HTML5 requirements *)
 
 (** Location information for ID occurrences. *)
-type id_location = {
-  element : string;
-  location : Message.location option;
-}
+type id_location = unit (* simplified since we only need to track existence *)
 
 (** Information about an ID reference. *)
 type id_reference = {
···
       ()
   (* Check for duplicate ID *)
   else if Hashtbl.mem state.ids id then
-    let first_occurrence = Hashtbl.find state.ids id in
-    let first_loc_str = match first_occurrence.location with
-      | None -> ""
-      | Some loc -> Printf.sprintf " at line %d, column %d" loc.line loc.column
-    in
     Message_collector.add_error collector
-      ~message:(Printf.sprintf
-        "Duplicate ID '%s': first used on <%s>%s, now on <%s>"
-        id first_occurrence.element first_loc_str element)
+      ~message:(Printf.sprintf "Duplicate ID \xe2\x80\x9c%s\xe2\x80\x9d." id)
       ~code:"duplicate-id"
       ?location
       ~element
···
       ()
   else
     (* Store the ID *)
-    Hashtbl.add state.ids id { element; location }
+    Hashtbl.add state.ids id ()
 
 (** Record a single ID reference. *)
 let add_reference state ~referring_element ~attribute ~referenced_id ~location =
···
     | "name" when element = "map" ->
         (* Track map name attributes for usemap resolution *)
         if String.length value > 0 then
-          Hashtbl.add state.map_names value { element; location }
+          Hashtbl.add state.map_names value ()
 
     | attr when List.mem attr single_id_ref_attrs ->
         add_reference state ~referring_element:element

lib/html5_checker/specialized/aria_checker.ml

···
 
 (** Stack node representing an element in the ancestor chain. *)
 type stack_node = {
+  element_name : string;
   explicit_roles : string list;
   implicit_role : string option;
 }
···
 (** Checker state. *)
 type state = {
   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 *)
 }
 
-let create () = { stack = [] }
+let create () = { stack = []; has_active_tab = false; has_tabpanel = false }
 
-let reset state = state.stack <- []
+let reset state =
+  state.stack <- [];
+  state.has_active_tab <- false;
+  state.has_tabpanel <- false
 
 (** Check if any ancestor has one of the required roles. *)
 let has_required_ancestor_role state required_roles =
···
     | None -> false
   ) state.stack
 
+(** Get the first ancestor role from a list of target roles. *)
+let get_ancestor_role state target_roles =
+  let rec find_in_stack = function
+    | [] -> None
+    | ancestor :: rest ->
+      let found_explicit = List.find_opt (fun role -> List.mem role target_roles) ancestor.explicit_roles in
+      match found_explicit with
+      | Some r -> Some r
+      | None ->
+        match ancestor.implicit_role with
+        | Some r when List.mem r target_roles -> Some r
+        | _ -> find_in_stack rest
+  in
+  find_in_stack state.stack
+
+(** Get the immediate parent element name. *)
+let get_parent_element state =
+  match state.stack with
+  | parent :: _ -> Some parent.element_name
+  | [] -> None
+
 (** Render a list of roles as a human-readable string. *)
 let render_role_set roles =
   match roles with
···
       (* Get implicit role for this element *)
       let implicit_role = get_implicit_role name_lower attrs in
 
+      (* Track active tabs and tabpanel roles for end_document validation *)
+      if List.mem "tab" explicit_roles then begin
+        let aria_selected = List.assoc_opt "aria-selected" attrs in
+        if aria_selected = Some "true" then state.has_active_tab <- true
+      end;
+      if List.mem "tabpanel" explicit_roles then state.has_tabpanel <- true;
+
       (* Check br/wbr role restrictions - only none/presentation allowed *)
       if (name_lower = "br" || name_lower = "wbr") && explicit_roles <> [] then begin
         let first_role = List.hd explicit_roles in
···
         | _ -> ()
       end;
 
+      (* Check for input[type=checkbox][role=button] requires aria-pressed *)
+      if name_lower = "input" then begin
+        let input_type = match List.assoc_opt "type" attrs with
+          | Some t -> String.lowercase_ascii t
+          | None -> "text"
+        in
+        if input_type = "checkbox" && List.mem "button" explicit_roles then begin
+          let has_aria_pressed = List.assoc_opt "aria-pressed" attrs <> None in
+          if not has_aria_pressed then
+            Message_collector.add_error collector
+              ~message:"An \xe2\x80\x9cinput\xe2\x80\x9d element with a \xe2\x80\x9ctype\xe2\x80\x9d attribute whose value is \xe2\x80\x9ccheckbox\xe2\x80\x9d and with a \xe2\x80\x9crole\xe2\x80\x9d attribute whose value is \xe2\x80\x9cbutton\xe2\x80\x9d must have an \xe2\x80\x9caria-pressed\xe2\x80\x9d attribute."
+              ~code:"checkbox-button-needs-aria-pressed"
+              ~element:name
+              ~attribute:"role"
+              ()
+        end
+      end;
+
+      (* Check li role restrictions in menu/menubar/tablist contexts *)
+      if name_lower = "li" && explicit_roles <> [] then begin
+        let first_role = List.hd explicit_roles in
+        (* none/presentation are always allowed as they remove from accessibility tree *)
+        if first_role <> "none" && first_role <> "presentation" then begin
+          (* Check if in menu or menubar context *)
+          (match get_ancestor_role state ["menu"; "menubar"] with
+          | Some _ ->
+            let valid_roles = ["group"; "menuitem"; "menuitemcheckbox"; "menuitemradio"; "separator"] in
+            if not (List.mem first_role valid_roles) then
+              Message_collector.add_error collector
+                ~message:"An \xe2\x80\x9cli\xe2\x80\x9d element that is a descendant of a \xe2\x80\x9crole=menu\xe2\x80\x9d element or \xe2\x80\x9crole=menubar\xe2\x80\x9d element must not have any \xe2\x80\x9crole\xe2\x80\x9d value other than \xe2\x80\x9cgroup\xe2\x80\x9d, \xe2\x80\x9cmenuitem\xe2\x80\x9d, \xe2\x80\x9cmenuitemcheckbox\xe2\x80\x9d, \xe2\x80\x9cmenuitemradio\xe2\x80\x9d, or \xe2\x80\x9cseparator\xe2\x80\x9d."
+                ~code:"invalid-li-role-in-menu"
+                ~element:name
+                ~attribute:"role"
+                ()
+          | None ->
+            (* Check if in tablist context *)
+            match get_ancestor_role state ["tablist"] with
+            | Some _ ->
+              if first_role <> "tab" then
+                Message_collector.add_error collector
+                  ~message:"An \xe2\x80\x9cli\xe2\x80\x9d element that is a descendant of a \xe2\x80\x9crole=tablist\xe2\x80\x9d element must not have any \xe2\x80\x9crole\xe2\x80\x9d value other than \xe2\x80\x9ctab\xe2\x80\x9d."
+                  ~code:"invalid-li-role-in-tablist"
+                  ~element:name
+                  ~attribute:"role"
+                  ()
+            | None -> ())
+        end
+      end;
+
       (* Check for aria-hidden="true" on body element *)
       if name_lower = "body" then begin
         let aria_hidden = List.assoc_opt "aria-hidden" attrs in
···
           | None -> ()
       ) attrs;
 
+      (* Check summary restrictions in details context *)
+      if name_lower = "summary" then begin
+        let parent = get_parent_element state in
+        let is_in_details = parent = Some "details" in
+        if is_in_details then begin
+          (* summary that is the first child of details *)
+          (* Cannot have role=paragraph (or other non-button roles) *)
+          if explicit_roles <> [] then begin
+            let first_role = List.hd explicit_roles in
+            if first_role <> "button" && first_role <> "none" && first_role <> "presentation" then
+              Message_collector.add_error collector
+                ~message:"The \xe2\x80\x9crole\xe2\x80\x9d attribute must not be used on any \xe2\x80\x9csummary\xe2\x80\x9d element that is a summary for its parent \xe2\x80\x9cdetails\xe2\x80\x9d element."
+                ~code:"invalid-role-on-summary"
+                ~element:name
+                ~attribute:"role"
+                ()
+          end;
+          (* If has aria-expanded or aria-pressed, must have role *)
+          let has_aria_expanded = List.assoc_opt "aria-expanded" attrs <> None in
+          let has_aria_pressed = List.assoc_opt "aria-pressed" attrs <> None in
+          if (has_aria_expanded || has_aria_pressed) && explicit_roles = [] then begin
+            if has_aria_pressed then
+              Message_collector.add_error collector
+                ~message:"Element \xe2\x80\x9csummary\xe2\x80\x9d is missing required attribute \xe2\x80\x9crole\xe2\x80\x9d."
+                ~code:"missing-role-on-summary"
+                ~element:name ()
+            else
+              Message_collector.add_error collector
+                ~message:"Element \xe2\x80\x9csummary\xe2\x80\x9d is missing one or more of the following attributes: [aria-checked, aria-level, role]."
+                ~code:"missing-role-on-summary"
+                ~element:name ()
+          end
+        end
+      end;
+
       (* Push current element onto stack *)
       let node = {
+        element_name = name_lower;
         explicit_roles;
         implicit_role;
       } in
···
 
 let characters _state _text _collector = ()
 
-let end_document _state _collector = ()
+let end_document state collector =
+  (* Check that active tabs have corresponding tabpanels *)
+  if state.has_active_tab && not state.has_tabpanel then
+    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"
+      ()
 
 let checker = (module struct
   type nonrec state = state

lib/html5_checker/specialized/attr_restrictions_checker.ml

···
      The HTML5 parser normalizes attribute names to lowercase, so this check
      is only effective when the document is parsed as XML.
      Commenting out until we have XML parsing support. *)
-  ignore state.is_xhtml
+  ignore state.is_xhtml;
+
+  (* Validate media attribute on link, style, source elements *)
+  if namespace = None && (name_lower = "link" || name_lower = "style" || name_lower = "source") then begin
+    List.iter (fun (attr_name, attr_value) ->
+      let attr_lower = String.lowercase_ascii attr_name in
+      if attr_lower = "media" then begin
+        let trimmed = String.trim attr_value in
+        if trimmed <> "" then begin
+          match Dt_media_query.validate_media_query_strict trimmed with
+          | Ok () -> ()
+          | Error msg ->
+            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: Bad media query: %s"
+                attr_value attr_name name msg)
+              ~code:"bad-attribute-value"
+              ~element:name ~attribute:attr_name ()
+        end
+      end
+    ) attrs
+  end;
+
+  (* Validate RDFa prefix attribute - space-separated list of prefix:iri pairs *)
+  if namespace = None then begin
+    List.iter (fun (attr_name, attr_value) ->
+      let attr_lower = String.lowercase_ascii attr_name in
+      if attr_lower = "prefix" then begin
+        (* Parse prefix attribute value - format: "prefix1: iri1 prefix2: iri2 ..." *)
+        let trimmed = String.trim attr_value in
+        if trimmed <> "" then begin
+          (* Check for empty prefix (starts with : or has space:) *)
+          if String.length trimmed > 0 && trimmed.[0] = ':' 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."
+                attr_value attr_name name)
+              ~code:"bad-attribute-value"
+              ~element:name ~attribute:attr_name ()
+          else begin
+            (* Check for invalid prefix names - must start with letter or underscore *)
+            let is_ncname_start c =
+              (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c = '_'
+            in
+            if String.length trimmed > 0 && not (is_ncname_start trimmed.[0]) 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."
+                  attr_value attr_name name)
+                ~code:"bad-attribute-value"
+                ~element:name ~attribute:attr_name ()
+          end
+        end
+      end
+    ) attrs
+  end
 
 let end_element _state ~name:_ ~namespace:_ _collector = ()
 let characters _state _text _collector = ()

lib/html5_checker/specialized/dl_checker.ml

···
   | ctx :: _ -> Some ctx
   | [] -> None
 
-let start_element state ~name ~namespace ~attrs:_ collector =
+let get_attr name attrs =
+  List.find_map (fun (n, v) ->
+    if String.lowercase_ascii n = name then Some v else None
+  ) attrs
+
+let start_element state ~name ~namespace ~attrs collector =
   let name_lower = String.lowercase_ascii name in
 
   (* Track parent stack for all HTML elements first *)
···
             ~message:"Element \xe2\x80\x9cdiv\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:"div" ();
+        (* Check that role is only presentation or none *)
+        (match get_attr "role" attrs with
+        | Some role_value ->
+          let role_lower = String.lowercase_ascii (String.trim role_value) in
+          if role_lower <> "presentation" && role_lower <> "none" then
+            Message_collector.add_error collector
+              ~message:"A \xe2\x80\x9cdiv\xe2\x80\x9d child of a \xe2\x80\x9cdl\xe2\x80\x9d element must not have any \xe2\x80\x9crole\xe2\x80\x9d value other than \xe2\x80\x9cpresentation\xe2\x80\x9d or \xe2\x80\x9cnone\xe2\x80\x9d."
+              ~code:"invalid-role-on-div-in-dl"
+              ~element:"div"
+              ~attribute:"role" ()
+        | None -> ());
         let div_ctx = { has_dt = false; has_dd = false; group_count = 0; in_dd_part = false } in
         state.div_in_dl_stack <- div_ctx :: state.div_in_dl_stack
       | Some _ when state.div_in_dl_stack <> [] ->

lib/html5_checker/specialized/label_checker.ml

···
     if String.lowercase_ascii n = name_lower then Some v else None
   ) attrs
 
+type label_for_info = {
+  for_target : string;
+  has_role : bool;
+  has_aria_label : bool;
+}
+
 type state = {
   mutable in_label : bool;
   mutable label_depth : int;
   mutable labelable_count : int;
   mutable label_for_value : string option;  (* Value of for attribute on current label *)
+  mutable label_has_role : bool;  (* Whether current label has role attribute *)
+  mutable label_has_aria_label : bool;  (* Whether current label has aria-label attribute *)
+  mutable labels_for : label_for_info list;  (* Labels with for= attribute *)
+  mutable labelable_ids : string list;  (* IDs of labelable elements *)
 }
 
 let create () = {
···
   label_depth = 0;
   labelable_count = 0;
   label_for_value = None;
+  label_has_role = false;
+  label_has_aria_label = false;
+  labels_for = [];
+  labelable_ids = [];
 }
 
 let reset state =
   state.in_label <- false;
   state.label_depth <- 0;
   state.labelable_count <- 0;
-  state.label_for_value <- None
+  state.label_for_value <- None;
+  state.label_has_role <- false;
+  state.label_has_aria_label <- false;
+  state.labels_for <- [];
+  state.labelable_ids <- []
 
 let start_element state ~name ~namespace ~attrs collector =
   if namespace <> None then ()
···
 
     if name_lower = "label" then begin
       state.in_label <- true;
-      state.label_depth <- 0;
+      state.label_depth <- 1;  (* Start at 1 for the label element itself *)
       state.labelable_count <- 0;
-      state.label_for_value <- get_attr attrs "for"
+      let for_value = get_attr attrs "for" in
+      let has_role = get_attr attrs "role" <> None in
+      let has_aria_label = get_attr attrs "aria-label" <> None in
+      state.label_for_value <- for_value;
+      state.label_has_role <- has_role;
+      state.label_has_aria_label <- has_aria_label;
+      (* Track this label if it has for= and role/aria-label *)
+      (match for_value with
+      | Some target when has_role || has_aria_label ->
+        state.labels_for <- { for_target = target; has_role; has_aria_label } :: state.labels_for
+      | _ -> ())
     end;
+    (* Track labelable element IDs *)
+    (if List.mem name_lower labelable_elements then
+      match get_attr attrs "id" with
+      | Some id -> state.labelable_ids <- id :: state.labelable_ids
+      | None -> ());
 
-    if state.in_label then begin
+    if state.in_label && name_lower <> "label" then begin
       state.label_depth <- state.label_depth + 1;
 
       (* Check for labelable elements inside label *)
···
             ~element:"label" ();
 
         (* Check if label has for attribute and descendant has mismatched id *)
-        match state.label_for_value with
+        (match state.label_for_value with
         | Some for_value ->
           let descendant_id = get_attr attrs "id" in
           (match descendant_id with
···
              ())
         | None ->
           (* No for attribute on label - no constraint on descendant id *)
-          ()
+          ())
       end
     end
   end
 
-let end_element state ~name ~namespace _collector =
+let end_element state ~name ~namespace collector =
   if namespace <> None then ()
   else begin
     let name_lower = String.lowercase_ascii name in
···
     if state.in_label then begin
       state.label_depth <- state.label_depth - 1;
 
-      if name_lower = "label" && state.label_depth < 0 then begin
+      if name_lower = "label" && state.label_depth = 0 then begin
+        (* Check for role attribute on label that's ancestor of labelable element *)
+        if state.label_has_role && state.labelable_count > 0 then
+          Message_collector.add_error collector
+            ~message:"The \xe2\x80\x9crole\xe2\x80\x9d attribute must not be used on any \xe2\x80\x9clabel\xe2\x80\x9d element that is an ancestor of a labelable element."
+            ~code:"role-on-label-ancestor"
+            ~element:"label"
+            ~attribute:"role" ();
+
         state.in_label <- false;
         state.labelable_count <- 0;
-        state.label_for_value <- None
+        state.label_for_value <- None;
+        state.label_has_role <- false;
+        state.label_has_aria_label <- false
       end
     end
   end
 
 let characters _state _text _collector = ()
 
-let end_document _state _collector = ()
+let end_document state collector =
+  (* Check labels with for= that target labelable elements *)
+  List.iter (fun label_info ->
+    if List.mem label_info.for_target state.labelable_ids then begin
+      (* This label is associated with a labelable element *)
+      if label_info.has_role then
+        Message_collector.add_error collector
+          ~message:"The \xe2\x80\x9crole\xe2\x80\x9d attribute must not be used on any \xe2\x80\x9clabel\xe2\x80\x9d element that is associated with a labelable element."
+          ~code:"role-on-label-for"
+          ~element:"label"
+          ~attribute:"role" ();
+      if label_info.has_aria_label then
+        Message_collector.add_error collector
+          ~message:"The \xe2\x80\x9caria-label\xe2\x80\x9d attribute must not be used on any \xe2\x80\x9clabel\xe2\x80\x9d element that is associated with a labelable element."
+          ~code:"aria-label-on-label-for"
+          ~element:"label"
+          ~attribute:"aria-label" ()
+    end
+  ) state.labels_for
 
 let checker =
   (module struct

lib/html5_checker/specialized/microdata_checker.ml

···
 let is_url s =
   String.contains s ':'
 
+(** Validate that a URL is a valid absolute URL for itemtype.
+    itemtype must be an absolute URL per the HTML5 spec.
+    http/https URLs require :// but other schemes like mailto:, data:, javascript: don't. *)
+let validate_itemtype_url url =
+  let url = String.trim url in
+  if String.length url = 0 then
+    Error "itemtype must not be empty"
+  else
+    match String.index_opt url ':' with
+    | None -> Error "Expected a slash (\"/\")."
+    | Some colon_pos ->
+      if colon_pos = 0 then
+        Error "Expected a slash (\"/\")."
+      else
+        let scheme = String.lowercase_ascii (String.sub url 0 colon_pos) in
+        (* Schemes that require :// for itemtype validation
+           Note: The Nu validator only enforces :// for http, https, and ftp *)
+        let special_schemes = [
+          "http"; "https"; "ftp"
+        ] in
+        if List.mem scheme special_schemes then begin
+          if colon_pos + 2 >= String.length url then
+            Error "Expected a slash (\"/\")."
+          else if url.[colon_pos + 1] <> '/' || url.[colon_pos + 2] <> '/' then
+            Error "Expected a slash (\"/\")."
+          else
+            Ok ()
+        end else
+          (* Other schemes (mailto:, data:, javascript:, etc.) are valid as-is *)
+          Ok ()
+
 (** Check if itemprop value is valid. *)
 let validate_itemprop_value value =
   if String.length value = 0 then
···
   | None -> ()
   end;
 
-  (* Check itemtype requires itemscope *)
+  (* Check itemtype requires itemscope and is valid URL *)
   begin match itemtype_opt with
-  | Some _itemtype ->
+  | Some itemtype ->
       if not has_itemscope then
         Message_collector.add_error collector
           ~message:"itemtype attribute requires itemscope attribute"
···
           ~element
           ~attribute:"itemtype"
           ()
+      else begin
+        (* Validate each itemtype URL (can be space-separated) *)
+        let types = split_whitespace itemtype in
+        List.iter (fun url ->
+          match validate_itemtype_url url with
+          | Ok () -> ()
+          | Error msg ->
+            Message_collector.add_error collector
+              ~message:(Printf.sprintf
+                "Bad value \xe2\x80\x9c%s\xe2\x80\x9d for attribute \xe2\x80\x9citemtype\xe2\x80\x9d on element \xe2\x80\x9c%s\xe2\x80\x9d: Bad absolute URL: %s"
+                url element msg)
+              ~code:"microdata-invalid-itemtype"
+              ?location
+              ~element
+              ~attribute:"itemtype"
+              ()
+        ) types
+      end
   | None -> ()
   end;
 

lib/html5rw/parser/parser_tree_builder.ml

···
   | Token.Tag { kind = Token.Start; name; _ }
     when List.mem name ["caption"; "colgroup"; "head"; "tbody"; "td"; "tfoot"; "th"; "thead"; "tr"] ->
     parse_error t "unexpected-start-tag"
-  | Token.Tag { kind = Token.Start; name; attrs; _ } ->
+  | Token.Tag { kind = Token.Start; name; attrs; self_closing } ->
     (* Any other start tag *)
     reconstruct_active_formatting t;
-    ignore (insert_element t name ~push:true attrs)
+    ignore (insert_element t name ~push:true attrs);
+    (* Check for self-closing on non-void HTML element *)
+    if self_closing && not (List.mem name Parser_constants.void_elements) then
+      parse_error t "non-void-html-element-start-tag-with-trailing-solidus"
   | Token.Tag { kind = Token.End; name; _ } ->
     (* Any other end tag *)
     let rec check = function

test/debug_check.ml

···
+let () =
+  let test_file = "validator/tests/html/microdata/itemtype/scheme-https-no-slash-novalid.html" in
+  let ic = open_in test_file in
+  let html = really_input_string ic (in_channel_length ic) in
+  close_in ic;
+  let reader = Bytesrw.Bytes.Reader.of_string html in
+  let result = Html5_checker.check ~collect_parse_errors:true ~system_id:test_file reader in
+  let errors = Html5_checker.errors result in
+  let warnings = Html5_checker.warnings result in
+  print_endline "=== Errors ===";
+  List.iter (fun e -> print_endline e.Html5_checker.Message.message) errors;
+  print_endline "=== Warnings ===";
+  List.iter (fun e -> print_endline e.Html5_checker.Message.message) warnings;
+  if List.length errors > 0 then
+    print_endline "PASS (has errors)"
+  else
+    print_endline "FAIL (no errors)"