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

Author: githubrobbi

.intent/config.json

@@ -0,0 +1,22 @@
+{
+  "scripts": [
+    {
+      "name": "build",
+      "command": "cargo build",
+      "mode": "command",
+      "category": "build"
+    },
+    {
+      "name": "test",
+      "command": "cargo test",
+      "mode": "command",
+      "category": "test"
+    },
+    {
+      "name": "check",
+      "command": "cargo check",
+      "mode": "command",
+      "category": "typecheck"
+    }
+  ]
+}

Cargo.toml

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

LOG/Output

@@ -88,6 +88,27 @@ impl MftIndex {
             );
         }
 
+        // C++ parity: fix total_stream_count for non-directory records that
+        // have NO unnamed $DATA attribute but DO have other streams.  In C++,
+        // the first non-$STD_INFO/non-$FILE_NAME attribute becomes first_stream
+        // directly — there is no phantom empty default.  Rust always counts 1
+        // for the default slot.  The `has_default_data()` bit (set during
+        // parsing in both base and extension handlers) lets us distinguish
+        // "has empty $DATA" (keep the 1) from "has no $DATA" (subtract 1).
+        {
+            let no_entry = super::NO_ENTRY;
+            for rec in &mut self.records {
+                if !rec.stdinfo.is_directory()
+                    && !rec.has_default_data()
+                    && rec.total_stream_count > 1
+                    && (rec.first_stream.next_entry != no_entry
+                        || rec.first_internal_stream != no_entry)
+                {
+                    rec.total_stream_count -= 1;
+                }
+            }
+        }
+
         // First pass: compute tree metrics
         crate::tree_metrics::compute_tree_metrics(self, debug, skip_orphans);
         tracing::debug!("[TRIP] MftIndex::compute_tree_metrics_impl -> first pass done");

crates/uffs-mft/src/index/tree.rs

@@ -632,7 +632,7 @@ pub struct FileRecord {
     /// Primary filename namespace (0=POSIX, 1=Win32, 2=DOS, 3=Win32+DOS)
     pub namespace: u8,
     /// Forensic flags (bit-packed): bit 0 = `is_deleted`, bit 1 = `is_corrupt`,
-    /// bit 2 = `is_extension`
+    /// bit 2 = `is_extension`, bit 3 = `has_default_data` (unnamed $DATA found)
     pub forensic_flags: u8,
     /// Log File Sequence Number - correlates with `$LogFile` journal (forensic)
     pub lsn: u64,
@@ -780,11 +780,28 @@ impl FileRecord {
     /// Sets the forensic flags from parsed record fields.
     #[inline]
     pub fn set_forensic_flags(&mut self, is_deleted: bool, is_corrupt: bool, is_extension: bool) {
-        self.forensic_flags = u8::from(is_deleted)
+        // Preserve bit 3 (has_default_data) when setting forensic bits
+        self.forensic_flags = (self.forensic_flags & 0b1000)
+            | u8::from(is_deleted)
             | (u8::from(is_corrupt) << 1_u8)
             | (u8::from(is_extension) << 2_u8);
     }
 
+    /// Returns true if an unnamed `$DATA` attribute was found during parsing.
+    /// Used by tree metrics to distinguish "has empty $DATA" from "has no
+    /// $DATA".
+    #[inline]
+    #[must_use]
+    pub const fn has_default_data(&self) -> bool {
+        self.forensic_flags & 0b1000 != 0
+    }
+
+    /// Marks that an unnamed `$DATA` attribute was found during parsing.
+    #[inline]
+    pub const fn set_has_default_data(&mut self) {
+        self.forensic_flags |= 0b1000;
+    }
+
     /// Returns the tree metrics tuple (descendants, treesize,
     /// `tree_allocated`).
     ///

crates/uffs-mft/src/index/types.rs

@@ -39,7 +39,7 @@ pub use parser::parse_record_to_fragment;
 pub use parser::{
     ExtensionAttributes, ParseResult, ParsedColumns, ParsedRecord,
     add_missing_parent_placeholders_to_vec, create_placeholder_record, parse_record,
-    parse_record_full, parse_record_to_index, parse_record_zero_alloc,
+    parse_record_full, parse_record_to_index, parse_record_zero_alloc, process_record,
 };
 // Export Windows-specific readers (require HANDLE)
 #[cfg(windows)]

crates/uffs-mft/src/io.rs

@@ -15,7 +15,6 @@ use zerocopy::FromBytes;
     reason = "internal use in deprecated parse_record_to_fragment"
 )]
 use super::fragment_extension::parse_extension_to_fragment;
