File size: 37,549 Bytes

15d1f1d

#!/usr/bin/env python3
"""Causally scoped v5.2-rc3 evaluator (offline acceptance candidate).

RC3 deliberately exposes two different verifier scopes:

``components`` / ``verified_reward_full_gt``
    Offline, executed-DXF versus full-GT verification.  Full-GT physical
    geometry is retained here because an RLVR verifier is allowed to access
    the reference answer.

``online_reward_prompt_masked``
    The FMFS-masked view of physical/annotation supervision.  Prompt physical
    features are scored only when the sidecar supplies a certified mapping to
    actual geometry.  Missing or ambiguous mappings are ineligible; there is
    no fallback to predicted DIMENSION text or to the full-GT physical score.

One positive uniform sheet scale remains an explicit legal invariance.  The
metric verifies geometry and physical proportions after fitting that scale;
it does not require a particular DXF plotting scale.

This module is add-only and is not connected to GRPO.  It uses the RC3 matcher
so every predicted cluster, including clusters outside the bounded role
assignment search, contributes to extra-geometry precision.
"""

from __future__ import annotations

import copy
import math
from itertools import combinations
from pathlib import Path
from typing import Any, Mapping, Sequence

import numpy as np
from scipy.optimize import linear_sum_assignment

try:
    from . import eval_geometric052 as BASE
    from . import eval_geometric052_rc2 as RC2
    from . import view_entity_matching_v52_rc3 as MATCH
except ImportError:  # direct evaluator import
    import eval_geometric052 as BASE
    import eval_geometric052_rc2 as RC2
    import view_entity_matching_v52_rc3 as MATCH


METRIC_VERSION = "v5.2-rc3"
SCHEMA_VERSION = "edp-geometric-evaluator-v5.2-rc3"
ENGINEERING_THRESHOLDS = dict(BASE.ENGINEERING_THRESHOLDS)

PHYSICAL_SUPPORTED_SEMANTICS = BASE.PHYSICAL_SUPPORTED_SEMANTICS | {
    "bounding_box_width",
    "bounding_box_height",
    "cut_profile_diameter",
}

MAX_DIMENSION_BINDING_FRACTION = 0.08
MAX_DIMENSION_VALUE_LOG_ERROR = math.log(1.5)
MAX_GEOMETRY_BINDING_REL_ERROR = 0.03
SEVERE_ANNOTATION_SPAM_MULTIPLIER = 3
SEVERE_ANNOTATION_SPAM_ALLOWANCE = 6


def _consume_appended_omitted_marker(context: dict[str, Any]) -> dict[str, Any]:
    """Make clear that RC3 appended, and therefore did not omit, the clusters."""

    alignment = context.get("alignment")
    if not isinstance(alignment, dict):
        return context
    original = list(alignment.get("omitted_original_indices", []))
    alignment["role_assignment_omitted_original_indices"] = original
    alignment["omitted_original_indices"] = []
    alignment["omitted_clusters_are_appended_as_extras"] = True
    return context


def _layout_component(
    context: Mapping[str, Any], rows: Mapping[str, Any]
) -> dict[str, Any]:
    """Measure layout with radius/arc-parameter-invariant view anchors."""

    roles = [role for role, row in rows.items() if row["present"]]
    if len(roles) < 2:
        return BASE._component(
            None, False, "fewer_than_two_semantic_roles", matched_roles=roles
        )
    alignment = context["alignment"]
    scale = float(alignment.get("global_scale", 1.0))
    role_to_pred = alignment["role_to_pred"]
    pred_views = context["pred_views"]
    gt_by_role = context["gt_by_role"]
    sheet_diagonal = max(float(alignment.get("sheet_diagonal", 1.0)), 1.0)
    errors: list[float] = []
    pair_rows: list[dict[str, Any]] = []
    for first, second in combinations(roles, 2):
        pred_first = pred_views[role_to_pred[first]].get("layout_anchor")
        pred_second = pred_views[role_to_pred[second]].get("layout_anchor")
        gt_first = gt_by_role[first].get("layout_anchor")
        gt_second = gt_by_role[second].get("layout_anchor")
        if any(value is None for value in (pred_first, pred_second, gt_first, gt_second)):
            return BASE._component(
                None,
                False,
                "layout_anchor_unavailable",
                matched_roles=roles,
                anchor_definition=MATCH.LAYOUT_ANCHOR_DEFINITION,
            )
        pred_vector = scale * (
            np.asarray(pred_second, dtype=float) - np.asarray(pred_first, dtype=float)
        )
        gt_vector = np.asarray(gt_second, dtype=float) - np.asarray(gt_first, dtype=float)
        error = float(np.linalg.norm(pred_vector - gt_vector) / sheet_diagonal)
        errors.append(error)
        pair_rows.append(
            {"roles": [first, second], "vector_error_fraction": BASE._round(error)}
        )
    mean_error = float(np.mean(errors))
    score = math.exp(-mean_error / 0.10)
    return BASE._component(
        score,
        True,
        "ok" if mean_error <= 0.02 else "relative_view_layout_mismatch",
        matched_roles=roles,
        mean_pair_vector_error_fraction=BASE._round(mean_error),
        pairs=pair_rows,
        anchor_definition=MATCH.LAYOUT_ANCHOR_DEFINITION,
        uniform_sheet_scale_invariant=True,
    )


