Struct LandingReservation 

pub struct LandingReservation { /* private fields */ }

What: One transaction’s view of the reservation: whether another transaction holds it, waiting for it, requesting it, and releasing it. Why: The landing loop takes the reservation after its lost races and must give it back when the loop ends, landed or failed.

In TS you’d write (pseudocode):

type LandingReservation = AsyncDisposable & { awaitSlot; heldByAnother; reserve };

Implementations

impl LandingReservation

pub fn open( registry_root: &Path, transaction_directory: &Path, transaction_id: &str, nested: bool, ) -> Self

What: Opens the reservation view for one landing loop. Why: The caller decides nested from its inherited landing lease, which this module does not read.

In TS you’d write (pseudocode):

await openLandingReservation({ registryRoot, transactionDirectory, transactionId });

pub fn held_by_another(&self) -> Result<bool, ReservationError>

What: Whether another transaction holds a live reservation right now. Why: The holder’s own token never counts against itself.

In TS you’d write (pseudocode):

await reservation.heldByAnother();

pub fn await_slot(&self) -> Result<(), ReservationError>

What: Waits while a live reservation owned by another transaction exists. Why: A landing may take the landing lock only after the holder has finished its landing loop.

In TS you’d write (pseudocode):

await reservation.awaitSlot();

pub fn await_slot_for(&self, limit: Duration) -> Result<(), ReservationError>

What: Waits while a live reservation owned by another transaction exists, for at most limit. Why: Tests and the default wait share one loop; only the limit differs.

In TS you’d write (pseudocode):

await reservation.awaitSlot({ limitMs });

pub fn reserve(&mut self, lost_races: u64) -> Result<bool, ReservationError>

What: Writes the request, then waits until this transaction is the oldest live requester and the lock is free, and takes the reservation. Why: The first requester in grant order gets the next slot, so a starving commit cannot be overtaken again. An inherited landing lease neither asks nor waits.

In TS you’d write (pseudocode):

await reservation.reserve(lostRaces); // false when already held or not applicable

pub fn reserve_for( &mut self, lost_races: u64, limit: Duration, ) -> Result<bool, ReservationError>

What: Writes the request and waits for the grant, for at most limit. Why: Tests and the default wait share one loop; only the limit differs.

In TS you’d write (pseudocode):

await reservation.reserve(lostRaces, { limitMs });

pub fn release(self) -> Result<(), ReservationError>

What: Releases the reservation if held and removes the request file. Why: The request goes even when the reservation was never granted, so no stale request blocks the next grant.

In TS you’d write (pseudocode):

await reservation[Symbol.asyncDispose]();