@@ -1552,26 +1552,25 @@ impl RowGroupsPrunedParquetOpen {
             // installed filter is owned by the decoder and is not
             // recoverable once replaced.
             let first_rg_fully_matched = rg_plan.front().is_some_and(|e| e.fully_matched);
-            let initial_filter = precomputed_context
-                .as_ref()
-                .and_then(|ctx| ctx.build_row_filter());
             let row_filter_context = precomputed_context;
 
             let mut builder =
                 decoder_config.build(prepared_access_plan, reader_metadata.clone());
             let mut filter_installed = false;
-            if let Some(row_filter) = initial_filter {
+            if let Some(ctx) = row_filter_context.as_ref() {
                 if first_rg_fully_matched {
                     // The first RG is fully matched: install an empty filter
                     // and count the suppression, exactly as the per-RG toggle
                     // does mid-scan, so the metric is consistent whether the
-                    // skip happens at open time or at a later boundary.
+                    // skip happens at open time or at a later boundary. The
+                    // real filter is only built (lazily, from the prebuilt
+                    // candidates) at the first non-fully-matched boundary.
                     builder = builder.with_row_filter(
                         parquet::arrow::arrow_reader::RowFilter::new(vec![]),
                     );
                     row_filter_skipped_fully_matched.add_one();
                 } else {
-                    builder = builder.with_row_filter(row_filter);
+                    builder = builder.with_row_filter(ctx.build_row_filter());
                     filter_installed = true;
                     if let Some(max_predicate_cache_size) =
                         prepared.max_predicate_cache_size
 
@@ -340,10 +340,6 @@ impl PrebuiltRowFilterCandidateList {
         }
     }
 
-    fn is_empty(&self) -> bool {
-        self.inner.is_empty()
-    }
-
     fn as_slice(&self) -> &[PrebuiltRowFilterCandidate] {
         &self.inner
     }
@@ -397,15 +393,15 @@ impl RowFilterContext {
     /// Build a fresh [`RowFilter`] for the next non-fully-matched run using
     /// the cached candidates. Cheap: no tree walks, only counter allocation
     /// and (optionally) a sort by `required_bytes`.
-    pub(crate) fn build_row_filter(&self) -> Option<RowFilter> {
-        if self.prebuilt.is_empty() {
-            return None;
-        }
-        Some(row_filter_from_prebuilt(
+    ///
+    /// Infallible by construction: [`Self::try_new`] only produces a context
+    /// when the prebuilt candidate list is non-empty.
+    pub(crate) fn build_row_filter(&self) -> RowFilter {
+        row_filter_from_prebuilt(
             self.prebuilt.as_slice(),
             self.reorder_predicates,
             &self.file_metrics,
-        ))
+        )
     }
 }
 
@@ -667,22 +663,11 @@ impl PushDecoderStreamState {
                     .row_filter_context
                     .as_ref()
                     .expect("filter_needs_toggle ⇒ context set");
-                match ctx.build_row_filter() {
-                    Some(filter) => {
-                        builder = builder.with_row_filter(filter);
-                        if let Some(cap) = ctx.max_predicate_cache_size {
-                            builder = builder.with_max_predicate_cache_size(cap);
-                        }
-                        self.filter_installed = true;
-                    }
-                    None => {
-                        // Filter could not be rebuilt; install an empty filter
-                        // so the decoder runs unfiltered for this run rather
-                        // than failing.
-                        builder = builder.with_row_filter(RowFilter::new(vec![]));
-                        self.filter_installed = false;
-                    }
+                builder = builder.with_row_filter(ctx.build_row_filter());
+                if let Some(cap) = ctx.max_predicate_cache_size {
+                    builder = builder.with_max_predicate_cache_size(cap);
                 }
+                self.filter_installed = true;
             } else {
                 // Skip per-row filtering for the upcoming fully-matched RG.
                 builder = builder.with_row_filter(RowFilter::new(vec![]));
 
@@ -428,7 +428,7 @@ pub fn build_row_filter(
 /// Extracting this from [`build_row_filter`] lets callers pay the tree-walk +
 /// column-resolution + `reassign_expr_columns` cost **once per file** instead
 /// of once per row group, which is the hot path for
-/// [`RowFilterContext::build`](crate::push_decoder::RowFilterContext) rebuilds
+/// [`RowFilterContext::build_row_filter`](crate::push_decoder::RowFilterContext) rebuilds
 /// on `fully_matched → not-fully-matched` boundaries.
 #[derive(Clone, Debug)]
 pub(crate) struct PrebuiltRowFilterCandidate {