def _scope_contract(
    sidecar: Mapping[str, Any] | None, scope: str
) -> tuple[dict[str, Any], dict[str, Any]]:
    contract = BASE.EV51._scope_contracts(sidecar)
    selected = contract.get(scope, {})
    return contract, selected if isinstance(selected, Mapping) else {}


def _dimension_targets(
    context: Mapping[str, Any],
    sidecar: Mapping[str, Any] | None,
    contract: Mapping[str, Any],
) -> list[dict[str, Any]]:
    gt_dims = list((context.get("raw_gt") or {}).get("dims", []))
    targets: list[dict[str, Any]] = []
    for spec_index, raw_spec in enumerate(contract.get("specs", [])):
        spec = dict(raw_spec)
        try:
            gt_index = int(spec["gt_dimension_index"])
        except (KeyError, TypeError, ValueError):
            continue
        if not 0 <= gt_index < len(gt_dims):
            continue
        targets.append(
            {
                "spec_index": spec_index,
                "spec": spec,
                "gt_index": gt_index,
                "dimension": gt_dims[gt_index],
                "role": BASE._dimension_role(sidecar, gt_index),
            }
        )
    return targets


def _dimension_pair_detail(
    context: Mapping[str, Any],
    pred_dim: Mapping[str, Any],
    target: Mapping[str, Any],
) -> dict[str, Any]:
    role = target.get("role")
    transform = MATCH.role_local_transform(context, str(role)) if role else None
    if transform is None:
        scale = float(context["alignment"].get("global_scale", 1.0))
        translation = np.asarray(
            context["alignment"].get("translation", (0.0, 0.0)), dtype=float
        )
    else:
        scale, translation = transform
    sheet_diagonal = max(float(context["alignment"].get("sheet_diagonal", 1.0)), 1.0)
    pred_binding = np.asarray(pred_dim.get("binding_point", (0.0, 0.0)), dtype=float)
    gt_binding = np.asarray(
        target["dimension"].get("binding_point", (0.0, 0.0)), dtype=float
    )
    distance = float(
        np.linalg.norm(pred_binding * scale + translation - gt_binding) / sheet_diagonal
    )
    pred_family = BASE._semantic_family(pred_dim.get("family"))
    target_family = BASE._semantic_family(target["spec"].get("family"))
    target_value = abs(float(target["spec"]["value"]))
    predicted_value, value_source = BASE._dimension_display_value(
        pred_dim,
        target_value=target_value,
        target_dimension=target["dimension"],
        global_scale=float(scale),
    )
    if predicted_value is None or target_value <= 1e-12:
        value_log_error = math.inf
        value_relative_error = None
    else:
        value_log_error = abs(
            math.log(max(float(predicted_value), 1e-12) / target_value)
        )
        value_relative_error = abs(float(predicted_value) / target_value - 1.0)
    family_ok = pred_family == target_family
    accepted = bool(
        family_ok
        and distance <= MAX_DIMENSION_BINDING_FRACTION
        and value_log_error <= MAX_DIMENSION_VALUE_LOG_ERROR
    )
    cost = (
        distance
        + (2.0 if not family_ok else 0.0)
        + 0.20 * min(value_log_error, 2.0)
    )
    return {
        "cost": cost,
        "accepted": accepted,
        "binding_distance_fraction": distance,
        "predicted_family": pred_family,
        "target_family": target_family,
        "family_ok": family_ok,
        "target_value": target_value,
        "predicted_value": predicted_value,
        "value_source": value_source,
        "value_log_error": value_log_error,
        "value_relative_error": value_relative_error,
        "scale": float(scale),
        "role": role,
    }


