merge_machines 0.2.0-x86_64-linux

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2d0658ea6e6338e7e3e562c25a7252c24e1f1decf3d2e65672eefce6d8df8f76
+  data.tar.gz: cb093d38e65a6cdaa206a1bc6ae7c85eea3917a1fb54ff831ff8897d1d1fea9e
+SHA512:
+  metadata.gz: 2f62e616091582604a54cc1324b29b04bd2b9570db407b70080ed64b10d96d7a424a9df76652c8146565b3c53930f7b987b953e63a9926acb2f922d96bd46347
+  data.tar.gz: 6d8559d9f9cdba3dd029f5b4ba0d7dac389ac46d71fb0d82b29f333c310a3936442cf622e9b3cdb4ac4084b9ef52251f94db124ca345fd8fec58fbc917f599e9

data/CHANGELOG.md

@@ -0,0 +1,57 @@
+# Changelog
+
+## [0.2.0](https://github.com/seuros/merge_machines/compare/merge_machines-v0.1.0...merge_machines/v0.2.0) (2026-11-01)
+
+
+### ⚠ BREAKING CHANGES
+
+* hybrid timestamps cross the boundary as nanoseconds, not Float seconds
+
+### Features
+
+* CRDTs and the clocks they need ([0cf6b7f](https://github.com/seuros/merge_machines/commit/0cf6b7f8de95fc40b5cdb6f05a1bf4bcafe6e7af))
+* pass a rubygems OTP through the environment ([6834db9](https://github.com/seuros/merge_machines/commit/6834db97472a0028a6fa837d2cb3b845620d97e6))
+* Ruby gem, magnus FFI, and a codec for every state ([6be0bda](https://github.com/seuros/merge_machines/commit/6be0bdaea6317b2bc02087db28eb374c0eea88af))
+
+
+### Bug Fixes
+
+* a crowded reading let the hybrid clock reissue one timestamp ([4c4d139](https://github.com/seuros/merge_machines/commit/4c4d13942d5ccb3b70a5666f0b7306d1487d367b))
+* a merge that overran capacity kept the names of the keys it turned down ([fe5ac2a](https://github.com/seuros/merge_machines/commit/fe5ac2aaec8bf9db35e2131fb67951dcaf5c4c1b))
+* a PNCounter balance was the difference of two clamped totals ([dde63bc](https://github.com/seuros/merge_machines/commit/dde63bca70683ed8ba57deb962f980fab854b776))
+* a register that got its value by merging took a stale write ([ae393ef](https://github.com/seuros/merge_machines/commit/ae393efc1fdaf8bf3980d70e7ef0508a3296c36d))
+* a single observed timestamp stopped a Lamport clock for good ([48f7788](https://github.com/seuros/merge_machines/commit/48f77882dffb7bdd6952c1175612ca60e69c0aae))
+* a source install can build, and a failed gem push fails the release ([bf37071](https://github.com/seuros/merge_machines/commit/bf37071c1398ecc81d4185f24d89cd89e8a8abe0))
+* a truncated register blob loaded as an empty one ([1aa9391](https://github.com/seuros/merge_machines/commit/1aa939148ba7f5161158b033a0a08c658ad3d9fa))
+* an OrSet add vanished when a replica's tag counter ran out ([8f81ce8](https://github.com/seuros/merge_machines/commit/8f81ce8240ce9070bb50f685bd6d54750674089b))
+* collect the built gems whatever depth the download puts them at ([29ccbdd](https://github.com/seuros/merge_machines/commit/29ccbddfbaee366919c2833925cfa989a5fb2a00))
+* hybrid timestamps cross the boundary as nanoseconds, not Float seconds ([01c9d86](https://github.com/seuros/merge_machines/commit/01c9d8602d07be6bdfcb659ae90b8f42706130e4))
+* keep the name table consistent when a merge overruns capacity ([3f34aa5](https://github.com/seuros/merge_machines/commit/3f34aa5c24bae838a1a3421f64ae061c5a6afb5b))
+* refuse a fractional stamp instead of truncating it into a tie ([6d3be65](https://github.com/seuros/merge_machines/commit/6d3be65af48918f890544e8547cfeb0eb03b45a2))
+* ship the core's test files so the packaged crate builds ([4651644](https://github.com/seuros/merge_machines/commit/4651644a58306aac0b6fd0e890f1f033b89adfa9))
+* the hash let a short key collide with a longer zero-padded one ([0a53206](https://github.com/seuros/merge_machines/commit/0a532065246def302a6510f082779f7981a61ff3))
+* the release tag carries the gem name, and the gate uses the aggregate output ([d048d8c](https://github.com/seuros/merge_machines/commit/d048d8cf92bf29b7a284a2f475c4e6f94280563d))
+* two unrescuable panics, a non-commutative merge, and a lost first write ([6951483](https://github.com/seuros/merge_machines/commit/6951483b917a731359ac2b4d94c0b326439f0882))
+
+## 0.1.0
+
+- Initial release.
+- `MergeMachines::GCounter` and `PNCounter`: one count per replica, summed for
+  a value that only grows, and two of those for one that moves both ways.
+- `MergeMachines::LwwRegister`: one value, held by whichever write was stamped
+  last, with the replica id as the tie-break, stamped by either clock.
+- `MergeMachines::GSet` and `OrSet`: a set nothing leaves, and one where a
+  remove only takes out the adds it has seen, so a concurrent add survives it.
+- `MergeMachines::LogicalClock` and `HybridClock`: Lamport's counter, and a
+  wall-clock reading paired with a counter that breaks its ties. The hybrid
+  clock reads `Process::CLOCK_REALTIME`, which may step backwards, and no
+  deadline may be derived from it.
+- Keys and register values are Ruby strings, carried as 64-bit hashes with a
+  side table that `dump` and `load` round-trip.
+- Replica counts and set capacities are const generics in the crate, so each
+  size is a separately compiled type and anything off the menu raises
+  `ArgumentError`.
+- `merge-machines` core crate: the states and the clocks in `no_std` Rust with
+  zero dependencies, plus a fixed-length codec per state. Builds and lints
+  clean on bare metal.
+- RBS signatures for the whole public API.

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 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,252 @@
+# MergeMachines 🔀
+
+> **Two ships, one log, no argument.** The tender that lets separated crews write
+> their own records and still agree when the fleet regroups.
+
+Conflict-free replicated data types for Ruby, and the clocks that stamp them.
+
+Two processes that both edited the same thing have to agree on the result
+without asking each other. These states merge commutatively, associatively and
+idempotently, so a replica converges on the same value whatever order the
+updates arrived in and however many times one of them arrived. **AMS Lamport**
+runs under comms blackout by design: it never calls home, it reconciles on
+contact.
+
+---
+
+## 🚀 Launch Sequence
+
+```ruby
+require 'merge_machines'
+
+edge = MergeMachines::GCounter.new(replicas: 8)
+origin = MergeMachines::GCounter.new(replicas: 8)
+
+edge.increment(replica: 1, by: 3)
+origin.increment(replica: 2, by: 7)
+
+edge.merge(origin).value   # => 10
+edge.merge(origin).value   # => 10, the same state again is absorbed
+```
+
+Nothing here talks to a network. The caller owns the transport, the replica ids
+and every clock reading.
+
+---
+
+## 🔩 The Native Extension Is Required
+
+There is no pure-Ruby fallback and no `DISABLE_*` switch. The gem is a binding
+to the `merge-machines` crate in `ext/merge_machines_native/core`, and it needs
+Ruby 4.0 and a Rust toolchain (or a platform gem). A second implementation
+would mean two sets of convergence tests and two byte formats to keep in step.
+
+---
+
+## 📐 Sizes Are a Fixed Menu
+
+The crate sizes every state by a const generic, so each size is a separately
+compiled type. The extension carries these and raises `ArgumentError` for
+anything else:
+
+| Class         | Keyword     | Values           |
+| ------------- | ----------- | ---------------- |
+| `GCounter`    | `replicas:` | 4, 8, 16, 32     |
+| `PNCounter`   | `replicas:` | 4, 8, 16, 32     |
+| `GSet`        | `capacity:` | 64, 256, 1024    |
+| `OrSet`       | `capacity:` | 64, 256, 1024    |
+| `LwwRegister` | `stamp:`    | `:logical`, `:hybrid` |
+
+```ruby
+MergeMachines::GSet.new(capacity: 100)
+# ArgumentError: capacity 100 is not supported, expected one of [64, 256, 1024]
+```
+
+A state with no free slot left raises `MergeMachines::Full` rather than
+growing. That is the deal a fixed size buys: a replica's memory is known at
+construction time.
+
+---
+
+## 🔢 Counters
+
+```ruby
+counter = MergeMachines::GCounter.new(replicas: 8)
+counter.increment(replica: 1, by: 3)
+counter.increment(replica: 1)        # by: defaults to 1
+counter.count(replica: 1)            # => 4
+counter.value                        # => 4, every replica's count
+counter.merge(other)                 # exact union, idempotent
+```
+
+One shared number cannot be merged: two replicas that both saw 5 and both added
+1 have no way to tell 6 from 7. One count per replica can, because no replica
+ever writes another's count, which is why `increment` needs a `replica:`.
+
+`PNCounter` is two of those, one for what went up and one for what came down,
+so its value may be negative.
+
+```ruby
+counter = MergeMachines::PNCounter.new(replicas: 8)
+counter.increment(replica: 1, by: 10)
+counter.decrement(replica: 2, by: 4)
+counter.value     # => 6
+counter.added     # => 10
+counter.removed   # => 4
+```
+
+---
+
+## 🗂️ Sets
+
+Keys are strings and must be UTF-8. The crate's elements are `Copy + Eq`, so a
+key crosses as a 64-bit hash of its bytes and the extension keeps the string
+each hash came from; `dump` carries that table along, so `load` hands the real
+strings back.
+
+```ruby
+set = MergeMachines::GSet.new(capacity: 64)
+set.add('user-1')
+set.include?('user-1')   # => true
+set.members              # => ['user-1']
+set.merge(other)         # union
+```
+
+`GSet` only grows, so merging is the union and there is nothing to resolve.
+`OrSet` tags every add and tombstones the tags a remove has seen, so a remove
+races a concurrent add and loses, and re-adding afterwards works.
+
+```ruby
+set = MergeMachines::OrSet.new(capacity: 64)
+set.add('user-1', replica: 1)
+set.remove('user-1')
+set.include?('user-1')   # => false
+
+set.add('user-1', replica: 1)
+set.include?('user-1')   # => true
+```
+
+`capacity:` bounds the adds and the tombstones separately. A removed key keeps
+its add slot, so a set that churns runs out.
+
+---
+
+## 🏁 One Value, Last Writer Wins
+
+Stamps order the writes and the replica id breaks the ties. Both sides of a
+concurrent write pick the same winner, which is the whole point, and the
+loser's value is gone, which is the price.
+
+```ruby
+register = MergeMachines::LwwRegister.new
+register.set('http://origin', replica: 1, stamp: 7)
+register.value      # => 'http://origin'
+register.stamp      # => 7
+register.replica    # => 1
+register.merge(other)
+```
+
+A register nobody has written holds `nil`. `stamp:` is whichever clock you
+picked at construction: an Integer for `:logical`, a `Timestamp` for
+`:hybrid`.
+
+---
+
+## 🕰️ Which Chronometer
+
+`LogicalClock` is Lamport's counter. It advances on every local event and jumps
+past any stamp it is shown, so a receive is always stamped after the send it
+answers. No clock is read.
+
+```ruby
+clock = MergeMachines::LogicalClock.new(replica: 1)
+sent_at = clock.tick       # => 1
+clock.observe(42)          # => 43, past both the local history and the send
+clock.now                  # => 43
+```
+
+A counter with nothing left raises `MergeMachines::Exhausted` rather than
+handing out a stamp it already gave away, and the clock stays where it was.
+
+`HybridClock` pairs a wall-clock reading with a counter: close to physical
+time, still totally ordered, and still monotonic when the host's clock is
+corrected backwards.
+
+```ruby
+clock = MergeMachines::HybridClock.new(replica: 1)
+clock.tick                              # Timestamp, reading from the realtime clock
+clock.tick(wall_ns: 1_700_000_000_500_000_000)  # or a reading you supply
+clock.observe(wall_ns: 1_500_000_000, counter: 3) # a timestamp that arrived
+clock.now                               # the last one issued
+```
+
+It raises `MergeMachines::Exhausted` too, when the reading has not advanced and
+the counter that separates two events at one reading has nothing left. A
+reading that really did advance resets that counter.
+
+### ⚠️ The Reading It Wants Is Not a Monotonic One
+
+`wall_ns:` is physical time two machines can compare, in nanoseconds, and
+defaults to
+`Process.clock_gettime(Process::CLOCK_REALTIME, :nanosecond)`. That clock
+**steps backwards** when the host's is corrected, which is exactly why the
+counter exists.
+
+**No deadline, timeout or budget may be derived from it.** Measuring how long
+something took belongs to the monotonic clock, which this gem neither reads nor
+models. `deadline_machines` owns that, and **AMS Layland** is the ship you hail
+for it.
+
+A reading crosses this boundary as seconds in a Float, so a realtime reading
+round-trips to about 256 nanoseconds. Two timestamps that land inside the same
+window are separated by the counter, which is what it is for.
+
+---
+
+## 📦 Putting State on a Wire
+
+`dump` returns a binary string and `load` reads one back.
+
+```ruby
+blob = set.dump                    # String, Encoding::BINARY
+MergeMachines::GSet.load(blob)
+```
+
+A blob is the crate's own fixed-length frame, led by a tag byte naming the
+structure and a field naming the shape, followed by whatever the Ruby surface
+needs that the frame does not hold: the key table for the sets and the
+register, the replica id for the clocks. `load` raises `ArgumentError` on a
+truncated blob, on one written by another structure, and on one written at a
+shape this build does not carry.
+
+```ruby
+MergeMachines::GSet.load(MergeMachines::OrSet.new(capacity: 64).dump)
+# ArgumentError: codec: wrong structure tag
+```
+
+---
+
+## 🚫 Rules of Engagement
+
+- It is not a transport. There is no gossip, no anti-entropy loop, no peer
+  list. You ship the blobs.
+- It is not a timer. The hybrid clock reads a wall clock, never a monotonic
+  one, and nothing here measures elapsed time.
+- It is not a state machine, and it does not retry, back off, break a circuit
+  or shed load. Other machines in this family do those.
+
+---
+
+## 📡 Credits
+
+**AMS Lamport**, NCC-1178, *Lamport*-class tender.
+
+Named for Leslie Lamport's *Time, Clocks, and the Ordering of Events in a
+Distributed System* (1978), which showed that order between separated machines
+is something you stamp, not something you read off a clock.
+
+---
+
+## License
+
+MIT.

data/ext/merge_machines_native/extconf.rb

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

data/lib/merge_machines/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module MergeMachines
+  VERSION = '0.2.0'
+end

data/lib/merge_machines.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require_relative 'merge_machines/version'
+
+# GCounter, PNCounter, LwwRegister, GSet, OrSet, LogicalClock and HybridClock
+# are defined by the native extension; there is no pure-Ruby implementation to
+# fall back to.
+require 'merge_machines_native/merge_machines_native'

data/sig/merge_machines.rbs

@@ -0,0 +1,238 @@
+# Conflict-free replicated data types and the clocks that stamp them. Every
+# class here is defined by the native extension, which binds the
+# `merge-machines` crate.
+#
+# Every state merges commutatively, associatively and idempotently, so replicas
+# converge without a coordinator and without ordering their messages. Nothing
+# here talks to a network: the caller owns the transport and the replica ids.
+module MergeMachines
+  VERSION: String
+
+  # Nanoseconds in a second. Wall-clock readings cross this boundary as seconds
+  # and move through the clocks as nanoseconds.
+  NS_PER_SECOND: Integer
+
+  class Error < StandardError
+  end
+
+  # Raised when a state needs a slot and every one of them is taken.
+  class Full < Error
+  end
+
+  # Raised when a clock has issued the last stamp its counter can hold, by
+  # either clock.
+  class Exhausted < Error
+  end
+
+  # A wall-clock reading in nanoseconds and the counter that breaks its ties.
+  class Timestamp < ::Data
+    attr_reader wall_ns: Integer
+    attr_reader counter: Integer
+  end
+
+  # Which clock stamps a register's writes.
+  type stamp_kind = :logical | :hybrid
+
+  # A counter that only grows, counted separately by each replica.
+  class GCounter
+    # `replicas` is 4, 8, 16 or 32.
+    def self.new: (replicas: Integer) -> instance
+
+    def self.load: (String blob) -> instance
+
+    def replicas: () -> Integer
+
+    # Adds `by` to `replica`'s own count. Raises `Full` when `replica` has no
+    # slot yet and every one of them is taken.
+    def increment: (replica: Integer, ?by: Integer) -> nil
+
+    # What `replica` has added, zero if it has no slot here.
+    def count: (replica: Integer) -> Integer
+
+    # Every replica's count.
+    def value: () -> Integer
+
+    # Folds `other` in. Raises `ArgumentError` on a different replica count.
+    def merge: (GCounter other) -> self
+
+    def dump: () -> String
+    def inspect: () -> String
+  end
+
+  # A counter replicas can both raise and lower, from two that only grow.
+  class PNCounter
+    # `replicas` is 4, 8, 16 or 32.
+    def self.new: (replicas: Integer) -> instance
+
+    def self.load: (String blob) -> instance
+
+    def replicas: () -> Integer
+
+    def increment: (replica: Integer, ?by: Integer) -> nil
+
+    def decrement: (replica: Integer, ?by: Integer) -> nil
+
+    # Everything added, minus everything taken away, which may be negative.
+    def value: () -> Integer
+
+    def added: () -> Integer
+    def removed: () -> Integer
+
+    # Folds `other` in. Raises `ArgumentError` on a different replica count.
+    def merge: (PNCounter other) -> self
+
+    def dump: () -> String
+    def inspect: () -> String
+  end
+
+  # One value, held by whichever write was stamped last, with the replica id as
+  # the tie-break.
+  class LwwRegister
+    # `stamp` picks which clock stamps the writes, defaulting to `:logical`.
+    def self.new: (?stamp: stamp_kind) -> instance
+
+    def self.load: (String blob) -> instance
+
+    def stamp_kind: () -> stamp_kind
+
+    # Writes `value` if `stamp` and `replica` beat the write already held.
+    # `stamp` is an Integer on a logical register and a `Timestamp` on a hybrid
+    # one. `value` must be UTF-8.
+    def set: (String value, replica: Integer, stamp: Integer | Timestamp) -> nil
+
+    # The value being held, `nil` until the first write.
+    def value: () -> String?
+
+    # The stamp of the write being held.
+    def stamp: () -> (Integer | Timestamp)
+
+    # The replica that wrote what is being held.
+    def replica: () -> Integer
+
+    # Folds `other` in. Raises `ArgumentError` on a register stamped by the
+    # other clock.
+    def merge: (LwwRegister other) -> self
+
+    def dump: () -> String
+    def inspect: () -> String
+  end
+
+  # A set nothing is ever taken out of.
+  class GSet
+    # `capacity` is 64, 256 or 1024.
+    def self.new: (capacity: Integer) -> instance
+
+    def self.load: (String blob) -> instance
+
+    def capacity: () -> Integer
+
+    # Adds `key`, which is a no-op if it is already in. Raises `Full` when
+    # `key` is new and every slot is taken, `EncodingError` when it is not
+    # UTF-8.
+    def add: (String key) -> nil
+
+    def include?: (String key) -> bool
+
+    # The keys in the set, in no particular order.
+    def members: () -> Array[String]
+
+    def size: () -> Integer
+    def empty?: () -> bool
+
+    # Unions `other` in. Raises `ArgumentError` on a different capacity.
+    def merge: (GSet other) -> self
+
+    def dump: () -> String
+    def inspect: () -> String
+  end
+
+  # A set keys can leave, where a concurrent add survives a remove.
+  class OrSet
+    # `capacity` is 64, 256 or 1024, and bounds the adds and the tombstones
+    # separately.
+    def self.new: (capacity: Integer) -> instance
+
+    def self.load: (String blob) -> instance
+
+    def capacity: () -> Integer
+
+    # Adds `key` under a tag of `replica` and the next counter that replica has
+    # not used here. Raises `Full` when every add slot is taken, `Exhausted`
+    # when `replica` has no counter left, `EncodingError` when `key` is not
+    # UTF-8.
+    def add: (String key, replica: Integer) -> nil
+
+    # Tombstones every tag this set has seen for `key`. Raises `Full` when the
+    # tombstones do not fit.
+    def remove: (String key) -> nil
+
+    def include?: (String key) -> bool
+
+    # The keys still in the set, each once, in no particular order.
+    def members: () -> Array[String]
+
+    def size: () -> Integer
+    def empty?: () -> bool
+
+    # Folds `other` in. Raises `ArgumentError` on a different capacity.
+    def merge: (OrSet other) -> self
+
+    def dump: () -> String
+    def inspect: () -> String
+  end
+
+  # Lamport's counter: ordering events without reading a clock.
+  class LogicalClock
+    def self.new: (replica: Integer) -> instance
+
+    def self.load: (String blob) -> instance
+
+    # The replica whose events this clock stamps.
+    def replica: () -> Integer
+
+    # The last stamp this clock issued.
+    def now: () -> Integer
+
+    # Stamps a local event. Raises `Exhausted` when the counter holds its
+    # highest value, which leaves the clock where it was.
+    def tick: () -> Integer
+
+    # Stamps the receipt of `observed`, a stamp from another replica. Raises
+    # `Exhausted` when it cannot be stamped after `observed`.
+    def observe: (Integer observed) -> Integer
+
+    def dump: () -> String
+    def inspect: () -> String
+  end
+
+  # A wall-clock reading paired with a counter that breaks its ties, which never
+  # goes backwards.
+  #
+  # The reading comes from `Process::CLOCK_REALTIME`, which may step backwards.
+  # No deadline may be derived from it.
+  class HybridClock
+    def self.new: (replica: Integer) -> instance
+
+    def self.load: (String blob) -> instance
+
+    # The replica whose events this clock stamps.
+    def replica: () -> Integer
+
+    # The last timestamp this clock issued.
+    def now: () -> Timestamp
+
+    # Stamps a local event at `wall_ns`, defaulting to the realtime clock's
+    # reading. Raises `Exhausted` when the reading has not advanced and the
+    # counter that separates two events at one reading holds its highest value,
+    # which leaves the clock where it was.
+    def tick: (?wall_ns: Integer) -> Timestamp
+
+    # Stamps the receipt of the timestamp `wall_ns` and `counter` name, at the
+    # realtime clock's reading. Raises `Exhausted` when it cannot be stamped
+    # after the timestamp observed.
+    def observe: (wall_ns: Integer, counter: Integer) -> Timestamp
+
+    def dump: () -> String
+    def inspect: () -> String
+  end
+end

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification
+name: merge_machines
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: x86_64-linux
+authors:
+- Abdelkader Boudih
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2026-11-01 00:00:00.000000000 Z
+dependencies: []
+description: Counters, a last-writer-wins register, grow-only and observed-remove
+  sets, and the Lamport and hybrid logical clocks that stamp them, bound to Ruby from
+  the no_std merge-machines crate. Every state merges commutatively, associatively
+  and idempotently, and encodes to a byte string other languages reading the same
+  crate can decode.
+email:
+- oss@seuros.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- ext/merge_machines_native/extconf.rb
+- lib/merge_machines.rb
+- lib/merge_machines/version.rb
+- lib/merge_machines_native/merge_machines_native.so
+- sig/merge_machines.rbs
+homepage: https://github.com/seuros/merge_machines
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/seuros/merge_machines
+  changelog_uri: https://github.com/seuros/merge_machines/blob/main/CHANGELOG.md
+  bug_tracker_uri: https://github.com/seuros/merge_machines/issues
+  rubygems_mfa_required: 'true'
+  cargo_crate_name: merge_machines_native
+  cargo_manifest_path: ext/merge_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: Conflict-free replicated data types for Ruby
+test_files: []