chore: development v0.3.44 - comprehensive testing complete [auto-commit]

Author: githubrobbi

Cargo.toml

@@ -36,7 +36,7 @@ exclude = [
 # Workspace Package Metadata (inherited by all crates)
 # ─────────────────────────────────────────────────────────────────────────────
 [workspace.package]
-version = "0.3.43"
+version = "0.3.44"
 edition = "2024"
 rust-version = "1.85"
 license = "MPL-2.0 OR LicenseRef-UFFS-Commercial"

LOG/Output

@@ -36,6 +36,59 @@ pub(super) struct NativeOfflineQueryResults {
     pub(super) query_ms: u128,
 }
 
+/// Index-only load result for the streaming output path.
+pub(super) struct NativeIndexOnly {
+    /// Loaded offline index.
+    pub(super) index: uffs_mft::MftIndex,
+    /// Raw MFT load duration in milliseconds.
+    pub(super) load_ms: u128,
+}
+
+/// Load MFT index without running any query (for streaming output).
+pub(super) fn load_index_from_mft_file(
+    mft_path: &Path,
+    drive_letter: Option<char>,
+    debug_tree: bool,
+    chaos_seed: Option<u64>,
+    reserved_allocated: Option<u64>,
+) -> Result<NativeIndexOnly> {
+    use uffs_mft::LoadRawOptions;
+
+    let volume = drive_letter.unwrap_or('X');
+    info!(volume = %volume, path = %mft_path.display(), "Loading raw MFT file (index only)");
+
+    let t_load = std::time::Instant::now();
+    let is_iocp = uffs_mft::is_iocp_capture(mft_path).unwrap_or(false);
+
+    let index = if let Some(seed) = chaos_seed {
+        use uffs_mft::io::readers::parallel::{ChaosMftReader, ChaosStrategy};
+        let chaos_reader = ChaosMftReader::new(ChaosStrategy::Random { seed }, 2 * 1024 * 1024);
+        chaos_reader
+            .read_with_chaos(mft_path, volume)
+            .with_context(|| format!("Failed to load MFT in chaos mode: {}", mft_path.display()))?
+    } else if is_iocp && !debug_tree {
+        let mut idx = uffs_mft::load_iocp_to_index(mft_path)
+            .with_context(|| format!("Failed to load IOCP capture: {}", mft_path.display()))?;
+        if let Some(ra) = reserved_allocated {
+            if idx.reserved_allocated_bytes == 0 && ra > 0 {
+                idx.reserved_allocated_bytes = ra;
+                idx.compute_tree_metrics();
+            }
+        }
+        idx
+    } else {
+        let options = LoadRawOptions {
+            volume_letter: Some(volume),
+            ..Default::default()
+        };
+        MftReader::load_raw_to_index_with_options(mft_path, &options)
+            .with_context(|| format!("Failed to load raw MFT: {}", mft_path.display()))?
+    };
+    let load_ms = t_load.elapsed().as_millis();
+
+    Ok(NativeIndexOnly { index, load_ms })
+}
+
 /// Query filter options for the search command.
 pub struct QueryFilters<'a> {
     /// Parsed search pattern (glob, regex, or literal).

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

@@ -112,10 +112,6 @@ fn should_use_index_path(
     clippy::print_stderr,
     reason = "intentional user-facing output to stderr"
 )]
-#[expect(
-    clippy::too_many_lines,
-    reason = "top-level search orchestrator remains the command surface entry point"
-)]
 #[expect(
     clippy::single_call_fn,
     reason = "public CLI entry point called from main dispatch"