def _annotation_component(
    context: Mapping[str, Any],
    sidecar: Mapping[str, Any] | None,
    *,
    scope: str,
) -> dict[str, Any]:
    """Score masked target quality plus precision against the total GT inventory."""

    contract, selected_contract = _scope_contract(sidecar, scope)
    mask = selected_contract.get("annotation_mask", [])
    if not selected_contract.get("annotation_eligible"):
        return BASE._component(
            None,
            False,
            f"{scope}_annotation_mask_ineligible",
            scope=scope,
            contract_errors=contract.get("errors", []),
            reason_codes=selected_contract.get("reason_codes", []),
        )
    targets = _dimension_targets(context, sidecar, contract)
    selected_spec_indices = {
        index for index, selected in enumerate(mask) if selected
    }
    selected_targets = [
        target for target in targets if target["spec_index"] in selected_spec_indices
    ]
    if not selected_targets:
        return BASE._component(
            None, False, "no_valid_masked_target_dimensions", scope=scope
        )

    pred_dims = list((context.get("raw_pred") or {}).get("dims", []))
    details: dict[tuple[int, int], dict[str, Any]] = {}
    pairs_by_target: dict[int, int] = {}
    if pred_dims and targets:
        costs = np.zeros((len(pred_dims), len(targets)), dtype=float)
        for pred_index, pred_dim in enumerate(pred_dims):
            for target_index, target in enumerate(targets):
                detail = _dimension_pair_detail(context, pred_dim, target)
                details[(pred_index, target_index)] = detail
                costs[pred_index, target_index] = float(detail["cost"])
        pred_rows, target_columns = linear_sum_assignment(costs)
        for pred_index, target_index in zip(pred_rows, target_columns):
            detail = details[(int(pred_index), int(target_index))]
            if detail["accepted"]:
                pairs_by_target[int(target_index)] = int(pred_index)

    target_position = {target["spec_index"]: index for index, target in enumerate(targets)}
    item_rows: list[dict[str, Any]] = []
    item_scores: list[float] = []
    presence_values: list[float] = []
    type_values: list[float] = []
    value_values: list[float] = []
    binding_values: list[float] = []
    for target in selected_targets:
        position = target_position[target["spec_index"]]
        pred_index = pairs_by_target.get(position)
        spec = target["spec"]
        if pred_index is None:
            item_scores.append(0.0)
            presence_values.append(0.0)
            type_values.append(0.0)
            value_values.append(0.0)
            binding_values.append(0.0)
            item_rows.append(
                {
                    "id": spec["id"],
                    "gt_dimension_index": target["gt_index"],
                    "pred_dimension_index": None,
                    "role": target.get("role"),
                    "presence": 0.0,
                    "type": 0.0,
                    "display_value": 0.0,
                    "binding": 0.0,
                    "score": 0.0,
                    "reason": "missing_or_semantically_incompatible_dimension",
                }
            )
            continue
        detail = details[(pred_index, position)]
        value_quality = math.exp(-float(detail["value_log_error"]) / 0.10)
        binding_quality = math.exp(
            -float(detail["binding_distance_fraction"]) / 0.03
        )
        item_score = 0.35 + 0.20 + 0.30 * value_quality + 0.15 * binding_quality
        item_scores.append(item_score)
        presence_values.append(1.0)
        type_values.append(1.0)
        value_values.append(value_quality)
        binding_values.append(binding_quality)
        item_rows.append(
            {
                "id": spec["id"],
                "gt_dimension_index": target["gt_index"],
                "pred_dimension_index": pred_index,
                "role": target.get("role"),
                "presence": 1.0,
                "type": 1.0,
                "display_value": BASE._round(value_quality),
                "binding": BASE._round(binding_quality),
                "target_display_value": BASE._round(detail["target_value"]),
                "predicted_display_value": BASE._round(detail["predicted_value"]),
                "display_value_source": detail["value_source"],
                "display_value_relative_error": BASE._round(
                    detail["value_relative_error"]
                ),
                "binding_distance_fraction": BASE._round(
                    detail["binding_distance_fraction"]
                ),
                "score": BASE._round(item_score),
                "reason": "ok" if item_score >= 0.90 else "annotation_field_mismatch",
            }
        )

    target_macro = float(np.mean(item_scores))
    target_worst = min(item_scores)
    target_quality = 0.50 * target_macro + 0.50 * target_worst
    matched_predicted = set(pairs_by_target.values())
    pred_meta = context.get("pred_meta", {})
    gt_meta = context.get("gt_meta", {})
    pred_text = int(pred_meta.get("dimension_like_text", 0) or 0)
    gt_text = int(gt_meta.get("dimension_like_text", 0) or 0)
    predicted_inventory = len(pred_dims) + pred_text
    matched_inventory = len(matched_predicted) + min(pred_text, gt_text)
    predicted_precision = (
        matched_inventory / predicted_inventory if predicted_inventory else 0.0
    )
    score = BASE._harmonic(target_quality, predicted_precision)
    return BASE._component(
        score,
        True,
        "ok" if score >= ENGINEERING_THRESHOLDS["annotation"] else "annotation_recall_precision_or_field_mismatch",
        scope=scope,
        n_selected_target=len(selected_targets),
        n_total_gt_dimension_targets=len(targets),
        n_predicted_native=len(pred_dims),
        n_predicted_dimension_like_text=pred_text,
        n_matched_predicted_native=len(matched_predicted),
        n_unmatched_predicted_native=len(pred_dims) - len(matched_predicted),
        predicted_precision=BASE._round(predicted_precision),
        presence_recall=BASE._round(float(np.mean(presence_values))),
        type_macro=BASE._round(float(np.mean(type_values))),
        display_value_macro=BASE._round(float(np.mean(value_values))),
        binding_macro=BASE._round(float(np.mean(binding_values))),
        target_quality=BASE._round(target_quality),
        item_macro=BASE._round(target_macro),
        item_worst=BASE._round(target_worst),
        items=item_rows,
        matching_policy="one_to_one_all_gt_inventory_family_binding_value_gated",
        unselected_gt_dimensions_are_precision_neutral=True,
        reads_actual_geometry=False,
    )


