DevDocMD/implementation/partition_layer_cache.md

@@ -69,6 +69,79 @@ let a per-partition type hold layers of mixed `D` (today `LayeredMap<D>`
 can't, being monomorphic — see "The gap in `obilayeredmap`'s existing
 cache" below).
 
+## Major restructuring (2026-08-20): `KmerPartitions` merged into `KmerIndex`
+
+Prompted by a direct question: why keep `KmerIndex`/`KmerPartitions` split
+when, one level down, `KmerPartitions` is going to directly hold
+`Vec<KmerPartition>` rather than being split again into
+"collection-holder" + "collection"? Investigating the actual justification
+("`KmerPartitions` has an independent lifecycle, used before an index
+exists") turned out to be **false** — `KmerPartitions::create` was called
+in exactly one place, inside `KmerIndex::create`, and every
+`open_with_config` reopen outside `KmerIndex`'s own constructors was a
+redundant re-derivation of a `KmerPartitions` already reachable via
+`index.partition()` (the exact kind of duplication this whole doc has been
+tracking). Once that was gone, so was the reason to keep them separate.
+
+Second correction, from the same conversation: `obikpartitionner` had
+accumulated query/merge/select/rebuild/dump/distance logic that has
+nothing to do with partitioning super-kmers — it operates on *layers*,
+which don't exist yet at the phase `obikpartitionner` is actually
+responsible for (scatter → dereplicate → count, all pre-layer). That
+logic moved to `obikindex`, which already depends on `obilayeredmap` and
+never needed `obikpartitionner` for it. No crate-dependency inversion was
+needed — `obikindex → obikpartitionner` stays the same direction as before.
+
+**Result:**
+- `obikpartitionner` (renamed back from `obikpartition`) now contains only
+  `PartitionRouter` (superkmer routing: `write`/`write_batch`/`flush`/
+  `close`, `dereplicate`, `count_kmer`, `KmerSpectrum`) and the
+  `partition_dir(root, i)` naming primitive both `PartitionRouter` and
+  `KmerIndex` build on. `KmerPartitions` no longer exists as a type.
+- `KmerIndex` (`obikindex`) absorbed `KmerPartitions`'s read-side entirely:
+  `partition_dir`/`index_dir`/`layer_dir`/`partition_meta`/`n_layers`/
+  `partition_mode`/`n_partitions` (the last now derived from
+  `2^config.n_bits`, no longer a stored, independently-set duplicate field
+  — `kmer_size`/`minimizer_size` used to be double-stored, in both
+  `KmerPartitions` and `IndexMeta.config`, a latent-drift risk flagged
+  earlier in this doc; now single-sourced from `IndexMeta.config`). Seven
+  whole files moved from `obikpartitionner` into `obikindex` verbatim as
+  `impl KmerIndex` blocks, kept as separate files (not merged into
+  existing same-topic files): `index_layer.rs`, `query_layer.rs`,
+  `merge_layer/`, `select_layer.rs`, `rebuild_layer.rs`, `dump_layer.rs`,
+  plus `distance.rs`'s `count_store`/`presence_store` (renamed
+  `matrix_store.rs` to avoid colliding with `obikindex`'s own pre-existing
+  `distance.rs`), and their shared support (`common.rs`'s `load_meta`/
+  `olm_to_sk`, `filter.rs`, `graph_pipeline.rs`).
+- `obikphylo::siblings::cache::PartitionCache::build` now takes `&KmerIndex`
+  directly instead of a separately-opened `&KmerPartitions` — this deleted
+  the redundant-reopen pattern at all 8 call sites
+  (`alignment`/`build`/`cardinality`/`distance`/`entropy`×2/
+  `sankoff_bundle`/`stats`), the same bug flagged earlier in this
+  conversation as a side effect of investigating the false "independent
+  lifecycle" claim.
+- `KmerIndex::partition()`/`partition_mut()` are gone; `scatter()`
+  (`obikmer`) and any write-side code get a transient `PartitionRouter` via
+  `KmerIndex::partition_router()`.
+- A real bug caught by the test suite during this move:
+  `PartitionRouter::open` initially defaulted to `closed: true` (inherited
+  from `KmerPartitions::open_with_config`'s old read-only-reopen
+  semantics), which broke every write through a router obtained via
+  `partition_router()`. Fixed — `PartitionRouter` is exclusively a
+  write/processing tool now, so `open` always starts open.
+
+Full workspace test suite green (0 failed) after, including all 27
+`obikphylo::siblings` tests.
+
+Still open: (1)/(2) themselves — `AnyLayer` (or whatever it ends up named;
+`AnyLayer` was rejected as a placeholder, no replacement chosen yet) and
+`KmerPartition` (singular, one partition's open layers) are not built yet.
+`obikphylo::siblings::cache::{Mat, PartitionCache}` and
+`obikpartitionner::query_layer` (now `obikindex::query_layer`)'s
+`QueryLayer` still each independently bundle MPHF+matrix — unchanged by
+this restructuring, which was purely about *where* code lives, not about
+building the heterogeneous-layer cache itself.
+
 ## The problem
 
 Reading a layer's data (MPHF + matrix) is not free: `MphfLayer::open` mmaps

src/Cargo.lock

@@ -1595,18 +1595,26 @@ name = "obikindex"
 version = "0.1.0"
 dependencies = [
  "anyhow",
+ "cacheline-ef",
  "crossbeam-channel",
+ "epserde",
  "hwlocality",
  "indicatif",
+ "memmap2",
  "ndarray",
+ "niffler",
  "obicompactvec",
+ "obidebruinj",
+ "obikentropy",
  "obikpartitionner",
  "obikseq",
  "obilayeredmap",
+ "obipipeline",
  "obiread",
  "obiskio",
  "obisys",
  "obitaxonomy",
+ "ptr_hash",
  "rayon",
  "serde",
  "serde_json",
@@ -1653,16 +1661,11 @@ version = "0.1.0"
 dependencies = [
  "cacheline-ef",
  "epserde",
- "indicatif",
  "memmap2",
  "niffler",
  "obicompactvec",
- "obidebruinj",
- "obikentropy",
  "obikrope",
  "obikseq",
- "obilayeredmap",
- "obipipeline",
  "obiread",
  "obiskbuilder",
  "obiskio",

src/obikindex/Cargo.toml

@@ -11,6 +11,14 @@ obiskio          = { path = "../obiskio" }
 obisys           = { path = "../obisys" }
 obicompactvec    = { path = "../obicompactvec" }
 obilayeredmap    = { path = "../obilayeredmap" }
+obidebruinj      = { path = "../obidebruinj" }
+obipipeline      = { path = "../obipipeline" }
+obikentropy      = { path = "../obikentropy" }
+cacheline-ef     = "1.1"
+epserde          = "0.8"
+ptr_hash         = "1.1"
+niffler          = "3.0.0"
+memmap2          = "0.9.10"
 ndarray          = "0.17"
 rayon             = "1"
 crossbeam-channel = "0.5"

src/obikindex/examples/compare_sparse.rs

@@ -25,16 +25,16 @@ fn main() -> anyhow::Result<()> {
     let mut first_mismatch = None;
 
     for part in 0..n_parts {
-        let index_dir_sparse = sparse.partition().index_dir(part);
+        let index_dir_sparse = sparse.index_dir(part);
-        let index_dir_dense = dense.partition().index_dir(part);
+        let index_dir_dense = dense.index_dir(part);
 
         if !index_dir_sparse.exists() || !index_dir_dense.exists() {
             continue;
         }
 
         for layer in 0..n_layers {
-            let layer_dir_sparse = sparse.partition().layer_dir(part, layer);
+            let layer_dir_sparse = sparse.layer_dir(part, layer);
-            let layer_dir_dense = dense.partition().layer_dir(part, layer);
+            let layer_dir_dense = dense.layer_dir(part, layer);
 
             if !layer_dir_sparse.exists() || !layer_dir_dense.exists() {
                 continue;

src/obikindex/src/distance.rs

@@ -74,7 +74,7 @@ impl KmerIndex {
         if use_counts {
             let stores: Vec<_> = (0..n_parts)
                 .into_par_iter()
-                .map(|i| self.partition.count_store(i).map_err(OKIError::Partition))
+                .map(|i| self.count_store(i).map_err(OKIError::Partition))
                 .collect::<OKIResult<_>>()?;
             let global = LayeredStore::new(stores);
 
@@ -105,7 +105,7 @@ impl KmerIndex {
         } else {
             let stores: Vec<_> = (0..n_parts)
                 .into_par_iter()
-                .map(|i| self.partition.presence_store(i).map_err(OKIError::Partition))
+                .map(|i| self.presence_store(i).map_err(OKIError::Partition))
                 .collect::<OKIResult<_>>()?;
             let global = LayeredStore::new(stores);
 

src/obikindex/src/dump.rs

@@ -5,7 +5,7 @@ use rayon::prelude::*;
 
 use crate::error::{OKIError, OKIResult};
 use crate::index::KmerIndex;
-use obikpartitionner::KmerFilter;
+use crate::KmerFilter;
 
 impl KmerIndex {
     /// Write a CSV table of all indexed kmers to `out`.
@@ -69,14 +69,14 @@ impl KmerIndex {
                     }
                 };
                 if debug {
-                    self.partition
+                    self
                         .iter_partition_kmers_located(i, use_counts, n_genomes, filters, |part, layer, kmer, row| {
                             let seq = String::from_utf8(kmer.to_ascii()).unwrap_or_else(|_| "?".repeat(kmer_size));
                             try_write(&mut buf, &row, &format!("{part},{layer},{seq}"))
                         })
                         .map_err(OKIError::Partition)?;
                 } else {
-                    self.partition
+                    self
                         .iter_partition_kmers(i, use_counts, n_genomes, filters, |kmer, row| {
                             let seq = String::from_utf8(kmer.to_ascii()).unwrap_or_else(|_| "?".repeat(kmer_size));
                             try_write(&mut buf, &row, &seq)
@@ -91,7 +91,7 @@ impl KmerIndex {
             (0..n).into_par_iter().map(|i| {
                 let mut buf = Vec::<u8>::new();
                 if debug {
-                    self.partition
+                    self
                         .iter_partition_kmers_located(i, use_counts, n_genomes, filters, |part, layer, kmer, row| {
                             let seq = String::from_utf8(kmer.to_ascii()).unwrap_or_else(|_| "?".repeat(kmer_size));
                             write_row(&mut buf, &row, &format!("{part},{layer},{seq}"));
@@ -99,7 +99,7 @@ impl KmerIndex {
                         })
                         .map_err(OKIError::Partition)?;
                 } else {
-                    self.partition
+                    self
                         .iter_partition_kmers(i, use_counts, n_genomes, filters, |kmer, row| {
                             let seq = String::from_utf8(kmer.to_ascii()).unwrap_or_else(|_| "?".repeat(kmer_size));
                             write_row(&mut buf, &row, &seq);

src/obikindex/src/dump_layer.rs

@@ -4,7 +4,7 @@ use obilayeredmap::{IndexMode, MphfLayer, OLMError};
 use obiskio::{SKError, SKResult, UnitigFileReader};
 
 use crate::filter::{KmerFilter, passes_all};
-use crate::partition::KmerPartitions;
+use crate::index::KmerIndex;
 
 fn olm_to_sk(e: OLMError) -> SKError {
     match e {
@@ -16,7 +16,7 @@ fn olm_to_sk(e: OLMError) -> SKError {
     }
 }
 
-impl KmerPartitions {
+impl KmerIndex {
     /// Iterate all indexed kmers in partition `part`, calling `cb(kmer, row)` for each
     /// kmer that passes every filter in `filters`.
     ///
@@ -41,7 +41,7 @@ impl KmerPartitions {
             return Ok(true);
         }
 
-        let index_mode = self.index_mode(part).unwrap_or(IndexMode::Exact);
+        let index_mode = self.partition_mode(part).unwrap_or(IndexMode::Exact);
 
         let mut l = 0;
         loop {
@@ -131,7 +131,7 @@ impl KmerPartitions {
             return Ok(true);
         }
 
-        let index_mode = self.index_mode(part).unwrap_or(IndexMode::Exact);
+        let index_mode = self.partition_mode(part).unwrap_or(IndexMode::Exact);
 
         let mut layer = 0;
         loop {

src/obikindex/src/index.rs

@@ -2,13 +2,15 @@ use std::collections::BTreeMap;
 use std::fs;
 use std::path::{Path, PathBuf};
 
-use obikpartitionner::{KmerPartitions, KmerSpectrum, PARTITIONS_SUBDIR};
+use obikpartitionner::{KmerSpectrum, PartitionRouter};
+use obilayeredmap::meta::PartitionMeta;
 use obisys::{Reporter, Stage, progress_bar};
 use rayon::prelude::*;
 use tracing::info;
 
 use obikseq::{set_k, set_m};
 
+use crate::common::load_meta;
 use crate::error::{OKIError, OKIResult};
 use crate::meta::{GenomeInfo, IndexConfig, IndexMeta};
 use crate::state::{IndexState, SENTINEL_COUNTED, SENTINEL_INDEXED, SENTINEL_SCATTERED};
@@ -16,7 +18,6 @@ use crate::state::{IndexState, SENTINEL_COUNTED, SENTINEL_INDEXED, SENTINEL_SCAT
 pub struct KmerIndex {
     pub(crate) root_path: PathBuf,
     pub(crate) meta: IndexMeta,
-    pub(crate) partition: KmerPartitions,
 }
 
 impl KmerIndex {
@@ -31,13 +32,7 @@ impl KmerIndex {
         force: bool,
     ) -> OKIResult<Self> {
         let root_path = path.as_ref().to_owned();
-        let partition = KmerPartitions::create(
+        PartitionRouter::create(&root_path, config.n_bits, force)?;
-            &root_path,
-            config.n_bits,
-            config.kmer_size,
-            config.minimizer_size,
-            force,
-        )?;
         set_k(config.kmer_size);
         set_m(config.minimizer_size);
         let mut meta = IndexMeta::new(config);
@@ -45,11 +40,7 @@ impl KmerIndex {
             meta.genomes.push(info);
         }
         meta.write(&root_path)?;
-        Ok(Self {
+        Ok(Self { root_path, meta })
-            root_path,
-            meta,
-            partition,
-        })
     }
 
     pub fn open<P: AsRef<Path>>(path: P) -> OKIResult<Self> {
@@ -57,17 +48,7 @@ impl KmerIndex {
         let meta = IndexMeta::read(&root_path).map_err(OKIError::Io)?;
         set_k(meta.config.kmer_size);
         set_m(meta.config.minimizer_size);
-        let partition = KmerPartitions::open_with_config(
+        Ok(Self { root_path, meta })
-            &root_path,
-            meta.config.kmer_size,
-            meta.config.minimizer_size,
-            meta.config.n_bits,
-        )?;
-        Ok(Self {
-            root_path,
-            meta,
-            partition,
-        })
     }
 
     /// Return `true` if `path` contains an `index.meta` file.
@@ -96,25 +77,17 @@ impl KmerIndex {
     }
 
     /// Lay out a fresh index skeleton at `output`: the root directory,
-    /// `index.meta` (from `meta`), and an opened, empty partition set.
+    /// `index.meta` (from `meta`), and an empty partition layout.
     ///
     /// For construction paths that build partitions from scratch (`select`,
     /// `rebuild`). `merge` bootstraps by copying a source index instead, so
     /// it does not use this.
-    pub(crate) fn create_skeleton<P: AsRef<Path>>(
+    pub(crate) fn create_skeleton<P: AsRef<Path>>(output: P, meta: &IndexMeta) -> OKIResult<KmerIndex> {
-        output: P,
-        meta: &IndexMeta,
-    ) -> OKIResult<KmerPartitions> {
         let output = output.as_ref();
         fs::create_dir_all(output).map_err(OKIError::Io)?;
         meta.write(output).map_err(OKIError::Io)?;
-        fs::create_dir_all(output.join(PARTITIONS_SUBDIR)).map_err(OKIError::Io)?;
+        PartitionRouter::create(output, meta.config.n_bits, false)?;
-        Ok(KmerPartitions::open_with_config(
+        Ok(KmerIndex { root_path: output.to_owned(), meta: meta.clone() })
-            output,
-            meta.config.kmer_size,
-            meta.config.minimizer_size,
-            meta.config.n_bits,
-        )?)
     }
 
     /// Mark `output` as fully indexed, pack its column matrices, and reopen it.
@@ -139,9 +112,7 @@ impl KmerIndex {
         IndexState::detect(&self.root_path).unwrap_or(IndexState::Empty)
     }
 
-    /// The index's root directory — needed by out-of-crate extension code
+    /// The index's root directory.
-    /// (e.g. `obikphylo`) that opens its own `KmerPartition` handle onto
-    /// the same on-disk index.
     pub fn root_path(&self) -> &Path {
         &self.root_path
     }
@@ -185,7 +156,48 @@ impl KmerIndex {
         &self.meta.genomes
     }
     pub fn n_partitions(&self) -> usize {
-        self.partition.n_partitions()
+        1usize << self.meta.config.n_bits
+    }
+
+    /// Path of partition `i`'s raw directory (`partitions/part_{i:05}`) —
+    /// the on-disk naming convention `obikpartitionner::PartitionRouter`
+    /// also writes to (raw/dereplicated superkmer files, `mphf1.bin`,
+    /// `counts1.bin`), the single point of agreement between the two.
+    pub fn partition_dir(&self, i: usize) -> PathBuf {
+        obikpartitionner::partition_dir(&self.root_path, i)
+    }
+
+    /// Path of partition `i`'s layered-index directory (`<partition>/index`).
+    pub fn index_dir(&self, i: usize) -> PathBuf {
+        self.partition_dir(i).join("index")
+    }
+
+    /// Path of layer `l` within partition `i`'s layered index.
+    pub fn layer_dir(&self, i: usize, l: usize) -> PathBuf {
+        obilayeredmap::layer_dir(&self.index_dir(i), l)
+    }
+
+    /// Partition `i`'s metadata (layer count, evidence mode). Returns
+    /// `obiskio::SKResult`, not `OKIResult` — matches the error convention
+    /// of the partition/layer-construction code below (moved here from
+    /// `obikpartitionner`, which predates `OKIError`); `?` still converts
+    /// it to `OKIResult` at any call site that needs one (`OKIError: From<SKError>`).
+    pub fn partition_meta(&self, i: usize) -> obiskio::SKResult<PartitionMeta> {
+        load_meta(&self.index_dir(i), "partition_meta")
+    }
+
+    /// Number of layers in partition `i` — see [`partition_meta`](Self::partition_meta).
+    pub fn n_layers(&self, i: usize) -> obiskio::SKResult<usize> {
+        Ok(self.partition_meta(i)?.n_layers)
+    }
+
+    /// Evidence mode partition `i` was actually built with — see
+    /// [`partition_meta`](Self::partition_meta). Distinct from
+    /// [`evidence_mode`](Self::evidence_mode): that one is the index-level
+    /// config, this one is per-partition ground truth (the two agree in
+    /// practice, but this is what `Layer::open` needs).
+    pub fn partition_mode(&self, i: usize) -> obiskio::SKResult<obilayeredmap::IndexMode> {
+        Ok(self.partition_meta(i)?.mode)
     }
 
     /// Number of layers per partition.
@@ -194,13 +206,7 @@ impl KmerIndex {
     /// homogeneous across all partitions — reading it off partition 0
     /// is enough, no need to scan every partition.
     pub fn n_layers_per_partition(&self) -> OKIResult<usize> {
-        Ok(self.partition.n_layers(0)?)
+        Ok(self.n_layers(0)?)
-    }
-
-    /// Expose the inner partition so the caller can run scatter into it.
-    /// Call `mark_scattered` once scatter is complete.
-    pub fn partition_mut(&mut self) -> &mut KmerPartitions {
-        &mut self.partition
     }
 
     /// Mark scatter as complete and write `scatter.done`.
@@ -217,6 +223,14 @@ impl KmerIndex {
         Ok(())
     }
 
+    /// Open a fresh [`PartitionRouter`] onto this index's partition layout
+    /// — the write-side handle for `scatter`, or for `dereplicate_and_count`
+    /// below. Transient: no state is kept in `KmerIndex` itself between
+    /// calls, only on disk.
+    pub fn partition_router(&self) -> OKIResult<PartitionRouter> {
+        Ok(PartitionRouter::open(&self.root_path, self.meta.config.n_bits)?)
+    }
+
     /// Dereplicate all partitions then compute kmer counts.
     ///
     /// Writes `spectrums/{label}.json` and touches `count.done` upon completion.
@@ -226,12 +240,14 @@ impl KmerIndex {
         keep_intermediate: bool,
         rep: &mut Reporter,
     ) -> OKIResult<()> {
+        let router = self.partition_router()?;
+
         let t = Stage::start("dereplicate");
-        self.partition.dereplicate()?;
+        router.dereplicate()?;
         rep.push(t.stop());
 
         let t = Stage::start("count_kmer");
-        let spectrum = self.partition.count_kmer(keep_intermediate)?;
+        let spectrum = router.count_kmer(keep_intermediate)?;
         rep.push(t.stop());
 
         self.write_spectrum(&spectrum)?;
@@ -273,7 +289,7 @@ impl KmerIndex {
         keep_intermediate: bool,
         rep: &mut Reporter,
     ) -> OKIResult<()> {
-        let n = self.partition.n_partitions();
+        let n = self.n_partitions();
         let t = Stage::start("index");
         let with_counts = self.meta.config.with_counts;
         let evidence = self.meta.config.evidence.clone();
@@ -287,7 +303,7 @@ impl KmerIndex {
             .run(
                 &order,
                 |i| {
-                    self.partition.build_index_layer(
+                    self.build_index_layer(
                         i,
                         min_ab,
                         max_ab,
@@ -311,7 +327,7 @@ impl KmerIndex {
 
         if !keep_intermediate {
             for i in 0..n {
-                self.partition.remove_build_artifacts(i);
+                self.remove_build_artifacts(i);
             }
         }
 
@@ -320,14 +336,9 @@ impl KmerIndex {
         Ok(())
     }
 
-    /// Borrow the inner partition for direct superkmer-level queries.
-    pub fn partition(&self) -> &KmerPartitions {
-        &self.partition
-    }
-
     /// Path to the unitigs file for partition `part`, layer `layer`.
     pub fn layer_unitigs_path(&self, part: usize, layer: usize) -> PathBuf {
-        self.partition.layer_dir(part, layer).join("unitigs.bin")
+        self.layer_dir(part, layer).join("unitigs.bin")
     }
 
     /// Pack all partition matrices into single-file format (presence → .pbmx, counts → .pcmx).
@@ -349,13 +360,13 @@ impl KmerIndex {
         crate::numa::PartitionRunner::new().run(
             &order,
             |i| -> OKIResult<()> {
-                let index_dir = self.partition.index_dir(i);
+                let index_dir = self.index_dir(i);
                 if !index_dir.exists() {
                     return Ok(());
                 }
-                let n_layers = self.partition.n_layers(i)?;
+                let n_layers = self.n_layers(i)?;
                 for l in 0..n_layers {
-                    let layer_dir = self.partition.layer_dir(i, l);
+                    let layer_dir = self.layer_dir(i, l);
                     let presence_dir = layer_dir.join("presence");
                     let counts_dir = layer_dir.join("counts");
                     if presence_dir.exists() {
@@ -391,11 +402,11 @@ impl KmerIndex {
         let errors: Vec<_> = (0..n)
             .into_par_iter()
             .filter_map(|i| {
-                let index_dir = self.partition.index_dir(i);
+                let index_dir = self.index_dir(i);
                 if !index_dir.exists() {
                     return None;
                 }
-                let n_layers = match self.partition.n_layers(i) {
+                let n_layers = match self.n_layers(i) {
                     Ok(n) => n,
                     Err(e) => {
                         return Some(OKIError::Io(std::io::Error::new(
@@ -405,7 +416,7 @@ impl KmerIndex {
                     }
                 };
                 for l in 0..n_layers {
-                    let layer_dir = self.partition.layer_dir(i, l);
+                    let layer_dir = self.layer_dir(i, l);
                     let meta_path = layer_dir.join(LayerMeta::FILENAME);
                     if meta_path.exists() {
                         continue;

src/obikindex/src/index_layer.rs

@@ -12,7 +12,7 @@ use ptr_hash::{PtrHash, bucket_fn::CubicEps, hash::Xx64};
 
 use crate::common::olm_to_sk;
 use crate::graph_pipeline::{materialize_layer, write_graph_as_unitigs};
-use crate::partition::KmerPartitions;
+use crate::index::KmerIndex;
 
 type Mphf = PtrHash<u64, CubicEps, CachelineEfVec<Vec<CachelineEf>>, Xx64, Vec<u8>>;
 
@@ -24,7 +24,7 @@ fn remove_if_exists(path: &std::path::Path) {
     }
 }
 
-impl KmerPartitions {
+impl KmerIndex {
     /// Build the layered MPHF index for partition `i`.
     ///
     /// Returns the number of canonical k-mers indexed, or 0 if the partition

src/obikindex/src/lib.rs

@@ -2,22 +2,35 @@ pub mod error;
 pub mod meta;
 pub mod predicate;
 pub mod state;
+mod common;
 mod distance;
 mod dump;
+mod dump_layer;
+pub mod filter;
+mod graph_pipeline;
 mod index;
+mod index_layer;
+mod matrix_store;
 mod merge;
+mod merge_layer;
 mod numa;
+mod query_layer;
 mod rebuild;
+mod rebuild_layer;
 mod reindex;
 mod select;
+mod select_layer;
 mod stats;
 
 pub use error::{OKIError, OKIResult};
 pub use distance::{DistanceMetric, DistanceOutput};
+pub use filter::{GroupQuorumFilter, KmerFilter, passes_all};
 pub use index::KmerIndex;
-pub use merge::MergeMode;
+pub use merge_layer::MergeMode;
 pub use meta::{validate_label, GenomeInfo, IndexConfig, IndexMeta, META_FILENAME};
 pub use predicate::{GroupFilterParams, MetaPred};
+pub use query_layer::{KmerDesc, QueryHit, QueryStats};
+pub use select_layer::{AggOp, OutputCol};
 pub use state::{IndexState, SENTINEL_COUNTED, SENTINEL_INDEXED, SENTINEL_SCATTERED};
 pub use stats::IndexBitsPerKmer;
 pub use numa::PartitionRunner;

src/obikindex/src/matrix_store.rs

@@ -3,9 +3,9 @@ use obilayeredmap::{LayeredStore, open_data};
 use obiskio::SKResult;
 
 use crate::common::{load_meta, olm_to_sk};
-use crate::partition::KmerPartitions;
+use crate::index::KmerIndex;
 
-impl KmerPartitions {
+impl KmerIndex {
     /// Open all count matrices for partition `part`, one per layer.
     /// Layers without a `counts/` directory are skipped.
     pub fn count_store(&self, part: usize) -> SKResult<LayeredStore<PersistentCompactIntMatrix>> {

src/obikindex/src/merge.rs

@@ -13,7 +13,7 @@ use crate::index::KmerIndex;
 use crate::meta::{GenomeInfo, IndexMeta};
 use crate::state::{IndexState, SENTINEL_INDEXED};
 
-pub use obikpartitionner::MergeMode;
+pub use crate::merge_layer::MergeMode;
 
 // ── per-partition diagnostic record ──────────────────────────────────────────
 
@@ -189,13 +189,12 @@ impl KmerIndex {
             let t = Stage::start("merge_partitions");
             let pb = progress_bar("merge", n_partitions as u64, "partitions");
 
-            let dst_partition = &dst.partition;
             let block_bits = dst.meta.config.block_bits;
 
             // Pre-build source list once (avoid rebuilding per partition)
-            let srcs: Vec<(&obikpartitionner::KmerPartitions, usize)> = remaining_sources
+            let srcs: Vec<(&KmerIndex, usize)> = remaining_sources
                 .iter()
-                .map(|s| (&s.partition, s.meta.genomes.len()))
+                .map(|s| (*s, s.meta.genomes.len()))
                 .collect();
 
             // Per-partition unitig byte sizes across remaining sources (stat() only)
@@ -225,7 +224,7 @@ impl KmerIndex {
                 .run(
                     &order,
                     |i| {
-                        dst_partition.merge_partition(
+                        dst.merge_partition(
                             i,
                             srcs,
                             mode,
@@ -418,7 +417,7 @@ fn is_trivial(src: &KmerIndex, mode: MergeMode) -> bool {
 }
 
 fn index_unitig_size(src: &KmerIndex) -> u64 {
-    let n = src.partition.n_partitions();
+    let n = src.n_partitions();
     (0..n).map(|i| partition_unitig_bytes(src, i)).sum()
 }
 

src/obikindex/src/merge_layer/mod.rs

@@ -25,7 +25,7 @@ use obiskio::{SKError, SKResult, UnitigFileReader};
 
 use crate::common::{ColBuilder, load_meta, olm_to_sk};
 use crate::graph_pipeline::{build_graph, materialize_layer};
-use crate::partition::KmerPartitions;
+use crate::index::KmerIndex;
 
 mod src_layer;
 
@@ -198,7 +198,7 @@ mod matrix_builder_tests {
 
 // ── KmerPartition::merge_partition ────────────────────────────────────────────
 
-impl KmerPartitions {
+impl KmerIndex {
     /// Merge `sources` into destination partition `i`.
     ///
     /// Each entry in `sources` is `(partition, n_genomes)` where `n_genomes` is
@@ -211,7 +211,7 @@ impl KmerPartitions {
     pub fn merge_partition(
         &self,
         i: usize,
-        sources: &[(&KmerPartitions, usize)],
+        sources: &[(&KmerIndex, usize)],
         mode: MergeMode,
         n_dst_genomes: usize,
         block_bits: u8,

src/obikindex/src/predicate.rs

@@ -1,6 +1,6 @@
 use std::collections::HashMap;
 
-use obikpartitionner::GroupQuorumFilter;
+use crate::GroupQuorumFilter;
 use obitaxonomy::{TaxPath, TaxPattern};
 
 use crate::meta::{GenomeInfo, IndexMeta};

src/obikindex/src/query_layer.rs

@@ -6,7 +6,7 @@ use obikseq::CanonicalKmer;
 use obilayeredmap::{IndexMode, MphfLayer, OLMError};
 use obiskio::{SKError, SKResult};
 
-use crate::partition::KmerPartitions;
+use crate::index::KmerIndex;
 
 fn olm_to_sk(e: OLMError) -> SKError {
     match e {
@@ -143,7 +143,7 @@ pub enum QueryHit<'a> {
 
 // ── KmerPartition::query_partition_with ──────────────────────────────────────
 
-impl KmerPartitions {
+impl KmerIndex {
     /// Query a single partition for a pre-deduplicated map of canonical
     /// k-mers → their occurrences (`seq_idx`, `pos`) in the query batch.
     ///

src/obikindex/src/rebuild.rs

@@ -1,6 +1,6 @@
 use std::path::Path;
 
-use obikpartitionner::{KmerFilter, MergeMode};
+use crate::{KmerFilter, MergeMode};
 use obisys::{Reporter, Stage, progress_bar};
 use tracing::info;
 
@@ -46,7 +46,7 @@ impl KmerIndex {
         meta.genomes = src.meta.genomes.clone();
 
         let n_genomes = src.meta.genomes.len();
-        let n_partitions = src.partition.n_partitions();
+        let n_partitions = src.n_partitions();
 
         // ── Create an empty destination KmerPartition ─────────────────────────
         let dst_partition = KmerIndex::create_skeleton(output, &meta)?;
@@ -59,14 +59,13 @@ impl KmerIndex {
         let t = Stage::start("rebuild");
         let pb = progress_bar("rebuild", n_partitions as u64, "partitions");
 
-        let src_partition = &src.partition;
         let block_bits = meta.config.block_bits;
 
         let order: Vec<usize> = (0..n_partitions).collect();
         let runner = crate::numa::PartitionRunner::new();
         runner.run(
             &order,
-            |i| dst_partition.rebuild_partition(src_partition, i, filters, mode, n_genomes, block_bits),
+            |i| dst_partition.rebuild_partition(src, i, filters, mode, n_genomes, block_bits),
             |_, _, _| { pb.inc(1); },
         ).map_err(OKIError::Partition)?;
 

src/obikindex/src/rebuild_layer.rs

@@ -14,7 +14,7 @@ use crate::common::{load_meta, olm_to_sk};
 use crate::filter::KmerFilter;
 use crate::graph_pipeline::materialize_layer;
 use crate::merge_layer::{MergeMode, SrcLayerData};
-use crate::partition::KmerPartitions;
+use crate::index::KmerIndex;
 
 // ── Builders — pair matrix builder + column builders for one mode ─────────────
 
@@ -193,7 +193,7 @@ fn iter_src_layers(
 
 // ── KmerPartition::rebuild_partition ─────────────────────────────────────────
 
-impl KmerPartitions {
+impl KmerIndex {
     /// Rebuild partition `i` from `src` into `self` (an empty destination partition).
     ///
     /// Only k-mers whose per-genome row passes all `filters` are written.
@@ -203,7 +203,7 @@ impl KmerPartitions {
     /// `n_genomes` is the number of genome columns in the source (and destination).
     pub fn rebuild_partition(
         &self,
-        src: &KmerPartitions,
+        src: &KmerIndex,
         i: usize,
         filters: &[Box<dyn KmerFilter>],
         mode: MergeMode,

src/obikindex/src/reindex.rs

@@ -1,4 +1,3 @@
-use obikpartitionner::KmerPartitions;
 use obilayeredmap::{IndexMode, layer::Layer};
 use obisys::{Reporter, Stage, progress_bar};
 use std::fs;
@@ -35,7 +34,7 @@ impl KmerIndex {
             return Err(OKIError::NotIndexed(self.root_path.clone()));
         }
 
-        let n = self.partition.n_partitions();
+        let n = self.n_partitions();
         info!(
             "reindex {} partition(s): {:?} → {:?}",
             n, self.meta.config.evidence, target,
@@ -49,7 +48,7 @@ impl KmerIndex {
         runner.run(
             &order,
             |i| {
-                reindex_partition(&self.partition, i, &target, block_bits)
+                reindex_partition(self, i, &target, block_bits)
                     .map_err(|e| OKIError::InvalidInput(format!("partition {i}: {e}")))
             },
             |_, _, _| {
@@ -71,19 +70,19 @@ impl KmerIndex {
 
 /// Process all layers of one partition's index directory.
 fn reindex_partition(
-    partition: &KmerPartitions,
+    index: &KmerIndex,
     i: usize,
     target: &IndexMode,
     block_bits: u8,
 ) -> OKIResult<()> {
-    if !partition.index_dir(i).exists() {
+    if !index.index_dir(i).exists() {
         return Ok(());
     }
-    let n_layers = partition
+    let n_layers = index
         .n_layers(i)
         .map_err(|e| OKIError::InvalidInput(e.to_string()))?;
     for layer_idx in 0..n_layers {
-        reindex_layer(&partition.layer_dir(i, layer_idx), target, block_bits)?;
+        reindex_layer(&index.layer_dir(i, layer_idx), target, block_bits)?;
     }
     Ok(())
 }

src/obikindex/src/select.rs

@@ -1,6 +1,6 @@
 use std::path::Path;
 
-use obikpartitionner::{KmerPartitions, OutputCol};
+use crate::OutputCol;
 use obisys::{Reporter, Stage, progress_bar};
 use tracing::info;
 
@@ -41,7 +41,7 @@ impl KmerIndex {
             .collect();
 
         let n_src_genomes = src.meta.genomes.len();
-        let n_partitions = src.partition.n_partitions();
+        let n_partitions = src.n_partitions();
 
         let dst_partition = KmerIndex::create_skeleton(output, &meta)?;
 
@@ -54,7 +54,6 @@ impl KmerIndex {
 
         let t = Stage::start("select");
         let pb = progress_bar("select", n_partitions as u64, "partitions");
-        let src_partition = &src.partition;
 
         let order: Vec<usize> = (0..n_partitions).collect();
         let runner = crate::numa::PartitionRunner::new();
@@ -63,7 +62,7 @@ impl KmerIndex {
                 &order,
                 |i| {
                     dst_partition.select_partition(
-                        src_partition,
+                        src,
                         i,
                         specs,
                         n_src_genomes,
@@ -99,14 +98,7 @@ impl KmerIndex {
         }
 
         let n_src_genomes = self.meta.genomes.len();
-        let n_partitions = self.partition.n_partitions();
+        let n_partitions = self.n_partitions();
-
-        let src_partition = KmerPartitions::open_with_config(
-            &self.root_path,
-            self.meta.config.kmer_size,
-            self.meta.config.minimizer_size,
-            self.meta.config.n_bits,
-        )?;
 
         info!(
             "select (in-place): {} partition(s), {} source genome(s) → {} output column(s)",
@@ -118,15 +110,14 @@ impl KmerIndex {
         let t = Stage::start("select");
         let pb = progress_bar("select", n_partitions as u64, "partitions");
 
-        let partition = &self.partition;
         let order: Vec<usize> = (0..n_partitions).collect();
         let runner = crate::numa::PartitionRunner::new();
         runner
             .run(
                 &order,
                 |i| {
-                    partition.select_partition(
+                    self.select_partition(
-                        &src_partition,
+                        self,
                         i,
                         specs,
                         n_src_genomes,

src/obikindex/src/select_layer.rs

@@ -9,7 +9,7 @@ use obicompactvec::{
 use obilayeredmap::OLMError;
 use obiskio::{SKError, SKResult};
 
-use crate::partition::KmerPartitions;
+use crate::index::KmerIndex;
 
 // ── AggOp ─────────────────────────────────────────────────────────────────────
 
@@ -170,7 +170,7 @@ fn fill_builders(
 
 // ── KmerPartition::select_partition ──────────────────────────────────────────
 
-impl KmerPartitions {
+impl KmerIndex {
     /// Rewrite the data matrices of partition `i` in `src` into `self`.
     ///
     /// `specs` defines the output columns (projection/aggregation).
@@ -178,7 +178,7 @@ impl KmerPartitions {
     /// `in_place` — `self` and `src` share the same root; write to temp dirs then swap.
     pub fn select_partition(
         &self,
-        src: &KmerPartitions,
+        src: &KmerIndex,
         i: usize,
         specs: &[OutputCol],
         _n_src_genomes: usize,

src/obikindex/src/stats.rs

@@ -89,13 +89,13 @@ impl KmerIndex {
         let (n_kmers, mphf_b, evidence_b, matrix_b) = (0..n)
             .into_par_iter()
             .map(|i| {
-                let index_dir = self.partition.index_dir(i);
+                let index_dir = self.index_dir(i);
                 if !index_dir.exists() { return (0usize, 0u64, 0u64, 0u64); }
 
-                let n_layers = self.partition.n_layers(i).unwrap_or(0);
+                let n_layers = self.n_layers(i).unwrap_or(0);
 
                 (0..n_layers).fold((0usize, 0u64, 0u64, 0u64), |acc, l| {
-                    let lb = layer_bytes(&self.partition.layer_dir(i, l));
+                    let lb = layer_bytes(&self.layer_dir(i, l));
                     (acc.0 + lb.n_kmers, acc.1 + lb.mphf, acc.2 + lb.evidence, acc.3 + lb.matrix)
                 })
             })
@@ -138,13 +138,13 @@ impl KmerIndex {
                 let mut counts  = vec![0u64; n_genomes];
                 let mut n_kmers = 0usize;
 
-                let index_dir = self.partition.index_dir(i);
+                let index_dir = self.index_dir(i);
                 if !index_dir.exists() { return (0, counts); }
 
-                let n_layers = self.partition.n_layers(i).unwrap_or(0);
+                let n_layers = self.n_layers(i).unwrap_or(0);
 
                 for l in 0..n_layers {
-                    let this_layer_dir = self.partition.layer_dir(i, l);
+                    let this_layer_dir = self.layer_dir(i, l);
                     if !this_layer_dir.exists() { continue; }
 
                     n_kmers += LayerMeta::load(&this_layer_dir).map(|m| m.n).unwrap_or(0);

src/obikindex/src/tests/query_layer.rs

@@ -1,4 +1,5 @@
 use super::*;
+use crate::meta::IndexConfig;
 
 // ── QueryStats::AddAssign ───────────────────────────────────────────────────
 
@@ -44,8 +45,15 @@ fn query_stats_default_is_zero() {
 #[test]
 fn query_partition_with_missing_index_dir_returns_default_stats() {
     let tmp = tempfile::tempdir().expect("tempdir");
-    let partition =
+    let config = IndexConfig {
-        KmerPartitions::create(tmp.path().join("idx"), 2, 21, 9, false).expect("create partition");
+        kmer_size: 21,
+        minimizer_size: 9,
+        n_bits: 2,
+        with_counts: false,
+        evidence: obilayeredmap::IndexMode::Exact,
+        block_bits: 0,
+    };
+    let index = KmerIndex::create(tmp.path().join("idx"), config, None, false).expect("create index");
 
     let mut kmers: HashMap<CanonicalKmer, Vec<KmerDesc>> = HashMap::new();
     // Any well-formed canonical k-mer works here — the call must return
@@ -53,7 +61,7 @@ fn query_partition_with_missing_index_dir_returns_default_stats() {
     let kmer = CanonicalKmer::from_raw_unchecked(0u64);
     kmers.insert(kmer, vec![KmerDesc { seq_idx: 0, pos: 0 }]);
 
-    let stats = partition
+    let stats = index
         .query_partition_with(0, &kmers, 1, false, |_event| {
             panic!("on_event must not be called: no index was built");
         })
@@ -65,11 +73,18 @@ fn query_partition_with_missing_index_dir_returns_default_stats() {
 #[test]
 fn query_partition_with_empty_kmers_is_a_noop() {
     let tmp = tempfile::tempdir().expect("tempdir");
-    let partition =
+    let config = IndexConfig {
-        KmerPartitions::create(tmp.path().join("idx"), 2, 21, 9, false).expect("create partition");
+        kmer_size: 21,
+        minimizer_size: 9,
+        n_bits: 2,
+        with_counts: false,
+        evidence: obilayeredmap::IndexMode::Exact,
+        block_bits: 0,
+    };
+    let index = KmerIndex::create(tmp.path().join("idx"), config, None, false).expect("create index");
 
     let kmers: HashMap<CanonicalKmer, Vec<KmerDesc>> = HashMap::new();
-    let stats = partition
+    let stats = index
         .query_partition_with(0, &kmers, 1, false, |_event| {
             panic!("on_event must not be called on an empty kmer map");
         })

src/obikmer/src/cmd/filter/mod.rs

@@ -2,7 +2,7 @@ use std::path::PathBuf;
 
 use clap::Args;
 use obikindex::{KmerIndex, MergeMode};
-use obikpartitionner::filter::{MaxTotalCount, MinComplexity, MinTotalCount};
+use obikindex::filter::{MaxTotalCount, MinComplexity, MinTotalCount};
 use obisys::Reporter;
 use tracing::info;
 

src/obikmer/src/cmd/index/mod.rs

@@ -240,7 +240,11 @@ pub fn run(args: IndexArgs) {
         let n_workers = args.common.threads.max(1);
 
         let max_open = args.common.effective_max_open();
-        scatter(idx.partition_mut(), args.common.seqfile_paths(), k, level_max, theta, n_workers, max_open, &mut rep);
+        let mut router = idx.partition_router().unwrap_or_else(|e| {
+            eprintln!("error opening partition router: {e}");
+            std::process::exit(1);
+        });
+        scatter(&mut router, args.common.seqfile_paths(), k, level_max, theta, n_workers, max_open, &mut rep);
 
         idx.mark_scattered().unwrap_or_else(|e| {
             eprintln!("error marking scatter done: {e}");

src/obikmer/src/cmd/predicate.rs

@@ -1,6 +1,6 @@
 use clap::Args;
 use obikindex::{GroupFilterParams, IndexMeta, MetaPred};
-use obikpartitionner::KmerFilter;
+use obikindex::KmerFilter;
 
 /// CLI args for ingroup/outgroup filtering — embeddable in any command via `#[command(flatten)]`.
 #[derive(Args)]

src/obikmer/src/cmd/query/batch.rs

@@ -1,6 +1,6 @@
 use std::collections::HashMap;
 
-use obikpartitionner::KmerDesc;
+use obikindex::KmerDesc;
 use obikseq::CanonicalKmer;
 use obiread::record::SeqRecord;
 use obiskbuilder::SuperKmerIter;

src/obikmer/src/cmd/query/chunk.rs

@@ -1,7 +1,7 @@
 use std::time::Instant;
 
 use obikindex::KmerIndex;
-use obikpartitionner::{KmerDesc, QueryHit, QueryStats};
+use obikindex::{KmerDesc, QueryHit, QueryStats};
 use obikrope::Rope;
 use obikseq::CanonicalKmer;
 use obiread::record::parse_chunk;
@@ -110,7 +110,7 @@ pub(super) fn process_chunk(
             continue;
         }
 
-        let stats = idx.partition()
+        let stats = idx
             .query_partition_with(
                 part_idx,
                 kmers,

src/obikmer/src/cmd/select/mod.rs

@@ -3,7 +3,7 @@ use std::path::PathBuf;
 
 use clap::{Args, ValueEnum};
 use obikindex::{IndexMeta, KmerIndex};
-use obikpartitionner::{AggOp, OutputCol};
+use obikindex::{AggOp, OutputCol};
 use obisys::Reporter;
 use tracing::info;
 

src/obikmer/src/cmd/unitig/mod.rs

@@ -36,7 +36,6 @@ pub fn run(args: UnitigArgs) {
     info!("unitig: building de Bruijn graph from {n} partition(s) (k={k})");
 
     let filters = args.filter.build_filters(idx.meta());
-    let partition = idx.partition();
     let mut rep = Reporter::new();
 
     // ── Phase 1 : collect filtered kmers in parallel ──────────────────────────
@@ -45,7 +44,7 @@ pub fn run(args: UnitigArgs) {
     let g = (0..n)
         .into_par_iter()
         .fold(GraphDeBruijn::new, |mut local_g, i| {
-            partition
+            idx
                 .iter_partition_kmers(i, use_counts, n_genomes, &filters, |kmer, _row| {
                     local_g.push(kmer);
                     true

src/obikmer/src/steps/scatter.rs

@@ -3,7 +3,7 @@ use std::sync::Arc;
 use std::sync::atomic::{AtomicU32, AtomicU64, Ordering};
 use std::time::Instant;
 
-use obikpartitionner::KmerPartitions;
+use obikpartitionner::PartitionRouter;
 use obipipeline::{ThrottleGuard, Throttled, throttle};
 use obiread::NucPage;
 use obisys::spinner;
@@ -38,7 +38,7 @@ impl Drop for GuardedIter {
 /// Run scatter: normalise → build superkmers → route to partition → close.
 /// Reports the "scatter" stage to `rep`.
 pub fn scatter(
-    kp: &mut KmerPartitions,
+    kp: &mut PartitionRouter,
     path_source: impl Iterator<Item = PathBuf> + Send + 'static,
     k: usize,
     level_max: usize,

src/obikpartitionner/Cargo.toml

@@ -13,11 +13,8 @@ obikrope  = { path = "../obikrope" }
 niffler = "3.0.0"
 remove_dir_all = "1.0"
 obikseq      = { path = "../obikseq" }
-obikentropy  = { path = "../obikentropy" }
 obiskbuilder = { path = "../obiskbuilder" }
 obiskio      = { path = "../obiskio" }
-obidebruinj  = { path = "../obidebruinj" }
-obilayeredmap = { path = "../obilayeredmap" }
 rayon = "1"
 sysinfo = "0.39"
 serde = { version = "1", features = ["derive"] }
@@ -28,6 +25,4 @@ epserde = "0.8"
 memmap2 = "0.9.10"
 obicompactvec = { path = "../obicompactvec" }
 ptr_hash = "1.1"
-indicatif = "0.18"
 obisys      = { path = "../obisys" }
-obipipeline = { path = "../obipipeline" }

src/obikpartitionner/src/lib.rs

@@ -1,18 +1,4 @@
-mod common;
-mod distance;
-mod dump_layer;
-pub mod filter;
-mod graph_pipeline;
-mod index_layer;
 mod kmer_sort;
-mod merge_layer;
 mod partition;
-mod query_layer;
-mod rebuild_layer;
-mod select_layer;
 
-pub use filter::{GroupQuorumFilter, KmerFilter, passes_all};
+pub use partition::{partition_dir, KmerSpectrum, PartitionRouter, PARTITIONS_SUBDIR};
-pub use merge_layer::MergeMode;
-pub use partition::{KmerPartitions, KmerSpectrum, PARTITIONS_SUBDIR};
-pub use query_layer::{KmerDesc, QueryHit, QueryStats};
-pub use select_layer::{AggOp, OutputCol};

src/obikpartitionner/src/partition/mod.rs

@@ -1,19 +1,19 @@
 //! K-mer partitioning: routing super-kmers into per-partition files,
 //! deduplicating them, and counting unique canonical k-mers.
 //!
-//! Submodules: [`kmer_partition`] (`KmerPartition`, `KmerSpectrum` and the
+//! Submodules: [`router`] (`PartitionRouter`, `KmerSpectrum`, the
-//! routing/lifecycle API), [`dereplicate`] (two-phase split+merge
+//! `partition_dir` naming convention, and the routing/lifecycle API),
-//! deduplication), [`count`] (unique-kmer enumeration, MPHF, abundance
+//! [`dereplicate`] (two-phase split+merge deduplication), [`count`]
-//! counting).
+//! (unique-kmer enumeration, MPHF, abundance counting).
 
 mod count;
 mod dereplicate;
-mod kmer_partition;
+mod router;
 
 #[cfg(test)]
 mod tests;
 
-pub use kmer_partition::{KmerPartitions, KmerSpectrum};
+pub use router::{partition_dir, KmerSpectrum, PartitionRouter};
 
 const SK_EXT: &str = "skmer.zst";
 pub const PARTITIONS_SUBDIR: &str = "partitions";

src/obikpartitionner/src/partition/router.rs

@@ -7,8 +7,6 @@ use std::time::Instant;
 use obisys::progress_bar;
 
 use obikseq::RoutableSuperKmer;
-use obilayeredmap::IndexMode;
-use obilayeredmap::meta::PartitionMeta;
 use obiskio::SKResult;
 use rayon::prelude::*;
 use remove_dir_all::remove_dir_all;
@@ -18,19 +16,22 @@ use niffler::Level;
 use niffler::send::compression::Format;
 use obiskio::SKFileWriter;
 
-use crate::common::load_meta;
 use crate::kmer_sort::chunk_size_from_ram;
 
 use super::count::count_partition;
 use super::dereplicate::{dereplicate_partition, optimal_buckets};
 use super::{PARTITIONS_SUBDIR, SK_EXT};
 
-/// Name of a partition's layered-index subdirectory — the single source of
+/// Path of partition `i`'s directory under `root` — the single source of
-/// truth `index_dir`/`layer_dir` build on, replacing what used to be a
+/// truth for the `part_{i:05}` on-disk naming convention. Shared by
-/// `const INDEX_SUBDIR: &str = "index";` (or a bare `"index"` literal)
+/// `PartitionRouter` (which writes here) and, one crate up, `KmerIndex`
-/// redefined independently in every module that needed a partition's index
+/// (which builds `index_dir`/`layer_dir` on top of this same root, once
-/// path.
+/// `PartitionRouter` has finished writing) — the only piece of
-const INDEX_SUBDIR: &str = "index";
+/// partition-directory knowledge that genuinely needs to cross the
+/// crate boundary, since both sides must agree on where a partition lives.
+pub fn partition_dir(root: &Path, i: usize) -> PathBuf {
+    root.join(PARTITIONS_SUBDIR).join(format!("part_{i:05}"))
+}
 
 pub struct KmerSpectrum {
     pub f0: u64,
@@ -38,78 +39,51 @@ pub struct KmerSpectrum {
     pub counts: BTreeMap<u32, u64>,
 }
 
-pub struct KmerPartitions {
+/// Routes raw super-kmers into per-partition files, then dereplicates and
+/// counts them — this crate's entire job now that layer/query/merge/select/
+/// rebuild/dump/distance concerns have moved to `obikindex` (they operate on
+/// built layers, which don't exist yet at this stage — see
+/// `DevDocMD/implementation/partition_layer_cache.md`). Transient: it makes
+/// sense only while raw partition files are being written or processed, a
+/// phase that always precedes any `Layer`.
+pub struct PartitionRouter {
     root_path: PathBuf,
     n_partitions: usize,
     partitions_mask: u64,
-    kmer_size: usize,
-    minimizer_size: usize,
     writers: Vec<Option<SKFileWriter>>,
     level: Level,
     closed: bool,
 }
 
-impl KmerPartitions {
+impl PartitionRouter {
-    pub fn create<P: AsRef<Path>>(
+    /// Create a fresh partition layout at `root_path` for `n_partitions =
-        path: P,
+    /// 2^n_bits` partitions.
-        n_bits: usize,
+    pub fn create(root_path: &Path, n_bits: usize, force: bool) -> SKResult<Self> {
-        kmer_size: usize,
-        minimizer_size: usize,
-        force: bool,
-    ) -> SKResult<Self> {
-        Self::create_with(path, n_bits, kmer_size, minimizer_size, Level::One, force)
-    }
-
-    pub fn create_with<P: AsRef<Path>>(
-        path: P,
-        n_bits: usize,
-        kmer_size: usize,
-        minimizer_size: usize,
-        level: Level,
-        force: bool,
-    ) -> SKResult<Self> {
-        let root_path = path.as_ref().to_owned();
         // `root_path` itself may already exist as a bare directory: callers
         // typically hold an index-level lock file there before creating the
         // partition layout. What actually signals a pre-existing partition
         // set is the `PARTITIONS_SUBDIR` subdirectory, not the root itself.
         if root_path.join(PARTITIONS_SUBDIR).exists() {
             if force {
-                remove_dir_all(&root_path)?;
+                remove_dir_all(root_path)?;
             } else {
                 return Err(io::Error::new(
                     io::ErrorKind::AlreadyExists,
-                    format!(
+                    format!("{}: partition directory already exists", root_path.display()),
-                        "{}: partition directory already exists",
-                        root_path.display()
-                    ),
                 )
                 .into());
             }
         }
         fs::create_dir_all(root_path.join(PARTITIONS_SUBDIR))?;
-        let n_partitions = 1usize << n_bits;
+        Self::new(root_path, n_bits)
-        let writers = (0..n_partitions).map(|_| None).collect();
-        let partition = Self {
-            root_path,
-            n_partitions,
-            partitions_mask: (1u64 << n_bits) - 1,
-            kmer_size,
-            minimizer_size,
-            writers,
-            level,
-            closed: false,
-        };
-        Ok(partition)
     }
 
-    pub fn open_with_config<P: AsRef<Path>>(
+    /// Reopen the partition layout at `root_path` for further routing (or
-        path: P,
+    /// for `dereplicate`/`count_kmer`, which don't need `writers` but reuse
-        kmer_size: usize,
+    /// this same handle for consistency). Every caller of `open` wants to
-        minimizer_size: usize,
+    /// write or process, never just read paths (those live on `KmerIndex`
-        n_bits: usize,
+    /// directly), so this always starts open too.
-    ) -> SKResult<Self> {
+    pub fn open(root_path: &Path, n_bits: usize) -> SKResult<Self> {
-        let root_path = path.as_ref().to_owned();
         if !root_path.exists() {
             return Err(io::Error::new(
                 io::ErrorKind::NotFound,
@@ -117,17 +91,19 @@ impl KmerPartitions {
             )
             .into());
         }
+        Self::new(root_path, n_bits)
+    }
+
+    fn new(root_path: &Path, n_bits: usize) -> SKResult<Self> {
         let n_partitions = 1usize << n_bits;
         let writers = (0..n_partitions).map(|_| None).collect();
         Ok(Self {
-            root_path,
+            root_path: root_path.to_owned(),
             n_partitions,
             partitions_mask: (1u64 << n_bits) - 1,
-            kmer_size,
-            minimizer_size,
             writers,
             level: Level::One,
-            closed: true,
+            closed: false,
         })
     }
 
@@ -173,61 +149,6 @@ impl KmerPartitions {
         !self.closed
     }
 
-    pub fn path(&self) -> &Path {
-        &self.root_path
-    }
-
-    /// Path of partition `i` directory.
-    pub fn partition_dir(&self, i: usize) -> PathBuf {
-        self.root_path
-            .join(PARTITIONS_SUBDIR)
-            .join(format!("part_{i:05}"))
-    }
-
-    /// Path of partition `i`'s layered-index directory (`<partition>/index`).
-    pub fn index_dir(&self, i: usize) -> PathBuf {
-        self.partition_dir(i).join(INDEX_SUBDIR)
-    }
-
-    /// Path of layer `l` within partition `i`'s layered index — composes
-    /// [`index_dir`](Self::index_dir) with `obilayeredmap`'s own
-    /// `layer_N` naming convention rather than reimplementing it.
-    pub fn layer_dir(&self, i: usize, l: usize) -> PathBuf {
-        obilayeredmap::layer_dir(&self.index_dir(i), l)
-    }
-
-    /// Partition `i`'s metadata (layer count, evidence mode) — the single
-    /// entry point for this, so that callers outside `obikpartitionner`
-    /// never need to know it's a `meta.json` loaded via
-    /// `obilayeredmap::meta::PartitionMeta`, nor handle its own recovery
-    /// path for indexes built before that file existed (see
-    /// [`crate::common::load_meta`]).
-    pub fn partition_meta(&self, i: usize) -> SKResult<PartitionMeta> {
-        load_meta(&self.index_dir(i), "partition_meta")
-    }
-
-    /// Number of layers in partition `i` — see [`partition_meta`](Self::partition_meta).
-    pub fn n_layers(&self, i: usize) -> SKResult<usize> {
-        self.partition_meta(i).map(|m| m.n_layers)
-    }
-
-    /// Evidence mode of partition `i` — see [`partition_meta`](Self::partition_meta).
-    pub fn index_mode(&self, i: usize) -> SKResult<IndexMode> {
-        self.partition_meta(i).map(|m| m.mode)
-    }
-
-    pub fn kmer_size(&self) -> usize {
-        self.kmer_size
-    }
-
-    pub fn minimizer_size(&self) -> usize {
-        self.minimizer_size
-    }
-
-    pub fn n_partitions(&self) -> usize {
-        self.n_partitions
-    }
-
     /// Deduplicate all `raw.{ext}` files in parallel, replacing each with a
     /// `dereplicated.{ext}` file where identical canonical sequences are merged
     /// and their counts summed.
@@ -243,10 +164,6 @@ impl KmerPartitions {
     ///
     /// If a merged count exceeds the 24-bit header limit, the sequence is
     /// emitted as multiple records whose counts sum to the true total.
-    ///
-    /// `temp_bits` controls the split fan-out (`2^temp_bits` temp files per
-    /// partition).  Higher values reduce per-temp-file memory at the cost of
-    /// more temporary file descriptors — all managed by the global fd pool.
     pub fn dereplicate(&self) -> SKResult<()> {
         let level = self.level;
         let sys = System::new_all();
@@ -264,7 +181,7 @@ impl KmerPartitions {
         let results: Vec<SKResult<()>> = (0..self.n_partitions)
             .into_par_iter()
             .map(|i| {
-                let dir = self.partition_dir(i);
+                let dir = partition_dir(&self.root_path, i);
                 if !dir.exists() {
                     pb.inc(1);
                     return Ok(());
@@ -295,9 +212,6 @@ impl KmerPartitions {
     ///
     /// Returns the aggregated `KmerSpectrum`. Per-partition spectrum files are
     /// deleted after aggregation unless `keep_partial` is true.
-    ///
-    /// Partitions are processed in parallel via Rayon (one task per thread).
-    /// Peak memory per partition is ~80 MB, so n_threads partitions run simultaneously.
     pub fn count_kmer(&self, keep_partial: bool) -> SKResult<KmerSpectrum> {
         let sys = System::new_all();
         let available = match sys.available_memory() {
@@ -312,7 +226,7 @@ impl KmerPartitions {
         let results: Vec<SKResult<()>> = (0..self.n_partitions)
             .into_par_iter()
             .map(|i| {
-                let dir = self.partition_dir(i);
+                let dir = partition_dir(&self.root_path, i);
                 let dedup_path = dir.join(format!("dereplicated.{SK_EXT}"));
                 if !dedup_path.exists() {
                     pb.inc(1);
@@ -337,7 +251,7 @@ impl KmerPartitions {
         let mut f1: u64 = 0;
 
         for i in 0..self.n_partitions {
-            let path = self.partition_dir(i).join("kmer_spectrum_raw.json");
+            let path = partition_dir(&self.root_path, i).join("kmer_spectrum_raw.json");
             if !path.exists() {
                 continue;
             }
@@ -364,7 +278,7 @@ impl KmerPartitions {
 
     fn check_not_closed(&self) -> SKResult<()> {
         if self.closed {
-            Err(io::Error::new(io::ErrorKind::BrokenPipe, "write to closed KmerPartition").into())
+            Err(io::Error::new(io::ErrorKind::BrokenPipe, "write to closed PartitionRouter").into())
         } else {
             Ok(())
         }
@@ -372,7 +286,7 @@ impl KmerPartitions {
 
     fn ensure_writer(&mut self, partition: usize) -> SKResult<&mut SKFileWriter> {
         if self.writers[partition].is_none() {
-            let dir = self.partition_dir(partition);
+            let dir = partition_dir(&self.root_path, partition);
             fs::create_dir_all(&dir)?;
             let file_path = dir.join(format!("raw.{SK_EXT}"));
             let writer = SKFileWriter::create_with(file_path, Format::Zstd, self.level)?;
@@ -382,7 +296,7 @@ impl KmerPartitions {
     }
 }
 
-impl Drop for KmerPartitions {
+impl Drop for PartitionRouter {
     fn drop(&mut self) {
         let _ = self.close();
     }

src/obikpartitionner/src/partition/tests.rs

@@ -6,7 +6,7 @@ use obikseq::SuperKmer;
 use obiskbuilder::build_superkmers;
 
 use super::count::count_partition;
-use super::{KmerPartitions, PARTITIONS_SUBDIR};
+use super::{PartitionRouter, PARTITIONS_SUBDIR};
 
 const K: usize = 11;
 const M: usize = 5;
@@ -46,7 +46,7 @@ fn pipeline_counts(seqs: &[&[u8]]) -> (u64, u64) {
     let superkmers: Vec<_> = build_superkmers(rope, K, 1, 0.0);
 
     let dir = tempfile::tempdir().unwrap();
-    let mut kp = KmerPartitions::create(dir.path(), 0, K, M, true).unwrap();
+    let mut kp = PartitionRouter::create(dir.path(), 0, true).unwrap();
     kp.write_batch(superkmers).unwrap();
     kp.close().unwrap();
     kp.dereplicate().unwrap();

src/obikphylo/src/siblings/alignment.rs

@@ -1,10 +1,9 @@
 use std::sync::Arc;
 
-use obikpartitionner::KmerPartitions;
 use obisys::progress_bar;
 
 use obikindex::KmerIndex;
-use obikindex::{OKIError, OKIResult};
+use obikindex::OKIResult;
 
 use super::cache::PartitionCache;
 use super::family_scan::{Selection, scan_layer_families};
@@ -87,16 +86,7 @@ impl SnpAlignmentExt for KmerIndex {
         let n_genomes = self.meta().genomes.len();
         let with_counts = self.meta().config.with_counts;
         let k = self.kmer_size();
-        let n_bits = n_parts.trailing_zeros() as usize;
+        let cache = Arc::new(PartitionCache::build(self, n_parts, with_counts)?);
-
-        let partition = KmerPartitions::open_with_config(
-            self.root_path(),
-            self.kmer_size(),
-            self.minimizer_size(),
-            n_bits,
-        )
-        .map_err(OKIError::Partition)?;
-        let cache = Arc::new(PartitionCache::build(&partition, n_parts, with_counts)?);
         let layer_dirs = super::family_scan::sibling_layer_dirs(self)?;
         let selections =
             super::subsample::compute_selections(self, &layer_dirs, subsample, entropy_bias)?;

src/obikphylo/src/siblings/build.rs

@@ -4,7 +4,6 @@ use std::sync::atomic::Ordering;
 
 use rayon::prelude::*;
 
-use obikpartitionner::KmerPartitions;
 use obikseq::CanonicalKmer;
 use obilayeredmap::MphfLayer;
 use obilayeredmap::meta::IndexMode;
@@ -12,7 +11,7 @@ use obipipeline::ThrottleGuard;
 use obisys::progress_bar;
 
 use obikindex::KmerIndex;
-use obikindex::{OKIError, OKIResult};
+use obikindex::OKIResult;
 
 use super::cache::PartitionCache;
 use super::helpers::{central_base, is_minorant};
@@ -76,19 +75,10 @@ pub trait SiblingAnnexBuildExt {
 impl SiblingAnnexBuildExt for KmerIndex {
     fn build_sibling_annex(&self) -> OKIResult<()> {
         let n_parts = self.n_partitions();
-        let n_bits = n_parts.trailing_zeros() as usize;
-
-        let partition = KmerPartitions::open_with_config(
-            self.root_path(),
-            self.kmer_size(),
-            self.minimizer_size(),
-            n_bits,
-        )
-        .map_err(OKIError::Partition)?;
 
         tracing::info!("opening {n_parts} partition(s) for the sibling-annex sweep");
         let cache = Arc::new(PartitionCache::build(
-            &partition,
+            self,
             n_parts,
             self.meta().config.with_counts,
         )?);
@@ -96,18 +86,18 @@ impl SiblingAnnexBuildExt for KmerIndex {
         let pb = progress_bar("sibling_annex", n_parts as u64, "partitions");
         let mut total_slots: u64 = 0;
         for part in 0..n_parts {
-            let index_dir = self.partition().index_dir(part);
+            let index_dir = self.index_dir(part);
             if !index_dir.exists() {
                 pb.inc(1);
                 continue;
             }
-            let meta = self.partition().partition_meta(part)?;
+            let meta = self.partition_meta(part)?;
 
             let mut part_slots: u64 = 0;
             for l in 0..meta.n_layers {
                 part_slots += build_layer_sibling_annex(
                     self,
-                    &self.partition().layer_dir(part, l),
+                    &self.layer_dir(part, l),
                     &meta.mode,
                     n_parts,
                     l,

src/obikphylo/src/siblings/cache.rs

@@ -3,13 +3,12 @@ use rayon::prelude::*;
 use std::path::Path;
 
 use obicompactvec::{PersistentBitMatrix, PersistentCompactIntMatrix};
-use obikpartitionner::KmerPartitions;
 use obikseq::CanonicalKmer;
 use obilayeredmap::meta::IndexMode;
 use obilayeredmap::{Layer, OLMResult};
 use obisys::progress_bar;
 
-use obikindex::OKIResult;
+use obikindex::{KmerIndex, OKIResult};
 
 use super::SiblingAnnex;
 use super::iter::SiblingLayerExt;
@@ -159,7 +158,7 @@ pub(super) struct PartitionCache {
 
 impl PartitionCache {
     pub(super) fn build(
-        partition: &KmerPartitions,
+        index: &KmerIndex,
         n_parts: usize,
         with_counts: bool,
     ) -> OKIResult<Self> {
@@ -167,15 +166,15 @@ impl PartitionCache {
         let built: Vec<(Vec<Mat>, usize)> = (0..n_parts)
             .into_par_iter()
             .map(|part| -> OKIResult<(Vec<Mat>, usize)> {
-                let index_dir = partition.index_dir(part);
+                let index_dir = index.index_dir(part);
                 if !index_dir.exists() {
                     pb.inc(1);
                     return Ok((Vec::new(), 0));
                 }
-                let meta = partition.partition_meta(part)?;
+                let meta = index.partition_meta(part)?;
                 let mut mats = Vec::with_capacity(meta.n_layers);
                 for l in 0..meta.n_layers {
-                    let Ok(mat) = Mat::open(&partition.layer_dir(part, l), &meta.mode, with_counts)
+                    let Ok(mat) = Mat::open(&index.layer_dir(part, l), &meta.mode, with_counts)
                     else {
                         continue;
                     };

src/obikphylo/src/siblings/cardinality.rs

@@ -2,11 +2,10 @@ use std::sync::Arc;
 
 use ndarray::Array2;
 
-use obikpartitionner::KmerPartitions;
 use obisys::progress_bar;
 
 use obikindex::KmerIndex;
-use obikindex::{OKIError, OKIResult};
+use obikindex::OKIResult;
 
 use super::cache::PartitionCache;
 use super::distance::RawSnpDistanceOutput;
@@ -69,8 +68,6 @@ impl CardinalityExt for KmerIndex {
         let n_genomes = self.meta().genomes.len();
         let with_counts = self.meta().config.with_counts;
         let k = self.kmer_size();
-        let n_bits = n_parts.trailing_zeros() as usize;
-
         let included = Array2::from_shape_fn((n_genomes, n_genomes), |(i, j)| {
             if i == j {
                 return false;
@@ -80,14 +77,7 @@ impl CardinalityExt for KmerIndex {
             total > 0 && (snp as f64 / total as f64) <= ratio_ceiling
         });
 
-        let partition = KmerPartitions::open_with_config(
+        let cache = Arc::new(PartitionCache::build(self, n_parts, with_counts)?);
-            self.root_path(),
-            self.kmer_size(),
-            self.minimizer_size(),
-            n_bits,
-        )
-        .map_err(OKIError::Partition)?;
-        let cache = Arc::new(PartitionCache::build(&partition, n_parts, with_counts)?);
         let layer_dirs = super::family_scan::sibling_layer_dirs(self)?;
 
         let pb = progress_bar("cardinality_tally", layer_dirs.len() as u64, "layers");

src/obikphylo/src/siblings/distance.rs

@@ -2,11 +2,10 @@ use std::sync::Arc;
 
 use ndarray::Array2;
 
-use obikpartitionner::KmerPartitions;
 use obisys::progress_bar;
 
 use obikindex::KmerIndex;
-use obikindex::{OKIError, OKIResult};
+use obikindex::OKIResult;
 
 use super::cache::PartitionCache;
 use super::family_scan::{Selection, scan_layer_families};
@@ -70,16 +69,7 @@ where
     let n_genomes = index.meta().genomes.len();
     let with_counts = index.meta().config.with_counts;
     let k = index.kmer_size();
-    let n_bits = n_parts.trailing_zeros() as usize;
+    let cache = Arc::new(PartitionCache::build(index, n_parts, with_counts)?);
-
-    let partition = KmerPartitions::open_with_config(
-        index.root_path(),
-        index.kmer_size(),
-        index.minimizer_size(),
-        n_bits,
-    )
-    .map_err(OKIError::Partition)?;
-    let cache = Arc::new(PartitionCache::build(&partition, n_parts, with_counts)?);
     let layer_dirs = super::family_scan::sibling_layer_dirs(index)?;
 
     let pb = progress_bar(label, layer_dirs.len() as u64, "layers");

src/obikphylo/src/siblings/entropy.rs

@@ -13,7 +13,6 @@ use std::io::{BufWriter, Write};
 use std::path::{Path, PathBuf};
 use std::sync::Arc;
 
-use obikpartitionner::KmerPartitions;
 use obisys::progress_bar;
 
 use obikindex::KmerIndex;
@@ -139,16 +138,7 @@ impl ShannonEntropyExt for KmerIndex {
         let n_genomes = self.meta().genomes.len();
         let with_counts = self.meta().config.with_counts;
         let k = self.kmer_size();
-        let n_bits = n_parts.trailing_zeros() as usize;
+        let cache = Arc::new(PartitionCache::build(self, n_parts, with_counts)?);
-
-        let partition = KmerPartitions::open_with_config(
-            self.root_path(),
-            self.kmer_size(),
-            self.minimizer_size(),
-            n_bits,
-        )
-        .map_err(OKIError::Partition)?;
-        let cache = Arc::new(PartitionCache::build(&partition, n_parts, with_counts)?);
         let layer_dirs = super::family_scan::sibling_layer_dirs(self)?;
         let selections =
             super::subsample::compute_selections(self, &layer_dirs, subsample, entropy_bias)?;
@@ -240,16 +230,7 @@ pub(super) fn ensure_entropy_annexes(index: &KmerIndex, layer_dirs: &[PathBuf])
     let n_genomes = index.meta().genomes.len();
     let with_counts = index.meta().config.with_counts;
     let k = index.kmer_size();
-    let n_bits = n_parts.trailing_zeros() as usize;
+    let cache = Arc::new(PartitionCache::build(index, n_parts, with_counts)?);
-
-    let partition = KmerPartitions::open_with_config(
-        index.root_path(),
-        index.kmer_size(),
-        index.minimizer_size(),
-        n_bits,
-    )
-    .map_err(OKIError::Partition)?;
-    let cache = Arc::new(PartitionCache::build(&partition, n_parts, with_counts)?);
     let minorant_counts = super::subsample::minorant_counts(layer_dirs)?;
 
     let pb = progress_bar("entropy_annex_build", missing.len() as u64, "layers");

src/obikphylo/src/siblings/family_scan.rs

@@ -105,13 +105,13 @@ pub(crate) fn sibling_layer_dirs(index: &KmerIndex) -> OKIResult<Vec<PathBuf>> {
     let n_parts = index.n_partitions();
     let mut layer_dirs = Vec::new();
     for part in 0..n_parts {
-        let index_dir = index.partition().index_dir(part);
+        let index_dir = index.index_dir(part);
         if !index_dir.exists() {
             continue;
         }
-        let n_layers = index.partition().n_layers(part)?;
+        let n_layers = index.n_layers(part)?;
         for l in 0..n_layers {
-            let this_layer_dir = index.partition().layer_dir(part, l);
+            let this_layer_dir = index.layer_dir(part, l);
             let annex_path = this_layer_dir.join(ANNEX_FILE_NAME);
             if !annex_path.exists() {
                 return Err(OKIError::InvalidInput(format!(

src/obikphylo/src/siblings/sankoff_bundle.rs

@@ -29,11 +29,10 @@ use std::sync::Arc;
 
 use ndarray::Array2;
 
-use obikpartitionner::KmerPartitions;
 use obisys::progress_bar;
 
 use obikindex::KmerIndex;
-use obikindex::{OKIError, OKIResult};
+use obikindex::OKIResult;
 
 use super::alignment::{SnpAlignment, iupac_code};
 use super::cache::PartitionCache;
@@ -83,16 +82,7 @@ impl SankoffBundleExt for KmerIndex {
         let n_genomes = self.meta().genomes.len();
         let with_counts = self.meta().config.with_counts;
         let k = self.kmer_size();
-        let n_bits = n_parts.trailing_zeros() as usize;
+        let cache = Arc::new(PartitionCache::build(self, n_parts, with_counts)?);
-
-        let partition = KmerPartitions::open_with_config(
-            self.root_path(),
-            self.kmer_size(),
-            self.minimizer_size(),
-            n_bits,
-        )
-        .map_err(OKIError::Partition)?;
-        let cache = Arc::new(PartitionCache::build(&partition, n_parts, with_counts)?);
         let layer_dirs = sibling_layer_dirs(self)?;
         // Computed once — every pass below iterates the exact same
         // families, in the exact same layers, per the shared-selection

src/obikphylo/src/siblings/stats.rs

@@ -2,11 +2,10 @@ use std::sync::Arc;
 
 use rayon::prelude::*;
 
-use obikpartitionner::KmerPartitions;
 use obisys::progress_bar;
 
 use obikindex::KmerIndex;
-use obikindex::{OKIError, OKIResult};
+use obikindex::OKIResult;
 
 use super::ANNEX_FILE_NAME;
 use super::SiblingAnnex;
@@ -109,19 +108,10 @@ impl SiblingStatsExt for KmerIndex {
         let n_genomes = self.meta().genomes.len();
         let with_counts = self.meta().config.with_counts;
         let k = self.kmer_size();
-        let n_bits = n_parts.trailing_zeros() as usize;
-
         // Same whole-run cache as `build_sibling_annex` — see its docs for
         // why re-opening per lookup (or per call to a batching helper) is
         // not good enough on a real index.
-        let partition = KmerPartitions::open_with_config(
+        let cache = Arc::new(PartitionCache::build(self, n_parts, with_counts)?);
-            self.root_path(),
-            self.kmer_size(),
-            self.minimizer_size(),
-            n_bits,
-        )
-        .map_err(OKIError::Partition)?;
-        let cache = Arc::new(PartitionCache::build(&partition, n_parts, with_counts)?);
         let layer_dirs = super::family_scan::sibling_layer_dirs(self)?;
 
         // One layer at a time, not parallelised across layers — see

src/obikphylo/src/siblings/tests.rs

@@ -69,11 +69,12 @@ fn build_single_genome_index(dir: &Path, label: &str, seq: &[u8]) -> KmerIndex {
 
     let mut rep = Reporter::new();
     let stream = obiread::open_nuc_stream(fasta_path.to_str().unwrap(), K).expect("open fasta");
+    let mut router = idx.partition_router().expect("partition_router");
     for page in stream {
         let batch = obiskbuilder::build_superkmers_page(page, K, /* level_max */ 1, /* theta */ 0.0);
-        idx.partition_mut().write_batch(batch).expect("write_batch");
+        router.write_batch(batch).expect("write_batch");
     }
-    idx.partition_mut().close().expect("close partition writers");
+    router.close().expect("close partition writers");
     idx.mark_scattered().expect("mark_scattered");
     idx.dereplicate_and_count(false, &mut rep).expect("dereplicate_and_count");
     idx.build_layers(1, None, false, &mut rep).expect("build_layers");
@@ -87,9 +88,9 @@ fn canonical(ascii: &[u8]) -> CanonicalKmer {
 /// Read back the annex entry for a given canonical k-mer from the merged
 /// index's (single) partition/layer, asserting it was found at all.
 fn annex_info_for(idx: &KmerIndex, kmer: CanonicalKmer) -> FamilyMask {
-    let meta = idx.partition().partition_meta(0).unwrap();
+    let meta = idx.partition_meta(0).unwrap();
     for l in 0..meta.n_layers {
-        let layer_dir = idx.partition().layer_dir(0, l);
+        let layer_dir = idx.layer_dir(0, l);
         let mphf = MphfLayer::open(&layer_dir, &meta.mode).unwrap();
         if let Some(slot) = mphf.find(kmer) {
             let annex = SiblingAnnex::open(&layer_dir.join(ANNEX_FILE_NAME)).unwrap();
@@ -165,7 +166,7 @@ fn sibling_annex_works_after_pack_sparse() {
     let merged = merge_two(dir.path(), &g1, &g2);
     merged.pack_matrices(true).expect("pack_matrices(sparse)");
 
-    let index_dir = merged.partition().index_dir(0);
+    let index_dir = merged.index_dir(0);
     assert!(
         index_dir.join("layer_0").join("presence").join("is_multi.prsb").exists(),
         "pack_matrices(true) must leave the sparse marker file behind"
@@ -308,9 +309,9 @@ fn sibling_annex_no_empty_masks_after_build() {
     let g1 = build_single_genome_index(dir.path(), "g1", &seq);
     g1.build_sibling_annex().expect("build_sibling_annex");
 
-    let n_layers = g1.partition().n_layers(0).expect("partition meta");
+    let n_layers = g1.n_layers(0).expect("partition meta");
     for l in 0..n_layers {
-        let layer_dir = g1.partition().layer_dir(0, l);
+        let layer_dir = g1.layer_dir(0, l);
         let annex = SiblingAnnex::open(&layer_dir.join(ANNEX_FILE_NAME)).expect("annex open");
         for slot in 0..annex.len() {
             let mask = annex.get(slot).expect("slot must have an entry");
@@ -358,7 +359,7 @@ fn sibling_annex_records_the_real_layer_of_each_family_member() {
     let merged = merge_two(dir.path(), &g1, &g2);
     merged.build_sibling_annex().expect("build_sibling_annex");
 
-    let n_layers = merged.partition().n_layers(0).unwrap();
+    let n_layers = merged.n_layers(0).unwrap();
     assert_eq!(n_layers, 2, "fixture assumption: one merge, one new layer");
 
     let g1_kmer = canonical(b"AACCGCTTAAG"); // own base C (1), sibling base G (2) — lives in layer 1