"""Public leaderboards → append-only `benchmark_results` (tier 2). One connector class per leaderboard domain (the SDK binds one
`source_key` per connector, and each board has its own rate limit and provenance) — module kept as `leaderboards`.

  * aider_leaderboard     raw polyglot_leaderboard.yml from the aider repository → `aider-polyglot` (pass_rate_2) and the separate
                          `aider-polyglot-well-formed` benchmark (percent_cases_well_formed); run group = run date.
  * swebench_leaderboard  https://www.swebench.com/ embeds `<script id="leaderboard-data">` (5 boards: Verified, Lite, Test, Multimodal,
                          Multilingual) → results keyed by (model, benchmark, config {system, system_org, model_tag, reasoning_effort…});
                          trust `official-benchmark` when SWE-bench checked the submission, `community` otherwise.
  * livebench_leaderboard https://livebench.ai/ is a React app; its bundle lists the release dates and fetches `./table_<date>.csv` +
                          `./categories_<date>.json` (plus a model metadata map with display names / HF links). The connector follows
                          index → bundle → categories → table and emits the overall mean on `livebench` and each category average on its
                          own benchmark entity (`livebench-<category>`, family livebench) — never mixed metrics on one board.
  * artificial_analysis   https://artificialanalysis.ai/leaderboards/models — Next.js RSC flight payload (`self.__next_f.push`) with the full
                          model list: Intelligence Index (config {version}) + component evaluations mapped to registry benchmarks.

Model identity on leaderboards (`connectors/_identity.py`): names are free text or evaluator slugs → `EntityRef("model", …,
identity_confidence="medium")` with resolver-friendly aliases and the developer organisation when the id/name is first-party.
**Evaluation-effort variants are configurations, not models**: `claude-opus-5-xhigh`, "GPT-5.5 (xhigh)", `…-thinking-64k-high-effort`
all point at the base model with `config.reasoning_effort` / `config.reasoning` / `config.thinking_budget` set.
"""
from __future__ import annotations

import csv
import io
import json
import re
from datetime import UTC, date, datetime
from statistics import fmean
from typing import Any

import yaml

from aiatlas.connectors._identity import (
    family_ref,
    model_identity,
    model_ref_from_api_id,
    org_key_for_bare_id,
    org_ref_in,
    split_effort_label,
    strip_effort,
    strip_effort_words,
)
from aiatlas.ontology.benchmarks import trust_level
from aiatlas.registry import load, org_by_hf, org_ref, organizations
from aiatlas.sdk.connector import BaseConnector, Parsed, RunContext
from aiatlas.sdk.extract.dates import parse_datetime
from aiatlas.sdk.facts import EntityRef, Facts, Target
from aiatlas.sdk.fetch import FetchResult


def benchmark_ref(key: str) -> EntityRef | None:
    """Registry benchmark → EntityRef. `slug_hint` is the registry key; when an *organisation* already owns that slug (LiveBench the
    org vs `livebench` the benchmark) the resolver appends a collision suffix (`livebench-2` in production) — the identity is the
    `registry_benchmark` identifier, never the slug."""
    b = next((b for b in load("benchmarks") if b["key"] == key), None)
    if not b:
        return None
    return EntityRef(entity_type="benchmark", name=b["name"], identifiers={"registry_benchmark": key}, aliases=list(b.get("aliases", [])), slug_hint=key)


def _slug(s: str) -> str:
    return re.sub(r"[^a-z0-9]+", "", s.lower())


def org_from_name(facts: Facts, *names: str | None) -> EntityRef | None:
    """Registry organization by hf_org / key / name / alias (punctuation-insensitive: 'Z AI' == 'Z.ai'); models map to the lab, not the holding."""
    for n in names:
        if not n:
            continue
        low = n.strip().lower()
        known = org_by_hf(low)
        key = known["key"] if known else None
        if not key:
            wanted = _slug(low)
            for k, o in organizations().items():
                if wanted in {_slug(k), _slug(o["name"]), *(_slug(a) for a in o.get("aliases", []))}:
                    key = k
                    break
        if key:
            if key == "meta" and "meta-ai" in organizations():
                key = "meta-ai"
            return org_ref_in(facts, key)
    return None


