diff --git a/scripts/costruzione_grafo/hag_queries.py b/scripts/costruzione_grafo/hag_queries.py
new file mode 100644
index 0000000..82f23fe
--- /dev/null
+++ b/scripts/costruzione_grafo/hag_queries.py
@@ -0,0 +1,1161 @@
+from __future__ import annotations
+"""
+hag_queries.py
+==============
+Structural queries on the Heterogeneous Accessibility Graph (HAG) produced by
+heterogeneous_ax_graph.py.
+
+Each query function:
+  • accepts a nx.MultiDiGraph (the HAG)
+  • returns a list of Issue dicts with fields:
+      node_id   – graph node id(s) involved
+      wcag      – list of WCAG success criteria (e.g. ["1.3.2", "2.4.3"])
+      severity  – "critical" | "serious" | "moderate" | "minor"
+      layer     – which layer(s) the issue spans
+      title     – short human-readable label
+      detail    – explanation with node-specific values
+
+Queries are grouped by the "gap" they detect:
+  Δ0  – intra-layer DOM issues      (missing labels, ARIA misuse)
+  Δ1  – AX - DOM gap               (markup vs AX tree divergence)
+  Δ2  – AX - Visual gap            (semantic order vs perceptual order)
+  Δ3  – DOM - Visual gap           (structure vs layout)
+
+Usage
+-----
+    from hag_queries import run_all_queries, print_report
+    issues = run_all_queries(HAG)
+    print_report(issues)
+
+Or from the command line (requires a saved JSON graph):
+    python hag_queries.py hag.json
+    python hag_queries.py hag.json --verbose
+    python hag_queries.py hag.json --query Q1.1
+    python hag_queries.py hag.json --report issues.json
+"""
+
+"""
+Architettura del modulo
+Ogni query è una funzione autonoma che restituisce una lista di Issue — un dataclass con query_id, title, wcag, severity, layer, node_id, detail e un dizionario extra per dati specifici. La severità è calcolata in modo contestuale (non fissa) — ad esempio Q1.2 diventa critical se il nodo visivo senza AX occupa più del 10% della viewport.
+Le query sono organizzate in quattro gap, coerenti con la MVAR discussa prima:
+Δ0 — intra-layer (Q0.x): problemi rilevabili dentro un singolo layer, senza confronto tra viste. Gerarchia heading (livelli saltati, h1 multipli, heading vuoti), immagini senza alt, input senza label, struttura landmark, elementi interattivi senza nome. Sono i criteri più "classici" ma qui vengono rilevati con il contesto del grafo — ad esempio Q0.5 (input senza label) verifica sia il nome AX che l'assenza di arco label_for nel DOM layer.
+Δ1 — AX - DOM (Q1.x): divergenza tra markup dichiarato e albero AX effettivo. Q1.1 trova nodi AX senza visual (visually hidden non intenzionale), Q1.2 trova nodi visivi senza AX (invisibili agli screen reader), Q1.3 trova elementi interattivi del DOM senza alcun nodo AX (completamente opachi), Q1.4 trova nodi AX ignorati che però occupano spazio visivo significativo.
+Δ2 — AX - Visual (Q2.x): mismatch di ordine tra sequenza semantica e sequenza percettiva. Q2.1 misura lo scarto di posizione normalizzato tra rank AX e rank visivo, con soglia di prominenza per filtrare falsi positivi. Q2.2 fa lo stesso ma solo per elementi focusable (tab order vs visual order).
+Δ3 — DOM - Visual (Q3.x): elementi visivamente prominenti il cui DOM node non porta semantica (div/span senza ruolo ARIA).
+"""
+
+
+
+import json
+import sys
+from dataclasses import dataclass, field, asdict
+from typing import Any
+
+import networkx as nx
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Data model
+# ─────────────────────────────────────────────────────────────────────────────
+
+@dataclass
+class Issue:
+    query_id  : str
+    title     : str
+    wcag      : list[str]
+    severity  : str          # critical | serious | moderate | minor
+    layer     : str          # dom | ax | visual | cross
+    node_id   : str          # primary node involved
+    detail    : str
+    extra     : dict = field(default_factory=dict)  # optional extra fields
+
+    def as_dict(self) -> dict:
+        return asdict(self)
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Graph traversal helpers
+# ─────────────────────────────────────────────────────────────────────────────
+
+def _nodes_by_layer(HAG: nx.MultiDiGraph, layer: str) -> list[tuple[str, dict]]:
+    return [(n, d) for n, d in HAG.nodes(data=True) if d.get("layer") == layer]
+
+
+def _neighbors_by_relation(
+    HAG: nx.MultiDiGraph, node: str, relation: str
+) -> list[str]:
+    """Return all neighbours reachable via edges with the given relation."""
+    result = []
+    for _, v, data in HAG.out_edges(node, data=True):
+        if data.get("relation") == relation:
+            result.append(v)
+    for u, _, data in HAG.in_edges(node, data=True):
+        if data.get("relation") == relation:
+            result.append(u)
+    return result
+
+
+def _ax_neighbors_via_cross(HAG: nx.MultiDiGraph, ax_node: str) -> list[str]:
+    """Return visual layer nodes linked to an AX node via ax_to_visual."""
+    return _neighbors_by_relation(HAG, ax_node, "ax_to_visual")
+
+
+def _dom_neighbors_via_cross(HAG: nx.MultiDiGraph, dom_node: str) -> list[str]:
+    """Return AX nodes linked to a DOM node via dom_to_ax."""
+    return _neighbors_by_relation(HAG, dom_node, "dom_to_ax")
+
+
+def _ax_reading_order(HAG: nx.MultiDiGraph) -> list[tuple[str, dict]]:
+    """
+    Return non-ignored AX nodes in DOM tree order (breadth-first from root).
+    This approximates screen-reader reading order.
+    """
+    roots = [
+        n for n, d in HAG.nodes(data=True)
+        if d.get("layer") == "ax"
+        and d.get("role") in ("RootWebArea", "WebArea")
+    ]
+    if not roots:
+        # fallback: any AX node with no AX parent
+        ax_nodes = {n for n, d in HAG.nodes(data=True) if d.get("layer") == "ax"}
+        ax_children = set()
+        for u, v, d in HAG.edges(data=True):
+            if d.get("relation") == "hasChild" and d.get("layer") == "ax":
+                ax_children.add(v)
+        roots = list(ax_nodes - ax_children)
+
+    visited, order = set(), []
+    queue = list(roots)
+    while queue:
+        node = queue.pop(0)
+        if node in visited:
+            continue
+        visited.add(node)
+        attrs = HAG.nodes[node]
+        if not attrs.get("ignored"):
+            order.append((node, attrs))
+        children = [
+            v for _, v, d in HAG.out_edges(node, data=True)
+            if d.get("relation") == "hasChild" and d.get("layer") == "ax"
+        ]
+        queue.extend(children)
+    return order
+
+
+
+def _dom_reading_order(HAG: nx.MultiDiGraph) -> list[tuple[str, dict]]:
+    """
+    Return non-ignored DOM nodes in DOM tree order (breadth-first from root).
+    This approximates TAB reading order.
+    """
+    
+    #dom_nodes = {n for n, d in HAG.nodes(data=True) if (d.get("layer") == "dom" and d.get("node_type")==1)}
+    dom_nodes = {n for n, d in HAG.nodes(data=True) if d.get("layer") == "dom" }
+    print("dom_nodes:",dom_nodes)
+    dom_children = set()
+    for u, v, d in HAG.edges(data=True):
+        if d.get("relation") == "hasChild" and d.get("layer") == "dom": 
+            dom_children.add(v)
+    roots = list(dom_nodes - dom_children)
+    print("roots:",roots)# va controllato filtro solo eleenti realmente interattivi (vedi plugin)
+
+    
+
+    visited, order = set(), []
+    queue = list(roots)
+    while queue:
+        node = queue.pop(0)
+        if node in visited:
+            continue
+        visited.add(node)
+        attrs = HAG.nodes[node]
+        if not attrs.get("ignored"):
+            order.append((node, attrs))
+        children = [
+            v for _, v, d in HAG.out_edges(node, data=True)
+            if d.get("relation") == "hasChild" and d.get("layer") == "dom"
+        ]
+        queue.extend(children)
+    return order
+
+
+def _visual_reading_order(HAG: nx.MultiDiGraph) -> list[tuple[str, dict]]:
+    """Return visual nodes sorted by reading_rank (top→bottom, left→right)."""
+    vis = [(n, d) for n, d in HAG.nodes(data=True) if d.get("layer") == "visual"]
+    return sorted(vis, key=lambda x: x[1].get("reading_rank", 0))
+
+
+def _ax_ancestors(HAG: nx.MultiDiGraph, node: str) -> list[str]:
+    """Walk up the AX child edges and return ancestor node ids."""
+    ancestors = []
+    current = node
+    for _ in range(50):   # cap depth
+        parents = [
+            u for u, _, d in HAG.in_edges(current, data=True)
+            if d.get("relation") == "hasChild" and d.get("layer") == "ax"
+        ]
+        if not parents:
+            break
+        current = parents[0]
+        ancestors.append(current)
+    return ancestors
+
+
+def _dom_ancestors(HAG: nx.MultiDiGraph, node: str) -> list[str]:
+    ancestors = []
+    current = node
+    for _ in range(80):
+        parents = [
+            u for u, _, d in HAG.in_edges(current, data=True)
+            if d.get("relation") == "hasChild" and d.get("layer") == "dom"
+        ]
+        if not parents:
+            break
+        current = parents[0]
+        ancestors.append(current)
+    return ancestors
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Δ1 queries  –  AX - DOM gap
+#   "what the markup declares" vs "what the AX tree exposes"
+# ─────────────────────────────────────────────────────────────────────────────
+
+def q_ax_nodes_without_visual(HAG: nx.MultiDiGraph) -> list[Issue]:
+    """
+    Δ1/Δ2 – Non-ignored AX nodes with no linked visual node.
+
+    These elements exist in the semantic tree (screen reader sees them) but
+    have no rendered bounding box – meaning sighted users cannot perceive them
+    visually.  This can be intentional (visually-hidden text for SR only) or
+    a bug (content accidentally off-screen / clipped).
+
+    WCAG: 1.3.1 Info and Relationships (A)
+    #NL: qua dentro cadono anche i tag particolari come "main" o "list" tolta da grafo visivo (la lista di per se non viene vista ma solo i singoli elementi nel caso). ol e ul tolti anche perchè se le vede solo il testo
+    # ci cascano anche elemneti ax di tipo "generic"
+    """
+    issues = []
+    for nid, attrs in _nodes_by_layer(HAG, "ax"):
+        if attrs.get("ignored"):
+            continue
+        role = str(attrs.get("role") or "")
+        # skip purely structural roles that are never rendered
+        if role in ("RootWebArea", "WebArea", "InlineTextBox",
+                    "none", "presentation", "ListMarker"):
+            continue
+        vis_neighbors = _ax_neighbors_via_cross(HAG, nid)
+        # filter to only visual-layer nodes
+        vis_neighbors = [v for v in vis_neighbors
+                         if HAG.nodes[v].get("layer") == "visual"]
+        if not vis_neighbors:
+            name = attrs.get("name") or ""
+            issues.append(Issue(
+                query_id = "Q1.1",
+                title    = "AX node without visual counterpart",
+                wcag     = ["1.3.1"],
+                severity = "moderate",
+                layer    = "cross:ax-visual",
+                node_id  = nid,
+                detail   = (
+                    f"AX node role='{role}' name='{name}' is present in the "
+                    f"accessibility tree but has no rendered bounding box. "
+                    f"May be visually hidden or off-screen."
+                ),
+                extra    = {"role": role, "name": name},
+            ))
+    return issues
+
+
+def q_visual_nodes_without_ax(HAG: nx.MultiDiGraph) -> list[Issue]:
+    """
+    Δ2 – Visual nodes with no linked non-ignored AX node.
+
+    These elements are visible to sighted users but invisible to screen readers.
+    High prominence makes this more severe (large visible element = large barrier).
+
+    WCAG: 1.1.1 Non-text Content (A), 4.1.2 Name Role Value (A)
+    #NL: non capito. sembra elemento visivo collegato a elementi ax rilevanti, con ignore=false
+    """
+    issues = []
+    for nid, attrs in _nodes_by_layer(HAG, "visual"):
+        tag        = attrs.get("tag", "")
+        prominence = attrs.get("prominence", 0)
+
+        # Find all AX neighbors
+        ax_neighbors = _neighbors_by_relation(HAG, nid, "ax_to_visual")
+        # Also check via dom→ax chain
+        dom_neighbors = _neighbors_by_relation(HAG, nid, "dom_to_visual")
+        for dom_nid in dom_neighbors:
+            ax_neighbors += _dom_neighbors_via_cross(HAG, dom_nid)
+
+        # Filter: keep only non-ignored AX nodes
+        visible_ax = [
+            v for v in ax_neighbors
+            if HAG.nodes[v].get("layer") == "ax"
+            and not HAG.nodes[v].get("ignored")#take "ignored"=false, take usefull ax nodes
+        ]
+
+        if not visible_ax:
+            severity = (
+                "critical" if prominence > 0.10 else
+                "serious"  if prominence > 0.03 else
+                "moderate"
+            )
+            issues.append(Issue(
+                query_id = "Q1.2",
+                title    = "Visual node without AX counterpart",
+                wcag     = ["1.1.1", "4.1.2"],
+                severity = severity,
+                layer    = "cross:visual-ax",
+                node_id  = nid,
+                detail   = (
+                    f"<{tag}> element is rendered (prominence={prominence:.5f}) "
+                    f"but relevant AX node (ignored=false; has no corresponding non-ignored AX node.) "
+                    f"Screen reader users cannot perceive this content."
+                ),
+                extra    = {"tag": tag, "prominence": prominence,
+                            "reading_rank": attrs.get("reading_rank")},
+            ))
+    return issues
+
+
+def q_dom_nodes_without_ax(HAG: nx.MultiDiGraph) -> list[Issue]:
+    """
+    Δ1 – Interactive DOM nodes (a, button, input, select, textarea)
+    that have no AX node at all (not even an ignored one).
+    # NL da verificare comportamneto su modali e drop-down menu dove elemento DOM esiste ma non su accessibility tree (compare solo se elemento attivato)
+
+    WCAG: 4.1.2 Name, Role, Value (A)
+    """
+    INTERACTIVE_TAGS = {"a", "button", "input", "select", "textarea",
+                        "details", "summary"}
+    issues = []
+    for nid, attrs in _nodes_by_layer(HAG, "dom"):
+        tag = attrs.get("tag", "")
+        if tag not in INTERACTIVE_TAGS:
+            continue
+        ax_neighbors = _dom_neighbors_via_cross(HAG, nid)
+        if not ax_neighbors:
+            issues.append(Issue(
+                query_id = "Q1.3",
+                title    = "Interactive DOM node with no AX node",
+                wcag     = ["4.1.2"],
+                severity = "serious",
+                layer    = "cross:dom-ax",
+                node_id  = nid,
+                detail   = (
+                    f"<{tag}> element (DOM node {nid}) is interactive but "
+                    f"does not appear in the accessibility tree at all. "
+                    f"It is completely opaque to assistive technologies."
+                ),
+                extra    = {
+                    "tag": tag,
+                    "attr_id": attrs.get("attr_id"),
+                    "aria_hidden": attrs.get("aria_hidden"),
+                },
+            ))
+    return issues
+
+
+def q_ignored_ax_with_visual(HAG: nx.MultiDiGraph) -> list[Issue]:
+    """
+    Δ1 – AX nodes that are marked 'ignored' (hidden from SR) but still
+    have a corresponding visual node with significant prominence.
+
+    These are visually present but programmatically hidden – a mismatch
+    that can hide meaningful content from screen reader users.
+
+    WCAG: 1.3.1 Info and Relationships (A), 4.1.2 Name, Role, Value (A)
+    """
+    issues = []
+    for nid, attrs in _nodes_by_layer(HAG, "ax"):
+        if not attrs.get("ignored"):
+            continue
+        role = str(attrs.get("role") or "")
+        # Only flag roles that normally carry meaning
+        if role in ("none", "presentation", "InlineTextBox",
+                    "ListMarker", "ignored"):
+            continue
+        vis_neighbors = [
+            v for v in _ax_neighbors_via_cross(HAG, nid)
+            if HAG.nodes[v].get("layer") == "visual"
+        ]
+        for vis_nid in vis_neighbors:
+            prom = HAG.nodes[vis_nid].get("prominence", 0)
+            if prom > 0.02:   # at least 2% of viewport
+                issues.append(Issue(
+                    query_id = "Q1.4",
+                    title    = "Ignored AX node with prominent visual counterpart",
+                    wcag     = ["1.3.1", "4.1.2"],
+                    severity = "serious",
+                    layer    = "cross:ax-visual",
+                    node_id  = nid,
+                    detail   = (
+                        f"AX node role='{role}' is marked ignored "
+                        f"(reason: {attrs.get('ignored_reasons','unknown')}) "
+                        f"but its visual counterpart occupies "
+                        f"{prom*100:.1f}% of the viewport. "
+                        f"Content may be visible but inaccessible."
+                    ),
+                    extra    = {"role": role, "prominence": prom,
+                                "vis_node": vis_nid,
+                                "ignored_reasons": attrs.get("ignored_reasons")},
+                ))
+    return issues
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Δ2 queries  –  AX - Visual order gap
+#   "what SR reads" vs "what sighted users perceive first"
+# ─────────────────────────────────────────────────────────────────────────────
+
+
+def q_focus_order_vs_visual(HAG: nx.MultiDiGraph) -> list[Issue]:
+    """
+    Δ2 – Detect focusable AX nodes whose visual reading_rank differs greatly
+    from their position in the AX child traversal order.
+
+    Focusable elements with a wrong visual position violate 2.4.3 Focus Order.
+
+    WCAG: 2.4.3 Focus Order (A)
+    #NL: corrispettivo check disallineamento ordine visivo e screen reader / tab
+    """
+    FOCUSABLE_ROLES = {
+        "link", "button", "textbox", "combobox", "listbox",
+        "checkbox", "radio", "menuitem", "tab", "slider",
+        "spinbutton", "searchbox", "switch",
+    }
+    ax_order = _ax_reading_order(HAG)
+    ax_rank  = {nid: i for i, (nid, _) in enumerate(ax_order)}
+    max_ax   = max(ax_rank.values(), default=1) or 1
+
+    issues = []
+    focusable = [
+        (nid, attrs) for nid, attrs in ax_order
+        if str(attrs.get("role") or "").lower() in FOCUSABLE_ROLES
+        or str(attrs.get("aria_focusable") or "") == "True"
+    ]
+
+    for ax_nid, ax_attrs in focusable:
+        vis_neighbors = [
+            v for v in _ax_neighbors_via_cross(HAG, ax_nid)
+            if HAG.nodes[v].get("layer") == "visual"
+        ]
+        if not vis_neighbors:
+            continue
+
+        best_vis = max(vis_neighbors,
+                       key=lambda v: HAG.nodes[v].get("prominence", 0))
+        vis_attrs   = HAG.nodes[best_vis]
+        vis_r       = vis_attrs.get("reading_rank", 0)
+        max_vis     = max(
+            (HAG.nodes[v].get("reading_rank", 0)
+             for v in HAG.nodes()
+             if HAG.nodes[v].get("layer") == "visual"),
+            default=1,
+        ) or 1
+
+        ax_r_norm  = ax_rank[ax_nid] / max_ax
+        vis_r_norm = vis_r / max_vis
+        delta      = int(abs(ax_r_norm - vis_r_norm) * max_ax)
+
+        if delta >= 8:
+            role = str(ax_attrs.get("role") or "")
+            name = ax_attrs.get("name") or ""
+            issues.append(Issue(
+                query_id = "Q2.2",
+                title    = "Focus order diverges from visual order",
+                wcag     = ["2.4.3"],
+                severity = "serious",
+                layer    = "cross:ax-visual",
+                node_id  = ax_nid,
+                detail   = (
+                    f"Focusable element role='{role}' name='{name}' "
+                    f"is at tab-order position #{ax_rank[ax_nid]+1} "
+                    f"but visual rank #{vis_r}. "
+                    f"Keyboard users tabbing through the page will jump "
+                    f"unexpectedly (circa {delta} positions off)."
+                ),
+                extra = {
+                    "role": role, "name": name,
+                    "ax_rank": ax_rank[ax_nid], "visual_rank": vis_r,
+                    "delta": delta,
+                },
+            ))
+    return issues
+
+def q_reading_order_mismatch( 
+    HAG: nx.MultiDiGraph,
+    prominence_threshold: float = 0.05,
+    rank_distance_threshold: int = 5,
+) -> list[Issue]:
+    """
+    Δ2 – Detect elements whose AX reading order differs substantially from
+    their visual reading order (by rank_distance_threshold positions or more),
+    but only for elements with significant visual prominence.
+
+    High prominence + large order mismatch = likely confusing for SR users
+    navigating a page they cannot see.
+
+    WCAG: 1.3.2 Meaningful Sequence (A), 2.4.3 Focus Order (A)
+    #NL: corrispettivo check disallineamento ordine visivo e screen reader / tab
+    """
+    ax_order  = _ax_reading_order(HAG)        # [(nid, attrs), …]
+    vis_order = _visual_reading_order(HAG)     # [(nid, attrs), …]
+
+    # Build rank lookups
+    ax_rank:  dict[str, int] = {nid: i for i, (nid, _) in enumerate(ax_order)}
+    vis_rank: dict[str, int] = {nid: d.get("reading_rank", 0)
+                                 for nid, d in vis_order}
+
+    # Build a mapping: AX node → its visual counterpart's reading_rank
+    ax_to_vis_rank: dict[str, int] = {}
+    for ax_nid, ax_attrs in ax_order:
+        vis_neighbors = [
+            v for v in _ax_neighbors_via_cross(HAG, ax_nid)
+            if HAG.nodes[v].get("layer") == "visual"
+        ]
+        if vis_neighbors:
+            # pick the most prominent visual node
+            best_vis = max(
+                vis_neighbors,
+                key=lambda v: HAG.nodes[v].get("prominence", 0),
+            )
+            ax_to_vis_rank[ax_nid] = vis_rank.get(best_vis, 0)
+
+    # Normalize visual ranks to the same 0..N scale as AX ranks
+    max_vis = max(ax_to_vis_rank.values(), default=1) or 1
+    max_ax  = max(ax_rank.values(),        default=1) or 1
+    issues  = []
+
+    for ax_nid, ax_attrs in ax_order:
+        if ax_nid not in ax_to_vis_rank:
+            continue
+        vis_r_raw = ax_to_vis_rank[ax_nid]
+        # Normalise both to 0..1 then compare
+        ax_r_norm  = ax_rank[ax_nid]  / max_ax
+        vis_r_norm = vis_r_raw        / max_vis
+        delta_norm = ax_r_norm - vis_r_norm   # positive = AX later than visual
+
+        # Convert to "number of AX positions" for readability
+        delta_positions = int(abs(delta_norm) * max_ax)
+
+        if delta_positions < rank_distance_threshold:
+            continue
+
+        # Only flag if the visual element is prominent
+        vis_neighbors = [
+            v for v in _ax_neighbors_via_cross(HAG, ax_nid)
+            if HAG.nodes[v].get("layer") == "visual"
+        ]
+        max_prom = max(
+            (HAG.nodes[v].get("prominence", 0) for v in vis_neighbors),
+            default=0,
+        )
+        if max_prom < prominence_threshold:
+            continue
+
+        role = str(ax_attrs.get("role") or "")
+        name = ax_attrs.get("name") or ""
+        direction = "after" if delta_norm > 0 else "before"
+
+        issues.append(Issue(
+            query_id = "Q2.1",
+            title    = "Reading order mismatch (AX vs visual)",
+            wcag     = ["1.3.2", "2.4.3"],
+            severity = "serious" if delta_positions > 15 else "moderate",
+            layer    = "cross:ax-visual",
+            node_id  = ax_nid,
+            detail   = (
+                f"AX node role='{role}' name='{name}' appears at Screen Reader position "
+                f"#{ax_rank[ax_nid]+1} but at visual rank "
+                f"#{vis_r_raw} (circa {delta_positions} positions {direction} "
+                f"expected). Visual prominence={max_prom:.3f}. "
+                f"Screen reader users encounter this element "
+                f"{'much later' if direction=='after' else 'much earlier'} "
+                f"than sighted users."
+            ),
+            extra = {
+                "role": role, "name": name,
+                "ax_rank": ax_rank[ax_nid],
+                "visual_rank": vis_r_raw,
+                "delta_positions": delta_positions,
+                "prominence": max_prom,
+            },
+        ))
+
+    return issues
+
+
+def q_heading_hierarchy(HAG: nx.MultiDiGraph) -> list[Issue]:
+    """
+    Δ0/Δ2 – Detect broken heading hierarchy in the AX tree:
+      • heading level skipped (e.g. h1 → h3, missing h2)
+      • multiple h1 elements on the same page
+      • heading with no name / empty accessible name
+
+    WCAG: 1.3.1 Info and Relationships (A),
+          2.4.6 Headings and Labels (AA)
+    """
+    issues  = []
+    headings = [
+        (nid, attrs)
+        for nid, attrs in _nodes_by_layer(HAG, "ax")
+        if str(attrs.get("role") or "").lower() in ("heading",)
+        and not attrs.get("ignored")
+    ]
+
+    # Sort headings by AX reading order
+    ax_order_map = {
+        nid: i
+        for i, (nid, _) in enumerate(_ax_reading_order(HAG))
+    }
+    headings.sort(key=lambda x: ax_order_map.get(x[0], 9999))
+
+    prev_level = 0
+    h1_count   = 0
+
+    for nid, attrs in headings:
+        level = int(attrs.get("aria_level") or attrs.get("pw_level") or 0)
+        name  = attrs.get("name") or ""
+
+        # Empty heading
+        if not name.strip():
+            issues.append(Issue(
+                query_id = "Q0.1",
+                title    = "Heading with empty accessible name",
+                wcag     = ["1.3.1", "2.4.6"],
+                severity = "serious",
+                layer    = "ax",
+                node_id  = nid,
+                detail   = (
+                    f"h{level} element has no accessible name. "
+                    f"Screen reader users cannot understand the section topic."
+                ),
+                extra    = {"level": level},
+            ))
+
+        # Multiple h1
+        if level == 1:
+            h1_count += 1
+            if h1_count > 1:
+                issues.append(Issue(
+                    query_id = "Q0.2",
+                    title    = "Multiple h1 headings on the page",
+                    wcag     = ["1.3.1", "2.4.6"],
+                    severity = "moderate",
+                    layer    = "ax",
+                    node_id  = nid,
+                    detail   = (
+                        f"This is the {h1_count}. h1 heading found (name='{name}'). "
+                        f"Pages should generally have a single h1 as the main title."
+                    ),
+                    extra    = {"level": level, "name": name, "h1_count": h1_count},
+                ))
+
+        # Level skipped
+        if level > 0 and prev_level > 0 and level > prev_level + 1:
+            issues.append(Issue(
+                query_id = "Q0.3",
+                title    = "Heading level skipped",
+                wcag     = ["1.3.1", "2.4.6"],
+                severity = "moderate",
+                layer    = "ax",
+                node_id  = nid,
+                detail   = (
+                    f"Heading hierarchy jumps from h{prev_level} to "
+                    f"h{level} (name='{name}'). "
+                    f"Skipping levels breaks the outline structure that "
+                    f"screen reader users rely on for navigation."
+                ),
+                extra    = {"prev_level": prev_level, "level": level, "name": name},
+            ))
+
+        if level > 0:
+            prev_level = level
+
+    return issues
+
+
+
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Δ0 queries  –  intra-layer DOM / AX issues
+# ─────────────────────────────────────────────────────────────────────────────
+
+def q_images_missing_alt(HAG: nx.MultiDiGraph) -> list[Issue]:
+    """
+    Δ0 – Images (<img>, role=img) with no accessible name.
+
+    Checks both the DOM layer (alt attribute) and the AX layer
+    (accessible name computed by the browser).
+
+    WCAG: 1.1.1 Non-text Content (A)
+    """
+    issues = []
+
+    # AX layer check: img/image role with empty name
+    for nid, attrs in _nodes_by_layer(HAG, "ax"):
+        if attrs.get("ignored"):
+            continue
+        role = str(attrs.get("role") or "").lower()
+        if role not in ("img", "image"):
+            continue
+        name = (attrs.get("name") or "").strip()
+        if not name:
+            # Check if it's intentionally decorative (aria-hidden on DOM side)
+            dom_neighbors = _neighbors_by_relation(HAG, nid, "dom_to_ax")
+            aria_hidden = any(
+                str(HAG.nodes[d].get("aria_hidden") or "") == "true"
+                for d in dom_neighbors
+                if HAG.nodes[d].get("layer") == "dom"
+            )
+            if not aria_hidden:
+                # Get prominence from visual layer
+                vis_nodes = _ax_neighbors_via_cross(HAG, nid)
+                prom = max(
+                    (HAG.nodes[v].get("prominence", 0) for v in vis_nodes
+                     if HAG.nodes[v].get("layer") == "visual"),
+                    default=0,
+                )
+                issues.append(Issue(
+                    query_id = "Q0.4",
+                    title    = "Image missing accessible name",
+                    wcag     = ["1.1.1"],
+                    severity = "critical" if prom > 0.05 else "serious",
+                    layer    = "ax",
+                    node_id  = nid,
+                    detail   = (
+                        f"Image (role='{role}') has no accessible name "
+                        f"and is not marked as decorative. "
+                        f"Visual prominence={prom:.3f}. "
+                        f"Screen reader will announce it as 'image' with no context."
+                    ),
+                    extra    = {"role": role, "prominence": prom},
+                ))
+    return issues
+
+
+def q_form_inputs_without_label(HAG: nx.MultiDiGraph) -> list[Issue]:
+    """
+    Δ0/Δ1 – Form inputs (<input>, <select>, <textarea>) that have no
+    accessible name in the AX tree AND no label_for edge in the DOM layer.
+
+    WCAG: 1.3.1 Info and Relationships (A), 3.3.2 Labels or Instructions (AA)
+    """
+    INPUT_ROLES = {"textbox", "searchbox", "combobox", "listbox",
+                   "checkbox", "radio", "spinbutton", "slider", "switch"}
+    issues = []
+
+    for nid, attrs in _nodes_by_layer(HAG, "ax"):
+        if attrs.get("ignored"):
+            continue
+        role = str(attrs.get("role") or "").lower()
+        if role not in INPUT_ROLES:
+            continue
+
+        name = (attrs.get("name") or "").strip()
+        if name:
+            continue  # has accessible name — fine
+
+        # Double-check DOM layer for label_for edge targeting this node's DOM peer
+        dom_peers = _neighbors_by_relation(HAG, nid, "dom_to_ax")
+        has_label = False
+        for dom_nid in dom_peers:
+            # Any DOM node that has an incoming label_for edge pointing here?
+            for u, _, d in HAG.in_edges(dom_nid, data=True):
+                if d.get("relation") == "label_for":
+                    has_label = True
+                    break
+            if has_label:
+                break
+
+        if not has_label:
+            issues.append(Issue(
+                query_id = "Q0.5",
+                title    = "Form input without accessible label",
+                wcag     = ["1.3.1", "3.3.2"],
+                severity = "critical",
+                layer    = "cross:dom-ax",
+                node_id  = nid,
+                detail   = (
+                    f"Form control role='{role}' has no accessible name "
+                    f"and no associated <label> element. "
+                    f"Screen reader users will not know the purpose of this field."
+                ),
+                extra    = {"role": role},
+            ))
+    return issues
+
+
+def q_landmark_structure(HAG: nx.MultiDiGraph) -> list[Issue]:
+    """
+    Δ0 – Check landmark region structure:
+      • Page has no <main> landmark
+      • Page has no navigation landmark
+      • Multiple <main> elements
+      • Landmarks without accessible names (when more than one of same type)
+
+    WCAG: 1.3.6 Identify Purpose (AAA), 2.4.1 Bypass Blocks (A)
+    """
+    LANDMARK_ROLES = {
+        "main", "navigation", "banner", "contentinfo",
+        "complementary", "form", "search", "region",
+    }
+    issues  = []
+    by_role: dict[str, list[tuple[str, dict]]] = {}
+
+    for nid, attrs in _nodes_by_layer(HAG, "ax"):
+        if attrs.get("ignored"):
+            continue
+        role = str(attrs.get("role") or "").lower()
+        if role in LANDMARK_ROLES:
+            by_role.setdefault(role, []).append((nid, attrs))
+
+    # No <main>
+    if "main" not in by_role:
+        issues.append(Issue(
+            query_id = "Q0.6",
+            title    = "No main landmark",
+            wcag     = ["2.4.1"],
+            severity = "serious",
+            layer    = "ax",
+            node_id  = "ax:—",
+            detail   = (
+                "The page has no <main> landmark. "
+                "Screen reader users cannot skip directly to the main content."
+            ),
+        ))
+
+    # No navigation landmark
+    if "navigation" not in by_role:
+        issues.append(Issue(
+            query_id = "Q0.7",
+            title    = "No navigation landmark",
+            wcag     = ["2.4.1"],
+            severity = "moderate",
+            layer    = "ax",
+            node_id  = "ax:—",
+            detail   = (
+                "The page has no <nav> / navigation landmark. "
+                "Screen reader users cannot jump to site navigation."
+            ),
+        ))
+
+    # Multiple <main>
+    if len(by_role.get("main", [])) > 1:
+        for nid, attrs in by_role["main"][1:]:
+            issues.append(Issue(
+                query_id = "Q0.8",
+                title    = "Multiple main landmarks",
+                wcag     = ["1.3.6"],
+                severity = "serious",
+                layer    = "ax",
+                node_id  = nid,
+                detail   = (
+                    f"Page contains {len(by_role['main'])} <main> landmarks. "
+                    f"Only one is allowed per page."
+                ),
+            ))
+
+    # Duplicate landmark roles without accessible names
+    for role, nodes in by_role.items():
+        if len(nodes) <= 1:
+            continue
+        for nid, attrs in nodes:
+            name = (attrs.get("name") or "").strip()
+            if not name:
+                issues.append(Issue(
+                    query_id = "Q0.9",
+                    title    = "Duplicate landmark without accessible name",
+                    wcag     = ["1.3.6"],
+                    severity = "moderate",
+                    layer    = "ax",
+                    node_id  = nid,
+                    detail   = (
+                        f"There are {len(nodes)} '{role}' landmarks on this page "
+                        f"but this one has no accessible name (aria-label / aria-labelledby). "
+                        f"Screen reader users cannot distinguish between them."
+                    ),
+                    extra    = {"role": role, "count": len(nodes)},
+                ))
+
+    return issues
+
+
+def q_interactive_without_name(HAG: nx.MultiDiGraph) -> list[Issue]:
+    """
+    Δ0 – Buttons and links with no accessible name.
+
+    WCAG: 4.1.2 Name, Role, Value (A), 2.4.6 Headings and Labels (AA)
+    """
+    TARGET_ROLES = {"button", "link", "menuitem", "tab", "treeitem"}
+    issues = []
+
+    for nid, attrs in _nodes_by_layer(HAG, "ax"):
+        if attrs.get("ignored"):
+            continue
+        role = str(attrs.get("role") or "").lower()
+        if role not in TARGET_ROLES:
+            continue
+        name = (attrs.get("name") or "").strip()
+        if not name:
+            vis_nodes = _ax_neighbors_via_cross(HAG, nid)
+            prom = max(
+                (HAG.nodes[v].get("prominence", 0) for v in vis_nodes
+                 if HAG.nodes[v].get("layer") == "visual"),
+                default=0,
+            )
+            issues.append(Issue(
+                query_id = "Q0.10",
+                title    = f"{role.capitalize()} without accessible name",
+                wcag     = ["4.1.2", "2.4.6"],
+                severity = "critical",
+                layer    = "ax",
+                node_id  = nid,
+                detail   = (
+                    f"Interactive element role='{role}' has no accessible name. "
+                    f"Screen reader will announce only '{role}' with no context. "
+                    f"Visual prominence={prom:.3f}."
+                ),
+                extra    = {"role": role, "prominence": prom},
+            ))
+    return issues
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Δ3 queries  –  DOM - Visual gap
+# ─────────────────────────────────────────────────────────────────────────────
+
+def q_prominent_visual_without_dom_semantics(HAG: nx.MultiDiGraph) -> list[Issue]:
+    """
+    Δ3 – Visually prominent elements whose DOM node carries no semantic role
+    (plain <div> or <span>) and has no ARIA role attribute.
+
+    These are elements that "look important" but convey no structure to AT.
+
+    WCAG: 1.3.1 Info and Relationships (A)
+    """
+    SEMANTIC_TAGS = {
+        "main", "nav", "header", "footer", "aside", "section",
+        "article", "h1", "h2", "h3", "h4", "h5", "h6",
+        "p", "ul", "ol", "li", "button", "a", "input",
+        "select", "textarea", "table", "th", "td", "form",
+        "figure", "figcaption", "blockquote", "details", "summary",
+    }
+    issues = []
+
+    for vis_nid, vis_attrs in _nodes_by_layer(HAG, "visual"):
+        prom = vis_attrs.get("prominence", 0)
+        if prom < 0.08:
+            continue
+
+        dom_neighbors = _neighbors_by_relation(HAG, vis_nid, "dom_to_visual")
+        for dom_nid in dom_neighbors:
+            dom_attrs = HAG.nodes[dom_nid]
+            tag       = dom_attrs.get("tag", "")
+            aria_role = dom_attrs.get("attr_role", "")
+            if tag in ("div", "span") and not aria_role:
+                issues.append(Issue(
+                    query_id = "Q3.1",
+                    title    = "Prominent visual element with no semantic DOM role",
+                    wcag     = ["1.3.1"],
+                    severity = "moderate",
+                    layer    = "cross:dom-visual",
+                    node_id  = dom_nid,
+                    detail   = (
+                        f"<{tag}> element occupies {prom*100:.1f}% of the viewport "
+                        f"(visual rank #{vis_attrs.get('reading_rank')}) "
+                        f"but carries no semantic HTML tag or ARIA role. "
+                        f"Structure is invisible to assistive technologies."
+                    ),
+                    extra    = {
+                        "tag": tag, "prominence": prom,
+                        "vis_node": vis_nid,
+                        "reading_rank": vis_attrs.get("reading_rank"),
+                    },
+                ))
+    return issues
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Registry + runner
+# ─────────────────────────────────────────────────────────────────────────────
+
+QUERY_REGISTRY: list[tuple[str, callable]] = [
+    # Δ0 – intra-layer
+    ("Q0.1–Q0.3  Heading hierarchy",           q_heading_hierarchy),
+    ("Q0.4       Images missing alt",           q_images_missing_alt),
+    ("Q0.5       Form inputs without label",    q_form_inputs_without_label),
+    ("Q0.6–Q0.9  Landmark structure",           q_landmark_structure),
+    ("Q0.10      Interactive without name",     q_interactive_without_name),
+    # Δ1 – AX - DOM
+    ("Q1.1       AX node without visual",       q_ax_nodes_without_visual),
+    ("Q1.2       Visual node without AX",       q_visual_nodes_without_ax),
+    ("Q1.3       Interactive DOM without AX",   q_dom_nodes_without_ax),
+    ("Q1.4       Ignored AX with visual",       q_ignored_ax_with_visual),
+    # Δ2 – AX - Visual order
+    ("Q2.1       Reading order mismatch",       q_reading_order_mismatch),
+    ("Q2.2       Focus order vs visual order",  q_focus_order_vs_visual),
+    # Δ3 – DOM - Visual
+    ("Q3.1       Prominent div without role",   q_prominent_visual_without_dom_semantics),
+]
+
+SEVERITY_ORDER = {"critical": 0, "serious": 1, "moderate": 2, "minor": 3}
+
+
+def run_all_queries(HAG: nx.MultiDiGraph) -> list[Issue]:
+    """Run every registered query and return a deduplicated, sorted issue list."""
+    all_issues: list[Issue] = []
+    for label, fn in QUERY_REGISTRY:
+        try:
+            found = fn(HAG)
+            print(f"  {label:<45} → {len(found)} issue(s)")
+            all_issues.extend(found)
+        except Exception as e:
+            print(f"  {label:<45} → ERROR: {e}")
+
+    # Sort by severity then query_id
+    all_issues.sort(
+        key=lambda i: (SEVERITY_ORDER.get(i.severity, 9), i.query_id)
+    )
+    return all_issues
+
+
+def run_query(HAG: nx.MultiDiGraph, query_id: str) -> list[Issue]:
+    """Run a single query by its ID prefix (e.g. 'Q1.1')."""
+    for label, fn in QUERY_REGISTRY:
+        if query_id in label:
+            return fn(HAG)
+    raise ValueError(f"Query '{query_id}' not found in registry")
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Report
+# ─────────────────────────────────────────────────────────────────────────────
+
+_SEV_ICON = {
+    "critical": "🔴",
+    "serious":  "🟠",
+    "moderate": "🟡",
+    "minor":    "🔵",
+}
+
+def print_report(issues: list[Issue], verbose: bool = False) -> None:
+    sev_counts: dict[str, int] = {}
+    wcag_counts: dict[str, int] = {}
+    for iss in issues:
+        sev_counts[iss.severity] = sev_counts.get(iss.severity, 0) + 1
+        for sc in iss.wcag:
+            wcag_counts[sc] = wcag_counts.get(sc, 0) + 1
+
+    print(f"\n{'═'*68}")
+    print("  ACCESSIBILITY ISSUE REPORT")
+    print(f"{'═'*68}")
+    print(f"  Total issues  : {len(issues)}")
+    for sev in ("critical", "serious", "moderate", "minor"):
+        c = sev_counts.get(sev, 0)
+        if c:
+            print(f"  {_SEV_ICON[sev]} {sev:<10}: {c}")
+    print(f"\n  WCAG SC breakdown:")
+    for sc, cnt in sorted(wcag_counts.items()):
+        print(f"    SC {sc:<8} {cnt} issue(s)")
+    print(f"{'─'*68}")
+
+    for iss in issues:
+        icon = _SEV_ICON.get(iss.severity, "⚪")
+        wcag_str = ", ".join(f"SC {sc}" for sc in iss.wcag)
+        print(f"\n  {icon} [{iss.query_id}] {iss.title}")
+        print(f"     WCAG : {wcag_str}")
+        print(f"     Layer: {iss.layer}")
+        print(f"     Node : {iss.node_id}")
+        if verbose:
+            print(f"     {iss.detail}")
+        else:
+            # truncate detail to 120 chars in compact mode
+            short = iss.detail[:120] + ("…" if len(iss.detail) > 120 else "")
+            print(f"     {short}")
+
+    print(f"\n{'═'*68}\n")
+
+
+def save_report_json(issues: list[Issue], path: str) -> None:
+    with open(path, "w", encoding="utf-8") as f:
+        json.dump([i.as_dict() for i in issues], f, indent=2, default=str)
+    print(f"[*] Report saved → {path}")
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# CLI – standalone usage: python hag_queries.py <hag.json> [--verbose]
+# ─────────────────────────────────────────────────────────────────────────────
+
+def _load_hag(path: str) -> nx.MultiDiGraph:
+    with open(path, encoding="utf-8") as f:
+        data = json.load(f)
+    return nx.node_link_graph(data, multigraph=True, directed=True)
+
+
+def _cli() -> None:
+    import argparse
+    p = argparse.ArgumentParser(
+        description="Run accessibility queries on a saved HAG JSON file"
+    )
+    p.add_argument("graph", help="Path to HAG node-link JSON file")
+    p.add_argument("--verbose", "-v", action="store_true",
+                   help="Show full issue detail")
+    p.add_argument("--report", "-r", default=None,
+                   help="Save JSON report to this path")
+    p.add_argument("--query", "-q", default=None,
+                   help="Run only this query (e.g. Q1.1)")
+    args = p.parse_args()
+
+    print(f"[*] Loading HAG from {args.graph} …")
+    HAG = _load_hag(args.graph)
+    print(f"    → {HAG.number_of_nodes()} nodes, {HAG.number_of_edges()} edges")
+
+    print("\n[*] Running queries …")
+    if args.query:
+        issues = run_query(HAG, args.query)
+    else:
+        issues = run_all_queries(HAG)
+
+    print_report(issues, verbose=args.verbose)
+
+    if args.report:
+        save_report_json(issues, args.report)
+    
+
+    
+    """
+    ###----- gia in def q_focus_order_vs_visual
+    ax_order=_ax_reading_order(HAG)
+    
+    ax_rank:  dict[str, int] = {nid: i for i, (nid, _) in enumerate(ax_order)}
+    print(f"ax_rank:{ax_rank}")
+
+
+    FOCUSABLE_TABBLE_ROLES = {
+        "link", "button", "textbox", "combobox", "listbox",
+        "checkbox", "radio", "menuitem", "tab", "slider",
+        "spinbutton", "searchbox", "switch",
+    }
+    focusable = [
+        (nid, attrs) for nid, attrs in ax_order
+        if str(attrs.get("role") or "").lower() in FOCUSABLE_TABBLE_ROLES
+        or str(attrs.get("aria_focusable") or "") == "True"
+    ]
+    print(f"focusable:{focusable}")
+
+    ax_rank_focusable:  dict[str, int] = {nid: i for i, (nid, _) in enumerate(focusable)}
+    print(f"ax_rank_focusable:{ax_rank_focusable}")
+
+    ##------------
+    """
+    dom_order=_dom_reading_order(HAG)
+    dom_rank:  dict[str, int] = {nid: i for i, (nid, _) in enumerate(dom_order)}
+    print(f"dom_rank:{dom_rank}")
+
+
+if __name__ == "__main__":
+    _cli()
diff --git a/scripts/costruzione_grafo/heterogeneous_ax_graph.py b/scripts/costruzione_grafo/heterogeneous_ax_graph.py
new file mode 100644
index 0000000..1b2af73
--- /dev/null
+++ b/scripts/costruzione_grafo/heterogeneous_ax_graph.py
@@ -0,0 +1,1203 @@
+"""
+heterogeneous_ax_graph.py
+=========================
+Build a heterogeneous accessibility graph (HAG) from a web page, combining
+three complementary views of the same page into a single NetworkX graph:
+
+  Layer A – DOM graph          (structural/syntactic view)
+  Layer B – Accessibility tree (semantic/prescriptive view)
+  Layer C – Visual layout      (perceptual/bounding-box view)
+
+Cross-edges connect the three layers:
+  A→B  dom_to_ax      DOM node ↔ AX node  (via backendDOMNodeId)
+  A→C  dom_to_visual  DOM node ↔ Visual node  (via backendNodeId)
+  B→C  ax_to_visual   AX node  ↔ Visual node  (via backendDOMNodeId)
+
+Node prefixes in the graph:
+  "dom:{nodeId}"     – DOM layer
+  "ax:{nodeId}"      – AX layer
+  "vis:{backendId}"  – Visual layer
+
+Usage
+-----
+    python heterogeneous_ax_graph.py <url> [--output hag.graphml] [--draw] [--no-ignored]
+    python heterogeneous_ax_graph.py https://www.regione.toscana.it/regione/amministrazione-trasparente/bandi-di-concorso --output graph_hete.json --draw
+    python heterogeneous_ax_graph.py https://www.regione.toscana.it/regione/amministrazione-trasparente/bandi-di-concorso --output graph_hete_ignored.json --draw --no-ignored  #per ignorare quelli nodi che hanno ignored=true
+
+
+Requirements
+------------
+    pip install playwright cdp-use networkx matplotlib pillow
+    playwright install chromium
+"""
+
+"""Riferimenti utili
+browser_use:
+site-packages\\browser_use\dom\\views.py  #per aria-attributes
+
+"""
+
+"""
+Architettura del grafo eterogeno
+Il grafo usa nx.MultiDiGraph perché tra la stessa coppia di nodi possono esistere archi di tipo diverso — ad esempio un nodo DOM e un nodo AX legati sia da dom_to_ax che eventualmente da labelledby.
+I prefissi dei nodi (dom:N, ax:N, vis:N) garantiscono che i tre namespace non collidano mai, anche quando i backend node ID si sovrappongono numericamente tra layers.
+Layer A — DOM (build_dom_layer): estrae l'albero completo via DOM.getDocument con depth: -1 e pierce: True (attraversa shadow DOM). Costruisce archi strutturali parent→child, archi label_for da <label for="X"> verso l'input corrispondente, e archi ARIA (aria-labelledby, aria-describedby) risolti per id HTML.
+Layer B — AX (build_ax_layer): invariato rispetto allo script precedente, ora lavora in parallelo agli altri due layer. Mantiene i nodi ignored (utili per Δ1 — confronto tra cosa il markup dichiara e cosa lo screen reader annuncia davvero).
+Layer C — Visual (build_visual_layer): chiama DOM.getBoxModel per ogni elemento DOM di tipo nodeType=1 (solo Element, non TextNode o Comment). Scarta elementi con area zero (display:none, collapsed). Calcola due attributi chiave: prominence (frazione della viewport occupata) e reading_rank (posizione nell'ordine visivo top→bottom, left→right). Aggiunge archi visual_overlap tra elementi sovrapposti e visual_sibling tra elementi allineati sulla stessa riga visiva.
+Cross-edges (add_cross_edges): i tre layer condividono il backendNodeId come chiave universale — CDP lo espone sia nel DOM tree (backendNodeId) che nell'AX tree (backendDOMNodeId), quindi il join è diretto. I 93 cross-edges del test (39 dom→ax + 27 dom→visual + 27 ax→visual) sono esattamente i punti dove puoi misurare Δ1 e Δ2 discussi prima.
+"""
+
+import argparse
+import asyncio
+import base64
+import json
+import socket
+import urllib.request
+from typing import Optional, Union, List, Dict, Any
+
+import networkx as nx
+from playwright.async_api import async_playwright
+from cdp_use import CDPClient
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Utilities
+# ─────────────────────────────────────────────────────────────────────────────
+
+def _free_port() -> int:
+    with socket.socket() as s:
+        s.bind(("", 0))
+        return s.getsockname()[1]
+
+
+def _attrs(**kw) -> dict:
+    """Return a dict with None / empty-string values removed."""
+    return {k: v for k, v in kw.items() if v is not None and v != ""}
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Layer A – DOM graph
+# ─────────────────────────────────────────────────────────────────────────────
+
+def _parse_attrs(flat_list: list[str]) -> dict[str, str]:
+    """Convert CDP's flat attribute array [name, val, name, val, …] to dict."""
+    result = {}
+    it = iter(flat_list)
+    for name in it:
+        result[name] = next(it, "")
+    return result
+
+
+def _dom_node_id(node_id: int) -> str:
+    return f"dom:{node_id}"
+
+
+def _flatten_dom_tree(raw_node: dict, result: Optional[dict] = None) -> dict:
+    """Recursively flatten the DOM tree returned by DOM.getDocument."""
+    if result is None:
+        result = {}
+
+    node_id     = raw_node.get("nodeId")
+    backend_id  = raw_node.get("backendNodeId")
+    node_type   = raw_node.get("nodeType", 0)   # 1=Element, 3=Text, …
+    node_name   = raw_node.get("nodeName", "")
+    node_value  = raw_node.get("nodeValue", "")
+    node_parent   = raw_node.get("parenId","")
+    attrs_flat  = raw_node.get("attributes") or []
+    attrs       = _parse_attrs(attrs_flat)
+
+    if node_id is not None:
+        result[node_id] = {
+            "raw_node":  raw_node,          # kept for edge building
+            "backend_id": backend_id,
+            "node_type":  node_type,
+            "node_name":  node_name.lower(),
+            "node_value": node_value,
+            "node_parent": node_parent,
+            "tag":        node_name.lower() if node_type == 1 else None,
+            # useful HTML attributes
+            "attr_id":    attrs.get("id"),
+            "attr_class": attrs.get("class"),
+            "attr_role":  attrs.get("role"),
+            "attr_focusable": attrs.get("focusable"),
+            "attr_focused":    attrs.get("focused"),
+            "attr_aria_label":       attrs.get("aria-label"),
+            "attr_aria_labelledby":  attrs.get("aria-labelledby"),
+            "attr_aria_describedby": attrs.get("aria-describedby"),
+            "attr_aria_hidden":      attrs.get("aria-hidden"),
+            "attr_tabindex":         attrs.get("tabindex"),
+            "attr_href":             attrs.get("href"),
+            "attr_src":              attrs.get("src"),
+            "attr_alt":              attrs.get("alt"),
+            "attr_type":             attrs.get("type"),
+            "attr_for":              attrs.get("for"),
+        }
+
+    for child in raw_node.get("children") or []:
+        _flatten_dom_tree(child, result)
+
+    return result
+
+
+async def build_dom_layer(dom_flat: dict,cdp: CDPClient) -> tuple[nx.MultiDiGraph, dict[int, str]]:
+    """
+    Build DOM sub-graph.
+    Returns (graph, backend_id → graph_node_id mapping).
+    """
+    G: nx.MultiDiGraph = nx.MultiDiGraph()
+    backend_to_gid: dict[int, str] = {}
+
+    # pass 1 – add nodes
+    for node_id, info in dom_flat.items():
+        gid = _dom_node_id(node_id)
+        backend_id = info.get("backend_id")
+
+        # Fetch outerHTML for debugging / inspection
+        node_outerHtml= await cdp.send_raw(
+                "DOM.getOuterHTML",
+                {"nodeId": node_id} 
+            )
+        node_attrs = _attrs(
+            layer        = "dom",
+            node_id      = node_id,
+            backend_id   = backend_id,
+            node_type    = info.get("node_type"),
+            node_name    = info.get("node_name").replace("#",""),#my setup replace because problem to push to neo4j
+            tag          = info.get("tag"),
+            node_value   = info.get("node_value").replace("#","") or None,
+            attr_id      = info.get("attr_id"),
+            attr_class   = info.get("attr_class"),
+            attr_role    = info.get("attr_role"),
+            attr_focusable = info.get("attr_focusable"),
+            attr_focused  = info.get("attr_focused"),
+            aria_label   = info.get("attr_aria_label"),
+            aria_hidden  = info.get("attr_aria_hidden"),
+            aria_labelledby  = info.get("attr_aria_labelledby"),
+            aria_describedby = info.get("attr_aria_describedby"),
+            tabindex     = info.get("attr_tabindex"),
+            href         = info.get("attr_href"),
+            alt          = info.get("attr_alt"),
+            src          = info.get("attr_src"),
+            input_type   = info.get("attr_type"),
+            label_for    = info.get("attr_for"),
+            outerHtml=node_outerHtml.get("outerHTML")[:100].replace("#","") or None,
+            type         = "dom_"+str(info.get("node_type"))+"_"+info.get("node_name").replace("#","")  #my setup
+        )
+        G.add_node(gid, **node_attrs)
+        if backend_id is not None:
+            backend_to_gid[backend_id] = gid
+
+    # pass 2 – structural edges (parent → child)
+    
+    for node_id, info in dom_flat.items():
+        gid = _dom_node_id(node_id)
+        raw = info["raw_node"]        
+        #print(f"[*] Processing DOM node {gid} with {len(raw.get('children') or [])} children and parent {raw.get('parentId')}")
+        for child_raw in raw.get("children") or []:
+            child_nid = child_raw.get("nodeId")
+            if child_nid is not None:
+                child_gid = _dom_node_id(child_nid)
+                if child_gid in G:
+                    G.add_edge(gid, child_gid,
+                               relation="hasChild", layer="dom",type="hasChild_dom")
+        #for parent_raw in raw.get("parentId") or []:
+        parent_nid = raw.get("parentId")
+        if parent_nid is not None:
+            parent_gid = _dom_node_id(parent_nid)
+            if parent_gid in G:
+                G.add_edge(gid,parent_gid,
+                        relation="hasParent", layer="dom",type="hasParent_dom")
+
+    # pass 3 – DOM reference edges
+    #   <label for="X"> → <input id="X">
+    id_attr_to_gid: dict[str, str] = {}
+    for node_id, info in dom_flat.items():
+        attr_id = info.get("attr_id")
+        if attr_id:
+            id_attr_to_gid[attr_id] = _dom_node_id(node_id)
+
+    for node_id, info in dom_flat.items():
+        #print("info",info)
+        gid      = _dom_node_id(node_id)
+        label_for = info.get("attr_for")
+        if label_for and label_for in id_attr_to_gid:
+            target = id_attr_to_gid[label_for]
+            print(f"    [*] Adding additional DOM edge: {gid} -- label_for --> {target}")
+            G.add_edge(gid, target, relation="label_for", layer="dom", type="label_for_dom")
+
+        for aria_attr in ("attr_aria_labelledby", "attr_aria_describedby"):# ("attr_aria_hidden","attr_aria_label" are not edge properties but node properties) this list is different from axe's ones
+            refs = (info.get(aria_attr) or "").split()
+            rel  = aria_attr.replace("attr_aria_", "")
+            for ref_id in refs:
+                if ref_id in id_attr_to_gid:
+                    print(f"    [*] Adding additional DOM edge: {gid} -- {rel} --> {id_attr_to_gid[ref_id]}")
+                    G.add_edge(gid, id_attr_to_gid[ref_id],
+                               relation=rel, layer="dom",type=rel+"_dom")
+
+    return G, backend_to_gid
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Layer B – Accessibility tree
+# ─────────────────────────────────────────────────────────────────────────────
+
+import re
+import yaml
+
+
+def merge_playwright_data(G: nx.MultiDiGraph, pw_flat: dict) -> None:
+    """
+    Match Playwright nodes to CDP nodes by (role, name) and enrich
+    graph node attributes with Playwright-specific computed states.
+    NB: only nodes are managed, not edges, since Playwright snapshot doesn't expose parent/child relationships.
+    """
+    role_name_to_nid: dict[tuple, str] = {}
+    for nid, attrs in G.nodes(data=True):
+        role = str(attrs.get("role") or "").lower()
+        name = str(attrs.get("name") or "").strip()
+        key = (role, name)
+        if key not in role_name_to_nid:
+            role_name_to_nid[key] = nid
+
+    for (role, name), pw_attrs in pw_flat.items():
+        nid = role_name_to_nid.get((role, name))
+        if nid:
+            # Only add keys not already present from CDP
+            existing = G.nodes[nid]
+            for k, v in pw_attrs.items():
+                if k not in existing:
+                    G.nodes[nid][k] = v
+
+def _build_graph_from_pw(pw_flat: dict) -> nx.MultiDiGraph:
+    """Fallback: build a simple graph from Playwright snapshot only."""
+    
+    G= nx.MultiDiGraph() # graph with multiple edges between the same nodes
+    id_map: dict[tuple, str] = {}
+
+    for i, (key, attrs) in enumerate(pw_flat.items()):
+        nid = str(i)
+        id_map[key] = nid
+        attrs["layer"] = "ax"
+        attrs["type"] ="ax_"+attrs["pw_role"]
+        G.add_node(nid, **attrs)
+
+    # Playwright flat dict doesn't carry parent references directly;
+    # reconstruct by depth ordering (parent = most recent node at depth-1)
+    depth_stack: dict[int, str] = {}
+    for i, (key, attrs) in enumerate(pw_flat.items()):
+        nid   = str(i)
+        depth = attrs.get("pw_depth", 0)
+        if depth > 0 and (depth - 1) in depth_stack:
+            G.add_edge(depth_stack[depth - 1], nid, relation="hasChild_pw",type="hasChild_ax_pw")#static, has to be manged
+        depth_stack[depth] = nid
+
+    return G
+
+
+def _flatten_playwright_snapshot(
+    yaml_str: str,
+    result: Optional[dict] = None,
+) -> dict:
+    """
+    Parses Playwright's YAML ARIA snapshot string and flattens it into a dict 
+    keyed by (role, name) for later merging with CDP nodes.
+    """
+    if result is None:
+        result = {}
+
+    try:
+        parsed_data = yaml.safe_load(yaml_str)
+    except Exception as e:
+        print(f"    [!] Failed to parse ARIA snapshot YAML: {e}")
+        return result
+
+    node_regex = re.compile(r'^([a-zA-Z0-9_-]+)(?:\s+"([^"]*)")?(?:\s+\[(.*)\])?$')
+
+    def _process_node(node: Any, depth: int = 0):
+        if isinstance(node, list):
+            for item in node:
+                _process_node(item, depth)
+        elif isinstance(node, dict):
+            for key, value in node.items():
+                _parse_single_node(key, value, depth)
+        elif isinstance(node, str):
+            _parse_single_node(node, None, depth)
+
+    def _parse_single_node(node_key: str, node_value: Any, depth: int):
+        if node_key == "box":
+            return
+
+        match = node_regex.match(node_key.strip())
+        if not match:
+            return
+
+        role = (match.group(1) or "unknown").lower()
+        name = (match.group(2) or "").strip()
+        attr_string = match.group(3) or ""
+        
+        if role == "text" and not name:
+            name = node_key.replace("text ", "").strip('" ')
+
+        key = (role, name)
+
+        if key not in result:
+            attrs = {
+                "pw_role": role,
+                "pw_name": name,
+                "pw_depth": depth,  #represents the nesting level of that element within the page's accessibility tree structure. The accessibility depth (pw_depth) is usually shallower than the actual DOM level because it skips all the purely visual wrapper elements
+                #"pw_level": #gestito in maniera custom sotto #pw_level represents the hierarchical structural level of an element—most commonly used for headings, lists, and tree grids.
+                #It directly maps to the standard HTML heading levels (<h1> through <h6>) or explicit aria-level attributes used on elements.
+                #This is a semantic property coming directly from the browser's accessibility layer. pw_depth: This is a structural
+            }
+            
+
+            # ── 1. Clean & extract box details ────────────────────────────
+            if "box=" in attr_string:
+                box_match = re.search(r'box=\[?(-?\d+),(-?\d+),(-?\d+),(-?\d+)\]?', attr_string)
+                if box_match:
+                    attrs["pw_box"] = [int(x) for x in box_match.groups()]
+                attr_string = re.sub(r',?\s*box=\[?[\d,,-]+\]?', '', attr_string).strip()
+
+            # ── 2. FIX: Clean & extract level details safely ──────────────
+            if "level=" in attr_string:
+                level_match = re.search(r'level=(\d+)', attr_string)
+                if level_match:
+                    attrs["pw_level"] = int(level_match.group(1))
+                # Clean out the level substring so the comma loop doesn't get corrupted brackets
+                attr_string = re.sub(r',?\s*level=\d+\]?\s*\[?', '', attr_string).strip()
+
+            # ── 3. Parse remaining standard inline attributes ─────────────
+            if attr_string:
+                # Clean up residual broken brackets before splitting
+                attr_string = attr_string.replace('[', '').replace(']', '').strip()
+                for pair in attr_string.split(','):
+                    pair = pair.strip()
+                    if not pair:
+                        continue
+                    if '=' in pair:
+                        k, v = pair.split('=', 1)
+                        attrs[f"pw_{k.strip()}"] = v.strip().strip('"')
+                    else:
+                        attrs[f"pw_{pair}"] = True
+
+            # ── 4. Extract nested structural sub-nodes ────────────────────
+            if isinstance(node_value, dict):
+                if "box" in node_value:
+                    attrs["pw_box"] = node_value["box"]
+                
+                for k, v in node_value.items():
+                    if k != "box" and not node_regex.match(k.strip()):
+                        attrs[f"pw_{k}"] = v
+
+            result[key] = {k: v for k, v in attrs.items() if v is not None and v != ""}
+
+        # ── 5. Handle child hierarchies ───────────────────────────────────
+        if isinstance(node_value, list):
+            _process_node(node_value, depth + 1)
+        elif isinstance(node_value, dict):
+            for k, v in node_value.items():
+                if k != "box" and node_regex.match(k.strip()):
+                    _parse_single_node(k, v, depth + 1)
+
+    _process_node(parsed_data)
+    return result    
+
+def _unwrap_ax(ax_value: Optional[dict]) -> Any:
+    """
+    Unwrap a CDP AXValue dict  { type, value, relatedNodes?, … }
+    to a plain Python scalar.
+    """
+    if ax_value is None:
+        return None
+    raw = ax_value.get("value")
+    typ = ax_value.get("type", "")
+    if typ == "boolean":
+        return bool(raw)
+    if typ in ("integer", "number"):
+        try:
+            return float(raw)
+        except (TypeError, ValueError):
+            return raw
+    if typ=="nodeList": #typical for labelledby properties
+        # Return a list of backendDOMNodeId for related nodes
+        #print(f"[*] Unwrapping nodeList: {ax_value}")
+        return [n.get("idref") for n in ax_value.get("relatedNodes", []) if n.get("backendDOMNodeId") is not None]        
+    if isinstance(raw, dict):
+        return raw.get("value") or str(raw)
+    return raw
+
+
+def _ax_node_id(node_id: str) -> str:
+    return f"ax:{node_id}"
+
+
+def build_ax_layer(
+    cdp_nodes: list[dict],
+) -> tuple[nx.MultiDiGraph, dict[int, str]]:
+    """
+    Build AX sub-graph.
+    Returns (graph, backendDOMNodeId → graph_node_id mapping).
+    """
+    G: nx.MultiDiGraph = nx.MultiDiGraph()
+    backend_to_gid: dict[int, str] = {}
+    id_to_raw: dict[str, dict] = {}
+
+    # pass 1 – nodes
+    for raw in cdp_nodes:
+        nid = raw.get("nodeId", "")
+        if not nid:
+            continue
+        gid = _ax_node_id(nid)
+
+        # Flatten all ARIA properties (focusable, focused, disabled, level, …)
+        #NB aria-hidden property is missing*, because it is not returned directly from CDP nor playwright. Probably can be inferred with some heuristic
+        # is available from DOM layer
+        #* probably can be retrived with ax_properties = await cdp.send(
+        #    "Accessibility.getAccessibilityPropertiesForNode",
+        #    {"nodeId": node_id}
+        #)
+        # that seems return
+        #{
+        #"properties": {
+        #    "focusable": true,
+        #    "disabled": false,
+        #    "hidden": false
+        #}
+        #}
+
+
+        props: dict[str, Any] = {}
+        # https://chromedevtools.github.io/devtools-protocol/tot/Accessibility/#type-AXPropertyName
+        for prop in raw.get("properties") or []:# manage properties attributes
+            pname = prop.get("name", "")
+            pval  = _unwrap_ax(prop.get("value"))
+            if pname:
+                props[f"aria_{pname}"] = pval
+
+        ignored_reasons = "; ".join(
+            #str(_unwrap_ax(r.get("value")))
+            r.get("name")
+            for r in (raw.get("ignoredReasons") or [])
+        ) or None
+
+        backend_id = raw.get("backendDOMNodeId")
+        # https://chromedevtools.github.io/devtools-protocol/tot/Accessibility/#type-AXNode
+        node_attrs = _attrs(
+            layer           = "ax",
+            node_id         = nid,
+            backend_dom_id  = backend_id,#The backend ID for the associated DOM node
+            ignored         = raw.get("ignored", False),
+            ignored_reasons = ignored_reasons,
+            role            = _unwrap_ax(raw.get("role")),
+            chrome_role     = _unwrap_ax(raw.get("chromeRole")),
+            name            = _unwrap_ax(raw.get("name")),
+            description     = _unwrap_ax(raw.get("description")),
+            value           = _unwrap_ax(raw.get("value")),
+            frame_id=          raw.get("frameId"),
+            type= "ax_"+_unwrap_ax(raw.get("role")),# already use for role
+            **props,
+        )
+        G.add_node(gid, **node_attrs)
+        id_to_raw[nid] = raw
+        if backend_id is not None:
+            backend_to_gid[backend_id] = gid
+
+    # pass 2 – structural edges
+    edge_attributes_child = {
+    "relation": "hasChild",
+    "type": "hasChild_ax",
+    "layer": "ax"
+    }
+
+    edge_attributes_parent = {
+    "relation": "hasParent",
+    "type": "hasParent_ax",
+    "layer": "ax"
+    }
+    for nid, raw in id_to_raw.items():
+        gid       = _ax_node_id(nid)
+        parent_id = raw.get("parentId")
+        if parent_id:
+            pgid = _ax_node_id(parent_id)
+            if pgid in G and not G.has_edge(gid,pgid):  
+                G.add_edge(gid,pgid, **edge_attributes_parent)
+        for child_id in raw.get("childIds") or []:
+            cgid = _ax_node_id(child_id)
+            if cgid in G and not G.has_edge(gid, cgid):
+                G.add_edge(gid, cgid, **edge_attributes_child)
+
+    # pass 3 – ARIA relational edges (labelledby, controls, owns, …)
+    # these links are built from node properties setted before (from "node properties" attributes). In reality they are built from id_to_raw but they follow the same elaboration
+    # these link has superior importance respect to parent-child relationship because they represent a semantic relationship. ths is why they override he previous
+    # because they are both node attributes and edge attributes, mayybe are redundant. TBM
+    ARIA_RELS = { #aria-describedby has the name describedby and so on...
+    
+	#Labeling and Describing. These attributes form a relationship between an element and the text that identifies or explains it.
+    'describedby', #'aria-describedby' has the name 'describedby' in CDP properties
+    'labelledby',
+    'details',
+
+     #Controlling and Owning. These attributes define hierarchy, control, and structural relationships when elements aren't nested inside each other in the actual HTML code.
+	'controls',     
+    'owns',
+    'activedescendant',
+
+    #Navigating and Ordering. These attributes help assistive technologies understand how to navigate between distinct elements or content blocks.
+    'flowto',  
+    'colindex',
+    'rowindex'
+    }
+    
+    for nid, raw in id_to_raw.items():
+        gid = _ax_node_id(nid)
+        for prop in raw.get("properties") or []:
+            pname = prop.get("name", "")
+            if pname not in ARIA_RELS:
+                continue
+            else:
+                print(f"    [*] Processing ARIA relation property: {pname}")
+
+            for rel_node in (prop.get("value") or {}).get("relatedNodes") or []:
+                bid    = rel_node.get("backendDOMNodeId")
+                target = backend_to_gid.get(bid)
+
+                if not target:
+                    print(f"    [!] Warning: No target node found for ARIA relation {pname} with backendDOMNodeId {bid}")
+                if G.has_edge(nid, target):
+                    print(f"    [!] Warning: Edge already exists for {nid} --{pname}--> {target}, updating/add link")    
+                #if target and not G.has_edge(nid, target):
+                if target :# multigraph, add multiiple edge type #ovverride!  this link is more important than the parent-child relationship
+                    print(f"    [*] Adding additional ARIA edge: {nid} --{pname}--> {target}")
+                    edge_attributes = {
+                    "relation": pname,
+                    "type": pname+"_ax",
+                    "layer": "ax"
+                    }
+                    G.add_edge(gid, target, **edge_attributes)
+
+    return G, backend_to_gid
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Layer C – Visual layout graph
+# ─────────────────────────────────────────────────────────────────────────────
+
+def _quad_to_bbox(quad: list[float]) -> tuple[float, float, float, float]:
+    """
+    CDP Quad is [x1,y1, x2,y2, x3,y3, x4,y4] (clockwise from top-left).
+    Returns (x, y, width, height).
+    """
+    xs = quad[0::2]
+    ys = quad[1::2]
+    x, y = min(xs), min(ys)
+    return x, y, max(xs) - x, max(ys) - y
+
+
+def _vis_node_id(backend_id: int) -> str:
+    return f"vis:{backend_id}"
+
+
+def should_keep_ui_node(node_info,ui_target_nodes=None,ui_target_roles=None):
+        # 1. Check tag name
+        node_name = node_info.get("node_name", "").lower()
+        if node_name in ui_target_nodes:
+            return True
+            
+        # 2. Check for interactive ARIA roles in attributes
+        attributes_list = node_info.get("attributes", [])
+        # Parse the flattened CDP array ["key1", "val1", "key2", "val2"]
+        attrs = dict(zip(attributes_list[0::2], attributes_list[1::2]))
+        
+        role = attrs.get("role", "").lower()
+        if role in ui_target_roles:
+            return True
+            
+        return False
+
+async def build_visual_layer(
+    cdp: CDPClient,
+    dom_flat: dict,
+    viewport_w: float,
+    viewport_h: float,
+) -> tuple[nx.MultiDiGraph, dict[int, str]]:
+    """
+    Build visual layout sub-graph by calling DOM.getBoxModel for every
+    DOM element node (nodeType == 1).
+
+    Returns (graph, backendNodeId → graph_node_id mapping).
+    """
+    G: nx.MultiDiGraph = nx.MultiDiGraph()
+    backend_to_gid: dict[int, str] = {}
+    viewport_area = max(viewport_w * viewport_h, 1)
+
+    ui_target_nodes = {
+    "h1", "h2", "h3", "h4", "h5", "h6", "p", "span", "a", "img", "svg", 
+    "video", "audio", "input", "textarea", "button", "select", "option", 
+    "label", "form", #"ul", "ol", "li", 
+    "table", #"tr", "td", "th",
+    "nav", 
+    "header", "footer",
+    "details", "summary", "dialog", "iframe"
+}
+
+    # ARIA roles that transform generic elements (like <div>) into interactive ones
+    ui_target_roles = {
+        "button", "link", "checkbox", "radio", "switch", 
+        "tab", "tabpanel", "combobox", "listbox", "menu", "dialog"
+    }
+
+    
+
+    # Only Element nodes (nodeType=3) have a box model
+    element_nodes = [
+        (nid, info)
+        for nid, info in dom_flat.items()
+        if info.get("node_type") == 3 or should_keep_ui_node(info,ui_target_nodes=ui_target_nodes,ui_target_roles=ui_target_roles) #info.get("node_name") in ("h1","h2","h3","h4","h5","h6","img", "input", "textarea", "button", "select", "a", "label", "svg","video","audio","text")
+       
+
+    ]
+
+    print(f"    → querying box model for {len(element_nodes)} DOM elements …")
+
+    # 1. Enable the CSS domain (Only need to do this once)
+    
+
+    for node_id, info in element_nodes:
+        backend_id = info.get("backend_id")
+        if backend_id is None:
+            continue
+
+        try:
+            #https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-getBoxModel
+            box_result = await cdp.send_raw(
+                "DOM.getBoxModel",
+                {"nodeId": node_id}  
+            )
+            model = box_result.get("model", {})
+        except Exception:
+            # Non-rendered nodes (display:none, detached, …) and JS raise an error. NB: "hidden" is not coverred
+            #print(f"    [!] Warning: Failed to get box model for DOM node {node_id} (backend {backend_id}). Probably not rendered or detached.")
+            continue
+
+        try: #extract visibility (if hidden should be skipped)
+            css_results = await cdp.send_raw(
+                "CSS.getComputedStyleForNode",
+                {"nodeId": node_id} 
+            )
+            
+            computed_properties = css_results.get("computedStyle", [])
+            # Extract the visibility property
+            visibility = next(
+                (p["value"] for p in computed_properties if p["name"] == "visibility"), 
+                "unknown"
+            )
+            if (visibility=="hidden"): # skip unvisible elements
+                #print(f"    Visibility is 'hidden' for DOM node {node_id} (backend {backend_id}).")
+                continue
+
+           
+        except Exception as e:
+            print(f"    [!] Warning: Failed to get computed style for DOM node {node_id} (backend {backend_id}). Error: {e}")
+            continue
+
+        content_quad = model.get("content")
+        if not content_quad:
+            continue
+
+        x, y, w, h = _quad_to_bbox(content_quad)
+        area = w * h
+
+        # Skip zero-size elements (invisible / collapsed)
+        if area == 0:
+            continue
+
+        gid = _vis_node_id(backend_id)
+
+        # Visual prominence = fraction of viewport occupied
+        prominence = round(area / viewport_area, 6)
+
+        # Estimate reading order rank within the viewport
+        # (simple top-to-bottom, left-to-right heuristic)
+        reading_rank = y * 10_000 + x   # will be normalized later
+
+        # Fetch outerHTML for debugging / inspection
+        node_outerHtml=await cdp.send_raw(
+                "DOM.getOuterHTML",
+                {"nodeId": node_id} 
+            )
+        #print(f"[*] Adding visual node {gid} for DOM node {node_id} ({info.get('node_name')}) at ({x:.1f},{y:.1f}) size {w:.1f}x{h:.1f}, prominence={prominence:.6f}, reading_rank={reading_rank}, outerHTML={node_outerHtml.get('outerHTML')[:30]}...")
+        node_attrs = _attrs(
+            layer       = "visual",
+            backend_id  = backend_id,
+            dom_node_id = node_id,
+            tag         = info.get("tag"),
+            bbox_x      = round(x, 2),
+            bbox_y      = round(y, 2),
+            bbox_w      = round(w, 2),
+            bbox_h      = round(h, 2),
+            area        = round(area, 2),
+            prominence  = prominence,
+            reading_rank = reading_rank,   # raw; normalized below
+            # padding / border / margin summaries
+            border_w    = round(model.get("width", 0), 2),
+            border_h    = round(model.get("height", 0), 2),
+            name= info.get("node_name").replace("#",""),#my setup replace because problem to push to neo4j
+            value   = info.get("node_value").replace("#","") or None,
+            outerHtml=node_outerHtml.get("outerHTML")[:100].replace("#","") or None,
+            visibility=visibility,
+            type= "visual_"+info.get("node_name").replace("#","")
+        )
+        G.add_node(gid, **node_attrs)
+        backend_to_gid[backend_id] = gid
+
+    # Normalize reading_rank to 1..N (top-to-bottom order)
+    sorted_nodes = sorted(
+        G.nodes(data=True),
+        key=lambda x: x[1].get("reading_rank", 0),
+    )
+    for rank, (gid, _) in enumerate(sorted_nodes, start=1):
+        G.nodes[gid]["reading_rank"] = rank
+
+    # Spatial edges: "visual_overlap" and "visual_sibling"
+    # For efficiency, only connect nodes whose bounding boxes overlap
+    # or are within a small vertical proximity (same visual "row")
+    # some overlap are caused because of boundix box retrived, not real visual elements occupation. This will be improved using object detection and segmentation in the future
+
+    nodes_list = list(G.nodes(data=True))
+    for i, (gid_a, a) in enumerate(nodes_list):
+        for gid_b, b in nodes_list[i + 1:]:
+            ax, ay, aw, ah = a["bbox_x"], a["bbox_y"], a["bbox_w"], a["bbox_h"]
+            bx, by, bw, bh = b["bbox_x"], b["bbox_y"], b["bbox_w"], b["bbox_h"]
+
+            # 1. FIXED Overlap check: Use an epsilon threshold (e.g., 1 pixel) 
+            # to prevent elements that are just touching or have subpixel rounding from overlapping.
+            EPSILON = 1.0  
+            h_overlap = (ax + EPSILON < bx + bw) and (bx + EPSILON < ax + aw)
+            v_overlap = (ay + EPSILON < by + bh) and (by + EPSILON < ay + ah)
+            
+            if h_overlap and v_overlap:
+                G.add_edge(gid_a, gid_b, relation="visual_overlap", layer="visual", type="visual_overlap")
+                continue  # Only skip if it's a true substantial overlap
+
+            # 2. Same-row heuristic
+            cy_a = ay + ah / 2
+            cy_b = by + bh / 2
+            if abs(cy_a - cy_b) < min(ah, bh) / 2:
+                if abs(ax - bx) < max(aw, bw) * 3:    # horizontally close
+                    left, right = (gid_a, gid_b) if ax < bx else (gid_b, gid_a)
+                    G.add_edge(left, right, relation="visual_sibling", layer="visual", type="visual_sibling")
+
+    return G, backend_to_gid
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Cross-edges (inter-layer)
+# ─────────────────────────────────────────────────────────────────────────────
+
+def add_cross_edges(
+    # the cross-edges are built using backendDOMNodeId / backendNodeId as the join key — it is the only identifier that means the same thing across the DOM, AX, and Visual layers
+    HAG: nx.MultiDiGraph,
+    dom_backend_to_gid: dict[int, str],   # backendNodeId  → dom:N
+    ax_backend_to_gid:  dict[int, str],   # backendDOMNodeId → ax:N
+    vis_backend_to_gid: dict[int, str],   # backendNodeId  → vis:N
+) -> None:
+    """
+    Connect the three layers with typed cross-edges:
+      dom_to_ax     : dom:N → ax:M   (same element, different view)
+      dom_to_visual : dom:N → vis:M  (same element, different view)
+      ax_to_visual  : ax:N  → vis:M  (semantic node ↔ rendered bbox)
+    """
+    cross_counts = {"dom_to_ax": 0, "dom_to_visual": 0, "ax_to_visual": 0}
+
+    # DOM ↔ AX  (both keyed by backendNodeId / backendDOMNodeId)
+    common_ids_dom_ax = set(dom_backend_to_gid) & set(ax_backend_to_gid)
+    for bid in common_ids_dom_ax:
+        dom_gid = dom_backend_to_gid[bid]
+        ax_gid  = ax_backend_to_gid[bid]
+        HAG.add_edge(dom_gid, ax_gid,
+                     relation="dom_to_ax", layer="cross",
+                     backend_id=bid,type="dom_to_ax")
+        cross_counts["dom_to_ax"] += 1
+
+    # DOM ↔ Visual
+    common_ids_dom_vis = set(dom_backend_to_gid) & set(vis_backend_to_gid)
+    for bid in common_ids_dom_vis:
+        dom_gid = dom_backend_to_gid[bid]
+        vis_gid = vis_backend_to_gid[bid]
+        HAG.add_edge(dom_gid, vis_gid,
+                     relation="dom_to_visual", layer="cross",
+                     backend_id=bid,type="dom_to_visual")
+        cross_counts["dom_to_visual"] += 1
+
+    # AX ↔ Visual
+    common_ids_ax_vis = set(ax_backend_to_gid) & set(vis_backend_to_gid)
+    for bid in common_ids_ax_vis:
+        ax_gid  = ax_backend_to_gid[bid]
+        vis_gid = vis_backend_to_gid[bid]
+        HAG.add_edge(ax_gid, vis_gid,
+                     relation="ax_to_visual", layer="cross",
+                     backend_id=bid,type="ax_to_visual")
+        cross_counts["ax_to_visual"] += 1
+
+    print(f"    → cross-edges: {cross_counts}")
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Main pipeline
+# ─────────────────────────────────────────────────────────────────────────────
+
+async def build_heterogeneous_graph(url: str) -> nx.MultiDiGraph:
+    """
+    Full pipeline:
+      1. Launch Chromium (Playwright) with CDP debug port.
+      2. Navigate and wait for idle.
+      3. Extract DOM tree  → Layer A.
+      4. Extract AX tree   → Layer B.
+      5. Extract box models → Layer C.
+      6. Merge into a MultiDiGraph with cross-edges.
+    """
+    debug_port = _free_port()
+    print(f"[*] CDP debug port : {debug_port}")
+
+    async with async_playwright() as pw:
+        browser = await pw.chromium.launch(
+            headless=True,
+            args=[f"--remote-debugging-port={debug_port}"],
+        )
+        viewport_res = {"width": 1920, "height": 1080} #{"width": 1280, "height": 800}
+        context = await browser.new_context(viewport=viewport_res)
+        page    = await context.new_page()
+
+        print(f"[*] Navigating → {url}")
+        await page.goto(url, wait_until="networkidle", timeout=30_000)
+        await page.wait_for_timeout(1000)
+
+        # ── Step B-B1: Playwright accessibility snapshot ─────────────────────
+        print("[*] Playwright: extracting accessibility snapshot …")
+
+        pw_snapshot_str: str = ""
+        try:
+            # Captures the new YAML-based ARIA snapshot including bounding box coordinates
+            # https://playwright.dev/python/docs/aria-snapshots
+            snapshot = await page.aria_snapshot(boxes=True,mode="ai")
+            if snapshot:
+                pw_snapshot_str = snapshot
+                # Since it's a YAML string, we can count lines or characters to log density
+                #print(f"yaml file: {pw_snapshot_str.strip().splitlines()}")
+                line_count = len(pw_snapshot_str.strip().splitlines())
+                print(f"    → Playwright ARIA snapshot collected ({line_count} lines of YAML structure)")
+                pw_flat = _flatten_playwright_snapshot(snapshot)
+            else:
+                print("    [!] Snapshot returned None (page may be empty)")
+        except Exception as e:
+            print(f"    [!] Playwright snapshot failed: {e}")
+        #---------------------    
+
+        viewport = page.viewport_size or viewport_res
+        vw, vh   = viewport["width"], viewport["height"]
+
+        # ── CDP target discovery ──────────────────────────────────────────
+        with urllib.request.urlopen(
+            f"http://localhost:{debug_port}/json", timeout=5
+        ) as resp:
+            targets = json.loads(resp.read())
+
+        page_targets = [
+            t for t in targets
+            if t.get("type") == "page" and "webSocketDebuggerUrl" in t
+        ]
+        if not page_targets:
+            raise RuntimeError("No CDP page target found")
+
+        ws_url = page_targets[0]["webSocketDebuggerUrl"]
+        print(f"[*] CDP WebSocket  : {ws_url}")
+
+        async with CDPClient(ws_url) as cdp:
+
+            # ── Layer A: DOM ──────────────────────────────────────────────
+            print("\n[A] Extracting DOM tree …")
+            await cdp.send_raw("DOM.enable")
+            await cdp.send_raw("CSS.enable")
+            #https://chromedevtools.github.io/devtools-protocol/tot/DOM/#method-getDocument
+            dom_result = await cdp.send_raw(
+                "DOM.getDocument",
+                {"depth": -1, "pierce": True}   # full tree, pierce shadow DOM
+            )
+            dom_root = dom_result.get("root", {})
+            dom_flat = _flatten_dom_tree(dom_root)
+            print(f"    → {len(dom_flat)} DOM nodes")
+
+            G_dom, dom_backend_map = await build_dom_layer(dom_flat,cdp)
+            print(f"    → DOM graph: {G_dom.number_of_nodes()} nodes, "
+                  f"{G_dom.number_of_edges()} edges")
+
+            # ── Layer B: AX tree ──────────────────────────────────────────
+            
+            # ── Step B2: CDP via cdp_use ───────────────────────────────────────
+            print("\n[B2] Extracting Accessibility tree …")
+            await cdp.send_raw("Accessibility.enable")
+            ax_result  = await cdp.send_raw("Accessibility.getFullAXTree", {})
+            cdp_nodes  = ax_result.get("nodes", [])
+            await cdp.send_raw("Accessibility.disable")
+
+            if cdp_nodes:
+                print("[*] Building AX graph from CDP nodes …")
+                print(f"    → {len(cdp_nodes)} AX nodes (raw)")
+
+                G_ax, ax_backend_map = build_ax_layer(cdp_nodes)
+                print(f"    → AX graph: {G_ax.number_of_nodes()} nodes, "
+                    f"{G_ax.number_of_edges()} edges")
+
+                if pw_flat:
+                    print("[*] Merging Playwright AX attributes …")
+                    merge_playwright_data(G_ax, pw_flat)
+
+            elif pw_flat:
+                print("[!] CDP unavailable — building AX graph from Playwright snapshot only")
+                G_ax = _build_graph_from_pw(pw_flat)
+            else:
+                raise RuntimeError("No accessibility data could be extracted.")
+
+            # ── Layer C: Visual layout ────────────────────────────────────
+            print("\n[C] Extracting visual layout (box models) …")
+            G_vis, vis_backend_map = await build_visual_layer(# it is just extracted from the dom layer (only element_type=1)
+                cdp, dom_flat, vw, vh
+            )
+            print(f"    → Visual graph: {G_vis.number_of_nodes()} nodes, "
+                  f"{G_vis.number_of_edges()} edges")
+            
+            await cdp.send_raw("DOM.disable")
+            await cdp.send_raw("CSS.disable")
+
+        await browser.close()
+
+    # ── Merge into heterogeneous graph ────────────────────────────────────
+    print("\n[HAG] Merging layers …")
+    HAG = nx.MultiDiGraph()
+    HAG.add_nodes_from(G_dom.nodes(data=True))
+    HAG.add_edges_from(G_dom.edges(data=True))
+    HAG.add_nodes_from(G_ax.nodes(data=True))
+    HAG.add_edges_from(G_ax.edges(data=True))
+    HAG.add_nodes_from(G_vis.nodes(data=True))
+    HAG.add_edges_from(G_vis.edges(data=True))
+
+    print("[HAG] Adding cross-edges …")
+    add_cross_edges(HAG, dom_backend_map, ax_backend_map, vis_backend_map)
+
+    return HAG
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Summary
+# ─────────────────────────────────────────────────────────────────────────────
+
+def print_summary(HAG: nx.MultiDiGraph) -> None:
+    print(f"\n{'='*65}")
+    print("  Heterogeneous Accessibility Graph (HAG) — Summary")
+    print(f"{'='*65}")
+    print(f"  Total nodes : {HAG.number_of_nodes()}")
+    print(f"  Total edges : {HAG.number_of_edges()}")
+
+    # Per-layer node counts
+    layer_counts: dict[str, int] = {}
+    for _, attrs in HAG.nodes(data=True):
+        lay = attrs.get("layer", "unknown")
+        layer_counts[lay] = layer_counts.get(lay, 0) + 1
+    print("\n  Nodes per layer:")
+    for lay, cnt in sorted(layer_counts.items()):
+        print(f"    {lay:<12} {cnt}")
+
+    # Per-relation edge counts
+    rel_counts: dict[str, int] = {}
+    for _, _, attrs in HAG.edges(data=True):
+        rel = attrs.get("relation", "unknown")
+        rel_counts[rel] = rel_counts.get(rel, 0) + 1
+    print("\n  Edges per relation:")
+    for rel, cnt in sorted(rel_counts.items(), key=lambda x: -x[1]):
+        print(f"    {rel:<25} {cnt}")
+
+    # AX role distribution (non-ignored)
+    roles: dict[str, int] = {}
+    for _, attrs in HAG.nodes(data=True):
+        if attrs.get("layer") != "ax" or attrs.get("ignored"):
+            continue
+        r = str(attrs.get("role") or "none")
+        roles[r] = roles.get(r, 0) + 1
+    if roles:
+        print("\n  AX roles (non-ignored, top 15):")
+        for role, cnt in sorted(roles.items(), key=lambda x: -x[1])[:15]:
+            print(f"    {role:<28} {cnt}")
+
+    # Visual layer stats
+    prominences = [
+        attrs["prominence"]
+        for _, attrs in HAG.nodes(data=True)
+        if attrs.get("layer") == "visual"
+    ]
+    if prominences:
+        print(f"\n  Visual nodes         : {len(prominences)}")
+        print(f"  Max prominence       : {max(prominences):.4f}")
+        print(f"  Avg prominence       : {sum(prominences)/len(prominences):.4f}")
+
+    components = nx.number_connected_components(HAG.to_undirected())
+    dag = nx.is_directed_acyclic_graph(HAG)
+    print(f"\n  Connected components: {components}")
+    print(f"  is DAG                 : {'yes' if dag else 'no (cycles detected)'}")
+    print(f"{'='*60}\n")    
+
+    
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Export
+# ─────────────────────────────────────────────────────────────────────────────
+
+def save_graph(HAG: nx.MultiDiGraph, path: str) -> None:
+    if path.endswith(".json"):
+        data = nx.node_link_data(HAG)
+        with open(path, "w", encoding="utf-8") as f:
+            json.dump(data, f, indent=2, default=str)
+        print(f"[*] Saved → {path}  (node-link JSON)")
+    else:
+        # GraphML: coerce all attrs to str
+        G_exp = HAG.copy()
+        for _, attrs in G_exp.nodes(data=True):
+            for k in list(attrs):
+                attrs[k] = str(attrs[k])
+        for _, _, attrs in G_exp.edges(data=True):
+            for k in list(attrs):
+                attrs[k] = str(attrs[k])
+        nx.write_graphml(G_exp, path)
+        print(f"[*] Saved → {path}  (GraphML)")
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# Drawing
+# ─────────────────────────────────────────────────────────────────────────────
+
+def draw_graph(HAG: nx.MultiDiGraph, out: str = "hag.png",
+               max_nodes: int = 120) -> None:
+    try:
+        import matplotlib.pyplot as plt
+        import matplotlib.patches as mpatches
+    except ImportError:
+        print("[!] matplotlib not installed — skip draw")
+        return
+
+    # Colour scheme per layer
+    LAYER_COLOR = {
+        "dom":    "#90CAF9",   # blue
+        "ax":     "#A5D6A7",   # green
+        "visual": "#FFCC80",   # orange
+    }
+    LAYER_SHAPE = {"dom": "s", "ax": "o", "visual": "D"}
+    EDGE_COLOR  = {
+        "child":          "#B0BEC5",
+        "dom_to_ax":      "#7986CB",
+        "dom_to_visual":  "#FF8A65",
+        "ax_to_visual":   "#4DB6AC",
+        "visual_sibling": "#FFD54F",
+        "visual_overlap": "#EF9A9A",
+    }
+
+    if HAG.number_of_nodes() > max_nodes:
+        # Keep the most connected nodes
+        top = sorted(HAG.nodes(), key=lambda n: HAG.degree(n), reverse=True)
+        HAG = HAG.subgraph(top[:max_nodes]).copy()
+        print(f"[*] Drawing subgraph: top {max_nodes} nodes by degree")
+
+    try:
+        pos = nx.nx_agraph.graphviz_layout(HAG, prog="dot")
+    except Exception:
+        pos = nx.spring_layout(HAG, seed=42, k=1.8)
+
+    fig, ax = plt.subplots(figsize=(24, 16))
+
+    # Draw edges per relation type
+    all_edges = list(HAG.edges(data=True))
+    for rel, color in EDGE_COLOR.items():
+        subset = [(u, v) for u, v, d in all_edges if d.get("relation") == rel]
+        if subset:
+            nx.draw_networkx_edges(
+                HAG, pos, edgelist=subset,
+                edge_color=color, width=0.8 if rel == "child" else 1.4,
+                alpha=0.6, arrows=True, ax=ax,
+                arrowsize=10,
+            )
+
+    # Draw nodes per layer
+    for layer, color in LAYER_COLOR.items():
+        subset = [n for n, d in HAG.nodes(data=True) if d.get("layer") == layer]
+        if subset:
+            nx.draw_networkx_nodes(
+                HAG, pos, nodelist=subset,
+                node_color=color, node_size=350, alpha=0.9, ax=ax,
+            )
+
+    # Labels (role/tag + name snippet)
+    labels = {}
+    for nid, attrs in HAG.nodes(data=True):
+        layer = attrs.get("layer", "")
+        if layer == "ax":
+            role = str(attrs.get("role") or "?")
+            name = str(attrs.get("name") or "")[:18]
+            labels[nid] = f"{role}\n{name}" if name else role
+        elif layer == "dom":
+            labels[nid] = str(attrs.get("tag") or "?")
+        elif layer == "visual":
+            labels[nid] = f"[{attrs.get('tag','?')}]\n{attrs.get('reading_rank','')}"
+    nx.draw_networkx_labels(HAG, pos, labels=labels, font_size=5, ax=ax)
+
+    # Legend
+    patches = [mpatches.Patch(color=c, label=l)
+               for l, c in LAYER_COLOR.items()]
+    edge_patches = [mpatches.Patch(color=c, label=l)
+                    for l, c in EDGE_COLOR.items() if l != "child"]
+    ax.legend(handles=patches + edge_patches, loc="upper left",
+              fontsize=8, framealpha=0.8)
+    ax.set_title("Heterogeneous Accessibility Graph (HAG)", fontsize=14)
+    ax.axis("off")
+    plt.tight_layout()
+    plt.savefig(out, dpi=150, bbox_inches="tight")
+    print(f"[*] Graph image saved → {out}")
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# CLI
+# ─────────────────────────────────────────────────────────────────────────────
+
+def _parse_args() -> argparse.Namespace:
+    p = argparse.ArgumentParser(
+        description="Build a Heterogeneous Accessibility Graph (DOM + AX + Visual)"
+    )
+    p.add_argument("url", help="URL to analyse (http/https or file://)")
+    p.add_argument("--output", "-o", default="hag.graphml",
+                   help="Output path: .graphml or .json  [default: hag.graphml]")
+    p.add_argument("--draw", action="store_true",
+                   help="Render and save hag.png")
+    p.add_argument("--no-ignored", action="store_true",
+                   help="Remove ignored AX nodes (and their cross-edges)")
+    return p.parse_args()
+
+
+async def main() -> None:
+    args = _parse_args()
+    HAG  = await build_heterogeneous_graph(args.url)
+
+    if args.no_ignored:
+        to_remove = [
+            n for n, a in HAG.nodes(data=True)
+            if a.get("layer") == "ax" and a.get("ignored")#remove only ignored AX nodes, keep the others
+        ]
+        HAG.remove_nodes_from(to_remove)
+        print(f"[*] Removed {len(to_remove)} ignored AX nodes")
+
+    print_summary(HAG)
+    save_graph(HAG, args.output)
+
+    if args.draw:
+        draw_graph(HAG)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())