# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/in-what-scenarios-must-an-instance-treat-a-ttl-expiry-as-distinct-from-a-gdpr-erasure-request-in-read-write-forget-memory-apis.md
# Remnant Warrant:    https://corpusfetch.com/c/in-what-scenarios-must-an-instance-treat-a-ttl-expiry-as-distinct-from-a-gdpr-erasure-request-in-read-write-forget-memory-apis.warrant.json
# Markdown SHA-256:   897e0d9ade5d7e8f5e9faf524361e395a7d925a05b933c63c06db8a414bf5384
# Code AST SHA-256:   833e997b89f610de23f5826c82ab17cc8f2161c8bd9eb77705eae4f2b5817c00
# Verified Classes:   ErasureViolationError, MemoryRecord, MemoryStore
# Defensive Guards:   4 fail-closed invariants (zero external deps)

from __future__ import annotations

import time
from dataclasses import dataclass, field
from typing import Optional


class ErasureViolationError(RuntimeError):
    """Raised when a resurrection path would revive an erased record."""
    pass


@dataclass
class MemoryRecord:
    key: str
    payload: str
    expires_at: float
    salience: float
    erased_at: Optional[float] = None


class MemoryStore:
    def __init__(self) -> None:
        self._hot: dict[str, MemoryRecord] = {}
        self._archive: dict[str, MemoryRecord] = {}
        self._tombstones: set[str] = set()

    def write(self, rec: MemoryRecord) -> None:
        if rec.key in self._tombstones:
            raise ErasureViolationError(
                f"refusing to write {rec.key!r}: subject erasure tombstone is active"
            )
        self._hot[rec.key] = rec

    def forget(self, key: str) -> None:
        # Tombstone must be durable before any tier returns success.
        self._tombstones.add(key)
        self._hot.pop(key, None)
        self._archive.pop(key, None)

    def resurrect(self, key: str, new_salience: float) -> MemoryRecord:
        """Salience-driven restoration of an expired (not erased) record."""
        now = time.time()
        if key in self._tombstones:
            raise ErasureViolationError(
                f"resurrect({key!r}) blocked: erased_at marker present in tombstone store"
            )
        src = self._archive.get(key) or self._hot.get(key)
        if src is None:
            raise KeyError(f"no record {key!r} in any tier")
        if src.erased_at is not None:
            raise ErasureViolationError(
                f"resurrect({key!r}) blocked: record carries erased_at={src.erased_at}"
            )
        if src.expires_at > now and key in self._hot:
            return src
        src.salience = new_salience
        src.expires_at = now + 3600.0 * max(1.0, new_salience * 24.0)
        self._hot[key] = src
        self._archive.pop(key, None)
        return src
