diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 6f9ed52e131..7f44923a4fa 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -584,7 +584,11 @@ jobs:
       - name: Rust Tests (Windows)
         if: matrix.os == 'windows-x64'
         run: |
-          cargo nextest run --locked --workspace --all-features --no-fail-fast --exclude vortex-bench --exclude vortex-python --exclude vortex-duckdb --exclude vortex-fuzz --exclude vortex-cuda --exclude vortex-nvcomp --exclude vortex-cub --exclude vortex-test-e2e-cuda --exclude duckdb-bench --exclude lance-bench --exclude datafusion-bench --exclude random-access-bench --exclude compress-bench --exclude xtask
+          cargo nextest run --locked --workspace --all-features --no-fail-fast --exclude vortex-bench `
+            --exclude vortex-python --exclude vortex-duckdb --exclude vortex-fuzz --exclude vortex-cuda `
+            --exclude vortex-nvcomp --exclude vortex-cub --exclude vortex-test-e2e-cuda --exclude duckdb-bench `
+            --exclude lance-bench --exclude datafusion-bench --exclude random-access-bench --exclude compress-bench `
+            --exclude xtask --exclude vortex-datafusion
       - name: Rust Tests (Other)
         if: matrix.os != 'windows-x64'
         run: cargo nextest run --locked --workspace --all-features --no-fail-fast --exclude vortex-bench --exclude xtask
diff --git a/Cargo.lock b/Cargo.lock
index de836acc39c..20822526491 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -3953,16 +3953,6 @@ dependencies = [
  "pin-project-lite",
 ]
 
-[[package]]
-name = "exponential-decay-histogram"
-version = "0.1.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d7962d7e9baab6ea05af175491fa6a8441f3bf461558037622142573d98dd6d6"
-dependencies = [
- "ordered-float 5.1.0",
- "rand 0.9.2",
-]
-
 [[package]]
 name = "ext-trait"
 version = "1.0.1"
@@ -8592,16 +8582,6 @@ dependencies = [
  "serde_derive",
 ]
 
-[[package]]
-name = "serde-value"
-version = "0.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f3a1a3341211875ef120e117ea7fd5228530ae7e7036a779fdc9117be6b3282c"
-dependencies = [
- "ordered-float 2.10.1",
- "serde",
-]
-
 [[package]]
 name = "serde_core"
 version = "1.0.228"
@@ -10864,8 +10844,8 @@ version = "0.1.0"
 dependencies = [
  "getrandom 0.3.4",
  "parking_lot",
+ "sketches-ddsketch",
  "vortex-session",
- "witchcraft-metrics",
 ]
 
 [[package]]
@@ -11826,19 +11806,6 @@ version = "0.51.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d7249219f66ced02969388cf2bb044a09756a083d0fab1e566056b04d9fbcaa5"
 
-[[package]]
-name = "witchcraft-metrics"
-version = "1.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "867a74dec702d742179279ab0b5bcab72ca5858c0c3ccf870bdb5c99f54d675b"
-dependencies = [
- "exponential-decay-histogram",
- "once_cell",
- "parking_lot",
- "serde",
- "serde-value",
-]
-
 [[package]]
 name = "writeable"
 version = "0.6.2"
diff --git a/Cargo.toml b/Cargo.toml
index abce82d3762..f25e858917f 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -233,7 +233,6 @@ url = "2.5.7"
 uuid = { version = "1.19", features = ["js"] }
 walkdir = "2.5.0"
 wasm-bindgen-futures = "0.4.39"
-witchcraft-metrics = "1.0.1"
 xshell = "0.2.6"
 xz2 = "0.1.7"
 zigzag = "0.1.0"
