Fix Rust parity: CompleteIndex, DriveDiscovery using, NtfsDrive.DevicePath, UsnWatcher.RunShared

FastSeekWpf/App.xaml.cs

@@ -115,9 +115,12 @@ public partial class App : Application
         PrintHeader("FastSeek CLI");
         Console.WriteLine();
 
+        // ── Elevation check ──
         bool elevated = Elevation.IsElevated();
         if (elevated)
+        {
             PrintLine(ConsoleColor.Green, "Elevation", "Administrator ✓");
+        }
         else
         {
             PrintLine(ConsoleColor.Red, "Elevation", $"{Elevation.StatusText()} ✗");
@@ -128,6 +131,7 @@ public partial class App : Application
             Console.WriteLine();
         }
 
+        // 1. Drives
         var drives = DriveDiscovery.GetNtfsDrives();
         PrintLine(ConsoleColor.Cyan, "Drives", $"{drives.Count} NTFS found");
         foreach (var d in drives) PrintDetail($"  {d.Letter}: {d.Root}");
@@ -143,8 +147,11 @@ public partial class App : Application
         }
 
         if (!elevated)
+        {
             PrintInfo("Attempting scan anyway (will likely fail without elevation)...");
+        }
 
+        // 2. Scan
         PrintLine(ConsoleColor.Cyan, "Scan", "Reading MFT...");
         var index = new IndexStore();
         long totalRecords = 0;
@@ -176,12 +183,13 @@ public partial class App : Application
             }
         }
 
-        index.Finalize();
+        index.CompleteIndex();
         sw.Stop();
 
         PrintLine(ConsoleColor.White, "Index", $"{index.Count:N0} entries  |  {sw.ElapsedMilliseconds}ms  |  {totalRecords / Math.Max(sw.ElapsedMilliseconds, 1):N0} rec/ms");
         Console.WriteLine();
 
+        // 3. Cache
         if (index.Count > 0)
         {
             var cacheSw = Stopwatch.StartNew();
@@ -192,22 +200,25 @@ public partial class App : Application
             PrintLine(ConsoleColor.Cyan, "Cache", $"saved {FormatBytes(cacheSize)} in {cacheSw.ElapsedMilliseconds}ms");
         }
         else
+        {
             PrintLine(ConsoleColor.DarkGray, "Cache", "skipped (empty index)");
+        }
         Console.WriteLine();
 
+        // 4. Benchmark
         if (index.Count > 0)
         {
             PrintLine(ConsoleColor.Cyan, "Benchmark", "1,000 random queries...");
             var benchSw = Stopwatch.StartNew();
             var rnd = new Random(42);
+            var names = index.NameCache;
             var exclusions = CacheManager.LoadExclusions();
             long benchResults = 0;
 
             for (int i = 0; i < 1000; i++)
             {
-                if (index.Entries.Count == 0) break;
-                var entry = index.Entries[rnd.Next(index.Entries.Count)];
-                var name = index.Name(entry);
+                if (names.Count == 0) break;
+                var name = names[rnd.Next(names.Count)];
                 if (name.Length < 2) continue;
                 int start = rnd.Next(name.Length - 1);
                 int len = rnd.Next(1, Math.Min(name.Length - start, 6));
@@ -221,7 +232,9 @@ public partial class App : Application
             PrintLine(ConsoleColor.White, "Result", $"{benchSw.ElapsedMilliseconds}ms total  |  {qps:N0} qps  |  {benchResults / 1000.0:F1} avg results");
         }
         else
+        {
             PrintLine(ConsoleColor.DarkGray, "Benchmark", "skipped (empty index)");
+        }
         Console.WriteLine();
         PrintDivider();
         Console.WriteLine();
@@ -248,6 +261,7 @@ public partial class App : Application
             Console.WriteLine();
         }
 
+        // 5. Interactive search
         if (index.Count > 0)
         {
             PrintHeader("Interactive Search (type 'exit' to quit)");

FastSeekWpf/Core/CacheManager.cs

@@ -48,7 +48,14 @@ public static class CacheManager
             byte[] compressed = File.ReadAllBytes(CachePath);
             byte[] bytes = LZ4Pickler.Unpickle(compressed);
             string json = Encoding.UTF8.GetString(bytes);
-            return JsonSerializer.Deserialize<CacheData>(json, JsonOptions);
+            var cache = JsonSerializer.Deserialize<CacheData>(json, JsonOptions);
+            // Back-compat: single DriveRoot → DriveRoots list
+            if (cache != null && cache.DriveRoots == null || cache!.DriveRoots.Count == 0)
+            {
+                // This is the old format — can't use it, need full rescan
+                return null;
+            }
+            return cache;
         }
         catch
         {

FastSeekWpf/Core/IndexStore.cs

@@ -12,17 +12,17 @@ public class CachedEntry
     public ulong ParentRef { get; set; }
     public string Name { get; set; } = string.Empty;
     public FileKind Kind { get; set; }
+    public byte DriveIdx { get; set; }
 }
 
 [Serializable]
 public class CacheData
 {
     public List<CachedEntry> Entries { get; set; } = new();
-    public string DriveRoot { get; set; } = string.Empty;
+    public List<string> DriveRoots { get; set; } = new();
     public List<JournalCheckpoint> Checkpoints { get; set; } = new();
 }
 
-// Compact in-memory entry — matches Rust IndexEntry exactly
 public struct IndexEntry
 {
     public ulong FileRef;
@@ -32,35 +32,29 @@ public struct IndexEntry
     public ushort NameLen;
     public ushort NameLowerLen;
     public byte Flags; // bit 0 = is_dir
+    public byte DriveIdx; // index into IndexStore.DriveRoots
 
     public readonly bool IsDir => (Flags & 1) != 0;
     public readonly FileKind Kind => IsDir ? FileKind.Directory : FileKind.File;
 }
 
