fix: resolve Windows cross-compilation errors

- Add raw_handle() and as_overlapped_ptr() accessors for IOCP types
- Replace num_cpus with std::thread::available_parallelism()
- Fix visibility for search_multi_drive_filtered (pub(crate))
- Restore execute_index_query function lost in prior refactor
- Add missing imports (MftReader, debug macro)
- Inline parse_buffer_zero_copy_inner to fix private type access
- Remove unused DriveResult import

Author: githubrobbi

crates/uffs-cli/src/commands/raw_io.rs

@@ -728,6 +728,58 @@ pub(super) async fn load_and_filter_data_index_multi(
     Ok(final_result)
 }
 
+/// Execute query against an `MftIndex` and return results as a `DataFrame`.
+///
+/// This function uses the fast `IndexQuery` path for filtering and then
+/// converts the results to a `DataFrame` for downstream processing.
+#[cfg(windows)]
+fn execute_index_query(
+    index: &uffs_mft::MftIndex,
+    filters: &QueryFilters<'_>,
+    resolve_paths: bool,
+) -> Result<uffs_mft::DataFrame> {
+    use uffs_core::{IndexQuery, TypeFilter, compile_parsed_pattern};
+
+    let mut query = IndexQuery::new(index);
+
+    let pattern = compile_parsed_pattern(filters.parsed);
+    query = query.with_pattern_result(pattern);
+
+    if let Some(ext_str) = filters.ext_filter {
+        let parsed_ext_filter = ExtensionFilter::parse(ext_str)
+            .map_err(|err| anyhow::anyhow!("Invalid extension filter: {err}"))?;
+        let exts: Vec<&str> = parsed_ext_filter
+            .extensions()
+            .iter()
+            .map(String::as_str)
+            .collect();
+        query = query.extensions(&exts);
+    }
+
+    if filters.files_only {
+        query = query.with_type_filter(TypeFilter::FilesOnly);
+    } else if filters.dirs_only {
+        query = query.with_type_filter(TypeFilter::DirsOnly);
+    }
+
+    if let Some(min) = filters.min_size {
+        query = query.min_size(min);
+    }
+    if let Some(max) = filters.max_size {
+        query = query.max_size(max);
+    }
+
+    if filters.limit > 0 {
+        query = query.limit(filters.limit as usize);
+    }
+
+    query = query.case_sensitive(filters.parsed.is_case_sensitive());
+    query = query.with_resolve_paths(resolve_paths);
+
+    let results = query.collect();
+    results_to_dataframe(index, results, resolve_paths)
+}
+
 /// Build and execute the MFT query with all filters applied.
 #[tracing::instrument(
     level = "debug",

crates/uffs-cli/src/commands/search/mod.rs

@@ -28,7 +28,7 @@ mod multi_drive;
 mod streaming;
 
 #[cfg(windows)]
-pub(super) use self::multi_drive::search_multi_drive_filtered;
+pub(crate) use self::multi_drive::search_multi_drive_filtered;
 #[cfg(windows)]
 use self::streaming::search_streaming;
 

crates/uffs-cli/src/commands/search/multi_drive.rs

@@ -9,7 +9,7 @@ use tokio::task::JoinSet;
 use tracing::info;
 use uffs_mft::IntoLazy;
 
-use super::drive_search::{DriveResult, reorder_drive_column, search_single_drive};
+use super::drive_search::{reorder_drive_column, search_single_drive};
 use crate::commands::raw_io::{OwnedQueryFilters, QueryFilters};
 use crate::commands::{add_drive_progress, create_multi_progress};
 
@@ -29,7 +29,7 @@ use crate::commands::{add_drive_progress, create_multi_progress};
 ///
 /// * `no_bitmap` - If true, disables MFT bitmap optimization (reads all
 ///   records).