def _sidecar_dimension_item(
    sidecar: Mapping[str, Any] | None, gt_index: int
) -> Mapping[str, Any] | None:
    dimensions = sidecar.get("dimensions") if isinstance(sidecar, Mapping) else None
    items = dimensions.get("items") if isinstance(dimensions, Mapping) else None
    if isinstance(items, Sequence) and 0 <= gt_index < len(items):
        item = items[gt_index]
        return item if isinstance(item, Mapping) else None
    return None


def _fmfs_prompt_items(
    sidecar: Mapping[str, Any] | None,
) -> dict[int, Mapping[str, Any]]:
    fmfs = sidecar.get("fmfs") if isinstance(sidecar, Mapping) else None
    prompt = fmfs.get("prompt") if isinstance(fmfs, Mapping) else None
    items = prompt.get("items") if isinstance(prompt, Mapping) else None
    result: dict[int, Mapping[str, Any]] = {}
    if not isinstance(items, Sequence) or isinstance(items, (str, bytes)):
        return result
    for item in items:
        if not isinstance(item, Mapping):
            continue
        try:
            gt_index = int(item["gt_dimension_index"])
        except (KeyError, TypeError, ValueError):
            continue
        result[gt_index] = item
    return result


def _linear_axis(item: Mapping[str, Any], target_dim: Mapping[str, Any]) -> int | None:
    binding = item.get("v51_binding")
    orientation = binding.get("orientation") if isinstance(binding, Mapping) else None
    if orientation == "horizontal":
        return 0
    if orientation == "vertical":
        return 1
    refs = target_dim.get("ref_points", {})
    if isinstance(refs, Mapping) and "defpoint2" in refs and "defpoint3" in refs:
        first = np.asarray(refs["defpoint2"], dtype=float)
        second = np.asarray(refs["defpoint3"], dtype=float)
        delta = np.abs(second - first)
        if float(np.max(delta)) > 1e-12:
            return int(delta[1] > delta[0])
    return None