-// Main index store — matches Rust IndexStore exactly (single drive_root)
 public class IndexStore
 {
     public List<IndexEntry> Entries = new();
-    public List<byte> NameArena = new();        // UTF-8 name bytes
-    public List<byte> NameLowerArena = new();   // UTF-8 lowercase name bytes
-    public List<(ulong fileRef, int idx)> RefLookup = new(); // sorted by file_ref
-    public string DriveRoot = string.Empty;
+    public List<byte> NameArena = new();
+    public List<byte> NameLowerArena = new();
+    public List<string> NameCache = new();
+    public List<string> NameLowerCache = new();
+    public List<(ulong fileRef, int idx)> RefLookup = new();
+    public List<string> DriveRoots = new();
     public List<JournalCheckpoint> Checkpoints = new();
 
     public int Count => Entries.Count;
 
-    // Arena accessors — matches Rust name() and name_lower()
-    public string Name(IndexEntry e)
-    {
-        return Encoding.UTF8.GetString(NameArena.ToArray(), (int)e.NameOff, e.NameLen);
-    }
-
-    public string NameLower(IndexEntry e)
-    {
-        return Encoding.UTF8.GetString(NameLowerArena.ToArray(), (int)e.NameLowerOff, e.NameLowerLen);
-    }
+    public string NameAt(int i) => NameCache[i];
+    public string NameLowerAt(int i) => NameLowerCache[i];
+    public string DriveRootAt(int i) => DriveRoots[Entries[i].DriveIdx];
 
-    // Ref lookup (binary search) — matches Rust lookup_idx()
     public uint? LookupIdx(ulong fileRef)
     {
         int lo = 0, hi = RefLookup.Count - 1;
@@ -84,14 +78,26 @@ public class IndexStore
         RefLookup.Sort((a, b) => a.fileRef.CompareTo(b.fileRef));
     }
 
-    // Populate from MFT scan — matches Rust populate_from_scan()
     public void PopulateFromScan(ScanResult scan, string driveRoot)
     {
-        this.DriveRoot = driveRoot;
+        byte driveIdx = 0;
+        int existing = DriveRoots.IndexOf(driveRoot);
+        if (existing >= 0)
+        {
+            driveIdx = (byte)existing;
+        }
+        else
+        {
+            driveIdx = (byte)DriveRoots.Count;
+            DriveRoots.Add(driveRoot);
+        }
+
         int count = scan.Records.Count;
-        Entries.Capacity = count;
-        NameArena.Capacity = count * 30;
-        NameLowerArena.Capacity = count * 30;
+        Entries.Capacity = Math.Max(Entries.Capacity, Entries.Count + count);
+        NameArena.Capacity = Math.Max(NameArena.Capacity, NameArena.Count + count * 30);
+        NameLowerArena.Capacity = Math.Max(NameLowerArena.Capacity, NameLowerArena.Count + count * 30);
+        NameCache.Capacity = Math.Max(NameCache.Capacity, NameCache.Count + count);
+        NameLowerCache.Capacity = Math.Max(NameLowerCache.Capacity, NameLowerCache.Count + count);
 
         foreach (var r in scan.Records)
         {
@@ -103,13 +109,16 @@ public class IndexStore
             string name = new string(nameChars);
             string nameLower = name.ToLowerInvariant();
 
+            byte[] nameBytes = Encoding.UTF8.GetBytes(name);
+            byte[] lowerBytes = Encoding.UTF8.GetBytes(nameLower);
+
             uint nOff = (uint)NameArena.Count;
-            ushort nLen = (ushort)name.Length;
-            NameArena.AddRange(Encoding.UTF8.GetBytes(name));
+            ushort nLen = (ushort)nameBytes.Length;
+            NameArena.AddRange(nameBytes);
 
             uint nlOff = (uint)NameLowerArena.Count;
-            ushort nlLen = (ushort)nameLower.Length;
-            NameLowerArena.AddRange(Encoding.UTF8.GetBytes(nameLower));
+            ushort nlLen = (ushort)lowerBytes.Length;
+            NameLowerArena.AddRange(lowerBytes);
 
             Entries.Add(new IndexEntry
             {
@@ -119,77 +128,90 @@ public class IndexStore
                 NameLowerOff = nlOff,
                 NameLen = nLen,
                 NameLowerLen = nlLen,
-                Flags = r.IsDir ? (byte)1 : (byte)0
+                Flags = r.IsDir ? (byte)1 : (byte)0,
+                DriveIdx = driveIdx
             });
+
+            NameCache.Add(name);
+            NameLowerCache.Add(nameLower);
         }
     }
 
-    // Sort entries by lowercase name and rebuild lookup — matches Rust finalize()
-    public void Finalize()
+    /// <summary>
+    /// Sort entries by lowercase name and rebuild lookup tables.
+    /// Matches Rust IndexStore::finalize().
+    /// </summary>
+    public void CompleteIndex()
     {
-        // Rust uses sort_unstable_by with store_ptr for name_lower comparison.
-        // We use a stable sort with proper key extraction.
         var indices = Enumerable.Range(0, Entries.Count).ToArray();
-        Array.Sort(indices, (a, b) =>
-        {
-            var ea = Entries[a];
-            var eb = Entries[b];
-            return string.CompareOrdinal(
-                Encoding.UTF8.GetString(NameLowerArena.ToArray(), (int)ea.NameLowerOff, ea.NameLowerLen),
-                Encoding.UTF8.GetString(NameLowerArena.ToArray(), (int)eb.NameLowerOff, eb.NameLowerLen));
-        });
+        Array.Sort(indices, (a, b) => string.CompareOrdinal(NameLowerCache[a], NameLowerCache[b]));
+
+        var sortedEntries = new List<IndexEntry>(Entries.Count);
+        var sortedNames = new List<string>(Entries.Count);
+        var sortedLower = new List<string>(Entries.Count);
 
-        var sorted = new List<IndexEntry>(Entries.Count);
         foreach (var i in indices)
-            sorted.Add(Entries[i]);
-        Entries = sorted;
+        {
+            sortedEntries.Add(Entries[i]);
+            sortedNames.Add(NameCache[i]);
+            sortedLower.Add(NameLowerCache[i]);
+        }
 
+        Entries = sortedEntries;
+        NameCache = sortedNames;
+        NameLowerCache = sortedLower;
         RebuildRefLookup();
+
         NameArena.TrimExcess();
         NameLowerArena.TrimExcess();
     }
 
-    // Cache serialization — matches Rust to_cache()
     public CacheData ToCache()
     {
         return new CacheData
         {
-            Entries = Entries.Select(e => new CachedEntry
+            Entries = Entries.Select((e, i) => new CachedEntry
             {
                 FileRef = e.FileRef,
                 ParentRef = e.ParentRef,
-                Name = Name(e),
-                Kind = e.Kind
+                Name = NameAt(i),
+                Kind = e.Kind,
+                DriveIdx = e.DriveIdx
             }).ToList(),
-            DriveRoot = DriveRoot,
+            DriveRoots = new List<string>(DriveRoots),
             Checkpoints = new List<JournalCheckpoint>(Checkpoints)
         };
     }
 
-    // Cache deserialization — matches Rust from_cache()
     public static IndexStore FromCache(CacheData cache)
     {
         int count = cache.Entries.Count;
         var store = new IndexStore
         {
-            DriveRoot = cache.DriveRoot,
+            DriveRoots = new List<string>(cache.DriveRoots),
             Checkpoints = new List<JournalCheckpoint>(cache.Checkpoints)
         };
         store.Entries.Capacity = count;
         store.NameArena.Capacity = count * 30;
         store.NameLowerArena.Capacity = count * 30;
+        store.NameCache.Capacity = count;
+        store.NameLowerCache.Capacity = count;
+        store.RefLookup.Capacity = count;
 
         foreach (var c in cache.Entries)
         {
             string nameLower = c.Name.ToLowerInvariant();
 
+            byte[] nameBytes = Encoding.UTF8.GetBytes(c.Name);
+            byte[] lowerBytes = Encoding.UTF8.GetBytes(nameLower);
+
             uint nOff = (uint)store.NameArena.Count;
-            ushort nLen = (ushort)c.Name.Length;
-            store.NameArena.AddRange(Encoding.UTF8.GetBytes(c.Name));
+            ushort nLen = (ushort)nameBytes.Length;
+            store.NameArena.AddRange(nameBytes);
 
             uint nlOff = (uint)store.NameLowerArena.Count;
-            ushort nlLen = (ushort)nameLower.Length;
-            store.NameLowerArena.AddRange(Encoding.UTF8.GetBytes(nameLower));
+            ushort nlLen = (ushort)lowerBytes.Length;
+            store.NameLowerArena.AddRange(lowerBytes);
 
             store.Entries.Add(new IndexEntry
             {
@@ -199,8 +221,12 @@ public class IndexStore
                 NameLowerOff = nlOff,
                 NameLen = nLen,
                 NameLowerLen = nlLen,
-                Flags = c.Kind == FileKind.Directory ? (byte)1 : (byte)0
+                Flags = c.Kind == FileKind.Directory ? (byte)1 : (byte)0,
+                DriveIdx = c.DriveIdx
             });
+
+            store.NameCache.Add(c.Name);
+            store.NameLowerCache.Add(nameLower);
         }
 
         store.RebuildRefLookup();
@@ -209,19 +235,24 @@ public class IndexStore
         return store;
     }
 
-    // Live mutations — match Rust insert(), remove(), rename(), apply_move()
-
     public void Insert(FileRecord record)
     {
         string nameLower = record.Name.ToLowerInvariant();
 
+        var nameBytes = Encoding.UTF8.GetBytes(record.Name);
+        var lowerBytes = Encoding.UTF8.GetBytes(nameLower);
+
         uint nOff = (uint)NameArena.Count;
-        ushort nLen = (ushort)record.Name.Length;
-        NameArena.AddRange(Encoding.UTF8.GetBytes(record.Name));
+        ushort nLen = (ushort)nameBytes.Length;
+        NameArena.AddRange(nameBytes);
 
         uint nlOff = (uint)NameLowerArena.Count;
-        ushort nlLen = (ushort)nameLower.Length;
-        NameLowerArena.AddRange(Encoding.UTF8.GetBytes(nameLower));
+        ushort nlLen = (ushort)lowerBytes.Length;
+        NameLowerArena.AddRange(lowerBytes);
+
+        byte driveIdx = 0;
+        if (DriveRoots.Count == 0)
+            DriveRoots.Add("C:\\");
 
         var entry = new IndexEntry
         {
@@ -231,27 +262,39 @@ public class IndexStore
             NameLowerOff = nlOff,
             NameLen = nLen,
             NameLowerLen = nlLen,
-            Flags = record.Kind == FileKind.Directory ? (byte)1 : (byte)0
+            Flags = record.Kind == FileKind.Directory ? (byte)1 : (byte)0,
+            DriveIdx = driveIdx
         };
 
-        // Rust: partition_point by name_lower comparison
         int pos = 0;
-        string key = nameLower;
         for (; pos < Entries.Count; pos++)
         {
-            var e = Entries[pos];
-            string cmp = Encoding.UTF8.GetString(NameLowerArena.ToArray(), (int)e.NameLowerOff, e.NameLowerLen);
-            if (string.CompareOrdinal(key, cmp) < 0)
+            if (string.CompareOrdinal(nameLower, NameLowerAt(pos)) < 0)
                 break;
         }
         Entries.Insert(pos, entry);
+        NameCache.Insert(pos, record.Name);
+        NameLowerCache.Insert(pos, nameLower);
+
         RebuildRefLookup();
     }
 
     public void Remove(ulong fileRef)
     {
-        // Name bytes left as dead space in arena (negligible for rare deletes)
-        Entries.RemoveAll(e => e.FileRef == fileRef);
+        int idx = -1;
+        for (int i = 0; i < Entries.Count; i++)
+        {
+            if (Entries[i].FileRef == fileRef)
+            {
+                idx = i;
+                break;
+            }
+        }
+        if (idx < 0) return;
+
+        Entries.RemoveAt(idx);
+        NameCache.RemoveAt(idx);
+        NameLowerCache.RemoveAt(idx);
         RebuildRefLookup();
     }
 
@@ -273,30 +316,34 @@ public class IndexStore
         });
     }
 