-pub(super) async fn search_multi_drive_filtered(
+pub(crate) async fn search_multi_drive_filtered(
     drives: &[char],
     filters: &QueryFilters<'_>,
     needs_paths: bool,

crates/uffs-mft/src/commands/windows/bench.rs

@@ -388,7 +388,7 @@ pub async fn cmd_bench_all(
         hostname: hostname::get()
             .map(|h| h.to_string_lossy().to_string())
             .unwrap_or_else(|_| "unknown".to_string()),
-        cpu_count: num_cpus::get(),
+        cpu_count: std::thread::available_parallelism().map_or(1, |p| p.get()),
         uffs_version: env!("CARGO_PKG_VERSION").to_string(),
         drives: results,
         total_benchmark_time_ms: total_time_ms,

crates/uffs-mft/src/commands/windows/benchmark_mft.rs

@@ -33,6 +33,10 @@ use crate::display::char_or_dot;
     clippy::fn_params_excessive_bools,
     reason = "bool params map directly to cli flags"
 )]
+#[expect(
+    unsafe_code,
+    reason = "FFI: SetFilePointerEx, ReadFile for raw volume I/O"
+)]
 pub async fn cmd_benchmark_mft(drive: char) -> Result<()> {
     use std::time::Instant;
 

crates/uffs-mft/src/commands/windows/info.rs

@@ -4,6 +4,7 @@ use anyhow::{Context, Result};
 use tracing::info;
 
 use super::shared::drive_type_label;
+use uffs_mft::MftReader;
 use crate::display::{format_bytes, format_duration, format_number_commas, truncate_string};
 
 #[cfg(windows)]

crates/uffs-mft/src/io/readers/iocp/reader.rs

@@ -237,9 +237,9 @@ impl IocpMftReader {
 
             // Find which slot completed by matching the overlapped pointer
             let mut completed_slot: Option<usize> = None;
-            for (idx, slot) in in_flight.iter().enumerate() {
+            for (idx, slot) in in_flight.iter_mut().enumerate() {
                 if let Some(op) = slot {
-                    let op_ptr = &op.overlapped as *const _ as *mut _;
+                    let op_ptr = op.as_overlapped_ptr();
                     if op_ptr == overlapped_ptr {
                         completed_slot = Some(idx);
                         break;

crates/uffs-mft/src/io/readers/parallel/bulk_iocp.rs

@@ -210,7 +210,7 @@ impl ParallelMftReader {
         // all synchronization is provided by the kernel-managed completion port.
         unsafe impl Sync for SendHandle {}
 
-        let iocp_handle_raw = SendHandle(iocp.handle.0 as isize);
+        let iocp_handle_raw = SendHandle(iocp.raw_handle().0 as isize);
 
         // Spawn worker threads
         let mut workers = Vec::with_capacity(num_workers);

crates/uffs-mft/src/io/readers/parallel/sliding_window.rs

@@ -248,11 +248,11 @@ impl ParallelMftReader {
             let mut overlapped_ptr: *mut windows::Win32::System::IO::OVERLAPPED =
                 std::ptr::null_mut();
 
-            // SAFETY: `iocp.handle` is a live completion port and all out-pointers
+            // SAFETY: `iocp.raw_handle()` is a live completion port and all out-pointers
             // reference writable stack storage for the duration of the wait.
             let result = unsafe {
                 GetQueuedCompletionStatus(
-                    iocp.handle,
+                    iocp.raw_handle(),
                     &mut bytes_transferred,
                     &mut completion_key,
                     &mut overlapped_ptr,

crates/uffs-mft/src/io/readers/parallel/to_index.rs

@@ -271,11 +271,11 @@ impl ParallelMftReader {
             let mut overlapped_ptr: *mut windows::Win32::System::IO::OVERLAPPED =
                 std::ptr::null_mut();
 
-            // SAFETY: `iocp.handle` is a live completion port and all out-pointers
+            // SAFETY: `iocp.raw_handle()` is a live completion port and all out-pointers
             // reference writable stack storage for the duration of the wait.
             let result = unsafe {
                 GetQueuedCompletionStatus(
-                    iocp.handle,
+                    iocp.raw_handle(),
                     &mut bytes_transferred,
                     &mut completion_key,
                     &mut overlapped_ptr,