def _dt(v: Any) -> datetime | None:
    if isinstance(v, datetime):
        return v if v.tzinfo else v.replace(tzinfo=UTC)
    if isinstance(v, date):
        return datetime(v.year, v.month, v.day, tzinfo=UTC)
    return parse_datetime(v) if isinstance(v, str) else None


def _clean(cfg: dict[str, Any]) -> dict[str, Any]:
    return {k: v for k, v in cfg.items() if v not in (None, "", [], {})}


class _Leaderboard(BaseConnector):
    version = "2"
    parser_version = "2"
    interval_seconds = 12 * 3600
    min_interval_seconds = 6 * 3600
    max_interval_seconds = 3 * 86400
    tier = 2
    priority = 2
    concurrency = 1


# ================================================================================================ Aider polyglot
AIDER_SHORTCUTS = {"r1", "sonnet", "opus", "haiku", "4o", "4-turbo", "35turbo", "3", "flash", "deepseek", "gemini", "gemini-exp", "gemini-2.5-pro"}


class AiderLeaderboardConnector(_Leaderboard):
    name = "aider_leaderboard"
    label = "Aider polyglot coding leaderboard"
    description = "polyglot_leaderboard.yml (raw GitHub file of the aider repo): pass rate and well-formed rate per run, edit format, API id."
    source_key = "aider.chat"
    rate_per_min = 10
    expected_min_records = 30
    URL = "https://raw.githubusercontent.com/Aider-AI/aider/main/aider/website/_data/polyglot_leaderboard.yml"
    PAGE = "https://aider.chat/docs/leaderboards/"

    async def discover(self, ctx: RunContext) -> list[Target]:
        return [Target(url=self.URL, doc_type="leaderboard", key="aider", min_bytes=1000, priority=1, meta={"content_type": "text/yaml"})]

    async def extract(self, ctx: RunContext, target: Target, res: FetchResult, parsed: Parsed) -> Facts:
        facts = Facts()
        bench = benchmark_ref("aider-polyglot")
        well_formed = benchmark_ref("aider-polyglot-well-formed")
        if bench is None:
            return facts
        facts.entities.append(bench)
        if well_formed is not None:
            facts.entities.append(well_formed)
        try:
            rows = yaml.safe_load(res.text) or []
        except yaml.YAMLError:
            return facts
        trust = trust_level(self.source_key)
        for row in rows:
            if not isinstance(row, dict) or not row.get("model") or row.get("pass_rate_2") is None:
                continue
            label = str(row["model"]).strip()
            if re.search(r"\s\+\s", label) or row.get("edit_format") == "architect":
                continue                                            # "o3 (high) + gpt-4.1": a two-model architect/editor system, not one model
            m = re.search(r"--model\s+(\S+)", str(row.get("command") or ""))
            api_id = m.group(1) if m else None
            trusted = bool(api_id) and api_id not in AIDER_SHORTCUTS
            # rolling ids (`deepseek/deepseek-chat`, `codestral-latest`) name whichever snapshot served that day: identifiers only for
            # pinned snapshots and namespaced (OpenRouter / hub) ids, aliases otherwise
            ident = model_identity(api_id, trusted=trusted) if trusted else None
            use_ids = bool(ident) and (ident.pinned or ident.provider_prefix == "openrouter" or "hf_repo" in ident.identifiers)  # type: ignore[union-attr]
            ref, effort = model_ref_from_api_id(facts, api_id if trusted else None, name=label, trusted=use_ids, identity_confidence="medium")
            evaluated = _dt(row.get("date"))
            config = _clean({"edit_format": row.get("edit_format"), "api_model_id": api_id, "date": evaluated.date().isoformat() if evaluated else None,
                             "reasoning_effort": row.get("reasoning_effort"), **effort})
            run_group = config.get("date")
            facts.result(model=ref, benchmark=bench, score=float(row["pass_rate_2"]), metric="pass_rate_2", unit="%", config=config, evaluated_at=evaluated,
                         source_url=self.PAGE, trust_level=trust, variant="polyglot", run_group=run_group)
            if well_formed is not None and row.get("percent_cases_well_formed") is not None:
                facts.result(model=ref, benchmark=well_formed, score=float(row["percent_cases_well_formed"]), metric="percent_cases_well_formed", unit="%",
                             config={**config, "variant": "well-formed"}, evaluated_at=evaluated, source_url=self.PAGE, trust_level=trust, variant="well-formed",
                             run_group=run_group)
        facts.document_entity = bench
        facts.document_title = "Aider polyglot leaderboard data"
        return facts


