Park index and park seams (tai42_kit.interactions)

BARRIER_TTL_MARGIN_SECONDS: Final[int] = 3600

DRIVE_LEASE_HEARTBEAT_SECONDS: Final[float] = 20.0

DRIVE_LEASE_SECONDS: Final[int] = 60

ENTRY_TTL_FLOOR_SECONDS: Final[int] = 30 * 24 * 3600

RESOLVED_FIELD: Final[str] = '__park_resolved__'

class Barrier

class BarrierNotFoundError(ParkIndexError)

class BufferResult

class DriveInProgressError(ParkIndexError)

class DriveLease

async acquire(self) -> DriveLease

async holds(self) -> bool

async release(self) -> None

async close(self) -> None

async mark_consumed(self) -> None

class LeaseLostError(ParkIndexError)

class ParkIndex

entry_key(self, entry_id: str) -> str

barrier_key(self, thread_id: str, superstep: str) -> str

lease_key(self, thread_id: str, superstep: str) -> str

resolution_key(self, thread_id: str, superstep: str) -> str

run_resolutions_key(self, thread_id: str) -> str

live_set_key(self, thread_id: str) -> str

async persist(
    self,
    *,
    thread_id: str,
    superstep: str,
    entries: Mapping[str, Mapping[str, Any]],
    expected: Mapping[str, Any],
    barrier_fields: Mapping[str, str] | None = None,
    entry_ttl: Mapping[str, int],
    barrier_ttl: int,
) -> None

async threads_with_live_barriers(self, thread_ids: Sequence[str]) -> set[str]

async read_entry(self, entry_id: str) -> dict[str, Any] | None

tombstone_kind(entry: Mapping[str, Any]) -> TombstoneKind

tombstone_coordinates(entry: Mapping[str, Any]) -> tuple[str, str]

async read_tombstone_resolution(self, entry: Mapping[str, Any]) -> ResolutionRecord | None

async read_barrier(self, thread_id: str, superstep: str) -> Barrier | None

async set_barrier_fields(self, thread_id: str, superstep: str, fields: Mapping[str, str]) -> bool

async buffer(self, thread_id: str, superstep: str, member_id: str, answer: Any) -> BufferResult

claim(self, thread_id: str, superstep: str) -> DriveLease

async finalize(
    self,
    lease: DriveLease,
    *,
    member_ids: Sequence[str],
    resolution: Resolution,
    value: Any,
) -> None

async read_resolution(self, thread_id: str, superstep: str) -> ResolutionRecord | None

async run_resolutions(self, thread_id: str) -> dict[str, list[str]]

async drop_run_resolutions(self, thread_id: str, *, keep: str | None = None) -> None

async drop_resolution(self, thread_id: str, superstep: str, *, member_ids: Iterable[str] = ()) -> None

async detach(self, entry_ids: Sequence[str]) -> None

async extend_horizon(self, entry_id: str, expiry_at: datetime | None) -> bool

class ParkIndexCorruptError(ParkIndexError)

class ParkIndexError(RuntimeError)

class ParkValueCodecError(ParkIndexError)

Resolution = Literal['terminal', 'suspended', 'aborted']

class ResolutionMissingError(ParkIndexError)

class ResolutionRecord

class SuperstepAlreadyResolvedError(ParkIndexError)

TombstoneKind = Literal['live', 'resolved', 'detached']

barrier_ttl_seconds(expiries: Iterable[datetime | None]) -> int

decode_value(encoded: Any) -> Any

encode_value(value: Any) -> dict[str, Any]

entry_ttl_seconds(expiry_at: datetime | None) -> int

resolution_ttl_seconds() -> int

superstep_id(member_ids: Iterable[str]) -> str

assert_park_adoptable(resume_owner: str | None, *, interaction_id: str, tool_name: str) -> None

attach_chained_park(key: str) -> None

chained_park_claims(claims: set[str] | None = None) -> Generator[set[str]]

is_chained_park_key(key: str) -> bool

new_chained_park_key() -> str

repark_notice(expiry_at: datetime | None) -> tuple[str, dict[str, Any]] | None

resolve_park_adoption(resume_owner: str | None, *, interaction_id: str, tool_name: str) -> tuple[str, str | None]

terminal_chain_notice(routing: ChainedResume, result: Any) -> tuple[str, dict[str, Any]]

ParkGiveUpHandler: TypeAlias = Callable[[str, Mapping[str, Any]], Awaitable[ParkGiveUpOutcome | None]]

class ParkGiveUpOutcome(NamedTuple)

async fire_park_giveup(interaction_id: str, failed_outcome: Mapping[str, Any]) -> ParkGiveUpOutcome | None

register_park_giveup_handler(handler: ParkGiveUpHandler) -> None