diff --git a/java/lance-jni/src/blocking_scanner.rs b/java/lance-jni/src/blocking_scanner.rs
index 9d65220aa53..8f06847da8b 100644
--- a/java/lance-jni/src/blocking_scanner.rs
+++ b/java/lance-jni/src/blocking_scanner.rs
@@ -21,9 +21,9 @@ use lance_index::scalar::FullTextSearchQuery;
 use lance_index::scalar::inverted::{
     DocumentGranularity,
     query::{
-        BooleanQuery as FtsBooleanQuery, BoostQuery as FtsBoostQuery, FtsQuery,
-        MatchQuery as FtsMatchQuery, MultiMatchQuery as FtsMultiMatchQuery, Occur as FtsOccur,
-        PhraseQuery as FtsPhraseQuery,
+        BooleanQuery as FtsBooleanQuery, BoostQuery as FtsBoostQuery,
+        CombinedFieldsQuery as FtsCombinedFieldsQuery, FtsQuery, MatchQuery as FtsMatchQuery,
+        MultiMatchQuery as FtsMultiMatchQuery, Occur as FtsOccur, PhraseQuery as FtsPhraseQuery,
     },
 };
 use lance_io::ffi::to_ffi_arrow_array_stream;
@@ -174,6 +174,33 @@ pub(crate) fn build_full_text_search_query<'a>(
 
             Ok(FtsQuery::MultiMatch(query))
         }