# ================================================================================================ SWE-bench
BOARD_KEYS = {"verified": "swe-bench-verified", "lite": "swe-bench-lite", "test": "swe-bench-full", "full": "swe-bench-full",
              "multimodal": "swe-bench-multimodal", "multilingual": "swe-bench-multilingual", "pro": "swe-bench-pro"}
NOT_A_MODEL = {"multiple", "undisclosed", "unknown", "n/a", "-", "—", "various", "proprietary", "custom", "internal"}


class SweBenchLeaderboardConnector(_Leaderboard):
    name = "swebench_leaderboard"
    label = "SWE-bench leaderboards (Verified, Lite, Full, Multimodal, Multilingual)"
    description = "Embedded leaderboard JSON of swebench.com: % resolved per (system, model) submission with dates; trust follows the SWE-bench check mark."
    source_key = "swebench.com"
    rate_per_min = 10
    expected_min_records = 50
    URL = "https://www.swebench.com/"

    async def discover(self, ctx: RunContext) -> list[Target]:
        return [Target(url=self.URL, doc_type="leaderboard", key="swebench", min_bytes=20000, priority=1)]

    async def extract(self, ctx: RunContext, target: Target, res: FetchResult, parsed: Parsed) -> Facts:
        facts = Facts()
        html = parsed.html
        if not html:
            return facts
        data = html.embedded_json.get("leaderboard-data")
        if not isinstance(data, list):
            return facts
        for board in data:
            key = BOARD_KEYS.get(str(board.get("name") or "").lower())
            bench = benchmark_ref(key) if key else None
            if bench is None:
                continue
            facts.entities.append(bench)
            for r in board.get("results") or []:
                self._row(facts, bench, board.get("name"), r)
        facts.document_title = html.title or "SWE-bench leaderboards"
        return facts

    def _row(self, facts: Facts, bench: EntityRef, board: str, r: dict[str, Any]) -> None:
        model_name = (r.get("model_display") or "").strip()
        resolved = r.get("resolved")
        if not model_name or not isinstance(resolved, (int, float)):
            return
        if re.search(r"\s(&|\+|and)\s", model_name):        # "GPT-4o & Claude 3 Opus": a multi-model system, not one model
            return
        if model_name.lower() in NOT_A_MODEL:                 # "Multiple", "Undisclosed": the submission does not name its model
            return
        tags = [t for t in r.get("tags") or [] if isinstance(t, str)]
        model_tags = [t.split(":", 1)[1].strip() for t in tags if t.lower().startswith("model:")]
        model_tag = model_tags[0] if model_tags else None
        org = org_from_name(facts, r.get("model_org"))
        # the "Model:" tag is free text ("claude-4-5-opus", "gpt-5-2"): aliases and organisation only, never an identifier
        ref, effort = model_ref_from_api_id(facts, model_tag, name=model_name, trusted=False, identity_confidence="medium", organization=org)
        evaluated = _dt(r.get("date"))
        config = _clean({"board": board, "system": r.get("agent") or r.get("name"), "system_org": r.get("agent_org"), "open_source_system": r.get("os_system"),
                         "checked_by_swebench": r.get("checked"), "submission": r.get("folder"), "date": evaluated.date().isoformat() if evaluated else None,
                         "model_tag": model_tag, "reasoning_effort": r.get("reasoning_effort") or None, **effort})
        facts.result(model=ref, benchmark=bench, score=float(resolved), metric="resolved", unit="%", config=config, evaluated_at=evaluated, source_url=self.URL,
                     trust_level=trust_level(self.source_key, config), variant=board, run_group=config.get("date"))


