@pify/search 0.1.0 → 0.3.0

package/README.md

@@ -33,15 +33,27 @@ The other half is the shape of the question. `find` wants a glob; people want *"
 
 Three modes because three different questions get asked: the exact string, a shape, and *"something like this"* for when you do not know how it is spelled.
 
-## Two engines, one interface
+## Three engines, one interface
 
-**Fast path** — [`@ff-labs/fff-node`](https://github.com/dmtrKovalenko/fff), a Rust index with a live file watcher, typo-resistant matching, git status and frecency. It scans this whole suite in about 80ms. Installed as an *optional* dependency: if the platform binary lands, it is used.
+**native** — this package's own Rust core, `native/`, built with napi. It indexes this suite (417 files) in about **40ms** cold, and a literal search then reads the **5** files the trigram index says could match rather than all 417. Searches come back in about a millisecond. Its index is [stored between sessions](#the-index-survives-the-process), so the second start does not pay for the first.
 
-**Fallback** — pure TypeScript, no dependencies. A trigram index for content, a fuzzy scorer for paths, an `fs.watch` subscription to stay current. Slower, and it runs wherever pi runs.
+**fff** — [`@ff-labs/fff-node`](https://github.com/dmtrKovalenko/fff), used when it is installed and the native core is not. A mature engine with its own watcher and git integration.
 
-The fallback is the point. A native binary is a promise you cannot always keep: an unsupported platform, a locked-down install, a blocked postinstall — any of those, and a binary-only search extension is one that silently does nothing. `/search` says which engine is live.
+**builtin** — pure TypeScript, no dependencies, no binary. A trigram index for content, a fuzzy scorer for paths, an `fs.watch` subscription to stay current.
 
-Both are checked against each other on a real tree (`test/live/engines.mjs`, 21/21): the same files found, the same literal matches, the same refusal to search `node_modules`, and cursors that advance rather than repeat.
+The fallback is the point. A native binary is a promise you cannot always keep: an unsupported platform, a locked-down install, a blocked postinstall — any of those, and a binary-only search extension is one that silently does nothing.
+
+All three are checked against each other on a real tree (`test/live/engines.mjs`, **33/33**): the same files found, the same literal matches, the same refusal to search `node_modules`, cursors that advance rather than repeat — and native and builtin **rank identically**, because they share their scoring constants on purpose. Losing the binary should change how fast a search is, never how it is ordered. `/search` says which engine is live.
+
+### Building the native core
+
+```bash
+npm run build:native      # cargo build --release --manifest-path native/Cargo.toml
+```
+
+The result is picked up automatically from `native/target/release/`. CI builds and smoke-tests six targets — win32 x64/arm64, darwin x64/arm64, linux x64/arm64 — on every tag.
+
+**Honest status:** only `win32-x64` has been built and verified by hand; the other five are proven by CI and nothing more. Per-platform npm packages (`@pify/search-<triple>`) are not published yet, so an installed copy of this package uses fff if you have it and the TypeScript engine otherwise. The loader already looks for them, so publishing is additive.
 
 ## How the content index works
 
@@ -49,6 +61,32 @@ Every overlapping three-byte window of every text file is a *trigram*, packed in
 
 The index only ever **narrows**; every surviving candidate is still matched for real, so a wrong candidate costs time and never correctness. The rule that makes it safe: a pattern with nothing indexable — `\d+`, a fuzzy query, one branch of an alternation that could match anywhere — reports "no candidate set is safe" and everything is read. Confusing *that* with "nothing matched" is how an index starts silently hiding results, so the two are different values throughout.
 
+## The index survives the process
+
+An index rebuilt at every start is one you pay for at every start. The native engine writes its index to disk and, next time, reloads it and reconciles instead of re-reading the tree.
+
+Measured on a synthetic 20,000-file tree (`node native/bench.mjs 20000`):
+
+| | build | files read | grep |
+|---|---|---|---|
+| cold (no stored index) | 1320ms | 20,000 | <1ms |
+| warm (unchanged tree) | **188ms** | 0 | <1ms |
+
+**7×**, and the cost that remains is the directory walk, not the files. Editing one file re-reads one file.
+
+Correctness rests on a single rule: a stored entry is trusted only while its **size and mtime still match what is on disk**. Anything changed, new, or vanished is re-read before a query can see it. A cache that answers confidently for a file that has moved on is worse than no cache. The reload path is checked against the rebuild path on every supported platform (`native/persist.mjs`, run in CI) — same totals, same lines, same order — including that a corrupt or truncated index is *discarded* rather than half-trusted.
+
+Trigram lists are stored as varint deltas, which is what makes this worth doing at all: 881KB for this suite, ~2.2KB per file, about a third of the naive encoding. Reading a cache that is larger than the sources it summarises costs more than the rebuild it was meant to avoid.
+
+The index lives in the platform cache directory — `%LOCALAPPDATA%`, `~/Library/Caches`, `$XDG_CACHE_HOME` — keyed by a hash of the absolute root, never inside your working tree.
+
+| variable | effect |
+|---|---|
+| `PIFY_SEARCH_NO_CACHE=1` | never store an index; rebuild every start |
+| `PIFY_SEARCH_CACHE_DIR` | store indexes somewhere else |
+| `PIFY_SEARCH_TIMING=1` | print how long the walk, the reload and the inversion each took |
+| `PIFY_SEARCH_ENGINE` | `builtin` or `fff` to force an engine |
+
 ## Ranking
 
 Frecency decays on a three-day half-life — an agent session is shorter and more concentrated than a human's week, so yesterday's file should not outrank today's. Every `read`, `edit` or `write` in the session counts as an access. History is capped at seven days and 128 timestamps per file, so the store cannot grow without bound.
@@ -59,7 +97,7 @@ This package adds two tools; it does not replace `find`, `grep` or `multi_grep`.
 
 ## Command
 
-`/search` — which engine is running, the indexed root, and how many files it holds.
+`/search` — which engine is running, the indexed root, how many files it holds, and how much of the index came back from the stored copy rather than from disk.
 
 ## License
 

package/extensions/search.ts

@@ -30,6 +30,7 @@ import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 
 import { loadFff, type SearchEngine } from "../src/engine.ts";
+import { loadNative } from "../src/native.ts";
 import { builtinEngine } from "../src/builtin.ts";
 import { parseHistory, pruneHistory, type History } from "../src/frecency.ts";
 import { formatFiles, formatMatches, formatStatus } from "../src/format.ts";
@@ -73,7 +74,9 @@ export default function searchExtension(pi: ExtensionAPI) {
       root = ctx.cwd;
       historyFile = historyPath(ctx.cwd);
       starting = (async () => {
-        const fast = await loadFff(root);
+        // Preference order: this package's own core, then fff if the user
+        // has it, then the fallback that always works.
+        const fast = loadNative(root) ?? (await loadFff(root));
         const chosen =
           fast ?? builtinEngine(root, { history: loadHistory(), onHistoryChange: saveHistory });
         await chosen.ready(READY_TIMEOUT_MS);
@@ -156,10 +159,21 @@ export default function searchExtension(pi: ExtensionAPI) {
     const name = (event as { toolName?: string }).toolName;
     if (name !== "read" && name !== "edit" && name !== "write") return undefined;
     const path = (event as { input?: { path?: unknown } }).input?.path;
-    if (typeof path === "string" && engine?.touch) engine.touch(path);
+    if (typeof path === "string") engine?.touch?.(path);
     return undefined;
   });
 
+  pi.on("tool_result", async (event) => {
+    // The agent just changed a file, so the index is stale for it. Re-reading
+    // one path is cheap; noticing later that a search missed a line the agent
+    // itself wrote is not.
+    const name = (event as { toolName?: string }).toolName;
+    if (name !== "edit" && name !== "write") return;
+    if ((event as { isError?: boolean }).isError === true) return;
+    const path = (event as { input?: Record<string, unknown> }).input?.path;
+    if (typeof path === "string") engine?.refresh?.(path);
+  });
+
   // ── Lifecycle ────────────────────────────────────────────────────────
 
   pi.on("session_start", async (_event, ctx) => {

package/native/Cargo.toml

@@ -0,0 +1,25 @@
+[package]
+name = "pify-search-core"
+version = "0.1.0"
+edition = "2021"
+license = "MIT"
+publish = false
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+napi = { version = "2", default-features = false, features = ["napi4"] }
+napi-derive = "2"
+walkdir = "2"
+rayon = "1"
+regex = "1"
+
+[build-dependencies]
+napi-build = "2"
+
+[profile.release]
+lto = true
+opt-level = 3
+codegen-units = 1
+strip = true

package/native/build.rs

@@ -0,0 +1,3 @@
+fn main() {
+    napi_build::setup();
+}

package/native/src/lib.rs

@@ -0,0 +1,508 @@
+//! The native core of `@pify/search`.
+//!
+//! An in-memory file index with a trigram index over contents, exposed to
+//! Node through napi. It answers the same two questions as the TypeScript
+//! fallback and gives the same answers — the scoring constants are copied
+//! across deliberately, so losing the binary changes how fast a search is and
+//! never how it is ordered.
+
+#![deny(clippy::all)]
+
+mod score;
+mod store;
+mod trigram;
+mod walk;
+
+use napi::bindgen_prelude::*;
+use napi_derive::napi;
+use rayon::prelude::*;
+use std::collections::HashMap;
+use std::path::{Path, PathBuf};
+use std::sync::RwLock;
+
+use trigram::{Index, Plan};
+
+struct Entry {
+    path: String,
+    absolute: PathBuf,
+    size: u64,
+    mtime_ms: i64,
+}
+
+#[napi(object)]
+pub struct FileHit {
+    pub path: String,
+    pub score: i32,
+    pub size: f64,
+    pub modified_ms: f64,
+}
+
+#[napi(object)]
+pub struct ContentHit {
+    pub path: String,
+    pub line: u32,
+    pub text: String,
+}
+
+#[napi(object)]
+pub struct FindPage {
+    pub items: Vec<FileHit>,
+    pub total: u32,
+    /// Offset for the next page, or -1 when this was the last.
+    pub next: i32,
+}
+
+#[napi(object)]
+pub struct GrepPage {
+    pub items: Vec<ContentHit>,
+    pub total: u32,
+    pub next: i32,
+    /// Files actually opened, so a caller can see the index doing its job.
+    pub scanned: u32,
+}
+
+#[napi]
+pub struct SearchIndex {
+    root: PathBuf,
+    entries: RwLock<Vec<Entry>>,
+    by_path: RwLock<HashMap<String, u32>>,
+    content: RwLock<Index>,
+    frecency: RwLock<HashMap<String, i32>>,
+    cache: Option<PathBuf>,
+    reused: u32,
+    rebuilt: u32,
+}
+
+#[napi]
+impl SearchIndex {
+    /// Build the index. Walking and content extraction run in parallel;
+    /// nothing is memory-mapped, so this behaves the same on every platform.
+    #[napi(constructor)]
+    pub fn new(root: String, max_files: Option<u32>, cache_path: Option<String>) -> Result<Self> {
+        let root_path = PathBuf::from(&root);
+        let cap = max_files.unwrap_or(200_000) as usize;
+        let t0 = std::time::Instant::now();
+        let found = walk::collect(&root_path, cap);
+        let t_walk = t0.elapsed();
+
+        // Anything the last run already extracted and that still looks the
+        // same on disk is reused; only genuinely changed files are re-read.
+        // That is the whole point of persisting — a session on a large tree
+        // should pay for what changed, not for the tree.
+        let cache = cache_path.as_ref().map(PathBuf::from);
+        let t1 = std::time::Instant::now();
+        let loaded = cache.as_ref().and_then(|p| store::load(p));
+        let t_load = t1.elapsed();
+        let had_cache = loaded.is_some();
+        let mut known = loaded.map(store::index_by_path).unwrap_or_default();
+
+        let mut entries = Vec::with_capacity(found.len());
+        let mut by_path = HashMap::with_capacity(found.len());
+        for (i, file) in found.iter().enumerate() {
+            by_path.insert(file.rel.clone(), i as u32);
+            entries.push(Entry {
+                path: file.rel.clone(),
+                absolute: file.absolute.clone(),
+                size: file.size,
+                mtime_ms: file.mtime_ms,
+            });
+        }
+
+        let mut reused = 0usize;
+        let mut carried: Vec<(u32, Vec<u32>)> = Vec::new();
+        let mut stale: Vec<(u32, &walk::Found)> = Vec::new();
+        for (i, file) in found.iter().enumerate() {
+            match known.remove(&file.rel) {
+                Some(entry) if store::still_valid(&entry, file.size, file.mtime_ms) => {
+                    reused += 1;
+                    carried.push((i as u32, entry.trigrams));
+                }
+                _ => stale.push((i as u32, file)),
+            }
+        }
+
+        // Reading and extracting is the expensive half and is embarrassingly
+        // parallel; building the map from the results is not, so it is done
+        // once at the end rather than behind a lock per file.
+        let extracted: Vec<(u32, Vec<u32>)> = stale
+            .par_iter()
+            .filter_map(|(id, file)| {
+                if !walk::index_content(&file.rel, file.size) {
+                    return None;
+                }
+                let bytes = std::fs::read(&file.absolute).ok()?;
+                if walk::looks_binary(&bytes) {
+                    return None;
+                }
+                let mut set = std::collections::HashSet::with_hasher(trigram::BuildTrigramHasher);
+                trigram::extract(&bytes, &mut set);
+                let mut list: Vec<u32> = set.into_iter().collect();
+                list.sort_unstable();
+                Some((*id, list))
+            })
+            .collect();
+
+        // Merged and sorted by id before insertion, which is not cosmetic:
+        // posting lists are kept sorted, so adding files in ascending order
+        // appends to each list, while the interleaved order that `carried` and
+        // `extracted` arrive in would insert into the middle and memmove the
+        // tail of every list it touches.
+        let rebuilt = extracted.len() as u32;
+        let mut all: Vec<(u32, Vec<u32>)> = carried;
+        all.extend(extracted);
+        all.sort_unstable_by_key(|(id, _)| *id);
+
+        let t2 = std::time::Instant::now();
+        let mut index = Index::new();
+        for (id, trigrams) in &all {
+            index.add(*id, trigrams);
+        }
+        let t_index = t2.elapsed();
+        // Off unless asked for. The three phases have very different costs and
+        // guessing which one dominates is how the first version of this spent
+        // most of its time rebuilding an index it had just loaded.
+        if std::env::var_os("PIFY_SEARCH_TIMING").is_some() {
+            eprintln!("  walk {t_walk:?}  load {t_load:?}  invert {t_index:?}");
+        }
+
+        // Rewriting an unchanged index costs a full re-inversion and a
+        // multi-megabyte write on every start, which on a large tree is most
+        // of what reloading was supposed to save. Write only when the tree
+        // actually moved: something re-read, something gone, or no cache yet.
+        let vanished = !known.is_empty();
+        let dirty = !had_cache || rebuilt > 0 || vanished;
+
+        let this = Self {
+            root: root_path,
+            entries: RwLock::new(entries),
+            by_path: RwLock::new(by_path),
+            content: RwLock::new(index),
+            frecency: RwLock::new(HashMap::new()),
+            cache,
+            reused: reused as u32,
+            rebuilt,
+        };
+        if dirty {
+            this.persist();
+        }
+        Ok(this)
+    }
+
+    /// Write the index back, best effort. A cache that cannot be written costs
+    /// the next session a rebuild, never this one a result.
+    fn persist(&self) {
+        let Some(path) = self.cache.as_ref() else { return };
+        let (Ok(entries), Ok(index)) = (self.entries.read(), self.content.read()) else {
+            return;
+        };
+        let mut by_file = index.by_file();
+        let mut files = Vec::with_capacity(by_file.len());
+        for (id, entry) in entries.iter().enumerate() {
+            if let Some(trigrams) = by_file.remove(&(id as u32)) {
+                files.push(store::StoredFile {
+                    rel: entry.path.clone(),
+                    size: entry.size,
+                    mtime_ms: entry.mtime_ms,
+                    trigrams,
+                });
+            }
+        }
+        let _ = store::save(path, &files);
+    }
+
+    /// How much of the last index survived, so the saving is observable.
+    #[napi]
+    pub fn reused_count(&self) -> u32 {
+        self.reused
+    }
+
+    #[napi]
+    pub fn rebuilt_count(&self) -> u32 {
+        self.rebuilt
+    }
+
+    /// Flush the index to its cache file.
+    #[napi]
+    pub fn save(&self) {
+        self.persist();
+    }
+
+    #[napi]
+    pub fn file_count(&self) -> u32 {
+        self.entries.read().map(|e| e.len() as u32).unwrap_or(0)
+    }
+
+    #[napi]
+    pub fn indexed_count(&self) -> u32 {
+        self.content.read().map(|c| c.len() as u32).unwrap_or(0)
+    }
+
+    /// Note that a path was used, so frecency can favour it later.
+    #[napi]
+    pub fn touch(&self, path: String) {
+        let key = walk::normalize(&path);
+        if let Ok(mut frecency) = self.frecency.write() {
+            let entry = frecency.entry(key).or_insert(0);
+            *entry = (*entry + 25).min(200);
+        }
+    }
+
+    /// Re-read one path: a create or a modify. Removing is `forget`.
+    #[napi]
+    pub fn refresh(&self, path: String) -> Result<()> {
+        let absolute = self.root.join(&path);
+        let rel = walk::relative(&self.root, &absolute);
+        let Ok(meta) = std::fs::metadata(&absolute) else {
+            return Ok(());
+        };
+        if !meta.is_file() {
+            return Ok(());
+        }
+
+        let id = {
+            let mut by_path = self.by_path.write().map_err(lock_err)?;
+            let mut entries = self.entries.write().map_err(lock_err)?;
+            match by_path.get(&rel) {
+                Some(&id) => {
+                    if let Some(entry) = entries.get_mut(id as usize) {
+                        entry.size = meta.len();
+                        entry.mtime_ms = walk::mtime_ms(&meta);
+                    }
+                    id
+                }
+                None => {
+                    let id = entries.len() as u32;
+                    entries.push(Entry {
+                        path: rel.clone(),
+                        absolute: absolute.clone(),
+                        size: meta.len(),
+                        mtime_ms: walk::mtime_ms(&meta),
+                    });
+                    by_path.insert(rel.clone(), id);
+                    id
+                }
+            }
+        };
+
+        let mut index = self.content.write().map_err(lock_err)?;
+        if !walk::index_content(&rel, meta.len()) {
+            index.remove(id);
+            return Ok(());
+        }
+        match std::fs::read(&absolute) {
+            Ok(bytes) if !walk::looks_binary(&bytes) => {
+                let mut set = std::collections::HashSet::with_hasher(trigram::BuildTrigramHasher);
+                trigram::extract(&bytes, &mut set);
+                let mut list: Vec<u32> = set.into_iter().collect();
+                list.sort_unstable();
+                index.add(id, &list);
+            }
+            _ => index.remove(id),
+        }
+        Ok(())
+    }
+
+    #[napi]
+    pub fn forget(&self, path: String) -> Result<()> {
+        let rel = walk::normalize(&path);
+        let id = { self.by_path.read().map_err(lock_err)?.get(&rel).copied() };
+        if let Some(id) = id {
+            self.content.write().map_err(lock_err)?.remove(id);
+            self.by_path.write().map_err(lock_err)?.remove(&rel);
+        }
+        Ok(())
+    }
+
+    #[napi]
+    pub fn find(&self, query: String, limit: u32, offset: u32, now_ms: f64) -> Result<FindPage> {
+        let entries = self.entries.read().map_err(lock_err)?;
+        let frecency = self.frecency.read().map_err(lock_err)?;
+        let now = now_ms as i64;
+
+        let mut scored: Vec<(i32, usize)> = entries
+            .par_iter()
+            .enumerate()
+            .filter_map(|(i, entry)| {
+                let candidate = score::Candidate {
+                    path: &entry.path,
+                    frecency: frecency.get(&entry.path).copied().unwrap_or(0),
+                    git: "",
+                    mtime_ms: entry.mtime_ms,
+                };
+                score::score(&candidate, &query, now).map(|s| (s, i))
+            })
+            .collect();
+
+        // Ties break on path so two runs of the same query agree.
+        scored.sort_by(|a, b| b.0.cmp(&a.0).then_with(|| entries[a.1].path.cmp(&entries[b.1].path)));
+
+        let total = scored.len();
+        let start = (offset as usize).min(total);
+        let end = (start + limit as usize).min(total);
+        let items = scored[start..end]
+            .iter()
+            .map(|&(s, i)| FileHit {
+                path: entries[i].path.clone(),
+                score: s,
+                size: entries[i].size as f64,
+                modified_ms: entries[i].mtime_ms as f64,
+            })
+            .collect();
+
+        Ok(FindPage {
+            items,
+            total: total as u32,
+            next: if end < total { end as i32 } else { -1 },
+        })
+    }
+
+    /// `mode` is "literal", "regex" or "fuzzy".
+    #[napi]
+    pub fn grep(
+        &self,
+        pattern: String,
+        mode: String,
+        limit: u32,
+        offset: u32,
+        case_insensitive: bool,
+    ) -> Result<GrepPage> {
+        if pattern.is_empty() {
+            return Ok(GrepPage { items: vec![], total: 0, next: -1, scanned: 0 });
+        }
+        let entries = self.entries.read().map_err(lock_err)?;
+        let index = self.content.read().map_err(lock_err)?;
+
+        // Fuzzy has no required substring, so the index cannot narrow it.
+        // Saying so beats narrowing wrongly and losing matches.
+        let plan = match mode.as_str() {
+            "fuzzy" => Plan::All,
+            "regex" => trigram::plan_for_regex(&pattern),
+            _ => trigram::plan_for_literal(&pattern),
+        };
+
+        let ids: Vec<u32> = match index.candidates(&plan) {
+            Some(list) => list,
+            None => (0..entries.len() as u32).collect(),
+        };
+
+        let needle = if case_insensitive { pattern.to_lowercase() } else { pattern.clone() };
+        let budget = score::max_typos(&pattern);
+
+        // Regex mode must actually run a regex. Falling back to `contains`
+        // made `declared\w+` match nothing at all while reporting a clean
+        // zero, which reads exactly like "this does not exist".
+        let compiled = if mode == "regex" {
+            match regex::RegexBuilder::new(&pattern)
+                .case_insensitive(case_insensitive)
+                .build()
+            {
+                Ok(re) => Some(re),
+                Err(e) => return Err(Error::from_reason(format!("invalid regex: {e}"))),
+            }
+        } else {
+            None
+        };
+
+        let mut hits: Vec<ContentHit> = ids
+            .par_iter()
+            .filter_map(|&id| {
+                let entry = entries.get(id as usize)?;
+                if entry.size > walk::MAX_SEARCHABLE_BYTES {
+                    return None;
+                }
+                let bytes = std::fs::read(&entry.absolute).ok()?;
+                if walk::looks_binary(&bytes) {
+                    return None;
+                }
+                let text = String::from_utf8_lossy(&bytes);
+                let mut found = Vec::new();
+                for (n, line) in text.lines().enumerate() {
+                    let matched = match &compiled {
+                        Some(re) => re.is_match(line),
+                        None => {
+                            let hay = if case_insensitive { line.to_lowercase() } else { line.to_string() };
+                            if mode == "fuzzy" {
+                                fuzzy_line(&hay, &needle, budget)
+                            } else {
+                                hay.contains(&needle)
+                            }
+                        }
+                    };
+                    if matched {
+                        found.push(ContentHit {
+                            path: entry.path.clone(),
+                            line: (n + 1) as u32,
+                            text: line.chars().take(400).collect(),
+                        });
+                    }
+                }
+                if found.is_empty() { None } else { Some(found) }
+            })
+            .flatten()
+            .collect();
+
+        hits.sort_by(|a, b| a.path.cmp(&b.path).then_with(|| a.line.cmp(&b.line)));
+
+        let total = hits.len();
+        let start = (offset as usize).min(total);
+        let end = (start + limit as usize).min(total);
+        Ok(GrepPage {
+            items: hits.drain(..).skip(start).take(end - start).collect(),
+            total: total as u32,
+            next: if end < total { end as i32 } else { -1 },
+            scanned: ids.len() as u32,
+        })
+    }
+}
+
+/// Characters in order, within the typo budget and close enough together to be
+/// one word rather than three scattered letters.
+fn fuzzy_line(hay: &str, needle: &str, budget: usize) -> bool {
+    let hay: Vec<char> = hay.chars().collect();
+    let need: Vec<char> = needle.chars().collect();
+    if need.is_empty() {
+        return false;
+    }
+    let span = (need.len() * 3).max(need.len() + 8);
+    for start in 0..hay.len() {
+        let mut typos = 0usize;
+        let mut at = start;
+        let mut matched = 0usize;
+        for &want in &need {
+            match hay[at.min(hay.len())..].iter().position(|&c| c == want) {
+                Some(offset) if at + offset - start <= span => {
+                    at += offset + 1;
+                    matched += 1;
+                }
+                _ => {
+                    typos += 1;
+                    if typos > budget {
+                        break;
+                    }
+                }
+            }
+        }
+        if typos <= budget && matched + budget >= need.len() && matched > 0 {
+            return true;
+        }
+    }
+    false
+}
+
+fn lock_err<T>(_: T) -> Error {
+    Error::from_reason("search index lock poisoned")
+}
+
+/// Exposed so the JavaScript side can assert the two engines agree.
+#[napi]
+pub fn literal_runs(pattern: String) -> Vec<String> {
+    trigram::literal_runs(&pattern)
+}
+
+#[napi]
+pub fn max_typos(query: String) -> u32 {
+    score::max_typos(&query) as u32
+}
+
+#[allow(dead_code)]
+fn unused(_: &Path) {}