dedup_machines 0.2.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e71d79c60c485879816ca73b9d2a57d6bb7beedb88b6783c3633ebc9efa9cb1e
+  data.tar.gz: 4d398af5165da22c1009cb91b3bca1de9288651606de6053ddda1a6803994e9e
+SHA512:
+  metadata.gz: dbfa660abb94f87711ddde8b8ca52c8ec6f034a2acafb46bb739b71eb558153bb1721bbbaa455c822890b00970cd74639b289f9d8a58df21b94a502703a0171e
+  data.tar.gz: 65916915e33cbc7a5ba15b2932b1920cf4e542d49ae3e73c36662873c24df7303cad74abb26e10fd0cc223636de069f8440ca4e8f028c5597e5b6a3405143665

data/CHANGELOG.md

@@ -0,0 +1,68 @@
+# Changelog
+
+## [0.2.2](https://github.com/seuros/dedup_machines/compare/dedup_machines/v0.2.1...dedup_machines/v0.2.2) (2026-11-06)
+
+
+### Bug Fixes
+
+* satisfy the nursery option_if_let_else lint in Entry::new ([88cf1eb](https://github.com/seuros/dedup_machines/commit/88cf1ebadcbfac752ac6e20fb0d2ce07dae765e9))
+* share core test helpers via test_support ([0c94d57](https://github.com/seuros/dedup_machines/commit/0c94d57d888c41b77d4a11c9db346fc0587ee78c))
+
+## [0.2.1](https://github.com/seuros/dedup_machines/compare/dedup_machines/v0.2.0...dedup_machines/v0.2.1) (2026-11-06)
+
+
+### Features
+
+* unseal Storage so a ledger can run over an external backend ([61c8c77](https://github.com/seuros/dedup_machines/commit/61c8c77d45923109919a5dda5b1315ce64427aba))
+
+## [0.2.0](https://github.com/seuros/dedup_machines/compare/dedup_machines/v0.1.5...dedup_machines/v0.2.0) (2026-11-06)
+
+
+### ⚠ BREAKING CHANGES
+
+* Claim carries a lifetime and value type, and Completed holds a reference to the stored value.
+
+### Features
+
+* heap-backed ledger, fingerprints, stored values, partition caps ([a9fee64](https://github.com/seuros/dedup_machines/commit/a9fee64ce94d8a32e62c9d97e014f3664fa8b20e))
+
+
+### Bug Fixes
+
+* document the error path of complete_with ([0c9dc20](https://github.com/seuros/dedup_machines/commit/0c9dc206c4c8ec55be2d6a37420eb7c4d101fb8b))
+* satisfy pedantic clippy on the test helpers and hashed constructor ([001a626](https://github.com/seuros/dedup_machines/commit/001a6265621f8f46a7b1d38e881ce04ead09c40f))
+
+## [0.1.5](https://github.com/seuros/dedup_machines/compare/dedup_machines/v0.1.4...dedup_machines/v0.1.5) (2026-11-06)
+
+
+### Bug Fixes
+
+* crates.io keywords and categories for the core ([2c5c7ee](https://github.com/seuros/dedup_machines/commit/2c5c7eebc94e34f772bdd7508d12f7d79c334c81))
+
+## [0.1.4](https://github.com/seuros/dedup_machines/compare/dedup_machines/v0.1.3...dedup_machines/v0.1.4) (2026-11-06)
+
+
+### Bug Fixes
+
+* keep test sources out of the packaged gem and crate ([dc18303](https://github.com/seuros/dedup_machines/commit/dc1830331de56e948e2ce082686be122a8a537aa))
+
+## [0.1.3](https://github.com/seuros/dedup_machines/compare/dedup_machines/v0.1.2...dedup_machines/v0.1.3) (2026-11-06)
+
+
+### Bug Fixes
+
+* name the gemspec block spec so the release workflow detects the extension ([a4584eb](https://github.com/seuros/dedup_machines/commit/a4584ebb0b40e77e8bdfb1e31ee72c7862cfa95e))
+
+## [0.1.2](https://github.com/seuros/dedup_machines/compare/dedup_machines/v0.1.1...dedup_machines/v0.1.2) (2026-11-06)
+
+
+### Bug Fixes
+
+* cross builds no longer compile for the host ([86e820b](https://github.com/seuros/dedup_machines/commit/86e820b3b73fdf971817d5415f3ef941d6f82125))
+
+## [0.1.1](https://github.com/seuros/dedup_machines/compare/dedup_machines-v0.1.0...dedup_machines/v0.1.1) (2026-11-06)
+
+
+### Features
+
+* initial extraction ([126339b](https://github.com/seuros/dedup_machines/commit/126339bf2ec50261af08c5e710436bafa2530365))

data/Cargo.toml

@@ -0,0 +1,26 @@
+[workspace]
+members = ["ext/dedup_machines_native/core", "ext/dedup_machines_native/ffi"]
+default-members = ["ext/dedup_machines_native/core"]
+resolver = "3"
+
+[workspace.package]
+edition = "2024"
+rust-version = "1.99"
+license = "MIT"
+
+[workspace.dependencies]
+dedup-machines = { path = "ext/dedup_machines_native/core" }
+magnus = { version = "0.9.3", default-features = false }
+rb-sys = { version = "0.9.130", default-features = false, features = ["stable-api-compiled-fallback"] }
+
+[workspace.lints.rust]
+unsafe_code = "deny"
+unused_must_use = "warn"
+missing_docs = "warn"
+
+[workspace.lints.clippy]
+all = { level = "warn", priority = -1 }
+pedantic = { level = "warn", priority = -1 }
+nursery = { level = "warn", priority = -1 }
+unwrap_used = "deny"
+expect_used = "deny"

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+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,208 @@
+# DedupMachines
+
+> The second copy of a message is not a second order. 📨
+
+A claim ledger for Ruby. Before you act on a message, you claim its key. The ledger tells you whether the key is fresh, already being worked on, or already done. Finish the work and mark it complete. Lose the worker and abandon the claim. Either way, the next copy of the same message gets the right answer instead of a second side effect.
+
+## Quick Start
+
+```bash
+gem 'dedup_machines'
+```
+
+```ruby
+ledger = DedupMachines::Ledger.new
+
+def handle(ledger, event, clock)
+  case (claim = ledger.claim(event.id, clock.now_ns, 24 * 3_600_000_000_000))
+  when :in_progress, :completed
+    return # someone has it, or had it. Nothing to do.
+  when :full, :rejected
+    raise "ledger refused #{event.id}: #{claim}"
+  end
+
+  charge_customer(event)
+  ledger.complete(claim, clock.now_ns)
+rescue ChargeFailed
+  ledger.abandon(claim)
+  raise
+end
+```
+
+One ledger, three methods. Keys and times are Integers. Times are nanoseconds from a clock that only goes forward.
+
+## A Message to the Resistance
+
+So Stripe sent you `payment_intent.succeeded`. Your webhook handler fulfilled the order and sent the confirmation email. Then Stripe, as the docs say it might, sent the same event again. Your handler fulfilled the order and sent the confirmation email.
+
+You know what the docs told you to do. "Make your handler idempotent." Four words, and the entire problem is yours again. So you add a `processed_events` table. Then two workers pick up the same event at the same instant, both find nothing in the table, both proceed. So you add a unique index and a transaction. Then a worker dies after the insert and before the charge, and that event is now marked done forever, and nobody gets charged.
+
+The piece you keep rebuilding is a tiny state machine per key: nobody has it, someone is working on it, someone finished it. With a timeout, so a dead worker's claim doesn't outlive the heat death of the universe. That machine is this gem.
+
+## Chapter 1: Stardate 2025.186, the AMS Birrell
+
+> **AMS Birrell**, NCC-4205, *Birrell*-class courier.
+> An echo from the relay is not a second delivery order.
+
+The courier doesn't deliver anything. It keeps the manifest. Every dispatch has an exact identity, and the manifest says whether that identity is unclaimed, out with a crew, or signed for. A relay that bounces the same order back an hour later finds it already signed for and files it under echoes.
+
+On a bridge somewhere, a cadet volunteers:
+
+```ruby
+def on_webhook(event)
+  return if Redis.current.get("seen:#{event.id}")
+  fulfil(event)
+  Redis.current.set("seen:#{event.id}", 1)
+end
+```
+
+"That," says the courier's quartermaster, "is a race with a two-line head start."
+
+## The Flight Plan
+
+Each key the ledger knows about is in one of these states:
+
+```mermaid
+stateDiagram-v2
+    [*] --> unclaimed
+    unclaimed --> in_progress: claim, returns a Claim
+    in_progress --> in_progress: claim again, returns :in_progress
+    in_progress --> completed: complete(claim)
+    in_progress --> unclaimed: abandon(claim)
+    completed --> completed: claim again, returns :completed
+    completed --> unclaimed: ttl elapsed since the claim
+    in_progress --> unclaimed: ttl elapsed since the claim
+```
+
+And the afternoon Stripe sent event 42 twice, into two workers:
+
+```mermaid
+sequenceDiagram
+    participant S as Stripe
+    participant W1 as Worker 1
+    participant L as Ledger
+    participant W2 as Worker 2
+
+    S->>W1: event 42
+    W1->>L: claim(42)
+    L-->>W1: Claim
+    W1->>W1: charge customer
+
+    S->>W2: event 42 (retry)
+    W2->>L: claim(42)
+    L-->>W2: :in_progress
+    Note over W2: drops it
+
+    W1->>L: complete(claim)
+    L-->>W1: true
+
+    S->>W2: event 42 (another retry)
+    W2->>L: claim(42)
+    L-->>W2: :completed
+    Note over W2: drops it. One charge.
+```
+
+## How the Ledger Works
+
+### Claim
+
+```ruby
+ledger = DedupMachines::Ledger.new
+
+claim = ledger.claim(42, 0, 10)   # key 42, now 0 ns, ttl 10 ns
+claim.class                        # => DedupMachines::Claim
+```
+
+A `Claim` means the key was unclaimed and is now yours. Ask again while you're still holding it and you get a symbol instead:
+
+```ruby
+ledger.claim(42, 1, 10)   # => :in_progress
+```
+
+### Complete
+
+```ruby
+ledger.complete(claim, 2)   # => true
+ledger.complete(claim, 2)   # => false, already spent
+ledger.claim(42, 9, 10)     # => :completed
+```
+
+A completed key keeps answering `:completed` until its ttl runs out. The ttl is measured from the moment of the claim, not from completion.
+
+### Expiry
+
+```ruby
+fresh = ledger.claim(42, 10, 10)   # ttl elapsed: a new Claim
+ledger.complete(claim, 10)         # => false, the old handle is dead
+ledger.abandon(fresh)              # => true
+```
+
+Ten nanoseconds after a claim with a ten-nanosecond ttl, the key is unclaimed again. The old `Claim` can't be completed or abandoned any more. Only the new one counts.
+
+### Abandon
+
+A worker that knows it failed gives the key back so the next copy can try:
+
+```ruby
+ledger = DedupMachines::Ledger.new
+claim = ledger.claim(7, 0, 100)
+
+ledger.abandon(claim)       # => true
+ledger.claim(7, 1, 100).class   # => DedupMachines::Claim
+```
+
+Abandon only an attempt you know did nothing. If the charge might have gone through, that's a reconciliation problem, not an abandon.
+
+### Capacity
+
+The ledger holds 64 keys at a time. Past that, `claim` says `:full` until something completes and expires, or is abandoned:
+
+```ruby
+ledger = DedupMachines::Ledger.new
+ledger.capacity                                  # => 64
+claims = 64.times.map { |i| ledger.claim(i, 0, 100) }
+ledger.claim(65, 0, 100)                         # => :full
+
+ledger.abandon(claims.first)                     # => true
+ledger.claim(65, 0, 100).class                   # => DedupMachines::Claim
+```
+
+An unexpired key is never evicted to make room. Size your ttl to your traffic, or shard across ledgers.
+
+### Time only moves forward
+
+The ledger remembers the latest `now_ns` it has seen. Hand it an earlier one and it refuses:
+
+```ruby
+ledger = DedupMachines::Ledger.new
+claim = ledger.claim(1, 10, 10)
+ledger.complete(claim, 9)    # => false
+ledger.complete(claim, 10)   # => true
+ledger.claim(2, 9, 10)       # => :rejected
+```
+
+A zero ttl is `:rejected` too. Feed it a monotonic clock in nanoseconds.
+
+## The Rules of the Courier
+
+- **Keys and times are Integers** in `0..2**64-1`. Times are nanoseconds. Floats, nil, and strings raise `TypeError`. Out of range raises `RangeError`.
+- **Claims belong to one ledger.** A `Claim` from one `Ledger` is refused by another, with `false`, even for the same key. Claims can't be built or copied by hand.
+- **Refusals don't raise.** `:in_progress`, `:completed`, `:full`, `:rejected`, and `false` are answers. Only malformed input raises.
+- **Frozen means frozen.** `freeze` the ledger and `claim`, `complete`, and `abandon` all raise `FrozenError`.
+
+## What You Think You're Doing vs Reality
+
+### You Think: "I'll check if I've seen it, then process it."
+### Reality: Two workers both haven't seen it.
+
+The check and the processing are two steps, and a second copy of the message fits neatly between them. The only check that works is one that *takes* the key as it reads it. `claim` is that check. There's no window, because there's no second step.
+
+## What's Yours
+
+The ledger lives in your process and forgets everything when the process does. If duplicates can arrive after a restart, write completed keys somewhere durable and seed a fresh ledger's decisions from that. A claim that times out may belong to a worker that's still running. Fence or reconcile its side effects before letting the next copy through.
+
+## License
+
+MIT License. See [LICENSE.txt](LICENSE.txt) for details.
+
+**Remember: Stripe will send it twice. The question is whether you charge twice.**

data/ext/dedup_machines_native/core/CHANGELOG.md

@@ -0,0 +1,54 @@
+# Changelog
+
+## [0.4.1](https://github.com/seuros/dedup_machines/compare/dedup-machines-v0.4.0...dedup-machines-v0.4.1) (2026-11-06)
+
+
+### Bug Fixes
+
+* satisfy the nursery option_if_let_else lint in Entry::new ([88cf1eb](https://github.com/seuros/dedup_machines/commit/88cf1ebadcbfac752ac6e20fb0d2ce07dae765e9))
+* share core test helpers via test_support ([0c94d57](https://github.com/seuros/dedup_machines/commit/0c94d57d888c41b77d4a11c9db346fc0587ee78c))
+
+## [0.4.0](https://github.com/seuros/dedup_machines/compare/dedup-machines-v0.3.0...dedup-machines-v0.4.0) (2026-11-06)
+
+
+### Features
+
+* unseal Storage so a ledger can run over an external backend ([61c8c77](https://github.com/seuros/dedup_machines/commit/61c8c77d45923109919a5dda5b1315ce64427aba))
+
+## [0.3.0](https://github.com/seuros/dedup_machines/compare/dedup-machines-v0.2.2...dedup-machines-v0.3.0) (2026-11-06)
+
+
+### ⚠ BREAKING CHANGES
+
+* Claim carries a lifetime and value type, and Completed holds a reference to the stored value.
+
+### Features
+
+* heap-backed ledger, fingerprints, stored values, partition caps ([a9fee64](https://github.com/seuros/dedup_machines/commit/a9fee64ce94d8a32e62c9d97e014f3664fa8b20e))
+
+
+### Bug Fixes
+
+* document the error path of complete_with ([0c9dc20](https://github.com/seuros/dedup_machines/commit/0c9dc206c4c8ec55be2d6a37420eb7c4d101fb8b))
+* satisfy pedantic clippy on the test helpers and hashed constructor ([001a626](https://github.com/seuros/dedup_machines/commit/001a6265621f8f46a7b1d38e881ce04ead09c40f))
+
+## [0.2.2](https://github.com/seuros/dedup_machines/compare/dedup-machines-v0.2.1...dedup-machines-v0.2.2) (2026-11-06)
+
+
+### Bug Fixes
+
+* crates.io keywords and categories for the core ([2c5c7ee](https://github.com/seuros/dedup_machines/commit/2c5c7eebc94e34f772bdd7508d12f7d79c334c81))
+
+## [0.2.1](https://github.com/seuros/dedup_machines/compare/dedup-machines-v0.2.0...dedup-machines-v0.2.1) (2026-11-06)
+
+
+### Bug Fixes
+
+* keep test sources out of the packaged gem and crate ([dc18303](https://github.com/seuros/dedup_machines/commit/dc1830331de56e948e2ce082686be122a8a537aa))
+
+## [0.2.0](https://github.com/seuros/dedup_machines/compare/dedup-machines-v0.1.0...dedup-machines-v0.2.0) (2026-11-06)
+
+
+### Features
+
+* initial extraction ([126339b](https://github.com/seuros/dedup_machines/commit/126339bf2ec50261af08c5e710436bafa2530365))

data/ext/dedup_machines_native/core/Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+name = "dedup-machines"
+version = "0.4.1"
+edition.workspace = true
+rust-version.workspace = true
+license.workspace = true
+description = "Bounded exact duplicate claims with generation-checked completion"
+readme = "README.md"
+exclude = ["src/**/tests.rs", "tests/"]
+keywords = ["deduplication", "idempotency", "ttl", "exactly-once", "no-std"]
+categories = ["no-std", "algorithms"]
+[features]
+default = []
+alloc = ["dep:hashbrown"]
+std = ["alloc"]
+
+[dependencies]
+hashbrown = { version = "0.17", default-features = false, features = ["default-hasher"], optional = true }
+
+[lints]
+workspace = true

data/ext/dedup_machines_native/core/README.md

@@ -0,0 +1,70 @@
+# dedup-machines
+
+> **AMS Birrell**, NCC-4205, *Birrell*-class courier.
+
+Engine-room flight manual: track repeated dispatches in a bounded delivery ledger.
+
+Allocation-free `no_std` exact-key claim ledger. Live claims and completed keys
+are retained until their original claim TTL; full tables reject new keys instead
+of evicting live records. Completion is generation-checked, so an expired worker
+cannot complete a replacement claim for the same slot/key.
+
+Time is explicit and monotonic. Zero/overflowing TTLs and backwards time are
+rejected. Pending claims may expire: their workers can still be executing, so
+fencing or transactional storage is required for side effects. Completion does
+not extend TTL. `abandon` frees a matching pending claim after a known failure.
+Do not abandon an uncertain external effect and assume a retry is safe.
+
+Completion may carry a value: `complete_with` stores it and every later claim
+of that key reads it back as `Completed(&value)`. Claims may carry a
+fingerprint of their payload: a record under the same key with a different
+fingerprint (or none) answers `Conflict`, so an id reused for another payload is
+refused instead of replayed. Claims may name a partition; with a partition cap
+set, a bucket at its quota answers `PartitionFull` while the table still has
+room. `expire_where` drops records whose owner is known to be gone before their
+TTL would.
+
+This in-memory ledger has no persistence, cross-process arbitration, or wire
+checkpoint format. Handles are scoped to one ledger lifetime; replacing the
+ledger resets its namespace.
+
+```rust
+use core::time::Duration;
+use dedup_machines::{Claim, Dedup};
+let mut ledger = Dedup::<u64, 8>::new();
+let Claim::Acquired(id) = ledger.claim(42, Duration::ZERO, Duration::from_secs(30))
+    else { panic!("fresh key must fit"); };
+assert!(ledger.complete(id, Duration::ZERO));
+assert_eq!(ledger.claim(42, Duration::ZERO, Duration::from_secs(30)), Claim::Completed(&()));
+```
+
+The `alloc` feature (`std` implies it) adds `HashDedup`, the same ledger over a
+heap table with a runtime capacity and hashed lookup, for keys that are not
+`Copy`:
+
+```rust
+# #[cfg(feature = "alloc")] {
+use core::time::Duration;
+use dedup_machines::{Attempt, Claim, HashDedup};
+let mut ledger = HashDedup::<String, String>::with_capacity(1024).with_partition_cap(128);
+let relay = |session: u64, source: &str| Attempt::new(format!("{session}/{source}")).partition(session);
+let Claim::Acquired(id) = ledger.admit(relay(7, "tool"), Duration::ZERO, Duration::from_secs(3600))
+    else { panic!("fresh key must fit"); };
+assert_eq!(ledger.complete_with(id, "elicit-1".into(), Duration::ZERO), Ok(()));
+assert_eq!(
+    ledger.admit(relay(7, "tool"), Duration::from_secs(1), Duration::from_secs(3600)),
+    Claim::Completed(&"elicit-1".to_string())
+);
+assert_eq!(ledger.expire_where(|key| key.starts_with("7/")), 1);
+# }
+```
+
+## Bring Your Own Storage
+
+`Fixed` and `Hashed` keep records in memory. `Storage` is a public trait, so
+the same ledger can run over a database table or a shared-memory arena: a
+backend stores the `Entry` values the ledger hands it and finds them again by
+key or slot. `Entry::new` and its accessors round-trip every field, and
+`Ledger::restore` continues from a persisted generation and clock watermark so
+no stored claim handle can be reissued.
+

data/ext/dedup_machines_native/core/src/hashed.rs

@@ -0,0 +1,127 @@
+use alloc::vec::Vec;
+use core::hash::{BuildHasher, Hash};
+
+use hashbrown::{DefaultHashBuilder, HashTable};
+
+use crate::{Entry, Ledger, Storage};
+
+/// Heap-backed storage with a runtime capacity and hashed key lookup.
+#[derive(Debug)]
+pub struct Hashed<K, V, H = DefaultHashBuilder> {
+    slots: Vec<Option<Entry<K, V>>>,
+    free: Vec<usize>,
+    index: HashTable<usize>,
+    hasher: H,
+    capacity: usize,
+}
+
+/// Heap-backed exact-key ledger.
+pub type HashDedup<K, V = (), H = DefaultHashBuilder> = Ledger<Hashed<K, V, H>>;
+
+impl<K: Hash + Eq, V> HashDedup<K, V> {
+    /// Start an empty ledger holding at most `capacity` unexpired records.
+    #[must_use]
+    pub fn with_capacity(capacity: usize) -> Self {
+        Self::with_capacity_and_hasher(capacity, DefaultHashBuilder::default())
+    }
+}
+
+impl<K: Hash + Eq, V, H: BuildHasher> HashDedup<K, V, H> {
+    /// Start an empty ledger with an explicit hasher.
+    #[must_use]
+    pub const fn with_capacity_and_hasher(capacity: usize, hasher: H) -> Self {
+        Self::over(Hashed {
+            slots: Vec::new(),
+            free: Vec::new(),
+            index: HashTable::new(),
+            hasher,
+            capacity,
+        })
+    }
+}
+
+impl<K: Hash + Eq, V, H: BuildHasher> Hashed<K, V, H> {
+    fn key_at(&self, slot: usize) -> Option<&K> {
+        self.slots.get(slot)?.as_ref().map(|entry| &entry.key)
+    }
+
+    fn unlink(&mut self, slot: usize) -> bool {
+        let Some(key) = self.key_at(slot) else {
+            return false;
+        };
+        let hash = self.hasher.hash_one(key);
+        let Ok(occupied) = self.index.find_entry(hash, |&candidate| candidate == slot) else {
+            return false;
+        };
+        occupied.remove();
+        self.slots.get_mut(slot).and_then(Option::take);
+        self.free.push(slot);
+        true
+    }
+}
+
+impl<K: Hash + Eq, V, H: BuildHasher> Storage for Hashed<K, V, H> {
+    type Key = K;
+    type Value = V;
+
+    fn get(&self, slot: usize) -> Option<&Entry<K, V>> {
+        self.slots.get(slot)?.as_ref()
+    }
+
+    fn get_mut(&mut self, slot: usize) -> Option<&mut Entry<K, V>> {
+        self.slots.get_mut(slot)?.as_mut()
+    }
+
+    fn find(&self, key: &K) -> Option<usize> {
+        let hash = self.hasher.hash_one(key);
+        self.index
+            .find(hash, |&slot| self.key_at(slot) == Some(key))
+            .copied()
+    }
+
+    fn insert(&mut self, entry: Entry<K, V>) -> Option<usize> {
+        if self.index.len() >= self.capacity {
+            return None;
+        }
+        let hash = self.hasher.hash_one(&entry.key);
+        let slot = match self.free.pop() {
+            Some(slot) if slot < self.slots.len() => {
+                self.slots[slot] = Some(entry);
+                slot
+            }
+            _ => {
+                self.slots.push(Some(entry));
+                self.slots.len() - 1
+            }
+        };
+        let (slots, hasher) = (&self.slots, &self.hasher);
+        self.index.insert_unique(hash, slot, |&other| {
+            slots
+                .get(other)
+                .and_then(Option::as_ref)
+                .map_or(0, |entry| hasher.hash_one(&entry.key))
+        });
+        Some(slot)
+    }
+
+    fn remove(&mut self, slot: usize) -> bool {
+        self.unlink(slot)
+    }
+
+    fn retain(&mut self, mut keep: impl FnMut(&Entry<K, V>) -> bool) -> usize {
+        let mut removed = 0;
+        for slot in 0..self.slots.len() {
+            if self.get(slot).is_some_and(|entry| !keep(entry)) && self.unlink(slot) {
+                removed += 1;
+            }
+        }
+        removed
+    }
+
+    fn iter(&self) -> impl Iterator<Item = &Entry<K, V>> {
+        self.slots.iter().flatten()
+    }
+}
+
+#[cfg(test)]
+mod tests;