Paddleocr Ui Test

# Python
__pycache__/
*.py[cod]
*$py.class
*.so
*.egg
*.egg-info/
dist/
build/
*.whl

# Virtual environments
.venv/
venv/
env/

# IDE
.vscode/
.idea/
*.swp
*.swo

# Test artifacts
test-results/
test/benchmark_images/
test/benchmark_results.json
test/mock_data/

# OS
.DS_Store
Thumbs.db

# Environment
.env
.env.local

flowchart TB
  subgraph INPUT["Input Layer"]
    direction TB
    CLI["CLI Entry<br/>scripts/ui_test.py"]
    MODES["Input modes<br/>url | artifacts | mcp"]
    CFG["Config sources<br/>rules/*.json<br/>profiles/*.json<br/>runtime --config"]
    CLI --> MODES
    CLI --> CFG
  end

  subgraph CONTRACTS["Unified Contracts"]
    direction LR
    EB["EvidenceBundle<br/>screenshot_path | a11y_tree | dom_html<br/>capabilities | provenance"]
    DC["DetectionContext"]
  end

  subgraph PIPE["Runtime Pipeline"]
    direction LR
    ST1["collect_evidence"]
    ST2["run_ocr_stage"]
    ST3["build_detection_context"]
    ST4["execute_levels"]
    ST5["apply_baseline_stage<br/>enrich_findings"]
    ST6["write_output_stage"]
    ST1 --> ST2 --> ST3 --> ST4 --> ST5 --> ST6
  end

  subgraph DETECT["Detector Registry"]
    direction TB
    L1["L1 TextConsistencyDetector"]
    L2["L2 LayoutReasonablenessDetector"]
    L3["L3 DomConsistencyDetector<br/>requires: has_a11y"]
    L4["L4 AccessibilityDetector<br/>requires: has_a11y"]
    L5["L5 InternationalizationDetector"]
    L6["L6 DynamicContentDetector<br/>requires: has_actions"]
    CAP["Capability model<br/>has_dom | has_a11y | has_actions | has_source_map"]
    SKIP["Missing capabilities are recorded as skipped<br/>with explicit reasons in detector_execution"]
    CAP --> SKIP
  end

  subgraph SUPPORT["Supporting Modules"]
    direction TB
    OCR["providers/ocr.py<br/>default: paddleocr-vl"]
    BASE["core/baseline.py<br/>baseline_diff.py"]
    SMAP["source_map_lookup.py"]
    QUAL["smoke_input_modes.py<br/>tests/test_architecture.py<br/>strict config validation"]
  end

  subgraph OUT["Outputs And Metadata"]
    direction TB
    RJSON["report.json<br/>source of truth"]
    RDER["report.md<br/>report.junit.xml<br/>report.sarif.json"]
    RFILES["annotated.png<br/>baseline.json<br/>screenshot.png"]
    META["metadata.detector_execution<br/>metadata.source_map_execution<br/>snapshots.ocr_texts<br/>snapshots.a11y_elements"]
  end

  MODES --> ST1
  CFG --> ST1
  ST1 --> EB
  EB --> ST2
  ST2 --> OCR
  ST3 --> DC
  DC --> ST4
  QUAL -.-> PIPE
  ST4 --> L1
  ST4 --> L2
  ST4 --> L3
  ST4 --> L4
  ST4 --> L5
  ST4 --> L6
  L1 --> ST5
  L2 --> ST5
  L3 --> ST5
  L4 --> ST5
  L5 --> ST5
  L6 --> ST5
  BASE --> ST5
  SMAP --> ST5
  ST6 --> RJSON
  ST6 --> RDER
  ST6 --> RFILES
  ST6 --> META

{
  "name": "Login Page UI Test",
  "url": "https://the-internet.herokuapp.com/login",
  "levels": ["L1", "L2", "L3", "L4"],
  "viewport": "1280x720",
  "wait_ms": 2000,
  "expected_texts": {
    "page_title": "Login Page",
    "description": "This is where you can log into the secure area",
    "username_label": "Username",
    "password_label": "Password",
    "submit_button": "Login"
  },
  "expected_language": "en",
  "ignore_texts": [
    "Powered by Elemental Selenium"
  ]
}

Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/

TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION

1. Definitions.

"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.

"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.

"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.

"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.

"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.

"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.

"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work.

"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship.

"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to the Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner.

"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.

2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.

3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted.

4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:

