Function bodies 845 total

    pub fn new(
        lookup: Vec<u16>,
        dense_data: Vec<u64>,
        dense_count: usize,
        words: usize,
        file_count: usize,
        populated: usize,
    ) -> Self {
        Self {
            lookup,
            dense_data,
            dense_count,
            words,
            file_count,
            populated,
            skip_index: None,
        }
    }

pub fn extract_bigrams(content: &[u8]) -> Vec<u16> {
    if content.len() < 2 {
        return Vec::new();
    }
    // Use a flat bitset (65536 bits = 8 KB) for dedup — faster than HashSet.
    let mut seen = vec![0u64; 1024]; // 1024 * 64 = 65536 bits
    let mut bigrams = Vec::new();

    let mut prev = content[0];
    for &b in &content[1..] {
        if (32..=126).contains(&prev) && (32..=126).contains(&b) {
            let key = (prev.to_ascii_lowercase() as u16) << 8 | b.to_ascii_lowercase() as u16;
            let word = key as usize / 64;
            let bit = 1u64 << (key as usize % 64);
            if seen[word] & bit == 0 {
                seen[word] |= bit;
                bigrams.push(key);
            }
        }
        prev = b;
    }
    bigrams
}

    pub(crate) fn new(base_file_count: usize) -> Self {
        let words = base_file_count.div_ceil(64);
        Self {
            modified: AHashMap::new(),
            tombstones: vec![0u64; words],
            base_file_count,
        }
    }

    pub(crate) fn modify_file(&mut self, file_idx: usize, content: &[u8]) {
        self.modified.insert(file_idx, extract_bigrams(content));
    }

    pub(crate) fn delete_file(&mut self, file_idx: usize) {
        if file_idx < self.base_file_count {
            let word = file_idx / 64;
            self.tombstones[word] |= 1u64 << (file_idx % 64);
        }
        self.modified.remove(&file_idx);
    }

    pub(crate) fn query_modified(&self, pattern_bigrams: &[u16]) -> Vec<usize> {
        if pattern_bigrams.is_empty() {
            return self.modified.keys().copied().collect();
        }
        self.modified
            .iter()
            .filter_map(|(&file_idx, bigrams)| {
                pattern_bigrams
                    .iter()
                    .all(|pb| bigrams.contains(pb))
                    .then_some(file_idx)
            })
            .collect()
    }

    pub(crate) fn base_file_count(&self) -> usize {
        self.base_file_count
    }

    pub(crate) fn tombstones(&self) -> &[u64] {
        &self.tombstones
    }

fn ascii_fold_byte(b: u8) -> u8 {
    if b.is_ascii_uppercase() { b | 0x20 } else { b }
}

fn ascii_swap_case(b: u8) -> u8 {
    b ^ 0x20
}

fn case_insensitive_rank(lower: u8) -> u8 {
    if lower.is_ascii_lowercase() {
        let upper = ascii_swap_case(lower);
        BYTE_FREQUENCIES[lower as usize].max(BYTE_FREQUENCIES[upper as usize])
    } else {
        BYTE_FREQUENCIES[lower as usize]
    }
}

fn select_rare_pair(needle_lower: &[u8]) -> (usize, usize) {
    debug_assert!(needle_lower.len() >= 2);

    let mut best1 = (u8::MAX, 0usize); // (rank, position)
    let mut best2 = (u8::MAX, 1usize);

    for (i, &b) in needle_lower.iter().enumerate() {
        let r = case_insensitive_rank(b);
        if r < best1.0 {
            best2 = best1;
            best1 = (r, i);
        } else if r < best2.0 && i != best1.1 {
            best2 = (r, i);
        }
    }

    let i1 = best1.1.min(best2.1);
    let i2 = best1.1.max(best2.1);
    (i1, i2)
}

fn verify_scalar(h: *const u8, needle_lower: &[u8]) -> bool {
    for (i, _) in needle_lower.iter().enumerate() {
        if ascii_fold_byte(unsafe { *h.add(i) }) != needle_lower[i] {
            return false;
        }
    }
    true
}

