initial commit

.gitignore

@@ -0,0 +1,47 @@
+# .NET build artifacts
+**/bin/
+**/obj/
+**/out/
+
+# Visual Studio files
+**/.vs/
+**/*.user
+**/*.suo
+**/*.userprefs
+**/*.sln.docstates
+
+# Rust build artifacts
+**/target/
+
+# IDE files
+**/.idea/
+**/.vscode/
+**/*.swp
+**/*.swo
+
+# Logs
+**/*.log
+**/logs/
+
+# Temporary files
+**/*.tmp
+**/*.temp
+**/temp/
+**/tmp/
+
+# OS files
+**/.DS_Store
+**/Thumbs.db
+
+# NuGet
+**/packages/
+**/*.nupkg
+
+# Test results
+**/TestResults/
+**/*.trx
+
+# Coverage
+**/coverage/
+**/*.coverage
+**/*.cobertura.xml

FastSeek.Cli/FastSeek.Cli.csproj

@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net8.0-windows</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+  </PropertyGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\FastSeek.Core\FastSeek.Core.csproj" />
+  </ItemGroup>
+</Project>

FastSeek.Cli/Program.cs

@@ -0,0 +1,102 @@
+using System.Diagnostics;
+using FastSeek.Core;
+
+namespace FastSeek.Cli;
+
+internal static class Program
+{
+    private static void Main()
+    {
+        Console.WriteLine("FastSeek - starting...");
+        using var engine = new FastSeekEngine();
+        engine.InitializeAsync(msg => Console.WriteLine($"[startup] {msg}")).GetAwaiter().GetResult();
+
+        var configPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "fastsearch", "config.txt");
+        Directory.CreateDirectory(Path.GetDirectoryName(configPath)!);
+        engine.ExcludedDirs.AddRange(LoadExclusions(configPath));
+
+        var resultLimit = 200;
+
+        Console.WriteLine("FastSeek - File Search");
+        PrintMetrics(engine);
+        Console.WriteLine("Commands: case, count, metrics, options, limit <n>, clearcache, exclusions, exclude <path>, unexclude <path>, quit");
+
+        while (true)
+        {
+            Console.Write("search> ");
+            var input = Console.ReadLine()?.Trim() ?? string.Empty;
+            if (string.IsNullOrEmpty(input)) continue;
+            if (input is "quit" or "exit" or "q") break;
+            if (input == "case") { engine.CaseSensitive = !engine.CaseSensitive; Console.WriteLine(engine.CaseSensitive ? "case sensitivity: ON" : "case sensitivity: OFF"); continue; }
+            if (input == "count") { Console.WriteLine($"{engine.Count():N0} files in index"); continue; }
+            if (input == "metrics") { PrintMetrics(engine); continue; }
+            if (input == "options") { Console.WriteLine($"case={(engine.CaseSensitive ? "on" : "off")}, limit={resultLimit}, exclusions={engine.ExcludedDirs.Count}, cache={engine.CachePath}"); continue; }
+            if (input == "clearcache")
+            {
+                try
+                {
+                    if (File.Exists(engine.CachePath)) File.Delete(engine.CachePath);
+                    Console.WriteLine($"cache cleared: {engine.CachePath}");
+                    Console.WriteLine("restart FastSeek to force full rescan");
+                }
+                catch (Exception ex)
+                {
+                    Console.WriteLine($"failed to clear cache: {ex.Message}");
+                }
+                continue;
+            }
+            if (input.StartsWith("limit ", StringComparison.OrdinalIgnoreCase))
+            {
+                if (int.TryParse(input[6..].Trim(), out var parsed) && parsed > 0 && parsed <= 5000)
+                {
+                    resultLimit = parsed;
+                    Console.WriteLine($"result limit set to {resultLimit}");
+                }
+                else Console.WriteLine("usage: limit <1..5000>");
+                continue;
+            }
+            if (input.StartsWith("exclude ", StringComparison.OrdinalIgnoreCase)) { var p = NormalizeExclude(input[8..]); if (!engine.ExcludedDirs.Contains(p)) engine.ExcludedDirs.Add(p); SaveExclusions(configPath, engine.ExcludedDirs); Console.WriteLine($"excluded: {p}"); continue; }
+            if (input.StartsWith("unexclude ", StringComparison.OrdinalIgnoreCase)) { var p = NormalizeExclude(input[10..]); engine.ExcludedDirs.RemoveAll(x => x == p); SaveExclusions(configPath, engine.ExcludedDirs); Console.WriteLine($"removed: {p}"); continue; }
+            if (input == "exclusions") { Console.WriteLine(engine.ExcludedDirs.Count == 0 ? "no excluded directories" : string.Join(Environment.NewLine, engine.ExcludedDirs.Select(x => $"- {x}"))); continue; }
+
+            var sw = Stopwatch.StartNew();
+            var results = engine.Search(input, resultLimit);
+            sw.Stop();
+
+            if (results.Count == 0) Console.WriteLine($"no results for \"{input}\"");
+            else
+            {
+                for (var i = 0; i < results.Count; i++) Console.WriteLine($"[{i + 1,4}] [{(results[i].IsDir ? "DIR " : "FILE")}] {results[i].FullPath}");
+                Console.WriteLine($"\nResults: {results.Count:N0}   Time: {sw.Elapsed.TotalMilliseconds:F2} ms   Limit: {resultLimit:N0}\n");
+            }
+        }
+    }
+
+    private static void PrintMetrics(FastSeekEngine engine)
+    {
+        var m = engine.LastStartupMetrics;
+        if (m is null) return;
+
+        Console.WriteLine();
+        Console.WriteLine("Startup Metrics");
+        Console.WriteLine("---------------");
+        Console.WriteLine($"Cache        : {(m.CacheLoaded ? "HIT" : "MISS")}");
+        Console.WriteLine($"Total Files  : {m.TotalFiles:N0}");
+        Console.WriteLine($"Drives       : {m.DriveDiscoveryMs,10:F2} ms");
+        Console.WriteLine($"Cache Load   : {m.CacheLoadMs,10:F2} ms");
+        Console.WriteLine($"Scan         : {m.ScanMs,10:F2} ms");
+        Console.WriteLine($"Index        : {m.IndexMs,10:F2} ms");
+        Console.WriteLine($"Cache Save   : {m.CacheSaveMs,10:F2} ms");
+        Console.WriteLine($"Startup Total: {m.TotalStartupMs,10:F2} ms");
+        Console.WriteLine($"Cache Path   : {engine.CachePath}");
+        Console.WriteLine();
+    }
+
+    private static List<string> LoadExclusions(string path) => File.Exists(path) ? File.ReadAllLines(path).Select(l => l.Trim().ToLowerInvariant()).Where(l => l.Length > 0).ToList() : [];
+    private static void SaveExclusions(string path, List<string> dirs) => File.WriteAllText(path, string.Join(Environment.NewLine, dirs));
+    private static string NormalizeExclude(string path)
+    {
+        var p = path.Trim().ToLowerInvariant();
+        return p.EndsWith("\\") || p.EndsWith("/") ? p : p + "\\";
+    }
+}

FastSeek.Core/Drives.cs

@@ -0,0 +1,38 @@
+using System.Text;
+using FastSeek.Core.Mft;
+
+namespace FastSeek.Core.Utils;
+
+public static class Drives
+{
+    public static List<NtfsDrive> GetNtfsDrives()
+    {
+        var drives = new List<NtfsDrive>();
+        var buffer = new char[256];
+        var len = NativeMethods.GetLogicalDriveStrings((uint)buffer.Length, buffer);
+        if (len == 0) return drives;
+
+        var all = new string(buffer, 0, (int)len).Split('\0', StringSplitOptions.RemoveEmptyEntries);
+        foreach (var root in all)
+        {
+            if (!IsNtfs(root)) continue;
+            var letter = root[0];
+            drives.Add(new NtfsDrive
+            {
+                Letter = letter,
+                Root = root,
+                DevicePath = $"\\\\.\\{letter}:"
+            });
+        }
+        return drives;
+    }
+
+    private static bool IsNtfs(string root)
+    {
+        var fs = new char[32];
+        var ok = NativeMethods.GetVolumeInformation(root, null, 0, out _, out _, out _, fs, (uint)fs.Length);
+        if (!ok) return false;
+        var fsName = new string(fs).TrimEnd('\0');
+        return fsName.StartsWith("NTFS", StringComparison.OrdinalIgnoreCase);
+    }
+}