diff --git a/benchmarks/datafusion-bench/src/main.rs b/benchmarks/datafusion-bench/src/main.rs
index 6be64e5bbad..0a8e26fde42 100644
--- a/benchmarks/datafusion-bench/src/main.rs
+++ b/benchmarks/datafusion-bench/src/main.rs
@@ -320,9 +320,9 @@ fn print_metrics(plans: &[(usize, Format, Arc<dyn ExecutionPlan>)]) {
 
         eprintln!("metrics for query={query_idx}, {format}:");
         for (scan_idx, metrics_set) in metric_sets.iter().enumerate() {
-            eprintln!("  scan[{scan_idx}]:");
-            for metric in metrics_set.clone().aggregate().sorted_for_display().iter() {
-                eprintln!("    {metric}");
+            eprintln!("\tscan[{scan_idx}]:");
+            for metric in metrics_set.aggregate().sorted_for_display().iter() {
+                eprintln!("\t\t{metric}");
             }
         }
     }
diff --git a/vortex-datafusion/src/persistent/metrics.rs b/vortex-datafusion/src/persistent/metrics.rs
index 58c68d82d58..7e99430568f 100644
--- a/vortex-datafusion/src/persistent/metrics.rs
+++ b/vortex-datafusion/src/persistent/metrics.rs
@@ -3,6 +3,7 @@
 
 //! Vortex table provider metrics.
 use std::sync::Arc;
+use std::time::Duration;
 
 use datafusion_datasource::file_scan_config::FileScanConfig;
 use datafusion_datasource::source::DataSourceExec;
@@ -15,13 +16,16 @@ use datafusion_physical_plan::metrics::Gauge;
 use datafusion_physical_plan::metrics::Label as DatafusionLabel;
 use datafusion_physical_plan::metrics::MetricValue as DatafusionMetricValue;
 use datafusion_physical_plan::metrics::MetricsSet;
+use datafusion_physical_plan::metrics::Time;
+use vortex::error::VortexExpect;
+use vortex::metrics::Label;
 use vortex::metrics::Metric;
-use vortex::metrics::MetricId;
-use vortex::metrics::Tags;
+use vortex::metrics::MetricValue;
 
 use crate::persistent::source::VortexSource;
 
 pub(crate) static PARTITION_LABEL: &str = "partition";
+pub(crate) static PATH_LABEL: &str = "file_path";
 
 /// Extracts datafusion metrics from all VortexExec instances in
 /// a given physical plan.
@@ -43,9 +47,8 @@ impl ExecutionPlanVisitor for VortexMetricsFinder {
     type Error = std::convert::Infallible;
     fn pre_visit(&mut self, plan: &dyn ExecutionPlan) -> Result<bool, Self::Error> {
         if let Some(exec) = plan.as_any().downcast_ref::<DataSourceExec>() {
-            if let Some(metrics) = exec.metrics() {
-                self.0.push(metrics);
-            }
+            // Start with exec metrics or create a new set
+            let mut set = exec.metrics().unwrap_or_default();
 
             // Include our own metrics from VortexSource
             if let Some(file_scan) = exec.data_source().as_any().downcast_ref::<FileScanConfig>()
@@ -54,92 +57,99 @@ impl ExecutionPlanVisitor for VortexMetricsFinder {
                     .as_any()
                     .downcast_ref::<VortexSource>()
             {
-                let mut set = MetricsSet::new();
                 for metric in scan
-                    .vx_metrics()
+                    .metrics_registry()
                     .snapshot()
                     .iter()
-                    .flat_map(|(id, metric)| metric_to_datafusion(id, metric))
+                    .flat_map(metric_to_datafusion)
                 {
                     set.push(Arc::new(metric));
                 }
-
-                self.0.push(set);
             }
-        }
 
-        Ok(true)
+            self.0.push(set);
+
+            Ok(false)
+        } else {
+            Ok(true)
+        }
     }
 }
 
-fn metric_to_datafusion(id: MetricId, metric: &Metric) -> impl Iterator<Item = DatafusionMetric> {
-    let (partition, labels) = tags_to_datafusion(id.tags());
-    metric_value_to_datafusion(id.name(), metric)
+fn metric_to_datafusion(metric: &Metric) -> impl Iterator<Item = DatafusionMetric> {
+    let (partition, labels) = labels_to_datafusion(metric.labels());
+    metric_value_to_datafusion(metric.name(), metric.value())
         .into_iter()
         .map(move |metric_value| {
             DatafusionMetric::new_with_labels(metric_value, partition, labels.clone())
         })
 }
 
-fn tags_to_datafusion(tags: &Tags) -> (Option<usize>, Vec<DatafusionLabel>) {
+fn labels_to_datafusion(tags: &[Label]) -> (Option<usize>, Vec<DatafusionLabel>) {
     tags.iter()
-        .fold((None, Vec::new()), |(mut partition, mut labels), (k, v)| {
-            if k == PARTITION_LABEL {
-                partition = v.parse().ok();
+        .fold((None, Vec::new()), |(mut partition, mut labels), metric| {
+            if metric.key() == PARTITION_LABEL {
+                partition = metric.value().parse().ok();
             } else {
-                labels.push(DatafusionLabel::new(k.to_string(), v.to_string()));
+                labels.push(DatafusionLabel::new(
+                    metric.key().to_string(),
+                    metric.value().to_string(),
+                ));
             }
             (partition, labels)
         })
 }
 
-fn metric_value_to_datafusion(name: &str, metric: &Metric) -> Vec<DatafusionMetricValue> {
+fn metric_value_to_datafusion(name: &str, metric: &MetricValue) -> Vec<DatafusionMetricValue> {
     match metric {
-        Metric::Counter(counter) => counter
-            .count()
+        MetricValue::Counter(counter) => counter
+            .value()
             .try_into()
             .into_iter()
             .map(|count| df_counter(name.to_string(), count))
             .collect(),
-        Metric::Histogram(hist) => {
+        MetricValue::Histogram(hist) => {
             let mut res = Vec::new();
-            if let Ok(count) = hist.count().try_into() {
-                res.push(df_counter(format!("{name}_count"), count));
-            }
-            let snapshot = hist.snapshot();
-            if let Ok(max) = snapshot.max().try_into() {
-                res.push(df_gauge(format!("{name}_max"), max));
-            }
-            if let Ok(min) = snapshot.min().try_into() {
-                res.push(df_gauge(format!("{name}_min"), min));
-            }
-            if let Some(p90) = f_to_u(snapshot.value(0.90)) {
-                res.push(df_gauge(format!("{name}_p95"), p90));
-            }
-            if let Some(p99) = f_to_u(snapshot.value(0.99)) {
-                res.push(df_gauge(format!("{name}_p99"), p99));
+
+            res.push(df_counter(format!("{name}_count"), hist.count()));
+
+            if !hist.is_empty() {
+                if let Some(max) = f_to_u(hist.quantile(1.0).vortex_expect("must not be empty")) {
+                    res.push(df_gauge(format!("{name}_max"), max));
+                }
+
+                if let Some(min) = f_to_u(hist.quantile(0.0).vortex_expect("must not be empty")) {
+                    res.push(df_gauge(format!("{name}_min"), min));
+                }
+
+                if let Some(p95) = f_to_u(hist.quantile(0.95).vortex_expect("must not be empty")) {
+                    res.push(df_gauge(format!("{name}_p95"), p95));
+                }
+                if let Some(p99) = f_to_u(hist.quantile(0.99).vortex_expect("must not be empty")) {
+                    res.push(df_gauge(format!("{name}_p99"), p99));
+                }
             }
+
             res
         }
-        Metric::Timer(timer) => {
+        MetricValue::Timer(timer) => {
             let mut res = Vec::new();
-            if let Ok(count) = timer.count().try_into() {
-                res.push(df_counter(format!("{name}_count"), count));
-            }
-            let snapshot = timer.snapshot();
-            if let Ok(max) = snapshot.max().try_into() {
-                // NOTE(os): unlike Time metrics, gauges allow custom aggregation
-                res.push(df_gauge(format!("{name}_max"), max));
-            }
-            if let Ok(min) = snapshot.min().try_into() {
-                res.push(df_gauge(format!("{name}_min"), min));
-            }
-            if let Some(p95) = f_to_u(snapshot.value(0.95)) {
-                res.push(df_gauge(format!("{name}_p95"), p95));
-            }
-            if let Some(p99) = f_to_u(snapshot.value(0.95)) {
-                res.push(df_gauge(format!("{name}_p99"), p99));
+            res.push(df_counter(format!("{name}_count"), timer.count()));
+
+            if !timer.is_empty() {
+                let max = timer.quantile(1.0).vortex_expect("must not be empty");
+                res.push(df_timer(format!("{name}_max"), max));
+
+                let min = timer.quantile(0.0).vortex_expect("must not be empty");
+                res.push(df_timer(format!("{name}_min"), min));
+
+                let p95 = timer.quantile(0.95).vortex_expect("must not be empty");
+                res.push(df_timer(format!("{name}_p95"), p95));
+
+                let p99 = timer.quantile(0.99).vortex_expect("must not be empty");
+                res.push(df_timer(format!("{name}_p99"), p99));
             }
+
             res
         }
         // TODO(os): add more metric types when added to VortexMetrics
@@ -165,6 +175,15 @@ fn df_gauge(name: String, value: usize) -> DatafusionMetricValue {
     }
 }
 
+fn df_timer(name: String, value: Duration) -> DatafusionMetricValue {
+    let time = Time::new();
+    time.add_duration(value);
+    DatafusionMetricValue::Time {
+        name: name.into(),
+        time,
+    }
+}
+
 #[expect(
     clippy::cast_possible_truncation,
     reason = "truncation is checked before cast"
@@ -174,3 +193,74 @@ fn f_to_u(f: f64) -> Option<usize> {
         // After the range check, truncation is guaranteed to keep the value in usize bounds.
         f.trunc() as usize)
 }
+
+#[cfg(test)]
+mod tests {
+
+    use datafusion_datasource::source::DataSourceExec;
+    use datafusion_physical_plan::ExecutionPlanVisitor;
+    use datafusion_physical_plan::accept;
+
+    use super::VortexMetricsFinder;
+    use crate::common_tests::TestSessionContext;
+
+    /// Counts the number of DataSourceExec nodes in a plan.
+    struct DataSourceExecCounter(usize);
+
+    impl ExecutionPlanVisitor for DataSourceExecCounter {
+        type Error = std::convert::Infallible;
+        fn pre_visit(
+            &mut self,
+            plan: &dyn datafusion_physical_plan::ExecutionPlan,
+        ) -> Result<bool, Self::Error> {
+            if plan.as_any().downcast_ref::<DataSourceExec>().is_some() {
+                self.0 += 1;
+                Ok(false)
+            } else {
+                Ok(true)
+            }
+        }
+    }
+
+    #[tokio::test]
+    async fn metrics_finder_returns_one_set_per_data_source_exec() -> anyhow::Result<()> {
+        let ctx = TestSessionContext::default();
+
+        ctx.session
+            .sql(
+                "CREATE EXTERNAL TABLE my_tbl \
+                (c1 VARCHAR NOT NULL, c2 INT NOT NULL) \
+                STORED AS vortex \
+                LOCATION 'files/'",
+            )
+            .await?;
+
+        ctx.session
+            .sql("INSERT INTO my_tbl VALUES ('a', 1), ('b', 2)")
+            .await?
+            .collect()
+            .await?;
+
+        let df = ctx.session.sql("SELECT * FROM my_tbl").await?;
+        let (state, plan) = df.into_parts();
+        let physical_plan = state.create_physical_plan(&plan).await?;
+
+        // Count DataSourceExec nodes
+        let mut counter = DataSourceExecCounter(0);
+        accept(physical_plan.as_ref(), &mut counter)?;
+
+        // Get metrics sets
+        let metrics_sets = VortexMetricsFinder::find_all(physical_plan.as_ref());
+
+        assert!(!metrics_sets.is_empty());
+        assert_eq!(
+            metrics_sets.len(),
+            counter.0,
+            "Expected one MetricsSet per DataSourceExec, got {} sets for {} DataSourceExec nodes",
+            metrics_sets.len(),
+            counter.0
+        );
+
+        Ok(())
+    }
+}
diff --git a/vortex-datafusion/src/persistent/opener.rs b/vortex-datafusion/src/persistent/opener.rs
index 45cbba7871c..15a2a81887a 100644
--- a/vortex-datafusion/src/persistent/opener.rs
+++ b/vortex-datafusion/src/persistent/opener.rs
@@ -38,7 +38,8 @@ use vortex::error::VortexError;
 use vortex::file::OpenOptionsSessionExt;
 use vortex::io::InstrumentedReadAt;
 use vortex::layout::LayoutReader;
-use vortex::metrics::VortexMetrics;
+use vortex::metrics::Label;
+use vortex::metrics::MetricsRegistry;
 use vortex::scan::ScanBuilder;
 use vortex::session::VortexSession;
 use vortex_utils::aliases::dash_map::DashMap;
@@ -50,11 +51,15 @@ use crate::convert::exprs::ExpressionConvertor;
 use crate::convert::exprs::ProcessedProjection;
 use crate::convert::exprs::make_vortex_predicate;
 use crate::convert::schema::calculate_physical_schema;
+use crate::metrics::PARTITION_LABEL;
+use crate::metrics::PATH_LABEL;
 use crate::persistent::cache::CachedVortexMetadata;
 use crate::persistent::stream::PrunableStream;
 
 #[derive(Clone)]
 pub(crate) struct VortexOpener {
+    /// The partition this opener is assigned to. Only used for labeling metrics.
+    pub partition: usize,
     pub session: VortexSession,
     pub vortex_reader_factory: Arc<dyn VortexReaderFactory>,
     /// Optional table schema projection. The indices are w.r.t. the `table_schema`, which is
@@ -76,7 +81,7 @@ pub(crate) struct VortexOpener {
     /// If provided, the scan will not return more than this many rows.
     pub limit: Option<u64>,
     /// A metrics object for tracking performance of the scan.
-    pub metrics: VortexMetrics,
+    pub metrics_registry: Arc<dyn MetricsRegistry>,
     /// A shared cache of file readers.
     ///
     /// To save on the overhead of reparsing FlatBuffers and rebuilding the layout tree, we cache
@@ -92,9 +97,11 @@ pub(crate) struct VortexOpener {
 impl FileOpener for VortexOpener {
     fn open(&self, file: PartitionedFile) -> DFResult<FileOpenFuture> {
         let session = self.session.clone();
-        let metrics = self
-            .metrics
-            .child_with_tags([("file_path", file.path().to_string())]);
+        let metrics_registry = self.metrics_registry.clone();
+        let labels = vec![
+            Label::new(PATH_LABEL, file.path().to_string()),
+            Label::new(PARTITION_LABEL, self.partition.to_string()),
+        ];
 
         let mut projection = self.projection.clone();
         let mut filter = self.filter.clone();
@@ -103,7 +110,8 @@ impl FileOpener for VortexOpener {
             .vortex_reader_factory
             .create_reader(file.path().as_ref(), &session)?;
 
-        let reader = InstrumentedReadAt::new(reader, &metrics);
+        let reader =
+            InstrumentedReadAt::new_with_labels(reader, metrics_registry.as_ref(), labels.clone());
 
         let file_pruning_predicate = self.file_pruning_predicate.clone();
         let expr_adapter_factory = self.expr_adapter_factory.clone();
@@ -169,7 +177,8 @@ impl FileOpener for VortexOpener {
             let mut open_opts = session
                 .open_options()
                 .with_file_size(file.object_meta.size)
-                .with_metrics(metrics.clone());
+                .with_metrics_registry(metrics_registry.clone())
+                .with_labels(labels);
 
             if let Some(file_metadata_cache) = file_metadata_cache
                 && let Some(file_metadata) = file_metadata_cache.get(&file.object_meta)
@@ -318,7 +327,7 @@ impl FileOpener for VortexOpener {
             }
 
             let stream = scan_builder
-                .with_metrics(metrics)
+                .with_metrics_registry(metrics_registry)
                 .with_projection(scan_projection)
                 .with_some_filter(filter)
                 .with_ordered(has_output_ordering)
@@ -440,6 +449,7 @@ mod tests {
     use vortex::file::WriteOptionsSessionExt;
     use vortex::io::ObjectStoreWriter;
     use vortex::io::VortexWrite;
+    use vortex::metrics::DefaultMetricsRegistry;
     use vortex::scan::Selection;
     use vortex::session::VortexSession;
 
@@ -516,6 +526,7 @@ mod tests {
         filter: Option<PhysicalExprRef>,
     ) -> VortexOpener {
         VortexOpener {
+            partition: 1,
             session: SESSION.clone(),
             vortex_reader_factory: Arc::new(DefaultVortexReaderFactory::new(object_store)),
             projection: ProjectionExprs::from_indices(&[0], table_schema.file_schema()),
@@ -525,7 +536,7 @@ mod tests {
             table_schema,
             batch_size: 100,
             limit: None,
-            metrics: Default::default(),
+            metrics_registry: Arc::new(DefaultMetricsRegistry::default()),
             layout_readers: Default::default(),
             has_output_ordering: false,
             expression_convertor: Arc::new(DefaultExpressionConvertor::default()),
@@ -607,6 +618,7 @@ mod tests {
         )])));
 
         let make_opener = |filter| VortexOpener {
+            partition: 1,
             session: SESSION.clone(),
             vortex_reader_factory: Arc::new(DefaultVortexReaderFactory::new(object_store.clone())),
             projection: ProjectionExprs::from_indices(&[0], table_schema.file_schema()),
@@ -616,7 +628,7 @@ mod tests {
             table_schema: table_schema.clone(),
             batch_size: 100,
             limit: None,
-            metrics: Default::default(),
+            metrics_registry: Arc::new(DefaultMetricsRegistry::default()),
             layout_readers: Default::default(),
             has_output_ordering: false,
             expression_convertor: Arc::new(DefaultExpressionConvertor::default()),
@@ -690,6 +702,7 @@ mod tests {
         ]));
 
         let opener = VortexOpener {
+            partition: 1,
             session: SESSION.clone(),
             vortex_reader_factory: Arc::new(DefaultVortexReaderFactory::new(object_store)),
             projection: ProjectionExprs::from_indices(&[0, 1, 2], &table_schema),
@@ -699,7 +712,7 @@ mod tests {
             table_schema: TableSchema::from_file_schema(table_schema.clone()),
             batch_size: 100,
             limit: None,
-            metrics: Default::default(),
+            metrics_registry: Arc::new(DefaultMetricsRegistry::default()),
             layout_readers: Default::default(),
             has_output_ordering: false,
             expression_convertor: Arc::new(DefaultExpressionConvertor::default()),
@@ -839,6 +852,7 @@ mod tests {
         let projection = vec![0, 2];
 
         let opener = VortexOpener {
+            partition: 1,
             session: SESSION.clone(),
             vortex_reader_factory: Arc::new(DefaultVortexReaderFactory::new(object_store.clone())),
             projection: ProjectionExprs::from_indices(
@@ -851,7 +865,7 @@ mod tests {
             table_schema: table_schema.clone(),
             batch_size: 100,
             limit: None,
-            metrics: Default::default(),
+            metrics_registry: Arc::new(DefaultMetricsRegistry::default()),
             layout_readers: Default::default(),
             has_output_ordering: false,
             expression_convertor: Arc::new(DefaultExpressionConvertor::default()),
@@ -898,6 +912,7 @@ mod tests {
         projection: ProjectionExprs,
     ) -> VortexOpener {
         VortexOpener {
+            partition: 1,
             session: SESSION.clone(),
             vortex_reader_factory: Arc::new(DefaultVortexReaderFactory::new(object_store)),
             projection,
@@ -907,7 +922,7 @@ mod tests {
             table_schema: TableSchema::from_file_schema(schema),
             batch_size: 100,
             limit: None,
-            metrics: Default::default(),
+            metrics_registry: Arc::new(DefaultMetricsRegistry::default()),
             layout_readers: Default::default(),
             has_output_ordering: false,
             expression_convertor: Arc::new(DefaultExpressionConvertor::default()),
@@ -1096,6 +1111,7 @@ mod tests {
         )]);
 
         let opener = VortexOpener {
+            partition: 1,
             session: SESSION.clone(),
             vortex_reader_factory: Arc::new(DefaultVortexReaderFactory::new(object_store.clone())),
             projection,
@@ -1105,7 +1121,7 @@ mod tests {
             table_schema,
             batch_size: 100,
             limit: None,
-            metrics: Default::default(),
+            metrics_registry: Arc::new(DefaultMetricsRegistry::default()),
             layout_readers: Default::default(),
             has_output_ordering: false,
             expression_convertor: Arc::new(DefaultExpressionConvertor::default()),
diff --git a/vortex-datafusion/src/persistent/source.rs b/vortex-datafusion/src/persistent/source.rs
index 5e46f61c5e4..53bdd639b38 100644
--- a/vortex-datafusion/src/persistent/source.rs
+++ b/vortex-datafusion/src/persistent/source.rs
@@ -29,11 +29,11 @@ use object_store::path::Path;
 use vortex::error::VortexExpect as _;
 use vortex::file::VORTEX_FILE_EXTENSION;
 use vortex::layout::LayoutReader;
-use vortex::metrics::VortexMetrics;
+use vortex::metrics::DefaultMetricsRegistry;
+use vortex::metrics::MetricsRegistry;
 use vortex::session::VortexSession;
 use vortex_utils::aliases::dash_map::DashMap;
 
-use super::metrics::PARTITION_LABEL;
 use super::opener::VortexOpener;
 use crate::DefaultVortexReaderFactory;
 use crate::VortexReaderFactory;
@@ -62,7 +62,7 @@ pub struct VortexSource {
     layout_readers: Arc<DashMap<Path, Weak<dyn LayoutReader>>>,
     expression_convertor: Arc<dyn ExpressionConvertor>,
     pub(crate) vortex_reader_factory: Option<Arc<dyn VortexReaderFactory>>,
-    vx_metrics: VortexMetrics,
+    vx_metrics_registry: Arc<dyn MetricsRegistry>,
     file_metadata_cache: Option<Arc<dyn FileMetadataCache>>,
 }
 
@@ -83,7 +83,7 @@ impl VortexSource {
             layout_readers: Arc::new(DashMap::default()),
             expression_convertor: Arc::new(DefaultExpressionConvertor::default()),
             vortex_reader_factory: None,
-            vx_metrics: VortexMetrics::default(),
+            vx_metrics_registry: Arc::new(DefaultMetricsRegistry::default()),
             file_metadata_cache: None,
         }
     }
@@ -108,9 +108,9 @@ impl VortexSource {
         self
     }
 
-    /// The metrics instance attached to this source.
-    pub fn vx_metrics(&self) -> &VortexMetrics {
-        &self.vx_metrics
+    /// Returns the [`MetricsRegistry`] attached to this source.
+    pub fn metrics_registry(&self) -> &Arc<dyn MetricsRegistry> {
+        &self.vx_metrics_registry
     }
 
     /// Override the file metadata cache
@@ -130,10 +130,6 @@ impl FileSource for VortexSource {
         base_config: &FileScanConfig,
         partition: usize,
     ) -> DFResult<Arc<dyn FileOpener>> {
-        let partition_metrics = self
-            .vx_metrics()
-            .child_with_tags([(PARTITION_LABEL, partition.to_string())].into_iter());
-
         let batch_size = self
             .batch_size
             .vortex_expect("batch_size must be supplied to VortexSource");
@@ -149,6 +145,7 @@ impl FileSource for VortexSource {
             .unwrap_or_else(|| Arc::new(DefaultVortexReaderFactory::new(object_store)));
 
         let opener = VortexOpener {
+            partition,
             session: self.session.clone(),
             vortex_reader_factory,
             projection: self.projection.clone(),
@@ -158,7 +155,7 @@ impl FileSource for VortexSource {
             table_schema: self.table_schema.clone(),
             batch_size,
             limit: base_config.limit.map(|l| l as u64),
-            metrics: partition_metrics,
+            metrics_registry: self.vx_metrics_registry.clone(),
             layout_readers: self.layout_readers.clone(),
             has_output_ordering: !base_config.output_ordering.is_empty(),
             expression_convertor: Arc::new(DefaultExpressionConvertor::default()),
diff --git a/vortex-file/src/open.rs b/vortex-file/src/open.rs
index 3e2d73aee40..b45e3d1bdc8 100644
--- a/vortex-file/src/open.rs
+++ b/vortex-file/src/open.rs
@@ -14,14 +14,16 @@ use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 use vortex_io::VortexReadAt;
 use vortex_io::session::RuntimeSessionExt;
+use vortex_layout::segments::InstrumentedSegmentCache;
 use vortex_layout::segments::NoOpSegmentCache;
 use vortex_layout::segments::SegmentCache;
-use vortex_layout::segments::SegmentCacheMetrics;
 use vortex_layout::segments::SegmentCacheSourceAdapter;
 use vortex_layout::segments::SegmentId;
 use vortex_layout::segments::SharedSegmentSource;
 use vortex_layout::session::LayoutSessionExt;
-use vortex_metrics::VortexMetrics;
+use vortex_metrics::DefaultMetricsRegistry;
+use vortex_metrics::Label;
+use vortex_metrics::MetricsRegistry;
 use vortex_session::VortexSession;
 use vortex_utils::aliases::hash_map::HashMap;
 
@@ -32,6 +34,7 @@ use crate::VortexFile;
 use crate::footer::Footer;
 use crate::segments::FileSegmentSource;
 use crate::segments::InitialReadSegmentCache;
+use crate::segments::RequestMetrics;
 
 const INITIAL_READ_SIZE: usize = MAX_POSTSCRIPT_SIZE as usize + EOF_SIZE;
 
@@ -40,7 +43,7 @@ pub struct VortexOpenOptions {
     /// The session to use for opening the file.
     session: VortexSession,
     /// Cache to use for file segments.
-    segment_cache: Arc<dyn SegmentCache>,
+    segment_cache: Option<Arc<dyn SegmentCache>>,
     /// The number of bytes to read when parsing the footer.
     initial_read_size: usize,
     /// An optional, externally provided, file size.
@@ -52,7 +55,9 @@ pub struct VortexOpenOptions {
     /// The segments read during the initial read.
     initial_read_segments: RwLock<HashMap<SegmentId, ByteBuffer>>,
     /// A metrics registry for the file.
-    metrics: Option<VortexMetrics>,
+    metrics_registry: Option<Arc<dyn MetricsRegistry>>,
+    /// Default labels applied to all the file's metrics
+    labels: Vec<Label>,
 }
 
 pub trait OpenOptionsSessionExt: ArraySessionExt + LayoutSessionExt + RuntimeSessionExt {
@@ -60,13 +65,14 @@ pub trait OpenOptionsSessionExt: ArraySessionExt + LayoutSessionExt + RuntimeSes
     fn open_options(&self) -> VortexOpenOptions {
         VortexOpenOptions {
             session: self.session(),
-            segment_cache: Arc::new(NoOpSegmentCache),
+            segment_cache: None,
             initial_read_size: INITIAL_READ_SIZE,
             file_size: None,
             dtype: None,
             footer: None,
             initial_read_segments: Default::default(),
-            metrics: None,
+            metrics_registry: None,
+            labels: Vec::default(),
         }
     }
 }
@@ -81,15 +87,10 @@ impl VortexOpenOptions {
 
     /// Configure a custom [`SegmentCache`].
     pub fn with_segment_cache(mut self, segment_cache: Arc<dyn SegmentCache>) -> Self {
-        self.segment_cache = segment_cache;
+        self.segment_cache = Some(segment_cache);
         self
     }
 
-    /// Disable segment caching entirely.
-    pub fn without_segment_cache(self) -> Self {
-        self.with_segment_cache(Arc::new(NoOpSegmentCache))
-    }
-
     /// Configure a known file size.
     ///
     /// This helps to prevent an I/O request to discover the size of the file.
@@ -119,9 +120,15 @@ impl VortexOpenOptions {
         self
     }
 
-    /// Configure a custom [`VortexMetrics`].
-    pub fn with_metrics(mut self, metrics: VortexMetrics) -> Self {
-        self.metrics = Some(metrics);
+    /// Configure a custom [`MetricsRegistry`] implementation.
+    pub fn with_metrics_registry(mut self, metrics: Arc<dyn MetricsRegistry>) -> Self {
+        self.metrics_registry = Some(metrics);
+        self
+    }
+
+    /// Adds labels to all the file's metrics.
+    pub fn with_labels(mut self, labels: Vec<Label>) -> Self {
+        self.labels.extend(labels);
         self
     }
 
@@ -147,36 +154,44 @@ impl VortexOpenOptions {
     /// Open a Vortex file from an in-memory buffer.
     pub fn open_buffer<B: Into<ByteBuffer>>(self, buffer: B) -> VortexResult<VortexFile> {
         // We know this is in memory, so we can open it synchronously.
-        block_on(
-            self.with_initial_read_size(0)
-                .without_segment_cache()
-                .open_read(buffer.into()),
-        )
+        block_on(self.with_initial_read_size(0).open_read(buffer.into()))
     }
 
     /// An API for opening a [`VortexFile`] using any [`VortexReadAt`] implementation.
     pub async fn open_read<R: VortexReadAt + Clone>(self, reader: R) -> VortexResult<VortexFile> {
-        let metrics = self.metrics.clone().unwrap_or_default();
+        let segment_cache = self
+            .segment_cache
+            .clone()
+            .unwrap_or_else(|| Arc::new(NoOpSegmentCache));
+
+        let metrics_registry = self
+            .metrics_registry
+            .clone()
+            .unwrap_or_else(|| Arc::new(DefaultMetricsRegistry::default()));
+
         let footer = if let Some(footer) = self.footer {
             footer
         } else {
             self.read_footer(&reader).await?
         };
 
-        let segment_cache = Arc::new(SegmentCacheMetrics::new(
+        let segment_cache = Arc::new(InstrumentedSegmentCache::new(
             InitialReadSegmentCache {
                 initial: self.initial_read_segments,
-                fallback: self.segment_cache,
+                fallback: segment_cache,
             },
-            metrics.clone(),
+            metrics_registry.as_ref(),
+            self.labels.clone(),
         ));
 
+        let metrics = RequestMetrics::new(metrics_registry.as_ref(), self.labels);
+
         // Create a segment source backed by the VortexRead implementation.
         let segment_source = Arc::new(SharedSegmentSource::new(FileSegmentSource::open(
             footer.segment_map().clone(),
             reader,
             self.session.handle(),
-            metrics.clone(),
+            metrics,
         )));
 
         // Wrap up the segment source to first resolve segments from the initial read cache.
@@ -344,7 +359,6 @@ mod tests {
         // Create a large file (> 1MB)
         let mut buf = ByteBufferMut::empty();
         let mut session = VortexSession::empty()
-            .with::<VortexMetrics>()
             .with::<DTypeSession>()
             .with::<ArraySession>()
             .with::<LayoutSession>()
diff --git a/vortex-file/src/read/driver.rs b/vortex-file/src/read/driver.rs
index e0aa59666fa..b2d7e6cc890 100644
--- a/vortex-file/src/read/driver.rs
+++ b/vortex-file/src/read/driver.rs
@@ -4,7 +4,6 @@
 use std::collections::BTreeMap;
 use std::collections::BTreeSet;
 use std::pin::Pin;
-use std::sync::Arc;
 use std::task::Context;
 use std::task::Poll;
 
@@ -13,15 +12,13 @@ use pin_project_lite::pin_project;
 use vortex_buffer::Alignment;
 use vortex_error::VortexExpect;
 use vortex_io::CoalesceConfig;
-use vortex_metrics::Counter;
-use vortex_metrics::Histogram;
-use vortex_metrics::VortexMetrics;
 
 use crate::read::ReadRequest;
 use crate::read::RequestId;
 use crate::read::request::CoalescedRequest;
 use crate::read::request::IoRequest;
 use crate::segments::ReadEvent;
+use crate::segments::RequestMetrics;
 
 pin_project! {
     /// A stream that performs coalescing and prioritization of I/O requests.
@@ -49,7 +46,7 @@ impl<S> IoRequestStream<S> {
         events: S,
         coalesce_window: Option<CoalesceConfig>,
         coalesced_buffer_alignment: Alignment,
-        metrics: VortexMetrics,
+        metrics: RequestMetrics,
     ) -> Self
     where
         S: Stream<Item = ReadEvent> + Unpin + Send + 'static,
@@ -118,33 +115,17 @@ struct State {
     requests_by_offset: BTreeSet<(u64, RequestId)>,
 
     // Metrics for tracking I/O request patterns
-    metrics: StateMetrics,
+    metrics: RequestMetrics,
     coalesced_buffer_alignment: Alignment,
 }
 
-struct StateMetrics {
-    individual_requests: Arc<Counter>,
-    coalesced_requests: Arc<Counter>,
-    num_requests_coalesced: Arc<Histogram>,
-}
-
-impl StateMetrics {
-    fn new(registry: VortexMetrics) -> Self {
-        Self {
-            individual_requests: registry.counter("io.requests.individual"),
-            coalesced_requests: registry.counter("io.requests.coalesced"),
-            num_requests_coalesced: registry.histogram("io.requests.coalesced.num_coalesced"),
-        }
-    }
-}
-
 impl State {
-    fn new(metrics: VortexMetrics, coalesced_buffer_alignment: Alignment) -> Self {
+    fn new(metrics: RequestMetrics, coalesced_buffer_alignment: Alignment) -> Self {
         Self {
             requests: BTreeMap::new(),
             polled_requests: BTreeMap::new(),
             requests_by_offset: BTreeSet::new(),
-            metrics: StateMetrics::new(metrics),
+            metrics,
             coalesced_buffer_alignment,
         }
     }
@@ -179,17 +160,17 @@ impl State {
     fn next(&mut self, coalesce_window: Option<&CoalesceConfig>) -> Option<IoRequest> {
         match coalesce_window {
             None => self.next_uncoalesced().map(|request| {
-                self.metrics.individual_requests.inc();
+                self.metrics.individual_requests.add(1);
                 IoRequest::new_single(request)
             }),
             Some(window) => self.next_coalesced(window).map(|request| {
                 match request.requests.len() {
-                    1 => self.metrics.individual_requests.inc(),
+                    1 => self.metrics.individual_requests.add(1),
                     num_requests => {
-                        self.metrics.coalesced_requests.inc();
+                        self.metrics.coalesced_requests.add(1);
                         self.metrics
                             .num_requests_coalesced
-                            .update(num_requests as i64);
+                            .update(num_requests as f64);
                     }
                 };
                 IoRequest::new_coalesced(request)
@@ -328,6 +309,9 @@ mod tests {
     use vortex_array::buffer::BufferHandle;
     use vortex_buffer::Alignment;
     use vortex_error::VortexResult;
+    use vortex_metrics::DefaultMetricsRegistry;
+    use vortex_metrics::MetricValue;
+    use vortex_metrics::MetricsRegistry;
 
     use super::*;
     use crate::read::request::IoRequestInner;
@@ -363,7 +347,8 @@ mod tests {
         coalesced_buffer_alignment: Alignment,
     ) -> Vec<IoRequest> {
         let event_stream = stream::iter(events);
-        let metrics = VortexMetrics::default();
+        let metrics_registry = DefaultMetricsRegistry::default();
+        let metrics = RequestMetrics::new(&metrics_registry, vec![]);
         let io_stream = IoRequestStream::new(
             event_stream,
             coalesce_window,
@@ -681,7 +666,8 @@ mod tests {
         ];
 
         let event_stream = stream::iter(events);
-        let metrics = VortexMetrics::default();
+        let metrics_registry = DefaultMetricsRegistry::default();
+        let metrics = RequestMetrics::new(&metrics_registry, vec![]);
         let io_stream = IoRequestStream::new(
             event_stream,
             Some(CoalesceConfig {
@@ -689,28 +675,28 @@ mod tests {
                 max_size: 1024,
             }),
             Alignment::none(),
-            metrics.clone(),
+            metrics,
         );
 
         let outputs: Vec<IoRequest> = io_stream.collect().await;
         assert_eq!(outputs.len(), 2);
 
-        let snapshot = metrics.snapshot();
-        let mut individual_count = 0i64;
-        let mut coalesced_operations = 0i64;
-        let mut coalesced_histogram_count = 0u64;
-
-        for (metric_id, metric) in snapshot.iter() {
-            match metric {
-                vortex_metrics::Metric::Counter(counter) => {
-                    if metric_id.name() == "io.requests.individual" {
-                        individual_count = counter.count();
-                    } else if metric_id.name() == "io.requests.coalesced" {
-                        coalesced_operations = counter.count();
+        let snapshot = metrics_registry.snapshot();
+        let mut individual_count = 0u64;
+        let mut coalesced_operations = 0u64;
+        let mut coalesced_histogram_count = 0usize;
+
+        for metric in snapshot.iter() {
+            match metric.value() {
+                MetricValue::Counter(counter) => {
+                    if metric.name() == "io.requests.individual" {
+                        individual_count = counter.value();
+                    } else if metric.name() == "io.requests.coalesced" {
+                        coalesced_operations = counter.value();
                     }
                 }
-                vortex_metrics::Metric::Histogram(histogram) => {
-                    if metric_id.name() == "io.requests.coalesced.num_coalesced" {
+                MetricValue::Histogram(histogram) => {
+                    if metric.name() == "io.requests.coalesced.num_coalesced" {
                         coalesced_histogram_count = histogram.count();
                     }
                 }
@@ -740,25 +726,25 @@ mod tests {
         ];
 
         let event_stream = stream::iter(events);
-        let metrics = VortexMetrics::default();
+        let metrics_registry = DefaultMetricsRegistry::default();
+        let metrics = RequestMetrics::new(&metrics_registry, vec![]);
         // No coalescing window - should be individual requests
-        let io_stream =
-            IoRequestStream::new(event_stream, None, Alignment::none(), metrics.clone());
+        let io_stream = IoRequestStream::new(event_stream, None, Alignment::none(), metrics);
 
         let outputs: Vec<IoRequest> = io_stream.collect().await;
         assert_eq!(outputs.len(), 2);
 
         // Check metrics
-        let snapshot = metrics.snapshot();
-        let mut individual_count = 0i64;
-        let mut coalesced_operations = 0i64;
-
-        for (metric_id, metric) in snapshot.iter() {
-            if let vortex_metrics::Metric::Counter(counter) = metric {
-                if metric_id.name() == "io.requests.individual" {
-                    individual_count = counter.count();
-                } else if metric_id.name() == "io.requests.coalesced.num_coalesced" {
-                    coalesced_operations = counter.count();
+        let snapshot = metrics_registry.snapshot();
+        let mut individual_count = 0_u64;
+        let mut coalesced_operations = 0_u64;
+
+        for metric in snapshot.iter() {
+            if let MetricValue::Counter(counter) = metric.value() {
+                if metric.name() == "io.requests.individual" {
+                    individual_count = counter.value();
+                } else if metric.name() == "io.requests.coalesced.num_coalesced" {
+                    coalesced_operations = counter.value();
                 }
             }
         }
diff --git a/vortex-file/src/segments/source.rs b/vortex-file/src/segments/source.rs
index 344f805f516..479d0f212ad 100644
--- a/vortex-file/src/segments/source.rs
+++ b/vortex-file/src/segments/source.rs
@@ -21,7 +21,11 @@ use vortex_io::runtime::Handle;
 use vortex_layout::segments::SegmentFuture;
 use vortex_layout::segments::SegmentId;
 use vortex_layout::segments::SegmentSource;
-use vortex_metrics::VortexMetrics;
+use vortex_metrics::Counter;
+use vortex_metrics::Histogram;
+use vortex_metrics::Label;
+use vortex_metrics::MetricBuilder;
+use vortex_metrics::MetricsRegistry;
 
 use crate::SegmentSpec;
 use crate::read::IoRequestStream;
@@ -69,7 +73,7 @@ impl FileSegmentSource {
         segments: Arc<[SegmentSpec]>,
         reader: R,
         handle: Handle,
-        metrics: VortexMetrics,
+        metrics: RequestMetrics,
     ) -> Self {
         let (send, recv) = mpsc::unbounded();
 
@@ -87,15 +91,15 @@ impl FileSegmentSource {
         });
         let concurrency = reader.concurrency();
 
-        let drive_fut = async move {
-            let stream = IoRequestStream::new(
-                StreamExt::boxed(recv),
-                coalesce_config,
-                max_alignment,
-                metrics,
-            )
-            .boxed();
+        let stream = IoRequestStream::new(
+            StreamExt::boxed(recv),
+            coalesce_config,
+            max_alignment,
+            metrics,
+        )
+        .boxed();
 
+        let drive_fut = async move {
             stream
                 .map(move |req| {
                     let reader = reader.clone();
@@ -203,3 +207,25 @@ impl Drop for ReadFuture {
         drop(self.events.unbounded_send(ReadEvent::Dropped(self.id)));
     }
 }
+
+pub struct RequestMetrics {
+    pub individual_requests: Counter,
+    pub coalesced_requests: Counter,
+    pub num_requests_coalesced: Histogram,
+}
+
+impl RequestMetrics {
+    pub fn new(metrics_registry: &dyn MetricsRegistry, labels: Vec<Label>) -> Self {
+        Self {
+            individual_requests: MetricBuilder::new(metrics_registry)
+                .add_labels(labels.clone())
+                .counter("io.requests.individual"),
+            coalesced_requests: MetricBuilder::new(metrics_registry)
+                .add_labels(labels.clone())
+                .counter("io.requests.coalesced"),
+            num_requests_coalesced: MetricBuilder::new(metrics_registry)
+                .add_labels(labels)
+                .histogram("io.requests.coalesced.num_coalesced"),
+        }
+    }
+}
diff --git a/vortex-file/src/tests.rs b/vortex-file/src/tests.rs
index a3932c1756a..f8c4d6c171c 100644
--- a/vortex-file/src/tests.rs
+++ b/vortex-file/src/tests.rs
@@ -64,7 +64,6 @@ use vortex_dtype::datetime::TimestampOptions;
 use vortex_error::VortexResult;
 use vortex_io::session::RuntimeSession;
 use vortex_layout::session::LayoutSession;
-use vortex_metrics::VortexMetrics;
 use vortex_scalar::Scalar;
 use vortex_scan::ScanBuilder;
 use vortex_session::VortexSession;
@@ -77,7 +76,6 @@ use crate::WriteOptionsSessionExt;
 
 static SESSION: LazyLock<VortexSession> = LazyLock::new(|| {
     let mut session = VortexSession::empty()
-        .with::<VortexMetrics>()
         .with::<ArraySession>()
         .with::<LayoutSession>()
         .with::<ExprSession>()
diff --git a/vortex-file/tests/test_write_table.rs b/vortex-file/tests/test_write_table.rs
index 4821e9962e6..360d07f4262 100644
--- a/vortex-file/tests/test_write_table.rs
+++ b/vortex-file/tests/test_write_table.rs
@@ -25,12 +25,10 @@ use vortex_layout::layouts::compressed::CompressingStrategy;
 use vortex_layout::layouts::flat::writer::FlatLayoutStrategy;
 use vortex_layout::layouts::table::TableStrategy;
 use vortex_layout::session::LayoutSession;
-use vortex_metrics::VortexMetrics;
 use vortex_session::VortexSession;
 
 static SESSION: LazyLock<VortexSession> = LazyLock::new(|| {
     let mut session = VortexSession::empty()
-        .with::<VortexMetrics>()
         .with::<ArraySession>()
         .with::<LayoutSession>()
         .with::<ExprSession>()
diff --git a/vortex-io/src/read.rs b/vortex-io/src/read.rs
index dbae9415e61..39c047146d3 100644
--- a/vortex-io/src/read.rs
+++ b/vortex-io/src/read.rs
@@ -13,8 +13,10 @@ use vortex_error::VortexResult;
 use vortex_error::vortex_bail;
 use vortex_metrics::Counter;
 use vortex_metrics::Histogram;
+use vortex_metrics::Label;
+use vortex_metrics::MetricBuilder;
+use vortex_metrics::MetricsRegistry;
 use vortex_metrics::Timer;
-use vortex_metrics::VortexMetrics;
 
 /// Configuration for coalescing nearby I/O requests into single operations.
 #[derive(Clone, Copy, Debug)]
@@ -136,12 +138,6 @@ impl<R: VortexReadAt> VortexReadAt for Arc<R> {
     ) -> BoxFuture<'static, VortexResult<BufferHandle>> {
         self.as_ref().read_at(offset, length, alignment)
     }
-
-    // fn drive(self: Arc<Self>, requests: BoxStream<'static, IoRequest>) -> BoxFuture<'static, ()> {
-    //     // Delegate to the inner implementation's drive
-    //     let inner: Arc<R> = Arc::clone(&self);
-    //     inner.drive(requests)
-    // }
 }
 
 impl VortexReadAt for ByteBuffer {
@@ -185,46 +181,90 @@ impl VortexReadAt for ByteBuffer {
 #[derive(Clone)]
 pub struct InstrumentedReadAt<T: VortexReadAt + Clone> {
     read: T,
-    sizes: Arc<Histogram>,
-    total_size: Arc<Counter>,
-    durations: Arc<Timer>,
+    // We use `Arc` to take care of all the complexity that's potentially associated with reference counting
+    // and dropping
+    metrics: Arc<InnerMetrics>,
+}
+
+struct InnerMetrics {
+    sizes: Histogram,
+    total_size: Counter,
+    durations: Timer,
 }
 
 impl<T: VortexReadAt + Clone> InstrumentedReadAt<T> {
-    pub fn new(read: T, metrics: &VortexMetrics) -> Self {
+    pub fn new(read: T, metrics_registry: &dyn MetricsRegistry) -> Self {
+        Self::new_with_labels(read, metrics_registry, Vec::<Label>::default())
+    }
+
+    pub fn new_with_labels<I, L>(read: T, metrics_registry: &dyn MetricsRegistry, labels: I) -> Self
+    where
+        I: IntoIterator<Item = L>,
+        L: Into<Label>,
+    {
+        let labels = labels.into_iter().map(|l| l.into()).collect::<Vec<Label>>();
+        let sizes = MetricBuilder::new(metrics_registry)
+            .add_labels(labels.clone())
+            .histogram("vortex.io.read.size");
+        let total_size = MetricBuilder::new(metrics_registry)
+            .add_labels(labels.clone())
+            .counter("vortex.io.read.total_size");
+        let durations = MetricBuilder::new(metrics_registry)
+            .add_labels(labels)
+            .timer("vortex.io.read.duration");
+
         Self {
             read,
-            sizes: metrics.histogram("vortex.io.read.size"),
-            total_size: metrics.counter("vortex.io.read.total_size"),
-            durations: metrics.timer("vortex.io.read.duration"),
+            metrics: Arc::new(InnerMetrics {
+                sizes,
+                total_size,
+                durations,
+            }),
         }
     }
 }
 
-impl<T: VortexReadAt + Clone> Drop for InstrumentedReadAt<T> {
+// We implement drop for `InnerMetrics` so this will be logged only when we eventually drop the final instance of `InstrumentedRead`
+impl Drop for InnerMetrics {
     #[allow(clippy::cognitive_complexity)]
     fn drop(&mut self) {
-        let sizes = self.sizes.snapshot();
         tracing::debug!("Reads: {}", self.sizes.count());
-        tracing::debug!(
-            "Read size: p50={} p95={} p99={} p999={}",
-            sizes.value(0.5),
-            sizes.value(0.95),
-            sizes.value(0.99),
-            sizes.value(0.999),
-        );
-
-        let total_size = self.total_size.count();
+        if !self.sizes.is_empty() {
+            tracing::debug!(
+                "Read size: p50={} p95={} p99={} p999={}",
+                self.sizes.quantile(0.5).vortex_expect("must not be empty"),
+                self.sizes.quantile(0.95).vortex_expect("must not be empty"),
+                self.sizes.quantile(0.99).vortex_expect("must not be empty"),
+                self.sizes
+                    .quantile(0.999)
+                    .vortex_expect("must not be empty"),
+            );
+        }
+
+        let total_size = self.total_size.value();
         tracing::debug!("Total read size: {total_size}");
 
-        let durations = self.durations.snapshot();
-        tracing::debug!(
-            "Read duration: p50={}ms p95={}ms p99={}ms p999={}ms",
-            durations.value(0.5) / 1_000_000.0,
-            durations.value(0.95) / 1_000_000.0,
-            durations.value(0.99) / 1_000_000.0,
-            durations.value(0.999) / 1_000_000.0
-        );
+        if !self.durations.is_empty() {
+            tracing::debug!(
+                "Read duration: p50={}ms p95={}ms p99={}ms p999={}ms",
+                self.durations
+                    .quantile(0.5)
+                    .vortex_expect("must not be empty")
+                    .as_millis(),
+                self.durations
+                    .quantile(0.95)
+                    .vortex_expect("must not be empty")
+                    .as_millis(),
+                self.durations
+                    .quantile(0.99)
+                    .vortex_expect("must not be empty")
+                    .as_millis(),
+                self.durations
+                    .quantile(0.999)
+                    .vortex_expect("must not be empty")
+                    .as_millis(),
+            );
+        }
     }
 }
 
@@ -251,15 +291,16 @@ impl<T: VortexReadAt + Clone> VortexReadAt for InstrumentedReadAt<T> {
         length: usize,
         alignment: Alignment,
     ) -> BoxFuture<'static, VortexResult<BufferHandle>> {
-        let durations = self.durations.clone();
-        let sizes = self.sizes.clone();
-        let total_size = self.total_size.clone();
+        let durations = self.metrics.durations.clone();
+        let sizes = self.metrics.sizes.clone();
+        let total_size = self.metrics.total_size.clone();
+
         let read_fut = self.read.read_at(offset, length, alignment);
         async move {
             let _timer = durations.time();
             let buf = read_fut.await;
-            sizes.update(length as i64);
-            total_size.add(length as i64);
+            sizes.update(length as f64);
+            total_size.add(length as u64);
             buf
         }
         .boxed()
diff --git a/vortex-layout/src/segments/cache.rs b/vortex-layout/src/segments/cache.rs
index 9bcb4db32a3..174c6b1e637 100644
--- a/vortex-layout/src/segments/cache.rs
+++ b/vortex-layout/src/segments/cache.rs
@@ -14,7 +14,9 @@ use vortex_buffer::ByteBuffer;
 use vortex_error::VortexExpect;
 use vortex_error::VortexResult;
 use vortex_metrics::Counter;
-use vortex_metrics::VortexMetrics;
+use vortex_metrics::Label;
+use vortex_metrics::MetricBuilder;
+use vortex_metrics::MetricsRegistry;
 
 use crate::segments::SegmentFuture;
 use crate::segments::SegmentId;
@@ -73,40 +75,51 @@ impl SegmentCache for MokaSegmentCache {
     }
 }
 
-pub struct SegmentCacheMetrics<C> {
+/// Wrapper for [`SegmentCache`] that tracks its hit rate.
+pub struct InstrumentedSegmentCache<C> {
     segment_cache: C,
 
-    hits: Arc<Counter>,
-    misses: Arc<Counter>,
-    stores: Arc<Counter>,
+    hits: Counter,
+    misses: Counter,
+    stores: Counter,
 }
 
-impl<C: SegmentCache> SegmentCacheMetrics<C> {
-    pub fn new(segment_cache: C, metrics: VortexMetrics) -> Self {
+impl<C: SegmentCache> InstrumentedSegmentCache<C> {
+    pub fn new(
+        segment_cache: C,
+        metrics_registry: &dyn MetricsRegistry,
+        labels: Vec<Label>,
+    ) -> Self {
         Self {
             segment_cache,
-            hits: metrics.counter("vortex.file.segments.cache.hits"),
-            misses: metrics.counter("vortex.file.segments.cache.misses"),
-            stores: metrics.counter("vortex.file.segments.cache.stores"),
+            hits: MetricBuilder::new(metrics_registry)
+                .add_labels(labels.clone())
+                .counter("vortex.file.segments.cache.hits"),
+            misses: MetricBuilder::new(metrics_registry)
+                .add_labels(labels.clone())
+                .counter("vortex.file.segments.cache.misses"),
+            stores: MetricBuilder::new(metrics_registry)
+                .add_labels(labels)
+                .counter("vortex.file.segments.cache.stores"),
         }
     }
 }
 
 #[async_trait]
-impl<C: SegmentCache> SegmentCache for SegmentCacheMetrics<C> {
+impl<C: SegmentCache> SegmentCache for InstrumentedSegmentCache<C> {
     async fn get(&self, id: SegmentId) -> VortexResult<Option<ByteBuffer>> {
         let result = self.segment_cache.get(id).await?;
         if result.is_some() {
-            self.hits.inc()
+            self.hits.add(1);
         } else {
-            self.misses.inc()
+            self.misses.add(1);
         }
         Ok(result)
     }
 
     async fn put(&self, id: SegmentId, buffer: ByteBuffer) -> VortexResult<()> {
         self.segment_cache.put(id, buffer).await?;
-        self.stores.inc();
+        self.stores.add(1);
         Ok(())
     }
 }
diff --git a/vortex-layout/src/test.rs b/vortex-layout/src/test.rs
index 47ebfa594eb..736b487db9f 100644
--- a/vortex-layout/src/test.rs
+++ b/vortex-layout/src/test.rs
@@ -6,14 +6,12 @@ use std::sync::LazyLock;
 use vortex_array::expr::session::ExprSession;
 use vortex_array::session::ArraySession;
 use vortex_io::session::RuntimeSession;
-use vortex_metrics::VortexMetrics;
 use vortex_session::VortexSession;
 
 use crate::session::LayoutSession;
 
 pub static SESSION: LazyLock<VortexSession> = LazyLock::new(|| {
     VortexSession::empty()
-        .with::<VortexMetrics>()
         .with::<ArraySession>()
         .with::<LayoutSession>()
         .with::<ExprSession>()
diff --git a/vortex-metrics/Cargo.toml b/vortex-metrics/Cargo.toml
index 59eeeb884c4..749701cd183 100644
--- a/vortex-metrics/Cargo.toml
+++ b/vortex-metrics/Cargo.toml
@@ -16,8 +16,8 @@ version = { workspace = true }
 [dependencies]
 getrandom_v03 = { workspace = true }
 parking_lot = { workspace = true }
+sketches-ddsketch = { workspace = true }
 vortex-session = { workspace = true }
-witchcraft-metrics = { workspace = true }
 
 [lints]
 workspace = true
diff --git a/vortex-metrics/src/counter.rs b/vortex-metrics/src/counter.rs
new file mode 100644
index 00000000000..fda03b277dd
--- /dev/null
+++ b/vortex-metrics/src/counter.rs
@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use std::sync::Arc;
+use std::sync::atomic::AtomicU64;
+use std::sync::atomic::Ordering;
+
+/// A commutative value that can only be increased, and starts at 0 on initialization.
+#[derive(Clone, Debug)]
+pub struct Counter(Arc<AtomicU64>);
+
+impl Counter {
+    pub(crate) fn new() -> Self {
+        Self(Default::default())
+    }
+
+    /// Adds `value` to the counter
+    pub fn add(&self, value: u64) {
+        self.0.fetch_add(value, Ordering::Release);
+    }
+
+    /// Returns the latest value stored in the counter
+    pub fn value(&self) -> u64 {
+        self.0.load(Ordering::Acquire)
+    }
+}
diff --git a/vortex-metrics/src/gauge.rs b/vortex-metrics/src/gauge.rs
new file mode 100644
index 00000000000..88d2a928f05
--- /dev/null
+++ b/vortex-metrics/src/gauge.rs
@@ -0,0 +1,65 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+use std::sync::Arc;
+use std::sync::atomic::AtomicU64;
+use std::sync::atomic::Ordering;
+
+/// A gauge metric that can increase or decrease, representing a single value at the point of sampling.
+#[derive(Clone)]
+pub struct Gauge(Arc<AtomicU64>);
+
+impl std::fmt::Debug for Gauge {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_tuple("Gauge").field(&self.value()).finish()
+    }
+}
+
+impl Gauge {
+    pub(crate) fn new() -> Self {
+        Self(Default::default())
+    }
+
+    /// Increment the gauge by value.
+    pub fn increment(&self, value: f64) {
+        loop {
+            if self
+                .0
+                .fetch_update(Ordering::AcqRel, Ordering::Relaxed, |current| {
+                    let input = f64::from_bits(current);
+                    Some((input + value).to_bits())
+                })
+                .is_ok()
+            {
+                break;
+            }
+        }
+    }
+
+    /// Decrement the gauge by value.
+    pub fn decrement(&self, value: f64) {
+        loop {
+            if self
+                .0
+                .fetch_update(Ordering::AcqRel, Ordering::Relaxed, |current| {
+                    let input = f64::from_bits(current);
+                    Some((input - value).to_bits())
+                })
+                .is_ok()
+            {
+                break;
+            }
+        }
+    }
+
+    /// Sets the gauge to a specific value.
+    pub fn set(&self, value: f64) {
+        _ = self.0.swap(value.to_bits(), Ordering::AcqRel);
+    }
+
+    /// Returns the current value of the gauge.
+    pub fn value(&self) -> f64 {
+        let value = self.0.load(Ordering::Relaxed);
+        f64::from_bits(value)
+    }
+}
diff --git a/vortex-metrics/src/histogram.rs b/vortex-metrics/src/histogram.rs
new file mode 100644
index 00000000000..353f78f7592
--- /dev/null
+++ b/vortex-metrics/src/histogram.rs
@@ -0,0 +1,62 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+#![allow(clippy::expect_used)]
+#![allow(clippy::unwrap_in_result)]
+
+use std::sync::Arc;
+
+use parking_lot::RwLock;
+use sketches_ddsketch::DDSketch;
+
+/// Stores an arbitrary number of data points, giving approximated information about its distribution.
+/// The current implementation uses an implementation of the [DDSketch] type but that might change in the future.
+///
+/// [DDSketch]: https://arxiv.org/pdf/1908.10693
+#[derive(Default, Clone)]
+pub struct Histogram(Arc<RwLock<DDSketch>>);
+
+impl std::fmt::Debug for Histogram {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_tuple("Histogram").finish_non_exhaustive()
+    }
+}
+
+impl Histogram {
+    pub(crate) fn new() -> Self {
+        Self(Default::default())
+    }
+
+    /// Adds a sample to the histogram
+    pub fn update(&self, value: f64) {
+        self.0.write().add(value);
+    }
+
+    /// Returns the estimated quantile value, which must be in the [0.0, 1.0] range, will panic otherwise.
+    /// Returns `None` if the histogram is empty.
+    pub fn quantile(&self, quantile: f64) -> Option<f64> {
+        assert!(
+            (0.0..=1.0).contains(&quantile),
+            "quantile must be between 0.0 and 1.0"
+        );
+        self.0
+            .read()
+            .quantile(quantile)
+            .expect("quantile range checked")
+    }
+
+    /// Returns the sum of all values stored in the histogram
+    pub fn total(&self) -> f64 {
+        self.0.read().sum().unwrap_or_default()
+    }
+
+    /// Returns the number of values recorded.
+    pub fn count(&self) -> usize {
+        self.0.read().count()
+    }
+
+    /// Returns true if the histogram contains 0 samples.
+    pub fn is_empty(&self) -> bool {
+        self.0.read().count() == 0
+    }
+}
diff --git a/vortex-metrics/src/lib.rs b/vortex-metrics/src/lib.rs
index c875d6680c8..225bd3fd5a6 100644
--- a/vortex-metrics/src/lib.rs
+++ b/vortex-metrics/src/lib.rs
@@ -6,300 +6,254 @@
 //! Vortex metrics
 
 use std::borrow::Cow;
-use std::collections::BTreeMap;
-use std::fmt::Debug;
-use std::fmt::Formatter;
 use std::sync::Arc;
 
-use parking_lot::RwLock;
-use witchcraft_metrics::MetricRegistry;
-use witchcraft_metrics::Metrics;
-use witchcraft_metrics::MetricsIter;
+use parking_lot::Mutex;
 
-/// A metric registry for various performance metrics.
-#[derive(Default, Clone)]
-pub struct VortexMetrics {
-    inner: Arc<Inner>,
-}
+mod counter;
+mod gauge;
+mod histogram;
+mod timer;
+
+pub use counter::*;
+pub use gauge::*;
+pub use histogram::*;
+pub use timer::*;
 
-#[derive(Default)]
-struct Inner {
-    registry: MetricRegistry,
-    default_tags: DefaultTags,
-    children: RwLock<Vec<VortexMetrics>>,
+/// A metric KV label.
+#[derive(Clone, Debug)]
+pub struct Label {
+    key: Cow<'static, str>,
+    value: Cow<'static, str>,
 }
 
-impl Debug for VortexMetrics {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("VortexMetrics")
-            .field("default_tags", &self.inner.default_tags)
-            .field("children", &self.inner.children)
-            .finish_non_exhaustive()
+impl std::fmt::Display for Label {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}={}", self.key, self.value)
     }
 }
 
-// re-export exposed metric types
-pub use witchcraft_metrics::Counter;
-pub use witchcraft_metrics::Histogram;
-pub use witchcraft_metrics::Metric;
-pub use witchcraft_metrics::MetricId;
-pub use witchcraft_metrics::Tags;
-pub use witchcraft_metrics::Timer;
-
-/// Default tags for metrics used in [`VortexMetrics`].
-#[derive(Default, Clone, Debug)]
-pub struct DefaultTags(BTreeMap<Cow<'static, str>, Cow<'static, str>>);
-
-impl<K, V, I> From<I> for DefaultTags
+impl<K, V> From<(K, V)> for Label
 where
-    I: IntoIterator<Item = (K, V)>,
     K: Into<Cow<'static, str>>,
     V: Into<Cow<'static, str>>,
 {
-    fn from(pairs: I) -> Self {
-        DefaultTags(
-            pairs
-                .into_iter()
-                .map(|(k, v)| (k.into(), v.into()))
-                .collect(),
-        )
+    fn from(value: (K, V)) -> Self {
+        Label::new(value.0, value.1)
     }
 }
 
-impl VortexMetrics {
-    /// Create a new [`VortexMetrics`] instance.
-    pub fn new(registry: MetricRegistry, default_tags: impl Into<DefaultTags>) -> Self {
-        let inner = Arc::new(Inner {
-            registry,
-            default_tags: default_tags.into(),
-            children: Default::default(),
-        });
-        Self { inner }
+impl Label {
+    /// Creates a new label
+    pub fn new(key: impl Into<Cow<'static, str>>, value: impl Into<Cow<'static, str>>) -> Self {
+        Self {
+            key: key.into(),
+            value: value.into(),
+        }
     }
 
-    /// Create an empty metric registry with default tags.
-    pub fn new_with_tags(default_tags: impl Into<DefaultTags>) -> Self {
-        Self::new(MetricRegistry::default(), default_tags)
+    /// Returns the label's key
+    pub fn key(&self) -> &str {
+        &self.key
     }
 
-    /// Create a new metrics registry with additional tags. Metrics created in the
-    /// child registry will be included in this registry's snapshots.
-    pub fn child_with_tags(&self, additional_tags: impl Into<DefaultTags>) -> Self {
-        let child = Self::new_with_tags(self.inner.default_tags.merge(&additional_tags.into()));
-        self.inner.children.write().push(child.clone());
-        child
+    /// Returns the label's value
+    pub fn value(&self) -> &str {
+        &self.value
     }
+}
 
-    /// Returns the counter with the specified ID, creating a default instance if absent.
-    ///
-    /// # Panics
-    ///
-    /// Panics if a metric is registered with the ID that is not a counter.
-    pub fn counter<T>(&self, id: T) -> Arc<Counter>
-    where
-        T: Into<MetricId>,
-    {
-        self.inner.registry.counter(id)
+/// A registry for metrics that allows creating and storing metrics with labels.
+///
+/// Both metrics and labels might not be unique, and its up to users to resolve such cases.
+pub trait MetricsRegistry: Send + Sync {
+    /// Create a counter with the given name and labels.
+    fn register_counter(&self, name: Cow<'static, str>, labels: Vec<Label>) -> Counter;
+
+    /// Create a histogram with the given name and labels.
+    fn register_histogram(&self, name: Cow<'static, str>, labels: Vec<Label>) -> Histogram;
+
+    /// Create a timer with the given name and labels.
+    fn register_timer(&self, name: Cow<'static, str>, labels: Vec<Label>) -> Timer;
+
+    /// Create a gauge with the given name and labels.
+    fn register_gauge(&self, name: Cow<'static, str>, labels: Vec<Label>) -> Gauge;
+
+    /// Returns a snapshot of the current metric values stored in the registry.
+    /// Metrics might not be unique.
+    fn snapshot(&self) -> Vec<Metric>;
+}
+
+/// Builder for creating metrics with labels.
+pub struct MetricBuilder<'s> {
+    labels: Vec<Label>,
+    registry: &'s dyn MetricsRegistry,
+}
+
+impl<'r> MetricBuilder<'r> {
+    /// Create a new builder for a metric backed by a [`MetricsRegistry`].
+    pub fn new(registry: &'r dyn MetricsRegistry) -> Self {
+        Self {
+            labels: vec![],
+            registry,
+        }
     }
 
-    /// Returns the histogram with the specified ID, creating a default instance if absent.
-    ///
-    /// # Panics
-    ///
-    /// Panics if a metric is registered with the ID that is not a histogram.
-    pub fn histogram<T>(&self, id: T) -> Arc<Histogram>
+    /// Add a label to the metric. Labels might not be unique, and its up to consumers of this data to resolve such cases.
+    pub fn add_label<K, V>(mut self, key: K, value: V) -> Self
     where
-        T: Into<MetricId>,
+        K: Into<Cow<'static, str>>,
+        V: Into<Cow<'static, str>>,
     {
-        self.inner.registry.histogram(id)
+        self.labels.push(Label::new(key, value));
+        self
     }
 
-    /// Returns the timer with the specified ID, creating a default instance if absent.
-    ///
-    /// # Panics
-    ///
-    /// Panics if a metric is registered with the ID that is not a timer.
-    pub fn timer<T>(&self, id: T) -> Arc<Timer>
+    /// Adds multiple labels to the metric. Labels might not be unique, and its up to consumers of this data to resolve such cases.
+    pub fn add_labels<I, L>(mut self, labels: I) -> Self
     where
-        T: Into<MetricId>,
+        I: IntoIterator<Item = L>,
+        L: Into<Label>,
     {
-        self.inner.registry.timer(id)
+        self.labels.extend(labels.into_iter().map(|l| l.into()));
+        self
     }
 
-    /// Returns a snapshot of the metrics in the registry.
-    ///
-    /// Modifications to the registry after this method is called will not affect the state of the returned `MetricsSnapshot`.
-    ///
-    /// Note: Tag values may contain sensitive information and should be properly sanitized before external exposure.
-    pub fn snapshot(&self) -> MetricsSnapshot {
-        let children = self.inner.children.read();
-        let snapshots = children.iter().map(|c| c.snapshot());
-        MetricsSnapshot(
-            std::iter::once((
-                self.inner.default_tags.clone(),
-                self.inner.registry.metrics(),
-            ))
-            .chain(snapshots.flat_map(|snapshots| snapshots.0.into_iter()))
-            .collect(),
-        )
+    /// Creates a new [`Counter`] with the given name, registering it with the backend.
+    pub fn counter(self, name: impl Into<Cow<'static, str>>) -> Counter {
+        self.registry.register_counter(name.into(), self.labels)
     }
-}
 
-/// A snapshot of the metrics in a registry with default tags.
-pub struct MetricsSnapshot(Vec<(DefaultTags, Metrics)>);
-
-impl MetricsSnapshot {
-    /// Create an iterator over the metrics snapshot.
-    pub fn iter(&self) -> impl Iterator<Item = (MetricId, &Metric)> {
-        self.0
-            .iter()
-            .flat_map(|(default_tags, metrics)| VortexMetricsIter {
-                iter: metrics.iter(),
-                default_tags,
-            })
+    /// Creates a new [`Histogram`] with the given name, registering it with the backend.
+    pub fn histogram(self, name: impl Into<Cow<'static, str>>) -> Histogram {
+        self.registry.register_histogram(name.into(), self.labels)
+    }
+
+    /// Creates a new [`Timer`] with the given name, registering it with the backend.
+    pub fn timer(self, name: impl Into<Cow<'static, str>>) -> Timer {
+        self.registry.register_timer(name.into(), self.labels)
     }
-}
 
-/// Metrics Iterator that applies the default tags to each metric in the inner iterator.
-pub struct VortexMetricsIter<'a> {
-    iter: MetricsIter<'a>,
-    default_tags: &'a DefaultTags,
+    /// Creates a new [`Gauge`] with the given name, registering it with the backend.
+    pub fn gauge(self, name: impl Into<Cow<'static, str>>) -> Gauge {
+        self.registry.register_gauge(name.into(), self.labels)
+    }
 }
 
-impl<'a> Iterator for VortexMetricsIter<'a> {
-    type Item = (MetricId, &'a Metric);
+/// Default metrics registry, stores all state in-memory.
+#[derive(Default, Clone)]
+pub struct DefaultMetricsRegistry {
+    inner: Arc<Mutex<Vec<Metric>>>,
+}
 
-    #[inline]
-    fn next(&mut self) -> Option<(MetricId, &'a Metric)> {
-        self.iter.next().map(|(k, v)| {
-            let mut metric_id = k.clone();
-            for (tag_key, tag_value) in self.default_tags.0.iter() {
-                metric_id = metric_id.with_tag(tag_key.clone(), tag_value.clone())
-            }
+#[derive(Clone, Debug)]
+/// The value of a metric.
+pub enum MetricValue {
+    /// Counter value
+    Counter(Counter),
+    /// Histogram value
+    Histogram(Histogram),
+    /// Timer value
+    Timer(Timer),
+    /// Gauge value
+    Gauge(Gauge),
+}
 
-            (metric_id, v)
-        })
+impl From<Counter> for MetricValue {
+    fn from(value: Counter) -> Self {
+        Self::Counter(value)
     }
+}
 
-    #[inline]
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        self.iter.size_hint()
+impl From<Histogram> for MetricValue {
+    fn from(value: Histogram) -> Self {
+        Self::Histogram(value)
     }
 }
 
-impl DefaultTags {
-    fn merge(&self, other: &Self) -> Self {
-        DefaultTags(
-            self.0
-                .iter()
-                .chain(other.0.iter())
-                .map(|(k, v)| (k.clone(), v.clone()))
-                .collect(),
-        )
+impl From<Timer> for MetricValue {
+    fn from(value: Timer) -> Self {
+        Self::Timer(value)
     }
 }
 
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_default_tags() -> Result<(), &'static str> {
-        let tags = [("file", "a"), ("partition", "1")];
-        let metrics = VortexMetrics::new_with_tags(tags);
-
-        // Create a metric to verify tags
-        let counter = metrics.counter("test.counter");
-        counter.inc();
-        let snapshot = metrics.snapshot();
-        let (name, metric) = snapshot.iter().next().unwrap();
-        assert_eq!(
-            name,
-            MetricId::new("test.counter")
-                .with_tag("file", "a")
-                .with_tag("partition", "1")
-        );
-        match metric {
-            Metric::Counter(c) => assert_eq!(c.count(), 1),
-            _ => return Err("metric is not a counter"),
-        }
-        Ok(())
+impl From<Gauge> for MetricValue {
+    fn from(value: Gauge) -> Self {
+        Self::Gauge(value)
     }
+}
 
-    #[test]
-    fn test_multiple_children_with_different_tags() -> Result<(), &'static str> {
-        let parent_tags = [("service", "vortex")];
-        let parent = VortexMetrics::new_with_tags(parent_tags);
-
-        let child1_tags = [("instance", "child1")];
-        let child2_tags = [("instance", "child2")];
+/// A stored metric with name, labels, and value.
+#[derive(Clone, Debug)]
+pub struct Metric {
+    name: Cow<'static, str>,
+    labels: Vec<Label>,
+    value: MetricValue,
+}
 
-        let child1 = parent.child_with_tags(child1_tags);
-        let child2 = parent.child_with_tags(child2_tags);
+impl Metric {
+    /// Returns the name of the metric
+    pub fn name(&self) -> &Cow<'static, str> {
+        &self.name
+    }
 
-        // Create same metric in both children
-        let counter1 = child1.counter("test.counter");
-        let counter2 = child2.counter("test.counter");
+    /// Returns the labels assigned to this metric
+    pub fn labels(&self) -> &[Label] {
+        &self.labels
+    }
 
-        counter1.inc();
-        counter2.add(2);
+    /// Returns the current value of the metric
+    pub fn value(&self) -> &MetricValue {
+        &self.value
+    }
+}
 
-        // Verify child1 metrics
-        let child1_snapshot = child1.snapshot();
-        let (name, metric) = child1_snapshot.iter().next().unwrap();
-        assert_eq!(
+impl MetricsRegistry for DefaultMetricsRegistry {
+    fn register_counter(&self, name: Cow<'static, str>, labels: Vec<Label>) -> Counter {
+        let counter = Counter::new();
+        let metric = Metric {
             name,
-            MetricId::new("test.counter")
-                .with_tag("service", "vortex")
-                .with_tag("instance", "child1")
-        );
-        match metric {
-            Metric::Counter(c) => assert_eq!(c.count(), 1),
-            _ => return Err("metric is not a counter"),
-        }
+            labels,
+            value: counter.clone().into(),
+        };
+        self.inner.lock().push(metric);
+        counter
+    }
 
-        // Verify child2 metrics
-        let child2_snapshot = child2.snapshot();
-        let (name, metric) = child2_snapshot.iter().next().unwrap();
-        assert_eq!(
+    fn register_histogram(&self, name: Cow<'static, str>, labels: Vec<Label>) -> Histogram {
+        let histogram = Histogram::new();
+        let metric = Metric {
             name,
-            MetricId::new("test.counter")
-                .with_tag("service", "vortex")
-                .with_tag("instance", "child2")
-        );
-        match metric {
-            Metric::Counter(c) => assert_eq!(c.count(), 2),
-            _ => return Err("metric is not a counter"),
-        }
-        Ok(())
+            labels,
+            value: histogram.clone().into(),
+        };
+        self.inner.lock().push(metric);
+        histogram
     }
 
-    #[test]
-    fn test_tag_overriding() -> Result<(), &'static str> {
-        let parent_tags = [("service", "vortex"), ("environment", "test")];
-        let parent = VortexMetrics::new_with_tags(parent_tags);
-
-        // Child tries to override parent's service tag
-        let child_tags = [("service", "override"), ("instance", "child1")];
-        let child = parent.child_with_tags(child_tags);
-
-        let child_counter = child.counter("test.counter");
-        child_counter.inc();
+    fn register_timer(&self, name: Cow<'static, str>, labels: Vec<Label>) -> Timer {
+        let timer = Timer::new();
+        let metric = Metric {
+            name,
+            labels,
+            value: timer.clone().into(),
+        };
+        self.inner.lock().push(metric);
+        timer
+    }
 
-        // Verify child metrics have the overridden tag value
-        let child_snapshot = child.snapshot();
-        let (name, metric) = child_snapshot.iter().next().unwrap();
-        assert_eq!(
+    fn register_gauge(&self, name: Cow<'static, str>, labels: Vec<Label>) -> Gauge {
+        let gauge = Gauge::new();
+        let metric = Metric {
             name,
-            MetricId::new("test.counter")
-                .with_tag("service", "override")
-                .with_tag("environment", "test")
-                .with_tag("instance", "child1")
-        );
-        match metric {
-            Metric::Counter(c) => assert_eq!(c.count(), 1),
-            _ => return Err("metric is not a counter"),
-        }
-        Ok(())
+            labels,
+            value: gauge.clone().into(),
+        };
+        self.inner.lock().push(metric);
+        gauge
+    }
+
+    fn snapshot(&self) -> Vec<Metric> {
+        self.inner.lock().clone()
     }
 }
diff --git a/vortex-metrics/src/timer.rs b/vortex-metrics/src/timer.rs
new file mode 100644
index 00000000000..98759424ccf
--- /dev/null
+++ b/vortex-metrics/src/timer.rs
@@ -0,0 +1,90 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright the Vortex contributors
+
+#![allow(clippy::expect_used)]
+#![allow(clippy::unwrap_in_result)]
+
+use std::sync::Arc;
+use std::time::Duration;
+use std::time::Instant;
+
+use parking_lot::RwLock;
+use sketches_ddsketch::DDSketch;
+
+/// A specialized histogram for storing timed measurements. Like [`Histogram`], it uses [DDSketch] to store approximated values
+/// but accepts and returns nano-scale durations.
+///
+/// [`Histogram`]: crate::Histogram
+#[derive(Clone, Default)]
+pub struct Timer(Arc<RwLock<DDSketch>>);
+
+impl std::fmt::Debug for Timer {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_tuple("Timer").finish_non_exhaustive()
+    }
+}
+
+impl Timer {
+    pub(crate) fn new() -> Self {
+        Self(Default::default())
+    }
+
+    /// Record a duration.
+    pub fn update(&self, duration: Duration) {
+        self.0.write().add(duration.as_secs_f64());
+    }
+
+    /// Returns the sum of all recorded durations.
+    pub fn total(&self) -> Duration {
+        self.0
+            .read()
+            .sum()
+            .map(Duration::from_secs_f64)
+            .unwrap_or_default()
+    }
+
+    /// Returns the estimated quantile value, which must be in the [0.0, 1.0] range, will panic otherwise.
+    /// Returns `None` if the timer is empty.
+    pub fn quantile(&self, quantile: f64) -> Option<Duration> {
+        assert!(
+            (0.0..=1.0).contains(&quantile),
+            "quantile must be between 0.0 and 1.0"
+        );
+        self.0
+            .read()
+            .quantile(quantile)
+            .expect("quantile range checked")
+            .map(Duration::from_secs_f64)
+    }
+
+    /// Returns the number of values recorded.
+    pub fn count(&self) -> usize {
+        self.0.read().count()
+    }
+
+    /// Returns true if the timer contains 0 samples.
+    pub fn is_empty(&self) -> bool {
+        self.0.read().count() == 0
+    }
+
+    /// Returns a RAII guard that starts measuring time, recording time passed between it being created to being dropped.
+    pub fn time(&self) -> TimeGuard<'_> {
+        TimeGuard {
+            source: self,
+            start: Instant::now(),
+        }
+    }
+}
+
+/// RAII guard attached to a [`Timer`] instance, will record the time passed since its creation when dropped.
+pub struct TimeGuard<'a> {
+    source: &'a Timer,
+    start: Instant,
+}
+
+impl Drop for TimeGuard<'_> {
+    fn drop(&mut self) {
+        let elapsed = self.start.elapsed();
+        self.source.update(elapsed);
+    }
+}
diff --git a/vortex-python/src/file.rs b/vortex-python/src/file.rs
index ee76121485e..eb6f0e51e24 100644
--- a/vortex-python/src/file.rs
+++ b/vortex-python/src/file.rs
@@ -66,9 +66,7 @@ pub fn open(
     let vxf = py.detach(|| {
         TOKIO_RUNTIME.block_on(async move {
             let mut options = SESSION.open_options();
-            if without_segment_cache {
-                options = options.without_segment_cache();
-            } else {
+            if !without_segment_cache {
                 // TODO(ngates): use a globally shared segment cache for all files
                 options = options.with_segment_cache(Arc::new(MokaSegmentCache::new(256 << 20)));
             }
diff --git a/vortex-scan/src/scan_builder.rs b/vortex-scan/src/scan_builder.rs
index af2995d3625..96bbac0db02 100644
--- a/vortex-scan/src/scan_builder.rs
+++ b/vortex-scan/src/scan_builder.rs
@@ -38,7 +38,7 @@ use vortex_io::session::RuntimeSessionExt;
 use vortex_layout::LayoutReader;
 use vortex_layout::LayoutReaderRef;
 use vortex_layout::layouts::row_idx::RowIdxLayoutReader;
-use vortex_metrics::VortexMetrics;
+use vortex_metrics::MetricsRegistry;
 use vortex_session::VortexSession;
 
 use crate::RepeatedScan;
@@ -66,7 +66,7 @@ pub struct ScanBuilder<A> {
     concurrency: usize,
     /// Function to apply to each [`ArrayRef`] within the spawned split tasks.
     map_fn: Arc<dyn Fn(ArrayRef) -> VortexResult<A> + Send + Sync>,
-    metrics: VortexMetrics,
+    metrics_registry: Option<Arc<dyn MetricsRegistry>>,
     /// Should we try to prune the file (using stats) on open.
     file_stats: Option<Arc<[StatsSet]>>,
     /// Maximal number of rows to read (after filtering)
@@ -91,7 +91,7 @@ impl ScanBuilder<ArrayRef> {
             // without too much impact on work-stealing.
             concurrency: 4,
             map_fn: Arc::new(Ok),
-            metrics: Default::default(),
+            metrics_registry: None,
             file_stats: None,
             limit: None,
             row_offset: 0,
@@ -175,8 +175,8 @@ impl<A: 'static + Send> ScanBuilder<A> {
         self
     }
 
-    pub fn with_metrics(mut self, metrics: VortexMetrics) -> Self {
-        self.metrics = metrics;
+    pub fn with_metrics_registry(mut self, metrics: Arc<dyn MetricsRegistry>) -> Self {
+        self.metrics_registry = Some(metrics);
         self
     }
 
@@ -211,7 +211,7 @@ impl<A: 'static + Send> ScanBuilder<A> {
             selection: self.selection,
             split_by: self.split_by,
             concurrency: self.concurrency,
-            metrics: self.metrics,
+            metrics_registry: self.metrics_registry,
             file_stats: self.file_stats,
             limit: self.limit,
             row_offset: self.row_offset,
diff --git a/vortex-scan/src/test.rs b/vortex-scan/src/test.rs
index d150d159716..9afe6aa034f 100644
--- a/vortex-scan/src/test.rs
+++ b/vortex-scan/src/test.rs
@@ -9,12 +9,10 @@ use vortex_io::runtime::Handle;
 use vortex_io::session::RuntimeSession;
 use vortex_io::session::RuntimeSessionExt;
 use vortex_layout::session::LayoutSession;
-use vortex_metrics::VortexMetrics;
 use vortex_session::VortexSession;
 
 pub fn new_session() -> VortexSession {
     VortexSession::empty()
-        .with::<VortexMetrics>()
         .with::<ArraySession>()
         .with::<LayoutSession>()
         .with::<ExprSession>()
diff --git a/vortex/src/lib.rs b/vortex/src/lib.rs
index d6dc3c3d479..e0832209966 100644
--- a/vortex/src/lib.rs
+++ b/vortex/src/lib.rs
@@ -14,7 +14,6 @@ use vortex_array::session::ArraySession;
 use vortex_dtype::session::DTypeSession;
 use vortex_io::session::RuntimeSession;
 use vortex_layout::session::LayoutSession;
-use vortex_metrics::VortexMetrics;
 use vortex_session::VortexSession;
 
 // We re-export like so in order to allow users to search inside subcrates when using the Rust docs.
@@ -155,7 +154,6 @@ impl VortexSessionDefault for VortexSession {
     #[allow(unused_mut)]
     fn default() -> VortexSession {
         let mut session = VortexSession::empty()
-            .with::<VortexMetrics>()
             .with::<DTypeSession>()
             .with::<ArraySession>()
             .with::<LayoutSession>()
diff --git a/wasm-test/.gitignore b/wasm-test/.gitignore
new file mode 100644
index 00000000000..ffa3bbd20ea
--- /dev/null
+++ b/wasm-test/.gitignore
@@ -0,0 +1 @@
+Cargo.lock
\ No newline at end of file
diff --git a/wasm-test/Cargo.lock b/wasm-test/Cargo.lock
deleted file mode 100644
index a3d499787bd..00000000000
--- a/wasm-test/Cargo.lock
+++ /dev/null
@@ -1,2820 +0,0 @@
-# This file is automatically @generated by Cargo.
-# It is not intended for manual editing.
-version = 4
-
-[[package]]
-name = "ahash"
-version = "0.8.12"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5a15f179cd60c4584b8a8c596927aadc462e27f2ca70c04e0071964a73ba7a75"
-dependencies = [
- "cfg-if",
- "const-random",
- "getrandom 0.3.4",
- "once_cell",
- "version_check",
- "zerocopy",
-]
-
-[[package]]
-name = "aho-corasick"
-version = "1.1.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ddd31a130427c27518df266943a5308ed92d4b226cc639f5a8f1002816174301"
-dependencies = [
- "memchr",
-]
-
-[[package]]
-name = "allocator-api2"
-version = "0.2.21"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923"
-
-[[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.100"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a23eb6b1614318a8071c9b2521f36b424b2c83db5eb3a0fead4a6c0809af6e61"
-
-[[package]]
-name = "arcref"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "28f6098a1e8ab66ff91324cce8fea6643101882cf7d09c85acdb1485ecf61e29"
-
-[[package]]
-name = "arrayref"
-version = "0.3.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "76a2e8124351fda1ef8aaaa3bbd7ebbcb486bbcd4225aca0aa0d84bb2db8fecb"
-
-[[package]]
-name = "arrow-arith"
-version = "57.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0f377dcd19e440174596d83deb49cd724886d91060c07fec4f67014ef9d54049"
-dependencies = [
- "arrow-array",
- "arrow-buffer",
- "arrow-data",
- "arrow-schema",
- "chrono",
- "num-traits",
-]
-
-[[package]]
-name = "arrow-array"
-version = "57.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a23eaff85a44e9fa914660fb0d0bb00b79c4a3d888b5334adb3ea4330c84f002"
-dependencies = [
- "ahash",
- "arrow-buffer",
- "arrow-data",
- "arrow-schema",
- "chrono",
- "half",
- "hashbrown 0.16.1",
- "num-complex",
- "num-integer",
- "num-traits",
-]
-
-[[package]]
-name = "arrow-buffer"
-version = "57.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a2819d893750cb3380ab31ebdc8c68874dd4429f90fd09180f3c93538bd21626"
-dependencies = [
- "bytes",
- "half",
- "num-bigint",
- "num-traits",
-]
-
-[[package]]
-name = "arrow-data"
-version = "57.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "05738f3d42cb922b9096f7786f606fcb8669260c2640df8490533bb2fa38c9d3"
-dependencies = [
- "arrow-buffer",
- "arrow-schema",
- "half",
- "num-integer",
- "num-traits",
-]
-
-[[package]]
-name = "arrow-ord"
-version = "57.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cbc94fc7adec5d1ba9e8cd1b1e8d6f72423b33fe978bf1f46d970fafab787521"
-dependencies = [
- "arrow-array",
- "arrow-buffer",
- "arrow-data",
- "arrow-schema",
- "arrow-select",
-]
-
-[[package]]
-name = "arrow-schema"
-version = "57.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d27609cd7dd45f006abae27995c2729ef6f4b9361cde1ddd019dc31a5aa017e0"
-dependencies = [
- "bitflags",
-]
-
-[[package]]
-name = "arrow-select"
-version = "57.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ae980d021879ea119dd6e2a13912d81e64abed372d53163e804dfe84639d8010"
-dependencies = [
- "ahash",
- "arrow-array",
- "arrow-buffer",
- "arrow-data",
- "arrow-schema",
- "num-traits",
-]
-
-[[package]]
-name = "arrow-string"
-version = "57.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cf35e8ef49dcf0c5f6d175edee6b8af7b45611805333129c541a8b89a0fc0534"
-dependencies = [
- "arrow-array",
- "arrow-buffer",
- "arrow-data",
- "arrow-schema",
- "arrow-select",
- "memchr",
- "num-traits",
- "regex",
- "regex-syntax",
-]
-
-[[package]]
-name = "async-channel"
-version = "2.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "924ed96dd52d1b75e9c1a3e6275715fd320f5f9439fb5a4a11fa51f4221158d2"
-dependencies = [
- "concurrent-queue",
- "event-listener-strategy",
- "futures-core",
- "pin-project-lite",
-]
-
-[[package]]
-name = "async-compat"
-version = "0.2.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1ba85bc55464dcbf728b56d97e119d673f4cf9062be330a9a26f3acf504a590"
-dependencies = [
- "futures-core",
- "futures-io",
- "once_cell",
- "pin-project-lite",
- "tokio",
-]
-
-[[package]]
-name = "async-executor"
-version = "1.13.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "497c00e0fd83a72a79a39fcbd8e3e2f055d6f6c7e025f3b3d91f4f8e76527fb8"
-dependencies = [
- "async-task",
- "concurrent-queue",
- "fastrand",
- "futures-lite",
- "pin-project-lite",
- "slab",
-]
-
-[[package]]
-name = "async-fs"
-version = "2.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8034a681df4aed8b8edbd7fbe472401ecf009251c8b40556b304567052e294c5"
-dependencies = [
- "async-lock",
- "blocking",
- "futures-lite",
-]
-
-[[package]]
-name = "async-io"
-version = "2.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "456b8a8feb6f42d237746d4b3e9a178494627745c3c56c6ea55d92ba50d026fc"
-dependencies = [
- "autocfg",
- "cfg-if",
- "concurrent-queue",
- "futures-io",
- "futures-lite",
- "parking",
- "polling",
- "rustix",
- "slab",
- "windows-sys",
-]
-
-[[package]]
-name = "async-lock"
-version = "3.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5fd03604047cee9b6ce9de9f70c6cd540a0520c813cbd49bae61f33ab80ed1dc"
-dependencies = [
- "event-listener",
- "event-listener-strategy",
- "pin-project-lite",
-]
-
-[[package]]
-name = "async-net"
-version = "2.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b948000fad4873c1c9339d60f2623323a0cfd3816e5181033c6a5cb68b2accf7"
-dependencies = [
- "async-io",
- "blocking",
- "futures-lite",
-]
-
-[[package]]
-name = "async-process"
-version = "2.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fc50921ec0055cdd8a16de48773bfeec5c972598674347252c0399676be7da75"
-dependencies = [
- "async-channel",
- "async-io",
- "async-lock",
- "async-signal",
- "async-task",
- "blocking",
- "cfg-if",
- "event-listener",
- "futures-lite",
- "rustix",
-]
-
-[[package]]
-name = "async-signal"
-version = "0.2.13"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "43c070bbf59cd3570b6b2dd54cd772527c7c3620fce8be898406dd3ed6adc64c"
-dependencies = [
- "async-io",
- "async-lock",
- "atomic-waker",
- "cfg-if",
- "futures-core",
- "futures-io",
- "rustix",
- "signal-hook-registry",
- "slab",
- "windows-sys",
-]
-
-[[package]]
-name = "async-stream"
-version = "0.3.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b5a71a6f37880a80d1d7f19efd781e4b5de42c88f0722cc13bcb6cc2cfe8476"
-dependencies = [
- "async-stream-impl",
- "futures-core",
- "pin-project-lite",
-]
-
-[[package]]
-name = "async-stream-impl"
-version = "0.3.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c7c24de15d275a1ecfd47a380fb4d5ec9bfe0933f309ed5e705b775596a3574d"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.111",
-]
-
-[[package]]
-name = "async-task"
-version = "4.7.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8b75356056920673b02621b35afd0f7dda9306d03c79a30f5c56c44cf256e3de"
-
-[[package]]
-name = "async-trait"
-version = "0.1.89"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9035ad2d096bed7955a320ee7e2230574d28fd3c3a0f186cbea1ff3c7eed5dbb"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.111",
-]
-
-[[package]]
-name = "atomic-waker"
-version = "1.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1505bd5d3d116872e7271a6d4e16d81d0c8570876c8de68093a09ac269d8aac0"
-
-[[package]]
-name = "autocfg"
-version = "1.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
-
-[[package]]
-name = "better_io"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "92fde17f91e7ba10b2a07f8dff29530b77144894bc6ae850fbc66e1276af0d28"
-
-[[package]]
-name = "bit-vec"
-version = "0.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e764a1d40d510daf35e07be9eb06e75770908c27d411ee6c92109c9840eaaf7"
-
-[[package]]
-name = "bitflags"
-version = "2.10.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "812e12b5285cc515a9c72a5c1d3b6d46a19dac5acfef5265968c166106e31dd3"
-
-[[package]]
-name = "bitvec"
-version = "1.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1bc2832c24239b0141d5674bb9174f9d68a8b5b3f2753311927c172ca46f7e9c"
-dependencies = [
- "funty",
- "radium",
- "tap",
- "wyz",
-]
-
-[[package]]
-name = "blocking"
-version = "1.6.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e83f8d02be6967315521be875afa792a316e28d57b5a2d401897e2a7921b7f21"
-dependencies = [
- "async-channel",
- "async-task",
- "futures-io",
- "futures-lite",
- "piper",
-]
-
-[[package]]
-name = "bumpalo"
-version = "3.19.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "46c5e41b57b8bba42a04676d81cb89e9ee8e859a1a66f80a5a72e1cb76b34d43"
-
-[[package]]
-name = "bytes"
-version = "1.11.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b35204fbdc0b3f4446b89fc1ac2cf84a8a68971995d0bf2e925ec7cd960f9cb3"
-
-[[package]]
-name = "cc"
-version = "1.2.49"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "90583009037521a116abf44494efecd645ba48b6622457080f080b85544e2215"
-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.42"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "145052bdd345b87320e369255277e3fb5152762ad123a901ef5c262dd38fe8d2"
-dependencies = [
- "iana-time-zone",
- "num-traits",
- "windows-link",
-]
-
-[[package]]
-name = "concurrent-queue"
-version = "2.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4ca0197aee26d1ae37445ee532fefce43251d24cc7c166799f4d46817f1d3973"
-dependencies = [
- "crossbeam-utils",
-]
-
-[[package]]
-name = "const-random"
-version = "0.1.18"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "87e00182fe74b066627d63b85fd550ac2998d4b0bd86bfed477a0ae4c7c71359"
-dependencies = [
- "const-random-macro",
-]
-
-[[package]]
-name = "const-random-macro"
-version = "0.1.16"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f9d839f2a20b0aee515dc581a6172f2321f96cab76c1a38a4c584a194955390e"
-dependencies = [
- "getrandom 0.2.16",
- "once_cell",
- "tiny-keccak",
-]
-
-[[package]]
-name = "const_for"
-version = "0.1.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d9c50fcfdf972929aff202c16b80086aa3cfc6a3a820af714096c58c7c1d0582"
-
-[[package]]
-name = "core-foundation-sys"
-version = "0.8.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"
-
-[[package]]
-name = "crossbeam-channel"
-version = "0.5.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "82b8f8f868b36967f9606790d1903570de9ceaf870a7bf9fbbd3016d636a2cb2"
-dependencies = [
- "crossbeam-utils",
-]
-
-[[package]]
-name = "crossbeam-epoch"
-version = "0.9.18"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e"
-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 = "crunchy"
-version = "0.2.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5"
-
-[[package]]
-name = "cudarc"
-version = "0.18.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ef0cfc5e22a6b6f7d04ee45b0151232ca236ede8ca3534210fd4072bdead0d60"
-dependencies = [
- "half",
- "libloading",
-]
-
-[[package]]
-name = "dashmap"
-version = "6.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5041cc499144891f3790297212f32a74fb938e5136a14943f338ef9e0ae276cf"
-dependencies = [
- "cfg-if",
- "crossbeam-utils",
- "hashbrown 0.14.5",
- "lock_api",
- "once_cell",
- "parking_lot_core",
-]
-
-[[package]]
-name = "displaydoc"
-version = "0.2.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.111",
-]
-
-[[package]]
-name = "dtype_dispatch"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d3a5ccdfd6c5e7e2fea9c5cf256f2a08216047fab19c621c3da64e9ae4a1462d"
-
-[[package]]
-name = "either"
-version = "1.15.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"
-
-[[package]]
-name = "enum-iterator"
-version = "2.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a4549325971814bda7a44061bf3fe7e487d447cba01e4220a4b454d630d7a016"
-dependencies = [
- "enum-iterator-derive",
-]
-
-[[package]]
-name = "enum-iterator-derive"
-version = "1.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "685adfa4d6f3d765a26bc5dbc936577de9abf756c1feeb3089b01dd395034842"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.111",
-]
-
-[[package]]
-name = "enum-map"
-version = "2.7.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6866f3bfdf8207509a033af1a75a7b08abda06bbaaeae6669323fd5a097df2e9"
-dependencies = [
- "enum-map-derive",
-]
-
-[[package]]
-name = "enum-map-derive"
-version = "0.17.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f282cfdfe92516eb26c2af8589c274c7c17681f5ecc03c18255fe741c6aa64eb"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.111",
-]
-
-[[package]]
-name = "equivalent"
-version = "1.0.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
-
-[[package]]
-name = "errno"
-version = "0.3.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
-dependencies = [
- "libc",
- "windows-sys",
-]
-
-[[package]]
-name = "event-listener"
-version = "5.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e13b66accf52311f30a0db42147dadea9850cb48cd070028831ae5f5d4b856ab"
-dependencies = [
- "concurrent-queue",
- "parking",
- "pin-project-lite",
-]
-
-[[package]]
-name = "event-listener-strategy"
-version = "0.5.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8be9f3dfaaffdae2972880079a491a1a8bb7cbed0b8dd7a347f668b4150a3b93"
-dependencies = [
- "event-listener",
- "pin-project-lite",
-]
-
-[[package]]
-name = "exponential-decay-histogram"
-version = "0.1.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d7962d7e9baab6ea05af175491fa6a8441f3bf461558037622142573d98dd6d6"
-dependencies = [
- "ordered-float 5.1.0",
- "rand",
-]
-
-[[package]]
-name = "ext-trait"
-version = "1.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d772df1c1a777963712fb68e014235e80863d6a91a85c4e06ba2d16243a310e5"
-dependencies = [
- "ext-trait-proc_macros",
-]
-
-[[package]]
-name = "ext-trait-proc_macros"
-version = "1.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ab7934152eaf26aa5aa9f7371408ad5af4c31357073c9e84c3b9d7f11ad639a"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 1.0.109",
-]
-
-[[package]]
-name = "extension-traits"
-version = "1.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a296e5a895621edf9fa8329c83aa1cb69a964643e36cf54d8d7a69b789089537"
-dependencies = [
- "ext-trait",
-]
-
-[[package]]
-name = "fastlanes"
-version = "0.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "414cb755aee48ff7b0907995d2949c68c8c17900970076dff6a808e18e592d71"
-dependencies = [
- "arrayref",
- "const_for",
- "num-traits",
- "paste",
- "seq-macro",
-]
-
-[[package]]
-name = "fastrand"
-version = "2.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be"
-
-[[package]]
-name = "find-msvc-tools"
-version = "0.1.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3a3076410a55c90011c298b04d0cfa770b00fa04e1e3c97d3f6c9de105a03844"
-
-[[package]]
-name = "flatbuffers"
-version = "25.9.23"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "09b6620799e7340ebd9968d2e0708eb82cf1971e9a16821e2091b6d6e475eed5"
-dependencies = [
- "bitflags",
- "rustc_version",
-]
-
-[[package]]
-name = "foldhash"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb"
-
-[[package]]
-name = "form_urlencoded"
-version = "1.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cb4cb245038516f5f85277875cdaa4f7d2c9a0fa0468de06ed190163b1581fcf"
-dependencies = [
- "percent-encoding",
-]
-
-[[package]]
-name = "fsst-rs"
-version = "0.5.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "561f2458a3407836ab8f1acc9113b8cda91b9d6378ba8dad13b2fe1a1d3af5ce"
-
-[[package]]
-name = "funty"
-version = "2.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"
-
-[[package]]
-name = "futures"
-version = "0.3.31"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "65bc07b1a8bc7c85c5f2e110c476c7389b4554ba72af57d8445ea63a576b0876"
-dependencies = [
- "futures-channel",
- "futures-core",
- "futures-executor",
- "futures-io",
- "futures-sink",
- "futures-task",
- "futures-util",
-]
-
-[[package]]
-name = "futures-channel"
-version = "0.3.31"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2dff15bf788c671c1934e366d07e30c1814a8ef514e1af724a602e8a2fbe1b10"
-dependencies = [
- "futures-core",
- "futures-sink",
-]
-
-[[package]]
-name = "futures-core"
-version = "0.3.31"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "05f29059c0c2090612e8d742178b0580d2dc940c837851ad723096f87af6663e"
-
-[[package]]
-name = "futures-executor"
-version = "0.3.31"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e28d1d997f585e54aebc3f97d39e72338912123a67330d723fdbb564d646c9f"
-dependencies = [
- "futures-core",
- "futures-task",
- "futures-util",
-]
-
-[[package]]
-name = "futures-io"
-version = "0.3.31"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9e5c1b78ca4aae1ac06c48a526a655760685149f0d465d21f37abfe57ce075c6"
-
-[[package]]
-name = "futures-lite"
-version = "2.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f78e10609fe0e0b3f4157ffab1876319b5b0db102a2c60dc4626306dc46b44ad"
-dependencies = [
- "fastrand",
- "futures-core",
- "futures-io",
- "parking",
- "pin-project-lite",
-]
-
-[[package]]
-name = "futures-macro"
-version = "0.3.31"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "162ee34ebcb7c64a8abebc059ce0fee27c2262618d7b60ed8faf72fef13c3650"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.111",
-]
-
-[[package]]
-name = "futures-sink"
-version = "0.3.31"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e575fab7d1e0dcb8d0c7bcf9a63ee213816ab51902e6d244a95819acacf1d4f7"
-
-[[package]]
-name = "futures-task"
-version = "0.3.31"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f90f7dce0722e95104fcb095585910c0977252f286e354b5e3bd38902cd99988"
-
-[[package]]
-name = "futures-util"
-version = "0.3.31"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9fa08315bb612088cc391249efdc3bc77536f16c91f6cf495e6fbe85b20a4a81"
-dependencies = [
- "futures-channel",
- "futures-core",
- "futures-io",
- "futures-macro",
- "futures-sink",
- "futures-task",
- "memchr",
- "pin-project-lite",
- "pin-utils",
- "slab",
-]
-
-[[package]]
-name = "getrandom"
-version = "0.2.16"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "335ff9f135e4384c8150d6f27c6daed433577f86b4750418338c01a1a2528592"
-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",
- "js-sys",
- "libc",
- "r-efi",
- "wasip2",
- "wasm-bindgen",
-]
-
-[[package]]
-name = "half"
-version = "2.7.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6ea2d84b969582b4b1864a92dc5d27cd2b77b622a8d79306834f1be5ba20d84b"
-dependencies = [
- "cfg-if",
- "crunchy",
- "num-traits",
- "rand",
- "rand_distr",
- "zerocopy",
-]
-
-[[package]]
-name = "handle"
-version = "1.0.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "52ed72152641d513a6084a3907bfcba3f35ae2d3335c22ce2242969c25ff8e46"
-
-[[package]]
-name = "hashbrown"
-version = "0.14.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1"
-
-[[package]]
-name = "hashbrown"
-version = "0.16.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100"
-dependencies = [
- "allocator-api2",
- "equivalent",
- "foldhash",
-]
-
-[[package]]
-name = "hermit-abi"
-version = "0.5.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fc0fef456e4baa96da950455cd02c081ca953b141298e41db3fc7e36b1da849c"
-
-[[package]]
-name = "humansize"
-version = "2.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6cb51c9a029ddc91b07a787f1d86b53ccfa49b0e86688c946ebe8d3555685dd7"
-dependencies = [
- "libm",
-]
-
-[[package]]
-name = "iana-time-zone"
-version = "0.1.64"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "33e57f83510bb73707521ebaffa789ec8caf86f9657cad665b092b581d40e9fb"
-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.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e93fcd3157766c0c8da2f8cff6ce651a31f0810eaa1c51ec363ef790bbb5fb99"
-dependencies = [
- "icu_collections",
- "icu_locale_core",
- "icu_properties_data",
- "icu_provider",
- "zerotrie",
- "zerovec",
-]
-
-[[package]]
-name = "icu_properties_data"
-version = "2.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "02845b3647bb045f1100ecd6480ff52f34c35f82d9880e029d329c21d1054899"
-
-[[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 = "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 = "inventory"
-version = "0.3.21"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bc61209c082fbeb19919bee74b176221b27223e27b65d781eb91af24eb1fb46e"
-dependencies = [
- "rustversion",
-]
-
-[[package]]
-name = "itertools"
-version = "0.14.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2b192c782037fadd9cfa75548310488aabdbf3d2da73885b31bd0abd03351285"
-dependencies = [
- "either",
-]
-
-[[package]]
-name = "jiff"
-version = "0.2.16"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "49cce2b81f2098e7e3efc35bc2e0a6b7abec9d34128283d7a26fa8f32a6dbb35"
-dependencies = [
- "jiff-static",
- "jiff-tzdb-platform",
- "log",
- "portable-atomic",
- "portable-atomic-util",
- "serde_core",
- "windows-sys",
-]
-
-[[package]]
-name = "jiff-static"
-version = "0.2.16"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "980af8b43c3ad5d8d349ace167ec8170839f753a42d233ba19e08afe1850fa69"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.111",
-]
-
-[[package]]
-name = "jiff-tzdb"
-version = "0.1.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c1283705eb0a21404d2bfd6eef2a7593d240bc42a0bdb39db0ad6fa2ec026524"
-
-[[package]]
-name = "jiff-tzdb-platform"
-version = "0.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "875a5a69ac2bab1a891711cf5eccbec1ce0341ea805560dcd90b7a2e925132e8"
-dependencies = [
- "jiff-tzdb",
-]
-
-[[package]]
-name = "js-sys"
-version = "0.3.83"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "464a3709c7f55f1f721e5389aa6ea4e3bc6aba669353300af094b29ffbdde1d8"
-dependencies = [
- "once_cell",
- "wasm-bindgen",
-]
-
-[[package]]
-name = "kanal"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9e3953adf0cd667798b396c2fa13552d6d9b3269d7dd1154c4c416442d1ff574"
-dependencies = [
- "futures-core",
- "lock_api",
-]
-
-[[package]]
-name = "lending-iterator"
-version = "0.1.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bc07588c853b50689205fb5c00498aa681d89828e0ce8cbd965ebc7a5d8ae260"
-dependencies = [
- "extension-traits",
- "lending-iterator-proc_macros",
- "macro_rules_attribute",
- "never-say-never",
- "nougat",
- "polonius-the-crab",
-]
-
-[[package]]
-name = "lending-iterator-proc_macros"
-version = "0.1.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b5445dd1c0deb1e97b8a16561d17fc686ca83e8411128fb036e9668a72d51b1d"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 1.0.109",
-]
-
-[[package]]
-name = "libc"
-version = "0.2.178"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "37c93d8daa9d8a012fd8ab92f088405fb202ea0b6ab73ee2482ae66af4f42091"
-
-[[package]]
-name = "libloading"
-version = "0.8.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d7c4b02199fee7c5d21a5ae7d8cfa79a6ef5bb2fc834d6e9058e89c825efdc55"
-dependencies = [
- "cfg-if",
- "windows-link",
-]
-
-[[package]]
-name = "libm"
-version = "0.2.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f9fbbcab51052fe104eb5e5d351cf728d30a5be1fe14d9be8a3b097481fb97de"
-
-[[package]]
-name = "linux-raw-sys"
-version = "0.11.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "df1d3c3b53da64cf5760482273a98e575c651a67eec7f77df96b5b642de8f039"
-
-[[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 = "macro_rules_attribute"
-version = "0.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cf0c9b980bf4f3a37fd7b1c066941dd1b1d0152ce6ee6e8fe8c49b9f6810d862"
-dependencies = [
- "macro_rules_attribute-proc_macro",
- "paste",
-]
-
-[[package]]
-name = "macro_rules_attribute-proc_macro"
-version = "0.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "58093314a45e00c77d5c508f76e77c3396afbbc0d01506e7fae47b018bac2b1d"
-
-[[package]]
-name = "memchr"
-version = "2.7.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f52b00d39961fc5b2736ea853c9cc86238e165017a493d1d5c8eac6bdc4cc273"
-
-[[package]]
-name = "moka"
-version = "0.12.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8261cd88c312e0004c1d51baad2980c66528dfdb2bee62003e643a4d8f86b077"
-dependencies = [
- "async-lock",
- "crossbeam-channel",
- "crossbeam-epoch",
- "crossbeam-utils",
- "equivalent",
- "event-listener",
- "futures-util",
- "parking_lot",
- "portable-atomic",
- "rustc_version",
- "smallvec",
- "tagptr",
- "uuid",
-]
-
-[[package]]
-name = "multiversion"
-version = "0.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7edb7f0ff51249dfda9ab96b5823695e15a052dc15074c9dbf3d118afaf2c201"
-dependencies = [
- "multiversion-macros",
- "target-features",
-]
-
-[[package]]
-name = "multiversion-macros"
-version = "0.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b093064383341eb3271f42e381cb8f10a01459478446953953c75d24bd339fc0"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.111",
- "target-features",
-]
-
-[[package]]
-name = "never-say-never"
-version = "6.6.666"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cf5a574dadd7941adeaa71823ecba5e28331b8313fb2e1c6a5c7e5981ea53ad6"
-
-[[package]]
-name = "nougat"
-version = "0.2.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "97b57b9ced431322f054fc673f1d3c7fa52d80efd9df74ad2fc759f044742510"
-dependencies = [
- "macro_rules_attribute",
- "nougat-proc_macros",
-]
-
-[[package]]
-name = "nougat-proc_macros"
-version = "0.2.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c84f77a45e99a2f9b492695d99e1c23844619caa5f3e57647cffacad773ca257"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 1.0.109",
-]
-
-[[package]]
-name = "num-bigint"
-version = "0.4.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a5e44f723f1133c9deac646763579fdb3ac745e418f2a7af9cd0c431da1f20b9"
-dependencies = [
- "num-integer",
- "num-traits",
-]
-
-[[package]]
-name = "num-complex"
-version = "0.4.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "73f88a1307638156682bada9d7604135552957b7818057dcef22705b4d509495"
-dependencies = [
- "num-traits",
-]
-
-[[package]]
-name = "num-integer"
-version = "0.1.46"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f"
-dependencies = [
- "num-traits",
-]
-
-[[package]]
-name = "num-traits"
-version = "0.2.19"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
-dependencies = [
- "autocfg",
- "libm",
-]
-
-[[package]]
-name = "num_enum"
-version = "0.7.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1207a7e20ad57b847bbddc6776b968420d38292bbfe2089accff5e19e82454c"
-dependencies = [
- "num_enum_derive",
- "rustversion",
-]
-
-[[package]]
-name = "num_enum_derive"
-version = "0.7.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ff32365de1b6743cb203b710788263c44a03de03802daf96092f2da4fe6ba4d7"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.111",
-]
-
-[[package]]
-name = "once_cell"
-version = "1.21.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
-dependencies = [
- "parking_lot_core",
-]
-
-[[package]]
-name = "oneshot"
-version = "0.1.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b4ce411919553d3f9fa53a0880544cda985a112117a0444d5ff1e870a893d6ea"
-
-[[package]]
-name = "ordered-float"
-version = "2.10.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "68f19d67e5a2795c94e73e0bb1cc1a7edeb2e28efd39e2e1c9b7a40c1108b11c"
-dependencies = [
- "num-traits",
-]
-
-[[package]]
-name = "ordered-float"
-version = "5.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f4779c6901a562440c3786d08192c6fbda7c1c2060edd10006b05ee35d10f2d"
-dependencies = [
- "num-traits",
-]
-
-[[package]]
-name = "parking"
-version = "2.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f38d5652c16fde515bb1ecef450ab0f6a219d619a7274976324d5e377f7dceba"
-
-[[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 = "pco"
-version = "0.4.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ab068b64f2c6f074cbdcafc80ebd83a27da92a3848deba2fabc21eba6691fc65"
-dependencies = [
- "better_io",
- "dtype_dispatch",
- "half",
- "rand_xoshiro",
-]
-
-[[package]]
-name = "percent-encoding"
-version = "2.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220"
-
-[[package]]
-name = "pin-project-lite"
-version = "0.2.16"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3b3cff922bd51709b605d9ead9aa71031d81447142d828eb4a6eba76fe619f9b"
-
-[[package]]
-name = "pin-utils"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
-
-[[package]]
-name = "piper"
-version = "0.2.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "96c8c490f422ef9a4efd2cb5b42b76c8613d7e7dfc1caf667b8a3350a5acc066"
-dependencies = [
- "atomic-waker",
- "fastrand",
- "futures-io",
-]
-
-[[package]]
-name = "polling"
-version = "3.11.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5d0e4f59085d47d8241c88ead0f274e8a0cb551f3625263c05eb8dd897c34218"
-dependencies = [
- "cfg-if",
- "concurrent-queue",
- "hermit-abi",
- "pin-project-lite",
- "rustix",
- "windows-sys",
-]
-
-[[package]]
-name = "polonius-the-crab"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c2a69ee997a6282f8462abf1e0d8c38c965e968799e912b3bed8c9e8a28c2f9f"
-
-[[package]]
-name = "portable-atomic"
-version = "1.11.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f84267b20a16ea918e43c6a88433c2d54fa145c92a811b5b047ccbe153674483"
-
-[[package]]
-name = "portable-atomic-util"
-version = "0.2.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d8a2f0d8d040d7848a709caf78912debcc3f33ee4b3cac47d73d1e1069e83507"
-dependencies = [
- "portable-atomic",
-]
-
-[[package]]
-name = "potential_utf"
-version = "0.1.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b73949432f5e2a09657003c25bca5e19a0e9c84f8058ca374f49e0ebe605af77"
-dependencies = [
- "zerovec",
-]
-
-[[package]]
-name = "ppv-lite86"
-version = "0.2.21"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9"
-dependencies = [
- "zerocopy",
-]
-
-[[package]]
-name = "proc-macro2"
-version = "1.0.103"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5ee95bc4ef87b8d5ba32e8b7714ccc834865276eab0aed5c9958d00ec45f49e8"
-dependencies = [
- "unicode-ident",
-]
-
-[[package]]
-name = "prost"
-version = "0.14.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7231bd9b3d3d33c86b58adbac74b5ec0ad9f496b19d22801d773636feaa95f3d"
-dependencies = [
- "bytes",
- "prost-derive",
-]
-
-[[package]]
-name = "prost-derive"
-version = "0.14.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9120690fafc389a67ba3803df527d0ec9cbbc9cc45e4cc20b332996dfb672425"
-dependencies = [
- "anyhow",
- "itertools",
- "proc-macro2",
- "quote",
- "syn 2.0.111",
-]
-
-[[package]]
-name = "prost-types"
-version = "0.14.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b9b4db3d6da204ed77bb26ba83b6122a73aeb2e87e25fbf7ad2e84c4ccbf8f72"
-dependencies = [
- "prost",
-]
-
-[[package]]
-name = "quote"
-version = "1.0.42"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a338cc41d27e6cc6dce6cefc13a0729dfbb81c262b1f519331575dd80ef3067f"
-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 = "radium"
-version = "0.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc33ff2d4973d518d823d61aa239014831e521c75da58e3df4840d3f47749d09"
-
-[[package]]
-name = "rand"
-version = "0.9.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6db2770f06117d490610c7488547d543617b21bfa07796d7a12f6f1bd53850d1"
-dependencies = [
- "rand_chacha",
- "rand_core 0.9.3",
-]
-
-[[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.3",
-]
-
-[[package]]
-name = "rand_core"
-version = "0.6.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
-
-[[package]]
-name = "rand_core"
-version = "0.9.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "99d9a13982dcf210057a8a78572b2217b667c3beacbf3a0d8b454f6f82837d38"
-dependencies = [
- "getrandom 0.3.4",
-]
-
-[[package]]
-name = "rand_distr"
-version = "0.5.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6a8615d50dcf34fa31f7ab52692afec947c4dd0ab803cc87cb3b0b4570ff7463"
-dependencies = [
- "num-traits",
- "rand",
-]
-
-[[package]]
-name = "rand_xoshiro"
-version = "0.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6f97cdb2a36ed4183de61b2f824cc45c9f1037f28afe0a322e9fff4c108b5aaa"
-dependencies = [
- "rand_core 0.6.4",
-]
-
-[[package]]
-name = "redox_syscall"
-version = "0.5.18"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d"
-dependencies = [
- "bitflags",
-]
-
-[[package]]
-name = "regex"
-version = "1.12.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "843bc0191f75f3e22651ae5f1e72939ab2f72a4bc30fa80a066bd66edefc24d4"
-dependencies = [
- "aho-corasick",
- "memchr",
- "regex-automata",
- "regex-syntax",
-]
-
-[[package]]
-name = "regex-automata"
-version = "0.4.13"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5276caf25ac86c8d810222b3dbb938e512c55c6831a10f3e6ed1c93b84041f1c"
-dependencies = [
- "aho-corasick",
- "memchr",
- "regex-syntax",
-]
-
-[[package]]
-name = "regex-syntax"
-version = "0.8.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a2d987857b319362043e95f5353c0535c1f58eec5336fdfcf626430af7def58"
-
-[[package]]
-name = "rustc-hash"
-version = "2.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "357703d41365b4b27c590e3ed91eabb1b663f07c4c084095e60cbed4362dff0d"
-
-[[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.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cd15f8a2c5551a84d56efdc1cd049089e409ac19a3072d5037a17fd70719ff3e"
-dependencies = [
- "bitflags",
- "errno",
- "libc",
- "linux-raw-sys",
- "windows-sys",
-]
-
-[[package]]
-name = "rustversion"
-version = "1.0.22"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d"
-
-[[package]]
-name = "scopeguard"
-version = "1.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
-
-[[package]]
-name = "semver"
-version = "1.0.27"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d767eb0aabc880b29956c35734170f26ed551a859dbd361d140cdbeca61ab1e2"
-
-[[package]]
-name = "seq-macro"
-version = "0.3.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1bc711410fbe7399f390ca1c3b60ad0f53f80e95c5eb935e52268a0e2cd49acc"
-
-[[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-value"
-version = "0.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f3a1a3341211875ef120e117ea7fd5228530ae7e7036a779fdc9117be6b3282c"
-dependencies = [
- "ordered-float 2.10.1",
- "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.111",
-]
-
-[[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.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7664a098b8e616bdfcc2dc0e9ac44eb231eedf41db4e9fe95d8d32ec728dedad"
-dependencies = [
- "libc",
-]
-
-[[package]]
-name = "simdutf8"
-version = "0.1.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e3a9fe34e3e7a50316060351f37187a3f546bce95496156754b601a5fa71b76e"
-
-[[package]]
-name = "sketches-ddsketch"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c1e9a774a6c28142ac54bb25d25562e6bcf957493a184f15ad4eebccb23e410a"
-
-[[package]]
-name = "slab"
-version = "0.4.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a2ae44ef20feb57a68b23d846850f861394c2e02dc425a50098ae8c90267589"
-
-[[package]]
-name = "smallvec"
-version = "1.15.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
-
-[[package]]
-name = "smol"
-version = "2.0.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a33bd3e260892199c3ccfc487c88b2da2265080acb316cd920da72fdfd7c599f"
-dependencies = [
- "async-channel",
- "async-executor",
- "async-fs",
- "async-io",
- "async-lock",
- "async-net",
- "async-process",
- "blocking",
- "futures-lite",
-]
-
-[[package]]
-name = "stable_deref_trait"
-version = "1.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596"
-
-[[package]]
-name = "static_assertions"
-version = "1.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
-
-[[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.111"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "390cc9a294ab71bdb1aa2e99d13be9c753cd2d7bd6560c77118597410c4d2e87"
-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.111",
-]
-
-[[package]]
-name = "tagptr"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b2093cf4c8eb1e67749a6762251bc9cd836b6fc171623bd0a9d324d37af2417"
-
-[[package]]
-name = "tap"
-version = "1.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369"
-
-[[package]]
-name = "target-features"
-version = "0.1.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c1bbb9f3c5c463a01705937a24fdabc5047929ac764b2d5b9cf681c1f5041ed5"
-
-[[package]]
-name = "termtree"
-version = "0.5.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f50febec83f5ee1df3015341d8bd429f2d1cc62bcba7ea2076759d315084683"
-
-[[package]]
-name = "tiny-keccak"
-version = "2.0.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2c9d3793400a45f954c52e73d068316d76b6f4e36977e3fcebb13a2721e80237"
-dependencies = [
- "crunchy",
-]
-
-[[package]]
-name = "tinystr"
-version = "0.8.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "42d3e9c45c09de15d06dd8acf5f4e0e399e85927b7f00711024eb7ae10fa4869"
-dependencies = [
- "displaydoc",
- "zerovec",
-]
-
-[[package]]
-name = "tokio"
-version = "1.48.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ff360e02eab121e0bc37a2d3b4d4dc622e6eda3a8e5253d5435ecf5bd4c68408"
-dependencies = [
- "bytes",
- "pin-project-lite",
-]
-
-[[package]]
-name = "tracing"
-version = "0.1.43"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2d15d90a0b5c19378952d479dc858407149d7bb45a14de0142f6c534b16fc647"
-dependencies = [
- "pin-project-lite",
- "tracing-attributes",
- "tracing-core",
-]
-
-[[package]]
-name = "tracing-attributes"
-version = "0.1.31"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7490cfa5ec963746568740651ac6781f701c9c5ea257c58e057f3ba8cf69e8da"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.111",
-]
-
-[[package]]
-name = "tracing-core"
-version = "0.1.35"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a04e24fab5c89c6a36eb8558c9656f30d81de51dfa4d3b45f26b21d61fa0a6c"
-dependencies = [
- "once_cell",
-]
-
-[[package]]
-name = "unicode-ident"
-version = "1.0.22"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9312f7c4f6ff9069b165498234ce8be658059c6728633667c526e27dc2cf1df5"
-
-[[package]]
-name = "url"
-version = "2.5.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "08bc136a29a3d1758e07a9cca267be308aeebf5cfd5a10f3f67ab2097683ef5b"
-dependencies = [
- "form_urlencoded",
- "idna",
- "percent-encoding",
- "serde",
-]
-
-[[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.19.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2e054861b4bd027cd373e18e8d8d8e6548085000e41290d95ce0c373a654b4a"
-dependencies = [
- "getrandom 0.3.4",
- "js-sys",
- "wasm-bindgen",
-]
-
-[[package]]
-name = "version_check"
-version = "0.9.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
-
-[[package]]
-name = "vortex"
-version = "0.1.0"
-dependencies = [
- "fastlanes",
- "rand",
- "vortex-alp",
- "vortex-array",
- "vortex-btrblocks",
- "vortex-buffer",
- "vortex-bytebool",
- "vortex-datetime-parts",
- "vortex-decimal-byte-parts",
- "vortex-dtype",
- "vortex-error",
- "vortex-fastlanes",
- "vortex-flatbuffers",
- "vortex-fsst",
- "vortex-io",
- "vortex-ipc",
- "vortex-layout",
- "vortex-mask",
- "vortex-metrics",
- "vortex-pco",
- "vortex-proto",
- "vortex-runend",
- "vortex-scalar",
- "vortex-scan",
- "vortex-sequence",
- "vortex-session",
- "vortex-sparse",
- "vortex-utils",
- "vortex-zigzag",
-]
-
-[[package]]
-name = "vortex-alp"
-version = "0.1.0"
-dependencies = [
- "itertools",
- "num-traits",
- "prost",
- "rustc-hash",
- "vortex-array",
- "vortex-buffer",
- "vortex-dtype",
- "vortex-error",
- "vortex-fastlanes",
- "vortex-mask",
- "vortex-scalar",
- "vortex-session",
- "vortex-utils",
- "vortex-vector",
-]
-
-[[package]]
-name = "vortex-array"
-version = "0.1.0"
-dependencies = [
- "arcref",
- "arrow-arith",
- "arrow-array",
- "arrow-buffer",
- "arrow-data",
- "arrow-ord",
- "arrow-schema",
- "arrow-select",
- "arrow-string",
- "async-trait",
- "bitvec",
- "cfg-if",
- "enum-iterator",
- "enum-map",
- "flatbuffers",
- "futures",
- "getrandom 0.3.4",
- "humansize",
- "inventory",
- "itertools",
- "log",
- "multiversion",
- "num-traits",
- "num_enum",
- "parking_lot",
- "paste",
- "pin-project-lite",
- "prost",
- "rand",
- "rustc-hash",
- "simdutf8",
- "static_assertions",
- "termtree",
- "vortex-buffer",
- "vortex-compute",
- "vortex-dtype",
- "vortex-error",
- "vortex-flatbuffers",
- "vortex-io",
- "vortex-mask",
- "vortex-metrics",
- "vortex-proto",
- "vortex-scalar",
- "vortex-session",
- "vortex-utils",
- "vortex-vector",
-]
-
-[[package]]
-name = "vortex-btrblocks"
-version = "0.1.0"
-dependencies = [
- "getrandom 0.3.4",
- "itertools",
- "log",
- "num-traits",
- "rand",
- "rustc-hash",
- "vortex-alp",
- "vortex-array",
- "vortex-buffer",
- "vortex-datetime-parts",
- "vortex-decimal-byte-parts",
- "vortex-dtype",
- "vortex-error",
- "vortex-fastlanes",
- "vortex-fsst",
- "vortex-mask",
- "vortex-runend",
- "vortex-scalar",
- "vortex-sequence",
- "vortex-sparse",
- "vortex-utils",
- "vortex-zigzag",
-]
-
-[[package]]
-name = "vortex-buffer"
-version = "0.1.0"
-dependencies = [
- "arrow-buffer",
- "bitvec",
- "bytes",
- "cudarc",
- "itertools",
- "num-traits",
- "simdutf8",
- "vortex-error",
-]
-
-[[package]]
-name = "vortex-bytebool"
-version = "0.1.0"
-dependencies = [
- "num-traits",
- "vortex-array",
- "vortex-buffer",
- "vortex-dtype",
- "vortex-error",
- "vortex-mask",
- "vortex-scalar",
-]
-
-[[package]]
-name = "vortex-compute"
-version = "0.1.0"
-dependencies = [
- "arrow-array",
- "arrow-buffer",
- "arrow-schema",
- "log",
- "multiversion",
- "num-traits",
- "paste",
- "vortex-buffer",
- "vortex-dtype",
- "vortex-error",
- "vortex-mask",
- "vortex-vector",
-]
-
-[[package]]
-name = "vortex-datetime-parts"
-version = "0.1.0"
-dependencies = [
- "num-traits",
- "prost",
- "vortex-array",
- "vortex-buffer",
- "vortex-dtype",
- "vortex-error",
- "vortex-mask",
- "vortex-scalar",
-]
-
-[[package]]
-name = "vortex-decimal-byte-parts"
-version = "0.1.0"
-dependencies = [
- "num-traits",
- "prost",
- "vortex-array",
- "vortex-buffer",
- "vortex-dtype",
- "vortex-error",
- "vortex-mask",
- "vortex-scalar",
-]
-
-[[package]]
-name = "vortex-dtype"
-version = "0.1.0"
-dependencies = [
- "arrow-buffer",
- "arrow-schema",
- "flatbuffers",
- "half",
- "itertools",
- "jiff",
- "num-traits",
- "num_enum",
- "paste",
- "prost",
- "serde",
- "static_assertions",
- "vortex-buffer",
- "vortex-error",
- "vortex-flatbuffers",
- "vortex-proto",
- "vortex-utils",
-]
-
-[[package]]
-name = "vortex-error"
-version = "0.1.0"
-dependencies = [
- "arrow-schema",
- "flatbuffers",
- "jiff",
- "prost",
- "url",
-]
-
-[[package]]
-name = "vortex-fastlanes"
-version = "0.1.0"
-dependencies = [
- "arrayref",
- "arrow-buffer",
- "fastlanes",
- "itertools",
- "lending-iterator",
- "log",
- "num-traits",
- "prost",
- "static_assertions",
- "vortex-array",
- "vortex-buffer",
- "vortex-compute",
- "vortex-dtype",
- "vortex-error",
- "vortex-mask",
- "vortex-scalar",
- "vortex-session",
- "vortex-utils",
- "vortex-vector",
-]
-
-[[package]]
-name = "vortex-flatbuffers"
-version = "0.1.0"
-dependencies = [
- "flatbuffers",
- "vortex-buffer",
-]
-
-[[package]]
-name = "vortex-fsst"
-version = "0.1.0"
-dependencies = [
- "async-trait",
- "fsst-rs",
- "prost",
- "vortex-array",
- "vortex-buffer",
- "vortex-dtype",
- "vortex-error",
- "vortex-mask",
- "vortex-scalar",
- "vortex-vector",
-]
-
-[[package]]
-name = "vortex-io"
-version = "0.1.0"
-dependencies = [
- "async-compat",
- "async-fs",
- "async-stream",
- "async-trait",
- "bytes",
- "cfg-if",
- "futures",
- "getrandom 0.3.4",
- "handle",
- "kanal",
- "log",
- "oneshot",
- "parking_lot",
- "pin-project-lite",
- "smol",
- "tokio",
- "tracing",
- "vortex-buffer",
- "vortex-error",
- "vortex-metrics",
- "vortex-session",
- "wasm-bindgen-futures",
-]
-
-[[package]]
-name = "vortex-ipc"
-version = "0.1.0"
-dependencies = [
- "bytes",
- "flatbuffers",
- "futures",
- "itertools",
- "pin-project-lite",
- "vortex-array",
- "vortex-buffer",
- "vortex-dtype",
- "vortex-error",
- "vortex-flatbuffers",
-]
-
-[[package]]
-name = "vortex-layout"
-version = "0.1.0"
-dependencies = [
- "arcref",
- "arrow-buffer",
- "async-stream",
- "async-trait",
- "flatbuffers",
- "futures",
- "itertools",
- "kanal",
- "log",
- "moka",
- "once_cell",
- "oneshot",
- "parking_lot",
- "paste",
- "pco",
- "pin-project-lite",
- "prost",
- "rustc-hash",
- "termtree",
- "uuid",
- "vortex-array",
- "vortex-btrblocks",
- "vortex-buffer",
- "vortex-decimal-byte-parts",
- "vortex-dtype",
- "vortex-error",
- "vortex-flatbuffers",
- "vortex-io",
- "vortex-mask",
- "vortex-metrics",
- "vortex-pco",
- "vortex-scalar",
- "vortex-sequence",
- "vortex-session",
- "vortex-utils",
-]
-
-[[package]]
-name = "vortex-mask"
-version = "0.1.0"
-dependencies = [
- "itertools",
- "vortex-buffer",
- "vortex-error",
-]
-
-[[package]]
-name = "vortex-metrics"
-version = "0.1.0"
-dependencies = [
- "getrandom 0.3.4",
- "parking_lot",
- "vortex-session",
- "witchcraft-metrics",
-]
-
-[[package]]
-name = "vortex-pco"
-version = "0.1.0"
-dependencies = [
- "itertools",
- "pco",
- "prost",
- "vortex-array",
- "vortex-buffer",
- "vortex-compute",
- "vortex-dtype",
- "vortex-error",
- "vortex-mask",
- "vortex-scalar",
- "vortex-vector",
-]
-
-[[package]]
-name = "vortex-proto"
-version = "0.1.0"
-dependencies = [
- "prost",
- "prost-types",
-]
-
-[[package]]
-name = "vortex-runend"
-version = "0.1.0"
-dependencies = [
- "arrow-array",
- "arrow-buffer",
- "itertools",
- "num-traits",
- "prost",
- "vortex-array",
- "vortex-buffer",
- "vortex-dtype",
- "vortex-error",
- "vortex-mask",
- "vortex-scalar",
-]
-
-[[package]]
-name = "vortex-scalar"
-version = "0.1.0"
-dependencies = [
- "arrow-array",
- "bytes",
- "itertools",
- "num-traits",
- "paste",
- "prost",
- "vortex-buffer",
- "vortex-dtype",
- "vortex-error",
- "vortex-mask",
- "vortex-proto",
- "vortex-utils",
- "vortex-vector",
-]
-
-[[package]]
-name = "vortex-scan"
-version = "0.1.0"
-dependencies = [
- "arrow-array",
- "arrow-schema",
- "bit-vec",
- "futures",
- "itertools",
- "log",
- "parking_lot",
- "sketches-ddsketch",
- "vortex-array",
- "vortex-buffer",
- "vortex-dtype",
- "vortex-error",
- "vortex-io",
- "vortex-layout",
- "vortex-mask",
- "vortex-metrics",
- "vortex-session",
-]
-
-[[package]]
-name = "vortex-sequence"
-version = "0.1.0"
-dependencies = [
- "num-traits",
- "prost",
- "vortex-array",
- "vortex-buffer",
- "vortex-dtype",
- "vortex-error",
- "vortex-io",
- "vortex-mask",
- "vortex-proto",
- "vortex-scalar",
- "vortex-vector",
-]
-
-[[package]]
-name = "vortex-session"
-version = "0.1.0"
-dependencies = [
- "dashmap",
- "vortex-error",
- "vortex-utils",
-]
-
-[[package]]
-name = "vortex-sparse"
-version = "0.1.0"
-dependencies = [
- "itertools",
- "num-traits",
- "prost",
- "vortex-array",
- "vortex-buffer",
- "vortex-dtype",
- "vortex-error",
- "vortex-mask",
- "vortex-scalar",
- "vortex-vector",
-]
-
-[[package]]
-name = "vortex-utils"
-version = "0.1.0"
-dependencies = [
- "dashmap",
- "hashbrown 0.16.1",
-]
-
-[[package]]
-name = "vortex-vector"
-version = "0.1.0"
-dependencies = [
- "paste",
- "static_assertions",
- "vortex-buffer",
- "vortex-dtype",
- "vortex-error",
- "vortex-mask",
-]
-
-[[package]]
-name = "vortex-zigzag"
-version = "0.1.0"
-dependencies = [
- "itertools",
- "vortex-array",
- "vortex-buffer",
- "vortex-dtype",
- "vortex-error",
- "vortex-mask",
- "vortex-scalar",
- "zigzag",
-]
-
-[[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.1+wasi-0.2.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0562428422c63773dad2c345a1882263bbf4d65cf3f42e90921f787ef5ad58e7"
-dependencies = [
- "wit-bindgen",
-]
-
-[[package]]
-name = "wasm-bindgen"
-version = "0.2.106"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0d759f433fa64a2d763d1340820e46e111a7a5ab75f993d1852d70b03dbb80fd"
-dependencies = [
- "cfg-if",
- "once_cell",
- "rustversion",
- "wasm-bindgen-macro",
- "wasm-bindgen-shared",
-]
-
-[[package]]
-name = "wasm-bindgen-futures"
-version = "0.4.56"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "836d9622d604feee9e5de25ac10e3ea5f2d65b41eac0d9ce72eb5deae707ce7c"
-dependencies = [
- "cfg-if",
- "js-sys",
- "once_cell",
- "wasm-bindgen",
- "web-sys",
-]
-
-[[package]]
-name = "wasm-bindgen-macro"
-version = "0.2.106"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "48cb0d2638f8baedbc542ed444afc0644a29166f1595371af4fecf8ce1e7eeb3"
-dependencies = [
- "quote",
- "wasm-bindgen-macro-support",
-]
-
-[[package]]
-name = "wasm-bindgen-macro-support"
-version = "0.2.106"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cefb59d5cd5f92d9dcf80e4683949f15ca4b511f4ac0a6e14d4e1ac60c6ecd40"
-dependencies = [
- "bumpalo",
- "proc-macro2",
- "quote",
- "syn 2.0.111",
- "wasm-bindgen-shared",
-]
-
-[[package]]
-name = "wasm-bindgen-shared"
-version = "0.2.106"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cbc538057e648b67f72a982e708d485b2efa771e1ac05fec311f9f63e5800db4"
-dependencies = [
- "unicode-ident",
-]
-
-[[package]]
-name = "wasm-test"
-version = "0.0.1"
-dependencies = [
- "vortex",
-]
-
-[[package]]
-name = "web-sys"
-version = "0.3.83"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9b32828d774c412041098d182a8b38b16ea816958e07cf40eec2bc080ae137ac"
-dependencies = [
- "js-sys",
- "wasm-bindgen",
-]
-
-[[package]]
-name = "windows-core"
-version = "0.62.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb"
-dependencies = [
- "windows-implement",
- "windows-interface",
- "windows-link",
- "windows-result",
- "windows-strings",
-]
-
-[[package]]
-name = "windows-implement"
-version = "0.60.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.111",
-]
-
-[[package]]
-name = "windows-interface"
-version = "0.59.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.111",
-]
-
-[[package]]
-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 = "7781fa89eaf60850ac3d2da7af8e5242a5ea78d1a11c49bf2910bb5a73853eb5"
-dependencies = [
- "windows-link",
-]
-
-[[package]]
-name = "windows-strings"
-version = "0.5.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7837d08f69c77cf6b07689544538e017c1bfcf57e34b4c0ff58e6c2cd3b37091"
-dependencies = [
- "windows-link",
-]
-
-[[package]]
-name = "windows-sys"
-version = "0.61.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"
-dependencies = [
- "windows-link",
-]
-
-[[package]]
-name = "wit-bindgen"
-version = "0.46.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f17a85883d4e6d00e8a97c586de764dabcc06133f7f1d55dce5cdc070ad7fe59"
-
-[[package]]
-name = "witchcraft-metrics"
-version = "1.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "867a74dec702d742179279ab0b5bcab72ca5858c0c3ccf870bdb5c99f54d675b"
-dependencies = [
- "exponential-decay-histogram",
- "once_cell",
- "parking_lot",
- "serde",
- "serde-value",
-]
-
-[[package]]
-name = "writeable"
-version = "0.6.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9edde0db4769d2dc68579893f2306b26c6ecfbe0ef499b013d731b7b9247e0b9"
-
-[[package]]
-name = "wyz"
-version = "0.5.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "05f360fc0b24296329c78fda852a1e9ae82de9cf7b27dae4b7f62f118f77b9ed"
-dependencies = [
- "tap",
-]
-
-[[package]]
-name = "yoke"
-version = "0.8.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "72d6e5c6afb84d73944e5cedb052c4680d5657337201555f9f2a16b7406d4954"
-dependencies = [
- "stable_deref_trait",
- "yoke-derive",
- "zerofrom",
-]
-
-[[package]]
-name = "yoke-derive"
-version = "0.8.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b659052874eb698efe5b9e8cf382204678a0086ebf46982b79d6ca3182927e5d"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.111",
- "synstructure",
-]
-
-[[package]]
-name = "zerocopy"
-version = "0.8.31"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fd74ec98b9250adb3ca554bdde269adf631549f51d8a8f8f0a10b50f1cb298c3"
-dependencies = [
- "zerocopy-derive",
-]
-
-[[package]]
-name = "zerocopy-derive"
-version = "0.8.31"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d8a8d209fdf45cf5138cbb5a506f6b52522a25afccc534d1475dad8e31105c6a"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.111",
-]
-
-[[package]]
-name = "zerofrom"
-version = "0.1.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "50cc42e0333e05660c3587f3bf9d0478688e15d870fab3346451ce7f8c9fbea5"
-dependencies = [
- "zerofrom-derive",
-]
-
-[[package]]
-name = "zerofrom-derive"
-version = "0.1.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d71e5d6e06ab090c67b5e44993ec16b72dcbaabc526db883a360057678b48502"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.111",
- "synstructure",
-]
-
-[[package]]
-name = "zerotrie"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2a59c17a5562d507e4b54960e8569ebee33bee890c70aa3fe7b97e85a9fd7851"
-dependencies = [
- "displaydoc",
- "yoke",
- "zerofrom",
-]
-
-[[package]]
-name = "zerovec"
-version = "0.11.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c28719294829477f525be0186d13efa9a3c602f7ec202ca9e353d310fb9a002"
-dependencies = [
- "yoke",
- "zerofrom",
- "zerovec-derive",
-]
-
-[[package]]
-name = "zerovec-derive"
-version = "0.11.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eadce39539ca5cb3985590102671f2567e659fca9666581ad3411d59207951f3"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.111",
-]
-
-[[package]]
-name = "zigzag"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "70b40401a28d86ce16a330b863b86fd7dbee4d7c940587ab09ab8c019f9e3fdf"
-dependencies = [
- "num-traits",
-]