def _map_prompt_physical_item(
    context: Mapping[str, Any],
    rows: Mapping[str, Any],
    sidecar: Mapping[str, Any] | None,
    target: Mapping[str, Any],
    fmfs_item: Mapping[str, Any],
) -> tuple[dict[str, Any] | None, str | None]:
    semantic = str(fmfs_item.get("semantic_type") or "")
    if semantic not in PHYSICAL_SUPPORTED_SEMANTICS:
        return None, f"unsupported_semantic:{semantic or 'missing'}"
    if not fmfs_item.get("physical_eligible"):
        return None, "fmfs_item_not_physical_eligible"
    binding = fmfs_item.get("binding")
    geometry_binding = binding.get("geometry") if isinstance(binding, Mapping) else None
    if not isinstance(geometry_binding, Mapping) or geometry_binding.get("state") != "certified":
        return None, "geometry_binding_not_certified"
    role = target.get("role")
    if role not in context.get("gt_by_role", {}):
        return None, "semantic_view_role_unavailable"
    target_view = context["gt_by_role"][role]
    row = rows[role]
    spec_family = BASE._semantic_family(target["spec"].get("family"))
    target_dim = target["dimension"]
    measurement = target_dim.get("measurement")
    if not isinstance(measurement, (int, float)) or float(measurement) <= 1e-12:
        return None, "target_geometry_measurement_unavailable"

    if spec_family == "linear":
        sidecar_item = _sidecar_dimension_item(sidecar, target["gt_index"])
        axis = _linear_axis(sidecar_item or {}, target_dim)
        if axis is None:
            return None, "linear_axis_unavailable"
        gt_size = np.asarray(target_view["size"], dtype=float)
        gt_value = float(gt_size[axis])
        relative = abs(float(measurement) / max(gt_value, 1e-12) - 1.0)
        if relative > MAX_GEOMETRY_BINDING_REL_ERROR:
            return None, "linear_dimension_not_equal_to_view_extent"
        pred_index = context["alignment"].get("role_to_pred", {}).get(role)
        if not isinstance(pred_index, int) or not 0 <= pred_index < len(context.get("pred_views", [])):
            score = 0.0
            pred_value = None
            log_error = None
        else:
            scale = float(context["alignment"].get("global_scale", 1.0))
            pred_value = float(context["pred_views"][pred_index]["size"][axis]) * scale
            log_error = abs(math.log(max(pred_value, 1e-12) / gt_value))
            score = math.exp(-log_error / 0.10)
        return {
            "id": target["spec"]["id"],
            "gt_dimension_index": target["gt_index"],
            "semantic": semantic,
            "role": role,
            "measurement": "bbox_width" if axis == 0 else "bbox_height",
            "target_actual_geometry": BASE._round(gt_value),
            "predicted_actual_geometry_aligned": BASE._round(pred_value),
            "log_error": BASE._round(log_error),
            "score": BASE._round(score),
        }, None

    if spec_family not in {"diameter", "radius"}:
        return None, f"unsupported_dimension_family:{spec_family}"
    multiplier = 2.0 if spec_family == "diameter" else 1.0
    candidates: list[tuple[str, int, float]] = []
    for family in ("circle", "arc"):
        plural = "circles" if family == "circle" else "arcs"
        for index, primitive in enumerate(target_view["entities"].get(plural, [])):
            geometry_value = multiplier * abs(float(primitive[2]))
            relative = abs(float(measurement) / max(geometry_value, 1e-12) - 1.0)
            if relative <= MAX_GEOMETRY_BINDING_REL_ERROR:
                candidates.append((family, index, geometry_value))
    if len(candidates) != 1:
        return None, "circular_geometry_binding_not_unique"
    family, target_index, geometry_value = candidates[0]
    primitive_row = row["primitive"][family]
    matched_pair = next(
        (
            pair
            for pair in primitive_row.get("pairs", [])
            if int(pair.get("target_index", -1)) == target_index
        ),
        None,
    )
    if matched_pair is None:
        score = 0.0
        log_error = None
    else:
        log_error = float(matched_pair.get("radius_log_error", 0.0))
        score = math.exp(-log_error / 0.10)
    return {
        "id": target["spec"]["id"],
        "gt_dimension_index": target["gt_index"],
        "semantic": semantic,
        "role": role,
        "measurement": f"{family}_{spec_family}",
        "target_actual_geometry": BASE._round(geometry_value),
        "matched": matched_pair is not None,
        "radius_log_error": BASE._round(log_error),
        "score": BASE._round(score),
    }, None


def _prompt_physical_component(
    context: Mapping[str, Any],
    rows: Mapping[str, Any],
    sidecar: Mapping[str, Any] | None,
) -> dict[str, Any]:
    contract, prompt = _scope_contract(sidecar, "prompt")
    if not prompt.get("physical_eligible"):
        return BASE._component(
            None,
            False,
            "prompt_physical_mask_ineligible",
            scope="prompt_masked_actual_geometry",
            contract_errors=contract.get("errors", []),
            reason_codes=prompt.get("reason_codes", []),
            reads_prediction_dimension_text=False,
        )
    mask = prompt.get("physical_mask", [])
    selected_indices = {index for index, selected in enumerate(mask) if selected}
    targets = [
        target
        for target in _dimension_targets(context, sidecar, contract)
        if target["spec_index"] in selected_indices
    ]
    fmfs_items = _fmfs_prompt_items(sidecar)
    mapped: list[dict[str, Any]] = []
    errors: list[dict[str, Any]] = []
    for target in targets:
        item = fmfs_items.get(target["gt_index"])
        if item is None:
            errors.append(
                {"gt_dimension_index": target["gt_index"], "reason": "missing_fmfs_prompt_item"}
            )
            continue
        row, error = _map_prompt_physical_item(context, rows, sidecar, target, item)
        if error:
            errors.append(
                {"gt_dimension_index": target["gt_index"], "reason": error}
            )
        elif row is not None:
            mapped.append(row)
    if not targets or errors or len(mapped) != len(targets):
        return BASE._component(
            None,
            False,
            "prompt_physical_actual_geometry_mapping_incomplete",
            scope="prompt_masked_actual_geometry",
            n_selected=len(targets),
            n_mapped=len(mapped),
            mapping_errors=errors,
            mapped_items=mapped,
            reads_prediction_dimension_text=False,
            fallback_to_full_gt_physical=False,
        )
    qualities = [float(item["score"]) for item in mapped]
    macro = float(np.mean(qualities))
    worst = min(qualities)
    score = 0.55 * macro + 0.45 * worst
    return BASE._component(
        score,
        True,
        "ok" if score >= ENGINEERING_THRESHOLDS["physical"] else "prompt_mapped_actual_geometry_mismatch",
        scope="prompt_masked_actual_geometry",
        macro=BASE._round(macro),
        worst=BASE._round(worst),
        items=mapped,
        reads_prediction_dimension_text=False,
        fallback_to_full_gt_physical=False,
        uniform_sheet_scale_invariant=True,
    )