# ================================================================================================ LiveBench
RELEASES = re.compile(r'\[("20\d\d-\d\d-\d\d"(?:,"20\d\d-\d\d-\d\d")*)\]')
MODEL_META = re.compile(r'"([\w.:/-]+)":\{((?:[^{}]|\{[^{}]*\})*?displayName:"(?:[^{}]|\{[^{}]*\})*)\}')
META_FIELD = re.compile(r'(url|huggingface|organization|displayName):"([^"]*)"')
CATEGORY_KEYS = {"Reasoning": "livebench-reasoning", "Coding": "livebench-coding", "Agentic Coding": "livebench-agentic-coding", "Mathematics": "livebench-mathematics",
                 "Data Analysis": "livebench-data-analysis", "Language": "livebench-language", "IF": "livebench-if", "Instruction Following": "livebench-if"}


class LiveBenchLeaderboardConnector(_Leaderboard):
    name = "livebench_leaderboard"
    label = "LiveBench leaderboard"
    description = "Latest LiveBench release table (CSV + categories JSON discovered from the site bundle): overall mean and one benchmark per category."
    source_key = "livebench.ai"
    rate_per_min = 10
    expected_min_records = 20
    BASE = "https://livebench.ai/"

    async def discover(self, ctx: RunContext) -> list[Target]:
        return [Target(url=self.BASE, doc_type="listing", key="livebench_index", min_bytes=200, priority=1)]

    async def extract(self, ctx: RunContext, target: Target, res: FetchResult, parsed: Parsed) -> Facts:
        facts = Facts()
        key = target.key or ""
        if key == "livebench_index" and parsed.html:
            script = next((s.attributes.get("src") for s in parsed.html.css("script[src]") if "main." in (s.attributes.get("src") or "")), None)
            if script:
                facts.follow(self.BASE + script.lstrip("./"), doc_type="script", key="livebench_js", min_bytes=10000, priority=1, meta={"content_type": "text/javascript"})
        elif key == "livebench_js":
            js = res.text
            dates = sorted({d for m in RELEASES.finditer(js) for d in json.loads("[" + m.group(1) + "]")})
            if not dates:
                ctx.log.warning("livebench bundle: no release list found")
                return facts
            latest = self.config.get("release") or dates[-1]
            models = {}
            for m in MODEL_META.finditer(js):
                fields = dict(META_FIELD.findall(m.group(2)))
                models[m.group(1)] = {"url": fields.get("url"), "huggingface": fields.get("huggingface"), "organization": fields.get("organization"),
                                      "display_name": fields.get("displayName")}
            tag = latest.replace("-", "_")
            facts.follow(f"{self.BASE}categories_{tag}.json", doc_type="data", key="livebench_categories", min_bytes=20, priority=1,
                         meta={"release": latest, "models": models, "content_type": "application/json"})
        elif key == "livebench_categories":
            cats = parsed.json if parsed.kind == "json" else None
            release = target.meta.get("release")
            if isinstance(cats, dict) and release:
                facts.follow(f"{self.BASE}table_{release.replace('-', '_')}.csv", doc_type="leaderboard", key="livebench_table", min_bytes=200, priority=1,
                             meta={"release": release, "categories": cats, "models": target.meta.get("models") or {}, "content_type": "text/csv"})
        elif key == "livebench_table":
            self._table(facts, target, res.text)
        return facts

    def _table(self, facts: Facts, target: Target, text: str) -> None:
        bench = benchmark_ref("livebench")
        if bench is None:
            return
        facts.entities.append(bench)
        release = target.meta.get("release")
        cats: dict[str, list[str]] = target.meta.get("categories") or {}
        meta: dict[str, dict[str, Any]] = target.meta.get("models") or {}
        evaluated = _dt(release)
        trust = trust_level(self.source_key)
        cat_benches: dict[str, EntityRef] = {}
        for cat in cats:
            ckey = CATEGORY_KEYS.get(cat) or f"livebench-{re.sub(r'[^a-z0-9]+', '-', cat.lower()).strip('-')}"
            cref = benchmark_ref(ckey)
            if cref is not None:
                cat_benches[cat] = cref
                facts.entities.append(cref)
        for row in csv.DictReader(io.StringIO(text)):
            mid = (row.get("model") or "").strip()
            if not mid:
                continue
            info = meta.get(mid) or {}
            base_id, effort = strip_effort(mid)
            display, label_effort = split_effort_label(info.get("display_name") or base_id)     # "GPT-5.6 Sol xHigh Effort" → base + setting
            effort = {**effort, **label_effort}
            if effort and info.get("display_name"):
                display = strip_effort_words(display, only_if=True)
            # no `hf_repo` identifier here: several LiveBench ids (effort variants, MLX conversions) share one display name and would
            # glue unrelated hub repositories onto a single entity; the link is kept as a claim on the leaderboard row's model
            org = org_from_name(facts, info.get("organization"))
            if org is None:
                _scheme, org_key = org_key_for_bare_id(base_id)
                org = org_ref_in(facts, org_key)
            ref = next((e for e in facts.entities if e.entity_type == "model" and e.name.lower() == display.lower()), None)
            if ref is None:
                ref = facts.entity("model", display[:200], organization=org, aliases=[a for a in dict.fromkeys([base_id, mid]) if a != display],
                                   identity_confidence="medium", family=family_ref(display, org))
            elif mid not in ref.aliases:
                ref.aliases.append(mid)
            hf = info.get("huggingface") or ""
            m = re.search(r"huggingface\.co/([\w.-]+/[\w.-]+)", hf)
            if m:
                facts.claim(ref, "livebench_hf_link", f"https://huggingface.co/{m.group(1)}")
            scores = {k: float(v) for k, v in row.items() if k and k != "model" and v not in (None, "", "-") and _is_number(v)}
            cat_avgs: dict[str, float] = {}
            for cat, tasks in cats.items():
                vals = [scores[t] for t in tasks if t in scores]
                if vals:
                    cat_avgs[cat] = round(fmean(vals), 3)
            if not cat_avgs:
                continue
            base_cfg = _clean({"release": release, "livebench_model_id": mid, "aggregation": "mean of category averages; category = mean of its subtasks", **effort})
            facts.result(model=ref, benchmark=bench, score=round(fmean(cat_avgs.values()), 3), metric="global_average", unit="%", config=base_cfg,
                         evaluated_at=evaluated, source_url=self.BASE, trust_level=trust, variant="global", run_group=release)
            for cat, avg in cat_avgs.items():
                cref = cat_benches.get(cat)
                if cref is None:
                    continue
                facts.result(model=ref, benchmark=cref, score=avg, metric="average score", unit="%",
                             config=_clean({"release": release, "livebench_model_id": mid, "variant": cat, "subtasks": cats[cat], **effort}),
                             evaluated_at=evaluated, source_url=self.BASE, trust_level=trust, variant=cat, run_group=release)
        facts.document_entity = bench
        facts.document_title = f"LiveBench {release}"