FastSeek.Core/FastSeek.Core.csproj

@@ -0,0 +1,8 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net8.0-windows</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+  </PropertyGroup>
+</Project>

FastSeek.Core/FastSeekEngine.cs

@@ -0,0 +1,301 @@
+using System.Collections.Concurrent;
+using System.Diagnostics;
+using FastSeek.Core.Index;
+using FastSeek.Core.Mft;
+using FastSeek.Core.Search;
+using FastSeek.Core.Utils;
+
+namespace FastSeek.Core;
+
+public sealed class StartupMetrics
+{
+    public bool CacheLoaded { get; init; }
+    public int TotalFiles { get; init; }
+    public double DriveDiscoveryMs { get; init; }
+    public double ScanMs { get; init; }
+    public double IndexMs { get; init; }
+    public double CacheLoadMs { get; init; }
+    public double CacheSaveMs { get; init; }
+    public double TotalStartupMs { get; init; }
+}
+
+public sealed class FastSeekEngine : IDisposable
+{
+    private readonly ReaderWriterLockSlim _storeLock = new();
+    private readonly BlockingCollection<IndexEvent> _queue = new();
+    private readonly CancellationTokenSource _cts = new();
+    private readonly object _checkpointLock = new();
+    private readonly string _cachePath = Path.Combine(Path.GetTempPath(), "fastseek_cache.bin");
+
+    private readonly List<JournalCheckpoint> _checkpoints = new();
+    private Task? _eventTask;
+    private readonly List<Task> _watcherTasks = new();
+
+    public IndexStore Store { get; } = new();
+    public bool CaseSensitive { get; set; }
+    public List<string> ExcludedDirs { get; } = new();
+    public StartupMetrics? LastStartupMetrics { get; private set; }
+    public string CachePath => _cachePath;
+
+    public async Task InitializeAsync(Action<string>? log = null)
+    {
+        log?.Invoke("Initializing FastSeek engine...");
+        var swTotal = Stopwatch.StartNew();
+
+        var swDrives = Stopwatch.StartNew();
+        var drives = Drives.GetNtfsDrives();
+        swDrives.Stop();
+        log?.Invoke($"Detected NTFS drives: {string.Join(", ", drives.Select(d => $"{d.Letter}:"))}");
+        if (drives.Count == 0) throw new InvalidOperationException("No NTFS drives found.");
+
+        var swCacheLoad = Stopwatch.StartNew();
+        log?.Invoke($"Loading cache: {_cachePath}");
+        var loaded = TryLoadCache(_cachePath);
+        swCacheLoad.Stop();
+        log?.Invoke(loaded ? "Cache hit. Loaded index from cache." : "Cache miss. Running full MFT scan...");
+
+        double scanMs = 0;
+        double indexMs = 0;
+        double cacheSaveMs = 0;
+
+        if (!loaded)
+        {
+            var swScan = Stopwatch.StartNew();
+            foreach (var d in drives)
+            {
+                log?.Invoke($"Scanning drive {d.Letter}:");
+                using var reader = MftReader.Open(d);
+                var direct = reader.ScanDirect(TimeSpan.FromSeconds(6), m => log?.Invoke($"[{d.Letter}:direct] {m}"));
+                var scan = direct ?? reader.Scan(m => log?.Invoke($"[{d.Letter}:ioctl] {m}"));
+                var method = direct is null ? "ioctl (fallback)" : "direct";
+                _storeLock.EnterWriteLock();
+                try { Store.PopulateFromScan(scan, d.Root); } finally { _storeLock.ExitWriteLock(); }
+                log?.Invoke($"Finished drive {d.Letter}: {scan.Records.Count:N0} records ({method})");
+            }
+            swScan.Stop();
+            scanMs = swScan.Elapsed.TotalMilliseconds;
+
+            var swIndex = Stopwatch.StartNew();
+            _storeLock.EnterWriteLock();
+            try { Store.FinalizeStore(); } finally { _storeLock.ExitWriteLock(); }
+            swIndex.Stop();
+            indexMs = swIndex.Elapsed.TotalMilliseconds;
+
+            var swCacheSave = Stopwatch.StartNew();
+            log?.Invoke("Saving cache...");
+            SaveCache(_cachePath);
+            swCacheSave.Stop();
+            cacheSaveMs = swCacheSave.Elapsed.TotalMilliseconds;
+            log?.Invoke("Cache saved.");
+        }
+
+        _storeLock.EnterReadLock();
+        try { _checkpoints.AddRange(Store.Checkpoints); }
+        finally { _storeLock.ExitReadLock(); }
+
+        foreach (var d in drives)
+        {
+            var drive = d;
+            _watcherTasks.Add(Task.Run(() =>
+            {
+                try
+                {
+                    using var watcher = UsnWatcher.New(drive, _queue);
+                    watcher.RunShared(_checkpoints, _checkpointLock, _cts.Token);
+                }
+                catch { }
+            }, _cts.Token));
+        }
+
+        _eventTask = Task.Run(() =>
+        {
+            foreach (var ev in _queue.GetConsumingEnumerable(_cts.Token))
+            {
+                _storeLock.EnterWriteLock();
+                try
+                {
+                    switch (ev)
+                    {
+                        case IndexEvent.Created c: Store.Insert(c.Record); break;
+                        case IndexEvent.Deleted d: Store.Remove(d.FileRef); break;
+                        case IndexEvent.Renamed r: Store.Rename(r.OldRef, r.NewRecord); break;
+                        case IndexEvent.Moved m: Store.ApplyMove(m.FileRef, m.NewParentRef, m.Name, m.Kind); break;
+                    }
+                }
+                finally { _storeLock.ExitWriteLock(); }
+            }
+        }, _cts.Token);
+
+        swTotal.Stop();
+        LastStartupMetrics = new StartupMetrics
+        {
+            CacheLoaded = loaded,
+            TotalFiles = Count(),
+            DriveDiscoveryMs = swDrives.Elapsed.TotalMilliseconds,
+            ScanMs = scanMs,
+            IndexMs = indexMs,
+            CacheLoadMs = swCacheLoad.Elapsed.TotalMilliseconds,
+            CacheSaveMs = cacheSaveMs,
+            TotalStartupMs = swTotal.Elapsed.TotalMilliseconds,
+        };
+        log?.Invoke($"Startup complete in {LastStartupMetrics.TotalStartupMs:F2} ms");
+
+        await Task.CompletedTask;
+    }
+
+    public List<SearchResult> Search(string input, int limit = 50)
+    {
+        if (string.IsNullOrWhiteSpace(input)) return [];
+        var parsed = ParseQuery(input.Trim());
+
+        _storeLock.EnterReadLock();
+        try
+        {
+            if (parsed.ExtFilter is not null)
+            {
+                var dot = "." + parsed.ExtFilter;
+                return Store.Entries.Where(e => e.NameLower.EndsWith(dot, StringComparison.Ordinal))
+                    .Where(e => parsed.Filter == Filter.All || (parsed.Filter == Filter.Dirs && e.IsDir) || (parsed.Filter == Filter.Files && !e.IsDir))
+                    .Select(e => new SearchResult { FullPath = SearchEngine.BuildPath(e.FileRef, Store), Name = e.Name, Rank = 0, IsDir = e.IsDir })
+                    .Where(r => ExcludedDirs.Count == 0 || !ExcludedDirs.Any(ex => r.FullPath.ToLowerInvariant().StartsWith(ex, StringComparison.Ordinal)))
+                    .Take(limit)
+                    .ToList();
+            }
+
+            var overshootLimit = Math.Max(limit * 4, 400);
+            return SearchEngine.Search(Store, parsed.Query, overshootLimit, CaseSensitive, ExcludedDirs)
+                .Where(r => parsed.Filter == Filter.All || (parsed.Filter == Filter.Dirs && r.IsDir) || (parsed.Filter == Filter.Files && !r.IsDir))
+                .Take(limit)
+                .ToList();
+        }
+        finally { _storeLock.ExitReadLock(); }
+    }
+
+    public int Count()
+    {
+        _storeLock.EnterReadLock();
+        try { return Store.Len(); }
+        finally { _storeLock.ExitReadLock(); }
+    }
+
+    private bool TryLoadCache(string path)
+    {
+        if (!File.Exists(path)) return false;
+        try
+        {
+            using var fs = File.OpenRead(path);
+            using var br = new BinaryReader(fs, System.Text.Encoding.UTF8, leaveOpen: false);
+            var magic = br.ReadUInt32();
+            if (magic != 0x4B534146) return false; // FASK
+            var version = br.ReadInt32();
+            if (version != 1) return false;
+
+            var driveRoot = br.ReadString();
+            var checkpointCount = br.ReadInt32();
+            var checkpoints = new List<JournalCheckpoint>(checkpointCount);
+            for (var i = 0; i < checkpointCount; i++)
+            {
+                checkpoints.Add(new JournalCheckpoint
+                {
+                    NextUsn = br.ReadInt64(),
+                    JournalId = br.ReadUInt64(),
+                    DriveLetter = br.ReadChar()
+                });
+            }
+
+            var entryCount = br.ReadInt32();
+            var cacheData = new CacheData
+            {
+                DriveRoot = driveRoot,
+                Checkpoints = checkpoints,
+                Entries = new List<CachedEntry>(entryCount)
+            };
+            for (var i = 0; i < entryCount; i++)
+            {
+                cacheData.Entries.Add(new CachedEntry
+                {
+                    FileRef = br.ReadUInt64(),
+                    ParentRef = br.ReadUInt64(),
+                    Kind = br.ReadByte() == 1 ? FileKind.Directory : FileKind.File,
+                    Name = br.ReadString()
+                });
+            }
+            var restored = IndexStore.FromCache(cacheData);
+
+            _storeLock.EnterWriteLock();
+            try
+            {
+                Store.Entries.Clear();
+                Store.RefLookup.Clear();
+                Store.DriveRoot = restored.DriveRoot;
+                Store.Checkpoints = restored.Checkpoints;
+                Store.Entries.AddRange(restored.Entries);
+                Store.RefLookup.AddRange(restored.RefLookup);
+            }
+            finally { _storeLock.ExitWriteLock(); }
+            return true;
+        }
+        catch { return false; }
+    }
+
+    private void SaveCache(string path)
+    {
+        try
+        {
+            _storeLock.EnterReadLock();
+            using var fs = File.Create(path);
+            using var bw = new BinaryWriter(fs, System.Text.Encoding.UTF8, leaveOpen: false);
+            bw.Write(0x4B534146u); // FASK
+            bw.Write(1); // version
+            bw.Write(Store.DriveRoot ?? string.Empty);
+            bw.Write(Store.Checkpoints.Count);
+            for (var i = 0; i < Store.Checkpoints.Count; i++)
+            {
+                var c = Store.Checkpoints[i];
+                bw.Write(c.NextUsn);
+                bw.Write(c.JournalId);
+                bw.Write(c.DriveLetter);
+            }
+
+            bw.Write(Store.Entries.Count);
+            for (var i = 0; i < Store.Entries.Count; i++)
+            {
+                var e = Store.Entries[i];
+                bw.Write(e.FileRef);
+                bw.Write(e.ParentRef);
+                bw.Write((byte)(e.IsDir ? 1 : 0));
+                bw.Write(e.Name);
+            }
+        }
+        catch { }
+    }
+
+    public void Dispose()
+    {
+        _cts.Cancel();
+        _queue.CompleteAdding();
+        lock (_checkpointLock)
+        {
+            _storeLock.EnterWriteLock();
+            try { Store.Checkpoints = _checkpoints.ToList(); } finally { _storeLock.ExitWriteLock(); }
+        }
+        SaveCache(_cachePath);
+        _storeLock.Dispose();
+        _queue.Dispose();
+        _cts.Dispose();
+    }
+
+    private enum Filter { All, Dirs, Files }
+    private sealed class ParsedQuery { public required string Query; public Filter Filter; public string? ExtFilter; }
+
+    private static ParsedQuery ParseQuery(string input)
+    {
+        if (input.StartsWith("ext:", StringComparison.OrdinalIgnoreCase)) return new ParsedQuery { Query = string.Empty, Filter = Filter.Files, ExtFilter = input[4..].ToLowerInvariant() };
+        if (input.StartsWith("*.", StringComparison.Ordinal)) return new ParsedQuery { Query = string.Empty, Filter = Filter.All, ExtFilter = input[2..].ToLowerInvariant() };
+        if (input.StartsWith("folder:", StringComparison.OrdinalIgnoreCase)) return new ParsedQuery { Query = input[7..].Trim(), Filter = Filter.Dirs };
+        if (input.StartsWith("file:", StringComparison.OrdinalIgnoreCase)) return new ParsedQuery { Query = input[5..].Trim(), Filter = Filter.Files };
+        if (input.StartsWith(':')) return new ParsedQuery { Query = input[1..], Filter = Filter.Dirs };
+        if (input.StartsWith('!')) return new ParsedQuery { Query = input[1..], Filter = Filter.Files };
+        return new ParsedQuery { Query = input, Filter = Filter.All };
+    }
+}

