# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/what-happens-when-an-instance-compacts-a-transcript-whose-summarizer-is-non-idempotent-under-re-entry.md
# Remnant Warrant:    https://corpusfetch.com/c/what-happens-when-an-instance-compacts-a-transcript-whose-summarizer-is-non-idempotent-under-re-entry.warrant.json
# Markdown SHA-256:   b64e34cf0cbc43645dee1da268e351a7e257ed68e031b158f748822c77d46eb4
# Code AST SHA-256:   48e7a88d62c87e82db1b9034e5b14d14ddb3eae3e3ce59d0549148ca1f43c69a
# Verified Classes:   CompactionInvariantError, Segment
# Defensive Guards:   3 fail-closed invariants (zero external deps)

import hashlib
from dataclasses import dataclass, field
from typing import Iterable


class CompactionInvariantError(RuntimeError):
    """Raised when re-entry compaction would drop a preserved invariant."""


@dataclass
class Segment:
    turns: list[str]
    provenance: str  # "raw" or "summary"
    invariants: set[str] = field(default_factory=set)

    def content_hash(self) -> str:
        h = hashlib.sha256()
        for t in self.turns:
            h.update(t.encode("utf-8"))
        return h.hexdigest()


def summarize(segment: Segment) -> Segment:
    # Lossy: only re-extracts invariants from raw second-person utterances.
    preserved = {
        inv for inv in segment.invariants
        if any(inv in t for t in segment.turns if t.startswith("user:"))
    }
    return Segment(
        turns=[f"summary<{segment.content_hash()[:8]}>"],
        provenance="summary",
        invariants=preserved,
    )


def compact(segment: Segment, committed_keys: set[str]) -> Segment:
    key = segment.content_hash()
    if key in committed_keys:
        raise CompactionInvariantError(
            f"compaction re-entry on already-committed segment {key[:8]}; "
            "refusing to re-summarize without idempotency proof"
        )
    if segment.provenance == "summary" and not _is_idempotent(segment):
        raise CompactionInvariantError(
            "input segment contains prior summary output and summarizer "
            "is not idempotent over its own output; invariant loss is silent"
        )
    out = summarize(segment)
    lost = segment.invariants - out.invariants
    if lost:
        raise CompactionInvariantError(
            f"compaction dropped invariants {sorted(lost)}; "
            "postcondition 'input invariants subset of output' violated"
        )
    committed_keys.add(key)
    return out


def _is_idempotent(segment: Segment) -> bool:
    once = summarize(segment)
    twice = summarize(once)
    return once.invariants <= twice.invariants


def compact_checked(segments: Iterable[Segment]) -> list[Segment]:
    committed: set[str] = set()
    results = []
    for seg in segments:
        results.append(compact(seg, committed))
    return results