def _is_number(v: str) -> bool:
    try:
        float(v)
        return True
    except ValueError:
        return False


# ================================================================================================ Artificial Analysis
# RSC field → (registry benchmark key, metric, variant label). GPQA on AA is the Diamond subset; τ²-Bench is the Telecom domain.
AA_EVALS = {"gpqa": ("gpqa-diamond", "accuracy", "Diamond"), "hle": ("humanitys-last-exam", "accuracy", None), "aime25": ("aime-2025", "accuracy", None),
            "livecodebench": ("livecodebench", "pass@1", None), "scicode": ("scicode", "accuracy", None), "ifbench": ("ifbench", "accuracy", None),
            "mmmuPro": ("mmmu-pro", "accuracy", None), "tau2": ("tau2-bench", "pass^1", "Telecom"), "terminalbenchV40": ("terminal-bench", "accuracy", "v4.0"),
            "terminalbenchV21": ("terminal-bench", "accuracy", "v2.1"), "terminalbenchHard": ("terminal-bench", "accuracy", "hard")}
PUSH = re.compile(r'self\.__next_f\.push\(\[1,"(.*?)"\]\)\s*</script>', re.DOTALL)
# model-level facts AA copies from the labs (same for every effort variant of a model) → written once per base model as `aa_*`
AA_MODEL_CLAIMS = ("aa_release_date", "aa_openness", "aa_context_window", "aa_deprecated")


