"""Deterministic causal football simulation for FTG Match Engine v3.

Unlike historical engines that sampled goals first and projected analytics later,
v3 simulates attacking possessions, pass chains, chance creation and shots. Goals
are therefore a consequence of authoritative shot outcomes. The same causal facts
feed xG, assists, keeper saves, player ratings and live checkpoint statistics.
"""
from __future__ import annotations

from collections import Counter, defaultdict
from dataclasses import replace
from typing import Any

from ..state import MatchState, SimulationResult, EngineStateError, PlayerState
from ..v1.engine import MatchEvaluation
from ..v2.engine import FTGMatchEngineV2, _domain_rng, _rating, _weighted_choice
from ..v2.contracts import (
    SportingResolutionV2,
    RESOLUTION_EXTRA_TIME,
    RESOLUTION_PENALTIES,
    RESOLUTION_REGULATION,
)
from ..reporting.v2 import (
    EVENT_GOAL,
    EVENT_INJURY,
    EVENT_PENALTY_MISSED,
    EVENT_PENALTY_SCORED,
    EVENT_RED,
    EVENT_SECOND_YELLOW,
    EVENT_SUBSTITUTION,
    EVENT_YELLOW,
    PHASE_EXTRA_TIME,
    PHASE_REGULATION,
    PHASE_SHOOTOUT,
    PlayerMatchStatisticsV2,
    ReportEventV2,
    TeamMatchStatisticsV2,
)
from ..reporting.v22 import TacticalDecisionV22
from ..reporting.v3 import MatchReportV3
from ..v21.policy import next_transition, opponent_defence_suppression, segment_multiplier
from ..v22.engine import FTGMatchEngineV22
from ..v22.commands import LiveCommandState, COMMAND_TACTICS
from ..v22.config import EXTRA_TIME_SEGMENTS, REGULATION_SEGMENTS
from .config import (
    ANALYTICS_POLICY_KEY,
    ANALYTICS_POLICY_VERSION,
    ANALYTICS_SCHEMA_VERSION,
    ATTACK_CHANCE_BONUS,
    ATTACK_POSSESSION_BONUS,
    ATTACK_SHOT_QUALITY,
    ATTACK_WORKLOAD,
    BASE_CHANCE_PROBABILITY,
    BIG_CHANCE_XG,
    DEFENCE_BLOCK_BONUS,
    DEFENCE_CHANCE_SUPPRESSION,
    DEFENCE_WORKLOAD,
    ENGINE_KEY,
    ENGINE_VERSION,
    EXTRA_TIME_POSSESSIONS_PER_SEGMENT,
    HOME_CHANCE_BONUS,
    MAX_CHANCE_PROBABILITY,
    MAX_GOAL_PROBABILITY,
    MAX_POSSESSION_SHARE,
    MAX_XG,
    MIN_CHANCE_PROBABILITY,
    MIN_GOAL_PROBABILITY,
    MIN_POSSESSION_SHARE,
    MIN_XG,
    REGULATION_POSSESSIONS_PER_SEGMENT,
)
from .contracts import MatchV3Outcome
from .evaluator import evaluate_team_v31
from ..roles import execution_fit, familiarity_from_map, role_behaviour, slot_family, resolve_tactical_role
from ..environment import MatchEnvironmentState, effects_for_environment
from ..possession import CHANNELS, PASS_TYPES, TransitionContext, is_progressive, zone_distance, zone_index
from ..pressing import compactness_pass_delta, shape_for_strategy, zone_press_factor

DOMAIN_SEGMENT = 0x6A09E667F3BCC909
DOMAIN_SHOOTOUT_REPORT = 0xBB67AE8584CAA73B
DOMAIN_SHOOTOUT_V32 = 0x3C6EF372FE94F82B
DOMAIN_ENVIRONMENT_INJURY = 0xA54FF53A5F1D36F1
DOMAIN_MEDICAL_BASELINE = 0x510E527FADE682D1
DOMAIN_MEDICAL_CONTACT = 0x9B05688C2B3E6C1F


def _clamp(value: float, low: float, high: float) -> float:
    return max(low, min(high, value))


def _phase(minute: int) -> str:
    return PHASE_REGULATION if minute <= 90 else PHASE_EXTRA_TIME


def _avg(players, attr: str, default=50) -> float:
    players = list(players)
    if not players:
        return float(default)
    return sum(_rating(player, attr, default) for player in players) / len(players)


