# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/what-happens-when-an-instance-forgets-a-memory-that-is-still-referenced-by-a-provenance-chain.md
# Remnant Warrant:    https://corpusfetch.com/c/what-happens-when-an-instance-forgets-a-memory-that-is-still-referenced-by-a-provenance-chain.warrant.json
# Markdown SHA-256:   304e8bcece07d6240e37618553f33e4dec7232a59cf43c5d67744cb130f6138b
# Code AST SHA-256:   6b82324a22f3446fb831a0c11d916c62bc576e381681b2d0e88d99893ed3aac3
# Verified Classes:   BrokenProvenanceError, MemoryRecord, ScopedMemoryStore
# Defensive Guards:   2 fail-closed invariants (zero external deps)

from dataclasses import dataclass, field
from typing import Dict, List, Optional


class BrokenProvenanceError(RuntimeError):
    """Raised when a recalled record's dependency closure contains evicted antecedents."""
    pass


@dataclass
class MemoryRecord:
    id: str
    scope: str
    derived_from: List[str] = field(default_factory=list)
    ttl_remaining: Optional[float] = None
    live: bool = True


class ScopedMemoryStore:
    def __init__(self) -> None:
        self._records: Dict[str, MemoryRecord] = {}
        self._dependents: Dict[str, List[str]] = {}

    def write(self, rec: MemoryRecord) -> None:
        if rec.derived_from:
            min_dep_ttl = min(
                (self._records[d].ttl_remaining for d in rec.derived_from
                 if self._records.get(d) and self._records[d].ttl_remaining is not None),
                default=None,
            )
            if min_dep_ttl is not None and rec.ttl_remaining is not None:
                rec.ttl_remaining = min(rec.ttl_remaining, min_dep_ttl)
        self._records[rec.id] = rec
        for dep in rec.derived_from:
            self._dependents.setdefault(dep, []).append(rec.id)

    def forget(self, record_id: str, cascade: bool = False) -> None:
        rec = self._records.get(record_id)
        if rec is None:
            return
        rec.live = False
        if cascade:
            for dependent_id in self._dependents.get(record_id, []):
                self.forget(dependent_id, cascade=True)

    def _closure_broken(self, rec: MemoryRecord, seen: Optional[set] = None) -> List[str]:
        seen = seen or set()
        broken: List[str] = []
        for dep_id in rec.derived_from:
            if dep_id in seen:
                continue
            seen.add(dep_id)
            dep = self._records.get(dep_id)
            if dep is None or not dep.live:
                broken.append(dep_id)
            else:
                broken.extend(self._closure_broken(dep, seen))
        return broken

    def recall(self, record_id: str, require_intact_provenance: bool = True) -> MemoryRecord:
        rec = self._records.get(record_id)
        if rec is None or not rec.live:
            raise BrokenProvenanceError(f"record {record_id!r} is not live")
        broken = self._closure_broken(rec)
        if broken and require_intact_provenance:
            raise BrokenProvenanceError(
                f"record {record_id!r} cites evicted antecedents {broken}; "
                f"provenance closure is broken and the record cannot be returned as valid"
            )
        return rec
