dmtrKovalenko
diff --git a/‎.github/workflows/rust.yml‎
Lines changed: 3 additions & 2 deletions b/‎.github/workflows/rust.yml‎
Lines changed: 3 additions & 2 deletions
diff --git a/‎crates/fff-core/src/constraints.rs‎
Lines changed: 90 additions & 27 deletions b/‎crates/fff-core/src/constraints.rs‎
Lines changed: 90 additions & 27 deletions
@@ -17,11 +17,12 @@ jobs:
     name: Test
     runs-on: ${{ matrix.os }}
     strategy:
+      fail-fast: false
       matrix:
-        os: [ubuntu-latest, macos-latest]
+        os: [ubuntu-latest, macos-latest, windows-latest]
     # Guard against deadlocks in the shared-picker / watcher teardown
     # path: a stuck test would otherwise consume a full 6h CI slot.
-    timeout-minutes: 10
+    timeout-minutes: 15
     steps:
       - uses: actions/checkout@v5
 
 
@@ -40,15 +40,34 @@ pub(crate) trait Constrainable {
     fn write_relative_path(&self, arena: ArenaPtr, out: &mut String);
 }
 
-/// Check if a relative path ends with the given suffix at a `/` boundary (case-insensitive).
-///
-/// Returns `true` when the path equals the suffix or the character before the suffix
-/// in the path is `/`. This ensures partial directory-name matches are rejected.
-///
-/// Examples:
-/// - `path_ends_with_suffix("libswscale/input.c", "libswscale/input.c")` → true (exact)
-/// - `path_ends_with_suffix("foo/libswscale/input.c", "libswscale/input.c")` → true (suffix)
-/// - `path_ends_with_suffix("xlibswscale/input.c", "libswscale/input.c")` → false (no boundary)
+/// Windows stores paths with `\\`; `/` comes from user queries.
+#[inline]
+fn is_path_sep(b: u8) -> bool {
+    #[cfg(windows)]
+    {
+        b == b'/' || b == b'\\'
+    }
+    #[cfg(not(windows))]
+    {
+        b == b'/'
+    }
+}
+
+#[inline]
+fn path_slice_eq(a: &[u8], b: &[u8]) -> bool {
+    if a.len() != b.len() {
+        return false;
+    }
+    a.iter().zip(b).all(|(x, y)| {
+        if is_path_sep(*x) && is_path_sep(*y) {
+            true
+        } else {
+            x.eq_ignore_ascii_case(y)
+        }
+    })
+}
+
+/// Path ends with suffix at a path-separator boundary (case-insensitive).
 #[inline]
 pub fn path_ends_with_suffix(path: &str, suffix: &str) -> bool {
     let path_bytes = path.as_bytes();
@@ -59,28 +78,25 @@ pub fn path_ends_with_suffix(path: &str, suffix: &str) -> bool {
 
     let start = path.len() - suffix.len();
 
-    // Must land on a char boundary — multi-byte UTF-8 can make
-    // `path.len() - suffix.len()` land inside a char.
+    // Multi-byte UTF-8 may put `start` inside a char.
     if !path.is_char_boundary(start) {
         return false;
     }
 
-    if !path[start..].eq_ignore_ascii_case(suffix) {
+    if !path_slice_eq(&path_bytes[start..], suffix_bytes) {
         return false;
     }
 
-    // Exact match, or the character before is '/'.
-    // `start` is a char boundary but `start - 1` may be inside a multi-byte
-    // char, so scan backward to find the preceding ASCII byte.
+    // Exact or preceded by a separator. Scan backward past any multi-byte
+    // continuation bytes to find the preceding ASCII byte.
     if start == 0 {
         return true;
     }
     let mut i = start;
     while i > 0 {
         i -= 1;
-        // ASCII bytes (0..128) are single-byte UTF-8 code units
         if path_bytes[i] < 128 {
-            return path_bytes[i] == b'/';
+            return is_path_sep(path_bytes[i]);
         }
     }
     false
@@ -94,44 +110,40 @@ pub fn file_has_extension(file_name: &str, ext: &str) -> bool {
         return false;
     }
     let start = name_bytes.len() - ext_bytes.len() - 1;
-    // `.` is ASCII (single byte), so `start` must be a char boundary.
-    // If it lands inside a multi-byte char the extension can't match.
     if start > 0 && !file_name.is_char_boundary(start) {
         return false;
     }
     name_bytes.get(start) == Some(&b'.') && name_bytes[start + 1..].eq_ignore_ascii_case(ext_bytes)
 }
 
-/// Supports multi-segment paths like "libswscale/aarch64" (consecutive components).
+/// Matches multi-segment queries like `libswscale/aarch64`.
 #[inline]
 pub fn path_contains_segment(path: &str, segment: &str) -> bool {
     let path_bytes = path.as_bytes();
     let segment_bytes = segment.as_bytes();
     let segment_len = segment_bytes.len();
 
-    // Check segment/ at start of path
     if path_bytes.len() > segment_len
-        && path_bytes.get(segment_len) == Some(&b'/')
+        && is_path_sep(path_bytes[segment_len])
         && path.is_char_boundary(segment_len)
-        && path_bytes[..segment_len].eq_ignore_ascii_case(segment_bytes)
+        && path_slice_eq(&path_bytes[..segment_len], segment_bytes)
     {
         return true;
     }
 
-    // Check /segment/ anywhere using byte scanning
     if path_bytes.len() < segment_len + 2 {
         return false;
     }
 
     for i in 0..path_bytes.len().saturating_sub(segment_len + 1) {
-        if path_bytes[i] == b'/' {
+        if is_path_sep(path_bytes[i]) {
             let start = i + 1;
             let end = start + segment_len;
             if end < path_bytes.len()
-                && path_bytes[end] == b'/'
+                && is_path_sep(path_bytes[end])
                 && path.is_char_boundary(start)
                 && path.is_char_boundary(end)
-                && path_bytes[start..end].eq_ignore_ascii_case(segment_bytes)
+                && path_slice_eq(&path_bytes[start..end], segment_bytes)
             {
                 return true;
             }
@@ -249,13 +261,21 @@ pub(crate) fn apply_constraints<'a, T: Constrainable + Sync>(
     let glob_results = if has_globs {
         // Build a single contiguous buffer of all relative paths + offset table.
         // One allocation for the buffer, one for offsets — NOT one String per file.
+        // On Windows we fold `\\` into `/` while copying so globset/zlob see a
+        // canonical separator. The rewrite is in place on bytes we just wrote.
         let mut path_buf = Vec::<u8>::new();
         let mut offsets = Vec::<(usize, usize)>::with_capacity(items.len());
         let mut tmp = String::with_capacity(64);
         for item in items.iter() {
             let start = path_buf.len();
             item.write_relative_path(arena, &mut tmp);
             path_buf.extend_from_slice(tmp.as_bytes());
+            #[cfg(windows)]
+            for b in &mut path_buf[start..] {
+                if *b == b'\\' {
+                    *b = b'/';
+                }
+            }
             offsets.push((start, path_buf.len() - start));
         }
         let path_refs: Vec<&str> = offsets
@@ -536,6 +556,32 @@ mod tests {
         assert!(!path_contains_segment("src", "src")); // no trailing slash
     }
 
+    #[cfg(windows)]
+    #[test]
+    fn test_path_contains_segment_accepts_backslash() {
+        assert!(path_contains_segment("src\\lib.rs", "src"));
+        assert!(path_contains_segment(
+            "app\\modules\\src\\services\\x.lua",
+            "src"
+        ));
+        assert!(path_contains_segment("app\\SRC\\x.lua", "src"));
+
+        assert!(path_contains_segment(
+            "foo\\libswscale\\aarch64\\input.S",
+            "libswscale/aarch64"
+        ));
+        assert!(path_contains_segment(
+            "crates\\fff-core\\src\\grep.rs",
+            "fff-core/src"
+        ));
+
+        assert!(!path_contains_segment("mysrc\\lib.rs", "src"));
+        assert!(!path_contains_segment(
+            "xlibswscale\\aarch64\\in.S",
+            "libswscale/aarch64"
+        ));
+    }
+
     #[test]
     fn test_path_ends_with_suffix() {
         // Exact match
@@ -580,6 +626,23 @@ mod tests {
         assert!(path_ends_with_suffix("crates/src/main.rs", "src/main.rs"));
     }
 
+    #[cfg(windows)]
+    #[test]
+    fn test_path_ends_with_suffix_accepts_backslash() {
+        assert!(path_ends_with_suffix(
+            "app\\modules\\src\\services\\handler.lua",
+            "services/handler.lua"
+        ));
+        assert!(path_ends_with_suffix(
+            "foo\\libswscale\\input.c",
+            "libswscale/input.c"
+        ));
+        assert!(!path_ends_with_suffix(
+            "xlibswscale\\input.c",
+            "libswscale/input.c"
+        ));
+    }
+
     #[test]
     fn test_path_ends_with_suffix_does_not_panic_on_unicode_suffix() {
         assert!(!path_ends_with_suffix("유니코드_파일_테스트.csv", "트.c"));