-    // Build path by walking parent chain — matches Rust build_path()
     public string BuildPath(ulong fileRef)
     {
-        var components = new List<string>(16);
+        string[] components = new string[64];
+        int compCount = 0;
         ulong current = fileRef;
+        byte driveIdx = 0;
 
         for (int i = 0; i < 64; i++)
         {
             var idx = LookupIdx(current);
             if (idx == null) break;
 
-            var entry = Entries[(int)idx];
-            components.Add(Name(entry));
+            int eIdx = (int)idx;
+            components[compCount++] = NameAt(eIdx);
+            var entry = Entries[eIdx];
+            driveIdx = entry.DriveIdx;
             if (entry.ParentRef == current) break;
             current = entry.ParentRef;
         }
 
-        components.Reverse();
-        var sb = new StringBuilder(DriveRoot);
-        foreach (var comp in components)
+        string driveRoot = driveIdx < DriveRoots.Count ? DriveRoots[driveIdx] : "C:\\";
+        var sb = new StringBuilder(driveRoot.Length + compCount * 32);
+        sb.Append(driveRoot);
+        for (int i = compCount - 1; i >= 0; i--)
         {
             if (sb.Length > 0 && sb[sb.Length - 1] != '\\' && sb[sb.Length - 1] != '/')
                 sb.Append('\\');
-            sb.Append(comp);
+            sb.Append(components[i]);
         }
         return sb.ToString();
     }