def _full_gt_physical_component(
    context: Mapping[str, Any],
    rows: Mapping[str, Any],
    sidecar: Mapping[str, Any] | None,
) -> dict[str, Any]:
    component = RC2._physical_component(context, rows, sidecar)
    details = component.setdefault("details", {})
    details["scope"] = "offline_full_gt_actual_geometry"
    details["prompt_mask_applied"] = False
    details["reads_prediction_dimension_text"] = False
    details["uniform_sheet_scale_invariant"] = True
    details["fail_closed_for_unsupported_semantics"] = False
    return component


def _structure_component(
    context: Mapping[str, Any], frozen: Mapping[str, Any]
) -> dict[str, Any]:
    """Independent validity gate; ordinary geometry/layout errors do not enter."""

    pred_meta = context.get("pred_meta", {})
    gt_meta = context.get("gt_meta", {})
    pred_counts = pred_meta.get("entity_type_counts", {})
    gt_counts = gt_meta.get("entity_type_counts", {})
    pred_native = int(pred_meta.get("native_dimensions", 0) or 0)
    gt_native = int(gt_meta.get("native_dimensions", 0) or 0)
    pred_text_total = sum(int(pred_counts.get(name, 0) or 0) for name in ("TEXT", "MTEXT"))
    gt_text_total = sum(int(gt_counts.get(name, 0) or 0) for name in ("TEXT", "MTEXT"))
    pred_annotation_total = pred_native + pred_text_total
    gt_annotation_total = gt_native + gt_text_total
    annotation_limit = max(
        SEVERE_ANNOTATION_SPAM_ALLOWANCE,
        gt_annotation_total + SEVERE_ANNOTATION_SPAM_ALLOWANCE,
        SEVERE_ANNOTATION_SPAM_MULTIPLIER * gt_annotation_total,
    )
    severe_annotation_spam = pred_annotation_total > annotation_limit
    unsupported = int(pred_meta.get("unsupported_geometry_like", 0) or 0)
    anti_hack = frozen.get("anti_hack", {}) if isinstance(frozen, Mapping) else {}
    try:
        duplicate_ratio = float(
            anti_hack.get("true_duplicate_dimension_ratio", 0.0) or 0.0
        )
    except (TypeError, ValueError):
        duplicate_ratio = 0.0
    alignment = context.get("alignment", {})
    accounting_ok = bool(alignment.get("all_extra_clusters_accounted_for", False))
    readable = bool(pred_meta.get("readable"))
    nondegenerate = bool(context.get("prediction_valid"))
    valid = bool(
        readable
        and nondegenerate
        and accounting_ok
        and unsupported == 0
        and duplicate_ratio < 0.50
        and not severe_annotation_spam
    )
    flags = [
        name
        for name, active in (
            ("unreadable_or_degenerate", not (readable and nondegenerate)),
            ("extra_cluster_accounting_incomplete", not accounting_ok),
            ("unsupported_geometry_like", unsupported > 0),
            ("true_duplicate_dimension_spam", duplicate_ratio >= 0.50),
            ("severe_dimension_or_text_spam", severe_annotation_spam),
        )
        if active
    ]
    return BASE._component(
        1.0 if valid else 0.0,
        True,
        "ok" if valid else "independent_validity_or_anti_hack_gate_failed",
        gate_only=True,
        flags=flags,
        readable=readable,
        nondegenerate=nondegenerate,
        all_extra_clusters_accounted_for=accounting_ok,
        unsupported_geometry_like=unsupported,
        true_duplicate_dimension_ratio=BASE._round(duplicate_ratio),
        predicted_native_dimensions=pred_native,
        predicted_text_mtext=pred_text_total,
        predicted_dimension_like_text=int(pred_meta.get("dimension_like_text", 0) or 0),
        target_annotation_inventory=gt_annotation_total,
        predicted_annotation_inventory=pred_annotation_total,
        severe_annotation_spam_limit=annotation_limit,
        positive_continuous_reward=False,
        reads_geometry_or_layout_quality=False,
    )


