# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/why-does-an-instance-accept-a-revoked-mcp-tool-manifest-when-the-revocation-is-signed-after-the-manifest-s-not-after-but-before-the-client-s-clock-ske.md
# Remnant Warrant:    https://corpusfetch.com/c/why-does-an-instance-accept-a-revoked-mcp-tool-manifest-when-the-revocation-is-signed-after-the-manifest-s-not-after-but-before-the-client-s-clock-ske.warrant.json
# Markdown SHA-256:   ee7f0250e4097939b6b0141fc024f24edc45e785dc0267b16966b93fb01e335a
# Code AST SHA-256:   ae2e52896299a6f3ac828991f6dbf6a168068ba369b960ea19545e08ee57cef0
# Verified Classes:   RevocationBypassError, Manifest, Revocation, ToolTrustStore
# Defensive Guards:   4 fail-closed invariants (zero external deps)

from __future__ import annotations

import time
from dataclasses import dataclass


class RevocationBypassError(RuntimeError):
    """Raised when an executable manifest escapes revocation evaluation."""


@dataclass(frozen=True)
class Manifest:
    digest: str
    not_after: float


@dataclass(frozen=True)
class Revocation:
    digest: str
    revoked_at: float


class ToolTrustStore:
    def __init__(self, skew: float = 300.0) -> None:
        self._active: dict[str, Manifest] = {}
        self._revoked: dict[str, float] = {}
        self._skew = skew

    def admit(self, m: Manifest) -> None:
        if m.digest in self._revoked:
            raise RevocationBypassError(
                f"refusing to admit revoked digest {m.digest}"
            )
        self._active[m.digest] = m

    def revoke(self, r: Revocation) -> None:
        self._revoked[r.digest] = r.revoked_at
        # Eager eviction: an executable copy must not survive revocation.
        self._active.pop(r.digest, None)

    def is_executable(self, digest: str) -> bool:
        return digest in self._active

    def authorize(self, digest: str, now: float | None = None) -> bool:
        now = time.time() if now is None else now
        m = self._active.get(digest)
        if m is None:
            return False
        # Revocation is evaluated unconditionally for executable manifests,
        # even if the manifest is past not_after + skew.
        revoked_at = self._revoked.get(digest)
        if revoked_at is not None and revoked_at <= now:
            raise RevocationBypassError(
                f"digest {digest} revoked at {revoked_at} but still executable"
            )
        if now > m.not_after + self._skew:
            # Expired: not refreshable, but still subject to revocation above.
            raise RevocationBypassError(
                f"digest {digest} expired at {m.not_after} yet present in tool table"
            )
        return True


def invoke(store: ToolTrustStore, digest: str, now: float) -> str:
    if not store.authorize(digest, now=now):
        raise RevocationBypassError(f"digest {digest} not authorized")
    return f"executed {digest}"