FastSeek.Core/IndexStore.cs

@@ -0,0 +1,124 @@
+using FastSeek.Core.Mft;
+
+namespace FastSeek.Core.Index;
+
+public sealed class IndexEntry
+{
+    public ulong FileRef;
+    public ulong ParentRef;
+    public required string Name;
+    public required string NameLower;
+    public byte Flags;
+    public bool IsDir => (Flags & 1) != 0;
+    public FileKind Kind => IsDir ? FileKind.Directory : FileKind.File;
+}
+
+public sealed class CachedEntry
+{
+    public ulong FileRef { get; set; }
+    public ulong ParentRef { get; set; }
+    public required string Name { get; set; }
+    public FileKind Kind { get; set; }
+}
+
+public sealed class CacheData
+{
+    public List<CachedEntry> Entries { get; set; } = new();
+    public string DriveRoot { get; set; } = string.Empty;
+    public List<JournalCheckpoint> Checkpoints { get; set; } = new();
+}
+
+public sealed class IndexStore
+{
+    public List<IndexEntry> Entries { get; } = new();
+    public List<(ulong fileRef, int idx)> RefLookup { get; } = new();
+    public string DriveRoot { get; set; } = string.Empty;
+    public List<JournalCheckpoint> Checkpoints { get; set; } = new();
+
+    public string Name(IndexEntry e) => e.Name;
+    public string NameLower(IndexEntry e) => e.NameLower;
+
+    public int? LookupIdx(ulong fileRef)
+    {
+        var lo = 0;
+        var hi = RefLookup.Count - 1;
+        while (lo <= hi)
+        {
+            var mid = lo + ((hi - lo) >> 1);
+            var cmp = RefLookup[mid].fileRef.CompareTo(fileRef);
+            if (cmp == 0) return RefLookup[mid].idx;
+            if (cmp < 0) lo = mid + 1; else hi = mid - 1;
+        }
+        return null;
+    }
+
+    internal void PopulateFromScan(ScanResult scan, string driveRoot)
+    {
+        DriveRoot = driveRoot;
+        var span = System.Runtime.InteropServices.CollectionsMarshal.AsSpan(scan.NameData);
+        Entries.Capacity = Math.Max(Entries.Capacity, Entries.Count + scan.Records.Count);
+        foreach (var r in scan.Records)
+        {
+            var name = new string(span.Slice((int)r.NameOff, r.NameLen));
+            AddEntry(r.FileRef, r.ParentRef, name, r.IsDir ? FileKind.Directory : FileKind.File);
+        }
+    }
+
+    public void FinalizeStore()
+    {
+        Entries.Sort(static (a, b) => string.CompareOrdinal(a.NameLower, b.NameLower));
+        RebuildRefLookup();
+    }
+
+    public void Insert(FileRecord record) => AddSorted(record.FileRef, record.ParentRef, record.Name, record.Kind);
+    public void Remove(ulong fileRef) { Entries.RemoveAll(e => e.FileRef == fileRef); RebuildRefLookup(); }
+    public void Rename(ulong oldRef, FileRecord r) { Remove(oldRef); Insert(r); }
+    public void ApplyMove(ulong fileRef, ulong newParentRef, string name, FileKind kind) { Remove(fileRef); Insert(new FileRecord { FileRef = fileRef, ParentRef = newParentRef, Name = name, Kind = kind }); }
+    public int Len() => Entries.Count;
+
+    public CacheData ToCache() => new()
+    {
+        DriveRoot = DriveRoot,
+        Checkpoints = Checkpoints,
+        Entries = Entries.Select(e => new CachedEntry { FileRef = e.FileRef, ParentRef = e.ParentRef, Name = e.Name, Kind = e.Kind }).ToList()
+    };
+
+    public static IndexStore FromCache(CacheData cache)
+    {
+        var s = new IndexStore { DriveRoot = cache.DriveRoot, Checkpoints = cache.Checkpoints };
+        s.Entries.Capacity = cache.Entries.Count;
+        foreach (var c in cache.Entries) s.AddEntry(c.FileRef, c.ParentRef, c.Name, c.Kind);
+        s.RebuildRefLookup();
+        return s;
+    }
+
+    private void AddSorted(ulong fileRef, ulong parentRef, string name, FileKind kind)
+    {
+        var lower = name.ToLowerInvariant();
+        var pos = Entries.BinarySearch(new IndexEntry { FileRef = fileRef, ParentRef = parentRef, Name = name, NameLower = lower, Flags = kind == FileKind.Directory ? (byte)1 : (byte)0 },
+            Comparer<IndexEntry>.Create(static (a, b) => string.CompareOrdinal(a.NameLower, b.NameLower)));
+        if (pos < 0) pos = ~pos;
+        Entries.Insert(pos, new IndexEntry { FileRef = fileRef, ParentRef = parentRef, Name = name, NameLower = lower, Flags = kind == FileKind.Directory ? (byte)1 : (byte)0 });
+        RebuildRefLookup();
+    }
+
+    private void AddEntry(ulong fileRef, ulong parentRef, string name, FileKind kind)
+    {
+        Entries.Add(new IndexEntry
+        {
+            FileRef = fileRef,
+            ParentRef = parentRef,
+            Name = name,
+            NameLower = name.ToLowerInvariant(),
+            Flags = kind == FileKind.Directory ? (byte)1 : (byte)0
+        });
+    }
+
+    private void RebuildRefLookup()
+    {
+        RefLookup.Clear();
+        RefLookup.Capacity = Math.Max(RefLookup.Capacity, Entries.Count);
+        for (var i = 0; i < Entries.Count; i++) RefLookup.Add((Entries[i].FileRef, i));
+        RefLookup.Sort(static (a, b) => a.fileRef.CompareTo(b.fileRef));
+    }
+}

