diff --git a/.github/workflows/rust-benchmark.yml b/.github/workflows/rust-benchmark.yml
index ddf4cb4..63ebc7f 100644
--- a/.github/workflows/rust-benchmark.yml
+++ b/.github/workflows/rust-benchmark.yml
@@ -3,10 +3,10 @@ name: Rust Benchmark
 on:
   push:
     branches: [main, master]
-    paths: ['rust/**', '.github/workflows/rust-benchmark.yml']
+    paths: ['rust/**', 'spacetime-module/**', '.github/workflows/rust-benchmark.yml']
   pull_request:
     branches: [main, master]
-    paths: ['rust/**', '.github/workflows/rust-benchmark.yml']
+    paths: ['rust/**', 'spacetime-module/**', '.github/workflows/rust-benchmark.yml']
 
 env:
   CARGO_TERM_COLOR: always
@@ -20,29 +20,26 @@ jobs:
   test:
     name: Test (${{ matrix.os }})
     runs-on: ${{ matrix.os }}
+    timeout-minutes: 360
     strategy:
       fail-fast: false
       matrix:
-        os: [ubuntu-latest, macos-latest, windows-latest]
+        os: [ubuntu-latest, macos-latest]
     steps:
       - uses: actions/checkout@v4
 
-      - name: Setup Rust (nightly-2022-08-22)
+      - name: Setup Rust (nightly)
         uses: dtolnay/rust-toolchain@master
         with:
-          toolchain: nightly-2022-08-22
+          toolchain: nightly
           components: rustfmt, clippy
+          targets: wasm32-unknown-unknown
 
       - name: Cache cargo registry
-        uses: actions/cache@v4
+        uses: Swatinem/rust-cache@v2
         with:
-          path: |
-            ~/.cargo/registry
-            ~/.cargo/git
-            rust/target
-          key: ${{ runner.os }}-cargo-${{ hashFiles('rust/Cargo.lock') }}
-          restore-keys: |
-            ${{ runner.os }}-cargo-
+          workspaces: rust -> target
+          cache-on-failure: "true"
 
       - name: Check formatting
         run: cargo fmt --all -- --check
@@ -50,8 +47,47 @@ jobs:
       - name: Run Clippy
         run: cargo clippy --all-targets
 
+      - name: Install SpacetimeDB CLI
+        shell: bash
+        run: |
+          curl -sSf https://install.spacetimedb.com | sh -s -- -y
+          echo "$HOME/.local/bin" >> $GITHUB_PATH
+        working-directory: .
+
+      - name: Build SpacetimeDB module (WASM)
+        run: cargo build --release --target wasm32-unknown-unknown
+        working-directory: rust/spacetime-module
+
+      - name: Start SpacetimeDB server
+        shell: bash
+        run: |
+          spacetime start &
+          echo "Waiting for SpacetimeDB server to be ready..."
+          for i in $(seq 1 30); do
+            if curl -sf http://localhost:3000/ > /dev/null 2>&1; then
+              echo "SpacetimeDB server is ready"
+              break
+            fi
+            sleep 1
+          done
+        working-directory: .
+
+      - name: Publish SpacetimeDB module
+        shell: bash
+        run: |
+          spacetime publish \
+            --server http://localhost:3000 \
+            --bin-path target/wasm32-unknown-unknown/release/spacetime_module.wasm \
+            --yes \
+            benchmark-links
+        working-directory: rust/spacetime-module
+
       - name: Run tests
-        run: cargo test --release
+        env:
+          SPACETIMEDB_URI: http://localhost:3000
+          SPACETIMEDB_DB: benchmark-links
+        # Run tests sequentially to avoid parallel interference with shared SpacetimeDB state.
+        run: cargo test -- --test-threads=1
 
   benchmark:
     name: Benchmark
@@ -64,10 +100,11 @@ jobs:
           fetch-depth: 0
           token: ${{ secrets.GITHUB_TOKEN }}
 
-      - name: Setup Rust (nightly-2022-08-22)
+      - name: Setup Rust (nightly)
         uses: dtolnay/rust-toolchain@master
         with:
-          toolchain: nightly-2022-08-22
+          toolchain: nightly
+          targets: wasm32-unknown-unknown
 
       - name: Setup Python
         uses: actions/setup-python@v5
@@ -78,15 +115,41 @@ jobs:
         run: pip install matplotlib numpy
 
       - name: Cache cargo registry
-        uses: actions/cache@v4
+        uses: Swatinem/rust-cache@v2
         with:
-          path: |
-            ~/.cargo/registry
-            ~/.cargo/git
-            rust/target
-          key: ubuntu-cargo-bench-${{ hashFiles('rust/Cargo.lock') }}
-          restore-keys: |
-            ubuntu-cargo-bench-
+          workspaces: rust -> target
+          cache-on-failure: "true"
+
+      - name: Install SpacetimeDB CLI
+        run: |
+          curl -sSf https://install.spacetimedb.com | sh -s -- -y
+          echo "$HOME/.local/bin" >> $GITHUB_PATH
+        working-directory: .
+
+      - name: Build SpacetimeDB module (WASM)
+        run: cargo build --release --target wasm32-unknown-unknown
+        working-directory: rust/spacetime-module
+
+      - name: Start SpacetimeDB server
+        run: |
+          spacetime start &
+          for i in $(seq 1 30); do
+            if curl -sf http://localhost:3000/ > /dev/null 2>&1; then
+              echo "SpacetimeDB server is ready"
+              break
+            fi
+            sleep 1
+          done
+        working-directory: .
+
+      - name: Publish SpacetimeDB module
+        run: |
+          spacetime publish \
+            --server http://localhost:3000 \
+            --bin-path target/wasm32-unknown-unknown/release/spacetime_module.wasm \
+            --yes \
+            benchmark-links
+        working-directory: rust/spacetime-module
 
       - name: Build benchmark
         run: cargo build --release
@@ -95,6 +158,8 @@ jobs:
         env:
           BENCHMARK_LINK_COUNT: 1000
           BACKGROUND_LINK_COUNT: 3000
+          SPACETIMEDB_URI: http://localhost:3000
+          SPACETIMEDB_DB: benchmark-links
         run: cargo bench --bench bench -- --output-format bencher | tee out.txt
 
       - name: Generate charts
diff --git a/README.md b/README.md
index 104a9fc..aff2adf 100644
--- a/README.md
+++ b/README.md
@@ -2,7 +2,7 @@
 
 Benchmark comparing [SpacetimeDB 2](https://github.com/clockworklabs/SpacetimeDB) vs [Doublets](https://github.com/linksplatform/doublets-rs) performance for basic CRUD operations with links.
 
-SpacetimeDB is benchmarked via its SQLite storage backend (the same engine SpacetimeDB 2 uses internally). Doublets is benchmarked with its in-memory (volatile) storage variants.
+SpacetimeDB is benchmarked using the official `spacetimedb-sdk` Rust crate connected to a running SpacetimeDB 2.0 server. Doublets is benchmarked with both in-memory (volatile) and file-backed (non-volatile) storage variants.
 
 ## Benchmark Operations
 
@@ -18,16 +18,18 @@ SpacetimeDB is benchmarked via its SQLite storage backend (the same engine Space
 
 ## Backends Benchmarked
 
-### SpacetimeDB (SQLite backend)
-- **SpacetimeDB Memory** — in-memory SQLite with B-tree indexes on `id`, `source`, `target`
+### SpacetimeDB
+- **SpacetimeDB** — connects to a running SpacetimeDB 2.0 server via the official `spacetimedb-sdk` Rust crate; uses the `links` table defined in the `spacetime-module` WebAssembly module
 
-SpacetimeDB 2 uses SQLite as its underlying data store for persistent tables. This benchmark measures the performance of SpacetimeDB's storage layer (SQLite + WAL mode) for link CRUD operations.
+The benchmark uses the official SpacetimeDB Rust client SDK, calling reducers to mutate data and reading from the client-side subscription cache.
 
 ### Doublets
 - **Doublets United Volatile** — in-memory store; links stored as contiguous `(index, source, target)` units
 - **Doublets Split Volatile** — in-memory store; separate data and index memory regions
+- **Doublets United NonVolatile** — file-backed store; same contiguous layout but memory-mapped to a single file; data persists to disk
+- **Doublets Split NonVolatile** — file-backed store; separate data and index files; both memory-mapped; data persists to disk
 
-Doublets is a custom in-memory doublet link data structure with O(1) lookup by id and O(log n + k) traversal by source/target using balanced tree indexes.
+Doublets uses a recursive-less size-balanced tree for O(1) lookup by id and O(log n + k) traversal by source/target. The file-backed variants use `memmap2` for memory-mapped file I/O, flushing changes to disk on drop via `sync_all()`. See [`rust/doublets-patched/PATCHES.md`](rust/doublets-patched/PATCHES.md) for why a local patched copy is used instead of the published crates.io version.
 
 ## Benchmark Background
 
@@ -44,15 +46,17 @@ Each benchmark iteration pre-populates the database with background links to sim
 
 ## Operation Complexity
 
-| Operation | SpacetimeDB (SQLite) | Doublets United | Doublets Split |
+| Operation | SpacetimeDB | Doublets United | Doublets Split |
 |---|---|---|---|
-| Create | O(log n) + disk I/O | O(log n) | O(log n) |
-| Delete | O(log n) + disk I/O | O(log n) | O(log n) |
-| Update | O(log n) + disk I/O | O(log n) | O(log n) |
-| Query All | O(n) + disk I/O | O(n) | O(n) |
-| Query by Id | O(log n) | O(1) | O(1) |
-| Query by Source | O(log n + k) | O(log n + k) | O(log n + k) |
-| Query by Target | O(log n + k) | O(log n + k) | O(log n + k) |
+| Create | O(log n) + network | O(log n) | O(log n) |
+| Delete | O(log n) + network | O(log n) | O(log n) |
+| Update | O(log n) + network | O(log n) | O(log n) |
+| Query All | O(n) cache read | O(n) | O(n) |
+| Query by Id | O(n) cache scan | O(1) | O(1) |
+| Query by Source | O(n) cache scan | O(log n + k) | O(log n + k) |
+| Query by Target | O(n) cache scan | O(log n + k) | O(log n + k) |
+
+The algorithmic complexity is the same for volatile and non-volatile Doublets variants. The non-volatile variants have additional I/O overhead due to memory-mapped file writes (flushed to disk on drop).
 
 ## Related Benchmarks
 
@@ -64,7 +68,19 @@ Each benchmark iteration pre-populates the database with background links to sim
 
 ### Prerequisites
 
-- Rust nightly-2022-08-22 (see `rust/rust-toolchain.toml`)
+- Rust nightly (see `rust/rust-toolchain.toml`)
+- SpacetimeDB CLI: `curl -sSf https://install.spacetimedb.com | sh`
+
+### Start SpacetimeDB server and publish module
+
+```bash
+# Start the local SpacetimeDB server
+spacetime start &
+
+# Build and publish the links module
+spacetime build --project-path spacetime-module
+spacetime publish --project-path spacetime-module benchmark-links
+```
 
 ### Run benchmarks
 
@@ -72,10 +88,13 @@ Each benchmark iteration pre-populates the database with background links to sim
 cd rust
 
 # Full benchmark run (1000 links, 3000 background)
-cargo bench --bench bench -- --output-format bencher | tee out.txt
+SPACETIMEDB_URI=http://localhost:3000 SPACETIMEDB_DB=benchmark-links \
+  cargo bench --bench bench -- --output-format bencher | tee out.txt
 
 # Quick benchmark run (CI scale)
-BENCHMARK_LINK_COUNT=10 BACKGROUND_LINK_COUNT=100 cargo bench --bench bench
+BENCHMARK_LINK_COUNT=10 BACKGROUND_LINK_COUNT=100 \
+SPACETIMEDB_URI=http://localhost:3000 SPACETIMEDB_DB=benchmark-links \
+  cargo bench --bench bench
 
 # Generate charts from results
 python3 out.py
@@ -85,7 +104,7 @@ python3 out.py
 
 ```bash
 cd rust
-cargo test --release
+SPACETIMEDB_URI=http://localhost:3000 SPACETIMEDB_DB=benchmark-links cargo test
 ```
 
 ### Code quality
@@ -100,14 +119,21 @@ cargo clippy --all-targets
 
 ```
 .
+├── spacetime-module/           # SpacetimeDB WASM module (links table + reducers)
+│   ├── Cargo.toml
+│   └── src/
+│       └── lib.rs              # Table definition and reducers using `spacetimedb` crate
 ├── rust/
 │   ├── Cargo.toml              # Package manifest with pinned dependencies
+│   ├── doublets-patched/       # Local patches to doublets-rs for modern nightly compatibility
+│   │   └── PATCHES.md          # Documents why patches are needed and what was changed
 │   ├── rust-toolchain.toml     # Pinned Rust nightly toolchain
 │   ├── rustfmt.toml            # Rust formatting config
 │   ├── out.py                  # Chart generation script (matplotlib)
 │   ├── src/
 │   │   ├── lib.rs              # Links trait, constants (BENCHMARK_LINK_COUNT, BACKGROUND_LINK_COUNT)
-│   │   ├── spacetimedb_impl.rs # SpacetimeDB SQLite client (implements Links)
+│   │   ├── module_bindings/    # spacetimedb-sdk client bindings for the links module
+│   │   ├── spacetimedb_impl.rs # SpacetimeDB SDK client (implements Links)
 │   │   ├── doublets_impl.rs    # Doublets store adapters (implements Links)
 │   │   ├── exclusive.rs        # Exclusive<T> wrapper for interior mutability
 │   │   ├── fork.rs             # Fork<B> — benchmark iteration isolation
@@ -116,7 +142,7 @@ cargo clippy --all-targets
 │   │       ├── spacetimedb_benched.rs  # Benched impl for SpacetimeDB
 │   │       └── doublets_benched.rs     # Benched impls for Doublets stores
 │   └── benches/
-│       └── bench.rs            # Criterion benchmark suite (7 operations x 3 backends)
+│       └── bench.rs            # Criterion benchmark suite (7 operations x 5 backends)
 └── .github/
     └── workflows/
         └── rust-benchmark.yml  # CI: test on 3 OS + benchmark + chart generation
diff --git a/changelog.d/20260224_spacetimedb_vs_doublets_benchmark.md b/changelog.d/20260224_spacetimedb_vs_doublets_benchmark.md
index 7d8ac60..3d2d2eb 100644
--- a/changelog.d/20260224_spacetimedb_vs_doublets_benchmark.md
+++ b/changelog.d/20260224_spacetimedb_vs_doublets_benchmark.md
@@ -4,17 +4,19 @@ bump: minor
 
 ### Added
 
-- **SpacetimeDB 2 vs Doublets benchmark** (`rust/`): New Rust benchmark suite comparing SpacetimeDB's SQLite backend against Doublets in-memory link stores for basic CRUD operations, following best practices from the Neo4j and PostgreSQL comparison benchmarks.
+- **SpacetimeDB 2 vs Doublets benchmark** (`rust/`): New Rust benchmark suite comparing SpacetimeDB 2.0 against Doublets in-memory link stores for basic CRUD operations.
 
   - **7 benchmark operations**: Create, Delete, Update, Query All, Query by Id, Query by Source, Query by Target
-  - **3 backends**: SpacetimeDB Memory (SQLite/WAL), Doublets United Volatile, Doublets Split Volatile
+  - **3 backends**: SpacetimeDB 2.0 (via official `spacetimedb-sdk` Rust crate), Doublets United Volatile, Doublets Split Volatile
   - **Configurable scale**: `BENCHMARK_LINK_COUNT` and `BACKGROUND_LINK_COUNT` environment variables
   - **Criterion harness**: Uses criterion 0.3.6 with custom `iter_custom` timing to exclude setup/teardown from measurements
   - **Fork/unfork lifecycle**: Each iteration starts from a clean database state with pre-populated background links
 
-- **`rust/src/lib.rs`**: `Links` trait as the shared interface for both SpacetimeDB and Doublets backends; `Benched` trait for benchmark lifecycle management.
+- **`spacetime-module/`**: SpacetimeDB WebAssembly module using the official `spacetimedb` Rust crate, defining the `links` table and CRUD reducers.
 
-- **`rust/src/spacetimedb_impl.rs`**: SpacetimeDB SQLite client implementing the `Links` trait using the same schema and indexes that SpacetimeDB 2 uses internally.
+- **`rust/src/module_bindings/`**: Client-side SDK bindings for the links module (equivalent to `spacetime generate --lang rust` output).
+
+- **`rust/src/spacetimedb_impl.rs`**: SpacetimeDB 2.0 implementation using the official `spacetimedb-sdk` Rust crate. Connects to a running SpacetimeDB server, subscribes to the links table, and calls reducers for CRUD operations.
 
 - **`rust/src/doublets_impl.rs`**: Doublets store adapters implementing the `Links` trait for both United Volatile and Split Volatile storage layouts.
 
@@ -22,6 +24,6 @@ bump: minor
 
 - **`rust/out.py`**: Python script for generating comparison charts (linear and log scale PNG) and a Markdown results table from benchmark output.
 
-- **`.github/workflows/rust-benchmark.yml`**: GitHub Actions CI workflow that runs tests on Ubuntu/macOS/Windows and generates benchmark charts on push to main.
+- **`.github/workflows/rust-benchmark.yml`**: GitHub Actions CI workflow that installs the SpacetimeDB CLI, starts a local server, publishes the module, runs tests on Ubuntu/macOS/Windows, and generates benchmark charts on push to main.
 
 - **Updated `README.md`**: Benchmark description, operation complexity table, and usage instructions.
diff --git a/rust/Cargo.lock b/rust/Cargo.lock
index 436a863..f5f4aca 100644
--- a/rust/Cargo.lock
+++ b/rust/Cargo.lock
@@ -1,34 +1,98 @@
 # This file is automatically @generated by Cargo.
 # It is not intended for manual editing.
-version = 3
+version = 4
+
+[[package]]
+name = "adler2"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"
 
 [[package]]
 name = "ahash"
-version = "0.7.8"
+version = "0.8.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "891477e0c6a8957309ee5c45a6368af3ae14bb510732d2684ffa19af310920f9"
+checksum = "5a15f179cd60c4584b8a8c596927aadc462e27f2ca70c04e0071964a73ba7a75"
 dependencies = [
- "getrandom",
+ "cfg-if",
  "once_cell",
  "version_check",
+ "zerocopy",
 ]
 
 [[package]]
 name = "aho-corasick"
-version = "0.7.20"
+version = "1.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cc936419f96fa211c1b9166887b38e5e40b19958e5b895be7c1f93adec7071ac"
+checksum = "ddd31a130427c27518df266943a5308ed92d4b226cc639f5a8f1002816174301"
 dependencies = [
  "memchr",
 ]
 
+[[package]]
+name = "alloc-no-stdlib"
+version = "2.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cc7bb162ec39d46ab1ca8c77bf72e890535becd1751bb45f64c597edb4c8c6b3"
+
+[[package]]
+name = "alloc-stdlib"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94fb8275041c72129eb51b7d0322c29b8387a0386127718b096429201a5d6ece"
+dependencies = [
+ "alloc-no-stdlib",
+]
+
+[[package]]
+name = "android_system_properties"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "anyhow"
+version = "1.0.102"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f202df86484c868dbad7eaa557ef785d5c66295e41b460ef922eca0723b842c"
+
+[[package]]
+name = "anymap"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "33954243bd79057c2de7338850b85983a44588021f8a5fee574a8888c6de4344"
+
+[[package]]
+name = "approx"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0e60b75072ecd4168020818c0107f2857bb6c4e64252d8d3983f6263b40a5c3"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "arrayref"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "76a2e8124351fda1ef8aaaa3bbd7ebbcb486bbcd4225aca0aa0d84bb2db8fecb"
+
+[[package]]
+name = "arrayvec"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50"
+
 [[package]]
 name = "atty"
 version = "0.2.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
 dependencies = [
- "hermit-abi 0.1.19",
+ "hermit-abi",
  "libc",
  "winapi",
 ]
@@ -39,6 +103,18 @@ version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
 
+[[package]]
+name = "base64"
+version = "0.21.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d297deb1925b89f2ccc13d7635fa0714f12c87adce1c75356b39ca9b7178567"
+
+[[package]]
+name = "base64"
+version = "0.22.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
+
 [[package]]
 name = "beef"
 version = "0.5.2"
@@ -51,11 +127,83 @@ version = "1.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 
+[[package]]
+name = "bitflags"
+version = "2.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "843867be96c8daad0d758b57df9392b6d8d271134fce549de6ce169ff98a92af"
+
+[[package]]
+name = "blake3"
+version = "1.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2468ef7d57b3fb7e16b576e8377cdbde2320c60e1491e961d11da40fc4f02a2d"
+dependencies = [
+ "arrayref",
+ "arrayvec",
+ "cc",
+ "cfg-if",
+ "constant_time_eq",
+ "cpufeatures",
+]
+
+[[package]]
+name = "block-buffer"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
+name = "brotli"
+version = "3.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d640d25bc63c50fb1f0b545ffd80207d2e10a4c965530809b40ba3386825c391"
+dependencies = [
+ "alloc-no-stdlib",
+ "alloc-stdlib",
+ "brotli-decompressor",
+]
+
+[[package]]
+name = "brotli-decompressor"
+version = "2.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4e2e4afe60d7dd600fdd3de8d0f08c2b7ec039712e3b6137ff98b7004e82de4f"
+dependencies = [
+ "alloc-no-stdlib",
+ "alloc-stdlib",
+]
+
 [[package]]
 name = "bumpalo"
-version = "3.11.1"
+version = "3.20.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d20789868f4b01b2f2caec9f5c4e0213b41e3e5702a50157d699ae31ced2fcb"
+
+[[package]]
+name = "bytemuck"
+version = "1.25.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8efb64bd706a16a1bdde310ae86b351e4d21550d98d056f22f8a7f7a2183fec"
+
+[[package]]
+name = "bytes"
+version = "1.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e748733b7cbc798e1434b6ac524f0c1ff2ab456fe201501e6497c8417a4fc33"
+
+[[package]]
+name = "bytestring"
+version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "572f695136211188308f16ad2ca5c851a712c464060ae6974944458eb83880ba"
+checksum = "113b4343b5f6617e7ad401ced8de3cc8b012e73a594347c307b90db3e9271289"
+dependencies = [
+ "bytes",
+ "serde_core",
+]
 
 [[package]]
 name = "cast"
@@ -63,6 +211,15 @@ version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
 
+[[package]]
+name = "castaway"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dec551ab6e7578819132c713a93c022a05d60159dc86e7a7050223577484c55a"
+dependencies = [
+ "rustversion",
+]
+
 [[package]]
 name = "cc"
 version = "1.2.56"
@@ -79,17 +236,96 @@ version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
 
+[[package]]
+name = "chrono"
+version = "0.4.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c673075a2e0e5f4a1dde27ce9dee1ea4558c7ffe648f576438a20ca1d2acc4b0"
+dependencies = [
+ "iana-time-zone",
+ "num-traits",
+ "serde",
+ "windows-link",
+]
+
 [[package]]
 name = "clap"
 version = "2.34.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a0610544180c38b88101fecf2dd634b174a62eef6946f84dfc6a7127512b381c"
 dependencies = [
- "bitflags",
+ "bitflags 1.3.2",
  "textwrap",
  "unicode-width",
 ]
 
+[[package]]
+name = "console"
+version = "0.15.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "054ccb5b10f9f2cbf51eb355ca1d05c2d279ce1804688d0db74b4733a5aeafd8"
+dependencies = [
+ "encode_unicode",
+ "libc",
+ "once_cell",
+ "windows-sys 0.59.0",
+]
+
+[[package]]
+name = "constant_time_eq"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d52eff69cd5e647efe296129160853a42795992097e8af39800e1060caeea9b"
+
+[[package]]
+name = "convert_case"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6245d59a3e82a7fc217c5828a6692dbc6dfb63a0c8c90495621f7b9d79704a0e"
+
+[[package]]
+name = "convert_case"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec182b0ca2f35d8fc196cf3404988fd8b8c739a4d270ff118a398feb0cbec1ca"
+dependencies = [
+ "unicode-segmentation",
+]
+
+[[package]]
+name = "core-foundation"
+version = "0.9.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91e195e091a93c46f7102ec7818a2aa394e1e1771c3ab4825963fa03e45afb8f"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
+[[package]]
+name = "core-foundation-sys"
+version = "0.8.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"
+
+[[package]]
+name = "cpufeatures"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "crc32fast"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9481c1c90cbf2ac953f07c8d4a58aa3945c425b7185c9154d67a65e4230da511"
+dependencies = [
+ "cfg-if",
+]
+
 [[package]]
 name = "criterion"
 version = "0.3.6"
@@ -101,7 +337,7 @@ dependencies = [
  "clap",
  "criterion-plot",
  "csv",
- "itertools",
+ "itertools 0.10.5",
  "lazy_static",
  "num-traits",
  "oorandom",
@@ -123,16 +359,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2673cc8207403546f45f5fd319a974b1e6983ad1a3ee7e6041650013be041876"
 dependencies = [
  "cast",
- "itertools",
-]
-
-[[package]]
-name = "crossbeam-channel"
-version = "0.5.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "82b8f8f868b36967f9606790d1903570de9ceaf870a7bf9fbbd3016d636a2cb2"
-dependencies = [
- "crossbeam-utils",
+ "itertools 0.10.5",
 ]
 
 [[package]]
@@ -154,22 +381,41 @@ dependencies = [
  "crossbeam-utils",
 ]
 
+[[package]]
+name = "crossbeam-queue"
+version = "0.3.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0f58bbc28f91df819d0aa2a2c00cd19754769c2fad90579b3592b1c9ba7a3115"
+dependencies = [
+ "crossbeam-utils",
+]
+
 [[package]]
 name = "crossbeam-utils"
 version = "0.8.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
 
+[[package]]
+name = "crypto-common"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a"
+dependencies = [
+ "generic-array",
+ "typenum",
+]
+
 [[package]]
 name = "csv"
-version = "1.3.1"
+version = "1.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "acdc4883a9c96732e4733212c01447ebd805833b7275a73ca3ee080fd77afdaf"
+checksum = "52cd9d68cf7efc6ddfaaee42e7288d3a99d613d4b50f76ce9827ae0c6e14f938"
 dependencies = [
  "csv-core",
  "itoa",
  "ryu",
- "serde",
+ "serde_core",
 ]
 
 [[package]]
@@ -182,694 +428,2699 @@ dependencies = [
 ]
 
 [[package]]
-name = "delegate"
-version = "0.7.0"
+name = "darling"
+version = "0.21.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d70a2d4995466955a415223acf3c9c934b9ff2339631cdf4ffc893da4bacd717"
+checksum = "9cdf337090841a411e2a7f3deb9187445851f91b309c0c0a29e05f74a00a48c0"
+dependencies = [
+ "darling_core",
+ "darling_macro",
+]
+
+[[package]]
+name = "darling_core"
+version = "0.21.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1247195ecd7e3c85f83c8d2a366e4210d588e802133e1e355180a9870b517ea4"
 dependencies = [
+ "fnv",
+ "ident_case",
  "proc-macro2",
  "quote",
- "syn",
+ "strsim",
+ "syn 2.0.117",
 ]
 
 [[package]]
-name = "doublets"
-version = "0.1.0-pre+beta.15"
-source = "git+https://github.com/linksplatform/doublets-rs.git?rev=5522d91c536654934b7181829f6efb570fb8bb44#5522d91c536654934b7181829f6efb570fb8bb44"
+name = "darling_macro"
+version = "0.21.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d38308df82d1080de0afee5d069fa14b0326a88c14f15c5ccda35b4a6c414c81"
 dependencies = [
- "bumpalo",
- "cfg-if",
- "leak_slice",
- "platform-data",
- "platform-mem",
- "platform-trees",
- "tap",
- "thiserror",
+ "darling_core",
+ "quote",
+ "syn 2.0.117",
 ]
 
 [[package]]
-name = "either"
-version = "1.15.0"
+name = "data-encoding"
+version = "2.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"
+checksum = "d7a1e2f27636f116493b8b860f5546edb47c8d8f8ea73e1d2a20be88e28d1fea"
 
 [[package]]
-name = "fallible-iterator"
-version = "0.2.0"
+name = "decorum"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4443176a9f2c162692bd3d352d745ef9413eec5782a80d8fd6f8a1ac692a07f7"
+checksum = "281759d3c8a14f5c3f0c49363be56810fcd7f910422f97f2db850c2920fde5cf"
+dependencies = [
+ "approx",
+ "num-traits",
+]
 
 [[package]]
-name = "fallible-streaming-iterator"
-version = "0.1.9"
+name = "delegate"
+version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7360491ce676a36bf9bb3c56c1aa791658183a54d2744120f27285738d90465a"
+checksum = "d70a2d4995466955a415223acf3c9c934b9ff2339631cdf4ffc893da4bacd717"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
 
 [[package]]
-name = "fastrand"
-version = "1.8.0"
+name = "deranged"
+version = "0.5.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a7a407cfaa3385c4ae6b23e84623d48c2798d06e3e6a1878f7f59f17b3f86499"
+checksum = "7cd812cc2bc1d69d4764bd80df88b4317eaef9e773c75226407d9bc0876b211c"
 dependencies = [
- "instant",
+ "powerfmt",
+ "serde_core",
 ]
 
 [[package]]
-name = "find-msvc-tools"
-version = "0.1.9"
+name = "derive_more"
+version = "0.99.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582"
+checksum = "6edb4b64a43d977b8e99788fe3a04d483834fba1215a7e02caa415b626497f7f"
+dependencies = [
+ "convert_case 0.4.0",
+ "proc-macro2",
+ "quote",
+ "rustc_version",
+ "syn 2.0.117",
+]
 
 [[package]]
-name = "funty"
-version = "2.0.0"
+name = "digest"
+version = "0.10.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"
+checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
+dependencies = [
+ "block-buffer",
+ "crypto-common",
+]
 
 [[package]]
-name = "getrandom"
-version = "0.2.8"
+name = "displaydoc"
+version = "0.2.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c05aeb6a22b8f62540c194aac980f2115af067bfe15a0734d7277a768d396b31"
+checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "doublets"
+version = "0.1.0-pre+beta.15"
 dependencies = [
+ "bumpalo",
  "cfg-if",
- "libc",
- "wasi",
+ "leak_slice",
+ "platform-data",
+ "platform-mem",
+ "platform-trees",
+ "tap",
+ "thiserror 1.0.69",
 ]
 
 [[package]]
-name = "half"
-version = "1.8.3"
+name = "dyn-clone"
+version = "1.0.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b43ede17f21864e81be2fa654110bf1e793774238d86ef8555c37e6519c0403"
+checksum = "d0881ea181b1df73ff77ffaaf9c7544ecc11e82fba9b5f27b262a3c73a332555"
 
 [[package]]
-name = "hashbrown"
-version = "0.11.2"
+name = "either"
+version = "1.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"
+
+[[package]]
+name = "encode_unicode"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34aa73646ffb006b8f5147f3dc182bd4bcb190227ce861fc4a4844bf8e3cb2c0"
+
+[[package]]
+name = "enum-as-inner"
+version = "0.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ab5ef0d4909ef3724cc8cce6ccc8572c5c817592e9285f5464f8e86f8bd3726e"
+checksum = "a1e6a265c649f3f5979b601d26f1d05ada116434c87741c9493cb56218f76cbc"
 dependencies = [
- "ahash",
+ "heck 0.5.0",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
 ]
 
 [[package]]
-name = "hashlink"
-version = "0.7.0"
+name = "enum-map"
+version = "2.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7249a3129cbc1ffccd74857f81464a323a152173cdb134e0fd81bc803b29facf"
+checksum = "6866f3bfdf8207509a033af1a75a7b08abda06bbaaeae6669323fd5a097df2e9"
 dependencies = [
- "hashbrown",
+ "enum-map-derive",
 ]
 
 [[package]]
-name = "hermit-abi"
-version = "0.1.19"
+name = "enum-map-derive"
+version = "0.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33"
+checksum = "f282cfdfe92516eb26c2af8589c274c7c17681f5ecc03c18255fe741c6aa64eb"
 dependencies = [
- "libc",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
 ]
 
 [[package]]
-name = "hermit-abi"
-version = "0.5.2"
+name = "equivalent"
+version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fc0fef456e4baa96da950455cd02c081ca953b141298e41db3fc7e36b1da849c"
+checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
 
 [[package]]
-name = "instant"
-version = "0.1.13"
+name = "errno"
+version = "0.3.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e0242819d153cba4b4b05a5a8f2a7e9bbf97b6055b2a002b395c96b5ff3c0222"
+checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
 dependencies = [
- "cfg-if",
+ "libc",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
-name = "itertools"
-version = "0.10.5"
+name = "ethnum"
+version = "1.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473"
+checksum = "ca81e6b4777c89fd810c25a4be2b1bd93ea034fbe58e6a75216a34c6b82c539b"
 dependencies = [
- "either",
+ "serde",
 ]
 
 [[package]]
-name = "itoa"
-version = "1.0.5"
+name = "fastrand"
+version = "2.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fad582f4b9e86b6caa621cabeb0963332d92eea04729ab12892c2533951e6440"
+checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be"
 
 [[package]]
-name = "js-sys"
-version = "0.3.61"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "445dde2150c55e483f3d8416706b97ec8e8237c307e5b7b4b8dd15e6af2a0730"
+name = "find-msvc-tools"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582"
+
+[[package]]
+name = "fixedbitset"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80"
+
+[[package]]
+name = "flate2"
+version = "1.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "843fba2746e448b37e26a819579957415c8cef339bf08564fe8b7ddbd959573c"
 dependencies = [
- "wasm-bindgen",
+ "crc32fast",
+ "miniz_oxide",
 ]
 
 [[package]]
-name = "lazy_static"
-version = "1.5.0"
+name = "fnv"
+version = "1.0.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
+checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
 
 [[package]]
-name = "leak_slice"
-version = "0.2.0"
+name = "foldhash"
+version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ecf3387da9fb41906394e1306ddd3cd26dd9b7177af11c19b45b364b743aed26"
+checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2"
 
 [[package]]
-name = "libc"
-version = "0.2.182"
+name = "foreign-types"
+version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6800badb6cb2082ffd7b6a67e6125bb39f18782f793520caee8cb8846be06112"
+checksum = "f6f339eb8adc052cd2ca78910fda869aefa38d22d5cb648e6485e4d3fc06f3b1"
+dependencies = [
+ "foreign-types-shared",
+]
+
+[[package]]
+name = "foreign-types-shared"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b"
 
 [[package]]
-name = "libsqlite3-sys"
-version = "0.24.2"
+name = "form_urlencoded"
+version = "1.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "898745e570c7d0453cc1fbc4a701eb6c662ed54e8fec8b7d14be137ebeeb9d14"
+checksum = "cb4cb245038516f5f85277875cdaa4f7d2c9a0fa0468de06ed190163b1581fcf"
 dependencies = [
- "cc",
- "pkg-config",
- "vcpkg",
+ "percent-encoding",
 ]
 
 [[package]]
-name = "log"
-version = "0.4.29"
+name = "funty"
+version = "2.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e5032e24019045c762d3c0f28f5b6b8bbf38563a65908389bf7978758920897"
+checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"
 
 [[package]]
-name = "memchr"
-version = "2.8.0"
+name = "futures"
+version = "0.3.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79"
+checksum = "8b147ee9d1f6d097cef9ce628cd2ee62288d963e16fb287bd9286455b241382d"
+dependencies = [
+ "futures-channel",
+ "futures-core",
+ "futures-executor",
+ "futures-io",
+ "futures-sink",
+ "futures-task",
+ "futures-util",
+]
 
 [[package]]
-name = "memmap2"
-version = "0.5.10"
+name = "futures-channel"
+version = "0.3.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "83faa42c0a078c393f6b29d5db232d8be22776a891f8f56e5284faee4a20b327"
+checksum = "07bbe89c50d7a535e539b8c17bc0b49bdb77747034daa8087407d655f3f7cc1d"
+dependencies = [
+ "futures-core",
+ "futures-sink",
+]
+
+[[package]]
+name = "futures-core"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7e3450815272ef58cec6d564423f6e755e25379b217b0bc688e295ba24df6b1d"
+
+[[package]]
+name = "futures-executor"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf29c38818342a3b26b5b923639e7b1f4a61fc5e76102d4b1981c6dc7a7579d"
+dependencies = [
+ "futures-core",
+ "futures-task",
+ "futures-util",
+]
+
+[[package]]
+name = "futures-io"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cecba35d7ad927e23624b22ad55235f2239cfa44fd10428eecbeba6d6a717718"
+
+[[package]]
+name = "futures-macro"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e835b70203e41293343137df5c0664546da5745f82ec9b84d40be8336958447b"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "futures-sink"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c39754e157331b013978ec91992bde1ac089843443c49cbc7f46150b0fad0893"
+
+[[package]]
+name = "futures-task"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "037711b3d59c33004d3856fbdc83b99d4ff37a24768fa1be9ce3538a1cde4393"
+
+[[package]]
+name = "futures-util"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "389ca41296e6190b48053de0321d02a77f32f8a5d2461dd38762c0593805c6d6"
+dependencies = [
+ "futures-channel",
+ "futures-core",
+ "futures-io",
+ "futures-macro",
+ "futures-sink",
+ "futures-task",
+ "memchr",
+ "pin-project-lite",
+ "slab",
+]
+
+[[package]]
+name = "generic-array"
+version = "0.14.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
+dependencies = [
+ "typenum",
+ "version_check",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd"
 dependencies = [
+ "cfg-if",
  "libc",
+ "r-efi",
+ "wasip2",
 ]
 
 [[package]]
-name = "num-traits"
-version = "0.2.19"
+name = "getrandom"
+version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
+checksum = "139ef39800118c7683f2fd3c98c1b23c09ae076556b435f8e9064ae108aaeeec"
 dependencies = [
- "autocfg",
+ "cfg-if",
+ "libc",
+ "r-efi",
+ "wasip2",
+ "wasip3",
+]
+
+[[package]]
+name = "half"
+version = "1.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b43ede17f21864e81be2fa654110bf1e793774238d86ef8555c37e6519c0403"
+
+[[package]]
+name = "hashbrown"
+version = "0.12.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
+
+[[package]]
+name = "hashbrown"
+version = "0.15.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1"
+dependencies = [
+ "foldhash",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.16.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100"
+dependencies = [
+ "equivalent",
+ "rayon",
+ "serde",
+ "serde_core",
 ]
 
 [[package]]
-name = "num_cpus"
-version = "1.17.0"
+name = "heck"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8"
+
+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+
+[[package]]
+name = "hermit-abi"
+version = "0.1.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "91df4bbde75afed763b708b7eee1e8e7651e02d97f6d5dd763e89367e957b23b"
+checksum = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33"
 dependencies = [
- "hermit-abi 0.5.2",
  "libc",
 ]
 
 [[package]]
-name = "once_cell"
-version = "1.21.3"
+name = "hex"
+version = "0.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
+checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
 
 [[package]]
-name = "oorandom"
-version = "11.1.5"
+name = "home"
+version = "0.5.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d6790f58c7ff633d8771f42965289203411a5e5c68388703c06e14f24770b41e"
+checksum = "cc627f471c528ff0c4a49e1d5e60450c8f6461dd6d10ba9dcd3a61d3dff7728d"
+dependencies = [
+ "windows-sys 0.61.2",
+]
 
 [[package]]
-name = "pkg-config"
-version = "0.3.32"
+name = "http"
+version = "1.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7edddbd0b52d732b21ad9a5fab5c704c14cd949e5e9a1ec5929a24fded1b904c"
+checksum = "e3ba2a386d7f85a81f119ad7498ebe444d2e22c2af0b86b069416ace48b3311a"
+dependencies = [
+ "bytes",
+ "itoa",
+]
+
+[[package]]
+name = "httparse"
+version = "1.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87"
+
+[[package]]
+name = "humantime"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "135b12329e5e3ce057a9f972339ea52bc954fe1e9358ef27f95e89716fbc5424"
+
+[[package]]
+name = "iana-time-zone"
+version = "0.1.65"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e31bc9ad994ba00e440a8aa5c9ef0ec67d5cb5e5cb0cc7f8b744a35b389cc470"
+dependencies = [
+ "android_system_properties",
+ "core-foundation-sys",
+ "iana-time-zone-haiku",
+ "js-sys",
+ "log",
+ "wasm-bindgen",
+ "windows-core",
+]
+
+[[package]]
+name = "iana-time-zone-haiku"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f"
+dependencies = [
+ "cc",
+]
+
+[[package]]
+name = "icu_collections"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4c6b649701667bbe825c3b7e6388cb521c23d88644678e83c0c4d0a621a34b43"
+dependencies = [
+ "displaydoc",
+ "potential_utf",
+ "yoke",
+ "zerofrom",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_locale_core"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "edba7861004dd3714265b4db54a3c390e880ab658fec5f7db895fae2046b5bb6"
+dependencies = [
+ "displaydoc",
+ "litemap",
+ "tinystr",
+ "writeable",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_normalizer"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5f6c8828b67bf8908d82127b2054ea1b4427ff0230ee9141c54251934ab1b599"
+dependencies = [
+ "icu_collections",
+ "icu_normalizer_data",
+ "icu_properties",
+ "icu_provider",
+ "smallvec",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_normalizer_data"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7aedcccd01fc5fe81e6b489c15b247b8b0690feb23304303a9e560f37efc560a"
+
+[[package]]
+name = "icu_properties"
+version = "2.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "020bfc02fe870ec3a66d93e677ccca0562506e5872c650f893269e08615d74ec"
+dependencies = [
+ "icu_collections",
+ "icu_locale_core",
+ "icu_properties_data",
+ "icu_provider",
+ "zerotrie",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_properties_data"
+version = "2.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "616c294cf8d725c6afcd8f55abc17c56464ef6211f9ed59cccffe534129c77af"
+
+[[package]]
+name = "icu_provider"
+version = "2.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85962cf0ce02e1e0a629cc34e7ca3e373ce20dda4c4d7294bbd0bf1fdb59e614"
+dependencies = [
+ "displaydoc",
+ "icu_locale_core",
+ "writeable",
+ "yoke",
+ "zerofrom",
+ "zerotrie",
+ "zerovec",
+]
+
+[[package]]
+name = "id-arena"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d3067d79b975e8844ca9eb072e16b31c3c1c36928edf9c6789548c524d0d954"
+
+[[package]]
+name = "ident_case"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39"
+
+[[package]]
+name = "idna"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b0875f23caa03898994f6ddc501886a45c7d3d62d04d2d90788d47be1b1e4de"
+dependencies = [
+ "idna_adapter",
+ "smallvec",
+ "utf8_iter",
+]
+
+[[package]]
+name = "idna_adapter"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3acae9609540aa318d1bc588455225fb2085b9ed0c4f6bd0d9d5bcd86f1a0344"
+dependencies = [
+ "icu_normalizer",
+ "icu_properties",
+]
+
+[[package]]
+name = "indexmap"
+version = "1.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bd070e393353796e801d209ad339e89596eb4c8d430d18ede6a1cced8fafbd99"
+dependencies = [
+ "autocfg",
+ "hashbrown 0.12.3",
+ "serde",
+]
+
+[[package]]
+name = "indexmap"
+version = "2.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7714e70437a7dc3ac8eb7e6f8df75fd8eb422675fc7678aff7364301092b1017"
+dependencies = [
+ "equivalent",
+ "hashbrown 0.16.1",
+ "serde",
+ "serde_core",
+]
+
+[[package]]
+name = "insta"
+version = "1.46.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e82db8c87c7f1ccecb34ce0c24399b8a73081427f3c7c50a5d597925356115e4"
+dependencies = [
+ "console",
+ "once_cell",
+ "regex",
+ "serde",
+ "similar",
+ "tempfile",
+ "toml_edit",
+ "toml_writer",
+]
+
+[[package]]
+name = "itertools"
+version = "0.10.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473"
+dependencies = [
+ "either",
+]
+
+[[package]]
+name = "itertools"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba291022dbbd398a455acf126c1e341954079855bc60dfdda641363bd6922569"
+dependencies = [
+ "either",
+]
+
+[[package]]
+name = "itoa"
+version = "1.0.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92ecc6618181def0457392ccd0ee51198e065e016d1d527a7ac1b6dc7c1f09d2"
+
+[[package]]
+name = "js-sys"
+version = "0.3.90"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "14dc6f6450b3f6d4ed5b16327f38fed626d375a886159ca555bd7822c0c3a5a6"
+dependencies = [
+ "once_cell",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "keccak"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb26cec98cce3a3d96cbb7bced3c4b16e3d13f27ec56dbd62cbc8f39cfb9d653"
+dependencies = [
+ "cpufeatures",
+]
+
+[[package]]
+name = "lazy_static"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
+
+[[package]]
+name = "leak_slice"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ecf3387da9fb41906394e1306ddd3cd26dd9b7177af11c19b45b364b743aed26"
+
+[[package]]
+name = "lean_string"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "962df00ba70ac8d5ca5c064e17e5c3d090c087fd8d21aa45096c716b169da514"
+dependencies = [
+ "castaway",
+ "itoa",
+ "ryu",
+]
+
+[[package]]
+name = "leb128fmt"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09edd9e8b54e49e587e4f6295a7d29c3ea94d469cb40ab8ca70b288248a81db2"
+
+[[package]]
+name = "libc"
+version = "0.2.182"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6800badb6cb2082ffd7b6a67e6125bb39f18782f793520caee8cb8846be06112"
+
+[[package]]
+name = "linux-raw-sys"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53"
+
+[[package]]
+name = "litemap"
+version = "0.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6373607a59f0be73a39b6fe456b8192fcc3585f602af20751600e974dd455e77"
+
+[[package]]
+name = "lock_api"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "224399e74b87b5f3557511d98dff8b14089b3dadafcab6bb93eab67d3aace965"
+dependencies = [
+ "scopeguard",
+]
+
+[[package]]
+name = "log"
+version = "0.4.29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e5032e24019045c762d3c0f28f5b6b8bbf38563a65908389bf7978758920897"
+
+[[package]]
+name = "memchr"
+version = "2.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79"
+
+[[package]]
+name = "memmap2"
+version = "0.5.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "83faa42c0a078c393f6b29d5db232d8be22776a891f8f56e5284faee4a20b327"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "miniz_oxide"
+version = "0.8.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fa76a2c86f704bdb222d66965fb3d63269ce38518b83cb0575fca855ebb6316"
+dependencies = [
+ "adler2",
+ "simd-adler32",
+]
+
+[[package]]
+name = "mio"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a69bcab0ad47271a0234d9422b131806bf3968021e5dc9328caf2d4cd58557fc"
+dependencies = [
+ "libc",
+ "wasi",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "native-tls"
+version = "0.2.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "87de3442987e9dbec73158d5c715e7ad9072fda936bb03d19d7fa10e00520f0e"
+dependencies = [
+ "libc",
+ "log",
+ "openssl",
+ "openssl-probe",
+ "openssl-sys",
+ "schannel",
+ "security-framework",
+ "security-framework-sys",
+ "tempfile",
+]
+
+[[package]]
+name = "nohash-hasher"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2bf50223579dc7cdcfb3bfcacf7069ff68243f8c363f62ffa99cf000a6b9c451"
+
+[[package]]
+name = "num-conv"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf97ec579c3c42f953ef76dbf8d55ac91fb219dde70e49aa4a6b7d74e9919050"
+
+[[package]]
+name = "num-traits"
+version = "0.2.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.21.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
+
+[[package]]
+name = "oorandom"
+version = "11.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d6790f58c7ff633d8771f42965289203411a5e5c68388703c06e14f24770b41e"
+
+[[package]]
+name = "openssl"
+version = "0.10.75"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08838db121398ad17ab8531ce9de97b244589089e290a384c900cb9ff7434328"
+dependencies = [
+ "bitflags 2.11.0",
+ "cfg-if",
+ "foreign-types",
+ "libc",
+ "once_cell",
+ "openssl-macros",
+ "openssl-sys",
+]
+
+[[package]]
+name = "openssl-macros"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a948666b637a0f465e8564c73e89d4dde00d72d4d473cc972f390fc3dcee7d9c"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "openssl-probe"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d05e27ee213611ffe7d6348b942e8f942b37114c00cc03cec254295a4a17852e"
+
+[[package]]
+name = "openssl-sys"
+version = "0.9.111"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "82cab2d520aa75e3c58898289429321eb788c3106963d0dc886ec7a5f4adc321"
+dependencies = [
+ "cc",
+ "libc",
+ "pkg-config",
+ "vcpkg",
+]
+
+[[package]]
+name = "parking_lot"
+version = "0.12.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93857453250e3077bd71ff98b6a65ea6621a19bb0f559a85248955ac12c45a1a"
+dependencies = [
+ "lock_api",
+ "parking_lot_core",
+]
+
+[[package]]
+name = "parking_lot_core"
+version = "0.9.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2621685985a2ebf1c516881c026032ac7deafcda1a2c9b7850dc81e3dfcb64c1"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "redox_syscall",
+ "smallvec",
+ "windows-link",
+]
+
+[[package]]
+name = "paste"
+version = "1.0.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"
+
+[[package]]
+name = "percent-encoding"
+version = "2.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220"
+
+[[package]]
+name = "petgraph"
+version = "0.6.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b4c5cc86750666a3ed20bdaf5ca2a0344f9c67674cae0515bec2da16fbaa47db"
+dependencies = [
+ "fixedbitset",
+ "indexmap 2.13.0",
+]
+
+[[package]]
+name = "pin-project-lite"
+version = "0.2.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b3cff922bd51709b605d9ead9aa71031d81447142d828eb4a6eba76fe619f9b"
+
+[[package]]
+name = "pkg-config"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7edddbd0b52d732b21ad9a5fab5c704c14cd949e5e9a1ec5929a24fded1b904c"
+
+[[package]]
+name = "platform-data"
+version = "0.1.0-beta.3"
+dependencies = [
+ "beef",
+ "funty",
+ "thiserror 1.0.69",
+]
+
+[[package]]
+name = "platform-mem"
+version = "0.1.0-pre+beta.2"
+dependencies = [
+ "delegate",
+ "memmap2",
+ "tap",
+ "tempfile",
+ "thiserror 1.0.69",
+]
+
+[[package]]
+name = "platform-trees"
+version = "0.1.0-beta.1"
+dependencies = [
+ "funty",
+ "platform-data",
+]
+
+[[package]]
+name = "plotters"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5aeb6f403d7a4911efb1e33402027fc44f29b5bf6def3effcc22d7bb75f2b747"
+dependencies = [
+ "num-traits",
+ "plotters-backend",
+ "plotters-svg",
+ "wasm-bindgen",
+ "web-sys",
+]
+
+[[package]]
+name = "plotters-backend"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df42e13c12958a16b3f7f4386b9ab1f3e7933914ecea48da7139435263a4172a"
+
+[[package]]
+name = "plotters-svg"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "51bae2ac328883f7acdfea3d66a7c35751187f870bc81f94563733a154d7a670"
+dependencies = [
+ "plotters-backend",
+]
+
+[[package]]
+name = "potential_utf"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b73949432f5e2a09657003c25bca5e19a0e9c84f8058ca374f49e0ebe605af77"
+dependencies = [
+ "zerovec",
+]
+
+[[package]]
+name = "powerfmt"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391"
+
+[[package]]
+name = "ppv-lite86"
+version = "0.2.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9"
+dependencies = [
+ "zerocopy",
+]
+
+[[package]]
+name = "prettyplease"
+version = "0.2.37"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "479ca8adacdd7ce8f1fb39ce9ecccbfe93a3f1344b3d0d97f20bc0196208f62b"
+dependencies = [
+ "proc-macro2",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.106"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "prometheus"
+version = "0.13.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d33c28a30771f7f96db69893f78b857f7450d7e0237e9c8fc6427a81bae7ed1"
+dependencies = [
+ "cfg-if",
+ "fnv",
+ "lazy_static",
+ "memchr",
+ "parking_lot",
+ "protobuf",
+ "thiserror 1.0.69",
+]
+
+[[package]]
+name = "protobuf"
+version = "2.28.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "106dd99e98437432fed6519dedecfade6a06a73bb7b2a1e019fdd2bee5778d94"
+
+[[package]]
+name = "quote"
+version = "1.0.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "21b2ebcf727b7760c461f091f9f0f539b77b8e87f2fd88131e7f1b433b3cece4"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "r-efi"
+version = "5.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
+
+[[package]]
+name = "rand"
+version = "0.9.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6db2770f06117d490610c7488547d543617b21bfa07796d7a12f6f1bd53850d1"
+dependencies = [
+ "rand_chacha",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb"
+dependencies = [
+ "ppv-lite86",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "76afc826de14238e6e8c374ddcc1fa19e374fd8dd986b0d2af0d02377261d83c"
+dependencies = [
+ "getrandom 0.3.4",
+]
+
+[[package]]
+name = "rayon"
+version = "1.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "368f01d005bf8fd9b1206fb6fa653e6c4a81ceb1466406b81792d87c5677a58f"
+dependencies = [
+ "either",
+ "rayon-core",
+]
+
+[[package]]
+name = "rayon-core"
+version = "1.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "22e18b0f0062d30d4230b2e85ff77fdfe4326feb054b9783a3460d8435c8ab91"
+dependencies = [
+ "crossbeam-deque",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "redox_syscall"
+version = "0.5.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d"
+dependencies = [
+ "bitflags 2.11.0",
+]
+
+[[package]]
+name = "ref-cast"
+version = "1.0.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f354300ae66f76f1c85c5f84693f0ce81d747e2c3f21a45fef496d89c960bf7d"
+dependencies = [
+ "ref-cast-impl",
+]
+
+[[package]]
+name = "ref-cast-impl"
+version = "1.0.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b7186006dcb21920990093f30e3dea63b7d6e977bf1256be20c3563a5db070da"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "regex"
+version = "1.12.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e10754a14b9137dd7b1e3e5b0493cc9171fdd105e0ab477f51b72e7f3ac0e276"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-automata",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6e1dd4122fc1595e8162618945476892eefca7b88c52820e74af6262213cae8f"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.8.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc897dd8d9e8bd1ed8cdad82b5966c3e0ecae09fb1907d58efaa013543185d0a"
+
+[[package]]
+name = "rustc_version"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cfcb3a22ef46e85b45de6ee7e79d063319ebb6594faafcf1c225ea92ab6e9b92"
+dependencies = [
+ "semver",
+]
+
+[[package]]
+name = "rustix"
+version = "1.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6fe4565b9518b83ef4f91bb47ce29620ca828bd32cb7e408f0062e9930ba190"
+dependencies = [
+ "bitflags 2.11.0",
+ "errno",
+ "libc",
+ "linux-raw-sys",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "rustversion"
+version = "1.0.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d"
+
+[[package]]
+name = "ryu"
+version = "1.0.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9774ba4a74de5f7b1c1451ed6cd5285a32eddb5cccb8cc655a4e50009e06477f"
+
+[[package]]
+name = "same-file"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502"
+dependencies = [
+ "winapi-util",
+]
+
+[[package]]
+name = "schannel"
+version = "0.1.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "891d81b926048e76efe18581bf793546b4c0eaf8448d72be8de2bbee5fd166e1"
+dependencies = [
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "schemars"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4cd191f9397d57d581cddd31014772520aa448f65ef991055d7f61582c65165f"
+dependencies = [
+ "dyn-clone",
+ "ref-cast",
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "schemars"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a2b42f36aa1cd011945615b92222f6bf73c599a102a300334cd7f8dbeec726cc"
+dependencies = [
+ "dyn-clone",
+ "ref-cast",
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "scopeguard"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
+
+[[package]]
+name = "second-stack"
+version = "0.3.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4904c83c6e51f1b9b08bfa5a86f35a51798e8307186e6f5513852210a219c0bb"
+
+[[package]]
+name = "security-framework"
+version = "2.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "897b2245f0b511c87893af39b033e5ca9cce68824c4d7e7630b5a1d339658d02"
+dependencies = [
+ "bitflags 2.11.0",
+ "core-foundation",
+ "core-foundation-sys",
+ "libc",
+ "security-framework-sys",
+]
+
+[[package]]
+name = "security-framework-sys"
+version = "2.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ce2691df843ecc5d231c0b14ece2acc3efb62c0a398c7e1d875f3983ce020e3"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
+[[package]]
+name = "semver"
+version = "1.0.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d767eb0aabc880b29956c35734170f26ed551a859dbd361d140cdbeca61ab1e2"
+
+[[package]]
+name = "serde"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"
+dependencies = [
+ "serde_core",
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_cbor"
+version = "0.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2bef2ebfde456fb76bbcf9f59315333decc4fda0b2b44b420243c11e0f5ec1f5"
+dependencies = [
+ "half",
+ "serde",
+]
+
+[[package]]
+name = "serde_core"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.149"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "83fc039473c5595ace860d8c4fafa220ff474b3fc6bfdb4293327f1a37e94d86"
+dependencies = [
+ "itoa",
+ "memchr",
+ "serde",
+ "serde_core",
+ "zmij",
+]
+
+[[package]]
+name = "serde_spanned"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8bbf91e5a4d6315eee45e704372590b30e260ee83af6639d64557f51b067776"
+dependencies = [
+ "serde_core",
+]
+
+[[package]]
+name = "serde_with"
+version = "3.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "381b283ce7bc6b476d903296fb59d0d36633652b633b27f64db4fb46dcbfc3b9"
+dependencies = [
+ "base64 0.22.1",
+ "chrono",
+ "hex",
+ "indexmap 1.9.3",
+ "indexmap 2.13.0",
+ "schemars 0.9.0",
+ "schemars 1.2.1",
+ "serde_core",
+ "serde_json",
+ "serde_with_macros",
+ "time",
+]
+
+[[package]]
+name = "serde_with_macros"
+version = "3.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a6d4e30573c8cb306ed6ab1dca8423eec9a463ea0e155f45399455e0368b27e0"
+dependencies = [
+ "darling",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "sha1"
+version = "0.10.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3bf829a2d51ab4a5ddf1352d8470c140cadc8301b2ae1789db023f01cedd6ba"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest",
+]
+
+[[package]]
+name = "sha3"
+version = "0.10.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75872d278a8f37ef87fa0ddbda7802605cb18344497949862c0d4dcb291eba60"
+dependencies = [
+ "digest",
+ "keccak",
+]
+
+[[package]]
+name = "shlex"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
+
+[[package]]
+name = "signal-hook-registry"
+version = "1.4.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c4db69cba1110affc0e9f7bcd48bbf87b3f4fc7c61fc9155afd4c469eb3d6c1b"
+dependencies = [
+ "errno",
+ "libc",
+]
+
+[[package]]
+name = "simd-adler32"
+version = "0.3.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e320a6c5ad31d271ad523dcf3ad13e2767ad8b1cb8f047f75a8aeaf8da139da2"
+
+[[package]]
+name = "similar"
+version = "2.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbbb5d9659141646ae647b42fe094daf6c6192d1620870b449d9557f748b2daa"
+
+[[package]]
+name = "slab"
+version = "0.4.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c790de23124f9ab44544d7ac05d60440adc586479ce501c1d6d7da3cd8c9cf5"
+
+[[package]]
+name = "smallvec"
+version = "1.15.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
+
+[[package]]
+name = "socket2"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "86f4aa3ad99f2088c990dfa82d367e19cb29268ed67c574d10d0a4bfe71f07e0"
+dependencies = [
+ "libc",
+ "windows-sys 0.60.2",
+]
+
+[[package]]
+name = "spacetimedb-bindings-macro"
+version = "2.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "21bfb058d197c94ea1c10186cf561e1d458284029aa17e145de91426645684ac"
+dependencies = [
+ "heck 0.4.1",
+ "humantime",
+ "proc-macro2",
+ "quote",
+ "spacetimedb-primitives",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "spacetimedb-client-api-messages"
+version = "2.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ee3c0fdc3600ee8d79ec12405d5e3da14f3a3fba1d79fcef359e95b1a9c31f0"
+dependencies = [
+ "bytes",
+ "bytestring",
+ "chrono",
+ "derive_more",
+ "enum-as-inner",
+ "serde",
+ "serde_json",
+ "serde_with",
+ "smallvec",
+ "spacetimedb-lib",
+ "spacetimedb-primitives",
+ "spacetimedb-sats",
+ "strum",
+ "thiserror 1.0.69",
+]
+
+[[package]]
+name = "spacetimedb-data-structures"
+version = "2.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "acef437ebc2cfe6722a435548791e6c804161bc60849874f8ebc8ab9521f8821"
+dependencies = [
+ "ahash",
+ "crossbeam-queue",
+ "either",
+ "hashbrown 0.16.1",
+ "nohash-hasher",
+ "smallvec",
+ "thiserror 1.0.69",
+]
+
+[[package]]
+name = "spacetimedb-lib"
+version = "2.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ebd9269f2e04205cedad7bc9ed4e7945b5ba7ff3ba338b9f27d6df809303dcb0"
+dependencies = [
+ "anyhow",
+ "bitflags 2.11.0",
+ "blake3",
+ "chrono",
+ "derive_more",
+ "enum-as-inner",
+ "enum-map",
+ "hex",
+ "itertools 0.12.1",
+ "log",
+ "serde",
+ "spacetimedb-bindings-macro",
+ "spacetimedb-metrics",
+ "spacetimedb-primitives",
+ "spacetimedb-sats",
+ "thiserror 1.0.69",
+]
+
+[[package]]
+name = "spacetimedb-memory-usage"
+version = "2.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff659ce77121badc47ba895e41932cf46553e2698658ce9bbfc0be48f72802d3"
+dependencies = [
+ "decorum",
+ "ethnum",
+]
+
+[[package]]
+name = "spacetimedb-metrics"
+version = "2.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fd823bcc42ea78e4d2fd85945ab7323f228756e86aac49676c99101c3cee987"
+dependencies = [
+ "arrayvec",
+ "itertools 0.12.1",
+ "paste",
+ "prometheus",
+]
+
+[[package]]
+name = "spacetimedb-primitives"
+version = "2.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "824c30dd781b206519447e2b2eed456312a1e9b4ff27781471f75ed2bbd77720"
+dependencies = [
+ "bitflags 2.11.0",
+ "either",
+ "enum-as-inner",
+ "itertools 0.12.1",
+ "nohash-hasher",
+ "spacetimedb-memory-usage",
+]
+
+[[package]]
+name = "spacetimedb-query-builder"
+version = "2.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f566a5c58b2f8a635aa10ee9139d6815511938e36ff6c4719ae5282f6c6dee73"
+dependencies = [
+ "spacetimedb-lib",
+]
+
+[[package]]
+name = "spacetimedb-sats"
+version = "2.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "194d29d4b59ae80ef25547fe2b5ab942452704db68400c799bfc005b8797a487"
+dependencies = [
+ "anyhow",
+ "arrayvec",
+ "bitflags 2.11.0",
+ "bytemuck",
+ "bytes",
+ "bytestring",
+ "chrono",
+ "decorum",
+ "derive_more",
+ "enum-as-inner",
+ "ethnum",
+ "hex",
+ "itertools 0.12.1",
+ "lean_string",
+ "rand",
+ "second-stack",
+ "serde",
+ "sha3",
+ "smallvec",
+ "spacetimedb-bindings-macro",
+ "spacetimedb-memory-usage",
+ "spacetimedb-metrics",
+ "spacetimedb-primitives",
+ "thiserror 1.0.69",
+ "uuid",
+]
+
+[[package]]
+name = "spacetimedb-schema"
+version = "2.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "45d3e526e5cad388a7d8985d6a1d2bc0d3c750039b585859f2a7fc985b0e2221"
+dependencies = [
+ "anyhow",
+ "convert_case 0.6.0",
+ "derive_more",
+ "enum-as-inner",
+ "enum-map",
+ "indexmap 2.13.0",
+ "insta",
+ "itertools 0.12.1",
+ "lazy_static",
+ "lean_string",
+ "petgraph",
+ "serde_json",
+ "smallvec",
+ "spacetimedb-data-structures",
+ "spacetimedb-lib",
+ "spacetimedb-memory-usage",
+ "spacetimedb-primitives",
+ "spacetimedb-sats",
+ "spacetimedb-sql-parser",
+ "termcolor",
+ "thiserror 1.0.69",
+ "unicode-ident",
+ "unicode-normalization",
+]
+
+[[package]]
+name = "spacetimedb-sdk"
+version = "2.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b641053a98ff8fe7f286ad62df42f77c8889baeb364a793056374888d1fbff44"
+dependencies = [
+ "anymap",
+ "base64 0.21.7",
+ "brotli",
+ "bytes",
+ "flate2",
+ "futures",
+ "futures-channel",
+ "home",
+ "http",
+ "log",
+ "native-tls",
+ "once_cell",
+ "prometheus",
+ "rand",
+ "spacetimedb-client-api-messages",
+ "spacetimedb-data-structures",
+ "spacetimedb-lib",
+ "spacetimedb-metrics",
+ "spacetimedb-query-builder",
+ "spacetimedb-sats",
+ "spacetimedb-schema",
+ "thiserror 1.0.69",
+ "tokio",
+ "tokio-tungstenite",
+]
+
+[[package]]
+name = "spacetimedb-sql-parser"
+version = "2.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "985c3f08dff7b2311bdf4dff5f6ed95e9d6c7ac6c65292542dd6a07e7e2b933b"
+dependencies = [
+ "derive_more",
+ "spacetimedb-lib",
+ "sqlparser",
+ "thiserror 1.0.69",
+]
+
+[[package]]
+name = "spacetimedb-vs-doublets"
+version = "0.1.0"
+dependencies = [
+ "criterion",
+ "doublets",
+ "once_cell",
+ "platform-mem",
+ "spacetimedb-sdk",
+]
+
+[[package]]
+name = "sqlparser"
+version = "0.38.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0272b7bb0a225320170c99901b4b5fb3a4384e255a7f2cc228f61e2ba3893e75"
+dependencies = [
+ "log",
+]
+
+[[package]]
+name = "stable_deref_trait"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596"
+
+[[package]]
+name = "strsim"
+version = "0.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
+
+[[package]]
+name = "strum"
+version = "0.25.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "290d54ea6f91c969195bdbcd7442c8c2a2ba87da8bf60a7ee86a235d4bc1e125"
+dependencies = [
+ "strum_macros",
+]
+
+[[package]]
+name = "strum_macros"
+version = "0.25.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "23dc1fa9ac9c169a78ba62f0b841814b7abae11bdd047b9c58f893439e309ea0"
+dependencies = [
+ "heck 0.4.1",
+ "proc-macro2",
+ "quote",
+ "rustversion",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "syn"
+version = "1.0.109"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.117"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "synstructure"
+version = "0.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "tap"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369"
+
+[[package]]
+name = "tempfile"
+version = "3.26.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "82a72c767771b47409d2345987fda8628641887d5466101319899796367354a0"
+dependencies = [
+ "fastrand",
+ "getrandom 0.4.1",
+ "once_cell",
+ "rustix",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "termcolor"
+version = "1.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "06794f8f6c5c898b3275aebefa6b8a1cb24cd2c6c79397ab15774837a0bc5755"
+dependencies = [
+ "winapi-util",
+]
+
+[[package]]
+name = "textwrap"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d326610f408c7a4eb6f51c37c330e496b08506c9457c9d34287ecc38809fb060"
+dependencies = [
+ "unicode-width",
+]
+
+[[package]]
+name = "thiserror"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52"
+dependencies = [
+ "thiserror-impl 1.0.69",
+]
+
+[[package]]
+name = "thiserror"
+version = "2.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4288b5bcbc7920c07a1149a35cf9590a2aa808e0bc1eafaade0b80947865fbc4"
+dependencies = [
+ "thiserror-impl 2.0.18",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "2.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ebc4ee7f67670e9b64d05fa4253e753e016c6c95ff35b89b7941d6b856dec1d5"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "time"
+version = "0.3.47"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "743bd48c283afc0388f9b8827b976905fb217ad9e647fae3a379a9283c4def2c"
+dependencies = [
+ "deranged",
+ "itoa",
+ "num-conv",
+ "powerfmt",
+ "serde_core",
+ "time-core",
+ "time-macros",
+]
+
+[[package]]
+name = "time-core"
+version = "0.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7694e1cfe791f8d31026952abf09c69ca6f6fa4e1a1229e18988f06a04a12dca"
+
+[[package]]
+name = "time-macros"
+version = "0.2.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2e70e4c5a0e0a8a4823ad65dfe1a6930e4f4d756dcd9dd7939022b5e8c501215"
+dependencies = [
+ "num-conv",
+ "time-core",
+]
+
+[[package]]
+name = "tinystr"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42d3e9c45c09de15d06dd8acf5f4e0e399e85927b7f00711024eb7ae10fa4869"
+dependencies = [
+ "displaydoc",
+ "zerovec",
+]
+
+[[package]]
+name = "tinytemplate"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "be4d6b5f19ff7664e8c98d03e2139cb510db9b0a60b55f8e8709b689d939b6bc"
+dependencies = [
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "tinyvec"
+version = "1.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bfa5fdc3bce6191a1dbc8c02d5c8bffcf557bafa17c124c5264a458f1b0613fa"
+dependencies = [
+ "tinyvec_macros",
+]
+
+[[package]]
+name = "tinyvec_macros"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
+
+[[package]]
+name = "tokio"
+version = "1.49.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72a2903cd7736441aac9df9d7688bd0ce48edccaadf181c3b90be801e81d3d86"
+dependencies = [
+ "bytes",
+ "libc",
+ "mio",
+ "parking_lot",
+ "pin-project-lite",
+ "signal-hook-registry",
+ "socket2",
+ "tokio-macros",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "tokio-macros"
+version = "2.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "af407857209536a95c8e56f8231ef2c2e2aff839b22e07a1ffcbc617e9db9fa5"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+]
+
+[[package]]
+name = "tokio-native-tls"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbae76ab933c85776efabc971569dd6119c580d8f5d448769dec1764bf796ef2"
+dependencies = [
+ "native-tls",
+ "tokio",
+]
+
+[[package]]
+name = "tokio-tungstenite"
+version = "0.27.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "489a59b6730eda1b0171fcfda8b121f4bee2b35cba8645ca35c5f7ba3eb736c1"
+dependencies = [
+ "futures-util",
+ "log",
+ "native-tls",
+ "tokio",
+ "tokio-native-tls",
+ "tungstenite",
+]
+
+[[package]]
+name = "toml_datetime"
+version = "0.7.5+spec-1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92e1cfed4a3038bc5a127e35a2d360f145e1f4b971b551a2ba5fd7aedf7e1347"
+dependencies = [
+ "serde_core",
+]
+
+[[package]]
+name = "toml_edit"
+version = "0.23.10+spec-1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "84c8b9f757e028cee9fa244aea147aab2a9ec09d5325a9b01e0a49730c2b5269"
+dependencies = [
+ "indexmap 2.13.0",
+ "serde_core",
+ "serde_spanned",
+ "toml_datetime",
+ "toml_parser",
+ "toml_writer",
+ "winnow",
+]
+
+[[package]]
+name = "toml_parser"
+version = "1.0.9+spec-1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "702d4415e08923e7e1ef96cd5727c0dfed80b4d2fa25db9647fe5eb6f7c5a4c4"
+dependencies = [
+ "winnow",
+]
+
+[[package]]
+name = "toml_writer"
+version = "1.0.6+spec-1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ab16f14aed21ee8bfd8ec22513f7287cd4a91aa92e44edfe2c17ddd004e92607"
+
+[[package]]
+name = "tungstenite"
+version = "0.27.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eadc29d668c91fcc564941132e17b28a7ceb2f3ebf0b9dae3e03fd7a6748eb0d"
+dependencies = [
+ "bytes",
+ "data-encoding",
+ "http",
+ "httparse",
+ "log",
+ "native-tls",
+ "rand",
+ "sha1",
+ "thiserror 2.0.18",
+ "url",
+ "utf-8",
+]
+
+[[package]]
+name = "typenum"
+version = "1.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "562d481066bde0658276a35467c4af00bdc6ee726305698a55b86e61d7ad82bb"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
+
+[[package]]
+name = "unicode-normalization"
+version = "0.1.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5fd4f6878c9cb28d874b009da9e8d183b5abc80117c40bbd187a1fde336be6e8"
+dependencies = [
+ "tinyvec",
+]
+
+[[package]]
+name = "unicode-segmentation"
+version = "1.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f6ccf251212114b54433ec949fd6a7841275f9ada20dddd2f29e9ceea4501493"
+
+[[package]]
+name = "unicode-width"
+version = "0.1.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7dd6e30e90baa6f72411720665d41d89b9a3d039dc45b8faea1ddd07f617f6af"
+
+[[package]]
+name = "unicode-xid"
+version = "0.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"
+
+[[package]]
+name = "url"
+version = "2.5.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff67a8a4397373c3ef660812acab3268222035010ab8680ec4215f38ba3d0eed"
+dependencies = [
+ "form_urlencoded",
+ "idna",
+ "percent-encoding",
+ "serde",
+]
+
+[[package]]
+name = "utf-8"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09cc8ee72d2a9becf2f2febe0205bbed8fc6615b7cb429ad062dc7b7ddd036a9"
+
+[[package]]
+name = "utf8_iter"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be"
+
+[[package]]
+name = "uuid"
+version = "1.21.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b672338555252d43fd2240c714dc444b8c6fb0a5c5335e65a07bba7742735ddb"
+dependencies = [
+ "getrandom 0.4.1",
+]
+
+[[package]]
+name = "vcpkg"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
+
+[[package]]
+name = "version_check"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
+
+[[package]]
+name = "walkdir"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b"
+dependencies = [
+ "same-file",
+ "winapi-util",
+]
+
+[[package]]
+name = "wasi"
+version = "0.11.1+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b"
+
+[[package]]
+name = "wasip2"
+version = "1.0.2+wasi-0.2.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9517f9239f02c069db75e65f174b3da828fe5f5b945c4dd26bd25d89c03ebcf5"
+dependencies = [
+ "wit-bindgen",
+]
+
+[[package]]
+name = "wasip3"
+version = "0.4.0+wasi-0.3.0-rc-2026-01-06"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5428f8bf88ea5ddc08faddef2ac4a67e390b88186c703ce6dbd955e1c145aca5"
+dependencies = [
+ "wit-bindgen",
+]
+
+[[package]]
+name = "wasm-bindgen"
+version = "0.2.113"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "60722a937f594b7fde9adb894d7c092fc1bb6612897c46368d18e7a20208eff2"
+dependencies = [
+ "cfg-if",
+ "once_cell",
+ "rustversion",
+ "wasm-bindgen-macro",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-macro"
+version = "0.2.113"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fac8c6395094b6b91c4af293f4c79371c163f9a6f56184d2c9a85f5a95f3950"
+dependencies = [
+ "quote",
+ "wasm-bindgen-macro-support",
+]
+
+[[package]]
+name = "wasm-bindgen-macro-support"
+version = "0.2.113"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ab3fabce6159dc20728033842636887e4877688ae94382766e00b180abac9d60"
+dependencies = [
+ "bumpalo",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-shared"
+version = "0.2.113"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "de0e091bdb824da87dc01d967388880d017a0a9bc4f3bdc0d86ee9f9336e3bb5"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "wasm-encoder"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "990065f2fe63003fe337b932cfb5e3b80e0b4d0f5ff650e6985b1048f62c8319"
+dependencies = [
+ "leb128fmt",
+ "wasmparser",
+]
 
 [[package]]
-name = "platform-data"
-version = "0.1.0-beta.3"
-source = "git+https://github.com/linksplatform/doublets-rs.git?rev=5522d91c536654934b7181829f6efb570fb8bb44#5522d91c536654934b7181829f6efb570fb8bb44"
+name = "wasm-metadata"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bb0e353e6a2fbdc176932bbaab493762eb1255a7900fe0fea1a2f96c296cc909"
 dependencies = [
- "beef",
- "funty",
- "thiserror",
+ "anyhow",
+ "indexmap 2.13.0",
+ "wasm-encoder",
+ "wasmparser",
 ]
 
 [[package]]
-name = "platform-mem"
-version = "0.1.0-pre+beta.2"
-source = "git+https://github.com/linksplatform/doublets-rs.git?rev=5522d91c536654934b7181829f6efb570fb8bb44#5522d91c536654934b7181829f6efb570fb8bb44"
+name = "wasmparser"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "47b807c72e1bac69382b3a6fb3dbe8ea4c0ed87ff5629b8685ae6b9a611028fe"
 dependencies = [
- "delegate",
- "memmap2",
- "tap",
- "tempfile",
- "thiserror",
+ "bitflags 2.11.0",
+ "hashbrown 0.15.5",
+ "indexmap 2.13.0",
+ "semver",
 ]
 
 [[package]]
-name = "platform-trees"
-version = "0.1.0-beta.1"
-source = "git+https://github.com/linksplatform/doublets-rs.git?rev=5522d91c536654934b7181829f6efb570fb8bb44#5522d91c536654934b7181829f6efb570fb8bb44"
+name = "web-sys"
+version = "0.3.90"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "705eceb4ce901230f8625bd1d665128056ccbe4b7408faa625eec1ba80f59a97"
 dependencies = [
- "funty",
- "platform-data",
+ "js-sys",
+ "wasm-bindgen",
 ]
 
 [[package]]
-name = "plotters"
-version = "0.3.6"
+name = "winapi"
+version = "0.3.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a15b6eccb8484002195a3e44fe65a4ce8e93a625797a063735536fd59cb01cf3"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
 dependencies = [
- "num-traits",
- "plotters-backend",
- "plotters-svg",
- "wasm-bindgen",
- "web-sys",
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
 ]
 
 [[package]]
-name = "plotters-backend"
-version = "0.3.7"
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "df42e13c12958a16b3f7f4386b9ab1f3e7933914ecea48da7139435263a4172a"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
 
 [[package]]
-name = "plotters-svg"
-version = "0.3.7"
+name = "winapi-util"
+version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "51bae2ac328883f7acdfea3d66a7c35751187f870bc81f94563733a154d7a670"
+checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
 dependencies = [
- "plotters-backend",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
-name = "proc-macro2"
-version = "1.0.36"
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
+
+[[package]]
+name = "windows-core"
+version = "0.62.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c7342d5883fbccae1cc37a2353b09c87c9b0f3afd73f5fb9bba687a1f733b029"
+checksum = "b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb"
 dependencies = [
- "unicode-xid",
+ "windows-implement",
+ "windows-interface",
+ "windows-link",
+ "windows-result",
+ "windows-strings",
 ]
 
 [[package]]
-name = "quote"
-version = "1.0.15"
+name = "windows-implement"
+version = "0.60.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "864d3e96a899863136fc6e99f3d7cae289dafe43bf2c5ac19b70df7210c0a145"
+checksum = "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf"
 dependencies = [
  "proc-macro2",
+ "quote",
+ "syn 2.0.117",
 ]
 
 [[package]]
-name = "rayon"
-version = "1.6.1"
+name = "windows-interface"
+version = "0.59.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6db3a213adf02b3bcfd2d3846bb41cb22857d131789e01df434fb7e7bc0759b7"
+checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358"
 dependencies = [
- "either",
- "rayon-core",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
 ]
 
 [[package]]
-name = "rayon-core"
-version = "1.10.2"
+name = "windows-link"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
+
+[[package]]
+name = "windows-result"
+version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "356a0625f1954f730c0201cdab48611198dc6ce21f4acff55089b5a78e6e835b"
+checksum = "7781fa89eaf60850ac3d2da7af8e5242a5ea78d1a11c49bf2910bb5a73853eb5"
 dependencies = [
- "crossbeam-channel",
- "crossbeam-deque",
- "crossbeam-utils",
- "num_cpus",
+ "windows-link",
 ]
 
 [[package]]
-name = "redox_syscall"
-version = "0.2.16"
+name = "windows-strings"
+version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fb5a58c1855b4b6819d59012155603f0b22ad30cad752600aadfcb695265519a"
+checksum = "7837d08f69c77cf6b07689544538e017c1bfcf57e34b4c0ff58e6c2cd3b37091"
 dependencies = [
- "bitflags",
+ "windows-link",
 ]
 
 [[package]]
-name = "regex"
-version = "1.7.1"
+name = "windows-sys"
+version = "0.59.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "48aaa5748ba571fb95cd2c85c09f629215d3a6ece942baa100950af03a34f733"
+checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
 dependencies = [
- "aho-corasick",
- "memchr",
- "regex-syntax",
+ "windows-targets 0.52.6",
 ]
 
 [[package]]
-name = "regex-automata"
-version = "0.1.10"
+name = "windows-sys"
+version = "0.60.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c230d73fb8d8c1b9c0b3135c5142a8acee3a0558fb8db5cf1cb65f8d7862132"
+checksum = "f2f500e4d28234f72040990ec9d39e3a6b950f9f22d3dba18416c35882612bcb"
 dependencies = [
- "regex-syntax",
+ "windows-targets 0.53.5",
 ]
 
 [[package]]
-name = "regex-syntax"
-version = "0.6.28"
+name = "windows-sys"
+version = "0.61.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "456c603be3e8d448b072f410900c09faf164fbce2d480456f50eea6e25f9c848"
+checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"
+dependencies = [
+ "windows-link",
+]
 
 [[package]]
-name = "remove_dir_all"
-version = "0.5.3"
+name = "windows-targets"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3acd125665422973a33ac9d3dd2df85edad0f4ae9b00dafb1a05e43a9f5ef8e7"
+checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
 dependencies = [
- "winapi",
+ "windows_aarch64_gnullvm 0.52.6",
+ "windows_aarch64_msvc 0.52.6",
+ "windows_i686_gnu 0.52.6",
+ "windows_i686_gnullvm 0.52.6",
+ "windows_i686_msvc 0.52.6",
+ "windows_x86_64_gnu 0.52.6",
+ "windows_x86_64_gnullvm 0.52.6",
+ "windows_x86_64_msvc 0.52.6",
 ]
 
 [[package]]
-name = "rusqlite"
-version = "0.27.0"
+name = "windows-targets"
+version = "0.53.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "85127183a999f7db96d1a976a309eebbfb6ea3b0b400ddd8340190129de6eb7a"
+checksum = "4945f9f551b88e0d65f3db0bc25c33b8acea4d9e41163edf90dcd0b19f9069f3"
 dependencies = [
- "bitflags",
- "fallible-iterator",
- "fallible-streaming-iterator",
- "hashlink",
- "libsqlite3-sys",
- "memchr",
- "smallvec",
+ "windows-link",
+ "windows_aarch64_gnullvm 0.53.1",
+ "windows_aarch64_msvc 0.53.1",
+ "windows_i686_gnu 0.53.1",
+ "windows_i686_gnullvm 0.53.1",
+ "windows_i686_msvc 0.53.1",
+ "windows_x86_64_gnu 0.53.1",
+ "windows_x86_64_gnullvm 0.53.1",
+ "windows_x86_64_msvc 0.53.1",
 ]
 
 [[package]]
-name = "ryu"
-version = "1.0.12"
+name = "windows_aarch64_gnullvm"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b4b9743ed687d4b4bcedf9ff5eaa7398495ae14e61cba0a295704edbc7decde"
+checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
 
 [[package]]
-name = "same-file"
-version = "1.0.6"
+name = "windows_aarch64_gnullvm"
+version = "0.53.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502"
-dependencies = [
- "winapi-util",
-]
+checksum = "a9d8416fa8b42f5c947f8482c43e7d89e73a173cead56d044f6a56104a6d1b53"
 
 [[package]]
-name = "serde"
-version = "1.0.185"
+name = "windows_aarch64_msvc"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "be9b6f69f1dfd54c3b568ffa45c310d6973a5e5148fd40cf515acaf38cf5bc31"
+checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
 
 [[package]]
-name = "serde_cbor"
-version = "0.11.2"
+name = "windows_aarch64_msvc"
+version = "0.53.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2bef2ebfde456fb76bbcf9f59315333decc4fda0b2b44b420243c11e0f5ec1f5"
-dependencies = [
- "half",
- "serde",
-]
+checksum = "b9d782e804c2f632e395708e99a94275910eb9100b2114651e04744e9b125006"
 
 [[package]]
-name = "serde_derive"
-version = "1.0.136"
+name = "windows_i686_gnu"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "08597e7152fcd306f41838ed3e37be9eaeed2b61c42e2117266a554fab4662f9"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
+checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
 
 [[package]]
-name = "serde_json"
-version = "1.0.109"
+name = "windows_i686_gnu"
+version = "0.53.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cb0652c533506ad7a2e353cce269330d6afd8bdfb6d75e0ace5b35aacbd7b9e9"
-dependencies = [
- "itoa",
- "ryu",
- "serde",
-]
+checksum = "960e6da069d81e09becb0ca57a65220ddff016ff2d6af6a223cf372a506593a3"
 
 [[package]]
-name = "shlex"
-version = "1.3.0"
+name = "windows_i686_gnullvm"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
+checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
 
 [[package]]
-name = "smallvec"
-version = "1.15.1"
+name = "windows_i686_gnullvm"
+version = "0.53.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
+checksum = "fa7359d10048f68ab8b09fa71c3daccfb0e9b559aed648a8f95469c27057180c"
 
 [[package]]
-name = "spacetimedb-vs-doublets"
-version = "0.1.0"
-dependencies = [
- "bumpalo",
- "criterion",
- "doublets",
- "fastrand",
- "getrandom",
- "itoa",
- "once_cell",
- "proc-macro2",
- "quote",
- "rayon",
- "rayon-core",
- "regex",
- "regex-automata",
- "regex-syntax",
- "rusqlite",
- "ryu",
- "same-file",
- "serde_derive",
- "syn",
- "tempfile",
- "unicode-width",
- "walkdir",
- "winapi-util",
-]
+name = "windows_i686_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
 
 [[package]]
-name = "syn"
-version = "1.0.86"
+name = "windows_i686_msvc"
+version = "0.53.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8a65b3f4ffa0092e9887669db0eae07941f023991ab58ea44da8fe8e2d511c6b"
-dependencies = [
- "proc-macro2",
- "quote",
- "unicode-xid",
-]
+checksum = "1e7ac75179f18232fe9c285163565a57ef8d3c89254a30685b57d83a38d326c2"
 
 [[package]]
-name = "tap"
-version = "1.0.1"
+name = "windows_x86_64_gnu"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369"
+checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
 
 [[package]]
-name = "tempfile"
-version = "3.3.0"
+name = "windows_x86_64_gnu"
+version = "0.53.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5cdb1ef4eaeeaddc8fbd371e5017057064af0911902ef36b39801f67cc6d79e4"
-dependencies = [
- "cfg-if",
- "fastrand",
- "libc",
- "redox_syscall",
- "remove_dir_all",
- "winapi",
-]
+checksum = "9c3842cdd74a865a8066ab39c8a7a473c0778a3f29370b5fd6b4b9aa7df4a499"
 
 [[package]]
-name = "textwrap"
-version = "0.11.0"
+name = "windows_x86_64_gnullvm"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d326610f408c7a4eb6f51c37c330e496b08506c9457c9d34287ecc38809fb060"
-dependencies = [
- "unicode-width",
-]
+checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
 
 [[package]]
-name = "thiserror"
-version = "1.0.39"
+name = "windows_x86_64_gnullvm"
+version = "0.53.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a5ab016db510546d856297882807df8da66a16fb8c4101cb8b30054b0d5b2d9c"
-dependencies = [
- "thiserror-impl",
-]
+checksum = "0ffa179e2d07eee8ad8f57493436566c7cc30ac536a3379fdf008f47f6bb7ae1"
 
 [[package]]
-name = "thiserror-impl"
-version = "1.0.39"
+name = "windows_x86_64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d6bbff5f0aada427a1e5a6da5f1f98158182f26556f345ac9e04d36d0ebed650"
+
+[[package]]
+name = "winnow"
+version = "0.7.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5420d42e90af0c38c3290abcca25b9b3bdf379fc9f55c528f53a269d9c9a267e"
+checksum = "5a5364e9d77fcdeeaa6062ced926ee3381faa2ee02d3eb83a5c27a8825540829"
 dependencies = [
- "proc-macro2",
- "quote",
- "syn",
+ "memchr",
 ]
 
 [[package]]
-name = "tinytemplate"
-version = "1.2.1"
+name = "wit-bindgen"
+version = "0.51.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "be4d6b5f19ff7664e8c98d03e2139cb510db9b0a60b55f8e8709b689d939b6bc"
+checksum = "d7249219f66ced02969388cf2bb044a09756a083d0fab1e566056b04d9fbcaa5"
 dependencies = [
- "serde",
- "serde_json",
+ "wit-bindgen-rust-macro",
 ]
 
 [[package]]
-name = "unicode-width"
-version = "0.1.10"
+name = "wit-bindgen-core"
+version = "0.51.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c0edd1e5b14653f783770bce4a4dabb4a5108a5370a5f5d8cfe8710c361f6c8b"
+checksum = "ea61de684c3ea68cb082b7a88508a8b27fcc8b797d738bfc99a82facf1d752dc"
+dependencies = [
+ "anyhow",
+ "heck 0.5.0",
+ "wit-parser",
+]
 
 [[package]]
-name = "unicode-xid"
-version = "0.2.6"
+name = "wit-bindgen-rust"
+version = "0.51.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"
+checksum = "b7c566e0f4b284dd6561c786d9cb0142da491f46a9fbed79ea69cdad5db17f21"
+dependencies = [
+ "anyhow",
+ "heck 0.5.0",
+ "indexmap 2.13.0",
+ "prettyplease",
+ "syn 2.0.117",
+ "wasm-metadata",
+ "wit-bindgen-core",
+ "wit-component",
+]
 
 [[package]]
-name = "vcpkg"
-version = "0.2.15"
+name = "wit-bindgen-rust-macro"
+version = "0.51.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
+checksum = "0c0f9bfd77e6a48eccf51359e3ae77140a7f50b1e2ebfe62422d8afdaffab17a"
+dependencies = [
+ "anyhow",
+ "prettyplease",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+ "wit-bindgen-core",
+ "wit-bindgen-rust",
+]
 
 [[package]]
-name = "version_check"
-version = "0.9.5"
+name = "wit-component"
+version = "0.244.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
+checksum = "9d66ea20e9553b30172b5e831994e35fbde2d165325bec84fc43dbf6f4eb9cb2"
+dependencies = [
+ "anyhow",
+ "bitflags 2.11.0",
+ "indexmap 2.13.0",
+ "log",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "wasm-encoder",
+ "wasm-metadata",
+ "wasmparser",
+ "wit-parser",
+]
 
 [[package]]
-name = "walkdir"
-version = "2.3.2"
+name = "wit-parser"
+version = "0.244.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "808cf2735cd4b6866113f648b791c6adc5714537bc222d9347bb203386ffda56"
+checksum = "ecc8ac4bc1dc3381b7f59c34f00b67e18f910c2c0f50015669dde7def656a736"
 dependencies = [
- "same-file",
- "winapi",
- "winapi-util",
+ "anyhow",
+ "id-arena",
+ "indexmap 2.13.0",
+ "log",
+ "semver",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "unicode-xid",
+ "wasmparser",
 ]
 
 [[package]]
-name = "wasi"
-version = "0.11.1+wasi-snapshot-preview1"
+name = "writeable"
+version = "0.6.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b"
+checksum = "9edde0db4769d2dc68579893f2306b26c6ecfbe0ef499b013d731b7b9247e0b9"
 
 [[package]]
-name = "wasm-bindgen"
-version = "0.2.84"
+name = "yoke"
+version = "0.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "31f8dcbc21f30d9b8f2ea926ecb58f6b91192c17e9d33594b3df58b2007ca53b"
+checksum = "72d6e5c6afb84d73944e5cedb052c4680d5657337201555f9f2a16b7406d4954"
 dependencies = [
- "cfg-if",
- "wasm-bindgen-macro",
+ "stable_deref_trait",
+ "yoke-derive",
+ "zerofrom",
 ]
 
 [[package]]
-name = "wasm-bindgen-backend"
-version = "0.2.84"
+name = "yoke-derive"
+version = "0.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "95ce90fd5bcc06af55a641a86428ee4229e44e07033963a2290a8e241607ccb9"
+checksum = "b659052874eb698efe5b9e8cf382204678a0086ebf46982b79d6ca3182927e5d"
 dependencies = [
- "bumpalo",
- "log",
- "once_cell",
  "proc-macro2",
  "quote",
- "syn",
- "wasm-bindgen-shared",
+ "syn 2.0.117",
+ "synstructure",
 ]
 
 [[package]]
-name = "wasm-bindgen-macro"
-version = "0.2.84"
+name = "zerocopy"
+version = "0.8.39"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4c21f77c0bedc37fd5dc21f897894a5ca01e7bb159884559461862ae90c0b4c5"
+checksum = "db6d35d663eadb6c932438e763b262fe1a70987f9ae936e60158176d710cae4a"
 dependencies = [
- "quote",
- "wasm-bindgen-macro-support",
+ "zerocopy-derive",
 ]
 
 [[package]]
-name = "wasm-bindgen-macro-support"
-version = "0.2.84"
+name = "zerocopy-derive"
+version = "0.8.39"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2aff81306fcac3c7515ad4e177f521b5c9a15f2b08f4e32d823066102f35a5f6"
+checksum = "4122cd3169e94605190e77839c9a40d40ed048d305bfdc146e7df40ab0f3e517"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn",
- "wasm-bindgen-backend",
- "wasm-bindgen-shared",
+ "syn 2.0.117",
 ]
 
 [[package]]
-name = "wasm-bindgen-shared"
-version = "0.2.84"
+name = "zerofrom"
+version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0046fef7e28c3804e5e38bfa31ea2a0f73905319b677e57ebe37e49358989b5d"
+checksum = "50cc42e0333e05660c3587f3bf9d0478688e15d870fab3346451ce7f8c9fbea5"
+dependencies = [
+ "zerofrom-derive",
+]
 
 [[package]]
-name = "web-sys"
-version = "0.3.61"
+name = "zerofrom-derive"
+version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e33b99f4b23ba3eec1a53ac264e35a755f00e966e0065077d6027c0f575b0b97"
+checksum = "d71e5d6e06ab090c67b5e44993ec16b72dcbaabc526db883a360057678b48502"
 dependencies = [
- "js-sys",
- "wasm-bindgen",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
+ "synstructure",
 ]
 
 [[package]]
-name = "winapi"
-version = "0.3.9"
+name = "zerotrie"
+version = "0.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+checksum = "2a59c17a5562d507e4b54960e8569ebee33bee890c70aa3fe7b97e85a9fd7851"
 dependencies = [
- "winapi-i686-pc-windows-gnu",
- "winapi-x86_64-pc-windows-gnu",
+ "displaydoc",
+ "yoke",
+ "zerofrom",
 ]
 
 [[package]]
-name = "winapi-i686-pc-windows-gnu"
-version = "0.4.0"
+name = "zerovec"
+version = "0.11.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+checksum = "6c28719294829477f525be0186d13efa9a3c602f7ec202ca9e353d310fb9a002"
+dependencies = [
+ "yoke",
+ "zerofrom",
+ "zerovec-derive",
+]
 
 [[package]]
-name = "winapi-util"
-version = "0.1.5"
+name = "zerovec-derive"
+version = "0.11.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "70ec6ce85bb158151cae5e5c87f95a8e97d2c0c4b001223f33a334e3ce5de178"
+checksum = "eadce39539ca5cb3985590102671f2567e659fca9666581ad3411d59207951f3"
 dependencies = [
- "winapi",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
 ]
 
 [[package]]
-name = "winapi-x86_64-pc-windows-gnu"
-version = "0.4.0"
+name = "zmij"
+version = "1.0.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
+checksum = "b8848ee67ecc8aedbaf3e4122217aff892639231befc6a1b58d29fff4c2cabaa"
diff --git a/rust/Cargo.toml b/rust/Cargo.toml
index dadead6..86c6254 100644
--- a/rust/Cargo.toml
+++ b/rust/Cargo.toml
@@ -10,34 +10,23 @@ name = "bench"
 harness = false
 
 [dependencies]
-rusqlite = { version = "=0.27.0", features = ["bundled"] }
-doublets = { git = "https://github.com/linksplatform/doublets-rs.git", rev = "5522d91c536654934b7181829f6efb570fb8bb44" }
+# SpacetimeDB 2.0 official Rust client SDK.
+spacetimedb-sdk = "2"
+# Use patched doublets that is compatible with modern nightly (>= 1.93.0).
+# The pinned git revision uses removed nightly features (generators, const_trait_impl,
+# const_deref, etc.) incompatible with Rust >= 1.80.0. The local patch:
+# - Removes unused #![feature(generators)] from doublets/src/lib.rs
+# - Patches dev-deps/data-rs to use non-const fn instead of removed ~const syntax
+# - Patches dev-deps/mem-rs to remove removed const feature flags
+doublets = { path = "doublets-patched/doublets" }
+# platform-mem is the memory abstraction layer used by doublets; we depend on it
+# directly to access FileMapped for file-backed (non-volatile) doublets stores.
+platform-mem = { path = "doublets-patched/dev-deps/mem-rs", package = "platform-mem" }
 once_cell = "1.14"
 
 [dev-dependencies]
 criterion = { version = "=0.3.6", default-features = false }
 
-# Pin dependencies for compatibility with nightly-2022-08-22 (rustc 1.65)
-serde_derive = "=1.0.136"
-proc-macro2 = "=1.0.36"
-quote = "=1.0.15"
-syn = "=1.0.86"
-bumpalo = "=3.11.1"
-rayon = "=1.6.1"
-rayon-core = "=1.10.2"
-itoa = "=1.0.5"
-ryu = "=1.0.12"
-unicode-width = "=0.1.10"
-tempfile = "=3.3.0"
-fastrand = "=1.8.0"
-getrandom = "=0.2.8"
-winapi-util = "=0.1.5"
-walkdir = "=2.3.2"
-same-file = "=1.0.6"
-regex = "=1.7.1"
-regex-automata = "=0.1.10"
-regex-syntax = "=0.6.28"
-
 [profile.release]
 lto = true
 codegen-units = 1
diff --git a/rust/benches/bench.rs b/rust/benches/bench.rs
index a30aed2..4792ff0 100644
--- a/rust/benches/bench.rs
+++ b/rust/benches/bench.rs
@@ -1,7 +1,14 @@
 //! SpacetimeDB vs Doublets benchmark suite.
 //!
 //! Runs criterion benchmarks for basic CRUD operations with links,
-//! comparing SpacetimeDB's SQLite backend against Doublets in-memory stores.
+//! comparing SpacetimeDB 2.0 (via official `spacetimedb-sdk`) against Doublets in-memory
+//! and file-backed stores.
+//!
+//! Requires a running SpacetimeDB server with the links module published:
+//! ```bash
+//! spacetime start &
+//! spacetime publish --project-path spacetime-module benchmark-links
+//! ```
 //!
 //! Run benchmarks:
 //! ```bash
@@ -11,14 +18,16 @@
 //! Configure scale via environment variables:
 //! - `BENCHMARK_LINK_COUNT` — links to create/update/delete per iteration (default: 1000)
 //! - `BACKGROUND_LINK_COUNT` — pre-populated links for realistic DB state (default: 3000)
+//! - `SPACETIMEDB_URI` — SpacetimeDB server URI (default: `http://localhost:3000`)
+//! - `SPACETIMEDB_DB` — database name (default: `benchmark-links`)
 
 #![feature(allocator_api)]
 
 use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
 use spacetimedb_vs_doublets::{
     benched::{
-        Benched, DoubletsSplitVolatileBenched, DoubletsUnitedVolatileBenched,
-        SpacetimeDbMemoryBenched,
+        Benched, DoubletsSplitNonVolatileBenched, DoubletsSplitVolatileBenched,
+        DoubletsUnitedNonVolatileBenched, DoubletsUnitedVolatileBenched, SpacetimeDbBenched,
     },
     Links, BACKGROUND_LINK_COUNT, BENCHMARK_LINK_COUNT,
 };
@@ -40,9 +49,9 @@ macro_rules! setup_background {
 
 fn spacetimedb_create(c: &mut Criterion) {
     let count = *BENCHMARK_LINK_COUNT;
-    let mut benched = SpacetimeDbMemoryBenched::setup(());
+    let mut benched = SpacetimeDbBenched::setup(());
     c.bench_with_input(
-        BenchmarkId::new("create/SpacetimeDB_Memory", count),
+        BenchmarkId::new("create/SpacetimeDB", count),
         &count,
         |b, &n| {
             b.iter_custom(|iters| {
@@ -110,13 +119,66 @@ fn doublets_split_create(c: &mut Criterion) {
     );
 }
 
+fn doublets_united_non_volatile_create(c: &mut Criterion) {
+    let count = *BENCHMARK_LINK_COUNT;
+    let mut benched = DoubletsUnitedNonVolatileBenched::setup(
+        "/tmp/bench_united_non_volatile_create.links".to_string(),
+    );
+    c.bench_with_input(
+        BenchmarkId::new("create/Doublets_United_NonVolatile", count),
+        &count,
+        |b, &n| {
+            b.iter_custom(|iters| {
+                let mut total = Duration::ZERO;
+                for _ in 0..iters {
+                    let mut fork = Benched::fork(&mut benched);
+                    setup_background!(fork);
+                    let start = Instant::now();
+                    for _ in 0..n {
+                        fork.create_point();
+                    }
+                    total += start.elapsed();
+                }
+                total
+            });
+        },
+    );
+}
+
+fn doublets_split_non_volatile_create(c: &mut Criterion) {
+    let count = *BENCHMARK_LINK_COUNT;
+    let mut benched = DoubletsSplitNonVolatileBenched::setup((
+        "/tmp/bench_split_non_volatile_create_data.links".to_string(),
+        "/tmp/bench_split_non_volatile_create_index.links".to_string(),
+    ));
+    c.bench_with_input(
+        BenchmarkId::new("create/Doublets_Split_NonVolatile", count),
+        &count,
+        |b, &n| {
+            b.iter_custom(|iters| {
+                let mut total = Duration::ZERO;
+                for _ in 0..iters {
+                    let mut fork = Benched::fork(&mut benched);
+                    setup_background!(fork);
+                    let start = Instant::now();
+                    for _ in 0..n {
+                        fork.create_point();
+                    }
+                    total += start.elapsed();
+                }
+                total
+            });
+        },
+    );
+}
+
 // ===================== DELETE =====================
 
 fn spacetimedb_delete(c: &mut Criterion) {
     let count = *BENCHMARK_LINK_COUNT;
-    let mut benched = SpacetimeDbMemoryBenched::setup(());
+    let mut benched = SpacetimeDbBenched::setup(());
     c.bench_with_input(
-        BenchmarkId::new("delete/SpacetimeDB_Memory", count),
+        BenchmarkId::new("delete/SpacetimeDB", count),
         &count,
         |b, &n| {
             b.iter_custom(|iters| {
@@ -187,13 +249,68 @@ fn doublets_split_delete(c: &mut Criterion) {
     );
 }
 
+fn doublets_united_non_volatile_delete(c: &mut Criterion) {
+    let count = *BENCHMARK_LINK_COUNT;
+    let mut benched = DoubletsUnitedNonVolatileBenched::setup(
+        "/tmp/bench_united_non_volatile_delete.links".to_string(),
+    );
+    c.bench_with_input(
+        BenchmarkId::new("delete/Doublets_United_NonVolatile", count),
+        &count,
+        |b, &n| {
+            b.iter_custom(|iters| {
+                let mut total = Duration::ZERO;
+                for _ in 0..iters {
+                    let mut fork = Benched::fork(&mut benched);
+                    setup_background!(fork);
+                    let ids: Vec<u64> = (0..n).map(|_| fork.create_point()).collect();
+                    let start = Instant::now();
+                    for id in ids {
+                        fork.delete(id);
+                    }
+                    total += start.elapsed();
+                }
+                total
+            });
+        },
+    );
+}
+
+fn doublets_split_non_volatile_delete(c: &mut Criterion) {
+    let count = *BENCHMARK_LINK_COUNT;
+    let mut benched = DoubletsSplitNonVolatileBenched::setup((
+        "/tmp/bench_split_non_volatile_delete_data.links".to_string(),
+        "/tmp/bench_split_non_volatile_delete_index.links".to_string(),
+    ));
+    c.bench_with_input(
+        BenchmarkId::new("delete/Doublets_Split_NonVolatile", count),
+        &count,
+        |b, &n| {
+            b.iter_custom(|iters| {
+                let mut total = Duration::ZERO;
+                for _ in 0..iters {
+                    let mut fork = Benched::fork(&mut benched);
+                    setup_background!(fork);
+                    let ids: Vec<u64> = (0..n).map(|_| fork.create_point()).collect();
+                    let start = Instant::now();
+                    for id in ids {
+                        fork.delete(id);
+                    }
+                    total += start.elapsed();
+                }
+                total
+            });
+        },
+    );
+}
+
 // ===================== UPDATE =====================
 
 fn spacetimedb_update(c: &mut Criterion) {
     let count = *BENCHMARK_LINK_COUNT;
-    let mut benched = SpacetimeDbMemoryBenched::setup(());
+    let mut benched = SpacetimeDbBenched::setup(());
     c.bench_with_input(
-        BenchmarkId::new("update/SpacetimeDB_Memory", count),
+        BenchmarkId::new("update/SpacetimeDB", count),
         &count,
         |b, &n| {
             b.iter_custom(|iters| {
@@ -273,13 +390,74 @@ fn doublets_split_update(c: &mut Criterion) {
     );
 }
 
+fn doublets_united_non_volatile_update(c: &mut Criterion) {
+    let count = *BENCHMARK_LINK_COUNT;
+    let mut benched = DoubletsUnitedNonVolatileBenched::setup(
+        "/tmp/bench_united_non_volatile_update.links".to_string(),
+    );
+    c.bench_with_input(
+        BenchmarkId::new("update/Doublets_United_NonVolatile", count),
+        &count,
+        |b, &n| {
+            b.iter_custom(|iters| {
+                let mut total = Duration::ZERO;
+                for _ in 0..iters {
+                    let mut fork = Benched::fork(&mut benched);
+                    setup_background!(fork);
+                    let ids: Vec<u64> = (0..n).map(|_| fork.create_point()).collect();
+                    let start = Instant::now();
+                    for &id in &ids {
+                        fork.update(id, 0, 0);
+                    }
+                    for &id in &ids {
+                        fork.update(id, id, id);
+                    }
+                    total += start.elapsed();
+                }
+                total
+            });
+        },
+    );
+}
+
+fn doublets_split_non_volatile_update(c: &mut Criterion) {
+    let count = *BENCHMARK_LINK_COUNT;
+    let mut benched = DoubletsSplitNonVolatileBenched::setup((
+        "/tmp/bench_split_non_volatile_update_data.links".to_string(),
+        "/tmp/bench_split_non_volatile_update_index.links".to_string(),
+    ));
+    c.bench_with_input(
+        BenchmarkId::new("update/Doublets_Split_NonVolatile", count),
+        &count,
+        |b, &n| {
+            b.iter_custom(|iters| {
+                let mut total = Duration::ZERO;
+                for _ in 0..iters {
+                    let mut fork = Benched::fork(&mut benched);
+                    setup_background!(fork);
+                    let ids: Vec<u64> = (0..n).map(|_| fork.create_point()).collect();
+                    let start = Instant::now();
+                    for &id in &ids {
+                        fork.update(id, 0, 0);
+                    }
+                    for &id in &ids {
+                        fork.update(id, id, id);
+                    }
+                    total += start.elapsed();
+                }
+                total
+            });
+        },
+    );
+}
+
 // ===================== QUERY ALL =====================
 
 fn spacetimedb_query_all(c: &mut Criterion) {
     let count = *BENCHMARK_LINK_COUNT;
-    let mut benched = SpacetimeDbMemoryBenched::setup(());
+    let mut benched = SpacetimeDbBenched::setup(());
     c.bench_with_input(
-        BenchmarkId::new("query_all/SpacetimeDB_Memory", count),
+        BenchmarkId::new("query_all/SpacetimeDB", count),
         &count,
         |b, &n| {
             b.iter_custom(|iters| {
@@ -350,13 +528,68 @@ fn doublets_split_query_all(c: &mut Criterion) {
     );
 }
 
+fn doublets_united_non_volatile_query_all(c: &mut Criterion) {
+    let count = *BENCHMARK_LINK_COUNT;
+    let mut benched = DoubletsUnitedNonVolatileBenched::setup(
+        "/tmp/bench_united_non_volatile_query_all.links".to_string(),
+    );
+    c.bench_with_input(
+        BenchmarkId::new("query_all/Doublets_United_NonVolatile", count),
+        &count,
+        |b, &n| {
+            b.iter_custom(|iters| {
+                let mut total = Duration::ZERO;
+                for _ in 0..iters {
+                    let mut fork = Benched::fork(&mut benched);
+                    setup_background!(fork);
+                    for _ in 0..n {
+                        fork.create_point();
+                    }
+                    let start = Instant::now();
+                    let _ = fork.query_all();
+                    total += start.elapsed();
+                }
+                total
+            });
+        },
+    );
+}
+
+fn doublets_split_non_volatile_query_all(c: &mut Criterion) {
+    let count = *BENCHMARK_LINK_COUNT;
+    let mut benched = DoubletsSplitNonVolatileBenched::setup((
+        "/tmp/bench_split_non_volatile_query_all_data.links".to_string(),
+        "/tmp/bench_split_non_volatile_query_all_index.links".to_string(),
+    ));
+    c.bench_with_input(
+        BenchmarkId::new("query_all/Doublets_Split_NonVolatile", count),
+        &count,
+        |b, &n| {
+            b.iter_custom(|iters| {
+                let mut total = Duration::ZERO;
+                for _ in 0..iters {
+                    let mut fork = Benched::fork(&mut benched);
+                    setup_background!(fork);
+                    for _ in 0..n {
+                        fork.create_point();
+                    }
+                    let start = Instant::now();
+                    let _ = fork.query_all();
+                    total += start.elapsed();
+                }
+                total
+            });
+        },
+    );
+}
+
 // ===================== QUERY BY ID =====================
 
 fn spacetimedb_query_by_id(c: &mut Criterion) {
     let count = *BENCHMARK_LINK_COUNT;
-    let mut benched = SpacetimeDbMemoryBenched::setup(());
+    let mut benched = SpacetimeDbBenched::setup(());
     c.bench_with_input(
-        BenchmarkId::new("query_by_id/SpacetimeDB_Memory", count),
+        BenchmarkId::new("query_by_id/SpacetimeDB", count),
         &count,
         |b, &n| {
             b.iter_custom(|iters| {
@@ -427,13 +660,68 @@ fn doublets_split_query_by_id(c: &mut Criterion) {
     );
 }
 
+fn doublets_united_non_volatile_query_by_id(c: &mut Criterion) {
+    let count = *BENCHMARK_LINK_COUNT;
+    let mut benched = DoubletsUnitedNonVolatileBenched::setup(
+        "/tmp/bench_united_non_volatile_query_by_id.links".to_string(),
+    );
+    c.bench_with_input(
+        BenchmarkId::new("query_by_id/Doublets_United_NonVolatile", count),
+        &count,
+        |b, &n| {
+            b.iter_custom(|iters| {
+                let mut total = Duration::ZERO;
+                for _ in 0..iters {
+                    let mut fork = Benched::fork(&mut benched);
+                    setup_background!(fork);
+                    let ids: Vec<u64> = (0..n).map(|_| fork.create_point()).collect();
+                    let start = Instant::now();
+                    for id in ids {
+                        let _ = fork.query_by_id(id);
+                    }
+                    total += start.elapsed();
+                }
+                total
+            });
+        },
+    );
+}
+
+fn doublets_split_non_volatile_query_by_id(c: &mut Criterion) {
+    let count = *BENCHMARK_LINK_COUNT;
+    let mut benched = DoubletsSplitNonVolatileBenched::setup((
+        "/tmp/bench_split_non_volatile_query_by_id_data.links".to_string(),
+        "/tmp/bench_split_non_volatile_query_by_id_index.links".to_string(),
+    ));
+    c.bench_with_input(
+        BenchmarkId::new("query_by_id/Doublets_Split_NonVolatile", count),
+        &count,
+        |b, &n| {
+            b.iter_custom(|iters| {
+                let mut total = Duration::ZERO;
+                for _ in 0..iters {
+                    let mut fork = Benched::fork(&mut benched);
+                    setup_background!(fork);
+                    let ids: Vec<u64> = (0..n).map(|_| fork.create_point()).collect();
+                    let start = Instant::now();
+                    for id in ids {
+                        let _ = fork.query_by_id(id);
+                    }
+                    total += start.elapsed();
+                }
+                total
+            });
+        },
+    );
+}
+
 // ===================== QUERY BY SOURCE =====================
 
 fn spacetimedb_query_by_source(c: &mut Criterion) {
     let count = *BENCHMARK_LINK_COUNT;
-    let mut benched = SpacetimeDbMemoryBenched::setup(());
+    let mut benched = SpacetimeDbBenched::setup(());
     c.bench_with_input(
-        BenchmarkId::new("query_by_source/SpacetimeDB_Memory", count),
+        BenchmarkId::new("query_by_source/SpacetimeDB", count),
         &count,
         |b, &n| {
             b.iter_custom(|iters| {
@@ -513,13 +801,74 @@ fn doublets_split_query_by_source(c: &mut Criterion) {
     );
 }
 
+fn doublets_united_non_volatile_query_by_source(c: &mut Criterion) {
+    let count = *BENCHMARK_LINK_COUNT;
+    let mut benched = DoubletsUnitedNonVolatileBenched::setup(
+        "/tmp/bench_united_non_volatile_query_by_source.links".to_string(),
+    );
+    c.bench_with_input(
+        BenchmarkId::new("query_by_source/Doublets_United_NonVolatile", count),
+        &count,
+        |b, &n| {
+            b.iter_custom(|iters| {
+                let mut total = Duration::ZERO;
+                for _ in 0..iters {
+                    let mut fork = Benched::fork(&mut benched);
+                    setup_background!(fork);
+                    // Create links with distributed sources
+                    for i in 1..=n as u64 {
+                        fork.create(i % 10 + 1, i % 7 + 1);
+                    }
+                    let start = Instant::now();
+                    for src in 1..=(n.min(10) as u64) {
+                        let _ = fork.query_by_source(src);
+                    }
+                    total += start.elapsed();
+                }
+                total
+            });
+        },
+    );
+}
+
+fn doublets_split_non_volatile_query_by_source(c: &mut Criterion) {
+    let count = *BENCHMARK_LINK_COUNT;
+    let mut benched = DoubletsSplitNonVolatileBenched::setup((
+        "/tmp/bench_split_non_volatile_query_by_source_data.links".to_string(),
+        "/tmp/bench_split_non_volatile_query_by_source_index.links".to_string(),
+    ));
+    c.bench_with_input(
+        BenchmarkId::new("query_by_source/Doublets_Split_NonVolatile", count),
+        &count,
+        |b, &n| {
+            b.iter_custom(|iters| {
+                let mut total = Duration::ZERO;
+                for _ in 0..iters {
+                    let mut fork = Benched::fork(&mut benched);
+                    setup_background!(fork);
+                    // Create links with distributed sources
+                    for i in 1..=n as u64 {
+                        fork.create(i % 10 + 1, i % 7 + 1);
+                    }
+                    let start = Instant::now();
+                    for src in 1..=(n.min(10) as u64) {
+                        let _ = fork.query_by_source(src);
+                    }
+                    total += start.elapsed();
+                }
+                total
+            });
+        },
+    );
+}
+
 // ===================== QUERY BY TARGET =====================
 
 fn spacetimedb_query_by_target(c: &mut Criterion) {
     let count = *BENCHMARK_LINK_COUNT;
-    let mut benched = SpacetimeDbMemoryBenched::setup(());
+    let mut benched = SpacetimeDbBenched::setup(());
     c.bench_with_input(
-        BenchmarkId::new("query_by_target/SpacetimeDB_Memory", count),
+        BenchmarkId::new("query_by_target/SpacetimeDB", count),
         &count,
         |b, &n| {
             b.iter_custom(|iters| {
@@ -599,11 +948,74 @@ fn doublets_split_query_by_target(c: &mut Criterion) {
     );
 }
 
+fn doublets_united_non_volatile_query_by_target(c: &mut Criterion) {
+    let count = *BENCHMARK_LINK_COUNT;
+    let mut benched = DoubletsUnitedNonVolatileBenched::setup(
+        "/tmp/bench_united_non_volatile_query_by_target.links".to_string(),
+    );
+    c.bench_with_input(
+        BenchmarkId::new("query_by_target/Doublets_United_NonVolatile", count),
+        &count,
+        |b, &n| {
+            b.iter_custom(|iters| {
+                let mut total = Duration::ZERO;
+                for _ in 0..iters {
+                    let mut fork = Benched::fork(&mut benched);
+                    setup_background!(fork);
+                    // Create links with distributed targets
+                    for i in 1..=n as u64 {
+                        fork.create(i % 7 + 1, i % 10 + 1);
+                    }
+                    let start = Instant::now();
+                    for tgt in 1..=(n.min(10) as u64) {
+                        let _ = fork.query_by_target(tgt);
+                    }
+                    total += start.elapsed();
+                }
+                total
+            });
+        },
+    );
+}
+
+fn doublets_split_non_volatile_query_by_target(c: &mut Criterion) {
+    let count = *BENCHMARK_LINK_COUNT;
+    let mut benched = DoubletsSplitNonVolatileBenched::setup((
+        "/tmp/bench_split_non_volatile_query_by_target_data.links".to_string(),
+        "/tmp/bench_split_non_volatile_query_by_target_index.links".to_string(),
+    ));
+    c.bench_with_input(
+        BenchmarkId::new("query_by_target/Doublets_Split_NonVolatile", count),
+        &count,
+        |b, &n| {
+            b.iter_custom(|iters| {
+                let mut total = Duration::ZERO;
+                for _ in 0..iters {
+                    let mut fork = Benched::fork(&mut benched);
+                    setup_background!(fork);
+                    // Create links with distributed targets
+                    for i in 1..=n as u64 {
+                        fork.create(i % 7 + 1, i % 10 + 1);
+                    }
+                    let start = Instant::now();
+                    for tgt in 1..=(n.min(10) as u64) {
+                        let _ = fork.query_by_target(tgt);
+                    }
+                    total += start.elapsed();
+                }
+                total
+            });
+        },
+    );
+}
+
 criterion_group!(
     create_benches,
     spacetimedb_create,
     doublets_united_create,
     doublets_split_create,
+    doublets_united_non_volatile_create,
+    doublets_split_non_volatile_create,
 );
 
 criterion_group!(
@@ -611,6 +1023,8 @@ criterion_group!(
     spacetimedb_delete,
     doublets_united_delete,
     doublets_split_delete,
+    doublets_united_non_volatile_delete,
+    doublets_split_non_volatile_delete,
 );
 
 criterion_group!(
@@ -618,6 +1032,8 @@ criterion_group!(
     spacetimedb_update,
     doublets_united_update,
     doublets_split_update,
+    doublets_united_non_volatile_update,
+    doublets_split_non_volatile_update,
 );
 
 criterion_group!(
@@ -625,6 +1041,8 @@ criterion_group!(
     spacetimedb_query_all,
     doublets_united_query_all,
     doublets_split_query_all,
+    doublets_united_non_volatile_query_all,
+    doublets_split_non_volatile_query_all,
 );
 
 criterion_group!(
@@ -632,6 +1050,8 @@ criterion_group!(
     spacetimedb_query_by_id,
     doublets_united_query_by_id,
     doublets_split_query_by_id,
+    doublets_united_non_volatile_query_by_id,
+    doublets_split_non_volatile_query_by_id,
 );
 
 criterion_group!(
@@ -639,6 +1059,8 @@ criterion_group!(
     spacetimedb_query_by_source,
     doublets_united_query_by_source,
     doublets_split_query_by_source,
+    doublets_united_non_volatile_query_by_source,
+    doublets_split_non_volatile_query_by_source,
 );
 
 criterion_group!(
@@ -646,6 +1068,8 @@ criterion_group!(
     spacetimedb_query_by_target,
     doublets_united_query_by_target,
     doublets_split_query_by_target,
+    doublets_united_non_volatile_query_by_target,
+    doublets_split_non_volatile_query_by_target,
 );
 
 criterion_main!(
diff --git a/rust/doublets-patched/PATCHES.md b/rust/doublets-patched/PATCHES.md
new file mode 100644
index 0000000..fa2f11d
--- /dev/null
+++ b/rust/doublets-patched/PATCHES.md
@@ -0,0 +1,31 @@
+# Why Patched Versions Are Needed
+
+This directory contains local patched copies of `doublets-rs` and its dependencies (`mem-rs`, `data-rs`, `trees-rs`). These patches are necessary because the published versions on crates.io use removed or renamed Rust nightly features that are incompatible with modern Rust nightly (≥ 1.80.0).
+
+## Background
+
+The `doublets` crate (and its internal dependencies `platform-mem`, `platform-data`, `platform-trees`) require Rust nightly due to heavy use of unstable features such as `allocator_api`, `fn_traits`, `try_trait_v2`, and others. The last published release on crates.io was pinned to a specific nightly toolchain from 2022–2023. Since then, several nightly features used by these crates have been stabilized, renamed, or removed from nightly entirely.
+
+## Specific Issues Fixed
+
+### `doublets` crate (`doublets-patched/doublets/`)
+
+- **Removed `#![feature(generators)]`**: The upstream crate declared `#![feature(generators)]` in `src/lib.rs`. Rust nightly removed the `generators` feature in [this change](https://github.com/rust-lang/rust/pull/116958) (replaced by `coroutines`). The feature gate no longer exists and causes a compilation error. Since generators were not actually used in any code paths exercised by this benchmark, the feature flag was simply removed.
+
+### `platform-data` crate (`doublets-patched/dev-deps/data-rs/`)
+
+- **Removed `~const` syntax**: The upstream code used `~const Fn` bounds (the "maybe-const" trait bound syntax) in several places. This experimental syntax was removed from nightly in 2023 (see [rust-lang/rust#110395](https://github.com/rust-lang/rust/issues/110395)). The affected functions were changed to use regular `Fn` bounds instead, which is correct since they are never called in a `const` context in this project.
+
+### `platform-mem` crate (`doublets-patched/dev-deps/mem-rs/`)
+
+- **Removed obsolete `#![feature(...)]` flags**: The upstream crate declared several feature flags that have since been stabilized or renamed. Specifically, `nonnull_slice_from_raw_parts` and `slice_ptr_get` were stabilized in Rust 1.70.0 and 1.74.0 respectively. Keeping them as `#![feature(...)]` flags causes errors on modern nightly because nightly rejects `#![feature]` declarations for already-stable features.
+
+## Why Not Use the Upstream Version?
+
+The `doublets` crate is not actively maintained for compatibility with current Rust nightly. Attempts to use the published crates.io version (or the upstream git repository) result in compilation failures on Rust nightly ≥ 1.80.0. Upstream issues have been filed but not addressed.
+
+The patches are minimal and surgical — they do not change any algorithmic behavior, data structures, or storage semantics. The only changes are the removal of feature flags and the replacement of removed syntax with equivalent stable alternatives.
+
+## Future Resolution
+
+Once the upstream `doublets-rs` crates are updated for modern Rust nightly compatibility, the `doublets-patched/` directory can be removed and the dependency replaced with a direct crates.io reference. This is tracked in the [doublets-rs repository](https://github.com/linksplatform/doublets-rs).
diff --git a/rust/doublets-patched/dev-deps/data-rs/Cargo.toml b/rust/doublets-patched/dev-deps/data-rs/Cargo.toml
new file mode 100644
index 0000000..6c97f08
--- /dev/null
+++ b/rust/doublets-patched/dev-deps/data-rs/Cargo.toml
@@ -0,0 +1,20 @@
+[package]
+name = "platform-data"
+version = "0.1.0-beta.3"
+edition = "2018"
+authors = ["uselesssgoddess", "Linksplatform Team <linksplatformtechnologies@gmail.com>"]
+license = "LGPL-3.0"
+repository = "https://github.com/linksplatform/platform-rs"
+homepage = "https://github.com/linksplatform/platform-rs"
+description = """
+Data for linksplatform
+"""
+
+[dependencies]
+beef = "~0.5"
+funty = "2.0.0"
+thiserror = "1.0.31"
+
+[dev-dependencies]
+quickcheck = "1.0.3"
+quickcheck_macros = "1.0.0"
\ No newline at end of file
diff --git a/rust/doublets-patched/dev-deps/data-rs/LICENSE b/rust/doublets-patched/dev-deps/data-rs/LICENSE
new file mode 100644
index 0000000..6bb8a29
--- /dev/null
+++ b/rust/doublets-patched/dev-deps/data-rs/LICENSE
@@ -0,0 +1,24 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+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 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.
+
+For more information, please refer to <http://unlicense.org>
\ No newline at end of file
diff --git a/rust/doublets-patched/dev-deps/data-rs/rustfmt.toml b/rust/doublets-patched/dev-deps/data-rs/rustfmt.toml
new file mode 100644
index 0000000..4dd7be3
--- /dev/null
+++ b/rust/doublets-patched/dev-deps/data-rs/rustfmt.toml
@@ -0,0 +1,5 @@
+error_on_line_overflow = true
+error_on_unformatted = true
+version = "Two"
+
+imports_granularity = "Crate"
\ No newline at end of file
diff --git a/rust/doublets-patched/dev-deps/data-rs/src/constants.rs b/rust/doublets-patched/dev-deps/data-rs/src/constants.rs
new file mode 100644
index 0000000..3cb2b4b
--- /dev/null
+++ b/rust/doublets-patched/dev-deps/data-rs/src/constants.rs
@@ -0,0 +1,111 @@
+use std::ops::RangeInclusive;
+
+use crate::{Hybrid, LinkType};
+
+#[derive(Clone, Eq, PartialEq, Debug)]
+pub struct LinksConstants<T: LinkType> {
+    pub index_part: T,
+    pub source_part: T,
+    pub target_part: T,
+    pub null: T,
+    pub r#continue: T,
+    pub r#break: T,
+    pub skip: T,
+    pub any: T,
+    pub itself: T,
+    pub error: T,
+    pub internal_range: RangeInclusive<T>,
+    pub external_range: Option<RangeInclusive<T>>,
+}
+
+impl<T: LinkType> LinksConstants<T> {
+    fn default_target_part() -> T {
+        T::funty(2)
+    }
+
+    pub fn full_new(
+        target_part: T,
+        internal: RangeInclusive<T>,
+        external: Option<RangeInclusive<T>>,
+    ) -> Self {
+        Self {
+            index_part: T::funty(0),
+            source_part: T::funty(1),
+            target_part,
+            null: T::funty(0),
+            r#continue: *internal.end(),
+            r#break: *internal.end() - T::funty(1),
+            skip: *internal.end() - T::funty(2),
+            any: *internal.end() - T::funty(3),
+            itself: *internal.end() - T::funty(4),
+            error: *internal.end() - T::funty(5),
+            internal_range: *internal.start()..=*internal.end() - T::funty(6),
+            external_range: external,
+        }
+    }
+
+    // TODO: enough for now
+    pub fn via_external(target_part: T, external: bool) -> Self {
+        Self::full_new(
+            target_part,
+            Self::default_internal(external),
+            Self::default_external(external),
+        )
+    }
+
+    pub fn via_ranges(internal: RangeInclusive<T>, external: Option<RangeInclusive<T>>) -> Self {
+        Self::full_new(Self::default_target_part(), internal, external)
+    }
+
+    pub fn via_only_external(external: bool) -> Self {
+        Self::via_external(Self::default_target_part(), external)
+    }
+
+    pub fn external() -> Self {
+        Self::via_only_external(true)
+    }
+
+    pub fn internal() -> Self {
+        Self::via_only_external(false)
+    }
+
+    pub fn new() -> Self {
+        Self::internal()
+    }
+
+    fn default_internal(external: bool) -> RangeInclusive<T> {
+        if external {
+            T::funty(1)..=Hybrid::half()
+        } else {
+            T::funty(1)..=T::MAX
+        }
+    }
+
+    fn default_external(external: bool) -> Option<RangeInclusive<T>> {
+        if external {
+            Some(Hybrid::half()..=T::MAX)
+        } else {
+            None
+        }
+    }
+
+    pub fn is_internal(&self, address: T) -> bool {
+        self.internal_range.contains(&address)
+    }
+
+    pub fn is_external(&self, address: T) -> bool {
+        self.external_range
+            .clone()
+            .map_or(false, |range| range.contains(&address))
+    }
+
+    pub fn is_reference(&self, address: T) -> bool {
+        self.is_internal(address) || self.is_external(address)
+    }
+}
+
+impl<T: LinkType> Default for LinksConstants<T> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
diff --git a/rust/doublets-patched/dev-deps/data-rs/src/converters.rs b/rust/doublets-patched/dev-deps/data-rs/src/converters.rs
new file mode 100644
index 0000000..adc6451
--- /dev/null
+++ b/rust/doublets-patched/dev-deps/data-rs/src/converters.rs
@@ -0,0 +1,21 @@
+use crate::{Hybrid, LinkType};
+use funty::Integral;
+use std::ops::Sub;
+
+#[derive(Default)]
+pub struct AddrToRaw;
+
+impl AddrToRaw {
+    pub fn convert<T: LinkType + Integral + Sub>(&self, source: T) -> T {
+        Hybrid::external(source).as_inner()
+    }
+}
+
+#[derive(Default)]
+pub struct RawToAddr;
+
+impl RawToAddr {
+    pub fn convert<T: LinkType + Integral + Sub>(&self, source: T) -> T {
+        Hybrid::external(source).abs()
+    }
+}
diff --git a/rust/doublets-patched/dev-deps/data-rs/src/flow.rs b/rust/doublets-patched/dev-deps/data-rs/src/flow.rs
new file mode 100644
index 0000000..9cb90b3
--- /dev/null
+++ b/rust/doublets-patched/dev-deps/data-rs/src/flow.rs
@@ -0,0 +1,37 @@
+use std::ops::{ControlFlow, FromResidual, Try};
+
+pub enum Flow {
+    Continue,
+    Break,
+}
+
+impl FromResidual for Flow {
+    fn from_residual(_: <Self as Try>::Residual) -> Self {
+        Flow::Break
+    }
+}
+
+impl Try for Flow {
+    type Output = ();
+    type Residual = Flow;
+
+    fn from_output(_: Self::Output) -> Self {
+        Flow::Continue
+    }
+
+    fn branch(self) -> ControlFlow<Self::Residual, Self::Output> {
+        match self {
+            Flow::Continue => ControlFlow::Continue(()),
+            Flow::Break => ControlFlow::Break(Flow::Break),
+        }
+    }
+}
+
+impl<C, B> From<ControlFlow<C, B>> for Flow {
+    fn from(flow: ControlFlow<C, B>) -> Self {
+        match flow {
+            ControlFlow::Continue(_) => Flow::Continue,
+            ControlFlow::Break(_) => Flow::Break,
+        }
+    }
+}
diff --git a/rust/doublets-patched/dev-deps/data-rs/src/hybrid.rs b/rust/doublets-patched/dev-deps/data-rs/src/hybrid.rs
new file mode 100644
index 0000000..6bdbaf5
--- /dev/null
+++ b/rust/doublets-patched/dev-deps/data-rs/src/hybrid.rs
@@ -0,0 +1,73 @@
+use crate::LinkType;
+use funty::Integral;
+use std::ops::{Div, Sub};
+
+#[derive(Debug, Clone, Copy, Hash, PartialOrd, PartialEq, Ord, Eq)]
+pub struct Hybrid<T> {
+    value: T,
+}
+
+impl<T: LinkType> Hybrid<T> {
+    pub fn new(value: T) -> Self {
+        Self::internal(value)
+    }
+
+    pub fn half() -> T
+    where
+        T: Div<Output = T>,
+    {
+        T::MAX / T::funty(2)
+    }
+
+    pub fn external(value: T) -> Self
+    where
+        T: Integral + Sub,
+    {
+        Self {
+            value: Self::extend_value(value),
+        }
+    }
+
+    pub fn internal(value: T) -> Self {
+        Self { value }
+    }
+
+    fn extend_value(value: T) -> T
+    where
+        T: Integral + Sub,
+    {
+        (T::MAX - value).wrapping_add(T::funty(1))
+    }
+
+    pub fn is_zero(&self) -> bool
+    where
+        T: Default + PartialEq,
+    {
+        self.value == T::funty(0)
+    }
+
+    pub fn is_internal(&self) -> bool
+    where
+        T: Div + PartialOrd,
+    {
+        self.value < Self::half() // || self.value == T::default()
+    }
+
+    pub fn is_external(&self) -> bool
+    where
+        T: Div + PartialOrd + PartialEq,
+    {
+        !self.is_internal() || self.value == T::funty(0)
+    }
+
+    pub fn abs(&self) -> T
+    where
+        T: Integral,
+    {
+        self.value.wrapping_add(T::funty(1)).wrapping_add(T::MAX)
+    }
+
+    pub fn as_inner(&self) -> T {
+        self.value
+    }
+}
diff --git a/rust/doublets-patched/dev-deps/data-rs/src/lib.rs b/rust/doublets-patched/dev-deps/data-rs/src/lib.rs
new file mode 100644
index 0000000..165378a
--- /dev/null
+++ b/rust/doublets-patched/dev-deps/data-rs/src/lib.rs
@@ -0,0 +1,21 @@
+#![feature(try_trait_v2)]
+#![feature(impl_trait_in_assoc_type)]
+#![feature(step_trait)]
+
+mod constants;
+mod converters;
+mod flow;
+mod hybrid;
+mod link_type;
+mod links;
+mod point;
+mod query;
+
+pub use constants::LinksConstants;
+pub use converters::{AddrToRaw, RawToAddr};
+pub use flow::Flow;
+pub use hybrid::Hybrid;
+pub use link_type::LinkType;
+pub use links::{Error, Links, ReadHandler, WriteHandler};
+pub use point::Point;
+pub use query::{Query, ToQuery};
diff --git a/rust/doublets-patched/dev-deps/data-rs/src/link_type.rs b/rust/doublets-patched/dev-deps/data-rs/src/link_type.rs
new file mode 100644
index 0000000..82af5e6
--- /dev/null
+++ b/rust/doublets-patched/dev-deps/data-rs/src/link_type.rs
@@ -0,0 +1,84 @@
+use funty::Unsigned;
+use std::{
+    convert::{TryFrom, TryInto},
+    fmt::Debug,
+    hint,
+    iter::Step,
+};
+
+pub trait FuntyPart: Sized + TryFrom<u8> {
+    fn funty(n: u8) -> Self;
+}
+
+// TryFrom<u8> has `Error = Infallible` for all types
+impl<All: TryFrom<u8>> FuntyPart for All {
+    fn funty(n: u8) -> Self {
+        // std `Result::unwrap_unchecked` is not const
+        match All::try_from(n) {
+            Ok(all) => all,
+            Err(_) => {
+                // <All as TryFrom<u8>>::Error is Infallible
+                unsafe { hint::unreachable_unchecked() }
+            }
+        }
+    }
+}
+
+pub trait LinkType:
+    Unsigned
+    + FuntyPart
+    + Step
+    + TryFrom<i8, Error: Debug>
+    + TryFrom<u8, Error: Debug>
+    + TryFrom<i16, Error: Debug>
+    + TryFrom<u16, Error: Debug>
+    + TryFrom<i32, Error: Debug>
+    + TryFrom<u32, Error: Debug>
+    + TryFrom<i64, Error: Debug>
+    + TryFrom<u64, Error: Debug>
+    + TryFrom<i128, Error: Debug>
+    + TryFrom<u128, Error: Debug>
+    + TryFrom<isize, Error: Debug>
+    + TryFrom<usize, Error: Debug>
+    + TryInto<i8, Error: Debug>
+    + TryInto<u8, Error: Debug>
+    + TryInto<i16, Error: Debug>
+    + TryInto<u16, Error: Debug>
+    + TryInto<i32, Error: Debug>
+    + TryInto<u32, Error: Debug>
+    + TryInto<i64, Error: Debug>
+    + TryInto<u64, Error: Debug>
+    + TryInto<i128, Error: Debug>
+    + TryInto<u128, Error: Debug>
+    + TryInto<isize, Error: Debug>
+    + TryInto<usize, Error: Debug>
+{
+}
+
+impl<All: Unsigned + FuntyPart + Step> LinkType for All where
+    All: TryFrom<i8, Error: Debug>
+        + TryFrom<u8, Error: Debug>
+        + TryFrom<i16, Error: Debug>
+        + TryFrom<u16, Error: Debug>
+        + TryFrom<i32, Error: Debug>
+        + TryFrom<u32, Error: Debug>
+        + TryFrom<i64, Error: Debug>
+        + TryFrom<u64, Error: Debug>
+        + TryFrom<i128, Error: Debug>
+        + TryFrom<u128, Error: Debug>
+        + TryFrom<isize, Error: Debug>
+        + TryFrom<usize, Error: Debug>
+        + TryInto<i8, Error: Debug>
+        + TryInto<u8, Error: Debug>
+        + TryInto<i16, Error: Debug>
+        + TryInto<u16, Error: Debug>
+        + TryInto<i32, Error: Debug>
+        + TryInto<u32, Error: Debug>
+        + TryInto<i64, Error: Debug>
+        + TryInto<u64, Error: Debug>
+        + TryInto<i128, Error: Debug>
+        + TryInto<u128, Error: Debug>
+        + TryInto<isize, Error: Debug>
+        + TryInto<usize, Error: Debug>
+{
+}
diff --git a/rust/doublets-patched/dev-deps/data-rs/src/links.rs b/rust/doublets-patched/dev-deps/data-rs/src/links.rs
new file mode 100644
index 0000000..7ccc94f
--- /dev/null
+++ b/rust/doublets-patched/dev-deps/data-rs/src/links.rs
@@ -0,0 +1,54 @@
+use crate::{Flow, LinkType, LinksConstants};
+use std::{borrow::Cow, error, io};
+
+#[derive(thiserror::Error, Debug)]
+pub enum Error<'a, T: LinkType> {
+    #[error("link {0} does not exist.")]
+    NotExists(T),
+
+    #[error("link {0:?} has dependencies")]
+    HasUsages(Vec<Cow<'a, [T]>>),
+
+    #[error("link {0} already exists")]
+    AlreadyExists(Cow<'a, T>),
+
+    #[error("limit for the number of links in the storage has been reached: {0}")]
+    LimitReached(T),
+
+    #[error("unable to allocate memory for links storage: `{0}`")]
+    AllocFailed(#[from] io::Error),
+
+    #[error("other internal error: `{0}`")]
+    Other(#[from] Box<dyn error::Error + Sync + Send>),
+}
+
+pub type ReadHandler<'a, T> = &'a mut dyn FnMut(&[T]) -> Flow;
+
+pub type WriteHandler<'a, T> = &'a mut dyn FnMut(&[T], &[T]) -> Flow;
+
+pub trait Links<T: LinkType> {
+    fn constants_links(&self) -> LinksConstants<T>;
+
+    fn count_links(&self, query: &[T]) -> T;
+
+    fn create_links(
+        &mut self,
+        query: &[T],
+        handler: WriteHandler<'_, T>,
+    ) -> Result<Flow, Error<'_, T>>;
+
+    fn each_links(&self, query: &[T], handler: ReadHandler<'_, T>) -> Result<Flow, Error<'_, T>>;
+
+    fn update_links(
+        &mut self,
+        query: &[T],
+        replacement: &[T],
+        handler: WriteHandler<'_, T>,
+    ) -> Result<Flow, Error<'_, T>>;
+
+    fn delete_links(
+        &mut self,
+        query: &[T],
+        handler: WriteHandler<'_, T>,
+    ) -> Result<Flow, Error<'_, T>>;
+}
diff --git a/rust/doublets-patched/dev-deps/data-rs/src/point.rs b/rust/doublets-patched/dev-deps/data-rs/src/point.rs
new file mode 100644
index 0000000..5d79dfa
--- /dev/null
+++ b/rust/doublets-patched/dev-deps/data-rs/src/point.rs
@@ -0,0 +1,57 @@
+pub struct Point<T> {
+    index: T,
+    size: usize,
+}
+
+impl<T: PartialEq> Point<T> {
+    pub const fn new(index: T, size: usize) -> Self {
+        Self { index, size }
+    }
+
+    pub const fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
+    pub const fn len(&self) -> usize {
+        self.size
+    }
+
+    pub fn is_full(link: &[T]) -> bool {
+        assert!(
+            link.len() >= 2,
+            "cannot determine link's pointless using only its identifier"
+        );
+
+        // SAFETY: slice size is at least 2
+        let a = unsafe { link.first().unwrap_unchecked() };
+        link.iter().skip(1).all(|b| b == a)
+    }
+
+    pub fn is_partial(link: &[T]) -> bool {
+        assert!(
+            link.len() >= 2,
+            "cannot determine link's pointless using only its identifier"
+        );
+
+        // SAFETY: slice size is at least 2
+        let a = unsafe { link.first().unwrap_unchecked() };
+        link.iter().skip(1).any(|b| b == a)
+    }
+
+    pub const fn get(&self, index: usize) -> Option<&T> {
+        if index < self.len() {
+            Some(&self.index)
+        } else {
+            None
+        }
+    }
+}
+
+impl<T: PartialEq + Copy> IntoIterator for Point<T> {
+    type Item = T;
+    type IntoIter = impl Iterator<Item = T>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        (0..self.len()).map(move |_| self.index)
+    }
+}
diff --git a/rust/doublets-patched/dev-deps/data-rs/src/query.rs b/rust/doublets-patched/dev-deps/data-rs/src/query.rs
new file mode 100644
index 0000000..9e6d215
--- /dev/null
+++ b/rust/doublets-patched/dev-deps/data-rs/src/query.rs
@@ -0,0 +1,79 @@
+use beef::lean::Cow;
+use std::{ops::Index, slice::SliceIndex};
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct Query<'a, T: Clone>(Cow<'a, [T]>);
+
+impl<'a, T: Clone> Query<'a, T> {
+    pub fn new<C>(beef: C) -> Self
+    where
+        C: Into<Cow<'a, [T]>>,
+    {
+        Query(beef.into())
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.0.is_empty()
+    }
+
+    pub fn len(&self) -> usize {
+        self.0.len()
+    }
+
+    pub fn into_inner(self) -> Cow<'a, [T]> {
+        self.0
+    }
+
+    pub fn into_owned(self) -> Vec<T> {
+        self.0.into_owned()
+    }
+}
+
+impl<'a, I: SliceIndex<[T]>, T: Clone> Index<I> for Query<'a, T> {
+    type Output = I::Output;
+
+    fn index(&self, index: I) -> &Self::Output {
+        self.0.index(index)
+    }
+}
+
+pub trait ToQuery<T: Clone> {
+    fn to_query(&self) -> Query<'_, T>;
+}
+
+impl<T: Clone> ToQuery<T> for Query<'_, T> {
+    fn to_query(&self) -> Query<'_, T> {
+        Query::new(&self[..])
+    }
+}
+
+impl<T: Clone> ToQuery<T> for [T] {
+    fn to_query(&self) -> Query<'_, T> {
+        Query::new(self)
+    }
+}
+
+impl<'a, T: Clone> ToQuery<T> for &'a [T] {
+    fn to_query(&self) -> Query<'a, T> {
+        Query::new(*self)
+    }
+}
+
+impl<T: Clone> ToQuery<T> for Vec<T> {
+    fn to_query(&self) -> Query<'_, T> {
+        Query::new(self.as_slice())
+    }
+}
+
+impl<T: Clone, const L: usize> ToQuery<T> for [T; L] {
+    fn to_query(&self) -> Query<'_, T> {
+        Query::new(self.as_slice())
+    }
+}
+
+#[macro_export]
+macro_rules! query {
+    ($($x:expr),*) => (
+        $crate::ToQuery::to_query(&[$($x),*])
+    );
+}
diff --git a/rust/doublets-patched/dev-deps/data-rs/tests/flow.rs b/rust/doublets-patched/dev-deps/data-rs/tests/flow.rs
new file mode 100644
index 0000000..b6b4a84
--- /dev/null
+++ b/rust/doublets-patched/dev-deps/data-rs/tests/flow.rs
@@ -0,0 +1,13 @@
+use platform_data::Flow;
+
+#[test]
+fn basic() {
+    let mut vec = vec![];
+
+    (0..20).try_for_each(|i| {
+        vec.push(i);
+        if i == 10 { Flow::Break } else { Flow::Continue }
+    });
+
+    assert_eq!(vec, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+}
diff --git a/rust/doublets-patched/dev-deps/data-rs/tests/hybrid.rs b/rust/doublets-patched/dev-deps/data-rs/tests/hybrid.rs
new file mode 100644
index 0000000..4a078f3
--- /dev/null
+++ b/rust/doublets-patched/dev-deps/data-rs/tests/hybrid.rs
@@ -0,0 +1,7 @@
+use platform_data::{AddrToRaw, Hybrid, RawToAddr};
+use quickcheck_macros::quickcheck;
+
+#[quickcheck]
+fn basic(orig: usize) -> bool {
+    RawToAddr.convert(AddrToRaw.convert(orig)) == orig && Hybrid::new(orig).abs() == orig
+}
diff --git a/rust/doublets-patched/dev-deps/data-rs/tests/point.rs b/rust/doublets-patched/dev-deps/data-rs/tests/point.rs
new file mode 100644
index 0000000..39a75e8
--- /dev/null
+++ b/rust/doublets-patched/dev-deps/data-rs/tests/point.rs
@@ -0,0 +1,13 @@
+use platform_data::Point;
+
+#[test]
+fn basic() {
+    let point = Point::new(228, 1337);
+
+    assert_eq!(point.len(), 1337);
+
+    assert_eq!(point.get(0), Some(&228));
+    assert_eq!(point.get(1), Some(&228));
+
+    assert!((0..point.len()).map(|_| 228).eq(point.into_iter()));
+}
diff --git a/rust/doublets-patched/dev-deps/data-rs/tests/query.rs b/rust/doublets-patched/dev-deps/data-rs/tests/query.rs
new file mode 100644
index 0000000..5516007
--- /dev/null
+++ b/rust/doublets-patched/dev-deps/data-rs/tests/query.rs
@@ -0,0 +1,14 @@
+use platform_data::{Query, ToQuery, query};
+
+#[test]
+fn by_ref() {
+    let query = query![1, 2, 3];
+    let ref_query = &query;
+    let _: Query<_> = ref_query.to_query();
+}
+
+#[test]
+fn empty_query() {
+    let query: Query<usize> = query![];
+    assert_eq!(query.len(), 0);
+}
diff --git a/rust/doublets-patched/dev-deps/mem-rs/Cargo.toml b/rust/doublets-patched/dev-deps/mem-rs/Cargo.toml
new file mode 100644
index 0000000..6f48c64
--- /dev/null
+++ b/rust/doublets-patched/dev-deps/mem-rs/Cargo.toml
@@ -0,0 +1,23 @@
+[package]
+name = "platform-mem"
+version = "0.1.0-pre+beta.2"
+edition = "2021"
+authors = ["uselesssgoddess", "Linksplatform Team <linksplatformtechnologies@gmail.com>"]
+license = "Unlicense"
+repository = "https://github.com/linksplatform/mem-rs"
+homepage = "https://github.com/linksplatform/mem-rs"
+description = """
+Memory for linksplatform
+"""
+
+[dependencies]
+tap = "1.0"
+memmap2 = "0.5"
+tempfile = "3.3"
+thiserror = "1.0"
+delegate = "0.7.0"
+
+[dev-dependencies]
+paste = "1.0"
+quickcheck = "1.0"
+quickcheck_macros = "1.0"
diff --git a/rust/doublets-patched/dev-deps/mem-rs/LICENSE b/rust/doublets-patched/dev-deps/mem-rs/LICENSE
new file mode 100644
index 0000000..6bb8a29
--- /dev/null
+++ b/rust/doublets-patched/dev-deps/mem-rs/LICENSE
@@ -0,0 +1,24 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+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 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.
+
+For more information, please refer to <http://unlicense.org>
\ No newline at end of file
diff --git a/rust/doublets-patched/dev-deps/mem-rs/rustfmt.toml b/rust/doublets-patched/dev-deps/mem-rs/rustfmt.toml
new file mode 100644
index 0000000..4dd7be3
--- /dev/null
+++ b/rust/doublets-patched/dev-deps/mem-rs/rustfmt.toml
@@ -0,0 +1,5 @@
+error_on_line_overflow = true
+error_on_unformatted = true
+version = "Two"
+
+imports_granularity = "Crate"
\ No newline at end of file
diff --git a/rust/doublets-patched/dev-deps/mem-rs/src/alloc.rs b/rust/doublets-patched/dev-deps/mem-rs/src/alloc.rs
new file mode 100644
index 0000000..298ca1f
--- /dev/null
+++ b/rust/doublets-patched/dev-deps/mem-rs/src/alloc.rs
@@ -0,0 +1,92 @@
+use crate::{RawMem, Result, base::Base, internal};
+use std::{
+    alloc::{Allocator, Layout},
+    cmp::Ordering,
+    ptr::{NonNull, drop_in_place},
+};
+use tap::Pipe;
+
+pub struct Alloc<T, A: Allocator> {
+    base: Base<T>,
+    alloc: A,
+}
+
+impl<T: Default, A: Allocator> Alloc<T, A> {
+    pub const fn new(alloc: A) -> Self {
+        Self {
+            base: Base::dangling(),
+            alloc,
+        }
+    }
+
+    unsafe fn alloc_impl(&mut self, capacity: usize) -> Result<&mut [T]> {
+        let old_capacity = self.base.ptr.len();
+        let new_capacity = capacity;
+
+        let result: Result<_> = try {
+            if self.base.ptr.as_non_null_ptr() == NonNull::dangling() {
+                let layout = Layout::array::<T>(capacity).map_err(crate::traits::Error::from)?;
+                self.alloc
+                    .allocate(layout)
+                    .map_err(crate::traits::Error::from)?
+            } else {
+                let old_layout =
+                    Layout::array::<T>(old_capacity).map_err(crate::traits::Error::from)?;
+                let new_layout =
+                    Layout::array::<T>(new_capacity).map_err(crate::traits::Error::from)?;
+
+                let ptr = internal::to_bytes(self.base.ptr);
+                match new_capacity.cmp(&old_capacity) {
+                    Ordering::Less => {
+                        self.base.handle_narrow(new_capacity);
+                        self.alloc
+                            .shrink(ptr.as_non_null_ptr(), old_layout, new_layout)
+                            .map_err(crate::traits::Error::from)?
+                    }
+                    Ordering::Greater => self
+                        .alloc
+                        .grow(ptr.as_non_null_ptr(), old_layout, new_layout)
+                        .map_err(crate::traits::Error::from)?,
+                    Ordering::Equal => ptr,
+                }
+            }
+        };
+
+        result.map(|ptr| {
+            self.base.ptr = internal::guaranteed_from_bytes(ptr);
+            self.base.handle_expand(old_capacity);
+            self.base.ptr.as_mut()
+        })
+    }
+}
+
+impl<T: Default, A: Allocator> RawMem<T> for Alloc<T, A> {
+    fn alloc(&mut self, capacity: usize) -> Result<&mut [T]> {
+        unsafe { self.alloc_impl(capacity) }
+    }
+
+    fn allocated(&self) -> usize {
+        self.base.allocated()
+    }
+}
+
+impl<T, A: Allocator> Drop for Alloc<T, A> {
+    fn drop(&mut self) {
+        // SAFETY: ptr is valid slice
+        // SAFETY: items is friendly to drop
+        unsafe { self.base.ptr.as_mut().pipe(|slice| drop_in_place(slice)) }
+
+        let _: Result<_> = try {
+            let ptr = self.base.ptr;
+            let layout = Layout::array::<T>(ptr.len()).map_err(crate::traits::Error::from)?;
+            // SAFETY: ptr is valid slice
+            unsafe {
+                let ptr = ptr.as_non_null_ptr().cast();
+                self.alloc.deallocate(ptr, layout);
+            }
+        };
+    }
+}
+
+unsafe impl<T: Sync, A: Allocator + Sync> Sync for Alloc<T, A> {}
+unsafe impl<T: Send, A: Allocator + Send> Send for Alloc<T, A> {}
diff --git a/rust/doublets-patched/dev-deps/mem-rs/src/base.rs b/rust/doublets-patched/dev-deps/mem-rs/src/base.rs
new file mode 100644
index 0000000..e50649c
--- /dev/null
+++ b/rust/doublets-patched/dev-deps/mem-rs/src/base.rs
@@ -0,0 +1,41 @@
+use std::{
+    marker::PhantomData,
+    ptr::{NonNull, drop_in_place},
+};
+
+pub struct Base<T> {
+    // fixme: use `Unique`
+    pub ptr: NonNull<[T]>,
+    // for dropck: `RawMem` usually owns `T`
+    marker: PhantomData<T>,
+}
+
+impl<T> Base<T> {
+    pub const fn new(ptr: NonNull<[T]>) -> Self {
+        Self {
+            ptr,
+            marker: PhantomData,
+        }
+    }
+
+    pub const fn dangling() -> Self {
+        Self::new(NonNull::slice_from_raw_parts(NonNull::dangling(), 0))
+    }
+
+    pub unsafe fn handle_narrow(&mut self, capacity: usize) {
+        drop_in_place(&mut self.ptr.as_mut()[capacity..]);
+    }
+
+    pub const fn allocated(&self) -> usize {
+        self.ptr.len()
+    }
+}
+
+impl<T: Default> Base<T> {
+    pub unsafe fn handle_expand(&mut self, capacity: usize) {
+        let ptr = self.ptr.as_mut_ptr();
+        for i in capacity..self.allocated() {
+            ptr.add(i).write(T::default());
+        }
+    }
+}
diff --git a/rust/doublets-patched/dev-deps/mem-rs/src/file_mapped.rs b/rust/doublets-patched/dev-deps/mem-rs/src/file_mapped.rs
new file mode 100644
index 0000000..291c20e
--- /dev/null
+++ b/rust/doublets-patched/dev-deps/mem-rs/src/file_mapped.rs
@@ -0,0 +1,161 @@
+use crate::{DEFAULT_PAGE_SIZE, RawMem, Result, base::Base, internal};
+use memmap2::{MmapMut, MmapOptions};
+use std::{
+    cmp::max,
+    fs::File,
+    io,
+    mem::{ManuallyDrop, size_of},
+    path::Path,
+    ptr::drop_in_place,
+};
+use tap::Pipe;
+
+/// [`RawMem`] that uses mapped file as space for a block of memory. It can change the file size
+pub struct FileMapped<T> {
+    base: Base<T>,
+    pub(crate) file: File,
+    mapping: ManuallyDrop<MmapMut>,
+}
+
+impl<T: Default> FileMapped<T> {
+    /// Constructs a new `FileMapped` with provided file.
+    /// File must be opened in read-write mode.
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// use std::{fs::File, io};
+    /// use platform_mem::FileMapped;
+    ///
+    /// let file = File::options().read(true).write(true).open("file").unwrap();
+    /// let mut mem: io::Result<FileMapped<usize>> = FileMapped::new(file);
+    /// ```
+    ///
+    /// # Errors
+    ///
+    /// Returns error if file is not opened in read-write mode
+    /// or it captured by other process.
+    pub fn new(file: File) -> io::Result<Self> {
+        let capacity = DEFAULT_PAGE_SIZE / size_of::<T>();
+        let mapping = unsafe { MmapOptions::new().map_mut(&file)? };
+
+        file.metadata()?
+            .len()
+            .pipe(|len| max(len, capacity as u64))
+            .pipe(|len| file.set_len(len))
+            .pipe(|_| Self {
+                base: Base::dangling(),
+                mapping: ManuallyDrop::new(mapping),
+                file,
+            })
+            .pipe(Ok)
+    }
+
+    /// Constructs a new `FileMapped` with provided file,
+    /// when open as read/write mode.
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// use std::io;
+    /// use platform_mem::FileMapped;
+    ///
+    /// let mut mem: io::Result<FileMapped<usize>> = FileMapped::from_path("file");
+    /// ```
+    ///
+    /// # Errors
+    ///
+    /// Returns error if file is captured by other process.
+    pub fn from_path<P: AsRef<Path>>(path: P) -> io::Result<Self> {
+        File::options()
+            .create(true)
+            .read(true)
+            .write(true)
+            .open(path)
+            .and_then(Self::new)
+    }
+
+    unsafe fn map(&mut self, capacity: usize) -> io::Result<&mut [u8]> {
+        self.mapping = MmapOptions::new()
+            .len(capacity)
+            .map_mut(&self.file)?
+            .pipe(ManuallyDrop::new);
+        self.mapping.as_mut().pipe(Ok)
+    }
+
+    unsafe fn unmap(&mut self) {
+        ManuallyDrop::drop(&mut self.mapping);
+    }
+}
+
+impl<T: Default> FileMapped<T> {
+    fn alloc_impl(&mut self, capacity: usize) -> io::Result<()> {
+        let cap = capacity * size_of::<T>();
+
+        if capacity < self.base.allocated() {
+            unsafe {
+                self.base.handle_narrow(capacity);
+            }
+        }
+
+        // SAFETY: `self.mapping` is initialized
+        unsafe {
+            self.unmap();
+        }
+
+        self.file
+            .metadata()?
+            .len()
+            .pipe(|len| max(len, cap as u64))
+            .pipe(|len| self.file.set_len(len))?;
+
+        // SAFETY: type is safe to slice from bytes
+        unsafe {
+            self.base.ptr = self
+                .map(cap)?
+                .pipe(internal::safety_from_bytes_slice)
+                .into();
+        }
+
+        if capacity > self.base.allocated() {
+            unsafe {
+                self.base.handle_expand(capacity);
+            }
+        }
+
+        Ok(())
+    }
+}
+
+impl<T: Default> RawMem<T> for FileMapped<T> {
+    fn alloc(&mut self, capacity: usize) -> Result<&mut [T]> {
+        self.alloc_impl(capacity)?;
+
+        // SAFETY: `ptr` is valid slice
+        unsafe { self.base.ptr.as_mut().pipe(Ok) }
+    }
+
+    fn allocated(&self) -> usize {
+        self.base.allocated()
+    }
+}
+
+impl<T> Drop for FileMapped<T> {
+    fn drop(&mut self) {
+        // SAFETY: `slice` is valid file piece
+        // `self.mapping` is initialized
+        // items is friendly to drop
+        unsafe {
+            drop_in_place(self.base.ptr.as_mut());
+            ManuallyDrop::drop(&mut self.mapping);
+        }
+
+        let _: Result<_> = try {
+            self.file.sync_all().map_err(crate::traits::Error::from)?;
+        };
+    }
+}
+
+unsafe impl<T: Sync> Sync for FileMapped<T> {}
+
+unsafe impl<T: Send> Send for FileMapped<T> {}
diff --git a/rust/doublets-patched/dev-deps/mem-rs/src/global.rs b/rust/doublets-patched/dev-deps/mem-rs/src/global.rs
new file mode 100644
index 0000000..ae148d1
--- /dev/null
+++ b/rust/doublets-patched/dev-deps/mem-rs/src/global.rs
@@ -0,0 +1,82 @@
+use crate::{Base, RawMem, Result, internal};
+use std::{
+    alloc::{self, Layout},
+    mem::size_of,
+    ptr::{self, NonNull},
+};
+use tap::Pipe;
+
+pub struct Global<T>(Base<T>);
+
+impl<T> Global<T> {
+    #[must_use]
+    pub const fn new() -> Self {
+        Self(Base::dangling())
+    }
+
+    fn layout_impl(capacity: usize) -> Result<Layout> {
+        Layout::array::<T>(capacity).map_err(Into::into)
+    }
+}
+
+impl<T: Default> Global<T> {
+    unsafe fn on_reserved_impl(&mut self, new_capacity: usize) -> Result<&mut [T]> {
+        let old_capacity = self.0.allocated();
+        let new_in_bytes = new_capacity * size_of::<T>();
+        let ptr = if self.0.ptr.as_non_null_ptr() == NonNull::dangling() {
+            Self::layout_impl(new_capacity)?.pipe(|layout| alloc::alloc(layout))
+        } else {
+            if new_capacity < old_capacity {
+                self.0.handle_narrow(new_capacity);
+            }
+            let ptr = internal::to_bytes(self.0.ptr).as_mut_ptr();
+            Self::layout_impl(old_capacity)?
+                .pipe(|layout| alloc::realloc(ptr, layout, new_in_bytes))
+        }
+        .pipe(|ptr| NonNull::new_unchecked(ptr))
+        .pipe(|ptr| NonNull::slice_from_raw_parts(ptr, new_in_bytes));
+
+        self.0.ptr = internal::guaranteed_from_bytes(ptr);
+        self.0.handle_expand(old_capacity);
+        self.0.ptr.as_mut().pipe(Ok)
+    }
+}
+
+impl<T: Default> Default for Global<T> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl<T: Default> RawMem<T> for Global<T> {
+    fn alloc(&mut self, capacity: usize) -> Result<&mut [T]> {
+        unsafe { self.on_reserved_impl(capacity) }
+    }
+
+    fn allocated(&self) -> usize {
+        self.0.allocated()
+    }
+}
+
+impl<T> Drop for Global<T> {
+    fn drop(&mut self) {
+        // SAFETY: ptr is valid slice
+        // items is friendly to drop
+        unsafe { self.0.ptr.as_mut().pipe(|slice| ptr::drop_in_place(slice)) }
+
+        let _: Result<_> = try {
+            let ptr = self.0.ptr;
+            let layout = Self::layout_impl(ptr.len())?;
+            // SAFETY: ptr is valid slice
+            unsafe {
+                ptr.as_non_null_ptr()
+                    .cast::<u8>()
+                    .as_ptr()
+                    .pipe(|ptr| alloc::dealloc(ptr, layout));
+            }
+        };
+    }
+}
+
+unsafe impl<T: Sync> Sync for Global<T> {}
+unsafe impl<T: Send> Send for Global<T> {}
diff --git a/rust/doublets-patched/dev-deps/mem-rs/src/internal.rs b/rust/doublets-patched/dev-deps/mem-rs/src/internal.rs
new file mode 100644
index 0000000..cd808ab
--- /dev/null
+++ b/rust/doublets-patched/dev-deps/mem-rs/src/internal.rs
@@ -0,0 +1,63 @@
+use std::{mem::size_of, ptr::NonNull};
+
+pub const fn to_bytes<T>(ptr: NonNull<[T]>) -> NonNull<[u8]> {
+    NonNull::slice_from_raw_parts(ptr.as_non_null_ptr().cast(), ptr.len() * size_of::<T>())
+}
+
+pub fn guaranteed_from_bytes<U>(ptr: NonNull<[u8]>) -> NonNull<[U]> {
+    debug_assert!(
+        ptr.len() % size_of::<U>() == 0,
+        "Types are not aligned; len: {}, size_of: {}",
+        ptr.len(),
+        size_of::<U>()
+    );
+
+    NonNull::slice_from_raw_parts(ptr.as_non_null_ptr().cast(), ptr.len() / size_of::<U>())
+}
+
+// for more explicit unsafe zones
+#[allow(unused_unsafe)]
+pub unsafe fn from_bytes_slice<U>(bytes: &mut [u8]) -> &mut [U] {
+    debug_assert!(bytes.len() % size_of::<U>() == 0, "Types are not aligned");
+
+    // SAFETY: Caller must guarantee that transmute<u8, U> no has side effects.
+    let (a, slice, b) = unsafe { bytes.align_to_mut() };
+    assert!(a.is_empty());
+    assert!(b.is_empty());
+    slice
+}
+
+// UNSAFE
+// wrapper for `.pipe` function
+pub fn safety_from_bytes_slice<U>(bytes: &mut [u8]) -> &mut [U] {
+    // SAFETY: the safety contract for `self::from_bytes_slice` must
+    // be upheld by the caller.
+    unsafe { from_bytes_slice::<U>(bytes) }
+}
+
+#[cfg(all(test, not(miri)))]
+mod quick_tests {
+    use super::*;
+    use quickcheck_macros::quickcheck;
+    use std::ptr::NonNull;
+
+    #[quickcheck]
+    fn align_to_from(data: Vec<usize>) -> bool {
+        let slice = data.as_slice();
+        let ptr = NonNull::from(slice);
+
+        let new_ptr: NonNull<_> = guaranteed_from_bytes(to_bytes(ptr));
+
+        let new_slice = unsafe { ptr.as_ref() };
+        ptr == new_ptr && slice == new_slice
+    }
+
+    #[quickcheck]
+    fn align_slice(mut data: Vec<u8>) -> bool {
+        let cloned = data.clone();
+        let slice = data.as_mut_slice();
+
+        let new_slice: &[u8] = unsafe { from_bytes_slice(slice) };
+        new_slice == cloned.as_slice()
+    }
+}
diff --git a/rust/doublets-patched/dev-deps/mem-rs/src/lib.rs b/rust/doublets-patched/dev-deps/mem-rs/src/lib.rs
new file mode 100644
index 0000000..c6d1bb3
--- /dev/null
+++ b/rust/doublets-patched/dev-deps/mem-rs/src/lib.rs
@@ -0,0 +1,70 @@
+#![feature(nonnull_slice_from_raw_parts)]
+#![feature(allocator_api)]
+#![feature(try_blocks)]
+#![feature(slice_ptr_get)]
+#![cfg_attr(not(test), forbid(clippy::unwrap_used))]
+#![warn(
+    clippy::perf,
+    clippy::single_match_else,
+    clippy::dbg_macro,
+    clippy::doc_markdown,
+    clippy::wildcard_imports,
+    clippy::struct_excessive_bools,
+    clippy::semicolon_if_nothing_returned,
+    clippy::pedantic,
+    clippy::nursery
+)]
+// for `clippy::pedantic`
+#![allow(
+    clippy::missing_errors_doc,
+    clippy::missing_panics_doc,
+    clippy::missing_safety_doc,
+    clippy::let_underscore_drop,
+    clippy::non_send_fields_in_send_ty
+)]
+#![deny(
+    clippy::all,
+    clippy::cast_lossless,
+    clippy::redundant_closure_for_method_calls,
+    clippy::use_self,
+    clippy::unnested_or_patterns,
+    clippy::trivially_copy_pass_by_ref,
+    clippy::needless_pass_by_value,
+    clippy::match_wildcard_for_single_variants,
+    clippy::map_unwrap_or,
+    unused_qualifications,
+    unused_import_braces,
+    unused_lifetimes,
+    // unreachable_pub,
+    trivial_numeric_casts,
+    // rustdoc,
+    // missing_debug_implementations,
+    // missing_copy_implementations,
+    deprecated_in_future,
+    meta_variable_misuse,
+    non_ascii_idents,
+    rust_2018_compatibility,
+    rust_2018_idioms,
+    future_incompatible,
+    nonstandard_style,
+)]
+// must be fixed later
+#![allow(clippy::needless_pass_by_value, clippy::comparison_chain)]
+
+pub use alloc::Alloc;
+pub use file_mapped::FileMapped;
+pub use global::Global;
+pub use prealloc::PreAlloc;
+pub use temp_file::TempFile;
+pub use traits::{DEFAULT_PAGE_SIZE, Error, RawMem, Result};
+
+mod alloc;
+mod base;
+mod file_mapped;
+mod global;
+mod internal;
+mod prealloc;
+mod temp_file;
+mod traits;
+
+pub(crate) use base::Base;
diff --git a/rust/doublets-patched/dev-deps/mem-rs/src/prealloc.rs b/rust/doublets-patched/dev-deps/mem-rs/src/prealloc.rs
new file mode 100644
index 0000000..119b551
--- /dev/null
+++ b/rust/doublets-patched/dev-deps/mem-rs/src/prealloc.rs
@@ -0,0 +1,50 @@
+use crate::{Error, RawMem, Result};
+use std::marker::PhantomData;
+use tap::TapOptional;
+
+/// [`RawMem`] that own any type that provides refs to memory block
+/// (<code>[`AsMut<[T]>`] + [`AsRef<[T]>`]</code>)
+pub struct PreAlloc<T, D> {
+    data: D,
+    allocated: usize,
+    // unlike other implementations dropck escape-hatch store in `D`
+    // but `T` is unused :)
+    marker: PhantomData<T>,
+}
+
+impl<T, D> PreAlloc<T, D> {
+    /// Constructs new `PreAlloc`
+    pub const fn new(data: D) -> Self {
+        Self {
+            data,
+            allocated: 0,
+            marker: PhantomData,
+        }
+    }
+}
+
+impl<T, D: AsMut<[T]> + AsRef<[T]>> RawMem<T> for PreAlloc<T, D> {
+    fn alloc(&mut self, capacity: usize) -> Result<&mut [T]> {
+        let slice = self.data.as_mut();
+        let available = slice.len();
+        slice
+            .get_mut(0..capacity)
+            // equivalent `Some::inspect` but stable and has more logic name than `inspect`
+            .tap_some(|_| {
+                // set `allocated` if data is valid
+                self.allocated = capacity;
+            })
+            .ok_or(Error::OverAlloc {
+                available,
+                to_alloc: capacity,
+            })
+    }
+
+    fn allocated(&self) -> usize {
+        self.allocated
+    }
+
+    fn size_hint(&self) -> usize {
+        self.data.as_ref().len()
+    }
+}
diff --git a/rust/doublets-patched/dev-deps/mem-rs/src/temp_file.rs b/rust/doublets-patched/dev-deps/mem-rs/src/temp_file.rs
new file mode 100644
index 0000000..976dda8
--- /dev/null
+++ b/rust/doublets-patched/dev-deps/mem-rs/src/temp_file.rs
@@ -0,0 +1,34 @@
+use crate::{FileMapped, RawMem, Result};
+use std::{fs::File, io, path::Path};
+
+/// Same as [`FileMapped`], but only allows temporary files
+#[repr(transparent)]
+pub struct TempFile<T>(FileMapped<T>);
+
+impl<T: Default> TempFile<T> {
+    /// Constructs a new `TempFile` with temp file in [`std::env::temp_dir()`]
+    pub fn new() -> io::Result<Self> {
+        Self::from_file(tempfile::tempfile())
+    }
+
+    /// Constructs a new `TempFile` with temp file in the specified directory.
+    pub fn new_in<P: AsRef<Path>>(path: P) -> io::Result<Self> {
+        Self::from_file(tempfile::tempfile_in(path))
+    }
+
+    fn from_file(file: io::Result<File>) -> io::Result<Self> {
+        file.and_then(FileMapped::new).map(Self)
+    }
+}
+
+impl<T: Default> RawMem<T> for TempFile<T> {
+    fn alloc(&mut self, capacity: usize) -> Result<&mut [T]> {
+        self.0.alloc(capacity)
+    }
+
+    fn allocated(&self) -> usize {
+        self.0.allocated()
+    }
+
+    // fixme: delegate all functions from `FileMapped`
+}
diff --git a/rust/doublets-patched/dev-deps/mem-rs/src/traits.rs b/rust/doublets-patched/dev-deps/mem-rs/src/traits.rs
new file mode 100644
index 0000000..e392f1e
--- /dev/null
+++ b/rust/doublets-patched/dev-deps/mem-rs/src/traits.rs
@@ -0,0 +1,197 @@
+use std::alloc::{AllocError, LayoutError};
+
+// Bare metal platforms usually have very small amounts of RAM
+// (in the order of hundreds of KB)
+/// RAM page size which is likely to be the same on most systems
+#[rustfmt::skip]
+pub const DEFAULT_PAGE_SIZE: usize = if cfg!(target_os = "espidf") { 512 } else { 8 * 1024 };
+
+/// Error memory allocation
+// fixme: maybe we should add `(X bytes)` after `cannot allocate/occupy`
+#[derive(thiserror::Error, Debug)]
+#[non_exhaustive]
+pub enum Error {
+    /// Error due to the computed capacity exceeding the maximum
+    /// (usually `usize::MAX` bytes).
+    ///
+    /// # Examples
+    ///
+    /// try grow/shrink more than `usize::MAX` bytes:
+    ///
+    /// ```
+    /// use platform_mem::{Error, Global, RawMem};
+    ///
+    /// let mut mem = Global::<usize>::new();
+    ///
+    /// let _ = mem.alloc(128);
+    ///
+    /// assert!(matches!(mem.grow(usize::MAX), Err(Error::CapacityOverflow)));
+    /// assert!(matches!(mem.shrink(usize::MAX), Err(Error::CapacityOverflow)));
+    /// ```
+    #[error("invalid capacity to RawMem::alloc/occupy/grow/shrink")]
+    CapacityOverflow,
+    /// Cannot to `allocate` more than `available`
+    ///
+    /// # Examples
+    ///
+    /// try to allocate more than `available` elements:
+    ///
+    /// ```
+    /// use platform_mem::{Error, PreAlloc, RawMem};
+    ///
+    /// let mut mem = PreAlloc::new(vec![0_usize; 64]);
+    ///
+    /// assert!(matches!(mem.alloc(128), Err(Error::OverAlloc { available: 64, to_alloc: 128 })));
+    #[error("cannot allocate {to_alloc} - available only {available}")]
+    OverAlloc { available: usize, to_alloc: usize },
+    /// Memory allocator return an error
+    /// This error won't happen,
+    /// but it may reveal buggy `RawMem` implementation.
+    #[error(transparent)]
+    AllocError(#[from] AllocError),
+    /// Memory allocator accept incorrect [`Layout`]
+    /// This error won't happen,
+    /// but it may reveal buggy `RawMem` implementation.
+    ///
+    /// [`Layout`]: std::alloc::Layout
+    #[error(transparent)]
+    LayoutError(#[from] LayoutError),
+    /// System error memory allocation occurred
+    #[error(transparent)]
+    System(#[from] std::io::Error),
+}
+
+/// Alias for `Result<T, Error>` to return from `RawMem` methods
+pub type Result<T> = std::result::Result<T, Error>;
+
+/// The implementation of `RawMem` can allocate, increase, decrease one arbitrary block
+/// of elements of the `T` type
+///
+/// Only one block can exist at time, so mut slice `&mut [T]` is returned to it
+///
+/// # Examples
+///
+/// Basic usage:
+///
+/// ```
+/// #![feature(allocator_api)]
+///
+/// use std::alloc::Global;
+/// use platform_mem::{RawMem, Alloc};
+///
+/// // `RawMem` when alloc memory via any `Allocator`
+/// let mut mem = Alloc::<usize, _>::new(Global);
+/// let slice = mem.alloc(10).unwrap();
+///
+/// slice.copy_from_slice(&[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+///
+/// // get new ref after realloc
+/// let slice = mem.grow(10).unwrap();
+/// assert_eq!(slice, &[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
+///
+/// slice[0..5].reverse();
+///
+/// let slice = mem.shrink(15).unwrap();
+/// assert_eq!(slice, &[5, 4, 3, 2, 1]);
+/// ```
+pub trait RawMem<T> {
+    /// Allocate or reserve a block of memory of the given `capacity`.
+    /// If block is already allocated, it will be shrink or grow with data retention.
+    ///
+    /// # Examples
+    ///
+    /// Basic usage:
+    ///
+    /// ```
+    /// // alloc mem via `std::alloc`
+    /// use platform_mem::{RawMem, Global};
+    ///
+    /// let mut mem = Global::<usize>::new();
+    ///
+    /// let slice = mem.alloc(10).unwrap();
+    /// assert_eq!(slice.len(), 10);
+    ///
+    /// let slice = mem.alloc(20).unwrap();
+    /// assert_eq!(slice.len(), 20);
+    fn alloc(&mut self, capacity: usize) -> Result<&mut [T]>;
+
+    /// Current allocated elements count. Must be equal `alloc` result length.
+    ///
+    /// # Examples
+    ///
+    /// Basic usage:
+    ///
+    /// ```
+    /// use platform_mem::{RawMem, Global};
+    ///
+    /// let mut mem = Global::<usize>::new();
+    ///
+    /// let slice = mem.alloc(10).unwrap();
+    /// assert_eq!(slice.len(), mem.allocated());
+    /// ```
+    fn allocated(&self) -> usize;
+
+    /// Returns the boundary (in count of elements) on the available elements.
+    ///
+    /// A [`usize::MAX`] here means that `RawMem` can allocate memory indefinitely
+    /// (as long as the system allows)
+    ///
+    /// # Implementation notes
+    ///
+    /// It is not enforced that an `RawMem` implementation yields the declared available elements.
+    /// A buggy `RawMem` may yield less than  the upper bound of elements.
+    ///
+    /// `size_hint()` is primarily intended to be used for limited `RawMem` implementors,
+    /// for example, reserving space without getting an error
+    /// when the available memory limit is exceeded
+    ///
+    /// The default implementation returns [`usize::MAX`] which is correct for any `RawMem`,
+    /// but it can interfere when approaching the boundary of available elements
+    ///
+    /// # Examples
+    ///
+    /// Basic usage:
+    ///
+    /// ```
+    /// use std::cmp::min;
+    /// use platform_mem::{PreAlloc, RawMem};
+    ///
+    /// let mut mem = PreAlloc::new(vec![0; 100]);
+    ///
+    /// let crazy_capacity = usize::MAX;
+    /// let _ = mem.alloc(crazy_capacity).unwrap_err();
+    ///
+    /// let smart_capacity = min(crazy_capacity, mem.size_hint());
+    /// let block = mem.alloc(smart_capacity).unwrap();
+    ///
+    /// assert_eq!(block.len(), 100);
+    /// ```
+    // fixme: maybe this should be return Option<usize> and None by default?
+    fn size_hint(&self) -> usize {
+        usize::MAX
+    }
+
+    /// Attempts to grow occupied memory.
+    ///
+    /// # Errors
+    ///
+    /// Returns error if the `allocated + capacity` overflowing
+    fn grow(&mut self, capacity: usize) -> Result<&mut [T]> {
+        self.allocated()
+            .checked_add(capacity)
+            .ok_or(Error::CapacityOverflow)
+            .and_then(|capacity| self.alloc(capacity))
+    }
+
+    /// Attempts to shrink the memory block.
+    ///
+    /// # Errors
+    ///
+    /// Returns error if the `allocated - capacity` overflowing
+    fn shrink(&mut self, capacity: usize) -> Result<&mut [T]> {
+        self.allocated()
+            .checked_sub(capacity)
+            .ok_or(Error::CapacityOverflow)
+            .and_then(|capacity| self.alloc(capacity))
+    }
+}
diff --git a/rust/doublets-patched/dev-deps/mem-rs/tests/basic.rs b/rust/doublets-patched/dev-deps/mem-rs/tests/basic.rs
new file mode 100644
index 0000000..f3116da
--- /dev/null
+++ b/rust/doublets-patched/dev-deps/mem-rs/tests/basic.rs
@@ -0,0 +1,57 @@
+#![feature(allocator_api)]
+
+mod internal;
+
+use platform_mem::{RawMem, Result};
+
+fn basic_impl(mut mem: impl RawMem<usize>) -> Result<()> {
+    let slice = mem.alloc(10)?;
+    assert_eq!(slice.len(), 10);
+
+    slice.iter_mut().enumerate().for_each(|(i, x)| *x = i);
+
+    assert_eq!(slice, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
+
+    let slice = mem.alloc(20)?;
+    assert_eq!(slice.len(), 20);
+    slice.iter_mut().enumerate().for_each(|(i, x)| *x = i);
+
+    assert_eq!(
+        slice,
+        [
+            0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19
+        ]
+    );
+
+    Ok(())
+}
+
+fn non_default_inner_impl(mut mem: impl RawMem<String>) -> Result<()> {
+    let slice = mem.alloc(10)?;
+
+    slice
+        .iter_mut()
+        .enumerate()
+        .for_each(|(i, x)| *x = i.to_string());
+
+    assert_eq!(slice, ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"]);
+
+    let slice = mem.alloc(20)?;
+    slice
+        .iter_mut()
+        .enumerate()
+        .for_each(|(i, x)| *x = i.to_string());
+
+    assert_eq!(
+        slice,
+        [
+            "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15",
+            "16", "17", "18", "19"
+        ]
+    );
+
+    Ok(())
+}
+
+test_for_all_mem!(basic, basic_impl);
+test_for_all_mem!(non_default_inner, non_default_inner_impl);
diff --git a/rust/doublets-patched/dev-deps/mem-rs/tests/internal.rs b/rust/doublets-patched/dev-deps/mem-rs/tests/internal.rs
new file mode 100644
index 0000000..5eab2de
--- /dev/null
+++ b/rust/doublets-patched/dev-deps/mem-rs/tests/internal.rs
@@ -0,0 +1,27 @@
+#[allow(dead_code)]
+pub fn pre_allocated<T: Default>(len: usize) -> Vec<T> {
+    (0..len).map(|_| T::default()).collect()
+}
+
+#[macro_export]
+macro_rules! test_for_all_mem {
+    ($test:ident, $impl:ident) => {
+        paste::paste! {
+            #[test]
+            fn [<$test _global>]() { $impl(platform_mem::Global::new()).unwrap(); }
+
+            #[test]
+            fn [<$test _alloc>]() { $impl(platform_mem::Alloc::new(std::alloc::Global)).unwrap(); }
+
+            // also test `FileMapped`
+            #[test]
+            #[cfg(not(miri))]
+            fn [<$test _temp_file>]() { $impl(platform_mem::TempFile::new().unwrap()).unwrap(); }
+
+            #[test]
+            fn [<$test _pre_alloc>]() {
+                $impl(platform_mem::PreAlloc::new(internal::pre_allocated(100))).unwrap();
+            }
+        }
+    };
+}
diff --git a/rust/doublets-patched/dev-deps/mem-rs/tests/prealloc.rs b/rust/doublets-patched/dev-deps/mem-rs/tests/prealloc.rs
new file mode 100644
index 0000000..f6811ed
--- /dev/null
+++ b/rust/doublets-patched/dev-deps/mem-rs/tests/prealloc.rs
@@ -0,0 +1,79 @@
+#![feature(allocator_api)]
+
+use platform_mem::{PreAlloc, RawMem};
+use quickcheck_macros::quickcheck;
+use std::error::Error;
+
+#[test]
+fn basic() -> Result<(), Box<dyn Error>> {
+    let prealloc = [0usize; 20];
+
+    let mut mem = PreAlloc::new(prealloc);
+    let slice = mem.alloc(10)?;
+
+    assert_eq!(slice.len(), 10);
+
+    slice.iter_mut().enumerate().for_each(|(i, x)| *x = i);
+
+    assert_eq!(slice, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
+
+    let slice = mem.alloc(20)?;
+    assert_eq!(slice.len(), 20);
+    slice.iter_mut().enumerate().for_each(|(i, x)| *x = i);
+
+    assert_eq!(
+        slice,
+        [
+            0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19
+        ]
+    );
+    Ok(())
+}
+
+#[test]
+fn with_non_default_inner() -> Result<(), Box<dyn Error>> {
+    // fixme: RFC #2920
+    //  let prealloc = [String::new(); 20];
+    let prealloc: Vec<_> = (0..20).map(|_| String::new()).collect();
+
+    let mut mem = PreAlloc::new(prealloc);
+    let slice = mem.alloc(10)?;
+    assert_eq!(slice.len(), 10);
+
+    slice
+        .iter_mut()
+        .enumerate()
+        .for_each(|(i, x)| *x = i.to_string());
+
+    assert_eq!(slice, ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"]);
+
+    let slice = mem.alloc(20)?;
+    assert_eq!(slice.len(), 20);
+    slice
+        .iter_mut()
+        .enumerate()
+        .for_each(|(i, x)| *x = i.to_string());
+
+    assert_eq!(
+        slice,
+        [
+            "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15",
+            "16", "17", "18", "19"
+        ]
+    );
+    Ok(())
+}
+
+#[cfg(not(miri))]
+#[quickcheck]
+fn valid_allocated_after_error(prealloc: Vec<usize>, capacity: usize) -> bool {
+    let len = prealloc.len();
+    let mut mem = PreAlloc::new(prealloc);
+    let result = mem.alloc(capacity);
+
+    (if capacity <= len {
+        result.is_ok() && mem.allocated() == capacity
+    } else {
+        result.is_err() && mem.allocated() == 0
+    }) && mem.size_hint() >= len
+}
diff --git a/rust/doublets-patched/dev-deps/mem-rs/tests/shrink_drop.rs b/rust/doublets-patched/dev-deps/mem-rs/tests/shrink_drop.rs
new file mode 100644
index 0000000..21a1389
--- /dev/null
+++ b/rust/doublets-patched/dev-deps/mem-rs/tests/shrink_drop.rs
@@ -0,0 +1,42 @@
+#![feature(allocator_api)]
+#![feature(thread_local)]
+
+mod internal;
+
+use platform_mem::{Alloc, Global, RawMem, Result};
+use std::alloc;
+
+static mut DROP_COUNT: usize = 0;
+
+// Not allowed zero size types
+#[derive(Default)]
+struct DropCounter(usize);
+
+impl Drop for DropCounter {
+    fn drop(&mut self) {
+        unsafe {
+            DROP_COUNT += 1;
+        }
+    }
+}
+
+fn shrink_drop_impl(mut mem: impl RawMem<DropCounter>) -> Result<()> {
+    let _ = mem.alloc(20)?;
+    let _ = mem.shrink(5)?;
+
+    unsafe {
+        assert_eq!(DROP_COUNT, 5);
+        drop(mem);
+        DROP_COUNT = 0;
+    }
+
+    Ok(())
+}
+
+#[test]
+fn shrink_drop() {
+    shrink_drop_impl(Global::new()).unwrap();
+    shrink_drop_impl(Alloc::new(alloc::Global)).unwrap();
+    #[cfg(not(miri))]
+    shrink_drop_impl(platform_mem::TempFile::new().unwrap()).unwrap();
+}
diff --git a/rust/doublets-patched/dev-deps/trees-rs/Cargo.toml b/rust/doublets-patched/dev-deps/trees-rs/Cargo.toml
new file mode 100644
index 0000000..c0504cd
--- /dev/null
+++ b/rust/doublets-patched/dev-deps/trees-rs/Cargo.toml
@@ -0,0 +1,15 @@
+[package]
+name = "platform-trees"
+version = "0.1.0-beta.1"
+edition = "2018"
+authors = ["uselesssgoddess", "Linksplatform Team <linksplatformtechnologies@gmail.com>"]
+license = "LGPL-3.0"
+repository = "https://github.com/linksplatform/Collections.Methods"
+homepage = "https://github.com/linksplatform/Collections.Methods/rust"
+description = """
+Trees methods for linksplatform
+"""
+
+[dependencies]
+funty = "2.0"
+platform-data = { version = "0.1.0-beta.3", path = "../data-rs" }
diff --git a/rust/doublets-patched/dev-deps/trees-rs/LICENSE b/rust/doublets-patched/dev-deps/trees-rs/LICENSE
new file mode 100644
index 0000000..6bb8a29
--- /dev/null
+++ b/rust/doublets-patched/dev-deps/trees-rs/LICENSE
@@ -0,0 +1,24 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+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 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.
+
+For more information, please refer to <http://unlicense.org>
\ No newline at end of file
diff --git a/rust/doublets-patched/dev-deps/trees-rs/src/lib.rs b/rust/doublets-patched/dev-deps/trees-rs/src/lib.rs
new file mode 100644
index 0000000..514f1e5
--- /dev/null
+++ b/rust/doublets-patched/dev-deps/trees-rs/src/lib.rs
@@ -0,0 +1,11 @@
+// fixme: #![no_std]
+
+mod lists;
+mod trees;
+
+pub use lists::{
+    AbsoluteCircularLinkedList, AbsoluteLinkedList, LinkedList, RelativeCircularLinkedList,
+    RelativeLinkedList,
+};
+
+pub use trees::{NoRecurSzbTree, SzbTree};
diff --git a/rust/doublets-patched/dev-deps/trees-rs/src/lists/absolute_circular_linked_list.rs b/rust/doublets-patched/dev-deps/trees-rs/src/lists/absolute_circular_linked_list.rs
new file mode 100644
index 0000000..ee278f8
--- /dev/null
+++ b/rust/doublets-patched/dev-deps/trees-rs/src/lists/absolute_circular_linked_list.rs
@@ -0,0 +1,71 @@
+use crate::AbsoluteLinkedList;
+use platform_data::LinkType;
+
+pub trait AbsoluteCircularLinkedList<T: LinkType>: AbsoluteLinkedList<T> {
+    fn attach_before(&mut self, base_element: T, new_element: T) {
+        let base_element_previous = self.get_previous(base_element);
+        self.set_previous(new_element, base_element_previous);
+        self.set_next(new_element, base_element);
+        if base_element == self.get_first() {
+            self.set_first(new_element);
+        }
+        self.set_next(base_element_previous, new_element);
+        self.set_previous(base_element, new_element);
+        self.inc_size();
+    }
+
+    fn attach_after(&mut self, base_element: T, new_element: T) {
+        let base_element_next = self.get_next(base_element);
+        self.set_previous(new_element, base_element);
+        self.set_next(new_element, base_element_next);
+        if base_element == self.get_last() {
+            self.set_last(new_element);
+        }
+        self.set_previous(base_element_next, new_element);
+        self.set_next(base_element, new_element);
+        self.inc_size();
+    }
+
+    fn attach_as_first(&mut self, element: T) {
+        let first = self.get_first();
+        if first == T::funty(0) {
+            self.set_first(element);
+            self.set_last(element);
+            self.set_previous(element, element);
+            self.set_next(element, element);
+            self.inc_size();
+        } else {
+            self.attach_before(first, element);
+        }
+    }
+
+    fn attach_as_last(&mut self, element: T) {
+        let last = self.get_last();
+        if last == T::funty(0) {
+            self.attach_as_first(element);
+        } else {
+            self.attach_after(last, element);
+        }
+    }
+
+    fn detach(&mut self, element: T) {
+        let element_previous = self.get_previous(element);
+        let element_next = self.get_next(element);
+        if element_next == element {
+            self.set_first(T::funty(0));
+            self.set_last(T::funty(0));
+        } else {
+            self.set_next(element_previous, element_next);
+            self.set_previous(element_next, element_previous);
+            if element == self.get_first() {
+                self.set_first(element_next);
+            }
+            if element == self.get_last() {
+                self.set_last(element_previous);
+            }
+        }
+        self.set_previous(element, T::funty(0));
+        self.set_next(element, T::funty(0));
+        self.dec_size();
+    }
+}
diff --git a/rust/doublets-patched/dev-deps/trees-rs/src/lists/absolute_linked_list.rs b/rust/doublets-patched/dev-deps/trees-rs/src/lists/absolute_linked_list.rs
new file mode 100644
index 0000000..6f91c59
--- /dev/null
+++ b/rust/doublets-patched/dev-deps/trees-rs/src/lists/absolute_linked_list.rs
@@ -0,0 +1,19 @@
+use crate::LinkedList;
+use platform_data::LinkType;
+
+pub trait AbsoluteLinkedList<T: LinkType>: LinkedList<T> {
+    fn get_first(&self) -> T;
+    fn get_last(&self) -> T;
+    fn get_size(&self) -> T;
+
+    fn set_first(&mut self, element: T);
+    fn set_last(&mut self, element: T);
+    fn set_size(&mut self, size: T);
+
+    fn inc_size(&mut self) {
+        self.set_size(self.get_size() + T::funty(1))
+    }
+    fn dec_size(&mut self) {
+        self.set_size(self.get_size() - T::funty(1))
+    }
+}
diff --git a/rust/doublets-patched/dev-deps/trees-rs/src/lists/linked_list.rs b/rust/doublets-patched/dev-deps/trees-rs/src/lists/linked_list.rs
new file mode 100644
index 0000000..771f378
--- /dev/null
+++ b/rust/doublets-patched/dev-deps/trees-rs/src/lists/linked_list.rs
@@ -0,0 +1,9 @@
+use platform_data::LinkType;
+
+pub trait LinkedList<T: LinkType> {
+    fn get_previous(&self, element: T) -> T;
+    fn get_next(&self, element: T) -> T;
+
+    fn set_previous(&mut self, element: T, previous: T);
+    fn set_next(&mut self, element: T, next: T);
+}
diff --git a/rust/doublets-patched/dev-deps/trees-rs/src/lists/mod.rs b/rust/doublets-patched/dev-deps/trees-rs/src/lists/mod.rs
new file mode 100644
index 0000000..b86462f
--- /dev/null
+++ b/rust/doublets-patched/dev-deps/trees-rs/src/lists/mod.rs
@@ -0,0 +1,12 @@
+mod absolute_circular_linked_list;
+mod absolute_linked_list;
+mod linked_list;
+mod relative_circular_linked_list;
+mod relative_doubly_linked_list;
+
+// TODO: use human names
+pub use absolute_circular_linked_list::AbsoluteCircularLinkedList;
+pub use absolute_linked_list::AbsoluteLinkedList;
+pub use linked_list::LinkedList;
+pub use relative_circular_linked_list::RelativeCircularLinkedList;
+pub use relative_doubly_linked_list::RelativeLinkedList;
diff --git a/rust/doublets-patched/dev-deps/trees-rs/src/lists/relative_circular_linked_list.rs b/rust/doublets-patched/dev-deps/trees-rs/src/lists/relative_circular_linked_list.rs
new file mode 100644
index 0000000..a161e33
--- /dev/null
+++ b/rust/doublets-patched/dev-deps/trees-rs/src/lists/relative_circular_linked_list.rs
@@ -0,0 +1,71 @@
+use crate::RelativeLinkedList;
+use platform_data::LinkType;
+
+pub trait RelativeCircularLinkedList<T: LinkType>: RelativeLinkedList<T> {
+    fn attach_before(&mut self, head: T, base_element: T, new_element: T) {
+        let base_element_previous = self.get_previous(base_element);
+        self.set_previous(new_element, base_element_previous);
+        self.set_next(new_element, base_element);
+        if base_element == self.get_first(head) {
+            self.set_first(head, new_element);
+        }
+        self.set_next(base_element_previous, new_element);
+        self.set_previous(base_element, new_element);
+        self.inc_size(head);
+    }
+
+    fn attach_after(&mut self, head: T, base_element: T, new_element: T) {
+        let base_element_next = self.get_next(base_element);
+        self.set_previous(new_element, base_element);
+        self.set_next(new_element, base_element_next);
+        if base_element == self.get_last(head) {
+            self.set_last(head, new_element);
+        }
+        self.set_previous(base_element_next, new_element);
+        self.set_next(base_element, new_element);
+        self.inc_size(head);
+    }
+
+    fn attach_as_first(&mut self, head: T, element: T) {
+        let first = self.get_first(head);
+        if first == T::funty(0) {
+            self.set_first(head, element);
+            self.set_last(head, element);
+            self.set_previous(element, element);
+            self.set_next(element, element);
+            self.inc_size(head);
+        } else {
+            self.attach_before(head, first, element);
+        }
+    }
+
+    fn attach_as_last(&mut self, head: T, element: T) {
+        let last = self.get_last(head);
+        if last == T::funty(0) {
+            self.attach_as_first(head, element);
+        } else {
+            self.attach_after(head, last, element);
+        }
+    }
+
+    fn detach(&mut self, head: T, element: T) {
+        let element_previous = self.get_previous(element);
+        let element_next = self.get_next(element);
+        if element_next == element {
+            self.set_first(head, T::funty(0));
+            self.set_last(head, T::funty(0));
+        } else {
+            self.set_next(element_previous, element_next);
+            self.set_previous(element_next, element_previous);
+            if element == self.get_first(head) {
+                self.set_first(head, element_next);
+            }
+            if element == self.get_last(head) {
+                self.set_last(head, element_previous);
+            }
+        }
+        self.set_previous(element, T::funty(0));
+        self.set_next(element, T::funty(0));
+        self.dec_size(head);
+    }
+}
diff --git a/rust/doublets-patched/dev-deps/trees-rs/src/lists/relative_doubly_linked_list.rs b/rust/doublets-patched/dev-deps/trees-rs/src/lists/relative_doubly_linked_list.rs
new file mode 100644
index 0000000..d7c7052
--- /dev/null
+++ b/rust/doublets-patched/dev-deps/trees-rs/src/lists/relative_doubly_linked_list.rs
@@ -0,0 +1,19 @@
+use crate::LinkedList;
+use platform_data::LinkType;
+
+pub trait RelativeLinkedList<T: LinkType>: LinkedList<T> {
+    fn get_first(&self, head: T) -> T;
+    fn get_last(&self, head: T) -> T;
+    fn get_size(&self, head: T) -> T;
+
+    fn set_first(&mut self, head: T, element: T);
+    fn set_last(&mut self, head: T, element: T);
+    fn set_size(&mut self, head: T, size: T);
+
+    fn inc_size(&mut self, head: T) {
+        self.set_size(head, self.get_size(head) + T::funty(1))
+    }
+    fn dec_size(&mut self, head: T) {
+        self.set_size(head, self.get_size(head) - T::funty(1))
+    }
+}
diff --git a/rust/doublets-patched/dev-deps/trees-rs/src/trees/mod.rs b/rust/doublets-patched/dev-deps/trees-rs/src/trees/mod.rs
new file mode 100644
index 0000000..cf576da
--- /dev/null
+++ b/rust/doublets-patched/dev-deps/trees-rs/src/trees/mod.rs
@@ -0,0 +1,5 @@
+mod no_recur_szb_tree;
+mod szb_tree;
+
+pub use no_recur_szb_tree::NoRecurSzbTree;
+pub use szb_tree::SzbTree;
diff --git a/rust/doublets-patched/dev-deps/trees-rs/src/trees/no_recur_szb_tree.rs b/rust/doublets-patched/dev-deps/trees-rs/src/trees/no_recur_szb_tree.rs
new file mode 100644
index 0000000..526ec7f
--- /dev/null
+++ b/rust/doublets-patched/dev-deps/trees-rs/src/trees/no_recur_szb_tree.rs
@@ -0,0 +1,153 @@
+use platform_data::LinkType;
+
+use crate::SzbTree;
+
+pub trait NoRecurSzbTree<T: LinkType>: SzbTree<T> {
+    unsafe fn attach(&mut self, root: *mut T, node: T) {
+        if *root == T::funty(0) {
+            self.set_size(node, T::funty(1));
+            *root = node;
+            return;
+        }
+        self.attach_core(root, node);
+    }
+    unsafe fn detach(&mut self, root: *mut T, node: T) {
+        self.detach_core(root, node);
+    }
+
+    unsafe fn attach_core(&mut self, mut root: *mut T, node: T) {
+        loop {
+            let left = self.get_mut_left_reference(*root);
+            let left_size = self.get_size_or_zero(*left);
+            let right = self.get_mut_right_reference(*root);
+            let right_size = self.get_size_or_zero(*right);
+            if self.first_is_to_the_left_of_second(node, *root) {
+                if *left == T::funty(0) {
+                    self.inc_size(*root);
+                    self.set_size(node, T::funty(1));
+                    *left = node;
+                    return;
+                }
+                if self.first_is_to_the_left_of_second(node, *left) {
+                    if (left_size + T::funty(1)) > right_size {
+                        self.right_rotate(root);
+                    } else {
+                        self.inc_size(*root);
+                        root = left;
+                    }
+                } else {
+                    let left_right_size = self.get_size_or_zero(self.get_right(*left));
+                    if (left_right_size + T::funty(1)) > right_size {
+                        if left_right_size == T::funty(0) && right_size == T::funty(0) {
+                            self.set_left(node, *left);
+                            self.set_right(node, *root);
+                            self.set_size(node, left_size + T::funty(1) + T::funty(1));
+                            self.set_left(*root, T::funty(0));
+                            self.set_size(*root, T::funty(1));
+                            *root = node;
+                            return;
+                        }
+                        self.left_rotate(left);
+                        self.right_rotate(root);
+                    } else {
+                        self.inc_size(*root);
+                        root = left;
+                    }
+                }
+            } else {
+                if *right == T::funty(0) {
+                    self.inc_size(*root);
+                    self.set_size(node, T::funty(1));
+                    *right = node;
+                    return;
+                }
+                if self.first_is_to_the_right_of_second(node, *right) {
+                    if (right_size + T::funty(1)) > left_size {
+                        self.left_rotate(root);
+                    } else {
+                        self.inc_size(*root);
+                        root = right;
+                    }
+                } else {
+                    let right_left_size = self.get_size_or_zero(self.get_left(*right));
+                    if (right_left_size + T::funty(1)) > left_size {
+                        if right_left_size == T::funty(0) && left_size == T::funty(0) {
+                            self.set_left(node, *root);
+                            self.set_right(node, *right);
+                            self.set_size(node, right_size + T::funty(1) + T::funty(1));
+                            self.set_right(*root, T::funty(0));
+                            self.set_size(*root, T::funty(1));
+                            *root = node;
+                            return;
+                        }
+                        self.right_rotate(right);
+                        self.left_rotate(root);
+                    } else {
+                        self.inc_size(*root);
+                        root = right;
+                    }
+                }
+            }
+        }
+    }
+
+    unsafe fn detach_core(&mut self, mut root: *mut T, node: T) {
+        loop {
+            let left = self.get_mut_left_reference(*root);
+            let left_size = self.get_size_or_zero(*left);
+            let right = self.get_mut_right_reference(*root);
+            let right_size = self.get_size_or_zero(*right);
+            if self.first_is_to_the_left_of_second(node, *root) {
+                let decremented_left_size = left_size - T::funty(1);
+                if self.get_size_or_zero(self.get_right_or_default(*right)) > decremented_left_size
+                {
+                    self.left_rotate(root);
+                } else if self.get_size_or_zero(self.get_left_or_default(*right))
+                    > decremented_left_size
+                {
+                    self.right_rotate(right);
+                    self.left_rotate(root);
+                } else {
+                    self.dec_size(*root);
+                    root = left;
+                }
+            } else if self.first_is_to_the_right_of_second(node, *root) {
+                let decremented_right_size = right_size - T::funty(1);
+                if self.get_size_or_zero(self.get_left_or_default(*left)) > decremented_right_size {
+                    self.right_rotate(root);
+                } else if self.get_size_or_zero(self.get_right_or_default(*left))
+                    > decremented_right_size
+                {
+                    self.left_rotate(left);
+                    self.right_rotate(root);
+                } else {
+                    self.dec_size(*root);
+                    root = right;
+                }
+            } else {
+                if left_size > T::funty(0) && right_size > T::funty(0) {
+                    let replacement;
+                    if left_size > right_size {
+                        replacement = self.get_rightest(*left);
+                        self.detach_core(left, replacement);
+                    } else {
+                        replacement = self.get_leftest(*right);
+                        self.detach_core(right, replacement);
+                    }
+                    self.set_left(replacement, *left);
+                    self.set_right(replacement, *right);
+                    self.set_size(replacement, left_size + right_size);
+                    *root = replacement;
+                } else if left_size > T::funty(0) {
+                    *root = *left;
+                } else if right_size > T::funty(0) {
+                    *root = *right;
+                } else {
+                    *root = T::funty(0);
+                }
+                self.clear_node(node);
+                return;
+            }
+        }
+    }
+}
diff --git a/rust/doublets-patched/dev-deps/trees-rs/src/trees/szb_tree.rs b/rust/doublets-patched/dev-deps/trees-rs/src/trees/szb_tree.rs
new file mode 100644
index 0000000..dc82d81
--- /dev/null
+++ b/rust/doublets-patched/dev-deps/trees-rs/src/trees/szb_tree.rs
@@ -0,0 +1,145 @@
+use platform_data::LinkType;
+
+pub trait SzbTree<T: LinkType> {
+    unsafe fn get_mut_left_reference(&mut self, node: T) -> *mut T;
+
+    unsafe fn get_mut_right_reference(&mut self, node: T) -> *mut T;
+
+    unsafe fn get_left_reference(&self, node: T) -> *const T;
+
+    unsafe fn get_right_reference(&self, node: T) -> *const T;
+
+    unsafe fn get_left(&self, node: T) -> T;
+
+    unsafe fn get_right(&self, node: T) -> T;
+
+    unsafe fn get_size(&self, node: T) -> T;
+
+    unsafe fn set_left(&mut self, node: T, left: T);
+
+    unsafe fn set_right(&mut self, node: T, right: T);
+
+    unsafe fn set_size(&mut self, node: T, size: T);
+
+    unsafe fn first_is_to_the_left_of_second(&self, first: T, second: T) -> bool;
+
+    unsafe fn first_is_to_the_right_of_second(&self, first: T, second: T) -> bool;
+
+    unsafe fn get_left_or_default(&self, node: T) -> T {
+        if node == T::funty(0) {
+            T::funty(0)
+        } else {
+            self.get_left(node)
+        }
+    }
+
+    unsafe fn get_right_or_default(&self, node: T) -> T {
+        if node == T::funty(0) {
+            T::funty(0)
+        } else {
+            self.get_right(node)
+        }
+    }
+
+    unsafe fn get_size_or_zero(&self, node: T) -> T {
+        if node == T::funty(0) {
+            T::funty(0)
+        } else {
+            self.get_size(node)
+        }
+    }
+
+    unsafe fn inc_size(&mut self, node: T) {
+        self.set_size(node, self.get_size(node) + T::funty(1));
+    }
+
+    unsafe fn dec_size(&mut self, node: T) {
+        self.set_size(node, self.get_size(node) - T::funty(1));
+    }
+
+    unsafe fn get_left_size(&self, node: T) -> T {
+        self.get_size_or_zero(self.get_left_or_default(node))
+    }
+
+    unsafe fn get_right_size(&self, node: T) -> T {
+        self.get_size_or_zero(self.get_right_or_default(node))
+    }
+
+    unsafe fn fix_size(&mut self, node: T) {
+        self.set_size(
+            node,
+            (self.get_left_size(node) + self.get_right_size(node)) + T::funty(1),
+        );
+    }
+
+    unsafe fn left_rotate(&mut self, root: *mut T) {
+        *root = self.left_rotate_core(*root);
+    }
+
+    unsafe fn left_rotate_core(&mut self, root: T) -> T {
+        let right = self.get_right(root);
+        self.set_right(root, self.get_left(right));
+        self.set_left(right, root);
+        self.set_size(right, self.get_size(root));
+        self.fix_size(root);
+        right
+    }
+
+    unsafe fn right_rotate(&mut self, root: *mut T) {
+        *root = self.right_rotate_core(*root);
+    }
+
+    unsafe fn right_rotate_core(&mut self, root: T) -> T {
+        let left = self.get_left(root);
+        self.set_left(root, self.get_right(left));
+        self.set_right(left, root);
+        self.set_size(left, self.get_size(root));
+        self.fix_size(root);
+        left
+    }
+
+    unsafe fn get_rightest(&self, mut current: T) -> T {
+        let mut current_right = self.get_right(current);
+        while current_right != T::funty(0) {
+            current = current_right;
+            current_right = self.get_right(current);
+        }
+        current
+    }
+
+    unsafe fn get_leftest(&self, mut current: T) -> T {
+        let mut current_left = self.get_left(current);
+        while current_left != T::funty(0) {
+            current = current_left;
+            current_left = self.get_left(current);
+        }
+        current
+    }
+
+    unsafe fn get_next(&self, node: T) -> T {
+        self.get_leftest(self.get_right(node))
+    }
+
+    unsafe fn get_previous(&self, node: T) -> T {
+        self.get_rightest(self.get_left(node))
+    }
+
+    unsafe fn contains(&self, node: T, mut root: T) -> bool {
+        while root != T::funty(0) {
+            if self.first_is_to_the_left_of_second(node, root) {
+                root = self.get_left(root);
+            } else if self.first_is_to_the_right_of_second(node, root) {
+                root = self.get_right(root);
+            } else {
+                return true;
+            }
+        }
+        false
+    }
+
+    unsafe fn clear_node(&mut self, node: T) {
+        self.set_left(node, T::funty(0));
+        self.set_right(node, T::funty(0));
+        self.set_size(node, T::funty(0));
+    }
+}
diff --git a/rust/doublets-patched/doublets/Cargo.toml b/rust/doublets-patched/doublets/Cargo.toml
new file mode 100644
index 0000000..3b44398
--- /dev/null
+++ b/rust/doublets-patched/doublets/Cargo.toml
@@ -0,0 +1,63 @@
+[package]
+name = "doublets"
+version = "0.1.0-pre+beta.15"
+edition = "2021"
+authors = [
+    "uselessgoddess",
+    "Linksplatform Team <linksplatformtechnologies@gmail.com>"
+]
+categories = [
+    "database-implementations", # wait rfcs#3185 "asynchronous"
+]
+keywords = [
+    "associative", "doublets", "db",
+]
+readme = "../README.md"
+license = "Unlicense"
+repository = "https://github.com/linksplatform/doublets-rs"
+homepage = "https://github.com/linksplatform/doublets-rs"
+description = """
+"""
+
+[dependencies]
+tap = { version = "1.0.1" }
+cfg-if = { version = "1.0.0" }
+thiserror = { version = "1.0.30" }
+leak_slice = { version = "0.2.0" }
+bumpalo = { version = "3.11.1", features = ["allocator_api", "collections"] }
+
+# platform
+data = { package = "platform-data", path = "../dev-deps/data-rs", version = "0.1.0-beta.1" }
+mem = { package = "platform-mem", version = "0.1.0-pre+beta.2", path = "../dev-deps/mem-rs" }
+trees = { package = "platform-trees", version = "0.1.0-alpha.2", path = "../dev-deps/trees-rs" }
+
+# optional
+smallvec = { version = "1.8.1", features = ["union"], optional = true }
+rayon = { version = "1.5.3", optional = true }
+
+[features]
+mem = []
+num = []
+data = []
+more-inline = []
+small-search = ["smallvec"]
+# todo: may be internal_platform
+platform = ["mem", "num", "data"]
+
+default = ["platform"]
+full = ["platform", "rayon", "small-search"]
+
+[dev-dependencies]
+tap = { version = "1.0.1" }
+rand = { version = "0.8.5" }
+criterion = { version = "0.3.6" }
+bumpalo = { version = "3.11.1", features = ["allocator_api", "collections"] }
+mimalloc = { version = "0.1.29", default-features = false }
+rpmalloc = "0.2.0"
+tinyvec = { version = "1.6.0", features = ["alloc"] }
+smallvec = { version = "1.9.0", features = [] }
+static_assertions = { version = "1.1.0" }
+
+[[bench]]
+name = "iter"
+harness = false
\ No newline at end of file
diff --git a/rust/doublets-patched/doublets/benches/iter.rs b/rust/doublets-patched/doublets/benches/iter.rs
new file mode 100644
index 0000000..4679638
--- /dev/null
+++ b/rust/doublets-patched/doublets/benches/iter.rs
@@ -0,0 +1,63 @@
+use criterion::{black_box, criterion_group, criterion_main, Criterion, Throughput};
+use data::Flow::Continue;
+use doublets::{split::Store, Doublets, DoubletsExt, Links};
+use mem::Global;
+
+fn iter(c: &mut Criterion) {
+    let mut store = Store::<usize, _, _>::new(Global::new(), Global::new()).unwrap();
+    let _any = store.constants().any;
+
+    for _ in 0..1_000_000 {
+        store.create_point().unwrap();
+    }
+
+    (1..=1_000_000).filter(|x| x % 172 == 0).for_each(|x| {
+        store.delete(x).unwrap();
+    });
+
+    c.bench_function("iter", |b| {
+        b.iter(|| {
+            store.iter().for_each(|item| {
+                black_box(item);
+            })
+        });
+    });
+    c.bench_function("each", |b| {
+        b.iter(|| {
+            store.each(|link| {
+                black_box(link);
+                Continue
+            });
+        });
+    });
+    c.bench_function("each_with_vec", |b| {
+        b.iter(|| {
+            let mut vec = Vec::with_capacity(store.count());
+            store.each(|link| {
+                vec.push(black_box(link));
+                Continue
+            });
+            black_box(vec);
+        });
+    });
+}
+
+fn create_point(c: &mut Criterion) {
+    let mut store = Store::<usize, _, _>::new(Global::new(), Global::new()).unwrap();
+
+    let n = 1_000_000;
+
+    let mut group = c.benchmark_group("create_point");
+    group.throughput(Throughput::Elements(n));
+
+    group.bench_function("create_point", |b| {
+        b.iter(|| {
+            for _ in 0..n {
+                store.create_point().unwrap();
+            }
+        });
+    });
+}
+
+criterion_group!(benches, iter, create_point);
+criterion_main!(benches);
diff --git a/rust/doublets-patched/doublets/src/data/doublet.rs b/rust/doublets-patched/doublets/src/data/doublet.rs
new file mode 100644
index 0000000..2a5d39b
--- /dev/null
+++ b/rust/doublets-patched/doublets/src/data/doublet.rs
@@ -0,0 +1,21 @@
+use std::fmt::{Debug, Display, Formatter};
+
+use data::LinkType;
+
+#[derive(Debug, Eq, PartialEq, Hash, Clone)]
+pub struct Doublet<T: LinkType> {
+    pub source: T,
+    pub target: T,
+}
+
+impl<T: LinkType> Doublet<T> {
+    pub fn new(source: T, target: T) -> Self {
+        Self { source, target }
+    }
+}
+
+impl<T: LinkType> Display for Doublet<T> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}->{}", self.source, self.target)
+    }
+}
diff --git a/rust/doublets-patched/doublets/src/data/error.rs b/rust/doublets-patched/doublets/src/data/error.rs
new file mode 100644
index 0000000..5cb0659
--- /dev/null
+++ b/rust/doublets-patched/doublets/src/data/error.rs
@@ -0,0 +1,30 @@
+use crate::{Doublet, Link};
+use data::LinkType;
+use std::{error::Error as StdError, io};
+
+#[derive(thiserror::Error, Debug)]
+pub enum Error<T: LinkType> {
+    #[error("link {0} does not exist.")]
+    NotExists(T),
+
+    #[error("link {0:?} has dependencies")]
+    HasUsages(Vec<Link<T>>),
+
+    #[error("link {0} already exists")]
+    AlreadyExists(Doublet<T>),
+
+    #[error("limit for the number of links in the storage has been reached: {0}")]
+    LimitReached(T),
+
+    #[error("unable to allocate memory for links storage: `{0}`")]
+    AllocFailed(#[from] mem::Error),
+
+    #[error("other internal error: `{0}`")]
+    Other(#[from] Box<dyn StdError + Sync + Send>),
+}
+
+impl<T: LinkType> From<io::Error> for Error<T> {
+    fn from(err: io::Error) -> Self {
+        Self::AllocFailed(err.into())
+    }
+}
diff --git a/rust/doublets-patched/doublets/src/data/handler.rs b/rust/doublets-patched/doublets/src/data/handler.rs
new file mode 100644
index 0000000..ef66d93
--- /dev/null
+++ b/rust/doublets-patched/doublets/src/data/handler.rs
@@ -0,0 +1,95 @@
+use crate::Link;
+use data::{Flow, LinkType};
+use std::{marker::PhantomData, mem::MaybeUninit, ops::Try};
+
+pub trait Handler<T, R>: FnMut(Link<T>, Link<T>) -> R
+where
+    T: LinkType,
+    R: Try<Output = ()>,
+{
+    fn fuse(self) -> Fuse<T, Self, R>
+    where
+        Self: Sized,
+    {
+        Fuse::new(self)
+    }
+}
+
+impl<T, R, All> Handler<T, R> for All
+where
+    T: LinkType,
+    R: Try<Output = ()>,
+    All: FnMut(Link<T>, Link<T>) -> R,
+{
+}
+
+pub struct Fuse<T, H, R>
+where
+    T: LinkType,
+    H: Handler<T, R>,
+    R: Try<Output = ()>,
+{
+    handler: H,
+    done: bool,
+    _marker: PhantomData<fn(T) -> R>,
+}
+
+impl<T, F, R> Fuse<T, F, R>
+where
+    T: LinkType,
+    F: FnMut(Link<T>, Link<T>) -> R,
+    R: Try<Output = ()>,
+{
+    pub fn new(handler: F) -> Self {
+        Self {
+            handler,
+            done: false,
+            _marker: PhantomData,
+        }
+    }
+}
+
+impl<T, H, R> From<H> for Fuse<T, H, R>
+where
+    T: LinkType,
+    H: Handler<T, R>,
+    R: Try<Output = ()>,
+{
+    fn from(handler: H) -> Self {
+        Self::new(handler)
+    }
+}
+
+impl<T, H, R> FnOnce<(Link<T>, Link<T>)> for Fuse<T, H, R>
+where
+    H: FnMut(Link<T>, Link<T>) -> R,
+    R: Try<Output = ()>,
+    T: LinkType,
+{
+    type Output = Flow;
+
+    extern "rust-call" fn call_once(self, args: (Link<T>, Link<T>)) -> Self::Output {
+        self.handler.call_once(args).branch().into()
+    }
+}
+
+impl<T, H, R> FnMut<(Link<T>, Link<T>)> for Fuse<T, H, R>
+where
+    T: LinkType,
+    H: Handler<T, R>,
+    R: Try<Output = ()>,
+{
+    extern "rust-call" fn call_mut(&mut self, args: (Link<T>, Link<T>)) -> Self::Output {
+        if self.done {
+            Flow::Break
+        } else {
+            let result = self.handler.call_mut(args);
+            if result.branch().is_break() {
+                self.done = false;
+                Flow::Break
+            } else {
+                Flow::Continue
+            }
+        }
+    }
+}
diff --git a/rust/doublets-patched/doublets/src/data/link.rs b/rust/doublets-patched/doublets/src/data/link.rs
new file mode 100644
index 0000000..138e7cb
--- /dev/null
+++ b/rust/doublets-patched/doublets/src/data/link.rs
@@ -0,0 +1,89 @@
+use std::fmt::{self, Debug, Formatter};
+
+use data::{LinkType, Query, ToQuery};
+
+#[derive(Default, Eq, PartialEq, Clone, Hash)]
+#[repr(C)]
+pub struct Link<T: LinkType> {
+    pub index: T,
+    pub source: T,
+    pub target: T,
+}
+
+impl<T: LinkType> Link<T> {
+    #[inline]
+    #[must_use]
+    pub fn nothing() -> Self {
+        Self::default()
+    }
+
+    #[inline]
+    #[must_use]
+    pub const fn new(index: T, source: T, target: T) -> Self {
+        Self {
+            index,
+            source,
+            target,
+        }
+    }
+
+    #[inline]
+    #[must_use]
+    pub const fn point(val: T) -> Self {
+        Self::new(val, val, val)
+    }
+
+    #[inline]
+    pub const fn from_slice(slice: &[T]) -> Self {
+        assert!(slice.len() >= 3);
+
+        // SAFETY: slice has at least 3 elements.
+        unsafe { Self::from_slice_unchecked(slice) }
+    }
+
+    #[inline]
+    #[must_use]
+    pub(crate) const unsafe fn from_slice_unchecked(slice: &[T]) -> Self {
+        match slice {
+            [index, source, target] => Self::new(*index, *source, *target),
+            _ => std::hint::unreachable_unchecked(),
+        }
+    }
+
+    #[inline]
+    #[must_use]
+    pub fn is_null(&self) -> bool {
+        *self == Self::point(T::funty(0))
+    }
+
+    #[inline]
+    #[must_use]
+    pub fn is_full(&self) -> bool {
+        self.index == self.source && self.index == self.target
+    }
+
+    #[inline]
+    #[must_use]
+    pub fn is_partial(&self) -> bool {
+        self.index == self.source || self.index == self.target
+    }
+
+    #[inline]
+    #[must_use]
+    pub const fn as_slice(&self) -> &[T] {
+        // SAFETY: Link is repr(C) and therefore is safe to transmute to a slice
+        unsafe { &*(self as *const Self).cast::<[T; 3]>() }
+    }
+}
+
+impl<T: LinkType> Debug for Link<T> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        write!(f, "{}: {} {}", self.index, self.source, self.target)
+    }
+}
+
+impl<T: LinkType> ToQuery<T> for Link<T> {
+    fn to_query(&self) -> Query<'_, T> {
+        self.as_slice().to_query()
+    }
+}
diff --git a/rust/doublets-patched/doublets/src/data/mod.rs b/rust/doublets-patched/doublets/src/data/mod.rs
new file mode 100644
index 0000000..6039909
--- /dev/null
+++ b/rust/doublets-patched/doublets/src/data/mod.rs
@@ -0,0 +1,14 @@
+mod doublet;
+mod error;
+mod handler;
+mod link;
+mod traits;
+
+pub use doublet::Doublet;
+pub use error::Error;
+pub use handler::{Fuse, Handler};
+pub use link::Link;
+pub use traits::{Doublets, DoubletsExt, Links, ReadHandler, WriteHandler};
+
+#[cfg(feature = "data")]
+pub use data::*;
diff --git a/rust/doublets-patched/doublets/src/data/traits.rs b/rust/doublets-patched/doublets/src/data/traits.rs
new file mode 100644
index 0000000..4a6bd7c
--- /dev/null
+++ b/rust/doublets-patched/doublets/src/data/traits.rs
@@ -0,0 +1,712 @@
+use bumpalo::Bump;
+#[cfg(feature = "rayon")]
+use rayon::prelude::*;
+use std::ops::{ControlFlow, Try};
+
+use crate::{Error, Fuse, Link};
+use data::{Flow, LinkType, LinksConstants, ToQuery};
+
+pub type ReadHandler<'a, T> = &'a mut dyn FnMut(Link<T>) -> Flow;
+
+pub type WriteHandler<'a, T> = &'a mut dyn FnMut(Link<T>, Link<T>) -> Flow;
+
+pub trait Links<T: LinkType>: Send + Sync {
+    fn constants(&self) -> &LinksConstants<T>;
+
+    fn count_links(&self, query: &[T]) -> T;
+
+    fn create_links(&mut self, query: &[T], handler: WriteHandler<'_, T>)
+        -> Result<Flow, Error<T>>;
+
+    fn each_links(&self, query: &[T], handler: ReadHandler<'_, T>) -> Flow;
+
+    fn update_links(
+        &mut self,
+        query: &[T],
+        change: &[T],
+        handler: WriteHandler<'_, T>,
+    ) -> Result<Flow, Error<T>>;
+
+    fn delete_links(&mut self, query: &[T], handler: WriteHandler<'_, T>)
+        -> Result<Flow, Error<T>>;
+}
+
+pub trait Doublets<T: LinkType>: Links<T> {
+    fn count_by(&self, query: impl ToQuery<T>) -> T
+    where
+        Self: Sized,
+    {
+        self.count_links(&query.to_query()[..])
+    }
+
+    fn count(&self) -> T
+    where
+        Self: Sized,
+    {
+        self.count_by([])
+    }
+
+    fn create_by_with<F, R>(
+        &mut self,
+        query: impl ToQuery<T>,
+        mut handler: F,
+    ) -> Result<R, Error<T>>
+    where
+        F: FnMut(Link<T>, Link<T>) -> R,
+        R: Try<Output = ()>,
+        Self: Sized,
+    {
+        let mut output = R::from_output(());
+        let query = query.to_query();
+
+        self.create_links(
+            &query[..],
+            &mut |before, after| match handler(before, after).branch() {
+                ControlFlow::Continue(_) => Flow::Continue,
+                ControlFlow::Break(residual) => {
+                    output = R::from_residual(residual);
+                    Flow::Break
+                }
+            },
+        )
+        .map(|_| output)
+    }
+
+    fn create_by(&mut self, query: impl ToQuery<T>) -> Result<T, Error<T>>
+    where
+        Self: Sized,
+    {
+        let mut index = Default::default();
+        self.create_by_with(query, |_before, link| {
+            index = link.index;
+            Flow::Continue
+        })
+        .map(|_| index)
+    }
+
+    fn create_with<F, R>(&mut self, handler: F) -> Result<R, Error<T>>
+    where
+        F: FnMut(Link<T>, Link<T>) -> R,
+        R: Try<Output = ()>,
+        Self: Sized,
+    {
+        self.create_by_with([], handler)
+    }
+
+    fn create(&mut self) -> Result<T, Error<T>>
+    where
+        Self: Sized,
+    {
+        self.create_by([])
+    }
+
+    fn each_by<F, R>(&self, query: impl ToQuery<T>, mut handler: F) -> R
+    where
+        F: FnMut(Link<T>) -> R,
+        R: Try<Output = ()>,
+        Self: Sized,
+    {
+        let mut output = R::from_output(());
+        let query = query.to_query();
+
+        self.each_links(&query[..], &mut |link| match handler(link).branch() {
+            ControlFlow::Continue(_) => Flow::Continue,
+            ControlFlow::Break(residual) => {
+                output = R::from_residual(residual);
+                Flow::Break
+            }
+        });
+
+        output
+    }
+
+    fn each<F, R>(&self, handler: F) -> R
+    where
+        F: FnMut(Link<T>) -> R,
+        R: Try<Output = ()>,
+        Self: Sized,
+    {
+        self.each_by([], handler)
+    }
+
+    fn update_by_with<H, R>(
+        &mut self,
+        query: impl ToQuery<T>,
+        change: impl ToQuery<T>,
+        mut handler: H,
+    ) -> Result<R, Error<T>>
+    where
+        H: FnMut(Link<T>, Link<T>) -> R,
+        R: Try<Output = ()>,
+        Self: Sized,
+    {
+        let mut output = R::from_output(());
+        let query = query.to_query();
+        let change = change.to_query();
+
+        self.update_links(
+            &query[..],
+            &change[..],
+            &mut |before, after| match handler(before, after).branch() {
+                ControlFlow::Continue(_) => Flow::Continue,
+                ControlFlow::Break(residual) => {
+                    output = R::from_residual(residual);
+                    Flow::Break
+                }
+            },
+        )
+        .map(|_| output)
+    }
+
+    fn update_by(&mut self, query: impl ToQuery<T>, change: impl ToQuery<T>) -> Result<T, Error<T>>
+    where
+        Self: Sized,
+    {
+        let mut result = Default::default();
+        self.update_by_with(query, change, |_, after| {
+            result = after.index;
+            Flow::Continue
+        })
+        .map(|_| result)
+    }
+
+    fn update_with<F, R>(
+        &mut self,
+        index: T,
+        source: T,
+        target: T,
+        handler: F,
+    ) -> Result<R, Error<T>>
+    where
+        F: FnMut(Link<T>, Link<T>) -> R,
+        R: Try<Output = ()>,
+        Self: Sized,
+    {
+        self.update_by_with([index], [index, source, target], handler)
+    }
+
+    fn update(&mut self, index: T, source: T, target: T) -> Result<T, Error<T>>
+    where
+        Self: Sized,
+    {
+        self.update_by([index], [index, source, target])
+    }
+
+    fn delete_by_with<F, R>(
+        &mut self,
+        query: impl ToQuery<T>,
+        mut handler: F,
+    ) -> Result<R, Error<T>>
+    where
+        F: FnMut(Link<T>, Link<T>) -> R,
+        R: Try<Output = ()>,
+        Self: Sized,
+    {
+        let mut output = R::from_output(());
+        let query = query.to_query();
+
+        self.delete_links(
+            &query[..],
+            &mut |before, after| match handler(before, after).branch() {
+                ControlFlow::Continue(_) => Flow::Continue,
+                ControlFlow::Break(residual) => {
+                    output = R::from_residual(residual);
+                    Flow::Break
+                }
+            },
+        )
+        .map(|_| output)
+    }
+
+    fn delete_by(&mut self, query: impl ToQuery<T>) -> Result<T, Error<T>>
+    where
+        Self: Sized,
+    {
+        let mut result = Default::default();
+        self.delete_by_with(query, |_before, after| {
+            result = after.index;
+            Flow::Continue
+        })
+        .map(|_| result)
+    }
+
+    fn delete_with<F, R>(&mut self, index: T, handler: F) -> Result<R, Error<T>>
+    where
+        F: FnMut(Link<T>, Link<T>) -> R,
+        R: Try<Output = ()>,
+        Self: Sized,
+    {
+        self.delete_by_with([index], handler)
+    }
+
+    fn delete(&mut self, index: T) -> Result<T, Error<T>>
+    where
+        Self: Sized,
+    {
+        self.delete_by([index])
+    }
+
+    fn try_get_link(&self, index: T) -> Result<Link<T>, Error<T>> {
+        self.get_link(index).ok_or(Error::NotExists(index))
+    }
+
+    fn get_link(&self, index: T) -> Option<Link<T>>;
+
+    fn delete_all(&mut self) -> Result<(), Error<T>>
+    where
+        Self: Sized,
+    {
+        // delete all links while self.count() != T::funty(0)
+        let mut count = self.count();
+        while count != T::funty(0) {
+            self.delete(count)?;
+            count = self.count();
+        }
+        Ok(())
+    }
+
+    fn delete_query_with<F, R>(
+        &mut self,
+        query: impl ToQuery<T>,
+        handler: F,
+    ) -> Result<(), Error<T>>
+    where
+        F: FnMut(Link<T>, Link<T>) -> R,
+        R: Try<Output = ()>,
+        Self: Sized,
+    {
+        let query = query.to_query();
+        let len = self.count_by(query.to_query()).as_usize();
+        let mut vec = Vec::with_capacity(len);
+
+        self.each_by(query, |link| {
+            vec.push(link.index);
+            Flow::Continue
+        });
+
+        let mut handler = Fuse::new(handler);
+        for index in vec.into_iter().rev() {
+            self.delete_with(index, &mut handler)?;
+        }
+        Ok(())
+    }
+
+    fn delete_usages_with<F, R>(&mut self, index: T, handler: F) -> Result<(), Error<T>>
+    where
+        F: FnMut(Link<T>, Link<T>) -> R,
+        R: Try<Output = ()>,
+        Self: Sized,
+    {
+        let any = self.constants().any;
+        let mut to_delete = Vec::with_capacity(
+            self.count_by([any, index, any]).as_usize()
+                + self.count_by([any, any, index]).as_usize(),
+        );
+        self.each_by([any, index, any], |link| {
+            if link.index != index {
+                to_delete.push(link.index);
+            }
+            Flow::Continue
+        });
+
+        self.each_by([any, any, index], |link| {
+            if link.index != index {
+                to_delete.push(link.index);
+            }
+            Flow::Continue
+        });
+
+        let mut handler = Fuse::new(handler);
+        for index in to_delete.into_iter().rev() {
+            self.delete_with(index, &mut handler)?;
+        }
+        Ok(())
+    }
+
+    fn delete_usages(&mut self, index: T) -> Result<(), Error<T>>
+    where
+        Self: Sized,
+    {
+        self.delete_usages_with(index, |_, _| Flow::Continue)
+    }
+
+    fn create_point(&mut self) -> Result<T, Error<T>>
+    where
+        Self: Sized,
+    {
+        let new = self.create()?;
+        self.update(new, new, new)
+    }
+
+    fn create_link_with<F, R>(&mut self, source: T, target: T, handler: F) -> Result<Flow, Error<T>>
+    where
+        F: FnMut(Link<T>, Link<T>) -> R,
+        R: Try<Output = ()>,
+        Self: Sized,
+    {
+        let mut new = Default::default();
+        let mut handler = Fuse::new(handler);
+        self.create_with(|before, after| {
+            new = after.index;
+            handler(before, after);
+            Flow::Continue
+        })?;
+
+        self.update_with(new, source, target, handler)
+    }
+
+    fn create_link(&mut self, source: T, target: T) -> Result<T, Error<T>>
+    where
+        Self: Sized,
+    {
+        let mut result = Default::default();
+        self.create_link_with(source, target, |_, link| {
+            result = link.index;
+            Flow::Continue
+        })
+        .map(|_| result)
+    }
+
+    fn found(&self, query: impl ToQuery<T>) -> bool
+    where
+        Self: Sized,
+    {
+        self.count_by(query) != T::funty(0)
+    }
+
+    fn find(&self, query: impl ToQuery<T>) -> Option<Link<T>>
+    where
+        Self: Sized,
+    {
+        let mut result = None;
+        self.each_by(query, |link| {
+            result = Some(link);
+            Flow::Break
+        });
+        result
+    }
+
+    fn search(&self, source: T, target: T) -> Option<T>
+    where
+        Self: Sized,
+    {
+        self.find([self.constants().any, source, target])
+            .map(|link| link.index)
+    }
+
+    #[deprecated(note = "use `search` instead")]
+    fn search_or(&self, source: T, target: T, default: T) -> T
+    where
+        Self: Sized,
+    {
+        self.search(source, target).unwrap_or(default)
+    }
+
+    fn single(&self, query: impl ToQuery<T>) -> Option<Link<T>>
+    where
+        Self: Sized,
+    {
+        let mut result = None;
+        self.each_by(query, |link| {
+            if result.is_none() {
+                result = Some(link);
+                Flow::Continue
+            } else {
+                result = None;
+                Flow::Break
+            }
+        });
+        result
+    }
+
+    fn get_or_create(&mut self, source: T, target: T) -> Result<T, Error<T>>
+    where
+        Self: Sized,
+    {
+        if let Some(link) = self.search(source, target) {
+            Ok(link)
+        } else {
+            self.create_link(source, target)
+        }
+    }
+
+    fn count_usages(&self, index: T) -> Result<T, Error<T>>
+    where
+        Self: Sized,
+    {
+        let any = self.constants().any;
+
+        let link = self.try_get_link(index)?;
+
+        let mut usage_source = self.count_by([any, index, any]);
+        if index == link.source {
+            usage_source -= T::funty(1);
+        }
+
+        let mut usage_target = self.count_by([any, any, index]);
+        if index == link.target {
+            usage_target -= T::funty(1);
+        }
+
+        Ok(usage_source + usage_target)
+    }
+
+    fn usages(&self, index: T) -> Result<Vec<T>, Error<T>>
+    where
+        Self: Sized,
+    {
+        let any = self.constants().any;
+        let mut usages = Vec::with_capacity(self.count_usages(index)?.as_usize());
+
+        self.each_by([any, index, any], |link| {
+            if link.index != index {
+                usages.push(link.index);
+            }
+            Flow::Continue
+        });
+
+        self.each_by([any, any, index], |link| {
+            if link.index != index {
+                usages.push(link.index);
+            }
+            Flow::Continue
+        });
+        Ok(usages)
+    }
+
+    fn exist(&self, link: T) -> bool
+    where
+        Self: Sized,
+    {
+        let constants = self.constants();
+        if constants.is_external(link) {
+            true
+        } else {
+            constants.is_internal(link) && self.count_by([link]) != T::funty(0)
+        }
+    }
+
+    fn has_usages(&self, link: T) -> bool
+    where
+        Self: Sized,
+    {
+        self.count_usages(link)
+            .map_or(false, |link| link != T::funty(0))
+    }
+
+    fn rebase_with<F, R>(&mut self, old: T, new: T, handler: F) -> Result<(), Error<T>>
+    where
+        F: FnMut(Link<T>, Link<T>) -> R,
+        R: Try<Output = ()>,
+        Self: Sized,
+    {
+        // guard
+        let _ = self.try_get_link(old)?;
+
+        if old == new {
+            return Ok(());
+        }
+
+        let any = self.constants().any;
+
+        let mut handler = Fuse::new(handler);
+
+        None.into_iter()
+            // best readability
+            .chain(self.each_iter([any, old, any]))
+            .chain(self.each_iter([any, any, old]))
+            .filter(|usage| usage.index != old)
+            .try_for_each(|usage| {
+                if usage.source == old {
+                    self.update_with(usage.index, new, usage.target, &mut handler)?;
+                }
+                if usage.target == old {
+                    self.update_with(usage.index, usage.source, new, &mut handler)?;
+                }
+                Ok(())
+            })
+    }
+
+    fn rebase(&mut self, old: T, new: T) -> Result<T, Error<T>>
+    where
+        Self: Sized,
+    {
+        self.rebase_with(old, new, |_, _| Flow::Continue)
+            .map(|_| new)
+    }
+
+    fn rebase_and_delete(&mut self, old: T, new: T) -> Result<T, Error<T>>
+    where
+        Self: Sized,
+    {
+        if old == new {
+            Ok(new)
+        } else {
+            self.rebase(old, new)?;
+            self.delete(old)
+        }
+    }
+}
+
+impl<T: LinkType, All: Doublets<T> + ?Sized> Links<T> for Box<All> {
+    fn constants(&self) -> &LinksConstants<T> {
+        (**self).constants()
+    }
+
+    fn count_links(&self, query: &[T]) -> T {
+        (**self).count_links(query)
+    }
+
+    fn create_links(
+        &mut self,
+        query: &[T],
+        handler: WriteHandler<'_, T>,
+    ) -> Result<Flow, Error<T>> {
+        (**self).create_links(query, handler)
+    }
+
+    fn each_links(&self, query: &[T], handler: ReadHandler<'_, T>) -> Flow {
+        (**self).each_links(query, handler)
+    }
+
+    fn update_links(
+        &mut self,
+        query: &[T],
+        change: &[T],
+        handler: WriteHandler<'_, T>,
+    ) -> Result<Flow, Error<T>> {
+        (**self).update_links(query, change, handler)
+    }
+
+    fn delete_links(
+        &mut self,
+        query: &[T],
+        handler: WriteHandler<'_, T>,
+    ) -> Result<Flow, Error<T>> {
+        (**self).delete_links(query, handler)
+    }
+}
+
+impl<T: LinkType, All: Doublets<T> + ?Sized> Doublets<T> for Box<All> {
+    fn get_link(&self, index: T) -> Option<Link<T>> {
+        (**self).get_link(index)
+    }
+}
+
+pub trait DoubletsExt<T: LinkType>: Sized + Doublets<T> {
+    #[cfg(feature = "rayon")]
+    type IdxParIter: IndexedParallelIterator<Item = Link<T>>;
+
+    #[cfg(feature = "rayon")]
+    fn par_iter(&self) -> Self::IdxParIter;
+
+    #[cfg(feature = "rayon")]
+    fn par_each_iter(&self, query: impl ToQuery<T>) -> Self::IdxParIter;
+
+    // Box<dyn Iterator<Item = T>> must used while `-> impl Trait` is not stabilized
+    // Box<dyn> than easier `Self::ImplIterator1,2,...`
+    // and have same performance if has only one possible dyn variant
+
+    type ImplIter: Iterator<Item = Link<T>>;
+    fn iter(&self) -> Self::ImplIter;
+
+    type ImplIterEach: Iterator<Item = Link<T>>;
+    fn each_iter(&self, query: impl ToQuery<T>) -> Self::ImplIterEach;
+
+    #[cfg(feature = "small-search")]
+    type ImplIterSmall: Iterator<Item = Link<T>>;
+    #[cfg(feature = "small-search")]
+    fn iter_small(&self) -> Self::ImplIterSmall;
+
+    #[cfg(feature = "small-search")]
+    type ImplIterEachSmall: Iterator<Item = Link<T>>;
+    #[cfg(feature = "small-search")]
+    fn each_iter_small(&self, query: impl ToQuery<T>) -> Self::ImplIterEachSmall;
+}
+
+impl<T: LinkType, All: Doublets<T> + Sized> DoubletsExt<T> for All {
+    #[cfg(feature = "rayon")]
+    type IdxParIter = impl IndexedParallelIterator<Item = Link<T>>;
+
+    #[cfg(feature = "rayon")]
+    fn par_iter(&self) -> Self::IdxParIter {
+        self.par_each_iter([self.constants().any; 3])
+    }
+
+    #[cfg(feature = "rayon")]
+    fn par_each_iter(&self, query: impl ToQuery<T>) -> Self::IdxParIter {
+        let mut vec = Vec::with_capacity(self.count_by(query.to_query()).as_usize());
+        self.each_by(query, |link| {
+            vec.push(link);
+            Flow::Continue
+        });
+        vec.into_par_iter()
+    }
+
+    type ImplIter = impl Iterator<Item = Link<T>>;
+
+    #[inline]
+    fn iter(&self) -> Self::ImplIter {
+        let cap = self
+            .count_by([self.constants().any; 3].to_query())
+            .as_usize();
+        let mut vec = Vec::with_capacity(cap);
+        self.each_by([self.constants().any; 3], &mut |link| {
+            vec.push(link);
+            Flow::Continue
+        });
+        vec.into_iter()
+    }
+
+    type ImplIterEach = impl Iterator<Item = Link<T>> + ExactSizeIterator + DoubleEndedIterator;
+
+    #[cfg_attr(feature = "more-inline", inline)]
+    fn each_iter(&self, query: impl ToQuery<T>) -> Self::ImplIterEach {
+        let cap = self.count_by(query.to_query()).as_usize();
+
+        let mut vec = Vec::with_capacity(cap);
+        self.each_by(query, &mut |link| {
+            vec.push(link);
+            Flow::Continue
+        });
+        vec.into_iter()
+    }
+
+    #[cfg(feature = "small-search")]
+    type ImplIterSmall = impl Iterator<Item = Link<T>>;
+
+    #[inline]
+    #[cfg(feature = "small-search")]
+    fn iter_small(&self) -> Self::ImplIterSmall {
+        const SIZE_HINT: usize = 2;
+        let mut vec = smallvec::SmallVec::<[Link<_>; SIZE_HINT]>::with_capacity(
+            self.count_by([self.constants().any; 3].to_query())
+                .as_usize(),
+        );
+        self.each_by([self.constants().any; 3], |link| {
+            vec.push(link);
+            Flow::Continue
+        });
+        vec.into_iter()
+    }
+
+    #[cfg(feature = "small-search")]
+    type ImplIterEachSmall =
+        impl Iterator<Item = Link<T>> + ExactSizeIterator + DoubleEndedIterator;
+
+    #[cfg(feature = "small-search")]
+    #[cfg_attr(feature = "more-inline", inline)]
+    fn each_iter_small(&self, query: impl ToQuery<T>) -> Self::ImplIterEachSmall {
+        // fixme: later use const generics
+        const SIZE_HINT: usize = 2;
+
+        let mut vec = smallvec::SmallVec::<[Link<_>; SIZE_HINT]>::with_capacity(
+            self.count_by(query.to_query()).as_usize(),
+        );
+        self.each_by(query, |link| {
+            vec.push(link);
+            Flow::Continue
+        });
+        vec.into_iter()
+    }
+}
diff --git a/rust/doublets-patched/doublets/src/lib.rs b/rust/doublets-patched/doublets/src/lib.rs
new file mode 100644
index 0000000..651f727
--- /dev/null
+++ b/rust/doublets-patched/doublets/src/lib.rs
@@ -0,0 +1,62 @@
+#![feature(fn_traits)]
+#![feature(try_trait_v2)]
+#![feature(unboxed_closures)]
+#![feature(nonnull_slice_from_raw_parts)]
+#![feature(associated_type_defaults)]
+#![feature(impl_trait_in_assoc_type)]
+#![feature(allocator_api)]
+#![feature(maybe_uninit_array_assume_init)]
+#![cfg_attr(not(test), forbid(clippy::unwrap_used))]
+#![warn(
+    clippy::perf,
+    clippy::single_match_else,
+    clippy::dbg_macro,
+    clippy::doc_markdown,
+    clippy::wildcard_imports,
+    clippy::struct_excessive_bools,
+    clippy::semicolon_if_nothing_returned,
+    clippy::pedantic,
+    clippy::nursery
+)]
+// for `clippy::pedantic`
+#![allow(
+    clippy::missing_errors_doc,
+    clippy::missing_panics_doc,
+    clippy::missing_safety_doc
+)]
+#![deny(
+    clippy::all,
+    clippy::cast_lossless,
+    clippy::redundant_closure_for_method_calls,
+    clippy::use_self,
+    clippy::unnested_or_patterns,
+    clippy::trivially_copy_pass_by_ref,
+    clippy::needless_pass_by_value,
+    clippy::match_wildcard_for_single_variants,
+    clippy::map_unwrap_or,
+    unused_qualifications,
+    unused_import_braces,
+    unused_lifetimes,
+    unreachable_pub,
+    trivial_numeric_casts,
+    // rustdoc,
+    // missing_debug_implementations,
+    // missing_copy_implementations,
+    deprecated_in_future,
+    meta_variable_misuse,
+    non_ascii_idents,
+    rust_2018_compatibility,
+    rust_2018_idioms,
+    future_incompatible,
+    nonstandard_style,
+)]
+// must be fixed later
+#![allow(clippy::needless_pass_by_value, clippy::comparison_chain)]
+
+pub mod data;
+pub mod mem;
+
+pub use self::mem::{parts, split, unit};
+
+pub use self::data::{Doublet, Doublets, DoubletsExt, Error, Fuse, Handler, Link, Links};
+pub(crate) use self::data::{Error as LinksError, ReadHandler, WriteHandler};
diff --git a/rust/doublets-patched/doublets/src/mem/header.rs b/rust/doublets-patched/doublets/src/mem/header.rs
new file mode 100644
index 0000000..83122c0
--- /dev/null
+++ b/rust/doublets-patched/doublets/src/mem/header.rs
@@ -0,0 +1,15 @@
+use data::LinkType;
+
+#[derive(Debug, Default, Clone, Eq, PartialEq)]
+#[repr(C)]
+pub struct LinksHeader<T: LinkType> {
+    pub allocated: T,
+    pub reserved: T,
+    pub free: T,
+    pub first_free: T,
+    pub root_as_source: T,
+    pub root_as_target: T,
+    pub last_free: T,
+
+    __reserved_8: T,
+}
diff --git a/rust/doublets-patched/doublets/src/mem/mod.rs b/rust/doublets-patched/doublets/src/mem/mod.rs
new file mode 100644
index 0000000..73d88da
--- /dev/null
+++ b/rust/doublets-patched/doublets/src/mem/mod.rs
@@ -0,0 +1,18 @@
+pub use header::LinksHeader;
+pub use traits::{
+    LinksList, LinksTree, SplitList, SplitTree, SplitUpdateMem, UnitTree, UnitUpdateMem,
+};
+mod header;
+pub mod split;
+mod traits;
+pub mod unit;
+
+#[cfg(feature = "mem")]
+pub use mem::*;
+
+pub mod parts {
+    pub use super::{
+        split::{DataPart, IndexPart},
+        unit::LinkPart,
+    };
+}
diff --git a/rust/doublets-patched/doublets/src/mem/split/data_part.rs b/rust/doublets-patched/doublets/src/mem/split/data_part.rs
new file mode 100644
index 0000000..21a6961
--- /dev/null
+++ b/rust/doublets-patched/doublets/src/mem/split/data_part.rs
@@ -0,0 +1,8 @@
+use data::LinkType;
+
+#[derive(Debug, Default, Eq, PartialEq, Hash, Clone)]
+#[repr(C)]
+pub struct DataPart<T: LinkType> {
+    pub(crate) source: T,
+    pub(crate) target: T,
+}
diff --git a/rust/doublets-patched/doublets/src/mem/split/generic/external_recursion_less_base.rs b/rust/doublets-patched/doublets/src/mem/split/generic/external_recursion_less_base.rs
new file mode 100644
index 0000000..416fc17
--- /dev/null
+++ b/rust/doublets-patched/doublets/src/mem/split/generic/external_recursion_less_base.rs
@@ -0,0 +1,76 @@
+use crate::{
+    mem::{
+        header::LinksHeader,
+        split::{DataPart, IndexPart},
+        traits::LinksTree,
+    },
+    Link,
+};
+use data::{LinkType, LinksConstants};
+use std::ptr::NonNull;
+use trees::NoRecurSzbTree;
+
+// TODO: why is there so much duplication in OOP!!! FIXME
+pub struct ExternalRecursionlessSizeBalancedTreeBase<T: LinkType> {
+    pub(crate) data: NonNull<[DataPart<T>]>,
+    pub(crate) indexes: NonNull<[IndexPart<T>]>,
+    pub(crate) r#break: T,
+    pub(crate) r#continue: T,
+}
+
+impl<T: LinkType> ExternalRecursionlessSizeBalancedTreeBase<T> {
+    pub(crate) fn new(
+        constants: LinksConstants<T>,
+        data: NonNull<[DataPart<T>]>,
+        indexes: NonNull<[IndexPart<T>]>,
+    ) -> Self {
+        Self {
+            data,
+            indexes,
+            r#break: constants.r#break,
+            r#continue: constants.r#continue,
+        }
+    }
+}
+
+pub trait ExternalRecursionlessSizeBalancedTreeBaseAbstract<T: LinkType>:
+    NoRecurSzbTree<T> + LinksTree<T>
+{
+    fn get_header(&self) -> &LinksHeader<T>;
+
+    fn get_mut_header(&mut self) -> &mut LinksHeader<T>;
+
+    fn get_index_part(&self, link: T) -> &IndexPart<T>;
+
+    fn get_mut_index_part(&mut self, link: T) -> &mut IndexPart<T>;
+
+    fn get_data_part(&self, link: T) -> &DataPart<T>;
+
+    fn get_mut_data_part(&mut self, link: T) -> &mut DataPart<T>;
+
+    fn get_tree_root(&self) -> T;
+
+    fn get_base_part(&self, link: T) -> T;
+
+    // TODO: rename
+    fn first_is_to_the_left_of_second_4(
+        &self,
+        source: T,
+        target: T,
+        root_source: T,
+        root_target: T,
+    ) -> bool;
+
+    fn first_is_to_the_right_of_second_4(
+        &self,
+        source: T,
+        target: T,
+        root_source: T,
+        root_target: T,
+    ) -> bool;
+
+    fn get_link_value(&self, index: T) -> Link<T> {
+        let link = self.get_data_part(index);
+        Link::new(index, link.source, link.target)
+    }
+}
diff --git a/rust/doublets-patched/doublets/src/mem/split/generic/external_sources_recursion_less_tree.rs b/rust/doublets-patched/doublets/src/mem/split/generic/external_sources_recursion_less_tree.rs
new file mode 100644
index 0000000..5d64276
--- /dev/null
+++ b/rust/doublets-patched/doublets/src/mem/split/generic/external_sources_recursion_less_tree.rs
@@ -0,0 +1,267 @@
+use std::{mem::transmute, ptr::NonNull};
+
+use crate::mem::{
+    header::LinksHeader,
+    split::{
+        generic::external_recursion_less_base::{
+            ExternalRecursionlessSizeBalancedTreeBase,
+            ExternalRecursionlessSizeBalancedTreeBaseAbstract,
+        },
+        DataPart, IndexPart,
+    },
+    traits::LinksTree,
+};
+
+use crate::{
+    mem::{SplitTree, SplitUpdateMem},
+    Link,
+};
+use data::{Flow, LinkType, LinksConstants};
+use trees::{NoRecurSzbTree, SzbTree};
+
+pub struct ExternalSourcesRecursionlessTree<T: LinkType> {
+    base: ExternalRecursionlessSizeBalancedTreeBase<T>,
+}
+
+impl<T: LinkType> ExternalSourcesRecursionlessTree<T> {
+    pub fn new(
+        constants: LinksConstants<T>,
+        data: NonNull<[DataPart<T>]>,
+        indexes: NonNull<[IndexPart<T>]>,
+    ) -> Self {
+        Self {
+            base: ExternalRecursionlessSizeBalancedTreeBase::new(constants, data, indexes),
+        }
+    }
+}
+
+impl<T: LinkType> SzbTree<T> for ExternalSourcesRecursionlessTree<T> {
+    unsafe fn get_left_reference(&self, node: T) -> *const T {
+        std::ptr::addr_of!(self.get_index_part(node).left_as_source)
+    }
+
+    unsafe fn get_right_reference(&self, node: T) -> *const T {
+        std::ptr::addr_of!(self.get_index_part(node).right_as_source)
+    }
+
+    unsafe fn get_mut_left_reference(&mut self, node: T) -> *mut T {
+        std::ptr::addr_of_mut!(self.get_mut_index_part(node).left_as_source)
+    }
+
+    unsafe fn get_mut_right_reference(&mut self, node: T) -> *mut T {
+        std::ptr::addr_of_mut!(self.get_mut_index_part(node).right_as_source)
+    }
+
+    unsafe fn get_left(&self, node: T) -> T {
+        self.get_index_part(node).left_as_source
+    }
+
+    unsafe fn get_right(&self, node: T) -> T {
+        self.get_index_part(node).right_as_source
+    }
+
+    unsafe fn get_size(&self, node: T) -> T {
+        self.get_index_part(node).size_as_source
+    }
+
+    unsafe fn set_left(&mut self, node: T, left: T) {
+        self.get_mut_index_part(node).left_as_source = left;
+    }
+
+    unsafe fn set_right(&mut self, node: T, right: T) {
+        self.get_mut_index_part(node).right_as_source = right;
+    }
+
+    unsafe fn set_size(&mut self, node: T, size: T) {
+        self.get_mut_index_part(node).size_as_source = size;
+    }
+
+    unsafe fn first_is_to_the_left_of_second(&self, first: T, second: T) -> bool {
+        let first = self.get_data_part(first);
+        let second = self.get_data_part(second);
+        self.first_is_to_the_left_of_second_4(
+            first.source,
+            first.target,
+            second.source,
+            second.target,
+        )
+    }
+
+    unsafe fn first_is_to_the_right_of_second(&self, first: T, second: T) -> bool {
+        let first = self.get_data_part(first);
+        let second = self.get_data_part(second);
+        self.first_is_to_the_right_of_second_4(
+            first.source,
+            first.target,
+            second.source,
+            second.target,
+        )
+    }
+
+    unsafe fn clear_node(&mut self, node: T) {
+        let link = self.get_mut_index_part(node);
+        link.left_as_source = T::funty(0);
+        link.right_as_source = T::funty(0);
+        link.size_as_source = T::funty(0);
+    }
+}
+
+impl<T: LinkType> NoRecurSzbTree<T> for ExternalSourcesRecursionlessTree<T> {}
+
+fn each_usages_core<T: LinkType, H: FnMut(Link<T>) -> Flow + ?Sized>(
+    this: &ExternalSourcesRecursionlessTree<T>,
+    base: T,
+    link: T,
+    handler: &mut H,
+) -> Flow {
+    if link == T::funty(0) {
+        return Flow::Continue;
+    }
+    let link_base_part = this.get_base_part(link);
+    unsafe {
+        if link_base_part > base {
+            each_usages_core(this, base, this.get_left_or_default(link), handler)?;
+        } else if link_base_part < base {
+            each_usages_core(this, base, this.get_right_or_default(link), handler)?;
+        } else {
+            handler(this.get_link_value(link))?;
+            each_usages_core(this, base, this.get_left_or_default(link), handler)?;
+            each_usages_core(this, base, this.get_right_or_default(link), handler)?;
+        }
+    }
+    Flow::Continue
+}
+
+impl<T: LinkType> LinksTree<T> for ExternalSourcesRecursionlessTree<T> {
+    fn count_usages(&self, link: T) -> T {
+        unsafe {
+            let mut root = self.get_tree_root();
+            let total = self.get_size(root);
+            let mut total_right_ignore = T::funty(0);
+            while root != T::funty(0) {
+                let base = self.get_base_part(root);
+                if base <= link {
+                    root = self.get_right_or_default(root);
+                } else {
+                    total_right_ignore += self.get_right_size(root) + T::funty(1);
+                    root = self.get_left_or_default(root);
+                }
+            }
+            root = self.get_tree_root();
+            let mut total_left_ignore = T::funty(0);
+            while root != T::funty(0) {
+                let base = self.get_base_part(root);
+                if base >= link {
+                    root = self.get_left_or_default(root);
+                } else {
+                    total_left_ignore += self.get_left_size(root) + T::funty(1);
+                    root = self.get_right_or_default(root);
+                }
+            }
+            total - total_right_ignore - total_left_ignore
+        }
+    }
+
+    fn search(&self, source: T, target: T) -> T {
+        unsafe {
+            let mut root = self.get_tree_root();
+            while root != T::funty(0) {
+                let root_link = self.get_data_part(root);
+                let root_source = root_link.source;
+                let root_target = root_link.target;
+                if self.first_is_to_the_left_of_second_4(source, target, root_source, root_target) {
+                    root = self.get_left_or_default(root);
+                } else if self.first_is_to_the_right_of_second_4(
+                    source,
+                    target,
+                    root_source,
+                    root_target,
+                ) {
+                    root = self.get_right_or_default(root);
+                } else {
+                    return root;
+                }
+            }
+            T::funty(0)
+        }
+    }
+
+    fn each_usages<H: FnMut(Link<T>) -> Flow + ?Sized>(&self, root: T, handler: &mut H) -> Flow {
+        each_usages_core(self, root, self.get_tree_root(), handler)
+    }
+
+    fn detach(&mut self, root: &mut T, index: T) {
+        unsafe { NoRecurSzbTree::detach(self, root as *mut _, index) }
+    }
+
+    fn attach(&mut self, root: &mut T, index: T) {
+        unsafe { NoRecurSzbTree::attach(self, root as *mut _, index) }
+    }
+}
+
+impl<T: LinkType> SplitUpdateMem<T> for ExternalSourcesRecursionlessTree<T> {
+    fn update_mem(&mut self, data: NonNull<[DataPart<T>]>, indexes: NonNull<[IndexPart<T>]>) {
+        self.base.indexes = indexes;
+        self.base.data = data;
+    }
+}
+
+impl<T: LinkType> SplitTree<T> for ExternalSourcesRecursionlessTree<T> {}
+
+impl<T: LinkType> ExternalRecursionlessSizeBalancedTreeBaseAbstract<T>
+    for ExternalSourcesRecursionlessTree<T>
+{
+    fn get_header(&self) -> &LinksHeader<T> {
+        unsafe { transmute(&self.base.indexes.as_ref()[0]) }
+    }
+
+    fn get_mut_header(&mut self) -> &mut LinksHeader<T> {
+        unsafe { transmute(&mut self.base.indexes.as_mut()[0]) }
+    }
+
+    fn get_index_part(&self, link: T) -> &IndexPart<T> {
+        unsafe { &self.base.indexes.as_ref()[link.as_usize()] }
+    }
+
+    fn get_mut_index_part(&mut self, link: T) -> &mut IndexPart<T> {
+        unsafe { &mut self.base.indexes.as_mut()[link.as_usize()] }
+    }
+
+    fn get_data_part(&self, link: T) -> &DataPart<T> {
+        unsafe { &self.base.data.as_ref()[link.as_usize()] }
+    }
+
+    fn get_mut_data_part(&mut self, link: T) -> &mut DataPart<T> {
+        unsafe { &mut self.base.data.as_mut()[link.as_usize()] }
+    }
+
+    fn get_tree_root(&self) -> T {
+        self.get_header().root_as_source
+    }
+
+    fn get_base_part(&self, link: T) -> T {
+        self.get_data_part(link).source
+    }
+
+    fn first_is_to_the_left_of_second_4(
+        &self,
+        first_source: T,
+        first_target: T,
+        second_source: T,
+        second_target: T,
+    ) -> bool {
+        (first_source < second_source)
+            || (first_source == second_source && first_target < second_target)
+    }
+
+    fn first_is_to_the_right_of_second_4(
+        &self,
+        first_source: T,
+        first_target: T,
+        second_source: T,
+        second_target: T,
+    ) -> bool {
+        (first_source > second_source)
+            || (first_source == second_source && first_target > second_target)
+    }
+}
diff --git a/rust/doublets-patched/doublets/src/mem/split/generic/external_targets_recursion_less_tree.rs b/rust/doublets-patched/doublets/src/mem/split/generic/external_targets_recursion_less_tree.rs
new file mode 100644
index 0000000..a5f377d
--- /dev/null
+++ b/rust/doublets-patched/doublets/src/mem/split/generic/external_targets_recursion_less_tree.rs
@@ -0,0 +1,265 @@
+use std::{mem::transmute, ptr::NonNull};
+
+use crate::mem::{
+    header::LinksHeader,
+    split::{
+        generic::external_recursion_less_base::{
+            ExternalRecursionlessSizeBalancedTreeBase,
+            ExternalRecursionlessSizeBalancedTreeBaseAbstract,
+        },
+        DataPart, IndexPart,
+    },
+    traits::LinksTree,
+    SplitTree,
+};
+
+use crate::{mem::SplitUpdateMem, Link};
+use data::{Flow, LinkType, LinksConstants};
+use trees::{NoRecurSzbTree, SzbTree};
+
+pub struct ExternalTargetsRecursionlessTree<T: LinkType> {
+    base: ExternalRecursionlessSizeBalancedTreeBase<T>,
+}
+
+impl<T: LinkType> ExternalTargetsRecursionlessTree<T> {
+    pub fn new(
+        constants: LinksConstants<T>,
+        data: NonNull<[DataPart<T>]>,
+        indexes: NonNull<[IndexPart<T>]>,
+    ) -> Self {
+        Self {
+            base: ExternalRecursionlessSizeBalancedTreeBase::new(constants, data, indexes),
+        }
+    }
+}
+
+impl<T: LinkType> SzbTree<T> for ExternalTargetsRecursionlessTree<T> {
+    unsafe fn get_left_reference(&self, node: T) -> *const T {
+        std::ptr::addr_of!(self.get_index_part(node).left_as_target)
+    }
+
+    unsafe fn get_right_reference(&self, node: T) -> *const T {
+        std::ptr::addr_of!(self.get_index_part(node).right_as_target)
+    }
+
+    unsafe fn get_mut_left_reference(&mut self, node: T) -> *mut T {
+        std::ptr::addr_of_mut!(self.get_mut_index_part(node).left_as_target)
+    }
+
+    unsafe fn get_mut_right_reference(&mut self, node: T) -> *mut T {
+        std::ptr::addr_of_mut!(self.get_mut_index_part(node).right_as_target)
+    }
+
+    unsafe fn get_left(&self, node: T) -> T {
+        self.get_index_part(node).left_as_target
+    }
+
+    unsafe fn get_right(&self, node: T) -> T {
+        self.get_index_part(node).right_as_target
+    }
+
+    unsafe fn get_size(&self, node: T) -> T {
+        self.get_index_part(node).size_as_target
+    }
+
+    unsafe fn set_left(&mut self, node: T, left: T) {
+        self.get_mut_index_part(node).left_as_target = left;
+    }
+
+    unsafe fn set_right(&mut self, node: T, right: T) {
+        self.get_mut_index_part(node).right_as_target = right;
+    }
+
+    unsafe fn set_size(&mut self, node: T, size: T) {
+        self.get_mut_index_part(node).size_as_target = size;
+    }
+
+    unsafe fn first_is_to_the_left_of_second(&self, first: T, second: T) -> bool {
+        let first = self.get_data_part(first);
+        let second = self.get_data_part(second);
+        self.first_is_to_the_left_of_second_4(
+            first.source,
+            first.target,
+            second.source,
+            second.target,
+        )
+    }
+
+    unsafe fn first_is_to_the_right_of_second(&self, first: T, second: T) -> bool {
+        let first = self.get_data_part(first);
+        let second = self.get_data_part(second);
+        self.first_is_to_the_right_of_second_4(
+            first.source,
+            first.target,
+            second.source,
+            second.target,
+        )
+    }
+
+    unsafe fn clear_node(&mut self, node: T) {
+        let link = self.get_mut_index_part(node);
+        link.left_as_target = T::funty(0);
+        link.right_as_target = T::funty(0);
+        link.size_as_target = T::funty(0);
+    }
+}
+
+impl<T: LinkType> NoRecurSzbTree<T> for ExternalTargetsRecursionlessTree<T> {}
+
+fn each_usages_core<T: LinkType, H: FnMut(Link<T>) -> Flow + ?Sized>(
+    this: &ExternalTargetsRecursionlessTree<T>,
+    base: T,
+    link: T,
+    handler: &mut H,
+) -> Flow {
+    if link == T::funty(0) {
+        return Flow::Continue;
+    }
+    unsafe {
+        let link_base_part = this.get_base_part(link);
+        if link_base_part > base {
+            each_usages_core(this, base, this.get_left_or_default(link), handler)?;
+        } else if link_base_part < base {
+            each_usages_core(this, base, this.get_right_or_default(link), handler)?;
+        } else {
+            handler(this.get_link_value(link))?;
+            each_usages_core(this, base, this.get_left_or_default(link), handler)?;
+            each_usages_core(this, base, this.get_right_or_default(link), handler)?;
+        }
+    }
+    Flow::Continue
+}
+
+impl<T: LinkType> LinksTree<T> for ExternalTargetsRecursionlessTree<T> {
+    fn count_usages(&self, link: T) -> T {
+        unsafe {
+            let mut root = self.get_tree_root();
+            let total = self.get_size(root);
+            let mut total_right_ignore = T::funty(0);
+            while root != T::funty(0) {
+                let base = self.get_base_part(root);
+                if base <= link {
+                    root = self.get_right_or_default(root);
+                } else {
+                    total_right_ignore += self.get_right_size(root) + T::funty(1);
+                    root = self.get_left_or_default(root);
+                }
+            }
+            root = self.get_tree_root();
+            let mut total_left_ignore = T::funty(0);
+            while root != T::funty(0) {
+                let base = self.get_base_part(root);
+                if base >= link {
+                    root = self.get_left_or_default(root);
+                } else {
+                    total_left_ignore += self.get_left_size(root) + T::funty(1);
+                    root = self.get_right_or_default(root);
+                }
+            }
+            total - total_right_ignore - total_left_ignore
+        }
+    }
+
+    fn search(&self, source: T, target: T) -> T {
+        unsafe {
+            let mut root = self.get_tree_root();
+            while root != T::funty(0) {
+                let root_link = self.get_data_part(root);
+                let root_source = root_link.source;
+                let root_target = root_link.target;
+                if self.first_is_to_the_left_of_second_4(source, target, root_source, root_target) {
+                    root = self.get_left_or_default(root);
+                } else if self.first_is_to_the_right_of_second_4(
+                    source,
+                    target,
+                    root_source,
+                    root_target,
+                ) {
+                    root = self.get_right_or_default(root);
+                } else {
+                    return root;
+                }
+            }
+            T::funty(0)
+        }
+    }
+
+    fn each_usages<H: FnMut(Link<T>) -> Flow + ?Sized>(&self, root: T, handler: &mut H) -> Flow {
+        each_usages_core(self, root, self.get_tree_root(), handler)
+    }
+
+    fn detach(&mut self, root: &mut T, index: T) {
+        unsafe { NoRecurSzbTree::detach(self, root as *mut _, index) }
+    }
+
+    fn attach(&mut self, root: &mut T, index: T) {
+        unsafe { NoRecurSzbTree::attach(self, root as *mut _, index) }
+    }
+}
+
+impl<T: LinkType> SplitUpdateMem<T> for ExternalTargetsRecursionlessTree<T> {
+    fn update_mem(&mut self, data: NonNull<[DataPart<T>]>, indexes: NonNull<[IndexPart<T>]>) {
+        self.base.indexes = indexes;
+        self.base.data = data;
+    }
+}
+
+impl<T: LinkType> SplitTree<T> for ExternalTargetsRecursionlessTree<T> {}
+
+impl<T: LinkType> ExternalRecursionlessSizeBalancedTreeBaseAbstract<T>
+    for ExternalTargetsRecursionlessTree<T>
+{
+    fn get_header(&self) -> &LinksHeader<T> {
+        unsafe { transmute(&self.base.indexes.as_ref()[0]) }
+    }
+
+    fn get_mut_header(&mut self) -> &mut LinksHeader<T> {
+        unsafe { transmute(&mut self.base.indexes.as_mut()[0]) }
+    }
+
+    fn get_index_part(&self, link: T) -> &IndexPart<T> {
+        unsafe { &self.base.indexes.as_ref()[link.as_usize()] }
+    }
+
+    fn get_mut_index_part(&mut self, link: T) -> &mut IndexPart<T> {
+        unsafe { &mut self.base.indexes.as_mut()[link.as_usize()] }
+    }
+
+    fn get_data_part(&self, link: T) -> &DataPart<T> {
+        unsafe { &self.base.data.as_ref()[link.as_usize()] }
+    }
+
+    fn get_mut_data_part(&mut self, link: T) -> &mut DataPart<T> {
+        unsafe { &mut self.base.data.as_mut()[link.as_usize()] }
+    }
+
+    fn get_tree_root(&self) -> T {
+        self.get_header().root_as_target
+    }
+
+    fn get_base_part(&self, link: T) -> T {
+        self.get_data_part(link).target
+    }
+
+    fn first_is_to_the_left_of_second_4(
+        &self,
+        first_source: T,
+        first_target: T,
+        second_source: T,
+        second_target: T,
+    ) -> bool {
+        (first_target < second_target)
+            || (first_target == second_target && first_source < second_source)
+    }
+
+    fn first_is_to_the_right_of_second_4(
+        &self,
+        first_source: T,
+        first_target: T,
+        second_source: T,
+        second_target: T,
+    ) -> bool {
+        (first_target > second_target)
+            || (first_target == second_target && first_source > second_source)
+    }
+}
diff --git a/rust/doublets-patched/doublets/src/mem/split/generic/internal_recursion_less_base.rs b/rust/doublets-patched/doublets/src/mem/split/generic/internal_recursion_less_base.rs
new file mode 100644
index 0000000..09bb145
--- /dev/null
+++ b/rust/doublets-patched/doublets/src/mem/split/generic/internal_recursion_less_base.rs
@@ -0,0 +1,76 @@
+use std::ptr::NonNull;
+
+use crate::mem::traits::LinksTree;
+
+use crate::{
+    mem::split::{DataPart, IndexPart},
+    Link,
+};
+use data::{LinkType, LinksConstants};
+use trees::NoRecurSzbTree;
+
+// TODO: why is there so much duplication in OOP!!! FIXME
+pub(crate) struct InternalRecursionlessSizeBalancedTreeBase<T: LinkType> {
+    pub(crate) data: NonNull<[DataPart<T>]>,
+    pub(crate) indexes: NonNull<[IndexPart<T>]>,
+    pub(crate) r#break: T,
+    pub(crate) r#continue: T,
+}
+
+impl<T: LinkType> InternalRecursionlessSizeBalancedTreeBase<T> {
+    pub(crate) fn new(
+        constants: LinksConstants<T>,
+        data: NonNull<[DataPart<T>]>,
+        indexes: NonNull<[IndexPart<T>]>,
+    ) -> Self {
+        Self {
+            data,
+            indexes,
+            r#break: constants.r#break,
+            r#continue: constants.r#continue,
+        }
+    }
+}
+
+pub(crate) trait InternalRecursionlessSizeBalancedTreeBaseAbstract<T: LinkType>:
+    NoRecurSzbTree<T> + LinksTree<T>
+{
+    fn get_index_part(&self, link: T) -> &IndexPart<T>;
+
+    fn get_mut_index_part(&mut self, link: T) -> &mut IndexPart<T>;
+
+    fn get_data_part(&self, link: T) -> &DataPart<T>;
+
+    fn get_mut_data_part(&mut self, link: T) -> &mut DataPart<T>;
+
+    fn get_tree_root(&self, link: T) -> T;
+
+    fn get_base_part(&self, link: T) -> T;
+
+    fn get_key_part(&self, link: T) -> T;
+
+    fn get_link_value(&self, index: T) -> Link<T> {
+        let link = self.get_data_part(index);
+        Link::new(index, link.source, link.target)
+    }
+
+    fn search_core(&self, mut root: T, key: T) -> T {
+        unsafe {
+            while root != T::funty(0) {
+                let root_key = self.get_key_part(root);
+                if key < root_key {
+                    root = self.get_left_or_default(root);
+                } else if key > root_key {
+                    root = self.get_right_or_default(root);
+                } else {
+                    return root;
+                }
+            }
+            T::funty(0)
+        }
+    }
+
+    fn count_usages_core(&self, link: T) -> T {
+        unsafe { self.get_size_or_zero(self.get_tree_root(link)) }
+    }
+}
diff --git a/rust/doublets-patched/doublets/src/mem/split/generic/internal_sources_linked_list.rs b/rust/doublets-patched/doublets/src/mem/split/generic/internal_sources_linked_list.rs
new file mode 100644
index 0000000..d086579
--- /dev/null
+++ b/rust/doublets-patched/doublets/src/mem/split/generic/internal_sources_linked_list.rs
@@ -0,0 +1,151 @@
+use crate::Link;
+use data::{Flow, LinksConstants};
+use std::mem::transmute;
+
+use std::ptr::NonNull;
+
+use crate::mem::{
+    header::LinksHeader,
+    split::{DataPart, IndexPart},
+    SplitUpdateMem,
+};
+
+use data::LinkType;
+use trees::{LinkedList, RelativeCircularLinkedList, RelativeLinkedList};
+
+pub struct InternalSourcesLinkedList<T: LinkType> {
+    data: NonNull<[DataPart<T>]>,
+    indexes: NonNull<[IndexPart<T>]>,
+    r#continue: T,
+    r#break: T,
+}
+
+impl<T: LinkType> InternalSourcesLinkedList<T> {
+    pub fn new(
+        constants: LinksConstants<T>,
+        data: NonNull<[DataPart<T>]>,
+        indexes: NonNull<[IndexPart<T>]>,
+    ) -> Self {
+        Self {
+            data,
+            indexes,
+            r#continue: constants.r#continue,
+            r#break: constants.r#break,
+        }
+    }
+
+    fn get_header(&self) -> &LinksHeader<T> {
+        unsafe { transmute(&self.indexes.as_ref()[0]) }
+    }
+
+    fn get_mut_header(&mut self) -> &mut LinksHeader<T> {
+        unsafe { transmute(&mut self.indexes.as_mut()[0]) }
+    }
+
+    fn get_data_part(&self, link: T) -> &DataPart<T> {
+        unsafe { &self.data.as_ref()[link.as_usize()] }
+    }
+
+    fn get_mut_data_part(&mut self, link: T) -> &mut DataPart<T> {
+        unsafe { &mut self.data.as_mut()[link.as_usize()] }
+    }
+
+    fn get_index_part(&self, link: T) -> &IndexPart<T> {
+        unsafe { &self.indexes.as_ref()[link.as_usize()] }
+    }
+
+    fn get_mut_index_part(&mut self, link: T) -> &mut IndexPart<T> {
+        unsafe { &mut self.indexes.as_mut()[link.as_usize()] }
+    }
+
+    fn get_link_value(&self, link: T) -> Link<T> {
+        let data = self.get_data_part(link);
+        Link::new(link, data.source, data.target)
+    }
+
+    pub fn count_usages(&self, head: T) -> T {
+        self.get_size(head)
+    }
+
+    pub fn each_usages<H: FnMut(Link<T>) -> Flow + ?Sized>(
+        &self,
+        source: T,
+        handler: &mut H,
+    ) -> Flow {
+        let mut current = self.get_first(source);
+        let first = current;
+
+        while current != T::funty(0) {
+            handler(self.get_link_value(current))?;
+            current = self.get_next(current);
+            if current == first {
+                return Flow::Continue;
+            }
+        }
+        Flow::Continue
+    }
+}
+
+impl<T: LinkType> RelativeLinkedList<T> for InternalSourcesLinkedList<T> {
+    fn get_first(&self, head: T) -> T {
+        self.get_index_part(head).root_as_source
+    }
+
+    fn get_last(&self, head: T) -> T {
+        let first = self.get_first(head);
+        if first == T::funty(0) {
+            first
+        } else {
+            self.get_previous(first)
+        }
+    }
+
+    fn get_size(&self, head: T) -> T {
+        self.get_index_part(head).size_as_source
+    }
+
+    fn set_first(&mut self, head: T, element: T) {
+        self.get_mut_index_part(head).root_as_source = element;
+    }
+
+    fn set_last(&mut self, _head: T, _element: T) {
+        // todo!("empty")
+        // let first = self.get_index_part(head).root_as_source;
+        // if first.is_zero() {
+        //     self.set_first(head, element);
+        // } else {
+        //     self.set_previous(first, element);
+        // }
+    }
+
+    fn set_size(&mut self, head: T, size: T) {
+        self.get_mut_index_part(head).size_as_source = size
+    }
+}
+
+impl<T: LinkType> LinkedList<T> for InternalSourcesLinkedList<T> {
+    fn get_previous(&self, element: T) -> T {
+        self.get_index_part(element).left_as_source
+    }
+
+    fn get_next(&self, element: T) -> T {
+        self.get_index_part(element).right_as_source
+    }
+
+    fn set_previous(&mut self, element: T, previous: T) {
+        self.get_mut_index_part(element).left_as_source = previous;
+    }
+
+    fn set_next(&mut self, element: T, next: T) {
+        self.get_mut_index_part(element).right_as_source = next;
+    }
+}
+
+impl<T: LinkType> RelativeCircularLinkedList<T> for InternalSourcesLinkedList<T> {}
+
+impl<T: LinkType> SplitUpdateMem<T> for InternalSourcesLinkedList<T> {
+    fn update_mem(&mut self, data: NonNull<[DataPart<T>]>, indexes: NonNull<[IndexPart<T>]>) {
+        self.data = data;
+        self.indexes = indexes;
+    }
+}
diff --git a/rust/doublets-patched/doublets/src/mem/split/generic/internal_sources_recursion_less_tree.rs b/rust/doublets-patched/doublets/src/mem/split/generic/internal_sources_recursion_less_tree.rs
new file mode 100644
index 0000000..d9bd0c6
--- /dev/null
+++ b/rust/doublets-patched/doublets/src/mem/split/generic/internal_sources_recursion_less_tree.rs
@@ -0,0 +1,173 @@
+use std::ptr::NonNull;
+
+use crate::mem::traits::LinksTree;
+
+use crate::mem::{
+    split::{
+        generic::internal_recursion_less_base::{
+            InternalRecursionlessSizeBalancedTreeBase,
+            InternalRecursionlessSizeBalancedTreeBaseAbstract,
+        },
+        DataPart, IndexPart,
+    },
+    SplitUpdateMem,
+};
+
+use crate::{mem::SplitTree, Link};
+use data::{Flow, LinkType, LinksConstants};
+use trees::{NoRecurSzbTree, SzbTree};
+
+pub struct InternalSourcesRecursionlessTree<T: LinkType> {
+    base: InternalRecursionlessSizeBalancedTreeBase<T>,
+}
+
+impl<T: LinkType> InternalSourcesRecursionlessTree<T> {
+    pub fn new(
+        constants: LinksConstants<T>,
+        data: NonNull<[DataPart<T>]>,
+        indexes: NonNull<[IndexPart<T>]>,
+    ) -> Self {
+        Self {
+            base: InternalRecursionlessSizeBalancedTreeBase::new(constants, data, indexes),
+        }
+    }
+}
+
+impl<T: LinkType> SzbTree<T> for InternalSourcesRecursionlessTree<T> {
+    unsafe fn get_left_reference(&self, node: T) -> *const T {
+        std::ptr::addr_of!(self.get_index_part(node).left_as_source)
+    }
+
+    unsafe fn get_right_reference(&self, node: T) -> *const T {
+        std::ptr::addr_of!(self.get_index_part(node).right_as_source)
+    }
+
+    unsafe fn get_mut_left_reference(&mut self, node: T) -> *mut T {
+        std::ptr::addr_of_mut!(self.get_mut_index_part(node).left_as_source)
+    }
+
+    unsafe fn get_mut_right_reference(&mut self, node: T) -> *mut T {
+        std::ptr::addr_of_mut!(self.get_mut_index_part(node).right_as_source)
+    }
+
+    unsafe fn get_left(&self, node: T) -> T {
+        self.get_index_part(node).left_as_source
+    }
+
+    unsafe fn get_right(&self, node: T) -> T {
+        self.get_index_part(node).right_as_source
+    }
+
+    unsafe fn get_size(&self, node: T) -> T {
+        self.get_index_part(node).size_as_source
+    }
+
+    unsafe fn set_left(&mut self, node: T, left: T) {
+        self.get_mut_index_part(node).left_as_source = left;
+    }
+
+    unsafe fn set_right(&mut self, node: T, right: T) {
+        self.get_mut_index_part(node).right_as_source = right;
+    }
+
+    unsafe fn set_size(&mut self, node: T, size: T) {
+        self.get_mut_index_part(node).size_as_source = size;
+    }
+
+    unsafe fn first_is_to_the_left_of_second(&self, first: T, second: T) -> bool {
+        self.get_key_part(first) < self.get_key_part(second)
+    }
+
+    unsafe fn first_is_to_the_right_of_second(&self, first: T, second: T) -> bool {
+        self.get_key_part(first) > self.get_key_part(second)
+    }
+
+    unsafe fn clear_node(&mut self, node: T) {
+        let link = self.get_mut_index_part(node);
+        link.left_as_source = T::funty(0);
+        link.right_as_source = T::funty(0);
+        link.size_as_source = T::funty(0);
+    }
+}
+
+impl<T: LinkType> NoRecurSzbTree<T> for InternalSourcesRecursionlessTree<T> {}
+
+fn each_usages_core<T: LinkType, H: FnMut(Link<T>) -> Flow + ?Sized>(
+    this: &InternalSourcesRecursionlessTree<T>,
+    base: T,
+    link: T,
+    handler: &mut H,
+) -> Flow {
+    if link == T::funty(0) {
+        return Flow::Continue;
+    }
+    unsafe {
+        each_usages_core(this, base, this.get_left_or_default(link), handler)?;
+        handler(this.get_link_value(link))?;
+        each_usages_core(this, base, this.get_right_or_default(link), handler)?;
+        Flow::Continue
+    }
+}
+
+impl<T: LinkType> LinksTree<T> for InternalSourcesRecursionlessTree<T> {
+    fn count_usages(&self, link: T) -> T {
+        self.count_usages_core(link)
+    }
+
+    fn search(&self, source: T, target: T) -> T {
+        self.search_core(self.get_tree_root(source), target)
+    }
+
+    fn each_usages<H: FnMut(Link<T>) -> Flow + ?Sized>(&self, root: T, handler: &mut H) -> Flow {
+        each_usages_core(self, root, self.get_tree_root(root), handler)
+    }
+
+    fn detach(&mut self, root: &mut T, index: T) {
+        unsafe { NoRecurSzbTree::detach(self, root as *mut _, index) }
+    }
+
+    fn attach(&mut self, root: &mut T, index: T) {
+        unsafe { NoRecurSzbTree::attach(self, root as *mut _, index) }
+    }
+}
+
+impl<T: LinkType> SplitUpdateMem<T> for InternalSourcesRecursionlessTree<T> {
+    fn update_mem(&mut self, data: NonNull<[DataPart<T>]>, index: NonNull<[IndexPart<T>]>) {
+        self.base.data = data;
+        self.base.indexes = index;
+    }
+}
+
+impl<T: LinkType> SplitTree<T> for InternalSourcesRecursionlessTree<T> {}
+
+impl<T: LinkType> InternalRecursionlessSizeBalancedTreeBaseAbstract<T>
+    for InternalSourcesRecursionlessTree<T>
+{
+    fn get_index_part(&self, link: T) -> &IndexPart<T> {
+        unsafe { &self.base.indexes.as_ref()[link.as_usize()] }
+    }
+
+    fn get_mut_index_part(&mut self, link: T) -> &mut IndexPart<T> {
+        unsafe { &mut self.base.indexes.as_mut()[link.as_usize()] }
+    }
+
+    fn get_data_part(&self, link: T) -> &DataPart<T> {
+        unsafe { &self.base.data.as_ref()[link.as_usize()] }
+    }
+
+    fn get_mut_data_part(&mut self, link: T) -> &mut DataPart<T> {
+        unsafe { &mut self.base.data.as_mut()[link.as_usize()] }
+    }
+
+    fn get_tree_root(&self, link: T) -> T {
+        self.get_index_part(link).root_as_source
+    }
+
+    fn get_base_part(&self, link: T) -> T {
+        self.get_data_part(link).source
+    }
+
+    fn get_key_part(&self, link: T) -> T {
+        self.get_data_part(link).target
+    }
+}
diff --git a/rust/doublets-patched/doublets/src/mem/split/generic/internal_targets_recursion_less_tree.rs b/rust/doublets-patched/doublets/src/mem/split/generic/internal_targets_recursion_less_tree.rs
new file mode 100644
index 0000000..f46dc4f
--- /dev/null
+++ b/rust/doublets-patched/doublets/src/mem/split/generic/internal_targets_recursion_less_tree.rs
@@ -0,0 +1,180 @@
+use std::ptr::NonNull;
+
+use crate::mem::traits::LinksTree;
+
+use crate::mem::split::{
+    generic::internal_recursion_less_base::{
+        InternalRecursionlessSizeBalancedTreeBase,
+        InternalRecursionlessSizeBalancedTreeBaseAbstract,
+    },
+    DataPart, IndexPart,
+};
+
+use crate::{
+    mem::{SplitTree, SplitUpdateMem},
+    Link,
+};
+use data::{Flow, LinkType, LinksConstants};
+use trees::{NoRecurSzbTree, SzbTree};
+
+pub struct InternalTargetsRecursionlessTree<T: LinkType> {
+    base: InternalRecursionlessSizeBalancedTreeBase<T>,
+}
+
+impl<T: LinkType> InternalTargetsRecursionlessTree<T> {
+    pub fn new(
+        constants: LinksConstants<T>,
+        data: NonNull<[DataPart<T>]>,
+        indexes: NonNull<[IndexPart<T>]>,
+    ) -> Self {
+        Self {
+            base: InternalRecursionlessSizeBalancedTreeBase::new(constants, data, indexes),
+        }
+    }
+}
+
+impl<T: LinkType> SzbTree<T> for InternalTargetsRecursionlessTree<T> {
+    unsafe fn get_left_reference(&self, node: T) -> *const T {
+        std::ptr::addr_of!(self.get_index_part(node).left_as_target)
+    }
+
+    unsafe fn get_right_reference(&self, node: T) -> *const T {
+        std::ptr::addr_of!(self.get_index_part(node).right_as_target)
+    }
+
+    unsafe fn get_mut_left_reference(&mut self, node: T) -> *mut T {
+        std::ptr::addr_of_mut!(self.get_mut_index_part(node).left_as_target)
+    }
+
+    unsafe fn get_mut_right_reference(&mut self, node: T) -> *mut T {
+        std::ptr::addr_of_mut!(self.get_mut_index_part(node).right_as_target)
+    }
+
+    unsafe fn get_left(&self, node: T) -> T {
+        self.get_index_part(node).left_as_target
+    }
+
+    unsafe fn get_right(&self, node: T) -> T {
+        self.get_index_part(node).right_as_target
+    }
+
+    unsafe fn get_size(&self, node: T) -> T {
+        self.get_index_part(node).size_as_target
+    }
+
+    unsafe fn set_left(&mut self, node: T, left: T) {
+        self.get_mut_index_part(node).left_as_target = left;
+    }
+
+    unsafe fn set_right(&mut self, node: T, right: T) {
+        self.get_mut_index_part(node).right_as_target = right;
+    }
+
+    unsafe fn set_size(&mut self, node: T, size: T) {
+        self.get_mut_index_part(node).size_as_target = size;
+    }
+
+    unsafe fn first_is_to_the_left_of_second(&self, first: T, second: T) -> bool {
+        self.get_key_part(first) < self.get_key_part(second)
+    }
+
+    unsafe fn first_is_to_the_right_of_second(&self, first: T, second: T) -> bool {
+        self.get_key_part(first) > self.get_key_part(second)
+    }
+
+    unsafe fn clear_node(&mut self, node: T) {
+        let link = self.get_mut_index_part(node);
+        link.left_as_target = T::funty(0);
+        link.right_as_target = T::funty(0);
+        link.size_as_target = T::funty(0);
+    }
+}
+
+impl<T: LinkType> NoRecurSzbTree<T> for InternalTargetsRecursionlessTree<T> {}
+
+fn each_usages_core<T: LinkType, H: FnMut(Link<T>) -> Flow + ?Sized>(
+    this: &InternalTargetsRecursionlessTree<T>,
+    base: T,
+    link: T,
+    handler: &mut H,
+) -> Flow {
+    if link == T::funty(0) {
+        return Flow::Continue;
+    }
+    unsafe {
+        let link_base_part = this.get_base_part(link);
+        if link_base_part > base {
+            each_usages_core(this, base, this.get_left_or_default(link), handler)?;
+        } else if link_base_part < base {
+            each_usages_core(this, base, this.get_right_or_default(link), handler)?;
+        } else {
+            handler(this.get_link_value(link))?;
+            each_usages_core(this, base, this.get_left_or_default(link), handler)?;
+            each_usages_core(this, base, this.get_right_or_default(link), handler)?;
+        }
+    }
+    Flow::Continue
+}
+
+impl<T: LinkType> LinksTree<T> for InternalTargetsRecursionlessTree<T> {
+    fn count_usages(&self, link: T) -> T {
+        self.count_usages_core(link)
+    }
+
+    fn search(&self, source: T, target: T) -> T {
+        self.search_core(self.get_tree_root(target), source)
+    }
+
+    fn each_usages<H: FnMut(Link<T>) -> Flow + ?Sized>(&self, root: T, handler: &mut H) -> Flow {
+        each_usages_core(self, root, self.get_tree_root(root), handler)
+    }
+
+    fn detach(&mut self, root: &mut T, index: T) {
+        unsafe { NoRecurSzbTree::detach(self, root as *mut _, index) }
+    }
+
+    fn attach(&mut self, root: &mut T, index: T) {
+        unsafe { NoRecurSzbTree::attach(self, root as *mut _, index) }
+    }
+}
+
+impl<T: LinkType> SplitUpdateMem<T> for InternalTargetsRecursionlessTree<T> {
+    fn update_mem(&mut self, data: NonNull<[DataPart<T>]>, indexes: NonNull<[IndexPart<T>]>) {
+        self.base.indexes = indexes;
+        self.base.data = data;
+    }
+}
+
+impl<T: LinkType> SplitTree<T> for InternalTargetsRecursionlessTree<T> {}
+
+impl<T: LinkType> InternalRecursionlessSizeBalancedTreeBaseAbstract<T>
+    for InternalTargetsRecursionlessTree<T>
+{
+    fn get_index_part(&self, link: T) -> &IndexPart<T> {
+        unsafe { &self.base.indexes.as_ref()[link.as_usize()] }
+    }
+
+    fn get_mut_index_part(&mut self, link: T) -> &mut IndexPart<T> {
+        unsafe { &mut self.base.indexes.as_mut()[link.as_usize()] }
+    }
+
+    fn get_data_part(&self, link: T) -> &DataPart<T> {
+        unsafe { &self.base.data.as_ref()[link.as_usize()] }
+    }
+
+    fn get_mut_data_part(&mut self, link: T) -> &mut DataPart<T> {
+        unsafe { &mut self.base.data.as_mut()[link.as_usize()] }
+    }
+
+    fn get_tree_root(&self, link: T) -> T {
+        self.get_index_part(link).root_as_target
+    }
+
+    fn get_base_part(&self, link: T) -> T {
+        self.get_data_part(link).target
+    }
+
+    fn get_key_part(&self, link: T) -> T {
+        self.get_data_part(link).source
+    }
+}
diff --git a/rust/doublets-patched/doublets/src/mem/split/generic/mod.rs b/rust/doublets-patched/doublets/src/mem/split/generic/mod.rs
new file mode 100644
index 0000000..7e935e4
--- /dev/null
+++ b/rust/doublets-patched/doublets/src/mem/split/generic/mod.rs
@@ -0,0 +1,21 @@
+mod external_recursion_less_base;
+mod external_sources_recursion_less_tree;
+mod external_targets_recursion_less_tree;
+mod internal_recursion_less_base;
+mod internal_sources_linked_list;
+mod internal_sources_recursion_less_tree;
+mod internal_targets_recursion_less_tree;
+mod unused_links;
+
+pub use external_recursion_less_base::{
+    ExternalRecursionlessSizeBalancedTreeBase, ExternalRecursionlessSizeBalancedTreeBaseAbstract,
+};
+pub use external_sources_recursion_less_tree::ExternalSourcesRecursionlessTree;
+pub use external_targets_recursion_less_tree::ExternalTargetsRecursionlessTree;
+
+pub use internal_sources_recursion_less_tree::InternalSourcesRecursionlessTree;
+pub use internal_targets_recursion_less_tree::InternalTargetsRecursionlessTree;
+
+pub use internal_sources_linked_list::InternalSourcesLinkedList;
+
+pub use unused_links::UnusedLinks;
diff --git a/rust/doublets-patched/doublets/src/mem/split/generic/unused_links.rs b/rust/doublets-patched/doublets/src/mem/split/generic/unused_links.rs
new file mode 100644
index 0000000..bf24187
--- /dev/null
+++ b/rust/doublets-patched/doublets/src/mem/split/generic/unused_links.rs
@@ -0,0 +1,101 @@
+use std::{mem::transmute, ptr::NonNull};
+
+use crate::{
+    mem::{header::LinksHeader, split::DataPart, traits::SplitList, LinksList, SplitUpdateMem},
+    split::IndexPart,
+};
+use data::LinkType;
+use trees::{AbsoluteCircularLinkedList, AbsoluteLinkedList, LinkedList};
+
+pub struct UnusedLinks<T: LinkType> {
+    links: NonNull<[DataPart<T>]>,
+    header: NonNull<[IndexPart<T>]>,
+}
+
+impl<T: LinkType> UnusedLinks<T> {
+    #[must_use]
+    pub fn new(links: NonNull<[DataPart<T>]>, header: NonNull<[IndexPart<T>]>) -> Self {
+        Self { links, header }
+    }
+
+    fn get_header(&self) -> &LinksHeader<T> {
+        unsafe { transmute(&self.header.as_ref()[0]) }
+    }
+
+    fn get_mut_header(&mut self) -> &mut LinksHeader<T> {
+        unsafe { transmute(&mut self.header.as_mut()[0]) }
+    }
+
+    fn get_link(&self, link: T) -> &DataPart<T> {
+        unsafe { &self.links.as_ref()[link.as_usize()] }
+    }
+
+    fn get_mut_link(&mut self, link: T) -> &mut DataPart<T> {
+        unsafe { &mut self.links.as_mut()[link.as_usize()] }
+    }
+}
+
+impl<T: LinkType> AbsoluteLinkedList<T> for UnusedLinks<T> {
+    fn get_first(&self) -> T {
+        self.get_header().first_free
+    }
+
+    fn get_last(&self) -> T {
+        self.get_header().last_free
+    }
+
+    fn get_size(&self) -> T {
+        self.get_header().free
+    }
+
+    fn set_first(&mut self, element: T) {
+        self.get_mut_header().first_free = element;
+    }
+
+    fn set_last(&mut self, element: T) {
+        self.get_mut_header().last_free = element;
+    }
+
+    fn set_size(&mut self, size: T) {
+        self.get_mut_header().free = size;
+    }
+}
+
+impl<T: LinkType> LinkedList<T> for UnusedLinks<T> {
+    fn get_previous(&self, element: T) -> T {
+        self.get_link(element).source
+    }
+
+    fn get_next(&self, element: T) -> T {
+        self.get_link(element).target
+    }
+
+    fn set_previous(&mut self, element: T, previous: T) {
+        self.get_mut_link(element).source = previous;
+    }
+
+    fn set_next(&mut self, element: T, next: T) {
+        self.get_mut_link(element).target = next;
+    }
+}
+
+impl<T: LinkType> AbsoluteCircularLinkedList<T> for UnusedLinks<T> {}
+
+impl<T: LinkType> SplitUpdateMem<T> for UnusedLinks<T> {
+    fn update_mem(&mut self, data: NonNull<[DataPart<T>]>, index: NonNull<[IndexPart<T>]>) {
+        self.links = data;
+        self.header = index;
+    }
+}
+
+impl<T: LinkType> LinksList<T> for UnusedLinks<T> {
+    fn detach(&mut self, link: T) {
+        AbsoluteCircularLinkedList::detach(self, link);
+    }
+
+    fn attach_as_first(&mut self, link: T) {
+        AbsoluteCircularLinkedList::attach_as_first(self, link);
+    }
+}
+
+impl<T: LinkType> SplitList<T> for UnusedLinks<T> {}
diff --git a/rust/doublets-patched/doublets/src/mem/split/index_part.rs b/rust/doublets-patched/doublets/src/mem/split/index_part.rs
new file mode 100644
index 0000000..9533e22
--- /dev/null
+++ b/rust/doublets-patched/doublets/src/mem/split/index_part.rs
@@ -0,0 +1,15 @@
+use data::LinkType;
+
+#[derive(Debug, Default, Eq, PartialEq, Hash, Clone)]
+#[repr(C)]
+pub struct IndexPart<T: LinkType> {
+    pub(crate) root_as_source: T,
+    pub(crate) left_as_source: T,
+    pub(crate) right_as_source: T,
+    pub(crate) size_as_source: T,
+
+    pub(crate) root_as_target: T,
+    pub(crate) left_as_target: T,
+    pub(crate) right_as_target: T,
+    pub(crate) size_as_target: T,
+}
diff --git a/rust/doublets-patched/doublets/src/mem/split/mod.rs b/rust/doublets-patched/doublets/src/mem/split/mod.rs
new file mode 100644
index 0000000..432a367
--- /dev/null
+++ b/rust/doublets-patched/doublets/src/mem/split/mod.rs
@@ -0,0 +1,10 @@
+mod data_part;
+mod generic;
+mod index_part;
+mod store;
+
+pub use data_part::DataPart;
+pub use index_part::IndexPart;
+
+pub use generic::*;
+pub use store::Store;
diff --git a/rust/doublets-patched/doublets/src/mem/split/store.rs b/rust/doublets-patched/doublets/src/mem/split/store.rs
new file mode 100644
index 0000000..628f7c4
--- /dev/null
+++ b/rust/doublets-patched/doublets/src/mem/split/store.rs
@@ -0,0 +1,896 @@
+use std::{cmp::Ordering, error::Error, mem::transmute, ptr::NonNull};
+
+use crate::{
+    mem::{
+        split::{
+            DataPart, ExternalSourcesRecursionlessTree, ExternalTargetsRecursionlessTree,
+            IndexPart, InternalSourcesLinkedList, InternalSourcesRecursionlessTree,
+            InternalTargetsRecursionlessTree, UnusedLinks,
+        },
+        LinksHeader, LinksTree, SplitList, SplitTree, SplitUpdateMem,
+    },
+    Doublets, DoubletsExt, Link, Links, LinksError, ReadHandler, WriteHandler,
+};
+use data::{Flow, LinkType, LinksConstants, ToQuery};
+use mem::{RawMem, DEFAULT_PAGE_SIZE};
+use trees::RelativeCircularLinkedList;
+
+pub struct Store<
+    T: LinkType,
+    MD: RawMem<DataPart<T>>,
+    MI: RawMem<IndexPart<T>>,
+    IS: SplitTree<T> = InternalSourcesRecursionlessTree<T>,
+    ES: SplitTree<T> = ExternalSourcesRecursionlessTree<T>,
+    IT: SplitTree<T> = InternalTargetsRecursionlessTree<T>,
+    ET: SplitTree<T> = ExternalTargetsRecursionlessTree<T>,
+    UL: SplitList<T> = UnusedLinks<T>,
+> {
+    data_mem: MD,
+    index_mem: MI,
+
+    data_ptr: NonNull<[DataPart<T>]>,
+    index_ptr: NonNull<[IndexPart<T>]>,
+
+    data_step: usize,
+    index_step: usize,
+
+    constants: LinksConstants<T>,
+
+    internal_sources: IS,
+    pub external_sources: ES,
+    internal_targets: IT,
+    pub external_targets: ET,
+
+    sources_list: InternalSourcesLinkedList<T>,
+    unused: UL,
+}
+
+impl<
+        T: LinkType,
+        MD: RawMem<DataPart<T>>,
+        MI: RawMem<IndexPart<T>>,
+        IS: SplitTree<T>,
+        ES: SplitTree<T>,
+        IT: SplitTree<T>,
+        ET: SplitTree<T>,
+        UL: SplitList<T>,
+    > Store<T, MD, MI, IS, ES, IT, ET, UL>
+{
+    const USE_LIST: bool = false;
+    #[cfg(not(miri))]
+    const SIZE_STEP: usize = 2_usize.pow(20);
+    #[cfg(miri)]
+    const SIZE_STEP: usize = 2_usize.pow(10);
+
+    // TODO: create Options
+    pub fn with_constants(
+        data_mem: MD,
+        index_mem: MI,
+        constants: LinksConstants<T>,
+    ) -> Result<Store<T, MD, MI>, LinksError<T>> {
+        let dangling_data = NonNull::slice_from_raw_parts(NonNull::dangling(), 0);
+        let dangling_index = NonNull::slice_from_raw_parts(NonNull::dangling(), 0);
+
+        let internal_sources =
+            InternalSourcesRecursionlessTree::new(constants.clone(), dangling_data, dangling_index);
+        let external_sources =
+            ExternalSourcesRecursionlessTree::new(constants.clone(), dangling_data, dangling_index);
+
+        let internal_targets =
+            InternalTargetsRecursionlessTree::new(constants.clone(), dangling_data, dangling_index);
+        let external_targets =
+            ExternalTargetsRecursionlessTree::new(constants.clone(), dangling_data, dangling_index);
+
+        let sources_list =
+            InternalSourcesLinkedList::new(constants.clone(), dangling_data, dangling_index);
+        let unused = UnusedLinks::new(dangling_data, dangling_index);
+
+        let mut new = Store {
+            data_mem,
+            index_mem,
+            data_ptr: dangling_data,
+            index_ptr: dangling_index,
+            data_step: Self::SIZE_STEP,
+            index_step: Self::SIZE_STEP,
+            constants,
+            internal_sources,
+            external_sources,
+            internal_targets,
+            external_targets,
+            sources_list,
+            unused,
+        };
+
+        // SAFETY: Without this, the code will become unsafe
+        unsafe {
+            new.init()?;
+        }
+        Ok(new)
+    }
+
+    pub fn new(data_mem: MD, index_mem: MI) -> Result<Store<T, MD, MI>, LinksError<T>> {
+        Self::with_constants(data_mem, index_mem, Default::default())
+    }
+
+    fn mut_from_mem<'a, U>(mut ptr: NonNull<[U]>, index: usize) -> Option<&'a mut U> {
+        if index < ptr.len() {
+            // SAFETY: `ptr` is non-dangling slice
+            Some(unsafe {
+                let slice = ptr.as_mut();
+                &mut slice[index]
+            })
+        } else {
+            None
+        }
+    }
+
+    fn get_from_mem<'a, U>(ptr: NonNull<[U]>, index: usize) -> Option<&'a U> {
+        Self::mut_from_mem(ptr, index).map(|v| &*v)
+    }
+
+    fn get_header(&self) -> &LinksHeader<T> {
+        // SAFETY: `LinksHeader` and `IndexPart` layout are equivalent
+        unsafe {
+            Self::get_from_mem(self.index_ptr, 0)
+                .map(|x| transmute(x))
+                .expect("Header should be in index memory")
+        }
+    }
+
+    fn mut_header(&mut self) -> &mut LinksHeader<T> {
+        // SAFETY: `LinksHeader` and `IndexPart` layout are equivalent
+        unsafe {
+            Self::mut_from_mem(self.index_ptr, 0)
+                .map(|x| transmute(x))
+                .expect("Header should be in index memory")
+        }
+    }
+
+    pub fn get_data_part(&self, index: T) -> &DataPart<T> {
+        Self::get_from_mem(self.data_ptr, index.as_usize())
+            .expect("Data part should be in data memory")
+    }
+
+    unsafe fn get_data_unchecked(&self, index: T) -> &DataPart<T> {
+        Self::get_from_mem(self.data_ptr, index.as_usize()).unwrap_unchecked()
+    }
+
+    fn mut_data_part(&mut self, index: T) -> &mut DataPart<T> {
+        Self::mut_from_mem(self.data_ptr, index.as_usize())
+            .expect("Data part should be in data memory")
+    }
+
+    pub fn get_index_part(&self, index: T) -> &IndexPart<T> {
+        Self::get_from_mem(self.index_ptr, index.as_usize())
+            .expect("Index part should be in index memory")
+    }
+
+    fn mut_index_part(&mut self, index: T) -> &mut IndexPart<T> {
+        Self::mut_from_mem(self.index_ptr, index.as_usize())
+            .expect("Index part should be in index memory")
+    }
+
+    unsafe fn mut_source_header_root(&mut self) -> *mut T {
+        &mut self.mut_header().root_as_source
+    }
+
+    unsafe fn mut_target_header_root(&mut self) -> *mut T {
+        &mut self.mut_header().root_as_target
+    }
+
+    unsafe fn mut_source_root(&mut self, link: T) -> *mut T {
+        &mut self.mut_index_part(link).root_as_source
+    }
+
+    unsafe fn mut_target_root(&mut self, link: T) -> *mut T {
+        &mut self.mut_index_part(link).root_as_target
+    }
+
+    unsafe fn detach_internal_source_unchecked(&mut self, root: *mut T, index: T) {
+        self.internal_sources.detach(&mut *root, index);
+    }
+
+    unsafe fn detach_internal_target_unchecked(&mut self, root: *mut T, index: T) {
+        self.internal_targets.detach(&mut *root, index);
+    }
+
+    unsafe fn attach_internal_source_unchecked(&mut self, root: *mut T, index: T) {
+        self.internal_sources.attach(&mut *root, index);
+    }
+
+    unsafe fn attach_internal_target_unchecked(&mut self, root: *mut T, index: T) {
+        self.internal_targets.attach(&mut *root, index);
+    }
+
+    unsafe fn detach_external_source_unchecked(&mut self, root: *mut T, index: T) {
+        self.external_sources.detach(&mut *root, index);
+    }
+
+    unsafe fn detach_external_target_unchecked(&mut self, root: *mut T, index: T) {
+        self.external_targets.detach(&mut *root, index);
+    }
+
+    unsafe fn attach_external_source_unchecked(&mut self, root: *mut T, index: T) {
+        self.external_sources.attach(&mut *root, index);
+    }
+
+    unsafe fn attach_external_target_unchecked(&mut self, root: *mut T, index: T) {
+        self.external_targets.attach(&mut *root, index);
+    }
+
+    unsafe fn detach_internal_source(&mut self, root: T, index: T) {
+        let root = self.mut_source_root(root);
+        self.detach_internal_source_unchecked(root, index);
+    }
+
+    unsafe fn detach_internal_target(&mut self, root: T, index: T) {
+        let root = self.mut_target_root(root);
+        self.detach_internal_target_unchecked(root, index);
+    }
+
+    unsafe fn attach_internal_source(&mut self, root: T, index: T) {
+        let root = self.mut_source_root(root);
+        self.attach_internal_source_unchecked(root, index);
+    }
+
+    unsafe fn attach_internal_target(&mut self, root: T, index: T) {
+        let root = self.mut_target_root(root);
+        self.attach_internal_target_unchecked(root, index);
+    }
+
+    unsafe fn detach_external_source(&mut self, index: T) {
+        let root = self.mut_source_header_root();
+        self.detach_external_source_unchecked(root, index);
+    }
+
+    unsafe fn detach_external_target(&mut self, index: T) {
+        let root = self.mut_target_header_root();
+        self.detach_external_target_unchecked(root, index);
+    }
+
+    unsafe fn attach_external_source(&mut self, index: T) {
+        let root = self.mut_source_header_root();
+        self.attach_external_source_unchecked(root, index);
+    }
+
+    unsafe fn attach_external_target(&mut self, index: T) {
+        let root = self.mut_target_header_root();
+        self.attach_external_target_unchecked(root, index);
+    }
+
+    fn update_mem(&mut self, data: NonNull<[DataPart<T>]>, index: NonNull<[IndexPart<T>]>) {
+        self.data_ptr = data;
+        self.index_ptr = index;
+
+        self.internal_sources.update_mem(data, index);
+        self.external_sources.update_mem(data, index);
+        self.internal_targets.update_mem(data, index);
+        self.external_targets.update_mem(data, index);
+        self.sources_list.update_mem(data, index);
+        self.unused.update_mem(data, index);
+    }
+
+    fn align(mut to_align: usize, target: usize) -> usize {
+        debug_assert!(to_align >= target);
+
+        // TODO: optimize this `if`
+        if to_align % target != 0 {
+            to_align = ((to_align / target) * target) + target;
+        }
+        to_align
+    }
+
+    unsafe fn init(&mut self) -> Result<(), LinksError<T>> {
+        let data = NonNull::from(self.data_mem.alloc(DEFAULT_PAGE_SIZE)?);
+        let index = NonNull::from(self.index_mem.alloc(DEFAULT_PAGE_SIZE)?);
+        self.update_mem(data, index);
+
+        let header = self.get_header().clone();
+        let allocated = header.allocated.as_usize();
+
+        let mut data_capacity = allocated;
+        data_capacity = data_capacity.max(self.data_mem.allocated());
+        data_capacity = data_capacity.max(self.data_step);
+
+        let mut index_capacity = allocated;
+        index_capacity = index_capacity.max(self.index_mem.allocated());
+        index_capacity = index_capacity.max(self.index_step);
+
+        data_capacity = Self::align(data_capacity, self.data_step);
+        index_capacity = Self::align(index_capacity, self.index_step);
+
+        let data = NonNull::from(self.data_mem.alloc(data_capacity)?);
+        let index = NonNull::from(self.index_mem.alloc(index_capacity)?);
+        self.update_mem(data, index);
+
+        self.mut_header().reserved = T::try_from(self.data_mem.allocated() - 1).expect("always ok");
+        Ok(())
+    }
+
+    fn total(&self) -> T {
+        let header = self.get_header();
+        header.allocated - header.free
+    }
+
+    pub fn is_unused(&self, link: T) -> bool {
+        let header = self.get_header();
+        if link <= header.allocated && header.first_free != link {
+            // TODO: May be this check is not needed
+            let index = self.get_index_part(link);
+            let data = self.get_data_part(link);
+            index.size_as_target == T::funty(0) && data.source != T::funty(0)
+        } else {
+            true
+        }
+    }
+
+    //fn is_non_
+
+    pub fn is_virtual(&self, link: T) -> bool {
+        self.is_unused(link)
+    }
+
+    pub fn exists(&self, link: T) -> bool {
+        let constants = self.constants();
+        let header = self.get_header();
+
+        // TODO: use attributes expressions feature
+        // TODO: use `Range::contains`
+        link >= *constants.internal_range.start()
+            && link <= header.allocated
+            && !self.is_unused(link)
+    }
+
+    // SAFETY: must be link exists
+    unsafe fn get_link_unchecked(&self, index: T) -> Link<T> {
+        debug_assert!(self.exists(index));
+
+        let raw = self.get_data_unchecked(index);
+        Link::new(index, raw.source, raw.target)
+    }
+
+    fn try_each_by_core(&self, handler: ReadHandler<'_, T>, query: &[T]) -> Flow {
+        let query = query.to_query();
+
+        if query.is_empty() {
+            for index in T::funty(1)..=self.get_header().allocated {
+                if let Some(link) = self.get_link(index) {
+                    handler(link)?;
+                }
+            }
+            return Flow::Continue;
+        }
+
+        let constants = self.constants.clone();
+        let any = constants.any;
+        let index = query[constants.index_part.as_usize()];
+        if query.len() == 1 {
+            return if index == any {
+                self.try_each_by_core(handler, &[])
+            } else if let Some(link) = self.get_link(index) {
+                handler(link)
+            } else {
+                Flow::Continue
+            };
+        }
+        //
+        if query.len() == 2 {
+            let value = query[1];
+            return if index == any {
+                if value == any {
+                    self.try_each_by_core(handler, &[])
+                } else {
+                    self.try_each_by_core(handler, &[index, value, any])?;
+                    self.try_each_by_core(handler, &[index, any, value])
+                }
+            } else if let Some(link) = self.get_link(index) {
+                if value == any || link.source == value || link.target == value {
+                    handler(link)
+                } else {
+                    Flow::Continue
+                }
+            } else {
+                Flow::Continue
+            };
+        }
+        //
+        if query.len() == 3 {
+            let source = query[constants.source_part.as_usize()];
+            let target = query[constants.target_part.as_usize()];
+            let is_virtual_source = self.is_virtual(source);
+            let is_virtual_target = self.is_virtual(target);
+
+            return if index == any {
+                if (source, target) == (any, any) {
+                    self.try_each_by_core(handler, &[])
+                } else if source == any {
+                    if is_virtual_target {
+                        self.external_targets.each_usages(target, handler)
+                    } else {
+                        self.internal_targets.each_usages(target, handler)
+                    }
+                } else if target == any {
+                    if is_virtual_source {
+                        self.external_sources.each_usages(source, handler)
+                    } else if Self::USE_LIST {
+                        self.sources_list.each_usages(source, handler)
+                    } else {
+                        self.internal_sources.each_usages(source, handler)
+                    }
+                } else {
+                    let link = if true {
+                        if is_virtual_source && is_virtual_target {
+                            self.external_sources.search(source, target)
+                        } else if is_virtual_source {
+                            self.internal_targets.search(source, target)
+                        } else if is_virtual_target {
+                            if Self::USE_LIST {
+                                self.external_sources.search(source, target)
+                            } else {
+                                self.internal_sources.search(source, target)
+                            }
+                        } else if Self::USE_LIST
+                            || self.internal_sources.count_usages(source)
+                                > self.internal_targets.count_usages(target)
+                        {
+                            self.internal_targets.search(source, target)
+                        } else {
+                            self.internal_sources.search(source, target)
+                        }
+                    } else if Self::USE_LIST
+                        || self.internal_sources.count_usages(source)
+                            > self.internal_targets.count_usages(target)
+                    {
+                        self.internal_targets.search(source, target)
+                    } else {
+                        self.internal_sources.search(source, target)
+                    };
+                    return if link == constants.null {
+                        Flow::Continue
+                    } else {
+                        // SAFETY: link 100% exists
+                        let link = unsafe { self.get_link(link).unwrap_unchecked() };
+                        handler(link)
+                    };
+                }
+            } else if let Some(link) = self.get_link(index) {
+                if (source, target) == (any, any) {
+                    handler(link)
+                } else if source != any && target != any {
+                    if (link.source, link.target) == (source, target) {
+                        handler(link)
+                    } else {
+                        Flow::Continue
+                    }
+                } else if source == any {
+                    if link.target == target {
+                        handler(link)
+                    } else {
+                        Flow::Continue
+                    }
+                } else if target == any {
+                    if link.source == source {
+                        handler(link)
+                    } else {
+                        Flow::Continue
+                    }
+                } else {
+                    Flow::Continue
+                }
+            } else {
+                Flow::Continue
+            };
+        }
+        todo!()
+    }
+
+    fn resolve_danglind_internal(&mut self, index: T) {
+        let any = self.constants.any;
+        for link in self
+            .each_iter([any, index, any])
+            .filter(|link| link.index != index)
+        {
+            unsafe {
+                self.detach_internal_source(index, link.index);
+                self.attach_external_source(link.index);
+            }
+        }
+
+        for link in self
+            .each_iter([any, any, index])
+            .filter(|link| link.index != index)
+            .filter(|link| !link.is_full())
+        {
+            unsafe {
+                self.detach_internal_target(index, link.index);
+                self.attach_external_target(link.index);
+            }
+        }
+    }
+
+    fn resolve_danglind_external(&mut self, free: T) {
+        let any = self.constants().any;
+        for link in self
+            .each_iter([any, free, any])
+            .filter(|link| link.index != free)
+        {
+            unsafe {
+                self.detach_external_source(link.index);
+                self.attach_internal_source(free, link.index);
+            }
+        }
+
+        for link in self
+            .each_iter([any, any, free])
+            .filter(|link| link.index != free)
+            .filter(|link| !link.is_full())
+        {
+            unsafe {
+                self.detach_external_target(link.index);
+                self.attach_internal_target(free, link.index);
+            }
+        }
+    }
+}
+
+impl<
+        T: LinkType,
+        MD: RawMem<DataPart<T>>,
+        MI: RawMem<IndexPart<T>>,
+        IS: SplitTree<T>,
+        ES: SplitTree<T>,
+        IT: SplitTree<T>,
+        ET: SplitTree<T>,
+        UL: SplitList<T>,
+    > Links<T> for Store<T, MD, MI, IS, ES, IT, ET, UL>
+{
+    fn constants(&self) -> &LinksConstants<T> {
+        &self.constants
+    }
+
+    fn count_links(&self, query: &[T]) -> T {
+        if query.is_empty() {
+            return self.total();
+        }
+
+        let constants = self.constants();
+        let any = constants.any;
+        let index = query[constants.index_part.as_usize()];
+        if query.len() == 1 {
+            return if index == any {
+                self.total()
+            } else if self.exists(index) {
+                T::funty(1)
+            } else {
+                T::funty(0)
+            };
+        }
+
+        if query.len() == 2 {
+            let value = query[1];
+            let is_virtual_val = self.is_virtual(value);
+
+            return if index == any {
+                if value == any {
+                    self.total()
+                } else if is_virtual_val {
+                    self.external_sources.count_usages(value)
+                        + self.external_targets.count_usages(value)
+                } else if Self::USE_LIST {
+                    self.sources_list.count_usages(value)
+                        + self.internal_targets.count_usages(value)
+                } else {
+                    self.internal_sources.count_usages(value)
+                        + self.internal_targets.count_usages(value)
+                }
+            } else if !self.exists(index) {
+                T::funty(0)
+            } else if value == any {
+                T::funty(1)
+            } else {
+                let stored = self.get_data_part(index);
+                if (stored.source, stored.target) == (value, value) {
+                    T::funty(1)
+                } else {
+                    T::funty(0)
+                }
+            };
+        }
+
+        if query.len() == 3 {
+            let source = query[constants.source_part.as_usize()];
+            let target = query[constants.target_part.as_usize()];
+
+            let is_virtual_source = self.is_virtual(source);
+            let is_virtual_target = self.is_virtual(target);
+
+            return if index == any {
+                if (source, target) == (any, any) {
+                    self.total()
+                } else if source == any {
+                    if is_virtual_target {
+                        self.external_targets.count_usages(target)
+                    } else {
+                        self.internal_targets.count_usages(target)
+                    }
+                } else if is_virtual_source {
+                    self.external_sources.count_usages(source)
+                } else if target == any {
+                    if Self::USE_LIST {
+                        self.sources_list.count_usages(source)
+                    } else {
+                        self.internal_sources.count_usages(source)
+                    }
+                } else {
+                    let link = if true {
+                        if is_virtual_source && is_virtual_target {
+                            self.external_sources.search(source, target)
+                        } else if is_virtual_source {
+                            self.internal_targets.search(source, target)
+                        } else if is_virtual_target {
+                            if Self::USE_LIST {
+                                self.external_sources.search(source, target)
+                            } else {
+                                self.internal_sources.search(source, target)
+                            }
+                        } else if Self::USE_LIST
+                            || self.internal_sources.count_usages(source)
+                                > self.internal_targets.count_usages(target)
+                        {
+                            self.internal_targets.search(source, target)
+                        } else {
+                            self.internal_sources.search(source, target)
+                        }
+                    } else if Self::USE_LIST
+                        || self.internal_sources.count_usages(source)
+                            > self.internal_targets.count_usages(target)
+                    {
+                        self.internal_targets.search(source, target)
+                    } else {
+                        self.internal_sources.search(source, target)
+                    };
+                    return if link == constants.null {
+                        T::funty(0)
+                    } else {
+                        T::funty(1)
+                    };
+                }
+            } else if !self.exists(index) {
+                T::funty(0)
+            } else if (source, target) == (any, any) {
+                T::funty(1)
+            } else {
+                let link = unsafe { self.get_link_unchecked(index) };
+                if source != any && target != any {
+                    if (link.source, link.target) == (source, target) {
+                        T::funty(1)
+                    } else {
+                        T::funty(0)
+                    }
+                } else if source == any {
+                    if link.target == target {
+                        T::funty(1)
+                    } else {
+                        T::funty(0)
+                    }
+                } else if target == any {
+                    if link.source == source {
+                        T::funty(1)
+                    } else {
+                        T::funty(0)
+                    }
+                } else {
+                    T::funty(0)
+                }
+            };
+        }
+
+        todo!()
+    }
+
+    fn create_links(
+        &mut self,
+        _query: &[T],
+        handler: WriteHandler<'_, T>,
+    ) -> Result<Flow, LinksError<T>> {
+        let constants = self.constants().clone();
+        let header = self.get_header();
+        let mut free = header.first_free;
+        if free == constants.null {
+            let max_inner = *constants.internal_range.end();
+            if header.allocated >= max_inner {
+                return Err(LinksError::LimitReached(max_inner));
+            }
+
+            if header.allocated >= header.reserved - T::funty(1) {
+                let data = NonNull::from(
+                    self.data_mem
+                        .alloc(self.data_mem.allocated() + self.data_step)?,
+                );
+                let index = NonNull::from(
+                    self.index_mem
+                        .alloc(self.index_mem.allocated() + self.index_step)?,
+                );
+                self.update_mem(data, index);
+                // let reserved = self.data_mem.allocated();
+                let reserved = self.index_mem.allocated();
+                let header = self.mut_header();
+                // header.reserved = T::try_from(reserved / Self::DATA_SIZE).unwrap()
+                header.reserved = T::try_from(reserved).expect("always ok");
+            }
+            let header = self.mut_header();
+            header.allocated += T::funty(1);
+            free = header.allocated;
+        } else {
+            self.unused.detach(free);
+        }
+
+        self.resolve_danglind_external(free);
+
+        Ok(handler(
+            Link::nothing(),
+            Link::new(free, T::funty(0), T::funty(0)),
+        ))
+    }
+
+    fn each_links(&self, query: &[T], handler: ReadHandler<'_, T>) -> Flow {
+        self.try_each_by_core(handler, query)
+    }
+
+    fn update_links(
+        &mut self,
+        query: &[T],
+        change: &[T],
+        handler: WriteHandler<'_, T>,
+    ) -> Result<Flow, LinksError<T>> {
+        let index = query[0];
+        let new_source = change[1];
+        let new_target = change[2];
+
+        let link = self.try_get_link(index)?;
+
+        if link.source != T::funty(0) {
+            // SAFETY: Here index attach to source
+            unsafe {
+                if self.is_virtual(link.source) {
+                    self.detach_external_source(index);
+                } else if Self::USE_LIST {
+                    // self.sources_list.attach_as_last(source, index);
+                    todo!()
+                } else {
+                    self.detach_internal_source(link.source, index);
+                }
+            }
+        }
+
+        if link.target != T::funty(0) {
+            // SAFETY: Here index attach to target
+            unsafe {
+                if self.is_virtual(link.target) {
+                    self.detach_external_target(index);
+                } else {
+                    self.detach_internal_target(link.target, index);
+                }
+            }
+        }
+
+        let virtual_source = self.is_virtual(new_source);
+        let virtual_target = self.is_virtual(new_target);
+        let place = self.mut_data_part(index);
+        place.source = new_source;
+        place.target = new_target;
+        let place = place.clone();
+
+        if place.source != T::funty(0) {
+            // SAFETY: Here index attach to source
+            unsafe {
+                if virtual_source {
+                    self.attach_external_source(index);
+                } else if Self::USE_LIST {
+                    // self.sources_list.attach_as_last(source, index);
+                    todo!()
+                } else {
+                    self.attach_internal_source(place.source, index);
+                }
+            }
+        }
+
+        if place.target != T::funty(0) {
+            // SAFETY: Here index attach to target
+            unsafe {
+                if virtual_target {
+                    self.attach_external_target(index);
+                } else {
+                    self.attach_internal_target(place.target, index);
+                }
+            }
+        }
+
+        Ok(handler(link, Link::new(index, place.source, place.target)))
+    }
+
+    fn delete_links(
+        &mut self,
+        query: &[T],
+        handler: WriteHandler<'_, T>,
+    ) -> Result<Flow, LinksError<T>> {
+        let index = query[0];
+        let link = self.try_get_link(index)?;
+
+        self.resolve_danglind_internal(index);
+
+        self.update(index, T::funty(0), T::funty(0))?;
+
+        // TODO: move to `delete_core`
+        let header = self.get_header();
+
+        match index.cmp(&header.allocated) {
+            Ordering::Less => self.unused.attach_as_first(index),
+            Ordering::Greater => unreachable!(),
+            Ordering::Equal => {
+                let allocated = self.get_header().allocated;
+                let header = self.mut_header();
+                header.allocated = allocated - T::funty(1);
+
+                loop {
+                    let allocated = self.get_header().allocated;
+                    if !(allocated > T::funty(0) && self.is_unused(allocated)) {
+                        break;
+                    }
+                    self.unused.detach(allocated);
+                    self.mut_header().allocated = allocated - T::funty(1);
+                }
+            }
+        }
+        Ok(handler(
+            Link::new(index, link.source, link.target),
+            Link::nothing(),
+        ))
+    }
+}
+
+impl<
+        T: LinkType,
+        MD: RawMem<DataPart<T>>,
+        MI: RawMem<IndexPart<T>>,
+        IS: SplitTree<T>,
+        ES: SplitTree<T>,
+        IT: SplitTree<T>,
+        ET: SplitTree<T>,
+        UL: SplitList<T>,
+    > Doublets<T> for Store<T, MD, MI, IS, ES, IT, ET, UL>
+{
+    fn get_link(&self, index: T) -> Option<Link<T>> {
+        if self.exists(index) {
+            Some(unsafe { self.get_link_unchecked(index) })
+        } else {
+            None
+        }
+    }
+}
+
+unsafe impl<
+        T: LinkType,
+        MD: RawMem<DataPart<T>>,
+        MI: RawMem<IndexPart<T>>,
+        IS: SplitTree<T>,
+        ES: SplitTree<T>,
+        IT: SplitTree<T>,
+        ET: SplitTree<T>,
+        UL: SplitList<T>,
+    > Sync for Store<T, MD, MI, IS, ES, IT, ET, UL>
+{
+}
+
+unsafe impl<
+        T: LinkType,
+        MD: RawMem<DataPart<T>>,
+        MI: RawMem<IndexPart<T>>,
+        IS: SplitTree<T>,
+        ES: SplitTree<T>,
+        IT: SplitTree<T>,
+        ET: SplitTree<T>,
+        UL: SplitList<T>,
+    > Send for Store<T, MD, MI, IS, ES, IT, ET, UL>
+{
+}
diff --git a/rust/doublets-patched/doublets/src/mem/traits.rs b/rust/doublets-patched/doublets/src/mem/traits.rs
new file mode 100644
index 0000000..dd8df6f
--- /dev/null
+++ b/rust/doublets-patched/doublets/src/mem/traits.rs
@@ -0,0 +1,41 @@
+use crate::{
+    mem::unit::LinkPart,
+    split::{DataPart, IndexPart},
+    Link,
+};
+use data::{Flow, LinkType};
+use std::ptr::NonNull;
+
+pub trait LinksTree<T: LinkType> {
+    fn count_usages(&self, root: T) -> T;
+
+    fn search(&self, source: T, target: T) -> T;
+
+    fn each_usages<H: FnMut(Link<T>) -> Flow + ?Sized>(&self, root: T, handler: &mut H) -> Flow;
+
+    fn detach(&mut self, root: &mut T, index: T);
+
+    fn attach(&mut self, root: &mut T, index: T);
+}
+
+pub trait UnitUpdateMem<T: LinkType> {
+    fn update_mem(&mut self, mem: NonNull<[LinkPart<T>]>);
+}
+
+pub trait UnitTree<T: LinkType>: LinksTree<T> + UnitUpdateMem<T> {}
+
+pub trait SplitUpdateMem<T: LinkType> {
+    fn update_mem(&mut self, data: NonNull<[DataPart<T>]>, index: NonNull<[IndexPart<T>]>);
+}
+
+pub trait SplitTree<T: LinkType>: LinksTree<T> + SplitUpdateMem<T> {}
+
+pub trait LinksList<T: LinkType> {
+    fn detach(&mut self, link: T);
+
+    fn attach_as_first(&mut self, link: T);
+}
+
+pub trait UnitList<T: LinkType>: LinksList<T> + UnitUpdateMem<T> {}
+
+pub trait SplitList<T: LinkType>: LinksList<T> + SplitUpdateMem<T> {}
diff --git a/rust/doublets-patched/doublets/src/mem/unit/generic/links_recursionless_size_balanced_tree_base.rs b/rust/doublets-patched/doublets/src/mem/unit/generic/links_recursionless_size_balanced_tree_base.rs
new file mode 100644
index 0000000..4f9fb23
--- /dev/null
+++ b/rust/doublets-patched/doublets/src/mem/unit/generic/links_recursionless_size_balanced_tree_base.rs
@@ -0,0 +1,66 @@
+use std::{marker::PhantomData, ptr::NonNull};
+
+use crate::{
+    mem::{header::LinksHeader, unit::raw_link::LinkPart, LinksTree},
+    Link,
+};
+use data::{LinkType, LinksConstants};
+use trees::NoRecurSzbTree;
+
+// TODO: why is there so much duplication in OOP!!! FIXME
+pub struct LinksRecursionlessSizeBalancedTreeBase<T: LinkType> {
+    pub mem: NonNull<[LinkPart<T>]>,
+    pub r#break: T,
+    pub r#continue: T,
+
+    _phantom: PhantomData<T>,
+}
+
+impl<T: LinkType> LinksRecursionlessSizeBalancedTreeBase<T> {
+    pub fn new(constants: LinksConstants<T>, mem: NonNull<[LinkPart<T>]>) -> Self {
+        Self {
+            mem,
+            r#break: constants.r#break,
+            r#continue: constants.r#continue,
+            _phantom: Default::default(),
+        }
+    }
+}
+
+pub trait LinkRecursionlessSizeBalancedTreeBaseAbstract<T: LinkType>:
+    NoRecurSzbTree<T> + LinksTree<T>
+{
+    fn get_header(&self) -> &LinksHeader<T>;
+
+    fn get_mut_header(&mut self) -> &mut LinksHeader<T>;
+
+    fn get_link(&self, link: T) -> &LinkPart<T>;
+
+    fn get_mut_link(&mut self, link: T) -> &mut LinkPart<T>;
+
+    fn get_tree_root(&self) -> T;
+
+    fn get_base_part(&self, link: T) -> T;
+
+    // TODO: rename
+    fn first_is_to_the_left_of_second_4(
+        &self,
+        source: T,
+        target: T,
+        root_source: T,
+        root_target: T,
+    ) -> bool;
+
+    fn first_is_to_the_right_of_second_4(
+        &self,
+        source: T,
+        target: T,
+        root_source: T,
+        root_target: T,
+    ) -> bool;
+
+    fn get_link_value(&self, index: T) -> Link<T> {
+        let link = self.get_link(index);
+        Link::new(index, link.source, link.target)
+    }
+}
diff --git a/rust/doublets-patched/doublets/src/mem/unit/generic/mod.rs b/rust/doublets-patched/doublets/src/mem/unit/generic/mod.rs
new file mode 100644
index 0000000..f0017e4
--- /dev/null
+++ b/rust/doublets-patched/doublets/src/mem/unit/generic/mod.rs
@@ -0,0 +1,12 @@
+pub use links_recursionless_size_balanced_tree_base::{
+    LinkRecursionlessSizeBalancedTreeBaseAbstract, LinksRecursionlessSizeBalancedTreeBase,
+};
+
+pub use sources_recursionless_size_balanced_tree::LinksSourcesRecursionlessSizeBalancedTree;
+pub use targets_recursionless_size_balanced_tree::LinksTargetsRecursionlessSizeBalancedTree;
+pub use unused_links::UnusedLinks;
+
+mod links_recursionless_size_balanced_tree_base;
+mod sources_recursionless_size_balanced_tree;
+mod targets_recursionless_size_balanced_tree;
+mod unused_links;
diff --git a/rust/doublets-patched/doublets/src/mem/unit/generic/sources_recursionless_size_balanced_tree.rs b/rust/doublets-patched/doublets/src/mem/unit/generic/sources_recursionless_size_balanced_tree.rs
new file mode 100644
index 0000000..8dd920c
--- /dev/null
+++ b/rust/doublets-patched/doublets/src/mem/unit/generic/sources_recursionless_size_balanced_tree.rs
@@ -0,0 +1,252 @@
+use std::{mem::transmute, ptr::NonNull};
+
+use crate::{
+    mem::{
+        header::LinksHeader,
+        unit::{
+            generic::{
+                LinkRecursionlessSizeBalancedTreeBaseAbstract,
+                LinksRecursionlessSizeBalancedTreeBase,
+            },
+            raw_link::LinkPart,
+        },
+        LinksTree, UnitTree, UnitUpdateMem,
+    },
+    Link,
+};
+use data::{Flow, LinkType, LinksConstants};
+use trees::{NoRecurSzbTree, SzbTree};
+
+pub struct LinksSourcesRecursionlessSizeBalancedTree<T: LinkType> {
+    base: LinksRecursionlessSizeBalancedTreeBase<T>,
+}
+
+impl<T: LinkType> LinksSourcesRecursionlessSizeBalancedTree<T> {
+    pub fn new(constants: LinksConstants<T>, mem: NonNull<[LinkPart<T>]>) -> Self {
+        Self {
+            base: LinksRecursionlessSizeBalancedTreeBase::new(constants, mem),
+        }
+    }
+}
+
+impl<T: LinkType> SzbTree<T> for LinksSourcesRecursionlessSizeBalancedTree<T> {
+    unsafe fn get_left_reference(&self, node: T) -> *const T {
+        std::ptr::addr_of!(self.get_link(node).left_as_source)
+    }
+
+    unsafe fn get_right_reference(&self, node: T) -> *const T {
+        std::ptr::addr_of!(self.get_link(node).right_as_source)
+    }
+
+    unsafe fn get_mut_left_reference(&mut self, node: T) -> *mut T {
+        std::ptr::addr_of_mut!(self.get_mut_link(node).left_as_source)
+    }
+
+    unsafe fn get_mut_right_reference(&mut self, node: T) -> *mut T {
+        std::ptr::addr_of_mut!(self.get_mut_link(node).right_as_source)
+    }
+
+    unsafe fn get_left(&self, node: T) -> T {
+        self.get_link(node).left_as_source
+    }
+
+    unsafe fn get_right(&self, node: T) -> T {
+        self.get_link(node).right_as_source
+    }
+
+    unsafe fn get_size(&self, node: T) -> T {
+        self.get_link(node).size_as_source
+    }
+
+    unsafe fn set_left(&mut self, node: T, left: T) {
+        self.get_mut_link(node).left_as_source = left;
+    }
+
+    unsafe fn set_right(&mut self, node: T, right: T) {
+        self.get_mut_link(node).right_as_source = right;
+    }
+
+    unsafe fn set_size(&mut self, node: T, size: T) {
+        self.get_mut_link(node).size_as_source = size;
+    }
+
+    unsafe fn first_is_to_the_left_of_second(&self, first: T, second: T) -> bool {
+        let first = self.get_link(first);
+        let second = self.get_link(second);
+        self.first_is_to_the_left_of_second_4(
+            first.source,
+            first.target,
+            second.source,
+            second.target,
+        )
+    }
+
+    unsafe fn first_is_to_the_right_of_second(&self, first: T, second: T) -> bool {
+        let first = self.get_link(first);
+        let second = self.get_link(second);
+        self.first_is_to_the_right_of_second_4(
+            first.source,
+            first.target,
+            second.source,
+            second.target,
+        )
+    }
+
+    unsafe fn clear_node(&mut self, node: T) {
+        let link = self.get_mut_link(node);
+        link.left_as_source = T::funty(0);
+        link.right_as_source = T::funty(0);
+        link.size_as_source = T::funty(0);
+    }
+}
+
+impl<T: LinkType> NoRecurSzbTree<T> for LinksSourcesRecursionlessSizeBalancedTree<T> {}
+
+fn each_usages_core<T: LinkType, H: FnMut(Link<T>) -> Flow + ?Sized>(
+    this: &LinksSourcesRecursionlessSizeBalancedTree<T>,
+    base: T,
+    link: T,
+    handler: &mut H,
+) -> Flow {
+    unsafe {
+        if link == T::funty(0) {
+            return Flow::Continue;
+        }
+        let link_base_part = this.get_base_part(link);
+        if link_base_part > base {
+            each_usages_core(this, base, this.get_left_or_default(link), handler)?;
+        } else if link_base_part < base {
+            each_usages_core(this, base, this.get_right_or_default(link), handler)?;
+        } else {
+            handler(this.get_link_value(link))?;
+            each_usages_core(this, base, this.get_left_or_default(link), handler)?;
+            each_usages_core(this, base, this.get_right_or_default(link), handler)?;
+        }
+    }
+    Flow::Continue
+}
+
+impl<T: LinkType> LinksTree<T> for LinksSourcesRecursionlessSizeBalancedTree<T> {
+    fn count_usages(&self, link: T) -> T {
+        unsafe {
+            let mut root = self.get_tree_root();
+            let total = self.get_size(root);
+            let mut total_right_ignore = T::funty(0);
+            while root != T::funty(0) {
+                let base = self.get_base_part(root);
+                if base <= link {
+                    root = self.get_right_or_default(root);
+                } else {
+                    total_right_ignore += self.get_right_size(root) + T::funty(1);
+                    root = self.get_left_or_default(root);
+                }
+            }
+            root = self.get_tree_root();
+            let mut total_left_ignore = T::funty(0);
+            while root != T::funty(0) {
+                let base = self.get_base_part(root);
+                if base >= link {
+                    root = self.get_left_or_default(root);
+                } else {
+                    total_left_ignore += self.get_left_size(root) + T::funty(1);
+                    root = self.get_right_or_default(root);
+                }
+            }
+            total - total_right_ignore - total_left_ignore
+        }
+    }
+
+    fn search(&self, source: T, target: T) -> T {
+        unsafe {
+            let mut root = self.get_tree_root();
+            while root != T::funty(0) {
+                let root_link = self.get_link(root);
+                let root_source = root_link.source;
+                let root_target = root_link.target;
+                if self.first_is_to_the_left_of_second_4(source, target, root_source, root_target) {
+                    root = self.get_left_or_default(root);
+                } else if self.first_is_to_the_right_of_second_4(
+                    source,
+                    target,
+                    root_source,
+                    root_target,
+                ) {
+                    root = self.get_right_or_default(root);
+                } else {
+                    return root;
+                }
+            }
+            T::funty(0)
+        }
+    }
+
+    fn each_usages<H: FnMut(Link<T>) -> Flow + ?Sized>(&self, root: T, handler: &mut H) -> Flow {
+        each_usages_core(self, root, self.get_tree_root(), handler)
+    }
+
+    fn detach(&mut self, root: &mut T, index: T) {
+        unsafe { NoRecurSzbTree::detach(self, root as *mut _, index) }
+    }
+
+    fn attach(&mut self, root: &mut T, index: T) {
+        unsafe { NoRecurSzbTree::attach(self, root as *mut _, index) }
+    }
+}
+
+impl<T: LinkType> UnitUpdateMem<T> for LinksSourcesRecursionlessSizeBalancedTree<T> {
+    fn update_mem(&mut self, mem: NonNull<[LinkPart<T>]>) {
+        self.base.mem = mem;
+    }
+}
+
+impl<T: LinkType> LinkRecursionlessSizeBalancedTreeBaseAbstract<T>
+    for LinksSourcesRecursionlessSizeBalancedTree<T>
+{
+    fn get_header(&self) -> &LinksHeader<T> {
+        unsafe { transmute(&self.base.mem.as_ref()[0]) }
+    }
+
+    fn get_mut_header(&mut self) -> &mut LinksHeader<T> {
+        unsafe { transmute(&mut self.base.mem.as_mut()[0]) }
+    }
+
+    fn get_link(&self, link: T) -> &LinkPart<T> {
+        unsafe { &self.base.mem.as_ref()[link.as_usize()] }
+    }
+
+    fn get_mut_link(&mut self, link: T) -> &mut LinkPart<T> {
+        unsafe { &mut self.base.mem.as_mut()[link.as_usize()] }
+    }
+
+    fn get_tree_root(&self) -> T {
+        self.get_header().root_as_source
+    }
+
+    fn get_base_part(&self, link: T) -> T {
+        self.get_link(link).source
+    }
+
+    fn first_is_to_the_left_of_second_4(
+        &self,
+        first_source: T,
+        first_target: T,
+        second_source: T,
+        second_target: T,
+    ) -> bool {
+        (first_source < second_source)
+            || (first_source == second_source && first_target < second_target)
+    }
+
+    fn first_is_to_the_right_of_second_4(
+        &self,
+        first_source: T,
+        first_target: T,
+        second_source: T,
+        second_target: T,
+    ) -> bool {
+        (first_source > second_source)
+            || (first_source == second_source && first_target > second_target)
+    }
+}
+
+impl<T: LinkType> UnitTree<T> for LinksSourcesRecursionlessSizeBalancedTree<T> {}
diff --git a/rust/doublets-patched/doublets/src/mem/unit/generic/targets_recursionless_size_balanced_tree.rs b/rust/doublets-patched/doublets/src/mem/unit/generic/targets_recursionless_size_balanced_tree.rs
new file mode 100644
index 0000000..2867d20
--- /dev/null
+++ b/rust/doublets-patched/doublets/src/mem/unit/generic/targets_recursionless_size_balanced_tree.rs
@@ -0,0 +1,252 @@
+use std::{mem::transmute, ptr::NonNull};
+
+use crate::{
+    mem::{
+        header::LinksHeader,
+        unit::{
+            generic::{
+                LinkRecursionlessSizeBalancedTreeBaseAbstract,
+                LinksRecursionlessSizeBalancedTreeBase,
+            },
+            raw_link::LinkPart,
+        },
+        LinksTree, UnitTree, UnitUpdateMem,
+    },
+    Link,
+};
+use data::{Flow, LinkType, LinksConstants};
+use trees::{NoRecurSzbTree, SzbTree};
+
+pub struct LinksTargetsRecursionlessSizeBalancedTree<T: LinkType> {
+    base: LinksRecursionlessSizeBalancedTreeBase<T>,
+}
+
+impl<T: LinkType> LinksTargetsRecursionlessSizeBalancedTree<T> {
+    pub fn new(constants: LinksConstants<T>, mem: NonNull<[LinkPart<T>]>) -> Self {
+        Self {
+            base: LinksRecursionlessSizeBalancedTreeBase::new(constants, mem),
+        }
+    }
+}
+
+impl<T: LinkType> SzbTree<T> for LinksTargetsRecursionlessSizeBalancedTree<T> {
+    unsafe fn get_left_reference(&self, node: T) -> *const T {
+        std::ptr::addr_of!(self.get_link(node).left_as_target)
+    }
+
+    unsafe fn get_right_reference(&self, node: T) -> *const T {
+        std::ptr::addr_of!(self.get_link(node).right_as_target)
+    }
+
+    unsafe fn get_mut_left_reference(&mut self, node: T) -> *mut T {
+        std::ptr::addr_of_mut!(self.get_mut_link(node).left_as_target)
+    }
+
+    unsafe fn get_mut_right_reference(&mut self, node: T) -> *mut T {
+        std::ptr::addr_of_mut!(self.get_mut_link(node).right_as_target)
+    }
+
+    unsafe fn get_left(&self, node: T) -> T {
+        self.get_link(node).left_as_target
+    }
+
+    unsafe fn get_right(&self, node: T) -> T {
+        self.get_link(node).right_as_target
+    }
+
+    unsafe fn get_size(&self, node: T) -> T {
+        self.get_link(node).size_as_target
+    }
+
+    unsafe fn set_left(&mut self, node: T, left: T) {
+        self.get_mut_link(node).left_as_target = left;
+    }
+
+    unsafe fn set_right(&mut self, node: T, right: T) {
+        self.get_mut_link(node).right_as_target = right;
+    }
+
+    unsafe fn set_size(&mut self, node: T, size: T) {
+        self.get_mut_link(node).size_as_target = size;
+    }
+
+    unsafe fn first_is_to_the_left_of_second(&self, first: T, second: T) -> bool {
+        let first = self.get_link(first);
+        let second = self.get_link(second);
+        self.first_is_to_the_left_of_second_4(
+            first.source,
+            first.target,
+            second.source,
+            second.target,
+        )
+    }
+
+    unsafe fn first_is_to_the_right_of_second(&self, first: T, second: T) -> bool {
+        let first = self.get_link(first);
+        let second = self.get_link(second);
+        self.first_is_to_the_right_of_second_4(
+            first.source,
+            first.target,
+            second.source,
+            second.target,
+        )
+    }
+
+    unsafe fn clear_node(&mut self, node: T) {
+        let link = self.get_mut_link(node);
+        link.left_as_target = T::funty(0);
+        link.right_as_target = T::funty(0);
+        link.size_as_target = T::funty(0);
+    }
+}
+
+impl<T: LinkType> NoRecurSzbTree<T> for LinksTargetsRecursionlessSizeBalancedTree<T> {}
+
+fn each_usages_core<T: LinkType, H: FnMut(Link<T>) -> Flow + ?Sized>(
+    this: &LinksTargetsRecursionlessSizeBalancedTree<T>,
+    base: T,
+    link: T,
+    handler: &mut H,
+) -> Flow {
+    if link == T::funty(0) {
+        return Flow::Continue;
+    }
+    unsafe {
+        let link_base_part = this.get_base_part(link);
+        if link_base_part > base {
+            each_usages_core(this, base, this.get_left_or_default(link), handler)?;
+        } else if link_base_part < base {
+            each_usages_core(this, base, this.get_right_or_default(link), handler)?;
+        } else {
+            handler(this.get_link_value(link))?;
+            each_usages_core(this, base, this.get_left_or_default(link), handler)?;
+            each_usages_core(this, base, this.get_right_or_default(link), handler)?;
+        }
+    }
+    Flow::Continue
+}
+
+impl<T: LinkType> LinksTree<T> for LinksTargetsRecursionlessSizeBalancedTree<T> {
+    fn count_usages(&self, link: T) -> T {
+        unsafe {
+            let mut root = self.get_tree_root();
+            let total = self.get_size(root);
+            let mut total_right_ignore = T::funty(0);
+            while root != T::funty(0) {
+                let base = self.get_base_part(root);
+                if base <= link {
+                    root = self.get_right_or_default(root);
+                } else {
+                    total_right_ignore += self.get_right_size(root) + T::funty(1);
+                    root = self.get_left_or_default(root);
+                }
+            }
+            root = self.get_tree_root();
+            let mut total_left_ignore = T::funty(0);
+            while root != T::funty(0) {
+                let base = self.get_base_part(root);
+                if base >= link {
+                    root = self.get_left_or_default(root);
+                } else {
+                    total_left_ignore += self.get_left_size(root) + T::funty(1);
+                    root = self.get_right_or_default(root);
+                }
+            }
+            total - total_right_ignore - total_left_ignore
+        }
+    }
+
+    fn search(&self, source: T, target: T) -> T {
+        unsafe {
+            let mut root = self.get_tree_root();
+            while root != T::funty(0) {
+                let root_link = self.get_link(root);
+                let root_source = root_link.source;
+                let root_target = root_link.target;
+                if self.first_is_to_the_left_of_second_4(source, target, root_source, root_target) {
+                    root = self.get_left_or_default(root);
+                } else if self.first_is_to_the_right_of_second_4(
+                    source,
+                    target,
+                    root_source,
+                    root_target,
+                ) {
+                    root = self.get_right_or_default(root);
+                } else {
+                    return root;
+                }
+            }
+            T::funty(0)
+        }
+    }
+
+    fn each_usages<H: FnMut(Link<T>) -> Flow + ?Sized>(&self, root: T, handler: &mut H) -> Flow {
+        each_usages_core(self, root, self.get_tree_root(), handler)
+    }
+
+    fn detach(&mut self, root: &mut T, index: T) {
+        unsafe { NoRecurSzbTree::detach(self, root as *mut _, index) }
+    }
+
+    fn attach(&mut self, root: &mut T, index: T) {
+        unsafe { NoRecurSzbTree::attach(self, root as *mut _, index) }
+    }
+}
+
+impl<T: LinkType> UnitUpdateMem<T> for LinksTargetsRecursionlessSizeBalancedTree<T> {
+    fn update_mem(&mut self, mem: NonNull<[LinkPart<T>]>) {
+        self.base.mem = mem;
+    }
+}
+
+impl<T: LinkType> LinkRecursionlessSizeBalancedTreeBaseAbstract<T>
+    for LinksTargetsRecursionlessSizeBalancedTree<T>
+{
+    fn get_header(&self) -> &LinksHeader<T> {
+        unsafe { transmute(&self.base.mem.as_ref()[0]) }
+    }
+
+    fn get_mut_header(&mut self) -> &mut LinksHeader<T> {
+        unsafe { transmute(&mut self.base.mem.as_mut()[0]) }
+    }
+
+    fn get_link(&self, link: T) -> &LinkPart<T> {
+        unsafe { &self.base.mem.as_ref()[link.as_usize()] }
+    }
+
+    fn get_mut_link(&mut self, link: T) -> &mut LinkPart<T> {
+        unsafe { &mut self.base.mem.as_mut()[link.as_usize()] }
+    }
+
+    fn get_tree_root(&self) -> T {
+        self.get_header().root_as_target
+    }
+
+    fn get_base_part(&self, link: T) -> T {
+        self.get_link(link).target
+    }
+
+    fn first_is_to_the_left_of_second_4(
+        &self,
+        first_source: T,
+        first_target: T,
+        second_source: T,
+        second_target: T,
+    ) -> bool {
+        first_target < second_target
+            || (first_target == second_target && first_source < second_source)
+    }
+
+    fn first_is_to_the_right_of_second_4(
+        &self,
+        first_source: T,
+        first_target: T,
+        second_source: T,
+        second_target: T,
+    ) -> bool {
+        first_target > second_target
+            || (first_target == second_target && first_source > second_source)
+    }
+}
+
+impl<T: LinkType> UnitTree<T> for LinksTargetsRecursionlessSizeBalancedTree<T> {}
diff --git a/rust/doublets-patched/doublets/src/mem/unit/generic/unused_links.rs b/rust/doublets-patched/doublets/src/mem/unit/generic/unused_links.rs
new file mode 100644
index 0000000..076b2f3
--- /dev/null
+++ b/rust/doublets-patched/doublets/src/mem/unit/generic/unused_links.rs
@@ -0,0 +1,98 @@
+use std::{mem::transmute, ptr::NonNull};
+
+use crate::mem::{
+    header::LinksHeader, traits::UnitList, unit::raw_link::LinkPart, LinksList, UnitUpdateMem,
+};
+use data::LinkType;
+use trees::{AbsoluteCircularLinkedList, AbsoluteLinkedList, LinkedList};
+
+pub struct UnusedLinks<T: LinkType> {
+    mem: NonNull<[LinkPart<T>]>,
+}
+
+impl<T: LinkType> UnusedLinks<T> {
+    #[must_use]
+    pub fn new(mem: NonNull<[LinkPart<T>]>) -> Self {
+        Self { mem }
+    }
+
+    fn get_header(&self) -> &LinksHeader<T> {
+        unsafe { transmute(&self.mem.as_ref()[0]) }
+    }
+
+    fn get_mut_header(&mut self) -> &mut LinksHeader<T> {
+        unsafe { transmute(&mut self.mem.as_mut()[0]) }
+    }
+
+    fn get_link(&self, link: T) -> &LinkPart<T> {
+        unsafe { &self.mem.as_ref()[link.as_usize()] }
+    }
+
+    fn get_mut_link(&mut self, link: T) -> &mut LinkPart<T> {
+        unsafe { &mut self.mem.as_mut()[link.as_usize()] }
+    }
+}
+
+impl<T: LinkType> AbsoluteLinkedList<T> for UnusedLinks<T> {
+    fn get_first(&self) -> T {
+        self.get_header().first_free
+    }
+
+    fn get_last(&self) -> T {
+        self.get_header().last_free
+    }
+
+    fn get_size(&self) -> T {
+        self.get_header().free
+    }
+
+    fn set_first(&mut self, element: T) {
+        self.get_mut_header().first_free = element;
+    }
+
+    fn set_last(&mut self, element: T) {
+        self.get_mut_header().last_free = element;
+    }
+
+    fn set_size(&mut self, size: T) {
+        self.get_mut_header().free = size;
+    }
+}
+
+impl<T: LinkType> LinkedList<T> for UnusedLinks<T> {
+    fn get_previous(&self, element: T) -> T {
+        self.get_link(element).source
+    }
+
+    fn get_next(&self, element: T) -> T {
+        self.get_link(element).target
+    }
+
+    fn set_previous(&mut self, element: T, previous: T) {
+        self.get_mut_link(element).source = previous;
+    }
+
+    fn set_next(&mut self, element: T, next: T) {
+        self.get_mut_link(element).target = next;
+    }
+}
+
+impl<T: LinkType> AbsoluteCircularLinkedList<T> for UnusedLinks<T> {}
+
+impl<T: LinkType> LinksList<T> for UnusedLinks<T> {
+    fn detach(&mut self, link: T) {
+        AbsoluteCircularLinkedList::detach(self, link);
+    }
+
+    fn attach_as_first(&mut self, link: T) {
+        AbsoluteCircularLinkedList::attach_as_first(self, link);
+    }
+}
+
+impl<T: LinkType> UnitUpdateMem<T> for UnusedLinks<T> {
+    fn update_mem(&mut self, mem: NonNull<[LinkPart<T>]>) {
+        self.mem = mem;
+    }
+}
+
+impl<T: LinkType> UnitList<T> for UnusedLinks<T> {}
diff --git a/rust/doublets-patched/doublets/src/mem/unit/mod.rs b/rust/doublets-patched/doublets/src/mem/unit/mod.rs
new file mode 100644
index 0000000..1328bc9
--- /dev/null
+++ b/rust/doublets-patched/doublets/src/mem/unit/mod.rs
@@ -0,0 +1,7 @@
+pub use generic::*;
+pub use raw_link::LinkPart;
+pub use store::Store;
+
+mod generic;
+mod raw_link;
+mod store;
diff --git a/rust/doublets-patched/doublets/src/mem/unit/raw_link.rs b/rust/doublets-patched/doublets/src/mem/unit/raw_link.rs
new file mode 100644
index 0000000..0948c8d
--- /dev/null
+++ b/rust/doublets-patched/doublets/src/mem/unit/raw_link.rs
@@ -0,0 +1,14 @@
+use data::LinkType;
+
+#[derive(Debug, Default, PartialEq, Eq, Hash, Clone)]
+#[repr(C)]
+pub struct LinkPart<T: LinkType> {
+    pub(crate) source: T,
+    pub(crate) target: T,
+    pub(crate) left_as_source: T,
+    pub(crate) right_as_source: T,
+    pub(crate) size_as_source: T,
+    pub(crate) left_as_target: T,
+    pub(crate) right_as_target: T,
+    pub(crate) size_as_target: T,
+}
diff --git a/rust/doublets-patched/doublets/src/mem/unit/store.rs b/rust/doublets-patched/doublets/src/mem/unit/store.rs
new file mode 100644
index 0000000..5231732
--- /dev/null
+++ b/rust/doublets-patched/doublets/src/mem/unit/store.rs
@@ -0,0 +1,580 @@
+use crate::{
+    mem::{
+        header::LinksHeader,
+        traits::UnitList,
+        unit::{
+            LinkPart, LinksSourcesRecursionlessSizeBalancedTree,
+            LinksTargetsRecursionlessSizeBalancedTree, UnusedLinks,
+        },
+        UnitTree,
+    },
+    Doublets, Link, Links, LinksError, ReadHandler, WriteHandler,
+};
+use data::{Flow, LinkType, LinksConstants, ToQuery};
+use leak_slice::LeakSliceExt;
+use mem::{RawMem, DEFAULT_PAGE_SIZE};
+
+use std::{cmp, cmp::Ordering, error::Error, mem::transmute, ptr::NonNull};
+
+pub struct Store<
+    T: LinkType,
+    M: RawMem<LinkPart<T>>,
+    TS: UnitTree<T> = LinksSourcesRecursionlessSizeBalancedTree<T>,
+    TT: UnitTree<T> = LinksTargetsRecursionlessSizeBalancedTree<T>,
+    TU: UnitList<T> = UnusedLinks<T>,
+> {
+    mem: M,
+    mem_ptr: NonNull<[LinkPart<T>]>,
+    reserve_step: usize,
+    constants: LinksConstants<T>,
+
+    sources: TS,
+    targets: TT,
+    unused: TU,
+}
+
+impl<T: LinkType, M: RawMem<LinkPart<T>>, TS: UnitTree<T>, TT: UnitTree<T>, TU: UnitList<T>>
+    Store<T, M, TS, TT, TU>
+{
+    #[cfg(not(miri))]
+    const SIZE_STEP: usize = 2_usize.pow(20);
+    #[cfg(miri)]
+    const SIZE_STEP: usize = 2_usize.pow(10);
+
+    pub fn new(mem: M) -> Result<Store<T, M>, LinksError<T>> {
+        Self::with_constants(mem, LinksConstants::new())
+    }
+
+    pub fn with_constants(
+        mem: M,
+        constants: LinksConstants<T>,
+    ) -> Result<Store<T, M>, LinksError<T>> {
+        let dangling_mem = NonNull::slice_from_raw_parts(NonNull::dangling(), 0);
+        let sources =
+            LinksSourcesRecursionlessSizeBalancedTree::new(constants.clone(), dangling_mem);
+        let targets =
+            LinksTargetsRecursionlessSizeBalancedTree::new(constants.clone(), dangling_mem);
+        let unused = UnusedLinks::new(dangling_mem);
+        let mut new = Store::<
+            T,
+            M,
+            LinksSourcesRecursionlessSizeBalancedTree<T>,
+            LinksTargetsRecursionlessSizeBalancedTree<T>,
+            UnusedLinks<T>,
+        > {
+            mem,
+            mem_ptr: dangling_mem,
+            reserve_step: Self::SIZE_STEP,
+            constants,
+            sources,
+            targets,
+            unused,
+        };
+
+        // SAFETY: Without this, the code will become unsafe
+        unsafe {
+            new.init()?;
+        }
+        Ok(new)
+    }
+
+    unsafe fn init(&mut self) -> Result<(), LinksError<T>> {
+        let mem = NonNull::from(self.mem.alloc(DEFAULT_PAGE_SIZE)?);
+        self.update_mem(mem);
+
+        let header = self.get_header().clone();
+        let capacity = cmp::max(self.reserve_step, header.allocated.as_usize());
+        let mem = self.mem.alloc(capacity)?.leak();
+        self.update_mem(mem);
+
+        let reserved = self.mem.allocated();
+
+        let header = self.mut_header();
+        header.reserved = T::try_from(reserved - 1).expect("always ok");
+        Ok(())
+    }
+
+    fn mut_from_mem<'a, U>(mut ptr: NonNull<[U]>, index: usize) -> Option<&'a mut U> {
+        if index < ptr.len() {
+            // SAFETY: `ptr` is non-dangling slice
+            Some(unsafe {
+                let slice = ptr.as_mut();
+                &mut slice[index]
+            })
+        } else {
+            None
+        }
+    }
+
+    fn get_from_mem<'a, U>(mem: NonNull<[U]>, index: usize) -> Option<&'a U> {
+        Self::mut_from_mem(mem, index).map(|v| &*v)
+    }
+
+    fn get_header(&self) -> &LinksHeader<T> {
+        // SAFETY: `LinksHeader` and `IndexPart` layout are equivalent
+        unsafe {
+            Self::get_from_mem(self.mem_ptr, 0)
+                .map(|x| transmute(x))
+                .expect("Header should be in index memory")
+        }
+    }
+
+    fn mut_header(&mut self) -> &mut LinksHeader<T> {
+        // SAFETY: `LinksHeader` and `IndexPart` layout are equivalent
+        unsafe {
+            Self::mut_from_mem(self.mem_ptr, 0)
+                .map(|x| transmute(x))
+                .expect("Header should be in index memory")
+        }
+    }
+
+    fn get_link_part(&self, index: T) -> &LinkPart<T> {
+        Self::get_from_mem(self.mem_ptr, index.as_usize())
+            .expect("Data part should be in data memory")
+    }
+
+    unsafe fn get_link_part_unchecked(&self, index: T) -> &LinkPart<T> {
+        Self::get_from_mem(self.mem_ptr, index.as_usize()).unwrap_unchecked()
+    }
+
+    fn mut_link_part(&mut self, index: T) -> &mut LinkPart<T> {
+        Self::mut_from_mem(self.mem_ptr, index.as_usize())
+            .expect("Data part should be in data memory")
+    }
+
+    unsafe fn mut_source_root(&mut self) -> *mut T {
+        &mut self.mut_header().root_as_source
+    }
+
+    unsafe fn mut_target_root(&mut self) -> *mut T {
+        &mut self.mut_header().root_as_target
+    }
+
+    unsafe fn detach_source_unchecked(&mut self, root: *mut T, index: T) {
+        self.sources.detach(&mut *root, index);
+    }
+
+    unsafe fn detach_target_unchecked(&mut self, root: *mut T, index: T) {
+        self.targets.detach(&mut *root, index);
+    }
+
+    unsafe fn attach_source_unchecked(&mut self, root: *mut T, index: T) {
+        self.sources.attach(&mut *root, index);
+    }
+
+    unsafe fn attach_target_unchecked(&mut self, root: *mut T, index: T) {
+        self.targets.attach(&mut *root, index);
+    }
+
+    unsafe fn detach_source(&mut self, index: T) {
+        let root = self.mut_source_root();
+        self.detach_source_unchecked(root, index);
+    }
+
+    unsafe fn detach_target(&mut self, index: T) {
+        let root = self.mut_target_root();
+        self.detach_target_unchecked(root, index);
+    }
+
+    unsafe fn attach_source(&mut self, index: T) {
+        let root = self.mut_source_root();
+        self.attach_source_unchecked(root, index);
+    }
+
+    unsafe fn attach_target(&mut self, index: T) {
+        let root = self.mut_target_root();
+        self.attach_target_unchecked(root, index);
+    }
+
+    fn get_total(&self) -> T {
+        let header = self.get_header();
+        header.allocated - header.free
+    }
+
+    fn is_unused(&self, link: T) -> bool {
+        let header = self.get_header();
+        if link <= header.allocated && header.first_free != link {
+            // SAFETY: link part memory is allocated
+            let link = unsafe { self.get_link_part_unchecked(link) };
+            // If the link is unused (that is, it was created but deleted),
+            // its search tree size is 0,
+            // its source and target will be used to build a LinkedList from similar links
+            link.size_as_source == T::funty(0) && link.source != T::funty(0)
+        } else {
+            true
+        }
+    }
+
+    fn exists(&self, link: T) -> bool {
+        let constants = self.constants();
+        let header = self.get_header();
+
+        link >= *constants.internal_range.start()
+            && link <= header.allocated
+            && !self.is_unused(link)
+    }
+
+    fn update_mem(&mut self, mem: NonNull<[LinkPart<T>]>) {
+        self.mem_ptr = mem;
+        self.targets.update_mem(mem);
+        self.sources.update_mem(mem);
+        self.unused.update_mem(mem);
+    }
+
+    unsafe fn get_link_unchecked(&self, index: T) -> Link<T> {
+        debug_assert!(self.exists(index));
+
+        let raw = self.get_link_part_unchecked(index);
+        Link::new(index, raw.source, raw.target)
+    }
+
+    fn each_core(&self, handler: ReadHandler<'_, T>, query: &[T]) -> Flow {
+        let constants = self.constants();
+
+        if query.is_empty() {
+            for index in T::funty(1)..=self.get_header().allocated {
+                if let Some(link) = self.get_link(index) {
+                    handler(link)?;
+                }
+            }
+            return Flow::Continue;
+        }
+
+        let any = constants.any;
+        let index = query[constants.index_part.as_usize()];
+
+        if query.len() == 1 {
+            return if index == any {
+                self.each_core(handler, &[])
+            } else if let Some(link) = self.get_link(index) {
+                handler(link)
+            } else {
+                Flow::Continue
+            };
+        }
+
+        if query.len() == 2 {
+            let value = query[1];
+            return if index == any {
+                if value == any {
+                    self.each_core(handler, &[])
+                } else {
+                    self.each_core(handler, &[index, value, any])?;
+                    self.each_core(handler, &[index, any, value])
+                }
+            } else if let Some(link) = self.get_link(index) {
+                if value == any || link.source == value || link.target == value {
+                    handler(link)
+                } else {
+                    Flow::Continue
+                }
+            } else {
+                Flow::Continue
+            };
+        }
+
+        if query.len() == 3 {
+            let source = query[constants.source_part.as_usize()];
+            let target = query[constants.target_part.as_usize()];
+
+            return if index == any {
+                if (source, target) == (any, any) {
+                    self.each_core(handler, &[])
+                } else if source == any {
+                    self.targets.each_usages(target, handler)
+                } else if target == any {
+                    self.sources.each_usages(source, handler)
+                } else {
+                    let link = self.sources.search(source, target);
+                    self.get_link(link).map_or(Flow::Continue, handler)
+                }
+            } else if let Some(link) = self.get_link(index) {
+                if (target, source) == (any, any) {
+                    handler(link) // TODO: add (x * *) search test
+                } else if target != any && source != any {
+                    if (source, target) == (link.source, link.target) {
+                        handler(link)
+                    } else {
+                        Flow::Continue
+                    }
+                } else if source == any {
+                    if link.target == target {
+                        handler(link)
+                    } else {
+                        Flow::Continue
+                    }
+                } else if target == any {
+                    if link.source == source {
+                        handler(link)
+                    } else {
+                        Flow::Continue
+                    }
+                } else {
+                    Flow::Continue
+                }
+            } else {
+                Flow::Continue
+            };
+        }
+        todo!()
+    }
+}
+
+impl<T: LinkType, M: RawMem<LinkPart<T>>, TS: UnitTree<T>, TT: UnitTree<T>, TU: UnitList<T>>
+    Links<T> for Store<T, M, TS, TT, TU>
+{
+    fn constants(&self) -> &LinksConstants<T> {
+        &self.constants
+    }
+
+    fn count_links(&self, query: &[T]) -> T {
+        if query.is_empty() {
+            return self.get_total();
+        };
+
+        let constants = self.constants();
+        let any = constants.any;
+        let index = query[constants.index_part.as_usize()];
+
+        if query.len() == 1 {
+            return if index == any {
+                self.get_total()
+            } else if self.exists(index) {
+                T::funty(1)
+            } else {
+                T::funty(0)
+            };
+        }
+
+        if query.len() == 2 {
+            let value = query[1];
+            return if index == any {
+                if value == any {
+                    self.get_total()
+                } else {
+                    self.targets.count_usages(value) + self.sources.count_usages(value)
+                }
+            } else {
+                if !self.exists(index) {
+                    return T::funty(0);
+                }
+                if value == any {
+                    return T::funty(1);
+                }
+
+                return self.get_link(index).map_or_else(
+                    || T::funty(0),
+                    |stored| {
+                        if stored.source == value || stored.target == value {
+                            T::funty(1)
+                        } else {
+                            T::funty(0)
+                        }
+                    },
+                );
+            };
+        }
+
+        if query.len() == 3 {
+            let source = query[constants.source_part.as_usize()];
+            let target = query[constants.target_part.as_usize()];
+
+            return if index == any {
+                if (target, source) == (any, any) {
+                    self.get_total()
+                } else if source == any {
+                    self.targets.count_usages(target)
+                } else if target == any {
+                    self.sources.count_usages(source)
+                } else {
+                    let link = self.sources.search(source, target);
+                    if link == constants.null {
+                        T::funty(0)
+                    } else {
+                        T::funty(1)
+                    }
+                }
+            } else if !self.exists(index) {
+                T::funty(0)
+            } else if (source, target) == (any, any) {
+                T::funty(1)
+            } else {
+                let link = unsafe { self.get_link_unchecked(index) };
+                if source != any && target != any {
+                    if (link.source, link.target) == (source, target) {
+                        T::funty(1)
+                    } else {
+                        T::funty(0)
+                    }
+                } else if source == any {
+                    if link.target == target {
+                        T::funty(1)
+                    } else {
+                        T::funty(0)
+                    }
+                } else if target == any {
+                    if link.source == source {
+                        T::funty(1)
+                    } else {
+                        T::funty(0)
+                    }
+                } else {
+                    T::funty(0)
+                }
+            };
+        }
+        todo!()
+    }
+
+    fn create_links(
+        &mut self,
+        _query: &[T],
+        handler: WriteHandler<'_, T>,
+    ) -> Result<Flow, LinksError<T>> {
+        let constants = self.constants();
+        let header = self.get_header();
+        let mut free = header.first_free;
+        if free == constants.null {
+            let max_inner = *constants.internal_range.end();
+            if header.allocated >= max_inner {
+                return Err(LinksError::LimitReached(max_inner));
+            }
+
+            if header.allocated >= header.reserved - T::funty(1) {
+                let mem = self
+                    .mem
+                    .alloc(self.mem.allocated() + self.reserve_step)?
+                    .leak();
+                self.update_mem(mem);
+                let reserved = self.mem.allocated();
+                let header = self.mut_header();
+                header.reserved = T::try_from(reserved).expect("always ok");
+            }
+            let header = self.mut_header();
+            header.allocated += T::funty(1);
+            free = header.allocated;
+        } else {
+            self.unused.detach(free);
+        }
+        Ok(handler(
+            Link::nothing(),
+            Link::new(free, T::funty(0), T::funty(0)),
+        ))
+    }
+
+    fn each_links(&self, query: &[T], handler: ReadHandler<'_, T>) -> Flow {
+        self.each_core(handler, &query.to_query()[..])
+    }
+
+    fn update_links(
+        &mut self,
+        query: &[T],
+        change: &[T],
+        handler: WriteHandler<'_, T>,
+    ) -> Result<Flow, LinksError<T>> {
+        let index = query[0];
+        let source = change[1];
+        let target = change[2];
+        let old_source = source;
+        let old_target = target;
+
+        let link = self.try_get_link(index)?;
+
+        if link.source != T::funty(0) {
+            // SAFETY: Here index detach from sources
+            // by default source is zero
+            unsafe {
+                self.detach_source(index);
+            }
+        }
+        if link.target != T::funty(0) {
+            // SAFETY: Here index detach from targets
+            // by default target is zero
+            unsafe {
+                self.detach_target(index);
+            }
+        }
+
+        let place = self.mut_link_part(index);
+        place.source = source;
+        place.target = target;
+        let place = place.clone();
+
+        if place.source != T::funty(0) {
+            // SAFETY: Here index attach to sources
+            unsafe {
+                self.attach_source(index);
+            }
+        }
+        if place.target != T::funty(0) {
+            // SAFETY: Here index attach to targets
+            unsafe {
+                self.attach_target(index);
+            }
+        }
+
+        Ok(handler(
+            Link::new(index, old_source, old_target),
+            Link::new(index, source, target),
+        ))
+    }
+
+    fn delete_links(
+        &mut self,
+        query: &[T],
+        handler: WriteHandler<'_, T>,
+    ) -> Result<Flow, LinksError<T>> {
+        let index = query[0];
+
+        let link = self.try_get_link(index)?;
+        self.update(index, T::funty(0), T::funty(0))?;
+
+        let header = self.get_header();
+        match index.cmp(&header.allocated) {
+            Ordering::Less => self.unused.attach_as_first(index),
+            Ordering::Equal => {
+                let allocated = self.get_header().allocated;
+                let header = self.mut_header();
+                header.allocated = allocated - T::funty(1);
+
+                loop {
+                    let allocated = self.get_header().allocated;
+                    if !(allocated > T::funty(0) && self.is_unused(allocated)) {
+                        break;
+                    }
+                    self.unused.detach(allocated);
+                    self.mut_header().allocated = allocated - T::funty(1);
+                }
+            }
+            // fixme: possible unreachable_unchecked
+            Ordering::Greater => unreachable!(),
+        }
+
+        Ok(handler(link, Link::nothing()))
+    }
+}
+
+impl<T: LinkType, M: RawMem<LinkPart<T>>, TS: UnitTree<T>, TT: UnitTree<T>, TU: UnitList<T>>
+    Doublets<T> for Store<T, M, TS, TT, TU>
+{
+    fn get_link(&self, index: T) -> Option<Link<T>> {
+        if self.exists(index) {
+            // SAFETY: links is exists
+            Some(unsafe { self.get_link_unchecked(index) })
+        } else {
+            None
+        }
+    }
+}
+
+// SAFETY: No read operations result in a write
+unsafe impl<T: LinkType, M: RawMem<LinkPart<T>>, TS: UnitTree<T>, TT: UnitTree<T>, TU: UnitList<T>>
+    Sync for Store<T, M, TS, TT, TU>
+{
+}
+
+// SAFETY: All data is moved together with the `Store`
+unsafe impl<T: LinkType, M: RawMem<LinkPart<T>>, TS: UnitTree<T>, TT: UnitTree<T>, TU: UnitList<T>>
+    Send for Store<T, M, TS, TT, TU>
+{
+}
diff --git a/rust/doublets-patched/doublets/tests/doublets.rs b/rust/doublets-patched/doublets/tests/doublets.rs
new file mode 100644
index 0000000..a9bfc67
--- /dev/null
+++ b/rust/doublets-patched/doublets/tests/doublets.rs
@@ -0,0 +1,42 @@
+use data::LinkType;
+use doublets::{unit, Doublets, DoubletsExt, Link};
+use mem::Global;
+use std::error::Error;
+use tap::Pipe;
+
+fn rebase_impl<T: LinkType>(mut store: impl Doublets<T>) -> Result<(), Box<dyn Error>> {
+    let a = store.create_point()?;
+    let b = store.create_point()?;
+
+    let c = store.create_point()?.pipe(|x| store.update(x, x, a))?;
+    let d = store.create_point()?.pipe(|x| store.update(x, a, x))?;
+
+    assert_eq!(
+        store.iter().collect::<Vec<_>>(),
+        vec![
+            Link::new(a, a, a),
+            Link::new(b, b, b),
+            Link::new(c, c, a),
+            Link::new(d, a, d)
+        ]
+    );
+
+    store.rebase(a, b)?;
+
+    assert_eq!(
+        store.iter().collect::<Vec<_>>(),
+        vec![
+            Link::new(a, a, a),
+            Link::new(b, b, b),
+            Link::new(c, c, b),
+            Link::new(d, b, d)
+        ]
+    );
+
+    Ok(())
+}
+
+#[test]
+fn rebase() {
+    rebase_impl(unit::Store::<usize, _>::new(Global::new()).unwrap()).unwrap();
+}
diff --git a/rust/doublets-patched/doublets/tests/dyn.rs b/rust/doublets-patched/doublets/tests/dyn.rs
new file mode 100644
index 0000000..5e93134
--- /dev/null
+++ b/rust/doublets-patched/doublets/tests/dyn.rs
@@ -0,0 +1,17 @@
+use doublets::{unit, Doublets, Error};
+use mem::Global;
+
+pub mod extensions;
+
+#[test]
+fn basic() -> Result<(), Error<usize>> {
+    let mut store: Box<dyn Doublets<_>> = Box::new(unit::Store::<usize, _>::new(Global::new())?);
+
+    let a = store.create_point()?;
+    let b = store.create_point()?;
+    let _ = store.create_link(a, b)?;
+
+    assert_eq!(store.count(), 3);
+
+    Ok(())
+}
diff --git a/rust/doublets-patched/doublets/tests/expansion.rs b/rust/doublets-patched/doublets/tests/expansion.rs
new file mode 100644
index 0000000..52b8428
--- /dev/null
+++ b/rust/doublets-patched/doublets/tests/expansion.rs
@@ -0,0 +1,65 @@
+use doublets::{split, unit, Doublets, Error};
+use mem::Global;
+use std::time::Instant;
+
+const MILLION: usize = 1_000_000;
+
+#[test]
+#[cfg(not(miri))]
+fn unit_million() -> Result<(), Error<usize>> {
+    let mut store = unit::Store::<usize, _>::new(Global::new())?;
+
+    for _ in 0..MILLION {
+        store.create().unwrap();
+    }
+
+    assert_eq!(store.count(), MILLION);
+
+    Ok(())
+}
+
+#[test]
+#[cfg(not(miri))]
+fn split_million() -> Result<(), Error<usize>> {
+    let mut store = split::Store::<usize, _, _>::new(Global::new(), Global::new())?;
+
+    for _ in 0..MILLION {
+        store.create().unwrap();
+    }
+
+    assert_eq!(store.count(), MILLION);
+
+    Ok(())
+}
+
+#[test]
+#[cfg(not(miri))]
+fn unit_million_points() -> Result<(), Error<usize>> {
+    let mut store = unit::Store::<usize, _>::new(Global::new())?;
+
+    let instant = Instant::now();
+    for _ in 0..MILLION {
+        store.create_point().unwrap();
+    }
+    println!("{:?}", instant.elapsed());
+
+    assert_eq!(store.count(), MILLION);
+
+    Ok(())
+}
+
+#[test]
+#[cfg(not(miri))]
+fn split_million_points() -> Result<(), Error<usize>> {
+    let mut store = split::Store::<usize, _, _>::new(Global::new(), Global::new())?;
+
+    let instant = Instant::now();
+    for _ in 0..MILLION {
+        store.create_point().unwrap();
+    }
+    println!("{:?}", instant.elapsed());
+
+    assert_eq!(store.count(), MILLION);
+
+    Ok(())
+}
diff --git a/rust/doublets-patched/doublets/tests/extensions.rs b/rust/doublets-patched/doublets/tests/extensions.rs
new file mode 100644
index 0000000..0fd5c0e
--- /dev/null
+++ b/rust/doublets-patched/doublets/tests/extensions.rs
@@ -0,0 +1,148 @@
+use rand::Rng;
+
+use data::{Flow, Hybrid, LinkType};
+use doublets::{Doublets, Link};
+
+pub fn test_crud<T: LinkType>(store: &mut impl Doublets<T>) {
+    let constants = store.constants().clone();
+
+    assert_eq!(store.count(), T::funty(0));
+
+    let address = store.create().unwrap();
+    // TODO: expect
+    let mut link: Link<T> = store.get_link(address).unwrap();
+
+    assert_eq!(link.index, address);
+    assert_eq!(link.source, constants.null);
+    assert_eq!(link.target, constants.null);
+    assert_eq!(store.count(), T::funty(0));
+
+    store.update(address, address, address).unwrap();
+
+    // TODO: expect
+    link = store.get_link(address).unwrap();
+    assert_eq!(link.source, address);
+    assert_eq!(link.target, address);
+
+    let updated = store
+        .update(address, constants.null, constants.null)
+        .unwrap();
+    assert_eq!(updated, address);
+    // TODO: expect
+    link = store.get_link(address).unwrap();
+    assert_eq!(link.source, constants.null);
+    assert_eq!(link.target, constants.null);
+
+    store.delete(address).unwrap();
+    assert_eq!(store.count(), T::funty(0));
+}
+
+pub fn test_raw_numbers_crud<T: LinkType>(store: &mut impl Doublets<T>) {
+    let links = store;
+
+    let constants = links.constants().clone();
+
+    let n106 = T::try_from(106_usize).unwrap();
+    let n107 = T::try_from(char::from_u32(107).unwrap() as usize).unwrap();
+    let n108 = T::try_from((-108_i32) as usize).unwrap();
+
+    let h106 = Hybrid::external(n106);
+    let h107 = Hybrid::new(n107);
+    let h108 = Hybrid::new(n108);
+
+    assert_eq!(h106.abs().as_usize(), 106);
+    assert_eq!(h107.abs().as_usize(), 107);
+    assert_eq!(h108.abs().as_usize(), 108);
+
+    let address1 = links.create().unwrap();
+    links
+        .update(address1, h106.as_inner(), h108.as_inner())
+        .unwrap();
+
+    let link = links.get_link(address1).unwrap();
+    assert_eq!(link.source, h106.as_inner());
+    assert_eq!(link.target, h108.as_inner());
+
+    let address2 = links.create().unwrap();
+    links.update(address2, address1, h108.as_inner()).unwrap();
+
+    let link = links.get_link(address2).unwrap();
+    assert_eq!(link.source, address1);
+    assert_eq!(link.target, h108.as_inner());
+
+    let address3 = links.create().unwrap();
+    links.update(address3, address1, address2).unwrap();
+
+    let link = links.get_link(address3).unwrap();
+    assert_eq!(link.source, address1);
+    assert_eq!(link.target, address2);
+
+    let any = constants.any;
+
+    let mut result = None;
+    links.each_by([any, h106.as_inner(), h108.as_inner()], |link| {
+        result = Some(link.index);
+        Flow::Break
+    });
+    assert_eq!(result, Some(address1));
+
+    let mut result = None;
+    links.each_by([any, h106.abs(), h107.abs()], |link| {
+        result = Some(link.index);
+        Flow::Break
+    }); // TODO: !!!
+    assert_eq!(result, None);
+
+    let updated = links.update(address3, T::funty(0), T::funty(0)).unwrap();
+    assert_eq!(updated, address3);
+
+    let link = links.get_link(updated).unwrap();
+    assert_eq!(link.source, T::funty(0));
+    assert_eq!(link.target, T::funty(0));
+    links.delete(updated).unwrap();
+
+    assert_eq!(links.count(), T::try_from(2).unwrap());
+
+    let _continue = links.constants().r#continue;
+    let mut result = None;
+    links.each(|link| {
+        result = Some(link.index);
+        Flow::Continue
+    });
+    assert_eq!(result, Some(address2));
+}
+
+pub fn test_random_creations_and_deletions<T: LinkType>(
+    store: &mut impl Doublets<T>,
+    per_cycle: usize,
+) {
+    for n in 1..per_cycle {
+        let mut created = 0;
+        let mut _deleted = 0;
+        for _ in 0..n {
+            let count = store.count().as_usize();
+            let create_point: bool = rand::random();
+            if count >= 2 && create_point {
+                let address = 1..=count;
+                let source = rand::thread_rng().gen_range(address.clone());
+                let target = rand::thread_rng().gen_range(address);
+                let result = store
+                    .get_or_create(T::try_from(source).unwrap(), T::try_from(target).unwrap())
+                    .unwrap()
+                    .as_usize();
+
+                if result > count {
+                    created += 1;
+                }
+            } else {
+                store.create().unwrap();
+                created += 1;
+            }
+            assert_eq!(created, store.count().as_usize());
+        }
+
+        store.delete_all().unwrap();
+
+        assert_eq!(store.count(), T::funty(0));
+    }
+}
diff --git a/rust/doublets-patched/doublets/tests/iter.rs b/rust/doublets-patched/doublets/tests/iter.rs
new file mode 100644
index 0000000..9b105f8
--- /dev/null
+++ b/rust/doublets-patched/doublets/tests/iter.rs
@@ -0,0 +1,117 @@
+use doublets::{split, unit, Doublets, DoubletsExt, Error, Link, Links};
+use mem::Global;
+use std::collections::HashSet;
+
+#[test]
+fn unit_iter() -> Result<(), Error<usize>> {
+    let mut store = unit::Store::<usize, _>::new(Global::new())?;
+
+    let a = store.create_point()?;
+    let b = store.create_point()?;
+    store.create_link(a, b)?;
+
+    assert_eq!(
+        store.iter().collect::<HashSet<_>>(),
+        vec![Link::new(1, 1, 1), Link::new(2, 2, 2), Link::new(3, 1, 2),]
+            .into_iter()
+            .collect()
+    );
+
+    Ok(())
+}
+
+#[test]
+fn unit_iter_bug() -> Result<(), Error<usize>> {
+    let mut store = unit::Store::<usize, _>::new(Global::new())?;
+
+    let a = store.create_point()?;
+    let b = store.create_point()?;
+    let c = store.create_link(a, b)?;
+    store.delete(b)?;
+    store.update(c, b, b)?;
+
+    assert_eq!(
+        store.iter().collect::<HashSet<_>>(),
+        vec![Link::new(1, 1, 1), Link::new(3, 2, 2),]
+            .into_iter()
+            .collect()
+    );
+
+    Ok(())
+}
+
+#[test]
+fn unit_each_iter() -> Result<(), Error<usize>> {
+    let mut store = unit::Store::<usize, _>::new(Global::new())?;
+
+    store.create_link(1, 1)?;
+    store.create_link(2, 1)?;
+    store.create_link(3, 1)?;
+
+    let any = store.constants().any;
+    assert_eq!(
+        store.each_iter([any, any, 1]).collect::<HashSet<_>>(),
+        vec![Link::new(1, 1, 1), Link::new(2, 2, 1), Link::new(3, 3, 1),]
+            .into_iter()
+            .collect()
+    );
+
+    Ok(())
+}
+
+#[test]
+fn split_iter() -> Result<(), Error<usize>> {
+    let mut store = split::Store::<usize, _, _>::new(Global::new(), Global::new())?;
+
+    let a = store.create_point()?;
+    let b = store.create_point()?;
+    store.create_link(a, b)?;
+
+    assert_eq!(
+        store.iter().collect::<HashSet<_>>(),
+        vec![Link::new(1, 1, 1), Link::new(2, 2, 2), Link::new(3, 1, 2),]
+            .into_iter()
+            .collect()
+    );
+
+    Ok(())
+}
+
+#[test]
+fn split_iter_bug() -> Result<(), Error<usize>> {
+    let mut store = split::Store::<usize, _, _>::new(Global::new(), Global::new())?;
+
+    let a = store.create_point()?;
+    let b = store.create_point()?;
+    let c = store.create_link(a, b)?;
+    store.delete(b)?;
+    store.update(c, b, b)?;
+
+    assert_eq!(
+        store.iter().collect::<HashSet<_>>(),
+        vec![Link::new(1, 1, 1), Link::new(3, 2, 2),]
+            .into_iter()
+            .collect()
+    );
+
+    Ok(())
+}
+
+#[test]
+fn split_each_iter() -> Result<(), Error<usize>> {
+    let mut store = split::Store::<usize, _, _>::new(Global::new(), Global::new())?;
+
+    store.create_link(1, 1)?;
+    store.create_link(2, 1)?;
+    store.create_link(3, 1)?;
+
+    let any = store.constants().any;
+    assert_eq!(
+        store.each_iter([any, any, 1]).collect::<HashSet<_>>(),
+        vec![Link::new(1, 1, 1), Link::new(2, 2, 1), Link::new(3, 3, 1),]
+            .into_iter()
+            .collect()
+    );
+
+    Ok(())
+}
diff --git a/rust/doublets-patched/doublets/tests/link.rs b/rust/doublets-patched/doublets/tests/link.rs
new file mode 100644
index 0000000..88e9f5c
--- /dev/null
+++ b/rust/doublets-patched/doublets/tests/link.rs
@@ -0,0 +1,8 @@
+use data::ToQuery;
+use doublets::Link;
+
+#[test]
+fn link_to_query() {
+    let link = Link::<usize>::new(1, 2, 3);
+    assert_eq!([1, 2, 3], &link.to_query()[..]);
+}
diff --git a/rust/doublets-patched/doublets/tests/multi.rs b/rust/doublets-patched/doublets/tests/multi.rs
new file mode 100644
index 0000000..3f7a436
--- /dev/null
+++ b/rust/doublets-patched/doublets/tests/multi.rs
@@ -0,0 +1,29 @@
+use doublets::{split, unit, Error};
+use mem::Global;
+use std::time::Instant;
+
+mod extensions;
+
+#[test]
+#[cfg(not(miri))]
+fn random_crud_unit() -> Result<(), Error<usize>> {
+    let mut store = unit::Store::<usize, _>::new(Global::new())?;
+
+    let instant = Instant::now();
+    extensions::test_random_creations_and_deletions(&mut store, 1000);
+    println!("{:?}", instant.elapsed());
+
+    Ok(())
+}
+
+#[test]
+#[cfg(not(miri))]
+fn random_crud_split() -> Result<(), Error<usize>> {
+    let mut store = split::Store::<usize, _, _>::new(Global::new(), Global::new())?;
+
+    let instant = Instant::now();
+    extensions::test_random_creations_and_deletions(&mut store, 1000);
+    println!("{:?}", instant.elapsed());
+
+    Ok(())
+}
diff --git a/rust/doublets-patched/doublets/tests/seq.rs b/rust/doublets-patched/doublets/tests/seq.rs
new file mode 100644
index 0000000..e87d574
--- /dev/null
+++ b/rust/doublets-patched/doublets/tests/seq.rs
@@ -0,0 +1,132 @@
+use doublets::{
+    data::{
+        Flow::{Break, Continue},
+        LinkType, ToQuery,
+    },
+    mem::Global,
+    split, Doublets, DoubletsExt, Error as LinksError, Link, Links,
+};
+
+use std::{error::Error, time::Instant};
+
+fn write_seq<T: LinkType>(store: &mut impl Doublets<T>, seq: &[T]) -> Result<T, LinksError<T>> {
+    let mut aliases = vec![store.create()?];
+
+    for id in seq {
+        let link = store.create()?;
+        aliases.push(store.update(link, link, *id)?)
+    }
+
+    for (i, cur) in aliases.iter().enumerate() {
+        if let Some(next) = aliases.get(i + 1) {
+            store.create_link(*cur, *next)?;
+        }
+    }
+    Ok(*aliases.first().unwrap_or(&T::funty(0)))
+}
+
+fn custom_single<T: LinkType>(store: &impl Doublets<T>, query: impl ToQuery<T>) -> Option<Link<T>> {
+    // todo:
+    //  store.each_iter(query).filter(Link::is_partial);
+
+    let mut single = None;
+    store.each_by(query, |link| {
+        if single.is_none() && link.index != link.source {
+            single = Some(link);
+            Continue
+        } else if link.index != link.source {
+            single = None;
+            Break
+        } else {
+            Continue
+        }
+    });
+    single
+}
+
+fn read_seq<T: LinkType>(store: &impl Doublets<T>, root: T) -> Result<Vec<T>, LinksError<T>> {
+    let any = store.constants().any;
+    let mut seq = vec![];
+    let mut cur = root;
+    while let Some(link) = custom_single(store, [any, cur, any]) {
+        cur = link.target;
+        let alias = store.try_get_link(link.target)?;
+        seq.push(alias.target);
+    }
+    Ok(seq)
+}
+
+const TEXT: &str = r#"
+    Bei Nacht im Dorf der Wächter rief:
+    Elfe!
+    Ein ganz kleines Elfchen im Walde schlief,
+    Wohl um die Elfe;
+    Und meint, es rief ihm aus dem Thal
+    Bei seinem Namen die Nachtigall,
+    Oder Silpelit[8] hätt' ihn gerufen.
+    Reibt sich der Elf' die Augen aus,
+    Begibt sich vor sein Schneckenhaus
+    Und ist als wie ein trunken Mann,
+    Sein Schläflein war nicht voll gethan,
+    Und humpelt also tippe tapp
+    Durch's Haselholz in's Thal hinab,
+    Schlupft an der Weinbergmauer hin,
+    Daran viel Feuerwürmchen glühn:
+    "Was sind das helle Fensterlein?
+    Da drin wird eine Hochzeit seyn;
+    Die Kleinen sitzen beim Mahle,
+    Und treiben's in dem Saale.
+    Da guck' ich wohl ein wenig 'nein!"
+    — Pfui, stößt den Kopf an harten Stein!
+    Elfe, gelt, du hast genug?
+    Gukuk! Gukuk!
+"#;
+
+fn str_as_vec(str: &str) -> Vec<usize> {
+    str.chars().map(|c| c as usize).collect()
+}
+
+const N: usize = 100;
+
+#[test]
+#[cfg(not(miri))]
+fn seq() -> Result<(), Box<dyn Error>> {
+    let mut store = split::Store::<usize, _, _>::new(Global::new(), Global::new())?;
+
+    let seq = str_as_vec(TEXT);
+    let instant = Instant::now();
+
+    let sequences: Vec<_> = (0..N)
+        .map(|_| write_seq(&mut store, seq.as_slice()).unwrap())
+        .collect();
+
+    for seq in sequences {
+        read_seq(&store, seq).unwrap();
+    }
+
+    println!("{:?}", instant.elapsed());
+
+    Ok(())
+}
+
+#[test]
+fn bug() -> Result<(), Box<dyn Error>> {
+    let mut store = split::Store::<usize, _, _>::new(Global::new(), Global::new())?;
+
+    let a = store.create_point()?;
+    let b = store.create_point()?;
+    let _c = store.create_link(a, b)?;
+
+    let _d = store.create_link(1, 10)?;
+    let _d = store.create_link(10, 1)?;
+
+    store.delete(a)?;
+
+    let any = store.constants().any;
+
+    for link in store.each_iter([any, any, 1]) {
+        println!("{:?}", link);
+    }
+
+    Ok(())
+}
diff --git a/rust/doublets-patched/doublets/tests/type_parts.rs b/rust/doublets-patched/doublets/tests/type_parts.rs
new file mode 100644
index 0000000..cdbbc1f
--- /dev/null
+++ b/rust/doublets-patched/doublets/tests/type_parts.rs
@@ -0,0 +1,22 @@
+use doublets::{parts, split, unit, Doublets};
+use mem::Global;
+
+type LinkType = usize;
+type Mem = Global<parts::LinkPart<LinkType>>;
+type UnitStore = unit::Store<LinkType, Mem>;
+
+#[test]
+fn unit_type_parts() {
+    let mut store = UnitStore::new(Global::new()).unwrap();
+    let _ = store.create();
+}
+
+type DataMem = Global<parts::DataPart<LinkType>>;
+type IndexMem = Global<parts::IndexPart<LinkType>>;
+type SplitStore = split::Store<LinkType, DataMem, IndexMem>;
+
+#[test]
+fn split_type_parts() {
+    let mut store = SplitStore::new(Global::new(), Global::new()).unwrap();
+    let _ = store.create();
+}
diff --git a/rust/out.py b/rust/out.py
index bad9b66..3dfccc3 100644
--- a/rust/out.py
+++ b/rust/out.py
@@ -52,13 +52,13 @@
 }
 
 VARIANTS = {
-    'SpacetimeDB_Memory': 'SpacetimeDB (SQLite/Memory)',
+    'SpacetimeDB': 'SpacetimeDB 2.0',
     'Doublets_United_Volatile': 'Doublets (United/Volatile)',
     'Doublets_Split_Volatile': 'Doublets (Split/Volatile)',
 }
 
 COLORS = {
-    'SpacetimeDB_Memory': '#e74c3c',
+    'SpacetimeDB': '#e74c3c',
     'Doublets_United_Volatile': '#2ecc71',
     'Doublets_Split_Volatile': '#3498db',
 }
@@ -161,7 +161,7 @@ def make_chart(ax, log_scale=False):
 
 def generate_markdown_table(results):
     """Generate a Markdown results table with speedup ratios."""
-    baseline = 'SpacetimeDB_Memory'
+    baseline = 'SpacetimeDB'
     doublets_variants = ['Doublets_United_Volatile', 'Doublets_Split_Volatile']
 
     header = (
diff --git a/rust/rust-toolchain.toml b/rust/rust-toolchain.toml
index 33c06c9..8e275b7 100644
--- a/rust/rust-toolchain.toml
+++ b/rust/rust-toolchain.toml
@@ -1,3 +1,3 @@
 [toolchain]
-channel = "nightly-2022-08-22"
+channel = "nightly"
 components = ["rustfmt", "clippy"]
diff --git a/rust/rust_out b/rust/rust_out
new file mode 100755
index 0000000..1ad1dd1
Binary files /dev/null and b/rust/rust_out differ
diff --git a/rust/spacetime-module/Cargo.lock b/rust/spacetime-module/Cargo.lock
new file mode 100644
index 0000000..d5cd5d4
--- /dev/null
+++ b/rust/spacetime-module/Cargo.lock
@@ -0,0 +1,980 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "anyhow"
+version = "1.0.102"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f202df86484c868dbad7eaa557ef785d5c66295e41b460ef922eca0723b842c"
+
+[[package]]
+name = "approx"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0e60b75072ecd4168020818c0107f2857bb6c4e64252d8d3983f6263b40a5c3"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "arrayref"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "76a2e8124351fda1ef8aaaa3bbd7ebbcb486bbcd4225aca0aa0d84bb2db8fecb"
+
+[[package]]
+name = "arrayvec"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50"
+
+[[package]]
+name = "autocfg"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
+
+[[package]]
+name = "bitflags"
+version = "2.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "843867be96c8daad0d758b57df9392b6d8d271134fce549de6ce169ff98a92af"
+
+[[package]]
+name = "blake3"
+version = "1.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2468ef7d57b3fb7e16b576e8377cdbde2320c60e1491e961d11da40fc4f02a2d"
+dependencies = [
+ "arrayref",
+ "arrayvec",
+ "cc",
+ "cfg-if",
+ "constant_time_eq",
+ "cpufeatures",
+]
+
+[[package]]
+name = "block-buffer"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
+name = "bytemuck"
+version = "1.25.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8efb64bd706a16a1bdde310ae86b351e4d21550d98d056f22f8a7f7a2183fec"
+
+[[package]]
+name = "bytes"
+version = "1.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e748733b7cbc798e1434b6ac524f0c1ff2ab456fe201501e6497c8417a4fc33"
+
+[[package]]
+name = "castaway"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dec551ab6e7578819132c713a93c022a05d60159dc86e7a7050223577484c55a"
+dependencies = [
+ "rustversion",
+]
+
+[[package]]
+name = "cc"
+version = "1.2.56"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aebf35691d1bfb0ac386a69bac2fde4dd276fb618cf8bf4f5318fe285e821bb2"
+dependencies = [
+ "find-msvc-tools",
+ "shlex",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
+
+[[package]]
+name = "chrono"
+version = "0.4.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c673075a2e0e5f4a1dde27ce9dee1ea4558c7ffe648f576438a20ca1d2acc4b0"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "constant_time_eq"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d52eff69cd5e647efe296129160853a42795992097e8af39800e1060caeea9b"
+
+[[package]]
+name = "convert_case"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6245d59a3e82a7fc217c5828a6692dbc6dfb63a0c8c90495621f7b9d79704a0e"
+
+[[package]]
+name = "cpufeatures"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "crypto-common"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a"
+dependencies = [
+ "generic-array",
+ "typenum",
+]
+
+[[package]]
+name = "decorum"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "281759d3c8a14f5c3f0c49363be56810fcd7f910422f97f2db850c2920fde5cf"
+dependencies = [
+ "approx",
+ "num-traits",
+]
+
+[[package]]
+name = "derive_more"
+version = "0.99.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6edb4b64a43d977b8e99788fe3a04d483834fba1215a7e02caa415b626497f7f"
+dependencies = [
+ "convert_case",
+ "proc-macro2",
+ "quote",
+ "rustc_version",
+ "syn",
+]
+
+[[package]]
+name = "digest"
+version = "0.10.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
+dependencies = [
+ "block-buffer",
+ "crypto-common",
+]
+
+[[package]]
+name = "either"
+version = "1.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"
+
+[[package]]
+name = "enum-as-inner"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1e6a265c649f3f5979b601d26f1d05ada116434c87741c9493cb56218f76cbc"
+dependencies = [
+ "heck 0.5.0",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "equivalent"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
+
+[[package]]
+name = "ethnum"
+version = "1.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ca81e6b4777c89fd810c25a4be2b1bd93ea034fbe58e6a75216a34c6b82c539b"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "find-msvc-tools"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582"
+
+[[package]]
+name = "foldhash"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2"
+
+[[package]]
+name = "generic-array"
+version = "0.14.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
+dependencies = [
+ "typenum",
+ "version_check",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff2abc00be7fca6ebc474524697ae276ad847ad0a6b3faa4bcb027e9a4614ad0"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "r-efi 5.3.0",
+ "wasip2",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0de51e6874e94e7bf76d726fc5d13ba782deca734ff60d5bb2fb2607c7406555"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "r-efi 6.0.0",
+ "wasip2",
+ "wasip3",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.15.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1"
+dependencies = [
+ "foldhash",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.16.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100"
+
+[[package]]
+name = "heck"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8"
+
+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+
+[[package]]
+name = "hex"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
+
+[[package]]
+name = "http"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3ba2a386d7f85a81f119ad7498ebe444d2e22c2af0b86b069416ace48b3311a"
+dependencies = [
+ "bytes",
+ "itoa",
+]
+
+[[package]]
+name = "humantime"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "135b12329e5e3ce057a9f972339ea52bc954fe1e9358ef27f95e89716fbc5424"
+
+[[package]]
+name = "id-arena"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d3067d79b975e8844ca9eb072e16b31c3c1c36928edf9c6789548c524d0d954"
+
+[[package]]
+name = "indexmap"
+version = "2.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7714e70437a7dc3ac8eb7e6f8df75fd8eb422675fc7678aff7364301092b1017"
+dependencies = [
+ "equivalent",
+ "hashbrown 0.16.1",
+ "serde",
+ "serde_core",
+]
+
+[[package]]
+name = "itertools"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba291022dbbd398a455acf126c1e341954079855bc60dfdda641363bd6922569"
+dependencies = [
+ "either",
+]
+
+[[package]]
+name = "itoa"
+version = "1.0.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92ecc6618181def0457392ccd0ee51198e065e016d1d527a7ac1b6dc7c1f09d2"
+
+[[package]]
+name = "keccak"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb26cec98cce3a3d96cbb7bced3c4b16e3d13f27ec56dbd62cbc8f39cfb9d653"
+dependencies = [
+ "cpufeatures",
+]
+
+[[package]]
+name = "lean_string"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "962df00ba70ac8d5ca5c064e17e5c3d090c087fd8d21aa45096c716b169da514"
+dependencies = [
+ "castaway",
+ "itoa",
+ "ryu",
+]
+
+[[package]]
+name = "leb128fmt"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09edd9e8b54e49e587e4f6295a7d29c3ea94d469cb40ab8ca70b288248a81db2"
+
+[[package]]
+name = "libc"
+version = "0.2.182"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6800badb6cb2082ffd7b6a67e6125bb39f18782f793520caee8cb8846be06112"
+
+[[package]]
+name = "log"
+version = "0.4.29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e5032e24019045c762d3c0f28f5b6b8bbf38563a65908389bf7978758920897"
+
+[[package]]
+name = "memchr"
+version = "2.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79"
+
+[[package]]
+name = "nohash-hasher"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2bf50223579dc7cdcfb3bfcacf7069ff68243f8c363f62ffa99cf000a6b9c451"
+
+[[package]]
+name = "num-traits"
+version = "0.2.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "ppv-lite86"
+version = "0.2.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9"
+dependencies = [
+ "zerocopy",
+]
+
+[[package]]
+name = "prettyplease"
+version = "0.2.37"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "479ca8adacdd7ce8f1fb39ce9ecccbfe93a3f1344b3d0d97f20bc0196208f62b"
+dependencies = [
+ "proc-macro2",
+ "syn",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.106"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.45"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "r-efi"
+version = "5.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
+
+[[package]]
+name = "r-efi"
+version = "6.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf"
+
+[[package]]
+name = "rand"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
+dependencies = [
+ "libc",
+ "rand_chacha 0.3.1",
+ "rand_core 0.6.4",
+]
+
+[[package]]
+name = "rand"
+version = "0.9.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6db2770f06117d490610c7488547d543617b21bfa07796d7a12f6f1bd53850d1"
+dependencies = [
+ "rand_chacha 0.9.0",
+ "rand_core 0.9.5",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
+dependencies = [
+ "ppv-lite86",
+ "rand_core 0.6.4",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb"
+dependencies = [
+ "ppv-lite86",
+ "rand_core 0.9.5",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
+dependencies = [
+ "getrandom 0.2.17",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "76afc826de14238e6e8c374ddcc1fa19e374fd8dd986b0d2af0d02377261d83c"
+dependencies = [
+ "getrandom 0.3.4",
+]
+
+[[package]]
+name = "rustc_version"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cfcb3a22ef46e85b45de6ee7e79d063319ebb6594faafcf1c225ea92ab6e9b92"
+dependencies = [
+ "semver",
+]
+
+[[package]]
+name = "rustversion"
+version = "1.0.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d"
+
+[[package]]
+name = "ryu"
+version = "1.0.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9774ba4a74de5f7b1c1451ed6cd5285a32eddb5cccb8cc655a4e50009e06477f"
+
+[[package]]
+name = "scoped-tls"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e1cf6437eb19a8f4a6cc0f7dca544973b0b78843adbfeb3683d1a94a0024a294"
+
+[[package]]
+name = "second-stack"
+version = "0.3.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4904c83c6e51f1b9b08bfa5a86f35a51798e8307186e6f5513852210a219c0bb"
+
+[[package]]
+name = "semver"
+version = "1.0.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d767eb0aabc880b29956c35734170f26ed551a859dbd361d140cdbeca61ab1e2"
+
+[[package]]
+name = "serde"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"
+dependencies = [
+ "serde_core",
+]
+
+[[package]]
+name = "serde_core"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.149"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "83fc039473c5595ace860d8c4fafa220ff474b3fc6bfdb4293327f1a37e94d86"
+dependencies = [
+ "itoa",
+ "memchr",
+ "serde",
+ "serde_core",
+ "zmij",
+]
+
+[[package]]
+name = "sha3"
+version = "0.10.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75872d278a8f37ef87fa0ddbda7802605cb18344497949862c0d4dcb291eba60"
+dependencies = [
+ "digest",
+ "keccak",
+]
+
+[[package]]
+name = "shlex"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
+
+[[package]]
+name = "smallvec"
+version = "1.15.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
+
+[[package]]
+name = "spacetime-module"
+version = "0.1.0"
+dependencies = [
+ "log",
+ "spacetimedb",
+]
+
+[[package]]
+name = "spacetimedb"
+version = "2.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f3f29fd00688a2351f9912bb09391082eb58a4a3c221a9f420b79987e3e0ecf0"
+dependencies = [
+ "anyhow",
+ "bytemuck",
+ "bytes",
+ "derive_more",
+ "getrandom 0.2.17",
+ "http",
+ "log",
+ "rand 0.8.5",
+ "scoped-tls",
+ "serde_json",
+ "spacetimedb-bindings-macro",
+ "spacetimedb-bindings-sys",
+ "spacetimedb-lib",
+ "spacetimedb-primitives",
+ "spacetimedb-query-builder",
+]
+
+[[package]]
+name = "spacetimedb-bindings-macro"
+version = "2.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "21bfb058d197c94ea1c10186cf561e1d458284029aa17e145de91426645684ac"
+dependencies = [
+ "heck 0.4.1",
+ "humantime",
+ "proc-macro2",
+ "quote",
+ "spacetimedb-primitives",
+ "syn",
+]
+
+[[package]]
+name = "spacetimedb-bindings-sys"
+version = "2.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a34cc5cb88e4927a8e0931dbbe74f1fceae63a43ca1cc52443f853de9a2b188"
+dependencies = [
+ "spacetimedb-primitives",
+]
+
+[[package]]
+name = "spacetimedb-lib"
+version = "2.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ebd9269f2e04205cedad7bc9ed4e7945b5ba7ff3ba338b9f27d6df809303dcb0"
+dependencies = [
+ "anyhow",
+ "bitflags",
+ "blake3",
+ "chrono",
+ "derive_more",
+ "enum-as-inner",
+ "hex",
+ "itertools",
+ "log",
+ "spacetimedb-bindings-macro",
+ "spacetimedb-primitives",
+ "spacetimedb-sats",
+ "thiserror",
+]
+
+[[package]]
+name = "spacetimedb-primitives"
+version = "2.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "824c30dd781b206519447e2b2eed456312a1e9b4ff27781471f75ed2bbd77720"
+dependencies = [
+ "bitflags",
+ "either",
+ "enum-as-inner",
+ "itertools",
+ "nohash-hasher",
+]
+
+[[package]]
+name = "spacetimedb-query-builder"
+version = "2.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f566a5c58b2f8a635aa10ee9139d6815511938e36ff6c4719ae5282f6c6dee73"
+dependencies = [
+ "spacetimedb-lib",
+]
+
+[[package]]
+name = "spacetimedb-sats"
+version = "2.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "194d29d4b59ae80ef25547fe2b5ab942452704db68400c799bfc005b8797a487"
+dependencies = [
+ "anyhow",
+ "arrayvec",
+ "bitflags",
+ "bytemuck",
+ "bytes",
+ "chrono",
+ "decorum",
+ "derive_more",
+ "enum-as-inner",
+ "ethnum",
+ "hex",
+ "itertools",
+ "lean_string",
+ "rand 0.9.2",
+ "second-stack",
+ "sha3",
+ "smallvec",
+ "spacetimedb-bindings-macro",
+ "spacetimedb-primitives",
+ "thiserror",
+ "uuid",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.117"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "thiserror"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52"
+dependencies = [
+ "thiserror-impl",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "typenum"
+version = "1.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "562d481066bde0658276a35467c4af00bdc6ee726305698a55b86e61d7ad82bb"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
+
+[[package]]
+name = "unicode-xid"
+version = "0.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"
+
+[[package]]
+name = "uuid"
+version = "1.22.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a68d3c8f01c0cfa54a75291d83601161799e4a89a39e0929f4b0354d88757a37"
+dependencies = [
+ "getrandom 0.4.2",
+]
+
+[[package]]
+name = "version_check"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
+
+[[package]]
+name = "wasi"
+version = "0.11.1+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b"
+
+[[package]]
+name = "wasip2"
+version = "1.0.2+wasi-0.2.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9517f9239f02c069db75e65f174b3da828fe5f5b945c4dd26bd25d89c03ebcf5"
+dependencies = [
+ "wit-bindgen",
+]
+
+[[package]]
+name = "wasip3"
+version = "0.4.0+wasi-0.3.0-rc-2026-01-06"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5428f8bf88ea5ddc08faddef2ac4a67e390b88186c703ce6dbd955e1c145aca5"
+dependencies = [
+ "wit-bindgen",
+]
+
+[[package]]
+name = "wasm-encoder"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "990065f2fe63003fe337b932cfb5e3b80e0b4d0f5ff650e6985b1048f62c8319"
+dependencies = [
+ "leb128fmt",
+ "wasmparser",
+]
+
+[[package]]
+name = "wasm-metadata"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bb0e353e6a2fbdc176932bbaab493762eb1255a7900fe0fea1a2f96c296cc909"
+dependencies = [
+ "anyhow",
+ "indexmap",
+ "wasm-encoder",
+ "wasmparser",
+]
+
+[[package]]
+name = "wasmparser"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "47b807c72e1bac69382b3a6fb3dbe8ea4c0ed87ff5629b8685ae6b9a611028fe"
+dependencies = [
+ "bitflags",
+ "hashbrown 0.15.5",
+ "indexmap",
+ "semver",
+]
+
+[[package]]
+name = "wit-bindgen"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d7249219f66ced02969388cf2bb044a09756a083d0fab1e566056b04d9fbcaa5"
+dependencies = [
+ "wit-bindgen-rust-macro",
+]
+
+[[package]]
+name = "wit-bindgen-core"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ea61de684c3ea68cb082b7a88508a8b27fcc8b797d738bfc99a82facf1d752dc"
+dependencies = [
+ "anyhow",
+ "heck 0.5.0",
+ "wit-parser",
+]
+
+[[package]]
+name = "wit-bindgen-rust"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b7c566e0f4b284dd6561c786d9cb0142da491f46a9fbed79ea69cdad5db17f21"
+dependencies = [
+ "anyhow",
+ "heck 0.5.0",
+ "indexmap",
+ "prettyplease",
+ "syn",
+ "wasm-metadata",
+ "wit-bindgen-core",
+ "wit-component",
+]
+
+[[package]]
+name = "wit-bindgen-rust-macro"
+version = "0.51.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c0f9bfd77e6a48eccf51359e3ae77140a7f50b1e2ebfe62422d8afdaffab17a"
+dependencies = [
+ "anyhow",
+ "prettyplease",
+ "proc-macro2",
+ "quote",
+ "syn",
+ "wit-bindgen-core",
+ "wit-bindgen-rust",
+]
+
+[[package]]
+name = "wit-component"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d66ea20e9553b30172b5e831994e35fbde2d165325bec84fc43dbf6f4eb9cb2"
+dependencies = [
+ "anyhow",
+ "bitflags",
+ "indexmap",
+ "log",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "wasm-encoder",
+ "wasm-metadata",
+ "wasmparser",
+ "wit-parser",
+]
+
+[[package]]
+name = "wit-parser"
+version = "0.244.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ecc8ac4bc1dc3381b7f59c34f00b67e18f910c2c0f50015669dde7def656a736"
+dependencies = [
+ "anyhow",
+ "id-arena",
+ "indexmap",
+ "log",
+ "semver",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "unicode-xid",
+ "wasmparser",
+]
+
+[[package]]
+name = "zerocopy"
+version = "0.8.40"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a789c6e490b576db9f7e6b6d661bcc9799f7c0ac8352f56ea20193b2681532e5"
+dependencies = [
+ "zerocopy-derive",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.8.40"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f65c489a7071a749c849713807783f70672b28094011623e200cb86dcb835953"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "zmij"
+version = "1.0.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8848ee67ecc8aedbaf3e4122217aff892639231befc6a1b58d29fff4c2cabaa"
diff --git a/rust/spacetime-module/Cargo.toml b/rust/spacetime-module/Cargo.toml
new file mode 100644
index 0000000..b1c28a5
--- /dev/null
+++ b/rust/spacetime-module/Cargo.toml
@@ -0,0 +1,13 @@
+[package]
+name = "spacetime-module"
+version = "0.1.0"
+edition = "2021"
+license = "Unlicense"
+description = "SpacetimeDB module defining the links table and reducers for benchmarking"
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+spacetimedb = "2"
+log = "0.4"
diff --git a/rust/spacetime-module/src/lib.rs b/rust/spacetime-module/src/lib.rs
new file mode 100644
index 0000000..ea306a0
--- /dev/null
+++ b/rust/spacetime-module/src/lib.rs
@@ -0,0 +1,50 @@
+use spacetimedb::{reducer, table, ReducerContext, Table};
+
+#[table(accessor = links, public)]
+pub struct Link {
+    #[primary_key]
+    #[auto_inc]
+    pub id: u64,
+    #[index(btree)]
+    pub source: u64,
+    #[index(btree)]
+    pub target: u64,
+}
+
+#[reducer(init)]
+pub fn init(_ctx: &ReducerContext) {
+    log::info!("SpacetimeDB links module initialized");
+}
+
+#[reducer]
+pub fn create_link(ctx: &ReducerContext, source: u64, target: u64) {
+    ctx.db.links().insert(Link {
+        id: 0,
+        source,
+        target,
+    });
+}
+
+#[reducer]
+pub fn update_link(ctx: &ReducerContext, id: u64, source: u64, target: u64) {
+    if let Some(link) = ctx.db.links().id().find(&id) {
+        ctx.db.links().id().update(Link {
+            id: link.id,
+            source,
+            target,
+        });
+    }
+}
+
+#[reducer]
+pub fn delete_link(ctx: &ReducerContext, id: u64) {
+    ctx.db.links().id().delete(&id);
+}
+
+#[reducer]
+pub fn delete_all_links(ctx: &ReducerContext) {
+    let ids: Vec<u64> = ctx.db.links().iter().map(|l| l.id).collect();
+    for id in ids {
+        ctx.db.links().id().delete(&id);
+    }
+}
diff --git a/rust/src/benched/doublets_benched.rs b/rust/src/benched/doublets_benched.rs
index f4c3e10..7952d67 100644
--- a/rust/src/benched/doublets_benched.rs
+++ b/rust/src/benched/doublets_benched.rs
@@ -3,8 +3,9 @@
 use crate::{
     benched::Benched,
     doublets_impl::{
-        create_split_volatile, create_united_volatile, DoubletsLinks, DoubletsSplitVolatile,
-        DoubletsUnitedVolatile,
+        create_split_non_volatile, create_split_volatile, create_united_non_volatile,
+        create_united_volatile, DoubletsLinks, DoubletsSplitNonVolatile, DoubletsSplitVolatile,
+        DoubletsUnitedNonVolatile, DoubletsUnitedVolatile,
     },
     Fork, Links,
 };
@@ -83,3 +84,110 @@ impl DerefMut for DoubletsSplitVolatileBenched {
         &mut self.links
     }
 }
+
+/// Benchmark subject for Doublets united non-volatile (file-backed, contiguous) store.
+///
+/// Uses a memory-mapped file for persistent storage. The file path is provided at setup.
+pub struct DoubletsUnitedNonVolatileBenched {
+    links: DoubletsLinks<DoubletsUnitedNonVolatile>,
+    path: String,
+}
+
+impl Benched for DoubletsUnitedNonVolatileBenched {
+    type Builder = String;
+
+    fn setup(builder: Self::Builder) -> Self {
+        // Remove any leftover file from a previous run so the store starts empty.
+        let _ = std::fs::remove_file(&builder);
+        let links = create_united_non_volatile(&builder);
+        Self {
+            links,
+            path: builder,
+        }
+    }
+
+    fn fork(&mut self) -> Fork<Self> {
+        Fork::new(self)
+    }
+
+    unsafe fn unfork(&mut self) {
+        self.links.delete_all();
+    }
+}
+
+impl Deref for DoubletsUnitedNonVolatileBenched {
+    type Target = DoubletsLinks<DoubletsUnitedNonVolatile>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.links
+    }
+}
+
+impl DerefMut for DoubletsUnitedNonVolatileBenched {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.links
+    }
+}
+
+impl Drop for DoubletsUnitedNonVolatileBenched {
+    fn drop(&mut self) {
+        // Clean up the benchmark file when the benched subject is dropped.
+        let _ = std::fs::remove_file(&self.path);
+    }
+}
+
+/// Benchmark subject for Doublets split non-volatile (file-backed, separate data/index) store.
+///
+/// Uses two memory-mapped files for persistent storage. File paths are provided at setup.
+pub struct DoubletsSplitNonVolatileBenched {
+    links: DoubletsLinks<DoubletsSplitNonVolatile>,
+    data_path: String,
+    index_path: String,
+}
+
+impl Benched for DoubletsSplitNonVolatileBenched {
+    type Builder = (String, String);
+
+    fn setup(builder: Self::Builder) -> Self {
+        let (data_path, index_path) = builder;
+        // Remove any leftover files from a previous run so the store starts empty.
+        let _ = std::fs::remove_file(&data_path);
+        let _ = std::fs::remove_file(&index_path);
+        let links = create_split_non_volatile(&data_path, &index_path);
+        Self {
+            links,
+            data_path,
+            index_path,
+        }
+    }
+
+    fn fork(&mut self) -> Fork<Self> {
+        Fork::new(self)
+    }
+
+    unsafe fn unfork(&mut self) {
+        self.links.delete_all();
+    }
+}
+
+impl Deref for DoubletsSplitNonVolatileBenched {
+    type Target = DoubletsLinks<DoubletsSplitNonVolatile>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.links
+    }
+}
+
+impl DerefMut for DoubletsSplitNonVolatileBenched {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.links
+    }
+}
+
+impl Drop for DoubletsSplitNonVolatileBenched {
+    fn drop(&mut self) {
+        // Clean up the benchmark files when the benched subject is dropped.
+        let _ = std::fs::remove_file(&self.data_path);
+        let _ = std::fs::remove_file(&self.index_path);
+    }
+}
diff --git a/rust/src/benched/spacetimedb_benched.rs b/rust/src/benched/spacetimedb_benched.rs
index 65ad283..634d07e 100644
--- a/rust/src/benched/spacetimedb_benched.rs
+++ b/rust/src/benched/spacetimedb_benched.rs
@@ -1,22 +1,22 @@
-//! `Benched` implementation for SpacetimeDB (SQLite backend).
+//! `Benched` implementation for SpacetimeDB.
 
 use crate::{benched::Benched, spacetimedb_impl::SpacetimeDbLinks, Fork, Links};
 use std::ops::{Deref, DerefMut};
 
-/// Benchmark subject for SpacetimeDB with in-memory SQLite backend.
+/// Benchmark subject for SpacetimeDB using the official `spacetimedb-sdk` Rust crate.
 ///
-/// Uses SpacetimeDB's SQLite storage layer directly, which is the same
-/// storage engine SpacetimeDB 2 uses internally for its tables.
-pub struct SpacetimeDbMemoryBenched {
+/// Connects to a running SpacetimeDB server and benchmarks link operations
+/// via the official client SDK.
+pub struct SpacetimeDbBenched {
     links: SpacetimeDbLinks,
 }
 
-impl Benched for SpacetimeDbMemoryBenched {
+impl Benched for SpacetimeDbBenched {
     type Builder = ();
 
     fn setup(_builder: Self::Builder) -> Self {
         Self {
-            links: SpacetimeDbLinks::new_memory(),
+            links: SpacetimeDbLinks::connect(),
         }
     }
 
@@ -29,7 +29,7 @@ impl Benched for SpacetimeDbMemoryBenched {
     }
 }
 
-impl Deref for SpacetimeDbMemoryBenched {
+impl Deref for SpacetimeDbBenched {
     type Target = SpacetimeDbLinks;
 
     fn deref(&self) -> &Self::Target {
@@ -37,7 +37,7 @@ impl Deref for SpacetimeDbMemoryBenched {
     }
 }
 
-impl DerefMut for SpacetimeDbMemoryBenched {
+impl DerefMut for SpacetimeDbBenched {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.links
     }
diff --git a/rust/src/doublets_impl.rs b/rust/src/doublets_impl.rs
index c0b4823..1706879 100644
--- a/rust/src/doublets_impl.rs
+++ b/rust/src/doublets_impl.rs
@@ -1,16 +1,20 @@
 //! Doublets storage implementation for links.
 //!
-//! Adapts the Doublets in-memory link store to the shared `Links` trait
-//! used in benchmarks.
+//! Adapts the Doublets link store to the shared `Links` trait used in benchmarks.
 //!
 //! # Doublets Storage Types
 //!
-//! Two in-memory storage layouts are benchmarked:
+//! Four storage layouts are benchmarked: volatile (in-memory) and non-volatile
+//! (file-backed) variants of united and split stores.
 //!
 //! - **United Volatile**: Each link stored as a contiguous unit `(index, source, target)`.
-//!   Single allocation; best cache locality for small stores.
+//!   Single allocation; best cache locality for small stores. Data lives in RAM only.
 //! - **Split Volatile**: Data part and index part in separate memory regions.
-//!   Better cache efficiency for index-heavy workloads.
+//!   Better cache efficiency for index-heavy workloads. Data lives in RAM only.
+//! - **United NonVolatile**: Same layout as United Volatile but backed by a memory-mapped
+//!   file. Data persists to disk on drop via `sync_all()`.
+//! - **Split NonVolatile**: Same layout as Split Volatile but backed by two memory-mapped
+//!   files (one for data, one for the index). Data persists to disk on drop via `sync_all()`.
 //!
 //! # Operation Complexity
 //!
@@ -32,6 +36,7 @@ use doublets::{
     unit::{self, LinkPart},
     Doublets, DoubletsExt,
 };
+use platform_mem::FileMapped;
 use std::alloc::Global;
 
 /// In-memory united (single contiguous region) doublets store.
@@ -41,6 +46,13 @@ pub type DoubletsUnitedVolatile<T = usize> = unit::Store<T, Alloc<LinkPart<T>, G
 pub type DoubletsSplitVolatile<T = usize> =
     split::Store<T, Alloc<DataPart<T>, Global>, Alloc<IndexPart<T>, Global>>;
 
+/// File-backed united (single contiguous region) doublets store.
+pub type DoubletsUnitedNonVolatile<T = usize> = unit::Store<T, FileMapped<LinkPart<T>>>;
+
+/// File-backed split (separate data and index regions) doublets store.
+pub type DoubletsSplitNonVolatile<T = usize> =
+    split::Store<T, FileMapped<DataPart<T>>, FileMapped<IndexPart<T>>>;
+
 /// Wrapper adapting a `doublets::Doublets` store to the shared `Links` trait.
 pub struct DoubletsLinks<S> {
     store: S,
@@ -146,6 +158,28 @@ pub fn create_split_volatile() -> DoubletsLinks<DoubletsSplitVolatile> {
     DoubletsLinks::new(store)
 }
 
+/// Create a new file-backed doublets united store at the given path.
+pub fn create_united_non_volatile(path: &str) -> DoubletsLinks<DoubletsUnitedNonVolatile> {
+    let mem = FileMapped::from_path(path).expect("Failed to open united links file");
+    let store = DoubletsUnitedNonVolatile::new(mem)
+        .expect("Failed to create doublets united non-volatile store");
+    DoubletsLinks::new(store)
+}
+
+/// Create a new file-backed doublets split store at the given paths.
+///
+/// `data_path` stores the link data (source, target), `index_path` stores the tree index.
+pub fn create_split_non_volatile(
+    data_path: &str,
+    index_path: &str,
+) -> DoubletsLinks<DoubletsSplitNonVolatile> {
+    let data_mem = FileMapped::from_path(data_path).expect("Failed to open split data file");
+    let index_mem = FileMapped::from_path(index_path).expect("Failed to open split index file");
+    let store = DoubletsSplitNonVolatile::new(data_mem, index_mem)
+        .expect("Failed to create doublets split non-volatile store");
+    DoubletsLinks::new(store)
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -230,4 +264,41 @@ mod tests {
         db.delete_all();
         assert_eq!(db.count(), 0);
     }
+
+    #[test]
+    fn test_create_and_query_united_non_volatile() {
+        let path = "/tmp/test_united_non_volatile.links";
+        // Remove any leftover file from previous runs
+        let _ = std::fs::remove_file(path);
+        {
+            let mut db = create_united_non_volatile(path);
+            let id = db.create_point();
+            assert_eq!(id, 1);
+            let link = db.query_by_id(id).unwrap();
+            assert_eq!(link.source, id);
+            assert_eq!(link.target, id);
+        }
+        // Clean up
+        let _ = std::fs::remove_file(path);
+    }
+
+    #[test]
+    fn test_create_and_query_split_non_volatile() {
+        let data_path = "/tmp/test_split_non_volatile_data.links";
+        let index_path = "/tmp/test_split_non_volatile_index.links";
+        // Remove any leftover files from previous runs
+        let _ = std::fs::remove_file(data_path);
+        let _ = std::fs::remove_file(index_path);
+        {
+            let mut db = create_split_non_volatile(data_path, index_path);
+            let id = db.create_point();
+            assert_eq!(id, 1);
+            let link = db.query_by_id(id).unwrap();
+            assert_eq!(link.source, id);
+            assert_eq!(link.target, id);
+        }
+        // Clean up
+        let _ = std::fs::remove_file(data_path);
+        let _ = std::fs::remove_file(index_path);
+    }
 }
diff --git a/rust/src/lib.rs b/rust/src/lib.rs
index 2e303e2..e957413 100644
--- a/rust/src/lib.rs
+++ b/rust/src/lib.rs
@@ -9,6 +9,7 @@ pub mod benched;
 pub mod doublets_impl;
 pub mod exclusive;
 pub mod fork;
+pub mod module_bindings;
 pub mod spacetimedb_impl;
 
 pub use benched::Benched;
diff --git a/rust/src/module_bindings/create_link_reducer.rs b/rust/src/module_bindings/create_link_reducer.rs
new file mode 100644
index 0000000..b3dfca6
--- /dev/null
+++ b/rust/src/module_bindings/create_link_reducer.rs
@@ -0,0 +1,54 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+#![allow(unused, clippy::all)]
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+pub(super) struct CreateLinkArgs {
+    pub source: u64,
+    pub target: u64,
+}
+
+impl From<CreateLinkArgs> for super::Reducer {
+    fn from(args: CreateLinkArgs) -> Self {
+        Self::CreateLink {
+            source: args.source,
+            target: args.target,
+        }
+    }
+}
+
+impl __sdk::InModule for CreateLinkArgs {
+    type Module = super::RemoteModule;
+}
+
+#[allow(non_camel_case_types)]
+pub trait create_link {
+    fn create_link(&self, source: u64, target: u64) -> __sdk::Result<()> {
+        self.create_link_then(source, target, |_, _| {})
+    }
+    fn create_link_then(
+        &self,
+        source: u64,
+        target: u64,
+        callback: impl FnOnce(&super::ReducerEventContext, Result<Result<(), String>, __sdk::InternalError>)
+            + Send
+            + 'static,
+    ) -> __sdk::Result<()>;
+}
+
+impl create_link for super::RemoteReducers {
+    fn create_link_then(
+        &self,
+        source: u64,
+        target: u64,
+        callback: impl FnOnce(&super::ReducerEventContext, Result<Result<(), String>, __sdk::InternalError>)
+            + Send
+            + 'static,
+    ) -> __sdk::Result<()> {
+        self.imp
+            .invoke_reducer_with_callback(CreateLinkArgs { source, target }, callback)
+    }
+}
diff --git a/rust/src/module_bindings/delete_all_links_reducer.rs b/rust/src/module_bindings/delete_all_links_reducer.rs
new file mode 100644
index 0000000..466faca
--- /dev/null
+++ b/rust/src/module_bindings/delete_all_links_reducer.rs
@@ -0,0 +1,44 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+#![allow(unused, clippy::all)]
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+pub(super) struct DeleteAllLinksArgs {}
+
+impl From<DeleteAllLinksArgs> for super::Reducer {
+    fn from(_args: DeleteAllLinksArgs) -> Self {
+        Self::DeleteAllLinks
+    }
+}
+
+impl __sdk::InModule for DeleteAllLinksArgs {
+    type Module = super::RemoteModule;
+}
+
+#[allow(non_camel_case_types)]
+pub trait delete_all_links {
+    fn delete_all_links(&self) -> __sdk::Result<()> {
+        self.delete_all_links_then(|_, _| {})
+    }
+    fn delete_all_links_then(
+        &self,
+        callback: impl FnOnce(&super::ReducerEventContext, Result<Result<(), String>, __sdk::InternalError>)
+            + Send
+            + 'static,
+    ) -> __sdk::Result<()>;
+}
+
+impl delete_all_links for super::RemoteReducers {
+    fn delete_all_links_then(
+        &self,
+        callback: impl FnOnce(&super::ReducerEventContext, Result<Result<(), String>, __sdk::InternalError>)
+            + Send
+            + 'static,
+    ) -> __sdk::Result<()> {
+        self.imp
+            .invoke_reducer_with_callback(DeleteAllLinksArgs {}, callback)
+    }
+}
diff --git a/rust/src/module_bindings/delete_link_reducer.rs b/rust/src/module_bindings/delete_link_reducer.rs
new file mode 100644
index 0000000..a973ae1
--- /dev/null
+++ b/rust/src/module_bindings/delete_link_reducer.rs
@@ -0,0 +1,48 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+#![allow(unused, clippy::all)]
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+pub(super) struct DeleteLinkArgs {
+    pub id: u64,
+}
+
+impl From<DeleteLinkArgs> for super::Reducer {
+    fn from(args: DeleteLinkArgs) -> Self {
+        Self::DeleteLink { id: args.id }
+    }
+}
+
+impl __sdk::InModule for DeleteLinkArgs {
+    type Module = super::RemoteModule;
+}
+
+#[allow(non_camel_case_types)]
+pub trait delete_link {
+    fn delete_link(&self, id: u64) -> __sdk::Result<()> {
+        self.delete_link_then(id, |_, _| {})
+    }
+    fn delete_link_then(
+        &self,
+        id: u64,
+        callback: impl FnOnce(&super::ReducerEventContext, Result<Result<(), String>, __sdk::InternalError>)
+            + Send
+            + 'static,
+    ) -> __sdk::Result<()>;
+}
+
+impl delete_link for super::RemoteReducers {
+    fn delete_link_then(
+        &self,
+        id: u64,
+        callback: impl FnOnce(&super::ReducerEventContext, Result<Result<(), String>, __sdk::InternalError>)
+            + Send
+            + 'static,
+    ) -> __sdk::Result<()> {
+        self.imp
+            .invoke_reducer_with_callback(DeleteLinkArgs { id }, callback)
+    }
+}
diff --git a/rust/src/module_bindings/link_table.rs b/rust/src/module_bindings/link_table.rs
new file mode 100644
index 0000000..f9fc58a
--- /dev/null
+++ b/rust/src/module_bindings/link_table.rs
@@ -0,0 +1,111 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+#![allow(unused, clippy::all)]
+use super::link_type::Link;
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+pub struct LinkTableHandle<'ctx> {
+    imp: __sdk::TableHandle<Link>,
+    ctx: std::marker::PhantomData<&'ctx super::RemoteTables>,
+}
+
+#[allow(non_camel_case_types)]
+pub trait LinkTableAccess {
+    #[allow(non_snake_case)]
+    fn links(&self) -> LinkTableHandle<'_>;
+}
+
+impl LinkTableAccess for super::RemoteTables {
+    fn links(&self) -> LinkTableHandle<'_> {
+        LinkTableHandle {
+            imp: self.imp.get_table::<Link>("links"),
+            ctx: std::marker::PhantomData,
+        }
+    }
+}
+
+pub struct LinkInsertCallbackId(__sdk::CallbackId);
+pub struct LinkDeleteCallbackId(__sdk::CallbackId);
+pub struct LinkUpdateCallbackId(__sdk::CallbackId);
+
+impl<'ctx> __sdk::Table for LinkTableHandle<'ctx> {
+    type Row = Link;
+    type EventContext = super::EventContext;
+
+    fn count(&self) -> u64 {
+        self.imp.count()
+    }
+    fn iter(&self) -> impl Iterator<Item = Link> + '_ {
+        self.imp.iter()
+    }
+
+    type InsertCallbackId = LinkInsertCallbackId;
+
+    fn on_insert(
+        &self,
+        callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static,
+    ) -> LinkInsertCallbackId {
+        LinkInsertCallbackId(self.imp.on_insert(Box::new(callback)))
+    }
+
+    fn remove_on_insert(&self, callback: LinkInsertCallbackId) {
+        self.imp.remove_on_insert(callback.0)
+    }
+
+    type DeleteCallbackId = LinkDeleteCallbackId;
+
+    fn on_delete(
+        &self,
+        callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static,
+    ) -> LinkDeleteCallbackId {
+        LinkDeleteCallbackId(self.imp.on_delete(Box::new(callback)))
+    }
+
+    fn remove_on_delete(&self, callback: LinkDeleteCallbackId) {
+        self.imp.remove_on_delete(callback.0)
+    }
+}
+
+impl<'ctx> __sdk::TableWithPrimaryKey for LinkTableHandle<'ctx> {
+    type UpdateCallbackId = LinkUpdateCallbackId;
+
+    fn on_update(
+        &self,
+        callback: impl FnMut(&Self::EventContext, &Self::Row, &Self::Row) + Send + 'static,
+    ) -> LinkUpdateCallbackId {
+        LinkUpdateCallbackId(self.imp.on_update(Box::new(callback)))
+    }
+
+    fn remove_on_update(&self, callback: LinkUpdateCallbackId) {
+        self.imp.remove_on_update(callback.0)
+    }
+}
+
+#[doc(hidden)]
+pub(super) fn register_table(client_cache: &mut __sdk::ClientCache<super::RemoteModule>) {
+    let _table = client_cache.get_or_make_table::<Link>("links");
+}
+
+#[doc(hidden)]
+pub(super) fn parse_table_update(
+    raw_updates: __ws::v2::TableUpdate,
+) -> __sdk::Result<__sdk::TableUpdate<Link>> {
+    __sdk::TableUpdate::parse_table_update(raw_updates).map_err(|e| {
+        __sdk::InternalError::failed_parse("TableUpdate<Link>", "TableUpdate")
+            .with_cause(e)
+            .into()
+    })
+}
+
+#[allow(non_camel_case_types)]
+pub trait linksQueryTableAccess {
+    #[allow(non_snake_case)]
+    fn links(&self) -> __sdk::__query_builder::Table<Link>;
+}
+
+impl linksQueryTableAccess for __sdk::QueryTableAccessor {
+    fn links(&self) -> __sdk::__query_builder::Table<Link> {
+        __sdk::__query_builder::Table::new("links")
+    }
+}
diff --git a/rust/src/module_bindings/link_type.rs b/rust/src/module_bindings/link_type.rs
new file mode 100644
index 0000000..3958dbd
--- /dev/null
+++ b/rust/src/module_bindings/link_type.rs
@@ -0,0 +1,55 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+//
+// This was generated for the `spacetime-module` crate (links table).
+
+#![allow(unused, clippy::all)]
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+pub struct Link {
+    pub id: u64,
+    pub source: u64,
+    pub target: u64,
+}
+
+impl __sdk::InModule for Link {
+    type Module = super::RemoteModule;
+}
+
+pub struct LinkCols {
+    pub id: __sdk::__query_builder::Col<Link, u64>,
+    pub source: __sdk::__query_builder::Col<Link, u64>,
+    pub target: __sdk::__query_builder::Col<Link, u64>,
+}
+
+impl __sdk::__query_builder::HasCols for Link {
+    type Cols = LinkCols;
+    fn cols(table_name: &'static str) -> Self::Cols {
+        LinkCols {
+            id: __sdk::__query_builder::Col::new(table_name, "id"),
+            source: __sdk::__query_builder::Col::new(table_name, "source"),
+            target: __sdk::__query_builder::Col::new(table_name, "target"),
+        }
+    }
+}
+
+pub struct LinkIxCols {
+    pub id: __sdk::__query_builder::IxCol<Link, u64>,
+    pub source: __sdk::__query_builder::IxCol<Link, u64>,
+    pub target: __sdk::__query_builder::IxCol<Link, u64>,
+}
+
+impl __sdk::__query_builder::HasIxCols for Link {
+    type IxCols = LinkIxCols;
+    fn ix_cols(table_name: &'static str) -> Self::IxCols {
+        LinkIxCols {
+            id: __sdk::__query_builder::IxCol::new(table_name, "id"),
+            source: __sdk::__query_builder::IxCol::new(table_name, "source"),
+            target: __sdk::__query_builder::IxCol::new(table_name, "target"),
+        }
+    }
+}
+
+impl __sdk::__query_builder::CanBeLookupTable for Link {}
diff --git a/rust/src/module_bindings/mod.rs b/rust/src/module_bindings/mod.rs
new file mode 100644
index 0000000..61a217d
--- /dev/null
+++ b/rust/src/module_bindings/mod.rs
@@ -0,0 +1,702 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+//
+// Generated for the `spacetime-module` links benchmark module.
+
+#![allow(unused, clippy::all)]
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+pub mod create_link_reducer;
+pub mod delete_all_links_reducer;
+pub mod delete_link_reducer;
+pub mod link_table;
+pub mod link_type;
+pub mod update_link_reducer;
+
+pub use create_link_reducer::create_link;
+pub use delete_all_links_reducer::delete_all_links;
+pub use delete_link_reducer::delete_link;
+pub use link_table::*;
+pub use link_type::Link;
+pub use update_link_reducer::update_link;
+
+#[derive(Clone, PartialEq, Debug)]
+pub enum Reducer {
+    CreateLink { source: u64, target: u64 },
+    UpdateLink { id: u64, source: u64, target: u64 },
+    DeleteLink { id: u64 },
+    DeleteAllLinks,
+}
+
+impl __sdk::InModule for Reducer {
+    type Module = RemoteModule;
+}
+
+impl __sdk::Reducer for Reducer {
+    fn reducer_name(&self) -> &'static str {
+        match self {
+            Reducer::CreateLink { .. } => "create_link",
+            Reducer::UpdateLink { .. } => "update_link",
+            Reducer::DeleteLink { .. } => "delete_link",
+            Reducer::DeleteAllLinks => "delete_all_links",
+        }
+    }
+    #[allow(clippy::clone_on_copy)]
+    fn args_bsatn(&self) -> Result<Vec<u8>, __sats::bsatn::EncodeError> {
+        match self {
+            Reducer::CreateLink { source, target } => {
+                __sats::bsatn::to_vec(&create_link_reducer::CreateLinkArgs {
+                    source: *source,
+                    target: *target,
+                })
+            }
+            Reducer::UpdateLink { id, source, target } => {
+                __sats::bsatn::to_vec(&update_link_reducer::UpdateLinkArgs {
+                    id: *id,
+                    source: *source,
+                    target: *target,
+                })
+            }
+            Reducer::DeleteLink { id } => {
+                __sats::bsatn::to_vec(&delete_link_reducer::DeleteLinkArgs { id: *id })
+            }
+            Reducer::DeleteAllLinks => {
+                __sats::bsatn::to_vec(&delete_all_links_reducer::DeleteAllLinksArgs {})
+            }
+        }
+    }
+}
+
+#[derive(Default)]
+#[allow(non_snake_case)]
+#[doc(hidden)]
+pub struct DbUpdate {
+    links: __sdk::TableUpdate<Link>,
+}
+
+impl TryFrom<__ws::v2::TransactionUpdate> for DbUpdate {
+    type Error = __sdk::Error;
+    fn try_from(raw: __ws::v2::TransactionUpdate) -> Result<Self, Self::Error> {
+        let mut db_update = DbUpdate::default();
+        for table_update in __sdk::transaction_update_iter_table_updates(raw) {
+            match &table_update.table_name[..] {
+                "links" => db_update
+                    .links
+                    .append(link_table::parse_table_update(table_update)?),
+                unknown => {
+                    return Err(__sdk::InternalError::unknown_name(
+                        "table",
+                        unknown,
+                        "DatabaseUpdate",
+                    )
+                    .into());
+                }
+            }
+        }
+        Ok(db_update)
+    }
+}
+
+impl __sdk::InModule for DbUpdate {
+    type Module = RemoteModule;
+}
+
+impl __sdk::DbUpdate for DbUpdate {
+    fn apply_to_client_cache(
+        &self,
+        cache: &mut __sdk::ClientCache<RemoteModule>,
+    ) -> AppliedDiff<'_> {
+        let mut diff = AppliedDiff::default();
+        diff.links = cache.apply_diff_to_table::<Link>("links", &self.links);
+        diff
+    }
+    fn parse_initial_rows(raw: __ws::v2::QueryRows) -> __sdk::Result<Self> {
+        let mut db_update = DbUpdate::default();
+        for table_rows in raw.tables {
+            match &table_rows.table[..] {
+                "links" => db_update
+                    .links
+                    .append(__sdk::parse_row_list_as_inserts(table_rows.rows)?),
+                unknown => {
+                    return Err(
+                        __sdk::InternalError::unknown_name("table", unknown, "QueryRows").into(),
+                    );
+                }
+            }
+        }
+        Ok(db_update)
+    }
+    fn parse_unsubscribe_rows(raw: __ws::v2::QueryRows) -> __sdk::Result<Self> {
+        let mut db_update = DbUpdate::default();
+        for table_rows in raw.tables {
+            match &table_rows.table[..] {
+                "links" => db_update
+                    .links
+                    .append(__sdk::parse_row_list_as_deletes(table_rows.rows)?),
+                unknown => {
+                    return Err(
+                        __sdk::InternalError::unknown_name("table", unknown, "QueryRows").into(),
+                    );
+                }
+            }
+        }
+        Ok(db_update)
+    }
+}
+
+#[derive(Default)]
+#[allow(non_snake_case)]
+#[doc(hidden)]
+pub struct AppliedDiff<'r> {
+    links: __sdk::TableAppliedDiff<'r, Link>,
+    __unused: std::marker::PhantomData<&'r ()>,
+}
+
+impl __sdk::InModule for AppliedDiff<'_> {
+    type Module = RemoteModule;
+}
+
+impl<'r> __sdk::AppliedDiff<'r> for AppliedDiff<'r> {
+    fn invoke_row_callbacks(
+        &self,
+        event: &EventContext,
+        callbacks: &mut __sdk::DbCallbacks<RemoteModule>,
+    ) {
+        callbacks.invoke_table_row_callbacks::<Link>("links", &self.links, event);
+    }
+}
+
+#[doc(hidden)]
+pub struct RemoteModule;
+
+impl __sdk::InModule for RemoteModule {
+    type Module = Self;
+}
+
+pub struct RemoteReducers {
+    imp: __sdk::DbContextImpl<RemoteModule>,
+}
+
+impl __sdk::InModule for RemoteReducers {
+    type Module = RemoteModule;
+}
+
+pub struct RemoteProcedures {
+    imp: __sdk::DbContextImpl<RemoteModule>,
+}
+
+impl __sdk::InModule for RemoteProcedures {
+    type Module = RemoteModule;
+}
+
+pub struct RemoteTables {
+    pub imp: __sdk::DbContextImpl<RemoteModule>,
+}
+
+impl __sdk::InModule for RemoteTables {
+    type Module = RemoteModule;
+}
+
+pub struct DbConnection {
+    pub db: RemoteTables,
+    pub reducers: RemoteReducers,
+    #[doc(hidden)]
+    pub procedures: RemoteProcedures,
+    imp: __sdk::DbContextImpl<RemoteModule>,
+}
+
+impl __sdk::InModule for DbConnection {
+    type Module = RemoteModule;
+}
+
+impl __sdk::DbContext for DbConnection {
+    type DbView = RemoteTables;
+    type Reducers = RemoteReducers;
+    type Procedures = RemoteProcedures;
+
+    fn db(&self) -> &Self::DbView {
+        &self.db
+    }
+    fn reducers(&self) -> &Self::Reducers {
+        &self.reducers
+    }
+    fn procedures(&self) -> &Self::Procedures {
+        &self.procedures
+    }
+
+    fn is_active(&self) -> bool {
+        self.imp.is_active()
+    }
+    fn disconnect(&self) -> __sdk::Result<()> {
+        self.imp.disconnect()
+    }
+
+    type SubscriptionBuilder = __sdk::SubscriptionBuilder<RemoteModule>;
+
+    fn subscription_builder(&self) -> Self::SubscriptionBuilder {
+        __sdk::SubscriptionBuilder::new(&self.imp)
+    }
+
+    fn try_identity(&self) -> Option<__sdk::Identity> {
+        self.imp.try_identity()
+    }
+    fn connection_id(&self) -> __sdk::ConnectionId {
+        self.imp.connection_id()
+    }
+    fn try_connection_id(&self) -> Option<__sdk::ConnectionId> {
+        self.imp.try_connection_id()
+    }
+}
+
+impl DbConnection {
+    pub fn builder() -> __sdk::DbConnectionBuilder<RemoteModule> {
+        __sdk::DbConnectionBuilder::new()
+    }
+
+    pub fn advance_one_message(&self) -> __sdk::Result<bool> {
+        self.imp.advance_one_message()
+    }
+
+    pub fn advance_one_message_blocking(&self) -> __sdk::Result<()> {
+        self.imp.advance_one_message_blocking()
+    }
+
+    pub async fn advance_one_message_async(&self) -> __sdk::Result<()> {
+        self.imp.advance_one_message_async().await
+    }
+
+    pub fn frame_tick(&self) -> __sdk::Result<()> {
+        self.imp.frame_tick()
+    }
+
+    pub fn run_threaded(&self) -> std::thread::JoinHandle<()> {
+        self.imp.run_threaded()
+    }
+
+    pub async fn run_async(&self) -> __sdk::Result<()> {
+        self.imp.run_async().await
+    }
+}
+
+impl __sdk::DbConnection for DbConnection {
+    fn new(imp: __sdk::DbContextImpl<RemoteModule>) -> Self {
+        Self {
+            db: RemoteTables { imp: imp.clone() },
+            reducers: RemoteReducers { imp: imp.clone() },
+            procedures: RemoteProcedures { imp: imp.clone() },
+            imp,
+        }
+    }
+}
+
+#[derive(Clone)]
+pub struct SubscriptionHandle {
+    imp: __sdk::SubscriptionHandleImpl<RemoteModule>,
+}
+
+impl __sdk::InModule for SubscriptionHandle {
+    type Module = RemoteModule;
+}
+
+impl __sdk::SubscriptionHandle for SubscriptionHandle {
+    fn new(imp: __sdk::SubscriptionHandleImpl<RemoteModule>) -> Self {
+        Self { imp }
+    }
+
+    fn is_ended(&self) -> bool {
+        self.imp.is_ended()
+    }
+
+    fn is_active(&self) -> bool {
+        self.imp.is_active()
+    }
+
+    fn unsubscribe_then(self, on_end: __sdk::OnEndedCallback<RemoteModule>) -> __sdk::Result<()> {
+        self.imp.unsubscribe_then(Some(on_end))
+    }
+
+    fn unsubscribe(self) -> __sdk::Result<()> {
+        self.imp.unsubscribe_then(None)
+    }
+}
+
+pub trait RemoteDbContext:
+    __sdk::DbContext<
+    DbView = RemoteTables,
+    Reducers = RemoteReducers,
+    SubscriptionBuilder = __sdk::SubscriptionBuilder<RemoteModule>,
+>
+{
+}
+impl<
+        Ctx: __sdk::DbContext<
+            DbView = RemoteTables,
+            Reducers = RemoteReducers,
+            SubscriptionBuilder = __sdk::SubscriptionBuilder<RemoteModule>,
+        >,
+    > RemoteDbContext for Ctx
+{
+}
+
+pub struct EventContext {
+    pub db: RemoteTables,
+    pub reducers: RemoteReducers,
+    pub procedures: RemoteProcedures,
+    pub event: __sdk::Event<Reducer>,
+    imp: __sdk::DbContextImpl<RemoteModule>,
+}
+
+impl __sdk::AbstractEventContext for EventContext {
+    type Event = __sdk::Event<Reducer>;
+    fn event(&self) -> &Self::Event {
+        &self.event
+    }
+    fn new(imp: __sdk::DbContextImpl<RemoteModule>, event: Self::Event) -> Self {
+        Self {
+            db: RemoteTables { imp: imp.clone() },
+            reducers: RemoteReducers { imp: imp.clone() },
+            procedures: RemoteProcedures { imp: imp.clone() },
+            event,
+            imp,
+        }
+    }
+}
+
+impl __sdk::InModule for EventContext {
+    type Module = RemoteModule;
+}
+
+impl __sdk::DbContext for EventContext {
+    type DbView = RemoteTables;
+    type Reducers = RemoteReducers;
+    type Procedures = RemoteProcedures;
+
+    fn db(&self) -> &Self::DbView {
+        &self.db
+    }
+    fn reducers(&self) -> &Self::Reducers {
+        &self.reducers
+    }
+    fn procedures(&self) -> &Self::Procedures {
+        &self.procedures
+    }
+
+    fn is_active(&self) -> bool {
+        self.imp.is_active()
+    }
+    fn disconnect(&self) -> __sdk::Result<()> {
+        self.imp.disconnect()
+    }
+
+    type SubscriptionBuilder = __sdk::SubscriptionBuilder<RemoteModule>;
+
+    fn subscription_builder(&self) -> Self::SubscriptionBuilder {
+        __sdk::SubscriptionBuilder::new(&self.imp)
+    }
+
+    fn try_identity(&self) -> Option<__sdk::Identity> {
+        self.imp.try_identity()
+    }
+    fn connection_id(&self) -> __sdk::ConnectionId {
+        self.imp.connection_id()
+    }
+    fn try_connection_id(&self) -> Option<__sdk::ConnectionId> {
+        self.imp.try_connection_id()
+    }
+}
+
+impl __sdk::EventContext for EventContext {}
+
+pub struct ReducerEventContext {
+    pub db: RemoteTables,
+    pub reducers: RemoteReducers,
+    pub procedures: RemoteProcedures,
+    pub event: __sdk::ReducerEvent<Reducer>,
+    imp: __sdk::DbContextImpl<RemoteModule>,
+}
+
+impl __sdk::AbstractEventContext for ReducerEventContext {
+    type Event = __sdk::ReducerEvent<Reducer>;
+    fn event(&self) -> &Self::Event {
+        &self.event
+    }
+    fn new(imp: __sdk::DbContextImpl<RemoteModule>, event: Self::Event) -> Self {
+        Self {
+            db: RemoteTables { imp: imp.clone() },
+            reducers: RemoteReducers { imp: imp.clone() },
+            procedures: RemoteProcedures { imp: imp.clone() },
+            event,
+            imp,
+        }
+    }
+}
+
+impl __sdk::InModule for ReducerEventContext {
+    type Module = RemoteModule;
+}
+
+impl __sdk::DbContext for ReducerEventContext {
+    type DbView = RemoteTables;
+    type Reducers = RemoteReducers;
+    type Procedures = RemoteProcedures;
+
+    fn db(&self) -> &Self::DbView {
+        &self.db
+    }
+    fn reducers(&self) -> &Self::Reducers {
+        &self.reducers
+    }
+    fn procedures(&self) -> &Self::Procedures {
+        &self.procedures
+    }
+
+    fn is_active(&self) -> bool {
+        self.imp.is_active()
+    }
+    fn disconnect(&self) -> __sdk::Result<()> {
+        self.imp.disconnect()
+    }
+
+    type SubscriptionBuilder = __sdk::SubscriptionBuilder<RemoteModule>;
+
+    fn subscription_builder(&self) -> Self::SubscriptionBuilder {
+        __sdk::SubscriptionBuilder::new(&self.imp)
+    }
+
+    fn try_identity(&self) -> Option<__sdk::Identity> {
+        self.imp.try_identity()
+    }
+    fn connection_id(&self) -> __sdk::ConnectionId {
+        self.imp.connection_id()
+    }
+    fn try_connection_id(&self) -> Option<__sdk::ConnectionId> {
+        self.imp.try_connection_id()
+    }
+}
+
+impl __sdk::ReducerEventContext for ReducerEventContext {}
+
+pub struct ProcedureEventContext {
+    pub db: RemoteTables,
+    pub reducers: RemoteReducers,
+    pub procedures: RemoteProcedures,
+    imp: __sdk::DbContextImpl<RemoteModule>,
+}
+
+impl __sdk::AbstractEventContext for ProcedureEventContext {
+    type Event = ();
+    fn event(&self) -> &Self::Event {
+        &()
+    }
+    fn new(imp: __sdk::DbContextImpl<RemoteModule>, _event: Self::Event) -> Self {
+        Self {
+            db: RemoteTables { imp: imp.clone() },
+            reducers: RemoteReducers { imp: imp.clone() },
+            procedures: RemoteProcedures { imp: imp.clone() },
+            imp,
+        }
+    }
+}
+
+impl __sdk::InModule for ProcedureEventContext {
+    type Module = RemoteModule;
+}
+
+impl __sdk::DbContext for ProcedureEventContext {
+    type DbView = RemoteTables;
+    type Reducers = RemoteReducers;
+    type Procedures = RemoteProcedures;
+
+    fn db(&self) -> &Self::DbView {
+        &self.db
+    }
+    fn reducers(&self) -> &Self::Reducers {
+        &self.reducers
+    }
+    fn procedures(&self) -> &Self::Procedures {
+        &self.procedures
+    }
+
+    fn is_active(&self) -> bool {
+        self.imp.is_active()
+    }
+    fn disconnect(&self) -> __sdk::Result<()> {
+        self.imp.disconnect()
+    }
+
+    type SubscriptionBuilder = __sdk::SubscriptionBuilder<RemoteModule>;
+
+    fn subscription_builder(&self) -> Self::SubscriptionBuilder {
+        __sdk::SubscriptionBuilder::new(&self.imp)
+    }
+
+    fn try_identity(&self) -> Option<__sdk::Identity> {
+        self.imp.try_identity()
+    }
+    fn connection_id(&self) -> __sdk::ConnectionId {
+        self.imp.connection_id()
+    }
+    fn try_connection_id(&self) -> Option<__sdk::ConnectionId> {
+        self.imp.try_connection_id()
+    }
+}
+
+impl __sdk::ProcedureEventContext for ProcedureEventContext {}
+
+pub struct SubscriptionEventContext {
+    pub db: RemoteTables,
+    pub reducers: RemoteReducers,
+    pub procedures: RemoteProcedures,
+    imp: __sdk::DbContextImpl<RemoteModule>,
+}
+
+impl __sdk::AbstractEventContext for SubscriptionEventContext {
+    type Event = ();
+    fn event(&self) -> &Self::Event {
+        &()
+    }
+    fn new(imp: __sdk::DbContextImpl<RemoteModule>, _event: Self::Event) -> Self {
+        Self {
+            db: RemoteTables { imp: imp.clone() },
+            reducers: RemoteReducers { imp: imp.clone() },
+            procedures: RemoteProcedures { imp: imp.clone() },
+            imp,
+        }
+    }
+}
+
+impl __sdk::InModule for SubscriptionEventContext {
+    type Module = RemoteModule;
+}
+
+impl __sdk::DbContext for SubscriptionEventContext {
+    type DbView = RemoteTables;
+    type Reducers = RemoteReducers;
+    type Procedures = RemoteProcedures;
+
+    fn db(&self) -> &Self::DbView {
+        &self.db
+    }
+    fn reducers(&self) -> &Self::Reducers {
+        &self.reducers
+    }
+    fn procedures(&self) -> &Self::Procedures {
+        &self.procedures
+    }
+
+    fn is_active(&self) -> bool {
+        self.imp.is_active()
+    }
+    fn disconnect(&self) -> __sdk::Result<()> {
+        self.imp.disconnect()
+    }
+
+    type SubscriptionBuilder = __sdk::SubscriptionBuilder<RemoteModule>;
+
+    fn subscription_builder(&self) -> Self::SubscriptionBuilder {
+        __sdk::SubscriptionBuilder::new(&self.imp)
+    }
+
+    fn try_identity(&self) -> Option<__sdk::Identity> {
+        self.imp.try_identity()
+    }
+    fn connection_id(&self) -> __sdk::ConnectionId {
+        self.imp.connection_id()
+    }
+    fn try_connection_id(&self) -> Option<__sdk::ConnectionId> {
+        self.imp.try_connection_id()
+    }
+}
+
+impl __sdk::SubscriptionEventContext for SubscriptionEventContext {}
+
+pub struct ErrorContext {
+    pub db: RemoteTables,
+    pub reducers: RemoteReducers,
+    pub procedures: RemoteProcedures,
+    pub event: Option<__sdk::Error>,
+    imp: __sdk::DbContextImpl<RemoteModule>,
+}
+
+impl __sdk::AbstractEventContext for ErrorContext {
+    type Event = Option<__sdk::Error>;
+    fn event(&self) -> &Self::Event {
+        &self.event
+    }
+    fn new(imp: __sdk::DbContextImpl<RemoteModule>, event: Self::Event) -> Self {
+        Self {
+            db: RemoteTables { imp: imp.clone() },
+            reducers: RemoteReducers { imp: imp.clone() },
+            procedures: RemoteProcedures { imp: imp.clone() },
+            event,
+            imp,
+        }
+    }
+}
+
+impl __sdk::InModule for ErrorContext {
+    type Module = RemoteModule;
+}
+
+impl __sdk::DbContext for ErrorContext {
+    type DbView = RemoteTables;
+    type Reducers = RemoteReducers;
+    type Procedures = RemoteProcedures;
+
+    fn db(&self) -> &Self::DbView {
+        &self.db
+    }
+    fn reducers(&self) -> &Self::Reducers {
+        &self.reducers
+    }
+    fn procedures(&self) -> &Self::Procedures {
+        &self.procedures
+    }
+
+    fn is_active(&self) -> bool {
+        self.imp.is_active()
+    }
+    fn disconnect(&self) -> __sdk::Result<()> {
+        self.imp.disconnect()
+    }
+
+    type SubscriptionBuilder = __sdk::SubscriptionBuilder<RemoteModule>;
+
+    fn subscription_builder(&self) -> Self::SubscriptionBuilder {
+        __sdk::SubscriptionBuilder::new(&self.imp)
+    }
+
+    fn try_identity(&self) -> Option<__sdk::Identity> {
+        self.imp.try_identity()
+    }
+    fn connection_id(&self) -> __sdk::ConnectionId {
+        self.imp.connection_id()
+    }
+    fn try_connection_id(&self) -> Option<__sdk::ConnectionId> {
+        self.imp.try_connection_id()
+    }
+}
+
+impl __sdk::ErrorContext for ErrorContext {}
+
+impl __sdk::SpacetimeModule for RemoteModule {
+    type DbConnection = DbConnection;
+    type EventContext = EventContext;
+    type ReducerEventContext = ReducerEventContext;
+    type ProcedureEventContext = ProcedureEventContext;
+    type SubscriptionEventContext = SubscriptionEventContext;
+    type ErrorContext = ErrorContext;
+    type Reducer = Reducer;
+    type DbView = RemoteTables;
+    type Reducers = RemoteReducers;
+    type Procedures = RemoteProcedures;
+    type DbUpdate = DbUpdate;
+    type AppliedDiff<'r> = AppliedDiff<'r>;
+    type SubscriptionHandle = SubscriptionHandle;
+    type QueryBuilder = __sdk::QueryBuilder;
+
+    fn register_tables(client_cache: &mut __sdk::ClientCache<Self>) {
+        link_table::register_table(client_cache);
+    }
+    const ALL_TABLE_NAMES: &'static [&'static str] = &["links"];
+}
diff --git a/rust/src/module_bindings/update_link_reducer.rs b/rust/src/module_bindings/update_link_reducer.rs
new file mode 100644
index 0000000..cc2fe65
--- /dev/null
+++ b/rust/src/module_bindings/update_link_reducer.rs
@@ -0,0 +1,58 @@
+// THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
+// WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
+
+#![allow(unused, clippy::all)]
+use spacetimedb_sdk::__codegen::{self as __sdk, __lib, __sats, __ws};
+
+#[derive(__lib::ser::Serialize, __lib::de::Deserialize, Clone, PartialEq, Debug)]
+#[sats(crate = __lib)]
+pub(super) struct UpdateLinkArgs {
+    pub id: u64,
+    pub source: u64,
+    pub target: u64,
+}
+
+impl From<UpdateLinkArgs> for super::Reducer {
+    fn from(args: UpdateLinkArgs) -> Self {
+        Self::UpdateLink {
+            id: args.id,
+            source: args.source,
+            target: args.target,
+        }
+    }
+}
+
+impl __sdk::InModule for UpdateLinkArgs {
+    type Module = super::RemoteModule;
+}
+
+#[allow(non_camel_case_types)]
+pub trait update_link {
+    fn update_link(&self, id: u64, source: u64, target: u64) -> __sdk::Result<()> {
+        self.update_link_then(id, source, target, |_, _| {})
+    }
+    fn update_link_then(
+        &self,
+        id: u64,
+        source: u64,
+        target: u64,
+        callback: impl FnOnce(&super::ReducerEventContext, Result<Result<(), String>, __sdk::InternalError>)
+            + Send
+            + 'static,
+    ) -> __sdk::Result<()>;
+}
+
+impl update_link for super::RemoteReducers {
+    fn update_link_then(
+        &self,
+        id: u64,
+        source: u64,
+        target: u64,
+        callback: impl FnOnce(&super::ReducerEventContext, Result<Result<(), String>, __sdk::InternalError>)
+            + Send
+            + 'static,
+    ) -> __sdk::Result<()> {
+        self.imp
+            .invoke_reducer_with_callback(UpdateLinkArgs { id, source, target }, callback)
+    }
+}
diff --git a/rust/src/spacetimedb_impl.rs b/rust/src/spacetimedb_impl.rs
index 740af12..078f228 100644
--- a/rust/src/spacetimedb_impl.rs
+++ b/rust/src/spacetimedb_impl.rs
@@ -1,231 +1,260 @@
-//! SpacetimeDB storage implementation for links (SQLite backend).
+//! SpacetimeDB 2.0 storage implementation using the official `spacetimedb-sdk` Rust crate.
 //!
-//! This implementation uses the same SQLite storage that SpacetimeDB 2 uses
-//! internally. SpacetimeDB stores data in SQLite tables with column-oriented
-//! layout; this implementation uses the equivalent schema.
+//! Connects to a running SpacetimeDB 2.0 server via WebSocket and calls
+//! reducers for link CRUD operations. Reads are served from the client-side
+//! subscription cache.
 //!
-//! SpacetimeDB is benchmarked via its SQLite backend to establish a fair
-//! baseline comparison with Doublets' in-memory data structures.
+//! # Setup
 //!
-//! # Schema
+//! Requires a running SpacetimeDB server with the links module published.
+//! Set `SPACETIMEDB_URI` (default: `http://localhost:3000`) and
+//! `SPACETIMEDB_DB` (default: `benchmark-links`) environment variables.
 //!
-//! ```sql
-//! CREATE TABLE links (
-//!     id     INTEGER PRIMARY KEY,
-//!     source INTEGER NOT NULL,
-//!     target INTEGER NOT NULL
-//! );
-//! CREATE INDEX idx_source ON links(source);
-//! CREATE INDEX idx_target ON links(target);
-//! CREATE INDEX idx_source_target ON links(source, target);
-//! ```
+//! # SpacetimeDB version
 //!
-//! # Operation Complexity
-//!
-//! | Operation              | Complexity            |
-//! |------------------------|-----------------------|
-//! | Create                 | O(log n) + disk I/O   |
-//! | Update                 | O(log n) + disk I/O   |
-//! | Delete                 | O(log n) + disk I/O   |
-//! | Query All              | O(n) + disk I/O       |
-//! | Query by Id            | O(log n)              |
-//! | Query by Source        | O(log n + k)          |
-//! | Query by Target        | O(log n + k)          |
-//! | Query by Source+Target | O(log n + k)          |
-
-use crate::{Link, Links};
-use rusqlite::{params, Connection};
-
-/// SQLite-based links storage using SpacetimeDB's internal schema.
+//! Uses `spacetimedb-sdk` v2 from crates.io (the official Rust client SDK).
+
+use crate::{
+    module_bindings::{
+        create_link_reducer::create_link, delete_all_links_reducer::delete_all_links,
+        delete_link_reducer::delete_link, link_table::LinkTableAccess,
+        update_link_reducer::update_link, DbConnection, Link as SdbLink,
+    },
+    Link, Links,
+};
+use once_cell::sync::Lazy;
+use spacetimedb_sdk::{DbContext, Table};
+use std::{
+    env,
+    sync::{Arc, Condvar, Mutex},
+    thread::JoinHandle,
+    time::Duration,
+};
+
+const DEFAULT_URI: &str = "http://localhost:3000";
+const DEFAULT_DB: &str = "benchmark-links";
+
+static SPACETIMEDB_URI: Lazy<String> =
+    Lazy::new(|| env::var("SPACETIMEDB_URI").unwrap_or_else(|_| DEFAULT_URI.to_string()));
+
+static SPACETIMEDB_DB: Lazy<String> =
+    Lazy::new(|| env::var("SPACETIMEDB_DB").unwrap_or_else(|_| DEFAULT_DB.to_string()));
+
+/// SpacetimeDB 2.0 links storage using the official `spacetimedb-sdk` Rust crate.
 ///
-/// SpacetimeDB 2 stores table data in SQLite with auto-incrementing
-/// primary keys and B-tree indexes on all searchable columns.
+/// Connects to a running SpacetimeDB server via WebSocket, subscribes to the
+/// `links` table, and calls reducers for CRUD operations. Reads are served
+/// from the client-side subscription cache.
 pub struct SpacetimeDbLinks {
-    conn: Connection,
-    next_id: u64,
+    conn: DbConnection,
+    /// Background thread handle keeping the SDK event loop alive.
+    _thread: JoinHandle<()>,
 }
 
 impl SpacetimeDbLinks {
-    /// Create a new in-memory SpacetimeDB links storage (no persistence).
+    /// Connect to the SpacetimeDB server and subscribe to the links table.
     ///
-    /// This matches SpacetimeDB's behavior when running without a persistent
-    /// data directory (e.g., for testing/benchmarking).
-    pub fn new_memory() -> Self {
-        let conn = Connection::open_in_memory().expect("Failed to open in-memory SQLite database");
-        Self::init(conn)
-    }
+    /// Reads server URI and database name from environment variables:
+    /// - `SPACETIMEDB_URI` (default: `http://localhost:3000`)
+    /// - `SPACETIMEDB_DB` (default: `benchmark-links`)
+    ///
+    /// Panics if the server is not reachable or the module is not published.
+    pub fn connect() -> Self {
+        let sub_ready = Arc::new((Mutex::new(false), Condvar::new()));
+        let sub_ready_clone = Arc::clone(&sub_ready);
 
-    fn init(conn: Connection) -> Self {
-        // Enable WAL mode for better write performance (SpacetimeDB default)
-        conn.execute_batch("PRAGMA journal_mode=WAL; PRAGMA synchronous=NORMAL;")
-            .expect("Failed to set SQLite pragmas");
-
-        conn.execute(
-            "CREATE TABLE IF NOT EXISTS links (
-                id     INTEGER PRIMARY KEY,
-                source INTEGER NOT NULL,
-                target INTEGER NOT NULL
-            )",
-            [],
-        )
-        .expect("Failed to create links table");
+        let uri = SPACETIMEDB_URI.as_str();
+        let db = SPACETIMEDB_DB.as_str();
 
-        // B-tree indexes on source, target, and composite (source, target)
-        // matching SpacetimeDB's automatic index generation for filtered columns
-        conn.execute("CREATE INDEX IF NOT EXISTS idx_source ON links(source)", [])
-            .expect("Failed to create source index");
+        eprintln!("[SpacetimeDB] Connecting to {uri}/{db}");
 
-        conn.execute("CREATE INDEX IF NOT EXISTS idx_target ON links(target)", [])
-            .expect("Failed to create target index");
+        let conn = DbConnection::builder()
+            .with_uri(uri)
+            .with_database_name(db)
+            .on_connect(|_ctx, identity, _token| {
+                eprintln!("[SpacetimeDB] Connected as {identity}");
+            })
+            .on_connect_error(|_ctx, err| {
+                panic!("[SpacetimeDB] Connection error: {err}");
+            })
+            .on_disconnect(|_ctx, _err| {
+                eprintln!("[SpacetimeDB] Disconnected");
+            })
+            .build()
+            .expect("Failed to connect to SpacetimeDB server");
+
+        // Subscribe to all links so the client cache is populated.
+        conn.subscription_builder()
+            .on_applied(move |_ctx| {
+                let (lock, cvar) = &*sub_ready_clone;
+                let mut ready = lock.lock().unwrap();
+                *ready = true;
+                cvar.notify_all();
+            })
+            .on_error(|_ctx, err| {
+                panic!("[SpacetimeDB] Subscription error: {err}");
+            })
+            .subscribe(["SELECT * FROM links"]);
+
+        // Run the SDK event loop in a background thread.
+        let thread = conn.run_threaded();
+
+        // Wait until the initial subscription is applied (cache is populated).
+        let (lock, cvar) = &*sub_ready;
+        let mut ready = lock.lock().unwrap();
+        while !*ready {
+            let result = cvar
+                .wait_timeout(ready, Duration::from_secs(30))
+                .expect("Subscription wait interrupted");
+            ready = result.0;
+            if result.1.timed_out() {
+                panic!("[SpacetimeDB] Timed out waiting for subscription to be applied");
+            }
+        }
 
-        conn.execute(
-            "CREATE INDEX IF NOT EXISTS idx_source_target ON links(source, target)",
-            [],
-        )
-        .expect("Failed to create source_target index");
+        eprintln!("[SpacetimeDB] Subscription ready, client cache populated");
 
-        let next_id: u64 = conn
-            .query_row("SELECT COALESCE(MAX(id), 0) + 1 FROM links", [], |row| {
-                row.get(0)
-            })
-            .unwrap_or(1);
+        Self {
+            conn,
+            _thread: thread,
+        }
+    }
 
-        Self { conn, next_id }
+    /// Wait for a reducer to complete by using its `_then` callback with a condvar.
+    ///
+    /// The background thread (from `run_threaded()`) processes messages and triggers
+    /// the callback. We wait on the condvar until the callback signals completion.
+    fn wait_for_reducer<F>(&self, invoke: F)
+    where
+        F: FnOnce(Arc<(Mutex<bool>, Condvar)>),
+    {
+        let done = Arc::new((Mutex::new(false), Condvar::new()));
+        invoke(Arc::clone(&done));
+        let (lock, cvar) = &*done;
+        let mut finished = lock.lock().unwrap();
+        while !*finished {
+            let result = cvar
+                .wait_timeout(finished, Duration::from_secs(30))
+                .expect("Reducer wait interrupted");
+            finished = result.0;
+            if result.1.timed_out() {
+                panic!("[SpacetimeDB] Timed out waiting for reducer to complete");
+            }
+        }
     }
 
-    /// Drop and recreate all tables and indexes (used by `delete_all`).
-    fn reset_schema(&mut self) {
-        self.conn
-            .execute("DELETE FROM links", [])
-            .expect("Failed to delete all links");
-        self.next_id = 1;
+    fn to_link(row: SdbLink) -> Link {
+        Link::new(row.id, row.source, row.target)
     }
 }
 
 impl Links for SpacetimeDbLinks {
     fn create(&mut self, source: u64, target: u64) -> u64 {
-        let id = self.next_id;
+        self.wait_for_reducer(|done| {
+            self.conn
+                .reducers
+                .create_link_then(source, target, move |_ctx, _result| {
+                    let (lock, cvar) = &*done;
+                    *lock.lock().unwrap() = true;
+                    cvar.notify_all();
+                })
+                .expect("create_link reducer failed");
+        });
+        // Return the id of the newly inserted link (max id matching source+target).
         self.conn
-            .execute(
-                "INSERT INTO links (id, source, target) VALUES (?1, ?2, ?3)",
-                params![id as i64, source as i64, target as i64],
-            )
-            .expect("Failed to insert link");
-        self.next_id += 1;
-        id
+            .db
+            .links()
+            .iter()
+            .filter(|l| l.source == source && l.target == target)
+            .map(|l| l.id)
+            .max()
+            .unwrap_or(0)
     }
 
     fn update(&mut self, id: u64, source: u64, target: u64) {
-        self.conn
-            .execute(
-                "UPDATE links SET source = ?1, target = ?2 WHERE id = ?3",
-                params![source as i64, target as i64, id as i64],
-            )
-            .expect("Failed to update link");
+        self.wait_for_reducer(|done| {
+            self.conn
+                .reducers
+                .update_link_then(id, source, target, move |_ctx, _result| {
+                    let (lock, cvar) = &*done;
+                    *lock.lock().unwrap() = true;
+                    cvar.notify_all();
+                })
+                .expect("update_link reducer failed");
+        });
     }
 
     fn delete(&mut self, id: u64) {
-        self.conn
-            .execute("DELETE FROM links WHERE id = ?1", params![id as i64])
-            .expect("Failed to delete link");
+        self.wait_for_reducer(|done| {
+            self.conn
+                .reducers
+                .delete_link_then(id, move |_ctx, _result| {
+                    let (lock, cvar) = &*done;
+                    *lock.lock().unwrap() = true;
+                    cvar.notify_all();
+                })
+                .expect("delete_link reducer failed");
+        });
     }
 
     fn delete_all(&mut self) {
-        self.reset_schema();
+        self.wait_for_reducer(|done| {
+            self.conn
+                .reducers
+                .delete_all_links_then(move |_ctx, _result| {
+                    let (lock, cvar) = &*done;
+                    *lock.lock().unwrap() = true;
+                    cvar.notify_all();
+                })
+                .expect("delete_all_links reducer failed");
+        });
     }
 
     fn query_all(&self) -> Vec<Link> {
-        let mut stmt = self
-            .conn
-            .prepare("SELECT id, source, target FROM links")
-            .expect("Failed to prepare query_all");
-
-        stmt.query_map([], |row| {
-            Ok(Link::new(
-                row.get::<_, i64>(0)? as u64,
-                row.get::<_, i64>(1)? as u64,
-                row.get::<_, i64>(2)? as u64,
-            ))
-        })
-        .expect("Failed to execute query_all")
-        .filter_map(|r| r.ok())
-        .collect()
+        self.conn.db.links().iter().map(Self::to_link).collect()
     }
 
     fn query_by_id(&self, id: u64) -> Option<Link> {
         self.conn
-            .query_row(
-                "SELECT id, source, target FROM links WHERE id = ?1",
-                params![id as i64],
-                |row| {
-                    Ok(Link::new(
-                        row.get::<_, i64>(0)? as u64,
-                        row.get::<_, i64>(1)? as u64,
-                        row.get::<_, i64>(2)? as u64,
-                    ))
-                },
-            )
-            .ok()
+            .db
+            .links()
+            .iter()
+            .find(|l| l.id == id)
+            .map(Self::to_link)
     }
 
     fn query_by_source(&self, source: u64) -> Vec<Link> {
-        let mut stmt = self
-            .conn
-            .prepare("SELECT id, source, target FROM links WHERE source = ?1")
-            .expect("Failed to prepare query_by_source");
-
-        stmt.query_map(params![source as i64], |row| {
-            Ok(Link::new(
-                row.get::<_, i64>(0)? as u64,
-                row.get::<_, i64>(1)? as u64,
-                row.get::<_, i64>(2)? as u64,
-            ))
-        })
-        .expect("Failed to execute query_by_source")
-        .filter_map(|r| r.ok())
-        .collect()
+        self.conn
+            .db
+            .links()
+            .iter()
+            .filter(|l| l.source == source)
+            .map(Self::to_link)
+            .collect()
     }
 
     fn query_by_target(&self, target: u64) -> Vec<Link> {
-        let mut stmt = self
-            .conn
-            .prepare("SELECT id, source, target FROM links WHERE target = ?1")
-            .expect("Failed to prepare query_by_target");
-
-        stmt.query_map(params![target as i64], |row| {
-            Ok(Link::new(
-                row.get::<_, i64>(0)? as u64,
-                row.get::<_, i64>(1)? as u64,
-                row.get::<_, i64>(2)? as u64,
-            ))
-        })
-        .expect("Failed to execute query_by_target")
-        .filter_map(|r| r.ok())
-        .collect()
+        self.conn
+            .db
+            .links()
+            .iter()
+            .filter(|l| l.target == target)
+            .map(Self::to_link)
+            .collect()
     }
 
     fn query_by_source_target(&self, source: u64, target: u64) -> Vec<Link> {
-        let mut stmt = self
-            .conn
-            .prepare("SELECT id, source, target FROM links WHERE source = ?1 AND target = ?2")
-            .expect("Failed to prepare query_by_source_target");
-
-        stmt.query_map(params![source as i64, target as i64], |row| {
-            Ok(Link::new(
-                row.get::<_, i64>(0)? as u64,
-                row.get::<_, i64>(1)? as u64,
-                row.get::<_, i64>(2)? as u64,
-            ))
-        })
-        .expect("Failed to execute query_by_source_target")
-        .filter_map(|r| r.ok())
-        .collect()
+        self.conn
+            .db
+            .links()
+            .iter()
+            .filter(|l| l.source == source && l.target == target)
+            .map(Self::to_link)
+            .collect()
     }
 
     fn count(&self) -> usize {
-        self.conn
-            .query_row("SELECT COUNT(*) FROM links", [], |row| row.get::<_, i64>(0))
-            .unwrap_or(0) as usize
+        self.conn.db.links().count() as usize
     }
 }
 
@@ -233,79 +262,80 @@ impl Links for SpacetimeDbLinks {
 mod tests {
     use super::*;
 
+    fn server_available() -> bool {
+        let uri = SPACETIMEDB_URI.as_str();
+        let addr = uri
+            .trim_start_matches("http://")
+            .trim_start_matches("https://");
+        let addr = if addr.contains(':') {
+            addr.to_string()
+        } else {
+            format!("{addr}:3000")
+        };
+        std::net::TcpStream::connect_timeout(
+            &addr
+                .parse()
+                .unwrap_or_else(|_| "127.0.0.1:3000".parse().unwrap()),
+            Duration::from_secs(1),
+        )
+        .is_ok()
+    }
+
     #[test]
-    fn test_create_and_query_memory() {
-        let mut db = SpacetimeDbLinks::new_memory();
+    fn test_create_and_query() {
+        if !server_available() {
+            eprintln!("SpacetimeDB server not available, skipping test");
+            return;
+        }
+        let mut db = SpacetimeDbLinks::connect();
+        db.delete_all();
         let id = db.create_point();
-        assert_eq!(id, 1);
-
+        assert!(id > 0);
         let link = db.query_by_id(id).unwrap();
         assert_eq!(link.source, id);
         assert_eq!(link.target, id);
     }
 
     #[test]
-    fn test_update_memory() {
-        let mut db = SpacetimeDbLinks::new_memory();
+    fn test_update() {
+        if !server_available() {
+            eprintln!("SpacetimeDB server not available, skipping test");
+            return;
+        }
+        let mut db = SpacetimeDbLinks::connect();
+        db.delete_all();
         let id = db.create(1, 2);
         db.update(id, 3, 4);
-
         let link = db.query_by_id(id).unwrap();
         assert_eq!(link.source, 3);
         assert_eq!(link.target, 4);
     }
 
     #[test]
-    fn test_delete_memory() {
-        let mut db = SpacetimeDbLinks::new_memory();
+    fn test_delete() {
+        if !server_available() {
+            eprintln!("SpacetimeDB server not available, skipping test");
+            return;
+        }
+        let mut db = SpacetimeDbLinks::connect();
+        db.delete_all();
         let id = db.create_point();
         db.delete(id);
         assert!(db.query_by_id(id).is_none());
     }
 
-    #[test]
-    fn test_query_by_source() {
-        let mut db = SpacetimeDbLinks::new_memory();
-        let id1 = db.create_point();
-        let id2 = db.create_point();
-        db.update(id1, id1, id2);
-        db.update(id2, id1, id1);
-
-        let links = db.query_by_source(id1);
-        assert_eq!(links.len(), 2);
-    }
-
-    #[test]
-    fn test_query_by_target() {
-        let mut db = SpacetimeDbLinks::new_memory();
-        let id1 = db.create_point();
-        let id2 = db.create_point();
-        db.update(id1, id2, id1);
-        db.update(id2, id2, id1);
-
-        let links = db.query_by_target(id1);
-        assert_eq!(links.len(), 2);
-    }
-
     #[test]
     fn test_delete_all() {
-        let mut db = SpacetimeDbLinks::new_memory();
-        for _ in 0..10 {
+        if !server_available() {
+            eprintln!("SpacetimeDB server not available, skipping test");
+            return;
+        }
+        let mut db = SpacetimeDbLinks::connect();
+        for _ in 0..5 {
             db.create_point();
         }
-        assert_eq!(db.count(), 10);
+        assert!(db.count() >= 5);
         db.delete_all();
         assert_eq!(db.count(), 0);
     }
-
-    #[test]
-    fn test_query_by_source_target() {
-        let mut db = SpacetimeDbLinks::new_memory();
-        let id1 = db.create(10, 20);
-        let _id2 = db.create(10, 30);
-
-        let links = db.query_by_source_target(10, 20);
-        assert_eq!(links.len(), 1);
-        assert_eq!(links[0].id, id1);
-    }
 }
diff --git a/scripts/check-file-size.mjs b/scripts/check-file-size.mjs
index 4f2aedc..6d2f638 100644
--- a/scripts/check-file-size.mjs
+++ b/scripts/check-file-size.mjs
@@ -13,7 +13,16 @@ import { join, relative, extname } from 'path';
 
 const MAX_LINES = 1000;
 const FILE_EXTENSIONS = ['.rs'];
-const EXCLUDE_PATTERNS = ['target', '.git', 'node_modules'];
+const EXCLUDE_PATTERNS = [
+  'target',
+  '.git',
+  'node_modules',
+  'doublets-patched',
+  'module_bindings',
+  // Benchmark files contain intentional repetition (one function per backend per operation)
+  // and are excluded from the line limit check.
+  'benches',
+];
 
 /**
  * Check if a path should be excluded