def _scoped_hierarchical_reward(
    components: Mapping[str, Mapping[str, Any]],
    atomic: Mapping[str, Any],
    *,
    scope: str,
) -> dict[str, Any]:
    """Renormalise absent optional stages instead of silently substituting them."""

    def eligible_score(name: str) -> float | None:
        row = components[name]
        value = row.get("score")
        if row.get("eligible") and isinstance(value, (int, float)):
            return float(value)
        return None

    structure = eligible_score("structure")
    view = eligible_score("view")
    geometry = eligible_score("geometry")
    if structure is None or view is None or geometry is None:
        return {
            "score": None,
            "eligible": False,
            "scope": scope,
            "reason": "required_reward_stage_ineligible",
        }
    topology = float(atomic.get("topology_score", 0.0))
    layout = eligible_score("layout")
    physical = eligible_score("physical")
    annotation = eligible_score("annotation")
    view_topology_gate = BASE._harmonic(view, topology)
    geometry_gate = BASE._harmonic(view_topology_gate, geometry)
    stages: dict[str, float] = {
        "view_topology": view_topology_gate
        * (0.70 + 0.30 * layout if layout is not None else 1.0),
        "geometry": view_topology_gate * geometry,
    }
    weights = {"view_topology": 0.35, "geometry": 0.30}
    upstream = geometry_gate
    if physical is not None:
        stages["physical"] = geometry_gate * physical
        weights["physical"] = 0.20
        upstream = BASE._harmonic(geometry_gate, physical)
    if annotation is not None:
        stages["annotation"] = upstream * annotation
        weights["annotation"] = 0.15
    active_weight = sum(weights.values())
    reward = structure * sum(weights[name] * stages[name] for name in weights) / active_weight
    excluded = [
        name
        for name in ("layout", "physical", "annotation")
        if eligible_score(name) is None
    ]
    return {
        "score": BASE._round(reward),
        "eligible": True,
        "scope": scope,
        "reason": "ok",
        "structure_gate": BASE._round(structure),
        "view_topology_gate": BASE._round(view_topology_gate),
        "geometry_gate": BASE._round(geometry_gate),
        "stages": {name: BASE._round(value) for name, value in stages.items()},
        "active_weights": {name: BASE._round(value / active_weight) for name, value in weights.items()},
        "excluded_ineligible_components": excluded,
        "ineligible_components_are_not_substituted": True,
    }


def _benchmark(components: Mapping[str, Mapping[str, Any]]) -> dict[str, Any]:
    states: dict[str, bool | None] = {}
    for name, threshold in ENGINEERING_THRESHOLDS.items():
        row = components[name]
        value = row.get("score")
        states[f"{name}_pass"] = (
            bool(float(value) >= threshold)
            if row.get("eligible") and isinstance(value, (int, float))
            else None
        )
    evaluable = all(value is not None for value in states.values())
    success = all(bool(value) for value in states.values()) if evaluable else None
    return {
        **states,
        "fully_evaluable": evaluable,
        "engineering_success": success,
        "cad_pass": success,
        "thresholds": dict(ENGINEERING_THRESHOLDS),
        "scope": "offline_full_gt_executed_dxf",
        "uniform_sheet_scale_invariant": True,
    }


def _matching_diagnostics(context: Mapping[str, Any]) -> dict[str, Any]:
    excluded = {
        "raw_pred",
        "raw_gt",
        "canonical_pred",
        "canonical_gt",
        "pred_views",
        "pred_views_all",
        "gt_by_role",
    }
    return {
        key: copy.deepcopy(value)
        for key, value in context.items()
        if key not in excluded
    }