FastSeekWpf/Core/MftReader.cs

@@ -9,7 +9,7 @@ namespace FastSeekWpf.Core;
 
 public class MftReader : IDisposable
 {
-    private readonly IntPtr _handle;
+    private readonly IntPtr _volumeHandle;
     private readonly NtfsDrive _drive;
     private bool _disposed;
 
@@ -21,7 +21,7 @@ public class MftReader : IDisposable
     public MftReader(NtfsDrive drive)
     {
         _drive = drive;
-        _handle = Win32Api.CreateFileW(
+        _volumeHandle = Win32Api.CreateFileW(
             drive.DevicePath,
             Win32Api.GENERIC_READ,
             Win32Api.FILE_SHARE_READ | Win32Api.FILE_SHARE_WRITE | Win32Api.FILE_SHARE_DELETE,
@@ -30,14 +30,17 @@ public class MftReader : IDisposable
             Win32Api.FILE_FLAG_BACKUP_SEMANTICS,
             IntPtr.Zero);
 
-        if (_handle == new IntPtr(-1))
+        if (_volumeHandle == new IntPtr(-1))
         {
             int err = Marshal.GetLastWin32Error();
             throw new IOException($"Failed to open volume {drive.DevicePath}: {Win32Error(err)} (code={err})");
         }
     }
 
-    // Try direct first, fall back to FSCTL — matches Rust main.rs exactly
+    // ------------------------------------------------------------------
+    //  Try direct first, fall back to FSCTL (matches Rust main.rs exactly)
+    // ------------------------------------------------------------------
+
     public (ScanResult scan, string method) ScanAny()
     {
         var direct = ScanDirect();
@@ -46,7 +49,10 @@ public class MftReader : IDisposable
         return (Scan(), "ioctl");
     }
 
-    // Primary: direct $MFT file read — matches Rust scan_direct()
+    // ------------------------------------------------------------------
+    //  Primary: direct $MFT file read (matches Rust scan_direct())
+    // ------------------------------------------------------------------
+
     public ScanResult? ScanDirect()
     {
         int? recordSize = ReadMftRecordSize();
@@ -107,13 +113,13 @@ public class MftReader : IDisposable
                     offset += recordSize.Value;
                 }
 
-                // Align down to record boundary — matches Rust offset = total - (total % record_size)
+                // Align down to record boundary (matches Rust: offset = total - (total % record_size))
                 offset = total - (total % recordSize.Value);
 
                 leftover = total - offset;
                 if (leftover > 0)
                 {
-                    // Copy tail to front — matches Rust std::ptr::copy
+                    // Copy tail to front of buffer (matches Rust std::ptr::copy)
                     Buffer.BlockCopy(buffer, offset, buffer, 0, leftover);
                 }
             }
@@ -127,7 +133,11 @@ public class MftReader : IDisposable
         }
     }
 
