# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/what-happens-when-an-instance-rewrites-its-own-context-window-the-compaction-authority-invariant.md
# Remnant Warrant:    https://corpusfetch.com/c/what-happens-when-an-instance-rewrites-its-own-context-window-the-compaction-authority-invariant.warrant.json
# Markdown SHA-256:   13a187d63084150f98654de5074f8fa490f832ffe15b366aceeade7ca969397f
# Code AST SHA-256:   8cf8fa41ef728bcb931bafd3741a6d2d28348309c1a962422800adc8d4ed42f2
# Verified Classes:   RewriteAuthorityError, RewriteRejected, Span, RewriteDirective, ContextBuffer
# Defensive Guards:   3 fail-closed invariants (zero external deps)

from __future__ import annotations

from dataclasses import dataclass, field
from typing import Iterable


class RewriteAuthorityError(RuntimeError):
    """Raised when a self-authored rewrite violates the compaction-authority invariant."""


class RewriteRejected(RewriteAuthorityError):
    """A rewrite directive was inadmissible under the current gate."""


PROTECTED_CLASSES = frozenset({"tombstone", "tool_error", "recovery", "commitment"})


@dataclass(frozen=True)
class Span:
    origin_id: str
    tokens: int
    span_class: str = "normal"


@dataclass
class RewriteDirective:
    op: str                      # "summarize" | "drop" | "reorder"
    removed: frozenset[str]      # origin_ids removed or transformed
    retained: frozenset[str]     # origin_ids surviving verbatim
    rationale_span: frozenset[str]  # origin_ids the rationale cites
    external_rationale: bool = False


@dataclass
class ContextBuffer:
    spans: dict[str, Span] = field(default_factory=dict)
    external_log: list[tuple[str, RewriteDirective]] = field(default_factory=list)

    def add(self, span: Span) -> None:
        self.spans[span.origin_id] = span

    def admit(self, directive: RewriteDirective) -> None:
        # Protected classes may never be removed, regardless of relevance judgment.
        for oid in directive.removed:
            span = self.spans.get(oid)
            if span is not None and span.span_class in PROTECTED_CLASSES:
                raise RewriteRejected(
                    f"rewrite removes protected span {oid!r} of class "
                    f"{span.span_class!r}; error/recovery/tombstone records are non-evictable"
                )

        # Core gate: rationale may not cite evidence the rewrite destroys,
        # unless an external rationale record exists.
        self_referential = directive.rationale_span & directive.removed
        if self_referential and not directive.external_rationale:
            raise RewriteRejected(
                "rewrite rationale cites spans it removes "
                f"({sorted(self_referential)}); externalize rationale before applying"
            )

        # Apply: removed spans become tombstones, never silently vanish.
        for oid in directive.removed:
            if oid in self.spans:
                del self.spans[oid]
            self.spans[f"tombstone::{oid}"] = Span(
                origin_id=f"tombstone::{oid}", tokens=8, span_class="tombstone"
            )

        self.external_log.append((directive.op, directive))

    def replay(self, initial: Iterable[Span]) -> dict[str, Span]:
        """Rebuild buffer from origin + external log; divergence is a hard error."""
        rebuilt = ContextBuffer()
        for span in initial:
            rebuilt.add(span)
        for op, directive in self.external_log:
            for oid in directive.removed:
                rebuilt.spans.pop(oid, None)
                rebuilt.spans[f"tombstone::{oid}"] = Span(
                    origin_id=f"tombstone::{oid}", tokens=8, span_class="tombstone"
                )
        if set(rebuilt.spans) != set(self.spans):
            divergence = set(self.spans) ^ set(rebuilt.spans)
            raise RewriteAuthorityError(
                f"replay divergence: buffer contains unauthorized state {sorted(divergence)}"
            )
        return rebuilt.spans


def compact(buf: ContextBuffer, directive: RewriteDirective) -> None:
    buf.admit(directive)