def score_dxf_pair(
    pred: str | Path,
    gt: str | Path,
    sidecar: Mapping[str, Any] | None = None,
    category: str | None = None,
    **_kwargs: Any,
) -> dict[str, Any]:
    """Score one executed prediction under explicit full-GT and prompt scopes."""

    frozen = BASE.EV51.score_dxf_pair(pred, gt, sidecar=sidecar, category=category)
    context = _consume_appended_omitted_marker(
        MATCH.build_pair_context(pred, gt, sidecar=sidecar)
    )
    result: dict[str, Any] = {
        "schema_version": SCHEMA_VERSION,
        "metric_version": METRIC_VERSION,
        "category": category,
        "metric_definition": {
            "uniform_sheet_scale_invariant": True,
            "absolute_dxf_plotting_scale_required": False,
            "grpo_connected": False,
        },
        "anti_hack": copy.deepcopy(frozen.get("anti_hack", {})),
        "diagnostics": {
            "v51_frozen": {
                "metric_version": frozen.get("metric_version"),
                "components": copy.deepcopy(frozen.get("components", {})),
                "benchmark": copy.deepcopy(frozen.get("benchmark", {})),
                "anti_hack": copy.deepcopy(frozen.get("anti_hack", {})),
            },
            "matching": _matching_diagnostics(context),
        },
    }
    names = ("view", "geometry", "physical", "annotation", "layout", "structure")
    if not context.get("eligible"):
        components = {
            name: BASE._component(None, False, str(context.get("reason")))
            for name in names
        }
        result["components"] = components
        result["verified_reward_full_gt"] = {
            "score": None,
            "eligible": False,
            "scope": "offline_full_gt_executed_dxf",
            "reason": "target_ineligible",
        }
        result["online_reward_prompt_masked"] = {
            "score": None,
            "eligible": False,
            "scope": "prompt_masked_actual_geometry",
            "reason": "target_ineligible",
            "components": components,
        }
        result["benchmark"] = _benchmark(components)
        result["engineering_success"] = None
        return result
    if not context.get("prediction_valid"):
        components = BASE._zero_components("prediction_dxf_unreadable_or_degenerate")
        full_reward = _scoped_hierarchical_reward(
            components, {"topology_score": 0.0}, scope="offline_full_gt_executed_dxf"
        )
        prompt_reward = _scoped_hierarchical_reward(
            components, {"topology_score": 0.0}, scope="prompt_masked_actual_geometry"
        )
        result["components"] = components
        result["verified_reward_full_gt"] = full_reward
        result["online_reward_prompt_masked"] = {
            **prompt_reward,
            "components": components,
        }
        result["benchmark"] = _benchmark(components)
        result["engineering_success"] = result["benchmark"]["engineering_success"]
        return result

    rows, curve = BASE._semantic_rows(context)
    view = BASE._view_component(context, rows)
    layout = _layout_component(context, rows)
    geometry, atomic = BASE._geometry_component(context, rows, curve)
    full_physical = _full_gt_physical_component(context, rows, sidecar)
    full_annotation = _annotation_component(context, sidecar, scope="full_gt")
    prompt_physical = _prompt_physical_component(context, rows, sidecar)
    prompt_annotation = _annotation_component(context, sidecar, scope="prompt")
    structure = _structure_component(context, frozen)
    components = {
        "view": view,
        "geometry": geometry,
        "physical": full_physical,
        "annotation": full_annotation,
        "layout": layout,
        "structure": structure,
    }
    prompt_components = {
        "view": copy.deepcopy(view),
        "geometry": copy.deepcopy(geometry),
        "physical": prompt_physical,
        "annotation": prompt_annotation,
        "layout": copy.deepcopy(layout),
        "structure": copy.deepcopy(structure),
    }
    full_reward = _scoped_hierarchical_reward(
        components, atomic, scope="offline_full_gt_executed_dxf"
    )
    prompt_reward = _scoped_hierarchical_reward(
        prompt_components, atomic, scope="prompt_masked_actual_geometry"
    )
    benchmark = _benchmark(components)
    result.update(
        {
            "components": components,
            "verified_reward_full_gt": full_reward,
            "online_reward_prompt_masked": {
                **prompt_reward,
                "components": prompt_components,
            },
            "benchmark": benchmark,
            "engineering_success": benchmark["engineering_success"],
        }
    )
    result["diagnostics"].update(
        {
            "semantic_views": rows,
            "curve_geometry": curve,
            "atomic_geometry": {
                key: copy.deepcopy(value)
                for key, value in atomic.items()
                if key != "curve"
            },
            "curve_summary": atomic.get("curve"),
            "release_status": {
                "grpo_connected": False,
                "candidate": METRIC_VERSION,
                "reason": "counterfactual_and_real_generation_acceptance_required",
            },
        }
    )
    return result


__all__ = [
    "ENGINEERING_THRESHOLDS",
    "METRIC_VERSION",
    "PHYSICAL_SUPPORTED_SEMANTICS",
    "SCHEMA_VERSION",
    "score_dxf_pair",
]