@ff-labs/fff-node 0.10.4-nightly.dd87489 → 0.10.5-dev.4d662ef

package/dist/index.cjs

@@ -0,0 +1,1971 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  FileFinder: () => FileFinder,
+  binaryExists: () => binaryExists,
+  closeLibrary: () => closeLibrary,
+  err: () => err,
+  findBinary: () => findBinary,
+  getLibExtension: () => getLibExtension,
+  getLibFilename: () => getLibFilename,
+  getNpmPackageName: () => getNpmPackageName,
+  getTriple: () => getTriple,
+  ok: () => ok
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/binary.ts
+var import_node_fs = require("fs");
+var import_node_module = require("module");
+var import_node_path = require("path");
+var import_node_url = require("url");
+
+// src/platform.ts
+var import_node_child_process = require("child_process");
+function getTriple() {
+  const platform = process.platform;
+  const arch = process.arch;
+  let osName;
+  if (platform === "darwin") {
+    osName = "apple-darwin";
+  } else if (platform === "android") {
+    osName = "linux-android";
+  } else if (platform === "linux") {
+    osName = detectLinuxLibc();
+  } else if (platform === "win32") {
+    osName = "pc-windows-msvc";
+  } else {
+    throw new Error(`Unsupported platform: ${platform}`);
+  }
+  const archName = normalizeArch(arch);
+  return `${archName}-${osName}`;
+}
+function detectLinuxLibc() {
+  let output = "";
+  try {
+    output = (0, import_node_child_process.execSync)("ldd --version 2>&1", {
+      encoding: "utf-8",
+      timeout: 5e3
+    });
+  } catch (e) {
+    const err2 = e;
+    output = String(err2?.stdout ?? "") + String(err2?.stderr ?? "");
+  }
+  if (output.toLowerCase().includes("musl")) {
+    return "unknown-linux-musl";
+  }
+  return "unknown-linux-gnu";
+}
+function normalizeArch(arch) {
+  switch (arch) {
+    case "x64":
+    case "amd64":
+      return "x86_64";
+    case "arm64":
+      return "aarch64";
+    case "arm":
+      return "arm";
+    default:
+      throw new Error(`Unsupported architecture: ${arch}`);
+  }
+}
+function getLibExtension() {
+  switch (process.platform) {
+    case "darwin":
+      return "dylib";
+    case "win32":
+      return "dll";
+    default:
+      return "so";
+  }
+}
+function getLibPrefix() {
+  return process.platform === "win32" ? "" : "lib";
+}
+function getLibFilename() {
+  const prefix = getLibPrefix();
+  const ext = getLibExtension();
+  return `${prefix}fff_c.${ext}`;
+}
+var TRIPLE_TO_NPM_PACKAGE = {
+  "aarch64-apple-darwin": "@ff-labs/fff-bin-darwin-arm64",
+  "x86_64-apple-darwin": "@ff-labs/fff-bin-darwin-x64",
+  "x86_64-unknown-linux-gnu": "@ff-labs/fff-bin-linux-x64-gnu",
+  "aarch64-unknown-linux-gnu": "@ff-labs/fff-bin-linux-arm64-gnu",
+  "x86_64-unknown-linux-musl": "@ff-labs/fff-bin-linux-x64-musl",
+  "aarch64-unknown-linux-musl": "@ff-labs/fff-bin-linux-arm64-musl",
+  "x86_64-pc-windows-msvc": "@ff-labs/fff-bin-win32-x64",
+  "aarch64-pc-windows-msvc": "@ff-labs/fff-bin-win32-arm64",
+  "aarch64-linux-android": "@ff-labs/fff-bin-android-arm64"
+};
+function getNpmPackageName() {
+  const triple = getTriple();
+  const packageName = TRIPLE_TO_NPM_PACKAGE[triple];
+  if (!packageName) {
+    throw new Error(`No npm package available for platform: ${triple}`);
+  }
+  return packageName;
+}
+
+// src/binary.ts
+var import_meta = {};
+function getCurrentDir() {
+  if (typeof __dirname !== "undefined") return __dirname;
+  const url = import_meta.url;
+  if (url.startsWith("file://")) {
+    return (0, import_node_path.dirname)((0, import_node_url.fileURLToPath)(url));
+  }
+  return (0, import_node_path.dirname)(url);
+}
+function getPackageDir() {
+  const currentDir = getCurrentDir();
+  let dir = currentDir;
+  for (let i = 0; i < 5; i++) {
+    if ((0, import_node_fs.existsSync)((0, import_node_path.join)(dir, "package.json"))) {
+      try {
+        const pkg = JSON.parse((0, import_node_fs.readFileSync)((0, import_node_path.join)(dir, "package.json"), "utf-8"));
+        if (pkg.name === "@ff-labs/fff-node") {
+          return dir;
+        }
+      } catch {
+      }
+    }
+    dir = (0, import_node_path.dirname)(dir);
+  }
+  return (0, import_node_path.dirname)(currentDir);
+}
+function binaryExists() {
+  return findBinary() !== null;
+}
+function resolveFromNpmPackage() {
+  const packageName = getNpmPackageName();
+  try {
+    const require2 = (0, import_node_module.createRequire)((0, import_node_path.join)(getPackageDir(), "package.json"));
+    const packageJsonPath = require2.resolve(`${packageName}/package.json`);
+    const packageDir = (0, import_node_path.dirname)(packageJsonPath);
+    const binaryPath = (0, import_node_path.join)(packageDir, getLibFilename());
+    if ((0, import_node_fs.existsSync)(binaryPath)) {
+      return binaryPath;
+    }
+  } catch {
+  }
+  return null;
+}
+function getDevBinaryPath() {
+  const packageDir = getPackageDir();
+  const workspaceRoot = (0, import_node_path.join)(packageDir, "..", "..");
+  const possiblePaths = [
+    (0, import_node_path.join)(workspaceRoot, "target", "release", getLibFilename()),
+    (0, import_node_path.join)(workspaceRoot, "target", "debug", getLibFilename())
+  ];
+  for (const path of possiblePaths) {
+    if ((0, import_node_fs.existsSync)(path)) {
+      return path;
+    }
+  }
+  return null;
+}
+function isDevWorkspace() {
+  const packageDir = getPackageDir();
+  const workspaceRoot = (0, import_node_path.join)(packageDir, "..", "..");
+  return (0, import_node_fs.existsSync)((0, import_node_path.join)(workspaceRoot, "Cargo.toml"));
+}
+function findBinary() {
+  if (isDevWorkspace()) {
+    const binPath = (0, import_node_path.join)(getPackageDir(), "bin", getLibFilename());
+    if ((0, import_node_fs.existsSync)(binPath)) return binPath;
+    const devPath = getDevBinaryPath();
+    if (devPath) return devPath;
+    const npmPath2 = resolveFromNpmPackage();
+    if (npmPath2) return npmPath2;
+    return null;
+  }
+  const npmPath = resolveFromNpmPackage();
+  if (npmPath) return npmPath;
+  return getDevBinaryPath();
+}
+
+// src/ffi.ts
+var import_ffi_rs = require("ffi-rs");
+
+// src/fff-api.ts
+function ok(value) {
+  return { ok: true, value };
+}
+function err(error) {
+  return { ok: false, error };
+}
+function createGrepCursor(offset) {
+  return { __brand: "GrepCursor", _offset: offset };
+}
+
+// src/ffi.ts
+var LIBRARY_KEY = "fff_c";
+var FFF_CREATE_OPTIONS_STRUCT = {
+  version: import_ffi_rs.DataType.U32,
+  base_path: import_ffi_rs.DataType.String,
+  frecency_db_path: import_ffi_rs.DataType.String,
+  history_db_path: import_ffi_rs.DataType.String,
+  enable_mmap_cache: import_ffi_rs.DataType.U8,
+  enable_content_indexing: import_ffi_rs.DataType.U8,
+  watch: import_ffi_rs.DataType.U8,
+  ai_mode: import_ffi_rs.DataType.U8,
+  log_file_path: import_ffi_rs.DataType.String,
+  log_level: import_ffi_rs.DataType.String,
+  cache_budget_max_files: import_ffi_rs.DataType.U64,
+  cache_budget_max_bytes: import_ffi_rs.DataType.U64,
+  cache_budget_max_file_size: import_ffi_rs.DataType.U64,
+  enable_fs_root_scanning: import_ffi_rs.DataType.U8,
+  enable_home_dir_scanning: import_ffi_rs.DataType.U8,
+  follow_symlinks: import_ffi_rs.DataType.U8
+};
+var FFF_CREATE_OPTIONS_VERSION = 2;
+var GREP_MODE_PLAIN = 0;
+var GREP_MODE_REGEX = 1;
+var GREP_MODE_FUZZY = 2;
+function grepModeToU8(mode) {
+  switch (mode) {
+    case "regex":
+      return GREP_MODE_REGEX;
+    case "fuzzy":
+      return GREP_MODE_FUZZY;
+    default:
+      return GREP_MODE_PLAIN;
+  }
+}
+var isLoaded = false;
+var FFF_RESULT_STRUCT = {
+  success: import_ffi_rs.DataType.U8,
+  error: import_ffi_rs.DataType.External,
+  handle: import_ffi_rs.DataType.External,
+  int_value: import_ffi_rs.DataType.I64
+};
+function loadLibrary() {
+  if (isLoaded) return;
+  const binaryPath = findBinary();
+  if (!binaryPath) {
+    throw new Error(
+      "fff native library not found. Run `npx @ff-labs/fff-node download` or build from source with `cargo build --release -p fff-c`"
+    );
+  }
+  (0, import_ffi_rs.open)({ library: LIBRARY_KEY, path: binaryPath });
+  isLoaded = true;
+}
+function snakeToCamel(obj) {
+  if (obj === null || obj === void 0) return obj;
+  if (typeof obj !== "object") return obj;
+  if (Array.isArray(obj)) return obj.map(snakeToCamel);
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    const camelKey = key.replace(
+      /_([a-z])/g,
+      (_, letter) => letter.toUpperCase()
+    );
+    result[camelKey] = snakeToCamel(value);
+  }
+  return result;
+}
+function readCString(ptr) {
+  if ((0, import_ffi_rs.isNullPointer)(ptr)) return null;
+  try {
+    const [str] = (0, import_ffi_rs.restorePointer)({
+      retType: [import_ffi_rs.DataType.String],
+      paramsValue: (0, import_ffi_rs.wrapPointer)([ptr])
+    });
+    return str;
+  } catch {
+    return null;
+  }
+}
+function callRaw(funcName, paramsType, paramsValue) {
+  const rawPtr = (0, import_ffi_rs.load)({
+    library: LIBRARY_KEY,
+    funcName,
+    retType: import_ffi_rs.DataType.External,
+    paramsType,
+    paramsValue,
+    freeResultMemory: false
+  });
+  const [structData] = (0, import_ffi_rs.restorePointer)({
+    retType: [FFF_RESULT_STRUCT],
+    paramsValue: (0, import_ffi_rs.wrapPointer)([rawPtr])
+  });
+  return { rawPtr, struct: structData };
+}
+function freeResult(resultPtr) {
+  try {
+    (0, import_ffi_rs.load)({
+      library: LIBRARY_KEY,
+      funcName: "fff_free_result",
+      retType: import_ffi_rs.DataType.Void,
+      paramsType: [import_ffi_rs.DataType.External],
+      paramsValue: [resultPtr]
+    });
+  } catch {
+  }
+}
+function readResultEnvelope(funcName, paramsType, paramsValue) {
+  loadLibrary();
+  const { rawPtr, struct: structData } = callRaw(funcName, paramsType, paramsValue);
+  if (structData.success === 0) {
+    const errorStr = readCString(structData.error);
+    freeResult(rawPtr);
+    return err(errorStr || "Unknown error");
+  }
+  return { rawPtr, struct: structData };
+}
+function callVoidResult(funcName, paramsType, paramsValue) {
+  const res = readResultEnvelope(funcName, paramsType, paramsValue);
+  if ("ok" in res) return res;
+  freeResult(res.rawPtr);
+  return { ok: true, value: void 0 };
+}
+function callIntResult(funcName, paramsType, paramsValue) {
+  const res = readResultEnvelope(funcName, paramsType, paramsValue);
+  if ("ok" in res) return res;
+  const value = Number(res.struct.int_value);
+  freeResult(res.rawPtr);
+  return { ok: true, value };
+}
+function callBoolResult(funcName, paramsType, paramsValue) {
+  const res = readResultEnvelope(funcName, paramsType, paramsValue);
+  if ("ok" in res) return res;
+  const value = Number(res.struct.int_value) !== 0;
+  freeResult(res.rawPtr);
+  return { ok: true, value };
+}
+function callStringResult(funcName, paramsType, paramsValue) {
+  const res = readResultEnvelope(funcName, paramsType, paramsValue);
+  if ("ok" in res) return res;
+  const handlePtr = res.struct.handle;
+  freeResult(res.rawPtr);
+  if ((0, import_ffi_rs.isNullPointer)(handlePtr)) return { ok: true, value: null };
+  const str = readCString(handlePtr);
+  freeString(handlePtr);
+  return { ok: true, value: str };
+}
+function callJsonResult(funcName, paramsType, paramsValue) {
+  const res = readResultEnvelope(funcName, paramsType, paramsValue);
+  if ("ok" in res) return res;
+  const handlePtr = res.struct.handle;
+  freeResult(res.rawPtr);
+  if ((0, import_ffi_rs.isNullPointer)(handlePtr)) return { ok: true, value: void 0 };
+  const jsonStr = readCString(handlePtr);
+  freeString(handlePtr);
+  if (jsonStr === null || jsonStr === "") return { ok: true, value: void 0 };
+  try {
+    return { ok: true, value: snakeToCamel(JSON.parse(jsonStr)) };
+  } catch {
+    return { ok: true, value: jsonStr };
+  }
+}
+function freeString(ptr) {
+  try {
+    (0, import_ffi_rs.load)({
+      library: LIBRARY_KEY,
+      funcName: "fff_free_string",
+      retType: import_ffi_rs.DataType.Void,
+      paramsType: [import_ffi_rs.DataType.External],
+      paramsValue: [ptr]
+    });
+  } catch {
+  }
+}
+function ffiCreate(basePath, frecencyDbPath, historyDbPath, _useUnsafeNoLock, enableMmapCache, enableContentIndexing, watch, aiMode, logFilePath, logLevel, cacheBudgetMaxFiles, cacheBudgetMaxBytes, cacheBudgetMaxFileSize, enableFsRootScanning, enableHomeDirScanning, followSymlinks) {
+  loadLibrary();
+  const optsValue = {
+    version: FFF_CREATE_OPTIONS_VERSION,
+    base_path: basePath,
+    frecency_db_path: frecencyDbPath,
+    history_db_path: historyDbPath,
+    enable_mmap_cache: enableMmapCache ? 1 : 0,
+    enable_content_indexing: enableContentIndexing ? 1 : 0,
+    watch: watch ? 1 : 0,
+    ai_mode: aiMode ? 1 : 0,
+    log_file_path: logFilePath,
+    log_level: logLevel,
+    cache_budget_max_files: cacheBudgetMaxFiles,
+    cache_budget_max_bytes: cacheBudgetMaxBytes,
+    cache_budget_max_file_size: cacheBudgetMaxFileSize,
+    enable_fs_root_scanning: enableFsRootScanning ? 1 : 0,
+    enable_home_dir_scanning: enableHomeDirScanning ? 1 : 0,
+    follow_symlinks: followSymlinks ? 1 : 0
+  };
+  const rawPtr = (0, import_ffi_rs.load)({
+    library: LIBRARY_KEY,
+    funcName: "fff_create_instance_with",
+    retType: import_ffi_rs.DataType.External,
+    paramsType: [FFF_CREATE_OPTIONS_STRUCT],
+    paramsValue: [optsValue],
+    freeResultMemory: false
+  });
+  const [structData] = (0, import_ffi_rs.restorePointer)({
+    retType: [FFF_RESULT_STRUCT],
+    paramsValue: (0, import_ffi_rs.wrapPointer)([rawPtr])
+  });
+  const success = structData.success !== 0;
+  try {
+    if (success) {
+      const handle = structData.handle;
+      if ((0, import_ffi_rs.isNullPointer)(handle)) {
+        return err("fff_create_instance_with returned null handle");
+      }
+      return { ok: true, value: handle };
+    } else {
+      const errorStr = readCString(structData.error);
+      return err(errorStr || "Unknown error");
+    }
+  } finally {
+    freeResult(rawPtr);
+  }
+}
+function ffiDestroy(handle) {
+  loadLibrary();
+  (0, import_ffi_rs.load)({
+    library: LIBRARY_KEY,
+    funcName: "fff_destroy",
+    retType: import_ffi_rs.DataType.Void,
+    paramsType: [import_ffi_rs.DataType.External],
+    paramsValue: [handle]
+  });
+}
+var FFF_FILE_ITEM_STRUCT = {
+  relative_path: import_ffi_rs.DataType.External,
+  file_name: import_ffi_rs.DataType.External,
+  git_status: import_ffi_rs.DataType.External,
+  size: import_ffi_rs.DataType.U64,
+  modified: import_ffi_rs.DataType.U64,
+  access_frecency_score: import_ffi_rs.DataType.I64,
+  modification_frecency_score: import_ffi_rs.DataType.I64,
+  total_frecency_score: import_ffi_rs.DataType.I64,
+  is_binary: import_ffi_rs.DataType.U8
+};
+var FFF_SCORE_STRUCT = {
+  total: import_ffi_rs.DataType.I32,
+  base_score: import_ffi_rs.DataType.I32,
+  filename_bonus: import_ffi_rs.DataType.I32,
+  special_filename_bonus: import_ffi_rs.DataType.I32,
+  frecency_boost: import_ffi_rs.DataType.I32,
+  distance_penalty: import_ffi_rs.DataType.I32,
+  current_file_penalty: import_ffi_rs.DataType.I32,
+  combo_match_boost: import_ffi_rs.DataType.I32,
+  exact_match: import_ffi_rs.DataType.U8,
+  match_type: import_ffi_rs.DataType.External
+};
+var FFF_SEARCH_RESULT_STRUCT = {
+  items: import_ffi_rs.DataType.External,
+  scores: import_ffi_rs.DataType.External,
+  count: import_ffi_rs.DataType.U32,
+  total_matched: import_ffi_rs.DataType.U32,
+  total_files: import_ffi_rs.DataType.U32,
+  // FffLocation inlined (flattened)
+  location_tag: import_ffi_rs.DataType.U8,
+  location_line: import_ffi_rs.DataType.I32,
+  location_col: import_ffi_rs.DataType.I32,
+  location_end_line: import_ffi_rs.DataType.I32,
+  location_end_col: import_ffi_rs.DataType.I32
+};
+var FFF_DIR_ITEM_STRUCT = {
+  relative_path: import_ffi_rs.DataType.External,
+  dir_name: import_ffi_rs.DataType.External,
+  max_access_frecency: import_ffi_rs.DataType.I32
+};
+var FFF_DIR_SEARCH_RESULT_STRUCT = {
+  items: import_ffi_rs.DataType.External,
+  scores: import_ffi_rs.DataType.External,
+  count: import_ffi_rs.DataType.U32,
+  total_matched: import_ffi_rs.DataType.U32,
+  total_dirs: import_ffi_rs.DataType.U32
+};
+var FFF_MIXED_ITEM_STRUCT = {
+  item_type: import_ffi_rs.DataType.U8,
+  relative_path: import_ffi_rs.DataType.External,
+  display_name: import_ffi_rs.DataType.External,
+  git_status: import_ffi_rs.DataType.External,
+  size: import_ffi_rs.DataType.U64,
+  modified: import_ffi_rs.DataType.U64,
+  access_frecency_score: import_ffi_rs.DataType.I64,
+  modification_frecency_score: import_ffi_rs.DataType.I64,
+  total_frecency_score: import_ffi_rs.DataType.I64,
+  is_binary: import_ffi_rs.DataType.U8
+};
+var FFF_MIXED_SEARCH_RESULT_STRUCT = {
+  items: import_ffi_rs.DataType.External,
+  scores: import_ffi_rs.DataType.External,
+  count: import_ffi_rs.DataType.U32,
+  total_matched: import_ffi_rs.DataType.U32,
+  total_files: import_ffi_rs.DataType.U32,
+  total_dirs: import_ffi_rs.DataType.U32,
+  // FffLocation inlined (flattened)
+  location_tag: import_ffi_rs.DataType.U8,
+  location_line: import_ffi_rs.DataType.I32,
+  location_col: import_ffi_rs.DataType.I32,
+  location_end_line: import_ffi_rs.DataType.I32,
+  location_end_col: import_ffi_rs.DataType.I32
+};
+var FFF_GREP_MATCH_STRUCT = {
+  relative_path: import_ffi_rs.DataType.External,
+  file_name: import_ffi_rs.DataType.External,
+  git_status: import_ffi_rs.DataType.External,
+  line_content: import_ffi_rs.DataType.External,
+  match_ranges: import_ffi_rs.DataType.External,
+  context_before: import_ffi_rs.DataType.External,
+  context_after: import_ffi_rs.DataType.External,
+  size: import_ffi_rs.DataType.U64,
+  modified: import_ffi_rs.DataType.U64,
+  total_frecency_score: import_ffi_rs.DataType.I64,
+  access_frecency_score: import_ffi_rs.DataType.I64,
+  modification_frecency_score: import_ffi_rs.DataType.I64,
+  line_number: import_ffi_rs.DataType.U64,
+  byte_offset: import_ffi_rs.DataType.U64,
+  col: import_ffi_rs.DataType.U32,
+  match_ranges_count: import_ffi_rs.DataType.U32,
+  context_before_count: import_ffi_rs.DataType.U32,
+  context_after_count: import_ffi_rs.DataType.U32,
+  fuzzy_score: import_ffi_rs.DataType.U32,
+  // actually u16 in C, but ffi-rs doesn't so we read it as u32 with padding
+  has_fuzzy_score: import_ffi_rs.DataType.U8,
+  is_binary: import_ffi_rs.DataType.U8,
+  is_definition: import_ffi_rs.DataType.U8
+};
+var FFF_GREP_RESULT_STRUCT = {
+  items: import_ffi_rs.DataType.External,
+  count: import_ffi_rs.DataType.U32,
+  total_matched: import_ffi_rs.DataType.U32,
+  total_files_searched: import_ffi_rs.DataType.U32,
+  total_files: import_ffi_rs.DataType.U32,
+  filtered_file_count: import_ffi_rs.DataType.U32,
+  next_file_offset: import_ffi_rs.DataType.U32,
+  regex_fallback_error: import_ffi_rs.DataType.External
+};
+var FFF_MATCH_RANGE_STRUCT = {
+  start: import_ffi_rs.DataType.U32,
+  end: import_ffi_rs.DataType.U32
+};
+function readFileItemFromRaw(raw) {
+  return {
+    relativePath: readCString(raw.relative_path) ?? "",
+    fileName: readCString(raw.file_name) ?? "",
+    gitStatus: readCString(raw.git_status) ?? "",
+    size: Number(raw.size),
+    modified: Number(raw.modified),
+    accessFrecencyScore: Number(raw.access_frecency_score),
+    modificationFrecencyScore: Number(raw.modification_frecency_score),
+    totalFrecencyScore: Number(raw.total_frecency_score)
+  };
+}
+function readScoreFromRaw(raw) {
+  return {
+    total: raw.total,
+    baseScore: raw.base_score,
+    filenameBonus: raw.filename_bonus,
+    specialFilenameBonus: raw.special_filename_bonus,
+    frecencyBoost: raw.frecency_boost,
+    distancePenalty: raw.distance_penalty,
+    currentFilePenalty: raw.current_file_penalty,
+    comboMatchBoost: raw.combo_match_boost,
+    exactMatch: raw.exact_match !== 0,
+    matchType: readCString(raw.match_type) ?? ""
+  };
+}
+function readDirItemFromRaw(raw) {
+  return {
+    relativePath: readCString(raw.relative_path) ?? "",
+    dirName: readCString(raw.dir_name) ?? "",
+    maxAccessFrecency: raw.max_access_frecency
+  };
+}
+function readMixedItemFromRaw(raw) {
+  if (raw.item_type === 1) {
+    return {
+      type: "directory",
+      item: {
+        relativePath: readCString(raw.relative_path) ?? "",
+        dirName: readCString(raw.display_name) ?? "",
+        maxAccessFrecency: Number(raw.access_frecency_score)
+      }
+    };
+  }
+  return {
+    type: "file",
+    item: {
+      relativePath: readCString(raw.relative_path) ?? "",
+      fileName: readCString(raw.display_name) ?? "",
+      gitStatus: readCString(raw.git_status) ?? "",
+      size: Number(raw.size),
+      modified: Number(raw.modified),
+      accessFrecencyScore: Number(raw.access_frecency_score),
+      modificationFrecencyScore: Number(raw.modification_frecency_score),
+      totalFrecencyScore: Number(raw.total_frecency_score)
+    }
+  };
+}
+function callAccessor(funcName, resultPtr, index, structDef) {
+  loadLibrary();
+  const elemPtr = (0, import_ffi_rs.load)({
+    library: LIBRARY_KEY,
+    funcName,
+    retType: import_ffi_rs.DataType.External,
+    paramsType: [import_ffi_rs.DataType.External, import_ffi_rs.DataType.U32],
+    paramsValue: [resultPtr, index]
+  });
+  const [raw] = (0, import_ffi_rs.restorePointer)({
+    retType: [structDef],
+    paramsValue: (0, import_ffi_rs.wrapPointer)([elemPtr])
+  });
+  return raw;
+}
+function ptrOffset(base, bytes) {
+  return (0, import_ffi_rs.load)({
+    library: LIBRARY_KEY,
+    funcName: "fff_ptr_offset",
+    retType: import_ffi_rs.DataType.External,
+    paramsType: [import_ffi_rs.DataType.External, import_ffi_rs.DataType.U64],
+    paramsValue: [base, bytes]
+  });
+}
+function readCStringArray(ptrArray, count) {
+  if (count === 0 || (0, import_ffi_rs.isNullPointer)(ptrArray)) return [];
+  const result = [];
+  for (let i = 0; i < count; i++) {
+    const elemPtr = ptrOffset(ptrArray, i * 8);
+    const [charPtr] = (0, import_ffi_rs.restorePointer)({
+      retType: [import_ffi_rs.DataType.External],
+      paramsValue: [elemPtr]
+    });
+    result.push(readCString(charPtr) ?? "");
+  }
+  return result;
+}
+function readGrepMatchFromRaw(raw) {
+  const matchRanges = [];
+  for (let i = 0; i < raw.match_ranges_count; i++) {
+    const rangePtr = ptrOffset(raw.match_ranges, i * 8);
+    const [rangeRaw] = (0, import_ffi_rs.restorePointer)({
+      retType: [FFF_MATCH_RANGE_STRUCT],
+      paramsValue: (0, import_ffi_rs.wrapPointer)([rangePtr])
+    });
+    matchRanges.push([rangeRaw.start, rangeRaw.end]);
+  }
+  const match = {
+    relativePath: readCString(raw.relative_path) ?? "",
+    fileName: readCString(raw.file_name) ?? "",
+    gitStatus: readCString(raw.git_status) ?? "",
+    lineContent: readCString(raw.line_content) ?? "",
+    size: Number(raw.size),
+    modified: Number(raw.modified),
+    totalFrecencyScore: Number(raw.total_frecency_score),
+    accessFrecencyScore: Number(raw.access_frecency_score),
+    modificationFrecencyScore: Number(raw.modification_frecency_score),
+    isBinary: raw.is_binary !== 0,
+    lineNumber: Number(raw.line_number),
+    col: raw.col,
+    byteOffset: Number(raw.byte_offset),
+    matchRanges
+  };
+  if (raw.has_fuzzy_score !== 0) {
+    match.fuzzyScore = raw.fuzzy_score;
+  }
+  if (raw.context_before_count > 0) {
+    match.contextBefore = readCStringArray(raw.context_before, raw.context_before_count);
+  }
+  if (raw.context_after_count > 0) {
+    match.contextAfter = readCStringArray(raw.context_after, raw.context_after_count);
+  }
+  if (raw.is_definition !== 0) {
+    match.isDefinition = true;
+  }
+  return match;
+}
+function parseGrepResult(rawPtr) {
+  loadLibrary();
+  const [envelope] = (0, import_ffi_rs.restorePointer)({
+    retType: [FFF_RESULT_STRUCT],
+    paramsValue: (0, import_ffi_rs.wrapPointer)([rawPtr])
+  });
+  const success = envelope.success !== 0;
+  if (!success) {
+    const errorMsg = readCString(envelope.error) || "Unknown error";
+    freeResult(rawPtr);
+    return err(errorMsg);
+  }
+  const handlePtr = envelope.handle;
+  freeResult(rawPtr);
+  if ((0, import_ffi_rs.isNullPointer)(handlePtr)) {
+    return err("grep returned null result");
+  }
+  const [gr] = (0, import_ffi_rs.restorePointer)({
+    retType: [FFF_GREP_RESULT_STRUCT],
+    paramsValue: (0, import_ffi_rs.wrapPointer)([handlePtr])
+  });
+  const count = gr.count;
+  const regexFallbackError = readCString(gr.regex_fallback_error) ?? void 0;
+  const items = [];
+  for (let i = 0; i < count; i++) {
+    const rawMatch = callAccessor(
+      "fff_grep_result_get_match",
+      handlePtr,
+      i,
+      FFF_GREP_MATCH_STRUCT
+    );
+    items.push(readGrepMatchFromRaw(rawMatch));
+  }
+  (0, import_ffi_rs.load)({
+    library: LIBRARY_KEY,
+    funcName: "fff_free_grep_result",
+    retType: import_ffi_rs.DataType.Void,
+    paramsType: [import_ffi_rs.DataType.External],
+    paramsValue: [handlePtr]
+  });
+  const grepResult = {
+    items,
+    totalMatched: gr.total_matched,
+    totalFilesSearched: gr.total_files_searched,
+    totalFiles: gr.total_files,
+    filteredFileCount: gr.filtered_file_count,
+    nextCursor: gr.next_file_offset > 0 ? createGrepCursor(gr.next_file_offset) : null
+  };
+  if (regexFallbackError) {
+    grepResult.regexFallbackError = regexFallbackError;
+  }
+  return { ok: true, value: grepResult };
+}
+function parseSearchResult(rawPtr) {
+  loadLibrary();
+  const [envelope] = (0, import_ffi_rs.restorePointer)({
+    retType: [FFF_RESULT_STRUCT],
+    paramsValue: (0, import_ffi_rs.wrapPointer)([rawPtr])
+  });
+  const success = envelope.success !== 0;
+  if (!success) {
+    const errorMsg = readCString(envelope.error) || "Unknown error";
+    freeResult(rawPtr);
+    return err(errorMsg);
+  }
+  const handlePtr = envelope.handle;
+  freeResult(rawPtr);
+  if ((0, import_ffi_rs.isNullPointer)(handlePtr)) {
+    return err("fff_search returned null search result");
+  }
+  const [sr] = (0, import_ffi_rs.restorePointer)({
+    retType: [FFF_SEARCH_RESULT_STRUCT],
+    paramsValue: (0, import_ffi_rs.wrapPointer)([handlePtr])
+  });
+  const count = sr.count;
+  let location;
+  if (sr.location_tag === 1) {
+    location = { type: "line", line: sr.location_line };
+  } else if (sr.location_tag === 2) {
+    location = {
+      type: "position",
+      line: sr.location_line,
+      col: sr.location_col
+    };
+  } else if (sr.location_tag === 3) {
+    location = {
+      type: "range",
+      start: { line: sr.location_line, col: sr.location_col },
+      end: { line: sr.location_end_line, col: sr.location_end_col }
+    };
+  }
+  const items = [];
+  const scores = [];
+  for (let i = 0; i < count; i++) {
+    const rawItem = callAccessor(
+      "fff_search_result_get_item",
+      handlePtr,
+      i,
+      FFF_FILE_ITEM_STRUCT
+    );
+    items.push(readFileItemFromRaw(rawItem));
+    const rawScore = callAccessor(
+      "fff_search_result_get_score",
+      handlePtr,
+      i,
+      FFF_SCORE_STRUCT
+    );
+    scores.push(readScoreFromRaw(rawScore));
+  }
+  (0, import_ffi_rs.load)({
+    library: LIBRARY_KEY,
+    funcName: "fff_free_search_result",
+    retType: import_ffi_rs.DataType.Void,
+    paramsType: [import_ffi_rs.DataType.External],
+    paramsValue: [handlePtr]
+  });
+  const result = {
+    items,
+    scores,
+    totalMatched: sr.total_matched,
+    totalFiles: sr.total_files
+  };
+  if (location) {
+    result.location = location;
+  }
+  return { ok: true, value: result };
+}
+function parseDirSearchResult(rawPtr) {
+  loadLibrary();
+  const [envelope] = (0, import_ffi_rs.restorePointer)({
+    retType: [FFF_RESULT_STRUCT],
+    paramsValue: (0, import_ffi_rs.wrapPointer)([rawPtr])
+  });
+  const success = envelope.success !== 0;
+  if (!success) {
+    const errorMsg = readCString(envelope.error) || "Unknown error";
+    freeResult(rawPtr);
+    return err(errorMsg);
+  }
+  const handlePtr = envelope.handle;
+  freeResult(rawPtr);
+  if ((0, import_ffi_rs.isNullPointer)(handlePtr)) {
+    return err("fff_search_directories returned null search result");
+  }
+  const [sr] = (0, import_ffi_rs.restorePointer)({
+    retType: [FFF_DIR_SEARCH_RESULT_STRUCT],
+    paramsValue: (0, import_ffi_rs.wrapPointer)([handlePtr])
+  });
+  const count = sr.count;
+  const items = [];
+  const scores = [];
+  for (let i = 0; i < count; i++) {
+    const rawItem = callAccessor(
+      "fff_dir_search_result_get_item",
+      handlePtr,
+      i,
+      FFF_DIR_ITEM_STRUCT
+    );
+    items.push(readDirItemFromRaw(rawItem));
+    const rawScore = callAccessor(
+      "fff_dir_search_result_get_score",
+      handlePtr,
+      i,
+      FFF_SCORE_STRUCT
+    );
+    scores.push(readScoreFromRaw(rawScore));
+  }
+  (0, import_ffi_rs.load)({
+    library: LIBRARY_KEY,
+    funcName: "fff_free_dir_search_result",
+    retType: import_ffi_rs.DataType.Void,
+    paramsType: [import_ffi_rs.DataType.External],
+    paramsValue: [handlePtr]
+  });
+  return {
+    ok: true,
+    value: {
+      items,
+      scores,
+      totalMatched: sr.total_matched,
+      totalDirs: sr.total_dirs
+    }
+  };
+}
+function parseMixedSearchResult(rawPtr) {
+  loadLibrary();
+  const [envelope] = (0, import_ffi_rs.restorePointer)({
+    retType: [FFF_RESULT_STRUCT],
+    paramsValue: (0, import_ffi_rs.wrapPointer)([rawPtr])
+  });
+  const success = envelope.success !== 0;
+  if (!success) {
+    const errorMsg = readCString(envelope.error) || "Unknown error";
+    freeResult(rawPtr);
+    return err(errorMsg);
+  }
+  const handlePtr = envelope.handle;
+  freeResult(rawPtr);
+  if ((0, import_ffi_rs.isNullPointer)(handlePtr)) {
+    return err("fff_search_mixed returned null search result");
+  }
+  const [sr] = (0, import_ffi_rs.restorePointer)({
+    retType: [FFF_MIXED_SEARCH_RESULT_STRUCT],
+    paramsValue: (0, import_ffi_rs.wrapPointer)([handlePtr])
+  });
+  const count = sr.count;
+  let location;
+  if (sr.location_tag === 1) {
+    location = { type: "line", line: sr.location_line };
+  } else if (sr.location_tag === 2) {
+    location = {
+      type: "position",
+      line: sr.location_line,
+      col: sr.location_col
+    };
+  } else if (sr.location_tag === 3) {
+    location = {
+      type: "range",
+      start: { line: sr.location_line, col: sr.location_col },
+      end: { line: sr.location_end_line, col: sr.location_end_col }
+    };
+  }
+  const items = [];
+  const scores = [];
+  for (let i = 0; i < count; i++) {
+    const rawItem = callAccessor(
+      "fff_mixed_search_result_get_item",
+      handlePtr,
+      i,
+      FFF_MIXED_ITEM_STRUCT
+    );
+    items.push(readMixedItemFromRaw(rawItem));
+    const rawScore = callAccessor(
+      "fff_mixed_search_result_get_score",
+      handlePtr,
+      i,
+      FFF_SCORE_STRUCT
+    );
+    scores.push(readScoreFromRaw(rawScore));
+  }
+  (0, import_ffi_rs.load)({
+    library: LIBRARY_KEY,
+    funcName: "fff_free_mixed_search_result",
+    retType: import_ffi_rs.DataType.Void,
+    paramsType: [import_ffi_rs.DataType.External],
+    paramsValue: [handlePtr]
+  });
+  const result = {
+    items,
+    scores,
+    totalMatched: sr.total_matched,
+    totalFiles: sr.total_files,
+    totalDirs: sr.total_dirs
+  };
+  if (location) {
+    result.location = location;
+  }
+  return { ok: true, value: result };
+}
+function ffiSearch(handle, query, currentFile, maxThreads, pageIndex, pageSize, comboBoostMultiplier, minComboCount) {
+  loadLibrary();
+  const rawPtr = (0, import_ffi_rs.load)({
+    library: LIBRARY_KEY,
+    funcName: "fff_search",
+    retType: import_ffi_rs.DataType.External,
+    paramsType: [
+      import_ffi_rs.DataType.External,
+      // handle
+      import_ffi_rs.DataType.String,
+      // query
+      import_ffi_rs.DataType.String,
+      // current_file
+      import_ffi_rs.DataType.U32,
+      // max_threads
+      import_ffi_rs.DataType.U32,
+      // page_index
+      import_ffi_rs.DataType.U32,
+      // page_size
+      import_ffi_rs.DataType.I32,
+      // combo_boost_multiplier
+      import_ffi_rs.DataType.U32
+      // min_combo_count
+    ],
+    paramsValue: [
+      handle,
+      query,
+      currentFile,
+      maxThreads,
+      pageIndex,
+      pageSize,
+      comboBoostMultiplier,
+      minComboCount
+    ],
+    freeResultMemory: false
+  });
+  return parseSearchResult(rawPtr);
+}
+function ffiGlob(handle, pattern, currentFile, maxThreads, pageIndex, pageSize) {
+  loadLibrary();
+  const rawPtr = (0, import_ffi_rs.load)({
+    library: LIBRARY_KEY,
+    funcName: "fff_glob",
+    retType: import_ffi_rs.DataType.External,
+    paramsType: [
+      import_ffi_rs.DataType.External,
+      // handle
+      import_ffi_rs.DataType.String,
+      // pattern
+      import_ffi_rs.DataType.String,
+      // current_file
+      import_ffi_rs.DataType.U32,
+      // max_threads
+      import_ffi_rs.DataType.U32,
+      // page_index
+      import_ffi_rs.DataType.U32
+      // page_size
+    ],
+    paramsValue: [handle, pattern, currentFile, maxThreads, pageIndex, pageSize],
+    freeResultMemory: false
+  });
+  return parseSearchResult(rawPtr);
+}
+function ffiSearchDirectories(handle, query, currentFile, maxThreads, pageIndex, pageSize) {
+  loadLibrary();
+  const rawPtr = (0, import_ffi_rs.load)({
+    library: LIBRARY_KEY,
+    funcName: "fff_search_directories",
+    retType: import_ffi_rs.DataType.External,
+    paramsType: [
+      import_ffi_rs.DataType.External,
+      // handle
+      import_ffi_rs.DataType.String,
+      // query
+      import_ffi_rs.DataType.String,
+      // current_file
+      import_ffi_rs.DataType.U32,
+      // max_threads
+      import_ffi_rs.DataType.U32,
+      // page_index
+      import_ffi_rs.DataType.U32
+      // page_size
+    ],
+    paramsValue: [handle, query, currentFile ?? "", maxThreads, pageIndex, pageSize],
+    freeResultMemory: false
+  });
+  return parseDirSearchResult(rawPtr);
+}
+function ffiSearchMixed(handle, query, currentFile, maxThreads, pageIndex, pageSize, comboBoostMultiplier, minComboCount) {
+  loadLibrary();
+  const rawPtr = (0, import_ffi_rs.load)({
+    library: LIBRARY_KEY,
+    funcName: "fff_search_mixed",
+    retType: import_ffi_rs.DataType.External,
+    paramsType: [
+      import_ffi_rs.DataType.External,
+      // handle
+      import_ffi_rs.DataType.String,
+      // query
+      import_ffi_rs.DataType.String,
+      // current_file
+      import_ffi_rs.DataType.U32,
+      // max_threads
+      import_ffi_rs.DataType.U32,
+      // page_index
+      import_ffi_rs.DataType.U32,
+      // page_size
+      import_ffi_rs.DataType.I32,
+      // combo_boost_multiplier
+      import_ffi_rs.DataType.U32
+      // min_combo_count
+    ],
+    paramsValue: [
+      handle,
+      query,
+      currentFile,
+      maxThreads,
+      pageIndex,
+      pageSize,
+      comboBoostMultiplier,
+      minComboCount
+    ],
+    freeResultMemory: false
+  });
+  return parseMixedSearchResult(rawPtr);
+}
+function ffiLiveGrep(handle, query, mode, maxFileSize, maxMatchesPerFile, smartCase, fileOffset, pageLimit, timeBudgetMs, beforeContext, afterContext, classifyDefinitions) {
+  loadLibrary();
+  const rawPtr = (0, import_ffi_rs.load)({
+    library: LIBRARY_KEY,
+    funcName: "fff_live_grep",
+    retType: import_ffi_rs.DataType.External,
+    paramsType: [
+      import_ffi_rs.DataType.External,
+      // handle
+      import_ffi_rs.DataType.String,
+      // query
+      import_ffi_rs.DataType.U8,
+      // mode
+      import_ffi_rs.DataType.U64,
+      // max_file_size
+      import_ffi_rs.DataType.U32,
+      // max_matches_per_file
+      import_ffi_rs.DataType.Boolean,
+      // smart_case
+      import_ffi_rs.DataType.U32,
+      // file_offset
+      import_ffi_rs.DataType.U32,
+      // page_limit
+      import_ffi_rs.DataType.U64,
+      // time_budget_ms
+      import_ffi_rs.DataType.U32,
+      // before_context
+      import_ffi_rs.DataType.U32,
+      // after_context
+      import_ffi_rs.DataType.Boolean
+      // classify_definitions
+    ],
+    paramsValue: [
+      handle,
+      query,
+      grepModeToU8(mode),
+      maxFileSize,
+      maxMatchesPerFile,
+      smartCase,
+      fileOffset,
+      pageLimit,
+      timeBudgetMs,
+      beforeContext,
+      afterContext,
+      classifyDefinitions
+    ],
+    freeResultMemory: false
+  });
+  return parseGrepResult(rawPtr);
+}
+function ffiMultiGrep(handle, patternsJoined, constraints, maxFileSize, maxMatchesPerFile, smartCase, fileOffset, pageLimit, timeBudgetMs, beforeContext, afterContext, classifyDefinitions) {
+  loadLibrary();
+  const rawPtr = (0, import_ffi_rs.load)({
+    library: LIBRARY_KEY,
+    funcName: "fff_multi_grep",
+    retType: import_ffi_rs.DataType.External,
+    paramsType: [
+      import_ffi_rs.DataType.External,
+      // handle
+      import_ffi_rs.DataType.String,
+      // patterns_joined
+      import_ffi_rs.DataType.String,
+      // constraints
+      import_ffi_rs.DataType.U64,
+      // max_file_size
+      import_ffi_rs.DataType.U32,
+      // max_matches_per_file
+      import_ffi_rs.DataType.Boolean,
+      // smart_case
+      import_ffi_rs.DataType.U32,
+      // file_offset
+      import_ffi_rs.DataType.U32,
+      // page_limit
+      import_ffi_rs.DataType.U64,
+      // time_budget_ms
+      import_ffi_rs.DataType.U32,
+      // before_context
+      import_ffi_rs.DataType.U32,
+      // after_context
+      import_ffi_rs.DataType.Boolean
+      // classify_definitions
+    ],
+    paramsValue: [
+      handle,
+      patternsJoined,
+      constraints,
+      maxFileSize,
+      maxMatchesPerFile,
+      smartCase,
+      fileOffset,
+      pageLimit,
+      timeBudgetMs,
+      beforeContext,
+      afterContext,
+      classifyDefinitions
+    ],
+    freeResultMemory: false
+  });
+  return parseGrepResult(rawPtr);
+}
+function ffiScanFiles(handle) {
+  return callVoidResult("fff_scan_files", [import_ffi_rs.DataType.External], [handle]);
+}
+function ffiIsScanning(handle) {
+  loadLibrary();
+  return (0, import_ffi_rs.load)({
+    library: LIBRARY_KEY,
+    funcName: "fff_is_scanning",
+    retType: import_ffi_rs.DataType.Boolean,
+    paramsType: [import_ffi_rs.DataType.External],
+    paramsValue: [handle]
+  });
+}
+function ffiGetBasePath(handle) {
+  return callStringResult("fff_get_base_path", [import_ffi_rs.DataType.External], [handle]);
+}
+var FFF_SCAN_PROGRESS_STRUCT = {
+  scanned_files_count: import_ffi_rs.DataType.U64,
+  is_scanning: import_ffi_rs.DataType.U8,
+  is_watcher_ready: import_ffi_rs.DataType.U8,
+  is_warmup_complete: import_ffi_rs.DataType.U8
+};
+function ffiGetScanProgress(handle) {
+  loadLibrary();
+  const res = readResultEnvelope("fff_get_scan_progress", [import_ffi_rs.DataType.External], [handle]);
+  if ("ok" in res) return res;
+  const handlePtr = res.struct.handle;
+  freeResult(res.rawPtr);
+  if ((0, import_ffi_rs.isNullPointer)(handlePtr)) return err("scan progress returned null");
+  const [sp] = (0, import_ffi_rs.restorePointer)({
+    retType: [FFF_SCAN_PROGRESS_STRUCT],
+    paramsValue: (0, import_ffi_rs.wrapPointer)([handlePtr])
+  });
+  const result = {
+    scannedFilesCount: Number(sp.scanned_files_count),
+    isScanning: sp.is_scanning !== 0,
+    isWatcherReady: sp.is_watcher_ready !== 0,
+    isWarmupComplete: sp.is_warmup_complete !== 0
+  };
+  (0, import_ffi_rs.load)({
+    library: LIBRARY_KEY,
+    funcName: "fff_free_scan_progress",
+    retType: import_ffi_rs.DataType.Void,
+    paramsType: [import_ffi_rs.DataType.External],
+    paramsValue: [handlePtr]
+  });
+  return { ok: true, value: result };
+}
+function ffiWaitForScan(handle, timeoutMs) {
+  return callBoolResult(
+    "fff_wait_for_scan",
+    [import_ffi_rs.DataType.External, import_ffi_rs.DataType.U64],
+    [handle, timeoutMs]
+  );
+}
+function ffiRestartIndex(handle, newPath) {
+  return callVoidResult(
+    "fff_restart_index",
+    [import_ffi_rs.DataType.External, import_ffi_rs.DataType.String],
+    [handle, newPath]
+  );
+}
+function ffiRefreshGitStatus(handle) {
+  return callIntResult("fff_refresh_git_status", [import_ffi_rs.DataType.External], [handle]);
+}
+function ffiTrackQuery(handle, query, filePath) {
+  return callBoolResult(
+    "fff_track_query",
+    [import_ffi_rs.DataType.External, import_ffi_rs.DataType.String, import_ffi_rs.DataType.String],
+    [handle, query, filePath]
+  );
+}
+function ffiGetHistoricalQuery(handle, offset) {
+  return callStringResult(
+    "fff_get_historical_query",
+    [import_ffi_rs.DataType.External, import_ffi_rs.DataType.U64],
+    [handle, offset]
+  );
+}
+function watchKindFromU8(kind) {
+  switch (kind) {
+    case 0:
+      return "created";
+    case 1:
+      return "modified";
+    case 2:
+      return "removed";
+    default:
+      return "rescan";
+  }
+}
+var WATCH_TRAMPOLINE_TYPE = (0, import_ffi_rs.funcConstructor)({
+  paramsType: [import_ffi_rs.DataType.U64, import_ffi_rs.DataType.U64, import_ffi_rs.DataType.U64],
+  retType: import_ffi_rs.DataType.Void
+});
+var watchHandlers = /* @__PURE__ */ new Map();
+var watchInstances = /* @__PURE__ */ new Set();
+var watchTrampoline = null;
+function addressToExternal(address) {
+  return (0, import_ffi_rs.load)({
+    library: LIBRARY_KEY,
+    funcName: "fff_ptr_offset",
+    retType: import_ffi_rs.DataType.External,
+    paramsType: [import_ffi_rs.DataType.U64, import_ffi_rs.DataType.U64],
+    paramsValue: [address, 0]
+  });
+}
+function consumeWatchBatch(address) {
+  const batchPtr = addressToExternal(address);
+  const count = (0, import_ffi_rs.load)({
+    library: LIBRARY_KEY,
+    funcName: "fff_watch_events_count",
+    retType: import_ffi_rs.DataType.U32,
+    paramsType: [import_ffi_rs.DataType.External],
+    paramsValue: [batchPtr]
+  });
+  const events = [];
+  for (let i = 0; i < count; i++) {
+    const path = (0, import_ffi_rs.load)({
+      library: LIBRARY_KEY,
+      funcName: "fff_watch_events_get_path",
+      retType: import_ffi_rs.DataType.External,
+      paramsType: [import_ffi_rs.DataType.External, import_ffi_rs.DataType.U32],
+      paramsValue: [batchPtr, i]
+    });
+    const kind = (0, import_ffi_rs.load)({
+      library: LIBRARY_KEY,
+      funcName: "fff_watch_events_get_kind",
+      retType: import_ffi_rs.DataType.U8,
+      paramsType: [import_ffi_rs.DataType.External, import_ffi_rs.DataType.U32],
+      paramsValue: [batchPtr, i]
+    });
+    events.push({
+      path: readCString(path) ?? "",
+      kind: watchKindFromU8(kind)
+    });
+  }
+  (0, import_ffi_rs.load)({
+    library: LIBRARY_KEY,
+    funcName: "fff_free_watch_events",
+    retType: import_ffi_rs.DataType.Void,
+    paramsType: [import_ffi_rs.DataType.U64],
+    paramsValue: [address]
+  });
+  return events;
+}
+function watchTrampolineImpl(watchId, batchAddress, _userData) {
+  const events = consumeWatchBatch(batchAddress);
+  const handler = watchHandlers.get(Number(watchId));
+  if (handler === void 0 || events.length === 0) return;
+  try {
+    handler(events);
+  } catch {
+  }
+}
+function ensureWatchTrampoline() {
+  if (watchTrampoline === null) {
+    watchTrampoline = (0, import_ffi_rs.createPointer)({
+      paramsType: [WATCH_TRAMPOLINE_TYPE],
+      paramsValue: [watchTrampolineImpl]
+    });
+  }
+  return (0, import_ffi_rs.unwrapPointer)(watchTrampoline)[0];
+}
+function ensureWatchCallbackRegistered(handle) {
+  if (watchInstances.has(handle)) return { ok: true, value: void 0 };
+  const trampoline = ensureWatchTrampoline();
+  const registered = callVoidResult(
+    "fff_set_watch_callback",
+    [import_ffi_rs.DataType.External, import_ffi_rs.DataType.External, import_ffi_rs.DataType.U64],
+    [handle, trampoline, 0]
+  );
+  if (registered.ok) watchInstances.add(handle);
+  return registered;
+}
+function releaseWatchTrampolineIfIdle() {
+  if (watchHandlers.size > 0 || watchInstances.size > 0 || watchTrampoline === null)
+    return;
+  (0, import_ffi_rs.freePointer)({
+    paramsType: [WATCH_TRAMPOLINE_TYPE],
+    paramsValue: watchTrampoline,
+    pointerType: import_ffi_rs.PointerType.RsPointer
+  });
+  watchTrampoline = null;
+}
+function ffiWatch(handle, pattern, ignore, callback) {
+  loadLibrary();
+  const registered = ensureWatchCallbackRegistered(handle);
+  if (!registered.ok) return registered;
+  const created = callIntResult(
+    "fff_watch_args",
+    [import_ffi_rs.DataType.External, import_ffi_rs.DataType.String, import_ffi_rs.DataType.StringArray, import_ffi_rs.DataType.U32],
+    [handle, pattern, ignore, ignore.length]
+  );
+  if (!created.ok) return created;
+  watchHandlers.set(created.value, callback);
+  return created;
+}
+function ffiUnwatch(handle, watchId) {
+  const result = callBoolResult(
+    "fff_unwatch",
+    [import_ffi_rs.DataType.External, import_ffi_rs.DataType.U64],
+    [handle, watchId]
+  );
+  watchHandlers.delete(watchId);
+  return result;
+}
+function ffiWatchCleanupAfterDestroy(handle, watchIds) {
+  for (const id of watchIds) {
+    watchHandlers.delete(id);
+  }
+  watchInstances.delete(handle);
+  releaseWatchTrampolineIfIdle();
+}
+function ffiHealthCheck(handle, testPath) {
+  if (handle === null) {
+    return callJsonResult(
+      "fff_health_check",
+      [import_ffi_rs.DataType.U64, import_ffi_rs.DataType.String],
+      [0, testPath]
+    );
+  }
+  return callJsonResult(
+    "fff_health_check",
+    [import_ffi_rs.DataType.External, import_ffi_rs.DataType.String],
+    [handle, testPath]
+  );
+}
+function ensureLoaded() {
+  loadLibrary();
+}
+function isAvailable() {
+  try {
+    loadLibrary();
+    return true;
+  } catch {
+    return false;
+  }
+}
+function closeLibrary() {
+  if (isLoaded) {
+    (0, import_ffi_rs.close)(LIBRARY_KEY);
+    isLoaded = false;
+  }
+}
+
+// src/finder.ts
+var FileFinder = class _FileFinder {
+  handle;
+  /** Native ids of this instance's active watch subscriptions. */
+  watchers = /* @__PURE__ */ new Set();
+  constructor(handle) {
+    this.handle = handle;
+  }
+  /**
+   * Create a new file finder instance.
+   *
+   * @param options - Initialization options
+   * @returns Result containing the new FileFinder instance or an error
+   *
+   * @example
+   * ```typescript
+   * // Basic initialization
+   * const finder = FileFinder.create({ basePath: "/path/to/project" });
+   *
+   * // With custom database paths
+   * const finder = FileFinder.create({
+   *   basePath: "/path/to/project",
+   *   frecencyDbPath: "/custom/frecency.mdb",
+   *   historyDbPath: "/custom/history.mdb",
+   * });
+   * ```
+   */
+  static create(options) {
+    const result = ffiCreate(
+      options.basePath,
+      options.frecencyDbPath ?? "",
+      options.historyDbPath ?? "",
+      options.useUnsafeNoLock ?? false,
+      !(options.disableMmapCache ?? false),
+      !(options.disableContentIndexing ?? options.disableMmapCache ?? false),
+      !(options.disableWatch ?? false),
+      options.aiMode ?? false,
+      options.logFilePath ?? "",
+      options.logLevel ?? "",
+      options.cacheBudgetMaxFiles ?? 0,
+      options.cacheBudgetMaxBytes ?? 0,
+      options.cacheBudgetMaxFileSize ?? 0,
+      options.enableFsRootScanning ?? false,
+      options.enableHomeDirScanning ?? false,
+      options.followSymlinks ?? false
+    );
+    if (!result.ok) {
+      return result;
+    }
+    return { ok: true, value: new _FileFinder(result.value) };
+  }
+  /**
+   * Destroy and clean up all resources.
+   *
+   * Call this when you're done using the file finder to free memory
+   * and stop background file watching. After calling this, the instance
+   * must not be used again.
+   */
+  destroy() {
+    if (this.handle !== null) {
+      const handle = this.handle;
+      ffiDestroy(handle);
+      this.handle = null;
+      ffiWatchCleanupAfterDestroy(handle, this.watchers);
+      this.watchers.clear();
+    }
+  }
+  /**
+   * Check if this instance has been destroyed.
+   */
+  get isDestroyed() {
+    return this.handle === null;
+  }
+  /**
+   * Guard that returns an error if the instance has been destroyed.
+   */
+  ensureAlive() {
+    if (this.handle === null) {
+      return err("FileFinder instance has been destroyed.");
+    }
+    return { ok: true, value: this.handle };
+  }
+  /**
+   * Search for files matching the query.
+   *
+   * The query supports fuzzy matching and special syntax:
+   * - `foo bar` - Match files containing "foo" and "bar"
+   * - `src/` - Match files in src directory
+   * - `file.ts:42` - Match file.ts with line 42
+   * - `file.ts:42:10` - Match file.ts with line 42, column 10
+   *
+   * @param query - Search query string
+   * @param options - Search options
+   * @returns Search results with matched files and scores
+   *
+   * @example
+   * ```typescript
+   * const result = finder.search("main.ts", { pageSize: 10 });
+   * if (result.ok) {
+   *   console.log(`Found ${result.value.totalMatched} files`);
+   *   for (const item of result.value.items) {
+   *     console.log(item.relativePath);
+   *   }
+   * }
+   * ```
+   */
+  fileSearch(query, options) {
+    const guard = this.ensureAlive();
+    if (!guard.ok) return guard;
+    return ffiSearch(
+      guard.value,
+      query,
+      options?.currentFile ?? "",
+      options?.maxThreads ?? 0,
+      options?.pageIndex ?? 0,
+      options?.pageSize ?? 0,
+      options?.comboBoostMultiplier ?? 0,
+      options?.minComboCount ?? 0
+    );
+  }
+  /**
+   * Filters files using glob wildcard expression.
+   *
+   * The pattern is applied as a single pass SIMD optimized prefiltering
+   * without any fuzzy matching involved. Faster and 100% compatible to npm `glob`.
+   *
+   * @param pattern - Glob pattern (required, non-empty)
+   * @param options - Glob search options (pagination, max threads, current file)
+   * @returns Search results with files matching the glob
+   *
+   * @example
+   * ```typescript
+   * const result = finder.glob("**\/*.rs", { pageSize: 100 });
+   * if (result.ok) {
+   *   for (const item of result.value.items) {
+   *     console.log(item.relativePath);
+   *   }
+   * }
+   * ```
+   */
+  glob(pattern, options) {
+    const guard = this.ensureAlive();
+    if (!guard.ok) return guard;
+    return ffiGlob(
+      guard.value,
+      pattern,
+      options?.currentFile ?? "",
+      options?.maxThreads ?? 0,
+      options?.pageIndex ?? 0,
+      options?.pageSize ?? 0
+    );
+  }
+  /**
+   * Search for directories matching the query.
+   *
+   * @param query - Search query string
+   * @param options - Directory search options
+   * @returns Search results with matched directories and scores
+   *
+   * @example
+   * ```typescript
+   * const result = finder.directorySearch("src/comp", { pageSize: 10 });
+   * if (result.ok) {
+   *   console.log(`Found ${result.value.totalMatched} directories`);
+   *   for (const item of result.value.items) {
+   *     console.log(item.relativePath);
+   *   }
+   * }
+   * ```
+   */
+  directorySearch(query, options) {
+    const guard = this.ensureAlive();
+    if (!guard.ok) return guard;
+    return ffiSearchDirectories(
+      guard.value,
+      query,
+      options?.currentFile ?? null,
+      options?.maxThreads ?? 0,
+      options?.pageIndex ?? 0,
+      options?.pageSize ?? 0
+    );
+  }
+  /**
+   * Search for files and directories matching the query (mixed results).
+   *
+   * Results are interleaved by total score in descending order, mixing
+   * both file and directory items.
+   *
+   * @param query - Search query string
+   * @param options - Search options
+   * @returns Mixed search results with files and directories interleaved by score
+   *
+   * @example
+   * ```typescript
+   * const result = finder.mixedSearch("main", { pageSize: 20 });
+   * if (result.ok) {
+   *   for (const entry of result.value.items) {
+   *     if (entry.type === "file") {
+   *       console.log(`File: ${entry.item.relativePath}`);
+   *     } else {
+   *       console.log(`Dir: ${entry.item.relativePath}`);
+   *     }
+   *   }
+   * }
+   * ```
+   */
+  mixedSearch(query, options) {
+    const guard = this.ensureAlive();
+    if (!guard.ok) return guard;
+    return ffiSearchMixed(
+      guard.value,
+      query,
+      options?.currentFile ?? "",
+      options?.maxThreads ?? 0,
+      options?.pageIndex ?? 0,
+      options?.pageSize ?? 0,
+      options?.comboBoostMultiplier ?? 0,
+      options?.minComboCount ?? 0
+    );
+  }
+  /**
+   * Search file contents (live grep).
+   *
+   * Searches through the contents of indexed files using the specified mode:
+   * - `"plain"` (default): SIMD-accelerated literal text matching
+   * - `"regex"`: Regular expression matching
+   * - `"fuzzy"`: Smith-Waterman fuzzy matching per line
+   *
+   * Supports pagination for large result sets. The result includes a `nextCursor`
+   * that can be passed back to fetch the next page.
+   *
+   * The query also supports constraint syntax:
+   * - `*.ts pattern` - Only search in TypeScript files
+   * - `src/ pattern` - Only search in the src directory
+   *
+   * @param query - Search query string
+   * @param options - Grep options (mode, pagination, limits)
+   * @returns Grep results with matched lines and file metadata
+   *
+   * @example
+   * ```typescript
+   * // First page
+   * const result = finder.grep("TODO", { mode: "plain" });
+   * if (result.ok) {
+   *   for (const match of result.value.items) {
+   *     console.log(`${match.relativePath}:${match.lineNumber}: ${match.lineContent}`);
+   *   }
+   *   // Fetch next page
+   *   if (result.value.nextCursor) {
+   *     const page2 = finder.grep("TODO", {
+   *       cursor: result.value.nextCursor,
+   *     });
+   *   }
+   * }
+   * ```
+   */
+  grep(query, options) {
+    const guard = this.ensureAlive();
+    if (!guard.ok) return guard;
+    return ffiLiveGrep(
+      guard.value,
+      query,
+      options?.mode ?? "plain",
+      options?.maxFileSize ?? 0,
+      options?.maxMatchesPerFile ?? 0,
+      options?.smartCase ?? true,
+      options?.cursor?._offset ?? 0,
+      options?.pageSize ?? 0,
+      options?.timeBudgetMs ?? 0,
+      options?.beforeContext ?? 0,
+      options?.afterContext ?? 0,
+      options?.classifyDefinitions ?? false
+    );
+  }
+  /**
+   * Multi-pattern OR search using Aho-Corasick.
+   *
+   * Searches for lines matching ANY of the provided patterns using
+   * SIMD-accelerated multi-needle matching. Faster than regex alternation
+   * for literal text searches.
+   *
+   * Supports pagination. The result includes a `nextCursor` that can be
+   * passed back to fetch the next page.
+   *
+   * @param options - Multi-grep options including patterns and optional constraints
+   * @returns Grep results with matched lines and file metadata
+   *
+   * @example
+   * ```typescript
+   * const result = finder.multiGrep({
+   *   patterns: ["VideoFrame", "video_frame", "PreloadedImage"],
+   * });
+   * if (result.ok) {
+   *   for (const match of result.value.items) {
+   *     console.log(`${match.relativePath}:${match.lineNumber}: ${match.lineContent}`);
+   *   }
+   * }
+   * ```
+   */
+  multiGrep(options) {
+    const guard = this.ensureAlive();
+    if (!guard.ok) return guard;
+    if (!options.patterns || options.patterns.length === 0) {
+      return err("patterns array must have at least 1 element");
+    }
+    return ffiMultiGrep(
+      guard.value,
+      options.patterns.join("\n"),
+      options.constraints ?? "",
+      options.maxFileSize ?? 0,
+      options.maxMatchesPerFile ?? 0,
+      options.smartCase ?? true,
+      options.cursor?._offset ?? 0,
+      options.pageSize ?? 0,
+      options.timeBudgetMs ?? 0,
+      options.beforeContext ?? 0,
+      options.afterContext ?? 0,
+      options.classifyDefinitions ?? false
+    );
+  }
+  /**
+   * Trigger a rescan of the indexed directory.
+   *
+   * This is useful after major file system changes that the
+   * background watcher might have missed.
+   */
+  scanFiles() {
+    const guard = this.ensureAlive();
+    if (!guard.ok) return guard;
+    return ffiScanFiles(guard.value);
+  }
+  /**
+   * Check if a scan is currently in progress.
+   */
+  isScanning() {
+    if (this.handle === null) return false;
+    return ffiIsScanning(this.handle);
+  }
+  /**
+   * Get the base path of the file picker (the root directory being indexed).
+   */
+  getBasePath() {
+    const guard = this.ensureAlive();
+    if (!guard.ok) return guard;
+    return ffiGetBasePath(guard.value);
+  }
+  /**
+   * Get the current scan progress.
+   */
+  getScanProgress() {
+    const guard = this.ensureAlive();
+    if (!guard.ok) return guard;
+    return ffiGetScanProgress(guard.value);
+  }
+  /**
+   * Wait for the initial file scan to complete.
+   * Non-blocking: polls `isScanning` and yields to the event loop between checks.
+   *
+   * @param timeoutMs - Maximum time to wait in milliseconds (default: 5000)
+   * @returns true if scan completed, false if timed out
+   *
+   * @example
+   * ```typescript
+   * const finder = FileFinder.create({ basePath: "/path/to/project" });
+   * if (finder.ok) {
+   *   const completed = await finder.value.waitForScan(10000);
+   *   if (!completed.ok || !completed.value) {
+   *     console.warn("Scan did not complete in time");
+   *   }
+   * }
+   * ```
+   */
+  async waitForScan(timeoutMs = 5e3) {
+    const guard = this.ensureAlive();
+    if (!guard.ok) return guard;
+    const deadline = Date.now() + timeoutMs;
+    while (this.isScanning()) {
+      if (Date.now() >= deadline) {
+        return { ok: true, value: false };
+      }
+      await new Promise((resolve) => setTimeout(resolve, 50));
+    }
+    return { ok: true, value: true };
+  }
+  /**
+   * Wait for the initial file scan to complete, blocking the calling thread.
+   *
+   * Backed by the native `fff_wait_for_scan` call. Prefer {@link waitForScan}
+   * unless you specifically need synchronous blocking behaviour.
+   *
+   * @param timeoutMs - Maximum time to wait in milliseconds (default: 5000)
+   * @returns true if scan completed, false if timed out
+   */
+  waitForScanBlocking(timeoutMs = 5e3) {
+    const guard = this.ensureAlive();
+    if (!guard.ok) return guard;
+    return ffiWaitForScan(guard.value, timeoutMs);
+  }
+  /**
+   * Wait until the index is fully ready: the scan has finished and the warmup
+   * (content indexing / bigram) phase has completed.
+   *
+   * Non-blocking: polls `getScanProgress` and yields to the event loop.
+   *
+   * @param timeoutMs - Maximum time to wait in milliseconds (default: 5000)
+   * @returns true if the index became ready, false if timed out
+   */
+  async waitForIndexReady(timeoutMs = 5e3) {
+    const guard = this.ensureAlive();
+    if (!guard.ok) return guard;
+    const deadline = Date.now() + timeoutMs;
+    while (true) {
+      const progress = this.getScanProgress();
+      if (!progress.ok) return progress;
+      if (!progress.value.isScanning && progress.value.isWarmupComplete) {
+        return { ok: true, value: true };
+      }
+      if (Date.now() >= deadline) {
+        return { ok: true, value: false };
+      }
+      await new Promise((resolve) => setTimeout(resolve, 50));
+    }
+  }
+  /**
+   * Change the indexed directory to a new path.
+   *
+   * This stops the current file watcher and starts indexing the new directory.
+   *
+   * @param newPath - New directory path to index
+   */
+  reindex(newPath) {
+    const guard = this.ensureAlive();
+    if (!guard.ok) return guard;
+    return ffiRestartIndex(guard.value, newPath);
+  }
+  /**
+   * Refresh the git status cache.
+   *
+   * @returns Number of files with updated git status
+   */
+  refreshGitStatus() {
+    const guard = this.ensureAlive();
+    if (!guard.ok) return guard;
+    return ffiRefreshGitStatus(guard.value);
+  }
+  /**
+   * Track query completion for smart suggestions.
+   *
+   * Call this when a user selects a file from search results.
+   * This helps improve future search rankings for similar queries.
+   *
+   * @param query - The search query that was used
+   * @param selectedFilePath - The file path that was selected
+   */
+  trackQuery(query, selectedFilePath) {
+    const guard = this.ensureAlive();
+    if (!guard.ok) return guard;
+    return ffiTrackQuery(guard.value, query, selectedFilePath);
+  }
+  /**
+   * Get a historical query by offset.
+   *
+   * @param offset - Offset from most recent (0 = most recent)
+   * @returns The historical query string, or null if not found
+   */
+  getHistoricalQuery(offset) {
+    const guard = this.ensureAlive();
+    if (!guard.ok) return guard;
+    return ffiGetHistoricalQuery(guard.value, offset);
+  }
+  watch(patternOrCallback, callbackOrOptions, maybeOptions) {
+    const noPattern = typeof patternOrCallback === "function";
+    const pattern = noPattern ? "" : patternOrCallback;
+    const callback = noPattern ? patternOrCallback : callbackOrOptions;
+    const options = noPattern ? callbackOrOptions : maybeOptions;
+    if (typeof callback !== "function") {
+      return err("watch callback must be a function");
+    }
+    const guard = this.ensureAlive();
+    if (!guard.ok) return guard;
+    const created = ffiWatch(guard.value, pattern, options?.ignore ?? [], callback);
+    if (!created.ok) return created;
+    const watchId = created.value;
+    this.watchers.add(watchId);
+    return {
+      ok: true,
+      value: () => {
+        if (!this.watchers.delete(watchId)) return;
+        if (this.handle !== null) ffiUnwatch(this.handle, watchId);
+      }
+    };
+  }
+  /**
+   * Get health check information.
+   *
+   * Useful for debugging and verifying the file finder is working correctly.
+   *
+   * @param testPath - Optional path to test git repository detection
+   */
+  healthCheck(testPath) {
+    return ffiHealthCheck(this.handle, testPath || "");
+  }
+  /**
+   * Check if the native library is available.
+   */
+  static isAvailable() {
+    return isAvailable();
+  }
+  /**
+   * Ensure the native library is loaded.
+   *
+   * Loads the native library from the platform-specific npm package
+   * or a local dev build. Throws if the binary is not found.
+   */
+  static ensureLoaded() {
+    ensureLoaded();
+  }
+  /**
+   * Get a health check without requiring an instance.
+   *
+   * Returns limited info (version + git only, no picker/frecency/query data).
+   *
+   * @param testPath - Optional path to test git repository detection
+   */
+  static healthCheckStatic(testPath) {
+    return ffiHealthCheck(null, testPath || "");
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FileFinder,
+  binaryExists,
+  closeLibrary,
+  err,
+  findBinary,
+  getLibExtension,
+  getLibFilename,
+  getNpmPackageName,
+  getTriple,
+  ok
+});
+//# sourceMappingURL=index.cjs.map