unsafe fn verify_avx2(h: *const u8, needle_lower: &[u8]) -> bool {
    use core::arch::x86_64::*;

    let len = needle_lower.len();
    let mut i = 0usize;

    // Broadcast constants used every iteration:
    //
    //   flip      = 0x80 in every lane — XOR converts unsigned→signed domain
    //   a_minus_1 = ('A' - 1) ^ 0x80  — lower bound for the range check (signed)
    //   z_plus_1  = ('Z' + 1) ^ 0x80  — upper bound for the range check (signed)
    //   bit20     = 0x20 in every lane — OR this onto uppercase bytes to lowercase them
    let flip = _mm256_set1_epi8(0x80u8 as i8);
    let a_minus_1 = _mm256_set1_epi8((b'A' - 1) as i8 ^ 0x80u8 as i8);
    let z_plus_1 = _mm256_set1_epi8((b'Z' + 1) as i8 ^ 0x80u8 as i8);
    let bit20 = _mm256_set1_epi8(0x20u8 as i8);

    while i + 32 <= len {
        // Load 32 bytes from the haystack candidate position.
        let hv = unsafe { _mm256_loadu_si256(h.add(i) as *const __m256i) };
        // Load 32 bytes from the pre-lowercased need

unsafe fn neon_movemask(v: core::arch::aarch64::uint8x16_t) -> u16 {
    use core::arch::aarch64::*;

    // AND each byte with its bit-position mask, then horizontally sum each half.
    // Max possible sum per half = 1+2+4+8+16+32+64+128 = 255, fits in u8.
    static BITS: [u8; 16] = [1, 2, 4, 8, 16, 32, 64, 128, 1, 2, 4, 8, 16, 32, 64, 128];
    let bit_mask = unsafe { vld1q_u8(BITS.as_ptr()) };
    let masked = vandq_u8(v, bit_mask);
    let lo = vaddv_u8(vget_low_u8(masked));
    let hi = vaddv_u8(vget_high_u8(masked));
    (lo as u16) | ((hi as u16) << 8)
}

unsafe fn verify_neon_dotprod(h: *const u8, needle_lower: &[u8]) -> bool {
    use core::arch::aarch64::*;

    let len = needle_lower.len();
    let mut i = 0usize;

    let a_val = vdupq_n_u8(b'A');
    let z_val = vdupq_n_u8(b'Z');
    let bit20 = vdupq_n_u8(0x20);

    while i + 16 <= len {
        let hv = unsafe { vld1q_u8(h.add(i)) };
        let nv = unsafe { vld1q_u8(needle_lower.as_ptr().add(i)) };

        // Unsigned range check: 'A' <= byte <= 'Z'
        let upper = vandq_u8(vcgeq_u8(hv, a_val), vcleq_u8(hv, z_val));
        // Case-fold: set bit 5 on uppercase bytes → 'A'..'Z' → 'a'..'z'
        let folded = vorrq_u8(hv, vandq_u8(upper, bit20));

        // XOR with needle — all-zero iff every byte matches.
        let xored = veorq_u8(folded, nv);

        // UDOT: dot(xored, xored) sums squares of 4 consecutive byte
        // differences into each of the 4 u32 lanes (accumulates into zero).
        // Any non-zero byte produces a positive u32 contribution.
        let

unsafe fn search_packed_pair_neon(
    haystack: &[u8],
    needle_lower: &[u8],
    i1: usize,
    i2: usize,
) -> bool {
    use core::arch::aarch64::*;

    let n = needle_lower.len();
    let hlen = haystack.len();
    let ptr = haystack.as_ptr();
    let last_start = hlen - n;

    let b1 = needle_lower[i1];
    let b1_alt = if b1.is_ascii_lowercase() {
        ascii_swap_case(b1)
    } else {
        b1
    };
    let b2 = needle_lower[i2];
    let b2_alt = if b2.is_ascii_lowercase() {
        ascii_swap_case(b2)
    } else {
        b2
    };

    let v1_lo = vdupq_n_u8(b1);
    let v1_hi = vdupq_n_u8(b1_alt);
    let v2_lo = vdupq_n_u8(b2);
    let v2_hi = vdupq_n_u8(b2_alt);

    let max_idx = i1.max(i2);
    let max_offset = hlen.saturating_sub(max_idx + 16);
    let mut offset = 0usize;

    while offset <= max_offset {
        let chunk1 = unsafe { vld1q_u8(ptr.add(offset + i1)) };
        let chunk2 = unsafe { vld1q_u8(ptr.add(offset + i2)) };

        // Case-insensitive 

unsafe fn verify_dispatch(h: *const u8, needle_lower: &[u8]) -> bool {
    #[cfg(target_arch = "x86_64")]
    {
        if needle_lower.len() >= 32 && std::is_x86_feature_detected!("avx2") {
            return unsafe { verify_avx2(h, needle_lower) };
        }
    }
    #[cfg(target_arch = "aarch64")]
    {
        if needle_lower.len() >= 16 && std::arch::is_aarch64_feature_detected!("dotprod") {
            return unsafe { verify_neon_dotprod(h, needle_lower) };
        }
    }

    verify_scalar(h, needle_lower)
}

unsafe fn search_packed_pair_avx2(
    haystack: &[u8],
    needle_lower: &[u8],
    i1: usize,
    i2: usize,
) -> bool {
    use core::arch::x86_64::*;

    let n = needle_lower.len();
    let hlen = haystack.len();
    let ptr = haystack.as_ptr();
    let last_start = hlen - n; // last valid match-start position

    let b1 = needle_lower[i1];
    let b1_alt = if b1.is_ascii_lowercase() {
        ascii_swap_case(b1)
    } else {
        b1
    };
    let b2 = needle_lower[i2];
    let b2_alt = if b2.is_ascii_lowercase() {
        ascii_swap_case(b2)
    } else {
        b2
    };

    let v1_lo = _mm256_set1_epi8(b1 as i8);
    let v1_hi = _mm256_set1_epi8(b1_alt as i8);
    let v2_lo = _mm256_set1_epi8(b2 as i8);
    let v2_hi = _mm256_set1_epi8(b2_alt as i8);

    // Main loop: process 32 candidate positions per iteration.
    // We load from ptr+offset+i1 and ptr+offset+i2, so we need
    // offset + max(i1,i2) + 31 < hlen.
    let max_idx = i1.max(i2);
    let max_offset = hlen.

pub fn search_packed_pair(haystack: &[u8], needle_lower: &[u8]) -> bool {
    let n = needle_lower.len();
    if n == 0 {
        return true;
    }
    if n < 2 {
        return search(haystack, needle_lower);
    }
    if n > haystack.len() {
        return false;
    }

    let (i1, i2) = select_rare_pair(needle_lower);

    #[cfg(target_arch = "x86_64")]
    {
        if std::is_x86_feature_detected!("avx2") {
            // Need enough haystack for at least one vector load.
            let max_idx = i1.max(i2);
            if haystack.len() >= max_idx + 32 {
                return unsafe { search_packed_pair_avx2(haystack, needle_lower, i1, i2) };
            }
        }
    }

    #[cfg(target_arch = "aarch64")]
    {
        // The NEON packed-pair scan checks 16 bytes/iteration with ~7 ops,
        // while memchr's optimized loop processes more bytes with fewer ops.
        // Packed-pair wins when the first byte is common (lots of false
        // positives for memchr2 that w

pub fn search(haystack: &[u8], needle_lower: &[u8]) -> bool {
    let n = needle_lower.len();
    if n == 0 {
        return true;
    }
    if n > haystack.len() {
        return false;
    }

    let search_space = &haystack[..=haystack.len() - n];
    let first = needle_lower[0];

    if first.is_ascii_lowercase() {
        let alt = ascii_swap_case(first);
        for pos in memchr::memchr2_iter(first, alt, search_space) {
            if unsafe { verify_dispatch(haystack.as_ptr().add(pos), needle_lower) } {
                return true;
            }
        }
    } else {
        for pos in memchr::memchr_iter(first, search_space) {
            if unsafe { verify_dispatch(haystack.as_ptr().add(pos), needle_lower) } {
                return true;
            }
        }
    }
    false
}

    fn basic_case_insensitive() {
        assert!(search_packed_pair(b"Hello World", b"hello"));
        assert!(search_packed_pair(b"Hello World", b"world"));
        assert!(search_packed_pair(b"NOMORE bugs", b"nomore"));
        assert!(!search_packed_pair(b"Hello World", b"xyz"));
    }

    fn edge_cases() {
        assert!(search_packed_pair(b"ab", b"ab"));
        assert!(search_packed_pair(b"AB", b"ab"));
        assert!(!search_packed_pair(b"a", b"ab"));
        assert!(search_packed_pair(b"anything", b""));
        assert!(!search_packed_pair(b"", b"x"));
    }

    fn packed_pair_matches_search() {
        let haystacks: &[&[u8]] = &[
            b"The quick brown fox jumps over the lazy dog",
            b"int mutex_lock(struct mutex *lock) { return 0; }",
            b"#define NOMORE_RETRIES 5\nif (nomore) return;",
            b"abcdefghijklmnopqrstuvwxyz",
            b"short",
        ];
        let needles: &[&[u8]] = &[b"fox", b"mutex", b"nomore", b"xyz", b"the", b"short", b"qr"];
        for h in haystacks {
            for n in needles {
                let lower: Vec<u8> = n.iter().map(|b| b.to_ascii_lowercase()).collect();
                assert_eq!(
                    search_packed_pair(h, &lower),
                    search(h, &lower),
                    "mismatch for haystack={:?} needle={:?}",
                    std::str::from_utf8(h),
                    std::str::from_utf8(n),
                );
            }
        }
    }

    fn long_haystack_neon_path() {
        // Haystack > 16 bytes exercises NEON packed-pair search loop
        let haystack =
            b"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaTHIS_IS_A_LONG_NEEDLE_TESTbbbbbbbbbbbbbbbbbb";
        assert!(search_packed_pair(haystack, b"this_is_a_long_needle_test"));
        assert!(!search_packed_pair(
            haystack,
            b"this_is_a_long_needle_testz"
        ));

        // Needle >= 16 bytes exercises NEON dotprod verify
        let long_needle = b"struct mutex *lock";
        let haystack2 = b"int STRUCT MUTEX *LOCK(struct mutex *lock) { return 0; }";
        assert!(search_packed_pair(haystack2, long_needle));

        // All uppercase haystack, lowercase needle
        let upper_hay = b"ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
        assert!(search_packed_pair(upper_hay, b"qrstuvwxyz0123456789a"));
        assert!(!search_packed_pair(upper_hay, b"qrstuvwxyz01234567899"));

        // Needle at very end
       

    fn rare_pair_selection() {
        // For "nomore": n=246, o=244, m=233, o=244, r=245, e=253
        // Rarest positions should include 'm' (pos 2, rank 233)
        let (i1, i2) = select_rare_pair(b"nomore");
        let ranks: Vec<u8> = b"nomore"
            .iter()
            .map(|&b| case_insensitive_rank(b))
            .collect();
        let r1 = ranks[i1];
        let r2 = ranks[i2];
        // Both selected ranks should be <= all other ranks
        for (i, &r) in ranks.iter().enumerate() {
            if i != i1 && i != i2 {
                assert!(r1 <= r || r2 <= r, "pair ({i1},{i2}) not optimal");
            }
        }
    }

fn contains_ascii_ci(haystack: &str, needle: &str) -> bool {
    let h = haystack.as_bytes();
    let n = needle.as_bytes();
    if n.len() > h.len() {
        return false;
    }
    if n.is_empty() {
        return true;
    }
    let first = n[0];
    for i in 0..=(h.len() - n.len()) {
        if h[i].to_ascii_lowercase() == first
            && h[i..i + n.len()]
                .iter()
                .zip(n)
                .all(|(a, b)| a.to_ascii_lowercase() == *b)
        {
            return true;
        }
    }
    false
}

pub fn path_ends_with_suffix(path: &str, suffix: &str) -> bool {
    if path.len() < suffix.len() {
        return false;
    }
    let start = path.len() - suffix.len();
    if !path[start..].eq_ignore_ascii_case(suffix) {
        return false;
    }
    // Exact match, or the character before is /
    start == 0 || path.as_bytes()[start - 1] == b'/'
}

pub fn file_has_extension(file_name: &str, ext: &str) -> bool {
    if file_name.len() <= ext.len() + 1 {
        return false;
    }
    let start = file_name.len() - ext.len() - 1;
    file_name.as_bytes().get(start) == Some(&b'.')
        && file_name[start + 1..].eq_ignore_ascii_case(ext)
}

pub fn path_contains_segment(path: &str, segment: &str) -> bool {
    let path_bytes = path.as_bytes();
    let segment_len = segment.len();

    // Check segment/ at start of path
    if path.len() > segment_len
        && path_bytes.get(segment_len) == Some(&b'/')
        && path[..segment_len].eq_ignore_ascii_case(segment)
    {
        return true;
    }

    // Check /segment/ anywhere using byte scanning
    if path.len() < segment_len + 2 {
        return false;
    }

    for i in 0..path.len().saturating_sub(segment_len + 1) {
        if path_bytes[i] == b'/' {
            let start = i + 1;
            let end = start + segment_len;
            if end < path.len()
                && path_bytes[end] == b'/'
                && path[start..end].eq_ignore_ascii_case(segment)
            {
                return true;
            }
        }
    }
    false
}

pub fn apply_constraints<'a, T: Constrainable + Sync>(
    items: &'a [T],
    constraints: &[Constraint<'_>],
) -> Option<Vec<&'a T>> {
    if constraints.is_empty() {
        return None;
    }

    // Separate extension constraints from other constraints — they use OR logic
    let mut extensions: SmallVec<[&str; 8]> = SmallVec::new();
    let mut other_constraints: SmallVec<[&Constraint<'_>; 8]> = SmallVec::new();

    for constraint in constraints {
        match constraint {
            Constraint::Extension(ext) => extensions.push(ext),
            _ => other_constraints.push(constraint),
        }
    }

    // Only collect paths if we have glob constraints (expensive)
    let has_globs = other_constraints
        .iter()
        .any(|c| matches!(c, Constraint::Glob(_) | Constraint::Not(_)));

    let glob_results = if has_globs {
        let paths: Vec<&str> = items.iter().map(|f| f.relative_path()).collect();
        precompute_glob_matches(&other_constraints, &paths)
    } 

fn precompute_glob_matches<'a>(
    constraints: &[&Constraint<'a>],
    paths: &[&str],
) -> Vec<(bool, AHashSet<usize>)> {
    let mut results = Vec::new();
    for constraint in constraints {
        collect_glob_indices(constraint, paths, &mut results, false);
    }
    results
}

fn match_glob_pattern(pattern: &str, paths: &[&str]) -> AHashSet<usize> {
    let Ok(Some(matches)) = zlob::zlob_match_paths(pattern, paths, zlob::ZlobFlags::RECOMMENDED)
    else {
        return AHashSet::new();
    };

    let matched_set: AHashSet<usize> = matches.iter().map(|s| s.as_ptr() as usize).collect();

    if paths.len() >= PAR_THRESHOLD {
        use rayon::prelude::*;
        paths
            .par_iter()
            .enumerate()
            .filter(|(_, p)| matched_set.contains(&(p.as_ptr() as usize)))
            .map(|(i, _)| i)
            .collect::<Vec<_>>()
            .into_iter()
            .collect()
    } else {
        paths
            .iter()
            .enumerate()
            .filter(|(_, p)| matched_set.contains(&(p.as_ptr() as usize)))
            .map(|(i, _)| i)
            .collect()
    }
}

fn match_glob_pattern(pattern: &str, paths: &[&str]) -> AHashSet<usize> {
    let Ok(glob) = globset::Glob::new(pattern) else {
        return AHashSet::new();
    };
    let matcher = glob.compile_matcher();

    if paths.len() >= PAR_THRESHOLD {
        use rayon::prelude::*;
        paths
            .par_iter()
            .enumerate()
            .filter(|(_, p)| matcher.is_match(p))
            .map(|(i, _)| i)
            .collect::<Vec<_>>()
            .into_iter()
            .collect()
    } else {
        paths
            .iter()
            .enumerate()
            .filter(|(_, p)| matcher.is_match(p))
            .map(|(i, _)| i)
            .collect()
    }
}

    fn test_file_has_extension() {
        assert!(file_has_extension("file.rs", "rs"));
        assert!(file_has_extension("file.RS", "rs")); // case-insensitive
        assert!(file_has_extension("file.test.rs", "rs"));
        assert!(file_has_extension("a.rs", "rs"));

        assert!(!file_has_extension("file.tsx", "rs"));
        assert!(!file_has_extension("rs", "rs")); // too short
        assert!(!file_has_extension(".rs", "rs")); // just extension
        assert!(!file_has_extension("file.rsx", "rs")); // different extension
        assert!(!file_has_extension("filers", "rs")); // no dot
    }

    fn test_path_contains_segment() {
        // Segment at start
        assert!(path_contains_segment("src/lib.rs", "src"));
        assert!(path_contains_segment("SRC/lib.rs", "src")); // case-insensitive

        // Segment in middle
        assert!(path_contains_segment("app/src/lib.rs", "src"));
        assert!(path_contains_segment("app/SRC/lib.rs", "src"));

        // Multiple levels
        assert!(path_contains_segment("core/workflow/src/main.rs", "src"));
        assert!(path_contains_segment(
            "core/workflow/src/main.rs",
            "workflow"
        ));
        assert!(path_contains_segment("core/workflow/src/main.rs", "core"));

        // Should not match partial segments
        assert!(!path_contains_segment("source/lib.rs", "src"));
        assert!(!path_contains_segment("mysrc/lib.rs", "src"));

        // Should not match filename
        assert!(!path_contains_segment("lib/src", "src"));

        // Multi-segment constraints
        assert!(path_conta

    fn test_path_ends_with_suffix() {
        // Exact match
        assert!(path_ends_with_suffix(
            "libswscale/input.c",
            "libswscale/input.c"
        ));

        // Suffix match at / boundary
        assert!(path_ends_with_suffix(
            "foo/libswscale/input.c",
            "libswscale/input.c"
        ));

        // Deep nesting
        assert!(path_ends_with_suffix(
            "a/b/c/libswscale/input.c",
            "libswscale/input.c"
        ));

        // No boundary — partial directory name
        assert!(!path_ends_with_suffix(
            "xlibswscale/input.c",
            "libswscale/input.c"
        ));

        // Case insensitive
        assert!(path_ends_with_suffix(
            "foo/LibSwscale/Input.C",
            "libswscale/input.c"
        ));

        // Single file name
        assert!(path_ends_with_suffix("input.c", "input.c"));
        assert!(!path_ends_with_suffix("xinput.c", "input.c"));

        // Suffix longer than path

    fn get_health(&self) -> Result<DbHealth> {
        let env = self.get_env();

        let size = env.real_disk_size().map_err(crate::error::Error::EnvOpen)?;
        let path = env.path().to_string_lossy().to_string();
        let entry_counts = self.count_entries()?;

        Ok(DbHealth {
            path,
            disk_size: size,
            entry_counts,
        })
    }

    pub fn is_ai(self) -> bool {
        self == FFFMode::Ai
    }

    fn new() -> Self {
        Self {
            files: Vec::new(),
            base_count: 0,
            git_workdir: None,
            bigram_index: None,
            bigram_overlay: None,
        }
    }

    fn files(&self) -> &[FileItem] {
        &self.files
    }

    fn overflow_files(&self) -> &[FileItem] {
        &self.files[self.base_count..]
    }

    fn get_file(&self, index: usize) -> Option<&FileItem> {
        self.files.get(index)
    }

    fn get_file_mut(&mut self, index: usize) -> Option<&mut FileItem> {
        self.files.get_mut(index)
    }

    fn find_file_index(&self, path: &Path) -> Result<usize, usize> {
        self.files[..self.base_count].binary_search_by(|f| f.as_path().cmp(path))
    }

    fn find_overflow_index(&self, path: &Path) -> Option<usize> {
        self.files[self.base_count..]
            .iter()
            .position(|f| f.as_path() == path)
            .map(|pos| self.base_count + pos)
    }

    fn len(&self) -> usize {
        self.files.len()
    }

    fn insert_file(&mut self, position: usize, file: FileItem) {
        self.files.insert(position, file);
    }

    fn remove_file(&mut self, index: usize) {
        if index < self.files.len() {
            self.files.remove(index);
        }
    }

    fn retain_files<F>(&mut self, mut predicate: F) -> usize
    where
        F: FnMut(&FileItem) -> bool,
    {
        let initial_len = self.files.len();
        // Count how many base files survive.
        let base_retained = self.files[..self.base_count]
            .iter()
            .filter(|f| predicate(f))
            .count();
        self.files.retain(predicate);
        self.base_count = base_retained;
        initial_len - self.files.len()
    }