class FTGMatchEngineV3(FTGMatchEngineV22):
    key = ENGINE_KEY
    version = ENGINE_VERSION

    def simulate(
        self,
        state: MatchState,
        *,
        seed: int,
        commands: tuple[LiveCommandState, ...] | list[LiveCommandState] = (),
    ) -> MatchV3Outcome:
        if isinstance(seed, bool) or not isinstance(seed, int) or seed < 1:
            raise ValueError("seed must be a positive integer.")
        if state.schema_version < 3:
            raise ValueError("Match Engine v3 requires a schema-v3 tactical snapshot.")
        commands = tuple(sorted(commands, key=lambda row: row.sequence))
        self._validate_commands(state=state, commands=commands)
        environment_effects = effects_for_environment(state.environment)
        # Runtime cache is refreshed on every simulation call. It keeps the many
        # low-level rating helpers environment-aware without polluting historical
        # engine contracts with dozens of extra parameters.
        self._runtime_environment = state.environment
        self._runtime_environment_effects = environment_effects

        rules = state.rules
        evaluation = MatchEvaluation(
            home=evaluate_team_v31(state.home),
            away=evaluate_team_v31(state.away),
            home_expected_goals=0.0,
            away_expected_goals=0.0,
        )
        base_engine = FTGMatchEngineV2()

        # Reuse the proven score-independent card/injury/substitution generator.
        zero_resolution = SportingResolutionV2(0, 0)
        zero_result = SimulationResult(home_score=0, away_score=0)
        skeleton = base_engine._build_report(
            state=state,
            result=zero_result,
            resolution=zero_resolution,
            seed=seed,
            max_substitutions=rules.max_substitutions,
            max_substitution_windows=rules.max_substitution_windows,
        )
        non_goal_events = list(self._merge_non_goal_timeline(
            state=state,
            base_events=skeleton.events,
            commands=commands,
            max_substitutions=rules.max_substitutions,
            max_substitution_windows=rules.max_substitution_windows,
        ))
        # Cards and injuries are now caused by authoritative match mechanics rather
        # than sampled independently by the legacy skeleton. Strategic substitutions
        # remain score-independent and are retained.
        non_goal_events = [
            row for row in non_goal_events
            if row.event_type not in {EVENT_YELLOW, EVENT_SECOND_YELLOW, EVENT_RED, EVENT_INJURY}
        ]

        tactical_commands = {
            segment: [
                row
                for row in commands
                if row.command_type == COMMAND_TACTICS and row.effective_segment == segment
            ]
            for segment in range(1, 9)
        }
        current = {
            state.home.club_id: [
                state.home_tactics.attacking_strategy,
                state.home_tactics.defensive_strategy,
            ],
            state.away.club_id: [
                state.away_tactics.attacking_strategy,
                state.away_tactics.defensive_strategy,
            ],
        }
        applied = {state.home.club_id: set(), state.away.club_id: set()}
        decisions: list[dict[str, Any]] = []

        # Causal ledgers accumulated during field play.
        shots: list[dict[str, Any]] = []
        set_piece_events: list[dict[str, Any]] = []
        referee_events: list[dict[str, Any]] = []
        medical_events: list[dict[str, Any]] = []
        defensive_events: list[dict[str, Any]] = []
        possession_events: list[dict[str, Any]] = []
        pressing_events: list[dict[str, Any]] = []
        pass_events: list[dict[str, Any]] = []
        possession_records: list[dict[str, Any]] = []
        pass_network_edges: Counter = Counter()
        transition_context = {
            state.home.club_id: TransitionContext(),
            state.away.club_id: TransitionContext(),
        }
        goal_events: list[tuple[int, str, str, str | None, dict[str, Any]]] = []
        player_metrics: dict[str, Counter] = defaultdict(Counter)
        team_metrics: dict[str, Counter] = {
            state.home.club_id: Counter(),
            state.away.club_id: Counter(),
        }
        possession_units = Counter()
        medical_penalties: dict[str, list[tuple[int, float]]] = defaultdict(list)
        scheduled_medical_incidents: list[dict[str, Any]] = []
        segment_statistics: list[dict[str, Any]] = []
        score = {state.home.club_id: 0, state.away.club_id: 0}

        teams = {state.home.club_id: state.home, state.away.club_id: state.away}
        medical_contexts = {
            state.home.club_id: state.home_medical,
            state.away.club_id: state.away_medical,
        }
        self._runtime_medical_penalties = medical_penalties
        opponent = {
            state.home.club_id: state.away.club_id,
            state.away.club_id: state.home.club_id,
        }

        def record_shot(*, attacking_club, defending_club, shooter, creator, xg, outcome, goalkeeper, minute, chance_type, set_piece_type=None, routine=None, delivery_player_id=None, metadata=None):
            metadata = dict(metadata or {})
            if outcome == "GOAL" and not metadata.get("var_reviewed"):
                if not goal_var_allows(
                    attacking_club=attacking_club, defending_club=defending_club,
                    minute=minute, scorer=shooter,
                    latent_offside=bool(metadata.get("latent_offside")),
                    marginal=bool(metadata.get("offside_marginal")),
                ):
                    return None
                metadata["var_reviewed"] = True
            shot = {
                "minute": minute,
                "phase": _phase(minute),
                "club_id": attacking_club,
                "player_id": shooter.player_id,
                "assisted_by_player_id": creator.player_id if creator else None,
                "xg": round(float(xg), 3),
                "outcome": outcome,
                "chance_type": chance_type,
                "set_piece_type": set_piece_type,
                "routine": routine,
                "delivery_player_id": delivery_player_id,
            }
            if metadata:
                shot.update(metadata)
            shots.append(shot)
            player_metrics[shooter.player_id]["shots"] += 1
            player_metrics[shooter.player_id]["xg_milli"] += int(round(float(xg) * 1000))
            if xg >= BIG_CHANCE_XG:
                player_metrics[shooter.player_id]["big_chances"] += 1
            if outcome in {"GOAL", "SAVED"}:
                player_metrics[shooter.player_id]["shots_on_target"] += 1
            if creator is not None:
                player_metrics[creator.player_id]["key_passes"] += 1
                player_metrics[creator.player_id]["xa_milli"] += int(round(float(xg) * 1000))
            if set_piece_type:
                player_metrics[shooter.player_id]["set_piece_shots"] += 1
                team_metrics[attacking_club]["set_piece_shots"] += 1
            if outcome == "SAVED" and goalkeeper is not None:
                player_metrics[goalkeeper.player_id]["saves"] += 1
                keeper_action, keeper_outcome = self._goalkeeper_save_action(
                    goalkeeper=goalkeeper, shooter=shooter, xg=float(xg), minute=minute,
                    chance_type=chance_type, rng=_domain_rng(seed, DOMAIN_SEGMENT ^ minute ^ len(shots) ^ 0x51A5),
                )
                shot["goalkeeper_action"] = keeper_action
                shot["goalkeeper_player_id"] = goalkeeper.player_id
                shot["save_outcome"] = keeper_outcome
                if keeper_action == "ONE_ON_ONE_SAVE":
                    player_metrics[goalkeeper.player_id]["one_on_one_saves"] += 1
                if keeper_action in {"PARRY", "TIP_OVER", "REFLEX_SAVE"}:
                    player_metrics[goalkeeper.player_id]["parries"] += 1
                if keeper_action == "CATCH":
                    player_metrics[goalkeeper.player_id]["catches"] += 1
                elif keeper_action == "CLAIM":
                    player_metrics[goalkeeper.player_id]["claims"] += 1
                record_defensive_event(
                    minute=minute, event_type=("ONE_ON_ONE_SAVE" if keeper_action == "ONE_ON_ONE_SAVE" else ("KEEPER_PARRY" if keeper_action in {"PARRY", "TIP_OVER", "REFLEX_SAVE"} else "KEEPER_SAVE")),
                    defending_club=defending_club, attacking_club=attacking_club,
                    player_id=goalkeeper.player_id, opponent_player_id=shooter.player_id,
                    outcome=keeper_outcome, zone="BOX",
                    detail={"action": keeper_action, "xg": round(float(xg), 3), "chance_type": chance_type},
                )
            elif outcome == "BLOCKED":
                defender = _weighted_choice(
                    _domain_rng(seed, DOMAIN_SEGMENT ^ minute ^ len(shots)),
                    [p for p in self._active_players_for_team(team=teams[defending_club], events=non_goal_events, minute=minute, club_id=defending_club) if not self._is_goalkeeper(p)] or self._active_players_for_team(team=teams[defending_club], events=non_goal_events, minute=minute, club_id=defending_club),
                    lambda p: max(1.0, self._defender_action_weight(p, minute=minute, defensive_strategy=current[defending_club][1], attacking_strategy=current[defending_club][0])),
                )
                player_metrics[defender.player_id]["blocks"] += 1
                team_metrics[defending_club]["blocks"] += 1
                shot["blocker_player_id"] = defender.player_id
                record_defensive_event(
                    minute=minute, event_type="BLOCK", defending_club=defending_club,
                    attacking_club=attacking_club, player_id=defender.player_id,
                    opponent_player_id=shooter.player_id, outcome="WON", zone="BOX",
                    detail={"xg": round(float(xg), 3), "chance_type": chance_type},
                )
            elif outcome == "GOAL":
                score[attacking_club] += 1
                player_metrics[shooter.player_id]["goals"] += 1
                if creator is not None:
                    player_metrics[creator.player_id]["assists"] += 1
                if set_piece_type:
                    team_metrics[attacking_club]["set_piece_goals"] += 1
                goal_events.append((
                    minute, attacking_club, shooter.player_id, creator.player_id if creator else None,
                    {
                        "xg": round(float(xg), 3),
                        "assist_player_id": creator.player_id if creator else None,
                        "chance_type": chance_type,
                        "set_piece_type": set_piece_type,
                        "routine": routine,
                        **(metadata or {}),
                    },
                ))
            return shot

        rng_holder = {"rng": None}

        def preferred_player(active_players, preferred_id, weight):
            if preferred_id:
                preferred = next((p for p in active_players if p.player_id == preferred_id), None)
                if preferred is not None:
                    return preferred
            return _weighted_choice(rng_holder["rng"], active_players, weight)

        def record_referee_event(*, minute, event_type, club_id, opponent_club_id=None,
                                 player_id=None, offender_player_id=None, initial_decision="",
                                 final_decision="", review_type="", var_used=False,
                                 overturned=False, advantage_played=False, marginal=False,
                                 detail=None):
            row = {
                "_ordinal": len(referee_events) + 1,
                "minute": int(minute),
                "phase": _phase(int(minute)),
                "type": str(event_type),
                "club_id": str(club_id),
                "opponent_club_id": str(opponent_club_id) if opponent_club_id else None,
                "player_id": str(player_id) if player_id else None,
                "offender_player_id": str(offender_player_id) if offender_player_id else None,
                "initial_decision": str(initial_decision),
                "final_decision": str(final_decision),
                "review_type": str(review_type),
                "var_used": bool(var_used),
                "overturned": bool(overturned),
                "advantage_played": bool(advantage_played),
                "marginal": bool(marginal),
                "detail": dict(detail or {}),
            }
            referee_events.append(row)
            return row

        def record_medical_event(*, minute, event_type, club_id, player_id, cause="",
                                 body_region="", severity="", suspected_concussion=False,
                                 final_decision="", treatment="", stoppage_seconds=0,
                                 expected_recovery_days=0, extra_substitution=False, detail=None):
            row = {
                "_ordinal": len(medical_events) + 1,
                "minute": int(minute),
                "phase": _phase(int(minute)),
                "type": str(event_type),
                "club_id": str(club_id),
                "player_id": str(player_id),
                "cause": str(cause),
                "body_region": str(body_region),
                "severity": str(severity),
                "suspected_concussion": bool(suspected_concussion),
                "final_decision": str(final_decision),
                "treatment": str(treatment),
                "stoppage_seconds": int(max(0, stoppage_seconds)),
                "expected_recovery_days": int(max(0, expected_recovery_days)),
                "extra_substitution": bool(extra_substitution),
                "detail": dict(detail or {}),
            }
            medical_events.append(row)
            if event_type == "ASSESSMENT":
                player_metrics[str(player_id)]["medical_assessments"] += 1
                team_metrics[str(club_id)]["medical_stoppages"] += 1
            return row

        def record_defensive_event(*, minute, event_type, defending_club, attacking_club,
                                   player_id=None, opponent_player_id=None, outcome="", zone="",
                                   detail=None):
            row = {
                "_ordinal": len(defensive_events) + 1,
                "minute": int(minute),
                "phase": _phase(int(minute)),
                "type": str(event_type),
                "defending_club_id": str(defending_club),
                "attacking_club_id": str(attacking_club),
                "player_id": str(player_id) if player_id else None,
                "opponent_player_id": str(opponent_player_id) if opponent_player_id else None,
                "outcome": str(outcome),
                "zone": str(zone),
                "detail": dict(detail or {}),
            }
            defensive_events.append(row)
            team_metrics[str(defending_club)]["defensive_actions"] += 1
            return row

        def record_possession_event(*, minute, possession_sequence, action_sequence, event_type,
                                    club_id, opponent_club_id, player_id=None, target_player_id=None,
                                    origin_zone="", destination_zone="", channel="CENTRE", outcome="",
                                    transition_state="SETTLED", detail=None):
            row = {
                "_ordinal": len(possession_events) + 1,
                "minute": int(minute),
                "phase": _phase(int(minute)),
                "possession_sequence": int(possession_sequence),
                "action_sequence": int(action_sequence),
                "type": str(event_type),
                "club_id": str(club_id),
                "opponent_club_id": str(opponent_club_id),
                "player_id": str(player_id) if player_id else None,
                "target_player_id": str(target_player_id) if target_player_id else None,
                "origin_zone": str(origin_zone),
                "destination_zone": str(destination_zone),
                "channel": str(channel),
                "outcome": str(outcome),
                "transition_state": str(transition_state),
                "detail": dict(detail or {}),
            }
            possession_events.append(row)
            return row

        def record_pressing_event(*, minute, event_type, pressing_club, opponent_club,
                                  possession_sequence, player_id=None, target_player_id=None,
                                  zone="MIDDLE_THIRD", channel="CENTRE", defensive_strategy="BALANCED",
                                  trigger="", outcome="", detail=None):
            profile = shape_for_strategy(defensive_strategy)
            row = {
                "_ordinal": len(pressing_events) + 1,
                "minute": int(minute),
                "phase": _phase(int(minute)),
                "type": str(event_type),
                "pressing_club_id": str(pressing_club),
                "opponent_club_id": str(opponent_club),
                "possession_sequence": int(possession_sequence),
                "player_id": str(player_id) if player_id else None,
                "target_player_id": str(target_player_id) if target_player_id else None,
                "zone": str(zone),
                "channel": str(channel),
                "defensive_strategy": str(defensive_strategy),
                "trigger": str(trigger),
                "line_height": int(profile.line_height),
                "compactness": int(profile.compactness),
                "width": int(profile.width),
                "press_intensity": round(float(profile.press_intensity), 3),
                "outcome": str(outcome),
                "detail": dict(detail or {}),
            }
            pressing_events.append(row)
            return row

        def attempt_counterpress(*, losing_club, winning_club, minute, zone, channel,
                                 losing_players, winning_player, defensive_strategy,
                                 attacking_strategy, possession_sequence):
            profile = shape_for_strategy(defensive_strategy)
            press_score = self._pressing_team_score(
                losing_players, minute=minute, defensive_strategy=defensive_strategy,
                attacking_strategy=attacking_strategy,
            )
            zone_factor = {
                "DEFENSIVE_THIRD": 0.62, "MIDDLE_THIRD": 0.96,
                "FINAL_THIRD": 1.18, "PENALTY_AREA": 1.12,
            }.get(zone, 1.0)
            trigger_probability = _clamp(
                0.10 + profile.counterpress_intensity * 0.48 * zone_factor
                + (press_score - 55.0) * 0.0022, 0.08, 0.72,
            )
            if rng_holder["rng"].random() > trigger_probability:
                return False, None
            pressers = [p for p in losing_players if not self._is_goalkeeper(p)] or list(losing_players)
            presser = _weighted_choice(
                rng_holder["rng"], pressers,
                lambda p: self._pressing_player_weight(
                    p, minute=minute, defensive_strategy=defensive_strategy,
                    attacking_strategy=attacking_strategy,
                ),
            )
            player_metrics[presser.player_id]["counterpresses"] += 1
            team_metrics[losing_club]["counterpresses"] += 1
            record_pressing_event(
                minute=minute, event_type="COUNTER_PRESS", pressing_club=losing_club,
                opponent_club=winning_club, possession_sequence=possession_sequence,
                player_id=presser.player_id, target_player_id=winning_player.player_id,
                zone=zone, channel=channel, defensive_strategy=defensive_strategy,
                trigger="TURNOVER", outcome="ENGAGED",
                detail={"trigger_probability": round(trigger_probability, 3)},
            )
            winner_control = (
                self._effective_rating(winning_player, "ball_control", minute=minute, attacking_strategy="BALANCED", defensive_strategy="BALANCED")
                + self._effective_rating(winning_player, "composure", minute=minute, attacking_strategy="BALANCED", defensive_strategy="BALANCED")
            ) / 2.0
            recovery_probability = _clamp(
                0.21 + profile.counterpress_intensity * 0.31
                + (self._pressing_player_weight(presser, minute=minute, defensive_strategy=defensive_strategy, attacking_strategy=attacking_strategy) - winner_control) * 0.0024,
                0.14, 0.67,
            )
            if rng_holder["rng"].random() <= recovery_probability:
                player_metrics[presser.player_id]["counterpress_recoveries"] += 1
                player_metrics[presser.player_id]["recoveries"] += 1
                team_metrics[losing_club]["counterpress_recoveries"] += 1
                # A successful counter-press is an authoritative ball recovery even when
                # the same possession chain is retained as SECOND_BALL. Keep team and
                # player recovery totals sourced from the same causal event.
                team_metrics[losing_club]["turnovers_won"] += 1
                record_pressing_event(
                    minute=minute, event_type="COUNTER_PRESS_RECOVERY", pressing_club=losing_club,
                    opponent_club=winning_club, possession_sequence=possession_sequence,
                    player_id=presser.player_id, target_player_id=winning_player.player_id,
                    zone=zone, channel=channel, defensive_strategy=defensive_strategy,
                    trigger="TURNOVER", outcome="RECOVERED",
                    detail={"recovery_probability": round(recovery_probability, 3)},
                )
                return True, presser
            team_metrics[losing_club]["counterpress_bypassed"] += 1
            record_pressing_event(
                minute=minute, event_type="COUNTER_PRESS_BYPASSED", pressing_club=losing_club,
                opponent_club=winning_club, possession_sequence=possession_sequence,
                player_id=presser.player_id, target_player_id=winning_player.player_id,
                zone=zone, channel=channel, defensive_strategy=defensive_strategy,
                trigger="TURNOVER", outcome="BYPASSED",
                detail={"recovery_probability": round(recovery_probability, 3)},
            )
            return True, None

        def substitution_usage(club_id, minute):
            standard = 0
            standard_windows = set()
            concussion_extra = 0
            used_in = set()
            for row in non_goal_events:
                if row.club_id != club_id or row.event_type != EVENT_SUBSTITUTION or row.minute > minute:
                    continue
                payload = row.detail_payload
                used_in.add(row.secondary_player_id)
                if payload.get("concussion_extra"):
                    concussion_extra += 1
                else:
                    standard += 1
                    standard_windows.add(row.minute)
            return standard, standard_windows, concussion_extra, used_in

        def choose_medical_replacement(*, team, outgoing, used_in):
            candidates = [p for p in team.substitutes if p.player_id not in used_in]
            if not candidates:
                return None
            target_slot = outgoing.lineup_slot
            return max(
                candidates,
                key=lambda p: (
                    familiarity_from_map(
                        p.natural_position, p.position_familiarities, target_slot
                    ) * 0.60
                    + _rating(p, "overall") * 0.40,
                    _rating(p, "overall"),
                    p.player_id,
                ),
            )

        def append_injury_event(*, club_id, player, minute, injury_code, severity, cause,
                                body_region, recovery_days, available, incident_ref, concussion=False):
            detail = {
                "injury_code": injury_code,
                "expected_recovery_days": int(recovery_days),
                "training_restriction": "LIMITED" if available else "PROHIBITED",
                "match_availability": "AVAILABLE" if available else "UNAVAILABLE",
                "medical_incident_ref": incident_ref,
                "severity": severity,
                "cause": cause,
                "body_region": body_region,
                "concussion": bool(concussion),
            }
            event = ReportEventV2(
                sequence=max(1, len(non_goal_events) + 1),
                minute=int(minute), phase=_phase(int(minute)), event_type=EVENT_INJURY,
                club_id=club_id, player_id=player.player_id, detail=tuple(sorted(detail.items())),
            )
            non_goal_events.append(event)
            return event

        def force_medical_substitution(*, club_id, player, minute, reason, concussion=False):
            team = teams[club_id]
            standard, windows, concussion_extra, used_in = substitution_usage(club_id, minute)
            incoming = choose_medical_replacement(team=team, outgoing=player, used_in=used_in)
            if incoming is None:
                return None, False
            extra_allowed = (
                concussion
                and rules.medical.concussion_substitution_enabled
                and concussion_extra < rules.medical.max_concussion_substitutions
            )
            standard_allowed = (
                standard < rules.max_substitutions
                and (minute in windows or len(windows) < rules.max_substitution_windows)
            )
            if not (extra_allowed or standard_allowed):
                return None, False
            detail = {
                "reason": reason,
                "medical": True,
                "concussion_extra": bool(extra_allowed),
                "outgoing_slot": player.lineup_slot,
                "outgoing_tactical_role": player.tactical_role,
            }
            event = ReportEventV2(
                sequence=max(1, len(non_goal_events) + 1), minute=int(minute),
                phase=_phase(int(minute)), event_type=EVENT_SUBSTITUTION,
                club_id=club_id, player_id=player.player_id,
                secondary_player_id=incoming.player_id, detail=tuple(sorted(detail.items())),
            )
            non_goal_events.append(event)
            team_metrics[club_id]["forced_medical_substitutions"] += 1
            if extra_allowed:
                team_metrics[club_id]["concussion_substitutions"] += 1
            return incoming, bool(extra_allowed)

        def resolve_medical_incident(*, club_id, player, minute, cause, incident_rng, impact=0.45, contact=False):
            if not rules.medical.medical_stoppages_enabled:
                return {"stop_play": False, "removed": False}
            context = medical_contexts[club_id]
            effects = environment_effects
            fatigue = self._fatigue_load(
                player, minute, current[club_id][0], current[club_id][1]
            )
            protection = (
                _rating(player, "natural_fitness") * 0.35
                + _rating(player, "balance") * 0.25
                + _rating(player, "strength") * 0.20
                + _rating(player, "agility") * 0.20
            )
            body_regions = ("ANKLE", "KNEE", "HAMSTRING", "CALF", "FOOT", "SHOULDER")
            body_region = body_regions[int(incident_rng.random() * len(body_regions)) % len(body_regions)]
            head_probability = 0.0
            if contact and rules.medical.concussion_protocol_enabled:
                head_probability = _clamp(0.045 + impact * 0.12, 0.025, 0.20)
            actual_concussion = incident_rng.random() < head_probability
            ambiguous_head_flag = _clamp(
                0.016 + context.concussion_recognition * 0.00018, 0.018, 0.036
            )
            false_suspicion = (
                not actual_concussion
                and contact
                and rules.medical.concussion_protocol_enabled
                and incident_rng.random() < ambiguous_head_flag
            )
            suspected_concussion = actual_concussion or false_suspicion
            if suspected_concussion:
                body_region = "HEAD"

            incident_ref = f"MED-{len(medical_events) + 1:04d}"
            record_medical_event(
                minute=minute, event_type="INCIDENT", club_id=club_id, player_id=player.player_id,
                cause=cause, body_region=body_region, severity="PENDING",
                suspected_concussion=suspected_concussion, final_decision="ASSESS",
                detail={"incident_ref": incident_ref, "impact": round(float(impact), 3)},
            )

            assessment_seconds = int(_clamp(
                80 + impact * 120 + (100 - context.assessment_quality) * 1.2
                + ((100 - context.concussion_recognition) * 0.25 if suspected_concussion else 0),
                60, rules.medical.max_assessment_seconds,
            ))
            if suspected_concussion:
                record_medical_event(
                    minute=minute, event_type="ASSESSMENT", club_id=club_id, player_id=player.player_id,
                    cause=cause, body_region="HEAD", severity="CONCUSSION_CHECK",
                    suspected_concussion=True, final_decision="CONCUSSION_CHECK",
                    treatment="NEUROLOGICAL_ASSESSMENT", stoppage_seconds=assessment_seconds,
                    detail={"incident_ref": incident_ref, "recognition_quality": context.concussion_recognition},
                )
                # Confirmed concussion is always removed. A false suspicion may be
                # cleared only when assessment evidence is sufficiently strong.
                if actual_concussion:
                    final = "REMOVED_CONCUSSION"
                    recovery_days = 14 + int(incident_rng.random() * 8)
                    injury_code = "MATCH_CONCUSSION"
                    removed = True
                else:
                    clear_probability = _clamp(
                        0.52 + context.assessment_quality * 0.003
                        - context.welfare_bias * 0.0012, 0.45, 0.82
                    )
                    cleared = incident_rng.random() < clear_probability
                    final = "CLEARED_TO_CONTINUE" if cleared else "PRECAUTIONARY_REMOVAL"
                    recovery_days = 0 if cleared else 2
                    injury_code = "MATCH_HEAD_IMPACT"
                    removed = not cleared
                if removed:
                    append_injury_event(
                        club_id=club_id, player=player, minute=minute, injury_code=injury_code,
                        severity="CONCUSSION" if actual_concussion else "PRECAUTIONARY", cause=cause,
                        body_region="HEAD", recovery_days=recovery_days, available=False,
                        incident_ref=incident_ref, concussion=actual_concussion,
                    )
                    incoming, extra = force_medical_substitution(
                        club_id=club_id, player=player, minute=minute,
                        reason="CONCUSSION" if actual_concussion else "HEAD_INJURY",
                        concussion=True,
                    )
                    player_metrics[player.player_id]["concussion_removed"] += int(actual_concussion)
                    team_metrics[club_id]["concussion_removals"] += int(actual_concussion)
                    record_medical_event(
                        minute=minute, event_type="RETURN_TO_PLAY_DECISION", club_id=club_id,
                        player_id=player.player_id, cause=cause, body_region="HEAD",
                        severity="CONCUSSION" if actual_concussion else "PRECAUTIONARY",
                        suspected_concussion=True, final_decision=final,
                        expected_recovery_days=recovery_days, extra_substitution=extra,
                        detail={"incident_ref": incident_ref, "replacement_player_id": incoming.player_id if incoming else None},
                    )
                    return {"stop_play": True, "removed": True, "concussion": actual_concussion}
                medical_penalties[player.player_id].append((int(minute), 0.02))
                player_metrics[player.player_id]["played_on_after_treatment"] += 1
                record_medical_event(
                    minute=minute, event_type="RETURN_TO_PLAY_DECISION", club_id=club_id,
                    player_id=player.player_id, cause=cause, body_region="HEAD", severity="CLEARED",
                    suspected_concussion=True, final_decision=final,
                    detail={"incident_ref": incident_ref, "monitoring": True},
                )
                return {"stop_play": True, "removed": False, "concussion": False}

            severity_pressure = (
                impact * 0.50
                + max(0.0, fatigue - 35.0) / 100.0 * 0.30
                + max(0.0, 65.0 - protection) / 100.0 * 0.20
                + max(0.0, effects.injury_risk_multiplier - 1.0) * 0.20
            )
            roll = incident_rng.random() + severity_pressure * 0.28
            if roll > 1.10:
                severity = "SEVERE"; recovery_days = 21 + int(incident_rng.random() * 28)
                injury_code = "MATCH_SEVERE"; removed = True; penalty = 0.18
            elif roll > 0.83:
                severity = "MODERATE"; recovery_days = 8 + int(incident_rng.random() * 14)
                injury_code = "MATCH_MODERATE"; removed = True; penalty = 0.12
            elif roll > 0.40:
                severity = "MINOR"; recovery_days = 2 + int(incident_rng.random() * 5)
                injury_code = "MATCH_MINOR"; removed = False; penalty = 0.055
            else:
                severity = "KNOCK"; recovery_days = 0; injury_code = ""; removed = False; penalty = 0.025

            treatment = "ON_FIELD_TREATMENT" if severity in {"MINOR", "KNOCK"} else "IMMOBILIZE_AND_REMOVE"
            penalty = _clamp(
                penalty * (1.0 - (context.treatment_quality - 50) * 0.0015),
                0.015, penalty,
            )
            stoppage = int(_clamp(45 + impact * 95 + (100 - context.treatment_quality), 35, 260))
            record_medical_event(
                minute=minute, event_type="ASSESSMENT", club_id=club_id, player_id=player.player_id,
                cause=cause, body_region=body_region, severity=severity, final_decision="TREAT",
                stoppage_seconds=stoppage, detail={"incident_ref": incident_ref},
            )
            record_medical_event(
                minute=minute, event_type="TREATMENT", club_id=club_id, player_id=player.player_id,
                cause=cause, body_region=body_region, severity=severity, treatment=treatment,
                stoppage_seconds=0, expected_recovery_days=recovery_days,
                detail={"incident_ref": incident_ref, "treatment_quality": context.treatment_quality},
            )
            if injury_code:
                append_injury_event(
                    club_id=club_id, player=player, minute=minute, injury_code=injury_code,
                    severity=severity, cause=cause, body_region=body_region,
                    recovery_days=recovery_days, available=not removed, incident_ref=incident_ref,
                )
            if removed:
                incoming, extra = force_medical_substitution(
                    club_id=club_id, player=player, minute=minute, reason="INJURY", concussion=False
                )
                record_medical_event(
                    minute=minute, event_type="RETURN_TO_PLAY_DECISION", club_id=club_id,
                    player_id=player.player_id, cause=cause, body_region=body_region, severity=severity,
                    final_decision="FORCED_REMOVAL", expected_recovery_days=recovery_days,
                    extra_substitution=extra,
                    detail={"incident_ref": incident_ref, "replacement_player_id": incoming.player_id if incoming else None},
                )
                return {"stop_play": True, "removed": True, "concussion": False}

            medical_penalties[player.player_id].append((int(minute), float(penalty)))
            player_metrics[player.player_id]["played_on_after_treatment"] += 1
            record_medical_event(
                minute=minute, event_type="RETURN_TO_PLAY_DECISION", club_id=club_id,
                player_id=player.player_id, cause=cause, body_region=body_region, severity=severity,
                final_decision="CONTINUE_LIMITED" if severity == "MINOR" else "CONTINUE",
                expected_recovery_days=recovery_days,
                detail={"incident_ref": incident_ref, "performance_penalty": round(penalty, 3)},
            )
            return {"stop_play": True, "removed": False, "concussion": False}

        def maybe_contact_medical_incident(*, club_id, player, defender, minute, danger, incident_rng):
            aggression_gap = max(0.0, _rating(defender, "aggression") - _rating(defender, "tackling"))
            base = {"BUILDUP": 0.018, "ATTACKING_THIRD": 0.030, "PENALTY_AREA": 0.038}.get(danger, 0.022)
            risk = base * environment_effects.injury_risk_multiplier
            risk += aggression_gap * 0.00035
            risk += max(0.0, self._fatigue_load(player, minute, current[club_id][0], current[club_id][1]) - 55) * 0.00030
            if incident_rng.random() >= _clamp(risk, 0.008, 0.12):
                return {"stop_play": False, "removed": False}
            impact = _clamp(0.32 + aggression_gap / 90.0 + incident_rng.random() * 0.32, 0.25, 0.95)
            return resolve_medical_incident(
                club_id=club_id, player=player, minute=minute, cause="FOUL_CONTACT",
                incident_rng=incident_rng, impact=impact, contact=True,
            )

        def seed_baseline_medical_incidents():
            for index, team in enumerate((state.home, state.away), start=1):
                salt = DOMAIN_MEDICAL_BASELINE ^ (index * 0x9E3779B97F4A7C15)
                mrng = _domain_rng(seed, salt)
                avg_fatigue = sum(float(getattr(p, "fatigue_index", 0)) for p in team.starters) / 11.0
                probability = _clamp(
                    (0.105 + avg_fatigue * 0.0016) * environment_effects.injury_risk_multiplier,
                    0.07, 0.34,
                )
                if mrng.random() >= probability:
                    continue
                minute = 12 + int(mrng.random() * 74)
                cause = "ENVIRONMENT_STRAIN" if environment_effects.injury_risk_multiplier > 1.25 and mrng.random() < 0.45 else "NON_CONTACT"
                impact = _clamp(0.28 + avg_fatigue / 180.0 + max(0.0, environment_effects.injury_risk_multiplier - 1.0) * 0.18, 0.25, 0.72)
                scheduled_medical_incidents.append({
                    "club_id": team.club_id, "minute": minute, "cause": cause,
                    "impact": impact, "salt": salt ^ (minute * 0x517CC1B727220A95),
                    "processed": False,
                })

        def process_scheduled_medical_incidents(up_to_minute):
            for item in sorted(scheduled_medical_incidents, key=lambda row: (row["minute"], row["club_id"])):
                if item["processed"] or item["minute"] > up_to_minute:
                    continue
                item["processed"] = True
                team = teams[item["club_id"]]
                mrng = _domain_rng(seed, item["salt"])
                active = self._active_players_for_team(
                    team=team, events=non_goal_events, minute=item["minute"], club_id=team.club_id
                )
                if not active:
                    continue
                player = _weighted_choice(
                    mrng, active,
                    lambda p: 25 + getattr(p, "fatigue_index", 0)
                    + max(0, 72 - _rating(p, "natural_fitness"))
                    + max(0, 62 - _rating(p, "agility")) * 0.35,
                )
                resolve_medical_incident(
                    club_id=team.club_id, player=player, minute=item["minute"], cause=item["cause"],
                    incident_rng=mrng, impact=item["impact"], contact=False,
                )

        seed_baseline_medical_incidents()

        def append_card(*, defending_club, defender, minute, card_type, foul_kind, decision_ref):
            if card_type is None:
                return None
            if card_type == EVENT_RED and rules.officiating.var_enabled:
                var_correct = rng_holder["rng"].random() < rules.officiating.var_accuracy / 100.0
                final_card = EVENT_RED if var_correct else EVENT_YELLOW
                record_referee_event(
                    minute=minute, event_type="VAR_REVIEW", club_id=defending_club,
                    player_id=defender.player_id, initial_decision="DIRECT_RED",
                    final_decision="RED_CONFIRMED" if final_card == EVENT_RED else "DOWNGRADED_TO_YELLOW",
                    review_type="DIRECT_RED_CHECK", var_used=True,
                    overturned=final_card != EVENT_RED, marginal=True,
                    detail={"foul_kind": foul_kind},
                )
                card_type = final_card
            previous_yellows = sum(
                row.player_id == defender.player_id
                and row.event_type in {EVENT_YELLOW, EVENT_SECOND_YELLOW}
                for row in non_goal_events
            )
            if card_type == EVENT_YELLOW and previous_yellows >= 1:
                card_type = EVENT_SECOND_YELLOW
            event = ReportEventV2(
                sequence=max(1, len(non_goal_events) + 1),
                minute=minute,
                phase=_phase(minute),
                event_type=card_type,
                club_id=defending_club,
                player_id=defender.player_id,
                detail=(("foul_kind", foul_kind), ("decision_ref", decision_ref)),
            )
            non_goal_events.append(event)
            return event

        def sanction_for_foul(*, defender, minute, danger):
            aggression = _rating(defender, "aggression")
            tackling = _rating(defender, "tackling")
            composure = _rating(defender, "composure")
            strictness = rules.officiating.referee_strictness
            reckless = max(0.0, aggression - tackling) + max(0.0, 55.0 - composure) * 0.35
            red_probability = 0.004 + reckless * 0.00045
            if danger == "PENALTY_AREA":
                red_probability += 0.012
            if rng_holder["rng"].random() < _clamp(red_probability, 0.002, 0.085):
                return EVENT_RED
            yellow_probability = 0.10 + (strictness - 50) * 0.0032 + reckless * 0.0042
            if danger in {"ATTACKING_THIRD", "PENALTY_AREA"}:
                yellow_probability += 0.05
            if rng_holder["rng"].random() < _clamp(yellow_probability, 0.05, 0.58):
                return EVENT_YELLOW
            return None

        def assess_offside(*, attacking_club, defending_club, minute, attacker, attack_strategy, source="OPEN_PLAY"):
            timing = _rating(attacker, "off_ball")
            pace = _rating(attacker, "pace")
            base = 0.042
            if attack_strategy == "DIRECT":
                base += 0.030
            elif attack_strategy == "COUNTER_ATTACK":
                base += 0.020
            elif attack_strategy == "HIGH_TEMPO":
                base += 0.012
            if source == "FREE_KICK":
                base += 0.022
            defending_shape = shape_for_strategy(current[defending_club][1])
            base += (defending_shape.line_height - 52) * 0.00045
            base += max(0.0, pace - 75) * 0.00035
            base -= max(0.0, timing - 50) * 0.00028
            actual_offside = rng_holder["rng"].random() < _clamp(base, 0.018, 0.105)
            marginal = rng_holder["rng"].random() < (0.68 if actual_offside else 0.12)
            assistant_accuracy = rules.officiating.assistant_accuracy / 100.0
            if marginal:
                assistant_accuracy = max(0.55, assistant_accuracy - 0.13)
            false_flag_probability = max(0.001, (1.0 - assistant_accuracy) * (0.28 if marginal else 0.08))
            flagged = (actual_offside and rng_holder["rng"].random() < assistant_accuracy) or (
                not actual_offside and rng_holder["rng"].random() < false_flag_probability
            )
            if not (actual_offside or flagged):
                return False, False, marginal
            if flagged:
                team_metrics[attacking_club]["offsides"] += 1
                player_metrics[attacker.player_id]["offsides"] += 1
            record_referee_event(
                minute=minute, event_type="OFFSIDE", club_id=attacking_club,
                opponent_club_id=defending_club, player_id=attacker.player_id,
                initial_decision="OFFSIDE" if flagged else "PLAY_ON",
                final_decision="OFFSIDE" if flagged else "PLAY_ON",
                marginal=marginal,
                detail={"actual_offside": actual_offside, "source": source},
            )
            return flagged, bool(actual_offside and not flagged), marginal

        def goal_var_allows(*, attacking_club, defending_club, minute, scorer, latent_offside=False, marginal=False):
            if not rules.officiating.var_enabled:
                return True
            accuracy = rules.officiating.var_accuracy / 100.0
            if marginal:
                accuracy = max(0.80, accuracy - 0.025)
            if latent_offside:
                catches = rng_holder["rng"].random() < accuracy
                final = "DISALLOWED_OFFSIDE" if catches else "GOAL_CONFIRMED"
                record_referee_event(
                    minute=minute, event_type="VAR_REVIEW", club_id=attacking_club,
                    opponent_club_id=defending_club, player_id=scorer.player_id,
                    initial_decision="GOAL", final_decision=final, review_type="GOAL_OFFSIDE",
                    var_used=True, overturned=catches, marginal=marginal,
                )
                if catches:
                    team_metrics[attacking_club]["var_disallowed_goals"] += 1
                    player_metrics[scorer.player_id]["disallowed_goals"] += 1
                    team_metrics[attacking_club]["offsides"] += 1
                    player_metrics[scorer.player_id]["offsides"] += 1
                return not catches
            record_referee_event(
                minute=minute, event_type="VAR_REVIEW", club_id=attacking_club,
                opponent_club_id=defending_club, player_id=scorer.player_id,
                initial_decision="GOAL", final_decision="GOAL_CONFIRMED", review_type="GOAL_CHECK",
                var_used=True, overturned=False, marginal=False,
            )
            return True

        def handle_foul(*, attacking_club, defending_club, minute, attacker, defender, attack_players, defend_players, danger):
            accuracy = rules.officiating.referee_accuracy / 100.0
            strictness = rules.officiating.referee_strictness
            medical_result = maybe_contact_medical_incident(
                club_id=attacking_club, player=attacker, defender=defender, minute=minute,
                danger=danger, incident_rng=rng_holder["rng"],
            )
            medical_stop = bool(medical_result.get("stop_play"))
            # Penalty-area contacts receive a VAR-capable decision path.
            if danger == "PENALTY_AREA":
                initial_award = rng_holder["rng"].random() < _clamp(accuracy + (strictness - 50) * 0.0015, 0.65, 0.99)
                final_award = initial_award
                used_var = False
                overturned = False
                if rules.officiating.var_enabled:
                    used_var = True
                    var_correct = rng_holder["rng"].random() < rules.officiating.var_accuracy / 100.0
                    final_award = True if var_correct else initial_award
                    overturned = final_award != initial_award
                decision = record_referee_event(
                    minute=minute, event_type="PENALTY_DECISION", club_id=attacking_club,
                    opponent_club_id=defending_club, player_id=attacker.player_id,
                    offender_player_id=defender.player_id,
                    initial_decision="PENALTY" if initial_award else "PLAY_ON",
                    final_decision="PENALTY" if final_award else "PLAY_ON",
                    review_type="PENALTY_CHECK" if used_var else "", var_used=used_var,
                    overturned=overturned, marginal=True,
                    detail={"danger": danger},
                )
                if not final_award:
                    return "STOPPED" if medical_stop else "MISSED"
                team_metrics[defending_club]["fouls"] += 1
                player_metrics[defender.player_id]["fouls_committed"] += 1
                player_metrics[attacker.player_id]["fouls_drawn"] += 1
                card = sanction_for_foul(defender=defender, minute=minute, danger=danger)
                append_card(defending_club=defending_club, defender=defender, minute=minute,
                            card_type=card, foul_kind="PENALTY", decision_ref=len(referee_events))
                execute_penalty(
                    attacking_club=attacking_club, defending_club=defending_club, minute=minute,
                    attack_players=attack_players, defend_players=defend_players, source="REFEREE_DECISION",
                )
                return "STOPPED"

            detected = rng_holder["rng"].random() < _clamp(accuracy + (strictness - 50) * 0.0018, 0.60, 0.995)
            if not detected:
                record_referee_event(
                    minute=minute, event_type="FOUL", club_id=attacking_club,
                    opponent_club_id=defending_club, player_id=attacker.player_id,
                    offender_player_id=defender.player_id, initial_decision="PLAY_ON",
                    final_decision="PLAY_ON", detail={"danger": danger, "missed": True},
                )
                return "STOPPED" if medical_stop else "MISSED"

            advantage = False
            if rules.officiating.advantage_enabled and not medical_stop:
                attack_quality = (_rating(attacker, "ball_control") + _rating(attacker, "decision_making") + _rating(attacker, "pace")) / 3.0
                advantage_base = 0.17 if danger == "BUILDUP" else 0.43
                advantage = rng_holder["rng"].random() < _clamp(advantage_base + (attack_quality - 50) * 0.002, 0.08, 0.66)
            team_metrics[defending_club]["fouls"] += 1
            player_metrics[defender.player_id]["fouls_committed"] += 1
            player_metrics[attacker.player_id]["fouls_drawn"] += 1
            card = sanction_for_foul(defender=defender, minute=minute, danger=danger)
            record_referee_event(
                minute=minute, event_type="FOUL", club_id=attacking_club,
                opponent_club_id=defending_club, player_id=attacker.player_id,
                offender_player_id=defender.player_id, initial_decision="FOUL",
                final_decision="ADVANTAGE" if advantage else "FREE_KICK",
                advantage_played=advantage, detail={"danger": danger, "card": card or ""},
            )
            append_card(defending_club=defending_club, defender=defender, minute=minute,
                        card_type=card, foul_kind=danger, decision_ref=len(referee_events))
            if advantage:
                team_metrics[attacking_club]["advantages"] += 1
                record_referee_event(
                    minute=minute, event_type="ADVANTAGE", club_id=attacking_club,
                    opponent_club_id=defending_club, player_id=attacker.player_id,
                    offender_player_id=defender.player_id, initial_decision="FOUL",
                    final_decision="PLAY_ON", advantage_played=True, detail={"danger": danger},
                )
                return "ADVANTAGE"
            execute_free_kick(
                attacking_club=attacking_club, defending_club=defending_club, minute=minute,
                attack_players=attack_players, defend_players=defend_players, danger=danger,
            )
            return "STOPPED"

        def execute_penalty(*, attacking_club, defending_club, minute, attack_players, defend_players, source="FOUL"):
            plan = teams[attacking_club].set_piece_plan
            taker = preferred_player(
                [p for p in attack_players if not self._is_goalkeeper(p)] or attack_players,
                plan.penalty_taker_id,
                lambda p: self._penalty_taker_weight(p, minute=minute),
            )
            goalkeeper = self._goalkeeper(defend_players)
            xg = self._penalty_xg(taker=taker, goalkeeper=goalkeeper, minute=minute)
            outcome = self._penalty_outcome(rng_holder["rng"], xg=xg, taker=taker, goalkeeper=goalkeeper, minute=minute)
            team_metrics[attacking_club]["penalties"] += 1
            player_metrics[taker.player_id]["penalties_taken"] += 1
            if outcome == "GOAL":
                player_metrics[taker.player_id]["penalties_scored"] += 1
            set_piece_events.append({
                "minute": minute, "club_id": attacking_club, "type": "PENALTY",
                "taker_player_id": taker.player_id, "routine": "PENALTY",
                "outcome": outcome, "xg": round(xg, 3), "source": source,
            })
            record_shot(
                attacking_club=attacking_club, defending_club=defending_club,
                shooter=taker, creator=None, xg=xg, outcome=outcome, goalkeeper=goalkeeper,
                minute=minute, chance_type="PENALTY", set_piece_type="PENALTY",
                routine="PENALTY", delivery_player_id=taker.player_id,
            )

        def execute_aerial_delivery(*, attacking_club, defending_club, minute, attack_players, defend_players, set_piece_type, routine, taker, delivery_quality):
            plan = teams[attacking_club].set_piece_plan
            outfield_attackers = [p for p in attack_players if p.player_id != taker.player_id and not self._is_goalkeeper(p)] or [p for p in attack_players if p.player_id != taker.player_id]
            outfield_defenders = [p for p in defend_players if not self._is_goalkeeper(p)] or defend_players
            target = preferred_player(
                outfield_attackers, plan.aerial_target_player_id,
                lambda p: self._aerial_attacker_weight(p, minute=minute, routine=routine),
            )
            if set_piece_type == "FREE_KICK":
                stopped, latent_offside, marginal_offside = assess_offside(
                    attacking_club=attacking_club, defending_club=defending_club, minute=minute,
                    attacker=target, attack_strategy="DIRECT", source="FREE_KICK",
                )
                if stopped:
                    set_piece_events.append({
                        "minute": minute, "club_id": attacking_club, "type": set_piece_type,
                        "taker_player_id": taker.player_id, "target_player_id": target.player_id,
                        "routine": routine, "delivery_quality": round(delivery_quality, 2),
                        "aerial_duel_won": False, "outcome": "OFFSIDE",
                    })
                    return
            else:
                latent_offside = False
                marginal_offside = False

            goalkeeper = self._goalkeeper(defend_players)
            if goalkeeper is not None:
                cross_action, cross_outcome = self._keeper_cross_intervention(
                    rng_holder["rng"], goalkeeper=goalkeeper, delivery_quality=delivery_quality,
                    routine=routine, minute=minute,
                )
                if cross_action == "CLAIM":
                    player_metrics[goalkeeper.player_id]["claims"] += 1
                    player_metrics[goalkeeper.player_id]["crosses_claimed"] += 1
                    team_metrics[defending_club]["keeper_claims"] += 1
                    record_defensive_event(
                        minute=minute, event_type="KEEPER_CLAIM", defending_club=defending_club,
                        attacking_club=attacking_club, player_id=goalkeeper.player_id,
                        opponent_player_id=target.player_id, outcome="HELD", zone="BOX",
                        detail={"routine": routine, "delivery_quality": round(delivery_quality, 2)},
                    )
                    set_piece_events.append({
                        "minute": minute, "club_id": attacking_club, "type": set_piece_type,
                        "taker_player_id": taker.player_id, "target_player_id": target.player_id,
                        "routine": routine, "delivery_quality": round(delivery_quality, 2),
                        "aerial_duel_won": False, "outcome": "GOALKEEPER_CLAIM",
                    })
                    return
                if cross_action == "PUNCH":
                    player_metrics[goalkeeper.player_id]["punches"] += 1
                    team_metrics[defending_club]["keeper_punches"] += 1
                    record_defensive_event(
                        minute=minute, event_type="KEEPER_PUNCH", defending_club=defending_club,
                        attacking_club=attacking_club, player_id=goalkeeper.player_id,
                        opponent_player_id=target.player_id, outcome=cross_outcome, zone="BOX",
                        detail={"routine": routine, "delivery_quality": round(delivery_quality, 2)},
                    )
                    if cross_outcome == "PUNCHED_CLEAR":
                        player_metrics[goalkeeper.player_id]["clearances"] += 1
                        team_metrics[defending_club]["clearances"] += 1
                        set_piece_events.append({
                            "minute": minute, "club_id": attacking_club, "type": set_piece_type,
                            "taker_player_id": taker.player_id, "target_player_id": target.player_id,
                            "routine": routine, "delivery_quality": round(delivery_quality, 2),
                            "aerial_duel_won": False, "outcome": "GOALKEEPER_PUNCH_CLEAR",
                        })
                        return
                    delivery_quality *= 0.72
                elif cross_action == "MISJUDGE":
                    player_metrics[goalkeeper.player_id]["keeper_errors"] += 1
                    team_metrics[defending_club]["keeper_errors"] += 1
                    record_defensive_event(
                        minute=minute, event_type="DEFENSIVE_ERROR", defending_club=defending_club,
                        attacking_club=attacking_club, player_id=goalkeeper.player_id,
                        opponent_player_id=target.player_id, outcome="MISJUDGED", zone="BOX",
                        detail={"subtype": "CROSS_MISJUDGEMENT", "routine": routine},
                    )
                    delivery_quality = min(100.0, delivery_quality + 8.0)

            marker = _weighted_choice(rng_holder["rng"], outfield_defenders, lambda p: self._aerial_defender_weight(p, minute=minute))
            player_metrics[target.player_id]["aerial_duels"] += 1
            player_metrics[marker.player_id]["aerial_duels"] += 1
            team_metrics[attacking_club]["aerial_duels"] += 1
            team_metrics[defending_club]["aerial_duels"] += 1
            attack_score = self._aerial_attacker_weight(target, minute=minute, routine=routine) + delivery_quality * 0.42
            defend_score = self._aerial_defender_weight(marker, minute=minute) + self._keeper_cross_command(defend_players, minute=minute) * (0.20 if routine == "CROWD_KEEPER" else 0.10)
            win_prob = _clamp(0.50 + (attack_score - defend_score) * 0.0042, 0.18, 0.78)
            won = rng_holder["rng"].random() < win_prob
            player_metrics[marker.player_id]["defensive_duels"] += 1
            team_metrics[defending_club]["defensive_duels"] += 1
            record_defensive_event(
                minute=minute, event_type="AERIAL_DUEL", defending_club=defending_club,
                attacking_club=attacking_club, player_id=marker.player_id,
                opponent_player_id=target.player_id, outcome=("LOST" if won else "WON"), zone="BOX",
                detail={"set_piece_type": set_piece_type, "routine": routine, "win_probability_attack": round(win_prob, 3)},
            )
            if won:
                player_metrics[target.player_id]["aerial_duels_won"] += 1
                team_metrics[attacking_club]["aerial_duels_won"] += 1
                routine_xg = {"NEAR_POST": 0.072, "FAR_POST": 0.062, "CROWD_KEEPER": 0.072, "CROSS": 0.055}.get(routine, 0.065)
                heading = self._effective_rating(target, "heading", minute=minute, attacking_strategy="BALANCED", defensive_strategy="BALANCED")
                xg = _clamp(routine_xg + (heading - 50) * 0.0010 + (delivery_quality - 50) * 0.0008 + rng_holder["rng"].random() * 0.055, 0.025, 0.36)
                outcome, goalkeeper = self._header_outcome(rng_holder["rng"], xg=xg, shooter=target, defenders=defend_players, minute=minute)
                recorded_shot = record_shot(
                    attacking_club=attacking_club, defending_club=defending_club,
                    shooter=target, creator=taker, xg=xg, outcome=outcome, goalkeeper=goalkeeper,
                    minute=minute, chance_type=f"{set_piece_type}_HEADER", set_piece_type=set_piece_type,
                    routine=routine, delivery_player_id=taker.player_id,
                    metadata={
                        "aerial_marker_player_id": marker.player_id,
                        "latent_offside": bool(latent_offside),
                        "offside_marginal": bool(marginal_offside),
                    },
                )
                result = "DISALLOWED_OFFSIDE" if outcome == "GOAL" and recorded_shot is None else outcome
            else:
                player_metrics[marker.player_id]["aerial_duels_won"] += 1
                player_metrics[marker.player_id]["defensive_duels_won"] += 1
                player_metrics[marker.player_id]["clearances"] += 1
                team_metrics[defending_club]["aerial_duels_won"] += 1
                team_metrics[defending_club]["defensive_duels_won"] += 1
                team_metrics[defending_club]["clearances"] += 1
                record_defensive_event(
                    minute=minute, event_type="CLEARANCE", defending_club=defending_club,
                    attacking_club=attacking_club, player_id=marker.player_id,
                    opponent_player_id=target.player_id, outcome="WON", zone="BOX",
                    detail={"method": "AERIAL", "set_piece_type": set_piece_type},
                )
                result = "DEFENSIVE_CLEARANCE"
                if rng_holder["rng"].random() < 0.28 and outfield_attackers:
                    rebounder = _weighted_choice(rng_holder["rng"], outfield_attackers, lambda p: self._second_ball_weight(p, minute=minute))
                    team_metrics[attacking_club]["second_balls"] += 1
                    player_metrics[rebounder.player_id]["second_ball_recoveries"] += 1
                    xg = _clamp(0.025 + rng_holder["rng"].random() * 0.065 + (self._effective_rating(rebounder, "long_shots", minute=minute, attacking_strategy="BALANCED", defensive_strategy="BALANCED") - 50) * 0.0005, 0.015, 0.14)
                    outcome, goalkeeper = self._shot_outcome(rng_holder["rng"], xg=xg, shooter=rebounder, defenders=defend_players, defend_strategy="BALANCED", attack_strategy="BALANCED", minute=minute)
                    record_shot(
                        attacking_club=attacking_club, defending_club=defending_club, shooter=rebounder, creator=None,
                        xg=xg, outcome=outcome, goalkeeper=goalkeeper, minute=minute,
                        chance_type=f"{set_piece_type}_SECOND_BALL", set_piece_type=set_piece_type,
                        routine=routine, delivery_player_id=taker.player_id, metadata={"second_ball": True},
                    )
                    result = f"SECOND_BALL_{outcome}"
            set_piece_events.append({
                "minute": minute, "club_id": attacking_club, "type": set_piece_type,
                "taker_player_id": taker.player_id, "target_player_id": target.player_id,
                "marker_player_id": marker.player_id, "routine": routine,
                "delivery_quality": round(delivery_quality, 2), "aerial_duel_won": won,
                "outcome": result,
            })

        def execute_corner(*, attacking_club, defending_club, minute, attack_players, defend_players):
            plan = teams[attacking_club].set_piece_plan
            side = "LEFT" if rng_holder["rng"].random() < 0.5 else "RIGHT"
            preferred_id = plan.left_corner_taker_id if side == "LEFT" else plan.right_corner_taker_id
            taker = preferred_player(
                [p for p in attack_players if not self._is_goalkeeper(p)] or attack_players, preferred_id,
                lambda p: self._corner_taker_weight(p, minute=minute),
            )
            routine = plan.corner_routine
            if routine == "MIXED":
                routine = ("NEAR_POST", "FAR_POST", "SHORT", "CROWD_KEEPER")[int(rng_holder["rng"].random() * 4)]
            team_metrics[attacking_club]["corners"] += 1
            player_metrics[taker.player_id]["corners_taken"] += 1
            delivery_quality = self._delivery_quality(taker, minute=minute, crossing=True)
            if routine == "SHORT":
                receivers = [p for p in attack_players if p.player_id != taker.player_id and not self._is_goalkeeper(p)]
                receiver = _weighted_choice(rng_holder["rng"], receivers or attack_players, lambda p: self._pass_weight(p, minute=minute, attacking_strategy="POSSESSION", defensive_strategy="BALANCED"))
                player_metrics[taker.player_id]["passes_attempted"] += 1
                player_metrics[taker.player_id]["passes_completed"] += 1
                xg = _clamp(0.025 + rng_holder["rng"].random() * 0.060 + (self._effective_rating(receiver, "decision_making", minute=minute, attacking_strategy="BALANCED", defensive_strategy="BALANCED") - 50) * 0.0005, 0.015, 0.13)
                shooter = self._choose_shooter(rng_holder["rng"], attack_players, minute=minute, attacking_strategy="POSSESSION", defensive_strategy="BALANCED")
                outcome, goalkeeper = self._shot_outcome(rng_holder["rng"], xg=xg, shooter=shooter, defenders=defend_players, defend_strategy="BALANCED", attack_strategy="POSSESSION", minute=minute)
                record_shot(attacking_club=attacking_club, defending_club=defending_club, shooter=shooter, creator=receiver, xg=xg, outcome=outcome, goalkeeper=goalkeeper, minute=minute, chance_type="CORNER_SHORT", set_piece_type="CORNER", routine=routine, delivery_player_id=taker.player_id)
                set_piece_events.append({"minute": minute, "club_id": attacking_club, "type": "CORNER", "side": side, "taker_player_id": taker.player_id, "routine": routine, "outcome": outcome})
                return
            execute_aerial_delivery(attacking_club=attacking_club, defending_club=defending_club, minute=minute, attack_players=attack_players, defend_players=defend_players, set_piece_type="CORNER", routine=routine, taker=taker, delivery_quality=delivery_quality)

        def execute_free_kick(*, attacking_club, defending_club, minute, attack_players, defend_players, danger="BUILDUP"):
            plan = teams[attacking_club].set_piece_plan
            team_metrics[attacking_club]["free_kicks"] += 1
            taker = preferred_player(
                [p for p in attack_players if not self._is_goalkeeper(p)] or attack_players,
                plan.direct_free_kick_taker_id,
                lambda p: self._free_kick_taker_weight(p, minute=minute),
            )
            player_metrics[taker.player_id]["free_kicks_taken"] += 1
            routine = plan.free_kick_routine
            if routine == "MIXED":
                roll = rng_holder["rng"].random()
                if danger == "ATTACKING_THIRD":
                    if roll < 0.46:
                        routine = "DIRECT"
                    elif roll < 0.80:
                        routine = "CROSS"
                    else:
                        routine = "SHORT"
                else:
                    if roll < 0.05:
                        routine = "DIRECT"
                    elif roll < 0.25:
                        routine = "CROSS"
                    else:
                        routine = "SHORT"
            if routine == "DIRECT":
                xg = self._direct_free_kick_xg(rng_holder["rng"], taker=taker, defenders=defend_players, minute=minute, danger=danger)
                outcome, goalkeeper = self._direct_free_kick_outcome(rng_holder["rng"], xg=xg, taker=taker, defenders=defend_players, minute=minute)
                record_shot(attacking_club=attacking_club, defending_club=defending_club, shooter=taker, creator=None, xg=xg, outcome=outcome, goalkeeper=goalkeeper, minute=minute, chance_type="DIRECT_FREE_KICK", set_piece_type="FREE_KICK", routine="DIRECT", delivery_player_id=taker.player_id)
                set_piece_events.append({"minute": minute, "club_id": attacking_club, "type": "FREE_KICK", "taker_player_id": taker.player_id, "routine": "DIRECT", "outcome": outcome, "xg": round(xg, 3)})
                if outcome == "BLOCKED" and rng_holder["rng"].random() < 0.25:
                    execute_corner(attacking_club=attacking_club, defending_club=defending_club, minute=min(120, minute + 1), attack_players=attack_players, defend_players=defend_players)
                return
            if routine == "SHORT":
                player_metrics[taker.player_id]["passes_attempted"] += 1
                player_metrics[taker.player_id]["passes_completed"] += 1
                set_piece_events.append({"minute": minute, "club_id": attacking_club, "type": "FREE_KICK", "taker_player_id": taker.player_id, "routine": "SHORT", "outcome": "RESTART_COMPLETED"})
                return
            delivery_quality = self._delivery_quality(taker, minute=minute, crossing=True) * 0.96
            execute_aerial_delivery(attacking_club=attacking_club, defending_club=defending_club, minute=minute, attack_players=attack_players, defend_players=defend_players, set_piece_type="FREE_KICK", routine="CROSS", taker=taker, delivery_quality=delivery_quality)

        def reds_before(club_id: str, minute: int) -> int:
            return sum(
                row.club_id == club_id
                and row.event_type in {EVENT_RED, EVENT_SECOND_YELLOW}
                and row.minute < minute
                for row in non_goal_events
            )

        def process_segment(segment_index: int, start: int, end: int, *, extra_time=False):
            phase = PHASE_EXTRA_TIME if extra_time else PHASE_REGULATION
            home_reds = reds_before(state.home.club_id, start)
            away_reds = reds_before(state.away.club_id, start)

            manual_clubs: set[str] = set()
            for command in tactical_commands[segment_index]:
                club_id = command.club_id
                context = state.home_tactics if club_id == state.home.club_id else state.away_tactics
                own_reds = home_reds if club_id == state.home.club_id else away_reds
                opp_reds = away_reds if club_id == state.home.club_id else home_reds
                previous_attack, previous_defence = current[club_id]
                current[club_id] = [command.attacking_strategy, command.defensive_strategy]
                manual_clubs.add(club_id)
                decisions.append({
                    "minute": start,
                    "phase": phase,
                    "club_id": club_id,
                    "source": "LIVE_COMMAND",
                    "trigger_type": "LIVE_COMMAND",
                    "previous_attack": previous_attack,
                    "previous_defence": previous_defence,
                    "attack": command.attacking_strategy,
                    "defence": command.defensive_strategy,
                    "home_score": score[state.home.club_id],
                    "away_score": score[state.away.club_id],
                    "own_reds": own_reds,
                    "opp_reds": opp_reds,
                    "command_ref": command.command_ref,
                    "context": context,
                })

            for club_id, context, own_reds, opp_reds in (
                (state.home.club_id, state.home_tactics, home_reds, away_reds),
                (state.away.club_id, state.away_tactics, away_reds, home_reds),
            ):
                if club_id in manual_clubs:
                    continue
                own_score = score[club_id]
                opp_score = score[opponent[club_id]]
                transition = next_transition(
                    context,
                    minute=start,
                    score_diff=own_score - opp_score,
                    own_reds=own_reds,
                    opponent_reds=opp_reds,
                    current_attack=current[club_id][0],
                    current_defence=current[club_id][1],
                    applied_keys=applied[club_id],
                )
                if transition is not None:
                    previous_attack, previous_defence = current[club_id]
                    current[club_id] = [
                        transition.attacking_strategy,
                        transition.defensive_strategy,
                    ]
                    applied[club_id].add(transition.applied_key)
                    decisions.append({
                        "minute": start,
                        "phase": phase,
                        "club_id": club_id,
                        "source": transition.source,
                        "trigger_type": transition.trigger_type,
                        "previous_attack": previous_attack,
                        "previous_defence": previous_defence,
                        "attack": transition.attacking_strategy,
                        "defence": transition.defensive_strategy,
                        "home_score": score[state.home.club_id],
                        "away_score": score[state.away.club_id],
                        "own_reds": own_reds,
                        "opp_reds": opp_reds,
                        "command_ref": None,
                        "context": context,
                    })

            home_factor = dict(segment_multiplier(
                state.home_tactics,
                attack_strategy=current[state.home.club_id][0],
                defence_strategy=current[state.home.club_id][1],
                opponent_attack_strategy=current[state.away.club_id][0],
                opponent_defence_strategy=current[state.away.club_id][1],
                own_reds=home_reds,
                opponent_reds=away_reds,
            ))
            away_factor = dict(segment_multiplier(
                state.away_tactics,
                attack_strategy=current[state.away.club_id][0],
                defence_strategy=current[state.away.club_id][1],
                opponent_attack_strategy=current[state.home.club_id][0],
                opponent_defence_strategy=current[state.home.club_id][1],
                own_reds=away_reds,
                opponent_reds=home_reds,
            ))
            home_factor["lineup_factor"] = self._lineup_strength_factor(
                state=state,
                club_id=state.home.club_id,
                events=non_goal_events,
                minute=start,
            )
            away_factor["lineup_factor"] = self._lineup_strength_factor(
                state=state,
                club_id=state.away.club_id,
                events=non_goal_events,
                minute=start,
            )
            home_suppression = opponent_defence_suppression(
                state.away_tactics,
                opponent_defence_strategy=current[state.away.club_id][1],
                attacking_strategy=current[state.home.club_id][0],
            )
            away_suppression = opponent_defence_suppression(
                state.home_tactics,
                opponent_defence_strategy=current[state.home.club_id][1],
                attacking_strategy=current[state.away.club_id][0],
            )

            for row in decisions:
                if row["minute"] == start and "effect" not in row:
                    row["effect"] = home_factor if row["club_id"] == state.home.club_id else away_factor

            rng = _domain_rng(seed, DOMAIN_SEGMENT ^ (segment_index * 0x9E3779B97F4A7C15))
            rng_holder["rng"] = rng
            home_share = self._possession_share(
                state=state,
                evaluation=evaluation,
                current=current,
                minute=start,
                home_reds=home_reds,
                away_reds=away_reds,
            )
            possessions = (
                EXTRA_TIME_POSSESSIONS_PER_SEGMENT if extra_time else REGULATION_POSSESSIONS_PER_SEGMENT
            )

            possession_schedule = []
            for possession_index in range(possessions):
                minute = start + int(rng.random() * (end - start + 1))
                attacking_club = (
                    state.home.club_id if rng.random() < home_share else state.away.club_id
                )
                possession_schedule.append((minute, possession_index, attacking_club))
            possession_schedule.sort(key=lambda row: (row[0], row[1]))

            for minute, possession_index, attacking_club in possession_schedule:
                process_scheduled_medical_incidents(minute)
                defending_club = opponent[attacking_club]
                possession_units[attacking_club] += 1
                attack_players = self._active_players_for_team(
                    team=teams[attacking_club],
                    events=non_goal_events,
                    minute=minute,
                    club_id=attacking_club,
                )
                defend_players = self._active_players_for_team(
                    team=teams[defending_club],
                    events=non_goal_events,
                    minute=minute,
                    club_id=defending_club,
                )
                if not attack_players or not defend_players:
                    continue

                attack_context = state.home_tactics if attacking_club == state.home.club_id else state.away_tactics
                defend_context = state.home_tactics if defending_club == state.home.club_id else state.away_tactics
                attack_strategy, attack_defence_strategy = current[attacking_club]
                _, defending_strategy = current[defending_club]
                own_factor = home_factor if attacking_club == state.home.club_id else away_factor
                own_suppression = home_suppression if attacking_club == state.home.club_id else away_suppression

                # Spatial possession: the ball has a real owner, zone and channel.
                possession_sequence = len(possession_records) + 1
                transition = transition_context[attacking_club]
                in_transition = transition.active(minute)
                transition_state = "COUNTER" if in_transition else "BUILDUP"
                current_zone = (
                    "MIDDLE_THIRD" if in_transition or attack_strategy in {"DIRECT", "COUNTER_ATTACK"}
                    else "DEFENSIVE_THIRD"
                )
                current_channel = self._initial_possession_channel(rng, attack_strategy)
                ball_carrier = _weighted_choice(
                    rng, attack_players,
                    lambda p: self._possession_start_weight(
                        p, minute=minute, zone=current_zone, attacking_strategy=attack_strategy,
                        defensive_strategy=attack_defence_strategy,
                    ),
                )
                action_sequence = 1
                possession_records.append({
                    "sequence": possession_sequence, "minute": minute, "club_id": attacking_club,
                    "opponent_club_id": defending_club, "start_zone": current_zone,
                    "transition_state": transition_state,
                })
                record_possession_event(
                    minute=minute, possession_sequence=possession_sequence, action_sequence=action_sequence,
                    event_type="POSSESSION_START", club_id=attacking_club, opponent_club_id=defending_club,
                    player_id=ball_carrier.player_id, origin_zone=current_zone, destination_zone=current_zone,
                    channel=current_channel, outcome="CONTROLLED", transition_state=transition_state,
                    detail={"source": "TURNOVER" if in_transition else "SETTLED_RESTART"},
                )
                player_metrics[ball_carrier.player_id]["touches"] += 1
                team_metrics[attacking_club][f"zone_start_{current_zone}"] += 1

                if in_transition:
                    team_metrics[attacking_club]["transition_possessions"] += 1
                    transition_context[attacking_club] = TransitionContext()

                # Possession style controls how many actions are normally needed before
                # the side can access a shooting state. Reaching the box can shorten it.
                if transition_state == "COUNTER":
                    chain_length = 1 + int(rng.random() * 3)
                elif attack_strategy == "POSSESSION":
                    chain_length = 3 + int(rng.random() * 4)
                elif attack_strategy == "DIRECT":
                    chain_length = 1 + int(rng.random() * 3)
                else:
                    chain_length = 2 + int(rng.random() * 4)

                chain_complete = True
                possession_end_reason = "TURNOVER"
                last_passer: PlayerState | None = None
                last_receiver: PlayerState | None = ball_carrier
                for pass_index in range(chain_length):
                    passer = ball_carrier
                    pass_type, destination_zone, destination_channel, completion_delta = self._pass_intent(
                        rng, passer=passer, current_zone=current_zone, current_channel=current_channel,
                        attacking_strategy=attack_strategy, transition_state=transition_state, minute=minute,
                    )
                    receiver_candidates = [p for p in attack_players if p.player_id != passer.player_id]
                    if not receiver_candidates:
                        break
                    receiver = _weighted_choice(
                        rng, receiver_candidates,
                        lambda p: self._pass_receiver_weight(
                            p, minute=minute, destination_zone=destination_zone,
                            destination_channel=destination_channel, pass_type=pass_type,
                            attacking_strategy=attack_strategy, defensive_strategy=attack_defence_strategy,
                        ),
                    )
                    last_passer = passer
                    last_receiver = receiver
                    player_metrics[passer.player_id]["passes_attempted"] += 1
                    team_metrics[attacking_club]["passes_attempted"] += 1
                    pass_skill = self._effective_rating(
                        passer, "passing", minute=minute, attacking_strategy=attack_strategy,
                        defensive_strategy=attack_defence_strategy,
                    )
                    vision = self._effective_rating(
                        passer, "vision", minute=minute, attacking_strategy=attack_strategy,
                        defensive_strategy=attack_defence_strategy,
                    )
                    receiver_control = (
                        self._effective_rating(receiver, "first_touch", minute=minute, attacking_strategy=attack_strategy, defensive_strategy=attack_defence_strategy)
                        + self._effective_rating(receiver, "ball_control", minute=minute, attacking_strategy=attack_strategy, defensive_strategy=attack_defence_strategy)
                    ) / 2.0
                    pressure = self._defensive_pressure(
                        defend_players, minute=minute, defensive_strategy=defending_strategy,
                        attacking_strategy=current[defending_club][0],
                    )
                    press_context = self._pressing_context(
                        rng, defend_players=defend_players, receiver=receiver, minute=minute,
                        defensive_strategy=defending_strategy, attacking_strategy=current[defending_club][0],
                        origin_zone=current_zone, destination_zone=destination_zone,
                        destination_channel=destination_channel, pass_type=pass_type,
                        transition_state=transition_state,
                    )
                    press_delta = 0.0
                    if press_context is not None:
                        presser = press_context["presser"]
                        player_metrics[presser.player_id]["pressures"] += 1
                        team_metrics[defending_club]["presses_attempted"] += 1
                        record_pressing_event(
                            minute=minute, event_type=("PRESSING_TRAP" if press_context["trigger"] == "WIDE_TRAP" else "PRESS_TRIGGERED"),
                            pressing_club=defending_club, opponent_club=attacking_club,
                            possession_sequence=possession_sequence, player_id=presser.player_id,
                            target_player_id=receiver.player_id, zone=destination_zone, channel=destination_channel,
                            defensive_strategy=defending_strategy, trigger=press_context["trigger"],
                            outcome="ENGAGED", detail={"strength": round(press_context["strength"], 3)},
                        )
                        press_delta = -press_context["completion_penalty"]
                    shape_delta = compactness_pass_delta(
                        strategy=defending_strategy, destination_zone=destination_zone,
                        destination_channel=destination_channel, pass_type=pass_type,
                    )
                    completion = _clamp(
                        0.675
                        + (pass_skill - 50.0) * 0.0032
                        + (vision - 50.0) * 0.0012
                        + (receiver_control - 50.0) * 0.0008
                        - (pressure - 50.0) * 0.0018
                        + (0.030 if attack_strategy == "POSSESSION" else 0.0)
                        + (0.012 if transition_state == "COUNTER" and pass_type in {"PROGRESSIVE", "THROUGH_BALL"} else 0.0)
                        + environment_effects.pass_completion_delta
                        + completion_delta
                        + press_delta
                        + shape_delta,
                        0.38, 0.95,
                    )
                    progressive = is_progressive(current_zone, destination_zone)
                    switch = destination_channel != current_channel and pass_type == "SWITCH"
                    action_sequence += 1
                    pass_row = {
                        "minute": int(minute), "phase": _phase(int(minute)),
                        "possession_sequence": possession_sequence, "pass_sequence": pass_index + 1,
                        "club_id": attacking_club, "passer_player_id": passer.player_id,
                        "receiver_player_id": receiver.player_id, "pass_type": pass_type,
                        "origin_zone": current_zone, "destination_zone": destination_zone,
                        "origin_channel": current_channel, "destination_channel": destination_channel,
                        "progressive": bool(progressive), "switch": bool(switch),
                        "transition_state": transition_state, "completion_probability": round(completion, 3),
                    }
                    if rng.random() <= completion:
                        pass_row["outcome"] = "COMPLETED"
                        pass_events.append(pass_row)
                        player_metrics[passer.player_id]["passes_completed"] += 1
                        player_metrics[receiver.player_id]["passes_received"] += 1
                        player_metrics[receiver.player_id]["touches"] += 1
                        team_metrics[attacking_club]["passes_completed"] += 1
                        if progressive:
                            player_metrics[passer.player_id]["progressive_passes"] += 1
                            team_metrics[attacking_club]["progressive_passes"] += 1
                        if pass_type == "THROUGH_BALL":
                            player_metrics[passer.player_id]["through_balls"] += 1
                            team_metrics[attacking_club]["through_balls"] += 1
                        if switch:
                            player_metrics[passer.player_id]["switches"] += 1
                            team_metrics[attacking_club]["switches"] += 1
                        if destination_zone == "FINAL_THIRD" and current_zone != "FINAL_THIRD":
                            player_metrics[passer.player_id]["final_third_entries"] += 1
                            team_metrics[attacking_club]["final_third_entries"] += 1
                        if destination_zone == "PENALTY_AREA" and current_zone != "PENALTY_AREA":
                            player_metrics[passer.player_id]["box_entries"] += 1
                            team_metrics[attacking_club]["box_entries"] += 1
                        pass_network_edges[(attacking_club, passer.player_id, receiver.player_id)] += 1
                        if press_context is not None:
                            presser = press_context["presser"]
                            player_metrics[passer.player_id]["press_bypasses"] += 1
                            team_metrics[defending_club]["press_bypassed"] += 1
                            record_pressing_event(
                                minute=minute, event_type="PRESS_BYPASSED", pressing_club=defending_club,
                                opponent_club=attacking_club, possession_sequence=possession_sequence,
                                player_id=presser.player_id, target_player_id=receiver.player_id,
                                zone=destination_zone, channel=destination_channel,
                                defensive_strategy=defending_strategy, trigger=press_context["trigger"], outcome="BYPASSED",
                                detail={"passer_player_id": passer.player_id, "pass_type": pass_type},
                            )
                            if progressive and zone_distance(current_zone, destination_zone) >= 1:
                                player_metrics[passer.player_id]["line_breaks"] += 1
                                team_metrics[attacking_club]["line_breaks"] += 1
                                team_metrics[defending_club]["line_breaks_allowed"] += 1
                                record_pressing_event(
                                    minute=minute, event_type="LINE_BREAK", pressing_club=defending_club,
                                    opponent_club=attacking_club, possession_sequence=possession_sequence,
                                    player_id=presser.player_id, target_player_id=receiver.player_id,
                                    zone=destination_zone, channel=destination_channel,
                                    defensive_strategy=defending_strategy, trigger=press_context["trigger"], outcome="LINE_BROKEN",
                                    detail={"passer_player_id": passer.player_id, "origin_zone": current_zone, "pass_type": pass_type},
                                )
                        record_possession_event(
                            minute=minute, possession_sequence=possession_sequence, action_sequence=action_sequence,
                            event_type="PASS", club_id=attacking_club, opponent_club_id=defending_club,
                            player_id=passer.player_id, target_player_id=receiver.player_id,
                            origin_zone=current_zone, destination_zone=destination_zone, channel=destination_channel,
                            outcome="COMPLETED", transition_state=transition_state,
                            detail={"pass_type": pass_type, "progressive": progressive, "switch": switch,
                                    "completion_probability": round(completion, 3)},
                        )
                        current_zone = destination_zone
                        current_channel = destination_channel
                        ball_carrier = receiver
                        if current_zone == "PENALTY_AREA":
                            transition_state = "PROGRESSION" if transition_state != "COUNTER" else "COUNTER"
                            break
                        continue

                    pass_row["outcome"] = "FAILED"
                    pass_events.append(pass_row)
                    record_possession_event(
                        minute=minute, possession_sequence=possession_sequence, action_sequence=action_sequence,
                        event_type="PASS", club_id=attacking_club, opponent_club_id=defending_club,
                        player_id=passer.player_id, target_player_id=receiver.player_id,
                        origin_zone=current_zone, destination_zone=destination_zone, channel=destination_channel,
                        outcome="FAILED", transition_state=transition_state,
                        detail={"pass_type": pass_type, "progressive": progressive, "switch": switch,
                                "completion_probability": round(completion, 3)},
                    )
                    chain_complete = False
                    defender = _weighted_choice(
                        rng, defend_players,
                        lambda p: self._defender_action_weight(
                            p, minute=minute, defensive_strategy=defending_strategy,
                            attacking_strategy=current[defending_club][0],
                        ),
                    )
                    defensive_type = "INTERCEPTION" if rng.random() < 0.54 else "TACKLE"
                    if defensive_type == "INTERCEPTION":
                        player_metrics[defender.player_id]["interceptions"] += 1
                        team_metrics[defending_club]["interceptions"] += 1
                    else:
                        player_metrics[defender.player_id]["tackles_attempted"] += 1
                        player_metrics[defender.player_id]["tackles_won"] += 1
                        player_metrics[defender.player_id]["defensive_duels"] += 1
                        player_metrics[defender.player_id]["defensive_duels_won"] += 1
                        team_metrics[defending_club]["tackles_won"] += 1
                        team_metrics[defending_club]["defensive_duels"] += 1
                        team_metrics[defending_club]["defensive_duels_won"] += 1
                    record_defensive_event(
                        minute=minute, event_type=defensive_type, defending_club=defending_club,
                        attacking_club=attacking_club, player_id=defender.player_id,
                        opponent_player_id=passer.player_id, outcome="WON", zone=current_zone,
                        detail={"pass_index": pass_index + 1, "pass_type": pass_type,
                                "origin_zone": current_zone, "destination_zone": destination_zone},
                    )
                    foul_result = None
                    if rng.random() < self._foul_probability(defender, defending_strategy):
                        foul_result = handle_foul(
                            attacking_club=attacking_club, defending_club=defending_club, minute=minute,
                            attacker=passer, defender=defender, attack_players=attack_players,
                            defend_players=defend_players, danger=(
                                "ATTACKING_THIRD" if current_zone in {"FINAL_THIRD", "PENALTY_AREA"} else "BUILDUP"
                            ),
                        )
                    if foul_result == "ADVANTAGE":
                        chain_complete = True
                        action_sequence += 1
                        record_possession_event(
                            minute=minute, possession_sequence=possession_sequence, action_sequence=action_sequence,
                            event_type="RECOVERY", club_id=attacking_club, opponent_club_id=defending_club,
                            player_id=passer.player_id, origin_zone=current_zone, destination_zone=current_zone,
                            channel=current_channel, outcome="ADVANTAGE_RETAINED", transition_state=transition_state,
                            detail={"after_failed_pass": True},
                        )
                    elif foul_result == "STOPPED":
                        possession_end_reason = "FOUL_STOPPAGE"
                        chain_complete = False
                    else:
                        if press_context is not None:
                            player_metrics[press_context["presser"].player_id]["pressing_recoveries"] += 1
                            team_metrics[defending_club]["pressing_recoveries"] += 1
                            record_pressing_event(
                                minute=minute, event_type="PRESS_RECOVERY", pressing_club=defending_club,
                                opponent_club=attacking_club, possession_sequence=possession_sequence,
                                player_id=press_context["presser"].player_id, target_player_id=passer.player_id,
                                zone=current_zone, channel=current_channel, defensive_strategy=defending_strategy,
                                trigger=press_context["trigger"], outcome="BALL_WON",
                                detail={"winner_player_id": defender.player_id, "mechanism": defensive_type},
                            )
                        counterpress_attempted, counterpress_recoverer = attempt_counterpress(
                            losing_club=attacking_club, winning_club=defending_club, minute=minute,
                            zone=current_zone, channel=current_channel, losing_players=attack_players,
                            winning_player=defender, defensive_strategy=attack_defence_strategy,
                            attacking_strategy=attack_strategy, possession_sequence=possession_sequence,
                        )
                        if counterpress_recoverer is not None:
                            chain_complete = True
                            ball_carrier = counterpress_recoverer
                            transition_state = "SECOND_BALL"
                            action_sequence += 1
                            record_possession_event(
                                minute=minute, possession_sequence=possession_sequence, action_sequence=action_sequence,
                                event_type="RECOVERY", club_id=attacking_club, opponent_club_id=defending_club,
                                player_id=counterpress_recoverer.player_id, target_player_id=defender.player_id,
                                origin_zone=current_zone, destination_zone=current_zone, channel=current_channel,
                                outcome="COUNTERPRESS_RECOVERY", transition_state=transition_state,
                            )
                            break
                        action_sequence += 1
                        record_possession_event(
                            minute=minute, possession_sequence=possession_sequence, action_sequence=action_sequence,
                            event_type="TURNOVER", club_id=attacking_club, opponent_club_id=defending_club,
                            player_id=passer.player_id, target_player_id=defender.player_id,
                            origin_zone=current_zone, destination_zone=current_zone, channel=current_channel,
                            outcome="LOST", transition_state=transition_state,
                            detail={"won_by_club_id": defending_club, "won_by_player_id": defender.player_id,
                                    "mechanism": defensive_type, "pass_type": pass_type},
                        )
                        team_metrics[attacking_club]["turnovers_lost"] += 1
                        team_metrics[defending_club]["turnovers_won"] += 1
                        player_metrics[passer.player_id]["turnovers"] += 1
                        player_metrics[defender.player_id]["recoveries"] += 1
                        transition_context[defending_club] = TransitionContext(
                            state="COUNTER",
                            source_zone=("MIDDLE_THIRD" if current_zone in {"FINAL_THIRD", "PENALTY_AREA"} else "DEFENSIVE_THIRD"),
                            expires_minute=min(120, minute + 2),
                            caused_by_player_id=defender.player_id,
                        )
                    break

                if not chain_complete:
                    action_sequence += 1
                    record_possession_event(
                        minute=minute, possession_sequence=possession_sequence, action_sequence=action_sequence,
                        event_type="POSSESSION_END", club_id=attacking_club, opponent_club_id=defending_club,
                        player_id=last_passer.player_id if last_passer else ball_carrier.player_id,
                        origin_zone=current_zone, destination_zone=current_zone, channel=current_channel,
                        outcome=possession_end_reason, transition_state=transition_state,
                    )
                    continue

                chance_prob = self._chance_probability(
                    attacking_club=attacking_club,
                    defending_club=defending_club,
                    state=state,
                    evaluation=evaluation,
                    attack_strategy=attack_strategy,
                    defending_strategy=defending_strategy,
                    own_factor=own_factor,
                    suppression=own_suppression,
                    attack_players=attack_players,
                    defend_players=defend_players,
                    minute=minute,
                )
                spatial_chance_delta = {
                    "DEFENSIVE_THIRD": -0.100,
                    "MIDDLE_THIRD": -0.040,
                    "FINAL_THIRD": 0.020,
                    "PENALTY_AREA": 0.070,
                }.get(current_zone, 0.0)
                defending_shape = shape_for_strategy(defending_strategy)
                if current_zone in {"FINAL_THIRD", "PENALTY_AREA"}:
                    spatial_chance_delta -= max(0, defending_shape.compactness - 68) * 0.00042
                if transition_state == "COUNTER":
                    spatial_chance_delta += 0.010 + max(0, defending_shape.line_height - 60) * 0.00028
                chance_prob = _clamp(chance_prob + spatial_chance_delta, MIN_CHANCE_PROBABILITY, MAX_CHANCE_PROBABILITY)
                if rng.random() > chance_prob:
                    corner_probability = 0.110 + (0.030 if attack_strategy == "WIDE_PLAY" else 0.0)
                    if attack_strategy == "WIDE_PLAY":
                        corner_probability *= environment_effects.wide_play_multiplier
                    if rng.random() < corner_probability:
                        execute_corner(
                            attacking_club=attacking_club, defending_club=defending_club, minute=minute,
                            attack_players=attack_players, defend_players=defend_players,
                        )
                        action_sequence += 1
                        record_possession_event(
                            minute=minute, possession_sequence=possession_sequence, action_sequence=action_sequence,
                            event_type="SET_PIECE_WON", club_id=attacking_club, opponent_club_id=defending_club,
                            player_id=ball_carrier.player_id, origin_zone=current_zone, destination_zone="PENALTY_AREA",
                            channel=current_channel, outcome="CORNER", transition_state=transition_state,
                        )
                    if rng.random() < 0.22:
                        dribbler = _weighted_choice(
                            rng,
                            attack_players,
                            lambda p: self._dribble_weight(p, minute, attack_strategy, attack_defence_strategy),
                        )
                        defender = _weighted_choice(
                            rng, defend_players,
                            lambda p: self._defender_action_weight(
                                p, minute=minute, defensive_strategy=defending_strategy,
                                attacking_strategy=current[defending_club][0],
                            ),
                        )
                        player_metrics[dribbler.player_id]["dribbles_attempted"] += 1
                        player_metrics[defender.player_id]["tackles_attempted"] += 1
                        player_metrics[defender.player_id]["defensive_duels"] += 1
                        team_metrics[defending_club]["defensive_duels"] += 1
                        dribble_prob = self._ground_duel_attack_probability(
                            attacker=dribbler, defender=defender, minute=minute,
                            attack_strategy=attack_strategy, defence_strategy=defending_strategy,
                        )
                        if rng.random() < dribble_prob:
                            player_metrics[dribbler.player_id]["dribbles_completed"] += 1
                            carry_destination = (
                                "PENALTY_AREA" if current_zone == "FINAL_THIRD" else
                                ("FINAL_THIRD" if current_zone == "MIDDLE_THIRD" else current_zone)
                            )
                            action_sequence += 1
                            record_possession_event(
                                minute=minute, possession_sequence=possession_sequence, action_sequence=action_sequence,
                                event_type="CARRY", club_id=attacking_club, opponent_club_id=defending_club,
                                player_id=dribbler.player_id, target_player_id=defender.player_id,
                                origin_zone=current_zone, destination_zone=carry_destination, channel=current_channel,
                                outcome="COMPLETED", transition_state=transition_state,
                                detail={"success_probability": round(dribble_prob, 3)},
                            )
                            if carry_destination != current_zone:
                                player_metrics[dribbler.player_id]["progressive_carries"] += 1
                                team_metrics[attacking_club]["progressive_carries"] += 1
                                if carry_destination == "FINAL_THIRD":
                                    player_metrics[dribbler.player_id]["final_third_entries"] += 1
                                    team_metrics[attacking_club]["final_third_entries"] += 1
                                elif carry_destination == "PENALTY_AREA":
                                    player_metrics[dribbler.player_id]["box_entries"] += 1
                                    team_metrics[attacking_club]["box_entries"] += 1
                            current_zone = carry_destination
                            ball_carrier = dribbler
                            record_defensive_event(
                                minute=minute, event_type="GROUND_DUEL", defending_club=defending_club,
                                attacking_club=attacking_club, player_id=defender.player_id,
                                opponent_player_id=dribbler.player_id, outcome="LOST", zone=current_zone,
                                detail={"attacker_success_probability": round(dribble_prob, 3)},
                            )
                        else:
                            player_metrics[defender.player_id]["tackles_won"] += 1
                            player_metrics[defender.player_id]["defensive_duels_won"] += 1
                            team_metrics[defending_club]["tackles_won"] += 1
                            team_metrics[defending_club]["defensive_duels_won"] += 1
                            record_defensive_event(
                                minute=minute, event_type="GROUND_DUEL", defending_club=defending_club,
                                attacking_club=attacking_club, player_id=defender.player_id,
                                opponent_player_id=dribbler.player_id, outcome="WON", zone=current_zone,
                                detail={"attacker_success_probability": round(dribble_prob, 3)},
                            )
                            action_sequence += 1
                            record_possession_event(
                                minute=minute, possession_sequence=possession_sequence, action_sequence=action_sequence,
                                event_type="TURNOVER", club_id=attacking_club, opponent_club_id=defending_club,
                                player_id=dribbler.player_id, target_player_id=defender.player_id,
                                origin_zone=current_zone, destination_zone=current_zone, channel=current_channel,
                                outcome="LOST", transition_state=transition_state,
                                detail={"won_by_club_id": defending_club, "won_by_player_id": defender.player_id, "mechanism": "GROUND_DUEL"},
                            )
                            team_metrics[attacking_club]["turnovers_lost"] += 1
                            team_metrics[defending_club]["turnovers_won"] += 1
                            player_metrics[dribbler.player_id]["turnovers"] += 1
                            player_metrics[defender.player_id]["recoveries"] += 1
                            transition_context[defending_club] = TransitionContext(
                                state="COUNTER", source_zone="MIDDLE_THIRD", expires_minute=min(120, minute + 2),
                                caused_by_player_id=defender.player_id,
                            )
                            action_sequence += 1
                            record_possession_event(
                                minute=minute, possession_sequence=possession_sequence, action_sequence=action_sequence,
                                event_type="POSSESSION_END", club_id=attacking_club, opponent_club_id=defending_club,
                                player_id=dribbler.player_id, origin_zone=current_zone, destination_zone=current_zone,
                                channel=current_channel, outcome="TURNOVER", transition_state=transition_state,
                            )
                            continue
                    action_sequence += 1
                    record_possession_event(
                        minute=minute, possession_sequence=possession_sequence, action_sequence=action_sequence,
                        event_type="POSSESSION_END", club_id=attacking_club, opponent_club_id=defending_club,
                        player_id=ball_carrier.player_id, origin_zone=current_zone, destination_zone=current_zone,
                        channel=current_channel, outcome="NO_SHOT", transition_state=transition_state,
                    )
                    continue

                shooter = None
                if (
                    ball_carrier is not None
                    and not self._is_goalkeeper(ball_carrier)
                    and current_zone in {"FINAL_THIRD", "PENALTY_AREA"}
                    and rng.random() < (0.78 if current_zone == "PENALTY_AREA" else 0.62)
                ):
                    shooter = ball_carrier
                if shooter is None:
                    shooter = self._choose_shooter(
                        rng, attack_players, minute=minute, attacking_strategy=attack_strategy,
                        defensive_strategy=attack_defence_strategy,
                    )
                creator = last_passer
                if creator is None or creator.player_id == shooter.player_id:
                    creator = self._choose_creator(
                        rng, attack_players, minute=minute, attacking_strategy=attack_strategy,
                        defensive_strategy=attack_defence_strategy, fallback=None,
                    )
                if creator is not None and creator.player_id == shooter.player_id:
                    creator = None
                action_sequence += 1
                record_possession_event(
                    minute=minute, possession_sequence=possession_sequence, action_sequence=action_sequence,
                    event_type="CHANCE_CREATED", club_id=attacking_club, opponent_club_id=defending_club,
                    player_id=creator.player_id if creator else shooter.player_id,
                    target_player_id=shooter.player_id, origin_zone=current_zone,
                    destination_zone="PENALTY_AREA" if current_zone == "FINAL_THIRD" else current_zone,
                    channel=current_channel, outcome="ACTIVE", transition_state=transition_state,
                    detail={"chance_probability": round(chance_prob, 3)},
                )
                team_metrics[attacking_club]["chances_created"] += 1

                # Offside is adjudicated at the attacking action, before a shot can
                # become an official statistical event. A missed marginal offside is
                # remembered so VAR can still disallow a resulting goal.
                offside_stopped, latent_offside, offside_marginal = assess_offside(
                    attacking_club=attacking_club, defending_club=defending_club,
                    minute=minute, attacker=shooter, attack_strategy=attack_strategy,
                )
                if offside_stopped:
                    action_sequence += 1
                    record_possession_event(
                        minute=minute, possession_sequence=possession_sequence, action_sequence=action_sequence,
                        event_type="POSSESSION_END", club_id=attacking_club, opponent_club_id=defending_club,
                        player_id=shooter.player_id, origin_zone=current_zone, destination_zone=current_zone,
                        channel=current_channel, outcome="OFFSIDE", transition_state=transition_state,
                    )
                    continue

                # Dangerous contact is resolved before the shot.  Advantage keeps the
                # causal attack alive; a whistle replaces the chance with the correct
                # restart and therefore no open-play shot is fabricated.
                if rng.random() < (0.030 + (0.012 if defending_strategy == "HIGH_PRESS" else 0.0)):
                    defender = _weighted_choice(
                        rng, defend_players,
                        lambda p: self._defender_action_weight(
                            p, minute=minute, defensive_strategy=defending_strategy,
                            attacking_strategy=current[defending_club][0],
                        ),
                    )
                    danger = "PENALTY_AREA" if rng.random() < 0.24 else "ATTACKING_THIRD"
                    foul_result = handle_foul(
                        attacking_club=attacking_club, defending_club=defending_club, minute=minute,
                        attacker=shooter, defender=defender, attack_players=attack_players,
                        defend_players=defend_players, danger=danger,
                    )
                    if foul_result == "STOPPED":
                        action_sequence += 1
                        record_possession_event(
                            minute=minute, possession_sequence=possession_sequence, action_sequence=action_sequence,
                            event_type="POSSESSION_END", club_id=attacking_club, opponent_club_id=defending_club,
                            player_id=shooter.player_id, target_player_id=defender.player_id,
                            origin_zone=current_zone, destination_zone=current_zone, channel=current_channel,
                            outcome="FOUL_STOPPAGE", transition_state=transition_state,
                        )
                        continue

                xg = self._shot_xg(
                    rng,
                    shooter=shooter,
                    creator=creator,
                    attack_strategy=attack_strategy,
                    defend_strategy=defending_strategy,
                    minute=minute,
                    attack_players=attack_players,
                    defend_players=defend_players,
                )
                spatial_xg_multiplier = {
                    "DEFENSIVE_THIRD": 0.58,
                    "MIDDLE_THIRD": 0.72,
                    "FINAL_THIRD": 1.00,
                    "PENALTY_AREA": 1.10,
                }.get(current_zone, 1.0)
                if transition_state == "COUNTER":
                    spatial_xg_multiplier *= 1.05
                xg = _clamp(xg * spatial_xg_multiplier, MIN_XG, MAX_XG)
                chance_type = self._chance_type(attack_strategy, xg)
                shot_metadata = {
                    "offside_checked": True,
                    "latent_offside": bool(latent_offside),
                    "offside_marginal": bool(offside_marginal),
                }

                # A rare concentration/positioning failure can materially improve the
                # chance, and is attached to the resulting shot/goal rather than
                # sampled as a detached post-match statistic.
                outfield_defenders = [p for p in defend_players if not self._is_goalkeeper(p)]
                error_defender = None
                if outfield_defenders:
                    candidate = _weighted_choice(
                        rng, outfield_defenders,
                        lambda p: self._defender_action_weight(
                            p, minute=minute, defensive_strategy=defending_strategy,
                            attacking_strategy=current[defending_club][0],
                        ),
                    )
                    if rng.random() < self._defensive_error_probability(candidate, minute=minute, defensive_strategy=defending_strategy):
                        error_defender = candidate
                        player_metrics[candidate.player_id]["errors_leading_to_shot"] += 1
                        team_metrics[defending_club]["errors_leading_to_shot"] += 1
                        xg = _clamp(xg + 0.065, MIN_XG, MAX_XG)
                        shot_metadata["defensive_error_player_id"] = candidate.player_id
                        record_defensive_event(
                            minute=minute, event_type="DEFENSIVE_ERROR", defending_club=defending_club,
                            attacking_club=attacking_club, player_id=candidate.player_id,
                            opponent_player_id=shooter.player_id, outcome="ERROR", zone="DEFENSIVE_THIRD",
                            detail={"subtype": "POSITIONAL_OR_CONTROL_ERROR", "boosted_xg": round(xg, 3)},
                        )

                # Sweeper-keeper decisions happen before the shot becomes official.
                # A successful intervention kills the chance; a mistimed rush makes
                # the subsequent shot more dangerous.
                goalkeeper = self._goalkeeper(defend_players)
                if goalkeeper is not None and (xg >= 0.20 or attack_strategy in {"DIRECT", "COUNTER_ATTACK"}):
                    sweep = self._sweeper_keeper_action(
                        rng, goalkeeper=goalkeeper, shooter=shooter, minute=minute,
                        xg=xg, attack_strategy=attack_strategy,
                    )
                    if sweep is not None:
                        action, success, modifier = sweep
                        player_metrics[goalkeeper.player_id]["sweeper_actions"] += 1
                        team_metrics[defending_club]["sweeper_actions"] += 1
                        if success:
                            player_metrics[goalkeeper.player_id]["sweeper_successes"] += 1
                            player_metrics[goalkeeper.player_id]["clearances"] += 1
                            team_metrics[defending_club]["sweeper_successes"] += 1
                            team_metrics[defending_club]["clearances"] += 1
                            record_defensive_event(
                                minute=minute, event_type="SWEEPER_CLEARANCE", defending_club=defending_club,
                                attacking_club=attacking_club, player_id=goalkeeper.player_id,
                                opponent_player_id=shooter.player_id, outcome="WON", zone="OUTSIDE_BOX",
                                detail={"action": action, "pre_action_xg": round(xg, 3)},
                            )
                            action_sequence += 1
                            record_possession_event(
                                minute=minute, possession_sequence=possession_sequence, action_sequence=action_sequence,
                                event_type="POSSESSION_END", club_id=attacking_club, opponent_club_id=defending_club,
                                player_id=shooter.player_id, target_player_id=goalkeeper.player_id,
                                origin_zone=current_zone, destination_zone=current_zone, channel=current_channel,
                                outcome="SWEEPER_CLEARANCE", transition_state=transition_state,
                            )
                            continue
                        player_metrics[goalkeeper.player_id]["keeper_errors"] += 1
                        team_metrics[defending_club]["keeper_errors"] += 1
                        xg = _clamp(xg * modifier, MIN_XG, MAX_XG)
                        shot_metadata["sweeper_misjudgement"] = True
                        shot_metadata["sweeper_keeper_player_id"] = goalkeeper.player_id
                        record_defensive_event(
                            minute=minute, event_type="SWEEPER_MISJUDGEMENT", defending_club=defending_club,
                            attacking_club=attacking_club, player_id=goalkeeper.player_id,
                            opponent_player_id=shooter.player_id, outcome="LOST", zone="OUTSIDE_BOX",
                            detail={"action": action, "post_action_xg": round(xg, 3)},
                        )

                chance_type = self._chance_type(attack_strategy, xg)
                outcome, goalkeeper = self._shot_outcome(
                    rng,
                    xg=xg,
                    shooter=shooter,
                    defenders=defend_players,
                    defend_strategy=defending_strategy,
                    attack_strategy=attack_strategy,
                    minute=minute,
                )
                if outcome == "GOAL" and not goal_var_allows(
                    attacking_club=attacking_club, defending_club=defending_club, minute=minute,
                    scorer=shooter, latent_offside=latent_offside, marginal=offside_marginal,
                ):
                    action_sequence += 1
                    record_possession_event(
                        minute=minute, possession_sequence=possession_sequence, action_sequence=action_sequence,
                        event_type="POSSESSION_END", club_id=attacking_club, opponent_club_id=defending_club,
                        player_id=shooter.player_id, origin_zone=current_zone, destination_zone=current_zone,
                        channel=current_channel, outcome="VAR_DISALLOWED", transition_state=transition_state,
                    )
                    continue
                if outcome == "GOAL" and error_defender is not None:
                    player_metrics[error_defender.player_id]["errors_leading_to_goal"] += 1
                    team_metrics[defending_club]["errors_leading_to_goal"] += 1
                shot_metadata["var_reviewed"] = outcome == "GOAL"
                shot = record_shot(
                    attacking_club=attacking_club, defending_club=defending_club,
                    shooter=shooter, creator=creator, xg=xg, outcome=outcome, goalkeeper=goalkeeper,
                    minute=minute, chance_type=chance_type, metadata=shot_metadata,
                )
                action_sequence += 1
                record_possession_event(
                    minute=minute, possession_sequence=possession_sequence, action_sequence=action_sequence,
                    event_type="SHOT", club_id=attacking_club, opponent_club_id=defending_club,
                    player_id=shooter.player_id, target_player_id=goalkeeper.player_id if goalkeeper else None,
                    origin_zone=current_zone, destination_zone="PENALTY_AREA", channel=current_channel,
                    outcome=outcome, transition_state=transition_state,
                    detail={"xg": round(float(xg), 3), "chance_type": chance_type,
                            "creator_player_id": creator.player_id if creator else None},
                )
                possession_end_outcome = "GOAL" if outcome == "GOAL" else "SHOT_END"
                if outcome == "BLOCKED" and rng.random() < 0.52:
                    execute_corner(
                        attacking_club=attacking_club, defending_club=defending_club, minute=min(120, minute + 1),
                        attack_players=attack_players, defend_players=defend_players,
                    )
                elif outcome == "SAVED" and shot is not None:
                    save_outcome = shot.get("save_outcome")
                    action = shot.get("goalkeeper_action")
                    if save_outcome == "PARRIED_DANGER" and rng.random() < 0.34:
                        rebounders = [p for p in attack_players if p.player_id != shooter.player_id and not self._is_goalkeeper(p)]
                        if rebounders:
                            rebounder = _weighted_choice(rng, rebounders, lambda p: self._second_ball_weight(p, minute=minute))
                            team_metrics[attacking_club]["second_balls"] += 1
                            player_metrics[rebounder.player_id]["second_ball_recoveries"] += 1
                            rebound_xg = _clamp(0.055 + rng.random() * 0.105, 0.035, 0.20)
                            rebound_outcome, rebound_gk = self._shot_outcome(
                                rng, xg=rebound_xg, shooter=rebounder, defenders=defend_players,
                                defend_strategy=defending_strategy, attack_strategy=attack_strategy, minute=minute,
                            )
                            record_shot(
                                attacking_club=attacking_club, defending_club=defending_club,
                                shooter=rebounder, creator=None, xg=rebound_xg, outcome=rebound_outcome,
                                goalkeeper=rebound_gk, minute=minute, chance_type="SAVE_REBOUND",
                                metadata={"second_ball": True, "rebound_from_player_id": shooter.player_id},
                            )
                            action_sequence += 1
                            record_possession_event(
                                minute=minute, possession_sequence=possession_sequence, action_sequence=action_sequence,
                                event_type="SHOT", club_id=attacking_club, opponent_club_id=defending_club,
                                player_id=rebounder.player_id, target_player_id=rebound_gk.player_id if rebound_gk else None,
                                origin_zone="PENALTY_AREA", destination_zone="PENALTY_AREA", channel=current_channel,
                                outcome=rebound_outcome, transition_state="SECOND_BALL",
                                detail={"xg": round(float(rebound_xg), 3), "chance_type": "SAVE_REBOUND",
                                        "second_ball": True, "rebound_from_player_id": shooter.player_id},
                            )
                            if rebound_outcome == "GOAL":
                                possession_end_outcome = "GOAL"
                    elif action in {"PARRY", "TIP_OVER", "REFLEX_SAVE"} and rng.random() < 0.46:
                        execute_corner(
                            attacking_club=attacking_club, defending_club=defending_club, minute=min(120, minute + 1),
                            attack_players=attack_players, defend_players=defend_players,
                        )

                action_sequence += 1
                record_possession_event(
                    minute=minute, possession_sequence=possession_sequence, action_sequence=action_sequence,
                    event_type="POSSESSION_END", club_id=attacking_club, opponent_club_id=defending_club,
                    player_id=shooter.player_id, origin_zone=current_zone, destination_zone=current_zone,
                    channel=current_channel, outcome=possession_end_outcome,
                    transition_state=transition_state,
                )


            process_scheduled_medical_incidents(end)
            self._append_segment_statistics(
                segment_statistics=segment_statistics,
                segment=segment_index,
                start=start,
                end=end,
                state=state,
                score=score,
                shots=shots,
                possession_units=possession_units,
                player_metrics=player_metrics,
                team_metrics=team_metrics,
            )

        for index, (start, end) in enumerate(REGULATION_SEGMENTS, start=1):
            process_segment(index, start, end)
        regulation_home = score[state.home.club_id]
        regulation_away = score[state.away.club_id]

        decision_stage = RESOLUTION_REGULATION
        if rules.requires_winner and regulation_home == regulation_away:
            if rules.allows_extra_time:
                for index, (start, end) in enumerate(EXTRA_TIME_SEGMENTS, start=7):
                    process_segment(index, start, end, extra_time=True)
                decision_stage = RESOLUTION_EXTRA_TIME
            elif not rules.allows_penalties:
                raise ValueError("Winner-required match has no draw-resolution rule.")

        final_home = score[state.home.club_id]
        final_away = score[state.away.club_id]
        extra_home = final_home - regulation_home
        extra_away = final_away - regulation_away
        penalties = None
        if rules.requires_winner and final_home == final_away:
            if not rules.allows_penalties:
                raise ValueError("Winner-required match remained drawn without penalties.")
            penalties = self._shootout(state=state, seed=seed, non_goal_events=non_goal_events)
            decision_stage = RESOLUTION_PENALTIES

        resolution = SportingResolutionV2(
            regulation_home_score=regulation_home,
            regulation_away_score=regulation_away,
            extra_time_home_goals=extra_home,
            extra_time_away_goals=extra_away,
            home_penalties=penalties[0] if penalties else None,
            away_penalties=penalties[1] if penalties else None,
            decision_stage=decision_stage,
        )
        result = SimulationResult(home_score=final_home, away_score=final_away)

        events, team_rows, player_rows = self._build_report_rows(
            state=state,
            seed=seed,
            non_goal_events=non_goal_events,
            goal_events=goal_events,
            result=result,
            resolution=resolution,
            player_metrics=player_metrics,
        )
        tactical_rows = tuple(
            TacticalDecisionV22(
                sequence=index + 1,
                minute=row["minute"],
                phase=row["phase"],
                club_id=row["club_id"],
                source=row["source"],
                trigger_type=row["trigger_type"],
                previous_attacking_strategy=row["previous_attack"],
                previous_defensive_strategy=row["previous_defence"],
                attacking_strategy=row["attack"],
                defensive_strategy=row["defence"],
                home_score=row["home_score"],
                away_score=row["away_score"],
                own_red_cards=row["own_reds"],
                opponent_red_cards=row["opp_reds"],
                command_ref=row["command_ref"],
                effect=tuple(sorted((row.get("effect") or {}).items())),
            )
            for index, row in enumerate(decisions)
        )

        advanced = self._build_advanced_analytics(
            state=state,
            events=events,
            team_rows=team_rows,
            player_rows=player_rows,
            shots=shots,
            possession_units=possession_units,
            player_metrics=player_metrics,
            team_metrics=team_metrics,
            segment_statistics=segment_statistics,
            result=result,
            match_minutes=120 if decision_stage in {RESOLUTION_EXTRA_TIME, RESOLUTION_PENALTIES} else 90,
            current=current,
            set_piece_events=set_piece_events,
            referee_events=referee_events,
            medical_events=medical_events,
            defensive_events=defensive_events,
            possession_events=possession_events,
            pressing_events=pressing_events,
            pass_events=pass_events,
            possession_records=possession_records,
            pass_network_edges=pass_network_edges,
        )
        report = MatchReportV3(
            events=events,
            team_statistics=team_rows,
            player_statistics=player_rows,
            tactical_decisions=tactical_rows,
            advanced_analytics=advanced,
        )
        return MatchV3Outcome(result=result, resolution=resolution, report=report)

    # ------------------------------------------------------------------
    # Causal football primitives
    # ------------------------------------------------------------------
    def _possession_share(self, *, state, evaluation, current, minute, home_reds, away_reds):
        diff = evaluation.home.midfield - evaluation.away.midfield
        share = 0.50 + diff * 0.0030
        share += ATTACK_POSSESSION_BONUS[current[state.home.club_id][0]]
        share -= ATTACK_POSSESSION_BONUS[current[state.away.club_id][0]]
        share -= home_reds * 0.055
        share += away_reds * 0.055
        # Home side gets a small territorial rather than direct-goal advantage.
        share += 0.012
        share += self._environment_effects().home_territorial_bonus
        return _clamp(share, MIN_POSSESSION_SHARE, MAX_POSSESSION_SHARE)

    def _environment_effects(self):
        return getattr(
            self, "_runtime_environment_effects",
            effects_for_environment(MatchEnvironmentState()),
        )

    def _environment_injury_events(self, *, state, seed, existing_events, effects):
        """Add only the incremental injury risk caused by harsh conditions.

        The legacy injury generator remains the neutral baseline. This layer adds
        deterministic environment-attributable incidents rather than resampling
        or rewriting baseline medical evidence.
        """
        incremental = max(0.0, float(effects.injury_risk_multiplier) - 1.0)
        if incremental <= 0.0:
            return []
        existing_injured = {row.player_id for row in existing_events if row.event_type == EVENT_INJURY}
        next_sequence = max((row.sequence for row in existing_events), default=0) + 1
        rows = []
        for team_index, team in enumerate((state.home, state.away)):
            rng = _domain_rng(seed, DOMAIN_ENVIRONMENT_INJURY ^ ((team_index + 1) * 0x9E3779B97F4A7C15))
            probability = min(0.16, incremental * 0.11)
            if rng.random() >= probability:
                continue
            candidates = [p for p in team.starters if p.player_id not in existing_injured]
            if not candidates:
                continue
            player = _weighted_choice(
                rng, candidates,
                lambda p: 30 + getattr(p, "fatigue_index", 0)
                + max(0, 70 - _rating(p, "natural_fitness"))
                + max(0, 60 - _rating(p, "agility")) * 0.4,
            )
            minute = 18 + int(rng.random() * 68)
            severe = effects.injury_risk_multiplier >= 1.75 and rng.random() < 0.18
            detail = {
                "injury_code": "MATCH_ENVIRONMENT_MODERATE" if severe else "MATCH_ENVIRONMENT_MINOR",
                "expected_recovery_days": 10 if severe else 3,
                "training_restriction": "PROHIBITED" if severe else "LIMITED",
                "match_availability": "UNAVAILABLE" if severe else "AVAILABLE",
                "environment_related": True,
                "weather_condition": state.environment.weather_condition,
                "pitch_quality": state.environment.pitch_quality,
            }
            rows.append(ReportEventV2(
                sequence=next_sequence, minute=minute, phase=_phase(minute),
                event_type=EVENT_INJURY, club_id=team.club_id, player_id=player.player_id,
                detail=tuple(sorted(detail.items())),
            ))
            next_sequence += 1
            existing_injured.add(player.player_id)
        return rows

    @staticmethod
    def _is_goalkeeper(player):
        return getattr(player, "lineup_slot", "") == "GK" or getattr(player, "natural_position", "") == "GK"

    def _goalkeeper(self, players):
        players = list(players)
        return next((p for p in players if getattr(p, "lineup_slot", "") == "GK"), None) or next(
            (p for p in players if getattr(p, "natural_position", "") == "GK"), None
        )

    @staticmethod
    def _player_map(team):
        return {p.player_id: p for p in (*team.starters, *team.substitutes)}

    def _active_players_for_team(self, *, team, events, minute, club_id):
        active = {p.player_id: p for p in team.starters}
        bench = {p.player_id: p for p in team.substitutes}
        all_players = self._player_map(team)
        for event in sorted(events, key=lambda row: (row.minute, row.sequence)):
            if event.club_id != club_id or event.minute > minute:
                continue
            if event.event_type == EVENT_SUBSTITUTION:
                outgoing = active.pop(event.player_id, None)
                incoming = bench.pop(event.secondary_player_id, None)
                detail = event.detail_payload
                outgoing_slot = outgoing.lineup_slot if outgoing is not None else ""
                outgoing_role = outgoing.tactical_role if outgoing is not None else "AUTO"
                if outgoing is None and detail.get("medical"):
                    # The injury event is ordered before its medical replacement.
                    # Runtime substitutes do not carry their assigned slot in the
                    # frozen bench row, so medical substitution evidence preserves it.
                    original = all_players.get(event.player_id)
                    outgoing_slot = str(detail.get("outgoing_slot") or getattr(original, "lineup_slot", ""))
                    outgoing_role = str(detail.get("outgoing_tactical_role") or getattr(original, "tactical_role", "AUTO"))
                if incoming is not None and outgoing_slot:
                    incoming = replace(
                        incoming,
                        lineup_slot=outgoing_slot,
                        tactical_role=outgoing_role,
                        position_familiarity=familiarity_from_map(
                            incoming.natural_position,
                            incoming.position_familiarities,
                            outgoing_slot,
                        ),
                    )
                    active[incoming.player_id] = incoming
            elif event.event_type in {EVENT_RED, EVENT_SECOND_YELLOW}:
                active.pop(event.player_id, None)
            elif event.event_type == EVENT_INJURY and event.detail_payload.get("match_availability") == "UNAVAILABLE":
                active.pop(event.player_id, None)
        return list(active.values())

    def _lineup_strength_factor(self, *, state, club_id, events, minute):
        team = state.home if club_id == state.home.club_id else state.away
        active = self._active_players_for_team(
            team=team, events=events, minute=minute, club_id=club_id
        )
        if not active:
            return 0.70
        base = sum(
            float(_rating(p, "overall")) * execution_fit(p.position_familiarity)
            for p in team.starters
        ) / len(team.starters)
        current = sum(
            self._effective_rating(
                p, "overall", minute=minute,
                attacking_strategy="BALANCED", defensive_strategy="BALANCED"
            )
            for p in active
        ) / len(active)
        quality = ((current + 1.0) / (base + 1.0)) ** 0.35
        headcount = (len(active) / 11.0) ** 0.30
        return max(0.70, min(1.15, quality * headcount))

    def _fatigue_load(self, player: PlayerState, minute: int, attacking_strategy: str, defensive_strategy: str) -> float:
        stamina = _rating(player, "stamina")
        natural = _rating(player, "natural_fitness")
        base = float(getattr(player, "fatigue_index", 0))
        minute_load = minute * (0.48 + max(0.0, 75 - stamina) * 0.006)
        fitness_relief = max(0.0, natural - 50) * 0.08
        workload = minute * (
            ATTACK_WORKLOAD.get(attacking_strategy, 0.0)
            + DEFENCE_WORKLOAD.get(defensive_strategy, 0.0)
        )
        role_load = role_behaviour(player.tactical_role, player.lineup_slot, "fatigue") if player.lineup_slot else 1.0
        workload *= role_load
        familiarity_cost = max(0.0, 85.0 - float(player.position_familiarity)) * 0.055
        environment_load = minute * self._environment_effects().fatigue_per_minute
        return _clamp(base + minute_load + workload + familiarity_cost + environment_load - fitness_relief, 0.0, 100.0)

    def _effective_rating(self, player, attr, *, minute, attacking_strategy, defensive_strategy):
        raw = float(_rating(player, attr))
        fatigue = self._fatigue_load(player, minute, attacking_strategy, defensive_strategy)
        positional_fit = execution_fit(player.position_familiarity)
        if attr in {"positioning", "decision_making", "anticipation", "marking", "off_ball", "teamwork", "vision"}:
            positional_fit = positional_fit ** 1.22
        elif attr in {"pace", "acceleration", "strength", "jumping", "natural_fitness"}:
            positional_fit = 0.88 + (positional_fit - 0.65) * (0.12 / 0.35)
        penalty_rows = getattr(self, "_runtime_medical_penalties", {}).get(player.player_id, ())
        medical_penalty = max((float(value) for start_minute, value in penalty_rows if int(start_minute) <= int(minute)), default=0.0)
        return raw * positional_fit * (1.0 - fatigue * 0.0022) * (1.0 - medical_penalty)

    def _effective_avg(self, players, attr, *, minute, attacking_strategy, defensive_strategy, default=50.0):
        rows = list(players)
        if not rows:
            return float(default)
        return sum(
            self._effective_rating(
                player, attr, minute=minute,
                attacking_strategy=attacking_strategy,
                defensive_strategy=defensive_strategy,
            )
            for player in rows
        ) / len(rows)

    def _pass_weight(self, player, *, minute, attacking_strategy, defensive_strategy):
        base = (
            0.38 * self._effective_rating(player, "passing", minute=minute, attacking_strategy=attacking_strategy, defensive_strategy=defensive_strategy)
            + 0.25 * self._effective_rating(player, "vision", minute=minute, attacking_strategy=attacking_strategy, defensive_strategy=defensive_strategy)
            + 0.22 * self._effective_rating(player, "decision_making", minute=minute, attacking_strategy=attacking_strategy, defensive_strategy=defensive_strategy)
            + 0.15 * self._effective_rating(player, "teamwork", minute=minute, attacking_strategy=attacking_strategy, defensive_strategy=defensive_strategy)
        )
        return base * role_behaviour(player.tactical_role, player.lineup_slot, "pass")

    @staticmethod
    def _initial_possession_channel(rng, attacking_strategy):
        if attacking_strategy == "WIDE_PLAY":
            return "LEFT" if rng.random() < 0.5 else "RIGHT"
        roll = rng.random()
        if roll < 0.24:
            return "LEFT"
        if roll > 0.76:
            return "RIGHT"
        return "CENTRE"

    def _possession_start_weight(self, player, *, minute, zone, attacking_strategy, defensive_strategy):
        slot = str(player.lineup_slot or player.natural_position or "")
        base = (
            0.34 * self._effective_rating(player, "passing", minute=minute, attacking_strategy=attacking_strategy, defensive_strategy=defensive_strategy)
            + 0.24 * self._effective_rating(player, "first_touch", minute=minute, attacking_strategy=attacking_strategy, defensive_strategy=defensive_strategy)
            + 0.22 * self._effective_rating(player, "decision_making", minute=minute, attacking_strategy=attacking_strategy, defensive_strategy=defensive_strategy)
            + 0.20 * self._effective_rating(player, "positioning", minute=minute, attacking_strategy=attacking_strategy, defensive_strategy=defensive_strategy)
        )
        if zone == "DEFENSIVE_THIRD":
            positional = 1.28 if any(token in slot for token in ("GK", "CB", "LB", "RB", "DM")) else 0.82
        elif zone == "MIDDLE_THIRD":
            positional = 1.25 if any(token in slot for token in ("DM", "CM", "AM", "LM", "RM", "LB", "RB")) else 0.92
        else:
            positional = 1.24 if any(token in slot for token in ("AM", "LW", "RW", "CF", "ST", "SS")) else 0.90
        return max(1.0, base * positional * role_behaviour(player.tactical_role, player.lineup_slot, "pass"))

    def _pass_intent(self, rng, *, passer, current_zone, current_channel, attacking_strategy, transition_state, minute):
        vision = self._effective_rating(passer, "vision", minute=minute, attacking_strategy=attacking_strategy, defensive_strategy="BALANCED")
        crossing = self._effective_rating(passer, "crossing", minute=minute, attacking_strategy=attacking_strategy, defensive_strategy="BALANCED")
        roll = rng.random()
        if current_zone == "DEFENSIVE_THIRD":
            direct_bias = 0.18 if attacking_strategy in {"DIRECT", "COUNTER_ATTACK"} else 0.0
            if roll < 0.48 + direct_bias:
                destination_zone, pass_type, delta = "MIDDLE_THIRD", "PROGRESSIVE", -0.035
            elif roll < 0.72:
                destination_zone, pass_type, delta = "DEFENSIVE_THIRD", "SHORT", 0.025
            elif roll < 0.90:
                destination_zone, pass_type, delta = "MIDDLE_THIRD", "SWITCH", -0.030
            else:
                destination_zone, pass_type, delta = "FINAL_THIRD", "PROGRESSIVE", -0.085
        elif current_zone == "MIDDLE_THIRD":
            through_bias = _clamp((vision - 55.0) * 0.0025, -0.03, 0.08)
            counter_bias = 0.08 if transition_state == "COUNTER" else 0.0
            if roll < 0.43 + counter_bias:
                destination_zone, pass_type, delta = "FINAL_THIRD", "PROGRESSIVE", -0.045
            elif roll < 0.58 + counter_bias + through_bias:
                destination_zone, pass_type, delta = "PENALTY_AREA", "THROUGH_BALL", -0.105
            elif roll < 0.78:
                destination_zone, pass_type, delta = "MIDDLE_THIRD", "SHORT", 0.018
            elif roll < 0.92:
                destination_zone, pass_type, delta = "MIDDLE_THIRD", "SWITCH", -0.025
            else:
                destination_zone, pass_type, delta = "DEFENSIVE_THIRD", "RECYCLE", 0.045
        elif current_zone == "FINAL_THIRD":
            wide = current_channel in {"LEFT", "RIGHT"}
            cross_bias = 0.15 if attacking_strategy == "WIDE_PLAY" else 0.0
            if wide and roll < 0.22 + cross_bias + _clamp((crossing - 60.0) * 0.002, -0.03, 0.05):
                destination_zone, pass_type, delta = "PENALTY_AREA", "CROSS", -0.095
            elif roll < 0.57 + (0.06 if transition_state == "COUNTER" else 0.0):
                destination_zone, pass_type, delta = "PENALTY_AREA", "THROUGH_BALL", -0.090
            elif roll < 0.80:
                destination_zone, pass_type, delta = "FINAL_THIRD", "SHORT", 0.005
            elif roll < 0.92:
                destination_zone, pass_type, delta = "FINAL_THIRD", "SWITCH", -0.025
            else:
                destination_zone, pass_type, delta = "MIDDLE_THIRD", "RECYCLE", 0.040
        else:
            destination_zone, pass_type, delta = "PENALTY_AREA", "SHORT", -0.020

        destination_channel = current_channel
        if pass_type == "SWITCH":
            destination_channel = "RIGHT" if current_channel == "LEFT" else ("LEFT" if current_channel == "RIGHT" else ("LEFT" if rng.random() < 0.5 else "RIGHT"))
        elif pass_type in {"THROUGH_BALL", "PROGRESSIVE"} and rng.random() < 0.22:
            destination_channel = CHANNELS[min(len(CHANNELS) - 1, int(rng.random() * len(CHANNELS)))]
        elif pass_type == "CROSS":
            destination_channel = "CENTRE"
        return pass_type, destination_zone, destination_channel, delta

    def _pass_receiver_weight(self, player, *, minute, destination_zone, destination_channel, pass_type, attacking_strategy, defensive_strategy):
        slot = str(player.lineup_slot or player.natural_position or "")
        base = (
            0.30 * self._effective_rating(player, "off_ball", minute=minute, attacking_strategy=attacking_strategy, defensive_strategy=defensive_strategy)
            + 0.25 * self._effective_rating(player, "first_touch", minute=minute, attacking_strategy=attacking_strategy, defensive_strategy=defensive_strategy)
            + 0.20 * self._effective_rating(player, "ball_control", minute=minute, attacking_strategy=attacking_strategy, defensive_strategy=defensive_strategy)
            + 0.15 * self._effective_rating(player, "anticipation", minute=minute, attacking_strategy=attacking_strategy, defensive_strategy=defensive_strategy)
            + 0.10 * self._effective_rating(player, "pace", minute=minute, attacking_strategy=attacking_strategy, defensive_strategy=defensive_strategy)
        )
        if destination_zone == "PENALTY_AREA":
            positional = 1.36 if any(token in slot for token in ("CF", "ST", "SS", "LW", "RW", "AM")) else 0.78
        elif destination_zone == "FINAL_THIRD":
            positional = 1.25 if any(token in slot for token in ("AM", "LW", "RW", "CF", "ST", "SS", "CM")) else 0.88
        elif destination_zone == "MIDDLE_THIRD":
            positional = 1.20 if any(token in slot for token in ("DM", "CM", "AM", "LM", "RM", "LB", "RB")) else 0.93
        else:
            positional = 1.18 if any(token in slot for token in ("CB", "LB", "RB", "DM", "GK")) else 0.90
        channel_bonus = 1.0
        if destination_channel == "LEFT" and any(token in slot for token in ("LB", "LW", "LM")):
            channel_bonus = 1.18
        elif destination_channel == "RIGHT" and any(token in slot for token in ("RB", "RW", "RM")):
            channel_bonus = 1.18
        elif destination_channel == "CENTRE" and any(token in slot for token in ("CB", "DM", "CM", "AM", "CF", "ST", "SS")):
            channel_bonus = 1.10
        if pass_type == "CROSS":
            base += 0.12 * self._effective_rating(player, "heading", minute=minute, attacking_strategy=attacking_strategy, defensive_strategy=defensive_strategy)
        return max(1.0, base * positional * channel_bonus * role_behaviour(player.tactical_role, player.lineup_slot, "receive"))

    def _defender_action_weight(self, player, *, minute, defensive_strategy, attacking_strategy):
        base = (
            0.35 * self._effective_rating(player, "tackling", minute=minute, attacking_strategy=attacking_strategy, defensive_strategy=defensive_strategy)
            + 0.30 * self._effective_rating(player, "positioning", minute=minute, attacking_strategy=attacking_strategy, defensive_strategy=defensive_strategy)
            + 0.20 * self._effective_rating(player, "anticipation", minute=minute, attacking_strategy=attacking_strategy, defensive_strategy=defensive_strategy)
            + 0.15 * self._effective_rating(player, "marking", minute=minute, attacking_strategy=attacking_strategy, defensive_strategy=defensive_strategy)
        )
        role_factor = role_behaviour(player.tactical_role, player.lineup_slot, "defender")
        press_factor = role_behaviour(player.tactical_role, player.lineup_slot, "press")
        return base * role_factor * (0.92 + 0.08 * press_factor)

    def _defensive_pressure(self, players, *, minute, defensive_strategy, attacking_strategy):
        base = sum(
            self._defender_action_weight(
                p,
                minute=minute,
                defensive_strategy=defensive_strategy,
                attacking_strategy=attacking_strategy,
            )
            for p in players
        ) / max(1, len(players))
        tactical = {
            "BALANCED": 0.0,
            "HIGH_PRESS": 7.0,
            "MID_BLOCK": 3.0,
            "LOW_BLOCK": -1.0,
            "MAN_MARKING": 4.0,
            "ZONAL_COMPACT": 3.5,
        }.get(defensive_strategy, 0.0)
        return base + tactical

    def _pressing_player_weight(self, player, *, minute, defensive_strategy, attacking_strategy):
        return max(1.0, (
            0.22 * self._effective_rating(player, "aggression", minute=minute, attacking_strategy=attacking_strategy, defensive_strategy=defensive_strategy)
            + 0.18 * self._effective_rating(player, "stamina", minute=minute, attacking_strategy=attacking_strategy, defensive_strategy=defensive_strategy)
            + 0.16 * self._effective_rating(player, "pace", minute=minute, attacking_strategy=attacking_strategy, defensive_strategy=defensive_strategy)
            + 0.16 * self._effective_rating(player, "anticipation", minute=minute, attacking_strategy=attacking_strategy, defensive_strategy=defensive_strategy)
            + 0.14 * self._effective_rating(player, "teamwork", minute=minute, attacking_strategy=attacking_strategy, defensive_strategy=defensive_strategy)
            + 0.14 * self._effective_rating(player, "tackling", minute=minute, attacking_strategy=attacking_strategy, defensive_strategy=defensive_strategy)
        ) * role_behaviour(player.tactical_role, player.lineup_slot, "press"))

    def _pressing_team_score(self, players, *, minute, defensive_strategy, attacking_strategy):
        rows = [p for p in players if not self._is_goalkeeper(p)] or list(players)
        if not rows:
            return 50.0
        return sum(
            self._pressing_player_weight(p, minute=minute, defensive_strategy=defensive_strategy, attacking_strategy=attacking_strategy)
            for p in rows
        ) / len(rows)

    def _pressing_context(self, rng, *, defend_players, receiver, minute, defensive_strategy, attacking_strategy,
                          origin_zone, destination_zone, destination_channel, pass_type, transition_state):
        profile = shape_for_strategy(defensive_strategy)
        pressers = [p for p in defend_players if not self._is_goalkeeper(p)] or list(defend_players)
        if not pressers:
            return None
        team_score = self._pressing_team_score(pressers, minute=minute, defensive_strategy=defensive_strategy, attacking_strategy=attacking_strategy)
        trigger = "BUILDUP_RECEIPT"
        if destination_channel in {"LEFT", "RIGHT"} and defensive_strategy in {"HIGH_PRESS", "MID_BLOCK", "ZONAL_COMPACT"}:
            trigger = "WIDE_TRAP"
        elif destination_channel == "CENTRE" and destination_zone in {"FINAL_THIRD", "PENALTY_AREA"} and profile.compactness >= 75:
            trigger = "CENTRAL_COMPACTNESS"
        elif pass_type in {"PROGRESSIVE", "THROUGH_BALL"}:
            trigger = "PROGRESSIVE_PASS"
        elif pass_type == "RECYCLE" or zone_index(destination_zone) < zone_index(origin_zone):
            trigger = "BACK_PASS"
        receiver_control = (
            self._effective_rating(receiver, "first_touch", minute=minute, attacking_strategy="BALANCED", defensive_strategy="BALANCED")
            + self._effective_rating(receiver, "composure", minute=minute, attacking_strategy="BALANCED", defensive_strategy="BALANCED")
        ) / 2.0
        trigger_probability = (
            0.055 + profile.press_intensity * 0.42 * zone_press_factor(defensive_strategy, destination_zone)
            + (team_score - 55.0) * 0.0018
        )
        if trigger == "WIDE_TRAP":
            trigger_probability += profile.trap_intensity * 0.11
        if trigger == "BACK_PASS" and defensive_strategy == "HIGH_PRESS":
            trigger_probability += 0.09
        if transition_state == "COUNTER":
            trigger_probability *= 0.72
        trigger_probability = _clamp(trigger_probability, 0.06, 0.78)
        if rng.random() > trigger_probability:
            return None
        presser = _weighted_choice(rng, pressers, lambda p: self._pressing_player_weight(p, minute=minute, defensive_strategy=defensive_strategy, attacking_strategy=attacking_strategy))
        presser_score = self._pressing_player_weight(presser, minute=minute, defensive_strategy=defensive_strategy, attacking_strategy=attacking_strategy)
        strength = _clamp(0.42 + profile.press_intensity * 0.28 + (presser_score - receiver_control) * 0.003, 0.25, 0.92)
        completion_penalty = _clamp(0.010 + strength * 0.060, 0.018, 0.068)
        return {"presser": presser, "trigger": trigger, "strength": strength, "completion_penalty": completion_penalty, "trigger_probability": trigger_probability}

    def _foul_probability(self, defender, defensive_strategy):
        aggression = _rating(defender, "aggression")
        tackling = _rating(defender, "tackling")
        press = 0.055 if defensive_strategy == "HIGH_PRESS" else 0.0
        return _clamp(0.20 + max(0, aggression - tackling) * 0.003 + press, 0.12, 0.36)

    def _delivery_quality(self, player, *, minute, crossing=True):
        set_piece = self._effective_rating(player, "set_pieces", minute=minute, attacking_strategy="BALANCED", defensive_strategy="BALANCED")
        technical = self._effective_rating(player, "crossing" if crossing else "passing", minute=minute, attacking_strategy="BALANCED", defensive_strategy="BALANCED")
        composure = self._effective_rating(player, "composure", minute=minute, attacking_strategy="BALANCED", defensive_strategy="BALANCED")
        decisions = self._effective_rating(player, "decision_making", minute=minute, attacking_strategy="BALANCED", defensive_strategy="BALANCED")
        quality = 0.46 * set_piece + 0.34 * technical + 0.12 * composure + 0.08 * decisions
        return quality * self._environment_effects().set_piece_delivery_multiplier

    def _penalty_taker_weight(self, player, *, minute):
        return (
            0.38 * self._effective_rating(player, "composure", minute=minute, attacking_strategy="BALANCED", defensive_strategy="BALANCED")
            + 0.34 * self._effective_rating(player, "set_pieces", minute=minute, attacking_strategy="BALANCED", defensive_strategy="BALANCED")
            + 0.28 * self._effective_rating(player, "finishing", minute=minute, attacking_strategy="BALANCED", defensive_strategy="BALANCED")
        )

    def _free_kick_taker_weight(self, player, *, minute):
        return (
            0.42 * self._effective_rating(player, "set_pieces", minute=minute, attacking_strategy="BALANCED", defensive_strategy="BALANCED")
            + 0.24 * self._effective_rating(player, "shooting", minute=minute, attacking_strategy="BALANCED", defensive_strategy="BALANCED")
            + 0.20 * self._effective_rating(player, "long_shots", minute=minute, attacking_strategy="BALANCED", defensive_strategy="BALANCED")
            + 0.14 * self._effective_rating(player, "composure", minute=minute, attacking_strategy="BALANCED", defensive_strategy="BALANCED")
        )

    def _corner_taker_weight(self, player, *, minute):
        return (
            0.48 * self._effective_rating(player, "set_pieces", minute=minute, attacking_strategy="BALANCED", defensive_strategy="BALANCED")
            + 0.37 * self._effective_rating(player, "crossing", minute=minute, attacking_strategy="BALANCED", defensive_strategy="BALANCED")
            + 0.15 * self._effective_rating(player, "composure", minute=minute, attacking_strategy="BALANCED", defensive_strategy="BALANCED")
        )

    def _aerial_attacker_weight(self, player, *, minute, routine):
        heading = self._effective_rating(player, "heading", minute=minute, attacking_strategy="BALANCED", defensive_strategy="BALANCED")
        jumping = self._effective_rating(player, "jumping", minute=minute, attacking_strategy="BALANCED", defensive_strategy="BALANCED")
        strength = self._effective_rating(player, "strength", minute=minute, attacking_strategy="BALANCED", defensive_strategy="BALANCED")
        off_ball = self._effective_rating(player, "off_ball", minute=minute, attacking_strategy="BALANCED", defensive_strategy="BALANCED")
        positioning = self._effective_rating(player, "positioning", minute=minute, attacking_strategy="BALANCED", defensive_strategy="BALANCED")
        weight = 0.31 * heading + 0.24 * jumping + 0.17 * strength + 0.16 * off_ball + 0.12 * positioning
        family = slot_family(player.lineup_slot)
        if family in {"centre_back", "striker"}:
            weight *= 1.10
        if routine == "NEAR_POST" and family == "striker":
            weight *= 1.06
        if routine == "FAR_POST" and family == "centre_back":
            weight *= 1.06
        return weight

    def _aerial_defender_weight(self, player, *, minute):
        return (
            0.28 * self._effective_rating(player, "marking", minute=minute, attacking_strategy="BALANCED", defensive_strategy="BALANCED")
            + 0.24 * self._effective_rating(player, "jumping", minute=minute, attacking_strategy="BALANCED", defensive_strategy="BALANCED")
            + 0.18 * self._effective_rating(player, "strength", minute=minute, attacking_strategy="BALANCED", defensive_strategy="BALANCED")
            + 0.16 * self._effective_rating(player, "positioning", minute=minute, attacking_strategy="BALANCED", defensive_strategy="BALANCED")
            + 0.14 * self._effective_rating(player, "anticipation", minute=minute, attacking_strategy="BALANCED", defensive_strategy="BALANCED")
        )

    def _keeper_cross_command(self, defenders, *, minute):
        goalkeeper = self._goalkeeper(defenders)
        if goalkeeper is None:
            return 35.0
        command = (
            self._effective_rating(goalkeeper, "gk_handling", minute=minute, attacking_strategy="BALANCED", defensive_strategy="BALANCED")
            + self._effective_rating(goalkeeper, "gk_positioning", minute=minute, attacking_strategy="BALANCED", defensive_strategy="BALANCED")
            + self._effective_rating(goalkeeper, "gk_reflexes", minute=minute, attacking_strategy="BALANCED", defensive_strategy="BALANCED")
        ) / 3.0
        return command * self._environment_effects().goalkeeper_handling_multiplier

    def _ground_duel_attack_probability(self, *, attacker, defender, minute, attack_strategy, defence_strategy):
        attack = (
            0.36 * self._effective_rating(attacker, "dribbling", minute=minute, attacking_strategy=attack_strategy, defensive_strategy="BALANCED")
            + 0.24 * self._effective_rating(attacker, "agility", minute=minute, attacking_strategy=attack_strategy, defensive_strategy="BALANCED")
            + 0.22 * self._effective_rating(attacker, "ball_control", minute=minute, attacking_strategy=attack_strategy, defensive_strategy="BALANCED")
            + 0.18 * self._effective_rating(attacker, "acceleration", minute=minute, attacking_strategy=attack_strategy, defensive_strategy="BALANCED")
        )
        defence = (
            0.40 * self._effective_rating(defender, "tackling", minute=minute, attacking_strategy="BALANCED", defensive_strategy=defence_strategy)
            + 0.24 * self._effective_rating(defender, "anticipation", minute=minute, attacking_strategy="BALANCED", defensive_strategy=defence_strategy)
            + 0.18 * self._effective_rating(defender, "strength", minute=minute, attacking_strategy="BALANCED", defensive_strategy=defence_strategy)
            + 0.18 * self._effective_rating(defender, "positioning", minute=minute, attacking_strategy="BALANCED", defensive_strategy=defence_strategy)
        )
        tactical = -0.025 if defence_strategy in {"MAN_MARKING", "HIGH_PRESS"} else 0.0
        return _clamp(
            0.50 + (attack - defence) * 0.004 + tactical + self._environment_effects().dribble_success_delta,
            0.18, 0.82,
        )

    def _defensive_error_probability(self, defender, *, minute, defensive_strategy):
        concentration = self._effective_rating(defender, "concentration", minute=minute, attacking_strategy="BALANCED", defensive_strategy=defensive_strategy)
        decisions = self._effective_rating(defender, "decision_making", minute=minute, attacking_strategy="BALANCED", defensive_strategy=defensive_strategy)
        positioning = self._effective_rating(defender, "positioning", minute=minute, attacking_strategy="BALANCED", defensive_strategy=defensive_strategy)
        fatigue = self._fatigue_load(defender, minute, "BALANCED", defensive_strategy)
        pressure = 0.006 if defensive_strategy == "HIGH_PRESS" else 0.0
        poor_surface = max(0.0, -self._environment_effects().dribble_success_delta) * 0.08
        probability = 0.011 + max(0.0, 62.0 - (concentration + decisions + positioning) / 3.0) * 0.0007
        probability += max(0.0, fatigue - 70.0) * 0.00045 + pressure + poor_surface
        return _clamp(probability, 0.004, 0.050)

    def _sweeper_keeper_action(self, rng, *, goalkeeper, shooter, minute, xg, attack_strategy):
        role = resolve_tactical_role(goalkeeper.tactical_role, goalkeeper.lineup_slot or "GK")
        attempt = 0.07 + (0.24 if role == "SWEEPER_KEEPER" else 0.0)
        if attack_strategy in {"DIRECT", "COUNTER_ATTACK"}:
            attempt += 0.07
        if xg >= 0.35:
            attempt += 0.05
        if rng.random() >= _clamp(attempt, 0.05, 0.42):
            return None
        keeper = (
            0.38 * self._effective_rating(goalkeeper, "gk_one_on_one", minute=minute, attacking_strategy="BALANCED", defensive_strategy="BALANCED")
            + 0.30 * self._effective_rating(goalkeeper, "gk_positioning", minute=minute, attacking_strategy="BALANCED", defensive_strategy="BALANCED")
            + 0.18 * self._effective_rating(goalkeeper, "decision_making", minute=minute, attacking_strategy="BALANCED", defensive_strategy="BALANCED")
            + 0.14 * self._effective_rating(goalkeeper, "pace", minute=minute, attacking_strategy="BALANCED", defensive_strategy="BALANCED")
        )
        attacker = (
            0.36 * self._effective_rating(shooter, "off_ball", minute=minute, attacking_strategy=attack_strategy, defensive_strategy="BALANCED")
            + 0.30 * self._effective_rating(shooter, "first_touch", minute=minute, attacking_strategy=attack_strategy, defensive_strategy="BALANCED")
            + 0.20 * self._effective_rating(shooter, "pace", minute=minute, attacking_strategy=attack_strategy, defensive_strategy="BALANCED")
            + 0.14 * self._effective_rating(shooter, "composure", minute=minute, attacking_strategy=attack_strategy, defensive_strategy="BALANCED")
        )
        success_prob = _clamp(0.52 + (keeper - attacker) * 0.0042, 0.22, 0.80)
        success = rng.random() < success_prob
        action = "RUSH_OUT" if role == "SWEEPER_KEEPER" else "EMERGENCY_RUSH"
        return action, success, (1.22 if role == "SWEEPER_KEEPER" else 1.18)

    def _keeper_cross_intervention(self, rng, *, goalkeeper, delivery_quality, routine, minute):
        command = self._keeper_cross_command([goalkeeper], minute=minute)
        crowd_penalty = 0.06 if routine == "CROWD_KEEPER" else 0.0
        attempt_prob = _clamp(0.09 + command * 0.0020 - crowd_penalty, 0.08, 0.30)
        if rng.random() >= attempt_prob:
            return None, ""
        handling = self._effective_rating(goalkeeper, "gk_handling", minute=minute, attacking_strategy="BALANCED", defensive_strategy="BALANCED") * self._environment_effects().goalkeeper_handling_multiplier
        positioning = self._effective_rating(goalkeeper, "gk_positioning", minute=minute, attacking_strategy="BALANCED", defensive_strategy="BALANCED")
        decisions = self._effective_rating(goalkeeper, "decision_making", minute=minute, attacking_strategy="BALANCED", defensive_strategy="BALANCED")
        quality_gap = (handling + positioning + decisions) / 3.0 - float(delivery_quality)
        success_prob = _clamp(0.73 + quality_gap * 0.0030 - crowd_penalty, 0.42, 0.90)
        if rng.random() > success_prob:
            return "MISJUDGE", "MISJUDGED"
        claim_prob = _clamp(0.55 + (handling - 60.0) * 0.006 - max(0.0, float(delivery_quality) - 70.0) * 0.004, 0.28, 0.78)
        if rng.random() < claim_prob:
            return "CLAIM", "HELD"
        return "PUNCH", ("PUNCHED_CLEAR" if rng.random() < 0.66 else "PUNCHED_CONTESTED")

    def _goalkeeper_save_action(self, *, goalkeeper, shooter, xg, minute, chance_type, rng):
        handling = self._effective_rating(goalkeeper, "gk_handling", minute=minute, attacking_strategy="BALANCED", defensive_strategy="BALANCED") * self._environment_effects().goalkeeper_handling_multiplier
        reflexes = self._effective_rating(goalkeeper, "gk_reflexes", minute=minute, attacking_strategy="BALANCED", defensive_strategy="BALANCED")
        one_on_one = self._effective_rating(goalkeeper, "gk_one_on_one", minute=minute, attacking_strategy="BALANCED", defensive_strategy="BALANCED")
        if xg >= 0.34 or "ONE_ON_ONE" in str(chance_type):
            action = "ONE_ON_ONE_SAVE"
            hold_prob = _clamp(0.20 + (handling - 50.0) * 0.004, 0.12, 0.42)
        elif xg <= 0.075:
            action = "CATCH" if rng.random() < _clamp(0.68 + (handling - 50.0) * 0.005, 0.50, 0.90) else "DIVING_SAVE"
            hold_prob = 0.78 if action == "CATCH" else 0.52
        else:
            if rng.random() < _clamp(0.34 + (reflexes - 50.0) * 0.004, 0.25, 0.60):
                action = "REFLEX_SAVE"
            elif rng.random() < 0.24:
                action = "TIP_OVER"
            else:
                action = "PARRY"
            hold_prob = _clamp(0.28 + (handling - 50.0) * 0.005 - xg * 0.18, 0.14, 0.58)
        if action == "TIP_OVER":
            return action, "PARRIED_SAFE"
        if rng.random() < hold_prob:
            return action, "HELD"
        danger = _clamp(0.25 + xg * 0.55 - (handling - 50.0) * 0.003, 0.12, 0.52)
        return action, ("PARRIED_DANGER" if rng.random() < danger else "PARRIED_SAFE")

    def _second_ball_weight(self, player, *, minute):
        return (
            0.34 * self._effective_rating(player, "anticipation", minute=minute, attacking_strategy="BALANCED", defensive_strategy="BALANCED")
            + 0.28 * self._effective_rating(player, "positioning", minute=minute, attacking_strategy="BALANCED", defensive_strategy="BALANCED")
            + 0.20 * self._effective_rating(player, "long_shots", minute=minute, attacking_strategy="BALANCED", defensive_strategy="BALANCED")
            + 0.18 * self._effective_rating(player, "work_rate", minute=minute, attacking_strategy="BALANCED", defensive_strategy="BALANCED")
        )

    def _penalty_xg(self, *, taker, goalkeeper, minute):
        skill = self._penalty_taker_weight(taker, minute=minute)
        gk = 50.0
        if goalkeeper is not None:
            gk = (
                self._effective_rating(goalkeeper, "gk_one_on_one", minute=minute, attacking_strategy="BALANCED", defensive_strategy="BALANCED")
                + self._effective_rating(goalkeeper, "gk_reflexes", minute=minute, attacking_strategy="BALANCED", defensive_strategy="BALANCED")
            ) / 2.0
        return _clamp(0.755 + (skill - 50) * 0.0017 - (gk - 50) * 0.0010, 0.62, 0.88)

    def _penalty_outcome(self, rng, *, xg, taker, goalkeeper, minute):
        if rng.random() < xg:
            return "GOAL"
        composure = self._effective_rating(taker, "composure", minute=minute, attacking_strategy="BALANCED", defensive_strategy="BALANCED")
        gk = 50.0 if goalkeeper is None else self._effective_rating(goalkeeper, "gk_reflexes", minute=minute, attacking_strategy="BALANCED", defensive_strategy="BALANCED")
        saved_share = _clamp(0.68 + (gk - 50) * 0.003 - (composure - 50) * 0.002, 0.48, 0.86)
        return "SAVED" if rng.random() < saved_share else "OFF_TARGET"

    def _direct_free_kick_xg(self, rng, *, taker, defenders, minute, danger):
        skill = self._free_kick_taker_weight(taker, minute=minute)
        outfield = [p for p in defenders if not self._is_goalkeeper(p)]
        wall = self._effective_avg(outfield, "jumping", minute=minute, attacking_strategy="BALANCED", defensive_strategy="BALANCED")
        base = 0.055 if danger == "ATTACKING_THIRD" else 0.025
        value = base + (skill - 50) * 0.0012 - (wall - 50) * 0.00035 + rng.random() * 0.045
        value += self._environment_effects().shot_quality_delta * 0.45
        return _clamp(value, 0.015, 0.19)

    def _direct_free_kick_outcome(self, rng, *, xg, taker, defenders, minute):
        goalkeeper = self._goalkeeper(defenders)
        gk = 50.0 if goalkeeper is None else (
            self._effective_rating(goalkeeper, "gk_reflexes", minute=minute, attacking_strategy="BALANCED", defensive_strategy="BALANCED")
            + self._effective_rating(goalkeeper, "gk_positioning", minute=minute, attacking_strategy="BALANCED", defensive_strategy="BALANCED")
        ) / 2.0
        gk *= self._environment_effects().goalkeeper_handling_multiplier
        skill = self._free_kick_taker_weight(taker, minute=minute)
        goal_prob = xg * (1.0 + (skill - 50) * 0.0030 - (gk - 50) * 0.0025)
        goal_prob *= self._environment_effects().goal_conversion_multiplier
        goal_prob = _clamp(goal_prob, 0.01, 0.25)
        if rng.random() < goal_prob:
            return "GOAL", goalkeeper
        wall_players = [p for p in defenders if not self._is_goalkeeper(p)]
        wall = self._effective_avg(wall_players, "jumping", minute=minute, attacking_strategy="BALANCED", defensive_strategy="BALANCED")
        roll = rng.random()
        block = _clamp(0.27 + (wall - 50) * 0.0022, 0.18, 0.42)
        save = _clamp(0.25 + (gk - 50) * 0.0020, 0.18, 0.42)
        if roll < block:
            return "BLOCKED", goalkeeper
        if roll < block + save:
            return "SAVED", goalkeeper
        return "OFF_TARGET", goalkeeper

    def _header_outcome(self, rng, *, xg, shooter, defenders, minute):
        goalkeeper = self._goalkeeper(defenders)
        gk = 50.0 if goalkeeper is None else (
            self._effective_rating(goalkeeper, "gk_reflexes", minute=minute, attacking_strategy="BALANCED", defensive_strategy="BALANCED")
            + self._effective_rating(goalkeeper, "gk_positioning", minute=minute, attacking_strategy="BALANCED", defensive_strategy="BALANCED")
            + self._effective_rating(goalkeeper, "gk_handling", minute=minute, attacking_strategy="BALANCED", defensive_strategy="BALANCED")
        ) / 3.0
        gk *= self._environment_effects().goalkeeper_handling_multiplier
        header = (
            self._effective_rating(shooter, "heading", minute=minute, attacking_strategy="BALANCED", defensive_strategy="BALANCED")
            + self._effective_rating(shooter, "composure", minute=minute, attacking_strategy="BALANCED", defensive_strategy="BALANCED")
        ) / 2.0
        goal_prob = xg * (1.0 + (header - 50) * 0.004 - (gk - 50) * 0.003)
        goal_prob *= self._environment_effects().goal_conversion_multiplier
        goal_prob = _clamp(goal_prob, 0.01, 0.52)
        if rng.random() < goal_prob:
            return "GOAL", goalkeeper
        roll = rng.random()
        if roll < 0.18:
            return "BLOCKED", goalkeeper
        if roll < _clamp(0.18 + 0.34 + (gk - 50) * 0.002, 0.42, 0.66):
            return "SAVED", goalkeeper
        return "OFF_TARGET", goalkeeper

    def _dribble_weight(self, player, minute, attack_strategy, defence_strategy):
        return (
            0.46 * self._effective_rating(player, "dribbling", minute=minute, attacking_strategy=attack_strategy, defensive_strategy=defence_strategy)
            + 0.28 * self._effective_rating(player, "agility", minute=minute, attacking_strategy=attack_strategy, defensive_strategy=defence_strategy)
            + 0.26 * self._effective_rating(player, "ball_control", minute=minute, attacking_strategy=attack_strategy, defensive_strategy=defence_strategy)
        )

    def _dribble_success(self, player, minute, attack_strategy, defence_strategy):
        skill = self._dribble_weight(player, minute, attack_strategy, defence_strategy)
        return _clamp(0.42 + (skill - 50) * 0.004 + self._environment_effects().dribble_success_delta, 0.24, 0.76)

    def _chance_probability(
        self, *, attacking_club, defending_club, state, evaluation,
        attack_strategy, defending_strategy, own_factor, suppression,
        attack_players, defend_players, minute,
    ):
        if attacking_club == state.home.club_id:
            attack = evaluation.home.attack
            defence = evaluation.away.defence
            home_bonus = HOME_CHANCE_BONUS
        else:
            attack = evaluation.away.attack
            defence = evaluation.home.defence
            home_bonus = 0.0
        attack_execution = self._effective_avg(
            attack_players, "decision_making", minute=minute,
            attacking_strategy=attack_strategy, defensive_strategy="BALANCED"
        ) + self._effective_avg(
            attack_players, "off_ball", minute=minute,
            attacking_strategy=attack_strategy, defensive_strategy="BALANCED"
        )
        defence_execution = self._effective_avg(
            defend_players, "positioning", minute=minute,
            attacking_strategy="BALANCED", defensive_strategy=defending_strategy
        ) + self._effective_avg(
            defend_players, "concentration", minute=minute,
            attacking_strategy="BALANCED", defensive_strategy=defending_strategy
        )
        chance = BASE_CHANCE_PROBABILITY + home_bonus
        chance += (attack - defence) * 0.0016
        chance += (attack_execution - defence_execution) * 0.00045
        chance += ATTACK_CHANCE_BONUS.get(attack_strategy, 0.0)
        chance -= DEFENCE_CHANCE_SUPPRESSION.get(defending_strategy, 0.0)
        effects = self._environment_effects()
        chance *= effects.chance_multiplier
        if attack_strategy == "WIDE_PLAY":
            chance *= effects.wide_play_multiplier
        elif attack_strategy == "DIRECT":
            chance *= effects.direct_play_multiplier
        chance *= float(own_factor.get("xg_factor", 1.0))
        chance *= float(own_factor.get("lineup_factor", 1.0))
        chance /= max(0.70, float(suppression))
        return _clamp(chance, MIN_CHANCE_PROBABILITY, MAX_CHANCE_PROBABILITY)

    def _choose_creator(self, rng, players, *, minute, attacking_strategy, defensive_strategy, fallback=None):
        candidates = [p for p in players if not self._is_goalkeeper(p)]
        if not candidates:
            return fallback
        if rng.random() < 0.16:
            return None
        return _weighted_choice(
            rng,
            candidates,
            lambda p: role_behaviour(p.tactical_role, p.lineup_slot, "creator") * (
                0.38 * self._effective_rating(p, "vision", minute=minute, attacking_strategy=attacking_strategy, defensive_strategy=defensive_strategy)
                + 0.32 * self._effective_rating(p, "passing", minute=minute, attacking_strategy=attacking_strategy, defensive_strategy=defensive_strategy)
                + 0.16 * self._effective_rating(p, "crossing", minute=minute, attacking_strategy=attacking_strategy, defensive_strategy=defensive_strategy)
                + 0.14 * self._effective_rating(p, "dribbling", minute=minute, attacking_strategy=attacking_strategy, defensive_strategy=defensive_strategy)
            ),
        )

    def _choose_shooter(self, rng, players, *, minute, attacking_strategy, defensive_strategy):
        candidates = [p for p in players if not self._is_goalkeeper(p)] or list(players)
        positional = {
            "striker": 1.60, "winger": 1.28, "attacking_midfield": 1.18,
            "wide_midfield": 0.96, "central_midfield": 0.86,
            "defensive_midfield": 0.52, "wingback": 0.50, "fullback": 0.44,
            "centre_back": 0.32, "goalkeeper": 0.02,
        }
        return _weighted_choice(
            rng,
            candidates,
            lambda p: positional.get(slot_family(p.lineup_slot), 0.8)
            * role_behaviour(p.tactical_role, p.lineup_slot, "shooter") * (
                0.40 * self._effective_rating(p, "finishing", minute=minute, attacking_strategy=attacking_strategy, defensive_strategy=defensive_strategy)
                + 0.24 * self._effective_rating(p, "positioning", minute=minute, attacking_strategy=attacking_strategy, defensive_strategy=defensive_strategy)
                + 0.20 * self._effective_rating(p, "off_ball", minute=minute, attacking_strategy=attacking_strategy, defensive_strategy=defensive_strategy)
                + 0.16 * self._effective_rating(p, "composure", minute=minute, attacking_strategy=attacking_strategy, defensive_strategy=defensive_strategy)
            ),
        )

    def _shot_xg(self, rng, *, shooter, creator, attack_strategy, defend_strategy, minute, attack_players, defend_players):
        finishing = self._effective_rating(shooter, "finishing", minute=minute, attacking_strategy=attack_strategy, defensive_strategy="BALANCED")
        positioning = self._effective_rating(shooter, "positioning", minute=minute, attacking_strategy=attack_strategy, defensive_strategy="BALANCED")
        creation = 50.0
        if creator is not None:
            creation = (
                self._effective_rating(creator, "vision", minute=minute, attacking_strategy=attack_strategy, defensive_strategy="BALANCED")
                + self._effective_rating(creator, "passing", minute=minute, attacking_strategy=attack_strategy, defensive_strategy="BALANCED")
            ) / 2.0
        defensive_shape = (
            self._effective_avg(defend_players, "positioning", minute=minute, attacking_strategy="BALANCED", defensive_strategy=defend_strategy)
            + self._effective_avg(defend_players, "marking", minute=minute, attacking_strategy="BALANCED", defensive_strategy=defend_strategy)
        ) / 2.0
        quality = 0.04 + (positioning - 50) * 0.0011 + (creation - 50) * 0.0008
        quality -= (defensive_shape - 50) * 0.0007
        quality += ATTACK_SHOT_QUALITY.get(attack_strategy, 0.0)
        # A bounded beta-like roll without depending on Python random implementation.
        roll = (rng.random() + rng.random() + rng.random()) / 3.0
        xg = quality + roll * 0.18 + (finishing - 50) * 0.00035
        xg += self._environment_effects().shot_quality_delta
        if attack_strategy == "COUNTER_ATTACK" and rng.random() < 0.24:
            xg += 0.0505
        if attack_strategy == "WIDE_PLAY" and _rating(shooter, "heading") >= 65 and rng.random() < 0.20:
            xg += 0.050
        return _clamp(xg, MIN_XG, MAX_XG)

    def _shot_outcome(self, rng, *, xg, shooter, defenders, defend_strategy, attack_strategy, minute):
        goalkeeper = self._goalkeeper(defenders)
        outfield = [p for p in defenders if not self._is_goalkeeper(p)]
        gk_skill = 50.0
        if goalkeeper is not None:
            gk_skill = (
                self._effective_rating(goalkeeper, "gk_reflexes", minute=minute, attacking_strategy="BALANCED", defensive_strategy=defend_strategy)
                + self._effective_rating(goalkeeper, "gk_positioning", minute=minute, attacking_strategy="BALANCED", defensive_strategy=defend_strategy)
                + self._effective_rating(goalkeeper, "gk_one_on_one", minute=minute, attacking_strategy="BALANCED", defensive_strategy=defend_strategy)
            ) / 3.0
            gk_skill *= self._environment_effects().goalkeeper_handling_multiplier
        finisher = (
            self._effective_rating(shooter, "finishing", minute=minute, attacking_strategy=attack_strategy, defensive_strategy="BALANCED")
            + self._effective_rating(shooter, "composure", minute=minute, attacking_strategy=attack_strategy, defensive_strategy="BALANCED")
        ) / 2.0
        # xG is the pre-shot chance quality. Finisher/GK quality changes actual
        # conversion around that baseline; goal is resolved before classifying misses.
        goal_prob = xg * (1.0 + (finisher - 50) * 0.0045 - (gk_skill - 50) * 0.0038)
        goal_prob *= self._environment_effects().goal_conversion_multiplier
        goal_prob = _clamp(goal_prob, MIN_GOAL_PROBABILITY, MAX_GOAL_PROBABILITY)
        if rng.random() < goal_prob:
            return "GOAL", goalkeeper

        defensive_block = (
            self._effective_avg(outfield, "positioning", minute=minute, attacking_strategy="BALANCED", defensive_strategy=defend_strategy)
            + self._effective_avg(outfield, "marking", minute=minute, attacking_strategy="BALANCED", defensive_strategy=defend_strategy)
        ) / 2.0
        block_prob = _clamp(
            0.14 + (defensive_block - 50) * 0.0018 + DEFENCE_BLOCK_BONUS.get(defend_strategy, 0.0) - xg * 0.08,
            0.08,
            0.36,
        )
        shooting = self._effective_rating(shooter, "shooting", minute=minute, attacking_strategy=attack_strategy, defensive_strategy="BALANCED")
        composure = self._effective_rating(shooter, "composure", minute=minute, attacking_strategy=attack_strategy, defensive_strategy="BALANCED")
        saved_prob = _clamp(0.28 + (shooting - 50) * 0.002 + (composure - 50) * 0.001 + (gk_skill - 50) * 0.002, 0.18, 0.52)
        roll = rng.random()
        if roll < block_prob:
            return "BLOCKED", goalkeeper
        if roll < block_prob + saved_prob:
            return "SAVED", goalkeeper
        return "OFF_TARGET", goalkeeper

    @staticmethod
    def _chance_type(attack_strategy: str, xg: float) -> str:
        if xg >= 0.45:
            return "BIG_CHANCE"
        if attack_strategy == "COUNTER_ATTACK":
            return "TRANSITION"
        if attack_strategy == "WIDE_PLAY":
            return "WIDE_CREATION"
        if attack_strategy == "DIRECT":
            return "DIRECT_ATTACK"
        if attack_strategy == "POSSESSION":
            return "PATIENT_BUILDUP"
        return "OPEN_PLAY"

    # ------------------------------------------------------------------
    # Report / statistics construction
    # ------------------------------------------------------------------
    def _build_report_rows(self, *, state, seed, non_goal_events, goal_events, result, resolution, player_metrics):
        teams = {state.home.club_id: state.home, state.away.club_id: state.away}
        match_minutes = 120 if resolution.decision_stage in {RESOLUTION_EXTRA_TIME, RESOLUTION_PENALTIES} else 90
        raw = []
        for row in non_goal_events:
            if row.minute <= match_minutes:
                raw.append((
                    row.minute, row.event_type, row.club_id, row.player_id,
                    row.secondary_player_id, row.detail_payload,
                ))
        for minute, club, scorer, assister, detail in goal_events:
            if minute <= match_minutes:
                payload = dict(detail)
                if assister:
                    payload["assist_player_id"] = assister
                raw.append((minute, EVENT_GOAL, club, scorer, None, payload))

        if resolution.decision_stage == RESOLUTION_PENALTIES:
            raw.extend(self._shootout_report_events(state=state, seed=seed, resolution=resolution, non_goal_events=non_goal_events))

        phase_order = {PHASE_REGULATION: 0, PHASE_EXTRA_TIME: 1, PHASE_SHOOTOUT: 2}
        def event_phase(kind, minute):
            if kind in {EVENT_PENALTY_SCORED, EVENT_PENALTY_MISSED}:
                return PHASE_SHOOTOUT
            return _phase(minute)
        def event_sort_key(row):
            phase = event_phase(row[1], row[0])
            if phase == PHASE_SHOOTOUT:
                return (phase_order[phase], int((row[5] or {}).get("kick_number", 999)), 0, row[2], row[3])
            return (phase_order[phase], row[0], 0 if row[1] != EVENT_GOAL else 1, row[2], row[3])
        raw.sort(key=event_sort_key)

        # Revalidate substitution chronology after medical removals. The legacy
        # skeleton may contain future planned substitutions that became impossible
        # because an injury consumed a slot/player earlier in the match. Only valid
        # on-field changes become authoritative report events.
        validation_active = {club: {p.player_id for p in team.starters} for club, team in teams.items()}
        validation_bench = {club: {p.player_id for p in team.substitutes} for club, team in teams.items()}
        validation_standard_subs = Counter()
        validation_windows = {club: set() for club in teams}
        validation_concussion_subs = Counter()
        medically_removed = {club: set() for club in teams}
        validated_raw = []
        for row in raw:
            minute, kind, club, pid, secondary, detail = row
            detail = detail or {}
            if kind == EVENT_SUBSTITUTION:
                incoming_available = secondary in validation_bench[club]
                outgoing_active = pid in validation_active[club]
                medical_replacement = bool(detail.get("medical")) and pid in medically_removed[club]
                if not incoming_available or not (outgoing_active or medical_replacement):
                    continue
                if detail.get("concussion_extra"):
                    if (
                        not state.rules.medical.concussion_substitution_enabled
                        or validation_concussion_subs[club] >= state.rules.medical.max_concussion_substitutions
                    ):
                        continue
                    validation_concussion_subs[club] += 1
                else:
                    new_window = minute not in validation_windows[club]
                    if validation_standard_subs[club] >= state.rules.max_substitutions:
                        continue
                    if new_window and len(validation_windows[club]) >= state.rules.max_substitution_windows:
                        continue
                    validation_standard_subs[club] += 1
                    validation_windows[club].add(minute)
                validation_active[club].discard(pid)
                validation_bench[club].discard(secondary)
                validation_active[club].add(secondary)
                medically_removed[club].discard(pid)
                validated_raw.append(row)
                continue
            if kind in {EVENT_RED, EVENT_SECOND_YELLOW}:
                validation_active[club].discard(pid)
            elif kind == EVENT_INJURY and detail.get("match_availability") == "UNAVAILABLE":
                validation_active[club].discard(pid)
                medically_removed[club].add(pid)
            validated_raw.append(row)
        raw = validated_raw

        report_events = tuple(
            ReportEventV2(
                sequence=index + 1,
                minute=minute,
                phase=event_phase(kind, minute),
                event_type=kind,
                club_id=club,
                player_id=pid,
                secondary_player_id=secondary,
                detail=tuple(sorted((detail or {}).items())),
            )
            for index, (minute, kind, club, pid, secondary, detail) in enumerate(raw)
        )

        entry_minute = {p.player_id: 0 for team in teams.values() for p in team.starters}
        exit_minute: dict[str, int] = {}
        started = set(entry_minute)
        subbed_in = set(); subbed_out = set(); injured = set()
        yellow = Counter(); red = Counter(); goals = Counter(); team_subs = Counter()
        active = {club: {p.player_id for p in team.starters} for club, team in teams.items()}
        for event in report_events:
            if event.phase == PHASE_SHOOTOUT:
                continue
            club = event.club_id
            pid = event.player_id
            if event.event_type == EVENT_SUBSTITUTION:
                active[club].discard(pid)
                if event.secondary_player_id:
                    active[club].add(event.secondary_player_id)
                    entry_minute[event.secondary_player_id] = event.minute
                    subbed_in.add(event.secondary_player_id)
                exit_minute.setdefault(pid, event.minute)
                subbed_out.add(pid)
                team_subs[club] += 1
            elif event.event_type == EVENT_YELLOW:
                yellow[pid] += 1
            elif event.event_type == EVENT_SECOND_YELLOW:
                yellow[pid] += 1; red[pid] = 1
                active[club].discard(pid); exit_minute.setdefault(pid, event.minute)
            elif event.event_type == EVENT_RED:
                red[pid] = 1
                active[club].discard(pid); exit_minute.setdefault(pid, event.minute)
            elif event.event_type == EVENT_INJURY:
                injured.add(pid)
                if event.detail_payload.get("match_availability") == "UNAVAILABLE":
                    active[club].discard(pid); exit_minute.setdefault(pid, event.minute)
            elif event.event_type == EVENT_GOAL:
                goals[pid] += 1

        for club in teams:
            for pid in active[club]:
                exit_minute.setdefault(pid, match_minutes)

        player_rows = []
        for club, team in teams.items():
            all_players = self._player_map(team)
            participating = set(entry_minute) & set(all_players)
            for pid in sorted(participating):
                start = entry_minute[pid]
                end = exit_minute.get(pid, match_minutes)
                minutes = max(0, min(match_minutes, end) - start)
                if minutes == 0 and pid in started:
                    minutes = 1
                player_rows.append(PlayerMatchStatisticsV2(
                    player_id=pid,
                    club_id=club,
                    started=pid in started,
                    minutes_played=minutes,
                    goals=goals[pid],
                    clean_sheet=(result.away_score == 0 if club == state.home.club_id else result.home_score == 0),
                    yellow_cards=yellow[pid],
                    red_cards=red[pid],
                    substituted_in=pid in subbed_in,
                    substituted_out=pid in subbed_out,
                    injured=pid in injured,
                ))

        team_rows = (
            TeamMatchStatisticsV2(
                club_id=state.home.club_id,
                goals_for=result.home_score,
                goals_against=result.away_score,
                clean_sheet=result.away_score == 0,
                yellow_cards=sum(yellow[p.player_id] for p in (*state.home.starters, *state.home.substitutes)),
                red_cards=sum(red[p.player_id] for p in (*state.home.starters, *state.home.substitutes)),
                substitutions=team_subs[state.home.club_id],
            ),
            TeamMatchStatisticsV2(
                club_id=state.away.club_id,
                goals_for=result.away_score,
                goals_against=result.home_score,
                clean_sheet=result.home_score == 0,
                yellow_cards=sum(yellow[p.player_id] for p in (*state.away.starters, *state.away.substitutes)),
                red_cards=sum(red[p.player_id] for p in (*state.away.starters, *state.away.substitutes)),
                substitutions=team_subs[state.away.club_id],
            ),
        )
        return report_events, team_rows, tuple(player_rows)

    def _ordered_shootout_takers(self, *, team, active):
        by_id = {player.player_id: player for player in active}
        ordered = []
        for player_id in team.set_piece_plan.penalty_order:
            player = by_id.get(player_id)
            if player is not None and not self._is_goalkeeper(player) and player not in ordered:
                ordered.append(player)
        remaining = [p for p in active if not self._is_goalkeeper(p) and p not in ordered]
        remaining.sort(key=lambda p: self._penalty_taker_weight(p, minute=120), reverse=True)
        ordered.extend(remaining)
        if not ordered:
            ordered = list(active)
        return ordered

    def _shootout_trace(self, *, state, seed, non_goal_events):
        rng = _domain_rng(seed, DOMAIN_SHOOTOUT_V32)
        clubs = (state.home.club_id, state.away.club_id)
        teams = {state.home.club_id: state.home, state.away.club_id: state.away}
        active = {
            club: self._active_players_for_team(team=teams[club], events=non_goal_events, minute=120, club_id=club) or list(teams[club].starters)
            for club in clubs
        }
        takers = {club: self._ordered_shootout_takers(team=teams[club], active=active[club]) for club in clubs}
        keepers = {club: self._goalkeeper(active[club]) for club in clubs}
        scores = {club: 0 for club in clubs}
        rows = []
        team_kicks = {club: 0 for club in clubs}

        def kick(club, opponent_club):
            index = team_kicks[club]
            taker = takers[club][index % len(takers[club])]
            goalkeeper = keepers[opponent_club]
            xg = self._penalty_xg(taker=taker, goalkeeper=goalkeeper, minute=120)
            outcome = self._penalty_outcome(rng, xg=xg, taker=taker, goalkeeper=goalkeeper, minute=120)
            scored = outcome == "GOAL"
            if scored:
                scores[club] += 1
            team_kicks[club] += 1
            rows.append({
                "club_id": club, "taker_player_id": taker.player_id,
                "goalkeeper_player_id": goalkeeper.player_id if goalkeeper else None,
                "team_kick_number": team_kicks[club], "xg": round(xg, 3),
                "outcome": outcome, "scored": scored,
            })

        # Initial five, with early clinch logic.
        for round_index in range(5):
            kick(clubs[0], clubs[1])
            remaining_away = 5 - team_kicks[clubs[1]]
            if scores[clubs[0]] > scores[clubs[1]] + remaining_away:
                return scores[clubs[0]], scores[clubs[1]], rows
            kick(clubs[1], clubs[0])
            remaining_home = 5 - team_kicks[clubs[0]]
            if scores[clubs[1]] > scores[clubs[0]] + remaining_home:
                return scores[clubs[0]], scores[clubs[1]], rows
        if scores[clubs[0]] != scores[clubs[1]]:
            return scores[clubs[0]], scores[clubs[1]], rows

        # Sudden death. Safety cap remains deterministic but far beyond normal use.
        for _ in range(20):
            kick(clubs[0], clubs[1])
            kick(clubs[1], clubs[0])
            if scores[clubs[0]] != scores[clubs[1]]:
                return scores[clubs[0]], scores[clubs[1]], rows
        # Extremely unlikely deterministic safety valve.
        if rng.random() < 0.5:
            scores[clubs[0]] += 1
        else:
            scores[clubs[1]] += 1
        return scores[clubs[0]], scores[clubs[1]], rows

    def _shootout(self, *, state, seed, non_goal_events):
        home, away, _rows = self._shootout_trace(state=state, seed=seed, non_goal_events=non_goal_events)
        return home, away

    def _shootout_report_events(self, *, state, seed, resolution, non_goal_events):
        home, away, trace = self._shootout_trace(state=state, seed=seed, non_goal_events=non_goal_events)
        if (home, away) != (int(resolution.home_penalties or 0), int(resolution.away_penalties or 0)):
            raise EngineStateError("Shootout trace does not reconcile with sporting resolution.")
        rows = []
        for sequence, row in enumerate(trace, start=1):
            rows.append((
                120,
                EVENT_PENALTY_SCORED if row["scored"] else EVENT_PENALTY_MISSED,
                row["club_id"], row["taker_player_id"], None,
                {
                    "kick_number": sequence,
                    "team_kick_number": row["team_kick_number"],
                    "xg": row["xg"],
                    "outcome": row["outcome"],
                    "goalkeeper_player_id": row["goalkeeper_player_id"],
                    "set_piece_type": "PENALTY_SHOOTOUT",
                },
            ))
        return rows

    def _append_segment_statistics(self, *, segment_statistics, segment, start, end, state, score, shots, possession_units, player_metrics, team_metrics):
        total_possessions = max(1, possession_units[state.home.club_id] + possession_units[state.away.club_id])
        row = {
            "segment": segment,
            "start_minute": start,
            "end_minute": end,
            "home": self._live_team_snapshot(
                club_id=state.home.club_id,
                opponent_id=state.away.club_id,
                player_ids=set(self._player_map(state.home)),
                score=score,
                shots=shots,
                possession_units=possession_units,
                total_possessions=total_possessions,
                player_metrics=player_metrics,
                team_metrics=team_metrics,
            ),
            "away": self._live_team_snapshot(
                club_id=state.away.club_id,
                opponent_id=state.home.club_id,
                player_ids=set(self._player_map(state.away)),
                score=score,
                shots=shots,
                possession_units=possession_units,
                total_possessions=total_possessions,
                player_metrics=player_metrics,
                team_metrics=team_metrics,
            ),
        }
        segment_statistics.append(row)

    @staticmethod
    def _live_team_snapshot(*, club_id, opponent_id, player_ids, score, shots, possession_units, total_possessions, player_metrics, team_metrics):
        club_shots = [row for row in shots if row["club_id"] == club_id]
        passes_attempted = sum(
            values["passes_attempted"] for pid, values in player_metrics.items() if pid in player_ids
        )
        passes_completed = sum(
            values["passes_completed"] for pid, values in player_metrics.items() if pid in player_ids
        )
        return {
            "score": score[club_id],
            "shots": len(club_shots),
            "shots_on_target": sum(row["outcome"] in {"GOAL", "SAVED"} for row in club_shots),
            "xg": round(sum(float(row["xg"]) for row in club_shots), 3),
            "possession_pct": round(100.0 * possession_units[club_id] / total_possessions, 1),
            "passes_attempted": passes_attempted,
            "passes_completed": passes_completed,
            "corners": team_metrics[club_id]["corners"],
            "free_kicks": team_metrics[club_id]["free_kicks"],
            "penalties": team_metrics[club_id]["penalties"],
            "set_piece_goals": team_metrics[club_id]["set_piece_goals"],
            "fouls": team_metrics[club_id]["fouls"],
        }

    def _build_advanced_analytics(
        self, *, state, events, team_rows, player_rows, shots, possession_units,
        player_metrics, team_metrics, segment_statistics, result, match_minutes, current,
        set_piece_events, referee_events, medical_events, defensive_events,
        possession_events, pressing_events, pass_events, possession_records, pass_network_edges,
    ):
        club_players = {
            state.home.club_id: self._player_map(state.home),
            state.away.club_id: self._player_map(state.away),
        }
        # Match report is authoritative for cards/substitution/injury/minutes.
        basic_by_player = {row.player_id: row for row in player_rows}
        goal_shot_by_player = Counter(row["player_id"] for row in shots if row["outcome"] == "GOAL")
        assist_by_player = Counter(
            row["assisted_by_player_id"] for row in shots
            if row["outcome"] == "GOAL" and row["assisted_by_player_id"]
        )
        total_possessions = max(1, possession_units[state.home.club_id] + possession_units[state.away.club_id])

        advanced_players = []
        for club_id, players in club_players.items():
            for pid, player in players.items():
                basic = basic_by_player.get(pid)
                if basic is None:
                    continue
                metrics = player_metrics[pid]
                shots_for_player = [row for row in shots if row["player_id"] == pid]
                xg = round(sum(float(row["xg"]) for row in shots_for_player), 3)
                xa = round(metrics["xa_milli"] / 1000.0, 3)
                rating = self._performance_rating(
                    basic=basic,
                    metrics=metrics,
                    xg=xg,
                    xa=xa,
                    goals=goal_shot_by_player[pid],
                    assists=assist_by_player[pid],
                )
                attack_strategy, defence_strategy = current[club_id]
                end_condition = round(100.0 - self._fatigue_load(player, min(match_minutes, max(1, basic.minutes_played)), attack_strategy, defence_strategy), 1)
                advanced_players.append({
                    "player_id": pid,
                    "club_id": club_id,
                    "natural_position": player.natural_position,
                    "lineup_slot": player.lineup_slot,
                    "tactical_role": player.tactical_role,
                    "position_familiarity": player.position_familiarity,
                    "out_of_position": player.position_familiarity < 85,
                    "started": basic.started,
                    "minutes_played": basic.minutes_played,
                    "goals": int(goal_shot_by_player[pid]),
                    "assists": int(assist_by_player[pid]),
                    "clean_sheet": basic.clean_sheet,
                    "yellow_cards": basic.yellow_cards,
                    "red_cards": basic.red_cards,
                    "substituted_in": basic.substituted_in,
                    "substituted_out": basic.substituted_out,
                    "injured": basic.injured,
                    "xg": xg,
                    "xa": xa,
                    "shots": metrics["shots"],
                    "shots_on_target": metrics["shots_on_target"],
                    "big_chances": metrics["big_chances"],
                    "passes_attempted": metrics["passes_attempted"],
                    "passes_completed": metrics["passes_completed"],
                    "passes_received": metrics["passes_received"],
                    "progressive_passes": metrics["progressive_passes"],
                    "through_balls": metrics["through_balls"],
                    "switches": metrics["switches"],
                    "touches": metrics["touches"],
                    "progressive_carries": metrics["progressive_carries"],
                    "final_third_entries": metrics["final_third_entries"],
                    "box_entries": metrics["box_entries"],
                    "turnovers": metrics["turnovers"],
                    "recoveries": metrics["recoveries"],
                    "pressures": metrics["pressures"],
                    "pressing_recoveries": metrics["pressing_recoveries"],
                    "counterpresses": metrics["counterpresses"],
                    "counterpress_recoveries": metrics["counterpress_recoveries"],
                    "press_bypasses": metrics["press_bypasses"],
                    "line_breaks": metrics["line_breaks"],
                    "key_passes": metrics["key_passes"],
                    "tackles_attempted": metrics["tackles_attempted"],
                    "tackles_won": metrics["tackles_won"],
                    "interceptions": metrics["interceptions"],
                    "blocks": metrics["blocks"],
                    "clearances": metrics["clearances"],
                    "defensive_duels": metrics["defensive_duels"],
                    "defensive_duels_won": metrics["defensive_duels_won"],
                    "errors_leading_to_shot": metrics["errors_leading_to_shot"],
                    "errors_leading_to_goal": metrics["errors_leading_to_goal"],
                    "saves": metrics["saves"],
                    "catches": metrics["catches"],
                    "claims": metrics["claims"],
                    "punches": metrics["punches"],
                    "parries": metrics["parries"],
                    "one_on_one_saves": metrics["one_on_one_saves"],
                    "sweeper_actions": metrics["sweeper_actions"],
                    "sweeper_successes": metrics["sweeper_successes"],
                    "keeper_errors": metrics["keeper_errors"],
                    "dribbles_attempted": metrics["dribbles_attempted"],
                    "dribbles_completed": metrics["dribbles_completed"],
                    "set_piece_shots": metrics["set_piece_shots"],
                    "penalties_taken": metrics["penalties_taken"],
                    "penalties_scored": metrics["penalties_scored"],
                    "free_kicks_taken": metrics["free_kicks_taken"],
                    "corners_taken": metrics["corners_taken"],
                    "aerial_duels": metrics["aerial_duels"],
                    "aerial_duels_won": metrics["aerial_duels_won"],
                    "second_ball_recoveries": metrics["second_ball_recoveries"],
                    "fouls_committed": metrics["fouls_committed"],
                    "fouls_drawn": metrics["fouls_drawn"],
                    "offsides": metrics["offsides"],
                    "disallowed_goals": metrics["disallowed_goals"],
                    "medical_assessments": metrics["medical_assessments"],
                    "played_on_after_treatment": metrics["played_on_after_treatment"],
                    "concussion_removed": metrics["concussion_removed"],
                    "rating": rating,
                    "is_man_of_the_match": False,
                    "condition_end_pct": max(0.0, end_condition),
                })

        if not advanced_players:
            raise EngineStateError("Causal analytics produced no player rows.")
        motm = sorted(
            advanced_players,
            key=lambda row: (-float(row["rating"]), -row["goals"], -row["assists"], -float(row["xg"]), row["player_id"]),
        )[0]
        for row in advanced_players:
            row["is_man_of_the_match"] = row["player_id"] == motm["player_id"]

        team_basic = {row.club_id: row for row in team_rows}
        advanced_teams = []
        for club_id, team in ((state.home.club_id, state.home), (state.away.club_id, state.away)):
            rows = [row for row in advanced_players if row["club_id"] == club_id]
            club_shots = [row for row in shots if row["club_id"] == club_id]
            passes_attempted = sum(row["passes_attempted"] for row in rows)
            passes_completed = sum(row["passes_completed"] for row in rows)
            tackles_attempted = sum(row["tackles_attempted"] for row in rows)
            tackles_won = sum(row["tackles_won"] for row in rows)
            base = team_basic[club_id]
            advanced_teams.append({
                "club_id": club_id,
                "formation": team.formation,
                "average_position_familiarity": round(sum(p.position_familiarity for p in team.starters) / 11.0, 1),
                "goals_for": base.goals_for,
                "goals_against": base.goals_against,
                "yellow_cards": base.yellow_cards,
                "red_cards": base.red_cards,
                "substitutions": base.substitutions,
                "possession_pct": round(100.0 * possession_units[club_id] / total_possessions, 1),
                "xg": round(sum(float(row["xg"]) for row in club_shots), 3),
                "shots": len(club_shots),
                "shots_on_target": sum(row["outcome"] in {"GOAL", "SAVED"} for row in club_shots),
                "big_chances": sum(float(row["xg"]) >= BIG_CHANCE_XG for row in club_shots),
                "passes_attempted": passes_attempted,
                "passes_completed": passes_completed,
                "pass_accuracy_pct": round(100.0 * passes_completed / max(1, passes_attempted), 1),
                "progressive_passes": sum(row["progressive_passes"] for row in rows),
                "through_balls": sum(row["through_balls"] for row in rows),
                "switches": sum(row["switches"] for row in rows),
                "progressive_carries": sum(row["progressive_carries"] for row in rows),
                "final_third_entries": team_metrics[club_id]["final_third_entries"],
                "box_entries": team_metrics[club_id]["box_entries"],
                "turnovers_lost": team_metrics[club_id]["turnovers_lost"],
                "turnovers_won": team_metrics[club_id]["turnovers_won"],
                "transition_possessions": team_metrics[club_id]["transition_possessions"],
                "chances_created": team_metrics[club_id]["chances_created"],
                "presses_attempted": team_metrics[club_id]["presses_attempted"],
                "pressing_recoveries": team_metrics[club_id]["pressing_recoveries"],
                "counterpresses": team_metrics[club_id]["counterpresses"],
                "counterpress_recoveries": team_metrics[club_id]["counterpress_recoveries"],
                "counterpress_bypassed": team_metrics[club_id]["counterpress_bypassed"],
                "press_bypassed": team_metrics[club_id]["press_bypassed"],
                "line_breaks": team_metrics[club_id]["line_breaks"],
                "line_breaks_allowed": team_metrics[club_id]["line_breaks_allowed"],
                "tackles_attempted": tackles_attempted,
                "tackles_won": tackles_won,
                "interceptions": sum(row["interceptions"] for row in rows),
                "blocks": sum(row["blocks"] for row in rows),
                "clearances": sum(row["clearances"] for row in rows),
                "defensive_duels": sum(row["defensive_duels"] for row in rows),
                "defensive_duels_won": sum(row["defensive_duels_won"] for row in rows),
                "errors_leading_to_shot": sum(row["errors_leading_to_shot"] for row in rows),
                "errors_leading_to_goal": sum(row["errors_leading_to_goal"] for row in rows),
                "saves": sum(row["saves"] for row in rows),
                "keeper_catches": sum(row["catches"] for row in rows),
                "keeper_claims": sum(row["claims"] for row in rows),
                "keeper_punches": sum(row["punches"] for row in rows),
                "keeper_parries": sum(row["parries"] for row in rows),
                "one_on_one_saves": sum(row["one_on_one_saves"] for row in rows),
                "sweeper_actions": sum(row["sweeper_actions"] for row in rows),
                "sweeper_successes": sum(row["sweeper_successes"] for row in rows),
                "keeper_errors": sum(row["keeper_errors"] for row in rows),
                "corners": team_metrics[club_id]["corners"],
                "free_kicks": team_metrics[club_id]["free_kicks"],
                "penalties": team_metrics[club_id]["penalties"],
                "set_piece_shots": team_metrics[club_id]["set_piece_shots"],
                "set_piece_goals": team_metrics[club_id]["set_piece_goals"],
                "aerial_duels": team_metrics[club_id]["aerial_duels"],
                "aerial_duels_won": team_metrics[club_id]["aerial_duels_won"],
                "second_balls": team_metrics[club_id]["second_balls"],
                "fouls": max(team_metrics[club_id]["fouls"], base.yellow_cards + base.red_cards),
                "offsides": team_metrics[club_id]["offsides"],
                "advantages": team_metrics[club_id]["advantages"],
                "var_disallowed_goals": team_metrics[club_id]["var_disallowed_goals"],
                "medical_stoppages": team_metrics[club_id]["medical_stoppages"],
                "forced_medical_substitutions": team_metrics[club_id]["forced_medical_substitutions"],
                "concussion_removals": team_metrics[club_id]["concussion_removals"],
                "concussion_substitutions": team_metrics[club_id]["concussion_substitutions"],
            })

        shot_payload = []
        for index, row in enumerate(sorted(shots, key=lambda item: (item["minute"], item["club_id"], item["player_id"])), start=1):
            shot_payload.append({"sequence": index, **row})
        referee_payload = []
        ordered_referee = sorted(referee_events, key=lambda item: (item["minute"], item.get("_ordinal", 0)))
        for index, row in enumerate(ordered_referee, start=1):
            clean = {key: value for key, value in row.items() if key != "_ordinal"}
            referee_payload.append({"sequence": index, **clean})
        medical_payload = []
        ordered_medical = sorted(medical_events, key=lambda item: (item["minute"], item.get("_ordinal", 0)))
        for index, row in enumerate(ordered_medical, start=1):
            clean = {key: value for key, value in row.items() if key != "_ordinal"}
            medical_payload.append({"sequence": index, **clean})
        defensive_payload = []
        ordered_defensive = sorted(defensive_events, key=lambda item: (item["minute"], item.get("_ordinal", 0)))
        for index, row in enumerate(ordered_defensive, start=1):
            clean = {key: value for key, value in row.items() if key != "_ordinal"}
            defensive_payload.append({"sequence": index, **clean})
        defensive_summary = {
            "total_actions": len(defensive_payload),
            "interceptions": sum(row["type"] == "INTERCEPTION" for row in defensive_payload),
            "tackles": sum(row["type"] == "TACKLE" for row in defensive_payload),
            "ground_duels": sum(row["type"] == "GROUND_DUEL" for row in defensive_payload),
            "aerial_duels": sum(row["type"] == "AERIAL_DUEL" for row in defensive_payload),
            "blocks": sum(row["type"] == "BLOCK" for row in defensive_payload),
            "clearances": sum(row["type"] in {"CLEARANCE", "SWEEPER_CLEARANCE"} for row in defensive_payload),
            "goalkeeper_saves": sum(row["type"] in {"KEEPER_SAVE", "KEEPER_PARRY", "ONE_ON_ONE_SAVE"} for row in defensive_payload),
            "goalkeeper_claims": sum(row["type"] == "KEEPER_CLAIM" for row in defensive_payload),
            "goalkeeper_punches": sum(row["type"] == "KEEPER_PUNCH" for row in defensive_payload),
            "sweeper_actions": sum(row["type"] in {"SWEEPER_CLEARANCE", "SWEEPER_MISJUDGEMENT"} for row in defensive_payload),
            "sweeper_successes": sum(row["type"] == "SWEEPER_CLEARANCE" for row in defensive_payload),
            "defensive_errors": sum(row["type"] == "DEFENSIVE_ERROR" for row in defensive_payload),
            "keeper_misjudgements": sum(row["type"] == "SWEEPER_MISJUDGEMENT" or (row["type"] == "DEFENSIVE_ERROR" and row.get("detail", {}).get("subtype") == "CROSS_MISJUDGEMENT") for row in defensive_payload),
        }

        pressing_payload = []
        ordered_pressing = sorted(pressing_events, key=lambda item: (item["minute"], item.get("_ordinal", 0)))
        for index, row in enumerate(ordered_pressing, start=1):
            clean = {key: value for key, value in row.items() if key != "_ordinal"}
            pressing_payload.append({"sequence": index, **clean})

        possession_payload = []
        ordered_possession = sorted(
            possession_events,
            key=lambda item: (item.get("possession_sequence", 0), item.get("action_sequence", 0), item.get("_ordinal", 0)),
        )
        for index, row in enumerate(ordered_possession, start=1):
            clean = {key: value for key, value in row.items() if key != "_ordinal"}
            possession_payload.append({"sequence": index, **clean})

        pass_payload = []
        ordered_passes = sorted(
            pass_events,
            key=lambda item: (item.get("possession_sequence", 0), item.get("pass_sequence", 0), item.get("minute", 0)),
        )
        for index, row in enumerate(ordered_passes, start=1):
            pass_payload.append({"sequence": index, **row})

        pass_attempt_edges = Counter(
            (row["club_id"], row["passer_player_id"], row["receiver_player_id"])
            for row in pass_payload
        )
        progressive_edges = Counter(
            (row["club_id"], row["passer_player_id"], row["receiver_player_id"])
            for row in pass_payload
            if row.get("outcome") == "COMPLETED" and row.get("progressive")
        )
        passing_network = []
        for edge, attempts in sorted(pass_attempt_edges.items(), key=lambda item: (-item[1], item[0])):
            club_id, passer_id, receiver_id = edge
            completed = int(pass_network_edges.get(edge, 0))
            passing_network.append({
                "club_id": club_id,
                "passer_player_id": passer_id,
                "receiver_player_id": receiver_id,
                "attempted": int(attempts),
                "completed": completed,
                "completion_pct": round(100.0 * completed / max(1, attempts), 1),
                "progressive_completed": int(progressive_edges.get(edge, 0)),
            })

        possession_ids_by_club = {state.home.club_id: set(), state.away.club_id: set()}
        actions_by_possession = Counter()
        shot_possessions = set()
        chance_possessions = set()
        turnover_possessions = set()
        counter_possessions = set()
        final_third_actions = Counter()
        box_actions = Counter()
        for row in possession_payload:
            pid = int(row["possession_sequence"])
            club_id = row["club_id"]
            possession_ids_by_club.setdefault(club_id, set()).add(pid)
            actions_by_possession[pid] += 1
            if row["type"] == "SHOT":
                shot_possessions.add(pid)
            if row["type"] == "CHANCE_CREATED":
                chance_possessions.add(pid)
            if row["type"] == "TURNOVER":
                turnover_possessions.add(pid)
            if row.get("transition_state") == "COUNTER":
                counter_possessions.add(pid)
            if row.get("destination_zone") == "FINAL_THIRD":
                final_third_actions[club_id] += 1
            if row.get("destination_zone") == "PENALTY_AREA":
                box_actions[club_id] += 1

        possession_summary = {
            "total_possessions": sum(len(rows) for rows in possession_ids_by_club.values()),
            "home_possessions": len(possession_ids_by_club.get(state.home.club_id, set())),
            "away_possessions": len(possession_ids_by_club.get(state.away.club_id, set())),
            "possessions_with_chance": len(chance_possessions),
            "possessions_with_shot": len(shot_possessions),
            "possessions_ending_turnover": len(turnover_possessions),
            "average_actions_per_possession": round(
                sum(actions_by_possession.values()) / max(1, len(actions_by_possession)), 2
            ),
            "team": {
                club_id: {
                    "possessions": len(possession_ids_by_club.get(club_id, set())),
                    "final_third_actions": int(final_third_actions[club_id]),
                    "penalty_area_actions": int(box_actions[club_id]),
                    "turnovers_lost": int(team_metrics[club_id]["turnovers_lost"]),
                    "turnovers_won": int(team_metrics[club_id]["turnovers_won"]),
                    "final_third_entries": int(team_metrics[club_id]["final_third_entries"]),
                    "box_entries": int(team_metrics[club_id]["box_entries"]),
                }
                for club_id in (state.home.club_id, state.away.club_id)
            },
        }
        transition_summary = {
            "counter_possessions": len(counter_possessions),
            "counter_shots": sum(
                row["type"] == "SHOT" and int(row["possession_sequence"]) in counter_possessions
                for row in possession_payload
            ),
            "counter_goals": sum(
                row["type"] == "SHOT" and row.get("outcome") == "GOAL"
                and int(row["possession_sequence"]) in counter_possessions
                for row in possession_payload
            ),
            "counter_chances": sum(
                row["type"] == "CHANCE_CREATED" and int(row["possession_sequence"]) in counter_possessions
                for row in possession_payload
            ),
        }

        pressing_summary = {
            "events": len(pressing_payload),
            "presses_triggered": sum(row["type"] in {"PRESS_TRIGGERED", "PRESSING_TRAP"} for row in pressing_payload),
            "press_recoveries": sum(row["type"] == "PRESS_RECOVERY" for row in pressing_payload),
            "presses_bypassed": sum(row["type"] == "PRESS_BYPASSED" for row in pressing_payload),
            "counterpresses": sum(row["type"] == "COUNTER_PRESS" for row in pressing_payload),
            "counterpress_recoveries": sum(row["type"] == "COUNTER_PRESS_RECOVERY" for row in pressing_payload),
            "counterpress_bypassed": sum(row["type"] == "COUNTER_PRESS_BYPASSED" for row in pressing_payload),
            "line_breaks": sum(row["type"] == "LINE_BREAK" for row in pressing_payload),
            "team": {
                club_id: {
                    "defensive_shape": shape_for_strategy(current[club_id][1]).to_payload(),
                    "presses_attempted": int(team_metrics[club_id]["presses_attempted"]),
                    "pressing_recoveries": int(team_metrics[club_id]["pressing_recoveries"]),
                    "counterpresses": int(team_metrics[club_id]["counterpresses"]),
                    "counterpress_recoveries": int(team_metrics[club_id]["counterpress_recoveries"]),
                    "press_bypassed": int(team_metrics[club_id]["press_bypassed"]),
                    "line_breaks_allowed": int(team_metrics[club_id]["line_breaks_allowed"]),
                }
                for club_id in (state.home.club_id, state.away.club_id)
            },
        }

        medical_summary = {
            "rules": state.rules.medical.to_payload(),
            "incidents": sum(row["type"] == "INCIDENT" for row in medical_payload),
            "assessments": sum(row["type"] == "ASSESSMENT" for row in medical_payload),
            "treatments": sum(row["type"] == "TREATMENT" for row in medical_payload),
            "return_to_play_decisions": sum(row["type"] == "RETURN_TO_PLAY_DECISION" for row in medical_payload),
            "forced_removals": sum(row["type"] == "RETURN_TO_PLAY_DECISION" and row["final_decision"] in {"FORCED_REMOVAL", "REMOVED_CONCUSSION", "PRECAUTIONARY_REMOVAL"} for row in medical_payload),
            "concussion_checks": sum(bool(row.get("suspected_concussion")) and row["type"] == "ASSESSMENT" for row in medical_payload),
            "concussion_removals": sum(row["final_decision"] == "REMOVED_CONCUSSION" for row in medical_payload),
            "players_continued_after_treatment": sum(row["type"] == "RETURN_TO_PLAY_DECISION" and row["final_decision"] in {"CONTINUE", "CONTINUE_LIMITED", "CLEARED_TO_CONTINUE"} for row in medical_payload),
            "stoppage_seconds": sum(int(row.get("stoppage_seconds") or 0) for row in medical_payload if row["type"] in {"ASSESSMENT", "TREATMENT"}),
        }
        medical_context = {
            "home": state.home_medical.to_payload(),
            "away": state.away_medical.to_payload(),
        }

        officiating_summary = {
            "rules": state.rules.officiating.to_payload(),
            "fouls_awarded": (
                sum(row["type"] == "FOUL" and row["final_decision"] in {"FREE_KICK", "ADVANTAGE"} for row in referee_payload)
                + sum(row["type"] == "PENALTY_DECISION" and row["final_decision"] == "PENALTY" for row in referee_payload)
            ),
            "advantages_played": sum(row["type"] == "ADVANTAGE" for row in referee_payload),
            "offsides_called": sum(row["type"] == "OFFSIDE" and row["final_decision"] == "OFFSIDE" for row in referee_payload)
                + sum(row["type"] == "VAR_REVIEW" and row["final_decision"] == "DISALLOWED_OFFSIDE" for row in referee_payload),
            "penalties_awarded": sum(row["type"] == "PENALTY_DECISION" and row["final_decision"] == "PENALTY" for row in referee_payload),
            "var_reviews": sum(bool(row["var_used"]) for row in referee_payload),
            "var_overturns": sum(bool(row["overturned"]) for row in referee_payload),
            "goals_disallowed_by_var": sum(row["type"] == "VAR_REVIEW" and row["final_decision"] == "DISALLOWED_OFFSIDE" for row in referee_payload),
        }
        return {
            "schema_version": ANALYTICS_SCHEMA_VERSION,
            "policy_key": ANALYTICS_POLICY_KEY,
            "policy_version": ANALYTICS_POLICY_VERSION,
            "causal": True,
            "environment": state.environment.to_payload(),
            "environment_effects": effects_for_environment(state.environment).to_payload(),
            "team_statistics": advanced_teams,
            "player_statistics": advanced_players,
            "shots": shot_payload,
            "set_piece_events": [
                {"sequence": index, **row}
                for index, row in enumerate(sorted(set_piece_events, key=lambda item: (item["minute"], item["club_id"], item["type"])), start=1)
            ],
            "referee_events": referee_payload,
            "officiating_summary": officiating_summary,
            "medical_events": medical_payload,
            "medical_summary": medical_summary,
            "medical_context": medical_context,
            "defensive_events": defensive_payload,
            "defensive_summary": defensive_summary,
            "pressing_events": pressing_payload,
            "pressing_summary": pressing_summary,
            "possession_events": possession_payload,
            "possession_summary": possession_summary,
            "pass_events": pass_payload,
            "passing_network": passing_network,
            "transition_summary": transition_summary,
            "segment_statistics": segment_statistics,
            "man_of_the_match": {
                "player_id": motm["player_id"],
                "club_id": motm["club_id"],
                "rating": motm["rating"],
            },
        }

    @staticmethod
    def _performance_rating(*, basic, metrics, xg, xa, goals, assists):
        rating = 6.0
        rating += goals * 1.05 + assists * 0.72
        rating += metrics["key_passes"] * 0.08 + metrics["tackles_won"] * 0.045 + metrics["interceptions"] * 0.05
        rating += metrics["pressing_recoveries"] * 0.025 + metrics["counterpress_recoveries"] * 0.04 + metrics["line_breaks"] * 0.018
        rating += metrics["blocks"] * 0.035 + metrics["clearances"] * 0.018 + metrics["defensive_duels_won"] * 0.015
        rating += metrics["saves"] * 0.11 + metrics["one_on_one_saves"] * 0.08 + metrics["claims"] * 0.015 + metrics["sweeper_successes"] * 0.03
        rating += metrics["dribbles_completed"] * 0.035
        rating -= metrics["errors_leading_to_shot"] * 0.12 + metrics["errors_leading_to_goal"] * 0.28 + metrics["keeper_errors"] * 0.10
        rating += metrics["aerial_duels_won"] * 0.025 + metrics["second_ball_recoveries"] * 0.018
        rating += metrics["penalties_scored"] * 0.08
        pass_accuracy = metrics["passes_completed"] / max(1, metrics["passes_attempted"])
        if metrics["passes_attempted"] >= 10:
            rating += (pass_accuracy - 0.76) * 1.25
        rating -= basic.yellow_cards * 0.18 + basic.red_cards * 1.10
        missed_big = max(0, metrics["big_chances"] - goals)
        rating -= missed_big * 0.12
        # Reward productive expected contribution without overpowering real goals.
        rating += min(0.35, max(0.0, xa * 0.18 + xg * 0.08))
        if basic.clean_sheet and metrics["saves"]:
            rating += 0.25
        if basic.minutes_played < 30:
            rating = 6.0 + (rating - 6.0) * max(0.25, basic.minutes_played / 30.0)
        return round(_clamp(rating, 3.0, 10.0), 2)