-use crate::ntfs::is_internal_windows_stream;
 
 /// Parses a record directly into an `MftIndexFragment` (for parallel parsing).
 ///
@@ -259,10 +258,10 @@ pub fn parse_record_to_fragment(
                             .map(|c| u16::from_le_bytes([c[0], c[1]]))
                             .collect();
                         let stream_name = String::from_utf16_lossy(&name_u16);
-                        // Filter out internal Windows streams (names starting with $)
-                        if !is_internal_windows_stream(&stream_name) {
-                            additional_streams.push((stream_name, size, allocated));
-                        }
+                        // C++ parity: ALL named $DATA streams create regular
+                        // stream entries.  Internal ones are filtered from
+                        // output by is_internal_windows_stream in the output layer.
+                        additional_streams.push((stream_name, size, allocated));
                     }
                 }
             }
@@ -546,7 +545,7 @@ pub fn parse_record_to_fragment(
     // Helper to add a child entry to a parent in the fragment
     let add_child_entry =
         |fragment: &mut crate::index::MftIndexFragment, p_frs: u64, name_idx: u16| {
-            if p_frs == frs || p_frs == 0 || p_frs == u64::from(NO_ENTRY) {
+            if p_frs == frs || p_frs == u64::from(NO_ENTRY) {
                 return;
             }
             // Ensure parent exists in fragment

crates/uffs-mft/src/io/parser/fragment.rs

@@ -10,8 +10,6 @@ use core::mem::size_of;
 use smallvec::SmallVec;
 use zerocopy::FromBytes;
 
-use crate::ntfs::is_internal_windows_stream;
-
 /// Parses an extension record and adds its names/streams to the base record in
 /// a fragment.
 ///
@@ -169,10 +167,10 @@ pub(super) fn parse_extension_to_fragment(
                             .map(|c| u16::from_le_bytes([c[0], c[1]]))
                             .collect();
                         let stream_name = String::from_utf16_lossy(&name_u16);
-                        // Filter out internal Windows streams (names starting with $)
-                        if !is_internal_windows_stream(&stream_name) {
-                            streams.push((stream_name, size, allocated));
-                        }
+                        // C++ parity: ALL named $DATA streams create regular
+                        // stream entries.  Internal ones are filtered from
+                        // output by is_internal_windows_stream in the output layer.
+                        streams.push((stream_name, size, allocated));
                     }
                 }
             }
@@ -340,7 +338,7 @@ pub(super) fn parse_extension_to_fragment(
 
     for (name_idx, (_, parent_frs)) in names.iter().enumerate() {
         let p_frs = *parent_frs;
-        if p_frs == base_frs || p_frs == 0 || p_frs == u64::from(NO_ENTRY) {
+        if p_frs == base_frs || p_frs == u64::from(NO_ENTRY) {
             continue;
         }
 

crates/uffs-mft/src/io/parser/fragment_extension.rs

@@ -37,7 +37,6 @@ use smallvec::SmallVec;
 use zerocopy::FromBytes;
 
 use super::index_extension::parse_extension_to_index;
-use crate::ntfs::is_internal_windows_stream;
 use crate::parse::index_helpers::{
     ExtensionSnapshot, InternalStreamChain, add_child_entry, add_link_to_index,
     add_stream_to_index, build_internal_stream_chain, chain_links, chain_streams,
@@ -338,7 +337,10 @@ pub fn parse_record_to_index(data: &[u8], frs: u64, index: &mut crate::index::Mf
                 };
 
                 if name_len == 0 {
-                    // Default stream
+                    // Default stream — mark that unnamed $DATA exists
+                    // (C++ parity: distinguishes "empty $DATA" from "no $DATA")
+                    let rec = index.get_or_create(frs);
+                    rec.set_has_default_data();
                     default_size = size;
                     default_allocated = allocated;
                 } else {
@@ -351,11 +353,37 @@ pub fn parse_record_to_index(data: &[u8], frs: u64, index: &mut crate::index::Mf
                             .map(|c| u16::from_le_bytes([c[0], c[1]]))
                             .collect();
                         let stream_name = String::from_utf16_lossy(&name_u16);
-                        // Filter out internal Windows streams (names starting with $)
-                        // These include $DSC, $REPARSE, $EA, $EA_INFORMATION, $TXF_DATA, $OBJECT_ID
-                        if !is_internal_windows_stream(&stream_name) {
-                            additional_streams.push((stream_name, size, allocated));
-                        }
+
+                        // C++ parity: $BadClus:$Bad (FRS 8) uses InitializedSize
+                        // instead of DataSize/AllocatedSize to avoid counting the
+                        // entire volume size (ntfs_index_load.hpp lines 431-452).
+                        let (size, allocated) = if frs == 8
+                            && attr_header.name_length == 4
+                            && stream_name == "$Bad"
+                            && attr_header.is_non_resident != 0
+                        {
+                            let init_size_offset = offset + 56;
+                            if init_size_offset + 8 <= data.len() {
+                                let init_size = u64::from_le_bytes(
+                                    data[init_size_offset..init_size_offset + 8]
+                                        .try_into()
+                                        .unwrap_or([0; 8]),
+                                );
+                                (init_size, init_size)
+                            } else {
+                                (0, 0)
+                            }
+                        } else {
+                            (size, allocated)
+                        };
+
+                        // C++ parity: ALL named $DATA streams create regular
+                        // stream entries (counted in stream_count).  Internal
+                        // ones (names starting with $) are filtered from
+                        // *output* by is_internal_windows_stream checks in the
+                        // output layer, but must be counted here to match C++
+                        // stream_count semantics for descendants.
+                        additional_streams.push((stream_name, size, allocated));
                     }
                 }
             }
@@ -656,16 +684,8 @@ pub fn parse_record_to_index(data: &[u8], frs: u64, index: &mut crate::index::Mf
 
             record.stdinfo = std_info;
             record.first_stream.size = SizeInfo {
-                length: if default_size == 0 && ext.first_stream_len > 0 {
-                    ext.first_stream_len
-                } else {
-                    default_size
-                },
-                allocated: if default_allocated == 0 && ext.first_stream_alloc > 0 {
-                    ext.first_stream_alloc
-                } else {
-                    default_allocated
-                },
+                length: default_size.saturating_add(ext.first_stream_len),
+                allocated: default_allocated.saturating_add(ext.first_stream_alloc),
             };
             record.first_stream.flags = if record.stdinfo.is_directory() {
                 0
@@ -764,16 +784,8 @@ pub fn parse_record_to_index(data: &[u8], frs: u64, index: &mut crate::index::Mf
 
     record.stdinfo = std_info;
     record.first_stream.size = SizeInfo {
-        length: if default_size == 0 && ext.first_stream_len > 0 {
-            ext.first_stream_len
-        } else {
-            default_size
-        },
-        allocated: if default_allocated == 0 && ext.first_stream_alloc > 0 {
-            ext.first_stream_alloc
-        } else {
-            default_allocated
-        },
+        length: default_size.saturating_add(ext.first_stream_len),
+        allocated: default_allocated.saturating_add(ext.first_stream_alloc),
     };
     record.first_stream.flags = if record.stdinfo.is_directory() {
         0

crates/uffs-mft/src/io/parser/index.rs

@@ -17,8 +17,6 @@ use core::mem::size_of;
 use smallvec::SmallVec;
 use zerocopy::FromBytes;
 
-use crate::ntfs::is_internal_windows_stream;
-
 /// Parses an extension record and adds its names/streams to the base record.
 ///
 /// Extension records contain additional `$FILE_NAME` attributes (hard links)
@@ -227,6 +225,17 @@ pub(super) fn parse_extension_to_index(
 
                 if name_len == 0 {
                     // Default $DATA stream — update base record size
+                    // Mark that unnamed $DATA exists on the base record
+                    // (C++ parity: distinguishes "empty $DATA" from "no $DATA")
+                    {
+                        let bf = base_frs as usize;
+                        if bf < index.frs_to_idx.len() {
+                            let base_idx = index.frs_to_idx[bf];
+                            if base_idx != NO_ENTRY {
+                                index.records[base_idx as usize].set_has_default_data();
+                            }
+                        }
+                    }
                     default_data_size = size;
                     default_data_allocated = allocated;
                     found_default_data = true;
@@ -240,10 +249,10 @@ pub(super) fn parse_extension_to_index(
                             .map(|c| u16::from_le_bytes([c[0], c[1]]))
                             .collect();
                         let stream_name = String::from_utf16_lossy(&name_u16);
-                        // Filter out internal Windows streams (names starting with $)
-                        if !is_internal_windows_stream(&stream_name) {
-                            streams.push((stream_name, size, allocated));
-                        }
+                        // C++ parity: ALL named $DATA streams create regular
+                        // stream entries.  Internal ones are filtered from
+                        // output by is_internal_windows_stream in the output layer.
+                        streams.push((stream_name, size, allocated));
                     }
                 }
             }
@@ -704,6 +713,9 @@ pub(super) fn parse_extension_to_index(
         // record (e.g., large files with extensive run lists).
         if found_default_data {
             let record = &mut index.records[record_idx as usize];
+            // Ensure has_default_data bit is set (may not have been set
+            // earlier if the base record didn't exist at attribute-parse time)
+            record.set_has_default_data();
 
             // If base record has no $DATA (both fields are 0), use extension's $DATA.
             // Otherwise, accumulate extension $DATA to base $DATA.
@@ -742,7 +754,7 @@ pub(super) fn parse_extension_to_index(
 
         for (name_idx, (_, parent_frs)) in names.iter().enumerate() {
             let p_frs = *parent_frs;
-            if p_frs == base_frs || p_frs == 0 || p_frs == u64::from(NO_ENTRY) {
+            if p_frs == base_frs || p_frs == u64::from(NO_ENTRY) {
                 continue;
             }
 
@@ -765,12 +777,21 @@ pub(super) fn parse_extension_to_index(
             // name_index is the position in the combined name list (existing + new)
             // For extension records, the first name might replace first_name (if empty),
             // so we need to account for that
+            //
+            // FIX: The off-by-one bug was here. Extension names are appended AFTER
+            // existing names, so the index should be existing_name_count + name_idx,
+            // not existing_name_count - 1 + name_idx.
+            //
+            // Example: base has 1 name (index 0), extension adds 1 name
+            //   - existing_name_count = 1
+            //   - name_idx = 0 (first extension name)
+            //   - effective_name_idx should be 1 (the second name overall)
             let effective_name_idx = if existing_name_count == 0 {
                 // First extension name became first_name, so name_index starts at 0
                 name_idx as u16
             } else {
                 // Extension names are appended after existing names
-                existing_name_count - 1 + name_idx as u16
+                existing_name_count + name_idx as u16
             };
 
             let child_idx = index.children.len() as u32;