class ArtificialAnalysisConnector(_Leaderboard):
    name = "artificial_analysis"
    label = "Artificial Analysis — Intelligence Index and component evaluations"
    description = "Model leaderboard page (RSC payload): Intelligence Index with version and component evaluations; effort variants fold into their base model."
    source_key = "artificialanalysis.ai"
    rate_per_min = 6
    expected_min_records = 100
    URL = "https://artificialanalysis.ai/leaderboards/models"

    async def discover(self, ctx: RunContext) -> list[Target]:
        return [Target(url=self.URL, doc_type="leaderboard", key="aa_models", min_bytes=50000, priority=1)]

    async def extract(self, ctx: RunContext, target: Target, res: FetchResult, parsed: Parsed) -> Facts:
        facts = Facts()
        models, version = parse_rsc_models(res.text)
        if not models:
            ctx.log.warning("artificial analysis: no model objects in the RSC payload")
            return facts
        index = benchmark_ref("artificial-analysis-intelligence-index")
        assert index
        facts.entities.append(index)
        benches = {k: benchmark_ref(k) for k, *_ in AA_EVALS.values()}
        trust = trust_level(self.source_key)
        written: set[tuple[int, str]] = set()

        def once(ref: EntityRef, prop: str, value: Any, **kw: Any) -> None:
            """One claim per (base model, property): several effort variants of a model repeat the same model-level facts."""
            if value in (None, "", []) or (id(ref), prop) in written:
                return
            written.add((id(ref), prop))
            facts.claim(ref, prop, value, **kw)

        for slug, m in models.items():
            ref, effort = self._model(facts, slug, m, models)
            # AA copies release date / openness / context / deprecation from the labs: recorded under `aa_*` so that a second-hand
            # tier-2 source never supersedes another tier-2 source (hub/OpenRouter) every run; the results are AA's own data.
            if m.get("releaseDate"):
                once(ref, "aa_release_date", str(m["releaseDate"])[:10])
            if isinstance(m.get("isOpenWeights"), bool):
                once(ref, "aa_openness", "open-weights" if m["isOpenWeights"] else "proprietary")
            if m.get("deprecated") is True and not effort:
                once(ref, "aa_deprecated", True)
            if isinstance(m.get("contextWindowTokens"), int) and m["contextWindowTokens"] > 0:
                once(ref, "aa_context_window", m["contextWindowTokens"], unit="tokens")
            if not effort:
                if isinstance(m.get("isReasoning"), bool):
                    once(ref, "reasoning", m["isReasoning"])
                if isinstance(m.get("medianOutputTokensPerSecond"), (int, float)):
                    once(ref, "metric.aa_median_output_tokens_per_second", round(float(m["medianOutputTokensPerSecond"]), 1))
            # the reasoning switch is part of every result's configuration (a base row and its "non-reasoning" sibling differ by it)
            if isinstance(m.get("isReasoning"), bool) and "reasoning" not in effort and "reasoning_effort" not in effort:
                effort["reasoning"] = "on" if m["isReasoning"] else "off"
            ii = m.get("intelligenceIndex")
            if isinstance(ii, (int, float)):
                cfg = _clean({"version": version, "estimated": bool(m.get("intelligenceIndexIsEstimated")), "aa_slug": slug, **effort})
                facts.result(model=ref, benchmark=index, score=round(float(ii), 2), metric="index", unit="", config=cfg, source_url=self.URL, trust_level=trust,
                             variant="index", run_group=version)
            for field, (bkey, metric, variant) in AA_EVALS.items():
                v = m.get(field)
                bench = benches.get(bkey)
                if bench is None or not isinstance(v, (int, float)):
                    continue
                if bench not in facts.entities:
                    facts.entities.append(bench)
                cfg = _clean({"evaluator": "Artificial Analysis", "index_version": version, "aa_slug": slug, "variant": variant, **effort})
                facts.result(model=ref, benchmark=bench, score=round(float(v) * 100, 2), metric=metric, unit="%", config=cfg, source_url=self.URL, trust_level=trust,
                             variant=variant, run_group=version)
        facts.document_entity = index
        facts.document_title = f"Artificial Analysis models — Intelligence Index v{version}" if version else "Artificial Analysis models"
        return facts

    def _model(self, facts: Facts, slug: str, m: dict[str, Any], models: dict[str, dict[str, Any]]) -> tuple[EntityRef, dict[str, str]]:
        """Base-model EntityRef + effort configuration for one AA row. AA's own base label is `shortName` without its parenthetical
        ("Claude Opus 5 (xhigh)" → "Claude Opus 5"); the slug carries the suffix (`claude-opus-5-xhigh`). The `artificial_analysis`
        identifier is attached only when AA lists the base slug itself; otherwise the base slug is an alias."""
        short = (m.get("shortName") or m.get("name") or slug).strip()
        label, label_effort = split_effort_label(short)
        base_slug, slug_effort = strip_effort(slug)
        effort = {**slug_effort, **label_effort}
        if slug_effort and not label_effort:
            label = strip_effort_words(label, only_if=True)
        variant = bool(effort) and base_slug != slug
        creator = m.get("creator") or {}
        creator_name = creator.get("name") or m.get("modelCreatorName")
        org = org_from_name(facts, creator.get("slug"), creator_name)
        if org is None and org_key_for_bare_id(base_slug)[1] is None and creator_name:
            # creator unknown to the registry and no first-party pattern: AA's own creator label becomes a company with AA's identifier
            existing = next((e for e in facts.entities if e.identifiers.get("artificial_analysis_creator") == (creator.get("slug") or _slug(creator_name))), None)
            org = existing or facts.entity("company", creator_name, identifiers={"artificial_analysis_creator": creator.get("slug") or _slug(creator_name)})
        identifiers: dict[str, str] = {}
        aliases: list[str] = []
        if not variant:
            identifiers["artificial_analysis"] = slug
        elif base_slug in models:
            identifiers["artificial_analysis"] = base_slug
        else:
            aliases.append(base_slug)
        aliases += [a for a in (short if not effort else None, m.get("shortName") if not effort else None) if a]
        ref, _ = model_ref_from_api_id(facts, base_slug, name=label or base_slug, trusted=False, identity_confidence="medium", organization=org,
                                       extra_aliases=aliases)
        for k, v in identifiers.items():
            ref.identifiers.setdefault(k, v)
        return ref, effort