(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and

(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and

(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and

(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear.

5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.

6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.

7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE.

8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law or such agreed to in writing,
shall any Contributor be liable to You for damages, including any
direct, indirect, special, incidental, or consequential damages
of any character arising as a result of this License or out of the
use or inability to use the Work.

9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License.

END OF TERMS AND CONDITIONS

{
  "name": "content",
  "description": "Content / Blog / News pages",
  "when_to_use": "Use when the user mentions blogs, news pages, article pages, documentation pages, or content display pages",
  "default_levels": ["L1", "L2", "L3"],
  "viewport": "1440x900",
  "wait_ms": 2000,
  "rule_overrides": {
    "layout-anomaly.full_page_text.width_threshold": 0.9,
    "layout-anomaly.full_page_text.height_threshold": 0.5
  }
}

{
  "name": "dashboard",
  "description": "Data dashboard / Analytics pages",
  "when_to_use": "Use when the user mentions data dashboards, analytics panels, chart pages, or real-time monitoring pages",
  "default_levels": ["L2", "L3", "L6"],
  "viewport": "1920x1080",
  "wait_ms": 5000,
  "rule_overrides": {
    "dom-ocr-crossval.count_mismatch.delta_threshold": 0.1,
    "layout-anomaly.element_overlap.enabled": true,
    "dynamic-content.content_persistence.enabled": true
  }
}

{
  "name": "ecommerce",
  "description": "E-commerce website",
  "when_to_use": "Use when the user mentions e-commerce websites, product listings, shopping carts, checkout pages, product detail pages",
  "default_levels": ["L1", "L2", "L3", "L4", "L5"],
  "viewport": "1440x900",
  "wait_ms": 4000,
  "rule_overrides": {
    "text-consistency.default_strategy": "fuzzy",
    "layout-anomaly.touch_target_size.enabled": true,
    "accessibility.missing_alt.enabled": true
  },
  "expected_elements": [
    {"role": "button", "name_pattern": ".*(Buy|Add to Cart|Checkout|购买|结算)."}
  ]
}

{
  "name": "form",
  "description": "Form / Login / Registration pages",
  "when_to_use": "Use when the user mentions login pages, registration pages, form pages, or any page with input fields and submit buttons",
  "default_levels": ["L1", "L3", "L4"],
  "viewport": "1280x720",
  "wait_ms": 2000,
  "rule_overrides": {
    "accessibility.missing_label.enabled": true,
    "accessibility.missing_label.roles": ["textbox", "button", "checkbox"]
  }
}

{
  "name": "mobile",
  "description": "Mobile H5 / Responsive pages",
  "when_to_use": "Use when the user mentions mobile pages, H5 pages, responsive design, or mobile browser pages",
  "default_levels": ["L1", "L2", "L3", "L4"],
  "viewport": "375x812",
  "wait_ms": 3000,
  "rule_overrides": {
    "layout-anomaly.touch_target_size.enabled": true,
    "layout-anomaly.touch_target_size.min_width_px": 44,
    "layout-anomaly.touch_target_size.min_height_px": 44,
    "layout-anomaly.overflow.enabled": true
  }
}

{
  "name": "saas",
  "description": "SaaS backend management system",
  "when_to_use": "Use when the user mentions backend management systems, data table pages, admin panels, CRM/ERP systems",
  "default_levels": ["L1", "L2", "L3", "L5"],
  "viewport": "1920x1080",
  "wait_ms": 3000,
  "rule_overrides": {
    "dom-ocr-crossval.fuzzy_match.enabled": true,
    "dom-ocr-crossval.count_mismatch.delta_threshold": 0.15
  },
  "expected_elements": [
    {"role": "navigation", "min_count": 1},
    {"role": "table", "min_count": 0}
  ],
  "ignore_patterns": ["^v\\d+\\.\\d+", "^[a-f0-9]{7}$"]
}

{
  "version": "1.0",
  "description": "L4: Accessibility analysis rules",
  "agent_hints": {
    "when_to_change": "Enable missing_label for form pages; ensure missing_alt is enabled for image-heavy pages; enable canvas_rendered_text to detect canvas-drawn text",
    "safe_defaults": "missing_alt enabled by default, others disabled",
    "tunable_params": ["missing_alt.enabled", "missing_alt.roles", "missing_label.enabled", "missing_label.roles", "canvas_rendered_text.enabled", "emoji_as_icon.enabled"]
  },
  "missing_alt": {
    "enabled": true,
    "roles": ["image", "graphic", "img"],
    "ignore_values": ["", "image", "icon"],
    "severity": "error"
  },
  "missing_label": {
    "enabled": false,
    "roles": ["button", "textbox", "checkbox", "radio", "combobox"],
    "severity": "error"
  },
  "canvas_rendered_text": {
    "enabled": false,
    "description": "Text visible in OCR but not in accessibility tree",
    "severity": "warning"
  },
  "emoji_as_icon": {
    "enabled": false,
    "emoji_pattern": "[\\U0001F600-\\U0001F64F\\U0001F300-\\U0001F5FF\\U0001F680-\\U0001F6FF\\U0001F1E0-\\U0001F1FF\\u2600-\\u26FF\\u2700-\\u27BF]",
    "severity": "warning"
  }
}

{
  "version": "1.0",
  "description": "L3: DOM vs OCR cross-validation rules",
  "agent_hints": {
    "when_to_change": "Lower fuzzy_match.threshold for pages with minor text rendering differences; lower count_mismatch.delta_threshold for data table pages",
    "safe_defaults": "fuzzy_match enabled with threshold 0.6; count_mismatch delta 0.3",
    "tunable_params": ["fuzzy_match.enabled", "fuzzy_match.threshold", "fuzzy_match.warning_threshold", "count_mismatch.delta_threshold", "count_mismatch.min_elements", "ignore_patterns"]
  },
  "fuzzy_match": {
    "enabled": true,
    "algorithm": "lcs",
    "threshold": 0.6,
    "warning_threshold": 0.7
  },
  "count_mismatch": {
    "enabled": true,
    "delta_threshold": 0.3,
    "min_elements": 5,
    "severity": "warning"
  },
  "dom_not_rendered": {
    "max_results": 10,
    "severity": "error"
  },
  "rendered_not_in_dom": {
    "max_results": 10,
    "severity": "warning"
  },
  "ignore_patterns": [
    "^[\\s\\u200b\\u200c\\u200d]+$"
  ]
}

{
  "version": "1.0",
  "description": "L6: Dynamic content state transition rules",
  "agent_hints": {
    "when_to_change": "Add custom loading patterns to state_transitions; enable content_persistence to track critical text elements",
    "safe_defaults": "loading->content and content->error built-in; max_tracked_changes 5",
    "tunable_params": ["state_transitions", "content_persistence.enabled", "content_persistence.critical_texts", "max_tracked_changes"]
  },
  "state_transitions": {
    "loading_to_content": {
      "should_disappear": ["Loading...", "loading", "spinner", "请稍候"],
      "should_appear": [],
      "timeout_ms": 5000
    },
    "content_to_error": {
      "should_disappear": [],
      "should_appear": ["Error", "error", "失败", "异常"],
      "timeout_ms": 10000
    }
  },
  "content_persistence": {
    "enabled": false,
    "critical_texts": []
  },
  "max_tracked_changes": 5
}

{
  "version": "1.0",
  "description": "L5: Internationalization rules",
  "agent_hints": {
    "when_to_change": "Add new languages in languages with script_pattern; add false positive terms to common_false_positives",
    "safe_defaults": "zh/en built-in, ja/ko optional; common_false_positives includes common abbreviations and technical terms",
    "tunable_params": ["languages", "common_false_positives", "mixed_language.enabled"]
  },
  "languages": {
    "zh": {
      "script_pattern": "[\\u4e00-\\u9fff]",
      "min_word_length": 1,
      "description": "Chinese"
    },
    "en": {
      "script_pattern": "[a-zA-Z]{4,}",
      "min_word_length": 4,
      "description": "English"
    },
    "ja": {
      "script_pattern": "[\\u3040-\\u309f\\u30a0-\\u30ff\\u4e00-\\u9fff]",
      "min_word_length": 1,
      "description": "Japanese"
    },
    "ko": {
      "script_pattern": "[\\uac00-\\ud7af\\u1100-\\u11ff]",
      "min_word_length": 1,
      "description": "Korean"
    }
  },
  "mixed_language": {
    "enabled": false,
    "severity": "info"
  },
  "common_false_positives": [
    "OK", "Login", "Sign Up", "API", "URL", "ID", "CSS", "HTML", "JS"
  ]
}

{
  "version": "1.0",
  "description": "L2: Layout anomaly detection rules",
  "agent_hints": {
    "when_to_change": "Enable touch_target_size and overflow for mobile pages; enable element_overlap for data dashboards",
    "safe_defaults": "overflow and full_page_text enabled by default, others disabled",
    "tunable_params": ["overflow.enabled", "element_overlap.enabled", "element_overlap.iou_threshold", "touch_target_size.enabled", "touch_target_size.min_width_px", "full_page_text.width_threshold", "full_page_text.height_threshold"]
  },
  "overflow": {
    "enabled": true,
    "severity": "warning"
  },
  "full_page_text": {
    "enabled": true,
    "width_threshold": 0.95,
    "height_threshold": 0.8,
    "severity": "warning"
  },
  "element_overlap": {
    "enabled": false,
    "iou_threshold": 0.3,
    "severity": "warning"
  },
  "text_truncation": {
    "enabled": false,
    "min_expected_chars": 20,
    "severity": "warning"
  },
  "touch_target_size": {
    "enabled": false,
    "min_width_px": 44,
    "min_height_px": 44,
    "severity": "warning"
  }
}

{
  "version": "1.0",
  "description": "L1: Text consistency rules",
  "agent_hints": {
    "when_to_change": "Set default_strategy to 'exact' when strict matching is required, or 'fuzzy' to tolerate minor typos",
    "safe_defaults": "substring works for most scenarios",
    "tunable_params": ["default_strategy", "match_strategies.fuzzy.threshold", "ignore_patterns", "max_results_per_check"]
  },
  "match_strategies": {
    "exact": {
      "type": "exact",
      "description": "Exact string match"
    },
    "substring": {
      "type": "substring",
      "description": "Substring match (default)"
    },
    "fuzzy": {
      "type": "fuzzy",
      "threshold": 0.8,
      "description": "LCS-based fuzzy matching"
    }
  },
  "default_strategy": "substring",
  "severity_overrides": {
    "text_missing": "error",
    "text_mismatch": "error",
    "extra_text": "info"
  },
  "max_results_per_check": 10,
  "ignore_patterns": []
}

"""Input adapters for PaddleOCR UI test."""

from .registry import build_adapter, detect_input_mode, list_adapters

__all__ = ["build_adapter", "detect_input_mode", "list_adapters"]

from __future__ import annotations

import json
from pathlib import Path
from typing import Any, Dict

from .base import EvidenceBundle, InputAdapter


class ArtifactDirAdapter(InputAdapter):
    name = "artifacts"
    description = "Load screenshot and optional DOM/A11y artifacts from a directory."
    produced_capabilities = ("has_dom", "has_a11y")

    async def load_bundle(self) -> EvidenceBundle:
        artifacts_dir = Path(self.args.artifacts_dir).resolve()
        if not artifacts_dir.exists() or not artifacts_dir.is_dir():
            raise ValueError(f"Invalid artifacts directory: {artifacts_dir}")

        screenshot_path = self._find_screenshot(artifacts_dir)
        a11y_tree = self._load_json_optional(
            artifacts_dir / "a11y_tree.json", default={}
        )
        dom_html = self._load_text_optional(artifacts_dir / "dom.html")
        meta = self._load_json_optional(artifacts_dir / "metadata.json", default={})

        return EvidenceBundle(
            screenshot_path=str(screenshot_path),
            a11y_tree=a11y_tree,
            dom_html=dom_html,
            url=meta.get("url", self.args.url or ""),
            viewport=meta.get("viewport", self.args.viewport or ""),
            source=self.args.source or meta.get("source", "artifacts"),
            extras={"artifacts_dir": str(artifacts_dir)},
            capabilities={
                "has_dom": bool(dom_html),
                "has_a11y": bool(a11y_tree),
                "has_actions": False,
            },
            provenance={
                "artifacts_dir": str(artifacts_dir),
                "metadata_file": str(artifacts_dir / "metadata.json"),
            },
        )

    def _find_screenshot(self, artifacts_dir: Path) -> Path:
        candidates = [
            artifacts_dir / "screenshot.png",
            artifacts_dir / "screenshot.jpg",
            artifacts_dir / "screenshot.jpeg",
            artifacts_dir / "screen.png",
        ]
        for candidate in candidates:
            if candidate.exists():
                return candidate
        raise ValueError(
            f"No screenshot file found in {artifacts_dir}. "
            "Expected one of: screenshot.png/jpg/jpeg or screen.png"
        )

    @staticmethod
    def _load_json_optional(path: Path, default: Dict[str, Any]) -> Dict[str, Any]:
        if not path.exists():
            return default
        return json.loads(path.read_text(encoding="utf-8"))

    @staticmethod
    def _load_text_optional(path: Path) -> str:
        if not path.exists():
            return ""
        return path.read_text(encoding="utf-8")

from __future__ import annotations

from pathlib import Path
from typing import Any, Dict, Optional

from core.models import EvidenceBundle


class InputAdapter:
    name = "base"
    description = ""
    produced_capabilities: tuple[str, ...] = ()

    def __init__(self, args: Any):
        self.args = args

    async def load_bundle(self) -> EvidenceBundle:
        raise NotImplementedError

    @classmethod
    def descriptor(cls) -> Dict[str, Any]:
        return {
            "name": cls.name,
            "description": cls.description,
            "produced_capabilities": list(cls.produced_capabilities),
        }

    @staticmethod
    def _resolve_path(path_value: str, base_dir: Optional[Path] = None) -> Path:
        path = Path(path_value)
        if path.is_absolute():
            return path
        if base_dir:
            return (base_dir / path).resolve()
        return path.resolve()

from __future__ import annotations

import json
from pathlib import Path

from .base import EvidenceBundle, InputAdapter


class MCPPayloadAdapter(InputAdapter):
    name = "mcp"
    description = "Load evidence from a path-based MCP payload."
    produced_capabilities = ("has_dom", "has_a11y")

    async def load_bundle(self) -> EvidenceBundle:
        input_json_path = Path(self.args.input_json).resolve()
        if not input_json_path.exists():
            raise ValueError(f"Input JSON not found: {input_json_path}")

        payload = json.loads(input_json_path.read_text(encoding="utf-8"))
        base_dir = input_json_path.parent

        screenshot_file = payload.get("screenshot_path")
        if not screenshot_file:
            raise ValueError("MCP payload missing required field: screenshot_path")
        screenshot_path = self._resolve_path(screenshot_file, base_dir=base_dir)
        if not screenshot_path.exists():
            raise ValueError(f"MCP screenshot file not found: {screenshot_path}")

        a11y_tree = {}
        if "a11y_tree" in payload and isinstance(payload["a11y_tree"], dict):
            a11y_tree = payload["a11y_tree"]
        elif payload.get("a11y_tree_path"):
            a11y_tree_path = self._resolve_path(
                payload["a11y_tree_path"], base_dir=base_dir
            )
            if a11y_tree_path.exists():
                a11y_tree = json.loads(a11y_tree_path.read_text(encoding="utf-8"))

        dom_html = ""
        if payload.get("dom_html"):
            dom_html = payload["dom_html"]
        elif payload.get("dom_path"):
            dom_path = self._resolve_path(payload["dom_path"], base_dir=base_dir)
            if dom_path.exists():
                dom_html = dom_path.read_text(encoding="utf-8")

        return EvidenceBundle(
            screenshot_path=str(screenshot_path),
            a11y_tree=a11y_tree,
            dom_html=dom_html,
            url=payload.get("url", self.args.url or ""),
            viewport=payload.get("viewport", self.args.viewport or ""),
            source=self.args.source or payload.get("source", "mcp"),
            extras={"input_json": str(input_json_path)},
            capabilities={
                "has_dom": bool(dom_html),
                "has_a11y": bool(a11y_tree),
                "has_actions": False,
            },
            provenance={
                "input_json": str(input_json_path),
            },
        )

from __future__ import annotations

from .artifact_dir import ArtifactDirAdapter
from .mcp_payload import MCPPayloadAdapter


BUILTIN_INPUTS = {
    "url": {
        "name": "url",
        "description": "Capture a page live with Playwright and build an evidence bundle.",
        "produced_capabilities": ["has_dom", "has_a11y", "has_actions"],
    },
    "artifacts": ArtifactDirAdapter.descriptor(),
    "mcp": MCPPayloadAdapter.descriptor(),
}


def detect_input_mode(args) -> str:
    if args.input_mode and args.input_mode != "auto":
        return args.input_mode
    if args.input_json:
        return "mcp"
    if args.artifacts_dir:
        return "artifacts"
    return "url"


def list_adapters(detailed: bool = False):
    if detailed:
        return [BUILTIN_INPUTS[name] for name in ("url", "artifacts", "mcp")]
    return ["url", "artifacts", "mcp"]


def build_adapter(args):
    mode = detect_input_mode(args)
    if mode == "mcp":
        if not args.input_json:
            raise ValueError("--input-mode mcp requires --input-json")
        return MCPPayloadAdapter(args), mode
    if mode == "artifacts":
        if not args.artifacts_dir:
            raise ValueError("--input-mode artifacts requires --artifacts-dir")
        return ArtifactDirAdapter(args), mode
    return None, "url"

from __future__ import annotations

from pathlib import Path
from typing import Optional, Tuple

from playwright.async_api import async_playwright

from .base import EvidenceBundle


A11Y_TREE_SCRIPT = """() => {
    function buildA11yTree(node, depth = 0) {
        if (depth > 20) return null;
        const role = node.getAttribute('role') ||
            (node.tagName === 'BUTTON' ? 'button' : '') ||
            (node.tagName === 'INPUT' ? 'textbox' : '') ||
            (node.tagName === 'IMG' ? 'img' : '') ||
            (node.tagName === 'A' ? 'link' : '') ||
            (node.tagName === 'H1' ? 'heading' : '') ||
            (node.tagName === 'H2' ? 'heading' : '') ||
            (node.tagName === 'H3' ? 'heading' : '') ||
            (node.tagName === 'H4' ? 'heading' : '') ||
            (node.tagName === 'H5' ? 'heading' : '') ||
            (node.tagName === 'H6' ? 'heading' : '') ||
            (node.tagName === 'NAV' ? 'navigation' : '') ||
            (node.tagName === 'MAIN' ? 'main' : '') ||
            (node.tagName === 'HEADER' ? 'banner' : '') ||
            (node.tagName === 'FOOTER' ? 'contentinfo' : '') ||
            node.tagName?.toLowerCase() || '';
        const name = node.getAttribute('aria-label') ||
            node.getAttribute('alt') ||
            node.textContent?.trim().substring(0, 200) || '';
        const rect = node.getBoundingClientRect();
        const result = {
            role: role || 'generic',
            name: name,
            bounds: {
                x: Math.round(rect.x),
                y: Math.round(rect.y),
                width: Math.round(rect.width),
                height: Math.round(rect.height)
            },
            tagName: node.tagName,
            visible: rect.width > 0 && rect.height > 0
        };
        const children = [];
        for (const child of node.children) {
            const childTree = buildA11yTree(child, depth + 1);
            if (childTree) children.push(childTree);
        }
        if (children.length) result.children = children;
        return result;
    }
    return buildA11yTree(document.body);
}"""


async def capture_from_url(
    *,
    url: str,
    viewport: str,
    wait_ms: int,
    screenshot_path: Path,
    source: str = "standalone",
    actions: Optional[str] = None,
    after_screenshot_path: Optional[Path] = None,
) -> Tuple[EvidenceBundle, Optional[str]]:
    viewport_tuple = tuple(map(int, viewport.split("x")))
    after_path = None

    async with async_playwright() as p:
        browser = await p.chromium.launch(headless=True)
        page = await browser.new_page(
            viewport={"width": viewport_tuple[0], "height": viewport_tuple[1]}
        )

        print(f"Navigating to {url} ...")
        await page.goto(url, wait_until="networkidle")
        await page.wait_for_timeout(wait_ms)

        print("Capturing screenshot ...")
        await page.screenshot(path=str(screenshot_path), full_page=True)

        print("Extracting accessibility tree ...")
        a11y_tree = await page.evaluate(A11Y_TREE_SCRIPT)
        dom_html = await page.content()

        if actions:
            await execute_actions(page, actions)
            if after_screenshot_path:
                await page.screenshot(path=str(after_screenshot_path), full_page=True)
                after_path = str(after_screenshot_path)

        await browser.close()

    return (
        EvidenceBundle(
            screenshot_path=str(screenshot_path),
            a11y_tree=a11y_tree or {},
            dom_html=dom_html,
            url=url,
            viewport=viewport,
            source=source,
            capabilities={
                "has_dom": bool(dom_html),
                "has_a11y": bool(a11y_tree),
                "has_actions": bool(actions),
            },
            provenance={
                "browser": "playwright-chromium",
                "capture_mode": "standalone_url",
            },
        ),
        after_path,
    )


async def execute_actions(page, actions_str: str) -> None:
    actions = actions_str.split(";")
    for action in actions:
        action = action.strip()
        if not action:
            continue
        if action.startswith("click("):
            selector = action[6:-1]
            print(f"  Clicking: {selector}")
            await page.click(selector)
        elif action.startswith("wait("):
            ms = int(action[5:-1])
            print(f"  Waiting: {ms}ms")
            await page.wait_for_timeout(ms)
        elif action.startswith("type("):
            inner = action[5:-1]
            comma_idx = inner.find(",")
            if comma_idx != -1:
                selector = inner[:comma_idx].strip()
                text = inner[comma_idx + 1 :].strip().strip('"').strip("'")
                print(f"  Typing '{text}' into: {selector}")
                await page.fill(selector, text)
        elif action == "screenshot":
            pass
        else:
            print(f"  Unknown action: {action}")

#!/usr/bin/env python3
"""
Annotate screenshot with issue markers from UI test results.

Draws colored bounding boxes and labels on the screenshot for each detected issue.
"""

import argparse
import json
from pathlib import Path
from typing import Any, Dict, List, Optional, Tuple

from PIL import Image, ImageDraw, ImageFont


COLOR_MAP = {
    "error": (255, 0, 0, 200),
    "warning": (255, 165, 0, 200),
    "info": (0, 128, 255, 200),
}

LABEL_COLORS = {
    "error": (255, 255, 255),
    "warning": (255, 255, 255),
    "info": (255, 255, 255),
}


def get_font(size: int = 16) -> ImageFont.FreeTypeFont:
    """Get a font for drawing labels, with fallback."""
    font_paths = [
        "/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf",
        "/usr/share/fonts/truetype/liberation/LiberationSans-Bold.ttf",
        "/System/Library/Fonts/Helvetica.ttc",
        "C:\\Windows\\Fonts\\arial.ttf",
    ]
    for fp in font_paths:
        try:
            return ImageFont.truetype(fp, size)
        except (IOError, OSError):
            continue
    return ImageFont.load_default()


def annotate_screenshot(
    screenshot_path: str,
    results: List[Dict[str, Any]],
    output_path: str,
    label_size: int = 16,
    border_width: int = 3,
) -> str:
    """Draw issue markers on screenshot.

    Args:
        screenshot_path: Path to original screenshot
        results: List of test result dicts with screenshot_region
        output_path: Path to save annotated image
        label_size: Font size for labels
        border_width: Width of bounding box borders

    Returns:
        Path to the annotated image
    """
    img = Image.open(screenshot_path).convert("RGBA")
    overlay = Image.new("RGBA", img.size, (0, 0, 0, 0))
    draw = ImageDraw.Draw(overlay)
    font = get_font(label_size)

    for r in results:
        region = r.get("screenshot_region")
        if not region or len(region) < 4:
            continue

        severity = r.get("severity", "info")
        color = COLOR_MAP.get(severity, (128, 128, 128, 180))
        label_color = LABEL_COLORS.get(severity, (255, 255, 255))

        box = [tuple(p) for p in region[:4]]
        draw.polygon(box, outline=color, width=border_width)

        label = f"[{r.get('level', '?')}] {r.get('type', '?')}"
        top_left = box[0]

        bbox = draw.textbbox(top_left, label, font=font)
        label_w = bbox[2] - bbox[0]
        label_h = bbox[3] - bbox[1]

        label_bg = (
            top_left[0],
            top_left[1] - label_h - 4,
            top_left[0] + label_w + 8,
            top_left[1],
        )

        if label_bg[1] < 0:
            label_bg = (
                top_left[0],
                top_left[1] + 4,
                top_left[0] + label_w + 8,
                top_left[1] + label_h + 8,
            )

        draw.rectangle(label_bg, fill=color)
        draw.text(
            (top_left[0] + 4, label_bg[1] + 2),
            label,
            fill=label_color,
            font=font,
        )

    annotated = Image.alpha_composite(img, overlay)
    annotated = annotated.convert("RGB")
    annotated.save(output_path)
    return output_path


def main():
    parser = argparse.ArgumentParser(description="Annotate screenshot with issue markers")
    parser.add_argument("--screenshot", required=True, help="Path to screenshot")
    parser.add_argument("--results", required=True, help="Path to report.json")
    parser.add_argument("--output", default=None, help="Output path (default: annotated.png)")
    parser.add_argument("--label-size", type=int, default=16, help="Label font size")
    args = parser.parse_args()

    if args.output is None:
        args.output = str(Path(args.screenshot).parent / "annotated.png")

    report = json.loads(Path(args.results).read_text())
    results = report.get("results", [])

    output = annotate_screenshot(args.screenshot, results, args.output, args.label_size)
    print(f"Annotated screenshot saved: {output}")


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Baseline diff engine for UI regression testing."""

from __future__ import annotations

import argparse
import json
from datetime import datetime, timezone
from pathlib import Path
from typing import Any, Dict, List, Tuple

from core.baseline import BaselineDiff


def _load_json(path: str) -> Dict[str, Any]:
    return json.loads(Path(path).read_text(encoding="utf-8"))


def _extract_current_snapshots(current_report: Dict[str, Any]) -> Tuple[Dict[str, Any], List[Dict[str, Any]]]:
    snapshots = current_report.get("snapshots", {})
    ocr_texts = snapshots.get("ocr_texts")
    a11y_elements = snapshots.get("a11y_elements")

    if ocr_texts is None:
        ocr_texts = []
        for result in current_report.get("results", []):
            if result.get("screenshot_region"):
                ocr_texts.append(
                    {
                        "text": result.get("element", ""),
                        "box": result["screenshot_region"],
                    }
                )

    if a11y_elements is None:
        a11y_elements = []

    return {"texts": ocr_texts}, a11y_elements


def _normalize_baseline_data(baseline_payload: Dict[str, Any]) -> Dict[str, Any]:
    if "ocr_texts" in baseline_payload or "a11y_elements" in baseline_payload:
        return baseline_payload

    extracted_ocr, extracted_a11y = _extract_current_snapshots(baseline_payload)
    normalized = dict(baseline_payload)
    normalized["ocr_texts"] = extracted_ocr.get("texts", [])
    normalized["a11y_elements"] = extracted_a11y
    normalized.setdefault("image_size", baseline_payload.get("image_size", [1280, 720]))
    return normalized


def main() -> None:
    parser = argparse.ArgumentParser(description="Baseline diff for UI regression testing")
    parser.add_argument("--baseline", required=True, help="Path to baseline JSON file")
    parser.add_argument("--current-report", required=True, help="Path to current report.json")
    parser.add_argument(
        "--threshold",
        type=float,
        default=0.1,
        help="Layout shift threshold (ratio of max dimension)",
    )
    parser.add_argument("--output", default=None, help="Output diff report path")
    args = parser.parse_args()

    baseline_data = _normalize_baseline_data(_load_json(args.baseline))
    current_report = _load_json(args.current_report)
    current_ocr, current_a11y = _extract_current_snapshots(current_report)

    diff = BaselineDiff(
        current_ocr=current_ocr,
        current_a11y=current_a11y,
        baseline_data=baseline_data,
        threshold=args.threshold,
    )
    results = diff.run()

    output_data = {
        "schema_version": "1.1",
        "diff_timestamp": datetime.now(timezone.utc).isoformat(),
        "baseline_file": args.baseline,
        "current_report": args.current_report,
        "threshold": args.threshold,
        "summary": {
            "total_issues": len(results),
            "errors": sum(1 for result in results if result.get("severity") == "error"),
            "warnings": sum(1 for result in results if result.get("severity") == "warning"),
        },
        "issues": results,
    }

    output_path = Path(args.output) if args.output else Path(args.baseline).parent / "diff.json"
    output_path.write_text(json.dumps(output_data, indent=2, ensure_ascii=False), encoding="utf-8")
    print(f"Diff report saved: {output_path}")
    print(
        f"  {output_data['summary']['total_issues']} issues: "
        f"{output_data['summary']['errors']} errors, "
        f"{output_data['summary']['warnings']} warnings"
    )


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Compare OCR results against DOM/Accessibility Tree."""

from __future__ import annotations

import argparse
import json
import sys
from pathlib import Path
from typing import Any, Dict, List

from core.a11y import flatten_a11y_tree
from core.config import load_rules
from core.text_utils import build_cross_validation_findings


def load_json(path: str) -> Any:
    return json.loads(Path(path).read_text(encoding="utf-8"))


def compare(
    ocr_texts: List[Dict[str, Any]],
    a11y_elements: List[Dict[str, Any]],
    rules: Dict[str, Any],
) -> Dict[str, Any]:
    return build_cross_validation_findings(ocr_texts, a11y_elements, rules)


def main() -> None:
    parser = argparse.ArgumentParser(description="OCR vs DOM cross-validation")
    parser.add_argument("--ocr", required=True, help="OCR result JSON file")
    parser.add_argument("--a11y", required=True, help="A11y tree JSON file")
    parser.add_argument(
        "--output", default="cross_validation_report.json", help="Output file"
    )
    parser.add_argument("--rules", help="Rules directory for config overrides")
    parser.add_argument(
        "--ci",
        action="store_true",
        help="CI mode: exit code 1 if issues found at or above --fail-on severity",
    )
    parser.add_argument(
        "--fail-on",
        choices=["error", "warning"],
        default="error",
        help="Minimum severity to fail in CI mode (default: error)",
    )
    args = parser.parse_args()

    rules = load_rules(args.rules)
    ocr_data = load_json(args.ocr)
    a11y_data = load_json(args.a11y)

    ocr_texts = ocr_data.get("texts", []) if isinstance(ocr_data, dict) else ocr_data
    if isinstance(a11y_data, dict):
        a11y_elements = flatten_a11y_tree(a11y_data, leaf_only=True)
    else:
        a11y_elements = a11y_data

    report = compare(ocr_texts, a11y_elements, rules=rules)
    Path(args.output).write_text(
        json.dumps(report, indent=2, ensure_ascii=False), encoding="utf-8"
    )

    print(f"Cross-validation report: {args.output}")
    print(f"  A11y texts: {report['summary']['a11y_text_count']}")
    print(f"  OCR texts:  {report['summary']['ocr_text_count']}")
    print(f"  Matching:   {report['summary']['matching']}")
    print(f"  Issues:     {report['summary']['issues']}")

    if args.ci:
        severities = [issue.get("severity", "info") for issue in report.get("issues", [])]
        if args.fail_on == "error" and "error" in severities:
            sys.exit(1)
        if args.fail_on == "warning" and any(
            severity in {"error", "warning"} for severity in severities
        ):
            sys.exit(1)


if __name__ == "__main__":
    main()

"""Core contracts and helpers for PaddleOCR UI test."""

from .a11y import flatten_a11y_tree
from .baseline import BaselineDiff, create_baseline
from .config import (
    SUPPORTED_LEVELS,
    DEFAULT_PROFILES_DIR,
    DEFAULT_RULES_DIR,
    list_available_profiles,
    load_profile,
    load_rules,
    load_runtime_config,
    resolve_run_settings,
)
from .models import DetectionContext, EvidenceBundle, Issue, coerce_issues
from .reporting import ReportWriter, summarize_issues
from .text_utils import build_cross_validation_findings, find_best_match, text_similarity

__all__ = [
    "BaselineDiff",
    "DetectionContext",
    "EvidenceBundle",
    "Issue",
    "ReportWriter",
    "SUPPORTED_LEVELS",
    "DEFAULT_PROFILES_DIR",
    "DEFAULT_RULES_DIR",
    "build_cross_validation_findings",
    "coerce_issues",
    "create_baseline",
    "find_best_match",
    "flatten_a11y_tree",
    "list_available_profiles",
    "load_profile",
    "load_rules",
    "load_runtime_config",
    "resolve_run_settings",
    "summarize_issues",
    "text_similarity",
]

from __future__ import annotations

from typing import Any, Dict, List


def flatten_a11y_tree(
    tree: Dict[str, Any],
    *,
    leaf_only: bool = True,
    include_empty: bool = False,
) -> List[Dict[str, Any]]:
    """Flatten an accessibility tree to a list of nodes.

    By default only leaf nodes are returned to avoid duplicate text inherited
    from ancestor textContent values.
    """

    elements: List[Dict[str, Any]] = []

    def walk(node: Dict[str, Any], path: str = "") -> None:
        role = node.get("role", "")
        name = node.get("name", "")
        value = node.get("value", "")
        bounds = node.get("bounds", {})
        text = (name or value or "").strip()
        children = node.get("children", []) or []

        is_leaf = len(children) == 0
        if (include_empty or text) and (not leaf_only or is_leaf):
            elements.append(
                {
                    "role": role,
                    "text": text,
                    "bounds": bounds,
                    "path": path,
                    "tagName": node.get("tagName", ""),
                }
            )

        for index, child in enumerate(children):
            child_path = f"{path}/{role}[{index}]" if path else f"{role}[{index}]"
            walk(child, child_path)

    if tree:
        walk(tree)
    return elements

from __future__ import annotations

from datetime import datetime, timezone
from typing import Any, Dict, List, Optional, Tuple

from .models import Issue, coerce_issues


class BaselineDiff:
    """Compare current test results against a saved baseline."""

    def __init__(
        self,
        current_ocr: Dict[str, Any],
        current_a11y: List[Dict[str, Any]],
        baseline_data: Dict[str, Any],
        threshold: float = 0.1,
        image_size: Optional[Tuple[int, int]] = None,
    ):
        self.current_ocr_texts = {
            t["text"] for t in current_ocr.get("texts", []) if t.get("text")
        }
        self.current_a11y_texts = {e["text"] for e in current_a11y if e.get("text")}
        self.baseline_ocr_texts = {
            t["text"]
            for t in baseline_data.get("ocr_texts", [])
            if isinstance(t, dict) and t.get("text")
        }
        self.baseline_a11y_texts = {
            e["text"]
            for e in baseline_data.get("a11y_elements", [])
            if isinstance(e, dict) and e.get("text")
        }
        self.baseline_ocr_map = {
            t["text"]: t
            for t in baseline_data.get("ocr_texts", [])
            if isinstance(t, dict) and t.get("text")
        }
        self.current_ocr_map = {
            t["text"]: t for t in current_ocr.get("texts", []) if t.get("text")
        }
        self.threshold = threshold
        self.image_size = image_size or tuple(
            baseline_data.get("image_size", [1280, 720])
        )
        self.results: List[Issue] = []

    def run(self) -> List[Dict[str, Any]]:
        self._check_removed_texts()
        self._check_added_texts()
        self._check_layout_shifts()
        self._check_element_count_changes()
        self._check_a11y_regressions()
        return coerce_issues(self.results)

    def _check_removed_texts(self) -> None:
        removed = self.baseline_ocr_texts - self.current_ocr_texts
        for text in list(removed)[:10]:
            self.results.append(
                Issue(
                    type="baseline_regression",
                    level="L1",
                    severity="error",
                    element=text[:60],
                    expected=f"Text exists in baseline: '{text}'",
                    actual="Not found in current run",
                    suggestion=(
                        "Regression: text that was previously visible is now missing"
                    ),
                    meta={"subtype": "text_removed"},
                )
            )

    def _check_added_texts(self) -> None:
        added = self.current_ocr_texts - self.baseline_ocr_texts
        for text in list(added)[:10]:
            self.results.append(
                Issue(
                    type="baseline_regression",
                    level="L1",
                    severity="warning",
                    element=text[:60],
                    expected="No unexpected text",
                    actual=f"New text: '{text}'",
                    suggestion="Unexpected content appeared - verify if intentional",
                    meta={"subtype": "text_added"},
                )
            )

    def _check_layout_shifts(self) -> None:
        for text in self.current_ocr_texts & self.baseline_ocr_texts:
            old_item = self.baseline_ocr_map.get(text)
            new_item = self.current_ocr_map.get(text)
            if not old_item or not new_item:
                continue
            old_box = old_item.get("box", [])
            new_box = new_item.get("box", [])
            if len(old_box) != 4 or len(new_box) != 4:
                continue

            shift = self._calculate_shift(old_box, new_box)
            max_dim = max(self.image_size)
            if shift > self.threshold * max_dim:
                self.results.append(
                    Issue(
                        type="baseline_regression",
                        level="L2",
                        severity="warning",
                        element=text[:60],
                        expected=f"Position: {old_box}",
                        actual=f"Position: {new_box} (shift: {shift:.0f}px)",
                        screenshot_region=new_box,
                        suggestion="Layout shift detected - element moved significantly",
                        meta={"subtype": "layout_shift"},
                    )
                )

    def _check_element_count_changes(self) -> None:
        old_count = len(self.baseline_ocr_texts)
        new_count = len(self.current_ocr_texts)
        if old_count > 0:
            delta = abs(new_count - old_count) / old_count
            if delta > self.threshold:
                self.results.append(
                    Issue(
                        type="baseline_regression",
                        level="L3",
                        severity="warning",
                        element="page",
                        expected=f"~{old_count} text elements",
                        actual=f"{new_count} text elements (change: {delta:.0%})",
                        suggestion="Significant change in text element count",
                        meta={"subtype": "count_change"},
                    )
                )

    def _check_a11y_regressions(self) -> None:
        removed_a11y = self.baseline_a11y_texts - self.current_a11y_texts
        for text in list(removed_a11y)[:5]:
            self.results.append(
                Issue(
                    type="baseline_regression",
                    level="L4",
                    severity="error",
                    element=text[:60],
                    expected=f"A11y element exists in baseline: '{text}'",
                    actual="Not found in current accessibility tree",
                    suggestion=(
                        "Accessibility regression: element lost its accessible name"
                    ),
                    meta={"subtype": "a11y_element_removed"},
                )
            )

    @staticmethod
    def _calculate_shift(box1: List[List[int]], box2: List[List[int]]) -> float:
        cx1 = sum(point[0] for point in box1) / 4
        cy1 = sum(point[1] for point in box1) / 4
        cx2 = sum(point[0] for point in box2) / 4
        cy2 = sum(point[1] for point in box2) / 4
        return ((cx2 - cx1) ** 2 + (cy2 - cy1) ** 2) ** 0.5


def create_baseline(
    ocr_result: Dict[str, Any],
    a11y_elements: List[Dict[str, Any]],
    url: str,
    viewport: str,
    image_size: Tuple[int, int],
    summary: Dict[str, Any],
) -> Dict[str, Any]:
    return {
        "baseline_version": "1.1",
        "created_at": datetime.now(timezone.utc).isoformat(),
        "url": url,
        "viewport": viewport,
        "image_size": list(image_size),
        "ocr_texts": ocr_result.get("texts", []),
        "a11y_elements": a11y_elements,
        "summary": summary,
    }

from __future__ import annotations

import copy
import json
import re
from dataclasses import dataclass
from pathlib import Path
from typing import Any, Dict, List, Optional, Sequence


REPO_ROOT = Path(__file__).resolve().parents[2]
DEFAULT_RULES_DIR = REPO_ROOT / "rules"
DEFAULT_PROFILES_DIR = REPO_ROOT / "profiles"
SUPPORTED_LEVELS = ("L1", "L2", "L3", "L4", "L5", "L6")

RULE_FILE_MAP = {
    "text-consistency": "text-consistency.json",
    "layout-anomaly": "layout-anomaly.json",
    "dom-ocr-crossval": "dom-ocr-crossval.json",
    "accessibility": "accessibility.json",
    "i18n": "i18n.json",
    "dynamic-content": "dynamic-content.json",
}

DEFAULT_RULES: Dict[str, Dict[str, Any]] = {
    "text-consistency": {
        "version": "1.0",
        "match_strategies": {
            "exact": {"type": "exact"},
            "substring": {"type": "substring"},
            "fuzzy": {"type": "fuzzy", "threshold": 0.8},
        },
        "default_strategy": "substring",
        "severity_overrides": {
            "text_missing": "error",
            "text_mismatch": "error",
            "extra_text": "info",
        },
        "max_results_per_check": 10,
        "ignore_patterns": [],
    },
    "layout-anomaly": {
        "version": "1.0",
        "overflow": {"enabled": True, "severity": "warning"},
        "full_page_text": {
            "enabled": True,
            "width_threshold": 0.95,
            "height_threshold": 0.8,
            "severity": "warning",
        },
        "element_overlap": {
            "enabled": False,
            "iou_threshold": 0.3,
            "severity": "warning",
        },
        "text_truncation": {
            "enabled": False,
            "min_expected_chars": 20,
            "severity": "warning",
        },
        "touch_target_size": {
            "enabled": False,
            "min_width_px": 44,
            "min_height_px": 44,
            "severity": "warning",
        },
    },
    "dom-ocr-crossval": {
        "version": "1.0",
        "fuzzy_match": {
            "enabled": True,
            "threshold": 0.6,
            "warning_threshold": 0.7,
        },
        "count_mismatch": {
            "enabled": True,
            "delta_threshold": 0.3,
            "min_elements": 5,
            "severity": "warning",
        },
        "dom_not_rendered": {"max_results": 10, "severity": "error"},
        "rendered_not_in_dom": {"max_results": 10, "severity": "warning"},
        "ignore_patterns": [r"^[\s\u200b\u200c\u200d]+$"],
    },
    "accessibility": {
        "version": "1.0",
        "missing_alt": {
            "enabled": True,
            "roles": ["image", "graphic", "img"],
            "ignore_values": ["", "image", "icon"],
            "severity": "error",
        },
        "missing_label": {
            "enabled": False,
            "roles": ["button", "textbox", "checkbox", "radio", "combobox"],
            "severity": "error",
        },
        "canvas_rendered_text": {"enabled": False, "severity": "warning"},
        "emoji_as_icon": {
            "enabled": False,
            "emoji_pattern": r"[\U0001F600-\U0001F64F\U0001F300-\U0001F5FF\U0001F680-\U0001F6FF\U0001F1E0-\U0001F1FF\u2600-\u26FF\u2700-\u27BF]",
            "severity": "warning",
        },
    },
    "i18n": {
        "version": "1.0",
        "languages": {
            "zh": {"script_pattern": r"[\u4e00-\u9fff]", "min_word_length": 1},
            "en": {"script_pattern": r"[a-zA-Z]{4,}", "min_word_length": 4},
            "ja": {
                "script_pattern": r"[\u3040-\u309f\u30a0-\u30ff\u4e00-\u9fff]",
                "min_word_length": 1,
            },
            "ko": {
                "script_pattern": r"[\uac00-\ud7af\u1100-\u11ff]",
                "min_word_length": 1,
            },
        },
        "mixed_language": {"enabled": False, "severity": "info"},
        "common_false_positives": [
            "OK",
            "Login",
            "Sign Up",
            "API",
            "URL",
            "ID",
            "CSS",
            "HTML",
            "JS",
        ],
    },
    "dynamic-content": {
        "version": "1.0",
        "state_transitions": {
            "loading_to_content": {
                "should_disappear": ["Loading...", "loading", "spinner", "请稍候"],
                "should_appear": [],
                "timeout_ms": 5000,
            },
            "content_to_error": {
                "should_disappear": [],
                "should_appear": ["Error", "error", "失败", "异常"],
                "timeout_ms": 10000,
            },
        },
        "content_persistence": {"enabled": False, "critical_texts": []},
        "max_tracked_changes": 5,
    },
}

ALLOWED_RULE_KEYS = {
    "text-consistency": {
        "version",
        "description",
        "agent_hints",
        "match_strategies",
        "default_strategy",
        "severity_overrides",
        "max_results_per_check",
        "ignore_patterns",
    },
    "layout-anomaly": {
        "version",
        "description",
        "agent_hints",
        "overflow",
        "full_page_text",
        "element_overlap",
        "text_truncation",
        "touch_target_size",
    },
    "dom-ocr-crossval": {
        "version",
        "description",
        "agent_hints",
        "fuzzy_match",
        "count_mismatch",
        "dom_not_rendered",
        "rendered_not_in_dom",
        "ignore_patterns",
    },
    "accessibility": {
        "version",
        "description",
        "agent_hints",
        "missing_alt",
        "missing_label",
        "canvas_rendered_text",
        "emoji_as_icon",
    },
    "i18n": {
        "version",
        "description",
        "agent_hints",
        "languages",
        "mixed_language",
        "common_false_positives",
    },
    "dynamic-content": {
        "version",
        "description",
        "agent_hints",
        "state_transitions",
        "content_persistence",
        "max_tracked_changes",
    },
}

PROFILE_ALLOWED_KEYS = {
    "name",
    "description",
    "when_to_use",
    "default_levels",
    "viewport",
    "wait_ms",
    "rule_overrides",
    "expected_elements",
    "ignore_patterns",
}
EXPECTED_ELEMENT_ALLOWED_KEYS = {"role", "name_pattern", "min_count", "max_count"}
RUNTIME_CONFIG_ALLOWED_KEYS = {
    "expected_texts",
    "expected_language",
    "ignore_texts",
    "levels",
    "wait_ms",
    "expected_elements",
    "ignore_patterns",
}


@dataclass
class ResolvedRunSettings:
    config: Dict[str, Any]
    rules: Dict[str, Any]
    levels: List[str]
    viewport: str
    wait_ms: int


def _deep_merge(base: Dict[str, Any], override: Dict[str, Any]) -> Dict[str, Any]:
    merged = copy.deepcopy(base)
    for key, value in override.items():
        if key in merged and isinstance(merged[key], dict) and isinstance(value, dict):
            merged[key] = _deep_merge(merged[key], value)
        else:
            merged[key] = copy.deepcopy(value)
    return merged


def _dedupe_strings(values: Sequence[str]) -> List[str]:
    seen = set()
    results = []
    for value in values:
        if value not in seen:
            seen.add(value)
            results.append(value)
    return results


def _has_nested_path(data: Dict[str, Any], parts: Sequence[str]) -> bool:
    target: Any = data
    for part in parts:
        if not isinstance(target, dict) or part not in target:
            return False
        target = target[part]
    return True


def _set_nested_path(data: Dict[str, Any], parts: Sequence[str], value: Any) -> None:
    target = data
    for part in parts[:-1]:
        target = target[part]
    target[parts[-1]] = value


def _validate_viewport(viewport: str) -> None:
    if not re.fullmatch(r"\d+x\d+", viewport or ""):
        raise ValueError(f"Invalid viewport format: {viewport}")


def _validate_levels(levels: Sequence[str]) -> None:
    invalid = [level for level in levels if level not in SUPPORTED_LEVELS]
    if invalid:
        raise ValueError(
            f"Unsupported test levels: {', '.join(invalid)}. Expected subset of {', '.join(SUPPORTED_LEVELS)}"
        )


def _validate_expected_elements(expected_elements: Sequence[Dict[str, Any]]) -> None:
    for idx, spec in enumerate(expected_elements):
        unknown = set(spec) - EXPECTED_ELEMENT_ALLOWED_KEYS
        if unknown:
            raise ValueError(
                f"Unknown expected_elements keys at index {idx}: {', '.join(sorted(unknown))}"
            )
        if not spec.get("role"):
            raise ValueError(f"expected_elements[{idx}] must define 'role'")


def list_available_profiles(profiles_dir: Optional[str] = None) -> List[str]:
    target = Path(profiles_dir) if profiles_dir else DEFAULT_PROFILES_DIR
    if not target.exists():
        return []
    return sorted(path.stem for path in target.glob("*.json"))


def load_rules(rules_dir: Optional[str] = None) -> Dict[str, Dict[str, Any]]:
    rules_path = Path(rules_dir) if rules_dir else DEFAULT_RULES_DIR
    rules: Dict[str, Dict[str, Any]] = {}
    for section, filename in RULE_FILE_MAP.items():
        loaded: Dict[str, Any] = {}
        filepath = rules_path / filename
        if filepath.exists():
            loaded = json.loads(filepath.read_text(encoding="utf-8"))
            unknown = set(loaded) - ALLOWED_RULE_KEYS[section]
            if unknown:
                raise ValueError(
                    f"Unknown keys in rule file {filename}: {', '.join(sorted(unknown))}"
                )
        rules[section] = _deep_merge(DEFAULT_RULES[section], loaded)
    return rules


def apply_rule_overrides(rules: Dict[str, Any], overrides: Dict[str, Any]) -> Dict[str, Any]:
    updated = copy.deepcopy(rules)
    for dotted_key, value in (overrides or {}).items():
        parts = dotted_key.split(".")
        if not _has_nested_path(updated, parts):
            raise ValueError(f"Unknown rule override path: {dotted_key}")
        _set_nested_path(updated, parts, value)
    return updated


def load_profile(
    profile_name: str,
    *,
    profiles_dir: Optional[str] = None,
    rules: Optional[Dict[str, Any]] = None,
) -> Dict[str, Any]:
    profiles_path = Path(profiles_dir) if profiles_dir else DEFAULT_PROFILES_DIR
    profile_path = profiles_path / f"{profile_name}.json"
    if not profile_path.exists():
        available = list_available_profiles(str(profiles_path))
        raise ValueError(
            f"Unknown profile: {profile_name}. Available: {', '.join(available) if available else 'none'}"
        )

    profile = json.loads(profile_path.read_text(encoding="utf-8"))
    unknown = set(profile) - PROFILE_ALLOWED_KEYS
    if unknown:
        raise ValueError(
            f"Unknown keys in profile {profile_name}: {', '.join(sorted(unknown))}"
        )

    if profile.get("default_levels"):
        _validate_levels(profile["default_levels"])
    if profile.get("viewport"):
        _validate_viewport(profile["viewport"])
    if profile.get("expected_elements"):
        _validate_expected_elements(profile["expected_elements"])

    candidate_rules = rules or load_rules()
    if profile.get("rule_overrides"):
        apply_rule_overrides(candidate_rules, profile["rule_overrides"])

    return profile


def load_runtime_config(config_path: Optional[str]) -> Dict[str, Any]:
    if not config_path:
        return {}
    config = json.loads(Path(config_path).read_text(encoding="utf-8"))
    unknown = set(config) - RUNTIME_CONFIG_ALLOWED_KEYS
    if unknown:
        raise ValueError(
            f"Unknown keys in runtime config: {', '.join(sorted(unknown))}"
        )
    if "levels" in config:
        _validate_levels(config["levels"])
    if "expected_elements" in config:
        _validate_expected_elements(config["expected_elements"])
    return config


def resolve_run_settings(
    *,
    args: Any,
    raw_config: Optional[Dict[str, Any]],
    rules: Dict[str, Any],
    profile: Optional[Dict[str, Any]] = None,
) -> ResolvedRunSettings:
    config = copy.deepcopy(raw_config or {})
    resolved_rules = copy.deepcopy(rules)
    profile = copy.deepcopy(profile or {})

    if profile.get("rule_overrides"):
        resolved_rules = apply_rule_overrides(resolved_rules, profile["rule_overrides"])

    merged_expected_elements = list(profile.get("expected_elements", [])) + list(
        config.get("expected_elements", [])
    )
    if merged_expected_elements:
        _validate_expected_elements(merged_expected_elements)
        config["expected_elements"] = merged_expected_elements

    merged_ignore_patterns = _dedupe_strings(
        list(profile.get("ignore_patterns", [])) + list(config.get("ignore_patterns", []))
    )
    if merged_ignore_patterns:
        config["ignore_patterns"] = merged_ignore_patterns
        for section in ("text-consistency", "dom-ocr-crossval"):
            resolved_rules[section]["ignore_patterns"] = _dedupe_strings(
                list(resolved_rules[section].get("ignore_patterns", []))
                + merged_ignore_patterns
            )

    levels = config.get("levels") or profile.get("default_levels") or ["L1", "L3"]
    if getattr(args, "levels", None):
        levels = [level.strip() for level in args.levels.split(",") if level.strip()]
    _validate_levels(levels)

    viewport = getattr(args, "viewport", None) or profile.get("viewport", "1280x720")
    _validate_viewport(viewport)

    wait_ms = int(config.get("wait_ms", profile.get("wait_ms", getattr(args, "wait", 2000))))

    return ResolvedRunSettings(
        config=config,
        rules=resolved_rules,
        levels=levels,
        viewport=viewport,
        wait_ms=wait_ms,
    )