lease_machines 0.1.6-aarch64-linux

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f58d55d1036fccfec406afa28a9fe41d7377ce663f3681d6b3b2025b808051c1
+  data.tar.gz: 3265fb1457c7f2a3f31fdb3288d9c6ddcab6876c80cdfbe55780fdd78e7c8a9b
+SHA512:
+  metadata.gz: 18354dad967f824971679f976b311f033ae4d038be40a7ce887f2c6536f55a635600ed367aee68f54eba21517cc5a01af9c86709f7854bf29e903b10acfb42f5
+  data.tar.gz: 275b0b17670661c0c76ff4efcc479028800708816c07eaecc19010e6091c80d19274dacd8f9c8ba242cea11f825df61f24d782865a8e0884cdf3d0350b4f4075

data/CHANGELOG.md

@@ -0,0 +1,43 @@
+# Changelog
+
+## [0.1.6](https://github.com/seuros/lease_machines/compare/lease_machines/v0.1.5...lease_machines/v0.1.6) (2026-11-06)
+
+
+### Bug Fixes
+
+* share lease renew/release checks in authority ([3c44626](https://github.com/seuros/lease_machines/commit/3c446267e004228b03df335e577f35b19b0c645f))
+
+## [0.1.5](https://github.com/seuros/lease_machines/compare/lease_machines/v0.1.4...lease_machines/v0.1.5) (2026-11-06)
+
+
+### Features
+
+* rebuild authorities from storage and model the holder side ([5fe2199](https://github.com/seuros/lease_machines/commit/5fe2199af3efca8666f5015511649c802d95b77f))
+
+## [0.1.4](https://github.com/seuros/lease_machines/compare/lease_machines/v0.1.3...lease_machines/v0.1.4) (2026-11-06)
+
+
+### Bug Fixes
+
+* crates.io keywords and categories for the core ([c4f147f](https://github.com/seuros/lease_machines/commit/c4f147f9cb2d69bac209d2d1c50e851f5137ff80))
+
+## [0.1.3](https://github.com/seuros/lease_machines/compare/lease_machines/v0.1.2...lease_machines/v0.1.3) (2026-11-06)
+
+
+### Bug Fixes
+
+* keep test sources out of the packaged gem and crate ([6f0b979](https://github.com/seuros/lease_machines/commit/6f0b979351f1fe456d7ae922203f1ec69274d70d))
+
+## [0.1.2](https://github.com/seuros/lease_machines/compare/lease_machines/v0.1.1...lease_machines/v0.1.2) (2026-11-06)
+
+
+### Bug Fixes
+
+* cross builds no longer compile for the host ([e7571a9](https://github.com/seuros/lease_machines/commit/e7571a988886534052055c05b31d97a686aaeca7))
+
+## [0.1.1](https://github.com/seuros/lease_machines/compare/lease_machines-v0.1.0...lease_machines/v0.1.1) (2026-11-06)
+
+
+### Features
+
+* initial extraction ([243e8f6](https://github.com/seuros/lease_machines/commit/243e8f642f63cc2dd61a61524de0f45cd858ab96))

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Abdelkader Boudih
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,236 @@
+# LeaseMachines
+
+> Expiry tells the next worker it may start. The fence tells the last one it must stop. 🔑
+
+Time-limited ownership for Ruby. One `Authority` decides who holds a resource and until when. Every grant comes with a token that only ever goes up. A `Fence` at the resource turns away any token older than the last one it saw. That's how a worker that fell asleep holding the key finds out, on waking, that it's no longer the captain.
+
+## Quick Start
+
+```bash
+gem 'lease_machines'
+```
+
+```ruby
+authority = LeaseMachines::Authority.new
+
+grant = authority.acquire(owner: worker.id, now: clock.now, ttl: 30.0)
+grant.status        # => :granted
+grant.lease.token   # => 1
+
+# ... do the work, renewing before the ttl runs out ...
+authority.renew(owner: worker.id, token: grant.lease.token, now: clock.now, ttl: 30.0)
+
+# ... and hand it back when done.
+authority.release(owner: worker.id, token: grant.lease.token, now: clock.now)
+```
+
+At the resource, keep a fence and show it every token before you touch anything:
+
+```ruby
+fence = LeaseMachines::Fence.new
+
+fence.accept(1)  # => true, first key seen
+fence.accept(2)  # => true, newer key
+fence.accept(1)  # => false, that captain is retired
+```
+
+## A Message to the Resistance
+
+So you put a lock in Redis. `SET nightly_report_lock worker-7 NX EX 30`. One worker runs the report, the others back off, everyone goes home.
+
+Then worker 7 hits a stop-the-world GC pause for forty seconds. The lock expires. Worker 12 takes it and starts writing the report. Worker 7 wakes up, has no idea anything happened, and finishes writing *its* report over the top of 12's.
+
+The lock did its job. It expired on time. The problem is that expiry only tells the *next* owner it can start. It never tells the *old* owner it has to stop, because the old owner isn't listening. It's busy.
+
+The only thing that works is a number. Every grant gets a bigger number than the last one, and the thing being protected refuses any number smaller than the biggest it has seen. Worker 7 shows up with token 1. The report store has already seen token 2. Door stays shut.
+
+This gem is that number, and the authority that hands it out.
+
+## Chapter 1: Stardate 2025.186, the AMS Cheriton
+
+> **AMS Cheriton**, NCC-4211, *Cheriton*-class authority tender.
+> An old captain's key must not open the engine room after a new command takes over.
+
+The tender doesn't guard the engine room. It issues keys, each stamped with a higher serial than the last, each valid until a stated time. The engine room hatch keeps its own record of the highest serial it has ever accepted. A captain who went out of radio range and came back still holding serial 1 finds a hatch that has already seen serial 2.
+
+Somewhere in the fleet, an ensign proposes:
+
+```ruby
+def run_nightly_report
+  return unless redis.set("lock", id, nx: true, ex: 30)
+  generate_report   # takes "about 20 seconds", usually
+  redis.del("lock")
+end
+```
+
+"That," says the quartermaster, "is how two captains end up writing the same log."
+
+## The Flight Plan
+
+```mermaid
+stateDiagram-v2
+    [*] --> vacant
+    vacant --> held: acquire, granted (token n)
+    held --> held: renew by owner with current token
+    held --> vacant: release by owner with current token
+    held --> vacant: acquire by anyone after expiry (token n+1)
+    held --> held: acquire by another owner before expiry, occupied
+```
+
+And the night worker 7 fell asleep:
+
+```mermaid
+sequenceDiagram
+    participant W7 as Worker 7
+    participant A as Authority
+    participant W12 as Worker 12
+    participant F as Fence at report store
+
+    W7->>A: acquire(owner 7, ttl 30)
+    A-->>W7: granted, token 1
+    W7->>F: accept(1)
+    F-->>W7: true
+    Note over W7: starts writing... then stalls for 40s
+
+    W12->>A: acquire(owner 12) at t=35
+    A-->>W12: granted, token 2 (lease 1 expired)
+    W12->>F: accept(2)
+    F-->>W12: true
+    Note over W12: writes the report
+
+    Note over W7: wakes up, still holding token 1
+    W7->>F: accept(1)
+    F-->>W7: false
+    Note over F: highest seen is 2. Door stays shut.
+```
+
+## How Authority Works
+
+### Acquire
+
+```ruby
+authority = LeaseMachines::Authority.new
+
+first = authority.acquire(owner: 1, now: 0.0, ttl: 2.0)
+first.status            # => :granted
+first.lease.owner       # => 1
+first.lease.token       # => 1
+first.lease.expires_at  # => 2.0
+```
+
+Every call returns a `Decision` with `status`, `lease`, and `reason`. A grant has a lease and no reason. A rejection has a reason and no lease.
+
+```ruby
+authority.acquire(owner: 2, now: 1.0, ttl: 2.0).reason   # => :occupied
+```
+
+Owner 2 asked at second 1. Owner 1's lease runs to second 2. Occupied. Ask again after it lapses and the answer changes:
+
+```ruby
+later = authority.acquire(owner: 2, now: 2.0, ttl: 2.0)
+later.status        # => :granted
+later.lease.token   # => 2
+```
+
+Token 2. Always bigger. Never reused.
+
+### Renew
+
+The holder extends the lease by presenting its token. The new expiry is counted from `now`, not from the old expiry.
+
+```ruby
+authority = LeaseMachines::Authority.new
+grant = authority.acquire(owner: 1, now: 0.0, ttl: 2.0)
+
+renewed = authority.renew(owner: 1, token: 1, now: 1.0, ttl: 3.0)
+renewed.status             # => :renewed
+renewed.lease.expires_at   # => 4.0
+```
+
+Renew with a token the authority didn't issue, or with the wrong owner, and you get a reason instead:
+
+```ruby
+authority.renew(owner: 1, token: 2, now: 1.0, ttl: 1.0).reason   # => :stale_token
+```
+
+### Release
+
+```ruby
+authority.release(owner: 1, token: 1, now: 2.0).status   # => :released
+```
+
+Release after the lease already lapsed and the authority tells you so:
+
+```ruby
+authority = LeaseMachines::Authority.new
+authority.acquire(owner: 1, now: 0.0, ttl: 1.0)
+authority.release(owner: 1, token: 1, now: 3.0).reason   # => :expired
+```
+
+### Time only moves forward
+
+You supply `now`. The authority remembers the latest `now` it has seen and refuses to go backwards.
+
+```ruby
+authority = LeaseMachines::Authority.new
+authority.acquire(owner: 1, now: 2.0, ttl: 1.0)
+authority.acquire(owner: 2, now: 1.0, ttl: 1.0).reason   # => :clock_regressed
+```
+
+Feed it a monotonic clock, not the wall clock. A `ttl` of zero is `:invalid_ttl`.
+
+## The Fence
+
+The authority decides who *should* have the resource. The fence is what the resource actually checks. Keep one next to the thing you're protecting and call `accept` with the token before every mutation. `highest` tells you the high-water mark it's enforcing.
+
+Restarted the resource and remembered that mark? Start the fence from there:
+
+```ruby
+fence = LeaseMachines::Fence.new(highest: 2)
+fence.accept(2)     # => true, equal is fine
+fence.accept(1)     # => false
+fence.highest       # => 2
+```
+
+`accept` says nothing about expiry or authenticity. It only answers one question: have I seen a newer key than this one? That question is the whole point.
+
+## Checkpoints
+
+An authority can hand you a `Checkpoint` and later be rebuilt from it. The rebuilt authority remembers the highest token it ever issued, so the serial numbers keep climbing across the restart.
+
+```ruby
+authority = LeaseMachines::Authority.new
+authority.acquire(owner: 1, now: 0.0, ttl: 1.0)
+
+checkpoint = authority.checkpoint
+checkpoint.last_issued   # => 1
+
+restored = LeaseMachines::Authority.restore(checkpoint)
+restored.acquire(owner: 2, now: 1.0, ttl: 1.0).lease.token   # => 2
+```
+
+Stop the old authority before you start the one you restored. Two authorities for one resource is two captains.
+
+## The Rules of the Tender
+
+- **Owners and tokens are Integers** in `0..2**64-1`. Tokens start at 1. Floats raise `TypeError`, out-of-range raises `RangeError`.
+- **Times are Floats** in seconds from a monotonic origin you choose. Negative, infinite, or NaN raise `ArgumentError`.
+- **Rejections don't raise.** Wrong owner, stale token, expired lease, clock regression, bad ttl: all come back as a `Decision` with a `reason`. Only malformed input raises.
+- **Frozen means frozen.** `freeze` an authority or a fence and every mutation raises `FrozenError`.
+
+## What You Think You're Doing vs Reality
+
+### You Think: "The lock has a TTL, so stale holders can't hurt anyone."
+### Reality: A stale holder doesn't know it's stale.
+
+Expiry frees the resource for the next owner. It does nothing to the previous one, who may be mid-write, paused, or partitioned, and will finish whatever it was doing the moment it can. The fence is what stops that write. Without it the TTL is a courtesy, not a guarantee.
+
+## What's Yours
+
+The authority is a decision engine, not a server. Run one per resource, make sure its decisions are written down before anyone acts on them, and feed it a clock that never runs backwards. Put the fence as close to the protected data as you can get it, ideally in the same transaction as the write.
+
+## License
+
+MIT License. See [LICENSE.txt](LICENSE.txt) for details.
+
+**Remember: Worker 7 is still out there, still holding token 1, still sure it's the captain.**

data/ext/lease_machines_native/core/CHANGELOG.md

@@ -0,0 +1,36 @@
+# Changelog
+
+## [0.3.1](https://github.com/seuros/lease_machines/compare/lease-machines-v0.3.0...lease-machines-v0.3.1) (2026-11-06)
+
+
+### Bug Fixes
+
+* share lease renew/release checks in authority ([3c44626](https://github.com/seuros/lease_machines/commit/3c446267e004228b03df335e577f35b19b0c645f))
+
+## [0.3.0](https://github.com/seuros/lease_machines/compare/lease-machines-v0.2.2...lease-machines-v0.3.0) (2026-11-06)
+
+
+### Features
+
+* rebuild authorities from storage and model the holder side ([5fe2199](https://github.com/seuros/lease_machines/commit/5fe2199af3efca8666f5015511649c802d95b77f))
+
+## [0.2.2](https://github.com/seuros/lease_machines/compare/lease-machines-v0.2.1...lease-machines-v0.2.2) (2026-11-06)
+
+
+### Bug Fixes
+
+* crates.io keywords and categories for the core ([c4f147f](https://github.com/seuros/lease_machines/commit/c4f147f9cb2d69bac209d2d1c50e851f5137ff80))
+
+## [0.2.1](https://github.com/seuros/lease_machines/compare/lease-machines-v0.2.0...lease-machines-v0.2.1) (2026-11-06)
+
+
+### Bug Fixes
+
+* keep test sources out of the packaged gem and crate ([6f0b979](https://github.com/seuros/lease_machines/commit/6f0b979351f1fe456d7ae922203f1ec69274d70d))
+
+## [0.2.0](https://github.com/seuros/lease_machines/compare/lease-machines-v0.1.0...lease-machines-v0.2.0) (2026-11-06)
+
+
+### Features
+
+* initial extraction ([243e8f6](https://github.com/seuros/lease_machines/commit/243e8f642f63cc2dd61a61524de0f45cd858ab96))

data/ext/lease_machines_native/core/README.md

@@ -0,0 +1,172 @@
+# lease-machines
+
+> **AMS Cheriton**, NCC-4211, *Cheriton*-class authority tender.
+
+Engine-room flight manual: model expiring command keys and resource-side fencing.
+
+A deterministic **single-authority decision model**, not a distributed lock,
+failure detector, consensus protocol, or storage backend.
+
+## Lease Lifecycle
+
+```rust
+use core::time::Duration;
+use lease_machines::{Decision, LeaseAuthority, OwnerId, Rejection};
+
+let mut authority = LeaseAuthority::new();
+let first = authority.acquire(
+    OwnerId::new(1), Duration::ZERO, Duration::from_secs(5),
+);
+let Decision::Granted(lease) = first else {
+    panic!("a fresh authority should grant");
+};
+assert_eq!(
+    authority.acquire(OwnerId::new(2), Duration::from_secs(1), Duration::from_secs(5)),
+    Decision::Rejected(Rejection::Occupied),
+);
+assert_eq!(
+    authority.release(OwnerId::new(1), lease.token(), Duration::from_secs(2)),
+    Decision::Released,
+);
+```
+
+- Each authority instance models **one resource and one token namespace**.
+- Every acquisition, even by the same owner after release/expiry, gets a strictly
+  greater token. Renewal retains the token and never shortens its expiration.
+- A lease expires at `now >= expires_at`. Renewal cannot resurrect an expired
+  lease. Release and renewal require both the current owner and current token.
+- Supply durations from one monotonic origin. Regressing observations are rejected.
+  Non-regressing observations advance the clock even when the request is rejected.
+- Zero TTL and deadline overflow are rejected. Exhausted token space fails closed;
+  tokens never wrap.
+- `reacquire` is `acquire` plus one exception: the current owner may rotate its own
+  unexpired grant to a new token. The old token is stale from then on, so anything
+  still holding it is fenced. Another owner's live grant is still `Occupied`.
+
+## Rebuilding an Authority from Storage
+
+```rust
+use core::time::Duration;
+use lease_machines::{Checkpoint, Decision, FencingToken, Lease, LeaseAuthority, OwnerId};
+
+# fn example() -> Option<()> {
+// One row per resource: owner id, token, expires_at (ms), token high-water.
+let (owner, token, expires_at_ms, last_issued) = (7_u64, 3_u64, 9_000_u64, 3_u64);
+let lease = Lease::new(
+    OwnerId::new(owner), FencingToken::new(token)?, Duration::from_millis(expires_at_ms),
+);
+let committed = Checkpoint::from_parts(FencingToken::new(last_issued), Some(lease), Duration::ZERO)?;
+let mut authority = LeaseAuthority::restore(committed);
+let Decision::Granted(next) = authority.acquire(
+    OwnerId::new(8), Duration::from_millis(9_000), Duration::from_secs(5),
+) else {
+    panic!("the previous grant expired");
+};
+assert_eq!(next.token().value(), 4);
+# Some(())
+# }
+# assert_eq!(example(), Some(()));
+```
+
+- `OwnerId` and `FencingToken` are plain `u64` on the wire: `new()` in, `value()` out.
+  String owners hash to a `u64` on the caller's side; the authority only compares.
+- `from_parts` refuses a lease whose token the history never issued. Keep the
+  high-water column even after release; it is what makes the next token greater.
+- `observed` is the clock watermark. Pass `Duration::ZERO` when storage keeps none,
+  and the authority trusts whatever `now` the next request brings.
+
+## Clocks
+
+Time is a `Duration` from an origin the caller picks: a monotonic start, or the Unix
+epoch when the clock is a database's wall clock in milliseconds. One origin per
+authority history.
+
+By default an observation earlier than the last one is `Rejection::ClockRegressed`
+and nothing changes. `with_clock_policy(ClockPolicy::Clamp)` evaluates such a request
+at the last observation instead: expiry checks and new deadlines use the later time,
+so a backwards step can never revive a lease or shorten one.
+
+## Fencing at the Protected Resource
+
+```rust
+use lease_machines::{Fence, FencingToken};
+
+# fn example() -> Option<()> {
+let old = FencingToken::new(7)?;
+let current = FencingToken::new(8)?;
+let mut fence = Fence::new(Some(old));
+assert!(fence.accept(current));
+assert!(!fence.accept(old));
+assert!(fence.accept(current)); // Multiple operations in one lease are allowed.
+# Some(())
+# }
+# assert_eq!(example(), Some(()));
+```
+
+Fencing rejects tokens lower than the highest token the resource has accepted.
+Equal tokens remain valid for repeated operations in the same lease.
+It does **not** prove current lease validity, authorize an owner, authenticate a
+token, or deduplicate operations. A resource cannot reject a newly stale owner on
+fencing grounds until it has observed a greater token. If immediate revocation is
+required, add an authority/expiry check under an appropriate protocol.
+
+## Holding a Lease
+
+```rust
+use core::time::Duration;
+use lease_machines::{Cadence, FencingToken, Holder, HolderState};
+
+# fn example() -> Option<()> {
+let secs = Duration::from_secs;
+let cadence = Cadence::new(secs(30), secs(10), secs(5))?;
+let mut holder = Holder::new(FencingToken::new(1)?, secs(0), cadence);
+assert!(!holder.renewal_due(secs(9)));
+assert!(holder.renewal_due(secs(10)));
+assert!(holder.refresh(secs(10)));
+assert_eq!(holder.state(), HolderState::Unconfirmed);
+assert!(holder.confirm(FencingToken::new(1)?, secs(11)));
+assert_eq!(holder.state(), HolderState::Confirmed);
+assert!(holder.at_risk(secs(36)));
+assert!(holder.expire());
+assert!(holder.reacquire(FencingToken::new(2)?, secs(40)));
+holder.fence();
+assert_eq!(holder.warning_deadline(), None);
+# Some(())
+# }
+# assert_eq!(example(), Some(()));
+```
+
+The holder is the other half of the conversation: it decides when to renew, how
+nervous to be, and when to stop writing. It runs on the holder's own clock and
+never compares instants with the authority.
+
+- `Confirmed` -> `refresh` -> `Unconfirmed`, or `AtRisk` once past the warning
+  deadline (`ttl - warn_before` after the last confirmation).
+- `confirm(token, at)` closes an attempt and reschedules. A response with an older
+  token than the current one is a stale reply and is ignored; the same or a newer
+  token is accepted.
+- `expire` means the authority said so; only `reacquire` with a strictly newer token
+  recovers. `fence` is terminal and idempotent; every predicate answers accordingly.
+- `renewal_due` is true whenever a renewal is outstanding, so a failed attempt
+  retries on the next poll without any extra state.
+
+## Required Runtime and Persistence Contract
+
+1. There must be one serialized authoritative history per resource. A local
+   mutable instance is not enough to arbitrate across partitioned servers.
+2. Commit authority state, including token high-water mark, active lease, and
+   releases/renewals, **before exposing successful decisions**. On uncertain
+   persistence, stop serving and recover; do not continue from ambiguous state.
+3. Resource adapters must authenticate issued tokens and atomically persist
+   their fencing high-water mark **with the protected mutation**. A separate
+   `accept()` call followed by an unguarded write is not safe under concurrency.
+4. Restore only the newest committed authority checkpoint, with the same clock
+   origin. Never roll back token state or start `new()` over an existing namespace.
+   A reboot or clock-origin change requires an external recovery protocol;
+   replaying old monotonic durations is not sufficient.
+5. Fence state must also survive resource restarts. Token comparisons are only
+   meaningful within the same resource namespace.
+
+`checkpoint()` / `restore()` provide an opaque typed state transfer for a host
+or deterministic simulation. There is no wire format, storage adapter, distributed
+replication, or crash-safe persistence implementation in this initial version.

data/ext/lease_machines_native/extconf.rb

@@ -0,0 +1,2 @@
+# frozen_string_literal: true
+require_relative 'ffi/extconf'

data/lib/lease_machines/version.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+module LeaseMachines
+  VERSION = '0.1.6'
+end

data/lib/lease_machines.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+require_relative 'lease_machines/version'
+require 'lease_machines_native/lease_machines_native'
+
+module LeaseMachines
+  Decision = Data.define(:status, :lease, :reason)
+
+  class Authority
+    def acquire(owner:, now:, ttl:)
+      Decision.new(*_acquire(owner, now, ttl))
+    end
+
+    def renew(owner:, token:, now:, ttl:)
+      Decision.new(*_renew(owner, token, now, ttl))
+    end
+
+    def release(owner:, token:, now:)
+      Decision.new(*_release(owner, token, now))
+    end
+
+    private :_acquire, :_renew, :_release
+  end
+
+  class Fence
+    def self.new(highest: nil) = _new(highest)
+    private_class_method :_new
+  end
+end

data/sig/lease_machines.rbs

@@ -0,0 +1,30 @@
+module LeaseMachines
+  VERSION: String
+  class Lease
+    def owner: () -> Integer
+    def token: () -> Integer
+    def expires_at: () -> Float
+  end
+  class Checkpoint
+    def last_issued: () -> Integer?
+    def observed: () -> Float
+  end
+  class Decision < Data
+    attr_reader status: Symbol
+    attr_reader lease: Lease?
+    attr_reader reason: Symbol?
+  end
+  class Authority
+    def self.new: () -> instance
+    def self.restore: (Checkpoint) -> instance
+    def acquire: (owner: Integer, now: Float, ttl: Float) -> Decision
+    def renew: (owner: Integer, token: Integer, now: Float, ttl: Float) -> Decision
+    def release: (owner: Integer, token: Integer, now: Float) -> Decision
+    def checkpoint: () -> Checkpoint
+  end
+  class Fence
+    def self.new: (?highest: Integer?) -> instance
+    def accept: (Integer) -> bool
+    def highest: () -> Integer?
+  end
+end

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification
+name: lease_machines
+version: !ruby/object:Gem::Version
+  version: 0.1.6
+platform: aarch64-linux
+authors:
+- Abdelkader Boudih
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2026-11-06 00:00:00.000000000 Z
+dependencies: []
+description: Thin Ruby bindings to the standalone lease-machines core; durability,
+  clocks, and resource enforcement belong to the caller.
+email:
+- oss@seuros.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- ext/lease_machines_native/core/CHANGELOG.md
+- ext/lease_machines_native/core/README.md
+- ext/lease_machines_native/extconf.rb
+- lib/lease_machines.rb
+- lib/lease_machines/version.rb
+- lib/lease_machines_native/lease_machines_native.so
+- sig/lease_machines.rbs
+homepage: https://github.com/seuros/lease_machines
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/seuros/lease_machines
+  rubygems_mfa_required: 'true'
+  cargo_crate_name: lease_machines_native
+  cargo_manifest_path: ext/lease_machines_native/ffi/Cargo.toml
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '4.0'
+  - - "<"
+    - !ruby/object:Gem::Version
+      version: 4.1.dev
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.23
+signing_key: 
+specification_version: 4
+summary: Native lease lifecycle and fencing decisions for Ruby
+test_files: []