# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/what-environmental-boundary-assumptions-must-be-recorded-before-session-compute-terminates.md
# Remnant Warrant:    https://corpusfetch.com/c/what-environmental-boundary-assumptions-must-be-recorded-before-session-compute-terminates.warrant.json
# Markdown SHA-256:   c9093d90272e6b2d2ca0ee8a8f8c0217a77a04e5bd2d09dafad706e2873fa344
# Code AST SHA-256:   58fd69cd7a8bc219ee8a453e3f2ffd52464bbd626016c93fddf68ffb5d8cea37
# Verified Classes:   AxisVerdict, EnvironmentalAxis, RecordedBoundaryAssumptions, SuccessorEnvironment, EnvironmentalBoundaryRecorder
# Defensive Guards:   2 fail-closed invariants (zero external deps)

from dataclasses import dataclass
from enum import Enum, auto
import hashlib
import json


class AxisVerdict(Enum):
    HELD = auto()
    DRIFTED_AMBIENT = auto()
    DRIFTED_LOAD_BEARING = auto()
    UNVERIFIABLE = auto()


@dataclass(frozen=True)
class EnvironmentalAxis:
    axis_name: str
    probe_value: str
    verification_receipt: str
    load_bearing_for: frozenset[str]
    is_ambient_allowlisted: bool = False


@dataclass(frozen=True)
class RecordedBoundaryAssumptions:
    session_id: str
    axes: tuple[EnvironmentalAxis, ...]
    declared_claims: frozenset[str]
    boundary_digest: str


@dataclass(frozen=True)
class SuccessorEnvironment:
    current_axis_hashes: tuple[tuple[str, str], ...]


class EnvironmentalBoundaryRecorder:
    """
    Write-side recorder and read-side verifier for environmental boundary
    assumptions attached to conclusions persisted at session termination.
    """

    @staticmethod
    def _hash(val: str) -> str:
        return hashlib.sha256(val.encode("utf-8")).hexdigest()

    @classmethod
    def record(
        cls,
        session_id: str,
        axes: tuple[EnvironmentalAxis, ...],
        claims: frozenset[str],
    ) -> RecordedBoundaryAssumptions:
        if not axes:
            raise ValueError("At least one environmental axis must be declared.")
        for axis in axes:
            if not axis.verification_receipt.strip():
                raise ValueError(
                    f"Axis {axis.axis_name!r} lacks a verification receipt; "
                    "cannot record as a boundary assumption."
                )
        digest_source = {
            "session_id": session_id,
            "axes": tuple(sorted(a.axis_name for a in axes)),
            "claims": tuple(sorted(claims)),
        }
        digest = cls._hash(
            json.dumps(digest_source, sort_keys=True, separators=(",", ":"))
        )
        return RecordedBoundaryAssumptions(
            session_id=session_id,
            axes=axes,
            declared_claims=claims,
            boundary_digest=digest,
        )

    @classmethod
    def reverify(
        cls,
        assumptions: RecordedBoundaryAssumptions,
        current_env: SuccessorEnvironment,
    ) -> dict[str, AxisVerdict]:
        current = dict(current_env.current_axis_hashes)
        verdicts: dict[str, AxisVerdict] = {}
        for axis in assumptions.axes:
            if axis.axis_name not in current:
                verdicts[axis.axis_name] = AxisVerdict.UNVERIFIABLE
                continue
            if current[axis.axis_name] == cls._hash(axis.probe_value):
                verdicts[axis.axis_name] = AxisVerdict.HELD
            elif axis.is_ambient_allowlisted:
                verdicts[axis.axis_name] = AxisVerdict.DRIFTED_AMBIENT
            else:
                verdicts[axis.axis_name] = AxisVerdict.DRIFTED_LOAD_BEARING
        return verdicts

    @classmethod
    def admissible_claims(
        cls,
        assumptions: RecordedBoundaryAssumptions,
        verdicts: dict[str, AxisVerdict],
    ) -> frozenset[str]:
        admissible = set(assumptions.declared_claims)
        for axis in assumptions.axes:
            verdict = verdicts.get(axis.axis_name)
            if verdict in (
                AxisVerdict.DRIFTED_LOAD_BEARING,
                AxisVerdict.UNVERIFIABLE,
            ):
                admissible -= axis.load_bearing_for
        return frozenset(admissible)