-    // Fallback: FSCTL_ENUM_USN_DATA (4 MB buffer) — matches Rust scan() exactly
+    // ------------------------------------------------------------------
+    //  Fallback: FSCTL_ENUM_USN_DATA (4 MB buffer)
+    //  Matches Rust scan() exactly.
+    // ------------------------------------------------------------------
+
     public ScanResult Scan()
     {
         var records = new List<CompactRecord>();
@@ -147,14 +157,16 @@ public class MftReader : IDisposable
 
         try
         {
+            int iterations = 0;
             while (true)
             {
+                iterations++;
                 IntPtr bufferPtr = Marshal.AllocHGlobal(buffer.Length);
                 try
                 {
                     uint bytesReturned = 0;
                     bool ok = Win32Api.DeviceIoControl(
-                        _handle,
+                        _volumeHandle,
                         Win32Api.FSCTL_ENUM_USN_DATA,
                         enumDataPtr,
                         (uint)enumDataSize,
@@ -166,13 +178,13 @@ public class MftReader : IDisposable
                     if (!ok)
                     {
                         int error = Marshal.GetLastWin32Error();
-                        // CRITICAL: GetLastWin32Error returns RAW Win32 error (38), NOT HRESULT (0x80070026)
-                        if (error == Win32Api.ERROR_HANDLE_EOF)
+                        uint code = (uint)error;
+                        if (code == 0x80070026) // ERROR_HANDLE_EOF
                         {
-                            Logger.Log($"[{Drive.Letter}] FSCTL_ENUM_USN_DATA: EOF");
+                            Logger.Log($"[{Drive.Letter}] FSCTL_ENUM_USN_DATA: EOF after {iterations} iterations");
                             break;
                         }
-                        if (error == Win32Api.ERROR_INSUFFICIENT_BUFFER)
+                        if (error == 122) // ERROR_INSUFFICIENT_BUFFER
                         {
                             Logger.Log($"[{Drive.Letter}] FSCTL buffer too small ({buffer.Length}), retrying");
                             buffer = new byte[buffer.Length * 2];
@@ -237,14 +249,18 @@ public class MftReader : IDisposable
         return new ScanResult(records, nameData);
     }
 
-    // Read MFT record size from NTFS boot sector — matches Rust read_mft_record_size()
+    // ------------------------------------------------------------------
+    //  NTFS helpers (match Rust exactly)
+    // ------------------------------------------------------------------
+
     private int? ReadMftRecordSize()
     {
-        Win32Api.SetFilePointerEx(_handle, 0, out _, 0);
+        // Seek to beginning of volume
+        Win32Api.SetFilePointerEx(_volumeHandle, 0, out _, 0);
 
         byte[] boot = new byte[512];
         uint br = 0;
-        bool ok = Win32Api.ReadFile(_handle, boot, 512, out br, IntPtr.Zero);
+        bool ok = Win32Api.ReadFile(_volumeHandle, boot, 512, out br, IntPtr.Zero);
         if (!ok || br < 512)
             return null;
 
@@ -262,7 +278,10 @@ public class MftReader : IDisposable
         return recordSize;
     }
 
-    // Apply NTFS multi-sector fixup — matches Rust apply_fixup() exactly
+    /// <summary>
+    /// Apply NTFS multi-sector fixup. Returns false if record is invalid.
+    /// CRITICAL: restores bytes from fixup array back to sector ends (matches Rust exactly).
+    /// </summary>
     private static bool ApplyFixup(byte[] record, int offset, int recordSize)
     {
         if (recordSize < 48 || record[offset] != 'F' || record[offset + 1] != 'I'
@@ -286,7 +305,7 @@ public class MftReader : IDisposable
             if (record[offset + end] != check0 || record[offset + end + 1] != check1)
                 return false;
 
-            // RESTORE real bytes from fixup array — matches Rust exactly
+            // RESTORE real bytes from fixup array (this is what Rust does)
             record[offset + end] = record[offset + fixupOff + i * 2];
             record[offset + end + 1] = record[offset + fixupOff + i * 2 + 1];
         }
@@ -294,7 +313,9 @@ public class MftReader : IDisposable
         return true;
     }
 
-    // Parse one MFT FILE record — matches Rust parse_file_record() exactly
+    /// <summary>
+    /// Parse one MFT FILE record (matches Rust parse_file_record exactly).
+    /// </summary>
     private static void ParseFileRecord(
         ReadOnlySpan<byte> record,
         ulong mftIndex,
@@ -401,7 +422,7 @@ public class MftReader : IDisposable
     {
         if (!_disposed)
         {
-            Win32Api.CloseHandle(_handle);
+            Win32Api.CloseHandle(_volumeHandle);
             _disposed = true;
         }
         GC.SuppressFinalize(this);

FastSeekWpf/Core/SearchEngine.cs

@@ -22,6 +22,21 @@ public class SearchResult
 
 public static class SearchEngine
 {
+    [ThreadStatic]
+    private static StringBuilder? _pathBuilder;
+
+    private static StringBuilder GetPathBuilder()
+    {
+        var sb = _pathBuilder;
+        if (sb == null)
+        {
+            sb = new StringBuilder(512);
+            _pathBuilder = sb;
+        }
+        sb.Clear();
+        return sb;
+    }
+
     private static readonly string[] AppExtensions = { "exe", "lnk", "msi", "appx", "msix" };
     private static readonly string[] AppPathMarkers = {
         "\\program files\\", "\\program files (x86)\\",
@@ -73,7 +88,20 @@ public static class SearchEngine
         return false;
     }
 
-    // Search — matches Rust search() exactly. Uses IndexStore.Name() / NameLower() / BuildPath()
+    private static bool SpanContains(ReadOnlySpan<char> haystack, ReadOnlySpan<char> needle)
+    {
+        if (needle.IsEmpty) return true;
+        if (needle.Length > haystack.Length) return false;
+
+        int limit = haystack.Length - needle.Length + 1;
+        for (int i = 0; i < limit; i++)
+        {
+            if (haystack.Slice(i, needle.Length).SequenceEqual(needle))
+                return true;
+        }
+        return false;
+    }
+
     public static List<SearchResult> Search(
         IndexStore store,
         string query,
@@ -81,58 +109,72 @@ public static class SearchEngine
         bool caseSensitive,
         List<string> excludedDirs)
     {
-        if (string.IsNullOrEmpty(query))
+        if (string.IsNullOrWhiteSpace(query))
             return new List<SearchResult>();
 
+        var searchSw = System.Diagnostics.Stopwatch.StartNew();
         string q = caseSensitive ? query : query.ToLowerInvariant();
+        ReadOnlySpan<char> qSpan = q.AsSpan();
 
-        // Phase 1: lightweight name-only matching
-        var candidates = new List<(int idx, byte rank)>();
+        Span<(int idx, byte rank)> candidates = stackalloc (int, byte)[10000];
+        int candidateCount = 0;
 
-        for (int i = 0; i < store.Entries.Count; i++)
+        lock (store)
         {
-            var entry = store.Entries[i];
-            string nameCmp = caseSensitive ? store.Name(entry) : store.NameLower(entry);
+            int count = store.Entries.Count;
+            for (int i = 0; i < count; i++)
+            {
+                string name = caseSensitive ? store.NameAt(i) : store.NameLowerAt(i);
+                ReadOnlySpan<char> nameSpan = name.AsSpan();
 
-            byte rank;
-            if (nameCmp == q) rank = 1;
-            else if (nameCmp.StartsWith(q, StringComparison.Ordinal)) rank = 2;
-            else if (nameCmp.Contains(q, StringComparison.Ordinal)) rank = 3;
-            else continue;
+                byte rank;
+                if (nameSpan.SequenceEqual(qSpan)) rank = 1;
+                else if (nameSpan.StartsWith(qSpan, StringComparison.Ordinal)) rank = 2;
+                else if (SpanContains(nameSpan, qSpan)) rank = 3;
+                else continue;
 
-            candidates.Add((i, rank));
+                if (candidateCount < candidates.Length)
+                    candidates[candidateCount++] = (i, rank);
+            }
         }
 
-        // Phase 2: sort by rank, keep overshoot buffer
-        candidates.Sort((a, b) => a.rank.CompareTo(b.rank));
+        candidates[..candidateCount].Sort((a, b) => a.rank.CompareTo(b.rank));
+
         int overshoot = Math.Max(limit * 5, 1000);
-        if (candidates.Count > overshoot)
-            candidates.RemoveRange(overshoot, candidates.Count - overshoot);
+        if (candidateCount > overshoot)
+            candidateCount = overshoot;
 
-        // Phase 3: build paths + exclusions + app promotion
-        var results = new List<SearchResult>(limit);
+        var results = new List<SearchResult>(Math.Min(limit, candidateCount));
+        var pathBuilder = GetPathBuilder();
 
-        foreach (var (idx, baseRank) in candidates)
+        foreach (var (idx, baseRank) in candidates[..candidateCount])
         {
             var entry = store.Entries[idx];
-            string fullPath = store.BuildPath(entry.FileRef);
+            string fullPath = BuildPathFast(store, entry.FileRef, pathBuilder, entry.DriveIdx);
+            string fullPathLower = fullPath.ToLowerInvariant();
 
             if (excludedDirs.Count > 0)
             {
-                string pathLower = fullPath.ToLowerInvariant();
-                if (excludedDirs.Any(ex => pathLower.StartsWith(ex, StringComparison.Ordinal)))
-                    continue;
+                bool excluded = false;
+                foreach (var ex in excludedDirs)
+                {
+                    if (fullPathLower.StartsWith(ex, StringComparison.Ordinal))
+                    { excluded = true; break; }
+                }
+                if (excluded) continue;
             }
 
-            string nameLower = store.NameLower(entry);
+            string name = store.NameAt(idx);
+            string nameLower = store.NameLowerAt(idx);
+
             byte rank = baseRank;
             if (baseRank <= 2)
             {
-                string? ext = nameLower.Contains('.') ? nameLower[(nameLower.LastIndexOf('.') + 1)..] : null;
-                if (ext != null && Array.IndexOf(AppExtensions, ext) >= 0)
+                int dotIdx = nameLower.LastIndexOf('.');
+                if (dotIdx >= 0)
                 {
-                    string pathLower = fullPath.ToLowerInvariant();
-                    if (ContainsAny(pathLower, AppPathMarkers))
+                    string ext = nameLower[(dotIdx + 1)..];
+                    if (Array.IndexOf(AppExtensions, ext) >= 0 && ContainsAny(fullPathLower, AppPathMarkers))
                         rank = 0;
                 }
             }
@@ -140,7 +182,6 @@ public static class SearchEngine
             string? fileExt = null;
             if (!entry.IsDir)
             {
-                string name = store.Name(entry);
                 int dot = name.LastIndexOf('.');
                 if (dot >= 0) fileExt = name[(dot + 1)..].ToLowerInvariant();
             }
@@ -148,10 +189,10 @@ public static class SearchEngine
             results.Add(new SearchResult
             {
                 FullPath = fullPath,
-                Name = store.Name(entry),
+                Name = name,
                 Rank = rank,
                 IsDir = entry.IsDir,
-                Kind = GetKind(fileExt, entry.IsDir, fullPath.ToLowerInvariant())
+                Kind = GetKind(fileExt, entry.IsDir, fullPathLower)
             });
         }
 
@@ -159,10 +200,12 @@ public static class SearchEngine
         if (results.Count > limit)
             results.RemoveRange(limit, results.Count - limit);
 
+        searchSw.Stop();
+        Logger.Log($"Search '{query}': {candidateCount} candidates, {results.Count} results, {searchSw.ElapsedMilliseconds}ms (index={store.Count:N0})");
+
         return results;
     }
 
-    // Extension search — matches Rust extension filtering in main.rs
     public static List<SearchResult> SearchByExtension(
         IndexStore store,
         string ext,
@@ -170,40 +213,76 @@ public static class SearchEngine
     {
         string dotExt = "." + ext.ToLowerInvariant();
         var results = new List<SearchResult>();
+        var pathBuilder = GetPathBuilder();
 
-        for (int i = 0; i < store.Entries.Count; i++)
+        lock (store)
         {
-            var entry = store.Entries[i];
-            string name = store.NameLower(entry);
-            if (!name.EndsWith(dotExt)) continue;
+            for (int i = 0; i < store.Entries.Count; i++)
+            {
+                string name = store.NameLowerAt(i);
+                if (!name.EndsWith(dotExt)) continue;
 
-            string fullPath = store.BuildPath(entry.FileRef);
-            string fullPathLower = fullPath.ToLowerInvariant();
+                var entry = store.Entries[i];
+                string fullPath = BuildPathFast(store, entry.FileRef, pathBuilder, entry.DriveIdx);
+                string fullPathLower = fullPath.ToLowerInvariant();
 
-            bool excluded = false;
-            foreach (var ex in excludedDirs)
-            {
-                if (fullPathLower.StartsWith(ex, StringComparison.Ordinal))
-                { excluded = true; break; }
-            }
-            if (excluded) continue;
+                bool excluded = false;
+                foreach (var ex in excludedDirs)
+                {
+                    if (fullPathLower.StartsWith(ex, StringComparison.Ordinal))
+                    { excluded = true; break; }
+                }
+                if (excluded) continue;
 
-            string? fileExt = null;
-            int dot = name.LastIndexOf('.');
-            if (dot >= 0) fileExt = name[(dot + 1)..];
+                string? fileExt = null;
+                int dot = name.LastIndexOf('.');
+                if (dot >= 0) fileExt = name[(dot + 1)..];
 
-            results.Add(new SearchResult
-            {
-                FullPath = fullPath,
-                Name = store.Name(entry),
-                Rank = 0,
-                IsDir = entry.IsDir,
-                Kind = GetKind(fileExt, entry.IsDir, fullPathLower)
-            });
+                results.Add(new SearchResult
+                {
+                    FullPath = fullPath,
+                    Name = store.NameAt(i),
+                    Rank = 0,
+                    IsDir = entry.IsDir,
+                    Kind = GetKind(fileExt, entry.IsDir, fullPathLower)
+                });
 
-            if (results.Count >= 50) break;
+                if (results.Count >= 50) break;
+            }
         }
 
         return results;
     }
+
+    private static string BuildPathFast(IndexStore store, ulong fileRef, StringBuilder sb, byte startDriveIdx)
+    {
+        sb.Clear();
+        string[] components = new string[64];
+        int compCount = 0;
+        ulong current = fileRef;
+        byte driveIdx = startDriveIdx;
+
+        for (int i = 0; i < 64; i++)
+        {
+            var idx = store.LookupIdx(current);
+            if (idx == null) break;
+
+            int eIdx = (int)idx;
+            components[compCount++] = store.NameAt(eIdx);
+            var entry = store.Entries[eIdx];
+            driveIdx = entry.DriveIdx;
+            if (entry.ParentRef == current) break;
+            current = entry.ParentRef;
+        }
+
+        string driveRoot = driveIdx < store.DriveRoots.Count ? store.DriveRoots[driveIdx] : "C:\\";
+        sb.Append(driveRoot);
+        for (int i = compCount - 1; i >= 0; i--)
+        {
+            if (sb.Length > 0 && sb[sb.Length - 1] != '\\' && sb[sb.Length - 1] != '/')
+                sb.Append('\\');
+            sb.Append(components[i]);
+        }
+        return sb.ToString();
+    }
 }

FastSeekWpf/Core/UsnWatcher.cs

@@ -102,33 +102,6 @@ public class UsnWatcher : IDisposable
         return count;
     }
 
-    /// <summary>Synchronous run loop — matches Rust UsnWatcher::run()</summary>
-    public void Run()
-    {
-        byte[] buffer = new byte[65536];
-        while (!_disposed)
-        {
-            Thread.Sleep(500);
-            Poll();
-        }
-    }
-
-    /// <summary>Synchronous run with shared checkpoint updates — matches Rust UsnWatcher::run_shared()</summary>
-    public void RunShared(List<JournalCheckpoint> sharedCheckpoints)
-    {
-        byte[] buffer = new byte[65536];
-        while (!_disposed)
-        {
-            Thread.Sleep(500);
-            Poll();
-            lock (sharedCheckpoints)
-            {
-                sharedCheckpoints.RemoveAll(c => c.DriveLetter == _drive.Letter);
-                sharedCheckpoints.Add(Checkpoint());
-            }
-        }
-    }
-
     public async Task RunAsync(CancellationToken ct)
     {
         _running = true;

FastSeekWpf/MainWindow.xaml.cs

@@ -164,7 +164,9 @@ public partial class MainWindow : Window, INotifyPropertyChanged
                 {
                     needFullScan = false;
                     while (_eventQueue.TryDequeue(out var evt))
+                    {
                         ApplyEvent(evt);
+                    }
                     Logger.Log("Delta events applied.");
                 }
                 else
@@ -211,7 +213,7 @@ public partial class MainWindow : Window, INotifyPropertyChanged
                             Logger.Log($"Scan failed for {drive.Letter}: {ex}");
                         }
                     }
-                    _index.Finalize();
+                    _index.CompleteIndex();
                     Logger.Log($"Full scan complete. Total indexed: {_index.Count}");
                     CacheManager.SaveCache(_index);
                     Logger.Log("Cache saved.");
@@ -275,7 +277,9 @@ public partial class MainWindow : Window, INotifyPropertyChanged
                 if (processed > 100) break;
             }
             if (processed > 50)
+            {
                 CacheManager.SaveCache(_index);
+            }
             Thread.Sleep(100);
         }
     }
@@ -312,7 +316,10 @@ public partial class MainWindow : Window, INotifyPropertyChanged
         return IntPtr.Zero;
     }
 
-    private void Window_Deactivated(object sender, EventArgs e) => FadeOutAndHide();
+    private void Window_Deactivated(object sender, EventArgs e)
+    {
+        FadeOutAndHide();
+    }
 
     private void Window_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
     {
@@ -324,7 +331,11 @@ public partial class MainWindow : Window, INotifyPropertyChanged
     {
         if (Resources["FadeAnim"] is Storyboard fade)
         {
-            fade.Completed += (s, e) => { Hide(); _isVisible = false; };
+            fade.Completed += (s, e) =>
+            {
+                Hide();
+                _isVisible = false;
+            };
             fade.Begin(this);
         }
         else
@@ -337,7 +348,9 @@ public partial class MainWindow : Window, INotifyPropertyChanged
     private void ToggleVisibility()
     {
         if (_isVisible)
+        {
             FadeOutAndHide();
+        }
         else
         {
             CenterWindow();
@@ -349,9 +362,13 @@ public partial class MainWindow : Window, INotifyPropertyChanged
             SearchBox.Focus();
 
             if (Resources["AppearAnim"] is Storyboard appear)
+            {
                 appear.Begin(this);
+            }
             else
+            {
                 Opacity = 1;
+            }
             _isVisible = true;
         }
     }
@@ -395,7 +412,10 @@ public partial class MainWindow : Window, INotifyPropertyChanged
         }
     }
 
-    private void SearchBox_Loaded(object sender, RoutedEventArgs e) => SearchBox.Focus();
+    private void SearchBox_Loaded(object sender, RoutedEventArgs e)
+    {
+        SearchBox.Focus();
+    }
 
     private void SearchBox_TextChanged(object sender, TextChangedEventArgs e)
     {

FastSeekWpf/NativeInterop/Win32Api.cs

@@ -30,12 +30,14 @@ internal static class Win32Api
     public const uint OPEN_EXISTING = 3;
     public const uint FILE_FLAG_BACKUP_SEMANTICS = 0x02000000;
     public const uint FILE_FLAG_SEQUENTIAL_SCAN = 0x08000000;
+    public const uint FILE_FLAG_NO_BUFFERING = 0x20000000;
+    public const uint FILE_ATTRIBUTE_NORMAL = 0x00000080;
 
-    // ── IOCTL codes ──
-    // From Windows SDK winioctl.h. Verified against windows-rs crate.
-    public const uint FSCTL_ENUM_USN_DATA = 0x000900B3;
-    public const uint FSCTL_QUERY_USN_JOURNAL = 0x000900F4;
-    public const uint FSCTL_READ_USN_JOURNAL = 0x000900BB;
+    // IOCTL codes
+    public const uint FSCTL_ENUM_USN_DATA = 0x900B03;
+    public const uint FSCTL_QUERY_USN_JOURNAL = 0x900F44;
+    public const uint FSCTL_READ_USN_JOURNAL = 0x900BB;
+    public const uint FSCTL_READ_FILE_USN_DATA = 0x900EB;
 
     // USN reasons
     public const uint USN_REASON_FILE_CREATE = 0x00000100;
@@ -43,12 +45,9 @@ internal static class Win32Api
     public const uint USN_REASON_RENAME_OLD_NAME = 0x00001000;
     public const uint USN_REASON_RENAME_NEW_NAME = 0x00002000;
 
-    // Win32 error codes (raw, NOT HRESULT)
-    // Marshal.GetLastWin32Error() returns these raw codes.
-    // Rust windows-rs wraps them as HRESULT (0x8007XXXX).
-    public const int ERROR_HANDLE_EOF = 38;               // Raw: 0x26
-    public const int ERROR_INSUFFICIENT_BUFFER = 122;    // Raw: 0x7A
-    public const int ERROR_JOURNAL_NOT_ACTIVE = 1179;    // Raw: 0x49B
+    // Error codes
+    public const uint ERROR_HANDLE_EOF = 0x80070026;
+    public const uint ERROR_JOURNAL_NOT_ACTIVE = 1179;
 
     // DWM
     public const int DWMWA_WINDOW_CORNER_PREFERENCE = 33;
@@ -74,7 +73,7 @@ internal static class Win32Api
         out uint lpNumberOfBytesRead,
         IntPtr lpOverlapped);
 
-    // Unsafe overload: read into a byte[] at a given offset — matches Rust ReadFile into &mut buffer[leftover..]
+    // Unsafe overload: read into a byte[] at a given offset via GCHandle
     public static unsafe bool ReadFile(
         IntPtr hFile,
         byte[] lpBuffer,

README.md

@@ -1,4 +1,7 @@
-
+---
+tags:
+- ml-intern
+---
 # FastSeek WPF
 
 A Windows-only WPF port of the FastSeek instant file search tool.
@@ -56,3 +59,11 @@ The app reads the NTFS Master File Table (MFT) directly via `FSCTL_ENUM_USN_DATA
 - [ ] Search results could use a virtualized `ListView` with container recycling for >10k visible items
 - [ ] No system tray icon — app runs hidden with hotkey toggle only
 - [ ] No settings UI for exclusions
+
+<!-- ml-intern-provenance -->
+## Generated by ML Intern
+
+This model repository was generated by [ML Intern](https://github.com/huggingface/ml-intern), an agent for machine learning research and development on the Hugging Face Hub.
+
+- Try ML Intern: https://smolagents-ml-intern.hf.space
+- Source code: https://github.com/huggingface/ml-intern