FastSeek.Core/MftReader.cs

@@ -0,0 +1,239 @@
+using System.Runtime.InteropServices;
+using Microsoft.Win32.SafeHandles;
+
+namespace FastSeek.Core.Mft;
+
+internal sealed class MftReader : IDisposable
+{
+    private const int FallbackBuf = 4 * 1024 * 1024;
+    private const int DirectBuf = 4 * 1024 * 1024;
+
+    private readonly SafeFileHandle _handle;
+    public NtfsDrive Drive { get; }
+
+    private MftReader(SafeFileHandle handle, NtfsDrive drive)
+    {
+        _handle = handle;
+        Drive = drive;
+    }
+
+    public static MftReader Open(NtfsDrive drive)
+    {
+        var h = NativeMethods.CreateFile(drive.DevicePath, NativeMethods.GENERIC_READ, NativeMethods.FILE_SHARE_READ | NativeMethods.FILE_SHARE_WRITE | NativeMethods.FILE_SHARE_DELETE, IntPtr.Zero, NativeMethods.OPEN_EXISTING, NativeMethods.FILE_FLAG_BACKUP_SEMANTICS, IntPtr.Zero);
+        if (h.IsInvalid) throw new IOException($"Open drive failed: {drive.DevicePath}");
+        return new MftReader(h, drive);
+    }
+
+    public ScanResult? ScanDirect(TimeSpan? maxDuration = null, Action<string>? log = null)
+    {
+        var started = DateTime.UtcNow;
+        var recordSize = ReadMftRecordSize();
+        if (recordSize is null)
+        {
+            log?.Invoke("direct: failed to read NTFS record size");
+            return null;
+        }
+        log?.Invoke($"direct: record size={recordSize.Value} bytes");
+
+        var mftPath = Path.Combine(Drive.Root, "$MFT");
+        var mft = NativeMethods.CreateFile(mftPath, NativeMethods.GENERIC_READ, NativeMethods.FILE_SHARE_READ | NativeMethods.FILE_SHARE_WRITE | NativeMethods.FILE_SHARE_DELETE, IntPtr.Zero, NativeMethods.OPEN_EXISTING, NativeMethods.FILE_FLAG_BACKUP_SEMANTICS | NativeMethods.FILE_FLAG_SEQUENTIAL_SCAN, IntPtr.Zero);
+        if (mft.IsInvalid)
+        {
+            log?.Invoke("direct: could not open $MFT");
+            return null;
+        }
+
+        try
+        {
+            var records = new List<CompactRecord>(3_000_000);
+            var names = new List<char>(40_000_000);
+            var buffer = new byte[DirectBuf];
+            var readChunk = new byte[DirectBuf];
+            ulong mftIndex = 0;
+            var leftover = 0;
+            long totalRead = 0;
+            var lastLog = DateTime.UtcNow;
+
+            while (NativeMethods.ReadFile(mft, readChunk, (uint)(buffer.Length - leftover), out var read, IntPtr.Zero) && read > 0)
+            {
+                if (maxDuration.HasValue && (DateTime.UtcNow - started) > maxDuration.Value)
+                {
+                    log?.Invoke($"direct: timed out after {(DateTime.UtcNow - started).TotalSeconds:F1}s, fallback to ioctl");
+                    return null;
+                }
+                totalRead += read;
+                Buffer.BlockCopy(readChunk, 0, buffer, leftover, (int)read);
+                var total = leftover + (int)read;
+                var offset = 0;
+                while (offset + recordSize.Value <= total)
+                {
+                    var slice = new Span<byte>(buffer, offset, recordSize.Value);
+                    if (ApplyFixup(slice)) ParseFileRecord(slice, mftIndex, records, names);
+                    mftIndex++;
+                    offset += recordSize.Value;
+                }
+                offset = total - (total % recordSize.Value);
+                leftover = total - offset;
+                if (leftover > 0) Buffer.BlockCopy(buffer, offset, buffer, 0, leftover);
+
+                var now = DateTime.UtcNow;
+                if ((now - lastLog).TotalSeconds >= 2.0)
+                {
+                    log?.Invoke($"direct: read={totalRead / (1024 * 1024)}MB parsed={records.Count:N0}");
+                    lastLog = now;
+                }
+            }
+
+            log?.Invoke($"direct: completed read={totalRead / (1024 * 1024)}MB parsed={records.Count:N0}");
+            return new ScanResult { Records = records, NameData = names };
+        }
+        finally { mft.Dispose(); }
+    }
+
+    public ScanResult Scan(Action<string>? log = null)
+    {
+        var records = new List<CompactRecord>(3_000_000);
+        var names = new List<char>(40_000_000);
+        var enumData = new MftEnumDataV0 { StartFileReferenceNumber = 0, LowUsn = 0, HighUsn = long.MaxValue };
+        var outBuf = new byte[FallbackBuf];
+        var loops = 0;
+        var lastLog = DateTime.UtcNow;
+
+        while (true)
+        {
+            var pIn = Marshal.AllocHGlobal(Marshal.SizeOf<MftEnumDataV0>());
+            try
+            {
+                Marshal.StructureToPtr(enumData, pIn, false);
+                if (!NativeMethods.DeviceIoControl(_handle, NativeMethods.FSCTL_ENUM_USN_DATA, pIn, (uint)Marshal.SizeOf<MftEnumDataV0>(), outBuf, (uint)outBuf.Length, out var returned, IntPtr.Zero))
+                {
+                    var err = Marshal.GetLastWin32Error();
+                    log?.Invoke($"ioctl: DeviceIoControl stop err=0x{err:X8}");
+                    break;
+                }
+                if (returned <= 8)
+                {
+                    log?.Invoke("ioctl: no more records");
+                    break;
+                }
+                loops++;
+
+                enumData.StartFileReferenceNumber = BitConverter.ToUInt64(outBuf, 0);
+                var offset = 8;
+                while (offset + Marshal.SizeOf<UsnRecordV2>() <= returned)
+                {
+                    var rec = MemoryMarshal.Read<UsnRecordV2>(new ReadOnlySpan<byte>(outBuf, offset, Marshal.SizeOf<UsnRecordV2>()));
+                    if (rec.RecordLength == 0 || offset + rec.RecordLength > returned) break;
+                    var nameLen = (ushort)(rec.FileNameLength / 2);
+                    var nameStart = offset + rec.FileNameOffset;
+                    var chars = MemoryMarshal.Cast<byte, char>(new ReadOnlySpan<byte>(outBuf, nameStart, nameLen * 2));
+                    var arenaOff = (uint)names.Count;
+                    AppendChars(names, chars);
+                    records.Add(new CompactRecord { FileRef = rec.FileReferenceNumber, ParentRef = rec.ParentFileReferenceNumber, NameOff = arenaOff, NameLen = nameLen, IsDir = (rec.FileAttributes & 0x10) != 0 });
+                    offset += (int)rec.RecordLength;
+                }
+
+                var now = DateTime.UtcNow;
+                if ((now - lastLog).TotalSeconds >= 2.0)
+                {
+                    log?.Invoke($"ioctl: loops={loops:N0} parsed={records.Count:N0} nextRef={enumData.StartFileReferenceNumber}");
+                    lastLog = now;
+                }
+            }
+            finally { Marshal.FreeHGlobal(pIn); }
+        }
+
+        log?.Invoke($"ioctl: completed loops={loops:N0} parsed={records.Count:N0}");
+        return new ScanResult { Records = records, NameData = names };
+    }
+
+    private int? ReadMftRecordSize()
+    {
+        if (!NativeMethods.SetFilePointerEx(_handle, 0, out _, NativeMethods.FILE_BEGIN)) return null;
+        var boot = new byte[512];
+        if (!NativeMethods.ReadFile(_handle, boot, 512, out var read, IntPtr.Zero) || read < 512) return null;
+        if (boot[3] != (byte)'N' || boot[4] != (byte)'T' || boot[5] != (byte)'F' || boot[6] != (byte)'S') return null;
+        var bps = BitConverter.ToUInt16(boot, 0x0B);
+        var spc = boot[0x0D];
+        var cluster = bps * spc;
+        var raw = unchecked((sbyte)boot[0x40]);
+        return raw > 0 ? raw * cluster : 1 << -raw;
+    }
+
+    private static bool ApplyFixup(Span<byte> rec)
+    {
+        if (rec.Length < 48 || rec[0] != (byte)'F' || rec[1] != (byte)'I' || rec[2] != (byte)'L' || rec[3] != (byte)'E') return false;
+        var off = BitConverter.ToUInt16(rec.Slice(4, 2));
+        var cnt = BitConverter.ToUInt16(rec.Slice(6, 2));
+        if (cnt < 2 || off + cnt * 2 > rec.Length) return false;
+        var c0 = rec[off]; var c1 = rec[off + 1];
+        for (var i = 1; i < cnt; i++)
+        {
+            var end = i * 512 - 2;
+            if (end + 1 >= rec.Length) break;
+            if (rec[end] != c0 || rec[end + 1] != c1) return false;
+            rec[end] = rec[off + i * 2];
+            rec[end + 1] = rec[off + i * 2 + 1];
+        }
+        return true;
+    }
+
+    private static void ParseFileRecord(ReadOnlySpan<byte> rec, ulong mftIndex, List<CompactRecord> outRecords, List<char> outNames)
+    {
+        var flags = BitConverter.ToUInt16(rec.Slice(0x16, 2));
+        if ((flags & 0x01) == 0) return;
+        var isDir = (flags & 0x02) != 0;
+        var seq = BitConverter.ToUInt16(rec.Slice(0x10, 2));
+        var fileRef = mftIndex | ((ulong)seq << 48);
+        var firstAttr = BitConverter.ToUInt16(rec.Slice(0x14, 2));
+        var aoff = (int)firstAttr;
+        byte bestNs = 255;
+        (int pos, int len, ulong parent)? best = null;
+
+        while (aoff + 8 <= rec.Length)
+        {
+            var atype = BitConverter.ToUInt32(rec.Slice(aoff, 4));
+            if (atype == 0xFFFFFFFF) break;
+            var alen = (int)BitConverter.ToUInt32(rec.Slice(aoff + 4, 4));
+            if (alen == 0 || aoff + alen > rec.Length) break;
+            if (atype == 0x30 && rec[aoff + 8] == 0)
+            {
+                var voff = (int)BitConverter.ToUInt16(rec.Slice(aoff + 20, 2));
+                var vs = aoff + voff;
+                if (vs + 66 <= rec.Length)
+                {
+                    var parent = BitConverter.ToUInt64(rec.Slice(vs, 8));
+                    var nlen = rec[vs + 64];
+                    var ns = rec[vs + 65];
+                    if (vs + 66 + nlen * 2 <= rec.Length && ns != 2)
+                    {
+                        var pr = ns == 1 ? 0 : ns == 3 ? 1 : ns == 0 ? 2 : 3;
+                        if (pr < bestNs)
+                        {
+                            bestNs = (byte)pr;
+                            best = (vs + 66, nlen, parent);
+                            if (pr == 0) break;
+                        }
+                    }
+                }
+            }
+            aoff += alen;
+        }
+
+        if (best is { } b)
+        {
+            var arenaOff = (uint)outNames.Count;
+            var chars = MemoryMarshal.Cast<byte, char>(rec.Slice(b.pos, b.len * 2));
+            AppendChars(outNames, chars);
+            outRecords.Add(new CompactRecord { FileRef = fileRef, ParentRef = b.parent, NameOff = arenaOff, NameLen = (ushort)b.len, IsDir = isDir });
+        }
+    }
+
+    private static void AppendChars(List<char> target, ReadOnlySpan<char> source)
+    {
+        target.Capacity = Math.Max(target.Capacity, target.Count + source.Length);
+        for (var i = 0; i < source.Length; i++) target.Add(source[i]);
+    }
+
+    public void Dispose() => _handle.Dispose();
+}