@@ -209,6 +205,106 @@ pub async fn search(
         && !benchmark
         && can_write_native_results(format, &output_config)
     {
+        // Detect full-scan (no filtering): use streaming direct-write-from-index
+        // to skip SearchResult allocation entirely.
+        let is_full_scan = !filters.files_only
+            && !filters.dirs_only
+            && !filters.hide_system
+            && filters.ext_filter.is_none()
+            && filters.min_size.is_none()
+            && filters.max_size.is_none()
+            && filters.limit == 0
+            && (filters.parsed.pattern() == "*"
+                || filters.parsed.pattern() == "**"
+                || filters.parsed.pattern() == "**/*"
+                || filters.parsed.pattern().is_empty());
+
+        if is_full_scan {
+            info!(
+                path = %mft_path.display(),
+                format,
+                "📂 Loading raw MFT file via STREAMING direct-from-index path (full scan)"
+            );
+
+            // Load index only (skip IndexQuery::collect entirely)
+            let native_index = super::raw_io::load_index_from_mft_file(
+                mft_path,
+                single_drive,
+                debug_tree,
+                chaos_seed,
+                reserved_allocated,
+            )?;
+
+            let t_output = std::time::Instant::now();
+
+            let is_console = matches!(
+                out.to_lowercase().as_str(),
+                "console" | "con" | "term" | "terminal"
+            );
+            // We need the row count for the footer, but we don't know it
+            // until after streaming. Use a placeholder and write footer after.
+            let cpp_pattern = format!(
+                ">{}:{}",
+                native_index.index.volume,
+                pattern.replace('*', ".*")
+            );
+
+            let row_count = if is_console {
+                let stdout_handle = std::io::stdout();
+                let mut stdout = stdout_handle.lock();
+                let footer_ctx = crate::commands::output::CppFooterContext {
+                    output_targets: &output_targets,
+                    pattern: &cpp_pattern,
+                    row_count: 0, // Updated by streaming writer
+                };
+                crate::commands::output::write_index_streaming(
+                    &native_index.index,
+                    &mut stdout,
+                    format,
+                    &output_config,
+                    &footer_ctx,
+                )?
+            } else {
+                use std::io::Write as _;
+                let file = std::fs::File::create(out)
+                    .with_context(|| format!("Failed to create output file: {out}"))?;
+                let mut writer = std::io::BufWriter::with_capacity(256 * 1024, file);
+                let footer_ctx = crate::commands::output::CppFooterContext {
+                    output_targets: &output_targets,
+                    pattern: &cpp_pattern,
+                    row_count: 0,
+                };
+                let count = crate::commands::output::write_index_streaming(
+                    &native_index.index,
+                    &mut writer,
+                    format,
+                    &output_config,
+                    &footer_ctx,
+                )?;
+                writer.flush()?;
+                info!(file = out, "Results written to file");
+                count
+            };
+
+            let output_ms = t_output.elapsed().as_millis();
+
+            if profile {
+                eprintln!("=== RAW MFT FILE TIMING (streaming) ===");
+                eprintln!(
+                    "  Load from file:  {:>6} ms  ({} records)",
+                    native_index.load_ms,
+                    native_index.index.len()
+                );
+                eprintln!("  Query/filter:    skipped (streaming)");
+                eprintln!("  Output/write:    {output_ms:>6} ms  ({row_count} rows)");
+                eprintln!("=== TOTAL: {} ms ===", start_time.elapsed().as_millis());
+            }
+
+            info!(count = row_count, "Search complete (streaming)");
+            return Ok(());
+        }
+
+        // Filtered query: use IndexQuery → SearchResult path
         info!(
             path = %mft_path.display(),
             format,

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

@@ -60,12 +60,13 @@ impl<'a> RecordExpander<'a> {
         };
         let path_index = self.path_cache.index();
         let path_resolver = self.path_cache.resolver();
+        let dir_cache = self.path_cache.dir_cache();
         let cached_path = self.resolve_paths.then(|| {
             debug_assert!(
                 path_resolver.is_valid_idx(record_idx),
                 "collect_results only resolves paths for valid record indices"
             );
-            path_resolver.materialize_path(path_index, record_idx)
+            path_resolver.materialize_path_cached(path_index, record_idx, dir_cache)
         });
 
         let mut results = Vec::with_capacity(usize::from(name_count) * usize::from(stream_count));

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

@@ -247,15 +247,68 @@ impl MftIndex {
         }
     }
 
+    /// Pre-size the `frs_to_idx` lookup table so that all FRS values up to
+    /// `total_records` can be inserted without any resize checks.
+    ///
+    /// Call this once before the parse loop to eliminate the per-call
+    /// `if frs_usize >= self.frs_to_idx.len()` branch in
+    /// `get_or_create_unified`.
+    pub fn pre_size_frs_lookup(&mut self, total_records: usize) {
+        // FRS numbers can be up to total_records (and sometimes slightly
+        // beyond due to extension records referencing higher FRS values).
+        // Over-allocate by 10% to cover most cases without any resize.
+        let capacity = total_records + total_records / 10;
+        if capacity > self.frs_to_idx.len() {
+            self.frs_to_idx.resize(capacity, NO_ENTRY);
+        }
+    }
+
+    /// Ensure a record exists for `frs` and return its index in `records`.
+    ///
+    /// This is the fast-path equivalent of `get_or_create_unified` that
+    /// returns a `u32` index instead of a mutable reference.  Callers can
+    /// then use `self.records[idx]` directly, avoiding redundant lookups.
+    #[inline]
+    #[expect(
+        clippy::cast_possible_truncation,
+        reason = "FRS fits in usize on 64-bit"
+    )]
+    #[expect(
+        clippy::indexing_slicing,
+        reason = "bounds checked: resize ensures frs_usize < len"
+    )]
+    pub fn ensure_record(&mut self, frs: u64) -> u32 {
+        let frs_usize = frs as usize;
+
+        if frs_usize >= self.frs_to_idx.len() {
+            self.frs_to_idx.resize(frs_usize + 1, NO_ENTRY);
+        }
+
+        let idx = self.frs_to_idx[frs_usize];
+        if idx == NO_ENTRY {
+            let new_idx = self.records.len() as u32;
+            self.frs_to_idx[frs_usize] = new_idx;
+            self.records.push(FileRecord::new_unified(frs));
+            new_idx
+        } else {
+            idx
+        }
+    }
+
     /// Find a record by FRS (returns None if not present)
+    #[inline]
     #[must_use]
+    #[expect(
+        clippy::cast_possible_truncation,
+        reason = "FRS and record index fit in usize on 64-bit"
+    )]
     pub fn find(&self, frs: u64) -> Option<&FileRecord> {
-        let frs_usize = usize::try_from(frs).ok()?;
+        let frs_usize = frs as usize;
         let idx = *self.frs_to_idx.get(frs_usize)?;
         if idx == NO_ENTRY {
             None
         } else {
-            self.records.get(usize::try_from(idx).ok()?)
+            self.records.get(idx as usize)
         }
     }
 
@@ -376,14 +429,19 @@ impl MftIndex {
     }
 
     /// Convert FRS to record index (returns None if not present).
+    #[inline]
     #[must_use]
+    #[expect(
+        clippy::cast_possible_truncation,
+        reason = "FRS and record index fit in usize on 64-bit"
+    )]
     pub fn frs_to_idx_opt(&self, frs: u64) -> Option<usize> {
-        let frs_usize = usize::try_from(frs).ok()?;
+        let frs_usize = frs as usize;
         let idx = *self.frs_to_idx.get(frs_usize)?;
         if idx == NO_ENTRY {
             None
         } else {
-            Some(usize::try_from(idx).ok()?)
+            Some(idx as usize)
         }
     }