computer: indexes + rolling

crates/brk_computer/src/blocks/interval/compute.rs

@@ -4,12 +4,13 @@ use brk_types::{CheckedSub, Timestamp};
 use vecdb::{Exit, ReadableVec};
 
 use super::Vecs;
-use crate::ComputeIndexes;
+use crate::{blocks, ComputeIndexes};
 
 impl Vecs {
     pub(crate) fn compute(
         &mut self,
         indexer: &Indexer,
+        count_vecs: &blocks::CountVecs,
         starting_indexes: &ComputeIndexes,
         exit: &Exit,
     ) -> Result<()> {
@@ -31,6 +32,15 @@ impl Vecs {
             },
             exit,
         )?;
+
+        let window_starts = count_vecs.window_starts();
+        self.interval_rolling.compute_distribution(
+            starting_indexes.height,
+            &window_starts,
+            &self.interval.height,
+            exit,
+        )?;
+
         Ok(())
     }
 }

crates/brk_computer/src/blocks/interval/import.rs

@@ -3,7 +3,10 @@ use brk_types::Version;
 use vecdb::Database;
 
 use super::Vecs;
-use crate::{indexes, internal::ComputedFromHeightDistribution};
+use crate::{
+    indexes,
+    internal::{ComputedFromHeightLast, RollingDistribution},
+};
 
 impl Vecs {
     pub(crate) fn forced_import(
@@ -11,13 +14,15 @@ impl Vecs {
         version: Version,
         indexes: &indexes::Vecs,
     ) -> Result<Self> {
-        let interval = ComputedFromHeightDistribution::forced_import(
-            db,
-            "block_interval",
-            version,
-            indexes,
-        )?;
+        let interval =
+            ComputedFromHeightLast::forced_import(db, "block_interval", version, indexes)?;
 
-        Ok(Self { interval })
+        let interval_rolling =
+            RollingDistribution::forced_import(db, "block_interval", version, indexes)?;
+
+        Ok(Self {
+            interval,
+            interval_rolling,
+        })
     }
 }

crates/brk_computer/src/blocks/interval/vecs.rs

@@ -2,10 +2,11 @@ use brk_traversable::Traversable;
 use brk_types::Timestamp;
 use vecdb::{Rw, StorageMode};
 
-use crate::internal::ComputedFromHeightDistribution;
+use crate::internal::{ComputedFromHeightLast, RollingDistribution};
 
 #[derive(Traversable)]
 pub struct Vecs<M: StorageMode = Rw> {
     #[traversable(flatten)]
-    pub interval: ComputedFromHeightDistribution<Timestamp, M>,
+    pub interval: ComputedFromHeightLast<Timestamp, M>,
+    pub interval_rolling: RollingDistribution<Timestamp, M>,
 }