+        "COMBINED_FIELDS" => {
+            let query_text = env.get_string_from_method(&java_obj, "getQueryText")?;
+            let columns: Vec<String> =
+                import_vec_from_method(env, &java_obj, "getColumns", |env, elem| {
+                    let jstr = JString::from(elem);
+                    let value: String = env.get_string(&jstr)?.into();
+                    Ok(value)
+                })?;
+
+            let boosts: Option<Vec<f32>> =
+                env.get_optional_from_method(&java_obj, "getBoosts", |env, list_obj| {
+                    import_vec_to_rust(env, &list_obj, |env, elem| {
+                        env.get_f32_from_method(&elem, "floatValue")
+                    })
+                })?;
+            let operator = env.get_fts_operator_from_method(&java_obj)?;
+
+            // Column uniqueness and boost (>= 1) validation live in the Rust core;
+            // `?` surfaces those errors across the JNI boundary.
+            let mut query = FtsCombinedFieldsQuery::try_new(query_text, columns)?;
+            if let Some(boosts) = boosts {
+                query = query.try_with_boosts(boosts)?;
+            }
+            query = query.with_operator(operator);
+
+            Ok(FtsQuery::CombinedFields(query))
+        }
         "BOOST" => {
             let positive_obj = env
                 .call_method(
diff --git a/java/src/main/java/org/lance/ipc/FullTextQuery.java b/java/src/main/java/org/lance/ipc/FullTextQuery.java
index 73badab9a49..193b3452ea0 100755
--- a/java/src/main/java/org/lance/ipc/FullTextQuery.java
+++ b/java/src/main/java/org/lance/ipc/FullTextQuery.java
@@ -36,6 +36,7 @@ public enum Type {
     MATCH_PHRASE,
     BOOST,
     MULTI_MATCH,
+    COMBINED_FIELDS,
     BOOLEAN
   }
 
@@ -156,6 +157,15 @@ public static FullTextQuery multiMatch(
     return new MultiMatchQuery(queryText, columns, boosts, operator);
   }
 
+  public static FullTextQuery combinedFields(String queryText, List<String> columns) {
+    return combinedFields(queryText, columns, null, Operator.OR);
+  }
+
+  public static FullTextQuery combinedFields(
+      String queryText, List<String> columns, List<Float> boosts, Operator operator) {
+    return new CombinedFieldsQuery(queryText, columns, boosts, operator);
+  }
+
   public static FullTextQuery boost(FullTextQuery positive, FullTextQuery negative) {
     return boost(positive, negative, 0.5f);
   }
@@ -431,6 +441,93 @@ public String toString() {
     }
   }
 
+  /**
+   * Combined-fields (BM25F) query across multiple columns.
+   *
+   * <p>Unlike {@link MultiMatchQuery}, which scores each column independently and keeps the best
+   * field, this query treats the target columns as a single virtual field so that term statistics
+   * are blended across fields (Lucene {@code CombinedFieldQuery}). A term that is rare in one field
+   * but common in another then scores consistently, and a single query term can match across fields
+   * (for example a first name in one column and a last name in another).
+   *
+   * <p>Target columns must be unique and share the same tokenizer/index configuration. When {@code
+   * boosts} is given, its length must equal the number of columns and each per-column weight must
+   * be finite and {@code >= 1} (fractional weights allowed); when {@code null}, every column
+   * defaults to {@code 1.0}. A {@code null} operator defaults to {@link Operator#OR}. These
+   * constraints are validated in the Rust core and surface as an exception when the query runs.
+   */
+  public static final class CombinedFieldsQuery extends FullTextQuery {
+    private final String queryText;
+    private final List<String> columns;
+    private final Optional<List<Float>> boosts;
+    private final Operator operator;
+
+    CombinedFieldsQuery(
+        String queryText, List<String> columns, List<Float> boosts, Operator operator) {
+      Preconditions.checkArgument(
+          queryText != null && !queryText.isEmpty(), "queryText must not be null or empty");
+      Preconditions.checkArgument(
+          columns != null && !columns.isEmpty(), "columns must not be null or empty");
+
+      this.queryText = queryText;
+      this.columns =
+          Collections.unmodifiableList(new java.util.ArrayList<>(Objects.requireNonNull(columns)));
+      this.boosts =
+          boosts == null
+              ? Optional.empty()
+              : Optional.of(Collections.unmodifiableList(new java.util.ArrayList<>(boosts)));
+      this.operator = operator == null ? Operator.OR : operator;
+    }
+
+    @Override
+    public Type getType() {
+      return Type.COMBINED_FIELDS;
+    }
+
+    public String getQueryText() {
+      return queryText;
+    }
+
+    public List<String> getColumns() {
+      return columns;
+    }
+
+    public Optional<List<Float>> getBoosts() {
+      return boosts;
+    }
+
+    public Operator getOperator() {
+      return operator;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+      if (this == o) return true;
+      if (!(o instanceof CombinedFieldsQuery)) return false;
+      CombinedFieldsQuery other = (CombinedFieldsQuery) o;
+      return operator == other.operator
+          && Objects.equals(queryText, other.queryText)
+          && Objects.equals(columns, other.columns)
+          && Objects.equals(boosts, other.boosts);
+    }
+
+    @Override
+    public int hashCode() {
+      return Objects.hash(queryText, columns, operator, boosts);
+    }
+
+    @Override
+    public String toString() {
+      return MoreObjects.toStringHelper(this)
+          .add("type", getType())
+          .add("queryText", queryText)
+          .add("columns", columns)
+          .add("boosts", boosts)
+          .add("operator", operator)
+          .toString();
+    }
+  }
+
   /** Boost query combining positive and negative queries. */
   public static final class BoostQuery extends FullTextQuery {
     private final FullTextQuery positive;
diff --git a/java/src/test/java/org/lance/ipc/FullTextQueryTest.java b/java/src/test/java/org/lance/ipc/FullTextQueryTest.java
index b84a19db4c8..7b6fe54784d 100755
--- a/java/src/test/java/org/lance/ipc/FullTextQueryTest.java
+++ b/java/src/test/java/org/lance/ipc/FullTextQueryTest.java
@@ -331,6 +331,101 @@ void testMultiMatchQueryInequalityDifferentBoosts() {
     assertFalse(a.equals(b), "MultiMatchQuery instances with different boosts must not be equal");
   }
 
+  @Test
+  void testCombinedFieldsWithoutBoosts() {
+    FullTextQuery.CombinedFieldsQuery q =
+        (FullTextQuery.CombinedFieldsQuery)
+            FullTextQuery.combinedFields("hello", Arrays.asList("title", "body"));
+
+    assertEquals(FullTextQuery.Type.COMBINED_FIELDS, q.getType());
+    assertEquals("hello", q.getQueryText());
+    assertEquals(Arrays.asList("title", "body"), q.getColumns());
+    assertFalse(q.getBoosts().isPresent());
+    assertEquals(FullTextQuery.Operator.OR, q.getOperator());
+  }
+
+  @Test
+  void testCombinedFieldsWithBoosts() {
+    FullTextQuery.CombinedFieldsQuery q =
+        (FullTextQuery.CombinedFieldsQuery)
+            FullTextQuery.combinedFields(
+                "hello",
+                Arrays.asList("title", "body"),
+                Arrays.asList(2.0f, 1.0f),
+                FullTextQuery.Operator.AND);
+
+    assertEquals(FullTextQuery.Type.COMBINED_FIELDS, q.getType());
+    assertTrue(q.getBoosts().isPresent());
+    assertEquals(2, q.getBoosts().get().size());
+    assertEquals(2.0f, q.getBoosts().get().get(0));
+    assertEquals(1.0f, q.getBoosts().get().get(1));
+    assertEquals(FullTextQuery.Operator.AND, q.getOperator());
+    assertNotNull(q.toString());
+  }
+
+  @Test
+  void testCombinedFieldsQueryEquality() {
+    FullTextQuery a = FullTextQuery.combinedFields("hello", Arrays.asList("title", "body"));
+    FullTextQuery b = FullTextQuery.combinedFields("hello", Arrays.asList("title", "body"));
+    assertEquals(a, b, "Two CombinedFieldsQuery instances with the same fields must be equal");
+    assertEquals(a.hashCode(), b.hashCode());
+  }
+
+  @Test
+  void testCombinedFieldsQueryInequalityDifferentOperator() {
+    FullTextQuery a =
+        FullTextQuery.combinedFields(
+            "hello", Arrays.asList("title", "body"), null, FullTextQuery.Operator.AND);
+    FullTextQuery b =
+        FullTextQuery.combinedFields(
+            "hello", Arrays.asList("title", "body"), null, FullTextQuery.Operator.OR);
+    assertFalse(
+        a.equals(b), "CombinedFieldsQuery instances with different operator must not be equal");
+  }
+
+  @Test
+  void testCombinedFieldsQueryInequalityDifferentBoosts() {
+    FullTextQuery a =
+        FullTextQuery.combinedFields(
+            "hello",
+            Arrays.asList("title", "body"),
+            Arrays.asList(2.0f, 1.0f),
+            FullTextQuery.Operator.OR);
+    FullTextQuery b =
+        FullTextQuery.combinedFields(
+            "hello",
+            Arrays.asList("title", "body"),
+            Arrays.asList(1.0f, 1.0f),
+            FullTextQuery.Operator.OR);
+    assertFalse(
+        a.equals(b), "CombinedFieldsQuery instances with different boosts must not be equal");
+  }
+
+  @Test
+  void testCombinedFieldsNotEqualMultiMatch() {
+    FullTextQuery combined = FullTextQuery.combinedFields("hello", Arrays.asList("title", "body"));
+    FullTextQuery multi = FullTextQuery.multiMatch("hello", Arrays.asList("title", "body"));
+    assertFalse(
+        combined.equals(multi),
+        "CombinedFieldsQuery and MultiMatchQuery must not be equal even with same fields");
+  }
+
+  @Test
+  void testCombinedFieldsBoostsDefensivelyCopied() {
+    java.util.List<Float> boosts = new java.util.ArrayList<>(Arrays.asList(2.0f, 1.0f));
+    FullTextQuery.CombinedFieldsQuery q =
+        (FullTextQuery.CombinedFieldsQuery)
+            FullTextQuery.combinedFields(
+                "hello", Arrays.asList("title", "body"), boosts, FullTextQuery.Operator.OR);
+
+    // Mutating the caller-provided list must not change the stored query.
+    boosts.set(0, 9.0f);
+    boosts.clear();
+
+    assertTrue(q.getBoosts().isPresent());
+    assertEquals(Arrays.asList(2.0f, 1.0f), q.getBoosts().get());
+  }
+
   @Test
   void testDifferentSubtypesNotEqual() {
     FullTextQuery match = FullTextQuery.match("hello", "body");
diff --git a/java/src/test/java/org/lance/ipc/LanceScannerFullTextSearchTest.java b/java/src/test/java/org/lance/ipc/LanceScannerFullTextSearchTest.java
index 06438d30706..e79b76a331f 100755
--- a/java/src/test/java/org/lance/ipc/LanceScannerFullTextSearchTest.java
+++ b/java/src/test/java/org/lance/ipc/LanceScannerFullTextSearchTest.java
@@ -49,6 +49,15 @@
 
 class LanceScannerFullTextSearchTest {
 
+  private static final List<String> DEFAULT_DOCUMENTS =
+      Arrays.asList("hello world", "hello lance", "other text");
+
+  private static ScalarIndexParams defaultIndexParams() {
+    return ScalarIndexParams.create(
+        "inverted",
+        "{\"base_tokenizer\":\"simple\",\"language\":\"English\",\"with_position\":true}");
+  }
+
   @Test
   void testMatchQuery() throws Exception {
     runFtsQuery(
@@ -120,6 +129,55 @@ void testMultiMatch() throws Exception {
     runFtsQuery("memory://fts_java_multimatch", multiMatch, 3);
   }
 
+  @Test
+  void testCombinedFields() throws Exception {
+    // "hello" appears in doc or title of every row, so all 3 match.
+    FullTextQuery combined = FullTextQuery.combinedFields("hello", Arrays.asList("doc", "title"));
+    runFtsQuery("memory://fts_java_combined", combined, 3);
+  }
+
+  @Test
+  void testCombinedFieldsWithBoosts() throws Exception {
+    FullTextQuery combined =
+        FullTextQuery.combinedFields(
+            "hello",
+            Arrays.asList("doc", "title"),
+            Arrays.asList(2.0f, 1.0f),
+            FullTextQuery.Operator.OR);
+    runFtsQuery("memory://fts_java_combined_boosts", combined, 3);
+  }
+
+  @Test
+  void testCombinedFieldsInvalidBoostPropagates() throws Exception {
+    // Per-column weights must be >= 1. The check lives in the Rust core and must
+    // surface across the JNI boundary when the query runs.
+    FullTextQuery combined =
+        FullTextQuery.combinedFields(
+            "hello",
+            Arrays.asList("doc", "title"),
+            Arrays.asList(0.5f, 1.0f),
+            FullTextQuery.Operator.OR);
+    withIndexedDataset(
+        "memory://fts_java_combined_bad_boost",
+        dataset -> {
+          ScanOptions scanOptions = new ScanOptions.Builder().fullTextQuery(combined).build();
+          IllegalArgumentException ex =
+              assertThrows(
+                  IllegalArgumentException.class,
+                  () -> {
+                    try (LanceScanner scanner = dataset.newScan(scanOptions);
+                        ArrowReader arrowReader = scanner.scanBatches()) {
+                      while (arrowReader.loadNextBatch()) {
+                        // Drain batches to force query execution.
+                      }
+                    }
+                  });
+          assertTrue(
+              ex.getMessage().contains("combined_fields boost for column 'doc'"),
+              "expected invalid-boost validation error, got: " + ex.getMessage());
+        });
+  }
+
   @Test
   void testBooleanQuery() throws Exception {
     FullTextQuery.MatchQuery shouldMatch =
@@ -139,16 +197,7 @@ void testBooleanQuery() throws Exception {
   }
 
   private void runFtsQuery(String uri, FullTextQuery query, long expectedTotal) throws Exception {
-    ScalarIndexParams indexParams =
-        ScalarIndexParams.create(
-            "inverted",
-            "{\"base_tokenizer\":\"simple\",\"language\":\"English\",\"with_position\":true}");
-    runFtsQuery(
-        uri,
-        query,
-        expectedTotal,
-        Arrays.asList("hello world", "hello lance", "other text"),
-        indexParams);
+    runFtsQuery(uri, query, expectedTotal, DEFAULT_DOCUMENTS, defaultIndexParams());
   }
 
   private void runFtsQuery(
@@ -158,7 +207,41 @@ private void runFtsQuery(
       List<String> documents,
       ScalarIndexParams scalarParams)
       throws Exception {
+    withIndexedDataset(
+        uri,
+        documents,
+        scalarParams,
+        dataset -> {
+          ScanOptions scanOptions = new ScanOptions.Builder().fullTextQuery(query).build();
+
+          try (LanceScanner scanner = dataset.newScan(scanOptions)) {
+            long total = 0L;
+            try (ArrowReader arrowReader = scanner.scanBatches()) {
+              while (arrowReader.loadNextBatch()) {
+                total += arrowReader.getVectorSchemaRoot().getRowCount();
+              }
+            }
+            assertEquals(expectedTotal, total);
+          }
+        });
+  }
+
+  /** Same dataset as the three-argument {@link #runFtsQuery}, without running a query on it. */
+  private void withIndexedDataset(String uri, IndexedDatasetConsumer consumer) throws Exception {
+    withIndexedDataset(uri, DEFAULT_DOCUMENTS, defaultIndexParams(), consumer);
+  }
 
+  /**
+   * Create an in-memory dataset with two text columns ({@code doc}, {@code title}), each backed by
+   * an inverted index, and hand it to {@code consumer}. Resources are released when the consumer
+   * returns.
+   */
+  private void withIndexedDataset(
+      String uri,
+      List<String> documents,
+      ScalarIndexParams scalarParams,
+      IndexedDatasetConsumer consumer)
+      throws Exception {
     Schema schema =
         new Schema(
             Arrays.asList(
@@ -212,20 +295,15 @@ private void runFtsQuery(
                     .withIndexName("title_idx")
                     .build());
 
-            ScanOptions scanOptions = new ScanOptions.Builder().fullTextQuery(query).build();
-
-            try (LanceScanner scanner = dataset.newScan(scanOptions)) {
-              long total = 0L;
-              try (ArrowReader arrowReader = scanner.scanBatches()) {
-                while (arrowReader.loadNextBatch()) {
-                  total += arrowReader.getVectorSchemaRoot().getRowCount();
-                }
-              }
-              assertEquals(expectedTotal, total);
-            }
+            consumer.accept(dataset);
           }
         }
       }
     }
   }
+
+  @FunctionalInterface
+  private interface IndexedDatasetConsumer {
+    void accept(Dataset dataset) throws Exception;
+  }
 }
diff --git a/rust/lance-index/src/scalar/inverted.rs b/rust/lance-index/src/scalar/inverted.rs
index 11a2b6e513f..a5c7dd05f8b 100644
--- a/rust/lance-index/src/scalar/inverted.rs
+++ b/rust/lance-index/src/scalar/inverted.rs
@@ -30,8 +30,8 @@ use arrow_schema::{DataType, Field};
 use async_trait::async_trait;
 pub use builder::InvertedIndexBuilder;
 pub use combined::{
-    CombinedFieldColumn, build_combined_bm25_scorer, combined_fields_search,
-    validate_combined_tokenizers,
+    CombinedCorpusStats, CombinedFieldColumn, FlatFieldStats, build_combined_bm25_scorer,
+    combined_fields_search, flat_combined_fields_search_stream, validate_combined_tokenizers,
 };
 pub use compound::{
     compound_search, compound_search_prepared_match,
diff --git a/rust/lance-index/src/scalar/inverted/combined.rs b/rust/lance-index/src/scalar/inverted/combined.rs
index 9de77185ce7..e48f245b8a0 100644
--- a/rust/lance-index/src/scalar/inverted/combined.rs
+++ b/rust/lance-index/src/scalar/inverted/combined.rs
@@ -23,6 +23,7 @@
 //! scored; see [`combined_fields_search`].
 
 mod cursor;
+mod flat;
 mod search;
 mod stats;
 #[cfg(test)]
@@ -31,9 +32,11 @@ mod testing;
 use std::sync::Arc;
 
 use lance_core::{Error, Result};
+use lance_select::RowAddrTreeMap;
 
+pub use flat::flat_combined_fields_search_stream;
 pub use search::combined_fields_search;
-pub use stats::build_combined_bm25_scorer;
+pub use stats::{CombinedCorpusStats, FlatFieldStats, build_combined_bm25_scorer};
 
 use super::index::InvertedIndex;
 use super::query::Tokens;
@@ -47,6 +50,12 @@ pub struct CombinedFieldColumn {
     pub weight: f32,
     /// Opened inverted-index segments for this column.
     pub indices: Vec<Arc<InvertedIndex>>,
+    /// Rows an overlay made stale, in the row-id domain index results use.
+    ///
+    /// The flat scan folds their current values into the corpus, so their old
+    /// values are subtracted from `indices` to avoid counting them twice.
+    /// `None` when no overlay touched this column.
+    pub stale_rows: Option<Arc<RowAddrTreeMap>>,
 }
 
 /// Deduplicate the query tokens into the unique terms of the virtual field,
diff --git a/rust/lance-index/src/scalar/inverted/combined/flat.rs b/rust/lance-index/src/scalar/inverted/combined/flat.rs
new file mode 100644
index 00000000000..6391db557ec
--- /dev/null
+++ b/rust/lance-index/src/scalar/inverted/combined/flat.rs
@@ -0,0 +1,388 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright The Lance Authors
+
+//! The unindexed `combined_fields` plan: blend the scanned column values into
+//! `dl'`/`tf'` and score the rows no target column's index covers.
+
+use std::sync::Arc;
+
+use arrow::array::{Float32Builder, UInt64Builder};
+use arrow_array::{ArrayRef, RecordBatch};
+use datafusion::execution::SendableRecordBatchStream;
+use datafusion::physical_plan::metrics::Time;
+use datafusion::physical_plan::stream::RecordBatchStreamAdapter;
+use futures::{FutureExt, stream};
+use lance_core::error::DataFusionResult;
+use lance_core::utils::tokio::spawn_cpu;
+use lance_select::RowAddrMask;
+
+use super::super::index::{BlendedRows, FTS_SCHEMA, slice_into_batches, tokenize_and_blend_multi};
+use super::super::query::{Operator, Tokens};
+use super::super::scorer::CombinedFieldsBM25Scorer;
+use super::super::tokenizer::document_tokenizer::LanceTokenizer;
+use super::stats::{CombinedCorpusStats, FlatFieldStats, build_combined_bm25_scorer};
+use super::{CombinedFieldColumn, unique_terms};
+use crate::metrics::MetricsCollector;
+
+/// Exact cross-field BM25F search over rows that no index fully covers, scored
+/// straight from their column values. Together with the indexed
+/// [`combined_fields_search`](super::combined_fields_search) this covers the
+/// whole dataset, with the same term deduplication and `operator` semantics.
+///
+/// - `input` carries `_rowid` plus every target column; `doc_col_indices` locates
+///   them, in `columns` order.
+/// - `stats_masks[column]` selects the rows folded into that column's corpus
+///   statistics, so a row indexed for some columns is not counted twice.
+/// - `emit_mask`, when set, selects the rows to emit from an unfiltered `input`.
+/// - `flat_covers_whole_corpus` selects [`CombinedCorpusStats::FlatOnly`].
+/// - `metrics` receives only the scorer build's index reads.
+///
+/// Returns the scorer alongside the stream. The whole input is consumed before
+/// the first output batch, so an indexed sibling can score against the same
+/// statistics.
+#[allow(clippy::too_many_arguments)]
+pub async fn flat_combined_fields_search_stream(
+    input: SendableRecordBatchStream,
+    columns: &[CombinedFieldColumn],
+    doc_col_indices: Vec<usize>,
+    stats_masks: &[Arc<RowAddrMask>],
+    emit_mask: Option<Arc<RowAddrMask>>,
+    flat_covers_whole_corpus: bool,
+    tokens: &Tokens,
+    tokenizer: Box<dyn LanceTokenizer>,
+    operator: Operator,
+    target_batch_size: usize,
+    elapsed_compute: Option<Time>,
+    metrics: Option<&dyn MetricsCollector>,
+) -> DataFusionResult<(SendableRecordBatchStream, Arc<CombinedFieldsBM25Scorer>)> {
+    let terms = unique_terms(tokens);
+    debug_assert_eq!(doc_col_indices.len(), columns.len());
+    debug_assert_eq!(stats_masks.len(), columns.len());
+    // A query that tokenizes to nothing matches nothing, as on the indexed path.
+    // The scorer is still returned, because an indexed sibling waits for it.
+    if terms.is_empty() || columns.is_empty() {
+        let empty = FlatFieldStats::zeros(columns.len(), 0);
+        let scorer = Arc::new(
+            build_combined_bm25_scorer(
+                columns,
+                tokens,
+                CombinedCorpusStats::for_flat_scan(&empty, flat_covers_whole_corpus),
+                metrics,
+            )
+            .boxed()
+            .await?,
+        );
+        return Ok((
+            Box::pin(RecordBatchStreamAdapter::new(
+                FTS_SCHEMA.clone(),
+                stream::empty::<DataFusionResult<RecordBatch>>(),
+            )),
+            scorer,
+        ));
+    }
+
+    let input_schema = input.schema();
+    // `tf'` is one value per deduplicated term, so the counter must see the same
+    // deduplicated list the indexed scan scores.
+    let unique_tokens = Arc::new(Tokens::new(terms.clone(), tokens.token_type().clone()));
+    // Same thresholds as the single-column flat path: tokenization is CPU-bound,
+    // so batches are accumulated before a task is dispatched.
+    const ACCUMULATE_BYTES: usize = 256 * 1024;
+    const SLICE_BYTES: usize = 512 * 1024;
+    let chunked = lance_arrow::stream::rechunk_stream_by_size(
+        input,
+        input_schema,
+        ACCUMULATE_BYTES,
+        SLICE_BYTES,
+    );
+
+    let weights: Vec<f32> = columns.iter().map(|column| column.weight).collect();
+    let (blended, flat_stats) = tokenize_and_blend_multi(
+        chunked,
+        tokenizer,
+        unique_tokens,
+        Arc::new(doc_col_indices),
+        Arc::new(weights),
+        Arc::new(stats_masks.to_vec()),
+        elapsed_compute.clone(),
+    )
+    .await?;
+
+    // Time the scorer build and the scoring loop together.
+    let post_await_start = std::time::Instant::now();
+    let scorer = Arc::new(
+        build_combined_bm25_scorer(
+            columns,
+            tokens,
+            CombinedCorpusStats::for_flat_scan(&flat_stats, flat_covers_whole_corpus),
+            metrics,
+        )
+        .boxed()
+        .await?,
+    );
+    // `rows x terms` synchronous work, offloaded like the indexed scoring loop so a
+    // large flat scan cannot hold a DataFusion worker.
+    let scores = {
+        let terms_for_scoring = terms.clone();
+        let scorer_for_scoring = scorer.clone();
+        let require_all_terms = operator == Operator::And;
+        spawn_cpu(move || {
+            flat_combined_score(
+                &terms_for_scoring,
+                blended,
+                scorer_for_scoring.as_ref(),
+                require_all_terms,
+                emit_mask.as_deref(),
+            )
+        })
+        .await?
+    };
+
+    let batches = slice_into_batches(scores, target_batch_size);
+    if let Some(t) = &elapsed_compute {
+        t.add_duration(post_await_start.elapsed());
+    }
+    Ok((
+        Box::pin(RecordBatchStreamAdapter::new(
+            FTS_SCHEMA.clone(),
+            stream::iter(batches),
+        )),
+        scorer,
+    ))
+}
+
+/// Score every retained flat row from its blended `dl'`/`tf'`, emitting
+/// `(ROW_ID, SCORE)` in [`FTS_SCHEMA`] for the rows `emit_mask` selects.
+///
+/// Takes the chunks by value and drops each one as it is scored, so the blend and
+/// the output arrays are never both fully resident.
+fn flat_combined_score(
+    terms: &[String],
+    blended: Vec<BlendedRows>,
+    scorer: &CombinedFieldsBM25Scorer,
+    require_all_terms: bool,
+    emit_mask: Option<&RowAddrMask>,
+) -> DataFusionResult<RecordBatch> {
+    let num_terms = terms.len();
+    let num_rows = blended.iter().map(|chunk| chunk.row_ids.len()).sum();
+    let mut row_ids = UInt64Builder::with_capacity(num_rows);
+    let mut scores = Float32Builder::with_capacity(num_rows);
+    for chunk in blended {
+        for (row, (input_row_id, dl_prime)) in
+            chunk.row_ids.iter().zip(&chunk.doc_lengths).enumerate()
+        {
+            if emit_mask.is_some_and(|mask| !mask.selected(*input_row_id)) {
+                continue;
+            }
+            let tf_prime = &chunk.term_freqs[row * num_terms..(row + 1) * num_terms];
+            // `And` spans the virtual field, so it checks the blended `tf'`.
+            if require_all_terms && tf_prime.iter().any(|tf| *tf <= 0.0) {
+                continue;
+            }
+            let score: f32 = terms
+                .iter()
+                .zip(tf_prime)
+                .map(|(term, tf)| scorer.query_weight(term) * scorer.doc_weight(*tf, *dl_prime))
+                .sum();
+            if score > 0.0 {
+                row_ids.append_value(*input_row_id);
+                scores.append_value(score);
+            }
+        }
+    }
+
+    Ok(RecordBatch::try_new(
+        FTS_SCHEMA.clone(),
+        vec![
+            Arc::new(row_ids.finish()) as ArrayRef,
+            Arc::new(scores.finish()) as ArrayRef,
+        ],
+    )?)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::super::super::tokenizer::InvertedIndexParams;
+    use super::super::super::tokenizer::document_tokenizer::DocType;
+    use super::super::testing::{flat_columns, flat_input, flat_scores};
+    use super::*;
+    use lance_select::RowAddrTreeMap;
+
+    /// Golden `(row_id, score)` for the flat BM25F scan, compared bit-for-bit.
+    ///
+    /// The blend `dl' = Σ_f w_f·dl_f` and `tf'_t = Σ_f w_f·tf_f,t` accumulates in
+    /// f32, which is not associative, and the corpus statistics it feeds are
+    /// derived from the same rows. Any change to how or where the per-column
+    /// contributions are summed has to leave these exact bits alone, so they are
+    /// pinned here rather than compared with a tolerance.
+    ///
+    /// The fixture exercises the parts that a plausible rewrite gets wrong:
+    /// non-unit and unequal weights, a row empty in one column but not the other,
+    /// a null, a row empty everywhere (dropped), and a `stats_masks` entry that
+    /// keeps one row out of one column's corpus totals.
+    #[tokio::test]
+    async fn test_flat_combined_fields_golden_scores() {
+        let row_ids: Vec<u64> = (0..7).collect();
+        let docs = vec![
+            vec![
+                Some("cat"),
+                Some("dog cat"),
+                None,
+                Some("bird"),
+                Some("cat cat dog"),
+                Some(""),
+                Some("cat dog bird"),
+            ],
+            vec![
+                Some("dog"),
+                None,
+                Some("cat dog dog"),
+                Some("fish"),
+                Some("cat"),
+                Some(""),
+                Some("bird bird"),
+            ],
+        ];
+        let weights = [1.0f32, 2.5];
+        let columns = flat_columns(&weights);
+        let tokens = Tokens::new(vec!["cat".to_string(), "dog".to_string()], DocType::Text);
+        let tokenizer = InvertedIndexParams::default().build().unwrap();
+        // Column 1 must not fold row 4 into its corpus totals (its index already
+        // holds that row); column 0 folds everything.
+        let stats_masks = vec![
+            Arc::new(RowAddrMask::all_rows()),
+            Arc::new(RowAddrMask::all_rows().also_block(RowAddrTreeMap::from_iter([4u64]))),
+        ];
+
+        let stream = flat_combined_fields_search_stream(
+            flat_input(&row_ids, &docs, 1),
+            &columns,
+            vec![1, 2],
+            &stats_masks,
+            /*emit_mask=*/ None,
+            /*flat_covers_whole_corpus=*/ false,
+            &tokens,
+            tokenizer,
+            Operator::Or,
+            3,
+            None,
+            None,
+        )
+        .await
+        .unwrap()
+        .0;
+        let (batch_sizes, scored) = flat_scores(stream).await;
+
+        // Row 5 is empty in both columns, so it never reaches the scorer, and row 3
+        // ("bird" / "fish") carries no query term, so it scores 0 and is dropped.
+        // `target_batch_size` of 3 splits the 5 survivors into 3 + 2.
+        assert_eq!(batch_sizes, vec![3, 2]);
+        assert_eq!(
+            scored,
+            vec![
+                (0, 0x3f9b_c3cf),
+                (1, 0x3f8f_0e96),
+                (2, 0x3fa6_8e68),
+                (4, 0x3f84_f2a6),
+                (6, 0x3f32_7287),
+            ]
+        );
+    }
+
+    /// The retained per-row payload must not grow with the number of target
+    /// columns. That independence is the whole point of blending during
+    /// tokenization: a `combined_fields` query over a wide column list routes the
+    /// entire dataset down this path as soon as one column's index is stale, and
+    /// the accumulation lives until the corpus statistics are complete.
+    ///
+    /// The input arrives as several batches, so this also covers the per-batch
+    /// statistics fold and that the retained rows stay in scan order across chunks.
+    #[tokio::test]
+    async fn test_flat_combined_fields_retention_is_independent_of_column_count() {
+        let row_ids: Vec<u64> = (0..64).collect();
+        let column = vec![Some("cat dog bird"); 64];
+        let tokens = Arc::new(Tokens::new(
+            vec!["cat".to_string(), "dog".to_string(), "bird".to_string()],
+            DocType::Text,
+        ));
+        let num_terms = tokens.len();
+
+        let mut footprints = Vec::new();
+        for num_columns in 1..=4usize {
+            let docs = vec![column.clone(); num_columns];
+            let (chunks, stats) = tokenize_and_blend_multi(
+                flat_input(&row_ids, &docs, 5),
+                InvertedIndexParams::default().build().unwrap(),
+                tokens.clone(),
+                Arc::new((1..=num_columns).collect()),
+                Arc::new(vec![1.0; num_columns]),
+                Arc::new(
+                    (0..num_columns)
+                        .map(|_| Arc::new(RowAddrMask::all_rows()))
+                        .collect(),
+                ),
+                None,
+            )
+            .await
+            .unwrap();
+
+            let retained: usize = chunks
+                .iter()
+                .map(|chunk| {
+                    chunk.row_ids.len() * size_of::<u64>()
+                        + (chunk.doc_lengths.len() + chunk.term_freqs.len()) * size_of::<f32>()
+                })
+                .sum();
+            let retained_row_ids: Vec<u64> = chunks
+                .iter()
+                .flat_map(|chunk| &chunk.row_ids)
+                .copied()
+                .collect();
+            assert!(chunks.len() > 1, "expected several chunks to fold");
+            assert_eq!(retained_row_ids, row_ids);
+            let rows = retained_row_ids.len();
+            // 8 bytes of row id plus `dl'` and one `tf'` per term, all f32.
+            assert_eq!(retained, rows * (8 + 4 * (1 + num_terms)));
+            footprints.push(retained);
+
+            // Every column sees the same three-token doc, so the statistics scale
+            // with the column count while the retained payload does not.
+            assert_eq!(stats.doc_counts, vec![rows; num_columns]);
+            assert_eq!(stats.total_tokens, vec![3 * rows as u64; num_columns]);
+            assert_eq!(stats.doc_freqs, vec![vec![rows; num_terms]; num_columns]);
+        }
+        assert!(footprints.windows(2).all(|pair| pair[0] == pair[1]));
+    }
+
+    /// A flat scan can legitimately see no batches at all (every scanned fragment
+    /// empty, or a prefilter that keeps nothing). The statistics fold still owes the
+    /// caller a scorer, so it reports all-zero totals rather than nothing.
+    #[tokio::test]
+    async fn test_flat_combined_fields_empty_scan_still_builds_a_scorer() {
+        let docs = vec![Vec::<Option<&str>>::new(), Vec::new()];
+        let stream = flat_combined_fields_search_stream(
+            flat_input(&[], &docs, 1),
+            &flat_columns(&[1.0, 2.5]),
+            vec![1, 2],
+            &[
+                Arc::new(RowAddrMask::all_rows()),
+                Arc::new(RowAddrMask::all_rows()),
+            ],
+            /*emit_mask=*/ None,
+            /*flat_covers_whole_corpus=*/ false,
+            &Tokens::new(vec!["cat".to_string()], DocType::Text),
+            InvertedIndexParams::default().build().unwrap(),
+            Operator::Or,
+            16,
+            None,
+            None,
+        )
+        .await
+        .unwrap()
+        .0;
+
+        let (batch_sizes, scored) = flat_scores(stream).await;
+        assert!(batch_sizes.is_empty());
+        assert!(scored.is_empty());
+    }
+}
diff --git a/rust/lance-index/src/scalar/inverted/combined/search.rs b/rust/lance-index/src/scalar/inverted/combined/search.rs
index f9650ffd5bc..65e66f2c4c1 100644
--- a/rust/lance-index/src/scalar/inverted/combined/search.rs
+++ b/rust/lance-index/src/scalar/inverted/combined/search.rs
@@ -183,7 +183,7 @@ mod tests {
     use super::super::super::index::InvertedListFormatVersion;
     use super::super::super::scorer::idf;
     use super::super::super::tokenizer::document_tokenizer::DocType;
-    use super::super::stats::build_combined_bm25_scorer;
+    use super::super::stats::{CombinedCorpusStats, build_combined_bm25_scorer};
     use super::super::testing::{
         ElementRows, as_row_documents, combined_columns, combined_top_k, element_document_index,
     };
@@ -242,7 +242,7 @@ mod tests {
         );
         assert_eq!(
             title_index
-                .bm25_row_stats_for_terms(&terms, None)
+                .bm25_row_stats_for_terms(&terms, None, None)
                 .await
                 .unwrap(),
             (19, 10, vec![1, 1]),
@@ -389,11 +389,17 @@ mod tests {
             "the fixture must still be element-per-document",
         );
         assert_eq!(
-            legacy.bm25_row_stats_for_terms(&terms, None).await.unwrap(),
+            legacy
+                .bm25_row_stats_for_terms(&terms, None, None)
+                .await
+                .unwrap(),
             (9, 4, vec![1, 3]),
         );
         assert_eq!(
-            modern.bm25_row_stats_for_terms(&terms, None).await.unwrap(),
+            modern
+                .bm25_row_stats_for_terms(&terms, None, None)
+                .await
+                .unwrap(),
             modern.bm25_stats_for_terms(&terms, None).await.unwrap(),
             "a row-per-document index must be untouched",
         );
@@ -404,6 +410,7 @@ mod tests {
         let scorer = build_combined_bm25_scorer(
             &columns,
             &Tokens::new(vec!["alpha".to_owned(), "beta".to_owned()], DocType::Text),
+            CombinedCorpusStats::IndexOnly,
             None,
         )
         .await
diff --git a/rust/lance-index/src/scalar/inverted/combined/stats.rs b/rust/lance-index/src/scalar/inverted/combined/stats.rs
index 8be1f095d52..0f21dc861ed 100644
--- a/rust/lance-index/src/scalar/inverted/combined/stats.rs
+++ b/rust/lance-index/src/scalar/inverted/combined/stats.rs
@@ -1,18 +1,146 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright The Lance Authors
 
-//! Corpus statistics for `combined_fields`: the cross-column BM25F scorer
-//! build.
+//! Corpus statistics for `combined_fields`: the flat-scan contribution
+//! ([`FlatFieldStats`]) and the cross-column BM25F scorer build.
 
 use std::collections::HashMap;
+use std::sync::Arc;
 
 use lance_core::Result;
+use lance_select::RowAddrMask;
 
 use super::super::query::Tokens;
 use super::super::scorer::CombinedFieldsBM25Scorer;
 use super::{CombinedFieldColumn, unique_terms};
 use crate::metrics::MetricsCollector;
 
+/// Per-column corpus contributions of the rows a `combined_fields` flat scan
+/// covers, i.e. rows in fragments that at least one target column's index is
+/// missing.
+///
+/// Folded into each column's own totals ahead of the BM25F cross-column blend so
+/// that `docCount'`, `docFreq'`, and `avgdl'` describe the whole scanned corpus
+/// rather than only its indexed part. Folding after the blend would be wrong:
+/// `docCount'`/`docFreq'` are a `max_f`, and `max_f(a_f) + max_f(b_f)` is not
+/// `max_f(a_f + b_f)`.
+///
+/// Every vector is indexed by the position of the column in the
+/// [`CombinedFieldColumn`] slice, and `doc_freqs[column]` is indexed by the
+/// deduplicated query term position (the order
+/// [`combined_fields_search`](super::combined_fields_search) uses).
+#[derive(Debug, Default, Clone)]
+pub struct FlatFieldStats {
+    /// Per column: flat docs with at least one token in that column.
+    pub doc_counts: Vec<usize>,
+    /// Per column: total tokens over all flat docs.
+    pub total_tokens: Vec<u64>,
+    /// `[column][term]`: flat docs containing that term in that column.
+    pub doc_freqs: Vec<Vec<usize>>,
+}
+
+impl FlatFieldStats {
+    /// An empty accumulator sized for `num_columns` columns and `num_terms`
+    /// deduplicated query terms.
+    pub(in crate::scalar::inverted) fn zeros(num_columns: usize, num_terms: usize) -> Self {
+        Self {
+            doc_counts: vec![0; num_columns],
+            total_tokens: vec![0; num_columns],
+            doc_freqs: vec![vec![0; num_terms]; num_columns],
+        }
+    }
+
+    /// Fold one flat row's per-column contribution in.
+    ///
+    /// `doc_lengths` is `dl_f` per column and `term_counts` is `[column][term]`,
+    /// both for a single row. A row absent from a field (`dl_f == 0`) counts
+    /// toward neither `docCount_f` nor `docFreq_f`, matching the indexed side
+    /// where it owns no document in that field's index.
+    ///
+    /// `stats_masks[column]` selects the rows that column's index does not
+    /// already count, so a row indexed for some target columns is not counted
+    /// twice for them. It may admit an overlay-stale row, whose old value the
+    /// index statistics then subtract (see [`CombinedFieldColumn::stale_rows`]).
+    pub(in crate::scalar::inverted) fn fold_row(
+        &mut self,
+        row_id: u64,
+        stats_masks: &[Arc<RowAddrMask>],
+        doc_lengths: &[u64],
+        term_counts: &[u64],
+    ) {
+        let num_terms = self.doc_freqs.first().map_or(0, |freqs| freqs.len());
+        for (column, doc_count) in self.doc_counts.iter_mut().enumerate() {
+            if doc_lengths[column] == 0 || !stats_masks[column].selected(row_id) {
+                continue;
+            }
+            *doc_count += 1;
+            self.total_tokens[column] += doc_lengths[column];
+            let base = column * num_terms;
+            for (term, doc_freq) in self.doc_freqs[column].iter_mut().enumerate() {
+                if term_counts[base + term] > 0 {
+                    *doc_freq += 1;
+                }
+            }
+        }
+    }
+
+    /// Add another accumulator's totals. Every field is an integer count, so
+    /// merging per-batch folds is exact and order-independent.
+    pub(in crate::scalar::inverted) fn merge(&mut self, other: Self) {
+        for (total, part) in self.doc_counts.iter_mut().zip(other.doc_counts) {
+            *total += part;
+        }
+        for (total, part) in self.total_tokens.iter_mut().zip(other.total_tokens) {
+            *total += part;
+        }
+        for (total, part) in self.doc_freqs.iter_mut().zip(other.doc_freqs) {
+            for (total, part) in total.iter_mut().zip(part) {
+                *total += part;
+            }
+        }
+    }
+}
+
+/// Which statistics [`build_combined_bm25_scorer`] folds into the BM25F blend.
+#[derive(Debug, Clone, Copy)]
+pub enum CombinedCorpusStats<'a> {
+    /// Index statistics alone: every target column's index covers every scanned
+    /// fragment, so no row was flat-scanned.
+    IndexOnly,
+    /// Index statistics plus a flat scan's contribution for the rows no index
+    /// covers. The masks the fold applied decide which rows those are, and so
+    /// whether a row lands on one side or, deliberately, on both.
+    Blended(&'a FlatFieldStats),
+    /// A flat scan's statistics alone, covering the whole target corpus.
+    ///
+    /// For a legacy segment, which cannot name the rows an overlay made stale, so
+    /// their pre-overlay values cannot be subtracted from its statistics.
+    FlatOnly(&'a FlatFieldStats),
+}
+
+impl<'a> CombinedCorpusStats<'a> {
+    /// The variant for a flat scan's statistics, by whether the scan read every
+    /// target fragment or only the rows no index covers.
+    pub fn for_flat_scan(flat: &'a FlatFieldStats, covers_whole_corpus: bool) -> Self {
+        if covers_whole_corpus {
+            Self::FlatOnly(flat)
+        } else {
+            Self::Blended(flat)
+        }
+    }
+
+    fn flat(&self) -> Option<&'a FlatFieldStats> {
+        match self {
+            Self::IndexOnly => None,
+            Self::Blended(flat) | Self::FlatOnly(flat) => Some(flat),
+        }
+    }
+
+    fn folds_index_stats(&self) -> bool {
+        !matches!(self, Self::FlatOnly(_))
+    }
+}
+
 /// Fold the target columns' segment statistics into a single [`CombinedFieldsBM25Scorer`].
 ///
 /// Generalizes [`build_global_bm25_scorer`](super::super::build_global_bm25_scorer)
@@ -23,34 +151,44 @@ use crate::metrics::MetricsCollector;
 /// deduplicates them, so the resulting per-term `docFreq'` covers exactly the
 /// terms [`combined_fields_search`](super::combined_fields_search) scores.
 ///
+/// `corpus` selects which statistics the blend is built from; see
+/// [`CombinedCorpusStats`].
+///
 /// `metrics`, when provided, receives the per-token posting-metadata cache
 /// lookups this fold triggers, exactly as
 /// [`build_global_bm25_scorer`](super::super::build_global_bm25_scorer)
 /// reports them on the single-column path. Without it a cold cross-field query
 /// undercounts `index_cache_misses` by one lookup per (term, partition, column).
+/// [`CombinedCorpusStats::FlatOnly`] reads none, so it reports none.
 pub async fn build_combined_bm25_scorer(
     columns: &[CombinedFieldColumn],
     tokens: &Tokens,
+    corpus: CombinedCorpusStats<'_>,
     metrics: Option<&dyn MetricsCollector>,
 ) -> Result<CombinedFieldsBM25Scorer> {
     let terms = unique_terms(tokens);
+    if let Some(flat) = corpus.flat() {
+        debug_assert_eq!(flat.doc_counts.len(), columns.len());
+        debug_assert!(flat.doc_freqs.iter().all(|df| df.len() == terms.len()));
+    }
     let mut doc_count = 0usize;
     let mut sum_total_term_freq = 0f64;
     let mut doc_freq: HashMap<String, usize> = terms.iter().map(|t| (t.clone(), 0)).collect();
 
-    for column in columns {
+    for (column_slot, column) in columns.iter().enumerate() {
         let mut column_num_docs = 0usize;
         let mut column_total_tokens = 0u64;
         let mut column_doc_freq = vec![0usize; terms.len()];
-        {
+        if corpus.folds_index_stats() {
             for index in &column.indices {
                 // Row granularity, not document granularity: `combined_fields_search`
                 // blends every posting a row owns into one `tf'` and every document
                 // length it owns into one `dl'`, and released V1/V2 indexes may hold
                 // one document per list element. See
                 // [`InvertedIndex::bm25_row_stats_for_terms`].
-                let (total_tokens, num_docs, token_docs) =
-                    index.bm25_row_stats_for_terms(&terms, metrics).await?;
+                let (total_tokens, num_docs, token_docs) = index
+                    .bm25_row_stats_for_terms(&terms, column.stale_rows.as_deref(), metrics)
+                    .await?;
                 column_total_tokens += total_tokens;
                 column_num_docs += num_docs;
                 for (slot, df) in token_docs.into_iter().enumerate() {
@@ -58,6 +196,13 @@ pub async fn build_combined_bm25_scorer(
                 }
             }
         }
+        if let Some(flat) = corpus.flat() {
+            column_num_docs += flat.doc_counts[column_slot];
+            column_total_tokens += flat.total_tokens[column_slot];
+            for (slot, df) in flat.doc_freqs[column_slot].iter().enumerate() {
+                column_doc_freq[slot] += df;
+            }
+        }
 
         doc_count = doc_count.max(column_num_docs);
         sum_total_term_freq += column.weight as f64 * column_total_tokens as f64;
@@ -84,13 +229,58 @@ pub async fn build_combined_bm25_scorer(
 #[cfg(test)]
 mod tests {
     use super::super::super::index::InvertedListFormatVersion;
+    use super::super::super::tokenizer::InvertedIndexParams;
     use super::super::super::tokenizer::document_tokenizer::DocType;
-    use super::super::testing::{ElementRows, combined_columns, element_document_index};
+    use super::super::flat::flat_combined_fields_search_stream;
+    use super::super::testing::{
+        ElementRows, combined_columns, element_document_index, flat_input, flat_scores,
+    };
     use super::*;
     use crate::metrics::LocalMetricsCollector;
+    use crate::scalar::inverted::query::Operator;
+    use lance_select::RowAddrTreeMap;
     use rstest::rstest;
 
-    /// The scorer build must report its index cache lookups to the query's
+    /// The statistics fold runs per batch and the partial results are merged, so
+    /// it must not matter how the scan is chunked.
+    #[test]
+    fn test_flat_field_stats_fold_is_split_invariant() {
+        // Two columns, two terms. Row 7 is empty in column 1 and row 9 is masked
+        // out of column 1, so neither contributes there.
+        let rows: [(u64, [u64; 2], [u64; 4]); 3] = [
+            (7, [4, 0], [1, 0, 0, 0]),
+            (8, [3, 5], [1, 1, 2, 0]),
+            (9, [2, 6], [0, 1, 1, 1]),
+        ];
+        let masks = vec![
+            Arc::new(RowAddrMask::all_rows()),
+            Arc::new(RowAddrMask::all_rows().also_block(RowAddrTreeMap::from_iter([9u64]))),
+        ];
+        let fold = |rows: &[(u64, [u64; 2], [u64; 4])]| {
+            let mut stats = FlatFieldStats::zeros(2, 2);
+            for (row_id, lengths, counts) in rows {
+                stats.fold_row(*row_id, &masks, lengths, counts);
+            }
+            stats
+        };
+
+        let whole = fold(&rows);
+        assert_eq!(whole.doc_counts, vec![3, 1]);
+        assert_eq!(whole.total_tokens, vec![9, 5]);
+        // Column 0: "cat" in rows 7 and 8, "dog" in rows 8 and 9.
+        // Column 1: only row 8 counts, with "cat" present and "dog" absent.
+        assert_eq!(whole.doc_freqs, vec![vec![2, 2], vec![1, 0]]);
+
+        for split in 0..=rows.len() {
+            let mut merged = fold(&rows[..split]);
+            merged.merge(fold(&rows[split..]));
+            assert_eq!(merged.doc_counts, whole.doc_counts, "split at {split}");
+            assert_eq!(merged.total_tokens, whole.total_tokens, "split at {split}");
+            assert_eq!(merged.doc_freqs, whole.doc_freqs, "split at {split}");
+        }
+    }
+
+    /// Both scorer builds must report their index cache lookups to the query's
     /// collector, the way the single-column `build_global_bm25_scorer` does; see
     /// [`build_combined_bm25_scorer`] for what goes wrong otherwise.
     ///
@@ -118,13 +308,49 @@ mod tests {
         let expected_lookups = 2 * columns.len();
 
         let indexed = LocalMetricsCollector::default();
-        build_combined_bm25_scorer(&columns, &tokens, Some(&indexed))
-            .await
-            .unwrap();
+        build_combined_bm25_scorer(
+            &columns,
+            &tokens,
+            CombinedCorpusStats::IndexOnly,
+            Some(&indexed),
+        )
+        .await
+        .unwrap();
         assert_eq!(
             indexed.index_cache_hits() + indexed.index_cache_misses(),
             expected_lookups,
-            "the scorer build must report every cache lookup it makes",
+            "indexed scorer build must report every cache lookup it makes",
+        );
+
+        // The flat sibling folds the same per-column index statistics in, so its
+        // build reports the same lookups. An empty input isolates them: the
+        // scanned rows contribute no index reads at all.
+        let flat = LocalMetricsCollector::default();
+        let stream = flat_combined_fields_search_stream(
+            flat_input(&[], &[Vec::new(), Vec::new()], 1),
+            &columns,
+            vec![1, 2],
+            &[
+                Arc::new(RowAddrMask::all_rows()),
+                Arc::new(RowAddrMask::all_rows()),
+            ],
+            /*emit_mask=*/ None,
+            /*flat_covers_whole_corpus=*/ false,
+            &tokens,
+            InvertedIndexParams::default().build().unwrap(),
+            Operator::Or,
+            16,
+            None,
+            Some(&flat),
+        )
+        .await
+        .unwrap()
+        .0;
+        assert!(flat_scores(stream).await.1.is_empty());
+        assert_eq!(
+            flat.index_cache_hits() + flat.index_cache_misses(),
+            expected_lookups,
+            "flat scorer build must report every cache lookup it makes",
         );
     }
 
@@ -158,7 +384,10 @@ mod tests {
         let documents = index.bm25_stats_for_terms(&terms, None).await.unwrap();
         assert_eq!(documents, (5, 3, vec![2, 2, 0]));
         assert_eq!(
-            index.bm25_row_stats_for_terms(&terms, None).await.unwrap(),
+            index
+                .bm25_row_stats_for_terms(&terms, None, None)
+                .await
+                .unwrap(),
             documents
         );
     }
@@ -201,7 +430,10 @@ mod tests {
             (4, 4, vec![2, 2]),
         );
         assert_eq!(
-            index.bm25_row_stats_for_terms(&terms, None).await.unwrap(),
+            index
+                .bm25_row_stats_for_terms(&terms, None, None)
+                .await
+                .unwrap(),
             (4, 2, vec![1, 2]),
         );
     }
diff --git a/rust/lance-index/src/scalar/inverted/combined/testing.rs b/rust/lance-index/src/scalar/inverted/combined/testing.rs
index e6f83fa60d6..21f187e4c74 100644
--- a/rust/lance-index/src/scalar/inverted/combined/testing.rs
+++ b/rust/lance-index/src/scalar/inverted/combined/testing.rs
@@ -8,9 +8,15 @@
 use std::collections::HashMap;
 use std::sync::Arc;
 
+use arrow::array::AsArray;
+use arrow::datatypes::{Float32Type, UInt64Type};
 use arrow_array::{ArrayRef, RecordBatch, UInt32Array, UInt64Array};
+use datafusion::execution::SendableRecordBatchStream;
+use datafusion::physical_plan::stream::RecordBatchStreamAdapter;
+use futures::stream;
 use lance_core::Result;
 use lance_core::cache::{LanceCache, WeakLanceCache};
+use lance_core::error::DataFusionResult;
 use lance_core::utils::tempfile::TempObjDir;
 use lance_io::object_store::ObjectStore;
 use lance_select::RowAddrTreeMap;
@@ -29,7 +35,9 @@ use super::super::index::{
 use super::super::query::{FtsSearchParams, Operator, Tokens};
 use super::super::tokenizer::document_tokenizer::DocType;
 use super::super::tokenizer::{InvertedIndexParams, LEGACY_BLOCK_SIZE};
-use super::{CombinedFieldColumn, build_combined_bm25_scorer, combined_fields_search};
+use super::{
+    CombinedCorpusStats, CombinedFieldColumn, build_combined_bm25_scorer, combined_fields_search,
+};
 use crate::metrics::NoOpMetricsCollector;
 use crate::prefilter::NoFilter;
 use crate::scalar::lance_format::LanceIndexStore;
@@ -135,6 +143,71 @@ pub(super) async fn modern_identity_docs(
     .unwrap()
 }
 
+/// `_rowid` plus one `Utf8` document column per entry of `docs`
+/// (`docs[column][row]`), delivered as `num_batches` equal batches.
+pub(super) fn flat_input(
+    row_ids: &[u64],
+    docs: &[Vec<Option<&str>>],
+    num_batches: usize,
+) -> SendableRecordBatchStream {
+    use arrow_array::StringArray;
+    use arrow_schema::{DataType, Field, Schema};
+
+    let mut fields = vec![lance_core::ROW_ID_FIELD.clone()];
+    let mut arrays: Vec<ArrayRef> = vec![Arc::new(UInt64Array::from(row_ids.to_vec()))];
+    for (slot, column) in docs.iter().enumerate() {
+        fields.push(Field::new(format!("doc{slot}"), DataType::Utf8, true));
+        arrays.push(Arc::new(StringArray::from(column.clone())));
+    }
+    let schema = Arc::new(Schema::new(fields));
+    let batch = RecordBatch::try_new(schema.clone(), arrays).unwrap();
+    // No rows means no batches at all, the way an empty scan arrives.
+    let rows_per_batch = row_ids.len().div_ceil(num_batches.max(1));
+    let batches = (0..row_ids.len().div_ceil(rows_per_batch.max(1)))
+        .map(|i| {
+            let start = i * rows_per_batch;
+            let len = (row_ids.len() - start).min(rows_per_batch);
+            DataFusionResult::Ok(batch.slice(start, len))
+        })
+        .collect::<Vec<_>>();
+    Box::pin(RecordBatchStreamAdapter::new(schema, stream::iter(batches)))
+}
+
+pub(super) fn flat_columns(weights: &[f32]) -> Vec<CombinedFieldColumn> {
+    weights
+        .iter()
+        .enumerate()
+        .map(|(slot, weight)| CombinedFieldColumn {
+            column: format!("doc{slot}"),
+            weight: *weight,
+            indices: Vec::new(),
+            stale_rows: None,
+        })
+        .collect()
+}
+
+/// Every `(row_id, score)` the flat scan emits, in emission order, with the
+/// score as raw bits so the comparison is exact.
+pub(super) async fn flat_scores(
+    stream: SendableRecordBatchStream,
+) -> (Vec<usize>, Vec<(u64, u32)>) {
+    use futures::TryStreamExt;
+
+    let batches: Vec<RecordBatch> = stream.try_collect().await.unwrap();
+    let sizes = batches.iter().map(|batch| batch.num_rows()).collect();
+    let scored = batches
+        .iter()
+        .flat_map(|batch| {
+            let row_ids = batch.column(0).as_primitive::<UInt64Type>();
+            let scores = batch.column(1).as_primitive::<Float32Type>();
+            (0..batch.num_rows())
+                .map(|i| (row_ids.value(i), scores.value(i).to_bits()))
+                .collect::<Vec<_>>()
+        })
+        .collect();
+    (sizes, scored)
+}
+
 // Legacy element-per-document corpus statistics.
 //
 // Released V1/V2 indexes indexed every `List<String>` element as its own document,
@@ -270,6 +343,7 @@ pub(super) fn combined_columns(indices: Vec<Arc<InvertedIndex>>) -> Vec<Combined
             column: format!("col{slot}"),
             weight: 1.0,
             indices: vec![index],
+            stale_rows: None,
         })
         .collect()
 }
@@ -284,7 +358,7 @@ pub(super) async fn combined_top_k(
         terms.iter().map(|t| (*t).to_owned()).collect(),
         DocType::Text,
     );
-    let scorer = build_combined_bm25_scorer(columns, &tokens, None)
+    let scorer = build_combined_bm25_scorer(columns, &tokens, CombinedCorpusStats::IndexOnly, None)
         .await
         .unwrap();
     let params = FtsSearchParams::new().with_limit(Some(limit));
diff --git a/rust/lance-index/src/scalar/inverted/index.rs b/rust/lance-index/src/scalar/inverted/index.rs
index d2b039ff07a..66d9feb8115 100644
--- a/rust/lance-index/src/scalar/inverted/index.rs
+++ b/rust/lance-index/src/scalar/inverted/index.rs
@@ -51,7 +51,7 @@ use lance_core::utils::address::RowAddress;
 use lance_core::utils::tokio::{get_num_compute_intensive_cpus, spawn_cpu};
 use lance_core::utils::tracing::{IO_TYPE_LOAD_SCALAR_PART, TRACE_IO_EVENTS};
 use lance_core::{Error, ROW_ID, ROW_ID_FIELD, Result};
-use lance_select::{RowAddrMask, RowAddrTreeMap};
+use lance_select::{RowAddrMask, RowAddrTreeMap, RowSetOps};
 use roaring::{RoaringBitmap, RoaringTreemap};
 use std::sync::LazyLock;
 use tokio::{
@@ -68,7 +68,9 @@ use super::encoding::{MAX_POSTING_BLOCK_SIZE, PositionBlockBuilder};
 use super::impact::{IMPACT_LEVEL1_BLOCKS, ImpactSkipData, ImpactSkipDataBuilder};
 use super::iter::PostingListIterator;
 use super::tokenizer::{LEGACY_BLOCK_SIZE, validate_block_size};
-use super::{DocumentGranularity, InvertedIndexBuilder, InvertedIndexParams, wand::*};
+use super::{
+    DocumentGranularity, FlatFieldStats, InvertedIndexBuilder, InvertedIndexParams, wand::*,
+};
 use super::{
     builder::{
         BLOCK_SIZE, ScoredDoc, doc_file_path,
diff --git a/rust/lance-index/src/scalar/inverted/index/flat_search.rs b/rust/lance-index/src/scalar/inverted/index/flat_search.rs
index 90c6946b2cc..136d202f2e6 100644
--- a/rust/lance-index/src/scalar/inverted/index/flat_search.rs
+++ b/rust/lance-index/src/scalar/inverted/index/flat_search.rs
@@ -521,6 +521,203 @@ pub(super) fn tokenize_and_count_list<ListOffset: OffsetSizeTrait>(
     Ok(())
 }
 
+/// One chunk's worth of blended per-row BM25F scoring inputs: everything a flat
+/// `combined_fields` scan retains until the corpus statistics are complete.
+/// `8 + 4·(1 + t)` bytes per row for `t` terms, independent of the column count.
+pub(in super::super) struct BlendedRows {
+    /// `_rowid` of every retained row.
+    pub(in super::super) row_ids: Vec<u64>,
+    /// `dl'(d) = Σ_f w_f · dl_f(d)`, one per retained row.
+    pub(in super::super) doc_lengths: Vec<f32>,
+    /// `tf'(t, d) = Σ_f w_f · tf_f(t, d)`, `num_terms`-strided by row.
+    pub(in super::super) term_freqs: Vec<f32>,
+}
+
+/// Count the query tokens in every target column of a flat batch stream and blend
+/// them into per-row BM25F scoring inputs, retaining a row when any column has
+/// tokens.
+///
+/// Unlike [`tokenize_and_count`], this walks all target columns in one pass,
+/// since a row may be empty in one field and populated in another. The
+/// per-column counts are dropped with each batch once blended; only the
+/// fixed-size [`FlatFieldStats`] needs them, so it is folded here, gated by
+/// `stats_masks`.
+pub(in super::super) async fn tokenize_and_blend_multi(
+    input: impl Stream<Item = DataFusionResult<RecordBatch>> + Send,
+    tokenizer: Box<dyn LanceTokenizer>,
+    query_tokens: Arc<Tokens>,
+    doc_col_indices: Arc<Vec<usize>>,
+    weights: Arc<Vec<f32>>,
+    stats_masks: Arc<Vec<Arc<RowAddrMask>>>,
+    elapsed_compute: Option<Time>,
+) -> DataFusionResult<(Vec<BlendedRows>, FlatFieldStats)> {
+    let num_columns = doc_col_indices.len();
+    let num_terms = query_tokens.len();
+    let retained_bytes_per_row = (size_of::<u64>() + (1 + num_terms) * size_of::<f32>()) as u64;
+    let query_token_indices = Arc::new(query_token_indices(query_tokens.as_ref()));
+    let bytes_accumulated = Arc::new(AtomicU64::new(0));
+    let bytes_warning_emitted = Arc::new(AtomicBool::new(false));
+
+    let tasks = input
+        .map(move |batch| {
+            let mut tokenizer = tokenizer.box_clone();
+            let query_token_indices = query_token_indices.clone();
+            let doc_col_indices = doc_col_indices.clone();
+            let weights = weights.clone();
+            let stats_masks = stats_masks.clone();
+            let bytes_accumulated = bytes_accumulated.clone();
+            let bytes_warning_emitted = bytes_warning_emitted.clone();
+            let elapsed_compute = elapsed_compute.clone();
+            spawn_cpu(move || {
+                let start = std::time::Instant::now();
+                let batch = batch?;
+                let num_rows = batch.num_rows();
+                let row_id_array = batch[ROW_ID].as_primitive::<UInt64Type>();
+
+                // Dense `(row, column)`-strided scratch, freed with the batch:
+                // whether a row is retained depends on all of its columns, so every
+                // column is counted before any row is filtered.
+                let mut all_tokens = vec![0u64; num_rows * num_columns];
+                let mut counts = vec![0u64; num_rows * num_columns * num_terms];
+                for (column_slot, doc_col_idx) in doc_col_indices.iter().enumerate() {
+                    count_column_into(
+                        batch.column(*doc_col_idx),
+                        num_columns,
+                        num_terms,
+                        column_slot,
+                        &mut tokenizer,
+                        &query_token_indices,
+                        &mut all_tokens,
+                        &mut counts,
+                    )?;
+                }
+
+                let mut blended = BlendedRows {
+                    row_ids: Vec::with_capacity(num_rows),
+                    doc_lengths: Vec::with_capacity(num_rows),
+                    term_freqs: Vec::with_capacity(num_rows * num_terms),
+                };
+                let mut stats = FlatFieldStats::zeros(num_columns, num_terms);
+                let counts_stride = num_columns * num_terms;
+                for row in 0..num_rows {
+                    let lengths = &all_tokens[row * num_columns..(row + 1) * num_columns];
+                    // Empty in every target column: `dl' == 0` and `tf' == 0`, so the
+                    // row cannot score. Dropping it here also keeps it out of the
+                    // corpus statistics, matching the indexed side (a row absent from
+                    // every field's DocSet contributes to no `docCount_f`).
+                    if lengths.iter().all(|length| *length == 0) {
+                        continue;
+                    }
+                    let row_id = row_id_array.value(row);
+                    let row_counts = &counts[row * counts_stride..(row + 1) * counts_stride];
+
+                    // Accumulate in column-slot order. f32 addition is not
+                    // associative, so this order is part of the contract: it keeps
+                    // the scores identical to summing the same contributions
+                    // downstream from a materialized breakdown.
+                    let terms_start = blended.term_freqs.len();
+                    blended.term_freqs.resize(terms_start + num_terms, 0.0);
+                    let term_freqs = &mut blended.term_freqs[terms_start..];
+                    let mut doc_length = 0f32;
+                    for (column, weight) in weights.iter().enumerate() {
+                        doc_length += weight * lengths[column] as f32;
+                        let base = column * num_terms;
+                        for (term, tf) in term_freqs.iter_mut().enumerate() {
+                            *tf += weight * row_counts[base + term] as f32;
+                        }
+                    }
+                    blended.row_ids.push(row_id);
+                    blended.doc_lengths.push(doc_length);
+
+                    stats.fold_row(row_id, &stats_masks, lengths, row_counts);
+                }
+
+                let bytes_accumulated = bytes_accumulated.fetch_add(
+                    blended.row_ids.len() as u64 * retained_bytes_per_row,
+                    Ordering::Relaxed,
+                );
+                if bytes_accumulated > BYTES_ACCUMULATED_WARNING_THRESHOLD
+                    && !bytes_warning_emitted.swap(true, Ordering::Relaxed)
+                {
+                    tracing::warn!(
+                        "Flat combined_fields search is accumulating a large number of bytes.  Consider indexing every target column instead."
+                    );
+                }
+                if let Some(t) = &elapsed_compute {
+                    t.add_duration(start.elapsed());
+                }
+                DataFusionResult::Ok((blended, stats))
+            })
+        })
+        .buffered(get_num_compute_intensive_cpus());
+
+    // Folded incrementally rather than collected and concatenated: the retained
+    // rows are already the whole accumulation, so a second contiguous copy would
+    // double the peak for nothing.
+    let mut tasks = std::pin::pin!(tasks);
+    let mut chunks = Vec::new();
+    // Seeded rather than taken from the first batch so that a scan with no batches
+    // at all still reports statistics, as all-zero totals.
+    let mut totals = FlatFieldStats::zeros(num_columns, num_terms);
+    while let Some(counted) = tasks.next().await {
+        let (blended, stats) = counted?;
+        totals.merge(stats);
+        chunks.push(blended);
+    }
+    Ok((chunks, totals))
+}
+
+/// Tokenize one column into the `(row, column_slot)`-strided slots of
+/// `all_tokens` / `counts`. Mirrors [`tokenize_and_count`]'s per-type handling: a
+/// list column sums over its elements and a null leaves the slots at zero.
+#[allow(clippy::too_many_arguments)]
+fn count_column_into(
+    doc_col: &ArrayRef,
+    num_columns: usize,
+    num_terms: usize,
+    column_slot: usize,
+    tokenizer: &mut Box<dyn LanceTokenizer>,
+    query_token_indices: &HashMap<String, Vec<usize>>,
+    all_tokens: &mut [u64],
+    counts: &mut [u64],
+) -> DataFusionResult<()> {
+    let mut record = |row: usize, doc: &str| {
+        let slot = row * num_columns + column_slot;
+        let base = slot * num_terms;
+        let mut stream = tokenizer.token_stream_for_doc(doc);
+        while let Some(token) = stream.next() {
+            all_tokens[slot] += 1;
+            if let Some(token_indices) = query_token_indices.get(&token.text) {
+                for token_index in token_indices {
+                    counts[base + *token_index] += 1;
+                }
+            }
+        }
+    };
+    match doc_col.data_type() {
+        DataType::Utf8 | DataType::LargeUtf8 => {
+            for (row, doc) in iter_str_array(doc_col.as_ref()).enumerate() {
+                if let Some(doc) = doc {
+                    record(row, doc);
+                }
+            }
+        }
+        // One string per row is the whole contract: a caller whose field path
+        // crosses a `List` owes a column already reduced to a row's document text
+        // (the planner uses `flatten_fts_document_column`), because reducing it
+        // here would count the elements separately and diverge from the single row
+        // document the index builder wrote.
+        data_type => {
+            return Err(datafusion_common::DataFusionError::Execution(format!(
+                "flat combined_fields search needs one string per row per column, got {}; \
+                 reduce a list-bearing field path to its row document first",
+                data_type
+            )));
+        }
+    }
+    Ok(())
+}
+
 pub(super) fn query_token_indices(query_tokens: &Tokens) -> HashMap<String, Vec<usize>> {
     let mut indices = HashMap::new();
     for idx in 0..query_tokens.len() {
@@ -948,13 +1145,7 @@ pub async fn flat_bm25_search_stream_with_options_and_scorer(
     )?;
 
     // Finally we emit batches according to the target batch size
-    let num_out_batches = scores.num_rows().div_ceil(target_batch_size);
-    let mut batches = Vec::with_capacity(num_out_batches);
-    for i in 0..num_out_batches {
-        let start = i * target_batch_size;
-        let len = (scores.num_rows() - start).min(target_batch_size);
-        batches.push(Ok(scores.slice(start, len)));
-    }
+    let batches = slice_into_batches(scores, target_batch_size);
     if let Some(t) = &elapsed_compute {
         t.add_duration(post_await_start.elapsed());
     }
@@ -967,6 +1158,23 @@ pub async fn flat_bm25_search_stream_with_options_and_scorer(
     ))
 }
 
+/// Cut one scored batch into the `target_batch_size` chunks a flat FTS scan
+/// emits. Slicing is zero-copy, so the whole scan's scores stay in one
+/// allocation.
+pub(in super::super) fn slice_into_batches(
+    batch: RecordBatch,
+    target_batch_size: usize,
+) -> Vec<DataFusionResult<RecordBatch>> {
+    let num_out_batches = batch.num_rows().div_ceil(target_batch_size);
+    let mut batches = Vec::with_capacity(num_out_batches);
+    for i in 0..num_out_batches {
+        let start = i * target_batch_size;
+        let len = (batch.num_rows() - start).min(target_batch_size);
+        batches.push(Ok(batch.slice(start, len)));
+    }
+    batches
+}
+
 pub fn is_phrase_query(query: &str) -> bool {
     phrase_query_text(query).is_some()
 }
diff --git a/rust/lance-index/src/scalar/inverted/index/partition.rs b/rust/lance-index/src/scalar/inverted/index/partition.rs
index 057d3ec2824..1f7c66f584b 100644
--- a/rust/lance-index/src/scalar/inverted/index/partition.rs
+++ b/rust/lance-index/src/scalar/inverted/index/partition.rs
@@ -742,6 +742,64 @@ impl InvertedPartition {
         Ok((num_rows, row_freqs))
     }
 
+    /// This partition's share of `stale_rows`, counted the same way
+    /// [`Self::row_stats_for_terms`] counts the whole partition, so the caller can
+    /// subtract one from the other.
+    ///
+    /// Rows this partition holds no document for are skipped, so it is fine to pass
+    /// rows that live elsewhere.
+    pub(super) async fn stale_row_stats_for_terms(
+        &self,
+        terms: &[String],
+        stale_rows: &RowAddrTreeMap,
+        metrics: Option<&dyn MetricsCollector>,
+    ) -> Result<(u64, usize, Vec<usize>)> {
+        let mut row_freqs = vec![0usize; terms.len()];
+        let Some(addresses) = stale_rows.row_addrs() else {
+            // A whole-fragment marker names no row to look up in a posting list.
+            return Err(Error::invalid_input(
+                "FTS corpus statistics cannot subtract overlay-stale rows named by whole fragments"
+                    .to_string(),
+            ));
+        };
+        let docs = self.docs.address_keyed().await?;
+        let mut total_tokens = 0u64;
+        let mut stale = RoaringTreemap::new();
+        for address in addresses {
+            let address = u64::from(address);
+            let doc_length = docs.doc_length_at(address);
+            if doc_length == 0 {
+                continue;
+            }
+            total_tokens += doc_length;
+            stale.insert(address);
+        }
+        if stale.is_empty() {
+            return Ok((0, 0, row_freqs));
+        }
+        let is_legacy = self.is_legacy();
+        for (slot, term) in terms.iter().enumerate() {
+            let Some(token_id) = self.tokens.get(term) else {
+                continue;
+            };
+            // Whether a row held the term before the overlay is only visible in the
+            // posting list itself, so this reads it rather than taking the
+            // `posting_len_for_token` count the unrestricted path uses.
+            let posting = self
+                .inverted_list
+                .posting_list(token_id, false, metrics.unwrap_or(&NoOpMetricsCollector))
+                .await?;
+            let mut rows = RoaringTreemap::new();
+            for (row_id, _) in live_posting_rows(&posting, &docs, is_legacy) {
+                if stale.contains(row_id) {
+                    rows.insert(row_id);
+                }
+            }
+            row_freqs[slot] = rows.len() as usize;
+        }
+        Ok((total_tokens, stale.len() as usize, row_freqs))
+    }
+
     pub async fn load(
         store: Arc<dyn IndexStore>,
         id: u64,
diff --git a/rust/lance-index/src/scalar/inverted/index/search.rs b/rust/lance-index/src/scalar/inverted/index/search.rs
index be3bd144ecd..db5f640cb27 100644
--- a/rust/lance-index/src/scalar/inverted/index/search.rs
+++ b/rust/lance-index/src/scalar/inverted/index/search.rs
@@ -205,6 +205,76 @@ impl InvertedIndex {
     /// statistics trigger, so both granularities report comparable
     /// `index_cache_hits`/`index_cache_misses`.
     pub async fn bm25_row_stats_for_terms(
+        &self,
+        terms: &[String],
+        stale_rows: Option<&RowAddrTreeMap>,
+        metrics: Option<&dyn MetricsCollector>,
+    ) -> Result<(u64, usize, Vec<usize>)> {
+        let base = self.bm25_row_stats_for_terms_unrestricted(terms, metrics);
+        let Some(stale_rows) = stale_rows.filter(|rows| !rows.is_empty()) else {
+            return base.await;
+        };
+        let (total_tokens, num_rows, mut row_freqs) = base.await?;
+        let (stale_tokens, stale_num_rows, stale_freqs) = self
+            .stale_row_stats_for_terms(terms, stale_rows, metrics)
+            .await?;
+        for (total, stale) in row_freqs.iter_mut().zip(stale_freqs) {
+            *total = total.saturating_sub(stale);
+        }
+        Ok((
+            total_tokens.saturating_sub(stale_tokens),
+            num_rows.saturating_sub(stale_num_rows),
+            row_freqs,
+        ))
+    }
+
+    /// What the rows an overlay made stale still contribute to this index's
+    /// statistics, for the caller to subtract.
+    ///
+    /// The index holds their pre-overlay values until it is optimized, and the flat
+    /// scan folds in their current ones. Counting both inflates `docCount` and
+    /// `docFreq`, which is enough to reorder results after an overlay that changed
+    /// no searchable value.
+    async fn stale_row_stats_for_terms(
+        &self,
+        terms: &[String],
+        stale_rows: &RowAddrTreeMap,
+        metrics: Option<&dyn MetricsCollector>,
+    ) -> Result<(u64, usize, Vec<usize>)> {
+        let io_parallelism = self.store.io_parallelism();
+        let futures = self
+            .partitions
+            .iter()
+            .map(|partition| {
+                let partition = partition.clone();
+                async move {
+                    partition
+                        .stale_row_stats_for_terms(terms, stale_rows, metrics)
+                        .await
+                }
+            })
+            .collect::<Vec<_>>();
+        let per_partition: Vec<(u64, usize, Vec<usize>)> = stream::iter(futures)
+            .buffer_unordered(io_parallelism)
+            .try_collect()
+            .await?;
+
+        let mut total_tokens = 0u64;
+        let mut num_rows = 0usize;
+        let mut row_freqs = vec![0usize; terms.len()];
+        // Partitions hold disjoint row sets, so a row lands in at most one of these.
+        for (partition_tokens, partition_rows, partition_freqs) in per_partition {
+            total_tokens += partition_tokens;
+            num_rows += partition_rows;
+            for (total, partition_freq) in row_freqs.iter_mut().zip(partition_freqs) {
+                *total += partition_freq;
+            }
+        }
+        Ok((total_tokens, num_rows, row_freqs))
+    }
+
+    /// [`Self::bm25_row_stats_for_terms`] with nothing subtracted.
+    async fn bm25_row_stats_for_terms_unrestricted(
         &self,
         terms: &[String],
         metrics: Option<&dyn MetricsCollector>,
diff --git a/rust/lance-index/src/scalar/inverted/index/tests/stats.rs b/rust/lance-index/src/scalar/inverted/index/tests/stats.rs
index 7c23d2c4337..e5ec2f558ba 100644
--- a/rust/lance-index/src/scalar/inverted/index/tests/stats.rs
+++ b/rust/lance-index/src/scalar/inverted/index/tests/stats.rs
@@ -358,7 +358,10 @@ async fn test_bm25_row_stats_for_terms_keeps_the_lazy_posting_metadata_path() {
     assert_eq!(metadata_rows, 1);
 
     assert_eq!(
-        index.bm25_row_stats_for_terms(&terms, None).await.unwrap(),
+        index
+            .bm25_row_stats_for_terms(&terms, None, None)
+            .await
+            .unwrap(),
         documents,
         "one document per row leaves the two granularities identical",
     );
@@ -427,7 +430,7 @@ async fn test_bm25_row_stats_for_terms_records_metadata_cache_stats() {
     let terms = ["t0".to_string(), "t1".to_string(), "t2".to_string()];
     let cold = LocalMetricsCollector::default();
     let cold_stats = index
-        .bm25_row_stats_for_terms(&terms, Some(&cold))
+        .bm25_row_stats_for_terms(&terms, None, Some(&cold))
         .await
         .unwrap();
     assert_eq!(cold_stats, (100, 100, vec![1, 1, 1]));
@@ -437,7 +440,7 @@ async fn test_bm25_row_stats_for_terms_records_metadata_cache_stats() {
     let warm = LocalMetricsCollector::default();
     assert_eq!(
         index
-            .bm25_row_stats_for_terms(&terms, Some(&warm))
+            .bm25_row_stats_for_terms(&terms, None, Some(&warm))
             .await
             .unwrap(),
         cold_stats,
diff --git a/rust/lance/src/dataset/scanner.rs b/rust/lance/src/dataset/scanner.rs
index c81afb9b663..8f97287d08c 100644
--- a/rust/lance/src/dataset/scanner.rs
+++ b/rust/lance/src/dataset/scanner.rs
@@ -115,8 +115,9 @@ use crate::io::exec::filtered_read::{
 };
 use crate::io::exec::fts::{
     BoostQueryExec, CombinedFieldsQueryExec, CompoundQueryExec, CrossColumnCompoundQueryExec,
-    FlatMatchFilterExec, FlatMatchQueryExec, FtsDocumentExec, HybridCompoundQueryExec,
-    MatchQueryExec, PhraseQueryExec, SharedFtsScorer,
+    FlatCombinedFieldsExec, FlatMatchFilterExec, FlatMatchQueryExec, FlatStatsCoverage,
+    FlatStatsScope, FtsDocumentExec, HybridCompoundQueryExec, MatchQueryExec, PhraseQueryExec,
+    SharedFtsScorer,
 };
 use crate::io::exec::knn::MultivectorScoringExec;
 use crate::io::exec::scalar_index::{MaterializeIndexExec, ScalarIndexExec};
@@ -173,6 +174,18 @@ enum FtsOverlayPlan {
     FullScan,
 }
 
+/// How a `combined_fields` flat scan gets its rows and which of them it emits.
+enum FlatScanFilter<'a> {
+    /// Push the filter into the scan. Its statistics then describe only the rows
+    /// that survive, which is what the index already reports for everything else.
+    PushDown(&'a ExprFilterPlan),
+    /// Read unfiltered and pick emitted rows with this prefilter, as the indexed
+    /// side does. Needed once a stale row folds: with the filter on the scan, a
+    /// folded row's contribution would depend on the filter, so a same-value
+    /// overlay would move the corpus and with it the ranking.
+    AtEmission(PreFilterSource),
+}
+
 fn collect_fts_columns_in_order(query: &FtsQuery) -> Vec<String> {
     fn visit(query: &FtsQuery, columns: &mut Vec<String>, seen: &mut HashSet<String>) {
         match query {
@@ -5219,7 +5232,7 @@ impl Scanner {
                 Arc::new(SortExec::new(sort_exprs.into(), fts_node).with_fetch(params.limit))
             }
             FtsQuery::CombinedFields(query) => {
-                self.plan_combined_fields_query(query, params, prefilter_source)
+                self.plan_combined_fields_query(query, params, filter_plan, prefilter_source)
                     .await?
             }
             FtsQuery::Boolean(query) => {
@@ -5776,12 +5789,14 @@ impl Scanner {
     /// overlay made stale, per target column, so the indexed scan neither returns a
     /// pre-overlay hit nor hides a new one. See [`Self::fts_overlay_plan`].
     ///
-    /// A fragment any target column's index does not fully cover cannot be scored,
-    /// so the query is refused rather than answered from partial statistics.
+    /// Those fragments are routed to [`FlatCombinedFieldsExec`] instead, and the
+    /// two sides are unioned and re-sorted by score, mirroring
+    /// [`Self::plan_match_query`].
     async fn plan_combined_fields_query(
         &self,
         query: &CombinedFieldsQuery,
         params: &FtsSearchParams,
+        filter_plan: &ExprFilterPlan,
         prefilter_source: &PreFilterSource,
     ) -> Result<Arc<dyn ExecutionPlan>> {
         let target_fragments: &[Fragment] = self
@@ -5798,8 +5813,12 @@ impl Scanner {
             ))));
         }
 
+        // Kept per column; see `FlatStatsCoverage`.
+        let mut per_column_coverage = Vec::with_capacity(query.column_names().len());
         let mut uncovered = RoaringBitmap::new();
         let mut any_indexed = false;
+        let mut any_overlay_stale = false;
+        let mut needs_whole_corpus = false;
         for column in query.column_names() {
             let column_uncovered: RoaringBitmap = match self
                 .dataset
@@ -5827,14 +5846,18 @@ impl Scanner {
                     .collect(),
             };
 
-            // Fragments this column's index holds documents for, but whose entries a
-            // newer data overlay made stale. The index cannot score them from its own
-            // statistics, so they count as uncovered.
+            // Fragments this column's index does hold documents for, but whose entries
+            // a newer data overlay made stale. They join the union so the indexed scan
+            // skips them and the flat sibling re-reads their current values, and the
+            // stale rows themselves also join this column's fold so a term the overlay
+            // introduced reaches `docFreq_f`.
             //
-            // Coverage is decided per fragment, not per row: a BM25F score needs every
-            // target column's `tf_f`/`dl_f`, so a row must be scored wholly from the
-            // index or not at all, and the fragment is the granularity the indexed
-            // scan's prefilter restriction works at.
+            // `plan_match_query` blocks the individual stale row addresses and takes
+            // them back on the flat side. BM25F cannot: a row's score needs every
+            // target column's `tf_f`/`dl_f`, so a row is scored on exactly one side,
+            // and the side is chosen per fragment because that is the granularity the
+            // indexed scan's prefilter restriction works at.
+            let mut column_stale_rows = RowAddrTreeMap::new();
             match self
                 .fts_overlay_plan(column, DocumentGranularity::Row, target_fragments)
                 .await?
@@ -5842,15 +5865,23 @@ impl Scanner {
                 FtsOverlayPlan::Unchanged(_) => {}
                 FtsOverlayPlan::RowLevel { stale_rows, .. } => {
                     uncovered.extend(stale_rows.keys().copied());
+                    column_stale_rows = self.stale_rows_in_id_domain(&stale_rows).await?;
+                    any_overlay_stale = true;
                 }
                 // A legacy segment reports no fragment coverage, so no target fragment
                 // can be proven free of stale entries and no row can be named as one.
                 FtsOverlayPlan::FullScan => {
                     uncovered.extend(target_fragments.iter().map(|fragment| fragment.id as u32));
+                    needs_whole_corpus = true;
+                    any_overlay_stale = true;
                 }
             }
 
             uncovered |= &column_uncovered;
+            per_column_coverage.push(FlatStatsCoverage {
+                fragments: column_uncovered,
+                stale_rows: Arc::new(column_stale_rows),
+            });
         }
 
         // BM25F needs one shared tokenizer configuration across the target columns
@@ -5928,22 +5959,156 @@ impl Scanner {
             return Ok(index_exec(Some(covered), None));
         }
 
-        // The flat scan that would score the rows no index covers is not part of
-        // this change, so a partial plan would silently drop them. Refuse instead,
-        // and name what is missing.
-        Err(Error::invalid_input(format!(
-            "combined_fields requires every target column to be indexed over every \
-             scanned fragment, but {} of {} fragments are not fully covered. Optimize \
-             the indexes on {} and retry.",
-            uncovered_fragments.len(),
-            target_fragments.len(),
-            query
-                .columns()
-                .iter()
-                .cloned()
-                .collect::<Vec<_>>()
-                .join(", "),
-        )))
+        // A legacy segment names no stale rows, so nothing can be folded on top of the
+        // index and the corpus has to be re-measured from every target fragment. That
+        // is a full scan, so it stays confined to that case.
+        let (flat_fragments, stats_scope) = if needs_whole_corpus {
+            (target_fragments.to_vec(), FlatStatsScope::WholeCorpus)
+        } else {
+            (
+                uncovered_fragments,
+                FlatStatsScope::PerColumn(per_column_coverage),
+            )
+        };
+        // Reading unfiltered costs the flat side its pushdown, so it is confined to
+        // the scans that fold a stale row (see `FlatScanFilter::AtEmission`).
+        //
+        // The emission prefilter is built over the fragments this scan reads, not
+        // reused from the indexed child. `prefilter_source` spans the fragments the
+        // target columns' indexes cover, so it names no row in an unindexed fragment,
+        // and an allow-list can only be narrowed afterwards
+        // (`build_prefilter_restricted_to_fragments`), never widened. Reusing it would
+        // drop every match an unindexed fragment holds as soon as an overlay routes
+        // the scan onto this path.
+        let scan_filter = if any_overlay_stale {
+            let flat_prefilter = self
+                .prefilter_source(
+                    filter_plan,
+                    flat_fragments
+                        .iter()
+                        .map(|fragment| fragment.id as u32)
+                        .collect(),
+                )
+                .await?;
+            FlatScanFilter::AtEmission(flat_prefilter)
+        } else {
+            FlatScanFilter::PushDown(filter_plan)
+        };
+        // Only a plan with both children needs the two to agree on a corpus, and a
+        // whole-corpus scan leaves no fragment for an indexed child.
+        let is_mixed = !needs_whole_corpus && flat_fragments.len() != target_fragments.len();
+        let shared_scorer = is_mixed.then(|| Arc::new(SharedFtsScorer::new()));
+        let flat_plan = self
+            .plan_flat_combined_fields_query(
+                flat_fragments,
+                stats_scope,
+                scan_filter,
+                query,
+                params,
+                shared_scorer.clone(),
+            )
+            .await?;
+        // The flat exec emits in scan order and applies no limit, so even with no
+        // index child the plan still needs the score sort and top-k fetch.
+        let scored_plan = if !is_mixed {
+            flat_plan
+        } else {
+            let union =
+                UnionExec::try_new(vec![index_exec(Some(covered), shared_scorer), flat_plan])?;
+            Arc::new(RepartitionExec::try_new(
+                union,
+                Partitioning::RoundRobinBatch(1),
+            )?)
+        };
+        Ok(Arc::new(
+            SortExec::new(
+                Self::fts_score_sort_exprs(scored_plan.schema().as_ref())?.into(),
+                scored_plan,
+            )
+            .with_fetch(params.limit),
+        ))
+    }
+
+    /// Plan the flat (unindexed) side of a `combined_fields` query: one scan over
+    /// `fragments` projecting every target column, scored as one virtual field.
+    ///
+    /// Emits in scan order with no limit applied; the caller supplies the score
+    /// sort and top-k fetch.
+    async fn plan_flat_combined_fields_query(
+        &self,
+        fragments: Vec<Fragment>,
+        stats_scope: FlatStatsScope,
+        scan_filter: FlatScanFilter<'_>,
+        query: &CombinedFieldsQuery,
+        params: &FtsSearchParams,
+        shared_scorer: Option<Arc<SharedFtsScorer<CombinedFieldsBM25Scorer>>>,
+    ) -> Result<Arc<dyn ExecutionPlan>> {
+        let unfiltered = ExprFilterPlan::default();
+        let (filter_plan, emit_prefilter) = match scan_filter {
+            FlatScanFilter::PushDown(filter_plan) => (filter_plan, None),
+            FlatScanFilter::AtEmission(prefilter) => (&unfiltered, Some(prefilter)),
+        };
+        // A path that continues past a `List` is not addressable by a projection,
+        // so such a column is scanned through its list root and walked down to the
+        // leaf by `FlatCombinedFieldsExec`, exactly as `plan_flat_match_query`
+        // does for a single column.
+        let resolved_fields = query
+            .column_names()
+            .map(|column| {
+                resolve_fts_field(self.dataset.schema(), column, DocumentGranularity::Row)
+            })
+            .collect::<Result<Vec<_>>>()?;
+        let columns = resolved_fields
+            .iter()
+            .map(|resolved| {
+                if resolved.has_lists() {
+                    resolved.root_column.clone()
+                } else {
+                    resolved.canonical_path.clone()
+                }
+            })
+            .collect::<Vec<_>>();
+        let scanned_fragments: RoaringBitmap = fragments
+            .iter()
+            .map(|fragment| fragment.id as u32)
+            .collect();
+        let mut plan = self
+            .plan_uncovered_rows_scan(fragments, HashMap::new(), columns, filter_plan)
+            .await?;
+        // A nested target column needs a flat alias so the exec can resolve it by
+        // name in the batch schema. A list-bearing one gets its flat column from
+        // the exec instead, since no projection can produce it.
+        for (column, resolved) in query.column_names().zip(&resolved_fields) {
+            if !resolved.has_lists() {
+                plan = self.ensure_column_alias(plan, column)?;
+            }
+        }
+
+        let mut flat_plan = FlatCombinedFieldsExec::try_new(
+            self.dataset.clone(),
+            query.clone(),
+            params.clone(),
+            plan,
+            scanned_fragments,
+            resolved_fields,
+            stats_scope,
+        )?;
+        if let Some(prefilter) = emit_prefilter {
+            flat_plan = flat_plan.with_emit_prefilter(prefilter);
+        }
+        if let Some(shared_scorer) = shared_scorer {
+            flat_plan = flat_plan.with_shared_scorer(shared_scorer);
+        }
+        let flat_plan: Arc<dyn ExecutionPlan> = Arc::new(flat_plan);
+        // The rows this side scores never reach an index-side prefilter, so the
+        // external row-address mask is applied to its output here, as the flat
+        // MatchQuery branch does. It restricts what is emitted, not the corpus the
+        // scores are computed against, so both children of a mixed plan keep
+        // scoring against the same statistics.
+        if let Some(mask) = self.external_row_mask.clone() {
+            return Ok(Arc::new(RowAddrMaskFilterExec::new(flat_plan, mask)));
+        }
+        Ok(flat_plan)
     }
 
     // ANN/KNN search execution node with optional prefilter
diff --git a/rust/lance/src/dataset/tests/dataset_fts_combined_fields.rs b/rust/lance/src/dataset/tests/dataset_fts_combined_fields.rs
index 914f9fa5055..0e2c4d34736 100644
--- a/rust/lance/src/dataset/tests/dataset_fts_combined_fields.rs
+++ b/rust/lance/src/dataset/tests/dataset_fts_combined_fields.rs
@@ -2,28 +2,38 @@
 // SPDX-FileCopyrightText: Copyright The Lance Authors
 
 use std::collections::{HashMap, HashSet};
+use std::sync::Arc;
 use std::vec;
 
+use super::dataset_index::nested_fts_batch;
+
 use crate::Dataset;
 
 use crate::dataset::write::{WriteMode, WriteParams};
 use crate::index::DatasetIndexExt;
 use crate::utils::test::copy_test_data_to_tmp;
-use arrow::array::AsArray;
+use arrow::array::{AsArray, GenericListBuilder, GenericStringBuilder};
+use arrow::datatypes::UInt64Type;
 use arrow_array::RecordBatch;
 use arrow_array::record_batch;
+use arrow_array::{Array, GenericStringArray, ListArray, StructArray};
 use arrow_array::{
-    RecordBatchIterator,
+    ArrayRef, Int32Array, RecordBatchIterator, StringArray,
     types::{Float32Type, Int32Type, Int64Type},
 };
+use arrow_buffer::{OffsetBuffer, ScalarBuffer};
+use arrow_schema::{DataType, Field as ArrowField, Fields as ArrowFields, Schema as ArrowSchema};
+use lance_core::ROW_ID;
 use lance_core::utils::tempfile::TempStrDir;
-use lance_index::IndexType;
+use lance_index::optimize::OptimizeOptions;
 use lance_index::scalar::FullTextSearchQuery;
 use lance_index::scalar::inverted::{
     Language,
     query::{MatchQuery, Operator},
     tokenizer::InvertedIndexParams,
 };
+use lance_index::{IndexType, scalar::ScalarIndexParams};
+use lance_select::{RowAddrMask, RowAddrTreeMap};
 
 use lance_index::scalar::inverted::builder::BLOCK_SIZE;
 use lance_index::scalar::inverted::oracle::{brute_force_bm25f, brute_force_ids};
@@ -836,6 +846,516 @@ async fn test_fts_combined_fields_concatenation_identity() {
     }
 }
 
+#[rstest]
+#[case::or(Operator::Or)]
+#[case::and(Operator::And)]
+#[tokio::test]
+async fn test_fts_combined_fields_covers_unindexed_fragments(#[case] operator: Operator) {
+    // A combined_fields query must not silently drop rows appended after the indexes
+    // were built. The indexed scan cannot score them (their fragment is in no
+    // index), so the planner has to union in a flat scan the same way a single
+    // MatchQuery does.
+    //
+    // Every row here matches, so both children of the union emit and the exact
+    // scores also pin down that they scored against a single shared corpus. Only the
+    // flat side sees the appended rows, so an indexed child that folded its own
+    // statistics would score row 0 on a 1-document corpus while rows 1 and 2 were
+    // scored on a 3-document one.
+    let titles = vec!["alpha", "alpha alpha", "gamma"];
+    let bodies = vec!["omega", "omega", "omega omega"];
+
+    let (test_uri, mut dataset) =
+        indexed_two_column_dataset(&titles[..1], &bodies[..1], None).await;
+
+    // Two appended fragments, so the flat side has to cover more than one.
+    for row in 1..3 {
+        let batch = combined_fields_batch(vec![row as i32], vec![titles[row]], vec![bodies[row]]);
+        dataset = append_fts_dataset(&test_uri, batch, Some(1)).await;
+    }
+
+    // A single-column match already falls back to a flat scan; combined_fields
+    // must reach the same rows.
+    let match_ids = fts_result_ids(
+        &dataset,
+        FtsQuery::Match(
+            MatchQuery::new("alpha".to_string()).with_column(Some("title".to_string())),
+        ),
+    )
+    .await;
+    // Score order, so compare as a set: both alpha-bearing rows must be reached.
+    assert_eq!(
+        match_ids.iter().copied().collect::<HashSet<_>>(),
+        HashSet::from([0, 1])
+    );
+
+    let expected = brute_force_bm25f(
+        &[(1.0, titles.clone()), (1.0, bodies.clone())],
+        "alpha omega",
+        operator == Operator::And,
+    );
+    let actual =
+        fts_result_id_scores(&dataset, combined_query("alpha omega", operator), None).await;
+    // Row 0 comes from the indexed child and rows 1 and 2 from the flat one, so
+    // matching the reference on all three proves the two share a corpus: the flat
+    // scan publishes the blend that folds in the appended rows, and the indexed scan
+    // waits for it instead of using its own `docCount'`/`docFreq'`/`avgdl'`.
+    assert_matches_brute_force(
+        &actual,
+        &expected,
+        "rows in unindexed fragments must be reached exactly once through the index/flat union",
+    );
+}
+
+/// An external row-address prefilter
+/// ([`Scanner::with_row_addr_prefilter`](crate::dataset::Scanner::with_row_addr_prefilter))
+/// must restrict a `combined_fields` result.
+///
+/// The two plan shapes reach it by different routes and are both checked: the
+/// fully covered one is a single indexed scan that ANDs the mask into its
+/// prefilter, while the mixed one adds a flat child whose rows never reach an
+/// index-side prefilter and so is masked on its output instead.
+///
+/// The mask picks what is emitted, not the corpus the scores are measured
+/// against, so the surviving rows keep the scores the unmasked query gave them.
+/// Folding it into the statistics would make a masked query rank its results
+/// differently from the same rows in an unmasked one.
+#[rstest]
+#[case::fully_indexed(false)]
+#[case::mixed_index_and_flat(true)]
+#[tokio::test]
+async fn test_fts_combined_fields_respects_external_row_mask(#[case] append_unindexed: bool) {
+    let titles = vec!["alpha", "alpha alpha", "gamma"];
+    let bodies = vec!["omega", "omega", "omega omega"];
+
+    let (_test_uri, mut dataset) = if append_unindexed {
+        // Index only row 0, then append the rest so the planner unions an indexed
+        // scan with a flat one.
+        let (test_uri, mut dataset) =
+            indexed_two_column_dataset(&titles[..1], &bodies[..1], None).await;
+        for row in 1..3 {
+            let batch =
+                combined_fields_batch(vec![row as i32], vec![titles[row]], vec![bodies[row]]);
+            dataset = append_fts_dataset(&test_uri, batch, Some(1)).await;
+        }
+        (test_uri, dataset)
+    } else {
+        indexed_two_column_dataset(&titles, &bodies, None).await
+    };
+    // Reload so the scanner sees the indices written above.
+    dataset.checkout_latest().await.unwrap();
+
+    // Row ids paired with the `id` values they carry, so the mask can be built in
+    // `_rowid` space while the assertions stay in terms of `id`.
+    let baseline = dataset
+        .scan()
+        .project(&["id"])
+        .unwrap()
+        .with_row_id()
+        .full_text_search(FullTextSearchQuery::new_query(combined_query(
+            "alpha omega",
+            Operator::Or,
+        )))
+        .unwrap()
+        .try_into_batch()
+        .await
+        .unwrap();
+    let baseline_ids = baseline["id"].as_primitive::<Int32Type>();
+    let baseline_row_ids = baseline[ROW_ID].as_primitive::<UInt64Type>();
+    let baseline_scores = baseline["_score"].as_primitive::<Float32Type>();
+    let baseline: Vec<(i32, u64, f32)> = (0..baseline.num_rows())
+        .map(|i| {
+            (
+                baseline_ids.value(i),
+                baseline_row_ids.value(i),
+                baseline_scores.value(i),
+            )
+        })
+        .collect();
+    assert_eq!(
+        baseline.iter().map(|(id, ..)| *id).collect::<HashSet<_>>(),
+        HashSet::from([0, 1, 2]),
+        "every row matches this query, so all three must be in the baseline"
+    );
+
+    let masked = |allowed: Vec<u64>| {
+        let dataset = dataset.clone();
+        async move {
+            let mut scan = dataset.scan();
+            scan.project(&["id"])
+                .unwrap()
+                .full_text_search(FullTextSearchQuery::new_query(combined_query(
+                    "alpha omega",
+                    Operator::Or,
+                )))
+                .unwrap()
+                .with_row_addr_prefilter(RowAddrMask::from_allowed(RowAddrTreeMap::from_iter(
+                    allowed,
+                )));
+            let batch = scan.try_into_batch().await.unwrap();
+            let ids = batch["id"].as_primitive::<Int32Type>();
+            let scores = batch["_score"].as_primitive::<Float32Type>();
+            (0..batch.num_rows())
+                .map(|i| (ids.value(i), scores.value(i)))
+                .collect::<Vec<_>>()
+        }
+    };
+
+    assert!(
+        masked(vec![]).await.is_empty(),
+        "an empty allow list must drop every combined_fields match"
+    );
+
+    // One row at a time, so both the indexed row (0) and the flat ones (1, 2) are
+    // each checked on their own.
+    for &(id, row_id, score) in &baseline {
+        let actual = masked(vec![row_id]).await;
+        assert_eq!(
+            actual.len(),
+            1,
+            "allowing only _rowid {row_id} must return exactly id {id}, got {actual:?}"
+        );
+        assert_eq!(actual[0].0, id);
+        assert!(
+            (actual[0].1 - score).abs() < 1e-3,
+            "masking must not move id {id}'s score: {} vs the unmasked {score}",
+            actual[0].1
+        );
+    }
+}
+
+/// Per-column index skew, over both row-id schemes.
+///
+/// The indexed scan is restricted to fragments every target column covers. That
+/// restriction has to be expressed in the same id space the index stores, and the
+/// inverted index trains with `_rowid` (`TrainingCriteria::with_row_id`), which is a
+/// logical stable id when the dataset uses stable row ids and a row address
+/// otherwise. A fragment-address block list therefore matches nothing under stable
+/// row ids, letting the indexed scan emit the very rows the flat scan also emits,
+/// the same duplicate-across-a-UNION failure `do_create_deletion_mask_row_id`
+/// documents for issue #6877.
+///
+/// `Operator::And` is checked here too: it decides matching across the virtual field
+/// as a whole, so a row whose terms are split between an indexed and a stale-indexed
+/// column must still be admitted, and the flat side has to evaluate the operator over
+/// the same blended `tf'` the indexed side does.
+#[rstest]
+#[case::or_row_addresses(false, Operator::Or)]
+#[case::or_stable_row_ids(true, Operator::Or)]
+#[case::and_row_addresses(false, Operator::And)]
+#[case::and_stable_row_ids(true, Operator::And)]
+#[tokio::test]
+async fn test_fts_combined_fields_per_column_index_skew(
+    #[case] stable_row_ids: bool,
+    #[case] operator: Operator,
+) {
+    // Columns indexed at different dataset versions: `title` covers every
+    // fragment, `body` only the first. A fragment indexed for some target columns
+    // but not others cannot be scored by the indexed scan at all, `dl'` sums each
+    // column's document length and a row missing from a column's DocSet
+    // contributes 0, so those fragments must be routed to the flat scan whole,
+    // not emitted with a partial `tf'`/`dl'`.
+    let params = combined_fields_test_params();
+    // Fragment 0 (rows 0-1) ends up indexed for both columns. Fragment 1 (rows
+    // 2-3) is indexed for `title` only: row 2 carries the term in `title`, which a
+    // partial score would rank wrongly, and row 3 carries it only in `body`, which
+    // a partial score would miss entirely.
+    let titles = vec!["aa bb", "cc", "aa aa", "dd"];
+    let bodies = vec!["cc dd", "aa bb", "dd", "aa bb bb"];
+    let write_params = |mode: WriteMode| WriteParams {
+        mode,
+        max_rows_per_file: 2,
+        enable_stable_row_ids: stable_row_ids,
+        ..Default::default()
+    };
+
+    let first = combined_fields_batch(
+        vec![0, 1],
+        vec![titles[0], titles[1]],
+        vec![bodies[0], bodies[1]],
+    );
+    let test_uri = TempStrDir::default();
+    let mut dataset =
+        write_fts_dataset(&test_uri, first, Some(write_params(WriteMode::Create))).await;
+    create_inverted_indices(&mut dataset, &["title", "body"], &params).await;
+
+    let second = combined_fields_batch(
+        vec![2, 3],
+        vec![titles[2], titles[3]],
+        vec![bodies[2], bodies[3]],
+    );
+    let mut dataset =
+        write_fts_dataset(&test_uri, second, Some(write_params(WriteMode::Append))).await;
+    // Re-index `title` only, so the two columns disagree on fragment coverage.
+    create_inverted_indices(&mut dataset, &["title"], &params).await;
+    assert_eq!(
+        dataset.manifest.uses_stable_row_ids(),
+        stable_row_ids,
+        "row-id scheme precondition"
+    );
+
+    // Non-unit weights so `tf'`/`dl'` actually depend on `w_f` on the flat path.
+    // Two terms so `And` differs from `Or`: row 2 carries only "aa", so it drops out
+    // under `And` while every other matching row keeps both terms somewhere.
+    let weights = [3.0f32, 1.0f32];
+    let expected = brute_force_bm25f(
+        &[(weights[0], titles.clone()), (weights[1], bodies.clone())],
+        "aa bb",
+        operator == Operator::And,
+    );
+    let expected_ids = brute_force_ids(&expected);
+
+    let actual = fts_result_id_scores(
+        &dataset,
+        combined_query_with_boosts("aa bb", operator, Some(weights.to_vec())),
+        None,
+    )
+    .await;
+    let actual_ids: HashSet<i32> = actual.iter().map(|(id, _)| *id).collect();
+    assert_eq!(
+        actual.len(),
+        expected_ids.len(),
+        "row emitted twice by both sides of the union: {actual:?}"
+    );
+    // Row 3 has "aa" only in `body`, whose index is missing fragment 1; an
+    // index-only plan cannot see it at all.
+    assert!(
+        actual_ids.contains(&3),
+        "row matching only through the column with stale index coverage was dropped: {actual_ids:?}"
+    );
+    assert_eq!(actual_ids, expected_ids);
+
+    // Rows 2 and 3 are scored by the flat side, which folds `body`'s missing
+    // fragment into the blended statistics, so it reaches the exact BM25F score.
+    // A partial `dl'` (missing `body`) would inflate row 2's score instead.
+    let scores: HashMap<i32, f32> = actual.into_iter().collect();
+    for id in [2, 3] {
+        match expected[id as usize] {
+            Some(want) => {
+                let got = scores[&id];
+                assert!(
+                    (got - want).abs() < 1e-3,
+                    "id {id} scored with partial cross-field data: scan={got}, brute force={want}"
+                );
+            }
+            None => assert!(
+                !scores.contains_key(&id),
+                "id {id} does not carry every term but {operator:?} returned it"
+            ),
+        }
+    }
+}
+
+#[tokio::test]
+async fn test_fts_combined_fields_partially_indexed_columns() {
+    // Only `title` is indexed. Every fragment is then uncovered for `body`, so the
+    // whole scan takes the flat-only planner branch, with no index child at all. That
+    // branch is the only one that builds a `CombinedFieldColumn` with no segments,
+    // and the only one where a column contributes zero index statistics and its
+    // entire contribution comes from the flat scan.
+    let params = combined_fields_test_params();
+    let titles = vec!["aa bb", "cc", "aa aa", "dd"];
+    let bodies = vec!["cc dd", "aa bb", "dd", "aa bb bb"];
+    let batch = combined_fields_batch(vec![0, 1, 2, 3], titles.clone(), bodies.clone());
+    let test_uri = TempStrDir::default();
+    let mut dataset = write_fts_dataset(
+        &test_uri,
+        batch,
+        Some(WriteParams {
+            max_rows_per_file: 2,
+            ..Default::default()
+        }),
+    )
+    .await;
+    create_inverted_indices(&mut dataset, &["title"], &params).await;
+
+    let weights = [2.0f32, 1.0f32];
+    let mut plan_scan = dataset.scan();
+    plan_scan
+        .project(&["id"])
+        .unwrap()
+        .full_text_search(FullTextSearchQuery::new_query(combined_query_with_boosts(
+            "aa",
+            Operator::Or,
+            Some(weights.to_vec()),
+        )))
+        .unwrap();
+    let plan = plan_scan.explain_plan(true).await.unwrap();
+    assert!(
+        plan.contains("FlatCombinedFields"),
+        "the flat-only branch must carry a flat child:\n{plan}"
+    );
+    assert!(
+        !plan.contains("CombinedFieldsQuery"),
+        "no fragment is covered for `body`, so nothing can be scored by an index \
+         child:\n{plan}"
+    );
+
+    let expected = brute_force_bm25f(
+        &[(weights[0], titles.clone()), (weights[1], bodies.clone())],
+        "aa",
+        false,
+    );
+    let actual = fts_result_id_scores(
+        &dataset,
+        combined_query_with_boosts("aa", Operator::Or, Some(weights.to_vec())),
+        None,
+    )
+    .await;
+    // The flat scan owns the entire corpus for `body` and reads `title` from its
+    // index, so the blended statistics are exact.
+    assert_matches_brute_force(
+        &actual,
+        &expected,
+        "the flat-only plan must score against the blend of its own corpus and \
+         `title`'s index",
+    );
+
+    // The flat exec emits in scan order and applies no limit, so this branch needs
+    // its own score sort: without one the rows come back unordered and `limit`
+    // truncates positionally instead of taking the top-k.
+    let scores: Vec<f32> = actual.iter().map(|(_, score)| *score).collect();
+    assert!(
+        scores.windows(2).all(|w| w[0] >= w[1]),
+        "flat-only plan is not score-ordered: {actual:?}"
+    );
+
+    let best = actual
+        .iter()
+        .max_by(|a, b| a.1.partial_cmp(&b.1).unwrap())
+        .map(|(id, _)| *id)
+        .unwrap();
+    let batch = dataset
+        .scan()
+        .project(&["id"])
+        .unwrap()
+        .full_text_search(FullTextSearchQuery::new_query(combined_query_with_boosts(
+            "aa",
+            Operator::Or,
+            Some(weights.to_vec()),
+        )))
+        .unwrap()
+        .limit(Some(1), None)
+        .unwrap()
+        .try_into_batch()
+        .await
+        .unwrap();
+    let top = batch
+        .column_by_name("id")
+        .unwrap()
+        .as_primitive::<Int32Type>()
+        .values()
+        .to_vec();
+    assert_eq!(
+        top,
+        vec![best],
+        "limit=1 on the flat-only plan did not return the top-scoring row"
+    );
+}
+
+/// Every row scores identically, so the whole result is one tie and
+/// `(score DESC, row_id ASC)` fixes the answer completely: the top-5 is the five
+/// lowest row ids.
+///
+/// Both plan shapes are covered because they settle ties in different places, and
+/// only one of them has a sort at all:
+///
+/// - **mixed coverage** unions an indexed child with a flat scan, so ties would
+///   otherwise break by fragment arrival order. The plan's `row_id ASC` second
+///   sort key decides them.
+/// - **fully indexed** returns `CombinedFieldsQueryExec` directly with no
+///   `SortExec` above it, so nothing downstream can reorder or recover a row.
+///   `combined_fields_search`'s own `(score, row_id)` heap ordering has to be
+///   right, and its bounded heap must not evict a tied row that belongs in the
+///   top-k.
+///
+/// Without either, `limit`/`offset` pagination could skip and repeat rows.
+#[rstest]
+#[case::fully_indexed(true)]
+#[case::mixed_coverage(false)]
+#[tokio::test]
+async fn test_fts_combined_fields_tied_scores_are_deterministic(#[case] fully_indexed: bool) {
+    let rows = 24usize;
+    // Spread the rows over several fragments either way: on the mixed plan that
+    // makes the flat scan's arrival order genuinely nondeterministic, and on the
+    // fully indexed one it spreads the postings over several index partitions.
+    let (_test_uri, dataset) = if fully_indexed {
+        indexed_two_column_dataset(&vec!["aa"; rows], &vec!["aa"; rows], Some(3)).await
+    } else {
+        let (test_uri, _indexed) =
+            indexed_two_column_dataset(&["aa", "aa"], &["aa", "aa"], None).await;
+        let second = combined_fields_batch(
+            (2..rows as i32).collect(),
+            vec!["aa"; rows - 2],
+            vec!["aa"; rows - 2],
+        );
+        let dataset = append_fts_dataset(&test_uri, second, Some(3)).await;
+        (test_uri, dataset)
+    };
+
+    // The two shapes must really be the two shapes, or the fully indexed case
+    // silently gains a sort that would mask the heap's own ordering.
+    let mut plan_scan = dataset.scan();
+    plan_scan
+        .project(&["id"])
+        .unwrap()
+        .full_text_search(FullTextSearchQuery::new_query(combined_query(
+            "aa",
+            Operator::Or,
+        )))
+        .unwrap()
+        .limit(Some(5), None)
+        .unwrap();
+    let plan = plan_scan.explain_plan(true).await.unwrap();
+    assert_eq!(
+        plan.contains("FlatCombinedFields"),
+        !fully_indexed,
+        "wrong plan shape for fully_indexed={fully_indexed}:\n{plan}"
+    );
+    assert_eq!(
+        plan.contains("SortExec"),
+        !fully_indexed,
+        "fully indexed plan must settle ties in the search, not in a sort:\n{plan}"
+    );
+
+    // Rows were written in id order across fragments, so row-id order is id order.
+    // Asserting the five lowest ids pins the specification, rather than observing
+    // that repeated runs happen to agree.
+    let expected_top: Vec<i32> = (0..5).collect();
+    let mut seen = HashSet::new();
+    for _ in 0..8 {
+        let batch = dataset
+            .scan()
+            .project(&["id"])
+            .unwrap()
+            .full_text_search(FullTextSearchQuery::new_query(combined_query(
+                "aa",
+                Operator::Or,
+            )))
+            .unwrap()
+            .limit(Some(5), None)
+            .unwrap()
+            .try_into_batch()
+            .await
+            .unwrap();
+        let ids = batch
+            .column_by_name("id")
+            .unwrap()
+            .as_primitive::<Int32Type>()
+            .values()
+            .to_vec();
+        assert_eq!(
+            ids, expected_top,
+            "tied scores must break by ascending row id"
+        );
+        seen.insert(ids);
+    }
+    assert_eq!(
+        seen.len(),
+        1,
+        "top-k over tied scores is nondeterministic across runs: {seen:?}"
+    );
+}
+
 #[tokio::test]
 async fn test_fts_combined_fields_fast_search_without_full_coverage_is_empty() {
     // `fast_search` is index-only. When a target column has no index at all no
@@ -864,6 +1384,44 @@ async fn test_fts_combined_fields_fast_search_without_full_coverage_is_empty() {
     assert_eq!(batch.num_rows(), 0);
 }
 
+#[tokio::test]
+async fn test_fts_combined_fields_unindexed_row_wins_topk() {
+    // The union applies the top-k limit after re-sorting both sides, so a row in an
+    // unindexed fragment must be able to take the single top slot. A plan that pushed
+    // the limit into the indexed side only would return the best row the index holds
+    // instead.
+    let titles = ["filler", "filler", "aa aa aa"];
+    let bodies = ["aa", "filler", "aa aa aa"];
+
+    let (test_uri, _indexed) = indexed_two_column_dataset(&titles[..2], &bodies[..2], None).await;
+
+    // Row 2 is the strongest match for "aa" but lands in an unindexed fragment.
+    let second = combined_fields_batch(vec![2], vec![titles[2]], vec![bodies[2]]);
+    let dataset = append_fts_dataset(&test_uri, second, None).await;
+
+    let batch = dataset
+        .scan()
+        .project(&["id"])
+        .unwrap()
+        .full_text_search(FullTextSearchQuery::new_query(combined_query(
+            "aa",
+            Operator::Or,
+        )))
+        .unwrap()
+        .limit(Some(1), None)
+        .unwrap()
+        .try_into_batch()
+        .await
+        .unwrap();
+    let ids = batch
+        .column_by_name("id")
+        .unwrap()
+        .as_primitive::<Int32Type>()
+        .values()
+        .to_vec();
+    assert_eq!(ids, vec![2], "top-1 was taken from the indexed side only");
+}
+
 #[tokio::test]
 async fn test_fts_combined_fields_fast_search_skips_uncovered_fragments() {
     // `fast_search` is index-only by contract, so appended rows stay invisible. It
@@ -950,3 +1508,897 @@ async fn test_fts_combined_fields_requires_an_index() {
         "unexpected error: {message}"
     );
 }
+
+/// Like [`combined_fields_batch`] but with optional text values, so a row can be
+/// NULL in one target column or in every one of them.
+fn nullable_combined_fields_batch(
+    ids: Vec<i32>,
+    titles: Vec<Option<&str>>,
+    bodies: Vec<Option<&str>>,
+) -> RecordBatch {
+    record_batch!(
+        ("id", Int32, ids),
+        ("title", Utf8, titles),
+        ("body", Utf8, bodies)
+    )
+    .unwrap()
+}
+
+#[tokio::test]
+async fn test_fts_combined_fields_flat_nulls_and_empty_strings() {
+    // NULL / empty-string handling on the flat path, which has its own counting
+    // code: `count_column_into` leaves a row's slots at zero for a NULL,
+    // `tokenize_and_blend_multi` drops a row that is empty in all target columns,
+    // and `FlatFieldStats::fold_row` skips a column whose `dl_f == 0` so the row
+    // raises neither that column's `docCount_f` nor its `docFreq_f`. Unlike
+    // `test_fts_combined_fields_nulls`, which covers the fully-indexed path, this
+    // one also pins the exact scores, where a miscounted `docCount'` shows up.
+    let params = combined_fields_test_params();
+    // Rows 0-1 are indexed for both columns and carry no query term, so the indexed
+    // child emits nothing and every returned row comes from the flat scan, whose
+    // blended statistics must still fold in the indexed rows.
+    let titles = vec![
+        Some("zz zz"),
+        Some("zz"),
+        None,          // NULL in one column
+        Some("aa aa"), // paired with an empty string in the other column
+        None,          // NULL in every column: never scored
+        Some(""),      // empty in every column: never scored
+        Some("aa"),
+        None, // NULL in one column, and no query term anywhere
+    ];
+    let bodies = vec![
+        Some("zz"),
+        Some("zz zz"),
+        Some("aa"),
+        Some(""),
+        None,
+        Some(""),
+        Some("aa zz"),
+        Some("zz"),
+    ];
+
+    let first =
+        nullable_combined_fields_batch(vec![0, 1], titles[..2].to_vec(), bodies[..2].to_vec());
+    let test_uri = TempStrDir::default();
+    let mut dataset = write_fts_dataset(&test_uri, first, None).await;
+    create_inverted_indices(&mut dataset, &["title", "body"], &params).await;
+
+    // Spread the appended rows over several fragments, one of which holds only
+    // rows that tokenize to nothing at all.
+    let second = nullable_combined_fields_batch(
+        (2..titles.len() as i32).collect(),
+        titles[2..].to_vec(),
+        bodies[2..].to_vec(),
+    );
+    let dataset = append_fts_dataset(&test_uri, second, Some(2)).await;
+
+    // A NULL and an empty string both tokenize to nothing, so the reference models
+    // either as `""`.
+    fn as_text<'a>(values: &[Option<&'a str>]) -> Vec<&'a str> {
+        values.iter().map(|v| v.unwrap_or("")).collect()
+    }
+    let weights = [2.0f32, 1.0f32];
+    let expected = brute_force_bm25f(
+        &[
+            (weights[0], as_text(&titles)),
+            (weights[1], as_text(&bodies)),
+        ],
+        "aa",
+        false,
+    );
+    assert_eq!(
+        brute_force_ids(&expected),
+        HashSet::from([2, 3, 6]),
+        "reference corpus changed; the null rows must stay unmatched"
+    );
+
+    let actual = fts_result_id_scores(
+        &dataset,
+        combined_query_with_boosts("aa", Operator::Or, Some(weights.to_vec())),
+        None,
+    )
+    .await;
+    assert_matches_brute_force(
+        &actual,
+        &expected,
+        "a row empty in every target column must not be scored, and docCount' must \
+         count only rows with tokens in that column",
+    );
+}
+
+/// An `id` + `tags` (a list of strings) + `body` batch, for the list-valued target
+/// column cases. `ListOffset` picks `List` vs `LargeList` and `StringOffset` picks
+/// `Utf8` vs `LargeUtf8`, both for the list elements and for `body`. A `None` entry
+/// in `tags` is a NULL list, an empty `Vec` an empty one.
+fn list_column_batch<
+    ListOffset: arrow::array::OffsetSizeTrait,
+    StringOffset: arrow::array::OffsetSizeTrait,
+>(
+    ids: &[i32],
+    tags: &[Option<Vec<&str>>],
+    bodies: &[&str],
+) -> RecordBatch {
+    let mut builder =
+        GenericListBuilder::<ListOffset, _>::new(GenericStringBuilder::<StringOffset>::new());
+    for row in tags {
+        match row {
+            Some(elements) => {
+                for element in elements {
+                    builder.values().append_value(element);
+                }
+                builder.append(true);
+            }
+            None => builder.append(false),
+        }
+    }
+    let tags_col = Arc::new(builder.finish()) as ArrayRef;
+    let bodies_col =
+        Arc::new(GenericStringArray::<StringOffset>::from(bodies.to_vec())) as ArrayRef;
+    RecordBatch::try_new(
+        Arc::new(ArrowSchema::new(vec![
+            ArrowField::new("id", DataType::Int32, false),
+            ArrowField::new("tags", tags_col.data_type().clone(), true),
+            ArrowField::new("body", bodies_col.data_type().clone(), false),
+        ])),
+        vec![
+            Arc::new(Int32Array::from(ids.to_vec())) as ArrayRef,
+            tags_col,
+            bodies_col,
+        ],
+    )
+    .unwrap()
+}
+
+#[tokio::test]
+async fn test_fts_combined_fields_flat_list_column() {
+    assert_combined_fields_flat_list_column::<i32, i32>().await;
+}
+
+#[tokio::test]
+async fn test_fts_combined_fields_flat_large_list_column() {
+    assert_combined_fields_flat_list_column::<i64, i64>().await;
+}
+
+/// The flat scan must reduce a list column to a row's document text the same way
+/// the index builder does, which is to join the elements with a space.
+///
+/// Under `simple` the two readings agree, because counting each element on its own
+/// yields the same tokens as counting them joined; only a tokenizer that is
+/// sensitive to the element boundary can tell them apart. `raw` emits one token
+/// per document, so a 2-element list is `dl_f = 1` when joined and `dl_f = 2` when
+/// counted per element.
+///
+/// Scoring the same rows once through each side pins the agreement down without a
+/// hand-computed reference: with `tags` indexed the statistics come from the
+/// index, and with only `body` indexed they come from the flat fold instead.
+#[tokio::test]
+async fn test_fts_combined_fields_flat_list_matches_index_under_raw_tokenizer() {
+    let params = InvertedIndexParams::new("raw".to_string(), Language::English)
+        .lower_case(false)
+        .stem(false)
+        .remove_stop_words(false);
+
+    // Row 1 is the discriminator: joined, its tags are the single token
+    // "alpha beta gamma", which does not match, but counted per element it holds
+    // the token "alpha beta", which does. Rows 0 and 2 match either way and pin
+    // down the scores.
+    let tags: Vec<Option<Vec<&str>>> = vec![
+        Some(vec!["alpha beta"]),
+        Some(vec!["alpha beta", "gamma"]),
+        Some(vec!["gamma", "delta"]),
+    ];
+    let bodies = vec!["alpha beta", "gamma", "alpha beta"];
+
+    let build = |indexed_columns: &'static [&'static str]| {
+        let params = params.clone();
+        let tags = tags.clone();
+        let bodies = bodies.clone();
+        async move {
+            let batch = list_column_batch::<i32, i32>(
+                &(0..tags.len() as i32).collect::<Vec<_>>(),
+                &tags,
+                &bodies,
+            );
+            let test_uri = TempStrDir::default();
+            let mut dataset = write_fts_dataset(&test_uri, batch, None).await;
+            create_inverted_indices(&mut dataset, indexed_columns, &params).await;
+            let scored = fts_result_id_scores(
+                &dataset,
+                combined_query_over(&["tags", "body"], "alpha beta", Operator::Or, None),
+                None,
+            )
+            .await;
+            // Keep the temporary directory alive until the scan has finished.
+            drop(test_uri);
+            scored
+        }
+    };
+
+    // `tags` indexed: its statistics and per-row lengths come from the index.
+    let indexed = build(&["tags", "body"]).await;
+    // `tags` unindexed: every fragment is uncovered for it, so the flat scan reads
+    // the raw list and folds its own statistics in.
+    let flat = build(&["body"]).await;
+
+    assert_eq!(
+        indexed.iter().map(|(id, _)| *id).collect::<Vec<_>>(),
+        vec![0, 2],
+        "row 1 only matches when its tag elements are counted separately"
+    );
+    assert_eq!(
+        indexed.len(),
+        flat.len(),
+        "flat={flat:?} indexed={indexed:?}"
+    );
+    for ((indexed_id, indexed_score), (flat_id, flat_score)) in indexed.iter().zip(&flat) {
+        assert_eq!(indexed_id, flat_id, "flat={flat:?} indexed={indexed:?}");
+        assert!(
+            (indexed_score - flat_score).abs() < 1e-5,
+            "id {indexed_id}: indexed={indexed_score}, flat={flat_score}; the flat scan must \
+             join a row's list elements the way the index builder does"
+        );
+    }
+}
+
+/// A list-valued target column on the flat path: the scan reduces the list to the
+/// row's document text and counts it as one document, so every element lands in
+/// the row's single `dl_f`/`tf_f`.
+async fn assert_combined_fields_flat_list_column<
+    ListOffset: arrow::array::OffsetSizeTrait,
+    StringOffset: arrow::array::OffsetSizeTrait,
+>() {
+    let params = combined_fields_test_params();
+    // `tags` is the list column. Row 2 spreads one term over two elements of
+    // differing length and row 3 repeats the term in two elements, so a reader that
+    // took only the first element, or treated each element as its own document,
+    // lands on a different `dl_f`/`tf_f` and a different score.
+    let tags: Vec<Option<Vec<&str>>> = vec![
+        Some(vec!["zz"]),
+        Some(vec!["zz", "zz"]),
+        Some(vec!["aa", "bb cc"]),
+        Some(vec!["aa", "aa"]),
+        None,         // NULL list
+        Some(vec![]), // empty list
+        Some(vec!["zz"]),
+    ];
+    let bodies = vec!["zz", "zz zz", "zz", "zz zz", "aa", "aa aa", "zz"];
+
+    // Rows 0-1 are indexed for both columns and match nothing, so every returned
+    // row is scored by the flat scan.
+    let first = list_column_batch::<ListOffset, StringOffset>(&[0, 1], &tags[..2], &bodies[..2]);
+    let test_uri = TempStrDir::default();
+    let mut dataset = write_fts_dataset(&test_uri, first, None).await;
+    create_inverted_indices(&mut dataset, &["tags", "body"], &params).await;
+
+    let second = list_column_batch::<ListOffset, StringOffset>(
+        &(2..tags.len() as i32).collect::<Vec<_>>(),
+        &tags[2..],
+        &bodies[2..],
+    );
+    let dataset = append_fts_dataset(&test_uri, second, Some(2)).await;
+
+    // The index joins list elements with a space before tokenizing, so the
+    // reference sees the same token counts either way.
+    let flattened: Vec<String> = tags
+        .iter()
+        .map(|row| row.as_ref().map(|e| e.join(" ")).unwrap_or_default())
+        .collect();
+    let weights = [2.0f32, 1.0f32];
+    let expected = brute_force_bm25f(
+        &[
+            (weights[0], flattened.iter().map(|s| s.as_str()).collect()),
+            (weights[1], bodies.clone()),
+        ],
+        "aa",
+        false,
+    );
+    assert_eq!(brute_force_ids(&expected), HashSet::from([2, 3, 4, 5]));
+
+    let actual = fts_result_id_scores(
+        &dataset,
+        combined_query_over(
+            &["tags", "body"],
+            "aa",
+            Operator::Or,
+            Some(weights.to_vec()),
+        ),
+        None,
+    )
+    .await;
+    assert_matches_brute_force(
+        &actual,
+        &expected,
+        "a row's list elements must sum into one dl_f",
+    );
+}
+
+/// A target column reached through a list (`List<Struct<Utf8>>`) is a shape a Lance
+/// projection cannot address by its public path, so the flat side scans the list
+/// root and walks down to the leaf itself.
+#[tokio::test]
+async fn test_fts_combined_fields_column_under_a_list() {
+    let params = combined_fields_test_params();
+    // Rows 0-1 are indexed and match "aa" nowhere, so every "aa" hit comes from
+    // the flat side and its score is the exact blended BM25F. Row 2 spreads the
+    // term over two struct elements and row 4 pairs an empty list with a matching
+    // title, so a reader that stopped at the first element, treated each element
+    // as its own document, or skipped empty lists lands on a different score.
+    let docs: Vec<Vec<&str>> = vec![
+        vec!["zz"],
+        vec!["zz zz"],
+        vec!["aa", "bb aa"],
+        vec!["aa aa"],
+        vec![],
+    ];
+    let titles = vec!["zz", "zz", "zz", "aa", "aa aa"];
+
+    let nested_batch = |ids: &[i32], docs: &[Vec<&str>], titles: &[&str]| {
+        let content_field = Arc::new(ArrowField::new("content", DataType::Utf8, true));
+        let struct_fields = ArrowFields::from(vec![content_field]);
+        let contents = docs.iter().flatten().copied().collect::<Vec<_>>();
+        let struct_values = StructArray::new(
+            struct_fields.clone(),
+            vec![Arc::new(StringArray::from(contents)) as ArrayRef],
+            None,
+        );
+        let item = Arc::new(ArrowField::new(
+            "item",
+            DataType::Struct(struct_fields),
+            true,
+        ));
+        let mut offsets = Vec::with_capacity(docs.len() + 1);
+        offsets.push(0i32);
+        for row in docs {
+            offsets.push(offsets.last().unwrap() + row.len() as i32);
+        }
+        let docs_col = Arc::new(ListArray::new(
+            item,
+            OffsetBuffer::new(ScalarBuffer::from(offsets)),
+            Arc::new(struct_values),
+            None,
+        )) as ArrayRef;
+        RecordBatch::try_new(
+            Arc::new(ArrowSchema::new(vec![
+                ArrowField::new("id", DataType::Int32, false),
+                ArrowField::new("docs", docs_col.data_type().clone(), true),
+                ArrowField::new("title", DataType::Utf8, false),
+            ])),
+            vec![
+                Arc::new(Int32Array::from(ids.to_vec())) as ArrayRef,
+                docs_col,
+                Arc::new(StringArray::from(titles.to_vec())) as ArrayRef,
+            ],
+        )
+        .unwrap()
+    };
+
+    let first = nested_batch(&[0, 1], &docs[..2], &titles[..2]);
+    let test_uri = TempStrDir::default();
+    let mut dataset = write_fts_dataset(&test_uri, first, None).await;
+    create_inverted_indices(&mut dataset, &["docs.content", "title"], &params).await;
+
+    let weights = [2.0f32, 1.0f32];
+    // The index joins a row's list elements with a space before tokenizing, so the
+    // reference counts the same tokens either way.
+    let joined: Vec<String> = docs.iter().map(|row| row.join(" ")).collect();
+    let assert_scored_like_reference = |dataset: Dataset, terms: &'static str, rows: usize| {
+        let joined = joined.clone();
+        let titles = titles.clone();
+        async move {
+            let expected = brute_force_bm25f(
+                &[
+                    (
+                        weights[0],
+                        joined[..rows].iter().map(|s| s.as_str()).collect(),
+                    ),
+                    (weights[1], titles[..rows].to_vec()),
+                ],
+                terms,
+                false,
+            );
+            assert!(
+                !brute_force_ids(&expected).is_empty(),
+                "the reference must match something"
+            );
+            let actual = fts_result_id_scores(
+                &dataset,
+                combined_query_over(
+                    &["docs.content", "title"],
+                    terms,
+                    Operator::Or,
+                    Some(weights.to_vec()),
+                ),
+                None,
+            )
+            .await;
+            assert_matches_brute_force(
+                &actual,
+                &expected,
+                "a target column reached through a list must be walked down to its leaf",
+            );
+        }
+    };
+
+    // Fully indexed, so the indexed child owns every hit.
+    assert_scored_like_reference(dataset.clone(), "zz", 2).await;
+
+    // Appending fragments no index covers routes the new rows to the flat sibling,
+    // which has to reach `docs.content` without projecting it.
+    let second = nested_batch(
+        &(2..docs.len() as i32).collect::<Vec<_>>(),
+        &docs[2..],
+        &titles[2..],
+    );
+    let dataset = append_fts_dataset(&test_uri, second, Some(2)).await;
+
+    assert_scored_like_reference(dataset, "aa", docs.len()).await;
+}
+
+/// A `title`/`body`/`tags` batch, for the three-column stride case.
+fn three_column_batch(
+    ids: Vec<i32>,
+    titles: Vec<&str>,
+    bodies: Vec<&str>,
+    tags: Vec<&str>,
+) -> RecordBatch {
+    record_batch!(
+        ("id", Int32, ids),
+        ("title", Utf8, titles),
+        ("body", Utf8, bodies),
+        ("tags", Utf8, tags)
+    )
+    .unwrap()
+}
+
+/// Three columns and two terms, with distinct per-column weights.
+///
+/// Every per-row count is addressed as `(row * num_columns + column) * num_terms +
+/// term`. With two columns and two terms that stride is symmetric enough for a
+/// transposition to survive. The corpus places each term in a different column per
+/// row, so swapping the column and term strides permutes `tf'` and changes the
+/// scores.
+///
+/// Both cases share one corpus and one expected answer: the `flat_side` case only
+/// moves where the rows are scored, which also asserts that the flat scan
+/// reproduces the fully-indexed scores exactly.
+#[rstest]
+#[case::fully_indexed(false)]
+#[case::flat_side(true)]
+#[tokio::test]
+async fn test_fts_combined_fields_three_columns_two_terms(#[case] append_unindexed: bool) {
+    let params = combined_fields_test_params();
+    // Rows 0-1 carry no query term, so they are never returned and the `flat_side`
+    // case can be compared against the same exact scores as the indexed one.
+    let titles = vec!["zz", "zz zz", "aa", "bb bb", "zz", "aa aa"];
+    let bodies = vec!["zz zz", "zz", "bb", "zz", "aa bb", "zz zz"];
+    let tags = vec!["zz", "zz zz", "zz", "aa", "bb", "aa bb"];
+    let columns = ["title", "body", "tags"];
+    let weights = [3.0f32, 2.0f32, 1.0f32];
+
+    let test_uri = TempStrDir::default();
+    let write_params = |mode: WriteMode| WriteParams {
+        mode,
+        max_rows_per_file: 2,
+        ..Default::default()
+    };
+    let indexed_rows = if append_unindexed { 2 } else { titles.len() };
+    let first = three_column_batch(
+        (0..indexed_rows as i32).collect(),
+        titles[..indexed_rows].to_vec(),
+        bodies[..indexed_rows].to_vec(),
+        tags[..indexed_rows].to_vec(),
+    );
+    let mut dataset =
+        write_fts_dataset(&test_uri, first, Some(write_params(WriteMode::Create))).await;
+    create_inverted_indices(&mut dataset, &columns, &params).await;
+
+    let dataset = if append_unindexed {
+        let second = three_column_batch(
+            (indexed_rows as i32..titles.len() as i32).collect(),
+            titles[indexed_rows..].to_vec(),
+            bodies[indexed_rows..].to_vec(),
+            tags[indexed_rows..].to_vec(),
+        );
+        write_fts_dataset(&test_uri, second, Some(write_params(WriteMode::Append))).await
+    } else {
+        dataset
+    };
+
+    for operator in [Operator::Or, Operator::And] {
+        let expected = brute_force_bm25f(
+            &[
+                (weights[0], titles.clone()),
+                (weights[1], bodies.clone()),
+                (weights[2], tags.clone()),
+            ],
+            "aa bb",
+            operator == Operator::And,
+        );
+        assert_eq!(
+            brute_force_ids(&expected),
+            HashSet::from([2, 3, 4, 5]),
+            "reference corpus changed; rows 0-1 must stay unmatched"
+        );
+
+        let actual = fts_result_id_scores(
+            &dataset,
+            combined_query_over(&columns, "aa bb", operator, Some(weights.to_vec())),
+            None,
+        )
+        .await;
+        assert_matches_brute_force(
+            &actual,
+            &expected,
+            &format!("op={operator:?}: the three-column, two-term stride must not transpose"),
+        );
+    }
+}
+
+/// A `combined_fields` query with a filter, over a mixed-coverage dataset.
+///
+/// The flat scan is a `filtered_read(is_prefilter=true)`. When the filter needs a
+/// refine expression, the scan projection gains that expression's columns, so the
+/// document columns no longer sit at the positions the query lists them in and
+/// `doc_col_indices` has to resolve them by name.
+///
+/// Both cases filter to the same rows through different plan shapes: `id >= 4`
+/// resolves entirely through the scalar index (no refine), while `category` has no
+/// index so the whole predicate becomes a refine expression.
+#[rstest]
+#[case::scalar_index_prefilter("id >= 4", true)]
+#[case::refine_expression("category = 'keep'", false)]
+#[tokio::test]
+async fn test_fts_combined_fields_with_filter(
+    #[case] filter: &str,
+    #[case] index_filter_column: bool,
+) {
+    let params = combined_fields_test_params();
+    // Rows 0-1 are indexed for both text columns and match nothing, so every
+    // returned row comes from the flat side and its score can be checked exactly.
+    // Rows 2-3 match but are filtered out, so they contribute no corpus statistics
+    // either: the flat scan never sees them.
+    let titles = vec!["zz zz", "zz", "aa", "zz", "aa aa", "zz"];
+    let bodies = vec!["zz", "zz zz", "zz", "aa aa", "zz", "aa"];
+    let categories = ["keep", "keep", "drop", "drop", "keep", "keep"];
+    // `category` is placed ahead of the document columns, so the refine expression
+    // pulling it into the projection shifts their positions.
+    let batch = |ids: Vec<i32>, rows: std::ops::Range<usize>| {
+        record_batch!(
+            ("id", Int32, ids),
+            ("category", Utf8, categories[rows.clone()].to_vec()),
+            ("title", Utf8, titles[rows.clone()].to_vec()),
+            ("body", Utf8, bodies[rows].to_vec())
+        )
+        .unwrap()
+    };
+
+    let test_uri = TempStrDir::default();
+    let mut dataset = write_fts_dataset(&test_uri, batch(vec![0, 1], 0..2), None).await;
+    create_inverted_indices(&mut dataset, &["title", "body"], &params).await;
+    if index_filter_column {
+        dataset
+            .create_index(
+                &["id"],
+                IndexType::BTree,
+                None,
+                &ScalarIndexParams::default(),
+                true,
+            )
+            .await
+            .unwrap();
+    }
+
+    let dataset = append_fts_dataset(&test_uri, batch((2..6).collect(), 2..6), Some(2)).await;
+
+    // The corpus the scan can see: every row of the indexed fragment (the index
+    // statistics are not filtered) plus only the flat rows that survive the filter.
+    let stats_rows = [0usize, 1, 4, 5];
+    let pick = |values: &[&'static str]| {
+        stats_rows
+            .iter()
+            .map(|&row| values[row])
+            .collect::<Vec<_>>()
+    };
+    let weights = [2.0f32, 1.0f32];
+    let expected = brute_force_bm25f(
+        &[(weights[0], pick(&titles)), (weights[1], pick(&bodies))],
+        "aa",
+        false,
+    );
+    let expected_scores: HashMap<i32, f32> = stats_rows
+        .iter()
+        .enumerate()
+        .filter_map(|(slot, &row)| expected[slot].map(|score| (row as i32, score)))
+        .collect();
+    assert_eq!(
+        expected_scores.keys().copied().collect::<HashSet<_>>(),
+        HashSet::from([4, 5]),
+        "reference corpus changed; only the kept rows may match"
+    );
+
+    let mut scan = dataset.scan();
+    scan.project(&["id"])
+        .unwrap()
+        .prefilter(true)
+        .full_text_search(FullTextSearchQuery::new_query(combined_query_with_boosts(
+            "aa",
+            Operator::Or,
+            Some(weights.to_vec()),
+        )))
+        .unwrap()
+        .filter(filter)
+        .unwrap();
+    let plan = scan.explain_plan(true).await.unwrap();
+    assert!(
+        plan.contains("FlatCombinedFields"),
+        "filtered plan lost its flat child:\n{plan}"
+    );
+    // Confirm the two cases really took the two different branches, rather than
+    // both landing on the same one.
+    if index_filter_column {
+        assert!(
+            plan.contains("ScalarIndexQuery") && plan.contains("refine_filter=--"),
+            "expected the filter to resolve entirely through the scalar index:\n{plan}"
+        );
+        assert!(
+            !plan.contains("category"),
+            "no refine expression, so `category` must stay out of the projection:\n{plan}"
+        );
+    } else {
+        assert!(
+            plan.contains("refine_filter=category"),
+            "expected the filter to become a refine expression:\n{plan}"
+        );
+        assert!(
+            !plan.contains("FilterExec"),
+            "the scan already applies the refine expression, so no second filter:\n{plan}"
+        );
+        assert!(
+            plan.contains("projection=[category, title, body]"),
+            "the refine expression's column must be added to the flat scan \
+             projection:\n{plan}"
+        );
+    }
+
+    let scan_batch = scan.try_into_batch().await.unwrap();
+    let ids = scan_batch
+        .column_by_name("id")
+        .unwrap()
+        .as_primitive::<Int32Type>();
+    let scores = scan_batch
+        .column_by_name("_score")
+        .unwrap()
+        .as_primitive::<Float32Type>();
+    let actual: Vec<(i32, f32)> = (0..scan_batch.num_rows())
+        .map(|i| (ids.value(i), scores.value(i)))
+        .collect();
+
+    assert_eq!(
+        actual.len(),
+        expected_scores.len(),
+        "filter did not restrict the result set:\n{plan}\n{actual:?}"
+    );
+    for (id, score) in actual {
+        let want = *expected_scores
+            .get(&id)
+            .unwrap_or_else(|| panic!("filtered-out row {id} was returned:\n{plan}"));
+        assert!(
+            (score - want).abs() < 1e-3,
+            "id {id}: scan={score}, brute force={want}"
+        );
+    }
+}
+
+#[tokio::test]
+async fn test_fts_combined_fields_deletions_then_optimize() {
+    // Deleted rows must disappear from both sides of the union: the indexed child
+    // sees them through the restricted deletion mask, and the flat child through
+    // its filtered read. The surviving scores must then be unchanged by
+    // `optimize_indices`, because folding a fragment's flat statistics in has to
+    // produce exactly the totals that indexing it produces.
+    let titles = vec!["aa", "aa aa", "zz", "aa aa aa", "aa", "zz zz"];
+    let bodies = vec!["zz", "zz", "aa aa", "zz", "aa aa", "aa"];
+
+    let (test_uri, _indexed) = indexed_two_column_dataset(&titles[..3], &bodies[..3], None).await;
+    let second = combined_fields_batch(vec![3, 4, 5], titles[3..].to_vec(), bodies[3..].to_vec());
+    let mut dataset = append_fts_dataset(&test_uri, second, None).await;
+
+    // One deletion in the indexed fragment, one in the appended (flat) fragment.
+    dataset.delete("id in (1, 4)").await.unwrap();
+
+    // Row 1 stays in the index's own statistics, because a delete does not rewrite
+    // the `DocSet`, while row 4 never reaches the flat counter, so it drops out of
+    // the corpus entirely.
+    let stats_rows = [0usize, 1, 2, 3, 5];
+    let pick = |values: &[&'static str]| {
+        stats_rows
+            .iter()
+            .map(|&row| values[row])
+            .collect::<Vec<_>>()
+    };
+    let weights = [2.0f32, 1.0f32];
+    let expected = brute_force_bm25f(
+        &[(weights[0], pick(&titles)), (weights[1], pick(&bodies))],
+        "aa",
+        false,
+    );
+    let expected_scores: HashMap<i32, f32> = stats_rows
+        .iter()
+        .enumerate()
+        .filter_map(|(slot, &row)| expected[slot].map(|score| (row as i32, score)))
+        .collect();
+
+    let query = || combined_query_with_boosts("aa", Operator::Or, Some(weights.to_vec()));
+    let live_ids = HashSet::from([0, 2, 3, 5]);
+    let mut scan = dataset.scan();
+    scan.project(&["id"])
+        .unwrap()
+        .full_text_search(FullTextSearchQuery::new_query(query()))
+        .unwrap();
+    let mixed_plan = scan.explain_plan(true).await.unwrap();
+    assert!(
+        mixed_plan.contains("FlatCombinedFields"),
+        "the appended fragment is unindexed, so the plan must have a flat child:\n{mixed_plan}"
+    );
+
+    let mixed = fts_result_id_scores(&dataset, query(), None).await;
+    assert_eq!(
+        mixed.iter().map(|(id, _)| *id).collect::<HashSet<_>>(),
+        live_ids,
+        "deleted rows leaked into the mixed index/flat plan: {mixed:?}"
+    );
+    assert_eq!(mixed.len(), live_ids.len(), "duplicate row: {mixed:?}");
+    // Rows 3 and 5 are the ones the flat child scores, so they see the blended
+    // statistics in full. Rows 0 and 2 come from the indexed child, which still
+    // scores against index-only statistics (a known gap documented at the union).
+    let mixed_scores: HashMap<i32, f32> = mixed.into_iter().collect();
+    for id in [3, 5] {
+        let want = expected_scores[&id];
+        let got = mixed_scores[&id];
+        assert!(
+            (got - want).abs() < 1e-3,
+            "id {id} after delete: scan={got}, brute force={want}"
+        );
+    }
+
+    // Indexing the appended fragment must leave those scores untouched, and the
+    // plan must collapse back to a single indexed scan.
+    dataset
+        .optimize_indices(&OptimizeOptions::default())
+        .await
+        .unwrap();
+    let mut scan = dataset.scan();
+    scan.project(&["id"])
+        .unwrap()
+        .full_text_search(FullTextSearchQuery::new_query(query()))
+        .unwrap();
+    let plan = scan.explain_plan(true).await.unwrap();
+    assert!(
+        plan.contains("CombinedFieldsQuery"),
+        "expected an indexed combined-fields scan:\n{plan}"
+    );
+    assert!(
+        !plan.contains("FlatCombinedFields"),
+        "every fragment is indexed but the plan still has a flat child:\n{plan}"
+    );
+
+    let optimized = fts_result_id_scores(&dataset, query(), None).await;
+    assert_eq!(
+        optimized.iter().map(|(id, _)| *id).collect::<HashSet<_>>(),
+        live_ids,
+        "deleted rows came back after optimize: {optimized:?}"
+    );
+    // Now that every row is indexed there is a single corpus, so every score has to
+    // match the reference, including the rows the mixed plan scored from the index
+    // only.
+    for (id, score) in optimized {
+        let want = expected_scores[&id];
+        assert!(
+            (score - want).abs() < 1e-3,
+            "id {id} after optimize: scan={score}, brute force={want}"
+        );
+    }
+}
+
+#[tokio::test]
+async fn test_fts_combined_fields_nested_columns() {
+    // Nested target columns: the flat plan projects the struct column from storage,
+    // so it calls `ensure_column_alias` once per target column to expose `s.a` and
+    // `s.b` as top-level names the exec can resolve. Both aliases survive only
+    // because one projection is nested inside the other.
+    let params = combined_fields_test_params();
+    let a_values = [
+        Some("zz zz"),
+        Some("zz"),
+        Some("aa"),
+        Some("zz"),
+        Some("aa aa"),
+    ];
+    let b_values = [
+        Some("zz"),
+        Some("zz zz"),
+        Some("zz"),
+        Some("aa aa"),
+        Some("aa"),
+    ];
+
+    let first = nested_fts_batch(vec![0, 1], a_values[..2].to_vec(), b_values[..2].to_vec());
+    let test_uri = TempStrDir::default();
+    let mut dataset = write_fts_dataset(&test_uri, first, None).await;
+    create_inverted_indices(&mut dataset, &["s.a", "s.b"], &params).await;
+    // Rows 0-1 are indexed and match nothing, so the appended rows are the ones
+    // returned and the flat path owns every score.
+    let second = nested_fts_batch(
+        vec![2, 3, 4],
+        a_values[2..].to_vec(),
+        b_values[2..].to_vec(),
+    );
+    let schema = second.schema();
+    dataset
+        .append(
+            RecordBatchIterator::new(vec![second].into_iter().map(Ok), schema),
+            None,
+        )
+        .await
+        .unwrap();
+
+    let weights = [2.0f32, 1.0f32];
+    let expected = brute_force_bm25f(
+        &[
+            (
+                weights[0],
+                a_values.iter().map(|v| v.unwrap_or("")).collect(),
+            ),
+            (
+                weights[1],
+                b_values.iter().map(|v| v.unwrap_or("")).collect(),
+            ),
+        ],
+        "aa",
+        false,
+    );
+    let expected_ids: HashSet<u64> = (0..expected.len())
+        .filter(|&i| expected[i].is_some())
+        .map(|i| i as u64)
+        .collect();
+    assert_eq!(expected_ids, HashSet::from([2, 3, 4]));
+
+    let mut scan = dataset.scan();
+    scan.full_text_search(FullTextSearchQuery::new_query(combined_query_over(
+        &["s.a", "s.b"],
+        "aa",
+        Operator::Or,
+        Some(weights.to_vec()),
+    )))
+    .unwrap();
+    let plan = scan.explain_plan(true).await.unwrap();
+    assert!(
+        plan.contains("FlatCombinedFields"),
+        "the appended fragment is unindexed, so the nested columns must be aliased \
+         for a flat child:\n{plan}"
+    );
+
+    let batch = scan.try_into_batch().await.unwrap();
+    let ids = batch["id"].as_primitive::<UInt64Type>();
+    let scores = batch["_score"].as_primitive::<Float32Type>();
+    let actual: Vec<(u64, f32)> = (0..batch.num_rows())
+        .map(|i| (ids.value(i), scores.value(i)))
+        .collect();
+    assert_eq!(
+        actual.len(),
+        expected_ids.len(),
+        "duplicate row: {actual:?}"
+    );
+    assert_eq!(
+        actual.iter().map(|(id, _)| *id).collect::<HashSet<_>>(),
+        expected_ids
+    );
+    for (id, score) in actual {
+        let want = expected[id as usize].expect("scan returned an unmatched doc");
+        assert!(
+            (score - want).abs() < 1e-3,
+            "id {id}: scan={score}, brute force={want}"
+        );
+    }
+}
diff --git a/rust/lance/src/dataset/tests/dataset_overlay_index_masking.rs b/rust/lance/src/dataset/tests/dataset_overlay_index_masking.rs
index 0113319c528..b3155560363 100644
--- a/rust/lance/src/dataset/tests/dataset_overlay_index_masking.rs
+++ b/rust/lance/src/dataset/tests/dataset_overlay_index_masking.rs
@@ -11,7 +11,7 @@ use futures::TryStreamExt;
 
 use arrow_array::builder::{ListBuilder, StringBuilder};
 use arrow_array::cast::AsArray;
-use arrow_array::types::Int32Type;
+use arrow_array::types::{Float32Type, Int32Type};
 use arrow_array::{ArrayRef, Int32Array, RecordBatch, RecordBatchIterator, StringArray};
 use arrow_schema::{DataType, Field as ArrowField, Schema as ArrowSchema};
 use lance_index::IndexType;
@@ -873,7 +873,7 @@ async fn build_text_fts_index_with_positions(dataset: &mut Dataset) {
         .unwrap();
 }
 
-/// Collect sorted IDs of rows returned by an FTS query on `text`.
+/// Collect sorted IDs of rows returned by an FTS query.
 async fn fts_ids(dataset: &Dataset, query: FullTextSearchQuery) -> Vec<i32> {
     let results = dataset
         .scan()
@@ -1649,6 +1649,683 @@ async fn test_fts_overlay_unrelated_field_not_excluded() {
     assert_eq!(fts_ids_matching(&dataset, "banana").await, vec![3, 999]);
 }
 
+fn combined_fields_query(terms: &str, columns: &[&str]) -> FullTextSearchQuery {
+    use lance_index::scalar::inverted::query::{CombinedFieldsQuery, FtsQuery};
+
+    FullTextSearchQuery::new_query(FtsQuery::CombinedFields(
+        CombinedFieldsQuery::try_new(
+            terms.to_owned(),
+            columns.iter().map(|column| column.to_string()).collect(),
+        )
+        .unwrap(),
+    ))
+}
+
+/// Optional settings for a `combined_fields` query in these tests.
+#[derive(Default)]
+struct CombinedScan<'a> {
+    /// Applied as a prefilter.
+    filter: Option<&'a str>,
+    fragment_ids: Option<&'a [u32]>,
+    limit: Option<i64>,
+    fast_search: bool,
+}
+
+/// `(id, score)` of every cross-field (BM25F) `combined_fields` hit, in score
+/// order. Scores are bit patterns, so a corpus that shifted by one document shows
+/// up instead of passing a tolerance.
+async fn fts_combined_hits(
+    dataset: &Dataset,
+    terms: &str,
+    columns: &[&str],
+    scan: CombinedScan<'_>,
+) -> Vec<(i32, u32)> {
+    let mut scanner = dataset.scan();
+    if let Some(fragment_ids) = scan.fragment_ids {
+        scanner.with_fragments(
+            dataset
+                .fragments()
+                .iter()
+                .filter(|fragment| fragment_ids.contains(&(fragment.id as u32)))
+                .cloned()
+                .collect(),
+        );
+    }
+    if let Some(filter) = scan.filter {
+        scanner.prefilter(true).filter(filter).unwrap();
+    }
+    if scan.fast_search {
+        scanner.fast_search();
+    }
+    scanner
+        .full_text_search(combined_fields_query(terms, columns).limit(scan.limit))
+        .unwrap()
+        .project(&["id"])
+        .unwrap();
+    let batch = scanner.try_into_batch().await.unwrap();
+    let ids = batch["id"].as_primitive::<Int32Type>();
+    let scores = batch["_score"].as_primitive::<Float32Type>();
+    (0..batch.num_rows())
+        .map(|i| (ids.value(i), scores.value(i).to_bits()))
+        .collect()
+}
+
+/// Sorted ids of [`fts_combined_hits`].
+async fn fts_combined_ids(
+    dataset: &Dataset,
+    terms: &str,
+    columns: &[&str],
+    scan: CombinedScan<'_>,
+) -> Vec<i32> {
+    let mut ids: Vec<i32> = fts_combined_hits(dataset, terms, columns, scan)
+        .await
+        .into_iter()
+        .map(|(id, _)| id)
+        .collect();
+    ids.sort_unstable();
+    ids
+}
+
+/// Sorted `id` values a single-column `MatchQuery` returns. This is the reference
+/// answer `combined_fields` must agree with: an `Or` combined-fields query matches
+/// a document when a query term appears in at least one target column, so the
+/// combined result is the union of the per-column match results.
+async fn fts_match_ids(dataset: &Dataset, term: &str, column: &str) -> Vec<i32> {
+    use lance_index::scalar::inverted::query::{FtsQuery, MatchQuery};
+
+    let query = FullTextSearchQuery::new_query(FtsQuery::Match(
+        MatchQuery::new(term.to_owned()).with_column(Some(column.to_owned())),
+    ));
+    fts_ids(dataset, query).await
+}
+
+/// Union of the per-column `MatchQuery` results for `term`, sorted.
+async fn fts_match_union_ids(dataset: &Dataset, term: &str, columns: &[&str]) -> Vec<i32> {
+    let mut ids = Vec::new();
+    for column in columns {
+        ids.extend(fts_match_ids(dataset, term, column).await);
+    }
+    ids.sort_unstable();
+    ids.dedup();
+    ids
+}
+
+/// Build an FTS index on `column` as one segment per fragment, the multi-segment
+/// counterpart of the whole-index single segment `build_text_fts_index` produces.
+/// An overlay-stale fragment is excluded from the indexed scan either way, so both
+/// layouts run the indexed and the flat side; only the number of segments the
+/// indexed side opens differs.
+async fn build_per_fragment_fts_index(dataset: &mut Dataset, column: &str) {
+    let params = InvertedIndexParams::default();
+    let name = format!("{column}_fts");
+    let fragment_ids = dataset
+        .get_fragments()
+        .into_iter()
+        .map(|fragment| fragment.id() as u32)
+        .collect::<Vec<_>>();
+    let mut segments = Vec::with_capacity(fragment_ids.len());
+    for fragment_id in fragment_ids {
+        segments.push(
+            CreateIndexBuilder::new(dataset, &[column], IndexType::Inverted, &params)
+                .name(name.clone())
+                .fragments(vec![fragment_id])
+                .execute_uncommitted()
+                .await
+                .unwrap(),
+        );
+    }
+    dataset
+        .commit_existing_index_segments(&name, column, segments)
+        .await
+        .unwrap();
+}
+
+/// `combined_fields` must honour the same data-overlay contract as `match`: a
+/// fragment holding an overlay-stale row is dropped from the indexed scan and
+/// re-evaluated on the flat path. Without that the indexed scan answers from the
+/// pre-overlay index, so it both returns stale hits and misses new matches.
+///
+/// `match` blocks the individual stale row addresses instead (see
+/// `plan_combined_fields_query` for why BM25F cannot), but the answer must be the
+/// same either way.
+///
+/// Parametrized over the segment layout: one segment for the whole index, and one
+/// segment per fragment.
+#[rstest]
+#[tokio::test]
+async fn test_fts_combined_fields_overlay_agrees_with_match(
+    #[values(false, true)] per_fragment_segments: bool,
+) {
+    let mut dataset = create_text_dataset(false).await;
+    if per_fragment_segments {
+        build_per_fragment_fts_index(&mut dataset, "text").await;
+    } else {
+        build_text_fts_index(&mut dataset).await;
+    }
+
+    // fragment 0, row offset 1 (id=1): "apple banana" → "cherry mango".
+    // Field ID 1 is the `text` column.
+    let dataset = commit_overlay(
+        dataset,
+        "combined_text_overlay",
+        0,
+        &[1],
+        OverlayCoverage::dense(RoaringBitmap::from_iter([1])),
+        vec![Arc::new(StringArray::from(vec![Some("cherry mango")]))],
+    )
+    .await;
+
+    // Both directions: "apple"/"banana" must lose the stale id=1 hit, and
+    // "cherry"/"mango" must gain it.
+    for (term, expected) in [
+        ("apple", vec![0]),
+        ("banana", vec![3]),
+        ("cherry", vec![1, 2]),
+        ("mango", vec![1, 6]),
+    ] {
+        let combined = fts_combined_ids(&dataset, term, &["text"], CombinedScan::default()).await;
+        assert_eq!(
+            combined,
+            fts_match_ids(&dataset, term, "text").await,
+            "combined_fields disagrees with match for '{term}'"
+        );
+        assert_eq!(combined, expected, "wrong rows for '{term}'");
+    }
+}
+
+/// The overlay term must be findable even when no indexed posting list holds it.
+///
+/// Taking the column's `docFreq_f` from the pre-overlay index alone leaves a term the
+/// overlay introduced at `docFreq' == 0`, so `query_weight` is `0.0`, the row scores
+/// zero and the flat scan drops it.
+#[tokio::test]
+async fn test_fts_combined_fields_overlay_new_term_absent_from_index_stats() {
+    let mut dataset = create_text_dataset(false).await;
+    build_text_fts_index(&mut dataset).await;
+
+    // fragment 0, row offset 1 (id=1): "apple banana" → "quasarunique", a term that
+    // occurs in no other row and so in no indexed posting list.
+    let dataset = commit_overlay(
+        dataset,
+        "combined_unique_text_overlay",
+        0,
+        &[1],
+        OverlayCoverage::dense(RoaringBitmap::from_iter([1])),
+        vec![Arc::new(StringArray::from(vec![Some("quasarunique")]))],
+    )
+    .await;
+
+    assert_eq!(
+        fts_match_ids(&dataset, "quasarunique", "text").await,
+        vec![1]
+    );
+    assert_eq!(
+        fts_combined_ids(&dataset, "quasarunique", &["text"], CombinedScan::default()).await,
+        vec![1]
+    );
+}
+
+/// Text dataset with an `id` column holding the row offset plus one `Utf8` column per
+/// entry of `columns`, laid out `rows_per_file` rows to a fragment. `id` is field 0 and
+/// the text columns take the following field IDs in order.
+async fn create_text_dataset_with(columns: &[(&str, &[&str])], rows_per_file: usize) -> Dataset {
+    let num_rows = columns[0].1.len() as i32;
+    let mut fields = vec![ArrowField::new("id", DataType::Int32, true)];
+    let mut arrays: Vec<ArrayRef> = vec![Arc::new(Int32Array::from_iter_values(0..num_rows))];
+    for (name, values) in columns {
+        fields.push(ArrowField::new(*name, DataType::Utf8, true));
+        arrays.push(Arc::new(StringArray::from(values.to_vec())));
+    }
+    let schema = Arc::new(ArrowSchema::new(fields));
+    let batch = RecordBatch::try_new(schema.clone(), arrays).unwrap();
+    let write_params = WriteParams {
+        max_rows_per_file: rows_per_file,
+        ..Default::default()
+    };
+    let reader = RecordBatchIterator::new(vec![Ok(batch)], schema.clone());
+    Dataset::write(reader, "memory://", Some(write_params))
+        .await
+        .unwrap()
+}
+
+/// A same-value overlay must not move top-k: it leaves every searchable value alone, so
+/// the corpus the ranking is measured against must not change either.
+///
+/// The prefilter prunes the flat scan, so statistics folded from that scan describe the
+/// filtered subset, while the indexed plan an overlay-free dataset takes uses the whole index.
+/// Globally `beta` is the rare term, so id 1 wins; the overlay rewrites a row the filter
+/// excludes.
+///
+/// - `tie`: over the filtered pair the two terms have equal `docFreq`, so the scores tie,
+///   which is enough to lose id 1.
+/// - `strict`: over ids 0..2, `df(alpha) = 1` against `df(beta) = 2` puts id 0 ahead by
+///   roughly 2x, so the ranking flips on a strict inequality rather than on tie order.
+///   Id 2 carries filler tokens purely to lengthen it, so it never ties with id 1.
+#[rstest]
+#[case::tie("alpha", "id < 2", 2)]
+#[case::strict("beta gamma delta", "id < 3", 5)]
+#[tokio::test]
+async fn test_fts_combined_fields_overlay_preserves_prefilter_corpus(
+    #[case] third_text: &str,
+    #[case] filter: &str,
+    #[case] overwritten_row: u32,
+) {
+    let mut texts = vec!["alpha"; 12];
+    texts[1] = "beta";
+    texts[2] = third_text;
+    let mut dataset = create_text_dataset_with(&[("text", &texts)], 12).await;
+    build_text_fts_index(&mut dataset).await;
+    let scan = || CombinedScan {
+        filter: Some(filter),
+        limit: Some(1),
+        ..Default::default()
+    };
+    assert_eq!(
+        fts_combined_ids(&dataset, "alpha beta", &["text"], scan()).await,
+        vec![1]
+    );
+
+    let dataset = commit_overlay(
+        dataset,
+        "combined_prefilter_same_value_overlay",
+        0,
+        &[1],
+        OverlayCoverage::dense(RoaringBitmap::from_iter([overwritten_row])),
+        vec![Arc::new(StringArray::from(vec![Some("alpha")]))],
+    )
+    .await;
+    assert_eq!(
+        fts_combined_ids(&dataset, "alpha beta", &["text"], scan()).await,
+        vec![1]
+    );
+}
+
+/// Fragment selection must restrict which rows are returned, not which corpus they
+/// are scored against. A same-value overlay inside the selection leaves every
+/// searchable value alone, so top-k must not move.
+#[tokio::test]
+async fn test_fts_combined_fields_overlay_preserves_fragment_corpus() {
+    // Fragment 0 holds the only `beta` rows; the nine `alpha` rows behind it are what
+    // make `beta` the rare term, and they are outside the selection.
+    let texts: &[&str] = &[
+        "alpha",
+        "beta",
+        "beta gamma delta",
+        "alpha",
+        "alpha",
+        "alpha",
+        "alpha",
+        "alpha",
+        "alpha",
+        "alpha",
+        "alpha",
+        "alpha",
+    ];
+    let mut dataset = create_text_dataset_with(&[("text", texts)], 3).await;
+    build_text_fts_index(&mut dataset).await;
+
+    assert_eq!(
+        fts_combined_ids(
+            &dataset,
+            "alpha beta",
+            &["text"],
+            CombinedScan {
+                fragment_ids: Some(&[0]),
+                limit: Some(1),
+                ..Default::default()
+            },
+        )
+        .await,
+        vec![1]
+    );
+
+    // Row offset 2 rewritten with the value it already holds.
+    let dataset = commit_overlay(
+        dataset,
+        "combined_fragment_same_value_overlay",
+        0,
+        &[1],
+        OverlayCoverage::dense(RoaringBitmap::from_iter([2])),
+        vec![Arc::new(StringArray::from(vec![Some("beta gamma delta")]))],
+    )
+    .await;
+    assert_eq!(
+        fts_combined_ids(
+            &dataset,
+            "alpha beta",
+            &["text"],
+            CombinedScan {
+                fragment_ids: Some(&[0]),
+                limit: Some(1),
+                ..Default::default()
+            },
+        )
+        .await,
+        vec![1]
+    );
+}
+
+/// An overlay that rewrites rows with the values they already hold has to leave
+/// every score alone, not just the order.
+///
+/// The index counts a stale row's old value and the flat scan folds in its current
+/// one, so the row is counted twice unless the old value is subtracted. Here that
+/// makes `alpha` look commoner than `beta` and flips the ranking. Ids alone would
+/// not catch it, because the same five rows come back either way.
+#[tokio::test]
+async fn test_fts_combined_fields_overlay_preserves_every_score() {
+    let texts: &[&str] = &["alpha", "alpha", "beta", "beta", "beta"];
+    let mut dataset = create_text_dataset_with(&[("text", texts)], 5).await;
+    build_text_fts_index(&mut dataset).await;
+    let before =
+        fts_combined_hits(&dataset, "alpha beta", &["text"], CombinedScan::default()).await;
+    // `alpha` is the rarer term, so its rows lead.
+    assert_eq!(
+        before.iter().map(|(id, _)| *id).collect::<Vec<_>>(),
+        vec![0, 1, 2, 3, 4]
+    );
+
+    let dataset = commit_overlay(
+        dataset,
+        "combined_same_value_overlay_scores",
+        0,
+        &[1],
+        OverlayCoverage::dense(RoaringBitmap::from_iter([0, 1])),
+        vec![Arc::new(StringArray::from(vec![
+            Some("alpha"),
+            Some("alpha"),
+        ]))],
+    )
+    .await;
+
+    assert_eq!(
+        fts_combined_hits(&dataset, "alpha beta", &["text"], CombinedScan::default()).await,
+        before
+    );
+}
+
+/// An overlay must cost only the fragments it touched. Folding the stale rows on top
+/// of the index keeps the corpus global, so the untouched fragments stay on the
+/// indexed side instead of the whole table going through a full scan.
+#[tokio::test]
+async fn test_fts_combined_fields_overlay_keeps_clean_fragments_indexed() {
+    let mut dataset = create_text_dataset(false).await;
+    build_text_fts_index(&mut dataset).await;
+
+    // Fragment 0 only; fragment 1 (ids 6..11) is untouched.
+    let dataset = commit_overlay(
+        dataset,
+        "combined_partial_overlay",
+        0,
+        &[1],
+        OverlayCoverage::dense(RoaringBitmap::from_iter([1])),
+        vec![Arc::new(StringArray::from(vec![Some("cherry mango")]))],
+    )
+    .await;
+
+    let mut scan = dataset.scan();
+    scan.project(&["id"])
+        .unwrap()
+        .full_text_search(combined_fields_query("cherry", &["text"]))
+        .unwrap();
+    let plan = scan.explain_plan(true).await.unwrap();
+    assert!(
+        plan.contains("CombinedFieldsQuery"),
+        "fragment 1 has no stale entry, so it must stay on the indexed side:\n{plan}"
+    );
+    assert!(
+        plan.contains("FlatCombinedFields"),
+        "fragment 0 must be re-read on the flat side:\n{plan}"
+    );
+}
+
+/// An overlay must not cost the flat scan the rows only it can return.
+///
+/// Once a stale row folds, the flat scan is read unfiltered and its emitted rows
+/// are picked by a prefilter instead, so that a same-value overlay cannot move the
+/// corpus (see `test_fts_combined_fields_overlay_preserves_prefilter_corpus`).
+/// That prefilter has to span the fragments the flat scan reads. The indexed
+/// child's own prefilter does not: it is built over the fragments the target
+/// columns' indexes cover, so it names no row in an appended fragment, and an
+/// allow-list can only be narrowed afterwards, never widened.
+#[tokio::test]
+async fn test_fts_combined_fields_overlay_keeps_unindexed_selected_match() {
+    let mut dataset = create_text_dataset(false).await;
+    build_text_fts_index(&mut dataset).await;
+
+    // `mango` now sits both in indexed fragment 1 (id 6) and in an appended
+    // fragment no index covers, so the two sides of the union are told apart.
+    let batch = arrow_array::record_batch!(("id", Int32, [12]), ("text", Utf8, ["mango"])).unwrap();
+    let schema = batch.schema();
+    let reader = RecordBatchIterator::new(vec![Ok(batch)], schema);
+    let dataset = Dataset::write(
+        reader,
+        Arc::new(dataset),
+        Some(WriteParams {
+            mode: crate::dataset::write::WriteMode::Append,
+            ..Default::default()
+        }),
+    )
+    .await
+    .unwrap();
+    let appended_fragment_id = dataset.fragments().last().unwrap().id as u32;
+    // A fragment selection is what makes the prefilter fragment-scoped in the first
+    // place; with no filter and no selection it allows every row.
+    let selected_fragments = [0, appended_fragment_id];
+
+    assert_eq!(
+        fts_combined_ids(
+            &dataset,
+            "mango",
+            &["text"],
+            CombinedScan {
+                fragment_ids: Some(&selected_fragments),
+                limit: Some(10),
+                ..Default::default()
+            },
+        )
+        .await,
+        vec![12],
+        "precondition: the appended match is returned before any overlay exists"
+    );
+
+    // Fragment 0 holds no `mango`, so this overlay changes no answer. All it does is
+    // route the scan onto the unfiltered-read path.
+    let dataset = commit_overlay(
+        dataset,
+        "combined_unindexed_selected_match_overlay",
+        0,
+        &[1],
+        OverlayCoverage::dense(RoaringBitmap::from_iter([0])),
+        vec![Arc::new(StringArray::from(vec![Some("apple pie")]))],
+    )
+    .await;
+
+    assert_eq!(
+        fts_combined_ids(&dataset, "mango", &["text"], CombinedScan::default()).await,
+        vec![6, 12],
+        "unselected control: both matches are still reachable"
+    );
+    assert_eq!(
+        fts_combined_ids(
+            &dataset,
+            "mango",
+            &["text"],
+            CombinedScan {
+                fragment_ids: Some(&selected_fragments),
+                limit: Some(10),
+                ..Default::default()
+            },
+        )
+        .await,
+        vec![12],
+        "the overlay dropped a match from a selected unindexed fragment"
+    );
+}
+
+/// Two-fragment dataset with two indexable text columns: `id`, `title`, `body`.
+/// Field IDs are 0 (`id`), 1 (`title`), 2 (`body`).
+async fn create_two_column_text_dataset() -> Dataset {
+    let titles: &[&str] = &[
+        "apple pie",
+        "apple banana", // row 1, fragment 0, overlaid in tests
+        "cherry cake",
+        "banana split",
+        "orange juice",
+        "grape vine",
+        "mango sorbet", // fragment 1 starts here
+        "pear tart",
+        "lemon curd",
+        "peach cobbler",
+        "plum pudding",
+        "fig newton",
+    ];
+    // `dessert` spans both fragments, and `fruit` sits on the overlaid row plus a
+    // row in the other fragment, so a body term exercises the flat and the indexed
+    // side of the union at once.
+    let bodies: &[&str] = &[
+        "sweet dessert",
+        "yellow fruit",
+        "red dessert",
+        "frozen treat",
+        "citrus drink",
+        "purple cluster",
+        "tropical ice",
+        "green fruit",
+        "sour spread",
+        "warm bake",
+        "dark dessert",
+        "dry biscuit",
+    ];
+    create_text_dataset_with(&[("title", titles), ("body", bodies)], 6).await
+}
+
+/// The multi-column shape of the contract above. An overlay on one target column
+/// makes the whole fragment unscorable from the indexes: a stale row poisons the
+/// blended `dl'`/`tf'` of every target column, not just the overlaid one, so the
+/// fragment has to be re-evaluated flat across all of them.
+///
+/// Only `title` is overlaid, so `body`'s index still covers the fragment. The
+/// indexed scan has to skip it for both columns anyway, the case where a missing
+/// fragment allow list emits the fragment twice, once per side of the union.
+#[rstest]
+#[tokio::test]
+async fn test_fts_combined_fields_multi_column_overlay_agrees_with_match(
+    #[values(false, true)] per_fragment_segments: bool,
+) {
+    let mut dataset = create_two_column_text_dataset().await;
+    for column in ["title", "body"] {
+        if per_fragment_segments {
+            build_per_fragment_fts_index(&mut dataset, column).await;
+        } else {
+            dataset
+                .create_index(
+                    &[column],
+                    IndexType::Inverted,
+                    None,
+                    &InvertedIndexParams::default(),
+                    true,
+                )
+                .await
+                .unwrap();
+        }
+    }
+
+    // Overlay `title` (field 1) of fragment 0, row offset 1 (id=1):
+    // "apple banana" → "cherry mango". `body` is untouched.
+    let dataset = commit_overlay(
+        dataset,
+        "combined_title_overlay",
+        0,
+        &[1],
+        OverlayCoverage::dense(RoaringBitmap::from_iter([1])),
+        vec![Arc::new(StringArray::from(vec![Some("cherry mango")]))],
+    )
+    .await;
+
+    let columns = ["title", "body"];
+    for (term, expected) in [
+        // Stale title hits are dropped.
+        ("apple", vec![0]),
+        ("banana", vec![3]),
+        // New title matches are found.
+        ("cherry", vec![1, 2]),
+        ("mango", vec![1, 6]),
+        // A term of the untouched target column still resolves on both sides of the
+        // union: id=1 comes from the flat path, id=7 from the indexed path.
+        ("fruit", vec![1, 7]),
+        ("dessert", vec![0, 2, 10]),
+    ] {
+        let combined = fts_combined_ids(&dataset, term, &columns, CombinedScan::default()).await;
+        assert_eq!(
+            combined,
+            fts_match_union_ids(&dataset, term, &columns).await,
+            "combined_fields disagrees with match for '{term}'"
+        );
+        assert_eq!(combined, expected, "wrong rows for '{term}'");
+    }
+}
+
+/// `fast_search` is index-only, so the overlay-stale fragment is dropped instead of
+/// re-evaluated: the stale hit still must not come back, and the new value stays
+/// invisible until compaction folds the overlay into the base. Every other fragment
+/// keeps answering, whichever segment layout holds it.
+#[rstest]
+#[tokio::test]
+async fn test_fts_combined_fields_overlay_under_fast_search(
+    #[values(false, true)] per_fragment_segments: bool,
+) {
+    let mut dataset = create_text_dataset(false).await;
+    if per_fragment_segments {
+        build_per_fragment_fts_index(&mut dataset, "text").await;
+    } else {
+        build_text_fts_index(&mut dataset).await;
+    }
+    let dataset = commit_overlay(
+        dataset,
+        "combined_fast_search_overlay",
+        0,
+        &[1],
+        OverlayCoverage::dense(RoaringBitmap::from_iter([1])),
+        vec![Arc::new(StringArray::from(vec![Some("cherry mango")]))],
+    )
+    .await;
+
+    // Fragment 0 is stale either way, so nothing it holds is answerable: no stale
+    // "apple"/"banana" hit and no new "cherry" hit.
+    for term in ["apple", "banana", "cherry"] {
+        assert_eq!(
+            fts_combined_ids(
+                &dataset,
+                term,
+                &["text"],
+                CombinedScan {
+                    fast_search: true,
+                    ..Default::default()
+                },
+            )
+            .await,
+            Vec::<i32>::new(),
+            "fast_search returned a row from the stale fragment for '{term}'"
+        );
+    }
+    // Fragment 1 holds no stale row, so it stays on the indexed side and answers
+    // even though the whole-index segment layout also covers the stale fragment.
+    assert_eq!(
+        fts_combined_ids(
+            &dataset,
+            "mango",
+            &["text"],
+            CombinedScan {
+                fast_search: true,
+                ..Default::default()
+            },
+        )
+        .await,
+        vec![6]
+    );
+}
+
 /// Benchmark: measure query latency for BTree, FTS, and vector ANN with 0/4/16 overlay layers.
 ///
 /// Run with:
diff --git a/rust/lance/src/index/scalar/inverted.rs b/rust/lance/src/index/scalar/inverted.rs
index 19be788e908..f8591fd2074 100644
--- a/rust/lance/src/index/scalar/inverted.rs
+++ b/rust/lance/src/index/scalar/inverted.rs
@@ -734,6 +734,71 @@ pub(crate) fn fts_document_schema(coordinate_rank: usize) -> Arc<ArrowSchema> {
     Arc::new(ArrowSchema::new(fields))
 }
 
+/// Add (or replace) a flat `Utf8` column holding each row's document text for a
+/// list-bearing FTS field path, leaving every other column and row untouched.
+///
+/// A Lance projection cannot address a field that continues past a `List`, so a
+/// scan that needs `docs.content` has to project the `docs` root instead. This
+/// walks the traversal down to the leaf per row, joining the elements exactly the
+/// way the index builder does at row granularity.
+///
+/// Row granularity yields one document per input row, in row order, keeping several
+/// such columns aligned for a cross-field blend. Not valid for list-element
+/// granularity, where a row expands to several documents.
+pub(crate) fn flatten_fts_document_column(
+    input: SendableRecordBatchStream,
+    resolved: ResolvedFtsField,
+) -> Result<SendableRecordBatchStream> {
+    if resolved.document_granularity.is_list_element() {
+        return Err(Error::internal(
+            "flatten_fts_document_column needs row documents to keep one output row per input row"
+                .to_string(),
+        ));
+    }
+    let input_schema = input.schema();
+    if input_schema
+        .column_with_name(&resolved.root_column)
+        .is_none()
+    {
+        return Err(Error::internal(format!(
+            "FTS document input must contain the root source column '{}'",
+            resolved.root_column
+        )));
+    }
+    let text_field = ArrowField::new(&resolved.canonical_path, DataType::Utf8, false);
+    let replaced = input_schema.column_with_name(&resolved.canonical_path);
+    let mut fields = input_schema.fields().to_vec();
+    match replaced {
+        Some((index, _)) => fields[index] = Arc::new(text_field),
+        None => fields.push(Arc::new(text_field)),
+    }
+    let replaced = replaced.map(|(index, _)| index);
+    let output_schema = Arc::new(ArrowSchema::new(fields));
+    let stream_schema = output_schema.clone();
+    let stream = input.map(move |batch| {
+        let batch = batch?;
+        let source = batch
+            .column_by_name(&resolved.root_column)
+            .expect("FTS document input schema was validated");
+        let documents = resolved
+            .documents_from_array(source, batch.num_rows())
+            .map_err(DataFusionError::from)?;
+        let texts = Arc::new(StringArray::from_iter_values(
+            documents.iter().map(|document| document.text.as_str()),
+        )) as ArrayRef;
+        let mut columns = batch.columns().to_vec();
+        match replaced {
+            Some(index) => columns[index] = texts,
+            None => columns.push(texts),
+        }
+        RecordBatch::try_new(stream_schema.clone(), columns).map_err(DataFusionError::from)
+    });
+    Ok(Box::pin(RecordBatchStreamAdapter::new(
+        output_schema,
+        stream,
+    )))
+}
+
 pub(crate) fn transform_fts_document_stream(
     input: SendableRecordBatchStream,
     resolved: ResolvedFtsField,
diff --git a/rust/lance/src/io/exec/fts.rs b/rust/lance/src/io/exec/fts.rs
index 38f40e9dc44..fe7d7d8b0ae 100644
--- a/rust/lance/src/io/exec/fts.rs
+++ b/rust/lance/src/io/exec/fts.rs
@@ -45,9 +45,10 @@ use super::utils::{
     IndexMetrics, PreFilterMasks, build_prefilter, build_prefilter_restricted_to_fragments,
 };
 use crate::dataset::mem_wal::index::{QueryLocalFtsIndex, QueryLocalFtsStats};
+use crate::index::prefilter::DatasetPreFilter;
 use crate::index::scalar::inverted::{
-    ResolvedFtsField, fts_document_schema, load_segment_details, load_segments,
-    transform_fts_document_stream,
+    ResolvedFtsField, flatten_fts_document_column, fts_document_schema, load_segment_details,
+    load_segments, transform_fts_document_stream,
 };
 use crate::{Dataset, index::DatasetIndexInternalExt};
 use lance_index::metrics::MetricsCollector;
@@ -60,15 +61,17 @@ use lance_index::scalar::inverted::query::{
 };
 use lance_index::scalar::inverted::tokenizer::document_tokenizer::TextTokenizer;
 use lance_index::scalar::inverted::{
-    CombinedFieldColumn, CombinedFieldsBM25Scorer, DOC_INDEX_COL, DocumentGranularity, FTS_SCHEMA,
-    FlatBm25SearchOptions, InvertedIndex, MemBM25Scorer, PreparedBm25Query, SCORE_COL, Scorer,
-    build_combined_bm25_scorer, build_global_bm25_scorer, combined_fields_search, compound_search,
-    compound_search_prepared_match, compound_search_prepared_match_with_score_floor,
-    compound_search_with_base_scorer, cross_column_compound_search, exclusive_scaled_score_floor,
-    flat_bm25_search_stream_with_options_and_scorer, fts_schema, materialized_compound_top_k,
-    prepare_bm25_query, validate_combined_tokenizers,
+    CombinedCorpusStats, CombinedFieldColumn, CombinedFieldsBM25Scorer, DOC_INDEX_COL,
+    DocumentGranularity, FTS_SCHEMA, FlatBm25SearchOptions, InvertedIndex, MemBM25Scorer,
+    PreparedBm25Query, SCORE_COL, Scorer, build_combined_bm25_scorer, build_global_bm25_scorer,
+    combined_fields_search, compound_search, compound_search_prepared_match,
+    compound_search_prepared_match_with_score_floor, compound_search_with_base_scorer,
+    cross_column_compound_search, exclusive_scaled_score_floor,
+    flat_bm25_search_stream_with_options_and_scorer, flat_combined_fields_search_stream,
+    fts_schema, materialized_compound_top_k, prepare_bm25_query, validate_combined_tokenizers,
 };
 use lance_index::{prefilter::PreFilter, scalar::inverted::query::BooleanQuery};
+use lance_select::{RowAddrTreeMap, RowSetOps};
 use lance_tokenizer::{SimpleTokenizer, TextAnalyzer};
 use tracing::instrument;
 use uuid::Uuid;
@@ -3301,13 +3304,26 @@ fn fmt_combined_fields(
     fmt_tokenized_query(tokenized_query, separator, f)
 }
 
-/// What [`open_combined_fields_scan`] hands back to the `combined_fields` exec.
+/// Which target columns of a `combined_fields` scan need an inverted index.
+#[derive(Debug, Clone, Copy)]
+enum CombinedFieldsIndexRequirement {
+    /// Every column, because the indexed side scores each of them from its
+    /// index.
+    EveryColumn,
+    /// At least one column, for the tokenizer. The flat side reads the document
+    /// text from the scan, so a column without an index only misses out on
+    /// contributing corpus statistics.
+    AtLeastOneColumn,
+}
+
+/// What [`open_combined_fields_scan`] hands back to either `combined_fields` exec.
 struct CombinedFieldsScan {
     columns: Vec<CombinedFieldColumn>,
     /// Every segment opened across all target columns, for the indexed side's
     /// prefilter.
     segments: Vec<IndexMetadata>,
     tokens: Tokens,
+    tokenizer: Box<dyn LanceTokenizer>,
 }
 
 /// Open every target column's segments, pair each with its boost, and tokenize
@@ -3321,25 +3337,37 @@ struct CombinedFieldsScan {
 /// Both sides count the opened segments toward parts searched: the flat side needs
 /// them for the tokenizer and the blended corpus statistics, the indexed side for
 /// scoring.
+///
+/// `stale_rows` is empty, or one entry per target column in query column order.
+/// See [`CombinedFieldColumn::stale_rows`].
 async fn open_combined_fields_scan(
     dataset: &Dataset,
     query: &CombinedFieldsQuery,
+    index_requirement: CombinedFieldsIndexRequirement,
+    stale_rows: &[Arc<RowAddrTreeMap>],
     tokenized_query: &OnceLock<TokenizedQuery>,
     metrics: &FtsIndexMetrics,
 ) -> DataFusionResult<CombinedFieldsScan> {
     let mut columns = Vec::with_capacity(query.column_names().len());
     let mut all_segments = Vec::new();
-    for (column, weight) in query.weighted_columns() {
-        let segments = Some(
-            FtsSegmentSelection::AllCommitted
-                .resolve(
-                    dataset,
-                    column,
-                    DocumentGranularity::Row,
-                    &metrics.segment_bind_duration,
-                )
-                .await?,
-        );
+    for (slot, (column, weight)) in query.weighted_columns().enumerate() {
+        let segments = match index_requirement {
+            CombinedFieldsIndexRequirement::EveryColumn => Some(
+                FtsSegmentSelection::AllCommitted
+                    .resolve(
+                        dataset,
+                        column,
+                        DocumentGranularity::Row,
+                        &metrics.segment_bind_duration,
+                    )
+                    .await?,
+            ),
+            CombinedFieldsIndexRequirement::AtLeastOneColumn => {
+                load_segments(dataset, column, DocumentGranularity::Row)
+                    .await?
+                    .map(Arc::from)
+            }
+        };
         let indices = match segments {
             Some(segments) => {
                 let _details = load_segment_details(dataset, column, &segments).await?;
@@ -3354,6 +3382,10 @@ async fn open_combined_fields_scan(
             column: column.to_string(),
             weight,
             indices,
+            stale_rows: stale_rows
+                .get(slot)
+                .filter(|rows| !rows.is_empty())
+                .cloned(),
         });
     }
     validate_combined_tokenizers(&columns)?;
@@ -3369,13 +3401,20 @@ async fn open_combined_fields_scan(
     let first_index = columns
         .iter()
         .find_map(|column| column.indices.first())
-        .ok_or_else(|| {
-            // Not a user error: segment resolution already failed for any column
-            // without an index, and `CombinedFieldsQuery::try_new` rejects an empty
-            // column list, so reaching this means one of those two guarantees broke.
-            DataFusionError::Internal(
+        .ok_or_else(|| match index_requirement {
+            // Not a user error: `EveryColumn` resolution already failed for any
+            // column without an index, and `CombinedFieldsQuery::try_new` rejects
+            // an empty column list, so reaching this means one of those two
+            // guarantees broke.
+            CombinedFieldsIndexRequirement::EveryColumn => DataFusionError::Internal(
                 "combined_fields query reached execution with no target columns".to_string(),
-            )
+            ),
+            CombinedFieldsIndexRequirement::AtLeastOneColumn => {
+                DataFusionError::Execution(format!(
+                    "combined_fields requires an inverted index on at least one of {:?}",
+                    query.column_names().collect::<Vec<_>>()
+                ))
+            }
         })?;
     let mut tokenizer = first_index.tokenizer();
     let tokens = try_collect_query_tokens(query.terms(), &mut tokenizer)?;
@@ -3385,6 +3424,7 @@ async fn open_combined_fields_scan(
         columns,
         segments: all_segments,
         tokens,
+        tokenizer,
     })
 }
 
@@ -3447,7 +3487,18 @@ impl ExecutionPlan for CombinedFieldsQueryExec {
                 segments: all_segments,
                 tokens,
                 ..
-            } = open_combined_fields_scan(&ds, &query, &tokenized_query, metrics.as_ref()).await?;
+            } = open_combined_fields_scan(
+                &ds,
+                &query,
+                CombinedFieldsIndexRequirement::EveryColumn,
+                // Nothing to subtract: this side either scores against index
+                // statistics alone or against the scorer the flat sibling built,
+                // and only that sibling folds a stale row in.
+                &[],
+                &tokenized_query,
+                metrics.as_ref(),
+            )
+            .await?;
 
             // With mixed coverage the planner supplies the fragments every target
             // column indexes, and the scan is restricted to exactly those: the
@@ -3490,15 +3541,22 @@ impl ExecutionPlan for CombinedFieldsQueryExec {
             }
             let scorer = match (preset_base_scorer, shared_scorer) {
                 (Some(scorer), _) => scorer,
-                // An injected scorer describes the corpus the whole plan scores
-                // against; wait for it rather than folding this side's statistics.
+                // A mixed plan routes the rows no index covers to a flat sibling,
+                // so folding only this side's index statistics here would score the
+                // two children against different `docCount'`/`docFreq'`/`avgdl'`.
+                // Wait for the blend that describes the whole scanned corpus.
                 (None, Some(shared_scorer)) => shared_scorer.wait().await?,
                 (None, None) => {
                     let scorer_start = std::time::Instant::now();
                     let scorer = Arc::new(
-                        build_combined_bm25_scorer(&columns, &tokens, Some(metrics.as_ref()))
-                            .boxed()
-                            .await?,
+                        build_combined_bm25_scorer(
+                            &columns,
+                            &tokens,
+                            CombinedCorpusStats::IndexOnly,
+                            Some(metrics.as_ref()),
+                        )
+                        .boxed()
+                        .await?,
                     );
                     metrics.record_scorer_build(scorer_start.elapsed());
                     scorer
@@ -4374,6 +4432,393 @@ impl ExecutionPlan for FlatMatchQueryExec {
     }
 }
 
+/// The rows of one target column that a flat `combined_fields` scan folds into
+/// that column's corpus statistics: the ones its index does not already count.
+///
+/// The scan reads every target column of every row it scores, but a scanned
+/// fragment can still be indexed for some of those columns. Folding such a row
+/// into that column's statistics as well would count it twice, inflating
+/// `docCount_f`, `sumTotalTermFreq_f` and `docFreq_f`.
+#[derive(Debug, Clone, Default)]
+pub struct FlatStatsCoverage {
+    /// Fragments this column's index does not cover at all.
+    pub fragments: roaring::RoaringBitmap,
+    /// Rows it does cover, but whose entries a newer overlay made stale, in the id
+    /// domain the scan's `_rowid` uses. Their current values are folded in, and
+    /// their pre-overlay values are subtracted from the index statistics (see
+    /// [`CombinedFieldColumn::stale_rows`]), so each counts once.
+    pub stale_rows: Arc<RowAddrTreeMap>,
+}
+
+/// Which corpus statistics a flat `combined_fields` scan contributes.
+#[derive(Debug, Clone)]
+pub enum FlatStatsScope {
+    /// Per target column, in query order, the rows to fold on top of that
+    /// column's index statistics.
+    PerColumn(Vec<FlatStatsCoverage>),
+    /// The scan reads every target fragment and its statistics replace the index
+    /// statistics; see [`CombinedCorpusStats::FlatOnly`].
+    WholeCorpus,
+}
+
+/// The sibling of [`CombinedFieldsQueryExec`] for the fragments that at least one
+/// target column's index is missing. Those rows cannot be scored from the indexes
+/// (`tf'`/`dl'` would omit the unindexed columns), so they are scored straight
+/// from their column values here. The two plans are unioned and re-sorted by the
+/// planner, exactly as the single-column match path does.
+///
+/// The input must carry `_rowid` plus every target column of the query.
+#[derive(Debug)]
+pub struct FlatCombinedFieldsExec {
+    dataset: Arc<Dataset>,
+    query: CombinedFieldsQuery,
+    /// Tokens `execute()` actually produced, for `analyze_plan`. Single snapshot
+    /// for the same reason as [`CombinedFieldsQueryExec::tokenized_query`].
+    tokenized_query: Arc<OnceLock<TokenizedQuery>>,
+    params: FtsSearchParams,
+    unindexed_input: Arc<dyn ExecutionPlan>,
+    /// The fragments `unindexed_input` reads.
+    scanned_fragments: roaring::RoaringBitmap,
+    /// Per target column, in query order: how `execute` turns the scanned column
+    /// into document text.
+    resolved_fields: Vec<ResolvedFtsField>,
+    stats_scope: FlatStatsScope,
+    /// See [`Self::with_emit_prefilter`].
+    emit_prefilter: Option<PreFilterSource>,
+    /// Publishes the blended scorer to an indexed sibling; see
+    /// [`Self::with_shared_scorer`].
+    shared_scorer: Option<Arc<SharedFtsScorer<CombinedFieldsBM25Scorer>>>,
+    properties: Arc<PlanProperties>,
+    metrics: ExecutionPlanMetricsSet,
+}
+
+impl DisplayAs for FlatCombinedFieldsExec {
+    fn fmt_as(&self, t: DisplayFormatType, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        fmt_combined_fields(
+            "FlatCombinedFields",
+            &self.query,
+            &self.tokenized_query,
+            t,
+            f,
+        )
+    }
+}
+
+impl FlatCombinedFieldsExec {
+    /// `resolved_fields` and a [`FlatStatsScope::PerColumn`] scope must hold one
+    /// entry per target column, in query order.
+    pub(crate) fn try_new(
+        dataset: Arc<Dataset>,
+        query: CombinedFieldsQuery,
+        params: FtsSearchParams,
+        unindexed_input: Arc<dyn ExecutionPlan>,
+        scanned_fragments: roaring::RoaringBitmap,
+        resolved_fields: Vec<ResolvedFtsField>,
+        stats_scope: FlatStatsScope,
+    ) -> Result<Self> {
+        let num_columns = query.column_names().len();
+        let num_coverage = match &stats_scope {
+            FlatStatsScope::PerColumn(coverage) => coverage.len(),
+            FlatStatsScope::WholeCorpus => num_columns,
+        };
+        if resolved_fields.len() != num_columns || num_coverage != num_columns {
+            return Err(Error::internal(format!(
+                "combined_fields flat scan got {} resolved fields and {} statistics coverage \
+                 sets for {} target columns",
+                resolved_fields.len(),
+                num_coverage,
+                num_columns
+            )));
+        }
+        let properties = Arc::new(PlanProperties::new(
+            EquivalenceProperties::new(FTS_SCHEMA.clone()),
+            Partitioning::RoundRobinBatch(1),
+            EmissionType::Incremental,
+            Boundedness::Bounded,
+        ));
+        Ok(Self {
+            dataset,
+            query,
+            tokenized_query: Arc::new(OnceLock::new()),
+            params,
+            unindexed_input,
+            scanned_fragments,
+            resolved_fields,
+            stats_scope,
+            emit_prefilter: None,
+            shared_scorer: None,
+            properties,
+            metrics: ExecutionPlanMetricsSet::new(),
+        })
+    }
+
+    /// Publish the blended scorer this scan builds to an indexed sibling.
+    ///
+    /// Only this side sees the unindexed rows, so only it can produce the corpus
+    /// statistics both sides must score against.
+    pub(crate) fn with_shared_scorer(
+        mut self,
+        scorer: Arc<SharedFtsScorer<CombinedFieldsBM25Scorer>>,
+    ) -> Self {
+        self.shared_scorer = Some(scorer);
+        self
+    }
+
+    /// Select the emitted rows with `prefilter`, for a scan the planner reads
+    /// unfiltered; see `FlatScanFilter::AtEmission` in the scanner.
+    pub(crate) fn with_emit_prefilter(mut self, prefilter: PreFilterSource) -> Self {
+        self.emit_prefilter = Some(prefilter);
+        self
+    }
+}
+
+impl ExecutionPlan for FlatCombinedFieldsExec {
+    fn name(&self) -> &str {
+        "FlatCombinedFieldsExec"
+    }
+
+    fn children(&self) -> Vec<&Arc<dyn ExecutionPlan>> {
+        let mut children = vec![&self.unindexed_input];
+        children.extend(
+            self.emit_prefilter
+                .as_ref()
+                .and_then(PreFilterSource::execution_plan),
+        );
+        children
+    }
+
+    fn required_input_distribution(&self) -> Vec<Distribution> {
+        // `execute()` reads only `unindexed_input.execute(partition)` for the
+        // single output partition, so the input must be coalesced to one
+        // partition or fragments would be silently dropped. Same reasoning as
+        // `FlatMatchQueryExec`.
+        self.children()
+            .iter()
+            .map(|_| Distribution::SinglePartition)
+            .collect()
+    }
+
+    fn with_new_children(
+        self: Arc<Self>,
+        mut children: Vec<Arc<dyn ExecutionPlan>>,
+    ) -> DataFusionResult<Arc<dyn ExecutionPlan>> {
+        if children.len() != self.children().len() {
+            return Err(DataFusionError::Internal(
+                "Unexpected number of children".to_string(),
+            ));
+        }
+        // Reverse order: the optional prefilter child is last, so pop it first.
+        let emit_prefilter = match &self.emit_prefilter {
+            Some(source) if source.execution_plan().is_some() => Some(
+                source.with_execution_plan(children.pop().expect("child count checked above"))?,
+            ),
+            // A prefilter source with no child of its own leaves the input last.
+            source => source.clone(),
+        };
+        let Some(unindexed_input) = children.pop() else {
+            return Err(DataFusionError::Internal(
+                "combined_fields flat scan lost its input child".to_string(),
+            ));
+        };
+        Ok(Arc::new(Self {
+            dataset: self.dataset.clone(),
+            query: self.query.clone(),
+            tokenized_query: self.tokenized_query.clone(),
+            params: self.params.clone(),
+            unindexed_input,
+            scanned_fragments: self.scanned_fragments.clone(),
+            resolved_fields: self.resolved_fields.clone(),
+            stats_scope: self.stats_scope.clone(),
+            emit_prefilter,
+            shared_scorer: self.shared_scorer.clone(),
+            properties: self.properties.clone(),
+            metrics: ExecutionPlanMetricsSet::new(),
+        }))
+    }
+
+    #[instrument(name = "flat_combined_fields_exec", level = "debug", skip_all)]
+    fn execute(
+        &self,
+        partition: usize,
+        context: Arc<datafusion::execution::TaskContext>,
+    ) -> DataFusionResult<SendableRecordBatchStream> {
+        let query = self.query.clone();
+        let tokenized_query = self.tokenized_query.clone();
+        let ds = self.dataset.clone();
+        let stats_scope = self.stats_scope.clone();
+        let stale_rows_per_column: Vec<Arc<RowAddrTreeMap>> = match &stats_scope {
+            FlatStatsScope::PerColumn(coverage) => coverage
+                .iter()
+                .map(|coverage| coverage.stale_rows.clone())
+                .collect(),
+            FlatStatsScope::WholeCorpus => Vec::new(),
+        };
+        let emit_prefilter = self.emit_prefilter.clone();
+        let scanned_fragments = self.scanned_fragments.clone();
+        let prefilter_context = context.clone();
+        let stats_mask_ds = self.dataset.clone();
+        let metrics_set = self.metrics.clone();
+        let metrics = Arc::new(FtsIndexMetrics::new(&self.metrics, partition));
+        let metrics_clone = metrics.clone();
+        let target_batch_size = context.session_config().batch_size();
+        let elapsed_compute = metrics.baseline_metrics.elapsed_compute().clone();
+
+        let shared_scorer_producer = self.shared_scorer.clone().map(SharedFtsScorerProducer::new);
+
+        let mut input = self.unindexed_input.execute(partition, context)?;
+        for (column, resolved) in query.column_names().zip(&self.resolved_fields) {
+            // A path that continues past a `List` cannot be projected, so the scan
+            // brought its list root instead and the leaf text is derived here.
+            input = if resolved.has_lists() {
+                flatten_fts_document_column(input, resolved.clone())?
+            } else {
+                document_input(input, column)?
+            };
+        }
+
+        let stream = stream::once(async move {
+            let shared_scorer_producer = shared_scorer_producer;
+            let result = async {
+                let CombinedFieldsScan {
+                    columns,
+                    tokens,
+                    tokenizer,
+                    ..
+                } = open_combined_fields_scan(
+                    &ds,
+                    &query,
+                    CombinedFieldsIndexRequirement::AtLeastOneColumn,
+                    &stale_rows_per_column,
+                    &tokenized_query,
+                    metrics.as_ref(),
+                )
+                .await?;
+
+                let input_schema = input.schema();
+                let doc_col_indices = query
+                    .column_names()
+                    .map(|column| input_schema.index_of(column))
+                    .collect::<std::result::Result<Vec<_>, _>>()?;
+
+                // One mask per target column over the rows it may fold. Built through
+                // `create_restricted_deletion_mask` so the fragment restriction lands in
+                // the id space the scan's `_rowid` uses; a hand-rolled fragment-address
+                // allow list would match nothing under stable row ids.
+                let fragment_mask = |fragments: roaring::RoaringBitmap| {
+                    let ds = stats_mask_ds.clone();
+                    async move {
+                        match DatasetPreFilter::create_restricted_deletion_mask(ds, fragments) {
+                            Some(mask) => mask.await,
+                            None => Ok(Arc::new(RowAddrMask::all_rows())),
+                        }
+                    }
+                };
+                let stats_masks = match &stats_scope {
+                    FlatStatsScope::PerColumn(coverage) => {
+                        let mut stats_masks = Vec::with_capacity(coverage.len());
+                        for coverage in coverage {
+                            let mask = fragment_mask(coverage.fragments.clone()).await?;
+                            // Stale rows sit in fragments the index does cover, so they
+                            // are allowed by address rather than by fragment.
+                            stats_masks.push(if coverage.stale_rows.is_empty() {
+                                mask
+                            } else {
+                                Arc::new(
+                                    mask.as_ref()
+                                        .clone()
+                                        .also_allow(coverage.stale_rows.as_ref().clone()),
+                                )
+                            });
+                        }
+                        stats_masks
+                    }
+                    FlatStatsScope::WholeCorpus => {
+                        vec![fragment_mask(scanned_fragments.clone()).await?; columns.len()]
+                    }
+                };
+
+                let emit_mask = match emit_prefilter {
+                    Some(prefilter) => {
+                        let pre_filter = build_prefilter_restricted_to_fragments(
+                            prefilter_context,
+                            partition,
+                            &prefilter,
+                            stats_mask_ds.clone(),
+                            scanned_fragments,
+                            // The external row-address mask is applied by the
+                            // planner's `RowAddrMaskFilterExec` wrap around this
+                            // node, so it stays out of the corpus statistics.
+                            None,
+                            &metrics_set,
+                        )?;
+                        pre_filter.wait_for_ready().await?;
+                        Some(pre_filter.mask())
+                    }
+                    None => None,
+                };
+
+                flat_combined_fields_search_stream(
+                    input,
+                    &columns,
+                    doc_col_indices,
+                    &stats_masks,
+                    emit_mask,
+                    matches!(stats_scope, FlatStatsScope::WholeCorpus),
+                    &tokens,
+                    tokenizer,
+                    query.operator(),
+                    target_batch_size,
+                    Some(elapsed_compute),
+                    Some(metrics.as_ref()),
+                )
+                .await
+            }
+            .await;
+
+            match result {
+                Ok((stream, scorer)) => {
+                    if let Some(producer) = shared_scorer_producer {
+                        producer.publish(scorer);
+                    }
+                    Ok(stream)
+                }
+                Err(error) => {
+                    if let Some(producer) = shared_scorer_producer {
+                        producer.publish_error(&error);
+                    }
+                    Err(error)
+                }
+            }
+        })
+        .try_flatten()
+        .map(move |batch| {
+            let poll = metrics_clone
+                .baseline_metrics
+                .record_poll(std::task::Poll::Ready(Some(batch)));
+            match poll {
+                std::task::Poll::Ready(Some(b)) => b,
+                _ => unreachable!("record_poll preserves Ready(Some) input"),
+            }
+        });
+        Ok(Box::pin(RecordBatchStreamAdapter::new(
+            self.schema(),
+            stream.stream_in_current_span().boxed(),
+        )))
+    }
+
+    fn metrics(&self) -> Option<MetricsSet> {
+        Some(self.metrics.clone_inner())
+    }
+
+    fn properties(&self) -> &Arc<PlanProperties> {
+        &self.properties
+    }
+
+    fn supports_limit_pushdown(&self) -> bool {
+        false
+    }
+}
+
 #[derive(Debug)]
 pub struct PhraseQueryExec {
     dataset: Arc<Dataset>,
@@ -5366,7 +5811,9 @@ mod tests {
     use lance_core::{ROW_ID, utils::address::RowAddress};
     use lance_datafusion::datagen::DatafusionDatagenExt;
     use lance_datafusion::exec::{ExecutionStatsCallback, ExecutionSummaryCounts};
-    use lance_datafusion::utils::{INDEX_CACHE_HITS_METRIC, PARTITIONS_SEARCHED_METRIC};
+    use lance_datafusion::utils::{
+        INDEX_CACHE_HITS_METRIC, INDEX_CACHE_MISSES_METRIC, PARTITIONS_SEARCHED_METRIC,
+    };
     use lance_datagen::{BatchCount, ByteCount, RowCount};
     use lance_index::metrics::NoOpMetricsCollector;
     use lance_index::scalar::inverted::builder::ScoredDoc;
@@ -5376,8 +5823,9 @@ mod tests {
         try_collect_query_tokens,
     };
     use lance_index::scalar::inverted::{
-        CombinedFieldColumn, DocumentGranularity, FTS_SCHEMA, InvertedIndex, Language, SCORE_COL,
-        build_combined_bm25_scorer, build_global_bm25_scorer, prepare_bm25_query,
+        CombinedCorpusStats, CombinedFieldColumn, DocumentGranularity, FTS_SCHEMA, InvertedIndex,
+        Language, SCORE_COL, build_combined_bm25_scorer, build_global_bm25_scorer,
+        prepare_bm25_query,
     };
     use lance_index::scalar::{FullTextSearchQuery, InvertedIndexParams};
     use lance_index::{IndexCriteria, IndexType};
@@ -5395,11 +5843,11 @@ mod tests {
 
     use super::{
         BoolSlot, BoostQueryExec, CombinedFieldsQueryExec, CompoundQueryExec,
-        CrossColumnCompoundQueryExec, FTS_SEGMENT_BIND_DURATION_METRIC, FlatMatchFilterExec,
-        FlatMatchQueryExec, MatchQueryExec, PhraseQueryExec, WAND_TIE_COMPLETION_BUDGET,
-        WandExactnessCertificate, build_boolean_query_children,
-        classify_wand_exactness_certificate, default_text_tokenizer, open_fts_segments,
-        tokenizer_for_match_query,
+        CrossColumnCompoundQueryExec, FTS_SEGMENT_BIND_DURATION_METRIC, FlatCombinedFieldsExec,
+        FlatMatchFilterExec, FlatMatchQueryExec, FlatStatsCoverage, FlatStatsScope, MatchQueryExec,
+        PhraseQueryExec, WAND_TIE_COMPLETION_BUDGET, WandExactnessCertificate,
+        build_boolean_query_children, classify_wand_exactness_certificate, default_text_tokenizer,
+        open_fts_segments, tokenizer_for_match_query,
     };
     use crate::io::exec::utils::IndexMetrics;
     use datafusion::physical_plan::empty::EmptyExec;
@@ -6090,6 +6538,41 @@ mod tests {
         );
     }
 
+    /// A `combined_fields` scan is a leaf FTS node, so `analyze_plan` must show
+    /// its tokens the way it does for `match` and `phrase`. Both children of a
+    /// mixed plan report, or a `Boolean{combined_fields, match}` plan would show
+    /// tokens on the `match` sibling only.
+    #[tokio::test]
+    async fn test_analyze_plan_shows_combined_fields_tokens() {
+        let dataset = create_tokenized_query_fixture(&["title", "body"], true).await;
+        let query = CombinedFieldsQuery::try_new(
+            "FIRST and SECOND".to_string(),
+            vec!["title".to_string(), "body".to_string()],
+        )
+        .unwrap();
+        let mut scanner = dataset.scan();
+        scanner
+            .full_text_search(FullTextSearchQuery::new_query(query.into()))
+            .unwrap();
+
+        let explained = scanner.explain_plan(false).await.unwrap();
+        assert!(
+            !explained.contains("tokenized_query="),
+            "explain_plan should not claim runtime tokenization: {explained}"
+        );
+
+        let analysis = scanner.analyze_plan().await.unwrap();
+        let expected = r#"tokenized_query=[("first", 0), ("second", 2)]"#;
+        assert!(
+            find_plan_line(&analysis, "CombinedFieldsQuery:").contains(expected),
+            "indexed combined_fields is missing token positions:\n{analysis}"
+        );
+        assert!(
+            find_plan_line(&analysis, "FlatCombinedFields:").contains(expected),
+            "flat combined_fields is missing token positions:\n{analysis}"
+        );
+    }
+
     #[tokio::test]
     async fn test_boolean_query_parts_searched_metrics() {
         let mut dataset = lance_datagen::gen_batch()
@@ -6228,6 +6711,7 @@ mod tests {
                 column: column.to_string(),
                 weight,
                 indices,
+                stale_rows: None,
             });
         }
         let mut tokenizer = columns[0].indices[0].tokenizer();
@@ -6246,7 +6730,7 @@ mod tests {
         let expected_lookups = terms.len() * partitions;
         assert!(expected_lookups > 0);
         let scorer = Arc::new(
-            build_combined_bm25_scorer(&columns, &tokens, None)
+            build_combined_bm25_scorer(&columns, &tokens, CombinedCorpusStats::IndexOnly, None)
                 .await
                 .unwrap(),
         );
@@ -6288,6 +6772,44 @@ mod tests {
             expected_lookups,
             "CombinedFieldsQueryExec must report the scorer build's cache lookups",
         );
+
+        // The flat sibling builds its own scorer from the same per-column index
+        // statistics. An empty input isolates those reads: the scanned rows
+        // contribute none, so the count is absolute rather than a delta.
+        let flat_schema = Arc::new(arrow_schema::Schema::new(vec![
+            lance_core::ROW_ID_FIELD.clone(),
+            arrow_schema::Field::new("title", DataType::Utf8, true),
+            arrow_schema::Field::new("body", DataType::Utf8, true),
+        ]));
+        let resolved_fields = query
+            .column_names()
+            .map(|column| {
+                crate::index::scalar::inverted::resolve_fts_field(
+                    dataset.schema(),
+                    column,
+                    DocumentGranularity::Row,
+                )
+                .unwrap()
+            })
+            .collect::<Vec<_>>();
+        let num_columns = resolved_fields.len();
+        let flat = FlatCombinedFieldsExec::try_new(
+            dataset.clone(),
+            query.clone(),
+            params.clone(),
+            Arc::new(EmptyExec::new(flat_schema)),
+            roaring::RoaringBitmap::new(),
+            resolved_fields,
+            FlatStatsScope::PerColumn(vec![FlatStatsCoverage::default(); num_columns]),
+        )
+        .unwrap();
+        assert!(execute_results(&flat).await.unwrap().is_empty());
+        assert_eq!(
+            metric_value(&flat, INDEX_CACHE_HITS_METRIC)
+                + metric_value(&flat, INDEX_CACHE_MISSES_METRIC),
+            expected_lookups,
+            "FlatCombinedFieldsExec must report the scorer build's cache lookups",
+        );
     }
 
     #[tokio::test]
diff --git a/rust/lance/tests/query/inverted.rs b/rust/lance/tests/query/inverted.rs
index dd24eb30fcb..f215aefa071 100644
--- a/rust/lance/tests/query/inverted.rs
+++ b/rust/lance/tests/query/inverted.rs
@@ -1089,7 +1089,9 @@ async fn test_element_document_nested_lists_use_deepest_boundary() {
     assert_eq!(row.fields, vec![content.id]);
     assert_ne!(row.fields, vec![docs.children[0].id]);
 
-    // A cross-field scan resolves the same nested path through the row index.
+    // A cross-field scan resolves the same path through the row index, and its
+    // flat sibling walks two list levels down to the leaf. Rows 2 and 3 repeat
+    // rows 0 and 1 in a fragment no index covers, so both sides contribute.
     let combined_indexed = run_fts(&ds, combined_fields("alpha", &[path]), None).await;
     assert_eq!(
         combined_indexed["id"]
@@ -1113,16 +1115,12 @@ async fn test_element_document_nested_lists_use_deepest_boundary() {
         .await
         .unwrap();
 
-    let mut combined_mixed = ds.scan();
-    combined_mixed
-        .full_text_search(combined_fields("alpha", &[path]))
-        .unwrap();
-    let error = combined_mixed.try_into_batch().await.unwrap_err();
-    assert!(matches!(error, lance_core::Error::InvalidInput { .. }));
-    let message = error.to_string();
-    assert!(
-        message.contains("1 of 2 fragments are not fully covered") && message.contains(path),
-        "{message}"
+    let combined_mixed = run_fts(&ds, combined_fields("alpha", &[path]), None).await;
+    assert_eq!(
+        combined_mixed["id"]
+            .as_primitive::<arrow_array::types::Int32Type>()
+            .values(),
+        &[0, 1, 2, 3]
     );
 
     let mut combined_fast = ds.scan();