FastSeek.Core/NativeMethods.cs

@@ -0,0 +1,136 @@
+using System.Runtime.InteropServices;
+using Microsoft.Win32.SafeHandles;
+
+namespace FastSeek.Core.Mft;
+
+internal static class NativeMethods
+{
+    internal const uint FILE_SHARE_READ = 0x00000001;
+    internal const uint FILE_SHARE_WRITE = 0x00000002;
+    internal const uint FILE_SHARE_DELETE = 0x00000004;
+    internal const uint OPEN_EXISTING = 3;
+    internal const uint FILE_FLAG_BACKUP_SEMANTICS = 0x02000000;
+    internal const uint FILE_FLAG_SEQUENTIAL_SCAN = 0x08000000;
+    internal const uint GENERIC_READ = 0x80000000;
+    internal const uint FILE_BEGIN = 0;
+
+    internal const uint FSCTL_ENUM_USN_DATA = 0x000900b3;
+    internal const uint FSCTL_QUERY_USN_JOURNAL = 0x000900f4;
+    internal const uint FSCTL_READ_USN_JOURNAL = 0x000900bb;
+
+    internal const uint USN_REASON_FILE_CREATE = 0x00000100;
+    internal const uint USN_REASON_FILE_DELETE = 0x00000200;
+    internal const uint USN_REASON_RENAME_OLD_NAME = 0x00001000;
+    internal const uint USN_REASON_RENAME_NEW_NAME = 0x00002000;
+
+    [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
+    internal static extern uint GetLogicalDriveStrings(uint nBufferLength, [Out] char[] lpBuffer);
+
+    [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    internal static extern bool GetVolumeInformation(
+        string lpRootPathName,
+        System.Text.StringBuilder? lpVolumeNameBuffer,
+        uint nVolumeNameSize,
+        out uint lpVolumeSerialNumber,
+        out uint lpMaximumComponentLength,
+        out uint lpFileSystemFlags,
+        [Out] char[] lpFileSystemNameBuffer,
+        uint nFileSystemNameSize);
+
+    [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
+    internal static extern SafeFileHandle CreateFile(
+        string lpFileName,
+        uint dwDesiredAccess,
+        uint dwShareMode,
+        IntPtr lpSecurityAttributes,
+        uint dwCreationDisposition,
+        uint dwFlagsAndAttributes,
+        IntPtr hTemplateFile);
+
+    [DllImport("kernel32.dll", SetLastError = true)]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    internal static extern bool ReadFile(
+        SafeFileHandle hFile,
+        [Out] byte[] lpBuffer,
+        uint nNumberOfBytesToRead,
+        out uint lpNumberOfBytesRead,
+        IntPtr lpOverlapped);
+
+    [DllImport("kernel32.dll", SetLastError = true)]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    internal static extern bool SetFilePointerEx(SafeFileHandle hFile, long liDistanceToMove, out long lpNewFilePointer, uint dwMoveMethod);
+
+    [DllImport("kernel32.dll", SetLastError = true)]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    internal static extern bool DeviceIoControl(
+        SafeFileHandle hDevice,
+        uint dwIoControlCode,
+        IntPtr lpInBuffer,
+        uint nInBufferSize,
+        [Out] byte[] lpOutBuffer,
+        uint nOutBufferSize,
+        out uint lpBytesReturned,
+        IntPtr lpOverlapped);
+
+    [DllImport("kernel32.dll", SetLastError = true)]
+    [return: MarshalAs(UnmanagedType.Bool)]
+    internal static extern bool DeviceIoControl(
+        SafeFileHandle hDevice,
+        uint dwIoControlCode,
+        IntPtr lpInBuffer,
+        uint nInBufferSize,
+        IntPtr lpOutBuffer,
+        uint nOutBufferSize,
+        out uint lpBytesReturned,
+        IntPtr lpOverlapped);
+}
+
+[StructLayout(LayoutKind.Sequential)]
+internal struct MftEnumDataV0
+{
+    public ulong StartFileReferenceNumber;
+    public long LowUsn;
+    public long HighUsn;
+}
+
+[StructLayout(LayoutKind.Sequential)]
+internal struct UsnJournalDataV0
+{
+    public ulong UsnJournalID;
+    public long FirstUsn;
+    public long NextUsn;
+    public long LowestValidUsn;
+    public long MaxUsn;
+    public ulong MaximumSize;
+    public ulong AllocationDelta;
+}
+
+[StructLayout(LayoutKind.Sequential)]
+internal struct ReadUsnJournalDataV0
+{
+    public long StartUsn;
+    public uint ReasonMask;
+    public uint ReturnOnlyOnClose;
+    public ulong Timeout;
+    public ulong BytesToWaitFor;
+    public ulong UsnJournalID;
+}
+
+[StructLayout(LayoutKind.Sequential)]
+internal struct UsnRecordV2
+{
+    public uint RecordLength;
+    public ushort MajorVersion;
+    public ushort MinorVersion;
+    public ulong FileReferenceNumber;
+    public ulong ParentFileReferenceNumber;
+    public long Usn;
+    public long TimeStamp;
+    public uint Reason;
+    public uint SourceInfo;
+    public uint SecurityId;
+    public uint FileAttributes;
+    public ushort FileNameLength;
+    public ushort FileNameOffset;
+}

FastSeek.Core/SearchEngine.cs

@@ -0,0 +1,103 @@
+using FastSeek.Core.Index;
+
+namespace FastSeek.Core.Search;
+
+public sealed class SearchResult
+{
+    public required string FullPath { get; init; }
+    public required string Name { get; init; }
+    public byte Rank { get; init; }
+    public bool IsDir { get; init; }
+}
+
+public static class SearchEngine
+{
+    private static readonly HashSet<string> AppExtensions = new(StringComparer.OrdinalIgnoreCase) { "exe", "lnk", "msi", "appx", "msix" };
+    private static readonly string[] AppPathMarkers = ["\\program files\\", "\\program files (x86)\\", "\\start menu\\", "\\desktop\\", "\\appdata\\"];
+
+    public static List<SearchResult> Search(IndexStore store, string query, int limit, bool caseSensitive, IReadOnlyList<string> excludedDirs)
+    {
+        if (string.IsNullOrEmpty(query)) return [];
+        var q = caseSensitive ? query : query.ToLowerInvariant();
+
+        var bag = new System.Collections.Concurrent.ConcurrentBag<(int idx, byte rank)>();
+        Parallel.For(0, store.Entries.Count, i =>
+        {
+            var e = store.Entries[i];
+            var nameCmp = caseSensitive ? e.Name : e.NameLower;
+            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 return;
+            bag.Add((i, rank));
+        });
+
+        var candidates = bag.ToList();
+        candidates.Sort(static (a, b) => a.rank.CompareTo(b.rank));
+        if (candidates.Count > Math.Max(limit * 5, 1000)) candidates.RemoveRange(Math.Max(limit * 5, 1000), candidates.Count - Math.Max(limit * 5, 1000));
+
+        var results = new List<SearchResult>(limit);
+        foreach (var (idx, baseRank) in candidates)
+        {
+            var entry = store.Entries[idx];
+            var path = BuildPath(entry.FileRef, store);
+            if (excludedDirs.Count > 0)
+            {
+                var lowerPath = path.ToLowerInvariant();
+                var excluded = false;
+                for (var i = 0; i < excludedDirs.Count; i++)
+                {
+                    if (lowerPath.StartsWith(excludedDirs[i], StringComparison.Ordinal)) { excluded = true; break; }
+                }
+                if (excluded) continue;
+            }
+
+            var rank = baseRank;
+            if (baseRank <= 2)
+            {
+                var extIdx = entry.NameLower.LastIndexOf('.');
+                if (extIdx >= 0 && extIdx + 1 < entry.NameLower.Length)
+                {
+                    var ext = entry.NameLower[(extIdx + 1)..];
+                    if (AppExtensions.Contains(ext))
+                    {
+                        var pathLower = path.ToLowerInvariant();
+                        for (var i = 0; i < AppPathMarkers.Length; i++)
+                        {
+                            if (pathLower.Contains(AppPathMarkers[i], StringComparison.Ordinal)) { rank = 0; break; }
+                        }
+                    }
+                }
+            }
+
+            results.Add(new SearchResult { FullPath = path, Name = entry.Name, Rank = rank, IsDir = entry.IsDir });
+        }
+
+        results.Sort(static (a, b) => a.Rank.CompareTo(b.Rank));
+        if (results.Count > limit) results.RemoveRange(limit, results.Count - limit);
+        return results;
+    }
+
+    public static string BuildPath(ulong fileRef, IndexStore store)
+    {
+        var components = new List<string>(16);
+        var current = fileRef;
+        for (var i = 0; i < 64; i++)
+        {
+            var idx = store.LookupIdx(current);
+            if (idx is null) break;
+            var e = store.Entries[idx.Value];
+            components.Add(e.Name);
+            if (e.ParentRef == current) break;
+            current = e.ParentRef;
+        }
+
+        components.Reverse();
+        if (components.Count == 0) return store.DriveRoot;
+
+        var path = store.DriveRoot;
+        for (var i = 0; i < components.Count; i++) path = Path.Combine(path, components[i]);
+        return path;
+    }
+}

FastSeek.Core/Types.cs

@@ -0,0 +1,56 @@
+using System.Runtime.InteropServices;
+
+namespace FastSeek.Core.Mft;
+
+public enum FileKind
+{
+    File,
+    Directory
+}
+
+public sealed class FileRecord
+{
+    public ulong FileRef { get; init; }
+    public ulong ParentRef { get; init; }
+    public required string Name { get; init; }
+    public FileKind Kind { get; init; }
+}
+
+public sealed class NtfsDrive
+{
+    public required char Letter { get; init; }
+    public required string Root { get; init; }
+    public required string DevicePath { get; init; }
+}
+
+public abstract record IndexEvent
+{
+    public sealed record Created(FileRecord Record) : IndexEvent;
+    public sealed record Deleted(ulong FileRef) : IndexEvent;
+    public sealed record Renamed(ulong OldRef, FileRecord NewRecord) : IndexEvent;
+    public sealed record Moved(ulong FileRef, ulong NewParentRef, string Name, FileKind Kind) : IndexEvent;
+}
+
+public sealed class JournalCheckpoint
+{
+    public long NextUsn { get; set; }
+    public ulong JournalId { get; set; }
+    public char DriveLetter { get; set; }
+}
+
+[StructLayout(LayoutKind.Sequential)]
+internal struct CompactRecord
+{
+    public ulong FileRef;
+    public ulong ParentRef;
+    public uint NameOff;
+    public ushort NameLen;
+    [MarshalAs(UnmanagedType.U1)]
+    public bool IsDir;
+}
+
+internal sealed class ScanResult
+{
+    public required List<CompactRecord> Records { get; init; }
+    public required List<char> NameData { get; init; }
+}

FastSeek.Core/UsnWatcher.cs

@@ -0,0 +1,130 @@
+using System.Collections.Concurrent;
+using System.Runtime.InteropServices;
+using Microsoft.Win32.SafeHandles;
+
+namespace FastSeek.Core.Mft;
+
+public sealed class UsnWatcher : IDisposable
+{
+    private const int BufferSize = 64 * 1024;
+    private readonly SafeFileHandle _handle;
+    private readonly NtfsDrive _drive;
+    private readonly BlockingCollection<IndexEvent> _sender;
+
+    public long NextUsn { get; private set; }
+    public ulong JournalId { get; private set; }
+
+    private UsnWatcher(SafeFileHandle handle, NtfsDrive drive, BlockingCollection<IndexEvent> sender, long nextUsn, ulong journalId)
+    {
+        _handle = handle;
+        _drive = drive;
+        _sender = sender;
+        NextUsn = nextUsn;
+        JournalId = journalId;
+    }
+
+    public static UsnWatcher New(NtfsDrive drive, BlockingCollection<IndexEvent> sender) => NewFrom(drive, sender, null);
+
+    public static UsnWatcher NewFrom(NtfsDrive drive, BlockingCollection<IndexEvent> sender, JournalCheckpoint? checkpoint)
+    {
+        var h = NativeMethods.CreateFile(drive.DevicePath, 0, NativeMethods.FILE_SHARE_READ | NativeMethods.FILE_SHARE_WRITE | NativeMethods.FILE_SHARE_DELETE, IntPtr.Zero, NativeMethods.OPEN_EXISTING, NativeMethods.FILE_FLAG_BACKUP_SEMANTICS, IntPtr.Zero);
+        if (h.IsInvalid) throw new IOException("USN open failed");
+
+        var outPtr = Marshal.AllocHGlobal(Marshal.SizeOf<UsnJournalDataV0>());
+        try
+        {
+            if (!NativeMethods.DeviceIoControl(h, NativeMethods.FSCTL_QUERY_USN_JOURNAL, IntPtr.Zero, 0, outPtr, (uint)Marshal.SizeOf<UsnJournalDataV0>(), out _, IntPtr.Zero))
+                throw new IOException("USN query failed");
+
+            var data = Marshal.PtrToStructure<UsnJournalDataV0>(outPtr);
+            long nextUsn;
+            if (checkpoint is not null)
+            {
+                if (checkpoint.JournalId != data.UsnJournalID || checkpoint.NextUsn < data.FirstUsn || checkpoint.NextUsn > data.NextUsn)
+                    throw new IOException("Journal mismatch - rescan needed");
+                nextUsn = checkpoint.NextUsn;
+            }
+            else nextUsn = data.NextUsn;
+
+            return new UsnWatcher(h, drive, sender, nextUsn, data.UsnJournalID);
+        }
+        finally { Marshal.FreeHGlobal(outPtr); }
+    }
+
+    public JournalCheckpoint Checkpoint() => new() { NextUsn = NextUsn, JournalId = JournalId, DriveLetter = _drive.Letter };
+
+    public void RunShared(List<JournalCheckpoint> checkpoints, object checkpointLock, CancellationToken token)
+    {
+        var buffer = new byte[BufferSize];
+        while (!token.IsCancellationRequested)
+        {
+            Thread.Sleep(500);
+            Poll(buffer);
+            lock (checkpointLock)
+            {
+                checkpoints.RemoveAll(c => c.DriveLetter == _drive.Letter);
+                checkpoints.Add(Checkpoint());
+            }
+        }
+    }
+
+    public int Drain()
+    {
+        var buffer = new byte[BufferSize];
+        var count = 0;
+        while (true)
+        {
+            var before = NextUsn;
+            Poll(buffer);
+            if (NextUsn == before) break;
+            count++;
+        }
+        return count;
+    }
+
+    private void Poll(byte[] buffer)
+    {
+        var read = new ReadUsnJournalDataV0
+        {
+            StartUsn = NextUsn,
+            ReasonMask = NativeMethods.USN_REASON_FILE_CREATE | NativeMethods.USN_REASON_FILE_DELETE | NativeMethods.USN_REASON_RENAME_NEW_NAME | NativeMethods.USN_REASON_RENAME_OLD_NAME,
+            ReturnOnlyOnClose = 0,
+            Timeout = 0,
+            BytesToWaitFor = 0,
+            UsnJournalID = JournalId,
+        };
+
+        var inPtr = Marshal.AllocHGlobal(Marshal.SizeOf<ReadUsnJournalDataV0>());
+        try
+        {
+            Marshal.StructureToPtr(read, inPtr, false);
+            if (!NativeMethods.DeviceIoControl(_handle, NativeMethods.FSCTL_READ_USN_JOURNAL, inPtr, (uint)Marshal.SizeOf<ReadUsnJournalDataV0>(), buffer, (uint)buffer.Length, out var returned, IntPtr.Zero) || returned <= 8) return;
+            NextUsn = BitConverter.ToInt64(buffer, 0);
+
+            var offset = 8;
+            while (offset + Marshal.SizeOf<UsnRecordV2>() <= returned)
+            {
+                var rec = MemoryMarshal.Read<UsnRecordV2>(new ReadOnlySpan<byte>(buffer, offset, Marshal.SizeOf<UsnRecordV2>()));
+                if (rec.RecordLength == 0) break;
+                ProcessRecord(rec, buffer, offset);
+                offset += (int)rec.RecordLength;
+            }
+        }
+        finally { Marshal.FreeHGlobal(inPtr); }
+    }
+
+    private void ProcessRecord(UsnRecordV2 record, byte[] buffer, int offset)
+    {
+        var nameLen = record.FileNameLength / 2;
+        var nameStart = offset + record.FileNameOffset;
+        var name = new string(MemoryMarshal.Cast<byte, char>(new ReadOnlySpan<byte>(buffer, nameStart, nameLen * 2)));
+        var isDir = (record.FileAttributes & 0x10) != 0;
+        var kind = isDir ? FileKind.Directory : FileKind.File;
+
+        if ((record.Reason & NativeMethods.USN_REASON_FILE_DELETE) != 0) { _sender.Add(new IndexEvent.Deleted(record.FileReferenceNumber)); return; }
+        if ((record.Reason & NativeMethods.USN_REASON_RENAME_NEW_NAME) != 0) { _sender.Add(new IndexEvent.Moved(record.FileReferenceNumber, record.ParentFileReferenceNumber, name, kind)); return; }
+        if ((record.Reason & NativeMethods.USN_REASON_FILE_CREATE) != 0) _sender.Add(new IndexEvent.Created(new FileRecord { FileRef = record.FileReferenceNumber, ParentRef = record.ParentFileReferenceNumber, Name = name, Kind = kind }));
+    }
+
+    public void Dispose() => _handle.Dispose();
+}

FastSeek.WinUI/App.xaml

@@ -0,0 +1,15 @@
+<Application
+    x:Class="FastSeek.WinUI.App"
+    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
+    <Application.Resources>
+        <ResourceDictionary>
+            <Color x:Key="Bg">#161A1D</Color>
+            <Color x:Key="Panel">#20262B</Color>
+            <Color x:Key="Accent">#4FC3F7</Color>
+            <SolidColorBrush x:Key="BgBrush" Color="{StaticResource Bg}" />
+            <SolidColorBrush x:Key="PanelBrush" Color="{StaticResource Panel}" />
+            <SolidColorBrush x:Key="AccentBrush" Color="{StaticResource Accent}" />
+        </ResourceDictionary>
+    </Application.Resources>
+</Application>

FastSeek.WinUI/App.xaml.cs

@@ -0,0 +1,19 @@
+using Microsoft.UI.Xaml;
+
+namespace FastSeek.WinUI;
+
+public partial class App : Application
+{
+    private Window? _window;
+
+    public App()
+    {
+        this.InitializeComponent();
+    }
+
+    protected override void OnLaunched(LaunchActivatedEventArgs args)
+    {
+        _window = new MainWindow();
+        _window.Activate();
+    }
+}

FastSeek.WinUI/FastSeek.WinUI.csproj

@@ -0,0 +1,27 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <OutputType>WinExe</OutputType>
+    <TargetFramework>net8.0-windows10.0.19041.0</TargetFramework>
+    <TargetPlatformMinVersion>10.0.17763.0</TargetPlatformMinVersion>
+    <RootNamespace>FastSeek.WinUI</RootNamespace>
+    <ApplicationManifest>app.manifest</ApplicationManifest>
+    <Platforms>x64</Platforms>
+    <RuntimeIdentifier>win-x64</RuntimeIdentifier>
+    <UseWinUI>true</UseWinUI>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+
+    <WindowsPackageType>None</WindowsPackageType>
+    <AppxPackage>false</AppxPackage>
+    <EnableMsixTooling>false</EnableMsixTooling>
+    <WindowsAppSdkSelfContained>true</WindowsAppSdkSelfContained>
+    <GenerateAppxPackageOnBuild>false</GenerateAppxPackageOnBuild>
+    <EnablePreviewMsixTooling>false</EnablePreviewMsixTooling>
+  </PropertyGroup>
+  <ItemGroup>
+    <PackageReference Include="Microsoft.WindowsAppSDK" Version="1.6.250205002" />
+  </ItemGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\FastSeek.Core\FastSeek.Core.csproj" />
+  </ItemGroup>
+</Project>

FastSeek.WinUI/MainWindow.xaml

@@ -0,0 +1,35 @@
+<Window
+    x:Class="FastSeek.WinUI.MainWindow"
+    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+    mc:Ignorable="d"
+    Title="FastSeek">
+    <Grid Background="{StaticResource BgBrush}">
+        <Border Width="860" CornerRadius="18" Background="{StaticResource PanelBrush}" BorderBrush="#2F3B44" BorderThickness="1" Padding="14" HorizontalAlignment="Center" VerticalAlignment="Center">
+            <Grid RowDefinitions="Auto,*">
+                <AutoSuggestBox x:Name="SearchBox" PlaceholderText="Search files and folders..." QueryIcon="Find" TextChanged="SearchBox_TextChanged" KeyDown="SearchBox_KeyDown" FontSize="20" Background="#14191D" BorderBrush="#2A333A" Foreground="White" />
+                <ListView x:Name="ResultsList" Grid.Row="1" Margin="0,12,0,0" IsItemClickEnabled="True" ItemClick="ResultsList_ItemClick" SelectionMode="Single" Background="Transparent" Foreground="White">
+                    <ListView.ItemTemplate>
+                        <DataTemplate>
+                            <Grid Padding="8,6">
+                                <Grid.ColumnDefinitions>
+                                    <ColumnDefinition Width="58"/>
+                                    <ColumnDefinition Width="*"/>
+                                </Grid.ColumnDefinitions>
+                                <Border Grid.Column="0" Background="#132028" CornerRadius="8" Padding="8,3">
+                                    <TextBlock Text="{Binding Kind}" Foreground="{StaticResource AccentBrush}" FontWeight="SemiBold"/>
+                                </Border>
+                                <StackPanel Grid.Column="1" Margin="10,0,0,0">
+                                    <TextBlock Text="{Binding Name}" FontSize="15" TextTrimming="CharacterEllipsis"/>
+                                    <TextBlock Text="{Binding FullPath}" FontSize="12" Foreground="#B9C2CC" TextTrimming="CharacterEllipsis"/>
+                                </StackPanel>
+                            </Grid>
+                        </DataTemplate>
+                    </ListView.ItemTemplate>
+                </ListView>
+            </Grid>
+        </Border>
+    </Grid>
+</Window>

FastSeek.WinUI/MainWindow.xaml.cs

@@ -0,0 +1,147 @@
+using System.Collections.ObjectModel;
+using System.Diagnostics;
+using FastSeek.Core;
+using FastSeek.Core.Search;
+using Microsoft.UI.Input;
+using Microsoft.UI.Windowing;
+using Microsoft.UI.Xaml;
+using Microsoft.UI.Xaml.Controls;
+using Microsoft.UI.Xaml.Input;
+using Windows.System;
+
+namespace FastSeek.WinUI;
+
+public sealed partial class MainWindow : Window
+{
+    private readonly FastSeekEngine _engine = new();
+    private readonly ObservableCollection<ResultItem> _items = new();
+
+    public MainWindow()
+    {
+        this.InitializeComponent();
+        ResultsList.ItemsSource = _items;
+        ExtendsContentIntoTitleBar = true;
+        this.Closed += (_, _) => _engine.Dispose();
+        SetSpotlightSizing();
+        _ = InitializeEngineAsync();
+    }
+
+    private async Task InitializeEngineAsync()
+    {
+        SearchBox.PlaceholderText = "Indexing NTFS drives...";
+        try
+        {
+            await _engine.InitializeAsync();
+            SearchBox.PlaceholderText = "Search files and folders...";
+        }
+        catch (Exception ex)
+        {
+            SearchBox.PlaceholderText = "Initialization failed";
+            _items.Clear();
+            _items.Add(new ResultItem { Kind = "ERR", Name = "Could not initialize index", FullPath = ex.Message, Raw = null });
+        }
+    }
+
+    private void SetSpotlightSizing()
+    {
+        var hwnd = WinRT.Interop.WindowNative.GetWindowHandle(this);
+        var id = Microsoft.UI.Win32Interop.GetWindowIdFromWindow(hwnd);
+        var appWindow = AppWindow.GetFromWindowId(id);
+        appWindow.Resize(new Windows.Graphics.SizeInt32(900, 560));
+        if (appWindow.Presenter is OverlappedPresenter p)
+        {
+            p.IsMaximizable = false;
+            p.IsMinimizable = true;
+            p.IsResizable = true;
+        }
+    }
+
+    private async void SearchBox_TextChanged(AutoSuggestBox sender, AutoSuggestBoxTextChangedEventArgs args)
+    {
+        if (args.Reason != AutoSuggestionBoxTextChangeReason.UserInput) return;
+        var query = sender.Text;
+        var results = await Task.Run(() => _engine.Search(query, 50));
+        RenderResults(results);
+    }
+
+    private void RenderResults(List<SearchResult> results)
+    {
+        _items.Clear();
+        foreach (var r in results)
+        {
+            _items.Add(new ResultItem
+            {
+                Kind = r.IsDir ? "DIR" : "FILE",
+                Name = r.Name,
+                FullPath = r.FullPath,
+                Raw = r,
+            });
+        }
+        if (_items.Count > 0) ResultsList.SelectedIndex = 0;
+    }
+
+    private void SearchBox_KeyDown(object sender, KeyRoutedEventArgs e)
+    {
+        if (e.Key == VirtualKey.Down)
+        {
+            if (_items.Count == 0) return;
+            var i = Math.Min(ResultsList.SelectedIndex + 1, _items.Count - 1);
+            ResultsList.SelectedIndex = i;
+            ResultsList.ScrollIntoView(_items[i]);
+            e.Handled = true;
+        }
+        else if (e.Key == VirtualKey.Up)
+        {
+            if (_items.Count == 0) return;
+            var i = Math.Max(ResultsList.SelectedIndex - 1, 0);
+            ResultsList.SelectedIndex = i;
+            ResultsList.ScrollIntoView(_items[i]);
+            e.Handled = true;
+        }
+        else if (e.Key == VirtualKey.Enter)
+        {
+            OpenSelected();
+            e.Handled = true;
+        }
+        else if (e.Key == VirtualKey.Escape)
+        {
+            this.Close();
+        }
+    }
+
+    private void ResultsList_ItemClick(object sender, ItemClickEventArgs e) => OpenSelected();
+
+    private void OpenSelected()
+    {
+        if (ResultsList.SelectedItem is not ResultItem item) return;
+        try
+        {
+            Process.Start(new ProcessStartInfo
+            {
+                FileName = item.FullPath,
+                UseShellExecute = true,
+            });
+        }
+        catch
+        {
+            try
+            {
+                Process.Start(new ProcessStartInfo
+                {
+                    FileName = "explorer.exe",
+                    Arguments = $"/select,\"{item.FullPath}\"",
+                    UseShellExecute = true,
+                });
+            }
+            catch { }
+        }
+    }
+
+    private sealed class ResultItem
+    {
+        public required string Kind { get; init; }
+        public required string Name { get; init; }
+        public required string FullPath { get; init; }
+        public SearchResult? Raw { get; init; }
+    }
+}

FastSeek.WinUI/app.manifest

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8"?>
+<assembly manifestVersion="1.0" xmlns="urn:schemas-microsoft-com:asm.v1">
+  <assemblyIdentity version="1.0.0.0" name="FastSeek.WinUI.app"/>
+  <compatibility xmlns="urn:schemas-microsoft-com:compatibility.v1">
+    <application>
+      <supportedOS Id="{8e0f7a12-bfb3-4fe8-b9a5-48fd50a15a9a}" />
+    </application>
+  </compatibility>
+</assembly>

global.json

@@ -0,0 +1,5 @@
+{
+  "sdk": {
+    "version": "10.0.203"
+  }
+}