def parse_rsc_models(html: str) -> tuple[dict[str, dict[str, Any]], str | None]:
    """Concatenate the Next.js flight chunks, parse each `id:json` line and collect every object with `slug` + `intelligenceIndex`."""
    chunks = []
    for p in PUSH.findall(html):
        try:
            chunks.append(json.loads('"' + p + '"'))
        except json.JSONDecodeError:
            continue
    blob = "".join(chunks)
    version_m = re.search(r"Intelligence Index v(\d+(?:\.\d+)?)", blob)
    models: dict[str, dict[str, Any]] = {}
    for line in blob.split("\n"):
        _, sep, payload = line.partition(":")
        if not sep or "intelligenceIndex" not in payload:
            continue
        try:
            data = json.loads(payload)
        except json.JSONDecodeError:
            continue
        stack = [data]
        while stack:
            o = stack.pop()
            if isinstance(o, dict):
                if "intelligenceIndex" in o and isinstance(o.get("slug"), str):
                    models.setdefault(o["slug"], o)
                else:
                    stack.extend(o.values())
            elif isinstance(o, list):
                stack.extend(o)
    return models, (version_m.group(1) if version_m else None)


_ = org_ref  # kept importable for tests/back-compat

CONNECTORS = [AiderLeaderboardConnector, SweBenchLeaderboardConnector, LiveBenchLeaderboardConnector, ArtificialAnalysisConnector]